From bb4ad9ed6bf3b7faf2ff01ded8eec9ff6ebb38d6 Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Fri, 30 Dec 2022 14:48:58 +0800
Subject: [PATCH 01/79] improve count if rewrite

---
 .../RewriteSumIfFunctionVisitor.cpp           | 50 +++++++++++++++----
 .../RewriteSumIfFunctionVisitor.h             |  3 ++
 2 files changed, 42 insertions(+), 11 deletions(-)

diff --git a/src/Interpreters/RewriteSumIfFunctionVisitor.cpp b/src/Interpreters/RewriteSumIfFunctionVisitor.cpp
index 50e6bec28f3..88f77606414 100644
--- a/src/Interpreters/RewriteSumIfFunctionVisitor.cpp
+++ b/src/Interpreters/RewriteSumIfFunctionVisitor.cpp
@@ -33,18 +33,25 @@ void RewriteSumIfFunctionMatcher::visit(const ASTFunction & func, ASTPtr & ast,
 
     if (lower_name == "sumif")
     {
-        /// sumIf(1, cond) -> countIf(cond)
         const auto * literal = func_arguments[0]->as<ASTLiteral>();
         if (!literal || !DB::isInt64OrUInt64FieldType(literal->value.getType()))
             return;
 
+        std::shared_ptr<ASTFunction> new_func;
         if (func_arguments.size() == 2 && literal->value.get<UInt64>() == 1)
         {
-            auto new_func = makeASTFunction("countIf", func_arguments[1]);
-            new_func->setAlias(func.alias);
-            ast = std::move(new_func);
-            return;
+            /// sumIf(1, cond) -> countIf(cond)
+            new_func = makeASTFunction("countIf", func_arguments[1]);
         }
+        else
+        {
+            /// sumIf(123, cond) -> 123 * countIf(cond)
+            auto count_if_func = makeASTFunction("countIf", func_arguments[1]);
+            new_func = makeASTFunction("multiply", func_arguments[0], std::move(count_if_func));
+        }
+        new_func->setAlias(func.alias);
+        ast = std::move(new_func);
+        return;
     }
     else
     {
@@ -65,19 +72,40 @@ void RewriteSumIfFunctionMatcher::visit(const ASTFunction & func, ASTPtr & ast,
 
             auto first_value = first_literal->value.get<UInt64>();
             auto second_value = second_literal->value.get<UInt64>();
-            /// sum(if(cond, 1, 0)) -> countIf(cond)
-            if (first_value == 1 && second_value == 0)
+
+            std::shared_ptr<ASTFunction> new_func;
+            if (second_value == 0)
             {
-                auto new_func = makeASTFunction("countIf", if_arguments[0]);
+                if (first_value == 1)
+                {
+                    /// sum(if(cond, 1, 0)) -> countIf(cond)
+                    new_func = makeASTFunction("countIf", if_arguments[0]);
+                }
+                else
+                {
+                    /// sum(if(cond, 123, 0)) -> 123 * countIf(cond)
+                    auto count_if_func = makeASTFunction("countIf", if_arguments[0]);
+                    new_func = makeASTFunction("multiply", if_arguments[1], std::move(count_if_func));
+                }
                 new_func->setAlias(func.alias);
                 ast = std::move(new_func);
                 return;
             }
-            /// sum(if(cond, 0, 1)) -> countIf(not(cond))
-            if (first_value == 0 && second_value == 1)
+
+            if (first_value == 0)
             {
                 auto not_func = makeASTFunction("not", if_arguments[0]);
-                auto new_func = makeASTFunction("countIf", not_func);
+                if (second_value == 1)
+                {
+                    /// sum(if(cond, 0, 1)) -> countIf(not(cond))
+                    new_func = makeASTFunction("countIf", std::move(not_func));
+                }
+                else
+                {
+                    /// sum(if(cond, 0, 123)) -> 123 * countIf(not(cond))
+                    auto count_if_func = makeASTFunction("countIf", std::move(not_func));
+                    new_func = makeASTFunction("multiply", if_arguments[2], std::move(count_if_func));
+                }
                 new_func->setAlias(func.alias);
                 ast = std::move(new_func);
                 return;
diff --git a/src/Interpreters/RewriteSumIfFunctionVisitor.h b/src/Interpreters/RewriteSumIfFunctionVisitor.h
index 86aeef65377..b3280e0c7c6 100644
--- a/src/Interpreters/RewriteSumIfFunctionVisitor.h
+++ b/src/Interpreters/RewriteSumIfFunctionVisitor.h
@@ -12,8 +12,11 @@ class ASTFunction;
 
 /// Rewrite 'sum(if())' and 'sumIf' functions to counIf.
 /// sumIf(1, cond) -> countIf(1, cond)
+/// sumIf(123, cond) -> 123 * countIf(1, cond)
 /// sum(if(cond, 1, 0)) -> countIf(cond)
+/// sum(if(cond, 123, 0)) -> 123 * countIf(cond)
 /// sum(if(cond, 0, 1)) -> countIf(not(cond))
+/// sum(if(cond, 0, 123)) -> 123 * countIf(not(cond))
 class RewriteSumIfFunctionMatcher
 {
 public:

From c3531455fcc2d76220743465643f258b5b02d44b Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Fri, 30 Dec 2022 15:43:54 +0800
Subject: [PATCH 02/79] commit again

---
 .../0_stateless/01646_rewrite_sum_if.reference       | 12 ++++++++++++
 tests/queries/0_stateless/01646_rewrite_sum_if.sql   |  8 ++++++++
 2 files changed, 20 insertions(+)

diff --git a/tests/queries/0_stateless/01646_rewrite_sum_if.reference b/tests/queries/0_stateless/01646_rewrite_sum_if.reference
index 0f315b0812a..0e37c91578a 100644
--- a/tests/queries/0_stateless/01646_rewrite_sum_if.reference
+++ b/tests/queries/0_stateless/01646_rewrite_sum_if.reference
@@ -10,6 +10,12 @@
 50
 50	50	50	1	0
 50
+SELECT sumIf(123, (number % 2) = 0)
+FROM numbers(100)
+SELECT sum(if((number % 2) = 0, 123, 0))
+FROM numbers(100)
+SELECT sum(if((number % 2) = 0, 0, 123))
+FROM numbers(100)
 0
 0	0	1
 0
@@ -22,3 +28,9 @@
 50
 50	50	50	1	0
 50
+SELECT 123 * countIf((number % 2) = 0)
+FROM numbers(100)
+SELECT 123 * countIf((number % 2) = 0)
+FROM numbers(100)
+SELECT 123 * countIf(NOT ((number % 2) = 0))
+FROM numbers(100)
diff --git a/tests/queries/0_stateless/01646_rewrite_sum_if.sql b/tests/queries/0_stateless/01646_rewrite_sum_if.sql
index 07fb90c0eb7..9abe7f35005 100644
--- a/tests/queries/0_stateless/01646_rewrite_sum_if.sql
+++ b/tests/queries/0_stateless/01646_rewrite_sum_if.sql
@@ -16,6 +16,10 @@ SELECT sum(if(number % 2 == 0, 0, 1)) FROM numbers(100);
 SELECT sum(if(number % 2 == 0 as cond_expr, 0 as zero_expr, 1 as one_expr) as if_expr), sum(cond_expr), sum(if_expr), one_expr, zero_expr FROM numbers(100);
 SELECT countIf(number % 2 != 0) FROM numbers(100);
 
+EXPLAIN SYNTAX SELECT sumIf(123, number % 2 == 0) FROM numbers(100);
+EXPLAIN SYNTAX SELECT sum(if(number % 2 == 0, 123, 0)) FROM numbers(100);
+EXPLAIN SYNTAX SELECT sum(if(number % 2 == 0, 0, 123)) FROM numbers(100);
+
 SET optimize_rewrite_sum_if_to_count_if = 1;
 
 SELECT sumIf(1, number % 2 > 2) FROM numbers(100);
@@ -33,3 +37,7 @@ SELECT countIf(number % 2 == 0) FROM numbers(100);
 SELECT sum(if(number % 2 == 0, 0, 1)) FROM numbers(100);
 SELECT sum(if(number % 2 == 0 as cond_expr, 0 as zero_expr, 1 as one_expr) as if_expr), sum(cond_expr), sum(if_expr), one_expr, zero_expr FROM numbers(100);
 SELECT countIf(number % 2 != 0) FROM numbers(100);
+
+EXPLAIN SYNTAX SELECT sumIf(123, number % 2 == 0) FROM numbers(100);
+EXPLAIN SYNTAX SELECT sum(if(number % 2 == 0, 123, 0)) FROM numbers(100);
+EXPLAIN SYNTAX SELECT sum(if(number % 2 == 0, 0, 123)) FROM numbers(100);

From ba0edb310f297aeb02b4c56f30d80aabd2fdd0a0 Mon Sep 17 00:00:00 2001
From: Meena Renganathan <Meena.Renganathan@ibm.com>
Date: Thu, 5 Jan 2023 12:16:26 -0500
Subject: [PATCH 03/79] Changes to support the HDFS in PowerPC

---
 contrib/libhdfs3-cmake/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/libhdfs3-cmake/CMakeLists.txt b/contrib/libhdfs3-cmake/CMakeLists.txt
index 15d7a4df424..0a142908735 100644
--- a/contrib/libhdfs3-cmake/CMakeLists.txt
+++ b/contrib/libhdfs3-cmake/CMakeLists.txt
@@ -1,4 +1,4 @@
-if(NOT ARCH_AARCH64 AND NOT OS_FREEBSD AND NOT APPLE AND NOT ARCH_PPC64LE)
+if(NOT ARCH_AARCH64 AND NOT OS_FREEBSD AND NOT APPLE)
     option(ENABLE_HDFS "Enable HDFS" ${ENABLE_LIBRARIES})
 elseif(ENABLE_HDFS)
     message (${RECONFIGURE_MESSAGE_LEVEL} "Cannot use HDFS3 with current configuration")

From 06e44827a37fe0cd791e27389a5e46900de58e07 Mon Sep 17 00:00:00 2001
From: Meena Renganathan <Meena.Renganathan@ibm.com>
Date: Thu, 5 Jan 2023 14:18:05 -0500
Subject: [PATCH 04/79] Added the file DataReader.cpp in source list when the
 HDFS submodule has been updated to the latest commit

---
 contrib/libhdfs3-cmake/CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/contrib/libhdfs3-cmake/CMakeLists.txt b/contrib/libhdfs3-cmake/CMakeLists.txt
index 0a142908735..bd48772dd33 100644
--- a/contrib/libhdfs3-cmake/CMakeLists.txt
+++ b/contrib/libhdfs3-cmake/CMakeLists.txt
@@ -47,6 +47,7 @@ set(SRCS
     "${HDFS3_SOURCE_DIR}/network/TcpSocket.cpp"
     "${HDFS3_SOURCE_DIR}/network/DomainSocket.cpp"
     "${HDFS3_SOURCE_DIR}/network/BufferedSocketReader.cpp"
+    "${HDFS3_SOURCE_DIR}/client/DataReader.cpp"
     "${HDFS3_SOURCE_DIR}/client/ReadShortCircuitInfo.cpp"
     "${HDFS3_SOURCE_DIR}/client/Pipeline.cpp"
     "${HDFS3_SOURCE_DIR}/client/Hdfs.cpp"

From 082e25b88e047b6d1c38527dbff35e21049f527c Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Thu, 12 Jan 2023 17:39:50 +0800
Subject: [PATCH 05/79] fix failed tests

---
 .../RewriteSumIfFunctionVisitor.cpp           | 29 ++++++++++---------
 1 file changed, 16 insertions(+), 13 deletions(-)

diff --git a/src/Interpreters/RewriteSumIfFunctionVisitor.cpp b/src/Interpreters/RewriteSumIfFunctionVisitor.cpp
index 88f77606414..c598fc1a6b7 100644
--- a/src/Interpreters/RewriteSumIfFunctionVisitor.cpp
+++ b/src/Interpreters/RewriteSumIfFunctionVisitor.cpp
@@ -37,21 +37,24 @@ void RewriteSumIfFunctionMatcher::visit(const ASTFunction & func, ASTPtr & ast,
         if (!literal || !DB::isInt64OrUInt64FieldType(literal->value.getType()))
             return;
 
-        std::shared_ptr<ASTFunction> new_func;
-        if (func_arguments.size() == 2 && literal->value.get<UInt64>() == 1)
+        if (func_arguments.size() == 2)
         {
-            /// sumIf(1, cond) -> countIf(cond)
-            new_func = makeASTFunction("countIf", func_arguments[1]);
+            std::shared_ptr<ASTFunction> new_func;
+            if (literal->value.get<UInt64>() == 1)
+            {
+                /// sumIf(1, cond) -> countIf(cond)
+                new_func = makeASTFunction("countIf", func_arguments[1]);
+            }
+            else
+            {
+                /// sumIf(123, cond) -> 123 * countIf(cond)
+                auto count_if_func = makeASTFunction("countIf", func_arguments[1]);
+                new_func = makeASTFunction("multiply", func_arguments[0], std::move(count_if_func));
+            }
+            new_func->setAlias(func.alias);
+            ast = std::move(new_func);
+            return;
         }
-        else
-        {
-            /// sumIf(123, cond) -> 123 * countIf(cond)
-            auto count_if_func = makeASTFunction("countIf", func_arguments[1]);
-            new_func = makeASTFunction("multiply", func_arguments[0], std::move(count_if_func));
-        }
-        new_func->setAlias(func.alias);
-        ast = std::move(new_func);
-        return;
     }
     else
     {

From 4448bfe8a78bda2838aac6c9b914b1a7691e65e1 Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Mon, 16 Jan 2023 15:08:12 +0800
Subject: [PATCH 06/79] try to improve performance of function multiif

---
 src/Core/Settings.h       |   2 +
 src/Functions/multiIf.cpp | 105 +++++++++++++++++++++++++++++++-------
 2 files changed, 89 insertions(+), 18 deletions(-)

diff --git a/src/Core/Settings.h b/src/Core/Settings.h
index b8d46244b6c..6f101164672 100644
--- a/src/Core/Settings.h
+++ b/src/Core/Settings.h
@@ -454,6 +454,8 @@ static constexpr UInt64 operator""_GiB(unsigned long long value)
     M(Bool, allow_simdjson, true, "Allow using simdjson library in 'JSON*' functions if AVX2 instructions are available. If disabled rapidjson will be used.", 0) \
     M(Bool, allow_introspection_functions, false, "Allow functions for introspection of ELF and DWARF for query profiling. These functions are slow and may impose security considerations.", 0) \
     \
+    M(Bool, allow_execute_multiif_columnar, true, "Allow execute multiIf function columnar", 0) \
+    \
     M(UInt64, max_partitions_per_insert_block, 100, "Limit maximum number of partitions in single INSERTed block. Zero means unlimited. Throw exception if the block contains too many partitions. This setting is a safety threshold, because using large number of partitions is a common misconception.", 0) \
     M(Int64, max_partitions_to_read, -1, "Limit the max number of partitions that can be accessed in one query. <= 0 means unlimited.", 0) \
     M(Bool, check_query_single_value_result, true, "Return check query result as single 1/0 value", 0) \
diff --git a/src/Functions/multiIf.cpp b/src/Functions/multiIf.cpp
index 37301037c0e..feb8abb1185 100644
--- a/src/Functions/multiIf.cpp
+++ b/src/Functions/multiIf.cpp
@@ -7,6 +7,7 @@
 #include <Interpreters/castColumn.h>
 #include <Common/assert_cast.h>
 #include <Common/typeid_cast.h>
+#include <Interpreters/Context.h>
 #include <DataTypes/DataTypeNullable.h>
 #include <DataTypes/getLeastSupertype.h>
 
@@ -36,7 +37,9 @@ class FunctionMultiIf final : public FunctionIfBase
 {
 public:
     static constexpr auto name = "multiIf";
-    static FunctionPtr create(ContextPtr) { return std::make_shared<FunctionMultiIf>(); }
+    static FunctionPtr create(ContextPtr context_) { return std::make_shared<FunctionMultiIf>(context_); }
+
+    explicit FunctionMultiIf(ContextPtr context_) : context(context_) { }
 
     String getName() const override { return name; }
     bool isVariadic() const override { return true; }
@@ -117,6 +120,21 @@ public:
         return getLeastSupertype(types_of_branches);
     }
 
+    struct Instruction
+    {
+        IColumn::Ptr condition = nullptr;
+        IColumn::Ptr source = nullptr;
+
+        bool condition_always_true = false;
+        bool condition_is_nullable = false;
+        bool source_is_constant = false;
+
+        bool condition_is_short = false;
+        bool source_is_short = false;
+        size_t condition_index = 0;
+        size_t source_index = 0;
+    };
+
     ColumnPtr executeImpl(const ColumnsWithTypeAndName & args, const DataTypePtr & result_type, size_t input_rows_count) const override
     {
         ColumnsWithTypeAndName arguments = args;
@@ -124,26 +142,13 @@ public:
         /** We will gather values from columns in branches to result column,
         *  depending on values of conditions.
         */
-        struct Instruction
-        {
-            IColumn::Ptr condition = nullptr;
-            IColumn::Ptr source = nullptr;
 
-            bool condition_always_true = false;
-            bool condition_is_nullable = false;
-            bool source_is_constant = false;
-
-            bool condition_is_short = false;
-            bool source_is_short = false;
-            size_t condition_index = 0;
-            size_t source_index = 0;
-        };
 
         std::vector<Instruction> instructions;
         instructions.reserve(arguments.size() / 2 + 1);
 
         Columns converted_columns_holder;
-        converted_columns_holder.reserve(instructions.size());
+        converted_columns_holder.reserve(instructions.capacity());
 
         const DataTypePtr & return_type = result_type;
 
@@ -225,6 +230,25 @@ public:
 
         size_t rows = input_rows_count;
 
+        /*
+            executeInstructionsColumnar<UInt8>(instructions, rows, res) || executeInstructionsColumnar<Int8>(instructions, rows, res) ||
+            executeInstructionsColumnar<UInt16>(instructions, rows, res) || executeInstructionsColumnar<Int16>(instructions, rows, res) ||
+            executeInstructionsColumnar<UInt32>(instructions, rows, res) || executeInstructionsColumnar<Int32>(instructions, rows, res) ||
+            executeInstructionsColumnar<UInt64>(instructions, rows, res) || executeInstructionsColumnar<Int64>(instructions, rows, res) ||
+            executeInstructionsColumnar<Int128>(instructions, rows, res) || executeInstructionsColumnar<Int256>(instructions, rows, res) ||
+            executeInstructionsColumnar<Int128>(instructions, rows, res) || executeInstructionsColumnar<Int256>(instructions, rows, res) ||
+        */
+        const auto & settings = context->getSettingsRef();
+        if (settings.allow_execute_multiif_columnar)
+            executeInstructionsColumnar(instructions, rows, res);
+        else
+            executeInstructions(instructions, rows, res);
+        return res;
+    }
+
+private:
+    static void executeInstructions(std::vector<Instruction> & instructions, size_t rows, const MutableColumnPtr & res)
+    {
         for (size_t i = 0; i < rows; ++i)
         {
             for (auto & instruction : instructions)
@@ -257,11 +281,54 @@ public:
                 }
             }
         }
-
-        return res;
     }
 
-private:
+    // template <typename T>
+    static void executeInstructionsColumnar(std::vector<Instruction> & instructions, size_t rows, const MutableColumnPtr & res)
+    {
+        /// We should read source from which instruction on each row?
+        PaddedPODArray<UInt64> inserts(rows, instructions.size());
+        // PaddedPODArray<T> & res_data = assert_cast<ColumnVector<T> &>(*res).getData();
+        for (Int64 i = instructions.size() - 1; i >= 0; --i)
+        {
+            auto & instruction = instructions[i];
+            if (instruction.condition_always_true)
+            {
+                for (size_t row_i = 0; row_i < rows; ++row_i)
+                    inserts[row_i] = i;
+            }
+            else if (!instruction.condition_is_nullable)
+            {
+                const auto & cond_data = assert_cast<const ColumnUInt8 &>(*instruction.condition).getData();
+                for (size_t row_i = 0; row_i < rows; ++row_i)
+                {
+                    size_t condition_index = instruction.condition_is_short ? instruction.condition_index++ : row_i;
+                    if (cond_data[condition_index])
+                        inserts[row_i] = i;
+                }
+            }
+            else
+            {
+                const ColumnNullable & condition_nullable = assert_cast<const ColumnNullable &>(*instruction.condition);
+                const ColumnUInt8 & condition_nested = assert_cast<const ColumnUInt8 &>(condition_nullable.getNestedColumn());
+                const NullMap & condition_null_map = condition_nullable.getNullMapData();
+
+                for (size_t row_i = 0; row_i < rows; ++row_i)
+                {
+                    size_t condition_index = instruction.condition_is_short ? instruction.condition_index++ : row_i;
+                    if (!condition_null_map[condition_index] && condition_nested.getData()[condition_index])
+                        inserts[row_i] = i;
+                }
+            }
+        }
+
+        for (size_t row_i = 0; row_i < rows; ++row_i)
+        {
+            auto & instruction = instructions[inserts[row_i]];
+            (*res)[row_i] = (*instruction.source)[row_i];
+        }
+    }
+
     static void executeShortCircuitArguments(ColumnsWithTypeAndName & arguments)
     {
         int last_short_circuit_argument_index = checkShortCircuitArguments(arguments);
@@ -330,6 +397,8 @@ private:
         for (; i <= last_short_circuit_argument_index; ++i)
             executeColumnIfNeeded(arguments[i], true);
     }
+
+    ContextPtr context;
 };
 
 }

From 5b3f9eb62e1133560a0040cb6b562e846c2017c3 Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Mon, 16 Jan 2023 20:35:26 +0800
Subject: [PATCH 07/79] vectorize function calculateInserts

---
 src/Functions/multiIf.cpp | 85 ++++++++++++++++++++++++++++-----------
 1 file changed, 61 insertions(+), 24 deletions(-)

diff --git a/src/Functions/multiIf.cpp b/src/Functions/multiIf.cpp
index feb8abb1185..8d3e10b480a 100644
--- a/src/Functions/multiIf.cpp
+++ b/src/Functions/multiIf.cpp
@@ -18,6 +18,7 @@ namespace ErrorCodes
 {
     extern const int ILLEGAL_TYPE_OF_ARGUMENT;
     extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
+    extern const int LOGICAL_ERROR;
 }
 
 namespace
@@ -217,37 +218,60 @@ public:
                 break;
         }
 
-        MutableColumnPtr res = return_type->createColumn();
 
         /// Special case if first instruction condition is always true and source is constant
         if (instructions.size() == 1 && instructions.front().source_is_constant
             && instructions.front().condition_always_true)
         {
+            MutableColumnPtr res = return_type->createColumn();
             auto & instruction = instructions.front();
             res->insertFrom(assert_cast<const ColumnConst &>(*instruction.source).getDataColumn(), 0);
             return ColumnConst::create(std::move(res), instruction.source->size());
         }
 
         size_t rows = input_rows_count;
-
-        /*
-            executeInstructionsColumnar<UInt8>(instructions, rows, res) || executeInstructionsColumnar<Int8>(instructions, rows, res) ||
-            executeInstructionsColumnar<UInt16>(instructions, rows, res) || executeInstructionsColumnar<Int16>(instructions, rows, res) ||
-            executeInstructionsColumnar<UInt32>(instructions, rows, res) || executeInstructionsColumnar<Int32>(instructions, rows, res) ||
-            executeInstructionsColumnar<UInt64>(instructions, rows, res) || executeInstructionsColumnar<Int64>(instructions, rows, res) ||
-            executeInstructionsColumnar<Int128>(instructions, rows, res) || executeInstructionsColumnar<Int256>(instructions, rows, res) ||
-            executeInstructionsColumnar<Int128>(instructions, rows, res) || executeInstructionsColumnar<Int256>(instructions, rows, res) ||
-        */
         const auto & settings = context->getSettingsRef();
-        if (settings.allow_execute_multiif_columnar)
-            executeInstructionsColumnar(instructions, rows, res);
+        const WhichDataType which(result_type);
+        if (settings.allow_execute_multiif_columnar && (which.isInt() || which.isUInt() || which.isFloat()))
+        {
+#define EXECUTE_INSTRUCTIONS_COLUMNAR(TYPE) \
+    if (which.is##TYPE()) \
+    { \
+        MutableColumnPtr res = ColumnVector<TYPE>::create(rows); \
+        executeInstructionsColumnar<TYPE>(instructions, rows, res); \
+        return std::move(res); \
+    }
+
+#define ENUMERATE_NUMERIC_TYPES(M) \
+    M(UInt8) \
+    M(UInt16) \
+    M(UInt32) \
+    M(UInt64) \
+    M(Int8) \
+    M(Int16) \
+    M(Int32) \
+    M(Int64) \
+    M(UInt128) \
+    M(UInt256) \
+    M(Int128) \
+    M(Int256) \
+    M(Float32) \
+    M(Float64)
+
+            ENUMERATE_NUMERIC_TYPES(EXECUTE_INSTRUCTIONS_COLUMNAR)
+        }
         else
+        {
+            MutableColumnPtr res = return_type->createColumn();
             executeInstructions(instructions, rows, res);
-        return res;
+            return std::move(res);
+        }
+
+        return {};
     }
 
 private:
-    static void executeInstructions(std::vector<Instruction> & instructions, size_t rows, const MutableColumnPtr & res)
+    static NO_INLINE void executeInstructions(std::vector<Instruction> & instructions, size_t rows, const MutableColumnPtr & res)
     {
         for (size_t i = 0; i < rows; ++i)
         {
@@ -283,12 +307,9 @@ private:
         }
     }
 
-    // template <typename T>
-    static void executeInstructionsColumnar(std::vector<Instruction> & instructions, size_t rows, const MutableColumnPtr & res)
+    /// We should read source from which instruction on each row?
+    static NO_INLINE void calculateInserts(std::vector<Instruction> & instructions, size_t rows, PaddedPODArray<Int64> & inserts)
     {
-        /// We should read source from which instruction on each row?
-        PaddedPODArray<UInt64> inserts(rows, instructions.size());
-        // PaddedPODArray<T> & res_data = assert_cast<ColumnVector<T> &>(*res).getData();
         for (Int64 i = instructions.size() - 1; i >= 0; --i)
         {
             auto & instruction = instructions[i];
@@ -303,29 +324,45 @@ private:
                 for (size_t row_i = 0; row_i < rows; ++row_i)
                 {
                     size_t condition_index = instruction.condition_is_short ? instruction.condition_index++ : row_i;
-                    if (cond_data[condition_index])
-                        inserts[row_i] = i;
+
+                    /// Equivalent to below code. But it is able to utilize SIMD instructions.
+                    /// if (cond_data[condition_index])
+                    ///     inserts[row_i] = i;
+                    inserts[row_i] += cond_data[condition_index] * (i - inserts[row_i]);
                 }
             }
             else
             {
                 const ColumnNullable & condition_nullable = assert_cast<const ColumnNullable &>(*instruction.condition);
                 const ColumnUInt8 & condition_nested = assert_cast<const ColumnUInt8 &>(condition_nullable.getNestedColumn());
+                const auto & condition_nested_data = condition_nested.getData();
                 const NullMap & condition_null_map = condition_nullable.getNullMapData();
 
                 for (size_t row_i = 0; row_i < rows; ++row_i)
                 {
                     size_t condition_index = instruction.condition_is_short ? instruction.condition_index++ : row_i;
-                    if (!condition_null_map[condition_index] && condition_nested.getData()[condition_index])
-                        inserts[row_i] = i;
+                    /// Equivalent to below code. But it is able to utilize SIMD instructions.
+                    /// if (!condition_null_map[condition_index] && condition_nested.getData()[condition_index])
+                    ///     inserts[row_i] = i;
+                    inserts[row_i] += (~condition_null_map[condition_index] & condition_nested_data[condition_index])
+                        * (i - inserts[row_i]);
                 }
             }
         }
+    }
 
+    template <typename T>
+    static NO_INLINE void executeInstructionsColumnar(std::vector<Instruction> & instructions, size_t rows, const MutableColumnPtr & res)
+    {
+        PaddedPODArray<Int64> inserts(rows, -1);
+        calculateInserts(instructions, rows, inserts);
+
+        PaddedPODArray<T> & res_data = assert_cast<ColumnVector<T> &>(*res).getData();
         for (size_t row_i = 0; row_i < rows; ++row_i)
         {
             auto & instruction = instructions[inserts[row_i]];
-            (*res)[row_i] = (*instruction.source)[row_i];
+            auto str_ref = instruction.source->getDataAt(row_i);
+            memcpy(&res_data[row_i], str_ref.data, str_ref.size);
         }
     }
 

From 87f869a12924d10fc1bd2022cd5b924d89305998 Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Mon, 16 Jan 2023 21:02:33 +0800
Subject: [PATCH 08/79] reorder branches

---
 src/Functions/multiIf.cpp | 34 ++++++++++++++++------------------
 1 file changed, 16 insertions(+), 18 deletions(-)

diff --git a/src/Functions/multiIf.cpp b/src/Functions/multiIf.cpp
index 8d3e10b480a..d3b15a2c200 100644
--- a/src/Functions/multiIf.cpp
+++ b/src/Functions/multiIf.cpp
@@ -18,7 +18,7 @@ namespace ErrorCodes
 {
     extern const int ILLEGAL_TYPE_OF_ARGUMENT;
     extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
-    extern const int LOGICAL_ERROR;
+    extern const int NOT_IMPLEMENTED;
 }
 
 namespace
@@ -232,8 +232,14 @@ public:
         size_t rows = input_rows_count;
         const auto & settings = context->getSettingsRef();
         const WhichDataType which(result_type);
-        if (settings.allow_execute_multiif_columnar && (which.isInt() || which.isUInt() || which.isFloat()))
+        bool execute_multiif_columnar = settings.allow_execute_multiif_columnar && (which.isInt() || which.isUInt() || which.isFloat());
+        if (!execute_multiif_columnar)
         {
+            MutableColumnPtr res = return_type->createColumn();
+            executeInstructions(instructions, rows, res);
+            return std::move(res);
+        }
+
 #define EXECUTE_INSTRUCTIONS_COLUMNAR(TYPE) \
     if (which.is##TYPE()) \
     { \
@@ -258,20 +264,12 @@ public:
     M(Float32) \
     M(Float64)
 
-            ENUMERATE_NUMERIC_TYPES(EXECUTE_INSTRUCTIONS_COLUMNAR)
-        }
-        else
-        {
-            MutableColumnPtr res = return_type->createColumn();
-            executeInstructions(instructions, rows, res);
-            return std::move(res);
-        }
-
-        return {};
-    }
+    ENUMERATE_NUMERIC_TYPES(EXECUTE_INSTRUCTIONS_COLUMNAR)
+    throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Columnar multiIf not implemented for type {}", result_type->getName());
+}
 
 private:
-    static NO_INLINE void executeInstructions(std::vector<Instruction> & instructions, size_t rows, const MutableColumnPtr & res)
+    static void executeInstructions(std::vector<Instruction> & instructions, size_t rows, const MutableColumnPtr & res)
     {
         for (size_t i = 0; i < rows; ++i)
         {
@@ -308,7 +306,7 @@ private:
     }
 
     /// We should read source from which instruction on each row?
-    static NO_INLINE void calculateInserts(std::vector<Instruction> & instructions, size_t rows, PaddedPODArray<Int64> & inserts)
+    static void calculateInserts(std::vector<Instruction> & instructions, size_t rows, PaddedPODArray<Int64> & inserts)
     {
         for (Int64 i = instructions.size() - 1; i >= 0; --i)
         {
@@ -352,7 +350,7 @@ private:
     }
 
     template <typename T>
-    static NO_INLINE void executeInstructionsColumnar(std::vector<Instruction> & instructions, size_t rows, const MutableColumnPtr & res)
+    static void executeInstructionsColumnar(std::vector<Instruction> & instructions, size_t rows, const MutableColumnPtr & res)
     {
         PaddedPODArray<Int64> inserts(rows, -1);
         calculateInserts(instructions, rows, inserts);
@@ -361,8 +359,8 @@ private:
         for (size_t row_i = 0; row_i < rows; ++row_i)
         {
             auto & instruction = instructions[inserts[row_i]];
-            auto str_ref = instruction.source->getDataAt(row_i);
-            memcpy(&res_data[row_i], str_ref.data, str_ref.size);
+            auto ref = instruction.source->getDataAt(row_i);
+            memcpy(&res_data[row_i], ref.data, ref.size);
         }
     }
 

From 9f571d3e930150497cad368df5e14ffcc0381a48 Mon Sep 17 00:00:00 2001
From: MeenaRenganathan22 <Meena.Renganathan@ibm.com>
Date: Mon, 16 Jan 2023 08:28:03 -0500
Subject: [PATCH 09/79] Updating the submodules libhdfs3 and libgsasl

---
 contrib/libgsasl | 2 +-
 contrib/libhdfs3 | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/contrib/libgsasl b/contrib/libgsasl
index 0324680f13f..f4e7bf0bb06 160000
--- a/contrib/libgsasl
+++ b/contrib/libgsasl
@@ -1 +1 @@
-Subproject commit 0324680f13f22bb43df5353a08e26453d7d640ac
+Subproject commit f4e7bf0bb068030d57266f87ccac4c8c012fb5c4
diff --git a/contrib/libhdfs3 b/contrib/libhdfs3
index 9194af44588..d18a7bb366b 160000
--- a/contrib/libhdfs3
+++ b/contrib/libhdfs3
@@ -1 +1 @@
-Subproject commit 9194af44588633c1b2dae44bf945804401ff883e
+Subproject commit d18a7bb366b2979032857c0950e3bf3b5fc846ed

From 3b4ac825ba24e4c51a0072ff87f8243433abf83d Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Tue, 17 Jan 2023 11:27:28 +0800
Subject: [PATCH 10/79] another optimization: adjuest type of inserts according
 to the size of instructions, which makes more parallalism

---
 src/Functions/multiIf.cpp | 68 +++++++++++++++++++++++++--------------
 1 file changed, 43 insertions(+), 25 deletions(-)

diff --git a/src/Functions/multiIf.cpp b/src/Functions/multiIf.cpp
index d3b15a2c200..ec116466dbf 100644
--- a/src/Functions/multiIf.cpp
+++ b/src/Functions/multiIf.cpp
@@ -19,6 +19,7 @@ namespace ErrorCodes
     extern const int ILLEGAL_TYPE_OF_ARGUMENT;
     extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
     extern const int NOT_IMPLEMENTED;
+    extern const int LOGICAL_ERROR;
 }
 
 namespace
@@ -240,33 +241,49 @@ public:
             return std::move(res);
         }
 
-#define EXECUTE_INSTRUCTIONS_COLUMNAR(TYPE) \
+#define EXECUTE_INSTRUCTIONS_COLUMNAR(TYPE, INDEX) \
     if (which.is##TYPE()) \
     { \
         MutableColumnPtr res = ColumnVector<TYPE>::create(rows); \
-        executeInstructionsColumnar<TYPE>(instructions, rows, res); \
+        executeInstructionsColumnar<TYPE, INDEX>(instructions, rows, res); \
         return std::move(res); \
     }
 
-#define ENUMERATE_NUMERIC_TYPES(M) \
-    M(UInt8) \
-    M(UInt16) \
-    M(UInt32) \
-    M(UInt64) \
-    M(Int8) \
-    M(Int16) \
-    M(Int32) \
-    M(Int64) \
-    M(UInt128) \
-    M(UInt256) \
-    M(Int128) \
-    M(Int256) \
-    M(Float32) \
-    M(Float64)
+#define ENUMERATE_NUMERIC_TYPES(M, INDEX) \
+    M(UInt8, INDEX) \
+    M(UInt16, INDEX) \
+    M(UInt32, INDEX) \
+    M(UInt64, INDEX) \
+    M(Int8, INDEX) \
+    M(Int16, INDEX) \
+    M(Int32, INDEX) \
+    M(Int64, INDEX) \
+    M(UInt128, INDEX) \
+    M(UInt256, INDEX) \
+    M(Int128, INDEX) \
+    M(Int256, INDEX) \
+    M(Float32, INDEX) \
+    M(Float64, INDEX) \
+    throw Exception( \
+        ErrorCodes::NOT_IMPLEMENTED, "Columnar execution of function {} not implemented for type {}", getName(), result_type->getName());
 
-    ENUMERATE_NUMERIC_TYPES(EXECUTE_INSTRUCTIONS_COLUMNAR)
-    throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Columnar multiIf not implemented for type {}", result_type->getName());
-}
+        size_t num_instructions = instructions.size();
+        if (num_instructions <= std::numeric_limits<Int16>::max())
+        {
+            ENUMERATE_NUMERIC_TYPES(EXECUTE_INSTRUCTIONS_COLUMNAR, Int16)
+        }
+        else if (num_instructions <= std::numeric_limits<Int32>::max())
+        {
+            ENUMERATE_NUMERIC_TYPES(EXECUTE_INSTRUCTIONS_COLUMNAR, Int32)
+        }
+        else if (num_instructions <= std::numeric_limits<Int64>::max())
+        {
+            ENUMERATE_NUMERIC_TYPES(EXECUTE_INSTRUCTIONS_COLUMNAR, Int64)
+        }
+        else
+            throw Exception(
+                ErrorCodes::LOGICAL_ERROR, "Instruction size({}) of function {} is out of range", getName(), result_type->getName());
+    }
 
 private:
     static void executeInstructions(std::vector<Instruction> & instructions, size_t rows, const MutableColumnPtr & res)
@@ -306,9 +323,10 @@ private:
     }
 
     /// We should read source from which instruction on each row?
-    static void calculateInserts(std::vector<Instruction> & instructions, size_t rows, PaddedPODArray<Int64> & inserts)
+    template <typename S>
+    static NO_INLINE void calculateInserts(std::vector<Instruction> & instructions, size_t rows, PaddedPODArray<S> & inserts)
     {
-        for (Int64 i = instructions.size() - 1; i >= 0; --i)
+        for (S i = static_cast<S>(instructions.size() - 1); i >= 0; --i)
         {
             auto & instruction = instructions[i];
             if (instruction.condition_always_true)
@@ -349,10 +367,10 @@ private:
         }
     }
 
-    template <typename T>
-    static void executeInstructionsColumnar(std::vector<Instruction> & instructions, size_t rows, const MutableColumnPtr & res)
+    template <typename T, typename S>
+    static NO_INLINE void executeInstructionsColumnar(std::vector<Instruction> & instructions, size_t rows, const MutableColumnPtr & res)
     {
-        PaddedPODArray<Int64> inserts(rows, -1);
+        PaddedPODArray<S> inserts(rows, static_cast<S>(instructions.size()));
         calculateInserts(instructions, rows, inserts);
 
         PaddedPODArray<T> & res_data = assert_cast<ColumnVector<T> &>(*res).getData();

From 9d2844e68975b551cf0257b8573228212adef8b3 Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Tue, 17 Jan 2023 11:40:06 +0800
Subject: [PATCH 11/79] last optimization: convert memcpy to assign operation
 of fixed type T

---
 src/Functions/multiIf.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Functions/multiIf.cpp b/src/Functions/multiIf.cpp
index ec116466dbf..a9aa1955fec 100644
--- a/src/Functions/multiIf.cpp
+++ b/src/Functions/multiIf.cpp
@@ -378,7 +378,7 @@ private:
         {
             auto & instruction = instructions[inserts[row_i]];
             auto ref = instruction.source->getDataAt(row_i);
-            memcpy(&res_data[row_i], ref.data, ref.size);
+            res_data[row_i] = *reinterpret_cast<const T*>(ref.data);
         }
     }
 

From d23e456f9ee409cdfbc330fb9d168b84af2be133 Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Tue, 17 Jan 2023 11:41:49 +0800
Subject: [PATCH 12/79] remove no_inline

---
 src/Functions/multiIf.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Functions/multiIf.cpp b/src/Functions/multiIf.cpp
index a9aa1955fec..65da8b31727 100644
--- a/src/Functions/multiIf.cpp
+++ b/src/Functions/multiIf.cpp
@@ -324,7 +324,7 @@ private:
 
     /// We should read source from which instruction on each row?
     template <typename S>
-    static NO_INLINE void calculateInserts(std::vector<Instruction> & instructions, size_t rows, PaddedPODArray<S> & inserts)
+    static void calculateInserts(std::vector<Instruction> & instructions, size_t rows, PaddedPODArray<S> & inserts)
     {
         for (S i = static_cast<S>(instructions.size() - 1); i >= 0; --i)
         {
@@ -368,7 +368,7 @@ private:
     }
 
     template <typename T, typename S>
-    static NO_INLINE void executeInstructionsColumnar(std::vector<Instruction> & instructions, size_t rows, const MutableColumnPtr & res)
+    static void executeInstructionsColumnar(std::vector<Instruction> & instructions, size_t rows, const MutableColumnPtr & res)
     {
         PaddedPODArray<S> inserts(rows, static_cast<S>(instructions.size()));
         calculateInserts(instructions, rows, inserts);

From 54d2ae4a78afc3e65872ece85b6b72666e73d936 Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Tue, 17 Jan 2023 14:44:33 +0800
Subject: [PATCH 13/79] add some debug logs

---
 src/Functions/multiIf.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/Functions/multiIf.cpp b/src/Functions/multiIf.cpp
index 65da8b31727..b0a75477c7a 100644
--- a/src/Functions/multiIf.cpp
+++ b/src/Functions/multiIf.cpp
@@ -219,6 +219,15 @@ public:
                 break;
         }
 
+        for (size_t i = 0; i < instructions.size(); ++i)
+        {
+            auto & instruction = instructions[i];
+            auto source = instruction.source;
+            for (size_t row_i = 0; row_i < input_rows_count; ++row_i)
+            {
+                std::cout << "number:" << row_i << ",instruction:" << i << ",field" << toString((*source)[row_i]) << std::endl;
+            }
+        }
 
         /// Special case if first instruction condition is always true and source is constant
         if (instructions.size() == 1 && instructions.front().source_is_constant
@@ -241,6 +250,7 @@ public:
             return std::move(res);
         }
 
+
 #define EXECUTE_INSTRUCTIONS_COLUMNAR(TYPE, INDEX) \
     if (which.is##TYPE()) \
     { \
@@ -373,12 +383,15 @@ private:
         PaddedPODArray<S> inserts(rows, static_cast<S>(instructions.size()));
         calculateInserts(instructions, rows, inserts);
 
+
+
         PaddedPODArray<T> & res_data = assert_cast<ColumnVector<T> &>(*res).getData();
         for (size_t row_i = 0; row_i < rows; ++row_i)
         {
             auto & instruction = instructions[inserts[row_i]];
             auto ref = instruction.source->getDataAt(row_i);
             res_data[row_i] = *reinterpret_cast<const T*>(ref.data);
+            std::cout << "number:" << row_i << ",instruction:" << inserts[row_i] << std::endl;
         }
     }
 

From 1093a42f685b46025f2b1acfff16ea5d3ab053fa Mon Sep 17 00:00:00 2001
From: Suzy Wang <suzy.wang@ibm.com>
Date: Tue, 17 Jan 2023 12:04:01 -0800
Subject: [PATCH 14/79] window view fix

---
 src/Interpreters/Aggregator.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/Interpreters/Aggregator.h b/src/Interpreters/Aggregator.h
index c81cfa2c0a2..7dec8c9c8a4 100644
--- a/src/Interpreters/Aggregator.h
+++ b/src/Interpreters/Aggregator.h
@@ -209,7 +209,8 @@ struct AggregationMethodOneNumber
     // Insert the key from the hash table into columns.
     static void insertKeyIntoColumns(const Key & key, std::vector<IColumn *> & key_columns, const Sizes & /*key_sizes*/)
     {
-        const auto * key_holder = reinterpret_cast<const char *>(&key);
+        FieldType casted_key = static_cast<FieldType>(key);
+        const auto * key_holder = reinterpret_cast<const char *>(&casted_key);
         auto * column = static_cast<ColumnVectorHelper *>(key_columns[0]);
         column->insertRawData<sizeof(FieldType)>(key_holder);
     }

From f66dbf6372cadb605ec46f6da0742285abf6f43c Mon Sep 17 00:00:00 2001
From: MeenaRenganathan22 <Meena.Renganathan@ibm.com>
Date: Wed, 18 Jan 2023 13:47:16 -0500
Subject: [PATCH 15/79] Committing the CMakeLists.txt with IntelAsmCrc32c.cpp
 and perf_checksum.cpp

---
 contrib/libhdfs3-cmake/CMakeLists.txt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/contrib/libhdfs3-cmake/CMakeLists.txt b/contrib/libhdfs3-cmake/CMakeLists.txt
index bd48772dd33..6b405ad628d 100644
--- a/contrib/libhdfs3-cmake/CMakeLists.txt
+++ b/contrib/libhdfs3-cmake/CMakeLists.txt
@@ -100,6 +100,8 @@ set(SRCS
     "${HDFS3_SOURCE_DIR}/common/Hash.cpp"
     "${HDFS3_SOURCE_DIR}/common/SWCrc32c.cpp"
     "${HDFS3_SOURCE_DIR}/common/Thread.cpp"
+    "${HDFS3_SOURCE_DIR}/common/IntelAsmCrc32c.cpp"
+    "${HDFS3_SOURCE_DIR}/common/perf_checksum.cpp"
     ${PROTO_SOURCES}
 )
 

From 359775a1cf0a0a66e5e65d67c6f4b2b31a5014fb Mon Sep 17 00:00:00 2001
From: MeenaRenganathan22 <Meena.Renganathan@ibm.com>
Date: Tue, 24 Jan 2023 20:31:33 -0500
Subject: [PATCH 16/79] Updated yhe libhdfs3 submoule

---
 contrib/libhdfs3 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/libhdfs3 b/contrib/libhdfs3
index d18a7bb366b..f938c73b401 160000
--- a/contrib/libhdfs3
+++ b/contrib/libhdfs3
@@ -1 +1 @@
-Subproject commit d18a7bb366b2979032857c0950e3bf3b5fc846ed
+Subproject commit f938c73b401967df45ae65bb791b601123aac5a4

From 6f76ecfdb5f90a2b0368c19e87c36a0da384eaa1 Mon Sep 17 00:00:00 2001
From: MeenaRenganathan22 <Meena.Renganathan@ibm.com>
Date: Tue, 24 Jan 2023 20:33:25 -0500
Subject: [PATCH 17/79] Committing the libhdfs3-cmake/CMakeLists.txt to include
 the IntelAsmCrc32c.cpp and perf_checksum.cpp

---
 contrib/libhdfs3-cmake/CMakeLists.txt | 28 +++++++++++++++++++++++----
 1 file changed, 24 insertions(+), 4 deletions(-)

diff --git a/contrib/libhdfs3-cmake/CMakeLists.txt b/contrib/libhdfs3-cmake/CMakeLists.txt
index 6b405ad628d..f9c59f0f016 100644
--- a/contrib/libhdfs3-cmake/CMakeLists.txt
+++ b/contrib/libhdfs3-cmake/CMakeLists.txt
@@ -101,10 +101,18 @@ set(SRCS
     "${HDFS3_SOURCE_DIR}/common/SWCrc32c.cpp"
     "${HDFS3_SOURCE_DIR}/common/Thread.cpp"
     "${HDFS3_SOURCE_DIR}/common/IntelAsmCrc32c.cpp"
-    "${HDFS3_SOURCE_DIR}/common/perf_checksum.cpp"
     ${PROTO_SOURCES}
 )
 
+if (ARCH_AMD64)
+    find_program(YASM_PATH NAMES yasm)
+    add_custom_command(
+        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/crc_iscsi_v_pcl.o
+        COMMAND ${YASM_PATH} -f x64 -f elf64 -X gnu -g dwarf2 -D LINUX -o ${CMAKE_CURRENT_BINARY_DIR}/crc_iscsi_v_pcl.o ${HDFS3_SOURCE_DIR}/common/crc_iscsi_v_pcl.asm
+        COMMENT "Translating Intel CRC assembly to object code")
+    LIST(APPEND SRCS ${CMAKE_CURRENT_BINARY_DIR}/crc_iscsi_v_pcl.o)
+endif ()
+
 # old kernels (< 3.17) doesn't have SYS_getrandom. Always use POSIX implementation to have better compatibility
 set_source_files_properties("${HDFS3_SOURCE_DIR}/rpc/RpcClient.cpp" PROPERTIES COMPILE_FLAGS "-DBOOST_UUID_RANDOM_PROVIDER_FORCE_POSIX=1")
 
@@ -113,9 +121,16 @@ add_library(_hdfs3 ${SRCS})
 
 add_dependencies(_hdfs3 protoc)
 
-target_include_directories(_hdfs3 PRIVATE ${HDFS3_SOURCE_DIR})
-target_include_directories(_hdfs3 PRIVATE ${HDFS3_COMMON_DIR})
-target_include_directories(_hdfs3 PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+if (ENABLE_CLICKHOUSE_BENCHMARK)
+    message(STATUS "enable perf checksum")
+    target_include_directories(_hdfs3 PUBLIC ${HDFS3_SOURCE_DIR})
+    target_include_directories(_hdfs3 PUBLIC ${HDFS3_COMMON_DIR})
+    target_include_directories(_hdfs3 PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
+else ()
+    target_include_directories(_hdfs3 PRIVATE ${HDFS3_SOURCE_DIR})
+    target_include_directories(_hdfs3 PRIVATE ${HDFS3_COMMON_DIR})
+    target_include_directories(_hdfs3 PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
+endif ()
 
 target_include_directories(_hdfs3 SYSTEM BEFORE INTERFACE "${ClickHouse_SOURCE_DIR}/contrib/libhdfs3/include")
 
@@ -132,3 +147,8 @@ if (TARGET OpenSSL::SSL)
 endif()
 
 add_library(ch_contrib::hdfs ALIAS _hdfs3)
+
+if (ENABLE_CLICKHOUSE_BENCHMARK)
+     add_executable(perf_checksum ${HDFS3_SOURCE_DIR}/common/perf_checksum.cpp)
+     target_link_libraries(perf_checksum PRIVATE ch_contrib::hdfs)
+endif ()

From 4a0202a07422b8328e6432adf38141ee4633f1f0 Mon Sep 17 00:00:00 2001
From: MeenaRenganathan22 <Meena.Renganathan@ibm.com>
Date: Tue, 24 Jan 2023 20:41:43 -0500
Subject: [PATCH 18/79] Committing the docker with the changes to install the
 ysam

---
 docker/packager/binary/Dockerfile | 1 +
 docker/server/Dockerfile.ubuntu   | 1 +
 2 files changed, 2 insertions(+)

diff --git a/docker/packager/binary/Dockerfile b/docker/packager/binary/Dockerfile
index cd9eb133f62..f750dbf4f74 100644
--- a/docker/packager/binary/Dockerfile
+++ b/docker/packager/binary/Dockerfile
@@ -23,6 +23,7 @@ RUN apt-get update && \
         libc6 \
         libc6-dev \
         libc6-dev-arm64-cross \
+        yasm \
         zstd && \
     apt-get clean
 
diff --git a/docker/server/Dockerfile.ubuntu b/docker/server/Dockerfile.ubuntu
index b6a93c808c3..6f8858feff5 100644
--- a/docker/server/Dockerfile.ubuntu
+++ b/docker/server/Dockerfile.ubuntu
@@ -16,6 +16,7 @@ RUN sed -i "s|http://archive.ubuntu.com|${apt_archive}|g" /etc/apt/sources.list
         gnupg \
         locales \
         wget \
+        yasm \
         tzdata \
     && apt-get clean
 

From f4d38b82e6e19c6e321523a516fbb48a9abfa3f4 Mon Sep 17 00:00:00 2001
From: Han Fei <hanfei19910905@gmail.com>
Date: Wed, 25 Jan 2023 10:38:51 +0100
Subject: [PATCH 19/79] RegExpTreeDict use re2 engines when processing heavy
 regexps

---
 src/Dictionaries/RegExpTreeDictionary.cpp     |  119 +-
 src/Dictionaries/RegExpTreeDictionary.h       |    4 +-
 tests/metadata/INFORMATION_SCHEMA.sql         |    2 +
 tests/metadata/information_schema.sql         |    2 +
 tests/metadata/system                         |    1 +
 tests/metadata/system.sql                     |    2 +
 ...2504_regexp_dictionary_ua_parser.reference |  793 +++++
 .../02504_regexp_dictionary_ua_parser.sh      |   87 +
 ...04_regexp_dictionary_yaml_source.reference |    6 +-
 .../02504_regexp_dictionary_yaml_source.sh    |    4 +-
 .../0_stateless/data_ua_parser/browser.yaml   | 1409 +++++++++
 .../0_stateless/data_ua_parser/device.yaml    | 2651 +++++++++++++++++
 .../0_stateless/data_ua_parser/os.yaml        | 1075 +++++++
 .../0_stateless/data_ua_parser/useragents.txt |  793 +++++
 14 files changed, 6926 insertions(+), 22 deletions(-)
 create mode 100644 tests/metadata/INFORMATION_SCHEMA.sql
 create mode 100644 tests/metadata/information_schema.sql
 create mode 120000 tests/metadata/system
 create mode 100644 tests/metadata/system.sql
 create mode 100644 tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.reference
 create mode 100755 tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.sh
 create mode 100644 tests/queries/0_stateless/data_ua_parser/browser.yaml
 create mode 100644 tests/queries/0_stateless/data_ua_parser/device.yaml
 create mode 100644 tests/queries/0_stateless/data_ua_parser/os.yaml
 create mode 100644 tests/queries/0_stateless/data_ua_parser/useragents.txt

diff --git a/src/Dictionaries/RegExpTreeDictionary.cpp b/src/Dictionaries/RegExpTreeDictionary.cpp
index 9410944c71b..21c61173e92 100644
--- a/src/Dictionaries/RegExpTreeDictionary.cpp
+++ b/src/Dictionaries/RegExpTreeDictionary.cpp
@@ -1,3 +1,4 @@
+#include <exception>
 #include <optional>
 #include <string_view>
 
@@ -86,8 +87,15 @@ struct RegExpTreeDictionary::RegexTreeNode
     UInt64      parent_id;
     std::string regex;
     re2_st::RE2 searcher;
+
     RegexTreeNode(UInt64 id_, UInt64 parent_id_, const String & regex_, const re2_st::RE2::Options & regexp_options):
         id(id_), parent_id(parent_id_), regex(regex_), searcher(regex_, regexp_options) {}
+
+    bool match(const char * haystack, size_t size) const
+    {
+        return searcher.Match(haystack, 0, size, re2_st::RE2::Anchor::UNANCHORED, nullptr, 0);
+    }
+
     struct AttributeValue
     {
         Field field;
@@ -142,6 +150,52 @@ void RegExpTreeDictionary::calculateBytesAllocated()
     bytes_allocated += 2 * sizeof(UInt64) * topology_order.size();
 }
 
+namespace
+{
+    /// hyper scan is not good at processing regex containing {0, 200}
+    /// This will make re compilation slow and failed. So we select this heavy regular expressions and
+    /// process it with re2.
+    struct ComplexRegexChecker
+    {
+        re2_st::RE2 searcher;
+        ComplexRegexChecker() : searcher(R"(\{([\d]+),([\d]+)\})") {}
+
+        static bool isFigureLargerThanFifty(const String & str)
+        try
+        {
+            auto number = std::stoi(str);
+            return number > 50;
+        }
+        catch (std::exception &)
+        {
+            return false;
+        }
+
+        bool check(const String & data) const
+        {
+
+            re2_st::StringPiece haystack(data.data(), data.size());
+            re2_st::StringPiece matches[10];
+            size_t start_pos = 0;
+            while (start_pos < data.size())
+            {
+                if (searcher.Match(haystack, start_pos, data.size(), re2_st::RE2::Anchor::UNANCHORED, matches, 10))
+                {
+                    const auto & match = matches[0];
+                    start_pos += match.length();
+                    const auto & match1 = matches[1];
+                    const auto & match2 = matches[2];
+                    if (isFigureLargerThanFifty(match1.ToString()) || isFigureLargerThanFifty(match2.ToString()))
+                        return true;
+                }
+                else
+                    break;
+            }
+            return false;
+        }
+    };
+}
+
 void RegExpTreeDictionary::initRegexNodes(Block & block)
 {
     auto id_column = block.getByName(kId).column;
@@ -150,6 +204,8 @@ void RegExpTreeDictionary::initRegexNodes(Block & block)
     auto keys_column = block.getByName(kKeys).column;
     auto values_column = block.getByName(kValues).column;
 
+    ComplexRegexChecker checker;
+
     size_t size = block.rows();
     for (size_t i = 0; i < size; i++)
     {
@@ -163,12 +219,10 @@ void RegExpTreeDictionary::initRegexNodes(Block & block)
         if (id == 0)
             throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION, "There are invalid id {}", id);
 
-        regexps.push_back(regex);
-        regexp_ids.push_back(id);
 
         re2_st::RE2::Options regexp_options;
         regexp_options.set_log_errors(false);
-        RegexTreeNodePtr node = std::make_unique<RegexTreeNode>(id, parent_id, regex, regexp_options);
+        RegexTreeNodePtr node = std::make_shared<RegexTreeNode>(id, parent_id, regex, regexp_options);
 
         int num_captures = std::min(node->searcher.NumberOfCapturingGroups() + 1, 10);
 
@@ -194,7 +248,17 @@ void RegExpTreeDictionary::initRegexNodes(Block & block)
                 }
             }
         }
-        regex_nodes.emplace(id, std::move(node));
+        regex_nodes.emplace(id, node);
+        if (checker.check(regex))
+        {
+            complex_regexp_nodes.push_back(node);
+            LOG_INFO(logger, "Found complex regexp {} in the config. This will slow down the queries", regex);
+        }
+        else
+        {
+            regexps.push_back(regex);
+            regexp_ids.push_back(id);
+        }
     }
 }
 
@@ -245,6 +309,7 @@ void RegExpTreeDictionary::loadData()
         initGraph();
         if (regexps.empty())
             throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION, "There are no available regular expression. Please check your config");
+        LOG_INFO(logger, "There are {} simple regexps and {} complex regexps", regexps.size(), complex_regexp_nodes.size());
         #if USE_VECTORSCAN
         try
         {
@@ -287,12 +352,15 @@ RegExpTreeDictionary::RegExpTreeDictionary(
     calculateBytesAllocated();
 }
 
-String processBackRefs(const String & data, const re2_st::RE2 & searcher, const std::vector<StringPiece> & pieces)
+std::pair<String, bool> processBackRefs(const String & data, const re2_st::RE2 & searcher, const std::vector<StringPiece> & pieces)
 {
     re2_st::StringPiece haystack(data.data(), data.size());
     re2_st::StringPiece matches[10];
     String result;
     searcher.Match(haystack, 0, data.size(), re2_st::RE2::Anchor::UNANCHORED, matches, 10);
+    /// if the pattern is a single '$1' but fails to match, we would use the default value.
+    if (pieces.size() == 1 && pieces[0].ref_num >= 0 && pieces[0].ref_num < 9 && matches[pieces[0].ref_num].empty())
+        return std::make_pair(result, true);
     for (const auto & item : pieces)
     {
         if (item.ref_num >= 0 && item.ref_num < 10)
@@ -300,7 +368,7 @@ String processBackRefs(const String & data, const re2_st::RE2 & searcher, const
         else
             result += item.literal;
     }
-    return result;
+    return std::make_pair(result, false);
 }
 
 // walk towards root and collect attributes.
@@ -323,8 +391,9 @@ bool RegExpTreeDictionary::setAttributes(
             continue;
         if (value.containsBackRefs())
         {
-            String updated_str = processBackRefs(data, regex_nodes.at(id)->searcher, value.pieces);
-            attributes_to_set[name] = parseStringToField(updated_str, attributes.at(name).type);
+            auto [updated_str, use_default] = processBackRefs(data, regex_nodes.at(id)->searcher, value.pieces);
+            if (!use_default)
+                attributes_to_set[name] = parseStringToField(updated_str, attributes.at(name).type);
         }
         else
             attributes_to_set[name] = value.field;
@@ -352,12 +421,19 @@ namespace
         MatchContext(const std::vector<UInt64> & regexp_ids_, const std::unordered_map<UInt64, UInt64> & topology_order_)
             : regexp_ids(regexp_ids_), topology_order(topology_order_) {}
 
-        void insert(unsigned int id)
+        void insertIdx(unsigned int idx)
         {
-            UInt64 idx = regexp_ids[id-1];
-            UInt64 topological_order = topology_order.at(idx);
-            matched_idx_set.emplace(idx);
-            matched_idx_sorted_list.push_back(std::make_pair(topological_order, idx));
+            UInt64 node_id = regexp_ids[idx-1];
+            UInt64 topological_order = topology_order.at(node_id);
+            matched_idx_set.emplace(node_id);
+            matched_idx_sorted_list.push_back(std::make_pair(topological_order, node_id));
+        }
+
+        void insertNodeID(UInt64 id)
+        {
+            UInt64 topological_order = topology_order.at(id);
+            matched_idx_set.emplace(id);
+            matched_idx_sorted_list.push_back(std::make_pair(topological_order, id));
         }
 
         void sort()
@@ -406,7 +482,7 @@ std::unordered_map<String, ColumnPtr> RegExpTreeDictionary::matchSearchAllIndice
                     unsigned int /* flags */,
                     void * context) -> int
     {
-        static_cast<MatchContext *>(context)->insert(id);
+        static_cast<MatchContext *>(context)->insertIdx(id);
         return 0;
     };
 
@@ -430,13 +506,25 @@ std::unordered_map<String, ColumnPtr> RegExpTreeDictionary::matchSearchAllIndice
         if (err != HS_SUCCESS)
             throw Exception(ErrorCodes::HYPERSCAN_CANNOT_SCAN_TEXT, "Failed to scan data with vectorscan");
 
+        if (!match_result.matched_idx_set.empty())
+        {
+            for (const auto & node_ptr : complex_regexp_nodes)
+            {
+                if (node_ptr->match(reinterpret_cast<const char *>(keys_data.data()) + offset, length))
+                {
+                    match_result.insertNodeID(node_ptr->id);
+                    break;
+                }
+            }
+        }
+
         match_result.sort();
 
         // Walk through the regex tree util all attributes are set;
         std::unordered_map<String, Field> attributes_to_set;
         std::unordered_set<UInt64> visited_nodes;
 
-        // check if it is a valid id
+        // Some node matches but its parents cannot match. In this case we must regard this node unmatched.
         auto is_invalid = [&](UInt64 id)
         {
             while (id)
@@ -466,7 +554,6 @@ std::unordered_map<String, ColumnPtr> RegExpTreeDictionary::matchSearchAllIndice
             if (attributes_to_set.contains(name))
                 continue;
 
-            /// TODO: default value might be a back-reference, that is useful in lib ua-core
             DefaultValueProvider default_value(attr.null_value, defaults.at(name));
             columns[name]->insert(default_value.getDefaultValue(key_idx));
         }
diff --git a/src/Dictionaries/RegExpTreeDictionary.h b/src/Dictionaries/RegExpTreeDictionary.h
index 8fdf5cff5e6..f3de05239b5 100644
--- a/src/Dictionaries/RegExpTreeDictionary.h
+++ b/src/Dictionaries/RegExpTreeDictionary.h
@@ -149,7 +149,9 @@ private:
         const std::unordered_map<String, const DictionaryAttribute &> & attributes) const;
 
     struct RegexTreeNode;
-    using RegexTreeNodePtr = std::unique_ptr<RegexTreeNode>;
+    using RegexTreeNodePtr = std::shared_ptr<RegexTreeNode>;
+
+    std::vector<RegexTreeNodePtr> complex_regexp_nodes;
 
     std::map<UInt64, RegexTreeNodePtr> regex_nodes;
     std::unordered_map<UInt64, UInt64> topology_order;
diff --git a/tests/metadata/INFORMATION_SCHEMA.sql b/tests/metadata/INFORMATION_SCHEMA.sql
new file mode 100644
index 00000000000..291582fd1eb
--- /dev/null
+++ b/tests/metadata/INFORMATION_SCHEMA.sql
@@ -0,0 +1,2 @@
+ATTACH DATABASE INFORMATION_SCHEMA
+ENGINE = Memory
diff --git a/tests/metadata/information_schema.sql b/tests/metadata/information_schema.sql
new file mode 100644
index 00000000000..6cea934b49d
--- /dev/null
+++ b/tests/metadata/information_schema.sql
@@ -0,0 +1,2 @@
+ATTACH DATABASE information_schema
+ENGINE = Memory
diff --git a/tests/metadata/system b/tests/metadata/system
new file mode 120000
index 00000000000..9a11b7e3458
--- /dev/null
+++ b/tests/metadata/system
@@ -0,0 +1 @@
+/home/hanfei/ClickHouse/tests/store/069/0693727d-7be1-48e3-9ff3-aa0bba736b34/
\ No newline at end of file
diff --git a/tests/metadata/system.sql b/tests/metadata/system.sql
new file mode 100644
index 00000000000..941c12b0a66
--- /dev/null
+++ b/tests/metadata/system.sql
@@ -0,0 +1,2 @@
+ATTACH DATABASE _ UUID '0693727d-7be1-48e3-9ff3-aa0bba736b34'
+ENGINE = Atomic
diff --git a/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.reference b/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.reference
new file mode 100644
index 00000000000..d6dd2adae74
--- /dev/null
+++ b/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.reference
@@ -0,0 +1,793 @@
+AppleTV	Other 0.0	ATV OS X 8.1.3
+LG-M150	Firefox Mobile 68.0	Android 7.0.0
+Other	Firefox Mobile 68.0	Android 8.0.0
+Other	Firefox Mobile 68.0	Android 8.1.0
+Other	Firefox Mobile 68.0	Android 9.0.0
+Other	Chrome Mobile 77.0	Android 10.0.0
+Other	Chrome Mobile 77.0	Android 10.0.0
+Other	Chrome Mobile 77.0	Android 10.0.0
+Other	Facebook 240.0	Android 10.0.0
+Other	Chrome Mobile WebView 77.0	Android 10.0.0
+Other	Chrome Mobile 77.0	Android 10.0.0
+HTC Sensation 4G	Chrome Mobile 42.0	Android 4.0.3
+Kindle	Amazon Silk 73.7	Android 4.0.3
+Samsung GT-I9152 	Chrome Mobile 42.0	Android 4.2.2
+Samsung GT-N5110	Chrome 76.0	Android 4.4.2
+RCT6773W22	Chrome 77.0	Android 4.4.2
+Samsung SM-T217S	Chrome 77.0	Android 4.4.2
+Samsung SM-T530NU	Chrome 77.0	Android 4.4.2
+Other	Chrome 69.0	Android 4.4.2
+Kindle	Amazon Silk 76.3	Android 4.4.3
+Samsung SM-A500H	Chrome Mobile 73.0	Android 5.0.2
+Samsung SM-T357T	Chrome 77.0	Android 5.0.2
+Samsung SM-T530NU	Chrome 76.0	Android 5.0.2
+Samsung SM-T530NU	Chrome 77.0	Android 5.0.2
+RCT6213W87DK	Yandex Browser 19.4	Android 5.0.0
+Samsung SM-N900T	Facebook 229.0	Android 5.0.0
+Other	Chrome Mobile WebView 70.0	Android 5.1.1
+Kindle	Amazon Silk 76.3	Android 5.1.1
+Other	Chrome Mobile WebView 70.0	Android 5.1.1
+Kindle	Amazon Silk 76.3	Android 5.1.1
+Kindle	Amazon Silk 76.3	Android 5.1.1
+Kindle	Amazon Silk 71.2	Android 5.1.1
+Kindle	Amazon Silk 76.3	Android 5.1.1
+Kindle	Amazon Silk 76.3	Android 5.1.1
+Kindle	Amazon Silk 76.3	Android 5.1.1
+Kindle	Amazon Silk 76.3	Android 5.1.1
+Kindle	Amazon Silk 77.1	Android 5.1.1
+LG-AS330	Chrome Mobile 77.0	Android 5.1.1
+Other	Chrome Mobile 77.0	Android 5.1.1
+Samsung SM-G530R7	Samsung Internet 9.2	Android 5.1.1
+Samsung SM-T377P	Samsung Internet 10.1	Android 5.1.1
+Samsung SM-T900	Samsung Internet 10.1	Android 5.1.1
+Samsung SM-T337A	Chrome 69.0	Android 5.1.1
+Samsung SM-G360T1	Chrome Mobile 67.0	Android 5.1.1
+Samsung SM-J320FN	Chrome Mobile 74.0	Android 5.1.1
+Other	Chrome 74.0	Android 5.1.1
+Samsung SM-T330NU	Chrome 71.0	Android 5.1.1
+Other	Chrome 76.0	Android 5.1.1
+Other	Chrome 77.0	Android 5.1.1
+Other	Chrome Mobile WebView 74.0	Android 5.1.1
+Other	Chrome Mobile 66.0	Android 5.1.0
+HTC Desire 626s	Chrome Mobile 77.0	Android 5.1.0
+HUAWEI LUA-L22	Chrome Mobile 50.0	Android 5.1.0
+Other	Chrome 77.0	Android 5.1.0
+Other	Chrome Mobile 73.0	Android 5.1.0
+Oppo CPH1613	Chrome Mobile 77.0	Android 6.0.1
+LG-M153 	Chrome Mobile WebView 55.0	Android 6.0.1
+LG-M153	Chrome Mobile 77.0	Android 6.0.1
+Other	Chrome Mobile 77.0	Android 6.0.1
+Other	Chrome Mobile 74.0	Android 6.0.1
+Other	Chrome 44.0	Android 6.0.1
+Samsung SM-G900I	Samsung Internet 10.1	Android 6.0.1
+Samsung SM-G900P	Samsung Internet 7.2	Android 6.0.1
+Samsung SM-J700M	Samsung Internet 10.1	Android 6.0.1
+Samsung SM-S327VL	Samsung Internet 10.1	Android 6.0.1
+Samsung SM-T377A	Chrome 77.0	Android 6.0.1
+Samsung SM-G532M	Chrome Mobile 55.0	Android 6.0.1
+Samsung SM-G532M	Facebook 240.0	Android 6.0.1
+Samsung SM-G532M	Chrome Mobile 77.0	Android 6.0.1
+Samsung SM-G550T	Chrome Mobile 76.0	Android 6.0.1
+Samsung SM-G550T	Chrome Mobile 77.0	Android 6.0.1
+Samsung SM-G550T1	Chrome Mobile 76.0	Android 6.0.1
+Samsung SM-G900V	Chrome Mobile 73.0	Android 6.0.1
+Samsung SM-G920A	Chrome Mobile 77.0	Android 6.0.1
+Samsung SM-J327P	Chrome Mobile 77.0	Android 6.0.1
+Samsung SM-N910S	Chrome Mobile 75.0	Android 6.0.1
+Samsung SM-N920V	Chrome Mobile 76.0	Android 6.0.1
+Samsung SM-T350	Chrome 59.0	Android 6.0.1
+Samsung SM-T560NU	Chrome 77.0	Android 6.0.1
+Other	Chrome 77.0	Android 6.0.1
+Other	Chrome Mobile 77.0	Android 6.0.1
+Other	Chrome Mobile 67.0	Android 6.0.1
+Other	Chrome Mobile WebView 45.0	Android 6.0.1
+Other	Chrome Mobile 76.0	Android 6.0.0
+Huawei CAM-L21	Chrome Mobile 77.0	Android 6.0.0
+Other	Chrome Mobile 77.0	Android 6.0.0
+RCT6603W47M7	Chrome 77.0	Android 6.0.0
+Other	Chrome Mobile 56.0	Android 7.0.0
+Asus A002A	Chrome Mobile 77.0	Android 7.0.0
+Other	Chrome Mobile 77.0	Android 7.0.0
+Other	Chrome Mobile WebView 59.0	Android 7.0.0
+Other	Chrome Mobile 77.0	Android 7.0.0
+LG-H872 	Chrome Mobile 64.0	Android 7.0.0
+LG-K425 	Chrome Mobile 55.0	Android 7.0.0
+LG-LS777	Chrome Mobile 77.0	Android 7.0.0
+LG-M210	Chrome Mobile 77.0	Android 7.0.0
+LG-M430	Chrome Mobile 77.0	Android 7.0.0
+LG-TP260 	Chrome Mobile WebView 64.0	Android 7.0.0
+LG-TP260	Chrome Mobile 77.0	Android 7.0.0
+LG-TP450 	Chrome Mobile 64.0	Android 7.0.0
+LG-V521	Chrome 75.0	Android 7.0.0
+LG-V521	Chrome 77.0	Android 7.0.0
+Other	Chrome Mobile 58.0	Android 7.0.0
+Other	Chrome Mobile 55.0	Android 7.0.0
+Other	Chrome Mobile 77.0	Android 7.0.0
+Other	Chrome 77.0	Android 7.0.0
+Other	Chrome Mobile 77.0	Android 7.0.0
+Samsung SM-J701F	Samsung Internet 10.1	Android 7.0.0
+Samsung SM-J710F	Samsung Internet 10.1	Android 7.0.0
+Samsung SM-N920T	Samsung Internet 9.2	Android 7.0.0
+Samsung SM-G920A	Chrome Mobile 77.0	Android 7.0.0
+Samsung SM-G920P	Flipboard 4.2	Android 7.0.0
+Samsung SM-G920V	Chrome Mobile 76.0	Android 7.0.0
+Samsung SM-G928V	Chrome Mobile 77.0	Android 7.0.0
+Samsung SM-G950U	Chrome Mobile 77.0	Android 7.0.0
+Samsung SM-G955U	Chrome Mobile 77.0	Android 7.0.0
+Samsung SM-J327T	Chrome Mobile 74.0	Android 7.0.0
+Samsung SM-J327T	Chrome Mobile 77.0	Android 7.0.0
+Samsung SM-J327T1	Chrome Mobile 64.0	Android 7.0.0
+Samsung SM-J327T1	Chrome Mobile 75.0	Android 7.0.0
+Samsung SM-J327T1	Chrome Mobile 77.0	Android 7.0.0
+Samsung SM-N9208	Chrome Mobile 73.0	Android 7.0.0
+Samsung SM-N920P	Chrome Mobile 74.0	Android 7.0.0
+Samsung SM-N920T	Chrome Mobile 77.0	Android 7.0.0
+Other	Chrome 77.0	Android 7.0.0
+Other	Chrome 75.0	Android 7.0.0
+Other	Chrome 76.0	Android 7.0.0
+Other	Chrome 77.0	Android 7.0.0
+Other	Chrome 76.0	Android 7.0.0
+Other	Chrome 76.0	Android 7.0.0
+Other	Chrome 75.0	Android 7.0.0
+Other	Chrome Mobile 77.0	Android 7.0.0
+Generic Smartphone	Chrome Mobile 58.0	Android 7.0.0
+Other	Chrome Mobile WebView 77.0	Android 7.1.1
+Other	Chrome Mobile 77.0	Android 7.1.1
+Oppo CPH1729	Facebook 240.0	Android 7.1.1
+Other	Chrome Mobile 74.0	Android 7.1.1
+Other	Chrome Mobile 77.0	Android 7.1.1
+Other	Chrome Mobile WebView 76.0	Android 7.1.1
+Other	Chrome Mobile 70.0	Android 7.1.1
+Other	Chrome Mobile 76.0	Android 7.1.1
+Other	Chrome Mobile 77.0	Android 7.1.1
+Other	Chrome Mobile 77.0	Android 7.1.1
+Other	Chrome Mobile 77.0	Android 7.1.1
+Other	Chrome Mobile 64.0	Android 7.1.1
+Samsung SM-J320A	Samsung Internet 10.1	Android 7.1.1
+Samsung SM-T550	Samsung Internet 10.1	Android 7.1.1
+Samsung SM-T377A	Chrome 64.0	Android 7.1.1
+Samsung SM-J250F	Chrome Mobile 76.0	Android 7.1.1
+Samsung SM-J700T	Chrome Mobile 77.0	Android 7.1.1
+Other	Chrome 77.0	Android 7.1.1
+Samsung SM-T377T	Chrome 77.0	Android 7.1.1
+Samsung SM-T550	Chrome 69.0	Android 7.1.1
+Other	Chrome 77.0	Android 7.1.1
+Samsung SM-T560NU	Chrome 77.0	Android 7.1.1
+X20	Chrome Mobile WebView 52.0	Android 7.1.1
+Other	Chrome Mobile 58.0	Android 7.1.1
+Other	Chrome Mobile WebView 74.0	Android 7.1.1
+Other	Chrome Mobile WebView 75.0	Android 7.1.1
+Other	Chrome Mobile 77.0	Android 7.1.1
+Other	Chrome Mobile WebView 70.0	Android 7.1.2
+Other	Chrome Mobile WebView 70.0	Android 7.1.2
+Kindle	Amazon Silk 76.3	Android 7.1.2
+Other	Chrome Mobile WebView 70.0	Android 7.1.2
+Other	Chrome Mobile WebView 70.0	Android 7.1.2
+Other	Chrome Mobile WebView 59.0	Android 7.1.2
+Kindle	Amazon Silk 76.3	Android 7.1.2
+Kindle	Amazon Silk 76.3	Android 7.1.2
+LG-SP200	Chrome Mobile 75.0	Android 7.1.2
+LG-SP200	Chrome Mobile 76.0	Android 7.1.2
+Other	Chrome Mobile 76.0	Android 7.1.2
+Other	Chrome Mobile 76.0	Android 7.1.2
+RCT6973W43R	Chrome 77.0	Android 7.1.2
+XiaoMi Redmi 4	Chrome Mobile 77.0	Android 7.1.2
+Other	Chrome Mobile WebView 76.0	Android 8.0.0
+Asus Z01FD	Chrome Mobile 77.0	Android 8.0.0
+Huawei AUM-L29	Chrome Mobile 77.0	Android 8.0.0
+Other	Chrome Mobile WebView 77.0	Android 8.0.0
+Other	Chrome 77.0	Android 8.0.0
+Other	Chrome Mobile 77.0	Android 8.0.0
+Other	Chrome Mobile 77.0	Android 8.0.0
+LG-H910	Chrome Mobile 77.0	Android 8.0.0
+LG-H931	Chrome Mobile 76.0	Android 8.0.0
+LG-H932	Chrome Mobile 77.0	Android 8.0.0
+Samsung SM-A520F	Samsung Internet 10.1	Android 8.0.0
+Samsung SM-G891A	Samsung Internet 8.2	Android 8.0.0
+Samsung SM-G935T	Samsung Internet 10.1	Android 8.0.0
+Samsung SM-G955U	Samsung Internet 10.1	Android 8.0.0
+Samsung SM-J337T	Samsung Internet 9.2	Android 8.0.0
+Samsung SM-J737P	Samsung Internet 10.1	Android 8.0.0
+Samsung SM-N950F	Samsung Internet 10.1	Android 8.0.0
+Samsung SM-G891A	Chrome Mobile 72.0	Android 8.0.0
+Samsung SM-G935A	Chrome Mobile 76.0	Android 8.0.0
+Samsung SM-A720F	Chrome Mobile 77.0	Android 8.0.0
+Samsung SM-G570F	Facebook 231.0	Android 8.0.0
+Samsung SM-G570Y	Chrome Mobile 77.0	Android 8.0.0
+Samsung SM-G930T	Chrome Mobile WebView 77.0	Android 8.0.0
+Samsung SM-G930V	Chrome Mobile 64.0	Android 8.0.0
+Samsung SM-G930VL	Chrome Mobile 74.0	Android 8.0.0
+Samsung SM-G935F	Chrome Mobile 75.0	Android 8.0.0
+Samsung SM-G935P	Chrome Mobile 77.0	Android 8.0.0
+Samsung SM-G935T	Facebook 240.0	Android 8.0.0
+Samsung SM-G935T	Chrome Mobile 77.0	Android 8.0.0
+Samsung SM-G950U	Chrome Mobile 77.0	Android 8.0.0
+Samsung SM-G955U	Chrome Mobile 74.0	Android 8.0.0
+Samsung SM-G955U	Chrome Mobile 77.0	Android 8.0.0
+Samsung SM-J330G	Chrome Mobile 77.0	Android 8.0.0
+Samsung SM-J337T	Chrome Mobile 77.0	Android 8.0.0
+Samsung SM-J737A	Chrome Mobile 77.0	Android 8.0.0
+Samsung SM-J737T1	Chrome Mobile 66.0	Android 8.0.0
+Samsung SM-J737T1	Chrome Mobile 77.0	Android 8.0.0
+Samsung SM-N950F	Chrome Mobile 66.0	Android 8.0.0
+Samsung SM-N950U	Chrome Mobile 76.0	Android 8.0.0
+Samsung SM-N950U	Chrome Mobile 77.0	Android 8.0.0
+Samsung SM-N950U1	Chrome Mobile 77.0	Android 8.0.0
+Samsung SM-S367VL	Chrome Mobile 77.0	Android 8.0.0
+Other	Chrome Mobile 77.0	Android 8.0.0
+Other	Chrome Mobile 77.0	Android 8.0.0
+Other	Chrome Mobile 76.0	Android 8.0.0
+Other	Chrome Mobile 77.0	Android 8.0.0
+Other	Chrome Mobile 76.0	Android 8.0.0
+Other	Chrome Mobile 77.0	Android 8.0.0
+Other	Chrome Mobile 77.0	Android 8.1.0
+Other	Chrome Mobile 77.0	Android 8.1.0
+Other	Chrome Mobile 67.0	Android 8.1.0
+Other	Chrome Mobile 76.0	Android 8.1.0
+Huawei BKK-LX2	Chrome Mobile 76.0	Android 8.1.0
+Other	Chrome Mobile 70.0	Android 8.1.0
+Other	Chrome Mobile 77.0	Android 8.1.0
+Other	Chrome Mobile 64.0	Android 8.1.0
+Other	Chrome Mobile 77.0	Android 8.1.0
+Other	Chrome Mobile 77.0	Android 8.1.0
+LG-Q710AL	Chrome Mobile 77.0	Android 8.1.0
+Other	Chrome Mobile 77.0	Android 8.1.0
+Other	Facebook 235.0	Android 8.1.0
+Other	Chrome Mobile 70.0	Android 8.1.0
+Other	Chrome Mobile 76.0	Android 8.1.0
+Other	Chrome Mobile 76.0	Android 8.1.0
+Other	Chrome Mobile 77.0	Android 8.1.0
+Other	Chrome Mobile 77.0	Android 8.1.0
+Other	UC Browser 11.6	Android 8.1.0
+Other	Chrome Mobile 70.0	Android 8.1.0
+Other	Chrome Mobile 72.0	Android 8.1.0
+Other	Chrome Mobile 77.0	Android 8.1.0
+Other	Chrome Mobile 77.0	Android 8.1.0
+Other	Chrome Mobile 70.0	Android 8.1.0
+Other	Chrome Mobile 76.0	Android 8.1.0
+Other	Chrome Mobile WebView 77.0	Android 8.1.0
+Other	Chrome Mobile 70.0	Android 8.1.0
+Other	Chrome Mobile 76.0	Android 8.1.0
+Other	Chrome Mobile 77.0	Android 8.1.0
+Other	Chrome Mobile 68.0	Android 8.1.0
+Other	Chrome Mobile 76.0	Android 8.1.0
+Other	Chrome Mobile 77.0	Android 8.1.0
+Other	Chrome Mobile 77.0	Android 8.1.0
+HTC One	Chrome Mobile WebView 70.0	Android 8.1.0
+RCT6873W42BMF8KC	Chrome Mobile 77.0	Android 8.1.0
+Other	Chrome Mobile 67.0	Android 8.1.0
+Other	Chrome Mobile 76.0	Android 8.1.0
+Samsung SM-J727T	Samsung Internet 10.1	Android 8.1.0
+Samsung SM-J727T1	Samsung Internet 9.4	Android 8.1.0
+Samsung SM-J727T1	Samsung Internet 10.1	Android 8.1.0
+Samsung SM-T580	Samsung Internet 9.4	Android 8.1.0
+Samsung SM-J727A	Facebook 240.0	Android 8.1.0
+Samsung SM-G610F	Chrome Mobile 77.0	Android 8.1.0
+Samsung SM-J260T1	Chrome Mobile 76.0	Android 8.1.0
+Samsung SM-J260T1	Chrome Mobile 76.0	Android 8.1.0
+Samsung SM-J260T1	Chrome Mobile 77.0	Android 8.1.0
+Samsung SM-J410F	Chrome Mobile 77.0	Android 8.1.0
+Samsung SM-J727P	Chrome Mobile 68.0	Android 8.1.0
+Samsung SM-J727T	Chrome Mobile 66.0	Android 8.1.0
+Samsung SM-J727T1	Chrome Mobile 76.0	Android 8.1.0
+Samsung SM-J727T1	Chrome Mobile 77.0	Android 8.1.0
+Samsung SM-J727T1	Chrome Mobile 77.0	Android 8.1.0
+Samsung SM-J727V	Chrome Mobile 70.0	Android 8.1.0
+Samsung SM-J727V	Chrome Mobile 77.0	Android 8.1.0
+Other	Chrome 77.0	Android 8.1.0
+Other	Chrome 75.0	Android 8.1.0
+Other	Edge Mobile 42.0	Android 8.1.0
+Other	Chrome 76.0	Android 8.1.0
+Other	Chrome 76.0	Android 8.1.0
+Other	Chrome 77.0	Android 8.1.0
+Samsung SM-T837T	Chrome 77.0	Android 8.1.0
+Other	Facebook 239.0	Android 8.1.0
+Other	Chrome Mobile 75.0	Android 8.1.0
+Other	Chrome Mobile 68.0	Android 8.1.0
+Other	Chrome Mobile 76.0	Android 8.1.0
+Other	Chrome Mobile 77.0	Android 8.1.0
+Other	DuckDuckGo Mobile 5.0	Android 9.0.0
+Other	Chrome Mobile 70.0	Android 9.0.0
+Other	Facebook 236.0	Android 9.0.0
+Other	Chrome Mobile 77.0	Android 9.0.0
+Huawei CLT-L04	Chrome Mobile 77.0	Android 9.0.0
+Oppo CPH1911	Facebook 239.0	Android 9.0.0
+Oppo CPH1923	Chrome Mobile WebView 76.0	Android 9.0.0
+Huawei ELE-L29	Chrome Mobile 77.0	Android 9.0.0
+Other	Chrome Mobile 77.0	Android 9.0.0
+Other	Chrome Mobile 76.0	Android 9.0.0
+Other	Chrome Mobile 77.0	Android 9.0.0
+Huawei INE-LX2	Chrome Mobile 76.0	Android 9.0.0
+Other	Chrome Mobile WebView 77.0	Android 9.0.0
+Other	Chrome Mobile 77.0	Android 9.0.0
+Other	Chrome Mobile WebView 77.0	Android 9.0.0
+Other	Chrome Mobile 76.0	Android 9.0.0
+Other	Chrome Mobile 77.0	Android 9.0.0
+Other	Chrome Mobile 72.0	Android 9.0.0
+Other	Chrome Mobile 77.0	Android 9.0.0
+Other	Chrome Mobile 77.0	Android 9.0.0
+XiaoMi MI 9	Chrome Mobile 77.0	Android 9.0.0
+XiaoMi Mi A2	Chrome Mobile 77.0	Android 9.0.0
+Other	Chrome Mobile 77.0	Android 9.0.0
+Nokia 6	Chrome Mobile 77.0	Android 9.0.0
+OnePlus ONEPLUS A6000	Chrome Mobile 77.0	Android 9.0.0
+OnePlus ONEPLUS A6003	Chrome Mobile 77.0	Android 9.0.0
+OnePlus ONEPLUS A6013	Chrome Mobile WebView 77.0	Android 9.0.0
+OnePlus ONEPLUS A6013	Chrome Mobile 74.0	Android 9.0.0
+OnePlus ONEPLUS A6013	Chrome Mobile 77.0	Android 9.0.0
+Other	Facebook 235.0	Android 9.0.0
+Other	Chrome Mobile 77.0	Android 9.0.0
+Other	Chrome Mobile WebView 77.0	Android 9.0.0
+Other	Chrome Mobile 76.0	Android 9.0.0
+Other	Chrome Mobile 77.0	Android 9.0.0
+Other	Chrome Mobile 77.0	Android 9.0.0
+Other	Chrome Mobile 73.0	Android 9.0.0
+Oppo RMX1801	Chrome Mobile 75.0	Android 9.0.0
+XiaoMi Redmi 7	Chrome Mobile 77.0	Android 9.0.0
+XiaoMi Redmi Note 7	Chrome Mobile 76.0	Android 9.0.0
+Samsung SM-A102U	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-A505FN	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-A505GN	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-G892U	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-G950U	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-G955F	Samsung Internet 9.4	Android 9.0.0
+Samsung SM-G955U	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-G9600	Samsung Internet 9.4	Android 9.0.0
+Samsung SM-G960U	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-G965U	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-G970F	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-G970U	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-G973U	Samsung Internet 9.4	Android 9.0.0
+Samsung SM-G973U	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-G975U	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-J415F	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-J730F	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-J737P	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-J737T	Samsung Internet 9.0	Android 9.0.0
+Samsung SM-N950U	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-N960F	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-N960U	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-N960U1	Samsung Internet 9.2	Android 9.0.0
+Samsung SM-N970U	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-N975U	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-N975U1	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-T510	Samsung Internet 10.1	Android 9.0.0
+Samsung SM-T720	Samsung Internet 10.1	Android 9.0.0
+Other	Chrome Mobile WebView 77.0	Android 9.0.0
+Samsung SM-A102U	Chrome Mobile 72.0	Android 9.0.0
+Samsung SM-A102U	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-A105M	Facebook 237.0	Android 9.0.0
+Samsung SM-A205G	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-A205U	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-A505F	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-A530F	Facebook 240.0	Android 9.0.0
+Samsung SM-A530N	Chrome Mobile WebView 77.0	Android 9.0.0
+Samsung SM-A600T	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-A605F	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-A920F	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-G892A	Chrome Mobile 74.0	Android 9.0.0
+Samsung SM-G950F	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-G950U	Chrome Mobile WebView 77.0	Android 9.0.0
+Samsung SM-G950U	Chrome Mobile 71.0	Android 9.0.0
+Samsung SM-G950U	Chrome Mobile 76.0	Android 9.0.0
+Samsung SM-G950U	Chrome Mobile 76.0	Android 9.0.0
+Samsung SM-G950U	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-G950U1	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-G955F	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-G955U	Facebook 240.0	Android 9.0.0
+Samsung SM-G955U	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-G9600	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-G960U	Facebook 233.0	Android 9.0.0
+Samsung SM-G960U	Chrome Mobile WebView 77.0	Android 9.0.0
+Samsung SM-G960U	Chrome Mobile 71.0	Android 9.0.0
+Samsung SM-G960U	Chrome Mobile 74.0	Android 9.0.0
+Samsung SM-G960U	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-G960U1	Facebook 240.0	Android 9.0.0
+Samsung SM-G960U1	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-G965F	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-G965U	Chrome Mobile 74.0	Android 9.0.0
+Samsung SM-G965U	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-G965U	Chrome Mobile 79.0	Android 9.0.0
+Samsung SM-G965U1	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-G970U	Facebook 240.0	Android 9.0.0
+Samsung SM-G970U	Chrome Mobile 75.0	Android 9.0.0
+Samsung SM-G970U	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-G970U1	Chrome Mobile WebView 77.0	Android 9.0.0
+Samsung SM-G973U	Chrome Mobile 74.0	Android 9.0.0
+Samsung SM-G973U	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-G973U1	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-G975U	Chrome Mobile 75.0	Android 9.0.0
+Samsung SM-G975U	Chrome Mobile 76.0	Android 9.0.0
+Samsung SM-G975U	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-G975U1	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-J260A	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-J337P	Chrome Mobile 76.0	Android 9.0.0
+Samsung SM-J600FN	Chrome Mobile 75.0	Android 9.0.0
+Samsung SM-J600G	Facebook 238.0	Android 9.0.0
+Samsung SM-J730F	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-J737A	Chrome Mobile WebView 77.0	Android 9.0.0
+Samsung SM-J737A	Chrome Mobile 74.0	Android 9.0.0
+Samsung SM-J737V	Pinterest 75.0	Android 9.0.0
+Samsung SM-J737V	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-J810M	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-N950U	Facebook 240.0	Android 9.0.0
+Samsung SM-N950U	Chrome Mobile 72.0	Android 9.0.0
+Samsung SM-N950U	Chrome Mobile 75.0	Android 9.0.0
+Samsung SM-N950U	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-N950U	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-N960F	Chrome Mobile 76.0	Android 9.0.0
+Samsung SM-N960U	Facebook 240.0	Android 9.0.0
+Samsung SM-N960U	Chrome Mobile WebView 77.0	Android 9.0.0
+Samsung SM-N960U	Chrome Mobile 74.0	Android 9.0.0
+Samsung SM-N960U	Chrome Mobile 75.0	Android 9.0.0
+Samsung SM-N960U	Chrome Mobile 76.0	Android 9.0.0
+Samsung SM-N960U	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-N960U1	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-N975U	Chrome Mobile WebView 77.0	Android 9.0.0
+Samsung SM-N975U	Chrome Mobile WebView 77.0	Android 9.0.0
+Samsung SM-N975U	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-N976V	Facebook 240.0	Android 9.0.0
+Samsung SM-S367VL	Chrome Mobile 77.0	Android 9.0.0
+Samsung SM-S767VL	Chrome Mobile 76.0	Android 9.0.0
+Samsung SM-T597P	Chrome 77.0	Android 9.0.0
+Other	Chrome 77.0	Android 9.0.0
+Other	Chrome Mobile 77.0	Android 9.0.0
+Huawei VOG-L29	Chrome Mobile 77.0	Android 9.0.0
+Other	Chrome Mobile 74.0	Android 9.0.0
+Other	Chrome Mobile WebView 77.0	Android 9.0.0
+Other	Chrome Mobile 77.0	Android 9.0.0
+Other	Facebook 235.0	Android 9.0.0
+Other	Chrome Mobile 70.0	Android 9.0.0
+Other	Chrome Mobile 75.0	Android 9.0.0
+Other	Chrome Mobile 77.0	Android 9.0.0
+Other	Chrome Mobile 73.0	Android 9.0.0
+Other	Chrome Mobile 77.0	Android 9.0.0
+Samsung GT-P3113 	Android 4.1	Android 4.1.1
+Samsung GT-I8160 	Android 4.1	Android 4.1.2
+Other	Android 4.2	Android 4.2.2
+Samsung SM-E500H	Android 4.4	Android 4.4.0
+Other	Chrome Mobile WebView 43.0	Android 6.0.1
+Samsung SM-J737T1	Chrome Mobile WebView 43.0	Android 6.0.1
+Other	Opera Mobile 5.3	Android 7.0.0
+XiaoMi Redmi 5A	MiuiBrowser 9.5	Android 7.1.2
+Oppo CPH1911	Chrome Mobile WebView 70.0	Android 9.0.0
+Other	Opera Mobile 44.1	Android 9.0.0
+Mac	Firefox 68.0	Mac OS X 10.11.0
+Mac	Firefox 69.0	Mac OS X 10.13.0
+Mac	Firefox 67.0	Mac OS X 10.14.0
+Mac	Firefox 68.0	Mac OS X 10.14.0
+Mac	Firefox 69.0	Mac OS X 10.14.0
+Mac	Firefox 70.0	Mac OS X 10.14.0
+Mac	Chrome 76.0	Mac OS X 10.10.5
+Mac	Chrome 77.0	Mac OS X 10.10.5
+Mac	Safari 10.1	Mac OS X 10.10.5
+Mac	Chrome 76.0	Mac OS X 10.11.4
+Mac	Chrome 72.0	Mac OS X 10.11.6
+Mac	Chrome 76.0	Mac OS X 10.11.6
+Mac	Chrome 76.0	Mac OS X 10.11.6
+Mac	Chrome 77.0	Mac OS X 10.11.6
+Mac	Safari 9.1	Mac OS X 10.11.6
+Mac	Safari 10.0	Mac OS X 10.11.6
+Mac	Safari 11.1	Mac OS X 10.11.6
+Mac	Chrome 77.0	Mac OS X 10.12.1
+Mac	Safari 10.0	Mac OS X 10.12.3
+Mac	Chrome 75.0	Mac OS X 10.12.6
+Mac	Chrome 76.0	Mac OS X 10.12.6
+Mac	Chrome 76.0	Mac OS X 10.12.6
+Mac	Chrome 77.0	Mac OS X 10.12.6
+Mac	Safari 12.1	Mac OS X 10.12.6
+Mac	Safari 11.0	Mac OS X 10.13.0
+Mac	Chrome 77.0	Mac OS X 10.13.1
+Mac	Chrome 77.0	Mac OS X 10.13.2
+Mac	Chrome 76.0	Mac OS X 10.13.4
+Mac	Chrome 76.0	Mac OS X 10.13.4
+Mac	Chrome 76.0	Mac OS X 10.13.5
+Mac	Chrome 75.0	Mac OS X 10.13.6
+Mac	Chrome 76.0	Mac OS X 10.13.6
+Mac	Chrome 77.0	Mac OS X 10.13.6
+Mac	Safari 12.0	Mac OS X 10.13.6
+Mac	Safari 12.1	Mac OS X 10.13.6
+Mac	Safari 12.1	Mac OS X 10.13.6
+Mac	Safari 13.0	Mac OS X 10.13.6
+Mac	Safari 13.0	Mac OS X 10.13.6
+Mac	Chrome 75.0	Mac OS X 10.14.0
+Mac	Chrome 76.0	Mac OS X 10.14.0
+Mac	Chrome 77.0	Mac OS X 10.14.0
+Mac	Chrome 77.0	Mac OS X 10.14.1
+Mac	Chrome 76.0	Mac OS X 10.14.2
+Mac	Chrome 69.0	Mac OS X 10.14.3
+Mac	Safari 12.0	Mac OS X 10.14.3
+Mac	Chrome 75.0	Mac OS X 10.14.4
+Mac	Chrome 77.0	Mac OS X 10.14.4
+Mac	Safari 12.1	Mac OS X 10.14.4
+Mac	Chrome 76.0	Mac OS X 10.14.5
+Mac	Chrome 77.0	Mac OS X 10.14.5
+Mac	Safari 12.1	Mac OS X 10.14.5
+Mac	Chrome 75.0	Mac OS X 10.14.6
+Mac	Chrome 76.0	Mac OS X 10.14.6
+Mac	Chrome 76.0	Mac OS X 10.14.6
+Mac	Chrome 77.0	Mac OS X 10.14.6
+Mac	Chrome 77.0	Mac OS X 10.14.6
+Mac	Safari 12.1	Mac OS X 10.14.6
+Mac	Safari 13.0	Mac OS X 10.14.6
+Mac	Chrome 65.0	Mac OS X 10.9.5
+Mac	Chrome 66.0	Mac OS X 10.9.5
+Mac	Chrome 67.0	Mac OS X 10.9.5
+PlayStation 4	Apple Mail 605.1	Other 0.0.0
+Other	Safari 3.0	Tizen 3.0.0
+Other	Samsung Internet 2.0	Tizen 3.0.0
+Other	Samsung Internet 2.1	Tizen 4.0.0
+Other	Samsung Internet 2.2	Tizen 5.0.0
+Other	Edge 17.17134	Windows 10.0.0
+Other	Edge 18.17763	Windows 10.0.0
+Other	Chrome 77.0	Windows 10.0.0
+Other	Maxthon 5.2	Windows 10.0.0
+Other	Chrome 73.1	Windows 10.0.0
+Other	Chrome 76.0	Windows 10.0.0
+Other	Opera 63.0	Windows 10.0.0
+Other	Chrome 77.0	Windows 10.0.0
+Other	Chrome 77.0	Windows 10.0.0
+Other	Coc Coc 82.0	Windows 10.0.0
+Other	IE 11.0	Windows 10.0.0
+Other	Firefox 59.0	Windows 10.0.0
+Other	Firefox 60.0	Windows 10.0.0
+Other	Edge 15.15063	Windows 10.0.0
+Other	Edge 16.16299	Windows 10.0.0
+Other	Edge 17.17134	Windows 10.0.0
+Other	Edge 18.17763	Windows 10.0.0
+Other	Chrome 65.0	Windows 10.0.0
+Other	Chrome 70.0	Windows 10.0.0
+Other	Edge 18.18362	Windows 10.0.0
+Other	Edge 18.18995	Windows 10.0.0
+Other	Edge 18.19493	Windows 10.0.0
+Other	Chrome 70.0	Windows 10.0.0
+Other	Chrome 71.0	Windows 10.0.0
+Other	Chrome 73.0	Windows 10.0.0
+Other	Chrome 74.0	Windows 10.0.0
+Other	Chrome 75.0	Windows 10.0.0
+Other	Chrome 76.0	Windows 10.0.0
+Other	Vivaldi 2.7	Windows 10.0.0
+Other	Chrome 76.0	Windows 10.0.0
+Other	Opera 63.0	Windows 10.0.0
+Other	Chrome 77.0	Windows 10.0.0
+Other	Chrome 77.0	Windows 10.0.0
+Other	Edge 79.0	Windows 10.0.0
+Other	Edge 18.18362	Windows 10.0.0
+Other	Edge 18.18363	Windows 10.0.0
+Other	Edge 18.18362	Windows 10.0.0
+Other	Firefox 61.0	Windows 10.0.0
+Other	Firefox 63.0	Windows 10.0.0
+Other	Firefox 67.0	Windows 10.0.0
+Other	Firefox 68.0	Windows 10.0.0
+Other	Firefox 69.0	Windows 10.0.0
+Other	Firefox 69.0	Windows 10.0.0
+Other	Chrome 49.0	Windows XP.0.0
+Other	Chrome 49.0	Windows Vista.0.0
+Other	Chrome 49.0	Windows Vista.0.0
+Other	Chrome 76.0	Windows 7.0.0
+Other	Chrome 77.0	Windows 7.0.0
+Other	Chrome 77.0	Windows 7.0.0
+Other	Coc Coc 80.0	Windows 7.0.0
+Other	Coc Coc 82.0	Windows 7.0.0
+Other	IE 11.0	Windows 7.0.0
+Other	Chrome 67.0	Windows 7.0.0
+Other	Chrome 70.0	Windows 7.0.0
+Other	Chrome 72.0	Windows 7.0.0
+Other	Chrome 74.0	Windows 7.0.0
+Other	Chrome 75.0	Windows 7.0.0
+Other	Chrome 76.0	Windows 7.0.0
+Other	Chrome 76.0	Windows 7.0.0
+Other	Chrome 77.0	Windows 7.0.0
+Other	Waterfox 56.2	Windows 7.0.0
+Other	Firefox 60.0	Windows 7.0.0
+Other	Firefox 63.0	Windows 7.0.0
+Other	Firefox 68.0	Windows 7.0.0
+Other	Firefox 69.0	Windows 7.0.0
+Other	Firefox 69.0	Windows 7.0.0
+Other	Chrome 77.0	Windows 8.0.0
+Other	Firefox 69.0	Windows 8.0.0
+Other	Chrome 77.0	Windows 8.1.0
+Other	IE 11.0	Windows RT 8.1.0
+Other	IE 11.0	Windows 8.1.0
+Other	IE 11.0	Windows 8.1.0
+Other	Chrome 63.0	Windows 8.1.0
+Other	Chrome 64.0	Windows 8.1.0
+Other	Chrome 76.0	Windows 8.1.0
+Other	Chrome 76.0	Windows 8.1.0
+Other	Chrome 77.0	Windows 8.1.0
+Other	Firefox 69.0	Windows 8.1.0
+Other	Firefox 69.0	Windows 8.1.0
+Other	Chrome 72.0	Windows 10.0.0
+Other	Chrome 77.0	Chrome OS 12371.75.0
+Other	Chrome 76.0	Chrome OS 12239.92.0
+Other	Chrome 69.0	Chrome OS 10895.78.0
+Other	Chrome 70.0	Chrome OS 11021.81.0
+Other	Chrome 74.0	Chrome OS 11895.118.0
+Other	Chrome 76.0	Chrome OS 12239.92.0
+Other	Chrome 76.0	Chrome OS 12239.92.1
+Other	Chrome 76.0	Chrome OS 12239.92.4
+Other	Chrome 77.0	Chrome OS 12371.46.0
+Other	Chrome 77.0	Chrome OS 12371.65.0
+Other	Chrome 75.0	Linux 0.0.0
+Other	Chrome 77.0	Linux 0.0.0
+Other	Samsung Internet 10.1	Linux 0.0.0
+Other	Chrome 66.0	Linux 0.0.0
+Other	Chrome 66.0	Linux 0.0.0
+Other	Chrome 66.0	Linux 0.0.0
+Other	Chrome 66.0	Linux 0.0.0
+Other	Chrome 66.0	Linux 0.0.0
+Other	Firefox 65.0	Ubuntu 0.0.0
+Other	Firefox 66.0	Ubuntu 0.0.0
+Other	Firefox 67.0	Ubuntu 0.0.0
+iPad	Google 22.0	iOS 10.3.3
+iPad	Chrome Mobile iOS 71.0	iOS 10.3.3
+iPad	Firefox iOS 14.0	iOS 10.3.3
+iPad	Mobile Safari UI/WKWebView 603.3	iOS 10.3.3
+iPad	Facebook 240.0	iOS 10.3.3
+iPad	Mobile Safari 10.0	iOS 10.3.3
+iPad	Mobile Safari 10.0	iOS 10.3.4
+iPad	Chrome Mobile iOS 76.0	iOS 11.1.0
+iPad	Chrome Mobile iOS 76.0	iOS 11.1.2
+iPad	Mobile Safari 11.0	iOS 11.2.1
+iPad	Mobile Safari 11.0	iOS 11.2.2
+iPad	Mobile Safari 11.0	iOS 11.2.6
+iPad	Mobile Safari 11.0	iOS 11.3.0
+iPad	Mobile Safari 11.0	iOS 11.4.0
+iPad	Mobile Safari UI/WKWebView 605.1	iOS 11.4.1
+iPad	Mobile Safari 11.0	iOS 11.4.1
+iPad	Google 83.0	iOS 12.0.0
+iPad	Mobile Safari 12.0	iOS 12.0.0
+iPad	Chrome Mobile iOS 75.0	iOS 12.1.0
+iPad	Chrome Mobile iOS 76.0	iOS 12.1.0
+iPad	Mobile Safari UI/WKWebView 605.1	iOS 12.1.0
+iPad	Mobile Safari 12.0	iOS 12.1.0
+iPad	Mobile Safari 12.0	iOS 12.1.1
+iPad	Google 48.0	iOS 12.1.4
+iPad	Mobile Safari UI/WKWebView 605.1	iOS 12.1.4
+iPad	Mobile Safari 12.0	iOS 12.1.4
+iPad	Chrome Mobile iOS 76.0	iOS 12.2.0
+iPad	Mobile Safari UI/WKWebView 605.1	iOS 12.2.0
+iPad	Mobile Safari 12.1	iOS 12.2.0
+iPad	Chrome Mobile iOS 77.0	iOS 12.3.0
+iPad	Google 83.0	iOS 12.3.0
+iPad	Mobile Safari 12.1	iOS 12.3.0
+iPad	Mobile Safari UI/WKWebView 605.1	iOS 12.3.1
+iPad	Mobile Safari 12.1	iOS 12.3.1
+iPad	Chrome Mobile iOS 76.0	iOS 12.4.0
+iPad	Chrome Mobile iOS 76.0	iOS 12.4.0
+iPad	Chrome Mobile iOS 77.0	iOS 12.4.0
+iPad	Chrome Mobile iOS 77.0	iOS 12.4.0
+iPad	Chrome Mobile iOS 77.0	iOS 12.4.0
+iPad	Google 74.0	iOS 12.4.0
+iPad	Google 83.0	iOS 12.4.0
+iPad	Mobile Safari UI/WKWebView 605.1	iOS 12.4.0
+iPad	Mobile Safari 12.1	iOS 12.4.0
+iPad	Chrome Mobile iOS 67.0	iOS 12.4.1
+iPad	Firefox iOS 19.0	iOS 12.4.1
+iPad	Mobile Safari UI/WKWebView 605.1	iOS 12.4.1
+iPad	Facebook 605.1	iOS 12.4.1
+iPad	Facebook 605.1	iOS 12.4.1
+iPad	Facebook 605.1	iOS 12.4.1
+iPad	Facebook 605.1	iOS 12.4.1
+iPad	Mobile Safari 12.1	iOS 12.4.1
+iPad	Mobile Safari 6.0	iOS 6.1.3
+iPad	Mobile Safari 8.0	iOS 8.0.0
+iPad	Mobile Safari 8.0	iOS 8.2.0
+iPad	Google 23.1	iOS 8.4.0
+iPad	Mobile Safari 9.0	iOS 9.3.2
+iPad	Mobile Safari 9.0	iOS 9.3.5
+iPhone	Mobile Safari 10.0	iOS 10.2.0
+iPhone	Facebook 603.3	iOS 10.3.3
+iPhone	Google 68.0	iOS 10.3.4
+iPhone	Mobile Safari 10.0	iOS 10.3.4
+iPhone	Mobile Safari 11.0	iOS 11.0.3
+iPhone	Mobile Safari 11.0	iOS 11.1.1
+iPhone	Mobile Safari 11.0	iOS 11.1.2
+iPhone	Mobile Safari 11.0	iOS 11.2.1
+iPhone	Facebook 207.0	iOS 11.2.6
+iPhone	Chrome Mobile iOS 76.0	iOS 11.3.0
+iPhone	Facebook 605.1	iOS 11.3.0
+iPhone	Mobile Safari 11.0	iOS 11.3.0
+iPhone	Google 83.0	iOS 11.4.0
+iPhone	Mobile Safari 11.0	iOS 11.4.0
+iPhone	Google 74.1	iOS 11.4.1
+iPhone	Mobile Safari 11.0	iOS 11.4.1
+iPhone	Mobile Safari 12.0	iOS 12.0.0
+iPhone	Mobile Safari 12.0	iOS 12.1.0
+iPhone	Mobile Safari 12.0	iOS 12.1.1
+iPhone	Google 74.1	iOS 12.1.2
+iPhone	Facebook 605.1	iOS 12.1.2
+iPhone	Mobile Safari 12.0	iOS 12.1.2
+iPhone	Mobile Safari 12.0	iOS 12.1.3
+iPhone	Google 74.1	iOS 12.1.4
+iPhone	Mobile Safari 12.0	iOS 12.1.4
+iPhone	Chrome Mobile iOS 72.0	iOS 12.2.0
+iPhone	Chrome Mobile iOS 76.0	iOS 12.2.0
+iPhone	Chrome Mobile iOS 77.0	iOS 12.2.0
+iPhone	Facebook 605.1	iOS 12.2.0
+iPhone	Facebook 605.1	iOS 12.2.0
+iPhone	Mobile Safari 12.1	iOS 12.2.0
+iPhone	Chrome Mobile iOS 77.0	iOS 12.3.0
+iPhone	Google 83.0	iOS 12.3.0
+iPhone	Mobile Safari 12.1	iOS 12.3.0
+iPhone	Google 79.0	iOS 12.3.1
+iPhone	Mobile Safari UI/WKWebView 605.1	iOS 12.3.1
+iPhone	DuckDuckGo Mobile 7.1	iOS 12.3.1
+iPhone	Facebook 605.1	iOS 12.3.1
+iPhone	Facebook 605.1	iOS 12.3.1
+iPhone	Facebook 605.1	iOS 12.3.1
+iPhone	Mobile Safari 12.1	iOS 12.3.1
+iPhone	Mobile Safari 12.1	iOS 12.3.2
+iPhone	Chrome Mobile iOS 69.0	iOS 12.4.0
+iPhone	Chrome Mobile iOS 73.0	iOS 12.4.0
+iPhone	Chrome Mobile iOS 75.0	iOS 12.4.0
+iPhone	Chrome Mobile iOS 76.0	iOS 12.4.0
+iPhone	Chrome Mobile iOS 77.0	iOS 12.4.0
+iPhone	Chrome Mobile iOS 77.0	iOS 12.4.0
+iPhone	Google 81.0	iOS 12.4.0
+iPhone	Google 82.1	iOS 12.4.0
+iPhone	Google 83.0	iOS 12.4.0
+iPhone	Facebook 605.1	iOS 12.4.0
+iPhone	Facebook 605.1	iOS 12.4.0
+iPhone	Facebook 605.1	iOS 12.4.0
+iPhone	Facebook 605.1	iOS 12.4.0
+iPhone	Mobile Safari 12.1	iOS 12.4.0
+iPhone	Google 74.1	iOS 12.4.1
+iPhone	Mobile Safari UI/WKWebView 605.1	iOS 12.4.1
+iPhone	Instagram 89.0	iOS 12.4.1
+iPhone	Facebook 240.0	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Mobile Safari 12.1	iOS 12.4.1
+iPhone	Mobile Safari 12.4	iOS 12.4.1
+iPhone	Mobile Safari UI/WKWebView 605.1	iOS 12.4.2
+iPhone	Mobile Safari 12.1	iOS 12.4.2
+iPhone	Chrome Mobile iOS 77.0	iOS 13.0.0
+iPhone	Facebook 605.1	iOS 13.0.0
+iPhone	Facebook 605.1	iOS 13.0.0
+iPhone	Facebook 605.1	iOS 13.0.0
+iPhone	Facebook 605.1	iOS 13.0.0
+iPhone	Facebook 605.1	iOS 13.0.0
+iPhone	Facebook 605.1	iOS 13.0.0
+iPhone	Mobile Safari 13.0	iOS 13.0.0
+iPhone	Chrome Mobile iOS 76.0	iOS 13.1.0
+iPhone	Chrome Mobile iOS 77.0	iOS 13.1.0
+iPhone	Chrome Mobile iOS 77.0	iOS 13.1.0
+iPhone	Firefox iOS 8.1	iOS 13.1.0
+iPhone	Google 83.0	iOS 13.1.0
+iPhone	Mobile Safari UI/WKWebView 605.1	iOS 13.1.0
+iPhone	DuckDuckGo Mobile 7.1	iOS 13.1.0
+iPhone	Facebook 605.1	iOS 13.1.0
+iPhone	Facebook 605.1	iOS 13.1.0
+iPhone	Facebook 605.1	iOS 13.1.0
+iPhone	Facebook 605.1	iOS 13.1.0
+iPhone	Facebook 605.1	iOS 13.1.0
+iPhone	Mobile Safari 13.0	iOS 13.1.0
+iPhone	Mobile Safari UI/WKWebView 605.1	iOS 13.1.1
+iPhone	Facebook 605.1	iOS 13.1.1
+iPhone	Facebook 605.1	iOS 13.1.1
+iPhone	Facebook 605.1	iOS 13.1.1
+iPhone	Facebook 605.1	iOS 13.1.1
+iPhone	Mobile Safari 13.0	iOS 13.1.1
+iPhone	Mobile Safari UI/WKWebView 605.1	iOS 13.1.2
+iPhone	Facebook 605.1	iOS 13.1.2
+iPhone	Mobile Safari 13.0	iOS 13.1.2
diff --git a/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.sh b/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.sh
new file mode 100755
index 00000000000..f783a0db60f
--- /dev/null
+++ b/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.sh
@@ -0,0 +1,87 @@
+#!/usr/bin/env bash
+
+# Tags: use-vectorscan, no-fasttest, no-parallel
+
+CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CURDIR"/../shell_config.sh
+
+user_files_path=$(clickhouse-client --query "select _path,_file from file('nonexist.txt', 'CSV', 'val1 char')" 2>&1 | grep Exception | awk '{gsub("/nonexist.txt","",$9); print $9}')
+
+mkdir -p $user_files_path/test_02504
+
+cp $CURDIR/data_ua_parser/os.yaml ${user_files_path}/test_02504/
+cp $CURDIR/data_ua_parser/browser.yaml ${user_files_path}/test_02504/
+cp $CURDIR/data_ua_parser/device.yaml ${user_files_path}/test_02504/
+
+$CLICKHOUSE_CLIENT -n --query="
+drop dictionary if exists regexp_os;
+drop dictionary if exists regexp_browser;
+drop dictionary if exists regexp_device;
+drop table if exists user_agents;
+create dictionary regexp_os
+(
+    regex String,
+    os_replacement String default 'Other',
+    os_v1_replacement String default '0',
+    os_v2_replacement String default '0',
+    os_v3_replacement String default '0',
+    os_v4_replacement String default '0'
+)
+PRIMARY KEY(regex)
+SOURCE(YAMLRegExpTree(PATH '${user_files_path}/test_02504/os.yaml'))
+LIFETIME(0)
+LAYOUT(regexp_tree);
+
+create dictionary regexp_browser
+(
+    regex String,
+    family_replacement String default 'Other',
+    v1_replacement String default '0',
+    v2_replacement String default '0'
+)
+PRIMARY KEY(regex)
+SOURCE(YAMLRegExpTree(PATH '${user_files_path}/test_02504/browser.yaml'))
+LIFETIME(0)
+LAYOUT(regexp_tree);
+
+create dictionary regexp_device
+(
+    regex String,
+    device_replacement String default 'Other',
+    brand_replacement String,
+    model_replacement String
+)
+PRIMARY KEY(regex)
+SOURCE(YAMLRegExpTree(PATH '${user_files_path}/test_02504/device.yaml'))
+LIFETIME(0)
+LAYOUT(regexp_tree);
+
+create table user_agents
+(
+    ua String
+)
+Engine = Log();
+"
+
+$CLICKHOUSE_CLIENT -n --query="
+insert into user_agents select ua from input('ua String') FORMAT LineAsString" < $CURDIR/data_ua_parser/useragents.txt
+
+$CLICKHOUSE_CLIENT -n --query="
+select device,
+concat(tupleElement(browser, 1), ' ', tupleElement(browser, 2), '.', tupleElement(browser, 3)) as browser ,
+concat(tupleElement(os, 1), ' ', tupleElement(os, 2), '.', tupleElement(os, 3), '.', tupleElement(os, 4)) as os
+from (
+     select dictGet('regexp_os', ('os_replacement', 'os_v1_replacement', 'os_v2_replacement', 'os_v3_replacement'), ua) os,
+     dictGet('regexp_browser', ('family_replacement', 'v1_replacement', 'v2_replacement'), ua) as browser,
+     dictGet('regexp_device', 'device_replacement', ua) device from user_agents);
+"
+
+$CLICKHOUSE_CLIENT -n --query="
+drop dictionary if exists regexp_os;
+drop dictionary if exists regexp_browser;
+drop dictionary if exists regexp_device;
+drop table if exists user_agents;
+"
+
+rm -rf "$USER_FILES_PATH/test_02504"
diff --git a/tests/queries/0_stateless/02504_regexp_dictionary_yaml_source.reference b/tests/queries/0_stateless/02504_regexp_dictionary_yaml_source.reference
index d4e23bf981c..6d5372cc484 100644
--- a/tests/queries/0_stateless/02504_regexp_dictionary_yaml_source.reference
+++ b/tests/queries/0_stateless/02504_regexp_dictionary_yaml_source.reference
@@ -1,5 +1,5 @@
 ('TencentOS','123.45.67')
-('Andriod','12')
-('Andriod','default')
-('Andriod','default')
+('Android','12')
+('Android','default')
+('Android','default')
 (true,'61f0c404-5cb3-11e7-907b-a6006ad3dba0','2023-01-01','2023-01-01 01:01:01',[1,2,3,-1,-2,-3])
diff --git a/tests/queries/0_stateless/02504_regexp_dictionary_yaml_source.sh b/tests/queries/0_stateless/02504_regexp_dictionary_yaml_source.sh
index f09409bb90b..8d80f9f1fea 100755
--- a/tests/queries/0_stateless/02504_regexp_dictionary_yaml_source.sh
+++ b/tests/queries/0_stateless/02504_regexp_dictionary_yaml_source.sh
@@ -18,7 +18,7 @@ cat > "$yaml" <<EOL
   version: '\1'
 
 - regexp: '\d+/tclwebkit(?:\d+[\.\d]*)'
-  name: 'Andriod'
+  name: 'Android'
   versions:
     - regexp: '33/tclwebkit'
       version: '13'
@@ -56,7 +56,7 @@ cat > "$yaml" <<EOL
   version: '\1'
 
 - regexp: '\d+/tclwebkit(?:\d+[\.\d]*)'
-  name: 'Andriod'
+  name: 'Android'
   versions:
     - regexp: '33/tclwebkit'
       version: '13'
diff --git a/tests/queries/0_stateless/data_ua_parser/browser.yaml b/tests/queries/0_stateless/data_ua_parser/browser.yaml
new file mode 100644
index 00000000000..3596589c94e
--- /dev/null
+++ b/tests/queries/0_stateless/data_ua_parser/browser.yaml
@@ -0,0 +1,1409 @@
+- family_replacement: $1
+  regex: (GeoEvent Server) (\d+)(?:\.(\d+)(?:\.(\d+)|)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: '(ArcGIS Pro)(?: (\d+)\.(\d+)\.([^ ]+)|)'
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: ArcMap
+  regex: ArcGIS Client Using WinInet
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Operations Dashboard for ArcGIS
+  regex: (OperationsDashboard)-(?:Windows)-(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: ArcGIS Earth
+  regex: (arcgisearth)/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: ArcGIS Earth
+  regex: com.esri.(earth).phone/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Explorer for ArcGIS
+  regex: (arcgis-explorer)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Collector for ArcGIS
+  regex: arcgis-(collector|aurora)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Workforce for ArcGIS
+  regex: (arcgis-workforce)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1 for ArcGIS
+  regex: (Collector|Explorer|Workforce)-(?:Android|iOS)-(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1 for ArcGIS
+  regex: (Explorer|Collector)/(\d+) CFNetwork
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: ArcGIS Runtime SDK for $1
+  regex: ArcGISRuntime-(Android|iOS|NET|Qt)/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: ArcGIS Runtime SDK for $1
+  regex: ArcGIS\.?(iOS|Android|NET|Qt)(?:-|\.)(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: ArcGIS Runtime SDK for $1
+  regex: ArcGIS\.Runtime\.(Qt)\.(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(Luminary)[Stage]+/(\d+) CFNetwork
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (ESPN)[%20| ]+Radio/(\d+)\.(\d+)\.(\d+) CFNetwork
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: AntennaPod
+  regex: (Antenna)/(\d+) CFNetwork
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (TopPodcasts)Pro/(\d+) CFNetwork
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (MusicDownloader)Lite/(\d+)\.(\d+)\.(\d+) CFNetwork
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(.{0,200})-iPad\/(\d+)(?:\.(\d+)|)(?:\.(\d+)|)(?:\.(\d+)|) CFNetwork
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(.{0,200})-iPhone/(\d+)(?:\.(\d+)|)(?:\.(\d+)|)(?:\.(\d+)|) CFNetwork
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(.{0,200})/(\d+)(?:\.(\d+)|)(?:\.(\d+)|)(?:\.(\d+)|) CFNetwork
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(Luminary)/(\d+)(?:\.(\d+)|)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: ESPN
+  regex: (espn\.go)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: ESPN
+  regex: (espnradio\.com)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: ESPN
+  regex: ESPN APP$
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: AudioBoom
+  regex: (audioboom\.com)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ' (Rivo) RHYTHM'
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: CFNetwork
+  regex: (CFNetwork)(?:/(\d+)\.(\d+)(?:\.(\d+)|)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: PingdomBot
+  regex: (Pingdom\.com_bot_version_)(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: PingdomBot
+  regex: (PingdomTMS)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: WebPageTest.org bot
+  regex: ' (PTST)/(\d+)(?:\.(\d+)|)$'
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: X11; (Datanyze); Linux
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: NewRelicPingerBot
+  regex: (NewRelicPinger)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Tableau
+  regex: (Tableau)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Adobe CreativeCloud
+  regex: AppleWebKit/\d{1,10}\.\d{1,10}.{0,200} Safari.{0,200} (CreativeCloud)/(\d+)\.(\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Salesforce)(?:.)\/(\d+)\.(\d?)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: StatusCakeBot
+  regex: (\(StatusCake\))
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: FacebookBot
+  regex: (facebookexternalhit)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: GooglePlusBot
+  regex: Google.{0,50}/\+/web/snippet
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: GmailImageProxy
+  regex: via ggpht\.com GoogleImageProxy
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: YahooMailProxy
+  regex: YahooMailProxy; https://help\.yahoo\.com/kb/yahoo-mail-proxy-SLN28749\.html
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Twitterbot
+  regex: (Twitterbot)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: /((?:Ant-|)Nutch|[A-z]+[Bb]ot|[A-z]+[Ss]pider|Axtaris|fetchurl|Isara|ShopSalad|Tailsweep)[
+    \-](\d+)(?:\.(\d+)|)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: \b(008|Altresium|Argus|BaiduMobaider|BoardReader|DNSGroup|DataparkSearch|EDI|Goodzer|Grub|INGRID|Infohelfer|LinkedInBot|LOOQ|Nutch|OgScrper|Pandora|PathDefender|Peew|PostPost|Steeler|Twitterbot|VSE|WebCrunch|WebZIP|Y!J-BR[A-Z]|YahooSeeker|envolk|sproose|wminer)/(\d+)(?:\.(\d+)|)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: MSIECrawler
+  regex: (MSIE) (\d+)\.(\d+)([a-z]\d|[a-z]|);.{0,200} MSIECrawler
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (DAVdroid)/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Google-HTTP-Java-Client|Apache-HttpClient|PostmanRuntime|Go-http-client|scalaj-http|http%20client|Python-urllib|HttpMonitor|TLSProber|WinHTTP|JNLP|okhttp|aihttp|reqwest|axios|unirest-(?:java|python|ruby|nodejs|php|net))(?:[
+    /](\d+)(?:\.(\d+)|)(?:\.(\d+)|)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Pinterestbot
+  regex: (Pinterest(?:bot|))/(\d+)(?:\.(\d+)|)(?:\.(\d+)|)[;\s(]+\+https://www.pinterest.com/bot.html
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: '(CSimpleSpider|Cityreview Robot|CrawlDaddy|CrawlFire|Finderbots|Index crawler|Job
+    Roboter|KiwiStatus Spider|Lijit Crawler|QuerySeekerSpider|ScollSpider|Trends Crawler|USyd-NLP-Spider|SiteCat
+    Webbot|BotName\/\$BotVersion|123metaspider-Bot|1470\.net crawler|50\.nu|8bo Crawler
+    Bot|Aboundex|Accoona-[A-z]{1,30}-Agent|AdsBot-Google(?:-[a-z]{1,30}|)|altavista|AppEngine-Google|archive.{0,30}\.org_bot|archiver|Ask
+    Jeeves|[Bb]ai[Dd]u[Ss]pider(?:-[A-Za-z]{1,30})(?:-[A-Za-z]{1,30}|)|bingbot|BingPreview|blitzbot|BlogBridge|Bloglovin|BoardReader
+    Blog Indexer|BoardReader Favicon Fetcher|boitho.com-dc|BotSeer|BUbiNG|\b\w{0,30}favicon\w{0,30}\b|\bYeti(?:-[a-z]{1,30}|)|Catchpoint(?:
+    bot|)|[Cc]harlotte|Checklinks|clumboot|Comodo HTTP\(S\) Crawler|Comodo-Webinspector-Crawler|ConveraCrawler|CRAWL-E|CrawlConvera|Daumoa(?:-feedfetcher|)|Feed
+    Seeker Bot|Feedbin|findlinks|Flamingo_SearchEngine|FollowSite Bot|furlbot|Genieo|gigabot|GomezAgent|gonzo1|(?:[a-zA-Z]{1,30}-|)Googlebot(?:-[a-zA-Z]{1,30}|)|Google
+    SketchUp|grub-client|gsa-crawler|heritrix|HiddenMarket|holmes|HooWWWer|htdig|ia_archiver|ICC-Crawler|Icarus6j|ichiro(?:/mobile|)|IconSurf|IlTrovatore(?:-Setaccio|)|InfuzApp|Innovazion
+    Crawler|InternetArchive|IP2[a-z]{1,30}Bot|jbot\b|KaloogaBot|Kraken|Kurzor|larbin|LEIA|LesnikBot|Linguee
+    Bot|LinkAider|LinkedInBot|Lite Bot|Llaut|lycos|Mail\.RU_Bot|masscan|masidani_bot|Mediapartners-Google|Microsoft
+    .{0,30} Bot|mogimogi|mozDex|MJ12bot|msnbot(?:-media {0,2}|)|msrbot|Mtps Feed Aggregation
+    System|netresearch|Netvibes|NewsGator[^/]{0,30}|^NING|Nutch[^/]{0,30}|Nymesis|ObjectsSearch|OgScrper|Orbiter|OOZBOT|PagePeeker|PagesInventory|PaxleFramework|Peeplo
+    Screenshot Bot|PHPCrawl|PlantyNet_WebRobot|Pompos|Qwantify|Read%20Later|Reaper|RedCarpet|Retreiver|Riddler|Rival
+    IQ|scooter|Scrapy|Scrubby|searchsight|seekbot|semanticdiscovery|SemrushBot|Simpy|SimplePie|SEOstats|SimpleRSS|SiteCon|Slackbot-LinkExpanding|Slack-ImgProxy|Slurp|snappy|Speedy
+    Spider|Squrl Java|Stringer|TheUsefulbot|ThumbShotsBot|Thumbshots\.ru|Tiny Tiny
+    RSS|Twitterbot|WhatsApp|URL2PNG|Vagabondo|VoilaBot|^vortex|Votay bot|^voyager|WASALive.Bot|Web-sniffer|WebThumb|WeSEE:[A-z]{1,30}|WhatWeb|WIRE|WordPress|Wotbox|www\.almaden\.ibm\.com|Xenu(?:.s|)
+    Link Sleuth|Xerka [A-z]{1,30}Bot|yacy(?:bot|)|YahooSeeker|Yahoo! Slurp|Yandex\w{1,30}|YodaoBot(?:-[A-z]{1,30}|)|YottaaMonitor|Yowedo|^Zao|^Zao-Crawler|ZeBot_www\.ze\.bz|ZooShot|ZyBorg|ArcGIS
+    Hub Indexer)(?:[ /]v?(\d+)(?:\.(\d+)(?:\.(\d+)|)|)|)'
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: \b(Boto3?|JetS3t|aws-(?:cli|sdk-(?:cpp|go|java|nodejs|ruby2?|dotnet-(?:\d{1,2}|core)))|s3fs)/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (FME)\/(\d+\.\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (QGIS)\/(\d)\.?0?(\d{1,2})\.?0?(\d{1,2})
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (JOSM)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Tygron Platform) \((\d+)\.(\d+)\.(\d+(?:\.\d+| RC \d+\.\d+))
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Facebook Messenger
+  regex: \[(FBAN/MessengerForiOS|FB_IAB/MESSENGER);FBAV/(\d+)(?:\.(\d+)(?:\.(\d+)(?:\.(\d+)|)|)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Facebook
+  regex: \[FB.{0,300};(FBAV)/(\d+)(?:\.(\d+)|)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Facebook
+  regex: \[FB.{0,300};
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^.{0,200}?(?:\/[A-Za-z0-9\.]{0,50}|) {0,2}([A-Za-z0-9 \-_\!\[\]:]{0,50}(?:[Aa]rchiver|[Ii]ndexer|[Ss]craper|[Bb]ot|[Ss]pider|[Cc]rawl[a-z]{0,50}))[/
+    ](\d+)(?:\.(\d+)(?:\.(\d+)|)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^.{0,200}?((?:[A-Za-z][A-Za-z0-9 -]{0,50}|)[^C][^Uu][Bb]ot)\b(?:(?:[ /]|
+    v)(\d+)(?:\.(\d+)|)(?:\.(\d+)|)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: '^.{0,200}?((?:[A-z0-9]{1,50}|[A-z\-]{1,50} ?|)(?: the |)(?:[Ss][Pp][Ii][Dd][Ee][Rr]|[Ss]crape|[Cc][Rr][Aa][Ww][Ll])[A-z0-9]{0,50})(?:(?:[
+    /]| v)(\d+)(?:\.(\d+)|)(?:\.(\d+)|)|)'
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (HbbTV)/(\d+)\.(\d+)\.(\d+) \(
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Chimera|SeaMonkey|Camino|Waterfox)/(\d+)\.(\d+)\.?([ab]?\d+[a-z]*|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Sailfish Browser
+  regex: (SailfishBrowser)/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: \[(Pinterest)/[^\]]{1,50}\]
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: '(Pinterest)(?: for Android(?: Tablet|)|)/(\d+)(?:\.(\d+)|)(?:\.(\d+)|)'
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: Mozilla.{1,200}Mobile.{1,100}(Instagram).(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: Mozilla.{1,200}Mobile.{1,100}(Flipboard).(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: Mozilla.{1,200}Mobile.{1,100}(Flipboard-Briefing).(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: Mozilla.{1,200}Mobile.{1,100}(Onefootball)\/Android.(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Snapchat)\/(\d+)\.(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Twitter
+  regex: (Twitter for (?:iPhone|iPad)|TwitterAndroid)(?:\/(\d+)\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Spider
+  regex: Mozilla.{1,100}Mobile.{1,100}AspiegelBot
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Spider
+  regex: AspiegelBot
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Basilisk
+  regex: (Firefox)/(\d+)\.(\d+) Basilisk/(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Pale Moon
+  regex: (PaleMoon)/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Firefox Mobile
+  regex: (Fennec)/(\d+)\.(\d+)\.?([ab]?\d+[a-z]*)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Firefox Mobile
+  regex: (Fennec)/(\d+)\.(\d+)(pre)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Firefox Mobile
+  regex: (Fennec)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Firefox Mobile
+  regex: (?:Mobile|Tablet);.{0,200}(Firefox)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Firefox ($1)
+  regex: (Namoroka|Shiretoko|Minefield)/(\d+)\.(\d+)\.(\d+(?:pre|))
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Firefox Alpha
+  regex: (Firefox)/(\d+)\.(\d+)(a\d+[a-z]*)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Firefox Beta
+  regex: (Firefox)/(\d+)\.(\d+)(b\d+[a-z]*)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Firefox Alpha
+  regex: (Firefox)-(?:\d+\.\d+|)/(\d+)\.(\d+)(a\d+[a-z]*)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Firefox Beta
+  regex: (Firefox)-(?:\d+\.\d+|)/(\d+)\.(\d+)(b\d+[a-z]*)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Firefox ($1)
+  regex: (Namoroka|Shiretoko|Minefield)/(\d+)\.(\d+)([ab]\d+[a-z]*|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: MicroB
+  regex: (Firefox).{0,200}Tablet browser (\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (MozillaDeveloperPreview)/(\d+)\.(\d+)([ab]\d+[a-z]*|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Firefox iOS
+  regex: (FxiOS)/(\d+)\.(\d+)(\.(\d+)|)(\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Flock)/(\d+)\.(\d+)(b\d+?)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (RockMelt)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Netscape
+  regex: (Navigator)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Netscape
+  regex: (Navigator)/(\d+)\.(\d+)([ab]\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Netscape
+  regex: (Netscape6)/(\d+)\.(\d+)\.?([ab]?\d+|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: My Internet Browser
+  regex: (MyIBrow)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: UC Browser
+  regex: (UC? ?Browser|UCWEB|U3)[ /]?(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Opera Tablet).{0,200}Version/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Opera Mini)(?:/att|)/?(\d+|)(?:\.(\d+)|)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Opera Mobile
+  regex: (Opera)/.{1,100}Opera Mobi.{1,100}Version/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Opera Mobile
+  regex: (Opera)/(\d+)\.(\d+).{1,100}Opera Mobi
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Opera Mobile
+  regex: Opera Mobi.{1,100}(Opera)(?:/|\s+)(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Opera Mobile
+  regex: Opera Mobi
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Opera)/9.80.{0,200}Version/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Opera Mobile
+  regex: (?:Mobile Safari).{1,300}(OPR)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Opera
+  regex: (?:Chrome).{1,300}(OPR)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Opera Coast
+  regex: (Coast)/(\d+).(\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Opera Mini
+  regex: (OPiOS)/(\d+).(\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Opera Neon
+  regex: Chrome/.{1,200}( MMS)/(\d+).(\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: webOS Browser
+  regex: (hpw|web)OS/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: LuaKit
+  regex: (luakit)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Snowshoe)/(\d+)\.(\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: Gecko/\d+ (Lightning)/(\d+)\.(\d+)\.?((?:[ab]?\d+[a-z]*)|(?:\d*))
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Swiftfox
+  regex: (Firefox)/(\d+)\.(\d+)\.(\d+(?:pre|)) \(Swiftfox\)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Swiftfox
+  regex: (Firefox)/(\d+)\.(\d+)([ab]\d+[a-z]*|) \(Swiftfox\)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Rekonq
+  regex: (rekonq)/(\d+)\.(\d+)(?:\.(\d+)|) Safari
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Rekonq
+  regex: rekonq
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Conkeror
+  regex: (conkeror|Conkeror)/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Konqueror
+  regex: (konqueror)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (WeTab)-Browser
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Comodo Dragon
+  regex: (Comodo_Dragon)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Symphony) (\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: NetFront NX
+  regex: PLAYSTATION 3.{1,200}WebKit
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: NetFront
+  regex: PLAYSTATION 3
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: NetFront
+  regex: (PlayStation Portable)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: NetFront NX
+  regex: (PlayStation Vita)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: NetFront NX
+  regex: AppleWebKit.{1,200} (NX)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: NetFront NX
+  regex: (Nintendo 3DS)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Amazon Silk
+  regex: (Silk)/(\d+)\.(\d+)(?:\.([0-9\-]+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Puffin)/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Edge Mobile
+  regex: Windows Phone .{0,200}(Edge)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Edge Mobile
+  regex: (EdgiOS|EdgA)/(\d+)\.(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Samsung Internet
+  regex: (SamsungBrowser)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: "Seznam prohl\xED\u017Ee\u010D"
+  regex: (SznProhlizec)/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Coc Coc
+  regex: (coc_coc_browser)/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Baidu Browser
+  regex: (baidubrowser)[/\s](\d+)(?:\.(\d+)|)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Baidu Explorer
+  regex: (FlyFlow)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Maxthon
+  regex: (MxBrowser)/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Crosswalk)/(\d+)\.(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: LINE
+  regex: (Line)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: MiuiBrowser
+  regex: (MiuiBrowser)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Mint Browser
+  regex: (Mint Browser)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: TopBuzz
+  regex: (TopBuzz)/(\d+).(\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Google
+  regex: Mozilla.{1,200}Android.{1,200}(GSA)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: QQ Browser Mini
+  regex: (MQQBrowser/Mini)(?:(\d+)(?:\.(\d+)|)(?:\.(\d+)|)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: QQ Browser Mobile
+  regex: (MQQBrowser)(?:/(\d+)(?:\.(\d+)|)(?:\.(\d+)|)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: QQ Browser
+  regex: (QQBrowser)(?:/(\d+)(?:\.(\d+)\.(\d+)(?:\.(\d+)|)|)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: DuckDuckGo Mobile
+  regex: Mobile.{0,200}(DuckDuckGo)/(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Tenta Browser
+  regex: (Tenta/)(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Chrome Mobile WebView
+  regex: Version/.{1,300}(Chrome)/(\d+)\.(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Chrome Mobile WebView
+  regex: ; wv\).{1,300}(Chrome)/(\d+)\.(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Chrome Mobile
+  regex: (CrMo)/(\d+)\.(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Chrome Mobile iOS
+  regex: (CriOS)/(\d+)\.(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Chrome Mobile
+  regex: (Chrome)/(\d+)\.(\d+)\.(\d+)\.(\d+) Mobile(?:[ /]|$)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Chrome Mobile
+  regex: ' Mobile .{1,300}(Chrome)/(\d+)\.(\d+)\.(\d+)\.(\d+)'
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Chrome Frame
+  regex: (chromeframe)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Tizen Browser
+  regex: (SLP Browser)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Sogou Explorer
+  regex: (SE 2\.X) MetaSr (\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: RackspaceBot
+  regex: (Rackspace Monitoring)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (PRTG Network Monitor)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (PyAMF)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Yandex Browser
+  regex: (YaBrowser)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Mail.ru Chromium Browser
+  regex: (Chrome)/(\d+)\.(\d+)\.(\d+).{0,100} MRCHROME
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (AOL) (\d+)\.(\d+); AOLBuild (\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (PodCruncher|Downcast)[ /]?(\d+)(?:\.(\d+)|)(?:\.(\d+)|)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ' (BoxNotes)/(\d+)\.(\d+)\.(\d+)'
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Whale
+  regex: (Whale)/(\d+)\.(\d+)\.(\d+)\.(\d+) Mobile(?:[ /]|$)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Whale
+  regex: (Whale)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (1Password)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Ghost)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: PAN (GlobalProtect)/(\d+)\.(\d+)\.(\d+) .{1,100} \(X11; Linux x86_64\)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Slack Desktop Client
+  regex: (Slack_SSB)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: HipChat Desktop Client
+  regex: (HipChat)/?(\d+|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: \b(MobileIron|FireWeb|Jasmine|ANTGalio|Midori|Fresco|Lobo|PaleMoon|Maxthon|Lynx|OmniWeb|Dillo|Camino|Demeter|Fluid|Fennec|Epiphany|Shiira|Sunrise|Spotify|Flock|Netscape|Lunascape|WebPilot|NetFront|Netfront|Konqueror|SeaMonkey|Kazehakase|Vienna|Iceape|Iceweasel|IceWeasel|Iron|K-Meleon|Sleipnir|Galeon|GranParadiso|Opera
+    Mini|iCab|NetNewsWire|ThunderBrowse|Iris|UP\.Browser|Bunjalloo|Google Earth|Raven
+    for Mac|Openwave|MacOutlook|Electron|OktaMobile)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Outlook
+  regex: Microsoft Office Outlook 12\.\d+\.\d+|MSOffice 12
+  v1_replacement: '2007'
+  v2_replacement: $3
+- family_replacement: Outlook
+  regex: Microsoft Outlook 14\.\d+\.\d+|MSOffice 14
+  v1_replacement: '2010'
+  v2_replacement: $3
+- family_replacement: Outlook
+  regex: Microsoft Outlook 15\.\d+\.\d+
+  v1_replacement: '2013'
+  v2_replacement: $3
+- family_replacement: Outlook
+  regex: Microsoft Outlook (?:Mail )?16\.\d+\.\d+|MSOffice 16
+  v1_replacement: '2016'
+  v2_replacement: $3
+- family_replacement: $1
+  regex: Microsoft Office (Word) 2014
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Windows Live Mail
+  regex: Outlook-Express\/7\.0
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Airmail) (\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Thunderbird
+  regex: (Thunderbird)/(\d+)\.(\d+)(?:\.(\d+(?:pre|))|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Postbox
+  regex: (Postbox)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Barca
+  regex: (Barca(?:Pro)?)/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Lotus Notes
+  regex: (Lotus-Notes)/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Superhuman
+  regex: Superhuman
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Vivaldi)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Edge
+  regex: (Edge?)/(\d+)(?:\.(\d+)|)(?:\.(\d+)|)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Brave
+  regex: (brave)/(\d+)\.(\d+)\.(\d+) Chrome
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Iron
+  regex: (Chrome)/(\d+)\.(\d+)\.(\d+)[\d.]{0,100} Iron[^/]
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: '\b(Dolphin)(?: |HDCN/|/INT\-)(\d+)\.(\d+)(?:\.(\d+)|)'
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (HeadlessChrome)(?:/(\d+)\.(\d+)\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Evolution)/(\d+)\.(\d+)\.(\d+\.\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (RCM CardDAV plugin)/(\d+)\.(\d+)\.(\d+(?:-dev|))
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (bingbot|Bolt|AdobeAIR|Jasmine|IceCat|Skyfire|Midori|Maxthon|Lynx|Arora|IBrowse|Dillo|Camino|Shiira|Fennec|Phoenix|Flock|Netscape|Lunascape|Epiphany|WebPilot|Opera
+    Mini|Opera|NetFront|Netfront|Konqueror|Googlebot|SeaMonkey|Kazehakase|Vienna|Iceape|Iceweasel|IceWeasel|Iron|K-Meleon|Sleipnir|Galeon|GranParadiso|iCab|iTunes|MacAppStore|NetNewsWire|Space
+    Bison|Stainless|Orca|Dolfin|BOLT|Minimo|Tizen Browser|Polaris|Abrowser|Planetweb|ICE
+    Browser|mDolphin|qutebrowser|Otter|QupZilla|MailBar|kmail2|YahooMobileMail|ExchangeWebServices|ExchangeServicesClient|Dragon|Outlook-iOS-Android)/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Chromium|Chrome)/(\d+)\.(\d+)(?:\.(\d+)|)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: IE Mobile
+  regex: (IEMobile)[ /](\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (BacaBerita App)\/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(bPod|Pocket Casts|Player FM)$
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(AlexaMediaPlayer|VLC)/(\d+)\.(\d+)\.([^.\s]+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(AntennaPod|WMPlayer|Zune|Podkicker|Radio|ExoPlayerDemo|Overcast|PocketTunes|NSPlayer|okhttp|DoggCatcher|QuickNews|QuickTime|Peapod|Podcasts|GoldenPod|VLC|Spotify|Miro|MediaGo|Juice|iPodder|gPodder|Banshee)/(\d+)\.(\d+)(?:\.(\d+)|)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(Peapod|Liferea)/([^.\s]+)\.([^.\s]+|)\.?([^.\s]+|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(bPod|Player FM) BMID/(\S+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: '^(Podcast ?Addict)/v(\d+) '
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: PodcastAddict
+  regex: '^(Podcast ?Addict) '
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Replay) AV
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (VOX) Music Player
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (CITA) RSS Aggregator/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Pocket Casts)$
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Player FM)$
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (LG Player|Doppler|FancyMusic|MediaMonkey|Clementine) (\d+)\.(\d+)\.?([^.\s]+|)\.?([^.\s]+|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (philpodder)/(\d+)\.(\d+)\.?([^.\s]+|)\.?([^.\s]+|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Player FM|Pocket Casts|DoggCatcher|Spotify|MediaMonkey|MediaGo|BashPodder)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (QuickTime)\.(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Kinoma)(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: FancyMusic
+  regex: (Fancy) Cloud Music (\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: ESPN
+  regex: EspnDownloadManager
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: '(ESPN) Radio (\d+)\.(\d+)(?:\.(\d+)|) ?(?:rv:(\d+)|) '
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (podracer|jPodder) v ?(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (ZDM)/(\d+)\.(\d+)[; ]?
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Zune|BeyondPod) (\d+)(?:\.(\d+)|)[\);]
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (WMPlayer)/(\d+)\.(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: WMPlayer
+  regex: ^(Lavf)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(RSSRadio)[ /]?(\d+|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: RSSRadio
+  regex: (RSS_Radio) (\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Podkicker
+  regex: (Podkicker) \S+/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(HTC) Streaming Player \S+ / \S+ / \S+ / (\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(Stitcher)/iOS
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(Stitcher)/Android
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(VLC) .{0,200}version (\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ' (VLC) for'
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: VLC
+  regex: (vlc)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(foobar)\S{1,10}/(\d+)\.(\d+|)\.?([\da-z]+|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(Clementine)\S{1,10} (\d+)\.(\d+|)\.?(\d+|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Amarok
+  regex: (amarok)/(\d+)\.(\d+|)\.?(\d+|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Custom)-Feed Reader
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (iRider|Crazy Browser|SkipStone|iCab|Lunascape|Sleipnir|Maemo Browser) (\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (iCab|Lunascape|Opera|Android|Jasmine|Polaris|Microsoft SkyDriveSync|The
+    Bat!) (\d+)(?:\.(\d+)|)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Kindle)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Android) Donut
+  v1_replacement: '1'
+  v2_replacement: '2'
+- family_replacement: $1
+  regex: (Android) Eclair
+  v1_replacement: '2'
+  v2_replacement: '1'
+- family_replacement: $1
+  regex: (Android) Froyo
+  v1_replacement: '2'
+  v2_replacement: '2'
+- family_replacement: $1
+  regex: (Android) Gingerbread
+  v1_replacement: '2'
+  v2_replacement: '3'
+- family_replacement: $1
+  regex: (Android) Honeycomb
+  v1_replacement: '3'
+  v2_replacement: $3
+- family_replacement: IE Large Screen
+  regex: (MSIE) (\d+)\.(\d+).{0,100}XBLWP7
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Nextcloud)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (mirall)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Owncloud
+  regex: (ownCloud-android)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Skype
+  regex: (OC)/(\d+)\.(\d+)\.(\d+)\.(\d+) \(Skype for Business\)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: OpenVAS Scanner
+  regex: (OpenVAS)(?:-VT)?(?:[ \/](\d+)(?:\.(\d+)|)(?:\.(\d+)|)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (AnyConnect)\/(\d+)(?:\.(\d+)(?:\.(\d+)|)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Monitis
+  regex: compatible; monitis
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Obigo)InternetBrowser
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Obigo)\-Browser
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Obigo
+  regex: (Obigo|OBIGO)[^\d]*(\d+)(?:.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Maxthon
+  regex: (MAXTHON|Maxthon) (\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Maxthon|MyIE2|Uzbl|Shiira)
+  v1_replacement: '0'
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (BrowseX) \((\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: NCSA Mosaic
+  regex: (NCSA_Mosaic)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Polaris
+  regex: (POLARIS)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Polaris
+  regex: (Embider)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Bon Echo
+  regex: (BonEcho)/(\d+)\.(\d+)\.?([ab]?\d+|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: TopBuzz
+  regex: (TopBuzz) com.alex.NewsMaster/(\d+).(\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: TopBuzz
+  regex: (TopBuzz) com.mobilesrepublic.newsrepublic/(\d+).(\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: TopBuzz
+  regex: (TopBuzz) com.topbuzz.videoen/(\d+).(\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Google
+  regex: (iPod|iPhone|iPad).{1,200}GSA/(\d+)\.(\d+)\.(\d+)(?:\.(\d+)|) Mobile
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Mobile Safari
+  regex: (iPod|iPhone|iPad).{1,200}Version/(\d+)\.(\d+)(?:\.(\d+)|).{1,200}[ +]Safari
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Mobile Safari UI/WKWebView
+  regex: (iPod|iPod touch|iPhone|iPad);.{0,30}CPU.{0,30}OS[ +](\d+)_(\d+)(?:_(\d+)|).{0,30}
+    AppleNews\/\d+\.\d+(?:\.\d+|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Mobile Safari UI/WKWebView
+  regex: (iPod|iPhone|iPad).{1,200}Version/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Mobile Safari
+  regex: (iPod|iPod touch|iPhone|iPad).{0,200} Safari
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Mobile Safari UI/WKWebView
+  regex: (iPod|iPod touch|iPhone|iPad)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Apple $1 App
+  regex: (Watch)(\d+),(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Outlook-iOS)/\d+\.\d+\.prod\.iphone \((\d+)\.(\d+)\.(\d+)\)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (AvantGo) (\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: ONE Browser
+  regex: (OneBrowser)/(\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Avant)
+  v1_replacement: '1'
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (QtCarBrowser)
+  v1_replacement: '1'
+  v2_replacement: $3
+- family_replacement: iBrowser Mini
+  regex: ^(iBrowser/Mini)(\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(iBrowser|iRAPP)/(\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Nokia Services (WAP) Browser
+  regex: ^(Nokia)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Nokia Browser
+  regex: (NokiaBrowser)/(\d+)\.(\d+).(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Nokia Browser
+  regex: (NokiaBrowser)/(\d+)\.(\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Nokia Browser
+  regex: (NokiaBrowser)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Nokia Browser
+  regex: (BrowserNG)/(\d+)\.(\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Nokia Browser
+  regex: (Series60)/5\.0
+  v1_replacement: '7'
+  v2_replacement: '0'
+- family_replacement: Nokia OSS Browser
+  regex: (Series60)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Ovi Browser
+  regex: (S40OviBrowser)/(\d+)\.(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Nokia)[EN]?(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: BlackBerry WebKit
+  regex: (PlayBook).{1,200}RIM Tablet OS (\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: BlackBerry WebKit
+  regex: (Black[bB]erry|BB10).{1,200}Version/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: BlackBerry
+  regex: (Black[bB]erry)\s?(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (OmniWeb)/v(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Palm Blazer
+  regex: (Blazer)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Palm Pre
+  regex: (Pre)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (ELinks)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (ELinks) \((\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Links) \((\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (QtWeb) Internet Browser/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (PhantomJS)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: WebKit Nightly
+  regex: (AppleWebKit)/(\d+)(?:\.(\d+)|)\+ .{0,200} Safari
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Safari
+  regex: (Version)/(\d+)\.(\d+)(?:\.(\d+)|).{0,100}Safari/
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Safari)/\d+
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (OLPC)/Update(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (OLPC)/Update()\.(\d+)
+  v1_replacement: '0'
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (SEMC\-Browser)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Teleca Browser
+  regex: (Teleca)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Phantom Browser
+  regex: (Phantom)/V(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: IE
+  regex: (Trident)/(7|8)\.(0)
+  v1_replacement: '11'
+  v2_replacement: $3
+- family_replacement: IE
+  regex: (Trident)/(6)\.(0)
+  v1_replacement: '10'
+  v2_replacement: $3
+- family_replacement: IE
+  regex: (Trident)/(5)\.(0)
+  v1_replacement: '9'
+  v2_replacement: $3
+- family_replacement: IE
+  regex: (Trident)/(4)\.(0)
+  v1_replacement: '8'
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Espial)/(\d+)(?:\.(\d+)|)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Apple Mail
+  regex: (AppleWebKit)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Firefox)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Firefox)/(\d+)\.(\d+)(pre|[ab]\d+[a-z]*|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: IE
+  regex: ([MS]?IE) (\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Python Requests
+  regex: (python-requests)/(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: \b(Windows-Update-Agent|WindowsPowerShell|Microsoft-CryptoAPI|SophosUpdateManager|SophosAgent|Debian
+    APT-HTTP|Ubuntu APT-HTTP|libcurl-agent|libwww-perl|urlgrabber|curl|PycURL|Wget|wget2|aria2|Axel|OpenBSD
+    ftp|lftp|jupdate|insomnia|fetch libfetch|akka-http|got|CloudCockpitBackend|ReactorNetty|axios|Jersey|Vert.x-WebClient|Apache-CXF|Go-CF-client|go-resty|AHC)(?:[
+    /](\d+)(?:\.(\d+)|)(?:\.(\d+)|)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: CloudFoundry
+  regex: ^(cf)\/(\d+)\.(\d+)\.(\S+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(sap-leonardo-iot-sdk-nodejs) \/ (\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(SAP NetWeaver Application Server) \(1.0;(\d{1})(\d{2})\)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: HTTPClient
+  regex: ^(\w+-HTTPClient)\/(\d+)\.(\d+)-(\S+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(go-cli)\s(\d+)\.(\d+).(\S+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(Java-EurekaClient|Java-EurekaClient-Replication|HTTPClient|lua-resty-http)\/v?(\d+)\.(\d+)\.?(\d*)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(ping-service|sap xsuaa|Node-oauth|Site24x7|SAP CPI|JAEGER_SECURITY)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Python aiohttp
+  regex: (Python/3\.\d{1,3} aiohttp)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Java)[/ ]?\d+\.(\d+)\.(\d+)[_-]*([a-zA-Z0-9]+|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (minio-go)/v(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(ureq)[/ ](\d+)\.(\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(http\.rb)/(\d+)\.(\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(GuzzleHttp)/(\d+)\.(\d+).(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(grab)\b
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(Cyberduck)/(\d+)\.(\d+)\.(\d+)(?:\.\d+|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(S3 Browser) (\d+)[.-](\d+)[.-](\d+)(?:\s*https?://s3browser\.com|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (S3Gof3r)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: \b(ibm-cos-sdk-(?:core|java|js|python))/(\d+)\.(\d+)(?:\.(\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(rusoto)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(rclone)/v(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: ^(Roku)/DVP-(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: Kurio App
+  regex: (Kurio)\/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: '^(Box(?: Sync)?)/(\d+)\.(\d+)\.(\d+)'
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: ViaFree
+  regex: ^(ViaFree|Viafree)-(?:tvOS-)?[A-Z]{2}/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Transmit)/(\d+)\.(\d+)\.(\d+)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: (Download Master)
+  v1_replacement: $2
+  v2_replacement: $3
+- family_replacement: $1
+  regex: \b(HTTrack) (\d+)\.(\d+)(?:[\.\-](\d+)|)
+  v1_replacement: $2
+  v2_replacement: $3
diff --git a/tests/queries/0_stateless/data_ua_parser/device.yaml b/tests/queries/0_stateless/data_ua_parser/device.yaml
new file mode 100644
index 00000000000..bf5cfcc84cd
--- /dev/null
+++ b/tests/queries/0_stateless/data_ua_parser/device.yaml
@@ -0,0 +1,2651 @@
+- brand_replacement: Spider
+  device_replacement: Spider
+  model_replacement: Smartphone
+  regex: ^.{0,100}?(?:(?:iPhone|Windows CE|Windows Phone|Android).{0,300}(?:(?:Bot|Yeti)-Mobile|YRSpider|BingPreview|bots?/\d|(?:bot|spider)\.html)|AdsBot-Google-Mobile.{0,200}iPhone)
+  regex_flag: i
+- brand_replacement: Spider
+  device_replacement: Spider
+  model_replacement: Feature Phone
+  regex: ^.{0,100}?(?:DoCoMo|\bMOT\b|\bLG\b|Nokia|Samsung|SonyEricsson).{0,200}(?:(?:Bot|Yeti)-Mobile|bots?/\d|(?:bot|crawler)\.html|(?:jump|google|Wukong)bot|ichiro/mobile|/spider|YahooSeeker)
+  regex_flag: i
+- brand_replacement: Spider
+  device_replacement: Spider
+  model_replacement: $1
+  regex: ' PTST/\d+(?:\.\d+|)$'
+- brand_replacement: Spider
+  device_replacement: Spider
+  model_replacement: $1
+  regex: X11; Datanyze; Linux
+- brand_replacement: Spider
+  device_replacement: Spider
+  model_replacement: Smartphone
+  regex: Mozilla.{1,100}Mobile.{1,100}AspiegelBot
+- brand_replacement: Spider
+  device_replacement: Spider
+  model_replacement: Desktop
+  regex: Mozilla.{0,200}AspiegelBot
+- brand_replacement: $1
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: \bSmartWatch {0,2}\( {0,2}([^;]{1,200}) {0,2}; {0,2}([^;]{1,200}) {0,2};
+- brand_replacement: $1$2
+  device_replacement: $1 $2
+  model_replacement: $3
+  regex: 'Android Application[^\-]{1,300} - (Sony) ?(Ericsson|) (.{1,200}) \w{1,20}
+    - '
+- brand_replacement: $1
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: 'Android Application[^\-]{1,300} - (?:HTC|HUAWEI|LGE|LENOVO|MEDION|TCT) (HTC|HUAWEI|LG|LENOVO|MEDION|ALCATEL)[
+    _\-](.{1,200}) \w{1,20} - '
+  regex_flag: i
+- brand_replacement: $1
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: 'Android Application[^\-]{1,300} - ([^ ]+) (.{1,200}) \w{1,20} - '
+- brand_replacement: 3Q
+  device_replacement: 3Q $1
+  model_replacement: $1
+  regex: '; {0,2}([BLRQ]C\d{4}[A-Z]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: 3Q
+  device_replacement: 3Q $1
+  model_replacement: $1
+  regex: '; {0,2}(?:3Q_)([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Acer
+  device_replacement: $1
+  model_replacement: $1
+  regex: 'Android [34].{0,200}; {0,2}(A100|A101|A110|A200|A210|A211|A500|A501|A510|A511|A700(?:
+    Lite| 3G|)|A701|B1-A71|A1-\d{3}|B1-\d{3}|V360|V370|W500|W500P|W501|W501P|W510|W511|W700|Slider
+    SL101|DA22[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Acer
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}Acer Iconia Tab ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Acer
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(Z1[1235]0|E320[^/]{0,10}|S500|S510|Liquid[^;/]{0,30}|Iconia A\d+)(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: Acer
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: '; {0,2}(Acer |ACER )([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Advent
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: '; {0,2}(Advent |)(Vega(?:Bean|Comb|)).{0,200}?(?: Build|\) AppleWebKit)'
+- brand_replacement: Ainol
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: '; {0,2}(Ainol |)((?:NOVO|[Nn]ovo)[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Airis
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}AIRIS[ _\-]?([^/;\)]+) {0,2}(?:;|\)|Build)
+  regex_flag: i
+- brand_replacement: Airis
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(OnePAD[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Airpad
+  device_replacement: Airpad $1
+  model_replacement: $1
+  regex: '; {0,2}Airpad[ \-]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Alcatel
+  device_replacement: Alcatel One Touch $2
+  model_replacement: One Touch $2
+  regex: '; {0,2}(one ?touch) (EVO7|T10|T20)(?: Build|\) AppleWebKit)'
+- brand_replacement: Alcatel
+  device_replacement: Alcatel One Touch $1
+  model_replacement: One Touch $1
+  regex: '; {0,2}(?:alcatel[ _]|)(?:(?:one[ _]?touch[ _])|ot[ \-])([^;/]{1,100}?)(?:
+    Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: $1
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(TCL)[ _]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Alcatel
+  device_replacement: Alcatel $1
+  model_replacement: $1
+  regex: '; {0,2}(Vodafone Smart II|Optimus_Madrid)(?: Build|\) AppleWebKit)'
+- brand_replacement: Alcatel
+  device_replacement: Alcatel One Touch 998
+  model_replacement: One Touch 998
+  regex: '; {0,2}BASE_Lutea_3(?: Build|\) AppleWebKit)'
+- brand_replacement: Alcatel
+  device_replacement: Alcatel One Touch 918D
+  model_replacement: One Touch 918D
+  regex: '; {0,2}BASE_Varia(?: Build|\) AppleWebKit)'
+- brand_replacement: Allfine
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}((?:FINE|Fine)\d[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Allview
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: '; {0,2}(ALLVIEW[ _]?|Allview[ _]?)((?:Speed|SPEED).{0,200}?)(?: Build|\)
+    AppleWebKit)'
+- brand_replacement: Allview
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: '; {0,2}(ALLVIEW[ _]?|Allview[ _]?|)(AX1_Shine|AX2_Frenzy)(?: Build|\) AppleWebKit)'
+- brand_replacement: Allview
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: '; {0,2}(ALLVIEW[ _]?|Allview[ _]?)([^;/]*?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Allwinner
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(A13-MID)(?: Build|\) AppleWebKit)'
+- brand_replacement: Allwinner
+  device_replacement: $1 $2
+  model_replacement: $1
+  regex: '; {0,2}(Allwinner)[ _\-]?([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Amaway
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(A651|A701B?|A702|A703|A705|A706|A707|A711|A712|A713|A717|A722|A785|A801|A802|A803|A901|A902|A1002|A1003|A1006|A1007|A9701|A9703|Q710|Q80)(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: Amoi
+  device_replacement: Amoi $1
+  model_replacement: $1
+  regex: '; {0,2}(?:AMOI|Amoi)[ _]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Amoi
+  device_replacement: Amoi $1
+  model_replacement: $1
+  regex: ^(?:AMOI|Amoi)[ _]([^;/]{1,100}?) Linux
+- brand_replacement: Aoc
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(MW(?:0[789]|10)[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Aoson
+  device_replacement: Aoson $1
+  model_replacement: $1
+  regex: '; {0,2}(G7|M1013|M1015G|M11[CG]?|M-?12[B]?|M15|M19[G]?|M30[ACQ]?|M31[GQ]|M32|M33[GQ]|M36|M37|M38|M701T|M710|M712B|M713|M715G|M716G|M71(?:G|GS|T|)|M72[T]?|M73[T]?|M75[GT]?|M77G|M79T|M7L|M7LN|M81|M810|M81T|M82|M92|M92KS|M92S|M717G|M721|M722G|M723|M725G|M739|M785|M791|M92SK|M93D)(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: Aoson
+  device_replacement: Aoson $1
+  model_replacement: $1
+  regex: '; {0,2}Aoson ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Apanda
+  device_replacement: Apanda $1
+  model_replacement: $1
+  regex: '; {0,2}[Aa]panda[ _\-]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Archos
+  device_replacement: Archos $1
+  model_replacement: $1
+  regex: '; {0,2}(?:ARCHOS|Archos) ?(GAMEPAD.{0,200}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Archos
+  device_replacement: Archos $1
+  model_replacement: $1
+  regex: ARCHOS; GOGI; ([^;]{1,200});
+- brand_replacement: Archos
+  device_replacement: Archos $1
+  model_replacement: $1
+  regex: '(?:ARCHOS|Archos)[ _]?(.{0,200}?)(?: Build|[;/\(\)\-]|$)'
+- brand_replacement: Archos
+  device_replacement: Archos $1
+  model_replacement: $1
+  regex: '; {0,2}(AN(?:7|8|9|10|13)[A-Z0-9]{1,4})(?: Build|\) AppleWebKit)'
+- brand_replacement: Archos
+  device_replacement: Archos $1
+  model_replacement: $1
+  regex: '; {0,2}(A28|A32|A43|A70(?:BHT|CHT|HB|S|X)|A101(?:B|C|IT)|A7EB|A7EB-WK|101G9|80G9)(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: Arival
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(PAD-FMD[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Arival
+  device_replacement: $1 $2
+  model_replacement: $1 $2
+  regex: '; {0,2}(BioniQ) ?([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Arnova
+  device_replacement: Arnova $1
+  model_replacement: $1
+  regex: '; {0,2}(AN\d[^;/]{1,100}|ARCHM\d+)(?: Build|\) AppleWebKit)'
+- brand_replacement: Arnova
+  device_replacement: Arnova $1
+  model_replacement: $1
+  regex: '; {0,2}(?:ARNOVA|Arnova) ?([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Assistant
+  device_replacement: Assistant $1-$2
+  model_replacement: $1-$2
+  regex: '; {0,2}(?:ASSISTANT |)(AP)-?([1789]\d{2}[A-Z]{0,2}|80104)(?: Build|\) AppleWebKit)'
+- brand_replacement: Asus
+  device_replacement: Asus $1
+  model_replacement: $1
+  regex: '; {0,2}(ME17\d[^;/]*|ME3\d{2}[^;/]{1,100}|K00[A-Z]|Nexus 10|Nexus 7(?: 2013|)|PadFone[^;/]*|Transformer[^;/]*|TF\d{3}[^;/]*|eeepc)(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: Asus
+  device_replacement: Asus $1
+  model_replacement: $1
+  regex: '; {0,2}ASUS[ _]{0,10}([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Garmin-Asus
+  device_replacement: Garmin-Asus $1
+  model_replacement: $1
+  regex: '; {0,2}Garmin-Asus ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Garmin-Asus
+  device_replacement: Garmin $1
+  model_replacement: $1
+  regex: '; {0,2}(Garminfone)(?: Build|\) AppleWebKit)'
+- brand_replacement: Attab
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; (@TAB-[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Audiosonic
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(T-(?:07|[^0]\d)[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Axioo
+  device_replacement: Axioo $1$2 $3
+  model_replacement: $1$2 $3
+  regex: '; {0,2}(?:Axioo[ _\-]([^;/]{1,100}?)|(picopad)[ _\-]([^;/]{1,100}?))(?:
+    Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Azend
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(V(?:100|700|800)[^;/]*)(?: Build|\) AppleWebKit)'
+- brand_replacement: Bak
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(IBAK\-[^;/]*)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Bedove
+  device_replacement: Bedove $1
+  model_replacement: $1
+  regex: '; {0,2}(HY5001|HY6501|X12|X21|I5)(?: Build|\) AppleWebKit)'
+- brand_replacement: Benss
+  device_replacement: Benss $1
+  model_replacement: $1
+  regex: '; {0,2}(JC-[^;/]*)(?: Build|\) AppleWebKit)'
+- brand_replacement: Blackberry
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(BB) ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: $1
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(BlackBird)[ _](I8.{0,200}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: $1
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(BlackBird)[ _](.{0,200}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Blaupunkt
+  device_replacement: Blaupunkt $1
+  model_replacement: $1
+  regex: '; {0,2}([0-9]+BP[EM][^;/]*|Endeavour[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Blu
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: '; {0,2}((?:BLU|Blu)[ _\-])([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Blu
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(?:BMOBILE )?(Blu|BLU|DASH [^;/]{1,100}|VIVO 4\.3|TANK 4\.5)(?: Build|\)
+    AppleWebKit)'
+- brand_replacement: Blusens
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(TOUCH\d[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Bmobile
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(AX5\d+)(?: Build|\) AppleWebKit)'
+- brand_replacement: bq
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}([Bb]q) ([^;/]{1,100}?);?(?: Build|\) AppleWebKit)'
+- brand_replacement: bq
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(Maxwell [^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Braun
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}((?:B-Tab|B-TAB) ?\d[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: $1
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(Broncho) ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Captiva
+  device_replacement: Captiva $1
+  model_replacement: $1
+  regex: '; {0,2}CAPTIVA ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Casio
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(C771|CAL21|IS11CA)(?: Build|\) AppleWebKit)'
+- brand_replacement: Cat
+  device_replacement: Cat $1
+  model_replacement: $1
+  regex: '; {0,2}(?:Cat|CAT) ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Cat
+  device_replacement: Cat $1
+  model_replacement: $1
+  regex: '; {0,2}(?:Cat)(Nova.{0,200}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Cat
+  device_replacement: $1
+  model_replacement: Tablet PHOENIX 8.1J0
+  regex: '; {0,2}(INM8002KP|ADM8000KP_[AB])(?: Build|\) AppleWebKit)'
+- brand_replacement: Celkon
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}(?:[Cc]elkon[ _\*]|CELKON[ _\*])([^;/\)]+) ?(?:Build|;|\))
+- brand_replacement: Celkon
+  device_replacement: $1
+  model_replacement: $1
+  regex: Build/(?:[Cc]elkon)+_?([^;/_\)]+)
+- brand_replacement: Celkon
+  device_replacement: $1$2
+  model_replacement: $1$2
+  regex: '; {0,2}(CT)-?(\d+)(?: Build|\) AppleWebKit)'
+- brand_replacement: Celkon
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}(A19|A19Q|A105|A107[^;/\)]*) ?(?:Build|;|\))
+- brand_replacement: ChangJia
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(TPC[0-9]{4,5})(?: Build|\) AppleWebKit)'
+- brand_replacement: Cloudfone
+  device_replacement: $1 $2 $3
+  model_replacement: $1 $2 $3
+  regex: '; {0,2}(Cloudfone)[ _](Excite)([^ ][^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Cloudfone
+  device_replacement: Cloudfone $1 $2
+  model_replacement: Cloudfone $1 $2
+  regex: '; {0,2}(Excite|ICE)[ _](\d+[^;/]{0,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Cloudfone
+  device_replacement: $1 $2
+  model_replacement: $1 $2
+  regex: '; {0,2}(Cloudfone|CloudPad)[ _]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Cmx
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}((?:Aquila|Clanga|Rapax)[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: CobyKyros
+  device_replacement: CobyKyros $1$2
+  model_replacement: $1$2
+  regex: ; {0,2}(?:CFW-|Kyros )?(MID[0-9]{4}(?:[ABC]|SR|TV)?)(\(3G\)-4G| GB 8K| 3G|
+    8K| GB)? {0,2}(?:Build|[;\)])
+- brand_replacement: Coolpad
+  device_replacement: $1$2
+  model_replacement: $1$2
+  regex: '; {0,2}([^;/]{0,50})Coolpad[ _]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Cube
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: '; {0,2}(CUBE[ _])?([KU][0-9]+ ?GT.{0,200}?|A5300)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Cubot
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}CUBOT ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Cubot
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(BOBBY)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Danew
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(Dslide [^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Dell
+  device_replacement: Dell $1$2
+  model_replacement: $1$2
+  regex: '; {0,2}(XCD)[ _]?(28|35)(?: Build|\) AppleWebKit)'
+- brand_replacement: Dell
+  device_replacement: Dell $1
+  model_replacement: Streak
+  regex: '; {0,2}(001DL)(?: Build|\) AppleWebKit)'
+- brand_replacement: Dell
+  device_replacement: Dell $1
+  model_replacement: Streak
+  regex: '; {0,2}(?:Dell|DELL) (Streak)(?: Build|\) AppleWebKit)'
+- brand_replacement: Dell
+  device_replacement: Dell $1
+  model_replacement: Streak Pro
+  regex: '; {0,2}(101DL|GS01|Streak Pro[^;/]{0,100})(?: Build|\) AppleWebKit)'
+- brand_replacement: Dell
+  device_replacement: Dell $1
+  model_replacement: Streak 7
+  regex: '; {0,2}([Ss]treak ?7)(?: Build|\) AppleWebKit)'
+- brand_replacement: Dell
+  device_replacement: Dell $1
+  model_replacement: $1
+  regex: '; {0,2}(Mini-3iX)(?: Build|\) AppleWebKit)'
+- brand_replacement: Dell
+  device_replacement: Dell $1
+  model_replacement: $1
+  regex: '; {0,2}(?:Dell|DELL)[ _](Aero|Venue|Thunder|Mini.{0,200}?|Streak[ _]Pro)(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: Dell
+  device_replacement: Dell $1
+  model_replacement: $1
+  regex: '; {0,2}Dell[ _]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Dell
+  device_replacement: Dell $1
+  model_replacement: $1
+  regex: '; {0,2}Dell ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Denver
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(TA[CD]-\d+[^;/]{0,100})(?: Build|\) AppleWebKit)'
+- brand_replacement: Dex
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(iP[789]\d{2}(?:-3G)?|IP10\d{2}(?:-8GB)?)(?: Build|\) AppleWebKit)'
+- brand_replacement: DNS
+  device_replacement: $1 $2
+  model_replacement: $1 $2
+  regex: '; {0,2}(AirTab)[ _\-]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Fujitsu
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(F\-\d[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: HTC
+  device_replacement: $1
+  model_replacement: Magic
+  regex: '; {0,2}(HT-03A)(?: Build|\) AppleWebKit)'
+- brand_replacement: HTC
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(HT\-\d[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: LG
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(L\-\d[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Nec
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(N\-\d[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Panasonic
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(P\-\d[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Samsung
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(SC\-\d[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Sharp
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(SH\-\d[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: SonyEricsson
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(SO\-\d[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Toshiba
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(T\-0[12][^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: DOOV
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(DOOV)[ _]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Enot
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(Enot|ENOT)[ -]?([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Evercoss
+  device_replacement: CROSS $1
+  model_replacement: Cross $1
+  regex: ; {0,2}[^;/]{1,100} Build/(?:CROSS|Cross)+[ _\-]([^\)]+)
+- brand_replacement: Evercoss
+  device_replacement: $1 $2
+  model_replacement: Cross $2
+  regex: '; {0,2}(CROSS|Cross)[ _\-]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Explay
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}Explay[_ ](.{1,200}?)(?:[\)]| Build)
+- brand_replacement: Fly
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(IQ.{0,200}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Fly
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(Fly|FLY)[ _](IQ[^;]{1,100}?|F[34]\d+[^;]{0,100}?);?(?: Build|\)
+    AppleWebKit)'
+- brand_replacement: Fujitsu
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(M532|Q572|FJL21)(?: Build|\) AppleWebKit)'
+- brand_replacement: Galapad
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(G1)(?: Build|\) AppleWebKit)'
+- brand_replacement: $1
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(Geeksphone) ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Gfive
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(G[^F]?FIVE) ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Gionee
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(Gionee)[ _\-]([^;/]{1,100}?)(?:/[^;/]{1,100}|)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Gionee
+  device_replacement: Gionee $1
+  model_replacement: $1
+  regex: '; {0,2}(GN\d+[A-Z]?|INFINITY_PASSION|Ctrl_V1)(?: Build|\) AppleWebKit)'
+- brand_replacement: Gionee
+  device_replacement: Gionee $1
+  model_replacement: $1
+  regex: ; {0,2}(E3) Build/JOP40D
+- brand_replacement: Gionee
+  device_replacement: Gionee $1
+  model_replacement: $1
+  regex: \sGIONEE[-\s_](\w*)
+  regex_flag: i
+- brand_replacement: GoClever
+  device_replacement: GoClever $1
+  model_replacement: $1
+  regex: '; {0,2}((?:FONE|QUANTUM|INSIGNIA) \d+[^;/]{0,100}|PLAYTAB)(?: Build|\) AppleWebKit)'
+- brand_replacement: GoClever
+  device_replacement: GoClever $1
+  model_replacement: $1
+  regex: '; {0,2}GOCLEVER ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Google
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(Glass \d+)(?: Build|\) AppleWebKit)'
+- brand_replacement: Google
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(Pixel.{0,200}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Gigabyte
+  device_replacement: $1 $2
+  model_replacement: $1 $2
+  regex: '; {0,2}(GSmart)[ -]([^/]{1,50})(?: Build|\) AppleWebKit)'
+- brand_replacement: Freescale
+  device_replacement: Freescale $1
+  model_replacement: $1
+  regex: '; {0,2}(imx5[13]_[^/]{1,50})(?: Build|\) AppleWebKit)'
+- brand_replacement: Haier
+  device_replacement: Haier $1
+  model_replacement: $1
+  regex: '; {0,2}Haier[ _\-]([^/]{1,50})(?: Build|\) AppleWebKit)'
+- brand_replacement: Haipad
+  device_replacement: Haipad $1
+  model_replacement: $1
+  regex: '; {0,2}(PAD1016)(?: Build|\) AppleWebKit)'
+- brand_replacement: Haipad
+  device_replacement: Haipad $1
+  model_replacement: $1
+  regex: '; {0,2}(M701|M7|M8|M9)(?: Build|\) AppleWebKit)'
+- brand_replacement: Hannspree
+  device_replacement: Hannspree $1
+  model_replacement: $1
+  regex: '; {0,2}(SN\d+T[^;\)/]*)(?: Build|[;\)])'
+- brand_replacement: HCLme
+  device_replacement: HCLme $1
+  model_replacement: $1
+  regex: Build/HCL ME Tablet ([^;\)]{1,3})[\);]
+- brand_replacement: HCLme
+  device_replacement: HCLme $1
+  model_replacement: $1
+  regex: ; {0,2}([^;\/]+) Build/HCL
+- brand_replacement: Hena
+  device_replacement: Hena $1
+  model_replacement: $1
+  regex: '; {0,2}(MID-?\d{4}C[EM])(?: Build|\) AppleWebKit)'
+- brand_replacement: Hisense
+  device_replacement: Hisense $1
+  model_replacement: $1
+  regex: '; {0,2}(EG\d{2,}|HS-[^;/]{1,100}|MIRA[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Hisense
+  device_replacement: Hisense $1
+  model_replacement: $1
+  regex: '; {0,2}(andromax[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: hitech
+  device_replacement: AMAZE $1$2
+  model_replacement: AMAZE $1$2
+  regex: '; {0,2}(?:AMAZE[ _](S\d+)|(S\d+)[ _]AMAZE)(?: Build|\) AppleWebKit)'
+- brand_replacement: HP
+  device_replacement: HP $1
+  model_replacement: $1
+  regex: '; {0,2}(PlayBook)(?: Build|\) AppleWebKit)'
+- brand_replacement: HP
+  device_replacement: HP $1
+  model_replacement: $1
+  regex: '; {0,2}HP ([^/]{1,50})(?: Build|\) AppleWebKit)'
+- brand_replacement: HP
+  device_replacement: HP TouchPad
+  model_replacement: TouchPad
+  regex: '; {0,2}([^/]{1,30}_tenderloin)(?: Build|\) AppleWebKit)'
+- brand_replacement: Huawei
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: ; {0,2}(HUAWEI |Huawei-|)([UY][^;/]{1,100}) Build/(?:Huawei|HUAWEI)([UY][^\);]+)\)
+- brand_replacement: Huawei
+  device_replacement: $1
+  model_replacement: $2
+  regex: ; {0,2}([^;/]{1,100}) Build[/ ]Huawei(MT1-U06|[A-Z]{1,50}\d+[^\);]{1,50})\)
+- brand_replacement: Huawei
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}(S7|M860) Build
+- brand_replacement: Huawei
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: ; {0,2}((?:HUAWEI|Huawei)[ \-]?)(MediaPad) Build
+- brand_replacement: Huawei
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: ; {0,2}((?:HUAWEI[ _]?|Huawei[ _]|)Ascend[ _])([^;/]{1,100}) Build
+- brand_replacement: Huawei
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: ; {0,2}((?:HUAWEI|Huawei)[ _\-]?)((?:G700-|MT-)[^;/]{1,100}) Build
+- brand_replacement: Huawei
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: ; {0,2}((?:HUAWEI|Huawei)[ _\-]?)([^;/]{1,100}) Build
+- brand_replacement: Huawei
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}(MediaPad[^;]{1,200}|SpringBoard) Build/Huawei
+- brand_replacement: Huawei
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}([^;]{1,200}) Build/(?:Huawei|HUAWEI)
+- brand_replacement: Huawei
+  device_replacement: $1$2
+  model_replacement: U$2
+  regex: ; {0,2}([Uu])([89]\d{3}) Build
+- brand_replacement: Huawei
+  device_replacement: Huawei Ideos$1
+  model_replacement: Ideos$1
+  regex: ; {0,2}(?:Ideos |IDEOS )(S7) Build
+- brand_replacement: Huawei
+  device_replacement: Huawei Ideos$1
+  model_replacement: Ideos$1
+  regex: ; {0,2}(?:Ideos |IDEOS )([^;/]{1,50}\s{0,5}|\s{0,5})Build
+- brand_replacement: Huawei
+  device_replacement: Huawei $1
+  model_replacement: $1
+  regex: ; {0,2}(Orange Daytona|Pulse|Pulse Mini|Vodafone 858|C8500|C8600|C8650|C8660|Nexus
+    6P|ATH-.{1,200}?) Build[/ ]
+- brand_replacement: Huawei
+  device_replacement: Huawei $1
+  model_replacement: $1
+  regex: ; {0,2}((?:[A-Z]{3})\-L[A-Za0-9]{2})[\)]
+- brand_replacement: Huawei
+  device_replacement: Huawei Honor $1
+  model_replacement: Honor $1
+  regex: ; {0,2}([^;]{1,200}) Build/(HONOR|Honor)
+- brand_replacement: HTC
+  device_replacement: HTC $1
+  model_replacement: $1
+  regex: ; {0,2}HTC[ _]([^;]{1,200}); Windows Phone
+- brand_replacement: HTC
+  device_replacement: HTC $1
+  model_replacement: $1
+  regex: '; {0,2}(?:HTC[ _/])+([^ _/]+)(?:[/\\]1\.0 | V|/| +)\d+\.\d[\d\.]*(?: {0,2}Build|\))'
+- brand_replacement: HTC
+  device_replacement: HTC $1 $2
+  model_replacement: $1 $2
+  regex: '; {0,2}(?:HTC[ _/])+([^ _/]+)(?:[ _/]([^ _/]+)|)(?:[/\\]1\.0 | V|/| +)\d+\.\d[\d\.]*(?:
+    {0,2}Build|\))'
+- brand_replacement: HTC
+  device_replacement: HTC $1 $2 $3
+  model_replacement: $1 $2 $3
+  regex: '; {0,2}(?:HTC[ _/])+([^ _/]+)(?:[ _/]([^ _/]+)(?:[ _/]([^ _/]+)|)|)(?:[/\\]1\.0
+    | V|/| +)\d+\.\d[\d\.]*(?: {0,2}Build|\))'
+- brand_replacement: HTC
+  device_replacement: HTC $1 $2 $3 $4
+  model_replacement: $1 $2 $3 $4
+  regex: '; {0,2}(?:HTC[ _/])+([^ _/]+)(?:[ _/]([^ _/]+)(?:[ _/]([^ _/]+)(?:[ _/]([^
+    _/]+)|)|)|)(?:[/\\]1\.0 | V|/| +)\d+\.\d[\d\.]*(?: {0,2}Build|\))'
+- brand_replacement: HTC
+  device_replacement: HTC $1
+  model_replacement: $1
+  regex: '; {0,2}(?:(?:HTC|htc)(?:_blocked|)[ _/])+([^ _/;]+)(?: {0,2}Build|[;\)]|
+    - )'
+- brand_replacement: HTC
+  device_replacement: HTC $1 $2
+  model_replacement: $1 $2
+  regex: '; {0,2}(?:(?:HTC|htc)(?:_blocked|)[ _/])+([^ _/]+)(?:[ _/]([^ _/;\)]+)|)(?:
+    {0,2}Build|[;\)]| - )'
+- brand_replacement: HTC
+  device_replacement: HTC $1 $2 $3
+  model_replacement: $1 $2 $3
+  regex: '; {0,2}(?:(?:HTC|htc)(?:_blocked|)[ _/])+([^ _/]+)(?:[ _/]([^ _/]+)(?:[
+    _/]([^ _/;\)]+)|)|)(?: {0,2}Build|[;\)]| - )'
+- brand_replacement: HTC
+  device_replacement: HTC $1 $2 $3 $4
+  model_replacement: $1 $2 $3 $4
+  regex: '; {0,2}(?:(?:HTC|htc)(?:_blocked|)[ _/])+([^ _/]+)(?:[ _/]([^ _/]+)(?:[
+    _/]([^ _/]+)(?:[ _/]([^ /;]+)|)|)|)(?: {0,2}Build|[;\)]| - )'
+- brand_replacement: HTC
+  device_replacement: HTC $1
+  model_replacement: $1
+  regex: HTC Streaming Player [^\/]{0,30}/[^\/]{0,10}/ htc_([^/]{1,10}) /
+- brand_replacement: HTC
+  device_replacement: HTC $1
+  model_replacement: $1
+  regex: '(?:[;,] {0,2}|^)(?:htccn_chs-|)HTC[ _-]?([^;]{1,200}?)(?: {0,2}Build|clay|Android|-?Mozilla|
+    Opera| Profile| UNTRUSTED|[;/\(\)]|$)'
+  regex_flag: i
+- brand_replacement: HTC
+  device_replacement: HTC $1
+  model_replacement: $1
+  regex: '; {0,2}(A6277|ADR6200|ADR6300|ADR6350|ADR6400[A-Z]*|ADR6425[A-Z]*|APX515CKT|ARIA|Desire[^_
+    ]*|Dream|EndeavorU|Eris|Evo|Flyer|HD2|Hero|HERO200|Hero CDMA|HTL21|Incredible|Inspire[A-Z0-9]*|Legend|Liberty|Nexus
+    ?(?:One|HD2)|One|One S C2|One[ _]?(?:S|V|X\+?)\w*|PC36100|PG06100|PG86100|S31HT|Sensation|Wildfire)(?:
+    Build|[/;\(\)])'
+  regex_flag: i
+- brand_replacement: HTC
+  device_replacement: HTC $1 $2
+  model_replacement: $1 $2
+  regex: ; {0,2}(ADR6200|ADR6400L|ADR6425LVW|Amaze|DesireS?|EndeavorU|Eris|EVO|Evo\d[A-Z]+|HD2|IncredibleS?|Inspire[A-Z0-9]*|Inspire[A-Z0-9]*|Sensation[A-Z0-9]*|Wildfire)[
+    _-](.{1,200}?)(?:[/;\)]|Build|MIUI|1\.0)
+  regex_flag: i
+- brand_replacement: Hyundai
+  device_replacement: Hyundai $1
+  model_replacement: $1
+  regex: '; {0,2}HYUNDAI (T\d[^/]{0,10})(?: Build|\) AppleWebKit)'
+- brand_replacement: Hyundai
+  device_replacement: Hyundai $1
+  model_replacement: $1
+  regex: '; {0,2}HYUNDAI ([^;/]{1,10}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Hyundai
+  device_replacement: Hyundai $1
+  model_replacement: $1
+  regex: '; {0,2}(X700|Hold X|MB-6900)(?: Build|\) AppleWebKit)'
+- brand_replacement: iBall
+  device_replacement: $1 $2
+  model_replacement: $1 $2
+  regex: '; {0,2}(?:iBall[ _\-]|)(Andi)[ _]?(\d[^;/]*)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: iBall
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(IBall)(?:[ _]([^;/]{1,100}?)|)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: IconBIT
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(NT-\d+[^ ;/]{0,50}|Net[Tt]AB [^;/]{1,50}|Mercury [A-Z]{1,50}|iconBIT)(?:
+    S/N:[^;/]{1,50}|)(?: Build|\) AppleWebKit)'
+- brand_replacement: IMO
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(IMO)[ _]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: imobile
+  device_replacement: i-mobile $1
+  model_replacement: $1
+  regex: '; {0,2}i-?mobile[ _]([^/]{1,50})(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: imobile
+  device_replacement: i-mobile $1
+  model_replacement: $1
+  regex: '; {0,2}(i-(?:style|note)[^/]{0,10})(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Impression
+  device_replacement: $1 $2
+  model_replacement: $1 $2
+  regex: '; {0,2}(ImPAD) ?(\d+(?:.){0,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Infinix
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(Infinix)[ _]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Informer
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(Informer)[ \-]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Intenso
+  device_replacement: Intenso $1
+  model_replacement: $1 $2
+  regex: '; {0,2}(TAB) ?([78][12]4)(?: Build|\) AppleWebKit)'
+- brand_replacement: Intex
+  device_replacement: $1$2$3
+  model_replacement: $1 $3
+  regex: ; {0,2}(?:Intex[ _]|)(AQUA|Aqua)([ _\.\-])([^;/]{1,100}?) {0,2}(?:Build|;)
+- brand_replacement: Intex
+  device_replacement: $1 $2
+  model_replacement: $1 $2
+  regex: ; {0,2}(?:INTEX|Intex)(?:[_ ]([^\ _;/]+))(?:[_ ]([^\ _;/]+)|) {0,2}(?:Build|;)
+- brand_replacement: Intex
+  device_replacement: $1 $2 $3
+  model_replacement: iBuddy $2 $3
+  regex: ; {0,2}([iI]Buddy)[ _]?(Connect)(?:_|\?_| |)([^;/]{0,50}) {0,2}(?:Build|;)
+- brand_replacement: Intex
+  device_replacement: $1 $2
+  model_replacement: iBuddy $2
+  regex: ; {0,2}(I-Buddy)[ _]([^;/]{1,100}?) {0,2}(?:Build|;)
+- brand_replacement: iOCEAN
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(iOCEAN) ([^/]{1,50})(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: ionik
+  device_replacement: ionik $1
+  model_replacement: $1
+  regex: '; {0,2}(TP\d+(?:\.\d+|)\-\d[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Iru
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(M702pro)(?: Build|\) AppleWebKit)'
+- brand_replacement: Itel
+  device_replacement: Itel $1
+  model_replacement: $1
+  regex: '; {0,2}itel ([^;/]*)(?: Build|\) AppleWebKit)'
+- brand_replacement: Ivio
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(DE88Plus|MD70)(?: Build|\) AppleWebKit)'
+- brand_replacement: Ivio
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}IVIO[_\-]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Jaytech
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(TPC-\d+|JAY-TECH)(?: Build|\) AppleWebKit)'
+- brand_replacement: Jiayu
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(JY-[^;/]{1,100}|G[234]S?)(?: Build|\) AppleWebKit)'
+- brand_replacement: JXD
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(JXD)[ _\-]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Karbonn
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}Karbonn[ _]?([^;/]{1,100}) {0,2}(?:Build|;)
+  regex_flag: i
+- brand_replacement: Karbonn
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}([^;]{1,200}) Build/Karbonn
+- brand_replacement: Karbonn
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}(A11|A39|A37|A34|ST8|ST10|ST7|Smart Tab3|Smart Tab2|Titanium S\d)
+    +Build
+- brand_replacement: Sharp
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(IS01|IS03|IS05|IS\d{2}SH)(?: Build|\) AppleWebKit)'
+- brand_replacement: Regza
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(IS04)(?: Build|\) AppleWebKit)'
+- brand_replacement: Pantech
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(IS06|IS\d{2}PT)(?: Build|\) AppleWebKit)'
+- brand_replacement: SonyEricsson
+  device_replacement: $1
+  model_replacement: Xperia Acro
+  regex: '; {0,2}(IS11S)(?: Build|\) AppleWebKit)'
+- brand_replacement: Casio
+  device_replacement: $1
+  model_replacement: GzOne $1
+  regex: '; {0,2}(IS11CA)(?: Build|\) AppleWebKit)'
+- brand_replacement: LG
+  device_replacement: $1
+  model_replacement: Optimus X
+  regex: '; {0,2}(IS11LG)(?: Build|\) AppleWebKit)'
+- brand_replacement: Medias
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(IS11N)(?: Build|\) AppleWebKit)'
+- brand_replacement: Pantech
+  device_replacement: $1
+  model_replacement: MIRACH
+  regex: '; {0,2}(IS11PT)(?: Build|\) AppleWebKit)'
+- brand_replacement: Fujitsu
+  device_replacement: $1
+  model_replacement: Arrows ES
+  regex: '; {0,2}(IS12F)(?: Build|\) AppleWebKit)'
+- brand_replacement: Motorola
+  device_replacement: $1
+  model_replacement: XT909
+  regex: '; {0,2}(IS12M)(?: Build|\) AppleWebKit)'
+- brand_replacement: SonyEricsson
+  device_replacement: $1
+  model_replacement: Xperia Acro HD
+  regex: '; {0,2}(IS12S)(?: Build|\) AppleWebKit)'
+- brand_replacement: Fujitsu
+  device_replacement: $1
+  model_replacement: Arrowz Z
+  regex: '; {0,2}(ISW11F)(?: Build|\) AppleWebKit)'
+- brand_replacement: HTC
+  device_replacement: $1
+  model_replacement: EVO
+  regex: '; {0,2}(ISW11HT)(?: Build|\) AppleWebKit)'
+- brand_replacement: Kyocera
+  device_replacement: $1
+  model_replacement: DIGNO
+  regex: '; {0,2}(ISW11K)(?: Build|\) AppleWebKit)'
+- brand_replacement: Motorola
+  device_replacement: $1
+  model_replacement: Photon
+  regex: '; {0,2}(ISW11M)(?: Build|\) AppleWebKit)'
+- brand_replacement: Samsung
+  device_replacement: $1
+  model_replacement: GALAXY S II WiMAX
+  regex: '; {0,2}(ISW11SC)(?: Build|\) AppleWebKit)'
+- brand_replacement: HTC
+  device_replacement: $1
+  model_replacement: EVO 3D
+  regex: '; {0,2}(ISW12HT)(?: Build|\) AppleWebKit)'
+- brand_replacement: HTC
+  device_replacement: $1
+  model_replacement: J
+  regex: '; {0,2}(ISW13HT)(?: Build|\) AppleWebKit)'
+- brand_replacement: KDDI
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(ISW?[0-9]{2}[A-Z]{0,2})(?: Build|\) AppleWebKit)'
+- brand_replacement: KDDI
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(INFOBAR [^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Kingcom
+  device_replacement: $1 $2
+  model_replacement: $1 $2
+  regex: '; {0,2}(JOYPAD|Joypad)[ _]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Kobo
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(Vox|VOX|Arc|K080)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Kobo
+  device_replacement: $1
+  model_replacement: $1
+  regex: \b(Kobo Touch)\b
+- brand_replacement: Ktouch
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(K-Touch)[ _]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: KTtech
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}((?:EV|KM)-S\d+[A-Z]?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Kyocera
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(Zio|Hydro|Torque|Event|EVENT|Echo|Milano|Rise|URBANO PROGRESSO|WX04K|WX06K|WX10K|KYL21|101K|C5[12]\d{2})(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: Lava
+  device_replacement: Iris $1
+  model_replacement: Iris $1
+  regex: ; {0,2}(?:LAVA[ _]|)IRIS[ _\-]?([^/;\)]+) {0,2}(?:;|\)|Build)
+  regex_flag: i
+- brand_replacement: Lava
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}LAVA[ _]([^;/]{1,100}) Build
+- brand_replacement: Lemon
+  device_replacement: Lemon $1$2
+  model_replacement: $1$2
+  regex: '; {0,2}(?:(Aspire A1)|(?:LEMON|Lemon)[ _]([^;/]{1,100}))_?(?: Build|\) AppleWebKit)'
+- brand_replacement: Lenco
+  device_replacement: Lenco $1
+  model_replacement: $1
+  regex: '; {0,2}(TAB-1012)(?: Build|\) AppleWebKit)'
+- brand_replacement: Lenco
+  device_replacement: Lenco $1
+  model_replacement: $1
+  regex: '; Lenco ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Lenovo
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}(A1_07|A2107A-H|S2005A-H|S1-37AH0) Build
+- brand_replacement: Lenovo
+  device_replacement: Lenovo $1 $2
+  model_replacement: $1 $2
+  regex: ; {0,2}(Idea[Tp]ab)[ _]([^;/]{1,100});? Build
+- brand_replacement: Lenovo
+  device_replacement: Lenovo $1 $2
+  model_replacement: $1 $2
+  regex: ; {0,2}(Idea(?:Tab|pad)) ?([^;/]{1,100}) Build
+- brand_replacement: Lenovo
+  device_replacement: Lenovo $1 $2
+  model_replacement: $1 $2
+  regex: ; {0,2}(ThinkPad) ?(Tablet) Build/
+- brand_replacement: Lenovo
+  device_replacement: Lenovo $1
+  model_replacement: $1
+  regex: ; {0,2}(?:LNV-|)(?:=?[Ll]enovo[ _\-]?|LENOVO[ _])(.{1,200}?)(?:Build|[;/\)])
+- brand_replacement: Lenovo
+  device_replacement: Lenovo $1 $2 $3
+  model_replacement: $1 $2 $3
+  regex: '[;,] (?:Vodafone |)(SmartTab) ?(II) ?(\d+) Build/'
+- brand_replacement: Lenovo
+  device_replacement: Lenovo Ideapad K1
+  model_replacement: Ideapad K1
+  regex: ; {0,2}(?:Ideapad |)K1 Build/
+- brand_replacement: Lenovo
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}(3GC101|3GW10[01]|A390) Build/
+- brand_replacement: Lenovo
+  device_replacement: Lenovo $1
+  model_replacement: $1
+  regex: \b(?:Lenovo|LENOVO)+[ _\-]?([^,;:/ ]+)
+- brand_replacement: Lexibook
+  device_replacement: $1$2
+  model_replacement: $1$2
+  regex: '; {0,2}(MFC\d+)[A-Z]{2}([^;,/]*),?(?: Build|\) AppleWebKit)'
+- brand_replacement: LG
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}(E[34][0-9]{2}|LS[6-8][0-9]{2}|VS[6-9][0-9]+[^;/]{1,30}|Nexus 4|Nexus
+    5X?|GT540f?|Optimus (?:2X|G|4X HD)|OptimusX4HD) {0,2}(?:Build|;)
+- brand_replacement: LG
+  device_replacement: $1
+  model_replacement: $1
+  regex: '[;:] {0,2}(L-\d+[A-Z]|LGL\d+[A-Z]?)(?:/V\d+|) {0,2}(?:Build|[;\)])'
+- brand_replacement: LG
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: ; {0,2}(LG-)([A-Z]{1,2}\d{2,}[^,;/\)\(]*?)(?:Build| V\d+|[,;/\)\(]|$)
+- brand_replacement: LG
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: ; {0,2}(LG[ \-]|LG)([^;/]{1,100})[;/]? Build
+- brand_replacement: LG
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: ^(LG)-([^;/]{1,100})/ Mozilla/.{0,200}; Android
+- brand_replacement: LG
+  device_replacement: LG $1 $2
+  model_replacement: $1 $2
+  regex: (Web0S); Linux/(SmartTV)
+- brand_replacement: Malata
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}((?:SMB|smb)[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Malata
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(?:Malata|MALATA) ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Manta
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(MS[45][0-9]{3}|MID0[568][NS]?|MID[1-9]|MID[78]0[1-9]|MID970[1-9]|MID100[1-9])(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: Match
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(M1052|M806|M9000|M9100|M9701|MID100|MID120|MID125|MID130|MID135|MID140|MID701|MID710|MID713|MID727|MID728|MID731|MID732|MID733|MID735|MID736|MID737|MID760|MID800|MID810|MID820|MID830|MID833|MID835|MID860|MID900|MID930|MID933|MID960|MID980)(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: Maxx
+  device_replacement: Maxx $1
+  model_replacement: $1
+  regex: '; {0,2}(GenxDroid7|MSD7.{0,200}?|AX\d.{0,200}?|Tab 701|Tab 722)(?: Build|\)
+    AppleWebKit)'
+- brand_replacement: Mediacom
+  device_replacement: Mediacom $1
+  model_replacement: $1
+  regex: '; {0,2}(M-PP[^;/]{1,30}|PhonePad ?\d{2,}[^;/]{1,30}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Mediacom
+  device_replacement: Mediacom $1
+  model_replacement: $1
+  regex: '; {0,2}(M-MP[^;/]{1,30}|SmartPad ?\d{2,}[^;/]{1,30}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Medion
+  device_replacement: Medion Lifetab $1
+  model_replacement: Lifetab $1
+  regex: '; {0,2}(?:MD_|)LIFETAB[ _]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Medion
+  device_replacement: Medion $1
+  model_replacement: $1
+  regex: '; {0,2}MEDION ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Meizu
+  device_replacement: Meizu $1
+  model_replacement: $1
+  regex: '; {0,2}(M030|M031|M035|M040|M065|m9)(?: Build|\) AppleWebKit)'
+- brand_replacement: Meizu
+  device_replacement: Meizu $1
+  model_replacement: $1
+  regex: ; {0,2}(?:meizu_|MEIZU )(.{1,200}?) {0,2}(?:Build|[;\)])
+- brand_replacement: Micromax
+  device_replacement: Micromax $1$2
+  model_replacement: $1$2
+  regex: ; {0,2}(?:Micromax[ _](A111|A240)|(A111|A240)) Build
+  regex_flag: i
+- brand_replacement: Micromax
+  device_replacement: Micromax $1
+  model_replacement: $1
+  regex: ; {0,2}Micromax[ _](A\d{2,3}[^;/]*) Build
+  regex_flag: i
+- brand_replacement: Micromax
+  device_replacement: Micromax $1
+  model_replacement: $1
+  regex: ; {0,2}(A\d{2}|A[12]\d{2}|A90S|A110Q) Build
+  regex_flag: i
+- brand_replacement: Micromax
+  device_replacement: Micromax $1
+  model_replacement: $1
+  regex: ; {0,2}Micromax[ _](P\d{3}[^;/]*) Build
+  regex_flag: i
+- brand_replacement: Micromax
+  device_replacement: Micromax $1
+  model_replacement: $1
+  regex: ; {0,2}(P\d{3}|P\d{3}\(Funbook\)) Build
+  regex_flag: i
+- brand_replacement: Mito
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(MITO)[ _\-]?([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Mobistel
+  device_replacement: $1 $2
+  model_replacement: $1 $2
+  regex: ; {0,2}(Cynus)[ _](F5|T\d|.{1,200}?) {0,2}(?:Build|[;/\)])
+  regex_flag: i
+- brand_replacement: Modecom
+  device_replacement: $1$2 $3
+  model_replacement: $2 $3
+  regex: '; {0,2}(MODECOM |)(FreeTab) ?([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Modecom
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(MODECOM )([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Motorola
+  device_replacement: Motorola $1
+  model_replacement: $1
+  regex: ; {0,2}(MZ\d{3}\+?|MZ\d{3} 4G|Xoom|XOOM[^;/]*) Build
+- brand_replacement: Motorola
+  device_replacement: Motorola $1$2
+  model_replacement: $2
+  regex: ; {0,2}(Milestone )(XT[^;/]*) Build
+- brand_replacement: Motorola
+  device_replacement: Motorola $1
+  model_replacement: DROID X
+  regex: ; {0,2}(Motoroi ?x|Droid X|DROIDX) Build
+  regex_flag: i
+- brand_replacement: Motorola
+  device_replacement: Motorola $1
+  model_replacement: $1
+  regex: ; {0,2}(Droid[^;/]*|DROID[^;/]*|Milestone[^;/]*|Photon|Triumph|Devour|Titanium)
+    Build
+- brand_replacement: Motorola
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}(A555|A85[34][^;/]*|A95[356]|ME[58]\d{2}\+?|ME600|ME632|ME722|MB\d{3}\+?|MT680|MT710|MT870|MT887|MT917|WX435|WX453|WX44[25]|XT\d{3,4}[A-Z\+]*|CL[iI]Q|CL[iI]Q
+    XT) Build
+- brand_replacement: Motorola
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: ; {0,2}(Motorola MOT-|Motorola[ _\-]|MOT\-?)([^;/]{1,100}) Build
+- brand_replacement: Motorola
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: ; {0,2}(Moto[_ ]?|MOT\-)([^;/]{1,100}) Build
+- brand_replacement: Mpman
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}((?:MP[DQ]C|MPG\d{1,4}|MP\d{3,4}|MID(?:(?:10[234]|114|43|7[247]|8[24]|7)C|8[01]1))[^;/]*)(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: Msi
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(?:MSI[ _]|)(Primo\d+|Enjoy[ _\-][^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Multilaser
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}Multilaser[ _]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: MyPhone
+  device_replacement: $1$2 $3
+  model_replacement: $1$2 $3
+  regex: '; {0,2}(My)[_]?(Pad)[ _]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: MyPhone
+  device_replacement: $1$2 $3
+  model_replacement: $3
+  regex: '; {0,2}(My)\|?(Phone)[ _]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: MyPhone
+  device_replacement: $1 $2
+  model_replacement: $1 $2
+  regex: '; {0,2}(A\d+)[ _](Duo|)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Mytab
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(myTab[^;/]*)(?: Build|\) AppleWebKit)'
+- brand_replacement: Nabi
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: '; {0,2}(NABI2?-)([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Nec
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(N-\d+[CDE])(?: Build|\) AppleWebKit)'
+- brand_replacement: Nec
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: '; ?(NEC-)(.{0,200}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Nec
+  device_replacement: $1
+  model_replacement: Lifetouch Note
+  regex: '; {0,2}(LT-NA7)(?: Build|\) AppleWebKit)'
+- brand_replacement: Nextbook
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(NXM\d+[A-Za-z0-9_]{0,50}|Next\d[A-Za-z0-9_ \-]{0,50}|NEXT\d[A-Za-z0-9_
+    \-]{0,50}|Nextbook [A-Za-z0-9_ ]{0,50}|DATAM803HC|M805)(?: Build|[\);])'
+- brand_replacement: Nokia
+  device_replacement: $1$2$3
+  model_replacement: $3
+  regex: ; {0,2}(Nokia)([ _\-]{0,5})([^;/]{0,50}) Build
+  regex_flag: i
+- brand_replacement: Nokia
+  device_replacement: Nokia $1
+  model_replacement: $1
+  regex: '; {0,2}(TA\-\d{4})(?: Build|\) AppleWebKit)'
+- brand_replacement: Nook
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: '; {0,2}(Nook ?|Barnes & Noble Nook |BN )([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Nook
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: '; {0,2}(NOOK |)(BNRV200|BNRV200A|BNTV250|BNTV250A|BNTV400|BNTV600|LogicPD
+    Zoom2)(?: Build|\) AppleWebKit)'
+- brand_replacement: Nook
+  device_replacement: $1
+  model_replacement: Tablet
+  regex: ; Build/(Nook)
+- brand_replacement: Olivetti
+  device_replacement: Olivetti $1
+  model_replacement: $1
+  regex: '; {0,2}(OP110|OliPad[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Omega
+  device_replacement: Omega $1
+  model_replacement: $1
+  regex: '; {0,2}OMEGA[ _\-](MID[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Omega
+  device_replacement: Omega $1
+  model_replacement: $1
+  regex: ^(MID7500|MID\d+) Mozilla/5\.0 \(iPad;
+- brand_replacement: Openpeak
+  device_replacement: Openpeak $1
+  model_replacement: $1
+  regex: '; {0,2}((?:CIUS|cius)[^;/]*)(?: Build|\) AppleWebKit)'
+- brand_replacement: Oppo
+  device_replacement: Oppo $1
+  model_replacement: $1
+  regex: '; {0,2}(Find ?(?:5|7a)|R8[012]\d{1,2}|T703\d?|U70\d{1,2}T?|X90\d{1,2}|[AFR]\d{1,2}[a-z]{1,2})(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: Oppo
+  device_replacement: Oppo $1
+  model_replacement: $1
+  regex: '; {0,2}OPPO ?([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Oppo
+  device_replacement: Oppo $1
+  model_replacement: $1
+  regex: '; {0,2}(CPH\d{1,4}|RMX\d{1,4}|P[A-Z]{3}\d{2})(?: Build|\) AppleWebKit)'
+- brand_replacement: Oppo
+  device_replacement: Oppo F1s
+  model_replacement: $1
+  regex: '; {0,2}(A1601)(?: Build|\) AppleWebKit)'
+- brand_replacement: Odys
+  device_replacement: Odys $1
+  model_replacement: $1
+  regex: '; {0,2}(?:Odys\-|ODYS\-|ODYS )([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Odys
+  device_replacement: Odys $1 $2
+  model_replacement: $1 $2
+  regex: '; {0,2}(SELECT) ?(7)(?: Build|\) AppleWebKit)'
+- brand_replacement: Odys
+  device_replacement: Odys $1 $2 $3
+  model_replacement: $1 $2 $3
+  regex: '; {0,2}(PEDI)_(PLUS)_(W)(?: Build|\) AppleWebKit)'
+- brand_replacement: Odys
+  device_replacement: Odys $1
+  model_replacement: $1
+  regex: '; {0,2}(AEON|BRAVIO|FUSION|FUSION2IN1|Genio|EOS10|IEOS[^;/]*|IRON|Loox|LOOX|LOOX
+    Plus|Motion|NOON|NOON_PRO|NEXT|OPOS|PEDI[^;/]*|PRIME[^;/]*|STUDYTAB|TABLO|Tablet-PC-4|UNO_X8|XELIO[^;/]*|Xelio
+    ?\d+ ?[Pp]ro|XENO10|XPRESS PRO)(?: Build|\) AppleWebKit)'
+- brand_replacement: OnePlus
+  device_replacement: OnePlus $1
+  model_replacement: $1
+  regex: '; (ONE [a-zA-Z]\d+)(?: Build|\) AppleWebKit)'
+- brand_replacement: OnePlus
+  device_replacement: OnePlus $1
+  model_replacement: $1
+  regex: '; (ONEPLUS [a-zA-Z]\d+)(?: Build|\) AppleWebKit)'
+- brand_replacement: Orion
+  device_replacement: Orion $1
+  model_replacement: $1
+  regex: '; {0,2}(TP-\d+)(?: Build|\) AppleWebKit)'
+- brand_replacement: PackardBell
+  device_replacement: PackardBell $1
+  model_replacement: $1
+  regex: '; {0,2}(G100W?)(?: Build|\) AppleWebKit)'
+- brand_replacement: $1
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(Panasonic)[_ ]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Panasonic
+  device_replacement: Panasonic $1
+  model_replacement: $1
+  regex: '; {0,2}(FZ-A1B|JT-B1)(?: Build|\) AppleWebKit)'
+- brand_replacement: Panasonic
+  device_replacement: Panasonic $1
+  model_replacement: $1
+  regex: '; {0,2}(dL1|DL1)(?: Build|\) AppleWebKit)'
+- brand_replacement: Pantech
+  device_replacement: Pantech $1$2
+  model_replacement: $1$2
+  regex: ; {0,2}(SKY[ _]|)(IM\-[AT]\d{3}[^;/]{1,100}).{0,30} Build/
+- brand_replacement: Pantech
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}((?:ADR8995|ADR910L|ADR930L|ADR930VW|PTL21|P8000)(?: 4G|)) Build/'
+- brand_replacement: Pantech
+  device_replacement: Pantech $1
+  model_replacement: $1
+  regex: ; {0,2}Pantech([^;/]{1,30}).{0,200}? Build/
+- brand_replacement: Papyre
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(papyre)[ _\-]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Pearl
+  device_replacement: Pearl $1
+  model_replacement: $1
+  regex: '; {0,2}(?:Touchlet )?(X10\.[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Phicomm
+  device_replacement: Phicomm $1
+  model_replacement: $1
+  regex: '; PHICOMM (i800)(?: Build|\) AppleWebKit)'
+- brand_replacement: Phicomm
+  device_replacement: Phicomm $1
+  model_replacement: $1
+  regex: '; PHICOMM ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Phicomm
+  device_replacement: Phicomm $1
+  model_replacement: $1
+  regex: '; {0,2}(FWS\d{3}[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Philips
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(D633|D822|D833|T539|T939|V726|W335|W336|W337|W3568|W536|W5510|W626|W632|W6350|W6360|W6500|W732|W736|W737|W7376|W820|W832|W8355|W8500|W8510|W930)(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: Philips
+  device_replacement: Philips $1
+  model_replacement: $1
+  regex: '; {0,2}(?:Philips|PHILIPS)[ _]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Pipo
+  device_replacement: Pipo $1$2
+  model_replacement: $1$2
+  regex: 'Android 4\..{0,200}; {0,2}(M[12356789]|U[12368]|S[123])\ ?(pro)?(?: Build|\)
+    AppleWebKit)'
+- brand_replacement: Ployer
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(MOMO[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Polaroid
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(?:Polaroid[ _]|)((?:MIDC\d{3,}|PMID\d{2,}|PTAB\d{3,})[^;/]{0,30}?)(\/[^;/]{0,30}|)(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: Polaroid
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(?:Polaroid )(Tablet)(?: Build|\) AppleWebKit)'
+- brand_replacement: Pomp
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: ; {0,2}(POMP)[ _\-](.{1,200}?) {0,2}(?:Build|[;/\)])
+- brand_replacement: Positivo
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(TB07STA|TB10STA|TB07FTA|TB10FTA)(?: Build|\) AppleWebKit)'
+- brand_replacement: Positivo
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(?:Positivo |)((?:YPY|Ypy)[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: POV
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(MOB-[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: POV
+  device_replacement: POV $1
+  model_replacement: $1
+  regex: '; {0,2}POV[ _\-]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: POV
+  device_replacement: POV $1
+  model_replacement: $1
+  regex: '; {0,2}((?:TAB-PLAYTAB|TAB-PROTAB|PROTAB|PlayTabPro|Mobii[ _\-]|TAB-P)[^;/]*)(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: Prestigio
+  device_replacement: Prestigio $1
+  model_replacement: $1
+  regex: '; {0,2}(?:Prestigio |)((?:PAP|PMP)\d[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Proscan
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(PLT[0-9]{4}.{0,200}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Qmobile
+  device_replacement: $1 $2
+  model_replacement: $1 $2
+  regex: '; {0,2}(A2|A5|A8|A900)_?(Classic|)(?: Build|\) AppleWebKit)'
+- brand_replacement: Qmobile
+  device_replacement: Qmobile $2 $3
+  model_replacement: $2 $3
+  regex: '; {0,2}(Q[Mm]obile)_([^_]+)_([^_]+?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Qmobile
+  device_replacement: Qmobile $2
+  model_replacement: $2
+  regex: '; {0,2}(Q\-?[Mm]obile)[_ ](A[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Qmobilevn
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(Q\-Smart)[ _]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Qmobilevn
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(Q\-?[Mm]obile)[ _\-](S[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Quanta
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(TA1013)(?: Build|\) AppleWebKit)'
+- brand_replacement: RCA
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; (RCT\w+)(?: Build|\) AppleWebKit)'
+- brand_replacement: RCA
+  device_replacement: RCA $1
+  model_replacement: $1
+  regex: '; RCA (\w+)(?: Build|\) AppleWebKit)'
+- brand_replacement: Rockchip
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(RK\d+),?(?: Build|\) AppleWebKit)'
+- brand_replacement: Rockchip
+  device_replacement: $1
+  model_replacement: $1
+  regex: ' Build/(RK\d+)'
+- brand_replacement: Samsung
+  device_replacement: Samsung $1$2
+  model_replacement: $2
+  regex: ; {0,2}(SAMSUNG |Samsung |)((?:Galaxy (?:Note II|S\d)|GT-I9082|GT-I9205|GT-N7\d{3}|SM-N9005)[^;/]{0,100})\/?[^;/]{0,50}
+    Build/
+- brand_replacement: Samsung
+  device_replacement: Samsung $1$2
+  model_replacement: $2
+  regex: '; {0,2}(Google |)(Nexus [Ss](?: 4G|)) Build/'
+- brand_replacement: Samsung
+  device_replacement: Samsung $2
+  model_replacement: $2
+  regex: ; {0,2}(SAMSUNG |Samsung )([^\/]{0,50})\/[^ ]{0,50} Build/
+- brand_replacement: Samsung
+  device_replacement: Samsung $1
+  model_replacement: $1
+  regex: '; {0,2}(Galaxy(?: Ace| Nexus| S ?II+|Nexus S| with MCR 1.2| Mini Plus 4G|))
+    Build/'
+- brand_replacement: Samsung
+  device_replacement: Samsung $2
+  model_replacement: $2
+  regex: ; {0,2}(SAMSUNG[ _\-]|)(?:SAMSUNG[ _\-])([^;/]{1,100}) Build
+- brand_replacement: Samsung
+  device_replacement: Samsung $1$2$3
+  model_replacement: $2
+  regex: ; {0,2}(SAMSUNG-|)(GT\-[BINPS]\d{4}[^\/]{0,50})(\/[^ ]{0,50}) Build
+- brand_replacement: Samsung
+  device_replacement: Samsung $1
+  model_replacement: $1
+  regex: (?:; {0,2}|^)((?:GT\-[BIiNPS]\d{4}|I9\d{2}0[A-Za-z\+]?\b)[^;/\)]*?)(?:Build|Linux|MIUI|[;/\)])
+- brand_replacement: Samsung
+  device_replacement: Samsung $1$2
+  model_replacement: $2
+  regex: ; (SAMSUNG-)([A-Za-z0-9\-]{0,50}).{0,200} Build/
+- brand_replacement: Samsung
+  device_replacement: Samsung $1
+  model_replacement: $1
+  regex: ; {0,2}((?:SCH|SGH|SHV|SHW|SPH|SC|SM)\-[A-Za-z0-9 ]{1,50})(/?[^ ]*|) Build
+- brand_replacement: Samsung
+  device_replacement: Samsung $1
+  model_replacement: $1
+  regex: ; {0,2}((?:SC)\-[A-Za-z0-9 ]{1,50})(/?[^ ]*|)\)
+- brand_replacement: Samsung
+  device_replacement: Samsung $1
+  model_replacement: $1
+  regex: ' ((?:SCH)\-[A-Za-z0-9 ]{1,50})(/?[^ ]*|) Build'
+- brand_replacement: Samsung
+  device_replacement: Samsung $1
+  model_replacement: $1
+  regex: ; {0,2}(Behold ?(?:2|II)|YP\-G[^;/]{1,100}|EK-GC100|SCL21|I9300) Build
+- brand_replacement: Samsung
+  device_replacement: Samsung $1
+  model_replacement: $1
+  regex: ; {0,2}((?:SCH|SGH|SHV|SHW|SPH|SC|SM)\-[A-Za-z0-9]{5,6})[\)]
+- brand_replacement: Sharp
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(SH\-?\d\d[^;/]{1,100}|SBM\d[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Sharp
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: '; {0,2}(SHARP[ -])([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Simvalley
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(SPX[_\-]\d[^;/]*)(?: Build|\) AppleWebKit)'
+- brand_replacement: Simvalley
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(SX7\-PEARL\.GmbH)(?: Build|\) AppleWebKit)'
+- brand_replacement: Simvalley
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(SP[T]?\-\d{2}[^;/]*)(?: Build|\) AppleWebKit)'
+- brand_replacement: SKtelesys
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(SK\-.{0,200}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Skytex
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(?:SKYTEX|SX)-([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Skytex
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(IMAGINE [^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: $1
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(SmartQ) ?([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Smartbitt
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(WF7C|WF10C|SBT[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Sharp
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}(SBM(?:003SH|005SH|006SH|007SH|102SH)) Build
+- brand_replacement: Panasonic
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}(003P|101P|101P11C|102P) Build
+- brand_replacement: ZTE
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}(00\dZ) Build/
+- brand_replacement: HTC
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; HTC(X06HT) Build
+- brand_replacement: HTC
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}(001HT|X06HT) Build
+- brand_replacement: Motorola
+  device_replacement: $1
+  model_replacement: XT902
+  regex: ; {0,2}(201M) Build
+- brand_replacement: Trekstor
+  device_replacement: Trekstor $1
+  model_replacement: $1
+  regex: ; {0,2}(ST\d{4}.{0,200})Build/ST
+- brand_replacement: Trekstor
+  device_replacement: Trekstor $1
+  model_replacement: $1
+  regex: '; {0,2}(ST\d{4}.{0,200}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: SonyEricsson
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: ; {0,2}(Sony ?Ericsson ?)([^;/]{1,100}) Build
+- brand_replacement: SonyEricsson
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}((?:SK|ST|E|X|LT|MK|MT|WT)\d{2}[a-z0-9]*(?:-o|)|R800i|U20i) Build
+- brand_replacement: SonyEricsson
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}(Xperia (?:A8|Arc|Acro|Active|Live with Walkman|Mini|Neo|Play|Pro|Ray|X\d+)[^;/]{0,50})
+    Build
+  regex_flag: i
+- brand_replacement: Sony
+  device_replacement: Sony $1
+  model_replacement: $1
+  regex: '; Sony (Tablet[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Sony
+  device_replacement: Sony $1
+  model_replacement: $1
+  regex: '; Sony ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: $1
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(Sony)([A-Za-z0-9\-]+)(?: Build|\) AppleWebKit)'
+- brand_replacement: Sony
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(Xperia [^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Sony
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(C(?:1[0-9]|2[0-9]|53|55|6[0-9])[0-9]{2}|D[25]\d{3}|D6[56]\d{2})(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: Sony
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(SGP\d{3}|SGPT\d{2})(?: Build|\) AppleWebKit)'
+- brand_replacement: Sony
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(NW-Z1000Series)(?: Build|\) AppleWebKit)'
+- brand_replacement: Sony
+  device_replacement: PlayStation 3
+  model_replacement: PlayStation 3
+  regex: PLAYSTATION 3
+- brand_replacement: Sony
+  device_replacement: $1
+  model_replacement: $1
+  regex: (PlayStation (?:Portable|Vita|\d+))
+- brand_replacement: Spice
+  device_replacement: $1$2$3$4
+  model_replacement: Mi$4
+  regex: '; {0,2}((?:CSL_Spice|Spice|SPICE|CSL)[ _\-]?|)([Mm][Ii])([ _\-]|)(\d{3}[^;/]*)(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: Sprint
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: ; {0,2}(Sprint )(.{1,200}?) {0,2}(?:Build|[;/])
+- brand_replacement: Sprint
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: '\b(Sprint)[: ]([^;,/ ]+)'
+- brand_replacement: Tagi
+  device_replacement: $1$2$3
+  model_replacement: $2$3
+  regex: '; {0,2}(TAGI[ ]?)(MID) ?([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Tecmobile
+  device_replacement: Tecmobile $1
+  model_replacement: $1
+  regex: '; {0,2}(Oyster500|Opal 800)(?: Build|\) AppleWebKit)'
+- brand_replacement: Tecno
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: '; {0,2}(TECNO[ _])([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: $1
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}Android for (Telechips|Techvision) ([^ ]+) '
+  regex_flag: i
+- brand_replacement: Telstra
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(T-Hub2)(?: Build|\) AppleWebKit)'
+- brand_replacement: Terra
+  device_replacement: Terra $1$2
+  model_replacement: $1$2
+  regex: '; {0,2}(PAD) ?(100[12])(?: Build|\) AppleWebKit)'
+- brand_replacement: Texet
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(T[BM]-\d{3}[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Thalia
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(tolino [^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Thalia
+  device_replacement: $1
+  model_replacement: Tolino Shine
+  regex: ; {0,2}Build/.{0,200} (TOLINO_BROWSER)
+- brand_replacement: Thl
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(?:CJ[ -])?(ThL|THL)[ -]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Thl
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(T100|T200|T5|W100|W200|W8s)(?: Build|\) AppleWebKit)'
+- brand_replacement: HTC
+  device_replacement: $1
+  model_replacement: Hero
+  regex: ; {0,2}(T-Mobile[ _]G2[ _]Touch) Build
+- brand_replacement: HTC
+  device_replacement: $1
+  model_replacement: Desire Z
+  regex: ; {0,2}(T-Mobile[ _]G2) Build
+- brand_replacement: Huawei
+  device_replacement: $1
+  model_replacement: U8730
+  regex: ; {0,2}(T-Mobile myTouch Q) Build
+- brand_replacement: Huawei
+  device_replacement: $1
+  model_replacement: U8680
+  regex: ; {0,2}(T-Mobile myTouch) Build
+- brand_replacement: HTC
+  device_replacement: $1
+  model_replacement: Espresso
+  regex: ; {0,2}(T-Mobile_Espresso) Build
+- brand_replacement: HTC
+  device_replacement: $1
+  model_replacement: Dream
+  regex: ; {0,2}(T-Mobile G1) Build
+- brand_replacement: HTC
+  device_replacement: $1$2 $3 $4
+  model_replacement: $2 $3 $4
+  regex: \b(T-Mobile ?|)(myTouch)[ _]?([34]G)[ _]?([^\/]*) (?:Mozilla|Build)
+- brand_replacement: Tmobile
+  device_replacement: $1 $2 $3
+  model_replacement: $2 $3
+  regex: \b(T-Mobile)_([^_]+)_(.{0,200}) Build
+- brand_replacement: Tmobile
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: \b(T-Mobile)[_ ]?(.{0,200}?)Build
+- brand_replacement: Tomtec
+  device_replacement: $1
+  model_replacement: $1
+  regex: ' (ATP[0-9]{4})(?: Build|\) AppleWebKit)'
+- brand_replacement: Tooky
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: ' ?(TOOKY)[ _\-]([^;/]{1,100}) ?(?:Build|;)'
+  regex_flag: i
+- brand_replacement: Toshiba
+  device_replacement: $1
+  model_replacement: Folio 100
+  regex: \b(TOSHIBA_AC_AND_AZ|TOSHIBA_FOLIO_AND_A|FOLIO_AND_A)
+- brand_replacement: Toshiba
+  device_replacement: $1
+  model_replacement: Folio 100
+  regex: '; {0,2}([Ff]olio ?100)(?: Build|\) AppleWebKit)'
+- brand_replacement: Toshiba
+  device_replacement: Toshiba $1
+  model_replacement: $1
+  regex: '; {0,2}(AT[0-9]{2,3}(?:\-A|LE\-A|PE\-A|SE|a|)|AT7-A|AT1S0|Hikari-iFrame/WDPF-[^;/]{1,100}|THRiVE|Thrive)(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: Touchmate
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(TM-MID\d+[^;/]{1,50}|TOUCHMATE|MID-750)(?: Build|\) AppleWebKit)'
+- brand_replacement: Touchmate
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(TM-SM\d+[^;/]{1,50}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Treq
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(A10 [Bb]asic2?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Treq
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: '; {0,2}(TREQ[ _\-])([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Umeox
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(X-?5|X-?3)(?: Build|\) AppleWebKit)'
+- brand_replacement: Umeox
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(A502\+?|A936|A603|X1|X2)(?: Build|\) AppleWebKit)'
+- brand_replacement: Vernee
+  device_replacement: Thor
+  model_replacement: Thor
+  regex: ; thor Build/
+- brand_replacement: Vernee
+  device_replacement: Thor $1
+  model_replacement: Thor
+  regex: ; Thor (E)? Build/
+- brand_replacement: Vernee
+  device_replacement: Apollo Lite
+  model_replacement: Apollo
+  regex: ; Apollo Lite Build/
+- brand_replacement: Versus
+  device_replacement: Versus $1
+  model_replacement: $1
+  regex: '(TOUCH(?:TAB|PAD).{1,200}?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Vertu
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '(VERTU) ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Videocon
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: ; {0,2}(Videocon)[ _\-]([^;/]{1,100}?) {0,2}(?:Build|;)
+- brand_replacement: Videocon
+  device_replacement: $1
+  model_replacement: $1
+  regex: ' (VT\d{2}[A-Za-z]*)(?: Build|\) AppleWebKit)'
+- brand_replacement: Viewsonic
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}((?:ViewPad|ViewPhone|VSD)[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Viewsonic
+  device_replacement: $1$2
+  model_replacement: $2
+  regex: '; {0,2}(ViewSonic-)([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Viewsonic
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(GTablet.{0,200}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: vivo
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}([Vv]ivo)[ _]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: $1
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '(Vodafone) (.{0,200}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Walton
+  device_replacement: Walton $1
+  model_replacement: $1
+  regex: '; {0,2}(?:Walton[ _\-]|)(Primo[ _\-][^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Wiko
+  device_replacement: Wiko $1
+  model_replacement: $1
+  regex: '; {0,2}(?:WIKO[ \-]|)(CINK\+?|BARRY|BLOOM|DARKFULL|DARKMOON|DARKNIGHT|DARKSIDE|FIZZ|HIGHWAY|IGGY|OZZY|RAINBOW|STAIRWAY|SUBLIM|WAX|CINK
+    [^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Wellcom
+  device_replacement: Wellcom $1
+  model_replacement: $1
+  regex: '; {0,2}WellcoM-([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: WeTab
+  device_replacement: $1
+  model_replacement: WeTab
+  regex: (?:(WeTab)-Browser|; (wetab) Build)
+- brand_replacement: Wolfgang
+  device_replacement: Wolfgang $1
+  model_replacement: $1
+  regex: '; {0,2}(AT-AS[^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Woxter
+  device_replacement: Woxter $1
+  model_replacement: $1
+  regex: '; {0,2}(?:Woxter|Wxt) ([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: Yarvik
+  device_replacement: Yarvik $1
+  model_replacement: $1
+  regex: '; {0,2}(?:Xenta |Luna |)(TAB[234][0-9]{2}|TAB0[78]-\d{3}|TAB0?9-\d{3}|TAB1[03]-\d{3}|SMP\d{2}-\d{3})(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: Yifang
+  device_replacement: Yifang $1$2$3
+  model_replacement: $2
+  regex: '; {0,2}([A-Z]{2,4})(M\d{3,}[A-Z]{2})([^;\)\/]*)(?: Build|[;\)])'
+- brand_replacement: XiaoMi
+  device_replacement: XiaoMi $1
+  model_replacement: $1
+  regex: ; {0,2}((Mi|MI|HM|MI-ONE|Redmi)[ -](NOTE |Note |)[^;/]*) (Build|MIUI)/
+- brand_replacement: XiaoMi
+  device_replacement: XiaoMi $1
+  model_replacement: $1
+  regex: ; {0,2}((Mi|MI|HM|MI-ONE|Redmi)[ -](NOTE |Note |)[^;/\)]*)
+- brand_replacement: XiaoMi
+  device_replacement: XiaoMi $1
+  model_replacement: $1
+  regex: ; {0,2}(MIX) (Build|MIUI)/
+- brand_replacement: XiaoMi
+  device_replacement: XiaoMi $1
+  model_replacement: $1
+  regex: ; {0,2}((MIX) ([^;/]*)) (Build|MIUI)/
+- brand_replacement: Xolo
+  device_replacement: Xolo $1
+  model_replacement: $1
+  regex: '; {0,2}XOLO[ _]([^;/]{0,30}tab.{0,30})(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Xolo
+  device_replacement: Xolo $1
+  model_replacement: $1
+  regex: '; {0,2}XOLO[ _]([^;/]{1,100}?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Xolo
+  device_replacement: Xolo $1
+  model_replacement: $1
+  regex: '; {0,2}(q\d0{2,3}[a-z]?)(?: Build|\) AppleWebKit)'
+  regex_flag: i
+- brand_replacement: Xoro
+  device_replacement: Xoro $1
+  model_replacement: $1
+  regex: '; {0,2}(PAD ?[79]\d+[^;/]{0,50}|TelePAD\d+[^;/])(?: Build|\) AppleWebKit)'
+- brand_replacement: Zopo
+  device_replacement: $1$2$3
+  model_replacement: $1$2$3
+  regex: '; {0,2}(?:(?:ZOPO|Zopo)[ _]([^;/]{1,100}?)|(ZP ?(?:\d{2}[^;/]{1,100}|C2))|(C[2379]))(?:
+    Build|\) AppleWebKit)'
+- brand_replacement: ZiiLabs
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(ZiiLABS) (Zii[^;/]*)(?: Build|\) AppleWebKit)'
+- brand_replacement: ZiiLabs
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: '; {0,2}(Zii)_([^;/]*)(?: Build|\) AppleWebKit)'
+- brand_replacement: ZTE
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(ARIZONA|(?:ATLAS|Atlas) W|D930|Grand (?:[SX][^;]{0,200}?|Era|Memo[^;]{0,200}?)|JOE|(?:Kis|KIS)\b[^;]{0,200}?|Libra|Light
+    [^;]{0,200}?|N8[056][01]|N850L|N8000|N9[15]\d{2}|N9810|NX501|Optik|(?:Vip )Racer[^;]{0,200}?|RacerII|RACERII|San
+    Francisco[^;]{0,200}?|V9[AC]|V55|V881|Z[679][0-9]{2}[A-z]?)(?: Build|\) AppleWebKit)'
+- brand_replacement: ZTE
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}([A-Z]\d+)_USA_[^;]{0,200}(?: Build|\) AppleWebKit)'
+- brand_replacement: ZTE
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; {0,2}(SmartTab\d+)[^;]{0,50}(?: Build|\) AppleWebKit)'
+- brand_replacement: ZTE
+  device_replacement: ZTE Blade$1
+  model_replacement: Blade$1
+  regex: '; {0,2}(?:Blade|BLADE|ZTE-BLADE)([^;/]*)(?: Build|\) AppleWebKit)'
+- brand_replacement: ZTE
+  device_replacement: ZTE Skate$1
+  model_replacement: Skate$1
+  regex: '; {0,2}(?:Skate|SKATE|ZTE-SKATE)([^;/]*)(?: Build|\) AppleWebKit)'
+- brand_replacement: ZTE
+  device_replacement: $1$2
+  model_replacement: $1$2
+  regex: '; {0,2}(Orange |Optimus )(Monte Carlo|San Francisco)(?: Build|\) AppleWebKit)'
+- brand_replacement: ZTE
+  device_replacement: ZTE $1
+  model_replacement: $1
+  regex: '; {0,2}(?:ZXY-ZTE_|ZTE\-U |ZTE[\- _]|ZTE-C[_ ])([^;/]{1,100}?)(?: Build|\)
+    AppleWebKit)'
+- brand_replacement: ZTE
+  device_replacement: $1 $2
+  model_replacement: $1 $2
+  regex: '; (BASE) (lutea|Lutea 2|Tab[^;]{0,200}?)(?: Build|\) AppleWebKit)'
+- brand_replacement: ZTE
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; (Avea inTouch 2|soft stone|tmn smart a7|Movistar[ _]Link)(?: Build|\)
+    AppleWebKit)'
+  regex_flag: i
+- brand_replacement: ZTE
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}(vp9plus)\)
+- brand_replacement: Zync
+  device_replacement: $1
+  model_replacement: $1
+  regex: '; ?(Cloud[ _]Z5|z1000|Z99 2G|z99|z930|z999|z990|z909|Z919|z900)(?: Build|\)
+    AppleWebKit)'
+- brand_replacement: Amazon
+  device_replacement: Kindle Fire
+  model_replacement: Kindle Fire
+  regex: ; ?(KFOT|Kindle Fire) Build\b
+- brand_replacement: Amazon
+  device_replacement: Kindle Fire 2
+  model_replacement: Kindle Fire 2
+  regex: ; ?(KFOTE|Amazon Kindle Fire2) Build\b
+- brand_replacement: Amazon
+  device_replacement: Kindle Fire HD
+  model_replacement: Kindle Fire HD 7"
+  regex: ; ?(KFTT) Build\b
+- brand_replacement: Amazon
+  device_replacement: Kindle Fire HD 8.9" WiFi
+  model_replacement: Kindle Fire HD 8.9" WiFi
+  regex: ; ?(KFJWI) Build\b
+- brand_replacement: Amazon
+  device_replacement: Kindle Fire HD 8.9" 4G
+  model_replacement: Kindle Fire HD 8.9" 4G
+  regex: ; ?(KFJWA) Build\b
+- brand_replacement: Amazon
+  device_replacement: Kindle Fire HD 7" WiFi
+  model_replacement: Kindle Fire HD 7" WiFi
+  regex: ; ?(KFSOWI) Build\b
+- brand_replacement: Amazon
+  device_replacement: Kindle Fire HDX 7" WiFi
+  model_replacement: Kindle Fire HDX 7" WiFi
+  regex: ; ?(KFTHWI) Build\b
+- brand_replacement: Amazon
+  device_replacement: Kindle Fire HDX 7" 4G
+  model_replacement: Kindle Fire HDX 7" 4G
+  regex: ; ?(KFTHWA) Build\b
+- brand_replacement: Amazon
+  device_replacement: Kindle Fire HDX 8.9" WiFi
+  model_replacement: Kindle Fire HDX 8.9" WiFi
+  regex: ; ?(KFAPWI) Build\b
+- brand_replacement: Amazon
+  device_replacement: Kindle Fire HDX 8.9" 4G
+  model_replacement: Kindle Fire HDX 8.9" 4G
+  regex: ; ?(KFAPWA) Build\b
+- brand_replacement: Amazon
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; ?Amazon ([^;/]{1,100}) Build\b
+- brand_replacement: Amazon
+  device_replacement: Kindle
+  model_replacement: Kindle
+  regex: ; ?(Kindle) Build\b
+- brand_replacement: Amazon
+  device_replacement: Kindle Fire
+  model_replacement: Kindle Fire$2
+  regex: ; ?(Silk)/(\d+)\.(\d+)(?:\.([0-9\-]+)|) Build\b
+- brand_replacement: Amazon
+  device_replacement: Kindle
+  model_replacement: $1 $2
+  regex: ' (Kindle)/(\d+\.\d+)'
+- brand_replacement: Amazon
+  device_replacement: Kindle
+  model_replacement: Kindle
+  regex: ' (Silk|Kindle)/(\d+)\.'
+- brand_replacement: $1
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: (sprd)\-([^/]{1,50})/
+- brand_replacement: Hero
+  device_replacement: $1
+  model_replacement: $1
+  regex: ; {0,2}(H\d{2}00\+?) Build
+- brand_replacement: Xianghe
+  device_replacement: Xianghe $1
+  model_replacement: $1
+  regex: ; {0,2}(iphone|iPhone5) Build/
+- brand_replacement: Xianghe
+  device_replacement: Xianghe $1
+  model_replacement: $1
+  regex: ; {0,2}(e\d{4}[a-z]?_?v\d+|v89_[^;/]{1,100})[^;/]{1,30} Build/
+- brand_replacement: Cellular
+  device_replacement: $1
+  model_replacement: $1
+  regex: \bUSCC[_\-]?([^ ;/\)]+)
+- brand_replacement: Alcatel
+  device_replacement: Alcatel $1
+  model_replacement: $1
+  regex: Windows Phone [^;]{1,30}; .{0,100}?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch;
+    ?|Touch; ?|)(?:ALCATEL)[^;]{0,200}; {0,2}([^;,\)]+)
+- brand_replacement: Asus
+  device_replacement: Asus $1
+  model_replacement: $1
+  regex: Windows Phone [^;]{1,30}; .{0,100}?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch;
+    ?|Touch; ?|WpsLondonTest; ?|)(?:ASUS|Asus)[^;]{0,200}; {0,2}([^;,\)]+)
+- brand_replacement: Dell
+  device_replacement: Dell $1
+  model_replacement: $1
+  regex: Windows Phone [^;]{1,30}; .{0,100}?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch;
+    ?|Touch; ?|)(?:DELL|Dell)[^;]{0,200}; {0,2}([^;,\)]+)
+- brand_replacement: HTC
+  device_replacement: HTC $1
+  model_replacement: $1
+  regex: Windows Phone [^;]{1,30}; .{0,100}?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch;
+    ?|Touch; ?|WpsLondonTest; ?|)(?:HTC|Htc|HTC_blocked[^;]{0,200})[^;]{0,200}; {0,2}(?:HTC|)([^;,\)]+)
+- brand_replacement: Huawei
+  device_replacement: Huawei $1
+  model_replacement: $1
+  regex: Windows Phone [^;]{1,30}; .{0,100}?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch;
+    ?|Touch; ?|)(?:HUAWEI)[^;]{0,200}; {0,2}(?:HUAWEI |)([^;,\)]+)
+- brand_replacement: LG
+  device_replacement: LG $1
+  model_replacement: $1
+  regex: Windows Phone [^;]{1,30}; .{0,100}?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch;
+    ?|Touch; ?|)(?:LG|Lg)[^;]{0,200}; {0,2}(?:LG[ \-]|)([^;,\)]+)
+- brand_replacement: Nokia
+  device_replacement: Lumia $1
+  model_replacement: Lumia $1
+  regex: Windows Phone [^;]{1,30}; .{0,100}?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch;
+    ?|Touch; ?|)(?:rv:11; |)(?:NOKIA|Nokia)[^;]{0,200}; {0,2}(?:NOKIA ?|Nokia ?|LUMIA
+    ?|[Ll]umia ?|)(\d{3,10}[^;\)]*)
+- brand_replacement: Nokia
+  device_replacement: Nokia $1
+  model_replacement: $1
+  regex: Windows Phone [^;]{1,30}; .{0,100}?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch;
+    ?|Touch; ?|)(?:NOKIA|Nokia)[^;]{0,200}; {0,2}(RM-\d{3,})
+- brand_replacement: Nokia
+  device_replacement: Nokia $1
+  model_replacement: $1
+  regex: (?:Windows Phone [^;]{1,30}; .{0,100}?IEMobile/[^;\)]+[;\)]|WPDesktop;) ?(?:ARM;
+    ?Touch; ?|Touch; ?|)(?:NOKIA|Nokia)[^;]{0,200}; {0,2}(?:NOKIA ?|Nokia ?|LUMIA
+    ?|[Ll]umia ?|)([^;\)]+)
+- brand_replacement: Microsoft
+  device_replacement: Microsoft $1
+  model_replacement: $1
+  regex: 'Windows Phone [^;]{1,30}; .{0,100}?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch;
+    ?|Touch; ?|)(?:Microsoft(?: Corporation|))[^;]{0,200}; {0,2}([^;,\)]+)'
+- brand_replacement: Samsung
+  device_replacement: Samsung $1
+  model_replacement: $1
+  regex: Windows Phone [^;]{1,30}; .{0,100}?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch;
+    ?|Touch; ?|WpsLondonTest; ?|)(?:SAMSUNG)[^;]{0,200}; {0,2}(?:SAMSUNG |)([^;,\.\)]+)
+- brand_replacement: Toshiba
+  device_replacement: Toshiba $1
+  model_replacement: $1
+  regex: Windows Phone [^;]{1,30}; .{0,100}?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch;
+    ?|Touch; ?|WpsLondonTest; ?|)(?:TOSHIBA|FujitsuToshibaMobileCommun)[^;]{0,200};
+    {0,2}([^;,\)]+)
+- brand_replacement: $1
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: Windows Phone [^;]{1,30}; .{0,100}?IEMobile/[^;\)]+[;\)] ?(?:ARM; ?Touch;
+    ?|Touch; ?|WpsLondonTest; ?|)([^;]{1,200}); {0,2}([^;,\)]+)
+- brand_replacement: Samsung
+  device_replacement: Samsung $1
+  model_replacement: $1
+  regex: (?:^|; )SAMSUNG\-([A-Za-z0-9\-]{1,50}).{0,200} Bada/
+- brand_replacement: Alcatel
+  device_replacement: Alcatel $1 $2 $3
+  model_replacement: One Touch $3
+  regex: \(Mobile; ALCATEL ?(One|ONE) ?(Touch|TOUCH) ?([^;/]{1,100}?)(?:/[^;]{1,200}|);
+    rv:[^\)]{1,200}\) Gecko/[^\/]{1,200} Firefox/
+- brand_replacement: ZTE
+  device_replacement: ZTE $1$2
+  model_replacement: $1$2
+  regex: \(Mobile; (?:ZTE([^;]{1,200})|(OpenC)); rv:[^\)]{1,200}\) Gecko/[^\/]{1,200}
+    Firefox/
+- brand_replacement: Alcatel
+  device_replacement: Alcatel $1
+  model_replacement: $1
+  regex: \(Mobile; ALCATEL([A-Za-z0-9\-]+); rv:[^\)]{1,200}\) Gecko/[^\/]{1,200} Firefox/[^\/]{1,200}
+    KaiOS/
+- brand_replacement: LYF
+  device_replacement: LYF $1
+  model_replacement: $1
+  regex: \(Mobile; LYF\/([A-Za-z0-9\-]{1,100})\/.{0,100};.{0,100}rv:[^\)]{1,100}\)
+    Gecko/[^\/]{1,100} Firefox/[^\/]{1,100} KAIOS/
+- brand_replacement: Nokia
+  device_replacement: Nokia $1
+  model_replacement: $1
+  regex: \(Mobile; Nokia_([A-Za-z0-9\-]{1,100})_.{1,100}; rv:[^\)]{1,100}\) Gecko/[^\/]{1,100}
+    Firefox/[^\/]{1,100} KAIOS/
+- brand_replacement: Nokia
+  device_replacement: Nokia $1
+  model_replacement: $1$2
+  regex: Nokia(N[0-9]+)([A-Za-z_\-][A-Za-z0-9_\-]*)
+- brand_replacement: Nokia
+  device_replacement: Nokia $1$2$3
+  model_replacement: $1$2$3
+  regex: (?:NOKIA|Nokia)(?:\-| {0,2})(?:([A-Za-z0-9]+)\-[0-9a-f]{32}|([A-Za-z0-9\-]+)(?:UCBrowser)|([A-Za-z0-9\-]+))
+- brand_replacement: Nokia
+  device_replacement: Lumia $1
+  model_replacement: Lumia $1
+  regex: Lumia ([A-Za-z0-9\-]+)
+- brand_replacement: $1
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: \(Symbian; U; S60 V5; [A-z]{2}\-[A-z]{2}; (SonyEricsson|Samsung|Nokia|LG)([^;/]{1,100}?)\)
+- brand_replacement: Nokia
+  device_replacement: Nokia $1
+  model_replacement: $1
+  regex: \(Symbian(?:/3|); U; ([^;]{1,200});
+- brand_replacement: BlackBerry
+  device_replacement: BlackBerry $1
+  model_replacement: $1
+  regex: BB10; ([A-Za-z0-9\- ]+)\)
+- brand_replacement: BlackBerry
+  device_replacement: BlackBerry Playbook
+  model_replacement: Playbook
+  regex: Play[Bb]ook.{1,200}RIM Tablet OS
+- brand_replacement: BlackBerry
+  device_replacement: BlackBerry $1
+  model_replacement: $1
+  regex: Black[Bb]erry ([0-9]+);
+- brand_replacement: BlackBerry
+  device_replacement: BlackBerry $1
+  model_replacement: $1
+  regex: Black[Bb]erry([0-9]+)
+- brand_replacement: BlackBerry
+  device_replacement: BlackBerry
+  model_replacement: $1
+  regex: Black[Bb]erry;
+- brand_replacement: Palm
+  device_replacement: Palm $1
+  model_replacement: $1
+  regex: (Pre|Pixi)/\d+\.\d+
+- brand_replacement: Palm
+  device_replacement: Palm $1
+  model_replacement: $1
+  regex: Palm([0-9]+)
+- brand_replacement: Palm
+  device_replacement: Palm Treo $1
+  model_replacement: Treo $1
+  regex: Treo([A-Za-z0-9]+)
+- brand_replacement: HP
+  device_replacement: HP Veer
+  model_replacement: Veer
+  regex: webOS.{0,200}(P160U(?:NA|))/(\d+).(\d+)
+- brand_replacement: HP
+  device_replacement: HP TouchPad
+  model_replacement: TouchPad
+  regex: (Touch[Pp]ad)/\d+\.\d+
+- brand_replacement: HP
+  device_replacement: HP iPAQ $1
+  model_replacement: iPAQ $1
+  regex: HPiPAQ([A-Za-z0-9]{1,20})/\d+\.\d+
+- brand_replacement: Sony
+  device_replacement: $1
+  model_replacement: $1 $2
+  regex: PDA; (PalmOS)/sony/model ([a-z]+)/Revision
+- brand_replacement: Apple
+  device_replacement: AppleTV
+  model_replacement: AppleTV
+  regex: (Apple\s?TV)
+- brand_replacement: Tesla
+  device_replacement: Tesla Model S
+  model_replacement: Model S
+  regex: (QtCarBrowser)
+- brand_replacement: Apple
+  device_replacement: $1
+  model_replacement: $1$2
+  regex: (iPhone|iPad|iPod)(\d+,\d+)
+- brand_replacement: Apple
+  device_replacement: $1
+  model_replacement: $1
+  regex: (iPad)(?:;| Simulator;)
+- brand_replacement: Apple
+  device_replacement: $1
+  model_replacement: $1
+  regex: (iPod)(?:;| touch;| Simulator;)
+- brand_replacement: Apple
+  device_replacement: $1
+  model_replacement: $1
+  regex: (iPhone)(?:;| Simulator;)
+- brand_replacement: Apple
+  device_replacement: Apple $1
+  model_replacement: $1$2
+  regex: (Watch)(\d+,\d+)
+- brand_replacement: Apple
+  device_replacement: $1
+  model_replacement: $1
+  regex: (Apple Watch)(?:;| Simulator;)
+- brand_replacement: Apple
+  device_replacement: $1
+  model_replacement: $1
+  regex: (HomePod)(?:;| Simulator;)
+- brand_replacement: Apple
+  device_replacement: iPhone
+  model_replacement: iPhone
+  regex: iPhone
+- brand_replacement: Apple
+  device_replacement: $1$2,$3
+  model_replacement: $1$2,$3
+  regex: CFNetwork/.{0,100} Darwin/\d.{0,100}\(((?:Mac|iMac|PowerMac|PowerBook)[^\d]*)(\d+)(?:,|%2C)(\d+)
+- brand_replacement: Apple
+  device_replacement: Mac
+  model_replacement: Mac
+  regex: CFNetwork/.{0,100} Darwin/\d+\.\d+\.\d+ \(x86_64\)
+- brand_replacement: Apple
+  device_replacement: iOS-Device
+  model_replacement: iOS-Device
+  regex: CFNetwork/.{0,100} Darwin/\d
+- brand_replacement: Apple
+  device_replacement: iPhone
+  model_replacement: iPhone
+  regex: Outlook-(iOS)/\d+\.\d+\.prod\.iphone
+- brand_replacement: Acer
+  device_replacement: Acer $1
+  model_replacement: $1
+  regex: acer_([A-Za-z0-9]+)_
+- brand_replacement: Alcatel
+  device_replacement: Alcatel $1
+  model_replacement: $1
+  regex: (?:ALCATEL|Alcatel)-([A-Za-z0-9\-]+)
+- brand_replacement: Amoi
+  device_replacement: Amoi $1
+  model_replacement: $1
+  regex: (?:Amoi|AMOI)\-([A-Za-z0-9]+)
+- brand_replacement: Asus
+  device_replacement: Asus $1
+  model_replacement: $1
+  regex: (?:; |\/|^)((?:Transformer (?:Pad|Prime) |Transformer |PadFone[ _]?)[A-Za-z0-9]*)
+- brand_replacement: Asus
+  device_replacement: Asus $1
+  model_replacement: $1
+  regex: (?:asus.{0,200}?ASUS|Asus|ASUS|asus)[\- ;]*((?:Transformer (?:Pad|Prime)
+    |Transformer |Padfone |Nexus[ _]|)[A-Za-z0-9]+)
+- brand_replacement: Asus
+  device_replacement: Asus $1
+  model_replacement: $1
+  regex: (?:ASUS)_([A-Za-z0-9\-]+)
+- brand_replacement: Bird
+  device_replacement: Bird $1
+  model_replacement: $1
+  regex: \bBIRD[ \-\.]([A-Za-z0-9]+)
+- brand_replacement: Dell
+  device_replacement: Dell $1
+  model_replacement: $1
+  regex: \bDell ([A-Za-z0-9]+)
+- brand_replacement: DoCoMo
+  device_replacement: DoCoMo $1
+  model_replacement: $1
+  regex: DoCoMo/2\.0 ([A-Za-z0-9]+)
+- brand_replacement: DoCoMo
+  device_replacement: DoCoMo $1
+  model_replacement: $1
+  regex: ^.{0,50}?([A-Za-z0-9]{1,30})_W;FOMA
+- brand_replacement: DoCoMo
+  device_replacement: DoCoMo $1
+  model_replacement: $1
+  regex: ^.{0,50}?([A-Za-z0-9]{1,30});FOMA
+- brand_replacement: HTC
+  device_replacement: HTC $1
+  model_replacement: $1
+  regex: \b(?:HTC/|HTC/[a-z0-9]{1,20}/|)HTC[ _\-;]? {0,2}(.{0,200}?)(?:-?Mozilla|fingerPrint|[;/\(\)]|$)
+- brand_replacement: Huawei
+  device_replacement: Huawei $1
+  model_replacement: $1
+  regex: Huawei([A-Za-z0-9]+)
+- brand_replacement: Huawei
+  device_replacement: Huawei $1
+  model_replacement: $1
+  regex: HUAWEI-([A-Za-z0-9]+)
+- brand_replacement: Huawei
+  device_replacement: Huawei $1
+  model_replacement: $1
+  regex: HUAWEI ([A-Za-z0-9\-]+)
+- brand_replacement: Huawei
+  device_replacement: Huawei Vodafone $1
+  model_replacement: Vodafone $1
+  regex: vodafone([A-Za-z0-9]+)
+- brand_replacement: i-mate
+  device_replacement: i-mate $1
+  model_replacement: $1
+  regex: i\-mate ([A-Za-z0-9]+)
+- brand_replacement: Kyocera
+  device_replacement: Kyocera $1
+  model_replacement: $1
+  regex: Kyocera\-([A-Za-z0-9]+)
+- brand_replacement: Kyocera
+  device_replacement: Kyocera $1
+  model_replacement: $1
+  regex: KWC\-([A-Za-z0-9]+)
+- brand_replacement: Lenovo
+  device_replacement: Lenovo $1
+  model_replacement: $1
+  regex: Lenovo[_\-]([A-Za-z0-9]+)
+- brand_replacement: $2
+  device_replacement: $1
+  model_replacement: $3
+  regex: (HbbTV)/[0-9]+\.[0-9]+\.[0-9]+ \( ?;(LG)E ?;([^;]{0,30})
+- brand_replacement: Thomson
+  device_replacement: $1
+  model_replacement: $4
+  regex: (HbbTV)/1\.1\.1.{0,200}CE-HTML/1\.\d;(Vendor/|)(THOM[^;]{0,200}?)[;\s].{0,30}(LF[^;]{1,200});?
+- brand_replacement: $2
+  device_replacement: $1
+  model_replacement: $3
+  regex: '(HbbTV)(?:/1\.1\.1|) ?(?: \(;;;;;\)|); {0,2}CE-HTML(?:/1\.\d|); {0,2}([^
+    ]{1,30}) ([^;]{1,200});'
+- brand_replacement: Samsung
+  device_replacement: $1
+  model_replacement: $1
+  regex: (HbbTV)/1\.1\.1 \(;;;;;\) Maple_2011
+- brand_replacement: $2$3
+  device_replacement: $1
+  model_replacement: $4
+  regex: (HbbTV)/[0-9]+\.[0-9]+\.[0-9]+ \([^;]{0,30}; ?(?:CUS:([^;]{0,200})|([^;]{1,200}))
+    ?; ?([^;]{0,30})
+- device_replacement: $1
+  model_replacement: $1
+  regex: (HbbTV)/[0-9]+\.[0-9]+\.[0-9]+
+- brand_replacement: LG
+  device_replacement: NetCast$2
+  model_replacement: $1
+  regex: LGE; (?:Media\/|)([^;]{0,200});[^;]{0,200};[^;]{0,200};?\); "?LG NetCast(\.TV|\.Media|)-\d+
+- brand_replacement: $1
+  device_replacement: Inettv
+  model_replacement: $2
+  regex: InettvBrowser/[0-9]{1,30}\.[0-9A-Z]{1,30} \([^;]{0,200};(Sony)([^;]{0,200});[^;]{0,200};[^\)]{0,10}\)
+- brand_replacement: Generic_Inettv
+  device_replacement: Inettv
+  model_replacement: $1
+  regex: InettvBrowser/[0-9]{1,30}\.[0-9A-Z]{1,30} \([^;]{0,200};([^;]{0,200});[^;]{0,200};[^\)]{0,10}\)
+- brand_replacement: Generic_Inettv
+  device_replacement: Inettv
+  model_replacement: $1
+  regex: (?:InettvBrowser|TSBNetTV|NETTV|HBBTV)
+- brand_replacement: $1
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: Series60/\d\.\d (LG)[\-]?([A-Za-z0-9 \-]+)
+- brand_replacement: LG
+  device_replacement: LG $1
+  model_replacement: $1
+  regex: \b(?:LGE[ \-]LG\-(?:AX|)|LGE |LGE?-LG|LGE?[ \-]|LG[ /\-]|lg[\-])([A-Za-z0-9]+)\b
+- brand_replacement: LG
+  device_replacement: LG $1
+  model_replacement: $1
+  regex: (?:^LG[\-]?|^LGE[\-/]?)([A-Za-z]+[0-9]+[A-Za-z]*)
+- brand_replacement: LG
+  device_replacement: LG $1
+  model_replacement: $1
+  regex: ^LG([0-9]+[A-Za-z]*)
+- brand_replacement: Microsoft
+  device_replacement: Microsoft $1
+  model_replacement: $1
+  regex: (KIN\.[^ ]+) (\d+)\.(\d+)
+- brand_replacement: Microsoft
+  device_replacement: $1
+  model_replacement: $1
+  regex: (?:MSIE|XBMC).{0,200}\b(Xbox)\b
+- brand_replacement: Microsoft
+  device_replacement: Microsoft Surface RT
+  model_replacement: Surface RT
+  regex: ; ARM; Trident/6\.0; Touch[\);]
+- brand_replacement: Motorola
+  device_replacement: Motorola $1
+  model_replacement: $1
+  regex: Motorola\-([A-Za-z0-9]+)
+- brand_replacement: Motorola
+  device_replacement: Motorola $1
+  model_replacement: $1
+  regex: MOTO\-([A-Za-z0-9]+)
+- brand_replacement: Motorola
+  device_replacement: Motorola $1
+  model_replacement: $1
+  regex: MOT\-([A-z0-9][A-z0-9\-]*)
+- brand_replacement: Nintendo
+  device_replacement: Nintendo Wii U
+  model_replacement: Wii U
+  regex: Nintendo WiiU
+- brand_replacement: Nintendo
+  device_replacement: Nintendo $1
+  model_replacement: $1
+  regex: Nintendo (DS|3DS|DSi|Wii);
+- brand_replacement: Pantech
+  device_replacement: Pantech $1
+  model_replacement: $1
+  regex: (?:Pantech|PANTECH)[ _-]?([A-Za-z0-9\-]+)
+- brand_replacement: Philips
+  device_replacement: Philips $1
+  model_replacement: $1
+  regex: Philips([A-Za-z0-9]+)
+- brand_replacement: Philips
+  device_replacement: Philips $1
+  model_replacement: $1
+  regex: Philips ([A-Za-z0-9]+)
+- brand_replacement: Samsung
+  device_replacement: Samsung $1
+  model_replacement: $1
+  regex: '(SMART-TV); .{0,200} Tizen '
+- brand_replacement: Samsung
+  device_replacement: Samsung $1
+  model_replacement: $1
+  regex: SymbianOS/9\.\d.{0,200} Samsung[/\-]([A-Za-z0-9 \-]+)
+- brand_replacement: $1
+  device_replacement: $1 $2$3
+  model_replacement: $2-$3
+  regex: (Samsung)(SGH)(i[0-9]+)
+- brand_replacement: Samsung
+  device_replacement: $1
+  model_replacement: $1
+  regex: SAMSUNG-ANDROID-MMS/([^;/]{1,100})
+- brand_replacement: Samsung
+  device_replacement: Samsung $1
+  model_replacement: $1
+  regex: SAMSUNG(?:; |[ -/])([A-Za-z0-9\-]+)
+  regex_flag: i
+- brand_replacement: Sega
+  device_replacement: Sega $1
+  model_replacement: $1
+  regex: (Dreamcast)
+- brand_replacement: Siemens
+  device_replacement: Siemens $1
+  model_replacement: $1
+  regex: ^SIE-([A-Za-z0-9]+)
+- brand_replacement: Softbank
+  device_replacement: Softbank $1
+  model_replacement: $1
+  regex: Softbank/[12]\.0/([A-Za-z0-9]+)
+- brand_replacement: SonyEricsson
+  device_replacement: Ericsson $1
+  model_replacement: $1
+  regex: SonyEricsson ?([A-Za-z0-9\-]+)
+- brand_replacement: $2
+  device_replacement: $2 $1
+  model_replacement: $1
+  regex: Android [^;]{1,200}; ([^ ]+) (Sony)/
+- brand_replacement: $1
+  device_replacement: $1 $2
+  model_replacement: $2
+  regex: (Sony)(?:BDP\/|\/|)([^ /;\)]+)[ /;\)]
+- brand_replacement: Apple
+  device_replacement: iPad
+  model_replacement: iPad
+  regex: Puffin/[\d\.]+IT
+- brand_replacement: Apple
+  device_replacement: iPhone
+  model_replacement: iPhone
+  regex: Puffin/[\d\.]+IP
+- brand_replacement: Generic
+  device_replacement: Generic Tablet
+  model_replacement: Tablet
+  regex: Puffin/[\d\.]+AT
+- brand_replacement: Generic
+  device_replacement: Generic Smartphone
+  model_replacement: Smartphone
+  regex: Puffin/[\d\.]+AP
+- brand_replacement: Generic_Android
+  device_replacement: $1
+  model_replacement: $1
+  regex: Android[\- ][\d]+\.[\d]+; [A-Za-z]{2}\-[A-Za-z]{0,2}; WOWMobile (.{1,200})(
+    Build[/ ]|\))
+- brand_replacement: Generic_Android
+  device_replacement: $1
+  model_replacement: $1
+  regex: Android[\- ][\d]+\.[\d]+\-update1; [A-Za-z]{2}\-[A-Za-z]{0,2} {0,2}; {0,2}(.{1,200}?)(
+    Build[/ ]|\))
+- brand_replacement: Generic_Android
+  device_replacement: $1
+  model_replacement: $1
+  regex: Android[\- ][\d]+(?:\.[\d]+)(?:\.[\d]+|); {0,2}[A-Za-z]{2}[_\-][A-Za-z]{0,2}\-?
+    {0,2}; {0,2}(.{1,200}?)( Build[/ ]|\))
+- brand_replacement: Generic_Android
+  device_replacement: $1
+  model_replacement: $1
+  regex: Android[\- ][\d]+(?:\.[\d]+)(?:\.[\d]+|); {0,2}[A-Za-z]{0,2}\- {0,2}; {0,2}(.{1,200}?)(
+    Build[/ ]|\))
+- brand_replacement: Generic
+  device_replacement: Generic Smartphone
+  model_replacement: Smartphone
+  regex: Android[\- ][\d]+(?:\.[\d]+)(?:\.[\d]+|); {0,2}[a-z]{0,2}[_\-]?[A-Za-z]{0,2};?(
+    Build[/ ]|\))
+- brand_replacement: Generic_Android
+  device_replacement: $1
+  model_replacement: $1
+  regex: Android[\- ][\d]+(?:\.[\d]+)(?:\.[\d]+|); {0,3}\-?[A-Za-z]{2}; {0,2}(.{1,50}?)(
+    Build[/ ]|\))
+- brand_replacement: Generic_Android
+  device_replacement: $1
+  model_replacement: $1
+  regex: 'Android \d+?(?:\.\d+|)(?:\.\d+|); ([^;]{1,100}?)(?: Build|\) AppleWebKit).{1,200}?
+    Mobile Safari'
+- brand_replacement: Generic_Android_Tablet
+  device_replacement: $1
+  model_replacement: $1
+  regex: 'Android \d+?(?:\.\d+|)(?:\.\d+|); ([^;]{1,100}?)(?: Build|\) AppleWebKit).{1,200}?
+    Safari'
+- brand_replacement: Generic_Android
+  device_replacement: $1
+  model_replacement: $1
+  regex: 'Android \d+?(?:\.\d+|)(?:\.\d+|); ([^;]{1,100}?)(?: Build|\))'
+- brand_replacement: Generic_Inettv
+  device_replacement: $1
+  model_replacement: $1
+  regex: (GoogleTV)
+- brand_replacement: Generic_Inettv
+  device_replacement: $1
+  model_replacement: $1
+  regex: (WebTV)/\d+.\d+
+- brand_replacement: Generic_Inettv
+  device_replacement: $1
+  model_replacement: $1
+  regex: ^(Roku)/DVP-\d+\.\d+
+- brand_replacement: Generic
+  device_replacement: Generic Tablet
+  model_replacement: Tablet
+  regex: (Android 3\.\d|Opera Tablet|Tablet; .{1,100}Firefox/|Android.{0,100}(?:Tab|Pad))
+  regex_flag: i
+- brand_replacement: Generic
+  device_replacement: Generic Smartphone
+  model_replacement: Smartphone
+  regex: (Symbian|\bS60(Version|V\d)|\bS60\b|\((Series 60|Windows Mobile|Palm OS|Bada);
+    Opera Mini|Windows CE|Opera Mobi|BREW|Brew|Mobile; .{1,200}Firefox/|iPhone OS|Android|MobileSafari|Windows
+    {0,2}Phone|\(webOS/|PalmOS)
+- brand_replacement: Generic
+  device_replacement: Generic Smartphone
+  model_replacement: Smartphone
+  regex: (hiptop|avantgo|plucker|xiino|blazer|elaine)
+  regex_flag: i
+- brand_replacement: Spider
+  device_replacement: Spider
+  model_replacement: Desktop
+  regex: ^.{0,100}(bot|BUbiNG|zao|borg|DBot|oegp|silk|Xenu|zeal|^NING|CCBot|crawl|htdig|lycos|slurp|teoma|voila|yahoo|Sogou|CiBra|Nutch|^Java/|^JNLP/|Daumoa|Daum|Genieo|ichiro|larbin|pompos|Scrapy|snappy|speedy|spider|msnbot|msrbot|vortex|^vortex|crawler|favicon|indexer|Riddler|scooter|scraper|scrubby|WhatWeb|WinHTTP|bingbot|BingPreview|openbot|gigabot|furlbot|polybot|seekbot|^voyager|archiver|Icarus6j|mogimogi|Netvibes|blitzbot|altavista|charlotte|findlinks|Retreiver|TLSProber|WordPress|SeznamBot|ProoXiBot|wsr\-agent|Squrl
+    Java|EtaoSpider|PaperLiBot|SputnikBot|A6\-Indexer|netresearch|searchsight|baiduspider|YisouSpider|ICC\-Crawler|http%20client|Python-urllib|dataparksearch|converacrawler|Screaming
+    Frog|AppEngine-Google|YahooCacheSystem|fast\-webcrawler|Sogou Pic Spider|semanticdiscovery|Innovazion
+    Crawler|facebookexternalhit|Google.{0,200}/\+/web/snippet|Google-HTTP-Java-Client|BlogBridge|IlTrovatore-Setaccio|InternetArchive|GomezAgent|WebThumbnail|heritrix|NewsGator|PagePeeker|Reaper|ZooShot|holmes|NL-Crawler|Pingdom|StatusCake|WhatsApp|masscan|Google
+    Web Preview|Qwantify|Yeti|OgScrper)
+  regex_flag: i
+- brand_replacement: Generic
+  device_replacement: Generic Feature Phone
+  model_replacement: Feature Phone
+  regex: ^(1207|3gso|4thp|501i|502i|503i|504i|505i|506i|6310|6590|770s|802s|a wa|acer|acs\-|airn|alav|asus|attw|au\-m|aur
+    |aus |abac|acoo|aiko|alco|alca|amoi|anex|anny|anyw|aptu|arch|argo|bmobile|bell|bird|bw\-n|bw\-u|beck|benq|bilb|blac|c55/|cdm\-|chtm|capi|comp|cond|dall|dbte|dc\-s|dica|ds\-d|ds12|dait|devi|dmob|doco|dopo|dorado|el(?:38|39|48|49|50|55|58|68)|el[3456]\d{2}dual|erk0|esl8|ex300|ez40|ez60|ez70|ezos|ezze|elai|emul|eric|ezwa|fake|fly\-|fly_|g\-mo|g1
+    u|g560|gf\-5|grun|gene|go.w|good|grad|hcit|hd\-m|hd\-p|hd\-t|hei\-|hp i|hpip|hs\-c|htc
+    |htc\-|htca|htcg)
+  regex_flag: i
+- brand_replacement: Generic
+  device_replacement: Generic Feature Phone
+  model_replacement: Feature Phone
+  regex: ^(htcp|htcs|htct|htc_|haie|hita|huaw|hutc|i\-20|i\-go|i\-ma|i\-mobile|i230|iac|iac\-|iac/|ig01|im1k|inno|iris|jata|kddi|kgt|kgt/|kpt
+    |kwc\-|klon|lexi|lg g|lg\-a|lg\-b|lg\-c|lg\-d|lg\-f|lg\-g|lg\-k|lg\-l|lg\-m|lg\-o|lg\-p|lg\-s|lg\-t|lg\-u|lg\-w|lg/k|lg/l|lg/u|lg50|lg54|lge\-|lge/|leno|m1\-w|m3ga|m50/|maui|mc01|mc21|mcca|medi|meri|mio8|mioa|mo01|mo02|mode|modo|mot
+    |mot\-|mt50|mtp1|mtv |mate|maxo|merc|mits|mobi|motv|mozz|n100|n101|n102|n202|n203|n300|n302|n500|n502|n505|n700|n701|n710|nec\-|nem\-|newg|neon)
+  regex_flag: i
+- brand_replacement: Generic
+  device_replacement: Generic Feature Phone
+  model_replacement: Feature Phone
+  regex: ^(netf|noki|nzph|o2 x|o2\-x|opwv|owg1|opti|oran|ot\-s|p800|pand|pg\-1|pg\-2|pg\-3|pg\-6|pg\-8|pg\-c|pg13|phil|pn\-2|pt\-g|palm|pana|pire|pock|pose|psio|qa\-a|qc\-2|qc\-3|qc\-5|qc\-7|qc07|qc12|qc21|qc32|qc60|qci\-|qwap|qtek|r380|r600|raks|rim9|rove|s55/|sage|sams|sc01|sch\-|scp\-|sdk/|se47|sec\-|sec0|sec1|semc|sgh\-|shar|sie\-|sk\-0|sl45|slid|smb3|smt5|sp01|sph\-|spv
+    |spv\-|sy01|samm|sany|sava|scoo|send|siem|smar|smit|soft|sony|t\-mo|t218|t250|t600|t610|t618|tcl\-|tdg\-|telm|tim\-|ts70|tsm\-|tsm3|tsm5|tx\-9|tagt)
+  regex_flag: i
+- brand_replacement: Generic
+  device_replacement: Generic Feature Phone
+  model_replacement: Feature Phone
+  regex: ^(talk|teli|topl|tosh|up.b|upg1|utst|v400|v750|veri|vk\-v|vk40|vk50|vk52|vk53|vm40|vx98|virg|vertu|vite|voda|vulc|w3c
+    |w3c\-|wapj|wapp|wapu|wapm|wig |wapi|wapr|wapv|wapy|wapa|waps|wapt|winc|winw|wonu|x700|xda2|xdag|yas\-|your|zte\-|zeto|aste|audi|avan|blaz|brew|brvw|bumb|ccwa|cell|cldc|cmd\-|dang|eml2|fetc|hipt|http|ibro|idea|ikom|ipaq|jbro|jemu|jigs|keji|kyoc|kyok|libw|m\-cr|midp|mmef|moto|mwbp|mywa|newt|nok6|o2im|pant|pdxg|play|pluc|port|prox|rozo|sama|seri|smal|symb|treo|upsi|vx52|vx53|vx60|vx61|vx70|vx80|vx81|vx83|vx85|wap\-|webc|whit|wmlb|xda\-|xda_)
+  regex_flag: i
+- brand_replacement: Generic
+  device_replacement: Generic Feature Phone
+  model_replacement: Feature Phone
+  regex: ^(Ice)$
+- brand_replacement: Generic
+  device_replacement: Generic Feature Phone
+  model_replacement: Feature Phone
+  regex: (wap[\-\ ]browser|maui|netfront|obigo|teleca|up\.browser|midp|Opera Mini)
+  regex_flag: i
+- brand_replacement: Apple
+  device_replacement: Mac
+  model_replacement: Mac
+  regex: Mac OS
diff --git a/tests/queries/0_stateless/data_ua_parser/os.yaml b/tests/queries/0_stateless/data_ua_parser/os.yaml
new file mode 100644
index 00000000000..13394fd50e2
--- /dev/null
+++ b/tests/queries/0_stateless/data_ua_parser/os.yaml
@@ -0,0 +1,1075 @@
+- os_replacement: $1
+  os_v1_replacement: '2013'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: HbbTV/\d+\.\d+\.\d+ \( ;(LG)E ;NetCast 4.0
+- os_replacement: $1
+  os_v1_replacement: '2012'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: HbbTV/\d+\.\d+\.\d+ \( ;(LG)E ;NetCast 3.0
+- os_replacement: Samsung
+  os_v1_replacement: '2011'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: HbbTV/1.1.1 \(;;;;;\) Maple_2011
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: UE40F7000
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: HbbTV/\d+\.\d+\.\d+ \(;(Samsung);SmartTV([0-9]{4});.{0,200}FXPDEUC
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: UE32F4500
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: HbbTV/\d+\.\d+\.\d+ \(;(Samsung);SmartTV([0-9]{4});.{0,200}MST12DEUC
+- os_replacement: $1
+  os_v1_replacement: '2013'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: HbbTV/1\.1\.1 \(; (Philips);.{0,200}NETTV/4
+- os_replacement: $1
+  os_v1_replacement: '2012'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: HbbTV/1\.1\.1 \(; (Philips);.{0,200}NETTV/3
+- os_replacement: $1
+  os_v1_replacement: '2011'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: HbbTV/1\.1\.1 \(; (Philips);.{0,200}NETTV/2
+- os_replacement: FireHbbTV
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: HbbTV/\d+\.\d+\.\d+.{0,100}(firetv)-firefox-plugin (\d+).(\d+).(\d+)
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: HbbTV/\d+\.\d+\.\d+ \(.{0,30}; ?([a-zA-Z]+) ?;.{0,30}(201[1-9]).{0,30}\)
+- os_replacement: Other
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: AspiegelBot
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Windows Phone) (?:OS[ /])?(\d+)\.(\d+)
+- os_replacement: iOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CPU[ +]OS|iPhone[ +]OS|CPU[ +]iPhone)[ +]+(\d+)[_\.](\d+)(?:[_\.](\d+)|).{0,100}Outlook-iOS-Android
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: ArcGIS\.?(iOS|Android)-\d+\.\d+(?:\.\d+|)(?:[^\/]{1,50}|)\/(\d+)(?:\.(\d+)(?:\.(\d+)|)|)
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: ArcGISRuntime-(?:Android|iOS)\/\d+\.\d+(?:\.\d+|) \((Android|iOS) (\d+)(?:\.(\d+)(?:\.(\d+)|)|);
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Android)[ \-/](\d+)(?:\.(\d+)|)(?:[.\-]([a-z0-9]+)|)
+- os_replacement: $1
+  os_v1_replacement: '1'
+  os_v2_replacement: '2'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Android) Donut
+- os_replacement: $1
+  os_v1_replacement: '2'
+  os_v2_replacement: '1'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Android) Eclair
+- os_replacement: $1
+  os_v1_replacement: '2'
+  os_v2_replacement: '2'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Android) Froyo
+- os_replacement: $1
+  os_v1_replacement: '2'
+  os_v2_replacement: '3'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Android) Gingerbread
+- os_replacement: $1
+  os_v1_replacement: '3'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Android) Honeycomb
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Android) (\d+);
+- os_replacement: Android
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: ^UCWEB.{0,200}; (Adr) (\d+)\.(\d+)(?:[.\-]([a-z0-9]{1,100})|);
+- os_replacement: iOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: ^UCWEB.{0,200}; (iPad|iPh|iPd) OS (\d+)_(\d+)(?:_(\d+)|);
+- os_replacement: Windows Phone
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: ^UCWEB.{0,200}; (wds) (\d+)\.(\d+)(?:\.(\d+)|);
+- os_replacement: Android
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: ^(JUC).{0,200}; ?U; ?(?:Android|)(\d+)\.(\d+)(?:[\.\-]([a-z0-9]{1,100})|)
+- os_replacement: Android
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (android)\s(?:mobile\/)(\d+)(?:\.(\d+)(?:\.(\d+)|)|)
+- os_replacement: Android
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Silk-Accelerated=[a-z]{4,5})
+- os_replacement: Chrome OS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (x86_64|aarch64)\ (\d+)\.(\d+)\.(\d+).{0,100}Chrome.{0,100}(?:CitrixChromeApp)$
+- os_replacement: Windows Phone
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (XBLWP7)
+- os_replacement: Windows Mobile
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Windows ?Mobile)
+- os_replacement: Windows
+  os_v1_replacement: '10'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Windows 10)
+- os_replacement: Windows
+  os_v1_replacement: XP
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Windows (?:NT 5\.2|NT 5\.1))
+- os_replacement: Windows
+  os_v1_replacement: '7'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Win(?:dows NT |32NT\/)6\.1)
+- os_replacement: Windows
+  os_v1_replacement: Vista
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Win(?:dows NT |32NT\/)6\.0)
+- os_replacement: Windows
+  os_v1_replacement: ME
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Win 9x 4\.90)
+- os_replacement: Windows
+  os_v1_replacement: RT
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Windows NT 6\.2; ARM;)
+- os_replacement: Windows
+  os_v1_replacement: '8'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Win(?:dows NT |32NT\/)6\.2)
+- os_replacement: Windows
+  os_v1_replacement: RT 8
+  os_v2_replacement: '1'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Windows NT 6\.3; ARM;)
+- os_replacement: Windows
+  os_v1_replacement: '8'
+  os_v2_replacement: '1'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Win(?:dows NT |32NT\/)6\.3)
+- os_replacement: Windows
+  os_v1_replacement: '10'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Win(?:dows NT |32NT\/)6\.4)
+- os_replacement: Windows
+  os_v1_replacement: '10'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Windows NT 10\.0)
+- os_replacement: Windows
+  os_v1_replacement: '2000'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Windows NT 5\.0)
+- os_replacement: Windows
+  os_v1_replacement: NT 4.0
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (WinNT4.0)
+- os_replacement: Windows
+  os_v1_replacement: CE
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Windows ?CE)
+- os_replacement: Windows
+  os_v1_replacement: $1
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: Win(?:dows)? ?(95|98|3.1|NT|ME|2000|XP|Vista|7|CE)
+- os_replacement: Windows
+  os_v1_replacement: '3.1'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: Win16
+- os_replacement: Windows
+  os_v1_replacement: '95'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: Win32
+- os_replacement: Windows
+  os_v1_replacement: $1
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: ^Box.{0,200}Windows/([\d.]+);
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Tizen)[/ ](\d+)\.(\d+)
+- os_replacement: Mac OS X
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: ((?:Mac[ +]?|; )OS[ +]X)[\s+/](?:(\d+)[_.](\d+)(?:[_.](\d+)|)|Mach-O)
+- os_replacement: Mac OS X
+  os_v1_replacement: $1
+  os_v2_replacement: $2
+  os_v3_replacement: $3
+  os_v4_replacement: $5
+  regex: Mac OS X\s.{1,50}\s(\d+).(\d+).(\d+)
+- os_replacement: Mac OS X
+  os_v1_replacement: '10'
+  os_v2_replacement: '5'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: ' (Dar)(win)/(9).(\d+).{0,100}\((?:i386|x86_64|Power Macintosh)\)'
+- os_replacement: Mac OS X
+  os_v1_replacement: '10'
+  os_v2_replacement: '6'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: ' (Dar)(win)/(10).(\d+).{0,100}\((?:i386|x86_64)\)'
+- os_replacement: Mac OS X
+  os_v1_replacement: '10'
+  os_v2_replacement: '7'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: ' (Dar)(win)/(11).(\d+).{0,100}\((?:i386|x86_64)\)'
+- os_replacement: Mac OS X
+  os_v1_replacement: '10'
+  os_v2_replacement: '8'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: ' (Dar)(win)/(12).(\d+).{0,100}\((?:i386|x86_64)\)'
+- os_replacement: Mac OS X
+  os_v1_replacement: '10'
+  os_v2_replacement: '9'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: ' (Dar)(win)/(13).(\d+).{0,100}\((?:i386|x86_64)\)'
+- os_replacement: Mac OS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: Mac_PowerPC
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (?:PPC|Intel) (Mac OS X)
+- os_replacement: Mac OS X
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: ^Box.{0,200};(Darwin)/(10)\.(1\d)(?:\.(\d+)|)
+- os_replacement: ATV OS X
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Apple\s?TV)(?:/(\d+)\.(\d+)|)
+- os_replacement: iOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CPU[ +]OS|iPhone[ +]OS|CPU[ +]iPhone|CPU IPhone OS|CPU iPad OS)[ +]+(\d+)[_\.](\d+)(?:[_\.](\d+)|)
+- os_replacement: iOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (iPhone|iPad|iPod); Opera
+- os_replacement: iOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (iPhone|iPad|iPod).{0,100}Mac OS X.{0,100}Version/(\d+)\.(\d+)
+- os_replacement: iOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CFNetwork)/(5)48\.0\.3.{0,100} Darwin/11\.0\.0
+- os_replacement: iOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CFNetwork)/(5)48\.(0)\.4.{0,100} Darwin/(1)1\.0\.0
+- os_replacement: iOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CFNetwork)/(5)48\.(1)\.4
+- os_replacement: iOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CFNetwork)/(4)85\.1(3)\.9
+- os_replacement: iOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CFNetwork)/(6)09\.(1)\.4
+- os_replacement: iOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CFNetwork)/(6)(0)9
+- os_replacement: iOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CFNetwork)/6(7)2\.(1)\.13
+- os_replacement: iOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CFNetwork)/6(7)2\.(1)\.(1)4
+- os_replacement: iOS
+  os_v1_replacement: '7'
+  os_v2_replacement: '1'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CF)(Network)/6(7)(2)\.1\.15
+- os_replacement: iOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CFNetwork)/6(7)2\.(0)\.(?:2|8)
+- os_replacement: iOS
+  os_v1_replacement: '8'
+  os_v2_replacement: 0.b5
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CFNetwork)/709\.1
+- os_replacement: iOS
+  os_v1_replacement: '8'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CF)(Network)/711\.(\d)
+- os_replacement: Mac OS X
+  os_v1_replacement: '10'
+  os_v2_replacement: '10'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CF)(Network)/(720)\.(\d)
+- os_replacement: Mac OS X
+  os_v1_replacement: '10'
+  os_v2_replacement: '11'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CF)(Network)/(760)\.(\d)
+- os_replacement: iOS
+  os_v1_replacement: '9'
+  os_v2_replacement: '3'
+  os_v3_replacement: '1'
+  os_v4_replacement: $5
+  regex: CFNetwork/7.{0,100} Darwin/15\.4\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '9'
+  os_v2_replacement: '3'
+  os_v3_replacement: '2'
+  os_v4_replacement: $5
+  regex: CFNetwork/7.{0,100} Darwin/15\.5\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '9'
+  os_v2_replacement: '3'
+  os_v3_replacement: '5'
+  os_v4_replacement: $5
+  regex: CFNetwork/7.{0,100} Darwin/15\.6\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '9'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CF)(Network)/758\.(\d)
+- os_replacement: iOS
+  os_v1_replacement: '10'
+  os_v2_replacement: '2'
+  os_v3_replacement: '1'
+  os_v4_replacement: $5
+  regex: CFNetwork/808\.3 Darwin/16\.3\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '10'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CF)(Network)/808\.(\d)
+- os_replacement: Mac OS X
+  os_v1_replacement: '10'
+  os_v2_replacement: '13'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/.{0,100} Darwin/17\.\d+.{0,100}\(x86_64\)
+- os_replacement: Mac OS X
+  os_v1_replacement: '10'
+  os_v2_replacement: '12'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/.{0,100} Darwin/16\.\d+.{0,100}\(x86_64\)
+- os_replacement: Mac OS X
+  os_v1_replacement: '10'
+  os_v2_replacement: '11'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/8.{0,100} Darwin/15\.\d+.{0,100}\(x86_64\)
+- os_replacement: iOS
+  os_v1_replacement: '1'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/.{0,100} Darwin/(9)\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '4'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/.{0,100} Darwin/(10)\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '5'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/.{0,100} Darwin/(11)\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '6'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/.{0,100} Darwin/(13)\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '7'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/6.{0,100} Darwin/(14)\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '8'
+  os_v2_replacement: '0'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/7.{0,100} Darwin/(14)\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '9'
+  os_v2_replacement: '0'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/7.{0,100} Darwin/(15)\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '10'
+  os_v2_replacement: '3'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/8.{0,100} Darwin/16\.5\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '10'
+  os_v2_replacement: '3'
+  os_v3_replacement: '2'
+  os_v4_replacement: $5
+  regex: CFNetwork/8.{0,100} Darwin/16\.6\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '10'
+  os_v2_replacement: '3'
+  os_v3_replacement: '3'
+  os_v4_replacement: $5
+  regex: CFNetwork/8.{0,100} Darwin/16\.7\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '10'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/8.{0,100} Darwin/(16)\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '11'
+  os_v2_replacement: '0'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/8.{0,100} Darwin/17\.0\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '11'
+  os_v2_replacement: '1'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/8.{0,100} Darwin/17\.2\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '11'
+  os_v2_replacement: '2'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/8.{0,100} Darwin/17\.3\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '11'
+  os_v2_replacement: '2'
+  os_v3_replacement: '6'
+  os_v4_replacement: $5
+  regex: CFNetwork/8.{0,100} Darwin/17\.4\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '11'
+  os_v2_replacement: '3'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/8.{0,100} Darwin/17\.5\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '11'
+  os_v2_replacement: '4'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/9.{0,100} Darwin/17\.6\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '11'
+  os_v2_replacement: '4'
+  os_v3_replacement: '1'
+  os_v4_replacement: $5
+  regex: CFNetwork/9.{0,100} Darwin/17\.7\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '11'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/8.{0,100} Darwin/(17)\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '12'
+  os_v2_replacement: '0'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/9.{0,100} Darwin/18\.0\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '12'
+  os_v2_replacement: '1'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/9.{0,100} Darwin/18\.2\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '12'
+  os_v2_replacement: '2'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/9.{0,100} Darwin/18\.5\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '12'
+  os_v2_replacement: '3'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/9.{0,100} Darwin/18\.6\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '12'
+  os_v2_replacement: '4'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/9.{0,100} Darwin/18\.7\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '12'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/9.{0,100} Darwin/(18)\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '13'
+  os_v2_replacement: '3'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/11.{0,100} Darwin/19\.2\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '13'
+  os_v2_replacement: '3'
+  os_v3_replacement: '1'
+  os_v4_replacement: $5
+  regex: CFNetwork/11.{0,100} Darwin/19\.3\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '13'
+  os_v2_replacement: '4'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/11.{0,100} Darwin/19\.4\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '13'
+  os_v2_replacement: '5'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/11.{0,100} Darwin/19\.5\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '13'
+  os_v2_replacement: '6'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/11.{0,100} Darwin/19\.6\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '13'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/1[01].{0,100} Darwin/19\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '14'
+  os_v2_replacement: '2'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/12.{0,100} Darwin/20\.1\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '14'
+  os_v2_replacement: '3'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/12.{0,100} Darwin/20\.2\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '14'
+  os_v2_replacement: '4'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/12.{0,100} Darwin/20\.3\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '14'
+  os_v2_replacement: '5'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/12.{0,100} Darwin/20\.4\.\d+
+- os_replacement: iOS
+  os_v1_replacement: '14'
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/.{0,100} Darwin/(20)\.\d+
+- os_replacement: iOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: CFNetwork/.{0,100} Darwin/
+- os_replacement: iOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: '\b(iOS[ /]|iOS; |iPhone(?:/| v|[ _]OS[/,]|; | OS : |\d,\d/|\d,\d; )|iPad/)(\d{1,2})[_\.](\d{1,2})(?:[_\.](\d+)|)'
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: \((iOS);
+- os_replacement: WatchOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (watchOS)[/ ](\d+)\.(\d+)(?:\.(\d+)|)
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: Outlook-(iOS)/\d+\.\d+\.prod\.iphone
+- os_replacement: iOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (iPod|iPhone|iPad)
+- os_replacement: tvOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (tvOS)[/ ](\d+)\.(\d+)(?:\.(\d+)|)
+- os_replacement: Chrome OS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CrOS) [a-z0-9_]+ (\d+)\.(\d+)(?:\.(\d+)|)
+- os_replacement: Debian
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: ([Dd]ebian)
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Linux Mint)(?:/(\d+)|)
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: '(Mandriva)(?: Linux|)/(?:[\d.-]+m[a-z]{2}(\d+).(\d)|)'
+- os_replacement: Symbian OS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Symbian[Oo][Ss])[/ ](\d+)\.(\d+)
+- os_replacement: Symbian^3 Anna
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Symbian/3).{1,200}NokiaBrowser/7\.3
+- os_replacement: Symbian^3 Belle
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Symbian/3).{1,200}NokiaBrowser/7\.4
+- os_replacement: Symbian^3
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Symbian/3)
+- os_replacement: Symbian OS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: \b(Series 60|SymbOS|S60Version|S60V\d|S60\b)
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (MeeGo)
+- os_replacement: Symbian OS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: Symbian [Oo][Ss]
+- os_replacement: Nokia Series 40
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: Series40;
+- os_replacement: Nokia Series 30 Plus
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: Series30Plus;
+- os_replacement: BlackBerry OS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (BB10);.{1,200}Version/(\d+)\.(\d+)\.(\d+)
+- os_replacement: BlackBerry OS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Black[Bb]erry)[0-9a-z]+/(\d+)\.(\d+)\.(\d+)(?:\.(\d+)|)
+- os_replacement: BlackBerry OS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Black[Bb]erry).{1,200}Version/(\d+)\.(\d+)\.(\d+)(?:\.(\d+)|)
+- os_replacement: BlackBerry Tablet OS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (RIM Tablet OS) (\d+)\.(\d+)\.(\d+)
+- os_replacement: BlackBerry Tablet OS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Play[Bb]ook)
+- os_replacement: BlackBerry OS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Black[Bb]erry)
+- os_replacement: KaiOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (K[Aa][Ii]OS)\/(\d+)\.(\d+)(?:\.(\d+)|)
+- os_replacement: Firefox OS
+  os_v1_replacement: '1'
+  os_v2_replacement: '0'
+  os_v3_replacement: '1'
+  os_v4_replacement: $5
+  regex: \((?:Mobile|Tablet);.{1,200}Gecko/18.0 Firefox/\d+\.\d+
+- os_replacement: Firefox OS
+  os_v1_replacement: '1'
+  os_v2_replacement: '1'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: \((?:Mobile|Tablet);.{1,200}Gecko/18.1 Firefox/\d+\.\d+
+- os_replacement: Firefox OS
+  os_v1_replacement: '1'
+  os_v2_replacement: '2'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: \((?:Mobile|Tablet);.{1,200}Gecko/26.0 Firefox/\d+\.\d+
+- os_replacement: Firefox OS
+  os_v1_replacement: '1'
+  os_v2_replacement: '3'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: \((?:Mobile|Tablet);.{1,200}Gecko/28.0 Firefox/\d+\.\d+
+- os_replacement: Firefox OS
+  os_v1_replacement: '1'
+  os_v2_replacement: '4'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: \((?:Mobile|Tablet);.{1,200}Gecko/30.0 Firefox/\d+\.\d+
+- os_replacement: Firefox OS
+  os_v1_replacement: '2'
+  os_v2_replacement: '0'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: \((?:Mobile|Tablet);.{1,200}Gecko/32.0 Firefox/\d+\.\d+
+- os_replacement: Firefox OS
+  os_v1_replacement: '2'
+  os_v2_replacement: '1'
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: \((?:Mobile|Tablet);.{1,200}Gecko/34.0 Firefox/\d+\.\d+
+- os_replacement: Firefox OS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: \((?:Mobile|Tablet);.{1,200}Firefox/\d+\.\d+
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (BREW)[ /](\d+)\.(\d+)\.(\d+)
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (BREW);
+- os_replacement: Brew MP
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Brew MP|BMP)[ /](\d+)\.(\d+)\.(\d+)
+- os_replacement: Brew MP
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: BMP;
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: '(GoogleTV)(?: (\d+)\.(\d+)(?:\.(\d+)|)|/[\da-z]+)'
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (WebTV)/(\d+).(\d+)
+- os_replacement: Chromecast
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (CrKey)(?:[/](\d+)\.(\d+)(?:\.(\d+)|)|)
+- os_replacement: webOS
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (hpw|web)OS/(\d+)\.(\d+)(?:\.(\d+)|)
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (VRE);
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Fedora|Red Hat|PCLinuxOS|Puppy|Ubuntu|Kindle|Bada|Sailfish|Lubuntu|BackTrack|Slackware|(?:Free|Open|Net|\b)BSD)[/
+    ](\d+)\.(\d+)(?:\.(\d+)|)(?:\.(\d+)|)
+- os_replacement: Gentoo
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Linux)[ /](\d+)\.(\d+)(?:\.(\d+)|).{0,100}gentoo
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: \((Bada);
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Windows|Android|WeTab|Maemo|Web0S)
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Ubuntu|Kubuntu|Arch Linux|CentOS|Slackware|Gentoo|openSUSE|SUSE|Red Hat|Fedora|PCLinuxOS|Mageia|(?:Free|Open|Net|\b)BSD)
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: (Linux)(?:[ /](\d+)\.(\d+)(?:\.(\d+)|)|)
+- os_replacement: Solaris
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: SunOS
+- os_replacement: Linux
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: \(linux-gnu\)
+- os_replacement: Red Hat
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: \(x86_64-redhat-linux-gnu\)
+- os_replacement: FreeBSD
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: \((freebsd)(\d+)\.(\d+)\)
+- os_replacement: Linux
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: linux
+- os_replacement: $1
+  os_v1_replacement: $2
+  os_v2_replacement: $3
+  os_v3_replacement: $4
+  os_v4_replacement: $5
+  regex: ^(Roku)/DVP-(\d+)\.(\d+)
diff --git a/tests/queries/0_stateless/data_ua_parser/useragents.txt b/tests/queries/0_stateless/data_ua_parser/useragents.txt
new file mode 100644
index 00000000000..98bc7e31d73
--- /dev/null
+++ b/tests/queries/0_stateless/data_ua_parser/useragents.txt
@@ -0,0 +1,793 @@
+AppleCoreMedia/1.0.0.12B466 (Apple TV; U; CPU OS 8_1_3 like Mac OS X; en_us)
+Mozilla/5.0 (Android 7.0; Mobile; LG-M150; rv:68.0) Gecko/68.0 Firefox/68.0
+Mozilla/5.0 (Android 8.0.0; Mobile; rv:68.0) Gecko/68.0 Firefox/68.0
+Mozilla/5.0 (Android 8.1.0; Tablet; rv:68.0) Gecko/68.0 Firefox/68.0
+Mozilla/5.0 (Android 9; Mobile; rv:68.0) Gecko/68.0 Firefox/68.0
+Mozilla/5.0 (Linux; Android 10; PH-1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 10; Pixel 2 XL) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 10; Pixel 2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 10; Pixel 3 Build/QP1A.190711.020.C3; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/240.0.0.38.121;]
+Mozilla/5.0 (Linux; Android 10; Pixel XL Build/QP1A.190711.020; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 10; Pixel XL) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 4.0.3; HTC Sensation 4G Build/IML74K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.111 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 4.0.3; KFTT) AppleWebKit/537.36 (KHTML, like Gecko) Silk/73.7.5 like Chrome/73.0.3683.90 Safari/537.36
+Mozilla/5.0 (Linux; Android 4.2.2; GT-I9152 Build/JDQ39) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.111 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 4.4.2; GT-N5110) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Linux; Android 4.4.2; RCT6773W22) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 4.4.2; SM-T217S) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 4.4.2; SM-T530NU) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 4.4.2; TegraNote-P1640 Build/KOT49H; en-us) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36
+Mozilla/5.0 (Linux; Android 4.4.3; KFTHWI) AppleWebKit/537.36 (KHTML, like Gecko) Silk/76.3.6 like Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.0.2; SM-A500H) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.90 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 5.0.2; SM-T357T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.0.2; SM-T530NU) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.0.2; SM-T530NU) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.0; RCT6213W87DK) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.103 YaBrowser/19.4.1.454.01 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.0; SM-N900T Build/LRX21V; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/229.0.0.35.117;]
+Mozilla/5.0 (Linux; Android 5.1.1) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Focus/4.4.1 Chrome/70.0.3538.110 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; AFTB) AppleWebKit/537.36 (KHTML, like Gecko) Silk/76.3.16 like Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; AFTT Build/LVY48F; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/70.0.3538.110 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.26
+Mozilla/5.0 (Linux; Android 5.1.1; AFTT) AppleWebKit/537.36 (KHTML, like Gecko) Silk/76.3.16 like Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; KFAUWI) AppleWebKit/537.36 (KHTML, like Gecko) Silk/76.3.6 like Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; KFDOWI) AppleWebKit/537.36 (KHTML, like Gecko) Silk/71.2.4 like Chrome/71.0.3578.98 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; KFDOWI) AppleWebKit/537.36 (KHTML, like Gecko) Silk/76.3.6 like Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; KFFOWI) AppleWebKit/537.36 (KHTML, like Gecko) Silk/76.3.6 like Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; KFGIWI) AppleWebKit/537.36 (KHTML, like Gecko) Silk/76.3.6 like Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; KFSUWI) AppleWebKit/537.36 (KHTML, like Gecko) Silk/76.3.6 like Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; KFSUWI) AppleWebKit/537.36 (KHTML, like Gecko) Silk/77.1.127 like Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; LG-AS330) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; LGL43AL) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; SAMSUNG SM-G530R7 Build/LMY47X) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/9.2 Chrome/67.0.3396.87 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; SAMSUNG SM-T377P) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; SAMSUNG SM-T900) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; SAMSUNG-SM-T337A Build/LMY47X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; SM-G360T1 Build/LMY47X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.81 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; SM-J320FN) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.157 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; SM-T280) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.157 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; SM-T330NU) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; SM-T670) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; SM-T670) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1.1; Vodafone Smart ultra 6 Build/LMY47V; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/74.0.3729.136 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1; BLU Advance 5.0 Build/LMY47I) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.158 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1; HTC Desire 626s) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1; HUAWEI LUA-L22 Build/HUAWEILUA-L22) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.89 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1; NX16A11264) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 5.1; XT1526) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.90 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; CPH1613) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; LG-M153 Build/MXB48T; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/55.0.2883.91 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; LG-M153) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; LGLS676) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; N9136) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.157 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; Nexus 7 Build/MOB30X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.133 Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; SAMSUNG SM-G900I) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; SAMSUNG SM-G900P Build/MMB29M) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/7.2 Chrome/59.0.3071.125 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; SAMSUNG SM-J700M) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; SAMSUNG SM-S327VL) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; SAMSUNG-SM-T377A) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; SM-G532M Build/MMB29T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.91 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; SM-G532M Build/MMB29T; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/75.0.3770.101 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/240.0.0.38.121;]
+Mozilla/5.0 (Linux; Android 6.0.1; SM-G532M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; SM-G550T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; SM-G550T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; SM-G550T1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; SM-G900V) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.75 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; SM-G920A) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; SM-J327P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; SM-N910S) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.143 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; SM-N920V) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.89 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; SM-T350 Build/MMB29M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.125 Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; SM-T560NU) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; SM-T800) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; XT1254) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; Z798BL Build/MMB29M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.87 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0.1; Z799VL Build/MMB29M; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/45.0.2454.95 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0; 5010X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.89 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0; CAM-L21) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0; F3313) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 6.0; RCT6603W47M7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; 5049Z Build/NRD90M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/56.0.2924.87 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; ASUS_A002A) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; Alcatel_5044C) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; Astra Young Pro Build/NRD90M; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/59.0.3071.125 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; Infinix X571) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; LG-H872 Build/NRD90U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.123 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; LG-K425 Build/NRD90U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.91 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; LG-LS777) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; LG-M210) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; LG-M430) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; LG-TP260 Build/NRD90U; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/64.0.3282.137 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.31
+Mozilla/5.0 (Linux; Android 7.0; LG-TP260) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; LG-TP450 Build/NRD90U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.137 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; LG-V521) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.143 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; LG-V521) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; LGMP260 Build/NRD90U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.83 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; LGMS210 Build/NRD90U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.91 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; LGMS210) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; P00I) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; RS988) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SAMSUNG SM-J701F) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SAMSUNG SM-J710F) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SAMSUNG SM-N920T Build/NRD90M) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/9.2 Chrome/67.0.3396.87 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SAMSUNG-SM-G920A) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SM-G920P Build/NRD90M; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36 Flipboard/4.2.23/4722,4.2.23.4722
+Mozilla/5.0 (Linux; Android 7.0; SM-G920V) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SM-G928V) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SM-G950U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SM-G955U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SM-J327T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.157 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SM-J327T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SM-J327T1 Build/NRD90M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.137 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SM-J327T1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.101 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SM-J327T1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SM-N9208) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.90 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SM-N920P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.157 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SM-N920T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SM-T585) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SM-T810) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.143 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SM-T810) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.111 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SM-T810) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SM-T813) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.111 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; SM-T813) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; ST1009X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.143 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0; XT1663) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.0;) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.96 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; A574BL Build/NMF26F; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.31
+Mozilla/5.0 (Linux; Android 7.1.1; A574BL) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; CPH1729 Build/N6F26Q; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/240.0.0.38.121;]
+Mozilla/5.0 (Linux; Android 7.1.1; Coolpad 3632A) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.157 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; General Mobile 4G Dual) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; Moto E (4) Plus Build/NCRS26.58-44-20; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/76.0.3809.111 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.31
+Mozilla/5.0 (Linux; Android 7.1.1; Moto E (4)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.80 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; Moto E (4)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; Moto E (4)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.73 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; Moto E (4)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; NX591J) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; REVVLPLUS C3701A Build/143.54.190611.3701A-TMO) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.137 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; SAMSUNG SM-J320A) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; SAMSUNG SM-T550) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; SAMSUNG-SM-T377A Build/NMF26X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.137 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; SM-J250F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; SM-J700T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; SM-T350) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; SM-T377T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.73 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; SM-T550 Build/NMF26X) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; SM-T550) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; SM-T560NU) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; X20 Build/N6F26Q; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/52.0.2743.100 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; Z851M Build/NMF26V) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.83 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.1; Z899VL Build/NMF26V; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/74.0.3729.136 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.31
+Mozilla/5.0 (Linux; Android 7.1.1; Z982 Build/NMF26V; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/75.0.3770.143 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.31
+Mozilla/5.0 (Linux; Android 7.1.1; Z982) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.2) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Focus/4.4.1 Chrome/70.0.3538.110 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.2; AFTKMST12 Build/NS6265; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/70.0.3538.110 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.26
+Mozilla/5.0 (Linux; Android 7.1.2; AFTKMST12) AppleWebKit/537.36 (KHTML, like Gecko) Silk/76.3.16 like Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.2; AFTMM Build/NS6265; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/70.0.3538.110 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.26
+Mozilla/5.0 (Linux; Android 7.1.2; AFTN Build/NS6265; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/70.0.3538.110 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.26
+Mozilla/5.0 (Linux; Android 7.1.2; KFKAWI Build/NS6301; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/59.0.3071.125 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.2; KFKAWI) AppleWebKit/537.36 (KHTML, like Gecko) Silk/76.3.6 like Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.2; KFMUWI) AppleWebKit/537.36 (KHTML, like Gecko) Silk/76.3.6 like Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.2; LG-SP200) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.143 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.2; LG-SP200) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.2; LM-X210(G)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.111 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.2; LM-X210) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.2; RCT6973W43R) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 7.1.2; Redmi 4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; ASUS_Z01FD) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; AUM-L29) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; BRAVIA 4K GB Build/OPR2.170623.027.S25; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.31
+Mozilla/5.0 (Linux; Android 8.0.0; CMR-W09) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; EVA-AL00) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.73 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; G3223) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; LG-H910) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; LG-H931) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; LG-H932) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SAMSUNG SM-A520F) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SAMSUNG SM-G891A Build/R16NW) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/8.2 Chrome/63.0.3239.111 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SAMSUNG SM-G935T) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SAMSUNG SM-G955U) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SAMSUNG SM-J337T Build/R16NW) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/9.2 Chrome/67.0.3396.87 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SAMSUNG SM-J737P) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SAMSUNG SM-N950F) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SAMSUNG-SM-G891A) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SAMSUNG-SM-G935A) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-A720F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-G570F Build/R16NW; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/73.0.3683.90 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/231.0.0.39.113;]
+Mozilla/5.0 (Linux; Android 8.0.0; SM-G570Y) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-G930T Build/R16NW; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.31
+Mozilla/5.0 (Linux; Android 8.0.0; SM-G930V Build/R16NW) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.137 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-G930VL) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.157 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-G935F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.143 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-G935P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-G935T Build/R16NW; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/240.0.0.38.121;]
+Mozilla/5.0 (Linux; Android 8.0.0; SM-G935T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-G950U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-G955U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.112 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-G955U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-J330G) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-J337T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-J737A) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-J737T1 Build/R16NW) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.126 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-J737T1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-N950F Build/R16NW) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.126 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-N950U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-N950U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-N950U1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; SM-S367VL Build/R16NW) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36 OPT/1.22.80
+Mozilla/5.0 (Linux; Android 8.0.0; VS995) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; XT1635-02) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; moto e5 play) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.111 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; moto e5 play) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; moto e5 supra) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.0.0; moto g(6)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; 5041C) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; 6062W) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; A502DL Build/OPM1.171019.011) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.87 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; A502DL) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; BKK-LX2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; C4 Build/OPM2.171019.012) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; Coolpad 3310A Build/3310A.SPRINT.190213.0S) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; Infinix X604 Build/O11019) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.137 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; Joy 1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LAVA LE9820) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LG-Q710AL) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LM-Q610(FGN)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LM-Q710(FGN) Build/OPM1.171019.019; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/235.0.0.38.118;]
+Mozilla/5.0 (Linux; Android 8.1.0; LM-Q710(FGN)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LM-Q710(FGN)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.111 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LM-Q710(FGN)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LM-Q710(FGN)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LM-V405) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LM-X210(G) Build/OPM1.171019.026; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36 agentweb/4.0.2  UCBrowser/11.6.4.950
+Mozilla/5.0 (Linux; Android 8.1.0; LM-X210(G)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LM-X210(G)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.105 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LM-X210(G)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LM-X212(G)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LM-X220) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LM-X220) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LM-X220PM Build/O11019; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.31
+Mozilla/5.0 (Linux; Android 8.1.0; LM-X410(FG)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LM-X410(FG)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.111 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LM-X410(FG)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LM-X410.FGN Build/OPM1.171019.019) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.91 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LML414DL) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; LML713DL) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; Moto G (5S) Plus) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; One) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/70.0.3538.110 Mobile Safari/537.36/TansoDL
+Mozilla/5.0 (Linux; Android 8.1.0; RCT6873W42BMF8KC Build/O11019) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; REVVL 2 Build/OPM1.171019.011) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.87 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; REVVL 2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SAMSUNG SM-J727T) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SAMSUNG SM-J727T1 Build/M1AJQ) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/9.4 Chrome/67.0.3396.87 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SAMSUNG SM-J727T1) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SAMSUNG SM-T580 Build/M1AJQ) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/9.4 Chrome/67.0.3396.87 Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SAMSUNG-SM-J727A Build/M1AJQ; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/240.0.0.38.121;]
+Mozilla/5.0 (Linux; Android 8.1.0; SM-G610F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SM-J260T1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.111 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SM-J260T1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SM-J260T1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SM-J410F Build/M1AJB) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SM-J727P Build/M1AJQ) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.91 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SM-J727T Build/M1AJQ) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.126 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SM-J727T1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.111 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SM-J727T1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.73 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SM-J727T1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SM-J727V) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SM-J727V) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SM-P580) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SM-T380) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.143 Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SM-T580) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.90 Safari/537.36 EdgA/42.0.2.3928
+Mozilla/5.0 (Linux; Android 8.1.0; SM-T580) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SM-T580) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.89 Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SM-T580) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; SM-T837T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; TECNO CF8 Build/O11019; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/239.0.0.41.152;]
+Mozilla/5.0 (Linux; Android 8.1.0; V1818CA) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.101 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; meizu C9 Build/OPM2.171019.012) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.91 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; vivo 1724) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 8.1.0; vivo 1814) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36 DuckDuckGo/5
+Mozilla/5.0 (Linux; Android 9; 1825) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; ANE-LX2 Build/HUAWEIANE-L22; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/76.0.3809.132 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/236.0.0.40.117;]
+Mozilla/5.0 (Linux; Android 9; BLA-A09) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; CLT-L04) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; CPH1911 Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/239.0.0.41.152;]
+Mozilla/5.0 (Linux; Android 9; CPH1923 Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/76.0.3809.111 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; ELE-L29) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; G8142) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; GM1911) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.111 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; GM1917) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; INE-LX2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.111 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; LM-G710 Build/PKQ1.181105.001; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; LM-Q720) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; LM-V405 Build/PKQ1.190202.001; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.15
+Mozilla/5.0 (Linux; Android 9; LM-V405) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.111 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; LM-V500N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; LM-X420) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; LM-X420) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; MAR-LX1A) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; MI 9) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; Mi A2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; Moto Z (2)) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; Nokia 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; ONEPLUS A6000) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; ONEPLUS A6003) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; ONEPLUS A6013 Build/PKQ1.180716.001; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; ONEPLUS A6013) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.157 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; ONEPLUS A6013) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; PAR-AL00 Build/HUAWEIPAR-AL00; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/235.0.0.38.118;]
+Mozilla/5.0 (Linux; Android 9; Pixel 2 XL) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; Pixel 3 Build/PQ1A.190105.004; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; Pixel 3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.111 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; Pixel 3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; Pixel 3a XL) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; REVVLRY ) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.90 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; RMX1801) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.101 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; Redmi 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; Redmi Note 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.89 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-A102U) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-A505FN) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-A505GN) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-G892U) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-G950U) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-G955F Build/PPR1.180610.011) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/9.4 Chrome/67.0.3396.87 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-G955U) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-G9600 Build/PPR1.180610.011) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/9.4 Chrome/67.0.3396.87 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-G965U) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-G970F) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-G970U) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-G973U Build/PPR1.180610.011) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/9.4 Chrome/67.0.3396.87 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-G973U) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-G975U) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-J415F) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-J730F) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-J737P) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-J737T Build/PPR1.180610.011) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/9.0 Chrome/67.0.3396.87 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-N950U) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-N960F) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-N960U) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-N960U1 Build/PPR1.180610.011) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/9.2 Chrome/67.0.3396.87 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-N970U) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-N975U) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-N975U1) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-T510) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SAMSUNG SM-T720) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SHIELD Android TV Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.31
+Mozilla/5.0 (Linux; Android 9; SM-A102U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-A102U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-A105M Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/237.0.0.44.120;]
+Mozilla/5.0 (Linux; Android 9; SM-A205G) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-A205U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-A505F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-A530F Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/240.0.0.38.121;]
+Mozilla/5.0 (Linux; Android 9; SM-A530N Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36;KAKAOTALK 1908560
+Mozilla/5.0 (Linux; Android 9; SM-A600T) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-A605F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-A920F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G892A) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.136 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G950F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G950U Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.31
+Mozilla/5.0 (Linux; Android 9; SM-G950U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G950U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.111 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G950U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G950U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G950U1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G955F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G955U Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.73 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/240.0.0.38.121;]
+Mozilla/5.0 (Linux; Android 9; SM-G955U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G9600) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G960U Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/73.0.3683.90 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/233.0.0.36.117;]
+Mozilla/5.0 (Linux; Android 9; SM-G960U Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.31
+Mozilla/5.0 (Linux; Android 9; SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.99 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.136 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G960U1 Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/240.0.0.38.121;]
+Mozilla/5.0 (Linux; Android 9; SM-G960U1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G965F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G965U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.136 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G965U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G965U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3921.2 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G965U1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G970U Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/240.0.0.38.121;]
+Mozilla/5.0 (Linux; Android 9; SM-G970U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.101 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G970U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G970U1 Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G973U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.136 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G973U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G973U1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G975U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.101 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G975U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G975U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-G975U1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-J260A) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-J337P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-J600FN) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.89 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-J600G Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.73 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/238.0.0.41.116;]
+Mozilla/5.0 (Linux; Android 9; SM-J730F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-J737A Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.31
+Mozilla/5.0 (Linux; Android 9; SM-J737A) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.136 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-J737V Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/75.0.3770.101 Mobile Safari/537.36 [Pinterest/Android]
+Mozilla/5.0 (Linux; Android 9; SM-J737V) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-J810M) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-N950U Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/240.0.0.38.121;]
+Mozilla/5.0 (Linux; Android 9; SM-N950U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-N950U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.101 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-N950U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.73 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-N950U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-N960F) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-N960U Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/74.0.3729.136 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/240.0.0.38.121;]
+Mozilla/5.0 (Linux; Android 9; SM-N960U Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.31
+Mozilla/5.0 (Linux; Android 9; SM-N960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.157 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-N960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.143 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-N960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-N960U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-N960U1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-N975U Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.73 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.31
+Mozilla/5.0 (Linux; Android 9; SM-N975U Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.31
+Mozilla/5.0 (Linux; Android 9; SM-N975U) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-N976V Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/240.0.0.38.121;]
+Mozilla/5.0 (Linux; Android 9; SM-S367VL) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-S767VL) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-T597P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 9; SM-T720) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Safari/537.36
+Mozilla/5.0 (Linux; Android 9; TECNO KC8) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; VOG-L29) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; cp3705A) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.136 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; moto g(6) Build/PPS29.118-15-11; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.92 Mobile Safari/537.36;dailymotion-player-sdk-android 0.1.31
+Mozilla/5.0 (Linux; Android 9; moto g(6) play) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; moto g(7) play Build/PCYS29.105-134-1; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/76.0.3809.132 Mobile Safari/537.36 [FB_IAB/FB4A;FBAV/235.0.0.38.118;]
+Mozilla/5.0 (Linux; Android 9; moto g(7) play) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.80 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; moto g(7) power) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.101 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; moto g(7) power) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.92 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; moto z4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.90 Mobile Safari/537.36
+Mozilla/5.0 (Linux; Android 9; moto z4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.73 Mobile Safari/537.36
+Mozilla/5.0 (Linux; U; Android 4.1.1; en-us; GT-P3113 Build/JRO03C) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Safari/534.30
+Mozilla/5.0 (Linux; U; Android 4.1.2; ar-ae; GT-I8160 Build/JZO54K) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30
+Mozilla/5.0 (Linux; U; Android 4.2.2; en-us; Nexus 7 Build/JDQ39) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Safari/534.30; DailymotionEmbedSDK 1.0
+Mozilla/5.0 (Linux; U; Android 4.4; en-us; SM-E500H Build/JOP24G) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30
+Mozilla/5.0 (Linux; U; Android 6.0.1; en-us; LGMS550 Build/JOP24G) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Chrome/43.0.2357.65 Mobile Safari/534.30
+Mozilla/5.0 (Linux; U; Android 6.0.1; en-us; SM-J737T1 Build/JOP24G) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Chrome/43.0.2357.65 Mobile Safari/534.30
+Mozilla/5.0 (Linux; U; Android 7.0; TECNO CA6 Build/NRD90M; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/64.0.3282.137 Mobile Safari/537.36 OPR/5.3.2254.135058
+Mozilla/5.0 (Linux; U; Android 7.1.2; id-id; Redmi 5A Build/N2G47H) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/53.0.2785.146 Mobile Safari/537.36 XiaoMi/MiuiBrowser/9.5.6
+Mozilla/5.0 (Linux; U; Android 9; in-id; CPH1911 Build/PPR1.180610.011) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/70.0.3538.80 Mobile Safari/537.36 OppoBrowser/25.6.0.0.5beta
+Mozilla/5.0 (Linux; U; Android 9; vivo 1904 Build/PPR1.180610.011; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/74.0.3729.136 Mobile Safari/537.36 OPR/44.1.2254.143214
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10.11; rv:68.0) Gecko/20100101 Firefox/68.0
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:69.0) Gecko/20100101 Firefox/69.0
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:67.0) Gecko/20100101 Firefox/67.0
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0) Gecko/20100101 Firefox/68.0
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:69.0) Gecko/20100101 Firefox/69.0
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:70.0) Gecko/20100101 Firefox/70.0
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/603.3.8 (KHTML, like Gecko) Version/10.1.2 Safari/603.3.8
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.119 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/601.7.7 (KHTML, like Gecko) Version/9.1.2 Safari/601.7.7
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/602.2.14 (KHTML, like Gecko) Version/10.0.1 Safari/602.2.14
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.1.2 Safari/605.1.15
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_3) AppleWebKit/602.4.8 (KHTML, like Gecko) Version/10.0.3 Safari/602.4.8
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.2 Safari/605.1.15
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Safari/604.1.38
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.142 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0.3 Safari/605.1.15
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.1 Safari/605.1.15
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.2 Safari/605.1.15
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0 Safari/605.1.15
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.1 Safari/605.1.15
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.142 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_3) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0.3 Safari/605.1.15
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.142 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_4) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1 Safari/605.1.15
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.1 Safari/605.1.15
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.142 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.75 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.2 Safari/605.1.15
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.1 Safari/605.1.15
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.181 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.181 Safari/537.36
+Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.87 Safari/537.36
+Mozilla/5.0 (PlayStation 4 6.72) AppleWebKit/605.1.15 (KHTML, like Gecko)
+Mozilla/5.0 (SMART-TV; LINUX; Tizen 3.0) AppleWebKit/538.1 (KHTML, like Gecko) Version/3.0 TV Safari/538.1
+Mozilla/5.0 (SMART-TV; Linux; Tizen 3.0) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/2.0 Chrome/47.0.2526.69 TV safari/537.36
+Mozilla/5.0 (SMART-TV; Linux; Tizen 4.0) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/2.1 Chrome/56.0.2924.0 TV Safari/537.36
+Mozilla/5.0 (SMART-TV; Linux; Tizen 5.0) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/2.2 Chrome/63.0.3239.84 TV Safari/537.36
+Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.140 Safari/537.36 Edge/17.17134
+Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.140 Safari/537.36 Edge/18.17763
+Mozilla/5.0 (Windows NT 10.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.75 Safari/537.36
+Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.79 Safari/537.36 Maxthon/5.2.7.5000
+Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.1.3683.41 Safari/537.36
+Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36
+Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36 OPR/63.0.3368.94
+Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.75 Safari/537.36
+Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) coc_coc_browser/82.0.144 Chrome/76.0.3809.144 Safari/537.36
+Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; rv:11.0) like Gecko
+Mozilla/5.0 (Windows NT 10.0; WOW64; rv:59.0) Gecko/20100101 Firefox/59.0
+Mozilla/5.0 (Windows NT 10.0; WOW64; rv:60.0) Gecko/20100101 Firefox/60.0
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36 Edge/15.15063
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36 Edge/16.16299
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.140 Safari/537.36 Edge/17.17134
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.140 Safari/537.36 Edge/18.17763
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.162 Safari/537.36
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.18362
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.18995
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.19493
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Safari/537.36
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.75 Safari/537.36
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 Safari/537.36
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.80 Safari/537.36
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.110 Safari/537.36 Vivaldi/2.7.1628.30
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36 OPR/63.0.3368.94
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.75 Safari/537.36
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3907.0 Safari/537.36 Edg/79.0.279.0
+Mozilla/5.0 (Windows NT 10.0; Win64; x64; Xbox; Xbox One) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.18362
+Mozilla/5.0 (Windows NT 10.0; Win64; x64; Xbox; Xbox One) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.18363
+Mozilla/5.0 (Windows NT 10.0; Win64; x64; Xbox; Xbox One; WebView/3.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.18362
+Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:61.0) Gecko/20100101 Firefox/61.0
+Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:63.0) Gecko/20100101 Firefox/63.0
+Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:67.0) Gecko/20100101 Firefox/67.0
+Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:68.0) Gecko/20100101 Firefox/68.0
+Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0
+Mozilla/5.0 (Windows NT 10.0; rv:69.0) Gecko/20100101 Firefox/69.0
+Mozilla/5.0 (Windows NT 5.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.112 Safari/537.36
+Mozilla/5.0 (Windows NT 6.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.112 Safari/537.36
+Mozilla/5.0 (Windows NT 6.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/49.0.2623.112 Safari/537.36
+Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) coc_coc_browser/80.0.180 Chrome/74.0.3729.180 Safari/537.36
+Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) coc_coc_browser/82.0.144 Chrome/76.0.3809.144 Safari/537.36
+Mozilla/5.0 (Windows NT 6.1; WOW64; Trident/7.0; rv:11.0) like Gecko
+Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.99 Safari/537.36
+Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.77 Safari/537.36
+Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36
+Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.131 Safari/537.36
+Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36
+Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36
+Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:56.0) Gecko/20100101 Firefox/56.0 Waterfox/56.2.14
+Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:60.0) Gecko/20100101 Firefox/60.0
+Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:63.0) Gecko/20100101 Firefox/63.0
+Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:68.0) Gecko/20100101 Firefox/68.0
+Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0
+Mozilla/5.0 (Windows NT 6.1; rv:69.0) Gecko/20100101 Firefox/69.0
+Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Windows NT 6.2; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0
+Mozilla/5.0 (Windows NT 6.3) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Windows NT 6.3; ARM; Trident/7.0; Touch; rv:11.0) like Gecko
+Mozilla/5.0 (Windows NT 6.3; Trident/7.0; Touch; rv:11.0) like Gecko
+Mozilla/5.0 (Windows NT 6.3; WOW64; Trident/7.0; rv:11.0) like Gecko
+Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.132 Safari/537.36
+Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.186 Safari/537.36
+Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36
+Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
+Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36
+Mozilla/5.0 (Windows NT 6.3; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0
+Mozilla/5.0 (Windows NT 6.3; rv:69.0) Gecko/20100101 Firefox/69.0
+Mozilla/5.0 (Windows; U; Windows NT 10.0; en-US; Valve Steam GameOverlay/1568860339; ) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.121 Safari/537.36
+Mozilla/5.0 (X11; CrOS aarch64 12371.75.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.105 Safari/537.36
+Mozilla/5.0 (X11; CrOS armv7l 12239.92.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.136 Safari/537.36
+Mozilla/5.0 (X11; CrOS x86_64 10895.78.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.120 Safari/537.36
+Mozilla/5.0 (X11; CrOS x86_64 11021.81.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36
+Mozilla/5.0 (X11; CrOS x86_64 11895.118.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.159 Safari/537.36
+Mozilla/5.0 (X11; CrOS x86_64 12239.92.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.136 Safari/537.36
+Mozilla/5.0 (X11; CrOS x86_64 12239.92.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.136 Safari/537.36
+Mozilla/5.0 (X11; CrOS x86_64 12239.92.4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.136 Safari/537.36
+Mozilla/5.0 (X11; CrOS x86_64 12371.46.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.63 Safari/537.36
+Mozilla/5.0 (X11; CrOS x86_64 12371.65.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.93 Safari/537.36
+Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.100 Safari/537.36
+Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.75 Safari/537.36
+Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/10.1 Chrome/71.0.3578.99 Safari/537.36
+Mozilla/5.0 (X11; U; U; Linux x86_64; in-id) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.139 Safari/537.36
+Mozilla/5.0 (X11; U; U; Linux x86_64; pt-pt) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.139 Safari/537.36
+Mozilla/5.0 (X11; U; U; Linux x86_64; th-th) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.139 Safari/537.36
+Mozilla/5.0 (X11; U; U; Linux x86_64; vi-vn) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.139 Safari/537.36
+Mozilla/5.0 (X11; U; U; Linux x86_64; zh-cn) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.139 Safari/537.36
+Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:65.0) Gecko/20100101 Firefox/65.0
+Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:66.0) Gecko/20100101 Firefox/66.0
+Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:67.0) Gecko/20100101 Firefox/67.0
+Mozilla/5.0 (iPad; CPU OS 10_3_3 like Mac OS X) AppleWebKit/600.1.4 (KHTML, like Gecko) GSA/22.0.141836113 Mobile/14G60 Safari/600.1.4
+Mozilla/5.0 (iPad; CPU OS 10_3_3 like Mac OS X) AppleWebKit/603.1.30 (KHTML, like Gecko) CriOS/71.0.3578.89 Mobile/14G60 Safari/602.1
+Mozilla/5.0 (iPad; CPU OS 10_3_3 like Mac OS X) AppleWebKit/603.3.8 (KHTML, like Gecko) FxiOS/14.0b12646 Mobile/14G60 Safari/603.3.8
+Mozilla/5.0 (iPad; CPU OS 10_3_3 like Mac OS X) AppleWebKit/603.3.8 (KHTML, like Gecko) Mobile/14G60
+Mozilla/5.0 (iPad; CPU OS 10_3_3 like Mac OS X) AppleWebKit/603.3.8 (KHTML, like Gecko) Mobile/14G60 [FBAN/FBIOS;FBAV/240.0.0.55.117;FBBV/174195427;FBDV/iPad5,3;FBMD/iPad;FBSN/iOS;FBSV/10.3.3;FBSS/2;FBID/tablet;FBLC/zh_TW;FBOP/5;FBRV/175353135;FBCR/]
+Mozilla/5.0 (iPad; CPU OS 10_3_3 like Mac OS X) AppleWebKit/603.3.8 (KHTML, like Gecko) Version/10.0 Mobile/14G60 Safari/602.1
+Mozilla/5.0 (iPad; CPU OS 10_3_4 like Mac OS X) AppleWebKit/603.3.8 (KHTML, like Gecko) Version/10.0 Mobile/14G61 Safari/602.1
+Mozilla/5.0 (iPad; CPU OS 11_1 like Mac OS X) AppleWebKit/604.1.34 (KHTML, like Gecko) CriOS/76.0.3809.123 Mobile/15B101 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 11_1_2 like Mac OS X) AppleWebKit/604.1.34 (KHTML, like Gecko) CriOS/76.0.3809.123 Mobile/15B202 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 11_2_1 like Mac OS X) AppleWebKit/604.4.7 (KHTML, like Gecko) Version/11.0 Mobile/15C153 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 11_2_2 like Mac OS X) AppleWebKit/604.4.7 (KHTML, like Gecko) Version/11.0 Mobile/15C202 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 11_2_6 like Mac OS X) AppleWebKit/604.5.6 (KHTML, like Gecko) Version/11.0 Mobile/15D100 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 11_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.0 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 11_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.0 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 11_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15G77
+Mozilla/5.0 (iPad; CPU OS 11_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.0 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 12_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) GSA/83.0.268992909 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPad; CPU OS 12_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 12_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/75.0.3770.103 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPad; CPU OS 12_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/76.0.3809.123 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPad; CPU OS 12_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/16B92
+Mozilla/5.0 (iPad; CPU OS 12_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 12_1_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 12_1_4 like Mac OS X) AppleWebKit/604.1.34 (KHTML, like Gecko) GSA/48.0.193557427 Mobile/16D57 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 12_1_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/16D57
+Mozilla/5.0 (iPad; CPU OS 12_1_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/76.0.3809.123 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPad; CPU OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148
+Mozilla/5.0 (iPad; CPU OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 12_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/77.0.3865.93 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPad; CPU OS 12_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) GSA/83.0.268992909 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPad; CPU OS 12_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.1 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 12_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148
+Mozilla/5.0 (iPad; CPU OS 12_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.1 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/76.0.3809.123 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPad; CPU OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/76.0.3809.81 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPad; CPU OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/77.0.3865.103 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPad; CPU OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/77.0.3865.69 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPad; CPU OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/77.0.3865.93 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPad; CPU OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) GSA/74.0.248026584 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPad; CPU OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) GSA/83.0.268992909 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPad; CPU OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148
+Mozilla/5.0 (iPad; CPU OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.2 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 12_4_1 like Mac OS X) AppleWebKit/604.1.34 (KHTML, like Gecko) CriOS/67.0.3396.87 Mobile/16G102 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) FxiOS/19.0b16042 Mobile/15E148 Safari/605.1.15
+Mozilla/5.0 (iPad; CPU OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148
+Mozilla/5.0 (iPad; CPU OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPad4,7;FBMD/iPad;FBSN/iOS;FBSV/12.4.1;FBSS/2;FBID/tablet;FBLC/vi_VN;FBOP/5;FBCR/]
+Mozilla/5.0 (iPad; CPU OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPad5,1;FBMD/iPad;FBSN/iOS;FBSV/12.4.1;FBSS/2;FBCR/;FBID/tablet;FBLC/en_US;FBOP/5]
+Mozilla/5.0 (iPad; CPU OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPad6,11;FBMD/iPad;FBSN/iOS;FBSV/12.4.1;FBSS/2;FBID/tablet;FBLC/en_US;FBOP/5;FBCR/]
+Mozilla/5.0 (iPad; CPU OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPad7,5;FBMD/iPad;FBSN/iOS;FBSV/12.4.1;FBSS/2;FBID/tablet;FBLC/en_US;FBOP/5;FBCR/]
+Mozilla/5.0 (iPad; CPU OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.2 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPad; CPU OS 6_1_3 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/6.0 Mobile/10B329 Safari/8536.25
+Mozilla/5.0 (iPad; CPU OS 8_0 like Mac OS X) AppleWebKit/600.1.4 (KHTML, like Gecko) Version/8.0 Mobile/12A365 Safari/600.1.4
+Mozilla/5.0 (iPad; CPU OS 8_2 like Mac OS X) AppleWebKit/600.1.4 (KHTML, like Gecko) Version/8.0 Mobile/12D508 Safari/600.1.4
+Mozilla/5.0 (iPad; CPU OS 8_4 like Mac OS X) AppleWebKit/600.1.4 (KHTML, like Gecko) GSA/23.1.148956103 Mobile/12H143 Safari/600.1.4
+Mozilla/5.0 (iPad; CPU OS 9_3_2 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Version/9.0 Mobile/13F69 Safari/601.1
+Mozilla/5.0 (iPad; CPU OS 9_3_5 like Mac OS X) AppleWebKit/601.1.46 (KHTML, like Gecko) Version/9.0 Mobile/13G36 Safari/601.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 10_2 like Mac OS X) AppleWebKit/602.3.12 (KHTML, like Gecko) Version/10.0 Mobile/14C92 Safari/602.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 10_3_3 like Mac OS X) AppleWebKit/603.3.8 (KHTML, like Gecko) Mobile/14G60 [FBAN/FBIOS;FBDV/iPhone7,1;FBMD/iPhone;FBSN/iOS;FBSV/10.3.3;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/Verizon]
+Mozilla/5.0 (iPhone; CPU iPhone OS 10_3_4 like Mac OS X) AppleWebKit/603.1.30 (KHTML, like Gecko) GSA/68.0.234683655 Mobile/14G61 Safari/602.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 10_3_4 like Mac OS X) AppleWebKit/603.3.8 (KHTML, like Gecko) Version/10.0 Mobile/14G61 Safari/602.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 11_0_3 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A432 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 11_1_1 like Mac OS X) AppleWebKit/604.3.5 (KHTML, like Gecko) Version/11.0 Mobile/15B150 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 11_1_2 like Mac OS X) AppleWebKit/604.3.5 (KHTML, like Gecko) Version/11.0 Mobile/15B202 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 11_2_1 like Mac OS X) AppleWebKit/604.4.7 (KHTML, like Gecko) Version/11.0 Mobile/15C153 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 11_2_6 like Mac OS X) AppleWebKit/604.5.6 (KHTML, like Gecko) Mobile/15D100 [FBAN/FBIOS;FBAV/207.0.0.48.100;FBBV/141048683;FBDV/iPhone9,3;FBMD/iPhone;FBSN/iOS;FBSV/11.2.6;FBSS/2;FBCR/SFR;FBID/phone;FBLC/fr_FR;FBOP/5;FBRV/142061404]
+Mozilla/5.0 (iPhone; CPU iPhone OS 11_3 like Mac OS X) AppleWebKit/604.1.34 (KHTML, like Gecko) CriOS/76.0.3809.123 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 11_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E302 [FBAN/FBIOS;FBDV/iPhone7,2;FBMD/iPhone;FBSN/iOS;FBSV/11.3.1;FBSS/2;FBID/phone;FBLC/fr_FR;FBOP/5;FBCR/VINI]
+Mozilla/5.0 (iPhone; CPU iPhone OS 11_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.0 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 11_4 like Mac OS X) AppleWebKit/604.1.34 (KHTML, like Gecko) GSA/83.0.268992909 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 11_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.0 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 11_4_1 like Mac OS X) AppleWebKit/604.1.34 (KHTML, like Gecko) GSA/74.1.250942683 Mobile/15G77 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 11_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.0 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_1_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_1_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) GSA/74.1.250942683 Mobile/16C101 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_1_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/16C101 [FBAN/FBIOS;FBDV/iPhone9,3;FBMD/iPhone;FBSN/iOS;FBSV/12.1.2;FBSS/2;FBCR/Free;FBID/phone;FBLC/fr_FR;FBOP/5]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_1_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_1_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_1_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) GSA/74.1.250942683 Mobile/16D57 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_1_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/72.0.3626.101 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/76.0.3809.123 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/77.0.3865.69 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,2;FBMD/iPhone;FBSN/iOS;FBSV/12.2;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/T-Mobile]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,5;FBMD/iPhone;FBSN/iOS;FBSV/12.2;FBSS/3;FBCR/AT&T;FBID/phone;FBLC/en_US;FBOP/5]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/77.0.3865.69 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) GSA/83.0.268992909 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.1 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) GSA/79.0.259819395 Mobile/16F203 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 DuckDuckGo/7
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,6;FBMD/iPhone;FBSN/iOS;FBSV/12.3.1;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/AT&T]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone11,6;FBMD/iPhone;FBSN/iOS;FBSV/12.3.1;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/AT&T]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone9,3;FBMD/iPhone;FBSN/iOS;FBSV/12.3.1;FBSS/2;FBID/phone;FBLC/es_LA;FBOP/5;FBCR/AT&T]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_3_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.1 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_3_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.1 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/69.0.3497.105 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/73.0.3683.68 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/75.0.3770.103 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/76.0.3809.123 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/77.0.3865.103 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/77.0.3865.69 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) GSA/81.0.264749124 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) GSA/82.1.267240167 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) GSA/83.0.268992909 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,1;FBMD/iPhone;FBSN/iOS;FBSV/12.4;FBSS/2;FBID/phone;FBLC/en_US;FBOP/5;FBCR/Verizon]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,5;FBMD/iPhone;FBSN/iOS;FBSV/12.4;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/T-Mobile]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone11,6;FBMD/iPhone;FBSN/iOS;FBSV/12.4;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/Sprint]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone9,4;FBMD/iPhone;FBSN/iOS;FBSV/12.4;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/T-Mobile]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.2 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) GSA/74.1.250942683 Mobile/16G102 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 Instagram 89.0.0.14.100 (iPhone11,6; iOS 12_4_1; en_US; en-US; scale=3.00; gamut=normal; 1242x2688; 149781277)
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBAV/240.0.0.55.117;FBBV/174195427;FBDV/iPhone7,2;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/2;FBID/phone;FBLC/es_LA;FBOP/5;FBRV/175040728;FBCR/AT&T]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,2;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/Sprint]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,3;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/T-Mobile]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,3;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/Verizon]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,4;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/2;FBID/phone;FBLC/es_LA;FBOP/5;FBCR/T-Mobile]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,4;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/2;FBID/phone;FBLC/fr_FR;FBOP/5;FBCR/AT&T]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,5;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/3;FBCR/T-Mobile;FBID/phone;FBLC/es_LA;FBOP/5]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,5;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/T-Mobile]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,5;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/3;FBID/phone;FBLC/es_LA;FBOP/5;FBCR/T-Mobile]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,6;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/AT&T]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone11,2;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/Verizon]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone11,6;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/AT&T]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone11,6;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/Verizon]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone11,6;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/3;FBID/phone;FBLC/fr_FR;FBOP/5;FBCR/SFR]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone11,8;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/2;FBID/phone;FBLC/en_US;FBOP/5;FBCR/AT&T]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone11,8;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/2;FBID/phone;FBLC/en_US;FBOP/5;FBCR/Verizon]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone11,8;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/2;FBID/phone;FBLC/fr_FR;FBOP/5;FBCR/Carrier]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone7,2;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/2;FBID/phone;FBLC/en_US;FBOP/5;FBCR/T-Mobile]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone8,1;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/2;FBID/phone;FBLC/en_US;FBOP/5;FBCR/MetroPCS]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone9,2;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/cricket]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone9,4;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/AT&T]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone9,4;FBMD/iPhone;FBSN/iOS;FBSV/12.4.1;FBSS/3;FBID/phone;FBLC/fr_FR;FBOP/5;FBCR/T-Mobile]
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.2 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.4.1 Mobile/15E148 Safari/605.1.15
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148
+Mozilla/5.0 (iPhone; CPU iPhone OS 12_4_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.2 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/77.0.3865.69 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,5;FBMD/iPhone;FBSN/iOS;FBSV/13.0;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/AT&T]
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,6;FBMD/iPhone;FBSN/iOS;FBSV/13.0;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/T-Mobile]
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone11,2;FBMD/iPhone;FBSN/iOS;FBSV/13.0;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/Verizon]
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone11,8;FBMD/iPhone;FBSN/iOS;FBSV/13.0;FBSS/2;FBID/phone;FBLC/en_US;FBOP/5;FBCR/T-Mobile]
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone11,8;FBMD/iPhone;FBSN/iOS;FBSV/13.0;FBSS/2;FBID/phone;FBLC/en_US;FBOP/5;FBCR/Verizon]
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone9,4;FBMD/iPhone;FBSN/iOS;FBSV/13.0;FBSS/3;FBID/phone;FBLC/fr_FR;FBOP/5;FBCR/Orange France]
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/76.0.3809.123 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/77.0.3865.69 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/77.0.3865.93 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) FxiOS/8.1.3 Mobile/15E148 Safari/605.1.15
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) GSA/83.0.268992909 Mobile/15E148 Safari/605.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 DuckDuckGo/7
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,1;FBMD/iPhone;FBSN/iOS;FBSV/13.1;FBSS/2;FBID/phone;FBLC/en_US;FBOP/5;FBCR/AT&T]
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,6;FBMD/iPhone;FBSN/iOS;FBSV/13.1;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/AT&T]
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,6;FBMD/iPhone;FBSN/iOS;FBSV/13.1;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/T-Mobile]
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone11,8;FBMD/iPhone;FBSN/iOS;FBSV/13.1;FBSS/2;FBID/phone;FBLC/en_US;FBOP/5;FBCR/AT&T]
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone9,4;FBMD/iPhone;FBSN/iOS;FBSV/13.1;FBSS/3;FBID/phone;FBLC/es_LA;FBOP/5;FBCR/Telcel]
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.1 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,1;FBMD/iPhone;FBSN/iOS;FBSV/13.1.1;FBSS/2;FBID/phone;FBLC/en_US;FBOP/5;FBCR/Union]
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone10,3;FBMD/iPhone;FBSN/iOS;FBSV/13.1.1;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/Verizon]
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone11,6;FBMD/iPhone;FBSN/iOS;FBSV/13.1.1;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/T-Mobile]
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone11,6;FBMD/iPhone;FBSN/iOS;FBSV/13.1.1;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/Verizon]
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.1 Mobile/15E148 Safari/604.1
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 [FBAN/FBIOS;FBDV/iPhone11,2;FBMD/iPhone;FBSN/iOS;FBSV/13.1.2;FBSS/3;FBID/phone;FBLC/en_US;FBOP/5;FBCR/AT&T]
+Mozilla/5.0 (iPhone; CPU iPhone OS 13_1_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.1 Mobile/15E148 Safari/604.1

From 7df30b1d828f568b715b196a1520a86f5b5a0e0b Mon Sep 17 00:00:00 2001
From: Han Fei <hanfei19910905@gmail.com>
Date: Wed, 25 Jan 2023 23:57:20 +0100
Subject: [PATCH 20/79] remove trivial logs

---
 src/Dictionaries/RegExpTreeDictionary.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/Dictionaries/RegExpTreeDictionary.cpp b/src/Dictionaries/RegExpTreeDictionary.cpp
index 21c61173e92..e6321e26a7b 100644
--- a/src/Dictionaries/RegExpTreeDictionary.cpp
+++ b/src/Dictionaries/RegExpTreeDictionary.cpp
@@ -252,7 +252,6 @@ void RegExpTreeDictionary::initRegexNodes(Block & block)
         if (checker.check(regex))
         {
             complex_regexp_nodes.push_back(node);
-            LOG_INFO(logger, "Found complex regexp {} in the config. This will slow down the queries", regex);
         }
         else
         {

From 2f172a3f8befe4ce649fbd9b3e2b1fde6cd7b93d Mon Sep 17 00:00:00 2001
From: Han Fei <hanfei19910905@gmail.com>
Date: Thu, 26 Jan 2023 09:07:34 +0100
Subject: [PATCH 21/79] fix check style

---
 tests/metadata/INFORMATION_SCHEMA.sql                          | 2 --
 tests/metadata/information_schema.sql                          | 2 --
 tests/metadata/system                                          | 1 -
 tests/metadata/system.sql                                      | 2 --
 tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.sh | 2 +-
 5 files changed, 1 insertion(+), 8 deletions(-)
 delete mode 100644 tests/metadata/INFORMATION_SCHEMA.sql
 delete mode 100644 tests/metadata/information_schema.sql
 delete mode 120000 tests/metadata/system
 delete mode 100644 tests/metadata/system.sql

diff --git a/tests/metadata/INFORMATION_SCHEMA.sql b/tests/metadata/INFORMATION_SCHEMA.sql
deleted file mode 100644
index 291582fd1eb..00000000000
--- a/tests/metadata/INFORMATION_SCHEMA.sql
+++ /dev/null
@@ -1,2 +0,0 @@
-ATTACH DATABASE INFORMATION_SCHEMA
-ENGINE = Memory
diff --git a/tests/metadata/information_schema.sql b/tests/metadata/information_schema.sql
deleted file mode 100644
index 6cea934b49d..00000000000
--- a/tests/metadata/information_schema.sql
+++ /dev/null
@@ -1,2 +0,0 @@
-ATTACH DATABASE information_schema
-ENGINE = Memory
diff --git a/tests/metadata/system b/tests/metadata/system
deleted file mode 120000
index 9a11b7e3458..00000000000
--- a/tests/metadata/system
+++ /dev/null
@@ -1 +0,0 @@
-/home/hanfei/ClickHouse/tests/store/069/0693727d-7be1-48e3-9ff3-aa0bba736b34/
\ No newline at end of file
diff --git a/tests/metadata/system.sql b/tests/metadata/system.sql
deleted file mode 100644
index 941c12b0a66..00000000000
--- a/tests/metadata/system.sql
+++ /dev/null
@@ -1,2 +0,0 @@
-ATTACH DATABASE _ UUID '0693727d-7be1-48e3-9ff3-aa0bba736b34'
-ENGINE = Atomic
diff --git a/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.sh b/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.sh
index f783a0db60f..4d372bf1ce6 100755
--- a/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.sh
+++ b/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.sh
@@ -84,4 +84,4 @@ drop dictionary if exists regexp_device;
 drop table if exists user_agents;
 "
 
-rm -rf "$USER_FILES_PATH/test_02504"
+rm -rf "$user_files_path/test_02504"

From fb3f7409fae9824f2081b08887ba0fc486b532c8 Mon Sep 17 00:00:00 2001
From: Anton Popov <anton@clickhouse.com>
Date: Thu, 26 Jan 2023 22:17:22 +0000
Subject: [PATCH 22/79] allow vertical merges from compact to wide parts

---
 src/Storages/MergeTree/IMergeTreeDataPart.h   |  2 -
 src/Storages/MergeTree/MergeTask.cpp          |  6 +--
 .../MergeTree/MergeTreeDataPartWide.h         |  2 -
 ...539_vertical_merge_compact_parts.reference |  2 +
 .../02539_vertical_merge_compact_parts.sql    | 41 +++++++++++++++++++
 5 files changed, 45 insertions(+), 8 deletions(-)
 create mode 100644 tests/queries/0_stateless/02539_vertical_merge_compact_parts.reference
 create mode 100644 tests/queries/0_stateless/02539_vertical_merge_compact_parts.sql

diff --git a/src/Storages/MergeTree/IMergeTreeDataPart.h b/src/Storages/MergeTree/IMergeTreeDataPart.h
index 68d5147362b..7a44770a05d 100644
--- a/src/Storages/MergeTree/IMergeTreeDataPart.h
+++ b/src/Storages/MergeTree/IMergeTreeDataPart.h
@@ -116,8 +116,6 @@ public:
 
     virtual bool isStoredOnRemoteDiskWithZeroCopySupport() const = 0;
 
-    virtual bool supportsVerticalMerge() const { return false; }
-
     /// NOTE: Returns zeros if column files are not found in checksums.
     /// Otherwise return information about column size on disk.
     ColumnSize getColumnSize(const String & column_name) const;
diff --git a/src/Storages/MergeTree/MergeTask.cpp b/src/Storages/MergeTree/MergeTask.cpp
index 35e1b82dae0..d5bba5d4ab5 100644
--- a/src/Storages/MergeTree/MergeTask.cpp
+++ b/src/Storages/MergeTree/MergeTask.cpp
@@ -955,10 +955,8 @@ MergeAlgorithm MergeTask::ExecuteAndFinalizeHorizontalPart::chooseMergeAlgorithm
         return MergeAlgorithm::Horizontal;
     if (ctx->need_remove_expired_values)
         return MergeAlgorithm::Horizontal;
-
-    for (const auto & part : global_ctx->future_part->parts)
-        if (!part->supportsVerticalMerge())
-            return MergeAlgorithm::Horizontal;
+    if (global_ctx->future_part->type != MergeTreeDataPartType::Wide)
+        return MergeAlgorithm::Horizontal;
 
     bool is_supported_storage =
         ctx->merging_params.mode == MergeTreeData::MergingParams::Ordinary ||
diff --git a/src/Storages/MergeTree/MergeTreeDataPartWide.h b/src/Storages/MergeTree/MergeTreeDataPartWide.h
index 601bdff51a1..3596d6172fc 100644
--- a/src/Storages/MergeTree/MergeTreeDataPartWide.h
+++ b/src/Storages/MergeTree/MergeTreeDataPartWide.h
@@ -53,8 +53,6 @@ public:
 
     bool isStoredOnRemoteDiskWithZeroCopySupport() const override;
 
-    bool supportsVerticalMerge() const override { return true; }
-
     String getFileNameForColumn(const NameAndTypePair & column) const override;
 
     ~MergeTreeDataPartWide() override;
diff --git a/tests/queries/0_stateless/02539_vertical_merge_compact_parts.reference b/tests/queries/0_stateless/02539_vertical_merge_compact_parts.reference
new file mode 100644
index 00000000000..cb19dda2d60
--- /dev/null
+++ b/tests/queries/0_stateless/02539_vertical_merge_compact_parts.reference
@@ -0,0 +1,2 @@
+1	2	all_1_2_1	MergeParts	Horizontal	Compact
+1	3	all_1_3_2	MergeParts	Vertical	Wide
diff --git a/tests/queries/0_stateless/02539_vertical_merge_compact_parts.sql b/tests/queries/0_stateless/02539_vertical_merge_compact_parts.sql
new file mode 100644
index 00000000000..45c7151b29b
--- /dev/null
+++ b/tests/queries/0_stateless/02539_vertical_merge_compact_parts.sql
@@ -0,0 +1,41 @@
+DROP TABLE IF EXISTS t_compact_vertical_merge;
+
+CREATE TABLE t_compact_vertical_merge (id UInt64, s LowCardinality(String), arr Array(UInt64))
+ENGINE MergeTree ORDER BY id
+SETTINGS
+    index_granularity = 16,
+    min_bytes_for_wide_part = 0,
+    min_rows_for_wide_part = 100,
+    vertical_merge_algorithm_min_rows_to_activate = 1,
+    vertical_merge_algorithm_min_columns_to_activate = 1;
+
+INSERT INTO t_compact_vertical_merge SELECT number, toString(number), range(number % 10) FROM numbers(40);
+INSERT INTO t_compact_vertical_merge SELECT number, toString(number), range(number % 10) FROM numbers(40);
+
+OPTIMIZE TABLE t_compact_vertical_merge FINAL;
+SYSTEM FLUSH LOGS;
+
+WITH splitByChar('_', part_name) AS name_parts,
+    name_parts[2]::UInt64 AS min_block,
+    name_parts[3]::UInt64 AS max_block
+SELECT min_block, max_block, part_name, event_type, merge_algorithm, part_type FROM system.part_log
+WHERE
+    database = currentDatabase() AND
+    table = 't_compact_vertical_merge' AND
+    min_block = 1 AND max_block = 2;
+
+INSERT INTO t_compact_vertical_merge SELECT number, toString(number), range(number % 10) FROM numbers(40);
+
+OPTIMIZE TABLE t_compact_vertical_merge FINAL;
+SYSTEM FLUSH LOGS;
+
+WITH splitByChar('_', part_name) AS name_parts,
+    name_parts[2]::UInt64 AS min_block,
+    name_parts[3]::UInt64 AS max_block
+SELECT min_block, max_block, part_name, event_type, merge_algorithm, part_type FROM system.part_log
+WHERE
+    database = currentDatabase() AND
+    table = 't_compact_vertical_merge' AND
+    min_block = 1 AND max_block = 3;
+
+DROP TABLE t_compact_vertical_merge;

From 9c1717b42d7897cd7f1c020cc3a967160307a6e7 Mon Sep 17 00:00:00 2001
From: Anton Popov <anton@clickhouse.com>
Date: Fri, 27 Jan 2023 13:35:04 +0000
Subject: [PATCH 23/79] fix computation of granularity in vertical merges

---
 .../MergeTree/MergeTreeDataPartWriterOnDisk.cpp     | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/src/Storages/MergeTree/MergeTreeDataPartWriterOnDisk.cpp b/src/Storages/MergeTree/MergeTreeDataPartWriterOnDisk.cpp
index 1f40177d0fa..61cb9a4e7bd 100644
--- a/src/Storages/MergeTree/MergeTreeDataPartWriterOnDisk.cpp
+++ b/src/Storages/MergeTree/MergeTreeDataPartWriterOnDisk.cpp
@@ -135,6 +135,7 @@ static size_t computeIndexGranularityImpl(
 {
     size_t rows_in_block = block.rows();
     size_t index_granularity_for_block;
+
     if (!can_use_adaptive_index_granularity)
     {
         index_granularity_for_block = fixed_index_granularity_rows;
@@ -143,7 +144,9 @@ static size_t computeIndexGranularityImpl(
     {
         size_t block_size_in_memory = block.bytes();
         if (blocks_are_granules)
+        {
             index_granularity_for_block = rows_in_block;
+        }
         else if (block_size_in_memory >= index_granularity_bytes)
         {
             size_t granules_in_block = block_size_in_memory / index_granularity_bytes;
@@ -155,10 +158,14 @@ static size_t computeIndexGranularityImpl(
             index_granularity_for_block = index_granularity_bytes / size_of_row_in_bytes;
         }
     }
-    /// We should be less or equal than fixed index granularity
-    index_granularity_for_block = std::min(fixed_index_granularity_rows, index_granularity_for_block);
 
-    /// very rare case when index granularity bytes less then single row
+    /// We should be less or equal than fixed index granularity.
+    /// But if block size is a granule size then do no ajust it.
+    /// Granularity greater than fixed granularity might come from compact part.
+    if (!blocks_are_granules)
+        index_granularity_for_block = std::min(fixed_index_granularity_rows, index_granularity_for_block);
+
+    /// Very rare case when index granularity bytes less than single row.
     if (index_granularity_for_block == 0)
         index_granularity_for_block = 1;
 

From e2324c9f153a1685629affc6470d389c5a049d45 Mon Sep 17 00:00:00 2001
From: Anton Popov <anton@clickhouse.com>
Date: Fri, 27 Jan 2023 14:54:10 +0000
Subject: [PATCH 24/79] better test

---
 .../0_stateless/02539_vertical_merge_compact_parts.reference  | 4 ++--
 .../0_stateless/02539_vertical_merge_compact_parts.sql        | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/queries/0_stateless/02539_vertical_merge_compact_parts.reference b/tests/queries/0_stateless/02539_vertical_merge_compact_parts.reference
index cb19dda2d60..685d3f3140d 100644
--- a/tests/queries/0_stateless/02539_vertical_merge_compact_parts.reference
+++ b/tests/queries/0_stateless/02539_vertical_merge_compact_parts.reference
@@ -1,2 +1,2 @@
-1	2	all_1_2_1	MergeParts	Horizontal	Compact
-1	3	all_1_3_2	MergeParts	Vertical	Wide
+1	2	MergeParts	Horizontal	Compact
+1	3	MergeParts	Vertical	Wide
diff --git a/tests/queries/0_stateless/02539_vertical_merge_compact_parts.sql b/tests/queries/0_stateless/02539_vertical_merge_compact_parts.sql
index 45c7151b29b..4140a73b8bc 100644
--- a/tests/queries/0_stateless/02539_vertical_merge_compact_parts.sql
+++ b/tests/queries/0_stateless/02539_vertical_merge_compact_parts.sql
@@ -18,7 +18,7 @@ SYSTEM FLUSH LOGS;
 WITH splitByChar('_', part_name) AS name_parts,
     name_parts[2]::UInt64 AS min_block,
     name_parts[3]::UInt64 AS max_block
-SELECT min_block, max_block, part_name, event_type, merge_algorithm, part_type FROM system.part_log
+SELECT min_block, max_block, event_type, merge_algorithm, part_type FROM system.part_log
 WHERE
     database = currentDatabase() AND
     table = 't_compact_vertical_merge' AND
@@ -32,7 +32,7 @@ SYSTEM FLUSH LOGS;
 WITH splitByChar('_', part_name) AS name_parts,
     name_parts[2]::UInt64 AS min_block,
     name_parts[3]::UInt64 AS max_block
-SELECT min_block, max_block, part_name, event_type, merge_algorithm, part_type FROM system.part_log
+SELECT min_block, max_block, event_type, merge_algorithm, part_type FROM system.part_log
 WHERE
     database = currentDatabase() AND
     table = 't_compact_vertical_merge' AND

From eeef2dae7748107f1b62c83e654ff2ea84056ddc Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Sun, 29 Jan 2023 19:48:46 +0800
Subject: [PATCH 25/79] fix cores

---
 src/Analyzer/IQueryTreeNode.h                 |  3 +
 src/Analyzer/Passes/SumIfToCountIfPass.cpp    | 45 +++++++++--
 .../01646_rewrite_sum_if.reference            | 81 +++++++++++++++++++
 .../0_stateless/01646_rewrite_sum_if.sql      |  6 ++
 4 files changed, 128 insertions(+), 7 deletions(-)

diff --git a/src/Analyzer/IQueryTreeNode.h b/src/Analyzer/IQueryTreeNode.h
index 8aa834e60b7..719f92d773e 100644
--- a/src/Analyzer/IQueryTreeNode.h
+++ b/src/Analyzer/IQueryTreeNode.h
@@ -72,6 +72,9 @@ class IQueryTreeNode : public TypePromotion<IQueryTreeNode>
 public:
     virtual ~IQueryTreeNode() = default;
 
+    IQueryTreeNode & operator=(const IQueryTreeNode &) = default;
+    IQueryTreeNode & operator=(IQueryTreeNode &&) = default;
+
     /// Get query tree node type
     virtual QueryTreeNodeType getNodeType() const = 0;
 
diff --git a/src/Analyzer/Passes/SumIfToCountIfPass.cpp b/src/Analyzer/Passes/SumIfToCountIfPass.cpp
index 4462131ed7a..d55af278152 100644
--- a/src/Analyzer/Passes/SumIfToCountIfPass.cpp
+++ b/src/Analyzer/Passes/SumIfToCountIfPass.cpp
@@ -58,13 +58,20 @@ public:
             if (!isInt64OrUInt64FieldType(constant_value_literal.getType()))
                 return;
 
-            if (constant_value_literal.get<UInt64>() != 1 || getSettings().aggregate_functions_null_for_empty)
+            if (getSettings().aggregate_functions_null_for_empty)
                 return;
 
+            /// Rewrite `sumIf(1, cond)` into `countIf(cond)`
+            auto multiplier_node = function_node_arguments_nodes[0];
             function_node_arguments_nodes[0] = std::move(function_node_arguments_nodes[1]);
             function_node_arguments_nodes.resize(1);
-
             resolveAsCountIfAggregateFunction(*function_node, function_node_arguments_nodes[0]->getResultType());
+
+            if (constant_value_literal.get<UInt64>() != 1)
+            {
+                /// Rewrite `sumIf(123, cond)` into `123 * countIf(cond)`
+                node = getMultiplyFunction(std::move(multiplier_node), node);
+            }
             return;
         }
 
@@ -79,7 +86,7 @@ public:
         if (!nested_function || nested_function->getFunctionName() != "if")
             return;
 
-        const auto & nested_if_function_arguments_nodes = nested_function->getArguments().getNodes();
+        const auto nested_if_function_arguments_nodes = nested_function->getArguments().getNodes();
         if (nested_if_function_arguments_nodes.size() != 3)
             return;
 
@@ -100,19 +107,25 @@ public:
         auto if_true_condition_value = if_true_condition_constant_value_literal.get<UInt64>();
         auto if_false_condition_value = if_false_condition_constant_value_literal.get<UInt64>();
 
-        /// Rewrite `sum(if(cond, 1, 0))` into `countIf(cond)`.
-        if (if_true_condition_value == 1 && if_false_condition_value == 0)
+        if (if_false_condition_value == 0)
         {
+            /// Rewrite `sum(if(cond, 1, 0))` into `countIf(cond)`.
             function_node_arguments_nodes[0] = nested_if_function_arguments_nodes[0];
             function_node_arguments_nodes.resize(1);
 
             resolveAsCountIfAggregateFunction(*function_node, function_node_arguments_nodes[0]->getResultType());
+
+            if (if_true_condition_value != 1)
+            {
+                /// Rewrite `sum(if(cond, 123, 0))` into `123 * countIf(cond)`.
+                node = getMultiplyFunction(nested_if_function_arguments_nodes[1], node);
+            }
             return;
         }
 
-        /// Rewrite `sum(if(cond, 0, 1))` into `countIf(not(cond))` if condition is not Nullable (otherwise the result can be different).
-        if (if_true_condition_value == 0 && if_false_condition_value == 1 && !cond_argument->getResultType()->isNullable())
+        if (if_true_condition_value == 0 && !cond_argument->getResultType()->isNullable())
         {
+            /// Rewrite `sum(if(cond, 0, 1))` into `countIf(not(cond))` if condition is not Nullable (otherwise the result can be different).
             DataTypePtr not_function_result_type = std::make_shared<DataTypeUInt8>();
 
             const auto & condition_result_type = nested_if_function_arguments_nodes[0]->getResultType();
@@ -130,6 +143,12 @@ public:
             function_node_arguments_nodes.resize(1);
 
             resolveAsCountIfAggregateFunction(*function_node, function_node_arguments_nodes[0]->getResultType());
+
+            if (if_false_condition_value != 1)
+            {
+                /// Rewrite `sum(if(cond, 0, 123))` into `123 * countIf(not(cond))` if condition is not Nullable (otherwise the result can be different).
+                node = getMultiplyFunction(nested_if_function_arguments_nodes[2], node);
+            }
             return;
         }
     }
@@ -145,6 +164,18 @@ private:
 
         function_node.resolveAsAggregateFunction(std::move(aggregate_function));
     }
+
+    inline QueryTreeNodePtr getMultiplyFunction(QueryTreeNodePtr left, QueryTreeNodePtr right)
+    {
+        auto multiply_function_node = std::make_shared<FunctionNode>("multiply");
+        auto & multiply_arguments_nodes = multiply_function_node->getArguments().getNodes();
+        multiply_arguments_nodes.push_back(std::move(left));
+        multiply_arguments_nodes.push_back(std::move(right));
+
+        auto multiply_function_base = FunctionFactory::instance().get("multiply", getContext())->build(multiply_function_node->getArgumentColumns());
+        multiply_function_node->resolveAsFunction(std::move(multiply_function_base));
+        return std::move(multiply_function_node);
+    }
 };
 
 }
diff --git a/tests/queries/0_stateless/01646_rewrite_sum_if.reference b/tests/queries/0_stateless/01646_rewrite_sum_if.reference
index 0e37c91578a..871c75737c6 100644
--- a/tests/queries/0_stateless/01646_rewrite_sum_if.reference
+++ b/tests/queries/0_stateless/01646_rewrite_sum_if.reference
@@ -34,3 +34,84 @@ SELECT 123 * countIf((number % 2) = 0)
 FROM numbers(100)
 SELECT 123 * countIf(NOT ((number % 2) = 0))
 FROM numbers(100)
+QUERY id: 0
+  PROJECTION COLUMNS
+    sumIf(123, equals(modulo(number, 2), 0)) UInt64
+  PROJECTION
+    LIST id: 1, nodes: 1
+      FUNCTION id: 2, function_name: multiply, function_type: ordinary, result_type: UInt64
+        ARGUMENTS
+          LIST id: 3, nodes: 2
+            CONSTANT id: 4, constant_value: UInt64_123, constant_value_type: UInt8
+            FUNCTION id: 5, function_name: countIf, function_type: aggregate, result_type: UInt64
+              ARGUMENTS
+                LIST id: 6, nodes: 1
+                  FUNCTION id: 7, function_name: equals, function_type: ordinary, result_type: UInt8
+                    ARGUMENTS
+                      LIST id: 8, nodes: 2
+                        FUNCTION id: 9, function_name: modulo, function_type: ordinary, result_type: UInt8
+                          ARGUMENTS
+                            LIST id: 10, nodes: 2
+                              COLUMN id: 11, column_name: number, result_type: UInt64, source_id: 12
+                              CONSTANT id: 13, constant_value: UInt64_2, constant_value_type: UInt8
+                        CONSTANT id: 14, constant_value: UInt64_0, constant_value_type: UInt8
+  JOIN TREE
+    TABLE_FUNCTION id: 12, table_function_name: numbers
+      ARGUMENTS
+        LIST id: 15, nodes: 1
+          CONSTANT id: 16, constant_value: UInt64_100, constant_value_type: UInt8
+QUERY id: 0
+  PROJECTION COLUMNS
+    sum(if(equals(modulo(number, 2), 0), 123, 0)) UInt64
+  PROJECTION
+    LIST id: 1, nodes: 1
+      FUNCTION id: 2, function_name: multiply, function_type: ordinary, result_type: UInt64
+        ARGUMENTS
+          LIST id: 3, nodes: 2
+            CONSTANT id: 4, constant_value: UInt64_123, constant_value_type: UInt8
+            FUNCTION id: 5, function_name: countIf, function_type: aggregate, result_type: UInt64
+              ARGUMENTS
+                LIST id: 6, nodes: 1
+                  FUNCTION id: 7, function_name: equals, function_type: ordinary, result_type: UInt8
+                    ARGUMENTS
+                      LIST id: 8, nodes: 2
+                        FUNCTION id: 9, function_name: modulo, function_type: ordinary, result_type: UInt8
+                          ARGUMENTS
+                            LIST id: 10, nodes: 2
+                              COLUMN id: 11, column_name: number, result_type: UInt64, source_id: 12
+                              CONSTANT id: 13, constant_value: UInt64_2, constant_value_type: UInt8
+                        CONSTANT id: 14, constant_value: UInt64_0, constant_value_type: UInt8
+  JOIN TREE
+    TABLE_FUNCTION id: 12, table_function_name: numbers
+      ARGUMENTS
+        LIST id: 15, nodes: 1
+          CONSTANT id: 16, constant_value: UInt64_100, constant_value_type: UInt8
+QUERY id: 0
+  PROJECTION COLUMNS
+    sum(if(equals(modulo(number, 2), 0), 0, 123)) UInt64
+  PROJECTION
+    LIST id: 1, nodes: 1
+      FUNCTION id: 2, function_name: multiply, function_type: ordinary, result_type: UInt64
+        ARGUMENTS
+          LIST id: 3, nodes: 2
+            CONSTANT id: 4, constant_value: UInt64_123, constant_value_type: UInt8
+            FUNCTION id: 5, function_name: countIf, function_type: aggregate, result_type: UInt64
+              ARGUMENTS
+                LIST id: 6, nodes: 1
+                  FUNCTION id: 7, function_name: not, function_type: ordinary, result_type: UInt8
+                    ARGUMENTS
+                      LIST id: 8, nodes: 1
+                        FUNCTION id: 9, function_name: equals, function_type: ordinary, result_type: UInt8
+                          ARGUMENTS
+                            LIST id: 10, nodes: 2
+                              FUNCTION id: 11, function_name: modulo, function_type: ordinary, result_type: UInt8
+                                ARGUMENTS
+                                  LIST id: 12, nodes: 2
+                                    COLUMN id: 13, column_name: number, result_type: UInt64, source_id: 14
+                                    CONSTANT id: 15, constant_value: UInt64_2, constant_value_type: UInt8
+                              CONSTANT id: 16, constant_value: UInt64_0, constant_value_type: UInt8
+  JOIN TREE
+    TABLE_FUNCTION id: 14, table_function_name: numbers
+      ARGUMENTS
+        LIST id: 17, nodes: 1
+          CONSTANT id: 18, constant_value: UInt64_100, constant_value_type: UInt8
diff --git a/tests/queries/0_stateless/01646_rewrite_sum_if.sql b/tests/queries/0_stateless/01646_rewrite_sum_if.sql
index 9abe7f35005..b2de98e9e07 100644
--- a/tests/queries/0_stateless/01646_rewrite_sum_if.sql
+++ b/tests/queries/0_stateless/01646_rewrite_sum_if.sql
@@ -41,3 +41,9 @@ SELECT countIf(number % 2 != 0) FROM numbers(100);
 EXPLAIN SYNTAX SELECT sumIf(123, number % 2 == 0) FROM numbers(100);
 EXPLAIN SYNTAX SELECT sum(if(number % 2 == 0, 123, 0)) FROM numbers(100);
 EXPLAIN SYNTAX SELECT sum(if(number % 2 == 0, 0, 123)) FROM numbers(100);
+
+set allow_experimental_analyzer = true;
+
+EXPLAIN QUERY TREE run_passes=1 SELECT sumIf(123, number % 2 == 0) FROM numbers(100);
+EXPLAIN QUERY TREE run_passes=1 SELECT sum(if(number % 2 == 0, 123, 0)) FROM numbers(100);
+EXPLAIN QUERY TREE run_passes=1 SELECT sum(if(number % 2 == 0, 0, 123)) FROM numbers(100);
\ No newline at end of file

From fa6dea8b6b08b5ec00e04a300923a84cb11560ae Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Sun, 29 Jan 2023 19:50:30 +0800
Subject: [PATCH 26/79] remove useless code

---
 src/Analyzer/IQueryTreeNode.h | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/Analyzer/IQueryTreeNode.h b/src/Analyzer/IQueryTreeNode.h
index 719f92d773e..8aa834e60b7 100644
--- a/src/Analyzer/IQueryTreeNode.h
+++ b/src/Analyzer/IQueryTreeNode.h
@@ -72,9 +72,6 @@ class IQueryTreeNode : public TypePromotion<IQueryTreeNode>
 public:
     virtual ~IQueryTreeNode() = default;
 
-    IQueryTreeNode & operator=(const IQueryTreeNode &) = default;
-    IQueryTreeNode & operator=(IQueryTreeNode &&) = default;
-
     /// Get query tree node type
     virtual QueryTreeNodeType getNodeType() const = 0;
 

From 2d7c357d61b7dc2b61a84ae736daaad1130d8832 Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Tue, 31 Jan 2023 18:00:31 +0800
Subject: [PATCH 27/79] implement columnar version for multiIf when
 instructions contains short

---
 src/Functions/multiIf.cpp | 160 ++++++++++++++++++++++++++++++++------
 1 file changed, 136 insertions(+), 24 deletions(-)

diff --git a/src/Functions/multiIf.cpp b/src/Functions/multiIf.cpp
index 247787f3a3a..c8be9e7b44e 100644
--- a/src/Functions/multiIf.cpp
+++ b/src/Functions/multiIf.cpp
@@ -217,16 +217,6 @@ public:
                 break;
         }
 
-        for (size_t i = 0; i < instructions.size(); ++i)
-        {
-            auto & instruction = instructions[i];
-            auto source = instruction.source;
-            for (size_t row_i = 0; row_i < input_rows_count; ++row_i)
-            {
-                std::cout << "number:" << row_i << ",instruction:" << i << ",field" << toString((*source)[row_i]) << std::endl;
-            }
-        }
-
         /// Special case if first instruction condition is always true and source is constant
         if (instructions.size() == 1 && instructions.front().source_is_constant
             && instructions.front().condition_always_true)
@@ -237,10 +227,45 @@ public:
             return ColumnConst::create(std::move(res), instruction.source->size());
         }
 
-        size_t rows = input_rows_count;
+        bool contains_short = false;
+        // size_t i = 0;
+        for (const auto & instruction : instructions)
+        {
+            if (instruction.condition_is_short || instruction.source_is_short)
+            {
+                contains_short = true;
+            }
+
+            /*
+            Field field;
+            for (size_t row_i = 0; row_i < instruction.source->size(); ++row_i)
+            {
+                instruction.source->get(row_i, field);
+                std::cout << "source" << i << ",row:" << row_i << ",value:" << toString(field) << std::endl;
+            }
+
+            if (instruction.condition_always_true)
+            {
+                std::cout << "cond" << i << " is always true" << std::endl;
+                continue;
+            }
+
+            for (size_t row_i=0; row_i < instruction.condition->size(); ++row_i)
+            {
+                instruction.condition->get(row_i, field);
+                std::cout << "cond" << i << ",row:" << row_i << ",value:" << toString(field) << std::endl;
+            }
+            ++i;
+            */
+        }
+        // std::cout << "contains_short:" << contains_short << std::endl;
+
         const auto & settings = context->getSettingsRef();
         const WhichDataType which(result_type);
         bool execute_multiif_columnar = settings.allow_execute_multiif_columnar && (which.isInt() || which.isUInt() || which.isFloat());
+        // std::cout << "execute_multiif_columnar:" << execute_multiif_columnar << std::endl;
+
+        size_t rows = input_rows_count;
         if (!execute_multiif_columnar)
         {
             MutableColumnPtr res = return_type->createColumn();
@@ -248,12 +273,14 @@ public:
             return std::move(res);
         }
 
-
 #define EXECUTE_INSTRUCTIONS_COLUMNAR(TYPE, INDEX) \
     if (which.is##TYPE()) \
     { \
         MutableColumnPtr res = ColumnVector<TYPE>::create(rows); \
-        executeInstructionsColumnar<TYPE, INDEX>(instructions, rows, res); \
+        if (!contains_short) \
+            executeInstructionsColumnar<TYPE, INDEX>(instructions, rows, res); \
+        else \
+            executeInstructionsColumnarNew<TYPE, INDEX>(instructions, rows, res); \
         return std::move(res); \
     }
 
@@ -347,12 +374,11 @@ private:
                 const auto & cond_data = assert_cast<const ColumnUInt8 &>(*instruction.condition).getData();
                 for (size_t row_i = 0; row_i < rows; ++row_i)
                 {
-                    size_t condition_index = instruction.condition_is_short ? instruction.condition_index++ : row_i;
-
                     /// Equivalent to below code. But it is able to utilize SIMD instructions.
-                    /// if (cond_data[condition_index])
+                    /// if (cond_data[row_i])
                     ///     inserts[row_i] = i;
-                    inserts[row_i] += cond_data[condition_index] * (i - inserts[row_i]);
+
+                    inserts[row_i] += (!!cond_data[row_i]) * (i - inserts[row_i]);
                 }
             }
             else
@@ -364,12 +390,10 @@ private:
 
                 for (size_t row_i = 0; row_i < rows; ++row_i)
                 {
-                    size_t condition_index = instruction.condition_is_short ? instruction.condition_index++ : row_i;
                     /// Equivalent to below code. But it is able to utilize SIMD instructions.
-                    /// if (!condition_null_map[condition_index] && condition_nested.getData()[condition_index])
+                    /// if (!condition_null_map[row_i] && condition_nested_data[row_i])
                     ///     inserts[row_i] = i;
-                    inserts[row_i] += (~condition_null_map[condition_index] & condition_nested_data[condition_index])
-                        * (i - inserts[row_i]);
+                    inserts[row_i] += (~condition_null_map[row_i] & (!!condition_nested_data[row_i])) * (i - inserts[row_i]);
                 }
             }
         }
@@ -381,15 +405,103 @@ private:
         PaddedPODArray<S> inserts(rows, static_cast<S>(instructions.size()));
         calculateInserts(instructions, rows, inserts);
 
-
-
         PaddedPODArray<T> & res_data = assert_cast<ColumnVector<T> &>(*res).getData();
         for (size_t row_i = 0; row_i < rows; ++row_i)
         {
             auto & instruction = instructions[inserts[row_i]];
             auto ref = instruction.source->getDataAt(row_i);
             res_data[row_i] = *reinterpret_cast<const T*>(ref.data);
-            std::cout << "number:" << row_i << ",instruction:" << inserts[row_i] << std::endl;
+            // std::cout << "row:" << row_i << ",instruction:" << inserts[row_i] << std::endl;
+        }
+    }
+
+    /// We should read source from which instruction on each row?
+    template <typename S>
+    static NO_INLINE void calculateInsertsNew(std::vector<Instruction> & instructions, size_t rows, PaddedPODArray<S> & instruction_indexes, PaddedPODArray<size_t> & source_indexes)
+    {
+        S instruction_size = static_cast<S>(instructions.size());
+        for (S i = 0; i < static_cast<S>(instructions.size()); ++i)
+        {
+            auto & instruction = instructions[i];
+            if (instruction.condition_always_true)
+            {
+                for (size_t row_i = 0; row_i < rows; ++row_i)
+                {
+                    if (instruction_indexes[row_i] != instruction_size)
+                        continue;
+
+                    instruction_indexes[row_i] = i;
+
+                    size_t source_index = instruction.source_is_short ? instruction.source_index++ : row_i;
+                    source_indexes[row_i] = source_index;
+                }
+            }
+            else if (!instruction.condition_is_nullable)
+            {
+                const auto & cond_data = assert_cast<const ColumnUInt8 &>(*instruction.condition).getData();
+                for (size_t row_i = 0; row_i < rows; ++row_i)
+                {
+                    if (instruction_indexes[row_i] != instruction_size)
+                        continue;
+
+                    size_t condition_index = instruction.condition_is_short ? instruction.condition_index++ : row_i;
+                    if (cond_data[condition_index])
+                    {
+                        instruction_indexes[row_i] = i;
+
+                        size_t source_index = instruction.source_is_short ? instruction.source_index++ : row_i;
+                        source_indexes[row_i] = source_index;
+                    }
+                }
+            }
+            else
+            {
+                const ColumnNullable & condition_nullable = assert_cast<const ColumnNullable &>(*instruction.condition);
+                const ColumnUInt8 & condition_nested = assert_cast<const ColumnUInt8 &>(condition_nullable.getNestedColumn());
+                const auto & condition_nested_data = condition_nested.getData();
+                const NullMap & condition_null_map = condition_nullable.getNullMapData();
+
+                for (size_t row_i = 0; row_i < rows; ++row_i)
+                {
+                    if (instruction_indexes[row_i] != instruction_size)
+                        continue;
+
+                    size_t condition_index = instruction.condition_is_short ? instruction.condition_index++ : row_i;
+                    if (!condition_null_map[condition_index] && condition_nested_data[condition_index])
+                    {
+                        instruction_indexes[row_i] = i;
+
+                        size_t source_index = instruction.source_is_short ? instruction.source_index++ : row_i;
+                        source_indexes[row_i] = source_index;
+                    }
+                }
+            }
+
+            /*
+            std::cout << "after instruction: " << i << std::endl;
+            for (size_t row_i = 0; row_i < rows; ++row_i)
+            {
+                std::cout << "instruction indexes[" << row_i << "]:" << instruction_indexes[row_i] << std::endl;
+                std::cout << "source indexes[" << row_i << "]:" << source_indexes[row_i] << std::endl;
+            }
+            */
+        }
+    }
+
+    template <typename T, typename S>
+    static NO_INLINE void executeInstructionsColumnarNew(std::vector<Instruction> & instructions, size_t rows, const MutableColumnPtr & res)
+    {
+        PaddedPODArray<S> instruction_indexes(rows, static_cast<S>(instructions.size()));
+        PaddedPODArray<size_t> source_indexes(rows, rows);
+        calculateInsertsNew(instructions, rows, instruction_indexes, source_indexes);
+
+        PaddedPODArray<T> & res_data = assert_cast<ColumnVector<T> &>(*res).getData();
+        for (size_t row_i = 0; row_i < rows; ++row_i)
+        {
+            // std::cout << "row:" << row_i << ", instruction:" << instruction_indexes[row_i] << ", source_row:" << source_indexes[row_i] << std::endl;
+            auto & instruction = instructions[instruction_indexes[row_i]];
+            auto ref = instruction.source->getDataAt(source_indexes[row_i]);
+            res_data[row_i] = *reinterpret_cast<const T*>(ref.data);
         }
     }
 

From d2e97fb94dd53ec972cb0cc8f00a2601250a19f0 Mon Sep 17 00:00:00 2001
From: taiyang-li <654010905@qq.com>
Date: Tue, 31 Jan 2023 18:13:01 +0800
Subject: [PATCH 28/79] remove columnar impl when instructions contains short

---
 src/Functions/multiIf.cpp | 125 ++------------------------------------
 1 file changed, 4 insertions(+), 121 deletions(-)

diff --git a/src/Functions/multiIf.cpp b/src/Functions/multiIf.cpp
index c8be9e7b44e..cdb9ca061c3 100644
--- a/src/Functions/multiIf.cpp
+++ b/src/Functions/multiIf.cpp
@@ -228,42 +228,19 @@ public:
         }
 
         bool contains_short = false;
-        // size_t i = 0;
         for (const auto & instruction : instructions)
         {
             if (instruction.condition_is_short || instruction.source_is_short)
             {
                 contains_short = true;
+                break;
             }
-
-            /*
-            Field field;
-            for (size_t row_i = 0; row_i < instruction.source->size(); ++row_i)
-            {
-                instruction.source->get(row_i, field);
-                std::cout << "source" << i << ",row:" << row_i << ",value:" << toString(field) << std::endl;
-            }
-
-            if (instruction.condition_always_true)
-            {
-                std::cout << "cond" << i << " is always true" << std::endl;
-                continue;
-            }
-
-            for (size_t row_i=0; row_i < instruction.condition->size(); ++row_i)
-            {
-                instruction.condition->get(row_i, field);
-                std::cout << "cond" << i << ",row:" << row_i << ",value:" << toString(field) << std::endl;
-            }
-            ++i;
-            */
         }
-        // std::cout << "contains_short:" << contains_short << std::endl;
 
         const auto & settings = context->getSettingsRef();
         const WhichDataType which(result_type);
-        bool execute_multiif_columnar = settings.allow_execute_multiif_columnar && (which.isInt() || which.isUInt() || which.isFloat());
-        // std::cout << "execute_multiif_columnar:" << execute_multiif_columnar << std::endl;
+        bool execute_multiif_columnar
+            = settings.allow_execute_multiif_columnar && !contains_short && (which.isInt() || which.isUInt() || which.isFloat());
 
         size_t rows = input_rows_count;
         if (!execute_multiif_columnar)
@@ -277,10 +254,7 @@ public:
     if (which.is##TYPE()) \
     { \
         MutableColumnPtr res = ColumnVector<TYPE>::create(rows); \
-        if (!contains_short) \
-            executeInstructionsColumnar<TYPE, INDEX>(instructions, rows, res); \
-        else \
-            executeInstructionsColumnarNew<TYPE, INDEX>(instructions, rows, res); \
+        executeInstructionsColumnar<TYPE, INDEX>(instructions, rows, res); \
         return std::move(res); \
     }
 
@@ -411,97 +385,6 @@ private:
             auto & instruction = instructions[inserts[row_i]];
             auto ref = instruction.source->getDataAt(row_i);
             res_data[row_i] = *reinterpret_cast<const T*>(ref.data);
-            // std::cout << "row:" << row_i << ",instruction:" << inserts[row_i] << std::endl;
-        }
-    }
-
-    /// We should read source from which instruction on each row?
-    template <typename S>
-    static NO_INLINE void calculateInsertsNew(std::vector<Instruction> & instructions, size_t rows, PaddedPODArray<S> & instruction_indexes, PaddedPODArray<size_t> & source_indexes)
-    {
-        S instruction_size = static_cast<S>(instructions.size());
-        for (S i = 0; i < static_cast<S>(instructions.size()); ++i)
-        {
-            auto & instruction = instructions[i];
-            if (instruction.condition_always_true)
-            {
-                for (size_t row_i = 0; row_i < rows; ++row_i)
-                {
-                    if (instruction_indexes[row_i] != instruction_size)
-                        continue;
-
-                    instruction_indexes[row_i] = i;
-
-                    size_t source_index = instruction.source_is_short ? instruction.source_index++ : row_i;
-                    source_indexes[row_i] = source_index;
-                }
-            }
-            else if (!instruction.condition_is_nullable)
-            {
-                const auto & cond_data = assert_cast<const ColumnUInt8 &>(*instruction.condition).getData();
-                for (size_t row_i = 0; row_i < rows; ++row_i)
-                {
-                    if (instruction_indexes[row_i] != instruction_size)
-                        continue;
-
-                    size_t condition_index = instruction.condition_is_short ? instruction.condition_index++ : row_i;
-                    if (cond_data[condition_index])
-                    {
-                        instruction_indexes[row_i] = i;
-
-                        size_t source_index = instruction.source_is_short ? instruction.source_index++ : row_i;
-                        source_indexes[row_i] = source_index;
-                    }
-                }
-            }
-            else
-            {
-                const ColumnNullable & condition_nullable = assert_cast<const ColumnNullable &>(*instruction.condition);
-                const ColumnUInt8 & condition_nested = assert_cast<const ColumnUInt8 &>(condition_nullable.getNestedColumn());
-                const auto & condition_nested_data = condition_nested.getData();
-                const NullMap & condition_null_map = condition_nullable.getNullMapData();
-
-                for (size_t row_i = 0; row_i < rows; ++row_i)
-                {
-                    if (instruction_indexes[row_i] != instruction_size)
-                        continue;
-
-                    size_t condition_index = instruction.condition_is_short ? instruction.condition_index++ : row_i;
-                    if (!condition_null_map[condition_index] && condition_nested_data[condition_index])
-                    {
-                        instruction_indexes[row_i] = i;
-
-                        size_t source_index = instruction.source_is_short ? instruction.source_index++ : row_i;
-                        source_indexes[row_i] = source_index;
-                    }
-                }
-            }
-
-            /*
-            std::cout << "after instruction: " << i << std::endl;
-            for (size_t row_i = 0; row_i < rows; ++row_i)
-            {
-                std::cout << "instruction indexes[" << row_i << "]:" << instruction_indexes[row_i] << std::endl;
-                std::cout << "source indexes[" << row_i << "]:" << source_indexes[row_i] << std::endl;
-            }
-            */
-        }
-    }
-
-    template <typename T, typename S>
-    static NO_INLINE void executeInstructionsColumnarNew(std::vector<Instruction> & instructions, size_t rows, const MutableColumnPtr & res)
-    {
-        PaddedPODArray<S> instruction_indexes(rows, static_cast<S>(instructions.size()));
-        PaddedPODArray<size_t> source_indexes(rows, rows);
-        calculateInsertsNew(instructions, rows, instruction_indexes, source_indexes);
-
-        PaddedPODArray<T> & res_data = assert_cast<ColumnVector<T> &>(*res).getData();
-        for (size_t row_i = 0; row_i < rows; ++row_i)
-        {
-            // std::cout << "row:" << row_i << ", instruction:" << instruction_indexes[row_i] << ", source_row:" << source_indexes[row_i] << std::endl;
-            auto & instruction = instructions[instruction_indexes[row_i]];
-            auto ref = instruction.source->getDataAt(source_indexes[row_i]);
-            res_data[row_i] = *reinterpret_cast<const T*>(ref.data);
         }
     }
 

From 90153c11fcff270de69567229f197db1efee300f Mon Sep 17 00:00:00 2001
From: Han Fei <hanfei19910905@gmail.com>
Date: Wed, 1 Feb 2023 15:09:04 +0100
Subject: [PATCH 29/79] fix matching priority

---
 src/Dictionaries/RegExpTreeDictionary.cpp     |  31 +-
 src/Dictionaries/RegExpTreeDictionary.h       |   4 +-
 ...2504_regexp_dictionary_ua_parser.reference | 478 +++++++++---------
 3 files changed, 260 insertions(+), 253 deletions(-)

diff --git a/src/Dictionaries/RegExpTreeDictionary.cpp b/src/Dictionaries/RegExpTreeDictionary.cpp
index 7feb3c50779..0cf7d579f96 100644
--- a/src/Dictionaries/RegExpTreeDictionary.cpp
+++ b/src/Dictionaries/RegExpTreeDictionary.cpp
@@ -289,7 +289,7 @@ void RegExpTreeDictionary::initTopologyOrder(UInt64 node_idx, std::set<UInt64> &
     visited.insert(node_idx);
     for (UInt64 child_idx : regex_nodes[node_idx]->children)
         if (visited.contains(child_idx))
-            throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION, "Invalid Regex tree");
+            throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION, "Invalid Regex tree. The input tree is cyclical");
         else
             initTopologyOrder(child_idx, visited, topology_id);
     topology_order[node_idx] = topology_id++;
@@ -360,7 +360,7 @@ std::pair<String, bool> processBackRefs(const String & data, const re2_st::RE2 &
     String result;
     searcher.Match(haystack, 0, data.size(), re2_st::RE2::Anchor::UNANCHORED, matches, 10);
     /// if the pattern is a single '$1' but fails to match, we would use the default value.
-    if (pieces.size() == 1 && pieces[0].ref_num >= 0 && pieces[0].ref_num < 9 && matches[pieces[0].ref_num].empty())
+    if (pieces.size() == 1 && pieces[0].ref_num >= 0 && pieces[0].ref_num < 10 && matches[pieces[0].ref_num].empty())
         return std::make_pair(result, true);
     for (const auto & item : pieces)
     {
@@ -379,7 +379,9 @@ bool RegExpTreeDictionary::setAttributes(
     std::unordered_map<String, Field> & attributes_to_set,
     const String & data,
     std::unordered_set<UInt64> & visited_nodes,
-    const std::unordered_map<String, const DictionaryAttribute &> & attributes) const
+    const std::unordered_map<String, const DictionaryAttribute &> & attributes,
+    const std::unordered_map<String, ColumnPtr> & defaults,
+    size_t key_index) const
 {
 
     if (visited_nodes.contains(id))
@@ -393,7 +395,12 @@ bool RegExpTreeDictionary::setAttributes(
         if (value.containsBackRefs())
         {
             auto [updated_str, use_default] = processBackRefs(data, regex_nodes.at(id)->searcher, value.pieces);
-            if (!use_default)
+            if (use_default)
+            {
+                DefaultValueProvider default_value(attributes.at(name).null_value, defaults.at(name));
+                attributes_to_set[name] = default_value.getDefaultValue(key_index);
+            }
+            else
                 attributes_to_set[name] = parseStringToField(updated_str, attributes.at(name).type);
         }
         else
@@ -402,7 +409,7 @@ bool RegExpTreeDictionary::setAttributes(
 
     auto parent_id = regex_nodes.at(id)->parent_id;
     if (parent_id > 0)
-        setAttributes(parent_id, attributes_to_set, data, visited_nodes, attributes);
+        setAttributes(parent_id, attributes_to_set, data, visited_nodes, attributes, defaults, key_index);
 
     // if all the attributes have set, the walking through can be stopped.
     return attributes_to_set.size() == attributes.size();
@@ -437,6 +444,7 @@ namespace
             matched_idx_sorted_list.push_back(std::make_pair(topological_order, id));
         }
 
+        /// Sort by topological order, which indicates the matching priorities.
         void sort()
         {
             std::sort(matched_idx_sorted_list.begin(), matched_idx_sorted_list.end());
@@ -507,15 +515,12 @@ std::unordered_map<String, ColumnPtr> RegExpTreeDictionary::matchSearchAllIndice
         if (err != HS_SUCCESS)
             throw Exception(ErrorCodes::HYPERSCAN_CANNOT_SCAN_TEXT, "Failed to scan data with vectorscan");
 
-        if (!match_result.matched_idx_set.empty())
+        for (const auto & node_ptr : complex_regexp_nodes)
         {
-            for (const auto & node_ptr : complex_regexp_nodes)
+            if (node_ptr->match(reinterpret_cast<const char *>(keys_data.data()) + offset, length))
             {
-                if (node_ptr->match(reinterpret_cast<const char *>(keys_data.data()) + offset, length))
-                {
-                    match_result.insertNodeID(node_ptr->id);
-                    break;
-                }
+                match_result.insertNodeID(node_ptr->id);
+                break;
             }
         }
 
@@ -546,7 +551,7 @@ std::unordered_map<String, ColumnPtr> RegExpTreeDictionary::matchSearchAllIndice
                 continue;
             if (visited_nodes.contains(id))
                 continue;
-            if (setAttributes(id, attributes_to_set, str, visited_nodes, attributes))
+            if (setAttributes(id, attributes_to_set, str, visited_nodes, attributes, defaults, key_idx))
                 break;
         }
 
diff --git a/src/Dictionaries/RegExpTreeDictionary.h b/src/Dictionaries/RegExpTreeDictionary.h
index f3de05239b5..29c8b461324 100644
--- a/src/Dictionaries/RegExpTreeDictionary.h
+++ b/src/Dictionaries/RegExpTreeDictionary.h
@@ -146,7 +146,9 @@ private:
         std::unordered_map<String, Field> & attributes_to_set,
         const String & data,
         std::unordered_set<UInt64> & visited_nodes,
-        const std::unordered_map<String, const DictionaryAttribute &> & attributes) const;
+        const std::unordered_map<String, const DictionaryAttribute &> & attributes,
+        const std::unordered_map<String, ColumnPtr> & defaults,
+        size_t key_index) const;
 
     struct RegexTreeNode;
     using RegexTreeNodePtr = std::shared_ptr<RegexTreeNode>;
diff --git a/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.reference b/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.reference
index d6dd2adae74..b161b099eef 100644
--- a/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.reference
+++ b/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.reference
@@ -1,14 +1,14 @@
-AppleTV	Other 0.0	ATV OS X 8.1.3
+AppleTV	Other 0.0	ATV OS X 0.0.0
 LG-M150	Firefox Mobile 68.0	Android 7.0.0
-Other	Firefox Mobile 68.0	Android 8.0.0
-Other	Firefox Mobile 68.0	Android 8.1.0
-Other	Firefox Mobile 68.0	Android 9.0.0
-Other	Chrome Mobile 77.0	Android 10.0.0
-Other	Chrome Mobile 77.0	Android 10.0.0
-Other	Chrome Mobile 77.0	Android 10.0.0
-Other	Facebook 240.0	Android 10.0.0
-Other	Chrome Mobile WebView 77.0	Android 10.0.0
-Other	Chrome Mobile 77.0	Android 10.0.0
+Generic Smartphone	Firefox Mobile 68.0	Android 8.0.0
+Generic Tablet	Firefox Mobile 68.0	Android 8.1.0
+Generic Smartphone	Firefox Mobile 68.0	Android 9.0.0
+PH-1	Chrome Mobile 77.0	Android 10.0.0
+Pixel 2 XL	Chrome Mobile 77.0	Android 10.0.0
+Pixel 2	Chrome Mobile 77.0	Android 10.0.0
+Pixel 3	Facebook 240.0	Android 10.0.0
+Pixel XL	Chrome Mobile WebView 77.0	Android 10.0.0
+Pixel XL	Chrome Mobile 77.0	Android 10.0.0
 HTC Sensation 4G	Chrome Mobile 42.0	Android 4.0.3
 Kindle	Amazon Silk 73.7	Android 4.0.3
 Samsung GT-I9152 	Chrome Mobile 42.0	Android 4.2.2
@@ -16,7 +16,7 @@ Samsung GT-N5110	Chrome 76.0	Android 4.4.2
 RCT6773W22	Chrome 77.0	Android 4.4.2
 Samsung SM-T217S	Chrome 77.0	Android 4.4.2
 Samsung SM-T530NU	Chrome 77.0	Android 4.4.2
-Other	Chrome 69.0	Android 4.4.2
+TegraNote-P1640	Chrome 69.0	Android 4.4.2
 Kindle	Amazon Silk 76.3	Android 4.4.3
 Samsung SM-A500H	Chrome Mobile 73.0	Android 5.0.2
 Samsung SM-T357T	Chrome 77.0	Android 5.0.2
@@ -24,9 +24,9 @@ Samsung SM-T530NU	Chrome 76.0	Android 5.0.2
 Samsung SM-T530NU	Chrome 77.0	Android 5.0.2
 RCT6213W87DK	Yandex Browser 19.4	Android 5.0.0
 Samsung SM-N900T	Facebook 229.0	Android 5.0.0
-Other	Chrome Mobile WebView 70.0	Android 5.1.1
+Generic Smartphone	Chrome Mobile WebView 70.0	Android 5.1.1
 Kindle	Amazon Silk 76.3	Android 5.1.1
-Other	Chrome Mobile WebView 70.0	Android 5.1.1
+AFTT	Chrome Mobile WebView 70.0	Android 5.1.1
 Kindle	Amazon Silk 76.3	Android 5.1.1
 Kindle	Amazon Silk 76.3	Android 5.1.1
 Kindle	Amazon Silk 71.2	Android 5.1.1
@@ -36,29 +36,29 @@ Kindle	Amazon Silk 76.3	Android 5.1.1
 Kindle	Amazon Silk 76.3	Android 5.1.1
 Kindle	Amazon Silk 77.1	Android 5.1.1
 LG-AS330	Chrome Mobile 77.0	Android 5.1.1
-Other	Chrome Mobile 77.0	Android 5.1.1
+LGL43AL	Chrome Mobile 77.0	Android 5.1.1
 Samsung SM-G530R7	Samsung Internet 9.2	Android 5.1.1
 Samsung SM-T377P	Samsung Internet 10.1	Android 5.1.1
 Samsung SM-T900	Samsung Internet 10.1	Android 5.1.1
 Samsung SM-T337A	Chrome 69.0	Android 5.1.1
 Samsung SM-G360T1	Chrome Mobile 67.0	Android 5.1.1
 Samsung SM-J320FN	Chrome Mobile 74.0	Android 5.1.1
-Other	Chrome 74.0	Android 5.1.1
+SM-T280	Chrome 74.0	Android 5.1.1
 Samsung SM-T330NU	Chrome 71.0	Android 5.1.1
-Other	Chrome 76.0	Android 5.1.1
-Other	Chrome 77.0	Android 5.1.1
-Other	Chrome Mobile WebView 74.0	Android 5.1.1
-Other	Chrome Mobile 66.0	Android 5.1.0
+SM-T670	Chrome 76.0	Android 5.1.1
+SM-T670	Chrome 77.0	Android 5.1.1
+Vodafone Smart ultra 6	Chrome Mobile WebView 74.0	Android 5.1.1
+BLU Advance 5.0	Chrome Mobile 66.0	Android 5.1.0
 HTC Desire 626s	Chrome Mobile 77.0	Android 5.1.0
 HUAWEI LUA-L22	Chrome Mobile 50.0	Android 5.1.0
-Other	Chrome 77.0	Android 5.1.0
-Other	Chrome Mobile 73.0	Android 5.1.0
+NX16A11264	Chrome 77.0	Android 5.1.0
+XT1526	Chrome Mobile 73.0	Android 5.1.0
 Oppo CPH1613	Chrome Mobile 77.0	Android 6.0.1
 LG-M153 	Chrome Mobile WebView 55.0	Android 6.0.1
 LG-M153	Chrome Mobile 77.0	Android 6.0.1
-Other	Chrome Mobile 77.0	Android 6.0.1
-Other	Chrome Mobile 74.0	Android 6.0.1
-Other	Chrome 44.0	Android 6.0.1
+LGLS676	Chrome Mobile 77.0	Android 6.0.1
+N9136	Chrome Mobile 74.0	Android 6.0.1
+Asus Nexus 7	Chrome 44.0	Android 6.0.1
 Samsung SM-G900I	Samsung Internet 10.1	Android 6.0.1
 Samsung SM-G900P	Samsung Internet 7.2	Android 6.0.1
 Samsung SM-J700M	Samsung Internet 10.1	Android 6.0.1
@@ -77,19 +77,19 @@ Samsung SM-N910S	Chrome Mobile 75.0	Android 6.0.1
 Samsung SM-N920V	Chrome Mobile 76.0	Android 6.0.1
 Samsung SM-T350	Chrome 59.0	Android 6.0.1
 Samsung SM-T560NU	Chrome 77.0	Android 6.0.1
-Other	Chrome 77.0	Android 6.0.1
-Other	Chrome Mobile 77.0	Android 6.0.1
-Other	Chrome Mobile 67.0	Android 6.0.1
-Other	Chrome Mobile WebView 45.0	Android 6.0.1
-Other	Chrome Mobile 76.0	Android 6.0.0
+SM-T800	Chrome 77.0	Android 6.0.1
+XT1254	Chrome Mobile 77.0	Android 6.0.1
+Z798BL	Chrome Mobile 67.0	Android 6.0.1
+Z799VL	Chrome Mobile WebView 45.0	Android 6.0.1
+5010X	Chrome Mobile 76.0	Android 6.0.0
 Huawei CAM-L21	Chrome Mobile 77.0	Android 6.0.0
-Other	Chrome Mobile 77.0	Android 6.0.0
+F3313	Chrome Mobile 77.0	Android 6.0.0
 RCT6603W47M7	Chrome 77.0	Android 6.0.0
-Other	Chrome Mobile 56.0	Android 7.0.0
+5049Z	Chrome Mobile 56.0	Android 7.0.0
 Asus A002A	Chrome Mobile 77.0	Android 7.0.0
-Other	Chrome Mobile 77.0	Android 7.0.0
-Other	Chrome Mobile WebView 59.0	Android 7.0.0
-Other	Chrome Mobile 77.0	Android 7.0.0
+Alcatel_5044C	Chrome Mobile 77.0	Android 7.0.0
+Astra Young Pro	Chrome Mobile WebView 59.0	Android 7.0.0
+Infinix X571	Chrome Mobile 77.0	Android 7.0.0
 LG-H872 	Chrome Mobile 64.0	Android 7.0.0
 LG-K425 	Chrome Mobile 55.0	Android 7.0.0
 LG-LS777	Chrome Mobile 77.0	Android 7.0.0
@@ -100,11 +100,11 @@ LG-TP260	Chrome Mobile 77.0	Android 7.0.0
 LG-TP450 	Chrome Mobile 64.0	Android 7.0.0
 LG-V521	Chrome 75.0	Android 7.0.0
 LG-V521	Chrome 77.0	Android 7.0.0
-Other	Chrome Mobile 58.0	Android 7.0.0
-Other	Chrome Mobile 55.0	Android 7.0.0
-Other	Chrome Mobile 77.0	Android 7.0.0
-Other	Chrome 77.0	Android 7.0.0
-Other	Chrome Mobile 77.0	Android 7.0.0
+LGMP260	Chrome Mobile 58.0	Android 7.0.0
+LGMS210	Chrome Mobile 55.0	Android 7.0.0
+LGMS210	Chrome Mobile 77.0	Android 7.0.0
+P00I	Chrome 77.0	Android 7.0.0
+RS988	Chrome Mobile 77.0	Android 7.0.0
 Samsung SM-J701F	Samsung Internet 10.1	Android 7.0.0
 Samsung SM-J710F	Samsung Internet 10.1	Android 7.0.0
 Samsung SM-N920T	Samsung Internet 9.2	Android 7.0.0
@@ -122,63 +122,63 @@ Samsung SM-J327T1	Chrome Mobile 77.0	Android 7.0.0
 Samsung SM-N9208	Chrome Mobile 73.0	Android 7.0.0
 Samsung SM-N920P	Chrome Mobile 74.0	Android 7.0.0
 Samsung SM-N920T	Chrome Mobile 77.0	Android 7.0.0
-Other	Chrome 77.0	Android 7.0.0
-Other	Chrome 75.0	Android 7.0.0
-Other	Chrome 76.0	Android 7.0.0
-Other	Chrome 77.0	Android 7.0.0
-Other	Chrome 76.0	Android 7.0.0
-Other	Chrome 76.0	Android 7.0.0
-Other	Chrome 75.0	Android 7.0.0
-Other	Chrome Mobile 77.0	Android 7.0.0
+SM-T585	Chrome 77.0	Android 7.0.0
+SM-T810	Chrome 75.0	Android 7.0.0
+SM-T810	Chrome 76.0	Android 7.0.0
+SM-T810	Chrome 77.0	Android 7.0.0
+SM-T813	Chrome 76.0	Android 7.0.0
+SM-T813	Chrome 76.0	Android 7.0.0
+Trekstor ST1009X	Chrome 75.0	Android 7.0.0
+XT1663	Chrome Mobile 77.0	Android 7.0.0
 Generic Smartphone	Chrome Mobile 58.0	Android 7.0.0
-Other	Chrome Mobile WebView 77.0	Android 7.1.1
-Other	Chrome Mobile 77.0	Android 7.1.1
+A574BL	Chrome Mobile WebView 77.0	Android 7.1.1
+A574BL	Chrome Mobile 77.0	Android 7.1.1
 Oppo CPH1729	Facebook 240.0	Android 7.1.1
-Other	Chrome Mobile 74.0	Android 7.1.1
-Other	Chrome Mobile 77.0	Android 7.1.1
-Other	Chrome Mobile WebView 76.0	Android 7.1.1
-Other	Chrome Mobile 70.0	Android 7.1.1
-Other	Chrome Mobile 76.0	Android 7.1.1
-Other	Chrome Mobile 77.0	Android 7.1.1
-Other	Chrome Mobile 77.0	Android 7.1.1
-Other	Chrome Mobile 77.0	Android 7.1.1
-Other	Chrome Mobile 64.0	Android 7.1.1
+3632A	Chrome Mobile 74.0	Android 7.1.1
+General Mobile 4G Dual	Chrome Mobile 77.0	Android 7.1.1
+Moto E (4) Plus	Chrome Mobile WebView 76.0	Android 7.1.1
+Moto E (4)	Chrome Mobile 70.0	Android 7.1.1
+Moto E (4)	Chrome Mobile 76.0	Android 7.1.1
+Moto E (4)	Chrome Mobile 77.0	Android 7.1.1
+Moto E (4)	Chrome Mobile 77.0	Android 7.1.1
+NX591J	Chrome Mobile 77.0	Android 7.1.1
+REVVLPLUS C3701A	Chrome Mobile 64.0	Android 7.1.1
 Samsung SM-J320A	Samsung Internet 10.1	Android 7.1.1
 Samsung SM-T550	Samsung Internet 10.1	Android 7.1.1
 Samsung SM-T377A	Chrome 64.0	Android 7.1.1
 Samsung SM-J250F	Chrome Mobile 76.0	Android 7.1.1
 Samsung SM-J700T	Chrome Mobile 77.0	Android 7.1.1
-Other	Chrome 77.0	Android 7.1.1
+SM-T350	Chrome 77.0	Android 7.1.1
 Samsung SM-T377T	Chrome 77.0	Android 7.1.1
 Samsung SM-T550	Chrome 69.0	Android 7.1.1
-Other	Chrome 77.0	Android 7.1.1
+SM-T550	Chrome 77.0	Android 7.1.1
 Samsung SM-T560NU	Chrome 77.0	Android 7.1.1
 X20	Chrome Mobile WebView 52.0	Android 7.1.1
-Other	Chrome Mobile 58.0	Android 7.1.1
-Other	Chrome Mobile WebView 74.0	Android 7.1.1
-Other	Chrome Mobile WebView 75.0	Android 7.1.1
-Other	Chrome Mobile 77.0	Android 7.1.1
-Other	Chrome Mobile WebView 70.0	Android 7.1.2
-Other	Chrome Mobile WebView 70.0	Android 7.1.2
+Z851M	Chrome Mobile 58.0	Android 7.1.1
+Z899VL	Chrome Mobile WebView 74.0	Android 7.1.1
+Z982	Chrome Mobile WebView 75.0	Android 7.1.1
+Z982	Chrome Mobile 77.0	Android 7.1.1
+Generic Smartphone	Chrome Mobile WebView 70.0	Android 7.1.2
+AFTKMST12	Chrome Mobile WebView 70.0	Android 7.1.2
 Kindle	Amazon Silk 76.3	Android 7.1.2
-Other	Chrome Mobile WebView 70.0	Android 7.1.2
-Other	Chrome Mobile WebView 70.0	Android 7.1.2
-Other	Chrome Mobile WebView 59.0	Android 7.1.2
+AFTMM	Chrome Mobile WebView 70.0	Android 7.1.2
+AFTN	Chrome Mobile WebView 70.0	Android 7.1.2
+KFKAWI	Chrome Mobile WebView 59.0	Android 7.1.2
 Kindle	Amazon Silk 76.3	Android 7.1.2
 Kindle	Amazon Silk 76.3	Android 7.1.2
 LG-SP200	Chrome Mobile 75.0	Android 7.1.2
 LG-SP200	Chrome Mobile 76.0	Android 7.1.2
-Other	Chrome Mobile 76.0	Android 7.1.2
-Other	Chrome Mobile 76.0	Android 7.1.2
+LM-X210(G)	Chrome Mobile 76.0	Android 7.1.2
+LM-X210	Chrome Mobile 76.0	Android 7.1.2
 RCT6973W43R	Chrome 77.0	Android 7.1.2
 XiaoMi Redmi 4	Chrome Mobile 77.0	Android 7.1.2
-Other	Chrome Mobile WebView 76.0	Android 8.0.0
+Generic Smartphone	Chrome Mobile WebView 76.0	Android 8.0.0
 Asus Z01FD	Chrome Mobile 77.0	Android 8.0.0
 Huawei AUM-L29	Chrome Mobile 77.0	Android 8.0.0
-Other	Chrome Mobile WebView 77.0	Android 8.0.0
-Other	Chrome 77.0	Android 8.0.0
-Other	Chrome Mobile 77.0	Android 8.0.0
-Other	Chrome Mobile 77.0	Android 8.0.0
+BRAVIA 4K GB	Chrome Mobile WebView 77.0	Android 8.0.0
+CMR-W09	Chrome 77.0	Android 8.0.0
+EVA-AL00	Chrome Mobile 77.0	Android 8.0.0
+G3223	Chrome Mobile 77.0	Android 8.0.0
 LG-H910	Chrome Mobile 77.0	Android 8.0.0
 LG-H931	Chrome Mobile 76.0	Android 8.0.0
 LG-H932	Chrome Mobile 77.0	Android 8.0.0
@@ -214,49 +214,49 @@ Samsung SM-N950U	Chrome Mobile 76.0	Android 8.0.0
 Samsung SM-N950U	Chrome Mobile 77.0	Android 8.0.0
 Samsung SM-N950U1	Chrome Mobile 77.0	Android 8.0.0
 Samsung SM-S367VL	Chrome Mobile 77.0	Android 8.0.0
-Other	Chrome Mobile 77.0	Android 8.0.0
-Other	Chrome Mobile 77.0	Android 8.0.0
-Other	Chrome Mobile 76.0	Android 8.0.0
-Other	Chrome Mobile 77.0	Android 8.0.0
-Other	Chrome Mobile 76.0	Android 8.0.0
-Other	Chrome Mobile 77.0	Android 8.0.0
-Other	Chrome Mobile 77.0	Android 8.1.0
-Other	Chrome Mobile 77.0	Android 8.1.0
-Other	Chrome Mobile 67.0	Android 8.1.0
-Other	Chrome Mobile 76.0	Android 8.1.0
+VS995	Chrome Mobile 77.0	Android 8.0.0
+XT1635-02	Chrome Mobile 77.0	Android 8.0.0
+moto e5 play	Chrome Mobile 76.0	Android 8.0.0
+moto e5 play	Chrome Mobile 77.0	Android 8.0.0
+moto e5 supra	Chrome Mobile 76.0	Android 8.0.0
+moto g(6)	Chrome Mobile 77.0	Android 8.0.0
+5041C	Chrome Mobile 77.0	Android 8.1.0
+6062W	Chrome Mobile 77.0	Android 8.1.0
+A502DL	Chrome Mobile 67.0	Android 8.1.0
+A502DL	Chrome Mobile 76.0	Android 8.1.0
 Huawei BKK-LX2	Chrome Mobile 76.0	Android 8.1.0
-Other	Chrome Mobile 70.0	Android 8.1.0
-Other	Chrome Mobile 77.0	Android 8.1.0
-Other	Chrome Mobile 64.0	Android 8.1.0
-Other	Chrome Mobile 77.0	Android 8.1.0
-Other	Chrome Mobile 77.0	Android 8.1.0
+C4	Chrome Mobile 70.0	Android 8.1.0
+3310A	Chrome Mobile 77.0	Android 8.1.0
+Infinix X604	Chrome Mobile 64.0	Android 8.1.0
+Joy 1	Chrome Mobile 77.0	Android 8.1.0
+LAVA LE9820	Chrome Mobile 77.0	Android 8.1.0
 LG-Q710AL	Chrome Mobile 77.0	Android 8.1.0
-Other	Chrome Mobile 77.0	Android 8.1.0
-Other	Facebook 235.0	Android 8.1.0
-Other	Chrome Mobile 70.0	Android 8.1.0
-Other	Chrome Mobile 76.0	Android 8.1.0
-Other	Chrome Mobile 76.0	Android 8.1.0
-Other	Chrome Mobile 77.0	Android 8.1.0
-Other	Chrome Mobile 77.0	Android 8.1.0
-Other	UC Browser 11.6	Android 8.1.0
-Other	Chrome Mobile 70.0	Android 8.1.0
-Other	Chrome Mobile 72.0	Android 8.1.0
-Other	Chrome Mobile 77.0	Android 8.1.0
-Other	Chrome Mobile 77.0	Android 8.1.0
-Other	Chrome Mobile 70.0	Android 8.1.0
-Other	Chrome Mobile 76.0	Android 8.1.0
-Other	Chrome Mobile WebView 77.0	Android 8.1.0
-Other	Chrome Mobile 70.0	Android 8.1.0
-Other	Chrome Mobile 76.0	Android 8.1.0
-Other	Chrome Mobile 77.0	Android 8.1.0
-Other	Chrome Mobile 68.0	Android 8.1.0
-Other	Chrome Mobile 76.0	Android 8.1.0
-Other	Chrome Mobile 77.0	Android 8.1.0
-Other	Chrome Mobile 77.0	Android 8.1.0
+LM-Q610(FGN)	Chrome Mobile 77.0	Android 8.1.0
+LM-Q710(FGN)	Facebook 235.0	Android 8.1.0
+LM-Q710(FGN)	Chrome Mobile 70.0	Android 8.1.0
+LM-Q710(FGN)	Chrome Mobile 76.0	Android 8.1.0
+LM-Q710(FGN)	Chrome Mobile 76.0	Android 8.1.0
+LM-Q710(FGN)	Chrome Mobile 77.0	Android 8.1.0
+LM-V405	Chrome Mobile 77.0	Android 8.1.0
+LM-X210(G)	UC Browser 11.6	Android 8.1.0
+LM-X210(G)	Chrome Mobile 70.0	Android 8.1.0
+LM-X210(G)	Chrome Mobile 72.0	Android 8.1.0
+LM-X210(G)	Chrome Mobile 77.0	Android 8.1.0
+LM-X212(G)	Chrome Mobile 77.0	Android 8.1.0
+LM-X220	Chrome Mobile 70.0	Android 8.1.0
+LM-X220	Chrome Mobile 76.0	Android 8.1.0
+LM-X220PM	Chrome Mobile WebView 77.0	Android 8.1.0
+LM-X410(FG)	Chrome Mobile 70.0	Android 8.1.0
+LM-X410(FG)	Chrome Mobile 76.0	Android 8.1.0
+LM-X410(FG)	Chrome Mobile 77.0	Android 8.1.0
+LM-X410.FGN	Chrome Mobile 68.0	Android 8.1.0
+LML414DL	Chrome Mobile 76.0	Android 8.1.0
+LML713DL	Chrome Mobile 77.0	Android 8.1.0
+Moto G (5S) Plus	Chrome Mobile 77.0	Android 8.1.0
 HTC One	Chrome Mobile WebView 70.0	Android 8.1.0
 RCT6873W42BMF8KC	Chrome Mobile 77.0	Android 8.1.0
-Other	Chrome Mobile 67.0	Android 8.1.0
-Other	Chrome Mobile 76.0	Android 8.1.0
+REVVL 2	Chrome Mobile 67.0	Android 8.1.0
+REVVL 2	Chrome Mobile 76.0	Android 8.1.0
 Samsung SM-J727T	Samsung Internet 10.1	Android 8.1.0
 Samsung SM-J727T1	Samsung Internet 9.4	Android 8.1.0
 Samsung SM-J727T1	Samsung Internet 10.1	Android 8.1.0
@@ -274,54 +274,54 @@ Samsung SM-J727T1	Chrome Mobile 77.0	Android 8.1.0
 Samsung SM-J727T1	Chrome Mobile 77.0	Android 8.1.0
 Samsung SM-J727V	Chrome Mobile 70.0	Android 8.1.0
 Samsung SM-J727V	Chrome Mobile 77.0	Android 8.1.0
-Other	Chrome 77.0	Android 8.1.0
-Other	Chrome 75.0	Android 8.1.0
-Other	Edge Mobile 42.0	Android 8.1.0
-Other	Chrome 76.0	Android 8.1.0
-Other	Chrome 76.0	Android 8.1.0
-Other	Chrome 77.0	Android 8.1.0
+SM-P580	Chrome 77.0	Android 8.1.0
+SM-T380	Chrome 75.0	Android 8.1.0
+SM-T580	Edge Mobile 42.0	Android 8.1.0
+SM-T580	Chrome 76.0	Android 8.1.0
+SM-T580	Chrome 76.0	Android 8.1.0
+SM-T580	Chrome 77.0	Android 8.1.0
 Samsung SM-T837T	Chrome 77.0	Android 8.1.0
-Other	Facebook 239.0	Android 8.1.0
-Other	Chrome Mobile 75.0	Android 8.1.0
-Other	Chrome Mobile 68.0	Android 8.1.0
-Other	Chrome Mobile 76.0	Android 8.1.0
-Other	Chrome Mobile 77.0	Android 8.1.0
-Other	DuckDuckGo Mobile 5.0	Android 9.0.0
-Other	Chrome Mobile 70.0	Android 9.0.0
-Other	Facebook 236.0	Android 9.0.0
-Other	Chrome Mobile 77.0	Android 9.0.0
+TECNO CF8	Facebook 239.0	Android 8.1.0
+V1818CA	Chrome Mobile 75.0	Android 8.1.0
+meizu C9	Chrome Mobile 68.0	Android 8.1.0
+vivo 1724	Chrome Mobile 76.0	Android 8.1.0
+vivo 1814	Chrome Mobile 77.0	Android 8.1.0
+Generic Smartphone	DuckDuckGo Mobile 5.0	Android 9.0.0
+1825	Chrome Mobile 70.0	Android 9.0.0
+ANE-LX2	Facebook 236.0	Android 9.0.0
+BLA-A09	Chrome Mobile 77.0	Android 9.0.0
 Huawei CLT-L04	Chrome Mobile 77.0	Android 9.0.0
 Oppo CPH1911	Facebook 239.0	Android 9.0.0
 Oppo CPH1923	Chrome Mobile WebView 76.0	Android 9.0.0
 Huawei ELE-L29	Chrome Mobile 77.0	Android 9.0.0
-Other	Chrome Mobile 77.0	Android 9.0.0
-Other	Chrome Mobile 76.0	Android 9.0.0
-Other	Chrome Mobile 77.0	Android 9.0.0
+G8142	Chrome Mobile 77.0	Android 9.0.0
+GM1911	Chrome Mobile 76.0	Android 9.0.0
+GM1917	Chrome Mobile 77.0	Android 9.0.0
 Huawei INE-LX2	Chrome Mobile 76.0	Android 9.0.0
-Other	Chrome Mobile WebView 77.0	Android 9.0.0
-Other	Chrome Mobile 77.0	Android 9.0.0
-Other	Chrome Mobile WebView 77.0	Android 9.0.0
-Other	Chrome Mobile 76.0	Android 9.0.0
-Other	Chrome Mobile 77.0	Android 9.0.0
-Other	Chrome Mobile 72.0	Android 9.0.0
-Other	Chrome Mobile 77.0	Android 9.0.0
-Other	Chrome Mobile 77.0	Android 9.0.0
+LM-G710	Chrome Mobile WebView 77.0	Android 9.0.0
+LM-Q720	Chrome Mobile 77.0	Android 9.0.0
+LM-V405	Chrome Mobile WebView 77.0	Android 9.0.0
+LM-V405	Chrome Mobile 76.0	Android 9.0.0
+LM-V500N	Chrome Mobile 77.0	Android 9.0.0
+LM-X420	Chrome Mobile 72.0	Android 9.0.0
+LM-X420	Chrome Mobile 77.0	Android 9.0.0
+MAR-LX1A	Chrome Mobile 77.0	Android 9.0.0
 XiaoMi MI 9	Chrome Mobile 77.0	Android 9.0.0
 XiaoMi Mi A2	Chrome Mobile 77.0	Android 9.0.0
-Other	Chrome Mobile 77.0	Android 9.0.0
+Moto Z (2)	Chrome Mobile 77.0	Android 9.0.0
 Nokia 6	Chrome Mobile 77.0	Android 9.0.0
 OnePlus ONEPLUS A6000	Chrome Mobile 77.0	Android 9.0.0
 OnePlus ONEPLUS A6003	Chrome Mobile 77.0	Android 9.0.0
 OnePlus ONEPLUS A6013	Chrome Mobile WebView 77.0	Android 9.0.0
 OnePlus ONEPLUS A6013	Chrome Mobile 74.0	Android 9.0.0
 OnePlus ONEPLUS A6013	Chrome Mobile 77.0	Android 9.0.0
-Other	Facebook 235.0	Android 9.0.0
-Other	Chrome Mobile 77.0	Android 9.0.0
-Other	Chrome Mobile WebView 77.0	Android 9.0.0
-Other	Chrome Mobile 76.0	Android 9.0.0
-Other	Chrome Mobile 77.0	Android 9.0.0
-Other	Chrome Mobile 77.0	Android 9.0.0
-Other	Chrome Mobile 73.0	Android 9.0.0
+PAR-AL00	Facebook 235.0	Android 9.0.0
+Pixel 2 XL	Chrome Mobile 77.0	Android 9.0.0
+Pixel 3	Chrome Mobile WebView 77.0	Android 9.0.0
+Pixel 3	Chrome Mobile 76.0	Android 9.0.0
+Pixel 3	Chrome Mobile 77.0	Android 9.0.0
+Pixel 3a XL	Chrome Mobile 77.0	Android 9.0.0
+REVVLRY 	Chrome Mobile 73.0	Android 9.0.0
 Oppo RMX1801	Chrome Mobile 75.0	Android 9.0.0
 XiaoMi Redmi 7	Chrome Mobile 77.0	Android 9.0.0
 XiaoMi Redmi Note 7	Chrome Mobile 76.0	Android 9.0.0
@@ -353,7 +353,7 @@ Samsung SM-N975U	Samsung Internet 10.1	Android 9.0.0
 Samsung SM-N975U1	Samsung Internet 10.1	Android 9.0.0
 Samsung SM-T510	Samsung Internet 10.1	Android 9.0.0
 Samsung SM-T720	Samsung Internet 10.1	Android 9.0.0
-Other	Chrome Mobile WebView 77.0	Android 9.0.0
+SHIELD Android TV	Chrome Mobile WebView 77.0	Android 9.0.0
 Samsung SM-A102U	Chrome Mobile 72.0	Android 9.0.0
 Samsung SM-A102U	Chrome Mobile 77.0	Android 9.0.0
 Samsung SM-A105M	Facebook 237.0	Android 9.0.0
@@ -407,7 +407,7 @@ Samsung SM-J600G	Facebook 238.0	Android 9.0.0
 Samsung SM-J730F	Chrome Mobile 77.0	Android 9.0.0
 Samsung SM-J737A	Chrome Mobile WebView 77.0	Android 9.0.0
 Samsung SM-J737A	Chrome Mobile 74.0	Android 9.0.0
-Samsung SM-J737V	Pinterest 75.0	Android 9.0.0
+Samsung SM-J737V	Pinterest 0.0	Android 9.0.0
 Samsung SM-J737V	Chrome Mobile 77.0	Android 9.0.0
 Samsung SM-J810M	Chrome Mobile 77.0	Android 9.0.0
 Samsung SM-N950U	Facebook 240.0	Android 9.0.0
@@ -430,28 +430,28 @@ Samsung SM-N976V	Facebook 240.0	Android 9.0.0
 Samsung SM-S367VL	Chrome Mobile 77.0	Android 9.0.0
 Samsung SM-S767VL	Chrome Mobile 76.0	Android 9.0.0
 Samsung SM-T597P	Chrome 77.0	Android 9.0.0
-Other	Chrome 77.0	Android 9.0.0
-Other	Chrome Mobile 77.0	Android 9.0.0
+SM-T720	Chrome 77.0	Android 9.0.0
+TECNO KC8	Chrome Mobile 77.0	Android 9.0.0
 Huawei VOG-L29	Chrome Mobile 77.0	Android 9.0.0
-Other	Chrome Mobile 74.0	Android 9.0.0
-Other	Chrome Mobile WebView 77.0	Android 9.0.0
-Other	Chrome Mobile 77.0	Android 9.0.0
-Other	Facebook 235.0	Android 9.0.0
-Other	Chrome Mobile 70.0	Android 9.0.0
-Other	Chrome Mobile 75.0	Android 9.0.0
-Other	Chrome Mobile 77.0	Android 9.0.0
-Other	Chrome Mobile 73.0	Android 9.0.0
-Other	Chrome Mobile 77.0	Android 9.0.0
+cp3705A	Chrome Mobile 74.0	Android 9.0.0
+moto g(6)	Chrome Mobile WebView 77.0	Android 9.0.0
+moto g(6) play	Chrome Mobile 77.0	Android 9.0.0
+moto g(7) play	Facebook 235.0	Android 9.0.0
+moto g(7) play	Chrome Mobile 70.0	Android 9.0.0
+moto g(7) power	Chrome Mobile 75.0	Android 9.0.0
+moto g(7) power	Chrome Mobile 77.0	Android 9.0.0
+moto z4	Chrome Mobile 73.0	Android 9.0.0
+moto z4	Chrome Mobile 77.0	Android 9.0.0
 Samsung GT-P3113 	Android 4.1	Android 4.1.1
 Samsung GT-I8160 	Android 4.1	Android 4.1.2
-Other	Android 4.2	Android 4.2.2
+Asus Nexus 7	Android 4.2	Android 4.2.2
 Samsung SM-E500H	Android 4.4	Android 4.4.0
-Other	Chrome Mobile WebView 43.0	Android 6.0.1
+LGMS550	Chrome Mobile WebView 43.0	Android 6.0.1
 Samsung SM-J737T1	Chrome Mobile WebView 43.0	Android 6.0.1
-Other	Opera Mobile 5.3	Android 7.0.0
+TECNO CA6	Opera Mobile 5.3	Android 7.0.0
 XiaoMi Redmi 5A	MiuiBrowser 9.5	Android 7.1.2
 Oppo CPH1911	Chrome Mobile WebView 70.0	Android 9.0.0
-Other	Opera Mobile 44.1	Android 9.0.0
+vivo 1904	Opera Mobile 44.1	Android 9.0.0
 Mac	Firefox 68.0	Mac OS X 10.11.0
 Mac	Firefox 69.0	Mac OS X 10.13.0
 Mac	Firefox 67.0	Mac OS X 10.14.0
@@ -514,10 +514,10 @@ Mac	Chrome 65.0	Mac OS X 10.9.5
 Mac	Chrome 66.0	Mac OS X 10.9.5
 Mac	Chrome 67.0	Mac OS X 10.9.5
 PlayStation 4	Apple Mail 605.1	Other 0.0.0
-Other	Safari 3.0	Tizen 3.0.0
-Other	Samsung Internet 2.0	Tizen 3.0.0
-Other	Samsung Internet 2.1	Tizen 4.0.0
-Other	Samsung Internet 2.2	Tizen 5.0.0
+Samsung SMART-TV	Safari 3.0	Tizen 3.0.0
+Samsung SMART-TV	Samsung Internet 2.0	Tizen 3.0.0
+Samsung SMART-TV	Samsung Internet 2.1	Tizen 4.0.0
+Samsung SMART-TV	Samsung Internet 2.2	Tizen 5.0.0
 Other	Edge 17.17134	Windows 10.0.0
 Other	Edge 18.17763	Windows 10.0.0
 Other	Chrome 77.0	Windows 10.0.0
@@ -622,7 +622,7 @@ Other	Firefox 67.0	Ubuntu 0.0.0
 iPad	Google 22.0	iOS 10.3.3
 iPad	Chrome Mobile iOS 71.0	iOS 10.3.3
 iPad	Firefox iOS 14.0	iOS 10.3.3
-iPad	Mobile Safari UI/WKWebView 603.3	iOS 10.3.3
+iPad	Mobile Safari UI/WKWebView 0.0	iOS 10.3.3
 iPad	Facebook 240.0	iOS 10.3.3
 iPad	Mobile Safari 10.0	iOS 10.3.3
 iPad	Mobile Safari 10.0	iOS 10.3.4
@@ -633,25 +633,25 @@ iPad	Mobile Safari 11.0	iOS 11.2.2
 iPad	Mobile Safari 11.0	iOS 11.2.6
 iPad	Mobile Safari 11.0	iOS 11.3.0
 iPad	Mobile Safari 11.0	iOS 11.4.0
-iPad	Mobile Safari UI/WKWebView 605.1	iOS 11.4.1
+iPad	Mobile Safari UI/WKWebView 0.0	iOS 11.4.1
 iPad	Mobile Safari 11.0	iOS 11.4.1
 iPad	Google 83.0	iOS 12.0.0
 iPad	Mobile Safari 12.0	iOS 12.0.0
 iPad	Chrome Mobile iOS 75.0	iOS 12.1.0
 iPad	Chrome Mobile iOS 76.0	iOS 12.1.0
-iPad	Mobile Safari UI/WKWebView 605.1	iOS 12.1.0
+iPad	Mobile Safari UI/WKWebView 0.0	iOS 12.1.0
 iPad	Mobile Safari 12.0	iOS 12.1.0
 iPad	Mobile Safari 12.0	iOS 12.1.1
 iPad	Google 48.0	iOS 12.1.4
-iPad	Mobile Safari UI/WKWebView 605.1	iOS 12.1.4
+iPad	Mobile Safari UI/WKWebView 0.0	iOS 12.1.4
 iPad	Mobile Safari 12.0	iOS 12.1.4
 iPad	Chrome Mobile iOS 76.0	iOS 12.2.0
-iPad	Mobile Safari UI/WKWebView 605.1	iOS 12.2.0
+iPad	Mobile Safari UI/WKWebView 0.0	iOS 12.2.0
 iPad	Mobile Safari 12.1	iOS 12.2.0
 iPad	Chrome Mobile iOS 77.0	iOS 12.3.0
 iPad	Google 83.0	iOS 12.3.0
 iPad	Mobile Safari 12.1	iOS 12.3.0
-iPad	Mobile Safari UI/WKWebView 605.1	iOS 12.3.1
+iPad	Mobile Safari UI/WKWebView 0.0	iOS 12.3.1
 iPad	Mobile Safari 12.1	iOS 12.3.1
 iPad	Chrome Mobile iOS 76.0	iOS 12.4.0
 iPad	Chrome Mobile iOS 76.0	iOS 12.4.0
@@ -660,15 +660,15 @@ iPad	Chrome Mobile iOS 77.0	iOS 12.4.0
 iPad	Chrome Mobile iOS 77.0	iOS 12.4.0
 iPad	Google 74.0	iOS 12.4.0
 iPad	Google 83.0	iOS 12.4.0
-iPad	Mobile Safari UI/WKWebView 605.1	iOS 12.4.0
+iPad	Mobile Safari UI/WKWebView 0.0	iOS 12.4.0
 iPad	Mobile Safari 12.1	iOS 12.4.0
 iPad	Chrome Mobile iOS 67.0	iOS 12.4.1
 iPad	Firefox iOS 19.0	iOS 12.4.1
-iPad	Mobile Safari UI/WKWebView 605.1	iOS 12.4.1
-iPad	Facebook 605.1	iOS 12.4.1
-iPad	Facebook 605.1	iOS 12.4.1
-iPad	Facebook 605.1	iOS 12.4.1
-iPad	Facebook 605.1	iOS 12.4.1
+iPad	Mobile Safari UI/WKWebView 0.0	iOS 12.4.1
+iPad	Facebook 0.0	iOS 12.4.1
+iPad	Facebook 0.0	iOS 12.4.1
+iPad	Facebook 0.0	iOS 12.4.1
+iPad	Facebook 0.0	iOS 12.4.1
 iPad	Mobile Safari 12.1	iOS 12.4.1
 iPad	Mobile Safari 6.0	iOS 6.1.3
 iPad	Mobile Safari 8.0	iOS 8.0.0
@@ -677,7 +677,7 @@ iPad	Google 23.1	iOS 8.4.0
 iPad	Mobile Safari 9.0	iOS 9.3.2
 iPad	Mobile Safari 9.0	iOS 9.3.5
 iPhone	Mobile Safari 10.0	iOS 10.2.0
-iPhone	Facebook 603.3	iOS 10.3.3
+iPhone	Facebook 0.0	iOS 10.3.3
 iPhone	Google 68.0	iOS 10.3.4
 iPhone	Mobile Safari 10.0	iOS 10.3.4
 iPhone	Mobile Safari 11.0	iOS 11.0.3
@@ -686,7 +686,7 @@ iPhone	Mobile Safari 11.0	iOS 11.1.2
 iPhone	Mobile Safari 11.0	iOS 11.2.1
 iPhone	Facebook 207.0	iOS 11.2.6
 iPhone	Chrome Mobile iOS 76.0	iOS 11.3.0
-iPhone	Facebook 605.1	iOS 11.3.0
+iPhone	Facebook 0.0	iOS 11.3.0
 iPhone	Mobile Safari 11.0	iOS 11.3.0
 iPhone	Google 83.0	iOS 11.4.0
 iPhone	Mobile Safari 11.0	iOS 11.4.0
@@ -696,7 +696,7 @@ iPhone	Mobile Safari 12.0	iOS 12.0.0
 iPhone	Mobile Safari 12.0	iOS 12.1.0
 iPhone	Mobile Safari 12.0	iOS 12.1.1
 iPhone	Google 74.1	iOS 12.1.2
-iPhone	Facebook 605.1	iOS 12.1.2
+iPhone	Facebook 0.0	iOS 12.1.2
 iPhone	Mobile Safari 12.0	iOS 12.1.2
 iPhone	Mobile Safari 12.0	iOS 12.1.3
 iPhone	Google 74.1	iOS 12.1.4
@@ -704,18 +704,18 @@ iPhone	Mobile Safari 12.0	iOS 12.1.4
 iPhone	Chrome Mobile iOS 72.0	iOS 12.2.0
 iPhone	Chrome Mobile iOS 76.0	iOS 12.2.0
 iPhone	Chrome Mobile iOS 77.0	iOS 12.2.0
-iPhone	Facebook 605.1	iOS 12.2.0
-iPhone	Facebook 605.1	iOS 12.2.0
+iPhone	Facebook 0.0	iOS 12.2.0
+iPhone	Facebook 0.0	iOS 12.2.0
 iPhone	Mobile Safari 12.1	iOS 12.2.0
 iPhone	Chrome Mobile iOS 77.0	iOS 12.3.0
 iPhone	Google 83.0	iOS 12.3.0
 iPhone	Mobile Safari 12.1	iOS 12.3.0
 iPhone	Google 79.0	iOS 12.3.1
-iPhone	Mobile Safari UI/WKWebView 605.1	iOS 12.3.1
-iPhone	DuckDuckGo Mobile 7.1	iOS 12.3.1
-iPhone	Facebook 605.1	iOS 12.3.1
-iPhone	Facebook 605.1	iOS 12.3.1
-iPhone	Facebook 605.1	iOS 12.3.1
+iPhone	Mobile Safari UI/WKWebView 0.0	iOS 12.3.1
+iPhone	DuckDuckGo Mobile 7.0	iOS 12.3.1
+iPhone	Facebook 0.0	iOS 12.3.1
+iPhone	Facebook 0.0	iOS 12.3.1
+iPhone	Facebook 0.0	iOS 12.3.1
 iPhone	Mobile Safari 12.1	iOS 12.3.1
 iPhone	Mobile Safari 12.1	iOS 12.3.2
 iPhone	Chrome Mobile iOS 69.0	iOS 12.4.0
@@ -727,67 +727,67 @@ iPhone	Chrome Mobile iOS 77.0	iOS 12.4.0
 iPhone	Google 81.0	iOS 12.4.0
 iPhone	Google 82.1	iOS 12.4.0
 iPhone	Google 83.0	iOS 12.4.0
-iPhone	Facebook 605.1	iOS 12.4.0
-iPhone	Facebook 605.1	iOS 12.4.0
-iPhone	Facebook 605.1	iOS 12.4.0
-iPhone	Facebook 605.1	iOS 12.4.0
+iPhone	Facebook 0.0	iOS 12.4.0
+iPhone	Facebook 0.0	iOS 12.4.0
+iPhone	Facebook 0.0	iOS 12.4.0
+iPhone	Facebook 0.0	iOS 12.4.0
 iPhone	Mobile Safari 12.1	iOS 12.4.0
 iPhone	Google 74.1	iOS 12.4.1
-iPhone	Mobile Safari UI/WKWebView 605.1	iOS 12.4.1
+iPhone	Mobile Safari UI/WKWebView 0.0	iOS 12.4.1
 iPhone	Instagram 89.0	iOS 12.4.1
 iPhone	Facebook 240.0	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
-iPhone	Facebook 605.1	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
+iPhone	Facebook 0.0	iOS 12.4.1
 iPhone	Mobile Safari 12.1	iOS 12.4.1
 iPhone	Mobile Safari 12.4	iOS 12.4.1
-iPhone	Mobile Safari UI/WKWebView 605.1	iOS 12.4.2
+iPhone	Mobile Safari UI/WKWebView 0.0	iOS 12.4.2
 iPhone	Mobile Safari 12.1	iOS 12.4.2
 iPhone	Chrome Mobile iOS 77.0	iOS 13.0.0
-iPhone	Facebook 605.1	iOS 13.0.0
-iPhone	Facebook 605.1	iOS 13.0.0
-iPhone	Facebook 605.1	iOS 13.0.0
-iPhone	Facebook 605.1	iOS 13.0.0
-iPhone	Facebook 605.1	iOS 13.0.0
-iPhone	Facebook 605.1	iOS 13.0.0
+iPhone	Facebook 0.0	iOS 13.0.0
+iPhone	Facebook 0.0	iOS 13.0.0
+iPhone	Facebook 0.0	iOS 13.0.0
+iPhone	Facebook 0.0	iOS 13.0.0
+iPhone	Facebook 0.0	iOS 13.0.0
+iPhone	Facebook 0.0	iOS 13.0.0
 iPhone	Mobile Safari 13.0	iOS 13.0.0
 iPhone	Chrome Mobile iOS 76.0	iOS 13.1.0
 iPhone	Chrome Mobile iOS 77.0	iOS 13.1.0
 iPhone	Chrome Mobile iOS 77.0	iOS 13.1.0
 iPhone	Firefox iOS 8.1	iOS 13.1.0
 iPhone	Google 83.0	iOS 13.1.0
-iPhone	Mobile Safari UI/WKWebView 605.1	iOS 13.1.0
-iPhone	DuckDuckGo Mobile 7.1	iOS 13.1.0
-iPhone	Facebook 605.1	iOS 13.1.0
-iPhone	Facebook 605.1	iOS 13.1.0
-iPhone	Facebook 605.1	iOS 13.1.0
-iPhone	Facebook 605.1	iOS 13.1.0
-iPhone	Facebook 605.1	iOS 13.1.0
+iPhone	Mobile Safari UI/WKWebView 0.0	iOS 13.1.0
+iPhone	DuckDuckGo Mobile 7.0	iOS 13.1.0
+iPhone	Facebook 0.0	iOS 13.1.0
+iPhone	Facebook 0.0	iOS 13.1.0
+iPhone	Facebook 0.0	iOS 13.1.0
+iPhone	Facebook 0.0	iOS 13.1.0
+iPhone	Facebook 0.0	iOS 13.1.0
 iPhone	Mobile Safari 13.0	iOS 13.1.0
-iPhone	Mobile Safari UI/WKWebView 605.1	iOS 13.1.1
-iPhone	Facebook 605.1	iOS 13.1.1
-iPhone	Facebook 605.1	iOS 13.1.1
-iPhone	Facebook 605.1	iOS 13.1.1
-iPhone	Facebook 605.1	iOS 13.1.1
+iPhone	Mobile Safari UI/WKWebView 0.0	iOS 13.1.1
+iPhone	Facebook 0.0	iOS 13.1.1
+iPhone	Facebook 0.0	iOS 13.1.1
+iPhone	Facebook 0.0	iOS 13.1.1
+iPhone	Facebook 0.0	iOS 13.1.1
 iPhone	Mobile Safari 13.0	iOS 13.1.1
-iPhone	Mobile Safari UI/WKWebView 605.1	iOS 13.1.2
-iPhone	Facebook 605.1	iOS 13.1.2
+iPhone	Mobile Safari UI/WKWebView 0.0	iOS 13.1.2
+iPhone	Facebook 0.0	iOS 13.1.2
 iPhone	Mobile Safari 13.0	iOS 13.1.2

From 9f26e169633edf1a3bf28e0e85d39719b7127709 Mon Sep 17 00:00:00 2001
From: Anton Popov <anton@clickhouse.com>
Date: Wed, 1 Feb 2023 15:31:06 +0000
Subject: [PATCH 30/79] loose the assertion

---
 src/Storages/MergeTree/MergeTreeDataPartWriterWide.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/Storages/MergeTree/MergeTreeDataPartWriterWide.cpp b/src/Storages/MergeTree/MergeTreeDataPartWriterWide.cpp
index cce459c1ba8..cf19f958b4c 100644
--- a/src/Storages/MergeTree/MergeTreeDataPartWriterWide.cpp
+++ b/src/Storages/MergeTree/MergeTreeDataPartWriterWide.cpp
@@ -484,7 +484,7 @@ void MergeTreeDataPartWriterWide::validateColumnOfFixedSize(const NameAndTypePai
                             column->size(), mark_num, index_granularity.getMarksCount(), index_granularity_rows);
         }
 
-        if (index_granularity_rows > data_part->index_granularity_info.fixed_index_granularity)
+        if (!settings.blocks_are_granules_size && index_granularity_rows > data_part->index_granularity_info.fixed_index_granularity)
         {
             throw Exception(ErrorCodes::LOGICAL_ERROR,
                             "Mark #{} has {} rows, but max fixed granularity is {}, index granularity size {}",
@@ -493,6 +493,7 @@ void MergeTreeDataPartWriterWide::validateColumnOfFixedSize(const NameAndTypePai
         }
 
         if (index_granularity_rows != index_granularity.getMarkRows(mark_num))
+        {
             throw Exception(
                             ErrorCodes::LOGICAL_ERROR,
                             "Incorrect mark rows for part {} for mark #{}"
@@ -501,6 +502,7 @@ void MergeTreeDataPartWriterWide::validateColumnOfFixedSize(const NameAndTypePai
                             mark_num, offset_in_compressed_file, offset_in_decompressed_block,
                             index_granularity.getMarkRows(mark_num), index_granularity_rows,
                             index_granularity.getMarksCount());
+        }
 
         auto column = type->createColumn();
 

From 7c416477ac9532d2822d0b8e057fc0322577a514 Mon Sep 17 00:00:00 2001
From: Sema Checherinda <Sema.Checherinda@clickhouse.com>
Date: Wed, 1 Feb 2023 17:22:49 +0100
Subject: [PATCH 31/79] do not run wal on remote disks

---
 src/Storages/MergeTree/MergeTreeData.cpp | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp
index b2e0c14489a..7b2b23c6e6b 100644
--- a/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/src/Storages/MergeTree/MergeTreeData.cpp
@@ -7541,7 +7541,19 @@ MergeTreeData::WriteAheadLogPtr MergeTreeData::getWriteAheadLog()
     if (!write_ahead_log)
     {
         auto reservation = reserveSpace(getSettings()->write_ahead_log_max_bytes);
-        write_ahead_log = std::make_shared<MergeTreeWriteAheadLog>(*this, reservation->getDisk());
+        for (auto disk: reservation->getDisks())
+        {
+            if (!disk->isRemote())
+            {
+                write_ahead_log = std::make_shared<MergeTreeWriteAheadLog>(*this, reservation->getDisk());
+                break;
+            }
+        }
+
+        if (!write_ahead_log)
+            throw Exception(
+                    ErrorCodes::NOT_IMPLEMENTED,
+                    "Can't store write ahead log in remote disk. It makes no sense.");
     }
 
     return write_ahead_log;

From 5b3054492ddad332393a73db547c301633afc1a9 Mon Sep 17 00:00:00 2001
From: Suzy Wang <suzy.wang@ibm.com>
Date: Wed, 1 Feb 2023 15:21:34 -0500
Subject: [PATCH 32/79] Update src/Interpreters/Aggregator.h

Co-authored-by: Yakov Olkhovskiy <99031427+yakov-olkhovskiy@users.noreply.github.com>
---
 src/Interpreters/Aggregator.h | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/Interpreters/Aggregator.h b/src/Interpreters/Aggregator.h
index 7dec8c9c8a4..3e65d220406 100644
--- a/src/Interpreters/Aggregator.h
+++ b/src/Interpreters/Aggregator.h
@@ -209,10 +209,13 @@ struct AggregationMethodOneNumber
     // Insert the key from the hash table into columns.
     static void insertKeyIntoColumns(const Key & key, std::vector<IColumn *> & key_columns, const Sizes & /*key_sizes*/)
     {
-        FieldType casted_key = static_cast<FieldType>(key);
-        const auto * key_holder = reinterpret_cast<const char *>(&casted_key);
+        static_assert(sizeof(FieldType) <= sizeof(Key));
+        const auto * key_holder = reinterpret_cast<const char *>(&key);
         auto * column = static_cast<ColumnVectorHelper *>(key_columns[0]);
-        column->insertRawData<sizeof(FieldType)>(key_holder);
+        if constexpr (sizeof(FieldType) < sizeof(Key) && std::endian::native == std::endian::big)
+            column->insertRawData<sizeof(FieldType)>(key_holder + (sizeof(Key) - sizeof(FieldType)));
+        else
+            column->insertRawData<sizeof(FieldType)>(key_holder);
     }
 };
 

From a2e43bc333645f3a437445b00393c3630495537a Mon Sep 17 00:00:00 2001
From: Han Fei <hanfei19910905@gmail.com>
Date: Thu, 2 Feb 2023 14:40:09 +0100
Subject: [PATCH 33/79] log for ci

---
 src/Dictionaries/RegExpTreeDictionary.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/Dictionaries/RegExpTreeDictionary.cpp b/src/Dictionaries/RegExpTreeDictionary.cpp
index 0cf7d579f96..5d8bb04623a 100644
--- a/src/Dictionaries/RegExpTreeDictionary.cpp
+++ b/src/Dictionaries/RegExpTreeDictionary.cpp
@@ -126,7 +126,7 @@ std::vector<StringPiece> createStringPieces(const String & value, int num_captur
                 }
                 int ref_num = value[i+1]-'0';
                 if (ref_num >= num_captures)
-                    LOG_DEBUG(logger,
+                    LOG_TRACE(logger,
                         "Reference Id {} in set string is invalid, the regexp {} only has {} capturing groups",
                         ref_num, regex, num_captures-1);
                 result.push_back(StringPiece(ref_num));
@@ -420,7 +420,7 @@ namespace
 {
     struct MatchContext
     {
-        std::unordered_set<UInt64> matched_idx_set;
+        std::set<UInt64> matched_idx_set;
         std::vector<std::pair<UInt64, UInt64>> matched_idx_sorted_list;
 
         const std::vector<UInt64> & regexp_ids ;
@@ -520,10 +520,11 @@ std::unordered_map<String, ColumnPtr> RegExpTreeDictionary::matchSearchAllIndice
             if (node_ptr->match(reinterpret_cast<const char *>(keys_data.data()) + offset, length))
             {
                 match_result.insertNodeID(node_ptr->id);
-                break;
             }
         }
 
+        LOG_TRACE(logger, "match string is {}, first matched id is {}, match number is {}", std::string(reinterpret_cast<const char *>(keys_data.data()) + offset, length), match_result.matched_idx_set.empty() ? -1 : *match_result.matched_idx_set.begin(), match_result.matched_idx_set.size());
+
         match_result.sort();
 
         // Walk through the regex tree util all attributes are set;

From a71ad718122e30d0890cf784e93c54c132b8d3cf Mon Sep 17 00:00:00 2001
From: MeenaRenganathan22 <Meena.Renganathan@ibm.com>
Date: Thu, 2 Feb 2023 10:26:34 -0500
Subject: [PATCH 34/79] Updating the libhdfs3 submoulde to point the branch
 HDSF_PowerPC

---
 .gitmodules | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.gitmodules b/.gitmodules
index b4673f113b7..d917d138932 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -58,7 +58,8 @@
 	url = https://github.com/apache/thrift
 [submodule "contrib/libhdfs3"]
 	path = contrib/libhdfs3
-	url = https://github.com/ClickHouse/libhdfs3
+	url = https://github.com/ClibMouse/libhdfs3.git
+        branch = HDFS_PowerPC
 [submodule "contrib/libxml2"]
 	path = contrib/libxml2
 	url = https://github.com/GNOME/libxml2

From 7435ba1e3d1ebbdea2f8c2486595ac16fdf10325 Mon Sep 17 00:00:00 2001
From: MeenaRenganathan22 <Meena.Renganathan@ibm.com>
Date: Thu, 2 Feb 2023 17:36:03 -0800
Subject: [PATCH 35/79] Updating the submodule and CMakeLists.txt

---
 contrib/libhdfs3                      | 2 +-
 contrib/libhdfs3-cmake/CMakeLists.txt | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/contrib/libhdfs3 b/contrib/libhdfs3
index f938c73b401..f3f4b9bc823 160000
--- a/contrib/libhdfs3
+++ b/contrib/libhdfs3
@@ -1 +1 @@
-Subproject commit f938c73b401967df45ae65bb791b601123aac5a4
+Subproject commit f3f4b9bc82356e0d027eb05bbd727988501ee6c2
diff --git a/contrib/libhdfs3-cmake/CMakeLists.txt b/contrib/libhdfs3-cmake/CMakeLists.txt
index f9c59f0f016..b270f2090c3 100644
--- a/contrib/libhdfs3-cmake/CMakeLists.txt
+++ b/contrib/libhdfs3-cmake/CMakeLists.txt
@@ -47,7 +47,6 @@ set(SRCS
     "${HDFS3_SOURCE_DIR}/network/TcpSocket.cpp"
     "${HDFS3_SOURCE_DIR}/network/DomainSocket.cpp"
     "${HDFS3_SOURCE_DIR}/network/BufferedSocketReader.cpp"
-    "${HDFS3_SOURCE_DIR}/client/DataReader.cpp"
     "${HDFS3_SOURCE_DIR}/client/ReadShortCircuitInfo.cpp"
     "${HDFS3_SOURCE_DIR}/client/Pipeline.cpp"
     "${HDFS3_SOURCE_DIR}/client/Hdfs.cpp"

From 486c10bde1e405a09e9b0ef16f7b2a433358bcca Mon Sep 17 00:00:00 2001
From: kssenii <sumarokovakseniia@mail.ru>
Date: Fri, 3 Feb 2023 13:11:21 +0100
Subject: [PATCH 36/79] Fix named collections access

---
 src/Access/Common/AccessType.h                |  2 +-
 .../configs/users.d/users.xml                 |  3 -
 .../users.d/users_no_default_access.xml       |  9 +++
 .../users.d/users_no_default_access2.xml      | 10 +++
 .../test_named_collections/test.py            | 67 ++++++++++++++++++-
 5 files changed, 85 insertions(+), 6 deletions(-)
 create mode 100644 tests/integration/test_named_collections/configs/users.d/users_no_default_access.xml
 create mode 100644 tests/integration/test_named_collections/configs/users.d/users_no_default_access2.xml

diff --git a/src/Access/Common/AccessType.h b/src/Access/Common/AccessType.h
index 366667410d5..8b8284f1185 100644
--- a/src/Access/Common/AccessType.h
+++ b/src/Access/Common/AccessType.h
@@ -134,7 +134,7 @@ enum class AccessType
     M(SHOW_QUOTAS, "SHOW CREATE QUOTA", GLOBAL, SHOW_ACCESS) \
     M(SHOW_SETTINGS_PROFILES, "SHOW PROFILES, SHOW CREATE SETTINGS PROFILE, SHOW CREATE PROFILE", GLOBAL, SHOW_ACCESS) \
     M(SHOW_ACCESS, "", GROUP, ACCESS_MANAGEMENT) \
-    M(SHOW_NAMED_COLLECTIONS, "SHOW NAMED COLLECTIONS", GROUP, ACCESS_MANAGEMENT) \
+    M(SHOW_NAMED_COLLECTIONS, "SHOW NAMED COLLECTIONS", GLOBAL, ACCESS_MANAGEMENT) \
     M(ACCESS_MANAGEMENT, "", GROUP, ALL) \
     \
     M(SYSTEM_SHUTDOWN, "SYSTEM KILL, SHUTDOWN", GLOBAL, SYSTEM) \
diff --git a/tests/integration/test_named_collections/configs/users.d/users.xml b/tests/integration/test_named_collections/configs/users.d/users.xml
index ee38baa3df9..fb5e2028d6e 100644
--- a/tests/integration/test_named_collections/configs/users.d/users.xml
+++ b/tests/integration/test_named_collections/configs/users.d/users.xml
@@ -2,9 +2,6 @@
     <users>
         <default>
             <password></password>
-            <networks>
-                <ip>::/0</ip>
-            </networks>
             <profile>default</profile>
             <quota>default</quota>
             <show_named_collections>1</show_named_collections>
diff --git a/tests/integration/test_named_collections/configs/users.d/users_no_default_access.xml b/tests/integration/test_named_collections/configs/users.d/users_no_default_access.xml
new file mode 100644
index 00000000000..b8f38f04ca9
--- /dev/null
+++ b/tests/integration/test_named_collections/configs/users.d/users_no_default_access.xml
@@ -0,0 +1,9 @@
+<clickhouse>
+    <users>
+        <default>
+            <password></password>
+            <profile>default</profile>
+            <quota>default</quota>
+        </default>
+    </users>
+</clickhouse>
diff --git a/tests/integration/test_named_collections/configs/users.d/users_no_default_access2.xml b/tests/integration/test_named_collections/configs/users.d/users_no_default_access2.xml
new file mode 100644
index 00000000000..83dc04f03aa
--- /dev/null
+++ b/tests/integration/test_named_collections/configs/users.d/users_no_default_access2.xml
@@ -0,0 +1,10 @@
+<clickhouse>
+    <users>
+        <default>
+            <password></password>
+            <profile>default</profile>
+            <quota>default</quota>
+            <access_management>1</access_management>
+        </default>
+    </users>
+</clickhouse>
diff --git a/tests/integration/test_named_collections/test.py b/tests/integration/test_named_collections/test.py
index ce5c8aaa62e..1b853fadaff 100644
--- a/tests/integration/test_named_collections/test.py
+++ b/tests/integration/test_named_collections/test.py
@@ -24,6 +24,26 @@ def cluster():
             ],
             stay_alive=True,
         )
+        cluster.add_instance(
+            "node_no_default_access",
+            main_configs=[
+                "configs/config.d/named_collections.xml",
+            ],
+            user_configs=[
+                "configs/users.d/users_no_default_access.xml",
+            ],
+            stay_alive=True,
+        )
+        cluster.add_instance(
+            "node_no_default_access_but_with_access_management",
+            main_configs=[
+                "configs/config.d/named_collections.xml",
+            ],
+            user_configs=[
+                "configs/users.d/users_no_default_access2.xml",
+            ],
+            stay_alive=True,
+        )
 
         logging.info("Starting cluster...")
         cluster.start()
@@ -34,7 +54,7 @@ def cluster():
         cluster.shutdown()
 
 
-def replace_config(node, old, new):
+def replace_in_server_config(node, old, new):
     node.replace_in_config(
         "/etc/clickhouse-server/config.d/named_collections.xml",
         old,
@@ -42,6 +62,49 @@ def replace_config(node, old, new):
     )
 
 
+def replace_in_users_config(node, old, new):
+    node.replace_in_config(
+        "/etc/clickhouse-server/users.d/users.xml",
+        old,
+        new,
+    )
+
+
+def test_access(cluster):
+    node = cluster.instances["node_no_default_access"]
+    assert (
+        "DB::Exception: default: Not enough privileges. To execute this query it's necessary to have grant SHOW NAMED COLLECTIONS ON *.*"
+        in node.query_and_get_error("select count() from system.named_collections")
+    )
+    node = cluster.instances["node_no_default_access_but_with_access_management"]
+    assert (
+        "DB::Exception: default: Not enough privileges. To execute this query it's necessary to have grant SHOW NAMED COLLECTIONS ON *.*"
+        in node.query_and_get_error("select count() from system.named_collections")
+    )
+
+    node = cluster.instances["node"]
+    assert int(node.query("select count() from system.named_collections")) > 0
+    replace_in_users_config(
+        node, "show_named_collections>1", "show_named_collections>0"
+    )
+    assert "show_named_collections>0" in node.exec_in_container(
+        ["bash", "-c", f"cat /etc/clickhouse-server/users.d/users.xml"]
+    )
+    node.restart_clickhouse()
+    assert (
+        "DB::Exception: default: Not enough privileges. To execute this query it's necessary to have grant SHOW NAMED COLLECTIONS ON *.*"
+        in node.query_and_get_error("select count() from system.named_collections")
+    )
+    replace_in_users_config(
+        node, "show_named_collections>0", "show_named_collections>1"
+    )
+    assert "show_named_collections>1" in node.exec_in_container(
+        ["bash", "-c", f"cat /etc/clickhouse-server/users.d/users.xml"]
+    )
+    node.restart_clickhouse()
+    assert int(node.query("select count() from system.named_collections")) > 0
+
+
 def test_config_reload(cluster):
     node = cluster.instances["node"]
     assert (
@@ -60,7 +123,7 @@ def test_config_reload(cluster):
         ).strip()
     )
 
-    replace_config(node, "value1", "value2")
+    replace_in_server_config(node, "value1", "value2")
     node.query("SYSTEM RELOAD CONFIG")
 
     assert (

From a356c64d9c229a6ec8962a07ad37f4f1902e6766 Mon Sep 17 00:00:00 2001
From: Sema Checherinda <Sema.Checherinda@clickhouse.com>
Date: Thu, 2 Feb 2023 14:37:08 +0100
Subject: [PATCH 37/79] add no-s3-storage to stateless tests with inmemory
 parts

---
 tests/queries/0_stateless/01130_in_memory_parts.sql            | 2 ++
 tests/queries/0_stateless/01130_in_memory_parts_check.sql      | 3 +++
 tests/queries/0_stateless/01130_in_memory_parts_default.sql    | 1 +
 tests/queries/0_stateless/01130_in_memory_parts_nested.sql     | 1 +
 tests/queries/0_stateless/01130_in_memory_parts_partitons.sql  | 2 +-
 tests/queries/0_stateless/01475_read_subcolumns_storages.sh    | 1 +
 .../01508_race_condition_rename_clear_zookeeper_long.sh        | 2 +-
 tests/queries/0_stateless/01600_parts_types_metrics_long.sh    | 2 +-
 tests/queries/0_stateless/01643_merge_tree_fsync_smoke.sql     | 2 ++
 .../0_stateless/01643_replicated_merge_tree_fsync_smoke.sql    | 2 +-
 tests/queries/0_stateless/02410_inmemory_wal_cleanup.sql       | 2 ++
 tests/queries/0_stateless/02423_drop_memory_parts.sql          | 2 ++
 12 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/tests/queries/0_stateless/01130_in_memory_parts.sql b/tests/queries/0_stateless/01130_in_memory_parts.sql
index dca12a85841..2b15ae24763 100644
--- a/tests/queries/0_stateless/01130_in_memory_parts.sql
+++ b/tests/queries/0_stateless/01130_in_memory_parts.sql
@@ -1,3 +1,5 @@
+-- Tags: no-s3-storage
+
 DROP TABLE IF EXISTS in_memory;
 CREATE TABLE in_memory (a UInt32, b UInt32)
     ENGINE = MergeTree ORDER BY a
diff --git a/tests/queries/0_stateless/01130_in_memory_parts_check.sql b/tests/queries/0_stateless/01130_in_memory_parts_check.sql
index 57cd1c83528..c2f5eba5949 100644
--- a/tests/queries/0_stateless/01130_in_memory_parts_check.sql
+++ b/tests/queries/0_stateless/01130_in_memory_parts_check.sql
@@ -1,4 +1,7 @@
+-- Tags: no-s3-storage
+
 -- Part of 00961_check_table test, but with in-memory parts
+
 SET check_query_single_value_result = 0;
 DROP TABLE IF EXISTS mt_table;
 CREATE TABLE mt_table (d Date, key UInt64, data String) ENGINE = MergeTree() PARTITION BY toYYYYMM(d) ORDER BY key
diff --git a/tests/queries/0_stateless/01130_in_memory_parts_default.sql b/tests/queries/0_stateless/01130_in_memory_parts_default.sql
index 61e20c84f3d..776d5f89fcf 100644
--- a/tests/queries/0_stateless/01130_in_memory_parts_default.sql
+++ b/tests/queries/0_stateless/01130_in_memory_parts_default.sql
@@ -1,3 +1,4 @@
+-- Tags: no-s3-storage
 -- Test 01266_default_prewhere_reqq, but with in-memory parts
 DROP TABLE IF EXISTS t1;
 
diff --git a/tests/queries/0_stateless/01130_in_memory_parts_nested.sql b/tests/queries/0_stateless/01130_in_memory_parts_nested.sql
index 76e5a6d7751..c503e8834b4 100644
--- a/tests/queries/0_stateless/01130_in_memory_parts_nested.sql
+++ b/tests/queries/0_stateless/01130_in_memory_parts_nested.sql
@@ -1,3 +1,4 @@
+-- Tags: no-s3-storage
 -- Test 00576_nested_and_prewhere, but with in-memory parts.
 DROP TABLE IF EXISTS nested;
 
diff --git a/tests/queries/0_stateless/01130_in_memory_parts_partitons.sql b/tests/queries/0_stateless/01130_in_memory_parts_partitons.sql
index b1ba8bc5560..18da2d2bd30 100644
--- a/tests/queries/0_stateless/01130_in_memory_parts_partitons.sql
+++ b/tests/queries/0_stateless/01130_in_memory_parts_partitons.sql
@@ -1,4 +1,4 @@
--- Tags: no-parallel
+-- Tags: no-parallel, no-s3-storage
 
 DROP TABLE IF EXISTS t2;
 
diff --git a/tests/queries/0_stateless/01475_read_subcolumns_storages.sh b/tests/queries/0_stateless/01475_read_subcolumns_storages.sh
index be22b1b4185..d770d5118ac 100755
--- a/tests/queries/0_stateless/01475_read_subcolumns_storages.sh
+++ b/tests/queries/0_stateless/01475_read_subcolumns_storages.sh
@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
+# Tags: no-s3-storage
 
 CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 # shellcheck source=../shell_config.sh
diff --git a/tests/queries/0_stateless/01508_race_condition_rename_clear_zookeeper_long.sh b/tests/queries/0_stateless/01508_race_condition_rename_clear_zookeeper_long.sh
index 7db9f22951c..efe24aa3a88 100755
--- a/tests/queries/0_stateless/01508_race_condition_rename_clear_zookeeper_long.sh
+++ b/tests/queries/0_stateless/01508_race_condition_rename_clear_zookeeper_long.sh
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Tags: race, zookeeper
+# Tags: race, zookeeper, no-s3-storage
 
 CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 # shellcheck source=../shell_config.sh
diff --git a/tests/queries/0_stateless/01600_parts_types_metrics_long.sh b/tests/queries/0_stateless/01600_parts_types_metrics_long.sh
index 6e4ccbdd325..05edf02f7ed 100755
--- a/tests/queries/0_stateless/01600_parts_types_metrics_long.sh
+++ b/tests/queries/0_stateless/01600_parts_types_metrics_long.sh
@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Tags: long
+# Tags: long, no-s3-storage
 
 CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 # shellcheck source=../shell_config.sh
diff --git a/tests/queries/0_stateless/01643_merge_tree_fsync_smoke.sql b/tests/queries/0_stateless/01643_merge_tree_fsync_smoke.sql
index 598e1ef3c34..ad0dfca0db2 100644
--- a/tests/queries/0_stateless/01643_merge_tree_fsync_smoke.sql
+++ b/tests/queries/0_stateless/01643_merge_tree_fsync_smoke.sql
@@ -1,3 +1,5 @@
+-- Tags: no-s3-storage
+
 drop table if exists data_01643;
 
 select 'default';
diff --git a/tests/queries/0_stateless/01643_replicated_merge_tree_fsync_smoke.sql b/tests/queries/0_stateless/01643_replicated_merge_tree_fsync_smoke.sql
index dadd7eaba6c..bcce87e11db 100644
--- a/tests/queries/0_stateless/01643_replicated_merge_tree_fsync_smoke.sql
+++ b/tests/queries/0_stateless/01643_replicated_merge_tree_fsync_smoke.sql
@@ -1,4 +1,4 @@
--- Tags: no-parallel
+-- Tags: no-parallel, no-s3-storage
 -- no-parallel -- for flaky check and to avoid "Removing leftovers from table" (for other tables)
 
 -- Temporarily skip warning 'table was created by another server at the same moment, will retry'
diff --git a/tests/queries/0_stateless/02410_inmemory_wal_cleanup.sql b/tests/queries/0_stateless/02410_inmemory_wal_cleanup.sql
index 0228852a115..7f832d980ba 100644
--- a/tests/queries/0_stateless/02410_inmemory_wal_cleanup.sql
+++ b/tests/queries/0_stateless/02410_inmemory_wal_cleanup.sql
@@ -1,3 +1,5 @@
+-- Tags: no-s3-storage
+
 -- { echo }
 
 DROP TABLE IF EXISTS in_memory;
diff --git a/tests/queries/0_stateless/02423_drop_memory_parts.sql b/tests/queries/0_stateless/02423_drop_memory_parts.sql
index fad81d46e68..9326f159b0c 100644
--- a/tests/queries/0_stateless/02423_drop_memory_parts.sql
+++ b/tests/queries/0_stateless/02423_drop_memory_parts.sql
@@ -1,3 +1,5 @@
+-- Tags: no-s3-storage
+
 DROP TABLE IF EXISTS table_in_memory;
 
 CREATE TABLE table_in_memory

From ed00db75801e5482ecaf7d0e7034e75789307f96 Mon Sep 17 00:00:00 2001
From: Igor Nikonov <igor@clickhouse.com>
Date: Fri, 3 Feb 2023 13:15:06 +0000
Subject: [PATCH 38/79] Update sorting properties after reading in order
 applied

---
 src/Processors/QueryPlan/DistinctStep.cpp     |  7 +++-
 .../Optimizations/optimizeReadInOrder.cpp     | 41 ++++++++++++++-----
 2 files changed, 37 insertions(+), 11 deletions(-)

diff --git a/src/Processors/QueryPlan/DistinctStep.cpp b/src/Processors/QueryPlan/DistinctStep.cpp
index e3d29256c23..323ef0bbdab 100644
--- a/src/Processors/QueryPlan/DistinctStep.cpp
+++ b/src/Processors/QueryPlan/DistinctStep.cpp
@@ -103,7 +103,12 @@ void DistinctStep::transformPipeline(QueryPipelineBuilder & pipeline, const Buil
                             return nullptr;
 
                         return std::make_shared<DistinctSortedChunkTransform>(
-                            header, set_size_limits, limit_hint, distinct_sort_desc, columns, false);
+                            header,
+                            set_size_limits,
+                            limit_hint,
+                            distinct_sort_desc,
+                            columns,
+                            input_stream.sort_scope == DataStream::SortScope::Stream);
                     });
                 return;
             }
diff --git a/src/Processors/QueryPlan/Optimizations/optimizeReadInOrder.cpp b/src/Processors/QueryPlan/Optimizations/optimizeReadInOrder.cpp
index bdf8f24f9d6..675436fc2d9 100644
--- a/src/Processors/QueryPlan/Optimizations/optimizeReadInOrder.cpp
+++ b/src/Processors/QueryPlan/Optimizations/optimizeReadInOrder.cpp
@@ -63,20 +63,25 @@ ISourceStep * checkSupportedReadingStep(IQueryPlanStep * step)
     return nullptr;
 }
 
-QueryPlan::Node * findReadingStep(QueryPlan::Node & node)
+QueryPlan::Node * findReadingStep(QueryPlan::Node & node, std::vector<IQueryPlanStep*>& backward_path)
 {
     IQueryPlanStep * step = node.step.get();
     if (auto * reading = checkSupportedReadingStep(step))
+    {
+        backward_path.push_back(node.step.get());
         return &node;
+    }
 
     if (node.children.size() != 1)
         return nullptr;
 
+    backward_path.push_back(node.step.get());
+
     if (typeid_cast<ExpressionStep *>(step) || typeid_cast<FilterStep *>(step) || typeid_cast<ArrayJoinStep *>(step))
-        return findReadingStep(*node.children.front());
+        return findReadingStep(*node.children.front(), backward_path);
 
     if (auto * distinct = typeid_cast<DistinctStep *>(step); distinct && distinct->isPreliminary())
-        return findReadingStep(*node.children.front());
+        return findReadingStep(*node.children.front(), backward_path);
 
     return nullptr;
 }
@@ -987,9 +992,9 @@ AggregationInputOrder buildInputOrderInfo(
     return order_info;
 }
 
-InputOrderInfoPtr buildInputOrderInfo(SortingStep & sorting, QueryPlan::Node & node)
+InputOrderInfoPtr buildInputOrderInfo(SortingStep & sorting, QueryPlan::Node & node, std::vector<IQueryPlanStep*>& backward_path)
 {
-    QueryPlan::Node * reading_node = findReadingStep(node);
+    QueryPlan::Node * reading_node = findReadingStep(node, backward_path);
     if (!reading_node)
         return nullptr;
 
@@ -1035,9 +1040,9 @@ InputOrderInfoPtr buildInputOrderInfo(SortingStep & sorting, QueryPlan::Node & n
     return nullptr;
 }
 
-AggregationInputOrder buildInputOrderInfo(AggregatingStep & aggregating, QueryPlan::Node & node)
+AggregationInputOrder buildInputOrderInfo(AggregatingStep & aggregating, QueryPlan::Node & node, std::vector<IQueryPlanStep*>& backward_path)
 {
-    QueryPlan::Node * reading_node = findReadingStep(node);
+    QueryPlan::Node * reading_node = findReadingStep(node, backward_path);
     if (!reading_node)
         return {};
 
@@ -1096,6 +1101,7 @@ void optimizeReadInOrder(QueryPlan::Node & node, QueryPlan::Nodes & nodes)
     if (sorting->getType() != SortingStep::Type::Full)
         return;
 
+    std::vector<IQueryPlanStep*> steps_to_update;
     if (typeid_cast<UnionStep *>(node.children.front()->step.get()))
     {
         auto & union_node = node.children.front();
@@ -1105,7 +1111,7 @@ void optimizeReadInOrder(QueryPlan::Node & node, QueryPlan::Nodes & nodes)
         infos.reserve(node.children.size());
         for (auto * child : union_node->children)
         {
-            infos.push_back(buildInputOrderInfo(*sorting, *child));
+            infos.push_back(buildInputOrderInfo(*sorting, *child, steps_to_update));
 
             if (infos.back() && (!max_sort_descr || max_sort_descr->size() < infos.back()->sort_description_for_merging.size()))
                 max_sort_descr = &infos.back()->sort_description_for_merging;
@@ -1155,9 +1161,23 @@ void optimizeReadInOrder(QueryPlan::Node & node, QueryPlan::Nodes & nodes)
 
         sorting->convertToFinishSorting(*max_sort_descr);
     }
-    else if (auto order_info = buildInputOrderInfo(*sorting, *node.children.front()))
+    else if (auto order_info = buildInputOrderInfo(*sorting, *node.children.front(), steps_to_update))
     {
         sorting->convertToFinishSorting(order_info->sort_description_for_merging);
+
+        /// update data stream's sorting properties for found transforms
+        if (!steps_to_update.empty())
+        {
+            const DataStream * input_stream = &steps_to_update.back()->getOutputStream();
+            steps_to_update.pop_back();
+
+            while (!steps_to_update.empty())
+            {
+                dynamic_cast<ITransformingStep*>(steps_to_update.back())->updateInputStream(*input_stream);
+                input_stream = &steps_to_update.back()->getOutputStream();
+                steps_to_update.pop_back();
+            }
+        }
     }
 }
 
@@ -1174,7 +1194,8 @@ void optimizeAggregationInOrder(QueryPlan::Node & node, QueryPlan::Nodes &)
         return;
 
     /// TODO: maybe add support for UNION later.
-    if (auto order_info = buildInputOrderInfo(*aggregating, *node.children.front()); order_info.input_order)
+    std::vector<IQueryPlanStep*> steps_to_update;
+    if (auto order_info = buildInputOrderInfo(*aggregating, *node.children.front(), steps_to_update); order_info.input_order)
     {
         aggregating->applyOrder(std::move(order_info.sort_description_for_merging), std::move(order_info.group_by_sort_description));
     }

From 2656027c9fa47de2eb1223a642182dac9200b1c9 Mon Sep 17 00:00:00 2001
From: Han Fei <hanfei19910905@gmail.com>
Date: Fri, 3 Feb 2023 14:25:53 +0100
Subject: [PATCH 39/79] make it work if we dont define use_vectorscan macro

---
 src/Dictionaries/RegExpTreeDictionary.cpp     | 50 +++++++++----------
 .../02504_regexp_dictionary_ua_parser.sh      |  2 +-
 2 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/src/Dictionaries/RegExpTreeDictionary.cpp b/src/Dictionaries/RegExpTreeDictionary.cpp
index 5d8bb04623a..f094e5ebcd4 100644
--- a/src/Dictionaries/RegExpTreeDictionary.cpp
+++ b/src/Dictionaries/RegExpTreeDictionary.cpp
@@ -173,6 +173,7 @@ namespace
             return false;
         }
 
+        [[maybe_unused]]
         bool check(const String & data) const
         {
 
@@ -251,15 +252,15 @@ void RegExpTreeDictionary::initRegexNodes(Block & block)
             }
         }
         regex_nodes.emplace(id, node);
-        if (checker.check(regex))
-        {
-            complex_regexp_nodes.push_back(node);
-        }
-        else
+#if USE_VECTORSCAN
+        if (!checker.check(regex))
         {
             regexps.push_back(regex);
             regexp_ids.push_back(id);
         }
+        else
+#endif
+            complex_regexp_nodes.push_back(node);
     }
 }
 
@@ -308,7 +309,7 @@ void RegExpTreeDictionary::loadData()
             initRegexNodes(block);
         }
         initGraph();
-        if (regexps.empty())
+        if (regexps.empty() && complex_regexp_nodes.empty())
             throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION, "There are no available regular expression. Please check your config");
         LOG_INFO(logger, "There are {} simple regexps and {} complex regexps", regexps.size(), complex_regexp_nodes.size());
         #if USE_VECTORSCAN
@@ -415,7 +416,6 @@ bool RegExpTreeDictionary::setAttributes(
     return attributes_to_set.size() == attributes.size();
 }
 
-#if USE_VECTORSCAN
 namespace
 {
     struct MatchContext
@@ -429,6 +429,7 @@ namespace
         MatchContext(const std::vector<UInt64> & regexp_ids_, const std::unordered_map<UInt64, UInt64> & topology_order_)
             : regexp_ids(regexp_ids_), topology_order(topology_order_) {}
 
+        [[maybe_unused]]
         void insertIdx(unsigned int idx)
         {
             UInt64 node_id = regexp_ids[idx-1];
@@ -456,14 +457,14 @@ namespace
         }
     };
 }
-#endif // USE_VECTORSCAN
 
 std::unordered_map<String, ColumnPtr> RegExpTreeDictionary::matchSearchAllIndices(
-    [[maybe_unused]] const ColumnString::Chars & keys_data,
-    [[maybe_unused]] const ColumnString::Offsets & keys_offsets,
-    [[maybe_unused]] const std::unordered_map<String, const DictionaryAttribute &> & attributes,
-    [[maybe_unused]] const std::unordered_map<String, ColumnPtr> & defaults) const
+    const ColumnString::Chars & keys_data,
+    const ColumnString::Offsets & keys_offsets,
+    const std::unordered_map<String, const DictionaryAttribute &> & attributes,
+    const std::unordered_map<String, ColumnPtr> & defaults) const
 {
+
 #if USE_VECTORSCAN
     hs_scratch_t * scratch = nullptr;
     hs_error_t err = hs_clone_scratch(hyperscan_regex->get()->getScratch(), &scratch);
@@ -474,6 +475,16 @@ std::unordered_map<String, ColumnPtr> RegExpTreeDictionary::matchSearchAllIndice
     }
 
     MultiRegexps::ScratchPtr smart_scratch(scratch);
+    auto on_match = [](unsigned int id,
+                    unsigned long long /* from */, // NOLINT
+                    unsigned long long /* to */, // NOLINT
+                    unsigned int /* flags */,
+                    void * context) -> int
+    {
+        static_cast<MatchContext *>(context)->insertIdx(id);
+        return 0;
+    };
+#endif
 
     std::unordered_map<String, MutableColumnPtr> columns;
 
@@ -485,16 +496,6 @@ std::unordered_map<String, ColumnPtr> RegExpTreeDictionary::matchSearchAllIndice
         columns[name] = std::move(col_ptr);
     }
 
-    auto on_match = [](unsigned int id,
-                    unsigned long long /* from */, // NOLINT
-                    unsigned long long /* to */, // NOLINT
-                    unsigned int /* flags */,
-                    void * context) -> int
-    {
-        static_cast<MatchContext *>(context)->insertIdx(id);
-        return 0;
-    };
-
     UInt64 offset = 0;
     for (size_t key_idx = 0; key_idx < keys_offsets.size(); ++key_idx)
     {
@@ -503,6 +504,7 @@ std::unordered_map<String, ColumnPtr> RegExpTreeDictionary::matchSearchAllIndice
 
         MatchContext match_result(regexp_ids, topology_order);
 
+#if USE_VECTORSCAN
         err = hs_scan(
             hyperscan_regex->get()->getDB(),
             reinterpret_cast<const char *>(keys_data.data()) + offset,
@@ -514,6 +516,7 @@ std::unordered_map<String, ColumnPtr> RegExpTreeDictionary::matchSearchAllIndice
 
         if (err != HS_SUCCESS)
             throw Exception(ErrorCodes::HYPERSCAN_CANNOT_SCAN_TEXT, "Failed to scan data with vectorscan");
+#endif
 
         for (const auto & node_ptr : complex_regexp_nodes)
         {
@@ -577,9 +580,6 @@ std::unordered_map<String, ColumnPtr> RegExpTreeDictionary::matchSearchAllIndice
         result.emplace(name, std::move(mutable_ptr));
 
     return result;
-#else
-    throw Exception(ErrorCodes::UNSUPPORTED_METHOD, "Multi search all indices is not implemented when USE_VECTORSCAN is off");
-#endif // USE_VECTORSCAN
 }
 
 Columns RegExpTreeDictionary::getColumns(
diff --git a/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.sh b/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.sh
index 4d372bf1ce6..8e361a191d6 100755
--- a/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.sh
+++ b/tests/queries/0_stateless/02504_regexp_dictionary_ua_parser.sh
@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-# Tags: use-vectorscan, no-fasttest, no-parallel
+# Tags: no-fasttest, no-parallel
 
 CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
 # shellcheck source=../shell_config.sh

From 0d77f29a990d63d6434e8018ac2ff604d60679ff Mon Sep 17 00:00:00 2001
From: Kseniia Sumarokova <54203879+kssenii@users.noreply.github.com>
Date: Fri, 3 Feb 2023 15:22:02 +0100
Subject: [PATCH 40/79] Update .reference

---
 tests/queries/0_stateless/01271_show_privileges.reference | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/queries/0_stateless/01271_show_privileges.reference b/tests/queries/0_stateless/01271_show_privileges.reference
index f2c3e8eda9d..af4efb357d0 100644
--- a/tests/queries/0_stateless/01271_show_privileges.reference
+++ b/tests/queries/0_stateless/01271_show_privileges.reference
@@ -89,7 +89,7 @@ SHOW ROW POLICIES	['SHOW POLICIES','SHOW CREATE ROW POLICY','SHOW CREATE POLICY'
 SHOW QUOTAS	['SHOW CREATE QUOTA']	GLOBAL	SHOW ACCESS
 SHOW SETTINGS PROFILES	['SHOW PROFILES','SHOW CREATE SETTINGS PROFILE','SHOW CREATE PROFILE']	GLOBAL	SHOW ACCESS
 SHOW ACCESS	[]	\N	ACCESS MANAGEMENT
-SHOW NAMED COLLECTIONS	['SHOW NAMED COLLECTIONS']	\N	ACCESS MANAGEMENT
+SHOW NAMED COLLECTIONS	['SHOW NAMED COLLECTIONS']	GLOBAL	ACCESS MANAGEMENT
 ACCESS MANAGEMENT	[]	\N	ALL
 SYSTEM SHUTDOWN	['SYSTEM KILL','SHUTDOWN']	GLOBAL	SYSTEM
 SYSTEM DROP DNS CACHE	['SYSTEM DROP DNS','DROP DNS CACHE','DROP DNS']	GLOBAL	SYSTEM DROP CACHE

From f49f5d7091128b92a7a1c82cf5e144e32e413b7b Mon Sep 17 00:00:00 2001
From: Igor Nikonov <igor@clickhouse.com>
Date: Fri, 3 Feb 2023 17:10:31 +0000
Subject: [PATCH 41/79] Update tests

+ updadte sorting properties after applying aggregation in order
---
 .../Optimizations/optimizeReadInOrder.cpp     | 46 +++++++++++--------
 ...ct_in_order_optimization_explain.reference |  6 +++
 ..._input_stream_properties_explain.reference |  8 ++--
 3 files changed, 38 insertions(+), 22 deletions(-)

diff --git a/src/Processors/QueryPlan/Optimizations/optimizeReadInOrder.cpp b/src/Processors/QueryPlan/Optimizations/optimizeReadInOrder.cpp
index 675436fc2d9..e2feb66c823 100644
--- a/src/Processors/QueryPlan/Optimizations/optimizeReadInOrder.cpp
+++ b/src/Processors/QueryPlan/Optimizations/optimizeReadInOrder.cpp
@@ -63,7 +63,9 @@ ISourceStep * checkSupportedReadingStep(IQueryPlanStep * step)
     return nullptr;
 }
 
-QueryPlan::Node * findReadingStep(QueryPlan::Node & node, std::vector<IQueryPlanStep*>& backward_path)
+using StepStack = std::vector<IQueryPlanStep*>;
+
+QueryPlan::Node * findReadingStep(QueryPlan::Node & node, StepStack & backward_path)
 {
     IQueryPlanStep * step = node.step.get();
     if (auto * reading = checkSupportedReadingStep(step))
@@ -86,6 +88,24 @@ QueryPlan::Node * findReadingStep(QueryPlan::Node & node, std::vector<IQueryPlan
     return nullptr;
 }
 
+void updateStepsDataStreams(StepStack & steps_to_update)
+{
+    /// update data stream's sorting properties for found transforms
+    if (!steps_to_update.empty())
+    {
+        const DataStream * input_stream = &steps_to_update.back()->getOutputStream();
+        chassert(dynamic_cast<ISourceStep *>(steps_to_update.back()));
+        steps_to_update.pop_back();
+
+        while (!steps_to_update.empty())
+        {
+            dynamic_cast<ITransformingStep *>(steps_to_update.back())->updateInputStream(*input_stream);
+            input_stream = &steps_to_update.back()->getOutputStream();
+            steps_to_update.pop_back();
+        }
+    }
+}
+
 /// FixedColumns are columns which values become constants after filtering.
 /// In a query "SELECT x, y, z FROM table WHERE x = 1 AND y = 'a' ORDER BY x, y, z"
 /// Fixed columns are 'x' and 'y'.
@@ -992,7 +1012,7 @@ AggregationInputOrder buildInputOrderInfo(
     return order_info;
 }
 
-InputOrderInfoPtr buildInputOrderInfo(SortingStep & sorting, QueryPlan::Node & node, std::vector<IQueryPlanStep*>& backward_path)
+InputOrderInfoPtr buildInputOrderInfo(SortingStep & sorting, QueryPlan::Node & node, StepStack & backward_path)
 {
     QueryPlan::Node * reading_node = findReadingStep(node, backward_path);
     if (!reading_node)
@@ -1040,7 +1060,7 @@ InputOrderInfoPtr buildInputOrderInfo(SortingStep & sorting, QueryPlan::Node & n
     return nullptr;
 }
 
-AggregationInputOrder buildInputOrderInfo(AggregatingStep & aggregating, QueryPlan::Node & node, std::vector<IQueryPlanStep*>& backward_path)
+AggregationInputOrder buildInputOrderInfo(AggregatingStep & aggregating, QueryPlan::Node & node, StepStack & backward_path)
 {
     QueryPlan::Node * reading_node = findReadingStep(node, backward_path);
     if (!reading_node)
@@ -1101,7 +1121,7 @@ void optimizeReadInOrder(QueryPlan::Node & node, QueryPlan::Nodes & nodes)
     if (sorting->getType() != SortingStep::Type::Full)
         return;
 
-    std::vector<IQueryPlanStep*> steps_to_update;
+    StepStack steps_to_update;
     if (typeid_cast<UnionStep *>(node.children.front()->step.get()))
     {
         auto & union_node = node.children.front();
@@ -1164,20 +1184,8 @@ void optimizeReadInOrder(QueryPlan::Node & node, QueryPlan::Nodes & nodes)
     else if (auto order_info = buildInputOrderInfo(*sorting, *node.children.front(), steps_to_update))
     {
         sorting->convertToFinishSorting(order_info->sort_description_for_merging);
-
-        /// update data stream's sorting properties for found transforms
-        if (!steps_to_update.empty())
-        {
-            const DataStream * input_stream = &steps_to_update.back()->getOutputStream();
-            steps_to_update.pop_back();
-
-            while (!steps_to_update.empty())
-            {
-                dynamic_cast<ITransformingStep*>(steps_to_update.back())->updateInputStream(*input_stream);
-                input_stream = &steps_to_update.back()->getOutputStream();
-                steps_to_update.pop_back();
-            }
-        }
+        /// update data stream's sorting properties
+        updateStepsDataStreams(steps_to_update);
     }
 }
 
@@ -1198,6 +1206,8 @@ void optimizeAggregationInOrder(QueryPlan::Node & node, QueryPlan::Nodes &)
     if (auto order_info = buildInputOrderInfo(*aggregating, *node.children.front(), steps_to_update); order_info.input_order)
     {
         aggregating->applyOrder(std::move(order_info.sort_description_for_merging), std::move(order_info.group_by_sort_description));
+        /// update data stream's sorting properties
+        updateStepsDataStreams(steps_to_update);
     }
 }
 
diff --git a/tests/queries/0_stateless/02317_distinct_in_order_optimization_explain.reference b/tests/queries/0_stateless/02317_distinct_in_order_optimization_explain.reference
index f85b9cd9e86..2511c806e1b 100644
--- a/tests/queries/0_stateless/02317_distinct_in_order_optimization_explain.reference
+++ b/tests/queries/0_stateless/02317_distinct_in_order_optimization_explain.reference
@@ -59,6 +59,8 @@ Sorting (Stream): a ASC, b ASC
 -- check that reading in order optimization for ORDER BY and DISTINCT applied correctly in the same query
 -- disabled, check that sorting description for ReadFromMergeTree match ORDER BY columns
 Sorting (Stream): a ASC
+Sorting (Stream): a ASC
+Sorting (Stream): a ASC
 -- enabled, check that ReadFromMergeTree sorting description is overwritten by DISTINCT optimization i.e. it contains columns from DISTINCT clause
 Sorting (Stream): a ASC, b ASC
 Sorting (Stream): a ASC, b ASC
@@ -69,8 +71,12 @@ Sorting (Stream): a DESC, b DESC
 Sorting (Stream): a DESC, b DESC
 -- enabled, check that ReadFromMergeTree sorting description is NOT overwritten by DISTINCT optimization (1), - it contains columns from ORDER BY clause
 Sorting (Stream): a ASC, b ASC
+Sorting (Stream): a ASC, b ASC
+Sorting (Stream): a ASC, b ASC
 -- enabled, check that ReadFromMergeTree sorting description is NOT overwritten by DISTINCT optimization (2), - direction used from ORDER BY clause
 Sorting (Stream): a DESC, b DESC
+Sorting (Stream): a DESC, b DESC
+Sorting (Stream): a DESC, b DESC
 -- enabled, check that disabling other 'read in order' optimizations do not disable distinct in order optimization
 Sorting (Stream): a ASC, b ASC
 Sorting (Stream): a ASC, b ASC
diff --git a/tests/queries/0_stateless/02377_optimize_sorting_by_input_stream_properties_explain.reference b/tests/queries/0_stateless/02377_optimize_sorting_by_input_stream_properties_explain.reference
index bafa70556e7..9d78707429e 100644
--- a/tests/queries/0_stateless/02377_optimize_sorting_by_input_stream_properties_explain.reference
+++ b/tests/queries/0_stateless/02377_optimize_sorting_by_input_stream_properties_explain.reference
@@ -25,7 +25,7 @@ PartialSortingTransform × 3
 Sorting (Global): a ASC
 Sorting (Sorting for ORDER BY)
 Sorting (Global): a ASC
-Sorting (Chunk): a ASC
+Sorting (Stream): a ASC
 Sorting (Stream): a ASC
 -- QUERY: set optimize_read_in_order=1;set max_threads=3;set query_plan_remove_redundant_sorting=0;EXPLAIN PLAN actions=1, header=1, sorting=1 SELECT a FROM optimize_sorting ORDER BY a+1
 Sorting (None)
@@ -70,14 +70,14 @@ Sorting (Global): a ASC
 Sorting (None)
 Sorting (Sorting for ORDER BY)
 Sorting (Global): a ASC
-Sorting (Chunk): a ASC
+Sorting (Stream): a ASC
 Sorting (Stream): a ASC
 -- aliases DONT break sorting order
 -- QUERY: set optimize_read_in_order=1;set max_threads=3;set query_plan_remove_redundant_sorting=0;EXPLAIN PLAN actions=1, header=1, sorting=1 SELECT a, b FROM (SELECT x AS a, y AS b FROM (SELECT a AS x, b AS y FROM optimize_sorting) ORDER BY x, y)
 Sorting (Global): x ASC, y ASC
 Sorting (Sorting for ORDER BY)
 Sorting (Global): x ASC, y ASC
-Sorting (Chunk): a ASC, b ASC
+Sorting (Stream): a ASC, b ASC
 Sorting (Stream): a ASC, b ASC
 -- actions chain breaks sorting order: input(column a)->sipHash64(column a)->alias(sipHash64(column a), a)->plus(alias a, 1)
 -- QUERY: set optimize_read_in_order=1;set max_threads=3;set query_plan_remove_redundant_sorting=0;EXPLAIN PLAN actions=1, header=1, sorting=1 SELECT a, z FROM (SELECT sipHash64(a) AS a, a + 1 AS z FROM (SELECT a FROM optimize_sorting ORDER BY a + 1)) ORDER BY a + 1
@@ -94,5 +94,5 @@ Sorting (Chunk): a ASC
 Sorting (Global): a ASC
 Sorting (Sorting for ORDER BY)
 Sorting (Global): a ASC
-Sorting (Chunk): a ASC, b ASC
+Sorting (Stream): a ASC
 Sorting (Stream): a ASC

From 722e389847170c665ae0d9071dfdedf9251e79e3 Mon Sep 17 00:00:00 2001
From: MeenaRenganathan22 <Meena.Renganathan@ibm.com>
Date: Fri, 3 Feb 2023 17:45:48 -0800
Subject: [PATCH 42/79] Updating the submodule to the local branch HDFS_PowerPC

---
 contrib/libhdfs3 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/libhdfs3 b/contrib/libhdfs3
index f3f4b9bc823..30df3beedd2 160000
--- a/contrib/libhdfs3
+++ b/contrib/libhdfs3
@@ -1 +1 @@
-Subproject commit f3f4b9bc82356e0d027eb05bbd727988501ee6c2
+Subproject commit 30df3beedd226f598051126f72a5ed760232d662

From 9ea3de14ceb8f2a61fe0ea9ffac0159fdd977561 Mon Sep 17 00:00:00 2001
From: Han Fei <hanfei19910905@gmail.com>
Date: Sat, 4 Feb 2023 10:53:54 +0100
Subject: [PATCH 43/79] use re2 by default

---
 src/Core/Settings.h                       |  1 +
 src/Dictionaries/RegExpTreeDictionary.cpp | 88 +++++++++++++----------
 src/Dictionaries/RegExpTreeDictionary.h   | 21 +++---
 3 files changed, 66 insertions(+), 44 deletions(-)

diff --git a/src/Core/Settings.h b/src/Core/Settings.h
index dbe905ee962..5897b62defe 100644
--- a/src/Core/Settings.h
+++ b/src/Core/Settings.h
@@ -891,6 +891,7 @@ class IColumn;
     M(Bool, input_format_bson_skip_fields_with_unsupported_types_in_schema_inference, false, "Skip fields with unsupported types while schema inference for format BSON.", 0) \
     \
     M(Bool, regexp_dict_allow_other_sources, false, "Allow regexp_tree dictionary to use sources other than yaml source.", 0) \
+    M(Bool, regexp_dict_allow_hyperscan, false, "Allow regexp_tree dictionary using Hyperscan library.", 0) \
 
 // End of FORMAT_FACTORY_SETTINGS
 // Please add settings non-related to formats into the COMMON_SETTINGS above.
diff --git a/src/Dictionaries/RegExpTreeDictionary.cpp b/src/Dictionaries/RegExpTreeDictionary.cpp
index f094e5ebcd4..ecb7a009b67 100644
--- a/src/Dictionaries/RegExpTreeDictionary.cpp
+++ b/src/Dictionaries/RegExpTreeDictionary.cpp
@@ -145,7 +145,7 @@ std::vector<StringPiece> createStringPieces(const String & value, int num_captur
 
 void RegExpTreeDictionary::calculateBytesAllocated()
 {
-    for (const String & regex : regexps)
+    for (const String & regex : simple_regexps)
         bytes_allocated += regex.size();
     bytes_allocated += sizeof(UInt64) * regexp_ids.size();
     bytes_allocated += (sizeof(RegexTreeNode) + sizeof(UInt64)) * regex_nodes.size();
@@ -253,9 +253,9 @@ void RegExpTreeDictionary::initRegexNodes(Block & block)
         }
         regex_nodes.emplace(id, node);
 #if USE_VECTORSCAN
-        if (!checker.check(regex))
+        if (use_vectorscan && !checker.check(regex))
         {
-            regexps.push_back(regex);
+            simple_regexps.push_back(regex);
             regexp_ids.push_back(id);
         }
         else
@@ -309,13 +309,15 @@ void RegExpTreeDictionary::loadData()
             initRegexNodes(block);
         }
         initGraph();
-        if (regexps.empty() && complex_regexp_nodes.empty())
+        if (simple_regexps.empty() && complex_regexp_nodes.empty())
             throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION, "There are no available regular expression. Please check your config");
-        LOG_INFO(logger, "There are {} simple regexps and {} complex regexps", regexps.size(), complex_regexp_nodes.size());
+        LOG_INFO(logger, "There are {} simple regexps and {} complex regexps", simple_regexps.size(), complex_regexp_nodes.size());
+        if (!use_vectorscan)
+            return;
         #if USE_VECTORSCAN
         try
         {
-            std::vector<std::string_view> regexps_views(regexps.begin(), regexps.end());
+            std::vector<std::string_view> regexps_views(simple_regexps.begin(), simple_regexps.end());
             hyperscan_regex = MultiRegexps::getOrSet<true, false>(regexps_views, std::nullopt);
             hyperscan_regex->get();
         }
@@ -323,7 +325,6 @@ void RegExpTreeDictionary::loadData()
         {
             /// Some compile errors will be thrown as LOGICAL ERROR and cause crash, e.g. empty expression or expressions are too large.
             /// We catch the error here and rethrow again.
-            /// TODO: fallback to other engine, like re2, when exceptions occur.
             throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION, "Error occurs when compiling regular expressions, reason: {}", e.message());
         }
         #endif
@@ -335,8 +336,17 @@ void RegExpTreeDictionary::loadData()
 }
 
 RegExpTreeDictionary::RegExpTreeDictionary(
-    const StorageID & id_, const DictionaryStructure & structure_, DictionarySourcePtr source_ptr_, Configuration configuration_)
-    : IDictionary(id_), structure(structure_), source_ptr(source_ptr_), configuration(configuration_), logger(&Poco::Logger::get("RegExpTreeDictionary"))
+    const StorageID & id_,
+    const DictionaryStructure & structure_,
+    DictionarySourcePtr source_ptr_,
+    Configuration configuration_,
+    bool use_vectorscan_)
+    : IDictionary(id_),
+      structure(structure_),
+      source_ptr(source_ptr_),
+      configuration(configuration_),
+      use_vectorscan(use_vectorscan_),
+      logger(&Poco::Logger::get("RegExpTreeDictionary"))
 {
     if (auto * ch_source = typeid_cast<ClickHouseDictionarySource *>(source_ptr.get()))
     {
@@ -370,7 +380,7 @@ std::pair<String, bool> processBackRefs(const String & data, const re2_st::RE2 &
         else
             result += item.literal;
     }
-    return std::make_pair(result, false);
+    return {result, false};
 }
 
 // walk towards root and collect attributes.
@@ -458,7 +468,7 @@ namespace
     };
 }
 
-std::unordered_map<String, ColumnPtr> RegExpTreeDictionary::matchSearchAllIndices(
+std::unordered_map<String, ColumnPtr> RegExpTreeDictionary::match(
     const ColumnString::Chars & keys_data,
     const ColumnString::Offsets & keys_offsets,
     const std::unordered_map<String, const DictionaryAttribute &> & attributes,
@@ -467,23 +477,17 @@ std::unordered_map<String, ColumnPtr> RegExpTreeDictionary::matchSearchAllIndice
 
 #if USE_VECTORSCAN
     hs_scratch_t * scratch = nullptr;
-    hs_error_t err = hs_clone_scratch(hyperscan_regex->get()->getScratch(), &scratch);
-
-    if (err != HS_SUCCESS)
+    if (use_vectorscan)
     {
-        throw Exception(ErrorCodes::CANNOT_ALLOCATE_MEMORY, "Could not clone scratch space for hyperscan");
+        hs_error_t err = hs_clone_scratch(hyperscan_regex->get()->getScratch(), &scratch);
+
+        if (err != HS_SUCCESS)
+        {
+            throw Exception(ErrorCodes::CANNOT_ALLOCATE_MEMORY, "Could not clone scratch space for hyperscan");
+        }
     }
 
     MultiRegexps::ScratchPtr smart_scratch(scratch);
-    auto on_match = [](unsigned int id,
-                    unsigned long long /* from */, // NOLINT
-                    unsigned long long /* to */, // NOLINT
-                    unsigned int /* flags */,
-                    void * context) -> int
-    {
-        static_cast<MatchContext *>(context)->insertIdx(id);
-        return 0;
-    };
 #endif
 
     std::unordered_map<String, MutableColumnPtr> columns;
@@ -505,17 +509,29 @@ std::unordered_map<String, ColumnPtr> RegExpTreeDictionary::matchSearchAllIndice
         MatchContext match_result(regexp_ids, topology_order);
 
 #if USE_VECTORSCAN
-        err = hs_scan(
-            hyperscan_regex->get()->getDB(),
-            reinterpret_cast<const char *>(keys_data.data()) + offset,
-            static_cast<unsigned>(length),
-            0,
-            smart_scratch.get(),
-            on_match,
-            &match_result);
+        if (use_vectorscan)
+        {
+            auto on_match = [](unsigned int id,
+                            unsigned long long /* from */, // NOLINT
+                            unsigned long long /* to */, // NOLINT
+                            unsigned int /* flags */,
+                            void * context) -> int
+            {
+                static_cast<MatchContext *>(context)->insertIdx(id);
+                return 0;
+            };
+            hs_error_t err = hs_scan(
+                hyperscan_regex->get()->getDB(),
+                reinterpret_cast<const char *>(keys_data.data()) + offset,
+                static_cast<unsigned>(length),
+                0,
+                smart_scratch.get(),
+                on_match,
+                &match_result);
 
-        if (err != HS_SUCCESS)
-            throw Exception(ErrorCodes::HYPERSCAN_CANNOT_SCAN_TEXT, "Failed to scan data with vectorscan");
+            if (err != HS_SUCCESS)
+                throw Exception(ErrorCodes::HYPERSCAN_CANNOT_SCAN_TEXT, "Failed to scan data with vectorscan");
+        }
 #endif
 
         for (const auto & node_ptr : complex_regexp_nodes)
@@ -608,7 +624,7 @@ Columns RegExpTreeDictionary::getColumns(
 
     /// calculate matches
     const ColumnString * key_column = typeid_cast<const ColumnString *>(key_columns[0].get());
-    const auto & columns_map = matchSearchAllIndices(
+    const auto & columns_map = match(
         key_column->getChars(),
         key_column->getOffsets(),
         attributes,
@@ -653,7 +669,7 @@ void registerDictionaryRegExpTree(DictionaryFactory & factory)
                             "regexp_tree dictionary doesn't accept sources other than yaml source. "
                             "To active it, please set regexp_dict_allow_other_sources=true");
 
-        return std::make_unique<RegExpTreeDictionary>(dict_id, dict_struct, std::move(source_ptr), configuration);
+        return std::make_unique<RegExpTreeDictionary>(dict_id, dict_struct, std::move(source_ptr), configuration, context->getSettings().regexp_dict_allow_hyperscan);
     };
 
     factory.registerLayout("regexp_tree", create_layout, true);
diff --git a/src/Dictionaries/RegExpTreeDictionary.h b/src/Dictionaries/RegExpTreeDictionary.h
index 29c8b461324..32206f25429 100644
--- a/src/Dictionaries/RegExpTreeDictionary.h
+++ b/src/Dictionaries/RegExpTreeDictionary.h
@@ -43,7 +43,11 @@ public:
     const std::string name = "RegExpTree";
 
     RegExpTreeDictionary(
-        const StorageID & id_, const DictionaryStructure & structure_, DictionarySourcePtr source_ptr_, Configuration configuration_);
+        const StorageID & id_,
+        const DictionaryStructure & structure_,
+        DictionarySourcePtr source_ptr_,
+        Configuration configuration_,
+        bool use_vectorscan_);
 
     std::string getTypeName() const override { return name; }
 
@@ -79,7 +83,7 @@ public:
 
     std::shared_ptr<const IExternalLoadable> clone() const override
     {
-        return std::make_shared<RegExpTreeDictionary>(getDictionaryID(), structure, source_ptr->clone(), configuration);
+        return std::make_shared<RegExpTreeDictionary>(getDictionaryID(), structure, source_ptr->clone(), configuration, use_vectorscan);
     }
 
     ColumnUInt8::Ptr hasKeys(const Columns &, const DataTypes &) const override
@@ -122,11 +126,6 @@ private:
     mutable std::atomic<size_t> query_count{0};
     mutable std::atomic<size_t> found_count{0};
 
-    std::vector<std::string> regexps;
-    std::vector<UInt64>      regexp_ids;
-
-    Poco::Logger * logger;
-
     void calculateBytesAllocated();
 
     void loadData();
@@ -135,7 +134,7 @@ private:
     void initTopologyOrder(UInt64 node_idx, std::set<UInt64> & visited, UInt64 & topology_id);
     void initGraph();
 
-    std::unordered_map<String, ColumnPtr> matchSearchAllIndices(
+    std::unordered_map<String, ColumnPtr> match(
         const ColumnString::Chars & keys_data,
         const ColumnString::Offsets & keys_offsets,
         const std::unordered_map<String, const DictionaryAttribute &> & attributes,
@@ -153,6 +152,10 @@ private:
     struct RegexTreeNode;
     using RegexTreeNodePtr = std::shared_ptr<RegexTreeNode>;
 
+    bool use_vectorscan;
+
+    std::vector<std::string> simple_regexps;
+    std::vector<UInt64>      regexp_ids;
     std::vector<RegexTreeNodePtr> complex_regexp_nodes;
 
     std::map<UInt64, RegexTreeNodePtr> regex_nodes;
@@ -160,6 +163,8 @@ private:
     #if USE_VECTORSCAN
     MultiRegexps::DeferredConstructedRegexpsPtr hyperscan_regex;
     #endif
+
+    Poco::Logger * logger;
 };
 
 }

From cb4757fc43e9a773b32dff5e6dfe189d01acfe67 Mon Sep 17 00:00:00 2001
From: kssenii <sumarokovakseniia@mail.ru>
Date: Sat, 4 Feb 2023 22:54:49 +0100
Subject: [PATCH 44/79] Fix tests

---
 .../test_create_query_constraints/configs/users.xml    | 10 ++++++++++
 .../integration/test_create_query_constraints/test.py  |  8 ++++++--
 tests/integration/test_grant_and_revoke/test.py        |  8 +++++---
 .../configs/users.d/users.xml                          | 10 ++++++++++
 .../test_settings_constraints_distributed/test.py      |  6 +++---
 5 files changed, 34 insertions(+), 8 deletions(-)
 create mode 100644 tests/integration/test_create_query_constraints/configs/users.xml
 create mode 100644 tests/integration/test_settings_constraints_distributed/configs/users.d/users.xml

diff --git a/tests/integration/test_create_query_constraints/configs/users.xml b/tests/integration/test_create_query_constraints/configs/users.xml
new file mode 100644
index 00000000000..fb5e2028d6e
--- /dev/null
+++ b/tests/integration/test_create_query_constraints/configs/users.xml
@@ -0,0 +1,10 @@
+<clickhouse>
+    <users>
+        <default>
+            <password></password>
+            <profile>default</profile>
+            <quota>default</quota>
+            <show_named_collections>1</show_named_collections>
+        </default>
+    </users>
+</clickhouse>
diff --git a/tests/integration/test_create_query_constraints/test.py b/tests/integration/test_create_query_constraints/test.py
index 997671a6996..54173528aa3 100644
--- a/tests/integration/test_create_query_constraints/test.py
+++ b/tests/integration/test_create_query_constraints/test.py
@@ -7,8 +7,12 @@ from helpers.cluster import ClickHouseCluster
 from helpers.test_tools import assert_eq_with_retry, TSV
 
 cluster = ClickHouseCluster(__file__)
-instance = cluster.add_instance("instance")
-
+instance = cluster.add_instance(
+    "instance",
+    user_configs=[
+        "configs/users.xml",
+    ],
+)
 
 @pytest.fixture(scope="module", autouse=True)
 def start_cluster():
diff --git a/tests/integration/test_grant_and_revoke/test.py b/tests/integration/test_grant_and_revoke/test.py
index d0a2f2ab933..e5cb47cbc80 100644
--- a/tests/integration/test_grant_and_revoke/test.py
+++ b/tests/integration/test_grant_and_revoke/test.py
@@ -377,6 +377,8 @@ def test_introspection():
     instance.query("GRANT SELECT ON test.table TO A")
     instance.query("GRANT CREATE ON *.* TO B WITH GRANT OPTION")
 
+    all_access_except_show_named_collections="SHOW, SELECT, INSERT, ALTER, CREATE, DROP, TRUNCATE, OPTIMIZE, BACKUP, KILL QUERY, KILL TRANSACTION, MOVE PARTITION BETWEEN SHARDS, CREATE USER, ALTER USER, DROP USER, CREATE ROLE, ALTER ROLE, DROP ROLE, ROLE ADMIN, CREATE ROW POLICY, ALTER ROW POLICY, DROP ROW POLICY, CREATE QUOTA, ALTER QUOTA, DROP QUOTA, CREATE SETTINGS PROFILE, ALTER SETTINGS PROFILE, DROP SETTINGS PROFILE, SHOW ACCESS, SYSTEM, dictGet, INTROSPECTION, SOURCES, CLUSTER"
+
     assert instance.query("SHOW USERS") == TSV(["A", "B", "default"])
     assert instance.query("SHOW CREATE USERS A") == TSV(["CREATE USER A"])
     assert instance.query("SHOW CREATE USERS B") == TSV(["CREATE USER B"])
@@ -413,7 +415,7 @@ def test_introspection():
         [
             "GRANT SELECT ON test.table TO A",
             "GRANT CREATE ON *.* TO B WITH GRANT OPTION",
-            "GRANT ALL ON *.* TO default WITH GRANT OPTION",
+            f"GRANT {all_access_except_show_named_collections} ON *.* TO default WITH GRANT OPTION",
         ]
     )
 
@@ -434,7 +436,7 @@ def test_introspection():
         [
             "GRANT SELECT ON test.table TO A",
             "GRANT CREATE ON *.* TO B WITH GRANT OPTION",
-            "GRANT ALL ON *.* TO default WITH GRANT OPTION",
+            f"GRANT {all_access_except_show_named_collections} ON *.* TO default WITH GRANT OPTION",
         ]
     )
 
@@ -449,7 +451,7 @@ def test_introspection():
     expected_access2 = (
         "GRANT SELECT ON test.table TO A\n"
         "GRANT CREATE ON *.* TO B WITH GRANT OPTION\n"
-        "GRANT ALL ON *.* TO default WITH GRANT OPTION\n"
+        f"GRANT {all_access_except_show_named_collections} ON *.* TO default WITH GRANT OPTION"
     )
     assert expected_access1 in instance.query("SHOW ACCESS")
     assert expected_access2 in instance.query("SHOW ACCESS")
diff --git a/tests/integration/test_settings_constraints_distributed/configs/users.d/users.xml b/tests/integration/test_settings_constraints_distributed/configs/users.d/users.xml
new file mode 100644
index 00000000000..fb5e2028d6e
--- /dev/null
+++ b/tests/integration/test_settings_constraints_distributed/configs/users.d/users.xml
@@ -0,0 +1,10 @@
+<clickhouse>
+    <users>
+        <default>
+            <password></password>
+            <profile>default</profile>
+            <quota>default</quota>
+            <show_named_collections>1</show_named_collections>
+        </default>
+    </users>
+</clickhouse>
diff --git a/tests/integration/test_settings_constraints_distributed/test.py b/tests/integration/test_settings_constraints_distributed/test.py
index aed522bb5d1..254a8562a03 100644
--- a/tests/integration/test_settings_constraints_distributed/test.py
+++ b/tests/integration/test_settings_constraints_distributed/test.py
@@ -8,17 +8,17 @@ cluster = ClickHouseCluster(__file__)
 node1 = cluster.add_instance(
     "node1",
     main_configs=["configs/config.d/remote_servers.xml"],
-    user_configs=["configs/users.d/allow_introspection_functions.xml"],
+    user_configs=["configs/users.d/allow_introspection_functions.xml", "configs/users.d/users.xml"],
 )
 node2 = cluster.add_instance(
     "node2",
     main_configs=["configs/config.d/remote_servers.xml"],
-    user_configs=["configs/users.d/allow_introspection_functions.xml"],
+    user_configs=["configs/users.d/allow_introspection_functions.xml", "configs/users.d/users.xml"],
 )
 distributed = cluster.add_instance(
     "distributed",
     main_configs=["configs/config.d/remote_servers.xml"],
-    user_configs=["configs/users.d/allow_introspection_functions.xml"],
+    user_configs=["configs/users.d/allow_introspection_functions.xml", "configs/users.d/users.xml"],
     stay_alive=True,
 )
 

From 2a48f3c88b4c9f2b2d83d135ecb8b4c30afbd6e6 Mon Sep 17 00:00:00 2001
From: Igor Nikonov <igor@clickhouse.com>
Date: Sat, 4 Feb 2023 22:47:26 +0000
Subject: [PATCH 45/79] Update tests

---
 .../02317_distinct_in_order_optimization_explain.reference    | 4 ++--
 .../0_stateless/02481_aggregation_in_order_plan.reference     | 1 +
 tests/queries/0_stateless/02481_aggregation_in_order_plan.sql | 1 +
 3 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/tests/queries/0_stateless/02317_distinct_in_order_optimization_explain.reference b/tests/queries/0_stateless/02317_distinct_in_order_optimization_explain.reference
index 2511c806e1b..da24918a208 100644
--- a/tests/queries/0_stateless/02317_distinct_in_order_optimization_explain.reference
+++ b/tests/queries/0_stateless/02317_distinct_in_order_optimization_explain.reference
@@ -14,10 +14,10 @@ DistinctSortedTransform
 DistinctSortedChunkTransform
 -- distinct with primary key prefix and order by the same columns -> pre-distinct and final distinct optimization
 DistinctSortedStreamTransform
-DistinctSortedChunkTransform
+DistinctSortedStreamTransform
 -- distinct with primary key prefix and order by columns are prefix of distinct columns -> pre-distinct and final distinct optimization
 DistinctSortedTransform
-DistinctSortedChunkTransform
+DistinctSortedStreamTransform
 -- distinct with primary key prefix and order by column in distinct but non-primary key prefix -> pre-distinct and final distinct optimization
 DistinctSortedTransform
 DistinctSortedChunkTransform
diff --git a/tests/queries/0_stateless/02481_aggregation_in_order_plan.reference b/tests/queries/0_stateless/02481_aggregation_in_order_plan.reference
index ea266a98c7e..d8b62435bfa 100644
--- a/tests/queries/0_stateless/02481_aggregation_in_order_plan.reference
+++ b/tests/queries/0_stateless/02481_aggregation_in_order_plan.reference
@@ -4,5 +4,6 @@
 0	1	2	200
   Aggregating
   Order: a ASC, c ASC
+    Sorting (Stream): a ASC, b ASC, c ASC
       ReadFromMergeTree (default.tab)
       Sorting (Stream): a ASC, b ASC, c ASC
diff --git a/tests/queries/0_stateless/02481_aggregation_in_order_plan.sql b/tests/queries/0_stateless/02481_aggregation_in_order_plan.sql
index 1568e44dbd5..9c99609ca46 100644
--- a/tests/queries/0_stateless/02481_aggregation_in_order_plan.sql
+++ b/tests/queries/0_stateless/02481_aggregation_in_order_plan.sql
@@ -1,3 +1,4 @@
+drop table if exists tab;
 create table tab (a Int32, b Int32, c Int32, d Int32) engine = MergeTree order by (a, b, c);
 
 insert into tab select 0, number % 3, 2 - intDiv(number, 3), (number % 3 + 1) * 10 from numbers(6);

From 3042e9ee6e0155a266f2389f13fb502a25717955 Mon Sep 17 00:00:00 2001
From: kssenii <sumarokovakseniia@mail.ru>
Date: Sun, 5 Feb 2023 13:03:03 +0100
Subject: [PATCH 46/79] Fix integration test

---
 .../test_overcommit_tracker/configs/users.d/users.xml  | 10 ++++++++++
 tests/integration/test_overcommit_tracker/test.py      |  7 ++++++-
 2 files changed, 16 insertions(+), 1 deletion(-)
 create mode 100644 tests/integration/test_overcommit_tracker/configs/users.d/users.xml

diff --git a/tests/integration/test_overcommit_tracker/configs/users.d/users.xml b/tests/integration/test_overcommit_tracker/configs/users.d/users.xml
new file mode 100644
index 00000000000..fb5e2028d6e
--- /dev/null
+++ b/tests/integration/test_overcommit_tracker/configs/users.d/users.xml
@@ -0,0 +1,10 @@
+<clickhouse>
+    <users>
+        <default>
+            <password></password>
+            <profile>default</profile>
+            <quota>default</quota>
+            <show_named_collections>1</show_named_collections>
+        </default>
+    </users>
+</clickhouse>
diff --git a/tests/integration/test_overcommit_tracker/test.py b/tests/integration/test_overcommit_tracker/test.py
index 50979526e6a..1f1f23de1f8 100644
--- a/tests/integration/test_overcommit_tracker/test.py
+++ b/tests/integration/test_overcommit_tracker/test.py
@@ -4,7 +4,12 @@ from helpers.cluster import ClickHouseCluster
 
 cluster = ClickHouseCluster(__file__)
 
-node = cluster.add_instance("node")
+node = cluster.add_instance(
+    "node",
+    user_configs=[
+        "configs/users.d/users.xml",
+    ],
+)
 
 
 @pytest.fixture(scope="module", autouse=True)

From 089a0009ad859e829ec7b9c1a0a48deafbdaaa5e Mon Sep 17 00:00:00 2001
From: Igor Nikonov <igor@clickhouse.com>
Date: Sun, 5 Feb 2023 13:38:20 +0000
Subject: [PATCH 47/79] Polishing

+ try to stabilize distinct in order perf test
---
 .../QueryPlan/Optimizations/optimizeReadInOrder.cpp         | 6 +++++-
 tests/performance/distinct_in_order.xml                     | 2 ++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/Processors/QueryPlan/Optimizations/optimizeReadInOrder.cpp b/src/Processors/QueryPlan/Optimizations/optimizeReadInOrder.cpp
index e2feb66c823..421a9bbe317 100644
--- a/src/Processors/QueryPlan/Optimizations/optimizeReadInOrder.cpp
+++ b/src/Processors/QueryPlan/Optimizations/optimizeReadInOrder.cpp
@@ -99,7 +99,11 @@ void updateStepsDataStreams(StepStack & steps_to_update)
 
         while (!steps_to_update.empty())
         {
-            dynamic_cast<ITransformingStep *>(steps_to_update.back())->updateInputStream(*input_stream);
+            auto * transforming_step = dynamic_cast<ITransformingStep *>(steps_to_update.back());
+            if (!transforming_step)
+                break;
+
+            transforming_step->updateInputStream(*input_stream);
             input_stream = &steps_to_update.back()->getOutputStream();
             steps_to_update.pop_back();
         }
diff --git a/tests/performance/distinct_in_order.xml b/tests/performance/distinct_in_order.xml
index 78856b507e7..9e089ddc158 100644
--- a/tests/performance/distinct_in_order.xml
+++ b/tests/performance/distinct_in_order.xml
@@ -2,6 +2,7 @@
     <!-- high cardinality -->
     <create_query>CREATE TABLE distinct_cardinality_high (high UInt64, medium UInt64, low UInt64) ENGINE MergeTree() ORDER BY (high, medium)</create_query>
     <fill_query>INSERT INTO distinct_cardinality_high SELECT number % 1e6, number % 1e4, number % 1e2 FROM numbers_mt(1e8)</fill_query>
+    <fill_query>OPTIMIZE TABLE distinct_cardinality_high FINAL</fill_query>
 
     <query>SELECT DISTINCT high FROM distinct_cardinality_high FORMAT Null</query>
     <query>SELECT DISTINCT high, medium FROM distinct_cardinality_high FORMAT Null</query>
@@ -14,6 +15,7 @@
     <!-- low cardinality -->
     <create_query>CREATE TABLE distinct_cardinality_low (low UInt64, medium UInt64, high UInt64) ENGINE MergeTree() ORDER BY (low, medium)</create_query>
     <fill_query>INSERT INTO distinct_cardinality_low SELECT number % 1e2, number % 1e4, number % 1e6 FROM numbers_mt(1e8)</fill_query>
+    <fill_query>OPTIMIZE TABLE distinct_cardinality_low FINAL</fill_query>
 
     <query>SELECT DISTINCT low FROM distinct_cardinality_low FORMAT Null</query>
     <query>SELECT DISTINCT low, medium FROM distinct_cardinality_low FORMAT Null</query>

From baa345fa64bb36b7dea31885ca221db4d05352dc Mon Sep 17 00:00:00 2001
From: Han Fei <hanfei19910905@gmail.com>
Date: Sun, 5 Feb 2023 18:06:06 +0100
Subject: [PATCH 48/79] remove logs

---
 src/Dictionaries/RegExpTreeDictionary.cpp | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/Dictionaries/RegExpTreeDictionary.cpp b/src/Dictionaries/RegExpTreeDictionary.cpp
index ecb7a009b67..ca1fc4e48bc 100644
--- a/src/Dictionaries/RegExpTreeDictionary.cpp
+++ b/src/Dictionaries/RegExpTreeDictionary.cpp
@@ -422,7 +422,7 @@ bool RegExpTreeDictionary::setAttributes(
     if (parent_id > 0)
         setAttributes(parent_id, attributes_to_set, data, visited_nodes, attributes, defaults, key_index);
 
-    // if all the attributes have set, the walking through can be stopped.
+    /// if all the attributes have set, the walking through can be stopped.
     return attributes_to_set.size() == attributes.size();
 }
 
@@ -542,15 +542,12 @@ std::unordered_map<String, ColumnPtr> RegExpTreeDictionary::match(
             }
         }
 
-        LOG_TRACE(logger, "match string is {}, first matched id is {}, match number is {}", std::string(reinterpret_cast<const char *>(keys_data.data()) + offset, length), match_result.matched_idx_set.empty() ? -1 : *match_result.matched_idx_set.begin(), match_result.matched_idx_set.size());
-
         match_result.sort();
-
-        // Walk through the regex tree util all attributes are set;
+        /// Walk through the regex tree util all attributes are set;
         std::unordered_map<String, Field> attributes_to_set;
         std::unordered_set<UInt64> visited_nodes;
 
-        // Some node matches but its parents cannot match. In this case we must regard this node unmatched.
+        /// Some node matches but its parents cannot match. In this case we must regard this node unmatched.
         auto is_invalid = [&](UInt64 id)
         {
             while (id)
@@ -584,7 +581,7 @@ std::unordered_map<String, ColumnPtr> RegExpTreeDictionary::match(
             columns[name]->insert(default_value.getDefaultValue(key_idx));
         }
 
-        // insert to columns
+        /// insert to columns
         for (const auto & [name, value] : attributes_to_set)
             columns[name]->insert(value);
 

From 9937e73fa950af876549e74f3cb80a9218382741 Mon Sep 17 00:00:00 2001
From: kssenii <sumarokovakseniia@mail.ru>
Date: Sun, 5 Feb 2023 22:38:07 +0100
Subject: [PATCH 49/79] Fix integration test

---
 .../test_access_control_on_cluster/test.py    | 21 ++++++++++++++++---
 .../test_global_overcommit_tracker/test.py    |  6 +++++-
 2 files changed, 23 insertions(+), 4 deletions(-)

diff --git a/tests/integration/test_access_control_on_cluster/test.py b/tests/integration/test_access_control_on_cluster/test.py
index db76233a35f..8dbb87c67d8 100644
--- a/tests/integration/test_access_control_on_cluster/test.py
+++ b/tests/integration/test_access_control_on_cluster/test.py
@@ -3,13 +3,28 @@ from helpers.cluster import ClickHouseCluster
 
 cluster = ClickHouseCluster(__file__)
 ch1 = cluster.add_instance(
-    "ch1", main_configs=["configs/config.d/clusters.xml"], with_zookeeper=True
+    "ch1",
+    main_configs=["configs/config.d/clusters.xml"],
+    user_configs=[
+        "configs/users.d/users.xml",
+    ],
+    with_zookeeper=True,
 )
 ch2 = cluster.add_instance(
-    "ch2", main_configs=["configs/config.d/clusters.xml"], with_zookeeper=True
+    "ch2",
+    main_configs=["configs/config.d/clusters.xml"],
+    user_configs=[
+        "configs/users.d/users.xml",
+    ],
+    with_zookeeper=True,
 )
 ch3 = cluster.add_instance(
-    "ch3", main_configs=["configs/config.d/clusters.xml"], with_zookeeper=True
+    "ch3",
+    main_configs=["configs/config.d/clusters.xml"],
+    user_configs=[
+        "configs/users.d/users.xml",
+    ],
+    with_zookeeper=True,
 )
 
 
diff --git a/tests/integration/test_global_overcommit_tracker/test.py b/tests/integration/test_global_overcommit_tracker/test.py
index 6bedc03a30e..4c60ee8783c 100644
--- a/tests/integration/test_global_overcommit_tracker/test.py
+++ b/tests/integration/test_global_overcommit_tracker/test.py
@@ -5,7 +5,11 @@ from helpers.cluster import ClickHouseCluster
 cluster = ClickHouseCluster(__file__)
 
 node = cluster.add_instance(
-    "node", main_configs=["configs/global_overcommit_tracker.xml"]
+    "node",
+    main_configs=["configs/global_overcommit_tracker.xml"],
+    user_configs=[
+        "configs/users.xml",
+    ],
 )
 
 

From 631c460c967030e13d432e96c648dc1427059768 Mon Sep 17 00:00:00 2001
From: kssenii <sumarokovakseniia@mail.ru>
Date: Mon, 6 Feb 2023 11:34:46 +0100
Subject: [PATCH 50/79] Add forgitten config file

---
 .../configs/users.d/users.xml                          | 10 ++++++++++
 .../test_global_overcommit_tracker/configs/users.xml   | 10 ++++++++++
 2 files changed, 20 insertions(+)
 create mode 100644 tests/integration/test_access_control_on_cluster/configs/users.d/users.xml
 create mode 100644 tests/integration/test_global_overcommit_tracker/configs/users.xml

diff --git a/tests/integration/test_access_control_on_cluster/configs/users.d/users.xml b/tests/integration/test_access_control_on_cluster/configs/users.d/users.xml
new file mode 100644
index 00000000000..fb5e2028d6e
--- /dev/null
+++ b/tests/integration/test_access_control_on_cluster/configs/users.d/users.xml
@@ -0,0 +1,10 @@
+<clickhouse>
+    <users>
+        <default>
+            <password></password>
+            <profile>default</profile>
+            <quota>default</quota>
+            <show_named_collections>1</show_named_collections>
+        </default>
+    </users>
+</clickhouse>
diff --git a/tests/integration/test_global_overcommit_tracker/configs/users.xml b/tests/integration/test_global_overcommit_tracker/configs/users.xml
new file mode 100644
index 00000000000..fb5e2028d6e
--- /dev/null
+++ b/tests/integration/test_global_overcommit_tracker/configs/users.xml
@@ -0,0 +1,10 @@
+<clickhouse>
+    <users>
+        <default>
+            <password></password>
+            <profile>default</profile>
+            <quota>default</quota>
+            <show_named_collections>1</show_named_collections>
+        </default>
+    </users>
+</clickhouse>

From dfb961db724999b0417b50b55a7a99b547ec7b28 Mon Sep 17 00:00:00 2001
From: Sema Checherinda <104093494+CheSema@users.noreply.github.com>
Date: Mon, 6 Feb 2023 12:06:06 +0100
Subject: [PATCH 51/79] increase block size in order to speed up test

---
 tests/queries/0_stateless/01130_in_memory_parts_nested.sql | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/queries/0_stateless/01130_in_memory_parts_nested.sql b/tests/queries/0_stateless/01130_in_memory_parts_nested.sql
index c503e8834b4..45e778b9f04 100644
--- a/tests/queries/0_stateless/01130_in_memory_parts_nested.sql
+++ b/tests/queries/0_stateless/01130_in_memory_parts_nested.sql
@@ -9,8 +9,8 @@ INSERT INTO nested SELECT number, number % 2, range(number % 10) FROM system.num
 
 ALTER TABLE nested ADD COLUMN n.b Array(UInt64);
 SELECT DISTINCT n.b FROM nested PREWHERE filter;
-SELECT DISTINCT n.b FROM nested PREWHERE filter SETTINGS max_block_size = 10;
 SELECT DISTINCT n.b FROM nested PREWHERE filter SETTINGS max_block_size = 123;
+SELECT DISTINCT n.b FROM nested PREWHERE filter SETTINGS max_block_size = 1234;
 
 ALTER TABLE nested ADD COLUMN n.c Array(UInt64) DEFAULT arrayMap(x -> x * 2, n.a);
 SELECT DISTINCT n.c FROM nested PREWHERE filter;

From 734d3a318b2eacd092f4c5563937ae39ff7dc95a Mon Sep 17 00:00:00 2001
From: Sema Checherinda <104093494+CheSema@users.noreply.github.com>
Date: Mon, 6 Feb 2023 12:09:33 +0100
Subject: [PATCH 52/79] const auto ref in the loop

---
 src/Storages/MergeTree/MergeTreeData.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp
index 7b2b23c6e6b..84df58b6beb 100644
--- a/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/src/Storages/MergeTree/MergeTreeData.cpp
@@ -7541,11 +7541,11 @@ MergeTreeData::WriteAheadLogPtr MergeTreeData::getWriteAheadLog()
     if (!write_ahead_log)
     {
         auto reservation = reserveSpace(getSettings()->write_ahead_log_max_bytes);
-        for (auto disk: reservation->getDisks())
+        for (const auto & disk: reservation->getDisks())
         {
             if (!disk->isRemote())
             {
-                write_ahead_log = std::make_shared<MergeTreeWriteAheadLog>(*this, reservation->getDisk());
+                write_ahead_log = std::make_shared<MergeTreeWriteAheadLog>(*this, disk);
                 break;
             }
         }

From e8f45ddf596cceee8373a2e7f198a724cef0b256 Mon Sep 17 00:00:00 2001
From: MeenaRenganathan22 <Meena.Renganathan@ibm.com>
Date: Mon, 6 Feb 2023 10:22:29 -0500
Subject: [PATCH 53/79] Updating the submodule to reflect the latest changes
 i.e revert of PR#24

---
 .gitmodules      | 3 +--
 contrib/libhdfs3 | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/.gitmodules b/.gitmodules
index d917d138932..039d4f042f8 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -58,8 +58,7 @@
 	url = https://github.com/apache/thrift
 [submodule "contrib/libhdfs3"]
 	path = contrib/libhdfs3
-	url = https://github.com/ClibMouse/libhdfs3.git
-        branch = HDFS_PowerPC
+        url = https://github.com/ClickHouse/libhdfs3
 [submodule "contrib/libxml2"]
 	path = contrib/libxml2
 	url = https://github.com/GNOME/libxml2
diff --git a/contrib/libhdfs3 b/contrib/libhdfs3
index 30df3beedd2..9e286249a2a 160000
--- a/contrib/libhdfs3
+++ b/contrib/libhdfs3
@@ -1 +1 @@
-Subproject commit 30df3beedd226f598051126f72a5ed760232d662
+Subproject commit 9e286249a2a423f3b2f2759b3702dc29713eb020

From ab0dedf0c88cbfb732d7c0c71922dce49a227607 Mon Sep 17 00:00:00 2001
From: kssenii <sumarokovakseniia@mail.ru>
Date: Mon, 6 Feb 2023 15:36:47 +0100
Subject: [PATCH 54/79] Simplify code around storage s3 configuration

---
 src/IO/S3/URI.h                               |   1 +
 .../ExternalDataSourceConfiguration.h         |  12 --
 src/Storages/StorageConfiguration.h           |  15 +++
 src/Storages/StorageDeltaLake.cpp             |  69 ++++-------
 src/Storages/StorageDeltaLake.h               |  12 +-
 src/Storages/StorageHudi.cpp                  |  58 ++++------
 src/Storages/StorageHudi.h                    |   8 +-
 src/Storages/StorageS3.cpp                    | 109 ++++++++----------
 src/Storages/StorageS3.h                      |  61 ++++------
 src/Storages/StorageS3Cluster.cpp             |  10 +-
 src/Storages/StorageS3Cluster.h               |  10 +-
 src/Storages/StorageURL.h                     |   8 +-
 src/TableFunctions/TableFunctionDeltaLake.cpp |   6 +-
 src/TableFunctions/TableFunctionDeltaLake.h   |   4 +-
 src/TableFunctions/TableFunctionHudi.cpp      |   6 +-
 src/TableFunctions/TableFunctionHudi.h        |   4 +-
 src/TableFunctions/TableFunctionS3.cpp        |   8 +-
 src/TableFunctions/TableFunctionS3.h          |   6 +-
 src/TableFunctions/TableFunctionS3Cluster.cpp |   5 +-
 src/TableFunctions/TableFunctionS3Cluster.h   |   4 +-
 20 files changed, 181 insertions(+), 235 deletions(-)
 create mode 100644 src/Storages/StorageConfiguration.h

diff --git a/src/IO/S3/URI.h b/src/IO/S3/URI.h
index f21d30929ee..f8f40cf9108 100644
--- a/src/IO/S3/URI.h
+++ b/src/IO/S3/URI.h
@@ -30,6 +30,7 @@ struct URI
 
     bool is_virtual_hosted_style;
 
+    URI() = default;
     explicit URI(const std::string & uri_);
 
     static void validateBucket(const std::string & bucket, const Poco::URI & uri);
diff --git a/src/Storages/ExternalDataSourceConfiguration.h b/src/Storages/ExternalDataSourceConfiguration.h
index 65ef7d28b1b..4475daaa8ff 100644
--- a/src/Storages/ExternalDataSourceConfiguration.h
+++ b/src/Storages/ExternalDataSourceConfiguration.h
@@ -109,18 +109,6 @@ struct URLBasedDataSourceConfiguration
     void set(const URLBasedDataSourceConfiguration & conf);
 };
 
-struct StorageS3Configuration : URLBasedDataSourceConfiguration
-{
-    S3::AuthSettings auth_settings;
-    S3Settings::RequestSettings request_settings;
-};
-
-
-struct StorageS3ClusterConfiguration : StorageS3Configuration
-{
-    String cluster_name;
-};
-
 struct URLBasedDataSourceConfig
 {
     URLBasedDataSourceConfiguration configuration;
diff --git a/src/Storages/StorageConfiguration.h b/src/Storages/StorageConfiguration.h
new file mode 100644
index 00000000000..cab95203c81
--- /dev/null
+++ b/src/Storages/StorageConfiguration.h
@@ -0,0 +1,15 @@
+#pragma once
+#include <Core/Types.h>
+
+namespace DB
+{
+
+/// A base class for stateless table engines configurations.
+struct StatelessTableEngineConfiguration
+{
+    String format = "auto";
+    String compression_method = "auto";
+    String structure = "auto";
+};
+
+}
diff --git a/src/Storages/StorageDeltaLake.cpp b/src/Storages/StorageDeltaLake.cpp
index c74e37a207c..6127db79525 100644
--- a/src/Storages/StorageDeltaLake.cpp
+++ b/src/Storages/StorageDeltaLake.cpp
@@ -57,8 +57,8 @@ std::vector<String> DeltaLakeMetadata::listCurrentFiles() &&
     return keys;
 }
 
-JsonMetadataGetter::JsonMetadataGetter(StorageS3::S3Configuration & configuration_, const String & table_path_, ContextPtr context)
-    : base_configuration(configuration_), table_path(table_path_)
+JsonMetadataGetter::JsonMetadataGetter(const StorageS3::Configuration & configuration_, ContextPtr context)
+    : base_configuration(configuration_)
 {
     init(context);
 }
@@ -96,15 +96,15 @@ void JsonMetadataGetter::init(ContextPtr context)
 
 std::vector<String> JsonMetadataGetter::getJsonLogFiles()
 {
-    std::vector<String> keys;
-
     const auto & client = base_configuration.client;
+    const auto table_path = base_configuration.url.key;
+    const auto bucket = base_configuration.url.bucket;
 
+    std::vector<String> keys;
     S3::ListObjectsV2Request request;
     Aws::S3::Model::ListObjectsV2Outcome outcome;
 
     bool is_finished{false};
-    const auto bucket{base_configuration.uri.bucket};
 
     request.SetBucket(bucket);
 
@@ -154,9 +154,9 @@ std::shared_ptr<ReadBuffer> JsonMetadataGetter::createS3ReadBuffer(const String
     request_settings.max_single_read_retries = 10;
     return std::make_shared<ReadBufferFromS3>(
         base_configuration.client,
-        base_configuration.uri.bucket,
+        base_configuration.url.bucket,
         key,
-        base_configuration.uri.version_id,
+        base_configuration.url.version_id,
         request_settings,
         context->getReadSettings());
 }
@@ -182,11 +182,6 @@ void JsonMetadataGetter::handleJSON(const JSON & json)
 namespace
 {
 
-StorageS3::S3Configuration getBaseConfiguration(const StorageS3Configuration & configuration)
-{
-    return {configuration.url, configuration.auth_settings, configuration.request_settings, configuration.headers};
-}
-
 // DeltaLake stores data in parts in different files
 // keys is vector of parts with latest version
 // generateQueryFromKeys constructs query from parts filenames for
@@ -198,35 +193,25 @@ String generateQueryFromKeys(const std::vector<String> & keys)
 }
 
 
-StorageS3Configuration getAdjustedS3Configuration(
-    const ContextPtr & context,
-    StorageS3::S3Configuration & base_configuration,
-    const StorageS3Configuration & configuration,
-    const std::string & table_path,
-    Poco::Logger * log)
+StorageS3::Configuration getAdjustedS3Configuration(
+    const ContextPtr & context, const StorageS3::Configuration & configuration, Poco::Logger * log)
 {
-    JsonMetadataGetter getter{base_configuration, table_path, context};
-
-    auto keys = getter.getFiles();
-    auto new_uri = base_configuration.uri.uri.toString() + generateQueryFromKeys(keys);
-
-    LOG_DEBUG(log, "New uri: {}", new_uri);
-    LOG_DEBUG(log, "Table path: {}", table_path);
+    JsonMetadataGetter getter{configuration, context};
+    const auto keys = getter.getFiles();
+    const auto new_uri = configuration.url.uri.toString() + generateQueryFromKeys(keys);
 
     // set new url in configuration
-    StorageS3Configuration new_configuration;
-    new_configuration.url = new_uri;
-    new_configuration.auth_settings.access_key_id = configuration.auth_settings.access_key_id;
-    new_configuration.auth_settings.secret_access_key = configuration.auth_settings.secret_access_key;
-    new_configuration.format = configuration.format;
+    StorageS3::Configuration new_configuration(configuration);
+    new_configuration.url = S3::URI(new_uri);
 
+    LOG_DEBUG(log, "Table path: {}, new uri: {}", configuration.url.key, new_uri);
     return new_configuration;
 }
 
 }
 
 StorageDeltaLake::StorageDeltaLake(
-    const StorageS3Configuration & configuration_,
+    const StorageS3::Configuration & configuration_,
     const StorageID & table_id_,
     ColumnsDescription columns_,
     const ConstraintsDescription & constraints_,
@@ -234,14 +219,13 @@ StorageDeltaLake::StorageDeltaLake(
     ContextPtr context_,
     std::optional<FormatSettings> format_settings_)
     : IStorage(table_id_)
-    , base_configuration{getBaseConfiguration(configuration_)}
+    , base_configuration{configuration_}
     , log(&Poco::Logger::get("StorageDeltaLake (" + table_id_.table_name + ")"))
-    , table_path(base_configuration.uri.key)
+    , table_path(base_configuration.url.key)
 {
     StorageInMemoryMetadata storage_metadata;
     StorageS3::updateS3Configuration(context_, base_configuration);
-
-    auto new_configuration = getAdjustedS3Configuration(context_, base_configuration, configuration_, table_path, log);
+    auto new_configuration = getAdjustedS3Configuration(context_, base_configuration, log);
 
     if (columns_.empty())
     {
@@ -284,14 +268,11 @@ Pipe StorageDeltaLake::read(
 }
 
 ColumnsDescription StorageDeltaLake::getTableStructureFromData(
-    const StorageS3Configuration & configuration, const std::optional<FormatSettings> & format_settings, ContextPtr ctx)
+    StorageS3::Configuration & configuration, const std::optional<FormatSettings> & format_settings, ContextPtr ctx)
 {
-    auto base_configuration = getBaseConfiguration(configuration);
-    StorageS3::updateS3Configuration(ctx, base_configuration);
-    auto new_configuration = getAdjustedS3Configuration(
-        ctx, base_configuration, configuration, base_configuration.uri.key, &Poco::Logger::get("StorageDeltaLake"));
-    return StorageS3::getTableStructureFromData(
-        new_configuration, /*distributed processing*/ false, format_settings, ctx, /*object_infos*/ nullptr);
+    StorageS3::updateS3Configuration(ctx, configuration);
+    auto new_configuration = getAdjustedS3Configuration(ctx, configuration, &Poco::Logger::get("StorageDeltaLake"));
+    return StorageS3::getTableStructureFromData(new_configuration, /*distributed processing*/ false, format_settings, ctx, /*object_infos*/ nullptr);
 }
 
 void registerStorageDeltaLake(StorageFactory & factory)
@@ -306,9 +287,9 @@ void registerStorageDeltaLake(StorageFactory & factory)
                     ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH,
                     "Storage DeltaLake requires 3 to 4 arguments: table_url, access_key, secret_access_key, [format]");
 
-            StorageS3Configuration configuration;
+            StorageS3::Configuration configuration;
 
-            configuration.url = checkAndGetLiteralArgument<String>(engine_args[0], "url");
+            configuration.url = S3::URI(checkAndGetLiteralArgument<String>(engine_args[0], "url"));
             configuration.auth_settings.access_key_id = checkAndGetLiteralArgument<String>(engine_args[1], "access_key_id");
             configuration.auth_settings.secret_access_key = checkAndGetLiteralArgument<String>(engine_args[2], "secret_access_key");
 
diff --git a/src/Storages/StorageDeltaLake.h b/src/Storages/StorageDeltaLake.h
index 5e3fdd8ad71..3495a061b14 100644
--- a/src/Storages/StorageDeltaLake.h
+++ b/src/Storages/StorageDeltaLake.h
@@ -37,7 +37,7 @@ private:
 class JsonMetadataGetter
 {
 public:
-    JsonMetadataGetter(StorageS3::S3Configuration & configuration_, const String & table_path_, ContextPtr context);
+    JsonMetadataGetter(const StorageS3::Configuration & configuration_, ContextPtr context);
 
     std::vector<String> getFiles() { return std::move(metadata).listCurrentFiles(); }
 
@@ -50,8 +50,7 @@ private:
 
     void handleJSON(const JSON & json);
 
-    StorageS3::S3Configuration base_configuration;
-    String table_path;
+    StorageS3::Configuration base_configuration;
     DeltaLakeMetadata metadata;
 };
 
@@ -62,7 +61,7 @@ public:
     // 2. Finds out parts with latest version
     // 3. Creates url for underlying StorageS3 enigne to handle reads
     StorageDeltaLake(
-        const StorageS3Configuration & configuration_,
+        const StorageS3::Configuration & configuration_,
         const StorageID & table_id_,
         ColumnsDescription columns_,
         const ConstraintsDescription & constraints_,
@@ -83,11 +82,12 @@ public:
         size_t num_streams) override;
 
     static ColumnsDescription getTableStructureFromData(
-        const StorageS3Configuration & configuration,
+        StorageS3::Configuration & configuration,
         const std::optional<FormatSettings> & format_settings,
         ContextPtr ctx);
+
 private:
-    StorageS3::S3Configuration base_configuration;
+    StorageS3::Configuration base_configuration;
     std::shared_ptr<StorageS3> s3engine;
     Poco::Logger * log;
     String table_path;
diff --git a/src/Storages/StorageHudi.cpp b/src/Storages/StorageHudi.cpp
index 1b0de3c3ed2..b50759d1c2f 100644
--- a/src/Storages/StorageHudi.cpp
+++ b/src/Storages/StorageHudi.cpp
@@ -30,11 +30,6 @@ namespace ErrorCodes
 namespace
 {
 
-StorageS3::S3Configuration getBaseConfiguration(const StorageS3Configuration & configuration)
-{
-    return {configuration.url, configuration.auth_settings, configuration.request_settings, configuration.headers};
-}
-
 /// Apache Hudi store parts of data in different files.
 /// Every part file has timestamp in it.
 /// Every partition(directory) in Apache Hudi has different versions of part.
@@ -91,17 +86,17 @@ String generateQueryFromKeys(const std::vector<std::string> & keys, const String
     return "{" + list_of_keys + "}";
 }
 
-std::vector<std::string> getKeysFromS3(const StorageS3::S3Configuration & base_configuration, const std::string & table_path, Poco::Logger * log)
+std::vector<std::string> getKeysFromS3(const StorageS3::Configuration & configuration, Poco::Logger * log)
 {
+    const auto & client = configuration.client;
+    const auto & table_path = configuration.url.key;
+    const auto & bucket = configuration.url.bucket;
+
     std::vector<std::string> keys;
-
-    const auto & client = base_configuration.client;
-
     S3::ListObjectsV2Request request;
     Aws::S3::Model::ListObjectsV2Outcome outcome;
 
     bool is_finished{false};
-    const auto bucket{base_configuration.uri.bucket};
 
     request.SetBucket(bucket);
     request.SetPrefix(table_path);
@@ -134,31 +129,22 @@ std::vector<std::string> getKeysFromS3(const StorageS3::S3Configuration & base_c
 }
 
 
-StorageS3Configuration getAdjustedS3Configuration(
-    StorageS3::S3Configuration & base_configuration,
-    const StorageS3Configuration & configuration,
-    const std::string & table_path,
-    Poco::Logger * log)
+StorageS3::Configuration getAdjustedS3Configuration(const StorageS3::Configuration & configuration, Poco::Logger * log)
 {
-    auto keys = getKeysFromS3(base_configuration, table_path, log);
-    auto new_uri = base_configuration.uri.uri.toString() + generateQueryFromKeys(keys, configuration.format);
+    const auto keys = getKeysFromS3(configuration, log);
+    const auto new_uri = configuration.url.uri.toString() + generateQueryFromKeys(keys, configuration.format);
 
-    LOG_DEBUG(log, "New uri: {}", new_uri);
-    LOG_DEBUG(log, "Table path: {}", table_path);
-
-    StorageS3Configuration new_configuration;
-    new_configuration.url = new_uri;
-    new_configuration.auth_settings.access_key_id = configuration.auth_settings.access_key_id;
-    new_configuration.auth_settings.secret_access_key = configuration.auth_settings.secret_access_key;
-    new_configuration.format = configuration.format;
+    StorageS3::Configuration new_configuration(configuration);
+    new_configuration.url = S3::URI(new_uri);
 
+    LOG_DEBUG(log, "Table path: {}, new uri: {}", configuration.url.key, new_uri);
     return new_configuration;
 }
 
 }
 
 StorageHudi::StorageHudi(
-    const StorageS3Configuration & configuration_,
+    const StorageS3::Configuration & configuration_,
     const StorageID & table_id_,
     ColumnsDescription columns_,
     const ConstraintsDescription & constraints_,
@@ -166,14 +152,13 @@ StorageHudi::StorageHudi(
     ContextPtr context_,
     std::optional<FormatSettings> format_settings_)
     : IStorage(table_id_)
-    , base_configuration{getBaseConfiguration(configuration_)}
+    , base_configuration{configuration_}
     , log(&Poco::Logger::get("StorageHudi (" + table_id_.table_name + ")"))
-    , table_path(base_configuration.uri.key)
 {
     StorageInMemoryMetadata storage_metadata;
     StorageS3::updateS3Configuration(context_, base_configuration);
 
-    auto new_configuration = getAdjustedS3Configuration(base_configuration, configuration_, table_path, log);
+    auto new_configuration = getAdjustedS3Configuration(base_configuration, log);
 
     if (columns_.empty())
     {
@@ -214,14 +199,11 @@ Pipe StorageHudi::read(
 }
 
 ColumnsDescription StorageHudi::getTableStructureFromData(
-    const StorageS3Configuration & configuration, const std::optional<FormatSettings> & format_settings, ContextPtr ctx)
+    StorageS3::Configuration & configuration, const std::optional<FormatSettings> & format_settings, ContextPtr ctx)
 {
-    auto base_configuration = getBaseConfiguration(configuration);
-    StorageS3::updateS3Configuration(ctx, base_configuration);
-    auto new_configuration = getAdjustedS3Configuration(
-        base_configuration, configuration, base_configuration.uri.key, &Poco::Logger::get("StorageDeltaLake"));
-    return StorageS3::getTableStructureFromData(
-        new_configuration, /*distributed processing*/ false, format_settings, ctx, /*object_infos*/ nullptr);
+    StorageS3::updateS3Configuration(ctx, configuration);
+    auto new_configuration = getAdjustedS3Configuration(configuration, &Poco::Logger::get("StorageDeltaLake"));
+    return StorageS3::getTableStructureFromData(new_configuration, /*distributed processing*/ false, format_settings, ctx, /*object_infos*/ nullptr);
 }
 
 void registerStorageHudi(StorageFactory & factory)
@@ -236,9 +218,9 @@ void registerStorageHudi(StorageFactory & factory)
                     ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH,
                     "Storage Hudi requires 3 to 4 arguments: table_url, access_key, secret_access_key, [format]");
 
-            StorageS3Configuration configuration;
+            StorageS3::Configuration configuration;
 
-            configuration.url = checkAndGetLiteralArgument<String>(engine_args[0], "url");
+            configuration.url = S3::URI(checkAndGetLiteralArgument<String>(engine_args[0], "url"));
             configuration.auth_settings.access_key_id = checkAndGetLiteralArgument<String>(engine_args[1], "access_key_id");
             configuration.auth_settings.secret_access_key = checkAndGetLiteralArgument<String>(engine_args[2], "secret_access_key");
 
diff --git a/src/Storages/StorageHudi.h b/src/Storages/StorageHudi.h
index d4a9aa7ff09..6de94c97f83 100644
--- a/src/Storages/StorageHudi.h
+++ b/src/Storages/StorageHudi.h
@@ -22,7 +22,7 @@ public:
     /// 2. Finds out parts with latest version.
     /// 3. Creates url for underlying StorageS3 enigne to handle reads.
     StorageHudi(
-        const StorageS3Configuration & configuration_,
+        const StorageS3::Configuration & configuration_,
         const StorageID & table_id_,
         ColumnsDescription columns_,
         const ConstraintsDescription & constraints_,
@@ -44,14 +44,14 @@ public:
         size_t num_streams) override;
 
     static ColumnsDescription getTableStructureFromData(
-        const StorageS3Configuration & configuration,
+        StorageS3::Configuration & configuration,
         const std::optional<FormatSettings> & format_settings,
         ContextPtr ctx);
+
 private:
-    StorageS3::S3Configuration base_configuration;
+    StorageS3::Configuration base_configuration;
     std::shared_ptr<StorageS3> s3engine;
     Poco::Logger * log;
-    String table_path;
 };
 
 }
diff --git a/src/Storages/StorageS3.cpp b/src/Storages/StorageS3.cpp
index f6419430746..8ad02cb7319 100644
--- a/src/Storages/StorageS3.cpp
+++ b/src/Storages/StorageS3.cpp
@@ -764,7 +764,7 @@ public:
         ContextPtr context,
         std::optional<FormatSettings> format_settings_,
         const CompressionMethod compression_method,
-        const StorageS3::S3Configuration & s3_configuration_,
+        const StorageS3::Configuration & s3_configuration_,
         const String & bucket,
         const String & key)
         : SinkToStorage(sample_block_)
@@ -855,7 +855,7 @@ public:
         ContextPtr context_,
         std::optional<FormatSettings> format_settings_,
         const CompressionMethod compression_method_,
-        const StorageS3::S3Configuration & s3_configuration_,
+        const StorageS3::Configuration & s3_configuration_,
         const String & bucket_,
         const String & key_)
         : PartitionedSink(partition_by, context_, sample_block_)
@@ -895,7 +895,7 @@ private:
     const Block sample_block;
     ContextPtr context;
     const CompressionMethod compression_method;
-    const StorageS3::S3Configuration & s3_configuration;
+    const StorageS3::Configuration & s3_configuration;
     const String bucket;
     const String key;
     std::optional<FormatSettings> format_settings;
@@ -930,7 +930,7 @@ private:
 
 
 StorageS3::StorageS3(
-    const StorageS3Configuration & configuration_,
+    const StorageS3::Configuration & configuration_,
     const StorageID & table_id_,
     const ColumnsDescription & columns_,
     const ConstraintsDescription & constraints_,
@@ -940,18 +940,18 @@ StorageS3::StorageS3(
     bool distributed_processing_,
     ASTPtr partition_by_)
     : IStorage(table_id_)
-    , s3_configuration{configuration_.url, configuration_.auth_settings, configuration_.request_settings, configuration_.headers}
-    , keys({s3_configuration.uri.key})
+    , s3_configuration{configuration_}
+    , keys({s3_configuration.url.key})
     , format_name(configuration_.format)
     , compression_method(configuration_.compression_method)
-    , name(s3_configuration.uri.storage_name)
+    , name(s3_configuration.url.storage_name)
     , distributed_processing(distributed_processing_)
     , format_settings(format_settings_)
     , partition_by(partition_by_)
-    , is_key_with_globs(s3_configuration.uri.key.find_first_of("*?{") != std::string::npos)
+    , is_key_with_globs(s3_configuration.url.key.find_first_of("*?{") != std::string::npos)
 {
     FormatFactory::instance().checkFormatName(format_name);
-    context_->getGlobalContext()->getRemoteHostFilter().checkURL(s3_configuration.uri.uri);
+    context_->getGlobalContext()->getRemoteHostFilter().checkURL(s3_configuration.url.uri);
     StorageInMemoryMetadata storage_metadata;
 
     updateS3Configuration(context_, s3_configuration);
@@ -987,7 +987,7 @@ StorageS3::StorageS3(
 }
 
 std::shared_ptr<StorageS3Source::IIterator> StorageS3::createFileIterator(
-    const S3Configuration & s3_configuration,
+    const Configuration & s3_configuration,
     const std::vector<String> & keys,
     bool is_key_with_globs,
     bool distributed_processing,
@@ -1005,14 +1005,14 @@ std::shared_ptr<StorageS3Source::IIterator> StorageS3::createFileIterator(
     {
         /// Iterate through disclosed globs and make a source for each file
         return std::make_shared<StorageS3Source::DisclosedGlobIterator>(
-            *s3_configuration.client, s3_configuration.uri, query, virtual_block,
+            *s3_configuration.client, s3_configuration.url, query, virtual_block,
             local_context, object_infos, read_keys, s3_configuration.request_settings);
     }
     else
     {
         return std::make_shared<StorageS3Source::KeysIterator>(
-            *s3_configuration.client, s3_configuration.uri.version_id, keys,
-            s3_configuration.uri.bucket, s3_configuration.request_settings, query, virtual_block, local_context,
+            *s3_configuration.client, s3_configuration.url.version_id, keys,
+            s3_configuration.url.bucket, s3_configuration.request_settings, query, virtual_block, local_context,
             object_infos, read_keys);
     }
 }
@@ -1036,7 +1036,7 @@ Pipe StorageS3::read(
     size_t max_block_size,
     size_t num_streams)
 {
-    bool has_wildcards = s3_configuration.uri.bucket.find(PARTITION_ID_WILDCARD) != String::npos
+    bool has_wildcards = s3_configuration.url.bucket.find(PARTITION_ID_WILDCARD) != String::npos
         || keys.back().find(PARTITION_ID_WILDCARD) != String::npos;
     if (partition_by && has_wildcards)
         throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Reading from a partitioned S3 storage is not implemented yet");
@@ -1102,8 +1102,8 @@ Pipe StorageS3::read(
             s3_configuration.request_settings,
             compression_method,
             s3_configuration.client,
-            s3_configuration.uri.bucket,
-            s3_configuration.uri.version_id,
+            s3_configuration.url.bucket,
+            s3_configuration.url.version_id,
             iterator_wrapper,
             max_download_threads));
     }
@@ -1120,7 +1120,7 @@ SinkToStoragePtr StorageS3::write(const ASTPtr & query, const StorageMetadataPtr
 
     auto sample_block = metadata_snapshot->getSampleBlock();
     auto chosen_compression_method = chooseCompressionMethod(keys.back(), compression_method);
-    bool has_wildcards = s3_configuration.uri.bucket.find(PARTITION_ID_WILDCARD) != String::npos || keys.back().find(PARTITION_ID_WILDCARD) != String::npos;
+    bool has_wildcards = s3_configuration.url.bucket.find(PARTITION_ID_WILDCARD) != String::npos || keys.back().find(PARTITION_ID_WILDCARD) != String::npos;
     auto insert_query = std::dynamic_pointer_cast<ASTInsertQuery>(query);
 
     auto partition_by_ast = insert_query ? (insert_query->partition_by ? insert_query->partition_by : partition_by) : nullptr;
@@ -1136,18 +1136,18 @@ SinkToStoragePtr StorageS3::write(const ASTPtr & query, const StorageMetadataPtr
             format_settings,
             chosen_compression_method,
             s3_configuration,
-            s3_configuration.uri.bucket,
+            s3_configuration.url.bucket,
             keys.back());
     }
     else
     {
         if (is_key_with_globs)
             throw Exception(ErrorCodes::DATABASE_ACCESS_DENIED,
-                            "S3 key '{}' contains globs, so the table is in readonly mode", s3_configuration.uri.key);
+                            "S3 key '{}' contains globs, so the table is in readonly mode", s3_configuration.url.key);
 
         bool truncate_in_insert = local_context->getSettingsRef().s3_truncate_on_insert;
 
-        if (!truncate_in_insert && S3::objectExists(*s3_configuration.client, s3_configuration.uri.bucket, keys.back(), s3_configuration.uri.version_id, s3_configuration.request_settings))
+        if (!truncate_in_insert && S3::objectExists(*s3_configuration.client, s3_configuration.url.bucket, keys.back(), s3_configuration.url.version_id, s3_configuration.request_settings))
         {
             if (local_context->getSettingsRef().s3_create_new_file_on_insert)
             {
@@ -1159,7 +1159,7 @@ SinkToStoragePtr StorageS3::write(const ASTPtr & query, const StorageMetadataPtr
                     new_key = keys[0].substr(0, pos) + "." + std::to_string(index) + (pos == std::string::npos ? "" : keys[0].substr(pos));
                     ++index;
                 }
-                while (S3::objectExists(*s3_configuration.client, s3_configuration.uri.bucket, new_key, s3_configuration.uri.version_id, s3_configuration.request_settings));
+                while (S3::objectExists(*s3_configuration.client, s3_configuration.url.bucket, new_key, s3_configuration.url.version_id, s3_configuration.request_settings));
                 keys.push_back(new_key);
             }
             else
@@ -1168,7 +1168,7 @@ SinkToStoragePtr StorageS3::write(const ASTPtr & query, const StorageMetadataPtr
                                 "Object in bucket {} with key {} already exists. "
                                 "If you want to overwrite it, enable setting s3_truncate_on_insert, if you "
                                 "want to create a new file on each insert, enable setting s3_create_new_file_on_insert",
-                                s3_configuration.uri.bucket,
+                                s3_configuration.url.bucket,
                                 keys.back());
         }
 
@@ -1179,7 +1179,7 @@ SinkToStoragePtr StorageS3::write(const ASTPtr & query, const StorageMetadataPtr
             format_settings,
             chosen_compression_method,
             s3_configuration,
-            s3_configuration.uri.bucket,
+            s3_configuration.url.bucket,
             keys.back());
     }
 }
@@ -1190,7 +1190,7 @@ void StorageS3::truncate(const ASTPtr & /* query */, const StorageMetadataPtr &,
 
     if (is_key_with_globs)
         throw Exception(ErrorCodes::DATABASE_ACCESS_DENIED,
-                            "S3 key '{}' contains globs, so the table is in readonly mode", s3_configuration.uri.key);
+                            "S3 key '{}' contains globs, so the table is in readonly mode", s3_configuration.url.key);
 
     Aws::S3::Model::Delete delkeys;
 
@@ -1203,7 +1203,7 @@ void StorageS3::truncate(const ASTPtr & /* query */, const StorageMetadataPtr &,
 
     ProfileEvents::increment(ProfileEvents::S3DeleteObjects);
     S3::DeleteObjectsRequest request;
-    request.SetBucket(s3_configuration.uri.bucket);
+    request.SetBucket(s3_configuration.url.bucket);
     request.SetDelete(delkeys);
 
     auto response = s3_configuration.client->DeleteObjects(request);
@@ -1218,9 +1218,9 @@ void StorageS3::truncate(const ASTPtr & /* query */, const StorageMetadataPtr &,
 }
 
 
-void StorageS3::updateS3Configuration(ContextPtr ctx, StorageS3::S3Configuration & upd)
+void StorageS3::updateS3Configuration(ContextPtr ctx, StorageS3::Configuration & upd)
 {
-    auto settings = ctx->getStorageS3Settings().getSettings(upd.uri.uri.toString());
+    auto settings = ctx->getStorageS3Settings().getSettings(upd.url.uri.toString());
     upd.request_settings = settings.request_settings;
     upd.request_settings.updateFromSettings(ctx->getSettings());
 
@@ -1244,7 +1244,7 @@ void StorageS3::updateS3Configuration(ContextPtr ctx, StorageS3::S3Configuration
         upd.request_settings.get_request_throttler,
         upd.request_settings.put_request_throttler);
 
-    client_configuration.endpointOverride = upd.uri.endpoint;
+    client_configuration.endpointOverride = upd.url.endpoint;
     client_configuration.maxConnections = static_cast<unsigned>(upd.request_settings.max_connections);
 
     auto credentials = Aws::Auth::AWSCredentials(upd.auth_settings.access_key_id, upd.auth_settings.secret_access_key);
@@ -1254,7 +1254,7 @@ void StorageS3::updateS3Configuration(ContextPtr ctx, StorageS3::S3Configuration
 
     upd.client = S3::ClientFactory::instance().create(
         client_configuration,
-        upd.uri.is_virtual_hosted_style,
+        upd.url.is_virtual_hosted_style,
         credentials.GetAWSAccessKeyId(),
         credentials.GetAWSSecretKey(),
         upd.auth_settings.server_side_encryption_customer_key_base64,
@@ -1263,15 +1263,15 @@ void StorageS3::updateS3Configuration(ContextPtr ctx, StorageS3::S3Configuration
         upd.auth_settings.use_insecure_imds_request.value_or(ctx->getConfigRef().getBool("s3.use_insecure_imds_request", false)));
 }
 
-void StorageS3::processNamedCollectionResult(StorageS3Configuration & configuration, const NamedCollection & collection)
+void StorageS3::processNamedCollectionResult(StorageS3::Configuration & configuration, const NamedCollection & collection)
 {
     validateNamedCollection(collection, required_configuration_keys, optional_configuration_keys);
 
-    configuration.url = collection.get<String>("url");
-
     auto filename = collection.getOrDefault<String>("filename", "");
     if (!filename.empty())
-        configuration.url = std::filesystem::path(configuration.url) / filename;
+        configuration.url = S3::URI(std::filesystem::path(collection.get<String>("url")) / filename);
+    else
+        configuration.url = S3::URI(collection.get<String>("url"));
 
     configuration.auth_settings.access_key_id = collection.getOrDefault<String>("access_key_id", "");
     configuration.auth_settings.secret_access_key = collection.getOrDefault<String>("secret_access_key", "");
@@ -1284,9 +1284,9 @@ void StorageS3::processNamedCollectionResult(StorageS3Configuration & configurat
     configuration.request_settings = S3Settings::RequestSettings(collection);
 }
 
-StorageS3Configuration StorageS3::getConfiguration(ASTs & engine_args, ContextPtr local_context)
+StorageS3::Configuration StorageS3::getConfiguration(ASTs & engine_args, ContextPtr local_context)
 {
-    StorageS3Configuration configuration;
+    StorageS3::Configuration configuration;
 
     if (auto named_collection = tryGetNamedCollectionWithOverrides(engine_args))
     {
@@ -1307,14 +1307,14 @@ StorageS3Configuration StorageS3::getConfiguration(ASTs & engine_args, ContextPt
                             "Storage S3 requires 1 to 5 arguments: "
                             "url, [access_key_id, secret_access_key], name of used format and [compression_method].");
 
-        auto * header_it = StorageURL::collectHeaders(engine_args, configuration.headers, local_context);
+        auto * header_it = StorageURL::collectHeaders(engine_args, configuration.headers_from_ast, local_context);
         if (header_it != engine_args.end())
             engine_args.erase(header_it);
 
         for (auto & engine_arg : engine_args)
             engine_arg = evaluateConstantExpressionOrIdentifierAsLiteral(engine_arg, local_context);
 
-        configuration.url = checkAndGetLiteralArgument<String>(engine_args[0], "url");
+        configuration.url = S3::URI(checkAndGetLiteralArgument<String>(engine_args[0], "url"));
         if (engine_args.size() >= 4)
         {
             configuration.auth_settings.access_key_id = checkAndGetLiteralArgument<String>(engine_args[1], "access_key_id");
@@ -1334,34 +1334,27 @@ StorageS3Configuration StorageS3::getConfiguration(ASTs & engine_args, ContextPt
     }
 
     if (configuration.format == "auto")
-        configuration.format = FormatFactory::instance().getFormatFromFileName(configuration.url, true);
+        configuration.format = FormatFactory::instance().getFormatFromFileName(configuration.url.key, true);
 
     return configuration;
 }
 
 ColumnsDescription StorageS3::getTableStructureFromData(
-    const StorageS3Configuration & configuration,
+    StorageS3::Configuration & configuration,
     bool distributed_processing,
     const std::optional<FormatSettings> & format_settings,
     ContextPtr ctx,
     ObjectInfos * object_infos)
 {
-    S3Configuration s3_configuration{
-        configuration.url,
-        configuration.auth_settings,
-        S3Settings::RequestSettings(ctx->getSettingsRef()),
-        configuration.headers};
-
-    updateS3Configuration(ctx, s3_configuration);
-
+    updateS3Configuration(ctx, configuration);
     return getTableStructureFromDataImpl(
-        configuration.format, s3_configuration, configuration.compression_method, distributed_processing,
-        s3_configuration.uri.key.find_first_of("*?{") != std::string::npos, format_settings, ctx, object_infos);
+        configuration.format, configuration, configuration.compression_method, distributed_processing,
+        configuration.url.key.find_first_of("*?{") != std::string::npos, format_settings, ctx, object_infos);
 }
 
 ColumnsDescription StorageS3::getTableStructureFromDataImpl(
     const String & format,
-    const S3Configuration & s3_configuration,
+    const Configuration & s3_configuration,
     const String & compression_method,
     bool distributed_processing,
     bool is_key_with_globs,
@@ -1373,7 +1366,7 @@ ColumnsDescription StorageS3::getTableStructureFromDataImpl(
 
     auto file_iterator = createFileIterator(
         s3_configuration,
-        {s3_configuration.uri.key},
+        {s3_configuration.url.key},
         is_key_with_globs,
         distributed_processing,
         ctx, nullptr,
@@ -1415,7 +1408,7 @@ ColumnsDescription StorageS3::getTableStructureFromDataImpl(
         int zstd_window_log_max = static_cast<int>(ctx->getSettingsRef().zstd_window_log_max);
         return wrapReadBufferWithCompressionMethod(
             std::make_unique<ReadBufferFromS3>(
-                s3_configuration.client, s3_configuration.uri.bucket, key, s3_configuration.uri.version_id, s3_configuration.request_settings, ctx->getReadSettings()),
+                s3_configuration.client, s3_configuration.url.bucket, key, s3_configuration.url.version_id, s3_configuration.request_settings, ctx->getReadSettings()),
             chooseCompressionMethod(key, compression_method),
             zstd_window_log_max);
     };
@@ -1525,7 +1518,7 @@ SchemaCache & StorageS3::getSchemaCache(const ContextPtr & ctx)
 std::optional<ColumnsDescription> StorageS3::tryGetColumnsFromCache(
     const Strings::const_iterator & begin,
     const Strings::const_iterator & end,
-    const S3Configuration & s3_configuration,
+    const Configuration & s3_configuration,
     ObjectInfos * object_infos,
     const String & format_name,
     const std::optional<FormatSettings> & format_settings,
@@ -1534,7 +1527,7 @@ std::optional<ColumnsDescription> StorageS3::tryGetColumnsFromCache(
     auto & schema_cache = getSchemaCache(ctx);
     for (auto it = begin; it < end; ++it)
     {
-        String path = fs::path(s3_configuration.uri.bucket) / *it;
+        String path = fs::path(s3_configuration.url.bucket) / *it;
         auto get_last_mod_time = [&]() -> std::optional<time_t>
         {
             S3::ObjectInfo info;
@@ -1547,7 +1540,7 @@ std::optional<ColumnsDescription> StorageS3::tryGetColumnsFromCache(
                 /// Note that in case of exception in getObjectInfo returned info will be empty,
                 /// but schema cache will handle this case and won't return columns from cache
                 /// because we can't say that it's valid without last modification time.
-                info = S3::getObjectInfo(*s3_configuration.client, s3_configuration.uri.bucket, *it, s3_configuration.uri.version_id, s3_configuration.request_settings,
+                info = S3::getObjectInfo(*s3_configuration.client, s3_configuration.url.bucket, *it, s3_configuration.url.version_id, s3_configuration.request_settings,
                                          {}, {}, /* throw_on_error= */ false);
                 if (object_infos)
                     (*object_infos)[path] = info;
@@ -1559,7 +1552,7 @@ std::optional<ColumnsDescription> StorageS3::tryGetColumnsFromCache(
             return std::nullopt;
         };
 
-        String source = fs::path(s3_configuration.uri.uri.getHost() + std::to_string(s3_configuration.uri.uri.getPort())) / path;
+        String source = fs::path(s3_configuration.url.uri.getHost() + std::to_string(s3_configuration.url.uri.getPort())) / path;
         auto cache_key = getKeyForSchemaCache(source, format_name, format_settings, ctx);
         auto columns = schema_cache.tryGet(cache_key, get_last_mod_time);
         if (columns)
@@ -1571,13 +1564,13 @@ std::optional<ColumnsDescription> StorageS3::tryGetColumnsFromCache(
 
 void StorageS3::addColumnsToCache(
     const Strings & keys,
-    const S3Configuration & s3_configuration,
+    const Configuration & s3_configuration,
     const ColumnsDescription & columns,
     const String & format_name,
     const std::optional<FormatSettings> & format_settings,
     const ContextPtr & ctx)
 {
-    auto host_and_bucket = fs::path(s3_configuration.uri.uri.getHost() + std::to_string(s3_configuration.uri.uri.getPort())) / s3_configuration.uri.bucket;
+    auto host_and_bucket = fs::path(s3_configuration.url.uri.getHost() + std::to_string(s3_configuration.url.uri.getPort())) / s3_configuration.url.bucket;
     Strings sources;
     sources.reserve(keys.size());
     std::transform(keys.begin(), keys.end(), std::back_inserter(sources), [&](const String & key){ return host_and_bucket / key; });
diff --git a/src/Storages/StorageS3.h b/src/Storages/StorageS3.h
index 65c6928906d..0531a3c08d3 100644
--- a/src/Storages/StorageS3.h
+++ b/src/Storages/StorageS3.h
@@ -21,6 +21,7 @@
 #include <Interpreters/threadPoolCallbackRunner.h>
 #include <Storages/ExternalDataSourceConfiguration.h>
 #include <Storages/Cache/SchemaCache.h>
+#include <Storages/StorageConfiguration.h>
 
 namespace Aws::S3
 {
@@ -238,8 +239,21 @@ private:
 class StorageS3 : public IStorage, WithContext
 {
 public:
+    struct Configuration : public StatelessTableEngineConfiguration
+    {
+        S3::URI url;
+        std::shared_ptr<const S3::Client> client;
+        S3::AuthSettings auth_settings;
+        S3Settings::RequestSettings request_settings;
+        /// If s3 configuration was passed from ast, then it is static.
+        /// If from config - it can be changed with config reload.
+        bool static_configuration = true;
+        /// Headers from ast is a part of static configuration.
+        HTTPHeaderEntries headers_from_ast;
+    };
+
     StorageS3(
-        const StorageS3Configuration & configuration_,
+        const StorageS3::Configuration & configuration_,
         const StorageID & table_id_,
         const ColumnsDescription & columns_,
         const ConstraintsDescription & constraints_,
@@ -271,45 +285,18 @@ public:
 
     bool supportsPartitionBy() const override;
 
-    static StorageS3Configuration getConfiguration(ASTs & engine_args, ContextPtr local_context);
+    static StorageS3::Configuration getConfiguration(ASTs & engine_args, ContextPtr local_context);
 
     using ObjectInfos = StorageS3Source::ObjectInfos;
 
     static ColumnsDescription getTableStructureFromData(
-        const StorageS3Configuration & configuration,
+        StorageS3::Configuration & configuration,
         bool distributed_processing,
         const std::optional<FormatSettings> & format_settings,
         ContextPtr ctx,
         ObjectInfos * object_infos = nullptr);
 
-    static void processNamedCollectionResult(StorageS3Configuration & configuration, const NamedCollection & collection);
-
-    struct S3Configuration
-    {
-        const S3::URI uri;
-        std::shared_ptr<const S3::Client> client;
-
-        S3::AuthSettings auth_settings;
-        S3Settings::RequestSettings request_settings;
-
-        /// If s3 configuration was passed from ast, then it is static.
-        /// If from config - it can be changed with config reload.
-        bool static_configuration = true;
-
-        /// Headers from ast is a part of static configuration.
-        HTTPHeaderEntries headers_from_ast;
-
-        S3Configuration(
-            const String & url_,
-            const S3::AuthSettings & auth_settings_,
-            const S3Settings::RequestSettings & request_settings_,
-            const HTTPHeaderEntries & headers_from_ast_)
-            : uri(S3::URI(url_))
-            , auth_settings(auth_settings_)
-            , request_settings(request_settings_)
-            , static_configuration(!auth_settings_.access_key_id.empty())
-            , headers_from_ast(headers_from_ast_) {}
-    };
+    static void processNamedCollectionResult(StorageS3::Configuration & configuration, const NamedCollection & collection);
 
     static SchemaCache & getSchemaCache(const ContextPtr & ctx);
 
@@ -319,7 +306,7 @@ private:
     friend class StorageHudi;
     friend class StorageDeltaLake;
 
-    S3Configuration s3_configuration;
+    Configuration s3_configuration;
     std::vector<String> keys;
     NamesAndTypesList virtual_columns;
     Block virtual_block;
@@ -334,10 +321,10 @@ private:
 
     ObjectInfos object_infos;
 
-    static void updateS3Configuration(ContextPtr, S3Configuration &);
+    static void updateS3Configuration(ContextPtr, Configuration &);
 
     static std::shared_ptr<StorageS3Source::IIterator> createFileIterator(
-        const S3Configuration & s3_configuration,
+        const Configuration & s3_configuration,
         const std::vector<String> & keys,
         bool is_key_with_globs,
         bool distributed_processing,
@@ -349,7 +336,7 @@ private:
 
     static ColumnsDescription getTableStructureFromDataImpl(
         const String & format,
-        const S3Configuration & s3_configuration,
+        const Configuration & s3_configuration,
         const String & compression_method,
         bool distributed_processing,
         bool is_key_with_globs,
@@ -364,7 +351,7 @@ private:
     static std::optional<ColumnsDescription> tryGetColumnsFromCache(
         const Strings::const_iterator & begin,
         const Strings::const_iterator & end,
-        const S3Configuration & s3_configuration,
+        const Configuration & s3_configuration,
         ObjectInfos * object_infos,
         const String & format_name,
         const std::optional<FormatSettings> & format_settings,
@@ -372,7 +359,7 @@ private:
 
     static void addColumnsToCache(
         const Strings & keys,
-        const S3Configuration & s3_configuration,
+        const Configuration & s3_configuration,
         const ColumnsDescription & columns,
         const String & format_name,
         const std::optional<FormatSettings> & format_settings,
diff --git a/src/Storages/StorageS3Cluster.cpp b/src/Storages/StorageS3Cluster.cpp
index e158aff60a0..65353d6a521 100644
--- a/src/Storages/StorageS3Cluster.cpp
+++ b/src/Storages/StorageS3Cluster.cpp
@@ -41,26 +41,26 @@ namespace DB
 {
 
 StorageS3Cluster::StorageS3Cluster(
-    const StorageS3ClusterConfiguration & configuration_,
+    const Configuration & configuration_,
     const StorageID & table_id_,
     const ColumnsDescription & columns_,
     const ConstraintsDescription & constraints_,
     ContextPtr context_,
     bool structure_argument_was_provided_)
     : IStorageCluster(table_id_)
-    , s3_configuration{configuration_.url, configuration_.auth_settings, configuration_.request_settings, configuration_.headers}
-    , filename(configuration_.url)
+    , s3_configuration{configuration_}
     , cluster_name(configuration_.cluster_name)
     , format_name(configuration_.format)
     , compression_method(configuration_.compression_method)
     , structure_argument_was_provided(structure_argument_was_provided_)
 {
-    context_->getGlobalContext()->getRemoteHostFilter().checkURL(Poco::URI{filename});
+    context_->getGlobalContext()->getRemoteHostFilter().checkURL(configuration_.url.uri);
     StorageInMemoryMetadata storage_metadata;
     StorageS3::updateS3Configuration(context_, s3_configuration);
 
     if (columns_.empty())
     {
+        const auto & filename = configuration_.url.uri.getPath();
         const bool is_key_with_globs = filename.find_first_of("*?{") != std::string::npos;
 
         /// `distributed_processing` is set to false, because this code is executed on the initiator, so there is no callback set
@@ -173,7 +173,7 @@ ClusterPtr StorageS3Cluster::getCluster(ContextPtr context) const
 RemoteQueryExecutor::Extension StorageS3Cluster::getTaskIteratorExtension(ASTPtr query, ContextPtr context) const
 {
     auto iterator = std::make_shared<StorageS3Source::DisclosedGlobIterator>(
-        *s3_configuration.client, s3_configuration.uri, query, virtual_block, context);
+        *s3_configuration.client, s3_configuration.url, query, virtual_block, context);
     auto callback = std::make_shared<std::function<String()>>([iterator]() mutable -> String { return iterator->next().key; });
     return RemoteQueryExecutor::Extension{ .task_iterator = std::move(callback) };
 }
diff --git a/src/Storages/StorageS3Cluster.h b/src/Storages/StorageS3Cluster.h
index d9b69b4913b..e55382c66b2 100644
--- a/src/Storages/StorageS3Cluster.h
+++ b/src/Storages/StorageS3Cluster.h
@@ -21,8 +21,13 @@ class Context;
 class StorageS3Cluster : public IStorageCluster
 {
 public:
+    struct Configuration : public StorageS3::Configuration
+    {
+        std::string cluster_name;
+    };
+
     StorageS3Cluster(
-        const StorageS3ClusterConfiguration & configuration_,
+        const Configuration & configuration_,
         const StorageID & table_id_,
         const ColumnsDescription & columns_,
         const ConstraintsDescription & constraints_,
@@ -43,8 +48,7 @@ public:
     ClusterPtr getCluster(ContextPtr context) const override;
 
 private:
-    StorageS3::S3Configuration s3_configuration;
-    String filename;
+    StorageS3::Configuration s3_configuration;
     String cluster_name;
     String format_name;
     String compression_method;
diff --git a/src/Storages/StorageURL.h b/src/Storages/StorageURL.h
index 6666e2a716e..acf49f3cb71 100644
--- a/src/Storages/StorageURL.h
+++ b/src/Storages/StorageURL.h
@@ -10,6 +10,7 @@
 #include <Storages/StorageFactory.h>
 #include <Storages/ExternalDataSourceConfiguration.h>
 #include <Storages/Cache/SchemaCache.h>
+#include <Storages/StorageConfiguration.h>
 
 
 namespace DB
@@ -181,15 +182,10 @@ public:
 
     static FormatSettings getFormatSettingsFromArgs(const StorageFactory::Arguments & args);
 
-    struct Configuration
+    struct Configuration : public StatelessTableEngineConfiguration
     {
         std::string url;
         std::string http_method;
-
-        std::string format = "auto";
-        std::string compression_method = "auto";
-        std::string structure = "auto";
-
         HTTPHeaderEntries headers;
     };
 
diff --git a/src/TableFunctions/TableFunctionDeltaLake.cpp b/src/TableFunctions/TableFunctionDeltaLake.cpp
index 4a285445016..f8339e06820 100644
--- a/src/TableFunctions/TableFunctionDeltaLake.cpp
+++ b/src/TableFunctions/TableFunctionDeltaLake.cpp
@@ -28,12 +28,12 @@ namespace ErrorCodes
 
 
 void TableFunctionDeltaLake::parseArgumentsImpl(
-    const String & error_message, ASTs & args, ContextPtr context, StorageS3Configuration & base_configuration)
+    const String & error_message, ASTs & args, ContextPtr context, StorageS3::Configuration & base_configuration)
 {
     if (args.empty() || args.size() > 6)
         throw Exception::createDeprecated(error_message, ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-    auto * header_it = StorageURL::collectHeaders(args, base_configuration.headers, context);
+    auto * header_it = StorageURL::collectHeaders(args, base_configuration.headers_from_ast, context);
     if (header_it != args.end())
         args.erase(header_it);
 
@@ -77,7 +77,7 @@ void TableFunctionDeltaLake::parseArgumentsImpl(
     }
 
     /// This argument is always the first
-    base_configuration.url = checkAndGetLiteralArgument<String>(args[0], "url");
+    base_configuration.url = S3::URI(checkAndGetLiteralArgument<String>(args[0], "url"));
 
     if (args_to_idx.contains("format"))
         base_configuration.format = checkAndGetLiteralArgument<String>(args[args_to_idx["format"]], "format");
diff --git a/src/TableFunctions/TableFunctionDeltaLake.h b/src/TableFunctions/TableFunctionDeltaLake.h
index e36ffc3847f..657a8b02d90 100644
--- a/src/TableFunctions/TableFunctionDeltaLake.h
+++ b/src/TableFunctions/TableFunctionDeltaLake.h
@@ -34,9 +34,9 @@ protected:
     ColumnsDescription getActualTableStructure(ContextPtr context) const override;
     void parseArguments(const ASTPtr & ast_function, ContextPtr context) override;
 
-    static void parseArgumentsImpl(const String & error_message, ASTs & args, ContextPtr context, StorageS3Configuration & configuration);
+    static void parseArgumentsImpl(const String & error_message, ASTs & args, ContextPtr context, StorageS3::Configuration & configuration);
 
-    StorageS3Configuration configuration;
+    mutable StorageS3::Configuration configuration;
 };
 
 }
diff --git a/src/TableFunctions/TableFunctionHudi.cpp b/src/TableFunctions/TableFunctionHudi.cpp
index 781518ad77c..3f89fdb640a 100644
--- a/src/TableFunctions/TableFunctionHudi.cpp
+++ b/src/TableFunctions/TableFunctionHudi.cpp
@@ -28,12 +28,12 @@ namespace ErrorCodes
 
 
 void TableFunctionHudi::parseArgumentsImpl(
-    const String & error_message, ASTs & args, ContextPtr context, StorageS3Configuration & base_configuration)
+    const String & error_message, ASTs & args, ContextPtr context, StorageS3::Configuration & base_configuration)
 {
     if (args.empty() || args.size() > 6)
         throw Exception::createDeprecated(error_message, ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-    auto * header_it = StorageURL::collectHeaders(args, base_configuration.headers, context);
+    auto * header_it = StorageURL::collectHeaders(args, base_configuration.headers_from_ast, context);
     if (header_it != args.end())
         args.erase(header_it);
 
@@ -77,7 +77,7 @@ void TableFunctionHudi::parseArgumentsImpl(
     }
 
     /// This argument is always the first
-    base_configuration.url = checkAndGetLiteralArgument<String>(args[0], "url");
+    base_configuration.url = S3::URI(checkAndGetLiteralArgument<String>(args[0], "url"));
 
     if (args_to_idx.contains("format"))
         base_configuration.format = checkAndGetLiteralArgument<String>(args[args_to_idx["format"]], "format");
diff --git a/src/TableFunctions/TableFunctionHudi.h b/src/TableFunctions/TableFunctionHudi.h
index a370bca8c45..519d95e074a 100644
--- a/src/TableFunctions/TableFunctionHudi.h
+++ b/src/TableFunctions/TableFunctionHudi.h
@@ -34,9 +34,9 @@ protected:
     ColumnsDescription getActualTableStructure(ContextPtr context) const override;
     void parseArguments(const ASTPtr & ast_function, ContextPtr context) override;
 
-    static void parseArgumentsImpl(const String & error_message, ASTs & args, ContextPtr context, StorageS3Configuration & configuration);
+    static void parseArgumentsImpl(const String & error_message, ASTs & args, ContextPtr context, StorageS3::Configuration & configuration);
 
-    StorageS3Configuration configuration;
+    mutable StorageS3::Configuration configuration;
 };
 
 }
diff --git a/src/TableFunctions/TableFunctionS3.cpp b/src/TableFunctions/TableFunctionS3.cpp
index f7d5e9c9df2..0abddfef3e4 100644
--- a/src/TableFunctions/TableFunctionS3.cpp
+++ b/src/TableFunctions/TableFunctionS3.cpp
@@ -29,7 +29,7 @@ namespace ErrorCodes
 
 
 /// This is needed to avoid copy-pase. Because s3Cluster arguments only differ in additional argument (first) - cluster name
-void TableFunctionS3::parseArgumentsImpl(const String & error_message, ASTs & args, ContextPtr context, StorageS3Configuration & s3_configuration)
+void TableFunctionS3::parseArgumentsImpl(const String & error_message, ASTs & args, ContextPtr context, StorageS3::Configuration & s3_configuration)
 {
     if (auto named_collection = tryGetNamedCollectionWithOverrides(args))
     {
@@ -40,7 +40,7 @@ void TableFunctionS3::parseArgumentsImpl(const String & error_message, ASTs & ar
         if (args.empty() || args.size() > 6)
             throw Exception::createDeprecated(error_message, ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-        auto * header_it = StorageURL::collectHeaders(args, s3_configuration.headers, context);
+        auto * header_it = StorageURL::collectHeaders(args, s3_configuration.headers_from_ast, context);
         if (header_it != args.end())
             args.erase(header_it);
 
@@ -87,7 +87,7 @@ void TableFunctionS3::parseArgumentsImpl(const String & error_message, ASTs & ar
         }
 
         /// This argument is always the first
-        s3_configuration.url = checkAndGetLiteralArgument<String>(args[0], "url");
+        s3_configuration.url = S3::URI(checkAndGetLiteralArgument<String>(args[0], "url"));
 
         if (args_to_idx.contains("format"))
             s3_configuration.format = checkAndGetLiteralArgument<String>(args[args_to_idx["format"]], "format");
@@ -106,7 +106,7 @@ void TableFunctionS3::parseArgumentsImpl(const String & error_message, ASTs & ar
     }
 
     if (s3_configuration.format == "auto")
-        s3_configuration.format = FormatFactory::instance().getFormatFromFileName(s3_configuration.url, true);
+        s3_configuration.format = FormatFactory::instance().getFormatFromFileName(s3_configuration.url.uri.getPath(), true);
 }
 
 void TableFunctionS3::parseArguments(const ASTPtr & ast_function, ContextPtr context)
diff --git a/src/TableFunctions/TableFunctionS3.h b/src/TableFunctions/TableFunctionS3.h
index 125238fa7db..2adddef538c 100644
--- a/src/TableFunctions/TableFunctionS3.h
+++ b/src/TableFunctions/TableFunctionS3.h
@@ -5,7 +5,7 @@
 #if USE_AWS_S3
 
 #include <TableFunctions/ITableFunction.h>
-#include <Storages/ExternalDataSourceConfiguration.h>
+#include <Storages/StorageS3.h>
 
 
 namespace DB
@@ -51,9 +51,9 @@ protected:
     ColumnsDescription getActualTableStructure(ContextPtr context) const override;
     void parseArguments(const ASTPtr & ast_function, ContextPtr context) override;
 
-    static void parseArgumentsImpl(const String & error_message, ASTs & args, ContextPtr context, StorageS3Configuration & configuration);
+    static void parseArgumentsImpl(const String & error_message, ASTs & args, ContextPtr context, StorageS3::Configuration & configuration);
 
-    StorageS3Configuration configuration;
+    mutable StorageS3::Configuration configuration;
     ColumnsDescription structure_hint;
 };
 
diff --git a/src/TableFunctions/TableFunctionS3Cluster.cpp b/src/TableFunctions/TableFunctionS3Cluster.cpp
index 9572d67c720..9dc49d3c4f8 100644
--- a/src/TableFunctions/TableFunctionS3Cluster.cpp
+++ b/src/TableFunctions/TableFunctionS3Cluster.cpp
@@ -2,7 +2,6 @@
 
 #if USE_AWS_S3
 
-#include <Storages/StorageS3Cluster.h>
 #include <Storages/StorageS3.h>
 #include <Storages/checkAndGetLiteralArgument.h>
 
@@ -73,8 +72,8 @@ void TableFunctionS3Cluster::parseArguments(const ASTPtr & ast_function, Context
     clipped_args.reserve(args.size());
     std::copy(args.begin() + 1, args.end(), std::back_inserter(clipped_args));
 
-    /// StorageS3ClusterConfiguration inherints from StorageS3Configuration, so it is safe to upcast it.
-    TableFunctionS3::parseArgumentsImpl(message.text, clipped_args, context, static_cast<StorageS3Configuration & >(configuration));
+    /// StorageS3ClusterConfiguration inherints from StorageS3::Configuration, so it is safe to upcast it.
+    TableFunctionS3::parseArgumentsImpl(message.text, clipped_args, context, static_cast<StorageS3::Configuration & >(configuration));
 }
 
 
diff --git a/src/TableFunctions/TableFunctionS3Cluster.h b/src/TableFunctions/TableFunctionS3Cluster.h
index 42dbfe2ec23..17df8999470 100644
--- a/src/TableFunctions/TableFunctionS3Cluster.h
+++ b/src/TableFunctions/TableFunctionS3Cluster.h
@@ -5,7 +5,7 @@
 #if USE_AWS_S3
 
 #include <TableFunctions/ITableFunction.h>
-#include <Storages/ExternalDataSourceConfiguration.h>
+#include <Storages/StorageS3Cluster.h>
 
 
 namespace DB
@@ -50,7 +50,7 @@ protected:
     ColumnsDescription getActualTableStructure(ContextPtr) const override;
     void parseArguments(const ASTPtr &, ContextPtr) override;
 
-    StorageS3ClusterConfiguration configuration;
+    mutable StorageS3Cluster::Configuration configuration;
     ColumnsDescription structure_hint;
 };
 

From b90411f323ca7c9980e48d44ec5eea0873411b45 Mon Sep 17 00:00:00 2001
From: MeenaRenganathan22 <Meena.Renganathan@ibm.com>
Date: Mon, 6 Feb 2023 10:24:54 -0500
Subject: [PATCH 55/79] Fix the indentation

---
 .gitmodules | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitmodules b/.gitmodules
index 039d4f042f8..b4673f113b7 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -58,7 +58,7 @@
 	url = https://github.com/apache/thrift
 [submodule "contrib/libhdfs3"]
 	path = contrib/libhdfs3
-        url = https://github.com/ClickHouse/libhdfs3
+	url = https://github.com/ClickHouse/libhdfs3
 [submodule "contrib/libxml2"]
 	path = contrib/libxml2
 	url = https://github.com/GNOME/libxml2

From eb760413125fbfc1679c19e8cb26647cb1847374 Mon Sep 17 00:00:00 2001
From: Han Fei <hanfei19910905@gmail.com>
Date: Mon, 6 Feb 2023 17:26:20 +0100
Subject: [PATCH 56/79] address comments and add one more test

---
 src/Dictionaries/RegExpTreeDictionary.cpp     | 19 +++++++++++--------
 ...04_regexp_dictionary_yaml_source.reference |  2 ++
 .../02504_regexp_dictionary_yaml_source.sh    | 19 ++++++++++++++++++-
 3 files changed, 31 insertions(+), 9 deletions(-)

diff --git a/src/Dictionaries/RegExpTreeDictionary.cpp b/src/Dictionaries/RegExpTreeDictionary.cpp
index ca1fc4e48bc..8f82e642462 100644
--- a/src/Dictionaries/RegExpTreeDictionary.cpp
+++ b/src/Dictionaries/RegExpTreeDictionary.cpp
@@ -157,10 +157,10 @@ namespace
     /// hyper scan is not good at processing regex containing {0, 200}
     /// This will make re compilation slow and failed. So we select this heavy regular expressions and
     /// process it with re2.
-    struct ComplexRegexChecker
+    struct RegexChecker
     {
         re2_st::RE2 searcher;
-        ComplexRegexChecker() : searcher(R"(\{([\d]+),([\d]+)\})") {}
+        RegexChecker() : searcher(R"(\{([\d]+),([\d]+)\})") {}
 
         static bool isFigureLargerThanFifty(const String & str)
         try
@@ -174,15 +174,15 @@ namespace
         }
 
         [[maybe_unused]]
-        bool check(const String & data) const
+        bool isSimpleRegex(const String & regex) const
         {
 
-            re2_st::StringPiece haystack(data.data(), data.size());
+            re2_st::StringPiece haystack(regex.data(), regex.size());
             re2_st::StringPiece matches[10];
             size_t start_pos = 0;
-            while (start_pos < data.size())
+            while (start_pos < regex.size())
             {
-                if (searcher.Match(haystack, start_pos, data.size(), re2_st::RE2::Anchor::UNANCHORED, matches, 10))
+                if (searcher.Match(haystack, start_pos, regex.size(), re2_st::RE2::Anchor::UNANCHORED, matches, 10))
                 {
                     const auto & match = matches[0];
                     start_pos += match.length();
@@ -207,7 +207,7 @@ void RegExpTreeDictionary::initRegexNodes(Block & block)
     auto keys_column = block.getByName(kKeys).column;
     auto values_column = block.getByName(kValues).column;
 
-    ComplexRegexChecker checker;
+    RegexChecker checker;
 
     size_t size = block.rows();
     for (size_t i = 0; i < size; i++)
@@ -253,7 +253,7 @@ void RegExpTreeDictionary::initRegexNodes(Block & block)
         }
         regex_nodes.emplace(id, node);
 #if USE_VECTORSCAN
-        if (use_vectorscan && !checker.check(regex))
+        if (use_vectorscan && !checker.isSimpleRegex(regex))
         {
             simple_regexps.push_back(regex);
             regexp_ids.push_back(id);
@@ -312,6 +312,9 @@ void RegExpTreeDictionary::loadData()
         if (simple_regexps.empty() && complex_regexp_nodes.empty())
             throw Exception(ErrorCodes::INCORRECT_DICTIONARY_DEFINITION, "There are no available regular expression. Please check your config");
         LOG_INFO(logger, "There are {} simple regexps and {} complex regexps", simple_regexps.size(), complex_regexp_nodes.size());
+        /// If all the regexps cannot work with hyperscan, we should set this flag off to avoid exceptions.
+        if (simple_regexps.empty())
+            use_vectorscan = false;
         if (!use_vectorscan)
             return;
         #if USE_VECTORSCAN
diff --git a/tests/queries/0_stateless/02504_regexp_dictionary_yaml_source.reference b/tests/queries/0_stateless/02504_regexp_dictionary_yaml_source.reference
index 6d5372cc484..dfcd170e8f4 100644
--- a/tests/queries/0_stateless/02504_regexp_dictionary_yaml_source.reference
+++ b/tests/queries/0_stateless/02504_regexp_dictionary_yaml_source.reference
@@ -2,4 +2,6 @@
 ('Android','12')
 ('Android','default')
 ('Android','default')
+('BlackBerry WebKit','10.0')
+('BlackBerry WebKit','1.0')
 (true,'61f0c404-5cb3-11e7-907b-a6006ad3dba0','2023-01-01','2023-01-01 01:01:01',[1,2,3,-1,-2,-3])
diff --git a/tests/queries/0_stateless/02504_regexp_dictionary_yaml_source.sh b/tests/queries/0_stateless/02504_regexp_dictionary_yaml_source.sh
index 8d80f9f1fea..1b5a9cdeea4 100755
--- a/tests/queries/0_stateless/02504_regexp_dictionary_yaml_source.sh
+++ b/tests/queries/0_stateless/02504_regexp_dictionary_yaml_source.sh
@@ -42,7 +42,8 @@ create dictionary regexp_dict1
 PRIMARY KEY(regexp)
 SOURCE(YAMLRegExpTree(PATH '$yaml'))
 LIFETIME(0)
-LAYOUT(regexp_tree);
+LAYOUT(regexp_tree)
+SETTINGS(regexp_dict_allow_hyperscan = true);
 
 select dictGet('regexp_dict1', ('name', 'version'), 'Linux/123.45.67 tlinux');
 select dictGet('regexp_dict1', ('name', 'version'), '31/tclwebkit1024');
@@ -84,6 +85,22 @@ EOL
 $CLICKHOUSE_CLIENT -n --query="
 system reload dictionary regexp_dict1; -- { serverError 318 }
 "
+
+cat > "$yaml" <<EOL
+- name: BlackBerry WebKit
+  regexp: (PlayBook).{1,200}RIM Tablet OS (\d+)\.(\d+)\.(\d+)
+  version: '\2.\3'
+- name: BlackBerry WebKit
+  regexp: (Black[bB]erry|BB10).{1,200}Version/(\d+)\.(\d+)\.(\d+)
+  version: '\2.\3'
+EOL
+
+$CLICKHOUSE_CLIENT -n --query="
+system reload dictionary regexp_dict1;
+select dictGet('regexp_dict1', ('name', 'version'), 'Mozilla/5.0 (BB10; Touch) AppleWebKit/537.3+ (KHTML, like Gecko) Version/10.0.9.388 Mobile Safari/537.3+');
+select dictGet('regexp_dict1', ('name', 'version'), 'Mozilla/5.0 (PlayBook; U; RIM Tablet OS 1.0.0; en-US) AppleWebKit/534.8+ (KHTML, like Gecko) Version/0.0.1 Safari/534.8+');
+"
+
 cat > "$yaml" <<EOL
 - regexp: 'abc'
   col_bool: 'true'

From e433c26cf9b6dcdfa50e688d76d8c2430339a890 Mon Sep 17 00:00:00 2001
From: Yakov Olkhovskiy <yakov@clickhouse.com>
Date: Mon, 6 Feb 2023 16:30:18 +0000
Subject: [PATCH 57/79] allow bloom filter for IPv4 and IPv6

---
 src/Interpreters/BloomFilterHash.h             |  4 ++++
 .../MergeTree/MergeTreeIndexBloomFilter.cpp    |  3 ++-
 .../0_stateless/02559_ip_types_bloom.reference |  1 +
 .../0_stateless/02559_ip_types_bloom.sql       | 18 ++++++++++++++++++
 4 files changed, 25 insertions(+), 1 deletion(-)
 create mode 100644 tests/queries/0_stateless/02559_ip_types_bloom.reference
 create mode 100644 tests/queries/0_stateless/02559_ip_types_bloom.sql

diff --git a/src/Interpreters/BloomFilterHash.h b/src/Interpreters/BloomFilterHash.h
index 88feeb5b3df..a340fe29ab4 100644
--- a/src/Interpreters/BloomFilterHash.h
+++ b/src/Interpreters/BloomFilterHash.h
@@ -94,6 +94,8 @@ struct BloomFilterHash
         else if (which.isFloat32()) return build_hash_column(getNumberTypeHash<Float64, Float64>(field));
         else if (which.isFloat64()) return build_hash_column(getNumberTypeHash<Float64, Float64>(field));
         else if (which.isUUID()) return build_hash_column(getNumberTypeHash<UUID, UUID>(field));
+        else if (which.isIPv4()) return build_hash_column(getNumberTypeHash<IPv4, IPv4>(field));
+        else if (which.isIPv6()) return build_hash_column(getNumberTypeHash<IPv6, IPv6>(field));
         else if (which.isString()) return build_hash_column(getStringTypeHash(field));
         else if (which.isFixedString()) return build_hash_column(getFixedStringTypeHash(field, data_type));
         else throw Exception(ErrorCodes::BAD_ARGUMENTS, "Unexpected type {} of bloom filter index.", data_type->getName());
@@ -156,6 +158,8 @@ struct BloomFilterHash
         else if (which.isFloat32()) getNumberTypeHash<Float32, is_first>(column, vec, pos);
         else if (which.isFloat64()) getNumberTypeHash<Float64, is_first>(column, vec, pos);
         else if (which.isUUID()) getNumberTypeHash<UUID, is_first>(column, vec, pos);
+        else if (which.isIPv4()) getNumberTypeHash<IPv4, is_first>(column, vec, pos);
+        else if (which.isIPv6()) getNumberTypeHash<IPv6, is_first>(column, vec, pos);
         else if (which.isString()) getStringTypeHash<is_first>(column, vec, pos);
         else if (which.isFixedString()) getStringTypeHash<is_first>(column, vec, pos);
         else throw Exception(ErrorCodes::BAD_ARGUMENTS, "Unexpected type {} of bloom filter index.", data_type->getName());
diff --git a/src/Storages/MergeTree/MergeTreeIndexBloomFilter.cpp b/src/Storages/MergeTree/MergeTreeIndexBloomFilter.cpp
index 7a8a28b24aa..b3e6ec6ec10 100644
--- a/src/Storages/MergeTree/MergeTreeIndexBloomFilter.cpp
+++ b/src/Storages/MergeTree/MergeTreeIndexBloomFilter.cpp
@@ -88,7 +88,8 @@ static void assertIndexColumnsType(const Block & header)
         WhichDataType which(actual_type);
 
         if (!which.isUInt() && !which.isInt() && !which.isString() && !which.isFixedString() && !which.isFloat() &&
-            !which.isDate() && !which.isDateTime() && !which.isDateTime64() && !which.isEnum() && !which.isUUID())
+            !which.isDate() && !which.isDateTime() && !which.isDateTime64() && !which.isEnum() && !which.isUUID() &&
+            !which.isIPv4() && !which.isIPv6())
             throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Unexpected type {} of bloom filter index.", type->getName());
     }
 }
diff --git a/tests/queries/0_stateless/02559_ip_types_bloom.reference b/tests/queries/0_stateless/02559_ip_types_bloom.reference
new file mode 100644
index 00000000000..7a76aeeff8e
--- /dev/null
+++ b/tests/queries/0_stateless/02559_ip_types_bloom.reference
@@ -0,0 +1 @@
+1	1.1.1.1	::1
diff --git a/tests/queries/0_stateless/02559_ip_types_bloom.sql b/tests/queries/0_stateless/02559_ip_types_bloom.sql
new file mode 100644
index 00000000000..b3fc16debd9
--- /dev/null
+++ b/tests/queries/0_stateless/02559_ip_types_bloom.sql
@@ -0,0 +1,18 @@
+DROP TABLE IF EXISTS ip_bloom;
+
+CREATE TABLE ip_bloom
+(
+    `a` UInt32,
+    `ip4` Nullable(IPv4),
+    `ip6` Nullable(IPv6),
+    INDEX x4 ip4 TYPE bloom_filter(0.1) GRANULARITY 3,
+    INDEX x6 ip6 TYPE bloom_filter(0.1) GRANULARITY 3
+)
+ENGINE = MergeTree
+ORDER BY a;
+
+INSERT INTO ip_bloom VALUES (1, '1.1.1.1', '::1');
+
+SELECT * FROM ip_bloom;
+
+DROP TABLE ip_bloom;

From d1d893275a862830546e34ae567cb253bfbd5bb3 Mon Sep 17 00:00:00 2001
From: Han Fei <hanfei19910905@gmail.com>
Date: Mon, 6 Feb 2023 18:46:23 +0100
Subject: [PATCH 58/79] fix

---
 src/Dictionaries/RegExpTreeDictionary.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/Dictionaries/RegExpTreeDictionary.cpp b/src/Dictionaries/RegExpTreeDictionary.cpp
index 8f82e642462..fdda2cd407d 100644
--- a/src/Dictionaries/RegExpTreeDictionary.cpp
+++ b/src/Dictionaries/RegExpTreeDictionary.cpp
@@ -189,12 +189,12 @@ namespace
                     const auto & match1 = matches[1];
                     const auto & match2 = matches[2];
                     if (isFigureLargerThanFifty(match1.ToString()) || isFigureLargerThanFifty(match2.ToString()))
-                        return true;
+                        return false;
                 }
                 else
                     break;
             }
-            return false;
+            return true;
         }
     };
 }
@@ -253,7 +253,7 @@ void RegExpTreeDictionary::initRegexNodes(Block & block)
         }
         regex_nodes.emplace(id, node);
 #if USE_VECTORSCAN
-        if (use_vectorscan && !checker.isSimpleRegex(regex))
+        if (use_vectorscan && checker.isSimpleRegex(regex))
         {
             simple_regexps.push_back(regex);
             regexp_ids.push_back(id);

From ad3b4da4884a8b29a5a7afc089b06ad4f9fac77b Mon Sep 17 00:00:00 2001
From: Azat Khuzhin <a3at.mail@gmail.com>
Date: Mon, 6 Feb 2023 19:45:02 +0100
Subject: [PATCH 59/79] Add also last messages from stdout/stderr/debuglog in
 clickhouse-test

First lines not very helpful usually, since the problem usually happens
at the end [1], though some tricky stuff may happens at the beginning,
so let's output both.

  [1]: https://s3.amazonaws.com/clickhouse-test-reports/45654/1716af465d376f5335720b5045bcccdd9e1823aa/fast_test.html

Signed-off-by: Azat Khuzhin <a.khuzhin@semrush.com>
---
 tests/clickhouse-test | 22 +++++++++++++++-------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/tests/clickhouse-test b/tests/clickhouse-test
index 4361b64b62f..b52c6c58946 100755
--- a/tests/clickhouse-test
+++ b/tests/clickhouse-test
@@ -71,6 +71,13 @@ def stringhash(s):
     return zlib.crc32(s.encode("utf-8"))
 
 
+def trim_for_log(s):
+    if not s:
+        return s
+    lines = s.splitlines()
+    return "\n".join(lines[:50] + ["#" * 100] + lines[-50:])
+
+
 class HTTPError(Exception):
     def __init__(self, message=None, code=None):
         self.message = message
@@ -870,8 +877,7 @@ class TestCase:
     ):
         description = ""
 
-        if debug_log:
-            debug_log = "\n".join(debug_log.splitlines()[:100])
+        debug_log = trim_for_log(debug_log)
 
         if proc:
             if proc.returncode is None:
@@ -921,9 +927,7 @@ class TestCase:
 
                 if os.path.isfile(self.stdout_file):
                     description += ", result:\n\n"
-                    description += "\n".join(
-                        open(self.stdout_file).read().splitlines()[:100]
-                    )
+                    description += trim_for_log(open(self.stdout_file).read())
                     description += "\n"
 
                 description += f"\nstdout:\n{stdout}\n"
@@ -932,7 +936,9 @@ class TestCase:
                 )
 
         if stderr:
-            description += "\n{}\n".format("\n".join(stderr.splitlines()[:100]))
+            description += "\n"
+            description += trim_for_log(stderr)
+            description += "\n"
             description += f"\nstdout:\n{stdout}\n"
             if debug_log:
                 description += "\n"
@@ -946,7 +952,9 @@ class TestCase:
             )
 
         if "Exception" in stdout:
-            description += "\n{}\n".format("\n".join(stdout.splitlines()[:100]))
+            description += "\n"
+            description += trim_for_log(stdout)
+            description += "\n"
             if debug_log:
                 description += "\n"
                 description += debug_log

From 6a389eef32cc7ae3668e1af5e87f2c9550d1b5f7 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Mon, 6 Feb 2023 22:27:46 +0300
Subject: [PATCH 60/79] Add a comment

---
 tests/clickhouse-test | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/clickhouse-test b/tests/clickhouse-test
index b52c6c58946..a65662440f6 100755
--- a/tests/clickhouse-test
+++ b/tests/clickhouse-test
@@ -71,6 +71,7 @@ def stringhash(s):
     return zlib.crc32(s.encode("utf-8"))
 
 
+# First and last lines of the log
 def trim_for_log(s):
     if not s:
         return s

From 7dfea59267eb6ec837753676ac7cd98de8d624cd Mon Sep 17 00:00:00 2001
From: Anton Popov <anton@clickhouse.com>
Date: Tue, 7 Feb 2023 00:50:41 +0000
Subject: [PATCH 61/79] remove an assertion

---
 src/Storages/MergeTree/MergeTreeDataPartWriterWide.cpp | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/src/Storages/MergeTree/MergeTreeDataPartWriterWide.cpp b/src/Storages/MergeTree/MergeTreeDataPartWriterWide.cpp
index cf19f958b4c..f9fe6f2c8ab 100644
--- a/src/Storages/MergeTree/MergeTreeDataPartWriterWide.cpp
+++ b/src/Storages/MergeTree/MergeTreeDataPartWriterWide.cpp
@@ -484,14 +484,6 @@ void MergeTreeDataPartWriterWide::validateColumnOfFixedSize(const NameAndTypePai
                             column->size(), mark_num, index_granularity.getMarksCount(), index_granularity_rows);
         }
 
-        if (!settings.blocks_are_granules_size && index_granularity_rows > data_part->index_granularity_info.fixed_index_granularity)
-        {
-            throw Exception(ErrorCodes::LOGICAL_ERROR,
-                            "Mark #{} has {} rows, but max fixed granularity is {}, index granularity size {}",
-                            mark_num, index_granularity_rows, data_part->index_granularity_info.fixed_index_granularity,
-                            index_granularity.getMarksCount());
-        }
-
         if (index_granularity_rows != index_granularity.getMarkRows(mark_num))
         {
             throw Exception(

From 427f2d02578007ad92a5a87f40979ff76c1890f4 Mon Sep 17 00:00:00 2001
From: kssenii <sumarokovakseniia@mail.ru>
Date: Tue, 7 Feb 2023 12:36:25 +0100
Subject: [PATCH 62/79] Try fix rabbit test

---
 tests/integration/test_storage_rabbitmq/test.py | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/tests/integration/test_storage_rabbitmq/test.py b/tests/integration/test_storage_rabbitmq/test.py
index f354ae01714..030d9507d4f 100644
--- a/tests/integration/test_storage_rabbitmq/test.py
+++ b/tests/integration/test_storage_rabbitmq/test.py
@@ -1031,9 +1031,9 @@ def test_rabbitmq_overloaded_insert(rabbitmq_cluster):
                      rabbitmq_exchange_name = 'over',
                      rabbitmq_queue_base = 'over',
                      rabbitmq_exchange_type = 'direct',
-                     rabbitmq_num_consumers = 3,
+                     rabbitmq_num_consumers = 2,
                      rabbitmq_flush_interval_ms=1000,
-                     rabbitmq_max_block_size = 100,
+                     rabbitmq_max_block_size = 1000,
                      rabbitmq_num_queues = 2,
                      rabbitmq_routing_key_list = 'over',
                      rabbitmq_format = 'TSV',
@@ -1045,13 +1045,12 @@ def test_rabbitmq_overloaded_insert(rabbitmq_cluster):
                      rabbitmq_exchange_type = 'direct',
                      rabbitmq_routing_key_list = 'over',
                      rabbitmq_flush_interval_ms=1000,
-                     rabbitmq_max_block_size = 100,
+                     rabbitmq_max_block_size = 1000,
                      rabbitmq_format = 'TSV',
                      rabbitmq_row_delimiter = '\\n';
         CREATE TABLE test.view_overload (key UInt64, value UInt64)
             ENGINE = MergeTree
-            ORDER BY key
-            SETTINGS old_parts_lifetime=5, cleanup_delay_period=2, cleanup_delay_period_random_add=3;
+            ORDER BY key;
         CREATE MATERIALIZED VIEW test.consumer_overload TO test.view_overload AS
             SELECT * FROM test.rabbitmq_consume;
     """
@@ -1080,7 +1079,7 @@ def test_rabbitmq_overloaded_insert(rabbitmq_cluster):
                     raise
 
     threads = []
-    threads_num = 3
+    threads_num = 2
     for _ in range(threads_num):
         threads.append(threading.Thread(target=insert))
     for thread in threads:
@@ -1089,11 +1088,11 @@ def test_rabbitmq_overloaded_insert(rabbitmq_cluster):
 
     while True:
         result = instance.query("SELECT count() FROM test.view_overload")
-        time.sleep(1)
         expected = messages_num * threads_num
         if int(result) == expected:
             break
         print(f"Result: {result} / {expected}")
+        time.sleep(1)
 
     instance.query(
         """

From 9485873a2f4697000a00230ec11332c8d8a97235 Mon Sep 17 00:00:00 2001
From: kssenii <sumarokovakseniia@mail.ru>
Date: Tue, 7 Feb 2023 12:45:23 +0100
Subject: [PATCH 63/79] Fix integration test

---
 src/Storages/StorageS3.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/Storages/StorageS3.cpp b/src/Storages/StorageS3.cpp
index 8ad02cb7319..40ddc09adaf 100644
--- a/src/Storages/StorageS3.cpp
+++ b/src/Storages/StorageS3.cpp
@@ -1332,6 +1332,7 @@ StorageS3::Configuration StorageS3::getConfiguration(ASTs & engine_args, Context
             configuration.format = checkAndGetLiteralArgument<String>(engine_args.back(), "format");
         }
     }
+    configuration.static_configuration = !configuration.auth_settings.access_key_id.empty();
 
     if (configuration.format == "auto")
         configuration.format = FormatFactory::instance().getFormatFromFileName(configuration.url.key, true);

From fe832c4418d4753fa461da80b5e84dae739215e0 Mon Sep 17 00:00:00 2001
From: Azat Khuzhin <a3at.mail@gmail.com>
Date: Tue, 7 Feb 2023 12:04:16 +0100
Subject: [PATCH 64/79] Fix TOCTOU while checking for container existence in
 azure_blob_storage

This is a simple time-of-check vs time-of-use, since between checking
does such container exist and creating one, there is a time window.

Signed-off-by: Azat Khuzhin <a.khuzhin@semrush.com>
---
 .../AzureBlobStorage/AzureBlobStorageAuth.cpp | 28 ++++++++++---------
 1 file changed, 15 insertions(+), 13 deletions(-)

diff --git a/src/Disks/ObjectStorages/AzureBlobStorage/AzureBlobStorageAuth.cpp b/src/Disks/ObjectStorages/AzureBlobStorage/AzureBlobStorageAuth.cpp
index 4756a2b11f1..61fa4af100e 100644
--- a/src/Disks/ObjectStorages/AzureBlobStorage/AzureBlobStorageAuth.cpp
+++ b/src/Disks/ObjectStorages/AzureBlobStorage/AzureBlobStorageAuth.cpp
@@ -2,6 +2,7 @@
 
 #if USE_AZURE_BLOB_STORAGE
 
+#include <Common/Exception.h>
 #include <optional>
 #include <re2/re2.h>
 #include <azure/identity/managed_identity_credential.hpp>
@@ -125,21 +126,22 @@ std::unique_ptr<BlobContainerClient> getAzureBlobContainerClient(
 
     auto blob_service_client = getAzureBlobStorageClientWithAuth<BlobServiceClient>(endpoint.storage_account_url, container_name, config, config_prefix);
 
-    if (!endpoint.container_already_exists.has_value())
+    try
     {
-        ListBlobContainersOptions blob_containers_list_options;
-        blob_containers_list_options.Prefix = container_name;
-        blob_containers_list_options.PageSizeHint = 1;
-        auto blob_containers = blob_service_client->ListBlobContainers().BlobContainers;
-        for (const auto & blob_container : blob_containers)
-        {
-            if (blob_container.Name == endpoint.container_name)
-                return getAzureBlobStorageClientWithAuth<BlobContainerClient>(final_url, container_name, config, config_prefix);
-        }
+        return std::make_unique<BlobContainerClient>(
+            blob_service_client->CreateBlobContainer(container_name).Value);
+    }
+    catch (const Azure::Storage::StorageException & e)
+    {
+        /// If container_already_exists is not set (in config), ignore already exists error.
+        /// (Conflict - The specified container already exists)
+        if (!endpoint.container_already_exists.has_value() && e.StatusCode == Azure::Core::Http::HttpStatusCode::Conflict)
+        {
+            tryLogCurrentException("Container already exist, return existing container");
+            return getAzureBlobStorageClientWithAuth<BlobContainerClient>(final_url, container_name, config, config_prefix);
+        }
+        throw;
     }
-
-    return std::make_unique<BlobContainerClient>(
-        blob_service_client->CreateBlobContainer(container_name).Value);
 }
 
 std::unique_ptr<AzureObjectStorageSettings> getAzureBlobStorageSettings(const Poco::Util::AbstractConfiguration & config, const String & config_prefix, ContextPtr /*context*/)

From bca85c685286f526843c85adba03ddc0a8ee7da3 Mon Sep 17 00:00:00 2001
From: Azat Khuzhin <a3at.mail@gmail.com>
Date: Tue, 7 Feb 2023 12:27:23 +0100
Subject: [PATCH 65/79] Fix
 test_merge_tree_azure_blob_storage::test_zero_copy_replication test

Here is an example of an error [1]:

    2023.02.06 21:59:09.076849 [ 200 ] {} <Information> DiskObjectStorage(DiskAzureBlobStorage): Starting up disk blob_storage_disk
    2023.02.06 21:59:09.076897 [ 200 ] {} <Information> DiskObjectStorage(DiskAzureBlobStorage): Disk blob_storage_disk started up
    2023.02.06 21:59:09.077263 [ 200 ] {} <Trace> StoragePolicy (blob_storage_policy): Storage policy blob_storage_policy created, total volumes 1
    2023.02.06 21:59:09.077318 [ 200 ] {} <Information> StoragePolicySelector: Storage policy `blob_storage_policy` loaded
    ...
    2023.02.06 21:59:09.227326 [ 1 ] {} <Error> Application: std::exception. Code: 1001, type: Azure::Storage::StorageException, e.what() = 409 The specified container already exists.
    The specified container already exists.
    RequestId:73d54dcf-0c66-489c-b9b8-2b5398df9384
    Time:2023-02-06T21:59:08.225Z
    Request ID: 73d54dcf-0c66-489c-b9b8-2b5398df9384, Stack trace (when copying this message, always include the lines below):

    0. ./build_docker/../contrib/llvm-project/libcxx/include/exception:134: std::runtime_error::runtime_error() @ 0x44297b8d in /usr/bin/clickhouse
    ...
    5. ./build_docker/../contrib/llvm-project/libcxx/include/__memory/unique_ptr.h:714: DB::getAzureBlobContainerClient() @ 0x2f5b225f in /usr/bin/clickhouse
    6. ./build_docker/../src/Disks/ObjectStorages/AzureBlobStorage/registerDiskAzureBlobStorage.cpp:0:
    10. ./build_docker/../src/Interpreters/Context.cpp:0: DB::Context::getDisksMap() const @ 0x2f95af47 in /usr/bin/clickhouse
    ...
    13. ./build_docker/../contrib/llvm-project/libcxx/include/__memory/unique_ptr.h:714: DB::AsynchronousMetrics::start() @ 0x1f4d6161 in /usr/bin/clickhouse
    14. ./build_docker/../programs/server/Server.cpp:0: DB::Server::main() @ 0x1f3a5bfb in /usr/bin/clickhouse
    15. ./build_docker/../contrib/poco/Util/src/Application.cpp:0: Poco::Util::Application::run() @ 0x3c7546bf in /usr/bin/clickhouse
    16. ./build_docker/../programs/server/Server.cpp:476: DB::Server::run() @ 0x1f381f7b in /usr/bin/clickhouse
    17. ./build_docker/../contrib/poco/Util/src/ServerApplication.cpp:612: Poco::Util::ServerApplication::run(int, char**) @ 0x3c797ee0 in /usr/bin/clickhouse
    18. ./build_docker/../programs/server/Server.cpp:0: mainEntryClickHouseServer(int, char**) @ 0x1f37a262 in /usr/bin/clickhouse
    19. ./build_docker/../programs/main.cpp:0: main @ 0xe9d21ae in /usr/bin/clickhouse
    20. __libc_start_main @ 0x7f58271a1083 in ?
    21. _start @ 0xe90ef6e in /usr/bin/clickhouse
     (version 23.2.1.1)
    2023.02.06 21:59:09.227971 [ 1 ] {} <Error> Application: 409 The specified container already exists.
    The specified container already exists.
    RequestId:73d54dcf-0c66-489c-b9b8-2b5398df9384
    Time:2023-02-06T21:59:08.225Z
    Request ID: 73d54dcf-0c66-489c-b9b8-2b5398df9384

  [1]: https://s3.amazonaws.com/clickhouse-test-reports/46045/bd4170e03c6af583a51d12d2c39fa775dcb9997b/integration_tests__asan__[6/6].html

Signed-off-by: Azat Khuzhin <a.khuzhin@semrush.com>
---
 .../configs/config.d/storage_conf.xml                        | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/integration/test_merge_tree_azure_blob_storage/configs/config.d/storage_conf.xml b/tests/integration/test_merge_tree_azure_blob_storage/configs/config.d/storage_conf.xml
index 1440160b857..07f57c08e32 100644
--- a/tests/integration/test_merge_tree_azure_blob_storage/configs/config.d/storage_conf.xml
+++ b/tests/integration/test_merge_tree_azure_blob_storage/configs/config.d/storage_conf.xml
@@ -5,12 +5,15 @@
                 <type>azure_blob_storage</type>
                 <storage_account_url>http://azurite1:10000/devstoreaccount1</storage_account_url>
                 <container_name>cont</container_name>
-                <container_already_exists>false</container_already_exists>
                 <skip_access_check>false</skip_access_check>
                 <!-- default credentials for Azurite storage account -->
                 <account_name>devstoreaccount1</account_name>
                 <account_key>Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==</account_key>
                 <max_single_part_upload_size>100000</max_single_part_upload_size>
+                <!-- NOTE: container_already_exists is omitted to:
+                  a) create it
+                  b) ignore if it already exists, since there are two instances, that conflicts with each other
+                -->
             </blob_storage_disk>
             <hdd>
                  <type>local</type>

From 022d4308ced7d429f8526e7a1edc5b37e2c2c2af Mon Sep 17 00:00:00 2001
From: kssenii <sumarokovakseniia@mail.ru>
Date: Tue, 7 Feb 2023 13:01:15 +0100
Subject: [PATCH 66/79] Address review comments

---
 .../configs/users.d/users.xml                     | 10 ++++++++++
 tests/integration/test_grant_and_revoke/test.py   | 15 +++++++++------
 ..._no_default_access_with_access_management.xml} |  0
 tests/integration/test_named_collections/test.py  |  2 +-
 4 files changed, 20 insertions(+), 7 deletions(-)
 create mode 100644 tests/integration/test_grant_and_revoke/configs/users.d/users.xml
 rename tests/integration/test_named_collections/configs/users.d/{users_no_default_access2.xml => users_no_default_access_with_access_management.xml} (100%)

diff --git a/tests/integration/test_grant_and_revoke/configs/users.d/users.xml b/tests/integration/test_grant_and_revoke/configs/users.d/users.xml
new file mode 100644
index 00000000000..fb5e2028d6e
--- /dev/null
+++ b/tests/integration/test_grant_and_revoke/configs/users.d/users.xml
@@ -0,0 +1,10 @@
+<clickhouse>
+    <users>
+        <default>
+            <password></password>
+            <profile>default</profile>
+            <quota>default</quota>
+            <show_named_collections>1</show_named_collections>
+        </default>
+    </users>
+</clickhouse>
diff --git a/tests/integration/test_grant_and_revoke/test.py b/tests/integration/test_grant_and_revoke/test.py
index a04002b2ddc..6011c4379fe 100644
--- a/tests/integration/test_grant_and_revoke/test.py
+++ b/tests/integration/test_grant_and_revoke/test.py
@@ -3,7 +3,12 @@ from helpers.cluster import ClickHouseCluster
 from helpers.test_tools import TSV
 
 cluster = ClickHouseCluster(__file__)
-instance = cluster.add_instance("instance")
+instance = cluster.add_instance(
+    "instance",
+    user_configs=[
+        "configs/users.d/users.xml",
+    ],
+)
 
 
 @pytest.fixture(scope="module", autouse=True)
@@ -377,8 +382,6 @@ def test_introspection():
     instance.query("GRANT SELECT ON test.table TO A")
     instance.query("GRANT CREATE ON *.* TO B WITH GRANT OPTION")
 
-    all_access_except_show_named_collections = "SHOW, SELECT, INSERT, ALTER, CREATE, DROP, TRUNCATE, OPTIMIZE, BACKUP, KILL QUERY, KILL TRANSACTION, MOVE PARTITION BETWEEN SHARDS, CREATE USER, ALTER USER, DROP USER, CREATE ROLE, ALTER ROLE, DROP ROLE, ROLE ADMIN, CREATE ROW POLICY, ALTER ROW POLICY, DROP ROW POLICY, CREATE QUOTA, ALTER QUOTA, DROP QUOTA, CREATE SETTINGS PROFILE, ALTER SETTINGS PROFILE, DROP SETTINGS PROFILE, SHOW ACCESS, SYSTEM, dictGet, INTROSPECTION, SOURCES, CLUSTER"
-
     assert instance.query("SHOW USERS") == TSV(["A", "B", "default"])
     assert instance.query("SHOW CREATE USERS A") == TSV(["CREATE USER A"])
     assert instance.query("SHOW CREATE USERS B") == TSV(["CREATE USER B"])
@@ -415,7 +418,7 @@ def test_introspection():
         [
             "GRANT SELECT ON test.table TO A",
             "GRANT CREATE ON *.* TO B WITH GRANT OPTION",
-            f"GRANT {all_access_except_show_named_collections} ON *.* TO default WITH GRANT OPTION",
+            "GRANT ALL ON *.* TO default WITH GRANT OPTION",
         ]
     )
 
@@ -436,7 +439,7 @@ def test_introspection():
         [
             "GRANT SELECT ON test.table TO A",
             "GRANT CREATE ON *.* TO B WITH GRANT OPTION",
-            f"GRANT {all_access_except_show_named_collections} ON *.* TO default WITH GRANT OPTION",
+            "GRANT ALL ON *.* TO default WITH GRANT OPTION",
         ]
     )
 
@@ -451,7 +454,7 @@ def test_introspection():
     expected_access2 = (
         "GRANT SELECT ON test.table TO A\n"
         "GRANT CREATE ON *.* TO B WITH GRANT OPTION\n"
-        f"GRANT {all_access_except_show_named_collections} ON *.* TO default WITH GRANT OPTION"
+        "GRANT ALL ON *.* TO default WITH GRANT OPTION\n"
     )
     assert expected_access1 in instance.query("SHOW ACCESS")
     assert expected_access2 in instance.query("SHOW ACCESS")
diff --git a/tests/integration/test_named_collections/configs/users.d/users_no_default_access2.xml b/tests/integration/test_named_collections/configs/users.d/users_no_default_access_with_access_management.xml
similarity index 100%
rename from tests/integration/test_named_collections/configs/users.d/users_no_default_access2.xml
rename to tests/integration/test_named_collections/configs/users.d/users_no_default_access_with_access_management.xml
diff --git a/tests/integration/test_named_collections/test.py b/tests/integration/test_named_collections/test.py
index 1b853fadaff..3b102f1aa70 100644
--- a/tests/integration/test_named_collections/test.py
+++ b/tests/integration/test_named_collections/test.py
@@ -40,7 +40,7 @@ def cluster():
                 "configs/config.d/named_collections.xml",
             ],
             user_configs=[
-                "configs/users.d/users_no_default_access2.xml",
+                "configs/users.d/users_no_default_access_with_access_management.xml",
             ],
             stay_alive=True,
         )

From 2445a391fbaf7e798c6eb9b65863ac6d6b1c60d8 Mon Sep 17 00:00:00 2001
From: MeenaRenganathan22 <Meena.Renganathan@ibm.com>
Date: Tue, 7 Feb 2023 09:05:12 -0500
Subject: [PATCH 67/79] Updating the libhdfs3 to reflect the revert of PR#21

---
 contrib/libhdfs3 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/libhdfs3 b/contrib/libhdfs3
index 9e286249a2a..9ee3ce77215 160000
--- a/contrib/libhdfs3
+++ b/contrib/libhdfs3
@@ -1 +1 @@
-Subproject commit 9e286249a2a423f3b2f2759b3702dc29713eb020
+Subproject commit 9ee3ce77215fca83b7fdfcfe2186a3db0d0bdb74

From 40deaf1661812d6d89fd19ff3efdfc867175d1ac Mon Sep 17 00:00:00 2001
From: kssenii <sumarokovakseniia@mail.ru>
Date: Tue, 7 Feb 2023 16:30:04 +0100
Subject: [PATCH 68/79] Fix clang-tidy

---
 src/Storages/StorageDeltaLake.cpp | 2 +-
 src/Storages/StorageDeltaLake.h   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/Storages/StorageDeltaLake.cpp b/src/Storages/StorageDeltaLake.cpp
index 6127db79525..9f86eaf70d0 100644
--- a/src/Storages/StorageDeltaLake.cpp
+++ b/src/Storages/StorageDeltaLake.cpp
@@ -94,7 +94,7 @@ void JsonMetadataGetter::init(ContextPtr context)
     }
 }
 
-std::vector<String> JsonMetadataGetter::getJsonLogFiles()
+std::vector<String> JsonMetadataGetter::getJsonLogFiles() const
 {
     const auto & client = base_configuration.client;
     const auto table_path = base_configuration.url.key;
diff --git a/src/Storages/StorageDeltaLake.h b/src/Storages/StorageDeltaLake.h
index 3495a061b14..33a15dcf115 100644
--- a/src/Storages/StorageDeltaLake.h
+++ b/src/Storages/StorageDeltaLake.h
@@ -44,7 +44,7 @@ public:
 private:
     void init(ContextPtr context);
 
-    std::vector<String> getJsonLogFiles();
+    std::vector<String> getJsonLogFiles() const;
 
     std::shared_ptr<ReadBuffer> createS3ReadBuffer(const String & key, ContextPtr context);
 

From b43ffb98e865b367bbd634928dc3dded757abe75 Mon Sep 17 00:00:00 2001
From: Zhiguo Zhou <zhiguo.zhou@intel.com>
Date: Tue, 7 Feb 2023 23:33:01 +0800
Subject: [PATCH 69/79] Vectorize filter generation of ColumnNullable in
 FilterDescription (#45962)

This commit achieved the data parallelism for filter generations of
the nullable columns by replacing the logical AND operator with the
bitwise one, which could be auto-vectorized by the compiler.
---
 src/Columns/FilterDescription.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/Columns/FilterDescription.cpp b/src/Columns/FilterDescription.cpp
index a87c70dcdad..9e967a85c59 100644
--- a/src/Columns/FilterDescription.cpp
+++ b/src/Columns/FilterDescription.cpp
@@ -82,7 +82,12 @@ FilterDescription::FilterDescription(const IColumn & column_)
         const auto size = res.size();
         assert(size == null_map.size());
         for (size_t i = 0; i < size; ++i)
-            res[i] = res[i] && !null_map[i];
+        {
+            auto has_val = static_cast<UInt8>(!!res[i]);
+            auto not_null = static_cast<UInt8>(!null_map[i]);
+            /// Instead of the logical AND operator(&&), the bitwise one(&) is utilized for the auto vectorization.
+            res[i] = has_val & not_null;
+        }
 
         data = &res;
         data_holder = std::move(mutable_holder);

From 18d2a99761db4c4fd73a7eb8aa0352c114e8a0cc Mon Sep 17 00:00:00 2001
From: Azat Khuzhin <a3at.mail@gmail.com>
Date: Tue, 7 Feb 2023 16:53:45 +0100
Subject: [PATCH 70/79] Use comments for variables that clang can parse

Signed-off-by: Azat Khuzhin <a.khuzhin@semrush.com>
---
 programs/copier/ClusterCopier.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/programs/copier/ClusterCopier.cpp b/programs/copier/ClusterCopier.cpp
index 2fc0eb27213..69f87d9bbf3 100644
--- a/programs/copier/ClusterCopier.cpp
+++ b/programs/copier/ClusterCopier.cpp
@@ -1452,7 +1452,7 @@ TaskStatus ClusterCopier::processPartitionPieceTaskImpl(
                                                            *zookeeper, host_id);
         // Maybe we are the first worker
 
-        ASTPtr query_select_ast = get_select_query(split_table_for_current_piece, "count()", /*enable_splitting*/ true);
+        ASTPtr query_select_ast = get_select_query(split_table_for_current_piece, "count()", /* enable_splitting= */ true);
         UInt64 count;
         {
             auto local_context = Context::createCopy(context);
@@ -1520,7 +1520,7 @@ TaskStatus ClusterCopier::processPartitionPieceTaskImpl(
         }
 
         // Select all fields
-        ASTPtr query_select_ast = get_select_query(task_shard.table_read_shard, "*", /*enable_splitting*/ true, inject_fault ? "1" : "");
+        ASTPtr query_select_ast = get_select_query(task_shard.table_read_shard, "*", /* enable_splitting= */ true, inject_fault ? "1" : "");
 
         LOG_INFO(log, "Executing SELECT query and pull from {}: {}", task_shard.getDescription(), queryToString(query_select_ast));
 

From ff324fe81af22d04fd4bbec7958449197c1f755d Mon Sep 17 00:00:00 2001
From: Azat Khuzhin <a3at.mail@gmail.com>
Date: Tue, 7 Feb 2023 16:53:59 +0100
Subject: [PATCH 71/79] Fix fault injection in copier (wrong query syntax)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

There are very frequent flakiness of `test_cluster_copier` test, here is
an example of copier failures on CI [1]:

    AssertionError: Instance: s0_1_0 (172.16.29.9). Info: {'ID': '5d68dcb46fdb4b0c54b7c7ba1ddde83b8f34d483bbb32abcb0c52b966444ce82', 'Running': False, 'ExitCode': 85, 'ProcessConfig': {'tty': False, 'entrypoint': '/usr/bin/clickhouse', 'arguments': ['copier', '--config', '/etc/clickhouse-server/config-copier.xml', '--task-path', '/clickhouse-copier/task_simple_4DFWYTDD49', '--task-file', '/task0_description.xml', '--task-upload-force', 'true', '--base-dir', '/var/log/clickhouse-server/copier', '--copy-fault-probability', '0.2', '--experimental-use-sample-offset', '1'], 'privileged': False, 'user': '0'}, 'OpenStdin': False, 'OpenStderr': True, 'OpenStdout': True, 'CanRemove': False, 'ContainerID': 'f356df6694b3cc09ee9830c623681626f8e8d999677c188b9fe911aa702784ca', 'DetachKeys': '', 'Pid': 84332}
    assert 85 == 0

But let's look what the error it is, apparently it is UNFINISHED:

    SELECT
        name,
        code
    FROM system.errors
    WHERE ((code % 256) = 85) AND (NOT remote)
    SETTINGS system_events_show_zero_values = 1

    ┌─name─────────────────────────────┬─code─┐
    │ FORMAT_IS_NOT_SUITABLE_FOR_INPUT │   85 │
    │ UNFINISHED                       │  341 │
    │ NO_SUCH_ERROR_CODE               │  597 │
    └──────────────────────────────────┴──────┘

Let's verify:

    $ grep -r UNFINISHED ./test_cluster_copier/_instances_0/s0_1_0/logs/copier/clickhouse-copier_*
    ./test_cluster_copier/_instances_0/s0_1_0/logs/copier/clickhouse-copier_20230206220846_368/log.log:2023.02.06 22:09:19.015251 [ 368 ] {} <Error> : virtual int DB::ClusterCopierApp::main(const std::vector<std::string> &): Code: 341. DB::Exception: Too many tries to process table cluster1.default.hits. Abort remaining execution. (UNFINISHED), Stack trace (when copying this message, always include the lines below):

And apparently that it is due to query error with fault injection:

    2023.02.06 22:09:15.654724 [ 368 ] {} <Error> Application: An error occurred while processing partition 0: Code: 62. DB::Exception: Syntax error (Query): failed at position 168 ('Native'): Native. Expected one of: token, Dot, OR, AND, BETWEEN, NOT BETWEEN, LIKE, ILIKE, NOT LIKE, NOT ILIKE, IN, NOT IN, GLOBAL IN, GLOBAL NOT IN, MOD, DIV, IS NULL, IS NOT NULL, alias, AS, Comma, OFFSET, WITH TIES, BY, LIMIT, SETTINGS, UNION, EXCEPT, INTERSECT, INTO OUTFILE, FORMAT, end of query. (SYNTAX_ERROR), Stack trace (when copying this message, always include the lines below):

Example:

    select x from x limit  1FORMAT Native

    Syntax error: failed at position 32 ('Native'):

So fixing this should fix test_cluster_copier flakiness.

  [1]: https://s3.amazonaws.com/clickhouse-test-reports/46045/bd4170e03c6af583a51d12d2c39fa775dcb9997b/integration_tests__release__[4/4].html

Signed-off-by: Azat Khuzhin <a.khuzhin@semrush.com>
---
 programs/copier/ClusterCopier.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/programs/copier/ClusterCopier.cpp b/programs/copier/ClusterCopier.cpp
index 69f87d9bbf3..c4e48bf7eb0 100644
--- a/programs/copier/ClusterCopier.cpp
+++ b/programs/copier/ClusterCopier.cpp
@@ -1306,7 +1306,7 @@ TaskStatus ClusterCopier::processPartitionPieceTaskImpl(
         if (!limit.empty())
             query += " LIMIT " + limit;
 
-        query += "FORMAT Native";
+        query += " FORMAT Native";
 
         ParserQuery p_query(query.data() + query.size());
 

From e5b5fce970f80502f3e28a7c8eb6c1c4a543746a Mon Sep 17 00:00:00 2001
From: Nikolay Degterinsky <43110995+evillique@users.noreply.github.com>
Date: Tue, 7 Feb 2023 18:11:43 +0100
Subject: [PATCH 72/79] Update liburing CmakeLists.txt

---
 contrib/liburing-cmake/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/liburing-cmake/CMakeLists.txt b/contrib/liburing-cmake/CMakeLists.txt
index 02bc116c660..300cc02c864 100644
--- a/contrib/liburing-cmake/CMakeLists.txt
+++ b/contrib/liburing-cmake/CMakeLists.txt
@@ -50,4 +50,4 @@ configure_file (io_uring_version.h.in ${LIBURING_VERSION_HEADER})
 add_library (_liburing ${SRCS})
 add_library (ch_contrib::liburing ALIAS _liburing)
 
-target_include_directories (_liburing SYSTEM PUBLIC ${LIBURING_COMPAT_INCLUDE_DIR} ${LIBURING_GENERATED_INCLUDE_DIR} "${LIBURING_SOURCE_DIR}/include")
+target_include_directories (_liburing SYSTEM PUBLIC ${LIBURING_COMPAT_INCLUDE_DIR} ${LIBURING_GENERATED_INCLUDE_DIR} ${LIBURING_INCLUDE_DIR})

From fe5bc0195135426a33c51b350a3d9491af38ee9a Mon Sep 17 00:00:00 2001
From: DanRoscigno <dan@roscigno.com>
Date: Tue, 7 Feb 2023 14:43:36 -0500
Subject: [PATCH 73/79] merged Mermaid support today

---
 docs/en/development/architecture.md | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/docs/en/development/architecture.md b/docs/en/development/architecture.md
index 4d4271ab79f..50b338844df 100644
--- a/docs/en/development/architecture.md
+++ b/docs/en/development/architecture.md
@@ -198,7 +198,19 @@ Each slot can be seen as an independent state machine with the following states:
 
 Note that `allocated` slot can be in two different states: `granted` and `acquired`. The former is a transitional state, that actually should be short (from the instant when a slot is allocated to a query till the moment when the up-scaling procedure is run by any thread of that query).
 
-![state diagram](@site/docs/en/development/images/concurrency.png)
+```mermaid
+stateDiagram-v2
+    direction LR
+    [*] --> free
+    free --> allocated: allocate
+    state allocated {
+        direction LR
+        [*] --> granted
+        granted --> acquired: acquire
+        acquired --> [*]
+    }
+    allocated --> free: release
+```
 
 API of `ConcurrencyControl` consists of the following functions:
 1. Create a resource allocation for a query: `auto slots = ConcurrencyControl::instance().allocate(1, max_threads);`. It will allocate at least 1 and at most `max_threads` slots. Note that the first slot is granted immediately, but the remaining slots may be granted later. Thus limit is soft, because every query will obtain at least one thread.

From a60a3726e88395fad98d277dd00e7580cd06a1d1 Mon Sep 17 00:00:00 2001
From: Tyler Hannan <tyler@clickhouse.com>
Date: Tue, 7 Feb 2023 23:06:32 +0100
Subject: [PATCH 74/79] Adding FOSDEM

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index bcf2643c33d..4cb18c5b6b2 100644
--- a/README.md
+++ b/README.md
@@ -15,6 +15,7 @@ ClickHouse® is an open-source column-oriented database management system that a
 * [Code Browser (github.dev)](https://github.dev/ClickHouse/ClickHouse) with syntax highlight, powered by github.dev.
 * [Contacts](https://clickhouse.com/company/contact) can help to get your questions answered if there are any.
 
-## Upcoming events
+## Events
+* **FOSDEM 2023**: In the "Fast and Streaming Data" room Alexey gave a talk entitled "Building Analytical Apps With ClickHouse" that looks at the landscape of data tools, an interesting data set, and how you can interact with data quickly. Check out the recording on [youtube](https://www.youtube.com/watch?v=JlcI2Vfz_uk)
 * **Recording available**: [**v23.1 Release Webinar**](https://www.youtube.com/watch?v=zYSZXBnTMSE) 23.1 is the ClickHouse New Year release. Original creator, co-founder, and CTO of ClickHouse Alexey Milovidov will walk us through the highlights of the release. Inverted indices, query cache, and so -- very -- much more.
 * **Recording available**: [**ClickHouse Meetup at the CHEQ office in Tel Aviv**](https://www.meetup.com/clickhouse-tel-aviv-user-group/events/289599423/) - We are very excited to be holding our next in-person ClickHouse meetup at the CHEQ office in Tel Aviv! Hear from CHEQ, ServiceNow and Contentsquare, as well as a deep dive presentation from ClickHouse CTO Alexey Milovidov. Join us for a fun evening of talks, food and discussion!

From 924f19e94a0b5381d88fb7b24096095b21bcc75b Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 8 Feb 2023 04:12:00 +0300
Subject: [PATCH 75/79] Update AzureBlobStorageAuth.cpp

---
 .../ObjectStorages/AzureBlobStorage/AzureBlobStorageAuth.cpp    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Disks/ObjectStorages/AzureBlobStorage/AzureBlobStorageAuth.cpp b/src/Disks/ObjectStorages/AzureBlobStorage/AzureBlobStorageAuth.cpp
index 61fa4af100e..1e06490b5bc 100644
--- a/src/Disks/ObjectStorages/AzureBlobStorage/AzureBlobStorageAuth.cpp
+++ b/src/Disks/ObjectStorages/AzureBlobStorage/AzureBlobStorageAuth.cpp
@@ -137,7 +137,7 @@ std::unique_ptr<BlobContainerClient> getAzureBlobContainerClient(
         /// (Conflict - The specified container already exists)
         if (!endpoint.container_already_exists.has_value() && e.StatusCode == Azure::Core::Http::HttpStatusCode::Conflict)
         {
-            tryLogCurrentException("Container already exist, return existing container");
+            tryLogCurrentException("Container already exists, returning the existing container");
             return getAzureBlobStorageClientWithAuth<BlobContainerClient>(final_url, container_name, config, config_prefix);
         }
         throw;

From 66e9dd3c9475b9d9103b67c5d3280966f3f625d1 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@clickhouse.com>
Date: Wed, 8 Feb 2023 04:53:47 +0300
Subject: [PATCH 76/79] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 4cb18c5b6b2..75e0fa1bc4d 100644
--- a/README.md
+++ b/README.md
@@ -16,6 +16,6 @@ ClickHouse® is an open-source column-oriented database management system that a
 * [Contacts](https://clickhouse.com/company/contact) can help to get your questions answered if there are any.
 
 ## Events
-* **FOSDEM 2023**: In the "Fast and Streaming Data" room Alexey gave a talk entitled "Building Analytical Apps With ClickHouse" that looks at the landscape of data tools, an interesting data set, and how you can interact with data quickly. Check out the recording on [youtube](https://www.youtube.com/watch?v=JlcI2Vfz_uk)
+* **FOSDEM 2023**: In the "Fast and Streaming Data" room Alexey gave a talk entitled "Building Analytical Apps With ClickHouse" that looks at the landscape of data tools, an interesting data set, and how you can interact with data quickly. Check out the recording on **[YouTube](https://www.youtube.com/watch?v=JlcI2Vfz_uk)**.
 * **Recording available**: [**v23.1 Release Webinar**](https://www.youtube.com/watch?v=zYSZXBnTMSE) 23.1 is the ClickHouse New Year release. Original creator, co-founder, and CTO of ClickHouse Alexey Milovidov will walk us through the highlights of the release. Inverted indices, query cache, and so -- very -- much more.
 * **Recording available**: [**ClickHouse Meetup at the CHEQ office in Tel Aviv**](https://www.meetup.com/clickhouse-tel-aviv-user-group/events/289599423/) - We are very excited to be holding our next in-person ClickHouse meetup at the CHEQ office in Tel Aviv! Hear from CHEQ, ServiceNow and Contentsquare, as well as a deep dive presentation from ClickHouse CTO Alexey Milovidov. Join us for a fun evening of talks, food and discussion!

From a2df6e950ed3568ba09246e0f2cd009b91926de3 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@clickhouse.com>
Date: Wed, 8 Feb 2023 03:38:14 +0100
Subject: [PATCH 77/79] Whitespace

---
 tests/performance/decimal_casts.xml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/performance/decimal_casts.xml b/tests/performance/decimal_casts.xml
index 6dd38b6a06a..f385a0362cc 100644
--- a/tests/performance/decimal_casts.xml
+++ b/tests/performance/decimal_casts.xml
@@ -17,7 +17,7 @@
     <query>SELECT toUInt256(x) y, toDecimal32(y, 1), toDecimal64(y, 5), toDecimal128(y, 6) FROM t LIMIT 10000000 FORMAT Null</query>
     <query>SELECT toFloat32(x) y, toDecimal32(y, 1), toDecimal64(y, 5), toDecimal128(y, 6) FROM t FORMAT Null</query>
     <query>SELECT toFloat64(x) y, toDecimal32(y, 1), toDecimal64(y, 5), toDecimal128(y, 6) FROM t FORMAT Null</query>
-    
+
     <query>SELECT toInt32(d32),   toInt64(d32),   toInt128(d32)   FROM t FORMAT Null</query>
     <query>SELECT toInt32(d64),   toInt64(d64),   toInt128(d64)   FROM t FORMAT Null</query>
     <query>SELECT toInt32(d128),  toInt64(d128),  toInt128(d128)  FROM t FORMAT Null</query>

From a69f9c05a981a6c95af496b47413e540c87e2c09 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@clickhouse.com>
Date: Wed, 8 Feb 2023 05:35:19 +0100
Subject: [PATCH 78/79] Remove flaky test

---
 ...nd_exception_messages_formatting.reference | 14 -----
 ..._log_and_exception_messages_formatting.sql | 61 -------------------
 2 files changed, 75 deletions(-)
 delete mode 100644 tests/queries/0_stateless/00002_log_and_exception_messages_formatting.reference
 delete mode 100644 tests/queries/0_stateless/00002_log_and_exception_messages_formatting.sql

diff --git a/tests/queries/0_stateless/00002_log_and_exception_messages_formatting.reference b/tests/queries/0_stateless/00002_log_and_exception_messages_formatting.reference
deleted file mode 100644
index d3b69939e66..00000000000
--- a/tests/queries/0_stateless/00002_log_and_exception_messages_formatting.reference
+++ /dev/null
@@ -1,14 +0,0 @@
-10	0.001
-20	0.05
-30	10
-40	40
-50	125
-60	0.3
-70	0.16
-80	0.08
-90	0.04
-100	0.005
-110	0.01
-120	3
-130	10
-140	15
diff --git a/tests/queries/0_stateless/00002_log_and_exception_messages_formatting.sql b/tests/queries/0_stateless/00002_log_and_exception_messages_formatting.sql
deleted file mode 100644
index 686d04013fe..00000000000
--- a/tests/queries/0_stateless/00002_log_and_exception_messages_formatting.sql
+++ /dev/null
@@ -1,61 +0,0 @@
--- Tags: no-parallel
--- no-parallel because we want to run this test when most of the other tests already passed
-
--- If this test fails, see the "Top patterns of log messages" diagnostics in the end of run.log
-
-system flush logs;
-drop table if exists logs;
-create view logs as select * from system.text_log where now() - toIntervalMinute(120) < event_time;
-
--- Check that we don't have too many messages formatted with fmt::runtime or strings concatenation.
--- 0.001 threshold should be always enough, the value was about 0.00025
-select 10, max2(sum(length(message_format_string) = 0) / count(), 0.001) from logs;
-
--- Check the same for exceptions. The value was 0.03
-select 20, max2(sum(length(message_format_string) = 0) / count(), 0.05) from logs where message like '%DB::Exception%';
-
--- Check that we don't have too many short meaningless message patterns.
-select 30, max2(countDistinct(message_format_string), 10) from logs where length(message_format_string) < 10;
-
--- Same as above. Feel free to update the threshold or remove this query if really necessary
-select 40, max2(countDistinct(message_format_string), 40) from logs where length(message_format_string) < 16;
-
--- Same as above, but exceptions must be more informative. Feel free to update the threshold or remove this query if really necessary
-select 50, max2(countDistinct(message_format_string), 125) from logs where length(message_format_string) < 30 and message ilike '%DB::Exception%';
-
-
--- Avoid too noisy messages: top 1 message frequency must be less than 30%. We should reduce the threshold
-select 60, max2((select count() from logs group by message_format_string order by count() desc limit 1) / (select count() from logs), 0.30);
-
--- Same as above, but excluding Test level (actually finds top 1 Trace message)
-with ('Access granted: {}{}', '{} -> {}') as frequent_in_tests
-select 70, max2((select count() from logs where level!='Test' and message_format_string not in frequent_in_tests
-    group by message_format_string order by count() desc limit 1) / (select count() from logs), 0.16);
-
--- Same as above for Debug
-select 80, max2((select count() from logs where level <= 'Debug' group by message_format_string order by count() desc limit 1) / (select count() from logs), 0.08);
-
--- Same as above for Info
-select 90, max2((select count() from logs where level <= 'Information' group by message_format_string order by count() desc limit 1) / (select count() from logs), 0.04);
-
--- Same as above for Warning
-with ('Not enabled four letter command {}') as frequent_in_tests
-select 100, max2((select count() from logs where level = 'Warning' and message_format_string not in frequent_in_tests
-    group by message_format_string order by count() desc limit 1) / (select count() from logs), 0.005);
-
--- Same as above for Error
-select 110, max2((select count() from logs where level = 'Error' group by message_format_string order by count() desc limit 1) / (select count() from logs), 0.01);
-
--- Avoid too noisy messages: limit the number of messages with high frequency
-select 120, max2(count(), 3) from (select count() / (select count() from logs) as freq, message_format_string from logs group by message_format_string having freq > 0.10);
-select 130, max2(count(), 10) from (select count() / (select count() from logs) as freq, message_format_string from logs group by message_format_string having freq > 0.05);
-
--- Each message matches its pattern (returns 0 rows)
--- FIXME maybe we should make it stricter ('Code:%Exception: '||s||'%'), but it's not easy because of addMessage
-select 140, max2(countDistinct(message_format_string), 15) from (
-    select message_format_string, any(message) as any_message from logs
-    where message not like (replaceRegexpAll(message_format_string, '{[:.0-9dfx]*}', '%') as s)
-    and message not like ('%Exception: '||s||'%') group by message_format_string
-) where any_message not like '%Poco::Exception%';
-
-drop table logs;

From b79ead9c847b9cf5077145611a1c13b8c45daa5b Mon Sep 17 00:00:00 2001
From: Robert Schulze <robert@clickhouse.com>
Date: Wed, 8 Feb 2023 12:04:11 +0100
Subject: [PATCH 79/79] Move poco to base/poco/ (#46075)

* Replicate poco into base/poco/

* De-register poco submodule

* Build poco from ClickHouse

* Exclude poco from stylecheck

* Exclude poco from whitespace check

* Exclude poco from typo check

* Remove x bit from sources/headers (the style check complained)

* Exclude poco from duplicate include check

* Fix fasttest

* Remove contrib/poco-cmake/*

* Simplify poco build descriptions

* Remove poco stuff not used by ClickHouse

* Glob poco sources

* Exclude poco from clang-tidy
---
 .gitmodules                                   |     4 -
 base/CMakeLists.txt                           |     5 +-
 base/base/CMakeLists.txt                      |     4 +
 base/pcg-random/CMakeLists.txt                |     4 +
 base/poco/CHANGELOG                           |  2791 ++++
 .../poco-cmake => base/poco}/CMakeLists.txt   |     5 +-
 base/poco/CONTRIBUTORS                        |    52 +
 base/poco/Crypto/CMakeLists.txt               |    17 +
 base/poco/Crypto/include/Poco/Crypto/Cipher.h |   138 +
 .../include/Poco/Crypto/CipherFactory.h       |    75 +
 .../Crypto/include/Poco/Crypto/CipherImpl.h   |    69 +
 .../Crypto/include/Poco/Crypto/CipherKey.h    |   201 +
 .../include/Poco/Crypto/CipherKeyImpl.h       |   168 +
 base/poco/Crypto/include/Poco/Crypto/Crypto.h |   195 +
 .../include/Poco/Crypto/CryptoException.h     |    56 +
 .../Crypto/include/Poco/Crypto/CryptoStream.h |   192 +
 .../include/Poco/Crypto/CryptoTransform.h     |    87 +
 .../Crypto/include/Poco/Crypto/DigestEngine.h |    80 +
 .../include/Poco/Crypto/ECDSADigestEngine.h   |   101 +
 base/poco/Crypto/include/Poco/Crypto/ECKey.h  |   136 +
 .../Crypto/include/Poco/Crypto/ECKeyImpl.h    |   174 +
 .../poco/Crypto/include/Poco/Crypto/EVPPKey.h |   354 +
 .../poco/Crypto/include/Poco/Crypto/KeyPair.h |   133 +
 .../Crypto/include/Poco/Crypto/KeyPairImpl.h  |   107 +
 .../include/Poco/Crypto/OpenSSLInitializer.h  |   115 +
 .../include/Poco/Crypto/PKCS12Container.h     |   159 +
 .../include/Poco/Crypto/RSACipherImpl.h       |    77 +
 .../include/Poco/Crypto/RSADigestEngine.h     |   111 +
 base/poco/Crypto/include/Poco/Crypto/RSAKey.h |   125 +
 .../Crypto/include/Poco/Crypto/RSAKeyImpl.h   |   141 +
 .../include/Poco/Crypto/X509Certificate.h     |   245 +
 base/poco/Crypto/src/Cipher.cpp               |   140 +
 base/poco/Crypto/src/CipherFactory.cpp        |    65 +
 base/poco/Crypto/src/CipherImpl.cpp           |   272 +
 base/poco/Crypto/src/CipherKey.cpp            |    49 +
 base/poco/Crypto/src/CipherKeyImpl.cpp        |   222 +
 base/poco/Crypto/src/CryptoException.cpp      |   108 +
 base/poco/Crypto/src/CryptoStream.cpp         |   355 +
 base/poco/Crypto/src/CryptoTransform.cpp      |    38 +
 base/poco/Crypto/src/DigestEngine.cpp         |    80 +
 base/poco/Crypto/src/ECDSADigestEngine.cpp    |   100 +
 base/poco/Crypto/src/ECKey.cpp                |    75 +
 base/poco/Crypto/src/ECKeyImpl.cpp            |   258 +
 base/poco/Crypto/src/EVPPKey.cpp              |   321 +
 base/poco/Crypto/src/KeyPair.cpp              |    34 +
 base/poco/Crypto/src/KeyPairImpl.cpp          |    35 +
 base/poco/Crypto/src/OpenSSLInitializer.cpp   |   190 +
 base/poco/Crypto/src/PKCS12Container.cpp      |   191 +
 base/poco/Crypto/src/RSACipherImpl.cpp        |   342 +
 base/poco/Crypto/src/RSADigestEngine.cpp      |    96 +
 base/poco/Crypto/src/RSAKey.cpp               |    87 +
 base/poco/Crypto/src/RSAKeyImpl.cpp           |   386 +
 base/poco/Crypto/src/X509Certificate.cpp      |   386 +
 base/poco/Data/CMakeLists.txt                 |     7 +
 base/poco/Data/ODBC/CMakeLists.txt            |    39 +
 .../Data/ODBC/include/Poco/Data/ODBC/Binder.h |  1516 ++
 .../include/Poco/Data/ODBC/ConnectionHandle.h |    96 +
 .../ODBC/include/Poco/Data/ODBC/Connector.h   |    96 +
 .../ODBC/include/Poco/Data/ODBC/Diagnostics.h |   239 +
 .../Poco/Data/ODBC/EnvironmentHandle.h        |    94 +
 .../Data/ODBC/include/Poco/Data/ODBC/Error.h  |   124 +
 .../ODBC/include/Poco/Data/ODBC/Extractor.h   |   728 +
 .../Data/ODBC/include/Poco/Data/ODBC/Handle.h |   113 +
 .../Data/ODBC/include/Poco/Data/ODBC/ODBC.h   |    69 +
 .../include/Poco/Data/ODBC/ODBCException.h    |   150 +
 .../include/Poco/Data/ODBC/ODBCMetaColumn.h   |    92 +
 .../Poco/Data/ODBC/ODBCStatementImpl.h        |   206 +
 .../ODBC/include/Poco/Data/ODBC/Parameter.h   |   111 +
 .../ODBC/include/Poco/Data/ODBC/Preparator.h  |  1271 ++
 .../ODBC/include/Poco/Data/ODBC/SessionImpl.h |   290 +
 .../ODBC/include/Poco/Data/ODBC/TypeInfo.h    |   117 +
 .../ODBC/include/Poco/Data/ODBC/Unicode.h     |   985 ++
 .../include/Poco/Data/ODBC/Unicode_UNIXODBC.h |    51 +
 .../include/Poco/Data/ODBC/Unicode_WIN32.h    |    57 +
 .../ODBC/include/Poco/Data/ODBC/Utility.h     |   207 +
 base/poco/Data/ODBC/src/Binder.cpp            |   541 +
 base/poco/Data/ODBC/src/ConnectionHandle.cpp  |    57 +
 base/poco/Data/ODBC/src/Connector.cpp         |    64 +
 base/poco/Data/ODBC/src/EnvironmentHandle.cpp |    54 +
 base/poco/Data/ODBC/src/Extractor.cpp         |  1312 ++
 base/poco/Data/ODBC/src/ODBCException.cpp     |    30 +
 base/poco/Data/ODBC/src/ODBCMetaColumn.cpp    |   168 +
 base/poco/Data/ODBC/src/ODBCStatementImpl.cpp |   458 +
 base/poco/Data/ODBC/src/Parameter.cpp         |    53 +
 base/poco/Data/ODBC/src/Preparator.cpp        |   209 +
 base/poco/Data/ODBC/src/SessionImpl.cpp       |   418 +
 base/poco/Data/ODBC/src/TypeInfo.cpp          |   265 +
 base/poco/Data/ODBC/src/Unicode.cpp           |    22 +
 base/poco/Data/ODBC/src/Unicode_UNIXODBC.cpp  |   775 +
 base/poco/Data/ODBC/src/Unicode_WIN32.cpp     |   761 +
 base/poco/Data/ODBC/src/Utility.cpp           |   159 +
 .../Data/include/Poco/Data/AbstractBinder.h   |   373 +
 .../Data/include/Poco/Data/AbstractBinding.h  |   144 +
 .../include/Poco/Data/AbstractExtraction.h    |   278 +
 .../include/Poco/Data/AbstractExtractor.h     |   351 +
 .../include/Poco/Data/AbstractPreparation.h   |    71 +
 .../include/Poco/Data/AbstractPreparator.h    |   388 +
 .../include/Poco/Data/AbstractSessionImpl.h   |   315 +
 .../Data/include/Poco/Data/ArchiveStrategy.h  |   222 +
 .../Data/include/Poco/Data/AutoTransaction.h  |    35 +
 base/poco/Data/include/Poco/Data/Binding.h    |  1496 ++
 base/poco/Data/include/Poco/Data/Bulk.h       |    96 +
 .../poco/Data/include/Poco/Data/BulkBinding.h |   148 +
 .../Data/include/Poco/Data/BulkExtraction.h   |   276 +
 base/poco/Data/include/Poco/Data/Column.h     |   490 +
 base/poco/Data/include/Poco/Data/Connector.h  |    56 +
 base/poco/Data/include/Poco/Data/Constants.h  |    36 +
 base/poco/Data/include/Poco/Data/Data.h       |    62 +
 .../Data/include/Poco/Data/DataException.h    |    50 +
 base/poco/Data/include/Poco/Data/Date.h       |   225 +
 .../Data/include/Poco/Data/DynamicDateTime.h  |    47 +
 base/poco/Data/include/Poco/Data/DynamicLOB.h |    45 +
 base/poco/Data/include/Poco/Data/Extraction.h |   869 ++
 base/poco/Data/include/Poco/Data/LOB.h        |   309 +
 base/poco/Data/include/Poco/Data/LOBStream.h  |   150 +
 base/poco/Data/include/Poco/Data/Limit.h      |   113 +
 base/poco/Data/include/Poco/Data/MetaColumn.h |   188 +
 .../include/Poco/Data/PooledSessionHolder.h   |    99 +
 .../include/Poco/Data/PooledSessionImpl.h     |    97 +
 base/poco/Data/include/Poco/Data/Position.h   |    75 +
 .../poco/Data/include/Poco/Data/Preparation.h |   161 +
 base/poco/Data/include/Poco/Data/Range.h      |   104 +
 base/poco/Data/include/Poco/Data/RecordSet.h  |   653 +
 base/poco/Data/include/Poco/Data/Row.h        |   312 +
 base/poco/Data/include/Poco/Data/RowFilter.h  |   276 +
 .../Data/include/Poco/Data/RowFormatter.h     |   231 +
 .../poco/Data/include/Poco/Data/RowIterator.h |   150 +
 base/poco/Data/include/Poco/Data/SQLChannel.h |   217 +
 base/poco/Data/include/Poco/Data/Session.h    |   494 +
 .../Data/include/Poco/Data/SessionFactory.h   |    99 +
 .../poco/Data/include/Poco/Data/SessionImpl.h |   221 +
 .../poco/Data/include/Poco/Data/SessionPool.h |   233 +
 .../include/Poco/Data/SessionPoolContainer.h  |   114 +
 .../include/Poco/Data/SimpleRowFormatter.h    |   122 +
 base/poco/Data/include/Poco/Data/Statement.h  |   822 ++
 .../Data/include/Poco/Data/StatementCreator.h |    73 +
 .../Data/include/Poco/Data/StatementImpl.h    |   632 +
 base/poco/Data/include/Poco/Data/Time.h       |   229 +
 .../poco/Data/include/Poco/Data/Transaction.h |   194 +
 .../poco/Data/include/Poco/Data/TypeHandler.h |  2090 +++
 base/poco/Data/src/AbstractBinder.cpp         |   527 +
 base/poco/Data/src/AbstractBinding.cpp        |    45 +
 base/poco/Data/src/AbstractExtraction.cpp     |    40 +
 base/poco/Data/src/AbstractExtractor.cpp      |   437 +
 base/poco/Data/src/AbstractPreparation.cpp    |    34 +
 base/poco/Data/src/AbstractPreparator.cpp     |   438 +
 base/poco/Data/src/ArchiveStrategy.cpp        |   146 +
 base/poco/Data/src/Bulk.cpp                   |    37 +
 base/poco/Data/src/Connector.cpp              |    32 +
 base/poco/Data/src/DataException.cpp          |    41 +
 base/poco/Data/src/Date.cpp                   |   142 +
 base/poco/Data/src/DynamicLOB.cpp             |    74 +
 base/poco/Data/src/Limit.cpp                  |    35 +
 base/poco/Data/src/MetaColumn.cpp             |    53 +
 base/poco/Data/src/PooledSessionHolder.cpp    |    34 +
 base/poco/Data/src/PooledSessionImpl.cpp      |   192 +
 base/poco/Data/src/Position.cpp               |    32 +
 base/poco/Data/src/Range.cpp                  |    40 +
 base/poco/Data/src/RecordSet.cpp              |   392 +
 base/poco/Data/src/Row.cpp                    |   369 +
 base/poco/Data/src/RowFilter.cpp              |   225 +
 base/poco/Data/src/RowFormatter.cpp           |    80 +
 base/poco/Data/src/RowIterator.cpp            |   207 +
 base/poco/Data/src/SQLChannel.cpp             |   296 +
 base/poco/Data/src/Session.cpp                |    78 +
 base/poco/Data/src/SessionFactory.cpp         |    93 +
 base/poco/Data/src/SessionImpl.cpp            |    52 +
 base/poco/Data/src/SessionPool.cpp            |   308 +
 base/poco/Data/src/SessionPoolContainer.cpp   |   122 +
 base/poco/Data/src/SimpleRowFormatter.cpp     |   113 +
 base/poco/Data/src/Statement.cpp              |   296 +
 base/poco/Data/src/StatementCreator.cpp       |    60 +
 base/poco/Data/src/StatementImpl.cpp          |   476 +
 base/poco/Data/src/Time.cpp                   |   139 +
 base/poco/Data/src/Transaction.cpp            |   124 +
 base/poco/Foundation/CMakeLists.txt           |   211 +
 .../Foundation/include/Poco/ASCIIEncoding.h   |    51 +
 .../Foundation/include/Poco/AbstractCache.h   |   366 +
 .../include/Poco/AbstractDelegate.h           |   110 +
 .../Foundation/include/Poco/AbstractEvent.h   |   558 +
 .../include/Poco/AbstractObserver.h           |    50 +
 .../include/Poco/AbstractPriorityDelegate.h   |    63 +
 .../include/Poco/AbstractStrategy.h           |    77 +
 .../include/Poco/AccessExpirationDecorator.h  |    83 +
 .../include/Poco/AccessExpireCache.h          |    63 +
 .../include/Poco/AccessExpireLRUCache.h       |    62 +
 .../include/Poco/AccessExpireStrategy.h       |    74 +
 .../include/Poco/ActiveDispatcher.h           |   116 +
 .../Foundation/include/Poco/ActiveMethod.h    |   218 +
 .../Foundation/include/Poco/ActiveResult.h    |   495 +
 .../Foundation/include/Poco/ActiveRunnable.h  |   231 +
 .../Foundation/include/Poco/ActiveStarter.h   |    48 +
 base/poco/Foundation/include/Poco/Activity.h  |   208 +
 base/poco/Foundation/include/Poco/Alignment.h |   246 +
 base/poco/Foundation/include/Poco/Any.h       |   599 +
 .../Foundation/include/Poco/ArchiveStrategy.h |   173 +
 base/poco/Foundation/include/Poco/Array.h     |   249 +
 base/poco/Foundation/include/Poco/Ascii.h     |   220 +
 .../Foundation/include/Poco/AsyncChannel.h    |   100 +
 .../Foundation/include/Poco/AtomicCounter.h   |   417 +
 base/poco/Foundation/include/Poco/AutoPtr.h   |   386 +
 .../Foundation/include/Poco/AutoReleasePool.h |    86 +
 .../Foundation/include/Poco/Base32Decoder.h   |   104 +
 .../Foundation/include/Poco/Base32Encoder.h   |   110 +
 .../Foundation/include/Poco/Base64Decoder.h   |   108 +
 .../Foundation/include/Poco/Base64Encoder.h   |   138 +
 .../poco/Foundation/include/Poco/BasicEvent.h |    60 +
 .../Foundation/include/Poco/BinaryReader.h    |   265 +
 .../Foundation/include/Poco/BinaryWriter.h    |   269 +
 base/poco/Foundation/include/Poco/Buffer.h    |   329 +
 .../Foundation/include/Poco/BufferAllocator.h |    52 +
 .../Poco/BufferedBidirectionalStreamBuf.h     |   181 +
 .../include/Poco/BufferedStreamBuf.h          |   173 +
 base/poco/Foundation/include/Poco/Bugcheck.h  |   206 +
 base/poco/Foundation/include/Poco/ByteOrder.h |   239 +
 base/poco/Foundation/include/Poco/Channel.h   |    78 +
 base/poco/Foundation/include/Poco/Checksum.h  |   108 +
 .../Foundation/include/Poco/ClassLibrary.h    |   101 +
 .../Foundation/include/Poco/ClassLoader.h     |   365 +
 base/poco/Foundation/include/Poco/Clock.h     |   238 +
 .../include/Poco/CompressedLogFile.h          |    60 +
 base/poco/Foundation/include/Poco/Condition.h |   137 +
 base/poco/Foundation/include/Poco/Config.h    |   207 +
 .../Foundation/include/Poco/Configurable.h    |    70 +
 .../Foundation/include/Poco/ConsoleChannel.h  |   187 +
 .../Foundation/include/Poco/CountingStream.h  |   237 +
 base/poco/Foundation/include/Poco/DateTime.h  |   415 +
 .../Foundation/include/Poco/DateTimeFormat.h  |   109 +
 .../include/Poco/DateTimeFormatter.h          |   215 +
 .../Foundation/include/Poco/DateTimeParser.h  |   116 +
 base/poco/Foundation/include/Poco/Debugger.h  |    70 +
 .../Foundation/include/Poco/DefaultStrategy.h |   226 +
 .../Foundation/include/Poco/DeflatingStream.h |   201 +
 base/poco/Foundation/include/Poco/Delegate.h  |   452 +
 .../Foundation/include/Poco/DigestEngine.h    |   111 +
 .../Foundation/include/Poco/DigestStream.h    |   100 +
 .../include/Poco/DirectoryIterator.h          |   153 +
 .../include/Poco/DirectoryIteratorStrategy.h  |    92 +
 .../include/Poco/DirectoryIterator_UNIX.h     |    72 +
 .../include/Poco/DirectoryIterator_WIN32.h    |    73 +
 .../include/Poco/DirectoryIterator_WIN32U.h   |    73 +
 .../include/Poco/DirectoryWatcher.h           |   232 +
 .../Foundation/include/Poco/Dynamic/Pair.h    |   412 +
 .../Foundation/include/Poco/Dynamic/Struct.h  |   567 +
 .../Foundation/include/Poco/Dynamic/Var.h     |  2228 +++
 .../include/Poco/Dynamic/VarHolder.h          |  4186 ++++++
 .../include/Poco/Dynamic/VarIterator.h        |   150 +
 .../poco/Foundation/include/Poco/DynamicAny.h |    24 +
 .../include/Poco/DynamicAnyHolder.h           |    24 +
 .../Foundation/include/Poco/DynamicFactory.h  |   141 +
 .../Foundation/include/Poco/DynamicStruct.h   |    24 +
 .../Foundation/include/Poco/Environment.h     |   123 +
 .../include/Poco/Environment_UNIX.h           |    56 +
 .../Foundation/include/Poco/Environment_VX.h  |    56 +
 .../include/Poco/Environment_WIN32.h          |    48 +
 .../include/Poco/Environment_WIN32U.h         |    48 +
 .../include/Poco/Environment_WINCE.h          |    59 +
 base/poco/Foundation/include/Poco/Error.h     |    52 +
 .../Foundation/include/Poco/ErrorHandler.h    |   120 +
 base/poco/Foundation/include/Poco/Event.h     |   123 +
 base/poco/Foundation/include/Poco/EventArgs.h |    45 +
 .../Foundation/include/Poco/EventChannel.h    |    54 +
 .../Foundation/include/Poco/EventLogChannel.h |   105 +
 .../Foundation/include/Poco/Event_POSIX.h     |    77 +
 base/poco/Foundation/include/Poco/Event_VX.h  |    49 +
 .../Foundation/include/Poco/Event_WIN32.h     |    68 +
 base/poco/Foundation/include/Poco/Exception.h |   264 +
 .../include/Poco/ExpirationDecorator.h        |    92 +
 base/poco/Foundation/include/Poco/Expire.h    |   194 +
 .../Foundation/include/Poco/ExpireCache.h     |    65 +
 .../Foundation/include/Poco/ExpireLRUCache.h  |    62 +
 .../Foundation/include/Poco/ExpireStrategy.h  |   132 +
 .../poco/Foundation/include/Poco/FIFOBuffer.h |   556 +
 .../include/Poco/FIFOBufferStream.h           |   154 +
 base/poco/Foundation/include/Poco/FIFOEvent.h |    63 +
 .../Foundation/include/Poco/FIFOStrategy.h    |    59 +
 .../Foundation/include/Poco/FPEnvironment.h   |   207 +
 .../include/Poco/FPEnvironment_C99.h          |   125 +
 .../include/Poco/FPEnvironment_DEC.h          |    89 +
 .../include/Poco/FPEnvironment_DUMMY.h        |   125 +
 .../include/Poco/FPEnvironment_QNX.h          |   133 +
 .../include/Poco/FPEnvironment_SUN.h          |    74 +
 .../include/Poco/FPEnvironment_WIN32.h        |   150 +
 base/poco/Foundation/include/Poco/File.h      |   315 +
 .../Foundation/include/Poco/FileChannel.h     |   276 +
 .../poco/Foundation/include/Poco/FileStream.h |   176 +
 .../include/Poco/FileStreamFactory.h          |    61 +
 .../include/Poco/FileStream_POSIX.h           |    72 +
 .../include/Poco/FileStream_WIN32.h           |    71 +
 base/poco/Foundation/include/Poco/File_UNIX.h |    86 +
 base/poco/Foundation/include/Poco/File_VX.h   |    84 +
 .../poco/Foundation/include/Poco/File_WIN32.h |    87 +
 .../Foundation/include/Poco/File_WIN32U.h     |    91 +
 .../poco/Foundation/include/Poco/File_WINCE.h |    90 +
 base/poco/Foundation/include/Poco/Format.h    |   138 +
 base/poco/Foundation/include/Poco/Formatter.h |    74 +
 .../include/Poco/FormattingChannel.h          |    96 +
 .../poco/Foundation/include/Poco/Foundation.h |   168 +
 .../include/Poco/FunctionDelegate.h           |   438 +
 .../include/Poco/FunctionPriorityDelegate.h   |   450 +
 base/poco/Foundation/include/Poco/Glob.h      |   152 +
 .../poco/Foundation/include/Poco/HMACEngine.h |   146 +
 base/poco/Foundation/include/Poco/Hash.h      |   105 +
 .../Foundation/include/Poco/HashFunction.h    |    57 +
 base/poco/Foundation/include/Poco/HashMap.h   |   228 +
 base/poco/Foundation/include/Poco/HashSet.h   |   177 +
 .../Foundation/include/Poco/HashStatistic.h   |   126 +
 base/poco/Foundation/include/Poco/HashTable.h |   369 +
 .../include/Poco/HexBinaryDecoder.h           |    94 +
 .../include/Poco/HexBinaryEncoder.h           |   117 +
 .../Foundation/include/Poco/InflatingStream.h |   211 +
 .../Foundation/include/Poco/Instantiator.h    |    82 +
 .../poco/Foundation/include/Poco/JSONString.h |    93 +
 .../Foundation/include/Poco/KeyValueArgs.h    |    73 +
 base/poco/Foundation/include/Poco/LRUCache.h  |    56 +
 .../Foundation/include/Poco/LRUStrategy.h     |   140 +
 .../Foundation/include/Poco/Latin1Encoding.h  |    51 +
 .../Foundation/include/Poco/Latin2Encoding.h  |    54 +
 .../Foundation/include/Poco/Latin9Encoding.h  |    54 +
 .../include/Poco/LineEndingConverter.h        |   181 +
 .../Foundation/include/Poco/LinearHashTable.h |   503 +
 base/poco/Foundation/include/Poco/ListMap.h   |   246 +
 .../Foundation/include/Poco/LocalDateTime.h   |   388 +
 base/poco/Foundation/include/Poco/LogFile.h   |   104 +
 .../Foundation/include/Poco/LogFile_STD.h     |    53 +
 .../Foundation/include/Poco/LogFile_WIN32.h   |    55 +
 .../Foundation/include/Poco/LogFile_WIN32U.h  |    55 +
 base/poco/Foundation/include/Poco/LogStream.h |   192 +
 base/poco/Foundation/include/Poco/Logger.h    |  1447 ++
 .../Foundation/include/Poco/LoggingFactory.h  |    92 +
 .../Foundation/include/Poco/LoggingRegistry.h |    99 +
 base/poco/Foundation/include/Poco/MD4Engine.h |    95 +
 base/poco/Foundation/include/Poco/MD5Engine.h |    95 +
 base/poco/Foundation/include/Poco/Manifest.h  |   180 +
 .../poco/Foundation/include/Poco/MemoryPool.h |   115 +
 .../Foundation/include/Poco/MemoryStream.h    |   246 +
 base/poco/Foundation/include/Poco/Message.h   |   270 +
 .../poco/Foundation/include/Poco/MetaObject.h |   201 +
 .../Foundation/include/Poco/MetaProgramming.h |   144 +
 base/poco/Foundation/include/Poco/Mutex.h     |   270 +
 .../Foundation/include/Poco/Mutex_POSIX.h     |    86 +
 base/poco/Foundation/include/Poco/Mutex_VX.h  |    80 +
 .../Foundation/include/Poco/Mutex_WIN32.h     |    85 +
 .../Foundation/include/Poco/Mutex_WINCE.h     |    50 +
 base/poco/Foundation/include/Poco/NObserver.h |   126 +
 .../poco/Foundation/include/Poco/NamedEvent.h |    96 +
 .../include/Poco/NamedEvent_Android.h         |    40 +
 .../Foundation/include/Poco/NamedEvent_UNIX.h |    53 +
 .../include/Poco/NamedEvent_WIN32.h           |    45 +
 .../include/Poco/NamedEvent_WIN32U.h          |    46 +
 .../poco/Foundation/include/Poco/NamedMutex.h |   110 +
 .../include/Poco/NamedMutex_Android.h         |    41 +
 .../Foundation/include/Poco/NamedMutex_UNIX.h |    57 +
 .../include/Poco/NamedMutex_WIN32.h           |    46 +
 .../include/Poco/NamedMutex_WIN32U.h          |    47 +
 .../poco/Foundation/include/Poco/NamedTuple.h |  4462 ++++++
 .../include/Poco/NestedDiagnosticContext.h    |   181 +
 .../Foundation/include/Poco/Notification.h    |    55 +
 .../include/Poco/NotificationCenter.h         |   139 +
 .../include/Poco/NotificationQueue.h          |   155 +
 .../include/Poco/NotificationStrategy.h       |   112 +
 .../Foundation/include/Poco/NullChannel.h     |    55 +
 .../poco/Foundation/include/Poco/NullStream.h |    90 +
 base/poco/Foundation/include/Poco/Nullable.h  |   323 +
 .../Foundation/include/Poco/NumberFormatter.h |   907 ++
 .../Foundation/include/Poco/NumberParser.h    |   156 +
 .../Foundation/include/Poco/NumericString.h   |   560 +
 .../poco/Foundation/include/Poco/ObjectPool.h |   332 +
 base/poco/Foundation/include/Poco/Observer.h  |   124 +
 base/poco/Foundation/include/Poco/Optional.h  |   161 +
 .../Foundation/include/Poco/PBKDF2Engine.h    |   149 +
 base/poco/Foundation/include/Poco/Path.h      |   501 +
 base/poco/Foundation/include/Poco/Path_UNIX.h |    48 +
 .../poco/Foundation/include/Poco/Path_WIN32.h |    49 +
 .../Foundation/include/Poco/Path_WIN32U.h     |    54 +
 .../poco/Foundation/include/Poco/Path_WINCE.h |    54 +
 .../include/Poco/PatternFormatter.h           |   148 +
 base/poco/Foundation/include/Poco/Pipe.h      |   142 +
 base/poco/Foundation/include/Poco/PipeImpl.h  |    37 +
 .../Foundation/include/Poco/PipeImpl_DUMMY.h  |    49 +
 .../Foundation/include/Poco/PipeImpl_POSIX.h  |    53 +
 .../Foundation/include/Poco/PipeImpl_WIN32.h  |    54 +
 .../poco/Foundation/include/Poco/PipeStream.h |   120 +
 base/poco/Foundation/include/Poco/Platform.h  |   284 +
 .../Foundation/include/Poco/Platform_POSIX.h  |    53 +
 .../Foundation/include/Poco/Platform_VX.h     |    29 +
 .../Foundation/include/Poco/Platform_WIN32.h  |   216 +
 base/poco/Foundation/include/Poco/Poco.h      |    24 +
 .../include/Poco/PriorityDelegate.h           |   464 +
 .../Foundation/include/Poco/PriorityEvent.h   |    61 +
 .../Foundation/include/Poco/PriorityExpire.h  |   195 +
 .../include/Poco/PriorityNotificationQueue.h  |   158 +
 .../include/Poco/PriorityStrategy.h           |   230 +
 base/poco/Foundation/include/Poco/Process.h   |   266 +
 .../Foundation/include/Poco/Process_UNIX.h    |    86 +
 .../poco/Foundation/include/Poco/Process_VX.h |    78 +
 .../Foundation/include/Poco/Process_WIN32.h   |    83 +
 .../Foundation/include/Poco/Process_WIN32U.h  |    83 +
 .../Foundation/include/Poco/Process_WINCE.h   |    83 +
 .../Foundation/include/Poco/PurgeStrategy.h   |   107 +
 base/poco/Foundation/include/Poco/RWLock.h    |   203 +
 .../Foundation/include/Poco/RWLock_Android.h  |    97 +
 .../Foundation/include/Poco/RWLock_POSIX.h    |    99 +
 base/poco/Foundation/include/Poco/RWLock_VX.h |    92 +
 .../Foundation/include/Poco/RWLock_WIN32.h    |    57 +
 .../Foundation/include/Poco/RWLock_WINCE.h    |    61 +
 base/poco/Foundation/include/Poco/Random.h    |   165 +
 .../Foundation/include/Poco/RandomStream.h    |    73 +
 .../include/Poco/RecursiveDirectoryIterator.h |   254 +
 .../Poco/RecursiveDirectoryIteratorImpl.h     |   111 +
 .../include/Poco/RefCountedObject.h           |    94 +
 .../include/Poco/RegularExpression.h          |   247 +
 .../Foundation/include/Poco/RotateStrategy.h  |   165 +
 base/poco/Foundation/include/Poco/Runnable.h  |    45 +
 .../Foundation/include/Poco/RunnableAdapter.h |    78 +
 .../poco/Foundation/include/Poco/SHA1Engine.h |    81 +
 .../poco/Foundation/include/Poco/ScopedLock.h |   121 +
 .../Foundation/include/Poco/ScopedUnlock.h    |    64 +
 base/poco/Foundation/include/Poco/Semaphore.h |   137 +
 .../Foundation/include/Poco/Semaphore_POSIX.h |    75 +
 .../Foundation/include/Poco/Semaphore_VX.h    |    56 +
 .../Foundation/include/Poco/Semaphore_WIN32.h |    58 +
 .../Foundation/include/Poco/SharedLibrary.h   |   144 +
 .../include/Poco/SharedLibrary_HPUX.h         |    52 +
 .../include/Poco/SharedLibrary_UNIX.h         |    57 +
 .../include/Poco/SharedLibrary_VX.h           |    52 +
 .../include/Poco/SharedLibrary_WIN32.h        |    51 +
 .../include/Poco/SharedLibrary_WIN32U.h       |    51 +
 .../Foundation/include/Poco/SharedMemory.h    |   113 +
 .../include/Poco/SharedMemory_DUMMY.h         |    88 +
 .../include/Poco/SharedMemory_POSIX.h         |   107 +
 .../include/Poco/SharedMemory_WIN32.h         |   103 +
 base/poco/Foundation/include/Poco/SharedPtr.h |   448 +
 .../Foundation/include/Poco/SignalHandler.h   |   129 +
 .../include/Poco/SimpleFileChannel.h          |   150 +
 .../Foundation/include/Poco/SimpleHashTable.h |   398 +
 .../Foundation/include/Poco/SingletonHolder.h |    77 +
 .../include/Poco/SortedDirectoryIterator.h    |    70 +
 .../Foundation/include/Poco/SplitterChannel.h |    77 +
 base/poco/Foundation/include/Poco/Stopwatch.h |   108 +
 .../include/Poco/StrategyCollection.h         |   133 +
 .../Foundation/include/Poco/StreamChannel.h   |    59 +
 .../Foundation/include/Poco/StreamConverter.h |   128 +
 .../Foundation/include/Poco/StreamCopier.h    |    85 +
 .../Foundation/include/Poco/StreamTokenizer.h |    97 +
 .../poco/Foundation/include/Poco/StreamUtil.h |    92 +
 base/poco/Foundation/include/Poco/String.h    |   706 +
 .../Foundation/include/Poco/StringTokenizer.h |   135 +
 .../include/Poco/SynchronizedObject.h         |   131 +
 .../Foundation/include/Poco/SyslogChannel.h   |   109 +
 base/poco/Foundation/include/Poco/Task.h      |   190 +
 .../Foundation/include/Poco/TaskManager.h     |   137 +
 .../include/Poco/TaskNotification.h           |   170 +
 base/poco/Foundation/include/Poco/TeeStream.h |   132 +
 .../Foundation/include/Poco/TemporaryFile.h   |    84 +
 .../include/Poco/TextBufferIterator.h         |   145 +
 .../Foundation/include/Poco/TextConverter.h   |    93 +
 .../Foundation/include/Poco/TextEncoding.h    |   185 +
 .../Foundation/include/Poco/TextIterator.h    |   141 +
 base/poco/Foundation/include/Poco/Thread.h    |   367 +
 .../Foundation/include/Poco/ThreadLocal.h     |   157 +
 .../poco/Foundation/include/Poco/ThreadPool.h |   208 +
 .../Foundation/include/Poco/ThreadTarget.h    |    87 +
 .../Foundation/include/Poco/Thread_POSIX.h    |   198 +
 base/poco/Foundation/include/Poco/Thread_VX.h |   169 +
 .../Foundation/include/Poco/Thread_WIN32.h    |   183 +
 .../Foundation/include/Poco/Thread_WINCE.h    |   179 +
 .../include/Poco/TimedNotificationQueue.h     |   143 +
 base/poco/Foundation/include/Poco/Timer.h     |   229 +
 base/poco/Foundation/include/Poco/Timespan.h  |   303 +
 base/poco/Foundation/include/Poco/Timestamp.h |   277 +
 base/poco/Foundation/include/Poco/Timezone.h  |    67 +
 base/poco/Foundation/include/Poco/Token.h     |   172 +
 base/poco/Foundation/include/Poco/Tuple.h     |  1747 +++
 base/poco/Foundation/include/Poco/TypeList.h  |   483 +
 base/poco/Foundation/include/Poco/Types.h     |   201 +
 base/poco/Foundation/include/Poco/URI.h       |   406 +
 .../include/Poco/URIStreamFactory.h           |    97 +
 .../Foundation/include/Poco/URIStreamOpener.h |   135 +
 .../Foundation/include/Poco/UTF16Encoding.h   |    85 +
 .../Foundation/include/Poco/UTF32Encoding.h   |    82 +
 .../Foundation/include/Poco/UTF8Encoding.h    |    61 +
 .../poco/Foundation/include/Poco/UTF8String.h |    83 +
 base/poco/Foundation/include/Poco/UTFString.h |   305 +
 base/poco/Foundation/include/Poco/UUID.h      |   219 +
 .../Foundation/include/Poco/UUIDGenerator.h   |   104 +
 base/poco/Foundation/include/Poco/UnWindows.h |   142 +
 .../include/Poco/UnbufferedStreamBuf.h        |   179 +
 base/poco/Foundation/include/Poco/Unicode.h   |   327 +
 .../include/Poco/UnicodeConverter.h           |   141 +
 .../include/Poco/UniqueAccessExpireCache.h    |    73 +
 .../include/Poco/UniqueAccessExpireLRUCache.h |    71 +
 .../include/Poco/UniqueAccessExpireStrategy.h |   156 +
 .../include/Poco/UniqueExpireCache.h          |    72 +
 .../include/Poco/UniqueExpireLRUCache.h       |    70 +
 .../include/Poco/UniqueExpireStrategy.h       |   138 +
 base/poco/Foundation/include/Poco/ValidArgs.h |    74 +
 base/poco/Foundation/include/Poco/Version.h   |    42 +
 base/poco/Foundation/include/Poco/Void.h      |    73 +
 .../include/Poco/Windows1250Encoding.h        |    52 +
 .../include/Poco/Windows1251Encoding.h        |    52 +
 .../include/Poco/Windows1252Encoding.h        |    51 +
 .../include/Poco/WindowsConsoleChannel.h      |   183 +
 base/poco/Foundation/src/ASCIIEncoding.cpp    |   116 +
 base/poco/Foundation/src/AbstractObserver.cpp |    42 +
 base/poco/Foundation/src/ActiveDispatcher.cpp |   116 +
 base/poco/Foundation/src/ArchiveStrategy.cpp  |   212 +
 base/poco/Foundation/src/Ascii.cpp            |   154 +
 base/poco/Foundation/src/AsyncChannel.cpp     |   168 +
 base/poco/Foundation/src/AtomicCounter.cpp    |   231 +
 base/poco/Foundation/src/Base32Decoder.cpp    |   160 +
 base/poco/Foundation/src/Base32Encoder.cpp    |   202 +
 base/poco/Foundation/src/Base64Decoder.cpp    |   178 +
 base/poco/Foundation/src/Base64Encoder.cpp    |   183 +
 base/poco/Foundation/src/BinaryReader.cpp     |   287 +
 base/poco/Foundation/src/BinaryWriter.cpp     |   351 +
 base/poco/Foundation/src/Bugcheck.cpp         |   119 +
 base/poco/Foundation/src/ByteOrder.cpp        |    15 +
 base/poco/Foundation/src/Channel.cpp          |    53 +
 base/poco/Foundation/src/Checksum.cpp         |    58 +
 base/poco/Foundation/src/Clock.cpp            |   231 +
 .../poco/Foundation/src/CompressedLogFile.cpp |   112 +
 base/poco/Foundation/src/Condition.cpp        |    79 +
 base/poco/Foundation/src/Configurable.cpp     |    31 +
 base/poco/Foundation/src/ConsoleChannel.cpp   |   281 +
 base/poco/Foundation/src/CountingStream.cpp   |   199 +
 base/poco/Foundation/src/DateTime.cpp         |   432 +
 base/poco/Foundation/src/DateTimeFormat.cpp   |    61 +
 .../poco/Foundation/src/DateTimeFormatter.cpp |   155 +
 base/poco/Foundation/src/DateTimeParser.cpp   |   393 +
 base/poco/Foundation/src/Debugger.cpp         |   150 +
 base/poco/Foundation/src/DeflatingStream.cpp  |   390 +
 base/poco/Foundation/src/DigestEngine.cpp     |    99 +
 base/poco/Foundation/src/DigestStream.cpp     |   150 +
 .../poco/Foundation/src/DirectoryIterator.cpp |   145 +
 .../src/DirectoryIteratorStrategy.cpp         |   168 +
 .../Foundation/src/DirectoryIterator_UNIX.cpp |    64 +
 .../src/DirectoryIterator_WIN32.cpp           |    66 +
 .../src/DirectoryIterator_WIN32U.cpp          |    75 +
 base/poco/Foundation/src/DirectoryWatcher.cpp |   608 +
 base/poco/Foundation/src/Environment.cpp      |   160 +
 base/poco/Foundation/src/Environment_UNIX.cpp |   332 +
 base/poco/Foundation/src/Environment_VX.cpp   |   159 +
 .../poco/Foundation/src/Environment_WIN32.cpp |   221 +
 .../Foundation/src/Environment_WIN32U.cpp     |   235 +
 .../poco/Foundation/src/Environment_WINCE.cpp |   243 +
 base/poco/Foundation/src/Error.cpp            |   117 +
 base/poco/Foundation/src/ErrorHandler.cpp     |   114 +
 base/poco/Foundation/src/Event.cpp            |    40 +
 base/poco/Foundation/src/EventArgs.cpp        |    33 +
 base/poco/Foundation/src/EventChannel.cpp     |    37 +
 base/poco/Foundation/src/EventLogChannel.cpp  |   319 +
 base/poco/Foundation/src/Event_POSIX.cpp      |   170 +
 base/poco/Foundation/src/Event_VX.cpp         |    79 +
 base/poco/Foundation/src/Event_WIN32.cpp      |    61 +
 base/poco/Foundation/src/Exception.cpp        |   185 +
 base/poco/Foundation/src/FIFOBufferStream.cpp |   186 +
 base/poco/Foundation/src/FPEnvironment.cpp    |    83 +
 .../poco/Foundation/src/FPEnvironment_C99.cpp |    82 +
 .../poco/Foundation/src/FPEnvironment_DEC.cpp |   195 +
 .../Foundation/src/FPEnvironment_DUMMY.cpp    |    79 +
 .../poco/Foundation/src/FPEnvironment_QNX.cpp |    82 +
 .../poco/Foundation/src/FPEnvironment_SUN.cpp |   139 +
 .../Foundation/src/FPEnvironment_WIN32.cpp    |    76 +
 base/poco/Foundation/src/File.cpp             |   394 +
 base/poco/Foundation/src/FileChannel.cpp      |   570 +
 base/poco/Foundation/src/FileStream.cpp       |   121 +
 .../poco/Foundation/src/FileStreamFactory.cpp |    64 +
 base/poco/Foundation/src/FileStream_POSIX.cpp |   170 +
 base/poco/Foundation/src/FileStream_WIN32.cpp |   208 +
 base/poco/Foundation/src/File_UNIX.cpp        |   527 +
 base/poco/Foundation/src/File_VX.cpp          |   408 +
 base/poco/Foundation/src/File_WIN32.cpp       |   465 +
 base/poco/Foundation/src/File_WIN32U.cpp      |   492 +
 base/poco/Foundation/src/File_WINCE.cpp       |   441 +
 base/poco/Foundation/src/Format.cpp           |   476 +
 base/poco/Foundation/src/Formatter.cpp        |    44 +
 .../poco/Foundation/src/FormattingChannel.cpp |   126 +
 base/poco/Foundation/src/Glob.cpp             |   285 +
 base/poco/Foundation/src/Hash.cpp             |    34 +
 base/poco/Foundation/src/HashStatistic.cpp    |    64 +
 base/poco/Foundation/src/HexBinaryDecoder.cpp |    94 +
 base/poco/Foundation/src/HexBinaryEncoder.cpp |   117 +
 base/poco/Foundation/src/InflatingStream.cpp  |   360 +
 base/poco/Foundation/src/JSONString.cpp       |   101 +
 base/poco/Foundation/src/Latin1Encoding.cpp   |   119 +
 base/poco/Foundation/src/Latin2Encoding.cpp   |   179 +
 base/poco/Foundation/src/Latin9Encoding.cpp   |   130 +
 .../Foundation/src/LineEndingConverter.cpp    |   175 +
 base/poco/Foundation/src/LocalDateTime.cpp    |   317 +
 base/poco/Foundation/src/LogFile.cpp          |    40 +
 base/poco/Foundation/src/LogFile_STD.cpp      |    76 +
 base/poco/Foundation/src/LogFile_WIN32.cpp    |   125 +
 base/poco/Foundation/src/LogFile_WIN32U.cpp   |   130 +
 base/poco/Foundation/src/LogStream.cpp        |   231 +
 base/poco/Foundation/src/Logger.cpp           |   485 +
 base/poco/Foundation/src/LoggingFactory.cpp   |   117 +
 base/poco/Foundation/src/LoggingRegistry.cpp  |   117 +
 base/poco/Foundation/src/MD4Engine.cpp        |   278 +
 base/poco/Foundation/src/MD5Engine.cpp        |   309 +
 base/poco/Foundation/src/Manifest.cpp         |    31 +
 base/poco/Foundation/src/MemoryPool.cpp       |   105 +
 base/poco/Foundation/src/MemoryStream.cpp     |    57 +
 base/poco/Foundation/src/Message.cpp          |   289 +
 base/poco/Foundation/src/Mutex.cpp            |    54 +
 base/poco/Foundation/src/Mutex_POSIX.cpp      |   175 +
 base/poco/Foundation/src/Mutex_VX.cpp         |    68 +
 base/poco/Foundation/src/Mutex_WIN32.cpp      |    59 +
 base/poco/Foundation/src/Mutex_WINCE.cpp      |    80 +
 base/poco/Foundation/src/NamedEvent.cpp       |    43 +
 .../Foundation/src/NamedEvent_Android.cpp     |    44 +
 base/poco/Foundation/src/NamedEvent_UNIX.cpp  |   148 +
 base/poco/Foundation/src/NamedEvent_WIN32.cpp |    61 +
 .../poco/Foundation/src/NamedEvent_WIN32U.cpp |    63 +
 base/poco/Foundation/src/NamedMutex.cpp       |    43 +
 .../Foundation/src/NamedMutex_Android.cpp     |    50 +
 base/poco/Foundation/src/NamedMutex_UNIX.cpp  |   170 +
 base/poco/Foundation/src/NamedMutex_WIN32.cpp |    73 +
 .../poco/Foundation/src/NamedMutex_WIN32U.cpp |    75 +
 .../src/NestedDiagnosticContext.cpp           |   129 +
 base/poco/Foundation/src/Notification.cpp     |    38 +
 .../Foundation/src/NotificationCenter.cpp     |   109 +
 .../poco/Foundation/src/NotificationQueue.cpp |   211 +
 base/poco/Foundation/src/NullChannel.cpp      |    41 +
 base/poco/Foundation/src/NullStream.cpp       |    74 +
 base/poco/Foundation/src/NumberFormatter.cpp  |   492 +
 base/poco/Foundation/src/NumberParser.cpp     |   250 +
 base/poco/Foundation/src/NumericString.cpp    |   316 +
 base/poco/Foundation/src/Path.cpp             |  1064 ++
 base/poco/Foundation/src/Path_UNIX.cpp        |   265 +
 base/poco/Foundation/src/Path_WIN32.cpp       |   203 +
 base/poco/Foundation/src/Path_WIN32U.cpp      |   222 +
 base/poco/Foundation/src/Path_WINCE.cpp       |   144 +
 base/poco/Foundation/src/PatternFormatter.cpp |   247 +
 base/poco/Foundation/src/Pipe.cpp             |    70 +
 base/poco/Foundation/src/PipeImpl.cpp         |    28 +
 base/poco/Foundation/src/PipeImpl_DUMMY.cpp   |    65 +
 base/poco/Foundation/src/PipeImpl_POSIX.cpp   |   111 +
 base/poco/Foundation/src/PipeImpl_WIN32.cpp   |    97 +
 base/poco/Foundation/src/PipeStream.cpp       |   127 +
 .../src/PriorityNotificationQueue.cpp         |   195 +
 base/poco/Foundation/src/Process.cpp          |   197 +
 base/poco/Foundation/src/Process_UNIX.cpp     |   280 +
 base/poco/Foundation/src/Process_VX.cpp       |   100 +
 base/poco/Foundation/src/Process_WIN32.cpp    |   349 +
 base/poco/Foundation/src/Process_WIN32U.cpp   |   371 +
 base/poco/Foundation/src/Process_WINCE.cpp    |   223 +
 base/poco/Foundation/src/PurgeStrategy.cpp    |   154 +
 base/poco/Foundation/src/RWLock.cpp           |    46 +
 base/poco/Foundation/src/RWLock_Android.cpp   |    39 +
 base/poco/Foundation/src/RWLock_POSIX.cpp     |    34 +
 base/poco/Foundation/src/RWLock_VX.cpp        |    48 +
 base/poco/Foundation/src/RWLock_WIN32.cpp     |   207 +
 base/poco/Foundation/src/RWLock_WINCE.cpp     |   174 +
 base/poco/Foundation/src/Random.cpp           |   364 +
 base/poco/Foundation/src/RandomStream.cpp     |   127 +
 base/poco/Foundation/src/RefCountedObject.cpp |    31 +
 .../poco/Foundation/src/RegularExpression.cpp |   284 +
 base/poco/Foundation/src/RotateStrategy.cpp   |   113 +
 base/poco/Foundation/src/Runnable.cpp         |    32 +
 base/poco/Foundation/src/SHA1Engine.cpp       |   283 +
 base/poco/Foundation/src/Semaphore.cpp        |    45 +
 base/poco/Foundation/src/Semaphore_POSIX.cpp  |   170 +
 base/poco/Foundation/src/Semaphore_VX.cpp     |    52 +
 base/poco/Foundation/src/Semaphore_WIN32.cpp  |    65 +
 base/poco/Foundation/src/SharedLibrary.cpp    |   115 +
 .../Foundation/src/SharedLibrary_HPUX.cpp     |   100 +
 .../Foundation/src/SharedLibrary_UNIX.cpp     |   136 +
 base/poco/Foundation/src/SharedLibrary_VX.cpp |   141 +
 .../Foundation/src/SharedLibrary_WIN32.cpp    |   108 +
 .../Foundation/src/SharedLibrary_WIN32U.cpp   |   121 +
 base/poco/Foundation/src/SharedMemory.cpp     |    90 +
 .../Foundation/src/SharedMemory_DUMMY.cpp     |    36 +
 .../Foundation/src/SharedMemory_POSIX.cpp     |   134 +
 .../Foundation/src/SharedMemory_WIN32.cpp     |   168 +
 base/poco/Foundation/src/SignalHandler.cpp    |   111 +
 .../poco/Foundation/src/SimpleFileChannel.cpp |   227 +
 .../src/SortedDirectoryIterator.cpp           |   122 +
 base/poco/Foundation/src/SplitterChannel.cpp  |   113 +
 base/poco/Foundation/src/Stopwatch.cpp        |    60 +
 base/poco/Foundation/src/StreamChannel.cpp    |    40 +
 base/poco/Foundation/src/StreamConverter.cpp  |   192 +
 base/poco/Foundation/src/StreamCopier.cpp     |   150 +
 base/poco/Foundation/src/StreamTokenizer.cpp  |   105 +
 base/poco/Foundation/src/String.cpp           |   240 +
 base/poco/Foundation/src/StringTokenizer.cpp  |   135 +
 .../Foundation/src/SynchronizedObject.cpp     |    31 +
 base/poco/Foundation/src/SyslogChannel.cpp    |   257 +
 base/poco/Foundation/src/Task.cpp             |   146 +
 base/poco/Foundation/src/TaskManager.cpp      |   156 +
 base/poco/Foundation/src/TaskNotification.cpp |    92 +
 base/poco/Foundation/src/TeeStream.cpp        |   133 +
 base/poco/Foundation/src/TemporaryFile.cpp    |   167 +
 .../Foundation/src/TextBufferIterator.cpp     |   178 +
 base/poco/Foundation/src/TextConverter.cpp    |   128 +
 base/poco/Foundation/src/TextEncoding.cpp     |   208 +
 base/poco/Foundation/src/TextIterator.cpp     |   175 +
 base/poco/Foundation/src/Thread.cpp           |   212 +
 base/poco/Foundation/src/ThreadLocal.cpp      |    85 +
 base/poco/Foundation/src/ThreadPool.cpp       |   527 +
 base/poco/Foundation/src/ThreadTarget.cpp     |    43 +
 base/poco/Foundation/src/Thread_POSIX.cpp     |   412 +
 base/poco/Foundation/src/Thread_VX.cpp        |   273 +
 base/poco/Foundation/src/Thread_WIN32.cpp     |   223 +
 base/poco/Foundation/src/Thread_WINCE.cpp     |   169 +
 .../Foundation/src/TimedNotificationQueue.cpp |   203 +
 base/poco/Foundation/src/Timer.cpp            |   247 +
 base/poco/Foundation/src/Timespan.cpp         |   145 +
 base/poco/Foundation/src/Timestamp.cpp        |   313 +
 base/poco/Foundation/src/Timezone.cpp         |    41 +
 base/poco/Foundation/src/Timezone_UNIX.cpp    |   110 +
 base/poco/Foundation/src/Timezone_VX.cpp      |    78 +
 base/poco/Foundation/src/Timezone_WIN32.cpp   |   101 +
 base/poco/Foundation/src/Timezone_WINCE.cpp   |    92 +
 base/poco/Foundation/src/Token.cpp            |   166 +
 base/poco/Foundation/src/URI.cpp              |   918 ++
 base/poco/Foundation/src/URIStreamFactory.cpp |    58 +
 base/poco/Foundation/src/URIStreamOpener.cpp  |   211 +
 base/poco/Foundation/src/UTF16Encoding.cpp    |   273 +
 base/poco/Foundation/src/UTF32Encoding.cpp    |   178 +
 base/poco/Foundation/src/UTF8Encoding.cpp     |   246 +
 base/poco/Foundation/src/UTF8String.cpp       |   377 +
 base/poco/Foundation/src/UUID.cpp             |   370 +
 base/poco/Foundation/src/UUIDGenerator.cpp    |   151 +
 base/poco/Foundation/src/Unicode.cpp          |    56 +
 base/poco/Foundation/src/UnicodeConverter.cpp |   161 +
 base/poco/Foundation/src/Var.cpp              |   636 +
 base/poco/Foundation/src/VarHolder.cpp        |    92 +
 base/poco/Foundation/src/VarIterator.cpp      |   167 +
 base/poco/Foundation/src/Void.cpp             |    42 +
 .../Foundation/src/Windows1250Encoding.cpp    |   196 +
 .../Foundation/src/Windows1251Encoding.cpp    |   237 +
 .../Foundation/src/Windows1252Encoding.cpp    |   151 +
 .../Foundation/src/WindowsConsoleChannel.cpp  |   302 +
 base/poco/Foundation/src/adler32.c            |   188 +
 base/poco/Foundation/src/bignum-dtoa.cc       |   641 +
 base/poco/Foundation/src/bignum-dtoa.h        |    84 +
 base/poco/Foundation/src/bignum.cc            |   766 +
 base/poco/Foundation/src/bignum.h             |   145 +
 base/poco/Foundation/src/cached-powers.cc     |   176 +
 base/poco/Foundation/src/cached-powers.h      |    64 +
 base/poco/Foundation/src/compress.c           |    86 +
 base/poco/Foundation/src/crc32.c              |   444 +
 base/poco/Foundation/src/crc32.h              |   441 +
 base/poco/Foundation/src/deflate.c            |  2163 +++
 base/poco/Foundation/src/deflate.h            |   349 +
 base/poco/Foundation/src/diy-fp.cc            |    57 +
 base/poco/Foundation/src/diy-fp.h             |   118 +
 base/poco/Foundation/src/double-conversion.cc |   911 ++
 base/poco/Foundation/src/double-conversion.h  |   536 +
 base/poco/Foundation/src/fast-dtoa.cc         |   665 +
 base/poco/Foundation/src/fast-dtoa.h          |    88 +
 base/poco/Foundation/src/fixed-dtoa.cc        |   404 +
 base/poco/Foundation/src/fixed-dtoa.h         |    56 +
 base/poco/Foundation/src/gzguts.h             |   219 +
 base/poco/Foundation/src/ieee.h               |   402 +
 base/poco/Foundation/src/infback.c            |   640 +
 base/poco/Foundation/src/inffast.c            |   323 +
 base/poco/Foundation/src/inffast.h            |    11 +
 base/poco/Foundation/src/inffixed.h           |    94 +
 base/poco/Foundation/src/inflate.c            |  1561 ++
 base/poco/Foundation/src/inflate.h            |   125 +
 base/poco/Foundation/src/inftrees.c           |   304 +
 base/poco/Foundation/src/inftrees.h           |    62 +
 base/poco/Foundation/src/pcre.h               |   677 +
 base/poco/Foundation/src/pcre_byte_order.c    |   315 +
 base/poco/Foundation/src/pcre_chartables.c    |   195 +
 base/poco/Foundation/src/pcre_compile.c       |  9806 +++++++++++++
 base/poco/Foundation/src/pcre_config.c        |   187 +
 base/poco/Foundation/src/pcre_config.h        |   413 +
 base/poco/Foundation/src/pcre_dfa_exec.c      |  3675 +++++
 base/poco/Foundation/src/pcre_exec.c          |  7174 ++++++++++
 base/poco/Foundation/src/pcre_fullinfo.c      |   242 +
 base/poco/Foundation/src/pcre_get.c           |   666 +
 base/poco/Foundation/src/pcre_globals.c       |    83 +
 base/poco/Foundation/src/pcre_internal.h      |  2807 ++++
 base/poco/Foundation/src/pcre_jit_compile.c   | 11912 ++++++++++++++++
 base/poco/Foundation/src/pcre_maketables.c    |   155 +
 base/poco/Foundation/src/pcre_newline.c       |   207 +
 base/poco/Foundation/src/pcre_ord2utf8.c      |    92 +
 base/poco/Foundation/src/pcre_refcount.c      |    90 +
 base/poco/Foundation/src/pcre_string_utils.c  |   207 +
 base/poco/Foundation/src/pcre_study.c         |  1683 +++
 base/poco/Foundation/src/pcre_tables.c        |   723 +
 base/poco/Foundation/src/pcre_ucd.c           |  3641 +++++
 base/poco/Foundation/src/pcre_valid_utf8.c    |   298 +
 base/poco/Foundation/src/pcre_version.c       |    94 +
 base/poco/Foundation/src/pcre_xclass.c        |   264 +
 base/poco/Foundation/src/pocomsg.mc           |    87 +
 base/poco/Foundation/src/strtod.cc            |   556 +
 base/poco/Foundation/src/strtod.h             |    45 +
 base/poco/Foundation/src/trees.c              |  1203 ++
 base/poco/Foundation/src/trees.h              |   128 +
 base/poco/Foundation/src/ucp.h                |   224 +
 base/poco/Foundation/src/utils.h              |   325 +
 base/poco/Foundation/src/zutil.c              |   324 +
 base/poco/Foundation/src/zutil.h              |   253 +
 base/poco/JSON/CMakeLists.txt                 |    18 +
 base/poco/JSON/include/Poco/JSON/Array.h      |   566 +
 base/poco/JSON/include/Poco/JSON/Handler.h    |   106 +
 base/poco/JSON/include/Poco/JSON/JSON.h       |    62 +
 .../JSON/include/Poco/JSON/JSONException.h    |    35 +
 base/poco/JSON/include/Poco/JSON/Object.h     |   715 +
 .../JSON/include/Poco/JSON/ParseHandler.h     |   169 +
 base/poco/JSON/include/Poco/JSON/Parser.h     |   203 +
 base/poco/JSON/include/Poco/JSON/ParserImpl.h |   194 +
 .../JSON/include/Poco/JSON/PrintHandler.h     |   139 +
 base/poco/JSON/include/Poco/JSON/Query.h      |   125 +
 .../poco/JSON/include/Poco/JSON/Stringifier.h |    73 +
 base/poco/JSON/include/Poco/JSON/Template.h   |   151 +
 .../JSON/include/Poco/JSON/TemplateCache.h    |   105 +
 base/poco/JSON/src/Array.cpp                  |   268 +
 base/poco/JSON/src/Handler.cpp                |    45 +
 base/poco/JSON/src/JSONException.cpp          |    26 +
 base/poco/JSON/src/Object.cpp                 |   298 +
 base/poco/JSON/src/ParseHandler.cpp           |   148 +
 base/poco/JSON/src/Parser.cpp                 |    49 +
 base/poco/JSON/src/ParserImpl.cpp             |   241 +
 base/poco/JSON/src/PrintHandler.cpp           |   215 +
 base/poco/JSON/src/Query.cpp                  |   172 +
 base/poco/JSON/src/Stringifier.cpp            |    86 +
 base/poco/JSON/src/Template.cpp               |   701 +
 base/poco/JSON/src/TemplateCache.cpp          |   157 +
 base/poco/JSON/src/pdjson.c                   |   870 ++
 base/poco/JSON/src/pdjson.h                   |   113 +
 base/poco/LICENSE                             |    32 +
 base/poco/MongoDB/CMakeLists.txt              |     7 +
 .../poco/MongoDB/include/Poco/MongoDB/Array.h |   110 +
 .../MongoDB/include/Poco/MongoDB/BSONReader.h |    84 +
 .../MongoDB/include/Poco/MongoDB/BSONWriter.h |    74 +
 .../MongoDB/include/Poco/MongoDB/Binary.h     |   155 +
 .../MongoDB/include/Poco/MongoDB/Connection.h |   164 +
 .../MongoDB/include/Poco/MongoDB/Cursor.h     |    74 +
 .../MongoDB/include/Poco/MongoDB/Database.h   |   162 +
 .../include/Poco/MongoDB/DeleteRequest.h      |   113 +
 .../MongoDB/include/Poco/MongoDB/Document.h   |   277 +
 .../MongoDB/include/Poco/MongoDB/Element.h    |   403 +
 .../include/Poco/MongoDB/GetMoreRequest.h     |    89 +
 .../include/Poco/MongoDB/InsertRequest.h      |    97 +
 .../include/Poco/MongoDB/JavaScriptCode.h     |   105 +
 .../include/Poco/MongoDB/KillCursorsRequest.h |    62 +
 .../MongoDB/include/Poco/MongoDB/Message.h    |    73 +
 .../include/Poco/MongoDB/MessageHeader.h      |   130 +
 .../MongoDB/include/Poco/MongoDB/MongoDB.h    |    64 +
 .../MongoDB/include/Poco/MongoDB/ObjectId.h   |   147 +
 .../Poco/MongoDB/PoolableConnectionFactory.h  |   128 +
 .../include/Poco/MongoDB/QueryRequest.h       |   187 +
 .../include/Poco/MongoDB/RegularExpression.h  |   129 +
 .../MongoDB/include/Poco/MongoDB/ReplicaSet.h |    58 +
 .../include/Poco/MongoDB/RequestMessage.h     |    51 +
 .../include/Poco/MongoDB/ResponseMessage.h    |   108 +
 .../include/Poco/MongoDB/UpdateRequest.h      |   114 +
 base/poco/MongoDB/src/Array.cpp               |    75 +
 base/poco/MongoDB/src/Binary.cpp              |    89 +
 base/poco/MongoDB/src/Connection.cpp          |   235 +
 base/poco/MongoDB/src/Cursor.cpp              |    77 +
 base/poco/MongoDB/src/Database.cpp            |   430 +
 base/poco/MongoDB/src/DeleteRequest.cpp       |    54 +
 base/poco/MongoDB/src/Document.cpp            |   219 +
 base/poco/MongoDB/src/Element.cpp             |    32 +
 base/poco/MongoDB/src/GetMoreRequest.cpp      |    46 +
 base/poco/MongoDB/src/InsertRequest.cpp       |    49 +
 base/poco/MongoDB/src/JavaScriptCode.cpp      |    33 +
 base/poco/MongoDB/src/KillCursorsRequest.cpp  |    44 +
 base/poco/MongoDB/src/Message.cpp             |    33 +
 base/poco/MongoDB/src/MessageHeader.cpp       |    63 +
 base/poco/MongoDB/src/ObjectId.cpp            |    66 +
 base/poco/MongoDB/src/QueryRequest.cpp        |    54 +
 base/poco/MongoDB/src/RegularExpression.cpp   |    71 +
 base/poco/MongoDB/src/ReplicaSet.cpp          |    89 +
 base/poco/MongoDB/src/RequestMessage.cpp      |    51 +
 base/poco/MongoDB/src/ResponseMessage.cpp     |    70 +
 base/poco/MongoDB/src/UpdateRequest.cpp       |    47 +
 base/poco/Net/CMakeLists.txt                  |    25 +
 .../Poco/Net/AbstractHTTPRequestHandler.h     |   136 +
 base/poco/Net/include/Poco/Net/DNS.h          |   199 +
 .../Net/include/Poco/Net/DatagramSocket.h     |   168 +
 .../Net/include/Poco/Net/DatagramSocketImpl.h |    55 +
 base/poco/Net/include/Poco/Net/DialogSocket.h |   211 +
 .../Net/include/Poco/Net/FTPClientSession.h   |   403 +
 .../Net/include/Poco/Net/FTPStreamFactory.h   |   120 +
 .../Net/include/Poco/Net/FilePartSource.h     |    77 +
 base/poco/Net/include/Poco/Net/HTMLForm.h     |   272 +
 .../Poco/Net/HTTPAuthenticationParams.h       |   103 +
 .../include/Poco/Net/HTTPBasicCredentials.h   |   123 +
 .../Net/include/Poco/Net/HTTPBasicStreamBuf.h |    36 +
 .../include/Poco/Net/HTTPBufferAllocator.h    |    50 +
 .../Net/include/Poco/Net/HTTPChunkedStream.h  |   108 +
 .../Net/include/Poco/Net/HTTPClientSession.h  |   436 +
 base/poco/Net/include/Poco/Net/HTTPCookie.h   |   272 +
 .../Net/include/Poco/Net/HTTPCredentials.h    |   206 +
 .../include/Poco/Net/HTTPDigestCredentials.h  |   186 +
 .../include/Poco/Net/HTTPFixedLengthStream.h  |   110 +
 .../Net/include/Poco/Net/HTTPHeaderStream.h   |   102 +
 base/poco/Net/include/Poco/Net/HTTPIOStream.h |    88 +
 base/poco/Net/include/Poco/Net/HTTPMessage.h  |   185 +
 base/poco/Net/include/Poco/Net/HTTPRequest.h  |   208 +
 .../Net/include/Poco/Net/HTTPRequestHandler.h |    67 +
 .../Poco/Net/HTTPRequestHandlerFactory.h      |    78 +
 base/poco/Net/include/Poco/Net/HTTPResponse.h |   306 +
 base/poco/Net/include/Poco/Net/HTTPServer.h   |   103 +
 .../include/Poco/Net/HTTPServerConnection.h   |    65 +
 .../Poco/Net/HTTPServerConnectionFactory.h    |    55 +
 .../Net/include/Poco/Net/HTTPServerParams.h   |   154 +
 .../Net/include/Poco/Net/HTTPServerRequest.h  |    80 +
 .../include/Poco/Net/HTTPServerRequestImpl.h  |   142 +
 .../Net/include/Poco/Net/HTTPServerResponse.h |   127 +
 .../include/Poco/Net/HTTPServerResponseImpl.h |   151 +
 .../Net/include/Poco/Net/HTTPServerSession.h  |    76 +
 base/poco/Net/include/Poco/Net/HTTPSession.h  |   251 +
 .../Net/include/Poco/Net/HTTPSessionFactory.h |   155 +
 .../Poco/Net/HTTPSessionInstantiator.h        |   117 +
 base/poco/Net/include/Poco/Net/HTTPStream.h   |   103 +
 .../Net/include/Poco/Net/HTTPStreamFactory.h  |    92 +
 base/poco/Net/include/Poco/Net/HostEntry.h    |   115 +
 base/poco/Net/include/Poco/Net/ICMPClient.h   |    97 +
 .../poco/Net/include/Poco/Net/ICMPEventArgs.h |   163 +
 base/poco/Net/include/Poco/Net/ICMPPacket.h   |    89 +
 .../Net/include/Poco/Net/ICMPPacketImpl.h     |   141 +
 base/poco/Net/include/Poco/Net/ICMPSocket.h   |    91 +
 .../Net/include/Poco/Net/ICMPSocketImpl.h     |    94 +
 .../Net/include/Poco/Net/ICMPv4PacketImpl.h   |   173 +
 base/poco/Net/include/Poco/Net/IPAddress.h    |   450 +
 .../poco/Net/include/Poco/Net/IPAddressImpl.h |   179 +
 base/poco/Net/include/Poco/Net/MailMessage.h  |   314 +
 .../poco/Net/include/Poco/Net/MailRecipient.h |   120 +
 base/poco/Net/include/Poco/Net/MailStream.h   |   146 +
 base/poco/Net/include/Poco/Net/MediaType.h    |   169 +
 .../poco/Net/include/Poco/Net/MessageHeader.h |   169 +
 .../Net/include/Poco/Net/MulticastSocket.h    |   135 +
 .../Net/include/Poco/Net/MultipartReader.h    |   160 +
 .../Net/include/Poco/Net/MultipartWriter.h    |   109 +
 base/poco/Net/include/Poco/Net/NTPClient.h    |    64 +
 base/poco/Net/include/Poco/Net/NTPEventArgs.h |    84 +
 base/poco/Net/include/Poco/Net/NTPPacket.h    |   207 +
 .../include/Poco/Net/NameValueCollection.h    |   126 +
 base/poco/Net/include/Poco/Net/Net.h          |   122 +
 base/poco/Net/include/Poco/Net/NetException.h |    60 +
 .../Net/include/Poco/Net/NetworkInterface.h   |   352 +
 .../Net/include/Poco/Net/NullPartHandler.h    |    47 +
 .../Net/include/Poco/Net/OAuth10Credentials.h |   274 +
 .../Net/include/Poco/Net/OAuth20Credentials.h |   132 +
 .../Net/include/Poco/Net/POP3ClientSession.h  |   185 +
 .../include/Poco/Net/ParallelSocketAcceptor.h |   233 +
 .../include/Poco/Net/ParallelSocketReactor.h  |    90 +
 base/poco/Net/include/Poco/Net/PartHandler.h  |    68 +
 base/poco/Net/include/Poco/Net/PartSource.h   |   110 +
 base/poco/Net/include/Poco/Net/PartStore.h    |   106 +
 base/poco/Net/include/Poco/Net/PollSet.h      |    86 +
 .../include/Poco/Net/QuotedPrintableDecoder.h |    86 +
 .../include/Poco/Net/QuotedPrintableEncoder.h |    85 +
 base/poco/Net/include/Poco/Net/RawSocket.h    |   161 +
 .../poco/Net/include/Poco/Net/RawSocketImpl.h |    56 +
 .../include/Poco/Net/RemoteSyslogChannel.h    |   158 +
 .../include/Poco/Net/RemoteSyslogListener.h   |   121 +
 base/poco/Net/include/Poco/Net/SMTPChannel.h  |   108 +
 .../Net/include/Poco/Net/SMTPClientSession.h  |   234 +
 base/poco/Net/include/Poco/Net/ServerSocket.h |   230 +
 .../Net/include/Poco/Net/ServerSocketImpl.h   |    45 +
 base/poco/Net/include/Poco/Net/Socket.h       |   631 +
 .../Net/include/Poco/Net/SocketAcceptor.h     |   196 +
 .../poco/Net/include/Poco/Net/SocketAddress.h |   301 +
 .../Net/include/Poco/Net/SocketAddressImpl.h  |   258 +
 .../Net/include/Poco/Net/SocketConnector.h    |   212 +
 base/poco/Net/include/Poco/Net/SocketDefs.h   |   379 +
 base/poco/Net/include/Poco/Net/SocketImpl.h   |   503 +
 .../Net/include/Poco/Net/SocketNotification.h |   153 +
 .../Net/include/Poco/Net/SocketNotifier.h     |   110 +
 .../poco/Net/include/Poco/Net/SocketReactor.h |   235 +
 base/poco/Net/include/Poco/Net/SocketStream.h |   177 +
 base/poco/Net/include/Poco/Net/StreamSocket.h |   180 +
 .../Net/include/Poco/Net/StreamSocketImpl.h   |    59 +
 .../Net/include/Poco/Net/StringPartSource.h   |    71 +
 base/poco/Net/include/Poco/Net/TCPServer.h    |   260 +
 .../include/Poco/Net/TCPServerConnection.h    |    86 +
 .../Poco/Net/TCPServerConnectionFactory.h     |    89 +
 .../include/Poco/Net/TCPServerDispatcher.h    |   131 +
 .../Net/include/Poco/Net/TCPServerParams.h    |   137 +
 base/poco/Net/include/Poco/Net/WebSocket.h    |   297 +
 .../poco/Net/include/Poco/Net/WebSocketImpl.h |   142 +
 .../Net/src/AbstractHTTPRequestHandler.cpp    |   109 +
 base/poco/Net/src/DNS.cpp                     |   687 +
 base/poco/Net/src/DatagramSocket.cpp          |   114 +
 base/poco/Net/src/DatagramSocketImpl.cpp      |    63 +
 base/poco/Net/src/DialogSocket.cpp            |   295 +
 base/poco/Net/src/FTPClientSession.cpp        |   599 +
 base/poco/Net/src/FTPStreamFactory.cpp        |   243 +
 base/poco/Net/src/FilePartSource.cpp          |    87 +
 base/poco/Net/src/HTMLForm.cpp                |   468 +
 .../poco/Net/src/HTTPAuthenticationParams.cpp |   316 +
 base/poco/Net/src/HTTPBasicCredentials.cpp    |   134 +
 base/poco/Net/src/HTTPBufferAllocator.cpp     |    44 +
 base/poco/Net/src/HTTPChunkedStream.cpp       |   258 +
 base/poco/Net/src/HTTPClientSession.cpp       |   514 +
 base/poco/Net/src/HTTPCookie.cpp              |   343 +
 base/poco/Net/src/HTTPCredentials.cpp         |   208 +
 base/poco/Net/src/HTTPDigestCredentials.cpp   |   313 +
 base/poco/Net/src/HTTPFixedLengthStream.cpp   |   185 +
 base/poco/Net/src/HTTPHeaderStream.cpp        |   178 +
 base/poco/Net/src/HTTPIOStream.cpp            |    65 +
 base/poco/Net/src/HTTPMessage.cpp             |   184 +
 base/poco/Net/src/HTTPRequest.cpp             |   277 +
 base/poco/Net/src/HTTPRequestHandler.cpp      |    32 +
 .../Net/src/HTTPRequestHandlerFactory.cpp     |    32 +
 base/poco/Net/src/HTTPResponse.cpp            |   390 +
 base/poco/Net/src/HTTPServer.cpp              |    59 +
 base/poco/Net/src/HTTPServerConnection.cpp    |   180 +
 .../Net/src/HTTPServerConnectionFactory.cpp   |    43 +
 base/poco/Net/src/HTTPServerParams.cpp        |    73 +
 base/poco/Net/src/HTTPServerRequest.cpp       |    32 +
 base/poco/Net/src/HTTPServerRequestImpl.cpp   |    88 +
 base/poco/Net/src/HTTPServerResponse.cpp      |    32 +
 base/poco/Net/src/HTTPServerResponseImpl.cpp  |   221 +
 base/poco/Net/src/HTTPServerSession.cpp       |    70 +
 base/poco/Net/src/HTTPSession.cpp             |   261 +
 base/poco/Net/src/HTTPSessionFactory.cpp      |   146 +
 base/poco/Net/src/HTTPSessionInstantiator.cpp |    77 +
 base/poco/Net/src/HTTPStream.cpp              |   173 +
 base/poco/Net/src/HTTPStreamFactory.cpp       |   187 +
 base/poco/Net/src/HostEntry.cpp               |   135 +
 base/poco/Net/src/ICMPClient.cpp              |   150 +
 base/poco/Net/src/ICMPEventArgs.cpp           |   168 +
 base/poco/Net/src/ICMPPacket.cpp              |   110 +
 base/poco/Net/src/ICMPPacketImpl.cpp          |   103 +
 base/poco/Net/src/ICMPSocket.cpp              |    94 +
 base/poco/Net/src/ICMPSocketImpl.cpp          |    97 +
 base/poco/Net/src/ICMPv4PacketImpl.cpp        |   263 +
 base/poco/Net/src/IPAddress.cpp               |   601 +
 base/poco/Net/src/IPAddressImpl.cpp           |   813 ++
 base/poco/Net/src/MailMessage.cpp             |   695 +
 base/poco/Net/src/MailRecipient.cpp           |    94 +
 base/poco/Net/src/MailStream.cpp              |   221 +
 base/poco/Net/src/MediaType.cpp               |   191 +
 base/poco/Net/src/MessageHeader.cpp           |   394 +
 base/poco/Net/src/MulticastSocket.cpp         |   289 +
 base/poco/Net/src/MultipartReader.cpp         |   309 +
 base/poco/Net/src/MultipartWriter.cpp         |    87 +
 base/poco/Net/src/NTPClient.cpp               |    87 +
 base/poco/Net/src/NTPEventArgs.cpp            |    71 +
 base/poco/Net/src/NTPPacket.cpp               |   158 +
 base/poco/Net/src/NameValueCollection.cpp     |   153 +
 base/poco/Net/src/Net.cpp                     |    76 +
 base/poco/Net/src/NetException.cpp            |    54 +
 base/poco/Net/src/NetworkInterface.cpp        |  1827 +++
 base/poco/Net/src/NullPartHandler.cpp         |    46 +
 base/poco/Net/src/OAuth10Credentials.cpp      |   365 +
 base/poco/Net/src/OAuth20Credentials.cpp      |   105 +
 base/poco/Net/src/POP3ClientSession.cpp       |   280 +
 base/poco/Net/src/PartHandler.cpp             |    32 +
 base/poco/Net/src/PartSource.cpp              |    58 +
 base/poco/Net/src/PartStore.cpp               |    87 +
 base/poco/Net/src/PollSet.cpp                 |   532 +
 base/poco/Net/src/QuotedPrintableDecoder.cpp  |   102 +
 base/poco/Net/src/QuotedPrintableEncoder.cpp  |   150 +
 base/poco/Net/src/RawSocket.cpp               |   117 +
 base/poco/Net/src/RawSocketImpl.cpp           |    69 +
 base/poco/Net/src/RemoteSyslogChannel.cpp     |   356 +
 base/poco/Net/src/RemoteSyslogListener.cpp    |   630 +
 base/poco/Net/src/SMTPChannel.cpp             |   210 +
 base/poco/Net/src/SMTPClientSession.cpp       |   466 +
 base/poco/Net/src/ServerSocket.cpp            |   158 +
 base/poco/Net/src/ServerSocketImpl.cpp        |    32 +
 base/poco/Net/src/Socket.cpp                  |   392 +
 base/poco/Net/src/SocketAddress.cpp           |   435 +
 base/poco/Net/src/SocketAddressImpl.cpp       |   184 +
 base/poco/Net/src/SocketImpl.cpp              |  1090 ++
 base/poco/Net/src/SocketNotification.cpp      |   105 +
 base/poco/Net/src/SocketNotifier.cpp          |    89 +
 base/poco/Net/src/SocketReactor.cpp           |   297 +
 base/poco/Net/src/SocketStream.cpp            |   156 +
 base/poco/Net/src/StreamSocket.cpp            |   150 +
 base/poco/Net/src/StreamSocketImpl.cpp        |    77 +
 base/poco/Net/src/StringPartSource.cpp        |    67 +
 base/poco/Net/src/TCPServer.cpp               |   243 +
 base/poco/Net/src/TCPServerConnection.cpp     |    60 +
 .../Net/src/TCPServerConnectionFactory.cpp    |    32 +
 base/poco/Net/src/TCPServerDispatcher.cpp     |   240 +
 base/poco/Net/src/TCPServerParams.cpp         |    64 +
 base/poco/Net/src/WebSocket.cpp               |   263 +
 base/poco/Net/src/WebSocketImpl.cpp           |   400 +
 base/poco/NetSSL_OpenSSL/CMakeLists.txt       |    14 +
 .../Poco/Net/AcceptCertificateHandler.h       |    52 +
 .../Poco/Net/CertificateHandlerFactory.h      |    93 +
 .../Poco/Net/CertificateHandlerFactoryMgr.h   |    64 +
 .../Poco/Net/ConsoleCertificateHandler.h      |    50 +
 .../NetSSL_OpenSSL/include/Poco/Net/Context.h |   415 +
 .../include/Poco/Net/HTTPSClientSession.h     |   165 +
 .../Poco/Net/HTTPSSessionInstantiator.h       |    65 +
 .../include/Poco/Net/HTTPSStreamFactory.h     |    83 +
 .../Poco/Net/InvalidCertificateHandler.h      |    80 +
 .../include/Poco/Net/KeyConsoleHandler.h      |    47 +
 .../include/Poco/Net/KeyFileHandler.h         |    51 +
 .../NetSSL_OpenSSL/include/Poco/Net/NetSSL.h  |    94 +
 .../include/Poco/Net/PrivateKeyFactory.h      |    95 +
 .../include/Poco/Net/PrivateKeyFactoryMgr.h   |    64 +
 .../Poco/Net/PrivateKeyPassphraseHandler.h    |    84 +
 .../Poco/Net/RejectCertificateHandler.h       |    48 +
 .../include/Poco/Net/SSLException.h           |    39 +
 .../include/Poco/Net/SSLManager.h             |   390 +
 .../Poco/Net/SecureSMTPClientSession.h        |    96 +
 .../include/Poco/Net/SecureServerSocket.h     |   136 +
 .../include/Poco/Net/SecureServerSocketImpl.h |   146 +
 .../include/Poco/Net/SecureSocketImpl.h       |   268 +
 .../include/Poco/Net/SecureStreamSocket.h     |   272 +
 .../include/Poco/Net/SecureStreamSocketImpl.h |   303 +
 .../NetSSL_OpenSSL/include/Poco/Net/Session.h |    79 +
 .../NetSSL_OpenSSL/include/Poco/Net/Utility.h |    52 +
 .../include/Poco/Net/VerificationErrorArgs.h  |   108 +
 .../include/Poco/Net/X509Certificate.h        |   102 +
 .../src/AcceptCertificateHandler.cpp          |    38 +
 .../src/CertificateHandlerFactory.cpp         |    44 +
 .../src/CertificateHandlerFactoryMgr.cpp      |    69 +
 .../src/ConsoleCertificateHandler.cpp         |    53 +
 base/poco/NetSSL_OpenSSL/src/Context.cpp      |   733 +
 .../NetSSL_OpenSSL/src/HTTPSClientSession.cpp |   210 +
 .../src/HTTPSSessionInstantiator.cpp          |    71 +
 .../NetSSL_OpenSSL/src/HTTPSStreamFactory.cpp |   194 +
 .../src/InvalidCertificateHandler.cpp         |    52 +
 .../NetSSL_OpenSSL/src/KeyConsoleHandler.cpp  |    40 +
 .../NetSSL_OpenSSL/src/KeyFileHandler.cpp     |    61 +
 .../NetSSL_OpenSSL/src/PrivateKeyFactory.cpp  |    44 +
 .../src/PrivateKeyFactoryMgr.cpp              |    67 +
 .../src/PrivateKeyPassphraseHandler.cpp       |    46 +
 .../src/RejectCertificateHandler.cpp          |    38 +
 base/poco/NetSSL_OpenSSL/src/SSLException.cpp |    30 +
 base/poco/NetSSL_OpenSSL/src/SSLManager.cpp   |   460 +
 .../src/SecureSMTPClientSession.cpp           |    64 +
 .../NetSSL_OpenSSL/src/SecureServerSocket.cpp |   121 +
 .../src/SecureServerSocketImpl.cpp            |   122 +
 .../NetSSL_OpenSSL/src/SecureSocketImpl.cpp   |   633 +
 .../NetSSL_OpenSSL/src/SecureStreamSocket.cpp |   287 +
 .../src/SecureStreamSocketImpl.cpp            |   241 +
 base/poco/NetSSL_OpenSSL/src/Session.cpp      |    40 +
 base/poco/NetSSL_OpenSSL/src/Utility.cpp      |    71 +
 .../src/VerificationErrorArgs.cpp             |    37 +
 .../NetSSL_OpenSSL/src/X509Certificate.cpp    |   175 +
 base/poco/README.md                           |    38 +
 base/poco/Redis/CMakeLists.txt                |     8 +
 base/poco/Redis/include/Poco/Redis/Array.h    |   322 +
 .../Redis/include/Poco/Redis/AsyncReader.h    |    98 +
 base/poco/Redis/include/Poco/Redis/Client.h   |   239 +
 base/poco/Redis/include/Poco/Redis/Command.h  |   279 +
 base/poco/Redis/include/Poco/Redis/Error.h    |    91 +
 .../poco/Redis/include/Poco/Redis/Exception.h |    36 +
 .../Poco/Redis/PoolableConnectionFactory.h    |   114 +
 base/poco/Redis/include/Poco/Redis/Redis.h    |    62 +
 .../Redis/include/Poco/Redis/RedisEventArgs.h |    99 +
 .../Redis/include/Poco/Redis/RedisStream.h    |   114 +
 base/poco/Redis/include/Poco/Redis/Type.h     |   293 +
 base/poco/Redis/src/Array.cpp                 |    67 +
 base/poco/Redis/src/AsyncReader.cpp           |    61 +
 base/poco/Redis/src/Client.cpp                |   213 +
 base/poco/Redis/src/Command.cpp               |   738 +
 base/poco/Redis/src/Error.cpp                 |    39 +
 base/poco/Redis/src/Exception.cpp             |    27 +
 base/poco/Redis/src/RedisEventArgs.cpp        |    46 +
 base/poco/Redis/src/RedisStream.cpp           |   133 +
 base/poco/Redis/src/Type.cpp                  |    62 +
 base/poco/Util/CMakeLists.txt                 |     7 +
 .../include/Poco/Util/AbstractConfiguration.h |   381 +
 .../poco/Util/include/Poco/Util/Application.h |   545 +
 .../include/Poco/Util/ConfigurationMapper.h   |    94 +
 .../include/Poco/Util/ConfigurationView.h     |    82 +
 .../Poco/Util/FilesystemConfiguration.h       |    93 +
 .../Util/include/Poco/Util/HelpFormatter.h    |   202 +
 .../include/Poco/Util/IniFileConfiguration.h  |    99 +
 .../Util/include/Poco/Util/IntValidator.h     |    56 +
 .../include/Poco/Util/JSONConfiguration.h     |   150 +
 .../include/Poco/Util/LayeredConfiguration.h  |   184 +
 .../include/Poco/Util/LoggingConfigurator.h   |   139 +
 .../Util/include/Poco/Util/LoggingSubsystem.h |    52 +
 .../Util/include/Poco/Util/MapConfiguration.h |    64 +
 base/poco/Util/include/Poco/Util/Option.h     |   332 +
 .../Util/include/Poco/Util/OptionCallback.h   |   109 +
 .../Util/include/Poco/Util/OptionException.h  |    44 +
 .../Util/include/Poco/Util/OptionProcessor.h  |   137 +
 base/poco/Util/include/Poco/Util/OptionSet.h  |    88 +
 .../Poco/Util/PropertyFileConfiguration.h     |    99 +
 .../Util/include/Poco/Util/RegExpValidator.h  |    54 +
 .../include/Poco/Util/ServerApplication.h     |   287 +
 base/poco/Util/include/Poco/Util/Subsystem.h  |    98 +
 .../include/Poco/Util/SystemConfiguration.h   |    99 +
 base/poco/Util/include/Poco/Util/Timer.h      |   169 +
 base/poco/Util/include/Poco/Util/TimerTask.h  |    98 +
 .../Util/include/Poco/Util/TimerTaskAdapter.h |    69 +
 base/poco/Util/include/Poco/Util/Units.h      |  1298 ++
 base/poco/Util/include/Poco/Util/Util.h       |    62 +
 base/poco/Util/include/Poco/Util/Validator.h  |    57 +
 .../Poco/Util/WinRegistryConfiguration.h      |    71 +
 .../Util/include/Poco/Util/WinRegistryKey.h   |   198 +
 base/poco/Util/include/Poco/Util/WinService.h |   141 +
 .../Util/include/Poco/Util/XMLConfiguration.h |   209 +
 base/poco/Util/src/AbstractConfiguration.cpp  |   536 +
 base/poco/Util/src/Application.cpp            |   568 +
 base/poco/Util/src/ConfigurationMapper.cpp    |   101 +
 base/poco/Util/src/ConfigurationView.cpp      |    75 +
 .../poco/Util/src/FilesystemConfiguration.cpp |   127 +
 base/poco/Util/src/HelpFormatter.cpp          |   296 +
 base/poco/Util/src/IniFileConfiguration.cpp   |   190 +
 base/poco/Util/src/IntValidator.cpp           |    54 +
 base/poco/Util/src/JSONConfiguration.cpp      |   386 +
 base/poco/Util/src/LayeredConfiguration.cpp   |   233 +
 base/poco/Util/src/LoggingConfigurator.cpp    |   203 +
 base/poco/Util/src/LoggingSubsystem.cpp       |    58 +
 base/poco/Util/src/MapConfiguration.cpp       |   122 +
 base/poco/Util/src/Option.cpp                 |   292 +
 base/poco/Util/src/OptionCallback.cpp         |    37 +
 base/poco/Util/src/OptionException.cpp        |    35 +
 base/poco/Util/src/OptionProcessor.cpp        |   159 +
 base/poco/Util/src/OptionSet.cpp              |   122 +
 .../Util/src/PropertyFileConfiguration.cpp    |   190 +
 base/poco/Util/src/RegExpValidator.cpp        |    47 +
 base/poco/Util/src/ServerApplication.cpp      |   749 +
 base/poco/Util/src/Subsystem.cpp              |    44 +
 base/poco/Util/src/SystemConfiguration.cpp    |   212 +
 base/poco/Util/src/Timer.cpp                  |   351 +
 base/poco/Util/src/TimerTask.cpp              |    40 +
 base/poco/Util/src/Validator.cpp              |    32 +
 base/poco/Util/src/XMLConfiguration.cpp       |   479 +
 base/poco/XML/CMakeLists.txt                  |    19 +
 .../include/Poco/DOM/AbstractContainerNode.h  |    78 +
 base/poco/XML/include/Poco/DOM/AbstractNode.h |   125 +
 base/poco/XML/include/Poco/DOM/Attr.h         |   180 +
 base/poco/XML/include/Poco/DOM/AttrMap.h      |    65 +
 base/poco/XML/include/Poco/DOM/AutoPtr.h      |    35 +
 base/poco/XML/include/Poco/DOM/CDATASection.h |    84 +
 .../poco/XML/include/Poco/DOM/CharacterData.h |   123 +
 .../XML/include/Poco/DOM/ChildNodesList.h     |    55 +
 base/poco/XML/include/Poco/DOM/Comment.h      |    58 +
 base/poco/XML/include/Poco/DOM/DOMBuilder.h   |   112 +
 base/poco/XML/include/Poco/DOM/DOMException.h |   112 +
 .../XML/include/Poco/DOM/DOMImplementation.h  |    82 +
 base/poco/XML/include/Poco/DOM/DOMObject.h    |   103 +
 base/poco/XML/include/Poco/DOM/DOMParser.h    |   114 +
 .../poco/XML/include/Poco/DOM/DOMSerializer.h |   122 +
 base/poco/XML/include/Poco/DOM/DOMWriter.h    |   127 +
 base/poco/XML/include/Poco/DOM/DTDMap.h       |    67 +
 base/poco/XML/include/Poco/DOM/Document.h     |   285 +
 .../poco/XML/include/Poco/DOM/DocumentEvent.h |    65 +
 .../XML/include/Poco/DOM/DocumentFragment.h   |    84 +
 base/poco/XML/include/Poco/DOM/DocumentType.h |   125 +
 base/poco/XML/include/Poco/DOM/Element.h      |   219 +
 .../include/Poco/DOM/ElementsByTagNameList.h  |    86 +
 base/poco/XML/include/Poco/DOM/Entity.h       |   126 +
 .../XML/include/Poco/DOM/EntityReference.h    |    73 +
 base/poco/XML/include/Poco/DOM/Event.h        |   209 +
 .../XML/include/Poco/DOM/EventDispatcher.h    |    97 +
 .../XML/include/Poco/DOM/EventException.h     |    81 +
 .../poco/XML/include/Poco/DOM/EventListener.h |    57 +
 base/poco/XML/include/Poco/DOM/EventTarget.h  |    76 +
 .../poco/XML/include/Poco/DOM/MutationEvent.h |   143 +
 base/poco/XML/include/Poco/DOM/NamedNodeMap.h |    93 +
 base/poco/XML/include/Poco/DOM/Node.h         |   285 +
 base/poco/XML/include/Poco/DOM/NodeAppender.h |    81 +
 base/poco/XML/include/Poco/DOM/NodeFilter.h   |   146 +
 base/poco/XML/include/Poco/DOM/NodeIterator.h |   167 +
 base/poco/XML/include/Poco/DOM/NodeList.h     |    61 +
 base/poco/XML/include/Poco/DOM/Notation.h     |    93 +
 .../include/Poco/DOM/ProcessingInstruction.h  |    99 +
 base/poco/XML/include/Poco/DOM/Text.h         |    79 +
 base/poco/XML/include/Poco/DOM/TreeWalker.h   |   211 +
 base/poco/XML/include/Poco/SAX/Attributes.h   |   120 +
 .../XML/include/Poco/SAX/AttributesImpl.h     |   307 +
 .../XML/include/Poco/SAX/ContentHandler.h     |   240 +
 base/poco/XML/include/Poco/SAX/DTDHandler.h   |    86 +
 base/poco/XML/include/Poco/SAX/DeclHandler.h  |    91 +
 .../XML/include/Poco/SAX/DefaultHandler.h     |    83 +
 .../XML/include/Poco/SAX/EntityResolver.h     |    86 +
 .../XML/include/Poco/SAX/EntityResolverImpl.h |    78 +
 base/poco/XML/include/Poco/SAX/ErrorHandler.h |    92 +
 base/poco/XML/include/Poco/SAX/InputSource.h  |   169 +
 .../XML/include/Poco/SAX/LexicalHandler.h     |   125 +
 base/poco/XML/include/Poco/SAX/Locator.h      |   103 +
 base/poco/XML/include/Poco/SAX/LocatorImpl.h  |    88 +
 .../XML/include/Poco/SAX/NamespaceSupport.h   |   195 +
 base/poco/XML/include/Poco/SAX/SAXException.h |   176 +
 base/poco/XML/include/Poco/SAX/SAXParser.h    |   113 +
 .../XML/include/Poco/SAX/WhitespaceFilter.h   |    81 +
 base/poco/XML/include/Poco/SAX/XMLFilter.h    |    61 +
 .../poco/XML/include/Poco/SAX/XMLFilterImpl.h |   132 +
 base/poco/XML/include/Poco/SAX/XMLReader.h    |   205 +
 base/poco/XML/include/Poco/XML/Content.h      |    63 +
 base/poco/XML/include/Poco/XML/Name.h         |   144 +
 base/poco/XML/include/Poco/XML/NamePool.h     |    83 +
 .../XML/include/Poco/XML/NamespaceStrategy.h  |   115 +
 base/poco/XML/include/Poco/XML/ParserEngine.h |   384 +
 base/poco/XML/include/Poco/XML/QName.h        |   148 +
 base/poco/XML/include/Poco/XML/ValueTraits.h  |   104 +
 base/poco/XML/include/Poco/XML/XML.h          |    62 +
 base/poco/XML/include/Poco/XML/XMLException.h |    37 +
 base/poco/XML/include/Poco/XML/XMLStream.h    |    71 +
 .../XML/include/Poco/XML/XMLStreamParser.h    |   634 +
 .../Poco/XML/XMLStreamParserException.h       |    58 +
 base/poco/XML/include/Poco/XML/XMLString.h    |    87 +
 base/poco/XML/include/Poco/XML/XMLWriter.h    |   375 +
 base/poco/XML/include/Poco/XML/expat.h        |  1064 ++
 .../XML/include/Poco/XML/expat_external.h     |   165 +
 base/poco/XML/src/AbstractContainerNode.cpp   |   580 +
 base/poco/XML/src/AbstractNode.cpp            |   367 +
 base/poco/XML/src/Attr.cpp                    |   133 +
 base/poco/XML/src/AttrMap.cpp                 |   123 +
 base/poco/XML/src/Attributes.cpp              |    27 +
 base/poco/XML/src/AttributesImpl.cpp          |   299 +
 base/poco/XML/src/CDATASection.cpp            |    74 +
 base/poco/XML/src/CharacterData.cpp           |   152 +
 base/poco/XML/src/ChildNodesList.cpp          |    70 +
 base/poco/XML/src/Comment.cpp                 |    60 +
 base/poco/XML/src/ContentHandler.cpp          |    27 +
 base/poco/XML/src/DOMBuilder.cpp              |   312 +
 base/poco/XML/src/DOMException.cpp            |   107 +
 base/poco/XML/src/DOMImplementation.cpp       |    86 +
 base/poco/XML/src/DOMObject.cpp               |    32 +
 base/poco/XML/src/DOMParser.cpp               |   157 +
 base/poco/XML/src/DOMSerializer.cpp           |   323 +
 base/poco/XML/src/DOMWriter.cpp               |   102 +
 base/poco/XML/src/DTDHandler.cpp              |    27 +
 base/poco/XML/src/DTDMap.cpp                  |   117 +
 base/poco/XML/src/DeclHandler.cpp             |    27 +
 base/poco/XML/src/DefaultHandler.cpp          |   123 +
 base/poco/XML/src/Document.cpp                |   326 +
 base/poco/XML/src/DocumentEvent.cpp           |    27 +
 base/poco/XML/src/DocumentFragment.cpp        |    70 +
 base/poco/XML/src/DocumentType.cpp            |    84 +
 base/poco/XML/src/Element.cpp                 |   444 +
 base/poco/XML/src/ElementsByTagNameList.cpp   |   151 +
 base/poco/XML/src/Entity.cpp                  |    68 +
 base/poco/XML/src/EntityReference.cpp         |    59 +
 base/poco/XML/src/EntityResolver.cpp          |    27 +
 base/poco/XML/src/EntityResolverImpl.cpp      |    78 +
 base/poco/XML/src/ErrorHandler.cpp            |    27 +
 base/poco/XML/src/Event.cpp                   |   102 +
 base/poco/XML/src/EventDispatcher.cpp         |   146 +
 base/poco/XML/src/EventException.cpp          |    65 +
 base/poco/XML/src/EventListener.cpp           |    27 +
 base/poco/XML/src/EventTarget.cpp             |    27 +
 base/poco/XML/src/InputSource.cpp             |    80 +
 base/poco/XML/src/LexicalHandler.cpp          |    27 +
 base/poco/XML/src/Locator.cpp                 |    27 +
 base/poco/XML/src/LocatorImpl.cpp             |   104 +
 base/poco/XML/src/MutationEvent.cpp           |    76 +
 base/poco/XML/src/Name.cpp                    |   188 +
 base/poco/XML/src/NamePool.cpp                |   132 +
 base/poco/XML/src/NamedNodeMap.cpp            |    27 +
 base/poco/XML/src/NamespaceStrategy.cpp       |   195 +
 base/poco/XML/src/NamespaceSupport.cpp        |   187 +
 base/poco/XML/src/Node.cpp                    |    27 +
 base/poco/XML/src/NodeAppender.cpp            |    82 +
 base/poco/XML/src/NodeFilter.cpp              |    27 +
 base/poco/XML/src/NodeIterator.cpp            |   176 +
 base/poco/XML/src/NodeList.cpp                |    27 +
 base/poco/XML/src/Notation.cpp                |    63 +
 base/poco/XML/src/ParserEngine.cpp            |   943 ++
 base/poco/XML/src/ProcessingInstruction.cpp   |    79 +
 base/poco/XML/src/QName.cpp                   |   114 +
 base/poco/XML/src/SAXException.cpp            |   138 +
 base/poco/XML/src/SAXParser.cpp               |   245 +
 base/poco/XML/src/Text.cpp                    |    80 +
 base/poco/XML/src/TreeWalker.cpp              |   227 +
 base/poco/XML/src/ValueTraits.cpp             |    39 +
 base/poco/XML/src/WhitespaceFilter.cpp        |   212 +
 base/poco/XML/src/XMLException.cpp            |    29 +
 base/poco/XML/src/XMLFilter.cpp               |    27 +
 base/poco/XML/src/XMLFilterImpl.cpp           |   313 +
 base/poco/XML/src/XMLReader.cpp               |    37 +
 base/poco/XML/src/XMLStreamParser.cpp         |   939 ++
 .../poco/XML/src/XMLStreamParserException.cpp |    88 +
 base/poco/XML/src/XMLString.cpp               |    64 +
 base/poco/XML/src/XMLWriter.cpp               |  1068 ++
 base/poco/XML/src/ascii.h                     |   123 +
 base/poco/XML/src/asciitab.h                  |    66 +
 base/poco/XML/src/expat_config.h              |    39 +
 base/poco/XML/src/iasciitab.h                 |    67 +
 base/poco/XML/src/internal.h                  |   163 +
 base/poco/XML/src/latin1tab.h                 |    66 +
 base/poco/XML/src/nametab.h                   |   136 +
 base/poco/XML/src/siphash.h                   |   393 +
 base/poco/XML/src/utf8tab.h                   |    66 +
 base/poco/XML/src/xmlparse.cpp                |  8402 +++++++++++
 base/poco/XML/src/xmlrole.c                   |  1255 ++
 base/poco/XML/src/xmlrole.h                   |   142 +
 base/poco/XML/src/xmltok.c                    |  1676 +++
 base/poco/XML/src/xmltok.h                    |   319 +
 base/poco/XML/src/xmltok_impl.c               |  1817 +++
 base/poco/XML/src/xmltok_impl.h               |    74 +
 base/poco/XML/src/xmltok_ns.c                 |   122 +
 base/poco/patches/AIX/xlC8.diff               |   439 +
 base/readpassphrase/CMakeLists.txt            |     4 +
 base/widechar_width/CMakeLists.txt            |     4 +
 contrib/CMakeLists.txt                        |     1 -
 contrib/poco                                  |     1 -
 contrib/poco-cmake/Crypto/CMakeLists.txt      |    40 -
 contrib/poco-cmake/Data/CMakeLists.txt        |    46 -
 contrib/poco-cmake/Data/ODBC/CMakeLists.txt   |    39 -
 contrib/poco-cmake/Foundation/CMakeLists.txt  |   236 -
 contrib/poco-cmake/JSON/CMakeLists.txt        |    31 -
 contrib/poco-cmake/MongoDB/CMakeLists.txt     |    29 -
 contrib/poco-cmake/Net/CMakeLists.txt         |   128 -
 contrib/poco-cmake/Net/SSL/CMakeLists.txt     |    42 -
 contrib/poco-cmake/Redis/CMakeLists.txt       |    21 -
 contrib/poco-cmake/Util/CMakeLists.txt        |    35 -
 contrib/poco-cmake/XML/CMakeLists.txt         |   100 -
 docker/test/fasttest/run.sh                   |     1 -
 src/Functions/CMakeLists.txt                  |     4 -
 src/Functions/examples/CMakeLists.txt         |     0
 utils/check-style/check-duplicate-includes.sh |     2 +-
 utils/check-style/check-style                 |     2 +-
 utils/check-style/check-typos                 |     2 +-
 utils/check-style/check-whitespaces           |     4 +-
 1408 files changed, 318315 insertions(+), 769 deletions(-)
 create mode 100644 base/poco/CHANGELOG
 rename {contrib/poco-cmake => base/poco}/CMakeLists.txt (67%)
 create mode 100644 base/poco/CONTRIBUTORS
 create mode 100644 base/poco/Crypto/CMakeLists.txt
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/Cipher.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/CipherFactory.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/CipherImpl.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/CipherKey.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/CipherKeyImpl.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/Crypto.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/CryptoException.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/CryptoStream.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/CryptoTransform.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/DigestEngine.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/ECDSADigestEngine.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/ECKey.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/ECKeyImpl.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/EVPPKey.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/KeyPair.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/KeyPairImpl.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/OpenSSLInitializer.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/PKCS12Container.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/RSACipherImpl.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/RSADigestEngine.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/RSAKey.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/RSAKeyImpl.h
 create mode 100644 base/poco/Crypto/include/Poco/Crypto/X509Certificate.h
 create mode 100644 base/poco/Crypto/src/Cipher.cpp
 create mode 100644 base/poco/Crypto/src/CipherFactory.cpp
 create mode 100644 base/poco/Crypto/src/CipherImpl.cpp
 create mode 100644 base/poco/Crypto/src/CipherKey.cpp
 create mode 100644 base/poco/Crypto/src/CipherKeyImpl.cpp
 create mode 100644 base/poco/Crypto/src/CryptoException.cpp
 create mode 100644 base/poco/Crypto/src/CryptoStream.cpp
 create mode 100644 base/poco/Crypto/src/CryptoTransform.cpp
 create mode 100644 base/poco/Crypto/src/DigestEngine.cpp
 create mode 100644 base/poco/Crypto/src/ECDSADigestEngine.cpp
 create mode 100644 base/poco/Crypto/src/ECKey.cpp
 create mode 100644 base/poco/Crypto/src/ECKeyImpl.cpp
 create mode 100644 base/poco/Crypto/src/EVPPKey.cpp
 create mode 100644 base/poco/Crypto/src/KeyPair.cpp
 create mode 100644 base/poco/Crypto/src/KeyPairImpl.cpp
 create mode 100644 base/poco/Crypto/src/OpenSSLInitializer.cpp
 create mode 100644 base/poco/Crypto/src/PKCS12Container.cpp
 create mode 100644 base/poco/Crypto/src/RSACipherImpl.cpp
 create mode 100644 base/poco/Crypto/src/RSADigestEngine.cpp
 create mode 100644 base/poco/Crypto/src/RSAKey.cpp
 create mode 100644 base/poco/Crypto/src/RSAKeyImpl.cpp
 create mode 100644 base/poco/Crypto/src/X509Certificate.cpp
 create mode 100644 base/poco/Data/CMakeLists.txt
 create mode 100644 base/poco/Data/ODBC/CMakeLists.txt
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/Binder.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/ConnectionHandle.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/Connector.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/Diagnostics.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/EnvironmentHandle.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/Error.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/Extractor.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/Handle.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBC.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBCException.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBCMetaColumn.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBCStatementImpl.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/Parameter.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/Preparator.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/SessionImpl.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/TypeInfo.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/Unicode.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/Unicode_UNIXODBC.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/Unicode_WIN32.h
 create mode 100644 base/poco/Data/ODBC/include/Poco/Data/ODBC/Utility.h
 create mode 100644 base/poco/Data/ODBC/src/Binder.cpp
 create mode 100644 base/poco/Data/ODBC/src/ConnectionHandle.cpp
 create mode 100644 base/poco/Data/ODBC/src/Connector.cpp
 create mode 100644 base/poco/Data/ODBC/src/EnvironmentHandle.cpp
 create mode 100644 base/poco/Data/ODBC/src/Extractor.cpp
 create mode 100644 base/poco/Data/ODBC/src/ODBCException.cpp
 create mode 100644 base/poco/Data/ODBC/src/ODBCMetaColumn.cpp
 create mode 100644 base/poco/Data/ODBC/src/ODBCStatementImpl.cpp
 create mode 100644 base/poco/Data/ODBC/src/Parameter.cpp
 create mode 100644 base/poco/Data/ODBC/src/Preparator.cpp
 create mode 100644 base/poco/Data/ODBC/src/SessionImpl.cpp
 create mode 100644 base/poco/Data/ODBC/src/TypeInfo.cpp
 create mode 100644 base/poco/Data/ODBC/src/Unicode.cpp
 create mode 100644 base/poco/Data/ODBC/src/Unicode_UNIXODBC.cpp
 create mode 100644 base/poco/Data/ODBC/src/Unicode_WIN32.cpp
 create mode 100644 base/poco/Data/ODBC/src/Utility.cpp
 create mode 100644 base/poco/Data/include/Poco/Data/AbstractBinder.h
 create mode 100644 base/poco/Data/include/Poco/Data/AbstractBinding.h
 create mode 100644 base/poco/Data/include/Poco/Data/AbstractExtraction.h
 create mode 100644 base/poco/Data/include/Poco/Data/AbstractExtractor.h
 create mode 100644 base/poco/Data/include/Poco/Data/AbstractPreparation.h
 create mode 100644 base/poco/Data/include/Poco/Data/AbstractPreparator.h
 create mode 100644 base/poco/Data/include/Poco/Data/AbstractSessionImpl.h
 create mode 100644 base/poco/Data/include/Poco/Data/ArchiveStrategy.h
 create mode 100644 base/poco/Data/include/Poco/Data/AutoTransaction.h
 create mode 100644 base/poco/Data/include/Poco/Data/Binding.h
 create mode 100644 base/poco/Data/include/Poco/Data/Bulk.h
 create mode 100644 base/poco/Data/include/Poco/Data/BulkBinding.h
 create mode 100644 base/poco/Data/include/Poco/Data/BulkExtraction.h
 create mode 100644 base/poco/Data/include/Poco/Data/Column.h
 create mode 100644 base/poco/Data/include/Poco/Data/Connector.h
 create mode 100644 base/poco/Data/include/Poco/Data/Constants.h
 create mode 100644 base/poco/Data/include/Poco/Data/Data.h
 create mode 100644 base/poco/Data/include/Poco/Data/DataException.h
 create mode 100644 base/poco/Data/include/Poco/Data/Date.h
 create mode 100644 base/poco/Data/include/Poco/Data/DynamicDateTime.h
 create mode 100644 base/poco/Data/include/Poco/Data/DynamicLOB.h
 create mode 100644 base/poco/Data/include/Poco/Data/Extraction.h
 create mode 100644 base/poco/Data/include/Poco/Data/LOB.h
 create mode 100644 base/poco/Data/include/Poco/Data/LOBStream.h
 create mode 100644 base/poco/Data/include/Poco/Data/Limit.h
 create mode 100644 base/poco/Data/include/Poco/Data/MetaColumn.h
 create mode 100644 base/poco/Data/include/Poco/Data/PooledSessionHolder.h
 create mode 100644 base/poco/Data/include/Poco/Data/PooledSessionImpl.h
 create mode 100644 base/poco/Data/include/Poco/Data/Position.h
 create mode 100644 base/poco/Data/include/Poco/Data/Preparation.h
 create mode 100644 base/poco/Data/include/Poco/Data/Range.h
 create mode 100644 base/poco/Data/include/Poco/Data/RecordSet.h
 create mode 100644 base/poco/Data/include/Poco/Data/Row.h
 create mode 100644 base/poco/Data/include/Poco/Data/RowFilter.h
 create mode 100644 base/poco/Data/include/Poco/Data/RowFormatter.h
 create mode 100644 base/poco/Data/include/Poco/Data/RowIterator.h
 create mode 100644 base/poco/Data/include/Poco/Data/SQLChannel.h
 create mode 100644 base/poco/Data/include/Poco/Data/Session.h
 create mode 100644 base/poco/Data/include/Poco/Data/SessionFactory.h
 create mode 100644 base/poco/Data/include/Poco/Data/SessionImpl.h
 create mode 100644 base/poco/Data/include/Poco/Data/SessionPool.h
 create mode 100644 base/poco/Data/include/Poco/Data/SessionPoolContainer.h
 create mode 100644 base/poco/Data/include/Poco/Data/SimpleRowFormatter.h
 create mode 100644 base/poco/Data/include/Poco/Data/Statement.h
 create mode 100644 base/poco/Data/include/Poco/Data/StatementCreator.h
 create mode 100644 base/poco/Data/include/Poco/Data/StatementImpl.h
 create mode 100644 base/poco/Data/include/Poco/Data/Time.h
 create mode 100644 base/poco/Data/include/Poco/Data/Transaction.h
 create mode 100644 base/poco/Data/include/Poco/Data/TypeHandler.h
 create mode 100644 base/poco/Data/src/AbstractBinder.cpp
 create mode 100644 base/poco/Data/src/AbstractBinding.cpp
 create mode 100644 base/poco/Data/src/AbstractExtraction.cpp
 create mode 100644 base/poco/Data/src/AbstractExtractor.cpp
 create mode 100644 base/poco/Data/src/AbstractPreparation.cpp
 create mode 100644 base/poco/Data/src/AbstractPreparator.cpp
 create mode 100644 base/poco/Data/src/ArchiveStrategy.cpp
 create mode 100644 base/poco/Data/src/Bulk.cpp
 create mode 100644 base/poco/Data/src/Connector.cpp
 create mode 100644 base/poco/Data/src/DataException.cpp
 create mode 100644 base/poco/Data/src/Date.cpp
 create mode 100644 base/poco/Data/src/DynamicLOB.cpp
 create mode 100644 base/poco/Data/src/Limit.cpp
 create mode 100644 base/poco/Data/src/MetaColumn.cpp
 create mode 100644 base/poco/Data/src/PooledSessionHolder.cpp
 create mode 100644 base/poco/Data/src/PooledSessionImpl.cpp
 create mode 100644 base/poco/Data/src/Position.cpp
 create mode 100644 base/poco/Data/src/Range.cpp
 create mode 100644 base/poco/Data/src/RecordSet.cpp
 create mode 100644 base/poco/Data/src/Row.cpp
 create mode 100644 base/poco/Data/src/RowFilter.cpp
 create mode 100644 base/poco/Data/src/RowFormatter.cpp
 create mode 100644 base/poco/Data/src/RowIterator.cpp
 create mode 100644 base/poco/Data/src/SQLChannel.cpp
 create mode 100644 base/poco/Data/src/Session.cpp
 create mode 100644 base/poco/Data/src/SessionFactory.cpp
 create mode 100644 base/poco/Data/src/SessionImpl.cpp
 create mode 100644 base/poco/Data/src/SessionPool.cpp
 create mode 100644 base/poco/Data/src/SessionPoolContainer.cpp
 create mode 100644 base/poco/Data/src/SimpleRowFormatter.cpp
 create mode 100644 base/poco/Data/src/Statement.cpp
 create mode 100644 base/poco/Data/src/StatementCreator.cpp
 create mode 100644 base/poco/Data/src/StatementImpl.cpp
 create mode 100644 base/poco/Data/src/Time.cpp
 create mode 100644 base/poco/Data/src/Transaction.cpp
 create mode 100644 base/poco/Foundation/CMakeLists.txt
 create mode 100644 base/poco/Foundation/include/Poco/ASCIIEncoding.h
 create mode 100644 base/poco/Foundation/include/Poco/AbstractCache.h
 create mode 100644 base/poco/Foundation/include/Poco/AbstractDelegate.h
 create mode 100644 base/poco/Foundation/include/Poco/AbstractEvent.h
 create mode 100644 base/poco/Foundation/include/Poco/AbstractObserver.h
 create mode 100644 base/poco/Foundation/include/Poco/AbstractPriorityDelegate.h
 create mode 100644 base/poco/Foundation/include/Poco/AbstractStrategy.h
 create mode 100644 base/poco/Foundation/include/Poco/AccessExpirationDecorator.h
 create mode 100644 base/poco/Foundation/include/Poco/AccessExpireCache.h
 create mode 100644 base/poco/Foundation/include/Poco/AccessExpireLRUCache.h
 create mode 100644 base/poco/Foundation/include/Poco/AccessExpireStrategy.h
 create mode 100644 base/poco/Foundation/include/Poco/ActiveDispatcher.h
 create mode 100644 base/poco/Foundation/include/Poco/ActiveMethod.h
 create mode 100644 base/poco/Foundation/include/Poco/ActiveResult.h
 create mode 100644 base/poco/Foundation/include/Poco/ActiveRunnable.h
 create mode 100644 base/poco/Foundation/include/Poco/ActiveStarter.h
 create mode 100644 base/poco/Foundation/include/Poco/Activity.h
 create mode 100644 base/poco/Foundation/include/Poco/Alignment.h
 create mode 100644 base/poco/Foundation/include/Poco/Any.h
 create mode 100644 base/poco/Foundation/include/Poco/ArchiveStrategy.h
 create mode 100644 base/poco/Foundation/include/Poco/Array.h
 create mode 100644 base/poco/Foundation/include/Poco/Ascii.h
 create mode 100644 base/poco/Foundation/include/Poco/AsyncChannel.h
 create mode 100644 base/poco/Foundation/include/Poco/AtomicCounter.h
 create mode 100644 base/poco/Foundation/include/Poco/AutoPtr.h
 create mode 100644 base/poco/Foundation/include/Poco/AutoReleasePool.h
 create mode 100644 base/poco/Foundation/include/Poco/Base32Decoder.h
 create mode 100644 base/poco/Foundation/include/Poco/Base32Encoder.h
 create mode 100644 base/poco/Foundation/include/Poco/Base64Decoder.h
 create mode 100644 base/poco/Foundation/include/Poco/Base64Encoder.h
 create mode 100644 base/poco/Foundation/include/Poco/BasicEvent.h
 create mode 100644 base/poco/Foundation/include/Poco/BinaryReader.h
 create mode 100644 base/poco/Foundation/include/Poco/BinaryWriter.h
 create mode 100644 base/poco/Foundation/include/Poco/Buffer.h
 create mode 100644 base/poco/Foundation/include/Poco/BufferAllocator.h
 create mode 100644 base/poco/Foundation/include/Poco/BufferedBidirectionalStreamBuf.h
 create mode 100644 base/poco/Foundation/include/Poco/BufferedStreamBuf.h
 create mode 100644 base/poco/Foundation/include/Poco/Bugcheck.h
 create mode 100644 base/poco/Foundation/include/Poco/ByteOrder.h
 create mode 100644 base/poco/Foundation/include/Poco/Channel.h
 create mode 100644 base/poco/Foundation/include/Poco/Checksum.h
 create mode 100644 base/poco/Foundation/include/Poco/ClassLibrary.h
 create mode 100644 base/poco/Foundation/include/Poco/ClassLoader.h
 create mode 100644 base/poco/Foundation/include/Poco/Clock.h
 create mode 100644 base/poco/Foundation/include/Poco/CompressedLogFile.h
 create mode 100644 base/poco/Foundation/include/Poco/Condition.h
 create mode 100644 base/poco/Foundation/include/Poco/Config.h
 create mode 100644 base/poco/Foundation/include/Poco/Configurable.h
 create mode 100644 base/poco/Foundation/include/Poco/ConsoleChannel.h
 create mode 100644 base/poco/Foundation/include/Poco/CountingStream.h
 create mode 100644 base/poco/Foundation/include/Poco/DateTime.h
 create mode 100644 base/poco/Foundation/include/Poco/DateTimeFormat.h
 create mode 100644 base/poco/Foundation/include/Poco/DateTimeFormatter.h
 create mode 100644 base/poco/Foundation/include/Poco/DateTimeParser.h
 create mode 100644 base/poco/Foundation/include/Poco/Debugger.h
 create mode 100644 base/poco/Foundation/include/Poco/DefaultStrategy.h
 create mode 100644 base/poco/Foundation/include/Poco/DeflatingStream.h
 create mode 100644 base/poco/Foundation/include/Poco/Delegate.h
 create mode 100644 base/poco/Foundation/include/Poco/DigestEngine.h
 create mode 100644 base/poco/Foundation/include/Poco/DigestStream.h
 create mode 100644 base/poco/Foundation/include/Poco/DirectoryIterator.h
 create mode 100644 base/poco/Foundation/include/Poco/DirectoryIteratorStrategy.h
 create mode 100644 base/poco/Foundation/include/Poco/DirectoryIterator_UNIX.h
 create mode 100644 base/poco/Foundation/include/Poco/DirectoryIterator_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/DirectoryIterator_WIN32U.h
 create mode 100644 base/poco/Foundation/include/Poco/DirectoryWatcher.h
 create mode 100644 base/poco/Foundation/include/Poco/Dynamic/Pair.h
 create mode 100644 base/poco/Foundation/include/Poco/Dynamic/Struct.h
 create mode 100644 base/poco/Foundation/include/Poco/Dynamic/Var.h
 create mode 100644 base/poco/Foundation/include/Poco/Dynamic/VarHolder.h
 create mode 100644 base/poco/Foundation/include/Poco/Dynamic/VarIterator.h
 create mode 100644 base/poco/Foundation/include/Poco/DynamicAny.h
 create mode 100644 base/poco/Foundation/include/Poco/DynamicAnyHolder.h
 create mode 100644 base/poco/Foundation/include/Poco/DynamicFactory.h
 create mode 100644 base/poco/Foundation/include/Poco/DynamicStruct.h
 create mode 100644 base/poco/Foundation/include/Poco/Environment.h
 create mode 100644 base/poco/Foundation/include/Poco/Environment_UNIX.h
 create mode 100644 base/poco/Foundation/include/Poco/Environment_VX.h
 create mode 100644 base/poco/Foundation/include/Poco/Environment_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/Environment_WIN32U.h
 create mode 100644 base/poco/Foundation/include/Poco/Environment_WINCE.h
 create mode 100644 base/poco/Foundation/include/Poco/Error.h
 create mode 100644 base/poco/Foundation/include/Poco/ErrorHandler.h
 create mode 100644 base/poco/Foundation/include/Poco/Event.h
 create mode 100644 base/poco/Foundation/include/Poco/EventArgs.h
 create mode 100644 base/poco/Foundation/include/Poco/EventChannel.h
 create mode 100644 base/poco/Foundation/include/Poco/EventLogChannel.h
 create mode 100644 base/poco/Foundation/include/Poco/Event_POSIX.h
 create mode 100644 base/poco/Foundation/include/Poco/Event_VX.h
 create mode 100644 base/poco/Foundation/include/Poco/Event_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/Exception.h
 create mode 100644 base/poco/Foundation/include/Poco/ExpirationDecorator.h
 create mode 100644 base/poco/Foundation/include/Poco/Expire.h
 create mode 100644 base/poco/Foundation/include/Poco/ExpireCache.h
 create mode 100644 base/poco/Foundation/include/Poco/ExpireLRUCache.h
 create mode 100644 base/poco/Foundation/include/Poco/ExpireStrategy.h
 create mode 100644 base/poco/Foundation/include/Poco/FIFOBuffer.h
 create mode 100644 base/poco/Foundation/include/Poco/FIFOBufferStream.h
 create mode 100644 base/poco/Foundation/include/Poco/FIFOEvent.h
 create mode 100644 base/poco/Foundation/include/Poco/FIFOStrategy.h
 create mode 100644 base/poco/Foundation/include/Poco/FPEnvironment.h
 create mode 100644 base/poco/Foundation/include/Poco/FPEnvironment_C99.h
 create mode 100644 base/poco/Foundation/include/Poco/FPEnvironment_DEC.h
 create mode 100644 base/poco/Foundation/include/Poco/FPEnvironment_DUMMY.h
 create mode 100644 base/poco/Foundation/include/Poco/FPEnvironment_QNX.h
 create mode 100644 base/poco/Foundation/include/Poco/FPEnvironment_SUN.h
 create mode 100644 base/poco/Foundation/include/Poco/FPEnvironment_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/File.h
 create mode 100644 base/poco/Foundation/include/Poco/FileChannel.h
 create mode 100644 base/poco/Foundation/include/Poco/FileStream.h
 create mode 100644 base/poco/Foundation/include/Poco/FileStreamFactory.h
 create mode 100644 base/poco/Foundation/include/Poco/FileStream_POSIX.h
 create mode 100644 base/poco/Foundation/include/Poco/FileStream_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/File_UNIX.h
 create mode 100644 base/poco/Foundation/include/Poco/File_VX.h
 create mode 100644 base/poco/Foundation/include/Poco/File_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/File_WIN32U.h
 create mode 100644 base/poco/Foundation/include/Poco/File_WINCE.h
 create mode 100644 base/poco/Foundation/include/Poco/Format.h
 create mode 100644 base/poco/Foundation/include/Poco/Formatter.h
 create mode 100644 base/poco/Foundation/include/Poco/FormattingChannel.h
 create mode 100644 base/poco/Foundation/include/Poco/Foundation.h
 create mode 100644 base/poco/Foundation/include/Poco/FunctionDelegate.h
 create mode 100644 base/poco/Foundation/include/Poco/FunctionPriorityDelegate.h
 create mode 100644 base/poco/Foundation/include/Poco/Glob.h
 create mode 100644 base/poco/Foundation/include/Poco/HMACEngine.h
 create mode 100644 base/poco/Foundation/include/Poco/Hash.h
 create mode 100644 base/poco/Foundation/include/Poco/HashFunction.h
 create mode 100644 base/poco/Foundation/include/Poco/HashMap.h
 create mode 100644 base/poco/Foundation/include/Poco/HashSet.h
 create mode 100644 base/poco/Foundation/include/Poco/HashStatistic.h
 create mode 100644 base/poco/Foundation/include/Poco/HashTable.h
 create mode 100644 base/poco/Foundation/include/Poco/HexBinaryDecoder.h
 create mode 100644 base/poco/Foundation/include/Poco/HexBinaryEncoder.h
 create mode 100644 base/poco/Foundation/include/Poco/InflatingStream.h
 create mode 100644 base/poco/Foundation/include/Poco/Instantiator.h
 create mode 100644 base/poco/Foundation/include/Poco/JSONString.h
 create mode 100644 base/poco/Foundation/include/Poco/KeyValueArgs.h
 create mode 100644 base/poco/Foundation/include/Poco/LRUCache.h
 create mode 100644 base/poco/Foundation/include/Poco/LRUStrategy.h
 create mode 100644 base/poco/Foundation/include/Poco/Latin1Encoding.h
 create mode 100644 base/poco/Foundation/include/Poco/Latin2Encoding.h
 create mode 100644 base/poco/Foundation/include/Poco/Latin9Encoding.h
 create mode 100644 base/poco/Foundation/include/Poco/LineEndingConverter.h
 create mode 100644 base/poco/Foundation/include/Poco/LinearHashTable.h
 create mode 100644 base/poco/Foundation/include/Poco/ListMap.h
 create mode 100644 base/poco/Foundation/include/Poco/LocalDateTime.h
 create mode 100644 base/poco/Foundation/include/Poco/LogFile.h
 create mode 100644 base/poco/Foundation/include/Poco/LogFile_STD.h
 create mode 100644 base/poco/Foundation/include/Poco/LogFile_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/LogFile_WIN32U.h
 create mode 100644 base/poco/Foundation/include/Poco/LogStream.h
 create mode 100644 base/poco/Foundation/include/Poco/Logger.h
 create mode 100644 base/poco/Foundation/include/Poco/LoggingFactory.h
 create mode 100644 base/poco/Foundation/include/Poco/LoggingRegistry.h
 create mode 100644 base/poco/Foundation/include/Poco/MD4Engine.h
 create mode 100644 base/poco/Foundation/include/Poco/MD5Engine.h
 create mode 100644 base/poco/Foundation/include/Poco/Manifest.h
 create mode 100644 base/poco/Foundation/include/Poco/MemoryPool.h
 create mode 100644 base/poco/Foundation/include/Poco/MemoryStream.h
 create mode 100644 base/poco/Foundation/include/Poco/Message.h
 create mode 100644 base/poco/Foundation/include/Poco/MetaObject.h
 create mode 100644 base/poco/Foundation/include/Poco/MetaProgramming.h
 create mode 100644 base/poco/Foundation/include/Poco/Mutex.h
 create mode 100644 base/poco/Foundation/include/Poco/Mutex_POSIX.h
 create mode 100644 base/poco/Foundation/include/Poco/Mutex_VX.h
 create mode 100644 base/poco/Foundation/include/Poco/Mutex_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/Mutex_WINCE.h
 create mode 100644 base/poco/Foundation/include/Poco/NObserver.h
 create mode 100644 base/poco/Foundation/include/Poco/NamedEvent.h
 create mode 100644 base/poco/Foundation/include/Poco/NamedEvent_Android.h
 create mode 100644 base/poco/Foundation/include/Poco/NamedEvent_UNIX.h
 create mode 100644 base/poco/Foundation/include/Poco/NamedEvent_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/NamedEvent_WIN32U.h
 create mode 100644 base/poco/Foundation/include/Poco/NamedMutex.h
 create mode 100644 base/poco/Foundation/include/Poco/NamedMutex_Android.h
 create mode 100644 base/poco/Foundation/include/Poco/NamedMutex_UNIX.h
 create mode 100644 base/poco/Foundation/include/Poco/NamedMutex_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/NamedMutex_WIN32U.h
 create mode 100644 base/poco/Foundation/include/Poco/NamedTuple.h
 create mode 100644 base/poco/Foundation/include/Poco/NestedDiagnosticContext.h
 create mode 100644 base/poco/Foundation/include/Poco/Notification.h
 create mode 100644 base/poco/Foundation/include/Poco/NotificationCenter.h
 create mode 100644 base/poco/Foundation/include/Poco/NotificationQueue.h
 create mode 100644 base/poco/Foundation/include/Poco/NotificationStrategy.h
 create mode 100644 base/poco/Foundation/include/Poco/NullChannel.h
 create mode 100644 base/poco/Foundation/include/Poco/NullStream.h
 create mode 100644 base/poco/Foundation/include/Poco/Nullable.h
 create mode 100644 base/poco/Foundation/include/Poco/NumberFormatter.h
 create mode 100644 base/poco/Foundation/include/Poco/NumberParser.h
 create mode 100644 base/poco/Foundation/include/Poco/NumericString.h
 create mode 100644 base/poco/Foundation/include/Poco/ObjectPool.h
 create mode 100644 base/poco/Foundation/include/Poco/Observer.h
 create mode 100644 base/poco/Foundation/include/Poco/Optional.h
 create mode 100644 base/poco/Foundation/include/Poco/PBKDF2Engine.h
 create mode 100644 base/poco/Foundation/include/Poco/Path.h
 create mode 100644 base/poco/Foundation/include/Poco/Path_UNIX.h
 create mode 100644 base/poco/Foundation/include/Poco/Path_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/Path_WIN32U.h
 create mode 100644 base/poco/Foundation/include/Poco/Path_WINCE.h
 create mode 100644 base/poco/Foundation/include/Poco/PatternFormatter.h
 create mode 100644 base/poco/Foundation/include/Poco/Pipe.h
 create mode 100644 base/poco/Foundation/include/Poco/PipeImpl.h
 create mode 100644 base/poco/Foundation/include/Poco/PipeImpl_DUMMY.h
 create mode 100644 base/poco/Foundation/include/Poco/PipeImpl_POSIX.h
 create mode 100644 base/poco/Foundation/include/Poco/PipeImpl_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/PipeStream.h
 create mode 100644 base/poco/Foundation/include/Poco/Platform.h
 create mode 100644 base/poco/Foundation/include/Poco/Platform_POSIX.h
 create mode 100644 base/poco/Foundation/include/Poco/Platform_VX.h
 create mode 100644 base/poco/Foundation/include/Poco/Platform_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/Poco.h
 create mode 100644 base/poco/Foundation/include/Poco/PriorityDelegate.h
 create mode 100644 base/poco/Foundation/include/Poco/PriorityEvent.h
 create mode 100644 base/poco/Foundation/include/Poco/PriorityExpire.h
 create mode 100644 base/poco/Foundation/include/Poco/PriorityNotificationQueue.h
 create mode 100644 base/poco/Foundation/include/Poco/PriorityStrategy.h
 create mode 100644 base/poco/Foundation/include/Poco/Process.h
 create mode 100644 base/poco/Foundation/include/Poco/Process_UNIX.h
 create mode 100644 base/poco/Foundation/include/Poco/Process_VX.h
 create mode 100644 base/poco/Foundation/include/Poco/Process_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/Process_WIN32U.h
 create mode 100644 base/poco/Foundation/include/Poco/Process_WINCE.h
 create mode 100644 base/poco/Foundation/include/Poco/PurgeStrategy.h
 create mode 100644 base/poco/Foundation/include/Poco/RWLock.h
 create mode 100644 base/poco/Foundation/include/Poco/RWLock_Android.h
 create mode 100644 base/poco/Foundation/include/Poco/RWLock_POSIX.h
 create mode 100644 base/poco/Foundation/include/Poco/RWLock_VX.h
 create mode 100644 base/poco/Foundation/include/Poco/RWLock_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/RWLock_WINCE.h
 create mode 100644 base/poco/Foundation/include/Poco/Random.h
 create mode 100644 base/poco/Foundation/include/Poco/RandomStream.h
 create mode 100644 base/poco/Foundation/include/Poco/RecursiveDirectoryIterator.h
 create mode 100644 base/poco/Foundation/include/Poco/RecursiveDirectoryIteratorImpl.h
 create mode 100644 base/poco/Foundation/include/Poco/RefCountedObject.h
 create mode 100644 base/poco/Foundation/include/Poco/RegularExpression.h
 create mode 100644 base/poco/Foundation/include/Poco/RotateStrategy.h
 create mode 100644 base/poco/Foundation/include/Poco/Runnable.h
 create mode 100644 base/poco/Foundation/include/Poco/RunnableAdapter.h
 create mode 100644 base/poco/Foundation/include/Poco/SHA1Engine.h
 create mode 100644 base/poco/Foundation/include/Poco/ScopedLock.h
 create mode 100644 base/poco/Foundation/include/Poco/ScopedUnlock.h
 create mode 100644 base/poco/Foundation/include/Poco/Semaphore.h
 create mode 100644 base/poco/Foundation/include/Poco/Semaphore_POSIX.h
 create mode 100644 base/poco/Foundation/include/Poco/Semaphore_VX.h
 create mode 100644 base/poco/Foundation/include/Poco/Semaphore_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/SharedLibrary.h
 create mode 100644 base/poco/Foundation/include/Poco/SharedLibrary_HPUX.h
 create mode 100644 base/poco/Foundation/include/Poco/SharedLibrary_UNIX.h
 create mode 100644 base/poco/Foundation/include/Poco/SharedLibrary_VX.h
 create mode 100644 base/poco/Foundation/include/Poco/SharedLibrary_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/SharedLibrary_WIN32U.h
 create mode 100644 base/poco/Foundation/include/Poco/SharedMemory.h
 create mode 100644 base/poco/Foundation/include/Poco/SharedMemory_DUMMY.h
 create mode 100644 base/poco/Foundation/include/Poco/SharedMemory_POSIX.h
 create mode 100644 base/poco/Foundation/include/Poco/SharedMemory_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/SharedPtr.h
 create mode 100644 base/poco/Foundation/include/Poco/SignalHandler.h
 create mode 100644 base/poco/Foundation/include/Poco/SimpleFileChannel.h
 create mode 100644 base/poco/Foundation/include/Poco/SimpleHashTable.h
 create mode 100644 base/poco/Foundation/include/Poco/SingletonHolder.h
 create mode 100644 base/poco/Foundation/include/Poco/SortedDirectoryIterator.h
 create mode 100644 base/poco/Foundation/include/Poco/SplitterChannel.h
 create mode 100644 base/poco/Foundation/include/Poco/Stopwatch.h
 create mode 100644 base/poco/Foundation/include/Poco/StrategyCollection.h
 create mode 100644 base/poco/Foundation/include/Poco/StreamChannel.h
 create mode 100644 base/poco/Foundation/include/Poco/StreamConverter.h
 create mode 100644 base/poco/Foundation/include/Poco/StreamCopier.h
 create mode 100644 base/poco/Foundation/include/Poco/StreamTokenizer.h
 create mode 100644 base/poco/Foundation/include/Poco/StreamUtil.h
 create mode 100644 base/poco/Foundation/include/Poco/String.h
 create mode 100644 base/poco/Foundation/include/Poco/StringTokenizer.h
 create mode 100644 base/poco/Foundation/include/Poco/SynchronizedObject.h
 create mode 100644 base/poco/Foundation/include/Poco/SyslogChannel.h
 create mode 100644 base/poco/Foundation/include/Poco/Task.h
 create mode 100644 base/poco/Foundation/include/Poco/TaskManager.h
 create mode 100644 base/poco/Foundation/include/Poco/TaskNotification.h
 create mode 100644 base/poco/Foundation/include/Poco/TeeStream.h
 create mode 100644 base/poco/Foundation/include/Poco/TemporaryFile.h
 create mode 100644 base/poco/Foundation/include/Poco/TextBufferIterator.h
 create mode 100644 base/poco/Foundation/include/Poco/TextConverter.h
 create mode 100644 base/poco/Foundation/include/Poco/TextEncoding.h
 create mode 100644 base/poco/Foundation/include/Poco/TextIterator.h
 create mode 100644 base/poco/Foundation/include/Poco/Thread.h
 create mode 100644 base/poco/Foundation/include/Poco/ThreadLocal.h
 create mode 100644 base/poco/Foundation/include/Poco/ThreadPool.h
 create mode 100644 base/poco/Foundation/include/Poco/ThreadTarget.h
 create mode 100644 base/poco/Foundation/include/Poco/Thread_POSIX.h
 create mode 100644 base/poco/Foundation/include/Poco/Thread_VX.h
 create mode 100644 base/poco/Foundation/include/Poco/Thread_WIN32.h
 create mode 100644 base/poco/Foundation/include/Poco/Thread_WINCE.h
 create mode 100644 base/poco/Foundation/include/Poco/TimedNotificationQueue.h
 create mode 100644 base/poco/Foundation/include/Poco/Timer.h
 create mode 100644 base/poco/Foundation/include/Poco/Timespan.h
 create mode 100644 base/poco/Foundation/include/Poco/Timestamp.h
 create mode 100644 base/poco/Foundation/include/Poco/Timezone.h
 create mode 100644 base/poco/Foundation/include/Poco/Token.h
 create mode 100644 base/poco/Foundation/include/Poco/Tuple.h
 create mode 100644 base/poco/Foundation/include/Poco/TypeList.h
 create mode 100644 base/poco/Foundation/include/Poco/Types.h
 create mode 100644 base/poco/Foundation/include/Poco/URI.h
 create mode 100644 base/poco/Foundation/include/Poco/URIStreamFactory.h
 create mode 100644 base/poco/Foundation/include/Poco/URIStreamOpener.h
 create mode 100644 base/poco/Foundation/include/Poco/UTF16Encoding.h
 create mode 100644 base/poco/Foundation/include/Poco/UTF32Encoding.h
 create mode 100644 base/poco/Foundation/include/Poco/UTF8Encoding.h
 create mode 100644 base/poco/Foundation/include/Poco/UTF8String.h
 create mode 100644 base/poco/Foundation/include/Poco/UTFString.h
 create mode 100644 base/poco/Foundation/include/Poco/UUID.h
 create mode 100644 base/poco/Foundation/include/Poco/UUIDGenerator.h
 create mode 100644 base/poco/Foundation/include/Poco/UnWindows.h
 create mode 100644 base/poco/Foundation/include/Poco/UnbufferedStreamBuf.h
 create mode 100644 base/poco/Foundation/include/Poco/Unicode.h
 create mode 100644 base/poco/Foundation/include/Poco/UnicodeConverter.h
 create mode 100644 base/poco/Foundation/include/Poco/UniqueAccessExpireCache.h
 create mode 100644 base/poco/Foundation/include/Poco/UniqueAccessExpireLRUCache.h
 create mode 100644 base/poco/Foundation/include/Poco/UniqueAccessExpireStrategy.h
 create mode 100644 base/poco/Foundation/include/Poco/UniqueExpireCache.h
 create mode 100644 base/poco/Foundation/include/Poco/UniqueExpireLRUCache.h
 create mode 100644 base/poco/Foundation/include/Poco/UniqueExpireStrategy.h
 create mode 100644 base/poco/Foundation/include/Poco/ValidArgs.h
 create mode 100644 base/poco/Foundation/include/Poco/Version.h
 create mode 100644 base/poco/Foundation/include/Poco/Void.h
 create mode 100644 base/poco/Foundation/include/Poco/Windows1250Encoding.h
 create mode 100644 base/poco/Foundation/include/Poco/Windows1251Encoding.h
 create mode 100644 base/poco/Foundation/include/Poco/Windows1252Encoding.h
 create mode 100644 base/poco/Foundation/include/Poco/WindowsConsoleChannel.h
 create mode 100644 base/poco/Foundation/src/ASCIIEncoding.cpp
 create mode 100644 base/poco/Foundation/src/AbstractObserver.cpp
 create mode 100644 base/poco/Foundation/src/ActiveDispatcher.cpp
 create mode 100644 base/poco/Foundation/src/ArchiveStrategy.cpp
 create mode 100644 base/poco/Foundation/src/Ascii.cpp
 create mode 100644 base/poco/Foundation/src/AsyncChannel.cpp
 create mode 100644 base/poco/Foundation/src/AtomicCounter.cpp
 create mode 100644 base/poco/Foundation/src/Base32Decoder.cpp
 create mode 100644 base/poco/Foundation/src/Base32Encoder.cpp
 create mode 100644 base/poco/Foundation/src/Base64Decoder.cpp
 create mode 100644 base/poco/Foundation/src/Base64Encoder.cpp
 create mode 100644 base/poco/Foundation/src/BinaryReader.cpp
 create mode 100644 base/poco/Foundation/src/BinaryWriter.cpp
 create mode 100644 base/poco/Foundation/src/Bugcheck.cpp
 create mode 100644 base/poco/Foundation/src/ByteOrder.cpp
 create mode 100644 base/poco/Foundation/src/Channel.cpp
 create mode 100644 base/poco/Foundation/src/Checksum.cpp
 create mode 100644 base/poco/Foundation/src/Clock.cpp
 create mode 100644 base/poco/Foundation/src/CompressedLogFile.cpp
 create mode 100644 base/poco/Foundation/src/Condition.cpp
 create mode 100644 base/poco/Foundation/src/Configurable.cpp
 create mode 100644 base/poco/Foundation/src/ConsoleChannel.cpp
 create mode 100644 base/poco/Foundation/src/CountingStream.cpp
 create mode 100644 base/poco/Foundation/src/DateTime.cpp
 create mode 100644 base/poco/Foundation/src/DateTimeFormat.cpp
 create mode 100644 base/poco/Foundation/src/DateTimeFormatter.cpp
 create mode 100644 base/poco/Foundation/src/DateTimeParser.cpp
 create mode 100644 base/poco/Foundation/src/Debugger.cpp
 create mode 100644 base/poco/Foundation/src/DeflatingStream.cpp
 create mode 100644 base/poco/Foundation/src/DigestEngine.cpp
 create mode 100644 base/poco/Foundation/src/DigestStream.cpp
 create mode 100644 base/poco/Foundation/src/DirectoryIterator.cpp
 create mode 100644 base/poco/Foundation/src/DirectoryIteratorStrategy.cpp
 create mode 100644 base/poco/Foundation/src/DirectoryIterator_UNIX.cpp
 create mode 100644 base/poco/Foundation/src/DirectoryIterator_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/DirectoryIterator_WIN32U.cpp
 create mode 100644 base/poco/Foundation/src/DirectoryWatcher.cpp
 create mode 100644 base/poco/Foundation/src/Environment.cpp
 create mode 100644 base/poco/Foundation/src/Environment_UNIX.cpp
 create mode 100644 base/poco/Foundation/src/Environment_VX.cpp
 create mode 100644 base/poco/Foundation/src/Environment_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/Environment_WIN32U.cpp
 create mode 100644 base/poco/Foundation/src/Environment_WINCE.cpp
 create mode 100644 base/poco/Foundation/src/Error.cpp
 create mode 100644 base/poco/Foundation/src/ErrorHandler.cpp
 create mode 100644 base/poco/Foundation/src/Event.cpp
 create mode 100644 base/poco/Foundation/src/EventArgs.cpp
 create mode 100644 base/poco/Foundation/src/EventChannel.cpp
 create mode 100644 base/poco/Foundation/src/EventLogChannel.cpp
 create mode 100644 base/poco/Foundation/src/Event_POSIX.cpp
 create mode 100644 base/poco/Foundation/src/Event_VX.cpp
 create mode 100644 base/poco/Foundation/src/Event_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/Exception.cpp
 create mode 100644 base/poco/Foundation/src/FIFOBufferStream.cpp
 create mode 100644 base/poco/Foundation/src/FPEnvironment.cpp
 create mode 100644 base/poco/Foundation/src/FPEnvironment_C99.cpp
 create mode 100644 base/poco/Foundation/src/FPEnvironment_DEC.cpp
 create mode 100644 base/poco/Foundation/src/FPEnvironment_DUMMY.cpp
 create mode 100644 base/poco/Foundation/src/FPEnvironment_QNX.cpp
 create mode 100644 base/poco/Foundation/src/FPEnvironment_SUN.cpp
 create mode 100644 base/poco/Foundation/src/FPEnvironment_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/File.cpp
 create mode 100644 base/poco/Foundation/src/FileChannel.cpp
 create mode 100644 base/poco/Foundation/src/FileStream.cpp
 create mode 100644 base/poco/Foundation/src/FileStreamFactory.cpp
 create mode 100644 base/poco/Foundation/src/FileStream_POSIX.cpp
 create mode 100644 base/poco/Foundation/src/FileStream_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/File_UNIX.cpp
 create mode 100644 base/poco/Foundation/src/File_VX.cpp
 create mode 100644 base/poco/Foundation/src/File_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/File_WIN32U.cpp
 create mode 100644 base/poco/Foundation/src/File_WINCE.cpp
 create mode 100644 base/poco/Foundation/src/Format.cpp
 create mode 100644 base/poco/Foundation/src/Formatter.cpp
 create mode 100644 base/poco/Foundation/src/FormattingChannel.cpp
 create mode 100644 base/poco/Foundation/src/Glob.cpp
 create mode 100644 base/poco/Foundation/src/Hash.cpp
 create mode 100644 base/poco/Foundation/src/HashStatistic.cpp
 create mode 100644 base/poco/Foundation/src/HexBinaryDecoder.cpp
 create mode 100644 base/poco/Foundation/src/HexBinaryEncoder.cpp
 create mode 100644 base/poco/Foundation/src/InflatingStream.cpp
 create mode 100644 base/poco/Foundation/src/JSONString.cpp
 create mode 100644 base/poco/Foundation/src/Latin1Encoding.cpp
 create mode 100644 base/poco/Foundation/src/Latin2Encoding.cpp
 create mode 100644 base/poco/Foundation/src/Latin9Encoding.cpp
 create mode 100644 base/poco/Foundation/src/LineEndingConverter.cpp
 create mode 100644 base/poco/Foundation/src/LocalDateTime.cpp
 create mode 100644 base/poco/Foundation/src/LogFile.cpp
 create mode 100644 base/poco/Foundation/src/LogFile_STD.cpp
 create mode 100644 base/poco/Foundation/src/LogFile_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/LogFile_WIN32U.cpp
 create mode 100644 base/poco/Foundation/src/LogStream.cpp
 create mode 100644 base/poco/Foundation/src/Logger.cpp
 create mode 100644 base/poco/Foundation/src/LoggingFactory.cpp
 create mode 100644 base/poco/Foundation/src/LoggingRegistry.cpp
 create mode 100644 base/poco/Foundation/src/MD4Engine.cpp
 create mode 100644 base/poco/Foundation/src/MD5Engine.cpp
 create mode 100644 base/poco/Foundation/src/Manifest.cpp
 create mode 100644 base/poco/Foundation/src/MemoryPool.cpp
 create mode 100644 base/poco/Foundation/src/MemoryStream.cpp
 create mode 100644 base/poco/Foundation/src/Message.cpp
 create mode 100644 base/poco/Foundation/src/Mutex.cpp
 create mode 100644 base/poco/Foundation/src/Mutex_POSIX.cpp
 create mode 100644 base/poco/Foundation/src/Mutex_VX.cpp
 create mode 100644 base/poco/Foundation/src/Mutex_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/Mutex_WINCE.cpp
 create mode 100644 base/poco/Foundation/src/NamedEvent.cpp
 create mode 100644 base/poco/Foundation/src/NamedEvent_Android.cpp
 create mode 100644 base/poco/Foundation/src/NamedEvent_UNIX.cpp
 create mode 100644 base/poco/Foundation/src/NamedEvent_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/NamedEvent_WIN32U.cpp
 create mode 100644 base/poco/Foundation/src/NamedMutex.cpp
 create mode 100644 base/poco/Foundation/src/NamedMutex_Android.cpp
 create mode 100644 base/poco/Foundation/src/NamedMutex_UNIX.cpp
 create mode 100644 base/poco/Foundation/src/NamedMutex_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/NamedMutex_WIN32U.cpp
 create mode 100644 base/poco/Foundation/src/NestedDiagnosticContext.cpp
 create mode 100644 base/poco/Foundation/src/Notification.cpp
 create mode 100644 base/poco/Foundation/src/NotificationCenter.cpp
 create mode 100644 base/poco/Foundation/src/NotificationQueue.cpp
 create mode 100644 base/poco/Foundation/src/NullChannel.cpp
 create mode 100644 base/poco/Foundation/src/NullStream.cpp
 create mode 100644 base/poco/Foundation/src/NumberFormatter.cpp
 create mode 100644 base/poco/Foundation/src/NumberParser.cpp
 create mode 100644 base/poco/Foundation/src/NumericString.cpp
 create mode 100644 base/poco/Foundation/src/Path.cpp
 create mode 100644 base/poco/Foundation/src/Path_UNIX.cpp
 create mode 100644 base/poco/Foundation/src/Path_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/Path_WIN32U.cpp
 create mode 100644 base/poco/Foundation/src/Path_WINCE.cpp
 create mode 100644 base/poco/Foundation/src/PatternFormatter.cpp
 create mode 100644 base/poco/Foundation/src/Pipe.cpp
 create mode 100644 base/poco/Foundation/src/PipeImpl.cpp
 create mode 100644 base/poco/Foundation/src/PipeImpl_DUMMY.cpp
 create mode 100644 base/poco/Foundation/src/PipeImpl_POSIX.cpp
 create mode 100644 base/poco/Foundation/src/PipeImpl_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/PipeStream.cpp
 create mode 100644 base/poco/Foundation/src/PriorityNotificationQueue.cpp
 create mode 100644 base/poco/Foundation/src/Process.cpp
 create mode 100644 base/poco/Foundation/src/Process_UNIX.cpp
 create mode 100644 base/poco/Foundation/src/Process_VX.cpp
 create mode 100644 base/poco/Foundation/src/Process_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/Process_WIN32U.cpp
 create mode 100644 base/poco/Foundation/src/Process_WINCE.cpp
 create mode 100644 base/poco/Foundation/src/PurgeStrategy.cpp
 create mode 100644 base/poco/Foundation/src/RWLock.cpp
 create mode 100644 base/poco/Foundation/src/RWLock_Android.cpp
 create mode 100644 base/poco/Foundation/src/RWLock_POSIX.cpp
 create mode 100644 base/poco/Foundation/src/RWLock_VX.cpp
 create mode 100644 base/poco/Foundation/src/RWLock_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/RWLock_WINCE.cpp
 create mode 100644 base/poco/Foundation/src/Random.cpp
 create mode 100644 base/poco/Foundation/src/RandomStream.cpp
 create mode 100644 base/poco/Foundation/src/RefCountedObject.cpp
 create mode 100644 base/poco/Foundation/src/RegularExpression.cpp
 create mode 100644 base/poco/Foundation/src/RotateStrategy.cpp
 create mode 100644 base/poco/Foundation/src/Runnable.cpp
 create mode 100644 base/poco/Foundation/src/SHA1Engine.cpp
 create mode 100644 base/poco/Foundation/src/Semaphore.cpp
 create mode 100644 base/poco/Foundation/src/Semaphore_POSIX.cpp
 create mode 100644 base/poco/Foundation/src/Semaphore_VX.cpp
 create mode 100644 base/poco/Foundation/src/Semaphore_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/SharedLibrary.cpp
 create mode 100644 base/poco/Foundation/src/SharedLibrary_HPUX.cpp
 create mode 100644 base/poco/Foundation/src/SharedLibrary_UNIX.cpp
 create mode 100644 base/poco/Foundation/src/SharedLibrary_VX.cpp
 create mode 100644 base/poco/Foundation/src/SharedLibrary_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/SharedLibrary_WIN32U.cpp
 create mode 100644 base/poco/Foundation/src/SharedMemory.cpp
 create mode 100644 base/poco/Foundation/src/SharedMemory_DUMMY.cpp
 create mode 100644 base/poco/Foundation/src/SharedMemory_POSIX.cpp
 create mode 100644 base/poco/Foundation/src/SharedMemory_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/SignalHandler.cpp
 create mode 100644 base/poco/Foundation/src/SimpleFileChannel.cpp
 create mode 100644 base/poco/Foundation/src/SortedDirectoryIterator.cpp
 create mode 100644 base/poco/Foundation/src/SplitterChannel.cpp
 create mode 100644 base/poco/Foundation/src/Stopwatch.cpp
 create mode 100644 base/poco/Foundation/src/StreamChannel.cpp
 create mode 100644 base/poco/Foundation/src/StreamConverter.cpp
 create mode 100644 base/poco/Foundation/src/StreamCopier.cpp
 create mode 100644 base/poco/Foundation/src/StreamTokenizer.cpp
 create mode 100644 base/poco/Foundation/src/String.cpp
 create mode 100644 base/poco/Foundation/src/StringTokenizer.cpp
 create mode 100644 base/poco/Foundation/src/SynchronizedObject.cpp
 create mode 100644 base/poco/Foundation/src/SyslogChannel.cpp
 create mode 100644 base/poco/Foundation/src/Task.cpp
 create mode 100644 base/poco/Foundation/src/TaskManager.cpp
 create mode 100644 base/poco/Foundation/src/TaskNotification.cpp
 create mode 100644 base/poco/Foundation/src/TeeStream.cpp
 create mode 100644 base/poco/Foundation/src/TemporaryFile.cpp
 create mode 100644 base/poco/Foundation/src/TextBufferIterator.cpp
 create mode 100644 base/poco/Foundation/src/TextConverter.cpp
 create mode 100644 base/poco/Foundation/src/TextEncoding.cpp
 create mode 100644 base/poco/Foundation/src/TextIterator.cpp
 create mode 100644 base/poco/Foundation/src/Thread.cpp
 create mode 100644 base/poco/Foundation/src/ThreadLocal.cpp
 create mode 100644 base/poco/Foundation/src/ThreadPool.cpp
 create mode 100644 base/poco/Foundation/src/ThreadTarget.cpp
 create mode 100644 base/poco/Foundation/src/Thread_POSIX.cpp
 create mode 100644 base/poco/Foundation/src/Thread_VX.cpp
 create mode 100644 base/poco/Foundation/src/Thread_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/Thread_WINCE.cpp
 create mode 100644 base/poco/Foundation/src/TimedNotificationQueue.cpp
 create mode 100644 base/poco/Foundation/src/Timer.cpp
 create mode 100644 base/poco/Foundation/src/Timespan.cpp
 create mode 100644 base/poco/Foundation/src/Timestamp.cpp
 create mode 100644 base/poco/Foundation/src/Timezone.cpp
 create mode 100644 base/poco/Foundation/src/Timezone_UNIX.cpp
 create mode 100644 base/poco/Foundation/src/Timezone_VX.cpp
 create mode 100644 base/poco/Foundation/src/Timezone_WIN32.cpp
 create mode 100644 base/poco/Foundation/src/Timezone_WINCE.cpp
 create mode 100644 base/poco/Foundation/src/Token.cpp
 create mode 100644 base/poco/Foundation/src/URI.cpp
 create mode 100644 base/poco/Foundation/src/URIStreamFactory.cpp
 create mode 100644 base/poco/Foundation/src/URIStreamOpener.cpp
 create mode 100644 base/poco/Foundation/src/UTF16Encoding.cpp
 create mode 100644 base/poco/Foundation/src/UTF32Encoding.cpp
 create mode 100644 base/poco/Foundation/src/UTF8Encoding.cpp
 create mode 100644 base/poco/Foundation/src/UTF8String.cpp
 create mode 100644 base/poco/Foundation/src/UUID.cpp
 create mode 100644 base/poco/Foundation/src/UUIDGenerator.cpp
 create mode 100644 base/poco/Foundation/src/Unicode.cpp
 create mode 100644 base/poco/Foundation/src/UnicodeConverter.cpp
 create mode 100644 base/poco/Foundation/src/Var.cpp
 create mode 100644 base/poco/Foundation/src/VarHolder.cpp
 create mode 100644 base/poco/Foundation/src/VarIterator.cpp
 create mode 100644 base/poco/Foundation/src/Void.cpp
 create mode 100644 base/poco/Foundation/src/Windows1250Encoding.cpp
 create mode 100644 base/poco/Foundation/src/Windows1251Encoding.cpp
 create mode 100644 base/poco/Foundation/src/Windows1252Encoding.cpp
 create mode 100644 base/poco/Foundation/src/WindowsConsoleChannel.cpp
 create mode 100644 base/poco/Foundation/src/adler32.c
 create mode 100644 base/poco/Foundation/src/bignum-dtoa.cc
 create mode 100644 base/poco/Foundation/src/bignum-dtoa.h
 create mode 100644 base/poco/Foundation/src/bignum.cc
 create mode 100644 base/poco/Foundation/src/bignum.h
 create mode 100644 base/poco/Foundation/src/cached-powers.cc
 create mode 100644 base/poco/Foundation/src/cached-powers.h
 create mode 100644 base/poco/Foundation/src/compress.c
 create mode 100644 base/poco/Foundation/src/crc32.c
 create mode 100644 base/poco/Foundation/src/crc32.h
 create mode 100644 base/poco/Foundation/src/deflate.c
 create mode 100644 base/poco/Foundation/src/deflate.h
 create mode 100644 base/poco/Foundation/src/diy-fp.cc
 create mode 100644 base/poco/Foundation/src/diy-fp.h
 create mode 100644 base/poco/Foundation/src/double-conversion.cc
 create mode 100644 base/poco/Foundation/src/double-conversion.h
 create mode 100644 base/poco/Foundation/src/fast-dtoa.cc
 create mode 100644 base/poco/Foundation/src/fast-dtoa.h
 create mode 100644 base/poco/Foundation/src/fixed-dtoa.cc
 create mode 100644 base/poco/Foundation/src/fixed-dtoa.h
 create mode 100644 base/poco/Foundation/src/gzguts.h
 create mode 100644 base/poco/Foundation/src/ieee.h
 create mode 100644 base/poco/Foundation/src/infback.c
 create mode 100644 base/poco/Foundation/src/inffast.c
 create mode 100644 base/poco/Foundation/src/inffast.h
 create mode 100644 base/poco/Foundation/src/inffixed.h
 create mode 100644 base/poco/Foundation/src/inflate.c
 create mode 100644 base/poco/Foundation/src/inflate.h
 create mode 100644 base/poco/Foundation/src/inftrees.c
 create mode 100644 base/poco/Foundation/src/inftrees.h
 create mode 100644 base/poco/Foundation/src/pcre.h
 create mode 100644 base/poco/Foundation/src/pcre_byte_order.c
 create mode 100644 base/poco/Foundation/src/pcre_chartables.c
 create mode 100644 base/poco/Foundation/src/pcre_compile.c
 create mode 100644 base/poco/Foundation/src/pcre_config.c
 create mode 100644 base/poco/Foundation/src/pcre_config.h
 create mode 100644 base/poco/Foundation/src/pcre_dfa_exec.c
 create mode 100644 base/poco/Foundation/src/pcre_exec.c
 create mode 100644 base/poco/Foundation/src/pcre_fullinfo.c
 create mode 100644 base/poco/Foundation/src/pcre_get.c
 create mode 100644 base/poco/Foundation/src/pcre_globals.c
 create mode 100644 base/poco/Foundation/src/pcre_internal.h
 create mode 100644 base/poco/Foundation/src/pcre_jit_compile.c
 create mode 100644 base/poco/Foundation/src/pcre_maketables.c
 create mode 100644 base/poco/Foundation/src/pcre_newline.c
 create mode 100644 base/poco/Foundation/src/pcre_ord2utf8.c
 create mode 100644 base/poco/Foundation/src/pcre_refcount.c
 create mode 100644 base/poco/Foundation/src/pcre_string_utils.c
 create mode 100644 base/poco/Foundation/src/pcre_study.c
 create mode 100644 base/poco/Foundation/src/pcre_tables.c
 create mode 100644 base/poco/Foundation/src/pcre_ucd.c
 create mode 100644 base/poco/Foundation/src/pcre_valid_utf8.c
 create mode 100644 base/poco/Foundation/src/pcre_version.c
 create mode 100644 base/poco/Foundation/src/pcre_xclass.c
 create mode 100644 base/poco/Foundation/src/pocomsg.mc
 create mode 100644 base/poco/Foundation/src/strtod.cc
 create mode 100644 base/poco/Foundation/src/strtod.h
 create mode 100644 base/poco/Foundation/src/trees.c
 create mode 100644 base/poco/Foundation/src/trees.h
 create mode 100644 base/poco/Foundation/src/ucp.h
 create mode 100644 base/poco/Foundation/src/utils.h
 create mode 100644 base/poco/Foundation/src/zutil.c
 create mode 100644 base/poco/Foundation/src/zutil.h
 create mode 100644 base/poco/JSON/CMakeLists.txt
 create mode 100644 base/poco/JSON/include/Poco/JSON/Array.h
 create mode 100644 base/poco/JSON/include/Poco/JSON/Handler.h
 create mode 100644 base/poco/JSON/include/Poco/JSON/JSON.h
 create mode 100644 base/poco/JSON/include/Poco/JSON/JSONException.h
 create mode 100644 base/poco/JSON/include/Poco/JSON/Object.h
 create mode 100644 base/poco/JSON/include/Poco/JSON/ParseHandler.h
 create mode 100644 base/poco/JSON/include/Poco/JSON/Parser.h
 create mode 100644 base/poco/JSON/include/Poco/JSON/ParserImpl.h
 create mode 100644 base/poco/JSON/include/Poco/JSON/PrintHandler.h
 create mode 100644 base/poco/JSON/include/Poco/JSON/Query.h
 create mode 100644 base/poco/JSON/include/Poco/JSON/Stringifier.h
 create mode 100644 base/poco/JSON/include/Poco/JSON/Template.h
 create mode 100644 base/poco/JSON/include/Poco/JSON/TemplateCache.h
 create mode 100644 base/poco/JSON/src/Array.cpp
 create mode 100644 base/poco/JSON/src/Handler.cpp
 create mode 100644 base/poco/JSON/src/JSONException.cpp
 create mode 100644 base/poco/JSON/src/Object.cpp
 create mode 100644 base/poco/JSON/src/ParseHandler.cpp
 create mode 100644 base/poco/JSON/src/Parser.cpp
 create mode 100644 base/poco/JSON/src/ParserImpl.cpp
 create mode 100644 base/poco/JSON/src/PrintHandler.cpp
 create mode 100644 base/poco/JSON/src/Query.cpp
 create mode 100644 base/poco/JSON/src/Stringifier.cpp
 create mode 100644 base/poco/JSON/src/Template.cpp
 create mode 100644 base/poco/JSON/src/TemplateCache.cpp
 create mode 100644 base/poco/JSON/src/pdjson.c
 create mode 100644 base/poco/JSON/src/pdjson.h
 create mode 100644 base/poco/LICENSE
 create mode 100644 base/poco/MongoDB/CMakeLists.txt
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/Array.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/BSONReader.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/BSONWriter.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/Binary.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/Connection.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/Cursor.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/Database.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/DeleteRequest.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/Document.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/Element.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/GetMoreRequest.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/InsertRequest.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/JavaScriptCode.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/KillCursorsRequest.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/Message.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/MessageHeader.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/MongoDB.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/ObjectId.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/PoolableConnectionFactory.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/QueryRequest.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/RegularExpression.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/ReplicaSet.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/RequestMessage.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/ResponseMessage.h
 create mode 100644 base/poco/MongoDB/include/Poco/MongoDB/UpdateRequest.h
 create mode 100644 base/poco/MongoDB/src/Array.cpp
 create mode 100644 base/poco/MongoDB/src/Binary.cpp
 create mode 100644 base/poco/MongoDB/src/Connection.cpp
 create mode 100644 base/poco/MongoDB/src/Cursor.cpp
 create mode 100644 base/poco/MongoDB/src/Database.cpp
 create mode 100644 base/poco/MongoDB/src/DeleteRequest.cpp
 create mode 100644 base/poco/MongoDB/src/Document.cpp
 create mode 100644 base/poco/MongoDB/src/Element.cpp
 create mode 100644 base/poco/MongoDB/src/GetMoreRequest.cpp
 create mode 100644 base/poco/MongoDB/src/InsertRequest.cpp
 create mode 100644 base/poco/MongoDB/src/JavaScriptCode.cpp
 create mode 100644 base/poco/MongoDB/src/KillCursorsRequest.cpp
 create mode 100644 base/poco/MongoDB/src/Message.cpp
 create mode 100644 base/poco/MongoDB/src/MessageHeader.cpp
 create mode 100644 base/poco/MongoDB/src/ObjectId.cpp
 create mode 100644 base/poco/MongoDB/src/QueryRequest.cpp
 create mode 100644 base/poco/MongoDB/src/RegularExpression.cpp
 create mode 100644 base/poco/MongoDB/src/ReplicaSet.cpp
 create mode 100644 base/poco/MongoDB/src/RequestMessage.cpp
 create mode 100644 base/poco/MongoDB/src/ResponseMessage.cpp
 create mode 100644 base/poco/MongoDB/src/UpdateRequest.cpp
 create mode 100644 base/poco/Net/CMakeLists.txt
 create mode 100644 base/poco/Net/include/Poco/Net/AbstractHTTPRequestHandler.h
 create mode 100644 base/poco/Net/include/Poco/Net/DNS.h
 create mode 100644 base/poco/Net/include/Poco/Net/DatagramSocket.h
 create mode 100644 base/poco/Net/include/Poco/Net/DatagramSocketImpl.h
 create mode 100644 base/poco/Net/include/Poco/Net/DialogSocket.h
 create mode 100644 base/poco/Net/include/Poco/Net/FTPClientSession.h
 create mode 100644 base/poco/Net/include/Poco/Net/FTPStreamFactory.h
 create mode 100644 base/poco/Net/include/Poco/Net/FilePartSource.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTMLForm.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPAuthenticationParams.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPBasicCredentials.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPBasicStreamBuf.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPBufferAllocator.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPChunkedStream.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPClientSession.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPCookie.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPCredentials.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPDigestCredentials.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPFixedLengthStream.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPHeaderStream.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPIOStream.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPMessage.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPRequest.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPRequestHandler.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPRequestHandlerFactory.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPResponse.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPServer.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPServerConnection.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPServerConnectionFactory.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPServerParams.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPServerRequest.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPServerRequestImpl.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPServerResponse.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPServerResponseImpl.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPServerSession.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPSession.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPSessionFactory.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPSessionInstantiator.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPStream.h
 create mode 100644 base/poco/Net/include/Poco/Net/HTTPStreamFactory.h
 create mode 100644 base/poco/Net/include/Poco/Net/HostEntry.h
 create mode 100644 base/poco/Net/include/Poco/Net/ICMPClient.h
 create mode 100644 base/poco/Net/include/Poco/Net/ICMPEventArgs.h
 create mode 100644 base/poco/Net/include/Poco/Net/ICMPPacket.h
 create mode 100644 base/poco/Net/include/Poco/Net/ICMPPacketImpl.h
 create mode 100644 base/poco/Net/include/Poco/Net/ICMPSocket.h
 create mode 100644 base/poco/Net/include/Poco/Net/ICMPSocketImpl.h
 create mode 100644 base/poco/Net/include/Poco/Net/ICMPv4PacketImpl.h
 create mode 100644 base/poco/Net/include/Poco/Net/IPAddress.h
 create mode 100644 base/poco/Net/include/Poco/Net/IPAddressImpl.h
 create mode 100644 base/poco/Net/include/Poco/Net/MailMessage.h
 create mode 100644 base/poco/Net/include/Poco/Net/MailRecipient.h
 create mode 100644 base/poco/Net/include/Poco/Net/MailStream.h
 create mode 100644 base/poco/Net/include/Poco/Net/MediaType.h
 create mode 100644 base/poco/Net/include/Poco/Net/MessageHeader.h
 create mode 100644 base/poco/Net/include/Poco/Net/MulticastSocket.h
 create mode 100644 base/poco/Net/include/Poco/Net/MultipartReader.h
 create mode 100644 base/poco/Net/include/Poco/Net/MultipartWriter.h
 create mode 100644 base/poco/Net/include/Poco/Net/NTPClient.h
 create mode 100644 base/poco/Net/include/Poco/Net/NTPEventArgs.h
 create mode 100644 base/poco/Net/include/Poco/Net/NTPPacket.h
 create mode 100644 base/poco/Net/include/Poco/Net/NameValueCollection.h
 create mode 100644 base/poco/Net/include/Poco/Net/Net.h
 create mode 100644 base/poco/Net/include/Poco/Net/NetException.h
 create mode 100644 base/poco/Net/include/Poco/Net/NetworkInterface.h
 create mode 100644 base/poco/Net/include/Poco/Net/NullPartHandler.h
 create mode 100644 base/poco/Net/include/Poco/Net/OAuth10Credentials.h
 create mode 100644 base/poco/Net/include/Poco/Net/OAuth20Credentials.h
 create mode 100644 base/poco/Net/include/Poco/Net/POP3ClientSession.h
 create mode 100644 base/poco/Net/include/Poco/Net/ParallelSocketAcceptor.h
 create mode 100644 base/poco/Net/include/Poco/Net/ParallelSocketReactor.h
 create mode 100644 base/poco/Net/include/Poco/Net/PartHandler.h
 create mode 100644 base/poco/Net/include/Poco/Net/PartSource.h
 create mode 100644 base/poco/Net/include/Poco/Net/PartStore.h
 create mode 100644 base/poco/Net/include/Poco/Net/PollSet.h
 create mode 100644 base/poco/Net/include/Poco/Net/QuotedPrintableDecoder.h
 create mode 100644 base/poco/Net/include/Poco/Net/QuotedPrintableEncoder.h
 create mode 100644 base/poco/Net/include/Poco/Net/RawSocket.h
 create mode 100644 base/poco/Net/include/Poco/Net/RawSocketImpl.h
 create mode 100644 base/poco/Net/include/Poco/Net/RemoteSyslogChannel.h
 create mode 100644 base/poco/Net/include/Poco/Net/RemoteSyslogListener.h
 create mode 100644 base/poco/Net/include/Poco/Net/SMTPChannel.h
 create mode 100644 base/poco/Net/include/Poco/Net/SMTPClientSession.h
 create mode 100644 base/poco/Net/include/Poco/Net/ServerSocket.h
 create mode 100644 base/poco/Net/include/Poco/Net/ServerSocketImpl.h
 create mode 100644 base/poco/Net/include/Poco/Net/Socket.h
 create mode 100644 base/poco/Net/include/Poco/Net/SocketAcceptor.h
 create mode 100644 base/poco/Net/include/Poco/Net/SocketAddress.h
 create mode 100644 base/poco/Net/include/Poco/Net/SocketAddressImpl.h
 create mode 100644 base/poco/Net/include/Poco/Net/SocketConnector.h
 create mode 100644 base/poco/Net/include/Poco/Net/SocketDefs.h
 create mode 100644 base/poco/Net/include/Poco/Net/SocketImpl.h
 create mode 100644 base/poco/Net/include/Poco/Net/SocketNotification.h
 create mode 100644 base/poco/Net/include/Poco/Net/SocketNotifier.h
 create mode 100644 base/poco/Net/include/Poco/Net/SocketReactor.h
 create mode 100644 base/poco/Net/include/Poco/Net/SocketStream.h
 create mode 100644 base/poco/Net/include/Poco/Net/StreamSocket.h
 create mode 100644 base/poco/Net/include/Poco/Net/StreamSocketImpl.h
 create mode 100644 base/poco/Net/include/Poco/Net/StringPartSource.h
 create mode 100644 base/poco/Net/include/Poco/Net/TCPServer.h
 create mode 100644 base/poco/Net/include/Poco/Net/TCPServerConnection.h
 create mode 100644 base/poco/Net/include/Poco/Net/TCPServerConnectionFactory.h
 create mode 100644 base/poco/Net/include/Poco/Net/TCPServerDispatcher.h
 create mode 100644 base/poco/Net/include/Poco/Net/TCPServerParams.h
 create mode 100644 base/poco/Net/include/Poco/Net/WebSocket.h
 create mode 100644 base/poco/Net/include/Poco/Net/WebSocketImpl.h
 create mode 100644 base/poco/Net/src/AbstractHTTPRequestHandler.cpp
 create mode 100644 base/poco/Net/src/DNS.cpp
 create mode 100644 base/poco/Net/src/DatagramSocket.cpp
 create mode 100644 base/poco/Net/src/DatagramSocketImpl.cpp
 create mode 100644 base/poco/Net/src/DialogSocket.cpp
 create mode 100644 base/poco/Net/src/FTPClientSession.cpp
 create mode 100644 base/poco/Net/src/FTPStreamFactory.cpp
 create mode 100644 base/poco/Net/src/FilePartSource.cpp
 create mode 100644 base/poco/Net/src/HTMLForm.cpp
 create mode 100644 base/poco/Net/src/HTTPAuthenticationParams.cpp
 create mode 100644 base/poco/Net/src/HTTPBasicCredentials.cpp
 create mode 100644 base/poco/Net/src/HTTPBufferAllocator.cpp
 create mode 100644 base/poco/Net/src/HTTPChunkedStream.cpp
 create mode 100644 base/poco/Net/src/HTTPClientSession.cpp
 create mode 100644 base/poco/Net/src/HTTPCookie.cpp
 create mode 100644 base/poco/Net/src/HTTPCredentials.cpp
 create mode 100644 base/poco/Net/src/HTTPDigestCredentials.cpp
 create mode 100644 base/poco/Net/src/HTTPFixedLengthStream.cpp
 create mode 100644 base/poco/Net/src/HTTPHeaderStream.cpp
 create mode 100644 base/poco/Net/src/HTTPIOStream.cpp
 create mode 100644 base/poco/Net/src/HTTPMessage.cpp
 create mode 100644 base/poco/Net/src/HTTPRequest.cpp
 create mode 100644 base/poco/Net/src/HTTPRequestHandler.cpp
 create mode 100644 base/poco/Net/src/HTTPRequestHandlerFactory.cpp
 create mode 100644 base/poco/Net/src/HTTPResponse.cpp
 create mode 100644 base/poco/Net/src/HTTPServer.cpp
 create mode 100644 base/poco/Net/src/HTTPServerConnection.cpp
 create mode 100644 base/poco/Net/src/HTTPServerConnectionFactory.cpp
 create mode 100644 base/poco/Net/src/HTTPServerParams.cpp
 create mode 100644 base/poco/Net/src/HTTPServerRequest.cpp
 create mode 100644 base/poco/Net/src/HTTPServerRequestImpl.cpp
 create mode 100644 base/poco/Net/src/HTTPServerResponse.cpp
 create mode 100644 base/poco/Net/src/HTTPServerResponseImpl.cpp
 create mode 100644 base/poco/Net/src/HTTPServerSession.cpp
 create mode 100644 base/poco/Net/src/HTTPSession.cpp
 create mode 100644 base/poco/Net/src/HTTPSessionFactory.cpp
 create mode 100644 base/poco/Net/src/HTTPSessionInstantiator.cpp
 create mode 100644 base/poco/Net/src/HTTPStream.cpp
 create mode 100644 base/poco/Net/src/HTTPStreamFactory.cpp
 create mode 100644 base/poco/Net/src/HostEntry.cpp
 create mode 100644 base/poco/Net/src/ICMPClient.cpp
 create mode 100644 base/poco/Net/src/ICMPEventArgs.cpp
 create mode 100644 base/poco/Net/src/ICMPPacket.cpp
 create mode 100644 base/poco/Net/src/ICMPPacketImpl.cpp
 create mode 100644 base/poco/Net/src/ICMPSocket.cpp
 create mode 100644 base/poco/Net/src/ICMPSocketImpl.cpp
 create mode 100644 base/poco/Net/src/ICMPv4PacketImpl.cpp
 create mode 100644 base/poco/Net/src/IPAddress.cpp
 create mode 100644 base/poco/Net/src/IPAddressImpl.cpp
 create mode 100644 base/poco/Net/src/MailMessage.cpp
 create mode 100644 base/poco/Net/src/MailRecipient.cpp
 create mode 100644 base/poco/Net/src/MailStream.cpp
 create mode 100644 base/poco/Net/src/MediaType.cpp
 create mode 100644 base/poco/Net/src/MessageHeader.cpp
 create mode 100644 base/poco/Net/src/MulticastSocket.cpp
 create mode 100644 base/poco/Net/src/MultipartReader.cpp
 create mode 100644 base/poco/Net/src/MultipartWriter.cpp
 create mode 100644 base/poco/Net/src/NTPClient.cpp
 create mode 100644 base/poco/Net/src/NTPEventArgs.cpp
 create mode 100644 base/poco/Net/src/NTPPacket.cpp
 create mode 100644 base/poco/Net/src/NameValueCollection.cpp
 create mode 100644 base/poco/Net/src/Net.cpp
 create mode 100644 base/poco/Net/src/NetException.cpp
 create mode 100644 base/poco/Net/src/NetworkInterface.cpp
 create mode 100644 base/poco/Net/src/NullPartHandler.cpp
 create mode 100644 base/poco/Net/src/OAuth10Credentials.cpp
 create mode 100644 base/poco/Net/src/OAuth20Credentials.cpp
 create mode 100644 base/poco/Net/src/POP3ClientSession.cpp
 create mode 100644 base/poco/Net/src/PartHandler.cpp
 create mode 100644 base/poco/Net/src/PartSource.cpp
 create mode 100644 base/poco/Net/src/PartStore.cpp
 create mode 100644 base/poco/Net/src/PollSet.cpp
 create mode 100644 base/poco/Net/src/QuotedPrintableDecoder.cpp
 create mode 100644 base/poco/Net/src/QuotedPrintableEncoder.cpp
 create mode 100644 base/poco/Net/src/RawSocket.cpp
 create mode 100644 base/poco/Net/src/RawSocketImpl.cpp
 create mode 100644 base/poco/Net/src/RemoteSyslogChannel.cpp
 create mode 100644 base/poco/Net/src/RemoteSyslogListener.cpp
 create mode 100644 base/poco/Net/src/SMTPChannel.cpp
 create mode 100644 base/poco/Net/src/SMTPClientSession.cpp
 create mode 100644 base/poco/Net/src/ServerSocket.cpp
 create mode 100644 base/poco/Net/src/ServerSocketImpl.cpp
 create mode 100644 base/poco/Net/src/Socket.cpp
 create mode 100644 base/poco/Net/src/SocketAddress.cpp
 create mode 100644 base/poco/Net/src/SocketAddressImpl.cpp
 create mode 100644 base/poco/Net/src/SocketImpl.cpp
 create mode 100644 base/poco/Net/src/SocketNotification.cpp
 create mode 100644 base/poco/Net/src/SocketNotifier.cpp
 create mode 100644 base/poco/Net/src/SocketReactor.cpp
 create mode 100644 base/poco/Net/src/SocketStream.cpp
 create mode 100644 base/poco/Net/src/StreamSocket.cpp
 create mode 100644 base/poco/Net/src/StreamSocketImpl.cpp
 create mode 100644 base/poco/Net/src/StringPartSource.cpp
 create mode 100644 base/poco/Net/src/TCPServer.cpp
 create mode 100644 base/poco/Net/src/TCPServerConnection.cpp
 create mode 100644 base/poco/Net/src/TCPServerConnectionFactory.cpp
 create mode 100644 base/poco/Net/src/TCPServerDispatcher.cpp
 create mode 100644 base/poco/Net/src/TCPServerParams.cpp
 create mode 100644 base/poco/Net/src/WebSocket.cpp
 create mode 100644 base/poco/Net/src/WebSocketImpl.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/CMakeLists.txt
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/AcceptCertificateHandler.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/CertificateHandlerFactory.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/CertificateHandlerFactoryMgr.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/ConsoleCertificateHandler.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/Context.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/HTTPSClientSession.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/HTTPSSessionInstantiator.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/HTTPSStreamFactory.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/InvalidCertificateHandler.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/KeyConsoleHandler.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/KeyFileHandler.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/NetSSL.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/PrivateKeyFactory.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/PrivateKeyFactoryMgr.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/PrivateKeyPassphraseHandler.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/RejectCertificateHandler.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/SSLException.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/SSLManager.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureSMTPClientSession.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureServerSocket.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureServerSocketImpl.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureSocketImpl.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureStreamSocket.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureStreamSocketImpl.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/Session.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/Utility.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/VerificationErrorArgs.h
 create mode 100644 base/poco/NetSSL_OpenSSL/include/Poco/Net/X509Certificate.h
 create mode 100644 base/poco/NetSSL_OpenSSL/src/AcceptCertificateHandler.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/CertificateHandlerFactory.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/CertificateHandlerFactoryMgr.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/ConsoleCertificateHandler.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/Context.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/HTTPSClientSession.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/HTTPSSessionInstantiator.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/HTTPSStreamFactory.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/InvalidCertificateHandler.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/KeyConsoleHandler.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/KeyFileHandler.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/PrivateKeyFactory.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/PrivateKeyFactoryMgr.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/PrivateKeyPassphraseHandler.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/RejectCertificateHandler.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/SSLException.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/SSLManager.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/SecureSMTPClientSession.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/SecureServerSocket.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/SecureServerSocketImpl.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/SecureSocketImpl.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/SecureStreamSocket.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/SecureStreamSocketImpl.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/Session.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/Utility.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/VerificationErrorArgs.cpp
 create mode 100644 base/poco/NetSSL_OpenSSL/src/X509Certificate.cpp
 create mode 100644 base/poco/README.md
 create mode 100644 base/poco/Redis/CMakeLists.txt
 create mode 100644 base/poco/Redis/include/Poco/Redis/Array.h
 create mode 100644 base/poco/Redis/include/Poco/Redis/AsyncReader.h
 create mode 100644 base/poco/Redis/include/Poco/Redis/Client.h
 create mode 100644 base/poco/Redis/include/Poco/Redis/Command.h
 create mode 100644 base/poco/Redis/include/Poco/Redis/Error.h
 create mode 100644 base/poco/Redis/include/Poco/Redis/Exception.h
 create mode 100644 base/poco/Redis/include/Poco/Redis/PoolableConnectionFactory.h
 create mode 100644 base/poco/Redis/include/Poco/Redis/Redis.h
 create mode 100644 base/poco/Redis/include/Poco/Redis/RedisEventArgs.h
 create mode 100644 base/poco/Redis/include/Poco/Redis/RedisStream.h
 create mode 100644 base/poco/Redis/include/Poco/Redis/Type.h
 create mode 100644 base/poco/Redis/src/Array.cpp
 create mode 100644 base/poco/Redis/src/AsyncReader.cpp
 create mode 100644 base/poco/Redis/src/Client.cpp
 create mode 100644 base/poco/Redis/src/Command.cpp
 create mode 100644 base/poco/Redis/src/Error.cpp
 create mode 100644 base/poco/Redis/src/Exception.cpp
 create mode 100644 base/poco/Redis/src/RedisEventArgs.cpp
 create mode 100644 base/poco/Redis/src/RedisStream.cpp
 create mode 100644 base/poco/Redis/src/Type.cpp
 create mode 100644 base/poco/Util/CMakeLists.txt
 create mode 100644 base/poco/Util/include/Poco/Util/AbstractConfiguration.h
 create mode 100644 base/poco/Util/include/Poco/Util/Application.h
 create mode 100644 base/poco/Util/include/Poco/Util/ConfigurationMapper.h
 create mode 100644 base/poco/Util/include/Poco/Util/ConfigurationView.h
 create mode 100644 base/poco/Util/include/Poco/Util/FilesystemConfiguration.h
 create mode 100644 base/poco/Util/include/Poco/Util/HelpFormatter.h
 create mode 100644 base/poco/Util/include/Poco/Util/IniFileConfiguration.h
 create mode 100644 base/poco/Util/include/Poco/Util/IntValidator.h
 create mode 100644 base/poco/Util/include/Poco/Util/JSONConfiguration.h
 create mode 100644 base/poco/Util/include/Poco/Util/LayeredConfiguration.h
 create mode 100644 base/poco/Util/include/Poco/Util/LoggingConfigurator.h
 create mode 100644 base/poco/Util/include/Poco/Util/LoggingSubsystem.h
 create mode 100644 base/poco/Util/include/Poco/Util/MapConfiguration.h
 create mode 100644 base/poco/Util/include/Poco/Util/Option.h
 create mode 100644 base/poco/Util/include/Poco/Util/OptionCallback.h
 create mode 100644 base/poco/Util/include/Poco/Util/OptionException.h
 create mode 100644 base/poco/Util/include/Poco/Util/OptionProcessor.h
 create mode 100644 base/poco/Util/include/Poco/Util/OptionSet.h
 create mode 100644 base/poco/Util/include/Poco/Util/PropertyFileConfiguration.h
 create mode 100644 base/poco/Util/include/Poco/Util/RegExpValidator.h
 create mode 100644 base/poco/Util/include/Poco/Util/ServerApplication.h
 create mode 100644 base/poco/Util/include/Poco/Util/Subsystem.h
 create mode 100644 base/poco/Util/include/Poco/Util/SystemConfiguration.h
 create mode 100644 base/poco/Util/include/Poco/Util/Timer.h
 create mode 100644 base/poco/Util/include/Poco/Util/TimerTask.h
 create mode 100644 base/poco/Util/include/Poco/Util/TimerTaskAdapter.h
 create mode 100644 base/poco/Util/include/Poco/Util/Units.h
 create mode 100644 base/poco/Util/include/Poco/Util/Util.h
 create mode 100644 base/poco/Util/include/Poco/Util/Validator.h
 create mode 100644 base/poco/Util/include/Poco/Util/WinRegistryConfiguration.h
 create mode 100644 base/poco/Util/include/Poco/Util/WinRegistryKey.h
 create mode 100644 base/poco/Util/include/Poco/Util/WinService.h
 create mode 100644 base/poco/Util/include/Poco/Util/XMLConfiguration.h
 create mode 100644 base/poco/Util/src/AbstractConfiguration.cpp
 create mode 100644 base/poco/Util/src/Application.cpp
 create mode 100644 base/poco/Util/src/ConfigurationMapper.cpp
 create mode 100644 base/poco/Util/src/ConfigurationView.cpp
 create mode 100644 base/poco/Util/src/FilesystemConfiguration.cpp
 create mode 100644 base/poco/Util/src/HelpFormatter.cpp
 create mode 100644 base/poco/Util/src/IniFileConfiguration.cpp
 create mode 100644 base/poco/Util/src/IntValidator.cpp
 create mode 100644 base/poco/Util/src/JSONConfiguration.cpp
 create mode 100644 base/poco/Util/src/LayeredConfiguration.cpp
 create mode 100644 base/poco/Util/src/LoggingConfigurator.cpp
 create mode 100644 base/poco/Util/src/LoggingSubsystem.cpp
 create mode 100644 base/poco/Util/src/MapConfiguration.cpp
 create mode 100644 base/poco/Util/src/Option.cpp
 create mode 100644 base/poco/Util/src/OptionCallback.cpp
 create mode 100644 base/poco/Util/src/OptionException.cpp
 create mode 100644 base/poco/Util/src/OptionProcessor.cpp
 create mode 100644 base/poco/Util/src/OptionSet.cpp
 create mode 100644 base/poco/Util/src/PropertyFileConfiguration.cpp
 create mode 100644 base/poco/Util/src/RegExpValidator.cpp
 create mode 100644 base/poco/Util/src/ServerApplication.cpp
 create mode 100644 base/poco/Util/src/Subsystem.cpp
 create mode 100644 base/poco/Util/src/SystemConfiguration.cpp
 create mode 100644 base/poco/Util/src/Timer.cpp
 create mode 100644 base/poco/Util/src/TimerTask.cpp
 create mode 100644 base/poco/Util/src/Validator.cpp
 create mode 100644 base/poco/Util/src/XMLConfiguration.cpp
 create mode 100644 base/poco/XML/CMakeLists.txt
 create mode 100644 base/poco/XML/include/Poco/DOM/AbstractContainerNode.h
 create mode 100644 base/poco/XML/include/Poco/DOM/AbstractNode.h
 create mode 100644 base/poco/XML/include/Poco/DOM/Attr.h
 create mode 100644 base/poco/XML/include/Poco/DOM/AttrMap.h
 create mode 100644 base/poco/XML/include/Poco/DOM/AutoPtr.h
 create mode 100644 base/poco/XML/include/Poco/DOM/CDATASection.h
 create mode 100644 base/poco/XML/include/Poco/DOM/CharacterData.h
 create mode 100644 base/poco/XML/include/Poco/DOM/ChildNodesList.h
 create mode 100644 base/poco/XML/include/Poco/DOM/Comment.h
 create mode 100644 base/poco/XML/include/Poco/DOM/DOMBuilder.h
 create mode 100644 base/poco/XML/include/Poco/DOM/DOMException.h
 create mode 100644 base/poco/XML/include/Poco/DOM/DOMImplementation.h
 create mode 100644 base/poco/XML/include/Poco/DOM/DOMObject.h
 create mode 100644 base/poco/XML/include/Poco/DOM/DOMParser.h
 create mode 100644 base/poco/XML/include/Poco/DOM/DOMSerializer.h
 create mode 100644 base/poco/XML/include/Poco/DOM/DOMWriter.h
 create mode 100644 base/poco/XML/include/Poco/DOM/DTDMap.h
 create mode 100644 base/poco/XML/include/Poco/DOM/Document.h
 create mode 100644 base/poco/XML/include/Poco/DOM/DocumentEvent.h
 create mode 100644 base/poco/XML/include/Poco/DOM/DocumentFragment.h
 create mode 100644 base/poco/XML/include/Poco/DOM/DocumentType.h
 create mode 100644 base/poco/XML/include/Poco/DOM/Element.h
 create mode 100644 base/poco/XML/include/Poco/DOM/ElementsByTagNameList.h
 create mode 100644 base/poco/XML/include/Poco/DOM/Entity.h
 create mode 100644 base/poco/XML/include/Poco/DOM/EntityReference.h
 create mode 100644 base/poco/XML/include/Poco/DOM/Event.h
 create mode 100644 base/poco/XML/include/Poco/DOM/EventDispatcher.h
 create mode 100644 base/poco/XML/include/Poco/DOM/EventException.h
 create mode 100644 base/poco/XML/include/Poco/DOM/EventListener.h
 create mode 100644 base/poco/XML/include/Poco/DOM/EventTarget.h
 create mode 100644 base/poco/XML/include/Poco/DOM/MutationEvent.h
 create mode 100644 base/poco/XML/include/Poco/DOM/NamedNodeMap.h
 create mode 100644 base/poco/XML/include/Poco/DOM/Node.h
 create mode 100644 base/poco/XML/include/Poco/DOM/NodeAppender.h
 create mode 100644 base/poco/XML/include/Poco/DOM/NodeFilter.h
 create mode 100644 base/poco/XML/include/Poco/DOM/NodeIterator.h
 create mode 100644 base/poco/XML/include/Poco/DOM/NodeList.h
 create mode 100644 base/poco/XML/include/Poco/DOM/Notation.h
 create mode 100644 base/poco/XML/include/Poco/DOM/ProcessingInstruction.h
 create mode 100644 base/poco/XML/include/Poco/DOM/Text.h
 create mode 100644 base/poco/XML/include/Poco/DOM/TreeWalker.h
 create mode 100644 base/poco/XML/include/Poco/SAX/Attributes.h
 create mode 100644 base/poco/XML/include/Poco/SAX/AttributesImpl.h
 create mode 100644 base/poco/XML/include/Poco/SAX/ContentHandler.h
 create mode 100644 base/poco/XML/include/Poco/SAX/DTDHandler.h
 create mode 100644 base/poco/XML/include/Poco/SAX/DeclHandler.h
 create mode 100644 base/poco/XML/include/Poco/SAX/DefaultHandler.h
 create mode 100644 base/poco/XML/include/Poco/SAX/EntityResolver.h
 create mode 100644 base/poco/XML/include/Poco/SAX/EntityResolverImpl.h
 create mode 100644 base/poco/XML/include/Poco/SAX/ErrorHandler.h
 create mode 100644 base/poco/XML/include/Poco/SAX/InputSource.h
 create mode 100644 base/poco/XML/include/Poco/SAX/LexicalHandler.h
 create mode 100644 base/poco/XML/include/Poco/SAX/Locator.h
 create mode 100644 base/poco/XML/include/Poco/SAX/LocatorImpl.h
 create mode 100644 base/poco/XML/include/Poco/SAX/NamespaceSupport.h
 create mode 100644 base/poco/XML/include/Poco/SAX/SAXException.h
 create mode 100644 base/poco/XML/include/Poco/SAX/SAXParser.h
 create mode 100644 base/poco/XML/include/Poco/SAX/WhitespaceFilter.h
 create mode 100644 base/poco/XML/include/Poco/SAX/XMLFilter.h
 create mode 100644 base/poco/XML/include/Poco/SAX/XMLFilterImpl.h
 create mode 100644 base/poco/XML/include/Poco/SAX/XMLReader.h
 create mode 100644 base/poco/XML/include/Poco/XML/Content.h
 create mode 100644 base/poco/XML/include/Poco/XML/Name.h
 create mode 100644 base/poco/XML/include/Poco/XML/NamePool.h
 create mode 100644 base/poco/XML/include/Poco/XML/NamespaceStrategy.h
 create mode 100644 base/poco/XML/include/Poco/XML/ParserEngine.h
 create mode 100644 base/poco/XML/include/Poco/XML/QName.h
 create mode 100644 base/poco/XML/include/Poco/XML/ValueTraits.h
 create mode 100644 base/poco/XML/include/Poco/XML/XML.h
 create mode 100644 base/poco/XML/include/Poco/XML/XMLException.h
 create mode 100644 base/poco/XML/include/Poco/XML/XMLStream.h
 create mode 100644 base/poco/XML/include/Poco/XML/XMLStreamParser.h
 create mode 100644 base/poco/XML/include/Poco/XML/XMLStreamParserException.h
 create mode 100644 base/poco/XML/include/Poco/XML/XMLString.h
 create mode 100644 base/poco/XML/include/Poco/XML/XMLWriter.h
 create mode 100644 base/poco/XML/include/Poco/XML/expat.h
 create mode 100644 base/poco/XML/include/Poco/XML/expat_external.h
 create mode 100644 base/poco/XML/src/AbstractContainerNode.cpp
 create mode 100644 base/poco/XML/src/AbstractNode.cpp
 create mode 100644 base/poco/XML/src/Attr.cpp
 create mode 100644 base/poco/XML/src/AttrMap.cpp
 create mode 100644 base/poco/XML/src/Attributes.cpp
 create mode 100644 base/poco/XML/src/AttributesImpl.cpp
 create mode 100644 base/poco/XML/src/CDATASection.cpp
 create mode 100644 base/poco/XML/src/CharacterData.cpp
 create mode 100644 base/poco/XML/src/ChildNodesList.cpp
 create mode 100644 base/poco/XML/src/Comment.cpp
 create mode 100644 base/poco/XML/src/ContentHandler.cpp
 create mode 100644 base/poco/XML/src/DOMBuilder.cpp
 create mode 100644 base/poco/XML/src/DOMException.cpp
 create mode 100644 base/poco/XML/src/DOMImplementation.cpp
 create mode 100644 base/poco/XML/src/DOMObject.cpp
 create mode 100644 base/poco/XML/src/DOMParser.cpp
 create mode 100644 base/poco/XML/src/DOMSerializer.cpp
 create mode 100644 base/poco/XML/src/DOMWriter.cpp
 create mode 100644 base/poco/XML/src/DTDHandler.cpp
 create mode 100644 base/poco/XML/src/DTDMap.cpp
 create mode 100644 base/poco/XML/src/DeclHandler.cpp
 create mode 100644 base/poco/XML/src/DefaultHandler.cpp
 create mode 100644 base/poco/XML/src/Document.cpp
 create mode 100644 base/poco/XML/src/DocumentEvent.cpp
 create mode 100644 base/poco/XML/src/DocumentFragment.cpp
 create mode 100644 base/poco/XML/src/DocumentType.cpp
 create mode 100644 base/poco/XML/src/Element.cpp
 create mode 100644 base/poco/XML/src/ElementsByTagNameList.cpp
 create mode 100644 base/poco/XML/src/Entity.cpp
 create mode 100644 base/poco/XML/src/EntityReference.cpp
 create mode 100644 base/poco/XML/src/EntityResolver.cpp
 create mode 100644 base/poco/XML/src/EntityResolverImpl.cpp
 create mode 100644 base/poco/XML/src/ErrorHandler.cpp
 create mode 100644 base/poco/XML/src/Event.cpp
 create mode 100644 base/poco/XML/src/EventDispatcher.cpp
 create mode 100644 base/poco/XML/src/EventException.cpp
 create mode 100644 base/poco/XML/src/EventListener.cpp
 create mode 100644 base/poco/XML/src/EventTarget.cpp
 create mode 100644 base/poco/XML/src/InputSource.cpp
 create mode 100644 base/poco/XML/src/LexicalHandler.cpp
 create mode 100644 base/poco/XML/src/Locator.cpp
 create mode 100644 base/poco/XML/src/LocatorImpl.cpp
 create mode 100644 base/poco/XML/src/MutationEvent.cpp
 create mode 100644 base/poco/XML/src/Name.cpp
 create mode 100644 base/poco/XML/src/NamePool.cpp
 create mode 100644 base/poco/XML/src/NamedNodeMap.cpp
 create mode 100644 base/poco/XML/src/NamespaceStrategy.cpp
 create mode 100644 base/poco/XML/src/NamespaceSupport.cpp
 create mode 100644 base/poco/XML/src/Node.cpp
 create mode 100644 base/poco/XML/src/NodeAppender.cpp
 create mode 100644 base/poco/XML/src/NodeFilter.cpp
 create mode 100644 base/poco/XML/src/NodeIterator.cpp
 create mode 100644 base/poco/XML/src/NodeList.cpp
 create mode 100644 base/poco/XML/src/Notation.cpp
 create mode 100644 base/poco/XML/src/ParserEngine.cpp
 create mode 100644 base/poco/XML/src/ProcessingInstruction.cpp
 create mode 100644 base/poco/XML/src/QName.cpp
 create mode 100644 base/poco/XML/src/SAXException.cpp
 create mode 100644 base/poco/XML/src/SAXParser.cpp
 create mode 100644 base/poco/XML/src/Text.cpp
 create mode 100644 base/poco/XML/src/TreeWalker.cpp
 create mode 100644 base/poco/XML/src/ValueTraits.cpp
 create mode 100644 base/poco/XML/src/WhitespaceFilter.cpp
 create mode 100644 base/poco/XML/src/XMLException.cpp
 create mode 100644 base/poco/XML/src/XMLFilter.cpp
 create mode 100644 base/poco/XML/src/XMLFilterImpl.cpp
 create mode 100644 base/poco/XML/src/XMLReader.cpp
 create mode 100644 base/poco/XML/src/XMLStreamParser.cpp
 create mode 100644 base/poco/XML/src/XMLStreamParserException.cpp
 create mode 100644 base/poco/XML/src/XMLString.cpp
 create mode 100644 base/poco/XML/src/XMLWriter.cpp
 create mode 100644 base/poco/XML/src/ascii.h
 create mode 100644 base/poco/XML/src/asciitab.h
 create mode 100644 base/poco/XML/src/expat_config.h
 create mode 100644 base/poco/XML/src/iasciitab.h
 create mode 100644 base/poco/XML/src/internal.h
 create mode 100644 base/poco/XML/src/latin1tab.h
 create mode 100644 base/poco/XML/src/nametab.h
 create mode 100644 base/poco/XML/src/siphash.h
 create mode 100644 base/poco/XML/src/utf8tab.h
 create mode 100644 base/poco/XML/src/xmlparse.cpp
 create mode 100644 base/poco/XML/src/xmlrole.c
 create mode 100644 base/poco/XML/src/xmlrole.h
 create mode 100644 base/poco/XML/src/xmltok.c
 create mode 100644 base/poco/XML/src/xmltok.h
 create mode 100644 base/poco/XML/src/xmltok_impl.c
 create mode 100644 base/poco/XML/src/xmltok_impl.h
 create mode 100644 base/poco/XML/src/xmltok_ns.c
 create mode 100644 base/poco/patches/AIX/xlC8.diff
 delete mode 160000 contrib/poco
 delete mode 100644 contrib/poco-cmake/Crypto/CMakeLists.txt
 delete mode 100644 contrib/poco-cmake/Data/CMakeLists.txt
 delete mode 100644 contrib/poco-cmake/Data/ODBC/CMakeLists.txt
 delete mode 100644 contrib/poco-cmake/Foundation/CMakeLists.txt
 delete mode 100644 contrib/poco-cmake/JSON/CMakeLists.txt
 delete mode 100644 contrib/poco-cmake/MongoDB/CMakeLists.txt
 delete mode 100644 contrib/poco-cmake/Net/CMakeLists.txt
 delete mode 100644 contrib/poco-cmake/Net/SSL/CMakeLists.txt
 delete mode 100644 contrib/poco-cmake/Redis/CMakeLists.txt
 delete mode 100644 contrib/poco-cmake/Util/CMakeLists.txt
 delete mode 100644 contrib/poco-cmake/XML/CMakeLists.txt
 delete mode 100644 src/Functions/examples/CMakeLists.txt

diff --git a/.gitmodules b/.gitmodules
index 13b1b2035be..0b88bd616fb 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,7 +1,3 @@
-[submodule "contrib/poco"]
-	path = contrib/poco
-	url = https://github.com/ClickHouse/poco
-	branch = clickhouse
 [submodule "contrib/zstd"]
 	path = contrib/zstd
 	url = https://github.com/facebook/zstd
diff --git a/base/CMakeLists.txt b/base/CMakeLists.txt
index dcf8f650262..9c47d63e9a2 100644
--- a/base/CMakeLists.txt
+++ b/base/CMakeLists.txt
@@ -1,8 +1,5 @@
-if (USE_CLANG_TIDY)
-    set (CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_PATH}")
-endif ()
-
 add_subdirectory (base)
 add_subdirectory (pcg-random)
+add_subdirectory (poco)
 add_subdirectory (widechar_width)
 add_subdirectory (readpassphrase)
diff --git a/base/base/CMakeLists.txt b/base/base/CMakeLists.txt
index 5d9f1de8309..64785d575c5 100644
--- a/base/base/CMakeLists.txt
+++ b/base/base/CMakeLists.txt
@@ -1,3 +1,7 @@
+if (USE_CLANG_TIDY)
+    set (CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_PATH}")
+endif ()
+
 set (SRCS
     argsToConfig.cpp
     coverage.cpp
diff --git a/base/pcg-random/CMakeLists.txt b/base/pcg-random/CMakeLists.txt
index 88acabba6a7..005b8dfa61f 100644
--- a/base/pcg-random/CMakeLists.txt
+++ b/base/pcg-random/CMakeLists.txt
@@ -1,2 +1,6 @@
+if (USE_CLANG_TIDY)
+    set (CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_PATH}")
+endif ()
+
 add_library(pcg_random INTERFACE)
 target_include_directories(pcg_random INTERFACE .)
diff --git a/base/poco/CHANGELOG b/base/poco/CHANGELOG
new file mode 100644
index 00000000000..a10371b381c
--- /dev/null
+++ b/base/poco/CHANGELOG
@@ -0,0 +1,2791 @@
+This is the changelog file for the POCO C++ Libraries.
+
+Release 1.9.3 (2019-08-20)
+==========================
+
+- fixed GH #2603: Remove incorrect upper size limits for SSL certificates in NetSSL_Win
+- fixed GH #2661: Poco::Zip::ZipArchive cannot load new tomcat.zip file (additional fix)
+- fixed GH #2742: Support of vs150 & vs160 with the official Microsoft localization executable,
+  vswhere.exe, installed by MSVC starting from VS2017
+- Data/ODBC: make binding of std::string configurable (SQL_LONGVARCHAR - default or SQL_VARCHAR)
+  through a global setting (Poco::Data::ODBC::Connector::bindStringToLongVarChar()).
+- added Poco::SharedLibrary::setSearchPath() (currently implemented on Windows only)
+- Windows required minimum version is now Windows XP SP2
+- upgraded bundled SQLite to 3.29.0
+- CppParser now supports type aliases defined with using keyword.
+- PageCompiler: added support for adding Content-Security-Policy and Cache-Control headers.
+
+
+Release 1.9.2 (2019-07-02)
+==========================
+
+- fixed GH #2736: Error using CMake gui - latest version
+- fixed GH #2737: Bundles vulnerable copy of Expat — please upgrade to Expat 2.2.7
+- fixed GH #2738: Poco::AccessExpireStrategy::onGet() must not extend expiration time after expiration
+
+
+Release 1.9.1 (2019-06-24)
+==========================
+
+- Added support for building with different OpenSSL distributions on Windows.
+  See the POCO_EXTERNAL_OPENSSL macro defined in Foundation/include/Poco/Config.h
+  for options.
+- Added Poco::Net::HTTPClientSession::flushRequest()
+- Added Poco::Net::WebSocket::setMaxPayloadSize() and Poco::Net::WebSocket::getMaxPayloadSize()
+  to specify a maximum acceptable payload size for Poco::Net::WebSocket::receiveFrame().
+- Poco::Net::WebSocket: don't attempt to send empty credentials in response to 401 response.
+- Redis: added support for additional commands (exists, expire, ping, multi, exec, discard)
+- Redis: added Poco::Redis::Client::isConnected()
+- Upgraded bundled PCRE to version 8.43
+- Upgraded bundled SQLite to version 3.28.0
+- Added project/solution files for Visual Studio 2019
+- Fixed Visual Studio project files (version information from DLLVersion.rc not included in DLLs)
+- Include version resource in DLLs built with CMake
+- Added HTTP*Credentials::empty() and HTTPCredentials::clear()
+- fixed GH #2220: Encoding/DoubleByteEncoding.cpp fails to compile with VS2008 and _DEBUG
+- fixed GH #2243: DLLVersion.rc is excluded from build, missing detail information in properties of *.dll
+- fixed GH #2277: SQLite null pointer dereference occurs when exception is being thrown
+- fixed GH #2313: PollSet behaves differently on windows
+- fixed GH #2316: cmake can't find MySQL and ODBC libraries
+- fixed GH #2336: Omit ContentLength in WebSocket accept response
+- fixed GH #2358: Don't include <openssl/fips.h> for later OpenSSL
+- fixed GH #2364: Stringify escapes every unicode symbol when object contain an array
+- fixed GH #2380: Calling Poco::Net::X509Certificate::addChainCertificate() leads to double free.
+- fixed GH #2492: Net::Socket::address() crash on Android
+- fixed GH #2549: Fix keepAlive in http client session
+- fixed GH #2565: HTMLForm: optional enforcement of Content-Length instead of Chunked Transfer-Encoding
+- fixed GH #2570: DialogSocket: receiveStatusMessage() - line length limit applies to entire multi-line message
+- fixed GH #2583: Crypto library does not build with OpenSSL 1.0.0
+- fixed GH #2655: MongoDB Binary element to string - bug
+- fixed GH #2661: Poco::Zip::ZipArchive cannot load new tomcat.zip file
+- fixed GH #2700: Invalid read of memory in Poco::Environment::set which may cause crashes.
+- fixed GH #2712: File_WIN32.cpp(168): error C2065: "_upath":Undeclared identifier
+- fixed GH #2723: Access violation when trying to decompress .zip file with unsupported compression method.
+
+
+Release 1.9.0 (2018-03-07)
+==========================
+
+- Added additional text encodings, available in the new PocoEncodings library (GH #2165)
+- Added Punycode support for resolving Internationalized Domain Names to Poco::Net::DNS (GH #2164)
+- Added XDG Base Directory Specification support in Poco::Path, Poco::Util::SystemConfiguration
+  and Poco::Util::Application (GH #1609, GH #561, GH #1609)
+- Added support for GCM ciphers in Crypto library (GH #2129)
+- Poco::Net::RemoteSyslogChannel and Poco::Net::RemoteSyslogListener now have basic
+  support for RFC 5424 structured data (GH #2173)
+- Poco::File now has methods for obtaining partition space (GH #1545)
+- Added Poco::Net::Context::addCertificateAuthority() (GH #2197)
+- Added Poco::AutoPtr::reset() and Poco::SharedPtr::reset() to improve compatibility
+  with std::shared_ptr() (GH #2172)
+- fixed GH #703: Poco::Data::SQLite data types (INTEGER is now mapped to Int64)
+- fixed GH #1426: inttypes.h is available on sun solaris
+- fixed GH #1912: Run ping with custom data size #1912
+- fixed GH #2177: Run ping with custom timeout instead of the default
+- fixed GH #2058 and GH #2095: Synchronization issue/deadlock in Poco::Util::Timer at destruction
+- fixed GH #2089: Allow hyphen in HTTP authentication scheme names
+- fixed GH #2106: Undefined behavior in Delegate::equals()
+- fixed GH #2108: POCO SQLite Data Connector hangs for 20 secs waiting for thread timeouts on Windows
+- fixed GH #2142: JSON::Object preserveOrder keys not synced on assignment
+- fixed GH #2199 and GH #2188: Illegal header in zip file exception/assertion failure during JAR file decompression
+- fixed GH #2203: Use MAX_ADDRESS_LENGTH to determine buffer size
+
+
+Release 1.8.1 (2018-01-09)
+==========================
+
+- Added Poco::File::linkTo()
+- fixed GH #2044: Poco::Net::NetworkInterface::list does not list inactive interfaces
+  even when explicitly being asked for it.
+- fixed GH #2042: Android abstract namespace local socket address
+- fixed GH #2038: Poco::Net::MultipartWriter::createBoundary() always returns the same string.
+- fixed GH #2020: SQLite not handling parameter count mismatch correctly.
+- fixed GH #2012: Data/SQLite: Exception messages contain duplicate text
+- fixed GH #2005: Upgraded bundled PCRE to 8.41
+- fixed GH #2000: Fix building XMLStreamParser with unbundled expat
+- fixed GH #1603: fix MinGW 4.8.2 Compilation
+- fixed GH #1991: Support building poco 1.8.0 as cmake sub-project
+- fixed GH #2080: Bugs in Poco::Net::Socket::select when POCO_HAVE_FD_POLL is defined
+
+
+Release 1.8.0.1 (2017-11-11)
+============================
+
+- Reverted change for GH #1828; DeflatingStreamBuf::sync() no longer flushes
+  underlying stream as this causes corruption for some Zip files.
+- PocoDoc: fix for handling compiler configuration for Gradle builds.
+
+
+Release 1.8.0 (2017-11-10)
+==========================
+
+- Poco::Base64Encoder: add support for base64url encoding (GH #1967)
+- Add Poco::Net::PollSet class to Net library (GH #1763)
+- The Net library now supports Unix Domain Sockets, where available.
+- Added stream parser (Poco::XML::XMLStreamParser) to XML library (GH #1697)
+- Added Poco::Net::TCPServerConnectionFilter and Poco::Net::TCPServer::setConnectionFilter()
+  to support connection filtering and IP blacklisting (GH #1485)
+- Added Redis library (GH #1383)
+- Added Zip64 support to Zip library (GH #1356)
+- Upgraded bundled SQLite to 3.21.0
+- Removed OpenVMS support (GH #1988)
+- fixed GH #271: NamedMutex_UNIX.cpp must remove semid
+- fixed GH #739: Add WebSocket::receiveFrame() that appends to a Poco::Buffer<char>
+- fixed GH #749: NTP Packet impl not according to RFC958
+- fixed GH #896: Sample "TwitterClient" of NetSSL_OpenSSL can't be build
+- fixed GH #1172: Poco::Data default storage should be std::vector
+- fixed GH #1337: Poco::HTMLForm throws exception HTMLFormException("Form must be prepared")
+  even after form is prepared.
+- fixed GH #1373: SessionImpl::close() does not check return code of close handle specific function
+- fixed GH #1425: Workaround bug in SolarisStudio 12.4 on RVO-ed objects.
+- fixed GH #1614: Problematic license for JSON component: the previously used JSON.org parser
+  has been replaced with pdjson
+- fixed GH #1659: wrong field size calculation in ODBC code
+- fixed GH #1683: Poco::Data ODBC impl doesn't bind to unsigned numeric types properly
+- fixed GH #1705: MongoDB: support URI in Connection
+- fixed GH #1708: "SocketReactor::addEventHandler" and "SocketReactor::removeEventHandler"
+  must protect the access to "NotifierPtr pNotifier"
+- fixed GH #1729: getConnectionTimeout of SQLite DB wrapper returns wrong value
+  (in milliseconds, should be in seconds)
+- fixed GH #1739: OpenSSLInitializer isn't threadsafe
+- fixed GH #1750: double_conversion in NumericString is in conflict with Qt5 Core
+- fixed GH #1804 and GH #1805: Integer Overflow or Wraparound
+- fixed GH #1828: DeflatingStreamBuf::sync() should also flush underlying stream.
+- fixed GH #1880: FTPClientSession::close() error
+- fixed GH #1897: DateTime wrong binding/extraction for MySQL database
+- fixed GH #1905: Compiling Foundation library with POCO_NO_FPENVIRONMENT in Config.h fails
+- fixed GH #1906: Race condition in ThreadPool
+- fixed GH #1913: Message Doesn't Support 64-bit Thread IDs
+- fixed GH #1921: ICMPSocket does not check reply address
+- fixed GH #1926: Exception when using SortedDirectoryIterator
+- fixed GH #1934: File::setExecutable() on POSIX should set executable bit for group and
+  other if corresponding readable bit is set
+- fixed GH #1950: Net Exception: Address family not supported with clang
+- fixed GH #1964: Buffer<> swap miss ownMem
+
+
+Release 1.7.9p2 (2017-11-06)
+============================
+
+- fixed GH #1628: Export Poco::Zip::ZipUtil class
+
+
+Release 1.7.9p1 (2017-11-02)
+============================
+
+- fixed GH #1968: Zip Decompress Parent Path Injection
+
+
+Release 1.7.9 (2017-09-11)
+==========================
+
+- fixed GH #1813: xmlparse.cpp doesn't compile in WinCE (poco 1.7.8p3)
+- fixed GH #1826: XPath query error
+- fixed GH #1834: Visual Studio 2008 cannot find stdint.h
+- fixed GH #1842: Upgrade bundled expat to 2.2.3
+- fixed GH #1843: Use random salt for Poco::XML::NamePool
+- fixed GH #1865: AbstractEvent::hasDelegates() is not thread-safe
+- improved/fixed QNX support
+- Poco::Util::LayeredConfiguration: added support for labelling configurations and
+  finding them by their label
+- upgraded bundled SQLite to 3.20.1
+- PageCompiler: support <%@ include file="<path>" %> syntax for includes, in addition
+  to <%@ include page="<path>" %>
+- PageCompiler: optimize generated request handler code by removing useless
+  statements, e.g. writing empty strings.
+- added POCO_DEPRECATED macro which will be used in the future to deprecate
+  classes and methods.
+- Poco::NamedMutex and Poco::NamedEvent (System V Semaphores implementation): files are
+  now opened with O_RDONLY | O_CREAT instead of O_WRONLY | O_CREAT, allowing sharing
+  between different users. Furthermore, ftok() is called with 'p' as project ID
+  argument.
+
+
+Release 1.7.8p3 (2017-06-22)
+============================
+
+- fixed GH #1760: Upgrade bundled expat to 2.2.1 which fixes some vulnerabilities:
+  http://seclists.org/oss-sec/2017/q2/499
+
+
+Release 1.7.8p2 (2017-04-18)
+============================
+
+- fixed GH #1655: CipherImpl memory leak with OpenSSL 1.1
+
+
+Release 1.7.8 (2017-02-21)
+==========================
+
+- fixed GH #1212: Lost WebSocket Frames after Client Websocket Handshake is complete
+- fixed GH #1260: URI encoding
+- fixed GH #1501: Alpine 3.4 trouble with Foundation/src/Error.cpp
+- fixed GH #1523: Long path names under Windows
+- fixed GH #1536: Building with OS X 10.12 SDK and 10.7 deployment target without libc++ fails
+- fixed GH #1537: Need to add multiple cflags parameters to configure
+- fixed GH #1539: Allow overriding POCO_TARGET_OSARCH for iPhoneSimulator
+- fixed GH #1546: Enable bitcode for iPhone build config
+- fixed GH #1549: Latin2Encoding and 0xFF
+- fixed GH #1551: Unable to use Poco on macOS 10.12
+- fixed GH #1552: IPv6 & operator throws an exception when scope = 0
+- fixed GH #1566: Poco/Zip issue with some CM_DEFLATE archives
+- fixed GH #1567: Poco/ZIP issue with uncompressed archives
+- fixed GH #1570: IPv6AddressImpl::toString() returns wrong output for IPv6 address "::"
+- fixed GH #1571: ODBC Preparator memory leak
+- fixed GH #1573: Poco::File::createDirectories() should not throw Poco::FileExistsException
+- fixed GH #1580: Unable to unzip zip file created using non-seeking stream
+- fixed GH #1581: Cannot find 'pcre.h' when using POCO_UNBUNDLED, a non-system PCRE, and CMake
+- fixed GH #1588: Poco::Net::HTTPChunkedStreamBuf::readFromDevice(): restrict maximum
+  size of chunk length
+- fixed GH #1589: Poco::Net::HTMLForm: restrict maximum field and value length
+- fixed GH #1590: Poco::Net::DialogSocket: restrict maximum line length
+- fixed GH #1591: Poco::Net::MultipartReader: restrict maximum boundary string length
+- fixed GH #1597: adding empty file to zip leads to archive that can't be unzipped by windows
+- fixed GH #1599: readFromDevice() in AutoDetectStream.cpp in Poco Zip cannot detect signature
+- fixed GH #1534: Upgraded bundled zlib to 1.2.11
+- fixed GH #1558: Upgraded bundled SQLite to 3.16.2
+- fixed GH #1586: Upgraded bundled PCRE to 8.40
+- fixed GH #1538: Upgraded bundled double-conversion to 1.1.5
+- MongoDB: added support for authentication using "MONGODB-CR" and "SCRAM-SHA-1"
+  authentication schemes.
+- MongoDB: additional documentation and fixes for style and consistency and minor
+  API improvements (e.g., Poco::MongoDB::Binary)
+  Note: some flag enumeration values have been renamed for better consistency
+  and readability; existing code using these will have to be updated.
+
+
+Release 1.7.7 (2016-12-31)
+==========================
+
+- fixed GH #865: FileChannel compress fails leaving empty .gz files
+- fixed GH #990: Potential race condition in Poco::File on Windows
+- fixed GH #1157: Fixing a bug in the NetSSL_Win module (Host name verification failed error)
+- fixed GH #1351: Fix for android include pthread.h from /usr/include
+- fixed GH #1436: ODBC Bug: Unicode text(NVARCHAT) read from DB is truncated to half
+- fixed GH #1453: _clock_gettime Symbol not found on Mac 10.11
+- fixed GH #1460: POCO does not build with OpenSSL 1.1
+- fixed GH #1461: Poco::Data::SQLite::SQLiteStatementImpl::next() error
+- fixed GH #1462: AbstractConfiguration::getUInt does not parse hex numbers
+- fixed GH #1464: ODBCMetaColumn::init() always maps integer NUMERIC/DECIMAL to Int32
+- fixed GH #1465: Assertion violation in DateTime.cpp using ZipArchive
+- fixed GH #1472: HTTP(S)StreamFactory should send a User-Agent header.
+- fixed GH #1476: Fixed error with Poco::UTF8Encoding::isLegal()
+- fixed GH #1484: ODBC: fix uninitialized variable
+- fixed GH #1486: Support ODBC GUID data type as string
+- fixed GH #1488: Poco::ObjectPool shrinks if returned object is not valid
+- fixed GH #1515: Detection of closed websocket connection
+- fixed GH #1521: bug in JSON ParseHandler.cpp (empty keys should be valid)
+- fixed GH #1526: iOS app rejected, IPv6 not working
+- fixed GH #1532: RecordSet and RowFilter: bad use of reference counter
+
+
+Release 1.7.6 (2016-10-18)
+==========================
+
+- fixed GH #1298: ZipFileInfo: Assertion violation when reading ods files
+- fixed GH #1315: Redefine Poco assertions for static analysis
+- fixed GH #1397: Fix issues reported by static source code analysis
+- fixed GH #1403: Android compile with poco-1.7.5 no 'pthread_condattr_setclock' error
+- fixed GH #1416: Assertion violation when unzipping
+- fixed GH #1418: Poco::Delegate assignment operator fails to compile for some specializations
+- fixed GH #1422: Can't build poco 1.7.4 or 1.7.5 on centos5 32 bit
+- fixed GH #1429: exception thrown in MongoDB when using replicaset
+- fixed GH #1431: Poco/FIFOBuffer.h copy issue
+- fixed GH #1445: Use stable_sort to preserve order of IP addresses from DNS
+- fixed GH #1456: better handle leap seconds in Poco::DateTime and Poco::LocalDateTime
+- fixed GH #1458: Probably invalid epoll_create() usage inside Poco/Socket.cpp
+- Poco::XML::NamePool: increased default size from 251 to 509. Default size can now
+  be changed by defining the POCO_XML_NAMEPOOL_DEFAULT_SIZE macro accordingly.
+- Enchancements: Poco::XML::Document and Poco::XML::DOMParser have new constructors
+  taking a NamePool size. Poco::Util::XMLConfiguration::load() also has a new overload
+  for that purpose.
+- Improved error handling in the Zip library (getting rid of some poco_assert macros
+  and did proper error handling instead).
+- Added Poco::URISyntaxException (subclass of Poco::SyntaxException), which is now
+  thrown by Poco::URI.
+- Improved error handling in Poco::URIStreamOpener::open().
+- Poco::Data::MySQL: Handle connection lost/server gone error when starting a transaction
+  and retry.
+- XMLConfiguration default (and single-argument delimiter) constructor now loads an empty
+  XML document with "config" root element to make the configuration usable without an
+  additional call to load() or loadEmpty().
+
+
+Release 1.7.5 (2016-08-29)
+==========================
+
+- fixed GH #1252: Unable to compile Poco::Data for Windows Compact Embedded 2013
+- fixed GH #1344: Poco::Event::wait(timeout) should use CLOCK_MONOTONIC on Linux
+- fixed GH #1355: [JSON::Object] After copy-ctor, JSON::Object::_keys still points to
+  keys in map of copied object
+- GH #1361: Shell expansion rules say that tilde must be replaced with $HOME before
+  calling getpwuid
+- Poco::SingletonHolder: added reset() method
+- prefer clock_getttime() over gettimeofday() if available
+- Upgraded bundled SQLite to 3.14.1
+
+
+Release 1.7.4 (2016-07-20)
+==========================
+
+- fixed GH #1300: Session constructor hangs
+- fixed GH #1303: HTTPSClientSession::sendRequest() fails if server has wildcard cert
+- fixed GH #1304: URI doesn't know "ws:/" or "wss://" schemes
+- fixed GH #1307: Upgrade bundled expat to 2.2.0
+- fixed GH #1313: XML library compilation error
+- fixed GH #1316: Empty SocketReactor never sleeps
+- Upgraded bundled SQLite to 3.13.0
+
+
+Release 1.7.3 (2016-05-02)
+==========================
+
+- fixed GH #993: Invalid zip format when opening a docx in word
+- fixed GH #1235: Poco::Net::HTTPClientSession::sendRequest() should also handle HTTP_PATCH
+- fixed GH #1236: Remove Poco::Data::Row::checkEmpty() as it prevents Row from being used
+  with all NULL rows
+- fixed GH #1239: Poco::Zip::Compress with non-seekable stream fails for CM_STORE
+- fixed GH #1242: Poco::Data::RowFormatter generate exception if the first column of first
+  row is null
+- fixed GH #1253: ListMap does not maintain insertion order if key already exists
+- Upgraded bundled SQLite to 3.12.2
+
+
+Release 1.7.2 (2016-03-21)
+==========================
+
+- fixed GH #1197: Upgrade bundled expat to 2.1.1
+  Expat 2.1.1 fixes a CVE: https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2015-1283
+- fixed GH #1204: getdtablesize has been removed on Android 21
+- fixed GH #1203: Poco::Data::RecordSet should be reusable
+- fixed GH #1198: Upgrade bundled SQLite to 3.12.1
+
+
+Release 1.7.1 (2016-03-14)
+==========================
+
+- fixed GH #1187: Data/MySQL: Seeing frequent "MySQL server has gone away" errors
+- fixed GH #1184: Attempting to connect via a proxy throws a DNS error "Host not found"
+- fixed GH #1180: Possible deadlock when TaskManager::count() is called in onFinished
+- NetSSL_OpenSSL: use TLS_*_method() instead of deprecated SSLv23_*_method()
+  if OpenSSL version is >= 1.1; initialize default/fallback client context to support
+  all TLS protocols, not just TLSv1
+
+
+Release 1.7.0 (2016-03-07)
+==========================
+
+- POSSIBLE BREAKING CHANGE: removed automatic registration of Data connectors due to
+  issues with static initialization order.
+- NetSSL_OpenSSL: added support for ECDH and DH ciphers; added support to disable
+  specific protocols (Poco::Net::Context::disableProtocols());
+  new Poco::Net::Context constructor taking a Poco::Net::Context::Params structure that
+  allows specifying ECDH and DH parameters.
+- Poco::Net::TCPServer: add additional try ... catch block around poll() to
+  gracefully deal with errors due to high system load (e.g., out of file descriptors).
+- fixed GH #1171: Poco::Data::RecordSet: rowCount not reset after execute
+- fixed GH #1167: CMake & POCO_UNBUNDLED: expat sources are compiled in libPocoXML
+- fixed GH #1160: Poco::Net::NetException
+  "SSL Exception: error:1409F07F:SSL routines:ssl3_write_pending:bad write retry"
+- fixed GH #1152: Wrong TaskProgressNotification description
+- fixed GH #1141: Poco::StringTokenizer::TOK_TRIM changes behavior between 1.4 and 1.6
+- fixed GH #1137: Missing 'longint' type in SQLite
+- fixed GH #1135: Different package on github and official web site
+- fixed GH #1030: tvOS / WatchOS bitcode enabled for simulators
+- fixed GH #1114: World-write permissions on files created by daemon
+- fixed GH #1087: prevent line breaks in base64-encoded creds
+- fixed GH #1026: Fixes for producing the poco-1.6.2 release on a Cygwin x86 platform
+- fixed GH #1022: Abbreviation in setThreadName can happen even if thread name is not too long
+- fixed GH #1002: ActiveDispatcher saves reference to event context after event was
+  performed until it gets new event
+- fixed GH #973: overwrite existing files on windows when moving files
+- fixed GH #969: Poco::File::renameTo() behaviour differs on windows and linux
+- fixed GH #967: Missing data types in SQLite
+- fixed GH #966: Possible crash when processing a corrupted Zip file
+- fixed GH #958: Bug while reading X509Certificate subjectName
+- fixed GH #937: Missing build_vs140.cmd
+- fixed GH #933: Change in JSON::Object::set(key,value) behavior in 1.6.1
+- fixed GH #931: make strToInt() more strict in what it accepts
+- fixed GH #921: `BasicUnbufferedStreamBuf` needs to be marked for import/export
+- fixed GH #848: MailMessage::_encoding is not set when retrieving plain/text message
+- fixed GH #767: Inconsistency in getPath & getPathAndQuery returns
+- fixed GH #724: Poco 1.6.0 is not compiled with openssl 1.0.0
+- fixed GH #713: Improved support for producing Canonical XML in XMLWriter
+- fixed GH #696: bug in parsing name of attachment poco c++ 1.6.0
+- fixed GH #335: Compress with nonseekable
+- upgraded bundled SQLite to 3.11.0
+- added Poco::Crypto::X509Certificate::equals() to compare two certificates
+- support for detecting Win8/Win10 in Poco::Environment
+- Poco::Net::HTTPServerRequestImpl: fixed an issue with DELETE in persistent connections
+- NetSSL: added Context::preferServerCiphers()
+- NetSSL: added support for ECDH, new Context constructor
+- NetSSL: add support for disabling certain protocols
+- SMTPClientSession: added support for XOAUTH2 authentication
+- Poco::Data::SessionPool: re-added customizeSession() method from 1.4.x releases
+- improved SSLManager to automatically set-up a reasonable client Context if
+  none is configured
+- add brew OpenSSL search paths to Darwin configs
+- add HTTP/1.1 version to HTTPRequest for client WebSocket, as this is required for
+  most servers
+- remove GCC_DIAG_OFF as this caused more issues than it solved
+- respect POCO_NO_FORK_EXEC in ServerApplication (tvOS)
+- tvOS and WatchOS support
+- fix: need an implementation of available() for WebSocketImpl
+- HTTPSessionInstantiator: respect global proxy config
+- added constant for HTTP PATCH method to Poco::Net::HTTPRequest
+- NumberParser::parseHex[64](): allow 0x/0X prefix
+
+
+Release 1.6.1 (2015-08-03)
+==========================
+
+- added project and solution files for Visual Studio 2015
+- upgraded bundled SQLite to 3.8.11.1
+- fixed GH #782: Poco::JSON::PrintHandler not working for nested arrays
+- fixed GH #819: JSON Stringifier fails with preserve insert order
+- fixed GH #878: UUID tryParse
+- fixed GH #869: FIFOBuffer::read(T*, std::size_t) documentation inaccurate
+- fixed GH #861: Var BadCastException
+- fixed GH #779: BUG in 1.6.0 Zip code
+- fixed GH #769: Poco::Var operator== throws exception
+- fixed GH #766: Poco::JSON::PrintHandler not working for objects in array
+- fixed GH #763: Unable to build static with NetSSL_OpenSSL for OS X
+- fixed GH #750: BsonWriter::write<Binary::Ptr> missing size ?
+- fixed GH #741: Timestamp anomaly in Poco::Logger on WindowsCE
+- fixed GH #735: WEC2013 build fails due to missing Poco::Path methods.
+- fixed GH #722: poco-1.6.0: Unicode Converter Test confuses string and char types
+- fixed GH #719: StreamSocket::receiveBytes and FIFOBuffer issue in 1.6
+- fixed GH #706: POCO1.6 Sample EchoServer BUG
+- fixed GH #646: Prevent possible data race in access to Timer::_periodicInerval
+- DeflatingStream: do not flush underlying stream on sync() as these can cause
+  corrupted files in Zip archives
+
+
+Release 1.6.0 (2014-12-22)
+==========================
+
+- fixed GH #625: MongoDB ensureIndex double insert?
+- fixed GH #622: Crypto: RSATest::testSign() should verify with public key only
+- fixed GH #620: Data documentation sample code outdated
+- fixed GH #618: OS X 10.10 defines PAGE_SIZE macro, conflicts with PAGE_SIZE in Thread_POSIX.cpp
+- fixed GH #616: Visual Studio warning C4244
+- fixed GH #612: OpenSSLInitializer calls OPENSSL_config but not CONF_modules_free
+- fixed GH #608: (Parallel)SocketAcceptor ctor/dtor call virtual functions
+- fixed GH #607: Idle Reactor high CPU usage
+- fixed GH #606: HTMLForm constructor read application/x-www-form-urlencoded UTF-8 request
+  body first parameter with BOM in name
+- fixed GH #596: For OpenSSL 1.0.1, include openssl/crypto.h not openssl/fips.h
+- fixed GH #592: Incorrect format string in Poco::Dynamic::Struct
+- fixed GH #590: Poco::Data::SQlite doesn't support URI filenames
+- fixed GH #564: URI::encode
+- fixed GH #560: DateTime class calculates a wrong day
+- fixed GH #549: Memory allocation is not safe between fork() and execve()
+- fixed GH #500: SSLManager causes a crash
+- fixed GH #490: 2 byte frame with payload length of 0 throws "Incomplete Frame Received" exception
+- fixed GH #483: multiple cases for sqlite_busy
+- fixed GH #482: Poco::JSON::Stringifier::stringify bad behaviour
+- fixed GH #478: HTTPCredentials not according to HTTP spec
+- fixed GH #471: vs2010 release builds have optimization disabled ?
+- fixed GH #468: HTTPClientSession/HTTPResponse not forwarding exceptions
+- fixed GH #438: Poco::File::setLastModified() doesn't work
+- fixed GH #402: StreamSocket::receiveBytes(FIFOBuffer&) and sendBytes(FIFOBuffer&) are
+  not thread safe
+- fixed GH #345: Linker warning LNK4221 in Foundation for SignalHandler.obj, String.obj
+  and ByteOrder.obj
+- fixed GH #331: Poco::Zip does not support files with ".." in the name.
+- fixed GH #318: Logger local time doesn't automatically account for DST
+- fixed GH #294: Poco::Net::TCPServerParams::setMaxThreads(int count) will not accept count == 0.
+- fixed GH #215: develop WinCE build broken
+- fixed GH #63: Net::NameValueCollection::size() returns int
+- Poco::Logger: formatting methods now support up to 10 arguments.
+- added Poco::Timestamp::raw()
+- Poco::DeflatingOutputStream and Poco::InflatingOutputStreams also flush underlying stream
+  on flush()/sync().
+- Poco::Util::Timer: prevent re-schedule of cancelled TimerTask
+- enabled WinRegistryKey and WinRegistryConfiguration for WinCE
+- Poco::BasicEvent improvements and preparations for future support of lambdas/std::function
+- upgraded bundled sqlite to 3.8.7.2
+- Poco::Thread: added support for starting functors/lambdas
+- Poco::Net::HTTPClientSession: added support for global proxy configuration
+- added support for OAuth 1.0/2.0 via Poco::Net::OAuth10Credentials and
+  Poco::Net::OAuth20Credentials classes.
+- Poco::Net::IPAddress: fixed IPv6 prefix handling issue on Windows
+- added Poco::Timestamp::TIMEVAL_MIN and Poco::Timestamp::TIMEVAL_MAX
+- added Poco::Clock::CLOCKVAL_MIN and Poco::Clock::CLOCKVAL_MAX
+- added poco_assert_msg() and poco_assert_msg_dbg() macros
+- Poco::Net::Context: fixed a memory leak if the CA file was not found while creating the
+  Context object (the underlying OpenSSL context would leak)
+- Poco::URI: added new constructor to create URI from Path
+- Various documentation and style fixes
+- Removed support (project/solution files) for Visual Studio.NET 2003 and Visual Studio 2005.
+- Improved CMake support
+
+
+Release 1.5.4 (2014-10-14)
+==========================
+
+- fixed GH #326: compile Net lib 1.5.2 without UTF8 support enabled
+- fixed GH #518: NetworkInterface.cpp compile error w/ POCO_NO_WSTRING (1.5.3)
+- Fixed MSVC 2010 warnings on large alignment
+- make HTTPAuthenticationParams::parse() add value on end of string
+- fixed GH #482: Poco::JSON::Stringifier::stringify bad behaviour
+- fixed GH #508: Can't compile for arm64 architecture
+- fixed GH #510: Incorrect RSAKey construction from istream
+- fix SharedMemory for WinCE/WEC2013
+- Add NIOS2 double conversion detection, fixes compile errors
+- added VS2013 project/solution files for Windows Embedded Compact 2013
+- added Process::isRunning()
+- NetSSL: Fix typo in documentation
+- NetSSL_OpenSSL: support for TLS 1.1 and 1.2
+- Zip: Added CM_AUTO, which automatically selects CM_STORE or CM_DEFLATE based
+  on file extension. Used to avoid double-compression of already compressed file
+  formats such as images.
+- added %L modifier to PatternFormatter to switch to local time
+- removed unnecessary explicit in some multi-arg constructors
+- Allow SecureStreamSocket::attach() to be used in server connections
+- added Var::isBoolean() and fixed JSON stringifier
+- added poco_unexpected() macro invoking Bugcheck::unexpected() to deal
+  with unexpected exceptions in destructors
+- fixed GH #538 prevent destructors from throwing exceptions
+- improved HTTP server handling of errors while reading header
+- fixed GH #545: use short for sign
+- upgraded SQLite to 3.8.6
+- fixed GH #550 WebSocket fragmented message problem
+- improved HTTPClientSession handling of network errors while sending the request
+- updated bundled PCRE to 8.35.0
+- fixed GH #552: FIFOBuffer drain() problem
+- fixed GH #402: StreamSocket::receiveBytes(FIFOBuffer&) and sendBytes(FIFOBuffer&) are
+  not thread safe
+- HTTPCookie: fix documentation for max age
+- added Timestamp::raw() and Clock::raw()
+- Poco::Buffer properly handles zero-sized buffers
+- GH #512: Poco:Data:ODBC:Binder.h causes a crash
+- Added Crypto_Win and NetSSL_Win libraries which are re-implementations of existing
+  Crypto and NetSSL_OpenSSL libraries based on WinCrypt/Schannel. The new libraries
+  can be used as an almost drop-in replacement for the OpenSSL based libraries on
+  Windows and Windows Embedded Compact platforms. Only available from GitHub for now.
+
+
+Release 1.5.3 (2014-06-30)
+==========================
+
+- fixed GH# 316: Poco::DateTimeFormatter::append() gives wrong result for
+  Poco::LocalDateTime
+- Poco::Data::MySQL: added SQLite thread cleanup handler
+- Poco::Net::X509Certificate: improved and fixed domain name verification for
+  wildcard domains
+- added Poco::Clock class, which uses a system-provided monotonic clock
+  (if available) and is thus not affected by system realtime clock changes.
+  Monotonic Clock is available on Windows, Linux, OS X and on POSIX platforms
+  supporting clock_gettime() and CLOCK_MONOTONIC.
+- Poco::Timer, Poco::Stopwatch, Poco::TimedNotificationQueue and Poco::Util::Timer
+  have been changed to use Poco::Clock instead of Poco::Timestamp and are now
+  unaffected by system realtime clock changes.
+- fixed GH# 350: Memory leak in Data/ODBC with BLOB
+- Correctly set MySQL time_type for Poco::Data::Date.
+- fixed GH #352: Removed redundant #includes and fixed spelling mistakes.
+- fixed setting of MYSQL_BIND is_unsigned value.
+- fixed GH #360: CMakeLists foundation: add Clock.cpp in the list of source files
+- Add extern "C" around <net/if.h> on HPUX platform.
+- added runtests.sh
+- fixed CPPUNIT_IGNORE parsing
+- fixed Glob from start path, for platforms not alowing transverse from root (Android)
+- added NTPClient (Rangel Reale)
+- added PowerShell build script
+- added SmartOS build support
+- fix warnings in headers
+- XMLWriter: removed unnecessary apostrophe escaping (&apos)
+- MongoDB: use Int32 for messageLength
+- fixed GH #380: SecureSocket+DialogSocket crashes with SIGSEGV when timeout occours
+- Improve RSADigestEngine, using Poco::Crypto::DigestEngine to calculate hash before signing
+- added Poco::PBKDF2Engine
+- Fixed GH #380: SecureSocket+DialogSocket crashes with SIGSEGV when timeout occours
+- added support for a 'Priority' attribute on cookies.
+- GH #386: fixed bug in MailMessage without content-transfer-encoding header
+- GH #384: ew hash algorithms support for RSADigestEngine
+- fixed Clock overflow bug on Windows
+- Poco::ByteOrder now uses intrinsics, if available
+- CMake: added /bigobj option for msvc
+- Fix typo to restore Net/TestSuite_x64_vs120 build
+- correct path for CONFIGURE_FILE in CMakeLists.txt
+- Building Poco 1.5.2 for Synology RS812+ (Intel Atom) (honor POCO_NO_INOTIFY)
+- added WEC2013 support to buildwin.cmd and buildwin.ps1
+- HTMLForm: in URL encoding, percent-encode more characters
+- Fixed #include <linux/if.h> conflict with other libraries
+- Poco::Net::X509Certificate::verify() no longer uses DNS reverse lookups to validate host names
+- cert hostname validation is case insensitive and stricter for wildcard certificates
+- TCPServer: do not reduce the capacity of the default ThreadPool
+- added POCO_LOG_DEBUG flag
+- Zip: fixed a crash caused by an I/O error
+- added runtest script for windows
+- added SQlite Full Text Search support
+- added Thread::trySleep() and Thread::wakeUp()
+- fixed GH #410: Bug in JSON::Object.stringify() in 1.5.2
+- fixed GH #362: Defect in Var::parseString when there is no space between value and newline
+- fixed GH #314: JSON parsing bug
+- added GH #313: MetaColumn additions for Data::ODBC and Data::SQLite
+- fixed GH #346: Make Poco::Data::Date and Poco::Data::Time compare functions const.
+- fixed GH #341: Compiling poco-1.5.2 for Cygwin
+- fixed GH #305: There are bugs in Buffer.h
+- fixed GH #321: trivial build fixes (BB QNX build)
+- fixed GH #440: MongoDB ObjectId string formatting
+- added SevenZip library (Guenter Obiltschnig)
+- fixed GH #442: Use correct prefix length field of Windows IP_ADAPTER_PREFIX structure
+- improved GH #328: NetworkInterface on Windows XP
+- fixed GH #154 Add support for MYSQL_TYPE_NEWDECIMAL to Poco::Data::MySQL
+- fixed GH #290: Unicode support
+- fixed GH #318: Logger local time doesn't automatically account for DST
+- fixed GH #363: DateTimeParser tryParse/parse
+- added HTMLForm Content-Length calculation (Rangel Reale)
+- Make TemporaryFile append a slash to tempDir
+- fixed GH #319 android build with cmake
+- added hasDelegates() method to AbstractEvent
+- fixed GH #230: Poco::Timer problem
+- fixed GH #317: Poco::Zip does not support newer Zip file versions.
+- fixed GH #176: Poco::JSON::Stringifier UTF encoding
+- fixed GH #458: Broadcast address and subnet mask for IEEE802.11 network interface
+- fixed GH #456: poco: library install dirs per RUNTIME/LIBRARY/ARCHIVE
+
+
+Release 1.5.2 (2013-09-16)
+==========================
+
+- added MongoDB library
+- fixed GH #57: poco-1.5.1: Doesn't compile for Android
+- added VoidEvent (Arturo Castro)
+- fixed GH #80: NumberFormatter::append broken
+- fixed GH #93: ParallelSocketAcceptor virtual functions
+- optional small object optimization for IPAddress, SocketAddress, Any and Dynamic::Var
+- SQLite events (insert, update, delete, commit, rollback) handlers
+- merged GH #91: Improve SQLite multi-threaded use (Rangel Reale)
+- merged GH #86: Invalid pointers to vector internals (Adrian Imboden)
+- automatic library initialization macros
+- fixed GH #110: WebSocket accept() fails when Connection header contains multiple tokens
+- fixed GH #71: WebSocket and broken Timeouts (POCO_BROKEN_TIMEOUTS)
+- fixed a warning in Poco/Crypto/OpenSSLInitializer.h
+- fixed GH #109: Bug in Poco::Net::SMTPClientSession::loginUsingPlain
+- added clang libc++ build configurations for Darwin and iPhone (Andrea Bigagli)
+- fixed GH #116: Wrong timezone parsing in DateTimeParse (Matej Knopp)
+- fixed GH #118: JSON::Object::stringify endless loop
+- added Recursive and SortedDirectoryIterator (Marian Krivos)
+- added ListMap (map-like container with preserving insertion order)
+- MailMessage: attachments saving support and consistent read/write
+- fixed GH #124: Possible buffer overrun in Foundation/EventLogChannel
+- fixed GH #119: JSON::Object holds values in ordered map
+- added JSON::PrintHandler
+- renamed JSON::DefaultHandler to ParseHandler (breaking change!)
+- fixed GH #127: Eliminate -Wshadow warnings
+- fixed GH #79: Poco::Thread leak on Linux
+- fixed GH #61: static_md build configs for Crypto and NetSSL
+- fixed GH #130: prefer sysconf over sysctlbyname
+- fixed GH #131: no timezone global var on OpenBSD
+- fixed GH #102: Some subprojects don't have x64 solutions for VS 2010
+- added GH #75: Poco::Uri addQueryParameter method
+- Poco::Environment::osDisplayName() now recognizes Windows 8/Server 2012
+- fixed GH #140: Poco::Runnable threading cleanup issue
+- simplified default TCP/HTTPServer construction
+- fixed GH #141: Application::run() documentation/implementation discrepancy
+- changed RowFormatter to SharedPtr<RowFormatter> in Data::RecordSet interface (breaking change!)
+- fixed GH #144: Poco::Dynamic emits invalid JSON
+- removed naked pointers from Data interfaces
+- fixed GH #82: name conflict in Data::Keywords::bind
+- fixed GH #157: MySQL: cannot bind to 'long' data type on Windows/Visual C++
+- fixed GH #158: MySQL: MYSQL_BIND 'is_unsigned' member is not set
+- fixed GH #160: MultipartReader ignores first part, if preamble is missing
+- fixed GH #156: Possible buffer overrun in Foundation/EventLogChannel
+- XML: fixed an issue with parsing a memory buffer > 2 GB
+- upgraded to expat 2.1.0
+- Data/ODBC: added support for setting query timeout (via setProperty
+  of "queryTimeout"). Timeout is int, given in seconds.
+- fixed a potential endless loop in SecureStreamSocketImpl::sendBytes()
+  and also removed unnecessary code.
+- fixed GH #159: Crash in openssl CRYPTO_thread_id() after library libPocoCrypto.so
+  has been unloaded.
+- fixed GH #155: MailOutputStream mangles consecutive newline sequences
+- fixed GH #139: FileChannel::PROP_FLUSH is invalid (contains a tab character)
+- fixed GH #173: HTTPClientSession::proxyConnect forces DNS lookup of host names
+- fixed GH #194: MessageNotification constructor is inefficient.
+- fixed GH #189: Poco::NumberParser::tryParse() documentation bug
+- fixed GH #172: IPv6 Host field is stripped of Brackets in HTTPClientSession
+- fixed GH #188: Net: SocketAddress operator < unusable for std::map key
+- fixed GH #128: DOMWriter incorrectly adds SYSTEM keyword to DTD if PUBLIC is
+  already specified
+- fixed GH #65: Poco::format() misorders sign and padding specifiers
+- upgraded bundled SQLite to 3.7.17
+- replaced JSON parser with Poco::Web::JSON parser (from sandbox)
+- added JSON conversion to Dynamic Struct and Array
+- added VarIterator
+- modified behavior of empty Var (empty == empty)
+- added Alignment.h header for C++03 alignment needs
+- added Data/WebNotifier (DB, WebSocket) example
+- fixed GH #209: Poco::NumberFormatter double length
+- fixed GH #204: Upgrade zlib to 1.2.8
+- fixed GH #198: The "application.configDir" property is not always created.
+- fixed GH #185: Poco::NumberFormatter::format(double value, int precision)
+  ignore precision == 0
+- fixed GH #138: FreeBSD JSON tests fail
+- fixed GH #99: JSON::Query an JSON::Object
+- limited allowed types for JSON::Query to Object, Array, Object::Ptr,
+  Array::Ptr and empty
+- fixed GH #175: HTMLForm does not read URL parameters on POST or PUT
+- added GH #187: MySQL: allow access to the underlying connection handle
+- added GH #186: MySQL: support for MYSQL_SECURE_AUTH
+- fixed GH #174: MySQL: 4GB allocated when reading any largetext or largeblob field
+- fixed a potential memory leak in Poco::Net::HTTPClientSession if it is misused
+  (e.g., sendRequest() is sent two times in a row without an intermediate call to
+  receiveResponse(), or by calling receiveResponse() two times in a row without
+  an intermediate call to sendRequest()) - GH #217
+- removed a few unnecessary protected accessor methods from Poco::Net::HTTPClientSession
+  that would provide inappropriate access to internal state
+- merged GH #210: Don't call CloseHandle() twice on Windows; Ability to select the
+  threadpool that will be used to start an Activity(Patrice Tarabbia)
+- fixed GH #212: JSONConfiguration was missing from the vs90 project(Patrice Tarabbia)
+- fixed GH #220: add qualifiers for FPEnvironment in C99 (Lucas Clemente)
+- fixed GH #222: HTTPCookie doesn't support expiry times in the past (Karl Reid)
+- fixed GH #224: building 1.5.1 on Windows for x64
+- fixed GH# 233: ServerSocket::bind6(Poco::UInt16 port, bool reuseAddress, bool ipV6Only) does not work
+- fixed GH# 231: Compatibility issue with Poco::Net::NetworkInterface
+- fixed GH# 236: Bug in RecursiveDirectoryIterator
+- added ColorConsoleChannel and WindowsColorConsoleChannel classes supporting
+  colorizing log messages
+- fixed GH# 259: Poco::EventLogChannel fails to find 64bit Poco Foundation dll
+- fixed GH# 254: UTF8::icompare unexpected behavior
+- Poco::UUID::tryParse() also accepts UUIDs without hyphens. Also updated documentation
+  (links to specifications).
+- added GH# 268: Method to get JSON object value using Poco::Nullable
+- fixed GH# 267: JSON 'find' not returning empty result if object is expected but another value is found
+- Added support for ARM64 architecture and iPhone 5s 64-bit builds
+  (POCO_TARGET_OSARCH=arm64).
+
+
+Release 1.5.1 (2013-01-11)
+==========================
+
+- using double-conversion library for floating-point numeric/string conversions
+- added Poco::istring (case-insensitive string) and Poco::isubstr
+- added SQLite sys.dual (in-memory system table)
+- applied SF Patch #120: The ExpireLRUCache does not compile with a tuple as key on Visual Studio 2010
+- fixed SF Bug #599: JSON::Array and JSON::Object size() member can implicitly lose precision
+- fixed SF Bug #602: iterating database table rows not correct if no data in table
+- fixed SF Bug #603: count() is missing in HashMap
+- fixed GH #23: JSON::Object::stringify throw BadCastException
+- fixed GH #16: NetworkInterface::firstAddress() should not throw on unconfigured interfaces
+- Android compile/build support (by Rangel Reale)
+- TypeHandler::prepare() now takes const-reference
+- fixed GH #27: Poco::URI::decode() doesn't properly handle '+'
+- fixed GH #31: JSON implementation bug
+- fixed SF #597: Configure script ignores cflags
+- fixed SF #593: Poco 1.5.0 on FreeBSD: cannot find -ldl
+- added SF #542: SocketAddress() needs port-only constructor
+- fixed SF #215: Wrong return type in SocketConnector.h
+- applied SF Patch #97: fix c++0x / clang++ bugs
+- fixed GH32/SF596: Poco::JSON: Parsing long integer (int64) value fails.
+- added Net ifconfig sample (contributed by Philip Prindeville)
+- merged GH #34: add algorithm header (Roger Meier/Philip Prindeville)
+- fixed GH #26: Cannot compile on gcc
+- merged SF #111: FTP Client logging (Marian Krivos)
+- fixed GH #30: Poco::Path::home() throws when called from Windows Service
+- fixed GH #22: MySQL connection string lowercased
+- added MySQL support for Date/Time
+- upgraded SQLite to version 3.7.15.1 (2012-12-19)
+- improved SQLite execute() return (affected rows) value and added tests
+- added SQLite::Utility::isThreadSafe() function
+- added SQLite::Utility::setThreadMode(int mode) function
+- fixed GH #36: 'distclean' requires 3 traversals of project tree
+- fixed GH #41: Buffer::resize crash
+- fixed GH #42: Linux unbundled builds don't link
+- fixed GH #44: Problems with win x64 build
+- fixed GH #46: 1.5.1 build fails on OS X when using libc++
+- fixed GH #48: Need getArgs() accessor to Util::Application to retrieve start-up arguments
+- fixed GH #49: NetworkInterface::list doesn't return MAC addresses
+- fixed GH #51: Android should use isfinite, isinf, isnan and signbit from the std namespace
+- fixed GH #53: JSON unicode fixes and running tests on invalid unicode JSON
+- added ParallelAcceptor and ParallelReactor classes
+- added EOF and error to FIFOBuffer
+
+
+Release 1.5.0 (2012-10-14)
+==========================
+
+- added JSON library
+- added Util::JSONConfiguration
+- added FIFOBuffer and FIFOBufferStream
+- fixed SF# 3522906: Unregistering handlers from SocketReactor
+- fixed SF# 3522084: AbstractConfiguration does not support 64-bit integers
+- HTTPServer::stopAll(): close the socket instead of just shutting it down, as the latter won't wake up a select() on Windows
+- added SMTPLogger
+- added cmake support
+- fixed SF#3538778: NetworkInterface enumeration uses deprecated API
+- fixed SF#3538779: IPAddress lacks useful constructors: from prefix mask, native SOCKADDR
+- fixed SF#3538780: SocketAddress needs operator < function
+- fixed SF#3538775: Issues building on Fedora/Centos, etc. for AMD64
+- fixed SF#3538786: Use size_t for describing data-blocks in DigestEngine
+- added IPAddress bitwise operators (&,|,^,~)
+- added IPAddress BinaryReader/Writer << and >> operators
+- modified IPAddress to force IPv6 to lowercase (RFC 5952)
+- fixed SF#3538785: SMTPClientSession::sendMessage() should take recipient list
+- added IPAddress::prefixLength()
+- UTF portability improvements
+- fixed SF#3556186: Linux shouldn't use <net/if.h> in Net/SocketDefs.h
+- added IPAddress RFC 4291 compatible site-local prefix support
+- fixed SF#3012166: IPv6 patch
+- added SF#3558085: Add formatter to MACAddress object
+- fixed SF#3552774: Don't hide default target in subordinate makefile
+- fixed SF#3534307: Building IPv6 for Linux by default
+- fixed SF#3516844: poco missing symbols with external >=lipcre-8.13
+- added SF#3544720: AbstractConfigurator to support 64bit values
+- fixed SF#3522081: WinRegistryConfiguration unable to read REG_QWORD values
+- fixed SF#3563626: For Win32 set Up/Running flags on NetworkInterface
+- fixed SF#3560807: Deprecate setPeerAddress() as this is now done in getifaddrs
+- fixed SF#3560776: Fix byte-ordering issues with INADDR_* literals
+- fixed SF#3563627: Set IP address on multicast socket from socket family
+- fixed SF#3563999: Size BinaryWriter based on buffer's capacity(), not size()
+- fixed SF#102 Fix building Poco on Debian GNU/kFreeBSD
+- fixed SF#321 Binding DatTime or Timestamp
+- fixed SF#307 Detect the SQL driver type at run time
+- added VS 2012 Projects/Solutions
+- enhanced and accelerated numeric parsing for integers and floats
+- fixed SF#590 Segfault on FreeBSD when stack size not rounded
+- added warn function and warnmsg macro in CppUnit
+- fixed SF# 3558012 Compilation fails when building with -ansi or -std=c++0x
+- fixed SF# 3563517 Get rid of loss-of-precision warnings on x64 MacOS
+- fixed SF#3562244: Portability fix for AF_LINK
+- fixed SF #3562400: DatagramSocketImpl comment is incorrect
+
+
+Release 1.4.7p1 (2014-11-25)
+============================
+
+- Fixed Visual C++ 2010-2013 project files. Release builds now have optimization enabled.
+- Poco::URI: added constructor to create URI from Path.
+- fixed GH #618: OS X 10.10 defines PAGE_SIZE macro, conflicts with PAGE_SIZE in Thread_POSIX.cpp
+- Poco::Net::HTTPClientSession: added support for global proxy configuration
+- fixed GH #331: Poco::Zip does not support files with .. in the name.
+- fixed a memory leak in Poco::Net::Context constructor when it fails to load the certificate
+  or private key files.
+- upgraded bundled SQLite to 3.8.7.2
+- fixed GH #229: added missing value() function
+- fixed GH #69: MySQL empty text/blob
+
+
+Release 1.4.7 (2014-10-06)
+==========================
+
+- fixed GH #398: PropertyFileConfiguration: input != output
+- fixed GH #368: Build failure of Poco 1.4.6p2 on FreeBSD 9.2
+- fixed GH #318: Logger local time doesn't automatically account for DST
+- fixed GH #317: Poco::Zip does not support newer Zip file versions.
+- fixed GH #454: Fix: handle unhandled exceptions
+- fixed GH #463: XML does not compile with XML_UNICODE_WCHAR_T
+- fixed GH #282: Using Thread in a global can cause crash on Windows
+- fixed GH #424: Poco::Timer deadlock
+- fixed GH #465: Fix result enum type XML_Error -> XML_Status
+- fixed GH #510: Incorrect RSAKey construction from istream
+- fixed GH #332: POCO::ConsoleChannnel::initColors() assigns no color to
+  PRIO_TRACE and wrong color to PRIO_FATAL
+- fixed GH #550: WebSocket fragmented message problem
+- Poco::Data::MySQL: added SQLite thread cleanup handler
+- Poco::Net::X509Certificate: improved and fixed domain name verification for
+  wildcard domains
+- fixed a crash in Foundation testsuite with Visual C++ 2012
+- improved and fixed domain name verification for wildcard domains in
+  Poco::Net::X509Certificate
+- updated TwitterClient sample to use new 1.1 API and OAuth
+- added Poco::Clock class, which uses a system-provided monotonic clock
+  (if available) and is thus not affected by system realtime clock changes.
+  Monotonic Clock is available on Windows, Linux, OS X and on POSIX platforms
+  supporting clock_gettime() and CLOCK_MONOTONIC.
+- Poco::Timer, Poco::Stopwatch, Poco::TimedNotificationQueue and Poco::Util::Timer
+  have been changed to use Poco::Clock instead of Poco::Timestamp and are now
+  unaffected by system realtime clock changes.
+- added Poco::PBKDF2Engine class template
+- Poco::Net::HTTPCookie: added support for Priority attribute (backport from develop)
+- fixed makedepend.* scripts to work in paths containing '.o*'
+  (contributed by Per-Erik Bjorkstad, Hakan Bengtsen)
+- Upgraded bundled SQLite to 3.8.6
+- Support for Windows Embedded Compact 2013 (Visual Studio 2012)
+- Project and solution files for Visual Studio 2013
+- Changes for C++11 compatibility.
+- fixed an issue with receiving empty web socket frames (such as ping)
+- improved error handling in secure socket classes
+- Poco::ByteOrder now uses intrinsics if available
+- added new text encoding classes: Latin2Encoding, Windows1250Encoding, Windows1251Encoding
+- Zip: Added CM_AUTO, which automatically selects CM_STORE or CM_DEFLATE based on file extension.
+  Used to avoid double-compression of already compressed file formats such as images.
+
+
+Release 1.4.6p4 (2014-04-18)
+============================
+
+- no longer use reverse DNS lookups for cert hostname validation
+- cert hostname validation is case insensitive and more strict
+- HTMLForm: in URL encoding, percent-encode more special characters
+- fixed thread priority issues on POSIX platforms with non-standard scheduling policy
+- XMLWriter no longer escapes apostrophe character
+- fixed GH #316: Poco::DateTimeFormatter::append() gives wrong result for Poco::LocalDateTime
+- fixed GH #305 (memcpy in Poco::Buffer uses wrong size if type != char)
+- Zip: fixed a crash caused by an I/O error (e.g., full disk) while creating a Zip archive
+
+
+Release 1.4.6p3 (2014-04-02)
+============================
+
+- Fixed a potential security vulnerability in client-side X509
+  certificate verification.
+
+
+Release 1.4.6p2 (2013-09-16)
+============================
+
+- fixed GH #156: Possible buffer overrun in Foundation/EventLogChannel
+- XML: fixed an issue with parsing a memory buffer > 2 GB
+- upgraded to expat 2.1.0
+- Data/ODBC: added support for setting query timeout (via setProperty
+  of "queryTimeout"). Timeout is int, given in seconds.
+- fixed a potential endless loop in SecureStreamSocketImpl::sendBytes()
+  and also removed unnecessary code.
+- fixed GH #159: Crash in openssl CRYPTO_thread_id() after library libPocoCrypto.so
+  has been unloaded.
+- fixed GH #155: MailOutputStream mangles consecutive newline sequences
+- fixed GH# 139: FileChannel::PROP_FLUSH is invalid (contains a tab character)
+- fixed GH# 173: HTTPClientSession::proxyConnect forces DNS lookup of host names
+- fixed GH# 194: MessageNotification constructor is inefficient.
+- fixed GH# 189: Poco::NumberParser::tryParse() documentation bug
+- fixed GH# 172: IPv6 Host field is stripped of Brackets in HTTPClientSession
+- fixed GH# 188: Net: SocketAddress operator < unusable for std::map key
+- fixed GH# 128: DOMWriter incorrectly adds SYSTEM keyword to DTD if PUBLIC is
+  already specified
+- fixed GH# 65: Poco::format() misorders sign and padding specifiers
+- upgraded bundled SQLite to 3.7.17
+- upgraded bundled zlib to 1.2.8
+- fixed a potential memory leak in Poco::Net::HTTPClientSession if it is misused
+  (e.g., sendRequest() is sent two times in a row without an intermediate call to
+  receiveResponse(), or by calling receiveResponse() two times in a row without
+  an intermediate call to sendRequest()) - GH #217
+- removed a few unnecessary protected accessor methods from Poco::Net::HTTPClientSession
+  that would provide inappropriate access to internal state
+- fixed GH# 223 (Poco::Net::HTTPCookie does not support expiry times in the past)
+- fixed GH# 233: ServerSocket::bind6(Poco::UInt16 port, bool reuseAddress, bool ipV6Only)
+  does not work
+- added ColorConsoleChannel and WindowsColorConsoleChannel classes supporting
+  colorizing log messages
+- fixed GH# 259: Poco::EventLogChannel fails to find 64bit Poco Foundation dll
+- fixed GH# 254: UTF8::icompare unexpected behavior
+- Poco::UUID::tryParse() also accepts UUIDs without hyphens. Also updated documentation
+  (links to specifications).
+- Added support for ARM64 architecture and iPhone 5s 64-bit builds
+  (POCO_TARGET_OSARCH=arm64).
+
+
+Release 1.4.6p1 (2013-03-06)
+============================
+
+- fixed GH# 71: WebSocket and broken Timeouts (POCO_BROKEN_TIMEOUTS)
+- fixed an ambiguity error with VC++ 2010 in Data/MySQL testsuite
+- Poco::Net::NetworkInterface now provides the interface index even for IPv4
+- added DNS::reload() as a wrapper for res_init().
+- On Linux, Poco::Environment::nodeId() first always tries to obtain the
+  MAC address of eth0, before looking for other interfaces.
+- Poco::Net::HTTPSession now always resets the buffer in connect() to clear
+  any leftover data from a (failed) previous session
+- fixed copysign namespace issue in FPEnvironment_DUMMY.h
+- fixed a warning in Poco/Crypto/OpenSSLInitializer.h
+- added a build configuration for BeagleBoard/Angstrom
+- fixed GH# 109: Bug in Poco::Net::SMTPClientSession::loginUsingPlain)
+- fixed compile errors with clang -std=c++11
+- fixed GH# 116: Wrong timezone parsing in DateTimeParse (fix by Matej Knopp)
+- updated bundled SQLite to 3.7.15.2
+
+
+Release 1.4.6 (2013-01-10)
+==========================
+
+- changed FPEnvironment_DUMMY.h to include <cmath> instead of <math.h>
+- updated bundled SQLite to 3.7.15.1
+- fixed GH# 30: Poco::Path::home() throws
+- fixed SF Patch# 120 The ExpireLRUCache does not compile with a tuple as key on VS2010
+- fixed SF# 603 count() is missing in HashMap
+- Crypto and NetSSL_OpenSSL project files now use OpenSSL *MD.lib library files for
+  static_md builds. Previously, the DLL import libs were used.
+- Poco::Environment::osDisplayName() now recognizes Windows 8/Server 2012
+
+
+Release 1.4.5 (2012-11-19)
+==========================
+
+- added Visual Studio 2012 project files
+- buildwin.cmd now support building with msbuild for VS2010 and 2012.
+- added Poco::Optional class
+- fixed SF# 3558012 Compilation fails when building with -ansi or -std=c++0x
+- fixed SF# 3563517 Get rid of loss-of-precision warnings on x64 MacOS
+- fixed SF# 3562244: Portability fix for AF_LINK
+- fixed SF# 3562400: DatagramSocketImpl comment
+- fixed SF# 594: Websocket fails with small masked payloads
+- fixed SF# 588: Missing POCO_ARCH and POCO_ARCH_LITTLE_ENDIAN define for WinCE on SH4
+- fixed SF# 581: Out-of-bound array access in Unicode::properties() function.
+- fixed SF# 590: Segfault on FreeBSD when stack size not rounded
+- fixed SF# 586: Poco::DateTimeParser and ISO8601 issues when seconds fraction has more than 6 digits
+- Poco::Net::HTTPSSessionInstantiator::registerInstantiator() now optionally accepts a
+  Poco::Net::Context object.
+- added Poco::XML::XMLWriter::depth() member function.
+- added Poco::XML::XMLWriter::uniquePrefix() and Poco::XML::XMLWriter::isNamespaceMapped().
+- Poco::FileChannel now supports a new rotateOnOpen property (true/false) which can be used
+  to force rotation of the log file when it's opened.
+- fixed a bug in Poco::XML::XMLWriter::emptyElement(): need to pop namespace context
+- OS X builds now use Clang as default compiler
+- Updated SQLite to 3.7.14.1
+- POCO_SERVER_MAIN macro now has a try ... catch block for Poco::Exception and writes
+  the displayText to stderr.
+- Poco/Platform.h now defines POCO_LOCAL_STATIC_INIT_IS_THREADSAFE macro if the compiler
+  generates thread-safe static local initialization code.
+
+
+Release 1.4.4 (2012-09-03)
+==========================
+
+- ZipStream now builds correctly in unbundled build.
+- added proxy digest authentication support to Net library
+- integrated MySQL BLOB fixes from Franky Braem.
+- use standard OpenSSL import libraries (libeay32.lib, ssleay32.lib) for Crypto and
+  NetSSL_OpenSSL Visual Studio project files.
+- fixed a potential buffer corruption issue in Poco::Net::SecureStreamSocket if lazy
+  handshake is enabled and the first attempt to complete the handshake fails
+- Poco::DateTimeParser::tryParse() without format specifier now correctly parses ISO8601
+  date/times with fractional seconds.
+- Poco::Process::launch() now has additional overloads allowing to specify an initial
+  directory and/or environment.
+- Poco::Net::FTPClientSession: timeout was not applied to data connection, only to
+  control connection.
+- Fixed potential IPv6 issue with socket constructors if IPv6 SocketAddress is given
+  (contributed by ??????? ????????? <milovidov@yandex-team.ru>).
+- Added an additional (optional) parameter to Poco::Thread::setOSPriority() allowing to
+  specify a scheduling policy. Currently this is only used on POSIX platforms and allows
+  specifying SCHED_OTHER (default), SCHED_FIFO or SCHED_RR, as well as other
+  platform-specific policy values.
+- Added Poco::Crypto::DigestEngine class providing a Poco::DigestEngine interface to
+  the digest algorithms provided by OpenSSL.
+- Fixed some potential compiler warnings in Crypto library
+- In some cases, when an SSL exception was unexpectedly closed, a generic Poco::IOException
+  was thrown. This was fixed to throw a SSLConnectionUnexpectedlyClosedException instead.
+- Added Poco::ObjectPool class template.
+- Poco::Net::HTTPServer has a new stopAll() method allowing stopping/aborting of all
+  currently active client connections.
+- The HTTP server framework now actively prevents sending a message body in the
+  response to a HEAD request, or in case of a 204 No Content or 304 Not Modified
+  response status.
+- fixed a DOM parser performance bug (patch by Peter Klotz)
+- fixed SF# 3559325: Util Windows broken in non-Unicode
+- updated iOS build configuration to use xcode-select for finding toolchain
+- Poco::Net::SecureSocketImpl::shutdown() now also shuts down the underlying socket.
+- fixed SF# 3552597: Crypto  des-ecb error
+- fixed SF# 3550553: SecureSocketImpl::connect hangs
+- fixed SF# 3543047: Poco::Timer bug for long startInterval/periodic interval
+- fixed SF# 3539695: Thread attributes should be destroyed using the pthread_attr_destroy()
+- fixed SF# 3532311: Not able to set socket option on ServerSocket before bind
+  Added Poco::Net::Socket::init(int af) which can be used to explicitely
+  initialize the underlying socket before calling bind(), connect(), etc.
+- fixed SF# 3521347: Typo in UnWindows.h undef
+- fixed SF# 3519474: WinRegistryConfiguration bug
+  Also added tests and fixed another potential issue with an empty root path passed to the constructor.
+- fixed SF# 3516827: wrong return value of WinRegistryKey::exists()
+- fixed SF# 3515284: RSA publickey format(X.509 SubjectPublicKeyInfo)
+- fixed SF# 3503267: VxWorks OS prio is not set in standard constructor
+- fixed SF# 3500438: HTTPResponse failure when reason is empty
+- fixed SF# 3495656: numberformater, numberparser error in mingw
+- fixed SF# 3496493: Reference counting broken in TaskManager postNotification
+- fixed SF# 3483174: LogFile flushing behavior on Windows
+  Flushing is now configurable for FileChannel and SimpleFileChannel
+  using the "flush" property (true or false).
+- fixed SF# 3479561: Subsequent IPs on a NIC is not enumerated
+- fixed SF# 3478665: Permission checks in Poco::File not correct for root
+- fixed SF# 3475050: Threading bug in initializeNetwork() on Windows
+- fixed SF# 3552680: websocket small frames bug and proposed fix
+- fixed a WebSocket interop issue with Firefox
+- added Poco::Net::MessageHeader::hasToken()
+- Poco::AtomicCounter now uses GCC 4.3 builtin atomics on more platforms
+- fixed SF# 3555938: NetSSL: socket closed twice
+- socket exceptions now include OS error code
+- fixed SF# 3556975: Need to fix Shared Memory for memory map
+- Poco::Net::SecureSocketImpl::close() now catches exceptions thrown by its call to shutdown().
+- fixed SF# 3535990: POCO_HAVE_IPv6 without POCO_WIN32_UTF8 conflict
+- fixed SF# 3559665: Poco::InflatingInputStream may not always inflate completely
+- added Poco::DirectoryWatcher class
+- fixed SF# 3561464: Poco::File::isDevice() can throw due to sharing violation
+- Poco::Zip::Compress::addRecursive() has a second variant that allows to specify the compression method.
+- Upgraded internal SQLite to 3.7.14
+
+
+Release 1.4.3p1 (2012-01-23)
+============================
+
+- fixed SF# 3476926: RegDeleteKeyEx not available on Windows XP 32-bit
+
+
+Release 1.4.3 (2012-01-16)
+==========================
+
+- fixed a compilation error with Data/MySQL on QNX.
+- fixed Util project files for WinCE (removed sources not compileable on CE)
+- removed MD2 license text from Ackowledgements document
+- fixed iPhone build config for Xcode 4.2 (compiler name changed to llvm-g++)
+- Poco::Util::XMLConfiguration: delimiter char (default '.') is now configurable.
+  This allows for working with XML documents having element names with '.' in them.
+- Poco::Util::OptionProcessor: Required option arguments can now be specified as
+  separate command line arguments, as in "--option value" in addition to the
+  "--option=value" format.
+- Poco::Util::HelpFormatter: improved option help formatting if  indentation has
+  been set explicitely.
+- added Mail sample to NetSSL_OpenSSL, showing use of Poco::Net::SecureSMTPClientSession.
+- added additional read() overloads to Poco::Net::HTMLForm.
+- fixed SF# 3440769: Poco::Net::HTTPResponse doesn't like Amazon EC2 cookies.
+- added support for requiring TLSv1 to Poco::Net::Context.
+- added an additional constructor to Poco::Net::HTTPBasicCredentials, allowing
+  the object to be created from a string containing a base64-encoded, colon-separated
+  username and password.
+- Poco::Zip::ZipStreamBuf: fixed a crash if CM_STORE was used.
+- Added setContentLength64() and getContentLength64() to Poco::Net::HTTPMessage.
+- added Poco::Environment::osDisplayName().
+- fixed SF# 3463096: WinService leaves dangling handles (open() now does not reopen the
+  service handle if it's already open)
+- fixed SF# 3426537: WinRegistryConfiguration can't read virtualized keys
+- added Poco::Buffer::resize()
+- fixed SF# 3441822: thread safety issue in HTTPClientSession:
+  always use getaddrinfo() instead of gethostbyname() on all platforms supporting it
+- added version resource to POCO DLLs
+- fixed SF# 3440599: Dir Path in Quotes in PATH cause PathTest::testFind to fail.
+- fixed SF# 3406030: Glob::collect problem
+- added Poco::Util::AbstractConfiguration::enableEvents()
+- Poco::AtomicCounter now uses GCC builtins with GCC 4.1 or newer
+  (contributed by Alexey Milovidov)
+- made Poco::Logger::formatDump() public as it may be useful for others as well
+  (SF# 3453446)
+- Poco::Net::DialogSocket now has a proper copy constructor (SF# 3414602)
+- Poco::Net::MessageHeader and Poco::Net::HTMLForm now limit the maximum number of
+  fields parsed from a message to prevent certain kinds of denial-of-service
+  attacks. The field limit can be changed with the new method setFieldLimit().
+  The default limit is 100.
+- Poco::NumberFormatter, Poco::NumberParser and Poco::format() now always use the
+  classic ("C") locale to format and parse floating-point numbers.
+- added Poco::StreamCopier::copyStream64(), Poco::StreamCopier::copyStreamUnbuffered64()
+  and Poco::StreamCopier::copyToString64(). These functions use a 64-bit integer
+  to count the number of bytes copied.
+- upgraded internal zlib to 1.2.5
+- upgraded internal sqlite to 3.7.9
+- XML: integrated bugfix for Expat bug# 2958794 (memory leak in poolGrow)
+- Added support for HTTP Digest authentication (based on a contribution by
+  Anton V. Yabchinskiy (arn at bestmx dot ru)). For information on how
+  to use this, see the Poco::Net::HTTPCredentials, Poco::Net::HTTPDigestCredentials
+  and Poco::Net::HTTPAuthenticationParams classes.
+- Poco::Net::HTTPStreamFactory and Poco::Net::HTTPSStreamFactory now support Basic
+  and Digest authentication. Username and password must be provided in the URI.
+- added Poco::Net::WebSocket, supporting the WebSocket protocol as described in RFC 6455
+- NetSSL_OpenSSL: added client-side support for Server Name Indication.
+  Poco::Net::SecureSocketImpl::connectSSL() now calls SSL_set_tlsext_host_name()
+  if its available (OpenSSL 9.8.6f and later).
+- added Poco::Net::HTTPClientSession::proxyConnect() (factored out from
+  Poco::Net::HTTPSClientSession::connect())
+- added Poco::Process::kill(const Poco::ProcessHandle&) which is preferable to
+  kill(pid) on Windows, as process IDs on Windows may be reused.
+- fixed SF# 3471463: Compiler warnings with -Wformat
+- Poco::Util::Application::run() now catches and logs exceptions thrown in initialize()
+- Fixed a WinCE-specific bug in Poco::Util::ServerApplication where uninitialize() would
+  be called twice.
+- fixed SF# 3471957: WinRegistryKey::deleteKey() unable to delete alt views
+- Added additional constructor to Poco::ScopedLock and Poco::ScopedLockWithUnlock
+  accepting a timeout as second argument.
+- Added Poco::Logger::parseLevel()
+- Poco::format(): an argument that does not match the format
+  specifier no longer results in a BadCastException. The string [ERRFMT] is
+  written to the result string instead.
+- PageCompiler: added createSession page attribute.
+
+
+Release 1.4.2p1 (2011-09-24)
+============================
+
+- On Linux, the RTLD_DEEPBIND option is no longer passed to dlopen().
+  This change was introduced in 1.4.2 to solve a specific problem one customer
+  was having. Unfortunately, it leads to problems with RTTI.
+- It's now possible to pass flags (SHLIB_GLOBAL, SHLIB_LOCAL) to
+  Poco::SharedLibrary::load() (and the constructor implicitly calling load()),
+  controlling the mode flags (RTLD_GLOBAL, RTLD_LOCAL) passed to dlopen().
+  On platforms not using dlopen(), these flags are ignored.
+- fixed SF# 3400267: Path_WIN32.cpp bug
+
+
+Release 1.4.2 (2011-08-28)
+==========================
+
+- added Poco::DateTimeFormat::ISO8601_FRAC_FORMAT
+- added new Poco::DateTimeFormatter and Poco::DateTimeParser format specifier:
+  %s for seconds with optional fractions of a second
+- fixed a problem with ioctl() on BSD platforms (including OS X) where the
+  second argument to ioctl() is unsigned long instead of int, causing bad
+  things on a OS X 64-bit kernel.
+- fixed a potential endless loop when enumerating IPv6 network addresses
+  (reported by Laurent Carcagno)
+- new compile-time config option on Windows to set thread names in
+  debugger. Enable with -DPOCO_WIN32_DEBUGGER_THREAD_NAMES. Available
+  only in debug builds.
+- Cipher can now create Base64 and HexBinary encoded output without linefeeds
+  (suitable for use in cookies, etc.)
+- added Poco::Path::popFrontDirectory()
+- improved VxWorks support
+- IPv6 fixes: added proper scope id handling in IPAddress, SocketAddress
+  and related classes.
+- Added Poco::Net::ServerSocket::bind6() which allows control over the
+  IPPROTO_IPV6/IPV6_V6ONLY socket option.
+- Removed Poco::MD2Engine class due to licensing issues (the
+  license for the MD2 code from RSA only allows non-commercial
+  use). Note that the MD4 and MD5 code from RSA does not have
+  this issue.
+- fixed a Net HTTP client testsuite issue where some tests might
+  have failed due to prematurely aborted connections by
+  the HTTPTestServer.
+- Poco::Net::SocketAddress: when there is more than one address
+  returned by a DNS lookup for a name, IPv4 addresses will be
+  preferred to IPv6 ones.
+- NetworkInterface::list() now also returns IPv4 interfaces on Windows when
+  built with -DPOCO_HAVE_IPv6
+- XMLWriter: fixed a bug with attribute namespaces (no namespace prefix
+  written if attribute namespace is the same as element namespace)
+- fixed SF# 3378588: Mismatched new[]/delete (in RSAEncryptImpl and RSADecryptImpl)
+- fixed SF# 3212954 (OpenSSLInitializer::uninitialize() crash) and
+  SF# 3196862 (Static OpenSSLInitializer instance causes Windows deadlocks) by
+  removing the static Poco::Crypto::OpenSSLInitializer instance. Automatic OpenSSL
+  initialization is now done through Poco::Crypto::Cipher, Poco::Crypto::CipherKey,
+  Poco::Crypto::X509Certificate, Poco::Net::Context classes; however, it is still
+  recommended to call Poco::Crypto::initializeCrypto() and
+  Poco::Crypto::uninitializeCrypto() early at application startup, and late at
+  shutdown respectively (or Poco::Net::initializeSSL()/Poco::Net::uninitializeSSL()
+  if the NetSSL library is used) to avoid multiple full OpenSSL init/uninit cycles
+  during application runtime.
+- Poco::Logger now also support a symbolic log level "none"
+  (for use with setLevel()) that disables logging completely
+  for that Logger (equivalent to setLevel(0)).
+- Added experimental Android support, using the existing gmake-based
+  build system.
+- fixed SF# 3288584: DateTimeFormatter link error
+- fixed SF# 3187117: Typo in InflatingInputStream doc
+- fixed SF# 3309731: _WIN32_WCE comparison should be with 0x600 not 600
+- fixed SF# 3393026: RegularExpression.h identical enum value
+- fixed SF# 3274222: AtomicCounter's postfix operators aren't atomic on Windows
+- fixed SF# 3317177: Handle leak on windows
+- fixed SF# 3181882: Poco::URI::getPathEtc() double-encodes query
+- fixed SF# 3379935: ThreadPool Start Bug
+- fixed SF# 3354451: Poco::Format::parsePrec never sets the precision to zero
+- fixed SF# 3387258: _MAX_PATH used but unknown in Path_WIN32
+- fixed a problem in RSAKeyImpl where direct access to the RSA in a EVP_PKEY
+  would no longer work in recent OpenSSL versions. Using EVP_PKEY_get1_RSA()
+  fixes the issue.
+- added Poco::Crypto::EncryptingInputStream, Poco::Crypto::EncryptingOutputStream,
+  Poco::Crypto::DecryptingInputStream and Poco::Crypto::DecryptingOutputStream.
+- fixed SF# 3148126: HTTPSClientSession destructor (!) throws an IOException
+- fixed SF# 3178098: Add constructor to Poco::TemporaryFile to specify directory
+- fixed SF# 3175310: Absolute path when device
+- fixed SF# 3301207: Guided tour example contradicts apidoc (API doc was wrong)
+- Poco::Net::HTTPMessage::setContentLength() and Poco::Net::HTTPMessage::getContentLength() now
+  use std::streamsize instead of int. This enables 64-bit Content-Length support at least
+  on 64-bit platforms.
+- fixed SF# 3177530: TemporaryFile::tempName() + glob bug on xp
+- fixed SF# 3177372: FileChannel documentation inconsistency
+- added %E format specifier to Poco::PattermFormatter (epoch time in seconds
+  since midnight, January 1 1970)
+- On Windows, Poco::Util::ServerApplication now supports a /description command
+  line argument for specifying a service description (together with /registerService)
+- added Poco::Util::WinService::setDescription() and
+  Poco::Util::WinService::getDescription()
+- fixed SF# 3155477: Incorrect URI path handling
+- fixed SF# 3309736: Extended Exception macros to set default exception code
+  new macro is named POCO_DECLARE_EXCEPTION_CODE
+- added getter functions for modulus and exponents to Poco::Crypto::RSAKey.
+- added Poco::Net::SocketAddress::operator == () and
+  Poco::Net::SocketAddress::operator != ()
+- fixed SF# 3182746: IPAddress.cpp IPv6 bug on big-endian
+- fixed SF# 3196961: Unix daemon fails to loadConfiguration() if started from cwd
+- fixed SF# 3393700: NotificationCenter may call a removed observer and crash.
+- Reworked implementation of the events framework (Poco::BasicEvent and friends).
+  The framework is now completely multithreading save (even in the case that
+  an event subscriber object unsubscribes and is deleted while an event is
+  being dispatched). Also, the restriction that any object can only register
+  one delegate for each event has been removed. For most cases, dispatching
+  events should be faster, as dispatching an event now needs less dynamic memory
+  allocations.
+- fixed SF# 3178109: getNodeByPath() changes:
+  getNodeByPath() and getNodeByPathNS() have been moved to Poco::XML::Node.
+  Furthermore, when invoked on a Poco::XML::Document, the behavior has changed
+  so that the document element is now included when traversing the path (previously,
+  traversal would start at the document element, now it starts at the document).
+  The path expression can now start with a double-slash, which results in a recursive
+  search for the path's first element in the DOM tree.
+- fixed SF# 3382935: String data being truncated using ODBC, and
+  SF# 2921813: Wrong implementation of the ODBC string binding
+
+
+Release 1.4.1p1 (2011-02-08)
+============================
+
+- Poco::Mutex is now a recursive mutex again on Linux
+  (this was caused by an unfortunate feature test for
+  PTHREAD_MUTEX_RECURSIVE which did not work on Linux
+  as PTHREAD_MUTEX_RECURSIVE is an enum value and not
+  a macro)
+- Poco::Net::SecureSocketImpl::abort() now only shuts
+  down the underlying socket connection and does not free
+  the SSL object, due to multithreading issues.
+
+
+Release 1.4.1 (2011-01-29)
+==========================
+
+- fixed SF# 3150223: Poco::BinaryReader cannot read std::vector correctly
+- fixed SF# 3146326: SharedMemory issue
+- made Poco::Net::HTTPSession::abort() virtual
+- added Poco::Net::SecureStreamSocket::abort() to immediately close
+  a SSL/TLS connection without performing an orderly SSL/TLS shutdown.
+- fixed SF# 3148126: HTTPSClientSession destructor (!) throws an IOException.
+  Added try/catch block to Poco::Net::SecureSocketImpl destructor.
+- added additional constructor to Poco::Net::HTTPSClientSession, taking
+  both a socket and a session object.
+- Poco::Net::HTTPSession::abort() now also can be used with a
+  Poco::Net::HTTPSClientSession.
+- fixed SF# 3148045: make clean and distclean issues
+- changed Data library names on Unix/Linux platforms to
+  match the names on Windows (PocoSQLite -> PocoDataSQLite,
+  PocoMySQL -> PocoDataMySQL, PocoODBC -> PocoDataODBC)
+- added additional options to configure script
+- added additional documentation to Poco::Net::HTTPClientSession
+- Poco::Net::HTTPClientSession::receiveResponse() closes the connection
+  if an exception is thrown while reading the response header.
+  This ensures that a new connection will be set up for the next request
+  if persistent connections are used.
+- improved Poco::Net::MultipartDecoder performance by reading directly from streambuf
+- improved performance of Poco::Base64Encoder, Poco::Base64Decoder,
+  Poco::HexBinaryEncoder and Poco::HexBinaryDecoder by working directly with the
+  given stream's streambuf.
+- improved performance of MessageHeader::read() by reading directly from streambuf
+  instead of istream.
+- it is now possible to specify additional MIME part header fields
+  for a MIME part through the Poco::Net::PartSource class.
+- upgraded SQLite to release 3.7.4
+- added experimental VxWorks support for VxWorks 5.5.1/Tornado 2.2 and
+  newer. Please see the VxWorks Platform Notes in the reference documentation
+  for more information. Currently, the VxWorks is untested; full support
+  will be available in release 1.4.2.
+- fixed SF# 3165918: Poco::DynamicAny fails to convert from string to float
+- fixed SF# 3165910: Poco::Net::MessageHeader does not accept HTTP conforming header
+- made Poco::Task::cancel() virtual so that tasks can implement custom
+  cancellation behavior.
+- added optional argument to Poco::Util::WinRegistryKey constructor
+  to specify additional flags (in addition to KEY_READ and KEY_WRITE)
+  for the samDesired argument of RegOpenKeyEx() or RegCreateKeyEx().
+- improved Poco::BasicEvent::notify() performance by avoiding an unnecessary heap
+  allocation.
+- added additional well-known port numbers to Poco::URI: rtsp, sip, sips, xmpp.
+- added Poco::Net::MediaType::matchesRange()
+- improved invalid socket handling: a Poco::Net::InvalidSocketException is
+  now thrown instead of an assertion when an operation is attempted on a closed or
+  otherwise uninitialized socket.
+
+
+Release 1.4.0 (2010-12-14)
+==========================
+
+- SSLManager: documentation fixes, code cleanup
+- SSLManager: renamed PrivateKeyPassPhrase event to PrivateKeyPassphraseRequired
+- added HTTPServerRequestImpl::socket() to get access to the underlying socket
+- added Socket::secure() to find out whether a given socket supports SSL/TLS
+- added SecureStreamSocket::havePeerCertificate()
+- NetSSL: added support for turning off extended certificate validation (hostname matching)
+- fixed SF# 2941228: ICMPClient::ping() issues on Mac OS X
+- fixed SF# 2941231: ICMPEventArgs out of bounds array access
+- added PageCompiler sample
+- added missing newline at end of xmlparse.c
+- Poco::Glob can now be used with an empty pattern which will match nothing (patch from Kim Graesman)
+- added support for HTTP proxy authentication (Basic authentication only)
+- fixed SF# 2958959: XMLWriter must encode CR, LF and TAB in attribute values as character entities.
+- HTMLForm now supports PUT requests as well (see <http://pocoproject.org/forum/viewtopic.php?f=12&t=2163&p=3930#p3930>)
+- fixed SF# #2970521: FileOutputStream and file permissions.
+  (also fixed in File class)
+- removed an unused (and wrong) default parameter from EventImpl constructor for WIN32.
+- added full support for session caching to NetSSL_OpenSSL
+- fixed SF# 2984454: Poco::Util::Timer::scheduleAtFixedRate() works incorrectly
+- fixed a bug in Poco::Util::Timer that could lead to high CPU load if
+  the system clock is moved forward.
+- added system.nodeId to SystemConfiguration
+- added a note to Poco::Util::ServerApplication documentation regarding
+  creation of threads
+- added Poco::Net::IPAddress::broadcast() and Poco::Net::IPAddress::wildcard() to
+  create broadcast (255.255.255.255) and wildcard (0.0.0.0) addresses.
+- fixed SF# 2916154: Poco::Net::IPAddress::isLoopback() only works for 127.0.0.1.
+- added build configuration for iPhone Simulator
+- GNU Make based build system provides new variables: POCO_HOST_BINDIR, POCO_HOST_BINPATH,
+  POCO_HOST_LIBDIR, POCO_HOST_LIBPATH and POCO_TARGET_* equivalents.
+- Application::initialize() and Application::uninitialize() will now be called from within run().
+  This solves various issues with uninitialize() not being called, or being called inappropriately
+  from the Application destructor.
+  Please note that this change will break applications that use the Application class,
+  but only call init() and not run().
+- added /startup option to specify startup mode for Windows services (automatic or manual)
+- fixed SF# 2967354: SecureSocketImpl shutdown/close problem
+- fixed SF# 3006340: LinearHashTable grows even if key already exists
+- fixed a particularly nasty Windows error handling issue that manifested itself on WinCE:
+  WSAGetLastError() would be called after a std::string was created. The string creation could result
+  in a heap operation which called a Windows API to allocate memory. This would reset the
+  GetLastError() error code. Since WSAGetLastError() is just an alias for GetLastError(), the actual
+  error code from the socket operation would be lost.
+- upgraded SQLite to 3.7.3
+- added --header-prefix option to PageCompiler
+- fixed SF# 3003875: SQLite data binding is broken
+- fixed SF# 2993988: Issue with multiple calls to open()/close() on File*Stream
+- fixed SF# 2990256: HTMLForm and file uploads
+- fixed SF# 2969227: DateTimeParser bug
+- fixed SF# 2966698: Socket connect with timeout issue
+- fixed SF# 2981041: Bind NULL to a query (patch supplied)
+- fixed SF# 2961419: UTF8Encoding::convert() doesn't work properly in DEBUG mode
+- fixed SF# 2957068: Timeout value not picked up by proxy in HTTPSClientSession
+- fixed NetSSL_OpenSSL test runner for Poco::Util::Application class changes
+- Poco::AbstractEvent, Poco::AbstractCache and related classes now accept a Mutex class as additional template argument.
+  Poco::NullMutex can be used if no synchronization is desired.
+- Added Poco::AbstractEvent::empty() to check whether an event has registered delegates.
+- Poco::URI now correctly handles IPv6 addresses.
+- Added Poco::Nullable class template.
+- Added Poco::NullMutex, a no-op mutex to be used as template argument for template classes
+  taking a mutex policy argument.
+- Poco::XML::XMLWriter: fixed a namespace handling issue that occured with startPrefixMapping() and endPrefixMapping()
+- Poco::Net::Context now allows for loading certificates and private keys from Poco::Crypto::X509Certificate objects
+  and Poco::Crypto::RSAKey objects.
+- Poco::Crypto::RSAKey no longer uses temporary files for stream operations. Memory buffers are used instead.
+- fixed SF# 2957865: added Poco::UUID::tryParse()
+- All Zip classes now use Poco::File[Input|Output]Stream instead of std::[i|o]fstream.
+  UTF-8 filenames will now be handled correctly on Windows.
+- fixed SF# 2902029: zlib flush support (Z_SYNC_FLUSH)
+- added Poco::TextBufferIterator class
+- fixed SF# 2977249: Use epoll instead select under Linux
+  Socket::select() and Socket::poll() will use epoll under Linux if the Net library is compiled
+  with -DPOCO_HAVE_FD_EPOLL. This is the default for the Linux build configuration (but not for
+  the various build configurations targeting embedded Linux platforms).
+- fixed SF# 2941664: Memory leak in DeflatingStream with zero-length streams (also fixed some other potential,
+  but unlikely, memory leaks)
+- fixed SF# 2946457: added RejectCertificateHandler
+- fixed SF# 2946621: Poco::Path bug with POCO_WIN32_UTF8
+- fixed SF# 2929805: Environment::nodeId() does not work if no eth0 device exists
+- Environment::nodeId() no longer throws if no hardware ethernet address can be determined.
+  It returns an all-zero address instead.
+- Added additional classification functions to Poco::Unicode class; made classification functions inline.
+- added Ascii class for ASCII character classification.
+  Methods of the Ascii class are now used instead of the
+  standard library functions (std::isspace(), etc.) due to
+  possible inconsistent results or assertions when the
+  standard library functions are used with character codes
+  outside the ASCII range.
+- Poco::Net::MailMessage: fixed a bug in StringPartHandler that resulted in incorrect handling of non-ASCII data if
+  char is signed.
+- Improved Poco::Net::SMTPClientSession compatibility with various mail servers when using AUTH_LOGIN authentication.
+- Added CRAM-SHA1 support to Poco::Net::SMTPClientSession
+- Poco::Net::SMTPClientSession now also supports login with AUTH PLAIN.
+- Added Poco::Net::SecureSMTPClientSession class, supporting STARTTLS for secure SMTP connections.
+- fixed an issue with SharedMemory on POSIX systems, where a shared memory region would be deleted
+  despite the server flag set to true (see http://pocoproject.org/forum/viewtopic.php?f=12&t=3494).
+- PageCompiler: added a new page context directive, to allow passing custom context objects to the
+  request handler.
+- fixed StreamSocketImpl::sendBytes() for non-blocking sockets
+- added Poco::Net::DialogSocket::receiveRawBytes(), which should be used instead of receiveBytes() due to internal
+  buffering by DialogSocket.
+- DOMParser: FEATURE_WHITESPACE has been renamed to FEATURE_FILTER_WHITESPACE (which now matches the underlying URI)
+  and is now handled correctly (previously we did the exact reverse thing)
+- added Poco::Util::AbstractConfiguration::remove() to remove a configuration property; added removeRaw() implementations
+  to all implementations (contributions by Daniel Hobi and Alexey Shults).
+- fixed NetSSL_OpenSSL compilation error on Windows with OpenSSL 1.0
+- Added optional FIPS mode support to NetSSL_OpenSSL (contributed by Lior Okman).
+  If OpenSSL has been configured and built with FIPS support, then FIPS support can
+  be enabled by calling Poco::Crypto::OpenSSLInitializer::enableFIPSMode(true); or
+  by setting the fips property in the OpenSSL configuration to true (see Poco::Net::SSLManager
+  for details).
+- fixed SF# 3031530: Ping and possible no timeout
+- added Poco::Net::SocketReactor::onBusy(), called whenever at least one notification will
+  be dispatched.
+- fixed SF# 3034863: Compiler warning in net/IPAddress.h with poco 1.3.2
+- added support for CRAM-SHA1 authentication to SMTPClientSession
+- Poco::format(): arguments can now be addressed by their index, e.g. %[2]d
+- Poco::Util::Timer::cancel() now accepts an optional boolean argument.
+  If true is passed, cancel() waits until the task queue has been purged.
+  Otherwise, it returns immediately and works asynchronously, as before.
+- Poco::Net::HTTPServerResponse::redirect() now accepts an optional additional
+  argument to specify the HTTP status code for the redirection.
+- fixed a warning (BinaryReader.cpp) and error (ThreadLocal.cpp) in Foundation when compiling with Visual Studio 2010
+- fixed a wrong exception in Poco::Net::POP3ClientSession
+- Poco::Net::FTPClientSession and Poco::Net::SMTPClientSession now set the error code in exceptions they throw
+- fixed a potential race condition with terminating a Windows service based on Poco::Util::ServerApplication
+- fixed a bug in global build configuration file: explicitly setting POCO_CONFIG did not work on Solaris platforms,
+  as it was always overridden by the automatically determined configuration.
+- Added support for MinGW cross builds on Linux.
+- Changed location of statically linked build products in the gmake-based build system.
+  Statically linked executables are now in bin/$(OSNAME)/$(OSARCH)/static and no longer
+  have the _s suffix
+- The POCO_VERSION macro now is in its own header file, "Poco/Version.h". It is no longer
+  available through "Poco/Foundation.h".
+- added Poco::Net::HTTPCookie::escape() and Poco::Net::HTTPCookie::unescape().
+- fixed SF# 3021173: Thread (POSIX) returns uninitialised value for OS priority
+- fixed SF# 3040870: ThreadPool has no function to get assigned name
+- fixed SF# 3044303: Can't use own config file on Solaris & OSARCH_64BITS ignored
+- fixed SF# 2943896: AsyncChannel::log blocks
+- fixed a bug in Poco::Util::WinRegistryKey::getInt():
+  The size variable passed to RegQueryValueExW() should be initialized to the size
+  of the output buffer.
+- Added rudimentary support for compiling with Clang 2.0 (Xcode 4) on Mac OS X.
+- New build configurations for Mac OS X: Darwin32 and Darwin64 for explicit
+  32-bit and 64-bit builds. Note that the default Darwin build configuration
+  will build 64-bit on Snow Leopard and 32-bit on Leopard, but will always place
+  build products in Darwin/i386. The new Darwin32 and Darwin64 configurations
+  will use the correct directories.
+- fixed SF# 3051598: Bug in URL encoding
+- Poco::ThreadPool::stopAll() (and thus also the destructor) will now wait for each
+  pooled thread to terminate before returning. This fixes an issue with creating
+  and orderly shutting down a thread pool in a plugin. Previously, a pooled thread
+  in a thread pool created by a dynamically loaded library might still be running
+  when the plugin's shared library was unloaded, resulting in Bad Things happening.
+  This can now no longer happen. As a downside, a pooled thread that fails to
+  finish will block stopAll() and the destructor forever.
+- NetSSL_OpenSSL: for a SecureStreamSocket, available() now returns the number of bytes that
+  are pending in the SSL buffer (SSL_pending()), not the actual socket buffer.
+- Added Poco::Net::HTTPClientSession::secure() to check for a secure connection.
+- Poco::Net::HTTPRequest::setHost() now does not include the port number in the Host header
+  if it's either 80 or 443.
+- log messages can now optionally include source file path and line number
+- Poco::PatternFormatter can format source file path and line number (%U, %u)
+- logging macros (poco_information(), etc.) now use __LINE__ and __FILE__
+- new logging macros that incorporate Poco::format(): poco_information_f1(logger, format, arg) with up to 4 arguments
+- added Poco::Net::HTTPSession::attachSessionData() and Poco::Net::HTTPSession::sessionData()
+  to attach arbitrary data to a HTTP session.
+- added additional constructors to zlib stream classes that allow passing
+  a windowBits parameter to the underlying zlib library.
+- fixed a potential error handling issue in Poco::Net::SecureSocketImpl.
+- fixed SF# 3110272: RSACipherImpl bug.
+- fixed SF# 3081677: ConfigurationView's getRaw not retrieving xml attributes.
+- added basic support for Canonical XML and better pretty-printing support to Poco::XML::XMLWriter.
+- Poco::Util::AbstractConfiguration now supports events fired when changing or
+  removing properties.
+- XML: added support for finding DOM nodes by XPath-like
+  expressions. Only a very minimal subset of XPath is supported.
+  See Poco::XML::Element::getNodeByPath(), Poco::XML::Element::getNodeByPathNS()
+  and the same methods in Poco::XML::Document.
+- Poco::Timer: If the callback takes longer to execute than the
+  timer interval, the callback function will not be called until the next
+  proper interval. The number of skipped invocations since the last
+  invocation will be recorded and can be obtained by the callback
+  by calling skipped().
+- Poco::BinaryReader and Poco::BinaryWriter now support reading and
+  writing std::vectors of the supported basic types. Also, strings
+  can now be written in a different encoding (a Poco::TextEncoding
+  can be optionally passed to the constructor).
+- Poco::UUID::nil() and Poco::UUID::isNil() have been renamed to
+  Poco::UUID::null() and Poco::UUID::isNull(), respectively, to avoid
+  issues with Objective-C++ projects on Mac OS X and iOS where nil is
+  a system-provided macro.
+- Crypto bugfixes: RSACipherImpl now pads every block of data, not just the
+  last (or last two).
+- Improved Crypto testsuite by adding new tests
+- Added new Visual Studio project configurations: debug_static_mt and release_static_mt
+  (linking with static runtime libraries). The existing configurations debug_static
+  and release_static have been renamed to debug_static_md and release_static_md, respectively.
+  The suffixes of the static libraries have also changed. The static_md configurations
+  now build libraries with suffixes md[d], while the libraries built by the static_mt
+  configurations have mt[d] suffixes.
+- Added Visual Studio project files for 64-bit builds.
+- Added Visual Studio 2010 project files.
+- Removed the use of local static objects in various methods due to
+  their construction not being threadsafe (and thus leading to
+  potential race conditions) on Windows/Visual C++.
+- Fixed some warning on 64-bit Windows builds.
+- The name of the Data connector libraries have changed. They are now
+  named PocoDataMySQL, PocoDataODBC and PocoDataSQLite.
+- fixed SF# 3125498: Linux NetworkInterface::list() doesn't return IPv6 IPs
+- fixed SF# 3125457: IPv6 IPAddress tests are wrong
+- Added initialization functions for the NetSSL_OpenSSL and Crypto libraries.
+  These should be called instead of relying on automatic initialization,
+  implemented with static initializer objects, as this won't work with
+  statically linked executables (where the linker won't include the
+  static initializer object).
+  The functions are Poco::Crypto::initializeCrypto(), Poco::Crypto::uninitializeCrypto(),
+  Poco::Net::initializeSSL() and Poco::Net::uninitializeSSL().
+  Applications using Crypto and/or NetSSL should call these methods appropriately at
+  program startup and shutdown.
+  Note: In release 1.3.6, similar functions have been added to the Net library.
+
+
+Release 1.3.6p2 (2010-01-15)
+============================
+
+- fixed an issue in the Windows implementation Poco::RWLock, where
+  tryReadLock() sometimes would return false even if no writers
+  were using the lock (fix contributed by Bjrn Carlsson)
+- added Poco::Environment::libraryVersion().
+- fixed SF# 2919461: Context ignores parameter cypherList
+- removed an unused enum from RSACipherImpl.cpp (Crypto)
+- integrated a new expat patch for CVE-2009-3560.
+- fixed SF# 2926458: SSL Context Problem. The Poco::Net::Context
+  class now makes sure that OpenSSL is properly initialized.
+- updated iPhone build configuration (contributed by Martin York)
+- fixed SF# 1815124 (reopened): XML Compile failed on VS7.1 with
+  XML_UNICODE_WCHAR_T
+- fixed SF# 2932647: FTPClientSession::getWorkingDirectory() returns a bad result
+
+
+Release 1.3.6p1 (2009-12-21)
+============================
+
+- added support for using external zlib, pcre, expat and sqlite3 instead of
+  bundled ones (-DPOCO_UNBUNDLED, configure --unbundled)
+- fixed SF# 2911407: Add sh4 support
+- fixed SF# 2912746: RSAKey::EXP_LARGE doesn't work
+- fixed SF# 2904119: abstractstrategy uses std::set but do not includes it
+- fixed SF# 2909946: localtime NULL pointer
+- fixed SF# 2914986: potential expat DoS security issues (CVE-2009-3560 and CVE-2009-3720)
+- fixed SF# 2916305: SSL Manager crashes
+- fixed SF# 2903676: Tuple TypeHander does not handle composites.
+
+
+Release 1.3.6 (2009-11-24)
+==========================
+
+- added Environment::processorCount()
+- added POCO_VERSION macro to Poco/Foundation.h
+- fixed SF# 2807527: Poco::Timer bug for long startInterval/periodic interval
+- fixed a bug similar to SF# 2807527 in Poco::Util::Timer.
+- fixed SF# 2795395: Constructor doesn't treat the params "key" and "iv"
+- fixed SF# 2804457: DateTime::checkLimit looks wrong
+- fixed SF# 2804546: DateTimeParser requires explicit RFC1123 format
+- added ReleaseArrayPolicy to Poco::SharedPtr
+- upgraded to SQLite 3.6.20
+- fixed SF# 2782709: Missing semicolons in "Logger.h" convenience
+- fixed SF# 2526407: DefaultStrategy.h ++it instead of it++ in a loop
+- fixed SF# 2502235: Poco STLPort patch
+- fixed SF# 2186643: Data::Statement::reset() not implemented in 1.3.3
+- fixed SF# 2164227: Allow File opened read only by FileInputSteam to be writable
+- fixed SF# 2791934: use of char_traits::copy in BufferedStreamBuf::underflow
+- fixed SF# 2807750: Support additional SQL types in SQLite
+- fixed documentation bugs in Timed/PriorityNotificationQueue
+- fixed SF# 2828401: Deadlock in SocketReactor/NotificationCenter (also fixes patch# 1956490)
+  NotificationCenter now uses a std::vector internally instead of a std::list, and the mutex is
+  no longer held while notifications are sent to observers.
+- fixed SF# 2835206: File_WIN32 not checking aganist INVALID_HANDLE_VALUE
+- fixed SF# 2841812: Posix ThreadImpl::sleepImpl throws exceptions on EINTR
+- fixed SF# 2839579: simple DoS for SSL TCPServer, HTTPS server
+  No SSL handshake is performed during accept() - the handshake is delayed until
+  sendBytes(), receiveBytes() or completeHandshake() is called for the first time.
+  This also allows for better handshake and certificate validation when using
+  nonblocking connections.
+- fixed SF# 2836049: Possible handle leak in FileStream
+  If sync() fails, close() now simply set's the stream's bad bit.
+  In any case, close() closes the file handle/descriptor.
+- fixed SF# 2814451: NetSSL: receiveBytes crashes if socket is closed
+- added a workaround for Vista service network initialization issue
+  (an Windows service using the Net library running under Vista will
+  crash in the call to WSAStartup() done in NetworkInitializer).
+  Workaround is to call WSAStartup() in the application's main().
+  Automatic call to WSAStartup() in the Net library can now be disabled
+  by compiling Net with -DPOCO_NET_NO_AUTOMATIC_WSASTARTUP. Also
+  the new Poco::Net::initializeNetwork() and Poco::Net::uninitializeNetwork()
+  functions can be used to call WSAStartup() and WSACleanup(), respectively,
+  in a platform-independent way (on platforms other than Windows, these
+  functions will simply do nothing).
+- added VCexpress build script support (contributed by Jolyon Wright)
+- fixed SF# 2851052: Poco::DirectoryIterator copy constructor is broken
+- fixed SF# 2851197: IPAddress ctor throw keyword missing
+- added Poco::ProtocolException
+- PageCompiler improvements: new tags, support for buffered output, etc.
+- better error reporting in Data MySQL connector (patch #2881270 by Jan "HanzZ" Kaluza)
+- fixed SF# 1892462: FTPClient:Choose explicitely between EPSV and PASV
+- fixed SF# 2806365: Option for PageCompiler to write output to different dir
+- fixed a documentation bug (wrong sample code) in Process::launch() documentation
+- added --header-output-dir option to PageCompiler
+- fixed SF# 2849144: Zip::Decompress notifications error
+- SAXParser has a new feature: "http://www.appinf.com/features/enable-partial-reads".
+  See ParserEngine::setEnablePartialReads() for a description of what this does.
+- fixed SF# 2876179: MySQL Signed/Unsigned value bug
+- fixed SF# 2877970: possible bug in timer task
+- fixed SF# 2874104: wrong parsing empty http headers
+- fixed SF# 2860694: Incorrect return code from SecureStreamSocketImpl::sendBytes
+- fixed SF# 2849750: Possible bug with XMLWriter?
+- added MailMessage::encodeWord() to support RFC 2047 word encoded
+  mail header fields when sending out mail containing non-ASCII
+  characters.
+- fixed SF# 2890975: SMTPClientSession bug with 7BIT encoding
+- fixed an issue with retrieving the value of socket options on Windows 7.
+  Before obtaining the value of a socket, we now initialize the variable receiving the
+  socket option value to zero.
+- fixed SF# 2836141: Documentation errors
+- fixed SF# 2864232: Socket::select() does not detect closed sockets on windows
+- fixed SF# 2812143: Socket::select() should check socket descriptors...
+- fixed SF# 2801750: NetworkInterface <iface-Obj>forName returns wrong subnetMask
+- fixed SF# 2816315: Problem with POSIX Thread::sleepImpl
+- fixed SF# 2795646: IPv6 address parsing bug
+- fixed #0000092: ServerApplication::waitForTerminationRequest(), SIGINT and GDB.
+  Poco::Util::ServerApplication::waitForTerminationRequest() no longer registers a
+  signal handler for SIGINT if the environment variable POCO_ENABLE_DEBUGGER
+  is defined.
+- fixed SF# 2896070: Poco::Net::Context with non-ASCII paths
+- added Unicode Surrogate support to Poco::UTF16Encoding.
+  See Poco::TextEncoding::queryConvert() and Poco::TextEncoding::sequenceLength()
+  for how this is implemented. Contributed by Philippe Cuvillier.
+- fixed SF# 2897650: [branch 1.3.6] Net.SocketAddress won't compile for CYGWIN
+- fixed SF# 2896161: Building on Windows fails when basedir has space in it
+- fixed SF# 2864380: Memory leak when using secure sockets
+- NetSSL_OpenSSL: the SSL/TLS session cache is now disabled by default and
+  can be enabled per Context using Poco::Net::Context::enableSessionCache().
+- fixed SF# 2899039: Wrong DST handling in LocalDateTime
+- added RWLock::ScopedReadLock and RWLock::ScopedWriteLock (contributed by Marc Chevrier)
+- added Thread::TID type, as well as Thread::tid() and Thread::currentTid() to obtain the native
+  thread handle/ID
+- added Zip file comment support
+- On Windows, Poco::SharedLibrary::load() now uses LoadLibraryEx instead of LoadLibrary
+  and uses the LOAD_WITH_ALTERED_SEARCH_PATH if an absolute path is specified. This will
+  add the directory containing the library to the search path for DLLs that the
+  loaded library depends upon.
+- Mac OS X build settings now match those used by default Xcode projects, making linking the
+  POCO libs to Xcode projects easier
+- Replaced use of std::valarray in Poco::Net::ICMPEventArgs with std::vector due to issues with
+  std::valarray together with STDCXX debug mode on OS X
+
+
+Release 1.3.5 (2009-05-11)
+==========================
+
+- fixed SF# 2779410: Poco::Data::ODBC::HandleException impovement
+- fixed wrong exception text for Poco::UnhandledException
+- Fixed a problem with SSL shutdown that causes clients (web browsers)
+  to hang when the server attempts to perform a clean SSL shutdown. We now call
+  SSL_shutdown() once, even if the shutdown is not complete after the first call.
+- added Poco::Crypto::X509Certificate::save()
+- fixed a bug in Poco::Zip::Decompress that results in wrong paths for extracted files
+- fixed a bug in Poco::Zip::ZipManipulator where the Zip file was opened in text format
+  on Windows.
+- added Poco::Crypto::X509Certificate::issuedBy() to verify certificate chain.
+- fixed 0000089: Thread::sleep() on Linux is extremely inaccurate
+- added methods to extract the contents of specific fields from the
+  subject and issuer distinguished names of a certificate.
+
+
+Release 1.3.4 (2009-04-21)
+==========================
+
+- fixed SF# 2611804: PropertyFileConfiguration continuation lines
+- fixed SF# 2529788: ServerApplication::beDaemon() broken
+- fixed SF# 2445467: Bug in Thread_WIN32.cpp
+- Improved performance of HTTP Server by removing some
+  string copy operations
+- fixed SF# 2310735: HTTPServer: Keep-Alive only works with send()
+- fixed appinf.com IP address in Net testsuite
+- fixed RFC-00188: NumberFormatter and float/double numbers
+- added --pidfile option to ServerApplication on Unix
+- fixed SF# 2499504: Bug in Win32_Thread when using from dll (fixed also for POSIX threads)
+- fixed SF# 2465794: HTTPServerRequestImpl memory leak
+- fixed SF# 2583934: Zip: No Unix permissions set
+- the NetSSL_OpenSSL library has been heavily refactored
+- added NumberFormatter::append*() and DateTimeFormatter::append() functions
+- use NumberFormatter::append() and DateTimeFormatter::append() instead of format() where
+  it makes sense to gain some performance
+- added system.dateTime and system.pid to Poco::Util::SystemConfiguration
+- added %F format specifier (fractional seconds/microseconds) to DateTimeFormatter,
+  DateTimeParser and PatternFormatter.
+- fixed SF# 2630476: Thread_POSIX::setStackSize() failure with g++ 4.3
+- fixed SF# 2679279: Handling of -- option broken
+- added compile options to reduce memory footprint of statically linked applications
+  by excluding various classes from automatically being linked.
+  See the POCO_NO_* macros in Poco/Config.h.
+- fixed SF# 2644940: on Windows the COMPUTER-NAME and the HOSTNAME can be different
+- added DNS::hostName() function
+- added build configuration for iPhone (using Apple's SDK)
+- basic support for AIX 5.x/xlC 8
+- fixed a bug resulting in a badly formatted exception message with IOException
+  thrown due to a socket-related error
+- fixed SF# 2644718: NetworkInterface name conflict in MinGW
+- added a missing #include to CryptoTransform.h
+- fixed SF# 2635377: HTTPServer::HTTPServer should take AutoPtr<HTTPServerParams>
+- replaced plain pointers with smart pointers in some interfaces
+- upgraded to sqlite 3.6.13
+- improved Data::SQLite error reporting
+- Poco::Glob now works with UTF-8 encoded strings and supports case-insensitive comparison.
+  This also fixes SF# 1944831: Glob::glob on windows should be case insensitve
+- added Twitter client sample to Net library
+- Fixed SF# 2513643: Seg fault in Poco::UTF8::toLower on 64-bit Linux
+- Poco::Data::SessionPool: the janitor can be disabled by specifying a zero idle time.
+- added Poco::Data::SessionPool::customizeSession()
+- added support for different SQLite transaction modes (DEFERRED, IMMEDIATE, EXCLUSIVE)
+- fixed a few wrong #if POCO_HAVE_IPv6 in the Net library
+- added support for creating an initialized, but unconnected StreamSocket.
+- added File::isDevice()
+- added family() member function to SocketAddress,
+- Data::SQLite: added support for automatic retries if the database is locked
+- XMLConfiguration is now writable
+- fixed an IPv6 implementation for Windows bug in HostEntry
+- Timer class improvement: interval between callback is no longer influenced by the
+  time needed to execute the callback.
+- added PriorityNotificationQueue and TimedNotificationQueue classes to Foundation.
+  These are variants of the NotificationQueue class that support priority and
+  timestamp-tagged notifications.
+- added Poco::Util::Timer class. This implements a timer that can schedule different
+  tasks at different times, using only one thread.
+- the signatures of Poco::NotificationQueue and Poco::NotificationCenter member functions
+  have been changed to accept a Poco::Notification::Ptr instead of Poco::Notification*
+  to improve exception safety. This change should be transparent and fully backwards
+  compatible. The signature of the methods returning a Poco::Notification* have not been
+  changed for backwards compatibility. It is recommended, that any Notification* obtained
+  should be immediately assigned to a Notification::Ptr.
+- SQLite::SessionImpl::isTransaction() now uses sqlite3_get_autocommit() to find out
+  about the transaction state.
+- refactored Crypto library to make it independent from NetSSL_OpenSSL.
+- added support for RSA-MD5 digital signatures to Crypto library.
+- removed SSLInitializer from NetSSL library (now moved to Crypto library)
+- added build configs for static libraries to Crypto library
+- OpenSSL now depends on Crypto library (which makes more sense than
+  vice versa, as it was before). Poco::Net::X509Certificate is now
+  a subclass of Poco::Crypto::X509Certificate (adding the verify()
+  member function) and the Poco::Net::SSLInitializer class was
+  moved to Poco::Crypto::OpenSSLInitializer.
+- added build configs for static libraries to Zip
+- added batch mode to CppUnit::WinTestRunner.
+  WinTestRunnerApp supports a batch mode, which runs the
+  test using the standard text-based TestRunner from CppUnit.
+  To enable batch mode, start the application with the "/b"
+  or "/B" command line argument. Optionally, a path to a file
+  where the test output will be written to may be given:
+  "/b:<path>" or "/B:<path>".
+  When run in batch mode, the exit code of the application
+  will denote test success (0) or failure (1).
+- testsuites now also work for static builds on Windows
+- The IPv6 support for Windows now basically works (Net library compiled with POCO_HAVE_IPv6)
+- fixed a potential error when shutting down openssl in a statically linked application
+- added static build configs to Data library
+- added Poco::AtomicCounter class, which uses OS-specific APIs for atomic (thread-safe)
+  manipulation of counter values.
+- Poco::RefCountedObject and Poco::SharedPtr now use Poco::AtomicCounter for
+  reference counting
+- fixed SF# 2765569: LoadConfiguration failing from current directory
+
+
+Release 1.3.3p1 (2008-10-09)
+============================
+
+- Fixed SF# 2153031: 1.3.3 Crypto won't compile on 64-bit Linux
+- Fixed a warning in MySQL connector
+- Updated README
+- The global Makefile in the Zip archive is no longer broken
+
+
+Release 1.3.3 (2008-10-07)
+==========================
+
+- Threads now have optional user-settable stack size (if the OS supports that feature)
+- Events now support simplified delegate syntax based on delegate function template.
+  See Poco::AbstractEvent documentation for new syntax.
+- Cache supports new access expire strategy.
+- Upgraded to SQLite 3.6.2
+- Upgraded to PCRE 7.8
+- added HttpOnly support to Poco::Net::HTTPCookie
+- NetworkInterface now has displayName() member (useful only on Windows)
+- Poco::Util::WinRegistryKey now has a read-only mode
+- Poco::Util::WinRegistryKey::deleteKey() can now recursively delete registry keys
+- Poco::File::created() now returns 0 if the creation date/time is not known, as
+  it's the case on most Unix platforms (including Linux).
+  On FreeBSD and Mac OS X, it returns the real creation time.
+- Time interval based log file rotation (Poco::FileChannel) now works
+  correctly. Since there's no reliable and portable way to find out the creation
+  date of a file (Windows has the tunneling "feature", most Unixes don't provide
+  the creation date), the creation/rotation date of the log file is written into
+  the log file as the first line.
+- added Environment::nodeId() for obtaining the Ethernet address of the system
+  (this is now also used by UUIDGenerator - the corresponding code from UUIDGenerator
+  was moved into Environment)
+- added a release policy argument to SharedPtr template
+- Socket::select() will no longer throw an InvalidArgumentException
+  on Windows when called with no sockets at all. If all three socket
+  sets are empty, Socket::select() will return 0 immediately.
+- SocketReactor::run() now catches exceptions and reports them via
+  the ErrorHandler.
+- SocketReactor has a new IdleNotification, which will be posted when
+  the SocketReactor has no sockets to handle.
+- added referenceCount() method to Poco::SharedPtr.
+- POCO now builds with GCC 4.3 (but there are some stupid warnings:
+  "suggest parentheses around && within ||".
+- Solution and project files for Visual Studio 2008 are included
+- The Zip library is now officially part of the standard POCO release.
+- The Crypto library (based on OpenSSL) has been added. The original code
+  was kindly contributed by Ferdinand Beyer.
+- A Data Connector to MySQL, contributed by Sergey Kholodilov, is now part
+  of the POCO release.
+- fixed SF# 1859738: AsyncChannel stall
+- fixed SF# 1815124: XML Compile failed on VS7.1 with XML_UNICODE_WCHAR_T
+- fixed SF# 1867340: Net and NetSSL additional dependency not set - ws2_32.lib
+- fixed SF# 1871946: no exception thrown on error
+- fixed SF# 1881113: LinearHashTable does not conform to stl iterators
+- fixed SF# 1899808: HTMLForm.load() should call clear() first
+- fixed SF# 2030074: Cookie problem with .NET server
+- fixed SF# 2009707: small bug in Net/ICMPPacketImpl.cpp
+- fixed SF# 1988579: Intel Warning: invalid multibyte character sequence
+- fixed SF# 2007486: Please clarify license for Data/samples/*
+- fixed SF# 1985180: Poco::Net::DNS multithreading issue
+- fixed SF# 1968106: DigestOutputStream losing data
+- fixed SF# 1980478: FileChannel loses messages with "archive"="timestamp"
+- fixed SF# 1906481: mingw build WC_NO_BEST_FIT_CHARS is not defined
+- fixed SF# 1916763: Bug in Activity?
+- fixed SF# 1956300: HTTPServerConnection hanging
+- fixed SF# 1963214: Typo in documentation for NumberParser::parseFloat
+- fixed SF# 1981865: Cygwin Makefile lacks ThreadTarget.cpp
+- fixed SF# 1981130: pointless comparison of unsigned integer with zero
+- fixed SF# 1943728: POCO_APP_MAIN namespace issue
+- fixed SF# 1981139: initial value of reference to non-const must be an lvalue
+- fixed SF# 1995073: setupRegistry is broken if POCO_WIN32_UTF8 enabled
+- fixed SF# 1981125: std::swap_ranges overloading resolution failed
+- fixed SF# 2019857: Memory leak in Data::ODBC Extractor
+- fixed SF# 1916761: Bug in Stopwatch?
+- fixed SF# 1951443: NetworkInterface::list BSD/QNX no netmask and broadcast addr
+- fixed SF# 1935310: Unhandled characters in Windows1252Encoding
+- fixed SF# 1948361: a little bug for win32
+- fixed SF# 1896482: tryReadLock intermittent error
+- workaround for SF# 1959059: Poco::SignalHandler deadlock
+  the SignalHandler can now be disabled globally by adding a
+  #define POCO_NO_SIGNAL_HANDLER to Poco/Config.h
+- fixed SF# 2012050: Configuration key created on read access
+- fixed SF# 1895483: PCRE - possible buffer overflow
+- fixed SF# 2062835: Logfile _creationDate is wrong
+- fixed SF# 2118943: out_of_bound access in Poco::Data::BLOB:rawContent
+- fixed SF# 2121732: Prevent InvalidArgumentException in SocketReactor
+- fixed SF# 1891132: Poco::Data::StatementImpl::executeWithLimit is not correct
+- fixed SF# 1951604: POCO refuses to compile with g++ 4.3.0
+- fixed SF# 1954327: CYGWIN's pthread does not define PTHREAD_STACK_MIN
+- fixed SF# 2124636: Discrepancy between FileWIN32(U)::handleLastError
+- fixed SF# 1558300: MinGW/MSYS Builds
+- fixed SF# 2123266: Memory leak under QNX6 with dinkum library
+- fixed SF# 2140411: ScopedUnlock documentation bug
+- fixed SF# 2036460: UUID regression tests are failing on Linux with g++ 4.3.1
+- fixed SF# 2150438: Tuple TypeHandler position increment size is wrong
+
+
+Release 1.3.2 (2008-02-04)
+==========================
+
+Foundation, XML, Net, Util:
+- added POCO_NO_SHAREDMEMORY to Config.h
+- POCO_NO_WSTRING now really disables all wide string related calls
+- added template specialization for string hashfunction (performance)
+- XML parser performance improvements (SAX parser is now up to 40 % faster
+- added parseMemoryNP() to XMLReader and friends
+- URIStreamOpener improvement: redirect logic is now in URIStreamOpener.
+  this enables support for redirects from http to https.
+- added support for temporary redirects and useproxy return code
+- added getBlocking() to Socket
+- added File::isHidden()
+- better WIN64 support (AMD64 and IA64 platforms are recognized)
+- added support for timed lock operations to [Fast]Mutex
+- SharedLibrary: dlopen() is called with RTLD_GLOBAL instead of RTLD_LOCAL
+  (see http://gcc.gnu.org/faq.html#dso)
+- Poco::Timer threads can now run with a specified priority
+- added testcase for SF# 1774351
+- fixed SF# 1784772: Message::swap omits _tid mem
+- fixed SF# 1790894: IPAddress(addr,family) doesn't fail on invalid address
+- fixed SF# 1804395: Constructor argument name wrong
+- fixed SF# 1806807: XMLWriter::characters should ignore empty strings
+- fixed SF# 1806994: property application.runAsService set too late
+- fixed SF# 1828908: HTMLForm does not encode '+'
+- fixed SF# 1831871: Windows configuration file line endings not correct.
+- fixed SF# 1845545: TCP server hangs on shutdown
+- fixed SF# 1846734: Option::validator() does not behave according to doc
+- fixed SF# 1856567: Assertion in DateTimeParser::tryParse()
+- fixed SF# 1864832: HTTP server sendFile() uses incorrect date
+- HTTPServerResponseImpl now always sets the Date header automatically
+  in the constructor.
+- fixed SF# 1787667: DateTimeFormatter and time related classes
+  (also SF# 1800031: The wrong behavior of time related classes)
+- fixed SF# 1829700: TaskManager::_taskList contains tasks that never started
+- fixed SF# 1834127: Anonymous enums in Tuple.h result in invalid C++
+- fixed SF# 1834130: RunnableAdapter::operator= not returning a value
+- fixed SF# 1873924: Add exception code to NetException
+- fixed SF# 1873929: SMTPClientSession support for name in sender field
+- logging performance improvements (PatternFormatter)
+- fixed SF# 1883871: TypeList operator < fails for tuples with duplicate values
+- CYGWIN build works again (most things work but Foundation testsuite still fails)
+- new build configuration for Digi Embedded Linux (ARM9, uclibc)
+- new build configuration for PowerPC Linux
+
+Data:
+- fixed SF# 1724388: ODBC Diagnostics
+- fixed SF# 1804797: ODBC Statement multiple execution fails
+- fixed SF# 1803435: SessionPool onJanitorTimer called too often?
+- fixed SF# 1851997: Undefined Behavior in ODBC::Preparation
+- updated SQlite to 3.5.5
+
+
+Release 1.3.1 (2007-08-08)
+==========================
+
+Foundation, XML, Net, Util:
+- DynamicAny fixes for char conversions
+- fixed SF# 1733362: Strange timeout handling in SocketImpl::poll and Socket::select
+- fixed SF patch# 1728912: crash in POCO on Solaris
+- fixed SF# 1732138: Bug in WinRegistryConfiguration::getString
+- fixed SF# 1730790: Reference counting breaks NetworkInterface::list()
+- fixed SF# 1720733: Poco::SignalHandler bug
+- fixed SF# 1718724: Poco::StreamCopier::copyStream loops forever
+- fixed SF# 1718437: HashMap bug
+- changed LinearHashTable iterator implementation. less templates -> good thing.
+- fixed SF# 1733964: DynamicAny compile error
+- UUIDGenerator: fixed infinite loop with non ethernet interfaces
+- updated expat to 2.0.1
+- fixed SF# 1730566: HTTP server throws exception
+- Glob supports symbolic links (additional flag to control behavior)
+- fixed a problem with non blocking connect in NetSSL_OpenSSL
+  (see http://www.appinf.com/poco/wiki/tiki-view_forum_thread.php?comments_parentId=441&topics_threshold=0&topics_offset=29&topics_sort_mode=commentDate_desc&topics_find=&forumId=6)
+- fixed a problem with SSL renegotiation in NetSSL_OpenSSL (thanks to Sanjay Chouksey for the fix)
+- fixed SF# 1714753: NetSSL_OpenSSL: HTTPS connections fail with wildcard certs
+- HTTPClientSession: set Host header only if it's not already set (proposed by EHL)
+- NetworkInterface (Windows): Loopback interface now has correct netmask;
+  interfaces that do not have an IP address assigned are no longer reported.
+- Fixes for VC++ W4 warnings from EHL
+- SharedMemory: first constructor has an additional "server" parameter
+  Setting to true does not unlink the shared memory region when the SharedMemory object is destroyed. (Alessandro Oliveira Ungaro)
+- fixed SF# 1768231: MemoryPool constructor
+
+Data:
+- fixed SF# 1739989: Data::RecordSet::operator = () (in 1.3 branch)
+- fixed SF# 1747525: SQLite, Transactions and Session Pooling (in 1.3 branch)
+- upgraded to SQLite 3.4.1
+
+
+Release 1.3.0 (2007-05-07)
+==========================
+
+- added HashMap, HashSet classes
+- the HashFunction class template has been changed in an incompatible
+  way. The member function formerly named hash() is now the function
+  call operator. If you have defined your own HashFunction classes,
+  you have to update your code. Sorry for the inconvenience.
+- added Poco::Tuple
+- added AbstractCache::getAllKeys(), improved performance of the get operation
+- fixed AbstractCache::size() to do cache replacement before returning the size
+- added additional match() method to RegularExpression and documented the fact that the simple
+  match() method internally sets RE_ANCHORED and RE_NOTEMPTY.
+- added ExpirationDecorator template. Decorates data types so that they can be used with UniqueExpireCaches
+- added operator ! to AutoPtr and SharedPtr
+- Buffer uses std::size_t instead of int
+- Exception::what() now returns exception name instead of message
+- added poco_ndc_dbg() macro (same as poco_ndc(), but only enabled in debug builds)
+- added Environment::get(name, defaultValue);
+- Foundation.h now includes Config.h at the very beginning.
+- added replace() and replaceInPlace() to Poco/String.h
+- added AutoPtr::assign() and SharedPtr::assign()
+- added operator () to AbstractEvent
+- gcc Makefiles now strip release builds
+- Void now has a == and != operator
+- Base64Encoder and HexBinaryEncoder now support an unlimited line length
+  (no newlines written), by specifying a line length of 0
+- NumberParser now has stricter syntax requirements: garbage following a number leads to a SyntaxException
+  (Thanks to phireis@gmail.com for the suggestion)
+- fixed SF# 1676830: Don't use -rpath in libraries
+- fixed SF# 1670279: AbstractConfiguration::unckeckedExpand crash
+- fixed a warning in Hashtable
+- HTTPClientSession now uses a keepAliveTimeout for better persistent connection handling
+- added DateTime::makeUTC() and DateTime::makeLocal()
+- added another constructor to LocalDateTime
+- POCO_WIN32_UTF8 is ignored on non-Windows platforms
+- fixed a timeout bug (with NetSSL) in HTTPSession
+- AsyncChannel is automatically opened with first log()
+- minor fix to NotificationQueue sample (reported by Laszlo Keresztfalvi)
+- added File::canExecute() and File::setExecutable()
+- added SharedMemory class to Foundation
+- added FileStream, FileInputStream, FileOutputStream to Foundation
+- added NodeAppender class to XML for faster DOM tree creation
+- HTTPServerRequest and HTTPServerResponse are now abstract base classes,
+  actual functionality has moved into HTTPServerRequestImpl and
+  HTTPServerResponseImpl. This allows us to plug other HTTP servers
+  into POCO.
+- added DynamicAny class to Foundation
+- replaced std::fstream with Poco::FileStream across POCO.
+- added Poco::Checksum class to Foundation.
+- fixed SF# 1700811: conflict in threadpool
+- bugfix: File::moveTo() does not work if the target is a directory
+- File::copyTo() and File::moveTo() now copy/move directories recursively
+- refactored NetworkInterface (now using pimpl idiom);
+  added broadcast address and netmask support
+- fixed SF# 1688982: POP3ClientSession fails when retrieving mails with attachment
+- fixed SF# 1655104: Enhance Poco::TextEncoding functionality
+- added Poco::Condition class, implementing a POSIX-style condition variable
+- fixed a bug in File::create() for Windows
+- added poco_static_assert (imported from boost)
+- added Thread::join(timeout) and Thread::tryJoin()
+- ClassLoader support for named manifests (see ClassLibrary.h - POCO_EXPORT_NAMED_MANIFEST)
+- POCO_WIN32_UTF8: UNICODE #define is no longer required (and no longer
+  automatically defined in POCO_WIN32_UTF8 is defined)
+- PCRE: upgraded to PCRE version 7.1
+- fixed SF# 1682162: Suggestion on thread priority
+- fixed SF# 1613460: MSVC/STLPort warnings
+- fixed SF# 1709358: Format double percent std::String bug
+- added WindowsConsoleChannel class to Foundation
+- added AutoPtr::unsafeCast<>() and SharedPtr::unsafeCast<>()
+- fixed SF# 1708552: Failed to build on arm and powerpc
+- fixed SF$ 1708529: Failed to build using GCC 4.3: missing #includes
+- fixed SF# 1710053: LogStream proposal
+- fixed a bug involving empty root directories in Windows DirectoryIterator implementation
+  (see http://www.appinf.com/poco/wiki/tiki-view_forum_thread.php?comments_parentId=343&forumId=6)
+- robustness improvements to ActiveMethod - removed the opportunity for memory leaks in
+  case something goes while invoking the method
+- made C library usage more C++-like - use C++ headers (e.g. <cstring>) instead of
+  C ones (<string.h>). Also, use C library functions in std namespace.
+- added Unicode and UTF8String for improved Unicode support.
+  The Unicode class can be used to obtain the Unicode properties of a character.
+  The UTF8 class provides case insensitive comparison and case conversion
+  for UTF-8 encoded strings.
+- added UnWindows.h header file, replaced all #include <windows.h> with #include "Poco/UnWindows.h".
+  See the Poco/UnWindows.h header file for a rationale and explanations.
+- fixed SF# 1713820: StreamSocketImpl::sendBytes sends too many bytes
+- File::copyTo(): on Windows, the copy now always has the read-only flag reset, to be consistent
+  with other platforms.
+- With Microsoft Visual C++, the necessary POCO libraries are now implicitly linked when
+  the corresponding header files are included (#pragma comment(lib, "PocoXYZ.lib") is used).
+  To disable this, compile POCO with the preprocessor symbol POCO_NO_AUTOMATIC_LIBS #define'd
+  (see Poco/Foundation.h and Poco/Config.h).
+- The Visual Studio project files for the POCO libraries now include configurations
+  for building static libraries.
+
+
+Release 1.2.9 (2007-02-26)
+==========================
+
+- fixed a formatting problem in Util::HelpFormatter
+- HTTPClientSession::sendRequest() now attempts to send the complete request in one network packet.
+- improved network performance of ChunkedOutputStream: chunk size and chunk data
+  are sent in one network packet if possible
+- fixed SF# 1655035: Wrong expires field calculation in HTTPCookie
+  (thanks to Sergey N. Yatskevich for this and other fixes)
+- fixed SF# 1655049: Fix discrepancy of a code to the description
+- fixed SF# 1655170: Poco::Timezone::standardName() problem on WIN32
+- fixed SF# 1629095: POCO_WIN32_UTF8 problem
+  There is a new function Path::transcode() that can be used to convert a path (or any other string)
+  from UTF-8 to the current Windows code page. This string can the be passed as a filename
+  to an fstream or fopen(). This function only does the conversion on Windows,
+  and only, if POCO_WIN32_UTF8 is defined. Otherwise, it simply returns the unmodified argument.
+- fixed SF# 1659607: Probably a bug in Poco::Net::DialogSocket
+- HTTPServer network performance improvement: responses that fit into a single network packet
+  sent with HTTPServerResponse::sendFile() or the new HTTPServerResponse::sendBuffer() are
+  sent in only one packet.
+- added HTTPServerResponse::sendBuffer()
+- HTTPServer now sends a Bad Request response if it fails to parse the HTTP request header.
+- HTTPServer now sends an Internal Server Error response if the request handler throws an
+  exception prior to sending a response.- enabled TCP_NODELAY per default on TCPServer/HTTPServer
+- fixed a bug in HTTP persistent connection handling
+  (server does not send Connection: close when it reaches connection maximum)
+- HTMLForm - POST submission of URL encoded form no longer uses chunked transfer encoding
+  (thus improving interoperability with certain web servers)
+- integrated Environment.cpp from Main (missing get(var, default))
+- added missing AutoPtr include to Util/Application
+  (and using Poco::AutoPtr is no longer necessary for POCO_APP_MAIN macro)
+- fixed SF# 1635420: Per Regents of the University of Calfornia letter,
+  remove advertising from BSD licensed parts
+- fixed SF# 1633133: MultipartWriter writes superluous CR-LF at beginning
+
+
+Release 1.2.8 (2007-01-04)
+==========================
+
+- fixed SF# 1613906: Util/Application.h and GCC 3.3
+- fixed a byte order issue (failed test) in IPv6 address formatting
+- fixed SF# 1626640: Poco::Net::SocketReactor bug
+- fixed client side chunked transfer encoding handling
+- fixed client side persistent connection handling
+- fixed SF# 1623536: HTTP Server Chunked Transfer Encoding Bug
+- improved HTTP server exception text
+- fixed SF# 1616294: KeepAlive HTTPServerSession patch
+- fixed SF# 1616296: Trivial Poco::TaskCustomNotification patch
+- fixed SF# 1619282: PurgeStrategy bug fix
+- fixed SF# 1620855: Format problem
+  there is a new format specifier %z for std::size_t, as well as a new
+  flag ? for %d, %i, %o, %x meaning any signed or unsigned integer
+
+
+Release 1.2.7 (2006-12-07)
+==========================
+
+- Poco::File: fixed root directory handling
+- fixed UUIDGenerator documentation
+- clarified Application::setUnixOptions() documentation
+- fixes for issue [SOAPLite Transport 0000023]: SOAP Transport Listener should be able to use existing HTTPServer instance
+- fixing mantis issues 13, 14, 15, 16, 17, 18, 19, 21
+- fixed SF# 1597022: Signed/unsigned warning in StringTokenizer::operator[]
+- fixed SF# 1598601: Message::op= leaks
+- fixed SF# 1605960: PatternFormatter crashes on custom property
+- fixed SF# 1605950: Memory leak in Logger sample code
+- fixed SF# 1591635: Copy Paste Error in sample code
+- fixed SF# 1591512: SMTPClientSession response stream
+- fixed SF #1592776: LayeredConfiguration: getRaw should enumerate in reverse order
+- SF Patch # 1599848 ] VS 2005 Util build fails
+- Logger::dump() now uses std::size_t instead of int for buffer size
+- LayeredConfiguration now supports a priority value for each configuration.
+  Also, it's possible to specify for each configuration added whether it
+  should be writeable.
+- ServerApplication: cd to root directory only if running as a daemon
+- added Message::swap()
+- improvements to build system:
+  global Makefile has correct dependencies for samples
+  on Windows, samples build after libraries are ready
+  configure supports --no-wstring and --no-fpenvironment flags
+  build system supports POCO_FLAGS environment variable for compiler flags
+- RemoteGen: fixed error handling for write protected files (SystemException)
+  fixing integral constant overflow messages with large cache expiration, m_ support for type serializers,
+  case-insensitive comparison added
+
+
+Release 1.2.6 (2006-11-19)
+==========================
+
+- added additional match() method to RegularExpression and documented the fact that the simple
+  match() method internally sets RE_ANCHORED and RE_NOTEMPTY.
+- added ExpirationDecorator template. Decorates data types so that they can be used with UniqueExpireCaches
+- added operator ! to AutoPtr and SharedPtr
+- Buffer uses std::size_t instead of int
+- added poco_ndc_dbg() macro (same as poco_ndc(), but only enabled in debug builds)
+- Foundation.h now includes Config.h at the very beginning.
+- added AutoPtr::assign() and SharedPtr::assign()
+- added operator () to AbstractEvent
+- gcc Makefiles now strip release builds
+- documentation improvements
+
+
+Release 1.2.5 (2006-10-23)
+==========================
+
+- Improved LoggingConfigurator: channel creation and configuration is now a two-step process.
+  This means that the previous problems with PropertyFileConfiguration and IniFileConfiguration when referencing other channels are solved.
+- improved options handling: better handling of (non) ambiguities.
+  If both an option named "help" and one named "helper" is specified, this no longer causes ambiguity errors.
+- added check for duplicate option definition
+- ThreadPool bugfix: fixed a crash that occurs on Linux multiprocessor machines
+  (caused by an thread unsafe string assignment corrupting the heap...)
+  (SF# 1575315)
+- improved ThreadPool performance
+- XML now compiles with -DXML_UNICODE_WCHAR_T (SF# 1575174)
+- fixed SF# 1572757: HTML forms can have more than one key/value pair with the same name
+- got rid of the dynamic casts in Events, Events/Cache: simpler/faster Delegate < operator,
+  prevents some rare dynamic casts error from occuring when using StrategyCollection with Caches
+- improvements to Logger and LoggingConfigurator:
+  * added Logger::unsafeGet()
+  * added Logger::setProperty(loggerName, propertyName, value)
+  * LoggingConfigurator now correctly (re)configures existing Loggers
+    (prior to this change, if a Logger named "a.b.c" existed before
+    the LoggingConfigurator started its work, and the LoggingConfigurator
+    configured a Logger named "a.b", then "a.b.c" would not inherit
+    the new configuration).
+- improvements to SplitterChannel and EventLogChannel configuration
+- improved LoggingRegistry exception messages
+- MessageHeader::read() is more liberal with malformed message headers.
+  This fixes problems with certain network cameras sending malformed HTTP headers.
+
+
+Release 1.2.4 (2006-10-02)
+==========================
+
+- some code beautifying and improvements to comments
+- DOMParser now automatically sets FEATURE_NAMESPACE_PREFIXES
+- fixed SF #1567051:  DOMBuilder/DOMParser/NamespaceStrategy bug
+- fixed SF #1567364: POCO_APP_MAIN
+- added Document::getElementById() (two-argument) and getElementByIdNS()
+- added another test for DOMParser
+- added AutoPtr::isNull() (to be consistent with SharedPtr)
+- this release again compiles on PA-RISC HP-UX systems with aCC
+- added CMAKE support files contributed by Andrew J. P. Maclean
+
+
+Release 1.2.3 (2006-09-14)
+==========================
+
+- configure script now checks if (auto)selected configuration is supported
+- fixed SF #1552904: NamedEvent bug?
+- fixed SF #1552787: POCO not handling EINTR
+- fixed SF #1552846: Random::~Random uses scalar delete
+- fixed SF #1552987: TLSSlot should explicitly default-construct _value
+- IPAddress no longer accepts an empty address string
+- split up Observer.h into AbstractObserver.h and Observer.h
+- added NObserver class template which supports an AutoPtr
+  argument for the notification callback
+- changed EchoServer sample to use NObserver
+- some Windows-specific files were missing in the tarballs
+
+
+Release 1.2.2 (2006-09-01)
+==========================
+
+- fixed SF # 1549973: NotificationCenter::hasObservers() returns wrong result
+- fixed a memory leak in EchoServer sample
+- fixed SocketReactor TimeoutNotification bug (SF #1549365, SocketNotifier::addObserver() incorrect behavior)
+- fixed SF# 1549513: MultipartReader does not work with Unix-style linefeeds
+- MailMessage and HTMLForm: processing of multipart messages will no longer fail if a PartHandler does not read all data from the part stream.
+- added additional test case (Unix-style line ends) to MultipartReaderTest
+
+
+Release 1.2.1 (2006-08-29)
+==========================
+
+- fixed Config.h header (no more #undefs)
+
+Release 1.2.0 (2006-08-29)
+==========================
+
+- DateTime fixes: Julian Day is no longer stored internally.
+  Times (hours, minutes, seconds, ...) are now always taken from an utcValue (if available) and not from the Julian day.
+  The Julian day is only used for calculating year, month and day (except when the Julian day is the only thing we have)
+  This helps us get rid of rounding errors that the Julian Day arithmetic introduced.- on Windows, UUIDGenerator no longer uses Netbios, but GetAdaptersInfo instead
+- The main Makefile now has correct dependencies
+- updated poco-doc.pl with latest version by Caleb Epstein
+- fixed SF #1542722: InflatingInputStream: buffer error
+- improved Windows UTF-8 support
+- added Logger::names()
+- added configure script and make install target
+- XMLWriter bugfix: pretty-print bug with characters() and rawCharacters()
+- improvements to build system: support builds outside of source tree
+- added header doc conversion tool contributed by Caleb Epstein
+- fixed SF #1542618 (build/config/Linux patch)
+- bugfix: BinaryReader/BinaryWriter BOM is now 16 bits, as documented
+- fixed SF #1542247 (Compiler warning from OptionCallback)
+- fixed SF #1542253 (ServerApplication::handleOption doesn't call Application::handleOption)
+- added Application::stopOptionsProcessing()
+- updated samples
+- Util::Application command line handling now supports:
+  * argument validation (Option::validator(); see Validator, IntValidator, RegExpValidator)
+  * binding of argument values to config properties (Option::binding())
+  * callbacks for arguments (Option::callback())
+  * checking of required parameters
+- changed header file locations:
+  Foundation headers are now in Poco (#include "Poco/Foundation.h")
+  XML headers are now in Poco/XML, Poco/SAX and Poco/DOM (#include "Poco/XML/XML.h")
+  Util headers are now in Poco/Util (#include "Poco/Util/Util.h")
+  etc.
+  Unfortunately, this change will break existing code. However, fixing the code is
+  a matter of a few global search/replace operations and can be done quickly.
+  On the plus side, POCO is now a much better citizen when used with other
+  libraries.
+- changed namespaces:
+  Foundation is now Poco
+  XML is now Poco::XML
+  Util is now Poco::Util
+  Net is now Poco::Net
+- removed namespace macros
+- fixed some warnings reported by gcc -Wall -Wextra
+- fixed AutoPtr and LayeredConfiguration documentation
+- improved StreamSocket::receiveBytes() doc
+- added Pipe and PipeStream classes
+- added support for I/O redirection (pipes) to Process::launch()
+- added LogStream class (ostream interface to Logger)
+- improved Makefiles (no more double-building if clean all is specified)
+- added CppUnit and DateTime testsuite contributions by Andrew Marlow
+- improved Cygwin and minimal MinGW support
+- FileChannel: gzip compression if archived files now runs in a background thread (SF #1537481)
+- POCO now compiles with large (64-bit) file support on Linux (SF #1536634)
+- added format() function, which provides typesafe sprintf-like functionality (SF #1327621)
+- added File::isLink()
+- bugfix: dangling symbolic links in a directory no longer cause recursive remove to fail with file not found error
+- added Void class (useful as argument to ActiveMethod)
+- ActiveResult now supports exceptions
+- bugfix: Timezone::utcOffset() and Timezone::dst() returned wrong values on Unix platforms (SF #1535428)
+- added ActiveDispatcher class
+- added ActiveStarter class, which is a policy used by ActiveMethod for starting methods
+- ActiveRunnable moved to its own header file
+- ThreadPool: added startWithPriority(), which allows for running threads with a different priority
+- added error handling to dir sample
+- added additional test case to HTTPServer test suite- HTMLForm: should now work with request methods other than POST and GET (all non-POST requests are treated the same as GET)
+- clarified HTMLForm documentation
+- HTMLForm bugfix: uploaded files no longer end up in value; PartHandler is called instead
+- NameValueCollection: added get(name, defaultValue)
+- added HTTPFormServer sample
+- added Foundation::HashTable and SimpleHashTable
+- added Net::HTTPSessionFactory
+- improvements to AutoPtr and SharedPtr
+- improvements to namespaces handling in XMLWriter
+- Foundation Cache: fixed add implementation to match the docu: a 2nd add will now simply overwrite existing entries
+- added DateTime::isValid()
+- added Exception::rethrow() (virtual, must be overridden by all subclasses)
+- Timer can now use a user-supplied ThreadPool
+- added rethrow() to exception classes
+- Net: made some constructors explicit
+- Net: added SocketAddress constructor to HTTPClientSession
+- Net: added HTTPSession::networkException() to check for exceptions swallowed by stream classes
+- Net: added single string argument constructor to SocketAddress.
+- Net: improved HTTPClientSession error handling (no more "Invalid HTTP version string" exceptions when the server prematurely closes the connection due to too much load)
+- Net: improved HTTPSession error handling. Exceptions while sending and receiving data are stored for later retrieval and no longer get lost since streambufs swallow them.
+- Net: added HTTPLoadTest sample
+- fixed a bug when opening logfiles on Unix platforms causing an existing logfile to be truncated
+- bugfix: log file purge intervals given in months did not work, due to a stupid typo
+- added RawSocket and ICMP classes
+- UUID: fixed a doc formatting bug
+- NetworkInterface::list() now includes loopback interface on Windows (SF #1460309)
+- made Exception::message() and Exception::nested() inline
+- added Net::UnsupportedRedirectException
+- HTTPStreamFactory throws an UnsupportedRedirectException if it encounters a redirect to https
+- HTTP: fixed bad 100 Continue handling in client and server code
+- added CONTRIBUTORS file
+
+
+Release 1.1.2 (2006-07-07)
+==========================
+
+- Changed license to Boost license
+- DBlite and NetSSL have been removed from the Boost-licensed release.
+  Please contact Applied Informatics (info@appinf.com) if you're interested in them.
+
+
+Release 1.1.1 (2006-04-03)
+==========================
+
+- NetSSL_OpenSSL now supports separate certificate verification
+  settings for client and server.
+- fixed SF #1460309 (enumerating network interfaces failed on 64bit Linux)
+- TCPServer no longer crashes if accept() fails
+
+
+Release 1.1.0 (2006-03-23)
+==========================
+
+- events no longer require awkward += new syntax
+- source code and documentation cleanups
+- basic support for new compilers and platforms
+
+
+Release 1.1b2 (2006-03-04)
+==========================
+
+- made NetSSL threadsafe (added locking callbacks for OpenSSL)
+- improved OpenSSL initialization (random generator seeding)
+- various changes to improve compatibility with various platforms
+
+
+Release 1.1b1 (2006-03-03)
+==========================
+
+- New Events package in Foundation. The package supports C#-style event handling
+- New Cache package in Foundation: a templates-based caching framework
+- added Any class to Foundation
+- added DBLite library
+- fixed a memory leak with layered configurations in the application
+- made POCO_DLL the default (unless POCO_STATIC is #defined)
+  It is no longer necessary to specify POCO_DLL in projects that use Poco
+  (SourceForge Patch #1408231 and Feature Request #1407575).
+- added Buffer template class to Foundation
+- added the UnicodeConverter utility class. This is mainly used for Windows Unicode support and probably of little use for anything else.
+- added Path::resolve()
+- added Windows Unicode support. This calls the Unicode variant of the Windows API functions.
+  For this to work, all strings must be UTF-8 encoded and POCO_WIN32_UTF8 must be defined in all compilation units.
+- added StreamCopier::copyToString()
+- added URIStreamOpener::unregisterStreamFactory() and new variants of URIStreamOpener::open() that also work with filesystem paths.
+  This fixes SourceForge Bug #1409064 and Feature Request #1409062.
+- added NodeIterator::currentNodeNP() to XML library
+- added some sanity checks to UTF8Encoding::convert()
+- added NetSSL - SSL support for Net library, based on OpenSSL
+- console output of processes launched with Process::launch() is now visible
+
+
+Release 1.0.0 (2006-01-19)
+==========================
+
+- removed unnecessary console output from ProcessTest
+- documentation fixes
+
+
+Release 1.0b2 (2006-01-16)
+==========================
+
+- added ProcessHandle class
+- Process::launch() now returns a ProcessHandle instead of a process ID.
+  This fixes a potential problem on Windows with Process::wait() when
+  the process terminates before wait() is called.
+- added SplitterChannel::close()
+- added Logger::destroy()
+- added POP3ClientSession::deleteMessage()
+- added test for Process::launch()
+- documentation fixes
+
+
+Release 1.0b1 (2006-01-09)
+==========================
+
+- improved recognition of Windows paths in Path::parseGuess()
+- added setCurrentLineNumber()/getCurrentLineNumber() to CountingStreamBuf
+- improvememts to StreamTokenizer and Token; fixed documentation
+- added a workaround for some strange istream behaviour with VS 2005 and FTPClientSessionTest
+- improved exception/error reporting in cppunit
+- added POP3ClientSession
+- added Process::launch() and Process::wait()
+- added Mail sample
+- added MailStream and SMTPClientSession classes
+- renamed some methods in DialogSocket to make them more general
+- NullPartHandler has moved out of HTMLForm.cpp into a separate file
+- Base64Encoder now always writes \r\n line ends
+- MessageHeader::quote has an optional addition arg controlling the treatment of whitespace
+- bugfix: MultipartReader had a problem with empty lines (\r\n sequences) in a part
+- added MailMessage and MailRecipient classes
+- added text encoding support for Windows-1252 codepage
+
+
+Release 1.0a1 (2006-01-03) [internal]
+=====================================
+
+- mediaType is used consistently to refer to a MIME media type (some occurences of contentType and mimeType have been replaced)
+- moved MediaType::quote() to MessageHeader and made it public
+- added MultipartWriter::stream()
+- Renamed AttachmentSource to PartSource and AttachmentHandler to PartHandler
+- SIGPIPE is always blocked in main thread on Unix systems
+- added EchoServer sample
+- fixed a bug in SocketImpl::setBlocking() - did exactly the opposite (value to ioctl was wrong)
+- fixed a memory leak in NotificationQueue sample
+- added comparison operators to Socket so that Sockets can be used as keys in maps
+- added Socket::setBlocking()
+- added StreamSocket::connectNB() (non-blocking connect)
+- added Observer::accepts()
+- added SocketReactor, SocketConnector and SocketAcceptor classes to support event-based socket programming
+- NamespacePrefixesStrategy now uses expat's XML_SetReturnNSTriplet().
+  The previously used separate namespace handling code has been removed.
+  This improves performance if NamespacePrefixesStrategy is used (both the n
+  amespaces and namespace-prefixes SAX2 features are used)
+- upgraded expat to 2.0 pre-release (2005-12-27) snapshot
+- added TeeInputStream and TeeOutputStream classes
+- added download sample for URIStreamOpener
+- renamed registerOpener() to registerFactory() in HTTPStreamFactory and FTPStreamFactory
+- added LineEndingConverter streams
+- added FTPClientSession
+- code and documentation clean-up
+- added DialogSocket class
+- reorganized HTTP test suites
+- added FTPClientSession and FTPStreamFactory
+- added DialogSocket class
+
+
+Release 0.96.1 (2005-12-28)
+===========================
+
+- fixed a memory leak caused by a bug in Microsoft's stream implementation (see the comment in Foundation/StreamUtil.h for an explanation)
+- added samples for Net library
+- added uptime() and startTime() to Util::Application
+- added DateTimeFormatter::format() for Timespan
+- added ErrorHandler class and better exception handling for threads
+- added poco_debugger() and poco_debugger_msg() macros
+- added project and solution files for Visual Studio 2005 (due to some bugs/leaks in Microsofts standard library - see
+  http://lab.msdn.microsoft.com/productfeedback/viewfeedback.aspx?feedbackid=e08bd793-3fef-40ff-adda-ed313e0eafcc
+  we do not recommend using this for production purposes)
+- fixed two problems with out-of-range string iterator in Path (the testsuite triggered an assertion in VC++ 8.0)
+- fixed mac line endings in a few files
+- added a workaround to the class loader that fixes strange behavior with VC++ 8.0. There seems to be a problem with typeid() not returning a valid typeinfo under certain circumstances.
+- added buffer allocator argument to buffered stream buffer templates
+- added buffer pools to HTTP to reduce memory fragmentation and to improve performance
+- added Net to Windows build.cmd script
+- added swap() to various classes that already support assignment
+- added a null pointer check in DOMWriter::writeNode()
+- fixed documentation in BinaryWriter.h and BinaryReader.h
+- added explicit support for network byte order to BinaryReader and BinaryWriter
+- added basic support for FreeBSD (needs more testing)
+- BinaryReader: renamed readRawData() to readRaw() to be consistent with BinaryWriter::writeRaw()
+- added support for uppercase output to HexBinaryEncoder.
+- added MediaType class
+- added QuotedPrintableEncoder and QuotedPrintableDecoder classes
+- renamed ObjectFactory to Instantiator. This should prevent the confusion caused by DynamicFactory and ObjectFactory. Sorry for the inconvenience if you are already using this.
+- AttachmentSource::filename() now returns const string&
+- added StringAttachmentSource
+- replaced old-style C casts with C++ casts in NetworkInterface.cpp
+- MutexImpl (WIN32): replaced InitializeCriticalSection with InitializeCriticalSectionAndSpinCount, which should increase performance on multiprocessor or multicore systems when many locks are used.
+- fixed a problem with STLport 5.0 when compiling StreamTokenizer
+- HTTPStreamOpener now also works with no-path URIs (like http://www.appinf.com)
+- fixed wrong delete usage (plain delete instead of delete [] was used in a few cases)
+- fixed a handle leak in WinTestRunner
+
+
+Release 0.95.4 (2005-11-07)
+===========================
+
+- fixed #1348006 and #1348005
+
+
+Release 0.95.3 (2005-10-28) [internal]
+======================================
+
+- updated build scripts (patch #1339015)
+- added support for AMD64 platforms (patch #1339015)
+- MultipartWriter creates its own boundary if an empty string is passed in as boundary
+- made MultipartWriter::createBoundary() public
+- fixed wrong documentation for DateTimeFormat::HTTP_FORMAT
+- added support for HTTP Basic authentication
+- added support for HTTP Cookies
+- added support for HTML forms
+
+
+Release 0.95.2 (2005-10-22) [internal]
+======================================
+
+- fixed a potential problems with streams when close in destructor fails (added try..catch block around close in destructors)
+- added HTTPServer & friends
+- added hasIdleThreads() method to NotificationQueue
+- added TCPServer and friend
+- added support for HTTP proxies to HTTPClientSession and HTTPStreamOpener
+- fixed documentation bugs (Mutex.h, ClassLoader.h)
+
+
+Relesae 0.95.1 (2005-10-15) [internal]
+======================================
+
+- Tasks can now throw custom notifications (contributed by Alex Fabijanic)
+- renamed URIFileStreamFactory to FileStreamFactory
+- added a few methods to URI (setPathEtc(), getPathEtc(), getPathAndQuery())
+- added new exception classes
+- fixed some documentation
+- added basic checks when reading a MessageHeader from a stream
+- added HTTP classes (testsuite still incomplete)
+- added MessageHeader, NameValueCollection, MultipartReader and MultipartWriter classes
+- added Timespan::useconds()
+- added ClassLoader::isLibraryLoaded()
+- Socket classes use Timespan::useconds() to fill struct timeval
+- added DatagramSocket, MulticastSocket and NetworkInterface classes
+- added socket classes and related basic stuff
+- added additonal constructor/assign to Timespan- added BasicBufferedBidirectionalStreamBuf
+- fixed a potential MT issue in Base64Decoder
+- code beautifying in [Un]BufferedStreamBuf
+- more improvements to ClassLoader
+- code cleanup and naming convention fixes (changed all *Imp classes to *Impl for consistency)
+
+
+Release 0.94.1 (2005-09-30) [internal]
+======================================
+
+- added MetaSingleton (based on a contribution by Alex Fabijanic)
+- added ClassLoader::create()
+- added ClassLoader::instance()
+- code clean-ups in FileChannel and related classes
+- added SimpleFileChannel
+- RotateAtTimeStrategy:
+  ::getNextRollover() rewritten (buggy)
+- DateTime
+  microseconds assert corrected
+  asserts in computeGregorian() (except for year - see comment in computeGregorian())
+  milliseconds calculation modified in computeGregorian()
+  microseconds assigned in computeGregorian()
+  normalize() and checkLimit() private functions to correct cases of overflow for milli/microseconds
+- LocalDateTime: added timestamp() method
+- FileChannel:
+  added "times" property (used to determine whether to use UTC or local time with RotateAtTimeStrategy)
+  ::setProperty() modified (whenever "times" property is set, methods setRotation and setArchive are
+  reinvoked to reflect the change)
+- FileChannel: added support for archived file compression and archived file purging
+- FileChannel tests modified
+- FileChannel: put LogFile, RotateStrategy and ArchiveStrategy into their own files
+- Message: added thread id field
+- PatternFormatter: added %I specifier for thread id
+- ThreadPool: PooledThread can be assigned a name
+- TaskManager: task name is reflected in thread name
+- fixed  LocalDateTime::operator - (const Timespan&) [#0000004]
+- upon startup all loggers' channels are set to a console channel
+- improved search for application configuration files (see loadConfiguration()).
+- added Glob class (fixes #1249700)
+- upgraded to zlib 1.2.3 (fixes #1261712)
+- added Logger::dump()
+- fixed a wrong condition in Logger::log(const Message&)
+- Path::find() now also works with relative paths in addition to plain file names
+- added Path(const Path&, const Path&) constructor
+- added SharedPtr template
+- added Path::tryParse()
+- SAXParser::parse()/EntityResolverImpl now works for both URIs and local filesystem paths (fixes #1254812)
+
+
+Release 0.93.1 (2005-08-01)
+===========================
+
+This release contains various new features, improvements and bugfixes:
+- bugfix: UUIDGenerator throws an exception if no connected ethernet adapter can
+  be found (and thus no MAC address can be obtained)
+- added UUIDGenerator::createOne() method
+- added error handling to UUID sample application
+- added relational (==, !=, <, <=, >, >=) and arithmetic operators (+, -, +=, -=) to DateTime
+- added LocalDateTime class
+- added support for LocalDateTime to DateTimeParser and DateTimeFormatter
+- added enqueueUrgentNotification() to NotificationQueue
+- added support for timezone specifiers (%z, %Z) to PatternFormatter
+- added [] operator and count() to StringTokenizer
+- added elapsed() and isElapsed() to Timestamp
+- added tzd() to Timezone
+- added WinRegistryKey and WinService classes (Windows only)
+- added index operator and count() to StringTokenizer
+- added day/time-based log rotation (thanks to Alex Fabijanic), minor improvements to DateTimeParser
+- support for Mac OS X 10.4/gcc 4.0.0
+- added NamedMutex and NamedEvent
+- added Process::kill()
+- added NoPermissionException
+- added Task and TaskManager classes
+- added ServerApplication class
+- bugfix: EventLogChannel - _logFile was not properly initialized in one constructor
+- bugfix: File::createDirectories did not work for hierarchies deeper than three
+- added Util::FilesystemConfiguration
+- documented logging policy: log() must open channel if it hasn't been opened yet
+- FileChannel::log() opens channel if necessary
+- the application reference passed to initialize() and reinitialize() is no longer const
+- improved application logging initialization
+- fixed a problem with configuration view and property placeholders
+- fixed Util build configuration for Visual Studio
+- improved application samples
+- fixed documentation for Semaphore class
+
+
+Release 0.92.1 (2005-05-09)
+===========================
+
+This release introduces the Util library that provides support for
+configuration file parsing (different file formats), command line
+argument processing, logging configuration and a framework for
+command line/server applications.
+There have also been various changes to the Foundation library:
+- a new RefCountedObject class that acts as a base class for
+  various classes that use reference counting
+- some missing members have been added to the AutoPtr template
+- various improvements and bugfixes to the Logging framework, as well as
+  new LoggingFactory and LoggingRegistry classses, and a NullChannel class
+- the SignalHandler class (Unix platforms only)
+- ObjectFactory and DynamicFactory template classes
+- the Path::find method for searching a file in a list of directories
+- various new Exception classes
+
+
+Release 0.91.4 (2005-04-11)
+===========================
+
+This is mainly a maintenance release that adds support for QNX Neutrino
+and OpenVMS. There are also minor bugfixes and improvements.
+
+The Unix build system has been modified to work on QNX Neutrino.
+The OpenVMS build system has been fixed and works now.
+Some missing #include's have been added for QNX Neutrino.
+Foundation/String.h: icompare now supports comparison with const char*;
+the classic C version of isspace() has been used in a few places instead of the
+C++ <locale> version, this has been fixed.
+Foundation/Exception.h: IllegalStateException added.
+
+
+Release 0.91.3 (2005-03-19)
+===========================
+
+This is a maintenance release that adds support for Solaris/Sun Forte C++.
+No new features have been added.
+
+An implementation of FPEnvironment for Solaris has been included.
+All stream classes have been modified to work around an initialization
+problem that surfaced with Sun's C++ compiler when using STLport.
+Source-code compatibility with the previous release is not affected. Various
+minor changes, mostly adding missing #include's for Solaris.
+
+
+Release 0.91.2 (2005-02-27)
+===========================
+
+Minor improvements to the Unix build system. No actual changes in the
+libraries.
+
+
+Release 0.91.1 (2005-02-21)
+===========================
+
+This is the first public release of the C++ Portable Components.
+The release does not contain all features planned for the later 1.0 release
+(the NET library is missing, for example), but is already quite usable.
+Please refer to the README file for more information and instructions for
+building the libraries.
diff --git a/contrib/poco-cmake/CMakeLists.txt b/base/poco/CMakeLists.txt
similarity index 67%
rename from contrib/poco-cmake/CMakeLists.txt
rename to base/poco/CMakeLists.txt
index d173f35b9bf..0432ce196bf 100644
--- a/contrib/poco-cmake/CMakeLists.txt
+++ b/base/poco/CMakeLists.txt
@@ -1,4 +1,5 @@
-set (LIBRARY_DIR "${ClickHouse_SOURCE_DIR}/contrib/poco")
+set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -w")
+set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w")
 
 add_subdirectory (Crypto)
 add_subdirectory (Data)
@@ -7,7 +8,7 @@ add_subdirectory (Foundation)
 add_subdirectory (JSON)
 add_subdirectory (MongoDB)
 add_subdirectory (Net)
-add_subdirectory (Net/SSL)
+add_subdirectory (NetSSL_OpenSSL)
 add_subdirectory (Redis)
 add_subdirectory (Util)
 add_subdirectory (XML)
diff --git a/base/poco/CONTRIBUTORS b/base/poco/CONTRIBUTORS
new file mode 100644
index 00000000000..7a74a9cc00c
--- /dev/null
+++ b/base/poco/CONTRIBUTORS
@@ -0,0 +1,52 @@
+Guenter Obiltschnig
+Alex Fabijanic
+Peter Schojer
+Ferdinand Beyer
+Krzysztof Burghardt
+Claus Dabringer
+Caleb Epstein
+Eran Hammer-Lahav
+Chris Johnson
+Sergey Kholodilov
+Ryan Kraay
+Larry Lewis
+Andrew J. P. Maclean
+Andrew Marlow
+Paschal Mushubi
+Jiang Shan
+David Shawley
+Sergey Skorokhodov
+Tom Tan
+Sergey N. Yatskevich
+Marc Chevrier
+Philippe Cuvillier
+Marian Krivos
+Franky Braem
+Philip Prindeville
+Anton Yabchinskiy
+Rangel Reale
+Fabrizio Duhem
+Patrick White
+Mike Naquin
+Roger Meier
+Mathaus Mendel
+Arturo Castro
+Adrian Imboden
+Matej Knopp
+Patrice Tarabbia
+Lucas Clemente
+Karl Reid
+Pascal Bach
+Cristian Thiago Moecke
+Sergei Nikulov
+Aaron Kaluszka
+Iyed Bennour
+Scott Davis
+Kristin Cowalcijk
+Yuval Kashtan
+Christopher Baker
+Scott Davis
+Jeff Adams
+Martin Osborne
+Björn Schramke
+Francis Andre
diff --git a/base/poco/Crypto/CMakeLists.txt b/base/poco/Crypto/CMakeLists.txt
new file mode 100644
index 00000000000..3753c5eed7b
--- /dev/null
+++ b/base/poco/Crypto/CMakeLists.txt
@@ -0,0 +1,17 @@
+if (ENABLE_SSL)
+    file (GLOB SRCS src/*.cpp)
+
+    add_library (_poco_crypto ${SRCS})
+    add_library (Poco::Crypto ALIAS _poco_crypto)
+
+    target_compile_options (_poco_crypto PRIVATE -Wno-newline-eof)
+    target_include_directories (_poco_crypto SYSTEM PUBLIC "include")
+    target_link_libraries (_poco_crypto PUBLIC Poco::Foundation OpenSSL::SSL OpenSSL::Crypto)
+
+    message (STATUS "Using Poco::Crypto")
+else ()
+    add_library (_poco_crypto INTERFACE)
+    add_library (Poco::Crypto ALIAS _poco_crypto)
+
+    message (STATUS "Not using Poco::Crypto")
+endif ()
diff --git a/base/poco/Crypto/include/Poco/Crypto/Cipher.h b/base/poco/Crypto/include/Poco/Crypto/Cipher.h
new file mode 100644
index 00000000000..fbe0c30ae8c
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/Cipher.h
@@ -0,0 +1,138 @@
+//
+// Cipher.h
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  Cipher
+//
+// Definition of the Cipher class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_Cipher_INCLUDED
+#define Crypto_Cipher_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include <istream>
+#include <ostream>
+#include <vector>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class CryptoTransform;
+
+
+class Crypto_API Cipher: public Poco::RefCountedObject
+	/// Represents the abstract base class from which all implementations of
+	/// symmetric/asymmetric encryption algorithms must inherit.  Use the CipherFactory
+	/// class to obtain an instance of this class:
+	///
+	///     CipherFactory& factory = CipherFactory::defaultFactory();
+	///     // Creates a 256-bit AES cipher
+	///     Cipher* pCipher = factory.createCipher(CipherKey("aes-256"));
+	///     Cipher* pRSACipher = factory.createCipher(RSAKey(RSAKey::KL_1024, RSAKey::EXP_SMALL));
+	///
+	/// Check the different Key constructors on how to initialize/create
+	/// a key. The above example auto-generates random keys.
+	///
+	/// Note that you won't be able to decrypt data encrypted with a random key
+	/// once the Cipher is destroyed unless you persist the generated key and IV.
+	/// An example usage for random keys is to encrypt data saved in a temporary
+	/// file.
+	///
+	/// Once your key is set up, you can use the Cipher object to encrypt or
+	/// decrypt strings or, in conjunction with a CryptoInputStream or a
+	/// CryptoOutputStream, to encrypt streams of data.
+	///
+	/// Since encrypted strings will contain arbitrary binary data that will cause
+	/// problems in applications that are not binary-safe (eg., when sending
+	/// encrypted data in e-mails), the encryptString() and decryptString() can
+	/// encode (or decode, respectively) encrypted data using a "transport encoding".
+	/// Supported encodings are Base64 and BinHex.
+	///
+	/// The following example encrypts and decrypts a string utilizing Base64
+	/// encoding:
+	///
+	///     std::string plainText = "This is my secret information";
+	///     std::string encrypted = pCipher->encryptString(plainText, Cipher::ENC_BASE64);
+	///     std::string decrypted = pCipher->decryptString(encrypted, Cipher::ENC_BASE64);
+	///
+	/// In order to encrypt a stream of data (eg. to encrypt files), you can use
+	/// a CryptoStream:
+	///
+	///     // Create an output stream that will encrypt all data going through it
+	///     // and write pass it to the underlying file stream.
+	///     Poco::FileOutputStream sink("encrypted.dat");
+	///     CryptoOutputStream encryptor(sink, pCipher->createEncryptor());
+	///     
+	///     Poco::FileInputStream source("source.txt");
+	///     Poco::StreamCopier::copyStream(source, encryptor);
+	///     
+	///     // Always close output streams to flush all internal buffers
+	///     encryptor.close();
+	///     sink.close();
+{
+public:
+	typedef Poco::AutoPtr<Cipher> Ptr;
+	typedef std::vector<unsigned char> ByteVec;
+
+	enum Encoding
+		/// Transport encoding to use for encryptString() and decryptString().
+	{
+		ENC_NONE         = 0x00, /// Plain binary output
+		ENC_BASE64       = 0x01, /// Base64-encoded output
+		ENC_BINHEX       = 0x02, /// BinHex-encoded output
+		ENC_BASE64_NO_LF = 0x81, /// Base64-encoded output, no linefeeds
+		ENC_BINHEX_NO_LF = 0x82  /// BinHex-encoded output, no linefeeds
+		
+	};
+
+	virtual ~Cipher();
+		/// Destroys the Cipher.
+
+	virtual const std::string& name() const = 0;
+		/// Returns the name of the Cipher.
+
+	virtual CryptoTransform* createEncryptor() = 0;
+		/// Creates an encryptor object to be used with a CryptoStream.
+
+	virtual CryptoTransform* createDecryptor() = 0;
+		/// Creates a decryptor object to be used with a CryptoStream.
+
+	virtual std::string encryptString(const std::string& str, Encoding encoding = ENC_NONE);
+		/// Directly encrypt a string and encode it using the given encoding.
+
+	virtual std::string decryptString(const std::string& str, Encoding encoding = ENC_NONE);
+		/// Directly decrypt a string that is encoded with the given encoding.
+
+	virtual void encrypt(std::istream& source, std::ostream& sink, Encoding encoding = ENC_NONE);
+		/// Directly encrypts an input stream and encodes it using the given encoding.
+
+	virtual void decrypt(std::istream& source, std::ostream& sink, Encoding encoding = ENC_NONE);
+		/// Directly decrypt an input stream that is encoded with the given encoding.
+
+protected:
+	Cipher();
+		/// Creates a new Cipher object.
+
+private:
+	Cipher(const Cipher&);
+	Cipher& operator = (const Cipher&);
+};
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_Cipher_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/CipherFactory.h b/base/poco/Crypto/include/Poco/Crypto/CipherFactory.h
new file mode 100644
index 00000000000..36aa964a1e6
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/CipherFactory.h
@@ -0,0 +1,75 @@
+//
+// CipherFactory.h
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CipherFactory
+//
+// Definition of the CipherFactory class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_CipherFactory_INCLUDED
+#define Crypto_CipherFactory_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class Cipher;
+class CipherKey;
+class RSAKey;
+
+
+class Crypto_API CipherFactory
+	/// A factory for Cipher objects. See the Cipher class for examples on how to
+	/// use the CipherFactory.
+{
+public:
+	CipherFactory();
+		/// Creates a new CipherFactory object.
+
+	virtual ~CipherFactory();
+		/// Destroys the CipherFactory.
+
+	Cipher* createCipher(const CipherKey& key);
+		/// Creates a Cipher object for the given Cipher name. Valid cipher 
+		/// names depend on the OpenSSL version the library is linked with;  
+		/// see the output of
+		///
+		///     openssl enc --help
+		///
+		/// for a list of supported block and stream ciphers.
+		///
+		/// Common examples are:
+		///
+		///   * AES: "aes-128", "aes-256"
+		///   * DES: "des", "des3"
+		///   * Blowfish: "bf"
+
+	Cipher* createCipher(const RSAKey& key, RSAPaddingMode paddingMode = RSA_PADDING_PKCS1);
+		/// Creates a RSACipher using the given RSA key and padding mode
+		/// for public key encryption/private key decryption.
+	
+	static CipherFactory& defaultFactory();
+		/// Returns the default CipherFactory.
+
+private:
+	CipherFactory(const CipherFactory&);
+	CipherFactory& operator = (const CipherFactory&);
+};
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_CipherFactory_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/CipherImpl.h b/base/poco/Crypto/include/Poco/Crypto/CipherImpl.h
new file mode 100644
index 00000000000..d6e8e0e79b2
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/CipherImpl.h
@@ -0,0 +1,69 @@
+//
+// CipherImpl.h
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CipherImpl
+//
+// Definition of the CipherImpl class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_CipherImpl_INCLUDED
+#define Crypto_CipherImpl_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/Cipher.h"
+#include "Poco/Crypto/CipherKey.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include <openssl/evp.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class CipherImpl: public Cipher
+	/// An implementation of the Cipher class for OpenSSL's crypto library.
+{
+public:
+	CipherImpl(const CipherKey& key);
+		/// Creates a new CipherImpl object for the given CipherKey.
+
+	virtual ~CipherImpl();
+		/// Destroys the CipherImpl.
+
+	const std::string& name() const;
+		/// Returns the name of the cipher.
+
+	CryptoTransform* createEncryptor();
+		/// Creates an encryptor object.
+
+	CryptoTransform* createDecryptor();
+		/// Creates a decryptor object.
+
+private:
+	CipherKey _key;
+	OpenSSLInitializer _openSSLInitializer;
+};
+
+
+//
+// Inlines
+//
+inline const std::string& CipherImpl::name() const
+{
+	return _key.name();
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_CipherImpl_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/CipherKey.h b/base/poco/Crypto/include/Poco/Crypto/CipherKey.h
new file mode 100644
index 00000000000..b102cc2310b
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/CipherKey.h
@@ -0,0 +1,201 @@
+//
+// CipherKey.h
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CipherKey
+//
+// Definition of the CipherKey class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_CipherKey_INCLUDED
+#define Crypto_CipherKey_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/CipherKeyImpl.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class Crypto_API CipherKey
+	/// CipherKey stores the key information for decryption/encryption of data.
+	/// To create a random key, using the following code:
+	///
+	///     CipherKey key("aes-256");
+	///
+	/// Note that you won't be able to decrypt data encrypted with a random key
+	/// once the Cipher is destroyed unless you persist the generated key and IV.
+	/// An example usage for random keys is to encrypt data saved in a temporary
+	/// file.
+	///
+	/// To create a key using a human-readable password
+	/// string, use the following code. We create a AES Cipher and 
+	/// use a salt value to make the key more robust:
+	///
+	///     std::string password = "secret";
+	///     std::string salt("asdff8723lasdf(**923412");
+	///     CipherKey key("aes-256", password, salt);
+	///
+	/// You may also control the digest and the number of iterations used to generate the key
+	/// by specifying the specific values. Here we create a key with the same data as before,
+	/// except that we use 100 iterations instead of DEFAULT_ITERATION_COUNT, and sha1 instead of
+	/// the default md5:
+	///
+	///     std::string password = "secret";
+	///     std::string salt("asdff8723lasdf(**923412");
+	///     std::string digest ("sha1");
+	///     CipherKey key("aes-256", password, salt, 100, digest);
+	///
+{
+public:
+	typedef CipherKeyImpl::Mode Mode;
+	typedef CipherKeyImpl::ByteVec ByteVec;
+
+	enum
+	{
+		DEFAULT_ITERATION_COUNT = 2000
+			/// Default iteration count to use with
+			/// generateKey(). RSA security recommends
+			/// an iteration count of at least 1000.
+	};
+
+	CipherKey(const std::string& name, 
+		const std::string& passphrase, 
+		const std::string& salt = "",
+		int iterationCount = DEFAULT_ITERATION_COUNT,
+		const std::string& digest = "md5");
+		/// Creates a new CipherKeyImpl object using the given
+		/// cipher name, passphrase, salt value, iteration count and digest.
+
+	CipherKey(const std::string& name, 
+		const ByteVec& key, 
+		const ByteVec& iv);
+		/// Creates a new CipherKeyImpl object using the given cipher
+		/// name, key and initialization vector (IV).
+		///
+		/// The size of the IV must match the cipher's expected
+		/// IV size (see ivSize()), except for GCM mode, which allows
+		/// a custom IV size.
+
+	CipherKey(const std::string& name);
+		/// Creates a new CipherKeyImpl object. Autoinitializes key and 
+		/// initialization vector.
+
+	~CipherKey();
+		/// Destroys the CipherKeyImpl.
+
+	const std::string& name() const;
+		/// Returns the name of the Cipher.
+
+	int keySize() const;
+		/// Returns the key size of the Cipher.
+
+	int blockSize() const;
+		/// Returns the block size of the Cipher.
+
+	int ivSize() const;
+		/// Returns the IV size of the Cipher.
+
+	Mode mode() const;
+		/// Returns the Cipher's mode of operation.
+	
+	const ByteVec& getKey() const;
+		/// Returns the key for the Cipher.
+
+	void setKey(const ByteVec& key);
+		/// Sets the key for the Cipher.
+
+	const ByteVec& getIV() const;
+		/// Returns the initialization vector (IV) for the Cipher.
+
+	void setIV(const ByteVec& iv);
+		/// Sets the initialization vector (IV) for the Cipher.
+		///
+		/// The size of the vector must match the cipher's expected
+		/// IV size (see ivSize()), except for GCM mode, which allows
+		/// a custom IV size.
+
+	CipherKeyImpl::Ptr impl();
+		/// Returns the impl object
+
+private:
+	CipherKeyImpl::Ptr _pImpl;
+};
+
+
+//
+// inlines
+//
+inline const std::string& CipherKey::name() const
+{
+	return _pImpl->name();
+}
+
+
+inline int CipherKey::keySize() const
+{
+	return _pImpl->keySize();
+}
+
+
+inline int CipherKey::blockSize() const
+{
+	return _pImpl->blockSize();
+}
+
+
+inline int CipherKey::ivSize() const
+{
+	return _pImpl->ivSize();
+}
+
+
+inline CipherKey::Mode CipherKey::mode() const
+{
+	return _pImpl->mode();
+}
+
+
+inline const CipherKey::ByteVec& CipherKey::getKey() const
+{
+	return _pImpl->getKey();
+}
+
+
+inline void CipherKey::setKey(const CipherKey::ByteVec& key)
+{
+	_pImpl->setKey(key);
+}
+
+
+inline const CipherKey::ByteVec& CipherKey::getIV() const
+{
+	return _pImpl->getIV();
+}
+
+
+inline void CipherKey::setIV(const CipherKey::ByteVec& iv)
+{
+	_pImpl->setIV(iv);
+}
+
+
+inline CipherKeyImpl::Ptr CipherKey::impl()
+{
+	return _pImpl;
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_CipherKey_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/CipherKeyImpl.h b/base/poco/Crypto/include/Poco/Crypto/CipherKeyImpl.h
new file mode 100644
index 00000000000..f7807aad9f8
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/CipherKeyImpl.h
@@ -0,0 +1,168 @@
+//
+// CipherKeyImpl.h
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CipherKeyImpl
+//
+// Definition of the CipherKeyImpl class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_CipherKeyImpl_INCLUDED
+#define Crypto_CipherKeyImpl_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include <vector>
+
+
+struct evp_cipher_st;
+typedef struct evp_cipher_st EVP_CIPHER;
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class CipherKeyImpl: public RefCountedObject
+	/// An implementation of the CipherKey class for OpenSSL's crypto library.
+{
+public:
+	typedef std::vector<unsigned char> ByteVec;
+	typedef Poco::AutoPtr<CipherKeyImpl> Ptr;
+
+	enum Mode
+		/// Cipher mode of operation. This mode determines how multiple blocks
+		/// are connected; this is essential to improve security.
+	{
+		MODE_STREAM_CIPHER,	/// Stream cipher
+		MODE_ECB,			/// Electronic codebook (plain concatenation)
+		MODE_CBC,			/// Cipher block chaining (default)
+		MODE_CFB,			/// Cipher feedback
+		MODE_OFB,			/// Output feedback
+		MODE_CTR,           /// Counter mode
+		MODE_GCM,           /// Galois/Counter mode
+		MODE_CCM            /// Counter with CBC-MAC
+	};
+
+	CipherKeyImpl(const std::string& name,
+		const std::string& passphrase,
+		const std::string& salt,
+		int iterationCount,
+		const std::string& digest);
+		/// Creates a new CipherKeyImpl object, using
+		/// the given cipher name, passphrase, salt value
+		/// and iteration count.
+
+	CipherKeyImpl(const std::string& name,
+		const ByteVec& key,
+		const ByteVec& iv);
+		/// Creates a new CipherKeyImpl object, using the
+		/// given cipher name, key and initialization vector.
+
+	CipherKeyImpl(const std::string& name);
+		/// Creates a new CipherKeyImpl object. Autoinitializes key
+		/// and initialization vector.
+
+	virtual ~CipherKeyImpl();
+		/// Destroys the CipherKeyImpl.
+
+	const std::string& name() const;
+		/// Returns the name of the Cipher.
+
+	int keySize() const;
+		/// Returns the key size of the Cipher.
+
+	int blockSize() const;
+		/// Returns the block size of the Cipher.
+
+	int ivSize() const;
+		/// Returns the IV size of the Cipher.
+
+	Mode mode() const;
+		/// Returns the Cipher's mode of operation.
+
+	const ByteVec& getKey() const;
+		/// Returns the key for the Cipher.
+
+	void setKey(const ByteVec& key);
+		/// Sets the key for the Cipher.
+
+	const ByteVec& getIV() const;
+		/// Returns the initialization vector (IV) for the Cipher.
+
+	void setIV(const ByteVec& iv);
+		/// Sets the initialization vector (IV) for the Cipher.
+
+	const EVP_CIPHER* cipher();
+		/// Returns the cipher object
+
+private:
+	void generateKey(const std::string& passphrase,
+		const std::string& salt,
+		int iterationCount);
+	 	/// Generates key and IV from a password and optional salt string.
+
+	void generateKey();
+		/// Generates key and IV from random data.
+
+	void getRandomBytes(ByteVec& vec, std::size_t count);
+		/// Stores random bytes in vec.
+
+private:
+	const EVP_CIPHER*  _pCipher;
+	const EVP_MD*      _pDigest;
+	std::string	       _name;
+	ByteVec		       _key;
+	ByteVec		       _iv;
+	OpenSSLInitializer _openSSLInitializer;
+};
+
+
+//
+// Inlines
+//
+inline const std::string& CipherKeyImpl::name() const
+{
+	return _name;
+}
+
+
+inline const CipherKeyImpl::ByteVec& CipherKeyImpl::getKey() const
+{
+	return _key;
+}
+
+
+inline void CipherKeyImpl::setKey(const ByteVec& key)
+{
+	poco_assert(key.size() == static_cast<ByteVec::size_type>(keySize()));
+	_key = key;
+}
+
+
+inline const CipherKeyImpl::ByteVec& CipherKeyImpl::getIV() const
+{
+	return _iv;
+}
+
+
+inline const EVP_CIPHER* CipherKeyImpl::cipher()
+{
+	return _pCipher;
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_CipherKeyImpl_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/Crypto.h b/base/poco/Crypto/include/Poco/Crypto/Crypto.h
new file mode 100644
index 00000000000..d6b3ede65cb
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/Crypto.h
@@ -0,0 +1,195 @@
+//
+// Crypto.h
+//
+// Library: Crypto
+// Package: CryptoCore
+// Module:  Crypto
+//
+// Basic definitions for the Poco Crypto library.
+// This file must be the first file included by every other Crypto
+// header file.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_Crypto_INCLUDED
+#define Crypto_Crypto_INCLUDED
+
+
+#define POCO_EXTERNAL_OPENSSL_DEFAULT 1
+#define POCO_EXTERNAL_OPENSSL_SLPRO 2
+
+
+#include "Poco/Foundation.h"
+#include <openssl/opensslv.h>
+
+
+#ifndef OPENSSL_VERSION_PREREQ
+	#if defined(OPENSSL_VERSION_MAJOR) && defined(OPENSSL_VERSION_MINOR)
+		#define OPENSSL_VERSION_PREREQ(maj, min) \
+			((OPENSSL_VERSION_MAJOR << 16) + OPENSSL_VERSION_MINOR >= ((maj) << 16) + (min))
+	#else
+		#define OPENSSL_VERSION_PREREQ(maj, min) \
+			(OPENSSL_VERSION_NUMBER >= (((maj) << 28) | ((min) << 20)))
+	#endif
+#endif
+
+
+enum RSAPaddingMode
+	/// The padding mode used for RSA public key encryption.
+{
+	RSA_PADDING_PKCS1,
+		/// PKCS #1 v1.5 padding. This currently is the most widely used mode. 
+		
+	RSA_PADDING_PKCS1_OAEP,
+		/// EME-OAEP as defined in PKCS #1 v2.0 with SHA-1, MGF1 and an empty 
+		/// encoding parameter. This mode is recommended for all new applications.
+		
+	RSA_PADDING_SSLV23,
+		/// PKCS #1 v1.5 padding with an SSL-specific modification that denotes 
+		/// that the server is SSL3 capable. 
+		
+	RSA_PADDING_NONE
+		/// Raw RSA encryption. This mode should only be used to implement cryptographically 
+		/// sound padding modes in the application code. Encrypting user data directly with RSA 
+		/// is insecure. 
+};
+
+
+//
+// The following block is the standard way of creating macros which make exporting
+// from a DLL simpler. All files within this DLL are compiled with the Crypto_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any project
+// that uses this DLL. This way any other project whose source files include this file see
+// Crypto_API functions as being imported from a DLL, whereas this DLL sees symbols
+// defined with this macro as being exported.
+//
+#if defined(_WIN32)
+	#if defined(POCO_DLL)
+		#if defined(Crypto_EXPORTS)
+			#define Crypto_API __declspec(dllexport)
+		#else
+			#define Crypto_API __declspec(dllimport)
+		#endif
+	#endif
+#endif
+
+
+#if !defined(Crypto_API)
+	#if !defined(POCO_NO_GCC_API_ATTRIBUTE) && defined (__GNUC__) && (__GNUC__ >= 4)
+		#define Crypto_API __attribute__ ((visibility ("default")))
+	#else
+		#define Crypto_API
+	#endif
+#endif
+
+
+//
+// Automatically link Crypto and OpenSSL libraries.
+//
+#if defined(_MSC_VER)
+	#if !defined(POCO_NO_AUTOMATIC_LIBS)
+		#if defined(POCO_INTERNAL_OPENSSL_MSVC_VER)
+			#if defined(POCO_EXTERNAL_OPENSSL)
+				#pragma message("External OpenSSL defined but internal headers used - possible mismatch!")
+			#endif // POCO_EXTERNAL_OPENSSL
+			#if !defined(_DEBUG)
+				#define POCO_DEBUG_SUFFIX ""
+				#if !defined (_DLL)
+					#define POCO_STATIC_SUFFIX "mt"
+				#else // _DLL
+					#define POCO_STATIC_SUFFIX ""
+				#endif
+			#else // _DEBUG
+				#define POCO_DEBUG_SUFFIX "d"
+				#if !defined (_DLL)
+					#define POCO_STATIC_SUFFIX "mt"
+				#else // _DLL
+					#define POCO_STATIC_SUFFIX ""
+				#endif
+			#endif
+			#pragma comment(lib, "libcrypto" POCO_STATIC_SUFFIX POCO_DEBUG_SUFFIX ".lib")
+			#pragma comment(lib, "libssl" POCO_STATIC_SUFFIX POCO_DEBUG_SUFFIX ".lib")
+			#if !defined(_WIN64) && !defined (_DLL) && \
+						(POCO_INTERNAL_OPENSSL_MSVC_VER == 120) && \
+						(POCO_MSVC_VERSION < POCO_INTERNAL_OPENSSL_MSVC_VER)
+				#pragma comment(lib, "libPreVS2013CRT" POCO_STATIC_SUFFIX POCO_DEBUG_SUFFIX ".lib")
+			#endif
+			#if !defined (_DLL) && (POCO_MSVS_VERSION >= 2015)
+				#pragma comment(lib, "legacy_stdio_definitions.lib")
+				#pragma comment(lib, "legacy_stdio_wide_specifiers.lib")
+			#endif
+		#elif defined(POCO_EXTERNAL_OPENSSL)
+			#if POCO_EXTERNAL_OPENSSL == POCO_EXTERNAL_OPENSSL_SLPRO
+				#if defined(POCO_DLL)
+					#if OPENSSL_VERSION_PREREQ(1,1)
+						#pragma comment(lib, "libcrypto.lib")
+						#pragma comment(lib, "libssl.lib")
+					#else
+						#pragma comment(lib, "libeay32.lib")
+						#pragma comment(lib, "ssleay32.lib")
+					#endif
+			  	#else
+					#if OPENSSL_VERSION_PREREQ(1,1)
+						#if defined(_WIN64)
+							#pragma comment(lib, "libcrypto64" POCO_LIB_SUFFIX)
+							#pragma comment(lib, "libssl64" POCO_LIB_SUFFIX)
+						#else
+							#pragma comment(lib, "libcrypto32" POCO_LIB_SUFFIX)
+							#pragma comment(lib, "libssl32" POCO_LIB_SUFFIX)
+						#endif
+					#else
+						#pragma comment(lib, "libeay32" POCO_LIB_SUFFIX)
+						#pragma comment(lib, "ssleay32" POCO_LIB_SUFFIX)
+					#endif
+				#endif
+			#elif POCO_EXTERNAL_OPENSSL == POCO_EXTERNAL_OPENSSL_DEFAULT
+				#if OPENSSL_VERSION_PREREQ(1,1)
+					#pragma comment(lib, "libcrypto.lib")
+					#pragma comment(lib, "libssl.lib")
+				#else
+					#pragma comment(lib, "libeay32.lib")
+					#pragma comment(lib, "ssleay32.lib")
+				#endif
+			#endif
+		#endif // POCO_INTERNAL_OPENSSL_MSVC_VER
+		#if !defined(Crypto_EXPORTS)
+			#pragma comment(lib, "PocoCrypto" POCO_LIB_SUFFIX)
+		#endif
+	#endif // POCO_NO_AUTOMATIC_LIBS
+#endif
+
+
+namespace Poco {
+namespace Crypto {
+
+
+void Crypto_API initializeCrypto();
+	/// Initialize the Crypto library, as well as the underlying OpenSSL
+	/// libraries, by calling OpenSSLInitializer::initialize().
+	///
+	/// Should be called before using any class from the Crypto library.
+	/// The Crypto library will be initialized automatically, through
+	/// OpenSSLInitializer instances held by various Crypto classes
+	/// (Cipher, CipherKey, RSAKey, X509Certificate).
+	/// However, it is recommended to call initializeCrypto()
+	/// in any case at application startup.
+	///
+	/// Can be called multiple times; however, for every call to
+	/// initializeCrypto(), a matching call to uninitializeCrypto()
+	/// must be performed.
+
+
+void Crypto_API uninitializeCrypto();
+	/// Uninitializes the Crypto library by calling
+	/// OpenSSLInitializer::uninitialize().
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_Crypto_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/CryptoException.h b/base/poco/Crypto/include/Poco/Crypto/CryptoException.h
new file mode 100644
index 00000000000..34c15111e6a
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/CryptoException.h
@@ -0,0 +1,56 @@
+//
+// CryptoException.h
+//
+//
+// Library: Crypto
+// Package: Crypto
+// Module:  CryptoException
+//
+// Definition of the CryptoException class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_CryptoException_INCLUDED
+#define Crypto_CryptoException_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+POCO_DECLARE_EXCEPTION(Crypto_API, CryptoException, Poco::Exception)
+
+
+class Crypto_API OpenSSLException : public CryptoException
+{
+public:
+	OpenSSLException(int code = 0);
+	OpenSSLException(const std::string& msg, int code = 0);
+	OpenSSLException(const std::string& msg, const std::string& arg, int code = 0);
+	OpenSSLException(const std::string& msg, const Poco::Exception& exc, int code = 0);
+	OpenSSLException(const OpenSSLException& exc);
+	~OpenSSLException() throw();
+	OpenSSLException& operator = (const OpenSSLException& exc);
+	const char* name() const throw();
+	const char* className() const throw();
+	Poco::Exception* clone() const;
+	void rethrow() const;
+
+private:
+	void setExtMessage();
+};
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_CryptoException_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/CryptoStream.h b/base/poco/Crypto/include/Poco/Crypto/CryptoStream.h
new file mode 100644
index 00000000000..25a99a4ae58
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/CryptoStream.h
@@ -0,0 +1,192 @@
+//
+// CryptoStream.h
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CryptoStream
+//
+// Definition of the CryptoStreamBuf, CryptoInputStream and CryptoOutputStream
+// classes.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_CryptoStream_INCLUDED
+#define Crypto_CryptoStream_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/BufferedStreamBuf.h"
+#include "Poco/Buffer.h"
+#include <iostream>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class CryptoTransform;
+class Cipher;
+
+
+class Crypto_API CryptoStreamBuf: public Poco::BufferedStreamBuf
+	/// This stream buffer performs cryptographic transformation on the data
+	/// going through it.
+{
+public:
+	CryptoStreamBuf(std::istream& istr, CryptoTransform* pTransform, std::streamsize bufferSize = 8192);
+	CryptoStreamBuf(std::ostream& ostr, CryptoTransform* pTransform, std::streamsize bufferSize = 8192);
+
+	virtual ~CryptoStreamBuf();
+
+	void close();
+		/// Flushes all buffers and finishes the encryption.
+
+protected:
+	int readFromDevice(char* buffer, std::streamsize length);
+	int writeToDevice(const char* buffer, std::streamsize length);
+
+private:
+	CryptoTransform* _pTransform;
+	std::istream*	 _pIstr;
+	std::ostream*	 _pOstr;
+	bool			 _eof;
+
+	Poco::Buffer<unsigned char> _buffer;
+
+	CryptoStreamBuf(const CryptoStreamBuf&);
+	CryptoStreamBuf& operator = (const CryptoStreamBuf&);
+};
+
+
+class Crypto_API CryptoIOS: public virtual std::ios
+	/// The base class for CryptoInputStream and CryptoOutputStream.
+	///
+	/// This class is needed to ensure correct initialization order of the
+	/// stream buffer and base classes.
+{
+public:
+	CryptoIOS(std::istream& istr, CryptoTransform* pTransform, std::streamsize bufferSize = 8192);
+	CryptoIOS(std::ostream& ostr, CryptoTransform* pTransform, std::streamsize bufferSize = 8192);
+	~CryptoIOS();
+	CryptoStreamBuf* rdbuf();
+
+protected:
+	CryptoStreamBuf _buf;
+};
+
+
+class Crypto_API CryptoInputStream: public CryptoIOS, public std::istream
+	/// This stream transforms all data passing through it using the given
+	/// CryptoTransform.
+	///
+	/// Use a CryptoTransform object provided by Cipher::createEncrytor() or
+	/// Cipher::createDecryptor() to create an encrypting or decrypting stream,
+	/// respectively.
+{
+public:
+	CryptoInputStream(std::istream& istr, CryptoTransform* pTransform, std::streamsize bufferSize = 8192);
+		/// Create a new CryptoInputStream object. The CryptoInputStream takes the
+		/// ownership of the given CryptoTransform object.
+
+	CryptoInputStream(std::istream& istr, Cipher& cipher, std::streamsize bufferSize = 8192);
+		/// Create a new encrypting CryptoInputStream object using the given cipher.
+
+	~CryptoInputStream();
+		/// Destroys the CryptoInputStream.
+};
+
+
+class Crypto_API CryptoOutputStream: public CryptoIOS, public std::ostream
+	/// This stream transforms all data passing through it using the given
+	/// CryptoTransform.
+	///
+	/// Use a CryptoTransform object provided by Cipher::createEncrytor() or
+	/// Cipher::createDecryptor() to create an encrypting or decrypting stream,
+	/// respectively.
+	///
+	/// After all data has been passed through the stream, close() must be called
+	/// to ensure completion of cryptographic transformation.
+{
+public:
+	CryptoOutputStream(std::ostream& ostr, CryptoTransform* pTransform, std::streamsize bufferSize = 8192);
+		/// Create a new CryptoOutputStream object. The CryptoOutputStream takes the
+		/// ownership of the given CryptoTransform object.
+
+	CryptoOutputStream(std::ostream& ostr, Cipher& cipher, std::streamsize bufferSize = 8192);
+		/// Create a new decrypting CryptoOutputStream object using the given cipher.
+
+	~CryptoOutputStream();
+		/// Destroys the CryptoOutputStream.
+
+	void close();
+		/// Flushes all buffers and finishes the encryption.
+};
+
+
+class Crypto_API DecryptingInputStream: public CryptoIOS, public std::istream
+	/// This stream decrypts all data passing through it using the given
+	/// Cipher.
+{
+public:
+	DecryptingInputStream(std::istream& istr, Cipher& cipher, std::streamsize bufferSize = 8192);
+		/// Create a new DecryptingInputStream object using the given cipher.
+
+	~DecryptingInputStream();
+		/// Destroys the DecryptingInputStream.
+};
+
+
+class Crypto_API DecryptingOutputStream: public CryptoIOS, public std::ostream
+	/// This stream decrypts all data passing through it using the given
+	/// Cipher.
+{
+public:
+	DecryptingOutputStream(std::ostream& ostr, Cipher& cipher, std::streamsize bufferSize = 8192);
+		/// Create a new DecryptingOutputStream object using the given cipher.
+
+	~DecryptingOutputStream();
+		/// Destroys the DecryptingOutputStream.
+
+	void close();
+		/// Flushes all buffers and finishes the decryption.
+};
+
+
+class Crypto_API EncryptingInputStream: public CryptoIOS, public std::istream
+	/// This stream encrypts all data passing through it using the given
+	/// Cipher.
+{
+public:
+	EncryptingInputStream(std::istream& istr, Cipher& cipher, std::streamsize bufferSize = 8192);
+		/// Create a new EncryptingInputStream object using the given cipher.
+
+	~EncryptingInputStream();
+		/// Destroys the EncryptingInputStream.
+};
+
+
+class Crypto_API EncryptingOutputStream: public CryptoIOS, public std::ostream
+	/// This stream encrypts all data passing through it using the given
+	/// Cipher.
+{
+public:
+	EncryptingOutputStream(std::ostream& ostr, Cipher& cipher, std::streamsize bufferSize = 8192);
+		/// Create a new EncryptingOutputStream object using the given cipher.
+
+	~EncryptingOutputStream();
+		/// Destroys the EncryptingOutputStream.
+
+	void close();
+		/// Flushes all buffers and finishes the encryption.
+};
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_CryptoStream_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/CryptoTransform.h b/base/poco/Crypto/include/Poco/Crypto/CryptoTransform.h
new file mode 100644
index 00000000000..9fa3806c653
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/CryptoTransform.h
@@ -0,0 +1,87 @@
+//
+// CryptoTransform.h
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CryptoTransform
+//
+// Definition of the CryptoTransform class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_CryptoTransform_INCLUDED
+#define Crypto_CryptoTransform_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include <ios>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class Crypto_API CryptoTransform
+	/// This interface represents the basic operations for cryptographic
+	/// transformations to be used with a CryptoInputStream or a
+	/// CryptoOutputStream.
+	///
+	/// Implementations of this class are returned by the Cipher class to
+	/// perform encryption or decryption of data.
+{
+public:
+	CryptoTransform();
+		/// Creates a new CryptoTransform object.
+
+	virtual ~CryptoTransform();
+		/// Destroys the CryptoTransform.
+
+	virtual std::size_t blockSize() const = 0;
+		/// Returns the block size for this CryptoTransform.
+
+	virtual int setPadding(int padding);
+		/// Enables or disables padding. By default encryption operations are padded using standard block
+		/// padding and the padding is checked and removed when decrypting. If the padding parameter is zero then
+		/// no padding is performed, the total amount of data encrypted or decrypted must then be a multiple of
+		/// the block size or an error will occur.
+
+	virtual std::string getTag(std::size_t tagSize = 16) = 0;
+		/// Returns the GCM tag after encrypting using GCM mode.
+		///
+		/// Must be called after finalize().
+
+	virtual void setTag(const std::string& tag) = 0;
+		/// Sets the GCM tag for authenticated decryption using GCM mode.
+		///
+		/// Must be set before finalize() is called, otherwise
+		/// decryption will fail.
+
+	virtual std::streamsize transform(
+		const unsigned char* input,
+		std::streamsize		 inputLength,
+		unsigned char*		 output,
+		std::streamsize		 outputLength) = 0;
+		/// Transforms a chunk of data. The inputLength is arbitrary and does not
+		/// need to be a multiple of the block size. The output buffer has a maximum
+		/// capacity of the given outputLength that must be at least
+		///   inputLength + blockSize() - 1
+		/// Returns the number of bytes written to the output buffer.
+
+	virtual std::streamsize finalize(unsigned char* output, std::streamsize length) = 0;
+		/// Finalizes the transformation. The output buffer must contain enough
+		/// space for at least two blocks, ie.
+		///   length >= 2*blockSize()
+		/// must be true.  Returns the number of bytes written to the output
+		/// buffer.
+};
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_CryptoTransform_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/DigestEngine.h b/base/poco/Crypto/include/Poco/Crypto/DigestEngine.h
new file mode 100644
index 00000000000..1c30e769d5f
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/DigestEngine.h
@@ -0,0 +1,80 @@
+//
+// DigestEngine.h
+//
+// Library: Crypto
+// Package: Digest
+// Module:  DigestEngine
+//
+// Definition of the DigestEngine class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_DigestEngine_INCLUDED
+#define Crypto_DigestEngine_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include "Poco/DigestEngine.h"
+#include <openssl/evp.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class Crypto_API DigestEngine: public Poco::DigestEngine
+	/// This class implements a Poco::DigestEngine for all
+	/// digest algorithms supported by OpenSSL.
+{
+public:
+	DigestEngine(const std::string& name);
+		/// Creates a DigestEngine using the digest with the given name
+		/// (e.g., "MD5", "SHA1", "SHA256", "SHA512", etc.).
+		/// See the OpenSSL documentation for a list of supported digest algorithms.
+		///
+		/// Throws a Poco::NotFoundException if no algorithm with the given name exists.
+
+	~DigestEngine();
+		/// Destroys the DigestEngine.
+
+	const std::string& algorithm() const;
+		/// Returns the name of the digest algorithm.
+
+	int nid() const;
+		/// Returns the NID (OpenSSL object identifier) of the digest algorithm.
+
+	// DigestEngine
+	std::size_t digestLength() const;
+	void reset();
+	const Poco::DigestEngine::Digest& digest();
+
+protected:
+	void updateImpl(const void* data, std::size_t length);
+
+private:
+	std::string _name;
+	EVP_MD_CTX* _pContext;
+	Poco::DigestEngine::Digest _digest;
+	OpenSSLInitializer _openSSLInitializer;
+};
+
+
+//
+// inlines
+//
+inline const std::string& DigestEngine::algorithm() const
+{
+	return _name;
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_DigestEngine_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/ECDSADigestEngine.h b/base/poco/Crypto/include/Poco/Crypto/ECDSADigestEngine.h
new file mode 100644
index 00000000000..ed6fab442f6
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/ECDSADigestEngine.h
@@ -0,0 +1,101 @@
+//
+// ECDSADigestEngine.h
+//
+//
+// Library: Crypto
+// Package: ECDSA
+// Module:  ECDSADigestEngine
+//
+// Definition of the ECDSADigestEngine class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_ECDSADigestEngine_INCLUDED
+#define Crypto_ECDSADigestEngine_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/ECKey.h"
+#include "Poco/DigestEngine.h"
+#include "Poco/Crypto/DigestEngine.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class Crypto_API ECDSADigestEngine: public Poco::DigestEngine
+	/// This class implements a Poco::DigestEngine that can be
+	/// used to compute a secure digital signature.
+	///
+	/// First another Poco::Crypto::DigestEngine is created and
+	/// used to compute a cryptographic hash of the data to be
+	/// signed. Then, the hash value is encrypted, using
+	/// the ECDSA private key.
+	///
+	/// To verify a signature, pass it to the verify() 
+	/// member function. It will decrypt the signature
+	/// using the ECDSA public key and compare the resulting
+	/// hash with the actual hash of the data.
+{
+public:
+
+	ECDSADigestEngine(const ECKey& key, const std::string &name);
+		/// Creates the ECDSADigestEngine with the given ECDSA key,
+		/// using the hash algorithm with the given name
+		/// (e.g., "SHA1", "SHA256", "SHA512", etc.).
+		/// See the OpenSSL documentation for a list of supported digest algorithms.
+		///
+		/// Throws a Poco::NotFoundException if no algorithm with the given name exists.
+
+	~ECDSADigestEngine();
+		/// Destroys the ECDSADigestEngine.
+
+	std::size_t digestLength() const;
+		/// Returns the length of the digest in bytes.
+
+	void reset();
+		/// Resets the engine so that a new
+		/// digest can be computed.
+		
+	const DigestEngine::Digest& digest();
+		/// Finishes the computation of the digest 
+		/// (the first time it's called) and
+		/// returns the message digest. 
+		///
+		/// Can be called multiple times.
+
+	const DigestEngine::Digest& signature();
+		/// Signs the digest using the ECDSADSA algorithm
+		/// and the private key (the first time it's
+		/// called) and returns the result.
+		///
+		/// Can be called multiple times.
+
+	bool verify(const DigestEngine::Digest& signature);
+		/// Verifies the data against the signature.
+		///
+		/// Returns true if the signature can be verified, false otherwise.
+
+protected:
+	void updateImpl(const void* data, std::size_t length);
+
+private:
+	ECKey _key;
+	Poco::Crypto::DigestEngine _engine;
+	Poco::DigestEngine::Digest _digest;
+	Poco::DigestEngine::Digest _signature;
+};
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_ECDSADigestEngine_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/ECKey.h b/base/poco/Crypto/include/Poco/Crypto/ECKey.h
new file mode 100644
index 00000000000..14f2ac0a189
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/ECKey.h
@@ -0,0 +1,136 @@
+//
+// ECKey.h
+//
+//
+// Library: Crypto
+// Package: EC
+// Module:  ECKey
+//
+// Definition of the ECKey class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_ECKey_INCLUDED
+#define Crypto_ECKey_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/KeyPair.h"
+#include "Poco/Crypto/ECKeyImpl.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class X509Certificate;
+class PKCS12Container;
+
+
+class Crypto_API ECKey : public KeyPair
+	/// This class stores an EC key pair, consisting
+	/// of private and public key. Storage of the private
+	/// key is optional.
+	///
+	/// If a private key is available, the ECKey can be
+	/// used for decrypting data (encrypted with the public key)
+	/// or computing secure digital signatures.
+{
+public:
+	ECKey(const EVPPKey& key);
+		/// Constructs ECKeyImpl by extracting the EC key.
+
+	ECKey(const X509Certificate& cert);
+		/// Extracts the EC public key from the given certificate.
+
+	ECKey(const PKCS12Container& cert);
+		/// Extracts the EC private key from the given certificate.
+
+	ECKey(const std::string& eccGroup);
+		/// Creates the ECKey. Creates a new public/private keypair using the given parameters.
+		/// Can be used to sign data and verify signatures.
+
+	ECKey(const std::string& publicKeyFile, const std::string& privateKeyFile, const std::string& privateKeyPassphrase = "");
+		/// Creates the ECKey, by reading public and private key from the given files and
+		/// using the given passphrase for the private key.
+		///
+		/// Cannot be used for signing or decryption unless a private key is available.
+		///
+		/// If a private key is specified, you don't need to specify a public key file.
+		/// OpenSSL will auto-create the public key from the private key.
+
+	ECKey(std::istream* pPublicKeyStream, std::istream* pPrivateKeyStream = 0, const std::string& privateKeyPassphrase = "");
+		/// Creates the ECKey, by reading public and private key from the given streams and
+		/// using the given passphrase for the private key.
+		///
+		/// Cannot be used for signing or decryption unless a private key is available.
+		///
+		/// If a private key is specified, you don't need to specify a public key file.
+		/// OpenSSL will auto-create the public key from the private key.
+
+	~ECKey();
+		/// Destroys the ECKey.
+
+	ECKeyImpl::Ptr impl() const;
+		/// Returns the impl object.
+
+	static std::string getCurveName(int nid = -1);
+		/// Returns elliptical curve name corresponding to
+		/// the given nid; if nid is not found, returns
+		/// empty string.
+		///
+		/// If nid is -1, returns first curve name.
+		///
+		/// If no curves are found, returns empty string;
+
+	static int getCurveNID(std::string& name);
+		/// Returns the NID of the specified curve.
+		///
+		/// If name is empty, returns the first curve NID
+		/// and updates the name accordingly.
+
+	static bool hasCurve(const std::string& name);
+		/// Returns true if the named curve is found,
+		/// false otherwise.
+
+private:
+	ECKeyImpl::Ptr _pImpl;
+};
+
+
+//
+// inlines
+//
+inline ECKeyImpl::Ptr ECKey::impl() const
+{
+	return _pImpl;
+}
+
+
+inline std::string ECKey::getCurveName(int nid)
+{
+	return ECKeyImpl::getCurveName(nid);
+}
+
+
+inline int ECKey::getCurveNID(std::string& name)
+{
+	return ECKeyImpl::getCurveNID(name);
+}
+
+
+inline bool ECKey::hasCurve(const std::string& name)
+{
+	return ECKeyImpl::hasCurve(name);
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_ECKey_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/ECKeyImpl.h b/base/poco/Crypto/include/Poco/Crypto/ECKeyImpl.h
new file mode 100644
index 00000000000..840764304d1
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/ECKeyImpl.h
@@ -0,0 +1,174 @@
+//
+// ECKeyImpl.h
+//
+//
+// Library: Crypto
+// Package: EC
+// Module:  ECKeyImpl
+//
+// Definition of the ECKeyImpl class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_ECKeyImplImpl_INCLUDED
+#define Crypto_ECKeyImplImpl_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/EVPPKey.h"
+#include "Poco/Crypto/KeyPairImpl.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include <istream>
+#include <ostream>
+#include <vector>
+#include <openssl/objects.h>
+#include <openssl/ec.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class X509Certificate;
+class PKCS12Container;
+
+
+class ECKeyImpl: public KeyPairImpl
+	/// Elliptic Curve key clas implementation.
+{
+public:
+	typedef Poco::AutoPtr<ECKeyImpl> Ptr;
+	typedef std::vector<unsigned char> ByteVec;
+
+	ECKeyImpl(const EVPPKey& key);
+		/// Constructs ECKeyImpl by extracting the EC key.
+
+	ECKeyImpl(const X509Certificate& cert);
+		/// Constructs ECKeyImpl by extracting the EC public key from the given certificate.
+
+	ECKeyImpl(const PKCS12Container& cert);
+		/// Constructs ECKeyImpl by extracting the EC private key from the given certificate.
+
+	ECKeyImpl(int eccGroup);
+		/// Creates the ECKey of the specified group. Creates a new public/private keypair using the given parameters.
+		/// Can be used to sign data and verify signatures.
+
+	ECKeyImpl(const std::string& publicKeyFile, const std::string& privateKeyFile, const std::string& privateKeyPassphrase);
+		/// Creates the ECKey, by reading public and private key from the given files and
+		/// using the given passphrase for the private key. Can only by used for signing if 
+		/// a private key is available. 
+
+	ECKeyImpl(std::istream* pPublicKeyStream, std::istream* pPrivateKeyStream, const std::string& privateKeyPassphrase);
+		/// Creates the ECKey. Can only by used for signing if pPrivKey
+		/// is not null. If a private key file is specified, you don't need to
+		/// specify a public key file. OpenSSL will auto-create it from the private key.
+
+	~ECKeyImpl();
+		/// Destroys the ECKeyImpl.
+
+	EC_KEY* getECKey();
+		/// Returns the OpenSSL EC key.
+
+	const EC_KEY* getECKey() const;
+		/// Returns the OpenSSL EC key.
+
+	int size() const;
+		/// Returns the EC key length in bits.
+
+	int groupId() const;
+		/// Returns the EC key group integer Id.
+
+	std::string groupName() const;
+		/// Returns the EC key group name.
+
+	void save(const std::string& publicKeyFile,
+		const std::string& privateKeyFile = "",
+		const std::string& privateKeyPassphrase = "") const;
+		/// Exports the public and private keys to the given files. 
+		///
+		/// If an empty filename is specified, the corresponding key
+		/// is not exported.
+
+	void save(std::ostream* pPublicKeyStream,
+		std::ostream* pPrivateKeyStream = 0,
+		const std::string& privateKeyPassphrase = "") const;
+		/// Exports the public and private key to the given streams.
+		///
+		/// If a null pointer is passed for a stream, the corresponding
+		/// key is not exported.
+
+	static std::string getCurveName(int nid = -1);
+		/// Returns elliptical curve name corresponding to
+		/// the given nid; if nid is not found, returns
+		/// empty string.
+		///
+		/// If nid is -1, returns first curve name.
+		///
+		/// If no curves are found, returns empty string;
+
+	static int getCurveNID(std::string& name);
+		/// Returns the NID of the specified curve.
+		///
+		/// If name is empty, returns the first curve NID
+		/// and updates the name accordingly.
+
+	static bool hasCurve(const std::string& name);
+		/// Returns true if the named curve is found,
+		/// false otherwise.
+
+private:
+	void checkEC(const std::string& method, const std::string& func) const;
+	void freeEC();
+
+	EC_KEY* _pEC;
+};
+
+
+//
+// inlines
+//
+inline EC_KEY* ECKeyImpl::getECKey()
+{
+	return _pEC;
+}
+
+
+inline const EC_KEY* ECKeyImpl::getECKey() const
+{
+	return _pEC;
+}
+
+
+inline std::string ECKeyImpl::groupName() const
+{
+	return OBJ_nid2sn(groupId());
+}
+
+
+inline void ECKeyImpl::save(const std::string& publicKeyFile,
+	const std::string& privateKeyFile,
+	const std::string& privateKeyPassphrase) const
+{
+	EVPPKey(_pEC).save(publicKeyFile, privateKeyFile, privateKeyPassphrase);
+}
+
+
+inline void ECKeyImpl::save(std::ostream* pPublicKeyStream,
+	std::ostream* pPrivateKeyStream,
+	const std::string& privateKeyPassphrase) const
+{
+	EVPPKey(_pEC).save(pPublicKeyStream, pPrivateKeyStream, privateKeyPassphrase);
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_ECKeyImplImpl_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/EVPPKey.h b/base/poco/Crypto/include/Poco/Crypto/EVPPKey.h
new file mode 100644
index 00000000000..fbcdad5b19c
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/EVPPKey.h
@@ -0,0 +1,354 @@
+//
+// EVPPKey.h
+//
+//
+// Library: Crypto
+// Package: CryptoCore
+// Module:  EVPPKey
+//
+// Definition of the EVPPKey class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_EVPPKeyImpl_INCLUDED
+#define Crypto_EVPPKeyImpl_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/CryptoException.h"
+#include "Poco/StreamCopier.h"
+#include <openssl/ec.h>
+#include <openssl/rsa.h>
+#include <openssl/evp.h>
+#include <openssl/pem.h>
+#include <sstream>
+#include <typeinfo>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class ECKey;
+class RSAKey;
+
+
+class Crypto_API EVPPKey
+	/// Utility class for conversion of native keys to EVP.
+	/// Currently, only RSA and EC keys are supported.
+{
+public:
+	explicit EVPPKey(const std::string& ecCurveName);
+		/// Constructs EVPPKey from ECC curve name.
+		///
+		/// Only EC keys can be wrapped by an EVPPKey
+		/// created using this constructor.
+
+	explicit EVPPKey(const char* ecCurveName);
+		/// Constructs EVPPKey from ECC curve name.
+		///
+		/// Only EC keys can be wrapped by an EVPPKey
+		/// created using this constructor.
+
+	explicit EVPPKey(EVP_PKEY* pEVPPKey);
+		/// Constructs EVPPKey from EVP_PKEY pointer.
+		/// The content behind the supplied pointer is internally duplicated.
+
+	template<typename K>
+	explicit EVPPKey(K* pKey): _pEVPPKey(EVP_PKEY_new())
+		/// Constructs EVPPKey from a "native" OpenSSL (RSA or EC_KEY),
+		/// or a Poco wrapper (RSAKey, ECKey) key pointer.
+	{
+		if (!_pEVPPKey) throw OpenSSLException();
+		setKey(pKey);
+	}
+
+	EVPPKey(const std::string& publicKeyFile, const std::string& privateKeyFile, const std::string& privateKeyPassphrase = "");
+		/// Creates the EVPPKey, by reading public and private key from the given files and
+		/// using the given passphrase for the private key. Can only by used for signing if
+		/// a private key is available.
+
+	EVPPKey(std::istream* pPublicKeyStream, std::istream* pPrivateKeyStream, const std::string& privateKeyPassphrase = "");
+		/// Creates the EVPPKey. Can only by used for signing if pPrivKey
+		/// is not null. If a private key file is specified, you don't need to
+		/// specify a public key file. OpenSSL will auto-create it from the private key.
+
+	EVPPKey(const EVPPKey& other);
+		/// Copy constructor.
+
+	EVPPKey& operator=(const EVPPKey& other);
+		/// Assignment operator.
+
+#ifdef POCO_ENABLE_CPP11
+
+	EVPPKey(EVPPKey&& other);
+		/// Move constructor.
+
+	EVPPKey& operator=(EVPPKey&& other);
+		/// Assignment move operator.
+
+#endif // POCO_ENABLE_CPP11
+
+	~EVPPKey();
+		/// Destroys the EVPPKey.
+
+	bool operator == (const EVPPKey& other) const;
+		/// Comparison operator.
+		/// Returns true if public key components and parameters
+		/// of the other key are equal to this key.
+		///
+		/// Works as expected when one key contains only public key,
+		/// while the other one contains private (thus also public) key.
+
+	bool operator != (const EVPPKey& other) const;
+		/// Comparison operator.
+		/// Returns true if public key components and parameters
+		/// of the other key are different from this key.
+		///
+		/// Works as expected when one key contains only public key,
+		/// while the other one contains private (thus also public) key.
+
+	void save(const std::string& publicKeyFile, const std::string& privateKeyFile = "", const std::string& privateKeyPassphrase = "") const;
+		/// Exports the public and/or private keys to the given files.
+		///
+		/// If an empty filename is specified, the corresponding key
+		/// is not exported.
+
+	void save(std::ostream* pPublicKeyStream, std::ostream* pPrivateKeyStream = 0, const std::string& privateKeyPassphrase = "") const;
+		/// Exports the public and/or private key to the given streams.
+		///
+		/// If a null pointer is passed for a stream, the corresponding
+		/// key is not exported.
+
+	int type() const;
+		/// Retuns the EVPPKey type NID.
+
+	bool isSupported(int type) const;
+		/// Returns true if OpenSSL type is supported
+
+	operator const EVP_PKEY*() const;
+		/// Returns const pointer to the OpenSSL EVP_PKEY structure.
+
+	operator EVP_PKEY*();
+		/// Returns pointer to the OpenSSL EVP_PKEY structure.
+
+	static EVP_PKEY* duplicate(const EVP_PKEY* pFromKey, EVP_PKEY** pToKey);
+		/// Duplicates pFromKey into *pToKey and returns
+		// the pointer to duplicated EVP_PKEY.
+
+private:
+	EVPPKey();
+
+	static int type(const EVP_PKEY* pEVPPKey);
+	void newECKey(const char* group);
+	void duplicate(EVP_PKEY* pEVPPKey);
+
+	void setKey(ECKey* pKey);
+	void setKey(RSAKey* pKey);
+	void setKey(EC_KEY* pKey);
+	void setKey(RSA* pKey);
+	static int passCB(char* buf, int size, int, void* pass);
+
+	typedef EVP_PKEY* (*PEM_read_FILE_Key_fn)(FILE*, EVP_PKEY**, pem_password_cb*, void*);
+	typedef EVP_PKEY* (*PEM_read_BIO_Key_fn)(BIO*, EVP_PKEY**, pem_password_cb*, void*);
+	typedef void* (*EVP_PKEY_get_Key_fn)(EVP_PKEY*);
+
+	// The following load*() functions are used by both native and EVP_PKEY type key
+	// loading from BIO/FILE.
+	// When used for EVP key loading, getFunc is null (ie. native key is not extracted
+	// from the loaded EVP_PKEY).
+	template <typename K, typename F>
+	static bool loadKey(K** ppKey,
+		PEM_read_FILE_Key_fn readFunc,
+		F getFunc,
+		const std::string& keyFile,
+		const std::string& pass = "")
+	{
+		poco_assert_dbg (((typeid(K*) == typeid(RSA*) || typeid(K*) == typeid(EC_KEY*)) && getFunc) ||
+						((typeid(K*) == typeid(EVP_PKEY*)) && !getFunc));
+		poco_check_ptr (ppKey);
+		poco_assert_dbg (!*ppKey);
+
+		FILE* pFile = 0;
+		if (!keyFile.empty())
+		{
+			if (!getFunc) *ppKey = (K*)EVP_PKEY_new();
+			EVP_PKEY* pKey = getFunc ? EVP_PKEY_new() : (EVP_PKEY*)*ppKey;
+			if (pKey)
+			{
+				pFile = fopen(keyFile.c_str(), "r");
+				if (pFile)
+				{
+					pem_password_cb* pCB = pass.empty() ? (pem_password_cb*)0 : &passCB;
+					void* pPassword = pass.empty() ? (void*)0 : (void*)pass.c_str();
+					if (readFunc(pFile, &pKey, pCB, pPassword))
+					{
+						fclose(pFile); pFile = 0;
+						if(getFunc)
+						{
+							*ppKey = (K*)getFunc(pKey);
+							EVP_PKEY_free(pKey);
+						}
+						else
+						{
+							poco_assert_dbg (typeid(K*) == typeid(EVP_PKEY*));
+							*ppKey = (K*)pKey;
+						}
+						if(!*ppKey) goto error;
+						return true;
+					}
+					goto error;
+				}
+				else
+				{
+					if (getFunc) EVP_PKEY_free(pKey);
+					throw IOException("ECKeyImpl, cannot open file", keyFile);
+				}
+			}
+			else goto error;
+		}
+		return false;
+
+	error:
+		if (pFile) fclose(pFile);
+		throw OpenSSLException("EVPKey::loadKey(string)");
+	}
+
+	template <typename K, typename F>
+	static bool loadKey(K** ppKey,
+		PEM_read_BIO_Key_fn readFunc,
+		F getFunc,
+		std::istream* pIstr,
+		const std::string& pass = "")
+	{
+		poco_assert_dbg (((typeid(K*) == typeid(RSA*) || typeid(K*) == typeid(EC_KEY*)) && getFunc) ||
+						((typeid(K*) == typeid(EVP_PKEY*)) && !getFunc));
+		poco_check_ptr(ppKey);
+		poco_assert_dbg(!*ppKey);
+
+		BIO* pBIO = 0;
+		if (pIstr)
+		{
+			std::ostringstream ostr;
+			Poco::StreamCopier::copyStream(*pIstr, ostr);
+			std::string key = ostr.str();
+			pBIO = BIO_new_mem_buf(const_cast<char*>(key.data()), static_cast<int>(key.size()));
+			if (pBIO)
+			{
+				if (!getFunc) *ppKey = (K*)EVP_PKEY_new();
+				EVP_PKEY* pKey = getFunc ? EVP_PKEY_new() : (EVP_PKEY*)*ppKey;
+				if (pKey)
+				{
+					pem_password_cb* pCB = pass.empty() ? (pem_password_cb*)0 : &passCB;
+					void* pPassword = pass.empty() ? (void*)0 : (void*)pass.c_str();
+					if (readFunc(pBIO, &pKey, pCB, pPassword))
+					{
+						BIO_free(pBIO); pBIO = 0;
+						if (getFunc)
+						{
+							*ppKey = (K*)getFunc(pKey);
+							EVP_PKEY_free(pKey);
+						}
+						else
+						{
+							poco_assert_dbg (typeid(K*) == typeid(EVP_PKEY*));
+							*ppKey = (K*)pKey;
+						}
+						if (!*ppKey) goto error;
+						return true;
+					}
+					if (getFunc) EVP_PKEY_free(pKey);
+					goto error;
+				}
+				else goto error;
+			}
+			else goto error;
+		}
+		return false;
+
+	error:
+		if (pBIO) BIO_free(pBIO);
+		throw OpenSSLException("EVPKey::loadKey(stream)");
+	}
+
+	EVP_PKEY* _pEVPPKey;
+
+	friend class ECKeyImpl;
+	friend class RSAKeyImpl;
+};
+
+
+//
+// inlines
+//
+
+
+inline bool EVPPKey::operator == (const EVPPKey& other) const
+{
+	poco_check_ptr (other._pEVPPKey);
+	poco_check_ptr (_pEVPPKey);
+	return (1 == EVP_PKEY_cmp(_pEVPPKey, other._pEVPPKey));
+}
+
+
+inline bool EVPPKey::operator != (const EVPPKey& other) const
+{
+	return !(other == *this);
+}
+
+
+inline int EVPPKey::type(const EVP_PKEY* pEVPPKey)
+{
+	if (!pEVPPKey) return NID_undef;
+
+	return EVP_PKEY_type(EVP_PKEY_id(pEVPPKey));
+}
+
+
+inline int EVPPKey::type() const
+{
+	return type(_pEVPPKey);
+}
+
+
+inline bool EVPPKey::isSupported(int type) const
+{
+	return type == EVP_PKEY_EC || type == EVP_PKEY_RSA;
+}
+
+
+inline EVPPKey::operator const EVP_PKEY*() const
+{
+	return _pEVPPKey;
+}
+
+
+inline EVPPKey::operator EVP_PKEY*()
+{
+	return _pEVPPKey;
+}
+
+
+inline void EVPPKey::setKey(EC_KEY* pKey)
+{
+	if (!EVP_PKEY_set1_EC_KEY(_pEVPPKey, pKey))
+		throw OpenSSLException();
+}
+
+
+inline void EVPPKey::setKey(RSA* pKey)
+{
+	if (!EVP_PKEY_set1_RSA(_pEVPPKey, pKey))
+		throw OpenSSLException();
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_EVPPKeyImpl_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/KeyPair.h b/base/poco/Crypto/include/Poco/Crypto/KeyPair.h
new file mode 100644
index 00000000000..b9a705f8f1b
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/KeyPair.h
@@ -0,0 +1,133 @@
+//
+// KeyPair.h
+//
+//
+// Library: Crypto
+// Package: CryptoCore
+// Module:  KeyPair
+//
+// Definition of the KeyPair class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_KeyPair_INCLUDED
+#define Crypto_KeyPair_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/KeyPairImpl.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class X509Certificate;
+
+
+class Crypto_API KeyPair
+	/// This is a parent class for classes storing a key pair, consisting
+	/// of private and public key. Storage of the private key is optional.
+	///
+	/// If a private key is available, the KeyPair can be
+	/// used for decrypting data (encrypted with the public key)
+	/// or computing secure digital signatures.
+{
+public:
+	enum Type
+	{
+		KT_RSA = KeyPairImpl::KT_RSA_IMPL,
+		KT_EC = KeyPairImpl::KT_EC_IMPL
+	};
+
+	explicit KeyPair(KeyPairImpl::Ptr pKeyPairImpl = 0);
+		/// Extracts the RSA public key from the given certificate.
+
+	virtual ~KeyPair();
+		/// Destroys the KeyPair.
+
+	virtual int size() const;
+		/// Returns the RSA modulus size.
+
+	virtual void save(const std::string& publicKeyPairFile,
+		const std::string& privateKeyPairFile = "",
+		const std::string& privateKeyPairPassphrase = "") const;
+		/// Exports the public and private keys to the given files. 
+		///
+		/// If an empty filename is specified, the corresponding key
+		/// is not exported.
+
+	virtual void save(std::ostream* pPublicKeyPairStream,
+		std::ostream* pPrivateKeyPairStream = 0,
+		const std::string& privateKeyPairPassphrase = "") const;
+		/// Exports the public and private key to the given streams.
+		///
+		/// If a null pointer is passed for a stream, the corresponding
+		/// key is not exported.
+
+	KeyPairImpl::Ptr impl() const;
+		/// Returns the impl object.
+
+	const std::string& name() const;
+		/// Returns key pair name
+
+	Type type() const;
+		/// Returns key pair type
+	
+private:
+	KeyPairImpl::Ptr _pImpl;
+};
+
+
+//
+// inlines
+//
+
+inline int KeyPair::size() const
+{
+	return _pImpl->size();
+}
+
+
+inline void KeyPair::save(const std::string& publicKeyFile,
+	const std::string& privateKeyFile,
+	const std::string& privateKeyPassphrase) const
+{
+	_pImpl->save(publicKeyFile, privateKeyFile, privateKeyPassphrase);
+}
+
+
+inline void KeyPair::save(std::ostream* pPublicKeyStream,
+	std::ostream* pPrivateKeyStream,
+	const std::string& privateKeyPassphrase) const
+{
+	_pImpl->save(pPublicKeyStream, pPrivateKeyStream, privateKeyPassphrase);
+}
+
+
+inline const std::string& KeyPair::name() const
+{
+	return _pImpl->name();
+}
+
+inline KeyPairImpl::Ptr KeyPair::impl() const
+{
+	return _pImpl;
+}
+
+
+inline KeyPair::Type KeyPair::type() const
+{
+	return (KeyPair::Type)impl()->type();
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_KeyPair_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/KeyPairImpl.h b/base/poco/Crypto/include/Poco/Crypto/KeyPairImpl.h
new file mode 100644
index 00000000000..e6320df044b
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/KeyPairImpl.h
@@ -0,0 +1,107 @@
+//
+// KeyPairImpl.h
+//
+//
+// Library: Crypto
+// Package: CryptoCore
+// Module:  KeyPairImpl
+//
+// Definition of the KeyPairImpl class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_KeyPairImplImpl_INCLUDED
+#define Crypto_KeyPairImplImpl_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include <string>
+#include <vector>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class KeyPairImpl: public Poco::RefCountedObject
+	/// Class KeyPairImpl
+{
+public:
+	enum Type
+	{
+		KT_RSA_IMPL = 0,
+		KT_EC_IMPL
+	};
+
+	typedef Poco::AutoPtr<KeyPairImpl> Ptr;
+	typedef std::vector<unsigned char> ByteVec;
+
+	KeyPairImpl(const std::string& name, Type type);
+		/// Create KeyPairImpl with specified type and name.
+
+	virtual ~KeyPairImpl();
+		/// Destroys the KeyPairImpl.
+
+	virtual int size() const = 0;
+		/// Returns the key size.
+
+	virtual void save(const std::string& publicKeyFile,
+		const std::string& privateKeyFile = "",
+		const std::string& privateKeyPassphrase = "") const = 0;
+		/// Exports the public and private keys to the given files. 
+		///
+		/// If an empty filename is specified, the corresponding key
+		/// is not exported.
+
+	virtual void save(std::ostream* pPublicKeyStream,
+		std::ostream* pPrivateKeyStream = 0,
+		const std::string& privateKeyPassphrase = "") const = 0;
+		/// Exports the public and private key to the given streams.
+		///
+		/// If a null pointer is passed for a stream, the corresponding
+		/// key is not exported.
+
+	const std::string& name() const;
+		/// Returns key pair name
+
+	Type type() const;
+		/// Returns key pair type
+
+private:
+	KeyPairImpl();
+
+	std::string _name;
+	Type        _type;
+	OpenSSLInitializer _openSSLInitializer;
+};
+
+
+//
+// inlines
+//
+
+
+inline const std::string& KeyPairImpl::name() const
+{
+	return _name;
+}
+
+
+inline KeyPairImpl::Type KeyPairImpl::type() const
+{
+	return _type;
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_KeyPairImplImpl_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/OpenSSLInitializer.h b/base/poco/Crypto/include/Poco/Crypto/OpenSSLInitializer.h
new file mode 100644
index 00000000000..42c97ae465d
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/OpenSSLInitializer.h
@@ -0,0 +1,115 @@
+//
+// OpenSSLInitializer.h
+//
+// Library: Crypto
+// Package: CryptoCore
+// Module:  OpenSSLInitializer
+//
+// Definition of the OpenSSLInitializer class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_OpenSSLInitializer_INCLUDED
+#define Crypto_OpenSSLInitializer_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Mutex.h"
+#include "Poco/AtomicCounter.h"
+#include <openssl/crypto.h>
+
+#if defined(OPENSSL_FIPS) && OPENSSL_VERSION_NUMBER < 0x010001000L
+#include <openssl/fips.h>
+#endif
+
+
+extern "C"
+{
+	struct CRYPTO_dynlock_value
+	{
+		Poco::FastMutex _mutex;
+	};
+}
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class Crypto_API OpenSSLInitializer
+	/// Initalizes the OpenSSL library.
+	///
+	/// The class ensures the earliest initialization and the
+	/// latest shutdown of the OpenSSL library.
+{
+public:
+	OpenSSLInitializer();
+		/// Automatically initialize OpenSSL on startup.
+		
+	~OpenSSLInitializer();
+		/// Automatically shut down OpenSSL on exit.
+	
+	static void initialize();
+		/// Initializes the OpenSSL machinery.
+
+	static void uninitialize();
+		/// Shuts down the OpenSSL machinery.
+
+	static bool isFIPSEnabled();
+		// Returns true if FIPS mode is enabled, false otherwise.
+
+	static void enableFIPSMode(bool enabled);
+		// Enable or disable FIPS mode. If FIPS is not available, this method doesn't do anything.
+
+protected:
+	enum
+	{
+		SEEDSIZE = 256
+	};
+	
+	// OpenSSL multithreading support
+	static void lock(int mode, int n, const char* file, int line);
+	static unsigned long id();
+	static struct CRYPTO_dynlock_value* dynlockCreate(const char* file, int line);
+	static void dynlock(int mode, struct CRYPTO_dynlock_value* lock, const char* file, int line);
+	static void dynlockDestroy(struct CRYPTO_dynlock_value* lock, const char* file, int line);
+
+private:
+	static Poco::FastMutex* _mutexes;
+	static Poco::AtomicCounter _rc;
+};
+
+
+//
+// inlines
+//
+inline bool OpenSSLInitializer::isFIPSEnabled()
+{
+#ifdef OPENSSL_FIPS
+	return FIPS_mode() ? true : false;
+#else
+	return false;
+#endif
+}
+
+#ifdef OPENSSL_FIPS
+inline void OpenSSLInitializer::enableFIPSMode(bool enabled)
+{
+	FIPS_mode_set(enabled);
+}
+#else
+inline void OpenSSLInitializer::enableFIPSMode(bool /*enabled*/)
+{
+}
+#endif
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_OpenSSLInitializer_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/PKCS12Container.h b/base/poco/Crypto/include/Poco/Crypto/PKCS12Container.h
new file mode 100644
index 00000000000..63cc224d8cc
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/PKCS12Container.h
@@ -0,0 +1,159 @@
+//
+// PKCS12Container.h
+//
+// Library: Crypto
+// Package: Certificate
+// Module:  PKCS12Container
+//
+// Definition of the PKCS12Container class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_PKCS12Container_INCLUDED
+#define Crypto_PKCS12Container_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include "Poco/Crypto/X509Certificate.h"
+#include "Poco/Crypto/EVPPKey.h"
+#include "Poco/Path.h"
+#include <memory>
+#include <istream>
+#include <openssl/pkcs12.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class Crypto_API PKCS12Container
+	/// This class implements PKCS#12 container functionality.
+{
+public:
+	typedef X509Certificate::List CAList;
+	typedef std::vector<std::string> CANameList;
+
+	explicit PKCS12Container(std::istream& istr, const std::string& password = "");
+		/// Creates the PKCS12Container object from a stream.
+
+	explicit PKCS12Container(const std::string& path, const std::string& password = "");
+		/// Creates the PKCS12Container object from a file.
+
+	PKCS12Container(const PKCS12Container& cont);
+		/// Copy constructor.
+
+	PKCS12Container& operator = (const PKCS12Container& cont);
+		/// Assignment operator.
+
+#ifdef POCO_ENABLE_CPP11
+
+	PKCS12Container(PKCS12Container&& cont);
+		/// Move constructor.
+
+	PKCS12Container& operator = (PKCS12Container&& cont);
+		/// Move assignment operator.
+
+#endif // POCO_ENABLE_CPP11
+
+	~PKCS12Container();
+		/// Destroys the PKCS12Container.
+
+	bool hasKey() const;
+		/// Returns true if container contains the key.
+
+	EVPPKey getKey() const;
+		/// Return key as openssl EVP_PKEY wrapper object.
+
+	bool hasX509Certificate() const;
+		/// Returns true if container has X509 certificate.
+
+	const X509Certificate& getX509Certificate() const;
+		/// Returns the X509 certificate.
+		/// Throws NotFoundException if there is no certificate.
+
+	const CAList& getCACerts() const;
+		/// Returns the list of CA certificates in this container.
+
+	const std::string& getFriendlyName() const;
+		/// Returns the friendly name of the certificate bag.
+
+	const CANameList& getFriendlyNamesCA() const;
+		/// Returns a list of CA certificates friendly names.
+
+private:
+	void load(PKCS12* pPKCS12, const std::string& password = "");
+	std::string extractFriendlyName(X509* pCert);
+
+#ifdef POCO_ENABLE_CPP11
+	typedef std::unique_ptr<X509Certificate> CertPtr;
+#else
+	typedef std::auto_ptr<X509Certificate> CertPtr;
+#endif // #ifdef POCO_ENABLE_CPP11
+
+	OpenSSLInitializer _openSSLInitializer;
+	EVP_PKEY*          _pKey;
+	CertPtr            _pX509Cert;
+	CAList             _caCertList;
+	CANameList         _caCertNames;
+	std::string        _pkcsFriendlyName;
+};
+
+
+//
+// inlines
+//
+
+inline bool PKCS12Container::hasX509Certificate() const
+{
+	return _pX509Cert.get() != 0;
+}
+
+
+inline const X509Certificate& PKCS12Container::getX509Certificate() const
+{
+	if (!hasX509Certificate())
+		throw NotFoundException("PKCS12Container X509 certificate");
+	return *_pX509Cert;
+}
+
+
+inline const std::string& PKCS12Container::getFriendlyName() const
+{
+	return _pkcsFriendlyName;
+}
+
+
+inline const PKCS12Container::CAList& PKCS12Container::getCACerts() const
+{
+	return _caCertList;
+}
+
+
+inline const PKCS12Container::CANameList& PKCS12Container::getFriendlyNamesCA() const
+{
+	return _caCertNames;
+}
+
+
+inline bool PKCS12Container::hasKey() const
+{
+	return _pKey != 0;
+}
+
+
+inline EVPPKey PKCS12Container::getKey() const
+{
+	return EVPPKey(_pKey);
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_PKCS12Container_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/RSACipherImpl.h b/base/poco/Crypto/include/Poco/Crypto/RSACipherImpl.h
new file mode 100644
index 00000000000..2ebc38e3b55
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/RSACipherImpl.h
@@ -0,0 +1,77 @@
+//
+// RSACipherImpl.h
+//
+// Library: Crypto
+// Package: RSA
+// Module:  RSACipherImpl
+//
+// Definition of the RSACipherImpl class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_RSACipherImpl_INCLUDED
+#define Crypto_RSACipherImpl_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/Cipher.h"
+#include "Poco/Crypto/RSAKey.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include <openssl/evp.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class RSACipherImpl: public Cipher
+	/// An implementation of the Cipher class for 
+	/// asymmetric (public-private key) encryption
+	/// based on the the RSA algorithm in OpenSSL's 
+	/// crypto library.
+	///
+	/// Encryption is using the public key, decryption
+	/// requires the private key.
+{
+public:
+	RSACipherImpl(const RSAKey& key, RSAPaddingMode paddingMode);
+		/// Creates a new RSACipherImpl object for the given RSAKey
+		/// and using the given padding mode.
+
+	virtual ~RSACipherImpl();
+		/// Destroys the RSACipherImpl.
+
+	const std::string& name() const;
+		/// Returns the name of the Cipher.
+	
+	CryptoTransform* createEncryptor();
+		/// Creates an encryptor object.
+
+	CryptoTransform* createDecryptor();
+		/// Creates a decryptor object.
+
+private:
+	RSAKey _key;
+	RSAPaddingMode _paddingMode;
+	OpenSSLInitializer _openSSLInitializer;
+};
+
+
+//
+// Inlines
+//
+inline const std::string& RSACipherImpl::name() const
+{
+	return _key.name();
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_RSACipherImpl_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/RSADigestEngine.h b/base/poco/Crypto/include/Poco/Crypto/RSADigestEngine.h
new file mode 100644
index 00000000000..7c4d3860508
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/RSADigestEngine.h
@@ -0,0 +1,111 @@
+//
+// RSADigestEngine.h
+//
+// Library: Crypto
+// Package: RSA
+// Module:  RSADigestEngine
+//
+// Definition of the RSADigestEngine class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_RSADigestEngine_INCLUDED
+#define Crypto_RSADigestEngine_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/RSAKey.h"
+#include "Poco/DigestEngine.h"
+#include "Poco/Crypto/DigestEngine.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class Crypto_API RSADigestEngine: public Poco::DigestEngine
+	/// This class implements a Poco::DigestEngine that can be
+	/// used to compute a secure digital signature.
+	///
+	/// First another Poco::Crypto::DigestEngine is created and
+	/// used to compute a cryptographic hash of the data to be
+	/// signed. Then, the hash value is encrypted, using
+	/// the RSA private key.
+	///
+	/// To verify a signature, pass it to the verify() 
+	/// member function. It will decrypt the signature
+	/// using the RSA public key and compare the resulting
+	/// hash with the actual hash of the data.
+{
+public:
+	enum DigestType
+	{
+		DIGEST_MD5,
+		DIGEST_SHA1
+	};
+	
+	//@ deprecated
+	RSADigestEngine(const RSAKey& key, DigestType digestType = DIGEST_SHA1);
+		/// Creates the RSADigestEngine with the given RSA key,
+		/// using the MD5 or SHA-1 hash algorithm.
+		/// Kept for backward compatibility
+
+	RSADigestEngine(const RSAKey& key, const std::string &name);
+		/// Creates the RSADigestEngine with the given RSA key,
+		/// using the hash algorithm with the given name
+		/// (e.g., "MD5", "SHA1", "SHA256", "SHA512", etc.).
+		/// See the OpenSSL documentation for a list of supported digest algorithms.
+		///
+		/// Throws a Poco::NotFoundException if no algorithm with the given name exists.
+
+	~RSADigestEngine();
+		/// Destroys the RSADigestEngine.
+
+	std::size_t digestLength() const;
+		/// Returns the length of the digest in bytes.
+
+	void reset();
+		/// Resets the engine so that a new
+		/// digest can be computed.
+		
+	const DigestEngine::Digest& digest();
+		/// Finishes the computation of the digest 
+		/// (the first time it's called) and
+		/// returns the message digest. 
+		///
+		/// Can be called multiple times.
+
+	const DigestEngine::Digest& signature();
+		/// Signs the digest using the RSA algorithm
+		/// and the private key (the first time it's
+		/// called) and returns the result.
+		///
+		/// Can be called multiple times.
+
+	bool verify(const DigestEngine::Digest& signature);
+		/// Verifies the data against the signature.
+		///
+		/// Returns true if the signature can be verified, false otherwise.
+
+protected:
+	void updateImpl(const void* data, std::size_t length);
+
+private:
+	RSAKey _key;
+	Poco::Crypto::DigestEngine _engine;
+	Poco::DigestEngine::Digest _digest;
+	Poco::DigestEngine::Digest _signature;
+};
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_RSADigestEngine_INCLUDED
diff --git a/base/poco/Crypto/include/Poco/Crypto/RSAKey.h b/base/poco/Crypto/include/Poco/Crypto/RSAKey.h
new file mode 100644
index 00000000000..ad9163ed42f
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/RSAKey.h
@@ -0,0 +1,125 @@
+//
+// RSAKey.h
+//
+// Library: Crypto
+// Package: RSA
+// Module:  RSAKey
+//
+// Definition of the RSAKey class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_RSAKey_INCLUDED
+#define Crypto_RSAKey_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/KeyPair.h"
+#include "Poco/Crypto/RSAKeyImpl.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class X509Certificate;
+class PKCS12Container;
+
+
+class Crypto_API RSAKey : public KeyPair
+	/// This class stores an RSA key pair, consisting
+	/// of private and public key. Storage of the private
+	/// key is optional.
+	///
+	/// If a private key is available, the RSAKey can be
+	/// used for decrypting data (encrypted with the public key)
+	/// or computing secure digital signatures.
+{
+public:
+	enum KeyLength
+	{
+		KL_512  = 512,
+		KL_1024 = 1024,
+		KL_2048 = 2048,
+		KL_4096 = 4096
+	};
+
+	enum Exponent
+	{
+		EXP_SMALL = 0,
+		EXP_LARGE
+	};
+
+	RSAKey(const EVPPKey& key);
+		/// Constructs ECKeyImpl by extracting the EC key.
+
+	RSAKey(const X509Certificate& cert);
+		/// Extracts the RSA public key from the given certificate.
+
+	RSAKey(const PKCS12Container& cert);
+		/// Extracts the RSA private key from the given certificate.
+
+	RSAKey(KeyLength keyLength, Exponent exp);
+		/// Creates the RSAKey. Creates a new public/private keypair using the given parameters.
+		/// Can be used to sign data and verify signatures.
+
+	RSAKey(const std::string& publicKeyFile,
+		const std::string& privateKeyFile = "",
+		const std::string& privateKeyPassphrase = "");
+		/// Creates the RSAKey, by reading public and private key from the given files and
+		/// using the given passphrase for the private key.
+		///
+		/// Cannot be used for signing or decryption unless a private key is available.
+		///
+		/// If a private key is specified, you don't need to specify a public key file.
+		/// OpenSSL will auto-create the public key from the private key.
+
+	RSAKey(std::istream* pPublicKeyStream,
+		std::istream* pPrivateKeyStream = 0,
+		const std::string& privateKeyPassphrase = "");
+		/// Creates the RSAKey, by reading public and private key from the given streams and
+		/// using the given passphrase for the private key.
+		///
+		/// Cannot be used for signing or decryption unless a private key is available.
+		///
+		/// If a private key is specified, you don't need to specify a public key file.
+		/// OpenSSL will auto-create the public key from the private key.
+
+	~RSAKey();
+		/// Destroys the RSAKey.
+
+	RSAKeyImpl::ByteVec modulus() const;
+		/// Returns the RSA modulus.
+
+	RSAKeyImpl::ByteVec encryptionExponent() const;
+		/// Returns the RSA encryption exponent.
+
+	RSAKeyImpl::ByteVec decryptionExponent() const;
+		/// Returns the RSA decryption exponent.
+
+	RSAKeyImpl::Ptr impl() const;
+		/// Returns the impl object.
+	
+private:
+	RSAKeyImpl::Ptr _pImpl;
+};
+
+
+//
+// inlines
+//
+inline RSAKeyImpl::Ptr RSAKey::impl() const
+{
+	return _pImpl;
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_RSAKey_INCLUDED
\ No newline at end of file
diff --git a/base/poco/Crypto/include/Poco/Crypto/RSAKeyImpl.h b/base/poco/Crypto/include/Poco/Crypto/RSAKeyImpl.h
new file mode 100644
index 00000000000..035881636b2
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/RSAKeyImpl.h
@@ -0,0 +1,141 @@
+//
+// RSAKeyImpl.h
+//
+// Library: Crypto
+// Package: RSA
+// Module:  RSAKeyImpl
+//
+// Definition of the RSAKeyImpl class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_RSAKeyImplImpl_INCLUDED
+#define Crypto_RSAKeyImplImpl_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/EVPPKey.h"
+#include "Poco/Crypto/KeyPairImpl.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include <istream>
+#include <ostream>
+#include <vector>
+
+
+struct bignum_st;
+struct rsa_st;
+typedef struct bignum_st BIGNUM;
+typedef struct rsa_st RSA;
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class X509Certificate;
+class PKCS12Container;
+
+
+class RSAKeyImpl: public KeyPairImpl
+	/// class RSAKeyImpl
+{
+public:
+	typedef Poco::AutoPtr<RSAKeyImpl> Ptr;
+	typedef std::vector<unsigned char> ByteVec;
+
+	RSAKeyImpl(const EVPPKey& key);
+		/// Constructs ECKeyImpl by extracting the EC key.
+
+	RSAKeyImpl(const X509Certificate& cert);
+		/// Extracts the RSA public key from the given certificate.
+
+	RSAKeyImpl(const PKCS12Container& cert);
+		/// Extracts the EC private key from the given certificate.
+
+	RSAKeyImpl(int keyLength, unsigned long exponent);
+		/// Creates the RSAKey. Creates a new public/private keypair using the given parameters.
+		/// Can be used to sign data and verify signatures.
+
+	RSAKeyImpl(const std::string& publicKeyFile, const std::string& privateKeyFile, const std::string& privateKeyPassphrase);
+		/// Creates the RSAKey, by reading public and private key from the given files and
+		/// using the given passphrase for the private key. Can only by used for signing if 
+		/// a private key is available. 
+
+	RSAKeyImpl(std::istream* pPublicKeyStream, std::istream* pPrivateKeyStream, const std::string& privateKeyPassphrase);
+		/// Creates the RSAKey. Can only by used for signing if pPrivKey
+		/// is not null. If a private key file is specified, you don't need to
+		/// specify a public key file. OpenSSL will auto-create it from the private key.
+
+	~RSAKeyImpl();
+		/// Destroys the RSAKeyImpl.
+
+	RSA* getRSA();
+		/// Returns the OpenSSL RSA object.
+
+	const RSA* getRSA() const;
+		/// Returns the OpenSSL RSA object.
+
+	int size() const;
+		/// Returns the RSA modulus size.
+
+	ByteVec modulus() const;
+		/// Returns the RSA modulus.
+
+	ByteVec encryptionExponent() const;
+		/// Returns the RSA encryption exponent.
+
+	ByteVec decryptionExponent() const;
+		/// Returns the RSA decryption exponent.
+
+	void save(const std::string& publicKeyFile,
+		const std::string& privateKeyFile = "",
+		const std::string& privateKeyPassphrase = "") const;
+		/// Exports the public and private keys to the given files. 
+		///
+		/// If an empty filename is specified, the corresponding key
+		/// is not exported.
+
+	void save(std::ostream* pPublicKeyStream,
+		std::ostream* pPrivateKeyStream = 0,
+		const std::string& privateKeyPassphrase = "") const;
+		/// Exports the public and private key to the given streams.
+		///
+		/// If a null pointer is passed for a stream, the corresponding
+		/// key is not exported.
+
+private:
+	RSAKeyImpl();
+
+	void freeRSA();
+	static ByteVec convertToByteVec(const BIGNUM* bn);
+
+	RSA* _pRSA;
+};
+
+
+//
+// inlines
+//
+inline RSA* RSAKeyImpl::getRSA()
+{
+	return _pRSA;
+}
+
+
+inline const RSA* RSAKeyImpl::getRSA() const
+{
+	return _pRSA;
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_RSAKeyImplImpl_INCLUDED
\ No newline at end of file
diff --git a/base/poco/Crypto/include/Poco/Crypto/X509Certificate.h b/base/poco/Crypto/include/Poco/Crypto/X509Certificate.h
new file mode 100644
index 00000000000..ccdab1ce37e
--- /dev/null
+++ b/base/poco/Crypto/include/Poco/Crypto/X509Certificate.h
@@ -0,0 +1,245 @@
+//
+// X509Certificate.h
+//
+// Library: Crypto
+// Package: Certificate
+// Module:  X509Certificate
+//
+// Definition of the X509Certificate class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Crypto_X509Certificate_INCLUDED
+#define Crypto_X509Certificate_INCLUDED
+
+
+#include "Poco/Crypto/Crypto.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include "Poco/DateTime.h"
+#include "Poco/SharedPtr.h"
+#include <vector>
+#include <set>
+#include <istream>
+#include <openssl/ssl.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+class Crypto_API X509Certificate
+	/// This class represents a X509 Certificate.
+{
+public:
+	typedef std::vector<X509Certificate> List;
+
+	enum NID
+		/// Name identifier for extracting information from
+		/// a certificate subject's or issuer's distinguished name.
+	{
+		NID_COMMON_NAME = 13,
+		NID_COUNTRY = 14,
+		NID_LOCALITY_NAME = 15,
+		NID_STATE_OR_PROVINCE = 16,
+		NID_ORGANIZATION_NAME = 17,
+		NID_ORGANIZATION_UNIT_NAME = 18,
+		NID_PKCS9_EMAIL_ADDRESS = 48,
+		NID_SERIAL_NUMBER = 105
+	};
+
+	explicit X509Certificate(std::istream& istr);
+		/// Creates the X509Certificate object by reading
+		/// a certificate in PEM format from a stream.
+
+	explicit X509Certificate(const std::string& path);
+		/// Creates the X509Certificate object by reading
+		/// a certificate in PEM format from a file.
+
+	explicit X509Certificate(X509* pCert);
+		/// Creates the X509Certificate from an existing
+		/// OpenSSL certificate. Ownership is taken of
+		/// the certificate.
+
+	X509Certificate(X509* pCert, bool shared);
+		/// Creates the X509Certificate from an existing
+		/// OpenSSL certificate. Ownership is taken of
+		/// the certificate. If shared is true, the
+		/// certificate's reference count is incremented.
+
+	X509Certificate(const X509Certificate& cert);
+		/// Creates the certificate by copying another one.
+
+	X509Certificate& operator = (const X509Certificate& cert);
+		/// Assigns a certificate.
+
+	void swap(X509Certificate& cert);
+		/// Exchanges the certificate with another one.
+
+	~X509Certificate();
+		/// Destroys the X509Certificate.
+
+	long version() const;
+		/// Returns the version of the certificate.
+
+	const std::string& serialNumber() const;
+		/// Returns the certificate serial number as a
+		/// string in decimal encoding.
+
+	const std::string& issuerName() const;
+		/// Returns the certificate issuer's distinguished name.
+
+	std::string issuerName(NID nid) const;
+		/// Extracts the information specified by the given
+		/// NID (name identifier) from the certificate issuer's
+		/// distinguished name.
+
+	const std::string& subjectName() const;
+		/// Returns the certificate subject's distinguished name.
+
+	std::string subjectName(NID nid) const;
+		/// Extracts the information specified by the given
+		/// NID (name identifier) from the certificate subject's
+		/// distinguished name.
+
+	std::string commonName() const;
+		/// Returns the common name stored in the certificate
+		/// subject's distinguished name.
+
+	void extractNames(std::string& commonName, std::set<std::string>& domainNames) const;
+		/// Extracts the common name and the alias domain names from the
+		/// certificate.
+
+	Poco::DateTime validFrom() const;
+		/// Returns the date and time the certificate is valid from.
+
+	Poco::DateTime expiresOn() const;
+		/// Returns the date and time the certificate expires.
+
+	void save(std::ostream& stream) const;
+		/// Writes the certificate to the given stream.
+		/// The certificate is written in PEM format.
+
+	void save(const std::string& path) const;
+		/// Writes the certificate to the file given by path.
+		/// The certificate is written in PEM format.
+
+	bool issuedBy(const X509Certificate& issuerCertificate) const;
+		/// Checks whether the certificate has been issued by
+		/// the issuer given by issuerCertificate. This can be
+		/// used to validate a certificate chain.
+		///
+		/// Verifies if the certificate has been signed with the
+		/// issuer's private key, using the public key from the issuer
+		/// certificate.
+		///
+		/// Returns true if verification against the issuer certificate
+		/// was successful, false otherwise.
+
+	bool equals(const X509Certificate& otherCertificate) const;
+		/// Checks whether the certificate is equal to
+		/// the other certificate, by comparing the hashes
+		/// of both certificates.
+		///
+		/// Returns true if both certificates are identical,
+		/// otherwise false.
+
+	const X509* certificate() const;
+		/// Returns the underlying OpenSSL certificate.
+
+	X509* dup() const;
+		/// Duplicates and returns the underlying OpenSSL certificate. Note that
+		/// the caller assumes responsibility for the lifecycle of the created
+		/// certificate.
+
+	std::string signatureAlgorithm() const;
+		/// Returns the certificate signature algorithm long name.
+
+	void print(std::ostream& out) const;
+		/// Prints the certificate information to ostream.
+
+	static List readPEM(const std::string& pemFileName);
+		/// Reads and returns a list of certificates from
+		/// the specified PEM file.
+
+	static void writePEM(const std::string& pemFileName, const List& list);
+		/// Writes the list of certificates to the specified PEM file.
+
+protected:
+	void load(std::istream& stream);
+		/// Loads the certificate from the given stream. The
+		/// certificate must be in PEM format.
+
+	void load(const std::string& path);
+		/// Loads the certificate from the given file. The
+		/// certificate must be in PEM format.
+
+	void init();
+		/// Extracts issuer and subject name from the certificate.
+
+private:
+	enum
+	{
+		NAME_BUFFER_SIZE = 256
+	};
+
+	std::string _issuerName;
+	std::string _subjectName;
+	std::string _serialNumber;
+	X509*       _pCert;
+	OpenSSLInitializer _openSSLInitializer;
+};
+
+
+//
+// inlines
+//
+
+
+inline long X509Certificate::version() const
+{
+	// This is defined by standards (X.509 et al) to be
+	// one less than the certificate version.
+	// So, eg. a version 3 certificate will return 2.
+	return X509_get_version(_pCert) + 1;
+}
+
+
+inline const std::string& X509Certificate::serialNumber() const
+{
+	return _serialNumber;
+}
+
+
+inline const std::string& X509Certificate::issuerName() const
+{
+	return _issuerName;
+}
+
+
+inline const std::string& X509Certificate::subjectName() const
+{
+	return _subjectName;
+}
+
+
+inline const X509* X509Certificate::certificate() const
+{
+	return _pCert;
+}
+
+
+inline X509* X509Certificate::dup() const
+{
+	return X509_dup(_pCert);
+}
+
+
+} } // namespace Poco::Crypto
+
+
+#endif // Crypto_X509Certificate_INCLUDED
diff --git a/base/poco/Crypto/src/Cipher.cpp b/base/poco/Crypto/src/Cipher.cpp
new file mode 100644
index 00000000000..8b4d57964f5
--- /dev/null
+++ b/base/poco/Crypto/src/Cipher.cpp
@@ -0,0 +1,140 @@
+//
+// Cipher.cpp
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  Cipher
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/Cipher.h"
+#include "Poco/Crypto/CryptoStream.h"
+#include "Poco/Crypto/CryptoTransform.h"
+#include "Poco/Base64Encoder.h"
+#include "Poco/Base64Decoder.h"
+#include "Poco/HexBinaryEncoder.h"
+#include "Poco/HexBinaryDecoder.h"
+#include "Poco/StreamCopier.h"
+#include "Poco/Exception.h"
+#include <sstream>
+#include <memory>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+Cipher::Cipher()
+{
+}
+
+
+Cipher::~Cipher()
+{
+}
+
+
+std::string Cipher::encryptString(const std::string& str, Encoding encoding)
+{
+	std::istringstream source(str);
+	std::ostringstream sink;
+
+	encrypt(source, sink, encoding);
+
+	return sink.str();
+}
+
+
+std::string Cipher::decryptString(const std::string& str, Encoding encoding)
+{
+	std::istringstream source(str);
+	std::ostringstream sink;
+
+	decrypt(source, sink, encoding);
+	return sink.str();
+}
+
+
+void Cipher::encrypt(std::istream& source, std::ostream& sink, Encoding encoding)
+{
+	CryptoInputStream encryptor(source, createEncryptor());
+
+	switch (encoding)
+	{
+	case ENC_NONE:
+		StreamCopier::copyStream(encryptor, sink);
+		break;
+
+	case ENC_BASE64:
+	case ENC_BASE64_NO_LF:
+		{
+			Poco::Base64Encoder encoder(sink);
+			if (encoding == ENC_BASE64_NO_LF)
+			{
+				encoder.rdbuf()->setLineLength(0);
+			}
+			StreamCopier::copyStream(encryptor, encoder);
+			encoder.close();
+		}
+		break;
+
+	case ENC_BINHEX:
+	case ENC_BINHEX_NO_LF:
+		{
+			Poco::HexBinaryEncoder encoder(sink);
+			if (encoding == ENC_BINHEX_NO_LF)
+			{
+				encoder.rdbuf()->setLineLength(0);
+			}
+			StreamCopier::copyStream(encryptor, encoder);
+			encoder.close();
+		}
+		break;
+
+	default:
+		throw Poco::InvalidArgumentException("Invalid argument", "encoding");
+	}
+}
+
+
+void Cipher::decrypt(std::istream& source, std::ostream& sink, Encoding encoding)
+{
+	CryptoOutputStream decryptor(sink, createDecryptor());
+
+	switch (encoding)
+	{
+	case ENC_NONE:
+		StreamCopier::copyStream(source, decryptor);
+		decryptor.close();
+		break;
+
+	case ENC_BASE64:
+	case ENC_BASE64_NO_LF:
+		{
+			Poco::Base64Decoder decoder(source);
+			StreamCopier::copyStream(decoder, decryptor);
+			decryptor.close();
+		}
+		break;
+
+	case ENC_BINHEX:
+	case ENC_BINHEX_NO_LF:
+		{
+			Poco::HexBinaryDecoder decoder(source);
+			StreamCopier::copyStream(decoder, decryptor);
+			decryptor.close();
+		}
+		break;
+
+	default:
+		throw Poco::InvalidArgumentException("Invalid argument", "encoding");
+	}
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/CipherFactory.cpp b/base/poco/Crypto/src/CipherFactory.cpp
new file mode 100644
index 00000000000..28ba3748643
--- /dev/null
+++ b/base/poco/Crypto/src/CipherFactory.cpp
@@ -0,0 +1,65 @@
+//
+// CipherFactory.cpp
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CipherFactory
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/CipherFactory.h"
+#include "Poco/Crypto/Cipher.h"
+#include "Poco/Crypto/CipherKey.h"
+#include "Poco/Crypto/RSAKey.h"
+#include "Poco/Crypto/CipherImpl.h"
+#include "Poco/Crypto/RSACipherImpl.h"
+#include "Poco/Exception.h"
+#include "Poco/SingletonHolder.h"
+#include <openssl/evp.h>
+#include <openssl/err.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+CipherFactory::CipherFactory()
+{
+}
+
+
+CipherFactory::~CipherFactory()
+{
+}
+
+
+namespace
+{
+	static Poco::SingletonHolder<CipherFactory> holder;
+}
+
+
+CipherFactory& CipherFactory::defaultFactory()
+{
+	return *holder.get();
+}
+
+
+Cipher* CipherFactory::createCipher(const CipherKey& key)
+{
+	return new CipherImpl(key);
+}
+
+
+Cipher* CipherFactory::createCipher(const RSAKey& key, RSAPaddingMode paddingMode)
+{
+	return new RSACipherImpl(key, paddingMode);
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/CipherImpl.cpp b/base/poco/Crypto/src/CipherImpl.cpp
new file mode 100644
index 00000000000..ae574775957
--- /dev/null
+++ b/base/poco/Crypto/src/CipherImpl.cpp
@@ -0,0 +1,272 @@
+//
+// CipherImpl.cpp
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CipherImpl
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/CipherImpl.h"
+#include "Poco/Crypto/CryptoTransform.h"
+#include "Poco/Exception.h"
+#include "Poco/Buffer.h"
+#include <openssl/err.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+namespace
+{
+	void throwError()
+	{
+		unsigned long err;
+		std::string msg;
+
+		while ((err = ERR_get_error()))
+		{
+			if (!msg.empty())
+				msg.append("; ");
+			msg.append(ERR_error_string(err, 0));
+		}
+
+		throw Poco::IOException(msg);
+	}
+
+
+	class CryptoTransformImpl: public CryptoTransform
+	{
+	public:
+		typedef Cipher::ByteVec ByteVec;
+
+		enum Direction
+		{
+			DIR_ENCRYPT,
+			DIR_DECRYPT
+		};
+
+		CryptoTransformImpl(
+			const EVP_CIPHER* pCipher,
+			const ByteVec&    key,
+			const ByteVec&    iv,
+			Direction         dir);
+
+		~CryptoTransformImpl();
+
+		std::size_t blockSize() const;
+		int setPadding(int padding);
+		std::string getTag(std::size_t tagSize);
+		void setTag(const std::string& tag);
+
+		std::streamsize transform(
+			const unsigned char* input,
+			std::streamsize      inputLength,
+			unsigned char*       output,
+			std::streamsize      outputLength);
+
+		std::streamsize finalize(
+			unsigned char*  output,
+			std::streamsize length);
+
+	private:
+		const EVP_CIPHER* _pCipher;
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		EVP_CIPHER_CTX*   _pContext;
+#else
+		EVP_CIPHER_CTX    _context;
+#endif
+		ByteVec           _key;
+		ByteVec           _iv;
+	};
+
+
+	CryptoTransformImpl::CryptoTransformImpl(
+		const EVP_CIPHER* pCipher,
+		const ByteVec&    key,
+		const ByteVec&    iv,
+		Direction         dir):
+		_pCipher(pCipher),
+		_key(key),
+		_iv(iv)
+	{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		_pContext = EVP_CIPHER_CTX_new();
+		EVP_CipherInit(
+			_pContext,
+			_pCipher,
+			&_key[0],
+			_iv.empty() ? 0 : &_iv[0],
+			(dir == DIR_ENCRYPT) ? 1 : 0);
+#else
+		EVP_CipherInit(
+			&_context,
+			_pCipher,
+			&_key[0],
+			_iv.empty() ? 0 : &_iv[0],
+			(dir == DIR_ENCRYPT) ? 1 : 0);
+#endif
+
+#if OPENSSL_VERSION_NUMBER >= 0x10001000L
+		if (_iv.size() != EVP_CIPHER_iv_length(_pCipher) && EVP_CIPHER_mode(_pCipher) == EVP_CIPH_GCM_MODE)
+		{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+			int rc = EVP_CIPHER_CTX_ctrl(_pContext, EVP_CTRL_GCM_SET_IVLEN, _iv.size(), NULL);
+#else
+			int rc = EVP_CIPHER_CTX_ctrl(&_context, EVP_CTRL_GCM_SET_IVLEN, _iv.size(), NULL);
+#endif
+			if (rc == 0) throwError();
+		}
+#endif
+	}
+
+
+	CryptoTransformImpl::~CryptoTransformImpl()
+	{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		EVP_CIPHER_CTX_cleanup(_pContext);
+		EVP_CIPHER_CTX_free(_pContext);
+#else
+		EVP_CIPHER_CTX_cleanup(&_context);
+#endif
+	}
+
+
+	std::size_t CryptoTransformImpl::blockSize() const
+	{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		return EVP_CIPHER_CTX_block_size(_pContext);
+#else
+		return EVP_CIPHER_CTX_block_size(&_context);
+#endif
+	}
+
+
+	int CryptoTransformImpl::setPadding(int padding)
+	{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		return EVP_CIPHER_CTX_block_size(_pContext);
+#else
+		return EVP_CIPHER_CTX_set_padding(&_context, padding);
+#endif
+	}
+
+
+	std::string CryptoTransformImpl::getTag(std::size_t tagSize)
+	{
+		std::string tag;
+#if OPENSSL_VERSION_NUMBER >= 0x10001000L
+		Poco::Buffer<char> buffer(tagSize);
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		int rc = EVP_CIPHER_CTX_ctrl(_pContext, EVP_CTRL_GCM_GET_TAG, tagSize, buffer.begin());
+#else
+		int rc = EVP_CIPHER_CTX_ctrl(&_context, EVP_CTRL_GCM_GET_TAG, tagSize, buffer.begin());
+#endif
+		if (rc == 0) throwError();
+		tag.assign(buffer.begin(), tagSize);
+#endif
+		return tag;
+	}
+
+
+	void CryptoTransformImpl::setTag(const std::string& tag)
+	{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		int rc = EVP_CIPHER_CTX_ctrl(_pContext, EVP_CTRL_GCM_SET_TAG, tag.size(), const_cast<char*>(tag.data()));
+#elif OPENSSL_VERSION_NUMBER >= 0x10001000L
+		int rc = EVP_CIPHER_CTX_ctrl(&_context, EVP_CTRL_GCM_SET_TAG, tag.size(), const_cast<char*>(tag.data()));
+#else
+		int rc = 0;
+#endif
+		if (rc == 0) throwError();
+	}
+
+
+	std::streamsize CryptoTransformImpl::transform(
+		const unsigned char* input,
+		std::streamsize      inputLength,
+		unsigned char*       output,
+		std::streamsize      outputLength)
+	{
+		poco_assert (outputLength >= (inputLength + blockSize() - 1));
+
+		int outLen = static_cast<int>(outputLength);
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		int rc = EVP_CipherUpdate(
+			_pContext,
+			output,
+			&outLen,
+			input,
+			static_cast<int>(inputLength));
+#else
+		int rc = EVP_CipherUpdate(
+			&_context,
+			output,
+			&outLen,
+			input,
+			static_cast<int>(inputLength));
+#endif
+		if (rc == 0)
+			throwError();
+
+		return static_cast<std::streamsize>(outLen);
+	}
+
+
+	std::streamsize CryptoTransformImpl::finalize(
+		unsigned char*	output,
+		std::streamsize length)
+	{
+		poco_assert (length >= blockSize());
+
+		int len = static_cast<int>(length);
+
+		// Use the '_ex' version that does not perform implicit cleanup since we
+		// will call EVP_CIPHER_CTX_cleanup() from the dtor as there is no
+		// guarantee that finalize() will be called if an error occurred.
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		int rc = EVP_CipherFinal_ex(_pContext, output, &len);
+#else
+		int rc = EVP_CipherFinal_ex(&_context, output, &len);
+#endif
+
+		if (rc == 0)
+			throwError();
+
+		return static_cast<std::streamsize>(len);
+	}
+}
+
+
+CipherImpl::CipherImpl(const CipherKey& key):
+	_key(key)
+{
+}
+
+
+CipherImpl::~CipherImpl()
+{
+}
+
+
+CryptoTransform* CipherImpl::createEncryptor()
+{
+	CipherKeyImpl::Ptr p = _key.impl();
+	return new CryptoTransformImpl(p->cipher(), p->getKey(), p->getIV(), CryptoTransformImpl::DIR_ENCRYPT);
+}
+
+
+CryptoTransform* CipherImpl::createDecryptor()
+{
+	CipherKeyImpl::Ptr p = _key.impl();
+	return new CryptoTransformImpl(p->cipher(), p->getKey(), p->getIV(), CryptoTransformImpl::DIR_DECRYPT);
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/CipherKey.cpp b/base/poco/Crypto/src/CipherKey.cpp
new file mode 100644
index 00000000000..275edd1c883
--- /dev/null
+++ b/base/poco/Crypto/src/CipherKey.cpp
@@ -0,0 +1,49 @@
+//
+// CipherKey.cpp
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CipherKey
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/CipherKey.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+CipherKey::CipherKey(const std::string& name,
+	const std::string& passphrase,
+	const std::string& salt,
+	int iterationCount,
+	const std::string &digest):
+		_pImpl(new CipherKeyImpl(name, passphrase, salt, iterationCount, digest))
+{
+}
+
+
+CipherKey::CipherKey(const std::string& name, const ByteVec& key, const ByteVec& iv):
+	_pImpl(new CipherKeyImpl(name, key, iv))
+{
+}
+
+
+CipherKey::CipherKey(const std::string& name):
+	_pImpl(new CipherKeyImpl(name))
+{
+}
+
+
+CipherKey::~CipherKey()
+{
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/CipherKeyImpl.cpp b/base/poco/Crypto/src/CipherKeyImpl.cpp
new file mode 100644
index 00000000000..d5ebc5e3b17
--- /dev/null
+++ b/base/poco/Crypto/src/CipherKeyImpl.cpp
@@ -0,0 +1,222 @@
+//
+// CipherKeyImpl.cpp
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CipherKeyImpl
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/CipherKeyImpl.h"
+#include "Poco/Crypto/CryptoTransform.h"
+#include "Poco/Crypto/CipherFactory.h"
+#include "Poco/Exception.h"
+#include "Poco/RandomStream.h"
+#include <openssl/err.h>
+#include <openssl/evp.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+CipherKeyImpl::CipherKeyImpl(const std::string& name,
+	const std::string& passphrase,
+	const std::string& salt,
+	int iterationCount,
+	const std::string& digest):
+	_pCipher(0),
+	_pDigest(0),
+	_name(name),
+	_key(),
+	_iv()
+{
+	// dummy access to Cipherfactory so that the EVP lib is initilaized
+	CipherFactory::defaultFactory();
+	_pCipher = EVP_get_cipherbyname(name.c_str());
+
+	if (!_pCipher)
+		throw Poco::NotFoundException("Cipher " + name + " was not found");
+
+	_pDigest = EVP_get_digestbyname(digest.c_str());
+
+	if (!_pDigest)
+		throw Poco::NotFoundException("Digest " + name + " was not found");
+
+	_key = ByteVec(keySize());
+	_iv = ByteVec(ivSize());
+	generateKey(passphrase, salt, iterationCount);
+}
+
+
+CipherKeyImpl::CipherKeyImpl(const std::string& name,
+	const ByteVec& key,
+	const ByteVec& iv):
+	_pCipher(0),
+	_pDigest(0),
+	_name(name),
+	_key(key),
+	_iv(iv)
+{
+	// dummy access to Cipherfactory so that the EVP lib is initialized
+	CipherFactory::defaultFactory();
+	_pCipher = EVP_get_cipherbyname(name.c_str());
+
+	if (!_pCipher)
+		throw Poco::NotFoundException("Cipher " + name + " was not found");
+}
+
+
+CipherKeyImpl::CipherKeyImpl(const std::string& name):
+	_pCipher(0),
+	_pDigest(0),
+	_name(name),
+	_key(),
+	_iv()
+{
+	// dummy access to Cipherfactory so that the EVP lib is initilaized
+	CipherFactory::defaultFactory();
+	_pCipher = EVP_get_cipherbyname(name.c_str());
+
+	if (!_pCipher)
+		throw Poco::NotFoundException("Cipher " + name + " was not found");
+	_key = ByteVec(keySize());
+	_iv = ByteVec(ivSize());
+	generateKey();
+}
+
+
+CipherKeyImpl::~CipherKeyImpl()
+{
+}
+
+
+CipherKeyImpl::Mode CipherKeyImpl::mode() const
+{
+	switch (EVP_CIPHER_mode(_pCipher))
+	{
+	case EVP_CIPH_STREAM_CIPHER:
+		return MODE_STREAM_CIPHER;
+
+	case EVP_CIPH_ECB_MODE:
+		return MODE_ECB;
+
+	case EVP_CIPH_CBC_MODE:
+		return MODE_CBC;
+
+	case EVP_CIPH_CFB_MODE:
+		return MODE_CFB;
+
+	case EVP_CIPH_OFB_MODE:
+		return MODE_OFB;
+
+#if OPENSSL_VERSION_NUMBER >= 0x10001000L
+	case EVP_CIPH_CTR_MODE:
+		return MODE_CTR;
+
+	case EVP_CIPH_GCM_MODE:
+		return MODE_GCM;
+
+#endif
+	}
+	throw Poco::IllegalStateException("Unexpected value of EVP_CIPHER_mode()");
+}
+
+
+void CipherKeyImpl::generateKey()
+{
+	ByteVec vec;
+
+	getRandomBytes(vec, keySize());
+	setKey(vec);
+
+	getRandomBytes(vec, ivSize());
+	setIV(vec);
+}
+
+
+void CipherKeyImpl::getRandomBytes(ByteVec& vec, std::size_t count)
+{
+	Poco::RandomInputStream random;
+
+	vec.clear();
+	vec.reserve(count);
+
+	for (int i = 0; i < count; ++i)
+		vec.push_back(static_cast<unsigned char>(random.get()));
+}
+
+
+void CipherKeyImpl::generateKey(
+	const std::string& password,
+	const std::string& salt,
+	int iterationCount)
+{
+	unsigned char keyBytes[EVP_MAX_KEY_LENGTH];
+	unsigned char ivBytes[EVP_MAX_IV_LENGTH];
+
+	// OpenSSL documentation specifies that the salt must be an 8-byte array.
+	unsigned char saltBytes[8];
+
+	if (!salt.empty())
+	{
+		int len = static_cast<int>(salt.size());
+		// Create the salt array from the salt string
+		for (int i = 0; i < 8; ++i)
+			saltBytes[i] = salt.at(i % len);
+		for (int i = 8; i < len; ++i)
+			saltBytes[i % 8] ^= salt.at(i);
+	}
+
+	// Now create the key and IV, using the MD5 digest algorithm.
+	int keySize = EVP_BytesToKey(
+		_pCipher,
+		_pDigest ? _pDigest : EVP_md5(),
+		(salt.empty() ? 0 : saltBytes),
+		reinterpret_cast<const unsigned char*>(password.data()),
+		static_cast<int>(password.size()),
+		iterationCount,
+		keyBytes,
+		ivBytes);
+
+	// Copy the buffers to our member byte vectors.
+	_key.assign(keyBytes, keyBytes + keySize);
+
+	if (ivSize() == 0)
+		_iv.clear();
+	else
+		_iv.assign(ivBytes, ivBytes + ivSize());
+}
+
+
+int CipherKeyImpl::keySize() const
+{
+	return EVP_CIPHER_key_length(_pCipher);
+}
+
+
+int CipherKeyImpl::blockSize() const
+{
+	return EVP_CIPHER_block_size(_pCipher);
+}
+
+
+int CipherKeyImpl::ivSize() const
+{
+	return EVP_CIPHER_iv_length(_pCipher);
+}
+
+
+void CipherKeyImpl::setIV(const ByteVec& iv)
+{
+	poco_assert(mode() == MODE_GCM || iv.size() == static_cast<ByteVec::size_type>(ivSize()));
+	_iv = iv;
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/CryptoException.cpp b/base/poco/Crypto/src/CryptoException.cpp
new file mode 100644
index 00000000000..a4450af9bf0
--- /dev/null
+++ b/base/poco/Crypto/src/CryptoException.cpp
@@ -0,0 +1,108 @@
+//
+// CryptoException.cpp
+//
+//
+// Library: Crypto
+// Package: Crypto
+// Module:  CryptoException
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/CryptoException.h"
+#include "Poco/NumberFormatter.h"
+#include <typeinfo>
+#include <openssl/err.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+POCO_IMPLEMENT_EXCEPTION(CryptoException, Exception, "Crypto Exception")
+
+
+OpenSSLException::OpenSSLException(int otherCode): CryptoException(otherCode)
+{
+	setExtMessage();
+}
+
+
+OpenSSLException::OpenSSLException(const std::string& msg, int otherCode): CryptoException(msg, otherCode)
+{
+	setExtMessage();
+}
+
+
+OpenSSLException::OpenSSLException(const std::string& msg, const std::string& arg, int otherCode): CryptoException(msg, arg, otherCode)
+{
+	setExtMessage();
+}
+
+
+OpenSSLException::OpenSSLException(const std::string& msg, const Poco::Exception& exc, int otherCode): CryptoException(msg, exc, otherCode)
+{
+	setExtMessage();
+}
+
+
+OpenSSLException::OpenSSLException(const OpenSSLException& exc): CryptoException(exc)
+{
+	setExtMessage();
+}
+
+
+OpenSSLException::~OpenSSLException() throw()
+{
+}
+
+
+OpenSSLException& OpenSSLException::operator = (const OpenSSLException& exc)
+{
+	CryptoException::operator = (exc);
+	return *this;
+}
+
+
+const char* OpenSSLException::name() const throw()
+{
+	return "OpenSSLException";
+}
+
+
+const char* OpenSSLException::className() const throw()
+{
+	return typeid(*this).name();
+}
+
+
+Poco::Exception* OpenSSLException::clone() const
+{
+	return new OpenSSLException(*this);
+}
+
+
+void OpenSSLException::setExtMessage()
+{
+	Poco::UInt64 e = static_cast<Poco::UInt64>(ERR_get_error());
+	char buf[128] = { 0 };
+	char* pErr = ERR_error_string(static_cast<unsigned long>(e), buf);
+	std::string err;
+	if (pErr) err = pErr;
+	else err = NumberFormatter::format(e);
+
+	extendedMessage(err);
+}
+
+
+void OpenSSLException::rethrow() const
+{
+	throw *this;
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/CryptoStream.cpp b/base/poco/Crypto/src/CryptoStream.cpp
new file mode 100644
index 00000000000..6b29b7f0775
--- /dev/null
+++ b/base/poco/Crypto/src/CryptoStream.cpp
@@ -0,0 +1,355 @@
+//
+// CryptoStream.cpp
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CryptoStream
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/CryptoStream.h"
+#include "Poco/Crypto/CryptoTransform.h"
+#include "Poco/Crypto/Cipher.h"
+#include "Poco/Exception.h"
+#include <algorithm>
+
+
+#undef min
+#undef max
+
+
+namespace Poco {
+namespace Crypto {
+
+
+//
+// CryptoStreamBuf
+//
+
+
+CryptoStreamBuf::CryptoStreamBuf(std::istream& istr, CryptoTransform* pTransform, std::streamsize bufferSize):
+	Poco::BufferedStreamBuf(bufferSize, std::ios::in),
+	_pTransform(pTransform),
+	_pIstr(&istr),
+	_pOstr(0),
+	_eof(false),
+	_buffer(static_cast<std::size_t>(bufferSize))
+{
+	poco_check_ptr (pTransform);
+	poco_assert (bufferSize > 2 * pTransform->blockSize());
+}
+
+
+CryptoStreamBuf::CryptoStreamBuf(std::ostream& ostr, CryptoTransform* pTransform, std::streamsize bufferSize):
+	Poco::BufferedStreamBuf(bufferSize, std::ios::out),
+	_pTransform(pTransform),
+	_pIstr(0),
+	_pOstr(&ostr),
+	_eof(false),
+	_buffer(static_cast<std::size_t>(bufferSize))
+{
+	poco_check_ptr (pTransform);
+	poco_assert (bufferSize > 2 * pTransform->blockSize());
+}
+
+
+CryptoStreamBuf::~CryptoStreamBuf()
+{
+	try
+	{
+		close();
+	}
+	catch (...)
+	{
+	}
+	delete _pTransform;
+}
+
+
+void CryptoStreamBuf::close()
+{
+	sync();
+
+	if (_pIstr)
+	{
+		_pIstr = 0;
+	}
+	else if (_pOstr)
+	{
+		// Close can be called multiple times. By zeroing the pointer we make
+		// sure that we call finalize() only once, even if an exception is
+		// thrown.
+		std::ostream* pOstr = _pOstr;
+		_pOstr = 0;
+		
+		// Finalize transformation.
+		std::streamsize n = _pTransform->finalize(_buffer.begin(), static_cast<std::streamsize>(_buffer.size()));
+		
+		if (n > 0)
+		{
+			pOstr->write(reinterpret_cast<char*>(_buffer.begin()), n);
+			if (!pOstr->good())
+				throw Poco::IOException("Output stream failure");
+		}
+	}
+}
+
+
+int CryptoStreamBuf::readFromDevice(char* buffer, std::streamsize length)
+{
+	if (!_pIstr)
+		return 0;
+
+	int count = 0;
+
+	while (!_eof)
+	{
+		int m = (static_cast<int>(length) - count)/2 - static_cast<int>(_pTransform->blockSize());
+
+		// Make sure we can read at least one more block. Explicitely check
+		// for m < 0 since blockSize() returns an unsigned int and the
+		// comparison might give false results for m < 0.
+		if (m <= 0)
+			break;
+
+		int n = 0;
+
+		if (_pIstr->good())
+		{
+			_pIstr->read(reinterpret_cast<char*>(_buffer.begin()), m);
+			n = static_cast<int>(_pIstr->gcount());
+		}
+
+		if (n == 0)
+		{
+			_eof = true;
+
+			// No more data, finalize transformation
+			count += static_cast<int>(_pTransform->finalize(
+				reinterpret_cast<unsigned char*>(buffer + count),
+				static_cast<int>(length) - count));
+		}
+		else
+		{
+			// Transform next chunk of data
+			count += static_cast<int>(_pTransform->transform(
+				_buffer.begin(),
+				n,
+				reinterpret_cast<unsigned char*>(buffer + count),
+				static_cast<int>(length) - count));
+		}
+	}
+
+	return count;
+}
+
+
+int CryptoStreamBuf::writeToDevice(const char* buffer, std::streamsize length)
+{
+	if (!_pOstr)
+		return 0;
+
+	std::size_t maxChunkSize = _buffer.size()/2;
+	std::size_t count = 0;
+
+	while (count < length)
+	{
+		// Truncate chunk size so that the maximum output fits into _buffer.
+		std::size_t n = static_cast<std::size_t>(length) - count;
+		if (n > maxChunkSize)
+			n = maxChunkSize;
+
+		// Transform next chunk of data
+		std::streamsize k = _pTransform->transform(
+			reinterpret_cast<const unsigned char*>(buffer + count),
+			static_cast<std::streamsize>(n),
+			_buffer.begin(),
+			static_cast<std::streamsize>(_buffer.size()));
+
+		// Attention: (n != k) might be true. In count, we have to track how
+		// many bytes from buffer have been consumed, not how many bytes have
+		// been written to _pOstr!
+		count += n;
+
+		if (k > 0)
+		{
+			_pOstr->write(reinterpret_cast<const char*>(_buffer.begin()), k);
+			if (!_pOstr->good())
+				throw Poco::IOException("Output stream failure");
+		}
+	}
+
+	return static_cast<int>(count);
+}
+
+
+//
+// CryptoIOS
+//
+
+
+CryptoIOS::CryptoIOS(std::istream& istr, CryptoTransform* pTransform, std::streamsize bufferSize):
+	_buf(istr, pTransform, bufferSize)
+{
+	poco_ios_init(&_buf);
+}
+
+
+CryptoIOS::CryptoIOS(std::ostream& ostr, CryptoTransform* pTransform, std::streamsize bufferSize):
+	_buf(ostr, pTransform, bufferSize)
+{
+	poco_ios_init(&_buf);
+}
+
+
+CryptoIOS::~CryptoIOS()
+{
+}
+
+
+CryptoStreamBuf* CryptoIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+//
+// CryptoInputStream
+//
+
+
+CryptoInputStream::CryptoInputStream(std::istream& istr, CryptoTransform* pTransform, std::streamsize bufferSize):
+	CryptoIOS(istr, pTransform, bufferSize),
+	std::istream(&_buf)
+{
+}
+
+
+CryptoInputStream::CryptoInputStream(std::istream& istr, Cipher& cipher, std::streamsize bufferSize):
+	CryptoIOS(istr, cipher.createEncryptor(), bufferSize),
+	std::istream(&_buf)
+{
+}
+
+
+CryptoInputStream::~CryptoInputStream()
+{
+}
+
+
+//
+// CryptoOutputStream
+//
+
+
+CryptoOutputStream::CryptoOutputStream(std::ostream& ostr, CryptoTransform* pTransform, std::streamsize bufferSize):
+	CryptoIOS(ostr, pTransform, bufferSize),
+	std::ostream(&_buf)
+{
+}
+
+
+CryptoOutputStream::CryptoOutputStream(std::ostream& ostr, Cipher& cipher, std::streamsize bufferSize):
+	CryptoIOS(ostr, cipher.createDecryptor(), bufferSize),
+	std::ostream(&_buf)
+{
+}
+
+
+CryptoOutputStream::~CryptoOutputStream()
+{
+}
+
+
+void CryptoOutputStream::close()
+{
+	_buf.close();
+}
+
+
+//
+// EncryptingInputStream
+//
+
+
+EncryptingInputStream::EncryptingInputStream(std::istream& istr, Cipher& cipher, std::streamsize bufferSize):
+	CryptoIOS(istr, cipher.createEncryptor(), bufferSize),
+	std::istream(&_buf)
+{
+}
+
+
+EncryptingInputStream::~EncryptingInputStream()
+{
+}
+
+
+//
+// EncryptingOuputStream
+//
+
+
+EncryptingOutputStream::EncryptingOutputStream(std::ostream& ostr, Cipher& cipher, std::streamsize bufferSize):
+	CryptoIOS(ostr, cipher.createEncryptor(), bufferSize),
+	std::ostream(&_buf)
+{
+}
+
+
+EncryptingOutputStream::~EncryptingOutputStream()
+{
+}
+
+
+void EncryptingOutputStream::close()
+{
+	_buf.close();
+}
+
+
+//
+// DecryptingInputStream
+//
+
+
+DecryptingInputStream::DecryptingInputStream(std::istream& istr, Cipher& cipher, std::streamsize bufferSize):
+	CryptoIOS(istr, cipher.createDecryptor(), bufferSize),
+	std::istream(&_buf)
+{
+}
+
+
+DecryptingInputStream::~DecryptingInputStream()
+{
+}
+
+
+//
+// DecryptingOuputStream
+//
+
+
+DecryptingOutputStream::DecryptingOutputStream(std::ostream& ostr, Cipher& cipher, std::streamsize bufferSize):
+	CryptoIOS(ostr, cipher.createDecryptor(), bufferSize),
+	std::ostream(&_buf)
+{
+}
+
+
+DecryptingOutputStream::~DecryptingOutputStream()
+{
+}
+
+
+void DecryptingOutputStream::close()
+{
+	_buf.close();
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/CryptoTransform.cpp b/base/poco/Crypto/src/CryptoTransform.cpp
new file mode 100644
index 00000000000..e4e58fd6e64
--- /dev/null
+++ b/base/poco/Crypto/src/CryptoTransform.cpp
@@ -0,0 +1,38 @@
+//
+// CryptoTransform.cpp
+//
+// Library: Crypto
+// Package: Cipher
+// Module:  CryptoTransform
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/CryptoTransform.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+CryptoTransform::CryptoTransform()
+{
+}
+
+
+CryptoTransform::~CryptoTransform()
+{
+}
+
+  
+int CryptoTransform::setPadding(int padding)
+{
+	return 1;
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/DigestEngine.cpp b/base/poco/Crypto/src/DigestEngine.cpp
new file mode 100644
index 00000000000..a09879fe732
--- /dev/null
+++ b/base/poco/Crypto/src/DigestEngine.cpp
@@ -0,0 +1,80 @@
+//
+// DigestEngine.cpp
+//
+// Library: Crypto
+// Package: Digest
+// Module:  DigestEngine
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/DigestEngine.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+DigestEngine::DigestEngine(const std::string& name):
+	_name(name),
+	_pContext(EVP_MD_CTX_create())
+{
+	const EVP_MD* md = EVP_get_digestbyname(_name.c_str());
+	if (!md) throw Poco::NotFoundException(_name);
+	EVP_DigestInit_ex(_pContext, md, NULL);
+}
+
+
+DigestEngine::~DigestEngine()
+{
+	EVP_MD_CTX_destroy(_pContext);
+}
+
+int DigestEngine::nid() const
+{
+	return EVP_MD_type(EVP_MD_CTX_md(_pContext));
+}
+
+std::size_t DigestEngine::digestLength() const
+{
+	return EVP_MD_CTX_size(_pContext);
+}
+
+
+void DigestEngine::reset()
+{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
+	EVP_MD_CTX_free(_pContext);
+	_pContext = EVP_MD_CTX_create();
+#else
+	EVP_MD_CTX_cleanup(_pContext);
+#endif
+	const EVP_MD* md = EVP_get_digestbyname(_name.c_str());
+	if (!md) throw Poco::NotFoundException(_name);
+	EVP_DigestInit_ex(_pContext, md, NULL);
+}
+
+
+const Poco::DigestEngine::Digest& DigestEngine::digest()
+{
+	_digest.clear();
+	unsigned len = EVP_MD_CTX_size(_pContext);
+	_digest.resize(len);
+	EVP_DigestFinal_ex(_pContext, &_digest[0], &len);
+	reset();
+	return _digest;
+}
+
+
+void DigestEngine::updateImpl(const void* data, std::size_t length)
+{
+	EVP_DigestUpdate(_pContext, data, length);
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/ECDSADigestEngine.cpp b/base/poco/Crypto/src/ECDSADigestEngine.cpp
new file mode 100644
index 00000000000..59512770cd1
--- /dev/null
+++ b/base/poco/Crypto/src/ECDSADigestEngine.cpp
@@ -0,0 +1,100 @@
+//
+// ECDSADigestEngine.cpp
+//
+//
+// Library: Crypto
+// Package: ECDSA
+// Module:  ECDSADigestEngine
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/ECDSADigestEngine.h"
+#include <openssl/ecdsa.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+ECDSADigestEngine::ECDSADigestEngine(const ECKey& key, const std::string &name):
+	_key(key),
+	_engine(name)
+{
+}
+
+
+ECDSADigestEngine::~ECDSADigestEngine()
+{
+}
+
+
+std::size_t ECDSADigestEngine::digestLength() const
+{
+	return _engine.digestLength();
+}
+
+
+void ECDSADigestEngine::reset()
+{
+	_engine.reset();
+	_digest.clear();
+	_signature.clear();
+}
+
+	
+const DigestEngine::Digest& ECDSADigestEngine::digest()
+{
+	if (_digest.empty())
+	{
+		_digest = _engine.digest();
+	}
+	return _digest;
+}
+
+
+const DigestEngine::Digest& ECDSADigestEngine::signature()
+{
+	if (_signature.empty())
+	{
+		digest();
+		_signature.resize(_key.size());
+		unsigned sigLen = static_cast<unsigned>(_signature.size());
+		if (!ECDSA_sign(0, &_digest[0], static_cast<unsigned>(_digest.size()),
+			&_signature[0], &sigLen, _key.impl()->getECKey()))
+		{
+			throw OpenSSLException();
+		}
+		if (sigLen < _signature.size()) _signature.resize(sigLen);
+	}
+	return _signature;
+}
+
+
+bool ECDSADigestEngine::verify(const DigestEngine::Digest& sig)
+{
+	digest();
+	EC_KEY* pKey = _key.impl()->getECKey();
+	if (pKey)
+	{
+		int ret = ECDSA_verify(0, &_digest[0], static_cast<unsigned>(_digest.size()),
+			&sig[0], static_cast<unsigned>(sig.size()),
+			pKey);
+		if (1 == ret) return true;
+		else if (0 == ret) return false;
+	}
+	throw OpenSSLException();
+}
+
+
+void ECDSADigestEngine::updateImpl(const void* data, std::size_t length)
+{
+	_engine.update(data, length);
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/ECKey.cpp b/base/poco/Crypto/src/ECKey.cpp
new file mode 100644
index 00000000000..56b8663776e
--- /dev/null
+++ b/base/poco/Crypto/src/ECKey.cpp
@@ -0,0 +1,75 @@
+//
+// ECKey.cpp
+//
+//
+// Library: Crypto
+// Package: EC
+// Module:  ECKey
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/ECKey.h"
+#include <openssl/rsa.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+ECKey::ECKey(const EVPPKey& key):
+	KeyPair(new ECKeyImpl(key)),
+	_pImpl(KeyPair::impl().cast<ECKeyImpl>())
+{
+}
+
+
+ECKey::ECKey(const X509Certificate& cert):
+	KeyPair(new ECKeyImpl(cert)),
+	_pImpl(KeyPair::impl().cast<ECKeyImpl>())
+{
+}
+
+
+ECKey::ECKey(const PKCS12Container& cont):
+	KeyPair(new ECKeyImpl(cont)),
+	_pImpl(KeyPair::impl().cast<ECKeyImpl>())
+{
+}
+
+
+ECKey::ECKey(const std::string& eccGroup):
+	KeyPair(new ECKeyImpl(OBJ_txt2nid(eccGroup.c_str()))),
+	_pImpl(KeyPair::impl().cast<ECKeyImpl>())
+{
+}
+
+
+ECKey::ECKey(const std::string& publicKeyFile,
+	const std::string& privateKeyFile,
+	const std::string& privateKeyPassphrase):
+		KeyPair(new ECKeyImpl(publicKeyFile, privateKeyFile, privateKeyPassphrase)),
+		_pImpl(KeyPair::impl().cast<ECKeyImpl>())
+{
+}
+
+
+ECKey::ECKey(std::istream* pPublicKeyStream,
+	std::istream* pPrivateKeyStream,
+	const std::string& privateKeyPassphrase):
+		KeyPair(new ECKeyImpl(pPublicKeyStream, pPrivateKeyStream, privateKeyPassphrase)),
+		_pImpl(KeyPair::impl().cast<ECKeyImpl>())
+{
+}
+
+
+ECKey::~ECKey()
+{
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/ECKeyImpl.cpp b/base/poco/Crypto/src/ECKeyImpl.cpp
new file mode 100644
index 00000000000..99ffae76067
--- /dev/null
+++ b/base/poco/Crypto/src/ECKeyImpl.cpp
@@ -0,0 +1,258 @@
+//
+// ECKeyImpl.cpp
+//
+//
+// Library: Crypto
+// Package: EC
+// Module:  ECKeyImpl
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/ECKeyImpl.h"
+#include "Poco/Crypto/X509Certificate.h"
+#include "Poco/Crypto/PKCS12Container.h"
+#include "Poco/FileStream.h"
+#include "Poco/Format.h"
+#include "Poco/StreamCopier.h"
+#include <sstream>
+#include <openssl/evp.h>
+#if OPENSSL_VERSION_NUMBER >= 0x00908000L
+#include <openssl/bn.h>
+#endif
+
+
+namespace Poco {
+namespace Crypto {
+
+
+ECKeyImpl::ECKeyImpl(const EVPPKey& key):
+	KeyPairImpl("ec", KT_EC_IMPL),
+	_pEC(EVP_PKEY_get1_EC_KEY(const_cast<EVP_PKEY*>((const EVP_PKEY*)key)))
+{
+	checkEC("ECKeyImpl(const EVPPKey&)", "EVP_PKEY_get1_EC_KEY()");
+}
+
+
+ECKeyImpl::ECKeyImpl(const X509Certificate& cert):
+	KeyPairImpl("ec", KT_EC_IMPL),
+	_pEC(0)
+{
+	const X509* pCert = cert.certificate();
+	if (pCert)
+	{
+		EVP_PKEY* pKey = X509_get_pubkey(const_cast<X509*>(pCert));
+		if (pKey)
+		{
+			_pEC = EVP_PKEY_get1_EC_KEY(pKey);
+			EVP_PKEY_free(pKey);
+			checkEC("ECKeyImpl(const const X509Certificate&)", "EVP_PKEY_get1_EC_KEY()");
+			return;
+		}
+	}
+	throw OpenSSLException("ECKeyImpl(const X509Certificate&)");
+}
+
+
+ECKeyImpl::ECKeyImpl(const PKCS12Container& cont):
+	KeyPairImpl("ec", KT_EC_IMPL),
+	_pEC(EVP_PKEY_get1_EC_KEY(cont.getKey()))
+{
+	checkEC("ECKeyImpl(const PKCS12Container&)", "EVP_PKEY_get1_EC_KEY()");
+}
+
+
+ECKeyImpl::ECKeyImpl(int curve):
+	KeyPairImpl("ec", KT_EC_IMPL),
+	_pEC(EC_KEY_new_by_curve_name(curve))
+{
+	poco_check_ptr(_pEC);
+	EC_KEY_set_asn1_flag(_pEC, OPENSSL_EC_NAMED_CURVE);
+	if (!(EC_KEY_generate_key(_pEC)))
+		throw OpenSSLException("ECKeyImpl(int curve): EC_KEY_generate_key()");
+	checkEC("ECKeyImpl(int curve)", "EC_KEY_generate_key()");
+}
+
+
+ECKeyImpl::ECKeyImpl(const std::string& publicKeyFile, 
+	const std::string& privateKeyFile, 
+	const std::string& privateKeyPassphrase): KeyPairImpl("ec", KT_EC_IMPL), _pEC(0)
+{
+	if (EVPPKey::loadKey(&_pEC, PEM_read_PrivateKey, EVP_PKEY_get1_EC_KEY, privateKeyFile, privateKeyPassphrase))
+	{
+		checkEC(Poco::format("ECKeyImpl(%s, %s, %s)",
+			publicKeyFile, privateKeyFile, privateKeyPassphrase.empty() ? privateKeyPassphrase : std::string("***")),
+			"PEM_read_PrivateKey() or EVP_PKEY_get1_EC_KEY()");
+		return; // private key is enough
+	}
+
+	// no private key, this must be public key only, otherwise throw
+	if (!EVPPKey::loadKey(&_pEC, PEM_read_PUBKEY, EVP_PKEY_get1_EC_KEY, publicKeyFile))
+	{
+		throw OpenSSLException("ECKeyImpl(const string&, const string&, const string&");
+	}
+	checkEC(Poco::format("ECKeyImpl(%s, %s, %s)",
+		publicKeyFile, privateKeyFile, privateKeyPassphrase.empty() ? privateKeyPassphrase : std::string("***")),
+		"PEM_read_PUBKEY() or EVP_PKEY_get1_EC_KEY()");
+}
+
+
+ECKeyImpl::ECKeyImpl(std::istream* pPublicKeyStream,
+	std::istream* pPrivateKeyStream,
+	const std::string& privateKeyPassphrase): KeyPairImpl("ec", KT_EC_IMPL), _pEC(0)
+{
+	if (EVPPKey::loadKey(&_pEC, PEM_read_bio_PrivateKey, EVP_PKEY_get1_EC_KEY, pPrivateKeyStream, privateKeyPassphrase))
+	{
+		checkEC(Poco::format("ECKeyImpl(stream, stream, %s)",
+			privateKeyPassphrase.empty() ? privateKeyPassphrase : std::string("***")),
+			"PEM_read_bio_PrivateKey() or EVP_PKEY_get1_EC_KEY()");
+		return; // private key is enough
+	}
+
+	// no private key, this must be public key only, otherwise throw
+	if (!EVPPKey::loadKey(&_pEC, PEM_read_bio_PUBKEY, EVP_PKEY_get1_EC_KEY, pPublicKeyStream))
+	{
+		throw OpenSSLException("ECKeyImpl(istream*, istream*, const string&");
+	}
+	checkEC(Poco::format("ECKeyImpl(stream, stream, %s)",
+		privateKeyPassphrase.empty() ? privateKeyPassphrase : std::string("***")),
+		"PEM_read_bio_PUBKEY() or EVP_PKEY_get1_EC_KEY()");
+}
+
+
+ECKeyImpl::~ECKeyImpl()
+{
+	freeEC();
+}
+
+
+void ECKeyImpl::checkEC(const std::string& method, const std::string& func) const
+{
+	if (!_pEC) throw OpenSSLException(Poco::format("%s: %s", method, func));
+	if (!EC_KEY_check_key(_pEC))
+		throw OpenSSLException(Poco::format("%s: EC_KEY_check_key()", method));
+}
+
+
+void ECKeyImpl::freeEC()
+{
+	if (_pEC)
+	{
+		EC_KEY_free(_pEC);
+		_pEC = 0;
+	}
+}
+
+
+int ECKeyImpl::size() const
+{
+	int sz = -1;
+	EVP_PKEY* pKey = EVP_PKEY_new();
+	if (pKey && EVP_PKEY_set1_EC_KEY(pKey, _pEC))
+	{
+		sz = EVP_PKEY_bits(pKey);
+		EVP_PKEY_free(pKey);
+		return sz;
+	}
+	throw OpenSSLException("ECKeyImpl::size()");
+}
+
+
+int ECKeyImpl::groupId() const
+{
+	if (_pEC)
+	{
+		const EC_GROUP* ecGroup = EC_KEY_get0_group(_pEC);
+		if (ecGroup)
+		{
+			return EC_GROUP_get_curve_name(ecGroup);
+		}
+		else
+		{
+			throw OpenSSLException("ECKeyImpl::groupName()");
+		}
+	}
+	throw NullPointerException("ECKeyImpl::groupName() => _pEC");
+}
+
+
+std::string ECKeyImpl::getCurveName(int nid)
+{
+	std::string curveName;
+	size_t len = EC_get_builtin_curves(NULL, 0);
+	EC_builtin_curve* pCurves =
+			(EC_builtin_curve*) OPENSSL_malloc(sizeof(EC_builtin_curve) * len);
+	if (!pCurves) return curveName;
+
+	if (!EC_get_builtin_curves(pCurves, len))
+	{
+		OPENSSL_free(pCurves);
+		return curveName;
+	}
+
+	if (-1 == nid) nid = pCurves[0].nid;
+	const int bufLen = 128;
+	char buf[bufLen];
+	std::memset(buf, 0, bufLen);
+	OBJ_obj2txt(buf, bufLen, OBJ_nid2obj(nid), 0);
+	curveName = buf;
+	OPENSSL_free(pCurves);
+	return curveName;
+}
+
+
+int ECKeyImpl::getCurveNID(std::string& name)
+{
+	std::string curveName;
+	size_t len = EC_get_builtin_curves(NULL, 0);
+	EC_builtin_curve* pCurves =
+		(EC_builtin_curve*)OPENSSL_malloc(static_cast<int>(sizeof(EC_builtin_curve) * len));
+	if (!pCurves) return -1;
+
+	if (!EC_get_builtin_curves(pCurves, len))
+	{
+		OPENSSL_free(pCurves);
+		return -1;
+	}
+
+	int nid = -1;
+	const int bufLen = 128;
+	char buf[bufLen];
+	if (name.empty())
+	{
+		std::memset(buf, 0, bufLen);
+		OBJ_obj2txt(buf, bufLen, OBJ_nid2obj(nid), 0);
+		name = buf;
+		nid = pCurves[0].nid;
+	}
+	else
+	{
+		for (int i = 0; i < len; ++i)
+		{
+			std::memset(buf, 0, bufLen);
+			OBJ_obj2txt(buf, bufLen, OBJ_nid2obj(pCurves[i].nid), 0);
+			if (strncmp(name.c_str(), buf, name.size() > bufLen ? bufLen : name.size()) == 0)
+			{
+				nid = pCurves[i].nid;
+				break;
+			}
+		}
+	}
+
+	OPENSSL_free(pCurves);
+	return nid;
+}
+
+
+bool ECKeyImpl::hasCurve(const std::string& name)
+{
+	std::string tmp(name);
+	return (-1 != getCurveNID(tmp));
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/EVPPKey.cpp b/base/poco/Crypto/src/EVPPKey.cpp
new file mode 100644
index 00000000000..ffa0a78c070
--- /dev/null
+++ b/base/poco/Crypto/src/EVPPKey.cpp
@@ -0,0 +1,321 @@
+//
+// EVPPKey.cpp
+//
+//
+// Library: Crypto
+// Package: CryptoCore
+// Module:  EVPPKey
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/EVPPKey.h"
+#include "Poco/Crypto/ECKey.h"
+#include "Poco/Crypto/RSAKey.h"
+#include "Poco/NumberFormatter.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+EVPPKey::EVPPKey(const std::string& ecCurveName): _pEVPPKey(0)
+{
+	newECKey(ecCurveName.c_str());
+	poco_check_ptr(_pEVPPKey);
+}
+
+
+EVPPKey::EVPPKey(const char* ecCurveName): _pEVPPKey(0)
+{
+	newECKey(ecCurveName);
+	poco_check_ptr(_pEVPPKey);
+}
+
+
+EVPPKey::EVPPKey(EVP_PKEY* pEVPPKey): _pEVPPKey(0)
+{
+	duplicate(pEVPPKey, &_pEVPPKey);
+	poco_check_ptr(_pEVPPKey);
+}
+
+
+EVPPKey::EVPPKey(const std::string& publicKeyFile,
+	const std::string& privateKeyFile,
+	const std::string& privateKeyPassphrase): _pEVPPKey(0)
+{
+	if (loadKey(&_pEVPPKey, PEM_read_PrivateKey, (EVP_PKEY_get_Key_fn)0, privateKeyFile, privateKeyPassphrase))
+	{
+		poco_check_ptr(_pEVPPKey);
+		return; // private key is enough
+	}
+
+	// no private key, this must be public key only, otherwise throw
+	if (!loadKey(&_pEVPPKey, PEM_read_PUBKEY, (EVP_PKEY_get_Key_fn)0, publicKeyFile))
+	{
+		throw OpenSSLException("ECKeyImpl(const string&, const string&, const string&");
+	}
+	poco_check_ptr(_pEVPPKey);
+}
+
+
+EVPPKey::EVPPKey(std::istream* pPublicKeyStream,
+	std::istream* pPrivateKeyStream,
+	const std::string& privateKeyPassphrase): _pEVPPKey(0)
+{
+	if (loadKey(&_pEVPPKey, PEM_read_bio_PrivateKey, (EVP_PKEY_get_Key_fn)0, pPrivateKeyStream, privateKeyPassphrase))
+	{
+		poco_check_ptr(_pEVPPKey);
+		return; // private key is enough
+	}
+
+	// no private key, this must be public key only, otherwise throw
+	if (!loadKey(&_pEVPPKey, PEM_read_bio_PUBKEY, (EVP_PKEY_get_Key_fn)0, pPublicKeyStream))
+	{
+		throw OpenSSLException("ECKeyImpl(istream*, istream*, const string&");
+	}
+	poco_check_ptr(_pEVPPKey);
+}
+
+
+EVPPKey::EVPPKey(const EVPPKey& other)
+{
+	duplicate(other._pEVPPKey, &_pEVPPKey);
+	poco_check_ptr(_pEVPPKey);
+}
+
+
+EVPPKey& EVPPKey::operator=(const EVPPKey& other)
+{
+	duplicate(other._pEVPPKey, &_pEVPPKey);
+	poco_check_ptr(_pEVPPKey);
+	return *this;
+}
+
+
+#ifdef POCO_ENABLE_CPP11
+
+EVPPKey::EVPPKey(EVPPKey&& other): _pEVPPKey(other._pEVPPKey)
+{
+	other._pEVPPKey = nullptr;
+	poco_check_ptr(_pEVPPKey);
+}
+
+
+EVPPKey& EVPPKey::operator=(EVPPKey&& other)
+{
+	_pEVPPKey = other._pEVPPKey;
+	other._pEVPPKey = nullptr;
+	poco_check_ptr(_pEVPPKey);
+	return *this;
+}
+
+#endif // POCO_ENABLE_CPP11
+
+EVPPKey::~EVPPKey()
+{
+	if (_pEVPPKey) EVP_PKEY_free(_pEVPPKey);
+}
+
+
+void EVPPKey::save(const std::string& publicKeyFile, const std::string& privateKeyFile, const std::string& privateKeyPassphrase) const
+{
+	if (!publicKeyFile.empty() && (publicKeyFile != privateKeyFile))
+	{
+		BIO* bio = BIO_new(BIO_s_file());
+		if (!bio) throw Poco::IOException("Cannot create BIO for writing public key file", publicKeyFile);
+		try
+		{
+			if (BIO_write_filename(bio, const_cast<char*>(publicKeyFile.c_str())))
+			{
+				if (!PEM_write_bio_PUBKEY(bio, _pEVPPKey))
+				{
+					throw Poco::WriteFileException("Failed to write public key to file", publicKeyFile);
+				}
+			}
+			else throw Poco::CreateFileException("Cannot create public key file");
+		}
+		catch (...)
+		{
+			BIO_free(bio);
+			throw;
+		}
+		BIO_free(bio);
+	}
+
+	if (!privateKeyFile.empty())
+	{
+		BIO* bio = BIO_new(BIO_s_file());
+		if (!bio) throw Poco::IOException("Cannot create BIO for writing private key file", privateKeyFile);
+		try
+		{
+			if (BIO_write_filename(bio, const_cast<char*>(privateKeyFile.c_str())))
+			{
+				int rc = 0;
+				if (privateKeyPassphrase.empty())
+				{
+					rc = PEM_write_bio_PrivateKey(bio, _pEVPPKey, 0, 0, 0, 0, 0);
+				}
+				else
+				{
+					rc = PEM_write_bio_PrivateKey(bio, _pEVPPKey, EVP_des_ede3_cbc(),
+						reinterpret_cast<unsigned char*>(const_cast<char*>(privateKeyPassphrase.c_str())),
+						static_cast<int>(privateKeyPassphrase.length()), 0, 0);
+				}
+				if (!rc)
+					throw Poco::FileException("Failed to write private key to file", privateKeyFile);
+			}
+			else throw Poco::CreateFileException("Cannot create private key file", privateKeyFile);
+		}
+		catch (...)
+		{
+			BIO_free(bio);
+			throw;
+		}
+		BIO_free(bio);
+	}
+}
+
+
+void EVPPKey::save(std::ostream* pPublicKeyStream, std::ostream* pPrivateKeyStream, const std::string& privateKeyPassphrase) const
+{
+	if (pPublicKeyStream && (pPublicKeyStream != pPrivateKeyStream))
+	{
+		BIO* bio = BIO_new(BIO_s_mem());
+		if (!bio) throw Poco::IOException("Cannot create BIO for writing public key");
+		if (!PEM_write_bio_PUBKEY(bio, _pEVPPKey))
+		{
+			BIO_free(bio);
+			throw Poco::WriteFileException("Failed to write public key to stream");
+		}
+		char* pData;
+		long size = BIO_get_mem_data(bio, &pData);
+		pPublicKeyStream->write(pData, static_cast<std::streamsize>(size));
+		BIO_free(bio);
+	}
+
+	if (pPrivateKeyStream)
+	{
+		BIO* bio = BIO_new(BIO_s_mem());
+		if (!bio) throw Poco::IOException("Cannot create BIO for writing public key");
+		int rc = 0;
+		if (privateKeyPassphrase.empty())
+			rc = PEM_write_bio_PrivateKey(bio, _pEVPPKey, 0, 0, 0, 0, 0);
+		else
+			rc = PEM_write_bio_PrivateKey(bio, _pEVPPKey, EVP_des_ede3_cbc(),
+				reinterpret_cast<unsigned char*>(const_cast<char*>(privateKeyPassphrase.c_str())),
+				static_cast<int>(privateKeyPassphrase.length()), 0, 0);
+		if (!rc)
+		{
+			BIO_free(bio);
+			throw Poco::FileException("Failed to write private key to stream");
+		}
+		char* pData;
+		long size = BIO_get_mem_data(bio, &pData);
+		pPrivateKeyStream->write(pData, static_cast<std::streamsize>(size));
+		BIO_free(bio);
+	}
+}
+
+
+EVP_PKEY* EVPPKey::duplicate(const EVP_PKEY* pFromKey, EVP_PKEY** pToKey)
+{
+	if (!pFromKey) throw NullPointerException("EVPPKey::duplicate(): "
+		"provided key pointer is null.");
+
+	*pToKey = EVP_PKEY_new();
+	if (!*pToKey) throw NullPointerException("EVPPKey::duplicate(): "
+		"EVP_PKEY_new() returned null.");
+
+	int keyType = type(pFromKey);
+	switch (keyType)
+	{
+		case EVP_PKEY_RSA:
+		{
+			RSA* pRSA = EVP_PKEY_get1_RSA(const_cast<EVP_PKEY*>(pFromKey));
+			if (pRSA)
+			{
+				EVP_PKEY_set1_RSA(*pToKey, pRSA);
+				RSA_free(pRSA);
+			}
+			else throw OpenSSLException("EVPPKey::duplicate(): EVP_PKEY_get1_RSA()");
+			break;
+		}
+		case EVP_PKEY_EC:
+		{
+			EC_KEY* pEC = EVP_PKEY_get1_EC_KEY(const_cast<EVP_PKEY*>(pFromKey));
+			if (pEC)
+			{
+				EVP_PKEY_set1_EC_KEY(*pToKey, pEC);
+				EC_KEY_free(pEC);
+				int cmp = EVP_PKEY_cmp_parameters(*pToKey, pFromKey);
+				if (cmp < 0)
+					throw OpenSSLException("EVPPKey::duplicate(): EVP_PKEY_cmp_parameters()");
+				if (0 == cmp)
+				{
+					if(!EVP_PKEY_copy_parameters(*pToKey, pFromKey))
+						throw OpenSSLException("EVPPKey::duplicate(): EVP_PKEY_copy_parameters()");
+				}
+			}
+			else throw OpenSSLException();
+			break;
+		}
+		default:
+			throw NotImplementedException("EVPPKey:duplicate(); Key type: " +
+				NumberFormatter::format(keyType));
+	}
+
+	return *pToKey;
+}
+
+
+void EVPPKey::newECKey(const char* ecCurveName)
+{
+	int curveID = OBJ_txt2nid(ecCurveName);
+	EC_KEY* pEC = EC_KEY_new_by_curve_name(curveID);
+	if (!pEC) goto err;
+	if (!EC_KEY_generate_key(pEC)) goto err;
+	_pEVPPKey = EVP_PKEY_new();
+	if (!_pEVPPKey) goto err;
+	if (!EVP_PKEY_set1_EC_KEY(_pEVPPKey, pEC)) goto err;
+	EC_KEY_free(pEC);
+	return;
+err:
+	throw OpenSSLException("EVPPKey:newECKey()");
+}
+
+
+void EVPPKey::setKey(ECKey* pKey)
+{
+	poco_check_ptr(pKey);
+	poco_check_ptr(pKey->impl());
+	setKey(pKey->impl()->getECKey());
+}
+
+
+void EVPPKey::setKey(RSAKey* pKey)
+{
+	poco_check_ptr(pKey);
+	poco_check_ptr(pKey->impl());
+	setKey(pKey->impl()->getRSA());
+}
+
+
+int EVPPKey::passCB(char* buf, int size, int, void* pass)
+{
+	if (pass)
+	{
+		int len = (int)std::strlen((char*)pass);
+		if(len > size) len = size;
+		std::memcpy(buf, pass, len);
+		return len;
+	}
+	return 0;
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/KeyPair.cpp b/base/poco/Crypto/src/KeyPair.cpp
new file mode 100644
index 00000000000..1c650806b37
--- /dev/null
+++ b/base/poco/Crypto/src/KeyPair.cpp
@@ -0,0 +1,34 @@
+//
+// KeyPair.cpp
+//
+//
+// Library: Crypto
+// Package: CryptoCore
+// Module:  KeyPair
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/KeyPair.h"
+#include <openssl/rsa.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+KeyPair::KeyPair(KeyPairImpl::Ptr pKeyPairImpl): _pImpl(pKeyPairImpl)
+{
+}
+
+
+KeyPair::~KeyPair()
+{
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/KeyPairImpl.cpp b/base/poco/Crypto/src/KeyPairImpl.cpp
new file mode 100644
index 00000000000..c782f04270d
--- /dev/null
+++ b/base/poco/Crypto/src/KeyPairImpl.cpp
@@ -0,0 +1,35 @@
+//
+// KeyPairImpl.cpp
+//
+//
+// Library: Crypto
+// Package: CryptoCore
+// Module:  KeyPairImpl
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/KeyPairImpl.h"
+
+
+namespace Poco {
+namespace Crypto {
+
+
+KeyPairImpl::KeyPairImpl(const std::string& name, Type type):
+	_name(name),
+	_type(type)
+{
+}
+
+
+KeyPairImpl::~KeyPairImpl()
+{
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/OpenSSLInitializer.cpp b/base/poco/Crypto/src/OpenSSLInitializer.cpp
new file mode 100644
index 00000000000..a3bc1d01431
--- /dev/null
+++ b/base/poco/Crypto/src/OpenSSLInitializer.cpp
@@ -0,0 +1,190 @@
+//
+// OpenSSLInitializer.cpp
+//
+// Library: Crypto
+// Package: CryptoCore
+// Module:  OpenSSLInitializer
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include "Poco/RandomStream.h"
+#include "Poco/Thread.h"
+#include <openssl/ssl.h>
+#include <openssl/rand.h>
+#include <openssl/crypto.h>
+#include <openssl/err.h>
+#if OPENSSL_VERSION_NUMBER >= 0x0907000L
+#include <openssl/conf.h>
+#endif
+#if defined(POCO_OS_FAMILY_WINDOWS)
+	#define POCO_STR_HELPER(x) #x
+	#define POCO_STR(x) POCO_STR_HELPER(x)
+	#if defined POCO_INTERNAL_OPENSSL_MSVC_VER
+		#define POCO_INTERNAL_OPENSSL_BUILD          \
+				" (POCO internal build, MSVC version " \
+				POCO_STR(POCO_INTERNAL_OPENSSL_MSVC_VER) ")"
+	#else
+		#define POCO_INTERNAL_OPENSSL_BUILD ""
+	#endif
+	#pragma message (OPENSSL_VERSION_TEXT POCO_INTERNAL_OPENSSL_BUILD)
+#endif
+
+
+using Poco::RandomInputStream;
+using Poco::Thread;
+
+
+#if defined(_MSC_VER) && !defined(_DLL) && defined(POCO_INTERNAL_OPENSSL_MSVC_VER)
+
+	#if (POCO_MSVS_VERSION >= 2015)
+		FILE _iob[] = { *stdin, *stdout, *stderr };
+		extern "C" FILE * __cdecl __iob_func(void) { return _iob; }
+	#endif // (POCO_MSVS_VERSION >= 2015)
+
+	#if (POCO_MSVS_VERSION < 2012)
+		extern "C" __declspec(noreturn) void __cdecl __report_rangecheckfailure(void) { ::ExitProcess(1); }
+	#endif // (POCO_MSVS_VERSION < 2012)
+
+#endif // _MSC_VER && _MT && !POCO_EXTERNAL_OPENSSL && (POCO_MSVS_VERSION < 2013)
+
+
+namespace Poco {
+namespace Crypto {
+
+
+Poco::FastMutex* OpenSSLInitializer::_mutexes(0);
+Poco::AtomicCounter OpenSSLInitializer::_rc;
+
+
+OpenSSLInitializer::OpenSSLInitializer()
+{
+	initialize();
+}
+
+
+OpenSSLInitializer::~OpenSSLInitializer()
+{
+	try
+	{
+		uninitialize();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void OpenSSLInitializer::initialize()
+{
+	if (++_rc == 1)
+	{
+#if OPENSSL_VERSION_NUMBER >= 0x0907000L
+		OPENSSL_config(NULL);
+#endif
+		SSL_library_init();
+		SSL_load_error_strings();
+		OpenSSL_add_all_algorithms();
+		
+		char seed[SEEDSIZE];
+		RandomInputStream rnd;
+		rnd.read(seed, sizeof(seed));
+		RAND_seed(seed, SEEDSIZE);
+		
+		int nMutexes = CRYPTO_num_locks();
+		_mutexes = new Poco::FastMutex[nMutexes];
+		CRYPTO_set_locking_callback(&OpenSSLInitializer::lock);
+#ifndef POCO_OS_FAMILY_WINDOWS
+// Not needed on Windows (see SF #110: random unhandled exceptions when linking with ssl).
+// https://sourceforge.net/p/poco/bugs/110/
+//
+// From http://www.openssl.org/docs/crypto/threads.html :
+// "If the application does not register such a callback using CRYPTO_THREADID_set_callback(), 
+//  then a default implementation is used - on Windows and BeOS this uses the system's 
+//  default thread identifying APIs"
+		CRYPTO_set_id_callback(&OpenSSLInitializer::id);
+#endif
+		CRYPTO_set_dynlock_create_callback(&OpenSSLInitializer::dynlockCreate);
+		CRYPTO_set_dynlock_lock_callback(&OpenSSLInitializer::dynlock);
+		CRYPTO_set_dynlock_destroy_callback(&OpenSSLInitializer::dynlockDestroy);
+	}
+}
+
+
+void OpenSSLInitializer::uninitialize()
+{
+	if (--_rc == 0)
+	{
+		EVP_cleanup();
+		ERR_free_strings();
+		CRYPTO_set_locking_callback(0);
+#ifndef POCO_OS_FAMILY_WINDOWS
+		CRYPTO_set_id_callback(0);
+#endif
+		delete [] _mutexes;
+		
+		CONF_modules_free();
+	}
+}
+
+
+void OpenSSLInitializer::lock(int mode, int n, const char* file, int line)
+{
+	if (mode & CRYPTO_LOCK)
+		_mutexes[n].lock();
+	else
+		_mutexes[n].unlock();
+}
+
+
+unsigned long OpenSSLInitializer::id()
+{
+	// Note: we use an old-style C cast here because
+	// neither static_cast<> nor reinterpret_cast<>
+	// work uniformly across all platforms.
+	return (unsigned long) Poco::Thread::currentTid();
+}
+
+
+struct CRYPTO_dynlock_value* OpenSSLInitializer::dynlockCreate(const char* file, int line)
+{
+	return new CRYPTO_dynlock_value;
+}
+
+
+void OpenSSLInitializer::dynlock(int mode, struct CRYPTO_dynlock_value* lock, const char* file, int line)
+{
+	poco_check_ptr (lock);
+
+	if (mode & CRYPTO_LOCK)
+		lock->_mutex.lock();
+	else
+		lock->_mutex.unlock();
+}
+
+
+void OpenSSLInitializer::dynlockDestroy(struct CRYPTO_dynlock_value* lock, const char* file, int line)
+{
+	delete lock;
+}
+
+
+void initializeCrypto()
+{
+	OpenSSLInitializer::initialize();
+}
+
+
+void uninitializeCrypto()
+{
+	OpenSSLInitializer::uninitialize();
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/PKCS12Container.cpp b/base/poco/Crypto/src/PKCS12Container.cpp
new file mode 100644
index 00000000000..def89bf0898
--- /dev/null
+++ b/base/poco/Crypto/src/PKCS12Container.cpp
@@ -0,0 +1,191 @@
+//
+// PKCS12Container.cpp
+//
+//
+// Library: Crypto
+// Package: Certificate
+// Module:  PKCS12Container
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/PKCS12Container.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/StreamCopier.h"
+#include <sstream>
+#include <openssl/err.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+PKCS12Container::PKCS12Container(std::istream& istr, const std::string& password): _pKey(0)
+{
+	std::ostringstream ostr;
+	Poco::StreamCopier::copyStream(istr, ostr);
+	const std::string& cont = ostr.str();
+
+	BIO *pBIO = BIO_new_mem_buf(const_cast<char*>(cont.data()), static_cast<int>(cont.size()));
+	if (pBIO)
+	{
+		PKCS12* pPKCS12 = 0;
+		d2i_PKCS12_bio(pBIO, &pPKCS12);
+		BIO_free(pBIO);
+		if (!pPKCS12) throw OpenSSLException("PKCS12Container(istream&, const string&)");
+		load(pPKCS12, password);
+	}
+	else
+	{
+		throw Poco::NullPointerException("PKCS12Container(istream&, const string&)");
+	}
+}
+
+
+PKCS12Container::PKCS12Container(const std::string& path, const std::string& password): _pKey(0)
+{
+	FILE* pFile = fopen(path.c_str(), "rb");
+	if (pFile)
+	{
+		PKCS12* pPKCS12 = d2i_PKCS12_fp(pFile, NULL);
+		fclose (pFile);
+		if (!pPKCS12) throw OpenSSLException("PKCS12Container(const string&, const string&)");
+		load(pPKCS12, password);
+	}
+	else
+	{
+		throw Poco::OpenFileException("PKCS12Container: " + path);
+	}
+}
+
+
+PKCS12Container::PKCS12Container(const PKCS12Container& other):
+	_pKey(EVPPKey::duplicate(other._pKey, &_pKey)),
+	_pX509Cert(new X509Certificate(*other._pX509Cert)),
+	_caCertList(other._caCertList),
+	_caCertNames(other._caCertNames),
+	_pkcsFriendlyName(other._pkcsFriendlyName)
+{
+}
+
+
+PKCS12Container& PKCS12Container::operator = (const PKCS12Container& other)
+{
+	if (&other != this)
+	{
+		if (_pKey) EVP_PKEY_free(_pKey);
+		_pKey = EVPPKey::duplicate(other._pKey, &_pKey);
+		_pX509Cert.reset(new X509Certificate(*other._pX509Cert));
+		_caCertList = other._caCertList;
+		_caCertNames = other._caCertNames;
+		_pkcsFriendlyName = other._pkcsFriendlyName;
+	}
+	return *this;
+}
+
+
+#ifdef POCO_ENABLE_CPP11
+
+
+PKCS12Container::PKCS12Container(PKCS12Container&& other):
+	_pKey(other._pKey),
+	_pX509Cert(std::move(other._pX509Cert)),
+	_caCertList(std::move(other._caCertList)),
+	_caCertNames(std::move(other._caCertNames)),
+	_pkcsFriendlyName(std::move(other._pkcsFriendlyName))
+{
+	other._pKey = 0;
+}
+
+
+PKCS12Container& PKCS12Container::operator = (PKCS12Container&& other)
+{
+	if (&other != this)
+	{
+		if (_pKey) EVP_PKEY_free(_pKey);
+		_pKey = other._pKey; other._pKey = 0;
+		_pX509Cert = std::move(other._pX509Cert);
+		_caCertList = std::move(other._caCertList);
+		_caCertNames = std::move(other._caCertNames);
+		_pkcsFriendlyName = std::move(other._pkcsFriendlyName);
+	}
+	return *this;
+}
+
+
+#endif // POCO_ENABLE_CPP11
+
+
+PKCS12Container::~PKCS12Container()
+{
+	if (_pKey) EVP_PKEY_free(_pKey);
+}
+
+
+std::string PKCS12Container::extractFriendlyName(X509* pCert)
+{
+	std::string friendlyName;
+	if(!pCert) throw NullPointerException("PKCS12Container::extractFriendlyName(X509)");
+
+	// This is how PKCS12_add_cert() sets friendlyName (via PKCS12_add_friendlyname())
+	int namelen = 0;
+	char *name = (char *)X509_alias_get0(pCert, &namelen);
+
+	friendlyName = std::string(name, namelen);
+	return friendlyName;
+}
+
+
+void PKCS12Container::load(PKCS12* pPKCS12, const std::string& password)
+{
+	if (pPKCS12)
+	{
+		X509* pCert = 0;
+		STACK_OF(X509)* pCA = 0;
+		if (PKCS12_parse(pPKCS12, password.c_str(), &_pKey, &pCert, &pCA))
+		{
+			if (pCert)
+			{
+				_pX509Cert.reset(new X509Certificate(pCert, true));
+				_pkcsFriendlyName = extractFriendlyName(pCert);
+			}
+			else _pX509Cert.reset();
+
+			_caCertList.clear();
+			_caCertNames.clear();
+			if (pCA)
+			{
+				int certCount = sk_X509_num(pCA);
+				for (int i = 0; i < certCount; ++i)
+				{
+					X509* pX509 = sk_X509_value(pCA, i);
+					if (pX509)
+					{
+						_caCertList.push_back(X509Certificate(pX509, true));
+						_caCertNames.push_back(extractFriendlyName(pX509));
+					}
+					else throw OpenSSLException("PKCS12Container::load()");
+				}
+			}
+		}
+		else
+		{
+			throw OpenSSLException();
+		}
+		PKCS12_free(pPKCS12);
+		sk_X509_pop_free(pCA, X509_free);
+		if (pCert) X509_free(pCert);
+		poco_assert_dbg (_caCertList.size() == _caCertNames.size());
+	}
+	else
+	{
+		throw NullPointerException("PKCS12Container: struct PKCS12");
+	}
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/RSACipherImpl.cpp b/base/poco/Crypto/src/RSACipherImpl.cpp
new file mode 100644
index 00000000000..4f9ddcf32ad
--- /dev/null
+++ b/base/poco/Crypto/src/RSACipherImpl.cpp
@@ -0,0 +1,342 @@
+//
+// RSACipherImpl.cpp
+//
+// Library: Crypto
+// Package: RSA
+// Module:  RSACipherImpl
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/RSACipherImpl.h"
+#include "Poco/Crypto/CryptoTransform.h"
+#include "Poco/Exception.h"
+#include <openssl/err.h>
+#include <openssl/rsa.h>
+#include <cstring>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+namespace
+{
+	void throwError()
+	{
+		unsigned long err;
+		std::string msg;
+
+		while ((err = ERR_get_error()))
+		{
+			if (!msg.empty())
+				msg.append("; ");
+			msg.append(ERR_error_string(err, 0));
+		}
+
+		throw Poco::IOException(msg);
+	}
+
+
+	int mapPaddingMode(RSAPaddingMode paddingMode)
+	{
+		switch (paddingMode)
+		{
+		case RSA_PADDING_PKCS1:
+			return RSA_PKCS1_PADDING;
+		case RSA_PADDING_PKCS1_OAEP:
+			return RSA_PKCS1_OAEP_PADDING;
+		case RSA_PADDING_NONE:
+			return RSA_NO_PADDING;
+		default:
+			poco_bugcheck();
+			return RSA_NO_PADDING;
+		}
+	}
+
+
+	class RSAEncryptImpl: public CryptoTransform
+	{
+	public:
+		RSAEncryptImpl(const RSA* pRSA, RSAPaddingMode paddingMode);
+		~RSAEncryptImpl();
+
+		std::size_t blockSize() const;
+		std::size_t maxDataSize() const;
+		std::string getTag(std::size_t);
+		void setTag(const std::string&);
+
+		std::streamsize transform(
+			const unsigned char* input,
+			std::streamsize		 inputLength,
+			unsigned char*		 output,
+			std::streamsize		 outputLength);
+
+		std::streamsize finalize(unsigned char*	output, std::streamsize length);
+
+	private:
+		const RSA*      _pRSA;
+		RSAPaddingMode  _paddingMode;
+		std::streamsize _pos;
+		unsigned char*  _pBuf;
+	};
+
+
+	RSAEncryptImpl::RSAEncryptImpl(const RSA* pRSA, RSAPaddingMode paddingMode):
+			_pRSA(pRSA),
+			_paddingMode(paddingMode),
+			_pos(0),
+			_pBuf(0)
+	{
+		_pBuf = new unsigned char[blockSize()];
+	}
+
+
+	RSAEncryptImpl::~RSAEncryptImpl()
+	{
+		delete [] _pBuf;
+	}
+
+
+	std::size_t RSAEncryptImpl::blockSize() const
+	{
+		return RSA_size(_pRSA);
+	}
+
+
+	std::size_t RSAEncryptImpl::maxDataSize() const
+	{
+		std::size_t size = blockSize();
+		switch (_paddingMode)
+		{
+		case RSA_PADDING_PKCS1:
+		case RSA_PADDING_SSLV23:
+			size -= 11;
+			break;
+		case RSA_PADDING_PKCS1_OAEP:
+			size -= 41;
+			break;
+		default:
+			break;
+		}
+		return size;
+	}
+
+
+	std::string RSAEncryptImpl::getTag(std::size_t)
+	{
+		return std::string();
+	}
+
+
+	void RSAEncryptImpl::setTag(const std::string&)
+	{
+	}
+
+
+	std::streamsize RSAEncryptImpl::transform(
+		const unsigned char* input,
+		std::streamsize		 inputLength,
+		unsigned char*		 output,
+		std::streamsize		 outputLength)
+	{
+		// always fill up the buffer before writing!
+		std::streamsize maxSize = static_cast<std::streamsize>(maxDataSize());
+		std::streamsize rsaSize = static_cast<std::streamsize>(blockSize());
+		poco_assert_dbg(_pos <= maxSize);
+		poco_assert (outputLength >= rsaSize);
+		int rc = 0;
+		while (inputLength > 0)
+		{
+			// check how many data bytes we are missing to get the buffer full
+			poco_assert_dbg (maxSize >= _pos);
+			std::streamsize missing = maxSize - _pos;
+			if (missing == 0)
+			{
+				poco_assert (outputLength >= rsaSize);
+				int n = RSA_public_encrypt(static_cast<int>(maxSize), _pBuf, output, const_cast<RSA*>(_pRSA), mapPaddingMode(_paddingMode));
+				if (n == -1)
+					throwError();
+				rc += n;
+				output += n;
+				outputLength -= n;
+				_pos = 0;
+
+			}
+			else
+			{
+				if (missing > inputLength)
+					missing = inputLength;
+
+				std::memcpy(_pBuf + _pos, input, static_cast<std::size_t>(missing));
+				input += missing;
+				_pos += missing;
+				inputLength -= missing;
+			}
+		}
+		return rc;
+	}
+
+
+	std::streamsize RSAEncryptImpl::finalize(unsigned char*	output, std::streamsize length)
+	{
+		poco_assert (length >= blockSize());
+		poco_assert (_pos <= maxDataSize());
+		int rc = 0;
+		if (_pos > 0)
+		{
+			rc = RSA_public_encrypt(static_cast<int>(_pos), _pBuf, output, const_cast<RSA*>(_pRSA), mapPaddingMode(_paddingMode));
+			if (rc == -1) throwError();
+		}
+		return rc;
+	}
+
+
+	class RSADecryptImpl: public CryptoTransform
+	{
+	public:
+		RSADecryptImpl(const RSA* pRSA, RSAPaddingMode paddingMode);
+		~RSADecryptImpl();
+
+		std::size_t blockSize() const;
+		std::string getTag(std::size_t);
+		void setTag(const std::string&);
+
+		std::streamsize transform(
+			const unsigned char* input,
+			std::streamsize		 inputLength,
+			unsigned char*		 output,
+			std::streamsize		 outputLength);
+
+		std::streamsize finalize(
+			unsigned char*	output,
+			std::streamsize length);
+
+	private:
+		const RSA*      _pRSA;
+		RSAPaddingMode  _paddingMode;
+		std::streamsize _pos;
+		unsigned char*  _pBuf;
+	};
+
+
+	RSADecryptImpl::RSADecryptImpl(const RSA* pRSA, RSAPaddingMode paddingMode):
+			_pRSA(pRSA),
+			_paddingMode(paddingMode),
+			_pos(0),
+			_pBuf(0)
+	{
+		_pBuf = new unsigned char[blockSize()];
+	}
+
+
+	RSADecryptImpl::~RSADecryptImpl()
+	{
+		delete [] _pBuf;
+	}
+
+
+	std::size_t RSADecryptImpl::blockSize() const
+	{
+		return RSA_size(_pRSA);
+	}
+
+
+	std::string RSADecryptImpl::getTag(std::size_t)
+	{
+		return std::string();
+	}
+
+
+	void RSADecryptImpl::setTag(const std::string&)
+	{
+	}
+
+
+	std::streamsize RSADecryptImpl::transform(
+		const unsigned char* input,
+		std::streamsize		 inputLength,
+		unsigned char*		 output,
+		std::streamsize		 outputLength)
+	{
+
+		// always fill up the buffer before decrypting!
+		std::streamsize rsaSize = static_cast<std::streamsize>(blockSize());
+		poco_assert_dbg(_pos <= rsaSize);
+		poco_assert (outputLength >= rsaSize);
+		int rc = 0;
+		while (inputLength > 0)
+		{
+			// check how many data bytes we are missing to get the buffer full
+			poco_assert_dbg (rsaSize >= _pos);
+			std::streamsize missing = rsaSize - _pos;
+			if (missing == 0)
+			{
+				int tmp = RSA_private_decrypt(static_cast<int>(rsaSize), _pBuf, output, const_cast<RSA*>(_pRSA), mapPaddingMode(_paddingMode));
+				if (tmp == -1)
+					throwError();
+				rc += tmp;
+				output += tmp;
+				outputLength -= tmp;
+				_pos = 0;
+
+			}
+			else
+			{
+				if (missing > inputLength)
+					missing = inputLength;
+
+				std::memcpy(_pBuf + _pos, input, static_cast<std::size_t>(missing));
+				input += missing;
+				_pos += missing;
+				inputLength -= missing;
+			}
+		}
+		return rc;
+	}
+
+
+	std::streamsize RSADecryptImpl::finalize(unsigned char*	output, std::streamsize length)
+	{
+		poco_assert (length >= blockSize());
+		int rc = 0;
+		if (_pos > 0)
+		{
+			rc = RSA_private_decrypt(static_cast<int>(_pos), _pBuf, output, const_cast<RSA*>(_pRSA), mapPaddingMode(_paddingMode));
+			if (rc == -1)
+				throwError();
+		}
+		return rc;
+	}
+}
+
+
+RSACipherImpl::RSACipherImpl(const RSAKey& key, RSAPaddingMode paddingMode):
+	_key(key),
+	_paddingMode(paddingMode)
+{
+}
+
+
+RSACipherImpl::~RSACipherImpl()
+{
+}
+
+
+CryptoTransform* RSACipherImpl::createEncryptor()
+{
+	return new RSAEncryptImpl(_key.impl()->getRSA(), _paddingMode);
+}
+
+
+CryptoTransform* RSACipherImpl::createDecryptor()
+{
+	return new RSADecryptImpl(_key.impl()->getRSA(), _paddingMode);
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/RSADigestEngine.cpp b/base/poco/Crypto/src/RSADigestEngine.cpp
new file mode 100644
index 00000000000..948aa25ac6c
--- /dev/null
+++ b/base/poco/Crypto/src/RSADigestEngine.cpp
@@ -0,0 +1,96 @@
+//
+// RSADigestEngine.cpp
+//
+// Library: Crypto
+// Package: RSA
+// Module:  RSADigestEngine
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/RSADigestEngine.h"
+#include <openssl/rsa.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+RSADigestEngine::RSADigestEngine(const RSAKey& key, DigestType digestType):
+	_key(key),
+	_engine(digestType == DIGEST_MD5 ? "MD5" : "SHA1")
+{
+}
+
+RSADigestEngine::RSADigestEngine(const RSAKey& key, const std::string &name):
+	_key(key),
+	_engine(name)
+{
+}
+
+
+RSADigestEngine::~RSADigestEngine()
+{
+}
+
+
+std::size_t RSADigestEngine::digestLength() const
+{
+	return _engine.digestLength();
+}
+
+
+void RSADigestEngine::reset()
+{
+	_engine.reset();
+	_digest.clear();
+	_signature.clear();
+}
+
+	
+const DigestEngine::Digest& RSADigestEngine::digest()
+{
+	if (_digest.empty())
+	{
+		_digest = _engine.digest();
+	}
+	return _digest;
+}
+
+
+const DigestEngine::Digest& RSADigestEngine::signature()
+{
+	if (_signature.empty())
+	{
+		digest();
+		_signature.resize(_key.size());
+		unsigned sigLen = static_cast<unsigned>(_signature.size());
+		RSA_sign(_engine.nid(), &_digest[0], static_cast<unsigned>(_digest.size()), &_signature[0], &sigLen, _key.impl()->getRSA());
+		// truncate _sig to sigLen
+		if (sigLen < _signature.size())
+			_signature.resize(sigLen);
+	}
+    return _signature;
+}
+
+	
+bool RSADigestEngine::verify(const DigestEngine::Digest& sig)
+{
+	digest();
+	DigestEngine::Digest sigCpy = sig; // copy becausse RSA_verify can modify sigCpy
+	int ret = RSA_verify(_engine.nid(), &_digest[0], static_cast<unsigned>(_digest.size()), &sigCpy[0], static_cast<unsigned>(sigCpy.size()), _key.impl()->getRSA());
+	return ret != 0;
+}
+
+
+void RSADigestEngine::updateImpl(const void* data, std::size_t length)
+{
+	_engine.update(data, length);
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Crypto/src/RSAKey.cpp b/base/poco/Crypto/src/RSAKey.cpp
new file mode 100644
index 00000000000..b81a0281bf5
--- /dev/null
+++ b/base/poco/Crypto/src/RSAKey.cpp
@@ -0,0 +1,87 @@
+//
+// RSAKey.cpp
+//
+// Library: Crypto
+// Package: RSA
+// Module:  RSAKey
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/RSAKey.h"
+#include <openssl/rsa.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+RSAKey::RSAKey(const EVPPKey& key):
+	KeyPair(new RSAKeyImpl(key)),
+	_pImpl(KeyPair::impl().cast<RSAKeyImpl>())
+{
+}
+
+
+RSAKey::RSAKey(const X509Certificate& cert):
+	KeyPair(new RSAKeyImpl(cert)),
+	_pImpl(KeyPair::impl().cast<RSAKeyImpl>())
+{
+}
+
+
+RSAKey::RSAKey(const PKCS12Container& cont):
+	KeyPair(new RSAKeyImpl(cont)),
+	_pImpl(KeyPair::impl().cast<RSAKeyImpl>())
+{
+}
+
+
+RSAKey::RSAKey(KeyLength keyLength, Exponent exp):
+	KeyPair(new RSAKeyImpl(keyLength, (exp == EXP_LARGE) ? RSA_F4 : RSA_3)),
+	_pImpl(KeyPair::impl().cast<RSAKeyImpl>())
+{
+}
+
+
+RSAKey::RSAKey(const std::string& publicKeyFile, const std::string& privateKeyFile, const std::string& privateKeyPassphrase):
+	KeyPair(new RSAKeyImpl(publicKeyFile, privateKeyFile, privateKeyPassphrase)),
+	_pImpl(KeyPair::impl().cast<RSAKeyImpl>())
+{
+}
+
+
+RSAKey::RSAKey(std::istream* pPublicKeyStream, std::istream* pPrivateKeyStream, const std::string& privateKeyPassphrase):
+	KeyPair(new RSAKeyImpl(pPublicKeyStream, pPrivateKeyStream, privateKeyPassphrase)),
+	_pImpl(KeyPair::impl().cast<RSAKeyImpl>())
+{
+}
+
+
+RSAKey::~RSAKey()
+{
+}
+
+RSAKeyImpl::ByteVec RSAKey::modulus() const
+{
+	return _pImpl->modulus();
+}
+
+
+RSAKeyImpl::ByteVec RSAKey::encryptionExponent() const
+{
+	return _pImpl->encryptionExponent();
+}
+
+
+RSAKeyImpl::ByteVec RSAKey::decryptionExponent() const
+{
+	return _pImpl->decryptionExponent();
+}
+
+
+} } // namespace Poco::Crypto
\ No newline at end of file
diff --git a/base/poco/Crypto/src/RSAKeyImpl.cpp b/base/poco/Crypto/src/RSAKeyImpl.cpp
new file mode 100644
index 00000000000..86089b828b1
--- /dev/null
+++ b/base/poco/Crypto/src/RSAKeyImpl.cpp
@@ -0,0 +1,386 @@
+//
+// RSAKeyImpl.cpp
+//
+// Library: Crypto
+// Package: RSA
+// Module:  RSAKeyImpl
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/RSAKeyImpl.h"
+#include "Poco/Crypto/X509Certificate.h"
+#include "Poco/Crypto/PKCS12Container.h"
+#include "Poco/FileStream.h"
+#include "Poco/StreamCopier.h"
+#include <sstream>
+#include <openssl/pem.h>
+#include <openssl/rsa.h>
+#include <openssl/evp.h>
+#if OPENSSL_VERSION_NUMBER >= 0x00908000L
+#include <openssl/bn.h>
+#endif
+
+
+namespace Poco {
+namespace Crypto {
+
+
+RSAKeyImpl::RSAKeyImpl(const EVPPKey& key):
+	KeyPairImpl("rsa", KT_RSA_IMPL),
+	_pRSA(EVP_PKEY_get1_RSA(const_cast<EVP_PKEY*>((const EVP_PKEY*)key)))
+{
+	if (!_pRSA) throw OpenSSLException();
+}
+
+
+RSAKeyImpl::RSAKeyImpl(const X509Certificate& cert):
+	KeyPairImpl("rsa", KT_RSA_IMPL),
+	_pRSA(0)
+{
+	const X509* pCert = cert.certificate();
+	EVP_PKEY* pKey = X509_get_pubkey(const_cast<X509*>(pCert));
+	if (pKey)
+	{
+		_pRSA = EVP_PKEY_get1_RSA(pKey);
+		EVP_PKEY_free(pKey);
+	}
+	else
+		throw OpenSSLException("RSAKeyImpl(const X509Certificate&)");
+}
+
+
+RSAKeyImpl::RSAKeyImpl(const PKCS12Container& cont):
+	KeyPairImpl("rsa", KT_RSA_IMPL),
+	_pRSA(0)
+{
+	EVPPKey key = cont.getKey();
+	_pRSA = EVP_PKEY_get1_RSA(key);
+}
+
+
+RSAKeyImpl::RSAKeyImpl(int keyLength, unsigned long exponent): KeyPairImpl("rsa", KT_RSA_IMPL),
+	_pRSA(0)
+{
+#if OPENSSL_VERSION_NUMBER >= 0x00908000L
+	_pRSA = RSA_new();
+	int ret = 0;
+	BIGNUM* bn = 0;
+	try
+	{
+		bn = BN_new();
+		BN_set_word(bn, exponent);
+		ret = RSA_generate_key_ex(_pRSA, keyLength, bn, 0);
+		BN_free(bn);
+	}
+	catch (...)
+	{
+		BN_free(bn);
+		throw;
+	}
+	if (!ret) throw Poco::InvalidArgumentException("Failed to create RSA context");
+#else
+	_pRSA = RSA_generate_key(keyLength, exponent, 0, 0);
+	if (!_pRSA) throw Poco::InvalidArgumentException("Failed to create RSA context");
+#endif
+}
+
+
+RSAKeyImpl::RSAKeyImpl(const std::string& publicKeyFile, 
+	const std::string& privateKeyFile, 
+	const std::string& privateKeyPassphrase): KeyPairImpl("rsa", KT_RSA_IMPL),
+		_pRSA(0)
+{
+	poco_assert_dbg(_pRSA == 0);
+
+	_pRSA = RSA_new();
+	if (!publicKeyFile.empty())
+	{
+		BIO* bio = BIO_new(BIO_s_file());
+		if (!bio) throw Poco::IOException("Cannot create BIO for reading public key", publicKeyFile);
+		int rc = BIO_read_filename(bio, publicKeyFile.c_str());
+		if (rc)
+		{
+			RSA* pubKey = PEM_read_bio_RSAPublicKey(bio, &_pRSA, 0, 0);
+			if (!pubKey)
+			{
+				int rc = BIO_reset(bio);
+				// BIO_reset() normally returns 1 for success and 0 or -1 for failure. 
+				// File BIOs are an exception, they return 0 for success and -1 for failure.
+				if (rc != 0) throw Poco::FileException("Failed to load public key", publicKeyFile);
+				pubKey = PEM_read_bio_RSA_PUBKEY(bio, &_pRSA, 0, 0);
+			}
+			BIO_free(bio);
+			if (!pubKey)
+			{
+				freeRSA();
+				throw Poco::FileException("Failed to load public key", publicKeyFile);
+			}
+		}
+		else
+		{
+			freeRSA();
+			throw Poco::FileNotFoundException("Public key file", publicKeyFile);
+		}
+	}
+
+	if (!privateKeyFile.empty())
+	{
+		BIO* bio = BIO_new(BIO_s_file());
+		if (!bio) throw Poco::IOException("Cannot create BIO for reading private key", privateKeyFile);
+		int rc = BIO_read_filename(bio, privateKeyFile.c_str());
+		if (rc)
+		{
+			RSA* privKey = 0;
+			if (privateKeyPassphrase.empty())
+				privKey = PEM_read_bio_RSAPrivateKey(bio, &_pRSA, 0, 0);
+			else
+				privKey = PEM_read_bio_RSAPrivateKey(bio, &_pRSA, 0, const_cast<char*>(privateKeyPassphrase.c_str()));
+			BIO_free(bio);
+			if (!privKey)
+			{
+				freeRSA();
+				throw Poco::FileException("Failed to load private key", privateKeyFile);
+			}
+		}
+		else
+		{
+			freeRSA();
+			throw Poco::FileNotFoundException("Private key file", privateKeyFile);
+		}
+	}
+}
+
+
+RSAKeyImpl::RSAKeyImpl(std::istream* pPublicKeyStream,
+	std::istream* pPrivateKeyStream,
+	const std::string& privateKeyPassphrase): KeyPairImpl("rsa", KT_RSA_IMPL),
+		_pRSA(0)
+{
+	poco_assert_dbg(_pRSA == 0);
+
+	_pRSA = RSA_new();
+	if (pPublicKeyStream)
+	{
+		std::string publicKeyData;
+		Poco::StreamCopier::copyToString(*pPublicKeyStream, publicKeyData);
+		BIO* bio = BIO_new_mem_buf(const_cast<char*>(publicKeyData.data()), static_cast<int>(publicKeyData.size()));
+		if (!bio) throw Poco::IOException("Cannot create BIO for reading public key");
+		RSA* publicKey = PEM_read_bio_RSAPublicKey(bio, &_pRSA, 0, 0);
+		if (!publicKey)
+		{
+			int rc = BIO_reset(bio);
+			// BIO_reset() normally returns 1 for success and 0 or -1 for failure. 
+			// File BIOs are an exception, they return 0 for success and -1 for failure.
+			if (rc != 1) throw Poco::FileException("Failed to load public key");
+			publicKey = PEM_read_bio_RSA_PUBKEY(bio, &_pRSA, 0, 0);
+		}
+		BIO_free(bio);
+		if (!publicKey)
+		{
+			freeRSA();
+			throw Poco::FileException("Failed to load public key");
+		}
+	}
+
+	if (pPrivateKeyStream)
+	{
+		std::string privateKeyData;
+		Poco::StreamCopier::copyToString(*pPrivateKeyStream, privateKeyData);
+		BIO* bio = BIO_new_mem_buf(const_cast<char*>(privateKeyData.data()), static_cast<int>(privateKeyData.size()));
+		if (!bio) throw Poco::IOException("Cannot create BIO for reading private key");
+		RSA* privateKey = 0;
+		if (privateKeyPassphrase.empty())
+			privateKey = PEM_read_bio_RSAPrivateKey(bio, &_pRSA, 0, 0);
+		else
+			privateKey = PEM_read_bio_RSAPrivateKey(bio, &_pRSA, 0, const_cast<char*>(privateKeyPassphrase.c_str()));
+		BIO_free(bio);
+		if (!privateKey)
+		{
+			freeRSA();
+			throw Poco::FileException("Failed to load private key");
+		}
+	}
+}
+
+
+RSAKeyImpl::~RSAKeyImpl()
+{
+	freeRSA();
+}
+
+
+void RSAKeyImpl::freeRSA()
+{
+	if (_pRSA) RSA_free(_pRSA);
+	_pRSA = 0;
+}
+
+
+int RSAKeyImpl::size() const
+{
+	return RSA_size(_pRSA);
+}
+
+
+RSAKeyImpl::ByteVec RSAKeyImpl::modulus() const
+{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
+	const BIGNUM* n = 0;
+	const BIGNUM* e = 0;
+	const BIGNUM* d = 0;
+	RSA_get0_key(_pRSA, &n, &e, &d);
+	return convertToByteVec(n);
+#else
+	return convertToByteVec(_pRSA->n);
+#endif
+}
+
+
+RSAKeyImpl::ByteVec RSAKeyImpl::encryptionExponent() const
+{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
+	const BIGNUM* n = 0;
+	const BIGNUM* e = 0;
+	const BIGNUM* d = 0;
+	RSA_get0_key(_pRSA, &n, &e, &d);
+	return convertToByteVec(e);
+#else
+	return convertToByteVec(_pRSA->e);
+#endif
+}
+
+
+RSAKeyImpl::ByteVec RSAKeyImpl::decryptionExponent() const
+{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER)
+	const BIGNUM* n = 0;
+	const BIGNUM* e = 0;
+	const BIGNUM* d = 0;
+	RSA_get0_key(_pRSA, &n, &e, &d);
+	return convertToByteVec(d);
+#else
+	return convertToByteVec(_pRSA->d);
+#endif
+}
+
+
+void RSAKeyImpl::save(const std::string& publicKeyFile,
+	const std::string& privateKeyFile,
+	const std::string& privateKeyPassphrase) const
+{
+	if (!publicKeyFile.empty())
+	{
+		BIO* bio = BIO_new(BIO_s_file());
+		if (!bio) throw Poco::IOException("Cannot create BIO for writing public key file", publicKeyFile);
+		try
+		{
+			if (BIO_write_filename(bio, const_cast<char*>(publicKeyFile.c_str())))
+			{
+				if (!PEM_write_bio_RSAPublicKey(bio, _pRSA))
+					throw Poco::WriteFileException("Failed to write public key to file", publicKeyFile);
+			}
+			else throw Poco::CreateFileException("Cannot create public key file");
+		}
+		catch (...)
+		{
+			BIO_free(bio);
+			throw;
+		}
+		BIO_free(bio);
+	}
+	
+	if (!privateKeyFile.empty())
+	{
+		BIO* bio = BIO_new(BIO_s_file());
+		if (!bio) throw Poco::IOException("Cannot create BIO for writing private key file", privateKeyFile);
+		try
+		{
+			if (BIO_write_filename(bio, const_cast<char*>(privateKeyFile.c_str())))
+			{
+				int rc = 0;
+				if (privateKeyPassphrase.empty())
+					rc = PEM_write_bio_RSAPrivateKey(bio, _pRSA, 0, 0, 0, 0, 0);
+				else
+					rc = PEM_write_bio_RSAPrivateKey(bio, _pRSA, EVP_des_ede3_cbc(), 
+						reinterpret_cast<unsigned char*>(const_cast<char*>(privateKeyPassphrase.c_str())), 
+						static_cast<int>(privateKeyPassphrase.length()), 0, 0);
+				if (!rc) throw Poco::FileException("Failed to write private key to file", privateKeyFile);
+			}
+			else throw Poco::CreateFileException("Cannot create private key file", privateKeyFile);
+		}
+		catch (...)
+		{
+			BIO_free(bio);
+			throw;
+		}
+		BIO_free(bio);
+	}
+}
+
+
+void RSAKeyImpl::save(std::ostream* pPublicKeyStream,
+	std::ostream* pPrivateKeyStream,
+	const std::string& privateKeyPassphrase) const
+{
+	if (pPublicKeyStream)
+	{
+		BIO* bio = BIO_new(BIO_s_mem());
+		if (!bio) throw Poco::IOException("Cannot create BIO for writing public key");
+		if (!PEM_write_bio_RSAPublicKey(bio, _pRSA))
+		{
+			BIO_free(bio);
+			throw Poco::WriteFileException("Failed to write public key to stream");
+		}
+		char* pData;
+		long size = BIO_get_mem_data(bio, &pData);
+		pPublicKeyStream->write(pData, static_cast<std::streamsize>(size));
+		BIO_free(bio);
+	}
+
+	if (pPrivateKeyStream)
+	{
+		BIO* bio = BIO_new(BIO_s_mem());
+		if (!bio) throw Poco::IOException("Cannot create BIO for writing public key");
+		int rc = 0;
+		if (privateKeyPassphrase.empty())
+			rc = PEM_write_bio_RSAPrivateKey(bio, _pRSA, 0, 0, 0, 0, 0);
+		else
+			rc = PEM_write_bio_RSAPrivateKey(bio, _pRSA, EVP_des_ede3_cbc(), 
+				reinterpret_cast<unsigned char*>(const_cast<char*>(privateKeyPassphrase.c_str())), 
+				static_cast<int>(privateKeyPassphrase.length()), 0, 0);
+		if (!rc) 
+		{
+			BIO_free(bio);
+			throw Poco::FileException("Failed to write private key to stream");
+		}
+		char* pData;
+		long size = BIO_get_mem_data(bio, &pData);
+		pPrivateKeyStream->write(pData, static_cast<std::streamsize>(size));
+		BIO_free(bio);
+	}
+}
+
+
+RSAKeyImpl::ByteVec RSAKeyImpl::convertToByteVec(const BIGNUM* bn)
+{
+	int numBytes = BN_num_bytes(bn);
+	ByteVec byteVector(numBytes);
+
+	ByteVec::value_type* buffer = new ByteVec::value_type[numBytes];
+	BN_bn2bin(bn, buffer);
+
+	for (int i = 0; i < numBytes; ++i)
+		byteVector[i] = buffer[i];
+
+	delete [] buffer;
+
+	return byteVector;
+}
+
+
+} } // namespace Poco::Crypto
\ No newline at end of file
diff --git a/base/poco/Crypto/src/X509Certificate.cpp b/base/poco/Crypto/src/X509Certificate.cpp
new file mode 100644
index 00000000000..a32e465bb0a
--- /dev/null
+++ b/base/poco/Crypto/src/X509Certificate.cpp
@@ -0,0 +1,386 @@
+//
+// X509Certificate.cpp
+//
+// Library: Crypto
+// Package: Certificate
+// Module:  X509Certificate
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Crypto/X509Certificate.h"
+#include "Poco/Crypto/CryptoException.h"
+#include "Poco/StreamCopier.h"
+#include "Poco/String.h"
+#include "Poco/DateTimeParser.h"
+#include "Poco/Format.h"
+#include <sstream>
+#include <openssl/pem.h>
+#ifdef _WIN32
+// fix for WIN32 header conflict
+#undef X509_NAME 
+#endif
+#include <openssl/x509v3.h>
+#include <openssl/err.h>
+#include <openssl/evp.h>
+
+
+namespace Poco {
+namespace Crypto {
+
+
+X509Certificate::X509Certificate(std::istream& istr):
+	_pCert(0)
+{
+	load(istr);
+}
+
+
+X509Certificate::X509Certificate(const std::string& path):
+	_pCert(0)
+{
+	load(path);
+}
+
+
+X509Certificate::X509Certificate(X509* pCert):
+	_pCert(pCert)
+{
+	poco_check_ptr(_pCert);
+
+	init();
+}
+
+
+X509Certificate::X509Certificate(X509* pCert, bool shared):
+	_pCert(pCert)
+{
+	poco_check_ptr(_pCert);
+	
+	if (shared)
+	{
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+		X509_up_ref(_pCert);
+#else
+		_pCert->references++;
+#endif
+	}
+
+	init();
+}
+
+
+X509Certificate::X509Certificate(const X509Certificate& cert):
+	_issuerName(cert._issuerName),
+	_subjectName(cert._subjectName),
+	_serialNumber(cert._serialNumber),
+	_pCert(cert._pCert)
+{
+	_pCert = X509_dup(_pCert);
+}
+
+
+X509Certificate& X509Certificate::operator = (const X509Certificate& cert)
+{
+	X509Certificate tmp(cert);
+	swap(tmp);
+	return *this;
+}
+
+
+void X509Certificate::swap(X509Certificate& cert)
+{
+	using std::swap;
+	swap(cert._issuerName, _issuerName);
+	swap(cert._subjectName, _subjectName);
+	swap(cert._serialNumber, _serialNumber);
+	swap(cert._pCert, _pCert);
+}
+
+
+X509Certificate::~X509Certificate()
+{
+	X509_free(_pCert);
+}
+
+
+void X509Certificate::load(std::istream& istr)
+{
+	poco_assert (!_pCert);
+
+	std::stringstream certStream;
+	Poco::StreamCopier::copyStream(istr, certStream);
+	std::string cert = certStream.str();
+
+	BIO *pBIO = BIO_new_mem_buf(const_cast<char*>(cert.data()), static_cast<int>(cert.size()));
+	if (!pBIO) throw Poco::IOException("Cannot create BIO for reading certificate");
+	_pCert = PEM_read_bio_X509(pBIO, 0, 0, 0);
+	BIO_free(pBIO);
+
+	if (!_pCert) throw Poco::IOException("Failed to load certificate from stream");
+
+	init();
+}
+
+
+void X509Certificate::load(const std::string& path)
+{
+	poco_assert (!_pCert);
+
+	BIO *pBIO = BIO_new(BIO_s_file());
+	if (!pBIO) throw Poco::IOException("Cannot create BIO for reading certificate file", path);
+	if (!BIO_read_filename(pBIO, path.c_str()))
+	{
+		BIO_free(pBIO);
+		throw Poco::OpenFileException("Cannot open certificate file for reading", path);
+	}
+
+	_pCert = PEM_read_bio_X509(pBIO, 0, 0, 0);
+	BIO_free(pBIO);
+
+	if (!_pCert) throw Poco::ReadFileException("Faild to load certificate from", path);
+
+	init();
+}
+
+
+void X509Certificate::save(std::ostream& stream) const
+{
+	BIO *pBIO = BIO_new(BIO_s_mem());
+	if (!pBIO) throw Poco::IOException("Cannot create BIO for writing certificate");
+	try
+	{
+		if (!PEM_write_bio_X509(pBIO, _pCert)) 
+			throw Poco::IOException("Failed to write certificate to stream");
+
+		char *pData;
+		long size;
+		size = BIO_get_mem_data(pBIO, &pData);
+		stream.write(pData, size);
+	}
+	catch (...)
+	{
+		BIO_free(pBIO);
+		throw;
+	}
+	BIO_free(pBIO);
+}
+
+
+void X509Certificate::save(const std::string& path) const
+{
+	BIO *pBIO = BIO_new(BIO_s_file());
+	if (!pBIO) throw Poco::IOException("Cannot create BIO for reading certificate file", path);
+	if (!BIO_write_filename(pBIO, const_cast<char*>(path.c_str())))
+	{
+		BIO_free(pBIO);
+		throw Poco::CreateFileException("Cannot create certificate file", path);
+	}
+	try
+	{
+		if (!PEM_write_bio_X509(pBIO, _pCert)) 
+			throw Poco::WriteFileException("Failed to write certificate to file", path);
+	}
+	catch (...)
+	{
+		BIO_free(pBIO);
+		throw;
+	}
+	BIO_free(pBIO);
+}
+
+
+void X509Certificate::init()
+{
+	char buffer[NAME_BUFFER_SIZE];
+	X509_NAME_oneline(X509_get_issuer_name(_pCert), buffer, sizeof(buffer));
+	_issuerName = buffer;
+	X509_NAME_oneline(X509_get_subject_name(_pCert), buffer, sizeof(buffer));
+	_subjectName = buffer;
+	BIGNUM* pBN = ASN1_INTEGER_to_BN(X509_get_serialNumber(const_cast<X509*>(_pCert)), 0);
+	if (pBN)
+	{
+		char* pSN = BN_bn2hex(pBN);
+		if (pSN)
+		{
+			_serialNumber = pSN;
+			OPENSSL_free(pSN);
+		}
+		BN_free(pBN);
+	}
+}
+
+
+std::string X509Certificate::commonName() const
+{
+	return subjectName(NID_COMMON_NAME);
+}
+
+
+std::string X509Certificate::issuerName(NID nid) const
+{
+	if (X509_NAME* issuer = X509_get_issuer_name(_pCert))
+	{
+		char buffer[NAME_BUFFER_SIZE];
+		if (X509_NAME_get_text_by_NID(issuer, nid, buffer, sizeof(buffer)) >= 0)
+			return std::string(buffer);
+	}
+	return std::string();
+}
+
+
+std::string X509Certificate::subjectName(NID nid) const
+{
+	if (X509_NAME* subj = X509_get_subject_name(_pCert))
+	{
+		char buffer[NAME_BUFFER_SIZE];
+		if (X509_NAME_get_text_by_NID(subj, nid, buffer, sizeof(buffer)) >= 0)
+			return std::string(buffer);
+	}
+	return std::string();
+}
+
+
+void X509Certificate::extractNames(std::string& cmnName, std::set<std::string>& domainNames) const
+{
+	domainNames.clear(); 
+	if (STACK_OF(GENERAL_NAME)* names = static_cast<STACK_OF(GENERAL_NAME)*>(X509_get_ext_d2i(_pCert, NID_subject_alt_name, 0, 0)))
+	{
+		for (int i = 0; i < sk_GENERAL_NAME_num(names); ++i)
+		{
+			const GENERAL_NAME* name = sk_GENERAL_NAME_value(names, i);
+			if (name->type == GEN_DNS)
+			{
+				const char* data = reinterpret_cast<char*>(ASN1_STRING_data(name->d.ia5));
+				std::size_t len = ASN1_STRING_length(name->d.ia5);
+				domainNames.insert(std::string(data, len));
+			}
+		}
+		GENERAL_NAMES_free(names);
+	}
+ 
+	cmnName = commonName();
+	if (!cmnName.empty() && domainNames.empty())
+	{
+		domainNames.insert(cmnName);
+	}
+}
+
+
+Poco::DateTime X509Certificate::validFrom() const
+{
+	ASN1_TIME* certTime = X509_get_notBefore(_pCert);
+	std::string dateTime(reinterpret_cast<char*>(certTime->data));
+	int tzd;
+	return DateTimeParser::parse("%y%m%d%H%M%S", dateTime, tzd);
+}
+
+	
+Poco::DateTime X509Certificate::expiresOn() const
+{
+	ASN1_TIME* certTime = X509_get_notAfter(_pCert);
+	std::string dateTime(reinterpret_cast<char*>(certTime->data));
+	int tzd;
+	return DateTimeParser::parse("%y%m%d%H%M%S", dateTime, tzd);
+}
+
+
+bool X509Certificate::issuedBy(const X509Certificate& issuerCertificate) const
+{
+	X509* pCert = const_cast<X509*>(_pCert);
+	X509* pIssuerCert = const_cast<X509*>(issuerCertificate.certificate());
+	EVP_PKEY* pIssuerPublicKey = X509_get_pubkey(pIssuerCert);
+	if (!pIssuerPublicKey) throw Poco::InvalidArgumentException("Issuer certificate has no public key");
+	int rc = X509_verify(pCert, pIssuerPublicKey);
+	EVP_PKEY_free(pIssuerPublicKey);
+	return rc == 1;
+}
+
+
+bool X509Certificate::equals(const X509Certificate& otherCertificate) const
+{
+	X509* pCert = const_cast<X509*>(_pCert);
+	X509* pOtherCert = const_cast<X509*>(otherCertificate.certificate());
+	return X509_cmp(pCert, pOtherCert) == 0;
+}
+
+
+std::string X509Certificate::signatureAlgorithm() const
+{
+	int sigNID = NID_undef;
+
+#if (OPENSSL_VERSION_NUMBER >=  0x1010000fL) && !defined(LIBRESSL_VERSION_NUMBER)
+	sigNID = X509_get_signature_nid(_pCert);
+#else
+	poco_check_ptr(_pCert->sig_alg);
+	sigNID = OBJ_obj2nid(_pCert->sig_alg->algorithm);
+#endif
+
+	if (sigNID != NID_undef)
+	{
+		const char* pAlgName = OBJ_nid2ln(sigNID);
+		if (pAlgName) return std::string(pAlgName);
+		else throw OpenSSLException(Poco::format("X509Certificate::"
+				"signatureAlgorithm(): OBJ_nid2ln(%d)", sigNID));
+	}
+	else
+		throw NotFoundException("X509Certificate::signatureAlgorithm()");
+
+	return "";
+}
+
+
+X509Certificate::List X509Certificate::readPEM(const std::string& pemFileName)
+{
+	List caCertList;
+	BIO* pBIO = BIO_new_file(pemFileName.c_str(), "r");
+	if (pBIO == NULL) throw OpenFileException("X509Certificate::readPEM()");
+	X509* x = PEM_read_bio_X509(pBIO, NULL, 0, NULL);
+	if (!x) throw OpenSSLException(Poco::format("X509Certificate::readPEM(%s)", pemFileName));
+	while(x)
+	{
+		caCertList.push_back(X509Certificate(x));
+		x = PEM_read_bio_X509(pBIO, NULL, 0, NULL);
+	}
+	BIO_free(pBIO);
+	return caCertList;
+}
+
+
+void X509Certificate::writePEM(const std::string& pemFileName, const List& list)
+{
+	BIO* pBIO = BIO_new_file(pemFileName.c_str(), "a");
+	if (pBIO == NULL) throw OpenFileException("X509Certificate::writePEM()");
+	List::const_iterator it = list.begin();
+	List::const_iterator end = list.end();
+	for (; it != end; ++it)
+	{
+		if (!PEM_write_bio_X509(pBIO, const_cast<X509*>(it->certificate())))
+		{
+			throw OpenSSLException("X509Certificate::writePEM()");
+		}
+	}
+	BIO_free(pBIO);
+}
+
+
+void X509Certificate::print(std::ostream& out) const
+{
+	out << "subjectName: " << subjectName() << std::endl;
+	out << "issuerName: " << issuerName() << std::endl;
+	out << "commonName: " << commonName() << std::endl;
+	out << "country: " << subjectName(X509Certificate::NID_COUNTRY) << std::endl;
+	out << "localityName: " << subjectName(X509Certificate::NID_LOCALITY_NAME) << std::endl;
+	out << "stateOrProvince: " << subjectName(X509Certificate::NID_STATE_OR_PROVINCE) << std::endl;
+	out << "organizationName: " << subjectName(X509Certificate::NID_ORGANIZATION_NAME) << std::endl;
+	out << "organizationUnitName: " << subjectName(X509Certificate::NID_ORGANIZATION_UNIT_NAME) << std::endl;
+	out << "emailAddress: " << subjectName(X509Certificate::NID_PKCS9_EMAIL_ADDRESS) << std::endl;
+	out << "serialNumber: " << subjectName(X509Certificate::NID_SERIAL_NUMBER) << std::endl;
+}
+
+
+} } // namespace Poco::Crypto
diff --git a/base/poco/Data/CMakeLists.txt b/base/poco/Data/CMakeLists.txt
new file mode 100644
index 00000000000..142d3592b69
--- /dev/null
+++ b/base/poco/Data/CMakeLists.txt
@@ -0,0 +1,7 @@
+file (GLOB SRCS src/*.cpp)
+
+add_library (_poco_data ${SRCS})
+add_library (Poco::Data ALIAS _poco_data)
+
+target_include_directories (_poco_data SYSTEM PUBLIC "include")
+target_link_libraries (_poco_data PUBLIC Poco::Foundation)
diff --git a/base/poco/Data/ODBC/CMakeLists.txt b/base/poco/Data/ODBC/CMakeLists.txt
new file mode 100644
index 00000000000..4a49f915b67
--- /dev/null
+++ b/base/poco/Data/ODBC/CMakeLists.txt
@@ -0,0 +1,39 @@
+if (ENABLE_ODBC)
+    if (NOT TARGET ch_contrib::unixodbc)
+        message(FATAL_ERROR "Configuration error: unixodbc is not a target")
+    endif()
+
+    set (SRCS
+        src/Binder.cpp
+        src/ConnectionHandle.cpp
+        src/Connector.cpp
+        src/EnvironmentHandle.cpp
+        src/Extractor.cpp
+        src/ODBCException.cpp
+        src/ODBCMetaColumn.cpp
+        src/ODBCStatementImpl.cpp
+        src/Parameter.cpp
+        src/Preparator.cpp
+        src/SessionImpl.cpp
+        src/TypeInfo.cpp
+        src/Unicode.cpp
+        src/Utility.cpp
+    )
+
+    add_library (_poco_data_odbc ${SRCS})
+    add_library (Poco::Data::ODBC ALIAS _poco_data_odbc)
+
+    target_compile_options (_poco_data_odbc PRIVATE -Wno-unused-variable)
+    target_include_directories (_poco_data_odbc SYSTEM PUBLIC "include")
+    target_link_libraries (_poco_data_odbc PUBLIC Poco::Data ch_contrib::unixodbc)
+
+    message (STATUS "Using Poco::Data::ODBC")
+else ()
+    add_library (_poco_data_odbc INTERFACE)
+    add_library (Poco::Data::ODBC ALIAS _poco_data_odbc)
+    if (TARGET ch_contrib::unixodbc)
+        target_link_libraries (_poco_data_odbc INTERFACE ch_contrib::unixodbc)
+    endif()
+
+    message (STATUS "Not using Poco::Data::ODBC")
+endif ()
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/Binder.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Binder.h
new file mode 100644
index 00000000000..fd3241fbf8c
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Binder.h
@@ -0,0 +1,1516 @@
+//
+// Binder.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Binder
+//
+// Definition of the Binder class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Binder_INCLUDED
+#define Data_ODBC_Binder_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/AbstractBinder.h"
+#include "Poco/Data/LOB.h"
+#include "Poco/Data/ODBC/Handle.h"
+#include "Poco/Data/ODBC/Parameter.h"
+#include "Poco/Data/ODBC/ODBCMetaColumn.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/TypeInfo.h"
+#include "Poco/Exception.h"
+#include <vector>
+#include <deque>
+#include <list>
+#include <map>
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqlext.h>
+
+
+namespace Poco {
+
+
+class DateTime;
+
+
+namespace Data {
+
+
+class Date;
+class Time;
+
+
+namespace ODBC {
+
+
+class ODBC_API Binder: public Poco::Data::AbstractBinder
+	/// Binds placeholders in the sql query to the provided values. Performs data types mapping.
+{
+public:
+	typedef AbstractBinder::Direction Direction;
+	typedef std::map<SQLPOINTER, SQLLEN> ParamMap;
+
+	static const size_t DEFAULT_PARAM_SIZE = 1024;
+
+	enum ParameterBinding
+	{
+		PB_IMMEDIATE,
+		PB_AT_EXEC
+	};
+
+	Binder(const StatementHandle& rStmt,
+		std::size_t maxFieldSize,
+		ParameterBinding dataBinding = PB_IMMEDIATE,
+		TypeInfo* pDataTypes = 0);
+		/// Creates the Binder.
+
+	~Binder();
+		/// Destroys the Binder.
+
+	void bind(std::size_t pos, const Poco::Int8& val, Direction dir);
+		/// Binds an Int8.
+
+	void bind(std::size_t pos, const std::vector<Poco::Int8>& val, Direction dir);
+		/// Binds an Int8 vector.
+
+	void bind(std::size_t pos, const std::deque<Poco::Int8>& val, Direction dir);
+		/// Binds an Int8 deque.
+
+	void bind(std::size_t pos, const std::list<Poco::Int8>& val, Direction dir);
+		/// Binds an Int8 list.
+
+	void bind(std::size_t pos, const Poco::UInt8& val, Direction dir);
+		/// Binds an UInt8.
+
+	void bind(std::size_t pos, const std::vector<Poco::UInt8>& val, Direction dir);
+		/// Binds an UInt8 vector.
+
+	void bind(std::size_t pos, const std::deque<Poco::UInt8>& val, Direction dir);
+		/// Binds an UInt8 deque.
+
+	void bind(std::size_t pos, const std::list<Poco::UInt8>& val, Direction dir);
+		/// Binds an UInt8 list.
+
+	void bind(std::size_t pos, const Poco::Int16& val, Direction dir);
+		/// Binds an Int16.
+	
+	void bind(std::size_t pos, const std::vector<Poco::Int16>& val, Direction dir);
+		/// Binds an Int16 vector.
+
+	void bind(std::size_t pos, const std::deque<Poco::Int16>& val, Direction dir);
+		/// Binds an Int16 deque.
+
+	void bind(std::size_t pos, const std::list<Poco::Int16>& val, Direction dir);
+		/// Binds an Int16 list.
+
+	void bind(std::size_t pos, const Poco::UInt16& val, Direction dir);
+		/// Binds an UInt16.
+
+	void bind(std::size_t pos, const std::vector<Poco::UInt16>& val, Direction dir);
+		/// Binds an UInt16 vector.
+
+	void bind(std::size_t pos, const std::deque<Poco::UInt16>& val, Direction dir);
+		/// Binds an UInt16 deque.
+
+	void bind(std::size_t pos, const std::list<Poco::UInt16>& val, Direction dir);
+		/// Binds an UInt16 list.
+
+	void bind(std::size_t pos, const Poco::Int32& val, Direction dir);
+		/// Binds an Int32.
+
+	void bind(std::size_t pos, const std::vector<Poco::Int32>& val, Direction dir);
+		/// Binds an Int32 vector.
+
+	void bind(std::size_t pos, const std::deque<Poco::Int32>& val, Direction dir);
+		/// Binds an Int32 deque.
+
+	void bind(std::size_t pos, const std::list<Poco::Int32>& val, Direction dir);
+		/// Binds an Int32 list.
+
+	void bind(std::size_t pos, const Poco::UInt32& val, Direction dir);
+		/// Binds an UInt32.
+
+	void bind(std::size_t pos, const std::vector<Poco::UInt32>& val, Direction dir);
+		/// Binds an UInt32 vector.
+
+	void bind(std::size_t pos, const std::deque<Poco::UInt32>& val, Direction dir);
+		/// Binds an UInt32 deque.
+
+	void bind(std::size_t pos, const std::list<Poco::UInt32>& val, Direction dir);
+		/// Binds an UInt32 list.
+
+	void bind(std::size_t pos, const Poco::Int64& val, Direction dir);
+		/// Binds an Int64.
+
+	void bind(std::size_t pos, const std::vector<Poco::Int64>& val, Direction dir);
+		/// Binds an Int64 vector.
+
+	void bind(std::size_t pos, const std::deque<Poco::Int64>& val, Direction dir);
+		/// Binds an Int64 deque.
+
+	void bind(std::size_t pos, const std::list<Poco::Int64>& val, Direction dir);
+		/// Binds an Int64 list.
+
+	void bind(std::size_t pos, const Poco::UInt64& val, Direction dir);
+		/// Binds an UInt64.
+
+	void bind(std::size_t pos, const std::vector<Poco::UInt64>& val, Direction dir);
+		/// Binds an UInt64 vector.
+
+	void bind(std::size_t pos, const std::deque<Poco::UInt64>& val, Direction dir);
+		/// Binds an UInt64 deque.
+
+	void bind(std::size_t pos, const std::list<Poco::UInt64>& val, Direction dir);
+		/// Binds an UInt64 list.
+
+#ifndef POCO_LONG_IS_64_BIT
+	void bind(std::size_t pos, const long& val, Direction dir);
+		/// Binds a long.
+
+	void bind(std::size_t pos, const unsigned long& val, Direction dir);
+		/// Binds an unsigned long.
+
+	void bind(std::size_t pos, const std::vector<long>& val, Direction dir);
+		/// Binds a long vector.
+
+	void bind(std::size_t pos, const std::deque<long>& val, Direction dir);
+		/// Binds a long deque.
+
+	void bind(std::size_t pos, const std::list<long>& val, Direction dir);
+		/// Binds a long list.
+#endif
+
+	void bind(std::size_t pos, const bool& val, Direction dir);
+		/// Binds a boolean.
+
+	void bind(std::size_t pos, const std::vector<bool>& val, Direction dir);
+		/// Binds a boolean vector.
+
+	void bind(std::size_t pos, const std::deque<bool>& val, Direction dir);
+		/// Binds a boolean deque.
+
+	void bind(std::size_t pos, const std::list<bool>& val, Direction dir);
+		/// Binds a boolean list.
+
+	void bind(std::size_t pos, const float& val, Direction dir);
+		/// Binds a float.
+
+	void bind(std::size_t pos, const std::vector<float>& val, Direction dir);
+		/// Binds a float vector.
+
+	void bind(std::size_t pos, const std::deque<float>& val, Direction dir);
+		/// Binds a float deque.
+
+	void bind(std::size_t pos, const std::list<float>& val, Direction dir);
+		/// Binds a float list.
+
+	void bind(std::size_t pos, const double& val, Direction dir);
+		/// Binds a double.
+
+	void bind(std::size_t pos, const std::vector<double>& val, Direction dir);
+		/// Binds a double vector.
+
+	void bind(std::size_t pos, const std::deque<double>& val, Direction dir);
+		/// Binds a double deque.
+
+	void bind(std::size_t pos, const std::list<double>& val, Direction dir);
+		/// Binds a double list.
+
+	void bind(std::size_t pos, const char& val, Direction dir);
+		/// Binds a single character.
+
+	void bind(std::size_t pos, const std::vector<char>& val, Direction dir);
+		/// Binds a character vector.
+
+	void bind(std::size_t pos, const std::deque<char>& val, Direction dir);
+		/// Binds a character deque.
+
+	void bind(std::size_t pos, const std::list<char>& val, Direction dir);
+		/// Binds a character list.
+
+	void bind(std::size_t pos, const std::string& val, Direction dir);
+		/// Binds a string.
+
+	void bind(std::size_t pos, const std::vector<std::string>& val, Direction dir);
+		/// Binds a string vector.
+
+	void bind(std::size_t pos, const std::deque<std::string>& val, Direction dir);
+		/// Binds a string deque.
+
+	void bind(std::size_t pos, const std::list<std::string>& val, Direction dir);
+		/// Binds a string list.
+
+	void bind(std::size_t pos, const UTF16String& val, Direction dir);
+		/// Binds a string.
+
+	void bind(std::size_t pos, const std::vector<UTF16String>& val, Direction dir);
+		/// Binds a string vector.
+
+	void bind(std::size_t pos, const std::deque<UTF16String>& val, Direction dir);
+		/// Binds a string deque.
+
+	void bind(std::size_t pos, const std::list<UTF16String>& val, Direction dir);
+		/// Binds a string list.
+
+	void bind(std::size_t pos, const BLOB& val, Direction dir);
+		/// Binds a BLOB. In-bound only.
+
+	void bind(std::size_t pos, const CLOB& val, Direction dir);
+		/// Binds a CLOB. In-bound only.
+
+	void bind(std::size_t pos, const std::vector<BLOB>& val, Direction dir);
+		/// Binds a BLOB vector.
+
+	void bind(std::size_t pos, const std::deque<BLOB>& val, Direction dir);
+		/// Binds a BLOB deque.
+
+	void bind(std::size_t pos, const std::list<BLOB>& val, Direction dir);
+		/// Binds a BLOB list.
+
+	void bind(std::size_t pos, const std::vector<CLOB>& val, Direction dir);
+		/// Binds a CLOB vector.
+
+	void bind(std::size_t pos, const std::deque<CLOB>& val, Direction dir);
+		/// Binds a CLOB deque.
+
+	void bind(std::size_t pos, const std::list<CLOB>& val, Direction dir);
+		/// Binds a CLOB list.
+
+	void bind(std::size_t pos, const Date& val, Direction dir);
+		/// Binds a Date.
+
+	void bind(std::size_t pos, const std::vector<Date>& val, Direction dir);
+		/// Binds a Date vector.
+
+	void bind(std::size_t pos, const std::deque<Date>& val, Direction dir);
+		/// Binds a Date deque.
+
+	void bind(std::size_t pos, const std::list<Date>& val, Direction dir);
+		/// Binds a Date list.
+
+	void bind(std::size_t pos, const Time& val, Direction dir);
+		/// Binds a Time.
+
+	void bind(std::size_t pos, const std::vector<Time>& val, Direction dir);
+		/// Binds a Time vector.
+
+	void bind(std::size_t pos, const std::deque<Time>& val, Direction dir);
+		/// Binds a Time deque.
+
+	void bind(std::size_t pos, const std::list<Time>& val, Direction dir);
+		/// Binds a Time list.
+
+	void bind(std::size_t pos, const DateTime& val, Direction dir);
+		/// Binds a DateTime.
+
+	void bind(std::size_t pos, const std::vector<DateTime>& val, Direction dir);
+		/// Binds a DateTime vector.
+
+	void bind(std::size_t pos, const std::deque<DateTime>& val, Direction dir);
+		/// Binds a DateTime deque.
+
+	void bind(std::size_t pos, const std::list<DateTime>& val, Direction dir);
+		/// Binds a DateTime list.
+
+	void bind(std::size_t pos, const NullData& val, Direction dir);
+		/// Binds a null. In-bound only.
+
+	void bind(std::size_t pos, const std::vector<NullData>& val, Direction dir);
+		/// Binds a null vector.
+
+	void bind(std::size_t pos, const std::deque<NullData>& val, Direction dir);
+		/// Binds a null deque.
+
+	void bind(std::size_t pos, const std::list<NullData>& val, Direction dir);
+		/// Binds a null list.
+
+	void setDataBinding(ParameterBinding binding);
+		/// Set data binding type.
+
+	ParameterBinding getDataBinding() const;
+		/// Return data binding type.
+
+	std::size_t parameterSize(SQLPOINTER pAddr) const;
+		/// Returns bound data size for parameter at specified position.
+
+	void synchronize();
+		/// Transfers the results of non-POD outbound parameters from internal 
+		/// holders back into the externally supplied buffers.
+
+	void reset();
+		/// Clears the cached storage.
+
+private:
+	typedef std::vector<SQLLEN*>                             LengthPtrVec;
+	typedef std::vector<SQLLEN>                              LengthVec;
+	typedef std::vector<LengthVec*>                          LengthVecVec;
+	typedef std::vector<char*>                               CharPtrVec;
+	typedef std::vector<UTF16Char*>                          UTF16CharPtrVec;
+	typedef std::vector<bool*>                               BoolPtrVec;
+	typedef std::vector<SQL_DATE_STRUCT>                     DateVec;
+	typedef std::vector<DateVec*>                            DateVecVec;
+	typedef std::vector<SQL_TIME_STRUCT>                     TimeVec;
+	typedef std::vector<TimeVec*>                            TimeVecVec;
+	typedef std::vector<SQL_TIMESTAMP_STRUCT>                DateTimeVec;
+	typedef std::vector<DateTimeVec*>                        DateTimeVecVec;
+	typedef std::vector<Poco::Any>                           AnyVec;
+	typedef std::vector<AnyVec>                              AnyVecVec;
+	typedef std::map<char*, std::string*>                    StringMap;
+	typedef std::map<UTF16String::value_type*, UTF16String*> UTF16StringMap;
+	typedef std::map<SQL_DATE_STRUCT*, Date*>                DateMap;
+	typedef std::map<SQL_TIME_STRUCT*, Time*>                TimeMap;
+	typedef std::map<SQL_TIMESTAMP_STRUCT*, DateTime*>       TimestampMap;
+
+	void describeParameter(std::size_t pos);
+		/// Sets the description field for the parameter, if needed.
+
+	void bind(std::size_t pos, const char* const& pVal, Direction dir);
+		/// Binds a const char ptr. 
+		/// This is a private no-op in this implementation
+		/// due to security risk.
+
+	SQLSMALLINT toODBCDirection(Direction dir) const;
+		/// Returns ODBC parameter direction based on the parameter binding direction
+		/// specified by user.
+
+	template <typename T>
+	void bindImpl(std::size_t pos, T& val, SQLSMALLINT cDataType, Direction dir)
+	{
+		SQLINTEGER colSize = 0;
+		SQLSMALLINT decDigits = 0;
+		getColSizeAndPrecision(pos, cDataType, colSize, decDigits);
+
+		_lengthIndicator.push_back(0);
+
+		if (Utility::isError(SQLBindParameter(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			toODBCDirection(dir), 
+			cDataType, 
+			Utility::sqlDataType(cDataType), 
+			colSize,
+			decDigits,
+			(SQLPOINTER) &val, 0, 0)))
+		{
+			throw StatementException(_rStmt, "SQLBindParameter()");
+		}
+	}
+
+	template <typename L>
+	void bindImplLOB(std::size_t pos, const L& val, Direction dir)
+	{
+		if (isOutBound(dir) || !isInBound(dir))
+			throw NotImplementedException("LOB parameter type can only be inbound.");
+
+		SQLPOINTER pVal = (SQLPOINTER) val.rawContent();
+		SQLINTEGER size = (SQLINTEGER) val.size();
+			
+		_inParams.insert(ParamMap::value_type(pVal, size));
+
+		SQLLEN* pLenIn = new SQLLEN;
+		*pLenIn  = size;
+
+		if (PB_AT_EXEC == _paramBinding)
+			*pLenIn  = SQL_LEN_DATA_AT_EXEC(size);
+
+		_lengthIndicator.push_back(pLenIn);
+
+		if (Utility::isError(SQLBindParameter(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			SQL_PARAM_INPUT, 
+			SQL_C_BINARY, 
+			SQL_LONGVARBINARY, 
+			(SQLUINTEGER) size,
+			0,
+			pVal,
+			(SQLINTEGER) size, 
+			_lengthIndicator.back())))
+		{
+			throw StatementException(_rStmt, "SQLBindParameter(LOB)");
+		}
+	}
+
+	template <typename T>
+	void bindImplVec(std::size_t pos, const std::vector<T>& val, SQLSMALLINT cDataType, Direction dir)
+	{
+		if (PB_IMMEDIATE != _paramBinding)
+			throw InvalidAccessException("std::vector can only be bound immediately.");
+
+		std::size_t length = val.size();
+		SQLINTEGER colSize = 0;
+		SQLSMALLINT decDigits = 0;
+		getColSizeAndPrecision(pos, cDataType, colSize, decDigits);
+		setParamSetSize(length);
+
+		if (_vecLengthIndicator.size() <= pos)
+		{
+			_vecLengthIndicator.resize(pos + 1, 0);
+			_vecLengthIndicator[pos] = new LengthVec(length);
+		}
+
+		if (Utility::isError(SQLBindParameter(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			toODBCDirection(dir), 
+			cDataType, 
+			Utility::sqlDataType(cDataType), 
+			colSize,
+			decDigits,
+			(SQLPOINTER) &val[0], 
+			0, 
+			&(*_vecLengthIndicator[pos])[0])))
+		{
+			throw StatementException(_rStmt, "SQLBindParameter()");
+		}
+	}
+
+	template <typename C>
+	void bindImplContainer(std::size_t pos, const C& val, SQLSMALLINT cDataType, Direction dir)
+		/// Utility function - a "stand-in" for non-vector containers.
+		/// Creates, fills and stores the reference to the replacement std::vector container
+		/// for std::deque and std::list. Calls std::vector binding.
+	{
+		typedef typename C::value_type Type;
+
+		if (_containers.size() <= pos)
+			_containers.resize(pos + 1);
+
+		_containers[pos].push_back(std::vector<Type>());
+
+		std::vector<Type>& cont = RefAnyCast<std::vector<Type> >(_containers[pos].back());
+		cont.assign(val.begin(), val.end());
+		bindImplVec(pos, cont, cDataType, dir);
+	}
+
+	template <typename C>
+	void bindImplContainerBool(std::size_t pos, const C& val, SQLSMALLINT cDataType, Direction dir)
+	{
+		if (PB_IMMEDIATE != _paramBinding)
+			throw InvalidAccessException("std::vector can only be bound immediately.");
+
+		std::size_t length = val.size();
+		SQLINTEGER colSize = 0;
+		SQLSMALLINT decDigits = 0;
+		getColSizeAndPrecision(pos, cDataType, colSize, decDigits);
+
+		setParamSetSize(val.size());
+
+		if (_vecLengthIndicator.size() <= pos)
+		{
+			_vecLengthIndicator.resize(pos + 1, 0);
+			_vecLengthIndicator[pos] = new LengthVec(length);
+		}
+
+		if (_boolPtrs.size() <= pos)
+			_boolPtrs.resize(pos + 1);
+
+		_boolPtrs[pos] = new bool[val.size()];
+
+		typename C::const_iterator it = val.begin();
+		typename C::const_iterator end = val.end();
+		for (int i = 0; it != end; ++it, ++i) _boolPtrs[pos][i] = *it;
+
+		if (Utility::isError(SQLBindParameter(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			toODBCDirection(dir), 
+			cDataType, 
+			Utility::sqlDataType(cDataType), 
+			colSize,
+			decDigits,
+			(SQLPOINTER) &_boolPtrs[pos][0], 
+			0, 
+			&(*_vecLengthIndicator[pos])[0])))
+		{
+			throw StatementException(_rStmt, "SQLBindParameter()");
+		}
+	}
+
+	template <typename C>
+	void bindImplContainerString(std::size_t pos, const C& val, Direction dir)
+		/// Utility function to bind containers of strings.
+	{
+		if (isOutBound(dir) || !isInBound(dir))
+			throw NotImplementedException("String container parameter type can only be inbound.");
+
+		if (PB_IMMEDIATE != _paramBinding)
+			throw InvalidAccessException("Containers can only be bound immediately.");
+
+		std::size_t length = val.size();
+
+		if (0 == length)
+			throw InvalidArgumentException("Empty container not allowed.");
+
+		setParamSetSize(length);
+
+		SQLINTEGER size = 0;
+		getColumnOrParameterSize(pos, size);
+		poco_assert (size > 0);
+
+		if (size == _maxFieldSize)
+		{
+			getMinValueSize(val, size);
+			// accomodate for terminating zero
+			if (size != _maxFieldSize) ++size;
+		}
+
+		if (_vecLengthIndicator.size() <= pos)
+		{
+			_vecLengthIndicator.resize(pos + 1, 0);
+			_vecLengthIndicator[pos] = new LengthVec(length ? length : 1, SQL_NTS);
+		}
+
+		if (_charPtrs.size() <= pos)
+			_charPtrs.resize(pos + 1, 0);
+
+		_charPtrs[pos] = (char*) std::calloc(val.size() * size, sizeof(char));
+		
+		std::size_t strSize;
+		std::size_t offset = 0;
+		typename C::const_iterator it = val.begin();
+		typename C::const_iterator end = val.end();
+		for (; it != end; ++it)
+		{
+			strSize = it->size();
+			if (strSize > size)	
+				throw LengthExceededException("SQLBindParameter(std::vector<std::string>)");
+			std::memcpy(_charPtrs[pos] + offset, it->c_str(), strSize);
+			offset += size;
+		}
+
+		if (Utility::isError(SQLBindParameter(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			toODBCDirection(dir), 
+			SQL_C_CHAR, 
+			SQL_LONGVARCHAR, 
+			(SQLUINTEGER) size - 1,
+			0,
+			_charPtrs[pos], 
+			(SQLINTEGER) size, 
+			&(*_vecLengthIndicator[pos])[0])))
+		{
+			throw StatementException(_rStmt, "SQLBindParameter(std::vector<std::string>)");
+		}
+	}
+
+	template <typename C>
+	void bindImplContainerUTF16String(std::size_t pos, const C& val, Direction dir)
+		/// Utility function to bind containers of strings.
+	{
+		if (isOutBound(dir) || !isInBound(dir))
+			throw NotImplementedException("String container parameter type can only be inbound.");
+
+		if (PB_IMMEDIATE != _paramBinding)
+			throw InvalidAccessException("Containers can only be bound immediately.");
+
+		std::size_t length = val.size();
+		if (0 == length)
+			throw InvalidArgumentException("Empty container not allowed.");
+
+		setParamSetSize(val.size());
+
+		SQLINTEGER size = 0;
+		getColumnOrParameterSize(pos, size);
+		poco_assert(size > 0);
+
+		if (size == _maxFieldSize)
+		{
+			getMinValueSize(val, size);
+			// accomodate for terminating zero
+			if (size != _maxFieldSize) size += sizeof(UTF16Char);
+		}
+
+		if (_vecLengthIndicator.size() <= pos)
+		{
+			_vecLengthIndicator.resize(pos + 1, 0);
+			_vecLengthIndicator[pos] = new LengthVec(length ? length : 1, SQL_NTS);
+		}
+
+		if (_utf16CharPtrs.size() <= pos)
+			_utf16CharPtrs.resize(pos + 1, 0);
+
+		_utf16CharPtrs[pos] = (UTF16Char*)std::calloc(val.size() * size, sizeof(UTF16Char));
+
+		std::size_t strSize;
+		std::size_t offset = 0;
+		char* pBuf = (char*)_utf16CharPtrs[pos];
+		typename C::const_iterator it = val.begin();
+		typename C::const_iterator end = val.end();
+		for (; it != end; ++it)
+		{
+			strSize = it->size() * sizeof(UTF16Char);
+			if (strSize > size)
+				throw LengthExceededException("SQLBindParameter(std::vector<UTF16String>)");
+			std::memcpy(pBuf + offset, it->data(), strSize);
+			offset += size;
+		}
+
+		if (Utility::isError(SQLBindParameter(_rStmt,
+			(SQLUSMALLINT)pos + 1,
+			toODBCDirection(dir),
+			SQL_C_WCHAR,
+			SQL_WLONGVARCHAR,
+			(SQLUINTEGER)size - 1,
+			0,
+			_utf16CharPtrs[pos],
+			(SQLINTEGER)size,
+			&(*_vecLengthIndicator[pos])[0])))
+		{
+			throw StatementException(_rStmt, "SQLBindParameter(std::vector<UTF16String>)");
+		}
+	}
+
+	template <typename C>
+	void bindImplContainerLOB(std::size_t pos, const C& val, Direction dir)
+	{
+		typedef typename C::value_type LOBType;
+		typedef typename LOBType::ValueType CharType;
+
+		if (isOutBound(dir) || !isInBound(dir))
+			throw NotImplementedException("BLOB container parameter type can only be inbound.");
+
+		if (PB_IMMEDIATE != _paramBinding)
+			throw InvalidAccessException("Containers can only be bound immediately.");
+
+		std::size_t length = val.size();
+		if (0 == length)
+			throw InvalidArgumentException("Empty container not allowed.");
+
+		setParamSetSize(length);
+
+		SQLINTEGER size = 0;
+
+		if (_vecLengthIndicator.size() <= pos)
+		{
+			_vecLengthIndicator.resize(pos + 1, 0);
+			_vecLengthIndicator[pos] = new LengthVec(length ? length : 1);
+		}
+
+		std::vector<SQLLEN>::iterator lIt = _vecLengthIndicator[pos]->begin();
+		std::vector<SQLLEN>::iterator lEnd = _vecLengthIndicator[pos]->end();
+		typename C::const_iterator cIt = val.begin();
+		for (; lIt != lEnd; ++lIt, ++cIt) 
+		{
+			SQLLEN sz = static_cast<SQLLEN>(cIt->size());
+			if (sz > size) size = static_cast<SQLINTEGER>(sz);
+			*lIt = sz;
+		}
+
+		if (_charPtrs.size() <= pos)
+			_charPtrs.resize(pos + 1, 0);
+
+		_charPtrs[pos] = (char*) std::calloc(val.size() * size, sizeof(CharType));
+		poco_check_ptr (_charPtrs[pos]);
+
+		std::size_t blobSize;
+		std::size_t offset = 0;
+		cIt = val.begin();
+		typename C::const_iterator cEnd = val.end();
+		for (; cIt != cEnd; ++cIt)
+		{
+			blobSize = cIt->size();
+			if (blobSize > size)	
+				throw LengthExceededException("SQLBindParameter(std::vector<BLOB>)");
+			std::memcpy(_charPtrs[pos] + offset, cIt->rawContent(), blobSize * sizeof(CharType));
+			offset += size;
+		}
+
+		if (Utility::isError(SQLBindParameter(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			SQL_PARAM_INPUT, 
+			SQL_C_BINARY, 
+			SQL_LONGVARBINARY, 
+			(SQLUINTEGER) size,
+			0,
+			_charPtrs[pos], 
+			(SQLINTEGER) size, 
+			&(*_vecLengthIndicator[pos])[0])))
+		{
+			throw StatementException(_rStmt, "SQLBindParameter(std::vector<BLOB>)");
+		}
+	}
+
+	template<typename C>
+	void bindImplContainerDate(std::size_t pos, const C& val, Direction dir)
+	{
+		if (isOutBound(dir) || !isInBound(dir))
+			throw NotImplementedException("Date vector parameter type can only be inbound.");
+
+		if (PB_IMMEDIATE != _paramBinding)
+			throw InvalidAccessException("std::vector can only be bound immediately.");
+
+		std::size_t length = val.size();
+
+		if (0 == length)
+			throw InvalidArgumentException("Empty vector not allowed.");
+
+		setParamSetSize(length);
+
+		SQLINTEGER size = (SQLINTEGER) sizeof(SQL_DATE_STRUCT);
+
+		if (_vecLengthIndicator.size() <= pos)
+		{
+			_vecLengthIndicator.resize(pos + 1, 0);
+			_vecLengthIndicator[pos] = new LengthVec(length ? length : 1);
+		}
+
+		if (_dateVecVec.size() <= pos)
+		{
+			_dateVecVec.resize(pos + 1, 0);
+			_dateVecVec[pos] = new DateVec(length ? length : 1);
+		}
+
+		Utility::dateSync(*_dateVecVec[pos], val);
+
+		SQLINTEGER colSize = 0;
+		SQLSMALLINT decDigits = 0;
+		getColSizeAndPrecision(pos, SQL_TYPE_DATE, colSize, decDigits);
+
+		if (Utility::isError(SQLBindParameter(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			toODBCDirection(dir), 
+			SQL_C_TYPE_DATE, 
+			SQL_TYPE_DATE, 
+			colSize,
+			decDigits,
+			(SQLPOINTER) &(*_dateVecVec[pos])[0], 
+			0, 
+			&(*_vecLengthIndicator[pos])[0])))
+		{
+			throw StatementException(_rStmt, "SQLBindParameter(Date[])");
+		}
+	}
+
+	template<typename C>
+	void bindImplContainerTime(std::size_t pos, const C& val, Direction dir)
+	{
+		if (isOutBound(dir) || !isInBound(dir))
+			throw NotImplementedException("Time container parameter type can only be inbound.");
+
+		if (PB_IMMEDIATE != _paramBinding)
+			throw InvalidAccessException("Containers can only be bound immediately.");
+
+		std::size_t length = val.size();
+		if (0 == length)
+			throw InvalidArgumentException("Empty container not allowed.");
+
+		setParamSetSize(val.size());
+
+		SQLINTEGER size = (SQLINTEGER) sizeof(SQL_TIME_STRUCT);
+
+		if (_vecLengthIndicator.size() <= pos)
+		{
+			_vecLengthIndicator.resize(pos + 1, 0);
+			_vecLengthIndicator[pos] = new LengthVec(length ? length : 1);
+		}
+
+		if (_timeVecVec.size() <= pos)
+		{
+			_timeVecVec.resize(pos + 1, 0);
+			_timeVecVec[pos] = new TimeVec(length ? length : 1);
+		}
+
+		Utility::timeSync(*_timeVecVec[pos], val);
+
+		SQLINTEGER colSize = 0;
+		SQLSMALLINT decDigits = 0;
+		getColSizeAndPrecision(pos, SQL_TYPE_TIME, colSize, decDigits);
+
+		if (Utility::isError(SQLBindParameter(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			toODBCDirection(dir), 
+			SQL_C_TYPE_TIME, 
+			SQL_TYPE_TIME, 
+			colSize,
+			decDigits,
+			(SQLPOINTER) &(*_timeVecVec[pos])[0], 
+			0, 
+			&(*_vecLengthIndicator[pos])[0])))
+		{
+			throw StatementException(_rStmt, "SQLBindParameter(Time[])");
+		}
+	}
+
+	template<typename C>
+	void bindImplContainerDateTime(std::size_t pos, const C& val, Direction dir)
+	{
+		if (isOutBound(dir) || !isInBound(dir))
+			throw NotImplementedException("DateTime container parameter type can only be inbound.");
+
+		if (PB_IMMEDIATE != _paramBinding)
+			throw InvalidAccessException("Containers can only be bound immediately.");
+
+		std::size_t length = val.size();
+
+		if (0 == length)
+			throw InvalidArgumentException("Empty Containers not allowed.");
+
+		setParamSetSize(length);
+
+		SQLINTEGER size = (SQLINTEGER) sizeof(SQL_TIMESTAMP_STRUCT);
+
+		if (_vecLengthIndicator.size() <= pos)
+		{
+			_vecLengthIndicator.resize(pos + 1, 0);
+			_vecLengthIndicator[pos] = new LengthVec(length ? length : 1);
+		}
+
+		if (_dateTimeVecVec.size() <= pos)
+		{
+			_dateTimeVecVec.resize(pos + 1, 0);
+			_dateTimeVecVec[pos] = new DateTimeVec(length ? length : 1);
+		}
+
+		Utility::dateTimeSync(*_dateTimeVecVec[pos], val);
+
+		SQLINTEGER colSize = 0;
+		SQLSMALLINT decDigits = 0;
+		getColSizeAndPrecision(pos, SQL_TYPE_TIMESTAMP, colSize, decDigits);
+
+		if (Utility::isError(SQLBindParameter(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			toODBCDirection(dir), 
+			SQL_C_TYPE_TIMESTAMP, 
+			SQL_TYPE_TIMESTAMP, 
+			colSize,
+			decDigits,
+			(SQLPOINTER) &(*_dateTimeVecVec[pos])[0], 
+			0, 
+			&(*_vecLengthIndicator[pos])[0])))
+		{
+			throw StatementException(_rStmt, "SQLBindParameter(Time[])");
+		}
+	}
+
+	template<typename C>
+	void bindImplNullContainer(std::size_t pos, const C& val, Direction dir)
+	{
+		if (isOutBound(dir) || !isInBound(dir))
+			throw NotImplementedException("Null container parameter type can only be inbound.");
+
+		if (PB_IMMEDIATE != _paramBinding)
+			throw InvalidAccessException("Container can only be bound immediately.");
+
+		std::size_t length = val.size();
+
+		if (0 == length)
+			throw InvalidArgumentException("Empty container not allowed.");
+
+		setParamSetSize(length);
+
+		SQLINTEGER size = SQL_NULL_DATA;
+
+		if (_vecLengthIndicator.size() <= pos)
+		{
+			_vecLengthIndicator.resize(pos + 1, 0);
+			_vecLengthIndicator[pos] = new LengthVec(length ? length : 1);
+		}
+
+		SQLINTEGER colSize = 0;
+		SQLSMALLINT decDigits = 0;
+		getColSizeAndPrecision(pos, SQL_C_STINYINT, colSize, decDigits);
+
+		if (Utility::isError(SQLBindParameter(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			SQL_PARAM_INPUT, 
+			SQL_C_STINYINT, 
+			Utility::sqlDataType(SQL_C_STINYINT), 
+			colSize,
+			decDigits,
+			0, 
+			0, 
+			&(*_vecLengthIndicator[pos])[0])))
+		{
+			throw StatementException(_rStmt, "SQLBindParameter()");
+		}
+	}
+
+	void getColSizeAndPrecision(std::size_t pos, 
+		SQLSMALLINT cDataType, 
+		SQLINTEGER& colSize, 
+		SQLSMALLINT& decDigits,
+		std::size_t actualSize = 0);
+		/// Used to retrieve column size and precision.
+		/// Not all drivers cooperate with this inquiry under all circumstances
+		/// This function runs for query and stored procedure parameters (in and 
+		/// out-bound). Some drivers, however, do not care about knowing this 
+		/// information to start with. For that reason, after all the attempts 
+		/// to discover the required values are unsuccesfully exhausted, the values 
+		/// are both set to zero and no exception is thrown.
+		/// However, if the colSize is succesfully retrieved and it is greater than
+		/// session-wide maximum allowed field size, LengthExceededException is thrown.
+
+	void setParamSetSize(std::size_t length);
+		/// Sets the parameter set size. Used for column-wise binding.
+
+	void getColumnOrParameterSize(std::size_t pos, SQLINTEGER& size);
+		/// Fills the column or parameter size into the 'size' argument.
+		/// Does nothing if neither can be obtained from the driver, so
+		/// size should be set to some default value prior to calling this 
+		/// function in order to avoid undefined size value.
+
+	void freeMemory();
+		/// Frees all dynamically allocated memory resources.
+
+	template<typename T>
+	void getMinValueSize(T& val, SQLINTEGER& size)
+		/// Some ODBC drivers return DB-wide maximum allowed size for variable size columns,
+		/// rather than the allowed size for the actual column. In such cases, the length is 
+		/// automatically resized to the maximum field size allowed by the session.
+		/// This function, in order to prevent unnecessary memory allocation, does further 
+		/// optimization, looking for the maximum length within supplied data container and
+		/// uses the smaller of maximum found and maximum predefined data length.
+	{
+		typedef typename T::value_type ContainedValType;
+		typedef typename ContainedValType::value_type BaseValType;
+		std::size_t typeSize = sizeof(BaseValType);
+		std::size_t maxSize = 0;
+		typename T::const_iterator it = val.begin();
+		typename T::const_iterator end = val.end();
+		for (; it != end; ++it)
+		{
+			std::size_t sz = it->size() * typeSize;
+			if (sz > _maxFieldSize)
+				throw LengthExceededException();
+
+			if (sz == _maxFieldSize)
+			{
+				maxSize = 0;
+				break;
+			}
+
+			if (sz < _maxFieldSize && sz > maxSize)
+				maxSize = sz;
+		}
+		if (maxSize) size = static_cast<SQLINTEGER>(maxSize);
+	}
+
+	const StatementHandle& _rStmt;
+
+	LengthPtrVec     _lengthIndicator;
+	LengthVecVec     _vecLengthIndicator;
+
+	ParamMap         _inParams;
+	ParamMap         _outParams;
+	ParameterBinding _paramBinding;
+	
+	DateMap          _dates;
+	TimeMap          _times;
+	TimestampMap     _timestamps;
+	StringMap        _strings;
+	UTF16StringMap   _utf16Strings;
+
+	DateVecVec       _dateVecVec;
+	TimeVecVec       _timeVecVec;
+	DateTimeVecVec   _dateTimeVecVec;
+	CharPtrVec       _charPtrs;
+	UTF16CharPtrVec  _utf16CharPtrs;
+	BoolPtrVec       _boolPtrs;
+	const TypeInfo*  _pTypeInfo;
+	SQLINTEGER       _paramSetSize;
+	std::size_t      _maxFieldSize;
+	AnyVecVec        _containers;
+};
+
+
+//
+// inlines
+//
+inline void Binder::bind(std::size_t pos, const Poco::Int8& val, Direction dir)
+{
+	bindImpl(pos, val, SQL_C_STINYINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<Poco::Int8>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_STINYINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<Poco::Int8>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_STINYINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<Poco::Int8>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_STINYINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const Poco::UInt8& val, Direction dir)
+{
+	bindImpl(pos, val, SQL_C_UTINYINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<Poco::UInt8>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_UTINYINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<Poco::UInt8>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_UTINYINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<Poco::UInt8>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_UTINYINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const Poco::Int16& val, Direction dir)
+{
+	bindImpl(pos, val, SQL_C_SSHORT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<Poco::Int16>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_SSHORT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<Poco::Int16>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_SSHORT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<Poco::Int16>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_SSHORT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const Poco::UInt16& val, Direction dir)
+{
+	bindImpl(pos, val, SQL_C_USHORT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<Poco::UInt16>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_USHORT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<Poco::UInt16>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_USHORT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<Poco::UInt16>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_USHORT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const Poco::Int32& val, Direction dir)
+{
+	bindImpl(pos, val, SQL_C_SLONG, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<Poco::Int32>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_SLONG, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<Poco::Int32>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_SLONG, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<Poco::Int32>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_SLONG, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const Poco::UInt32& val, Direction dir)
+{
+	bindImpl(pos, val, SQL_C_ULONG, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<Poco::UInt32>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_ULONG, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<Poco::UInt32>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_ULONG, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<Poco::UInt32>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_ULONG, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const Poco::Int64& val, Direction dir)
+{
+	bindImpl(pos, val, SQL_C_SBIGINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<Poco::Int64>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_SBIGINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<Poco::Int64>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_SBIGINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<Poco::Int64>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_SBIGINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const Poco::UInt64& val, Direction dir)
+{
+	bindImpl(pos, val, SQL_C_UBIGINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<Poco::UInt64>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_UBIGINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<Poco::UInt64>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_UBIGINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<Poco::UInt64>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_UBIGINT, dir);
+}
+
+
+#ifndef POCO_LONG_IS_64_BIT
+inline void Binder::bind(std::size_t pos, const long& val, Direction dir)
+{
+	bindImpl(pos, val, SQL_C_SLONG, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const unsigned long& val, Direction dir)
+{
+	bindImpl(pos, val, SQL_C_SLONG, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<long>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_SLONG, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<long>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_SLONG, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<long>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_SLONG, dir);
+}
+#endif
+
+
+inline void Binder::bind(std::size_t pos, const float& val, Direction dir)
+{
+	bindImpl(pos, val, SQL_C_FLOAT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<float>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_FLOAT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<float>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_FLOAT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<float>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_FLOAT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const double& val, Direction dir)
+{
+	bindImpl(pos, val, SQL_C_DOUBLE, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<double>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_DOUBLE, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<double>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_DOUBLE, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<double>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_DOUBLE, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const bool& val, Direction dir)
+{
+	bindImpl(pos, val, SQL_C_BIT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<bool>& val, Direction dir)
+{
+	bindImplContainerBool(pos, val, SQL_C_BIT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<bool>& val, Direction dir)
+{
+	bindImplContainerBool(pos, val, SQL_C_BIT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<bool>& val, Direction dir)
+{
+	bindImplContainerBool(pos, val, SQL_C_BIT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const char& val, Direction dir)
+{
+	bindImpl(pos, val, SQL_C_STINYINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<char>& val, Direction dir)
+{
+	bindImplVec(pos, val, SQL_C_STINYINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<char>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_STINYINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<char>& val, Direction dir)
+{
+	bindImplContainer(pos, val, SQL_C_STINYINT, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<std::string>& val, Direction dir)
+{
+	bindImplContainerString(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<std::string>& val, Direction dir)
+{
+	bindImplContainerString(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<std::string>& val, Direction dir)
+{
+	bindImplContainerString(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<UTF16String>& val, Direction dir)
+{
+	bindImplContainerUTF16String(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<UTF16String>& val, Direction dir)
+{
+	bindImplContainerUTF16String(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<UTF16String>& val, Direction dir)
+{
+	bindImplContainerUTF16String(pos, val, dir);
+}
+
+inline void Binder::bind(std::size_t pos, const BLOB& val, Direction dir)
+{
+	bindImplLOB<BLOB>(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const CLOB& val, Direction dir)
+{
+	bindImplLOB<CLOB>(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<BLOB>& val, Direction dir)
+{
+	bindImplContainerLOB(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<BLOB>& val, Direction dir)
+{
+	bindImplContainerLOB(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<BLOB>& val, Direction dir)
+{
+	bindImplContainerLOB(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<CLOB>& val, Direction dir)
+{
+	bindImplContainerLOB(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<CLOB>& val, Direction dir)
+{
+	bindImplContainerLOB(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<CLOB>& val, Direction dir)
+{
+	bindImplContainerLOB(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<Date>& val, Direction dir)
+{
+	bindImplContainerDate(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<Date>& val, Direction dir)
+{
+	bindImplContainerDate(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<Date>& val, Direction dir)
+{
+	bindImplContainerDate(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<Time>& val, Direction dir)
+{
+	bindImplContainerTime(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<Time>& val, Direction dir)
+{
+	bindImplContainerTime(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<Time>& val, Direction dir)
+{
+	bindImplContainerTime(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<DateTime>& val, Direction dir)
+{
+	bindImplContainerDateTime(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<DateTime>& val, Direction dir)
+{
+	bindImplContainerDateTime(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<DateTime>& val, Direction dir)
+{
+	bindImplContainerDateTime(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::vector<NullData>& val, Direction dir)
+{
+	bindImplNullContainer(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::deque<NullData>& val, Direction dir)
+{
+	bindImplNullContainer(pos, val, dir);
+}
+
+
+inline void Binder::bind(std::size_t pos, const std::list<NullData>& val, Direction dir)
+{
+	bindImplNullContainer(pos, val, dir);
+}
+
+
+inline void Binder::setDataBinding(Binder::ParameterBinding binding)
+{
+	_paramBinding = binding;
+}
+
+
+inline Binder::ParameterBinding Binder::getDataBinding() const
+{
+	return _paramBinding;
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif // Data_ODBC_Binder_INCLUDED
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/ConnectionHandle.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/ConnectionHandle.h
new file mode 100644
index 00000000000..466ad937d60
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/ConnectionHandle.h
@@ -0,0 +1,96 @@
+//
+// ConnectionHandle.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  ConnectionHandle
+//
+// Definition of ConnectionHandle.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_ConnectionHandle_INCLUDED
+#define Data_ODBC_ConnectionHandle_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/EnvironmentHandle.h"
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqltypes.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API ConnectionHandle
+/// ODBC connection handle class
+{
+public:
+	ConnectionHandle(EnvironmentHandle* pEnvironment = 0);
+		/// Creates the ConnectionHandle.
+
+	~ConnectionHandle();
+		/// Creates the ConnectionHandle.
+
+	operator const SQLHDBC& () const;
+		/// Const conversion operator into reference to native type.
+
+	const SQLHDBC& handle() const;
+		/// Returns const reference to handle;
+
+private:
+	operator SQLHDBC& ();
+		/// Conversion operator into reference to native type.
+
+	SQLHDBC& handle();
+		/// Returns reference to handle;
+
+	ConnectionHandle(const ConnectionHandle&);
+	const ConnectionHandle& operator=(const ConnectionHandle&);
+
+	const EnvironmentHandle* _pEnvironment;
+	SQLHDBC                  _hdbc;
+	bool                     _ownsEnvironment;
+};
+
+
+//
+// inlines
+//
+inline ConnectionHandle::operator const SQLHDBC& () const
+{
+	return handle();
+}
+
+
+inline const SQLHDBC& ConnectionHandle::handle() const
+{
+	return _hdbc;
+}
+
+
+inline ConnectionHandle::operator SQLHDBC& ()
+{
+	return handle();
+}
+
+
+inline SQLHDBC& ConnectionHandle::handle()
+{
+	return _hdbc;
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/Connector.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Connector.h
new file mode 100644
index 00000000000..8849bf77514
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Connector.h
@@ -0,0 +1,96 @@
+//
+// Connector.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Connector
+//
+// Definition of the Connector class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Connector_INCLUDED
+#define Data_ODBC_Connector_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/Connector.h"
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API Connector: public Poco::Data::Connector
+	/// Connector instantiates SqLite SessionImpl objects.
+{
+public:
+	static const std::string KEY;
+		/// Keyword for creating ODBC sessions.
+
+	Connector();
+		/// Creates the Connector.
+
+	~Connector();
+		/// Destroys the Connector.
+
+	const std::string& name() const;
+		/// Returns the name associated with this connector.
+
+	Poco::AutoPtr<Poco::Data::SessionImpl> createSession(const std::string& connectionString,
+		std::size_t timeout = Poco::Data::SessionImpl::LOGIN_TIMEOUT_DEFAULT);
+		/// Creates a ODBC SessionImpl object and initializes it with the given connectionString.
+
+	static void registerConnector();
+		/// Registers the Connector under the Keyword Connector::KEY at the Poco::Data::SessionFactory
+
+	static void unregisterConnector();
+		/// Unregisters the Connector under the Keyword Connector::KEY at the Poco::Data::SessionFactory
+
+	static void bindStringToLongVarChar(bool flag = true);
+		/// If set to true (default), std::string is bound to SQL_LONGVARCHAR.
+		///
+		/// This can cause issues with SQL Server, resulting in an error
+		/// ("The data types varchar and text are incompatible in the equal to operator")
+		/// when comparing against a VARCHAR. 
+		///
+		/// Set this to false to bind std::string to SQL_VARCHAR.
+		///
+		/// NOTE: This is a global setting, affecting all sessions.
+		/// This setting should not be changed after the first Session has
+		/// been created.
+
+	static bool stringBoundToLongVarChar();
+		/// Returns true if std::string is bound to SQL_LONGVARCHAR,
+		/// otherwise false (bound to SQL_VARCHAR).
+
+private:
+	static bool _bindStringToLongVarChar;
+};
+
+
+///
+/// inlines
+///
+inline const std::string& Connector::name() const
+{
+	return KEY;
+}
+
+
+inline bool Connector::stringBoundToLongVarChar()
+{
+	return _bindStringToLongVarChar;
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif // Data_ODBC_Connector_INCLUDED
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/Diagnostics.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Diagnostics.h
new file mode 100644
index 00000000000..86c15fa4224
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Diagnostics.h
@@ -0,0 +1,239 @@
+//
+// Diagnostics.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Diagnostics
+//
+// Definition of Diagnostics.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Diagnostics_INCLUDED
+#define Data_ODBC_Diagnostics_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include <vector>
+#include <cstring>
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqlext.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+template <typename H, SQLSMALLINT handleType>
+class Diagnostics
+	/// Utility class providing functionality for retrieving ODBC diagnostic
+	/// records. Diagnostics object must be created with corresponding handle
+	/// as constructor argument. During construction, diagnostic records fields 
+	/// are populated and the object is ready for querying.
+{
+public:
+
+	static const unsigned int SQL_STATE_SIZE = SQL_SQLSTATE_SIZE + 1;
+	static const unsigned int SQL_MESSAGE_LENGTH = SQL_MAX_MESSAGE_LENGTH + 1;
+	static const unsigned int SQL_NAME_LENGTH = 128;
+	static const std::string  DATA_TRUNCATED;
+
+	struct DiagnosticFields
+	{
+		/// SQLGetDiagRec fields
+		SQLCHAR    _sqlState[SQL_STATE_SIZE];
+		SQLCHAR    _message[SQL_MESSAGE_LENGTH];
+		SQLINTEGER _nativeError;
+	};
+
+	typedef std::vector<DiagnosticFields> FieldVec;
+	typedef typename FieldVec::const_iterator Iterator;
+
+	explicit Diagnostics(const H& handle): _handle(handle)
+		/// Creates and initializes the Diagnostics.
+	{
+		std::memset(_connectionName, 0, sizeof(_connectionName));
+		std::memset(_serverName, 0, sizeof(_serverName));
+		diagnostics();
+	}
+
+	~Diagnostics()
+		/// Destroys the Diagnostics.
+	{
+	}
+
+	std::string sqlState(int index) const
+		/// Returns SQL state.
+	{
+		poco_assert (index < count());
+		return std::string((char*) _fields[index]._sqlState);
+	}
+
+	std::string message(int index) const
+		/// Returns error message.
+	{
+		poco_assert (index < count());
+		return std::string((char*) _fields[index]._message);
+	}
+
+	long nativeError(int index) const
+		/// Returns native error code.
+	{
+		poco_assert (index < count());
+		return _fields[index]._nativeError;
+	}
+
+	std::string connectionName() const
+		/// Returns the connection name. 
+		/// If there is no active connection, connection name defaults to NONE.
+		/// If connection name is not applicable for query context (such as when querying environment handle),
+		/// connection name defaults to NOT_APPLICABLE.
+	{
+		return std::string((char*) _connectionName);
+	}
+
+	std::string serverName() const
+		/// Returns the server name.
+		/// If the connection has not been established, server name defaults to NONE.
+		/// If server name is not applicable for query context (such as when querying environment handle),
+		/// connection name defaults to NOT_APPLICABLE.
+	{
+		return std::string((char*) _serverName);
+	}
+
+	int count() const
+		/// Returns the number of contained diagnostic records.
+	{
+		return (int) _fields.size();
+	}
+
+	void reset()
+		/// Resets the diagnostic fields container.
+	{
+		_fields.clear();
+	}
+
+	const FieldVec& fields() const
+	{
+		return _fields;
+	}
+
+	Iterator begin() const
+	{
+		return _fields.begin();
+	}
+
+	Iterator end() const
+	{
+		return _fields.end();
+	}
+
+	const Diagnostics& diagnostics()
+	{
+		DiagnosticFields df;
+		SQLSMALLINT count = 1;
+		SQLSMALLINT messageLength = 0;
+		static const std::string none = "None";
+		static const std::string na = "Not applicable";
+
+		reset();
+
+		while (!Utility::isError(SQLGetDiagRec(handleType, 
+			_handle, 
+			count, 
+			df._sqlState, 
+			&df._nativeError, 
+			df._message, 
+			SQL_MESSAGE_LENGTH, 
+			&messageLength))) 
+		{
+			if (1 == count)
+			{
+				// success of the following two calls is optional
+				// (they fail if connection has not been established yet
+				//  or return empty string if not applicable for the context)
+				if (Utility::isError(SQLGetDiagField(handleType, 
+					_handle, 
+					count, 
+					SQL_DIAG_CONNECTION_NAME, 
+					_connectionName, 
+					sizeof(_connectionName), 
+					&messageLength)))
+				{
+					std::size_t len = sizeof(_connectionName) > none.length() ? 
+						none.length() : sizeof(_connectionName) - 1;
+					std::memcpy(_connectionName, none.c_str(), len);
+				}
+				else if (0 == _connectionName[0]) 
+				{
+					std::size_t len = sizeof(_connectionName) > na.length() ? 
+						na.length() : sizeof(_connectionName) - 1;
+					std::memcpy(_connectionName, na.c_str(), len);
+				}
+				
+				if (Utility::isError(SQLGetDiagField(handleType, 
+					_handle, 
+					count, 
+					SQL_DIAG_SERVER_NAME, 
+					_serverName, 
+					sizeof(_serverName), 
+					&messageLength)))
+				{
+					std::size_t len = sizeof(_serverName) > none.length() ? 
+						none.length() : sizeof(_serverName) - 1;
+					std::memcpy(_serverName, none.c_str(), len);
+				}
+				else if (0 == _serverName[0]) 
+				{
+					std::size_t len = sizeof(_serverName) > na.length() ? 
+						na.length() : sizeof(_serverName) - 1;
+					std::memcpy(_serverName, na.c_str(), len);
+				}
+			}
+
+			_fields.push_back(df);
+
+			std::memset(df._sqlState, 0, SQL_STATE_SIZE);
+			std::memset(df._message, 0, SQL_MESSAGE_LENGTH);
+			df._nativeError = 0;
+
+			++count;
+		}
+
+		return *this;
+	}
+
+private:
+
+	Diagnostics();
+
+	/// SQLGetDiagField fields
+	SQLCHAR _connectionName[SQL_NAME_LENGTH];
+	SQLCHAR _serverName[SQL_NAME_LENGTH];
+
+	/// Diagnostics container
+	FieldVec _fields;
+
+	/// Context handle
+	const H& _handle;
+};
+
+
+typedef Diagnostics<SQLHENV, SQL_HANDLE_ENV> EnvironmentDiagnostics;
+typedef Diagnostics<SQLHDBC, SQL_HANDLE_DBC> ConnectionDiagnostics;
+typedef Diagnostics<SQLHSTMT, SQL_HANDLE_STMT> StatementDiagnostics;
+typedef Diagnostics<SQLHDESC, SQL_HANDLE_DESC> DescriptorDiagnostics;
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/EnvironmentHandle.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/EnvironmentHandle.h
new file mode 100644
index 00000000000..cec8d729ed0
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/EnvironmentHandle.h
@@ -0,0 +1,94 @@
+//
+// EnvironmentHandle.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  EnvironmentHandle
+//
+// Definition of EnvironmentHandle.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_EnvironmentHandle_INCLUDED
+#define Data_ODBC_EnvironmentHandle_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqltypes.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API EnvironmentHandle
+/// ODBC environment handle class
+{
+public:
+	EnvironmentHandle();
+		/// Creates the EnvironmentHandle.
+
+	~EnvironmentHandle();
+		/// Destroys the EnvironmentHandle.
+
+	operator const SQLHENV& () const;
+		/// Const conversion operator into reference to native type.
+
+	const SQLHENV& handle() const;
+		/// Returns const reference to handle.
+
+private:
+	operator SQLHENV& ();
+		/// Conversion operator into reference to native type.
+
+	SQLHENV& handle();
+		/// Returns reference to handle.
+
+	EnvironmentHandle(const EnvironmentHandle&);
+	const EnvironmentHandle& operator=(const EnvironmentHandle&);
+
+	SQLHENV _henv;
+	bool    _isOwner;
+};
+
+
+///
+/// inlines
+///
+inline EnvironmentHandle::operator const SQLHENV& () const
+{
+	return handle();
+}
+
+
+inline const SQLHENV& EnvironmentHandle::handle() const
+{
+	return _henv;
+}
+
+
+inline EnvironmentHandle::operator SQLHENV& ()
+{
+	return handle();
+}
+
+
+inline SQLHENV& EnvironmentHandle::handle()
+{
+	return _henv;
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/Error.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Error.h
new file mode 100644
index 00000000000..049cc02d1d1
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Error.h
@@ -0,0 +1,124 @@
+//
+// Error.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Error
+//
+// Definition of Error.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Error_INCLUDED
+#define Data_ODBC_Error_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/Diagnostics.h"
+#include "Poco/Format.h"
+#include <vector>
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqlext.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+template <typename H, SQLSMALLINT handleType>
+class Error
+	/// Class encapsulating ODBC diagnostic record collection. Collection is generated
+	/// during construction. Class provides access and string generation for the collection
+	/// as well as individual diagnostic records.
+{
+public:
+	explicit Error(const H& handle) : _diagnostics(handle)
+		/// Creates the Error.
+	{
+	}
+
+	~Error()
+		/// Destroys the Error.
+	{
+	}
+
+	const Diagnostics<H, handleType>& diagnostics() const
+		/// Returns the associated diagnostics.
+	{
+		return _diagnostics;
+	}
+
+	int count() const
+		/// Returns the count of diagnostic records.
+	{
+		return (int) _diagnostics.count();
+	}
+
+	std::string& toString(int index, std::string& str) const
+		/// Generates the string for the diagnostic record.
+	{
+		if ((index < 0) || (index > (count() - 1))) 
+			return str;
+
+		std::string s;
+		Poco::format(s, 
+			"===========================\n"
+			"ODBC Diagnostic record #%d:\n"
+			"===========================\n"
+			"SQLSTATE = %s\nNative Error Code = %ld\n%s\n\n",
+			index + 1,
+			_diagnostics.sqlState(index),
+			_diagnostics.nativeError(index),
+			_diagnostics.message(index));
+
+		str.append(s);
+
+		return str;
+	}
+
+	std::string toString() const
+		/// Generates the string for the diagnostic record collection.
+	{
+		std::string str;
+
+		Poco::format(str, 
+			"Connection:%s\nServer:%s\n",
+			_diagnostics.connectionName(),
+			_diagnostics.serverName());
+
+		std::string s;
+		for (int i = 0; i < count(); ++i)
+		{
+			s.clear();
+			str.append(toString(i, s));
+		}
+
+		return str;
+	}
+
+private:
+	Error();
+
+	Diagnostics<H, handleType> _diagnostics;
+};
+
+
+typedef Error<SQLHENV, SQL_HANDLE_ENV> EnvironmentError;
+typedef Error<SQLHDBC, SQL_HANDLE_DBC> ConnectionError;
+typedef Error<SQLHSTMT, SQL_HANDLE_STMT> StatementError;
+typedef Error<SQLHSTMT, SQL_HANDLE_DESC> DescriptorError;
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/Extractor.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Extractor.h
new file mode 100644
index 00000000000..f3ce016c34f
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Extractor.h
@@ -0,0 +1,728 @@
+//
+// Extractor.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Extractor
+//
+// Definition of the Extractor class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Extractor_INCLUDED
+#define Data_ODBC_Extractor_INCLUDED
+
+
+#include "Poco/Data/Constants.h"
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/AbstractExtractor.h"
+#include "Poco/Data/ODBC/Preparator.h"
+#include "Poco/Data/ODBC/ODBCMetaColumn.h"
+#include "Poco/Data/ODBC/Error.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/Date.h"
+#include "Poco/Data/Time.h"
+#include "Poco/DateTime.h"
+#include "Poco/Any.h"
+#include "Poco/Dynamic/Var.h"
+#include "Poco/Nullable.h"
+#include "Poco/UTFString.h"
+#include "Poco/Exception.h"
+#include <map>
+#ifdef POCO_OS_FAMILY_WINDOWS
+	#include <windows.h>
+#endif
+#include <sqltypes.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API Extractor: public Poco::Data::AbstractExtractor
+	/// Extracts and converts data values from the result row returned by ODBC.
+	/// If NULL is received, the incoming val value is not changed and false is returned
+{
+public:
+	typedef Preparator::Ptr PreparatorPtr;
+
+	Extractor(const StatementHandle& rStmt, 
+		Preparator::Ptr pPreparator);
+		/// Creates the Extractor.
+
+	~Extractor();
+		/// Destroys the Extractor.
+
+	bool extract(std::size_t pos, Poco::Int8& val);
+		/// Extracts an Int8.
+
+	bool extract(std::size_t pos, std::vector<Poco::Int8>& val);
+		/// Extracts an Int8 vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::Int8>& val);
+		/// Extracts an Int8 deque.
+
+	bool extract(std::size_t pos, std::list<Poco::Int8>& val);
+		/// Extracts an Int8 list.
+
+	bool extract(std::size_t pos, Poco::UInt8& val);
+		/// Extracts an UInt8.
+
+	bool extract(std::size_t pos, std::vector<Poco::UInt8>& val);
+		/// Extracts an UInt8 vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::UInt8>& val);
+		/// Extracts an UInt8 deque.
+
+	bool extract(std::size_t pos, std::list<Poco::UInt8>& val);
+		/// Extracts an UInt8 list.
+
+	bool extract(std::size_t pos, Poco::Int16& val);
+		/// Extracts an Int16.
+
+	bool extract(std::size_t pos, std::vector<Poco::Int16>& val);
+		/// Extracts an Int16 vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::Int16>& val);
+		/// Extracts an Int16 deque.
+
+	bool extract(std::size_t pos, std::list<Poco::Int16>& val);
+		/// Extracts an Int16 list.
+
+	bool extract(std::size_t pos, Poco::UInt16& val);
+		/// Extracts an UInt16.
+
+	bool extract(std::size_t pos, std::vector<Poco::UInt16>& val);
+		/// Extracts an UInt16 vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::UInt16>& val);
+		/// Extracts an UInt16 deque.
+
+	bool extract(std::size_t pos, std::list<Poco::UInt16>& val);
+		/// Extracts an UInt16 list.
+
+	bool extract(std::size_t pos, Poco::Int32& val);
+		/// Extracts an Int32.
+
+	bool extract(std::size_t pos, std::vector<Poco::Int32>& val);
+		/// Extracts an Int32 vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::Int32>& val);
+		/// Extracts an Int32 deque.
+
+	bool extract(std::size_t pos, std::list<Poco::Int32>& val);
+		/// Extracts an Int32 list.
+
+	bool extract(std::size_t pos, Poco::UInt32& val);
+		/// Extracts an UInt32.
+
+	bool extract(std::size_t pos, std::vector<Poco::UInt32>& val);
+		/// Extracts an UInt32 vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::UInt32>& val);
+		/// Extracts an UInt32 deque.
+
+	bool extract(std::size_t pos, std::list<Poco::UInt32>& val);
+		/// Extracts an UInt32 list.
+
+	bool extract(std::size_t pos, Poco::Int64& val);
+		/// Extracts an Int64.
+
+	bool extract(std::size_t pos, std::vector<Poco::Int64>& val);
+		/// Extracts an Int64 vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::Int64>& val);
+		/// Extracts an Int64 deque.
+
+	bool extract(std::size_t pos, std::list<Poco::Int64>& val);
+		/// Extracts an Int64 list.
+
+	bool extract(std::size_t pos, Poco::UInt64& val);
+		/// Extracts an UInt64.
+
+	bool extract(std::size_t pos, std::vector<Poco::UInt64>& val);
+		/// Extracts an UInt64 vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::UInt64>& val);
+		/// Extracts an UInt64 deque.
+
+	bool extract(std::size_t pos, std::list<Poco::UInt64>& val);
+		/// Extracts an UInt64 list.
+
+#ifndef POCO_LONG_IS_64_BIT
+	bool extract(std::size_t pos, long& val);
+		/// Extracts a long.
+
+	bool extract(std::size_t pos, unsigned long& val);
+		/// Extracts an unsigned long.
+
+	bool extract(std::size_t pos, std::vector<long>& val);
+		/// Extracts a long vector.
+
+	bool extract(std::size_t pos, std::deque<long>& val);
+		/// Extracts a long deque.
+
+	bool extract(std::size_t pos, std::list<long>& val);
+		/// Extracts a long list.
+#endif
+
+	bool extract(std::size_t pos, bool& val);
+		/// Extracts a boolean.
+
+	bool extract(std::size_t pos, std::vector<bool>& val);
+		/// Extracts a boolean vector.
+
+	bool extract(std::size_t pos, std::deque<bool>& val);
+		/// Extracts a boolean deque.
+
+	bool extract(std::size_t pos, std::list<bool>& val);
+		/// Extracts a boolean list.
+
+	bool extract(std::size_t pos, float& val);
+		/// Extracts a float.
+
+	bool extract(std::size_t pos, std::vector<float>& val);
+		/// Extracts a float vector.
+
+	bool extract(std::size_t pos, std::deque<float>& val);
+		/// Extracts a float deque.
+
+	bool extract(std::size_t pos, std::list<float>& val);
+		/// Extracts a float list.
+
+	bool extract(std::size_t pos, double& val);
+		/// Extracts a double.
+
+	bool extract(std::size_t pos, std::vector<double>& val);
+		/// Extracts a double vector.
+
+	bool extract(std::size_t pos, std::deque<double>& val);
+		/// Extracts a double deque.
+
+	bool extract(std::size_t pos, std::list<double>& val);
+		/// Extracts a double list.
+
+	bool extract(std::size_t pos, char& val);
+		/// Extracts a single character.
+
+	bool extract(std::size_t pos, std::vector<char>& val);
+		/// Extracts a single character vector.
+
+	bool extract(std::size_t pos, std::deque<char>& val);
+		/// Extracts a single character deque.
+
+	bool extract(std::size_t pos, std::list<char>& val);
+		/// Extracts a single character list.
+
+	bool extract(std::size_t pos, std::string& val);
+		/// Extracts a string.
+
+	bool extract(std::size_t pos, std::vector<std::string>& val);
+		/// Extracts a string vector.
+
+	bool extract(std::size_t pos, std::deque<std::string>& val);
+		/// Extracts a string deque.
+
+	bool extract(std::size_t pos, std::list<std::string>& val);
+		/// Extracts a string list.
+		/// Extracts a single character list.
+
+	bool extract(std::size_t pos, UTF16String& val);
+	/// Extracts a string.
+
+	bool extract(std::size_t pos, std::vector<UTF16String>& val);
+	/// Extracts a string vector.
+
+	bool extract(std::size_t pos, std::deque<UTF16String>& val);
+	/// Extracts a string deque.
+
+	bool extract(std::size_t pos, std::list<UTF16String>& val);
+	/// Extracts a string list.
+
+	bool extract(std::size_t pos, Poco::Data::BLOB& val);
+		/// Extracts a BLOB.
+
+	bool extract(std::size_t pos, Poco::Data::CLOB& val);
+		/// Extracts a CLOB.
+
+	bool extract(std::size_t pos, std::vector<Poco::Data::BLOB>& val);
+		/// Extracts a BLOB vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::Data::BLOB>& val);
+		/// Extracts a BLOB deque.
+
+	bool extract(std::size_t pos, std::list<Poco::Data::BLOB>& val);
+		/// Extracts a BLOB list.
+
+	bool extract(std::size_t pos, std::vector<Poco::Data::CLOB>& val);
+		/// Extracts a CLOB vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::Data::CLOB>& val);
+		/// Extracts a CLOB deque.
+
+	bool extract(std::size_t pos, std::list<Poco::Data::CLOB>& val);
+		/// Extracts a CLOB list.
+
+	bool extract(std::size_t pos, Poco::Data::Date& val);
+		/// Extracts a Date.
+
+	bool extract(std::size_t pos, std::vector<Poco::Data::Date>& val);
+		/// Extracts a Date vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::Data::Date>& val);
+		/// Extracts a Date deque.
+
+	bool extract(std::size_t pos, std::list<Poco::Data::Date>& val);
+		/// Extracts a Date list.
+
+	bool extract(std::size_t pos, Poco::Data::Time& val);
+		/// Extracts a Time.
+
+	bool extract(std::size_t pos, std::vector<Poco::Data::Time>& val);
+		/// Extracts a Time vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::Data::Time>& val);
+		/// Extracts a Time deque.
+
+	bool extract(std::size_t pos, std::list<Poco::Data::Time>& val);
+		/// Extracts a Time list.
+
+	bool extract(std::size_t pos, Poco::DateTime& val);
+		/// Extracts a DateTime.
+
+	bool extract(std::size_t pos, std::vector<Poco::DateTime>& val);
+		/// Extracts a DateTime vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::DateTime>& val);
+		/// Extracts a DateTime deque.
+
+	bool extract(std::size_t pos, std::list<Poco::DateTime>& val);
+		/// Extracts a DateTime list.
+	
+	bool extract(std::size_t pos, Poco::Any& val);
+		/// Extracts an Any.
+
+	bool extract(std::size_t pos, std::vector<Poco::Any>& val);
+		/// Extracts an Any vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::Any>& val);
+		/// Extracts an Any deque.
+
+	bool extract(std::size_t pos, std::list<Poco::Any>& val);
+		/// Extracts an Any list.
+
+	bool extract(std::size_t pos, Poco::DynamicAny& val);
+		/// Extracts a DynamicAny.
+
+	bool extract(std::size_t pos, std::vector<Poco::DynamicAny>& val);
+		/// Extracts a DynamicAny vector.
+
+	bool extract(std::size_t pos, std::deque<Poco::DynamicAny>& val);
+		/// Extracts a DynamicAny deque.
+
+	bool extract(std::size_t pos, std::list<Poco::DynamicAny>& val);
+		/// Extracts a DynamicAny list.
+
+	void setDataExtraction(Preparator::DataExtraction ext);
+		/// Set data extraction mode.
+
+	Preparator::DataExtraction getDataExtraction() const;
+		/// Returns data extraction mode.
+
+	bool isNull(std::size_t col, std::size_t row = POCO_DATA_INVALID_ROW);
+		/// Returns true if the value at [col,row] is null.
+
+	void reset();
+		/// Resets the internally cached length indicators. 
+
+private:
+	static const int CHUNK_SIZE = 1024;
+		/// Amount of data retrieved in one SQLGetData() request when doing manual extract.
+
+	static const std::string FLD_SIZE_EXCEEDED_FMT;
+		/// String format for the exception message when the field size is exceeded.
+
+	void checkDataSize(std::size_t size);
+		/// This check is only performed for bound data
+		/// retrieval from variable length columns.
+		/// The reason for this check is to ensure we can
+		/// accept the value ODBC driver is supplying
+		/// (i.e. the bound buffer is large enough to receive
+		/// the returned value)
+
+	void resizeLengths(std::size_t pos);
+		/// Resizes the vector holding extracted data lengths to the
+		/// appropriate size.
+
+	template<typename T>
+	bool extractBoundImpl(std::size_t pos, T& val)
+	{
+		if (isNull(pos)) return false;
+		poco_assert_dbg (typeid(T) == _pPreparator->at(pos).type());
+		val = *AnyCast<T>(&_pPreparator->at(pos)); 
+		return true;
+	}
+
+	bool extractBoundImpl(std::size_t pos, Poco::Data::BLOB& val);
+	bool extractBoundImpl(std::size_t pos, Poco::Data::CLOB& val);
+
+	template <typename C>
+	bool extractBoundImplContainer(std::size_t pos, C& val)
+	{
+		typedef typename C::value_type Type;
+		poco_assert_dbg (typeid(std::vector<Type>) == _pPreparator->at(pos).type());
+		std::vector<Type>& v = RefAnyCast<std::vector<Type> >(_pPreparator->at(pos));
+		val.assign(v.begin(), v.end());
+		return true;
+	}
+
+	bool extractBoundImplContainer(std::size_t pos, std::vector<std::string>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::deque<std::string>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::list<std::string>& values); 
+	bool extractBoundImplContainer(std::size_t pos, std::vector<Poco::UTF16String>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::deque<Poco::UTF16String>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::list<Poco::UTF16String>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::vector<Poco::Data::CLOB>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::deque<Poco::Data::CLOB>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::list<Poco::Data::CLOB>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::vector<Poco::Data::BLOB>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::deque<Poco::Data::BLOB>& values);
+	bool extractBoundImplContainer(std::size_t pos, std::list<Poco::Data::BLOB>& values);
+
+	template <typename C>
+	bool extractBoundImplContainerString(std::size_t pos, C& values)
+	{
+		typedef typename C::value_type StringType;
+		typedef typename C::iterator ItType;
+		typedef typename StringType::value_type CharType;
+
+		CharType** pc = AnyCast<CharType*>(&(_pPreparator->at(pos)));
+		poco_assert_dbg (pc);
+		poco_assert_dbg (_pPreparator->bulkSize() == values.size());
+		std::size_t colWidth = columnSize(pos);
+		ItType it = values.begin();
+		ItType end = values.end();
+		for (int row = 0; it != end; ++it, ++row)
+		{
+			it->assign(*pc + row * colWidth / sizeof(CharType), _pPreparator->actualDataSize(pos, row));
+			// clean up superfluous null chars returned by some drivers
+			typename StringType::size_type trimLen = 0;
+			typename StringType::reverse_iterator sIt = it->rbegin();
+			typename StringType::reverse_iterator sEnd = it->rend();
+			for (; sIt != sEnd; ++sIt)
+			{
+				if (*sIt == '\0') ++trimLen;
+				else break;
+			}
+			if (trimLen) it->assign(it->begin(), it->begin() + it->length() - trimLen);
+		}
+
+		return true;
+	}
+
+	template <typename C>
+	bool extractBoundImplContainerLOB(std::size_t pos, C& values)
+	{
+		typedef typename C::value_type LOBType;
+		typedef typename LOBType::ValueType CharType;
+		typedef typename C::iterator ItType;
+
+		CharType** pc = AnyCast<CharType*>(&(_pPreparator->at(pos)));
+		poco_assert_dbg (pc);
+		poco_assert_dbg (_pPreparator->bulkSize() == values.size());
+		std::size_t colWidth = _pPreparator->maxDataSize(pos);
+		ItType it = values.begin();
+		ItType end = values.end();
+		for (int row = 0; it != end; ++it, ++row)
+			it->assignRaw(*pc + row * colWidth, _pPreparator->actualDataSize(pos, row));
+
+		return true;
+	}
+
+	template<typename T>
+	bool extractBoundImplLOB(std::size_t pos, Poco::Data::LOB<T>& val)
+	{
+		if (isNull(pos)) return false;
+
+		std::size_t dataSize = _pPreparator->actualDataSize(pos);
+		checkDataSize(dataSize);
+		T* sp = AnyCast<T*>(_pPreparator->at(pos));
+		val.assignRaw(sp, dataSize);
+
+		return true;
+	}
+
+	template<typename T>
+	bool extractManualImpl(std::size_t pos, T& val, SQLSMALLINT cType)
+	{
+		SQLRETURN rc = 0;
+		T value = (T) 0;
+
+		resizeLengths(pos);
+
+		rc = SQLGetData(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			cType,  //C data type
+			&value, //returned value
+			0,      //buffer length (ignored)
+			&_lengths[pos]);  //length indicator
+
+		if (Utility::isError(rc))
+			throw StatementException(_rStmt, "SQLGetData()");
+		
+		if (isNullLengthIndicator(_lengths[pos])) 
+			return false;
+		else 
+		{
+			//for fixed-length data, buffer must be large enough
+			//otherwise, driver may write past the end
+			poco_assert_dbg (_lengths[pos] <= sizeof(T));
+			val = value;
+		}
+
+		return true;
+	}
+
+	template <typename T, typename NT>
+	bool extAny(std::size_t pos, T& val)
+	{
+		NT i;
+		if (extract(pos, i))
+		{
+			val = i;
+			return true;
+		}
+		else
+		{
+			val = Nullable<NT>();
+			return false;
+		}
+	}
+
+	template <typename T>
+	bool extractImpl(std::size_t pos, T& val)
+		/// Utility function for extraction of Any and DynamicAny.
+	{
+		ODBCMetaColumn column(_rStmt, pos);
+
+		switch (column.type())
+		{
+			case MetaColumn::FDT_INT8:
+			{ return extAny<T, Poco::Int8>(pos, val); }
+
+			case MetaColumn::FDT_UINT8:
+			{ return extAny<T, Poco::UInt8>(pos, val); }
+
+			case MetaColumn::FDT_INT16:
+			{ return extAny<T, Poco::Int16>(pos, val); }
+
+			case MetaColumn::FDT_UINT16:
+			{ return extAny<T, Poco::UInt16>(pos, val); }
+
+			case MetaColumn::FDT_INT32:
+			{ return extAny<T, Poco::Int32>(pos, val);	}
+
+			case MetaColumn::FDT_UINT32:
+			{ return extAny<T, Poco::UInt32>(pos, val); }
+
+			case MetaColumn::FDT_INT64:
+			{ return extAny<T, Poco::Int64>(pos, val); }
+
+			case MetaColumn::FDT_UINT64:
+			{ return extAny<T, Poco::UInt64>(pos, val); }
+
+			case MetaColumn::FDT_BOOL:
+			{ return extAny<T, bool>(pos, val); }
+
+			case MetaColumn::FDT_FLOAT:
+			{ return extAny<T, float>(pos, val); }
+
+			case MetaColumn::FDT_DOUBLE:
+			{ return extAny<T, double>(pos, val); }
+
+			case MetaColumn::FDT_STRING:
+			{ return extAny<T, std::string>(pos, val); }
+
+			case MetaColumn::FDT_WSTRING:
+			{ return extAny<T, Poco::UTF16String>(pos, val); }
+
+			case MetaColumn::FDT_BLOB:
+			{ return extAny<T, Poco::Data::BLOB>(pos, val); }
+
+			case MetaColumn::FDT_CLOB:
+			{ return extAny<T, Poco::Data::CLOB>(pos, val); }
+
+			case MetaColumn::FDT_DATE:
+			{ return extAny<T, Poco::Data::Date>(pos, val); }
+
+			case MetaColumn::FDT_TIME:
+			{ return extAny<T, Poco::Data::Time>(pos, val); }
+
+			case MetaColumn::FDT_TIMESTAMP:
+			{ return extAny<T, Poco::DateTime>(pos, val); }
+
+			default: 
+				throw DataFormatException("Unsupported data type.");
+		}
+
+		return false;
+	}
+
+	bool isNullLengthIndicator(SQLLEN val) const;
+		/// The reason for this utility wrapper are platforms where 
+		/// SQLLEN macro (a.k.a. SQLINTEGER) yields 64-bit value, 
+		/// while SQL_NULL_DATA (#define'd as -1 literal) remains 32-bit.
+
+	SQLINTEGER columnSize(std::size_t pos) const;
+
+	const StatementHandle&     _rStmt;
+	PreparatorPtr              _pPreparator;
+	Preparator::DataExtraction _dataExtraction;
+	std::vector<SQLLEN>        _lengths;
+};
+
+
+///
+/// inlines
+///
+
+inline bool Extractor::extractBoundImpl(std::size_t pos, Poco::Data::BLOB& val)
+{
+	return extractBoundImplLOB<BLOB::ValueType>(pos, val);
+}
+
+
+inline bool Extractor::extractBoundImpl(std::size_t pos, Poco::Data::CLOB& val)
+{
+	return extractBoundImplLOB<CLOB::ValueType>(pos, val);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, std::vector<std::string>& values)
+{
+	return extractBoundImplContainerString(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, std::deque<std::string>& values)
+{
+	return extractBoundImplContainerString(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, std::list<std::string>& values)
+{
+	return extractBoundImplContainerString(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, std::vector<Poco::UTF16String>& values)
+{
+	return extractBoundImplContainerString(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, std::deque<Poco::UTF16String>& values)
+{
+	return extractBoundImplContainerString(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, std::list<Poco::UTF16String>& values)
+{
+	return extractBoundImplContainerString(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, 
+	std::vector<Poco::Data::CLOB>& values)
+{
+	return extractBoundImplContainerLOB(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, 
+	std::deque<Poco::Data::CLOB>& values)
+{
+	return extractBoundImplContainerLOB(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, 
+	std::list<Poco::Data::CLOB>& values)
+{
+	return extractBoundImplContainerLOB(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, 
+	std::vector<Poco::Data::BLOB>& values)
+{
+	return extractBoundImplContainerLOB(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, 
+	std::deque<Poco::Data::BLOB>& values)
+{
+	return extractBoundImplContainerLOB(pos, values);
+}
+
+
+inline bool Extractor::extractBoundImplContainer(std::size_t pos, 
+	std::list<Poco::Data::BLOB>& values)
+{
+	return extractBoundImplContainerLOB(pos, values);
+}
+
+
+inline void Extractor::setDataExtraction(Preparator::DataExtraction ext)
+{
+	_pPreparator->setDataExtraction(_dataExtraction = ext);
+}
+
+
+inline Preparator::DataExtraction Extractor::getDataExtraction() const
+{
+	return _dataExtraction;
+}
+
+
+inline void Extractor::reset()
+{
+	_lengths.clear();
+}
+
+
+inline void Extractor::resizeLengths(std::size_t pos)
+{
+	if (pos >= _lengths.size()) 
+		_lengths.resize(pos + 1, (SQLLEN) 0);
+}
+
+
+inline bool Extractor::isNullLengthIndicator(SQLLEN val) const
+{
+	return SQL_NULL_DATA == (int) val;
+}
+
+
+inline SQLINTEGER Extractor::columnSize(std::size_t pos) const
+{
+	std::size_t size = ODBCMetaColumn(_rStmt, pos).length();
+	std::size_t maxSize = _pPreparator->maxDataSize(pos);
+	if (size > maxSize) size = maxSize;
+	return (SQLINTEGER) size;
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif // Data_ODBC_Extractor_INCLUDED
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/Handle.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Handle.h
new file mode 100644
index 00000000000..73afe5964c7
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Handle.h
@@ -0,0 +1,113 @@
+//
+// Handle.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Handle
+//
+// Definition of Handle.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Handle_INCLUDED
+#define Data_ODBC_Handle_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/EnvironmentHandle.h"
+#include "Poco/Data/ODBC/ConnectionHandle.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+#include "Poco/Data/ODBC/Utility.h"
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqltypes.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+template <typename H, SQLSMALLINT handleType>
+class Handle
+/// ODBC handle class template
+{
+public:
+	Handle(const ConnectionHandle& rConnection): 
+		_rConnection(rConnection),
+		_handle(0)
+			/// Creates the Handle.
+	{
+		if (Utility::isError(SQLAllocHandle(handleType, 
+			_rConnection, 
+			&_handle))) 
+		{
+			throw ODBCException("Could not allocate statement handle.");
+		}
+	}
+
+	~Handle()
+		/// Destroys the Handle.
+	{
+		try
+		{
+			SQLRETURN rc = SQLFreeHandle(handleType, _handle);
+			// N.B. Destructors should not throw, but neither do we want to
+			// leak resources. So, we throw here in debug mode if things go bad.
+			poco_assert_dbg (!Utility::isError(rc));
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	}
+
+	operator const H& () const
+		/// Const conversion operator into reference to native type.
+	{
+		return handle();
+	}
+
+	const H& handle() const
+		/// Returns const reference to native type.
+	{
+		return _handle;
+	}
+
+private:
+	Handle(const Handle&);
+	const Handle& operator=(const Handle&);
+
+	operator H& ()
+		/// Conversion operator into reference to native type.
+	{
+		return handle();
+	}
+
+	H& handle()
+		/// Returns reference to native type.
+	{
+		return _handle;
+	}
+
+	const ConnectionHandle& _rConnection;
+	H _handle;
+
+	friend class ODBCStatementImpl;
+};
+
+
+typedef Handle<SQLHSTMT, SQL_HANDLE_STMT> StatementHandle;
+typedef Handle<SQLHDESC, SQL_HANDLE_DESC> DescriptorHandle;
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBC.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBC.h
new file mode 100644
index 00000000000..647e4b8f060
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBC.h
@@ -0,0 +1,69 @@
+//
+// ODBC.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  ODBC
+//
+// Basic definitions for the Poco ODBC library.
+// This file must be the first file included by every other ODBC
+// header file.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_ODBC_INCLUDED
+#define Data_ODBC_ODBC_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+
+
+//
+// The following block is the standard way of creating macros which make exporting
+// from a DLL simpler. All files within this DLL are compiled with the ODBC_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any project
+// that uses this DLL. This way any other project whose source files include this file see
+// ODBC_API functions as being imported from a DLL, wheras this DLL sees symbols
+// defined with this macro as being exported.
+//
+#if defined(_WIN32) && defined(POCO_DLL)
+	#if defined(ODBC_EXPORTS)
+		#define ODBC_API __declspec(dllexport)
+	#else
+		#define ODBC_API __declspec(dllimport)
+	#endif
+#endif
+
+
+#if !defined(ODBC_API)
+	#if !defined(POCO_NO_GCC_API_ATTRIBUTE) && defined (__GNUC__) && (__GNUC__ >= 4)
+		#define ODBC_API __attribute__ ((visibility ("default")))
+	#else
+		#define ODBC_API
+	#endif
+#endif
+
+
+
+#include "Poco/Data/ODBC/Unicode.h"
+
+
+//
+// Automatically link Data library.
+//
+#if defined(_MSC_VER)
+	#if !defined(POCO_NO_AUTOMATIC_LIBS) && !defined(ODBC_EXPORTS)
+		#pragma comment(lib, "PocoDataODBC" POCO_LIB_SUFFIX)
+	#endif
+#endif
+
+
+#endif // ODBC_ODBC_INCLUDED
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBCException.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBCException.h
new file mode 100644
index 00000000000..63e5dab5fed
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBCException.h
@@ -0,0 +1,150 @@
+//
+// ODBCException.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  ODBCException
+//
+// Definition of ODBCException.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_ODBCException_INCLUDED
+#define Data_ODBC_ODBCException_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/Diagnostics.h"
+#include "Poco/Data/ODBC/Error.h"
+#include "Poco/Data/DataException.h"
+#include "Poco/Format.h"
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+POCO_DECLARE_EXCEPTION(ODBC_API, ODBCException, Poco::Data::DataException)
+POCO_DECLARE_EXCEPTION(ODBC_API, InsufficientStorageException, ODBCException)
+POCO_DECLARE_EXCEPTION(ODBC_API, UnknownDataLengthException, ODBCException)
+POCO_DECLARE_EXCEPTION(ODBC_API, DataTruncatedException, ODBCException)
+
+
+template <class H, SQLSMALLINT handleType>
+class HandleException: public ODBCException
+{
+public:
+	HandleException(const H& handle): _error(handle)
+		/// Creates HandleException
+	{
+		message(_error.toString());
+	}
+
+	HandleException(const H& handle, const std::string& msg): 
+		ODBCException(msg), 
+		_error(handle)
+		/// Creates HandleException
+	{
+		extendedMessage(_error.toString());
+	}							
+
+	HandleException(const H& handle, const std::string& msg, const std::string& arg): 
+		ODBCException(msg, arg), 
+		_error(handle)
+		/// Creates HandleException
+	{
+	}
+
+	HandleException(const H& handle, const std::string& msg, const Poco::Exception& exc): 
+		ODBCException(msg, exc),
+		_error(handle)
+		/// Creates HandleException
+	{
+	}
+
+	HandleException(const HandleException& exc): 
+		ODBCException(exc),
+		_error(exc._error)
+		/// Creates HandleException
+	{
+	}
+
+	~HandleException() throw()
+		/// Destroys HandleException
+	{
+	}
+
+	HandleException& operator = (const HandleException& exc)
+		/// Assignment operator
+	{
+		if (&exc != this) _error = exc._error;
+
+		return *this;
+	}
+
+	const char* name() const throw()
+		/// Returns the name of the exception
+	{
+		return "ODBC handle exception";
+	}
+
+	const char* className() const throw()
+		/// Returns the HandleException class name.
+	{
+		return typeid(*this).name();
+	}
+
+	Poco::Exception* clone() const
+		/// Clones the HandleException
+	{
+		return new HandleException(*this);
+	}
+
+	void rethrow() const
+		/// Re-throws the HandleException.
+	{
+		throw *this;
+	}
+
+	const Diagnostics<H, handleType>& diagnostics() const
+		/// Returns error diagnostics.
+	{
+		return _error.diagnostics();
+	}
+
+	std::string toString() const
+		/// Returns the formatted error diagnostics for the handle.
+	{
+		return Poco::format("ODBC Error: %s\n===================\n%s\n",
+			std::string(what()),
+			_error.toString());
+	}
+
+	static std::string errorString(const H& handle)
+		/// Returns the error diagnostics string for the handle.
+	{
+		return Error<H, handleType>(handle).toString();
+	}
+
+private:
+	Error<H, handleType> _error;
+};
+
+
+typedef HandleException<SQLHENV, SQL_HANDLE_ENV>   EnvironmentException;
+typedef HandleException<SQLHDBC, SQL_HANDLE_DBC>   ConnectionException;
+typedef HandleException<SQLHSTMT, SQL_HANDLE_STMT> StatementException;
+typedef HandleException<SQLHDESC, SQL_HANDLE_DESC> DescriptorException;
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBCMetaColumn.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBCMetaColumn.h
new file mode 100644
index 00000000000..cc9df6d36be
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBCMetaColumn.h
@@ -0,0 +1,92 @@
+//
+// ODBCMetaColumn.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  ODBCMetaColumn
+//
+// Definition of ODBCMetaColumn.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_ODBCColumn_INCLUDED
+#define Data_ODBC_ODBCColumn_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/Error.h"
+#include "Poco/Data/ODBC/Handle.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+#include "Poco/Data/MetaColumn.h"
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqlext.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API ODBCMetaColumn: public MetaColumn
+{
+public:
+	explicit ODBCMetaColumn(const StatementHandle& rStmt, std::size_t position);
+		/// Creates the ODBCMetaColumn.
+		
+	~ODBCMetaColumn();
+		/// Destroys the ODBCMetaColumn.
+
+	std::size_t dataLength() const;
+		/// A numeric value that is either the maximum or actual character length of a character 
+		/// string or binary data type. It is the maximum character length for a fixed-length data type, 
+		/// or the actual character length for a variable-length data type. Its value always excludes the 
+		/// null-termination byte that ends the character string. 
+		/// This information is returned from the SQL_DESC_LENGTH record field of the IRD.
+
+	bool isUnsigned() const;
+		/// Returns true if column is unsigned or a non-numeric data type.
+
+private:
+	ODBCMetaColumn();
+
+	static const int NAME_BUFFER_LENGTH = 2048;
+
+	struct ColumnDescription
+	{
+		SQLCHAR name[NAME_BUFFER_LENGTH];
+		SQLSMALLINT  nameBufferLength;
+		SQLSMALLINT  dataType;
+		SQLULEN      size;
+		SQLSMALLINT  decimalDigits;
+		SQLSMALLINT  isNullable;
+	};
+
+	void init();
+	void getDescription();
+
+	SQLLEN                 _dataLength;
+	const StatementHandle& _rStmt;
+	ColumnDescription      _columnDesc;
+};
+
+
+///
+/// inlines
+///
+inline std::size_t ODBCMetaColumn::dataLength() const
+{
+	return _dataLength;
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBCStatementImpl.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBCStatementImpl.h
new file mode 100644
index 00000000000..c4f8b3f956f
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/ODBCStatementImpl.h
@@ -0,0 +1,206 @@
+//
+// ODBCStatementImpl.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  ODBCStatementImpl
+//
+// Definition of the ODBCStatementImpl class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_ODBCStatementImpl_INCLUDED
+#define Data_ODBC_ODBCStatementImpl_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/SessionImpl.h"
+#include "Poco/Data/ODBC/Binder.h"
+#include "Poco/Data/ODBC/Extractor.h"
+#include "Poco/Data/ODBC/Preparator.h"
+#include "Poco/Data/ODBC/ODBCMetaColumn.h"
+#include "Poco/Data/StatementImpl.h"
+#include "Poco/Data/Column.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Format.h"
+#include <sstream>
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqltypes.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API ODBCStatementImpl: public Poco::Data::StatementImpl
+	/// Implements statement functionality needed for ODBC
+{
+public:
+	ODBCStatementImpl(SessionImpl& rSession);
+		/// Creates the ODBCStatementImpl.
+
+	~ODBCStatementImpl();
+		/// Destroys the ODBCStatementImpl.
+
+protected:
+	std::size_t columnsReturned() const;
+		/// Returns number of columns returned by query.
+
+	int affectedRowCount() const;
+		/// Returns the number of affected rows.
+		/// Used to find out the number of rows affected by insert or update.
+
+	const MetaColumn& metaColumn(std::size_t pos) const;
+		/// Returns column meta data.
+
+	bool hasNext();
+		/// Returns true if a call to next() will return data.
+
+	std::size_t next();
+		/// Retrieves the next row or set of rows from the resultset.
+		/// Returns the number of rows retrieved.
+		/// Will throw, if the resultset is empty.
+
+	bool canBind() const;
+		/// Returns true if a valid statement is set and we can bind.
+
+	bool canCompile() const;
+		/// Returns true if another compile is possible.
+
+	void compileImpl();
+		/// Compiles the statement, doesn't bind yet. 
+		/// Does nothing if the statement has already been compiled.
+
+	void bindImpl();
+		/// Binds all parameters and executes the statement.
+
+	AbstractExtraction::ExtractorPtr extractor();
+		/// Returns the concrete extractor used by the statement.
+
+	AbstractBinding::BinderPtr binder();
+		/// Returns the concrete binder used by the statement.
+
+	std::string nativeSQL();
+		/// Returns the SQL string as modified by the driver.
+
+private:
+	typedef Poco::Data::AbstractBindingVec    Bindings;
+	typedef Poco::SharedPtr<Binder>           BinderPtr;
+	typedef Poco::Data::AbstractExtractionVec Extractions;
+	typedef Poco::SharedPtr<Preparator>       PreparatorPtr;
+	typedef std::vector<PreparatorPtr>        PreparatorVec;
+	typedef Poco::SharedPtr<Extractor>        ExtractorPtr;
+	typedef std::vector<ExtractorPtr>         ExtractorVec;
+	typedef std::vector<ODBCMetaColumn*>      ColumnPtrVec;
+	typedef std::vector<ColumnPtrVec>         ColumnPtrVecVec;
+	
+	static const std::string INVALID_CURSOR_STATE;
+
+	void clear();
+		/// Closes the cursor and resets indicator variables.
+	
+	void doBind();
+		/// Binds parameters.
+
+	void makeInternalExtractors();
+		/// Creates internal extractors if none were supplied from the user.
+
+	bool isStoredProcedure() const;
+		/// Returns true if SQL is a stored procedure call.
+
+	void doPrepare();
+		/// Prepares placeholders for data returned by statement.
+		/// It is called during statement compilation for SQL statements
+		/// returning data. For stored procedures returning datasets, 
+		/// it is called upon the first check for data availability 
+		/// (see hasNext() function).
+
+	bool hasData() const;
+		/// Returns true if statement returns data.
+
+	void makeStep();
+		/// Fetches the next row of data.
+
+	bool nextRowReady() const;
+		/// Returns true if there is a row fetched but not yet extracted.
+
+	void putData();
+		/// Called whenever SQLExecute returns SQL_NEED_DATA. This is expected 
+		/// behavior for PB_AT_EXEC binding mode. 
+
+	void getData();
+
+	void addPreparator();
+	void fillColumns();
+	void checkError(SQLRETURN rc, const std::string& msg="");
+
+	const SQLHDBC&        _rConnection;
+	const StatementHandle _stmt;
+	PreparatorVec         _preparations;
+	BinderPtr             _pBinder;
+	ExtractorVec          _extractors;
+	bool                  _stepCalled;
+	int                   _nextResponse;
+	ColumnPtrVecVec       _columnPtrs;
+	bool                  _prepared;
+	mutable std::size_t   _affectedRowCount;
+	bool                  _canCompile;
+};
+
+
+//
+// inlines
+//
+inline AbstractExtraction::ExtractorPtr ODBCStatementImpl::extractor()
+{
+	poco_assert_dbg (currentDataSet() < _extractors.size());
+	poco_assert_dbg (_extractors[currentDataSet()]);
+	return _extractors[currentDataSet()];
+}
+
+
+inline AbstractBinding::BinderPtr ODBCStatementImpl::binder()
+{
+	poco_assert_dbg (!_pBinder.isNull());
+	return _pBinder;
+}
+
+
+inline std::size_t ODBCStatementImpl::columnsReturned() const
+{
+	poco_assert_dbg (currentDataSet() < _preparations.size());
+	poco_assert_dbg (_preparations[currentDataSet()]);
+	return static_cast<std::size_t>(_preparations[currentDataSet()]->columns());
+}
+
+
+inline bool ODBCStatementImpl::hasData() const
+{
+	return (columnsReturned() > 0);
+}
+
+
+inline bool ODBCStatementImpl::nextRowReady() const
+{
+	return (!Utility::isError(_nextResponse));
+}
+
+
+inline bool ODBCStatementImpl::canCompile() const
+{
+	return _canCompile;
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif // Data_ODBC_ODBCStatementImpl_INCLUDED
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/Parameter.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Parameter.h
new file mode 100644
index 00000000000..e9f11bdb51f
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Parameter.h
@@ -0,0 +1,111 @@
+//
+// Parameter.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Parameter
+//
+// Definition of Parameter.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Parameter_INCLUDED
+#define Data_ODBC_Parameter_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/Handle.h"
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqlext.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API Parameter
+{
+public:
+	explicit Parameter(const StatementHandle& rStmt, std::size_t colNum);
+		/// Creates the Parameter.
+		
+	~Parameter();
+		/// Destroys the Parameter.
+
+	std::size_t number() const;
+		/// Returns the column number.
+
+	std::size_t dataType() const;
+		/// Returns the SQL data type.
+
+	std::size_t columnSize() const;
+		/// Returns the the size of the column or expression of the corresponding 
+		/// parameter marker as defined by the data source.
+
+	std::size_t decimalDigits() const;
+		/// Returns the number of decimal digits of the column or expression 
+		/// of the corresponding parameter as defined by the data source.
+
+	bool isNullable() const;
+		/// Returns true if column allows null values, false otherwise.
+
+private:
+	Parameter();
+
+	void init();
+
+	SQLSMALLINT _dataType;
+    SQLULEN     _columnSize;
+    SQLSMALLINT _decimalDigits;
+    SQLSMALLINT _isNullable;
+
+	const StatementHandle& _rStmt;
+	std::size_t _number;
+};
+
+
+///
+/// inlines
+///
+inline std::size_t Parameter::number() const
+{
+	return _number;
+}
+
+
+inline std::size_t Parameter::dataType() const
+{
+	return _dataType;
+}
+
+
+inline std::size_t Parameter::columnSize() const
+{
+	return _columnSize;
+}
+
+
+inline std::size_t Parameter::decimalDigits() const
+{
+	return _decimalDigits;
+}
+
+
+inline bool Parameter::isNullable() const
+{
+	return SQL_NULLABLE == _isNullable;
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/Preparator.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Preparator.h
new file mode 100644
index 00000000000..aa38ea28ce9
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Preparator.h
@@ -0,0 +1,1271 @@
+//
+// Preparator.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Preparator
+//
+// Definition of the Preparator class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Preparator_INCLUDED
+#define Data_ODBC_Preparator_INCLUDED
+
+
+#include "Poco/Data/Constants.h"
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/Handle.h"
+#include "Poco/Data/ODBC/ODBCMetaColumn.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/AbstractPreparator.h"
+#include "Poco/Data/LOB.h"
+#include "Poco/Any.h"
+#include "Poco/DynamicAny.h"
+#include "Poco/DateTime.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/UTFString.h"
+#include <vector>
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqlext.h>
+
+
+namespace Poco {
+namespace Data {
+
+
+class Date;
+class Time;
+
+
+namespace ODBC {
+
+
+class ODBC_API Preparator : public AbstractPreparator
+	/// Class used for database preparation where we first have to register all data types 
+	/// with respective memory output locations before extracting data. 
+	/// Extraction works in two-phases: first prepare is called once, then extract n-times.
+	/// In ODBC, SQLBindCol/SQLFetch is the preferred method of data retrieval (SQLGetData is available, 
+	/// however with numerous driver implementation dependent limitations and inferior performance). 
+	/// In order to fit this functionality into Poco DataConnectors framework, every ODBC SQL statement 
+	/// instantiates its own Preparator object. 
+	/// This is done once per statement execution (from StatementImpl::bindImpl()).
+	///
+	/// Preparator object is used to :
+	///
+	///   1) Prepare SQL statement.
+	///   2) Provide and contain the memory locations where retrieved values are placed during recordset iteration.
+	///   3) Keep count of returned number of columns with their respective datatypes and sizes.
+	///
+	/// Notes:
+	///
+	/// - Value datatypes in this interface prepare() calls serve only for the purpose of type distinction.
+	/// - Preparator keeps its own std::vector<Any> buffer for fetched data to be later retrieved by Extractor.
+	/// - prepare() methods should not be called when extraction mode is DE_MANUAL
+	/// 
+{
+public:
+	typedef std::vector<char*> CharArray;
+	typedef SharedPtr<Preparator> Ptr;
+
+	enum DataExtraction
+	{
+		DE_MANUAL,
+		DE_BOUND
+	};
+
+	enum DataType
+	{
+		DT_BOOL,
+		DT_BOOL_ARRAY,
+		DT_CHAR,
+		DT_WCHAR,
+		DT_UCHAR,
+		DT_CHAR_ARRAY,
+		DT_WCHAR_ARRAY,
+		DT_UCHAR_ARRAY,
+		DT_DATE,
+		DT_TIME,
+		DT_DATETIME
+	};
+
+	Preparator(const StatementHandle& rStmt, 
+		const std::string& statement, 
+		std::size_t maxFieldSize,
+		DataExtraction dataExtraction = DE_BOUND);
+		/// Creates the Preparator.
+
+	Preparator(const Preparator& other);
+		/// Copy constructs the Preparator.
+
+	~Preparator();
+		/// Destroys the Preparator.
+
+	void prepare(std::size_t pos, const Poco::Int8& val);
+		/// Prepares an Int8.
+
+	void prepare(std::size_t pos, const std::vector<Poco::Int8>& val);
+		/// Prepares an Int8 vector.
+
+	void prepare(std::size_t pos, const std::deque<Poco::Int8>& val);
+		/// Prepares an Int8 deque.
+
+	void prepare(std::size_t pos, const std::list<Poco::Int8>& val);
+		/// Prepares an Int8 list.
+
+	void prepare(std::size_t pos, const Poco::UInt8& val);
+		/// Prepares an UInt8.
+
+	void prepare(std::size_t pos, const std::vector<Poco::UInt8>& val);
+		/// Prepares an UInt8 vector.
+
+	void prepare(std::size_t pos, const std::deque<Poco::UInt8>& val);
+		/// Prepares an UInt8 deque.
+
+	void prepare(std::size_t pos, const std::list<Poco::UInt8>& val);
+		/// Prepares an UInt8 list.
+
+	void prepare(std::size_t pos, const Poco::Int16& val);
+		/// Prepares an Int16.
+
+	void prepare(std::size_t pos, const std::vector<Poco::Int16>& val);
+		/// Prepares an Int16 vector.
+
+	void prepare(std::size_t pos, const std::deque<Poco::Int16>& val);
+		/// Prepares an Int16 deque.
+
+	void prepare(std::size_t pos, const std::list<Poco::Int16>& val);
+		/// Prepares an Int16 list.
+
+	void prepare(std::size_t pos, const Poco::UInt16& val);
+		/// Prepares an UInt16.
+
+	void prepare(std::size_t pos, const std::vector<Poco::UInt16>& val);
+		/// Prepares an UInt16 vector.
+
+	void prepare(std::size_t pos, const std::deque<Poco::UInt16>& val);
+		/// Prepares an UInt16 deque.
+
+	void prepare(std::size_t pos, const std::list<Poco::UInt16>& val);
+		/// Prepares an UInt16 list.
+
+	void prepare(std::size_t pos, const Poco::Int32& val);
+		/// Prepares an Int32.
+
+	void prepare(std::size_t pos, const std::vector<Poco::Int32>& val);
+		/// Prepares an Int32 vector.
+
+	void prepare(std::size_t pos, const std::deque<Poco::Int32>& val);
+		/// Prepares an Int32 deque.
+
+	void prepare(std::size_t pos, const std::list<Poco::Int32>& val);
+		/// Prepares an Int32 list.
+
+	void prepare(std::size_t pos, const Poco::UInt32& val);
+		/// Prepares an UInt32.
+
+	void prepare(std::size_t pos, const std::vector<Poco::UInt32>& val);
+		/// Prepares an UInt32 vector.
+
+	void prepare(std::size_t pos, const std::deque<Poco::UInt32>& val);
+		/// Prepares an UInt32 deque.
+
+	void prepare(std::size_t pos, const std::list<Poco::UInt32>& val);
+		/// Prepares an UInt32 list.
+
+	void prepare(std::size_t pos, const Poco::Int64& val);
+		/// Prepares an Int64.
+
+	void prepare(std::size_t pos, const std::vector<Poco::Int64>& val);
+		/// Prepares an Int64 vector.
+
+	void prepare(std::size_t pos, const std::deque<Poco::Int64>& val);
+		/// Prepares an Int64 deque.
+
+	void prepare(std::size_t pos, const std::list<Poco::Int64>& val);
+		/// Prepares an Int64 list.
+
+	void prepare(std::size_t pos, const Poco::UInt64& val);
+		/// Prepares an UInt64.
+
+	void prepare(std::size_t pos, const std::vector<Poco::UInt64>& val);
+		/// Prepares an UInt64 vector.
+
+	void prepare(std::size_t pos, const std::deque<Poco::UInt64>& val);
+		/// Prepares an UInt64 deque.
+
+	void prepare(std::size_t pos, const std::list<Poco::UInt64>& val);
+		/// Prepares an UInt64 list.
+
+#ifndef POCO_LONG_IS_64_BIT
+	void prepare(std::size_t pos, const long& val);
+		/// Prepares a long.
+
+	void prepare(std::size_t pos, const unsigned long& val);
+		/// Prepares an unsigned long.
+
+	void prepare(std::size_t pos, const std::vector<long>& val);
+		/// Prepares a long vector.
+
+	void prepare(std::size_t pos, const std::deque<long>& val);
+		/// Prepares a long deque.
+
+	void prepare(std::size_t pos, const std::list<long>& val);
+		/// Prepares a long list.
+#endif
+
+	void prepare(std::size_t pos, const bool& val);
+		/// Prepares a boolean.
+
+	void prepare(std::size_t pos, const std::vector<bool>& val);
+		/// Prepares a boolean vector.
+
+	void prepare(std::size_t pos, const std::deque<bool>& val);
+		/// Prepares a boolean deque.
+
+	void prepare(std::size_t pos, const std::list<bool>& val);
+		/// Prepares a boolean list.
+
+	void prepare(std::size_t pos, const float& val);
+		/// Prepares a float.
+
+	void prepare(std::size_t pos, const std::vector<float>& val);
+		/// Prepares a float vector.
+
+	void prepare(std::size_t pos, const std::deque<float>& val);
+		/// Prepares a float deque.
+
+	void prepare(std::size_t pos, const std::list<float>& val);
+		/// Prepares a float list.
+
+	void prepare(std::size_t pos, const double& val);
+		/// Prepares a double.
+
+	void prepare(std::size_t pos, const std::vector<double>& val);
+		/// Prepares a double vector.
+
+	void prepare(std::size_t pos, const std::deque<double>& val);
+		/// Prepares a double deque.
+
+	void prepare(std::size_t pos, const std::list<double>& val);
+		/// Prepares a double list.
+
+	void prepare(std::size_t pos, const char& val);
+		/// Prepares a single character.
+
+	void prepare(std::size_t pos, const std::vector<char>& val);
+		/// Prepares a single character vector.
+
+	void prepare(std::size_t pos, const std::deque<char>& val);
+		/// Prepares a single character deque.
+
+	void prepare(std::size_t pos, const std::list<char>& val);
+		/// Prepares a single character list.
+
+	void prepare(std::size_t pos, const std::string& val);
+		/// Prepares a string.
+
+	void prepare(std::size_t pos, const std::vector<std::string>& val);
+		/// Prepares a string vector.
+
+	void prepare(std::size_t pos, const std::deque<std::string>& val);
+		/// Prepares a string deque.
+
+	void prepare(std::size_t pos, const std::list<std::string>& val);
+		/// Prepares a string list.
+
+	void prepare(std::size_t pos, const UTF16String& val);
+	/// Prepares a string.
+
+	void prepare(std::size_t pos, const std::vector<UTF16String>& val);
+	/// Prepares a string vector.
+
+	void prepare(std::size_t pos, const std::deque<UTF16String>& val);
+	/// Prepares a string deque.
+
+	void prepare(std::size_t pos, const std::list<UTF16String>& val);
+	/// Prepares a string list.
+
+	void prepare(std::size_t pos, const Poco::Data::BLOB& val);
+		/// Prepares a BLOB.
+
+	void prepare(std::size_t pos, const std::vector<Poco::Data::BLOB>& val);
+		/// Prepares a BLOB vector.
+
+	void prepare(std::size_t pos, const std::deque<Poco::Data::BLOB>& val);
+		/// Prepares a BLOB deque.
+
+	void prepare(std::size_t pos, const std::list<Poco::Data::BLOB>& val);
+		/// Prepares a BLOB list.
+
+	void prepare(std::size_t pos, const Poco::Data::CLOB& val);
+		/// Prepares a CLOB.
+
+	void prepare(std::size_t pos, const std::vector<Poco::Data::CLOB>& val);
+		/// Prepares a CLOB vector.
+
+	void prepare(std::size_t pos, const std::deque<Poco::Data::CLOB>& val);
+		/// Prepares a CLOB deque.
+
+	void prepare(std::size_t pos, const std::list<Poco::Data::CLOB>& val);
+		/// Prepares a CLOB list.
+
+	void prepare(std::size_t pos, const Poco::Data::Date& val);
+		/// Prepares a Date.
+
+	void prepare(std::size_t pos, const std::vector<Poco::Data::Date>& val);
+		/// Prepares a Date vector.
+
+	void prepare(std::size_t pos, const std::deque<Poco::Data::Date>& val);
+		/// Prepares a Date deque.
+
+	void prepare(std::size_t pos, const std::list<Poco::Data::Date>& val);
+		/// Prepares a Date list.
+
+	void prepare(std::size_t pos, const Poco::Data::Time& val);
+		/// Prepares a Time.
+
+	void prepare(std::size_t pos, const std::vector<Poco::Data::Time>& val);
+		/// Prepares a Time vector.
+
+	void prepare(std::size_t pos, const std::deque<Poco::Data::Time>& val);
+		/// Prepares a Time deque.
+
+	void prepare(std::size_t pos, const std::list<Poco::Data::Time>& val);
+		/// Prepares a Time list.
+
+	void prepare(std::size_t pos, const Poco::DateTime& val);
+		/// Prepares a DateTime.
+
+	void prepare(std::size_t pos, const std::vector<Poco::DateTime>& val);
+		/// Prepares a DateTime vector.
+
+	void prepare(std::size_t pos, const std::deque<Poco::DateTime>& val);
+		/// Prepares a DateTime deque.
+
+	void prepare(std::size_t pos, const std::list<Poco::DateTime>& val);
+		/// Prepares a DateTime list.
+
+	void prepare(std::size_t pos, const Poco::Any& val);
+		/// Prepares an Any.
+
+	void prepare(std::size_t pos, const std::vector<Poco::Any>& val);
+		/// Prepares an Any vector.
+
+	void prepare(std::size_t pos, const std::deque<Poco::Any>& val);
+		/// Prepares an Any deque.
+
+	void prepare(std::size_t pos, const std::list<Poco::Any>& val);
+		/// Prepares an Any list.
+
+	void prepare(std::size_t pos, const Poco::DynamicAny& val);
+		/// Prepares a DynamicAny.
+
+	void prepare(std::size_t pos, const std::vector<Poco::DynamicAny>& val);
+		/// Prepares a DynamicAny vector.
+
+	void prepare(std::size_t pos, const std::deque<Poco::DynamicAny>& val);
+		/// Prepares a DynamicAny deque.
+
+	void prepare(std::size_t pos, const std::list<Poco::DynamicAny>& val);
+		/// Prepares a DynamicAny list.
+
+	std::size_t columns() const;
+		/// Returns the number of columns.
+		/// Resizes the internal storage iff the size is zero.
+
+	Poco::Any& operator [] (std::size_t pos);
+		/// Returns reference to column data.
+
+	Poco::Any& at(std::size_t pos);
+		/// Returns reference to column data.
+
+	void setMaxFieldSize(std::size_t size);
+		/// Sets maximum supported field size.
+
+	std::size_t getMaxFieldSize() const;
+		// Returns maximum supported field size.
+
+	std::size_t maxDataSize(std::size_t pos) const;
+		/// Returns max supported size for column at position pos.
+		/// Returned length for variable length fields is the one 
+		/// supported by this implementation, not the underlying DB.
+
+	std::size_t actualDataSize(std::size_t col, std::size_t row = POCO_DATA_INVALID_ROW) const;
+		/// Returns the returned length for the column and row specified. 
+		/// This is usually equal to the column size, except for 
+		/// variable length fields (BLOB and variable length strings).
+		/// For null values, the return value is -1 (SQL_NO_DATA)
+
+	std::size_t bulkSize(std::size_t col = 0) const;
+		/// Returns bulk size. Column argument is optional
+		/// since all columns must be the same size.
+
+	void setDataExtraction(DataExtraction ext);
+		/// Set data extraction mode.
+
+	DataExtraction getDataExtraction() const;
+		/// Returns data extraction mode.
+
+private:
+	typedef std::vector<Poco::Any> ValueVec;
+	typedef std::vector<SQLLEN>    LengthVec;
+	typedef std::vector<LengthVec> LengthLengthVec;
+	typedef std::map<std::size_t, DataType> IndexMap;
+
+	Preparator();
+	Preparator& operator = (const Preparator&);
+
+	template <typename C>
+	void prepareImpl(std::size_t pos, const C* pVal = 0)
+		/// Utility function to prepare Any and DynamicAny.
+	{
+		ODBCMetaColumn col(_rStmt, pos);
+
+		switch (col.type())
+		{
+			case MetaColumn::FDT_INT8:
+				if (pVal)
+					return prepareFixedSize<Poco::Int8>(pos, SQL_C_STINYINT, pVal->size());
+				else
+					return prepareFixedSize<Poco::Int8>(pos, SQL_C_STINYINT); 
+
+			case MetaColumn::FDT_UINT8:
+				if (pVal)
+					return prepareFixedSize<Poco::UInt8>(pos, SQL_C_UTINYINT, pVal->size());
+				else
+					return prepareFixedSize<Poco::UInt8>(pos, SQL_C_UTINYINT);
+
+			case MetaColumn::FDT_INT16:
+				if (pVal)
+					return prepareFixedSize<Poco::Int16>(pos, SQL_C_SSHORT, pVal->size());
+				else
+					return prepareFixedSize<Poco::Int16>(pos, SQL_C_SSHORT);
+
+			case MetaColumn::FDT_UINT16:
+				if (pVal)
+					return prepareFixedSize<Poco::UInt16>(pos, SQL_C_USHORT, pVal->size());
+				else
+					return prepareFixedSize<Poco::UInt16>(pos, SQL_C_USHORT);
+
+			case MetaColumn::FDT_INT32:
+				if (pVal)
+					return prepareFixedSize<Poco::Int32>(pos, SQL_C_SLONG, pVal->size());
+				else
+					return prepareFixedSize<Poco::Int32>(pos, SQL_C_SLONG);
+
+			case MetaColumn::FDT_UINT32:
+				if (pVal)
+					return prepareFixedSize<Poco::UInt32>(pos, SQL_C_ULONG, pVal->size());
+				else
+					return prepareFixedSize<Poco::UInt32>(pos, SQL_C_ULONG);
+
+			case MetaColumn::FDT_INT64:
+				if (pVal)
+					return prepareFixedSize<Poco::Int64>(pos, SQL_C_SBIGINT, pVal->size());
+				else
+					return prepareFixedSize<Poco::Int64>(pos, SQL_C_SBIGINT);
+
+			case MetaColumn::FDT_UINT64:
+				if (pVal)
+					return prepareFixedSize<Poco::UInt64>(pos, SQL_C_UBIGINT, pVal->size());
+				else
+					return prepareFixedSize<Poco::UInt64>(pos, SQL_C_UBIGINT);
+
+			case MetaColumn::FDT_BOOL:
+				if (pVal)
+					return prepareBoolArray(pos, SQL_C_BIT, pVal->size());
+				else
+					return prepareFixedSize<bool>(pos, SQL_C_BIT);
+
+			case MetaColumn::FDT_FLOAT:
+				if (pVal)
+					return prepareFixedSize<float>(pos, SQL_C_FLOAT, pVal->size());
+				else
+					return prepareFixedSize<float>(pos, SQL_C_FLOAT);
+
+			case MetaColumn::FDT_DOUBLE:
+				if (pVal)
+					return prepareFixedSize<double>(pos, SQL_C_DOUBLE, pVal->size());
+				else
+					return prepareFixedSize<double>(pos, SQL_C_DOUBLE);
+
+			case MetaColumn::FDT_STRING:
+				if (pVal)
+					return prepareCharArray<char, DT_CHAR_ARRAY>(pos, SQL_C_CHAR, maxDataSize(pos), pVal->size());
+				else
+					return prepareVariableLen<char>(pos, SQL_C_CHAR, maxDataSize(pos), DT_CHAR);
+
+			case MetaColumn::FDT_WSTRING:
+			{
+				typedef UTF16String::value_type CharType;
+				if (pVal)
+					return prepareCharArray<CharType, DT_WCHAR_ARRAY>(pos, SQL_C_WCHAR, maxDataSize(pos), pVal->size());
+				else
+					return prepareVariableLen<CharType>(pos, SQL_C_WCHAR, maxDataSize(pos), DT_WCHAR);
+			}
+
+			case MetaColumn::FDT_BLOB:
+			{
+				typedef Poco::Data::BLOB::ValueType CharType;
+				if (pVal)
+					return prepareCharArray<CharType, DT_UCHAR_ARRAY>(pos, SQL_C_BINARY, maxDataSize(pos), pVal->size());
+				else
+					return prepareVariableLen<CharType>(pos, SQL_C_BINARY, maxDataSize(pos), DT_UCHAR);
+			}
+
+			case MetaColumn::FDT_CLOB:
+			{
+				typedef Poco::Data::CLOB::ValueType CharType;
+				if (pVal)
+					return prepareCharArray<CharType, DT_CHAR_ARRAY>(pos, SQL_C_BINARY, maxDataSize(pos), pVal->size());
+				else
+					return prepareVariableLen<CharType>(pos, SQL_C_BINARY, maxDataSize(pos), DT_CHAR);
+			}
+
+			case MetaColumn::FDT_DATE:
+				if (pVal)
+					return prepareFixedSize<Date>(pos, SQL_C_TYPE_DATE, pVal->size());
+				else
+					return prepareFixedSize<Date>(pos, SQL_C_TYPE_DATE);
+
+			case MetaColumn::FDT_TIME:
+				if (pVal)
+					return prepareFixedSize<Time>(pos, SQL_C_TYPE_TIME, pVal->size());
+				else
+					return prepareFixedSize<Time>(pos, SQL_C_TYPE_TIME);
+
+			case MetaColumn::FDT_TIMESTAMP:
+				if (pVal)
+					return prepareFixedSize<DateTime>(pos, SQL_C_TYPE_TIMESTAMP, pVal->size());
+				else
+					return prepareFixedSize<DateTime>(pos, SQL_C_TYPE_TIMESTAMP);
+
+			default: 
+				throw DataFormatException("Unsupported data type.");
+		}
+	}
+
+	void resize() const;
+		/// Resize the values and lengths vectors.
+
+	template <typename T>
+	void prepareFixedSize(std::size_t pos, SQLSMALLINT valueType)
+		/// Utility function for preparation of fixed length columns.
+	{
+		poco_assert (DE_BOUND == _dataExtraction);
+		std::size_t dataSize = sizeof(T);
+
+		poco_assert (pos < _values.size());
+		_values[pos] = Poco::Any(T());
+
+		T* pVal = AnyCast<T>(&_values[pos]);
+		if (Utility::isError(SQLBindCol(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			valueType, 
+			(SQLPOINTER) pVal,  
+			(SQLINTEGER) dataSize, 
+			&_lengths[pos])))
+		{
+			throw StatementException(_rStmt, "SQLBindCol()");
+		}
+	}
+
+	template <typename T>
+	void prepareFixedSize(std::size_t pos, SQLSMALLINT valueType, std::size_t length)
+		/// Utility function for preparation of fixed length columns that are
+		/// bound to a std::vector.
+	{
+		poco_assert (DE_BOUND == _dataExtraction);
+		std::size_t dataSize = sizeof(T);
+
+		poco_assert (pos < _values.size());
+		poco_assert (length);
+		_values[pos] = Poco::Any(std::vector<T>());
+		_lengths[pos] = 0;
+		poco_assert (0 == _lenLengths[pos].size());
+		_lenLengths[pos].resize(length);
+
+		std::vector<T>& cache = RefAnyCast<std::vector<T> >(_values[pos]);
+		cache.resize(length);
+
+		if (Utility::isError(SQLBindCol(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			valueType, 
+			(SQLPOINTER) &cache[0], 
+			(SQLINTEGER) dataSize, 
+			&_lenLengths[pos][0])))
+		{
+			throw StatementException(_rStmt, "SQLBindCol()");
+		}
+	}
+
+	template <typename T>
+	void prepareVariableLen(std::size_t pos, SQLSMALLINT valueType, std::size_t size, DataType dt)
+		/// Utility function for preparation of variable length columns.
+	{
+		poco_assert (DE_BOUND == _dataExtraction);
+		poco_assert (pos < _values.size());
+
+		T* pCache = new T[size]; 
+		std::memset(pCache, 0, size);
+
+		_values[pos] = Any(pCache);
+		_lengths[pos] = (SQLLEN) size;
+		_varLengthArrays.insert(IndexMap::value_type(pos, dt));
+
+		if (Utility::isError(SQLBindCol(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			valueType, 
+			(SQLPOINTER) pCache, 
+			(SQLINTEGER) size*sizeof(T), 
+			&_lengths[pos])))
+		{
+			throw StatementException(_rStmt, "SQLBindCol()");
+		}
+	}
+
+	template <typename T, DataType DT>
+	void prepareCharArray(std::size_t pos, SQLSMALLINT valueType, std::size_t size, std::size_t length)
+		/// Utility function for preparation of bulk variable length character and LOB columns.
+	{
+		poco_assert_dbg (DE_BOUND == _dataExtraction);
+		poco_assert_dbg (pos < _values.size());
+		poco_assert_dbg (pos < _lengths.size());
+		poco_assert_dbg (pos < _lenLengths.size());
+
+		T* pArray = (T*) std::calloc(length * size, sizeof(T));
+
+		_values[pos] = Any(pArray);
+		_lengths[pos] = 0;
+		_lenLengths[pos].resize(length);
+		_varLengthArrays.insert(IndexMap::value_type(pos, DT));
+
+		if (Utility::isError(SQLBindCol(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			valueType, 
+			(SQLPOINTER) pArray, 
+			(SQLINTEGER) size, 
+			&_lenLengths[pos][0])))
+		{
+			throw StatementException(_rStmt, "SQLBindCol()");
+		}
+	}
+
+	void prepareBoolArray(std::size_t pos, SQLSMALLINT valueType, std::size_t length);
+		/// Utility function for preparation of bulk bool columns.
+
+	void freeMemory() const;
+		/// Utility function. Releases memory allocated for variable length columns.
+
+	template <typename T>
+	void deleteCachedArray(std::size_t pos) const
+	{
+		T** p = Poco::AnyCast<T*>(&_values[pos]);
+		if (p) delete [] *p;
+	}
+
+	const StatementHandle&  _rStmt;
+	mutable ValueVec        _values;
+	mutable LengthVec       _lengths;
+	mutable LengthLengthVec _lenLengths;
+	mutable IndexMap        _varLengthArrays;
+	std::size_t             _maxFieldSize;
+	DataExtraction          _dataExtraction;
+};
+
+
+//
+// inlines
+//
+inline void Preparator::prepare(std::size_t pos, const Poco::Int8&)
+{
+	prepareFixedSize<Poco::Int8>(pos, SQL_C_STINYINT);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::Int8>& val)
+{
+	prepareFixedSize<Poco::Int8>(pos, SQL_C_STINYINT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::Int8>& val)
+{
+	prepareFixedSize<Poco::Int8>(pos, SQL_C_STINYINT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<Poco::Int8>& val)
+{
+	prepareFixedSize<Poco::Int8>(pos, SQL_C_STINYINT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const Poco::UInt8&)
+{
+	prepareFixedSize<Poco::UInt8>(pos, SQL_C_UTINYINT);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::UInt8>& val)
+{
+	prepareFixedSize<Poco::UInt8>(pos, SQL_C_UTINYINT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::UInt8>& val)
+{
+	prepareFixedSize<Poco::UInt8>(pos, SQL_C_UTINYINT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<Poco::UInt8>& val)
+{
+	prepareFixedSize<Poco::UInt8>(pos, SQL_C_UTINYINT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const Poco::Int16&)
+{
+	prepareFixedSize<Poco::Int16>(pos, SQL_C_SSHORT);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::Int16>& val)
+{
+	prepareFixedSize<Poco::Int16>(pos, SQL_C_SSHORT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::Int16>& val)
+{
+	prepareFixedSize<Poco::Int16>(pos, SQL_C_SSHORT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<Poco::Int16>& val)
+{
+	prepareFixedSize<Poco::Int16>(pos, SQL_C_SSHORT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const Poco::UInt16&)
+{
+	prepareFixedSize<Poco::UInt16>(pos, SQL_C_USHORT);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::UInt16>& val)
+{
+	prepareFixedSize<Poco::UInt16>(pos, SQL_C_USHORT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::UInt16>& val)
+{
+	prepareFixedSize<Poco::UInt16>(pos, SQL_C_USHORT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<Poco::UInt16>& val)
+{
+	prepareFixedSize<Poco::UInt16>(pos, SQL_C_USHORT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const Poco::Int32&)
+{
+	prepareFixedSize<Poco::Int32>(pos, SQL_C_SLONG);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::Int32>& val)
+{
+	prepareFixedSize<Poco::Int32>(pos, SQL_C_SLONG, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::Int32>& val)
+{
+	prepareFixedSize<Poco::Int32>(pos, SQL_C_SLONG, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<Poco::Int32>& val)
+{
+	prepareFixedSize<Poco::Int32>(pos, SQL_C_SLONG, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const Poco::UInt32&)
+{
+	prepareFixedSize<Poco::UInt32>(pos, SQL_C_ULONG);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::UInt32>& val)
+{
+	prepareFixedSize<Poco::UInt32>(pos, SQL_C_ULONG, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::UInt32>& val)
+{
+	prepareFixedSize<Poco::UInt32>(pos, SQL_C_ULONG, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<Poco::UInt32>& val)
+{
+	prepareFixedSize<Poco::UInt32>(pos, SQL_C_ULONG, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const Poco::Int64&)
+{
+	prepareFixedSize<Poco::Int64>(pos, SQL_C_SBIGINT);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::Int64>& val)
+{
+	prepareFixedSize<Poco::Int64>(pos, SQL_C_SBIGINT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::Int64>& val)
+{
+	prepareFixedSize<Poco::Int64>(pos, SQL_C_SBIGINT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<Poco::Int64>& val)
+{
+	prepareFixedSize<Poco::Int64>(pos, SQL_C_SBIGINT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const Poco::UInt64&)
+{
+	prepareFixedSize<Poco::UInt64>(pos, SQL_C_UBIGINT);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::UInt64>& val)
+{
+	prepareFixedSize<Poco::UInt64>(pos, SQL_C_UBIGINT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::UInt64>& val)
+{
+	prepareFixedSize<Poco::UInt64>(pos, SQL_C_UBIGINT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<Poco::UInt64>& val)
+{
+	prepareFixedSize<Poco::UInt64>(pos, SQL_C_UBIGINT, val.size());
+}
+
+
+#ifndef POCO_LONG_IS_64_BIT
+inline void Preparator::prepare(std::size_t pos, const long&)
+{
+	prepareFixedSize<long>(pos, SQL_C_SLONG);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const unsigned long&)
+{
+	prepareFixedSize<long>(pos, SQL_C_SLONG);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<long>& val)
+{
+	prepareFixedSize<long>(pos, SQL_C_SLONG, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<long>& val)
+{
+	prepareFixedSize<long>(pos, SQL_C_SLONG, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<long>& val)
+{
+	prepareFixedSize<long>(pos, SQL_C_SLONG, val.size());
+}
+#endif
+
+
+inline void Preparator::prepare(std::size_t pos, const bool&)
+{
+	prepareFixedSize<bool>(pos, SQL_C_BIT);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<bool>& val)
+{
+	prepareBoolArray(pos, SQL_C_BIT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<bool>& val)
+{
+	prepareBoolArray(pos, SQL_C_BIT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<bool>& val)
+{
+	prepareBoolArray(pos, SQL_C_BIT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const float&)
+{
+	prepareFixedSize<float>(pos, SQL_C_FLOAT);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<float>& val)
+{
+	prepareFixedSize<float>(pos, SQL_C_FLOAT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<float>& val)
+{
+	prepareFixedSize<float>(pos, SQL_C_FLOAT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<float>& val)
+{
+	prepareFixedSize<float>(pos, SQL_C_FLOAT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const double&)
+{
+	prepareFixedSize<double>(pos, SQL_C_DOUBLE);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<double>& val)
+{
+	prepareFixedSize<double>(pos, SQL_C_DOUBLE, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<double>& val)
+{
+	prepareFixedSize<double>(pos, SQL_C_DOUBLE, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<double>& val)
+{
+	prepareFixedSize<double>(pos, SQL_C_DOUBLE, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const char&)
+{
+	prepareFixedSize<char>(pos, SQL_C_STINYINT);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<char>& val)
+{
+	prepareFixedSize<char>(pos, SQL_C_STINYINT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<char>& val)
+{
+	prepareFixedSize<char>(pos, SQL_C_STINYINT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<char>& val)
+{
+	prepareFixedSize<char>(pos, SQL_C_STINYINT, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::string&)
+{
+	prepareVariableLen<char>(pos, SQL_C_CHAR, maxDataSize(pos), DT_CHAR);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<std::string>& val)
+{
+	prepareCharArray<char, DT_CHAR_ARRAY>(pos, SQL_C_CHAR, maxDataSize(pos), val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<std::string>& val)
+{
+	prepareCharArray<char, DT_CHAR_ARRAY>(pos, SQL_C_CHAR, maxDataSize(pos), val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<std::string>& val)
+{
+	prepareCharArray<char, DT_CHAR_ARRAY>(pos, SQL_C_CHAR, maxDataSize(pos), val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const UTF16String&)
+{
+	prepareVariableLen<UTF16String::value_type>(pos, SQL_C_WCHAR, maxDataSize(pos), DT_WCHAR);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<UTF16String>& val)
+{
+	prepareCharArray<UTF16String::value_type, DT_WCHAR_ARRAY>(pos, SQL_C_WCHAR, maxDataSize(pos), val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<UTF16String>& val)
+{
+	prepareCharArray<UTF16String::value_type, DT_WCHAR_ARRAY>(pos, SQL_C_WCHAR, maxDataSize(pos), val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<UTF16String>& val)
+{
+	prepareCharArray<UTF16String::value_type, DT_WCHAR_ARRAY>(pos, SQL_C_WCHAR, maxDataSize(pos), val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const Poco::Data::BLOB&)
+{
+	prepareVariableLen<Poco::Data::BLOB::ValueType>(pos, SQL_C_BINARY, maxDataSize(pos), DT_UCHAR);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::Data::BLOB>& val)
+{
+	prepareCharArray<char, DT_UCHAR_ARRAY>(pos, SQL_C_BINARY, maxDataSize(pos), val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::Data::BLOB>& val)
+{
+	prepareCharArray<char, DT_UCHAR_ARRAY>(pos, SQL_C_BINARY, maxDataSize(pos), val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<Poco::Data::BLOB>& val)
+{
+	prepareCharArray<char, DT_UCHAR_ARRAY>(pos, SQL_C_BINARY, maxDataSize(pos), val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const Poco::Data::CLOB&)
+{
+	prepareVariableLen<Poco::Data::CLOB::ValueType>(pos, SQL_C_BINARY, maxDataSize(pos), DT_CHAR);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::Data::CLOB>& val)
+{
+	prepareCharArray<char, DT_CHAR_ARRAY>(pos, SQL_C_BINARY, maxDataSize(pos), val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::Data::CLOB>& val)
+{
+	prepareCharArray<char, DT_CHAR_ARRAY>(pos, SQL_C_BINARY, maxDataSize(pos), val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<Poco::Data::CLOB>& val)
+{
+	prepareCharArray<char, DT_CHAR_ARRAY>(pos, SQL_C_BINARY, maxDataSize(pos), val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const Poco::Data::Date&)
+{
+	prepareFixedSize<SQL_DATE_STRUCT>(pos, SQL_C_TYPE_DATE);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::Data::Date>& val)
+{
+	prepareFixedSize<SQL_DATE_STRUCT>(pos, SQL_C_TYPE_DATE, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::Data::Date>& val)
+{
+	prepareFixedSize<SQL_DATE_STRUCT>(pos, SQL_C_TYPE_DATE, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<Poco::Data::Date>& val)
+{
+	prepareFixedSize<SQL_DATE_STRUCT>(pos, SQL_C_TYPE_DATE, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const Poco::Data::Time&)
+{
+	prepareFixedSize<SQL_TIME_STRUCT>(pos, SQL_C_TYPE_TIME);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::Data::Time>& val)
+{
+	prepareFixedSize<SQL_TIME_STRUCT>(pos, SQL_C_TYPE_TIME, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::Data::Time>& val)
+{
+	prepareFixedSize<SQL_TIME_STRUCT>(pos, SQL_C_TYPE_TIME, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<Poco::Data::Time>& val)
+{
+	prepareFixedSize<SQL_TIME_STRUCT>(pos, SQL_C_TYPE_TIME, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const Poco::DateTime&)
+{
+	prepareFixedSize<SQL_TIMESTAMP_STRUCT>(pos, SQL_C_TYPE_TIMESTAMP);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::DateTime>& val)
+{
+	prepareFixedSize<SQL_TIMESTAMP_STRUCT>(pos, SQL_C_TYPE_TIMESTAMP, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::DateTime>& val)
+{
+	prepareFixedSize<SQL_TIMESTAMP_STRUCT>(pos, SQL_C_TYPE_TIMESTAMP, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<Poco::DateTime>& val)
+{
+	prepareFixedSize<SQL_TIMESTAMP_STRUCT>(pos, SQL_C_TYPE_TIMESTAMP, val.size());
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const Poco::Any& val)
+{
+	prepareImpl<std::vector<Poco::Any> >(pos);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::Any>& val)
+{
+	prepareImpl<std::vector<Poco::Any> >(pos, &val);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::Any>& val)
+{
+	prepareImpl<std::deque<Poco::Any> >(pos, &val);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<Poco::Any>& val)
+{
+	prepareImpl<std::list<Poco::Any> >(pos, &val);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const Poco::DynamicAny& val)
+{
+	prepareImpl<std::vector<Poco::DynamicAny> >(pos);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::vector<Poco::DynamicAny>& val)
+{
+	prepareImpl<std::vector<Poco::DynamicAny> >(pos, &val);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::deque<Poco::DynamicAny>& val)
+{
+	prepareImpl<std::deque<Poco::DynamicAny> >(pos, &val);
+}
+
+
+inline void Preparator::prepare(std::size_t pos, const std::list<Poco::DynamicAny>& val)
+{
+	prepareImpl<std::list<Poco::DynamicAny> >(pos, &val);
+}
+
+
+inline std::size_t Preparator::bulkSize(std::size_t col) const
+{
+	poco_assert (col < _lenLengths.size());
+
+	return _lenLengths[col].size();
+}
+
+
+inline void Preparator::setMaxFieldSize(std::size_t size)
+{
+	_maxFieldSize = size;
+}
+
+
+inline std::size_t Preparator::getMaxFieldSize() const
+{
+	return _maxFieldSize;
+}
+
+
+inline void Preparator::setDataExtraction(Preparator::DataExtraction ext)
+{
+	_dataExtraction = ext;
+}
+
+
+inline Preparator::DataExtraction Preparator::getDataExtraction() const
+{
+	return _dataExtraction;
+}
+
+
+inline Poco::Any& Preparator::operator [] (std::size_t pos)
+{
+	return at(pos);
+}
+
+
+inline Poco::Any& Preparator::at(std::size_t pos)
+{
+	return _values.at(pos);
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif // Data_ODBC_Preparator_INCLUDED
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/SessionImpl.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/SessionImpl.h
new file mode 100644
index 00000000000..72937bfac28
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/SessionImpl.h
@@ -0,0 +1,290 @@
+//
+// SessionImpl.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  SessionImpl
+//
+// Definition of the SessionImpl class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_SessionImpl_INCLUDED
+#define Data_ODBC_SessionImpl_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/Connector.h"
+#include "Poco/Data/ODBC/TypeInfo.h"
+#include "Poco/Data/ODBC/Binder.h"
+#include "Poco/Data/ODBC/Handle.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+#include "Poco/Data/AbstractSessionImpl.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Mutex.h"
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqltypes.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API SessionImpl: public Poco::Data::AbstractSessionImpl<SessionImpl>
+	/// Implements SessionImpl interface
+{
+public:
+	static const std::size_t ODBC_MAX_FIELD_SIZE = 1024u;
+
+	enum TransactionCapability
+	{
+		ODBC_TXN_CAPABILITY_UNKNOWN = -1,
+		ODBC_TXN_CAPABILITY_FALSE = 0,
+		ODBC_TXN_CAPABILITY_TRUE = 1
+	};
+
+	SessionImpl(const std::string& connect,
+		std::size_t loginTimeout,
+		std::size_t maxFieldSize = ODBC_MAX_FIELD_SIZE, 
+		bool autoBind = true,
+		bool autoExtract = true);
+		/// Creates the SessionImpl. Opens a connection to the database.
+		/// Throws NotConnectedException if connection was not succesful.
+
+	//@ deprecated
+	SessionImpl(const std::string& connect, 
+		Poco::Any maxFieldSize = ODBC_MAX_FIELD_SIZE, 
+		bool enforceCapability=false,
+		bool autoBind = true,
+		bool autoExtract = true);
+		/// Creates the SessionImpl. Opens a connection to the database.
+
+	~SessionImpl();
+		/// Destroys the SessionImpl.
+
+	Poco::Data::StatementImpl* createStatementImpl();
+		/// Returns an ODBC StatementImpl
+
+	void open(const std::string& connect = "");
+		/// Opens a connection to the Database
+
+	void close();
+		/// Closes the connection
+
+	bool isConnected();
+		/// Returns true if session is connected
+
+	void setConnectionTimeout(std::size_t timeout);
+		/// Sets the session connection timeout value.
+
+	std::size_t getConnectionTimeout();
+		/// Returns the session connection timeout value.
+
+	void begin();
+		/// Starts a transaction
+
+	void commit();
+		/// Commits and ends a transaction
+
+	void rollback();
+		/// Aborts a transaction
+
+	bool isTransaction();
+		/// Returns true iff a transaction is in progress.
+
+	const std::string& connectorName() const;
+		/// Returns the name of the connector.
+
+	bool canTransact();
+		/// Returns true if connection is transaction-capable.
+
+	void setTransactionIsolation(Poco::UInt32 ti);
+		/// Sets the transaction isolation level.
+
+	Poco::UInt32 getTransactionIsolation();
+		/// Returns the transaction isolation level.
+
+	bool hasTransactionIsolation(Poco::UInt32);
+		/// Returns true iff the transaction isolation level corresponding
+		/// to the supplied bitmask is supported.
+
+	bool isTransactionIsolation(Poco::UInt32);
+		/// Returns true iff the transaction isolation level corresponds
+		/// to the supplied bitmask.
+
+	void autoCommit(const std::string&, bool val);
+		/// Sets autocommit property for the session.
+
+	bool isAutoCommit(const std::string& name="");
+		/// Returns autocommit property value.
+
+	void autoBind(const std::string&, bool val);
+		/// Sets automatic binding for the session.
+
+	bool isAutoBind(const std::string& name="");
+		/// Returns true if binding is automatic for this session.
+
+	void autoExtract(const std::string&, bool val);
+		/// Sets automatic extraction for the session.
+
+	bool isAutoExtract(const std::string& name="");
+		/// Returns true if extraction is automatic for this session.
+
+	void setMaxFieldSize(const std::string& rName, const Poco::Any& rValue);
+		/// Sets the max field size (the default used when column size is unknown).
+		
+	Poco::Any getMaxFieldSize(const std::string& rName="");
+		/// Returns the max field size (the default used when column size is unknown).
+
+	int maxStatementLength();
+		/// Returns maximum length of SQL statement allowed by driver.
+
+	void setQueryTimeout(const std::string&, const Poco::Any& value);
+		/// Sets the timeout (in seconds) for queries.
+		/// Value must be of type int.
+		
+	Poco::Any getQueryTimeout(const std::string&);
+		/// Returns the timeout (in seconds) for queries,
+		/// or -1 if no timeout has been set.
+		
+	int queryTimeout() const;
+		/// Returns the timeout (in seconds) for queries,
+		/// or -1 if no timeout has been set.
+
+	const ConnectionHandle& dbc() const;
+		/// Returns the connection handle.
+
+	Poco::Any dataTypeInfo(const std::string& rName="");
+		/// Returns the data types information.
+
+private:
+	void setDataTypeInfo(const std::string& rName, const Poco::Any& rValue);
+		/// No-op. Throws InvalidAccessException.
+
+	static const int FUNCTIONS = SQL_API_ODBC3_ALL_FUNCTIONS_SIZE;
+
+	void checkError(SQLRETURN rc, const std::string& msg="");
+
+	Poco::UInt32 getDefaultTransactionIsolation();
+
+	Poco::UInt32 transactionIsolation(SQLULEN isolation);
+
+	std::string            _connector;
+	const ConnectionHandle _db;
+	Poco::Any              _maxFieldSize;
+	bool                   _autoBind;
+	bool                   _autoExtract;
+	TypeInfo               _dataTypes;
+	char                   _canTransact;
+	bool                   _inTransaction;
+	int                    _queryTimeout;
+	Poco::FastMutex        _mutex;
+};
+
+
+///
+/// inlines
+///
+inline void SessionImpl::checkError(SQLRETURN rc, const std::string& msg)
+{
+	if (Utility::isError(rc))
+		throw ConnectionException(_db, msg);
+}
+
+
+inline const ConnectionHandle& SessionImpl::dbc() const
+{
+	return _db;
+}
+
+
+inline void SessionImpl::setMaxFieldSize(const std::string& rName, const Poco::Any& rValue)
+{
+	_maxFieldSize = rValue;
+}
+
+		
+inline Poco::Any SessionImpl::getMaxFieldSize(const std::string& rName)
+{
+	return _maxFieldSize;
+}
+
+
+inline void SessionImpl::setDataTypeInfo(const std::string& rName, const Poco::Any& rValue)
+{
+	throw InvalidAccessException();
+}
+
+		
+inline Poco::Any SessionImpl::dataTypeInfo(const std::string& rName)
+{
+	return &_dataTypes;
+}
+
+
+inline void SessionImpl::autoBind(const std::string&, bool val)
+{
+	_autoBind = val;
+}
+
+
+inline bool SessionImpl::isAutoBind(const std::string& name)
+{
+	return _autoBind;
+}
+
+
+inline void SessionImpl::autoExtract(const std::string&, bool val)
+{
+	_autoExtract = val;
+}
+
+
+inline bool SessionImpl::isAutoExtract(const std::string& name)
+{
+	return _autoExtract;
+}
+
+
+inline const std::string& SessionImpl::connectorName() const
+{
+	return _connector;
+}
+
+
+inline bool SessionImpl::isTransactionIsolation(Poco::UInt32 ti)
+{
+	return 0 != (ti & getTransactionIsolation());
+}
+
+
+inline void SessionImpl::setQueryTimeout(const std::string&, const Poco::Any& value)
+{
+	_queryTimeout = Poco::AnyCast<int>(value);
+}
+
+
+inline Poco::Any SessionImpl::getQueryTimeout(const std::string&)
+{
+	return _queryTimeout;
+}
+
+
+inline int SessionImpl::queryTimeout() const
+{
+	return _queryTimeout;
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif // Data_ODBC_SessionImpl_INCLUDED
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/TypeInfo.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/TypeInfo.h
new file mode 100644
index 00000000000..f8b14a8014d
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/TypeInfo.h
@@ -0,0 +1,117 @@
+//
+// TypeInfo.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  TypeInfo
+//
+// Definition of TypeInfo.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_DataTypes_INCLUDED
+#define Data_ODBC_DataTypes_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/NamedTuple.h"
+#include "Poco/DynamicAny.h"
+#include <vector>
+#include <map>
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+#include <sqlext.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API TypeInfo
+	/// Datatypes mapping utility class.
+	///
+	/// This class provides mapping between C and SQL datatypes as well
+	/// as datatypes supported by the underlying database. In order for database
+	/// types to be available, a valid conection handle must be supplied at either
+	/// object construction time, or at a later point in time, through call to
+	/// fillTypeInfo member function.
+	///
+	/// Class also provides a convenient debugging function that prints
+	/// tabulated data to an output stream.
+{
+public:
+	typedef std::map<int, int> DataTypeMap;
+	typedef DataTypeMap::value_type ValueType;
+	typedef Poco::NamedTuple<std::string,
+		SQLSMALLINT,
+		SQLINTEGER,
+		std::string,
+		std::string,
+		std::string,
+		SQLSMALLINT,
+		SQLSMALLINT,
+		SQLSMALLINT,
+		SQLSMALLINT,
+		SQLSMALLINT,
+		SQLSMALLINT,
+		std::string,
+		SQLSMALLINT,
+		SQLSMALLINT,
+		SQLSMALLINT,
+		SQLSMALLINT,
+		SQLINTEGER,
+		SQLSMALLINT> TypeInfoTup;
+	typedef std::vector<TypeInfoTup> TypeInfoVec;
+
+	explicit TypeInfo(SQLHDBC* pHDBC=0);
+		/// Creates the TypeInfo.
+
+	~TypeInfo();
+		/// Destroys the TypeInfo.
+
+	int cDataType(int sqlDataType) const;
+		/// Returns C data type corresponding to supplied SQL data type.
+
+	int sqlDataType(int cDataType) const;
+		/// Returns SQL data type corresponding to supplied C data type.
+
+	void fillTypeInfo(SQLHDBC pHDBC);
+		/// Fills the data type info structure for the database.
+
+	DynamicAny getInfo(SQLSMALLINT type, const std::string& param) const;
+		/// Returns information about specified data type as specified by parameter 'type'.
+		/// The requested information is specified by parameter 'param'.
+		/// Will fail with a Poco::NotFoundException thrown if the param is not found
+		
+	bool tryGetInfo(SQLSMALLINT type, const std::string& param, DynamicAny& result) const;
+		/// Returns information about specified data type as specified by parameter 'type' in param result.
+		/// The requested information is specified by parameter 'param'.
+		/// Will return false if the param is not found. The value of result will be not changed in this case.
+			
+
+	void print(std::ostream& ostr);
+		/// Prints all the types (as reported by the underlying database)
+		/// to the supplied output stream.
+
+private:
+	void fillCTypes();
+	void fillSQLTypes();
+
+	DataTypeMap _cDataTypes; 
+	DataTypeMap _sqlDataTypes; 
+	TypeInfoVec _typeInfo;
+	SQLHDBC*    _pHDBC;
+};
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/Unicode.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Unicode.h
new file mode 100644
index 00000000000..1c5e4b39812
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Unicode.h
@@ -0,0 +1,985 @@
+//
+// Unicode.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Unicode
+//
+// Definition of Unicode.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Unicode_INCLUDED
+#define Data_ODBC_Unicode_INCLUDED
+
+
+#include "Poco/UnicodeConverter.h"
+#include "Poco/Buffer.h"
+#include "Poco/Exception.h"
+#include <cstring>
+#ifdef POCO_OS_FAMILY_WINDOWS
+	#include <windows.h>
+#endif
+#ifndef SQL_NOUNICODEMAP
+	#define SQL_NOUNICODEMAP
+#endif
+#include <sqlext.h>
+#include <sqltypes.h>
+#include <sqlucode.h>
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS) && defined(POCO_WIN32_UTF8)
+	#define POCO_ODBC_UNICODE
+	#define POCO_ODBC_UNICODE_WINDOWS
+#elif defined(POCO_OS_FAMILY_UNIX) && defined(UNICODE)
+	#define POCO_ODBC_UNICODE
+	#ifdef POCO_UNIXODBC
+		#define POCO_ODBC_UNICODE_UNIXODBC
+	#elif defined(POCO_IODBC)
+		#error "iODBC Unicode not supported"
+	#endif
+#endif
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+#if defined(POCO_PTR_IS_64_BIT) || defined(POCO_OS_FAMILY_UNIX) // mkrivos - POCO_OS_FAMILY_UNIX doesn't compile with SQLPOINTER & SQLColAttribute()
+	typedef SQLLEN* NumAttrPtrType;
+#else
+	typedef SQLPOINTER NumAttrPtrType;
+#endif
+
+
+SQLRETURN ODBC_API SQLColAttribute(SQLHSTMT hstmt,
+	SQLUSMALLINT   iCol,
+	SQLUSMALLINT   iField,
+	SQLPOINTER	   pCharAttr,
+	SQLSMALLINT	   cbCharAttrMax,
+	SQLSMALLINT*   pcbCharAttr,
+	NumAttrPtrType pNumAttr);
+
+
+SQLRETURN ODBC_API SQLColAttributes(SQLHSTMT hstmt,
+	SQLUSMALLINT icol,
+	SQLUSMALLINT fDescType,
+	SQLPOINTER   rgbDesc,
+	SQLSMALLINT  cbDescMax,
+	SQLSMALLINT* pcbDesc,
+	SQLLEN*      pfDesc);
+
+SQLRETURN ODBC_API SQLConnect(SQLHDBC hdbc,
+	SQLCHAR*    szDSN,
+	SQLSMALLINT cbDSN,
+	SQLCHAR*    szUID,
+	SQLSMALLINT cbUID,
+	SQLCHAR*    szAuthStr,
+	SQLSMALLINT cbAuthStr);
+
+SQLRETURN ODBC_API SQLDescribeCol(SQLHSTMT hstmt,
+	SQLUSMALLINT icol,
+	SQLCHAR*     szColName,
+	SQLSMALLINT  cbColNameMax,
+	SQLSMALLINT* pcbColName,
+	SQLSMALLINT* pfSqlType,
+	SQLULEN*     pcbColDef,
+	SQLSMALLINT* pibScale,
+	SQLSMALLINT* pfNullable);
+
+SQLRETURN ODBC_API SQLError(SQLHENV henv,
+	SQLHDBC      hdbc,
+	SQLHSTMT     hstmt,
+	SQLCHAR*     szSqlState,
+	SQLINTEGER*  pfNativeError,
+	SQLCHAR*     szErrorMsg,
+	SQLSMALLINT  cbErrorMsgMax,
+	SQLSMALLINT* pcbErrorMsg);
+
+SQLRETURN ODBC_API SQLExecDirect(SQLHSTMT hstmt,
+	SQLCHAR*   szSqlStr,
+	SQLINTEGER cbSqlStr);
+
+SQLRETURN ODBC_API SQLGetConnectAttr(SQLHDBC hdbc,
+	SQLINTEGER  fAttribute,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER  cbValueMax,
+	SQLINTEGER* pcbValue);
+
+SQLRETURN ODBC_API SQLGetCursorName(SQLHSTMT hstmt,
+	SQLCHAR*     szCursor,
+	SQLSMALLINT  cbCursorMax,
+	SQLSMALLINT* pcbCursor);
+
+SQLRETURN ODBC_API SQLSetDescField(SQLHDESC DescriptorHandle,
+	SQLSMALLINT RecNumber,
+	SQLSMALLINT FieldIdentifier,
+	SQLPOINTER  Value,
+	SQLINTEGER  BufferLength);
+
+SQLRETURN ODBC_API SQLGetDescField(SQLHDESC hdesc,
+	SQLSMALLINT iRecord,
+	SQLSMALLINT iField,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER	cbValueMax,
+	SQLINTEGER* pcbValue);
+
+SQLRETURN ODBC_API SQLGetDescRec(SQLHDESC hdesc,
+	SQLSMALLINT  iRecord,
+	SQLCHAR*     szName,
+	SQLSMALLINT  cbNameMax,
+	SQLSMALLINT* pcbName,
+	SQLSMALLINT* pfType,
+	SQLSMALLINT* pfSubType,
+	SQLLEN*      pLength,
+	SQLSMALLINT* pPrecision,
+	SQLSMALLINT* pScale,
+	SQLSMALLINT* pNullable);
+
+SQLRETURN ODBC_API SQLGetDiagField(SQLSMALLINT fHandleType,
+	SQLHANDLE    handle,
+	SQLSMALLINT  iRecord,
+	SQLSMALLINT  fDiagField,
+	SQLPOINTER   rgbDiagInfo,
+	SQLSMALLINT  cbDiagInfoMax,
+	SQLSMALLINT* pcbDiagInfo);
+
+SQLRETURN ODBC_API SQLGetDiagRec(SQLSMALLINT fHandleType,
+	SQLHANDLE    handle,
+	SQLSMALLINT  iRecord,
+	SQLCHAR*     szSqlState,
+	SQLINTEGER*  pfNativeError,
+	SQLCHAR*     szErrorMsg,
+	SQLSMALLINT  cbErrorMsgMax,
+	SQLSMALLINT* pcbErrorMsg);
+
+SQLRETURN ODBC_API SQLPrepare(SQLHSTMT hstmt,
+	SQLCHAR*   szSqlStr,
+	SQLINTEGER cbSqlStr);
+
+SQLRETURN ODBC_API SQLSetConnectAttr(SQLHDBC hdbc,
+	SQLINTEGER fAttribute,
+	SQLPOINTER rgbValue,
+	SQLINTEGER cbValue);
+
+SQLRETURN ODBC_API SQLSetCursorName(SQLHSTMT hstmt,
+	SQLCHAR*    szCursor,
+	SQLSMALLINT cbCursor);
+
+SQLRETURN ODBC_API SQLSetStmtAttr(SQLHSTMT hstmt,
+	SQLINTEGER fAttribute,
+	SQLPOINTER rgbValue,
+	SQLINTEGER cbValueMax);
+
+SQLRETURN ODBC_API SQLGetStmtAttr(SQLHSTMT hstmt,
+	SQLINTEGER  fAttribute,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER  cbValueMax,
+	SQLINTEGER* pcbValue);
+
+SQLRETURN ODBC_API SQLColumns(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName);
+
+SQLRETURN ODBC_API SQLGetConnectOption(SQLHDBC hdbc,
+	SQLUSMALLINT fOption,
+	SQLPOINTER   pvParam);
+
+SQLRETURN ODBC_API SQLGetInfo(SQLHDBC hdbc,
+	SQLUSMALLINT fInfoType,
+	SQLPOINTER   rgbInfoValue,
+	SQLSMALLINT  cbInfoValueMax,
+	SQLSMALLINT* pcbInfoValue);
+
+SQLRETURN ODBC_API SQLGetTypeInfo(SQLHSTMT StatementHandle,
+	SQLSMALLINT	DataType);
+
+SQLRETURN ODBC_API SQLSetConnectOption(SQLHDBC hdbc,
+	SQLUSMALLINT fOption,
+	SQLULEN      vParam);
+
+SQLRETURN ODBC_API SQLSpecialColumns(SQLHSTMT hstmt,
+	SQLUSMALLINT fColType,
+	SQLCHAR*     szCatalogName,
+	SQLSMALLINT  cbCatalogName,
+	SQLCHAR*     szSchemaName,
+	SQLSMALLINT  cbSchemaName,
+	SQLCHAR*     szTableName,
+	SQLSMALLINT  cbTableName,
+	SQLUSMALLINT fScope,
+	SQLUSMALLINT fNullable);
+
+SQLRETURN ODBC_API SQLStatistics(SQLHSTMT hstmt,
+	SQLCHAR*     szCatalogName,
+	SQLSMALLINT  cbCatalogName,
+	SQLCHAR*     szSchemaName,
+	SQLSMALLINT  cbSchemaName,
+	SQLCHAR*     szTableName,
+	SQLSMALLINT  cbTableName,
+	SQLUSMALLINT fUnique,
+	SQLUSMALLINT fAccuracy);
+
+SQLRETURN ODBC_API SQLTables(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szTableType,
+	SQLSMALLINT cbTableType);
+
+SQLRETURN ODBC_API SQLDataSources(SQLHENV henv,
+	SQLUSMALLINT fDirection,
+	SQLCHAR*     szDSN,
+	SQLSMALLINT  cbDSNMax,
+	SQLSMALLINT* pcbDSN,
+	SQLCHAR*     szDescription,
+	SQLSMALLINT  cbDescriptionMax,
+	SQLSMALLINT* pcbDescription);
+
+SQLRETURN ODBC_API SQLDriverConnect(SQLHDBC hdbc,
+	SQLHWND      hwnd,
+	SQLCHAR*     szConnStrIn,
+	SQLSMALLINT  cbConnStrIn,
+	SQLCHAR*     szConnStrOut,
+	SQLSMALLINT  cbConnStrOutMax,
+	SQLSMALLINT* pcbConnStrOut,
+	SQLUSMALLINT fDriverCompletion);
+
+SQLRETURN ODBC_API SQLBrowseConnect(SQLHDBC hdbc,
+	SQLCHAR*     szConnStrIn,
+	SQLSMALLINT  cbConnStrIn,
+	SQLCHAR*     szConnStrOut,
+	SQLSMALLINT  cbConnStrOutMax,
+	SQLSMALLINT* pcbConnStrOut);
+
+SQLRETURN ODBC_API SQLColumnPrivileges(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName);
+
+SQLRETURN ODBC_API SQLForeignKeys(SQLHSTMT hstmt,
+	SQLCHAR*    szPkCatalogName,
+	SQLSMALLINT cbPkCatalogName,
+	SQLCHAR*    szPkSchemaName,
+	SQLSMALLINT cbPkSchemaName,
+	SQLCHAR*    szPkTableName,
+	SQLSMALLINT cbPkTableName,
+	SQLCHAR*    szFkCatalogName,
+	SQLSMALLINT cbFkCatalogName,
+	SQLCHAR*    szFkSchemaName,
+	SQLSMALLINT cbFkSchemaName,
+	SQLCHAR*    szFkTableName,
+	SQLSMALLINT cbFkTableName);
+
+SQLRETURN ODBC_API SQLNativeSql(SQLHDBC hdbc,
+	SQLCHAR*    szSqlStrIn,
+	SQLINTEGER  cbSqlStrIn,
+	SQLCHAR*    szSqlStr,
+	SQLINTEGER  cbSqlStrMax,
+	SQLINTEGER* pcbSqlStr);
+
+SQLRETURN ODBC_API SQLPrimaryKeys(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName);
+
+SQLRETURN ODBC_API SQLProcedureColumns(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szProcName,
+	SQLSMALLINT cbProcName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName);
+
+SQLRETURN ODBC_API SQLProcedures(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szProcName,
+	SQLSMALLINT cbProcName);
+
+SQLRETURN ODBC_API SQLTablePrivileges(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName);
+
+SQLRETURN ODBC_API SQLDrivers(SQLHENV henv,
+	SQLUSMALLINT fDirection,
+	SQLCHAR*     szDriverDesc,
+	SQLSMALLINT  cbDriverDescMax,
+	SQLSMALLINT* pcbDriverDesc,
+	SQLCHAR*     szDriverAttributes,
+	SQLSMALLINT  cbDrvrAttrMax,
+	SQLSMALLINT* pcbDrvrAttr);
+
+
+///
+/// inlines
+///
+
+inline bool isString(SQLPOINTER pValue, SQLINTEGER length)
+{
+	return (SQL_NTS == length || length > 0) && pValue;
+}
+
+
+inline SQLINTEGER stringLength(SQLPOINTER pValue, SQLINTEGER length)
+{
+	if (SQL_NTS != length) return length;
+
+	return (SQLINTEGER) std::strlen((const char*) pValue);
+}
+
+
+#if !defined(POCO_ODBC_UNICODE)
+
+
+///
+/// inlines
+///
+
+inline SQLRETURN SQLColAttribute(SQLHSTMT hstmt,
+	SQLUSMALLINT   iCol,
+	SQLUSMALLINT   iField,
+	SQLPOINTER     pCharAttr,
+	SQLSMALLINT    cbCharAttrMax,
+	SQLSMALLINT*   pcbCharAttr,
+	NumAttrPtrType pNumAttr)
+{
+	return ::SQLColAttributeA(hstmt,
+		iCol,
+		iField,
+		pCharAttr,
+		cbCharAttrMax,
+		pcbCharAttr,
+		pNumAttr);
+}
+
+
+inline SQLRETURN SQLColAttributes(SQLHSTMT hstmt,
+	SQLUSMALLINT icol,
+	SQLUSMALLINT fDescType,
+	SQLPOINTER   rgbDesc,
+	SQLSMALLINT  cbDescMax,
+	SQLSMALLINT* pcbDesc,
+	SQLLEN*      pfDesc)
+{
+	return ::SQLColAttributesA(hstmt,
+		icol,
+		fDescType,
+		rgbDesc,
+		cbDescMax,
+		pcbDesc,
+		pfDesc);
+}
+
+
+inline SQLRETURN SQLConnect(SQLHDBC hdbc,
+	SQLCHAR*    szDSN,
+	SQLSMALLINT cbDSN,
+	SQLCHAR*    szUID,
+	SQLSMALLINT cbUID,
+	SQLCHAR*    szAuthStr,
+	SQLSMALLINT cbAuthStr)
+{
+	return ::SQLConnectA(hdbc,
+		szDSN,
+		cbDSN,
+		szUID,
+		cbUID,
+		szAuthStr,
+		cbAuthStr);
+}
+
+
+inline SQLRETURN SQLDescribeCol(SQLHSTMT hstmt,
+	SQLUSMALLINT icol,
+	SQLCHAR*     szColName,
+	SQLSMALLINT  cbColNameMax,
+	SQLSMALLINT* pcbColName,
+	SQLSMALLINT* pfSqlType,
+	SQLULEN*     pcbColDef,
+	SQLSMALLINT* pibScale,
+	SQLSMALLINT* pfNullable)
+{
+	return ::SQLDescribeColA(hstmt,
+		icol,
+		szColName,
+		cbColNameMax,
+		pcbColName,
+		pfSqlType,
+		pcbColDef,
+		pibScale,
+		pfNullable);
+}
+
+
+inline SQLRETURN SQLError(SQLHENV henv,
+	SQLHDBC      hdbc,
+	SQLHSTMT     hstmt,
+	SQLCHAR*     szSqlState,
+	SQLINTEGER*  pfNativeError,
+	SQLCHAR*     szErrorMsg,
+	SQLSMALLINT  cbErrorMsgMax,
+	SQLSMALLINT* pcbErrorMsg)
+{
+	throw Poco::NotImplementedException("SQLError is obsolete. "
+		"Use SQLGetDiagRec instead.");
+}
+
+
+inline SQLRETURN SQLExecDirect(SQLHSTMT hstmt,
+	SQLCHAR*   szSqlStr,
+	SQLINTEGER cbSqlStr)
+{
+	return ::SQLExecDirectA(hstmt, szSqlStr, cbSqlStr);
+}
+
+
+inline SQLRETURN SQLGetConnectAttr(SQLHDBC hdbc,
+	SQLINTEGER  fAttribute,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER  cbValueMax,
+	SQLINTEGER* pcbValue)
+{
+	return ::SQLGetConnectAttrA(hdbc,
+		fAttribute,
+		rgbValue,
+		cbValueMax,
+		pcbValue);
+}
+
+
+inline SQLRETURN SQLGetCursorName(SQLHSTMT hstmt,
+	SQLCHAR*     szCursor,
+	SQLSMALLINT  cbCursorMax,
+	SQLSMALLINT* pcbCursor)
+{
+	throw Poco::NotImplementedException("Not implemented");
+}
+
+
+inline SQLRETURN SQLSetDescField(SQLHDESC DescriptorHandle,
+	SQLSMALLINT RecNumber,
+	SQLSMALLINT FieldIdentifier,
+	SQLPOINTER  Value,
+	SQLINTEGER  BufferLength)
+{
+	return ::SQLSetDescField(DescriptorHandle,
+		RecNumber,
+		FieldIdentifier,
+		Value,
+		BufferLength);
+}
+
+
+inline SQLRETURN SQLGetDescField(SQLHDESC hdesc,
+	SQLSMALLINT iRecord,
+	SQLSMALLINT iField,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER	cbValueMax,
+	SQLINTEGER* pcbValue)
+{
+	return ::SQLGetDescFieldA(hdesc,
+		iRecord,
+		iField,
+		rgbValue,
+		cbValueMax,
+		pcbValue);
+}
+
+
+inline SQLRETURN SQLGetDescRec(SQLHDESC hdesc,
+	SQLSMALLINT  iRecord,
+	SQLCHAR*     szName,
+	SQLSMALLINT  cbNameMax,
+	SQLSMALLINT* pcbName,
+	SQLSMALLINT* pfType,
+	SQLSMALLINT* pfSubType,
+	SQLLEN*      pLength,
+	SQLSMALLINT* pPrecision,
+	SQLSMALLINT* pScale,
+	SQLSMALLINT* pNullable)
+{
+	return ::SQLGetDescRecA(hdesc,
+		iRecord,
+		szName,
+		cbNameMax,
+		pcbName,
+		pfType,
+		pfSubType,
+		pLength,
+		pPrecision,
+		pScale,
+		pNullable);
+}
+
+
+inline SQLRETURN SQLGetDiagField(SQLSMALLINT fHandleType,
+	SQLHANDLE    handle,
+	SQLSMALLINT  iRecord,
+	SQLSMALLINT  fDiagField,
+	SQLPOINTER   rgbDiagInfo,
+	SQLSMALLINT  cbDiagInfoMax,
+	SQLSMALLINT* pcbDiagInfo)
+{
+	return ::SQLGetDiagFieldA(fHandleType,
+		handle,
+		iRecord,
+		fDiagField,
+		rgbDiagInfo,
+		cbDiagInfoMax,
+		pcbDiagInfo);
+}
+
+
+inline SQLRETURN SQLGetDiagRec(SQLSMALLINT fHandleType,
+	SQLHANDLE    handle,
+	SQLSMALLINT  iRecord,
+	SQLCHAR*     szSqlState,
+	SQLINTEGER*  pfNativeError,
+	SQLCHAR*     szErrorMsg,
+	SQLSMALLINT  cbErrorMsgMax,
+	SQLSMALLINT* pcbErrorMsg)
+{
+	return ::SQLGetDiagRecA(fHandleType,
+		handle,
+		iRecord,
+		szSqlState,
+		pfNativeError,
+		szErrorMsg,
+		cbErrorMsgMax,
+		pcbErrorMsg);
+}
+
+
+inline SQLRETURN SQLPrepare(SQLHSTMT hstmt,
+	SQLCHAR*   szSqlStr,
+	SQLINTEGER cbSqlStr)
+{
+	return ::SQLPrepareA(hstmt,	szSqlStr, cbSqlStr);
+}
+
+
+inline SQLRETURN SQLSetConnectAttr(SQLHDBC hdbc,
+	SQLINTEGER fAttribute,
+	SQLPOINTER rgbValue,
+	SQLINTEGER cbValue)
+{
+	return ::SQLSetConnectAttrA(hdbc,	fAttribute,	rgbValue, cbValue);
+}
+
+
+inline SQLRETURN SQLSetCursorName(SQLHSTMT hstmt,
+	SQLCHAR*    szCursor,
+	SQLSMALLINT cbCursor)
+{
+	throw Poco::NotImplementedException("Not implemented");
+}
+
+
+inline SQLRETURN SQLSetStmtAttr(SQLHSTMT hstmt,
+	SQLINTEGER fAttribute,
+	SQLPOINTER rgbValue,
+	SQLINTEGER cbValueMax)
+{
+	return ::SQLSetStmtAttr(hstmt, fAttribute, rgbValue, cbValueMax);
+}
+
+
+inline SQLRETURN SQLGetStmtAttr(SQLHSTMT hstmt,
+	SQLINTEGER  fAttribute,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER  cbValueMax,
+	SQLINTEGER* pcbValue)
+{
+	return ::SQLGetStmtAttrA(hstmt,
+		fAttribute,
+		rgbValue,
+		cbValueMax,
+		pcbValue);
+}
+
+
+inline SQLRETURN SQLColumns(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName)
+{
+	return ::SQLColumnsA(hstmt,
+		szCatalogName,
+		cbCatalogName,
+		szSchemaName,
+		cbSchemaName,
+		szTableName,
+		cbTableName,
+		szColumnName,
+		cbColumnName);
+}
+
+
+inline SQLRETURN SQLGetConnectOption(SQLHDBC hdbc,
+	SQLUSMALLINT fOption,
+	SQLPOINTER   pvParam)
+{
+	return ::SQLGetConnectOptionA(hdbc, fOption, pvParam);
+}
+
+
+inline SQLRETURN SQLGetInfo(SQLHDBC hdbc,
+	SQLUSMALLINT fInfoType,
+	SQLPOINTER   rgbInfoValue,
+	SQLSMALLINT  cbInfoValueMax,
+	SQLSMALLINT* pcbInfoValue)
+{
+	return ::SQLGetInfoA(hdbc,
+		fInfoType,
+		rgbInfoValue,
+		cbInfoValueMax,
+		pcbInfoValue);
+}
+
+
+inline SQLRETURN SQLGetTypeInfo(SQLHSTMT StatementHandle,
+	SQLSMALLINT	DataType)
+{
+	return ::SQLGetTypeInfoA(StatementHandle, DataType);
+}
+
+
+inline SQLRETURN SQLSetConnectOption(SQLHDBC hdbc,
+	SQLUSMALLINT fOption,
+	SQLULEN      vParam)
+{
+	return ::SQLSetConnectOptionA(hdbc, fOption, vParam);
+}
+
+
+inline SQLRETURN SQLSpecialColumns(SQLHSTMT hstmt,
+	SQLUSMALLINT fColType,
+	SQLCHAR*     szCatalogName,
+	SQLSMALLINT  cbCatalogName,
+	SQLCHAR*     szSchemaName,
+	SQLSMALLINT  cbSchemaName,
+	SQLCHAR*     szTableName,
+	SQLSMALLINT  cbTableName,
+	SQLUSMALLINT fScope,
+	SQLUSMALLINT fNullable)
+{
+	return ::SQLSpecialColumnsA(hstmt,
+		fColType,
+		szCatalogName,
+		cbCatalogName,
+		szSchemaName,
+		cbSchemaName,
+		szTableName,
+		cbTableName,
+		fScope,
+		fNullable);
+}
+
+
+inline SQLRETURN SQLStatistics(SQLHSTMT hstmt,
+	SQLCHAR*     szCatalogName,
+	SQLSMALLINT  cbCatalogName,
+	SQLCHAR*     szSchemaName,
+	SQLSMALLINT  cbSchemaName,
+	SQLCHAR*     szTableName,
+	SQLSMALLINT  cbTableName,
+	SQLUSMALLINT fUnique,
+	SQLUSMALLINT fAccuracy)
+{
+	return ::SQLStatisticsA(hstmt,
+		szCatalogName,
+		cbCatalogName,
+		szSchemaName,
+		cbSchemaName,
+		szTableName,
+		cbTableName,
+		fUnique,
+		fAccuracy);
+}
+
+
+inline SQLRETURN SQLTables(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szTableType,
+	SQLSMALLINT cbTableType)
+{
+	return ::SQLTablesA(hstmt,
+		szCatalogName,
+		cbCatalogName,
+		szSchemaName,
+		cbSchemaName,
+		szTableName,
+		cbTableName,
+		szTableType,
+		cbTableType);
+}
+
+
+inline SQLRETURN SQLDataSources(SQLHENV henv,
+	SQLUSMALLINT fDirection,
+	SQLCHAR*     szDSN,
+	SQLSMALLINT  cbDSNMax,
+	SQLSMALLINT* pcbDSN,
+	SQLCHAR*     szDescription,
+	SQLSMALLINT  cbDescriptionMax,
+	SQLSMALLINT* pcbDescription)
+{
+	return ::SQLDataSourcesA(henv,
+		fDirection,
+		szDSN,
+		cbDSNMax,
+		pcbDSN,
+		szDescription,
+		cbDescriptionMax,
+		pcbDescription);
+}
+
+
+inline SQLRETURN SQLDriverConnect(SQLHDBC hdbc,
+	SQLHWND      hwnd,
+	SQLCHAR*     szConnStrIn,
+	SQLSMALLINT  cbConnStrIn,
+	SQLCHAR*     szConnStrOut,
+	SQLSMALLINT  cbConnStrOutMax,
+	SQLSMALLINT* pcbConnStrOut,
+	SQLUSMALLINT fDriverCompletion)
+{
+	return ::SQLDriverConnectA(hdbc,
+		hwnd,
+		szConnStrIn,
+		cbConnStrIn,
+		szConnStrOut,
+		cbConnStrOutMax,
+		pcbConnStrOut,
+		fDriverCompletion);
+}
+
+
+inline SQLRETURN SQLBrowseConnect(SQLHDBC hdbc,
+	SQLCHAR*     szConnStrIn,
+	SQLSMALLINT  cbConnStrIn,
+	SQLCHAR*     szConnStrOut,
+	SQLSMALLINT  cbConnStrOutMax,
+	SQLSMALLINT* pcbConnStrOut)
+{
+	return ::SQLBrowseConnectA(hdbc,
+		szConnStrIn,
+		cbConnStrIn,
+		szConnStrOut,
+		cbConnStrOutMax,
+		pcbConnStrOut);
+}
+
+
+inline SQLRETURN SQLColumnPrivileges(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName)
+{
+	return ::SQLColumnPrivilegesA(hstmt,
+		szCatalogName,
+		cbCatalogName,
+		szSchemaName,
+		cbSchemaName,
+		szTableName,
+		cbTableName,
+		szColumnName,
+		cbColumnName);
+}
+
+
+inline SQLRETURN SQLForeignKeys(SQLHSTMT hstmt,
+	SQLCHAR*    szPkCatalogName,
+	SQLSMALLINT cbPkCatalogName,
+	SQLCHAR*    szPkSchemaName,
+	SQLSMALLINT cbPkSchemaName,
+	SQLCHAR*    szPkTableName,
+	SQLSMALLINT cbPkTableName,
+	SQLCHAR*    szFkCatalogName,
+	SQLSMALLINT cbFkCatalogName,
+	SQLCHAR*    szFkSchemaName,
+	SQLSMALLINT cbFkSchemaName,
+	SQLCHAR*    szFkTableName,
+	SQLSMALLINT cbFkTableName)
+{
+	return ::SQLForeignKeysA(hstmt,
+		szPkCatalogName,
+		cbPkCatalogName,
+		szPkSchemaName,
+		cbPkSchemaName,
+		szPkTableName,
+		cbPkTableName,
+		szFkCatalogName,
+		cbFkCatalogName,
+		szFkSchemaName,
+		cbFkSchemaName,
+		szFkTableName,
+		cbFkTableName);
+}
+
+
+inline SQLRETURN SQLNativeSql(SQLHDBC hdbc,
+	SQLCHAR*    szSqlStrIn,
+	SQLINTEGER  cbSqlStrIn,
+	SQLCHAR*    szSqlStr,
+	SQLINTEGER  cbSqlStrMax,
+	SQLINTEGER* pcbSqlStr)
+{
+	return ::SQLNativeSqlA(hdbc,
+		szSqlStrIn,
+		cbSqlStrIn,
+		szSqlStr,
+		cbSqlStrMax,
+		pcbSqlStr);
+}
+
+
+inline SQLRETURN SQLPrimaryKeys(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName)
+{
+	return ::SQLPrimaryKeysA(hstmt,
+		szCatalogName,
+		cbCatalogName,
+		szSchemaName,
+		cbSchemaName,
+		szTableName,
+		cbTableName);
+}
+
+
+inline SQLRETURN SQLProcedureColumns(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szProcName,
+	SQLSMALLINT cbProcName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName)
+{
+	return ::SQLProcedureColumnsA(hstmt,
+		szCatalogName,
+		cbCatalogName,
+		szSchemaName,
+		cbSchemaName,
+		szProcName,
+		cbProcName,
+		szColumnName,
+		cbColumnName);
+}
+
+
+inline SQLRETURN SQLProcedures(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szProcName,
+	SQLSMALLINT cbProcName)
+{
+	return ::SQLProceduresA(hstmt,
+		szCatalogName,
+		cbCatalogName,
+		szSchemaName,
+		cbSchemaName,
+		szProcName,
+		cbProcName);
+}
+
+
+inline SQLRETURN SQLTablePrivileges(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName)
+{
+	return ::SQLTablePrivilegesA(hstmt,
+		szCatalogName,
+		cbCatalogName,
+		szSchemaName,
+		cbSchemaName,
+		szTableName,
+		cbTableName);
+}
+
+
+inline SQLRETURN SQLDrivers(SQLHENV henv,
+	SQLUSMALLINT fDirection,
+	SQLCHAR*     szDriverDesc,
+	SQLSMALLINT  cbDriverDescMax,
+	SQLSMALLINT* pcbDriverDesc,
+	SQLCHAR*     szDriverAttributes,
+	SQLSMALLINT  cbDrvrAttrMax,
+	SQLSMALLINT* pcbDrvrAttr)
+{
+	return ::SQLDriversA(henv,
+		fDirection,
+		szDriverDesc,
+		cbDriverDescMax,
+		pcbDriverDesc,
+		szDriverAttributes,
+		cbDrvrAttrMax,
+		pcbDrvrAttr);
+}
+
+
+#endif // POCO_ODBC_UNICODE
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif // ODBC_Unicode_INCLUDED
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/Unicode_UNIXODBC.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Unicode_UNIXODBC.h
new file mode 100644
index 00000000000..f2e67942546
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Unicode_UNIXODBC.h
@@ -0,0 +1,51 @@
+//
+// Unicode.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Unicode
+//
+// Definition of Unicode_UNIX.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Unicode_UNIX_INCLUDED
+#define Data_ODBC_Unicode_UNIX_INCLUDED
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+void makeUTF16(SQLCHAR* pSQLChar, SQLINTEGER length, std::string& target);
+	/// Utility function for conversion from UTF-8 to UTF-16
+
+
+inline void makeUTF16(SQLCHAR* pSQLChar, SQLSMALLINT length, std::string& target)
+	/// Utility function for conversion from UTF-8 to UTF-16.
+{
+	makeUTF16(pSQLChar, (SQLINTEGER) length, target);
+}
+
+
+void makeUTF8(Poco::Buffer<SQLWCHAR>& buffer, SQLINTEGER length, SQLPOINTER pTarget, SQLINTEGER targetLength);
+	/// Utility function for conversion from UTF-16 to UTF-8.
+
+
+inline void makeUTF8(Poco::Buffer<SQLWCHAR>& buffer, int length, SQLPOINTER pTarget, SQLSMALLINT targetLength)
+	/// Utility function for conversion from UTF-16 to UTF-8.
+{
+	makeUTF8(buffer, length, pTarget, (SQLINTEGER) targetLength);
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif // Data_ODBC_Unicode_UNIX_INCLUDED
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/Unicode_WIN32.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Unicode_WIN32.h
new file mode 100644
index 00000000000..fa1abe94540
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Unicode_WIN32.h
@@ -0,0 +1,57 @@
+//
+// Unicode.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Unicode
+//
+// Definition of Unicode_WIN32.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Unicode_WIN32_INCLUDED
+#define Data_ODBC_Unicode_WIN32_INCLUDED
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+inline void makeUTF16(SQLCHAR* pSQLChar, SQLINTEGER length, std::wstring& target)
+	/// Utility function for conversion from UTF-8 to UTF-16
+{
+	int len = length;
+	if (SQL_NTS == len) 
+		len = (int) std::strlen((const char *) pSQLChar);
+
+	UnicodeConverter::toUTF16((const char *) pSQLChar, len, target);
+}
+
+
+inline void makeUTF8(Poco::Buffer<wchar_t>& buffer, SQLINTEGER length, SQLPOINTER pTarget, SQLINTEGER targetLength)
+	/// Utility function for conversion from UTF-16 to UTF-8. Length is in bytes.
+{
+	if (buffer.sizeBytes() < length)
+		throw InvalidArgumentException("Specified length exceeds available length.");
+	else if ((length % 2) != 0)
+		throw InvalidArgumentException("Length must be an even number.");
+
+	length /= sizeof(wchar_t);
+	std::string result;
+	UnicodeConverter::toUTF8(buffer.begin(), length, result);
+	
+	std::memset(pTarget, 0, targetLength);
+	std::strncpy((char*) pTarget, result.c_str(), result.size() < targetLength ? result.size() : targetLength);
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif // Data_ODBC_Unicode_WIN32_INCLUDED
diff --git a/base/poco/Data/ODBC/include/Poco/Data/ODBC/Utility.h b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Utility.h
new file mode 100644
index 00000000000..28e7865355e
--- /dev/null
+++ b/base/poco/Data/ODBC/include/Poco/Data/ODBC/Utility.h
@@ -0,0 +1,207 @@
+//
+// Utility.h
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Utility
+//
+// Definition of Utility.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ODBC_Utility_INCLUDED
+#define Data_ODBC_Utility_INCLUDED
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/TypeInfo.h"
+#include "Poco/Data/Date.h"
+#include "Poco/Data/Time.h"
+#include "Poco/DateTime.h"
+#include <sstream>
+#include <map>
+#include <sqltypes.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+class ODBC_API Utility
+	/// Various utility functions
+{
+public:
+	typedef std::map<std::string, std::string> DSNMap;
+	typedef DSNMap DriverMap;
+
+	static bool isError(SQLRETURN rc);
+		/// Returns true if return code is error
+
+	static DriverMap& drivers(DriverMap& driverMap);
+		/// Returns driver-attributes map of available ODBC drivers.
+
+	static DSNMap& dataSources(DSNMap& dsnMap);
+		/// Returns DSN-description map of available ODBC data sources.
+
+	template<typename MapType, typename KeyArgType, typename ValueArgType>
+	static typename MapType::iterator mapInsert(MapType& m, const KeyArgType& k, const ValueArgType& v)
+		/// Utility map "insert or replace" function (from S. Meyers: Effective STL, Item 24)
+	{
+		typename MapType::iterator lb = m.lower_bound(k);
+		if (lb != m.end() && !(m.key_comp()(k, lb->first)))
+		{
+			lb->second = v;
+			return lb;
+		}
+		else
+		{
+			typedef typename MapType::value_type MVT;
+			return m.insert(lb, MVT(k,v));
+		}
+	}
+
+	static int cDataType(int sqlDataType);
+		/// Returns C data type corresponding to supplied SQL data type.
+
+	static int sqlDataType(int cDataType);
+		/// Returns SQL data type corresponding to supplied C data type.
+
+	static void dateSync(Date& dt, const SQL_DATE_STRUCT& ts);
+		/// Transfers data from ODBC SQL_DATE_STRUCT to Poco::DateTime.
+
+	template <typename T, typename F>
+	static void dateSync(T& d, const F& ds)
+		/// Transfers data from ODBC SQL_DATE_STRUCT container to Poco::DateTime container.
+	{
+		std::size_t size = ds.size();
+		if (d.size() != size) d.resize(size);
+		typename T::iterator dIt = d.begin();
+		typename F::const_iterator it = ds.begin();
+		typename F::const_iterator end = ds.end();
+		for (; it != end; ++it, ++dIt) dateSync(*dIt, *it);
+	}
+
+	static void timeSync(Time& dt, const SQL_TIME_STRUCT& ts);
+		/// Transfers data from ODBC SQL_TIME_STRUCT to Poco::DateTime.
+
+	template <typename T, typename F>
+	static void timeSync(T& t, const F& ts)
+		/// Transfers data from ODBC SQL_TIME_STRUCT container to Poco::DateTime container.
+	{
+		std::size_t size = ts.size();
+		if (t.size() != size) t.resize(size);
+		typename T::iterator dIt = t.begin();
+		typename F::const_iterator it = ts.begin();
+		typename F::const_iterator end = ts.end();
+		for (; it != end; ++it, ++dIt) timeSync(*dIt, *it);
+	}
+
+	static void dateTimeSync(Poco::DateTime& dt, const SQL_TIMESTAMP_STRUCT& ts);
+		/// Transfers data from ODBC SQL_TIMESTAMP_STRUCT to Poco::DateTime.
+
+	template <typename T, typename F>
+	static void dateTimeSync(T& dt, const F& ts)
+		/// Transfers data from ODBC SQL_TIMESTAMP_STRUCT container to Poco::DateTime container.
+	{
+		std::size_t size = ts.size();
+		if (dt.size() != size) dt.resize(size);
+		typename T::iterator dIt = dt.begin();
+		typename F::const_iterator it = ts.begin();
+		typename F::const_iterator end = ts.end();
+		for (; it != end; ++it, ++dIt) dateTimeSync(*dIt, *it);
+	}
+
+	static void dateSync(SQL_DATE_STRUCT& ts, const Date& dt);
+		/// Transfers data from Poco::Data::Date to ODBC SQL_DATE_STRUCT.
+
+	template <typename C>
+	static void dateSync(std::vector<SQL_DATE_STRUCT>& ds, const C& d)
+		/// Transfers data from Poco::Data::Date vector to ODBC SQL_DATE_STRUCT container.
+	{
+		std::size_t size = d.size();
+		if (ds.size() != size) ds.resize(size);
+		std::vector<SQL_DATE_STRUCT>::iterator dIt = ds.begin();
+		typename C::const_iterator it = d.begin();
+		typename C::const_iterator end = d.end();
+		for (; it != end; ++it, ++dIt) dateSync(*dIt, *it);
+	}
+
+	static void timeSync(SQL_TIME_STRUCT& ts, const Time& dt);
+		/// Transfers data from Poco::Data::Time to ODBC SQL_TIME_STRUCT.
+
+	template <typename C>
+	static void timeSync(std::vector<SQL_TIME_STRUCT>& ts, const C& t)
+		/// Transfers data from Poco::Data::Time container to ODBC SQL_TIME_STRUCT vector.
+	{
+		std::size_t size = t.size();
+		if (ts.size() != size) ts.resize(size);
+		std::vector<SQL_TIME_STRUCT>::iterator tIt = ts.begin();
+		typename C::const_iterator it = t.begin();
+		typename C::const_iterator end = t.end();
+		for (; it != end; ++it, ++tIt) timeSync(*tIt, *it);
+	}
+
+	static void dateTimeSync(SQL_TIMESTAMP_STRUCT& ts, const Poco::DateTime& dt);
+		/// Transfers data from Poco::DateTime to ODBC SQL_TIMESTAMP_STRUCT.
+
+	template <typename C>
+	static void dateTimeSync(std::vector<SQL_TIMESTAMP_STRUCT>& ts, const C& dt)
+		/// Transfers data from Poco::DateTime to ODBC SQL_TIMESTAMP_STRUCT.
+	{
+		std::size_t size = dt.size();
+		if (ts.size() != size) ts.resize(size);
+		std::vector<SQL_TIMESTAMP_STRUCT>::iterator tIt = ts.begin();
+		typename C::const_iterator it = dt.begin();
+		typename C::const_iterator end = dt.end();
+		for (; it != end; ++it, ++tIt) dateTimeSync(*tIt, *it);
+	}
+
+private:
+	static const TypeInfo _dataTypes;
+		/// C <==> SQL data type mapping
+};
+
+
+///
+/// inlines
+///
+inline bool Utility::isError(SQLRETURN rc)
+{
+	return (0 != (rc & (~1)));
+}
+
+
+inline int Utility::cDataType(int sqlDataType)
+{
+	return _dataTypes.cDataType(sqlDataType);
+}
+
+
+inline int Utility::sqlDataType(int cDataType)
+{
+	return _dataTypes.sqlDataType(cDataType);
+}
+
+
+inline void Utility::dateSync(Date& d, const SQL_DATE_STRUCT& ts)
+{
+	d.assign(ts.year, ts.month, ts.day);
+}
+
+
+inline void Utility::timeSync(Time& t, const SQL_TIME_STRUCT& ts)
+{
+	t.assign(ts.hour, ts.minute, ts.second);
+}
+
+
+} } } // namespace Poco::Data::ODBC
+
+
+#endif
diff --git a/base/poco/Data/ODBC/src/Binder.cpp b/base/poco/Data/ODBC/src/Binder.cpp
new file mode 100644
index 00000000000..aa2c9e157f1
--- /dev/null
+++ b/base/poco/Data/ODBC/src/Binder.cpp
@@ -0,0 +1,541 @@
+//
+// Binder.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Binder
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/Binder.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/Connector.h"
+#include "Poco/Data/LOB.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+#include "Poco/DateTime.h"
+#include "Poco/Exception.h"
+#include <sql.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+Binder::Binder(const StatementHandle& rStmt,
+	std::size_t maxFieldSize,
+	Binder::ParameterBinding dataBinding,
+	TypeInfo* pDataTypes):
+	_rStmt(rStmt),
+	_paramBinding(dataBinding),
+	_pTypeInfo(pDataTypes),
+	_paramSetSize(0),
+	_maxFieldSize(maxFieldSize)
+{
+}
+
+
+Binder::~Binder()
+{
+	freeMemory();
+}
+
+
+void Binder::freeMemory()
+{
+	LengthPtrVec::iterator itLen = _lengthIndicator.begin();
+	LengthPtrVec::iterator itLenEnd = _lengthIndicator.end();
+	for(; itLen != itLenEnd; ++itLen) delete *itLen;
+
+	LengthVecVec::iterator itVecLen = _vecLengthIndicator.begin();
+	LengthVecVec::iterator itVecLenEnd = _vecLengthIndicator.end();
+	for (; itVecLen != itVecLenEnd; ++itVecLen) delete *itVecLen;
+
+	TimeMap::iterator itT = _times.begin();
+	TimeMap::iterator itTEnd = _times.end();
+	for(; itT != itTEnd; ++itT) delete itT->first;
+
+	DateMap::iterator itD = _dates.begin();
+	DateMap::iterator itDEnd = _dates.end();
+	for(; itD != itDEnd; ++itD) delete itD->first;
+
+	TimestampMap::iterator itTS = _timestamps.begin();
+	TimestampMap::iterator itTSEnd = _timestamps.end();
+	for(; itTS != itTSEnd; ++itTS) delete itTS->first;
+
+	StringMap::iterator itStr = _strings.begin();
+	StringMap::iterator itStrEnd = _strings.end();
+	for(; itStr != itStrEnd; ++itStr) std::free(itStr->first);
+
+	CharPtrVec::iterator itChr = _charPtrs.begin();
+	CharPtrVec::iterator endChr = _charPtrs.end();
+	for (; itChr != endChr; ++itChr) std::free(*itChr);
+
+	UTF16CharPtrVec::iterator itUTF16Chr = _utf16CharPtrs.begin();
+	UTF16CharPtrVec::iterator endUTF16Chr = _utf16CharPtrs.end();
+	for (; itUTF16Chr != endUTF16Chr; ++itUTF16Chr) std::free(*itUTF16Chr);
+
+	BoolPtrVec::iterator itBool = _boolPtrs.begin();
+	BoolPtrVec::iterator endBool = _boolPtrs.end();
+	for (; itBool != endBool; ++itBool) delete [] *itBool;
+
+	DateVecVec::iterator itDateVec = _dateVecVec.begin();
+	DateVecVec::iterator itDateVecEnd = _dateVecVec.end();
+	for (; itDateVec != itDateVecEnd; ++itDateVec) delete *itDateVec;
+
+	TimeVecVec::iterator itTimeVec = _timeVecVec.begin();
+	TimeVecVec::iterator itTimeVecEnd = _timeVecVec.end();
+	for (; itTimeVec != itTimeVecEnd; ++itTimeVec) delete *itTimeVec;
+
+	DateTimeVecVec::iterator itDateTimeVec = _dateTimeVecVec.begin();
+	DateTimeVecVec::iterator itDateTimeVecEnd = _dateTimeVecVec.end();
+	for (; itDateTimeVec != itDateTimeVecEnd; ++itDateTimeVec) delete *itDateTimeVec;
+}
+
+
+void Binder::bind(std::size_t pos, const std::string& val, Direction dir)
+{
+	SQLPOINTER pVal = 0;
+	SQLINTEGER size = (SQLINTEGER) val.size();
+	SQLINTEGER colSize = 0;
+	SQLSMALLINT decDigits = 0;
+	getColSizeAndPrecision(pos, SQL_C_CHAR, colSize, decDigits, val.size());
+
+	if (isOutBound(dir))
+	{
+		getColumnOrParameterSize(pos, size);
+		char* pChar = (char*) std::calloc(size, sizeof(char));
+		pVal = (SQLPOINTER) pChar;
+		_outParams.insert(ParamMap::value_type(pVal, size));
+		_strings.insert(StringMap::value_type(pChar, const_cast<std::string*>(&val)));
+	}
+	else if (isInBound(dir))
+	{
+		pVal = (SQLPOINTER) val.c_str();
+		_inParams.insert(ParamMap::value_type(pVal, size));
+	}
+	else
+		throw InvalidArgumentException("Parameter must be [in] OR [out] bound.");
+
+	SQLLEN* pLenIn = new SQLLEN(SQL_NTS);
+
+	if (PB_AT_EXEC == _paramBinding)
+		*pLenIn = SQL_LEN_DATA_AT_EXEC(size);
+
+	_lengthIndicator.push_back(pLenIn);
+
+	if (Utility::isError(SQLBindParameter(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		toODBCDirection(dir), 
+		SQL_C_CHAR, 
+		Connector::stringBoundToLongVarChar() ? SQL_LONGVARCHAR : SQL_VARCHAR, 
+		(SQLUINTEGER) colSize,
+		0,
+		pVal, 
+		(SQLINTEGER) size, 
+		_lengthIndicator.back())))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter(std::string)");
+	}
+}
+
+
+void Binder::bind(std::size_t pos, const UTF16String& val, Direction dir)
+{
+	typedef UTF16String::value_type CharT;
+
+	SQLPOINTER pVal = 0;
+	SQLINTEGER size = (SQLINTEGER)(val.size() * sizeof(CharT));
+	SQLINTEGER colSize = 0;
+	SQLSMALLINT decDigits = 0;
+	getColSizeAndPrecision(pos, SQL_C_WCHAR, colSize, decDigits);
+
+	if (isOutBound(dir))
+	{
+		getColumnOrParameterSize(pos, size);
+		CharT* pChar = (CharT*)std::calloc(size, 1);
+		pVal = (SQLPOINTER)pChar;
+		_outParams.insert(ParamMap::value_type(pVal, size));
+		_utf16Strings.insert(UTF16StringMap::value_type(pChar, const_cast<UTF16String*>(&val)));
+	}
+	else if (isInBound(dir))
+	{
+		pVal = (SQLPOINTER)val.c_str();
+		_inParams.insert(ParamMap::value_type(pVal, size));
+	}
+	else
+		throw InvalidArgumentException("Parameter must be [in] OR [out] bound.");
+
+	SQLLEN* pLenIn = new SQLLEN(SQL_NTS);
+
+	if (PB_AT_EXEC == _paramBinding)
+	{
+		*pLenIn = SQL_LEN_DATA_AT_EXEC(size);
+	}
+
+	_lengthIndicator.push_back(pLenIn);
+
+	if (Utility::isError(SQLBindParameter(_rStmt,
+		(SQLUSMALLINT)pos + 1,
+		toODBCDirection(dir),
+		SQL_C_WCHAR,
+		SQL_WLONGVARCHAR,
+		(SQLUINTEGER)colSize,
+		0,
+		pVal,
+		(SQLINTEGER)size,
+		_lengthIndicator.back())))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter(std::string)");
+	}
+}
+
+
+void Binder::bind(std::size_t pos, const Date& val, Direction dir)
+{
+	SQLINTEGER size = (SQLINTEGER) sizeof(SQL_DATE_STRUCT);
+	SQLLEN* pLenIn = new SQLLEN;
+	*pLenIn  = size;
+
+	_lengthIndicator.push_back(pLenIn);
+
+	SQL_DATE_STRUCT* pDS = new SQL_DATE_STRUCT;
+	Utility::dateSync(*pDS, val);
+	
+	_dates.insert(DateMap::value_type(pDS, const_cast<Date*>(&val)));
+
+	SQLINTEGER colSize = 0;
+	SQLSMALLINT decDigits = 0;
+	getColSizeAndPrecision(pos, SQL_TYPE_DATE, colSize, decDigits);
+
+	if (Utility::isError(SQLBindParameter(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		toODBCDirection(dir), 
+		SQL_C_TYPE_DATE, 
+		SQL_TYPE_DATE, 
+		colSize,
+		decDigits,
+		(SQLPOINTER) pDS, 
+		0, 
+		_lengthIndicator.back())))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter(Date)");
+	}
+}
+
+
+void Binder::bind(std::size_t pos, const Time& val, Direction dir)
+{
+	SQLINTEGER size = (SQLINTEGER) sizeof(SQL_TIME_STRUCT);
+	SQLLEN* pLenIn = new SQLLEN;
+	*pLenIn  = size;
+
+	_lengthIndicator.push_back(pLenIn);
+
+	SQL_TIME_STRUCT* pTS = new SQL_TIME_STRUCT;
+	Utility::timeSync(*pTS, val);
+	
+	_times.insert(TimeMap::value_type(pTS, const_cast<Time*>(&val)));
+
+	SQLINTEGER colSize = 0;
+	SQLSMALLINT decDigits = 0;
+	getColSizeAndPrecision(pos, SQL_TYPE_TIME, colSize, decDigits);
+
+	if (Utility::isError(SQLBindParameter(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		toODBCDirection(dir), 
+		SQL_C_TYPE_TIME, 
+		SQL_TYPE_TIME, 
+		colSize,
+		decDigits,
+		(SQLPOINTER) pTS, 
+		0, 
+		_lengthIndicator.back())))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter(Time)");
+	}
+}
+
+
+void Binder::bind(std::size_t pos, const Poco::DateTime& val, Direction dir)
+{
+	SQLINTEGER size = (SQLINTEGER) sizeof(SQL_TIMESTAMP_STRUCT);
+	SQLLEN* pLenIn = new SQLLEN;
+	*pLenIn  = size;
+
+	_lengthIndicator.push_back(pLenIn);
+
+	SQL_TIMESTAMP_STRUCT* pTS = new SQL_TIMESTAMP_STRUCT;
+	Utility::dateTimeSync(*pTS, val);
+
+	_timestamps.insert(TimestampMap::value_type(pTS, const_cast<DateTime*>(&val)));
+
+	SQLINTEGER colSize = 0;
+	SQLSMALLINT decDigits = 0;
+	getColSizeAndPrecision(pos, SQL_TYPE_TIMESTAMP, colSize, decDigits);
+
+	if (Utility::isError(SQLBindParameter(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		toODBCDirection(dir), 
+		SQL_C_TYPE_TIMESTAMP, 
+		SQL_TYPE_TIMESTAMP, 
+		colSize,
+		decDigits,
+		(SQLPOINTER) pTS, 
+		0, 
+		_lengthIndicator.back())))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter(DateTime)");
+	}
+}
+
+
+void Binder::bind(std::size_t pos, const NullData& val, Direction dir)
+{
+	if (isOutBound(dir) || !isInBound(dir))
+		throw NotImplementedException("NULL parameter type can only be inbound.");
+
+	_inParams.insert(ParamMap::value_type(SQLPOINTER(0), SQLINTEGER(0)));
+
+	SQLLEN* pLenIn = new SQLLEN;
+	*pLenIn  = SQL_NULL_DATA;
+
+	_lengthIndicator.push_back(pLenIn);
+
+	SQLINTEGER colSize = 0;
+	SQLSMALLINT decDigits = 0;
+	getColSizeAndPrecision(pos, SQL_C_STINYINT, colSize, decDigits);
+
+	if (Utility::isError(SQLBindParameter(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		SQL_PARAM_INPUT, 
+		SQL_C_STINYINT, 
+		Utility::sqlDataType(SQL_C_STINYINT), 
+		colSize,
+		decDigits,
+		0, 
+		0, 
+		_lengthIndicator.back())))
+	{
+		throw StatementException(_rStmt, "SQLBindParameter()");
+	}
+}
+
+
+std::size_t Binder::parameterSize(SQLPOINTER pAddr) const
+{
+	ParamMap::const_iterator it = _inParams.find(pAddr);
+	if (it != _inParams.end()) return it->second;
+
+	it = _outParams.find(pAddr);
+	if (it != _outParams.end()) return it->second;
+	
+	throw NotFoundException("Requested data size not found.");
+}
+
+
+void Binder::bind(std::size_t pos, const char* const &pVal, Direction dir)
+{
+	throw NotImplementedException("char* binding not implemented, Use std::string instead.");
+}
+
+
+SQLSMALLINT Binder::toODBCDirection(Direction dir) const
+{
+	bool in = isInBound(dir);
+	bool out = isOutBound(dir);
+	SQLSMALLINT ioType = SQL_PARAM_TYPE_UNKNOWN;
+	if (in && out) ioType = SQL_PARAM_INPUT_OUTPUT; 
+	else if(in)    ioType = SQL_PARAM_INPUT;
+	else if(out)   ioType = SQL_PARAM_OUTPUT;
+	else throw Poco::IllegalStateException("Binder not bound (must be [in] OR [out]).");
+
+	return ioType;
+}
+
+
+void Binder::synchronize()
+{
+	if (_dates.size())
+	{
+		DateMap::iterator it = _dates.begin();
+		DateMap::iterator end = _dates.end();
+		for(; it != end; ++it) 
+			Utility::dateSync(*it->second, *it->first);
+	}
+
+	if (_times.size())
+	{
+		TimeMap::iterator it = _times.begin();
+		TimeMap::iterator end = _times.end();
+		for(; it != end; ++it) 
+			Utility::timeSync(*it->second, *it->first);
+	}
+
+	if (_timestamps.size())
+	{
+		TimestampMap::iterator it = _timestamps.begin();
+		TimestampMap::iterator end = _timestamps.end();
+		for(; it != end; ++it) 
+			Utility::dateTimeSync(*it->second, *it->first);
+	}
+
+	if (_strings.size())
+	{
+		StringMap::iterator it = _strings.begin();
+		StringMap::iterator end = _strings.end();
+		for(; it != end; ++it)
+			it->second->assign(it->first, std::strlen(it->first));
+	}
+}
+
+
+void Binder::reset()
+{
+	freeMemory();
+	LengthPtrVec().swap(_lengthIndicator);
+	_inParams.clear();
+	_outParams.clear();
+	_dates.clear();
+	_times.clear();
+	_timestamps.clear();
+	_strings.clear();
+	_dateVecVec.clear();
+	_timeVecVec.clear();
+	_dateTimeVecVec.clear();
+	_charPtrs.clear();
+	_boolPtrs.clear();
+	_containers.clear();
+	_paramSetSize = 0;
+}
+
+
+void Binder::getColSizeAndPrecision(std::size_t pos, 
+	SQLSMALLINT cDataType, 
+	SQLINTEGER& colSize, 
+	SQLSMALLINT& decDigits,
+	std::size_t actualSize)
+{
+	// Not all drivers are equally willing to cooperate in this matter.
+	// Hence the funky flow control.
+	DynamicAny tmp;
+	bool found(false);
+	if (_pTypeInfo)
+	{
+		found = _pTypeInfo->tryGetInfo(cDataType, "COLUMN_SIZE", tmp);
+		if (found) colSize = tmp;
+		if (actualSize > colSize)
+		{
+			throw LengthExceededException(Poco::format("Error binding column %z size=%z, max size=%ld)",
+					pos, actualSize, static_cast<long>(colSize)));
+		}
+		found = _pTypeInfo->tryGetInfo(cDataType, "MINIMUM_SCALE", tmp);
+		if (found)
+		{
+			decDigits = tmp;
+			return;
+		}
+	}
+
+	try
+	{
+		Parameter p(_rStmt, pos);
+		colSize = (SQLINTEGER) p.columnSize();
+		decDigits = (SQLSMALLINT) p.decimalDigits();
+		return;
+	} 
+	catch (StatementException&)
+	{ 
+	}
+
+	try
+	{
+		ODBCMetaColumn c(_rStmt, pos);
+		colSize = (SQLINTEGER) c.length();
+		decDigits = (SQLSMALLINT) c.precision();
+		return;
+	} 
+	catch (StatementException&) 
+	{ 
+	}
+
+	// last check, just in case
+	if ((0 != colSize) && (actualSize > colSize))
+	{
+		throw LengthExceededException(Poco::format("Error binding column %z size=%z, max size=%ld)",
+				pos, actualSize, static_cast<long>(colSize)));
+	}
+
+	// no success, set to zero and hope for the best
+	// (most drivers do not require these most of the times anyway)
+	colSize = 0;
+	decDigits = 0;
+	return;
+}
+
+
+void Binder::getColumnOrParameterSize(std::size_t pos, SQLINTEGER& size)
+{
+	std::size_t colSize = 0;
+	std::size_t paramSize = 0;
+
+	try
+	{
+		ODBCMetaColumn col(_rStmt, pos);
+		colSize = col.length();
+	}
+	catch (StatementException&) { }
+
+	try
+	{
+		Parameter p(_rStmt, pos);
+		paramSize = p.columnSize();
+	}
+	catch (StatementException&)
+	{
+		size = DEFAULT_PARAM_SIZE;
+//On Linux, PostgreSQL driver segfaults on SQLGetDescField, so this is disabled for now
+#ifdef POCO_OS_FAMILY_WINDOWS
+		SQLHDESC hIPD = 0;
+		if (!Utility::isError(SQLGetStmtAttr(_rStmt, SQL_ATTR_IMP_PARAM_DESC, &hIPD, SQL_IS_POINTER, 0)))
+		{
+			SQLUINTEGER sz = 0;
+			if (!Utility::isError(SQLGetDescField(hIPD, (SQLSMALLINT) pos + 1, SQL_DESC_LENGTH, &sz, SQL_IS_UINTEGER, 0)) && 
+				sz > 0)
+			{
+				size = sz;
+			}
+		}
+#endif
+	}
+
+	if (colSize > 0 && paramSize > 0)
+		size = colSize < paramSize ? static_cast<SQLINTEGER>(colSize) : static_cast<SQLINTEGER>(paramSize);
+	else if (colSize > 0)
+		size = static_cast<SQLINTEGER>(colSize);
+	else if (paramSize > 0)
+		size = static_cast<SQLINTEGER>(paramSize);
+
+	if (size > _maxFieldSize) size = static_cast<SQLINTEGER>(_maxFieldSize);
+}
+
+
+void Binder::setParamSetSize(std::size_t length)
+{
+	if (0 == _paramSetSize)
+	{
+		if (Utility::isError(Poco::Data::ODBC::SQLSetStmtAttr(_rStmt, SQL_ATTR_PARAM_BIND_TYPE, SQL_PARAM_BIND_BY_COLUMN, SQL_IS_UINTEGER)) ||  
+			Utility::isError(Poco::Data::ODBC::SQLSetStmtAttr(_rStmt, SQL_ATTR_PARAMSET_SIZE, (SQLPOINTER) length, SQL_IS_UINTEGER)))
+				throw StatementException(_rStmt, "SQLSetStmtAttr()");
+
+		_paramSetSize = static_cast<SQLINTEGER>(length);
+	}
+}
+
+
+} } } // namespace Poco::Data::ODBC
diff --git a/base/poco/Data/ODBC/src/ConnectionHandle.cpp b/base/poco/Data/ODBC/src/ConnectionHandle.cpp
new file mode 100644
index 00000000000..065031bb497
--- /dev/null
+++ b/base/poco/Data/ODBC/src/ConnectionHandle.cpp
@@ -0,0 +1,57 @@
+//
+// ConnectionHandle.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  ConnectionHandle
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/ConnectionHandle.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+ConnectionHandle::ConnectionHandle(EnvironmentHandle* pEnvironment): 
+	_pEnvironment(pEnvironment ? pEnvironment : new EnvironmentHandle),
+	_hdbc(SQL_NULL_HDBC), 
+	_ownsEnvironment(pEnvironment ? false : true)
+{
+	if (Utility::isError(SQLAllocHandle(SQL_HANDLE_DBC, 
+		_pEnvironment->handle(), 
+		&_hdbc))) 
+	{
+		throw ODBCException("Could not allocate connection handle.");
+	}
+}
+
+
+ConnectionHandle::~ConnectionHandle()
+{
+	try
+	{
+		SQLDisconnect(_hdbc);
+		SQLRETURN rc = SQLFreeHandle(SQL_HANDLE_DBC, _hdbc);
+
+		if (_ownsEnvironment) delete _pEnvironment;
+
+		poco_assert (!Utility::isError(rc));
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+} } } // namespace Poco::Data::ODBC
diff --git a/base/poco/Data/ODBC/src/Connector.cpp b/base/poco/Data/ODBC/src/Connector.cpp
new file mode 100644
index 00000000000..9fb71822bb8
--- /dev/null
+++ b/base/poco/Data/ODBC/src/Connector.cpp
@@ -0,0 +1,64 @@
+//
+// Connector.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Connector
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/Connector.h"
+#include "Poco/Data/ODBC/SessionImpl.h"
+#include "Poco/Data/SessionFactory.h"
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+const std::string Connector::KEY("ODBC");
+bool Connector::_bindStringToLongVarChar(true);
+
+
+Connector::Connector()
+{
+}
+
+
+Connector::~Connector()
+{
+}
+
+
+Poco::AutoPtr<Poco::Data::SessionImpl> Connector::createSession(const std::string& connectionString,
+	std::size_t timeout)
+{
+	return Poco::AutoPtr<Poco::Data::SessionImpl>(new SessionImpl(connectionString, timeout));
+}
+
+
+void Connector::registerConnector()
+{
+	Poco::Data::SessionFactory::instance().add(new Connector());
+}
+
+
+void Connector::unregisterConnector()
+{
+	Poco::Data::SessionFactory::instance().remove(KEY);
+}
+
+
+void Connector::bindStringToLongVarChar(bool flag)
+{
+	_bindStringToLongVarChar = flag;
+}
+
+
+} } } // namespace Poco::Data::ODBC
diff --git a/base/poco/Data/ODBC/src/EnvironmentHandle.cpp b/base/poco/Data/ODBC/src/EnvironmentHandle.cpp
new file mode 100644
index 00000000000..61ce83f3d2c
--- /dev/null
+++ b/base/poco/Data/ODBC/src/EnvironmentHandle.cpp
@@ -0,0 +1,54 @@
+//
+// EnvironmentHandle.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  EnvironmentHandle
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/EnvironmentHandle.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+EnvironmentHandle::EnvironmentHandle(): _henv(SQL_NULL_HENV)
+{
+	if (Utility::isError(SQLAllocHandle(SQL_HANDLE_ENV, 
+			SQL_NULL_HANDLE, 
+			&_henv)) ||
+		Utility::isError(SQLSetEnvAttr(_henv, 
+			SQL_ATTR_ODBC_VERSION, 
+			(SQLPOINTER) SQL_OV_ODBC3, 
+			0)))
+	{
+		throw ODBCException("Could not initialize environment.");
+	}
+}
+
+
+EnvironmentHandle::~EnvironmentHandle()
+{
+	try
+	{
+		SQLRETURN rc = SQLFreeHandle(SQL_HANDLE_ENV, _henv);
+		poco_assert (!Utility::isError(rc));
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+} } } // namespace Poco::Data::ODBC
diff --git a/base/poco/Data/ODBC/src/Extractor.cpp b/base/poco/Data/ODBC/src/Extractor.cpp
new file mode 100644
index 00000000000..0961fa2b529
--- /dev/null
+++ b/base/poco/Data/ODBC/src/Extractor.cpp
@@ -0,0 +1,1312 @@
+//
+// Extractor.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Extractor
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/Extractor.h"
+#include "Poco/Data/ODBC/ODBCMetaColumn.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+#include "Poco/Data/LOB.h"
+#include "Poco/Buffer.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+const std::string Extractor::FLD_SIZE_EXCEEDED_FMT = "Specified data size (%z bytes) "
+	"exceeds maximum value (%z).\n"
+	"Use Session.setProperty(\"maxFieldSize\", value) "
+	"to increase the maximum allowed data size\n";
+
+
+Extractor::Extractor(const StatementHandle& rStmt, 
+	Preparator::Ptr pPreparator): 
+	_rStmt(rStmt), 
+	_pPreparator(pPreparator),
+	_dataExtraction(pPreparator->getDataExtraction())
+{
+}
+
+
+Extractor::~Extractor()
+{
+}
+
+
+template<>
+bool Extractor::extractBoundImpl<std::string>(std::size_t pos, std::string& val)
+{
+	if (isNull(pos)) return false;
+
+	std::size_t dataSize = _pPreparator->actualDataSize(pos);
+	char* sp = AnyCast<char*>(_pPreparator->at(pos));
+	std::size_t len = std::strlen(sp);
+	if (len < dataSize) dataSize = len;
+	checkDataSize(dataSize);
+	val.assign(sp, dataSize);
+
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImpl<UTF16String>(std::size_t pos, UTF16String& val)
+{
+	typedef UTF16String::value_type CharT;
+	if (isNull(pos)) return false;
+	std::size_t dataSize = _pPreparator->actualDataSize(pos);
+	CharT* sp = AnyCast<CharT*>(_pPreparator->at(pos));
+	std::size_t len = Poco::UnicodeConverter::UTFStrlen(sp);
+	if (len < dataSize) dataSize = len;
+	checkDataSize(dataSize);
+	val.assign(sp, dataSize);
+
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImpl<Poco::Data::Date>(std::size_t pos, Poco::Data::Date& val)
+{
+	if (isNull(pos)) return false;
+	SQL_DATE_STRUCT& ds = *AnyCast<SQL_DATE_STRUCT>(&(_pPreparator->at(pos)));
+	Utility::dateSync(val, ds);
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImplContainer<std::vector<Poco::Data::Date> >(std::size_t pos, 
+	std::vector<Poco::Data::Date>& val)
+{
+	std::vector<SQL_DATE_STRUCT>& ds = RefAnyCast<std::vector<SQL_DATE_STRUCT> >(_pPreparator->at(pos));
+	Utility::dateSync(val, ds);
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImplContainer<std::deque<Poco::Data::Date> >(std::size_t pos, 
+	std::deque<Poco::Data::Date>& val)
+{
+	std::vector<SQL_DATE_STRUCT>& ds = RefAnyCast<std::vector<SQL_DATE_STRUCT> >(_pPreparator->at(pos));
+	Utility::dateSync(val, ds);
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImplContainer<std::list<Poco::Data::Date> >(std::size_t pos, 
+	std::list<Poco::Data::Date>& val)
+{
+	std::vector<SQL_DATE_STRUCT>& ds = RefAnyCast<std::vector<SQL_DATE_STRUCT> >(_pPreparator->at(pos));
+	Utility::dateSync(val, ds);
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImpl<Poco::Data::Time>(std::size_t pos, Poco::Data::Time& val)
+{
+	if (isNull(pos)) return false;
+
+	std::size_t dataSize = _pPreparator->actualDataSize(pos);
+	checkDataSize(dataSize);
+	SQL_TIME_STRUCT& ts = *AnyCast<SQL_TIME_STRUCT>(&_pPreparator->at(pos));
+	Utility::timeSync(val, ts);
+
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImplContainer<std::vector<Poco::Data::Time> >(std::size_t pos, 
+	std::vector<Poco::Data::Time>& val)
+{
+	std::vector<SQL_TIME_STRUCT>& ds = RefAnyCast<std::vector<SQL_TIME_STRUCT> >(_pPreparator->at(pos));
+	Utility::timeSync(val, ds);
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImplContainer<std::deque<Poco::Data::Time> >(std::size_t pos, 
+	std::deque<Poco::Data::Time>& val)
+{
+	std::vector<SQL_TIME_STRUCT>& ds = RefAnyCast<std::vector<SQL_TIME_STRUCT> >(_pPreparator->at(pos));
+	Utility::timeSync(val, ds);
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImplContainer<std::list<Poco::Data::Time> >(std::size_t pos, 
+	std::list<Poco::Data::Time>& val)
+{
+	std::vector<SQL_TIME_STRUCT>& ds = RefAnyCast<std::vector<SQL_TIME_STRUCT> >(_pPreparator->at(pos));
+	Utility::timeSync(val, ds);
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImpl<Poco::DateTime>(std::size_t pos, Poco::DateTime& val)
+{
+	if (isNull(pos)) return false;
+
+	std::size_t dataSize = _pPreparator->actualDataSize(pos);
+	checkDataSize(dataSize);
+	SQL_TIMESTAMP_STRUCT& tss = *AnyCast<SQL_TIMESTAMP_STRUCT>(&_pPreparator->at(pos));
+	Utility::dateTimeSync(val, tss);
+
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImplContainer<std::vector<Poco::DateTime> >(std::size_t pos, 
+	std::vector<Poco::DateTime>& val)
+{
+	std::vector<SQL_TIMESTAMP_STRUCT>& ds = RefAnyCast<std::vector<SQL_TIMESTAMP_STRUCT> >(_pPreparator->at(pos));
+	Utility::dateTimeSync(val, ds);
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImplContainer<std::deque<Poco::DateTime> >(std::size_t pos, 
+	std::deque<Poco::DateTime>& val)
+{
+	std::vector<SQL_TIMESTAMP_STRUCT>& ds = RefAnyCast<std::vector<SQL_TIMESTAMP_STRUCT> >(_pPreparator->at(pos));
+	Utility::dateTimeSync(val, ds);
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImplContainer<std::list<Poco::DateTime> >(std::size_t pos, 
+	std::list<Poco::DateTime>& val)
+{
+	std::vector<SQL_TIMESTAMP_STRUCT>& ds = RefAnyCast<std::vector<SQL_TIMESTAMP_STRUCT> >(_pPreparator->at(pos));
+	Utility::dateTimeSync(val, ds);
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImplContainer<std::vector<bool> >(std::size_t pos, 
+	std::vector<bool>& val)
+{
+	std::size_t length = _pPreparator->getLength();
+	bool** p = AnyCast<bool*>(&_pPreparator->at(pos));
+	val.assign(*p, *p + length);
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImplContainer<std::deque<bool> >(std::size_t pos, 
+	std::deque<bool>& val)
+{
+	std::size_t length = _pPreparator->getLength();
+	bool** p = AnyCast<bool*>(&_pPreparator->at(pos));
+	val.assign(*p, *p + length);
+	return true;
+}
+
+
+template<>
+bool Extractor::extractBoundImplContainer<std::list<bool> >(std::size_t pos, 
+	std::list<bool>& val)
+{
+	std::size_t length = _pPreparator->getLength();
+	bool** p = AnyCast<bool*>(&_pPreparator->at(pos));
+	val.assign(*p, *p + length);
+	return true;
+}
+
+
+template<>
+bool Extractor::extractManualImpl<std::string>(std::size_t pos, std::string& val, SQLSMALLINT cType)
+{
+	std::size_t maxSize = _pPreparator->getMaxFieldSize();
+	std::size_t fetchedSize = 0;
+	std::size_t totalSize = 0;
+	
+	SQLLEN len;
+	const int bufSize = CHUNK_SIZE;
+	Poco::Buffer<char> apChar(bufSize);
+	char* pChar = apChar.begin();
+	SQLRETURN rc = 0;
+	
+	val.clear();
+	resizeLengths(pos);
+
+	do
+	{
+		std::memset(pChar, 0, bufSize);
+		len = 0;
+		rc = SQLGetData(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			cType, //C data type
+			pChar, //returned value
+			bufSize, //buffer length
+			&len); //length indicator
+
+		if (SQL_NO_DATA != rc && Utility::isError(rc))
+			throw StatementException(_rStmt, "SQLGetData()");
+
+		if (SQL_NO_TOTAL == len)//unknown length, throw
+			throw UnknownDataLengthException("Could not determine returned data length.");
+
+		if (isNullLengthIndicator(len))
+		{
+			_lengths[pos] = len;
+			return false;
+		}
+
+		if (SQL_NO_DATA == rc || !len)
+			break;
+
+		_lengths[pos] += len;
+		fetchedSize = _lengths[pos] > CHUNK_SIZE ? CHUNK_SIZE : _lengths[pos];
+		totalSize += fetchedSize;
+		if (totalSize <= maxSize) 
+			val.append(pChar, fetchedSize);
+		else 
+			throw DataException(format(FLD_SIZE_EXCEEDED_FMT, fetchedSize, maxSize));
+	}while (true);
+
+	return true;
+}
+
+
+template<>
+bool Extractor::extractManualImpl<UTF16String>(std::size_t pos, UTF16String& val, SQLSMALLINT cType)
+{
+	std::size_t maxSize = _pPreparator->getMaxFieldSize();
+	std::size_t fetchedSize = 0;
+	std::size_t totalSize = 0;
+
+	SQLLEN len;
+	const int bufSize = CHUNK_SIZE;
+	Poco::Buffer<UTF16String::value_type> apChar(bufSize);
+	UTF16String::value_type* pChar = apChar.begin();
+	SQLRETURN rc = 0;
+
+	val.clear();
+	resizeLengths(pos);
+
+	do
+	{
+		std::memset(pChar, 0, bufSize);
+		len = 0;
+		rc = SQLGetData(_rStmt,
+			(SQLUSMALLINT)pos + 1,
+			cType, //C data type
+			pChar, //returned value
+			bufSize, //buffer length
+			&len); //length indicator
+
+		if (SQL_NO_DATA != rc && Utility::isError(rc))
+			throw StatementException(_rStmt, "SQLGetData()");
+
+		if (SQL_NO_TOTAL == len)//unknown length, throw
+			throw UnknownDataLengthException("Could not determine returned data length.");
+
+		if (isNullLengthIndicator(len))
+		{
+			_lengths[pos] = len;
+			return false;
+		}
+
+		if (SQL_NO_DATA == rc || !len)
+			break;
+
+		_lengths[pos] += len;
+		fetchedSize = _lengths[pos] > CHUNK_SIZE ? CHUNK_SIZE : _lengths[pos];
+		totalSize += fetchedSize;
+		if (totalSize <= maxSize)
+			val.append(pChar, fetchedSize / sizeof(UTF16Char));
+		else
+			throw DataException(format(FLD_SIZE_EXCEEDED_FMT, fetchedSize, maxSize));
+	} while (true);
+
+	return true;
+}
+
+
+template<>
+bool Extractor::extractManualImpl<Poco::Data::CLOB>(std::size_t pos, 
+	Poco::Data::CLOB& val, 
+	SQLSMALLINT cType)
+{
+	std::size_t maxSize = _pPreparator->getMaxFieldSize();
+	std::size_t fetchedSize = 0;
+	std::size_t totalSize = 0;
+
+	SQLLEN len;
+	const int bufSize = CHUNK_SIZE;
+	Poco::Buffer<char> apChar(bufSize);
+	char* pChar = apChar.begin();
+	SQLRETURN rc = 0;
+	
+	val.clear();
+	resizeLengths(pos);
+
+	do
+	{
+		std::memset(pChar, 0, bufSize);
+		len = 0;
+		rc = SQLGetData(_rStmt, 
+			(SQLUSMALLINT) pos + 1, 
+			cType, //C data type
+			pChar, //returned value
+			bufSize, //buffer length
+			&len); //length indicator
+		
+		_lengths[pos] += len;
+
+		if (SQL_NO_DATA != rc && Utility::isError(rc))
+			throw StatementException(_rStmt, "SQLGetData()");
+
+		if (SQL_NO_TOTAL == len)//unknown length, throw
+			throw UnknownDataLengthException("Could not determine returned data length.");
+
+		if (isNullLengthIndicator(len))
+			return false;
+
+		if (SQL_NO_DATA == rc || !len)
+			break;
+
+		fetchedSize = len > CHUNK_SIZE ? CHUNK_SIZE : len;
+		totalSize += fetchedSize;
+		if (totalSize <= maxSize) 
+			val.appendRaw(pChar, fetchedSize);
+		else 
+			throw DataException(format(FLD_SIZE_EXCEEDED_FMT, fetchedSize, maxSize));
+
+	}while (true);
+
+	return true;
+}
+
+
+template<>
+bool Extractor::extractManualImpl<Poco::Data::Date>(std::size_t pos, 
+	Poco::Data::Date& val, 
+	SQLSMALLINT cType)
+{
+	SQL_DATE_STRUCT ds;
+	resizeLengths(pos);
+
+	SQLRETURN rc = SQLGetData(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		cType, //C data type
+		&ds, //returned value
+		sizeof(ds), //buffer length
+		&_lengths[pos]); //length indicator
+	
+	if (Utility::isError(rc))
+		throw StatementException(_rStmt, "SQLGetData()");
+
+	if (isNullLengthIndicator(_lengths[pos])) 
+		return false;
+	else 
+		Utility::dateSync(val, ds);
+
+	return true;
+}
+
+
+template<>
+bool Extractor::extractManualImpl<Poco::Data::Time>(std::size_t pos, 
+	Poco::Data::Time& val, 
+	SQLSMALLINT cType)
+{
+	SQL_TIME_STRUCT ts;
+	resizeLengths(pos);
+
+	SQLRETURN rc = SQLGetData(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		cType, //C data type
+		&ts, //returned value
+		sizeof(ts), //buffer length
+		&_lengths[pos]); //length indicator
+	
+	if (Utility::isError(rc))
+		throw StatementException(_rStmt, "SQLGetData()");
+
+	if (isNullLengthIndicator(_lengths[pos])) 
+		return false;
+	else 
+		Utility::timeSync(val, ts);
+
+	return true;
+}
+
+
+template<>
+bool Extractor::extractManualImpl<Poco::DateTime>(std::size_t pos, 
+	Poco::DateTime& val, 
+	SQLSMALLINT cType)
+{
+	SQL_TIMESTAMP_STRUCT ts;
+	resizeLengths(pos);
+
+	SQLRETURN rc = SQLGetData(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		cType, //C data type
+		&ts, //returned value
+		sizeof(ts), //buffer length
+		&_lengths[pos]); //length indicator
+	
+	if (Utility::isError(rc))
+		throw StatementException(_rStmt, "SQLGetData()");
+
+	if (isNullLengthIndicator(_lengths[pos])) 
+		return false;
+	else 
+		Utility::dateTimeSync(val, ts);
+
+	return true;
+}
+
+
+bool Extractor::extract(std::size_t pos, Poco::Int32& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_SLONG);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<Poco::Int32>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<Poco::Int32>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<Poco::Int32>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, Poco::Int64& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_SBIGINT);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<Poco::Int64>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<Poco::Int64>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<Poco::Int64>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+#ifndef POCO_LONG_IS_64_BIT
+bool Extractor::extract(std::size_t pos, long& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_SLONG);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, unsigned long& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_SLONG);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<long>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<long>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<long>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+#endif
+
+
+bool Extractor::extract(std::size_t pos, double& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_DOUBLE);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<double>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<double>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<double>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::string& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_CHAR);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<std::string>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<std::string>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<std::string>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, UTF16String& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_WCHAR);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<UTF16String>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<UTF16String>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<UTF16String>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, Poco::Data::BLOB& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_BINARY);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, Poco::Data::CLOB& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_BINARY);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<Poco::Data::BLOB>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<Poco::Data::BLOB>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<Poco::Data::BLOB>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<Poco::Data::CLOB>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<Poco::Data::CLOB>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<Poco::Data::CLOB>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, Poco::Data::Date& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_TYPE_DATE);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<Poco::Data::Date>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<Poco::Data::Date>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<Poco::Data::Date>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, Poco::Data::Time& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_TYPE_TIME);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<Poco::Data::Time>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<Poco::Data::Time>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<Poco::Data::Time>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, Poco::DateTime& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_TYPE_TIMESTAMP);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<Poco::DateTime>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<Poco::DateTime>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<Poco::DateTime>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, Poco::Int8& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_STINYINT);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<Poco::Int8>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<Poco::Int8>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<Poco::Int8>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, Poco::UInt8& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_UTINYINT);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<Poco::UInt8>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<Poco::UInt8>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<Poco::UInt8>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, Poco::Int16& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_SSHORT);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<Poco::Int16>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<Poco::Int16>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<Poco::Int16>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, Poco::UInt16& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_USHORT);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<Poco::UInt16>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<Poco::UInt16>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<Poco::UInt16>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, Poco::UInt32& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_ULONG);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<Poco::UInt32>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<Poco::UInt32>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<Poco::UInt32>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, Poco::UInt64& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_SBIGINT);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<Poco::UInt64>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<Poco::UInt64>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<Poco::UInt64>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, bool& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_BIT);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<bool>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<bool>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<bool>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, float& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_FLOAT);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<float>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<float>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<float>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, char& val)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+		return extractManualImpl(pos, val, SQL_C_STINYINT);
+	else
+		return extractBoundImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<char>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<char>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<char>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImplContainer(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, Poco::Any& val)
+{
+	return extractImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<Poco::Any>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImpl(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<Poco::Any>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImpl(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<Poco::Any>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImpl(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, Poco::DynamicAny& val)
+{
+	return extractImpl(pos, val);
+}
+
+
+bool Extractor::extract(std::size_t pos, std::vector<Poco::DynamicAny>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImpl(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::deque<Poco::DynamicAny>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImpl(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::extract(std::size_t pos, std::list<Poco::DynamicAny>& val)
+{
+	if (Preparator::DE_BOUND == _dataExtraction)
+		return extractBoundImpl(pos, val);
+	else
+		throw InvalidAccessException("Direct container extraction only allowed for bound mode.");
+}
+
+
+bool Extractor::isNull(std::size_t col, std::size_t row)
+{
+	if (Preparator::DE_MANUAL == _dataExtraction)
+	{
+		try
+		{
+			return isNullLengthIndicator(_lengths.at(col));
+		} 
+		catch (std::out_of_range& ex)
+		{
+			throw RangeException(ex.what()); 
+		}
+	}
+	else
+		return SQL_NULL_DATA == _pPreparator->actualDataSize(col, row);
+}
+
+
+void Extractor::checkDataSize(std::size_t size)
+{
+	std::size_t maxSize = _pPreparator->getMaxFieldSize();
+	if (size > maxSize)
+		throw DataException(format(FLD_SIZE_EXCEEDED_FMT, size, maxSize));
+}
+
+
+} } } // namespace Poco::Data::ODBC
diff --git a/base/poco/Data/ODBC/src/ODBCException.cpp b/base/poco/Data/ODBC/src/ODBCException.cpp
new file mode 100644
index 00000000000..a9249e4cbfe
--- /dev/null
+++ b/base/poco/Data/ODBC/src/ODBCException.cpp
@@ -0,0 +1,30 @@
+//
+// ODBCException.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  ODBCException
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/ODBCException.h"
+#include <typeinfo>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+POCO_IMPLEMENT_EXCEPTION(ODBCException, Poco::Data::DataException, "Generic ODBC error")
+POCO_IMPLEMENT_EXCEPTION(InsufficientStorageException, ODBCException, "Insufficient storage error")
+POCO_IMPLEMENT_EXCEPTION(UnknownDataLengthException, ODBCException, "Unknown length of remaining data")
+POCO_IMPLEMENT_EXCEPTION(DataTruncatedException, ODBCException, "Variable length character or binary data truncated")
+
+
+} } } // namespace Poco::Data::ODBC
diff --git a/base/poco/Data/ODBC/src/ODBCMetaColumn.cpp b/base/poco/Data/ODBC/src/ODBCMetaColumn.cpp
new file mode 100644
index 00000000000..597589dc94b
--- /dev/null
+++ b/base/poco/Data/ODBC/src/ODBCMetaColumn.cpp
@@ -0,0 +1,168 @@
+//
+// ODBCMetaColumn.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  ODBCMetaColumn
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/ODBCMetaColumn.h"
+#include "Poco/Data/ODBC/Utility.h"
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+ODBCMetaColumn::ODBCMetaColumn(const StatementHandle& rStmt, std::size_t position) : 
+	MetaColumn(position),
+	_rStmt(rStmt)
+{
+	init();
+}
+
+	
+ODBCMetaColumn::~ODBCMetaColumn()
+{
+}
+
+
+void ODBCMetaColumn::getDescription()
+{
+	std::memset(_columnDesc.name, 0, NAME_BUFFER_LENGTH);
+	_columnDesc.nameBufferLength = 0;
+	_columnDesc.dataType = 0;
+	_columnDesc.size = 0;
+	_columnDesc.decimalDigits = 0;
+	_columnDesc.isNullable = 0;
+
+	if (Utility::isError(Poco::Data::ODBC::SQLDescribeCol(_rStmt, 
+		(SQLUSMALLINT) position() + 1, // ODBC columns are 1-based
+		_columnDesc.name, 
+		NAME_BUFFER_LENGTH,
+		&_columnDesc.nameBufferLength, 
+		&_columnDesc.dataType,
+		&_columnDesc.size, 
+		&_columnDesc.decimalDigits, 
+		&_columnDesc.isNullable)))
+	{
+		throw StatementException(_rStmt);
+	}
+}
+
+
+bool ODBCMetaColumn::isUnsigned() const
+{
+	SQLLEN val = 0;
+	if (Utility::isError(Poco::Data::ODBC::SQLColAttribute(_rStmt,
+		(SQLUSMALLINT)position() + 1, // ODBC columns are 1-based
+		SQL_DESC_UNSIGNED,
+		0,
+		0,
+		0,
+		&val)))
+	{
+		throw StatementException(_rStmt);
+	}
+	return (val == SQL_TRUE);
+}
+
+
+void ODBCMetaColumn::init()
+{
+	getDescription();
+
+	if (Utility::isError(Poco::Data::ODBC::SQLColAttribute(_rStmt,
+			(SQLUSMALLINT) position() + 1, // ODBC columns are 1-based
+			SQL_DESC_LENGTH,
+			0,
+			0,
+			0,
+			&_dataLength)))
+	{
+		throw StatementException(_rStmt);
+	}
+
+	setName(std::string((char*) _columnDesc.name));
+	setLength(_columnDesc.size);
+	setPrecision(_columnDesc.decimalDigits);
+	setNullable(SQL_NULLABLE == _columnDesc.isNullable);
+	switch(_columnDesc.dataType)
+	{
+	case SQL_BIT:
+		setType(MetaColumn::FDT_BOOL); break;
+
+	case SQL_CHAR:
+	case SQL_VARCHAR:
+	case SQL_LONGVARCHAR:
+#ifdef SQL_GUID
+	case SQL_GUID:
+#endif
+		setType(MetaColumn::FDT_STRING); break;
+
+	case SQL_WCHAR:
+	case SQL_WVARCHAR:
+	case SQL_WLONGVARCHAR:
+		setType(MetaColumn::FDT_WSTRING); break;
+
+	case SQL_TINYINT:
+		setType(isUnsigned() ? MetaColumn::FDT_UINT8 : MetaColumn::FDT_INT8);
+		break;
+
+	case SQL_SMALLINT:
+		setType(isUnsigned() ? MetaColumn::FDT_UINT16 : MetaColumn::FDT_INT16);
+		break;
+
+	case SQL_INTEGER:
+		setType(isUnsigned() ? MetaColumn::FDT_UINT32 : MetaColumn::FDT_INT32);
+		break;
+
+	case SQL_BIGINT:
+		setType(isUnsigned() ? MetaColumn::FDT_UINT64 : MetaColumn::FDT_INT64);
+		break;
+
+	case SQL_DOUBLE:
+	case SQL_FLOAT:
+		setType(MetaColumn::FDT_DOUBLE); break;
+
+	case SQL_NUMERIC:
+	case SQL_DECIMAL:
+		// Oracle has no INTEGER type - it's essentially NUMBER with 38 whole and
+		// 0 fractional digits. It also does not recognize SQL_BIGINT type,
+		// so the workaround here is to hardcode it to 32 bit integer
+		if (0 == _columnDesc.decimalDigits) setType(MetaColumn::FDT_INT32);
+		else setType(MetaColumn::FDT_DOUBLE);
+		break;
+
+	case SQL_REAL:
+		setType(MetaColumn::FDT_FLOAT); break;
+	
+	case SQL_BINARY:
+	case SQL_VARBINARY:
+	case SQL_LONGVARBINARY:
+	case -98:// IBM DB2 non-standard type
+		setType(MetaColumn::FDT_BLOB); break;
+	
+	case SQL_TYPE_DATE:
+		setType(MetaColumn::FDT_DATE); break;
+	
+	case SQL_TYPE_TIME:
+		setType(MetaColumn::FDT_TIME); break;
+	
+	case SQL_TYPE_TIMESTAMP:
+		setType(MetaColumn::FDT_TIMESTAMP); break;
+	
+	default:
+		throw DataFormatException("Unsupported data type.");
+	}
+}
+
+
+} } } // namespace Poco::Data::ODBC
diff --git a/base/poco/Data/ODBC/src/ODBCStatementImpl.cpp b/base/poco/Data/ODBC/src/ODBCStatementImpl.cpp
new file mode 100644
index 00000000000..b209fe772a9
--- /dev/null
+++ b/base/poco/Data/ODBC/src/ODBCStatementImpl.cpp
@@ -0,0 +1,458 @@
+//
+// ODBCStatementImpl.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  ODBCStatementImpl
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/ODBCStatementImpl.h"
+#include "Poco/Data/ODBC/ConnectionHandle.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+#include "Poco/Data/AbstractPreparation.h"
+#include "Poco/Exception.h"
+
+
+#ifdef POCO_OS_FAMILY_WINDOWS
+	#pragma warning(disable:4312)// 'type cast' : conversion from 'std::size_t' to 'SQLPOINTER' of greater size
+#endif
+
+
+using Poco::DataFormatException;
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+const std::string ODBCStatementImpl::INVALID_CURSOR_STATE = "24000";
+
+
+ODBCStatementImpl::ODBCStatementImpl(SessionImpl& rSession):
+	Poco::Data::StatementImpl(rSession),
+	_rConnection(rSession.dbc()),
+	_stmt(rSession.dbc()),
+	_stepCalled(false),
+	_nextResponse(0),
+	_prepared(false),
+	_affectedRowCount(0),
+	_canCompile(true)
+{
+	int queryTimeout = rSession.queryTimeout();
+	if (queryTimeout >= 0)
+	{
+		SQLULEN uqt = static_cast<SQLULEN>(queryTimeout);
+		SQLSetStmtAttr(_stmt,
+			SQL_ATTR_QUERY_TIMEOUT,
+			(SQLPOINTER) uqt,
+			0);
+	}
+}
+
+
+ODBCStatementImpl::~ODBCStatementImpl()
+{
+	ColumnPtrVecVec::iterator it = _columnPtrs.begin();
+	ColumnPtrVecVec::iterator end = _columnPtrs.end();
+	for (; it != end; ++it)
+	{
+		ColumnPtrVec::iterator itC = it->begin();
+		ColumnPtrVec::iterator endC = it->end();
+		for (; itC != endC; ++itC) delete *itC;
+	}
+}
+
+
+void ODBCStatementImpl::compileImpl()
+{
+	if (!_canCompile) return;
+
+	_stepCalled = false;
+	_nextResponse = 0;
+
+	if (_preparations.size())
+		PreparatorVec().swap(_preparations);
+
+	addPreparator();
+
+	Binder::ParameterBinding bind = session().getFeature("autoBind") ? 
+		Binder::PB_IMMEDIATE : Binder::PB_AT_EXEC;
+
+	TypeInfo* pDT = 0;
+	try
+	{
+		Poco::Any dti = session().getProperty("dataTypeInfo");
+		pDT = AnyCast<TypeInfo*>(dti);
+	}
+	catch (NotSupportedException&) 
+	{
+	}
+
+	std::size_t maxFieldSize = AnyCast<std::size_t>(session().getProperty("maxFieldSize"));
+	
+	_pBinder = new Binder(_stmt, maxFieldSize, bind, pDT);
+	
+	makeInternalExtractors();
+	doPrepare();
+
+	 _canCompile = false;
+}
+
+
+void ODBCStatementImpl::makeInternalExtractors()
+{
+	if (hasData() && !extractions().size()) 
+	{
+		try
+		{
+			fillColumns();
+		} 
+		catch (DataFormatException&)
+		{
+			if (isStoredProcedure()) return;
+			throw;
+		}
+
+		makeExtractors(columnsReturned());
+		fixupExtraction();
+	}
+}
+
+
+void ODBCStatementImpl::addPreparator()
+{
+	if (0 == _preparations.size())
+	{
+		std::string statement(toString());
+		if (statement.empty())
+			throw ODBCException("Empty statements are illegal");
+
+		Preparator::DataExtraction ext = session().getFeature("autoExtract") ? 
+			Preparator::DE_BOUND : Preparator::DE_MANUAL;
+
+		std::size_t maxFieldSize = AnyCast<std::size_t>(session().getProperty("maxFieldSize"));
+
+		_preparations.push_back(new Preparator(_stmt, statement, maxFieldSize, ext));
+	}
+	else
+		_preparations.push_back(new Preparator(*_preparations[0]));
+
+	_extractors.push_back(new Extractor(_stmt, _preparations.back()));
+}
+
+
+void ODBCStatementImpl::doPrepare()
+{
+	if (session().getFeature("autoExtract") && hasData())
+	{
+		std::size_t curDataSet = currentDataSet();
+		poco_check_ptr (_preparations[curDataSet]);
+
+		Extractions& extracts = extractions();
+		Extractions::iterator it    = extracts.begin();
+		Extractions::iterator itEnd = extracts.end();
+
+		if (it != itEnd && (*it)->isBulk())
+		{
+			std::size_t limit = getExtractionLimit();
+			if (limit == Limit::LIMIT_UNLIMITED) 
+				throw InvalidArgumentException("Bulk operation not allowed without limit.");
+			checkError(Poco::Data::ODBC::SQLSetStmtAttr(_stmt, SQL_ATTR_ROW_ARRAY_SIZE, (SQLPOINTER) limit, 0),
+					"SQLSetStmtAttr(SQL_ATTR_ROW_ARRAY_SIZE)");
+		}
+
+		AbstractPreparation::Ptr pAP = 0;
+		Poco::Data::AbstractPreparator::Ptr pP = _preparations[curDataSet];
+		for (std::size_t pos = 0; it != itEnd; ++it)
+		{
+			pAP = (*it)->createPreparation(pP, pos);
+			pAP->prepare();
+			pos += (*it)->numOfColumnsHandled();
+		}
+
+		_prepared = true;
+	}
+}
+
+
+bool ODBCStatementImpl::canBind() const
+{
+	if (!bindings().empty())
+		return (*bindings().begin())->canBind();
+
+	return false;
+}
+
+
+void ODBCStatementImpl::doBind()
+{
+	this->clear();
+	Bindings& binds = bindings();
+	if (!binds.empty())
+	{
+		Bindings::iterator it    = binds.begin();
+		Bindings::iterator itEnd = binds.end();
+
+		if (it != itEnd && 0 == _affectedRowCount)
+			_affectedRowCount = static_cast<std::size_t>((*it)->numOfRowsHandled());
+
+		for (std::size_t pos = 0; it != itEnd && (*it)->canBind(); ++it)
+		{
+			(*it)->bind(pos);
+			pos += (*it)->numOfColumnsHandled();
+		}
+	}
+}
+
+
+void ODBCStatementImpl::bindImpl()
+{
+	doBind();
+
+	SQLRETURN rc = SQLExecute(_stmt);
+
+	if (SQL_NEED_DATA == rc) putData();
+	else checkError(rc, "SQLExecute()");
+
+	_pBinder->synchronize();
+}
+
+
+void ODBCStatementImpl::putData()
+{
+	SQLPOINTER pParam = 0;
+	SQLINTEGER dataSize = 0;
+	SQLRETURN rc;
+
+	while (SQL_NEED_DATA == (rc = SQLParamData(_stmt, &pParam)))
+	{
+		if (pParam)
+		{
+			dataSize = (SQLINTEGER) _pBinder->parameterSize(pParam);
+
+			if (Utility::isError(SQLPutData(_stmt, pParam, dataSize))) 
+				throw StatementException(_stmt, "SQLPutData()");
+		}
+		else // if pParam is null pointer, do a dummy call
+		{
+			char dummy = 0;
+			if (Utility::isError(SQLPutData(_stmt, &dummy, 0))) 
+				throw StatementException(_stmt, "SQLPutData()");
+		}
+	}
+
+	checkError(rc, "SQLParamData()");
+}
+
+
+void ODBCStatementImpl::clear()
+{
+	SQLRETURN rc = SQLCloseCursor(_stmt);
+	_stepCalled = false;
+	_affectedRowCount = 0;
+
+	if (Utility::isError(rc))
+	{
+		StatementError err(_stmt);
+		bool ignoreError = false;
+
+		const StatementDiagnostics& diagnostics = err.diagnostics();
+		//ignore "Invalid cursor state" error
+		//(returned by 3.x drivers when cursor is not opened)
+		for (int i = 0; i < diagnostics.count(); ++i)
+		{
+			if ((ignoreError =
+				(INVALID_CURSOR_STATE == std::string(diagnostics.sqlState(i)))))
+			{
+				break;
+			}
+		}
+
+		if (!ignoreError)
+			throw StatementException(_stmt, "SQLCloseCursor()");
+	}
+}
+
+
+bool ODBCStatementImpl::hasNext()
+{
+	if (hasData())
+	{
+		if (!extractions().size())
+			makeInternalExtractors();
+
+		if (!_prepared) doPrepare();
+
+		if (_stepCalled)
+			return _stepCalled = nextRowReady();
+
+		makeStep();
+
+		if (!nextRowReady())
+		{
+			if (hasMoreDataSets()) activateNextDataSet();
+			else return false;
+
+			if (SQL_NO_DATA == SQLMoreResults(_stmt))
+				return false;
+
+			addPreparator();
+			doPrepare();
+			fixupExtraction();
+			makeStep();
+		}
+		else if (Utility::isError(_nextResponse))
+			checkError(_nextResponse, "SQLFetch()");
+
+		return true;
+	}
+
+	return false;
+}
+
+
+void ODBCStatementImpl::makeStep()
+{
+	_extractors[currentDataSet()]->reset();
+	_nextResponse = SQLFetch(_stmt);
+	checkError(_nextResponse);
+	_stepCalled = true;
+}
+
+
+std::size_t ODBCStatementImpl::next()
+{
+	std::size_t count = 0;
+
+	if (nextRowReady())
+	{
+		Extractions& extracts = extractions();
+		Extractions::iterator it    = extracts.begin();
+		Extractions::iterator itEnd = extracts.end();
+		std::size_t prevCount = 0;
+		for (std::size_t pos = 0; it != itEnd; ++it)
+		{
+			count = (*it)->extract(pos);
+			if (prevCount && count != prevCount)
+				throw IllegalStateException("Different extraction counts");
+			prevCount = count;
+			pos += (*it)->numOfColumnsHandled();
+		}
+		_stepCalled = false;
+	}
+	else
+	{
+		throw StatementException(_stmt,
+			std::string("Next row not available."));
+	}
+
+	return count;
+}
+
+
+std::string ODBCStatementImpl::nativeSQL()
+{
+	std::string statement = toString();
+
+	SQLINTEGER length = (SQLINTEGER) statement.size() * 2;
+
+	char* pNative = 0;
+	SQLINTEGER retlen = length;
+	do
+	{
+		delete [] pNative;
+		pNative = new char[retlen];
+		std::memset(pNative, 0, retlen);
+		length = retlen;
+		if (Utility::isError(SQLNativeSql(_rConnection,
+			(SQLCHAR*) statement.c_str(),
+			(SQLINTEGER) statement.size(),
+			(SQLCHAR*) pNative,
+			length,
+			&retlen)))
+		{
+			delete [] pNative;
+			throw ConnectionException(_rConnection, "SQLNativeSql()");
+		}
+		++retlen;//accomodate for terminating '\0'
+	}while (retlen > length);
+
+	std::string sql(pNative);
+	delete [] pNative;
+	return sql;
+}
+
+
+void ODBCStatementImpl::checkError(SQLRETURN rc, const std::string& msg)
+{
+	if (SQL_NO_DATA == rc) return;
+
+	if (Utility::isError(rc))
+	{
+		std::ostringstream os;
+		os << std::endl << "Requested SQL statement: " << toString() << std::endl; 	 
+		os << "Native SQL statement: " << nativeSQL() << std::endl; 	 
+		std::string str(msg); str += os.str();
+		
+		throw StatementException(_stmt, str);
+	}
+}
+
+
+void ODBCStatementImpl::fillColumns()
+{
+	std::size_t colCount = columnsReturned();
+	std::size_t curDataSet = currentDataSet();
+	if (curDataSet >= _columnPtrs.size())
+		_columnPtrs.resize(curDataSet + 1);
+
+	for (int i = 0; i < colCount; ++i)
+		_columnPtrs[curDataSet].push_back(new ODBCMetaColumn(_stmt, i));
+}
+
+
+bool ODBCStatementImpl::isStoredProcedure() const 	 
+{ 	 
+	std::string str = toString(); 	 
+	if (trimInPlace(str).size() < 2) return false; 	 
+
+	return ('{' == str[0] && '}' == str[str.size()-1]); 	 
+}
+
+
+const MetaColumn& ODBCStatementImpl::metaColumn(std::size_t pos) const
+{
+	std::size_t curDataSet = currentDataSet();
+	poco_assert_dbg (curDataSet < _columnPtrs.size());
+
+	std::size_t sz = _columnPtrs[curDataSet].size();
+
+	if (0 == sz || pos > sz - 1)
+		throw InvalidAccessException(format("Invalid column number: %u", pos));
+
+	return *_columnPtrs[curDataSet][pos];
+}
+
+
+int ODBCStatementImpl::affectedRowCount() const
+{
+	if (0 == _affectedRowCount)
+	{
+		SQLLEN rows = 0;
+		if (!Utility::isError(SQLRowCount(_stmt, &rows)))
+			_affectedRowCount = static_cast<std::size_t>(rows);
+	}
+
+	return static_cast<int>(_affectedRowCount);
+}
+
+
+} } } // namespace Poco::Data::ODBC
diff --git a/base/poco/Data/ODBC/src/Parameter.cpp b/base/poco/Data/ODBC/src/Parameter.cpp
new file mode 100644
index 00000000000..23023779b33
--- /dev/null
+++ b/base/poco/Data/ODBC/src/Parameter.cpp
@@ -0,0 +1,53 @@
+//
+// Parameter.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Parameter
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/Parameter.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/Error.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+Parameter::Parameter(const StatementHandle& rStmt, std::size_t colNum) : 
+	_rStmt(rStmt), 
+	_number(colNum)
+{
+	init();
+}
+
+	
+Parameter::~Parameter()
+{
+}
+
+
+void Parameter::init()
+{
+	if (Utility::isError(SQLDescribeParam(_rStmt, 
+		(SQLUSMALLINT) _number + 1, 
+		&_dataType,
+		&_columnSize,
+		&_decimalDigits,
+		&_isNullable)))
+	{
+		throw StatementException(_rStmt);
+	}
+}
+
+
+} } } // namespace Poco::Data::ODBC
diff --git a/base/poco/Data/ODBC/src/Preparator.cpp b/base/poco/Data/ODBC/src/Preparator.cpp
new file mode 100644
index 00000000000..1b00eca2a27
--- /dev/null
+++ b/base/poco/Data/ODBC/src/Preparator.cpp
@@ -0,0 +1,209 @@
+//
+// Preparator.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Preparator
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/Preparator.h"
+#include "Poco/Data/ODBC/ODBCMetaColumn.h"
+#include "Poco/Exception.h"
+
+
+using Poco::InvalidArgumentException;
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+Preparator::Preparator(const StatementHandle& rStmt, 
+	const std::string& statement, 
+	std::size_t maxFieldSize,
+	DataExtraction dataExtraction): 
+	_rStmt(rStmt),
+	_maxFieldSize(maxFieldSize),
+	_dataExtraction(dataExtraction)
+{
+	SQLCHAR* pStr = (SQLCHAR*) statement.c_str();
+	if (Utility::isError(Poco::Data::ODBC::SQLPrepare(_rStmt, pStr, (SQLINTEGER) statement.length())))
+		throw StatementException(_rStmt);
+}
+
+
+Preparator::Preparator(const Preparator& other): 
+	_rStmt(other._rStmt),
+	_maxFieldSize(other._maxFieldSize),
+	_dataExtraction(other._dataExtraction)
+{
+	resize();
+}
+
+
+Preparator::~Preparator()
+{
+	try
+	{
+		freeMemory();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void Preparator::freeMemory() const
+{
+	IndexMap::iterator it = _varLengthArrays.begin();
+	IndexMap::iterator end = _varLengthArrays.end();
+	for (; it != end; ++it)
+	{
+		switch (it->second)
+		{
+			case DT_BOOL:
+				deleteCachedArray<bool>(it->first);
+				break;
+
+			case DT_CHAR:
+				deleteCachedArray<char>(it->first);
+				break;
+
+			case DT_WCHAR:
+				deleteCachedArray<UTF16String::value_type>(it->first);
+				break;
+
+			case DT_UCHAR:
+				deleteCachedArray<unsigned char>(it->first);
+				break;
+
+			case DT_CHAR_ARRAY:
+			{
+				char** pc = AnyCast<char*>(&_values[it->first]);
+				if (pc) std::free(*pc);
+				break;
+			}
+
+			case DT_WCHAR_ARRAY:
+			{
+				UTF16String::value_type** pc = AnyCast<UTF16String::value_type*>(&_values[it->first]);
+				if (pc) std::free(*pc);
+				break;
+			}
+
+			case DT_UCHAR_ARRAY:
+			{
+				unsigned char** pc = AnyCast<unsigned char*>(&_values[it->first]);
+				if (pc) std::free(*pc);
+				break;
+			}
+
+			case DT_BOOL_ARRAY:
+			{
+				bool** pb = AnyCast<bool*>(&_values[it->first]);
+				if (pb) std::free(*pb);
+				break;
+			}
+
+			default:
+				throw InvalidArgumentException("Unknown data type.");
+		}
+	}
+}
+
+
+std::size_t Preparator::columns() const
+{
+	if (_values.empty()) resize();
+	return _values.size();
+}
+
+
+void Preparator::resize() const
+{
+	SQLSMALLINT nCol = 0;
+	if (!Utility::isError(SQLNumResultCols(_rStmt, &nCol)) && 0 != nCol)
+	{
+		_values.resize(nCol, 0);
+		_lengths.resize(nCol, 0);
+		_lenLengths.resize(nCol);
+		if(_varLengthArrays.size())
+		{
+			freeMemory();
+			_varLengthArrays.clear();
+		}
+	}
+}
+
+
+std::size_t Preparator::maxDataSize(std::size_t pos) const
+{
+	poco_assert_dbg (pos < _values.size());
+
+	std::size_t sz = 0;
+	std::size_t maxsz = getMaxFieldSize();
+
+	try 
+	{
+		ODBCMetaColumn mc(_rStmt, pos);
+		sz = mc.length();
+
+		// accomodate for terminating zero (non-bulk only!)
+		MetaColumn::ColumnDataType type = mc.type();
+		if (!isBulk() && ((ODBCMetaColumn::FDT_WSTRING == type) || (ODBCMetaColumn::FDT_STRING == type))) ++sz;
+	}
+	catch (StatementException&) { }
+
+	if (!sz || sz > maxsz) sz = maxsz;
+
+	return sz;
+}
+
+
+std::size_t Preparator::actualDataSize(std::size_t col, std::size_t row) const
+{
+	SQLLEN size = (POCO_DATA_INVALID_ROW == row) ? _lengths.at(col) :
+		_lenLengths.at(col).at(row);
+
+	// workaround for drivers returning negative length
+	if (size < 0 && SQL_NULL_DATA != size) size *= -1;
+
+	return size;
+}
+
+
+void Preparator::prepareBoolArray(std::size_t pos, SQLSMALLINT valueType, std::size_t length)
+{
+	poco_assert_dbg (DE_BOUND == _dataExtraction);
+	poco_assert_dbg (pos < _values.size());
+	poco_assert_dbg (pos < _lengths.size());
+	poco_assert_dbg (pos < _lenLengths.size());
+
+	bool* pArray = (bool*) std::calloc(length, sizeof(bool));
+
+	_values[pos] = Any(pArray);
+	_lengths[pos] = 0;
+	_lenLengths[pos].resize(length);
+	_varLengthArrays.insert(IndexMap::value_type(pos, DT_BOOL_ARRAY));
+
+	if (Utility::isError(SQLBindCol(_rStmt, 
+		(SQLUSMALLINT) pos + 1, 
+		valueType, 
+		(SQLPOINTER) pArray, 
+		(SQLINTEGER) sizeof(bool), 
+		&_lenLengths[pos][0])))
+	{
+		throw StatementException(_rStmt, "SQLBindCol()");
+	}
+}
+
+
+} } } // namespace Poco::Data::ODBC
diff --git a/base/poco/Data/ODBC/src/SessionImpl.cpp b/base/poco/Data/ODBC/src/SessionImpl.cpp
new file mode 100644
index 00000000000..99e7ff340de
--- /dev/null
+++ b/base/poco/Data/ODBC/src/SessionImpl.cpp
@@ -0,0 +1,418 @@
+//
+// SessionImpl.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  SessionImpl
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/SessionImpl.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/ODBCStatementImpl.h"
+#include "Poco/Data/ODBC/Error.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+#include "Poco/Data/Session.h"
+#include "Poco/String.h"
+#include <sqlext.h>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+SessionImpl::SessionImpl(const std::string& connect,
+	std::size_t loginTimeout,
+	std::size_t maxFieldSize,
+	bool autoBind,
+	bool autoExtract): 
+	Poco::Data::AbstractSessionImpl<SessionImpl>(connect, loginTimeout),
+		_connector(Connector::KEY),
+		_maxFieldSize(maxFieldSize),
+		_autoBind(autoBind),
+		_autoExtract(autoExtract),
+		_canTransact(ODBC_TXN_CAPABILITY_UNKNOWN),
+		_inTransaction(false),
+		_queryTimeout(-1)
+{
+	setFeature("bulk", true);
+	open();
+	setProperty("handle", _db.handle());
+}
+
+
+SessionImpl::SessionImpl(const std::string& connect,
+	Poco::Any maxFieldSize, 
+	bool enforceCapability,
+	bool autoBind,
+	bool autoExtract): Poco::Data::AbstractSessionImpl<SessionImpl>(connect),
+		_connector(Connector::KEY),
+		_maxFieldSize(maxFieldSize),
+		_autoBind(autoBind),
+		_autoExtract(autoExtract),
+		_canTransact(ODBC_TXN_CAPABILITY_UNKNOWN),
+		_inTransaction(false),
+		_queryTimeout(-1)
+{
+	setFeature("bulk", true);
+	open();
+	setProperty("handle", _db.handle());
+}
+
+
+SessionImpl::~SessionImpl()
+{
+	try
+	{
+		if (isTransaction() && !getFeature("autoCommit"))
+		{
+			try { rollback(); }
+			catch (...) { }
+		}
+
+		close();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+Poco::Data::StatementImpl* SessionImpl::createStatementImpl()
+{
+	return new ODBCStatementImpl(*this);
+}
+
+
+void SessionImpl::open(const std::string& connect)
+{
+	if (connect != connectionString())
+	{
+		if (isConnected())
+			throw InvalidAccessException("Session already connected");
+
+		if (!connect.empty())
+			setConnectionString(connect);
+	}
+
+	poco_assert_dbg (!connectionString().empty());
+
+	SQLULEN tout = static_cast<SQLULEN>(getLoginTimeout());
+	if (Utility::isError(SQLSetConnectAttr(_db, SQL_ATTR_LOGIN_TIMEOUT, (SQLPOINTER) tout, 0)))
+	{
+		if (Utility::isError(SQLGetConnectAttr(_db, SQL_ATTR_LOGIN_TIMEOUT, &tout, 0, 0)) ||
+				getLoginTimeout() != tout)
+		{
+			ConnectionError e(_db);
+			throw ConnectionFailedException(e.toString());
+		}
+	}
+
+	SQLCHAR connectOutput[512] = {0};
+	SQLSMALLINT result;
+
+	if (Utility::isError(Poco::Data::ODBC::SQLDriverConnect(_db
+		, NULL
+		,(SQLCHAR*) connectionString().c_str()
+		,(SQLSMALLINT) SQL_NTS
+		, connectOutput
+		, sizeof(connectOutput)
+		, &result
+		, SQL_DRIVER_NOPROMPT)))
+	{
+		ConnectionError err(_db);
+		std::string errStr = err.toString();
+		close();
+		throw ConnectionFailedException(errStr);
+	}
+
+	_dataTypes.fillTypeInfo(_db);
+		addProperty("dataTypeInfo", 
+		&SessionImpl::setDataTypeInfo, 
+		&SessionImpl::dataTypeInfo);
+
+	addFeature("autoCommit", 
+		&SessionImpl::autoCommit, 
+		&SessionImpl::isAutoCommit);
+
+	addFeature("autoBind", 
+		&SessionImpl::autoBind, 
+		&SessionImpl::isAutoBind);
+
+	addFeature("autoExtract", 
+		&SessionImpl::autoExtract, 
+		&SessionImpl::isAutoExtract);
+
+	addProperty("maxFieldSize",
+		&SessionImpl::setMaxFieldSize,
+		&SessionImpl::getMaxFieldSize);
+
+	addProperty("queryTimeout",
+		&SessionImpl::setQueryTimeout,
+		&SessionImpl::getQueryTimeout);
+
+	Poco::Data::ODBC::SQLSetConnectAttr(_db, SQL_ATTR_QUIET_MODE, 0, 0);
+
+	if (!canTransact()) autoCommit("", true);
+}
+
+
+bool SessionImpl::isConnected()
+{
+	SQLULEN value = 0;
+
+	if (Utility::isError(Poco::Data::ODBC::SQLGetConnectAttr(_db,
+		SQL_ATTR_CONNECTION_DEAD,
+		&value,
+		0,
+		0))) return false;
+
+	return (SQL_CD_FALSE == value);
+}
+
+
+void SessionImpl::setConnectionTimeout(std::size_t timeout)
+{
+	SQLUINTEGER value = static_cast<SQLUINTEGER>(timeout);
+
+	checkError(Poco::Data::ODBC::SQLSetConnectAttr(_db,
+		SQL_ATTR_CONNECTION_TIMEOUT,
+		&value,
+		SQL_IS_UINTEGER), "Failed to set connection timeout.");
+}
+
+
+std::size_t SessionImpl::getConnectionTimeout()
+{
+	SQLULEN value = 0;
+
+	checkError(Poco::Data::ODBC::SQLGetConnectAttr(_db,
+		SQL_ATTR_CONNECTION_TIMEOUT,
+		&value,
+		0,
+		0), "Failed to get connection timeout.");
+
+	return value;
+}
+
+
+bool SessionImpl::canTransact()
+{
+	if (ODBC_TXN_CAPABILITY_UNKNOWN == _canTransact)
+	{
+		SQLUSMALLINT ret;
+		checkError(Poco::Data::ODBC::SQLGetInfo(_db, SQL_TXN_CAPABLE, &ret, 0, 0), 
+			"Failed to obtain transaction capability info.");
+
+		_canTransact = (SQL_TC_NONE != ret) ? 
+			ODBC_TXN_CAPABILITY_TRUE : 
+			ODBC_TXN_CAPABILITY_FALSE;
+	}
+
+	return ODBC_TXN_CAPABILITY_TRUE == _canTransact;
+}
+
+
+void SessionImpl::setTransactionIsolation(Poco::UInt32 ti)
+{
+#if POCO_PTR_IS_64_BIT
+	Poco::UInt64 isolation = 0;
+#else
+	Poco::UInt32 isolation = 0;
+#endif
+
+	if (ti & Session::TRANSACTION_READ_UNCOMMITTED)
+		isolation |= SQL_TXN_READ_UNCOMMITTED;
+
+	if (ti & Session::TRANSACTION_READ_COMMITTED)
+		isolation |= SQL_TXN_READ_COMMITTED;
+
+	if (ti & Session::TRANSACTION_REPEATABLE_READ)
+		isolation |= SQL_TXN_REPEATABLE_READ;
+
+	if (ti & Session::TRANSACTION_SERIALIZABLE)
+		isolation |= SQL_TXN_SERIALIZABLE;
+
+	checkError(SQLSetConnectAttr(_db, SQL_ATTR_TXN_ISOLATION, (SQLPOINTER) isolation, 0));
+}
+
+
+Poco::UInt32 SessionImpl::getTransactionIsolation()
+{
+	SQLULEN isolation = 0;
+	checkError(SQLGetConnectAttr(_db, SQL_ATTR_TXN_ISOLATION,
+		&isolation,
+		0,
+		0));
+
+	return transactionIsolation(isolation);
+}
+
+
+bool SessionImpl::hasTransactionIsolation(Poco::UInt32 ti)
+{
+	if (isTransaction()) throw InvalidAccessException();
+
+	bool retval = true;
+	Poco::UInt32 old = getTransactionIsolation();
+	try { setTransactionIsolation(ti); }
+	catch (Poco::Exception&) { retval = false; }
+	setTransactionIsolation(old);
+	return retval;
+}
+
+
+Poco::UInt32 SessionImpl::getDefaultTransactionIsolation()
+{
+	SQLUINTEGER isolation = 0;
+	checkError(SQLGetInfo(_db, SQL_DEFAULT_TXN_ISOLATION,
+		&isolation,
+		0,
+		0));
+
+	return transactionIsolation(isolation);
+}
+
+
+Poco::UInt32 SessionImpl::transactionIsolation(SQLULEN isolation)
+{
+	if (0 == isolation)
+		throw InvalidArgumentException("transactionIsolation(SQLUINTEGER)");
+
+	Poco::UInt32 ret = 0;
+
+	if (isolation & SQL_TXN_READ_UNCOMMITTED)
+		ret |= Session::TRANSACTION_READ_UNCOMMITTED;
+
+	if (isolation & SQL_TXN_READ_COMMITTED)
+		ret |= Session::TRANSACTION_READ_COMMITTED;
+
+	if (isolation & SQL_TXN_REPEATABLE_READ)
+		ret |= Session::TRANSACTION_REPEATABLE_READ;
+
+	if (isolation & SQL_TXN_SERIALIZABLE)
+		ret |= Session::TRANSACTION_SERIALIZABLE;
+
+	if (0 == ret)
+		throw InvalidArgumentException("transactionIsolation(SQLUINTEGER)");
+
+	return ret;
+}
+
+
+void SessionImpl::autoCommit(const std::string&, bool val)
+{
+	checkError(Poco::Data::ODBC::SQLSetConnectAttr(_db, 
+		SQL_ATTR_AUTOCOMMIT, 
+		val ? (SQLPOINTER) SQL_AUTOCOMMIT_ON : 
+			(SQLPOINTER) SQL_AUTOCOMMIT_OFF, 
+		SQL_IS_UINTEGER), "Failed to set automatic commit.");
+}
+
+
+bool SessionImpl::isAutoCommit(const std::string&)
+{
+	SQLULEN value = 0;
+
+	checkError(Poco::Data::ODBC::SQLGetConnectAttr(_db,
+		SQL_ATTR_AUTOCOMMIT,
+		&value,
+		0,
+		0));
+
+	return (0 != value);
+}
+
+
+bool SessionImpl::isTransaction()
+{
+	if (!canTransact()) return false;
+
+	SQLULEN value = 0;
+	checkError(Poco::Data::ODBC::SQLGetConnectAttr(_db,
+		SQL_ATTR_AUTOCOMMIT,
+		&value,
+		0,
+		0));
+
+	if (0 == value) return _inTransaction;
+	else return false;
+}
+
+
+void SessionImpl::begin()
+{
+	if (isAutoCommit())
+		throw InvalidAccessException("Session in auto commit mode.");
+
+	{
+		Poco::FastMutex::ScopedLock l(_mutex);
+
+		if (_inTransaction)
+			throw InvalidAccessException("Transaction in progress.");
+
+		_inTransaction = true;
+	}
+}
+
+
+void SessionImpl::commit()
+{
+	if (!isAutoCommit())
+		checkError(SQLEndTran(SQL_HANDLE_DBC, _db, SQL_COMMIT));
+
+	_inTransaction = false;
+}
+
+
+void SessionImpl::rollback()
+{
+	if (!isAutoCommit())
+		checkError(SQLEndTran(SQL_HANDLE_DBC, _db, SQL_ROLLBACK));
+
+	_inTransaction = false;
+}
+
+
+void SessionImpl::close()
+{
+	if (!isConnected()) return;
+
+	try
+	{
+		commit();
+	}
+	catch (ConnectionException&) 
+	{
+	}
+
+	SQLDisconnect(_db);
+}
+
+
+int SessionImpl::maxStatementLength()
+{
+	SQLUINTEGER info;
+	SQLRETURN rc = 0;
+	if (Utility::isError(rc = Poco::Data::ODBC::SQLGetInfo(_db,
+		SQL_MAXIMUM_STATEMENT_LENGTH,
+		(SQLPOINTER) &info,
+		0,
+		0)))
+	{
+		throw ConnectionException(_db, 
+			"SQLGetInfo(SQL_MAXIMUM_STATEMENT_LENGTH)");
+	}
+
+	return info;
+}
+
+
+} } } // namespace Poco::Data::ODBC
diff --git a/base/poco/Data/ODBC/src/TypeInfo.cpp b/base/poco/Data/ODBC/src/TypeInfo.cpp
new file mode 100644
index 00000000000..ca5aa0eb1d9
--- /dev/null
+++ b/base/poco/Data/ODBC/src/TypeInfo.cpp
@@ -0,0 +1,265 @@
+//
+// TypeInfo.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  TypeInfo
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/TypeInfo.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+#include "Poco/Format.h"
+#include "Poco/Exception.h"
+#include <iostream>
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+TypeInfo::TypeInfo(SQLHDBC* pHDBC): _pHDBC(pHDBC)
+{
+	fillCTypes();
+	fillSQLTypes();
+	if (_pHDBC) fillTypeInfo(*_pHDBC);
+}
+
+
+TypeInfo::~TypeInfo()
+{
+}
+
+
+void TypeInfo::fillCTypes()
+{
+	_cDataTypes.insert(ValueType(SQL_CHAR, SQL_C_CHAR));
+	_cDataTypes.insert(ValueType(SQL_VARCHAR, SQL_C_CHAR));
+	_cDataTypes.insert(ValueType(SQL_LONGVARCHAR, SQL_C_CHAR));
+	_cDataTypes.insert(ValueType(SQL_DECIMAL, SQL_C_DOUBLE));
+	_cDataTypes.insert(ValueType(SQL_NUMERIC, SQL_C_DOUBLE));
+	_cDataTypes.insert(ValueType(SQL_BIT, SQL_C_BIT));
+	_cDataTypes.insert(ValueType(SQL_TINYINT, SQL_C_STINYINT));
+	_cDataTypes.insert(ValueType(SQL_SMALLINT, SQL_C_SSHORT));
+	_cDataTypes.insert(ValueType(SQL_INTEGER, SQL_C_SLONG));
+	_cDataTypes.insert(ValueType(SQL_BIGINT, SQL_C_SBIGINT));
+	_cDataTypes.insert(ValueType(SQL_REAL, SQL_C_FLOAT));
+	_cDataTypes.insert(ValueType(SQL_FLOAT, SQL_C_DOUBLE));
+	_cDataTypes.insert(ValueType(SQL_DOUBLE, SQL_C_DOUBLE));
+	_cDataTypes.insert(ValueType(SQL_BINARY, SQL_C_BINARY));
+	_cDataTypes.insert(ValueType(SQL_VARBINARY, SQL_C_BINARY));
+	_cDataTypes.insert(ValueType(SQL_LONGVARBINARY, SQL_C_BINARY));
+	_cDataTypes.insert(ValueType(SQL_TYPE_DATE, SQL_C_TYPE_DATE));
+	_cDataTypes.insert(ValueType(SQL_TYPE_TIME, SQL_C_TYPE_TIME));
+	_cDataTypes.insert(ValueType(SQL_TYPE_TIMESTAMP, SQL_C_TYPE_TIMESTAMP));
+}
+
+
+void TypeInfo::fillSQLTypes()
+{
+	_sqlDataTypes.insert(ValueType(SQL_C_CHAR, SQL_LONGVARCHAR));
+	_sqlDataTypes.insert(ValueType(SQL_C_BIT, SQL_BIT));
+	_sqlDataTypes.insert(ValueType(SQL_C_TINYINT, SQL_TINYINT));
+	_sqlDataTypes.insert(ValueType(SQL_C_STINYINT, SQL_TINYINT));
+	_sqlDataTypes.insert(ValueType(SQL_C_UTINYINT, SQL_TINYINT));
+	_sqlDataTypes.insert(ValueType(SQL_C_SHORT, SQL_SMALLINT));
+	_sqlDataTypes.insert(ValueType(SQL_C_SSHORT, SQL_SMALLINT));
+	_sqlDataTypes.insert(ValueType(SQL_C_USHORT, SQL_SMALLINT));
+	_sqlDataTypes.insert(ValueType(SQL_C_LONG, SQL_INTEGER));
+	_sqlDataTypes.insert(ValueType(SQL_C_SLONG, SQL_INTEGER));
+	_sqlDataTypes.insert(ValueType(SQL_C_ULONG, SQL_INTEGER));
+	_sqlDataTypes.insert(ValueType(SQL_C_SBIGINT, SQL_BIGINT));
+	_sqlDataTypes.insert(ValueType(SQL_C_UBIGINT, SQL_BIGINT));
+	_sqlDataTypes.insert(ValueType(SQL_C_FLOAT, SQL_REAL));
+	_sqlDataTypes.insert(ValueType(SQL_C_DOUBLE, SQL_DOUBLE));
+	_sqlDataTypes.insert(ValueType(SQL_C_BINARY, SQL_LONGVARBINARY));
+	_sqlDataTypes.insert(ValueType(SQL_C_TYPE_DATE, SQL_TYPE_DATE));
+	_sqlDataTypes.insert(ValueType(SQL_C_TYPE_TIME, SQL_TYPE_TIME));
+	_sqlDataTypes.insert(ValueType(SQL_C_TYPE_TIMESTAMP, SQL_TYPE_TIMESTAMP));
+}
+
+
+void TypeInfo::fillTypeInfo(SQLHDBC pHDBC)
+{
+	_pHDBC = &pHDBC;
+
+	if (_typeInfo.empty() && _pHDBC)
+	{
+		const static int stringSize = 512;
+		TypeInfoVec().swap(_typeInfo);
+
+		SQLRETURN rc;
+		SQLHSTMT hstmt = SQL_NULL_HSTMT;
+
+		rc = SQLAllocHandle(SQL_HANDLE_STMT, *_pHDBC, &hstmt);
+		if (!SQL_SUCCEEDED(rc))
+			throw StatementException(hstmt, "SQLGetData()");
+
+		rc = SQLGetTypeInfo(hstmt, SQL_ALL_TYPES);
+		if (SQL_SUCCEEDED(rc))
+		{
+			while (SQLFetch(hstmt) != SQL_NO_DATA_FOUND)
+			{
+				char typeName[stringSize] = { 0 };
+				char literalPrefix[stringSize] = { 0 };
+				char literalSuffix[stringSize] = { 0 };
+				char createParams[stringSize] = { 0 };
+				char localTypeName[stringSize] = { 0 };
+				
+				TypeInfoTup ti("TYPE_NAME", "",
+					"DATA_TYPE", 0,
+					"COLUMN_SIZE", 0,
+					"LITERAL_PREFIX", "",
+					"LITERAL_SUFFIX", "",
+					"CREATE_PARAMS", "",
+					"NULLABLE", 0,
+					"CASE_SENSITIVE", 0,
+					"SEARCHABLE", 0,
+					"UNSIGNED_ATTRIBUTE", 0,
+					"FIXED_PREC_SCALE", 0,
+					"AUTO_UNIQUE_VALUE", 0,
+					"LOCAL_TYPE_NAME", "",
+					"MINIMUM_SCALE", 0,
+					"MAXIMUM_SCALE", 0,
+					"SQL_DATA_TYPE", 0,
+					"SQL_DATETIME_SUB", 0,
+					"NUM_PREC_RADIX", 0,
+					"INTERVAL_PRECISION", 0);
+
+				SQLLEN ind = 0;
+				rc = SQLGetData(hstmt, 1, SQL_C_CHAR, typeName, sizeof(typeName), &ind);
+				ti.set<0>(typeName);
+				rc = SQLGetData(hstmt, 2, SQL_C_SSHORT, &ti.get<1>(), sizeof(SQLSMALLINT), &ind);
+				rc = SQLGetData(hstmt, 3, SQL_C_SLONG, &ti.get<2>(), sizeof(SQLINTEGER), &ind);
+				rc = SQLGetData(hstmt, 4, SQL_C_CHAR, literalPrefix, sizeof(literalPrefix), &ind);
+				ti.set<3>(literalPrefix);
+				rc = SQLGetData(hstmt, 5, SQL_C_CHAR, literalSuffix, sizeof(literalSuffix), &ind);
+				ti.set<4>(literalSuffix);
+				rc = SQLGetData(hstmt, 6, SQL_C_CHAR, createParams, sizeof(createParams), &ind);
+				ti.set<5>(createParams);
+				rc = SQLGetData(hstmt, 7, SQL_C_SSHORT, &ti.get<6>(), sizeof(SQLSMALLINT), &ind); 
+				rc = SQLGetData(hstmt, 8, SQL_C_SSHORT, &ti.get<7>(), sizeof(SQLSMALLINT), &ind); 
+				rc = SQLGetData(hstmt, 9, SQL_C_SSHORT, &ti.get<8>(), sizeof(SQLSMALLINT), &ind); 
+				rc = SQLGetData(hstmt, 10, SQL_C_SSHORT, &ti.get<9>(), sizeof(SQLSMALLINT), &ind); 
+				rc = SQLGetData(hstmt, 11, SQL_C_SSHORT, &ti.get<10>(), sizeof(SQLSMALLINT), &ind);
+				rc = SQLGetData(hstmt, 12, SQL_C_SSHORT, &ti.get<11>(), sizeof(SQLSMALLINT), &ind);
+				rc = SQLGetData(hstmt, 13, SQL_C_CHAR, localTypeName, sizeof(localTypeName), &ind);
+				ti.set<12>(localTypeName);
+				rc = SQLGetData(hstmt, 14, SQL_C_SSHORT, &ti.get<13>(), sizeof(SQLSMALLINT), &ind);
+				rc = SQLGetData(hstmt, 15, SQL_C_SSHORT, &ti.get<14>(), sizeof(SQLSMALLINT), &ind);
+				rc = SQLGetData(hstmt, 16, SQL_C_SSHORT, &ti.get<15>(), sizeof(SQLSMALLINT), &ind);
+				rc = SQLGetData(hstmt, 17, SQL_C_SSHORT, &ti.get<16>(), sizeof(SQLSMALLINT), &ind);
+				rc = SQLGetData(hstmt, 18, SQL_C_SLONG, &ti.get<17>(), sizeof(SQLINTEGER), &ind);
+				rc = SQLGetData(hstmt, 19, SQL_C_SSHORT, &ti.get<18>(), sizeof(SQLSMALLINT), &ind);
+
+				_typeInfo.push_back(ti);
+			}
+		}
+
+		SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
+	}
+}
+
+
+DynamicAny TypeInfo::getInfo(SQLSMALLINT type, const std::string& param) const
+{
+	TypeInfoVec::const_iterator it = _typeInfo.begin();
+	TypeInfoVec::const_iterator end = _typeInfo.end();
+	for (; it != end; ++it)
+	{
+		if (type == it->get<1>())
+			return (*it)[param];
+	}
+
+	throw NotFoundException(param);
+}
+
+
+bool TypeInfo::tryGetInfo(SQLSMALLINT type, const std::string& param, DynamicAny& result) const
+{
+	TypeInfoVec::const_iterator it = _typeInfo.begin();
+	TypeInfoVec::const_iterator end = _typeInfo.end();
+	for (; it != end; ++it)
+	{
+		if (type == it->get<1>())
+		{
+			result = (*it)[param];
+			return true;
+		}
+	}
+	
+	return false;
+}
+
+
+int TypeInfo::cDataType(int sqlDataType) const
+{
+	DataTypeMap::const_iterator it = _cDataTypes.find(sqlDataType);
+
+	if (_cDataTypes.end() == it)
+		throw NotFoundException(format("C data type not found for SQL data type: %d", sqlDataType));
+
+	return it->second;
+}
+
+
+int TypeInfo::sqlDataType(int cDataType) const
+{
+	DataTypeMap::const_iterator it = _sqlDataTypes.find(cDataType);
+
+	if (_sqlDataTypes.end() == it)
+		throw NotFoundException(format("SQL data type not found for C data type: %d", cDataType));
+
+	return it->second;
+}
+
+
+void TypeInfo::print(std::ostream& ostr)
+{
+	if (_typeInfo.empty())
+	{
+		ostr << "No data found.";
+		return;
+	}
+
+	TypeInfoTup::NameVec::const_iterator nIt = (*_typeInfo[0].names()).begin();
+	TypeInfoTup::NameVec::const_iterator nItEnd = (*_typeInfo[0].names()).end();
+	for (; nIt != nItEnd; ++nIt)
+		ostr << *nIt << "\t";
+
+	ostr << std::endl;
+
+	TypeInfoVec::const_iterator it = _typeInfo.begin();
+	TypeInfoVec::const_iterator end = _typeInfo.end();
+
+	for (; it != end; ++it)
+	{
+		ostr << it->get<0>() << "\t" 
+			<< it->get<1>() << "\t" 
+			<< it->get<2>() << "\t" 
+			<< it->get<3>() << "\t" 
+			<< it->get<4>() << "\t" 
+			<< it->get<5>() << "\t" 
+			<< it->get<6>() << "\t" 
+			<< it->get<7>() << "\t" 
+			<< it->get<8>() << "\t" 
+			<< it->get<9>() << "\t" 
+			<< it->get<10>() << "\t" 
+			<< it->get<11>() << "\t" 
+			<< it->get<12>() << "\t" 
+			<< it->get<13>() << "\t" 
+			<< it->get<14>() << "\t"
+			<< it->get<15>() << "\t" 
+			<< it->get<16>() << "\t" 
+			<< it->get<17>() << "\t" 
+			<< it->get<18>() << std::endl;
+	}
+}
+
+
+} } } // namespace Poco::Data::ODBC
diff --git a/base/poco/Data/ODBC/src/Unicode.cpp b/base/poco/Data/ODBC/src/Unicode.cpp
new file mode 100644
index 00000000000..5129972cd7b
--- /dev/null
+++ b/base/poco/Data/ODBC/src/Unicode.cpp
@@ -0,0 +1,22 @@
+//
+// Unicode.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Unicode
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+
+
+#if defined(POCO_ODBC_UNICODE_WINDOWS)
+#include "Unicode_WIN32.cpp"
+#elif defined(POCO_ODBC_UNICODE_UNIXODBC)
+#include "Unicode_UNIXODBC.cpp"
+#endif
diff --git a/base/poco/Data/ODBC/src/Unicode_UNIXODBC.cpp b/base/poco/Data/ODBC/src/Unicode_UNIXODBC.cpp
new file mode 100644
index 00000000000..4caf097c28a
--- /dev/null
+++ b/base/poco/Data/ODBC/src/Unicode_UNIXODBC.cpp
@@ -0,0 +1,775 @@
+//
+// Unicode.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Unicode
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/Unicode_UNIXODBC.h"
+#include "Poco/TextConverter.h"
+#include "Poco/UTF8Encoding.h"
+#include "Poco/UTF16Encoding.h"
+#include "Poco/Buffer.h"
+#include "Poco/Exception.h"
+#include <iostream>
+
+
+using Poco::Buffer;
+using Poco::UTF8Encoding;
+using Poco::UTF16Encoding;
+using Poco::TextConverter;
+using Poco::InvalidArgumentException;
+using Poco::NotImplementedException;
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+void makeUTF16(SQLCHAR* pSQLChar, SQLINTEGER length, std::string& target)
+{
+	int len = length;
+	if (SQL_NTS == len) 
+		len = (int) std::strlen((const char *) pSQLChar);
+
+	UTF8Encoding utf8Encoding;
+	UTF16Encoding utf16Encoding;
+	TextConverter converter(utf8Encoding, utf16Encoding);
+
+	if (0 != converter.convert(pSQLChar, len, target))
+		throw DataFormatException("Error converting UTF-8 to UTF-16");
+}
+
+
+void makeUTF8(Poco::Buffer<SQLWCHAR>& buffer, SQLINTEGER length, SQLPOINTER pTarget, SQLINTEGER targetLength)
+{
+	UTF8Encoding utf8Encoding;
+	UTF16Encoding utf16Encoding;
+	TextConverter converter(utf16Encoding, utf8Encoding);
+
+	std::string result;
+	if (0 != converter.convert(buffer.begin(), length, result))
+		throw DataFormatException("Error converting UTF-16 to UTF-8");
+	
+	std::memset(pTarget, 0, targetLength);
+	std::strncpy((char*) pTarget, result.c_str(), result.size() < targetLength ? result.size() : targetLength);
+}
+
+
+SQLRETURN SQLColAttribute(SQLHSTMT hstmt,
+	SQLUSMALLINT   iCol,
+	SQLUSMALLINT   iField,
+	SQLPOINTER	   pCharAttr,
+	SQLSMALLINT	   cbCharAttrMax,	
+	SQLSMALLINT*   pcbCharAttr,
+	NumAttrPtrType pNumAttr)
+{
+	if (isString(pCharAttr, cbCharAttrMax))
+	{
+		Buffer<SQLWCHAR> buffer(stringLength(pCharAttr, cbCharAttrMax));
+
+		SQLRETURN rc = SQLColAttributeW(hstmt,
+			iCol,
+			iField,
+			buffer.begin(),
+			(SQLSMALLINT) buffer.sizeBytes(),
+			pcbCharAttr,
+			pNumAttr);
+
+		makeUTF8(buffer, *pcbCharAttr, pCharAttr, cbCharAttrMax);
+		return rc;
+	}
+
+	return SQLColAttributeW(hstmt,
+		iCol,
+		iField,
+		pCharAttr,
+		cbCharAttrMax,	
+		pcbCharAttr,
+		pNumAttr);
+}
+
+
+SQLRETURN SQLColAttributes(SQLHSTMT hstmt,
+	SQLUSMALLINT icol,
+	SQLUSMALLINT fDescType,
+	SQLPOINTER   rgbDesc,
+	SQLSMALLINT  cbDescMax,
+	SQLSMALLINT* pcbDesc,
+	SQLLEN*      pfDesc)
+{
+	return SQLColAttribute(hstmt,
+		icol,
+		fDescType,
+		rgbDesc,
+		cbDescMax,
+		pcbDesc,
+		pfDesc);
+}
+
+
+SQLRETURN SQLConnect(SQLHDBC hdbc,
+	SQLCHAR*    szDSN,
+	SQLSMALLINT cbDSN,
+	SQLCHAR*    szUID,
+	SQLSMALLINT cbUID,
+	SQLCHAR*    szAuthStr,
+	SQLSMALLINT cbAuthStr)
+{
+	std::string sqlDSN;
+	makeUTF16(szDSN, cbDSN, sqlDSN);
+
+	std::string sqlUID;
+	makeUTF16(szUID, cbUID, sqlUID);
+
+	std::string sqlPWD;
+	makeUTF16(szAuthStr, cbAuthStr, sqlPWD);
+	
+	return SQLConnectW(hdbc, 
+		(SQLWCHAR*) sqlDSN.c_str(), cbDSN,
+		(SQLWCHAR*) sqlUID.c_str(), cbUID,
+		(SQLWCHAR*) sqlPWD.c_str(), cbAuthStr);
+}
+
+
+SQLRETURN SQLDescribeCol(SQLHSTMT hstmt,
+	SQLUSMALLINT icol,
+	SQLCHAR*     szColName,
+	SQLSMALLINT  cbColNameMax,
+	SQLSMALLINT* pcbColName,
+	SQLSMALLINT* pfSqlType,
+	SQLULEN*     pcbColDef,
+	SQLSMALLINT* pibScale,
+	SQLSMALLINT* pfNullable)
+{
+	Buffer<SQLWCHAR> buffer(cbColNameMax);
+	SQLRETURN rc = SQLDescribeColW(hstmt,
+		icol,
+		(SQLWCHAR*) buffer.begin(),
+		(SQLSMALLINT) buffer.size(),
+		pcbColName,
+		pfSqlType,
+		pcbColDef,
+		pibScale,
+		pfNullable);
+
+	makeUTF8(buffer, *pcbColName * sizeof(SQLWCHAR), szColName, cbColNameMax);
+	return rc;
+}
+
+
+SQLRETURN SQLError(SQLHENV henv,
+	SQLHDBC      hdbc,
+	SQLHSTMT     hstmt,
+	SQLCHAR*     szSqlState,
+	SQLINTEGER*  pfNativeError,
+	SQLCHAR*     szErrorMsg,
+	SQLSMALLINT  cbErrorMsgMax,
+	SQLSMALLINT* pcbErrorMsg)
+{
+	throw NotImplementedException("SQLError is obsolete. "
+		"Use SQLGetDiagRec instead.");
+}
+
+
+SQLRETURN SQLExecDirect(SQLHSTMT hstmt,
+	SQLCHAR*   szSqlStr,
+	SQLINTEGER cbSqlStr)
+{
+	std::string sqlStr;
+	makeUTF16(szSqlStr, cbSqlStr, sqlStr);
+
+	return SQLExecDirectW(hstmt, (SQLWCHAR*) sqlStr.c_str(), cbSqlStr);
+}
+
+
+SQLRETURN SQLGetConnectAttr(SQLHDBC hdbc,
+	SQLINTEGER  fAttribute,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER  cbValueMax,
+	SQLINTEGER* pcbValue)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		Buffer<SQLWCHAR> buffer(stringLength(rgbValue, cbValueMax));
+
+		SQLRETURN rc = SQLGetConnectAttrW(hdbc,
+				fAttribute,
+				buffer.begin(),
+				(SQLINTEGER) buffer.sizeBytes(),
+				pcbValue);
+
+		makeUTF8(buffer, *pcbValue, rgbValue, cbValueMax);
+		return rc;
+	}
+	
+
+	return SQLGetConnectAttrW(hdbc,
+		fAttribute,
+		rgbValue,
+		cbValueMax,
+		pcbValue);
+}
+
+
+SQLRETURN SQLGetCursorName(SQLHSTMT hstmt,
+	SQLCHAR*     szCursor,
+	SQLSMALLINT  cbCursorMax,
+	SQLSMALLINT* pcbCursor)
+{
+	throw NotImplementedException("Not implemented");
+}
+
+
+SQLRETURN SQLSetDescField(SQLHDESC hdesc,
+	SQLSMALLINT iRecord, 
+	SQLSMALLINT iField,
+	SQLPOINTER  rgbValue, 
+	SQLINTEGER  cbValueMax)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		std::string str;
+		makeUTF16((SQLCHAR*) rgbValue, cbValueMax, str);
+
+		return SQLSetDescFieldW(hdesc,
+			iRecord, 
+			iField,
+			(SQLPOINTER) str.c_str(), 
+			(SQLINTEGER) str.size() * sizeof(SQLWCHAR));
+	}
+
+	return SQLSetDescFieldW(hdesc,
+		iRecord, 
+		iField,
+		rgbValue, 
+		cbValueMax);
+}
+
+
+SQLRETURN SQLGetDescField(SQLHDESC hdesc,
+	SQLSMALLINT iRecord,
+	SQLSMALLINT iField,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER	cbValueMax,
+	SQLINTEGER* pcbValue)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		Buffer<SQLWCHAR> buffer(stringLength(rgbValue, cbValueMax));
+
+		SQLRETURN rc = SQLGetDescFieldW(hdesc,
+			iRecord,
+			iField,
+			buffer.begin(),
+			(SQLINTEGER) buffer.sizeBytes(),
+			pcbValue);
+
+		makeUTF8(buffer, *pcbValue, rgbValue, cbValueMax);
+
+		return rc;
+	}
+
+	return SQLGetDescFieldW(hdesc,
+		iRecord,
+		iField,
+		rgbValue,
+		cbValueMax,
+		pcbValue);
+}
+
+
+SQLRETURN SQLGetDescRec(SQLHDESC hdesc,
+	SQLSMALLINT  iRecord,
+	SQLCHAR*     szName,
+	SQLSMALLINT  cbNameMax,
+	SQLSMALLINT* pcbName,
+	SQLSMALLINT* pfType,
+	SQLSMALLINT* pfSubType,
+	SQLLEN*      pLength,
+	SQLSMALLINT* pPrecision, 
+	SQLSMALLINT* pScale,
+	SQLSMALLINT* pNullable)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLGetDiagField(SQLSMALLINT fHandleType,
+	SQLHANDLE    handle,
+	SQLSMALLINT  iRecord,
+	SQLSMALLINT  fDiagField,
+	SQLPOINTER   rgbDiagInfo,
+	SQLSMALLINT  cbDiagInfoMax,
+	SQLSMALLINT* pcbDiagInfo)
+{
+	if (isString(rgbDiagInfo, cbDiagInfoMax))
+	{
+		Buffer<SQLWCHAR> buffer(stringLength(rgbDiagInfo, cbDiagInfoMax));
+
+		SQLRETURN rc = SQLGetDiagFieldW(fHandleType,
+			handle,
+			iRecord,
+			fDiagField,
+			buffer.begin(),
+			(SQLSMALLINT) buffer.sizeBytes(),
+			pcbDiagInfo);
+
+		makeUTF8(buffer, *pcbDiagInfo, rgbDiagInfo, cbDiagInfoMax);
+
+		return rc;
+	}
+
+	return SQLGetDiagFieldW(fHandleType,
+		handle,
+		iRecord,
+		fDiagField,
+		rgbDiagInfo,
+		cbDiagInfoMax,
+		pcbDiagInfo);
+}
+
+
+SQLRETURN SQLGetDiagRec(SQLSMALLINT fHandleType,
+	SQLHANDLE    handle,
+	SQLSMALLINT  iRecord,
+	SQLCHAR*     szSqlState,
+	SQLINTEGER*  pfNativeError,
+	SQLCHAR*     szErrorMsg,
+	SQLSMALLINT  cbErrorMsgMax,
+	SQLSMALLINT* pcbErrorMsg)
+{
+	const SQLINTEGER stateLen = SQL_SQLSTATE_SIZE + 1;
+	Buffer<SQLWCHAR> bufState(stateLen);
+	Buffer<SQLWCHAR> bufErr(cbErrorMsgMax);
+
+	SQLRETURN rc = SQLGetDiagRecW(fHandleType,
+		handle,
+		iRecord,
+		bufState.begin(),
+		pfNativeError,
+		bufErr.begin(),
+		(SQLSMALLINT) bufErr.size(),
+		pcbErrorMsg);
+
+	makeUTF8(bufState, stateLen * sizeof(SQLWCHAR), szSqlState, stateLen);
+	makeUTF8(bufErr, *pcbErrorMsg * sizeof(SQLWCHAR), szErrorMsg, cbErrorMsgMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLPrepare(SQLHSTMT hstmt,
+	SQLCHAR*   szSqlStr,
+	SQLINTEGER cbSqlStr)
+{
+	std::string sqlStr;
+	makeUTF16(szSqlStr, cbSqlStr, sqlStr);
+
+	return SQLPrepareW(hstmt, (SQLWCHAR*) sqlStr.c_str(), (SQLINTEGER) sqlStr.size());
+}
+
+
+SQLRETURN SQLSetConnectAttr(SQLHDBC hdbc,
+	SQLINTEGER fAttribute,
+	SQLPOINTER rgbValue,
+	SQLINTEGER cbValue)
+{
+	if (isString(rgbValue, cbValue))
+	{
+		std::string str;
+		makeUTF16((SQLCHAR*) rgbValue, cbValue, str);
+
+		return SQLSetConnectAttrW(hdbc,
+			fAttribute,
+			(SQLWCHAR*) str.c_str(), 
+			(SQLINTEGER) str.size() * sizeof(SQLWCHAR));
+	}
+
+	return SQLSetConnectAttrW(hdbc,	fAttribute,	rgbValue, cbValue);
+}
+
+
+SQLRETURN SQLSetCursorName(SQLHSTMT hstmt,
+	SQLCHAR*    szCursor,
+	SQLSMALLINT cbCursor)
+{
+	throw NotImplementedException("Not implemented");
+}
+
+
+SQLRETURN SQLSetStmtAttr(SQLHSTMT hstmt,
+	SQLINTEGER fAttribute,
+	SQLPOINTER rgbValue,
+	SQLINTEGER cbValueMax)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		std::string str;
+		makeUTF16((SQLCHAR*) rgbValue, cbValueMax, str);
+
+		return SQLSetStmtAttrW(hstmt,
+			fAttribute,
+			(SQLWCHAR*) str.c_str(),
+			(SQLINTEGER) str.size());
+	}
+
+	return SQLSetStmtAttrW(hstmt, fAttribute, rgbValue,	cbValueMax);
+}
+
+
+SQLRETURN SQLGetStmtAttr(SQLHSTMT hstmt,
+	SQLINTEGER  fAttribute,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER  cbValueMax,
+	SQLINTEGER* pcbValue)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		Buffer<SQLWCHAR> buffer(stringLength(rgbValue, cbValueMax));
+
+		return SQLGetStmtAttrW(hstmt,
+			fAttribute,
+			(SQLPOINTER) buffer.begin(),
+			(SQLINTEGER) buffer.sizeBytes(),
+			pcbValue);
+	}
+
+	return SQLGetStmtAttrW(hstmt, fAttribute, rgbValue, cbValueMax, pcbValue);
+}
+
+
+SQLRETURN SQLColumns(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLGetConnectOption(SQLHDBC hdbc,
+	SQLUSMALLINT fOption,
+	SQLPOINTER   pvParam)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLGetInfo(SQLHDBC hdbc,
+	SQLUSMALLINT fInfoType,
+	SQLPOINTER   rgbInfoValue,
+	SQLSMALLINT  cbInfoValueMax,
+	SQLSMALLINT* pcbInfoValue)
+{
+	if (cbInfoValueMax)
+	{
+		Buffer<SQLWCHAR> buffer(cbInfoValueMax);
+
+		SQLRETURN rc = SQLGetInfoW(hdbc,
+			fInfoType,
+			(SQLPOINTER) buffer.begin(),
+			(SQLSMALLINT) buffer.sizeBytes(),
+			pcbInfoValue);
+
+		makeUTF8(buffer, *pcbInfoValue, rgbInfoValue, cbInfoValueMax);
+		
+		return rc;
+	}
+
+	return SQLGetInfoW(hdbc, fInfoType, rgbInfoValue, cbInfoValueMax, pcbInfoValue);
+}
+
+
+SQLRETURN SQLGetTypeInfo(SQLHSTMT StatementHandle, SQLSMALLINT DataType)
+{
+	return SQLGetTypeInfoW(StatementHandle, DataType);
+}
+
+
+SQLRETURN SQLSetConnectOption(SQLHDBC hdbc,
+	SQLUSMALLINT fOption,
+	SQLULEN      vParam)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLSpecialColumns(SQLHSTMT hstmt,
+	SQLUSMALLINT fColType,
+	SQLCHAR*     szCatalogName,
+	SQLSMALLINT  cbCatalogName,
+	SQLCHAR*     szSchemaName,
+	SQLSMALLINT  cbSchemaName,
+	SQLCHAR*     szTableName,
+	SQLSMALLINT  cbTableName,
+	SQLUSMALLINT fScope,
+	SQLUSMALLINT fNullable)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLStatistics(SQLHSTMT hstmt,
+	SQLCHAR*     szCatalogName,
+	SQLSMALLINT  cbCatalogName,
+	SQLCHAR*     szSchemaName,
+	SQLSMALLINT  cbSchemaName,
+	SQLCHAR*     szTableName,
+	SQLSMALLINT  cbTableName,
+	SQLUSMALLINT fUnique,
+	SQLUSMALLINT fAccuracy)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLTables(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szTableType,
+	SQLSMALLINT cbTableType)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLDataSources(SQLHENV henv,
+	SQLUSMALLINT fDirection,
+	SQLCHAR*     szDSN,
+	SQLSMALLINT  cbDSNMax,
+	SQLSMALLINT* pcbDSN,
+	SQLCHAR*     szDesc,
+	SQLSMALLINT  cbDescMax,
+	SQLSMALLINT* pcbDesc)
+{
+	Buffer<SQLWCHAR> bufDSN(cbDSNMax);
+	Buffer<SQLWCHAR> bufDesc(cbDescMax);
+
+	SQLRETURN rc = SQLDataSourcesW(henv,
+		fDirection,
+		bufDSN.begin(),
+		(SQLSMALLINT) bufDSN.size(),
+		pcbDSN,
+		bufDesc.begin(),
+		(SQLSMALLINT) bufDesc.size(),
+		pcbDesc);
+
+	makeUTF8(bufDSN, *pcbDSN * sizeof(SQLWCHAR), szDSN, cbDSNMax);
+	makeUTF8(bufDesc, *pcbDesc * sizeof(SQLWCHAR), szDesc, cbDescMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLDriverConnect(SQLHDBC hdbc,
+	SQLHWND      hwnd,
+	SQLCHAR*     szConnStrIn,
+	SQLSMALLINT  cbConnStrIn,
+	SQLCHAR*     szConnStrOut,
+	SQLSMALLINT  cbConnStrOutMax,
+	SQLSMALLINT* pcbConnStrOut,
+	SQLUSMALLINT fDriverCompletion)
+{
+	SQLSMALLINT len = cbConnStrIn;
+	if (SQL_NTS == len) 
+		len = (SQLSMALLINT) std::strlen((const char*) szConnStrIn) + 1;
+
+	std::string connStrIn;
+	makeUTF16(szConnStrIn, len, connStrIn);
+	
+	Buffer<SQLWCHAR> out(cbConnStrOutMax);
+	SQLRETURN rc = SQLDriverConnectW(hdbc,
+		hwnd,
+		(SQLWCHAR*) connStrIn.c_str(),
+		(SQLSMALLINT) connStrIn.size(),
+		out.begin(),
+		cbConnStrOutMax,
+		pcbConnStrOut,
+		fDriverCompletion);
+
+	makeUTF8(out, *pcbConnStrOut * sizeof(SQLWCHAR), pcbConnStrOut, cbConnStrOutMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLBrowseConnect(SQLHDBC hdbc,
+	SQLCHAR*     szConnStrIn,
+	SQLSMALLINT  cbConnStrIn,
+	SQLCHAR*     szConnStrOut,
+	SQLSMALLINT  cbConnStrOutMax,
+	SQLSMALLINT* pcbConnStrOut)
+{
+	std::string str;
+	makeUTF16(szConnStrIn, cbConnStrIn, str);
+
+	Buffer<SQLWCHAR> bufConnStrOut(cbConnStrOutMax);
+
+	SQLRETURN rc = SQLBrowseConnectW(hdbc,
+		(SQLWCHAR*) str.c_str(),
+		(SQLSMALLINT) str.size(),
+		bufConnStrOut.begin(),
+		(SQLSMALLINT) bufConnStrOut.size(),
+		pcbConnStrOut);
+
+	makeUTF8(bufConnStrOut, *pcbConnStrOut * sizeof(SQLWCHAR), szConnStrOut, cbConnStrOutMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLColumnPrivileges(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLForeignKeys(SQLHSTMT hstmt,
+	SQLCHAR*    szPkCatalogName,
+	SQLSMALLINT cbPkCatalogName,
+	SQLCHAR*    szPkSchemaName,
+	SQLSMALLINT cbPkSchemaName,
+	SQLCHAR*    szPkTableName,
+	SQLSMALLINT cbPkTableName,
+	SQLCHAR*    szFkCatalogName,
+	SQLSMALLINT cbFkCatalogName,
+	SQLCHAR*    szFkSchemaName,
+	SQLSMALLINT cbFkSchemaName,
+	SQLCHAR*    szFkTableName,
+	SQLSMALLINT cbFkTableName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLNativeSql(SQLHDBC hdbc,
+	SQLCHAR*    szSqlStrIn,
+	SQLINTEGER  cbSqlStrIn,
+	SQLCHAR*    szSqlStr,
+	SQLINTEGER  cbSqlStrMax,
+	SQLINTEGER* pcbSqlStr)
+{
+	std::string str;
+	makeUTF16(szSqlStrIn, cbSqlStrIn, str);
+
+	Buffer<SQLWCHAR> bufSQLOut(cbSqlStrMax);
+
+	SQLRETURN rc = SQLNativeSqlW(hdbc,
+		(SQLWCHAR*) str.c_str(),
+		(SQLINTEGER) str.size(),
+		bufSQLOut.begin(),
+		(SQLINTEGER) bufSQLOut.size(),
+		pcbSqlStr);
+
+	makeUTF8(bufSQLOut, *pcbSqlStr * sizeof(SQLWCHAR), szSqlStr, cbSqlStrMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLPrimaryKeys(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLProcedureColumns(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szProcName,
+	SQLSMALLINT cbProcName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLProcedures(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szProcName,
+	SQLSMALLINT cbProcName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLTablePrivileges(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLDrivers(SQLHENV henv,
+	SQLUSMALLINT fDirection,
+	SQLCHAR*     szDriverDesc,
+	SQLSMALLINT  cbDriverDescMax,
+	SQLSMALLINT* pcbDriverDesc,
+	SQLCHAR*     szDriverAttributes,
+	SQLSMALLINT  cbDrvrAttrMax,
+	SQLSMALLINT* pcbDrvrAttr)
+{
+	Buffer<SQLWCHAR> bufDriverDesc(cbDriverDescMax);
+	Buffer<SQLWCHAR> bufDriverAttr(cbDrvrAttrMax);
+
+	SQLRETURN rc = SQLDriversW(henv,
+		fDirection,
+		bufDriverDesc.begin(),
+		(SQLSMALLINT) bufDriverDesc.size(),
+		pcbDriverDesc,
+		bufDriverAttr.begin(),
+		(SQLSMALLINT) bufDriverAttr.size(),
+		pcbDrvrAttr);
+
+	makeUTF8(bufDriverDesc, *pcbDriverDesc * sizeof(SQLWCHAR), szDriverDesc, cbDriverDescMax);
+	makeUTF8(bufDriverAttr, *pcbDrvrAttr * sizeof(SQLWCHAR), szDriverAttributes, cbDrvrAttrMax);
+
+	return rc;
+}
+
+
+} } } // namespace Poco::Data::ODBC
diff --git a/base/poco/Data/ODBC/src/Unicode_WIN32.cpp b/base/poco/Data/ODBC/src/Unicode_WIN32.cpp
new file mode 100644
index 00000000000..fe637e49b3d
--- /dev/null
+++ b/base/poco/Data/ODBC/src/Unicode_WIN32.cpp
@@ -0,0 +1,761 @@
+//
+// Unicode.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Unicode
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/ODBC.h"
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/Unicode_WIN32.h"
+#include "Poco/Buffer.h"
+#include "Poco/Exception.h"
+
+
+using Poco::Buffer;
+using Poco::InvalidArgumentException;
+using Poco::NotImplementedException;
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+SQLRETURN SQLColAttribute(SQLHSTMT hstmt,
+	SQLUSMALLINT   iCol,
+	SQLUSMALLINT   iField,
+	SQLPOINTER	   pCharAttr,
+	SQLSMALLINT	   cbCharAttrMax,
+	SQLSMALLINT*   pcbCharAttr,
+	NumAttrPtrType pNumAttr)
+{
+	if (isString(pCharAttr, cbCharAttrMax))
+	{
+		Buffer<wchar_t> buffer(stringLength(pCharAttr, cbCharAttrMax));
+
+		SQLRETURN rc = SQLColAttributeW(hstmt,
+			iCol,
+			iField,
+			buffer.begin(),
+			(SQLSMALLINT) buffer.sizeBytes(),
+			pcbCharAttr,
+			pNumAttr);
+
+		makeUTF8(buffer, *pcbCharAttr, pCharAttr, cbCharAttrMax);
+		return rc;
+	}
+
+	return SQLColAttributeW(hstmt,
+		iCol,
+		iField,
+		pCharAttr,
+		cbCharAttrMax,
+		pcbCharAttr,
+		pNumAttr);
+}
+
+
+SQLRETURN SQLColAttributes(SQLHSTMT hstmt,
+	SQLUSMALLINT icol,
+	SQLUSMALLINT fDescType,
+	SQLPOINTER   rgbDesc,
+	SQLSMALLINT  cbDescMax,
+	SQLSMALLINT* pcbDesc,
+	SQLLEN*      pfDesc)
+{
+	return SQLColAttribute(hstmt,
+		icol,
+		fDescType,
+		rgbDesc,
+		cbDescMax,
+		pcbDesc,
+		pfDesc);
+}
+
+
+SQLRETURN SQLConnect(SQLHDBC hdbc,
+	SQLCHAR*    szDSN,
+	SQLSMALLINT cbDSN,
+	SQLCHAR*    szUID,
+	SQLSMALLINT cbUID,
+	SQLCHAR*    szAuthStr,
+	SQLSMALLINT cbAuthStr)
+{
+	std::wstring sqlDSN;
+	makeUTF16(szDSN, cbDSN, sqlDSN);
+
+	std::wstring sqlUID;
+	makeUTF16(szUID, cbUID, sqlUID);
+
+	std::wstring sqlPWD;
+	makeUTF16(szAuthStr, cbAuthStr, sqlPWD);
+	
+	return SQLConnectW(hdbc,
+		(SQLWCHAR*) sqlDSN.c_str(),
+		(SQLSMALLINT) sqlDSN.size(),
+		(SQLWCHAR*) sqlUID.c_str(),
+		(SQLSMALLINT) sqlUID.size(),
+		(SQLWCHAR*) sqlPWD.c_str(),
+		(SQLSMALLINT) sqlPWD.size());
+}
+
+
+SQLRETURN SQLDescribeCol(SQLHSTMT hstmt,
+	SQLUSMALLINT icol,
+	SQLCHAR*     szColName,
+	SQLSMALLINT  cbColNameMax,
+	SQLSMALLINT* pcbColName,
+	SQLSMALLINT* pfSqlType,
+	SQLULEN*     pcbColDef,
+	SQLSMALLINT* pibScale,
+	SQLSMALLINT* pfNullable)
+{
+	Buffer<wchar_t> buffer(cbColNameMax);
+	SQLRETURN rc = SQLDescribeColW(hstmt,
+		icol,
+		(SQLWCHAR*) buffer.begin(),
+		(SQLSMALLINT) buffer.size(),
+		pcbColName,
+		pfSqlType,
+		pcbColDef,
+		pibScale,
+		pfNullable);
+
+	makeUTF8(buffer, *pcbColName * sizeof(wchar_t), szColName, cbColNameMax);
+	return rc;
+}
+
+
+SQLRETURN SQLError(SQLHENV henv,
+	SQLHDBC      hdbc,
+	SQLHSTMT     hstmt,
+	SQLCHAR*     szSqlState,
+	SQLINTEGER*  pfNativeError,
+	SQLCHAR*     szErrorMsg,
+	SQLSMALLINT  cbErrorMsgMax,
+	SQLSMALLINT* pcbErrorMsg)
+{
+	throw NotImplementedException("SQLError is obsolete. "
+		"Use SQLGetDiagRec instead.");
+}
+
+
+SQLRETURN SQLExecDirect(SQLHSTMT hstmt,
+	SQLCHAR*   szSqlStr,
+	SQLINTEGER cbSqlStr)
+{
+	std::wstring sqlStr;
+	makeUTF16(szSqlStr, cbSqlStr, sqlStr);
+
+	return SQLExecDirectW(hstmt, 
+		(SQLWCHAR*) sqlStr.c_str(), 
+		(SQLINTEGER) sqlStr.size());
+}
+
+
+SQLRETURN SQLGetConnectAttr(SQLHDBC hdbc,
+	SQLINTEGER  fAttribute,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER  cbValueMax,
+	SQLINTEGER* pcbValue)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		Buffer<wchar_t> buffer(stringLength(rgbValue, cbValueMax));
+
+		SQLRETURN rc = SQLGetConnectAttrW(hdbc,
+				fAttribute,
+				buffer.begin(),
+				(SQLINTEGER) buffer.sizeBytes(),
+				pcbValue);
+
+		makeUTF8(buffer, *pcbValue, rgbValue, cbValueMax);
+		return rc;
+	}
+	
+
+	return SQLGetConnectAttrW(hdbc,
+		fAttribute,
+		rgbValue,
+		cbValueMax,
+		pcbValue);
+}
+
+
+SQLRETURN SQLGetCursorName(SQLHSTMT hstmt,
+	SQLCHAR*     szCursor,
+	SQLSMALLINT  cbCursorMax,
+	SQLSMALLINT* pcbCursor)
+{
+	throw NotImplementedException("Not implemented");
+}
+
+
+SQLRETURN SQLSetDescField(SQLHDESC hdesc,
+	SQLSMALLINT iRecord, 
+	SQLSMALLINT iField,
+	SQLPOINTER  rgbValue, 
+	SQLINTEGER  cbValueMax)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		std::wstring str;
+		makeUTF16((SQLCHAR*) rgbValue, cbValueMax, str);
+
+		SQLRETURN rc = SQLSetDescFieldW(hdesc,
+			iRecord, 
+			iField,
+			(SQLPOINTER) str.c_str(), 
+			(SQLINTEGER) str.size() * sizeof(std::wstring::value_type));
+
+		return rc;
+	}
+
+	return SQLSetDescFieldW(hdesc,
+		iRecord, 
+		iField,
+		rgbValue, 
+		cbValueMax);
+}
+
+
+SQLRETURN SQLGetDescField(SQLHDESC hdesc,
+	SQLSMALLINT iRecord,
+	SQLSMALLINT iField,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER	cbValueMax,
+	SQLINTEGER* pcbValue)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		Buffer<wchar_t> buffer(stringLength(rgbValue, cbValueMax));
+
+		SQLRETURN rc = SQLGetDescFieldW(hdesc,
+			iRecord,
+			iField,
+			buffer.begin(),
+			(SQLINTEGER) buffer.sizeBytes(),
+			pcbValue);
+
+		makeUTF8(buffer, *pcbValue, rgbValue, cbValueMax);
+		return rc;
+	}
+
+	return SQLGetDescFieldW(hdesc,
+		iRecord,
+		iField,
+		rgbValue,
+		cbValueMax,
+		pcbValue);
+}
+
+
+SQLRETURN SQLGetDescRec(SQLHDESC hdesc,
+	SQLSMALLINT  iRecord,
+	SQLCHAR*     szName,
+	SQLSMALLINT  cbNameMax,
+	SQLSMALLINT* pcbName,
+	SQLSMALLINT* pfType,
+	SQLSMALLINT* pfSubType,
+	SQLLEN*      pLength,
+	SQLSMALLINT* pPrecision, 
+	SQLSMALLINT* pScale,
+	SQLSMALLINT* pNullable)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLGetDiagField(SQLSMALLINT fHandleType,
+	SQLHANDLE    handle,
+	SQLSMALLINT  iRecord,
+	SQLSMALLINT  fDiagField,
+	SQLPOINTER   rgbDiagInfo,
+	SQLSMALLINT  cbDiagInfoMax,
+	SQLSMALLINT* pcbDiagInfo)
+{
+	if (isString(rgbDiagInfo, cbDiagInfoMax))
+	{
+		Buffer<wchar_t> buffer(stringLength(rgbDiagInfo, cbDiagInfoMax));
+
+		SQLRETURN rc = SQLGetDiagFieldW(fHandleType,
+			handle,
+			iRecord,
+			fDiagField,
+			buffer.begin(),
+			(SQLSMALLINT) buffer.sizeBytes(),
+			pcbDiagInfo);
+
+		makeUTF8(buffer, *pcbDiagInfo, rgbDiagInfo, cbDiagInfoMax);
+		return rc;
+	}
+
+	return SQLGetDiagFieldW(fHandleType,
+		handle,
+		iRecord,
+		fDiagField,
+		rgbDiagInfo,
+		cbDiagInfoMax,
+		pcbDiagInfo);
+}
+
+
+SQLRETURN SQLGetDiagRec(SQLSMALLINT fHandleType,
+	SQLHANDLE    handle,
+	SQLSMALLINT  iRecord,
+	SQLCHAR*     szSqlState,
+	SQLINTEGER*  pfNativeError,
+	SQLCHAR*     szErrorMsg,
+	SQLSMALLINT  cbErrorMsgMax,
+	SQLSMALLINT* pcbErrorMsg)
+{
+	const SQLINTEGER stateLen = SQL_SQLSTATE_SIZE + 1;
+	Buffer<wchar_t> bufState(stateLen);
+	Buffer<wchar_t> bufErr(cbErrorMsgMax);
+
+	SQLRETURN rc = SQLGetDiagRecW(fHandleType,
+		handle,
+		iRecord,
+		bufState.begin(),
+		pfNativeError,
+		bufErr.begin(),
+		(SQLSMALLINT) bufErr.size(),
+		pcbErrorMsg);
+
+	makeUTF8(bufState, stateLen * sizeof(wchar_t), szSqlState, stateLen);
+	makeUTF8(bufErr, *pcbErrorMsg * sizeof(wchar_t), szErrorMsg, cbErrorMsgMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLPrepare(SQLHSTMT hstmt,
+	SQLCHAR*   szSqlStr,
+	SQLINTEGER cbSqlStr)
+{
+	std::wstring sqlStr;
+	makeUTF16(szSqlStr, cbSqlStr, sqlStr);
+
+	return SQLPrepareW(hstmt, 
+		(SQLWCHAR*) sqlStr.c_str(), 
+		(SQLINTEGER) sqlStr.size());
+}
+
+
+SQLRETURN SQLSetConnectAttr(SQLHDBC hdbc,
+	SQLINTEGER fAttribute,
+	SQLPOINTER rgbValue,
+	SQLINTEGER cbValue)
+{
+	if (isString(rgbValue, cbValue))
+	{
+		std::wstring str;
+		makeUTF16((SQLCHAR*) rgbValue, cbValue, str);
+
+		return SQLSetConnectAttrW(hdbc,
+			fAttribute,
+			(SQLWCHAR*) str.c_str(), 
+			(SQLINTEGER) str.size() * sizeof(std::wstring::value_type));
+	}
+
+	return SQLSetConnectAttrW(hdbc,
+		fAttribute,
+		rgbValue, 
+		cbValue);
+}
+
+
+SQLRETURN SQLSetCursorName(SQLHSTMT hstmt,
+	SQLCHAR*    szCursor,
+	SQLSMALLINT cbCursor)
+{
+	throw NotImplementedException("Not implemented");
+}
+
+
+SQLRETURN SQLSetStmtAttr(SQLHSTMT hstmt,
+	SQLINTEGER fAttribute,
+	SQLPOINTER rgbValue,
+	SQLINTEGER cbValueMax)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		std::wstring str;
+		makeUTF16((SQLCHAR*) rgbValue, cbValueMax, str);
+
+		return SQLSetStmtAttrW(hstmt,
+			fAttribute,
+			(SQLPOINTER) str.c_str(),
+			(SQLINTEGER) str.size());
+	}
+
+	return SQLSetStmtAttrW(hstmt,
+		fAttribute,
+		rgbValue,
+		cbValueMax);
+}
+
+
+SQLRETURN SQLGetStmtAttr(SQLHSTMT hstmt,
+	SQLINTEGER  fAttribute,
+	SQLPOINTER  rgbValue,
+	SQLINTEGER  cbValueMax,
+	SQLINTEGER* pcbValue)
+{
+	if (isString(rgbValue, cbValueMax))
+	{
+		Buffer<wchar_t> buffer(stringLength(rgbValue, cbValueMax));
+
+		return SQLGetStmtAttrW(hstmt,
+			fAttribute,
+			(SQLPOINTER) buffer.begin(),
+			(SQLINTEGER) buffer.sizeBytes(),
+			pcbValue);
+	}
+
+	return SQLGetStmtAttrW(hstmt,
+			fAttribute,
+			rgbValue,
+			cbValueMax,
+			pcbValue);
+}
+
+
+SQLRETURN SQLColumns(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLGetConnectOption(SQLHDBC hdbc,
+	SQLUSMALLINT fOption,
+	SQLPOINTER   pvParam)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLGetInfo(SQLHDBC hdbc,
+	SQLUSMALLINT fInfoType,
+	SQLPOINTER   rgbInfoValue,
+	SQLSMALLINT  cbInfoValueMax,
+	SQLSMALLINT* pcbInfoValue)
+{
+	if (cbInfoValueMax)
+	{
+		Buffer<wchar_t> buffer(cbInfoValueMax);
+
+		SQLRETURN rc = SQLGetInfoW(hdbc,
+			fInfoType,
+			(SQLPOINTER) buffer.begin(),
+			(SQLSMALLINT) buffer.sizeBytes(),
+			pcbInfoValue);
+
+		makeUTF8(buffer, *pcbInfoValue, rgbInfoValue, cbInfoValueMax);
+
+		return rc;
+	}
+
+	return SQLGetInfoW(hdbc,
+		fInfoType,
+		rgbInfoValue,
+		cbInfoValueMax,
+		pcbInfoValue);
+}
+
+
+SQLRETURN SQLGetTypeInfo(SQLHSTMT StatementHandle, SQLSMALLINT DataType)
+{
+	return SQLGetTypeInfoW(StatementHandle, DataType);
+}
+
+
+SQLRETURN SQLSetConnectOption(SQLHDBC hdbc,
+	SQLUSMALLINT fOption,
+	SQLULEN      vParam)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLSpecialColumns(SQLHSTMT hstmt,
+	SQLUSMALLINT fColType,
+	SQLCHAR*     szCatalogName,
+	SQLSMALLINT  cbCatalogName,
+	SQLCHAR*     szSchemaName,
+	SQLSMALLINT  cbSchemaName,
+	SQLCHAR*     szTableName,
+	SQLSMALLINT  cbTableName,
+	SQLUSMALLINT fScope,
+	SQLUSMALLINT fNullable)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLStatistics(SQLHSTMT hstmt,
+	SQLCHAR*     szCatalogName,
+	SQLSMALLINT  cbCatalogName,
+	SQLCHAR*     szSchemaName,
+	SQLSMALLINT  cbSchemaName,
+	SQLCHAR*     szTableName,
+	SQLSMALLINT  cbTableName,
+	SQLUSMALLINT fUnique,
+	SQLUSMALLINT fAccuracy)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLTables(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szTableType,
+	SQLSMALLINT cbTableType)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLDataSources(SQLHENV henv,
+	SQLUSMALLINT fDirection,
+	SQLCHAR*     szDSN,
+	SQLSMALLINT  cbDSNMax,
+	SQLSMALLINT* pcbDSN,
+	SQLCHAR*     szDesc,
+	SQLSMALLINT  cbDescMax,
+	SQLSMALLINT* pcbDesc)
+{
+	Buffer<wchar_t> bufDSN(cbDSNMax);
+	Buffer<wchar_t> bufDesc(cbDescMax);
+
+	SQLRETURN rc = SQLDataSourcesW(henv,
+		fDirection,
+		bufDSN.begin(),
+		(SQLSMALLINT) bufDSN.size(),
+		pcbDSN,
+		bufDesc.begin(),
+		(SQLSMALLINT) bufDesc.size(),
+		pcbDesc);
+
+	makeUTF8(bufDSN, *pcbDSN * sizeof(wchar_t), szDSN, cbDSNMax);
+	makeUTF8(bufDesc, *pcbDesc * sizeof(wchar_t), szDesc, cbDescMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLDriverConnect(SQLHDBC hdbc,
+	SQLHWND      hwnd,
+	SQLCHAR*     szConnStrIn,
+	SQLSMALLINT  cbConnStrIn,
+	SQLCHAR*     szConnStrOut,
+	SQLSMALLINT  cbConnStrOutMax,
+	SQLSMALLINT* pcbConnStrOut,
+	SQLUSMALLINT fDriverCompletion)
+{
+	std::wstring connStrIn;
+	int len = cbConnStrIn;
+	if (SQL_NTS == len) 
+		len = (int) std::strlen((const char*) szConnStrIn);
+
+	Poco::UnicodeConverter::toUTF16((const char *) szConnStrIn, len, connStrIn);
+
+	Buffer<wchar_t> bufOut(cbConnStrOutMax);
+	SQLRETURN rc = SQLDriverConnectW(hdbc,
+		hwnd,
+		(SQLWCHAR*) connStrIn.c_str(),
+		(SQLSMALLINT) connStrIn.size(),
+		bufOut.begin(),
+		(SQLSMALLINT) bufOut.size(),
+		pcbConnStrOut,
+		fDriverCompletion);
+
+	if (!Utility::isError(rc))
+		makeUTF8(bufOut, *pcbConnStrOut * sizeof(wchar_t), szConnStrOut, cbConnStrOutMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLBrowseConnect(SQLHDBC hdbc,
+	SQLCHAR*     szConnStrIn,
+	SQLSMALLINT  cbConnStrIn,
+	SQLCHAR*     szConnStrOut,
+	SQLSMALLINT  cbConnStrOutMax,
+	SQLSMALLINT* pcbConnStrOut)
+{
+	std::wstring str;
+	makeUTF16(szConnStrIn, cbConnStrIn, str);
+
+	Buffer<wchar_t> bufConnStrOut(cbConnStrOutMax);
+
+	SQLRETURN rc = SQLBrowseConnectW(hdbc,
+		(SQLWCHAR*) str.c_str(),
+		(SQLSMALLINT) str.size(),
+		bufConnStrOut.begin(),
+		(SQLSMALLINT) bufConnStrOut.size(),
+		pcbConnStrOut);
+
+	makeUTF8(bufConnStrOut, *pcbConnStrOut * sizeof(wchar_t), szConnStrOut, cbConnStrOutMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLColumnPrivileges(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLForeignKeys(SQLHSTMT hstmt,
+	SQLCHAR*    szPkCatalogName,
+	SQLSMALLINT cbPkCatalogName,
+	SQLCHAR*    szPkSchemaName,
+	SQLSMALLINT cbPkSchemaName,
+	SQLCHAR*    szPkTableName,
+	SQLSMALLINT cbPkTableName,
+	SQLCHAR*    szFkCatalogName,
+	SQLSMALLINT cbFkCatalogName,
+	SQLCHAR*    szFkSchemaName,
+	SQLSMALLINT cbFkSchemaName,
+	SQLCHAR*    szFkTableName,
+	SQLSMALLINT cbFkTableName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLNativeSql(SQLHDBC hdbc,
+	SQLCHAR*    szSqlStrIn,
+	SQLINTEGER  cbSqlStrIn,
+	SQLCHAR*    szSqlStr,
+	SQLINTEGER  cbSqlStrMax,
+	SQLINTEGER* pcbSqlStr)
+{
+	std::wstring str;
+	makeUTF16(szSqlStrIn, cbSqlStrIn, str);
+
+	Buffer<wchar_t> bufSQLOut(cbSqlStrMax);
+
+	SQLRETURN rc = SQLNativeSqlW(hdbc,
+		(SQLWCHAR*) str.c_str(),
+		(SQLINTEGER) str.size(),
+		bufSQLOut.begin(),
+		(SQLINTEGER) bufSQLOut.size(),
+		pcbSqlStr);
+
+	makeUTF8(bufSQLOut, *pcbSqlStr * sizeof(wchar_t), szSqlStr, cbSqlStrMax);
+
+	return rc;
+}
+
+
+SQLRETURN SQLPrimaryKeys(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLProcedureColumns(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szProcName,
+	SQLSMALLINT cbProcName,
+	SQLCHAR*    szColumnName,
+	SQLSMALLINT cbColumnName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLProcedures(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szProcName,
+	SQLSMALLINT cbProcName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLTablePrivileges(SQLHSTMT hstmt,
+	SQLCHAR*    szCatalogName,
+	SQLSMALLINT cbCatalogName,
+	SQLCHAR*    szSchemaName,
+	SQLSMALLINT cbSchemaName,
+	SQLCHAR*    szTableName,
+	SQLSMALLINT cbTableName)
+{
+	throw NotImplementedException();
+}
+
+
+SQLRETURN SQLDrivers(SQLHENV henv,
+	SQLUSMALLINT fDirection,
+	SQLCHAR*     szDriverDesc,
+	SQLSMALLINT  cbDriverDescMax,
+	SQLSMALLINT* pcbDriverDesc,
+	SQLCHAR*     szDriverAttributes,
+	SQLSMALLINT  cbDrvrAttrMax,
+	SQLSMALLINT* pcbDrvrAttr)
+{
+	Buffer<wchar_t> bufDriverDesc(cbDriverDescMax);
+	Buffer<wchar_t> bufDriverAttr(cbDrvrAttrMax);
+
+	SQLRETURN rc = SQLDriversW(henv,
+		fDirection,
+		bufDriverDesc.begin(),
+		(SQLSMALLINT) bufDriverDesc.size(),
+		pcbDriverDesc,
+		bufDriverAttr.begin(),
+		(SQLSMALLINT) bufDriverAttr.size(),
+		pcbDrvrAttr);
+
+	makeUTF8(bufDriverDesc, *pcbDriverDesc * sizeof(wchar_t), szDriverDesc, cbDriverDescMax);
+	makeUTF8(bufDriverAttr, *pcbDrvrAttr * sizeof(wchar_t), szDriverAttributes, cbDrvrAttrMax);
+
+	return rc;
+}
+
+
+} } } // namespace Poco::Data::ODBC
diff --git a/base/poco/Data/ODBC/src/Utility.cpp b/base/poco/Data/ODBC/src/Utility.cpp
new file mode 100644
index 00000000000..62a22a40b3d
--- /dev/null
+++ b/base/poco/Data/ODBC/src/Utility.cpp
@@ -0,0 +1,159 @@
+//
+// Utility.cpp
+//
+// Library: Data/ODBC
+// Package: ODBC
+// Module:  Utility
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ODBC/Utility.h"
+#include "Poco/Data/ODBC/Handle.h"
+#include "Poco/Data/ODBC/ODBCException.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/DateTime.h"
+#include <cmath>
+
+
+namespace Poco {
+namespace Data {
+namespace ODBC {
+
+
+const TypeInfo Utility::_dataTypes;
+
+
+Utility::DriverMap& Utility::drivers(Utility::DriverMap& driverMap)
+{
+	static const EnvironmentHandle henv;
+	const int length = sizeof(SQLCHAR) * 512;
+
+	SQLCHAR desc[length];
+	std::memset(desc, 0, length);
+	SQLSMALLINT len1 = length;
+	SQLCHAR attr[length];
+	std::memset(attr, 0, length);
+	SQLSMALLINT len2 = length;
+	RETCODE rc = 0;
+
+	if (!Utility::isError(rc = SQLDrivers(henv, 
+		SQL_FETCH_FIRST,
+		desc,
+		length,
+		&len1,
+		attr,
+		len2,
+		&len2)))
+	{
+		do
+		{
+			driverMap.insert(DSNMap::value_type(std::string((char *) desc), 
+				std::string((char *) attr)));
+			std::memset(desc, 0, length);
+			std::memset(attr, 0, length);
+			len2 = length;
+		}while (!Utility::isError(rc = SQLDrivers(henv, 
+			SQL_FETCH_NEXT,
+			desc,
+			length,
+			&len1,
+			attr,
+			len2,
+			&len2)));
+	}
+
+	if (SQL_NO_DATA != rc) 
+		throw EnvironmentException(henv);
+
+	return driverMap;
+}
+
+
+Utility::DSNMap& Utility::dataSources(Utility::DSNMap& dsnMap)
+{
+	static const EnvironmentHandle henv;
+	const int length = sizeof(SQLCHAR) * 512;
+	const int dsnLength = sizeof(SQLCHAR) * (SQL_MAX_DSN_LENGTH + 1);
+
+	SQLCHAR dsn[dsnLength];
+	std::memset(dsn, 0, dsnLength);
+	SQLSMALLINT len1 = sizeof(SQLCHAR) * SQL_MAX_DSN_LENGTH;
+	SQLCHAR desc[length];
+	std::memset(desc, 0, length);
+	SQLSMALLINT len2 = length;
+	RETCODE rc = 0;
+
+	while (!Utility::isError(rc = Poco::Data::ODBC::SQLDataSources(henv, 
+		SQL_FETCH_NEXT,
+		dsn,
+		SQL_MAX_DSN_LENGTH,
+		&len1,
+		desc,
+		len2,
+		&len2)))
+	{
+		dsnMap.insert(DSNMap::value_type(std::string((char *) dsn), std::string((char *) desc)));
+		std::memset(dsn, 0, dsnLength);
+		std::memset(desc, 0, length);
+		len2 = length;
+	}
+
+	if (SQL_NO_DATA != rc) 
+		throw EnvironmentException(henv);
+
+	return dsnMap;
+}
+
+
+void Utility::dateTimeSync(Poco::DateTime& dt, const SQL_TIMESTAMP_STRUCT& ts)
+{
+	double msec = ts.fraction/1000000;
+	double usec = 1000 * (msec - std::floor(msec));
+
+	dt.assign(ts.year,
+		ts.month,
+		ts.day,
+		ts.hour,
+		ts.minute,
+		ts.second,
+		(int) std::floor(msec),
+		(int) std::floor(usec));
+}
+
+
+void Utility::dateSync(SQL_DATE_STRUCT& ds, const Date& d)
+{
+	ds.year = d.year();
+	ds.month = d.month();
+	ds.day = d.day();
+}
+
+
+void Utility::timeSync(SQL_TIME_STRUCT& ts, const Time& t)
+{
+	ts.hour = t.hour();
+	ts.minute = t.minute();
+	ts.second = t.second();
+}
+
+
+void Utility::dateTimeSync(SQL_TIMESTAMP_STRUCT& ts, const Poco::DateTime& dt)
+{
+	ts.year = dt.year();
+	ts.month = dt.month();
+	ts.day = dt.day();
+	ts.hour = dt.hour();
+	ts.minute = dt.minute();
+	ts.second = dt.second();
+	// Fraction support is limited to milliseconds due to MS SQL Server limitation
+	// see http://support.microsoft.com/kb/263872
+	ts.fraction = (dt.millisecond() * 1000000);// + (dt.microsecond() * 1000);
+}
+
+
+} } } // namespace Poco::Data::ODBC
diff --git a/base/poco/Data/include/Poco/Data/AbstractBinder.h b/base/poco/Data/include/Poco/Data/AbstractBinder.h
new file mode 100644
index 00000000000..d88efba0a91
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/AbstractBinder.h
@@ -0,0 +1,373 @@
+//
+// AbstractBinder.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractBinder
+//
+// Definition of the AbstractBinder class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_AbstractBinder_INCLUDED
+#define Data_AbstractBinder_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/Date.h"
+#include "Poco/Data/Time.h"
+#include "Poco/Data/LOB.h"
+#include "Poco/DateTime.h"
+#include "Poco/Nullable.h"
+#include "Poco/Any.h"
+#include "Poco/Dynamic/Var.h"
+#include "Poco/UTFString.h"
+#include <vector>
+#include <deque>
+#include <list>
+#include <cstddef>
+
+
+namespace Poco {
+namespace Data {
+
+
+typedef NullType NullData;
+
+
+namespace Keywords {
+
+
+static const NullData null = NULL_GENERIC;
+
+
+} // namespace Keywords
+
+
+class Data_API AbstractBinder
+	/// Interface for Binding data types to placeholders.
+{
+public:
+	typedef SharedPtr<AbstractBinder> Ptr;
+
+	enum Direction
+		/// Binding direction for a parameter.
+	{
+		PD_IN,
+		PD_OUT,
+		PD_IN_OUT
+	};
+
+	AbstractBinder();
+		/// Creates the AbstractBinder.
+
+	virtual ~AbstractBinder();
+		/// Destroys the AbstractBinder.
+
+	virtual void bind(std::size_t pos, const Poco::Int8& val, Direction dir = PD_IN) = 0;
+		/// Binds an Int8.
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::Int8>& val, Direction dir = PD_IN);
+		/// Binds an Int8 vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::Int8>& val, Direction dir = PD_IN);
+		/// Binds an Int8 deque.
+
+	virtual void bind(std::size_t pos, const std::list<Poco::Int8>& val, Direction dir = PD_IN);
+		/// Binds an Int8 list.
+
+	virtual void bind(std::size_t pos, const Poco::UInt8& val, Direction dir = PD_IN) = 0;
+		/// Binds an UInt8.
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::UInt8>& val, Direction dir = PD_IN);
+		/// Binds an UInt8 vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::UInt8>& val, Direction dir = PD_IN);
+		/// Binds an UInt8 deque.
+
+	virtual void bind(std::size_t pos, const std::list<Poco::UInt8>& val, Direction dir = PD_IN);
+		/// Binds an UInt8 list.
+
+	virtual void bind(std::size_t pos, const Poco::Int16& val, Direction dir = PD_IN) = 0;
+		/// Binds an Int16.
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::Int16>& val, Direction dir = PD_IN);
+		/// Binds an Int16 vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::Int16>& val, Direction dir = PD_IN);
+		/// Binds an Int16 deque.
+
+	virtual void bind(std::size_t pos, const std::list<Poco::Int16>& val, Direction dir = PD_IN);
+		/// Binds an Int16 list.
+
+	virtual void bind(std::size_t pos, const Poco::UInt16& val, Direction dir = PD_IN) = 0;
+		/// Binds an UInt16.
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::UInt16>& val, Direction dir = PD_IN);
+		/// Binds an UInt16 vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::UInt16>& val, Direction dir = PD_IN);
+		/// Binds an UInt16 deque.
+
+	virtual void bind(std::size_t pos, const std::list<Poco::UInt16>& val, Direction dir = PD_IN);
+		/// Binds an UInt16 list.
+
+	virtual void bind(std::size_t pos, const Poco::Int32& val, Direction dir = PD_IN) = 0;
+		/// Binds an Int32.
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::Int32>& val, Direction dir = PD_IN);
+		/// Binds an Int32 vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::Int32>& val, Direction dir = PD_IN);
+		/// Binds an Int32 deque.
+
+	virtual void bind(std::size_t pos, const std::list<Poco::Int32>& val, Direction dir = PD_IN);
+		/// Binds an Int32 list.
+
+	virtual void bind(std::size_t pos, const Poco::UInt32& val, Direction dir = PD_IN) = 0;
+		/// Binds an UInt32.
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::UInt32>& val, Direction dir = PD_IN);
+		/// Binds an UInt32 vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::UInt32>& val, Direction dir = PD_IN);
+		/// Binds an UInt32 deque.
+
+	virtual void bind(std::size_t pos, const std::list<Poco::UInt32>& val, Direction dir = PD_IN);
+		/// Binds an UInt32 list.
+		
+	virtual void bind(std::size_t pos, const Poco::Int64& val, Direction dir = PD_IN) = 0;
+		/// Binds an Int64.
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::Int64>& val, Direction dir = PD_IN);
+		/// Binds an Int64 vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::Int64>& val, Direction dir = PD_IN);
+		/// Binds an Int64 deque.
+
+	virtual void bind(std::size_t pos, const std::list<Poco::Int64>& val, Direction dir = PD_IN);
+		/// Binds an Int64 list.
+
+	virtual void bind(std::size_t pos, const Poco::UInt64& val, Direction dir = PD_IN) = 0;
+		/// Binds an UInt64.
+
+	virtual void bind(std::size_t pos, const std::vector<Poco::UInt64>& val, Direction dir = PD_IN);
+		/// Binds an UInt64 vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Poco::UInt64>& val, Direction dir = PD_IN);
+		/// Binds an UInt64 deque.
+
+	virtual void bind(std::size_t pos, const std::list<Poco::UInt64>& val, Direction dir = PD_IN);
+		/// Binds an UInt64 list.
+
+#ifndef POCO_LONG_IS_64_BIT
+	virtual void bind(std::size_t pos, const long& val, Direction dir = PD_IN) = 0;
+		/// Binds a long.
+
+	virtual void bind(std::size_t pos, const unsigned long& val, Direction dir = PD_IN) = 0;
+		/// Binds an unsiged long.
+
+	virtual void bind(std::size_t pos, const std::vector<long>& val, Direction dir = PD_IN);
+		/// Binds a long vector.
+
+	virtual void bind(std::size_t pos, const std::deque<long>& val, Direction dir = PD_IN);
+		/// Binds a long deque.
+
+	virtual void bind(std::size_t pos, const std::list<long>& val, Direction dir = PD_IN);
+		/// Binds a long list.
+#endif
+
+	virtual void bind(std::size_t pos, const bool& val, Direction dir = PD_IN) = 0;
+		/// Binds a boolean.
+
+	virtual void bind(std::size_t pos, const std::vector<bool>& val, Direction dir = PD_IN);
+		/// Binds a boolean vector.
+
+	virtual void bind(std::size_t pos, const std::deque<bool>& val, Direction dir = PD_IN);
+		/// Binds a boolean deque.
+
+	virtual void bind(std::size_t pos, const std::list<bool>& val, Direction dir = PD_IN);
+		/// Binds a boolean list.
+
+	virtual void bind(std::size_t pos, const float& val, Direction dir = PD_IN) = 0;
+		/// Binds a float.
+
+	virtual void bind(std::size_t pos, const std::vector<float>& val, Direction dir = PD_IN);
+		/// Binds a float vector.
+
+	virtual void bind(std::size_t pos, const std::deque<float>& val, Direction dir = PD_IN);
+		/// Binds a float deque.
+
+	virtual void bind(std::size_t pos, const std::list<float>& val, Direction dir = PD_IN);
+		/// Binds a float list.
+
+	virtual void bind(std::size_t pos, const double& val, Direction dir = PD_IN) = 0;
+		/// Binds a double.
+
+	virtual void bind(std::size_t pos, const std::vector<double>& val, Direction dir = PD_IN);
+		/// Binds a double vector.
+
+	virtual void bind(std::size_t pos, const std::deque<double>& val, Direction dir = PD_IN);
+		/// Binds a double deque.
+
+	virtual void bind(std::size_t pos, const std::list<double>& val, Direction dir = PD_IN);
+		/// Binds a double list.
+
+	virtual void bind(std::size_t pos, const char& val, Direction dir = PD_IN) = 0;
+		/// Binds a single character.
+
+	virtual void bind(std::size_t pos, const std::vector<char>& val, Direction dir = PD_IN);
+		/// Binds a character vector.
+
+	virtual void bind(std::size_t pos, const std::deque<char>& val, Direction dir = PD_IN);
+		/// Binds a character deque.
+
+	virtual void bind(std::size_t pos, const std::list<char>& val, Direction dir = PD_IN);
+		/// Binds a character list.
+
+	virtual void bind(std::size_t pos, const char* const& pVal, Direction dir = PD_IN) = 0;
+		/// Binds a const char ptr.
+
+	virtual void bind(std::size_t pos, const std::string& val, Direction dir = PD_IN) = 0;
+		/// Binds a string.
+
+	virtual void bind(std::size_t pos, const std::vector<std::string>& val, Direction dir = PD_IN);
+		/// Binds a string vector.
+
+	virtual void bind(std::size_t pos, const std::deque<std::string>& val, Direction dir = PD_IN);
+		/// Binds a string deque.
+
+	virtual void bind(std::size_t pos, const std::list<std::string>& val, Direction dir = PD_IN);
+		/// Binds a string list.
+
+	virtual void bind(std::size_t pos, const UTF16String& val, Direction dir = PD_IN);
+		/// Binds a UTF-16 Unicode string.
+
+	virtual void bind(std::size_t pos, const std::vector<UTF16String>& val, Direction dir = PD_IN);
+		/// Binds a UTF-16 Unicode string vector.
+
+	virtual void bind(std::size_t pos, const std::deque<UTF16String>& val, Direction dir = PD_IN);
+		/// Binds a UTF-16 Unicode string deque.
+
+	virtual void bind(std::size_t pos, const std::list<UTF16String>& val, Direction dir = PD_IN);
+		/// Binds a UTF-16 Unicode string list.
+
+	virtual void bind(std::size_t pos, const BLOB& val, Direction dir = PD_IN) = 0;
+		/// Binds a BLOB.
+
+	virtual void bind(std::size_t pos, const CLOB& val, Direction dir = PD_IN) = 0;
+		/// Binds a CLOB.
+
+	virtual void bind(std::size_t pos, const std::vector<BLOB>& val, Direction dir = PD_IN);
+		/// Binds a BLOB vector.
+
+	virtual void bind(std::size_t pos, const std::deque<BLOB>& val, Direction dir = PD_IN);
+		/// Binds a BLOB deque.
+
+	virtual void bind(std::size_t pos, const std::list<BLOB>& val, Direction dir = PD_IN);
+		/// Binds a BLOB list.
+
+	virtual void bind(std::size_t pos, const std::vector<CLOB>& val, Direction dir = PD_IN);
+		/// Binds a CLOB vector.
+
+	virtual void bind(std::size_t pos, const std::deque<CLOB>& val, Direction dir = PD_IN);
+		/// Binds a CLOB deque.
+
+	virtual void bind(std::size_t pos, const std::list<CLOB>& val, Direction dir = PD_IN);
+		/// Binds a CLOB list.
+
+	virtual void bind(std::size_t pos, const DateTime& val, Direction dir = PD_IN) = 0;
+		/// Binds a DateTime.
+
+	virtual void bind(std::size_t pos, const std::vector<DateTime>& val, Direction dir = PD_IN);
+		/// Binds a DateTime vector.
+
+	virtual void bind(std::size_t pos, const std::deque<DateTime>& val, Direction dir = PD_IN);
+		/// Binds a DateTime deque.
+
+	virtual void bind(std::size_t pos, const std::list<DateTime>& val, Direction dir = PD_IN);
+		/// Binds a DateTime list.
+
+	virtual void bind(std::size_t pos, const Date& val, Direction dir = PD_IN) = 0;
+		/// Binds a Date.
+
+	virtual void bind(std::size_t pos, const std::vector<Date>& val, Direction dir = PD_IN);
+		/// Binds a Date vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Date>& val, Direction dir = PD_IN);
+		/// Binds a Date deque.
+
+	virtual void bind(std::size_t pos, const std::list<Date>& val, Direction dir = PD_IN);
+		/// Binds a Date list.
+
+	virtual void bind(std::size_t pos, const Time& val, Direction dir = PD_IN) = 0;
+		/// Binds a Time.
+
+	virtual void bind(std::size_t pos, const std::vector<Time>& val, Direction dir = PD_IN);
+		/// Binds a Time vector.
+
+	virtual void bind(std::size_t pos, const std::deque<Time>& val, Direction dir = PD_IN);
+		/// Binds a Time deque.
+
+	virtual void bind(std::size_t pos, const std::list<Time>& val, Direction dir = PD_IN);
+		/// Binds a Time list.
+
+	virtual void bind(std::size_t pos, const NullData& val, Direction dir = PD_IN) = 0;
+		/// Binds a null.
+
+	virtual void bind(std::size_t pos, const std::vector<NullData>& val, Direction dir = PD_IN);
+		/// Binds a null vector.
+
+	virtual void bind(std::size_t pos, const std::deque<NullData>& val, Direction dir = PD_IN);
+		/// Binds a null deque.
+
+	virtual void bind(std::size_t pos, const std::list<NullData>& val, Direction dir = PD_IN);
+		/// Binds a null list.
+
+	void bind(std::size_t pos, const Any& val, Direction dir = PD_IN);
+		/// Binds an Any.
+	
+	void bind(std::size_t pos, const Poco::Dynamic::Var& val, Direction dir = PD_IN);
+	/// Binds a Var.
+
+	virtual void reset();
+		/// Resets a binder. No-op by default. Implement for binders that cache data.
+
+	static bool isOutBound(Direction dir);
+		/// Returns true if direction is out bound;
+
+	static bool isInBound(Direction dir);
+		/// Returns true if direction is in bound;
+};
+
+
+//
+// inlines
+//
+inline void AbstractBinder::reset()
+{
+	//no-op
+}
+
+
+inline bool AbstractBinder::isOutBound(Direction dir)
+{
+	return PD_OUT == dir || PD_IN_OUT == dir;
+}
+
+
+inline bool AbstractBinder::isInBound(Direction dir)
+{
+	return PD_IN == dir || PD_IN_OUT == dir;
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_AbstractBinder_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/AbstractBinding.h b/base/poco/Data/include/Poco/Data/AbstractBinding.h
new file mode 100644
index 00000000000..1c16da1a6f2
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/AbstractBinding.h
@@ -0,0 +1,144 @@
+//
+// AbstractBinding.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractBinding
+//
+// Definition of the AbstractBinding class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_AbstractBinding_INCLUDED
+#define Data_AbstractBinding_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/AbstractBinder.h"
+#include "Poco/Any.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include <vector>
+#include <list>
+#include <deque>
+#include <cstddef>
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API AbstractBinding
+	/// AbstractBinding connects a value with a placeholder via an AbstractBinder interface.
+{
+public:
+	typedef SharedPtr<AbstractBinding> Ptr;
+	typedef AbstractBinder::Ptr        BinderPtr;
+
+	enum Direction
+	{
+		PD_IN = AbstractBinder::PD_IN,
+		PD_OUT = AbstractBinder::PD_OUT,
+		PD_IN_OUT = AbstractBinder::PD_IN_OUT
+	};
+
+	AbstractBinding(const std::string& name = "", Direction direction = PD_IN, Poco::UInt32 bulkSize = 0);
+		/// Creates the AbstractBinding.
+
+	virtual ~AbstractBinding();
+		/// Destroys the AbstractBinding.
+
+	void setBinder(BinderPtr pBinder);
+		/// Sets the object used for binding; object does NOT take ownership of the pointer.
+
+	BinderPtr getBinder() const;
+		/// Returns the AbstractBinder used for binding data.
+
+	virtual std::size_t numOfColumnsHandled() const = 0;
+		/// Returns the number of columns that the binding handles.
+		///
+		/// The trivial case will be one single column but when
+		/// complex types are used this value can be larger than one.
+
+	virtual std::size_t numOfRowsHandled() const = 0;
+		/// Returns the number of rows that the binding handles.
+		///
+		/// The trivial case will be one single row but 
+		/// for collection data types it can be larger.
+
+	virtual bool canBind() const = 0;
+		/// Returns true if we have enough data to bind
+
+	virtual void bind(std::size_t pos) = 0;
+		/// Binds a value to the given column position
+
+	virtual void reset() = 0;
+		/// Allows a binding to be reused.
+
+	AbstractBinder::Direction getDirection() const;
+		/// Returns the binding direction.
+
+	const std::string& name() const;
+		/// Returns the name for this binding.
+
+	bool isBulk() const;
+		/// Returns true if extraction is bulk.
+
+	Poco::UInt32 bulkSize() const;
+		/// Returns the size of the bulk binding.
+
+private:
+	BinderPtr    _pBinder;
+	std::string  _name;
+	Direction    _direction;
+	Poco::UInt32 _bulkSize;
+};
+
+
+typedef std::vector<AbstractBinding::Ptr> AbstractBindingVec;
+typedef std::deque<AbstractBinding::Ptr>  AbstractBindingDeq;
+typedef std::list<AbstractBinding::Ptr>   AbstractBindingLst;
+
+
+//
+// inlines
+//
+inline AbstractBinder::Ptr AbstractBinding::getBinder() const
+{
+	return _pBinder;
+}
+
+
+inline const std::string& AbstractBinding::name() const
+{
+	return _name;
+}
+
+
+inline AbstractBinder::Direction AbstractBinding::getDirection() const
+{
+	return (AbstractBinder::Direction) _direction;
+}
+
+
+inline bool AbstractBinding::isBulk() const
+{
+	return _bulkSize > 0;
+}
+
+
+inline Poco::UInt32 AbstractBinding::bulkSize() const
+{
+	return _bulkSize;
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_AbstractBinding_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/AbstractExtraction.h b/base/poco/Data/include/Poco/Data/AbstractExtraction.h
new file mode 100644
index 00000000000..8960d74441b
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/AbstractExtraction.h
@@ -0,0 +1,278 @@
+//
+// AbstractExtraction.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractExtraction
+//
+// Definition of the AbstractExtraction class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_AbstractExtraction_INCLUDED
+#define Data_AbstractExtraction_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/AbstractExtractor.h"
+#include "Poco/Data/AbstractPreparation.h"
+#include "Poco/Data/Limit.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/UTFString.h"
+#include "Poco/AutoPtr.h"
+#include <vector>
+#include <deque>
+#include <list>
+#include <cstddef>
+
+
+namespace Poco {
+namespace Data {
+
+
+class AbstractPreparator;
+
+
+class Data_API AbstractExtraction
+	/// AbstractExtraction is the interface class that connects output positions to concrete values
+	/// retrieved via an AbstractExtractor.
+{
+public:
+	typedef SharedPtr<AbstractExtraction> Ptr;
+	typedef SharedPtr<AbstractExtractor>  ExtractorPtr;
+	typedef SharedPtr<AbstractPreparator> PreparatorPtr;
+
+	AbstractExtraction(Poco::UInt32 limit = Limit::LIMIT_UNLIMITED,
+		Poco::UInt32 position = 0, bool bulk = false);
+		/// Creates the AbstractExtraction. A limit value equal to EXTRACT_UNLIMITED (0xffffffffu) 
+		/// means that we extract as much data as possible during one execute.
+		/// Otherwise the limit value is used to partition data extracting to a limited amount of rows.
+
+	virtual ~AbstractExtraction();
+		/// Destroys the AbstractExtraction.
+
+	void setExtractor(ExtractorPtr pExtractor);
+		/// Sets the class used for extracting the data. Does not take ownership of the pointer.
+
+	ExtractorPtr getExtractor() const;
+		/// Retrieves the extractor object
+
+	Poco::UInt32 position() const;
+		/// Returns the extraction position.
+
+	virtual std::size_t numOfColumnsHandled() const = 0;
+		/// Returns the number of columns that the extraction handles.
+		///
+		/// The trivial case will be one single column but when
+		/// complex types are used this value can be larger than one.
+
+	virtual std::size_t numOfRowsHandled() const = 0;
+		/// Returns the number of rows that the extraction handles.
+		///
+		/// The trivial case will be one single row but 
+		/// for collection data types (ie vector) it can be larger.
+
+	virtual std::size_t numOfRowsAllowed() const = 0;
+		/// Returns the upper limit on number of rows that the extraction will handle.
+
+	virtual std::size_t extract(std::size_t pos) = 0;
+		/// Extracts a value from the param, starting at the given column position.
+		/// Returns the number of rows extracted.
+
+	virtual void reset();
+		/// Resets the extractor so that it can be re-used.
+		/// Does nothing in this implementation.
+		/// Implementations should override it for different behavior.
+
+	virtual bool canExtract() const;
+		/// Returns true. Implementations should override it for different behavior.
+
+	virtual AbstractPreparation::Ptr createPreparation(PreparatorPtr& pPrep, std::size_t pos) = 0;
+		/// Creates and returns shared pointer to Preparation object for the extracting object.
+
+	void setLimit(Poco::UInt32 limit);
+		/// Sets the limit.
+
+	Poco::UInt32 getLimit() const;
+		/// Gets the limit.
+
+	virtual bool isNull(std::size_t row) const;
+		/// In implementations, this function returns true if value at row is null, 
+		/// false otherwise. 
+		/// Normal behavior is to replace nulls with default values.
+		/// However, extraction implementations may remember the underlying database
+		/// null values and be able to later provide information about them.
+		/// Here, this function throws NotImplementedException.
+
+	bool isBulk() const;
+		/// Returns true if this is bulk extraction.
+
+	void setEmptyStringIsNull(bool emptyStringIsNull);
+		/// Sets the empty string handling flag.
+
+	bool getEmptyStringIsNull() const;
+		/// Returns the empty string handling flag.
+
+	void setForceEmptyString(bool forceEmptyString);
+		/// Sets the force empty string flag.
+
+	bool getForceEmptyString() const;
+		/// Returns the force empty string flag.
+
+	template <typename T>
+	bool isValueNull(const T& str, bool deflt)
+		/// Utility function to determine the nullness of the value.
+		/// This generic version always returns default value
+		/// (i.e. does nothing). The std::string overload does
+		/// the actual work.
+		///
+	{
+		return deflt;
+	}
+
+	bool isValueNull(const std::string& str, bool deflt);
+		/// Overload for const reference to std::string.
+		///
+		/// Returns true when folowing conditions are met:
+		///
+		/// - string is empty 
+		/// - getEmptyStringIsNull() returns true
+
+	bool isValueNull(const Poco::UTF16String& str, bool deflt);
+		/// Overload for const reference to UTF16String.
+		///
+		/// Returns true when folowing conditions are met:
+		///
+		/// - string is empty 
+		/// - getEmptyStringIsNull() returns true
+
+private:
+	template <typename S>
+	bool isStringNull(const S& str, bool deflt)
+	{
+		if (getForceEmptyString()) return false;
+
+		if (getEmptyStringIsNull() && str.empty())
+			return true;
+
+		return deflt;
+	}
+
+	ExtractorPtr _pExtractor;
+	Poco::UInt32 _limit;
+	Poco::UInt32 _position;
+	bool         _bulk;
+	bool         _emptyStringIsNull;
+	bool         _forceEmptyString;
+};
+
+
+typedef std::vector<AbstractExtraction::Ptr> AbstractExtractionVec;
+typedef std::vector<AbstractExtractionVec>   AbstractExtractionVecVec;
+typedef std::deque<AbstractExtraction::Ptr>  AbstractExtractionDeq;
+typedef std::vector<AbstractExtractionDeq>   AbstractExtractionDeqVec;
+typedef std::list<AbstractExtraction::Ptr>   AbstractExtractionLst;
+typedef std::vector<AbstractExtractionLst>   AbstractExtractionLstVec;
+
+
+//
+// inlines
+//
+inline void AbstractExtraction::setExtractor(ExtractorPtr pExtractor)
+{
+	_pExtractor = pExtractor;
+}
+
+
+inline AbstractExtraction::ExtractorPtr AbstractExtraction::getExtractor() const
+{
+	return _pExtractor;
+}
+
+
+inline void AbstractExtraction::setLimit(Poco::UInt32 limit)
+{
+	_limit = limit;
+}
+
+
+inline Poco::UInt32 AbstractExtraction::getLimit() const
+{
+	return _limit;
+}
+
+
+inline bool AbstractExtraction::isNull(std::size_t row) const
+{
+	throw NotImplementedException("Check for null values not implemented.");
+}
+
+
+inline Poco::UInt32 AbstractExtraction::position() const
+{
+	return _position;
+}
+
+
+inline bool AbstractExtraction::isBulk() const
+{
+	return _bulk;
+}
+
+
+inline void AbstractExtraction::reset()
+{
+}
+
+
+inline bool AbstractExtraction::canExtract() const
+{
+	return true;
+}
+
+
+inline void AbstractExtraction::setEmptyStringIsNull(bool emptyStringIsNull)
+{
+	_emptyStringIsNull = emptyStringIsNull;
+}
+
+
+inline bool AbstractExtraction::getEmptyStringIsNull() const
+{
+	return _emptyStringIsNull;
+}
+
+
+inline void AbstractExtraction::setForceEmptyString(bool forceEmptyString)
+{
+	_forceEmptyString = forceEmptyString;
+}
+
+
+inline bool AbstractExtraction::getForceEmptyString() const
+{
+	return _forceEmptyString;
+}
+
+
+inline bool AbstractExtraction::isValueNull(const std::string& str, bool deflt)
+{
+	return isStringNull(str, deflt);
+}
+
+
+inline bool AbstractExtraction::isValueNull(const Poco::UTF16String& str, bool deflt)
+{
+	return isStringNull(str, deflt);
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_AbstractExtraction_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/AbstractExtractor.h b/base/poco/Data/include/Poco/Data/AbstractExtractor.h
new file mode 100644
index 00000000000..aa973bc29f9
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/AbstractExtractor.h
@@ -0,0 +1,351 @@
+//
+// AbstractExtractor.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractExtractor
+//
+// Definition of the AbstractExtractor class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_AbstractExtractor_INCLUDED
+#define Data_AbstractExtractor_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/Constants.h"
+#include "Poco/Data/LOB.h"
+#include "Poco/UTFString.h"
+#include <vector>
+#include <deque>
+#include <list>
+#include <string>
+#include <cstddef>
+
+
+namespace Poco {
+
+
+class DateTime;
+class Any;
+
+namespace Dynamic {
+class Var;
+}
+
+namespace Data {
+
+
+class Date;
+class Time;
+
+
+class Data_API AbstractExtractor
+	/// Interface used to extract data from a single result row.
+	/// If an extractor receives null it is not allowed to change val!
+{
+public:
+	typedef SharedPtr<AbstractExtractor> Ptr;
+
+	AbstractExtractor();
+		/// Creates the AbstractExtractor.
+
+	virtual ~AbstractExtractor();
+		/// Destroys the AbstractExtractor.
+
+	virtual bool extract(std::size_t pos, Poco::Int8& val) = 0;
+		/// Extracts an Int8. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int8>& val);
+		/// Extracts an Int8 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::Int8>& val);
+		/// Extracts an Int8 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::Int8>& val);
+		/// Extracts an Int8 list.
+
+	virtual bool extract(std::size_t pos, Poco::UInt8& val) = 0;
+		/// Extracts an UInt8. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt8>& val);
+		/// Extracts an UInt8 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::UInt8>& val);
+		/// Extracts an UInt8 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::UInt8>& val);
+		/// Extracts an UInt8 list.
+
+	virtual bool extract(std::size_t pos, Poco::Int16& val) = 0;
+		/// Extracts an Int16. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int16>& val);
+		/// Extracts an Int16 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::Int16>& val);
+		/// Extracts an Int16 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::Int16>& val);
+		/// Extracts an Int16 list.
+
+	virtual bool extract(std::size_t pos, Poco::UInt16& val) = 0;
+		/// Extracts an UInt16. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt16>& val);
+		/// Extracts an UInt16 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::UInt16>& val);
+		/// Extracts an UInt16 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::UInt16>& val);
+		/// Extracts an UInt16 list.
+
+	virtual bool extract(std::size_t pos, Poco::Int32& val) = 0;
+		/// Extracts an Int32. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int32>& val);
+		/// Extracts an Int32 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::Int32>& val);
+		/// Extracts an Int32 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::Int32>& val);
+		/// Extracts an Int32 list.
+
+	virtual bool extract(std::size_t pos, Poco::UInt32& val) = 0;
+		/// Extracts an UInt32. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt32>& val);
+		/// Extracts an UInt32 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::UInt32>& val);
+		/// Extracts an UInt32 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::UInt32>& val);
+		/// Extracts an UInt32 list.
+
+	virtual bool extract(std::size_t pos, Poco::Int64& val) = 0;
+		/// Extracts an Int64. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::Int64>& val);
+		/// Extracts an Int64 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::Int64>& val);
+		/// Extracts an Int64 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::Int64>& val);
+		/// Extracts an Int64 list.
+
+	virtual bool extract(std::size_t pos, Poco::UInt64& val) = 0;
+		/// Extracts an UInt64. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::UInt64>& val);
+		/// Extracts an UInt64 vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::UInt64>& val);
+		/// Extracts an UInt64 deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::UInt64>& val);
+		/// Extracts an UInt64 list.
+
+#ifndef POCO_LONG_IS_64_BIT
+	virtual bool extract(std::size_t pos, long& val) = 0;
+		/// Extracts a long. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, unsigned long& val) = 0;
+		/// Extracts an unsigned long. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<long>& val);
+		/// Extracts a long vector.
+
+	virtual bool extract(std::size_t pos, std::deque<long>& val);
+		/// Extracts a long deque.
+
+	virtual bool extract(std::size_t pos, std::list<long>& val);
+		/// Extracts a long list.
+#endif
+
+	virtual bool extract(std::size_t pos, bool& val) = 0;
+		/// Extracts a boolean. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<bool>& val);
+		/// Extracts a boolean vector.
+
+	virtual bool extract(std::size_t pos, std::deque<bool>& val);
+		/// Extracts a boolean deque.
+
+	virtual bool extract(std::size_t pos, std::list<bool>& val);
+		/// Extracts a boolean list.
+
+	virtual bool extract(std::size_t pos, float& val) = 0;
+		/// Extracts a float. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<float>& val);
+		/// Extracts a float vector.
+
+	virtual bool extract(std::size_t pos, std::deque<float>& val);
+		/// Extracts a float deque.
+
+	virtual bool extract(std::size_t pos, std::list<float>& val);
+		/// Extracts a float list.
+
+	virtual bool extract(std::size_t pos, double& val) = 0;
+		/// Extracts a double. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<double>& val);
+		/// Extracts a double vector.
+
+	virtual bool extract(std::size_t pos, std::deque<double>& val);
+		/// Extracts a double deque.
+
+	virtual bool extract(std::size_t pos, std::list<double>& val);
+		/// Extracts a double list.
+
+	virtual bool extract(std::size_t pos, char& val) = 0;
+		/// Extracts a single character. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<char>& val);
+		/// Extracts a character vector.
+
+	virtual bool extract(std::size_t pos, std::deque<char>& val);
+		/// Extracts a character deque.
+
+	virtual bool extract(std::size_t pos, std::list<char>& val);
+		/// Extracts a character list.
+
+	virtual bool extract(std::size_t pos, std::string& val) = 0;
+		/// Extracts a string. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<std::string>& val);
+		/// Extracts a string vector.
+
+	virtual bool extract(std::size_t pos, std::deque<std::string>& val);
+		/// Extracts a string deque.
+
+	virtual bool extract(std::size_t pos, std::list<std::string>& val);
+		/// Extracts a string list.
+
+	virtual bool extract(std::size_t pos, UTF16String& val);
+		/// Extracts a UTF16String. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<UTF16String>& val);
+		/// Extracts a UTF16String vector.
+
+	virtual bool extract(std::size_t pos, std::deque<UTF16String>& val);
+		/// Extracts a UTF16String deque.
+
+	virtual bool extract(std::size_t pos, std::list<UTF16String>& val);
+		/// Extracts a UTF16String list.
+
+	virtual bool extract(std::size_t pos, BLOB& val) = 0;
+		/// Extracts a BLOB. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, CLOB& val) = 0;
+		/// Extracts a CLOB. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<BLOB>& val);
+		/// Extracts a BLOB vector.
+
+	virtual bool extract(std::size_t pos, std::deque<BLOB>& val);
+		/// Extracts a BLOB deque.
+
+	virtual bool extract(std::size_t pos, std::list<BLOB>& val);
+		/// Extracts a BLOB list.
+
+	virtual bool extract(std::size_t pos, std::vector<CLOB>& val);
+		/// Extracts a CLOB vector.
+
+	virtual bool extract(std::size_t pos, std::deque<CLOB>& val);
+		/// Extracts a CLOB deque.
+
+	virtual bool extract(std::size_t pos, std::list<CLOB>& val);
+		/// Extracts a CLOB list.
+
+	virtual bool extract(std::size_t pos, DateTime& val) = 0;
+		/// Extracts a DateTime. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<DateTime>& val);
+		/// Extracts a DateTime vector.
+
+	virtual bool extract(std::size_t pos, std::deque<DateTime>& val);
+		/// Extracts a DateTime deque.
+
+	virtual bool extract(std::size_t pos, std::list<DateTime>& val);
+		/// Extracts a DateTime list.
+
+	virtual bool extract(std::size_t pos, Date& val) = 0;
+		/// Extracts a Date. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Date>& val);
+		/// Extracts a Date vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Date>& val);
+		/// Extracts a Date deque.
+
+	virtual bool extract(std::size_t pos, std::list<Date>& val);
+		/// Extracts a Date list.
+
+	virtual bool extract(std::size_t pos, Time& val) = 0;
+		/// Extracts a Time. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Time>& val);
+		/// Extracts a Time vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Time>& val);
+		/// Extracts a Time deque.
+
+	virtual bool extract(std::size_t pos, std::list<Time>& val);
+		/// Extracts a Time list.
+
+	virtual bool extract(std::size_t pos, Any& val) = 0;
+		/// Extracts an Any. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Any>& val);
+		/// Extracts an Any vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Any>& val);
+		/// Extracts an Any deque.
+
+	virtual bool extract(std::size_t pos, std::list<Any>& val);
+		/// Extracts an Any list.
+
+	virtual bool extract(std::size_t pos, Poco::Dynamic::Var& val) = 0;
+		/// Extracts a Var. Returns false if null was received.
+
+	virtual bool extract(std::size_t pos, std::vector<Poco::Dynamic::Var>& val);
+		/// Extracts a Var vector.
+
+	virtual bool extract(std::size_t pos, std::deque<Poco::Dynamic::Var>& val);
+		/// Extracts a Var deque.
+
+	virtual bool extract(std::size_t pos, std::list<Poco::Dynamic::Var>& val);
+		/// Extracts a Var list.
+
+	virtual bool isNull(std::size_t col, std::size_t row = POCO_DATA_INVALID_ROW) = 0;
+		/// Returns true if the value at [col,row] position is null.
+
+	virtual void reset();
+		/// Resets any information internally cached by the extractor.
+};
+
+
+///
+/// inlines
+///
+inline void AbstractExtractor::reset()
+{
+	//default no-op
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_AbstractExtractor_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/AbstractPreparation.h b/base/poco/Data/include/Poco/Data/AbstractPreparation.h
new file mode 100644
index 00000000000..6d921572dce
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/AbstractPreparation.h
@@ -0,0 +1,71 @@
+//
+// AbstractPreparation.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractPreparation
+//
+// Definition of the AbstractPreparation class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_AbstractPreparation_INCLUDED
+#define Data_AbstractPreparation_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/AbstractPreparator.h"
+#include "Poco/SharedPtr.h"
+#include <cstddef>
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API AbstractPreparation
+	/// Interface for calling the appropriate AbstractPreparator method
+{
+public:
+	typedef SharedPtr<AbstractPreparation> Ptr;
+	typedef AbstractPreparator::Ptr PreparatorPtr;
+
+	AbstractPreparation(PreparatorPtr pPreparator);
+		/// Creates the AbstractPreparation.
+
+	virtual ~AbstractPreparation();
+		/// Destroys the AbstractPreparation.
+
+	virtual void prepare() = 0;
+		/// Prepares data.
+
+protected:
+	AbstractPreparation();
+	AbstractPreparation(const AbstractPreparation&);
+	AbstractPreparation& operator = (const AbstractPreparation&);
+
+	PreparatorPtr preparation();
+		/// Returns the preparation object
+
+	PreparatorPtr _pPreparator;
+};
+
+
+//
+// inlines
+//
+inline AbstractPreparation::PreparatorPtr AbstractPreparation::preparation()
+{
+	return _pPreparator;
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_AbstractPreparation_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/AbstractPreparator.h b/base/poco/Data/include/Poco/Data/AbstractPreparator.h
new file mode 100644
index 00000000000..da086b051a7
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/AbstractPreparator.h
@@ -0,0 +1,388 @@
+//
+// AbstractPreparator.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractPreparator
+//
+// Definition of the AbstractPreparator class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_AbstractPreparator_INCLUDED
+#define Data_AbstractPreparator_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/Data/LOB.h"
+#include "Poco/UTFString.h"
+#include <vector>
+#include <deque>
+#include <list>
+#include <cstddef>
+
+
+namespace Poco {
+
+
+class DateTime;
+class Any;
+
+namespace Dynamic {
+class Var;
+}
+
+
+namespace Data {
+
+
+class Date;
+class Time;
+
+
+class Data_API AbstractPreparator
+	/// Interface used for database preparation where we first have to register all data types
+	/// (and memory output locations) before extracting data, e.g. ODBC.
+	/// Extract works as two-phase extract: first we call prepare once, then extract n-times.
+	/// There are cases (bulk operations using std::vector storage) when extract is called only once.
+	/// The value passed to a prepare() call is not used by the prepare, serving only as an indication 
+	/// of the data type being prepared, thus all values are passed as const references. 
+	/// Implementing this interface is not mandatory for a connector. Connectors that only extract data 
+	/// after SQL execution (e.g. SQLite) do not need this functionality at all.
+{
+public:
+	typedef SharedPtr<AbstractPreparator> Ptr;
+
+	AbstractPreparator(Poco::UInt32 length = 1u);
+		/// Creates the AbstractPreparator.
+
+	virtual ~AbstractPreparator();
+		/// Destroys the AbstractPreparator.
+
+	virtual void prepare(std::size_t pos, const Poco::Int8&) = 0;
+		/// Prepares an Int8.
+
+	virtual void prepare(std::size_t pos, const std::vector<Poco::Int8>& val);
+		/// Prepares an Int8 vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Poco::Int8>& val);
+		/// Prepares an Int8 deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Poco::Int8>& val);
+		/// Prepares an Int8 list.
+
+	virtual void prepare(std::size_t pos, const Poco::UInt8&) = 0;
+		/// Prepares an UInt8.
+
+	virtual void prepare(std::size_t pos, const std::vector<Poco::UInt8>& val);
+		/// Prepares an UInt8 vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Poco::UInt8>& val);
+		/// Prepares an UInt8 deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Poco::UInt8>& val);
+		/// Prepares an UInt8 list.
+
+	virtual void prepare(std::size_t pos, const Poco::Int16&) = 0;
+		/// Prepares an Int16.
+
+	virtual void prepare(std::size_t pos, const std::vector<Poco::Int16>& val);
+		/// Prepares an Int16 vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Poco::Int16>& val);
+		/// Prepares an Int16 deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Poco::Int16>& val);
+		/// Prepares an Int16 list.
+
+	virtual void prepare(std::size_t pos, const Poco::UInt16&) = 0;
+		/// Prepares an UInt16.
+
+	virtual void prepare(std::size_t pos, const std::vector<Poco::UInt16>& val);
+		/// Prepares an UInt16 vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Poco::UInt16>& val);
+		/// Prepares an UInt16 deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Poco::UInt16>& val);
+		/// Prepares an UInt16 list.
+
+	virtual void prepare(std::size_t pos, const Poco::Int32&) = 0;
+		/// Prepares an Int32.
+
+	virtual void prepare(std::size_t pos, const std::vector<Poco::Int32>& val);
+		/// Prepares an Int32 vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Poco::Int32>& val);
+		/// Prepares an Int32 deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Poco::Int32>& val);
+		/// Prepares an Int32 list.
+
+	virtual void prepare(std::size_t pos, const Poco::UInt32&) = 0;
+		/// Prepares an UInt32.
+
+	virtual void prepare(std::size_t pos, const std::vector<Poco::UInt32>& val);
+		/// Prepares an UInt32 vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Poco::UInt32>& val);
+		/// Prepares an UInt32 deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Poco::UInt32>& val);
+		/// Prepares an UInt32 list.
+
+	virtual void prepare(std::size_t pos, const Poco::Int64&) = 0;
+		/// Prepares an Int64.
+
+	virtual void prepare(std::size_t pos, const std::vector<Poco::Int64>& val);
+		/// Prepares an Int64 vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Poco::Int64>& val);
+		/// Prepares an Int64 deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Poco::Int64>& val);
+		/// Prepares an Int64 list.
+
+	virtual void prepare(std::size_t pos, const Poco::UInt64&) = 0;
+		/// Prepares an UInt64.
+
+	virtual void prepare(std::size_t pos, const std::vector<Poco::UInt64>& val);
+		/// Prepares an UInt64 vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Poco::UInt64>& val);
+		/// Prepares an UInt64 deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Poco::UInt64>& val);
+		/// Prepares an UInt64 list.
+
+#ifndef POCO_LONG_IS_64_BIT
+	virtual void prepare(std::size_t pos, const long&) = 0;
+		/// Prepares a long.
+
+	virtual void prepare(std::size_t pos, const unsigned long&) = 0;
+		/// Prepares an unsigned long.
+
+	virtual void prepare(std::size_t pos, const std::vector<long>& val);
+		/// Prepares a long vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<long>& val);
+		/// Prepares a long deque.
+
+	virtual void prepare(std::size_t pos, const std::list<long>& val);
+		/// Prepares a long list.
+#endif
+
+	virtual void prepare(std::size_t pos, const bool&) = 0;
+		/// Prepares a boolean.
+
+	virtual void prepare(std::size_t pos, const std::vector<bool>& val);
+		/// Prepares a boolean vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<bool>& val);
+		/// Prepares a boolean deque.
+
+	virtual void prepare(std::size_t pos, const std::list<bool>& val);
+		/// Prepares a boolean list.
+
+	virtual void prepare(std::size_t pos, const float&) = 0;
+		/// Prepares a float.
+
+	virtual void prepare(std::size_t pos, const std::vector<float>& val);
+		/// Prepares a float vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<float>& val);
+		/// Prepares a float deque.
+
+	virtual void prepare(std::size_t pos, const std::list<float>& val);
+		/// Prepares a float list.
+
+	virtual void prepare(std::size_t pos, const double&) = 0;
+		/// Prepares a double.
+
+	virtual void prepare(std::size_t pos, const std::vector<double>& val);
+		/// Prepares a double vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<double>& val);
+		/// Prepares a double deque.
+
+	virtual void prepare(std::size_t pos, const std::list<double>& val);
+		/// Prepares a double list.
+
+	virtual void prepare(std::size_t pos, const char&) = 0;
+		/// Prepares a single character.
+
+	virtual void prepare(std::size_t pos, const std::vector<char>& val);
+		/// Prepares a character vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<char>& val);
+		/// Prepares a character deque.
+
+	virtual void prepare(std::size_t pos, const std::list<char>& val);
+		/// Prepares a character list.
+
+	virtual void prepare(std::size_t pos, const std::string&) = 0;
+		/// Prepares a string.
+
+	virtual void prepare(std::size_t pos, const std::vector<std::string>& val);
+		/// Prepares a string vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<std::string>& val);
+		/// Prepares a string deque.
+
+	virtual void prepare(std::size_t pos, const std::list<std::string>& val);
+		/// Prepares a character list.
+
+	virtual void prepare(std::size_t pos, const UTF16String&);
+		/// Prepares a UTF16String.
+
+	virtual void prepare(std::size_t pos, const std::vector<UTF16String>& val);
+		/// Prepares a UTF16String vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<UTF16String>& val);
+		/// Prepares a UTF16String deque.
+
+	virtual void prepare(std::size_t pos, const std::list<UTF16String>& val);
+		/// Prepares a UTF16String list.
+
+	virtual void prepare(std::size_t pos, const BLOB&) = 0;
+		/// Prepares a BLOB.
+
+	virtual void prepare(std::size_t pos, const CLOB&) = 0;
+		/// Prepares a CLOB.
+
+	virtual void prepare(std::size_t pos, const std::vector<BLOB>& val);
+		/// Prepares a BLOB vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<BLOB>& val);
+		/// Prepares a BLOB deque.
+
+	virtual void prepare(std::size_t pos, const std::list<BLOB>& val);
+		/// Prepares a BLOB list.
+
+	virtual void prepare(std::size_t pos, const std::vector<CLOB>& val);
+		/// Prepares a CLOB vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<CLOB>& val);
+		/// Prepares a CLOB deque.
+
+	virtual void prepare(std::size_t pos, const std::list<CLOB>& val);
+		/// Prepares a CLOB list.
+
+	virtual void prepare(std::size_t pos, const DateTime&) = 0;
+		/// Prepares a DateTime.
+
+	virtual void prepare(std::size_t pos, const std::vector<DateTime>& val);
+		/// Prepares a DateTime vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<DateTime>& val);
+		/// Prepares a DateTime deque.
+
+	virtual void prepare(std::size_t pos, const std::list<DateTime>& val);
+		/// Prepares a DateTime list.
+
+	virtual void prepare(std::size_t pos, const Date&) = 0;
+		/// Prepares a Date.
+
+	virtual void prepare(std::size_t pos, const std::vector<Date>& val);
+		/// Prepares a Date vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Date>& val);
+		/// Prepares a Date deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Date>& val);
+		/// Prepares a Date list.
+
+	virtual void prepare(std::size_t pos, const Time&) = 0;
+		/// Prepares a Time.
+
+	virtual void prepare(std::size_t pos, const std::vector<Time>& val);
+		/// Prepares a Time vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Time>& val);
+		/// Prepares a Time deque.
+	
+	virtual void prepare(std::size_t pos, const std::list<Time>& val);
+		/// Prepares a Time list.
+
+	virtual void prepare(std::size_t pos, const Any&) = 0;
+		/// Prepares an Any.
+
+	virtual void prepare(std::size_t pos, const std::vector<Any>& val);
+		/// Prepares an Any vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Any>& val);
+		/// Prepares an Any deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Any>& val);
+		/// Prepares an Any list.
+
+	virtual void prepare(std::size_t pos, const Poco::Dynamic::Var&) = 0;
+		/// Prepares a Var.
+
+	virtual void prepare(std::size_t pos, const std::vector<Poco::Dynamic::Var>& val);
+		/// Prepares a Var vector.
+
+	virtual void prepare(std::size_t pos, const std::deque<Poco::Dynamic::Var>& val);
+		/// Prepares a Var deque.
+
+	virtual void prepare(std::size_t pos, const std::list<Poco::Dynamic::Var>& val);
+		/// Prepares a Var list.
+
+	void setLength(Poco::UInt32 length);
+		/// Sets the length of prepared data.
+		/// Needed only for data lengths greater than 1 (i.e. for
+		/// bulk operations).
+
+	Poco::UInt32 getLength() const;
+		/// Returns the length of prepared data. Defaults to 1.
+		/// The length is greater than one for bulk operations.
+
+	void setBulk(bool bulkPrep = true);
+		/// Sets bulk operation flag (always false at object creation time)
+
+	bool isBulk() const;
+		/// Returns bulk operation flag.
+
+private:
+	Poco::UInt32 _length;
+	bool         _bulk;
+};
+
+
+///
+/// inlines
+///
+inline void AbstractPreparator::setLength(Poco::UInt32 length)
+{
+	_length = length;
+}
+
+
+inline Poco::UInt32 AbstractPreparator::getLength() const
+{
+	return _length;
+}
+
+
+inline void AbstractPreparator::setBulk(bool bulkPrep)
+{
+	_bulk = bulkPrep;
+}
+
+
+inline bool AbstractPreparator::isBulk() const
+{
+	return _bulk;
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_AbstractPreparator_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/AbstractSessionImpl.h b/base/poco/Data/include/Poco/Data/AbstractSessionImpl.h
new file mode 100644
index 00000000000..97b4fe1491f
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/AbstractSessionImpl.h
@@ -0,0 +1,315 @@
+//
+// AbstractSessionImpl.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractSessionImpl
+//
+// Definition of the AbstractSessionImpl class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_AbstractSessionImpl_INCLUDED
+#define Data_AbstractSessionImpl_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/SessionImpl.h"
+#include "Poco/Data/DataException.h"
+#include <map>
+
+
+namespace Poco {
+namespace Data {
+
+
+template <class C>
+class AbstractSessionImpl: public SessionImpl
+	/// A partial implementation of SessionImpl, providing
+	/// features and properties management.
+	///
+	/// To implement a certain feature or property, a subclass
+	/// must provide setter and getter methods and register
+	/// them with addFeature() or addProperty().
+{
+public:
+	typedef void (C::*FeatureSetter)(const std::string&, bool);
+		/// The setter method for a feature.
+		
+	typedef bool (C::*FeatureGetter)(const std::string&);
+		/// The getter method for a feature.
+		
+	typedef void (C::*PropertySetter)(const std::string&, const Poco::Any&);
+		/// The setter method for a property.
+		
+	typedef Poco::Any (C::*PropertyGetter)(const std::string&);
+		/// The getter method for a property.
+
+	AbstractSessionImpl(const std::string& connectionString,
+		std::size_t timeout = LOGIN_TIMEOUT_DEFAULT): SessionImpl(connectionString, timeout),
+			_storage(std::string("deque")),
+			_bulk(false),
+			_emptyStringIsNull(false),
+			_forceEmptyString(false)
+		/// Creates the AbstractSessionImpl.
+		/// 
+		/// Adds "storage" property and sets the default internal storage container 
+		/// type to std::deque.
+		/// The storage is created by statements automatically whenever a query 
+		/// returning results is executed but external storage is provided by the user.
+		/// Storage type can be reconfigured at runtime both globally (for the
+		/// duration of the session) and locally (for a single statement execution only). 
+		/// See StatementImpl for details on how this property is used at runtime.
+		/// 
+		/// Adds "handle" property which, if set by the back end, returns native handle
+		/// for the back end DB.
+		/// 
+		/// Adds "bulk" feature and sets it to false.
+		/// Bulk feature determines whether the session is capable of bulk operations.
+		/// Connectors that are capable of it must set this feature prior to attempting 
+		/// bulk operations.
+		///
+		/// Adds "emptyStringIsNull" feature and sets it to false. This feature should be
+		/// set to true in order to modify the behavior of the databases that distinguish
+		/// between zero-length character strings as nulls. Setting this feature to true 
+		/// shall disregard any difference between empty character strings and nulls,
+		/// causing the framework to treat them the same (i.e. behave like Oracle).		
+		///
+		/// Adds "forceEmptyString" feature and sets it to false. This feature should be set
+		/// to true in order to force the databases that do not distinguish empty strings from
+		/// nulls (e.g. Oracle) to always report empty string.
+		///
+		/// The "emptyStringIsNull" and "forceEmptyString" features are mutually exclusive.
+		/// While these features can not both be true at the same time, they can both be false,
+		/// resulting in default underlying database behavior.
+		///
+	{
+		addProperty("storage", 
+			&AbstractSessionImpl<C>::setStorage, 
+			&AbstractSessionImpl<C>::getStorage);
+
+		addProperty("handle", 
+			&AbstractSessionImpl<C>::setHandle,
+			&AbstractSessionImpl<C>::getHandle);
+
+		addFeature("bulk", 
+			&AbstractSessionImpl<C>::setBulk, 
+			&AbstractSessionImpl<C>::getBulk);
+
+		addFeature("emptyStringIsNull", 
+			&AbstractSessionImpl<C>::setEmptyStringIsNull,
+			&AbstractSessionImpl<C>::getEmptyStringIsNull);
+
+		addFeature("forceEmptyString", 
+			&AbstractSessionImpl<C>::setForceEmptyString,
+			&AbstractSessionImpl<C>::getForceEmptyString);
+	}
+
+	~AbstractSessionImpl()
+		/// Destroys the AbstractSessionImpl.
+	{
+	}
+
+	void setFeature(const std::string& name, bool state)
+		/// Looks a feature up in the features map
+		/// and calls the feature's setter, if there is one.
+	{
+		typename FeatureMap::const_iterator it = _features.find(name);
+		if (it != _features.end())
+		{
+			if (it->second.setter)
+				(static_cast<C*>(this)->*it->second.setter)(name, state);
+			else
+				throw NotImplementedException("set", name);
+		}
+		else throw NotSupportedException(name);
+	}
+	
+	bool getFeature(const std::string& name)
+		/// Looks a feature up in the features map
+		/// and calls the feature's getter, if there is one.
+	{
+		typename FeatureMap::const_iterator it = _features.find(name);
+		if (it != _features.end())
+		{
+			if (it->second.getter)
+				return (static_cast<C*>(this)->*it->second.getter)(name);
+			else
+				throw NotImplementedException("get", name);
+		}
+		else throw NotSupportedException(name);
+	}
+	
+	void setProperty(const std::string& name, const Poco::Any& value)
+		/// Looks a property up in the properties map
+		/// and calls the property's setter, if there is one.
+	{
+		typename PropertyMap::const_iterator it = _properties.find(name);
+		if (it != _properties.end())
+		{
+			if (it->second.setter)
+				(static_cast<C*>(this)->*it->second.setter)(name, value);
+			else
+				throw NotImplementedException("set", name);
+		}
+		else throw NotSupportedException(name);
+	}
+
+	Poco::Any getProperty(const std::string& name)
+		/// Looks a property up in the properties map
+		/// and calls the property's getter, if there is one.
+	{
+		typename PropertyMap::const_iterator it = _properties.find(name);
+		if (it != _properties.end())
+		{
+			if (it->second.getter)
+				return (static_cast<C*>(this)->*it->second.getter)(name);
+			else
+				throw NotImplementedException("set", name);
+		}
+		else throw NotSupportedException(name);
+	}
+	
+	void setStorage(const std::string& value)
+		/// Sets the storage type.
+	{
+		_storage = value;
+	}
+
+	void setStorage(const std::string& name, const Poco::Any& value)
+		/// Sets the storage type.
+	{
+		_storage = Poco::RefAnyCast<std::string>(value);
+	}
+		
+	Poco::Any getStorage(const std::string& name="")
+		/// Returns the storage type
+	{
+		return _storage;
+	}
+
+	void setHandle(const std::string& name, const Poco::Any& handle)
+		/// Sets the native session handle. 
+	{
+		_handle = handle;
+	}
+		
+	Poco::Any getHandle(const std::string& name="")
+		/// Returns the native session handle. 
+	{
+		return _handle;
+	}
+
+	void setBulk(const std::string& name, bool bulk)
+		/// Sets the execution type.
+	{
+		_bulk = bulk;
+	}
+		
+	bool getBulk(const std::string& name="")
+		/// Returns the execution type
+	{
+		return _bulk;
+	}
+
+	void setEmptyStringIsNull(const std::string& name, bool emptyStringIsNull)
+		/// Sets the behavior regarding empty variable length strings.
+		/// Those are treated as NULL by Oracle and as empty string by
+		/// most other databases.
+		/// When this feature is true, empty strings are treated as NULL.
+	{
+		if (emptyStringIsNull && _forceEmptyString)
+			throw InvalidAccessException("Features mutually exclusive");
+
+		_emptyStringIsNull = emptyStringIsNull;
+	}
+		
+	bool getEmptyStringIsNull(const std::string& name="")
+		/// Returns the setting for the behavior regarding empty variable
+		/// length strings. See setEmptyStringIsNull(const std::string&, bool)
+		/// and this class documentation for feature rationale and details.
+	{
+		return _emptyStringIsNull;
+	}
+
+	void setForceEmptyString(const std::string& name, bool forceEmptyString)
+		/// Sets the behavior regarding empty variable length strings.
+		/// Those are treated as NULL by Oracle and as empty string by
+		/// most other databases.
+		/// When this feature is true, both empty strings and NULL values
+		/// are reported as empty strings.
+	{
+		if (forceEmptyString && _emptyStringIsNull)
+			throw InvalidAccessException("Features mutually exclusive");
+
+		_forceEmptyString = forceEmptyString;
+	}
+		
+	bool getForceEmptyString(const std::string& name="")
+		/// Returns the setting for the behavior regarding empty variable
+		/// length strings. See setForceEmptyString(const std::string&, bool)
+		/// and this class documentation for feature rationale and details.
+	{
+		return _forceEmptyString;
+	}
+
+protected:
+	void addFeature(const std::string& name, FeatureSetter setter, FeatureGetter getter)
+		/// Adds a feature to the map of supported features.
+		///
+		/// The setter or getter can be null, in case setting or getting a feature
+		/// is not supported.
+	{
+		Feature feature;
+		feature.setter = setter;
+		feature.getter = getter;
+		_features[name] = feature;
+	}
+		
+	void addProperty(const std::string& name, PropertySetter setter, PropertyGetter getter)
+		/// Adds a property to the map of supported properties.
+		///
+		/// The setter or getter can be null, in case setting or getting a property
+		/// is not supported.
+	{
+		Property property;
+		property.setter = setter;
+		property.getter = getter;
+		_properties[name] = property;
+	}
+
+private:
+	struct Feature
+	{
+		FeatureSetter setter;
+		FeatureGetter getter;
+	};
+	
+	struct Property
+	{
+		PropertySetter setter;
+		PropertyGetter getter;
+	};
+	
+	typedef std::map<std::string, Feature>  FeatureMap;
+	typedef std::map<std::string, Property> PropertyMap;
+	
+	FeatureMap  _features;
+	PropertyMap _properties;
+	std::string _storage;
+	bool        _bulk;
+	bool        _emptyStringIsNull;
+	bool        _forceEmptyString;
+	Poco::Any   _handle;
+};
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_AbstractSessionImpl_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/ArchiveStrategy.h b/base/poco/Data/include/Poco/Data/ArchiveStrategy.h
new file mode 100644
index 00000000000..3b644c5f2f5
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/ArchiveStrategy.h
@@ -0,0 +1,222 @@
+//
+// ArchiveStrategy.h
+//
+// Library: Data
+// Package: Logging
+// Module:  ArchiveStrategy
+//
+// Definition of the ArchiveStrategy class and subclasses.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_ArchiveStrategy_INCLUDED
+#define Data_ArchiveStrategy_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/Session.h"
+#include "Poco/DateTime.h"
+#include "Poco/Timespan.h"
+#include "Poco/Dynamic/Var.h"
+#include "Poco/SharedPtr.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API ArchiveStrategy
+	/// The ArchiveStrategy is used by SQLChannel to archive log rows.
+{
+public:
+	static const std::string DEFAULT_ARCHIVE_DESTINATION;
+
+	ArchiveStrategy(const std::string& connector, 
+		const std::string& connect, 
+		const std::string& source, 
+		const std::string& destination = DEFAULT_ARCHIVE_DESTINATION);
+		/// Creates archive strategy.
+
+	virtual ~ArchiveStrategy();
+		/// Destroys archive strategy.
+
+	void open();
+		/// Opens the session.
+
+	virtual void archive() = 0;
+		/// Archives the rows.
+
+	const std::string& getSource() const;
+		/// Returns the name of the source table containing rows to be archived.
+
+	void setSource(const std::string& source);
+		/// Sets the name of the source table.
+
+	const std::string& getDestination() const;
+		/// Returns the name of the destination table for rows to be archived.
+
+	void setDestination(const std::string& destination);
+		/// Sets the name of the destination table.
+
+	virtual const std::string& getThreshold() const = 0;
+		/// Returns the archive threshold.
+
+	virtual void setThreshold(const std::string& threshold) = 0;
+		/// Sets the archive threshold.
+
+protected:
+	typedef Poco::SharedPtr<Session>   SessionPtr;
+	typedef Poco::SharedPtr<Statement> StatementPtr;
+
+	Session& session();
+
+	void setCopyStatement();
+	void setDeleteStatement();
+	void setCountStatement();
+
+	Statement& getCopyStatement();
+	Statement& getDeleteStatement();
+	Statement& getCountStatement();
+private:
+	
+	ArchiveStrategy();
+	ArchiveStrategy(const ArchiveStrategy&);
+	ArchiveStrategy& operator = (const ArchiveStrategy&);
+
+	std::string  _connector;
+	std::string  _connect;
+	SessionPtr   _pSession;
+	StatementPtr _pCopyStatement;
+	StatementPtr _pDeleteStatement;
+	StatementPtr _pCountStatement;
+	std::string  _source;
+	std::string  _destination;
+};
+
+
+//
+// inlines
+//
+
+inline const std::string& ArchiveStrategy::getSource() const
+{
+	return _source;
+}
+
+
+inline void ArchiveStrategy::setSource(const std::string& source)
+{
+	_source = source;
+}
+
+
+inline void ArchiveStrategy::setDestination(const std::string& destination)
+{
+	_destination = destination;
+}
+
+
+inline const std::string& ArchiveStrategy::getDestination() const
+{
+	return _destination;
+}
+
+
+inline Session& ArchiveStrategy::session()
+{
+	return *_pSession;
+}
+
+
+inline void ArchiveStrategy::setCopyStatement()
+{
+	_pCopyStatement = new Statement(*_pSession);
+}
+
+
+inline void ArchiveStrategy::setDeleteStatement()
+{
+	_pDeleteStatement = new Statement(*_pSession);
+}
+
+
+inline void ArchiveStrategy::setCountStatement()
+{
+	_pCountStatement = new Statement(*_pSession);
+}
+
+
+inline Statement& ArchiveStrategy::getCopyStatement()
+{
+	return *_pCopyStatement;
+}
+
+
+inline Statement& ArchiveStrategy::getDeleteStatement()
+{
+	return *_pDeleteStatement;
+}
+
+
+inline Statement& ArchiveStrategy::getCountStatement()
+{
+	return *_pCountStatement;
+}
+
+
+
+//
+// ArchiveByAgeStrategy
+//
+class Data_API ArchiveByAgeStrategy: public ArchiveStrategy
+	/// Archives rows scheduled for archiving.
+{
+public:
+	ArchiveByAgeStrategy(const std::string& connector, 
+		const std::string& connect, 
+		const std::string& sourceTable, 
+		const std::string& destinationTable = DEFAULT_ARCHIVE_DESTINATION);
+	
+	~ArchiveByAgeStrategy();
+
+	void archive();
+
+	const std::string& getThreshold() const;
+		/// Returns the archive threshold.
+
+	void setThreshold(const std::string& threshold);
+		/// Sets the archive threshold.
+
+private:
+	ArchiveByAgeStrategy();
+	ArchiveByAgeStrategy(const ArchiveByAgeStrategy&);
+	ArchiveByAgeStrategy& operator = (const ArchiveByAgeStrategy&);
+
+	void initStatements();
+
+	Timespan     _maxAge;
+	std::string  _ageString;
+	DateTime     _archiveDateTime;
+	Poco::Dynamic::Var _archiveCount;
+};
+
+
+//
+// inlines
+//
+
+inline const std::string& ArchiveByAgeStrategy::getThreshold() const
+{
+	return _ageString;
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_ArchiveStrategy_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/AutoTransaction.h b/base/poco/Data/include/Poco/Data/AutoTransaction.h
new file mode 100644
index 00000000000..6d88184f059
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/AutoTransaction.h
@@ -0,0 +1,35 @@
+//
+// AutoTransaction.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  AutoTransaction
+//
+// Forward header for the Transaction class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+
+#ifndef Data_AutoTransaction_INCLUDED
+#define Data_AutoTransaction_INCLUDED
+
+
+#include "Poco/Data/Transaction.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+typedef Transaction AutoTransaction;
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_AutoTransaction_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/Binding.h b/base/poco/Data/include/Poco/Data/Binding.h
new file mode 100644
index 00000000000..464c3143e1a
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/Binding.h
@@ -0,0 +1,1496 @@
+//
+// Binding.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  Binding
+//
+// Definition of the Binding class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_Binding_INCLUDED
+#define Data_Binding_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/AbstractBinding.h"
+#include "Poco/Data/DataException.h"
+#include "Poco/Data/TypeHandler.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/MetaProgramming.h"
+#include "Poco/Bugcheck.h"
+#include <vector>
+#include <list>
+#include <deque>
+#include <set>
+#include <map>
+#include <cstddef>
+
+
+namespace Poco {
+namespace Data {
+
+
+template <class T>
+class Binding: public AbstractBinding
+	/// Binding maps a value or multiple values (see Binding specializations for STL containers as
+	/// well as type handlers) to database column(s). Values to be bound can be either mapped 
+	/// directly (by reference) or a copy can be created, depending on the value of the copy argument.
+	/// To pass a reference to a variable, it is recommended to pass it to the intermediate
+	/// utility function use(), which will create the proper binding. In cases when a reference 
+	/// is passed to binding, the storage it refers to must be valid at the statement execution time.
+	/// To pass a copy of a variable, constant or string literal, use utility function bind().
+	/// Variables can be passed as either copies or references (i.e. using either use() or bind()).
+	/// Constants, however, can only be passed as copies. this is best achieved using bind() utility 
+	/// function. An attempt to pass a constant by reference shall result in compile-time error.
+{
+public:
+	typedef T                  ValType;
+	typedef SharedPtr<ValType> ValPtr;
+	typedef Binding<ValType>   Type;
+	typedef SharedPtr<Type>    Ptr;
+
+	explicit Binding(T& val,
+		const std::string& name = "", 
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction),
+		_val(val), 
+		_bound(false)
+		/// Creates the Binding using the passed reference as bound value.
+		/// If copy is true, a copy of the value referred to is created.
+	{
+	}
+
+	~Binding()
+		/// Destroys the Binding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return 1u;
+	}
+
+	bool canBind() const
+	{
+		return !_bound;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		TypeHandler<T>::bind(pos, _val, getBinder(), getDirection());
+		_bound = true;
+	}
+
+	void reset ()
+	{
+		_bound = false;
+		AbstractBinder::Ptr pBinder = getBinder();
+		poco_assert_dbg (!pBinder.isNull());
+		pBinder->reset();
+	}
+
+private:
+	const T& _val;
+	bool     _bound;
+};
+
+
+
+template <class T>
+class CopyBinding: public AbstractBinding
+	/// Binding maps a value or multiple values (see Binding specializations for STL containers as
+	/// well as type handlers) to database column(s). Values to be bound can be either mapped 
+	/// directly (by reference) or a copy can be created, depending on the value of the copy argument.
+	/// To pass a reference to a variable, it is recommended to pass it to the intermediate
+	/// utility function use(), which will create the proper binding. In cases when a reference 
+	/// is passed to binding, the storage it refers to must be valid at the statement execution time.
+	/// To pass a copy of a variable, constant or string literal, use utility function bind().
+	/// Variables can be passed as either copies or references (i.e. using either use() or bind()).
+{
+public:
+	typedef T                    ValType;
+	typedef SharedPtr<ValType>   ValPtr;
+	typedef CopyBinding<ValType> Type;
+	typedef SharedPtr<Type>      Ptr;
+
+	explicit CopyBinding(T& val,
+		const std::string& name = "", 
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction),
+		_pVal(new T(val)),
+		_bound(false)
+		/// Creates the Binding using the passed reference as bound value.
+		/// If copy is true, a copy of the value referred to is created.
+	{
+	}
+
+	~CopyBinding()
+		/// Destroys the CopyBinding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return 1;
+	}
+
+	bool canBind() const
+	{
+		return !_bound;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		TypeHandler<T>::bind(pos, *_pVal, getBinder(), getDirection());
+		_bound = true;
+	}
+
+	void reset ()
+	{
+		_bound = false;
+		AbstractBinder::Ptr pBinder = getBinder();
+		poco_assert_dbg (!pBinder.isNull());
+		pBinder->reset();
+	}
+
+private:
+	//typedef typename TypeWrapper<T>::TYPE ValueType;
+	ValPtr _pVal;
+	bool   _bound;
+};
+
+
+template <>
+class Binding<const char*>: public AbstractBinding
+	/// Binding const char* specialization wraps char pointer into string.
+{
+public:
+	typedef const char*          ValType;
+	typedef SharedPtr<ValType>   ValPtr;
+	typedef Binding<const char*> Type;
+	typedef SharedPtr<Type>      Ptr;
+
+	explicit Binding(const char* pVal, 
+		const std::string& name = "",
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction), 
+		_val(pVal ? pVal : throw NullPointerException() ),
+		_bound(false)
+		/// Creates the Binding by copying the passed string.
+	{
+	}
+
+	~Binding()
+		/// Destroys the Binding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return 1u;
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return 1u;
+	}
+
+	bool canBind() const
+	{
+		return !_bound;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		TypeHandler<std::string>::bind(pos, _val, getBinder(), getDirection());
+		_bound = true;
+	}
+
+	void reset ()
+	{
+		_bound = false;
+		AbstractBinder::Ptr pBinder = getBinder();
+		poco_assert_dbg (!pBinder.isNull());
+		pBinder->reset();
+	}
+
+private:
+	std::string _val;
+	bool        _bound;
+};
+
+
+
+template <>
+class CopyBinding<const char*>: public AbstractBinding
+	/// Binding const char* specialization wraps char pointer into string.
+{
+public:
+	typedef const char*              ValType;
+	typedef SharedPtr<ValType>       ValPtr;
+	typedef CopyBinding<const char*> Type;
+	typedef SharedPtr<Type>          Ptr;
+
+	explicit CopyBinding(const char* pVal, 
+		const std::string& name = "",
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction), 
+		_val(pVal ? pVal : throw NullPointerException() ),
+		_bound(false)
+		/// Creates the Binding by copying the passed string.
+	{
+	}
+
+	~CopyBinding()
+		/// Destroys the CopyBinding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return 1u;
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return 1u;
+	}
+
+	bool canBind() const
+	{
+		return !_bound;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		TypeHandler<std::string>::bind(pos, _val, getBinder(), getDirection());
+		_bound = true;
+	}
+
+	void reset ()
+	{
+		_bound = false;
+		AbstractBinder::Ptr pBinder = getBinder();
+		poco_assert_dbg (!pBinder.isNull());
+		pBinder->reset();
+	}
+
+private:
+	std::string _val;
+	bool        _bound;
+};
+
+
+template <class T>
+class Binding<std::vector<T> >: public AbstractBinding
+	/// Specialization for std::vector.
+{
+public:
+	typedef std::vector<T>                   ValType;
+	typedef SharedPtr<ValType>               ValPtr;
+	typedef SharedPtr<Binding<ValType> >     Ptr;
+	typedef typename ValType::const_iterator Iterator;
+
+	explicit Binding(std::vector<T>& val, 
+		const std::string& name = "", 
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction),
+		_val(val), 
+		_begin(), 
+		_end()
+		/// Creates the Binding.
+	{
+		if (PD_IN == direction && numOfRowsHandled() == 0)
+			throw BindingException("It is illegal to bind to an empty data collection");
+		reset();
+	}
+
+	~Binding()
+		/// Destroys the Binding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return static_cast<std::size_t>(_val.size());
+	}
+
+	bool canBind() const
+	{
+		return _begin != _end;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		poco_assert_dbg(canBind());
+		
+		TypeHandler<T>::bind(pos, *_begin, getBinder(), getDirection());
+		++_begin;
+	}
+
+	void reset()
+	{
+		_begin = _val.begin();
+		_end   = _val.end();
+	}
+
+private:
+	const ValType& _val;
+	Iterator       _begin;
+	Iterator       _end;
+};
+
+
+template <class T>
+class CopyBinding<std::vector<T> >: public AbstractBinding
+	/// Specialization for std::vector.
+{
+public:
+	
+	typedef std::vector<T>                   ValType;
+	typedef SharedPtr<ValType>               ValPtr;
+	typedef SharedPtr<CopyBinding<ValType> > Ptr;
+	typedef typename ValType::const_iterator Iterator;
+
+	explicit CopyBinding(std::vector<T>& val, 
+		const std::string& name = "", 
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction),
+		_pVal(new std::vector<T>(val)),
+		_begin(), 
+		_end()
+		/// Creates the Binding.
+	{
+		if (PD_IN == direction && numOfRowsHandled() == 0)
+			throw BindingException("It is illegal to bind to an empty data collection");
+		reset();
+	}
+
+	~CopyBinding()
+		/// Destroys the CopyBinding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return _pVal->size();
+	}
+
+	bool canBind() const
+	{
+		return _begin != _end;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		poco_assert_dbg(canBind());
+		
+		TypeHandler<T>::bind(pos, *_begin, getBinder(), getDirection());
+		++_begin;
+	}
+
+	void reset()
+	{
+		_begin = _pVal->begin();
+		_end   = _pVal->end();
+	}
+
+private:
+	ValPtr   _pVal;
+	Iterator _begin;
+	Iterator _end;
+};
+
+
+template <>
+class Binding<std::vector<bool> >: public AbstractBinding
+	/// Specialization for std::vector<bool>.
+	/// This specialization is necessary due to the nature of std::vector<bool>.
+	/// For details, see the standard library implementation of std::vector<bool> 
+	/// or
+	/// S. Meyers: "Effective STL" (Copyright Addison-Wesley 2001),
+	/// Item 18: "Avoid using vector<bool>."
+	/// 
+	/// The workaround employed here is using std::deque<bool> as an
+	/// internal replacement container. 
+	/// 
+	/// IMPORTANT:
+	/// Only IN binding is supported.
+{
+public:
+	typedef std::vector<bool>            ValType;
+	typedef SharedPtr<ValType>           ValPtr;
+	typedef SharedPtr<Binding<ValType> > Ptr;
+	typedef ValType::const_iterator      Iterator;
+
+	explicit Binding(const std::vector<bool>& val, 
+		const std::string& name = "", 
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction), 
+		_val(val), 
+		_deq(_val.begin(), _val.end()),
+		_begin(), 
+		_end()
+		/// Creates the Binding.
+	{
+		if (PD_IN != direction)
+			throw BindingException("Only IN direction is legal for std:vector<bool> binding.");
+
+		if (numOfRowsHandled() == 0)
+			throw BindingException("It is illegal to bind to an empty data collection");
+		reset();
+	}
+
+	~Binding()
+		/// Destroys the Binding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return 1u;
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return static_cast<std::size_t>(_val.size());
+	}
+
+	bool canBind() const
+	{
+		return _begin != _end;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		poco_assert_dbg(canBind());
+		TypeHandler<bool>::bind(pos, *_begin, getBinder(), getDirection());
+		++_begin;
+
+	}
+
+	void reset()
+	{
+		_begin = _deq.begin();
+		_end   = _deq.end();
+	}
+
+private:
+	const std::vector<bool>&         _val;
+	std::deque<bool>                 _deq;
+	std::deque<bool>::const_iterator _begin;
+	std::deque<bool>::const_iterator _end;
+};
+
+
+template <>
+class CopyBinding<std::vector<bool> >: public AbstractBinding
+	/// Specialization for std::vector<bool>.
+	/// This specialization is necessary due to the nature of std::vector<bool>.
+	/// For details, see the standard library implementation of std::vector<bool> 
+	/// or
+	/// S. Meyers: "Effective STL" (Copyright Addison-Wesley 2001),
+	/// Item 18: "Avoid using vector<bool>."
+	/// 
+	/// The workaround employed here is using std::deque<bool> as an
+	/// internal replacement container. 
+	/// 
+	/// IMPORTANT:
+	/// Only IN binding is supported.
+{
+public:
+	typedef std::vector<bool>                ValType;
+	typedef SharedPtr<ValType>               ValPtr;
+	typedef SharedPtr<CopyBinding<ValType> > Ptr;
+	typedef ValType::const_iterator          Iterator;
+
+	explicit CopyBinding(const std::vector<bool>& val, 
+		const std::string& name = "", 
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction), 
+		_deq(val.begin(), val.end()),
+		_begin(), 
+		_end()
+		/// Creates the Binding.
+	{
+		if (PD_IN != direction)
+			throw BindingException("Only IN direction is legal for std:vector<bool> binding.");
+
+		if (numOfRowsHandled() == 0)
+			throw BindingException("It is illegal to bind to an empty data collection");
+
+		reset();
+	}
+
+	~CopyBinding()
+		/// Destroys the CopyBinding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return 1u;
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return static_cast<std::size_t>(_deq.size());
+	}
+
+	bool canBind() const
+	{
+		return _begin != _end;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		poco_assert_dbg(canBind());
+		TypeHandler<bool>::bind(pos, *_begin, getBinder(), getDirection());
+		++_begin;
+	}
+
+	void reset()
+	{
+		_begin = _deq.begin();
+		_end   = _deq.end();
+	}
+
+private:
+	std::deque<bool>                 _deq;
+	std::deque<bool>::const_iterator _begin;
+	std::deque<bool>::const_iterator _end;
+};
+
+
+template <class T>
+class Binding<std::list<T> >: public AbstractBinding
+	/// Specialization for std::list.
+{
+public:
+	typedef std::list<T>                     ValType;
+	typedef SharedPtr<ValType>               ValPtr;
+	typedef SharedPtr<Binding<ValType> >     Ptr;
+	typedef typename ValType::const_iterator Iterator;
+
+	explicit Binding(std::list<T>& val,
+		const std::string& name = "",
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction), 
+		_val(val), 
+		_begin(), 
+		_end()
+		/// Creates the Binding.
+	{
+		if (PD_IN == direction && numOfRowsHandled() == 0)
+			throw BindingException("It is illegal to bind to an empty data collection");
+		reset();
+	}
+
+	~Binding()
+		/// Destroys the Binding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return _val.size();
+	}
+
+	bool canBind() const
+	{
+		return _begin != _end;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		poco_assert_dbg(canBind());
+		TypeHandler<T>::bind(pos, *_begin, getBinder(), getDirection());
+		++_begin;
+	}
+
+	void reset()
+	{
+		_begin = _val.begin();
+		_end   = _val.end();
+	}
+
+private:
+	const ValType& _val;
+	Iterator       _begin;
+	Iterator       _end;
+};
+
+
+template <class T>
+class CopyBinding<std::list<T> >: public AbstractBinding
+	/// Specialization for std::list.
+{
+public:
+	typedef typename std::list<T>            ValType;
+	typedef SharedPtr<ValType>               ValPtr;
+	typedef SharedPtr<CopyBinding<ValType> > Ptr;
+	typedef typename ValType::const_iterator Iterator;
+
+	explicit CopyBinding(ValType& val,
+		const std::string& name = "",
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction), 
+		_pVal(new std::list<T>(val)),
+		_begin(), 
+		_end()
+		/// Creates the Binding.
+	{
+		if (PD_IN == direction && numOfRowsHandled() == 0)
+			throw BindingException("It is illegal to bind to an empty data collection");
+		reset();
+	}
+
+	~CopyBinding()
+		/// Destroys the CopyBinding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return _pVal->size();
+	}
+
+	bool canBind() const
+	{
+		return _begin != _end;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		poco_assert_dbg(canBind());
+		TypeHandler<T>::bind(pos, *_begin, getBinder(), getDirection());
+		++_begin;
+	}
+
+	void reset()
+	{
+		_begin = _pVal->begin();
+		_end   = _pVal->end();
+	}
+
+private:
+	ValPtr   _pVal;
+	Iterator _begin;
+	Iterator _end;
+};
+
+
+template <class T>
+class Binding<std::deque<T> >: public AbstractBinding
+	/// Specialization for std::deque.
+{
+public:
+	typedef std::deque<T>                    ValType;
+	typedef SharedPtr<ValType>               ValPtr;
+	typedef SharedPtr<Binding<ValType> >     Ptr;
+	typedef typename ValType::const_iterator Iterator;
+
+	explicit Binding(std::deque<T>& val,
+		const std::string& name = "",
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction), 
+		_val(val), 
+		_begin(), 
+		_end()
+		/// Creates the Binding.
+	{
+		if (PD_IN == direction && numOfRowsHandled() == 0)
+			throw BindingException("It is illegal to bind to an empty data collection");
+		reset();
+	}
+
+	~Binding()
+		/// Destroys the Binding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return _val.size();
+	}
+
+	bool canBind() const
+	{
+		return _begin != _end;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		poco_assert_dbg(canBind());
+		TypeHandler<T>::bind(pos, *_begin, getBinder(), getDirection());
+		++_begin;
+	}
+
+	void reset()
+	{
+		_begin = _val.begin();
+		_end   = _val.end();
+	}
+
+private:
+	const ValType& _val;
+	Iterator       _begin;
+	Iterator       _end;
+};
+
+
+template <class T>
+class CopyBinding<std::deque<T> >: public AbstractBinding
+	/// Specialization for std::deque.
+{
+public:
+	typedef std::deque<T>                    ValType;
+	typedef SharedPtr<ValType>               ValPtr;
+	typedef SharedPtr<CopyBinding<ValType> > Ptr;
+	typedef typename ValType::const_iterator Iterator;
+
+	explicit CopyBinding(std::deque<T>& val,
+		const std::string& name = "",
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction), 
+		_pVal(new std::deque<T>(val)),
+		_begin(), 
+		_end()
+		/// Creates the Binding.
+	{
+		if (PD_IN == direction && numOfRowsHandled() == 0)
+			throw BindingException("It is illegal to bind to an empty data collection");
+		reset();
+	}
+
+	~CopyBinding()
+		/// Destroys the CopyBinding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return _pVal->size();
+	}
+
+	bool canBind() const
+	{
+		return _begin != _end;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		poco_assert_dbg(canBind());
+		TypeHandler<T>::bind(pos, *_begin, getBinder(), getDirection());
+		++_begin;
+	}
+
+	void reset()
+	{
+		_begin = _pVal->begin();
+		_end   = _pVal->end();
+	}
+
+private:
+	ValPtr   _pVal;
+	Iterator _begin;
+	Iterator _end;
+};
+
+
+template <class T>
+class Binding<std::set<T> >: public AbstractBinding
+	/// Specialization for std::set.
+{
+public:
+	typedef std::set<T>                      ValType;
+	typedef SharedPtr<ValType>               ValPtr;
+	typedef SharedPtr<Binding<ValType> >     Ptr;
+	typedef typename ValType::const_iterator Iterator;
+
+	explicit Binding(std::set<T>& val,
+		const std::string& name = "",
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction), 
+		_val(val), 
+		_begin(), 
+		_end()
+		/// Creates the Binding.
+	{
+		if (PD_IN == direction && numOfRowsHandled() == 0)
+			throw BindingException("It is illegal to bind to an empty data collection");
+		reset();
+	}
+
+	~Binding()
+		/// Destroys the Binding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return static_cast<std::size_t>(_val.size());
+	}
+
+	bool canBind() const
+	{
+		return _begin != _end;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		poco_assert_dbg(canBind());
+		TypeHandler<T>::bind(pos, *_begin, getBinder(), getDirection());
+		++_begin;
+	}
+
+	void reset()
+	{
+		_begin = _val.begin();
+		_end   = _val.end();
+	}
+
+private:
+	const ValType& _val;
+	Iterator       _begin;
+	Iterator       _end;
+};
+
+
+template <class T>
+class CopyBinding<std::set<T> >: public AbstractBinding
+	/// Specialization for std::set.
+{
+public:
+	typedef std::set<T>                      ValType;
+	typedef SharedPtr<ValType>               ValPtr;
+	typedef SharedPtr<CopyBinding<ValType> > Ptr;
+	typedef typename ValType::const_iterator Iterator;
+
+	explicit CopyBinding(std::set<T>& val,
+		const std::string& name = "",
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction), 
+		_pVal(new std::set<T>(val)),
+		_begin(), 
+		_end()
+		/// Creates the Binding.
+	{
+		if (PD_IN == direction && numOfRowsHandled() == 0)
+			throw BindingException("It is illegal to bind to an empty data collection");
+		reset();
+	}
+
+	~CopyBinding()
+		/// Destroys the CopyBinding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return _pVal->size();
+	}
+
+	bool canBind() const
+	{
+		return _begin != _end;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		poco_assert_dbg(canBind());
+		TypeHandler<T>::bind(pos, *_begin, getBinder(), getDirection());
+		++_begin;
+	}
+
+	void reset()
+	{
+		_begin = _pVal->begin();
+		_end   = _pVal->end();
+	}
+
+private:
+	ValPtr   _pVal;
+	Iterator _begin;
+	Iterator _end;
+};
+
+
+template <class T>
+class Binding<std::multiset<T> >: public AbstractBinding
+	/// Specialization for std::multiset.
+{
+public:
+	typedef std::multiset<T>                 ValType;
+	typedef SharedPtr<ValType>               ValPtr;
+	typedef SharedPtr<Binding<ValType> >     Ptr;
+	typedef typename ValType::const_iterator Iterator;
+
+	explicit Binding(std::multiset<T>& val,
+		const std::string& name = "",
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction), 
+		_val(val), 
+		_begin(), 
+		_end()
+		/// Creates the Binding.
+	{
+		if (PD_IN == direction && numOfRowsHandled() == 0)
+			throw BindingException("It is illegal to bind to an empty data collection");
+		reset();
+	}
+
+	~Binding()
+		/// Destroys the Binding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return static_cast<std::size_t>(_val.size());
+	}
+
+	bool canBind() const
+	{
+		return _begin != _end;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		poco_assert_dbg(canBind());
+		TypeHandler<T>::bind(pos, *_begin, getBinder(), getDirection());
+		++_begin;
+	}
+
+	void reset()
+	{
+		_begin = _val.begin();
+		_end   = _val.end();
+	}
+
+private:
+	const ValType& _val;
+	Iterator       _begin;
+	Iterator       _end;
+};
+
+
+template <class T>
+class CopyBinding<std::multiset<T> >: public AbstractBinding
+	/// Specialization for std::multiset.
+{
+public:
+	typedef std::multiset<T>             ValType;
+	typedef SharedPtr<ValType>           ValPtr;
+	typedef SharedPtr<CopyBinding<ValType> > Ptr;
+	typedef typename ValType::const_iterator Iterator;
+
+	explicit CopyBinding(std::multiset<T>& val,
+		const std::string& name = "",
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction), 
+		_pVal(new std::multiset<T>(val)),
+		_begin(), 
+		_end()
+		/// Creates the Binding.
+	{
+		if (PD_IN == direction && numOfRowsHandled() == 0)
+			throw BindingException("It is illegal to bind to an empty data collection");
+		reset();
+	}
+
+	~CopyBinding()
+		/// Destroys the CopyBinding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return _pVal->size();
+	}
+
+	bool canBind() const
+	{
+		return _begin != _end;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		poco_assert_dbg(canBind());
+		TypeHandler<T>::bind(pos, *_begin, getBinder(), getDirection());
+		++_begin;
+	}
+
+	void reset()
+	{
+		_begin = _pVal->begin();
+		_end   = _pVal->end();
+	}
+
+private:
+	ValPtr    _pVal;
+	Iterator _begin;
+	Iterator _end;
+};
+
+
+template <class K, class V>
+class Binding<std::map<K, V> >: public AbstractBinding
+	/// Specialization for std::map.
+{
+public:
+	typedef std::map<K, V>                   ValType;
+	typedef SharedPtr<ValType>               ValPtr;
+	typedef SharedPtr<Binding<ValType> >     Ptr;
+	typedef typename ValType::const_iterator Iterator;
+
+	explicit Binding(std::map<K, V>& val,
+		const std::string& name = "",
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction), 
+		_val(val), 
+		_begin(), 
+		_end()
+		/// Creates the Binding.
+	{
+		if (PD_IN == direction && numOfRowsHandled() == 0)
+			throw BindingException("It is illegal to bind to an empty data collection");
+		reset();
+	}
+
+	~Binding()
+		/// Destroys the Binding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<V>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return static_cast<std::size_t>(_val.size());
+	}
+
+	bool canBind() const
+	{
+		return _begin != _end;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		poco_assert_dbg(canBind());
+		TypeHandler<V>::bind(pos, _begin->second, getBinder(), getDirection());
+		++_begin;
+	}
+
+	void reset()
+	{
+		_begin = _val.begin();
+		_end   = _val.end();
+	}
+
+private:
+	const ValType& _val;
+	Iterator       _begin;
+	Iterator       _end;
+};
+
+
+template <class K, class V>
+class CopyBinding<std::map<K, V> >: public AbstractBinding
+	/// Specialization for std::map.
+{
+public:
+	typedef std::map<K, V>                   ValType;
+	typedef SharedPtr<ValType>               ValPtr;
+	typedef SharedPtr<CopyBinding<ValType> > Ptr;
+	typedef typename ValType::const_iterator Iterator;
+
+	explicit CopyBinding(std::map<K, V>& val,
+		const std::string& name = "",
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction), 
+		_pVal(new std::map<K, V>(val)),
+		_begin(), 
+		_end()
+		/// Creates the Binding.
+	{
+		if (PD_IN == direction && numOfRowsHandled() == 0)
+			throw BindingException("It is illegal to bind to an empty data collection");
+		reset();
+	}
+
+	~CopyBinding()
+		/// Destroys the CopyBinding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<V>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return _pVal->size();
+	}
+
+	bool canBind() const
+	{
+		return _begin != _end;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		poco_assert_dbg(canBind());
+		TypeHandler<V>::bind(pos, _begin->second, getBinder(), getDirection());
+		++_begin;
+	}
+
+	void reset()
+	{
+		_begin = _pVal->begin();
+		_end   = _pVal->end();
+	}
+
+private:
+	ValPtr   _pVal;
+	Iterator _begin;
+	Iterator _end;
+};
+
+
+template <class K, class V>
+class Binding<std::multimap<K, V> >: public AbstractBinding
+	/// Specialization for std::multimap.
+{
+public:
+	typedef std::multimap<K, V>              ValType;
+	typedef SharedPtr<ValType>               ValPtr;
+	typedef SharedPtr<Binding<ValType> >     Ptr;
+	typedef typename ValType::const_iterator Iterator;
+
+	explicit Binding(std::multimap<K, V>& val,
+		const std::string& name = "",
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction), 
+		_val(val), 
+		_begin(), 
+		_end()
+		/// Creates the Binding.
+	{
+		if (PD_IN == direction && numOfRowsHandled() == 0)
+			throw BindingException("It is illegal to bind to an empty data collection");
+		reset();
+	}
+
+	~Binding()
+		/// Destroys the Binding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<V>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return static_cast<std::size_t>(_val.size());
+	}
+
+	bool canBind() const
+	{
+		return _begin != _end;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		poco_assert_dbg(canBind());
+		TypeHandler<V>::bind(pos, _begin->second, getBinder(), getDirection());
+		++_begin;
+	}
+
+	void reset()
+	{
+		_begin = _val.begin();
+		_end   = _val.end();
+	}
+
+private:
+	const ValType& _val;
+	Iterator       _begin;
+	Iterator       _end;
+};
+
+
+template <class K, class V>
+class CopyBinding<std::multimap<K, V> >: public AbstractBinding
+	/// Specialization for std::multimap.
+{
+public:
+	typedef std::multimap<K, V>              ValType;
+	typedef SharedPtr<ValType>               ValPtr;
+	typedef SharedPtr<CopyBinding<ValType> > Ptr;
+	typedef typename ValType::const_iterator Iterator;
+
+	explicit CopyBinding(std::multimap<K, V>& val,
+		const std::string& name = "",
+		Direction direction = PD_IN): 
+		AbstractBinding(name, direction), 
+		_pVal(new std::multimap<K, V>(val)),
+		_begin(), 
+		_end()
+		/// Creates the Binding.
+	{
+		if (PD_IN == direction && numOfRowsHandled() == 0)
+			throw BindingException("It is illegal to bind to an empty data collection");
+		reset();
+	}
+
+	~CopyBinding()
+		/// Destroys the CopyBinding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<V>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return _pVal->size();
+	}
+
+	bool canBind() const
+	{
+		return _begin != _end;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		poco_assert_dbg(canBind());
+		TypeHandler<V>::bind(pos, _begin->second, getBinder(), getDirection());
+		++_begin;
+	}
+
+	void reset()
+	{
+		_begin = _pVal->begin();
+		_end   = _pVal->end();
+	}
+
+private:
+	ValPtr   _pVal;
+	Iterator _begin;
+	Iterator _end;
+};
+
+
+namespace Keywords {
+
+
+template <typename T> 
+inline AbstractBinding::Ptr use(T& t, const std::string& name = "")
+	/// Convenience function for a more compact Binding creation.
+{
+	// If this fails to compile, a const ref was passed to use().
+	// This can be resolved by either (a) using bind (which will copy the value),
+	// or (b) if the const ref is guaranteed to exist when execute is called 
+	// (which can be much later!), by using the "useRef" keyword instead
+	poco_static_assert (!IsConst<T>::VALUE);
+	return new Binding<T>(t, name, AbstractBinding::PD_IN);
+}
+
+
+inline AbstractBinding::Ptr use(const NullData& t, const std::string& name = "")
+	/// NullData overload.
+{
+	return new Binding<NullData>(const_cast<NullData&>(t), name, AbstractBinding::PD_IN);
+}
+
+
+template <typename T> 
+inline AbstractBinding::Ptr useRef(T& t, const std::string& name = "")
+	/// Convenience function for a more compact Binding creation.
+{
+	return new Binding<T>(t, name, AbstractBinding::PD_IN);
+}
+
+
+template <typename T> 
+inline AbstractBinding::Ptr in(T& t, const std::string& name = "")
+	/// Convenience function for a more compact Binding creation.
+{
+	return use(t, name);
+}
+
+
+inline AbstractBinding::Ptr in(const NullData& t, const std::string& name = "")
+	/// NullData overload.
+{
+	return use(t, name);
+}
+
+
+template <typename T> 
+inline AbstractBinding::Ptr out(T& t)
+	/// Convenience function for a more compact Binding creation.
+{
+	poco_static_assert (!IsConst<T>::VALUE);
+	return new Binding<T>(t, "", AbstractBinding::PD_OUT);
+}
+
+
+template <typename T> 
+inline AbstractBinding::Ptr io(T& t)
+	/// Convenience function for a more compact Binding creation.
+{
+	poco_static_assert (!IsConst<T>::VALUE);
+	return new Binding<T>(t, "", AbstractBinding::PD_IN_OUT);
+}
+
+
+inline AbstractBindingVec& use(AbstractBindingVec& bv)
+	/// Convenience dummy function (for syntax purposes only).
+{
+	return bv;
+}
+
+
+inline AbstractBindingVec& in(AbstractBindingVec& bv)
+	/// Convenience dummy function (for syntax purposes only).
+{
+	return bv;
+}
+
+
+inline AbstractBindingVec& out(AbstractBindingVec& bv)
+	/// Convenience dummy function (for syntax purposes only).
+{
+	return bv;
+}
+
+
+inline AbstractBindingVec& io(AbstractBindingVec& bv)
+	/// Convenience dummy function (for syntax purposes only).
+{
+	return bv;
+}
+
+
+template <typename T> 
+inline AbstractBinding::Ptr bind(T t, const std::string& name)
+	/// Convenience function for a more compact Binding creation.
+	/// This funtion differs from use() in its value copy semantics.
+{
+	return new CopyBinding<T>(t, name, AbstractBinding::PD_IN);
+}
+
+
+template <typename T> 
+inline AbstractBinding::Ptr bind(T t)
+	/// Convenience function for a more compact Binding creation.
+	/// This funtion differs from use() in its value copy semantics.
+{
+	return Poco::Data::Keywords::bind(t, "");
+}
+
+
+} // namespace Keywords
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_Binding_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/Bulk.h b/base/poco/Data/include/Poco/Data/Bulk.h
new file mode 100644
index 00000000000..7b30ae63350
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/Bulk.h
@@ -0,0 +1,96 @@
+//
+// BulkExtraction.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  Bulk
+//
+// Definition of the BulkExtraction class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_Bulk_INCLUDED
+#define Data_Bulk_INCLUDED
+
+
+#include "Poco/Void.h"
+#include "Poco/Data/Limit.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API Bulk
+{
+public:
+	Bulk(const Limit& limit);
+		/// Creates the Bulk.
+
+	Bulk(Poco::UInt32 value);
+		/// Creates the Bulk.
+
+	~Bulk();
+		/// Destroys the bulk.
+
+	const Limit& limit() const;
+		/// Returns the limit asociated with this bulk object.
+
+	Poco::UInt32 size() const;
+		/// Returns the value of the limit asociated with 
+		/// this bulk object.
+	
+private:
+	Bulk();
+
+	Limit _limit;
+};
+
+
+///
+/// inlines
+///
+inline const Limit& Bulk::limit() const 
+{ 
+	return _limit; 
+}
+
+
+inline Poco::UInt32 Bulk::size() const 
+{ 
+	return _limit.value(); 
+}
+
+
+namespace Keywords {
+
+
+inline Bulk bulk(const Limit& limit = Limit(Limit::LIMIT_UNLIMITED, false, false))
+	/// Convenience function for creation of bulk.
+{
+	return Bulk(limit);
+}
+
+
+inline void bulk(Void)
+	/// Dummy bulk function. Used for bulk binding creation
+	/// (see BulkBinding) and bulk extraction signalling to Statement.
+{
+}
+
+
+} // namespace Keywords
+
+
+typedef void (*BulkFnType)(Void);
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_Bulk_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/BulkBinding.h b/base/poco/Data/include/Poco/Data/BulkBinding.h
new file mode 100644
index 00000000000..a28213ea4d7
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/BulkBinding.h
@@ -0,0 +1,148 @@
+//
+// BulkBinding.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  BulkBinding
+//
+// Definition of the BulkBinding class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_BulkBinding_INCLUDED
+#define Data_BulkBinding_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/AbstractBinding.h"
+#include "Poco/Data/DataException.h"
+#include "Poco/Data/TypeHandler.h"
+#include "Poco/Data/Bulk.h"
+#include <vector>
+#include <deque>
+#include <list>
+#include <cstddef>
+
+
+namespace Poco {
+namespace Data {
+
+
+template <class T>
+class BulkBinding: public AbstractBinding
+	/// A BulkBinding maps a value to a column. 
+	/// Bulk binding support is provided only for std::vector.
+{
+public:
+	BulkBinding(const T& val, Poco::UInt32 bulkSize, const std::string& name = "", Direction direction = PD_IN): 
+		AbstractBinding(name, direction, bulkSize), 
+		_val(val), 
+		_bound(false)
+		/// Creates the BulkBinding.
+	{
+		if (0 == _val.size())
+			throw BindingException("Zero size containers not allowed.");
+	}
+
+	~BulkBinding()
+		/// Destroys the BulkBinding.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return 1;
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return _val.size();
+	}
+
+	bool canBind() const
+	{
+		return !_bound;
+	}
+
+	void bind(std::size_t pos)
+	{
+		poco_assert_dbg(!getBinder().isNull());
+		TypeHandler<T>::bind(pos, _val, getBinder(), getDirection());
+		_bound = true;
+	}
+
+	void reset ()
+	{
+		_bound = false;
+		getBinder()->reset();
+	}
+
+private:
+	const T& _val;
+	bool     _bound;
+};
+
+
+namespace Keywords {
+
+
+template <typename T> 
+AbstractBinding::Ptr use(const std::vector<T>& t, BulkFnType, const std::string& name = "")
+	/// Convenience function for a more compact BulkBinding creation for std::vector.
+{
+	return new BulkBinding<std::vector<T> >(t, static_cast<Poco::UInt32>(t.size()), name);
+}
+
+
+template <typename T> 
+AbstractBinding::Ptr in(const std::vector<T>& t, BulkFnType, const std::string& name = "")
+	/// Convenience function for a more compact BulkBinding creation for std::vector.
+{
+	return new BulkBinding<std::vector<T> >(t, static_cast<Poco::UInt32>(t.size()), name);
+}
+
+
+template <typename T> 
+AbstractBinding::Ptr use(const std::deque<T>& t, BulkFnType, const std::string& name = "")
+	/// Convenience function for a more compact BulkBinding creation for std::deque.
+{
+	return new BulkBinding<std::deque<T> >(t, static_cast<Poco::UInt32>(t.size()), name);
+}
+
+
+template <typename T> 
+AbstractBinding::Ptr in(const std::deque<T>& t, BulkFnType, const std::string& name = "")
+	/// Convenience function for a more compact BulkBinding creation for std::deque.
+{
+	return new BulkBinding<std::deque<T> >(t, static_cast<Poco::UInt32>(t.size()), name);
+}
+
+
+template <typename T> 
+AbstractBinding::Ptr use(const std::list<T>& t, BulkFnType, const std::string& name = "")
+	/// Convenience function for a more compact BulkBinding creation for std::list.
+{
+	return new BulkBinding<std::list<T> >(t, static_cast<Poco::UInt32>(t.size()), name);
+}
+
+
+template <typename T> 
+AbstractBinding::Ptr in(const std::list<T>& t, BulkFnType, const std::string& name = "")
+	/// Convenience function for a more compact BulkBinding creation for std::list.
+{
+	return new BulkBinding<std::list<T> >(t, static_cast<Poco::UInt32>(t.size()), name);
+}
+
+
+} // namespace Keywords
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_BulkBinding_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/BulkExtraction.h b/base/poco/Data/include/Poco/Data/BulkExtraction.h
new file mode 100644
index 00000000000..75c25f69b7d
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/BulkExtraction.h
@@ -0,0 +1,276 @@
+//
+// BulkExtraction.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  BulkExtraction
+//
+// Definition of the BulkExtraction class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_BulkExtraction_INCLUDED
+#define Data_BulkExtraction_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/AbstractExtraction.h"
+#include "Poco/Data/Bulk.h"
+#include "Poco/Data/Preparation.h"
+#include <vector>
+
+
+namespace Poco {
+namespace Data {
+
+
+template <class C>
+class BulkExtraction: public AbstractExtraction
+	/// Specialization for bulk extraction of values from a query result set.
+	/// Bulk extraction support is provided only for following STL containers:
+	/// - std::vector
+	/// - std::deque
+	/// - std::list
+{
+public:
+	typedef C                       ValType;
+	typedef typename C::value_type  CValType;
+	typedef SharedPtr<ValType>      ValPtr;
+	typedef BulkExtraction<ValType> Type;
+	typedef SharedPtr<Type>         Ptr;
+
+	BulkExtraction(C& result, Poco::UInt32 limit, const Position& pos = Position(0)): 
+		AbstractExtraction(limit, pos.value(), true),
+		_rResult(result), 
+		_default()
+	{
+		if (static_cast<Poco::UInt32>(result.size()) != limit)
+			result.resize(limit);
+	}
+
+	BulkExtraction(C& result, const CValType& def, Poco::UInt32 limit, const Position& pos = Position(0)): 
+		AbstractExtraction(limit, pos.value(), true),
+		_rResult(result), 
+		_default(def)
+	{
+		if (static_cast<Poco::UInt32>(result.size()) != limit)
+			result.resize(limit);
+	}
+
+	virtual ~BulkExtraction()
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<C>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return _rResult.size();
+	}
+
+	std::size_t numOfRowsAllowed() const
+	{
+		return getLimit();
+	}
+
+	bool isNull(std::size_t row) const
+	{
+		try
+		{
+			return _nulls.at(row);
+		}
+		catch (std::out_of_range& ex)
+		{ 
+			throw RangeException(ex.what()); 
+		}
+	}
+
+	std::size_t extract(std::size_t col)
+	{
+		AbstractExtractor::Ptr pExt = getExtractor();
+		TypeHandler<C>::extract(col, _rResult, _default, pExt);
+		typename C::iterator it = _rResult.begin();
+		typename C::iterator end = _rResult.end();
+		for (int row = 0; it !=end; ++it, ++row)
+		{
+			_nulls.push_back(isValueNull(*it, pExt->isNull(col, row)));
+		}
+
+		return _rResult.size();
+	}
+
+	virtual void reset()
+	{
+	}
+
+	AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t col)
+	{
+		Poco::UInt32 limit = getLimit();
+		if (limit != _rResult.size()) _rResult.resize(limit);
+		pPrep->setLength(limit);
+		pPrep->setBulk(true);
+		return new Preparation<C>(pPrep, col, _rResult);
+	}
+
+protected:
+	const C& result() const
+	{
+		return _rResult;
+	}
+
+private:
+	C&               _rResult;
+	CValType         _default;
+	std::deque<bool> _nulls;
+};
+
+
+template <class C>
+class InternalBulkExtraction: public BulkExtraction<C>
+	/// Container Data Type specialization extension for extraction of values from a query result set.
+	///
+	/// This class is intended for PocoData internal use - it is used by StatementImpl 
+	/// to automaticaly create internal BulkExtraction in cases when statement returns data and no external storage
+	/// was supplied. It is later used by RecordSet to retrieve the fetched data after statement execution.
+	/// It takes ownership of the Column pointer supplied as constructor argument. Column object, in turn
+	/// owns the data container pointer.
+	///
+	/// InternalBulkExtraction objects can not be copied or assigned.
+{
+public:
+	typedef C                               ValType;
+	typedef typename C::value_type          CValType;
+	typedef SharedPtr<ValType>              ValPtr;
+	typedef InternalBulkExtraction<ValType> Type;
+	typedef SharedPtr<Type>                 Ptr;
+
+	InternalBulkExtraction(C& result,
+		Column<C>* pColumn,
+		Poco::UInt32 limit,
+		const Position& pos = Position(0)): 
+		BulkExtraction<C>(result, CValType(), limit, pos), 
+		_pColumn(pColumn)
+		/// Creates InternalBulkExtraction.
+	{
+	}
+
+	~InternalBulkExtraction()
+		/// Destroys InternalBulkExtraction.
+	{
+		delete _pColumn;
+	}
+
+	void reset()
+	{
+		_pColumn->reset();
+	}	
+
+	const CValType& value(int index) const
+	{
+		try
+		{ 
+			return BulkExtraction<C>::result().at(index); 
+		}
+		catch (std::out_of_range& ex)
+		{ 
+			throw RangeException(ex.what()); 
+		}
+	}
+
+	bool isNull(std::size_t row) const
+	{
+		return BulkExtraction<C>::isNull(row);
+	}
+
+	const Column<C>& column() const
+	{
+		return *_pColumn;
+	}
+
+private:
+	InternalBulkExtraction();
+	InternalBulkExtraction(const InternalBulkExtraction&);
+	InternalBulkExtraction& operator = (const InternalBulkExtraction&);
+
+	Column<C>* _pColumn;
+};
+
+
+namespace Keywords {
+
+
+template <typename T> 
+AbstractExtraction::Ptr into(std::vector<T>& t, const Bulk& bulk, const Position& pos = Position(0))
+	/// Convenience function to allow for a more compact creation of an extraction object
+	/// with std::vector bulk extraction support.
+{
+	return new BulkExtraction<std::vector<T> >(t, bulk.size(), pos);
+}
+
+
+template <typename T> 
+AbstractExtraction::Ptr into(std::vector<T>& t, BulkFnType, const Position& pos = Position(0))
+	/// Convenience function to allow for a more compact creation of an extraction object
+	/// with std::vector bulk extraction support.
+{
+	Poco::UInt32 size = static_cast<Poco::UInt32>(t.size());
+	if (0 == size) throw InvalidArgumentException("Zero length not allowed.");
+	return new BulkExtraction<std::vector<T> >(t, size, pos);
+}
+
+
+template <typename T> 
+AbstractExtraction::Ptr into(std::deque<T>& t, const Bulk& bulk, const Position& pos = Position(0))
+	/// Convenience function to allow for a more compact creation of an extraction object
+	/// with std::deque bulk extraction support.
+{
+	return new BulkExtraction<std::deque<T> >(t, bulk.size(), pos);
+}
+
+
+template <typename T> 
+AbstractExtraction::Ptr into(std::deque<T>& t, BulkFnType, const Position& pos = Position(0))
+	/// Convenience function to allow for a more compact creation of an extraction object
+	/// with std::deque bulk extraction support.
+{
+	Poco::UInt32 size = static_cast<Poco::UInt32>(t.size());
+	if (0 == size) throw InvalidArgumentException("Zero length not allowed.");
+	return new BulkExtraction<std::deque<T> >(t, size, pos);
+}
+
+
+template <typename T> 
+AbstractExtraction::Ptr into(std::list<T>& t, const Bulk& bulk, const Position& pos = Position(0))
+	/// Convenience function to allow for a more compact creation of an extraction object
+	/// with std::list bulk extraction support.
+{
+	return new BulkExtraction<std::list<T> >(t, bulk.size(), pos);
+}
+
+
+template <typename T> 
+AbstractExtraction::Ptr into(std::list<T>& t, BulkFnType, const Position& pos = Position(0))
+	/// Convenience function to allow for a more compact creation of an extraction object
+	/// with std::list bulk extraction support.
+{
+	Poco::UInt32 size = static_cast<Poco::UInt32>(t.size());
+	if (0 == size) throw InvalidArgumentException("Zero length not allowed.");
+	return new BulkExtraction<std::list<T> >(t, size, pos);
+}
+
+
+} // namespace Keywords
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_BulkExtraction_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/Column.h b/base/poco/Data/include/Poco/Data/Column.h
new file mode 100644
index 00000000000..22c44a2fa52
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/Column.h
@@ -0,0 +1,490 @@
+//
+// Column.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  Column
+//
+// Definition of the Column class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_Column_INCLUDED
+#define Data_Column_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/MetaColumn.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/RefCountedObject.h"
+#include <vector>
+#include <list>
+#include <deque>
+
+
+namespace Poco {
+namespace Data {
+
+
+template <class C>
+class Column
+	/// Column class is column data container.
+	/// Data (a pointer to underlying STL container) is assigned to the class 
+	/// at construction time. Construction with null pointer is not allowed.
+	/// This class owns the data assigned to it and deletes the storage on destruction.
+{
+public:
+	typedef C                                  Container;
+	typedef Poco::SharedPtr<C>                 ContainerPtr;
+	typedef typename C::const_iterator         Iterator;
+	typedef typename C::const_reverse_iterator RIterator;
+	typedef typename C::size_type              Size;
+	typedef typename C::value_type             Type;
+
+	Column(const MetaColumn& metaColumn, Container* pData): 
+		_metaColumn(metaColumn),
+		_pData(pData)
+		/// Creates the Column.
+	{
+		if (!_pData)
+			throw NullPointerException("Container pointer must point to valid storage.");
+	}
+
+	Column(const Column& col): 
+		_metaColumn(col._metaColumn), 
+		_pData(col._pData)
+		/// Creates the Column.
+	{
+	}
+
+	~Column()
+		/// Destroys the Column.
+	{
+	}
+
+	Column& operator = (const Column& col)
+		/// Assignment operator.
+	{
+		Column tmp(col);
+		swap(tmp);
+		return *this;
+	}
+
+	void swap(Column& other)
+		/// Swaps the column with another one.
+	{
+		using std::swap;
+		swap(_metaColumn, other._metaColumn);
+		swap(_pData, other._pData);
+	}
+
+	Container& data()
+		/// Returns reference to contained data.
+	{
+		return *_pData;
+	}
+
+	const Type& value(std::size_t row) const
+		/// Returns the field value in specified row.
+	{
+		try
+		{
+			return _pData->at(row);
+		}
+		catch (std::out_of_range& ex)
+		{ 
+			throw RangeException(ex.what()); 
+		}
+	}
+
+	const Type& operator [] (std::size_t row) const
+		/// Returns the field value in specified row.
+	{
+		return value(row);
+	}
+
+	Size rowCount() const
+		/// Returns number of rows.
+	{
+		return _pData->size();
+	}
+
+	void reset()
+		/// Clears and shrinks the storage.
+	{
+		Container().swap(*_pData);
+	}
+
+	const std::string& name() const
+		/// Returns column name.
+	{
+		return _metaColumn.name();
+	}
+
+	std::size_t length() const
+		/// Returns column maximum length.
+	{
+		return _metaColumn.length();
+	}
+
+	std::size_t precision() const
+		/// Returns column precision.
+		/// Valid for floating point fields only (zero for other data types).
+	{
+		return _metaColumn.precision();
+	}
+
+	std::size_t position() const
+		/// Returns column position.
+	{
+		return _metaColumn.position();
+	}
+
+	MetaColumn::ColumnDataType type() const
+		/// Returns column type.
+	{
+		return _metaColumn.type();
+	}
+
+	Iterator begin() const
+		/// Returns iterator pointing to the beginning of data storage vector.
+	{
+		return _pData->begin();
+	}
+
+	Iterator end() const
+		/// Returns iterator pointing to the end of data storage vector.
+	{
+		return _pData->end();
+	}
+
+private:
+	Column();
+
+	MetaColumn   _metaColumn;
+	ContainerPtr _pData;
+};
+
+
+template <>
+class Column<std::vector<bool> >
+	/// The std::vector<bool> specialization for the Column class.
+	/// 
+	/// This specialization is necessary due to the nature of std::vector<bool>.
+	/// For details, see the standard library implementation of vector<bool> 
+	/// or
+	/// S. Meyers: "Effective STL" (Copyright Addison-Wesley 2001),
+	/// Item 18: "Avoid using vector<bool>."
+	/// 
+	/// The workaround employed here is using deque<bool> as an
+	/// internal "companion" container kept in sync with the vector<bool>
+	/// column data.
+{
+public:
+	typedef std::vector<bool>                 Container;
+	typedef Poco::SharedPtr<Container>        ContainerPtr;
+	typedef Container::const_iterator         Iterator;
+	typedef Container::const_reverse_iterator RIterator;
+	typedef Container::size_type              Size;
+
+	Column(const MetaColumn& metaColumn, Container* pData): 
+		_metaColumn(metaColumn), 
+		_pData(pData)
+		/// Creates the Column.
+	{
+		poco_check_ptr (_pData);
+		_deque.assign(_pData->begin(), _pData->end());
+	}
+
+	Column(const Column& col): 
+		_metaColumn(col._metaColumn), 
+		_pData(col._pData)
+		/// Creates the Column.
+	{
+		_deque.assign(_pData->begin(), _pData->end());
+	}
+
+	~Column()
+		/// Destroys the Column.
+	{
+	}
+
+	Column& operator = (const Column& col)
+		/// Assignment operator.
+	{
+		Column tmp(col);
+		swap(tmp);
+		return *this;
+	}
+
+	void swap(Column& other)
+		/// Swaps the column with another one.
+	{
+		using std::swap;
+		swap(_metaColumn, other._metaColumn);
+		swap(_pData, other._pData);
+		swap(_deque, other._deque);
+	}
+
+	Container& data()
+		/// Returns reference to contained data.
+	{
+		return *_pData;
+	}
+
+	const bool& value(std::size_t row) const
+		/// Returns the field value in specified row.
+	{
+		if (_deque.size() < _pData->size())
+			_deque.resize(_pData->size());
+
+		try
+		{
+			return _deque.at(row) = _pData->at(row);
+		}
+		catch (std::out_of_range& ex)
+		{ 
+			throw RangeException(ex.what()); 
+		}
+	}
+
+	const bool& operator [] (std::size_t row) const
+		/// Returns the field value in specified row.
+	{
+		return value(row);
+	}
+
+	Size rowCount() const
+		/// Returns number of rows.
+	{
+		return _pData->size();
+	}
+
+	void reset()
+		/// Clears and shrinks the storage.
+	{
+		Container().swap(*_pData);
+		_deque.clear();
+	}
+
+	const std::string& name() const
+		/// Returns column name.
+	{
+		return _metaColumn.name();
+	}
+
+	std::size_t length() const
+		/// Returns column maximum length.
+	{
+		return _metaColumn.length();
+	}
+
+	std::size_t precision() const
+		/// Returns column precision.
+		/// Valid for floating point fields only (zero for other data types).
+	{
+		return _metaColumn.precision();
+	}
+
+	std::size_t position() const
+		/// Returns column position.
+	{
+		return _metaColumn.position();
+	}
+
+	MetaColumn::ColumnDataType type() const
+		/// Returns column type.
+	{
+		return _metaColumn.type();
+	}
+
+	Iterator begin() const
+		/// Returns iterator pointing to the beginning of data storage vector.
+	{
+		return _pData->begin();
+	}
+
+	Iterator end() const
+		/// Returns iterator pointing to the end of data storage vector.
+	{
+		return _pData->end();
+	}
+
+private:
+	Column();
+
+	MetaColumn               _metaColumn;
+	ContainerPtr             _pData;
+	mutable std::deque<bool> _deque;
+};
+
+
+template <class T>
+class Column<std::list<T> >
+	/// Column specialization for std::list
+{
+public:
+	typedef std::list<T>                               Container;
+	typedef Poco::SharedPtr<Container>                 ContainerPtr;
+	typedef typename Container::const_iterator         Iterator;
+	typedef typename Container::const_reverse_iterator RIterator;
+	typedef typename Container::size_type              Size;
+
+	Column(const MetaColumn& metaColumn, std::list<T>* pData): 
+		_metaColumn(metaColumn), 
+		_pData(pData)
+		/// Creates the Column.
+	{
+		poco_check_ptr (_pData);
+	}
+
+	Column(const Column& col):
+		_metaColumn(col._metaColumn),
+		_pData(col._pData)
+		/// Creates the Column.
+	{
+	}
+
+	~Column()
+		/// Destroys the Column.
+	{
+	}
+
+	Column& operator = (const Column& col)
+		/// Assignment operator.
+	{
+		Column tmp(col);
+		swap(tmp);
+		return *this;
+	}
+
+	void swap(Column& other)
+		/// Swaps the column with another one.
+	{
+		using std::swap;
+		swap(_metaColumn, other._metaColumn);
+		swap(_pData, other._pData);
+	}
+
+	Container& data()
+		/// Returns reference to contained data.
+	{
+		return *_pData;
+	}
+
+	const T& value(std::size_t row) const
+		/// Returns the field value in specified row.
+		/// This is the std::list specialization and std::list
+		/// is not the optimal solution for cases where random 
+		/// access is needed.
+		/// However, to allow for compatibility with other
+		/// containers, this functionality is provided here.
+		/// To alleviate the problem, an effort is made
+		/// to start iteration from beginning or end,
+		/// depending on the position requested.
+	{
+		if (row <= (std::size_t) (_pData->size() / 2))
+		{
+			Iterator it = _pData->begin();
+			Iterator end = _pData->end();
+			for (int i = 0; it != end; ++it, ++i)
+				if (i == row) return *it;
+		}
+		else
+		{
+			row = _pData->size() - row;
+			RIterator it = _pData->rbegin();
+			RIterator end = _pData->rend();
+			for (int i = 1; it != end; ++it, ++i)
+				if (i == row) return *it;
+		}
+
+		throw RangeException("Invalid row number."); 
+	}
+
+	const T& operator [] (std::size_t row) const
+		/// Returns the field value in specified row.
+	{
+		return value(row);
+	}
+
+	Size rowCount() const
+		/// Returns number of rows.
+	{
+		return _pData->size();
+	}
+
+	void reset()
+		/// Clears the storage.
+	{
+		_pData->clear();
+	}
+
+	const std::string& name() const
+		/// Returns column name.
+	{
+		return _metaColumn.name();
+	}
+
+	std::size_t length() const
+		/// Returns column maximum length.
+	{
+		return _metaColumn.length();
+	}
+
+	std::size_t precision() const
+		/// Returns column precision.
+		/// Valid for floating point fields only (zero for other data types).
+	{
+		return _metaColumn.precision();
+	}
+
+	std::size_t position() const
+		/// Returns column position.
+	{
+		return _metaColumn.position();
+	}
+
+	MetaColumn::ColumnDataType type() const
+		/// Returns column type.
+	{
+		return _metaColumn.type();
+	}
+
+	Iterator begin() const
+		/// Returns iterator pointing to the beginning of data storage vector.
+	{
+		return _pData->begin();
+	}
+
+	Iterator end() const
+		/// Returns iterator pointing to the end of data storage vector.
+	{
+		return _pData->end();
+	}
+
+private:
+	Column();
+
+	MetaColumn   _metaColumn;
+	ContainerPtr _pData;
+};
+
+
+template <typename C>
+inline void swap(Column<C>& c1, Column<C>& c2)
+{
+	c1.swap(c2);
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_Column_INCLUDED
+
diff --git a/base/poco/Data/include/Poco/Data/Connector.h b/base/poco/Data/include/Poco/Data/Connector.h
new file mode 100644
index 00000000000..ee922f4e0f8
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/Connector.h
@@ -0,0 +1,56 @@
+//
+// Connector.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  Connector
+//
+// Definition of the Connector class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_Connector_INCLUDED
+#define Data_Connector_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/SessionImpl.h"
+#include "Poco/AutoPtr.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API Connector
+	/// A Connector creates SessionImpl objects.
+	///
+	/// Every connector library (like the SQLite or the ODBC connector)
+	/// provides a subclass of this class, an instance of which is
+	/// registered with the SessionFactory.
+{
+public:
+	Connector();
+		/// Creates the Connector.
+
+	virtual ~Connector();
+		/// Destroys the Connector.
+
+	virtual const std::string& name() const = 0;
+		/// Returns the name associated with this connector.
+
+	virtual Poco::AutoPtr<SessionImpl> createSession(const std::string& connectionString,
+		std::size_t timeout = SessionImpl::LOGIN_TIMEOUT_DEFAULT) = 0;
+		/// Create a SessionImpl object and initialize it with the given connectionString.
+};
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_Connector_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/Constants.h b/base/poco/Data/include/Poco/Data/Constants.h
new file mode 100644
index 00000000000..574c09bb4ca
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/Constants.h
@@ -0,0 +1,36 @@
+//
+// Data.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  Constants
+//
+// Constant definitions for the Poco Data library.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_Constants_INCLUDED
+#define Data_Constants_INCLUDED
+
+
+#undef max
+#include <limits>
+#include <cstddef>
+
+
+namespace Poco {
+namespace Data {
+
+
+static const std::size_t POCO_DATA_INVALID_ROW = std::numeric_limits<std::size_t>::max();
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_Constants_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/Data.h b/base/poco/Data/include/Poco/Data/Data.h
new file mode 100644
index 00000000000..8a9e532e952
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/Data.h
@@ -0,0 +1,62 @@
+//
+// Data.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  Data
+//
+// Basic definitions for the Poco Data library.
+// This file must be the first file included by every other Data
+// header file.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_Data_INCLUDED
+#define Data_Data_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+//
+// The following block is the standard way of creating macros which make exporting
+// from a DLL simpler. All files within this DLL are compiled with the Data_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any project
+// that uses this DLL. This way any other project whose source files include this file see
+// Data_API functions as being imported from a DLL, wheras this DLL sees symbols
+// defined with this macro as being exported.
+//
+#if defined(_WIN32) && defined(POCO_DLL)
+	#if defined(Data_EXPORTS)
+		#define Data_API __declspec(dllexport)
+	#else
+		#define Data_API __declspec(dllimport)
+	#endif
+#endif
+
+
+#if !defined(Data_API)
+	#if !defined(POCO_NO_GCC_API_ATTRIBUTE) && defined (__GNUC__) && (__GNUC__ >= 4)
+		#define Data_API __attribute__ ((visibility ("default")))
+	#else
+		#define Data_API
+	#endif
+#endif
+
+
+//
+// Automatically link Data library.
+//
+#if defined(_MSC_VER)
+	#if !defined(POCO_NO_AUTOMATIC_LIBS) && !defined(Data_EXPORTS)
+		#pragma comment(lib, "PocoData" POCO_LIB_SUFFIX)
+	#endif
+#endif
+
+
+#endif // Data_Data_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/DataException.h b/base/poco/Data/include/Poco/Data/DataException.h
new file mode 100644
index 00000000000..cc976e2fac5
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/DataException.h
@@ -0,0 +1,50 @@
+//
+// DataException.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  DataException
+//
+// Definition of the DataException class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_DataException_INCLUDED
+#define Data_DataException_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+POCO_DECLARE_EXCEPTION(Data_API, DataException, Poco::IOException)
+POCO_DECLARE_EXCEPTION(Data_API, RowDataMissingException, DataException)
+POCO_DECLARE_EXCEPTION(Data_API, UnknownDataBaseException, DataException)
+POCO_DECLARE_EXCEPTION(Data_API, UnknownTypeException, DataException)
+POCO_DECLARE_EXCEPTION(Data_API, ExecutionException, DataException)
+POCO_DECLARE_EXCEPTION(Data_API, BindingException, DataException)
+POCO_DECLARE_EXCEPTION(Data_API, ExtractException, DataException)
+POCO_DECLARE_EXCEPTION(Data_API, LimitException, DataException)
+POCO_DECLARE_EXCEPTION(Data_API, NotSupportedException, DataException)
+POCO_DECLARE_EXCEPTION(Data_API, SessionUnavailableException, DataException)
+POCO_DECLARE_EXCEPTION(Data_API, SessionPoolExhaustedException, DataException)
+POCO_DECLARE_EXCEPTION(Data_API, SessionPoolExistsException, DataException)
+POCO_DECLARE_EXCEPTION(Data_API, NoDataException, DataException)
+POCO_DECLARE_EXCEPTION(Data_API, LengthExceededException, DataException)
+POCO_DECLARE_EXCEPTION(Data_API, ConnectionFailedException, DataException)
+POCO_DECLARE_EXCEPTION(Data_API, NotConnectedException, DataException)
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_DataException_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/Date.h b/base/poco/Data/include/Poco/Data/Date.h
new file mode 100644
index 00000000000..4ac234bb753
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/Date.h
@@ -0,0 +1,225 @@
+//
+// Date.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  Date
+//
+// Definition of the Date class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_Date_INCLUDED
+#define Data_Date_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Dynamic/VarHolder.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+class DateTime;
+
+namespace Dynamic {
+
+class Var;
+
+}
+
+namespace Data {
+
+
+class Time;
+
+
+class Data_API Date
+	/// Date class wraps a DateTime and exposes date related interface.
+	/// The purpose of this class is binding/extraction support for date fields.
+{
+public:
+	Date();
+		/// Creates the Date
+
+	Date(int year, int month, int day);
+		/// Creates the Date
+
+	Date(const DateTime& dt);
+		/// Creates the Date from DateTime
+
+	~Date();
+		/// Destroys the Date.
+
+	int year() const;
+		/// Returns the year.
+
+	int month() const;
+		/// Returns the month.
+
+	int day() const;
+		/// Returns the day.
+
+	void assign(int year, int month, int day);
+		/// Assigns date.
+
+	Date& operator = (const Date& d);
+		/// Assignment operator for Date.
+
+	Date& operator = (const DateTime& dt);
+		/// Assignment operator for DateTime.
+
+	Date& operator = (const Poco::Dynamic::Var& var);
+		/// Assignment operator for Var.
+
+	bool operator == (const Date& date) const;
+		/// Equality operator.
+
+	bool operator != (const Date& date) const;
+		/// Inequality operator.
+
+	bool operator < (const Date& date) const;
+		/// Less then operator.
+
+	bool operator > (const Date& date) const;
+		/// Greater then operator.
+
+private:
+	int _year;
+	int _month;
+	int _day;
+};
+
+
+//
+// inlines
+//
+inline int Date::year() const
+{
+	return _year;
+}
+
+
+inline int Date::month() const
+{
+	return _month;
+}
+
+
+inline int Date::day() const
+{
+	return _day;
+}
+
+
+inline Date& Date::operator = (const Date& d)
+{
+	assign(d.year(), d.month(), d.day());
+	return *this;
+}
+
+
+inline Date& Date::operator = (const DateTime& dt)
+{
+	assign(dt.year(), dt.month(), dt.day());
+	return *this;
+}
+
+
+inline bool Date::operator == (const Date& date) const
+{
+	return _year == date.year() &&
+		_month == date.month() &&
+		_day == date.day();
+}
+
+
+inline bool Date::operator != (const Date& date) const
+{
+	return !(*this == date);
+}
+
+
+inline bool Date::operator > (const Date& date) const
+{
+	return !(*this == date) && !(*this < date);
+}
+
+
+} } // namespace Poco::Data
+
+
+//
+// VarHolderImpl<Date>
+//
+
+
+namespace Poco {
+namespace Dynamic {
+
+
+template <>
+class VarHolderImpl<Poco::Data::Date>: public VarHolder
+{
+public:
+	VarHolderImpl(const Poco::Data::Date& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+	
+	const std::type_info& type() const
+	{
+		return typeid(Poco::Data::Date);
+	}
+
+	void convert(Poco::Timestamp& val) const
+	{
+		DateTime dt;
+		dt.assign(_val.year(), _val.month(), _val.day());
+		val = dt.timestamp();
+	}
+
+	void convert(Poco::DateTime& val) const
+	{
+		val.assign(_val.year(), _val.month(), _val.day());
+	}
+
+	void convert(Poco::LocalDateTime& val) const
+	{
+		val.assign(_val.year(), _val.month(), _val.day());
+	}
+
+	void convert(std::string& val) const
+	{
+		DateTime dt(_val.year(), _val.month(), _val.day());
+		val = DateTimeFormatter::format(dt, "%Y/%m/%d");
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+	
+	const Poco::Data::Date& value() const
+	{
+		return _val;
+	}
+
+private:
+	VarHolderImpl();
+	Poco::Data::Date _val;
+};
+
+
+} } // namespace Poco::Dynamic
+
+
+#endif // Data_Date_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/DynamicDateTime.h b/base/poco/Data/include/Poco/Data/DynamicDateTime.h
new file mode 100644
index 00000000000..0ed87305403
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/DynamicDateTime.h
@@ -0,0 +1,47 @@
+//
+// DynamicDateTime.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  DynamicDateTime
+//
+// Definition of the Date and Time cast operators for Poco::Dynamic::Var.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_DynamicDateTime_INCLUDED
+#define Data_DynamicDateTime_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/Date.h"
+#include "Poco/Data/Time.h"
+#include "Poco/Dynamic/Var.h"
+
+
+namespace Poco {
+namespace Data {
+
+class Date;
+class Time;
+
+} } // namespace Poco::Data
+
+
+namespace Poco {
+namespace Dynamic {
+
+
+template <> Data_API Var::operator Poco::Data::Date () const;
+template <> Data_API Var::operator Poco::Data::Time () const;
+
+
+} } // namespace Poco::Dynamic
+
+
+#endif // Data_DynamicDateTime_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/DynamicLOB.h b/base/poco/Data/include/Poco/Data/DynamicLOB.h
new file mode 100644
index 00000000000..1ed817d26e1
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/DynamicLOB.h
@@ -0,0 +1,45 @@
+//
+// DynamicLOB.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  DynamicLOB
+//
+// Definition of the Poco::Dynamic::Var LOB cast operators.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_DynamicLOB_INCLUDED
+#define Data_DynamicLOB_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/LOB.h"
+#include "Poco/Dynamic/Var.h"
+
+
+namespace Poco {
+namespace Data {
+
+template <typename T> class LOB;
+typedef LOB<unsigned char> BLOB;
+typedef LOB<char> CLOB;
+
+} } // namespace Poco::Data
+
+
+namespace Poco {
+namespace Dynamic {
+
+template <> Data_API Var::operator Poco::Data::CLOB () const;
+template <> Data_API Var::operator Poco::Data::BLOB () const;
+
+} } // namespace Poco::Dynamic
+
+
+#endif // Data_DynamicLOB_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/Extraction.h b/base/poco/Data/include/Poco/Data/Extraction.h
new file mode 100644
index 00000000000..7b98700e905
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/Extraction.h
@@ -0,0 +1,869 @@
+//
+// Extraction.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  Extraction
+//
+// Definition of the Extraction class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_Extraction_INCLUDED
+#define Data_Extraction_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/AbstractExtraction.h"
+#include "Poco/Data/Preparation.h"
+#include "Poco/Data/TypeHandler.h"
+#include "Poco/Data/Column.h"
+#include "Poco/Data/Position.h"
+#include "Poco/Data/DataException.h"
+#include <set>
+#include <vector>
+#include <list>
+#include <deque>
+#include <map>
+#include <cstddef>
+
+
+namespace Poco {
+namespace Data {
+
+
+template <class T>
+class Extraction: public AbstractExtraction
+	/// Concrete Data Type specific extraction of values from a query result set.
+{
+public:
+	typedef T                   ValType;
+	typedef SharedPtr<ValType>  ValPtr;
+	typedef Extraction<ValType> Type;
+	typedef SharedPtr<Type>     Ptr;
+
+	Extraction(T& result, const Position& pos = Position(0)):
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default(), 
+		_extracted(false),
+		_null(false)
+		/// Creates an Extraction object at specified position.
+		/// Uses an empty object T as default value.
+	{
+	}
+
+	Extraction(T& result, const T& def, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default(def), 
+		_extracted(false),
+		_null(false)
+		/// Creates an Extraction object at specified position.
+		/// Uses the provided def object as default value.
+	{
+	}
+
+	~Extraction()
+		/// Destroys the Extraction object.
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return _extracted ? 1u : 0;
+	}
+
+	std::size_t numOfRowsAllowed() const
+	{
+		return 1u;
+	}
+
+	bool isNull(std::size_t row = 0) const
+	{
+		return _null;
+	}
+
+	std::size_t extract(std::size_t pos)
+	{
+		if (_extracted) throw ExtractException("value already extracted");
+		_extracted = true;
+		AbstractExtractor::Ptr pExt = getExtractor();
+		TypeHandler<T>::extract(pos, _rResult, _default, pExt);
+		_null = isValueNull<T>(_rResult, pExt->isNull(pos));
+		
+		return 1u;
+	}
+
+	void reset()
+	{
+		_extracted = false;
+	}
+
+	bool canExtract() const
+	{
+		return !_extracted;
+	}
+
+	AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
+	{
+		return new Preparation<T>(pPrep, pos, _rResult);
+	}
+
+private:
+	T&   _rResult;
+	T    _default;
+	bool _extracted;
+	bool _null;
+};
+
+
+template <class T>
+class Extraction<std::vector<T> >: public AbstractExtraction
+	/// Vector Data Type specialization for extraction of values from a query result set.
+{
+public:
+	
+	typedef std::vector<T>      ValType;
+	typedef SharedPtr<ValType>  ValPtr;
+	typedef Extraction<ValType> Type;
+	typedef SharedPtr<Type>     Ptr;
+
+	Extraction(std::vector<T>& result, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default()
+	{
+		_rResult.clear();
+	}
+
+	Extraction(std::vector<T>& result, const T& def, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default(def)
+	{
+		_rResult.clear();
+	}
+
+	virtual ~Extraction()
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return static_cast<std::size_t>(_rResult.size());
+	}
+
+	std::size_t numOfRowsAllowed() const
+	{
+		return getLimit();
+	}
+
+	bool isNull(std::size_t row) const
+	{
+		try
+		{
+			return _nulls.at(row);
+		}
+		catch (std::out_of_range& ex)
+		{ 
+			throw RangeException(ex.what()); 
+		}
+	}
+
+	std::size_t extract(std::size_t pos)
+	{
+		AbstractExtractor::Ptr pExt = getExtractor();
+		_rResult.push_back(_default);
+		TypeHandler<T>::extract(pos, _rResult.back(), _default, pExt);
+		_nulls.push_back(isValueNull(_rResult.back(), pExt->isNull(pos)));
+		return 1u;
+	}
+
+	AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
+	{
+		return new Preparation<T>(pPrep, pos, _default);
+	}
+
+	void reset()
+	{
+		_nulls.clear();
+	}
+
+protected:
+
+	const std::vector<T>& result() const
+	{
+		return _rResult;
+	}
+
+private:
+	std::vector<T>&  _rResult;
+	T                _default;
+	std::deque<bool> _nulls;
+};
+
+
+template <>
+class Extraction<std::vector<bool> >: public AbstractExtraction
+	/// Vector bool specialization for extraction of values from a query result set.
+{
+public:
+	typedef std::vector<bool>   ValType;
+	typedef SharedPtr<ValType>  ValPtr;
+	typedef Extraction<ValType> Type;
+	typedef SharedPtr<Type>     Ptr;
+
+	Extraction(std::vector<bool>& result, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default()
+	{
+		_rResult.clear();
+	}
+
+	Extraction(std::vector<bool>& result, const bool& def, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default(def)
+	{
+		_rResult.clear();
+	}
+
+	virtual ~Extraction()
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<bool>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return static_cast<std::size_t>(_rResult.size());
+	}
+
+	std::size_t numOfRowsAllowed() const
+	{
+		return getLimit();
+	}
+
+	bool isNull(std::size_t row) const
+	{
+		try
+		{
+			return _nulls.at(row);
+		}
+		catch (std::out_of_range& ex)
+		{ 
+			throw RangeException(ex.what()); 
+		}
+	}
+
+	std::size_t extract(std::size_t pos)
+	{
+		AbstractExtractor::Ptr pExt = getExtractor();
+
+		bool tmp = _default;
+		TypeHandler<bool>::extract(pos, tmp, _default, pExt);
+		_rResult.push_back(tmp);
+		_nulls.push_back(pExt->isNull(pos));
+		return 1u;
+	}
+
+	AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
+	{
+		return new Preparation<bool>(pPrep, pos, _default);
+	}
+
+	void reset()
+	{
+		_nulls.clear();
+	}
+
+protected:
+
+	const std::vector<bool>& result() const
+	{
+		return _rResult;
+	}
+
+private:
+	std::vector<bool>& _rResult;
+	bool               _default;
+	std::deque<bool>   _nulls;
+};
+
+
+template <class T>
+class Extraction<std::list<T> >: public AbstractExtraction
+	/// List Data Type specialization for extraction of values from a query result set.
+{
+public:
+	typedef std::list<T>        ValType;
+	typedef SharedPtr<ValType>  ValPtr;
+	typedef Extraction<ValType> Type;
+	typedef SharedPtr<Type>     Ptr;
+
+	Extraction(std::list<T>& result, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default()
+	{
+		_rResult.clear();
+	}
+
+	Extraction(std::list<T>& result, const T& def, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default(def)
+	{
+		_rResult.clear();
+	}
+
+	virtual ~Extraction()
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return _rResult.size();
+	}
+
+	std::size_t numOfRowsAllowed() const
+	{
+		return getLimit();
+	}
+
+	bool isNull(std::size_t row) const
+	{
+		try
+		{
+			return _nulls.at(row);
+		}
+		catch (std::out_of_range& ex)
+		{ 
+			throw RangeException(ex.what()); 
+		}
+	}
+
+	std::size_t extract(std::size_t pos)
+	{
+		AbstractExtractor::Ptr pExt = getExtractor();
+		_rResult.push_back(_default);
+		TypeHandler<T>::extract(pos, _rResult.back(), _default, pExt);
+		_nulls.push_back(isValueNull(_rResult.back(), pExt->isNull(pos)));
+		return 1u;
+	}
+
+	AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
+	{
+		return new Preparation<T>(pPrep, pos, _default);
+	}
+
+	void reset()
+	{
+		_nulls.clear();
+	}
+
+protected:
+
+	const std::list<T>& result() const
+	{
+		return _rResult;
+	}
+
+private:
+	std::list<T>&    _rResult;
+	T                _default;
+	std::deque<bool> _nulls;
+};
+
+
+template <class T>
+class Extraction<std::deque<T> >: public AbstractExtraction
+	/// Deque Data Type specialization for extraction of values from a query result set.
+{
+public:
+	typedef std::deque<T>       ValType;
+	typedef SharedPtr<ValType>  ValPtr;
+	typedef Extraction<ValType> Type;
+	typedef SharedPtr<Type>     Ptr;
+
+	Extraction(std::deque<T>& result, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default()
+	{
+		_rResult.clear();
+	}
+
+	Extraction(std::deque<T>& result, const T& def, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default(def)
+	{
+		_rResult.clear();
+	}
+
+	virtual ~Extraction()
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return _rResult.size();
+	}
+
+	std::size_t numOfRowsAllowed() const
+	{
+		return getLimit();
+	}
+
+	bool isNull(std::size_t row) const
+	{
+		try
+		{
+			return _nulls.at(row);
+		}
+		catch (std::out_of_range& ex)
+		{ 
+			throw RangeException(ex.what()); 
+		}
+	}
+
+	std::size_t extract(std::size_t pos)
+	{
+		AbstractExtractor::Ptr pExt = getExtractor();
+		_rResult.push_back(_default);
+		TypeHandler<T>::extract(pos, _rResult.back(), _default, pExt);
+		_nulls.push_back(isValueNull(_rResult.back(), pExt->isNull(pos)));
+		return 1u;
+	}
+
+	AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
+	{
+		return new Preparation<T>(pPrep, pos, _default);
+	}
+
+	void reset()
+	{
+		_nulls.clear();
+	}
+
+protected:
+
+	const std::deque<T>& result() const
+	{
+		return _rResult;
+	}
+
+private:
+	std::deque<T>&   _rResult;
+	T                _default;
+	std::deque<bool> _nulls;
+};
+
+
+template <class C>
+class InternalExtraction: public Extraction<C>
+	/// Container Data Type specialization extension for extraction of values from a query result set.
+	///
+	/// This class is intended for PocoData internal use - it is used by StatementImpl 
+	/// to automaticaly create internal Extraction in cases when statement returns data and no external storage
+	/// was supplied. It is later used by RecordSet to retrieve the fetched data after statement execution.
+	/// It takes ownership of the Column pointer supplied as constructor argument. Column object, in turn
+	/// owns the data container pointer.
+	///
+	/// InternalExtraction objects can not be copied or assigned.
+{
+public:
+	typedef typename C::value_type ValType;
+	typedef SharedPtr<ValType>     ValPtr;
+	typedef Extraction<ValType>    Type;
+	typedef SharedPtr<Type>        Ptr;
+
+
+	InternalExtraction(C& result, Column<C>* pColumn, const Position& pos = Position(0)): 
+		Extraction<C>(result, ValType(), pos), 
+		_pColumn(pColumn)
+		/// Creates InternalExtraction.
+	{
+	}
+
+	~InternalExtraction()
+		/// Destroys InternalExtraction.
+	{
+		delete _pColumn;
+	}
+
+	void reset()
+	{
+		Extraction<C>::reset();
+		_pColumn->reset();
+	}	
+
+	const ValType& value(int index) const
+	{
+		try
+		{ 
+			return Extraction<C>::result().at(index); 
+		}
+		catch (std::out_of_range& ex)
+		{ 
+			throw RangeException(ex.what()); 
+		}
+	}
+
+	bool isNull(std::size_t row) const
+	{
+		return Extraction<C>::isNull(row);
+	}
+
+	const Column<C>& column() const
+	{
+		return *_pColumn;
+	}
+
+private:
+	InternalExtraction();
+	InternalExtraction(const InternalExtraction&);
+	InternalExtraction& operator = (const InternalExtraction&);
+
+	Column<C>* _pColumn;
+};
+
+
+template <class T>
+class Extraction<std::set<T> >: public AbstractExtraction
+	/// Set Data Type specialization for extraction of values from a query result set.
+{
+public:
+	typedef std::set<T>                ValType;
+	typedef SharedPtr<ValType>         ValPtr;
+	typedef Extraction<ValType>        Type;
+	typedef SharedPtr<Type>            Ptr;
+	typedef typename ValType::iterator Iterator;
+
+	Extraction(std::set<T>& result, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default()
+	{
+		_rResult.clear();
+	}
+
+	Extraction(std::set<T>& result, const T& def, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default(def)
+	{
+		_rResult.clear();
+	}
+
+	~Extraction()
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return static_cast<std::size_t>(_rResult.size());
+	}
+
+	std::size_t numOfRowsAllowed() const
+	{
+		return getLimit();
+	}
+
+	std::size_t extract(std::size_t pos)
+	{
+		T tmp;
+		TypeHandler<T>::extract(pos, tmp, _default, getExtractor());
+		_rResult.insert(tmp);
+		return 1u;
+	}
+
+	AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
+	{
+		return new Preparation<T>(pPrep, pos, _default);
+	}
+
+private:
+	std::set<T>& _rResult;
+	T            _default;
+};
+
+
+template <class T>
+class Extraction<std::multiset<T> >: public AbstractExtraction
+	/// Multiset Data Type specialization for extraction of values from a query result set.
+{
+public:
+	typedef std::multiset<T>    ValType;
+	typedef SharedPtr<ValType>  ValPtr;
+	typedef Extraction<ValType> Type;
+	typedef SharedPtr<Type>     Ptr;
+
+	Extraction(std::multiset<T>& result, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default()
+	{
+		_rResult.clear();
+	}
+
+	Extraction(std::multiset<T>& result, const T& def, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default(def)
+	{
+		_rResult.clear();
+	}
+
+	~Extraction()
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<T>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return static_cast<std::size_t>(_rResult.size());
+	}
+
+	std::size_t numOfRowsAllowed() const
+	{
+		return getLimit();
+	}
+
+	std::size_t extract(std::size_t pos)
+	{
+		T tmp;
+		TypeHandler<T>::extract(pos, tmp, _default, getExtractor());
+		_rResult.insert(tmp);
+		return 1u;
+	}
+
+	AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
+	{
+		return new Preparation<T>(pPrep, pos, _default);
+	}
+
+private:
+	std::multiset<T>& _rResult;
+	T                 _default;
+};
+
+
+template <class K, class V>
+class Extraction<std::map<K, V> >: public AbstractExtraction
+	/// Map Data Type specialization for extraction of values from a query result set.
+{
+public:
+	typedef std::map<K, V>      ValType;
+	typedef SharedPtr<ValType>  ValPtr;
+	typedef Extraction<ValType> Type;
+	typedef SharedPtr<Type>     Ptr;
+
+	Extraction(std::map<K, V>& result, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default()
+	{
+		_rResult.clear();
+	}
+
+	Extraction(std::map<K, V>& result, const V& def, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default(def)
+	{
+		_rResult.clear();
+	}
+
+	~Extraction()
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<V>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return static_cast<std::size_t>(_rResult.size());
+	}
+
+	std::size_t numOfRowsAllowed() const
+	{
+		return getLimit();
+	}
+
+	std::size_t extract(std::size_t pos)
+	{
+		V tmp;
+		TypeHandler<V>::extract(pos, tmp, _default, getExtractor());
+		_rResult.insert(std::make_pair(tmp(), tmp));
+		return 1u;
+	}
+
+	AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
+	{
+		return new Preparation<V>(pPrep, pos, _default);
+	}
+
+private:
+	std::map<K, V>& _rResult;
+	V               _default;
+};
+
+
+template <class K, class V>
+class Extraction<std::multimap<K, V> >: public AbstractExtraction
+	/// Multimap Data Type specialization for extraction of values from a query result set.
+{
+public:
+	typedef std::multimap<K, V> ValType;
+	typedef SharedPtr<ValType>  ValPtr;
+	typedef Extraction<ValType> Type;
+	typedef SharedPtr<Type>     Ptr;
+
+	Extraction(std::multimap<K, V>& result, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default()
+	{
+		_rResult.clear();
+	}
+
+	Extraction(std::multimap<K, V>& result, const V& def, const Position& pos = Position(0)): 
+		AbstractExtraction(Limit::LIMIT_UNLIMITED, pos.value()),
+		_rResult(result), 
+		_default(def)
+	{
+		_rResult.clear();
+	}
+
+	~Extraction()
+	{
+	}
+
+	std::size_t numOfColumnsHandled() const
+	{
+		return TypeHandler<V>::size();
+	}
+
+	std::size_t numOfRowsHandled() const
+	{
+		return static_cast<std::size_t>(_rResult.size());
+	}
+
+	std::size_t numOfRowsAllowed() const
+	{
+		return getLimit();
+	}
+
+	std::size_t extract(std::size_t pos)
+	{
+		V tmp;
+		TypeHandler<V>::extract(pos, tmp, _default, getExtractor());
+		_rResult.insert(std::make_pair(tmp(), tmp));
+		return 1u;
+	}
+
+	AbstractPreparation::Ptr createPreparation(AbstractPreparator::Ptr& pPrep, std::size_t pos)
+	{
+		return new Preparation<V>(pPrep, pos, _default);
+	}
+
+private:
+	std::multimap<K, V>& _rResult;
+	V                    _default;
+};
+
+
+namespace Keywords {
+
+
+template <typename T> 
+inline AbstractExtraction::Ptr into(T& t)
+	/// Convenience function to allow for a more compact creation of an extraction object.
+{
+	return new Extraction<T>(t);
+}
+
+
+template <typename T> 
+inline AbstractExtraction::Ptr into(T& t, const Position& pos)
+	/// Convenience function to allow for a more compact creation of an extraction object
+	/// with multiple recordset support.
+{
+	return new Extraction<T>(t, pos);
+}
+
+
+template <typename T> 
+inline AbstractExtraction::Ptr into(T& t, const Position& pos, const T& def)
+	/// Convenience function to allow for a more compact creation of an extraction object 
+	/// with multiple recordset support and the given default
+{
+	return new Extraction<T>(t, def, pos);
+}
+
+
+inline AbstractExtractionVecVec& into(AbstractExtractionVecVec& evv)
+	/// Convenience dummy function (for syntax purposes only).
+{
+	return evv;
+}
+
+
+inline AbstractExtractionVec& into(AbstractExtractionVec& ev)
+	/// Convenience dummy function (for syntax purposes only).
+{
+	return ev;
+}
+
+
+} // namespace Keywords
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_Extraction_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/LOB.h b/base/poco/Data/include/Poco/Data/LOB.h
new file mode 100644
index 00000000000..99c1e7b71f4
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/LOB.h
@@ -0,0 +1,309 @@
+//
+// LOB.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  LOB
+//
+// Definition of the LOB class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_LOB_INCLUDED
+#define Data_LOB_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Dynamic/VarHolder.h"
+#include "Poco/Exception.h"
+#include <vector>
+#include <algorithm>
+
+
+namespace Poco {
+namespace Data {
+
+
+template <typename T>
+class LOB
+	/// Representation of a Large OBject.
+	///
+	/// A LOB can hold arbitrary data.
+	/// The maximum size depends on the underlying database.
+	///
+	/// The LOBInputStream and LOBOutputStream classes provide
+	/// a convenient way to access the data in a LOB.
+{
+public:
+	typedef typename std::vector<T>::const_iterator Iterator;
+	typedef T ValueType;
+	typedef typename std::vector<T> Container;
+	typedef Poco::SharedPtr<Container> ContentPtr;
+
+	LOB(): _pContent(new std::vector<T>())
+		/// Creates an empty LOB.
+	{
+	}
+
+	LOB(const std::vector<T>& content):
+		_pContent(new std::vector<T>(content))
+		/// Creates the LOB, content is deep-copied.
+	{
+	}
+
+	LOB(const T* const pContent, std::size_t size):
+		_pContent(new std::vector<T>(pContent, pContent + size))
+		/// Creates the LOB by deep-copying pContent.
+	{
+	}
+
+	LOB(const std::basic_string<T>& content):
+		_pContent(new std::vector<T>(content.begin(), content.end()))
+		/// Creates a LOB from a string.
+	{
+	}
+
+	LOB(const LOB& other): _pContent(other._pContent)
+		/// Creates a LOB by copying another one.
+	{
+	}
+
+	~LOB()
+		/// Destroys the LOB.
+	{
+	}
+
+	LOB& operator = (const LOB& other)
+		/// Assignment operator.
+	{
+		LOB tmp(other);
+		swap(tmp);
+		return *this;
+	}
+
+	bool operator == (const LOB& other) const
+		/// Compares for equality LOB by value.
+	{
+		return *_pContent == *other._pContent;
+	}
+
+	bool operator != (const LOB& other) const
+		/// Compares for inequality LOB by value.
+	{
+		return *_pContent != *other._pContent;
+	}
+
+	void swap(LOB& other)
+		/// Swaps the LOB with another one.
+	{
+		using std::swap;
+		swap(_pContent, other._pContent);
+	}
+
+	const std::vector<T>& content() const
+		/// Returns the content.
+	{
+		return *_pContent;
+	}
+
+	const T* rawContent() const
+		/// Returns the raw content.
+		///
+		/// If the LOB is empty, returns NULL.
+	{
+		if (_pContent->empty())
+			return 0;
+		else
+			return &(*_pContent)[0];
+	}
+
+	void assignVal(std::size_t count, const T& val)
+		/// Assigns raw content to internal storage.
+	{
+		ContentPtr tmp = new Container(count, val);
+		_pContent.swap(tmp);
+	}
+
+	void assignRaw(const T* ptr, std::size_t count)
+		/// Assigns raw content to internal storage.
+	{
+		poco_assert_dbg (ptr);
+		LOB tmp(ptr, count);
+		swap(tmp);
+	}
+
+	void appendRaw(const T* pChar, std::size_t count)
+		/// Assigns raw content to internal storage.
+	{
+		poco_assert_dbg (pChar);
+		_pContent->insert(_pContent->end(), pChar, pChar+count);
+	}
+
+	void clear(bool doCompact = false)
+		/// Clears the content of the blob.
+		/// If doCompact is true, trims the excess capacity.
+	{
+		_pContent->clear();
+		if (doCompact) compact();
+	}
+
+	void compact()
+		/// Trims the internal storage excess capacity.
+	{
+		std::vector<T>(*_pContent).swap(*_pContent);
+	}
+
+	Iterator begin() const
+	{
+		return _pContent->begin();
+	}
+
+	Iterator end() const
+	{
+		return _pContent->end();
+	}
+
+	std::size_t size() const
+		/// Returns the size of the LOB in bytes.
+	{
+		return static_cast<std::size_t>(_pContent->size());
+	}
+
+private:
+	ContentPtr _pContent;
+};
+
+
+typedef LOB<unsigned char> BLOB;
+typedef LOB<char> CLOB;
+
+
+//
+// inlines
+//
+
+template <typename T>
+inline void swap(LOB<T>& b1, LOB<T>& b2)
+{
+	b1.swap(b2);
+}
+
+
+} } // namespace Poco::Data
+
+
+namespace std
+{
+	template<>
+	inline void swap<Poco::Data::BLOB>(Poco::Data::BLOB& b1, 
+		Poco::Data::BLOB& b2)
+		/// Full template specalization of std:::swap for BLOB
+	{
+		b1.swap(b2);
+	}
+
+	template<>
+	inline void swap<Poco::Data::CLOB>(Poco::Data::CLOB& c1, 
+		Poco::Data::CLOB& c2)
+		/// Full template specalization of std:::swap for CLOB
+	{
+		c1.swap(c2);
+	}
+}
+
+
+//
+// VarHolderImpl<LOB>
+//
+
+
+namespace Poco {
+namespace Dynamic {
+
+
+template <>
+class VarHolderImpl<Poco::Data::BLOB>: public VarHolder
+{
+public:
+	VarHolderImpl(const Poco::Data::BLOB& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+	
+	const std::type_info& type() const
+	{
+		return typeid(Poco::Data::BLOB);
+	}
+
+	void convert(std::string& val) const
+	{
+		val.assign(_val.begin(), _val.end());
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+	
+	const Poco::Data::BLOB& value() const
+	{
+		return _val;
+	}
+
+private:
+	VarHolderImpl();
+	Poco::Data::BLOB _val;
+};
+
+
+template <>
+class VarHolderImpl<Poco::Data::CLOB>: public VarHolder
+{
+public:
+	VarHolderImpl(const Poco::Data::CLOB& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+	
+	const std::type_info& type() const
+	{
+		return typeid(Poco::Data::CLOB);
+	}
+
+	void convert(std::string& val) const
+	{
+		val.assign(_val.begin(), _val.end());
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+	
+	const Poco::Data::CLOB& value() const
+	{
+		return _val;
+	}
+
+private:
+	VarHolderImpl();
+	Poco::Data::CLOB _val;
+};
+
+
+} } // namespace Poco::Dynamic
+
+
+#endif // Data_LOB_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/LOBStream.h b/base/poco/Data/include/Poco/Data/LOBStream.h
new file mode 100644
index 00000000000..d363457c2fb
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/LOBStream.h
@@ -0,0 +1,150 @@
+//
+// LOBStream.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  LOBStream
+//
+// Definition of the LOBStream class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_LOBStream_INCLUDED
+#define Data_LOBStream_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include "Poco/Data/LOB.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+namespace Data {
+
+
+template <typename T>
+class LOBStreamBuf: public BasicUnbufferedStreamBuf<T, std::char_traits<T> >
+	/// This is the streambuf class used for reading from and writing to a LOB.
+{
+public:	
+	LOBStreamBuf(LOB<T>& lob): _lob(lob), _it(_lob.begin())
+		/// Creates LOBStreamBuf.
+	{
+	}
+
+
+	~LOBStreamBuf()
+		/// Destroys LOBStreamBuf.
+	{
+	}
+
+protected:
+	typedef std::char_traits<T> TraitsType;
+	typedef BasicUnbufferedStreamBuf<T, TraitsType> BaseType;
+
+	typename BaseType::int_type readFromDevice()
+	{
+		if (_it != _lob.end())
+			return BaseType::charToInt(*_it++);
+		else
+			return -1;
+	}
+
+	typename BaseType::int_type writeToDevice(T c)
+	{
+		_lob.appendRaw(&c, 1);
+		return 1;
+	}
+
+private:
+	LOB<T>& _lob;
+	typename LOB<T>::Iterator _it;
+};
+
+
+template <typename T>
+class LOBIOS: public virtual std::ios
+	/// The base class for LOBInputStream and
+	/// LOBOutputStream.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	LOBIOS(LOB<T>& lob, openmode mode): _buf(lob)
+		/// Creates the LOBIOS with the given LOB.
+	{
+		poco_ios_init(&_buf);
+	}
+
+	~LOBIOS()
+		/// Destroys the LOBIOS.
+	{
+	}
+
+	LOBStreamBuf<T>* rdbuf()
+		/// Returns a pointer to the internal LOBStreamBuf.
+	{
+		return &_buf;
+	}
+
+protected:
+	LOBStreamBuf<T> _buf;
+};
+
+
+template <typename T>
+class LOBOutputStream: public LOBIOS<T>, public std::basic_ostream<T, std::char_traits<T> >
+	/// An output stream for writing to a LOB.
+{
+public:
+	LOBOutputStream(LOB<T>& lob):
+		LOBIOS<T>(lob, std::ios::out),
+		std::ostream(LOBIOS<T>::rdbuf())
+		/// Creates the LOBOutputStream with the given LOB.
+	{
+	}
+
+	~LOBOutputStream()
+		/// Destroys the LOBOutputStream.
+	{
+	}
+};
+
+
+template <typename T>
+class LOBInputStream: public LOBIOS<T>, public std::basic_istream<T, std::char_traits<T> >
+	/// An input stream for reading from a LOB.
+{
+public:
+	LOBInputStream(LOB<T>& lob):
+		LOBIOS<T>(lob, std::ios::in),
+		std::istream(LOBIOS<T>::rdbuf())
+		/// Creates the LOBInputStream with the given LOB.
+	{
+	}
+
+	~LOBInputStream()
+		/// Destroys the LOBInputStream.
+	{
+	}
+};
+
+
+typedef LOBOutputStream<unsigned char> BLOBOutputStream;
+typedef LOBOutputStream<char> CLOBOutputStream;
+
+typedef LOBInputStream<unsigned char> BLOBInputStream;
+typedef LOBInputStream<char> CLOBInputStream;
+
+} } // namespace Poco::Data
+
+
+#endif // Data_LOBStream_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/Limit.h b/base/poco/Data/include/Poco/Data/Limit.h
new file mode 100644
index 00000000000..f45ec3e98b0
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/Limit.h
@@ -0,0 +1,113 @@
+//
+// Limit.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  Limit
+//
+// Definition of the Limit class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_Limit_INCLUDED
+#define Data_Limit_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API Limit
+	/// Limit stores information how many rows a query should return.
+{
+public:
+	typedef Poco::UInt32 SizeT;
+
+	enum Type
+	{
+		LIMIT_UNLIMITED = ~((SizeT) 0)
+	};
+	
+	Limit(SizeT value, bool hardLimit = false, bool isLowerLimit = false);
+		/// Creates the Limit. 
+		///
+		/// Value contains the upper row hint, if hardLimit is set to true, the limit acts as a hard
+		/// border, ie. every query must return exactly value rows, returning more than value objects will throw an exception!
+		/// LowerLimits always act as hard-limits!
+		///
+		/// A value of LIMIT_UNLIMITED disables the limit.
+
+	~Limit();
+		/// Destroys the Limit.
+
+	SizeT value() const;
+		/// Returns the value of the limit
+
+	bool isHardLimit() const;
+		/// Returns true if the limit is a hard limit.
+
+	bool isLowerLimit() const;
+		/// Returns true if the limit is a lower limit, otherwise it is an upperLimit
+
+	bool operator == (const Limit& other) const;
+		/// Equality operator.
+
+	bool operator != (const Limit& other) const;
+		/// Inequality operator.
+
+private:
+	SizeT _value;
+	bool  _hardLimit;
+	bool  _isLowerLimit;
+};
+
+
+//
+// inlines
+//
+inline Poco::UInt32 Limit::value() const
+{
+	return _value;
+}
+
+
+inline bool Limit::isHardLimit() const
+{
+	return _hardLimit;
+}
+
+
+inline bool Limit::isLowerLimit() const
+{
+	return _isLowerLimit;
+}
+
+
+inline bool Limit::operator == (const Limit& other) const
+{
+	return other._value == _value &&
+		other._hardLimit == _hardLimit &&
+		other._isLowerLimit == _isLowerLimit;
+}
+
+
+inline bool Limit::operator != (const Limit& other) const
+{
+	return other._value != _value ||
+		other._hardLimit != _hardLimit ||
+		other._isLowerLimit != _isLowerLimit;
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_Limit_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/MetaColumn.h b/base/poco/Data/include/Poco/Data/MetaColumn.h
new file mode 100644
index 00000000000..65410a07dc9
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/MetaColumn.h
@@ -0,0 +1,188 @@
+//
+// MetaColumn.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  MetaColumn
+//
+// Definition of the MetaColumn class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_MetaColumn_INCLUDED
+#define Data_MetaColumn_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include <cstddef>
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API MetaColumn
+	/// MetaColumn class contains column metadata information.
+{
+public:
+	enum ColumnDataType
+	{
+		FDT_BOOL,
+		FDT_INT8,
+		FDT_UINT8,
+		FDT_INT16,
+		FDT_UINT16,
+		FDT_INT32,
+		FDT_UINT32,
+		FDT_INT64,
+		FDT_UINT64,
+		FDT_FLOAT,
+		FDT_DOUBLE,
+		FDT_STRING,
+		FDT_WSTRING,
+		FDT_BLOB,
+		FDT_CLOB,
+		FDT_DATE,
+		FDT_TIME,
+		FDT_TIMESTAMP,
+		FDT_UNKNOWN
+	};
+
+	MetaColumn();
+		/// Creates the MetaColumn.
+
+	explicit MetaColumn(std::size_t position,
+		const std::string& name = "",
+		ColumnDataType type = FDT_UNKNOWN,
+		std::size_t length = 0,
+		std::size_t precision = 0,
+		bool nullable = false);
+		/// Creates the MetaColumn.
+
+	virtual ~MetaColumn();
+		/// Destroys the MetaColumn.
+
+	const std::string& name() const;
+		/// Returns column name.
+
+	std::size_t length() const;
+		/// Returns column maximum length.
+
+	std::size_t precision() const;
+		/// Returns column precision.
+		/// Valid for floating point fields only
+		/// (zero for other data types).
+
+	std::size_t position() const;
+		/// Returns column position.
+
+	ColumnDataType type() const;
+		/// Returns column type.
+
+	bool isNullable() const;
+		/// Returns true if column allows null values, false otherwise.
+
+protected:
+	void setName(const std::string& name);
+		/// Sets the column name.
+
+	void setLength(std::size_t length);
+		/// Sets the column length.
+
+	void setPrecision(std::size_t precision);
+		/// Sets the column precision.
+
+	void setType(ColumnDataType type);
+		/// Sets the column data type.
+
+	void setNullable(bool nullable);
+		/// Sets the column nullability.
+
+private:
+	std::string     _name;
+	std::size_t     _length;
+	std::size_t     _precision;
+	std::size_t     _position;
+	ColumnDataType  _type;
+	bool            _nullable;
+};
+
+
+///
+/// inlines
+///
+inline const std::string& MetaColumn::name() const
+{
+	return _name;
+}
+
+
+inline std::size_t MetaColumn::length() const
+{
+	return _length;
+}
+
+
+inline std::size_t MetaColumn::precision() const
+{
+	return _precision;
+}
+
+
+inline std::size_t MetaColumn::position() const
+{
+	return _position;
+}
+
+
+inline MetaColumn::ColumnDataType MetaColumn::type() const
+{
+	return _type;
+}
+
+
+inline bool MetaColumn::isNullable() const
+{
+	return _nullable;
+}
+
+
+inline void MetaColumn::setName(const std::string& name)
+{
+	_name = name;
+}
+
+
+inline void MetaColumn::setLength(std::size_t length)
+{
+	_length = length;
+}
+
+
+inline void MetaColumn::setPrecision(std::size_t precision)
+{
+	_precision = precision;
+}
+
+
+inline void MetaColumn::setType(ColumnDataType type)
+{
+	_type = type;
+}
+
+
+inline void MetaColumn::setNullable(bool nullable)
+{
+	_nullable = nullable;
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_MetaColumn_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/PooledSessionHolder.h b/base/poco/Data/include/Poco/Data/PooledSessionHolder.h
new file mode 100644
index 00000000000..8924589fbef
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/PooledSessionHolder.h
@@ -0,0 +1,99 @@
+//
+// PooledSessionHolder.h
+//
+// Library: Data
+// Package: SessionPooling
+// Module:  PooledSessionHolder
+//
+// Definition of the PooledSessionHolder class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_PooledSessionHolder_INCLUDED
+#define Data_PooledSessionHolder_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/SessionImpl.h"
+#include "Poco/AutoPtr.h"
+#include "Poco/Timestamp.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+class SessionPool;
+
+
+class Data_API PooledSessionHolder: public Poco::RefCountedObject
+	/// This class is used by SessionPool to manage SessionImpl objects.
+{
+public:
+	PooledSessionHolder(SessionPool& owner, SessionImpl* pSessionImpl);
+		/// Creates the PooledSessionHolder.
+
+	~PooledSessionHolder();
+		/// Destroys the PooledSessionHolder.
+
+	SessionImpl* session();
+		/// Returns a pointer to the SessionImpl.
+
+	SessionPool& owner();
+		/// Returns a reference to the SessionHolder's owner.
+
+	void access();
+		/// Updates the last access timestamp.
+
+	int idle() const;
+		/// Returns the number of seconds the session has not been used.
+
+private:
+	SessionPool& _owner;
+	Poco::AutoPtr<SessionImpl> _pImpl;
+	Poco::Timestamp _lastUsed;
+	mutable Poco::FastMutex _mutex;
+};
+
+
+//
+// inlines
+//
+inline SessionImpl* PooledSessionHolder::session()
+{
+	return _pImpl;
+}
+
+
+inline SessionPool& PooledSessionHolder::owner()
+{
+	return _owner;
+}
+
+
+inline void PooledSessionHolder::access()
+{
+	Poco::FastMutex::ScopedLock lock(_mutex);
+	
+	_lastUsed.update();
+}
+
+
+inline int PooledSessionHolder::idle() const
+{
+	Poco::FastMutex::ScopedLock lock(_mutex);
+
+	return (int) (_lastUsed.elapsed()/Poco::Timestamp::resolution());
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_PooledSessionHolder_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/PooledSessionImpl.h b/base/poco/Data/include/Poco/Data/PooledSessionImpl.h
new file mode 100644
index 00000000000..1d11028eec6
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/PooledSessionImpl.h
@@ -0,0 +1,97 @@
+//
+// PooledSessionImpl.h
+//
+// Library: Data
+// Package: SessionPooling
+// Module:  PooledSessionImpl
+//
+// Definition of the PooledSessionImpl class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_PooledSessionImpl_INCLUDED
+#define Data_PooledSessionImpl_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/SessionImpl.h"
+#include "Poco/Data/PooledSessionHolder.h"
+#include "Poco/AutoPtr.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+class SessionPool;
+
+
+class Data_API PooledSessionImpl: public SessionImpl
+	/// PooledSessionImpl is a decorator created by
+	/// SessionPool that adds session pool
+	/// management to SessionImpl objects.
+{
+public:
+	PooledSessionImpl(PooledSessionHolder* pHolder);
+		/// Creates the PooledSessionImpl.
+
+	~PooledSessionImpl();
+		/// Destroys the PooledSessionImpl.
+
+	// SessionImpl
+	StatementImpl* createStatementImpl();
+	void begin();
+	void commit();
+	void rollback();
+	void open(const std::string& connect = "");
+	void close();
+	bool isConnected();
+	void setConnectionTimeout(std::size_t timeout);
+	std::size_t getConnectionTimeout();
+	bool canTransact();
+	bool isTransaction();
+	void setTransactionIsolation(Poco::UInt32);
+	Poco::UInt32 getTransactionIsolation();
+	bool hasTransactionIsolation(Poco::UInt32);
+	bool isTransactionIsolation(Poco::UInt32);
+	const std::string& connectorName() const;
+	void setFeature(const std::string& name, bool state);	
+	bool getFeature(const std::string& name);
+	void setProperty(const std::string& name, const Poco::Any& value);
+	Poco::Any getProperty(const std::string& name);
+	
+protected:
+	SessionImpl* access() const;
+		/// Updates the last access timestamp,
+		/// verifies validity of the session
+		/// and returns the session if it is valid.
+		///
+		/// Throws an SessionUnavailableException if the
+		/// session is no longer valid.
+		
+	SessionImpl* impl() const;
+		/// Returns a pointer to the SessionImpl.
+				
+private:	
+	mutable Poco::AutoPtr<PooledSessionHolder> _pHolder;
+};
+
+
+//
+// inlines
+//
+inline SessionImpl* PooledSessionImpl::impl() const
+{
+	return _pHolder->session();
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_PooledSessionImpl_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/Position.h b/base/poco/Data/include/Poco/Data/Position.h
new file mode 100644
index 00000000000..727d27b74ee
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/Position.h
@@ -0,0 +1,75 @@
+//
+// PositionExtraction.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  Position
+//
+// Definition of the PositionExtraction class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_Position_INCLUDED
+#define Data_Position_INCLUDED
+
+
+#include "Poco/Data/Limit.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API Position
+	/// Utility class wrapping unsigned integer. Used to
+	/// indicate the recordset position in batch SQL statements.
+{
+public:
+	Position(Poco::UInt32 value);
+		/// Creates the Position.
+
+	~Position();
+		/// Destroys the Position.
+
+	Poco::UInt32 value() const;
+		/// Returns the position value.
+	
+private:
+	Position();
+
+	Poco::UInt32 _value;
+};
+
+
+///
+/// inlines
+///
+inline Poco::UInt32 Position::value() const 
+{ 
+	return _value; 
+}
+
+
+namespace Keywords {
+
+
+template <typename T>
+inline Position from(const T& value)
+	/// Convenience function for creation of position.
+{
+	return Position(value);
+}
+
+
+} // namespace Keywords
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_Position_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/Preparation.h b/base/poco/Data/include/Poco/Data/Preparation.h
new file mode 100644
index 00000000000..f573a2099f9
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/Preparation.h
@@ -0,0 +1,161 @@
+//
+// Preparation.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  Preparation
+//
+// Definition of the Preparation class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_Preparation_INCLUDED
+#define Data_Preparation_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/AbstractPreparation.h"
+#include "Poco/Data/TypeHandler.h"
+#include <cstddef>
+#include <vector>
+
+
+namespace Poco {
+namespace Data {
+
+
+template<typename T>
+class Preparation: public AbstractPreparation
+	/// Class for calling the appropriate AbstractPreparator method.
+{
+public:
+	Preparation(AbstractPreparator::Ptr& pPreparator, std::size_t pos, T& val): 
+		AbstractPreparation(pPreparator), 
+		_pos(pos), 
+		_val(val)
+		/// Creates the Preparation.
+	{
+	}
+
+	~Preparation()
+		/// Destroys the Preparation.
+	{
+	}
+
+	void prepare()
+		/// Prepares data.
+	{
+		TypeHandler<T>::prepare(_pos, _val, preparation());
+	}
+
+private:
+	std::size_t _pos;
+	T&          _val;
+};
+
+
+template<typename T>
+class Preparation<std::vector<T> >: public AbstractPreparation
+	/// Preparation specialization for std::vector.
+	/// This specialization is needed for bulk operations to enforce
+	/// the whole vector preparation, rather than only individual contained values.
+{
+public:
+	Preparation(AbstractPreparator::Ptr pPreparator, std::size_t pos, std::vector<T>& val = std::vector<T>()): 
+		AbstractPreparation(pPreparator), 
+		_pos(pos), 
+		_val(val)
+		/// Creates the Preparation.
+	{
+	}
+
+	~Preparation()
+		/// Destroys the Preparation.
+	{
+	}
+
+	void prepare()
+		/// Prepares data.
+	{
+		TypeHandler<std::vector<T> >::prepare(_pos, _val, preparation());
+	}
+
+private:
+	std::size_t     _pos;
+	std::vector<T>& _val;
+};
+
+
+template<typename T>
+class Preparation<std::deque<T> >: public AbstractPreparation
+	/// Preparation specialization for std::deque.
+	/// This specialization is needed for bulk operations to enforce
+	/// the whole deque preparation, rather than only individual contained values.
+{
+public:
+	Preparation(AbstractPreparator::Ptr pPreparator, std::size_t pos, std::deque<T>& val = std::deque<T>()): 
+		AbstractPreparation(pPreparator), 
+		_pos(pos), 
+		_val(val)
+		/// Creates the Preparation.
+	{
+	}
+
+	~Preparation()
+		/// Destroys the Preparation.
+	{
+	}
+
+	void prepare()
+		/// Prepares data.
+	{
+		TypeHandler<std::deque<T> >::prepare(_pos, _val, preparation());
+	}
+
+private:
+	std::size_t     _pos;
+	std::deque<T>&  _val;
+};
+
+
+template<typename T>
+class Preparation<std::list<T> >: public AbstractPreparation
+	/// Preparation specialization for std::list.
+	/// This specialization is needed for bulk operations to enforce
+	/// the whole list preparation, rather than only individual contained values.
+{
+public:
+	Preparation(AbstractPreparator::Ptr pPreparator, std::size_t pos, std::list<T>& val = std::list<T>()): 
+		AbstractPreparation(pPreparator), 
+		_pos(pos), 
+		_val(val)
+		/// Creates the Preparation.
+	{
+	}
+
+	~Preparation()
+		/// Destroys the Preparation.
+	{
+	}
+
+	void prepare()
+		/// Prepares data.
+	{
+		TypeHandler<std::list<T> >::prepare(_pos, _val, preparation());
+	}
+
+private:
+	std::size_t   _pos;
+	std::list<T>& _val;
+};
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_Preparation_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/Range.h b/base/poco/Data/include/Poco/Data/Range.h
new file mode 100644
index 00000000000..8f0ab042e8d
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/Range.h
@@ -0,0 +1,104 @@
+//
+// Range.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  Range
+//
+// Definition of the Range class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_Range_INCLUDED
+#define Data_Range_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/Limit.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API Range
+	/// Range stores information how many rows a query should return.
+{
+public:
+	Range(Limit::SizeT lowValue, Limit::SizeT upValue, bool hardLimit);
+		/// Creates the Range. lowValue must be smaller equal than upValue
+
+	~Range();
+		/// Destroys the Limit.
+
+	const Limit& lower() const;
+		/// Returns the lower limit
+
+	const Limit& upper() const;
+		/// Returns the upper limit
+
+private:
+	Limit _lower;
+	Limit _upper;
+};
+
+
+//
+// inlines
+//
+inline const Limit& Range::lower() const
+{
+	return _lower;
+}
+
+
+inline const Limit& Range::upper() const
+{
+	return _upper;
+}
+
+
+namespace Keywords {
+
+
+template <typename T> 
+Limit limit(T lim, bool hard = false)
+	/// Creates an upperLimit
+{
+	return Limit(static_cast<Limit::SizeT>(lim), hard, false);
+}
+
+
+template <typename T> 
+Limit upperLimit(T lim, bool hard = false)
+{
+	return limit(lim, hard);
+}
+
+
+template <typename T> 
+Limit lowerLimit(T lim)
+{
+	return Limit(static_cast<Limit::SizeT>(lim), true, true);
+}
+
+
+template <typename T> 
+Range range(T low, T upp, bool hard = false)
+{
+	return Range(static_cast<Limit::SizeT>(low), static_cast<Limit::SizeT>(upp), hard);
+}
+
+
+} // namespace Keywords
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_Range_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/RecordSet.h b/base/poco/Data/include/Poco/Data/RecordSet.h
new file mode 100644
index 00000000000..050b3892725
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/RecordSet.h
@@ -0,0 +1,653 @@
+//
+// RecordSet.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  RecordSet
+//
+// Definition of the RecordSet class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_RecordSet_INCLUDED
+#define Data_RecordSet_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/Session.h"
+#include "Poco/Data/Extraction.h"
+#include "Poco/Data/BulkExtraction.h"
+#include "Poco/Data/Statement.h"
+#include "Poco/Data/RowIterator.h"
+#include "Poco/Data/RowFilter.h"
+#include "Poco/Data/LOB.h"
+#include "Poco/String.h"
+#include "Poco/Dynamic/Var.h"
+#include "Poco/Exception.h"
+#include "Poco/AutoPtr.h"
+#include <ostream>
+#include <limits>
+
+
+namespace Poco {
+namespace Data {
+
+
+class RowFilter;
+
+
+class Data_API RecordSet: private Statement
+	/// RecordSet provides access to data returned from a query.
+	/// Data access indices (row and column) are 0-based, as usual in C++.
+	/// 
+	/// Recordset provides navigation methods to iterate through the
+	/// recordset, retrieval methods to extract data, and methods
+	/// to get metadata (type, etc.) about columns.
+	///
+	/// To work with a RecordSet, first create a Statement, execute it, and
+	/// create the RecordSet from the Statement, as follows:
+	///
+	///     Statement select(session);
+	///     select << "SELECT * FROM Person";
+	///     select.execute();
+	///     RecordSet rs(select);
+	///
+	/// The shorter way to do the above is following:
+	///
+	///     RecordSet rs(session, "SELECT * FROM Person"[, new SimpleRowFormatter]);
+	///
+	/// The third (optional) argument passed to the Recordset constructor is a RowFormatter
+	/// implementation. The formatter is used in conjunction with << operator for recordset
+	/// data formating.
+	/// 
+	/// The number of rows in the RecordSet can be limited by specifying
+	/// a limit for the Statement.
+{
+public:
+	typedef std::map<std::size_t, Row*> RowMap;
+	typedef const RowIterator           ConstIterator;
+	typedef RowIterator                 Iterator;
+
+	using Statement::isNull;
+	using Statement::subTotalRowCount;
+
+	static const std::size_t UNKNOWN_TOTAL_ROW_COUNT;
+
+	explicit RecordSet(const Statement& rStatement,
+		RowFormatter::Ptr pRowFormatter = 0);
+		/// Creates the RecordSet.
+
+	RecordSet(Session& rSession, 
+		const std::string& query,
+		RowFormatter::Ptr pRowFormatter = 0);
+		/// Creates the RecordSet.
+
+	RecordSet(Session& rSession, 
+		const std::string& query,
+		const RowFormatter& rowFormatter);
+		/// Creates the RecordSet.
+
+	template <class RF>
+	RecordSet(Session& rSession, const std::string& query, const RF& rowFormatter): 
+		Statement((rSession << query, Keywords::now)),
+		_currentRow(0),
+		_pBegin(new RowIterator(this, 0 == rowsExtracted())),
+		_pEnd(new RowIterator(this, true)),
+		_totalRowCount(UNKNOWN_TOTAL_ROW_COUNT)
+		/// Creates the RecordSet.
+	{
+		setRowFormatter(Keywords::format(rowFormatter));
+	}
+
+	RecordSet(const RecordSet& other);
+		/// Copy-creates the recordset.
+
+	~RecordSet();
+		/// Destroys the RecordSet.
+
+	void setRowFormatter(RowFormatter::Ptr pRowFormatter);
+		/// Assigns the row formatter to the statement and all recordset rows.
+
+	Statement& operator = (const Statement& stmt);
+		/// Assignment operator.
+
+	std::size_t rowCount() const;
+		/// Returns the number of rows in the RecordSet.
+		/// The number of rows reported is dependent on filtering.
+		/// Due to the need for filter conditions checking,
+		/// this function may suffer significant performance penalty
+		/// for large recordsets, so it should be used judiciously.
+		/// Use totalRowCount() to obtain the total number of rows.
+
+	std::size_t extractedRowCount() const;
+		/// Returns the number of rows extracted during the last statement
+		/// execution.
+		/// The number of rows reported is independent of filtering.
+
+	std::size_t totalRowCount() const;
+		//@ deprecated
+		/// Replaced with subTotalRowCount() and getTotalRowCount().
+
+	std::size_t getTotalRowCount() const;
+		/// Returns the total number of rows in the RecordSet.
+		/// The number of rows reported is independent of filtering.
+		/// If the total row count has not been set externally 
+		/// (either explicitly or implicitly through SQL), the value
+		/// returned shall only be accurate if the statement limit
+		/// is less or equal to the total row count.
+
+	void setTotalRowCount(std::size_t totalRowCount);
+		/// Explicitly sets the total row count.
+
+	void setTotalRowCount(const std::string& sql);
+		/// Implicitly sets the total row count.
+		/// The supplied sql must return exactly one column
+		/// and one row. The returned value must be an unsigned
+		/// integer. The value is set as the total number of rows.
+
+	std::size_t columnCount() const;
+		/// Returns the number of columns in the recordset.
+
+	template <class C>
+	const Column<C>& column(const std::string& name) const
+		/// Returns the reference to the first Column with the specified name.
+	{
+		if (isBulkExtraction())
+		{
+			typedef InternalBulkExtraction<C> E;
+			return columnImpl<C,E>(name);
+		}
+		else
+		{
+			typedef InternalExtraction<C> E;
+			return columnImpl<C,E>(name);
+		}
+	}
+
+	template <class C>
+	const Column<C>& column(std::size_t pos) const
+		/// Returns the reference to column at specified position.
+	{
+		if (isBulkExtraction())
+		{
+			typedef InternalBulkExtraction<C> E;
+			return columnImpl<C,E>(pos);
+		}
+		else
+		{
+			typedef InternalExtraction<C> E;
+			return columnImpl<C,E>(pos);
+		}
+	}
+
+	Row& row(std::size_t pos);
+		/// Returns reference to row at position pos.
+		/// Rows are lazy-created and cached.
+
+	template <class T>
+	const T& value(std::size_t col, std::size_t row, bool useFilter = true) const
+		/// Returns the reference to data value at [col, row] location.
+	{
+		if (useFilter && isFiltered() && !isAllowed(row))
+			throw InvalidAccessException("Row not allowed");
+
+		switch (storage())
+		{
+			case STORAGE_VECTOR:
+			{
+				typedef typename std::vector<T> C;
+				return column<C>(col).value(row);
+			}
+			case STORAGE_LIST:
+			{
+				typedef typename std::list<T> C;
+				return column<C>(col).value(row);
+			}
+			case STORAGE_DEQUE:
+			case STORAGE_UNKNOWN:
+			{
+				typedef typename std::deque<T> C;
+				return column<C>(col).value(row);
+			}
+			default:
+				throw IllegalStateException("Invalid storage setting.");
+		}
+	}
+
+	template <class T>
+	const T& value(const std::string& name, std::size_t row, bool useFilter = true) const
+		/// Returns the reference to data value at named column, row location.
+	{
+		if (useFilter && isFiltered() && !isAllowed(row))
+			throw InvalidAccessException("Row not allowed");
+
+		switch (storage())
+		{
+			case STORAGE_VECTOR:
+			{
+				typedef typename std::vector<T> C;
+				return column<C>(name).value(row);
+			}
+			case STORAGE_LIST:
+			{
+				typedef typename std::list<T> C;
+				return column<C>(name).value(row);
+			}
+			case STORAGE_DEQUE:
+			case STORAGE_UNKNOWN:
+			{
+				typedef typename std::deque<T> C;
+				return column<C>(name).value(row);
+			}
+			default:
+				throw IllegalStateException("Invalid storage setting.");
+		}
+	}
+
+	Poco::Dynamic::Var value(std::size_t col, std::size_t row, bool checkFiltering = true) const;
+		/// Returns the data value at column, row location.
+
+	Poco::Dynamic::Var value(const std::string& name, std::size_t row, bool checkFiltering = true) const;
+		/// Returns the data value at named column, row location.
+
+	template <typename T>
+	Poco::Dynamic::Var nvl(const std::string& name, const T& deflt = T()) const
+		/// Returns the value in the named column of the current row
+		/// if the value is not NULL, or deflt otherwise.
+	{
+		if (isNull(name))
+			return Poco::Dynamic::Var(deflt);
+		else
+			return value(name, _currentRow);
+	}
+	
+	template <typename T>
+	Poco::Dynamic::Var nvl(std::size_t index, const T& deflt = T()) const
+		/// Returns the value in the given column of the current row
+		/// if the value is not NULL, or deflt otherwise.
+	{
+		if (isNull(index, _currentRow))
+			return Poco::Dynamic::Var(deflt);
+		else
+			return value(index, _currentRow);
+	}
+
+	ConstIterator& begin() const;
+		/// Returns the const row iterator.
+
+	ConstIterator& end() const;
+		/// Returns the const row iterator.
+
+	Iterator begin();
+		/// Returns the row iterator.
+
+	Iterator end();
+		/// Returns the row iterator.
+
+	bool moveFirst();
+		/// Moves the row cursor to the first row.
+		///
+		/// Returns true if there is at least one row in the RecordSet,
+		/// false otherwise.
+
+	bool moveNext();
+		/// Moves the row cursor to the next row.
+		///
+		/// Returns true if the row is available, or false
+		/// if the end of the record set has been reached and
+		/// no more rows are available.
+
+	bool movePrevious();
+		/// Moves the row cursor to the previous row.
+		///
+		/// Returns true if the row is available, or false
+		/// if there are no more rows available.
+
+	bool moveLast();
+		/// Moves the row cursor to the last row.
+		///
+		/// Returns true if there is at least one row in the RecordSet,
+		/// false otherwise.
+
+	using Statement::reset;
+		/// Don't hide base class method.
+
+	void reset(const Statement& stmt);
+		/// Resets the RecordSet and assigns a new statement.
+		/// Should be called after the given statement has been reset,
+		/// assigned a new SQL statement, and executed.
+		///
+		/// Does not remove the associated RowFilter or RowFormatter.
+
+	Poco::Dynamic::Var value(const std::string& name);
+		/// Returns the value in the named column of the current row.
+
+	Poco::Dynamic::Var value(std::size_t index);
+		/// Returns the value in the given column of the current row.
+
+	Poco::Dynamic::Var operator [] (const std::string& name);
+		/// Returns the value in the named column of the current row.
+
+	Poco::Dynamic::Var operator [] (std::size_t index);
+		/// Returns the value in the named column of the current row.
+
+	MetaColumn::ColumnDataType columnType(std::size_t pos) const;
+		/// Returns the type for the column at specified position.
+
+	MetaColumn::ColumnDataType columnType(const std::string& name) const;
+		/// Returns the type for the column with specified name.
+
+	const std::string& columnName(std::size_t pos) const;
+		/// Returns column name for the column at specified position.
+
+	std::size_t columnLength(std::size_t pos) const;
+		/// Returns column maximum length for the column at specified position.
+
+	std::size_t columnLength(const std::string& name) const;
+		/// Returns column maximum length for the column with specified name.
+
+	std::size_t columnPrecision(std::size_t pos) const;
+		/// Returns column precision for the column at specified position.
+		/// Valid for floating point fields only (zero for other data types).
+
+	std::size_t columnPrecision(const std::string& name) const;
+		/// Returns column precision for the column with specified name.
+		/// Valid for floating point fields only (zero for other data types).
+
+	bool isNull(const std::string& name) const;
+		/// Returns true if column value of the current row is null.
+
+	std::ostream& copyNames(std::ostream& os) const;
+		/// Copies the column names to the target output stream.
+		/// Copied string is formatted by the current RowFormatter.
+
+	void formatNames() const;
+		/// Formats names using the current RowFormatter.
+
+	std::ostream& copyValues(std::ostream& os, 
+		std::size_t offset = 0, 
+		std::size_t length = RowIterator::POSITION_END) const;
+		/// Copies the data values to the supplied output stream.
+		/// The data set to be copied is starting at the specified offset 
+		/// from the recordset beginning. The number of rows to be copied
+		/// is specified by length argument.
+		/// An invalid combination of offset/length arguments shall
+		/// cause RangeException to be thrown.
+		/// Copied string is formatted by the current RowFormatter.
+
+	void formatValues(std::size_t offset, std::size_t length) const;
+		/// Formats values using the current RowFormatter.
+		/// The data set to be formatted is starting at the specified offset 
+		/// from the recordset beginning. The number of rows to be copied
+		/// is specified by length argument.
+		/// An invalid combination of offset/length arguments shall
+		/// cause RangeException to be thrown.
+
+	std::ostream& copy(std::ostream& os,
+		std::size_t offset = 0,
+		std::size_t length = RowIterator::POSITION_END) const;
+		/// Copies the column names and values to the target output stream.
+		/// Copied strings are formatted by the current RowFormatter.
+
+	bool isFiltered() const;
+		/// Returns true if recordset is filtered.
+
+private:
+	RecordSet();
+
+	template<class C, class E>
+	std::size_t columnPosition(const std::string& name) const
+		/// Returns the position of the column with specified name.
+	{
+		typedef typename C::value_type T;
+		typedef const E* ExtractionVecPtr;
+
+		bool typeFound = false;
+
+		const AbstractExtractionVec& rExtractions = extractions();
+		AbstractExtractionVec::const_iterator it = rExtractions.begin();
+		AbstractExtractionVec::const_iterator end = rExtractions.end();
+		
+		for (; it != end; ++it)
+		{
+			ExtractionVecPtr pExtraction = dynamic_cast<ExtractionVecPtr>(it->get());
+
+			if (pExtraction)
+			{
+				typeFound = true;
+				const Column<C>& col = pExtraction->column();
+				if (0 == Poco::icompare(name, col.name()))
+					return col.position();
+			}
+		}
+
+		if (typeFound)
+			throw NotFoundException(Poco::format("Column name: %s", name));
+		else
+			throw NotFoundException(Poco::format("Column type: %s, name: %s", std::string(typeid(T).name()), name));
+	}
+
+	template <class C, class E>
+	const Column<C>& columnImpl(const std::string& name) const
+		/// Returns the reference to the first Column with the specified name.
+	{
+		return columnImpl<C,E>(columnPosition<C,E>(name));
+	}
+
+	template <class C, class E>
+	const Column<C>& columnImpl(std::size_t pos) const
+		/// Returns the reference to column at specified position.
+	{
+		typedef typename C::value_type T;
+		typedef const E* ExtractionVecPtr;
+
+		const AbstractExtractionVec& rExtractions = extractions();
+
+		std::size_t s = rExtractions.size();
+		if (0 == s || pos >= s)
+			throw RangeException(Poco::format("Invalid column index: %z", pos));
+
+		ExtractionVecPtr pExtraction = dynamic_cast<ExtractionVecPtr>(rExtractions[pos].get());
+
+		if (pExtraction)
+		{
+			return pExtraction->column();
+		}
+		else 
+		{
+			throw Poco::BadCastException(Poco::format("Type cast failed!\nColumn: %z\nTarget type:\t%s",  
+				pos,
+				std::string(typeid(T).name())));
+		}
+	}
+
+	bool isAllowed(std::size_t row) const;
+		/// Returns true if the specified row is allowed by the
+		/// currently active filter.
+
+	void filter(const Poco::AutoPtr<RowFilter>& pFilter);
+		/// Sets the filter for the RecordSet.
+
+	const Poco::AutoPtr<RowFilter>& getFilter() const;
+		/// Returns the filter associated with the RecordSet.
+
+	std::size_t  _currentRow;
+	RowIterator* _pBegin;
+	RowIterator* _pEnd;
+	RowMap       _rowMap;
+	Poco::AutoPtr<RowFilter> _pFilter;
+	std::size_t  _totalRowCount;
+
+	friend class RowIterator;
+	friend class RowFilter;
+};
+
+
+///
+/// inlines
+///
+
+
+inline Data_API std::ostream& operator << (std::ostream &os, const RecordSet& rs)
+{
+	return rs.copy(os);
+}
+
+
+inline std::size_t RecordSet::getTotalRowCount() const
+{
+	if (UNKNOWN_TOTAL_ROW_COUNT == _totalRowCount)
+		return subTotalRowCount();
+	else
+		return _totalRowCount;
+}
+
+
+inline std::size_t RecordSet::totalRowCount() const
+{
+	return getTotalRowCount();
+}
+
+
+inline void RecordSet::setTotalRowCount(std::size_t totalRowCount)
+{
+	_totalRowCount = totalRowCount;
+}
+
+
+inline std::size_t RecordSet::extractedRowCount() const
+{
+	return rowsExtracted();
+}
+
+
+inline std::size_t RecordSet::columnCount() const
+{
+	return static_cast<std::size_t>(extractions().size());
+}
+
+
+inline Statement& RecordSet::operator = (const Statement& stmt)
+{
+	reset(stmt);
+	return *this;
+}
+
+
+inline Poco::Dynamic::Var RecordSet::value(const std::string& name)
+{
+	return value(name, _currentRow);
+}
+
+
+inline Poco::Dynamic::Var RecordSet::value(std::size_t index)
+{
+	return value(index, _currentRow);
+}
+
+
+inline Poco::Dynamic::Var RecordSet::operator [] (const std::string& name)
+{
+	return value(name, _currentRow);
+}
+
+
+inline Poco::Dynamic::Var RecordSet::operator [] (std::size_t index)
+{
+	return value(index, _currentRow);
+}
+
+
+inline MetaColumn::ColumnDataType RecordSet::columnType(std::size_t pos)const
+{
+	return metaColumn(static_cast<UInt32>(pos)).type();
+}
+
+
+inline MetaColumn::ColumnDataType RecordSet::columnType(const std::string& name)const
+{
+	return metaColumn(name).type();
+}
+
+
+inline const std::string& RecordSet::columnName(std::size_t pos) const
+{
+	return metaColumn(static_cast<UInt32>(pos)).name();
+}
+
+
+inline std::size_t RecordSet::columnLength(std::size_t pos) const
+{
+	return metaColumn(static_cast<UInt32>(pos)).length();
+}
+
+
+inline std::size_t RecordSet::columnLength(const std::string& name)const
+{
+	return metaColumn(name).length();
+}
+
+
+inline std::size_t RecordSet::columnPrecision(std::size_t pos) const
+{
+	return metaColumn(static_cast<UInt32>(pos)).precision();
+}
+
+
+inline std::size_t RecordSet::columnPrecision(const std::string& name)const
+{
+	return metaColumn(name).precision();
+}
+
+
+inline bool RecordSet::isNull(const std::string& name) const
+{
+	return isNull(metaColumn(name).position(), _currentRow);
+}
+
+
+inline RecordSet::ConstIterator& RecordSet::begin() const
+{
+	return *_pBegin;
+}
+
+
+inline RecordSet::ConstIterator& RecordSet::end() const
+{
+	return *_pEnd;
+}
+
+
+inline RecordSet::Iterator RecordSet::begin()
+{
+	return *_pBegin;
+}
+
+
+inline RecordSet::Iterator RecordSet::end()
+{
+	return *_pEnd;
+}
+
+
+inline const Poco::AutoPtr<RowFilter>& RecordSet::getFilter() const
+{
+	return _pFilter;
+}
+
+
+inline void RecordSet::formatNames() const
+{
+	(*_pBegin)->formatNames();
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_RecordSet_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/Row.h b/base/poco/Data/include/Poco/Data/Row.h
new file mode 100644
index 00000000000..6144967803f
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/Row.h
@@ -0,0 +1,312 @@
+//
+// Row.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  Row
+//
+// Definition of the Row class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_Row_INCLUDED
+#define Data_Row_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/RowFormatter.h"
+#include "Poco/Dynamic/Var.h"
+#include "Poco/Tuple.h"
+#include "Poco/SharedPtr.h"
+#include <vector>
+#include <string>
+#include <ostream>
+
+
+namespace Poco {
+namespace Data {
+
+
+class RecordSet;
+
+
+class Data_API Row
+	/// Row class provides a data type for RecordSet iteration purposes.
+	/// Dereferencing a RowIterator returns Row.
+	/// Rows are sortable. The sortability is maintained at all times (i.e. there
+	/// is always at least one column specified as a sorting criteria) .
+	/// The default and minimal sorting criteria is the first field (position 0).
+	/// The default sorting criteria can be replaced with any other field by 
+	/// calling replaceSortField() member function.
+	/// Additional fields can be added to sorting criteria, in which case the
+	/// field precedence corresponds to addition order (i.e. later added fields
+	/// have lower sorting precedence).
+	/// These features make Row suitable for use with standard sorted 
+	/// containers and algorithms. The main constraint is that all the rows from
+	/// a set that is being sorted must have the same sorting criteria (i.e., the same
+	/// set of fields must be in sorting criteria in the same order). Since rows don't
+	/// know about each other, it is the programmer's responsibility to ensure this
+	/// constraint is satisfied.
+	/// Field names are a shared pointer to a vector of strings. For efficiency sake,
+	/// a constructor taking a shared pointer to names vector argument is provided.
+	/// The stream operator is provided for Row data type as a free-standing function.
+{
+public:
+	typedef RowFormatter::NameVec    NameVec;
+	typedef RowFormatter::NameVecPtr NameVecPtr;
+	typedef RowFormatter::ValueVec   ValueVec;
+
+	enum ComparisonType
+	{
+		COMPARE_AS_EMPTY,
+		COMPARE_AS_INTEGER,
+		COMPARE_AS_FLOAT,
+		COMPARE_AS_STRING
+	};
+
+	typedef Tuple<std::size_t, ComparisonType> SortTuple;
+	typedef std::vector<SortTuple>             SortMap;
+		/// The type for map holding fields used for sorting criteria.
+		/// Fields are added sequentially and have precedence that
+		/// corresponds to field adding sequence order (rather than field's 
+		/// position in the row).
+		/// This requirement rules out use of std::map due to its sorted nature.
+	typedef SharedPtr<SortMap> SortMapPtr;
+
+	Row();
+		/// Creates the Row.
+
+	Row(NameVecPtr pNames,
+		const RowFormatter::Ptr& pFormatter = 0);
+		/// Creates the Row.
+
+	Row(NameVecPtr pNames,
+		const SortMapPtr& pSortMap,
+		const RowFormatter::Ptr& pFormatter = 0);
+		/// Creates the Row.
+
+	~Row();
+		/// Destroys the Row.
+
+	Poco::Dynamic::Var& get(std::size_t col);
+		/// Returns the reference to data value at column location.
+
+	Poco::Dynamic::Var& operator [] (std::size_t col);
+		/// Returns the reference to data value at column location.
+
+	Poco::Dynamic::Var& operator [] (const std::string& name);
+		/// Returns the reference to data value at named column location.
+
+	template <typename T>
+	void append(const std::string& name, const T& val)
+		/// Appends the value to the row.
+	{
+		if (!_pNames) _pNames = new NameVec;
+		_values.push_back(val);
+		_pNames->push_back(name);
+		if (1 == _values.size()) addSortField(0);
+	}
+	
+	template <typename T>
+	void set(std::size_t pos, const T& val)
+		/// Assigns the value to the row.
+	{
+		try
+		{
+			_values.at(pos) = val;
+		}
+		catch (std::out_of_range&)
+		{
+			throw RangeException("Invalid column number.");
+		}
+	}
+
+	template <typename T>
+	void set(const std::string& name, const T& val)
+		/// Assigns the value to the row.
+	{
+		NameVec::iterator it = _pNames->begin();
+		NameVec::iterator end = _pNames->end();
+		for (int i = 0; it != end; ++it, ++i)
+		{
+			if (*it == name)
+				return set(i, val);
+		}
+
+		std::ostringstream os;
+		os << "Column with name " << name << " not found.";
+		throw NotFoundException(os.str());
+	}
+
+	std::size_t fieldCount() const;
+		/// Returns the number of fields in this row.
+
+	void reset();
+		/// Resets the row by clearing all field names and values.
+
+	void separator(const std::string& sep);
+		/// Sets the separator.
+
+	void addSortField(std::size_t pos);
+		/// Adds the field used for sorting.
+
+	void addSortField(const std::string& name);
+		/// Adds the field used for sorting.
+
+	void removeSortField(std::size_t pos);
+		/// Removes the field used for sorting.
+
+	void removeSortField(const std::string& name);
+		/// Removes the field used for sorting.
+
+	void replaceSortField(std::size_t oldPos, std::size_t newPos);
+		/// Replaces the field used for sorting.
+
+	void replaceSortField(const std::string& oldName, const std::string& newName);
+		/// Replaces the field used for sorting.
+
+	void resetSort();
+		/// Resets the sorting criteria to field 0 only.
+
+	const std::string& namesToString() const;
+		/// Converts the column names to string.
+
+	void formatNames() const;
+		/// Fomats the column names.
+
+	const std::string& valuesToString() const;
+		/// Converts the row values to string and returns the formated string.
+
+	void formatValues() const;
+		/// Fomats the row values.
+
+	bool operator == (const Row& other) const;
+		/// Equality operator.
+
+	bool operator != (const Row& other) const;
+		/// Inequality operator.
+
+	bool operator < (const Row& other) const;
+		/// Less-than operator.
+
+	const NameVecPtr names() const;
+		/// Returns the shared pointer to names vector.
+
+	const ValueVec& values() const;
+		/// Returns the const reference to values vector.
+
+	void setFormatter(const RowFormatter::Ptr& pFormatter = 0);
+		/// Sets the formatter for this row and takes the
+		/// shared ownership of it.
+
+	const RowFormatter& getFormatter() const;
+		/// Returns the reference to the formatter.
+
+	void setSortMap(const SortMapPtr& pSortMap = 0);
+		/// Adds the sorting fields entry and takes the
+		/// shared ownership of it.
+
+	const SortMapPtr& getSortMap() const;
+		/// Returns the reference to the sorting fields.
+
+private:
+	void init(const SortMapPtr& pSortMap, const RowFormatter::Ptr& pFormatter);
+
+	ValueVec& values();
+		/// Returns the reference to values vector.
+
+	std::size_t getPosition(const std::string& name);
+	bool isEqualSize(const Row& other) const;
+	bool isEqualType(const Row& other) const;
+
+	NameVecPtr                _pNames;
+	ValueVec                  _values;
+	SortMapPtr                _pSortMap;
+	mutable RowFormatter::Ptr _pFormatter;
+	mutable std::string       _nameStr;
+	mutable std::string       _valueStr;
+};
+
+
+Data_API std::ostream& operator << (std::ostream &os, const Row& row);
+
+
+///
+/// inlines
+///
+inline std::size_t Row::fieldCount() const
+{
+	return static_cast<std::size_t>(_values.size());
+}
+
+
+inline void Row::reset()
+{
+	_pNames->clear();
+	_values.clear();
+}
+
+
+inline const Row::NameVecPtr Row::names() const
+{
+	return _pNames;
+}
+
+
+inline const Row::ValueVec& Row::values() const
+{
+	return _values;
+}
+
+
+inline Row::ValueVec& Row::values()
+{
+	return _values;
+}
+
+
+inline Poco::Dynamic::Var& Row::operator [] (std::size_t col)
+{
+	return get(col);
+}
+
+
+inline Poco::Dynamic::Var& Row::operator [] (const std::string& name)
+{
+	return get(getPosition(name));
+}
+
+
+inline const RowFormatter& Row::getFormatter() const
+{
+	return *_pFormatter;
+}
+
+
+inline const Row::SortMapPtr& Row::getSortMap() const
+{
+	return _pSortMap;
+}
+
+
+inline const std::string& Row::valuesToString() const
+{
+	return _pFormatter->formatValues(values(), _valueStr);
+}
+
+
+inline void Row::formatValues() const
+{
+	return _pFormatter->formatValues(values());
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_Row_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/RowFilter.h b/base/poco/Data/include/Poco/Data/RowFilter.h
new file mode 100644
index 00000000000..0b0febd2dc4
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/RowFilter.h
@@ -0,0 +1,276 @@
+//
+// RowFilter.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  RowFilter
+//
+// Definition of the RowFilter class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_RowFilter_INCLUDED
+#define Data_RowFilter_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Dynamic/Var.h"
+#include "Poco/Tuple.h"
+#include "Poco/String.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include <map>
+#include <list>
+#include <utility>
+
+
+namespace Poco {
+namespace Data {
+
+
+class RecordSet;
+
+
+class Data_API RowFilter: public RefCountedObject
+	/// RowFilter class provides row filtering functionality.
+	/// A filter contains a set of criteria (field name, value and
+	/// logical operation) for row filtering.
+	/// Additionally, a row filter contains a map of pointers to other
+	/// filters with related logical operations between filters.
+	/// RowFilter is typically added to recordset in order to filter
+	/// its content. Since the recordset own iteration is dependent upon
+	/// filtering, whenever the filtering criteria is changed,
+	/// the filter automatically notifies all associated recordsets
+	/// by rewinding them to the first position.
+{
+public:
+	enum Comparison
+	{
+		VALUE_LESS_THAN,
+		VALUE_LESS_THAN_OR_EQUAL,
+		VALUE_EQUAL,
+		VALUE_GREATER_THAN,
+		VALUE_GREATER_THAN_OR_EQUAL,
+		VALUE_NOT_EQUAL,
+		VALUE_IS_NULL
+	};
+
+	enum LogicOperator
+	{
+		OP_AND,
+		OP_OR,
+		OP_NOT
+	};
+
+	typedef bool (*CompT)(const Poco::Dynamic::Var&, const Poco::Dynamic::Var&);
+	typedef AutoPtr<RowFilter> Ptr;
+	typedef std::map<std::string, Comparison> Comparisons;
+	typedef Tuple<Poco::Dynamic::Var, Comparison, LogicOperator> ComparisonEntry;
+	typedef std::multimap<std::string, ComparisonEntry> ComparisonMap;
+	typedef std::map<AutoPtr<RowFilter>, LogicOperator> FilterMap;
+
+	RowFilter(RecordSet* pRecordSet);
+		/// Creates the top-level RowFilter and associates it with the recordset.
+
+	RowFilter(Ptr pParent, LogicOperator op = OP_OR);
+		/// Creates child RowFilter and associates it with the parent filter.
+
+	~RowFilter();
+		/// Destroys the RowFilter.
+
+	void addFilter(Ptr pFilter, LogicOperator comparison);
+		/// Appends another filter to this one.
+
+	void removeFilter(Ptr pFilter);
+		/// Removes filter from this filter.
+
+	bool has(Ptr pFilter) const;
+		/// Returns true if this filter is parent of pFilter;
+
+	template <typename T>
+	void add(const std::string& name, Comparison comparison, const T& value, LogicOperator op = OP_OR)
+		/// Adds value to the filter.
+	{
+		rewindRecordSet();
+		_comparisonMap.insert(ComparisonMap::value_type(toUpper(name),
+			ComparisonEntry(value, comparison, op)));
+	}
+
+	template <typename T>
+	void add(const std::string& name, const std::string& comp, const T& value, LogicOperator op = OP_OR)
+		/// Adds value to the filter.
+	{
+		add(name, getComparison(comp), value, op);
+	}
+
+	template <typename T>
+	void addAnd(const std::string& name, const std::string& comp, const T& value)
+		/// Adds logically AND-ed value to the filter.
+	{
+		add(name, getComparison(comp), value, OP_AND);
+	}
+
+	template <typename T>
+	void addOr(const std::string& name, const std::string& comp, const T& value)
+		/// Adds logically OR-ed value to the filter.
+	{
+		add(name, getComparison(comp), value, OP_OR);
+	}
+
+	int remove(const std::string& name);
+		/// Removes named comparisons from the filter.
+		/// All comparisons with specified name are removed.
+		/// Returns the number of comparisons removed.
+
+	void toggleNot();
+		/// Togless the NOT operator for this filter;
+
+	bool isNot() const;
+		/// Returns true if filter is NOT-ed, false otherwise.
+
+	bool isEmpty() const;
+		/// Returns true if there is not filtering criteria specified.
+
+	bool isAllowed(std::size_t row) const;
+		/// Returns true if name and value are allowed.
+
+	bool exists(const std::string& name) const;
+		/// Returns true if name is known to this row filter.
+
+private:
+	RowFilter();
+	RowFilter(const RowFilter&);
+	RowFilter& operator=(const RowFilter&);
+
+	void init();
+
+	static bool equal(const Poco::Dynamic::Var& p1, const Poco::Dynamic::Var& p2);
+	static bool notEqual(const Poco::Dynamic::Var& p1, const Poco::Dynamic::Var& p2);
+	static bool less(const Poco::Dynamic::Var& p1, const Poco::Dynamic::Var& p2);
+	static bool greater(const Poco::Dynamic::Var& p1, const Poco::Dynamic::Var& p2);
+	static bool lessOrEqual(const Poco::Dynamic::Var& p1, const Poco::Dynamic::Var& p2);
+	static bool greaterOrEqual(const Poco::Dynamic::Var& p1, const Poco::Dynamic::Var& p2);
+	static bool logicalAnd(const Poco::Dynamic::Var& p1, const Poco::Dynamic::Var& p2);
+	static bool logicalOr(const Poco::Dynamic::Var& p1, const Poco::Dynamic::Var& p2);
+	static bool isNull(const Poco::Dynamic::Var& p1, const Poco::Dynamic::Var&);
+
+	static void doCompare(Poco::Dynamic::Var& ret,
+		Poco::Dynamic::Var& val,
+		CompT comp,
+		const ComparisonEntry& ce);
+
+	RecordSet& recordSet() const;
+
+	Comparison getComparison(const std::string& comp) const;
+	
+	void rewindRecordSet();
+
+	Comparisons        _comparisons;
+	ComparisonMap      _comparisonMap;
+	mutable RecordSet* _pRecordSet;
+	Ptr                _pParent;
+	FilterMap          _filterMap;
+	bool               _not;
+
+	friend class RecordSet;
+};
+
+
+///
+/// inlines
+///
+
+
+inline bool RowFilter::has(Ptr pFilter) const
+{
+	return _filterMap.find(pFilter) != _filterMap.end();
+}
+
+
+inline bool RowFilter::isEmpty() const
+{
+	return _comparisonMap.size() == 0;
+}
+
+
+inline bool RowFilter::exists(const std::string& name) const
+{
+	return _comparisonMap.find(name) != _comparisonMap.end();
+}
+
+
+inline void RowFilter::toggleNot()
+{
+	_not = !_not;
+}
+
+
+inline bool RowFilter::isNot() const
+{
+	return _not;
+}
+
+
+inline bool RowFilter::equal(const Poco::Dynamic::Var& p1, const Poco::Dynamic::Var& p2)
+{
+	return p1 == p2;
+}
+
+
+inline bool RowFilter::notEqual(const Poco::Dynamic::Var& p1, const Poco::Dynamic::Var& p2)
+{
+	return p1 != p2;
+}
+
+
+inline bool RowFilter::less(const Poco::Dynamic::Var& p1, const Poco::Dynamic::Var& p2)
+{
+	return p1 < p2;
+}
+
+
+inline bool RowFilter::greater(const Poco::Dynamic::Var& p1, const Poco::Dynamic::Var& p2)
+{
+	return p1 > p2;
+}
+
+
+inline bool RowFilter::lessOrEqual(const Poco::Dynamic::Var& p1, const Poco::Dynamic::Var& p2)
+{
+	return p1 <= p2;
+}
+
+
+inline bool RowFilter::greaterOrEqual(const Poco::Dynamic::Var& p1, const Poco::Dynamic::Var& p2)
+{
+	return p1 >= p2;
+}
+
+
+inline bool RowFilter::logicalAnd(const Poco::Dynamic::Var& p1, const Poco::Dynamic::Var& p2)
+{
+	return p1 && p2;
+}
+
+
+inline bool RowFilter::logicalOr(const Poco::Dynamic::Var& p1, const Poco::Dynamic::Var& p2)
+{
+	return p1 || p2;
+}
+
+
+inline bool RowFilter::isNull(const Poco::Dynamic::Var& p1, const Poco::Dynamic::Var&)
+{
+	return p1.isEmpty();
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_RowFilter_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/RowFormatter.h b/base/poco/Data/include/Poco/Data/RowFormatter.h
new file mode 100644
index 00000000000..a2a0c8614eb
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/RowFormatter.h
@@ -0,0 +1,231 @@
+//
+// RowFormatter.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  RowFormatter
+//
+// Definition of the RowFormatter class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_RowFormatter_INCLUDED
+#define Data_RowFormatter_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/Dynamic/Var.h"
+#include <sstream>
+#include <vector>
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API RowFormatter
+	/// Row formatter is an abstract class providing definition for row formatting functionality.
+	/// For custom formatting strategies, inherit from this class and override formatNames()
+	/// and formatValues() member functions.
+	///
+	/// Row formatter can be either passed to the RecordSet at construction time,
+	/// like in the following example:
+	///
+	/// RecordSet rs(session. "SELECT * FROM Table", new MyRowFormater);
+	///
+	/// or it can be supplied to the statement as in the following example:
+	///
+	/// MyRowFormatter rf
+	/// session << "SELECT * FROM Table", format(rf);
+	///
+	/// If no formatter is externally supplied to the statement, the SimpleRowFormatter is used.
+	/// Statement always has the ownership of the row formatter and shares
+	/// it with rows through RecordSet.
+	///
+	/// To accomodate for various formatting needs, a formatter can operate in two modes:
+	/// 
+	///	  - progressive: formatted individual row strings are gemerated and returned from each 
+	///     call to formatValues;
+	///     std::string& formatNames(const NameVecPtr, std::string&) and
+	///     std::string& formatValues(const ValueVec&, std::string&) member calls should be
+	///     used in this case; this is the default mode
+	///
+	///   - bulk: formatted resulting string is accumulated internally and obtained at
+	///     the end of iteration via toString() member function;
+	///     void formatNames(const NameVecPtr) and
+	///     void formatValues(const ValueVec&) member calls should be used in this case
+	///
+	/// When formatter is used in conjunction with Row/RecordSet, the formatting members corresponding
+	/// to the formater mode are expected to be implemented. If a call is propagated to this parent
+	/// class, the functions do nothing or silently return empty string respectively.
+	///
+{
+public:
+	typedef SharedPtr<RowFormatter>              Ptr;
+	typedef std::vector<std::string>             NameVec;
+	typedef SharedPtr<std::vector<std::string> > NameVecPtr;
+	typedef std::vector<Poco::Dynamic::Var>      ValueVec;
+
+	static const int INVALID_ROW_COUNT = -1;
+
+	enum Mode
+	{
+		FORMAT_PROGRESSIVE,
+		FORMAT_BULK
+	};
+
+	RowFormatter(const std::string& prefix = "",
+		const std::string& postfix = "",
+		Mode mode = FORMAT_PROGRESSIVE);
+		/// Creates the RowFormatter and sets the prefix and postfix to specified values.
+
+	virtual ~RowFormatter();
+		/// Destroys the RowFormatter.
+
+	virtual std::string& formatNames(const NameVecPtr pNames, std::string& formattedNames);
+		/// Should be implemented to format the row fields names and return the formatted string.
+		/// The default implementation clears the names string and returns it.
+
+	virtual void formatNames(const NameVecPtr pNames);
+		/// Should be implemented to format the row fields names.
+		/// The default implementation does nothing.
+
+	virtual std::string& formatValues(const ValueVec& vals, std::string& formattedValues);
+		/// Should be implemented to format the row fields values and return the formatted string.
+		/// The default implementation clears the values string and returns it.
+
+	virtual void formatValues(const ValueVec& vals);
+		/// Should be implemented to format the row fields values.
+		/// The default implementation does nothing.
+
+	virtual const std::string& toString();
+		/// Throws NotImplementedException. Formatters operating in bulk mode should 
+		/// implement this member function to return valid pointer to the formatted result.
+
+	virtual int rowCount() const;
+		/// Returns INVALID_ROW_COUNT. Must be implemented by inheriting classes
+		/// which maintain count of processed rows.
+
+	int getTotalRowCount() const;
+		/// Returns zero. Must be implemented by inheriting classes.
+		/// Typically, total row count shall be set up front through
+		/// setTotalRowCount() call.
+
+	void setTotalRowCount(int count);
+		/// Sets total row count.
+
+	virtual const std::string& prefix() const;
+		/// Returns prefix string;
+
+	virtual const std::string& postfix() const;
+		/// Returns postfix string;
+
+	void reset();
+		/// Resets the formatter by setting prefix and postfix
+		/// to empty strings and row count to INVALID_ROW_COUNT.
+
+	Mode getMode() const;
+		/// Returns the formater mode.
+
+	void setMode(Mode mode);
+		/// Sets the fromatter mode.
+
+protected:
+
+	void setPrefix(const std::string& prefix);
+		/// Sets the prefix for the formatter.
+
+	void setPostfix(const std::string& postfix);
+		/// Sets the postfix for the formatter
+
+private:
+
+	mutable std::string _prefix;
+	mutable std::string _postfix;
+	Mode                _mode;
+	int                 _totalRowCount;
+};
+
+
+///
+/// inlines
+///
+inline int RowFormatter::rowCount() const
+{
+	return INVALID_ROW_COUNT;
+}
+
+
+inline int RowFormatter::getTotalRowCount() const
+{
+	return _totalRowCount;
+}
+
+
+inline void RowFormatter::setTotalRowCount(int count)
+{
+	_totalRowCount = count;
+}
+
+
+inline void RowFormatter::setPrefix(const std::string& prefix)
+{
+	_prefix = prefix;
+}
+
+
+inline void RowFormatter::setPostfix(const std::string& postfix)
+{
+	_postfix = postfix;
+}
+
+
+inline const std::string& RowFormatter::prefix() const
+{
+	return _prefix;
+}
+
+
+inline const std::string& RowFormatter::postfix() const
+{
+	return _postfix;
+}
+
+
+inline RowFormatter::Mode RowFormatter::getMode() const
+{
+	return _mode;
+}
+
+
+inline void RowFormatter::setMode(Mode mode)
+{
+	_mode = mode;
+}
+
+
+namespace Keywords {
+
+
+template <typename T>
+inline RowFormatter::Ptr format(const T& formatter)
+	/// Utility function used to pass formatter to the statement.
+{
+	return new T(formatter);
+}
+
+
+} // namespace Keywords
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_RowFormatter_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/RowIterator.h b/base/poco/Data/include/Poco/Data/RowIterator.h
new file mode 100644
index 00000000000..32ca45bd437
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/RowIterator.h
@@ -0,0 +1,150 @@
+//
+// RowIterator.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  RowIterator
+//
+// Definition of the RowIterator class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_RowIterator_INCLUDED
+#define Data_RowIterator_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/Row.h"
+#include "Poco/Dynamic/Var.h"
+#include <iterator>
+#include <algorithm>
+
+
+namespace Poco {
+namespace Data {
+
+
+class RecordSet;
+
+
+class Data_API RowIterator
+	/// RowIterator class.
+{
+public:
+	typedef std::bidirectional_iterator_tag iterator_category;
+	typedef Row                             value_type;
+	typedef std::ptrdiff_t                  difference_type;
+	typedef Row*                            pointer;
+	typedef Row&                            reference;
+
+	static const std::size_t POSITION_END;
+		/// End position indicator.
+
+	RowIterator(RecordSet* pRecordSet, bool positionEnd);
+		/// Creates the RowIterator and positions it at the end of
+		/// the recordset if positionEnd is true. Otherwise, it is
+		/// positioned at the beginning.
+
+	RowIterator(const RowIterator& other);
+		/// Creates a copy of other RowIterator.
+
+	~RowIterator();
+		/// Destroys the RowIterator.
+
+	RowIterator& operator = (const RowIterator& other);
+		/// Assigns the other RowIterator.
+
+	bool operator == (const RowIterator& other) const;
+		/// Equality operator.
+
+	bool operator != (const RowIterator& other) const;
+		/// Inequality operator.
+
+	Row& operator * () const;
+		/// Returns reference to the current row.
+
+	Row* operator -> () const;
+		/// Returns pointer to the current row.
+
+	const RowIterator& operator ++ () const;
+		/// Advances by one position and returns current position.
+
+	RowIterator operator ++ (int) const;
+		/// Advances by one position and returns copy of the iterator with 
+		/// previous current position.
+
+	const RowIterator& operator -- () const;
+		/// Goes back by one position and returns copy of the iterator with 
+		/// previous current position.
+
+	RowIterator operator -- (int) const;
+		/// Goes back by one position and returns previous current position.
+
+	RowIterator operator + (std::size_t diff) const;
+		/// Returns a copy the RowIterator advanced by diff positions.
+
+	RowIterator operator - (std::size_t diff) const;
+		/// Returns a copy the RowIterator backed by diff positions.
+		/// Throws RangeException if diff is larger than current position.
+
+	void swap(RowIterator& other);
+		/// Swaps the RowIterator with another one.
+
+private:
+	RowIterator();
+
+	void increment() const;
+		/// Increments the iterator position by one. 
+		/// Throws RangeException if position is out of range.
+
+	void decrement() const;
+		/// Decrements the iterator position by one. 
+		/// Throws RangeException if position is out of range.
+
+	void setPosition(std::size_t pos) const;
+		/// Sets the iterator position. 
+		/// Throws RangeException if position is out of range.
+
+	RecordSet*          _pRecordSet;
+	mutable std::size_t _position;
+};
+
+
+///
+/// inlines
+///
+
+
+inline bool RowIterator::operator == (const RowIterator& other) const
+{
+	return _pRecordSet == other._pRecordSet && _position == other._position;
+}
+
+
+inline bool RowIterator::operator != (const RowIterator& other) const
+{
+	return _pRecordSet != other._pRecordSet || _position != other._position;
+}
+
+
+} } // namespace Poco::Data
+
+
+namespace std
+{
+	template<>
+	inline void swap<Poco::Data::RowIterator>(Poco::Data::RowIterator& s1, 
+		Poco::Data::RowIterator& s2)
+		/// Full template specalization of std:::swap for RowIterator
+	{
+		s1.swap(s2);
+	}
+}
+
+
+#endif // Data_RowIterator_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/SQLChannel.h b/base/poco/Data/include/Poco/Data/SQLChannel.h
new file mode 100644
index 00000000000..e76d67626a3
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/SQLChannel.h
@@ -0,0 +1,217 @@
+//
+// SQLChannel.h
+//
+// Library: Data
+// Package: Logging
+// Module:  SQLChannel
+//
+// Definition of the SQLChannel class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_SQLChannel_INCLUDED
+#define Data_SQLChannel_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/Connector.h"
+#include "Poco/Data/Session.h"
+#include "Poco/Data/Statement.h"
+#include "Poco/Data/ArchiveStrategy.h"
+#include "Poco/Channel.h"
+#include "Poco/Message.h"
+#include "Poco/AutoPtr.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API SQLChannel: public Poco::Channel
+	/// This Channel implements logging to a SQL database.
+	/// The channel is dependent on the schema. The DDL for
+	/// table creation (subject to target DDL dialect dependent 
+	/// modifications) is:
+	///
+	/// "CREATE TABLE T_POCO_LOG (Source VARCHAR, 
+	///		Name VARCHAR, 
+	///		ProcessId INTEGER, 
+	///		Thread VARCHAR, 
+	///		ThreadId INTEGER, 
+	///		Priority INTEGER, 
+	///		Text VARCHAR, 
+	///		DateTime DATE)"
+	///
+	/// The table name is configurable through "table" property. 
+	/// Other than DateTime filed name used for optiona time-based archiving purposes, currently the 
+	/// field names are not mandated. However, it is recomended to use names as specified above.
+	/// 
+	/// To provide as non-intrusive operation as possbile, the log entries are cached and 
+	/// inserted into the target database asynchronously by default . The blocking, however, will occur 
+	/// before the next entry insertion with default timeout of 1 second. The default settings can be 
+	/// overriden (see async, timeout and throw properties for details).
+	/// If throw property is false, insertion timeouts are ignored, otherwise a TimeoutException is thrown.
+	/// To force insertion of every entry, set timeout to 0. This setting, however, introduces
+	/// a risk of long blocking periods in case of remote server communication delays.
+{
+public:
+	SQLChannel();
+		/// Creates SQLChannel.
+
+	SQLChannel(const std::string& connector, 
+		const std::string& connect,
+		const std::string& name = "-");
+		/// Creates a SQLChannel with the given connector, connect string, timeout, table and name.
+		/// The connector must be already registered.
+	
+	void open();
+		/// Opens the SQLChannel.
+		
+	void close();
+		/// Closes the SQLChannel.
+		
+	void log(const Message& msg);
+		/// Sends the message's text to the syslog service.
+		
+	void setProperty(const std::string& name, const std::string& value);
+		/// Sets the property with the given value.
+		///
+		/// The following properties are supported:
+		///     * name:      The name used to identify the source of log messages.
+		///                  Defaults to "-".
+		///
+		///     * target:    The target data storage type ("SQLite", "ODBC", ...).
+		///
+		///     * connector: The target data storage connector name.
+		///
+		///     * connect:   The target data storage connection string.
+		///
+		///     * table:     Destination log table name. Defaults to "T_POCO_LOG".
+		///                  Table must exist in the target database.
+		///
+		///     * keep:      Max row age for the log table. To disable archiving,
+		///                  set this property to empty string or "forever".
+		///
+		///     * archive:   Archive table name. Defaults to "T_POCO_LOG_ARCHIVE".
+		///                  Table must exist in the target database. To disable archiving,
+		///                  set this property to empty string.
+		///
+		///     * async:     Indicates asynchronous execution. When excuting asynchronously,
+		///                  messages are sent to the target using asyncronous execution.
+		///                  However, prior to the next message being processed and sent to
+		///                  the target, the previous operation must have been either completed 
+		///                  or timed out (see timeout and throw properties for details on
+		///                  how abnormal conditos are handled).
+		///
+		///     * timeout:   Timeout (ms) to wait for previous log operation completion.
+		///                  Values "0" and "" mean no timeout. Only valid when logging
+		///                  is asynchronous, otherwise ignored.
+		///
+		///     * throw:     Boolean value indicating whether to throw in case of timeout.
+		///                  Setting this property to false may result in log entries being lost.
+		///                  True values are (case insensitive) "true", "t", "yes", "y".
+		///                  Anything else yields false.
+		
+	std::string getProperty(const std::string& name) const;
+		/// Returns the value of the property with the given name.
+
+	std::size_t wait();
+		/// Waits for the completion of the previous operation and returns
+		/// the result. If chanel is in synchronous mode, returns 0 immediately.
+
+	static void registerChannel();
+		/// Registers the channel with the global LoggingFactory.
+
+	static const std::string PROP_CONNECT;
+	static const std::string PROP_CONNECTOR;
+	static const std::string PROP_NAME;
+	static const std::string PROP_TABLE;
+	static const std::string PROP_ARCHIVE_TABLE;
+	static const std::string PROP_MAX_AGE;
+	static const std::string PROP_ASYNC;
+	static const std::string PROP_TIMEOUT;
+	static const std::string PROP_THROW;
+
+protected:
+	~SQLChannel();
+
+private:
+	typedef Poco::SharedPtr<Session>         SessionPtr;
+	typedef Poco::SharedPtr<Statement>       StatementPtr;
+	typedef Poco::Message::Priority          Priority;
+	typedef Poco::SharedPtr<ArchiveStrategy> StrategyPtr;
+
+	void initLogStatement();
+		/// Initiallizes the log statement.
+
+	void initArchiveStatements();
+	/// Initiallizes the archive statement.
+
+	void logAsync(const Message& msg);
+		/// Waits for previous operation completion and
+		/// calls logSync(). If the previous operation times out,
+		/// and _throw is true, TimeoutException is thrown, oterwise
+		/// the timeout is ignored and log entry is lost.
+
+	void logSync(const Message& msg);
+		/// Inserts the message in the target database.
+
+	bool isTrue(const std::string& value) const;
+		/// Returns true is value is "true", "t", "yes" or "y".
+		/// Case insensitive.
+
+	std::string  _connector;
+	std::string  _connect;
+	SessionPtr   _pSession;
+	StatementPtr _pLogStatement;
+	std::string  _name;
+	std::string  _table;
+	int          _timeout;
+	bool         _throw;
+	bool         _async;
+	
+	// members for log entry cache (needed for async mode)
+	std::string _source;
+	long        _pid;
+	std::string _thread;
+	long        _tid;
+	int         _priority;
+	std::string _text;
+	DateTime    _dateTime;
+
+	StrategyPtr _pArchiveStrategy;
+};
+
+
+//
+// inlines
+//
+
+inline std::size_t SQLChannel::wait()
+{
+	if (_async && _pLogStatement) 
+		return _pLogStatement->wait(_timeout);
+	
+	return 0;
+}
+
+
+inline bool SQLChannel::isTrue(const std::string& value) const
+{
+	return ((0 == icompare(value, "true")) ||
+			(0 == icompare(value, "t")) ||
+			(0 == icompare(value, "yes")) ||
+			(0 == icompare(value, "y")));
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_SQLChannel_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/Session.h b/base/poco/Data/include/Poco/Data/Session.h
new file mode 100644
index 00000000000..bf96efefa94
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/Session.h
@@ -0,0 +1,494 @@
+//
+// Session.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  Session
+//
+// Definition of the Session class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_Session_INCLUDED
+#define Data_Session_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/SessionImpl.h"
+#include "Poco/Data/Statement.h"
+#include "Poco/Data/StatementCreator.h"
+#include "Poco/Data/Binding.h"
+#include "Poco/AutoPtr.h"
+#include "Poco/Any.h"
+#include <algorithm>
+
+
+namespace Poco {
+namespace Data {
+
+
+class StatementImpl;
+
+
+class Data_API Session
+	/// A Session holds a connection to a Database and creates Statement objects.
+	///
+	/// Sessions are always created via the SessionFactory:
+	///    
+	///     Session ses(SessionFactory::instance().create(connectorKey, connectionString));
+	///    
+	/// where the first param presents the type of session one wants to create (e.g., for SQLite one would choose "SQLite",
+	/// for ODBC the key is "ODBC") and the second param is the connection string that the session implementation 
+	/// requires to connect to the database. The format of the connection string is specific to the actual connector.
+	///
+	/// A simpler form to create the session is to pass the connector key and connection string directly to
+	/// the Session constructor.
+	///
+	/// A concrete example to open an SQLite database stored in the file "dummy.db" would be
+	///    
+	///     Session ses("SQLite", "dummy.db");
+	///    
+	/// Via a Session one can create two different types of statements. First, statements that should only be executed once and immediately, and
+	/// second, statements that should be executed multiple times, using a separate execute() call.
+	/// The simple one is immediate execution:
+	///    
+	///     ses << "CREATE TABLE Dummy (data INTEGER(10))", now;
+	///
+	/// The now at the end of the statement is required, otherwise the statement
+	/// would not be executed.
+	///    
+	/// If one wants to reuse a Statement (and avoid the overhead of repeatedly parsing an SQL statement)
+	/// one uses an explicit Statement object and its execute() method:
+	///    
+	///     int i = 0;
+	///     Statement stmt = (ses << "INSERT INTO Dummy VALUES(:data)", use(i));
+	///    
+	///     for (i = 0; i < 100; ++i)
+	///     {
+	///         stmt.execute();
+	///     }
+	///    
+	/// The above example assigns the variable i to the ":data" placeholder in the SQL query. The query is parsed and compiled exactly
+	/// once, but executed 100 times. At the end the values 0 to 99 will be present in the Table "DUMMY".
+	///
+	/// A faster implementaton of the above code will simply create a vector of int
+	/// and use the vector as parameter to the use clause (you could also use set or multiset instead):
+	///    
+	///     std::vector<int> data;
+	///     for (int i = 0; i < 100; ++i)
+	///     {
+	///         data.push_back(i);
+	///     }
+	///     ses << "INSERT INTO Dummy VALUES(:data)", use(data);
+	///
+	/// NEVER try to bind to an empty collection. This will give a BindingException at run-time!
+	///
+	/// Retrieving data from a database works similar, you could use simple data types, vectors, sets or multiset as your targets:
+	///
+	///     std::set<int> retData;
+	///     ses << "SELECT * FROM Dummy", into(retData));
+	///
+	/// Due to the blocking nature of the above call it is possible to partition the data retrieval into chunks by setting a limit to
+	/// the maximum number of rows retrieved from the database:
+	///
+	///     std::set<int> retData;
+	///     Statement stmt = (ses << "SELECT * FROM Dummy", into(retData), limit(50));
+	///     while (!stmt.done())
+	///     {
+	///         stmt.execute();
+	///     }
+	///
+	/// The "into" keyword is used to inform the statement where output results should be placed. The limit value ensures
+	/// that during each run at most 50 rows are retrieved. Assuming Dummy contains 100 rows, retData will contain 50 
+	/// elements after the first run and 100 after the second run, i.e.
+	/// the collection is not cleared between consecutive runs. After the second execute stmt.done() will return true.
+	///
+	/// A prepared Statement will behave exactly the same but a further call to execute() will simply reset the Statement, 
+	/// execute it again and append more data to the result set.
+	///
+	/// Note that it is possible to append several "bind" or "into" clauses to the statement. Theoretically, one could also have several
+	/// limit clauses but only the last one that was added will be effective. 
+	/// Also several preconditions must be met concerning binds and intos.
+	/// Take the following example:
+	///
+	///     ses << "CREATE TABLE Person (LastName VARCHAR(30), FirstName VARCHAR, Age INTEGER(3))";
+	///     std::vector<std::string> nameVec; // [...] add some elements
+	///     std::vector<int> ageVec; // [...] add some elements
+	///     ses << "INSERT INTO Person (LastName, Age) VALUES(:ln, :age)", use(nameVec), use(ageVec);
+	///
+	/// The size of all use parameters MUST be the same, otherwise an exception is thrown. Furthermore,
+	/// the amount of use clauses must match the number of wildcards in the query (to be more precise: 
+	/// each binding has a numberOfColumnsHandled() value which defaults to 1. The sum of all these values 
+	/// must match the wildcard count in the query.
+	/// However, this is only important if you have written your own TypeHandler specializations.
+	/// If you plan to map complex object types to tables see the TypeHandler documentation.
+	/// For now, we simply assume we have written one TypeHandler for Person objects. Instead of having n different vectors,
+	/// we have one collection:
+	///
+	///     std::vector<Person> people; // [...] add some elements
+	///     ses << "INSERT INTO Person (LastName, FirstName, Age) VALUES(:ln, :fn, :age)", use(people);
+	///
+	/// which will insert all Person objects from the people vector to the database (and again, you can use set, multiset too,
+	/// even map and multimap if Person provides an operator() which returns the key for the map).
+	/// The same works for a SELECT statement with "into" clauses:
+	///
+	///     std::vector<Person> people;
+	///     ses << "SELECT * FROM PERSON", into(people);
+	/// 
+	/// Mixing constants or variables with manipulators is allowed provided there are corresponding placeholders for the constants provided in
+	/// the SQL string, such as in following example:
+	///
+	///     std::vector<Person> people;
+	///     ses << "SELECT * FROM %s", into(people), "PERSON";
+	/// 
+	/// Formatting only kicks in if there are values to be injected into the SQL string, otherwise it is skipped.
+	/// If the formatting will occur and the percent sign is part of the query itself, it can be passed to the query by entering it twice (%%).
+	/// However, if no formatting is used, one percent sign is sufficient as the string will be passed unaltered.
+	/// For complete list of supported data types with their respective specifications, see the documentation for format in Foundation.
+{
+public:
+	static const std::size_t LOGIN_TIMEOUT_DEFAULT = SessionImpl::LOGIN_TIMEOUT_DEFAULT;
+	static const Poco::UInt32 TRANSACTION_READ_UNCOMMITTED = 0x00000001L;
+	static const Poco::UInt32 TRANSACTION_READ_COMMITTED   = 0x00000002L;
+	static const Poco::UInt32 TRANSACTION_REPEATABLE_READ  = 0x00000004L;
+	static const Poco::UInt32 TRANSACTION_SERIALIZABLE     = 0x00000008L;
+
+	Session(Poco::AutoPtr<SessionImpl> ptrImpl);
+		/// Creates the Session.
+
+	Session(const std::string& connector,
+		const std::string& connectionString,
+		std::size_t timeout = LOGIN_TIMEOUT_DEFAULT);
+		/// Creates a new session, using the given connector (which must have
+		/// been registered), and connectionString.
+
+	Session(const std::string& connection,
+		std::size_t timeout = LOGIN_TIMEOUT_DEFAULT);
+		/// Creates a new session, using the given connection (must be in
+		/// "connection:///connectionString" format).
+
+	Session(const Session&);
+		/// Creates a session by copying another one.
+
+	Session& operator = (const Session&);
+		/// Assignment operator.
+
+	~Session();
+		/// Destroys the Session.
+
+	void swap(Session& other);
+		/// Swaps the session with another one.
+
+	template <typename T>
+	Statement operator << (const T& t)
+		/// Creates a Statement with the given data as SQLContent
+	{
+		return _statementCreator << t;
+	}
+
+	StatementImpl* createStatementImpl();
+		/// Creates a StatementImpl.
+
+	void open(const std::string& connect = "");
+		/// Opens the session using the supplied string.
+		/// Can also be used with default empty string to 
+		/// reconnect a disconnected session.
+		/// If the connection is not established, 
+		/// a ConnectionFailedException is thrown. 
+		/// Zero timout means indefinite
+
+	void close();
+		/// Closes the session.
+
+	bool isConnected();
+		/// Returns true iff session is connected, false otherwise.
+
+	void reconnect();
+		/// Closes the session and opens it.
+
+	void setLoginTimeout(std::size_t timeout);
+		/// Sets the session login timeout value.
+
+	std::size_t getLoginTimeout() const;
+		/// Returns the session login timeout value.
+
+	void setConnectionTimeout(std::size_t timeout);
+		/// Sets the session connection timeout value.
+
+	std::size_t getConnectionTimeout();
+		/// Returns the session connection timeout value.
+
+	void begin();
+		/// Starts a transaction.
+
+	void commit();
+		/// Commits and ends a transaction.
+
+	void rollback();
+		/// Rolls back and ends a transaction.
+
+	bool canTransact();
+		/// Returns true if session has transaction capabilities.
+
+	bool isTransaction();
+		/// Returns true iff a transaction is in progress, false otherwise.
+
+	void setTransactionIsolation(Poco::UInt32);
+		/// Sets the transaction isolation level.
+
+	Poco::UInt32 getTransactionIsolation();
+		/// Returns the transaction isolation level.
+
+	bool hasTransactionIsolation(Poco::UInt32 ti);
+		/// Returns true iff the transaction isolation level corresponding
+		/// to the supplied bitmask is supported.
+
+	bool isTransactionIsolation(Poco::UInt32 ti);
+		/// Returns true iff the transaction isolation level corresponds
+		/// to the supplied bitmask.
+
+	std::string connector() const;
+		/// Returns the connector name for this session.
+
+	std::string uri() const;
+		/// Returns the URI for this session.
+
+	static std::string uri(const std::string& connector,
+		const std::string& connectionString);
+		/// Utility function that teturns the URI formatted from supplied 
+		/// arguments as "connector:///connectionString".
+
+	void setFeature(const std::string& name, bool state);
+		/// Set the state of a feature.
+		///
+		/// Features are a generic extension mechanism for session implementations.
+		/// and are defined by the underlying SessionImpl instance.
+		///
+		/// Throws a NotSupportedException if the requested feature is
+		/// not supported by the underlying implementation.
+	
+	bool getFeature(const std::string& name) const;
+		/// Look up the state of a feature.
+		///
+		/// Features are a generic extension mechanism for session implementations.
+		/// and are defined by the underlying SessionImpl instance.
+		///
+		/// Throws a NotSupportedException if the requested feature is
+		/// not supported by the underlying implementation.
+
+	void setProperty(const std::string& name, const Poco::Any& value);
+		/// Set the value of a property.
+		///
+		/// Properties are a generic extension mechanism for session implementations.
+		/// and are defined by the underlying SessionImpl instance.
+		///
+		/// Throws a NotSupportedException if the requested property is
+		/// not supported by the underlying implementation.
+
+	Poco::Any getProperty(const std::string& name) const;
+		/// Look up the value of a property.
+		///
+		/// Properties are a generic extension mechanism for session implementations.
+		/// and are defined by the underlying SessionImpl instance.
+		///
+		/// Throws a NotSupportedException if the requested property is
+		/// not supported by the underlying implementation.
+
+	SessionImpl* impl();
+		/// Returns a pointer to the underlying SessionImpl.
+
+private:
+	Session();
+
+	Poco::AutoPtr<SessionImpl> _pImpl;
+	StatementCreator           _statementCreator;
+};
+
+
+//
+// inlines
+//
+inline StatementImpl* Session::createStatementImpl()
+{
+	return _pImpl->createStatementImpl();
+}
+
+
+inline void Session::open(const std::string& connect)
+{
+	_pImpl->open(connect);
+}
+
+
+inline void Session::close()
+{
+	_pImpl->close();
+}
+
+
+inline bool Session::isConnected()
+{
+	return _pImpl->isConnected();
+}
+
+
+inline void Session::reconnect()
+{
+	_pImpl->reconnect();
+}
+
+
+inline void Session::setLoginTimeout(std::size_t timeout)
+{
+	_pImpl->setLoginTimeout(timeout);
+}
+
+
+inline std::size_t Session::getLoginTimeout() const
+{
+	return _pImpl->getLoginTimeout();
+}
+
+
+inline void Session::setConnectionTimeout(std::size_t timeout)
+{
+	_pImpl->setConnectionTimeout(timeout);
+}
+
+
+inline std::size_t Session::getConnectionTimeout()
+{
+	return _pImpl->getConnectionTimeout();
+}
+
+
+inline void Session::begin()
+{
+	return _pImpl->begin();
+}
+
+
+inline void Session::commit()
+{
+	return _pImpl->commit();
+}
+
+
+inline void Session::rollback()
+{
+	return _pImpl->rollback();
+}
+
+
+inline bool Session::canTransact()
+{
+	return _pImpl->canTransact();
+}
+
+
+inline bool Session::isTransaction()
+{
+	return _pImpl->isTransaction();
+}
+
+
+inline void Session::setTransactionIsolation(Poco::UInt32 ti)
+{
+	_pImpl->setTransactionIsolation(ti);
+}
+
+
+inline Poco::UInt32 Session::getTransactionIsolation()
+{
+	return _pImpl->getTransactionIsolation();
+}
+
+
+inline bool Session::hasTransactionIsolation(Poco::UInt32 ti)
+{
+	return _pImpl->hasTransactionIsolation(ti);
+}
+
+
+inline bool Session::isTransactionIsolation(Poco::UInt32 ti)
+{
+	return _pImpl->isTransactionIsolation(ti);
+}
+
+
+inline std::string Session::connector() const
+{
+	return _pImpl->connectorName();
+}
+
+
+inline std::string Session::uri(const std::string& connector,
+	const std::string& connectionString)
+{
+	return SessionImpl::uri(connector, connectionString);
+}
+
+
+inline std::string Session::uri() const
+{
+	return _pImpl->uri();
+}
+
+
+inline void Session::setFeature(const std::string& name, bool state)
+{
+	_pImpl->setFeature(name, state);
+}
+
+
+inline bool Session::getFeature(const std::string& name) const
+{
+	return const_cast<SessionImpl*>(_pImpl.get())->getFeature(name);
+}
+
+
+inline void Session::setProperty(const std::string& name, const Poco::Any& value)
+{
+	_pImpl->setProperty(name, value);
+}
+
+
+inline Poco::Any Session::getProperty(const std::string& name) const
+{
+	return const_cast<SessionImpl*>(_pImpl.get())->getProperty(name);
+}
+
+
+inline SessionImpl* Session::impl()
+{
+	return _pImpl;
+}
+
+
+inline void swap(Session& s1, Session& s2)
+{
+	s1.swap(s2);
+}
+
+
+} } // namespace Poco::Data
+
+
+namespace std
+{
+	template<>
+	inline void swap<Poco::Data::Session>(Poco::Data::Session& s1, 
+		Poco::Data::Session& s2)
+		/// Full template specalization of std:::swap for Session
+	{
+		s1.swap(s2);
+	}
+}
+
+
+#endif // Data_Session_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/SessionFactory.h b/base/poco/Data/include/Poco/Data/SessionFactory.h
new file mode 100644
index 00000000000..0185a8a3816
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/SessionFactory.h
@@ -0,0 +1,99 @@
+//
+// SessionFactory.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  SessionFactory
+//
+// Definition of the SessionFactory class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_SessionFactory_INCLUDED
+#define Data_SessionFactory_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/Connector.h"
+#include "Poco/Data/Session.h"
+#include "Poco/Mutex.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/String.h"
+#include <map>
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API SessionFactory
+	/// A SessionFactory is a singleton class that stores Connectors and allows to 
+	/// create Sessions of the required type:
+	///    
+	///     Session ses(SessionFactory::instance().create(connector, connectionString));
+	///    
+	/// where the first param presents the type of session one wants to create (e.g. for SQLite one would choose "SQLite")
+	/// and the second param is the connection string that the connector requires to connect to the database.
+	///
+	/// A concrete example to open an SQLite database stored in the file "dummy.db" would be
+	///    
+	///     Session ses(SessionFactory::instance().create(SQLite::Connector::KEY, "dummy.db"));
+	///
+	/// An even simpler way to create a session is to use the two argument constructor of Session, which
+	/// automatically invokes the SessionFactory:
+	///
+	///      Session ses("SQLite", "dummy.db");
+{
+public:
+	
+	static SessionFactory& instance();
+		/// returns the static instance of the singleton.
+
+	void add(Connector* pIn);
+		/// Registers a Connector under its key at the factory. If a registration for that
+		/// key is already active, the first registration will be kept, only its reference count will be increased.
+		/// Always takes ownership of parameter pIn.
+
+	void remove(const std::string& key);
+		/// Lowers the reference count for the Connector registered under that key. If the count reaches zero,
+		/// the object is removed.
+
+	Session create(const std::string& key,
+		const std::string& connectionString,
+		std::size_t timeout = Session::LOGIN_TIMEOUT_DEFAULT);
+		/// Creates a Session for the given key with the connectionString. Throws an Poco:Data::UnknownDataBaseException
+		/// if no Connector is registered for that key.
+
+	Session create(const std::string& uri,
+		std::size_t timeout = Session::LOGIN_TIMEOUT_DEFAULT);
+		/// Creates a Session for the given URI (must be in key:///connectionString format). 
+		/// Throws a Poco:Data::UnknownDataBaseException if no Connector is registered for the key.
+
+private:
+	SessionFactory();
+	~SessionFactory();
+	SessionFactory(const SessionFactory&);
+	SessionFactory& operator = (const SessionFactory&);
+
+	struct SessionInfo
+	{
+		int cnt;
+		Poco::SharedPtr<Connector> ptrSI;
+		SessionInfo(Connector* pSI);
+	};
+	
+	typedef std::map<std::string, SessionInfo, Poco::CILess> Connectors;
+	Connectors      _connectors;
+	Poco::FastMutex _mutex;
+};
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_SessionFactory_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/SessionImpl.h b/base/poco/Data/include/Poco/Data/SessionImpl.h
new file mode 100644
index 00000000000..223c2bf978b
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/SessionImpl.h
@@ -0,0 +1,221 @@
+//
+// SessionImpl.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  SessionImpl
+//
+// Definition of the SessionImpl class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_SessionImpl_INCLUDED
+#define Data_SessionImpl_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/String.h"
+#include "Poco/Format.h"
+#include "Poco/Any.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+class StatementImpl;
+
+
+class Data_API SessionImpl: public Poco::RefCountedObject
+	/// Interface for Session functionality that subclasses must extend. 
+	/// SessionImpl objects are noncopyable.
+{
+public:
+	static const std::size_t LOGIN_TIMEOUT_INFINITE = 0;
+		/// Infinite connection/login timeout.
+
+	static const std::size_t LOGIN_TIMEOUT_DEFAULT = 60;
+		/// Default connection/login timeout in seconds.
+
+	static const std::size_t CONNECTION_TIMEOUT_INFINITE = 0;
+		/// Infinite connection/login timeout.
+
+	static const std::size_t CONNECTION_TIMEOUT_DEFAULT = CONNECTION_TIMEOUT_INFINITE;
+		/// Default connection/login timeout in seconds.
+
+	SessionImpl(const std::string& connectionString,
+		std::size_t timeout = LOGIN_TIMEOUT_DEFAULT);
+		/// Creates the SessionImpl.
+
+	virtual ~SessionImpl();
+		/// Destroys the SessionImpl.
+
+	virtual StatementImpl* createStatementImpl() = 0;
+		/// Creates a StatementImpl.
+
+	virtual void open(const std::string& connectionString = "") = 0;
+		/// Opens the session using the supplied string.
+		/// Can also be used with default empty string to reconnect 
+		/// a disconnected session.
+		/// If the connection is not established within requested timeout 
+		/// (specified in seconds), a ConnectionFailedException is thrown. 
+		/// Zero timout means indefinite
+
+	virtual void close() = 0;
+		/// Closes the connection.
+
+	virtual bool isConnected() = 0;
+		/// Returns true if session is connected, false otherwise.
+
+	void setLoginTimeout(std::size_t timeout);
+		/// Sets the session login timeout value.
+
+	std::size_t getLoginTimeout() const;
+		/// Returns the session login timeout value.
+
+	virtual void setConnectionTimeout(std::size_t timeout) = 0;
+		/// Sets the session connection timeout value.
+
+	virtual std::size_t getConnectionTimeout() = 0;
+		/// Returns the session connection timeout value.
+
+	void reconnect();
+		/// Closes the connection and opens it again.
+
+	virtual void begin() = 0;
+		/// Starts a transaction.
+
+	virtual void commit() = 0;
+		/// Commits and ends a transaction.
+
+	virtual void rollback() = 0;
+		/// Aborts a transaction.
+
+	virtual bool canTransact() = 0;
+		/// Returns true if session has transaction capabilities.
+
+	virtual bool isTransaction() = 0;
+		/// Returns true iff a transaction is a transaction is in progress, false otherwise.
+
+	virtual void setTransactionIsolation(Poco::UInt32) = 0;
+		/// Sets the transaction isolation level.
+
+	virtual Poco::UInt32 getTransactionIsolation() = 0;
+		/// Returns the transaction isolation level.
+
+	virtual bool hasTransactionIsolation(Poco::UInt32) = 0;
+		/// Returns true iff the transaction isolation level corresponding
+		/// to the supplied bitmask is supported.
+
+	virtual bool isTransactionIsolation(Poco::UInt32) = 0;
+		/// Returns true iff the transaction isolation level corresponds
+		/// to the supplied bitmask.
+
+	virtual const std::string& connectorName() const = 0;
+		/// Returns the name of the connector.
+
+	const std::string& connectionString() const;
+		/// Returns the connection string.
+
+	static std::string uri(const std::string& connector, const std::string& connectionString);
+		/// Returns formatted URI.
+
+	std::string uri() const;
+		/// Returns the URI for this session.
+
+	virtual void setFeature(const std::string& name, bool state) = 0;
+		/// Set the state of a feature.
+		///
+		/// Features are a generic extension mechanism for session implementations.
+		/// and are defined by the underlying SessionImpl instance.
+		///
+		/// Throws a NotSupportedException if the requested feature is
+		/// not supported by the underlying implementation.
+	
+	virtual bool getFeature(const std::string& name) = 0;
+		/// Look up the state of a feature.
+		///
+		/// Features are a generic extension mechanism for session implementations.
+		/// and are defined by the underlying SessionImpl instance.
+		///
+		/// Throws a NotSupportedException if the requested feature is
+		/// not supported by the underlying implementation.
+
+	virtual void setProperty(const std::string& name, const Poco::Any& value) = 0;
+		/// Set the value of a property.
+		///
+		/// Properties are a generic extension mechanism for session implementations.
+		/// and are defined by the underlying SessionImpl instance.
+		///
+		/// Throws a NotSupportedException if the requested property is
+		/// not supported by the underlying implementation.
+
+	virtual Poco::Any getProperty(const std::string& name) = 0;
+		/// Look up the value of a property.
+		///
+		/// Properties are a generic extension mechanism for session implementations.
+		/// and are defined by the underlying SessionImpl instance.
+		///
+		/// Throws a NotSupportedException if the requested property is
+		/// not supported by the underlying implementation.
+
+protected:
+	void setConnectionString(const std::string& connectionString);
+		/// Sets the connection string. Should only be called on
+		/// disconnetced sessions. Throws InvalidAccessException when called on
+		/// a connected session.
+
+private:
+	SessionImpl();
+	SessionImpl(const SessionImpl&);
+	SessionImpl& operator = (const SessionImpl&);
+
+	std::string _connectionString;
+	std::size_t _loginTimeout;
+};
+
+
+//
+// inlines
+//
+inline const std::string& SessionImpl::connectionString() const
+{
+	return _connectionString;
+}
+
+
+inline void SessionImpl::setLoginTimeout(std::size_t timeout)
+{
+	_loginTimeout = timeout;
+}
+
+
+inline std::size_t SessionImpl::getLoginTimeout() const
+{
+	return _loginTimeout;
+}
+
+
+inline std::string SessionImpl::uri(const std::string& connector,
+	const std::string& connectionString)
+{
+	return format("%s:///%s", connector, connectionString);
+}
+
+
+inline std::string SessionImpl::uri() const
+{
+	return uri(connectorName(), connectionString());
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_SessionImpl_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/SessionPool.h b/base/poco/Data/include/Poco/Data/SessionPool.h
new file mode 100644
index 00000000000..6994c331e6f
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/SessionPool.h
@@ -0,0 +1,233 @@
+//
+// SessionPool.h
+//
+// Library: Data
+// Package: SessionPooling
+// Module:  SessionPool
+//
+// Definition of the SessionPool class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_SessionPool_INCLUDED
+#define Data_SessionPool_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/PooledSessionHolder.h"
+#include "Poco/Data/PooledSessionImpl.h"
+#include "Poco/Data/Session.h"
+#include "Poco/HashMap.h"
+#include "Poco/Any.h"
+#include "Poco/Timer.h"
+#include "Poco/Mutex.h"
+#include <list>
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API SessionPool: public RefCountedObject
+	/// This class implements session pooling for POCO Data.
+	///
+	/// Creating a connection to a database is often a time consuming
+	/// operation. Therefore it makes sense to reuse a session object
+	/// once it is no longer needed.
+	///
+	/// A SessionPool manages a collection of SessionImpl objects 
+	/// (decorated with a PooledSessionImpl).
+	///
+	/// When a SessionImpl object is requested, the SessionPool first
+	/// looks in its set of already initialized SessionImpl for an
+	/// available object. If one is found, it is returned to the
+	/// client and marked as "in-use". If no SessionImpl is available,
+	/// the SessionPool attempts to create a new one for the client.
+	/// To avoid excessive creation of SessionImpl objects, a limit
+	/// can be set on the maximum number of objects.
+	/// Sessions found not to be connected to the database are purged
+	/// from the pool whenever one of the following events occurs:
+	/// 
+	///   - JanitorTimer event
+	///   - get() request
+	///   - putBack() request
+	///
+	/// Not connected idle sessions can not exist.
+	///
+	/// Usage example:
+	///
+	///     SessionPool pool("ODBC", "...");
+	///     ...
+	///     Session sess(pool.get());
+	///     ...
+{
+public:
+	SessionPool(const std::string& connector, 
+		const std::string& connectionString, 
+		int minSessions = 1, 
+		int maxSessions = 32, 
+		int idleTime = 60);
+		/// Creates the SessionPool for sessions with the given connector
+		/// and connectionString.
+		///
+		/// The pool allows for at most maxSessions sessions to be created.
+		/// If a session has been idle for more than idleTime seconds, and more than
+		/// minSessions sessions are in the pool, the session is automatically destroyed.
+
+	~SessionPool();
+		/// Destroys the SessionPool.
+		
+	Session get();
+		/// Returns a Session.
+		///
+		/// If there are unused sessions available, one of the
+		/// unused sessions is recycled. Otherwise, a new session
+		/// is created. 
+		///
+		/// If the maximum number of sessions for this pool has
+		/// already been created, a SessionPoolExhaustedException
+		/// is thrown.
+	
+	template <typename T>
+	Session get(const std::string& name, const T& value)
+		/// Returns a Session with requested property set.
+		/// The property can be different from the default pool
+		/// value, in which case it is reset back to the pool 
+		/// value when the session is reclaimed by the pool.
+	{
+		Session s = get();
+		_addPropertyMap.insert(AddPropertyMap::value_type(s.impl(),
+			std::make_pair(name, s.getProperty(name))));
+		s.setProperty(name, value);
+
+		return s;
+	}
+
+	Session get(const std::string& name, bool value);
+		/// Returns a Session with requested feature set.
+		/// The feature can be different from the default pool
+		/// value, in which case it is reset back to the pool 
+		/// value when the session is reclaimed by the pool.
+
+	int capacity() const;
+		/// Returns the maximum number of sessions the SessionPool will manage.
+		
+	int used() const;
+		/// Returns the number of sessions currently in use.
+		
+	int idle() const;
+		/// Returns the number of idle sessions.
+		
+	int dead();
+		/// Returns the number of not connected active sessions.
+
+	int allocated() const;
+		/// Returns the number of allocated sessions.
+		
+	int available() const;
+		/// Returns the number of available (idle + remaining capacity) sessions.
+
+	std::string name() const;
+		/// Returns the name for this pool.
+
+	static std::string name(const std::string& connector,
+		const std::string& connectionString);
+	/// Returns the name formatted from supplied arguments as "connector:///connectionString".
+
+	void setFeature(const std::string& name, bool state);
+		/// Sets feature for all the sessions.
+
+	bool getFeature(const std::string& name);
+		/// Returns the requested feature.
+
+	void setProperty(const std::string& name, const Poco::Any& value);
+		/// Sets property for all sessions.
+
+	Poco::Any getProperty(const std::string& name);
+		/// Returns the requested property.
+
+	void shutdown();
+		/// Shuts down the session pool.
+
+	bool isActive() const;
+		/// Returns true if session pool is active (not shut down).
+
+protected:
+	virtual void customizeSession(Session& session);
+		/// Can be overridden by subclass to perform custom initialization
+		/// of a newly created database session.
+		///
+		/// The default implementation does nothing.
+
+	typedef Poco::AutoPtr<PooledSessionHolder>    PooledSessionHolderPtr;
+	typedef Poco::AutoPtr<PooledSessionImpl>      PooledSessionImplPtr;
+	typedef std::list<PooledSessionHolderPtr>     SessionList;
+	typedef Poco::HashMap<std::string, bool>      FeatureMap;
+	typedef Poco::HashMap<std::string, Poco::Any> PropertyMap;
+
+	void purgeDeadSessions();
+	int deadImpl(SessionList& rSessions);
+	void applySettings(SessionImpl* pImpl);
+	void putBack(PooledSessionHolderPtr pHolder);
+	void onJanitorTimer(Poco::Timer&);
+
+private:
+	typedef std::pair<std::string, Poco::Any> PropertyPair; 
+	typedef std::pair<std::string, bool> FeaturePair; 
+	typedef std::map<SessionImpl*, PropertyPair> AddPropertyMap;
+	typedef std::map<SessionImpl*, FeaturePair> AddFeatureMap;
+
+	SessionPool(const SessionPool&);
+	SessionPool& operator = (const SessionPool&);
+		
+	void closeAll(SessionList& sessionList);
+
+	std::string    _connector;
+	std::string    _connectionString;
+	int            _minSessions;
+	int            _maxSessions;
+	int            _idleTime;
+	int            _nSessions;
+	SessionList    _idleSessions;
+	SessionList    _activeSessions;
+	Poco::Timer    _janitorTimer;
+	FeatureMap     _featureMap;
+	PropertyMap    _propertyMap;
+	bool           _shutdown;
+	AddPropertyMap _addPropertyMap;
+	AddFeatureMap  _addFeatureMap;
+	mutable
+	Poco::Mutex _mutex;
+	
+	friend class PooledSessionImpl;
+};
+
+
+inline std::string SessionPool::name(const std::string& connector,
+	const std::string& connectionString)
+{
+	return Session::uri(connector, connectionString);
+}
+
+
+inline std::string SessionPool::name() const
+{
+	return name(_connector, _connectionString);
+}
+
+
+inline bool SessionPool::isActive() const
+{
+	return !_shutdown;
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_SessionPool_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/SessionPoolContainer.h b/base/poco/Data/include/Poco/Data/SessionPoolContainer.h
new file mode 100644
index 00000000000..15c3e83b992
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/SessionPoolContainer.h
@@ -0,0 +1,114 @@
+//
+// SessionPoolContainer.h
+//
+// Library: Data
+// Package: SessionPooling
+// Module:  SessionPoolContainer
+//
+// Definition of the SessionPoolContainer class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_SessionPoolContainer_INCLUDED
+#define Data_SessionPoolContainer_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/Session.h"
+#include "Poco/Data/SessionPool.h"
+#include "Poco/String.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API SessionPoolContainer
+	/// This class implements container of session pools.
+{
+public:
+	SessionPoolContainer();
+		/// Creates the SessionPoolContainer for sessions with the given session parameters.
+
+	~SessionPoolContainer();
+		/// Destroys the SessionPoolContainer.
+	
+	void add(SessionPool* pPool);
+		/// Adds existing session pool to the container.
+		/// Throws SessionPoolExistsException if pool already exists.
+
+	Session add(const std::string& sessionKey, 
+		const std::string& connectionString,
+		int minSessions = 1, 
+		int maxSessions = 32, 
+		int idleTime = 60);
+		/// Adds a new session pool to the container and returns a Session from
+		/// newly created pool. If pool already exists, request to add is silently
+		/// ignored and session is returned from the existing pool.
+
+	bool has(const std::string& name) const;
+		/// Returns true if the requested name exists, false otherwise.
+
+	bool isActive(const std::string& sessionKey,
+		const std::string& connectionString = "") const;
+		/// Returns true if the session is active (i.e. not shut down).
+		/// If connectionString is empty string, sessionKey must be a 
+		/// fully qualified session name as registered with the pool
+		/// container.
+
+	Session get(const std::string& name);
+		/// Returns the requested Session.
+		/// Throws NotFoundException if session is not found.
+
+	SessionPool& getPool(const std::string& name);
+		/// Returns a SessionPool reference.
+		/// Throws NotFoundException if session is not found.
+
+	void remove(const std::string& name);
+		/// Removes a SessionPool.
+		
+	int count() const;
+		/// Returns the number of session pols in the container.
+
+	void shutdown();
+		/// Shuts down all the held pools.
+
+private:
+	typedef std::map<std::string, AutoPtr<SessionPool>, Poco::CILess> SessionPoolMap;
+
+	SessionPoolContainer(const SessionPoolContainer&);
+	SessionPoolContainer& operator = (const SessionPoolContainer&);
+		
+	SessionPoolMap  _sessionPools;
+	Poco::FastMutex _mutex;
+};
+
+
+inline bool SessionPoolContainer::has(const std::string& name) const
+{
+	return _sessionPools.find(name) != _sessionPools.end();
+}
+
+
+inline void SessionPoolContainer::remove(const std::string& name)
+{
+	_sessionPools.erase(name);
+}
+
+
+inline int SessionPoolContainer::count() const
+{
+	return static_cast<int>(_sessionPools.size());
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_SessionPoolContainer_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/SimpleRowFormatter.h b/base/poco/Data/include/Poco/Data/SimpleRowFormatter.h
new file mode 100644
index 00000000000..2ddfdac9cc4
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/SimpleRowFormatter.h
@@ -0,0 +1,122 @@
+//
+// RowFormatter.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  SimpleRowFormatter
+//
+// Definition of the RowFormatter class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_SimpleRowFormatter_INCLUDED
+#define Data_SimpleRowFormatter_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/RowFormatter.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API SimpleRowFormatter: public RowFormatter
+	/// A simple row formatting class.
+{
+public:
+	//typedef RowFormatter::NameVec    NameVec;
+	//typedef RowFormatter::NameVecPtr NameVecPtr;
+	//typedef RowFormatter::ValueVec   ValueVec;
+
+	static const int DEFAULT_COLUMN_WIDTH = 16;
+	static const int DEFAULT_SPACING = 1;
+
+	SimpleRowFormatter(std::streamsize columnWidth = DEFAULT_COLUMN_WIDTH, std::streamsize spacing = DEFAULT_SPACING);
+		/// Creates the SimpleRowFormatter and sets the column width to specified value.
+
+	SimpleRowFormatter(const SimpleRowFormatter& other);
+		/// Creates the copy of the supplied SimpleRowFormatter.
+
+	SimpleRowFormatter& operator = (const SimpleRowFormatter& row);
+		/// Assignment operator.
+
+	~SimpleRowFormatter();
+		/// Destroys the SimpleRowFormatter.
+
+	void swap(SimpleRowFormatter& other);
+		/// Swaps the row formatter with another one.
+
+	std::string& formatNames(const NameVecPtr pNames, std::string& formattedNames);
+		/// Formats the row field names.
+
+	std::string& formatValues(const ValueVec& vals, std::string& formattedValues);
+		/// Formats the row values.
+
+	int rowCount() const;
+		/// Returns row count.
+
+	void setColumnWidth(std::streamsize width);
+		/// Sets the column width.
+
+	std::streamsize getColumnWidth() const;
+		/// Returns the column width.
+		
+	std::streamsize getSpacing() const;
+		/// Returns the spacing.
+
+private:
+	std::streamsize _colWidth;
+	std::streamsize _spacing;
+	int             _rowCount;
+};
+
+
+///
+/// inlines
+///
+inline int SimpleRowFormatter::rowCount() const
+{
+	return _rowCount;
+}
+
+
+inline void SimpleRowFormatter::setColumnWidth(std::streamsize columnWidth)
+{
+	_colWidth = columnWidth;
+}
+
+
+inline std::streamsize SimpleRowFormatter::getColumnWidth() const
+{
+	return _colWidth;
+}
+
+
+inline std::streamsize SimpleRowFormatter::getSpacing() const
+{
+	return _spacing;
+}
+
+
+} } // namespace Poco::Data
+
+
+namespace std
+{
+	template<>
+	inline void swap<Poco::Data::SimpleRowFormatter>(Poco::Data::SimpleRowFormatter& s1, 
+		Poco::Data::SimpleRowFormatter& s2)
+		/// Full template specalization of std:::swap for SimpleRowFormatter
+	{
+		s1.swap(s2);
+	}
+}
+
+
+#endif // Data_SimpleRowFormatter_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/Statement.h b/base/poco/Data/include/Poco/Data/Statement.h
new file mode 100644
index 00000000000..5373e092cc8
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/Statement.h
@@ -0,0 +1,822 @@
+//
+// Statement.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  Statement
+//
+// Definition of the Statement class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_Statement_INCLUDED
+#define Data_Statement_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/StatementImpl.h"
+#include "Poco/Data/Binding.h"
+#include "Poco/Data/Range.h"
+#include "Poco/Data/Bulk.h"
+#include "Poco/Data/Row.h"
+#include "Poco/Data/SimpleRowFormatter.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Mutex.h"
+#include "Poco/ActiveMethod.h"
+#include "Poco/ActiveResult.h"
+#include "Poco/Format.h"
+#include <algorithm>
+
+
+namespace Poco {
+namespace Data {
+
+
+class AbstractBinding;
+class AbstractExtraction;
+class Session;
+class Limit;
+
+
+class Data_API Statement
+	/// A Statement is used to execute SQL statements.
+	/// It does not contain code of its own.
+	/// Its main purpose is to forward calls to the concrete StatementImpl stored inside.
+	/// Statement execution can be synchronous or asynchronous.
+	/// Synchronous ececution is achieved through execute() call, while asynchronous is
+	/// achieved through executeAsync() method call.
+	/// An asynchronously executing statement should not be copied during the execution.
+	///
+	/// Note:
+	///
+	/// Once set as asynchronous through 'async' manipulator, statement remains
+	/// asynchronous for all subsequent execution calls, both execute() and executeAsync().
+	/// However, calling executAsync() on a synchronous statement shall execute
+	/// asynchronously but without altering the underlying statement's synchronous nature.
+	///
+	/// Once asynchronous, a statement can be reverted back to synchronous state in two ways:
+	///
+	///   1) By calling setAsync(false)
+	///   2) By means of 'sync' or 'reset' manipulators
+	///
+	/// See individual functions documentation for more details.
+	///
+	/// Statement owns the RowFormatter, which can be provided externaly through setFormatter()
+	/// member function.
+	/// If no formatter is externally supplied to the statement, the SimpleRowFormatter is lazy
+	/// created and used.
+{
+public:
+	typedef void (*Manipulator)(Statement&);
+
+	typedef ActiveResult<std::size_t>                      Result;
+	typedef SharedPtr<Result>                              ResultPtr;
+	typedef ActiveMethod<std::size_t, bool, StatementImpl> AsyncExecMethod;
+	typedef SharedPtr<AsyncExecMethod>                     AsyncExecMethodPtr;
+
+	static const int WAIT_FOREVER = -1;
+
+	enum Storage
+	{
+		STORAGE_DEQUE   = StatementImpl::STORAGE_DEQUE_IMPL,
+		STORAGE_VECTOR  = StatementImpl::STORAGE_VECTOR_IMPL,
+		STORAGE_LIST    = StatementImpl::STORAGE_LIST_IMPL,
+		STORAGE_UNKNOWN = StatementImpl::STORAGE_UNKNOWN_IMPL
+	};
+
+	Statement(StatementImpl::Ptr pImpl);
+		/// Creates the Statement.
+
+	explicit Statement(Session& session);
+		/// Creates the Statement for the given Session.
+		///
+		/// The following:
+		///
+		///     Statement stmt(sess);
+		///     stmt << "SELECT * FROM Table", ...
+		///
+		/// is equivalent to:
+		///
+		///     Statement stmt(sess << "SELECT * FROM Table", ...);
+		///
+		/// but in some cases better readable.
+
+	~Statement();
+		/// Destroys the Statement.
+
+	Statement(const Statement& stmt);
+		/// Copy constructor.
+		/// If the statement has been executed asynchronously and has not been
+		/// synchronized prior to copy operation (i.e. is copied while executing),
+		/// this constructor shall synchronize it.
+
+	Statement& operator = (const Statement& stmt);
+		/// Assignment operator.
+
+	void swap(Statement& other);
+		/// Swaps the statement with another one.
+
+	template <typename T>
+	Statement& operator << (const T& t)
+		/// Concatenates data with the SQL statement string.
+	{
+		_pImpl->add(t);
+		return *this;
+	}
+
+	Statement& operator , (Manipulator manip);
+		/// Handles manipulators, such as now, async, etc.
+
+	Statement& operator , (AbstractBinding::Ptr pBind);
+		/// Registers the Binding with the Statement by calling addBind().
+
+	Statement& addBind(AbstractBinding::Ptr pBind);
+		/// Registers a single binding with the statement.
+
+	void removeBind(const std::string& name);
+		/// Removes the all the bindings with specified name from the statement.
+
+	Statement& operator , (AbstractBindingVec& bindVec);
+		/// Registers the Binding vector with the Statement.
+
+	template <typename C>
+	Statement& addBinding(C& bindingCont, bool reset)
+		/// Registers binding container with the Statement.
+	{
+		if (reset) _pImpl->resetBinding();
+		typename C::iterator itAB = bindingCont.begin();
+		typename C::iterator itABEnd = bindingCont.end();
+		for (; itAB != itABEnd; ++itAB) addBind(*itAB);
+		return *this;
+	}
+
+	template <typename C>
+	Statement& bind(const C& value)
+		/// Adds a binding to the Statement. This can be used to implement
+		/// generic binding mechanisms and is a nicer syntax for:
+		///
+		///     statement , bind(value);
+	{
+		(*this) , Keywords::bind(value);
+		return *this;
+	}
+
+	Statement& operator , (AbstractExtraction::Ptr extract);
+		/// Registers objects used for extracting data with the Statement by
+		/// calling addExtract().
+
+	Statement& operator , (AbstractExtractionVec& extVec);
+		/// Registers the extraction vector with the Statement.
+		/// The vector is registered at position 0 (i.e. for the first returned data set).
+
+	Statement& operator , (AbstractExtractionVecVec& extVecVec);
+		/// Registers the vector of extraction vectors with the Statement.
+
+	template <typename C>
+	Statement& addExtraction(C& val, bool reset)
+		/// Registers extraction container with the Statement.
+	{
+		if (reset) _pImpl->resetExtraction();
+		typename C::iterator itAE = val.begin();
+		typename C::iterator itAEEnd = val.end();
+		for (; itAE != itAEEnd; ++itAE) addExtract(*itAE);
+		return *this;
+	}
+
+	template <typename C>
+	Statement& addExtractions(C& val)
+		/// Registers container of extraction containers with the Statement.
+	{
+		_pImpl->resetExtraction();
+		typename C::iterator itAEV = val.begin();
+		typename C::iterator itAEVEnd = val.end();
+		for (; itAEV != itAEVEnd; ++itAEV) addExtraction(*itAEV, false);
+		return *this;
+	}
+
+	Statement& addExtract(AbstractExtraction::Ptr pExtract);
+		/// Registers a single extraction with the statement.
+
+	Statement& operator , (const Bulk& bulk);
+		/// Sets the bulk execution mode (both binding and extraction) for this
+		/// statement.Statement must not have any extractors or binders set at the
+		/// time when this operator is applied.
+		/// Failure to adhere to the above constraint shall result in
+		/// InvalidAccessException.
+
+	Statement& operator , (BulkFnType);
+		/// Sets the bulk execution mode (both binding and extraction) for this
+		/// statement.Statement must not have any extractors or binders set at the
+		/// time when this operator is applied.
+		/// Additionally, this function requires limit to be set in order to
+		/// determine the bulk size.
+		/// Failure to adhere to the above constraints shall result in
+		/// InvalidAccessException.
+
+	Statement& operator , (const Limit& extrLimit);
+		/// Sets a limit on the maximum number of rows a select is allowed to return.
+		///
+		/// Set per default to zero to Limit::LIMIT_UNLIMITED, which disables the limit.
+
+	Statement& operator , (RowFormatter::Ptr pRowFformatter);
+		/// Sets the row formatter for the statement.
+
+	Statement& operator , (const Range& extrRange);
+		/// Sets a an extraction range for the maximum number of rows a select is allowed to return.
+		///
+		/// Set per default to Limit::LIMIT_UNLIMITED which disables the range.
+
+	Statement& operator , (char value);
+		/// Adds the value to the list of values to be supplied to the SQL string formatting function.
+
+	Statement& operator , (Poco::UInt8 value);
+		/// Adds the value to the list of values to be supplied to the SQL string formatting function.
+
+	Statement& operator , (Poco::Int8 value);
+		/// Adds the value to the list of values to be supplied to the SQL string formatting function.
+
+	Statement& operator , (Poco::UInt16 value);
+		/// Adds the value to the list of values to be supplied to the SQL string formatting function.
+
+	Statement& operator , (Poco::Int16 value);
+		/// Adds the value to the list of values to be supplied to the SQL string formatting function.
+
+	Statement& operator , (Poco::UInt32 value);
+		/// Adds the value to the list of values to be supplied to the SQL string formatting function.
+
+	Statement& operator , (Poco::Int32 value);
+		/// Adds the value to the list of values to be supplied to the SQL string formatting function.
+
+#ifndef POCO_LONG_IS_64_BIT
+	Statement& operator , (long value);
+		/// Adds the value to the list of values to be supplied to the SQL string formatting function.
+
+	Statement& operator , (unsigned long value);
+		/// Adds the value to the list of values to be supplied to the SQL string formatting function.
+#endif
+	Statement& operator , (Poco::UInt64 value);
+		/// Adds the value to the list of values to be supplied to the SQL string formatting function.
+
+	Statement& operator , (Poco::Int64 value);
+		/// Adds the value to the list of values to be supplied to the SQL string formatting function.
+
+	Statement& operator , (double value);
+		/// Adds the value to the list of values to be supplied to the SQL string formatting function.
+
+	Statement& operator , (float value);
+		/// Adds the value to the list of values to be supplied to the SQL string formatting function.
+
+	Statement& operator , (bool value);
+		/// Adds the value to the list of values to be supplied to the SQL string formatting function.
+
+	Statement& operator , (const std::string& value);
+		/// Adds the value to the list of values to be supplied to the SQL string formatting function.
+
+	Statement& operator , (const char* value);
+		/// Adds the value to the list of values to be supplied to the SQL string formatting function.
+
+	const std::string& toString() const;
+		/// Creates a string from the accumulated SQL statement.
+
+	std::size_t execute(bool reset = true);
+		/// Executes the statement synchronously or asynchronously.
+		/// Stops when either a limit is hit or the whole statement was executed.
+		/// Returns the number of rows extracted from the database (for statements
+		/// returning data) or number of rows affected (for all other statements).
+		/// If reset is true (default), associated storage is reset and reused.
+		/// Otherwise, the results from this execution step are appended.
+		/// Reset argument has no meaning for unlimited statements that return all rows.
+		/// If isAsync() returns  true, the statement is executed asynchronously
+		/// and the return value from this function is zero.
+		/// The result of execution (i.e. number of returned or affected rows) can be
+		/// obtained by calling wait() on the statement at a later point in time.
+
+	const Result& executeAsync(bool reset = true);
+		/// Executes the statement asynchronously.
+		/// Stops when either a limit is hit or the whole statement was executed.
+		/// Returns immediately. Calling wait() (on either the result returned from this
+		/// call or the statement itself) returns the number of rows extracted or number
+		/// of rows affected by the statement execution.
+		/// When executed on a synchronous statement, this method does not alter the
+		/// statement's synchronous nature.
+
+	void setAsync(bool async = true);
+		/// Sets the asynchronous flag. If this flag is true, executeAsync() is called
+		/// from the now() manipulator. This setting does not affect the statement's
+		/// capability to be executed synchronously by directly calling execute().
+
+	bool isAsync() const;
+		/// Returns true if statement was marked for asynchronous execution.
+
+	std::size_t wait(long milliseconds = WAIT_FOREVER);
+		/// Waits for the execution completion for asynchronous statements or
+		/// returns immediately for synchronous ones. The return value for
+		/// asynchronous statement is the execution result (i.e. number of
+		/// rows retrieved). For synchronous statements, the return value is zero.
+
+	bool initialized();
+		/// Returns true if the statement was initialized (i.e. not executed yet).
+
+	bool paused();
+		/// Returns true if the statement was paused (a range limit stopped it
+		/// and there is more work to do).
+
+	bool done();
+		/// Returns true if the statement was completely executed or false if a range limit stopped it
+		/// and there is more work to do. When no limit is set, it will always return true after calling execute().
+
+	Statement& reset(Session& session);
+		/// Resets the Statement so that it can be filled with a new SQL command.
+
+	bool canModifyStorage();
+		/// Returns true if statement is in a state that allows the internal storage to be modified.
+
+	Storage storage() const;
+		/// Returns the internal storage type for the statement.
+
+	void setStorage(const std::string& storage);
+		/// Sets the internal storage type for the statement.
+
+	const std::string& getStorage() const;
+		/// Returns the internal storage type for the statement.
+
+	std::size_t columnsExtracted(int dataSet = StatementImpl::USE_CURRENT_DATA_SET) const;
+		/// Returns the number of columns returned for current data set.
+		/// Default value indicates current data set (if any).
+
+	std::size_t rowsExtracted(int dataSet = StatementImpl::USE_CURRENT_DATA_SET) const;
+		/// Returns the number of rows returned for current data set during last statement
+		/// execution. Default value indicates current data set (if any).
+
+	std::size_t subTotalRowCount(int dataSet = StatementImpl::USE_CURRENT_DATA_SET) const;
+		/// Returns the number of rows extracted so far for the data set.
+		/// Default value indicates current data set (if any).
+
+	std::size_t extractionCount() const;
+		/// Returns the number of extraction storage buffers associated
+		/// with the current data set.
+
+	std::size_t dataSetCount() const;
+		/// Returns the number of data sets associated with the statement.
+
+	std::size_t nextDataSet();
+		/// Returns the index of the next data set.
+
+	std::size_t previousDataSet();
+		/// Returns the index of the previous data set.
+
+	bool hasMoreDataSets() const;
+		/// Returns false if the current data set index points to the last
+		/// data set. Otherwise, it returns true.
+
+	void setRowFormatter(RowFormatter::Ptr pRowFormatter);
+		/// Sets the row formatter for this statement.
+		/// Statement takes the ownership of the formatter.
+
+protected:
+	typedef StatementImpl::Ptr ImplPtr;
+
+	const AbstractExtractionVec& extractions() const;
+		/// Returns the extractions vector.
+
+	const MetaColumn& metaColumn(std::size_t pos) const;
+		/// Returns the type for the column at specified position.
+
+	const MetaColumn& metaColumn(const std::string& name) const;
+		/// Returns the type for the column with specified name.
+
+	 bool isNull(std::size_t col, std::size_t row) const;
+		/// Returns true if the current row value at column pos is null.
+
+	 bool isBulkExtraction() const;
+		/// Returns true if this statement extracts data in bulk.
+
+	ImplPtr impl() const;
+		/// Returns pointer to statement implementation.
+
+	const RowFormatter::Ptr& getRowFormatter();
+		/// Returns the row formatter for this statement.
+
+	Session session();
+		/// Returns the underlying session.
+
+private:
+
+	const Result& doAsyncExec(bool reset = true);
+		/// Asynchronously executes the statement.
+
+	template <typename T>
+	Statement& commaPODImpl(const T& val)
+	{
+		_arguments.push_back(val);
+		return *this;
+	}
+
+	StatementImpl::Ptr _pImpl;
+
+	// asynchronous execution related members
+	bool                _async;
+	mutable ResultPtr   _pResult;
+	Mutex               _mutex;
+	AsyncExecMethodPtr  _pAsyncExec;
+	std::vector<Any>    _arguments;
+	RowFormatter::Ptr   _pRowFormatter;
+	mutable std::string _stmtString;
+};
+
+//
+// inlines
+
+inline std::size_t Statement::subTotalRowCount(int dataSet) const
+{
+	return _pImpl->subTotalRowCount(dataSet);
+}
+
+
+namespace Keywords {
+
+
+//
+// Manipulators
+//
+
+inline void Data_API now(Statement& statement)
+	/// Enforces immediate execution of the statement.
+	/// If _isAsync flag has been set, execution is invoked asynchronously.
+{
+	statement.execute();
+}
+
+
+inline void Data_API sync(Statement& statement)
+	/// Sets the _isAsync flag to false, signalling synchronous execution.
+	/// Synchronous execution is default, so specifying this manipulator
+	/// only makes sense if async() was called for the statement before.
+{
+	statement.setAsync(false);
+}
+
+
+inline void Data_API async(Statement& statement)
+	/// Sets the _async flag to true, signalling asynchronous execution.
+{
+	statement.setAsync(true);
+}
+
+
+inline void Data_API deque(Statement& statement)
+	/// Sets the internal storage to std::deque.
+	/// std::deque is default storage, so specifying this manipulator
+	/// only makes sense if list() or deque() were called for the statement before.
+{
+	if (!statement.canModifyStorage())
+		throw InvalidAccessException("Storage not modifiable.");
+
+	statement.setStorage("deque");
+}
+
+
+inline void Data_API vector(Statement& statement)
+	/// Sets the internal storage to std::vector.
+{
+	if (!statement.canModifyStorage())
+		throw InvalidAccessException("Storage not modifiable.");
+
+	statement.setStorage("vector");
+}
+
+
+inline void Data_API list(Statement& statement)
+	/// Sets the internal storage to std::list.
+{
+	if (!statement.canModifyStorage())
+		throw InvalidAccessException("Storage not modifiable.");
+
+	statement.setStorage("list");
+}
+
+
+inline void Data_API reset(Statement& statement)
+	/// Sets all internal settings to their respective default values.
+{
+	if (!statement.canModifyStorage())
+		throw InvalidAccessException("Storage not modifiable.");
+
+	statement.setStorage("deque");
+	statement.setAsync(false);
+}
+
+
+} // namespace Keywords
+
+
+//
+// inlines
+//
+
+inline Statement& Statement::operator , (RowFormatter::Ptr pRowFformatter)
+{
+	_pRowFormatter = pRowFformatter;
+	return *this;
+}
+
+
+inline Statement& Statement::operator , (char value)
+{
+	return commaPODImpl(value);
+}
+
+
+inline Statement& Statement::operator , (Poco::UInt8 value)
+{
+	return commaPODImpl(value);
+}
+
+
+inline Statement& Statement::operator , (Poco::Int8 value)
+{
+	return commaPODImpl(value);
+}
+
+
+inline Statement& Statement::operator , (Poco::UInt16 value)
+{
+	return commaPODImpl(value);
+}
+
+
+inline Statement& Statement::operator , (Poco::Int16 value)
+{
+	return commaPODImpl(value);
+}
+
+
+inline Statement& Statement::operator , (Poco::UInt32 value)
+{
+	return commaPODImpl(value);
+}
+
+
+inline Statement& Statement::operator , (Poco::Int32 value)
+{
+	return commaPODImpl(value);
+}
+
+
+#ifndef POCO_LONG_IS_64_BIT
+inline Statement& Statement::operator , (long value)
+{
+	return commaPODImpl(value);
+}
+
+
+inline Statement& Statement::operator , (unsigned long value)
+{
+	return commaPODImpl(value);
+}
+#endif
+
+
+inline Statement& Statement::operator , (Poco::UInt64 value)
+{
+	return commaPODImpl(value);
+}
+
+
+inline Statement& Statement::operator , (Poco::Int64 value)
+{
+	return commaPODImpl(value);
+}
+
+
+inline Statement& Statement::operator , (double value)
+{
+	return commaPODImpl(value);
+}
+
+
+inline Statement& Statement::operator , (float value)
+{
+	return commaPODImpl(value);
+}
+
+
+inline Statement& Statement::operator , (bool value)
+{
+	return commaPODImpl(value);
+}
+
+
+inline Statement& Statement::operator , (const std::string& value)
+{
+	return commaPODImpl(value);
+}
+
+
+inline Statement& Statement::operator , (const char* value)
+{
+	return commaPODImpl(std::string(value));
+}
+
+
+inline void Statement::removeBind(const std::string& name)
+{
+	_pImpl->removeBind(name);
+}
+
+
+inline Statement& Statement::operator , (AbstractBinding::Ptr pBind)
+{
+	return addBind(pBind);
+}
+
+
+inline Statement& Statement::operator , (AbstractBindingVec& bindVec)
+{
+	return addBinding(bindVec, false);
+}
+
+
+inline Statement& Statement::operator , (AbstractExtraction::Ptr pExtract)
+{
+	return addExtract(pExtract);
+}
+
+
+inline Statement& Statement::operator , (AbstractExtractionVec& extVec)
+{
+	return addExtraction(extVec, false);
+}
+
+
+inline Statement& Statement::operator , (AbstractExtractionVecVec& extVecVec)
+{
+	return addExtractions(extVecVec);
+}
+
+
+inline Statement::ImplPtr Statement::impl() const
+{
+	return _pImpl;
+}
+
+
+inline const std::string& Statement::toString() const
+{
+	return _stmtString = _pImpl->toString();
+}
+
+inline const AbstractExtractionVec& Statement::extractions() const
+{
+	return _pImpl->extractions();
+}
+
+
+inline const MetaColumn& Statement::metaColumn(std::size_t pos) const
+{
+	return _pImpl->metaColumn(pos);
+}
+
+
+inline const MetaColumn& Statement::metaColumn(const std::string& name) const
+{
+	return _pImpl->metaColumn(name);
+}
+
+
+inline void Statement::setStorage(const std::string& storage)
+{
+	_pImpl->setStorage(storage);
+}
+
+
+inline std::size_t Statement::extractionCount() const
+{
+	return _pImpl->extractionCount();
+}
+
+
+inline std::size_t Statement::columnsExtracted(int dataSet) const
+{
+	return _pImpl->columnsExtracted(dataSet);
+}
+
+
+inline std::size_t Statement::rowsExtracted(int dataSet) const
+{
+	return _pImpl->rowsExtracted(dataSet);
+}
+
+
+inline std::size_t Statement::dataSetCount() const
+{
+	return _pImpl->dataSetCount();
+}
+
+
+inline std::size_t Statement::nextDataSet()
+{
+	return _pImpl->activateNextDataSet();
+}
+
+
+inline std::size_t Statement::previousDataSet()
+{
+	return _pImpl->activatePreviousDataSet();
+}
+
+
+inline bool Statement::hasMoreDataSets() const
+{
+	return _pImpl->hasMoreDataSets();
+}
+
+
+inline Statement::Storage Statement::storage() const
+{
+	return static_cast<Storage>(_pImpl->getStorage());
+}
+
+
+inline bool Statement::canModifyStorage()
+{
+	return (0 == extractionCount()) && (initialized() || done());
+}
+
+
+inline bool Statement::initialized()
+{
+	return _pImpl->getState() == StatementImpl::ST_INITIALIZED;
+}
+
+
+inline bool Statement::paused()
+{
+	return _pImpl->getState() == StatementImpl::ST_PAUSED;
+}
+
+
+inline bool Statement::done()
+{
+	return _pImpl->getState() == StatementImpl::ST_DONE;
+}
+
+
+inline bool Statement::isNull(std::size_t col, std::size_t row) const
+{
+	return _pImpl->isNull(col, row);
+}
+
+
+inline bool Statement::isBulkExtraction() const
+{
+	return _pImpl->isBulkExtraction();
+}
+
+
+inline bool Statement::isAsync() const
+{
+	return _async;
+}
+
+
+inline void Statement::setRowFormatter(RowFormatter::Ptr pRowFormatter)
+{
+	_pRowFormatter = pRowFormatter;
+}
+
+
+inline const RowFormatter::Ptr& Statement::getRowFormatter()
+{
+	if (!_pRowFormatter) _pRowFormatter = new SimpleRowFormatter;
+	return _pRowFormatter;
+}
+
+
+inline void swap(Statement& s1, Statement& s2)
+{
+	s1.swap(s2);
+}
+
+
+} } // namespace Poco::Data
+
+
+namespace std
+{
+	template<>
+	inline void swap<Poco::Data::Statement>(Poco::Data::Statement& s1,
+		Poco::Data::Statement& s2)
+		/// Full template specalization of std:::swap for Statement
+	{
+		s1.swap(s2);
+	}
+}
+
+
+#endif // Data_Statement_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/StatementCreator.h b/base/poco/Data/include/Poco/Data/StatementCreator.h
new file mode 100644
index 00000000000..ca278041731
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/StatementCreator.h
@@ -0,0 +1,73 @@
+//
+// StatementCreator.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  StatementCreator
+//
+// Definition of the StatementCreator class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_StatementCreator_INCLUDED
+#define Data_StatementCreator_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/SessionImpl.h"
+#include "Poco/Data/Statement.h"
+#include "Poco/AutoPtr.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API StatementCreator
+	/// A StatementCreator creates Statements.
+{
+public:
+	StatementCreator();
+		/// Creates an unitialized StatementCreator.
+		
+	StatementCreator(Poco::AutoPtr<SessionImpl> ptrImpl);
+		/// Creates a StatementCreator.
+
+	StatementCreator(const StatementCreator& other);
+		/// Creates a StatementCreator by copying another one.
+
+	~StatementCreator();
+		/// Destroys the StatementCreator.
+
+	StatementCreator& operator = (const StatementCreator& other);
+		/// Assignment operator.
+		
+	void swap(StatementCreator& other);
+		/// Swaps the StatementCreator with another one.	
+		
+	template <typename T>
+	Statement operator << (const T& t)
+		/// Creates a Statement.
+	{
+		if (!_ptrImpl->isConnected())
+			throw NotConnectedException(_ptrImpl->connectionString());
+
+		Statement stmt(_ptrImpl->createStatementImpl());
+		stmt << t;
+		return stmt;
+	}
+
+private:
+	Poco::AutoPtr<SessionImpl> _ptrImpl;
+};
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_StatementCreator_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/StatementImpl.h b/base/poco/Data/include/Poco/Data/StatementImpl.h
new file mode 100644
index 00000000000..d9371a74037
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/StatementImpl.h
@@ -0,0 +1,632 @@
+//
+// StatementImpl.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  StatementImpl
+//
+// Definition of the StatementImpl class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_StatementImpl_INCLUDED
+#define Data_StatementImpl_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/AbstractBinding.h"
+#include "Poco/Data/AbstractExtraction.h"
+#include "Poco/Data/Range.h"
+#include "Poco/Data/Bulk.h"
+#include "Poco/Data/Column.h"
+#include "Poco/Data/Extraction.h"
+#include "Poco/Data/BulkExtraction.h"
+#include "Poco/Data/SessionImpl.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/String.h"
+#include "Poco/Format.h"
+#include "Poco/Exception.h"
+#include <vector>
+#include <list>
+#include <deque>
+#include <string>
+#include <sstream>
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API StatementImpl
+	/// StatementImpl interface that subclasses must implement to define database dependent query execution.
+	///
+	/// StatementImpl's are noncopyable.
+{
+public:
+	typedef Poco::SharedPtr<StatementImpl> Ptr;
+
+	enum State
+	{
+		ST_INITIALIZED,
+		ST_COMPILED,
+		ST_BOUND,
+		ST_PAUSED,
+		ST_DONE,
+		ST_RESET
+	};
+
+	enum Storage
+	{
+		STORAGE_DEQUE_IMPL,
+		STORAGE_VECTOR_IMPL,
+		STORAGE_LIST_IMPL,
+		STORAGE_UNKNOWN_IMPL
+	};
+
+	enum BulkType
+	{
+		BULK_UNDEFINED,     
+			/// Bulk mode not defined yet.
+		BULK_BINDING,       
+			/// Binding in bulk mode.
+			/// If extraction is present in the same statement, 
+			/// it must also be bulk.
+		BULK_EXTRACTION,    
+			/// Extraction in bulk mode.
+			/// If binding is present in the same statement, 
+			/// it must also be bulk.
+		BULK_FORBIDDEN     
+			/// Bulk forbidden. 
+			/// Happens when the statement has already been 
+			/// configured as non-bulk.
+	};
+
+	static const std::string DEQUE;
+	static const std::string VECTOR;
+	static const std::string LIST;
+	static const std::string UNKNOWN;
+
+	static const int USE_CURRENT_DATA_SET = -1;
+
+	StatementImpl(SessionImpl& rSession);
+		/// Creates the StatementImpl.
+
+	virtual ~StatementImpl();
+		/// Destroys the StatementImpl.
+
+	template <typename T> 
+	void add(const T& t)
+		/// Appends SQL statement (fragments).
+	{
+		_ostr << t;
+	}
+
+	void addBind(AbstractBinding::Ptr pBinding);
+		/// Registers the Binding with the StatementImpl.
+
+	void removeBind(const std::string& name);
+		/// Unregisters all the bindings having specified name with the StatementImpl.
+		/// Bindings are released and, if this class was the sole owner, deleted.
+
+	void addExtract(AbstractExtraction::Ptr pExtraction);
+		/// Registers objects used for extracting data with the StatementImpl.
+
+	void setExtractionLimit(const Limit& extrLimit);
+		/// Changes the extractionLimit to extrLimit. 
+		/// Per default no limit (EXTRACT_UNLIMITED) is set.
+
+	std::string toString() const;
+		/// Create a string version of the SQL statement.
+
+	std::size_t execute(const bool& reset = true);
+		/// Executes a statement. Returns the number of rows 
+		/// extracted for statements returning data or number of rows 
+		/// affected for all other statements (insert, update, delete).
+		/// If reset is true (default), the underlying bound storage is
+		/// reset and reused. In case of containers, this means they are
+		/// cleared and resized to accomodate the number of rows returned by
+		/// this execution step. When reset is false, data is appended to the
+		/// bound containers during multiple execute calls.
+
+	void reset();
+		/// Resets the statement, so that we can reuse all bindings and re-execute again.
+
+	State getState() const;
+		/// Returns the state of the Statement.
+
+	void setStorage(Storage storage);
+		/// Sets the storage type for this statement;
+
+	void setStorage(const std::string& storage);
+		/// Sets the storage type for this statement;
+
+	Storage getStorage() const;
+		/// Returns the storage type for this statement.
+
+	std::size_t extractionCount() const;
+		/// Returns the number of extraction storage buffers associated
+		/// with the statement.
+
+	std::size_t dataSetCount() const;
+		/// Returns the number of data sets associated with the statement.
+		
+protected:
+	virtual std::size_t columnsReturned() const = 0;
+		/// Returns number of columns returned by query. 
+
+	virtual int affectedRowCount() const = 0;
+		/// Returns the number of affected rows.
+		/// Used to find out the number of rows affected by insert, delete or update.
+		/// 
+		/// Some back-ends may return a negative number in certain circumstances (e.g.
+		/// some ODBC drivers when this function is called after a select statement
+		/// execution).
+
+	virtual const MetaColumn& metaColumn(std::size_t pos) const = 0;
+		/// Returns column meta data.
+
+	const MetaColumn& metaColumn(const std::string& name) const;
+		/// Returns column meta data.
+
+	virtual bool hasNext() = 0;
+		/// Returns true if a call to next() will return data. 
+		///
+		/// Note that the implementation must support
+		/// several consecutive calls to hasNext without data getting lost, 
+		/// ie. hasNext(); hasNext(); next() must be equal to hasNext(); next();
+
+	virtual std::size_t next() = 0;
+		/// Retrieves the next row or set of rows from the resultset and
+		/// returns the number of rows retreved.
+		///
+		/// Will throw, if the resultset is empty.
+		/// Expects the statement to be compiled and bound.
+
+	virtual bool canBind() const = 0;
+		/// Returns true if another bind is possible.
+
+	virtual bool canCompile() const = 0;
+		/// Returns true if another compile is possible.
+
+	virtual void compileImpl() = 0;
+		/// Compiles the statement, doesn't bind yet.
+
+	virtual void bindImpl() = 0;
+		/// Binds parameters.
+
+	virtual AbstractExtraction::ExtractorPtr extractor() = 0;
+		/// Returns the concrete extractor used by the statement.
+
+	const AbstractExtractionVec& extractions() const;
+		/// Returns the const reference to extractions vector.
+
+	AbstractExtractionVec& extractions();
+		/// Returns the reference to extractions vector.
+
+	void fixupExtraction();
+		/// Sets the AbstractExtractor at the extractors.
+
+	Limit::SizeT getExtractionLimit();
+		/// Returns the extraction limit value.
+
+	const Limit& extractionLimit() const;
+		/// Returns the extraction limit.
+
+	std::size_t columnsExtracted(int dataSet = USE_CURRENT_DATA_SET) const;
+		/// Returns the number of columns that the extractors handle.
+
+	std::size_t rowsExtracted(int dataSet = USE_CURRENT_DATA_SET) const;
+		/// Returns the number of rows extracted for current data set.
+		/// Default value (USE_CURRENT_DATA_SET) indicates current data set (if any).
+
+	std::size_t subTotalRowCount(int dataSet = USE_CURRENT_DATA_SET) const;
+		/// Returns the number of rows extracted so far for the data set.
+		/// Default value indicates current data set (if any).
+
+	void makeExtractors(std::size_t count);
+		/// Determines the type of the internal extraction container and
+		/// calls the extraction creation function (addInternalExtract)
+		/// with appropriate data type and container type arguments.
+		/// 
+		/// This function is only called in cases when there is data 
+		/// returned by query, but no data storage supplied by user.
+		///
+		/// The type of the internal container is determined in the
+		/// following order:
+		/// 1. If statement has the container type set, the type is used.
+		/// 2. If statement does not have the container type set,
+		///    session is queried for container type setting. If the
+		///    session container type setting is found, it is used.
+		/// 3. If neither session nor statement have the internal
+		///    container type set, std::deque is used.
+		///
+		/// Supported internal extraction container types are:
+		/// - std::deque (default)
+		/// - std::vector
+		/// - std::list
+
+	SessionImpl& session();
+		/// Rteurns session associated with this statement.
+
+	virtual AbstractBinding::BinderPtr binder() = 0;
+		/// Returns the concrete binder used by the statement.
+
+	const AbstractBindingVec& bindings() const;
+		/// Returns the const reference to bindings vector.
+
+	AbstractBindingVec& bindings();
+		/// Returns the reference to bindings.
+
+	void fixupBinding();
+		/// Sets the AbstractBinder at the bindings.
+
+	void resetBinding();
+		/// Resets binding so it can be reused again.
+
+	virtual bool isStoredProcedure() const;
+		/// Returns true if the statement is stored procedure.
+		/// Used as a help to determine whether to automatically create the
+		/// internal extractions when no outside extraction is supplied.
+		/// The reason for this function is to prevent unnecessary internal
+		/// extraction creation in cases (behavior exhibited by some ODBC drivers) 
+		/// when there is data available from the stored procedure call 
+		/// statement execution but no external extraction is supplied (as is 
+		/// usually the case when stored procedures are called). In such cases
+		/// no storage is needed because output parameters serve as storage.
+		/// At the Data framework level, this function always returns false.
+		/// When connector-specific behavior is desired, it should be overriden 
+		/// by the statement implementation.
+
+	std::size_t currentDataSet() const;
+		/// Returns the current data set.
+
+	std::size_t activateNextDataSet();
+		/// Returns the next data set index, or throws NoDataException if the last 
+		/// data set was reached.
+
+	std::size_t activatePreviousDataSet();
+		/// Returns the previous data set index, or throws NoDataException if the last 
+		/// data set was reached.
+
+	bool hasMoreDataSets() const;
+		/// Returns true if there are data sets not activated yet.
+
+private:
+	void compile();
+		/// Compiles the statement.
+
+	void bind();
+		/// Binds the statement, if not yet bound.
+
+	std::size_t executeWithLimit();
+		/// Executes with an upper limit set. Returns the number of rows 
+		/// extracted for statements returning data or number of rows 
+		/// affected for all other statements (insert, update, delete).
+
+	std::size_t executeWithoutLimit();
+		/// Executes without an upper limit set. Returns the number of rows 
+		/// extracted for statements returning data or number of rows 
+		/// affected for all other statements (insert, update, delete).
+
+	void resetExtraction();
+		/// Resets extraction so it can be reused again.
+
+	template <class C>
+	SharedPtr<InternalExtraction<C> > createExtract(const MetaColumn& mc)
+	{
+		C* pData = new C;
+		Column<C>* pCol = new Column<C>(mc, pData);
+		return new InternalExtraction<C>(*pData, pCol, Poco::UInt32(currentDataSet()));
+	}
+
+	template <class C>
+	SharedPtr<InternalBulkExtraction<C> > createBulkExtract(const MetaColumn& mc)
+	{
+		C* pData = new C;
+		Column<C>* pCol = new Column<C>(mc, pData);
+		return new InternalBulkExtraction<C>(*pData,
+			pCol,
+			static_cast<Poco::UInt32>(getExtractionLimit()),
+			Position(static_cast<Poco::UInt32>(currentDataSet())));
+	}
+
+	template <class T>
+	void addInternalExtract(const MetaColumn& mc)
+		/// Creates and adds the internal extraction.
+		///
+		/// The decision about internal extraction container is done 
+		/// in a following way:
+		///
+		/// If this statement has _storage member set, that setting
+		/// overrides the session setting for storage, otherwise the
+		/// session setting is used.
+		/// If neither this statement nor the session have the storage
+		/// type set, std::deque is the default container type used.
+	{
+		std::string storage;
+	
+		switch (_storage)
+		{
+		case STORAGE_DEQUE_IMPL:  
+			storage = DEQUE; break;
+		case STORAGE_VECTOR_IMPL: 
+			storage = VECTOR; break;
+		case STORAGE_LIST_IMPL:   
+			storage = LIST; break;
+		case STORAGE_UNKNOWN_IMPL:
+			storage = AnyCast<std::string>(session().getProperty("storage")); 
+			break;
+		}
+
+		if (storage.empty()) storage = DEQUE;
+
+		if (0 == icompare(DEQUE, storage))
+		{
+			if (!isBulkExtraction())
+				addExtract(createExtract<std::deque<T> >(mc));
+			else
+				addExtract(createBulkExtract<std::deque<T> >(mc));
+		}
+		else if (0 == icompare(VECTOR, storage))
+		{
+			if (!isBulkExtraction())
+				addExtract(createExtract<std::vector<T> >(mc));
+			else
+				addExtract(createBulkExtract<std::vector<T> >(mc));
+		}
+		else if (0 == icompare(LIST, storage))
+		{
+			if (!isBulkExtraction())
+				addExtract(createExtract<std::list<T> >(mc));
+			else
+				addExtract(createBulkExtract<std::list<T> >(mc));
+		}
+	}
+
+	bool isNull(std::size_t col, std::size_t row) const;
+		/// Returns true if the value in [col, row] is null.
+		
+	void forbidBulk();
+		/// Forbids bulk operations.
+
+	void setBulkBinding();
+		/// Sets the bulk binding flag.
+
+	void setBulkExtraction(const Bulk& l);
+		/// Sets the bulk extraction flag and extraction limit.
+	
+	void resetBulk();
+		/// Resets the bulk extraction and binding flag.
+
+	bool bulkBindingAllowed() const;
+		/// Returns true if statement can be set to bind data in bulk.
+		/// Once bulk binding is set for a statement, it can be
+		/// neither altered nor mixed with non-bulk mode binding.
+
+	bool bulkExtractionAllowed() const;
+		/// Returns true if statement can be set to extract data in bulk.
+		/// Once bulk extraction is set for a statement, it can be
+		/// neither altered nor mixed with non-bulk mode extraction.
+
+	bool isBulkBinding() const;
+		/// Returns true if statement is set to bind data in bulk.
+
+	bool isBulkExtraction() const;
+		/// Returns true if statement is set to extract data in bulk.
+
+	bool isBulkSupported() const;
+		/// Returns true if connector and session support bulk operation.
+
+	void formatSQL(std::vector<Any>& arguments);
+		/// Formats the SQL string by filling in placeholders with values from supplied vector.
+
+	void assignSubTotal(bool reset);
+
+	StatementImpl(const StatementImpl& stmt);
+	StatementImpl& operator = (const StatementImpl& stmt);
+
+	typedef std::vector<std::size_t> CountVec;
+
+	State                    _state;
+	Limit                    _extrLimit;
+	std::size_t              _lowerLimit;
+	std::vector<int>         _columnsExtracted;
+	SessionImpl&             _rSession;
+	Storage                  _storage;
+	std::ostringstream       _ostr;
+	AbstractBindingVec       _bindings;
+	AbstractExtractionVecVec _extractors;
+	std::size_t              _curDataSet;
+	BulkType                 _bulkBinding;
+	BulkType                 _bulkExtraction;
+	CountVec                 _subTotalRowCount;
+
+	friend class Statement; 
+};
+
+
+//
+// inlines
+//
+
+
+inline void StatementImpl::addBind(AbstractBinding::Ptr pBinding)
+{
+	poco_check_ptr (pBinding);
+	_bindings.push_back(pBinding);
+}
+
+
+inline std::string StatementImpl::toString() const
+{
+	return _ostr.str();
+}
+
+
+inline const AbstractBindingVec& StatementImpl::bindings() const
+{
+	return _bindings;
+}
+
+
+inline AbstractBindingVec& StatementImpl::bindings()
+{
+	return _bindings;
+}
+
+
+inline const AbstractExtractionVec& StatementImpl::extractions() const
+{
+	poco_assert (_curDataSet < _extractors.size());
+	return _extractors[_curDataSet];
+}
+
+
+inline AbstractExtractionVec& StatementImpl::extractions()
+{
+	poco_assert (_curDataSet < _extractors.size());
+	return _extractors[_curDataSet];
+}
+
+
+inline StatementImpl::State StatementImpl::getState() const
+{
+	return _state;
+}
+
+
+inline SessionImpl& StatementImpl::session()
+{
+	return _rSession;
+}
+
+
+inline void StatementImpl::setStorage(Storage storage)
+{
+	_storage = storage;
+}
+
+
+inline StatementImpl::Storage StatementImpl::getStorage() const
+{
+	return _storage;
+}
+
+
+inline std::size_t StatementImpl::extractionCount() const
+{
+	return static_cast<std::size_t>(extractions().size());
+}
+
+
+inline std::size_t StatementImpl::dataSetCount() const
+{
+	return static_cast<std::size_t>(_extractors.size());
+}
+
+
+inline bool StatementImpl::isStoredProcedure() const
+{
+	return false;
+}
+
+
+inline bool StatementImpl::isNull(std::size_t col, std::size_t row) const
+{
+	try 
+	{
+		return extractions().at(col)->isNull(row);
+	}
+	catch (std::out_of_range& ex)
+	{ 
+		throw RangeException(ex.what()); 
+	}
+}
+
+
+inline std::size_t StatementImpl::currentDataSet() const
+{
+	return _curDataSet;
+}
+
+
+inline Limit::SizeT StatementImpl::getExtractionLimit()
+{
+	return _extrLimit.value();
+}
+
+
+inline const Limit& StatementImpl::extractionLimit() const
+{
+	return _extrLimit;
+}
+
+
+inline void StatementImpl::forbidBulk()
+{
+	_bulkBinding = BULK_FORBIDDEN;
+	_bulkExtraction = BULK_FORBIDDEN;
+}
+
+
+inline void StatementImpl::setBulkBinding()
+{
+	_bulkBinding = BULK_BINDING;
+}
+
+
+inline bool StatementImpl::bulkBindingAllowed() const
+{
+	return BULK_UNDEFINED == _bulkBinding ||
+		BULK_BINDING == _bulkBinding;
+}
+
+
+inline bool StatementImpl::bulkExtractionAllowed() const
+{
+	return BULK_UNDEFINED == _bulkExtraction ||
+		BULK_EXTRACTION == _bulkExtraction;
+}
+
+
+inline bool StatementImpl::isBulkBinding() const
+{
+	return BULK_BINDING == _bulkBinding;
+}
+
+
+inline bool StatementImpl::isBulkExtraction() const
+{
+	return BULK_EXTRACTION == _bulkExtraction;
+}
+
+	
+inline void StatementImpl::resetBulk()
+{
+	_bulkExtraction = BULK_UNDEFINED;
+	_bulkBinding = BULK_UNDEFINED;\
+	setExtractionLimit(Limit(Limit::LIMIT_UNLIMITED, false, false));
+}
+
+
+inline bool StatementImpl::isBulkSupported() const
+{
+	return _rSession.getFeature("bulk");
+}
+
+
+inline bool StatementImpl::hasMoreDataSets() const
+{
+	return currentDataSet() + 1 < dataSetCount();
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_StatementImpl_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/Time.h b/base/poco/Data/include/Poco/Data/Time.h
new file mode 100644
index 00000000000..07116906b01
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/Time.h
@@ -0,0 +1,229 @@
+//
+// Time.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  Time
+//
+// Definition of the Time class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_Time_INCLUDED
+#define Data_Time_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Dynamic/VarHolder.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+namespace Dynamic {
+
+class Var;
+
+}
+
+class DateTime;
+
+namespace Data {
+
+
+class Date;
+
+
+class Data_API Time
+	/// Time class wraps a DateTime and exposes time related interface.
+	/// The purpose of this class is binding/extraction support for time fields.
+{
+public:
+	Time();
+		/// Creates the Time
+
+	Time(int hour, int minute, int second);
+		/// Creates the Time
+
+	Time(const DateTime& dt);
+		/// Creates the Time from DateTime
+
+	~Time();
+		/// Destroys the Time.
+
+	int hour() const;
+		/// Returns the hour.
+
+	int minute() const;
+		/// Returns the minute.
+
+	int second() const;
+		/// Returns the second.
+
+	void assign(int hour, int minute, int second);
+		/// Assigns time.
+
+	Time& operator = (const Time& t);
+		/// Assignment operator for Time.
+
+	Time& operator = (const DateTime& dt);
+		/// Assignment operator for DateTime.
+
+	Time& operator = (const Poco::Dynamic::Var& var);
+		/// Assignment operator for Var.
+
+	bool operator == (const Time& time) const;
+		/// Equality operator.
+
+	bool operator != (const Time& time) const;
+		/// Inequality operator.
+
+	bool operator < (const Time& time) const;
+		/// Less then operator.
+
+	bool operator > (const Time& time) const;
+		/// Greater then operator.
+
+private:
+	int _hour;
+	int _minute;
+	int _second;
+};
+
+
+//
+// inlines
+//
+inline int Time::hour() const
+{
+	return _hour;
+}
+
+
+inline int Time::minute() const
+{
+	return _minute;
+}
+
+
+inline  int Time::second() const
+{
+	return _second;
+}
+
+
+inline Time& Time::operator = (const Time& t)
+{
+	assign(t.hour(), t.minute(), t.second());
+	return *this;
+}
+
+
+inline Time& Time::operator = (const DateTime& dt)
+{
+	assign(dt.hour(), dt.minute(), dt.second());
+	return *this;
+}
+
+
+inline bool Time::operator == (const Time& time) const
+{
+	return _hour == time.hour() &&
+		_minute == time.minute() &&
+		_second == time.second();
+}
+
+
+inline bool Time::operator != (const Time& time) const
+{
+	return !(*this == time);
+}
+
+
+inline bool Time::operator > (const Time& time) const
+{
+	return !(*this == time) && !(*this < time);
+}
+
+
+} } // namespace Poco::Data
+
+
+//
+// VarHolderImpl<Time>
+//
+
+
+namespace Poco {
+namespace Dynamic {
+
+
+template <>
+class VarHolderImpl<Poco::Data::Time>: public VarHolder
+{
+public:
+	VarHolderImpl(const Poco::Data::Time& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+	
+	const std::type_info& type() const
+	{
+		return typeid(Poco::Data::Time);
+	}
+
+	void convert(Poco::Timestamp& val) const
+	{
+		Poco::DateTime dt;
+		dt.assign(dt.year(), dt.month(), dt.day(), _val.hour(), _val.minute(), _val.second());
+		val = dt.timestamp();
+	}
+
+	void convert(Poco::DateTime& val) const
+	{
+		Poco::DateTime dt;
+		dt.assign(dt.year(), dt.month(), dt.day(), _val.hour(), _val.minute(), _val.second());
+		val = dt;
+	}
+
+	void convert(Poco::LocalDateTime& val) const
+	{
+		Poco::LocalDateTime ldt;
+		ldt.assign(ldt.year(), ldt.month(), ldt.day(), _val.hour(), _val.minute(), _val.second());
+		val = ldt;
+	}
+
+	void convert(std::string& val) const
+	{
+		DateTime dt(0, 1, 1, _val.hour(), _val.minute(), _val.second());
+		val = DateTimeFormatter::format(dt, "%H:%M:%S");
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+	
+	const Poco::Data::Time& value() const
+	{
+		return _val;
+	}
+
+private:
+	VarHolderImpl();
+	Poco::Data::Time _val;
+};
+
+
+} } // namespace Poco::Dynamic
+
+
+#endif // Data_Time_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/Transaction.h b/base/poco/Data/include/Poco/Data/Transaction.h
new file mode 100644
index 00000000000..a8fdc4699b1
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/Transaction.h
@@ -0,0 +1,194 @@
+//
+// Transaction.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  Transaction
+//
+// Definition of the Transaction class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+
+#ifndef Data_Transaction_INCLUDED
+#define Data_Transaction_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/Session.h"
+#include "Poco/Logger.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+class Data_API Transaction
+	/// Transaction helps with transactions in domain logic.
+	/// When an Transaction object is created, it first checks whether a
+	/// transaction is in progress. If not, a new transaction is created.
+	/// When the Transaction is destroyed, and commit() has been called,
+	/// nothing is done. Otherwise, the current transaction is rolled back.
+	/// See Transaction for more details and purpose of this template.
+{
+public:
+	Transaction(Poco::Data::Session& session, Poco::Logger* pLogger = 0);
+		/// Creates the Transaction and starts it, using the given database session and logger.
+
+	Transaction(Poco::Data::Session& session, bool start);
+		/// Creates the Transaction, using the given database session.
+		/// If start is true, transaction is started, otherwise begin() must be called
+		/// to start the transaction.
+		
+	template <typename T>
+	Transaction(Poco::Data::Session& rSession, T& t, Poco::Logger* pLogger = 0): 
+		_rSession(rSession),
+		_pLogger(pLogger)
+		/// Creates the Transaction, using the given database session, transactor and logger.
+		/// The transactor type must provide operator () overload taking non-const Session 
+		/// reference as an argument.
+		///
+		/// When transaction is created using this constructor, it is executed and
+		/// commited automatically. If no error occurs, rollback is disabled and does
+		/// not occur at destruction time. If an error occurs resulting in exception being
+		/// thrown, the transaction is rolled back and exception propagated to calling code.
+		/// 
+		/// Example usage:
+		/// 
+		/// struct Transactor
+		/// {
+		///		void operator () (Session& session) const
+		///		{
+		///			// do something ...
+		///		}
+		/// };
+		/// 
+		/// Transactor tr;
+		/// Transaction tn(session, tr); 
+	{
+		try { transact(t); }
+		catch (...)
+		{
+			if (_pLogger) _pLogger->error("Error executing transaction.");
+			rollback();
+			throw;
+		}
+	}
+
+	~Transaction();
+		/// Destroys the Transaction.
+		/// Rolls back the current database transaction if it has not been commited
+		/// (by calling commit()), or rolled back (by calling rollback()).
+		///
+		/// If an exception is thrown during rollback, the exception is logged
+		/// and no further action is taken. 
+
+	void setIsolation(Poco::UInt32 ti);
+		/// Sets the transaction isolation level.
+
+	Poco::UInt32 getIsolation();
+		/// Returns the transaction isolation level.
+
+	bool hasIsolation(Poco::UInt32 ti);
+		/// Returns true iff the transaction isolation level corresponding
+		/// to the supplied bitmask is supported.
+
+	bool isIsolation(Poco::UInt32 ti);
+		/// Returns true iff the transaction isolation level corresponds
+		/// to the supplied bitmask.
+
+	void execute(const std::string& sql, bool doCommit = true);
+		/// Executes and, if doCommit is true, commits the transaction.
+		/// Passing true value for commit disables rollback during destruction
+		/// of this Transaction object.
+
+	void execute(const std::vector<std::string>& sql);
+		/// Executes all the SQL statements supplied in the vector and, after the last
+		/// one is sucesfully executed, commits the transaction.
+		/// If an error occurs during execution, transaction is rolled back.
+		/// Passing true value for commit disables rollback during destruction
+		/// of this Transaction object.
+
+	template <typename T>
+	void transact(T& t)
+		/// Executes the transactor and, unless transactor throws an exception, 
+		/// commits the transaction.
+	{
+		if (!isActive()) begin();
+		t(_rSession);
+		commit();
+	}
+
+	void commit();
+		/// Commits the current transaction.
+		
+	void rollback();
+		/// Rolls back the current transaction.
+		
+	bool isActive();
+		/// Returns false after the transaction has been committed or rolled back,
+		/// true if the transaction is ongoing.
+
+	void setLogger(Poco::Logger* pLogger);
+		/// Sets the logger for this transaction.
+		/// Transaction does not take the ownership of the pointer.
+
+private:
+	Transaction();
+	Transaction(const Transaction&);
+	Transaction& operator = (const Transaction&);
+	
+	void begin();
+		/// Begins the transaction if the session is already not in transaction.
+		/// Otherwise does nothing.
+
+	Session _rSession;
+	Logger* _pLogger;
+};
+
+
+inline bool Transaction::isActive()
+{
+	return _rSession.isTransaction();
+}
+
+
+inline void Transaction::setIsolation(Poco::UInt32 ti)
+{
+	_rSession.setTransactionIsolation(ti);
+}
+
+
+inline Poco::UInt32 Transaction::getIsolation()
+{
+	return _rSession.getTransactionIsolation();
+}
+
+
+inline bool Transaction::hasIsolation(Poco::UInt32 ti)
+{
+	return _rSession.isTransactionIsolation(ti);
+}
+
+
+inline bool Transaction::isIsolation(Poco::UInt32 ti)
+{
+	return _rSession.isTransactionIsolation(ti);
+}
+
+
+inline void Transaction::setLogger(Poco::Logger* pLogger)
+{
+	_pLogger = pLogger;
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_Transaction_INCLUDED
diff --git a/base/poco/Data/include/Poco/Data/TypeHandler.h b/base/poco/Data/include/Poco/Data/TypeHandler.h
new file mode 100644
index 00000000000..4a2424cd1e7
--- /dev/null
+++ b/base/poco/Data/include/Poco/Data/TypeHandler.h
@@ -0,0 +1,2090 @@
+//
+// TypeHandler.h
+//
+// Library: Data
+// Package: DataCore
+// Module:  TypeHandler
+//
+// Definition of the TypeHandler class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Data_TypeHandler_INCLUDED
+#define Data_TypeHandler_INCLUDED
+
+
+#include "Poco/Data/Data.h"
+#include "Poco/Data/AbstractBinder.h"
+#include "Poco/Data/AbstractExtractor.h"
+#include "Poco/Data/AbstractPreparator.h"
+#include "Poco/Nullable.h"
+#include "Poco/Tuple.h"
+#include "Poco/AutoPtr.h"
+#include "Poco/SharedPtr.h"
+#include <cstddef>
+
+
+namespace Poco {
+namespace Data {
+
+
+class AbstractTypeHandler
+	/// Parent class for type handlers. 
+	/// The reason for this class is to prevent instantiations of type handlers.
+	/// For documentation on type handlers, see TypeHandler class.
+{
+protected:
+	AbstractTypeHandler();
+	~AbstractTypeHandler();
+	AbstractTypeHandler(const AbstractTypeHandler&);
+	AbstractTypeHandler& operator = (const AbstractTypeHandler&);
+};
+
+
+template <class T>
+class TypeHandler: public AbstractTypeHandler
+	/// Converts Rows to a Type and the other way around. Provide template specializations to support your own complex types.
+	///
+	/// Take as example the following (simplified) class:
+	///	class Person
+	///	{
+	///	private:
+	///		std::string _lastName;
+	///		std::string _firstName;
+	///		int		 _age;
+	///	public:
+	///		const std::string& getLastName();
+	///		[...] // other set/get methods (returning const reference), a default constructor, 
+	///		[...] // optional < operator (for set, multiset) or function operator (for map, multimap)
+	///	};
+	///
+	/// The TypeHandler must provide a custom bind, size, prepare and extract method:
+	///	
+	///	template <>
+	///	class TypeHandler<struct Person>
+	///	{
+	///	public:
+	///		static std::size_t size()
+	///		{
+	///			return 3; // lastName + firstname + age occupy three columns
+	///		}
+	///	
+	///		static void bind(std::size_t pos, const Person& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	///		{
+	///			// the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Age INTEGER(3))
+	///			// Note that we advance pos by the number of columns the datatype uses! For string/int this is one.
+	///			poco_assert_dbg (!pBinder.isNull());
+	///			TypeHandler<std::string>::bind(pos++, obj.getLastName(), pBinder, dir);
+	///			TypeHandler<std::string>::bind(pos++, obj.getFirstName(), pBinder, dir);
+	///			TypeHandler<int>::bind(pos++, obj.getAge(), pBinder, dir);
+	///		}
+	///	
+	///		static void prepare(std::size_t pos, const Person& obj, AbstractPreparator::Ptr pPreparator)
+	///		{
+	///			// the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Age INTEGER(3))
+	///			poco_assert_dbg (!pPreparator.isNull());
+	///			TypeHandler<std::string>::prepare(pos++, obj.getLastName(), pPreparator);
+	///			TypeHandler<std::string>::prepare(pos++, obj.getFirstName(), pPreparator);
+	///			TypeHandler<int>::prepare(pos++, obj.getAge(), pPreparator);
+	///		}
+	///	
+	///		static void extract(std::size_t pos, Person& obj, const Person& defVal, AbstractExtractor::Ptr pExt)
+	///		{
+	///			// defVal is the default person we should use if we encunter NULL entries, so we take the individual fields
+	///			// as defaults. You can do more complex checking, ie return defVal if only one single entry of the fields is null etc...
+	///			poco_assert_dbg (!pExt.isNull());
+	///			std::string lastName;
+	///			std::string firstName;
+	///			int age = 0;
+	///			// the table is defined as Person (LastName VARCHAR(30), FirstName VARCHAR, Age INTEGER(3))
+	///			TypeHandler<std::string>::extract(pos++, lastName, defVal.getLastName(), pExt);
+	///			TypeHandler<std::string>::extract(pos++, firstName, defVal.getFirstName(), pExt);
+	///			TypeHandler<int>::extract(pos++, age, defVal.getAge(), pExt);
+	///			obj.setLastName(lastName);
+	///			obj.setFirstName(firstName);
+	///			obj.setAge(age);
+	///		}
+	///	};
+	///
+	/// Note that the TypeHandler template specialization must always be declared in the namespace Poco::Data.
+	/// Apart from that no further work is needed. One can now use Person with into and use clauses.
+{
+public:
+	static void bind(std::size_t pos, const T& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		pBinder->bind(pos, obj, dir);
+	}
+
+	static std::size_t size()
+	{
+		return 1u;
+	}
+
+	static void extract(std::size_t pos, T& obj, const T& defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		if (!pExt->extract(pos, obj)) obj = defVal;
+	}
+
+	static void prepare(std::size_t pos, const T& obj, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		pPreparator->prepare(pos, obj);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator = (const TypeHandler&);
+};
+
+
+template <class T>
+class TypeHandler<std::deque<T> >: public AbstractTypeHandler
+	/// Specialization of type handler for std::deque.
+{
+public:
+	static void bind(std::size_t pos, const std::deque<T>& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		pBinder->bind(pos, obj, dir);
+	}
+
+	static std::size_t size()
+	{
+		return 1u;
+	}
+
+	static void extract(std::size_t pos, std::deque<T>& obj, const T& defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		if (!pExt->extract(pos, obj))
+			obj.assign(obj.size(), defVal);
+	}
+
+	static void prepare(std::size_t pos, const std::deque<T>& obj, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		pPreparator->prepare(pos, obj);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator = (const TypeHandler&);
+};
+
+
+template <class T>
+class TypeHandler<std::vector<T> >: public AbstractTypeHandler
+	/// Specialization of type handler for std::vector.
+{
+public:
+	static void bind(std::size_t pos, const std::vector<T>& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		pBinder->bind(pos, obj, dir);
+	}
+
+	static std::size_t size()
+	{
+		return 1u;
+	}
+
+	static void extract(std::size_t pos, std::vector<T>& obj, const T& defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		if (!pExt->extract(pos, obj))
+			obj.assign(obj.size(), defVal);
+	}
+
+	static void prepare(std::size_t pos, const std::vector<T>& obj, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		pPreparator->prepare(pos, obj);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator = (const TypeHandler&);
+};
+
+
+template <class T>
+class TypeHandler<std::list<T> >: public AbstractTypeHandler
+	/// Specialization of type handler for std::list.
+{
+public:
+	static void bind(std::size_t pos, const std::list<T>& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		pBinder->bind(pos, obj, dir);
+	}
+
+	static std::size_t size()
+	{
+		return 1u;
+	}
+
+	static void extract(std::size_t pos, std::list<T>& obj, const T& defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		if (!pExt->extract(pos, obj))
+			obj.assign(obj.size(), defVal);
+	}
+
+	static void prepare(std::size_t pos, const std::list<T>& obj, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		pPreparator->prepare(pos, obj);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator = (const TypeHandler&);
+};
+
+template <typename T>
+class TypeHandler<Nullable<T> > 
+	/// Specialization of type handler for Nullable.
+{
+public:
+
+	static void bind(std::size_t pos, const Nullable<T>& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir) 
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		if (obj.isNull()) 
+		{
+			pBinder->bind(pos++, Poco::Data::Keywords::null, dir);
+		}
+		else 
+		{
+			pBinder->bind(pos++, obj.value(), dir);
+		}
+	}
+	
+	static void prepare(std::size_t pos, const Nullable<T>& obj, AbstractPreparator::Ptr pPreparator) 
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		if (obj.isNull()) 
+		{
+			pPreparator->prepare(pos++, Poco::Data::Keywords::null);
+		}
+		else 
+		{
+			pPreparator->prepare(pos++, obj.value());
+		}
+	}
+
+	static std::size_t size() 
+	{
+		return 1u;
+	}
+
+	static void extract(std::size_t pos, Nullable<T>& obj, const Nullable<T>& , AbstractExtractor::Ptr pExt) 
+	{
+		poco_assert_dbg (!pExt.isNull());
+		T val;
+	
+		if (pExt->extract(pos++, val)) 
+		{
+			obj = val;
+		}
+		else 
+		{
+			obj.clear();
+		}
+	}
+
+private:
+
+	TypeHandler();
+	~TypeHandler();
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+/// Poco::Tuple TypeHandler specializations
+
+// define this macro to nothing for smaller code size
+#define POCO_TUPLE_TYPE_HANDLER_INLINE inline
+
+
+template <typename TupleType, typename Type, int N>
+POCO_TUPLE_TYPE_HANDLER_INLINE
+void tupleBind(std::size_t& pos, TupleType tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+{
+	TypeHandler<Type>::bind(pos, tuple.template get<N>(), pBinder, dir);
+	pos += TypeHandler<Type>::size();
+}
+
+
+template <typename TupleType, typename Type, int N>
+POCO_TUPLE_TYPE_HANDLER_INLINE
+void tuplePrepare(std::size_t& pos, TupleType tuple, AbstractPreparator::Ptr pPreparator)
+{
+	TypeHandler<Type>::prepare(pos, tuple.template get<N>(), pPreparator);
+	pos += TypeHandler<Type>::size();
+}
+
+
+template <typename TupleType, typename DefValType, typename Type, int N>
+POCO_TUPLE_TYPE_HANDLER_INLINE
+void tupleExtract(std::size_t& pos, TupleType tuple, DefValType defVal, AbstractExtractor::Ptr pExt)
+{
+	Poco::Data::TypeHandler<Type>::extract(pos, tuple.template get<N>(),
+	defVal.template get<N>(), pExt);
+	pos += TypeHandler<Type>::size();
+}
+
+
+template <class T0, 
+	class T1, 
+	class T2, 
+	class T3, 
+	class T4, 
+	class T5, 
+	class T6, 
+	class T7, 
+	class T8, 
+	class T9, 
+	class T10, 
+	class T11, 
+	class T12, 
+	class T13, 
+	class T14, 
+	class T15, 
+	class T16, 
+	class T17, 
+	class T18, 
+	class T19>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T19, 19>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T19, 19>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size() +
+			TypeHandler<T2>::size() +
+			TypeHandler<T3>::size() +
+			TypeHandler<T4>::size() +
+			TypeHandler<T5>::size() +
+			TypeHandler<T6>::size() +
+			TypeHandler<T7>::size() +
+			TypeHandler<T8>::size() +
+			TypeHandler<T9>::size() +
+			TypeHandler<T10>::size() +
+			TypeHandler<T11>::size() +
+			TypeHandler<T12>::size() +
+			TypeHandler<T13>::size() +
+			TypeHandler<T14>::size() +
+			TypeHandler<T15>::size() +
+			TypeHandler<T16>::size() +
+			TypeHandler<T17>::size() +
+			TypeHandler<T18>::size() +
+			TypeHandler<T19>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T19, 19>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0, 
+	class T1, 
+	class T2, 
+	class T3, 
+	class T4, 
+	class T5, 
+	class T6, 
+	class T7, 
+	class T8, 
+	class T9, 
+	class T10, 
+	class T11, 
+	class T12, 
+	class T13, 
+	class T14, 
+	class T15, 
+	class T16, 
+	class T17, 
+	class T18>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T18, 18>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T18, 18>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size() +
+			TypeHandler<T2>::size() +
+			TypeHandler<T3>::size() +
+			TypeHandler<T4>::size() +
+			TypeHandler<T5>::size() +
+			TypeHandler<T6>::size() +
+			TypeHandler<T7>::size() +
+			TypeHandler<T8>::size() +
+			TypeHandler<T9>::size() +
+			TypeHandler<T10>::size() +
+			TypeHandler<T11>::size() +
+			TypeHandler<T12>::size() +
+			TypeHandler<T13>::size() +
+			TypeHandler<T14>::size() +
+			TypeHandler<T15>::size() +
+			TypeHandler<T16>::size() +
+			TypeHandler<T17>::size() +
+			TypeHandler<T18>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T18, 18>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0, 
+	class T1, 
+	class T2, 
+	class T3, 
+	class T4, 
+	class T5, 
+	class T6, 
+	class T7, 
+	class T8, 
+	class T9, 
+	class T10, 
+	class T11, 
+	class T12, 
+	class T13, 
+	class T14, 
+	class T15, 
+	class T16, 
+	class T17>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T17, 17>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T17, 17>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size() +
+			TypeHandler<T2>::size() +
+			TypeHandler<T3>::size() +
+			TypeHandler<T4>::size() +
+			TypeHandler<T5>::size() +
+			TypeHandler<T6>::size() +
+			TypeHandler<T7>::size() +
+			TypeHandler<T8>::size() +
+			TypeHandler<T9>::size() +
+			TypeHandler<T10>::size() +
+			TypeHandler<T11>::size() +
+			TypeHandler<T12>::size() +
+			TypeHandler<T13>::size() +
+			TypeHandler<T14>::size() +
+			TypeHandler<T15>::size() +
+			TypeHandler<T16>::size() +
+			TypeHandler<T17>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T17, 17>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0, 
+	class T1, 
+	class T2, 
+	class T3, 
+	class T4, 
+	class T5, 
+	class T6, 
+	class T7, 
+	class T8, 
+	class T9, 
+	class T10, 
+	class T11, 
+	class T12, 
+	class T13, 
+	class T14, 
+	class T15, 
+	class T16>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T16, 16>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T16, 16>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size() +
+			TypeHandler<T2>::size() +
+			TypeHandler<T3>::size() +
+			TypeHandler<T4>::size() +
+			TypeHandler<T5>::size() +
+			TypeHandler<T6>::size() +
+			TypeHandler<T7>::size() +
+			TypeHandler<T8>::size() +
+			TypeHandler<T9>::size() +
+			TypeHandler<T10>::size() +
+			TypeHandler<T11>::size() +
+			TypeHandler<T12>::size() +
+			TypeHandler<T13>::size() +
+			TypeHandler<T14>::size() +
+			TypeHandler<T15>::size() +
+			TypeHandler<T16>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T16, 16>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0, 
+	class T1, 
+	class T2, 
+	class T3, 
+	class T4, 
+	class T5, 
+	class T6, 
+	class T7, 
+	class T8, 
+	class T9, 
+	class T10, 
+	class T11, 
+	class T12, 
+	class T13, 
+	class T14, 
+	class T15>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T15, 15>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T15, 15>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size() +
+			TypeHandler<T2>::size() +
+			TypeHandler<T3>::size() +
+			TypeHandler<T4>::size() +
+			TypeHandler<T5>::size() +
+			TypeHandler<T6>::size() +
+			TypeHandler<T7>::size() +
+			TypeHandler<T8>::size() +
+			TypeHandler<T9>::size() +
+			TypeHandler<T10>::size() +
+			TypeHandler<T11>::size() +
+			TypeHandler<T12>::size() +
+			TypeHandler<T13>::size() +
+			TypeHandler<T14>::size() +
+			TypeHandler<T15>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T15, 15>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0, 
+	class T1, 
+	class T2, 
+	class T3, 
+	class T4, 
+	class T5, 
+	class T6, 
+	class T7, 
+	class T8, 
+	class T9, 
+	class T10, 
+	class T11, 
+	class T12, 
+	class T13, 
+	class T14>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T14, 14>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T14, 14>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size() +
+			TypeHandler<T2>::size() +
+			TypeHandler<T3>::size() +
+			TypeHandler<T4>::size() +
+			TypeHandler<T5>::size() +
+			TypeHandler<T6>::size() +
+			TypeHandler<T7>::size() +
+			TypeHandler<T8>::size() +
+			TypeHandler<T9>::size() +
+			TypeHandler<T10>::size() +
+			TypeHandler<T11>::size() +
+			TypeHandler<T12>::size() +
+			TypeHandler<T13>::size() +
+			TypeHandler<T14>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T14, 14>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0, 
+	class T1, 
+	class T2, 
+	class T3, 
+	class T4, 
+	class T5, 
+	class T6, 
+	class T7, 
+	class T8, 
+	class T9, 
+	class T10, 
+	class T11, 
+	class T12, 
+	class T13>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T13, 13>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T13, 13>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size() +
+			TypeHandler<T2>::size() +
+			TypeHandler<T3>::size() +
+			TypeHandler<T4>::size() +
+			TypeHandler<T5>::size() +
+			TypeHandler<T6>::size() +
+			TypeHandler<T7>::size() +
+			TypeHandler<T8>::size() +
+			TypeHandler<T9>::size() +
+			TypeHandler<T10>::size() +
+			TypeHandler<T11>::size() +
+			TypeHandler<T12>::size() +
+			TypeHandler<T13>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T13, 13>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0, 
+	class T1, 
+	class T2, 
+	class T3, 
+	class T4, 
+	class T5, 
+	class T6, 
+	class T7, 
+	class T8, 
+	class T9, 
+	class T10, 
+	class T11, 
+	class T12>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T12, 12>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T12, 12>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size() +
+			TypeHandler<T2>::size() +
+			TypeHandler<T3>::size() +
+			TypeHandler<T4>::size() +
+			TypeHandler<T5>::size() +
+			TypeHandler<T6>::size() +
+			TypeHandler<T7>::size() +
+			TypeHandler<T8>::size() +
+			TypeHandler<T9>::size() +
+			TypeHandler<T10>::size() +
+			TypeHandler<T11>::size() +
+			TypeHandler<T12>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T12, 12>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0, 
+	class T1, 
+	class T2, 
+	class T3, 
+	class T4, 
+	class T5, 
+	class T6, 
+	class T7, 
+	class T8, 
+	class T9, 
+	class T10, 
+	class T11>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T11, 11>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T11, 11>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size() +
+			TypeHandler<T2>::size() +
+			TypeHandler<T3>::size() +
+			TypeHandler<T4>::size() +
+			TypeHandler<T5>::size() +
+			TypeHandler<T6>::size() +
+			TypeHandler<T7>::size() +
+			TypeHandler<T8>::size() +
+			TypeHandler<T9>::size() +
+			TypeHandler<T10>::size() +
+			TypeHandler<T11>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T11, 11>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0, 
+	class T1, 
+	class T2, 
+	class T3, 
+	class T4, 
+	class T5, 
+	class T6, 
+	class T7, 
+	class T8, 
+	class T9, 
+	class T10>
+class TypeHandler<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T10, 10>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T10, 10>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size() +
+			TypeHandler<T2>::size() +
+			TypeHandler<T3>::size() +
+			TypeHandler<T4>::size() +
+			TypeHandler<T5>::size() +
+			TypeHandler<T6>::size() +
+			TypeHandler<T7>::size() +
+			TypeHandler<T8>::size() +
+			TypeHandler<T9>::size() +
+			TypeHandler<T10>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T10, 10>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
+class TypeHandler<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T9, 9>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T9, 9>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size() +
+			TypeHandler<T2>::size() +
+			TypeHandler<T3>::size() +
+			TypeHandler<T4>::size() +
+			TypeHandler<T5>::size() +
+			TypeHandler<T6>::size() +
+			TypeHandler<T7>::size() +
+			TypeHandler<T8>::size() +
+			TypeHandler<T9>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T9, 9>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
+class TypeHandler<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, NullTypeList> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, NullTypeList> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, NullTypeList> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T8, 8>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T8, 8>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size() +
+			TypeHandler<T2>::size() +
+			TypeHandler<T3>::size() +
+			TypeHandler<T4>::size() +
+			TypeHandler<T5>::size() +
+			TypeHandler<T6>::size() +
+			TypeHandler<T7>::size() +
+			TypeHandler<T8>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T8, 8>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7>
+class TypeHandler<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, NullTypeList> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, NullTypeList> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, T7, NullTypeList> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T7, 7>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T7, 7>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size() +
+			TypeHandler<T2>::size() +
+			TypeHandler<T3>::size() +
+			TypeHandler<T4>::size() +
+			TypeHandler<T5>::size() +
+			TypeHandler<T6>::size() +
+			TypeHandler<T7>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T7, 7>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0, class T1, class T2, class T3, class T4, class T5, class T6>
+class TypeHandler<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, NullTypeList> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, NullTypeList> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, T6, NullTypeList> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T6, 6>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T6, 6>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size() +
+			TypeHandler<T2>::size() +
+			TypeHandler<T3>::size() +
+			TypeHandler<T4>::size() +
+			TypeHandler<T5>::size() +
+			TypeHandler<T6>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T6, 6>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0, class T1, class T2, class T3, class T4, class T5>
+class TypeHandler<Poco::Tuple<T0, T1, T2, T3, T4, T5, NullTypeList> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, NullTypeList> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, T5, NullTypeList> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T5, 5>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T5, 5>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size() +
+			TypeHandler<T2>::size() +
+			TypeHandler<T3>::size() +
+			TypeHandler<T4>::size() +
+			TypeHandler<T5>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T5, 5>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0, class T1, class T2, class T3, class T4>
+class TypeHandler<Poco::Tuple<T0, T1, T2, T3, T4, NullTypeList> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, NullTypeList> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, T4, NullTypeList> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T4, 4>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T4, 4>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size() +
+			TypeHandler<T2>::size() +
+			TypeHandler<T3>::size() +
+			TypeHandler<T4>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T4, 4>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0, class T1, class T2, class T3>
+class TypeHandler<Poco::Tuple<T0, T1, T2, T3, NullTypeList> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, NullTypeList> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, T3, NullTypeList> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T3, 3>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T3, 3>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size() +
+			TypeHandler<T2>::size() +
+			TypeHandler<T3>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T3, 3>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0, class T1, class T2>
+	class TypeHandler<Poco::Tuple<T0, T1, T2, NullTypeList> >
+{
+public:
+		typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, NullTypeList> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, T2, NullTypeList> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T2, 2>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T2, 2>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size() +
+			TypeHandler<T2>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T2, 2>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0, class T1>
+class TypeHandler<Poco::Tuple<T0, T1, NullTypeList> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, NullTypeList> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, T1, NullTypeList> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+		tupleBind<TupleConstRef, T1, 1>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+		tuplePrepare<TupleConstRef, T1, 1>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size() +
+			TypeHandler<T1>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+		tupleExtract<TupleRef, TupleConstRef, T1, 1>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class T0>
+class TypeHandler<Poco::Tuple<T0, NullTypeList> >
+{
+public:
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, NullTypeList> >::CONSTREFTYPE TupleConstRef;
+	typedef typename Poco::TypeWrapper<Poco::Tuple<T0, NullTypeList> >::REFTYPE	  TupleRef;
+
+	static void bind(std::size_t pos, TupleConstRef tuple, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		poco_assert_dbg (!pBinder.isNull());
+		tupleBind<TupleConstRef, T0, 0>(pos, tuple, pBinder, dir);
+	}
+
+	static void prepare(std::size_t pos, TupleConstRef tuple, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		tuplePrepare<TupleConstRef, T0, 0>(pos, tuple, pPreparator);
+	}
+
+	static std::size_t size()
+	{
+		return TypeHandler<T0>::size();
+	}
+
+	static void extract(std::size_t pos, TupleRef tuple, TupleConstRef defVal, 
+		AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		tupleExtract<TupleRef, TupleConstRef, T0, 0>(pos, tuple, defVal, pExt);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator=(const TypeHandler&);
+};
+
+
+template <class K, class V>
+class TypeHandler<std::pair<K, V> >: public AbstractTypeHandler
+{
+public:
+	static void bind(std::size_t pos, const std::pair<K, V>& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		TypeHandler<K>::bind(pos, obj.first, pBinder, dir);
+		pos += TypeHandler<K>::size();
+		TypeHandler<V>::bind(pos, obj.second, pBinder, dir);
+	}
+
+	static std::size_t size()
+	{
+		return static_cast<std::size_t>(TypeHandler<K>::size() + TypeHandler<V>::size());
+	}
+
+	static void extract(std::size_t pos, std::pair<K, V>& obj, const std::pair<K, V>& defVal, AbstractExtractor::Ptr pExt)
+	{
+		TypeHandler<K>::extract(pos, obj.first, defVal.first, pExt);
+		pos += TypeHandler<K>::size();
+		TypeHandler<V>::extract(pos, obj.second, defVal.second, pExt);
+	}
+
+	static void prepare(std::size_t pos, const std::pair<K, V>& obj, AbstractPreparator::Ptr pPreparator)
+	{
+		TypeHandler<K>::prepare(pos, obj.first, pPreparator);
+		pos += TypeHandler<K>::size();
+		TypeHandler<V>::prepare(pos, obj.second, pPreparator);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator = (const TypeHandler&);
+};
+
+
+template <class T>
+class TypeHandler<Poco::AutoPtr<T> >: public AbstractTypeHandler
+	/// Specialization of type handler for Poco::AutoPtr
+{
+public:
+	static void bind(std::size_t pos, const Poco::AutoPtr<T>& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		// *obj will trigger a nullpointer exception if empty: this is on purpose
+		TypeHandler<T>::bind(pos, *obj, pBinder, dir); 
+	}
+
+	static std::size_t size()
+	{
+		return static_cast<std::size_t>(TypeHandler<T>::size());
+	}
+
+	static void extract(std::size_t pos, Poco::AutoPtr<T>& obj, const Poco::AutoPtr<T>& defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		
+		obj = Poco::AutoPtr<T>(new T());
+		if (defVal)
+			TypeHandler<T>::extract(pos, *obj, *defVal, pExt);
+		else
+			TypeHandler<T>::extract(pos, *obj, *obj, pExt);
+	}
+
+	static void prepare(std::size_t pos, const Poco::AutoPtr<T>&, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		TypeHandler<T>::prepare(pos, T(), pPreparator);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator = (const TypeHandler&);
+};
+
+
+
+template <class T>
+class TypeHandler<Poco::SharedPtr<T> >: public AbstractTypeHandler
+	/// Specialization of type handler for Poco::SharedPtr
+{
+public:
+	static void bind(std::size_t pos, const Poco::SharedPtr<T>& obj, AbstractBinder::Ptr pBinder, AbstractBinder::Direction dir)
+	{
+		// *obj will trigger a nullpointer exception if empty
+		TypeHandler<T>::bind(pos, *obj, pBinder, dir); 
+	}
+
+	static std::size_t size()
+	{
+		return static_cast<std::size_t>(TypeHandler<T>::size());
+	}
+
+	static void extract(std::size_t pos, Poco::SharedPtr<T>& obj, const Poco::SharedPtr<T>& defVal, AbstractExtractor::Ptr pExt)
+	{
+		poco_assert_dbg (!pExt.isNull());
+		
+		obj = Poco::SharedPtr<T>(new T());
+		if (defVal)
+			TypeHandler<T>::extract(pos, *obj, *defVal, pExt);
+		else
+			TypeHandler<T>::extract(pos, *obj, *obj, pExt);
+	}
+
+	static void prepare(std::size_t pos, const Poco::SharedPtr<T>&, AbstractPreparator::Ptr pPreparator)
+	{
+		poco_assert_dbg (!pPreparator.isNull());
+		TypeHandler<T>::prepare(pos, T(), pPreparator);
+	}
+
+private:
+	TypeHandler(const TypeHandler&);
+	TypeHandler& operator = (const TypeHandler&);
+};
+
+
+} } // namespace Poco::Data
+
+
+#endif // Data_TypeHandler_INCLUDED
diff --git a/base/poco/Data/src/AbstractBinder.cpp b/base/poco/Data/src/AbstractBinder.cpp
new file mode 100644
index 00000000000..4854467eb20
--- /dev/null
+++ b/base/poco/Data/src/AbstractBinder.cpp
@@ -0,0 +1,527 @@
+//
+// AbstractBinder.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractBinder
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/AbstractBinder.h"
+#include "Poco/Data/Date.h"
+#include "Poco/Data/Time.h"
+#include "Poco/Data/LOB.h"
+#include "Poco/Data/DataException.h"
+#include "Poco/DateTime.h"
+#include "Poco/Any.h"
+#include "Poco/Dynamic/Var.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+AbstractBinder::AbstractBinder()
+{
+}
+
+
+AbstractBinder::~AbstractBinder()
+{
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<Poco::Int8>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<Poco::Int8>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<Poco::Int8>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<Poco::UInt8>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<Poco::UInt8>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<Poco::UInt8>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<Poco::Int16>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<Poco::Int16>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<Poco::Int16>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<Poco::UInt16>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<Poco::UInt16>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<Poco::UInt16>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<Poco::Int32>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<Poco::Int32>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<Poco::Int32>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<Poco::UInt32>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<Poco::UInt32>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<Poco::UInt32>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<Poco::Int64>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<Poco::Int64>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<Poco::Int64>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+	
+void AbstractBinder::bind(std::size_t pos, const std::vector<Poco::UInt64>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+	
+void AbstractBinder::bind(std::size_t pos, const std::deque<Poco::UInt64>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+	
+void AbstractBinder::bind(std::size_t pos, const std::list<Poco::UInt64>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+#ifndef POCO_LONG_IS_64_BIT
+void AbstractBinder::bind(std::size_t pos, const std::vector<long>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<long>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<long>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+#endif
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<bool>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<bool>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<bool>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<float>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<float>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<float>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<double>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<double>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<double>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<char>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<char>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<char>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<std::string>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<std::string>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<std::string>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const UTF16String& val, Direction dir)
+{
+	throw NotImplementedException("UTF16String binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<UTF16String>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<UTF16String>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<UTF16String>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<BLOB>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<BLOB>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<BLOB>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<CLOB>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<CLOB>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<CLOB>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<DateTime>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<DateTime>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<DateTime>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<Date>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<Date>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<Date>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<Time>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<Time>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<Time>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::vector<NullData>& val, Direction dir)
+{
+	throw NotImplementedException("std::vector binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::deque<NullData>& val, Direction dir)
+{
+	throw NotImplementedException("std::deque binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const std::list<NullData>& val, Direction dir)
+{
+	throw NotImplementedException("std::list binder must be implemented.");
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const Any& val, Direction dir)
+{
+	const std::type_info& type = val.type();
+
+	if(type == typeid(Int32))
+		bind(pos, RefAnyCast<Int32>(val), dir);
+	else if(type == typeid(std::string))
+		bind(pos, RefAnyCast<std::string>(val), dir);
+	else if (type == typeid(Poco::UTF16String))
+		bind(pos, RefAnyCast<Poco::UTF16String>(val), dir);
+	else if (type == typeid(bool))
+		bind(pos, RefAnyCast<bool>(val), dir);
+	else if(type == typeid(char))
+		bind(pos, RefAnyCast<char>(val), dir);
+	else if(type == typeid(Int8))
+		bind(pos, RefAnyCast<Int8>(val), dir);
+	else if(type == typeid(UInt8))
+		bind(pos, RefAnyCast<UInt8>(val), dir);
+	else if(type == typeid(Int16))
+		bind(pos, RefAnyCast<Int16>(val), dir);
+	else if(type == typeid(UInt16))
+		bind(pos, RefAnyCast<UInt16>(val), dir);
+	else if(type == typeid(UInt32))
+		bind(pos, RefAnyCast<UInt32>(val), dir);
+	else if(type == typeid(Int64))
+		bind(pos, RefAnyCast<Int64>(val), dir);
+	else if(type == typeid(UInt64))
+		bind(pos, RefAnyCast<UInt64>(val), dir);
+	else if(type == typeid(float))
+		bind(pos, RefAnyCast<float>(val), dir);
+	else if(type == typeid(double))
+		bind(pos, RefAnyCast<double>(val), dir);
+	else if(type == typeid(DateTime))
+		bind(pos, RefAnyCast<DateTime>(val), dir);
+	else if(type == typeid(Date))
+		bind(pos, RefAnyCast<Date>(val), dir);
+	else if(type == typeid(Time))
+		bind(pos, RefAnyCast<Time>(val), dir);
+	else if(type == typeid(BLOB))
+		bind(pos, RefAnyCast<BLOB>(val), dir);
+	else if(type == typeid(void))
+		bind(pos, Keywords::null, dir);
+#ifndef POCO_LONG_IS_64_BIT
+	else if(type == typeid(long))
+		bind(pos, RefAnyCast<long>(val), dir);
+#endif
+	else
+		throw UnknownTypeException(std::string(val.type().name()));
+}
+
+
+void AbstractBinder::bind(std::size_t pos, const Poco::Dynamic::Var& val, Direction dir)
+{
+	const std::type_info& type = val.type();
+
+	if(type == typeid(Int32))
+		bind(pos, val.extract<Int32>(), dir);
+	else if(type == typeid(std::string))
+		bind(pos, val.extract<std::string>(), dir);
+	else if (type == typeid(Poco::UTF16String))
+		bind(pos, val.extract<Poco::UTF16String>(), dir);
+	else if (type == typeid(bool))
+		bind(pos, val.extract<bool>(), dir);
+	else if(type == typeid(char))
+		bind(pos, val.extract<char>(), dir);
+	else if(type == typeid(Int8))
+		bind(pos, val.extract<Int8>(), dir);
+	else if(type == typeid(UInt8))
+		bind(pos, val.extract<UInt8>(), dir);
+	else if(type == typeid(Int16))
+		bind(pos, val.extract<Int16>(), dir);
+	else if(type == typeid(UInt16))
+		bind(pos, val.extract<UInt16>(), dir);
+	else if(type == typeid(UInt32))
+		bind(pos, val.extract<UInt32>(), dir);
+	else if(type == typeid(Int64))
+		bind(pos, val.extract<Int64>(), dir);
+	else if(type == typeid(UInt64))
+		bind(pos, val.extract<UInt64>(), dir);
+	else if(type == typeid(float))
+		bind(pos, val.extract<float>(), dir);
+	else if(type == typeid(double))
+		bind(pos, val.extract<double>(), dir);
+	else if(type == typeid(DateTime))
+		bind(pos, val.extract<DateTime>(), dir);
+	else if(type == typeid(Date))
+		bind(pos, val.extract<Date>(), dir);
+	else if(type == typeid(Time))
+		bind(pos, val.extract<Time>(), dir);
+	else if(type == typeid(BLOB))
+		bind(pos, val.extract<BLOB>(), dir);
+	else if(type == typeid(void))
+		bind(pos, Keywords::null, dir);
+#ifndef POCO_LONG_IS_64_BIT
+	else if(type == typeid(long))
+		bind(pos, val.extract<long>(), dir);
+#endif
+	else
+		throw UnknownTypeException(std::string(val.type().name()));
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/AbstractBinding.cpp b/base/poco/Data/src/AbstractBinding.cpp
new file mode 100644
index 00000000000..d30ccd1d8b7
--- /dev/null
+++ b/base/poco/Data/src/AbstractBinding.cpp
@@ -0,0 +1,45 @@
+//
+// AbstractBinding.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractBinding
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/AbstractBinding.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+AbstractBinding::AbstractBinding(const std::string& name, 
+	Direction direction, 
+	Poco::UInt32 bulkSize): 
+	_pBinder(0),
+	_name(name),
+	_direction(direction),
+	_bulkSize(bulkSize)
+{
+}
+
+
+AbstractBinding::~AbstractBinding()
+{
+}
+
+
+void AbstractBinding::setBinder(BinderPtr pBinder)
+{
+	poco_check_ptr (pBinder);
+	_pBinder = pBinder;
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/AbstractExtraction.cpp b/base/poco/Data/src/AbstractExtraction.cpp
new file mode 100644
index 00000000000..ac3f83927ec
--- /dev/null
+++ b/base/poco/Data/src/AbstractExtraction.cpp
@@ -0,0 +1,40 @@
+//
+// AbstractExtraction.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractExtraction
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/AbstractExtraction.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+AbstractExtraction::AbstractExtraction(Poco::UInt32 limit,
+	Poco::UInt32 position,
+	bool bulk): 
+	_pExtractor(0), 
+	_limit(limit),
+	_position(position),
+	_bulk(bulk),
+	_emptyStringIsNull(false),
+	_forceEmptyString(false)
+{
+}
+
+
+AbstractExtraction::~AbstractExtraction()
+{
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/AbstractExtractor.cpp b/base/poco/Data/src/AbstractExtractor.cpp
new file mode 100644
index 00000000000..566c721abe3
--- /dev/null
+++ b/base/poco/Data/src/AbstractExtractor.cpp
@@ -0,0 +1,437 @@
+//
+// AbstractExtractor.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractExtractor
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/AbstractExtractor.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+AbstractExtractor::AbstractExtractor()
+{
+}
+
+
+AbstractExtractor::~AbstractExtractor()
+{
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Poco::Int8>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<Poco::Int8>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<Poco::Int8>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Poco::UInt8>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<Poco::UInt8>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<Poco::UInt8>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Poco::Int16>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<Poco::Int16>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<Poco::Int16>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Poco::UInt16>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<Poco::UInt16>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<Poco::UInt16>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Poco::Int32>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<Poco::Int32>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<Poco::Int32>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Poco::UInt32>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<Poco::UInt32>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<Poco::UInt32>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Poco::Int64>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<Poco::Int64>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<Poco::Int64>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Poco::UInt64>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<Poco::UInt64>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<Poco::UInt64>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+#ifndef POCO_LONG_IS_64_BIT
+bool AbstractExtractor::extract(std::size_t pos, std::vector<long>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<long>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<long>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+#endif
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<bool>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<bool>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<bool>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<float>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<float>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<float>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<double>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<double>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<double>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<char>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<char>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<char>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<std::string>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<std::string>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<std::string>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, UTF16String& val)
+{
+	throw NotImplementedException("UTF16String extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<UTF16String>& val)
+{
+	throw NotImplementedException("std::vector<UTF16String> extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<UTF16String>& val)
+{
+	throw NotImplementedException("std::deque<UTF16String> extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<UTF16String>& val)
+{
+	throw NotImplementedException("std::list<UTF16String> extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<BLOB>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<BLOB>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<BLOB>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<CLOB>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<CLOB>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<CLOB>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<DateTime>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<DateTime>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<DateTime>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Date>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<Date>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<Date>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Time>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<Time>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<Time>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Any>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<Any>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<Any>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::vector<Poco::Dynamic::Var>& val)
+{
+	throw NotImplementedException("std::vector extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::deque<Poco::Dynamic::Var>& val)
+{
+	throw NotImplementedException("std::deque extractor must be implemented.");
+}
+
+
+bool AbstractExtractor::extract(std::size_t pos, std::list<Poco::Dynamic::Var>& val)
+{
+	throw NotImplementedException("std::list extractor must be implemented.");
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/AbstractPreparation.cpp b/base/poco/Data/src/AbstractPreparation.cpp
new file mode 100644
index 00000000000..0d8f4c690c3
--- /dev/null
+++ b/base/poco/Data/src/AbstractPreparation.cpp
@@ -0,0 +1,34 @@
+//
+// AbstractPreparation.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractPreparation
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/AbstractPreparation.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+AbstractPreparation::AbstractPreparation(PreparatorPtr pPreparator):
+	_pPreparator(pPreparator)
+{
+	poco_assert_dbg (_pPreparator);
+}
+
+
+AbstractPreparation::~AbstractPreparation()
+{
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/AbstractPreparator.cpp b/base/poco/Data/src/AbstractPreparator.cpp
new file mode 100644
index 00000000000..58eb4fb72de
--- /dev/null
+++ b/base/poco/Data/src/AbstractPreparator.cpp
@@ -0,0 +1,438 @@
+//
+// AbstractPreparator.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  AbstractPreparator
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/AbstractPreparator.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+AbstractPreparator::AbstractPreparator(Poco::UInt32 length): 
+	_length(length),
+	_bulk(false)
+{
+}
+
+
+AbstractPreparator::~AbstractPreparator()
+{
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<Poco::Int8>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<Poco::Int8>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<Poco::Int8>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<Poco::UInt8>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<Poco::UInt8>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<Poco::UInt8>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<Poco::Int16>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<Poco::Int16>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<Poco::Int16>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<Poco::UInt16>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<Poco::UInt16>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<Poco::UInt16>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<Poco::Int32>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<Poco::Int32>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<Poco::Int32>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<Poco::UInt32>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<Poco::UInt32>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<Poco::UInt32>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<Poco::Int64>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<Poco::Int64>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<Poco::Int64>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<Poco::UInt64>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<Poco::UInt64>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<Poco::UInt64>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+#ifndef POCO_LONG_IS_64_BIT
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<long>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<long>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<long>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+#endif
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<bool>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<bool>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<bool>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<float>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<float>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<float>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<double>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<double>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<double>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<char>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<char>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<char>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<std::string>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<std::string>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<std::string>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const UTF16String& val)
+{
+	throw NotImplementedException("UTF16String preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<UTF16String>& val)
+{
+	throw NotImplementedException("std::vector<UTF16String> preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<UTF16String>& val)
+{
+	throw NotImplementedException("std::deque<UTF16String> preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<UTF16String>& val)
+{
+	throw NotImplementedException("std::list<UTF16String> preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<BLOB>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<BLOB>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<BLOB>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<CLOB>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<CLOB>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<CLOB>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<DateTime>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<DateTime>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<DateTime>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<Date>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<Date>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<Date>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<Time>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<Time>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<Time>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<Any>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<Any>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<Any>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::vector<Poco::Dynamic::Var>& val)
+{
+	throw NotImplementedException("std::vector preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::deque<Poco::Dynamic::Var>& val)
+{
+	throw NotImplementedException("std::deque preparator must be implemented.");
+}
+
+
+void AbstractPreparator::prepare(std::size_t pos, const std::list<Poco::Dynamic::Var>& val)
+{
+	throw NotImplementedException("std::list preparator must be implemented.");
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/ArchiveStrategy.cpp b/base/poco/Data/src/ArchiveStrategy.cpp
new file mode 100644
index 00000000000..2d8842ba209
--- /dev/null
+++ b/base/poco/Data/src/ArchiveStrategy.cpp
@@ -0,0 +1,146 @@
+//
+// ArchiveStrategy.cpp
+//
+// Library: Data
+// Package: Logging
+// Module:  ArchiveStrategy
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/ArchiveStrategy.h"
+#include "Poco/Ascii.h"
+
+namespace Poco {
+namespace Data {
+
+
+using namespace Keywords;
+
+//
+// ArchiveStrategy
+//
+
+
+const std::string ArchiveStrategy::DEFAULT_ARCHIVE_DESTINATION = "T_POCO_LOG_ARCHIVE";
+
+
+ArchiveStrategy::ArchiveStrategy(const std::string& connector,
+	const std::string& connect, 
+	const std::string& source, 
+	const std::string& destination):
+	_connector(connector),
+	_connect(connect),
+	_source(source),
+	_destination(destination)
+{
+	open();
+}
+
+
+ArchiveStrategy::~ArchiveStrategy()
+{
+}
+
+
+void ArchiveStrategy::open()
+{
+	if (_connector.empty() || _connect.empty())
+		throw IllegalStateException("Connector and connect string must be non-empty.");
+
+	_pSession = new Session(_connector, _connect);
+}
+
+
+//
+// ArchiveByAgeStrategy
+//
+
+
+ArchiveByAgeStrategy::ArchiveByAgeStrategy(const std::string& connector, 
+	const std::string& connect, 
+	const std::string& sourceTable, 
+	const std::string& destinationTable):
+	ArchiveStrategy(connector, connect, sourceTable, destinationTable)
+{
+	initStatements();
+}
+
+
+ArchiveByAgeStrategy::~ArchiveByAgeStrategy()
+{
+}
+
+
+void ArchiveByAgeStrategy::archive()
+{
+	if (!session().isConnected()) open();
+
+	DateTime now;
+	_archiveDateTime = now - _maxAge;
+	getCountStatement().execute();
+	if (_archiveCount > 0)
+	{
+		getCopyStatement().execute();
+		getDeleteStatement().execute();
+	}
+}
+
+
+void ArchiveByAgeStrategy::initStatements()
+{
+	std::string src = getSource();
+	std::string dest = getDestination();
+
+	setCountStatement();
+	_archiveCount = 0;
+	std::string sql;
+	Poco::format(sql, "SELECT COUNT(*) FROM %s WHERE DateTime < ?", src);
+	getCountStatement() << sql, into(_archiveCount), use(_archiveDateTime);
+
+	setCopyStatement();
+	sql.clear();
+	Poco::format(sql, "INSERT INTO %s SELECT * FROM %s WHERE DateTime < ?", dest, src);
+	getCopyStatement() << sql, use(_archiveDateTime);
+
+	setDeleteStatement();
+	sql.clear();
+	Poco::format(sql, "DELETE FROM %s WHERE DateTime < ?", src);
+	getDeleteStatement() << sql, use(_archiveDateTime);
+}
+
+
+void ArchiveByAgeStrategy::setThreshold(const std::string& age)
+{
+	std::string::const_iterator it  = age.begin();
+	std::string::const_iterator end = age.end();
+	int n = 0;
+	while (it != end && Ascii::isSpace(*it)) ++it;
+	while (it != end && Ascii::isDigit(*it)) { n *= 10; n += *it++ - '0'; }
+	while (it != end && Ascii::isSpace(*it)) ++it;
+	std::string unit;
+	while (it != end && Ascii::isAlpha(*it)) unit += *it++;
+	
+	Timespan::TimeDiff factor = Timespan::SECONDS;
+	if (unit == "minutes")
+		factor = Timespan::MINUTES;
+	else if (unit == "hours")
+		factor = Timespan::HOURS;
+	else if (unit == "days")
+		factor = Timespan::DAYS;
+	else if (unit == "weeks")
+		factor = 7*Timespan::DAYS;
+	else if (unit == "months")
+		factor = 30*Timespan::DAYS;
+	else if (unit != "seconds")
+		throw InvalidArgumentException("setMaxAge", age);
+		
+	_maxAge = factor * n;
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/Bulk.cpp b/base/poco/Data/src/Bulk.cpp
new file mode 100644
index 00000000000..1def562266b
--- /dev/null
+++ b/base/poco/Data/src/Bulk.cpp
@@ -0,0 +1,37 @@
+//
+// Bulk.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  Bulk
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/Bulk.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+Bulk::Bulk(const Limit& limit): _limit(limit.value(), false, false)
+{
+}
+
+
+Bulk::Bulk(Poco::UInt32 value): _limit(value, false, false)
+{
+}
+
+
+Bulk::~Bulk()
+{
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/Connector.cpp b/base/poco/Data/src/Connector.cpp
new file mode 100644
index 00000000000..c721ae2a922
--- /dev/null
+++ b/base/poco/Data/src/Connector.cpp
@@ -0,0 +1,32 @@
+//
+// Connector.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  Connector
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/Connector.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+Connector::Connector()
+{
+}
+
+
+Connector::~Connector()
+{
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/DataException.cpp b/base/poco/Data/src/DataException.cpp
new file mode 100644
index 00000000000..b5bc7275b9d
--- /dev/null
+++ b/base/poco/Data/src/DataException.cpp
@@ -0,0 +1,41 @@
+//
+// DataException.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  DataException
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/DataException.h"
+#include <typeinfo>
+
+
+namespace Poco {
+namespace Data {
+
+
+POCO_IMPLEMENT_EXCEPTION(DataException, Poco::IOException, "Database Exception")
+POCO_IMPLEMENT_EXCEPTION(RowDataMissingException, DataException, "Data for row missing")
+POCO_IMPLEMENT_EXCEPTION(UnknownDataBaseException, DataException, "Type of data base unknown")
+POCO_IMPLEMENT_EXCEPTION(UnknownTypeException, DataException, "Type of data unknown")
+POCO_IMPLEMENT_EXCEPTION(ExecutionException, DataException, "Execution error")
+POCO_IMPLEMENT_EXCEPTION(BindingException, DataException, "Binding error")
+POCO_IMPLEMENT_EXCEPTION(ExtractException, DataException, "Extraction error")
+POCO_IMPLEMENT_EXCEPTION(LimitException, DataException, "Limit error")
+POCO_IMPLEMENT_EXCEPTION(NotSupportedException, DataException, "Feature or property not supported")
+POCO_IMPLEMENT_EXCEPTION(SessionUnavailableException, DataException, "Session is unavailable")
+POCO_IMPLEMENT_EXCEPTION(SessionPoolExhaustedException, DataException, "No more sessions available from the session pool")
+POCO_IMPLEMENT_EXCEPTION(SessionPoolExistsException, DataException, "Session already exists in the pool")
+POCO_IMPLEMENT_EXCEPTION(NoDataException, DataException, "No data found")
+POCO_IMPLEMENT_EXCEPTION(LengthExceededException, DataException, "Data too long")
+POCO_IMPLEMENT_EXCEPTION(ConnectionFailedException, DataException, "Connection attempt failed")
+POCO_IMPLEMENT_EXCEPTION(NotConnectedException, DataException, "Not connected to data source")
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/Date.cpp b/base/poco/Data/src/Date.cpp
new file mode 100644
index 00000000000..542d9a98126
--- /dev/null
+++ b/base/poco/Data/src/Date.cpp
@@ -0,0 +1,142 @@
+//
+// Date.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  Date
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/Date.h"
+#include "Poco/DateTime.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/Data/DynamicDateTime.h"
+#include "Poco/Dynamic/Var.h"
+
+
+using Poco::DateTime;
+using Poco::Dynamic::Var;
+using Poco::NumberFormatter;
+
+
+namespace Poco {
+namespace Data {
+
+
+Date::Date()
+{
+	DateTime dt;
+	assign(dt.year(), dt.month(), dt.day());
+}
+
+
+Date::Date(int year, int month, int day)
+{
+	assign(year, month, day);
+}
+
+
+Date::Date(const DateTime& dt)
+{
+	assign(dt.year(), dt.month(), dt.day());
+}
+
+
+Date::~Date()
+{
+}
+
+
+void Date::assign(int year, int month, int day)
+{
+	if (year < 0 || year > 9999)
+		throw InvalidArgumentException("Year must be between 0 and 9999");
+
+	if (month < 1 || month > 12)
+		throw InvalidArgumentException("Month must be between 1 and 12");
+
+	if (day < 1 || day > DateTime::daysOfMonth(year, month))
+		throw InvalidArgumentException("Month must be between 1 and " + 
+			NumberFormatter::format(DateTime::daysOfMonth(year, month)));
+
+	_year = year;
+	_month = month;
+	_day = day;
+}
+
+
+bool Date::operator < (const Date& date) const
+{
+	int year = date.year();
+
+	if (_year < year) return true;
+	else if (_year > year) return false;
+	else // years equal
+	{
+		int month = date.month();
+		if (_month < month) return true;
+		else 
+		if (_month > month) return false;
+		else // months equal
+		if (_day < date.day()) return true;
+	}
+
+	return false;
+}
+
+
+Date& Date::operator = (const Var& var)
+{
+#ifndef __GNUC__
+// g++ used to choke on this, newer versions seem to digest it fine
+// TODO: determine the version able to handle it properly
+	*this = var.extract<Date>();
+#else
+	*this = var.operator Date();
+#endif
+	return *this;
+}
+
+
+} } // namespace Poco::Data
+
+
+#ifdef __GNUC__
+// only needed for g++ (see comment in Date::operator = above)
+
+namespace Poco {
+namespace Dynamic {
+
+
+using Poco::Data::Date;
+using Poco::DateTime;
+
+
+template <>
+Var::operator Date () const
+{
+	VarHolder* pHolder = content();
+
+	if (!pHolder)
+		throw InvalidAccessException("Can not convert empty value.");
+
+	if (typeid(Date) == pHolder->type())
+		return extract<Date>();
+	else
+	{
+		Poco::DateTime result;
+		pHolder->convert(result);
+		return Date(result);
+	}
+}
+
+
+} } // namespace Poco::Dynamic
+
+
+#endif // __GNUC__
diff --git a/base/poco/Data/src/DynamicLOB.cpp b/base/poco/Data/src/DynamicLOB.cpp
new file mode 100644
index 00000000000..5dfe3df8574
--- /dev/null
+++ b/base/poco/Data/src/DynamicLOB.cpp
@@ -0,0 +1,74 @@
+//
+// DynamicLOB.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  DynamicLOB
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifdef __GNUC__
+// TODO: determine g++ version able to do the right thing without these specializations
+
+#include "Poco/Data/DynamicLOB.h"
+#include "Poco/Data/LOB.h"
+#include "Poco/Dynamic/Var.h"
+
+
+namespace Poco {
+namespace Dynamic {
+
+
+using Poco::Data::CLOB;
+using Poco::Data::BLOB;
+
+
+template <>
+Var::operator CLOB () const
+{
+	VarHolder* pHolder = content();
+
+	if (!pHolder)
+		throw InvalidAccessException("Can not convert empty value.");
+
+	if (typeid(CLOB) == pHolder->type())
+		return extract<CLOB>();
+	else
+	{
+		std::string result;
+		pHolder->convert(result);
+		return CLOB(result);
+	}
+}
+
+
+template <>
+Var::operator BLOB () const
+{
+	VarHolder* pHolder = content();
+
+	if (!pHolder)
+		throw InvalidAccessException("Can not convert empty value.");
+
+	if (typeid(BLOB) == pHolder->type())
+		return extract<BLOB>();
+	else
+	{
+		std::string result;
+		pHolder->convert(result);
+		return BLOB(reinterpret_cast<const unsigned char*>(result.data()),
+			result.size());
+	}
+}
+
+
+} } // namespace Poco::Data
+
+
+#endif // __GNUC__
+
diff --git a/base/poco/Data/src/Limit.cpp b/base/poco/Data/src/Limit.cpp
new file mode 100644
index 00000000000..3a111e34f98
--- /dev/null
+++ b/base/poco/Data/src/Limit.cpp
@@ -0,0 +1,35 @@
+//
+// Limit.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  Limit
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/Limit.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+Limit::Limit(SizeT value, bool hardLimit, bool isLowerLimit) :
+	_value(value),
+	_hardLimit(hardLimit),
+	_isLowerLimit(isLowerLimit)
+{
+}
+
+
+Limit::~Limit()
+{
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/MetaColumn.cpp b/base/poco/Data/src/MetaColumn.cpp
new file mode 100644
index 00000000000..7b937e6a447
--- /dev/null
+++ b/base/poco/Data/src/MetaColumn.cpp
@@ -0,0 +1,53 @@
+//
+// MetaColumn.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  MetaColumn
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/MetaColumn.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+MetaColumn::MetaColumn():
+	_length(),
+	_precision(),
+	_position(),
+	_type(),
+	_nullable()
+{
+}
+
+
+MetaColumn::MetaColumn(std::size_t position,
+	const std::string& name,
+	ColumnDataType type,
+	std::size_t length,
+	std::size_t precision,
+	bool nullable): 
+	_name(name),
+	_length(length),
+	_precision(precision),
+	_position(position),
+	_type(type),
+	_nullable(nullable)
+{
+}
+
+
+MetaColumn::~MetaColumn()
+{
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/PooledSessionHolder.cpp b/base/poco/Data/src/PooledSessionHolder.cpp
new file mode 100644
index 00000000000..80d35e2a615
--- /dev/null
+++ b/base/poco/Data/src/PooledSessionHolder.cpp
@@ -0,0 +1,34 @@
+//
+// PooledSessionHolder.cpp
+//
+// Library: Data
+// Package: SessionPooling
+// Module:  PooledSessionHolder
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/PooledSessionHolder.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+PooledSessionHolder::PooledSessionHolder(SessionPool& owner, SessionImpl* pSessionImpl):
+	_owner(owner),
+	_pImpl(pSessionImpl, true)
+{
+}
+
+
+PooledSessionHolder::~PooledSessionHolder()
+{
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/PooledSessionImpl.cpp b/base/poco/Data/src/PooledSessionImpl.cpp
new file mode 100644
index 00000000000..2acf2f9d836
--- /dev/null
+++ b/base/poco/Data/src/PooledSessionImpl.cpp
@@ -0,0 +1,192 @@
+//
+// PooledSessionImpl.cpp
+//
+// Library: Data
+// Package: SessionPooling
+// Module:  PooledSessionImpl
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/PooledSessionImpl.h"
+#include "Poco/Data/DataException.h"
+#include "Poco/Data/SessionPool.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+PooledSessionImpl::PooledSessionImpl(PooledSessionHolder* pHolder):
+	SessionImpl(pHolder->session()->connectionString(),
+		pHolder->session()->getLoginTimeout()),
+	_pHolder(pHolder, true)
+{
+}
+
+
+PooledSessionImpl::~PooledSessionImpl()
+{
+	try
+	{
+		close();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+StatementImpl* PooledSessionImpl::createStatementImpl()
+{
+	return access()->createStatementImpl();
+}
+
+
+void PooledSessionImpl::begin()
+{
+	return access()->begin();
+}
+
+
+void PooledSessionImpl::commit()
+{
+	return access()->commit();
+}
+
+
+bool PooledSessionImpl::isConnected()
+{
+	return access()->isConnected();
+}
+
+
+void PooledSessionImpl::setConnectionTimeout(std::size_t timeout)
+{
+	return access()->setConnectionTimeout(timeout);
+}
+
+
+std::size_t PooledSessionImpl::getConnectionTimeout()
+{
+	return access()->getConnectionTimeout();
+}
+
+
+bool PooledSessionImpl::canTransact()
+{
+	return access()->canTransact();
+}
+
+
+bool PooledSessionImpl::isTransaction()
+{
+	return access()->isTransaction();
+}
+
+
+void PooledSessionImpl::setTransactionIsolation(Poco::UInt32 ti)
+{
+	access()->setTransactionIsolation(ti);
+}
+
+
+Poco::UInt32 PooledSessionImpl::getTransactionIsolation()
+{
+	return access()->getTransactionIsolation();
+}
+
+
+bool PooledSessionImpl::hasTransactionIsolation(Poco::UInt32 ti)
+{
+	return access()->hasTransactionIsolation(ti);
+}
+
+
+bool PooledSessionImpl::isTransactionIsolation(Poco::UInt32 ti)
+{
+	return access()->isTransactionIsolation(ti);
+}
+
+
+void PooledSessionImpl::rollback()
+{
+	return access()->rollback();
+}
+
+
+void PooledSessionImpl::open(const std::string& connect)
+{
+	access()->open(connect);
+}
+
+
+void PooledSessionImpl::close()
+{
+	if (_pHolder)
+	{
+		if (isTransaction())
+		{
+			try
+			{
+				rollback();
+			}
+			catch (...)
+			{
+				// Something's wrong with the session. Get rid of it.
+				access()->close();
+			}
+		}
+		_pHolder->owner().putBack(_pHolder);
+		_pHolder = 0;
+	}
+}
+
+
+const std::string& PooledSessionImpl::connectorName() const
+{
+	return access()->connectorName();
+}
+
+
+void PooledSessionImpl::setFeature(const std::string& name, bool state)	
+{
+	access()->setFeature(name, state);
+}
+
+
+bool PooledSessionImpl::getFeature(const std::string& name)
+{
+	return access()->getFeature(name);
+}
+
+
+void PooledSessionImpl::setProperty(const std::string& name, const Poco::Any& value)
+{
+	access()->setProperty(name, value);
+}
+
+
+Poco::Any PooledSessionImpl::getProperty(const std::string& name)
+{
+	return access()->getProperty(name);
+}
+
+
+SessionImpl* PooledSessionImpl::access() const
+{
+	if (_pHolder)
+	{
+		_pHolder->access();
+		return impl();
+	}
+	else throw SessionUnavailableException();
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/Position.cpp b/base/poco/Data/src/Position.cpp
new file mode 100644
index 00000000000..64db6fca702
--- /dev/null
+++ b/base/poco/Data/src/Position.cpp
@@ -0,0 +1,32 @@
+//
+// Position.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  Position
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/Position.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+Position::Position(Poco::UInt32 value): _value(value)
+{
+}
+
+
+Position::~Position()
+{
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/Range.cpp b/base/poco/Data/src/Range.cpp
new file mode 100644
index 00000000000..d41fde130d3
--- /dev/null
+++ b/base/poco/Data/src/Range.cpp
@@ -0,0 +1,40 @@
+//
+// Range.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  Range
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/Range.h"
+#include "Poco/Data/DataException.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+using namespace Keywords;
+
+
+Range::Range(Limit::SizeT lowValue, Limit::SizeT upValue, bool hardLimit) :
+	_lower(lowerLimit(lowValue)),
+	_upper(upperLimit(upValue, hardLimit))
+{
+	if (lowValue > upValue)
+		throw LimitException("lowerLimit > upperLimit!");
+}
+
+
+Range::~Range()
+{
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/RecordSet.cpp b/base/poco/Data/src/RecordSet.cpp
new file mode 100644
index 00000000000..0d8c143a98c
--- /dev/null
+++ b/base/poco/Data/src/RecordSet.cpp
@@ -0,0 +1,392 @@
+//
+// RecordSet.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  RecordSet
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/RecordSet.h"
+#include "Poco/Data/RowFilter.h"
+#include "Poco/Data/Date.h"
+#include "Poco/Data/Time.h"
+#include "Poco/Data/DataException.h"
+#include "Poco/DateTime.h"
+#include "Poco/UTFString.h"
+
+
+using namespace Poco::Data::Keywords;
+using Poco::DateTime;
+using Poco::UTF16String;
+
+
+namespace Poco {
+namespace Data {
+
+
+const std::size_t RecordSet::UNKNOWN_TOTAL_ROW_COUNT = std::numeric_limits<std::size_t>::max();
+
+
+RecordSet::RecordSet(const Statement& rStatement,
+	RowFormatter::Ptr pRowFormatter): 
+	Statement(rStatement),
+	_currentRow(0),
+	_pBegin(new RowIterator(this, 0 == rowsExtracted())),
+	_pEnd(new RowIterator(this, true)),
+	_totalRowCount(UNKNOWN_TOTAL_ROW_COUNT)
+{
+	if (pRowFormatter) setRowFormatter(pRowFormatter);
+}
+
+
+RecordSet::RecordSet(Session& rSession, 
+	const std::string& query, 
+	RowFormatter::Ptr pRowFormatter): 
+	Statement((rSession << query, now)),
+	_currentRow(0),
+	_pBegin(new RowIterator(this, 0 == rowsExtracted())),
+	_pEnd(new RowIterator(this, true)),
+	_totalRowCount(UNKNOWN_TOTAL_ROW_COUNT)
+{
+	if (pRowFormatter) setRowFormatter(pRowFormatter);
+}
+
+
+RecordSet::RecordSet(const RecordSet& other):
+	Statement(other.impl()),
+	_currentRow(other._currentRow),
+	_pBegin(new RowIterator(this, 0 == rowsExtracted())),
+	_pEnd(new RowIterator(this, true)),
+	_pFilter(other._pFilter),
+	_totalRowCount(other._totalRowCount)
+{
+}
+
+
+RecordSet::~RecordSet()
+{
+	try
+	{
+		delete _pBegin;
+		delete _pEnd;
+
+		RowMap::iterator it = _rowMap.begin();
+		RowMap::iterator end = _rowMap.end();
+		for (; it != end; ++it) delete it->second;
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void RecordSet::reset(const Statement& stmt)
+{
+	delete _pBegin;
+	_pBegin = 0;
+	delete _pEnd;
+	_pEnd = 0;
+	_currentRow = 0;
+	_totalRowCount = UNKNOWN_TOTAL_ROW_COUNT;
+	
+	RowMap::iterator it = _rowMap.begin();
+	RowMap::iterator end = _rowMap.end();
+	for (; it != end; ++it) delete it->second;
+	_rowMap.clear();
+
+	Statement::operator = (stmt);
+
+	_pBegin = new RowIterator(this, 0 == rowsExtracted());
+	_pEnd = new RowIterator(this, true);
+}
+
+
+Poco::Dynamic::Var RecordSet::value(std::size_t col, std::size_t row, bool useFilter) const
+{
+	if (useFilter && isFiltered() && !isAllowed(row))
+		throw InvalidAccessException("Row not allowed");
+
+	if (isNull(col, row)) return Poco::Dynamic::Var();
+
+	switch (columnType(col))
+	{
+	case MetaColumn::FDT_BOOL:      return value<bool>(col, row, useFilter);
+	case MetaColumn::FDT_INT8:      return value<Int8>(col, row, useFilter);
+	case MetaColumn::FDT_UINT8:     return value<UInt8>(col, row, useFilter);
+	case MetaColumn::FDT_INT16:     return value<Int16>(col, row, useFilter);
+	case MetaColumn::FDT_UINT16:    return value<UInt16>(col, row, useFilter);
+	case MetaColumn::FDT_INT32:	    return value<Int32>(col, row, useFilter);
+	case MetaColumn::FDT_UINT32:    return value<UInt32>(col, row, useFilter);
+	case MetaColumn::FDT_INT64:     return value<Int64>(col, row, useFilter);
+	case MetaColumn::FDT_UINT64:    return value<UInt64>(col, row, useFilter);
+	case MetaColumn::FDT_FLOAT:     return value<float>(col, row, useFilter);
+	case MetaColumn::FDT_DOUBLE:    return value<double>(col, row, useFilter);
+	case MetaColumn::FDT_STRING:    return value<std::string>(col, row, useFilter);
+	case MetaColumn::FDT_WSTRING:   return value<UTF16String>(col, row, useFilter);
+	case MetaColumn::FDT_BLOB:      return value<BLOB>(col, row, useFilter);
+	case MetaColumn::FDT_CLOB:      return value<CLOB>(col, row, useFilter);
+	case MetaColumn::FDT_DATE:      return value<Date>(col, row, useFilter);
+	case MetaColumn::FDT_TIME:      return value<Time>(col, row, useFilter);
+	case MetaColumn::FDT_TIMESTAMP: return value<DateTime>(col, row);
+	default:
+		throw UnknownTypeException("Data type not supported.");
+	}
+}
+
+
+Poco::Dynamic::Var RecordSet::value(const std::string& name, std::size_t row, bool useFilter) const
+{
+	if (useFilter && isFiltered() && !isAllowed(row))
+		throw InvalidAccessException("Row not allowed");
+
+	if (isNull(metaColumn(name).position(), row)) return Poco::Dynamic::Var();
+
+	switch (columnType(name))
+	{
+	case MetaColumn::FDT_BOOL:      return value<bool>(name, row, useFilter);
+	case MetaColumn::FDT_INT8:      return value<Int8>(name, row, useFilter);
+	case MetaColumn::FDT_UINT8:     return value<UInt8>(name, row, useFilter);
+	case MetaColumn::FDT_INT16:     return value<Int16>(name, row, useFilter);
+	case MetaColumn::FDT_UINT16:    return value<UInt16>(name, row, useFilter);
+	case MetaColumn::FDT_INT32:	    return value<Int32>(name, row, useFilter);
+	case MetaColumn::FDT_UINT32:    return value<UInt32>(name, row, useFilter);
+	case MetaColumn::FDT_INT64:     return value<Int64>(name, row, useFilter);
+	case MetaColumn::FDT_UINT64:    return value<UInt64>(name, row, useFilter);
+	case MetaColumn::FDT_FLOAT:     return value<float>(name, row, useFilter);
+	case MetaColumn::FDT_DOUBLE:    return value<double>(name, row, useFilter);
+	case MetaColumn::FDT_STRING:    return value<std::string>(name, row, useFilter);
+	case MetaColumn::FDT_WSTRING:   return value<UTF16String>(name, row, useFilter);
+	case MetaColumn::FDT_BLOB:      return value<BLOB>(name, row, useFilter);
+	case MetaColumn::FDT_DATE:      return value<Date>(name, row, useFilter);
+	case MetaColumn::FDT_TIME:      return value<Time>(name, row, useFilter);
+	case MetaColumn::FDT_TIMESTAMP: return value<DateTime>(name, row, useFilter);
+	default:
+		throw UnknownTypeException("Data type not supported.");
+	}
+}
+
+
+Row& RecordSet::row(std::size_t pos)
+{
+	std::size_t rowCnt = rowCount();
+	if (0 == rowCnt || pos > rowCnt - 1)
+		throw RangeException("Invalid recordset row requested.");
+
+	RowMap::const_iterator it = _rowMap.find(pos);
+	Row* pRow = 0;
+	std::size_t columns = columnCount();
+	if (it == _rowMap.end())
+	{
+		if (_rowMap.size())
+		{
+			//reuse first row column names and sorting fields to save some memory 
+			pRow = new Row(_rowMap.begin()->second->names(),
+				_rowMap.begin()->second->getSortMap(),
+				getRowFormatter());
+
+			for (std::size_t col = 0; col < columns; ++col)
+				pRow->set(col, value(col, pos));
+		}
+		else 
+		{
+			pRow = new Row;
+			pRow->setFormatter(getRowFormatter());
+			for (std::size_t col = 0; col < columns; ++col)
+				pRow->append(metaColumn(static_cast<UInt32>(col)).name(), value(col, pos));
+		}
+
+		_rowMap.insert(RowMap::value_type(pos, pRow));
+	}
+	else 
+	{
+		pRow = it->second;
+		poco_check_ptr (pRow);
+	}
+
+	return *pRow;
+}
+
+
+std::size_t RecordSet::rowCount() const
+{
+	poco_assert (extractions().size());
+	std::size_t rc = subTotalRowCount();
+	if (!isFiltered()) return rc;
+
+	std::size_t counter = 0;
+	for (int row = 0; row < rc; ++row)
+	{
+		if (isAllowed(row)) ++counter;
+	}
+
+	return counter;
+}
+
+
+bool RecordSet::isAllowed(std::size_t row) const
+{
+	if (!isFiltered()) return true;
+	return _pFilter->isAllowed(row);
+}
+
+
+bool RecordSet::moveFirst()
+{
+	if (subTotalRowCount() > 0)
+	{
+		if (!isFiltered())
+		{
+			_currentRow = 0;
+			return true;
+		}
+
+		std::size_t currentRow = 0;
+		while (!isAllowed(currentRow))
+		{
+			if (currentRow >= subTotalRowCount() - 1) return false;
+			++currentRow;
+		}
+
+		_currentRow = currentRow;
+		return true;
+	}
+	else return false;
+}
+
+
+bool RecordSet::moveNext()
+{
+	std::size_t currentRow = _currentRow;
+	do
+	{
+		if (currentRow >= subTotalRowCount() - 1) return false;
+		++currentRow;
+	} while (isFiltered() && !isAllowed(currentRow));
+
+	_currentRow = currentRow;
+	return true;
+}
+
+
+bool RecordSet::movePrevious()
+{
+	std::size_t currentRow = _currentRow;
+	do
+	{
+		if (currentRow <= 0) return false;
+		--currentRow;
+	} while (isFiltered() && !isAllowed(currentRow));
+
+	_currentRow = currentRow;
+	return true;
+}
+
+
+bool RecordSet::moveLast()
+{
+	if (subTotalRowCount() > 0)
+	{
+		std::size_t currentRow = subTotalRowCount() - 1;
+		if (!isFiltered())
+		{
+			_currentRow = currentRow;
+			return true;
+		}
+
+		while (!isAllowed(currentRow))
+		{
+			if (currentRow <= 0) return false;
+			--currentRow;
+		}
+
+		_currentRow = currentRow;
+		return true;
+	}
+	else return false;
+}
+
+
+void RecordSet::setRowFormatter(RowFormatter::Ptr pRowFormatter)
+{
+	pRowFormatter->setTotalRowCount(static_cast<int>(getTotalRowCount()));
+	Statement::setRowFormatter(pRowFormatter);
+	RowMap::iterator it = _rowMap.begin();
+	RowMap::iterator end = _rowMap.end();
+	for (; it != end; ++it) it->second->setFormatter(getRowFormatter());
+}
+
+
+std::ostream& RecordSet::copyNames(std::ostream& os) const
+{
+	std::string names = (*_pBegin)->namesToString();
+	if (!names.empty()) os << names;
+	return os;
+}
+
+
+std::ostream& RecordSet::copyValues(std::ostream& os, std::size_t offset, std::size_t length) const
+{
+	RowIterator it = *_pBegin + offset;
+	RowIterator end = (RowIterator::POSITION_END != length) ? it + length : *_pEnd;
+	std::copy(it, end, std::ostream_iterator<Row>(os));
+	return os;
+}
+
+
+void RecordSet::formatValues(std::size_t offset, std::size_t length) const
+{
+	RowIterator it = *_pBegin + offset;
+	RowIterator end = (RowIterator::POSITION_END != length) ? it + length : *_pEnd;
+	std::string val;
+	for (; it != end; ++it) it->formatValues();
+}
+
+
+std::ostream& RecordSet::copy(std::ostream& os, std::size_t offset, std::size_t length) const
+{
+	RowFormatter& rf = const_cast<RowFormatter&>((*_pBegin)->getFormatter());
+	rf.setTotalRowCount(static_cast<int>(getTotalRowCount()));
+	if (RowFormatter::FORMAT_PROGRESSIVE == rf.getMode())
+	{
+		os << rf.prefix();
+		copyNames(os);
+		copyValues(os, offset, length);
+		os << rf.postfix();
+	}
+	else
+	{
+		formatNames();
+		formatValues(offset, length);
+		os << rf.toString();
+	}
+
+	return os;
+}
+
+
+void RecordSet::filter(const Poco::AutoPtr<RowFilter>& pFilter)
+{
+	_pFilter = pFilter;
+}
+
+
+bool RecordSet::isFiltered() const
+{
+	return _pFilter && !_pFilter->isEmpty();
+}
+
+
+void RecordSet::setTotalRowCount(const std::string& sql)
+{
+	session() << sql, into(_totalRowCount), now;
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/Row.cpp b/base/poco/Data/src/Row.cpp
new file mode 100644
index 00000000000..d078536bd5f
--- /dev/null
+++ b/base/poco/Data/src/Row.cpp
@@ -0,0 +1,369 @@
+//
+// Row.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  Row
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/Row.h"
+#include "Poco/Data/SimpleRowFormatter.h"
+#include "Poco/String.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+std::ostream& operator << (std::ostream &os, const Row& row)
+{
+	os << row.valuesToString();
+	return os;
+}
+
+
+Row::Row(): 
+	_pNames(0),
+	_pSortMap(new SortMap),
+	_pFormatter(new SimpleRowFormatter)
+{
+}
+
+
+Row::Row(NameVecPtr pNames,
+	const RowFormatter::Ptr& pFormatter): _pNames(pNames)
+{
+	if (!_pNames) throw NullPointerException();
+	init(0, pFormatter);
+}
+
+
+Row::Row(NameVecPtr pNames,
+	const SortMapPtr& pSortMap,
+	const RowFormatter::Ptr& pFormatter): _pNames(pNames)
+{
+	if (!_pNames) throw NullPointerException();
+	init(pSortMap, pFormatter);
+}
+
+
+void Row::init(const SortMapPtr& pSortMap, const RowFormatter::Ptr& pFormatter)
+{
+	setFormatter(pFormatter);
+	setSortMap(pSortMap);
+
+	NameVec::size_type sz = _pNames->size();
+	if (sz)
+	{
+		_values.resize(sz);
+		// Row sortability in the strict weak ordering sense is 
+		// an invariant, hence we must start with a zero here.
+		// If null value is later retrieved from DB, the 
+		// Var::empty() call should be used to empty
+		// the corresponding Row value.
+		_values[0] = 0;
+		addSortField(0);
+	}
+}
+
+
+Row::~Row()
+{
+}
+
+
+Poco::Dynamic::Var& Row::get(std::size_t col)
+{
+	try
+	{
+		return _values.at(col);
+	}
+	catch (std::out_of_range& re)
+	{
+		throw RangeException(re.what());
+	}
+}
+
+
+std::size_t Row::getPosition(const std::string& name)
+{
+	if (!_pNames)
+		throw NullPointerException();
+
+	NameVec::const_iterator it = _pNames->begin();
+	NameVec::const_iterator end = _pNames->end();
+	std::size_t col = 0;
+	for (; it != end; ++it, ++col)
+		if (0 == icompare(name, *it)) return col;
+	
+	throw NotFoundException(name);
+}
+
+
+void Row::addSortField(std::size_t pos)
+{
+	poco_assert (pos <= _values.size());
+
+	SortMap::iterator it = _pSortMap->begin();
+	SortMap::iterator end = _pSortMap->end();
+	for (; it != end; ++it)
+	{
+		if (it->get<0>() == pos) return; 
+	}
+
+	ComparisonType ct;
+	if (_values[pos].isEmpty())
+	{
+		ct = COMPARE_AS_EMPTY;
+	}
+	else if ((_values[pos].type() == typeid(Poco::Int8))   ||
+		(_values[pos].type() == typeid(Poco::UInt8))  ||
+		(_values[pos].type() == typeid(Poco::Int16))  ||
+		(_values[pos].type() == typeid(Poco::UInt16)) ||
+		(_values[pos].type() == typeid(Poco::Int32))  ||
+		(_values[pos].type() == typeid(Poco::UInt32)) ||
+		(_values[pos].type() == typeid(Poco::Int64))  ||
+		(_values[pos].type() == typeid(Poco::UInt64)) ||
+		(_values[pos].type() == typeid(bool)))
+	{
+		ct = COMPARE_AS_INTEGER;
+	}
+	else if ((_values[pos].type() == typeid(float)) ||
+		(_values[pos].type() == typeid(double)))
+	{
+		ct = COMPARE_AS_FLOAT;
+	}
+	else
+	{
+		ct = COMPARE_AS_STRING;
+	}
+
+	_pSortMap->push_back(SortTuple(pos, ct));
+}
+
+
+void Row::addSortField(const std::string& name)
+{
+	addSortField(getPosition(name));
+}
+
+
+void Row::removeSortField(std::size_t pos)
+{
+	SortMap::iterator it = _pSortMap->begin();
+	SortMap::iterator end = _pSortMap->end();
+	for (; it != end; ++it)
+	{
+		if (it->get<0>() == pos)
+		{
+			_pSortMap->erase(it);
+			return;
+		}
+	}
+}
+
+
+void Row::removeSortField(const std::string& name)
+{
+	removeSortField(getPosition(name));
+}
+
+
+void Row::replaceSortField(std::size_t oldPos, std::size_t newPos)
+{
+	poco_assert (oldPos <= _values.size());
+	poco_assert (newPos <= _values.size());
+
+	ComparisonType ct;
+
+	if (_values[newPos].isEmpty())
+	{
+		ct = COMPARE_AS_EMPTY;
+	}
+	else if ((_values[newPos].type() == typeid(Poco::Int8)) ||
+		(_values[newPos].type() == typeid(Poco::UInt8))     ||
+		(_values[newPos].type() == typeid(Poco::Int16))     ||
+		(_values[newPos].type() == typeid(Poco::UInt16))    ||
+		(_values[newPos].type() == typeid(Poco::Int32))     ||
+		(_values[newPos].type() == typeid(Poco::UInt32))    ||
+		(_values[newPos].type() == typeid(Poco::Int64))     ||
+		(_values[newPos].type() == typeid(Poco::UInt64))    ||
+		(_values[newPos].type() == typeid(bool)))
+	{
+		ct = COMPARE_AS_INTEGER;
+	}
+	else if ((_values[newPos].type() == typeid(float)) ||
+		(_values[newPos].type() == typeid(double)))
+	{
+		ct = COMPARE_AS_FLOAT;
+	}
+	else
+	{
+		ct = COMPARE_AS_STRING;
+	}
+
+	SortMap::iterator it = _pSortMap->begin();
+	SortMap::iterator end = _pSortMap->end();
+	for (; it != end; ++it)
+	{
+		if (it->get<0>() == oldPos)
+		{
+			*it = SortTuple(newPos, ct);
+			return;
+		}
+	}
+
+	throw NotFoundException("Field not found");
+}
+
+
+void Row::replaceSortField(const std::string& oldName, const std::string& newName)
+{
+	replaceSortField(getPosition(oldName), getPosition(newName));
+}
+
+
+void Row::resetSort()
+{
+	_pSortMap->clear();
+	if (_values.size())	addSortField(0);
+}
+
+
+bool Row::isEqualSize(const Row& other) const
+{
+	return (other._values.size() == _values.size());
+}
+
+
+bool Row::isEqualType(const Row& other) const
+{
+	std::vector<Poco::Dynamic::Var>::const_iterator it = _values.begin();
+	std::vector<Poco::Dynamic::Var>::const_iterator end = _values.end();
+	for (int i = 0; it != end; ++it, ++i)
+	{
+		if (it->type() != other._values[i].type())
+			return false;
+	}
+
+	return true;
+}
+
+
+bool Row::operator == (const Row& other) const
+{
+	if (!isEqualSize(other)) return false;
+	if (!isEqualType(other)) return false;
+
+	std::vector<Poco::Dynamic::Var>::const_iterator it = _values.begin();
+	std::vector<Poco::Dynamic::Var>::const_iterator end = _values.end();
+	for (int i = 0; it != end; ++it, ++i)
+	{
+		if ((*it).convert<std::string>() != other._values[i].convert<std::string>())
+			return false;
+	}
+
+	return true;
+}
+
+
+bool Row::operator != (const Row& other) const
+{
+	return !(*this == other);
+}
+
+
+bool Row::operator < (const Row& other) const
+{
+	if (*_pSortMap != *other._pSortMap)
+		throw InvalidAccessException("Rows compared have different sorting criteria.");
+
+	SortMap::const_iterator it = _pSortMap->begin();
+	SortMap::const_iterator end = _pSortMap->end();
+	for (; it != end; ++it)
+	{
+		switch (it->get<1>())
+		{
+		case COMPARE_AS_EMPTY:
+			return false;
+
+		case COMPARE_AS_INTEGER:
+			if (_values[it->get<0>()].convert<Poco::Int64>() < 
+				other._values[it->get<0>()].convert<Poco::Int64>())
+				return true;
+			else if (_values[it->get<0>()].convert<Poco::Int64>() != 
+				other._values[it->get<0>()].convert<Poco::Int64>())
+				return false;
+			break;
+
+		case COMPARE_AS_FLOAT:
+			if (_values[it->get<0>()].convert<double>() < 
+				other._values[it->get<0>()].convert<double>())
+				return true;
+			else if (_values[it->get<0>()].convert<double>() !=
+				other._values[it->get<0>()].convert<double>())
+				return false;
+			break;
+
+		case COMPARE_AS_STRING:
+			if (_values[it->get<0>()].convert<std::string>() < 
+				other._values[it->get<0>()].convert<std::string>())
+				return true;
+			else if (_values[it->get<0>()].convert<std::string>() !=
+				other._values[it->get<0>()].convert<std::string>())
+				return false;
+			break;
+
+		default:
+			throw IllegalStateException("Unknown comparison criteria.");
+		}
+	}
+
+	return false;
+}
+
+
+void Row::setFormatter(const RowFormatter::Ptr& pFormatter)
+{
+	if (pFormatter.get())
+		_pFormatter = pFormatter;
+	else 
+		_pFormatter = new SimpleRowFormatter;
+}
+
+
+void Row::setSortMap(const SortMapPtr& pSortMap)
+{
+	if (pSortMap.get())
+		_pSortMap = pSortMap;
+	else 
+		_pSortMap = new SortMap;
+}
+
+
+const std::string& Row::namesToString() const
+{
+	if (!_pNames)
+		throw NullPointerException();
+
+	return _pFormatter->formatNames(names(), _nameStr);
+}
+
+
+void Row::formatNames() const
+{
+	if (!_pNames)
+		throw NullPointerException();
+
+	return _pFormatter->formatNames(names());
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/RowFilter.cpp b/base/poco/Data/src/RowFilter.cpp
new file mode 100644
index 00000000000..9fd0b62879e
--- /dev/null
+++ b/base/poco/Data/src/RowFilter.cpp
@@ -0,0 +1,225 @@
+//
+// RowFilter.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  RowFilter
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/RowFilter.h"
+#include "Poco/Data/RecordSet.h"
+#include "Poco/String.h"
+#include "Poco/Exception.h"
+#include <functional>
+
+
+namespace Poco {
+namespace Data {
+
+
+RowFilter::RowFilter(RecordSet* pRecordSet): _pRecordSet(pRecordSet), _not(false)
+{
+	poco_check_ptr(pRecordSet);
+	init();
+	duplicate();
+	_pRecordSet->filter(this);
+}
+
+
+RowFilter::RowFilter(Ptr pParent, LogicOperator op): _pRecordSet(0),
+	_pParent(pParent),
+	_not(false)
+{
+	poco_check_ptr(_pParent.get());
+	init();
+	duplicate();
+	_pParent->addFilter(this, op);
+}
+
+
+void RowFilter::init()
+{
+	_comparisons.insert(Comparisons::value_type("<", VALUE_LESS_THAN));
+	_comparisons.insert(Comparisons::value_type("<=", VALUE_LESS_THAN_OR_EQUAL));
+	_comparisons.insert(Comparisons::value_type("=", VALUE_EQUAL));
+	_comparisons.insert(Comparisons::value_type("==", VALUE_EQUAL));
+	_comparisons.insert(Comparisons::value_type(">", VALUE_GREATER_THAN));
+	_comparisons.insert(Comparisons::value_type(">=", VALUE_GREATER_THAN_OR_EQUAL));
+	_comparisons.insert(Comparisons::value_type("<>", VALUE_NOT_EQUAL));
+	_comparisons.insert(Comparisons::value_type("!=", VALUE_NOT_EQUAL));
+	_comparisons.insert(Comparisons::value_type("IS NULL", VALUE_IS_NULL));
+}
+
+
+RowFilter::~RowFilter()
+{
+	try
+	{
+		if (_pRecordSet) _pRecordSet->filter(0);
+		if (_pParent && _pParent->has(this))
+			_pParent->removeFilter(this);
+		release();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+bool RowFilter::isAllowed(std::size_t row) const
+{
+	Poco::Dynamic::Var retVal;
+	const RecordSet& rs = recordSet();
+	
+	std::size_t columns = rs.columnCount();
+	ComparisonMap::const_iterator it = _comparisonMap.begin();
+	ComparisonMap::const_iterator end = _comparisonMap.end();
+	for (; it != end; ++it)
+	{
+		for (std::size_t col = 0; col < columns; ++col)
+		{
+			const std::string name = toUpper(rs.metaColumn(static_cast<UInt32>(col)).name());
+			if (_comparisonMap.find(name) == _comparisonMap.end()) continue;
+
+			Poco::Dynamic::Var ret;
+			CompT compOp = 0;
+			Poco::Dynamic::Var val = rs.value(col, row, false);
+
+			switch (it->second.get<1>())
+			{
+			case VALUE_LESS_THAN:
+				compOp = less; break;
+			case VALUE_LESS_THAN_OR_EQUAL:
+				compOp = lessOrEqual; break;
+			case VALUE_EQUAL:
+				compOp = equal; break;
+			case VALUE_GREATER_THAN:
+				compOp = greater; break;
+			case VALUE_GREATER_THAN_OR_EQUAL:
+				compOp = greaterOrEqual; break;
+			case VALUE_NOT_EQUAL:
+				compOp = notEqual; break;
+			case VALUE_IS_NULL:
+				compOp = isNull; break;
+			default:
+				throw IllegalStateException("Unsupported comparison criteria.");
+			}
+			
+			doCompare(ret, val, compOp, it->second);
+			if (retVal.isEmpty()) retVal = ret;
+			else retVal = retVal || ret;
+		}
+	}
+
+	// iterate through children
+	FilterMap::const_iterator fIt = _filterMap.begin();
+	FilterMap::const_iterator fEnd = _filterMap.end();
+	for (; fIt != fEnd; ++fIt)
+	{
+		if (OP_OR == fIt->second)
+		{
+			if (retVal.isEmpty())
+				retVal = fIt->first->isAllowed(row);
+			else
+				retVal = retVal || fIt->first->isAllowed(row);
+		}
+		else if (OP_AND == fIt->second)
+		{
+			if (retVal.isEmpty())
+				retVal = fIt->first->isAllowed(row);
+			else
+				retVal = retVal && fIt->first->isAllowed(row);
+		}
+		else
+			throw IllegalStateException("Unknown logical operation.");
+	}
+
+	if (retVal.isEmpty()) retVal = true; // no filtering found
+	return (!_not) && retVal.extract<bool>();
+}
+
+
+int RowFilter::remove(const std::string& name)
+{
+	poco_check_ptr (_pRecordSet);
+	_pRecordSet->moveFirst();
+	return static_cast<int>(_comparisonMap.erase(toUpper(name)));
+}
+
+
+RowFilter::Comparison RowFilter::getComparison(const std::string& comp) const
+{
+	Comparisons::const_iterator it = _comparisons.find(toUpper(comp));
+	if (it == _comparisons.end())
+		throw NotFoundException("Comparison not found", comp);
+
+	return it->second;
+}
+
+
+void RowFilter::addFilter(Ptr pFilter, LogicOperator comparison)
+{
+	poco_check_ptr (_pRecordSet);
+
+	pFilter->_pRecordSet = _pRecordSet;
+	_pRecordSet->moveFirst();
+	_filterMap.insert(FilterMap::value_type(pFilter, comparison));
+}
+
+
+void RowFilter::removeFilter(Ptr pFilter)
+{
+	poco_check_ptr (_pRecordSet);
+
+	_pRecordSet->moveFirst();
+	_filterMap.erase(pFilter);
+	pFilter->_pRecordSet = 0;
+	pFilter->_pParent = 0;
+}
+
+
+void RowFilter::doCompare(Poco::Dynamic::Var& ret,
+	Poco::Dynamic::Var& val,
+	CompT comp,
+	const ComparisonEntry& ce)
+{
+	if (ret.isEmpty()) ret = comp(val, ce.get<0>());
+	else
+	{
+		if (ce.get<2>() == OP_OR)
+			ret = ret || comp(val, ce.get<0>());
+		else if (ce.get<2>() == OP_AND)
+			ret = ret && comp(val, ce.get<0>());
+		else
+			throw IllegalStateException("Unknown logical operation.");
+	}
+}
+
+
+RecordSet& RowFilter::recordSet() const
+{
+	if (!_pRecordSet)
+	{
+		Ptr pParent = _pParent;
+		while (pParent && !_pRecordSet)
+			_pRecordSet = pParent->_pRecordSet;
+	}
+	poco_check_ptr (_pRecordSet);
+	return *_pRecordSet; 
+}
+
+
+void RowFilter::rewindRecordSet()
+{
+	if (_pRecordSet) _pRecordSet->moveFirst();
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/RowFormatter.cpp b/base/poco/Data/src/RowFormatter.cpp
new file mode 100644
index 00000000000..071c80f6f3a
--- /dev/null
+++ b/base/poco/Data/src/RowFormatter.cpp
@@ -0,0 +1,80 @@
+//
+// RowFormatter.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  RowFormatter
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/RowFormatter.h"
+#include "Poco/Exception.h"
+#include <iomanip>
+
+
+namespace Poco {
+namespace Data {
+
+
+RowFormatter::RowFormatter(const std::string& prefix,
+	const std::string& postfix,
+	Mode mode):
+	_prefix(prefix), 
+	_postfix(postfix),
+	_mode(mode),
+	_totalRowCount(0)
+{
+}
+
+
+RowFormatter::~RowFormatter()
+{
+}
+
+
+std::string& RowFormatter::formatNames(const NameVecPtr pNames, std::string& formattedNames)
+{
+	formattedNames.clear();
+	return formattedNames;
+}
+
+
+void RowFormatter::formatNames(const NameVecPtr pNames)
+{
+	return;
+}
+
+
+std::string& RowFormatter::formatValues(const ValueVec& vals, std::string& formattedValues)
+{
+	formattedValues.clear();
+	return formattedValues;
+}
+
+
+void RowFormatter::formatValues(const ValueVec& vals)
+{
+	return;
+}
+
+
+const std::string& RowFormatter::toString()
+{
+	throw NotImplementedException("RowFormatter::toString()");
+}
+
+
+void RowFormatter::reset()
+{
+	_prefix = "";
+	_postfix = "";
+	_totalRowCount = INVALID_ROW_COUNT;
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/RowIterator.cpp b/base/poco/Data/src/RowIterator.cpp
new file mode 100644
index 00000000000..c7e1f45c3e4
--- /dev/null
+++ b/base/poco/Data/src/RowIterator.cpp
@@ -0,0 +1,207 @@
+//
+// RowIterator.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  RowIterator
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/RowIterator.h"
+#include "Poco/Data/RecordSet.h"
+#undef min
+#undef max
+#include <limits>
+
+
+namespace Poco {
+namespace Data {
+
+
+const std::size_t RowIterator::POSITION_END = std::numeric_limits<std::size_t>::max();
+
+
+RowIterator::RowIterator(RecordSet* pRecordSet, bool positionEnd): 
+	_pRecordSet(pRecordSet),
+	_position(positionEnd ? POSITION_END : 0)
+{
+}
+
+
+RowIterator::RowIterator(const RowIterator& other):
+	_pRecordSet(other._pRecordSet),
+	_position(other._position)
+{
+}
+
+
+RowIterator::~RowIterator()
+{
+}
+
+
+RowIterator& RowIterator::operator = (const RowIterator& other)
+{
+	RowIterator tmp(other);
+	swap(tmp);
+	return *this;
+}
+
+
+void RowIterator::swap(RowIterator& other)
+{
+	using std::swap;
+	
+	swap(_pRecordSet, other._pRecordSet);
+	swap(_position, other._position);
+}
+
+
+void RowIterator::increment() const
+{
+	if (POSITION_END == _position)
+		throw RangeException("End of iterator reached.");
+
+	if (_position < _pRecordSet->subTotalRowCount() - 1)
+		++_position;
+	else
+		_position = POSITION_END;
+
+	if (_pRecordSet->getFilter() && POSITION_END != _position)
+	{
+		while (!_pRecordSet->isAllowed(_position))
+		{
+			increment();
+			if (POSITION_END == _position) break;
+		}
+	}
+}
+
+
+void RowIterator::decrement() const
+{
+	if (0 == _position)
+		throw RangeException("Beginning of iterator reached.");
+	else if (POSITION_END == _position)
+		_position = _pRecordSet->subTotalRowCount() - 1;
+	else
+		--_position;
+
+	if (_pRecordSet->getFilter() && 0 != _position)
+	{
+		while (!_pRecordSet->isAllowed(_position))
+		{
+			decrement();
+			if (0 == _position) break;
+		}
+	}
+}
+
+
+void RowIterator::setPosition(std::size_t pos) const
+{
+	if (_position == pos) return;
+
+	if (_pRecordSet->getFilter())
+	{
+		std::size_t start = _position;
+		if (_position > pos)
+		{
+			std::size_t end = _position - pos;
+			for (; start > end; --start)
+			{
+				if (pos) --pos;
+				else throw RangeException("Invalid position argument.");
+			}
+		}
+		else
+		{
+			std::size_t end = pos - _position;
+			for (; start < end; ++start)
+			{
+				if (_pRecordSet->subTotalRowCount() != pos) ++pos;
+				else throw RangeException("Invalid position argument.");
+			}
+		}
+	}
+
+	if (pos < _pRecordSet->subTotalRowCount())
+		_position = pos;
+	else if (pos == _pRecordSet->subTotalRowCount())
+		_position = POSITION_END;
+	else
+		throw RangeException("Invalid position argument.");
+}
+
+
+Row& RowIterator::operator * () const
+{
+	if (POSITION_END == _position)
+		throw InvalidAccessException("End of iterator reached.");
+
+	return _pRecordSet->row(_position);
+}
+
+
+Row* RowIterator::operator -> () const
+{
+	if (POSITION_END == _position)
+		throw InvalidAccessException("End of iterator reached.");
+
+	return &_pRecordSet->row(_position);
+}
+
+
+const RowIterator& RowIterator::operator ++ () const
+{
+	increment();
+	return *this;
+}
+
+
+RowIterator RowIterator::operator ++ (int) const
+{
+	RowIterator old(*this);
+	increment();
+	return old;
+}
+
+
+const RowIterator& RowIterator::operator -- () const
+{
+	decrement();
+	return *this;
+}
+
+
+RowIterator RowIterator::operator -- (int) const
+{
+	RowIterator old(*this);
+	decrement();
+	return old;
+}
+
+
+RowIterator RowIterator::operator + (std::size_t diff) const
+{
+	RowIterator ri(*this);
+	ri.setPosition(_position + diff);
+	return ri;
+}
+
+
+RowIterator RowIterator::operator - (std::size_t diff) const
+{
+	if (diff > _position) throw RangeException("Invalid position argument.");
+	RowIterator ri(*this);
+	ri.setPosition(_position - diff);
+	return ri;
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/SQLChannel.cpp b/base/poco/Data/src/SQLChannel.cpp
new file mode 100644
index 00000000000..bd23fc9a5bf
--- /dev/null
+++ b/base/poco/Data/src/SQLChannel.cpp
@@ -0,0 +1,296 @@
+//
+// SQLChannel.cpp
+//
+// Library: Data
+// Package: Logging
+// Module:  SQLChannel
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/SQLChannel.h"
+#include "Poco/Data/SessionFactory.h"
+#include "Poco/DateTime.h"
+#include "Poco/LoggingFactory.h"
+#include "Poco/Instantiator.h"
+#include "Poco/NumberParser.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/Format.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+using namespace Keywords;
+
+
+const std::string SQLChannel::PROP_CONNECTOR("connector");
+const std::string SQLChannel::PROP_CONNECT("connect");
+const std::string SQLChannel::PROP_NAME("name");
+const std::string SQLChannel::PROP_TABLE("table");
+const std::string SQLChannel::PROP_ARCHIVE_TABLE("archive");
+const std::string SQLChannel::PROP_MAX_AGE("keep");
+const std::string SQLChannel::PROP_ASYNC("async");
+const std::string SQLChannel::PROP_TIMEOUT("timeout");
+const std::string SQLChannel::PROP_THROW("throw");
+
+
+SQLChannel::SQLChannel():
+	_name("-"),
+	_table("T_POCO_LOG"),
+	_timeout(1000),
+	_throw(true),
+	_async(true),
+	_pid(),
+	_tid(),
+	_priority()
+{
+}
+
+
+SQLChannel::SQLChannel(const std::string& connector, 
+	const std::string& connect,
+	const std::string& name):
+	_connector(connector),
+	_connect(connect),
+	_name(name),
+	_table("T_POCO_LOG"),
+	_timeout(1000),
+	_throw(true),
+	_async(true),
+	_pid(),
+	_tid(),
+	_priority()
+{
+	open();
+}
+
+
+SQLChannel::~SQLChannel()
+{
+	try
+	{
+		close();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void SQLChannel::open()
+{
+	if (_connector.empty() || _connect.empty())
+		throw IllegalStateException("Connector and connect string must be non-empty.");
+
+	_pSession = new Session(_connector, _connect);
+	initLogStatement();
+}
+
+	
+void SQLChannel::close()
+{
+	wait();
+}
+
+
+void SQLChannel::log(const Message& msg)
+{
+	if (_async) logAsync(msg);
+	else logSync(msg);
+}
+
+
+void SQLChannel::logAsync(const Message& msg)
+{
+	poco_check_ptr (_pLogStatement);
+	if (0 == wait() && !_pLogStatement->done() && !_pLogStatement->initialized()) 
+	{
+		if (_throw) 
+			throw TimeoutException("Timed out waiting for previous statement completion");
+		else return;
+	}
+
+	if (!_pSession || !_pSession->isConnected()) open();
+	logSync(msg);
+}
+
+
+void SQLChannel::logSync(const Message& msg)
+{
+	if (_pArchiveStrategy) _pArchiveStrategy->archive();
+
+	_source = msg.getSource();
+	_pid = msg.getPid();
+	_thread = msg.getThread();
+	_tid = msg.getTid();
+	_priority = msg.getPriority();
+	_text = msg.getText();
+	_dateTime = msg.getTime();
+	if (_source.empty()) _source = _name;
+
+	try
+	{
+		_pLogStatement->execute();
+	}
+	catch (Exception&)
+	{
+		if (_throw) throw;
+	}
+}
+
+	
+void SQLChannel::setProperty(const std::string& name, const std::string& value)
+{
+	if (name == PROP_NAME)
+	{
+		_name = value;
+		if (_name.empty()) _name = "-";
+	}
+	else if (name == PROP_CONNECTOR)
+	{
+		_connector = value;
+		close(); open();
+	}
+	else if (name == PROP_CONNECT)
+	{
+		_connect = value;
+		close(); open();
+	}
+	else if (name == PROP_TABLE)
+	{
+		_table = value;
+		initLogStatement();
+	}
+	else if (name == PROP_ARCHIVE_TABLE)
+	{
+		if (value.empty())
+		{
+			_pArchiveStrategy = 0;
+		}
+		else if (_pArchiveStrategy)
+		{
+			_pArchiveStrategy->setDestination(value);
+		}
+		else
+		{
+			_pArchiveStrategy = new ArchiveByAgeStrategy(_connector, _connect, _table, value);
+		}
+	}
+	else if (name == PROP_MAX_AGE)
+	{
+		if (value.empty() || "forever" == value)
+		{
+			_pArchiveStrategy = 0;
+		}
+		else if (_pArchiveStrategy)
+		{
+			_pArchiveStrategy->setThreshold(value);
+		}
+		else
+		{
+			ArchiveByAgeStrategy* p = new ArchiveByAgeStrategy(_connector, _connect, _table);
+			p->setThreshold(value);
+			_pArchiveStrategy = p;
+		}
+	}
+	else if (name == PROP_ASYNC)
+	{
+		_async = isTrue(value);
+		initLogStatement();
+	}
+	else if (name == PROP_TIMEOUT)
+	{
+		if (value.empty() || '0' == value[0])
+			_timeout = Statement::WAIT_FOREVER;
+		else
+			_timeout = NumberParser::parse(value);
+	}
+	else if (name == PROP_THROW)
+	{
+		_throw = isTrue(value);
+	}
+	else
+	{
+		Channel::setProperty(name, value);
+	}
+}
+
+	
+std::string SQLChannel::getProperty(const std::string& name) const
+{
+	if (name == PROP_NAME)
+	{
+		if (_name != "-") return _name;
+		else return "";
+	}
+	else if (name == PROP_CONNECTOR)
+	{
+		return _connector;
+	}
+	else if (name == PROP_CONNECT)
+	{
+		return _connect;
+	}
+	else if (name == PROP_TABLE)
+	{
+		return _table;
+	}
+	else if (name == PROP_ARCHIVE_TABLE)
+	{
+		return _pArchiveStrategy ? _pArchiveStrategy->getDestination() : "" ;
+	}
+	else if (name == PROP_MAX_AGE)
+	{
+		return _pArchiveStrategy ? _pArchiveStrategy->getThreshold() : "forever";
+	}
+	else if (name == PROP_TIMEOUT)
+	{
+		return NumberFormatter::format(_timeout);
+	}
+	else if (name == PROP_THROW)
+	{
+		if (_throw) return "true";
+		else return "false";
+	}
+	else
+	{
+		return Channel::getProperty(name);
+	}
+}
+
+
+void SQLChannel::initLogStatement()
+{
+	_pLogStatement = new Statement(*_pSession);
+
+	std::string sql;
+	Poco::format(sql, "INSERT INTO %s VALUES (?,?,?,?,?,?,?,?)", _table);
+	*_pLogStatement << sql,
+		use(_source),
+		use(_name),
+		use(_pid),
+		use(_thread),
+		use(_tid),
+		use(_priority),
+		use(_text),
+		use(_dateTime);
+
+	if (_async) _pLogStatement->setAsync();
+}
+
+
+void SQLChannel::registerChannel()
+{
+	Poco::LoggingFactory::defaultFactory().registerChannelClass("SQLChannel", 
+		new Poco::Instantiator<SQLChannel, Poco::Channel>);
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/Session.cpp b/base/poco/Data/src/Session.cpp
new file mode 100644
index 00000000000..e2cc6b6dd3b
--- /dev/null
+++ b/base/poco/Data/src/Session.cpp
@@ -0,0 +1,78 @@
+//
+// Session.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  Session
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/Session.h"
+#include "Poco/Data/SessionFactory.h"
+#include "Poco/String.h"
+#include "Poco/URI.h"
+#include <algorithm>
+
+
+namespace Poco {
+namespace Data {
+
+
+Session::Session(Poco::AutoPtr<SessionImpl> pImpl):
+	_pImpl(pImpl),
+	_statementCreator(pImpl)
+{
+	poco_check_ptr (pImpl.get());
+}
+
+
+Session::Session(const std::string& connector,
+	const std::string& connectionString,
+	std::size_t timeout)
+{
+	Session newSession(SessionFactory::instance().create(connector, connectionString, timeout));
+	swap(newSession);
+}
+
+
+Session::Session(const std::string& connection,
+	std::size_t timeout)
+{
+	Session newSession(SessionFactory::instance().create(connection, timeout));
+	swap(newSession);
+}
+
+
+Session::Session(const Session& other):	_pImpl(other._pImpl),
+	_statementCreator(other._pImpl)
+{
+}
+
+
+Session::~Session()
+{
+}
+
+
+Session& Session::operator = (const Session& other)
+{
+	Session tmp(other);
+	swap(tmp);
+	return *this;
+}
+
+
+void Session::swap(Session& other)
+{
+	using std::swap;
+	swap(_statementCreator, other._statementCreator);
+	swap(_pImpl, other._pImpl);
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/SessionFactory.cpp b/base/poco/Data/src/SessionFactory.cpp
new file mode 100644
index 00000000000..bcc5c412f1c
--- /dev/null
+++ b/base/poco/Data/src/SessionFactory.cpp
@@ -0,0 +1,93 @@
+//
+// SessionFactory.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  SessionFactory
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/SessionFactory.h"
+#include "Poco/URI.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+SessionFactory::SessionFactory()
+{
+}
+
+
+SessionFactory::~SessionFactory()
+{
+}
+
+
+SessionFactory& SessionFactory::instance()
+{
+	static SessionFactory sf;
+	return sf;
+}
+
+
+void SessionFactory::add(Connector* pIn)
+{
+	Poco::FastMutex::ScopedLock lock(_mutex);
+	SessionInfo info(pIn);
+	std::pair<Connectors::iterator, bool> res =
+		_connectors.insert(std::make_pair(pIn->name(), info));
+	if (!res.second) res.first->second.cnt++;
+}
+
+
+void SessionFactory::remove(const std::string& key)
+{
+	Poco::FastMutex::ScopedLock lock(_mutex);
+	Connectors::iterator it = _connectors.find(key);
+	poco_assert (_connectors.end() != it);
+
+	--(it->second.cnt);
+	if (it->second.cnt == 0) _connectors.erase(it);
+}
+
+
+Session SessionFactory::create(const std::string& key,
+	const std::string& connectionString,
+	std::size_t timeout)
+{
+	Poco::SharedPtr<Connector> ptrSI;
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+		Connectors::iterator it = _connectors.find(key);
+		if (_connectors.end() == it) throw Poco::NotFoundException(key);
+		ptrSI = it->second.ptrSI;
+	}
+	return Session(ptrSI->createSession(connectionString, timeout));
+}
+
+
+Session SessionFactory::create(const std::string& uri,
+	std::size_t timeout)
+{
+	URI u(uri);
+	poco_assert (!u.getPath().empty());
+	return create(u.getScheme(), u.getPath().substr(1), timeout);
+}
+
+
+SessionFactory::SessionInfo::SessionInfo(Connector* pSI): 
+	cnt(1), 
+	ptrSI(pSI)
+{
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/SessionImpl.cpp b/base/poco/Data/src/SessionImpl.cpp
new file mode 100644
index 00000000000..a422f751696
--- /dev/null
+++ b/base/poco/Data/src/SessionImpl.cpp
@@ -0,0 +1,52 @@
+//
+// SessionImpl.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  SessionImpl
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/SessionImpl.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+SessionImpl::SessionImpl(const std::string& connectionString, std::size_t timeout): 
+	_connectionString(connectionString),
+	_loginTimeout(timeout)
+{
+}
+
+
+SessionImpl::~SessionImpl()
+{
+}
+
+
+void SessionImpl::reconnect()
+{
+	close();
+	open();
+}
+
+
+void SessionImpl::setConnectionString(const std::string& connectionString)
+{
+	if (isConnected())
+		throw Poco::InvalidAccessException("Can not change connection string on connected session."
+			" Close the session first.");
+
+	_connectionString = connectionString;
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/SessionPool.cpp b/base/poco/Data/src/SessionPool.cpp
new file mode 100644
index 00000000000..095b38cfc3e
--- /dev/null
+++ b/base/poco/Data/src/SessionPool.cpp
@@ -0,0 +1,308 @@
+//
+// SessionPool.cpp
+//
+// Library: Data
+// Package: SessionPooling
+// Module:  SessionPool
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/SessionPool.h"
+#include "Poco/Data/SessionFactory.h"
+#include "Poco/Data/DataException.h"
+#include <algorithm>
+
+
+namespace Poco {
+namespace Data {
+
+
+SessionPool::SessionPool(const std::string& connector, const std::string& connectionString, int minSessions, int maxSessions, int idleTime):
+	_connector(connector),
+	_connectionString(connectionString),
+	_minSessions(minSessions),
+	_maxSessions(maxSessions),
+	_idleTime(idleTime),
+	_nSessions(0),
+	_janitorTimer(1000*idleTime, 1000*idleTime/4),
+	_shutdown(false)
+{
+	Poco::TimerCallback<SessionPool> callback(*this, &SessionPool::onJanitorTimer);
+	_janitorTimer.start(callback);
+}
+
+
+SessionPool::~SessionPool()
+{
+	try
+	{
+		shutdown();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+Session SessionPool::get(const std::string& name, bool value)
+{
+	Session s = get();
+	_addFeatureMap.insert(AddFeatureMap::value_type(s.impl(),
+		std::make_pair(name, s.getFeature(name))));
+	s.setFeature(name, value);
+
+	return s;
+}
+
+
+Session SessionPool::get()
+{
+	Poco::Mutex::ScopedLock lock(_mutex);
+    if (_shutdown) throw InvalidAccessException("Session pool has been shut down.");
+	
+	purgeDeadSessions();
+
+	if (_idleSessions.empty())
+	{
+		if (_nSessions < _maxSessions)
+		{
+			Session newSession(SessionFactory::instance().create(_connector, _connectionString));
+			applySettings(newSession.impl());
+			customizeSession(newSession);
+
+			PooledSessionHolderPtr pHolder(new PooledSessionHolder(*this, newSession.impl()));
+			_idleSessions.push_front(pHolder);
+			++_nSessions;
+		}
+		else throw SessionPoolExhaustedException(_connector);
+	}
+
+	PooledSessionHolderPtr pHolder(_idleSessions.front());
+	PooledSessionImplPtr pPSI(new PooledSessionImpl(pHolder));
+	
+	_activeSessions.push_front(pHolder);
+	_idleSessions.pop_front();
+	return Session(pPSI);
+}
+
+
+void SessionPool::purgeDeadSessions()
+{
+	Poco::Mutex::ScopedLock lock(_mutex);
+	if (_shutdown) return;
+
+	SessionList::iterator it = _idleSessions.begin();
+	for (; it != _idleSessions.end(); )
+	{
+		if (!(*it)->session()->isConnected())
+		{
+			it = _idleSessions.erase(it);
+			--_nSessions;
+		}
+		else ++it;
+	}
+}
+
+
+int SessionPool::capacity() const
+{
+	return _maxSessions;
+}
+
+	
+int SessionPool::used() const
+{
+	Poco::Mutex::ScopedLock lock(_mutex);
+	return (int) _activeSessions.size();
+}
+
+	
+int SessionPool::idle() const
+{
+	Poco::Mutex::ScopedLock lock(_mutex);
+	return (int) _idleSessions.size();
+}
+
+
+int SessionPool::dead()
+{
+	Poco::Mutex::ScopedLock lock(_mutex);
+	int count = 0;
+
+	SessionList::iterator it = _activeSessions.begin();
+	SessionList::iterator itEnd = _activeSessions.end();
+	for (; it != itEnd; ++it)
+	{
+		if (!(*it)->session()->isConnected())
+			++count;
+	}
+
+	return count;
+}
+
+
+int SessionPool::allocated() const
+{
+	Poco::Mutex::ScopedLock lock(_mutex);
+	return _nSessions;
+}
+
+	
+int SessionPool::available() const
+{
+	if (_shutdown) return 0;
+	return _maxSessions - used();
+}
+
+
+void SessionPool::setFeature(const std::string& name, bool state)
+{
+	Poco::Mutex::ScopedLock lock(_mutex);
+	if (_shutdown) throw InvalidAccessException("Session pool has been shut down.");
+
+	if (_nSessions > 0)
+		throw InvalidAccessException("Features can not be set after the first session was created.");
+
+	_featureMap.insert(FeatureMap::ValueType(name, state));
+}
+
+
+bool SessionPool::getFeature(const std::string& name)
+{
+	FeatureMap::ConstIterator it = _featureMap.find(name);
+	if (_shutdown) throw InvalidAccessException("Session pool has been shut down.");
+
+	if (_featureMap.end() == it)
+		throw NotFoundException("Feature not found:" + name);
+
+	return it->second;
+}
+
+
+void SessionPool::setProperty(const std::string& name, const Poco::Any& value)
+{
+	Poco::Mutex::ScopedLock lock(_mutex);
+	if (_shutdown) throw InvalidAccessException("Session pool has been shut down.");
+
+	if (_nSessions > 0)
+		throw InvalidAccessException("Properties can not be set after first session was created.");
+
+	_propertyMap.insert(PropertyMap::ValueType(name, value));
+}
+
+
+Poco::Any SessionPool::getProperty(const std::string& name)
+{
+	PropertyMap::ConstIterator it = _propertyMap.find(name);
+
+	if (_propertyMap.end() == it)
+		throw NotFoundException("Property not found:" + name);
+
+	return it->second;
+}
+
+
+void SessionPool::applySettings(SessionImpl* pImpl)
+{
+	FeatureMap::Iterator fmIt = _featureMap.begin();
+	FeatureMap::Iterator fmEnd = _featureMap.end();
+	for (; fmIt != fmEnd; ++fmIt) pImpl->setFeature(fmIt->first, fmIt->second);
+
+	PropertyMap::Iterator pmIt = _propertyMap.begin();
+	PropertyMap::Iterator pmEnd = _propertyMap.end();
+	for (; pmIt != pmEnd; ++pmIt) pImpl->setProperty(pmIt->first, pmIt->second);
+}
+
+
+void SessionPool::customizeSession(Session&)
+{
+}
+
+
+void SessionPool::putBack(PooledSessionHolderPtr pHolder)
+{
+	Poco::Mutex::ScopedLock lock(_mutex);
+	if (_shutdown) return;
+
+	SessionList::iterator it = std::find(_activeSessions.begin(), _activeSessions.end(), pHolder);
+	if (it != _activeSessions.end())
+	{
+		if (pHolder->session()->isConnected())
+		{
+			// reverse settings applied at acquisition time, if any
+			AddPropertyMap::iterator pIt = _addPropertyMap.find(pHolder->session());
+			if (pIt != _addPropertyMap.end())
+				pHolder->session()->setProperty(pIt->second.first, pIt->second.second);
+
+			AddFeatureMap::iterator fIt = _addFeatureMap.find(pHolder->session());
+			if (fIt != _addFeatureMap.end())
+				pHolder->session()->setFeature(fIt->second.first, fIt->second.second);
+
+			// re-apply the default pool settings
+			applySettings(pHolder->session());
+
+			pHolder->access();
+			_idleSessions.push_front(pHolder);
+		}
+		else --_nSessions;
+
+		_activeSessions.erase(it);
+	}
+	else
+	{
+		poco_bugcheck_msg("Unknown session passed to SessionPool::putBack()");
+	}
+}
+
+
+void SessionPool::onJanitorTimer(Poco::Timer&)
+{
+	Poco::Mutex::ScopedLock lock(_mutex);
+	if (_shutdown) return;
+
+	SessionList::iterator it = _idleSessions.begin(); 
+	while (_nSessions > _minSessions && it != _idleSessions.end())
+	{
+		if ((*it)->idle() > _idleTime || !(*it)->session()->isConnected())
+		{	
+			try	{ (*it)->session()->close(); }
+			catch (...) { }
+			it = _idleSessions.erase(it);
+			--_nSessions;
+		}
+		else ++it;
+	}
+}
+
+
+void SessionPool::shutdown()
+{
+	Poco::Mutex::ScopedLock lock(_mutex);
+	if (_shutdown) return;
+	_shutdown = true;
+	_janitorTimer.stop();
+	closeAll(_idleSessions);
+	closeAll(_activeSessions);
+}
+
+
+void SessionPool::closeAll(SessionList& sessionList)
+{
+	SessionList::iterator it = sessionList.begin(); 
+	for (; it != sessionList.end();)
+	{
+		try	{ (*it)->session()->close(); }
+		catch (...) { }
+		it = sessionList.erase(it);
+		if (_nSessions > 0) --_nSessions;
+	}
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/SessionPoolContainer.cpp b/base/poco/Data/src/SessionPoolContainer.cpp
new file mode 100644
index 00000000000..1fd1bb292ca
--- /dev/null
+++ b/base/poco/Data/src/SessionPoolContainer.cpp
@@ -0,0 +1,122 @@
+//
+// SessionPoolContainer.cpp
+//
+// Library: Data
+// Package: SessionPooling
+// Module:  SessionPoolContainer
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/SessionPoolContainer.h"
+#include "Poco/Data/SessionFactory.h"
+#include "Poco/Data/DataException.h"
+#include "Poco/URI.h"
+#include "Poco/String.h"
+#include "Poco/Exception.h"
+#include <algorithm>
+
+
+using Poco::FastMutex;
+
+
+namespace Poco {
+namespace Data {
+
+
+SessionPoolContainer::SessionPoolContainer()
+{
+}
+
+
+SessionPoolContainer::~SessionPoolContainer()
+{
+}
+
+
+void SessionPoolContainer::add(SessionPool* pPool)
+{
+	poco_check_ptr (pPool);
+
+	FastMutex::ScopedLock lock(_mutex);
+	if (_sessionPools.find(pPool->name()) != _sessionPools.end())
+		throw SessionPoolExistsException("Session pool already exists: " + pPool->name());
+
+	pPool->duplicate();
+	_sessionPools.insert(SessionPoolMap::value_type(pPool->name(), pPool));
+}
+
+
+Session SessionPoolContainer::add(const std::string& sessionKey, 
+	const std::string& connectionString,
+	int minSessions, 
+	int maxSessions, 
+	int idleTime)
+{
+	std::string name = SessionPool::name(sessionKey, connectionString);
+
+	FastMutex::ScopedLock lock(_mutex);
+	SessionPoolMap::iterator it = _sessionPools.find(name);
+
+	// pool already exists, silently return a session from it
+	if (it != _sessionPools.end()) return it->second->get();
+
+	SessionPool* pSP = 
+		new SessionPool(sessionKey, connectionString, minSessions, maxSessions, idleTime);
+
+	std::pair<SessionPoolMap::iterator, bool> ins = 
+		_sessionPools.insert(SessionPoolMap::value_type(name, pSP));
+
+	return ins.first->second->get();
+}
+
+
+bool SessionPoolContainer::isActive(const std::string& sessionKey,
+		const std::string& connectionString) const
+{
+	std::string name = connectionString.empty() ? 
+		sessionKey : SessionPool::name(sessionKey, connectionString);
+
+	SessionPoolMap::const_iterator it = _sessionPools.find(name);
+	if (it != _sessionPools.end() && it->second->isActive())
+	{
+		return true;
+	}
+
+	return false;
+}
+
+
+Session SessionPoolContainer::get(const std::string& name)
+{
+	return getPool(name).get();
+}
+
+
+SessionPool& SessionPoolContainer::getPool(const std::string& name)
+{
+	URI uri(name);
+	std::string path = uri.getPath();
+	poco_assert (!path.empty());
+	std::string n = Session::uri(uri.getScheme(), path.substr(1));
+
+	FastMutex::ScopedLock lock(_mutex);
+	SessionPoolMap::iterator it = _sessionPools.find(n);
+	if (_sessionPools.end() == it) throw NotFoundException(n);
+	return *it->second;
+}
+
+
+void SessionPoolContainer::shutdown()
+{
+	SessionPoolMap::iterator it = _sessionPools.begin();
+	SessionPoolMap::iterator end = _sessionPools.end();
+	for (; it != end; ++it) it->second->shutdown();
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/SimpleRowFormatter.cpp b/base/poco/Data/src/SimpleRowFormatter.cpp
new file mode 100644
index 00000000000..839eb86e52d
--- /dev/null
+++ b/base/poco/Data/src/SimpleRowFormatter.cpp
@@ -0,0 +1,113 @@
+//
+// RowFormatter.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  RowFormatter
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/SimpleRowFormatter.h"
+#include "Poco/Exception.h"
+#include <iomanip>
+
+
+namespace Poco {
+namespace Data {
+
+
+SimpleRowFormatter::SimpleRowFormatter(std::streamsize columnWidth, std::streamsize spacing):
+	_colWidth(columnWidth), _spacing(spacing), _rowCount(0)
+{
+}
+
+
+SimpleRowFormatter::SimpleRowFormatter(const SimpleRowFormatter& other):
+	RowFormatter(other.prefix(), other.postfix()),
+	_colWidth(other._colWidth),
+	_spacing(other._spacing),
+	_rowCount(0)
+{
+}
+
+
+SimpleRowFormatter::~SimpleRowFormatter()
+{
+}
+
+
+SimpleRowFormatter& SimpleRowFormatter::operator = (const SimpleRowFormatter& row)
+{
+	SimpleRowFormatter tmp(row);
+	swap(tmp);
+	return *this;
+}
+
+
+void SimpleRowFormatter::swap(SimpleRowFormatter& other)
+{
+	using std::swap;
+
+	setPrefix(other.prefix());
+	setPostfix(other.postfix());
+	swap(_colWidth, other._colWidth);
+	swap(_spacing, other._spacing);
+}
+
+
+std::string& SimpleRowFormatter::formatNames(const NameVecPtr pNames, std::string& formattedNames)
+{
+	_rowCount = 0;
+
+	std::ostringstream str;
+	std::string line(std::string::size_type(pNames->size()*_colWidth + (pNames->size() - 1)*_spacing), '-');
+	std::string space(_spacing, ' ');
+	NameVec::const_iterator it = pNames->begin();
+	NameVec::const_iterator end = pNames->end();
+	for (; it != end; ++it)
+	{
+		if (it != pNames->begin()) str << space;
+		str << std::left << std::setw(_colWidth) << *it;
+	}
+	str << std::endl << line << std::endl;
+
+	return formattedNames = str.str();
+}
+
+
+std::string& SimpleRowFormatter::formatValues(const ValueVec& vals, std::string& formattedValues)
+{
+	std::ostringstream str;
+	std::string space(_spacing, ' ');
+	ValueVec::const_iterator it = vals.begin();
+	ValueVec::const_iterator end = vals.end();
+	for (; it != end; ++it)
+	{
+		if (it != vals.begin()) str << space;
+		if (it->isNumeric())
+		{
+			str << std::right 
+				<< std::fixed
+				<< std::setprecision(2);
+		}
+		else str << std::left;
+
+		if (!it->isEmpty())
+			str << std::setw(_colWidth) << it->convert<std::string>();
+		else
+			str << std::setw(_colWidth) << "null";
+	}
+	str << std::endl;
+
+	++_rowCount;
+
+	return formattedValues = str.str();
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/Statement.cpp b/base/poco/Data/src/Statement.cpp
new file mode 100644
index 00000000000..d4c470ae836
--- /dev/null
+++ b/base/poco/Data/src/Statement.cpp
@@ -0,0 +1,296 @@
+//
+// Statement.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  Statement
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/Statement.h"
+#include "Poco/Data/DataException.h"
+#include "Poco/Data/Extraction.h"
+#include "Poco/Data/Session.h"
+#include "Poco/Data/Bulk.h"
+#include "Poco/Any.h"
+#include "Poco/Tuple.h"
+#include "Poco/ActiveMethod.h"
+#include <algorithm>
+
+
+namespace Poco {
+namespace Data {
+
+
+Statement::Statement(StatementImpl::Ptr pImpl):
+	_pImpl(pImpl),
+	_async(false)
+{
+	poco_check_ptr (pImpl);
+}
+
+
+Statement::Statement(Session& session):
+	_async(false)
+{
+	reset(session);
+}
+
+
+Statement::Statement(const Statement& stmt):
+	_pImpl(stmt._pImpl),
+	_async(stmt._async),
+	_pResult(stmt._pResult),
+	_pAsyncExec(stmt._pAsyncExec),
+	_arguments(stmt._arguments),
+	_pRowFormatter(stmt._pRowFormatter)
+{
+}
+
+
+Statement::~Statement()
+{
+}
+
+
+Statement& Statement::operator = (const Statement& stmt)
+{
+	Statement tmp(stmt);
+	swap(tmp);
+	return *this;
+}
+
+
+void Statement::swap(Statement& other)
+{
+	using std::swap;
+	
+	swap(_pImpl, other._pImpl);
+	swap(_async, other._async);
+	swap(_pAsyncExec, other._pAsyncExec);
+	swap(_pResult, other._pResult);
+	_arguments.swap(other._arguments);
+	swap(_pRowFormatter, other._pRowFormatter);
+}
+
+
+Statement& Statement::reset(Session& session)
+{
+	Statement stmt(session.createStatementImpl());
+	swap(stmt);
+	return *this;
+}
+
+
+std::size_t Statement::execute(bool reset)
+{
+	Mutex::ScopedLock lock(_mutex);
+	bool isDone = done();
+	if (initialized() || paused() || isDone)
+	{
+		if (_arguments.size()) 
+		{
+			_pImpl->formatSQL(_arguments);
+			_arguments.clear();
+		}
+
+		if (!isAsync())
+		{
+			if (isDone) _pImpl->reset();
+			return _pImpl->execute(reset);
+		}
+		else
+		{
+			doAsyncExec();
+			return 0;
+		}
+	} 
+	else throw InvalidAccessException("Statement still executing.");
+}
+
+
+const Statement::Result& Statement::executeAsync(bool reset)
+{
+	Mutex::ScopedLock lock(_mutex);
+	if (initialized() || paused() || done())
+		return doAsyncExec(reset);
+	else
+		throw InvalidAccessException("Statement still executing.");
+}
+
+
+const Statement::Result& Statement::doAsyncExec(bool reset)
+{
+	if (done()) _pImpl->reset();
+	if (!_pAsyncExec)
+		_pAsyncExec = new AsyncExecMethod(_pImpl, &StatementImpl::execute);
+	_pResult = new Result((*_pAsyncExec)(reset));
+	return *_pResult;
+}
+
+
+void Statement::setAsync(bool async)
+{
+	_async = async;
+	if (_async && !_pAsyncExec)
+		_pAsyncExec = new AsyncExecMethod(_pImpl, &StatementImpl::execute);
+}
+
+
+std::size_t Statement::wait(long milliseconds)
+{
+	if (!_pResult) return 0;
+	bool success = true;
+	if (WAIT_FOREVER != milliseconds)
+		success = _pResult->tryWait(milliseconds);
+	else
+		_pResult->wait();
+
+	if (_pResult->exception())
+		throw *_pResult->exception();
+	else if (!success)
+		throw TimeoutException("Statement timed out.");
+
+	return _pResult->data();
+}
+
+
+const std::string& Statement::getStorage() const
+{
+	switch (storage())
+	{
+	case STORAGE_VECTOR:
+		return StatementImpl::VECTOR;
+	case STORAGE_LIST:
+		return StatementImpl::LIST;
+	case STORAGE_DEQUE:
+		return StatementImpl::DEQUE;
+	case STORAGE_UNKNOWN:
+		return StatementImpl::UNKNOWN;
+	}
+
+	throw IllegalStateException("Invalid storage setting.");
+}
+
+
+Statement& Statement::operator , (Manipulator manip)
+{
+	manip(*this);
+	return *this;
+}
+
+
+Statement& Statement::addBind(AbstractBinding::Ptr pBind)
+{
+	if (pBind->isBulk())
+	{
+		if (!_pImpl->isBulkSupported())
+			throw InvalidAccessException("Bulk not supported by this session.");
+
+		if(_pImpl->bulkBindingAllowed())
+			_pImpl->setBulkBinding();
+		else
+			throw InvalidAccessException("Bulk and non-bulk binding modes can not be mixed.");
+	}
+	else _pImpl->forbidBulk();
+
+	_pImpl->addBind(pBind);
+	return *this;
+}
+
+
+Statement& Statement::addExtract(AbstractExtraction::Ptr pExtract)
+{
+	if (pExtract->isBulk())
+	{
+		if (!_pImpl->isBulkSupported())
+			throw InvalidAccessException("Bulk not supported by this session.");
+
+		if(_pImpl->bulkExtractionAllowed())
+		{
+			Bulk b(pExtract->getLimit());
+			_pImpl->setBulkExtraction(b);
+		}
+		else
+			throw InvalidAccessException("Bulk and non-bulk extraction modes can not be mixed.");
+	}
+	else _pImpl->forbidBulk();
+
+	_pImpl->addExtract(pExtract);
+	return *this;
+}
+
+
+Statement& Statement::operator , (const Limit& extrLimit)
+{
+	if (_pImpl->isBulkExtraction() && _pImpl->extractionLimit() != extrLimit)
+		throw InvalidArgumentException("Limit for bulk extraction already set.");
+
+	_pImpl->setExtractionLimit(extrLimit);
+	return *this;
+}
+
+
+Statement& Statement::operator , (const Range& extrRange)
+{
+	if (_pImpl->isBulkExtraction())
+		throw InvalidAccessException("Can not set range for bulk extraction.");
+
+	_pImpl->setExtractionLimit(extrRange.lower());
+	_pImpl->setExtractionLimit(extrRange.upper());
+	return *this;
+}
+
+
+Statement& Statement::operator , (const Bulk& bulk)
+{
+	if (!_pImpl->isBulkSupported())
+			throw InvalidAccessException("Bulk not supported by this session.");
+
+	if (0 == _pImpl->extractions().size() && 
+		0 == _pImpl->bindings().size() &&
+		_pImpl->bulkExtractionAllowed() &&
+		_pImpl->bulkBindingAllowed())
+	{
+		_pImpl->setBulkExtraction(bulk);
+		_pImpl->setBulkBinding();
+	}
+	else
+		throw InvalidAccessException("Can not set bulk operations.");
+
+	return *this;
+}
+
+
+Statement& Statement::operator , (BulkFnType)
+{
+	const Limit& limit(_pImpl->extractionLimit());
+	if (limit.isHardLimit() || 
+		limit.isLowerLimit() || 
+		Limit::LIMIT_UNLIMITED == limit.value())
+	{
+		throw InvalidAccessException("Bulk is only allowed with limited extraction,"
+			"non-hard and zero-based limits.");
+	}
+
+	Bulk bulk(limit);
+	_pImpl->setBulkExtraction(bulk);
+	_pImpl->setBulkBinding();
+
+	return *this;
+}
+
+
+Session Statement::session()
+{
+	Poco::AutoPtr<SessionImpl> ps(&impl()->session(), true); 
+	return Session(ps);
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/StatementCreator.cpp b/base/poco/Data/src/StatementCreator.cpp
new file mode 100644
index 00000000000..6fd944aa005
--- /dev/null
+++ b/base/poco/Data/src/StatementCreator.cpp
@@ -0,0 +1,60 @@
+//
+// StatementCreator.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  StatementCreator
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/StatementCreator.h"
+#include <algorithm>
+
+
+namespace Poco {
+namespace Data {
+
+
+StatementCreator::StatementCreator()
+{
+}
+
+
+StatementCreator::StatementCreator(Poco::AutoPtr<SessionImpl> ptrImpl):
+	_ptrImpl(ptrImpl)
+{
+}
+
+
+StatementCreator::StatementCreator(const StatementCreator& other):
+	_ptrImpl(other._ptrImpl)
+{
+}
+
+
+StatementCreator& StatementCreator::operator = (const StatementCreator& other)
+{
+	StatementCreator tmp(other);
+	swap(tmp);
+	return *this;
+}
+
+
+void StatementCreator::swap(StatementCreator& other)
+{
+	using std::swap;
+	swap(_ptrImpl, other._ptrImpl);
+}
+
+
+StatementCreator::~StatementCreator()
+{
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/StatementImpl.cpp b/base/poco/Data/src/StatementImpl.cpp
new file mode 100644
index 00000000000..43d2c362c16
--- /dev/null
+++ b/base/poco/Data/src/StatementImpl.cpp
@@ -0,0 +1,476 @@
+//
+// StatementImpl.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  StatementImpl
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/StatementImpl.h"
+#include "Poco/Data/SessionImpl.h"
+#include "Poco/Data/DataException.h"
+#include "Poco/Data/AbstractBinder.h"
+#include "Poco/Data/Extraction.h"
+#include "Poco/Data/LOB.h"
+#include "Poco/Data/Date.h"
+#include "Poco/Data/Time.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/DateTime.h"
+#include "Poco/Exception.h"
+#include "Poco/Data/DataException.h"
+
+
+using Poco::icompare;
+
+
+namespace Poco {
+namespace Data {
+
+
+using namespace Keywords;
+
+
+const std::string StatementImpl::VECTOR = "vector";
+const std::string StatementImpl::LIST = "list";
+const std::string StatementImpl::DEQUE = "deque";
+const std::string StatementImpl::UNKNOWN = "unknown";
+
+
+StatementImpl::StatementImpl(SessionImpl& rSession):
+	_state(ST_INITIALIZED),
+	_extrLimit(upperLimit(Limit::LIMIT_UNLIMITED, false)),
+	_lowerLimit(0),
+	_rSession(rSession),
+	_storage(STORAGE_UNKNOWN_IMPL),
+	_ostr(),
+	_curDataSet(0),
+	_bulkBinding(BULK_UNDEFINED),
+	_bulkExtraction(BULK_UNDEFINED)
+{
+	if (!_rSession.isConnected())
+		throw NotConnectedException(_rSession.connectionString());
+
+	_extractors.resize(1);
+	_columnsExtracted.resize(1, 0);
+	_subTotalRowCount.resize(1, 0);
+}
+
+
+StatementImpl::~StatementImpl()
+{
+}
+
+
+std::size_t StatementImpl::execute(const bool& reset)
+{
+	if (reset) resetExtraction();
+
+	if (!_rSession.isConnected())
+	{
+		_state = ST_DONE;
+		throw NotConnectedException(_rSession.connectionString());
+	}
+
+	std::size_t lim = 0;
+	if (_lowerLimit > _extrLimit.value())
+		throw LimitException("Illegal Statement state. Upper limit must not be smaller than the lower limit.");
+
+	do
+	{
+		compile();
+		if (_extrLimit.value() == Limit::LIMIT_UNLIMITED)
+			lim += executeWithoutLimit();
+		else
+			lim += executeWithLimit();
+	} while (canCompile());
+
+	if (_extrLimit.value() == Limit::LIMIT_UNLIMITED)
+		_state = ST_DONE;
+
+	if (lim < _lowerLimit)
+		throw LimitException("Did not receive enough data.");
+
+	assignSubTotal(reset);
+
+	return lim;
+}
+
+
+void StatementImpl::assignSubTotal(bool reset)
+{
+	if (_extractors.size() == _subTotalRowCount.size())
+	{
+		CountVec::iterator it  = _subTotalRowCount.begin();
+		CountVec::iterator end = _subTotalRowCount.end();
+		for (int counter = 0; it != end; ++it, ++counter)
+		{
+			if (_extractors[counter].size())
+			{
+				if (reset)
+					*it = CountVec::value_type(_extractors[counter][0]->numOfRowsHandled());
+				else
+					*it += CountVec::value_type(_extractors[counter][0]->numOfRowsHandled());
+			}
+		}
+	}
+}
+
+
+std::size_t StatementImpl::executeWithLimit()
+{
+	poco_assert (_state != ST_DONE);
+	std::size_t count = 0;
+	std::size_t limit = _extrLimit.value();
+
+	do
+	{
+		bind();
+		while (count < limit && hasNext()) 
+			count += next();
+	} while (count < limit && canBind());
+
+	if (!canBind() && (!hasNext() || limit == 0)) 
+		_state = ST_DONE;
+	else if (hasNext() && limit == count && _extrLimit.isHardLimit())
+		throw LimitException("HardLimit reached (retrieved more data than requested).");
+	else 
+		_state = ST_PAUSED;
+
+	int affectedRows = affectedRowCount();
+	if (count == 0)
+	{
+		if (affectedRows > 0)
+			return affectedRows;
+	}
+
+	return count;
+}
+
+
+std::size_t StatementImpl::executeWithoutLimit()
+{
+	poco_assert (_state != ST_DONE);
+	std::size_t count = 0;
+
+	do
+	{
+		bind();
+		while (hasNext()) count += next();
+	} while (canBind());
+
+	int affectedRows = affectedRowCount();
+	if (count == 0)
+	{
+		if (affectedRows > 0)
+			return affectedRows;
+	}
+
+	return count;
+}
+
+
+void StatementImpl::compile()
+{
+	if (_state == ST_INITIALIZED || 
+		_state == ST_RESET || 
+		_state == ST_BOUND)
+	{
+		compileImpl();
+		_state = ST_COMPILED;
+
+		if (!extractions().size() && !isStoredProcedure())
+		{
+			std::size_t cols = columnsReturned();
+			if (cols) makeExtractors(cols);
+		}
+
+		fixupExtraction();
+		fixupBinding();
+	}
+}
+
+
+void StatementImpl::bind()
+{
+	if (_state == ST_COMPILED)
+	{
+		bindImpl();
+		_state = ST_BOUND;
+	}
+	else if (_state == ST_BOUND)
+	{
+		if (!hasNext())
+		{
+			if (canBind()) bindImpl();
+			else _state = ST_DONE;
+		}
+	}
+}
+
+
+void StatementImpl::reset()
+{
+	resetBinding();
+	resetExtraction();
+	_state = ST_RESET;
+}
+
+
+void StatementImpl::setExtractionLimit(const Limit& extrLimit)
+{
+	if (!extrLimit.isLowerLimit())
+		_extrLimit = extrLimit;
+	else
+		_lowerLimit = extrLimit.value();
+}
+
+
+void StatementImpl::setBulkExtraction(const Bulk& b)
+{
+	Limit::SizeT limit = getExtractionLimit();
+	if (Limit::LIMIT_UNLIMITED != limit && b.size() != limit)
+		throw InvalidArgumentException("Can not set limit for statement.");
+
+	setExtractionLimit(b.limit());
+	_bulkExtraction = BULK_EXTRACTION;
+}
+
+
+void StatementImpl::fixupExtraction()
+{
+	CountVec::iterator sIt  = _subTotalRowCount.begin();
+	CountVec::iterator sEnd = _subTotalRowCount.end();
+	for (; sIt != sEnd; ++sIt) *sIt = 0;
+
+	if (_curDataSet >= _columnsExtracted.size())
+	{
+		_columnsExtracted.resize(_curDataSet + 1, 0);
+		_subTotalRowCount.resize(_curDataSet + 1, 0);
+	}
+
+	Poco::Data::AbstractExtractionVec::iterator it    = extractions().begin();
+	Poco::Data::AbstractExtractionVec::iterator itEnd = extractions().end();
+	for (; it != itEnd; ++it)
+	{
+		(*it)->setExtractor(extractor());
+		(*it)->setLimit(_extrLimit.value()),
+		_columnsExtracted[_curDataSet] += (int)(*it)->numOfColumnsHandled();
+	}
+}
+
+
+void StatementImpl::fixupBinding()
+{
+	// no need to call binder().reset(); here will be called before each bind anyway
+	AbstractBindingVec::iterator it    = bindings().begin();
+	AbstractBindingVec::iterator itEnd = bindings().end();
+	for (; it != itEnd; ++it) (*it)->setBinder(binder());
+}
+
+
+void StatementImpl::resetBinding()
+{
+	AbstractBindingVec::iterator it    = bindings().begin();
+	AbstractBindingVec::iterator itEnd = bindings().end();
+	for (; it != itEnd; ++it) (*it)->reset();
+}
+
+
+void StatementImpl::resetExtraction()
+{
+	Poco::Data::AbstractExtractionVec::iterator it = extractions().begin();
+	Poco::Data::AbstractExtractionVec::iterator itEnd = extractions().end();
+	for (; it != itEnd; ++it) (*it)->reset();
+
+	poco_assert (_curDataSet < _columnsExtracted.size());
+	_columnsExtracted[_curDataSet] = 0;
+}
+
+
+void StatementImpl::setStorage(const std::string& storage)
+{
+	if (0 == icompare(DEQUE, storage))
+		_storage = STORAGE_DEQUE_IMPL;
+	else if (0 == icompare(VECTOR, storage))
+		_storage = STORAGE_VECTOR_IMPL; 
+	else if (0 == icompare(LIST, storage))
+		_storage = STORAGE_LIST_IMPL;
+	else if (0 == icompare(UNKNOWN, storage))
+		_storage = STORAGE_UNKNOWN_IMPL;
+	else
+		throw NotFoundException();
+}
+
+
+void StatementImpl::makeExtractors(std::size_t count)
+{
+	for (int i = 0; i < count; ++i)
+	{
+		const MetaColumn& mc = metaColumn(i);
+		switch (mc.type())
+		{
+			case MetaColumn::FDT_BOOL:
+				addInternalExtract<bool>(mc); break;
+			case MetaColumn::FDT_INT8:  
+				addInternalExtract<Int8>(mc); break;
+			case MetaColumn::FDT_UINT8:  
+				addInternalExtract<UInt8>(mc); break;
+			case MetaColumn::FDT_INT16:  
+				addInternalExtract<Int16>(mc); break;
+			case MetaColumn::FDT_UINT16: 
+				addInternalExtract<UInt16>(mc); break;
+			case MetaColumn::FDT_INT32:  
+				addInternalExtract<Int32>(mc); break;
+			case MetaColumn::FDT_UINT32: 
+				addInternalExtract<UInt32>(mc); break;
+			case MetaColumn::FDT_INT64:  
+				addInternalExtract<Int64>(mc); break;
+			case MetaColumn::FDT_UINT64: 
+				addInternalExtract<UInt64>(mc); break;
+			case MetaColumn::FDT_FLOAT:  
+				addInternalExtract<float>(mc); break;
+			case MetaColumn::FDT_DOUBLE: 
+				addInternalExtract<double>(mc); break;
+			case MetaColumn::FDT_STRING: 
+				addInternalExtract<std::string>(mc); break;
+			case MetaColumn::FDT_WSTRING:
+				addInternalExtract<Poco::UTF16String>(mc); break;
+			case MetaColumn::FDT_BLOB:   
+				addInternalExtract<BLOB>(mc); break;
+			case MetaColumn::FDT_DATE:
+				addInternalExtract<Date>(mc); break;
+			case MetaColumn::FDT_TIME:
+				addInternalExtract<Time>(mc); break;
+			case MetaColumn::FDT_TIMESTAMP:
+				addInternalExtract<DateTime>(mc); break;
+			default:
+				throw Poco::InvalidArgumentException("Data type not supported.");
+		}
+	}
+}
+
+
+const MetaColumn& StatementImpl::metaColumn(const std::string& name) const
+{
+	std::size_t cols = columnsReturned();
+	for (std::size_t i = 0; i < cols; ++i)
+	{
+		const MetaColumn& column = metaColumn(i);
+		if (0 == icompare(column.name(), name)) return column;
+	}
+
+	throw NotFoundException(format("Invalid column name: %s", name));
+}
+
+
+std::size_t StatementImpl::activateNextDataSet()
+{
+	if (_curDataSet + 1 < dataSetCount())
+		return ++_curDataSet;
+	else
+		throw NoDataException("End of data sets reached.");
+}
+
+
+std::size_t StatementImpl::activatePreviousDataSet()
+{
+	if (_curDataSet > 0)
+		return --_curDataSet;
+	else
+		throw NoDataException("Beginning of data sets reached.");
+}
+
+
+void StatementImpl::addExtract(AbstractExtraction::Ptr pExtraction)
+{
+	poco_check_ptr (pExtraction);
+	std::size_t pos = pExtraction->position();
+	if (pos >= _extractors.size()) 
+		_extractors.resize(pos + 1);
+
+	pExtraction->setEmptyStringIsNull(
+		_rSession.getFeature("emptyStringIsNull"));
+
+	pExtraction->setForceEmptyString(
+		_rSession.getFeature("forceEmptyString"));
+
+	_extractors[pos].push_back(pExtraction);
+}
+
+
+void StatementImpl::removeBind(const std::string& name)
+{
+	bool found = false;
+
+	AbstractBindingVec::iterator it = _bindings.begin();
+	for (; it != _bindings.end();)
+	{
+		if ((*it)->name() == name) 
+		{
+			it = _bindings.erase(it);
+			found = true;
+		}
+		else ++it;
+	}
+
+	if (!found)
+		throw NotFoundException(name);
+}
+
+
+std::size_t StatementImpl::columnsExtracted(int dataSet) const
+{
+	if (USE_CURRENT_DATA_SET == dataSet) dataSet = static_cast<int>(_curDataSet);
+	if (_columnsExtracted.size() > 0)
+	{
+		poco_assert (dataSet >= 0 && dataSet < _columnsExtracted.size());
+		return _columnsExtracted[dataSet];
+	}
+
+	return 0;
+}
+
+
+std::size_t StatementImpl::rowsExtracted(int dataSet) const
+{
+	if (USE_CURRENT_DATA_SET == dataSet) dataSet = static_cast<int>(_curDataSet);
+	if (extractions().size() > 0)
+	{
+		poco_assert (dataSet >= 0 && dataSet < _extractors.size());
+		if (_extractors[dataSet].size() > 0)
+			return _extractors[dataSet][0]->numOfRowsHandled();
+	}
+	
+	return 0;
+}
+
+
+std::size_t StatementImpl::subTotalRowCount(int dataSet) const
+{
+	if (USE_CURRENT_DATA_SET == dataSet) dataSet = static_cast<int>(_curDataSet);
+	if (_subTotalRowCount.size() > 0)
+	{
+		poco_assert (dataSet >= 0 && dataSet < _subTotalRowCount.size());
+		return _subTotalRowCount[dataSet];
+	}
+	
+	return 0;
+}
+
+
+void StatementImpl::formatSQL(std::vector<Any>& arguments)
+{
+	std::string sql;
+	Poco::format(sql, _ostr.str(), arguments);
+	_ostr.str("");
+	_ostr << sql;
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Data/src/Time.cpp b/base/poco/Data/src/Time.cpp
new file mode 100644
index 00000000000..de54b96e749
--- /dev/null
+++ b/base/poco/Data/src/Time.cpp
@@ -0,0 +1,139 @@
+//
+// Time.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  Time
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/Time.h"
+#include "Poco/Data/DynamicDateTime.h"
+#include "Poco/DateTime.h"
+#include "Poco/Dynamic/Var.h"
+
+
+using Poco::DateTime;
+using Poco::Dynamic::Var;
+
+
+namespace Poco {
+namespace Data {
+
+
+Time::Time()
+{
+	DateTime dt;
+	assign(dt.hour(), dt.minute(), dt.second());
+}
+
+
+Time::Time(int hour, int minute, int second)
+{
+	assign(hour, minute, second);
+}
+
+
+Time::Time(const DateTime& dt)
+{
+	assign(dt.hour(), dt.minute(), dt.second());
+}
+
+
+Time::~Time()
+{
+}
+
+
+void Time::assign(int hour, int minute, int second)
+{
+	if (hour < 0 || hour > 23) 
+		throw InvalidArgumentException("Hour must be between 0 and 23.");
+
+	if (minute < 0 || minute > 59) 
+		throw InvalidArgumentException("Minute must be between 0 and 59.");
+
+	if (second < 0 || second > 59) 
+		throw InvalidArgumentException("Second must be between 0 and 59.");
+
+	_hour = hour;
+	_minute = minute;
+	_second = second;
+}
+
+
+bool Time::operator < (const Time& time) const
+{
+	int hour = time.hour();
+
+	if (_hour < hour) return true;
+	else if (_hour > hour) return false;
+	else // hours equal
+	{
+		int minute = time.minute();
+		if (_minute < minute) return true;
+		else 
+		if (_minute > minute) return false;
+		else // minutes equal
+		if (_second < time.second()) return true;
+	}
+
+	return false;
+}
+
+
+Time& Time::operator = (const Var& var)
+{
+#ifndef __GNUC__
+// g++ used to choke on this, newer versions seem to digest it fine
+// TODO: determine the version able to handle it properly
+	*this = var.extract<Time>();
+#else
+	*this = var.operator Time(); 
+#endif
+	return *this;
+}
+
+
+} } // namespace Poco::Data
+
+
+#ifdef __GNUC__
+// only needed for g++ (see comment in Time::operator = above)
+
+namespace Poco {
+namespace Dynamic {
+
+
+using Poco::Data::Time;
+using Poco::DateTime;
+
+
+template <>
+Var::operator Time () const
+{
+	VarHolder* pHolder = content();
+
+	if (!pHolder)
+		throw InvalidAccessException("Can not convert empty value.");
+
+	if (typeid(Time) == pHolder->type())
+		return extract<Time>();
+	else
+	{
+		Poco::DateTime result;
+		pHolder->convert(result);
+		return Time(result);
+	}
+}
+
+
+} } // namespace Poco::Dynamic
+
+
+#endif // __GNUC__
diff --git a/base/poco/Data/src/Transaction.cpp b/base/poco/Data/src/Transaction.cpp
new file mode 100644
index 00000000000..21da65304d5
--- /dev/null
+++ b/base/poco/Data/src/Transaction.cpp
@@ -0,0 +1,124 @@
+//
+// Transaction.cpp
+//
+// Library: Data
+// Package: DataCore
+// Module:  Transaction
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Data/Transaction.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+namespace Data {
+
+
+Transaction::Transaction(Poco::Data::Session& rSession, Poco::Logger* pLogger):
+	_rSession(rSession),
+	_pLogger(pLogger)
+{
+	begin();
+}
+
+
+Transaction::Transaction(Poco::Data::Session& rSession, bool start):
+	_rSession(rSession),
+	_pLogger(0)
+{
+	if (start) begin();
+}
+
+	
+Transaction::~Transaction()
+{
+	try
+	{
+		if (_rSession.isTransaction())
+		{
+			try
+			{
+				if (_pLogger) 
+					_pLogger->debug("Rolling back transaction.");
+
+				_rSession.rollback();
+			}
+			catch (Poco::Exception& exc)
+			{
+				if (_pLogger) 
+					_pLogger->error("Error while rolling back database transaction: %s", exc.displayText());
+			}
+			catch (...)
+			{
+				if (_pLogger) 
+					_pLogger->error("Error while rolling back database transaction.");
+			}
+		}
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void Transaction::begin()
+{
+	if (!_rSession.isTransaction())
+		_rSession.begin();
+	else
+		throw InvalidAccessException("Transaction in progress.");
+}
+
+
+void Transaction::execute(const std::string& sql, bool doCommit)
+{
+	if (!_rSession.isTransaction()) _rSession.begin();
+	_rSession << sql, Keywords::now;
+	if (doCommit) commit();
+}
+
+
+void Transaction::execute(const std::vector<std::string>& sql)
+{
+	try
+	{
+		std::vector<std::string>::const_iterator it = sql.begin();
+		std::vector<std::string>::const_iterator end = sql.end();
+		for (; it != end; ++it)	execute(*it, it + 1 == end ? true : false);
+		return;
+	}
+	catch (Exception& ex)
+	{
+		if (_pLogger) _pLogger->log(ex);
+	}
+
+	rollback();
+}
+
+
+void Transaction::commit()
+{
+	if (_pLogger) 
+		_pLogger->debug("Committing transaction.");
+
+	_rSession.commit();
+}
+
+	
+void Transaction::rollback()
+{
+	if (_pLogger) 
+		_pLogger->debug("Rolling back transaction.");
+
+	_rSession.rollback();
+}
+
+
+} } // namespace Poco::Data
diff --git a/base/poco/Foundation/CMakeLists.txt b/base/poco/Foundation/CMakeLists.txt
new file mode 100644
index 00000000000..3e7c7ae3e3e
--- /dev/null
+++ b/base/poco/Foundation/CMakeLists.txt
@@ -0,0 +1,211 @@
+# Foundation (pcre)
+
+file (GLOB SRCS_PCRE src/pcre_*.c)
+
+add_library (_poco_foundation_pcre ${SRCS_PCRE})
+add_library (Poco::Foundation::PCRE ALIAS _poco_foundation_pcre)
+
+target_compile_options (_poco_foundation_pcre PRIVATE -Wno-sign-compare)
+
+# Foundation
+
+set (SRCS
+    src/AbstractObserver.cpp
+    src/ActiveDispatcher.cpp
+    src/ArchiveStrategy.cpp
+    src/Ascii.cpp
+    src/ASCIIEncoding.cpp
+    src/AsyncChannel.cpp
+    src/AtomicCounter.cpp
+    src/Base32Decoder.cpp
+    src/Base32Encoder.cpp
+    src/Base64Decoder.cpp
+    src/Base64Encoder.cpp
+    src/BinaryReader.cpp
+    src/BinaryWriter.cpp
+    src/Bugcheck.cpp
+    src/ByteOrder.cpp
+    src/Channel.cpp
+    src/Checksum.cpp
+    src/Clock.cpp
+    src/CompressedLogFile.cpp
+    src/Condition.cpp
+    src/Configurable.cpp
+    src/ConsoleChannel.cpp
+    src/CountingStream.cpp
+    src/DateTime.cpp
+    src/DateTimeFormat.cpp
+    src/DateTimeFormatter.cpp
+    src/DateTimeParser.cpp
+    src/Debugger.cpp
+    src/DeflatingStream.cpp
+    src/DigestEngine.cpp
+    src/DigestStream.cpp
+    src/DirectoryIterator.cpp
+    src/DirectoryIteratorStrategy.cpp
+    src/DirectoryWatcher.cpp
+    src/Environment.cpp
+    src/Error.cpp
+    src/ErrorHandler.cpp
+    src/Event.cpp
+    src/EventArgs.cpp
+    src/EventChannel.cpp
+    src/Exception.cpp
+    src/FIFOBufferStream.cpp
+    src/File.cpp
+    src/FileChannel.cpp
+    src/FileStream.cpp
+    src/FileStreamFactory.cpp
+    src/Format.cpp
+    src/Formatter.cpp
+    src/FormattingChannel.cpp
+    src/FPEnvironment.cpp
+    src/Glob.cpp
+    src/Hash.cpp
+    src/HashStatistic.cpp
+    src/HexBinaryDecoder.cpp
+    src/HexBinaryEncoder.cpp
+    src/InflatingStream.cpp
+    src/JSONString.cpp
+    src/Latin1Encoding.cpp
+    src/Latin2Encoding.cpp
+    src/Latin9Encoding.cpp
+    src/LineEndingConverter.cpp
+    src/LocalDateTime.cpp
+    src/LogFile.cpp
+    src/Logger.cpp
+    src/LoggingFactory.cpp
+    src/LoggingRegistry.cpp
+    src/LogStream.cpp
+    src/Manifest.cpp
+    src/MD4Engine.cpp
+    src/MD5Engine.cpp
+    src/MemoryPool.cpp
+    src/MemoryStream.cpp
+    src/Message.cpp
+    src/Mutex.cpp
+    src/NamedEvent.cpp
+    src/NamedMutex.cpp
+    src/NestedDiagnosticContext.cpp
+    src/Notification.cpp
+    src/NotificationCenter.cpp
+    src/NotificationQueue.cpp
+    src/NullChannel.cpp
+    src/NullStream.cpp
+    src/NumberFormatter.cpp
+    src/NumberParser.cpp
+    src/NumericString.cpp
+    src/Path.cpp
+    src/PatternFormatter.cpp
+    src/Pipe.cpp
+    src/PipeImpl.cpp
+    src/PipeStream.cpp
+    src/PriorityNotificationQueue.cpp
+    src/Process.cpp
+    src/PurgeStrategy.cpp
+    src/Random.cpp
+    src/RandomStream.cpp
+    src/RefCountedObject.cpp
+    src/RegularExpression.cpp
+    src/RotateStrategy.cpp
+    src/Runnable.cpp
+    src/RWLock.cpp
+    src/Semaphore.cpp
+    src/SHA1Engine.cpp
+    src/SharedLibrary.cpp
+    src/SharedMemory.cpp
+    src/SignalHandler.cpp
+    src/SimpleFileChannel.cpp
+    src/SortedDirectoryIterator.cpp
+    src/SplitterChannel.cpp
+    src/Stopwatch.cpp
+    src/StreamChannel.cpp
+    src/StreamConverter.cpp
+    src/StreamCopier.cpp
+    src/StreamTokenizer.cpp
+    src/String.cpp
+    src/StringTokenizer.cpp
+    src/SynchronizedObject.cpp
+    src/SyslogChannel.cpp
+    src/Task.cpp
+    src/TaskManager.cpp
+    src/TaskNotification.cpp
+    src/TeeStream.cpp
+    src/TemporaryFile.cpp
+    src/TextBufferIterator.cpp
+    src/TextConverter.cpp
+    src/TextEncoding.cpp
+    src/TextIterator.cpp
+    src/Thread.cpp
+    src/ThreadLocal.cpp
+    src/ThreadPool.cpp
+    src/ThreadTarget.cpp
+    src/TimedNotificationQueue.cpp
+    src/Timer.cpp
+    src/Timespan.cpp
+    src/Timestamp.cpp
+    src/Timezone.cpp
+    src/Token.cpp
+    src/Unicode.cpp
+    src/UnicodeConverter.cpp
+    src/URI.cpp
+    src/URIStreamFactory.cpp
+    src/URIStreamOpener.cpp
+    src/UTF16Encoding.cpp
+    src/UTF32Encoding.cpp
+    src/UTF8Encoding.cpp
+    src/UTF8String.cpp
+    src/UUID.cpp
+    src/UUIDGenerator.cpp
+    src/Var.cpp
+    src/VarHolder.cpp
+    src/VarIterator.cpp
+    src/Void.cpp
+    src/Windows1250Encoding.cpp
+    src/Windows1251Encoding.cpp
+    src/Windows1252Encoding.cpp
+)
+
+add_library (_poco_foundation ${SRCS})
+add_library (Poco::Foundation ALIAS _poco_foundation)
+
+target_compile_options (_poco_foundation
+    PRIVATE
+        -Wno-atomic-implicit-seq-cst
+        -Wno-deprecated
+        -Wno-extra-semi-stmt
+        -Wno-zero-as-null-pointer-constant
+        -Wno-implicit-int-float-conversion
+        -Wno-thread-safety-analysis
+        -Wno-thread-safety-negative
+)
+
+target_compile_options (_poco_foundation
+    PRIVATE
+        -Wno-sign-compare
+        -Wno-unused-parameter
+)
+
+target_compile_definitions (_poco_foundation
+    PRIVATE
+        POCO_UNBUNDLED
+        POCO_UNBUNDLED_ZLIB
+    PUBLIC
+        POCO_ENABLE_CPP11
+        POCO_OS_FAMILY_UNIX
+)
+
+target_include_directories (_poco_foundation SYSTEM PUBLIC "include")
+
+target_link_libraries (_poco_foundation
+    PRIVATE
+        Poco::Foundation::PCRE
+        ch_contrib::zlib
+        ch_contrib::lz4)
+
+if(OS_DARWIN AND ARCH_AARCH64)
+    target_compile_definitions (_poco_foundation
+        PRIVATE
+            POCO_NO_STAT64
+    )
+endif()
diff --git a/base/poco/Foundation/include/Poco/ASCIIEncoding.h b/base/poco/Foundation/include/Poco/ASCIIEncoding.h
new file mode 100644
index 00000000000..e47f6153840
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ASCIIEncoding.h
@@ -0,0 +1,51 @@
+//
+// ASCIIEncoding.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  ASCIIEncoding
+//
+// Definition of the ASCIIEncoding class.
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ASCIIEncoding_INCLUDED
+#define Foundation_ASCIIEncoding_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/TextEncoding.h"
+
+
+namespace Poco {
+
+
+class Foundation_API ASCIIEncoding: public TextEncoding
+	/// 7-bit ASCII text encoding.
+{
+public:
+	ASCIIEncoding();
+	~ASCIIEncoding();
+	const char* canonicalName() const;
+	bool isA(const std::string& encodingName) const;
+	const CharacterMap& characterMap() const;
+	int convert(const unsigned char* bytes) const;
+	int convert(int ch, unsigned char* bytes, int length) const;
+	int queryConvert(const unsigned char* bytes, int length) const;
+	int sequenceLength(const unsigned char* bytes, int length) const;
+	
+private:
+	static const char* _names[];
+	static const CharacterMap _charMap;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ASCIIEncoding_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/AbstractCache.h b/base/poco/Foundation/include/Poco/AbstractCache.h
new file mode 100644
index 00000000000..37cfc25b1ef
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/AbstractCache.h
@@ -0,0 +1,366 @@
+//
+// AbstractCache.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  AbstractCache
+//
+// Definition of the AbstractCache class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_AbstractCache_INCLUDED
+#define Foundation_AbstractCache_INCLUDED
+
+
+#include "Poco/KeyValueArgs.h"
+#include "Poco/ValidArgs.h" 
+#include "Poco/Mutex.h"
+#include "Poco/Exception.h"
+#include "Poco/FIFOEvent.h"
+#include "Poco/EventArgs.h"
+#include "Poco/Delegate.h"
+#include "Poco/SharedPtr.h"
+#include <map>
+#include <set>
+#include <cstddef>
+
+
+namespace Poco {
+
+
+template <class TKey, class TValue, class TStrategy, class TMutex = FastMutex, class TEventMutex = FastMutex> 
+class AbstractCache
+	/// An AbstractCache is the interface of all caches. 
+{
+public:
+	FIFOEvent<const KeyValueArgs<TKey, TValue >, TEventMutex > Add;
+	FIFOEvent<const KeyValueArgs<TKey, TValue >, TEventMutex > Update;
+	FIFOEvent<const TKey, TEventMutex>                         Remove;
+	FIFOEvent<const TKey, TEventMutex>                         Get;
+	FIFOEvent<const EventArgs, TEventMutex>                    Clear;
+
+	typedef std::map<TKey, SharedPtr<TValue > > DataHolder;
+	typedef typename DataHolder::iterator       Iterator;
+	typedef typename DataHolder::const_iterator ConstIterator;
+	typedef std::set<TKey>                      KeySet;
+
+	AbstractCache()
+	{
+		initialize();
+	}
+
+	AbstractCache(const TStrategy& strat): _strategy(strat)
+	{
+		initialize();
+	}
+
+	virtual ~AbstractCache()
+	{
+		try
+		{
+			uninitialize();
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	}
+
+	void add(const TKey& key, const TValue& val)
+		/// Adds the key value pair to the cache.
+		/// If for the key already an entry exists, it will be overwritten.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		doAdd(key, val);
+	}
+
+	void update(const TKey& key, const TValue& val)
+		/// Adds the key value pair to the cache. Note that adding a NULL SharedPtr will fail!
+		/// If for the key already an entry exists, it will be overwritten.
+		/// The difference to add is that no remove or add events are thrown in this case, 
+		/// just a simply silent update is performed
+		/// If the key doesnot exist the behavior is equal to add, ie. an add event is thrown
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		doUpdate(key, val);
+	}
+
+	void add(const TKey& key, SharedPtr<TValue > val)
+		/// Adds the key value pair to the cache. Note that adding a NULL SharedPtr will fail!
+		/// If for the key already an entry exists, it will be overwritten, ie. first a remove event
+		/// is thrown, then a add event
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		doAdd(key, val);
+	}
+
+	void update(const TKey& key, SharedPtr<TValue > val)
+		/// Adds the key value pair to the cache. Note that adding a NULL SharedPtr will fail!
+		/// If for the key already an entry exists, it will be overwritten.
+		/// The difference to add is that no remove or add events are thrown in this case, 
+		/// just an Update is thrown
+		/// If the key doesnot exist the behavior is equal to add, ie. an add event is thrown
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		doUpdate(key, val);
+	}
+
+	void remove(const TKey& key)
+		/// Removes an entry from the cache. If the entry is not found,
+		/// the remove is ignored.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		Iterator it = _data.find(key);
+		doRemove(it);
+	}
+
+	bool has(const TKey& key) const
+		/// Returns true if the cache contains a value for the key.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		return doHas(key);
+	}
+
+	SharedPtr<TValue> get(const TKey& key)
+		/// Returns a SharedPtr of the value. The SharedPointer will remain valid
+		/// even when cache replacement removes the element.
+		/// If for the key no value exists, an empty SharedPtr is returned.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		return doGet (key);
+	}
+
+	void clear()
+		/// Removes all elements from the cache.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		doClear();
+	}
+
+	std::size_t size()
+		/// Returns the number of cached elements
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		doReplace();
+		return _data.size();
+	}
+
+	void forceReplace()
+		/// Forces cache replacement. Note that Poco's cache strategy use for efficiency reason no background thread
+		/// which periodically triggers cache replacement. Cache Replacement is only started when the cache is modified
+		/// from outside, i.e. add is called, or when a user tries to access an cache element via get.
+		/// In some cases, i.e. expire based caching where for a long time no access to the cache happens,
+		/// it might be desirable to be able to trigger cache replacement manually.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		doReplace();
+	}
+
+	std::set<TKey> getAllKeys()
+		/// Returns a copy of all keys stored in the cache
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		doReplace();
+		ConstIterator it = _data.begin();
+		ConstIterator itEnd = _data.end();
+		std::set<TKey> result;
+		for (; it != itEnd; ++it)
+			result.insert(it->first);
+
+		return result;
+	}
+
+protected:
+	mutable FIFOEvent<ValidArgs<TKey> > IsValid;
+	mutable FIFOEvent<KeySet>           Replace;
+
+	void initialize()
+		/// Sets up event registration.
+	{
+		Add		+= Delegate<TStrategy, const KeyValueArgs<TKey, TValue> >(&_strategy, &TStrategy::onAdd);
+		Update	+= Delegate<TStrategy, const KeyValueArgs<TKey, TValue> >(&_strategy, &TStrategy::onUpdate);
+		Remove	+= Delegate<TStrategy, const TKey>(&_strategy, &TStrategy::onRemove);
+		Get		+= Delegate<TStrategy, const TKey>(&_strategy, &TStrategy::onGet);
+		Clear	+= Delegate<TStrategy, const EventArgs>(&_strategy, &TStrategy::onClear);
+		IsValid	+= Delegate<TStrategy, ValidArgs<TKey> >(&_strategy, &TStrategy::onIsValid);
+		Replace	+= Delegate<TStrategy, KeySet>(&_strategy, &TStrategy::onReplace);
+	}
+
+	void uninitialize()
+		/// Reverts event registration.
+	{
+		Add		-= Delegate<TStrategy, const KeyValueArgs<TKey, TValue> >(&_strategy, &TStrategy::onAdd );
+		Update	-= Delegate<TStrategy, const KeyValueArgs<TKey, TValue> >(&_strategy, &TStrategy::onUpdate);
+		Remove	-= Delegate<TStrategy, const TKey>(&_strategy, &TStrategy::onRemove);
+		Get		-= Delegate<TStrategy, const TKey>(&_strategy, &TStrategy::onGet);
+		Clear	-= Delegate<TStrategy, const EventArgs>(&_strategy, &TStrategy::onClear);
+		IsValid	-= Delegate<TStrategy, ValidArgs<TKey> >(&_strategy, &TStrategy::onIsValid);
+		Replace	-= Delegate<TStrategy, KeySet>(&_strategy, &TStrategy::onReplace);
+	}
+
+	void doAdd(const TKey& key, const TValue& val)
+		/// Adds the key value pair to the cache.
+		/// If for the key already an entry exists, it will be overwritten.
+	{
+		Iterator it = _data.find(key);
+		doRemove(it);
+
+		KeyValueArgs<TKey, TValue> args(key, val);
+		Add.notify(this, args);
+		_data.insert(std::make_pair(key, SharedPtr<TValue>(new TValue(val))));
+		
+		doReplace();
+	}
+
+	void doAdd(const TKey& key, SharedPtr<TValue>& val)
+		/// Adds the key value pair to the cache.
+		/// If for the key already an entry exists, it will be overwritten.
+	{
+		Iterator it = _data.find(key);
+		doRemove(it);
+
+		KeyValueArgs<TKey, TValue> args(key, *val);
+		Add.notify(this, args);
+		_data.insert(std::make_pair(key, val));
+		
+		doReplace();
+	}
+
+	void doUpdate(const TKey& key, const TValue& val)
+		/// Adds the key value pair to the cache.
+		/// If for the key already an entry exists, it will be overwritten.
+	{
+		KeyValueArgs<TKey, TValue> args(key, val);
+		Iterator it = _data.find(key);
+		if (it == _data.end())
+		{
+			Add.notify(this, args);
+			_data.insert(std::make_pair(key, SharedPtr<TValue>(new TValue(val))));
+		}
+		else
+		{
+			Update.notify(this, args);
+			it->second = SharedPtr<TValue>(new TValue(val));
+		}
+		
+		doReplace();
+	}
+
+	void doUpdate(const TKey& key, SharedPtr<TValue>& val)
+		/// Adds the key value pair to the cache.
+		/// If for the key already an entry exists, it will be overwritten.
+	{
+		KeyValueArgs<TKey, TValue> args(key, *val);
+		Iterator it = _data.find(key);
+		if (it == _data.end())
+		{
+			Add.notify(this, args);
+			_data.insert(std::make_pair(key, val));
+		}
+		else
+		{
+			Update.notify(this, args);
+			it->second = val;
+		}
+		
+		doReplace();
+	}
+
+	void doRemove(Iterator it) 
+		/// Removes an entry from the cache. If the entry is not found
+		/// the remove is ignored.
+	{
+		if (it != _data.end())
+		{
+			Remove.notify(this, it->first);
+			_data.erase(it);
+		}
+	}
+
+	bool doHas(const TKey& key) const
+		/// Returns true if the cache contains a value for the key
+	{
+		// ask the strategy if the key is valid
+		ConstIterator it = _data.find(key);
+		bool result = false;
+
+		if (it != _data.end())
+		{
+			ValidArgs<TKey> args(key);
+			IsValid.notify(this, args);
+			result = args.isValid();
+		}
+
+		return result;
+	}
+
+	SharedPtr<TValue> doGet(const TKey& key) 
+		/// Returns a SharedPtr of the cache entry, returns 0 if for
+		/// the key no value was found
+	{
+		Iterator it = _data.find(key);
+		SharedPtr<TValue> result;
+
+		if (it != _data.end())
+		{	
+			// inform all strategies that a read-access to an element happens
+			Get.notify(this, key);
+			// ask all strategies if the key is valid
+			ValidArgs<TKey> args(key);
+			IsValid.notify(this, args);
+
+			if (!args.isValid())
+			{
+				doRemove(it);
+			}
+			else
+			{
+				result = it->second;
+			}
+		}
+
+		return result;
+	}
+
+	void doClear()
+	{
+		static EventArgs _emptyArgs;
+		Clear.notify(this, _emptyArgs);
+		_data.clear();
+	}
+
+	void doReplace()
+	{
+		std::set<TKey> delMe;
+		Replace.notify(this, delMe);
+		// delMe contains the to be removed elements
+		typename std::set<TKey>::const_iterator it    = delMe.begin();
+		typename std::set<TKey>::const_iterator endIt = delMe.end();
+
+		for (; it != endIt; ++it)
+		{
+			Iterator itH = _data.find(*it);
+			doRemove(itH);
+		}
+	}
+
+	TStrategy          _strategy;
+	mutable DataHolder _data;
+	mutable TMutex  _mutex;
+
+private:
+	AbstractCache(const AbstractCache& aCache);
+	AbstractCache& operator = (const AbstractCache& aCache);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_AbstractCache_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/AbstractDelegate.h b/base/poco/Foundation/include/Poco/AbstractDelegate.h
new file mode 100644
index 00000000000..9dea69a364f
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/AbstractDelegate.h
@@ -0,0 +1,110 @@
+//
+// AbstractDelegate.h
+//
+// Library: Foundation
+// Package: Events
+// Module:  AbstractDelegate
+//
+// Implementation of the AbstractDelegate template.
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_AbstractDelegate_INCLUDED
+#define Foundation_AbstractDelegate_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+template <class TArgs> 
+class AbstractDelegate
+	/// Base class for Delegate and Expire.
+{
+public:
+	AbstractDelegate()
+	{
+	}
+
+	AbstractDelegate(const AbstractDelegate& /*del*/)
+	{
+	}
+
+	virtual ~AbstractDelegate() 
+	{
+	}
+
+	virtual bool notify(const void* sender, TArgs& arguments) = 0;
+		/// Invokes the delegate's callback function.
+		/// Returns true if successful, or false if the delegate
+		/// has been disabled or has expired.
+
+	virtual bool equals(const AbstractDelegate& other) const = 0;
+		/// Compares the AbstractDelegate with the other one for equality.
+
+	virtual AbstractDelegate* clone() const = 0;
+		/// Returns a deep copy of the AbstractDelegate.
+
+	virtual void disable() = 0;
+		/// Disables the delegate, which is done prior to removal.
+		
+	virtual const AbstractDelegate* unwrap() const
+		/// Returns the unwrapped delegate. Must be overridden by decorators
+		/// like Expire.
+	{
+		return this;
+	}
+};
+
+
+template <> 
+class AbstractDelegate<void>
+	/// Base class for Delegate and Expire.
+{
+public:
+	AbstractDelegate()
+	{
+	}
+
+	AbstractDelegate(const AbstractDelegate&)
+	{
+	}
+
+	virtual ~AbstractDelegate() 
+	{
+	}
+
+	virtual bool notify(const void* sender) = 0;
+		/// Invokes the delegate's callback function.
+		/// Returns true if successful, or false if the delegate
+		/// has been disabled or has expired.
+
+	virtual bool equals(const AbstractDelegate& other) const = 0;
+		/// Compares the AbstractDelegate with the other one for equality.
+
+	virtual AbstractDelegate* clone() const = 0;
+		/// Returns a deep copy of the AbstractDelegate.
+
+	virtual void disable() = 0;
+		/// Disables the delegate, which is done prior to removal.
+		
+	virtual const AbstractDelegate* unwrap() const
+		/// Returns the unwrapped delegate. Must be overridden by decorators
+		/// like Expire.
+	{
+		return this;
+	}
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_AbstractDelegate_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/AbstractEvent.h b/base/poco/Foundation/include/Poco/AbstractEvent.h
new file mode 100644
index 00000000000..917092a9a0e
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/AbstractEvent.h
@@ -0,0 +1,558 @@
+//
+// AbstractEvent.h
+//
+// Library: Foundation
+// Package: Events
+// Module:  AbstractEvent
+//
+// Definition of the AbstractEvent class.
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_AbstractFoundation_INCLUDED
+#define Foundation_AbstractFoundation_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/SingletonHolder.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/ActiveResult.h"
+#include "Poco/ActiveMethod.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+
+
+template <class TArgs, class TStrategy, class TDelegate, class TMutex = FastMutex>
+class AbstractEvent
+	/// An AbstractEvent is the base class of all events.
+	/// It works similar to the way C# handles notifications (aka events in C#).
+	///
+	/// Events can be used to send information to a set of delegates
+	/// which are registered with the event. The type of the data is specified with
+	/// the template parameter TArgs. The TStrategy parameter must be a subclass
+	/// of NotificationStrategy. The parameter TDelegate can either be a subclass of AbstractDelegate
+	/// or of AbstractPriorityDelegate.
+	///
+	/// Note that AbstractEvent should never be used directly. One ought to use
+	/// one of its subclasses which set the TStrategy and TDelegate template parameters
+	/// to fixed values. For most use-cases the BasicEvent template will be sufficient:
+	///
+	///     #include "Poco/BasicEvent.h"
+	///     #include "Poco/Delegate.h"
+	///
+	/// Note that as of release 1.4.2, the behavior of BasicEvent equals that of FIFOEvent,
+	/// so the FIFOEvent class is no longer necessary and provided for backwards compatibility
+	/// only.
+	///
+	/// BasicEvent works with a standard delegate. They allow one object to register
+	/// one or more delegates with an event. In contrast, a PriorityDelegate comes with an attached priority value
+	/// and allows one object to register for one priority value one or more delegates. Note that PriorityDelegates
+	/// only work with PriorityEvents:
+	///
+	///     #include "Poco/PriorityEvent.h"
+	///     #include "Poco/PriorityDelegate.h"
+	///
+	/// Use events by adding them as public members to the object which is throwing notifications:
+	///
+	///     class MyData
+	///     {
+	///     public:
+	///         Poco::BasicEvent<int> dataChanged;
+	///
+	///         MyData();
+	///         ...
+	///         void setData(int i);
+	///         ...
+	///     private:
+	///         int _data;
+	///     };
+	///
+	/// Firing the event is done either by calling the event's notify() or notifyAsync() method:
+	///
+	///     void MyData::setData(int i)
+	///     {
+	///         this->_data = i;
+	///         dataChanged.notify(this, this->_data);
+	///     }
+	///
+	/// Alternatively, instead of notify(), operator () can be used.
+	///
+	///     void MyData::setData(int i)
+	///     {
+	///         this->_data = i;
+	///         dataChanged(this, this->_data);
+	///     }
+	///
+	/// Note that operator (), notify() and notifyAsync() do not catch exceptions, i.e. in case a
+	/// delegate throws an exception, notifying is immediately aborted and the exception is propagated
+	/// back to the caller.
+	///
+	/// Delegates can register methods at the event. In the case of a BasicEvent
+	/// the Delegate template is used, in case of an PriorityEvent a PriorityDelegate is used.
+	/// Mixing of delegates, e.g. using a PriorityDelegate with a BasicEvent is not allowed and
+	/// can lead to compile-time and/or run-time errors. The standalone delegate() functions
+	/// can be used to construct Delegate objects.
+	///
+	/// Events require the observers to have one of the following method signatures:
+	///
+	///     void onEvent(const void* pSender, TArgs& args);
+	///     void onEvent(TArgs& args);
+	///     static void onEvent(const void* pSender, TArgs& args);
+	///     static void onEvent(void* pSender, TArgs& args);
+	///     static void onEvent(TArgs& args);
+	///
+	/// For performance reasons arguments are always sent by reference. This also allows observers
+	/// to modify the event argument. To prevent that, use <[const TArg]> as template
+	/// parameter. A non-conformant method signature leads to compile errors.
+	///
+	/// Assuming that the observer meets the method signature requirement, it can register
+	/// this method with the += operator:
+	///
+	///     class MyController
+	///     {
+	///     protected:
+	///         MyData _data;
+	///
+	///         void onDataChanged(void* pSender, int& data);
+	///         ...
+	///     };
+	///
+	///     MyController::MyController()
+	///     {
+	///         _data.dataChanged += delegate(this, &MyController::onDataChanged);
+	///     }
+	///
+	/// In some cases it might be desirable to work with automatically expiring registrations. Simply add
+	/// to delegate as 3rd parameter a expireValue (in milliseconds):
+	///
+	///     _data.dataChanged += delegate(this, &MyController::onDataChanged, 1000);
+	///
+	/// This will add a delegate to the event which will automatically be removed in 1000 millisecs.
+	///
+	/// Unregistering happens via the -= operator. Forgetting to unregister a method will lead to
+	/// segmentation faults later, when one tries to send a notify to a no longer existing object.
+	///
+	///     MyController::~MyController()
+	///     {
+	///         _data.dataChanged -= delegate(this, &MyController::onDataChanged);
+	///     }
+	///
+	/// Working with PriorityDelegate's as similar to working with BasicEvent.
+	/// Instead of delegate(), the priorityDelegate() function must be used
+	/// to create the PriorityDelegate.
+{
+public:
+	typedef TDelegate* DelegateHandle;
+	typedef TArgs Args;
+
+	AbstractEvent():
+		_executeAsync(this, &AbstractEvent::executeAsyncImpl),
+		_enabled(true)
+	{
+	}
+
+	AbstractEvent(const TStrategy& strat):
+		_executeAsync(this, &AbstractEvent::executeAsyncImpl),
+		_strategy(strat),
+		_enabled(true)
+	{
+	}
+
+	virtual ~AbstractEvent()
+	{
+	}
+
+	void operator += (const TDelegate& aDelegate)
+		/// Adds a delegate to the event.
+		///
+		/// Exact behavior is determined by the TStrategy.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		_strategy.add(aDelegate);
+	}
+
+	void operator -= (const TDelegate& aDelegate)
+		/// Removes a delegate from the event.
+		///
+		/// If the delegate is not found, this function does nothing.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		_strategy.remove(aDelegate);
+	}
+
+	DelegateHandle add(const TDelegate& aDelegate)
+		/// Adds a delegate to the event.
+		///
+		/// Exact behavior is determined by the TStrategy.
+		///
+		/// Returns a DelegateHandle which can be used in call to
+		/// remove() to remove the delegate.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		return _strategy.add(aDelegate);
+	}
+
+	void remove(DelegateHandle delegateHandle)
+		/// Removes a delegate from the event using a DelegateHandle
+		/// returned by add().
+		///
+		/// If the delegate is not found, this function does nothing.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		_strategy.remove(delegateHandle);
+	}
+
+	void operator () (const void* pSender, TArgs& args)
+		/// Shortcut for notify(pSender, args);
+	{
+		notify(pSender, args);
+	}
+
+	void operator () (TArgs& args)
+		/// Shortcut for notify(args).
+	{
+		notify(0, args);
+	}
+
+	void notify(const void* pSender, TArgs& args)
+		/// Sends a notification to all registered delegates. The order is
+		/// determined by the TStrategy. This method is blocking. While executing,
+		/// the list of delegates may be modified. These changes don't
+		/// influence the current active notifications but are activated with
+		/// the next notify. If a delegate is removed during a notify(), the
+		/// delegate will no longer be invoked (unless it has already been
+		/// invoked prior to removal). If one of the delegates throws an exception,
+		/// the notify method is immediately aborted and the exception is propagated
+		/// to the caller.
+	{
+		Poco::ScopedLockWithUnlock<TMutex> lock(_mutex);
+
+		if (!_enabled) return;
+
+		// thread-safeness:
+		// copy should be faster and safer than blocking until
+		// execution ends
+		TStrategy strategy(_strategy);
+		lock.unlock();
+		strategy.notify(pSender, args);
+	}
+
+	bool hasDelegates() const {
+		return !empty();
+	}
+
+	ActiveResult<TArgs> notifyAsync(const void* pSender, const TArgs& args)
+		/// Sends a notification to all registered delegates. The order is
+		/// determined by the TStrategy. This method is not blocking and will
+		/// immediately return. The delegates are invoked in a seperate thread.
+		/// Call activeResult.wait() to wait until the notification has ended.
+		/// While executing, other objects can change the delegate list. These changes don't
+		/// influence the current active notifications but are activated with
+		/// the next notify. If a delegate is removed during a notify(), the
+		/// delegate will no longer be invoked (unless it has already been
+		/// invoked prior to removal). If one of the delegates throws an exception,
+		/// the execution is aborted and the exception is propagated to the caller.
+	{
+		NotifyAsyncParams params(pSender, args);
+		{
+			typename TMutex::ScopedLock lock(_mutex);
+
+			// thread-safeness:
+			// copy should be faster and safer than blocking until
+			// execution ends
+			// make a copy of the strategy here to guarantee that
+			// between notifyAsync and the execution of the method no changes can occur
+
+			params.ptrStrat = SharedPtr<TStrategy>(new TStrategy(_strategy));
+			params.enabled  = _enabled;
+		}
+		ActiveResult<TArgs> result = _executeAsync(params);
+		return result;
+	}
+
+	void enable()
+		/// Enables the event.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		_enabled = true;
+	}
+
+	void disable()
+		/// Disables the event. notify and notifyAsnyc will be ignored,
+		/// but adding/removing delegates is still allowed.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		_enabled = false;
+	}
+
+	bool isEnabled() const
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		return _enabled;
+	}
+
+	void clear()
+		/// Removes all delegates.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		_strategy.clear();
+	}
+
+	bool empty() const
+		/// Checks if any delegates are registered at the delegate.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		return _strategy.empty();
+	}
+
+protected:
+	struct NotifyAsyncParams
+	{
+		SharedPtr<TStrategy> ptrStrat;
+		const void* pSender;
+		TArgs       args;
+		bool        enabled;
+
+		NotifyAsyncParams(const void* pSend, const TArgs& a):ptrStrat(), pSender(pSend), args(a), enabled(true)
+			/// Default constructor reduces the need for TArgs to have an empty constructor, only copy constructor is needed.
+		{
+		}
+	};
+
+	ActiveMethod<TArgs, NotifyAsyncParams, AbstractEvent> _executeAsync;
+
+	TArgs executeAsyncImpl(const NotifyAsyncParams& par)
+	{
+		if (!par.enabled)
+		{
+			return par.args;
+		}
+
+		NotifyAsyncParams params = par;
+		TArgs retArgs(params.args);
+		params.ptrStrat->notify(params.pSender, retArgs);
+		return retArgs;
+	}
+
+	TStrategy _strategy; /// The strategy used to notify observers.
+	bool      _enabled;  /// Stores if an event is enabled. Notfies on disabled events have no effect
+	                     /// but it is possible to change the observers.
+	mutable TMutex _mutex;
+
+private:
+	AbstractEvent(const AbstractEvent& other);
+	AbstractEvent& operator = (const AbstractEvent& other);
+};
+
+
+template <class TStrategy, class TDelegate, class TMutex>
+class AbstractEvent<void, TStrategy, TDelegate, TMutex>
+{
+public:
+	typedef TDelegate* DelegateHandle;
+
+	AbstractEvent():
+		_executeAsync(this, &AbstractEvent::executeAsyncImpl),
+		_enabled(true)
+	{
+	}
+
+	AbstractEvent(const TStrategy& strat):
+		_executeAsync(this, &AbstractEvent::executeAsyncImpl),
+		_strategy(strat),
+		_enabled(true)
+	{
+	}
+
+	virtual ~AbstractEvent()
+	{
+	}
+
+	void operator += (const TDelegate& aDelegate)
+		/// Adds a delegate to the event.
+		///
+		/// Exact behavior is determined by the TStrategy.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		_strategy.add(aDelegate);
+	}
+
+	void operator -= (const TDelegate& aDelegate)
+		/// Removes a delegate from the event.
+		///
+		/// If the delegate is not found, this function does nothing.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		_strategy.remove(aDelegate);
+	}
+
+	DelegateHandle add(const TDelegate& aDelegate)
+		/// Adds a delegate to the event.
+		///
+		/// Exact behavior is determined by the TStrategy.
+		///
+		/// Returns a DelegateHandle which can be used in call to
+		/// remove() to remove the delegate.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		return _strategy.add(aDelegate);
+	}
+
+	void remove(DelegateHandle delegateHandle)
+		/// Removes a delegate from the event using a DelegateHandle
+		/// returned by add().
+		///
+		/// If the delegate is not found, this function does nothing.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		_strategy.remove(delegateHandle);
+	}
+
+	void operator () (const void* pSender)
+		/// Shortcut for notify(pSender, args);
+	{
+		notify(pSender);
+	}
+
+	void operator () ()
+		/// Shortcut for notify(args).
+	{
+		notify(0);
+	}
+
+	void notify(const void* pSender)
+		/// Sends a notification to all registered delegates. The order is
+		/// determined by the TStrategy. This method is blocking. While executing,
+		/// the list of delegates may be modified. These changes don't
+		/// influence the current active notifications but are activated with
+		/// the next notify. If a delegate is removed during a notify(), the
+		/// delegate will no longer be invoked (unless it has already been
+		/// invoked prior to removal). If one of the delegates throws an exception,
+		/// the notify method is immediately aborted and the exception is propagated
+		/// to the caller.
+	{
+		Poco::ScopedLockWithUnlock<TMutex> lock(_mutex);
+
+		if (!_enabled) return;
+
+		// thread-safeness:
+		// copy should be faster and safer than blocking until
+		// execution ends
+		TStrategy strategy(_strategy);
+		lock.unlock();
+		strategy.notify(pSender);
+	}
+
+	ActiveResult<void> notifyAsync(const void* pSender)
+		/// Sends a notification to all registered delegates. The order is
+		/// determined by the TStrategy. This method is not blocking and will
+		/// immediately return. The delegates are invoked in a seperate thread.
+		/// Call activeResult.wait() to wait until the notification has ended.
+		/// While executing, other objects can change the delegate list. These changes don't
+		/// influence the current active notifications but are activated with
+		/// the next notify. If a delegate is removed during a notify(), the
+		/// delegate will no longer be invoked (unless it has already been
+		/// invoked prior to removal). If one of the delegates throws an exception,
+		/// the execution is aborted and the exception is propagated to the caller.
+	{
+		NotifyAsyncParams params(pSender);
+		{
+			typename TMutex::ScopedLock lock(_mutex);
+
+			// thread-safeness:
+			// copy should be faster and safer than blocking until
+			// execution ends
+			// make a copy of the strategy here to guarantee that
+			// between notifyAsync and the execution of the method no changes can occur
+
+			params.ptrStrat = SharedPtr<TStrategy>(new TStrategy(_strategy));
+			params.enabled  = _enabled;
+		}
+		ActiveResult<void> result = _executeAsync(params);
+		return result;
+	}
+
+	void enable()
+		/// Enables the event.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		_enabled = true;
+	}
+
+	void disable()
+		/// Disables the event. notify and notifyAsnyc will be ignored,
+		/// but adding/removing delegates is still allowed.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		_enabled = false;
+	}
+
+	bool isEnabled() const
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		return _enabled;
+	}
+
+	void clear()
+		/// Removes all delegates.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		_strategy.clear();
+	}
+
+	bool empty() const
+		/// Checks if any delegates are registered at the delegate.
+	{
+		typename TMutex::ScopedLock lock(_mutex);
+		return _strategy.empty();
+	}
+
+protected:
+	struct NotifyAsyncParams
+	{
+		SharedPtr<TStrategy> ptrStrat;
+		const void* pSender;
+		bool        enabled;
+
+		NotifyAsyncParams(const void* pSend):ptrStrat(), pSender(pSend), enabled(true)
+			/// Default constructor reduces the need for TArgs to have an empty constructor, only copy constructor is needed.
+		{
+		}
+	};
+
+	ActiveMethod<void, NotifyAsyncParams, AbstractEvent> _executeAsync;
+
+	void executeAsyncImpl(const NotifyAsyncParams& par)
+	{
+		if (!par.enabled)
+		{
+			return;
+		}
+
+		NotifyAsyncParams params = par;
+		params.ptrStrat->notify(params.pSender);
+		return;
+	}
+
+	TStrategy _strategy; /// The strategy used to notify observers.
+	bool      _enabled;  /// Stores if an event is enabled. Notfies on disabled events have no effect
+	                     /// but it is possible to change the observers.
+	mutable TMutex _mutex;
+
+private:
+	AbstractEvent(const AbstractEvent& other);
+	AbstractEvent& operator = (const AbstractEvent& other);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_AbstractFoundation_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/AbstractObserver.h b/base/poco/Foundation/include/Poco/AbstractObserver.h
new file mode 100644
index 00000000000..baa40a66dcc
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/AbstractObserver.h
@@ -0,0 +1,50 @@
+//
+// AbstractObserver.h
+//
+// Library: Foundation
+// Package: Notifications
+// Module:  NotificationCenter
+//
+// Definition of the AbstractObserver class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_AbstractObserver_INCLUDED
+#define Foundation_AbstractObserver_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Notification.h"
+
+
+namespace Poco {
+
+
+class Foundation_API AbstractObserver
+	/// The base class for all instantiations of
+	/// the Observer and NObserver template classes.
+{
+public:
+	AbstractObserver();
+	AbstractObserver(const AbstractObserver& observer);
+	virtual ~AbstractObserver();
+	
+	AbstractObserver& operator = (const AbstractObserver& observer);
+
+	virtual void notify(Notification* pNf) const = 0;
+	virtual bool equals(const AbstractObserver& observer) const = 0;
+	virtual bool accepts(Notification* pNf) const = 0;
+	virtual AbstractObserver* clone() const = 0;
+	virtual void disable() = 0;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_AbstractObserver_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/AbstractPriorityDelegate.h b/base/poco/Foundation/include/Poco/AbstractPriorityDelegate.h
new file mode 100644
index 00000000000..c27bc0c3f46
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/AbstractPriorityDelegate.h
@@ -0,0 +1,63 @@
+//
+// AbstractPriorityDelegate.h
+//
+// Library: Foundation
+// Package: Events
+// Module:  AbstractPriorityDelegate
+//
+// Implementation of the AbstractPriorityDelegate template.
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_AbstractPriorityDelegate_INCLUDED
+#define Foundation_AbstractPriorityDelegate_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/AbstractDelegate.h"
+
+
+namespace Poco {
+
+
+template <class TArgs> 
+class AbstractPriorityDelegate: public AbstractDelegate<TArgs>
+	/// Base class for PriorityDelegate and PriorityExpire.
+	///
+	/// Extends AbstractDelegate with a priority value.
+{
+public:
+	AbstractPriorityDelegate(int prio):
+		_priority(prio)
+	{
+	}
+
+	AbstractPriorityDelegate(const AbstractPriorityDelegate& del):
+		AbstractDelegate<TArgs>(del),
+		_priority(del._priority)
+	{
+	}
+
+	virtual ~AbstractPriorityDelegate() 
+	{
+	}
+
+	int priority() const
+	{
+		return _priority;
+	}
+
+protected:
+	int _priority;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_AbstractPriorityDelegate_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/AbstractStrategy.h b/base/poco/Foundation/include/Poco/AbstractStrategy.h
new file mode 100644
index 00000000000..8d0ac25a224
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/AbstractStrategy.h
@@ -0,0 +1,77 @@
+//
+// AbstractStrategy.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  AbstractCache
+//
+// Definition of the AbstractStrategy class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_AbstractStrategy_INCLUDED
+#define Foundation_AbstractStrategy_INCLUDED
+
+
+#include "Poco/KeyValueArgs.h"
+#include "Poco/ValidArgs.h"
+#include "Poco/EventArgs.h"
+#include <set>
+
+
+namespace Poco {
+
+
+template <class TKey, class TValue> 
+class AbstractStrategy
+	/// An AbstractStrategy is the interface for all strategies. 
+{
+public:
+	AbstractStrategy()
+	{
+	}
+
+	virtual ~AbstractStrategy()
+	{
+	}
+
+	virtual void onUpdate(const void* pSender, const KeyValueArgs <TKey, TValue>& args)
+		/// Updates an existing entry.
+	{
+		onRemove(pSender,args.key());
+		onAdd(pSender, args);
+	}
+	
+	virtual void onAdd(const void* pSender, const KeyValueArgs <TKey, TValue>& key) = 0;
+		/// Adds the key to the strategy.
+		/// If for the key already an entry exists, an exception will be thrown.
+
+	virtual void onRemove(const void* pSender, const TKey& key) = 0;
+		/// Removes an entry from the strategy. If the entry is not found
+		/// the remove is ignored.
+
+	virtual void onGet(const void* pSender, const TKey& key) = 0;
+		/// Informs the strategy that a read-access happens to an element.
+
+	virtual void onClear(const void* pSender, const EventArgs& args) = 0;
+		/// Removes all elements from the cache.
+
+	virtual void onIsValid(const void* pSender, ValidArgs<TKey>& key) = 0;
+		/// Used to query if a key is still valid (i.e. cached).
+
+	virtual void onReplace(const void* pSender, std::set<TKey>& elemsToRemove) = 0;
+		/// Used by the Strategy to indicate which elements should be removed from
+		/// the cache. Note that onReplace does not change the current list of keys.
+		/// The cache object is reponsible to remove the elements.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_AbstractStrategy_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/AccessExpirationDecorator.h b/base/poco/Foundation/include/Poco/AccessExpirationDecorator.h
new file mode 100644
index 00000000000..9978185ffcb
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/AccessExpirationDecorator.h
@@ -0,0 +1,83 @@
+//
+// AccessExpirationDecorator.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  AccessExpirationDecorator
+//
+// Implementation of the AccessExpirationDecorator template.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_AccessExpirationDecorator_INCLUDED
+#define Foundation_AccessExpirationDecorator_INCLUDED
+
+
+#include "Poco/Timestamp.h"
+#include "Poco/Timespan.h"
+
+
+namespace Poco {
+
+
+template <typename TArgs>
+class AccessExpirationDecorator
+	/// AccessExpirationDecorator adds an expiration method to values so that they can be used
+	/// with the UniqueAccessExpireCache
+{
+public:
+	AccessExpirationDecorator():
+		_value(),
+		_span()
+	{
+	}
+
+	AccessExpirationDecorator(const TArgs& p, const Poco::Timespan::TimeDiff& diffInMs):
+			/// Creates an element that will expire in diff milliseconds
+		_value(p),
+		_span(diffInMs*1000)
+	{
+	}
+
+	AccessExpirationDecorator(const TArgs& p, const Poco::Timespan& timeSpan):
+		/// Creates an element that will expire after the given timeSpan
+		_value(p),
+		_span(timeSpan)
+	{
+	}
+
+
+	~AccessExpirationDecorator()
+	{
+	}
+	
+	const Poco::Timespan& getTimeout() const
+	{
+		return _span;
+	}
+
+	const TArgs& value() const
+	{
+		return _value;
+	}
+
+	TArgs& value()
+	{
+		return _value;
+	}
+
+private:
+	TArgs     _value;
+	Timespan  _span;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_AccessExpirationDecorator_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/AccessExpireCache.h b/base/poco/Foundation/include/Poco/AccessExpireCache.h
new file mode 100644
index 00000000000..bb5c571526f
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/AccessExpireCache.h
@@ -0,0 +1,63 @@
+//
+// AccessExpireCache.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  AccessExpireCache
+//
+// Definition of the AccessExpireCache class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_AccessExpireCache_INCLUDED
+#define Foundation_AccessExpireCache_INCLUDED
+
+
+#include "Poco/AbstractCache.h"
+#include "Poco/AccessExpireStrategy.h"
+
+
+namespace Poco {
+
+
+template <
+	class TKey, 
+	class TValue, 
+	class TMutex = FastMutex, 
+	class TEventMutex = FastMutex
+> 
+class AccessExpireCache: public AbstractCache<TKey, TValue, AccessExpireStrategy<TKey, TValue>, TMutex, TEventMutex>
+	/// An AccessExpireCache caches entries for a fixed time period (per default 10 minutes).
+	/// Entries expire when they are not accessed with get() during this time period. Each access resets
+	/// the start time for expiration.
+	/// Be careful when using an AccessExpireCache. A cache is often used
+	/// like cache.has(x) followed by cache.get x). Note that it could happen
+	/// that the "has" call works, then the current execution thread gets descheduled, time passes,
+	/// the entry gets invalid, thus leading to an empty SharedPtr being returned 
+	/// when "get" is invoked.
+{
+public:
+	AccessExpireCache(Timestamp::TimeDiff expire = 600000): 
+		AbstractCache<TKey, TValue, AccessExpireStrategy<TKey, TValue>, TMutex, TEventMutex>(AccessExpireStrategy<TKey, TValue>(expire))
+	{
+	}
+
+	~AccessExpireCache()
+	{
+	}
+
+private:
+	AccessExpireCache(const AccessExpireCache& aCache);
+	AccessExpireCache& operator = (const AccessExpireCache& aCache);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_AccessExpireCache_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/AccessExpireLRUCache.h b/base/poco/Foundation/include/Poco/AccessExpireLRUCache.h
new file mode 100644
index 00000000000..278cbbccd17
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/AccessExpireLRUCache.h
@@ -0,0 +1,62 @@
+//
+// AccessExpireLRUCache.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  AccessExpireLRUCache
+//
+// Definition of the AccessExpireLRUCache class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_AccessExpireLRUCache_INCLUDED
+#define Foundation_AccessExpireLRUCache_INCLUDED
+
+
+#include "Poco/AbstractCache.h"
+#include "Poco/StrategyCollection.h"
+#include "Poco/AccessExpireStrategy.h"
+#include "Poco/LRUStrategy.h"
+
+
+namespace Poco {
+
+
+template < 
+	class TKey,
+	class TValue,
+	class TMutex = FastMutex, 
+	class TEventMutex = FastMutex
+>
+class AccessExpireLRUCache: public AbstractCache<TKey, TValue, StrategyCollection<TKey, TValue>, TMutex, TEventMutex>
+	/// An AccessExpireLRUCache combines LRU caching and time based expire caching.
+	/// It cache entries for a fixed time period (per default 10 minutes)
+	/// but also limits the size of the cache (per default: 1024).
+{
+public:
+	AccessExpireLRUCache(long cacheSize = 1024, Timestamp::TimeDiff expire = 600000): 
+		AbstractCache<TKey, TValue, StrategyCollection<TKey, TValue>, TMutex, TEventMutex >(StrategyCollection<TKey, TValue>())
+	{
+		this->_strategy.pushBack(new LRUStrategy<TKey, TValue>(cacheSize));
+		this->_strategy.pushBack(new AccessExpireStrategy<TKey, TValue>(expire));
+	}
+
+	~AccessExpireLRUCache()
+	{
+	}
+
+private:
+	AccessExpireLRUCache(const AccessExpireLRUCache& aCache);
+	AccessExpireLRUCache& operator = (const AccessExpireLRUCache& aCache);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_AccessExpireLRUCache_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/AccessExpireStrategy.h b/base/poco/Foundation/include/Poco/AccessExpireStrategy.h
new file mode 100644
index 00000000000..3bfa45c21f1
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/AccessExpireStrategy.h
@@ -0,0 +1,74 @@
+//
+// AccessExpireStrategy.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  AccessExpireStrategy
+//
+// Definition of the AccessExpireStrategy class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_AccessExpireStrategy_INCLUDED
+#define Foundation_AccessExpireStrategy_INCLUDED
+
+
+#include "Poco/KeyValueArgs.h"
+#include "Poco/ValidArgs.h"
+#include "Poco/ExpireStrategy.h"
+#include "Poco/Bugcheck.h"
+#include "Poco/Timestamp.h"
+#include "Poco/EventArgs.h"
+#include <set>
+#include <map>
+
+
+namespace Poco {
+
+
+template <
+	class TKey,
+	class TValue
+>
+class AccessExpireStrategy: public ExpireStrategy<TKey, TValue>
+	/// An AccessExpireStrategy implements time and access based expiration of cache entries
+{
+public:
+	AccessExpireStrategy(Timestamp::TimeDiff expireTimeInMilliSec): ExpireStrategy<TKey, TValue>(expireTimeInMilliSec)
+		/// Create an expire strategy. Note that the smallest allowed caching time is 25ms.
+		/// Anything lower than that is not useful with current operating systems.
+	{
+	}
+
+	~AccessExpireStrategy()
+	{
+	}
+
+	void onGet(const void*, const TKey& key)
+	{
+		// get triggers an update to the expiration time
+		typename ExpireStrategy<TKey, TValue>::Iterator it = this->_keys.find(key);
+		if (it != this->_keys.end())
+		{
+			if (!it->second->first.isElapsed(this->_expireTime)) // don't extend if already expired
+			{
+				this->_keyIndex.erase(it->second);
+				Timestamp now;
+				typename ExpireStrategy<TKey, TValue>::IndexIterator itIdx =
+					this->_keyIndex.insert(typename ExpireStrategy<TKey, TValue>::TimeIndex::value_type(now, key));
+				it->second = itIdx;
+			}
+		}
+	}
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_AccessExpireStrategy_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ActiveDispatcher.h b/base/poco/Foundation/include/Poco/ActiveDispatcher.h
new file mode 100644
index 00000000000..7550a2deaeb
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ActiveDispatcher.h
@@ -0,0 +1,116 @@
+//
+// ActiveDispatcher.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  ActiveObjects
+//
+// Definition of the ActiveDispatcher class.
+//
+// Copyright (c) 2006-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ActiveDispatcher_INCLUDED
+#define Foundation_ActiveDispatcher_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Runnable.h"
+#include "Poco/Thread.h"
+#include "Poco/ActiveStarter.h"
+#include "Poco/ActiveRunnable.h"
+#include "Poco/NotificationQueue.h"
+
+
+namespace Poco {
+
+
+class Foundation_API ActiveDispatcher: protected Runnable
+	/// This class is used to implement an active object
+	/// with strictly serialized method execution.
+	///
+	/// An active object, which is an ordinary object
+	/// containing ActiveMethod members, executes all
+	/// active methods in their own thread. 
+	/// This behavior does not fit the "classic"
+	/// definition of an active object, which serializes
+	/// the execution of active methods (in other words,
+	/// only one active method can be running at any given
+	/// time).
+	///
+	/// Using this class as a base class, the serializing
+	/// behavior for active objects can be implemented.
+	/// 
+	/// The following example shows how this is done:
+	///
+	///     class ActiveObject: public ActiveDispatcher
+	///     {
+	///     public:
+	///         ActiveObject():
+	///             exampleActiveMethod(this, &ActiveObject::exampleActiveMethodImpl)
+	///         {
+	///         }
+	///
+	///         ActiveMethod<std::string, std::string, ActiveObject, ActiveStarter<ActiveDispatcher> > exampleActiveMethod;
+	///
+	///     protected:
+	///         std::string exampleActiveMethodImpl(const std::string& arg)
+	///         {
+	///             ...
+	///         }
+	///     };
+	///
+	/// The only things different from the example in
+	/// ActiveMethod is that the ActiveObject in this case
+	/// inherits from ActiveDispatcher, and that the ActiveMethod
+	/// template for exampleActiveMethod has an additional parameter,
+	/// specifying the specialized ActiveStarter for ActiveDispatcher.
+{
+public:
+	ActiveDispatcher();
+		/// Creates the ActiveDispatcher.
+
+	ActiveDispatcher(Thread::Priority prio);
+		/// Creates the ActiveDispatcher and sets
+		/// the priority of its thread.
+
+	virtual ~ActiveDispatcher();
+		/// Destroys the ActiveDispatcher.
+
+	void start(ActiveRunnableBase::Ptr pRunnable);
+		/// Adds the Runnable to the dispatch queue.
+
+	void cancel();
+		/// Cancels all queued methods.
+		
+protected:
+	void run();
+	void stop();
+
+private:
+	Thread            _thread;
+	NotificationQueue _queue;
+};
+
+
+template <>
+class ActiveStarter<ActiveDispatcher>
+	/// A specialization of ActiveStarter
+	/// for ActiveDispatcher.
+{
+public:
+	static void start(ActiveDispatcher* pOwner, ActiveRunnableBase::Ptr pRunnable)
+	{
+		pOwner->start(pRunnable);
+	}
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ActiveDispatcher_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ActiveMethod.h b/base/poco/Foundation/include/Poco/ActiveMethod.h
new file mode 100644
index 00000000000..cefd8f76dc4
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ActiveMethod.h
@@ -0,0 +1,218 @@
+//
+// ActiveMethod.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  ActiveObjects
+//
+// Definition of the ActiveMethod class.
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ActiveMethod_INCLUDED
+#define Foundation_ActiveMethod_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/ActiveResult.h"
+#include "Poco/ActiveRunnable.h"
+#include "Poco/ActiveStarter.h"
+#include "Poco/AutoPtr.h"
+
+
+namespace Poco {
+
+
+template <class ResultType, class ArgType, class OwnerType, class StarterType = ActiveStarter<OwnerType> >
+class ActiveMethod
+	/// An active method is a method that, when called, executes
+	/// in its own thread. ActiveMethod's take exactly one
+	/// argument and can return a value. To pass more than one
+	/// argument to the method, use a struct.
+	/// The following example shows how to add an ActiveMethod
+	/// to a class:
+	///
+	///     class ActiveObject
+	///     {
+	///     public:
+	///         ActiveObject():
+	///             exampleActiveMethod(this, &ActiveObject::exampleActiveMethodImpl)
+	///         {
+	///         }
+	///
+	///         ActiveMethod<std::string, std::string, ActiveObject> exampleActiveMethod;
+	///
+	///     protected:
+	///         std::string exampleActiveMethodImpl(const std::string& arg)
+	///         {
+	///             ...
+	///         }
+	///     };
+	///
+	/// And following is an example that shows how to invoke an ActiveMethod.
+	///
+	///     ActiveObject myActiveObject;
+	///     ActiveResult<std::string> result = myActiveObject.exampleActiveMethod("foo");
+	///     ...
+	///     result.wait();
+	///     std::cout << result.data() << std::endl;
+	///
+	/// The way an ActiveMethod is started can be changed by passing a StarterType
+	/// template argument with a corresponding class. The default ActiveStarter
+	/// starts the method in its own thread, obtained from a thread pool.
+	///
+	/// For an alternative implementation of StarterType, see ActiveDispatcher.
+	///
+	/// For methods that do not require an argument or a return value, the Void
+	/// class can be used.
+{
+public:
+	typedef ResultType (OwnerType::*Callback)(const ArgType&);
+	typedef ActiveResult<ResultType> ActiveResultType;
+	typedef ActiveRunnable<ResultType, ArgType, OwnerType> ActiveRunnableType;
+
+	ActiveMethod(OwnerType* pOwner, Callback method):
+		_pOwner(pOwner),
+		_method(method)
+		/// Creates an ActiveMethod object.
+	{
+		poco_check_ptr (pOwner);
+	}
+	
+	ActiveResultType operator () (const ArgType& arg)
+		/// Invokes the ActiveMethod.
+	{
+		ActiveResultType result(new ActiveResultHolder<ResultType>());
+		ActiveRunnableBase::Ptr pRunnable(new ActiveRunnableType(_pOwner, _method, arg, result));
+		StarterType::start(_pOwner, pRunnable);
+		return result;
+	}
+		
+	ActiveMethod(const ActiveMethod& other):
+		_pOwner(other._pOwner),
+		_method(other._method)
+	{
+	}
+
+	ActiveMethod& operator = (const ActiveMethod& other)
+	{
+		ActiveMethod tmp(other);
+		swap(tmp);
+		return *this;
+	}
+
+	void swap(ActiveMethod& other)
+	{
+		std::swap(_pOwner, other._pOwner);
+		std::swap(_method, other._method);
+	}
+
+private:
+	ActiveMethod();
+
+	OwnerType* _pOwner;
+	Callback   _method;
+};
+
+
+
+template <class ResultType, class OwnerType, class StarterType>
+class ActiveMethod <ResultType, void, OwnerType, StarterType>
+	/// An active method is a method that, when called, executes
+	/// in its own thread. ActiveMethod's take exactly one
+	/// argument and can return a value. To pass more than one
+	/// argument to the method, use a struct.
+	/// The following example shows how to add an ActiveMethod
+	/// to a class:
+	///
+	///     class ActiveObject
+	///     {
+	///     public:
+	///         ActiveObject():
+	///             exampleActiveMethod(this, &ActiveObject::exampleActiveMethodImpl)
+	///         {
+	///         }
+	///
+	///         ActiveMethod<std::string, std::string, ActiveObject> exampleActiveMethod;
+	///
+	///     protected:
+	///         std::string exampleActiveMethodImpl(const std::string& arg)
+	///         {
+	///             ...
+	///         }
+	///     };
+	///
+	/// And following is an example that shows how to invoke an ActiveMethod.
+	///
+	///     ActiveObject myActiveObject;
+	///     ActiveResult<std::string> result = myActiveObject.exampleActiveMethod("foo");
+	///     ...
+	///     result.wait();
+	///     std::cout << result.data() << std::endl;
+	///
+	/// The way an ActiveMethod is started can be changed by passing a StarterType
+	/// template argument with a corresponding class. The default ActiveStarter
+	/// starts the method in its own thread, obtained from a thread pool.
+	///
+	/// For an alternative implementation of StarterType, see ActiveDispatcher.
+	///
+	/// For methods that do not require an argument or a return value, simply use void.
+{
+public:
+	typedef ResultType (OwnerType::*Callback)(void);
+	typedef ActiveResult<ResultType> ActiveResultType;
+	typedef ActiveRunnable<ResultType, void, OwnerType> ActiveRunnableType;
+
+	ActiveMethod(OwnerType* pOwner, Callback method):
+		_pOwner(pOwner),
+		_method(method)
+		/// Creates an ActiveMethod object.
+	{
+		poco_check_ptr (pOwner);
+	}
+	
+	ActiveResultType operator () (void)
+		/// Invokes the ActiveMethod.
+	{
+		ActiveResultType result(new ActiveResultHolder<ResultType>());
+		ActiveRunnableBase::Ptr pRunnable(new ActiveRunnableType(_pOwner, _method, result));
+		StarterType::start(_pOwner, pRunnable);
+		return result;
+	}
+		
+	ActiveMethod(const ActiveMethod& other):
+		_pOwner(other._pOwner),
+		_method(other._method)
+	{
+	}
+
+	ActiveMethod& operator = (const ActiveMethod& other)
+	{
+		ActiveMethod tmp(other);
+		swap(tmp);
+		return *this;
+	}
+
+	void swap(ActiveMethod& other)
+	{
+		std::swap(_pOwner, other._pOwner);
+		std::swap(_method, other._method);
+	}
+
+private:
+	ActiveMethod();
+
+	OwnerType* _pOwner;
+	Callback   _method;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ActiveMethod_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ActiveResult.h b/base/poco/Foundation/include/Poco/ActiveResult.h
new file mode 100644
index 00000000000..4cdc0ed0bf5
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ActiveResult.h
@@ -0,0 +1,495 @@
+//
+// ActiveResult.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  ActiveObjects
+//
+// Definition of the ActiveResult class.
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ActiveResult_INCLUDED
+#define Foundation_ActiveResult_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Mutex.h"
+#include "Poco/Event.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/Exception.h"
+#include <algorithm>
+
+
+namespace Poco {
+
+
+template <class ResultType>
+class ActiveResultHolder: public RefCountedObject
+	/// This class holds the result of an asynchronous method
+	/// invocation. It is used to pass the result from the
+	/// execution thread back to the invocation thread. 
+	/// The class uses reference counting for memory management.
+	/// Do not use this class directly, use ActiveResult instead.
+{
+public:
+	ActiveResultHolder():
+		_pData(0),
+		_pExc(0),
+		_event(false)
+		/// Creates an ActiveResultHolder.
+	{
+	}
+		
+	ResultType& data()
+		/// Returns a reference to the actual result.
+	{
+		poco_check_ptr(_pData);
+		return *_pData;
+	}
+	
+	void data(ResultType* pData)
+	{
+		delete _pData;
+		_pData = pData;
+	}
+	
+	void wait()
+		/// Pauses the caller until the result becomes available.
+	{
+		_event.wait();
+	}
+	
+	bool tryWait(long milliseconds)
+		/// Waits up to the specified interval for the result to
+		/// become available. Returns true if the result became
+		/// available, false otherwise.
+	{
+		return _event.tryWait(milliseconds);
+	}
+	
+	void wait(long milliseconds)
+		/// Waits up to the specified interval for the result to
+		/// become available. Throws a TimeoutException if the
+		/// result did not became available.
+	{
+		_event.wait(milliseconds);
+	}
+	
+	void notify()
+		/// Notifies the invoking thread that the result became available.
+	{
+		_event.set();
+	}
+	
+	bool failed() const
+		/// Returns true if the active method failed (and threw an exception).
+		/// Information about the exception can be obtained by calling error().
+	{
+		return _pExc != 0;
+	}
+	
+	std::string error() const
+		/// If the active method threw an exception, a textual representation
+		/// of the exception is returned. An empty string is returned if the
+		/// active method completed successfully.
+	{
+		if (_pExc)
+			return _pExc->message();
+		else
+			return std::string();
+	}
+	
+	Exception* exception() const
+		/// If the active method threw an exception, a clone of the exception
+		/// object is returned, otherwise null.
+	{
+		return _pExc;
+	}
+	
+	void error(const Exception& exc)
+		/// Sets the exception.
+	{
+		delete _pExc;
+		_pExc = exc.clone();
+	}
+	
+	void error(const std::string& msg)
+		/// Sets the exception.
+	{
+		delete _pExc;
+		_pExc = new UnhandledException(msg);
+	}
+
+protected:
+	~ActiveResultHolder()
+	{
+		delete _pData;
+		delete _pExc;
+	}
+
+private:
+	ResultType* _pData;
+	Exception*  _pExc;
+	Event       _event;
+};
+
+
+
+template <>
+class ActiveResultHolder<void>: public RefCountedObject
+{
+public:
+	ActiveResultHolder():
+		_pExc(0),
+		_event(false)
+		/// Creates an ActiveResultHolder.
+	{
+	}
+	
+	void wait()
+		/// Pauses the caller until the result becomes available.
+	{
+		_event.wait();
+	}
+	
+	bool tryWait(long milliseconds)
+		/// Waits up to the specified interval for the result to
+		/// become available. Returns true if the result became
+		/// available, false otherwise.
+	{
+		return _event.tryWait(milliseconds);
+	}
+	
+	void wait(long milliseconds)
+		/// Waits up to the specified interval for the result to
+		/// become available. Throws a TimeoutException if the
+		/// result did not became available.
+	{
+		_event.wait(milliseconds);
+	}
+	
+	void notify()
+		/// Notifies the invoking thread that the result became available.
+	{
+		_event.set();
+	}
+	
+	bool failed() const
+		/// Returns true if the active method failed (and threw an exception).
+		/// Information about the exception can be obtained by calling error().
+	{
+		return _pExc != 0;
+	}
+	
+	std::string error() const
+		/// If the active method threw an exception, a textual representation
+		/// of the exception is returned. An empty string is returned if the
+		/// active method completed successfully.
+	{
+		if (_pExc)
+			return _pExc->message();
+		else
+			return std::string();
+	}
+	
+	Exception* exception() const
+		/// If the active method threw an exception, a clone of the exception
+		/// object is returned, otherwise null.
+	{
+		return _pExc;
+	}
+	
+	void error(const Exception& exc)
+		/// Sets the exception.
+	{
+		delete _pExc;
+		_pExc = exc.clone();
+	}
+	
+	void error(const std::string& msg)
+		/// Sets the exception.
+	{
+		delete _pExc;
+		_pExc = new UnhandledException(msg);
+	}
+
+protected:
+	~ActiveResultHolder()
+	{
+		delete _pExc;
+	}
+
+private:
+	Exception*  _pExc;
+	Event       _event;
+};
+
+
+template <class RT>
+class ActiveResult
+	/// This class holds the result of an asynchronous method
+	/// invocation (see class ActiveMethod). It is used to pass the 
+	/// result from the execution thread back to the invocation thread. 
+{
+public:
+	typedef RT ResultType;
+	typedef ActiveResultHolder<ResultType> ActiveResultHolderType;
+
+	ActiveResult(ActiveResultHolderType* pHolder):
+		_pHolder(pHolder)
+		/// Creates the active result. For internal use only.
+	{
+		poco_check_ptr (pHolder);
+	}
+	
+	ActiveResult(const ActiveResult& result)
+		/// Copy constructor.
+	{
+		_pHolder = result._pHolder;
+		_pHolder->duplicate();
+	}
+	
+	~ActiveResult()
+		/// Destroys the result.
+	{
+		_pHolder->release();
+	}
+	
+	ActiveResult& operator = (const ActiveResult& result)
+		/// Assignment operator.
+	{
+		ActiveResult tmp(result);
+		swap(tmp);
+		return *this;
+	}
+	
+	void swap(ActiveResult& result)
+	{
+		using std::swap;
+		swap(_pHolder, result._pHolder);
+	}
+	
+	ResultType& data() const
+		/// Returns a reference to the result data.
+	{
+		return _pHolder->data();
+	}
+	
+	void data(ResultType* pValue)
+	{
+		_pHolder->data(pValue);
+	}
+	
+	void wait()
+		/// Pauses the caller until the result becomes available.
+	{
+		_pHolder->wait();
+	}
+	
+	bool tryWait(long milliseconds)
+		/// Waits up to the specified interval for the result to
+		/// become available. Returns true if the result became
+		/// available, false otherwise.
+	{
+		return _pHolder->tryWait(milliseconds);
+	}
+	
+	void wait(long milliseconds)
+		/// Waits up to the specified interval for the result to
+		/// become available. Throws a TimeoutException if the
+		/// result did not became available.
+	{
+		_pHolder->wait(milliseconds);
+	}
+	
+	bool available() const
+		/// Returns true if a result is available.
+	{
+		return _pHolder->tryWait(0);
+	}
+	
+	bool failed() const
+		/// Returns true if the active method failed (and threw an exception).
+		/// Information about the exception can be obtained by calling error().
+	{
+		return _pHolder->failed();
+	}
+	
+	std::string error() const
+		/// If the active method threw an exception, a textual representation
+		/// of the exception is returned. An empty string is returned if the
+		/// active method completed successfully.
+	{
+		return _pHolder->error();
+	}
+
+	Exception* exception() const
+		/// If the active method threw an exception, a clone of the exception
+		/// object is returned, otherwise null.
+	{
+		return _pHolder->exception();
+	}
+
+	void notify()
+		/// Notifies the invoking thread that the result became available.
+		/// For internal use only.
+	{
+		_pHolder->notify();
+	}
+	
+	ResultType& data()
+		/// Returns a non-const reference to the result data. For internal
+		/// use only.
+	{
+		return _pHolder->data();
+	}
+	
+	void error(const std::string& msg)
+		/// Sets the failed flag and the exception message.
+	{
+		_pHolder->error(msg);
+	}
+
+	void error(const Exception& exc)
+		/// Sets the failed flag and the exception message.
+	{
+		_pHolder->error(exc);
+	}
+	
+private:
+	ActiveResult();
+
+	ActiveResultHolderType* _pHolder;
+};
+
+
+
+template <>
+class ActiveResult<void>
+	/// This class holds the result of an asynchronous method
+	/// invocation (see class ActiveMethod). It is used to pass the 
+	/// result from the execution thread back to the invocation thread. 
+{
+public:
+	typedef ActiveResultHolder<void> ActiveResultHolderType;
+
+	ActiveResult(ActiveResultHolderType* pHolder):
+		_pHolder(pHolder)
+		/// Creates the active result. For internal use only.
+	{
+		poco_check_ptr (pHolder);
+	}
+	
+	ActiveResult(const ActiveResult& result)
+		/// Copy constructor.
+	{
+		_pHolder = result._pHolder;
+		_pHolder->duplicate();
+	}
+	
+	~ActiveResult()
+		/// Destroys the result.
+	{
+		_pHolder->release();
+	}
+	
+	ActiveResult& operator = (const ActiveResult& result)
+		/// Assignment operator.
+	{
+		ActiveResult tmp(result);
+		swap(tmp);
+		return *this;
+	}
+	
+	void swap(ActiveResult& result)
+	{
+		using std::swap;
+		swap(_pHolder, result._pHolder);
+	}
+	
+	void wait()
+		/// Pauses the caller until the result becomes available.
+	{
+		_pHolder->wait();
+	}
+	
+	bool tryWait(long milliseconds)
+		/// Waits up to the specified interval for the result to
+		/// become available. Returns true if the result became
+		/// available, false otherwise.
+	{
+		return _pHolder->tryWait(milliseconds);
+	}
+	
+	void wait(long milliseconds)
+		/// Waits up to the specified interval for the result to
+		/// become available. Throws a TimeoutException if the
+		/// result did not became available.
+	{
+		_pHolder->wait(milliseconds);
+	}
+	
+	bool available() const
+		/// Returns true if a result is available.
+	{
+		return _pHolder->tryWait(0);
+	}
+	
+	bool failed() const
+		/// Returns true if the active method failed (and threw an exception).
+		/// Information about the exception can be obtained by calling error().
+	{
+		return _pHolder->failed();
+	}
+	
+	std::string error() const
+		/// If the active method threw an exception, a textual representation
+		/// of the exception is returned. An empty string is returned if the
+		/// active method completed successfully.
+	{
+		return _pHolder->error();
+	}
+
+	Exception* exception() const
+		/// If the active method threw an exception, a clone of the exception
+		/// object is returned, otherwise null.
+	{
+		return _pHolder->exception();
+	}
+
+	void notify()
+		/// Notifies the invoking thread that the result became available.
+		/// For internal use only.
+	{
+		_pHolder->notify();
+	}
+	
+	void error(const std::string& msg)
+		/// Sets the failed flag and the exception message.
+	{
+		_pHolder->error(msg);
+	}
+
+	void error(const Exception& exc)
+		/// Sets the failed flag and the exception message.
+	{
+		_pHolder->error(exc);
+	}
+	
+private:
+	ActiveResult();
+
+	ActiveResultHolderType* _pHolder;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ActiveResult_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ActiveRunnable.h b/base/poco/Foundation/include/Poco/ActiveRunnable.h
new file mode 100644
index 00000000000..95317b0b3ff
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ActiveRunnable.h
@@ -0,0 +1,231 @@
+//
+// ActiveRunnable.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  ActiveObjects
+//
+// Definition of the ActiveRunnable class.
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ActiveRunnable_INCLUDED
+#define Foundation_ActiveRunnable_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/ActiveResult.h"
+#include "Poco/Runnable.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+
+class ActiveRunnableBase: public Runnable, public RefCountedObject
+	/// The base class for all ActiveRunnable instantiations.
+{
+public:
+	typedef AutoPtr<ActiveRunnableBase> Ptr;
+};
+
+
+template <class ResultType, class ArgType, class OwnerType>
+class ActiveRunnable: public ActiveRunnableBase
+	/// This class is used by ActiveMethod.
+	/// See the ActiveMethod class for more information.
+{
+public:
+	typedef ResultType (OwnerType::*Callback)(const ArgType&);
+	typedef ActiveResult<ResultType> ActiveResultType;
+
+	ActiveRunnable(OwnerType* pOwner, Callback method, const ArgType& arg, const ActiveResultType& result):
+		_pOwner(pOwner),
+		_method(method),
+		_arg(arg),
+		_result(result)
+	{
+		poco_check_ptr (pOwner);
+	}
+
+	void run()
+	{
+		ActiveRunnableBase::Ptr guard(this, false); // ensure automatic release when done
+		try
+		{
+			_result.data(new ResultType((_pOwner->*_method)(_arg)));
+		}
+		catch (Exception& e)
+		{
+			_result.error(e);
+		}
+		catch (std::exception& e)
+		{
+			_result.error(e.what());
+		}
+		catch (...)
+		{
+			_result.error("unknown exception");
+		}
+		_result.notify();
+	}
+
+private:
+	OwnerType* _pOwner;
+	Callback   _method;
+	ArgType    _arg;
+	ActiveResultType _result;
+};
+
+
+template <class ArgType, class OwnerType>
+class ActiveRunnable<void, ArgType, OwnerType>: public ActiveRunnableBase
+	/// This class is used by ActiveMethod.
+	/// See the ActiveMethod class for more information.
+{
+public:
+	typedef void (OwnerType::*Callback)(const ArgType&);
+	typedef ActiveResult<void> ActiveResultType;
+
+	ActiveRunnable(OwnerType* pOwner, Callback method, const ArgType& arg, const ActiveResultType& result):
+		_pOwner(pOwner),
+		_method(method),
+		_arg(arg),
+		_result(result)
+	{
+		poco_check_ptr (pOwner);
+	}
+
+	void run()
+	{
+		ActiveRunnableBase::Ptr guard(this, false); // ensure automatic release when done
+		try
+		{
+			(_pOwner->*_method)(_arg);
+		}
+		catch (Exception& e)
+		{
+			_result.error(e);
+		}
+		catch (std::exception& e)
+		{
+			_result.error(e.what());
+		}
+		catch (...)
+		{
+			_result.error("unknown exception");
+		}
+		_result.notify();
+	}
+
+private:
+	OwnerType* _pOwner;
+	Callback   _method;
+	ArgType    _arg;
+	ActiveResultType _result;
+};
+
+
+template <class ResultType, class OwnerType>
+class ActiveRunnable<ResultType, void, OwnerType>: public ActiveRunnableBase
+	/// This class is used by ActiveMethod.
+	/// See the ActiveMethod class for more information.
+{
+public:
+	typedef ResultType (OwnerType::*Callback)();
+	typedef ActiveResult<ResultType> ActiveResultType;
+
+	ActiveRunnable(OwnerType* pOwner, Callback method, const ActiveResultType& result):
+		_pOwner(pOwner),
+		_method(method),
+		_result(result)
+	{
+		poco_check_ptr (pOwner);
+	}
+
+	void run()
+	{
+		ActiveRunnableBase::Ptr guard(this, false); // ensure automatic release when done
+		try
+		{
+			_result.data(new ResultType((_pOwner->*_method)()));
+		}
+		catch (Exception& e)
+		{
+			_result.error(e);
+		}
+		catch (std::exception& e)
+		{
+			_result.error(e.what());
+		}
+		catch (...)
+		{
+			_result.error("unknown exception");
+		}
+		_result.notify();
+	}
+
+private:
+	OwnerType* _pOwner;
+	Callback   _method;
+	ActiveResultType _result;
+};
+
+
+template <class OwnerType>
+class ActiveRunnable<void, void, OwnerType>: public ActiveRunnableBase
+	/// This class is used by ActiveMethod.
+	/// See the ActiveMethod class for more information.
+{
+public:
+	typedef void (OwnerType::*Callback)();
+	typedef ActiveResult<void> ActiveResultType;
+
+	ActiveRunnable(OwnerType* pOwner, Callback method, const ActiveResultType& result):
+		_pOwner(pOwner),
+		_method(method),
+		_result(result)
+	{
+		poco_check_ptr (pOwner);
+	}
+
+	void run()
+	{
+		ActiveRunnableBase::Ptr guard(this, false); // ensure automatic release when done
+		try
+		{
+			(_pOwner->*_method)();
+		}
+		catch (Exception& e)
+		{
+			_result.error(e);
+		}
+		catch (std::exception& e)
+		{
+			_result.error(e.what());
+		}
+		catch (...)
+		{
+			_result.error("unknown exception");
+		}
+		_result.notify();
+	}
+
+private:
+	OwnerType* _pOwner;
+	Callback   _method;
+	ActiveResultType _result;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ActiveRunnable_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ActiveStarter.h b/base/poco/Foundation/include/Poco/ActiveStarter.h
new file mode 100644
index 00000000000..b79a31e8f87
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ActiveStarter.h
@@ -0,0 +1,48 @@
+//
+// ActiveStarter.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  ActiveObjects
+//
+// Definition of the ActiveStarter class.
+//
+// Copyright (c) 2006-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ActiveStarter_INCLUDED
+#define Foundation_ActiveStarter_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/ThreadPool.h"
+#include "Poco/ActiveRunnable.h"
+
+
+namespace Poco {
+
+
+template <class OwnerType>
+class ActiveStarter
+	/// The default implementation of the StarterType 
+	/// policy for ActiveMethod. It starts the method
+	/// in its own thread, obtained from the default
+	/// thread pool.
+{
+public:
+	static void start(OwnerType* /*pOwner*/, ActiveRunnableBase::Ptr pRunnable)
+	{
+		ThreadPool::defaultPool().start(*pRunnable);
+		pRunnable->duplicate(); // The runnable will release itself.
+	}
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ActiveStarter_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Activity.h b/base/poco/Foundation/include/Poco/Activity.h
new file mode 100644
index 00000000000..a7297f144f4
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Activity.h
@@ -0,0 +1,208 @@
+//
+// Activity.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  ActiveObjects
+//
+// Definition of the Activity template class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Activity_INCLUDED
+#define Foundation_Activity_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/RunnableAdapter.h"
+#include "Poco/ThreadPool.h"
+#include "Poco/Event.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+
+
+template <class C>
+class Activity: public Runnable
+	/// This template class helps to implement active objects.
+	/// An active object uses threads to decouple method
+	/// execution from method invocation, or to perform tasks
+	/// autonomously, without intervention of a caller.
+	///
+	/// An activity is a (typically longer running) method
+	/// that executes within its own task. Activities can
+	/// be started automatically (upon object construction)
+	/// or manually at a later time. Activities can also
+	/// be stopped at any time. However, to make stopping
+	/// an activity work, the method implementing the
+	/// activity has to check periodically whether it
+	/// has been requested to stop, and if so, return. 
+	/// Activities are stopped before the object they belong to is
+	/// destroyed. Methods implementing activities cannot have arguments
+	/// or return values. 
+	///
+	/// Activity objects are used as follows:
+	///
+	///     class ActiveObject
+	///     {
+	///     public:
+	///         ActiveObject(): 
+	///             _activity(this, &ActiveObject::runActivity)
+	///         {
+	///             ...
+	///         }
+	///   
+	///         ...
+	///  
+	///     protected:
+	///         void runActivity()
+	///         {
+	///             while (!_activity.isStopped())
+	///             {
+	///                 ...
+	///             }
+	///         }
+	///
+	///     private:
+	///         Activity<ActiveObject> _activity;
+	///     };
+{
+public:
+	typedef RunnableAdapter<C> RunnableAdapterType;
+	typedef typename RunnableAdapterType::Callback Callback;
+
+	Activity(C* pOwner, Callback method):
+		_pOwner(pOwner),
+		_runnable(*pOwner, method),
+		_stopped(true),
+		_running(false),
+		_done(false)
+		/// Creates the activity. Call start() to
+		/// start it.
+	{
+		poco_check_ptr (pOwner);
+	}
+	
+	~Activity()
+		/// Stops and destroys the activity.
+	{
+		try
+		{
+			stop();
+			wait();
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	}
+	
+	void start()
+		/// Starts the activity by acquiring a
+		/// thread for it from the default thread pool.
+	{
+		start(ThreadPool::defaultPool());
+	}
+
+	void start(ThreadPool& pool)
+	{
+		FastMutex::ScopedLock lock(_mutex);
+		
+		if (!_running)
+		{
+			_done.reset();
+			_stopped = false;
+			_running = true;
+			try
+			{
+				pool.start(*this);
+			}
+			catch (...)
+			{
+				_running = false;
+				throw;
+			}
+		}
+	}
+	
+	void stop()
+		/// Requests to stop the activity.
+	{
+		FastMutex::ScopedLock lock(_mutex);
+
+		_stopped = true;
+	}
+	
+	void wait()
+		/// Waits for the activity to complete.
+	{
+		if (_running)
+		{
+			_done.wait();
+		}
+	}
+
+	void wait(long milliseconds)
+		/// Waits the given interval for the activity to complete.
+		/// An TimeoutException is thrown if the activity does not
+		/// complete within the given interval.
+	{
+		if (_running)
+		{
+			_done.wait(milliseconds);
+		}
+	}
+	
+	bool isStopped() const
+		/// Returns true if the activity has been requested to stop.
+	{
+		return _stopped;
+	}
+	
+	bool isRunning() const
+		/// Returns true if the activity is running.
+	{
+		return _running;
+	}
+
+protected:
+	void run()
+	{
+		try
+		{
+			_runnable.run();
+		}
+		catch (...)
+		{
+			_running = false;
+			_done.set();
+			throw;
+		}
+		_running = false;
+		_done.set();
+	}
+	
+private:
+	Activity();
+	Activity(const Activity&);
+	Activity& operator = (const Activity&);
+
+	C*                  _pOwner;
+	RunnableAdapterType _runnable;
+	volatile bool       _stopped;
+	volatile bool       _running;
+	Event               _done;
+	FastMutex           _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Activity_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Alignment.h b/base/poco/Foundation/include/Poco/Alignment.h
new file mode 100644
index 00000000000..d655a3d9f4f
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Alignment.h
@@ -0,0 +1,246 @@
+//
+// Alignment.h
+//
+// Library: Foundation
+// Package: Dynamic
+// Module:  Alignment
+//
+// Definition of the Alignment class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+// Adapted for POCO from LLVM Compiler Infrastructure code:
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source License
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the AlignOf function that computes alignments for
+// arbitrary types.
+//
+//===----------------------------------------------------------------------===//
+
+
+#ifndef Foundation_AlignOf_INCLUDED
+#define Foundation_AlignOf_INCLUDED
+
+
+#include <cstddef>
+
+
+#ifdef POCO_ENABLE_CPP11
+
+
+	#include <type_traits>
+	#define POCO_HAVE_ALIGNMENT
+
+
+#else
+
+
+	namespace Poco {
+
+
+	template <typename T>
+	struct AlignmentCalcImpl
+	{
+		char x;
+		T t;
+	private:
+		AlignmentCalcImpl() {} // Never instantiate.
+	};
+
+
+	template <typename T>
+	struct AlignOf
+		/// A templated class that contains an enum value representing
+		/// the alignment of the template argument.  For example,
+		/// AlignOf<int>::Alignment represents the alignment of type "int".  The
+		/// alignment calculated is the minimum alignment, and not necessarily
+		/// the "desired" alignment returned by GCC's __alignof__ (for example).  Note
+		/// that because the alignment is an enum value, it can be used as a
+		/// compile-time constant (e.g., for template instantiation).
+	{
+		enum
+		{
+			Alignment = static_cast<unsigned int>(sizeof(AlignmentCalcImpl<T>) - sizeof(T))
+		};
+
+		enum { Alignment_GreaterEqual_2Bytes  = Alignment >= 2  ? 1 : 0 };
+		enum { Alignment_GreaterEqual_4Bytes  = Alignment >= 4  ? 1 : 0 };
+		enum { Alignment_GreaterEqual_8Bytes  = Alignment >= 8  ? 1 : 0 };
+		enum { Alignment_GreaterEqual_16Bytes = Alignment >= 16 ? 1 : 0 };
+	
+		enum { Alignment_LessEqual_2Bytes  = Alignment <= 2  ? 1 : 0 };
+		enum { Alignment_LessEqual_4Bytes  = Alignment <= 4  ? 1 : 0 };
+		enum { Alignment_LessEqual_8Bytes  = Alignment <= 8  ? 1 : 0 };
+		enum { Alignment_LessEqual_16Bytes = Alignment <= 16 ? 1 : 0 };
+
+	};
+
+
+	template <typename T>
+	inline unsigned alignOf()
+		/// A templated function that returns the minimum alignment of
+		/// of a type.  This provides no extra functionality beyond the AlignOf
+		/// class besides some cosmetic cleanliness.  Example usage:
+		/// alignOf<int>() returns the alignment of an int.
+	{
+		return AlignOf<T>::Alignment;
+	}
+
+
+	template <std::size_t Alignment> struct AlignedCharArrayImpl;
+		/// Helper for building an aligned character array type.
+		///
+		/// This template is used to explicitly build up a collection of aligned
+		/// character types. We have to build these up using a macro and explicit
+		/// specialization to cope with old versions of MSVC and GCC where only an
+		/// integer literal can be used to specify an alignment constraint. Once built
+		/// up here, we can then begin to indirect between these using normal C++
+		/// template parameters.
+
+
+	// MSVC requires special handling here.
+	#ifndef _MSC_VER
+
+		#ifdef POCO_COMPILER_CLANG
+
+			#if __has_feature(cxx_alignas)
+				#define POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(x) \
+					template <> struct AlignedCharArrayImpl<x> \
+					{ \
+						char aligned alignas(x); \
+					}
+				#define POCO_HAVE_ALIGNMENT
+			#endif
+
+		#elif defined(__GNUC__) || defined(__IBM_ATTRIBUTES)
+
+			#define POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(x) \
+				template <> struct AlignedCharArrayImpl<x> \
+				{ \
+					char aligned __attribute__((aligned(x))); \
+				}
+				#define POCO_HAVE_ALIGNMENT
+
+		#endif
+	
+		#ifdef POCO_HAVE_ALIGNMENT
+			POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(1);
+			POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(2);
+			POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(4);
+			POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(8);
+			POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(16);
+			POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(32);
+			POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(64);
+			POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(128);
+			POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(512);
+			POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(1024);
+			POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(2048);
+			POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(4096);
+			POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(8192);
+
+			#undef POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT
+		#endif // POCO_HAVE_ALIGNMENT
+
+	#else // _MSC_VER
+
+		// We provide special variations of this template for the most common
+		// alignments because __declspec(align(...)) doesn't actually work when it is
+		// a member of a by-value function argument in MSVC, even if the alignment
+		// request is something reasonably like 8-byte or 16-byte.
+		template <> struct AlignedCharArrayImpl<1> { char aligned; };
+		template <> struct AlignedCharArrayImpl<2> { short aligned; };
+		template <> struct AlignedCharArrayImpl<4> { int aligned; };
+		template <> struct AlignedCharArrayImpl<8> { double aligned; };
+
+		#define POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(x) \
+			template <> struct AlignedCharArrayImpl<x> { \
+				__declspec(align(x)) char aligned; \
+			}
+
+		POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(16);
+		POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(32);
+		POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(64);
+		POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(128);
+		
+		#if (_MSC_VER > 1600)  // MSVC 2010 complains on alignment  larger than 128
+			POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(512);
+			POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(1024);
+			POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(2048);
+			POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(4096);
+			POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT(8192);
+		#endif  // _MSC_VER > 1600
+		
+		// Any larger and MSVC complains.
+		#undef POCO_ALIGNEDCHARARRAY_TEMPLATE_ALIGNMENT
+
+		#define POCO_HAVE_ALIGNMENT
+	#endif // _MSC_VER
+
+	// POCO_HAVE_ALIGNMENT will be defined on the pre-C++11 platforms/compilers where
+	// it can be reliably determined and used. Uncomment the line below to explicitly
+	// disable use of alignment even for those platforms. 
+	// #undef POCO_HAVE_ALIGNMENT
+
+
+	#ifdef POCO_HAVE_ALIGNMENT
+
+		template <typename T1, typename T2 = char, typename T3 = char, typename T4 = char>
+		union AlignedCharArrayUnion
+			/// This union template exposes a suitably aligned and sized character
+			/// array member which can hold elements of any of up to four types.
+			///
+			/// These types may be arrays, structs, or any other types. The goal is to
+			/// produce a union type containing a character array which, when used, forms
+			/// storage suitable to placement new any of these types over. Support for more
+			/// than four types can be added at the cost of more boiler plate.
+		{
+		private:
+			class AlignerImpl
+			{
+				T1 t1;
+				T2 t2;
+				T3 t3;
+				T4 t4;
+		
+				AlignerImpl(); // Never defined or instantiated.
+			};
+	
+			union SizerImpl
+			{
+				char arr1[sizeof(T1)];
+				char arr2[sizeof(T2)];
+				char arr3[sizeof(T3)];
+				char arr4[sizeof(T4)];
+			};
+	
+		public:
+			char buffer[sizeof(SizerImpl)];
+				/// The character array buffer for use by clients.
+				///
+				/// No other member of this union should be referenced. They exist purely to
+				/// constrain the layout of this character array.
+	
+		private:
+			Poco::AlignedCharArrayImpl<AlignOf<AlignerImpl>::Alignment> _nonceMember;
+
+		};
+
+	#endif // POCO_HAVE_ALIGNMENT
+
+	} // namespace Poco
+
+
+#endif // POCO_ENABLE_CPP11
+
+
+#endif // Foundation_AlignOf_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Any.h b/base/poco/Foundation/include/Poco/Any.h
new file mode 100644
index 00000000000..30f5b764177
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Any.h
@@ -0,0 +1,599 @@
+//
+// Any.h
+//
+// Library: Foundation
+// Package: Core
+// Module:	Any
+//
+// Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved.
+// Extracted from Boost 1.33.1 lib and adapted for poco: Peter Schojer/AppliedInformatics 2006-02-02
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Any_INCLUDED
+#define Foundation_Any_INCLUDED
+
+
+#include "Poco/Exception.h"
+#include "Poco/MetaProgramming.h"
+#include <algorithm>
+#include <typeinfo>
+#include <cstring>
+
+
+namespace Poco {
+
+
+class Any;
+
+
+namespace Dynamic {
+
+class Var;
+class VarHolder;
+template <class> class VarHolderImpl;
+
+}
+
+#ifndef POCO_NO_SOO
+
+#ifndef POCO_ENABLE_CPP11
+	// C++11 needed for std::aligned_storage
+	#error "Any SOO can only be enabled with C++11 support"
+#endif
+
+template <typename PlaceholderT, unsigned int SizeV = POCO_SMALL_OBJECT_SIZE>
+union Placeholder
+	/// ValueHolder union (used by Poco::Any and Poco::Dynamic::Var for small
+	/// object optimization, when enabled).
+	/// 
+	/// If Holder<Type> fits into POCO_SMALL_OBJECT_SIZE bytes of storage, 
+	/// it will be placement-new-allocated into the local buffer
+	/// (i.e. there will be no heap-allocation). The local buffer size is one byte
+	/// larger - [POCO_SMALL_OBJECT_SIZE + 1], additional byte value indicating
+	/// where the object was allocated (0 => heap, 1 => local).
+{
+public:
+	struct Size
+	{
+		static const unsigned int value = SizeV;
+	};
+
+	Placeholder ()
+	{
+		erase();
+	}
+
+	void erase()
+	{
+		std::memset(holder, 0, sizeof(Placeholder));
+	}
+
+	bool isLocal() const
+	{
+		return holder[SizeV] != 0;
+	}
+
+	void setLocal(bool local) const
+	{
+		holder[SizeV] = local ? 1 : 0;
+	}
+
+	PlaceholderT* content() const
+	{
+		if (isLocal())
+			return reinterpret_cast<PlaceholderT*>(holder);
+		else
+			return pHolder;
+	}
+
+// MSVC71,80 won't extend friendship to nested class (Any::Holder)
+#if !defined(POCO_MSVC_VERSION) || (defined(POCO_MSVC_VERSION) && (POCO_MSVC_VERSION > 80))
+private:
+#endif
+	typedef typename std::aligned_storage<SizeV + 1>::type AlignerType;
+	
+	PlaceholderT* pHolder;
+	mutable char  holder [SizeV + 1];
+	AlignerType   aligner;
+
+	friend class Any;
+	friend class Dynamic::Var;
+	friend class Dynamic::VarHolder;
+	template <class> friend class Dynamic::VarHolderImpl;
+};
+
+
+#else // !POCO_NO_SOO
+
+
+template <typename PlaceholderT>
+union Placeholder
+	/// ValueHolder union (used by Poco::Any and Poco::Dynamic::Var for small
+	/// object optimization, when enabled).
+	/// 
+	/// If Holder<Type> fits into POCO_SMALL_OBJECT_SIZE bytes of storage, 
+	/// it will be placement-new-allocated into the local buffer
+	/// (i.e. there will be no heap-allocation). The local buffer size is one byte
+	/// larger - [POCO_SMALL_OBJECT_SIZE + 1], additional byte value indicating
+	/// where the object was allocated (0 => heap, 1 => local).
+{
+public:
+
+	Placeholder ()
+	{
+	}
+
+	PlaceholderT* content() const
+	{
+		return pHolder;
+	}
+
+// MSVC71,80 won't extend friendship to nested class (Any::Holder)
+#if !defined(POCO_MSVC_VERSION) || (defined(POCO_MSVC_VERSION) && (POCO_MSVC_VERSION > 80))
+private:
+#endif
+	
+	PlaceholderT*         pHolder;
+
+	friend class Any;
+	friend class Dynamic::Var;
+	friend class Dynamic::VarHolder;
+	template <class> friend class Dynamic::VarHolderImpl;
+};
+
+
+#endif // POCO_NO_SOO
+
+
+class Any
+	/// An Any class represents a general type and is capable of storing any type, supporting type-safe extraction
+	/// of the internally stored data.
+	///
+	/// Code taken from the Boost 1.33.1 library. Original copyright by Kevlin Henney. Modified for Poco
+	/// by Applied Informatics.
+	///
+	/// Modified for small object optimization support (optionally supported through conditional compilation)
+	/// by Alex Fabijanic.
+{
+public:
+
+#ifndef POCO_NO_SOO
+
+	Any()
+		/// Creates an empty any type.
+	{
+	}
+
+	template<typename ValueType>
+	Any(const ValueType & value)
+		/// Creates an any which stores the init parameter inside.
+		///
+		/// Example: 
+		///   Any a(13); 
+		///   Any a(string("12345"));
+	{
+		construct(value);
+	}
+
+	Any(const Any& other)
+		/// Copy constructor, works with both empty and initialized Any values.
+	{
+		if ((this != &other) && !other.empty())
+			construct(other);
+	}
+
+	~Any()
+		/// Destructor. If Any is locally held, calls ValueHolder destructor;
+		/// otherwise, deletes the placeholder from the heap.
+	{
+		if (!empty())
+		{
+			if (_valueHolder.isLocal())
+				destruct();
+			else
+				delete content();
+		}
+	}
+
+	Any& swap(Any& other)
+		/// Swaps the content of the two Anys.
+		/// 
+		/// When small object optimizaton is enabled, swap only
+		/// has no-throw guarantee when both (*this and other)
+		/// objects are allocated on the heap.
+	{
+		if (this == &other) return *this;
+
+		if (!_valueHolder.isLocal() && !other._valueHolder.isLocal())
+		{
+			std::swap(_valueHolder.pHolder, other._valueHolder.pHolder);
+		}
+		else
+		{
+			Any tmp(*this);
+			try
+			{
+				if (_valueHolder.isLocal()) destruct();
+				construct(other);
+				other = tmp;
+			}
+			catch (...)
+			{
+				construct(tmp);
+				throw;
+			}
+		}
+
+		return *this;
+	}
+
+	template<typename ValueType>
+	Any& operator = (const ValueType& rhs)
+		/// Assignment operator for all types != Any.
+		///
+		/// Example: 
+		///   Any a = 13; 
+		///   Any a = string("12345");
+	{
+		construct(rhs);
+		return *this;
+	}
+	
+	Any& operator = (const Any& rhs)
+		/// Assignment operator for Any.
+	{
+		if ((this != &rhs) && !rhs.empty())
+			construct(rhs);
+		else if ((this != &rhs) && rhs.empty())
+			_valueHolder.erase();
+
+		return *this;
+	}
+	
+	bool empty() const
+		/// Returns true if the Any is empty.
+	{
+		char buf[POCO_SMALL_OBJECT_SIZE] = { 0 };
+		return 0 == std::memcmp(_valueHolder.holder, buf, POCO_SMALL_OBJECT_SIZE);
+	}
+	
+	const std::type_info & type() const
+		/// Returns the type information of the stored content.
+		/// If the Any is empty typeid(void) is returned.
+		/// It is recommended to always query an Any for its type info before
+		/// trying to extract data via an AnyCast/RefAnyCast.
+	{
+		return empty() ? typeid(void) : content()->type();
+	}
+
+private:
+
+	class ValueHolder
+	{
+	public:
+	
+		virtual ~ValueHolder()
+		{
+		}
+
+		virtual const std::type_info & type() const = 0;
+		virtual void clone(Placeholder<ValueHolder>*) const = 0;
+	};
+
+	template<typename ValueType>
+	class Holder : public ValueHolder
+	{
+	public:
+		Holder(const ValueType & value) : _held(value)
+		{
+		}
+
+		virtual const std::type_info & type() const
+		{
+			return typeid(ValueType);
+		}
+
+		virtual void clone(Placeholder<ValueHolder>* pPlaceholder) const
+		{
+			if ((sizeof(Holder<ValueType>) <= POCO_SMALL_OBJECT_SIZE))
+			{
+				new ((ValueHolder*) pPlaceholder->holder) Holder(_held);
+				pPlaceholder->setLocal(true);
+			}
+			else
+			{
+				pPlaceholder->pHolder = new Holder(_held);
+				pPlaceholder->setLocal(false);
+			}
+		}
+
+		ValueType _held;
+
+	private:
+		Holder & operator = (const Holder &);
+	};
+
+	ValueHolder* content() const
+	{
+		return _valueHolder.content();
+	}
+
+	template<typename ValueType>
+	void construct(const ValueType& value)
+	{
+		if (sizeof(Holder<ValueType>) <= Placeholder<ValueType>::Size::value)
+		{
+			new (reinterpret_cast<ValueHolder*>(_valueHolder.holder)) Holder<ValueType>(value);
+			_valueHolder.setLocal(true);
+		}
+		else
+		{
+			_valueHolder.pHolder = new Holder<ValueType>(value);
+			_valueHolder.setLocal(false);
+		}
+	}
+
+	void construct(const Any& other)
+	{
+		if (!other.empty())
+			other.content()->clone(&_valueHolder);
+		else
+			_valueHolder.erase();
+	}
+	
+	void destruct()
+	{
+		content()->~ValueHolder();
+	}
+
+	Placeholder<ValueHolder> _valueHolder;
+
+
+#else // if POCO_NO_SOO
+
+
+	Any(): _pHolder(0)
+		/// Creates an empty any type.
+	{
+	}
+
+	template <typename ValueType>
+	Any(const ValueType& value):
+		_pHolder(new Holder<ValueType>(value))
+		/// Creates an any which stores the init parameter inside.
+		///
+		/// Example: 
+		///	 Any a(13); 
+		///	 Any a(string("12345"));
+	{
+	}
+
+	Any(const Any& other):
+		_pHolder(other._pHolder ? other._pHolder->clone() : 0)
+		/// Copy constructor, works with both empty and initialized Any values.
+	{
+	}
+
+	~Any()
+	{
+		delete _pHolder;
+	}
+
+	Any& swap(Any& rhs)
+		/// Swaps the content of the two Anys.
+	{
+		std::swap(_pHolder, rhs._pHolder);
+		return *this;
+	}
+
+	template <typename ValueType>
+	Any& operator = (const ValueType& rhs)
+		/// Assignment operator for all types != Any.
+		///
+		/// Example: 
+		///   Any a = 13; 
+		///   Any a = string("12345");
+	{
+		Any(rhs).swap(*this);
+		return *this;
+	}
+
+	Any& operator = (const Any& rhs)
+		/// Assignment operator for Any.
+	{
+		Any(rhs).swap(*this);
+		return *this;
+	}
+
+	bool empty() const
+		/// Returns true if the Any is empty.
+	{
+		return !_pHolder;
+	}
+
+	const std::type_info& type() const
+		/// Returns the type information of the stored content.
+		/// If the Any is empty typeid(void) is returned.
+		/// It is recommended to always query an Any for its type info before
+		/// trying to extract data via an AnyCast/RefAnyCast.
+	{
+		return _pHolder ? _pHolder->type() : typeid(void);
+	}
+
+private:
+	class ValueHolder
+	{
+	public:
+		virtual ~ValueHolder()
+		{
+		}
+
+		virtual const std::type_info& type() const = 0;
+		virtual ValueHolder* clone() const = 0;
+	};
+
+	template <typename ValueType>
+	class Holder: public ValueHolder
+	{
+	public: 
+		Holder(const ValueType& value):
+			_held(value)
+		{
+		}
+
+		virtual const std::type_info& type() const
+		{
+			return typeid(ValueType);
+		}
+
+		virtual ValueHolder* clone() const
+		{
+			return new Holder(_held);
+		}
+
+		ValueType _held;
+
+	private:
+		Holder & operator=(const Holder &);
+	};
+
+	ValueHolder* content() const
+	{
+		return _pHolder;
+	}
+
+private:
+	ValueHolder* _pHolder;
+
+#endif // POCO_NO_SOO
+
+	template <typename ValueType>
+	friend ValueType* AnyCast(Any*);
+
+	template <typename ValueType>
+	friend ValueType* UnsafeAnyCast(Any*);
+
+};
+
+
+template <typename ValueType>
+ValueType* AnyCast(Any* operand)
+	/// AnyCast operator used to extract the ValueType from an Any*. Will return a pointer
+	/// to the stored value. 
+	///
+	/// Example Usage: 
+	///	 MyType* pTmp = AnyCast<MyType*>(pAny).
+	/// Will return NULL if the cast fails, i.e. types don't match.
+{
+	return operand && operand->type() == typeid(ValueType)
+				? &static_cast<Any::Holder<ValueType>*>(operand->content())->_held
+				: 0;
+}
+
+
+template <typename ValueType>
+const ValueType* AnyCast(const Any* operand)
+	/// AnyCast operator used to extract a const ValueType pointer from an const Any*. Will return a const pointer
+	/// to the stored value. 
+	///
+	/// Example Usage:
+	///	 const MyType* pTmp = AnyCast<MyType*>(pAny).
+	/// Will return NULL if the cast fails, i.e. types don't match.
+{
+	return AnyCast<ValueType>(const_cast<Any*>(operand));
+}
+
+
+template <typename ValueType>
+ValueType AnyCast(Any& operand)
+	/// AnyCast operator used to extract a copy of the ValueType from an Any&.
+	///
+	/// Example Usage: 
+	///	 MyType tmp = AnyCast<MyType>(anAny).
+	/// Will throw a BadCastException if the cast fails.
+	/// Dont use an AnyCast in combination with references, i.e. MyType& tmp = ... or const MyType& tmp = ...
+	/// Some compilers will accept this code although a copy is returned. Use the RefAnyCast in
+	/// these cases.
+{
+	typedef typename TypeWrapper<ValueType>::TYPE NonRef;
+
+	NonRef* result = AnyCast<NonRef>(&operand);
+	if (!result) throw BadCastException("Failed to convert between Any types");
+	return *result;
+}
+
+
+template <typename ValueType>
+ValueType AnyCast(const Any& operand)
+	/// AnyCast operator used to extract a copy of the ValueType from an const Any&.
+	///
+	/// Example Usage: 
+	///	 MyType tmp = AnyCast<MyType>(anAny).
+	/// Will throw a BadCastException if the cast fails.
+	/// Dont use an AnyCast in combination with references, i.e. MyType& tmp = ... or const MyType& = ...
+	/// Some compilers will accept this code although a copy is returned. Use the RefAnyCast in
+	/// these cases.
+{
+	typedef typename TypeWrapper<ValueType>::TYPE NonRef;
+
+	return AnyCast<NonRef&>(const_cast<Any&>(operand));
+}
+
+
+template <typename ValueType>
+const ValueType& RefAnyCast(const Any & operand)
+	/// AnyCast operator used to return a const reference to the internal data. 
+	///
+	/// Example Usage: 
+	///	 const MyType& tmp = RefAnyCast<MyType>(anAny);
+{
+	ValueType* result = AnyCast<ValueType>(const_cast<Any*>(&operand));
+	if (!result) throw BadCastException("RefAnyCast: Failed to convert between const Any types");
+	return *result;
+}
+
+
+template <typename ValueType>
+ValueType& RefAnyCast(Any& operand)
+	/// AnyCast operator used to return a reference to the internal data.
+	///
+	/// Example Usage: 
+	///	 MyType& tmp = RefAnyCast<MyType>(anAny);
+{
+	ValueType* result = AnyCast<ValueType>(&operand);
+	if (!result) throw BadCastException("RefAnyCast: Failed to convert between Any types");
+	return *result;
+}
+
+
+template <typename ValueType>
+ValueType* UnsafeAnyCast(Any* operand)
+	/// The "unsafe" versions of AnyCast are not part of the
+	/// public interface and may be removed at any time. They are
+	/// required where we know what type is stored in the any and can't
+	/// use typeid() comparison, e.g., when our types may travel across
+	/// different shared libraries.
+{
+	return &static_cast<Any::Holder<ValueType>*>(operand->content())->_held;
+}
+
+
+template <typename ValueType>
+const ValueType* UnsafeAnyCast(const Any* operand)
+	/// The "unsafe" versions of AnyCast are not part of the
+	/// public interface and may be removed at any time. They are
+	/// required where we know what type is stored in the any and can't
+	/// use typeid() comparison, e.g., when our types may travel across
+	/// different shared libraries.
+{
+	return AnyCast<ValueType>(const_cast<Any*>(operand));
+}
+
+
+} // namespace Poco
+
+
+#endif
diff --git a/base/poco/Foundation/include/Poco/ArchiveStrategy.h b/base/poco/Foundation/include/Poco/ArchiveStrategy.h
new file mode 100644
index 00000000000..a6bc3d35c9a
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ArchiveStrategy.h
@@ -0,0 +1,173 @@
+//
+// ArchiveStrategy.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  FileChannel
+//
+// Definition of the ArchiveStrategy class and subclasses.
+//
+// Copyright (c) 2004-2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ArchiveStrategy_INCLUDED
+#define Foundation_ArchiveStrategy_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/LogFile.h"
+#include "Poco/CompressedLogFile.h"
+#include "Poco/File.h"
+#include "Poco/DateTimeFormatter.h"
+#include "Poco/NumberFormatter.h"
+
+
+namespace Poco {
+
+
+class ArchiveCompressor;
+
+
+class Foundation_API ArchiveStrategy
+	/// The ArchiveStrategy is used by FileChannel
+	/// to rename a rotated log file for archiving.
+	///
+	/// Archived files can be automatically compressed,
+	/// using the gzip file format.
+{
+public:
+	ArchiveStrategy();
+	virtual ~ArchiveStrategy();
+
+	virtual LogFile* archive(LogFile* pFile, bool streamCompress = false) = 0;
+		/// Renames the given log file for archiving
+		/// and creates and returns a new log file.
+		/// The given LogFile object is deleted.
+		/// Returns CompressedLogFile if streamCompress flag is set.
+
+	void compress(bool flag = true);
+		/// Enables or disables compression of archived files.
+
+protected:
+	void moveFile(const std::string& oldName, const std::string& newName);
+	bool exists(const std::string& name);
+	
+private:
+	ArchiveStrategy(const ArchiveStrategy&);
+	ArchiveStrategy& operator = (const ArchiveStrategy&);
+	
+	bool _compress;
+	ArchiveCompressor* _pCompressor;
+};
+
+
+class Foundation_API ArchiveByNumberStrategy: public ArchiveStrategy
+	/// A monotonic increasing number is appended to the
+	/// log file name. The most recent archived file
+	/// always has the number zero.
+{
+public:
+	ArchiveByNumberStrategy();
+	~ArchiveByNumberStrategy();
+	LogFile* archive(LogFile* pFile, bool streamCompress = false);
+};
+
+
+template <class DT>
+class ArchiveByTimestampStrategy: public ArchiveStrategy
+	/// A timestamp (YYYYMMDDhhmmssiii) is appended to archived
+	/// log files.
+{
+public:
+	ArchiveByTimestampStrategy()
+	{
+	}
+	
+	~ArchiveByTimestampStrategy()
+	{
+	}
+	
+	LogFile* archive(LogFile* pFile, bool streamCompress = false)
+		/// Archives the file by appending the current timestamp to the
+		/// file name. If the new file name exists, additionally a monotonic
+		/// increasing number is appended to the log file name.
+	{
+		std::string base = pFile->path();
+		std::string ext = "";
+
+		if (base.ends_with(".lz4"))
+		{
+			base.resize(base.size() - 4);
+			ext = ".lz4";
+		}
+
+		delete pFile;
+		std::string archPath = base;
+		archPath.append(".");
+		DateTimeFormatter::append(archPath, DT().timestamp(), "%Y%m%d%H%M%S%i");
+		archPath.append(ext);
+		
+		if (exists(archPath)) archiveByNumber(archPath);
+		else moveFile(base + ext, archPath);
+
+		if (streamCompress)
+			return new CompressedLogFile(base);
+		else
+			return new LogFile(base);
+	}
+
+private:
+	void archiveByNumber(const std::string& basePath)
+		/// A monotonic increasing number is appended to the
+		/// log file name. The most recent archived file
+		/// always has the number zero.
+	{
+		std::string base = basePath;
+		std::string ext = "";
+
+		if (base.ends_with(".lz4"))
+		{
+			base.resize(base.size() - 4);
+			ext = ".lz4";
+		}
+		
+		int n = -1;
+		std::string path;
+		do
+		{
+			path = base;
+			path.append(".");
+			NumberFormatter::append(path, ++n);
+			path.append(ext);
+		}
+		while (exists(path));
+		
+		while (n >= 0)
+		{
+			std::string oldPath = base;
+			if (n > 0)
+			{
+				oldPath.append(".");
+				NumberFormatter::append(oldPath, n - 1);
+			}
+			oldPath.append(ext);
+
+			std::string newPath = base;
+			newPath.append(".");
+			NumberFormatter::append(newPath, n);
+			newPath.append(ext);
+			moveFile(oldPath, newPath);
+			--n;
+		}
+	}
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ArchiveStrategy_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Array.h b/base/poco/Foundation/include/Poco/Array.h
new file mode 100644
index 00000000000..76e5faed891
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Array.h
@@ -0,0 +1,249 @@
+//
+// Array.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Array
+//
+// Definition of the Array class
+//
+// Copyright (c) 2004-2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+// ------------------------------------------------------------------------------
+// (C) Copyright Nicolai M. Josuttis 2001.
+// Permission to copy, use, modify, sell and distribute this software
+// is granted provided this copyright notice appears in all copies.
+// This software is provided "as is" without express or implied
+// warranty, and with no claim as to its suitability for any purpose.
+// ------------------------------------------------------------------------------
+
+
+#ifndef Foundation_Array_INCLUDED
+#define Foundation_Array_INCLUDED
+
+#include "Poco/Exception.h"
+#include "Poco/Bugcheck.h"
+#include <algorithm>
+
+namespace Poco {
+
+template<class T, std::size_t N>
+class Array 
+	/// STL container like C-style array replacement class. 
+	/// 
+	/// This implementation is based on the idea of Nicolai Josuttis.
+	/// His original implementation can be found at http://www.josuttis.com/cppcode/array.html . 
+{
+
+public:
+
+	typedef T				value_type;
+	typedef T*				iterator;
+	typedef const T*		const_iterator;
+	typedef T&				reference;
+	typedef const T&		const_reference;
+	typedef std::size_t		size_type;
+	typedef std::ptrdiff_t  difference_type;
+
+	iterator begin()
+	{
+		return elems;
+	}
+
+	const_iterator begin() const
+	{
+		return elems;
+	}
+
+	iterator end()
+	{ 
+		return elems+N;
+	}
+
+	const_iterator end() const
+	{
+		return elems+N;
+	}
+
+	typedef std::reverse_iterator<iterator>			reverse_iterator;
+	typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;
+
+	reverse_iterator rbegin()
+	{
+		return reverse_iterator(end());
+	}
+
+	const_reverse_iterator rbegin() const
+	{
+		return const_reverse_iterator(end());
+	}
+
+	reverse_iterator rend()
+	{ 
+		return reverse_iterator(begin());
+	}
+
+	const_reverse_iterator rend() const
+	{
+		return const_reverse_iterator(begin());
+	}
+
+	reference operator[](size_type i) 
+		/// Element access without range check. If the index is not small than the given size, the behavior is undefined.
+	{ 
+		poco_assert( i < N && "out of range" ); 
+		return elems[i];
+	}
+
+	const_reference operator[](size_type i) const 
+		/// Element access without range check. If the index is not small than the given size, the behavior is undefined.
+	{	 
+		poco_assert( i < N && "out of range" ); 
+		return elems[i]; 
+	}
+
+	reference at(size_type i)
+		/// Element access with range check. Throws Poco::InvalidArgumentException if the index is over range.
+	{ 
+		if(i>=size())
+			throw Poco::InvalidArgumentException("Array::at() range check failed: index is over range");
+		return elems[i]; 
+	}
+
+	const_reference at(size_type i) const
+		/// Element access with range check. Throws Poco::InvalidArgumentException if the index is over range.
+	{
+		if(i>=size())
+			throw Poco::InvalidArgumentException("Array::at() range check failed: index is over range");
+		return elems[i]; 
+	}
+
+	reference front() 
+	{ 
+		return elems[0]; 
+	}
+
+	const_reference front() const 
+	{
+		return elems[0];
+	}
+
+	reference back() 
+	{ 
+		return elems[N-1]; 
+	}
+
+	const_reference back() const 
+	{ 
+		return elems[N-1]; 
+	}
+
+	static size_type size()
+	{
+		return N; 
+	}
+
+	static bool empty()
+	{ 
+		return false; 
+	}
+
+	static size_type max_size()
+	{ 
+		return N; 
+	}
+
+	enum { static_size = N };
+
+	void swap (Array<T,N>& y) {
+		std::swap_ranges(begin(),end(),y.begin());
+	}
+
+	const T* data() const
+		/// Direct access to data (read-only)
+	{ 
+		return elems; 
+	}
+
+	T* data()
+	{ 
+		return elems;
+	}
+
+	T* c_array(){ 
+		/// Use array as C array (direct read/write access to data)
+		return elems;
+	}
+
+	template <typename Other>
+	Array<T,N>& operator= (const Array<Other,N>& rhs)
+		/// Assignment with type conversion 
+	{
+		std::copy(rhs.begin(),rhs.end(), begin());
+		return *this;
+	}
+
+	void assign (const T& value)
+		/// Assign one value to all elements
+	{
+		std::fill_n(begin(),size(),value);
+	}
+
+public:
+
+	T elems[N];	
+		/// Fixed-size array of elements of type T, public specifier used to make this class a aggregate.
+
+};
+
+// comparisons
+template<class T, std::size_t N>
+bool operator== (const Array<T,N>& x, const Array<T,N>& y) 
+{
+	return std::equal(x.begin(), x.end(), y.begin());
+}
+
+template<class T, std::size_t N>
+bool operator< (const Array<T,N>& x, const Array<T,N>& y) 
+{
+	return std::lexicographical_compare(x.begin(),x.end(),y.begin(),y.end());
+}
+
+template<class T, std::size_t N>
+bool operator!= (const Array<T,N>& x, const Array<T,N>& y) 
+{
+	return !(x==y);
+}
+
+template<class T, std::size_t N>
+bool operator> (const Array<T,N>& x, const Array<T,N>& y) 
+{
+	return y<x;
+}
+
+template<class T, std::size_t N>
+bool operator<= (const Array<T,N>& x, const Array<T,N>& y) 
+{
+	return !(y<x);
+}
+
+template<class T, std::size_t N>
+bool operator>= (const Array<T,N>& x, const Array<T,N>& y) 
+{
+	return !(x<y);
+}
+
+template<class T, std::size_t N>
+inline void swap (Array<T,N>& x, Array<T,N>& y) 
+	/// global swap()
+{
+	x.swap(y);
+}
+
+}// namespace Poco
+
+#endif // Foundation_Array_INCLUDED
+
diff --git a/base/poco/Foundation/include/Poco/Ascii.h b/base/poco/Foundation/include/Poco/Ascii.h
new file mode 100644
index 00000000000..5dd741df35c
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Ascii.h
@@ -0,0 +1,220 @@
+//
+// Ascii.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Ascii
+//
+// Definition of the Ascii class.
+//
+// Copyright (c) 2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Ascii_INCLUDED
+#define Foundation_Ascii_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Ascii
+	/// This class contains enumerations and static
+	/// utility functions for dealing with ASCII characters
+	/// and their properties.
+	///
+	/// The classification functions will also work if
+	/// non-ASCII character codes are passed to them,
+	/// but classification will only check for
+	/// ASCII characters.
+	///
+	/// This allows the classification methods to be used
+	/// on the single bytes of a UTF-8 string, without
+	/// causing assertions or inconsistent results (depending
+	/// upon the current locale) on bytes outside the ASCII range,
+	/// as may be produced by Ascii::isSpace(), etc.
+{
+public:
+	enum CharacterProperties
+		/// ASCII character properties.
+	{
+		ACP_CONTROL  = 0x0001,
+		ACP_SPACE    = 0x0002,
+		ACP_PUNCT    = 0x0004,
+		ACP_DIGIT    = 0x0008,
+		ACP_HEXDIGIT = 0x0010,
+		ACP_ALPHA    = 0x0020,
+		ACP_LOWER    = 0x0040,
+		ACP_UPPER    = 0x0080,
+		ACP_GRAPH    = 0x0100,
+		ACP_PRINT    = 0x0200
+	};
+	
+	static int properties(int ch);
+		/// Return the ASCII character properties for the
+		/// character with the given ASCII value.
+		///
+		/// If the character is outside the ASCII range
+		/// (0 .. 127), 0 is returned.
+
+	static bool hasSomeProperties(int ch, int properties);
+		/// Returns true if the given character is
+		/// within the ASCII range and has at least one of 
+		/// the given properties.
+
+	static bool hasProperties(int ch, int properties);
+		/// Returns true if the given character is
+		/// within the ASCII range and has all of 
+		/// the given properties.
+
+	static bool isAscii(int ch);
+		/// Returns true iff the given character code is within
+		/// the ASCII range (0 .. 127).
+		
+	static bool isSpace(int ch);
+		/// Returns true iff the given character is a whitespace.
+		
+	static bool isDigit(int ch);
+		/// Returns true iff the given character is a digit.
+
+	static bool isHexDigit(int ch);
+		/// Returns true iff the given character is a hexadecimal digit.
+		
+	static bool isPunct(int ch);
+		/// Returns true iff the given character is a punctuation character.
+		
+	static bool isAlpha(int ch);
+		/// Returns true iff the given character is an alphabetic character.	
+
+	static bool isAlphaNumeric(int ch);
+		/// Returns true iff the given character is an alphabetic character.	
+		
+	static bool isLower(int ch);
+		/// Returns true iff the given character is a lowercase alphabetic
+		/// character.
+		
+	static bool isUpper(int ch);
+		/// Returns true iff the given character is an uppercase alphabetic
+		/// character.
+		
+	static int toLower(int ch);
+		/// If the given character is an uppercase character,
+		/// return its lowercase counterpart, otherwise return
+		/// the character.
+
+	static int toUpper(int ch);
+		/// If the given character is a lowercase character,
+		/// return its uppercase counterpart, otherwise return
+		/// the character.
+		
+private:
+	static const int CHARACTER_PROPERTIES[128];
+};
+
+
+//
+// inlines
+//
+inline int Ascii::properties(int ch)
+{
+	if (isAscii(ch)) 
+		return CHARACTER_PROPERTIES[ch];
+	else
+		return 0;
+}
+
+
+inline bool Ascii::isAscii(int ch)
+{
+	return (static_cast<UInt32>(ch) & 0xFFFFFF80) == 0;
+}
+
+
+inline bool Ascii::hasProperties(int ch, int props)
+{
+	return (properties(ch) & props) == props;
+}
+
+
+inline bool Ascii::hasSomeProperties(int ch, int props)
+{
+	return (properties(ch) & props) != 0;
+}
+
+
+inline bool Ascii::isSpace(int ch)
+{
+	return hasProperties(ch, ACP_SPACE);
+}
+
+
+inline bool Ascii::isDigit(int ch)
+{
+	return hasProperties(ch, ACP_DIGIT);
+}
+
+
+inline bool Ascii::isHexDigit(int ch)
+{
+	return hasProperties(ch, ACP_HEXDIGIT);
+}
+
+
+inline bool Ascii::isPunct(int ch)
+{
+	return hasProperties(ch, ACP_PUNCT);
+}
+
+
+inline bool Ascii::isAlpha(int ch)
+{
+	return hasProperties(ch, ACP_ALPHA);
+}
+
+
+inline bool Ascii::isAlphaNumeric(int ch)
+{
+	return hasSomeProperties(ch, ACP_ALPHA | ACP_DIGIT);
+}
+
+
+inline bool Ascii::isLower(int ch)
+{
+	return hasProperties(ch, ACP_LOWER);
+}
+
+
+inline bool Ascii::isUpper(int ch)
+{
+	return hasProperties(ch, ACP_UPPER);
+}
+
+
+inline int Ascii::toLower(int ch)
+{
+	if (isUpper(ch))
+		return ch + 32;
+	else
+		return ch;
+}
+
+
+inline int Ascii::toUpper(int ch)
+{
+	if (isLower(ch))
+		return ch - 32;
+	else
+		return ch;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Ascii_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/AsyncChannel.h b/base/poco/Foundation/include/Poco/AsyncChannel.h
new file mode 100644
index 00000000000..9756edc3ebb
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/AsyncChannel.h
@@ -0,0 +1,100 @@
+//
+// AsyncChannel.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  AsyncChannel
+//
+// Definition of the AsyncChannel class.
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_AsyncChannel_INCLUDED
+#define Foundation_AsyncChannel_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Channel.h"
+#include "Poco/Thread.h"
+#include "Poco/Mutex.h"
+#include "Poco/Runnable.h"
+#include "Poco/NotificationQueue.h"
+
+
+namespace Poco {
+
+
+class Foundation_API AsyncChannel: public Channel, public Runnable
+	/// A channel uses a separate thread for logging.
+	///
+	/// Using this channel can help to improve the performance of
+	/// applications that produce huge amounts of log messages or
+	/// that write log messages to multiple channels simultaneously.
+	///
+	/// All log messages are put into a queue and this queue is
+	/// then processed by a separate thread.
+{
+public:
+	AsyncChannel(Channel* pChannel = 0, Thread::Priority prio = Thread::PRIO_NORMAL);
+		/// Creates the AsyncChannel and connects it to
+		/// the given channel.
+
+	void setChannel(Channel* pChannel);
+		/// Connects the AsyncChannel to the given target channel.
+		/// All messages will be forwarded to this channel.
+		
+	Channel* getChannel() const;
+		/// Returns the target channel.
+
+	void open();
+		/// Opens the channel and creates the 
+		/// background logging thread.
+		
+	void close();
+		/// Closes the channel and stops the background
+		/// logging thread.
+
+	void log(const Message& msg);
+		/// Queues the message for processing by the
+		/// background thread.
+
+	void setProperty(const std::string& name, const std::string& value);
+		/// Sets or changes a configuration property.
+		///
+		/// The "channel" property allows setting the target 
+		/// channel via the LoggingRegistry.
+		/// The "channel" property is set-only.
+		///
+		/// The "priority" property allows setting the thread
+		/// priority. The following values are supported:
+		///    * lowest
+		///    * low
+		///    * normal (default)
+		///    * high
+		///    * highest
+		///
+		/// The "priority" property is set-only.
+
+protected:
+	~AsyncChannel();
+	void run();
+	void setPriority(const std::string& value);
+		
+private:
+	Channel*  _pChannel;
+	Thread    _thread;
+	FastMutex _threadMutex;
+	FastMutex _channelMutex;
+	NotificationQueue _queue;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_AsyncChannel_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/AtomicCounter.h b/base/poco/Foundation/include/Poco/AtomicCounter.h
new file mode 100644
index 00000000000..4c7c7884f0b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/AtomicCounter.h
@@ -0,0 +1,417 @@
+//
+// AtomicCounter.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  AtomicCounter
+//
+// Definition of the AtomicCounter class.
+//
+// Copyright (c) 2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_AtomicCounter_INCLUDED
+#define Foundation_AtomicCounter_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#if POCO_OS == POCO_OS_WINDOWS_NT
+	#include "Poco/UnWindows.h"
+#elif POCO_OS == POCO_OS_MAC_OS_X
+	#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 101200 || __IPHONE_OS_VERSION_MAX_ALLOWED >= 100000 || __TV_OS_VERSION_MAX_ALLOWED >= 100000 || __WATCH_OS_VERSION_MAX_ALLOWED >= 30000
+		#if __cplusplus >= 201103L
+			#ifndef POCO_HAVE_STD_ATOMICS
+				#define POCO_HAVE_STD_ATOMICS
+			#endif
+		#else
+			#include <libkern/OSAtomic.h>
+		#endif
+	#else
+		#include <libkern/OSAtomic.h>
+	#endif
+#elif ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 2) || __GNUC__ > 4) && (defined(__x86_64__) || defined(__i386__))
+	#if !defined(POCO_HAVE_GCC_ATOMICS) && !defined(POCO_NO_GCC_ATOMICS)
+		#define POCO_HAVE_GCC_ATOMICS
+	#endif
+#elif ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3) || __GNUC__ > 4)
+	#if !defined(POCO_HAVE_GCC_ATOMICS) && !defined(POCO_NO_GCC_ATOMICS)
+		#define POCO_HAVE_GCC_ATOMICS
+	#endif
+#endif // POCO_OS
+#include "Poco/Mutex.h"
+#ifdef POCO_HAVE_STD_ATOMICS
+#include <atomic>
+#endif
+
+
+namespace Poco {
+
+
+class Foundation_API AtomicCounter
+	/// This class implements a simple counter, which
+	/// provides atomic operations that are safe to
+	/// use in a multithreaded environment.
+	///
+	/// Typical usage of AtomicCounter is for implementing
+	/// reference counting and similar things.
+	///
+	/// On some platforms, the implementation of AtomicCounter
+	/// is based on atomic primitives specific to the platform
+	/// (such as InterlockedIncrement, etc. on Windows), and
+	/// thus very efficient. On platforms that do not support
+	/// atomic primitives, operations are guarded by a FastMutex.
+	///
+	/// The following platforms currently have atomic
+	/// primitives:
+	///   - Windows
+	///   - Mac OS X
+	///   - GCC 4.1+ (Intel platforms only)
+{
+public:
+	typedef int ValueType; /// The underlying integer type.
+	
+	AtomicCounter();
+		/// Creates a new AtomicCounter and initializes it to zero.
+		
+	explicit AtomicCounter(ValueType initialValue);
+		/// Creates a new AtomicCounter and initializes it with
+		/// the given value.
+	
+	AtomicCounter(const AtomicCounter& counter);
+		/// Creates the counter by copying another one.
+	
+	~AtomicCounter();
+		/// Destroys the AtomicCounter.
+
+	AtomicCounter& operator = (const AtomicCounter& counter);
+		/// Assigns the value of another AtomicCounter.
+		
+	AtomicCounter& operator = (ValueType value);
+		/// Assigns a value to the counter.
+
+	operator ValueType () const;
+		/// Returns the value of the counter.
+		
+	ValueType value() const;
+		/// Returns the value of the counter.
+		
+	ValueType operator ++ (); // prefix
+		/// Increments the counter and returns the result.
+		
+	ValueType operator ++ (int); // postfix
+		/// Increments the counter and returns the previous value.
+		
+	ValueType operator -- (); // prefix
+		/// Decrements the counter and returns the result.
+		
+	ValueType operator -- (int); // postfix
+		/// Decrements the counter and returns the previous value.
+		
+	bool operator ! () const;
+		/// Returns true if the counter is zero, false otherwise.
+
+private:
+#if defined(POCO_HAVE_STD_ATOMICS)
+	typedef std::atomic<int> ImplType;
+#elif POCO_OS == POCO_OS_WINDOWS_NT
+	typedef volatile LONG ImplType;
+#elif POCO_OS == POCO_OS_MAC_OS_X
+	typedef int32_t ImplType;
+#elif defined(POCO_HAVE_GCC_ATOMICS)
+	typedef int ImplType;
+#else // generic implementation based on FastMutex
+	struct ImplType
+	{
+		mutable FastMutex mutex;
+		volatile int      value;
+	};
+#endif // POCO_OS
+
+	ImplType _counter;
+};
+
+
+//
+// inlines
+//
+
+
+#if defined(POCO_HAVE_STD_ATOMICS)
+//
+// C++11 atomics
+//
+inline AtomicCounter::operator AtomicCounter::ValueType () const
+{
+	return _counter.load();
+}
+
+	
+inline AtomicCounter::ValueType AtomicCounter::value() const
+{
+	return _counter.load();
+}
+
+
+inline AtomicCounter::ValueType AtomicCounter::operator ++ () // prefix
+{
+	return ++_counter;
+}
+
+	
+inline AtomicCounter::ValueType AtomicCounter::operator ++ (int) // postfix
+{
+	return _counter++;
+}
+
+
+inline AtomicCounter::ValueType AtomicCounter::operator -- () // prefix
+{
+	return --_counter;
+}
+
+	
+inline AtomicCounter::ValueType AtomicCounter::operator -- (int) // postfix
+{
+	return _counter--;
+}
+
+	
+inline bool AtomicCounter::operator ! () const
+{
+	return _counter.load() == 0;
+}
+
+
+#elif POCO_OS == POCO_OS_WINDOWS_NT
+//
+// Windows
+//
+inline AtomicCounter::operator AtomicCounter::ValueType () const
+{
+	return _counter;
+}
+
+	
+inline AtomicCounter::ValueType AtomicCounter::value() const
+{
+	return _counter;
+}
+
+
+inline AtomicCounter::ValueType AtomicCounter::operator ++ () // prefix
+{
+	return InterlockedIncrement(&_counter);
+}
+
+	
+inline AtomicCounter::ValueType AtomicCounter::operator ++ (int) // postfix
+{
+	ValueType result = InterlockedIncrement(&_counter);
+	return --result;
+}
+
+
+inline AtomicCounter::ValueType AtomicCounter::operator -- () // prefix
+{
+	return InterlockedDecrement(&_counter);
+}
+
+	
+inline AtomicCounter::ValueType AtomicCounter::operator -- (int) // postfix
+{
+	ValueType result = InterlockedDecrement(&_counter);
+	return ++result;
+}
+
+	
+inline bool AtomicCounter::operator ! () const
+{
+	return _counter == 0;
+}
+
+
+#elif POCO_OS == POCO_OS_MAC_OS_X
+//
+// Mac OS X
+//
+inline AtomicCounter::operator AtomicCounter::ValueType () const
+{
+	return _counter;
+}
+
+	
+inline AtomicCounter::ValueType AtomicCounter::value() const
+{
+	return _counter;
+}
+
+
+inline AtomicCounter::ValueType AtomicCounter::operator ++ () // prefix
+{
+	return OSAtomicIncrement32(&_counter);
+}
+
+	
+inline AtomicCounter::ValueType AtomicCounter::operator ++ (int) // postfix
+{
+	ValueType result = OSAtomicIncrement32(&_counter);
+	return --result;
+}
+
+
+inline AtomicCounter::ValueType AtomicCounter::operator -- () // prefix
+{
+	return OSAtomicDecrement32(&_counter);
+}
+
+	
+inline AtomicCounter::ValueType AtomicCounter::operator -- (int) // postfix
+{
+	ValueType result = OSAtomicDecrement32(&_counter);
+	return ++result;
+}
+
+	
+inline bool AtomicCounter::operator ! () const
+{
+	return _counter == 0;
+}
+
+#elif defined(POCO_HAVE_GCC_ATOMICS)
+//
+// GCC 4.1+ atomic builtins.
+//
+inline AtomicCounter::operator AtomicCounter::ValueType () const
+{
+	return _counter;
+}
+
+	
+inline AtomicCounter::ValueType AtomicCounter::value() const
+{
+	return _counter;
+}
+
+
+inline AtomicCounter::ValueType AtomicCounter::operator ++ () // prefix
+{
+	return __sync_add_and_fetch(&_counter, 1);
+}
+
+	
+inline AtomicCounter::ValueType AtomicCounter::operator ++ (int) // postfix
+{
+	return __sync_fetch_and_add(&_counter, 1);
+}
+
+
+inline AtomicCounter::ValueType AtomicCounter::operator -- () // prefix
+{
+	return __sync_sub_and_fetch(&_counter, 1);
+}
+
+	
+inline AtomicCounter::ValueType AtomicCounter::operator -- (int) // postfix
+{
+	return __sync_fetch_and_sub(&_counter, 1);
+}
+
+	
+inline bool AtomicCounter::operator ! () const
+{
+	return _counter == 0;
+}
+
+
+#else
+//
+// Generic implementation based on FastMutex
+//
+inline AtomicCounter::operator AtomicCounter::ValueType () const
+{
+	ValueType result;
+	{
+		FastMutex::ScopedLock lock(_counter.mutex);
+		result = _counter.value;
+	}
+	return result;
+}
+
+	
+inline AtomicCounter::ValueType AtomicCounter::value() const
+{
+	ValueType result;
+	{
+		FastMutex::ScopedLock lock(_counter.mutex);
+		result = _counter.value;
+	}
+	return result;
+}
+
+
+inline AtomicCounter::ValueType AtomicCounter::operator ++ () // prefix
+{
+	ValueType result;
+	{
+		FastMutex::ScopedLock lock(_counter.mutex);
+		result = ++_counter.value;
+	}
+	return result;
+}
+
+	
+inline AtomicCounter::ValueType AtomicCounter::operator ++ (int) // postfix
+{
+	ValueType result;
+	{
+		FastMutex::ScopedLock lock(_counter.mutex);
+		result = _counter.value++;
+	}
+	return result;
+}
+
+
+inline AtomicCounter::ValueType AtomicCounter::operator -- () // prefix
+{
+	ValueType result;
+	{
+		FastMutex::ScopedLock lock(_counter.mutex);
+		result = --_counter.value;
+	}
+	return result;
+}
+
+	
+inline AtomicCounter::ValueType AtomicCounter::operator -- (int) // postfix
+{
+	ValueType result;
+	{
+		FastMutex::ScopedLock lock(_counter.mutex);
+		result = _counter.value--;
+	}
+	return result;
+}
+
+	
+inline bool AtomicCounter::operator ! () const
+{
+	bool result;
+	{
+		FastMutex::ScopedLock lock(_counter.mutex);
+		result = _counter.value == 0;
+	}
+	return result;
+}
+
+
+#endif // POCO_OS
+
+
+} // namespace Poco
+
+
+#endif // Foundation_AtomicCounter_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/AutoPtr.h b/base/poco/Foundation/include/Poco/AutoPtr.h
new file mode 100644
index 00000000000..b860d44124c
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/AutoPtr.h
@@ -0,0 +1,386 @@
+//
+// AutoPtr.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  AutoPtr
+//
+// Definition of the AutoPtr template class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_AutoPtr_INCLUDED
+#define Foundation_AutoPtr_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include <algorithm>
+
+
+namespace Poco {
+
+
+template <class C>
+class AutoPtr
+	/// AutoPtr is a "smart" pointer for classes implementing
+	/// reference counting based garbage collection.
+	/// To be usable with the AutoPtr template, a class must
+	/// implement the following behaviour:
+	/// A class must maintain a reference count.
+	/// The constructors of the object initialize the reference
+	/// count to one.
+	/// The class must implement a public duplicate() method:
+	///     void duplicate();
+	/// that increments the reference count by one.
+	/// The class must implement a public release() method:
+	///     void release()
+	/// that decrements the reference count by one, and,
+	/// if the reference count reaches zero, deletes the
+	/// object.
+	///
+	/// AutoPtr works in the following way:
+	/// If an AutoPtr is assigned an ordinary pointer to
+	/// an object (via the constructor or the assignment operator),
+	/// it takes ownership of the object and the object's reference
+	/// count remains unchanged.
+	/// If the AutoPtr is assigned another AutoPtr, the
+	/// object's reference count is incremented by one by
+	/// calling duplicate() on its object.
+	/// The destructor of AutoPtr calls release() on its
+	/// object.
+	/// AutoPtr supports dereferencing with both the ->
+	/// and the * operator. An attempt to dereference a null
+	/// AutoPtr results in a NullPointerException being thrown.
+	/// AutoPtr also implements all relational operators.
+	/// Note that AutoPtr allows casting of its encapsulated data types.
+{
+public:
+	AutoPtr(): _ptr(0)
+	{
+	}
+
+	AutoPtr(C* ptr): _ptr(ptr)
+	{
+	}
+
+	AutoPtr(C* ptr, bool shared): _ptr(ptr)
+	{
+		if (shared && _ptr) _ptr->duplicate();
+	}
+
+	AutoPtr(const AutoPtr& ptr): _ptr(ptr._ptr)
+	{
+		if (_ptr) _ptr->duplicate(); // NOLINT
+	}
+
+	template <class Other>
+	AutoPtr(const AutoPtr<Other>& ptr): _ptr(const_cast<Other*>(ptr.get()))
+	{
+		if (_ptr) _ptr->duplicate();
+	}
+
+	~AutoPtr()
+	{
+		if (_ptr) _ptr->release(); // NOLINT
+	}
+
+	AutoPtr& assign(C* ptr)
+	{
+		if (_ptr != ptr)
+		{
+			if (_ptr) _ptr->release();
+			_ptr = ptr;
+		}
+		return *this;
+	}
+
+	AutoPtr& assign(C* ptr, bool shared)
+	{
+		if (_ptr != ptr)
+		{
+			if (_ptr) _ptr->release();
+			_ptr = ptr;
+			if (shared && _ptr) _ptr->duplicate();
+		}
+		return *this;
+	}
+
+	AutoPtr& assign(const AutoPtr& ptr)
+	{
+		if (&ptr != this)
+		{
+			if (_ptr) _ptr->release();
+			_ptr = ptr._ptr;
+			if (_ptr) _ptr->duplicate(); // NOLINT
+		}
+		return *this;
+	}
+
+	template <class Other>
+	AutoPtr& assign(const AutoPtr<Other>& ptr)
+	{
+		if (ptr.get() != _ptr)
+		{
+			if (_ptr) _ptr->release();
+			_ptr = const_cast<Other*>(ptr.get());
+			if (_ptr) _ptr->duplicate();
+		}
+		return *this;
+	}
+
+	void reset()
+	{
+		if (_ptr)
+		{
+			_ptr->release();
+			_ptr = 0;
+		}
+	}
+
+	void reset(C* ptr)
+	{
+		assign(ptr);
+	}
+
+	void reset(C* ptr, bool shared)
+	{
+		assign(ptr, shared);
+	}
+
+	void reset(const AutoPtr& ptr)
+	{
+		assign(ptr);
+	}
+
+	template <class Other>
+	void reset(const AutoPtr<Other>& ptr)
+	{
+		assign<Other>(ptr);
+	}
+
+	AutoPtr& operator = (C* ptr)
+	{
+		return assign(ptr);
+	}
+
+	AutoPtr& operator = (const AutoPtr& ptr)
+	{
+		return assign(ptr);
+	}
+
+	template <class Other>
+	AutoPtr& operator = (const AutoPtr<Other>& ptr)
+	{
+		return assign<Other>(ptr);
+	}
+
+	void swap(AutoPtr& ptr)
+	{
+		std::swap(_ptr, ptr._ptr);
+	}
+
+	template <class Other>
+	AutoPtr<Other> cast() const
+		/// Casts the AutoPtr via a dynamic cast to the given type.
+		/// Returns an AutoPtr containing NULL if the cast fails.
+		/// Example: (assume class Sub: public Super)
+		///    AutoPtr<Super> super(new Sub());
+		///    AutoPtr<Sub> sub = super.cast<Sub>();
+		///    poco_assert (sub.get());
+	{
+		Other* pOther = dynamic_cast<Other*>(_ptr);
+		return AutoPtr<Other>(pOther, true);
+	}
+
+	template <class Other>
+	AutoPtr<Other> unsafeCast() const
+		/// Casts the AutoPtr via a static cast to the given type.
+		/// Example: (assume class Sub: public Super)
+		///    AutoPtr<Super> super(new Sub());
+		///    AutoPtr<Sub> sub = super.unsafeCast<Sub>();
+		///    poco_assert (sub.get());
+	{
+		Other* pOther = static_cast<Other*>(_ptr);
+		return AutoPtr<Other>(pOther, true);
+	}
+
+	C* operator -> ()
+	{
+		if (_ptr)
+			return _ptr; // NOLINT
+		else
+			throw NullPointerException();
+	}
+
+	const C* operator -> () const
+	{
+		if (_ptr)
+			return _ptr;
+		else
+			throw NullPointerException();
+	}
+
+	C& operator * ()
+	{
+		if (_ptr)
+			return *_ptr; // NOLINT
+		else
+			throw NullPointerException();
+	}
+
+	const C& operator * () const
+	{
+		if (_ptr)
+			return *_ptr;
+		else
+			throw NullPointerException();
+	}
+
+	C* get()
+	{
+		return _ptr;
+	}
+
+	const C* get() const
+	{
+		return _ptr;
+	}
+
+	operator C* ()
+	{
+		return _ptr; // NOLINT
+	}
+
+	operator const C* () const
+	{
+		return _ptr;
+	}
+
+	bool operator ! () const
+	{
+		return _ptr == 0;
+	}
+
+	bool isNull() const
+	{
+		return _ptr == 0;
+	}
+
+	C* duplicate()
+	{
+		if (_ptr) _ptr->duplicate();
+		return _ptr;
+	}
+
+	bool operator == (const AutoPtr& ptr) const
+	{
+		return _ptr == ptr._ptr;
+	}
+
+	bool operator == (const C* ptr) const
+	{
+		return _ptr == ptr;
+	}
+
+	bool operator == (C* ptr) const
+	{
+		return _ptr == ptr;
+	}
+
+	bool operator != (const AutoPtr& ptr) const
+	{
+		return _ptr != ptr._ptr;
+	}
+
+	bool operator != (const C* ptr) const
+	{
+		return _ptr != ptr;
+	}
+
+	bool operator != (C* ptr) const
+	{
+		return _ptr != ptr;
+	}
+
+	bool operator < (const AutoPtr& ptr) const
+	{
+		return _ptr < ptr._ptr;
+	}
+
+	bool operator < (const C* ptr) const
+	{
+		return _ptr < ptr;
+	}
+
+	bool operator < (C* ptr) const
+	{
+		return _ptr < ptr;
+	}
+
+	bool operator <= (const AutoPtr& ptr) const
+	{
+		return _ptr <= ptr._ptr;
+	}
+
+	bool operator <= (const C* ptr) const
+	{
+		return _ptr <= ptr;
+	}
+
+	bool operator <= (C* ptr) const
+	{
+		return _ptr <= ptr;
+	}
+
+	bool operator > (const AutoPtr& ptr) const
+	{
+		return _ptr > ptr._ptr;
+	}
+
+	bool operator > (const C* ptr) const
+	{
+		return _ptr > ptr;
+	}
+
+	bool operator > (C* ptr) const
+	{
+		return _ptr > ptr;
+	}
+
+	bool operator >= (const AutoPtr& ptr) const
+	{
+		return _ptr >= ptr._ptr;
+	}
+
+	bool operator >= (const C* ptr) const
+	{
+		return _ptr >= ptr;
+	}
+
+	bool operator >= (C* ptr) const
+	{
+		return _ptr >= ptr;
+	}
+
+private:
+	C* _ptr;
+};
+
+
+template <class C>
+inline void swap(AutoPtr<C>& p1, AutoPtr<C>& p2)
+{
+	p1.swap(p2);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_AutoPtr_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/AutoReleasePool.h b/base/poco/Foundation/include/Poco/AutoReleasePool.h
new file mode 100644
index 00000000000..0b13956e8ea
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/AutoReleasePool.h
@@ -0,0 +1,86 @@
+//
+// AutoReleasePool.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  AutoReleasePool
+//
+// Definition of the AutoReleasePool class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_AutoReleasePool_INCLUDED
+#define Foundation_AutoReleasePool_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <list>
+
+
+namespace Poco {
+
+
+template <class C>
+class AutoReleasePool
+	/// An AutoReleasePool implements simple garbage collection for 
+	/// reference-counted objects.
+	/// It temporarily takes ownwership of reference-counted objects that 
+	/// nobody else wants to take ownership of and releases them 
+	/// at a later, appropriate point in time.
+	///
+	/// Note: The correct way to add an object hold by an AutoPtr<> to
+	/// an AutoReleasePool is by invoking the AutoPtr's duplicate()
+	/// method. Example:
+	///    AutoReleasePool<C> arp;
+	///    AutoPtr<C> ptr = new C;
+	///    ...
+	///    arp.add(ptr.duplicate());
+{
+public:
+	AutoReleasePool()
+		/// Creates the AutoReleasePool.
+	{
+	}
+	
+	~AutoReleasePool()
+		/// Destroys the AutoReleasePool and releases
+		/// all objects it currently holds.
+	{
+		release();
+	}
+	
+	void add(C* pObject)
+		/// Adds the given object to the AutoReleasePool.
+		/// The object's reference count is not modified
+	{
+		if (pObject)
+			_list.push_back(pObject);
+	}
+	
+	void release()
+		/// Releases all objects the AutoReleasePool currently holds
+		/// by calling each object's release() method.
+	{
+		while (!_list.empty())
+		{
+			_list.front()->release();
+			_list.pop_front();
+		}
+	}
+	
+private:
+	typedef std::list<C*> ObjectList;
+	
+	ObjectList _list;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_AutoReleasePool_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Base32Decoder.h b/base/poco/Foundation/include/Poco/Base32Decoder.h
new file mode 100644
index 00000000000..54367c58861
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Base32Decoder.h
@@ -0,0 +1,104 @@
+//
+// Base32Decoder.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  Base32
+//
+// Definition of class Base32Decoder.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Base32Decoder_INCLUDED
+#define Foundation_Base32Decoder_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include <istream>
+
+
+namespace Poco {
+
+
+class Foundation_API Base32DecoderBuf: public UnbufferedStreamBuf
+	/// This streambuf base32-decodes all data read
+	/// from the istream connected to it.
+	///
+	/// Note: For performance reasons, the characters 
+	/// are read directly from the given istream's 
+	/// underlying streambuf, so the state
+	/// of the istream will not reflect that of
+	/// its streambuf.
+{
+public:
+	Base32DecoderBuf(std::istream& istr);
+	~Base32DecoderBuf();
+	
+private:
+	int readFromDevice();
+	int readOne();
+
+	unsigned char   _group[8];
+	int             _groupLength;
+	int             _groupIndex;
+	std::streambuf& _buf;
+	
+	static unsigned char IN_ENCODING[256];
+	static bool          IN_ENCODING_INIT;
+	
+private:
+	Base32DecoderBuf(const Base32DecoderBuf&);
+	Base32DecoderBuf& operator = (const Base32DecoderBuf&);
+};
+
+
+class Foundation_API Base32DecoderIOS: public virtual std::ios
+	/// The base class for Base32Decoder.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	Base32DecoderIOS(std::istream& istr);
+	~Base32DecoderIOS();
+	Base32DecoderBuf* rdbuf();
+
+protected:
+	Base32DecoderBuf _buf;
+	
+private:
+	Base32DecoderIOS(const Base32DecoderIOS&);
+	Base32DecoderIOS& operator = (const Base32DecoderIOS&);
+};
+
+
+class Foundation_API Base32Decoder: public Base32DecoderIOS, public std::istream
+	/// This istream base32-decodes all data
+	/// read from the istream connected to it.
+	///
+	/// Note: For performance reasons, the characters 
+	/// are read directly from the given istream's 
+	/// underlying streambuf, so the state
+	/// of the istream will not reflect that of
+	/// its streambuf.
+{
+public:
+	Base32Decoder(std::istream& istr);
+	~Base32Decoder();
+
+private:
+	Base32Decoder(const Base32Decoder&);
+	Base32Decoder& operator = (const Base32Decoder&);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Base32Decoder_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Base32Encoder.h b/base/poco/Foundation/include/Poco/Base32Encoder.h
new file mode 100644
index 00000000000..246f8483b08
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Base32Encoder.h
@@ -0,0 +1,110 @@
+//
+// Base32Encoder.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  Base32
+//
+// Definition of class Base32Encoder.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Base32Encoder_INCLUDED
+#define Foundation_Base32Encoder_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include <ostream>
+
+
+namespace Poco {
+
+
+class Foundation_API Base32EncoderBuf: public UnbufferedStreamBuf
+	/// This streambuf base32-encodes all data written
+	/// to it and forwards it to a connected
+	/// ostream.
+	///
+	/// Note: The characters are directly written
+	/// to the ostream's streambuf, thus bypassing
+	/// the ostream. The ostream's state is therefore
+	/// not updated to match the buffer's state.
+{
+public:
+	Base32EncoderBuf(std::ostream& ostr, bool padding = true);
+	~Base32EncoderBuf();
+	
+	int close();
+		/// Closes the stream buffer.
+
+private:
+	int writeToDevice(char c);
+
+	unsigned char   _group[5];
+	int             _groupLength;
+	std::streambuf& _buf;
+	bool		_doPadding;
+	
+	static const unsigned char OUT_ENCODING[32];
+	
+	friend class Base32DecoderBuf;
+
+	Base32EncoderBuf(const Base32EncoderBuf&);
+	Base32EncoderBuf& operator = (const Base32EncoderBuf&);
+};
+
+
+class Foundation_API Base32EncoderIOS: public virtual std::ios
+	/// The base class for Base32Encoder.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	Base32EncoderIOS(std::ostream& ostr, bool padding = true);
+	~Base32EncoderIOS();
+	int close();
+	Base32EncoderBuf* rdbuf();
+
+protected:
+	Base32EncoderBuf _buf;
+
+private:
+	Base32EncoderIOS(const Base32EncoderIOS&);
+	Base32EncoderIOS& operator = (const Base32EncoderIOS&);
+};
+
+
+class Foundation_API Base32Encoder: public Base32EncoderIOS, public std::ostream
+	/// This ostream base32-encodes all data
+	/// written to it and forwards it to
+	/// a connected ostream.
+	/// Always call close() when done
+	/// writing data, to ensure proper
+	/// completion of the encoding operation.
+	///
+	/// Note: The characters are directly written
+	/// to the ostream's streambuf, thus bypassing
+	/// the ostream. The ostream's state is therefore
+	/// not updated to match the buffer's state.
+{
+public:
+	Base32Encoder(std::ostream& ostr, bool padding = true);
+	~Base32Encoder();
+
+private:
+	Base32Encoder(const Base32Encoder&);
+	Base32Encoder& operator = (const Base32Encoder&);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Base32Encoder_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Base64Decoder.h b/base/poco/Foundation/include/Poco/Base64Decoder.h
new file mode 100644
index 00000000000..51958231e0f
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Base64Decoder.h
@@ -0,0 +1,108 @@
+//
+// Base64Decoder.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  Base64
+//
+// Definition of class Base64Decoder.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Base64Decoder_INCLUDED
+#define Foundation_Base64Decoder_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include <istream>
+
+
+namespace Poco {
+
+
+class Foundation_API Base64DecoderBuf: public UnbufferedStreamBuf
+	/// This streambuf base64-decodes all data read
+	/// from the istream connected to it.
+	///
+	/// Note: For performance reasons, the characters 
+	/// are read directly from the given istream's 
+	/// underlying streambuf, so the state
+	/// of the istream will not reflect that of
+	/// its streambuf.
+{
+public:
+	Base64DecoderBuf(std::istream& istr, int options = 0);
+	~Base64DecoderBuf();
+
+private:
+	int readFromDevice();
+	int readOne();
+
+	int             _options;
+	unsigned char   _group[3];
+	int             _groupLength;
+	int             _groupIndex;
+	std::streambuf& _buf;
+	const unsigned char* _pInEncoding;
+
+	static unsigned char IN_ENCODING[256];
+	static bool          IN_ENCODING_INIT;
+	static unsigned char IN_ENCODING_URL[256];
+	static bool          IN_ENCODING_URL_INIT;
+
+private:
+	Base64DecoderBuf(const Base64DecoderBuf&);
+	Base64DecoderBuf& operator = (const Base64DecoderBuf&);
+};
+
+
+class Foundation_API Base64DecoderIOS: public virtual std::ios
+	/// The base class for Base64Decoder.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	Base64DecoderIOS(std::istream& istr, int options = 0);
+	~Base64DecoderIOS();
+	Base64DecoderBuf* rdbuf();
+
+protected:
+	Base64DecoderBuf _buf;
+
+private:
+	Base64DecoderIOS(const Base64DecoderIOS&);
+	Base64DecoderIOS& operator = (const Base64DecoderIOS&);
+};
+
+
+class Foundation_API Base64Decoder: public Base64DecoderIOS, public std::istream
+	/// This istream base64-decodes all data
+	/// read from the istream connected to it.
+	///
+	/// Note: For performance reasons, the characters 
+	/// are read directly from the given istream's 
+	/// underlying streambuf, so the state
+	/// of the istream will not reflect that of
+	/// its streambuf.
+{
+public:
+	Base64Decoder(std::istream& istr, int options = 0);
+	~Base64Decoder();
+
+private:
+	Base64Decoder(const Base64Decoder&);
+	Base64Decoder& operator = (const Base64Decoder&);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Base64Decoder_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Base64Encoder.h b/base/poco/Foundation/include/Poco/Base64Encoder.h
new file mode 100644
index 00000000000..4371803a596
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Base64Encoder.h
@@ -0,0 +1,138 @@
+//
+// Base64Encoder.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  Base64
+//
+// Definition of class Base64Encoder.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Base64Encoder_INCLUDED
+#define Foundation_Base64Encoder_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include <ostream>
+
+
+namespace Poco {
+
+
+enum Base64EncodingOptions
+{
+	BASE64_URL_ENCODING = 0x01,
+		/// Use the URL and filename-safe alphabet,
+		/// replacing '+' with '-' and '/' with '_'.
+		///
+		/// Will also set line length to unlimited.
+
+	BASE64_NO_PADDING   = 0x02
+		/// Do not append padding characters ('=') at end.
+};
+
+
+class Foundation_API Base64EncoderBuf: public UnbufferedStreamBuf
+	/// This streambuf base64-encodes all data written
+	/// to it and forwards it to a connected
+	/// ostream.
+	///
+	/// Note: The characters are directly written
+	/// to the ostream's streambuf, thus bypassing
+	/// the ostream. The ostream's state is therefore
+	/// not updated to match the buffer's state.
+{
+public:
+	Base64EncoderBuf(std::ostream& ostr, int options = 0);
+	~Base64EncoderBuf();
+
+	int close();
+		/// Closes the stream buffer.
+
+	void setLineLength(int lineLength);
+		/// Specify the line length.
+		///
+		/// After the given number of characters have been written, 
+		/// a newline character will be written.
+		///
+		/// Specify 0 for an unlimited line length.
+
+	int getLineLength() const;
+		/// Returns the currently set line length.
+
+private:
+	int writeToDevice(char c);
+
+	int             _options;
+	unsigned char   _group[3];
+	int             _groupLength;
+	int             _pos;
+	int             _lineLength;
+	std::streambuf& _buf;
+	const unsigned char* _pOutEncoding;
+
+	static const unsigned char OUT_ENCODING[64];
+	static const unsigned char OUT_ENCODING_URL[64];
+
+	friend class Base64DecoderBuf;
+
+	Base64EncoderBuf(const Base64EncoderBuf&);
+	Base64EncoderBuf& operator = (const Base64EncoderBuf&);
+};
+
+
+class Foundation_API Base64EncoderIOS: public virtual std::ios
+	/// The base class for Base64Encoder.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	Base64EncoderIOS(std::ostream& ostr, int options = 0);
+	~Base64EncoderIOS();
+	int close();
+	Base64EncoderBuf* rdbuf();
+
+protected:
+	Base64EncoderBuf _buf;
+
+private:
+	Base64EncoderIOS(const Base64EncoderIOS&);
+	Base64EncoderIOS& operator = (const Base64EncoderIOS&);
+};
+
+
+class Foundation_API Base64Encoder: public Base64EncoderIOS, public std::ostream
+	/// This ostream base64-encodes all data
+	/// written to it and forwards it to
+	/// a connected ostream.
+	/// Always call close() when done
+	/// writing data, to ensure proper
+	/// completion of the encoding operation.
+	///
+	/// Note: The characters are directly written
+	/// to the ostream's streambuf, thus bypassing
+	/// the ostream. The ostream's state is therefore
+	/// not updated to match the buffer's state.
+{
+public:
+	Base64Encoder(std::ostream& ostr, int options = 0);
+	~Base64Encoder();
+
+private:
+	Base64Encoder(const Base64Encoder&);
+	Base64Encoder& operator = (const Base64Encoder&);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Base64Encoder_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/BasicEvent.h b/base/poco/Foundation/include/Poco/BasicEvent.h
new file mode 100644
index 00000000000..bc2dd516c34
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/BasicEvent.h
@@ -0,0 +1,60 @@
+//
+// BasicEvent.h
+//
+// Library: Foundation
+// Package: Events
+// Module:  BasicEvent
+//
+// Implementation of the BasicEvent template.
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_BasicEvent_INCLUDED
+#define Foundation_BasicEvent_INCLUDED
+
+
+#include "Poco/AbstractEvent.h"
+#include "Poco/DefaultStrategy.h"
+#include "Poco/AbstractDelegate.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+
+
+template <class TArgs, class TMutex = FastMutex> 
+class BasicEvent: public AbstractEvent < 
+	TArgs, DefaultStrategy<TArgs, AbstractDelegate<TArgs> >,
+	AbstractDelegate<TArgs>,
+	TMutex
+>
+	/// A BasicEvent uses the DefaultStrategy which 
+	/// invokes delegates in the order they have been registered.
+	///
+	/// Please see the AbstractEvent class template documentation
+	/// for more information.
+{
+public:
+	BasicEvent()
+	{
+	}
+
+	~BasicEvent()
+	{
+	}
+
+private:
+	BasicEvent(const BasicEvent& e);
+	BasicEvent& operator = (const BasicEvent& e);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_BasicEvent_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/BinaryReader.h b/base/poco/Foundation/include/Poco/BinaryReader.h
new file mode 100644
index 00000000000..70d595450ae
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/BinaryReader.h
@@ -0,0 +1,265 @@
+//
+// BinaryReader.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  BinaryReaderWriter
+//
+// Definition of the BinaryReader class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_BinaryReader_INCLUDED
+#define Foundation_BinaryReader_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Buffer.h"
+#include "Poco/MemoryStream.h"
+#include <vector>
+#include <istream>
+
+
+namespace Poco {
+
+
+class TextEncoding;
+class TextConverter;
+
+
+class Foundation_API BinaryReader
+	/// This class reads basic types (and std::vectors thereof)
+	/// in binary form into an input stream.
+	/// It provides an extractor-based interface similar to istream.
+	/// The reader also supports automatic conversion from big-endian
+	/// (network byte order) to little-endian and vice-versa.
+	/// Use a BinaryWriter to create a stream suitable for a BinaryReader.
+{
+public:
+	enum StreamByteOrder
+	{
+		NATIVE_BYTE_ORDER        = 1,  /// the host's native byte-order
+		BIG_ENDIAN_BYTE_ORDER    = 2,  /// big-endian (network) byte-order
+		NETWORK_BYTE_ORDER       = 2,  /// big-endian (network) byte-order
+		LITTLE_ENDIAN_BYTE_ORDER = 3,  /// little-endian byte-order
+		UNSPECIFIED_BYTE_ORDER   = 4   /// unknown, byte-order will be determined by reading the byte-order mark
+	};
+
+	BinaryReader(std::istream& istr, StreamByteOrder byteOrder = NATIVE_BYTE_ORDER);
+		/// Creates the BinaryReader.
+
+	BinaryReader(std::istream& istr, TextEncoding& encoding, StreamByteOrder byteOrder = NATIVE_BYTE_ORDER);
+		/// Creates the BinaryReader using the given TextEncoding.
+		///
+		/// Strings will be converted from the specified encoding
+		/// to the currently set global encoding (see Poco::TextEncoding::global()).
+
+	~BinaryReader();
+		/// Destroys the BinaryReader.
+
+	BinaryReader& operator >> (bool& value);
+	BinaryReader& operator >> (char& value);
+	BinaryReader& operator >> (unsigned char& value);
+	BinaryReader& operator >> (signed char& value);
+	BinaryReader& operator >> (short& value);
+	BinaryReader& operator >> (unsigned short& value);
+	BinaryReader& operator >> (int& value);
+	BinaryReader& operator >> (unsigned int& value);
+	BinaryReader& operator >> (long& value);
+	BinaryReader& operator >> (unsigned long& value);
+	BinaryReader& operator >> (float& value);
+	BinaryReader& operator >> (double& value);
+
+#if defined(POCO_HAVE_INT64) && !defined(POCO_LONG_IS_64_BIT)
+	BinaryReader& operator >> (Int64& value);
+	BinaryReader& operator >> (UInt64& value);
+#endif
+
+	BinaryReader& operator >> (std::string& value);
+
+	template <typename T>
+	BinaryReader& operator >> (std::vector<T>& value)
+	{
+		Poco::UInt32 size(0);
+		T elem;
+
+		*this >> size;
+		if (!good()) return *this;
+		value.reserve(size);
+		while (this->good() && size-- > 0)
+		{
+			*this >> elem;
+			value.push_back(elem);
+		}
+		return *this;
+	}
+
+	void read7BitEncoded(UInt32& value);
+		/// Reads a 32-bit unsigned integer in compressed format.
+		/// See BinaryWriter::write7BitEncoded() for a description
+		/// of the compression algorithm.
+
+#if defined(POCO_HAVE_INT64)
+	void read7BitEncoded(UInt64& value);
+		/// Reads a 64-bit unsigned integer in compressed format.
+		/// See BinaryWriter::write7BitEncoded() for a description
+		/// of the compression algorithm.
+#endif
+
+	void readRaw(std::streamsize length, std::string& value);
+		/// Reads length bytes of raw data into value.
+
+	void readRaw(char* buffer, std::streamsize length);
+		/// Reads length bytes of raw data into buffer.
+
+	void readBOM();
+		/// Reads a byte-order mark from the stream and configures
+		/// the reader for the encountered byte order.
+		/// A byte-order mark is a 16-bit integer with a value of 0xFEFF,
+		/// written in host byte order.
+		
+	bool good();
+		/// Returns _istr.good();
+		
+	bool fail();
+		/// Returns _istr.fail();
+
+	bool bad();
+		/// Returns _istr.bad();
+	
+	bool eof();
+		/// Returns _istr.eof();
+
+	std::istream& stream() const;
+		/// Returns the underlying stream.
+		
+	StreamByteOrder byteOrder() const;
+		/// Returns the byte-order used by the reader, which is
+		/// either BIG_ENDIAN_BYTE_ORDER or LITTLE_ENDIAN_BYTE_ORDER.
+
+	void setExceptions(std::ios_base::iostate st = (std::istream::failbit | std::istream::badbit));
+		/// Sets the stream to throw exception on specified state (default failbit and badbit);
+
+	std::streamsize available() const;
+		/// Returns the number of available bytes in the stream.
+
+private:
+	std::istream&  _istr;
+	bool           _flipBytes; 
+	TextConverter* _pTextConverter;
+};
+
+
+template <typename T>
+class BasicMemoryBinaryReader : public BinaryReader
+	/// A convenient wrapper for using Buffer and MemoryStream with BinaryReader.
+{
+public:
+	BasicMemoryBinaryReader(const Buffer<T>& data, StreamByteOrder byteOrder = NATIVE_BYTE_ORDER):
+		BinaryReader(_istr, byteOrder),
+		_data(data),
+		_istr(data.begin(), data.capacity())
+	{
+	}
+
+	BasicMemoryBinaryReader(const Buffer<T>& data, TextEncoding& encoding, StreamByteOrder byteOrder = NATIVE_BYTE_ORDER):
+		BinaryReader(_istr, encoding, byteOrder),
+		_data(data),
+		_istr(data.begin(), data.capacity())
+	{
+	}
+
+	~BasicMemoryBinaryReader()
+	{
+	}
+
+	const Buffer<T>& data() const
+	{
+		return _data;
+	}
+
+	const MemoryInputStream& stream() const
+	{
+		return _istr;
+	}
+
+	MemoryInputStream& stream()
+	{
+		return _istr;
+	}
+
+private:
+	const Buffer<T>& _data;
+	MemoryInputStream _istr;
+};
+
+
+typedef BasicMemoryBinaryReader<char> MemoryBinaryReader;
+
+
+//
+// inlines
+//
+
+
+inline bool BinaryReader::good()
+{
+	return _istr.good();
+}
+
+	
+inline bool BinaryReader::fail()
+{
+	return _istr.fail();
+}
+
+
+inline bool BinaryReader::bad()
+{
+	return _istr.bad();
+}
+
+
+inline bool BinaryReader::eof()
+{
+	return _istr.eof();
+}
+
+
+inline std::istream& BinaryReader::stream() const
+{
+	return _istr;
+}
+
+	
+inline BinaryReader::StreamByteOrder BinaryReader::byteOrder() const
+{
+#if defined(POCO_ARCH_BIG_ENDIAN)
+	return _flipBytes ? LITTLE_ENDIAN_BYTE_ORDER : BIG_ENDIAN_BYTE_ORDER;
+#else
+	return _flipBytes ? BIG_ENDIAN_BYTE_ORDER : LITTLE_ENDIAN_BYTE_ORDER;
+#endif
+}
+
+
+inline void BinaryReader::setExceptions(std::ios_base::iostate st)
+{
+	_istr.exceptions(st);
+}
+
+
+inline std::streamsize BinaryReader::available() const
+{
+	return _istr.rdbuf()->in_avail();
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_BinaryReader_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/BinaryWriter.h b/base/poco/Foundation/include/Poco/BinaryWriter.h
new file mode 100644
index 00000000000..7941117c049
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/BinaryWriter.h
@@ -0,0 +1,269 @@
+//
+// BinaryWriter.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  BinaryReaderWriter
+//
+// Definition of the BinaryWriter class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_BinaryWriter_INCLUDED
+#define Foundation_BinaryWriter_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Buffer.h"
+#include "Poco/MemoryStream.h"
+#include <vector>
+#include <ostream>
+
+
+namespace Poco {
+
+
+class TextEncoding;
+class TextConverter;
+
+
+class Foundation_API BinaryWriter
+	/// This class writes basic types (and std::vectors of these) 
+	/// in binary form into an output stream.
+	/// It provides an inserter-based interface similar to ostream.
+	/// The writer also supports automatic conversion from big-endian
+	/// (network byte order) to little-endian and vice-versa.
+	/// Use a BinaryReader to read from a stream created by a BinaryWriter.
+	/// Be careful when exchanging data between systems with different
+	/// data type sizes (e.g., 32-bit and 64-bit architectures), as the sizes
+	/// of some of the basic types may be different. For example, writing a
+	/// long integer on a 64-bit system and reading it on a 32-bit system
+	/// may yield an incorrent result. Use fixed-size types (Int32, Int64, etc.)
+	/// in such a case.
+{
+public:
+	enum StreamByteOrder
+	{
+		NATIVE_BYTE_ORDER        = 1, /// the host's native byte-order
+		BIG_ENDIAN_BYTE_ORDER    = 2, /// big-endian (network) byte-order
+		NETWORK_BYTE_ORDER       = 2, /// big-endian (network) byte-order
+		LITTLE_ENDIAN_BYTE_ORDER = 3  /// little-endian byte-order
+	};
+	
+	BinaryWriter(std::ostream& ostr, StreamByteOrder byteOrder = NATIVE_BYTE_ORDER);
+		/// Creates the BinaryWriter.
+
+	BinaryWriter(std::ostream& ostr, TextEncoding& encoding, StreamByteOrder byteOrder = NATIVE_BYTE_ORDER);
+		/// Creates the BinaryWriter using the given TextEncoding.
+		///
+		/// Strings will be converted from the currently set global encoding
+		/// (see Poco::TextEncoding::global()) to the specified encoding.
+
+	~BinaryWriter();
+		/// Destroys the BinaryWriter.
+
+	BinaryWriter& operator << (bool value);
+	BinaryWriter& operator << (char value);
+	BinaryWriter& operator << (unsigned char value);
+	BinaryWriter& operator << (signed char value);
+	BinaryWriter& operator << (short value);
+	BinaryWriter& operator << (unsigned short value);
+	BinaryWriter& operator << (int value);
+	BinaryWriter& operator << (unsigned int value);
+	BinaryWriter& operator << (long value);
+	BinaryWriter& operator << (unsigned long value);
+	BinaryWriter& operator << (float value);
+	BinaryWriter& operator << (double value);
+
+#if defined(POCO_HAVE_INT64) && !defined(POCO_LONG_IS_64_BIT)
+	BinaryWriter& operator << (Int64 value);
+	BinaryWriter& operator << (UInt64 value);
+#endif
+
+	BinaryWriter& operator << (const std::string& value);
+	BinaryWriter& operator << (const char* value);
+
+	template <typename T>
+	BinaryWriter& operator << (const std::vector<T>& value)
+	{
+		Poco::UInt32 size(static_cast<Poco::UInt32>(value.size()));
+
+		*this << size;
+		for (typename std::vector<T>::const_iterator it = value.begin(); it != value.end(); ++it)
+		{
+			*this << *it;
+		}
+
+		return *this;
+	}
+	
+	void write7BitEncoded(UInt32 value);
+		/// Writes a 32-bit unsigned integer in a compressed format.
+		/// The value is written out seven bits at a time, starting 
+		/// with the seven least-significant bits. 
+		/// The high bit of a byte indicates whether there are more bytes to be 
+		/// written after this one.
+		/// If value will fit in seven bits, it takes only one byte of space. 
+		/// If value will not fit in seven bits, the high bit is set on the first byte and 
+		/// written out. value is then shifted by seven bits and the next byte is written. 
+		/// This process is repeated until the entire integer has been written.
+
+#if defined(POCO_HAVE_INT64)
+	void write7BitEncoded(UInt64 value);
+		/// Writes a 64-bit unsigned integer in a compressed format.
+		/// The value written out seven bits at a time, starting 
+		/// with the seven least-significant bits. 
+		/// The high bit of a byte indicates whether there are more bytes to be 
+		/// written after this one.
+		/// If value will fit in seven bits, it takes only one byte of space. 
+		/// If value will not fit in seven bits, the high bit is set on the first byte and 
+		/// written out. value is then shifted by seven bits and the next byte is written. 
+		/// This process is repeated until the entire integer has been written.
+#endif
+
+	void writeRaw(const std::string& rawData);
+		/// Writes the string as-is to the stream.
+		
+	void writeRaw(const char* buffer, std::streamsize length);
+		/// Writes length raw bytes from the given buffer to the stream.
+
+	void writeBOM();
+		/// Writes a byte-order mark to the stream. A byte order mark is
+		/// a 16-bit integer with a value of 0xFEFF, written in host byte-order. 
+		/// A BinaryReader uses the byte-order mark to determine the byte-order 
+		/// of the stream.
+
+	void flush();
+		/// Flushes the underlying stream.
+		
+	bool good();
+		/// Returns _ostr.good();
+		
+	bool fail();
+		/// Returns _ostr.fail();
+	
+	bool bad();
+		/// Returns _ostr.bad();
+		
+	std::ostream& stream() const;
+		/// Returns the underlying stream.
+		
+	StreamByteOrder byteOrder() const;
+		/// Returns the byte ordering used by the writer, which is
+		/// either BIG_ENDIAN_BYTE_ORDER or LITTLE_ENDIAN_BYTE_ORDER.
+
+private:
+	std::ostream&  _ostr;
+	bool           _flipBytes;
+	TextConverter* _pTextConverter;
+};
+
+
+template <typename T>
+class BasicMemoryBinaryWriter: public BinaryWriter
+	/// A convenient wrapper for using Buffer and MemoryStream with BinarWriter.
+{
+public:
+	BasicMemoryBinaryWriter(Buffer<T>& data, StreamByteOrder byteOrder = NATIVE_BYTE_ORDER): 
+		BinaryWriter(_ostr, byteOrder),
+		_data(data),
+		_ostr(data.begin(), data.capacity())
+	{
+	}
+
+	BasicMemoryBinaryWriter(Buffer<T>& data, TextEncoding& encoding, StreamByteOrder byteOrder = NATIVE_BYTE_ORDER): 
+		BinaryWriter(_ostr, encoding, byteOrder),
+		_data(data),
+		_ostr(data.begin(), data.capacity())
+	{
+	}
+
+	~BasicMemoryBinaryWriter()
+	{
+		try
+		{
+			flush();
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	}
+
+	Buffer<T>& data()
+	{
+		return _data;
+	}
+
+	const Buffer<T>& data() const
+	{
+		return _data;
+	}
+
+	const MemoryOutputStream& stream() const
+	{
+		return _ostr;
+	}
+
+	MemoryOutputStream& stream()
+	{
+		return _ostr;
+	}
+
+private:
+	Buffer<T>& _data;
+	MemoryOutputStream _ostr;
+};
+
+
+typedef BasicMemoryBinaryWriter<char> MemoryBinaryWriter;
+
+
+//
+// inlines
+//
+
+
+inline std::ostream& BinaryWriter::stream() const
+{
+	return _ostr;
+}
+
+
+inline bool BinaryWriter::good()
+{
+	return _ostr.good();
+}
+
+
+inline bool BinaryWriter::fail()
+{
+	return _ostr.fail();
+}
+
+
+inline bool BinaryWriter::bad()
+{
+	return _ostr.bad();
+}
+
+
+inline BinaryWriter::StreamByteOrder BinaryWriter::byteOrder() const
+{
+#if defined(POCO_ARCH_BIG_ENDIAN)
+	return _flipBytes ? LITTLE_ENDIAN_BYTE_ORDER : BIG_ENDIAN_BYTE_ORDER;
+#else
+	return _flipBytes ? BIG_ENDIAN_BYTE_ORDER : LITTLE_ENDIAN_BYTE_ORDER;
+#endif
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_BinaryWriter_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Buffer.h b/base/poco/Foundation/include/Poco/Buffer.h
new file mode 100644
index 00000000000..ae8599f08d5
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Buffer.h
@@ -0,0 +1,329 @@
+//
+// Buffer.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Buffer
+//
+// Definition of the Buffer class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Buffer_INCLUDED
+#define Foundation_Buffer_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include <cstring>
+#include <cstddef>
+
+
+namespace Poco {
+
+
+template <class T>
+class Buffer
+	/// A buffer class that allocates a buffer of a given type and size
+	/// in the constructor and deallocates the buffer in the destructor.
+	///
+	/// This class is useful everywhere where a temporary buffer
+	/// is needed.
+{
+public:
+	Buffer(std::size_t capacity):
+		_capacity(capacity),
+		_used(capacity),
+		_ptr(0),
+		_ownMem(true)
+		/// Creates and allocates the Buffer.
+	{
+		if (capacity > 0)
+		{
+			_ptr = new T[capacity];
+		}
+	}
+
+	Buffer(T* pMem, std::size_t length):
+		_capacity(length),
+		_used(length),
+		_ptr(pMem),
+		_ownMem(false)
+		/// Creates the Buffer. Length argument specifies the length
+		/// of the supplied memory pointed to by pMem in the number
+		/// of elements of type T. Supplied pointer is considered
+		/// blank and not owned by Buffer, so in this case Buffer
+		/// only acts as a wrapper around externally supplied
+		/// (and lifetime-managed) memory.
+	{
+	}
+
+	Buffer(const T* pMem, std::size_t length):
+		_capacity(length),
+		_used(length),
+		_ptr(0),
+		_ownMem(true)
+		/// Creates and allocates the Buffer; copies the contents of
+		/// the supplied memory into the buffer. Length argument specifies
+		/// the length of the supplied memory pointed to by pMem in the
+		/// number of elements of type T.
+	{
+		if (_capacity > 0)
+		{
+			_ptr = new T[_capacity];
+			std::memcpy(_ptr, pMem, _used * sizeof(T));
+		}
+	}
+
+	Buffer(const Buffer& other):
+		/// Copy constructor.
+		_capacity(other._used),
+		_used(other._used),
+		_ptr(0),
+		_ownMem(true)
+	{
+		if (_used)
+		{
+			_ptr = new T[_used];
+			std::memcpy(_ptr, other._ptr, _used * sizeof(T));
+		}
+	}
+
+	Buffer& operator = (const Buffer& other)
+		/// Assignment operator.
+	{
+		if (this != &other)
+		{
+			Buffer tmp(other);
+			swap(tmp);
+		}
+
+		return *this;
+	}
+
+	~Buffer()
+		/// Destroys the Buffer.
+	{
+		if (_ownMem) delete [] _ptr;
+	}
+
+	void resize(std::size_t newCapacity, bool preserveContent = true)
+		/// Resizes the buffer capacity and size. If preserveContent is true,
+		/// the content of the old buffer is copied over to the
+		/// new buffer. The new capacity can be larger or smaller than
+		/// the current one; if it is smaller, capacity will remain intact.
+		/// Size will always be set to the new capacity.
+		///
+		/// Buffers only wrapping externally owned storage can not be
+		/// resized. If resize is attempted on those, IllegalAccessException
+		/// is thrown.
+	{
+		if (!_ownMem) throw Poco::InvalidAccessException("Cannot resize buffer which does not own its storage.");
+
+		if (newCapacity > _capacity)
+		{
+			T* ptr = new T[newCapacity];
+			if (preserveContent && _used > 0)
+			{
+				std::memcpy(ptr, _ptr, _used * sizeof(T));
+			}
+			delete [] _ptr;
+			_ptr = ptr;
+			_capacity = newCapacity;
+		}
+
+		_used = newCapacity;
+	}
+
+	void setCapacity(std::size_t newCapacity, bool preserveContent = true)
+		/// Sets the buffer capacity. If preserveContent is true,
+		/// the content of the old buffer is copied over to the
+		/// new buffer. The new capacity can be larger or smaller than
+		/// the current one; size will be set to the new capacity only if
+		/// new capacity is smaller than the current size, otherwise it will
+		/// remain intact.
+		///
+		/// Buffers only wrapping externally owned storage can not be
+		/// resized. If resize is attempted on those, IllegalAccessException
+		/// is thrown.
+	{
+		if (!_ownMem) throw Poco::InvalidAccessException("Cannot resize buffer which does not own its storage.");
+
+		if (newCapacity != _capacity)
+		{
+			T* ptr = 0;
+			if (newCapacity > 0)
+			{
+				ptr = new T[newCapacity];
+				if (preserveContent)
+				{
+					std::size_t newSz = _used < newCapacity ? _used : newCapacity;
+					std::memcpy(ptr, _ptr, newSz * sizeof(T));
+				}
+			}
+			delete [] _ptr;
+			_ptr = ptr;
+			_capacity = newCapacity;
+
+			if (newCapacity < _used) _used = newCapacity;
+		}
+	}
+
+	void assign(const T* buf, std::size_t sz)
+		/// Assigns the argument buffer to this buffer.
+		/// If necessary, resizes the buffer.
+	{
+		if (0 == sz) return;
+		if (sz > _capacity) resize(sz, false);
+		std::memcpy(_ptr, buf, sz * sizeof(T));
+		_used = sz;
+	}
+
+	void append(const T* buf, std::size_t sz)
+		/// Resizes this buffer and appends the argument buffer.
+	{
+		if (0 == sz) return;
+		resize(_used + sz, true);
+		std::memcpy(_ptr + _used - sz, buf, sz * sizeof(T));
+	}
+
+	void append(T val)
+		/// Resizes this buffer by one element and appends the argument value.
+	{
+		resize(_used + 1, true);
+		_ptr[_used - 1] = val;
+	}
+
+	void append(const Buffer& buf)
+		/// Resizes this buffer and appends the argument buffer.
+	{
+		append(buf.begin(), buf.size());
+	}
+
+	std::size_t capacity() const
+		/// Returns the allocated memory size in elements.
+	{
+		return _capacity;
+	}
+
+	std::size_t capacityBytes() const
+		/// Returns the allocated memory size in bytes.
+	{
+		return _capacity * sizeof(T);
+	}
+
+	void swap(Buffer& other)
+	/// Swaps the buffer with another one.
+	{
+		using std::swap;
+
+		swap(_ptr, other._ptr);
+		swap(_capacity, other._capacity);
+		swap(_used, other._used);
+	}
+
+	bool operator == (const Buffer& other) const
+		/// Compare operator.
+	{
+		if (this != &other)
+		{
+			if (_used == other._used)
+			{
+				if (std::memcmp(_ptr, other._ptr, _used * sizeof(T)) == 0)
+				{
+					return true;
+				}
+			}
+			return false;
+		}
+
+		return true;
+	}
+
+	bool operator != (const Buffer& other) const
+		/// Compare operator.
+	{
+		return !(*this == other);
+	}
+
+	void clear()
+		/// Sets the contents of the buffer to zero.
+	{
+		std::memset(_ptr, 0, _used * sizeof(T));
+	}
+
+	std::size_t size() const
+		/// Returns the used size of the buffer in elements.
+	{
+		return _used;
+	}
+
+	std::size_t sizeBytes() const
+		/// Returns the used size of the buffer in bytes.
+	{
+		return _used * sizeof(T);
+	}
+
+	T* begin()
+		/// Returns a pointer to the beginning of the buffer.
+	{
+		return _ptr;
+	}
+
+	const T* begin() const
+		/// Returns a pointer to the beginning of the buffer.
+	{
+		return _ptr;
+	}
+
+	T* end()
+		/// Returns a pointer to end of the buffer.
+	{
+		return _ptr + _used;
+	}
+
+	const T* end() const
+		/// Returns a pointer to the end of the buffer.
+	{
+		return _ptr + _used;
+	}
+
+	bool empty() const
+		/// Return true if buffer is empty.
+	{
+		return 0 == _used;
+	}
+
+	T& operator [] (std::size_t index)
+	{
+		poco_assert (index < _used);
+
+		return _ptr[index];
+	}
+
+	const T& operator [] (std::size_t index) const
+	{
+		poco_assert (index < _used);
+
+		return _ptr[index];
+	}
+
+private:
+	Buffer();
+
+	std::size_t _capacity;
+	std::size_t _used;
+	T*          _ptr;
+	bool        _ownMem;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Buffer_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/BufferAllocator.h b/base/poco/Foundation/include/Poco/BufferAllocator.h
new file mode 100644
index 00000000000..ac71746b286
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/BufferAllocator.h
@@ -0,0 +1,52 @@
+//
+// BufferAllocator.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  BufferAllocator
+//
+// Definition of the BufferAllocator class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_BufferAllocator_INCLUDED
+#define Foundation_BufferAllocator_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <ios>
+#include <cstddef>
+
+
+namespace Poco {
+
+
+template <typename ch>
+class BufferAllocator
+	/// The BufferAllocator used if no specific
+	/// BufferAllocator has been specified.
+{
+public:
+	typedef ch char_type;
+
+	static char_type* allocate(std::streamsize size)
+	{
+		return new char_type[static_cast<std::size_t>(size)];
+	}
+	
+	static void deallocate(char_type* ptr, std::streamsize /*size*/) throw()
+	{
+		delete [] ptr;
+	}
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_BufferAllocator_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/BufferedBidirectionalStreamBuf.h b/base/poco/Foundation/include/Poco/BufferedBidirectionalStreamBuf.h
new file mode 100644
index 00000000000..321c3b1adb9
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/BufferedBidirectionalStreamBuf.h
@@ -0,0 +1,181 @@
+//
+// BufferedBidirectionalStreamBuf.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  StreamBuf
+//
+// Definition of template BasicBufferedBidirectionalStreamBuf and class BufferedBidirectionalStreamBuf.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_BufferedBidirectionalStreamBuf_INCLUDED
+#define Foundation_BufferedBidirectionalStreamBuf_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/BufferAllocator.h"
+#include "Poco/StreamUtil.h"
+#include <streambuf>
+#include <iosfwd>
+#include <ios>
+
+
+namespace Poco {
+
+
+template <typename ch, typename tr, typename ba = BufferAllocator<ch> > 
+class BasicBufferedBidirectionalStreamBuf: public std::basic_streambuf<ch, tr>
+	/// This is an implementation of a buffered bidirectional 
+	/// streambuf that greatly simplifies the implementation of
+	/// custom streambufs of various kinds.
+	/// Derived classes only have to override the methods
+	/// readFromDevice() or writeToDevice().
+	///
+	/// In contrast to BasicBufferedStreambuf, this class supports
+	/// simultaneous read and write access, so in addition to
+	/// istream and ostream this streambuf can also be used
+	/// for implementing an iostream.
+{
+protected:
+	typedef std::basic_streambuf<ch, tr> Base;
+	typedef std::basic_ios<ch, tr> IOS;
+	typedef ch char_type;
+	typedef tr char_traits;
+	typedef ba Allocator;
+	typedef typename Base::int_type int_type;
+	typedef typename Base::pos_type pos_type;
+	typedef typename Base::off_type off_type;
+	typedef typename IOS::openmode openmode;
+
+public:
+	BasicBufferedBidirectionalStreamBuf(std::streamsize bufferSize, openmode mode):
+		_bufsize(bufferSize),
+		_pReadBuffer(Allocator::allocate(_bufsize)),
+		_pWriteBuffer(Allocator::allocate(_bufsize)),
+		_mode(mode)
+	{
+		resetBuffers();
+	}
+
+	~BasicBufferedBidirectionalStreamBuf()
+	{
+		Allocator::deallocate(_pReadBuffer, _bufsize);
+		Allocator::deallocate(_pWriteBuffer, _bufsize);
+	}
+	
+	virtual int_type overflow(int_type c)
+	{
+		if (!(_mode & IOS::out)) return char_traits::eof();
+
+		if (flushBuffer() == std::streamsize(-1)) return char_traits::eof();
+		if (c != char_traits::eof()) 
+		{
+			*this->pptr() = char_traits::to_char_type(c);
+			this->pbump(1);
+		}
+
+		return c;
+	}
+
+	virtual int_type underflow()
+	{
+		if (!(_mode & IOS::in)) return char_traits::eof();
+
+		if (this->gptr() && (this->gptr() < this->egptr()))
+			return char_traits::to_int_type(*this->gptr());
+
+		int putback = int(this->gptr() - this->eback());
+		if (putback > 4) putback = 4;
+
+		char_traits::move(_pReadBuffer + (4 - putback), this->gptr() - putback, putback);
+
+		int n = readFromDevice(_pReadBuffer + 4, _bufsize - 4);
+		if (n <= 0) return char_traits::eof();
+
+		this->setg(_pReadBuffer + (4 - putback), _pReadBuffer + 4, _pReadBuffer + 4 + n);
+
+		// return next character
+		return char_traits::to_int_type(*this->gptr());    
+	}
+
+	virtual int sync()
+	{
+		if (this->pptr() && this->pptr() > this->pbase()) 
+		{
+			if (flushBuffer() == -1) return -1;
+		}
+		return 0;
+	}
+
+protected:
+	void setMode(openmode mode)
+	{
+		_mode = mode;
+	}
+
+	openmode getMode() const
+	{
+		return _mode;
+	}
+	
+	void resetBuffers()
+	{
+		this->setg(_pReadBuffer + 4, _pReadBuffer + 4, _pReadBuffer + 4);
+		this->setp(_pWriteBuffer, _pWriteBuffer + _bufsize);
+	}
+
+private:
+	virtual int readFromDevice(char_type* /*buffer*/, std::streamsize /*length*/)
+	{
+		return 0;
+	}
+
+	virtual int writeToDevice(const char_type* /*buffer*/, std::streamsize /*length*/)
+	{
+		return 0;
+	}
+
+	int flushBuffer()
+	{
+		int n = int(this->pptr() - this->pbase());
+		if (writeToDevice(this->pbase(), n) == n) 
+		{
+			this->pbump(-n);
+			return n;
+		}
+		return -1;
+	}
+
+	std::streamsize _bufsize;
+	char_type*      _pReadBuffer;
+	char_type*      _pWriteBuffer;
+	openmode        _mode;
+
+	BasicBufferedBidirectionalStreamBuf(const BasicBufferedBidirectionalStreamBuf&);
+	BasicBufferedBidirectionalStreamBuf& operator = (const BasicBufferedBidirectionalStreamBuf&);
+};
+
+
+//
+// We provide an instantiation for char.
+//
+// Visual C++ needs a workaround - explicitly importing the template
+// instantiation - to avoid duplicate symbols due to multiple
+// instantiations in different libraries.
+//
+#if defined(_MSC_VER) && defined(POCO_DLL) && !defined(Foundation_EXPORTS) 
+template class Foundation_API BasicBufferedBidirectionalStreamBuf<char, std::char_traits<char> >;
+#endif
+typedef BasicBufferedBidirectionalStreamBuf<char, std::char_traits<char> > BufferedBidirectionalStreamBuf;
+
+
+} // namespace Poco
+
+
+#endif // Foundation_BufferedBidirectionalStreamBuf_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/BufferedStreamBuf.h b/base/poco/Foundation/include/Poco/BufferedStreamBuf.h
new file mode 100644
index 00000000000..3e392152625
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/BufferedStreamBuf.h
@@ -0,0 +1,173 @@
+//
+// BufferedStreamBuf.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  StreamBuf
+//
+// Definition of template BasicBufferedStreamBuf and class BufferedStreamBuf.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_BufferedStreamBuf_INCLUDED
+#define Foundation_BufferedStreamBuf_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/BufferAllocator.h"
+#include "Poco/StreamUtil.h"
+#include <streambuf>
+#include <iosfwd>
+#include <ios>
+
+
+namespace Poco {
+
+
+template <typename ch, typename tr, typename ba = BufferAllocator<ch> > 
+class BasicBufferedStreamBuf: public std::basic_streambuf<ch, tr>
+	/// This is an implementation of a buffered streambuf
+	/// that greatly simplifies the implementation of
+	/// custom streambufs of various kinds.
+	/// Derived classes only have to override the methods
+	/// readFromDevice() or writeToDevice().
+	///
+	/// This streambuf only supports unidirectional streams.
+	/// In other words, the BasicBufferedStreamBuf can be
+	/// used for the implementation of an istream or an
+	/// ostream, but not for an iostream.
+{
+protected:
+	typedef std::basic_streambuf<ch, tr> Base;
+	typedef std::basic_ios<ch, tr> IOS;
+	typedef ch char_type;
+	typedef tr char_traits;
+	typedef ba Allocator;
+	typedef typename Base::int_type int_type;
+	typedef typename Base::pos_type pos_type;
+	typedef typename Base::off_type off_type;
+	typedef typename IOS::openmode openmode;
+
+public:
+	BasicBufferedStreamBuf(std::streamsize bufferSize, openmode mode):
+		_bufsize(bufferSize),
+		_pBuffer(Allocator::allocate(_bufsize)),
+		_mode(mode)
+	{
+		this->setg(_pBuffer + 4, _pBuffer + 4, _pBuffer + 4);
+		this->setp(_pBuffer, _pBuffer + _bufsize);
+	}
+
+	~BasicBufferedStreamBuf()
+	{
+		Allocator::deallocate(_pBuffer, _bufsize);
+	}
+
+	virtual int_type overflow(int_type c)
+	{
+		if (!(_mode & IOS::out)) return char_traits::eof();
+
+		if (flushBuffer() == std::streamsize(-1)) return char_traits::eof();
+		if (c != char_traits::eof()) 
+		{
+			*this->pptr() = char_traits::to_char_type(c);
+			this->pbump(1);
+		}
+
+		return c;
+	}
+
+	virtual int_type underflow()
+	{
+		if (!(_mode & IOS::in)) return char_traits::eof();
+
+		if (this->gptr() && (this->gptr() < this->egptr()))
+			return char_traits::to_int_type(*this->gptr());
+
+		int putback = int(this->gptr() - this->eback());
+		if (putback > 4) putback = 4;
+
+		char_traits::move(_pBuffer + (4 - putback), this->gptr() - putback, putback);
+
+		int n = readFromDevice(_pBuffer + 4, _bufsize - 4);
+		if (n <= 0) return char_traits::eof();
+
+		this->setg(_pBuffer + (4 - putback), _pBuffer + 4, _pBuffer + 4 + n);
+
+		// return next character
+		return char_traits::to_int_type(*this->gptr());    
+	}
+
+	virtual int sync()
+	{
+		if (this->pptr() && this->pptr() > this->pbase()) 
+		{
+			if (flushBuffer() == -1) return -1;
+		}
+		return 0;
+	}
+
+protected:
+	void setMode(openmode mode)
+	{
+		_mode = mode;
+	}
+	
+	openmode getMode() const
+	{
+		return _mode;
+	}
+
+private:
+	virtual int readFromDevice(char_type* /*buffer*/, std::streamsize /*length*/)
+	{
+		return 0;
+	}
+
+	virtual int writeToDevice(const char_type* /*buffer*/, std::streamsize /*length*/)
+	{
+		return 0;
+	}
+
+	int flushBuffer()
+	{
+		int n = int(this->pptr() - this->pbase());
+		if (writeToDevice(this->pbase(), n) == n) 
+		{
+			this->pbump(-n);
+			return n;
+		}
+		return -1;
+	}
+
+	std::streamsize _bufsize;
+	char_type*      _pBuffer;
+	openmode        _mode;
+
+	BasicBufferedStreamBuf(const BasicBufferedStreamBuf&);
+	BasicBufferedStreamBuf& operator = (const BasicBufferedStreamBuf&);
+};
+
+
+//
+// We provide an instantiation for char.
+//
+// Visual C++ needs a workaround - explicitly importing the template
+// instantiation - to avoid duplicate symbols due to multiple
+// instantiations in different libraries.
+//
+#if defined(_MSC_VER) && defined(POCO_DLL) && !defined(Foundation_EXPORTS)
+template class Foundation_API BasicBufferedStreamBuf<char, std::char_traits<char> >;
+#endif
+typedef BasicBufferedStreamBuf<char, std::char_traits<char> > BufferedStreamBuf;
+
+
+} // namespace Poco
+
+
+#endif // Foundation_BufferedStreamBuf_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Bugcheck.h b/base/poco/Foundation/include/Poco/Bugcheck.h
new file mode 100644
index 00000000000..ca475b8870b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Bugcheck.h
@@ -0,0 +1,206 @@
+//
+// Bugcheck.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Bugcheck
+//
+// Definition of the Bugcheck class and the self-testing macros.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Bugcheck_INCLUDED
+#define Foundation_Bugcheck_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <string>
+#include <cstdlib>
+#if defined(_DEBUG)
+#	include <iostream>
+#endif
+
+
+namespace Poco {
+
+
+class Foundation_API Bugcheck
+	/// This class provides some static methods that are
+	/// used by the
+	/// poco_assert_dbg(), poco_assert(), poco_check_ptr(), 
+	/// poco_bugcheck() and poco_unexpected() macros. 
+	/// You should not invoke these methods
+	/// directly. Use the macros instead, as they
+	/// automatically provide useful context information.
+{
+public:
+	static void assertion(const char* cond, const char* file, int line, const char* text = 0);
+		/// An assertion failed. Break into the debugger, if
+		/// possible, then throw an AssertionViolationException.
+
+	static void nullPointer(const char* ptr, const char* file, int line);
+		/// An null pointer was encountered. Break into the debugger, if
+		/// possible, then throw an NullPointerException.
+
+	static void bugcheck(const char* file, int line);
+		/// An internal error was encountered. Break into the debugger, if
+		/// possible, then throw an BugcheckException.
+
+	static void bugcheck(const char* msg, const char* file, int line);
+		/// An internal error was encountered. Break into the debugger, if
+		/// possible, then throw an BugcheckException.
+
+	static void unexpected(const char* file, int line);
+		/// An exception was caught in a destructor. Break into debugger,
+		/// if possible and report exception. Must only be called from
+		/// within a catch () block as it rethrows the exception to
+		/// determine its class.
+
+	static void debugger(const char* file, int line);
+		/// An internal error was encountered. Break into the debugger, if
+		/// possible.
+
+	static void debugger(const char* msg, const char* file, int line);
+		/// An internal error was encountered. Break into the debugger, if
+		/// possible.
+
+protected:
+	static std::string what(const char* msg, const char* file, int line, const char* text = 0);
+};
+
+
+} // namespace Poco
+
+
+//
+// useful macros (these automatically supply line number and file name)
+//
+#if defined(__KLOCWORK__) || defined(__clang_analyzer__)
+
+
+// Short-circuit these macros when under static analysis.
+// Ideally, static analysis tools should understand and reason correctly about
+// noreturn methods such as Bugcheck::bugcheck(). In practice, they don't.
+// Help them by turning these macros into std::abort() as described here:
+// https://developer.klocwork.com/documentation/en/insight/10-1/tuning-cc-analysis#Usingthe__KLOCWORK__macro
+
+#include <cstdlib> // for abort
+#define poco_assert_dbg(cond)           do { if (!(cond)) std::abort(); } while (0)
+#define poco_assert_msg_dbg(cond, text) do { if (!(cond)) std::abort(); } while (0)
+#define poco_assert(cond)               do { if (!(cond)) std::abort(); } while (0)
+#define poco_assert_msg(cond, text)     do { if (!(cond)) std::abort(); } while (0)
+#define poco_check_ptr(ptr)             do { if (!(ptr)) std::abort(); } while (0)
+#define poco_bugcheck()                 do { std::abort(); } while (0)
+#define poco_bugcheck_msg(msg)          do { std::abort(); } while (0)
+
+
+#else // defined(__KLOCWORK__) || defined(__clang_analyzer__)
+
+
+#if defined(_DEBUG)
+	#define poco_assert_dbg(cond) \
+		if (!(cond)) Poco::Bugcheck::assertion(#cond, __FILE__, __LINE__); else (void) 0
+
+	#define poco_assert_msg_dbg(cond, text) \
+		if (!(cond)) Poco::Bugcheck::assertion(#cond, __FILE__, __LINE__, text); else (void) 0
+#else
+	#define poco_assert_msg_dbg(cond, text)
+	#define poco_assert_dbg(cond)
+#endif
+
+
+#define poco_assert(cond) \
+	if (!(cond)) Poco::Bugcheck::assertion(#cond, __FILE__, __LINE__); else (void) 0
+
+
+#define poco_assert_msg(cond, text) \
+	if (!(cond)) Poco::Bugcheck::assertion(#cond, __FILE__, __LINE__, text); else (void) 0
+
+
+#define poco_check_ptr(ptr) \
+	if (!(ptr)) Poco::Bugcheck::nullPointer(#ptr, __FILE__, __LINE__); else (void) 0
+
+
+#define poco_bugcheck() \
+	Poco::Bugcheck::bugcheck(__FILE__, __LINE__)
+
+
+#define poco_bugcheck_msg(msg) \
+	Poco::Bugcheck::bugcheck(msg, __FILE__, __LINE__)
+
+
+#endif // defined(__KLOCWORK__) || defined(__clang_analyzer__)
+
+
+#define poco_unexpected() \
+	Poco::Bugcheck::unexpected(__FILE__, __LINE__);
+
+
+#define poco_debugger() \
+	Poco::Bugcheck::debugger(__FILE__, __LINE__)
+
+
+#define poco_debugger_msg(msg) \
+	Poco::Bugcheck::debugger(msg, __FILE__, __LINE__)
+
+
+#if defined(_DEBUG)
+#	define poco_stdout_dbg(outstr) \
+	std::cout << __FILE__ << '(' << std::dec << __LINE__ << "):" << outstr << std::endl;
+#else
+#	define poco_stdout_dbg(outstr)
+#endif
+
+
+#if defined(_DEBUG)
+#	define poco_stderr_dbg(outstr) \
+		std::cerr << __FILE__ << '(' << std::dec << __LINE__ << "):" << outstr << std::endl;
+#else
+#	define poco_stderr_dbg(outstr)
+#endif
+
+
+//
+// poco_static_assert
+//
+// The following was ported from <boost/static_assert.hpp>
+//
+
+
+template <bool x>
+struct POCO_STATIC_ASSERTION_FAILURE;
+
+
+template <>
+struct POCO_STATIC_ASSERTION_FAILURE<true>
+{
+	enum
+	{
+		value = 1
+	};
+};
+
+
+template <int x> 
+struct poco_static_assert_test
+{
+};
+
+
+#if defined(__GNUC__) && (__GNUC__ == 3) && ((__GNUC_MINOR__ == 3) || (__GNUC_MINOR__ == 4))
+#define poco_static_assert(B) \
+	typedef char POCO_JOIN(poco_static_assert_typedef_, __LINE__) \
+        [POCO_STATIC_ASSERTION_FAILURE<(bool) (B)>::value]
+#else
+#define poco_static_assert(B) \
+	typedef poco_static_assert_test<sizeof(POCO_STATIC_ASSERTION_FAILURE<(bool) (B)>)> \
+		POCO_JOIN(poco_static_assert_typedef_, __LINE__) POCO_UNUSED
+#endif
+
+
+#endif // Foundation_Bugcheck_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ByteOrder.h b/base/poco/Foundation/include/Poco/ByteOrder.h
new file mode 100644
index 00000000000..97732bcd49c
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ByteOrder.h
@@ -0,0 +1,239 @@
+//
+// ByteOrder.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  ByteOrder
+//
+// Copyright (c) 2004-2014, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ByteOrder_INCLUDED
+#define Foundation_ByteOrder_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Types.h"
+#if defined(_MSC_VER)
+#include <stdlib.h> // builtins
+#endif
+
+
+namespace Poco {
+
+
+class Foundation_API ByteOrder
+	/// This class contains a number of static methods
+	/// to convert between big-endian and little-endian
+	/// integers of various sizes.
+{
+public:
+	static Int16 flipBytes(Int16 value);
+	static UInt16 flipBytes(UInt16 value);
+	static Int32 flipBytes(Int32 value);
+	static UInt32 flipBytes(UInt32 value);
+#if defined(POCO_HAVE_INT64)
+	static Int64 flipBytes(Int64 value);
+	static UInt64 flipBytes(UInt64 value);
+#endif
+
+	static Int16 toBigEndian(Int16 value);
+	static UInt16 toBigEndian (UInt16 value);
+	static Int32 toBigEndian(Int32 value);
+	static UInt32 toBigEndian (UInt32 value);
+#if defined(POCO_HAVE_INT64)
+	static Int64 toBigEndian(Int64 value);
+	static UInt64 toBigEndian (UInt64 value);
+#endif
+
+	static Int16 fromBigEndian(Int16 value);
+	static UInt16 fromBigEndian (UInt16 value);
+	static Int32 fromBigEndian(Int32 value);
+	static UInt32 fromBigEndian (UInt32 value);
+#if defined(POCO_HAVE_INT64)
+	static Int64 fromBigEndian(Int64 value);
+	static UInt64 fromBigEndian (UInt64 value);
+#endif
+
+	static Int16 toLittleEndian(Int16 value);
+	static UInt16 toLittleEndian (UInt16 value);
+	static Int32 toLittleEndian(Int32 value);
+	static UInt32 toLittleEndian (UInt32 value);
+#if defined(POCO_HAVE_INT64)
+	static Int64 toLittleEndian(Int64 value);
+	static UInt64 toLittleEndian (UInt64 value);
+#endif
+
+	static Int16 fromLittleEndian(Int16 value);
+	static UInt16 fromLittleEndian (UInt16 value);
+	static Int32 fromLittleEndian(Int32 value);
+	static UInt32 fromLittleEndian (UInt32 value);
+#if defined(POCO_HAVE_INT64)
+	static Int64 fromLittleEndian(Int64 value);
+	static UInt64 fromLittleEndian (UInt64 value);
+#endif
+
+	static Int16 toNetwork(Int16 value);
+	static UInt16 toNetwork (UInt16 value);
+	static Int32 toNetwork(Int32 value);
+	static UInt32 toNetwork (UInt32 value);
+#if defined(POCO_HAVE_INT64)
+	static Int64 toNetwork(Int64 value);
+	static UInt64 toNetwork (UInt64 value);
+#endif
+
+	static Int16 fromNetwork(Int16 value);
+	static UInt16 fromNetwork (UInt16 value);
+	static Int32 fromNetwork(Int32 value);
+	static UInt32 fromNetwork (UInt32 value);
+#if defined(POCO_HAVE_INT64)
+	static Int64 fromNetwork(Int64 value);
+	static UInt64 fromNetwork (UInt64 value);
+#endif
+};
+
+
+#if !defined(POCO_NO_BYTESWAP_BUILTINS)
+	#if defined(_MSC_VER)
+		#if (POCO_MSVC_VERSION > 71)
+			#define POCO_HAVE_MSC_BYTESWAP 1
+		#endif
+	#elif defined(__clang__) 
+		#if __has_builtin(__builtin_bswap32)
+			#define POCO_HAVE_GCC_BYTESWAP 1
+		#endif
+	#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+		#define POCO_HAVE_GCC_BYTESWAP 1
+	#endif
+#endif
+
+
+//
+// inlines
+//
+inline UInt16 ByteOrder::flipBytes(UInt16 value)
+{
+#if defined(POCO_HAVE_MSC_BYTESWAP)
+	return _byteswap_ushort(value);
+#else
+	return ((value >> 8) & 0x00FF) | ((value << 8) & 0xFF00);
+#endif
+}
+
+
+inline Int16 ByteOrder::flipBytes(Int16 value)
+{
+	return Int16(flipBytes(UInt16(value)));
+}
+
+
+inline UInt32 ByteOrder::flipBytes(UInt32 value)
+{
+#if defined(POCO_HAVE_MSC_BYTESWAP)
+	return _byteswap_ulong(value);
+#elif defined(POCO_HAVE_GCC_BYTESWAP)
+	return __builtin_bswap32(value);
+#else
+	return ((value >> 24) & 0x000000FF) | ((value >> 8) & 0x0000FF00)
+	     | ((value << 8) & 0x00FF0000) | ((value << 24) & 0xFF000000);
+#endif
+}
+
+
+inline Int32 ByteOrder::flipBytes(Int32 value)
+{
+	return Int32(flipBytes(UInt32(value)));
+}
+
+
+#if defined(POCO_HAVE_INT64)
+inline UInt64 ByteOrder::flipBytes(UInt64 value)
+{
+#if defined(POCO_HAVE_MSC_BYTESWAP)
+	return _byteswap_uint64(value);
+#elif defined(POCO_HAVE_GCC_BYTESWAP)
+	return __builtin_bswap64(value);
+#else
+	UInt32 hi = UInt32(value >> 32);
+	UInt32 lo = UInt32(value & 0xFFFFFFFF);
+	return UInt64(flipBytes(hi)) | (UInt64(flipBytes(lo)) << 32);
+#endif
+}
+
+
+inline Int64 ByteOrder::flipBytes(Int64 value)
+{
+	return Int64(flipBytes(UInt64(value)));
+}
+#endif // POCO_HAVE_INT64
+
+
+//
+// some macro trickery to automate the method implementation
+//
+#define POCO_IMPLEMENT_BYTEORDER_NOOP_(op, type) \
+	inline type ByteOrder::op(type value)		\
+	{											\
+		return value;							\
+	}
+#define POCO_IMPLEMENT_BYTEORDER_FLIP_(op, type) \
+	inline type ByteOrder::op(type value)		\
+	{											\
+		return flipBytes(value);				\
+	}
+
+
+#if defined(POCO_HAVE_INT64)
+	#define POCO_IMPLEMENT_BYTEORDER_NOOP(op) \
+		POCO_IMPLEMENT_BYTEORDER_NOOP_(op, Int16)	\
+		POCO_IMPLEMENT_BYTEORDER_NOOP_(op, UInt16)	\
+		POCO_IMPLEMENT_BYTEORDER_NOOP_(op, Int32)	\
+		POCO_IMPLEMENT_BYTEORDER_NOOP_(op, UInt32)	\
+		POCO_IMPLEMENT_BYTEORDER_NOOP_(op, Int64)	\
+		POCO_IMPLEMENT_BYTEORDER_NOOP_(op, UInt64)
+	#define POCO_IMPLEMENT_BYTEORDER_FLIP(op) \
+		POCO_IMPLEMENT_BYTEORDER_FLIP_(op, Int16)	\
+		POCO_IMPLEMENT_BYTEORDER_FLIP_(op, UInt16)	\
+		POCO_IMPLEMENT_BYTEORDER_FLIP_(op, Int32)	\
+		POCO_IMPLEMENT_BYTEORDER_FLIP_(op, UInt32)	\
+		POCO_IMPLEMENT_BYTEORDER_FLIP_(op, Int64)	\
+		POCO_IMPLEMENT_BYTEORDER_FLIP_(op, UInt64)
+#else
+	#define POCO_IMPLEMENT_BYTEORDER_NOOP(op) \
+		POCO_IMPLEMENT_BYTEORDER_NOOP_(op, Int16)	\
+		POCO_IMPLEMENT_BYTEORDER_NOOP_(op, UInt16)	\
+		POCO_IMPLEMENT_BYTEORDER_NOOP_(op, Int32)	\
+		POCO_IMPLEMENT_BYTEORDER_NOOP_(op, UInt32)
+	#define POCO_IMPLEMENT_BYTEORDER_FLIP(op) \
+		POCO_IMPLEMENT_BYTEORDER_FLIP_(op, Int16)	\
+		POCO_IMPLEMENT_BYTEORDER_FLIP_(op, UInt16)	\
+		POCO_IMPLEMENT_BYTEORDER_FLIP_(op, Int32)	\
+		POCO_IMPLEMENT_BYTEORDER_FLIP_(op, UInt32)
+#endif
+
+
+#if defined(POCO_ARCH_BIG_ENDIAN)
+	#define POCO_IMPLEMENT_BYTEORDER_BIG POCO_IMPLEMENT_BYTEORDER_NOOP
+	#define POCO_IMPLEMENT_BYTEORDER_LIT POCO_IMPLEMENT_BYTEORDER_FLIP
+#else
+	#define POCO_IMPLEMENT_BYTEORDER_BIG POCO_IMPLEMENT_BYTEORDER_FLIP
+	#define POCO_IMPLEMENT_BYTEORDER_LIT POCO_IMPLEMENT_BYTEORDER_NOOP
+#endif
+
+
+POCO_IMPLEMENT_BYTEORDER_BIG(toBigEndian)
+POCO_IMPLEMENT_BYTEORDER_BIG(fromBigEndian)
+POCO_IMPLEMENT_BYTEORDER_BIG(toNetwork)
+POCO_IMPLEMENT_BYTEORDER_BIG(fromNetwork)
+POCO_IMPLEMENT_BYTEORDER_LIT(toLittleEndian)
+POCO_IMPLEMENT_BYTEORDER_LIT(fromLittleEndian)
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ByteOrder_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Channel.h b/base/poco/Foundation/include/Poco/Channel.h
new file mode 100644
index 00000000000..f820a2c3c71
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Channel.h
@@ -0,0 +1,78 @@
+//
+// Channel.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  Channel
+//
+// Definition of the Channel class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Channel_INCLUDED
+#define Foundation_Channel_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Configurable.h"
+#include "Poco/Mutex.h"
+#include "Poco/RefCountedObject.h"
+
+
+namespace Poco {
+
+
+class Message;
+
+
+class Foundation_API Channel: public Configurable, public RefCountedObject
+	/// The base class for all Channel classes.
+	///
+	/// Supports reference counting based garbage
+	/// collection and provides trivial implementations
+	/// of getProperty() and setProperty().
+{
+public:
+	Channel();
+		/// Creates the channel and initializes
+		/// the reference count to one.
+
+	virtual void open();
+		/// Does whatever is necessary to open the channel. 
+		/// The default implementation does nothing.
+		
+	virtual void close();
+		/// Does whatever is necessary to close the channel.
+		/// The default implementation does nothing.
+		
+	virtual void log(const Message& msg) = 0;
+		/// Logs the given message to the channel. Must be
+		/// overridden by subclasses.
+		///
+		/// If the channel has not been opened yet, the log()
+		/// method will open it.
+		
+	void setProperty(const std::string& name, const std::string& value);
+		/// Throws a PropertyNotSupportedException.
+
+	std::string getProperty(const std::string& name) const;
+		/// Throws a PropertyNotSupportedException.
+		
+protected:
+	virtual ~Channel();
+	
+private:
+	Channel(const Channel&);
+	Channel& operator = (const Channel&);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Channel_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Checksum.h b/base/poco/Foundation/include/Poco/Checksum.h
new file mode 100644
index 00000000000..3961bb762be
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Checksum.h
@@ -0,0 +1,108 @@
+//
+// Checksum.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Checksum
+//
+// Definition of the Checksum class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Checksum_INCLUDED
+#define Foundation_Checksum_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Checksum
+	/// This class calculates CRC-32 or Adler-32 checksums
+	/// for arbitrary data.
+	///
+	/// A cyclic redundancy check (CRC) is a type of hash function, which is used to produce a 
+	/// small, fixed-size checksum of a larger block of data, such as a packet of network 
+	/// traffic or a computer file. CRC-32 is one of the most commonly used CRC algorithms.
+	///
+	/// Adler-32 is a checksum algorithm which was invented by Mark Adler. 
+	/// It is almost as reliable as a 32-bit cyclic redundancy check for protecting against 
+	/// accidental modification of data, such as distortions occurring during a transmission, 
+	/// but is significantly faster to calculate in software.
+	
+{
+public:
+	enum Type
+	{
+		TYPE_ADLER32 = 0,
+		TYPE_CRC32
+	};
+
+	Checksum();
+		/// Creates a CRC-32 checksum initialized to 0.
+
+	Checksum(Type t);
+		/// Creates the Checksum, using the given type.
+
+	~Checksum();
+		/// Destroys the Checksum.
+
+	void update(const char* data, unsigned length);
+		/// Updates the checksum with the given data.
+
+	void update(const std::string& data);
+		/// Updates the checksum with the given data.
+
+	void update(char data);
+		/// Updates the checksum with the given data.
+
+	Poco::UInt32 checksum() const;
+		/// Returns the calculated checksum.
+
+	Type type() const;
+		/// Which type of checksum are we calulcating
+
+private:
+	Type         _type;
+	Poco::UInt32 _value;
+};
+
+
+//
+// inlines
+//
+inline void Checksum::update(const std::string& data)
+{
+	update(data.c_str(), static_cast<unsigned int>(data.size()));
+}
+
+
+inline void Checksum::update(char c)
+{
+	update(&c, 1);
+}
+
+
+inline Poco::UInt32 Checksum::checksum() const
+{
+	return _value;
+}
+
+
+inline Checksum::Type Checksum::type() const
+{
+	return _type;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Checksum_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ClassLibrary.h b/base/poco/Foundation/include/Poco/ClassLibrary.h
new file mode 100644
index 00000000000..14b10acb3dc
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ClassLibrary.h
@@ -0,0 +1,101 @@
+//
+// ClassLibrary.h
+//
+// Library: Foundation
+// Package: SharedLibrary
+// Module:  ClassLoader
+//
+// Definitions for class libraries.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ClassLibrary_INCLUDED
+#define Foundation_ClassLibrary_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Manifest.h"
+#include <typeinfo>
+
+
+#if defined(_WIN32)
+	#define POCO_LIBRARY_API __declspec(dllexport)
+#else
+	#define POCO_LIBRARY_API
+#endif
+
+
+//
+// the entry points for every class library
+//
+extern "C"
+{
+	bool POCO_LIBRARY_API pocoBuildManifest(Poco::ManifestBase* pManifest);
+	void POCO_LIBRARY_API pocoInitializeLibrary();
+	void POCO_LIBRARY_API pocoUninitializeLibrary();
+} 
+
+
+//
+// additional support for named manifests
+//
+#define POCO_DECLARE_NAMED_MANIFEST(name) \
+extern "C"	\
+{			\
+	bool POCO_LIBRARY_API POCO_JOIN(pocoBuildManifest, name)(Poco::ManifestBase* pManifest); \
+}
+
+
+//
+// Macros to automatically implement pocoBuildManifest
+//
+// usage:
+//
+// POCO_BEGIN_MANIFEST(MyBaseClass)
+//     POCO_EXPORT_CLASS(MyFirstClass)
+//     POCO_EXPORT_CLASS(MySecondClass)
+//     ...
+// POCO_END_MANIFEST
+//
+#define POCO_BEGIN_MANIFEST_IMPL(fnName, base) \
+	bool fnName(Poco::ManifestBase* pManifest_)										\
+	{																				\
+		typedef base _Base;															\
+		typedef Poco::Manifest<_Base> _Manifest;									\
+		std::string requiredType(typeid(_Manifest).name());							\
+		std::string actualType(pManifest_->className());							\
+		if (requiredType == actualType)												\
+		{																			\
+			Poco::Manifest<_Base>* pManifest = static_cast<_Manifest*>(pManifest_);
+
+
+#define POCO_BEGIN_MANIFEST(base) \
+	POCO_BEGIN_MANIFEST_IMPL(pocoBuildManifest, base)
+
+
+#define POCO_BEGIN_NAMED_MANIFEST(name, base)	\
+	POCO_DECLARE_NAMED_MANIFEST(name)			\
+	POCO_BEGIN_MANIFEST_IMPL(POCO_JOIN(pocoBuildManifest, name), base)
+
+
+#define POCO_END_MANIFEST \
+			return true;	\
+		}					\
+		else return false;	\
+	}
+
+
+#define POCO_EXPORT_CLASS(cls) \
+    pManifest->insert(new Poco::MetaObject<cls, _Base>(#cls));
+
+
+#define POCO_EXPORT_SINGLETON(cls) \
+	pManifest->insert(new Poco::MetaSingleton<cls, _Base>(#cls));
+
+
+#endif // Foundation_ClassLibrary_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ClassLoader.h b/base/poco/Foundation/include/Poco/ClassLoader.h
new file mode 100644
index 00000000000..450aec29285
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ClassLoader.h
@@ -0,0 +1,365 @@
+//
+// ClassLoader.h
+//
+// Library: Foundation
+// Package: SharedLibrary
+// Module:  ClassLoader
+//
+// Definition of the ClassLoader class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ClassLoader_INCLUDED
+#define Foundation_ClassLoader_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/MetaObject.h"
+#include "Poco/Manifest.h"
+#include "Poco/SharedLibrary.h"
+#include "Poco/Mutex.h"
+#include "Poco/Exception.h"
+#include <map>
+
+
+namespace Poco {
+
+
+template <class Base>
+class ClassLoader
+	/// The ClassLoader loads C++ classes from shared libraries
+	/// at runtime. It must be instantiated with a root class
+	/// of the loadable classes.
+	/// For a class to be loadable from a library, the library
+	/// must provide a Manifest of all the classes it contains.
+	/// The Manifest for a shared library can be easily built
+	/// with the help of the macros in the header file
+	/// "Foundation/ClassLibrary.h".
+	///
+	/// Starting with POCO release 1.3, a class library can
+	/// export multiple manifests. In addition to the default
+	/// (unnamed) manifest, multiple named manifests can
+	/// be exported, each having a different base class.
+	///
+	/// There is one important restriction: one instance of
+	/// ClassLoader can only load one manifest from a class
+	/// library.
+{
+public:
+	typedef AbstractMetaObject<Base> Meta;
+	typedef Manifest<Base> Manif;
+	typedef void (*InitializeLibraryFunc)();
+	typedef void (*UninitializeLibraryFunc)();
+	typedef bool (*BuildManifestFunc)(ManifestBase*);
+
+	struct LibraryInfo
+	{
+		SharedLibrary* pLibrary;
+		const Manif*   pManifest;
+		int            refCount;
+	};
+	typedef std::map<std::string, LibraryInfo> LibraryMap;
+
+	class Iterator
+		/// The ClassLoader's very own iterator class.
+	{
+	public:
+		typedef std::pair<std::string, const Manif*> Pair;
+
+		Iterator(const typename LibraryMap::const_iterator& it)
+		{
+			_it = it;
+		}
+		Iterator(const Iterator& it)
+		{
+			_it = it._it;
+		}
+		~Iterator()
+		{
+		}
+		Iterator& operator = (const Iterator& it)
+		{
+			_it = it._it;
+			return *this;
+		}
+		inline bool operator == (const Iterator& it) const
+		{
+			return _it == it._it;
+		}
+		inline bool operator != (const Iterator& it) const
+		{
+			return _it != it._it;
+		}
+		Iterator& operator ++ () // prefix
+		{
+			++_it;
+			return *this;
+		}
+		Iterator operator ++ (int) // postfix
+		{
+			Iterator result(_it);
+			++_it;
+			return result;
+		}
+		inline const Pair* operator * () const
+		{
+			_pair.first  = _it->first;
+			_pair.second = _it->second.pManifest;
+			return &_pair;
+		}
+		inline const Pair* operator -> () const
+		{
+			_pair.first  = _it->first;
+			_pair.second = _it->second.pManifest;
+			return &_pair;
+		}
+
+	private:
+		typename LibraryMap::const_iterator _it;
+		mutable Pair _pair;
+	};
+
+	ClassLoader()
+		/// Creates the ClassLoader.
+	{
+	}
+
+	virtual ~ClassLoader()
+		/// Destroys the ClassLoader.
+	{
+		for (typename LibraryMap::const_iterator it = _map.begin(); it != _map.end(); ++it)
+		{
+			delete it->second.pLibrary;
+			delete it->second.pManifest;
+		}
+	}
+
+	void loadLibrary(const std::string& path, const std::string& manifest)
+		/// Loads a library from the given path, using the given manifest. 
+		/// Does nothing if the library is already loaded.
+		/// Throws a LibraryLoadException if the library
+		/// cannot be loaded or does not have a Manifest.
+		/// If the library exports a function named "pocoInitializeLibrary",
+		/// this function is executed.
+		/// If called multiple times for the same library,
+		/// the number of calls to unloadLibrary() must be the same
+		/// for the library to become unloaded.
+	{
+		FastMutex::ScopedLock lock(_mutex);
+
+		typename LibraryMap::iterator it = _map.find(path);
+		if (it == _map.end())
+		{
+			LibraryInfo li;
+			li.pLibrary  = 0;
+			li.pManifest = 0;
+			li.refCount  = 1;
+			try
+			{
+				li.pLibrary  = new SharedLibrary(path);
+				li.pManifest = new Manif();
+				std::string pocoBuildManifestSymbol("pocoBuildManifest");
+				pocoBuildManifestSymbol.append(manifest);
+				if (li.pLibrary->hasSymbol("pocoInitializeLibrary"))
+				{
+					InitializeLibraryFunc initializeLibrary = (InitializeLibraryFunc) li.pLibrary->getSymbol("pocoInitializeLibrary");
+					initializeLibrary();
+				}
+				if (li.pLibrary->hasSymbol(pocoBuildManifestSymbol))
+				{
+					BuildManifestFunc buildManifest = (BuildManifestFunc) li.pLibrary->getSymbol(pocoBuildManifestSymbol);
+					if (buildManifest(const_cast<Manif*>(li.pManifest)))
+						_map[path] = li;
+					else
+						throw LibraryLoadException(std::string("Manifest class mismatch in ") + path, manifest);
+				}
+				else throw LibraryLoadException(std::string("No manifest in ") + path, manifest);
+			}
+			catch (...)
+			{
+				delete li.pLibrary;
+				delete li.pManifest;
+				throw;
+			}
+		}
+		else
+		{
+			++it->second.refCount;
+		}
+	}
+
+	void loadLibrary(const std::string& path)
+		/// Loads a library from the given path. Does nothing
+		/// if the library is already loaded.
+		/// Throws a LibraryLoadException if the library
+		/// cannot be loaded or does not have a Manifest.
+		/// If the library exports a function named "pocoInitializeLibrary",
+		/// this function is executed.
+		/// If called multiple times for the same library,
+		/// the number of calls to unloadLibrary() must be the same
+		/// for the library to become unloaded.
+		///
+		/// Equivalent to loadLibrary(path, "").
+	{
+		loadLibrary(path, "");
+	}
+		
+	void unloadLibrary(const std::string& path)
+		/// Unloads the given library. 
+		/// Be extremely cautious when unloading shared libraries.
+		/// If objects from the library are still referenced somewhere,
+		/// a total crash is very likely.
+		/// If the library exports a function named "pocoUninitializeLibrary",
+		/// this function is executed before it is unloaded.
+		/// If loadLibrary() has been called multiple times for the same
+		/// library, the number of calls to unloadLibrary() must be the same
+		/// for the library to become unloaded.
+	{
+		FastMutex::ScopedLock lock(_mutex);
+
+		typename LibraryMap::iterator it = _map.find(path);
+		if (it != _map.end())
+		{
+			if (--it->second.refCount == 0)
+			{
+				if (it->second.pLibrary->hasSymbol("pocoUninitializeLibrary"))
+				{
+					UninitializeLibraryFunc uninitializeLibrary = (UninitializeLibraryFunc) it->second.pLibrary->getSymbol("pocoUninitializeLibrary");
+					uninitializeLibrary();
+				}
+				delete it->second.pManifest;
+				it->second.pLibrary->unload();
+				delete it->second.pLibrary;
+				_map.erase(it);
+			}
+		}
+		else throw NotFoundException(path);
+	}
+
+	const Meta* findClass(const std::string& className) const
+		/// Returns a pointer to the MetaObject for the given
+		/// class, or a null pointer if the class is not known.
+	{
+		FastMutex::ScopedLock lock(_mutex);
+
+		for (typename LibraryMap::const_iterator it = _map.begin(); it != _map.end(); ++it)
+		{
+			const Manif* pManif = it->second.pManifest;
+			typename Manif::Iterator itm = pManif->find(className);
+			if (itm != pManif->end())
+				return *itm;
+		}
+		return 0;
+	}
+	
+	const Meta& classFor(const std::string& className) const
+		/// Returns a reference to the MetaObject for the given
+		/// class. Throws a NotFoundException if the class
+		/// is not known.
+	{
+		const Meta* pMeta = findClass(className);
+		if (pMeta)
+			return *pMeta;
+		else
+			throw NotFoundException(className);
+	}
+	
+	Base* create(const std::string& className) const
+		/// Creates an instance of the given class.
+		/// Throws a NotFoundException if the class
+		/// is not known.
+	{
+		return classFor(className).create();
+	}
+	
+	Base& instance(const std::string& className) const
+		/// Returns a reference to the sole instance of
+		/// the given class. The class must be a singleton,
+		/// otherwise an InvalidAccessException will be thrown.
+		/// Throws a NotFoundException if the class
+		/// is not known.
+	{
+		return classFor(className).instance();
+	}
+	
+	bool canCreate(const std::string& className) const
+		/// Returns true if create() can create new instances
+		/// of the class.
+	{
+		return classFor(className).canCreate();
+	}
+
+	void destroy(const std::string& className, Base* pObject) const
+		/// Destroys the object pObject points to.
+		/// Does nothing if object is not found.
+	{
+		classFor(className).destroy(pObject);
+	}
+
+	bool isAutoDelete(const std::string& className, Base* pObject) const
+		/// Returns true if the object is automatically
+		/// deleted by its meta object.
+	{
+		return classFor(className).isAutoDelete(pObject);
+	}
+	
+	const Manif* findManifest(const std::string& path) const
+		/// Returns a pointer to the Manifest for the given
+		/// library, or a null pointer if the library has not been loaded.
+	{
+		FastMutex::ScopedLock lock(_mutex);
+
+		typename LibraryMap::const_iterator it = _map.find(path);
+		if (it != _map.end())
+			return it->second.pManifest;
+		else
+			return 0;
+	}
+	
+	const Manif& manifestFor(const std::string& path) const
+		/// Returns a reference to the Manifest for the given library
+		/// Throws a NotFoundException if the library has not been loaded.
+	{
+		const Manif* pManif = findManifest(path);
+		if (pManif)
+			return *pManif;
+		else
+			throw NotFoundException(path);
+	}
+
+	bool isLibraryLoaded(const std::string& path) const
+		/// Returns true if the library with the given name
+		/// has already been loaded.
+	{
+		return findManifest(path) != 0;
+	}
+
+	Iterator begin() const
+	{
+		FastMutex::ScopedLock lock(_mutex);
+
+		return Iterator(_map.begin());
+	}
+
+	Iterator end() const
+	{
+		FastMutex::ScopedLock lock(_mutex);
+
+		return Iterator(_map.end());
+	}
+
+private:
+	LibraryMap _map;
+	mutable FastMutex _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ClassLoader_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Clock.h b/base/poco/Foundation/include/Poco/Clock.h
new file mode 100644
index 00000000000..43bb22f6406
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Clock.h
@@ -0,0 +1,238 @@
+//
+// Clock.h
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  Clock
+//
+// Definition of the Clock class.
+//
+// Copyright (c) 2013, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Clock_INCLUDED
+#define Foundation_Clock_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Clock
+	/// A Clock stores a monotonic* clock value
+	/// with (theoretical) microseconds resolution.
+	/// Clocks can be compared with each other
+	/// and simple arithmetics are supported.
+	///
+	/// [*] Note that Clock values are only monotonic if
+	/// the operating system provides a monotonic clock.
+	/// The monotonic() function can be used to check whether
+	/// the system's clock is monotonic.
+	///
+	/// Monotonic Clock is available on Windows, Linux, OS X 
+	/// and on POSIX platforms supporting clock_gettime() with CLOCK_MONOTONIC.	  
+	///
+	/// Clock values are relative to a system-dependent epoch time
+	/// (usually the system's startup time) and have no relation
+	/// to the time of day.
+{
+public:
+	typedef Int64 ClockVal;
+		/// Monotonic clock value in microsecond resolution.
+
+	typedef Int64 ClockDiff;
+		/// Difference between two ClockVal values in microseconds.
+
+	static const ClockVal CLOCKVAL_MIN; /// Minimum clock value.
+	static const ClockVal CLOCKVAL_MAX; /// Maximum clock value.
+
+	Clock();
+		/// Creates a Clock with the current system clock value.
+		
+	Clock(ClockVal tv);
+		/// Creates a Clock from the given clock value.
+		
+	Clock(const Clock& other);
+		/// Copy constructor.
+		
+	~Clock();
+		/// Destroys the Clock.
+		
+	Clock& operator = (const Clock& other);
+	Clock& operator = (ClockVal tv);
+	
+	void swap(Clock& clock);
+		/// Swaps the Clock with another one.
+	
+	void update();
+		/// Updates the Clock with the current system clock.
+
+	bool operator == (const Clock& ts) const;
+	bool operator != (const Clock& ts) const;
+	bool operator >  (const Clock& ts) const;
+	bool operator >= (const Clock& ts) const;
+	bool operator <  (const Clock& ts) const;
+	bool operator <= (const Clock& ts) const;
+	
+	Clock  operator +  (ClockDiff d) const;
+	Clock  operator -  (ClockDiff d) const;
+	ClockDiff operator - (const Clock& ts) const;
+	Clock& operator += (ClockDiff d);
+	Clock& operator -= (ClockDiff d);
+	
+	ClockVal microseconds() const;
+		/// Returns the clock value expressed in microseconds
+		/// since the system-specific epoch time (usually system
+		/// startup).
+
+	ClockVal raw() const;
+		/// Returns the clock value expressed in microseconds
+		/// since the system-specific epoch time (usually system
+		/// startup).
+		///
+		/// Same as microseconds().
+	
+	ClockDiff elapsed() const;
+		/// Returns the time elapsed since the time denoted by
+		/// the Clock instance. Equivalent to Clock() - *this.
+	
+	bool isElapsed(ClockDiff interval) const;
+		/// Returns true iff the given interval has passed
+		/// since the time denoted by the Clock instance.
+	
+	static ClockDiff resolution();
+		/// Returns the resolution in units per second.
+		/// Since the Clock clas has microsecond resolution,
+		/// the returned value is always 1000000.
+		
+	static ClockDiff accuracy();
+		/// Returns the system's clock accuracy in microseconds.
+		
+	static bool monotonic();
+		/// Returns true iff the system's clock is monotonic.
+
+private:
+	ClockVal _clock;
+};
+
+
+//
+// inlines
+//
+inline bool Clock::operator == (const Clock& ts) const
+{
+	return _clock == ts._clock;
+}
+
+
+inline bool Clock::operator != (const Clock& ts) const
+{
+	return _clock != ts._clock;
+}
+
+
+inline bool Clock::operator >  (const Clock& ts) const
+{
+	return _clock > ts._clock;
+}
+
+
+inline bool Clock::operator >= (const Clock& ts) const
+{
+	return _clock >= ts._clock;
+}
+
+
+inline bool Clock::operator <  (const Clock& ts) const
+{
+	return _clock < ts._clock;
+}
+
+
+inline bool Clock::operator <= (const Clock& ts) const
+{
+	return _clock <= ts._clock;
+}
+
+
+inline Clock Clock::operator + (Clock::ClockDiff d) const
+{
+	return Clock(_clock + d);
+}
+
+
+inline Clock Clock::operator - (Clock::ClockDiff d) const
+{
+	return Clock(_clock - d);
+}
+
+
+inline Clock::ClockDiff Clock::operator - (const Clock& ts) const
+{
+	return _clock - ts._clock;
+}
+
+
+inline Clock& Clock::operator += (Clock::ClockDiff d)
+{
+	_clock += d;
+	return *this;
+}
+
+
+inline Clock& Clock::operator -= (Clock::ClockDiff d)
+{
+	_clock -= d;
+	return *this;
+}
+
+
+inline Clock::ClockVal Clock::microseconds() const
+{
+	return _clock;
+}
+
+
+inline Clock::ClockDiff Clock::elapsed() const
+{
+	Clock now;
+	return now - *this;
+}
+
+
+inline bool Clock::isElapsed(Clock::ClockDiff interval) const
+{
+	Clock now;
+	Clock::ClockDiff diff = now - *this;
+	return diff >= interval;
+}
+
+
+inline Clock::ClockDiff Clock::resolution()
+{
+	return 1000000;
+}
+
+
+inline void swap(Clock& s1, Clock& s2)
+{
+	s1.swap(s2);
+}
+
+
+inline Clock::ClockVal Clock::raw() const
+{
+	return _clock;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Clock_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/CompressedLogFile.h b/base/poco/Foundation/include/Poco/CompressedLogFile.h
new file mode 100644
index 00000000000..71e45aada27
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/CompressedLogFile.h
@@ -0,0 +1,60 @@
+//
+// CompressedLogFile.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  CompressedLogFile
+//
+// Definition of the LogFile class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_CompressedLogFile_INCLUDED
+#define Foundation_CompressedLogFile_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/LogFile.h"
+#include "Poco/Buffer.h"
+
+#include <lz4.h>
+#include <lz4frame.h>
+
+
+namespace Poco {
+
+
+class Foundation_API CompressedLogFile: public LogFile
+{
+public:
+
+	CompressedLogFile(const std::string& path);
+		/// Allocates buffer and initializes compession state.
+
+	~CompressedLogFile();
+		/// Destoys CompressedLogFile
+
+	void write(const std::string& text, bool flush = true);
+		/// Writes the given text to the compressed log file.
+		/// If flush is true, the text will be immediately
+		/// flushed to the file.
+
+private:
+	Poco::Buffer<char> _buffer;
+
+	LZ4F_preferences_t _kPrefs;
+	LZ4F_compressionContext_t _ctx;
+};
+
+
+} // namespace Poco
+
+
+
+
+#endif // Foundation_CompressedLogFile_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Condition.h b/base/poco/Foundation/include/Poco/Condition.h
new file mode 100644
index 00000000000..3340533df1a
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Condition.h
@@ -0,0 +1,137 @@
+//
+// Condition.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Condition
+//
+// Definition of the Condition class template.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Condition_INCLUDED
+#define Foundation_Condition_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Mutex.h"
+#include "Poco/ScopedUnlock.h"
+#include "Poco/Event.h"
+#include "Poco/Exception.h"
+#include <deque>
+
+
+namespace Poco {
+
+
+class Foundation_API Condition
+	/// A Condition is a synchronization object used to block a thread 
+	/// until a particular condition is met. 
+	/// A Condition object is always used in conjunction with
+	/// a Mutex (or FastMutex) object.
+	///
+	/// Condition objects are similar to POSIX condition variables, which the
+	/// difference that Condition is not subject to spurious wakeups.
+	///
+	/// Threads waiting on a Condition are resumed in FIFO order.
+{
+public:
+	Condition();
+		/// Creates the Condition.
+	
+	~Condition();
+		/// Destroys the Condition.
+	
+	template <class Mtx>
+	void wait(Mtx& mutex)
+		/// Unlocks the mutex (which must be locked upon calling
+		/// wait()) and waits until the Condition is signalled.
+		///
+		/// The given mutex will be locked again upon 
+		/// leaving the function, even in case of an exception.
+	{
+		ScopedUnlock<Mtx> unlock(mutex, false);
+		Event event;
+		{
+			FastMutex::ScopedLock lock(_mutex);
+			mutex.unlock();
+			enqueue(event);
+		}
+		event.wait();
+	}
+	
+	template <class Mtx>
+	void wait(Mtx& mutex, long milliseconds)
+		/// Unlocks the mutex (which must be locked upon calling
+		/// wait()) and waits for the given time until the Condition is signalled.
+		///
+		/// The given mutex will be locked again upon successfully leaving the 
+		/// function, even in case of an exception.
+		///
+		/// Throws a TimeoutException if the Condition is not signalled
+		/// within the given time interval.
+	{
+		if (!tryWait(mutex, milliseconds))
+			throw TimeoutException();
+	}
+	
+	template <class Mtx>
+	bool tryWait(Mtx& mutex, long milliseconds)
+		/// Unlocks the mutex (which must be locked upon calling
+		/// tryWait()) and waits for the given time until the Condition is signalled.
+		///
+		/// The given mutex will be locked again upon leaving the 
+		/// function, even in case of an exception.
+		///
+		/// Returns true if the Condition has been signalled
+		/// within the given time interval, otherwise false.
+	{
+		ScopedUnlock<Mtx> unlock(mutex, false);
+		Event event;
+		{
+			FastMutex::ScopedLock lock(_mutex);
+			mutex.unlock();
+			enqueue(event);
+		}
+		if (!event.tryWait(milliseconds))
+		{
+			FastMutex::ScopedLock lock(_mutex);
+			dequeue(event);
+			return false;
+		}
+		return true;
+	}
+	
+	void signal();
+		/// Signals the Condition and allows one waiting thread
+		/// to continue execution.
+
+	void broadcast();
+		/// Signals the Condition and allows all waiting
+		/// threads to continue their execution.
+
+protected:
+	void enqueue(Event& event);
+	void dequeue();
+	void dequeue(Event& event);
+	
+private:
+	Condition(const Condition&);
+	Condition& operator = (const Condition&);
+	
+	typedef std::deque<Event*> WaitQueue;
+	
+	FastMutex _mutex;
+	WaitQueue _waitQueue;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Condition_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Config.h b/base/poco/Foundation/include/Poco/Config.h
new file mode 100644
index 00000000000..7dbe018237f
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Config.h
@@ -0,0 +1,207 @@
+//
+// Config.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Foundation
+//
+// Feature configuration for the POCO libraries.
+//
+// Copyright (c) 2006-2016, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Config_INCLUDED
+#define Foundation_Config_INCLUDED
+
+
+// Define to enable Windows Unicode (UTF-8) support
+// NOTE: As of POCO C++ Libraries release 1.6.0, compiling POCO
+// without POCO_WIN32_UTF8 defined on Windows is deprecated.
+#define POCO_WIN32_UTF8
+
+
+// Define to enable C++11 support
+// #define POCO_ENABLE_CPP11
+
+
+// Define to disable implicit linking
+// #define POCO_NO_AUTOMATIC_LIBS
+
+
+// Define to disable automatic initialization
+// Defining this will disable ALL automatic
+// initialization framework-wide (e.g. Net
+// on Windows, all Data back-ends, etc).
+//
+// #define POCO_NO_AUTOMATIC_LIB_INIT
+
+
+// Define to disable FPEnvironment support
+// #define POCO_NO_FPENVIRONMENT
+
+
+// Define if std::wstring is not available
+// #define POCO_NO_WSTRING
+
+
+// Define to disable shared memory
+// #define POCO_NO_SHAREDMEMORY
+
+
+// Define if no <locale> header is available (such as on WinCE)
+// #define POCO_NO_LOCALE
+
+
+// Define to desired default thread stack size
+// Zero means OS default
+#ifndef POCO_THREAD_STACK_SIZE
+	#define POCO_THREAD_STACK_SIZE 0
+#endif
+
+
+// Define to override system-provided
+// minimum thread priority value on POSIX
+// platforms (returned by Poco::Thread::getMinOSPriority()).
+// #define POCO_THREAD_PRIORITY_MIN 0
+
+
+// Define to override system-provided
+// maximum thread priority value on POSIX
+// platforms (returned by Poco::Thread::getMaxOSPriority()).
+// #define POCO_THREAD_PRIORITY_MAX 31
+
+
+// Define to disable small object optimization. If not
+// defined, Any and Dynamic::Var (and similar optimization
+// candidates) will be auto-allocated on the stack in
+// cases when value holder fits into POCO_SMALL_OBJECT_SIZE
+// (see below).
+//
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+// !!! NOTE: Any/Dynamic::Var SOO will NOT work reliably   !!!
+// !!! without C++11 (std::aligned_storage in particular). !!!
+// !!! Only comment this out if your compiler has support  !!!
+// !!! for std::aligned_storage.                           !!!
+// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+//
+#ifndef POCO_ENABLE_SOO
+#define POCO_NO_SOO
+#endif
+
+
+// Small object size in bytes. When assigned to Any or Var,
+// objects larger than this value will be alocated on the heap,
+// while those smaller will be placement new-ed into an
+// internal buffer.
+#if !defined(POCO_SMALL_OBJECT_SIZE) && !defined(POCO_NO_SOO)
+	#define POCO_SMALL_OBJECT_SIZE 32
+#endif
+
+
+// Define to disable compilation of DirectoryWatcher
+// on platforms with no inotify.
+// #define POCO_NO_INOTIFY
+
+
+// Following are options to remove certain features
+// to reduce library/executable size for smaller
+// embedded platforms. By enabling these options,
+// the size of a statically executable can be
+// reduced by a few 100 Kbytes.
+
+
+// No automatic registration of FileChannel in
+// LoggingFactory - avoids FileChannel and friends
+// being linked to executable.
+// #define POCO_NO_FILECHANNEL
+
+
+// No automatic registration of SplitterChannel in
+// LoggingFactory - avoids SplitterChannel being
+// linked to executable.
+// #define POCO_NO_SPLITTERCHANNEL
+
+
+// No automatic registration of SyslogChannel in
+// LoggingFactory - avoids SyslogChannel being
+// linked to executable on Unix/Linux systems.
+// #define POCO_NO_SYSLOGCHANNEL
+
+
+// Define to enable MSVC secure warnings
+// #define POCO_MSVC_SECURE_WARNINGS
+
+
+// No support for INI file configurations in
+// Poco::Util::Application.
+// #define POCO_UTIL_NO_INIFILECONFIGURATION
+
+
+// No support for JSON configuration in
+// Poco::Util::Application. Avoids linking of JSON
+// library and saves a few 100 Kbytes.
+// #define POCO_UTIL_NO_JSONCONFIGURATION
+
+
+// No support for XML configuration in
+// Poco::Util::Application. Avoids linking of XML
+// library and saves a few 100 Kbytes.
+// #define POCO_UTIL_NO_XMLCONFIGURATION
+
+
+// No IPv6 support
+// Define to disable IPv6
+// #define POCO_NET_NO_IPv6
+
+
+// Windows CE has no locale support
+#if defined(_WIN32_WCE)
+	#define POCO_NO_LOCALE
+#endif
+
+
+// Enable the poco_debug_* and poco_trace_* macros
+// even if the _DEBUG variable is not set.
+// This allows the use of these macros in a release version.
+// #define POCO_LOG_DEBUG
+
+
+// OpenSSL on Windows
+//
+// Poco has its own OpenSSL build system.
+// See <https://github.com/pocoproject/openssl/blob/master/README.md>
+// for details.
+//
+// These options are Windows only.
+//
+// To disable the use of Poco-provided OpenSSL binaries,
+// define POCO_EXTERNAL_OPENSSL.
+//
+// Possible values:
+//   POCO_EXTERNAL_OPENSSL_SLPRO:
+//     Automatically link OpenSSL libraries from OpenSSL Windows installer provided
+//     by Shining Light Productions <http://slproweb.com/products/Win32OpenSSL.html>
+//     The (global) library search path must be set accordingly.
+//   POCO_EXTERNAL_OPENSSL_DEFAULT:
+//     Automatically link OpenSSL libraries from standard OpenSSL Windows build.
+//     The (global) library search path must be set accordingly.
+//   empty or other value:
+//     Do not link any OpenSSL libraries automatically. You will have to edit the
+//     Visual C++ project files for Crypto and NetSSL_OpenSSL.
+// #define POCO_EXTERNAL_OPENSSL POCO_EXTERNAL_OPENSSL_SLPRO
+
+
+// Define to prevent changing the suffix for shared libraries
+// to "d.so", "d.dll", etc. for _DEBUG builds in Poco::SharedLibrary.
+// #define POCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX
+
+
+// Disarm POCO_DEPRECATED macro.
+// #define POCO_NO_DEPRECATED
+
+
+#endif // Foundation_Config_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Configurable.h b/base/poco/Foundation/include/Poco/Configurable.h
new file mode 100644
index 00000000000..cb260d38294
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Configurable.h
@@ -0,0 +1,70 @@
+//
+// Configurable.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  Configurable
+//
+// Definition of the Configurable class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Configurable_INCLUDED
+#define Foundation_Configurable_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Configurable
+	/// A simple interface that defines
+	/// getProperty() and setProperty() methods.
+	///
+	/// This interface is implemented by Formatter and
+	/// Channel and is used to configure arbitrary
+	/// channels and formatters.
+	///
+	/// A property is basically a name-value pair. For
+	/// simplicity, both names and values are strings.
+	/// Every property controls a certain aspect of a
+	/// Formatter or Channel. For example, the PatternFormatter's
+	/// formatting pattern is set via a property.
+	///
+	/// NOTE: The following property names are use internally
+	/// by the logging framework and must not be used by
+	/// channels or formatters:
+	///   - class
+	///   - pattern (Channel)
+	///   - formatter (Channel)
+{
+public:
+	Configurable();
+		/// Creates the Configurable.
+		
+	virtual ~Configurable();
+		/// Destroys the Configurable.
+		
+	virtual void setProperty(const std::string& name, const std::string& value) = 0;
+		/// Sets the property with the given name to the given value.
+		/// If a property with the given name is not supported, a
+		/// PropertyNotSupportedException is thrown.
+		
+	virtual std::string getProperty(const std::string& name) const = 0;
+		/// Returns the value of the property with the given name.
+		/// If a property with the given name is not supported, a
+		/// PropertyNotSupportedException is thrown.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Configurable_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ConsoleChannel.h b/base/poco/Foundation/include/Poco/ConsoleChannel.h
new file mode 100644
index 00000000000..28aab6e3ef5
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ConsoleChannel.h
@@ -0,0 +1,187 @@
+//
+// ConsoleChannel.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  ConsoleChannel
+//
+// Definition of the ConsoleChannel class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ConsoleChannel_INCLUDED
+#define Foundation_ConsoleChannel_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Channel.h"
+#include "Poco/Mutex.h"
+#include <ostream>
+
+
+namespace Poco {
+
+
+class Foundation_API ConsoleChannel: public Channel
+	/// A channel that writes to an ostream.
+	///
+	/// Only the message's text is written, followed
+	/// by a newline.
+	///
+	/// Chain this channel to a FormattingChannel with an
+	/// appropriate Formatter to control what is contained 
+	/// in the text.
+	///
+	/// Similar to StreamChannel, except that a static
+	/// mutex is used to protect against multiple
+	/// console channels concurrently writing to the
+	/// same stream.
+{
+public:
+	ConsoleChannel();
+		/// Creates the channel and attaches std::clog.
+		
+	ConsoleChannel(std::ostream& str);
+		/// Creates the channel using the given stream.
+
+	void log(const Message& msg);
+		/// Logs the given message to the channel's stream.
+		
+protected:
+	~ConsoleChannel();
+
+private:
+	std::ostream& _str;
+	static FastMutex _mutex;
+};
+
+
+class Foundation_API ColorConsoleChannel: public Channel
+	/// A channel that writes to an ostream.
+	///
+	/// Only the message's text is written, followed
+	/// by a newline.
+	///
+	/// Messages can be colored depending on priority.
+	/// The console device must support ANSI escape codes
+	/// in order to display colored messages.
+	///
+	/// To enable message coloring, set the "enableColors"
+	/// property to true (default). Furthermore, colors can be
+	/// configured by setting the following properties
+	/// (default values are given in parenthesis):
+	/// 
+	///   * traceColor (gray)
+	///   * debugColor (gray)
+	///   * informationColor (default)
+	///   * noticeColor (default)
+	///   * warningColor (yellow)
+	///   * errorColor (lightRed)
+	///   * criticalColor (lightRed)
+	///   * fatalColor (lightRed)
+	///
+	/// The following color values are supported:
+	/// 
+	///   * default
+	///   * black
+	///   * red
+	///   * green
+	///   * brown
+	///   * blue
+	///   * magenta
+	///   * cyan
+	///   * gray
+	///   * darkgray
+	///   * lightRed
+	///   * lightGreen
+	///   * yellow
+	///   * lightBlue
+	///   * lightMagenta
+	///   * lightCyan
+	///   * white
+	///
+	/// Chain this channel to a FormattingChannel with an
+	/// appropriate Formatter to control what is contained 
+	/// in the text.
+	///
+	/// Similar to StreamChannel, except that a static
+	/// mutex is used to protect against multiple
+	/// console channels concurrently writing to the
+	/// same stream.
+{
+public:	
+	ColorConsoleChannel();
+		/// Creates the channel and attaches std::clog.
+		
+	ColorConsoleChannel(std::ostream& str);
+		/// Creates the channel using the given stream.
+
+	void log(const Message& msg);
+		/// Logs the given message to the channel's stream.
+	
+	void setProperty(const std::string& name, const std::string& value);
+		/// Sets the property with the given name. 
+		/// 
+		/// The following properties are supported:
+		///   * enableColors:      Enable or disable colors.
+		///   * traceColor:        Specify color for trace messages.
+		///   * debugColor:        Specify color for debug messages.
+		///   * informationColor:  Specify color for information messages.
+		///   * noticeColor:       Specify color for notice messages.
+		///   * warningColor:      Specify color for warning messages.
+		///   * errorColor:        Specify color for error messages.
+		///   * criticalColor:     Specify color for critical messages.
+		///   * fatalColor:        Specify color for fatal messages.
+		///
+		/// See the class documentation for a list of supported color values.
+
+	std::string getProperty(const std::string& name) const;
+		/// Returns the value of the property with the given name.
+		/// See setProperty() for a description of the supported
+		/// properties.
+
+protected:	
+	enum Color
+	{
+		CC_DEFAULT      = 0x0027,
+		CC_BLACK        = 0x001e,
+		CC_RED          = 0x001f,
+		CC_GREEN        = 0x0020,
+		CC_BROWN        = 0x0021,
+		CC_BLUE         = 0x0022,
+		CC_MAGENTA      = 0x0023,
+		CC_CYAN         = 0x0024,
+		CC_GRAY         = 0x0025,
+		CC_DARKGRAY     = 0x011e,
+		CC_LIGHTRED     = 0x011f,
+		CC_LIGHTGREEN   = 0x0120,
+		CC_YELLOW       = 0x0121,
+		CC_LIGHTBLUE    = 0x0122,
+		CC_LIGHTMAGENTA = 0x0123,
+		CC_LIGHTCYAN    = 0x0124,
+		CC_WHITE        = 0x0125
+	};
+
+	~ColorConsoleChannel();
+	Color parseColor(const std::string& color) const;
+	std::string formatColor(Color color) const;
+	void initColors();
+
+private:
+	std::ostream& _str;
+	bool _enableColors;
+	Color _colors[9];
+	static FastMutex _mutex;
+	static const std::string CSI;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ConsoleChannel_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/CountingStream.h b/base/poco/Foundation/include/Poco/CountingStream.h
new file mode 100644
index 00000000000..17da1e4e717
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/CountingStream.h
@@ -0,0 +1,237 @@
+//
+// CountingStream.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  CountingStream
+//
+// Definition of the CountingStreamBuf, CountingInputStream and CountingOutputStream classes.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_CountingStream_INCLUDED
+#define Foundation_CountingStream_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+
+
+class Foundation_API CountingStreamBuf: public UnbufferedStreamBuf
+	/// This stream buffer counts all characters and lines
+	/// going through it.
+{
+public:
+	CountingStreamBuf();
+		/// Creates an unconnected CountingStreamBuf.
+	
+	CountingStreamBuf(std::istream& istr);
+		/// Creates the CountingStreamBuf and connects it
+		/// to the given input stream.
+
+	CountingStreamBuf(std::ostream& ostr);
+		/// Creates the CountingStreamBuf and connects it
+		/// to the given output stream.
+
+	~CountingStreamBuf();
+		/// Destroys the CountingStream.
+		
+	int chars() const;
+		/// Returns the total number of characters.
+		
+	int lines() const;
+		/// Returns the total number of lines.
+		
+	int pos() const;
+		/// Returns the number of characters on the current line.
+		
+	void reset();
+		/// Resets all counters.
+		
+	void setCurrentLineNumber(int line);
+		/// Sets the current line number.
+		///
+		/// This is mainly useful when parsing C/C++
+		/// preprocessed source code containing #line directives.
+		
+	int getCurrentLineNumber() const;
+		/// Returns the current line number (same as lines()).
+
+	void addChars(int chars);
+		/// Add to the total number of characters.
+		
+	void addLines(int lines);
+		/// Add to the total number of lines.
+		
+	void addPos(int pos);
+		/// Add to the number of characters on the current line.
+
+protected:
+	int readFromDevice();
+	int writeToDevice(char c);
+
+private:
+	std::istream* _pIstr;
+	std::ostream* _pOstr;
+	int _chars;
+	int _lines;
+	int _pos;
+};
+
+
+class Foundation_API CountingIOS: public virtual std::ios
+	/// The base class for CountingInputStream and CountingOutputStream.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	CountingIOS();
+		/// Creates the basic stream and leaves it unconnected.
+
+	CountingIOS(std::istream& istr);
+		/// Creates the basic stream and connects it
+		/// to the given input stream.
+
+	CountingIOS(std::ostream& ostr);
+		/// Creates the basic stream and connects it
+		/// to the given output stream.
+
+	~CountingIOS();
+		/// Destroys the stream.
+
+	int chars() const;
+		/// Returns the total number of characters.
+
+	int lines() const;
+		/// Returns the total number of lines.
+
+	int pos() const;
+		/// Returns the number of characters on the current line.
+
+	void reset();
+		/// Resets all counters.
+
+	void setCurrentLineNumber(int line);
+		/// Sets the current line number.
+		///
+		/// This is mainly useful when parsing C/C++
+		/// preprocessed source code containing #line directives.
+		
+	int getCurrentLineNumber() const;
+		/// Returns the current line number (same as lines()).
+
+	void addChars(int chars);
+		/// Add to the total number of characters.
+		
+	void addLines(int lines);
+		/// Add to the total number of lines.
+		
+	void addPos(int pos);
+		/// Add to the number of characters on the current line.
+
+	CountingStreamBuf* rdbuf();
+		/// Returns a pointer to the underlying streambuf.
+
+protected:
+	CountingStreamBuf _buf;
+};
+
+
+class Foundation_API CountingInputStream: public CountingIOS, public std::istream
+	/// This stream counts all characters and lines
+	/// going through it. This is useful for lexers and parsers
+	/// that need to determine the current position in the stream.
+{
+public:
+	CountingInputStream(std::istream& istr);
+		/// Creates the CountingInputStream and connects it
+		/// to the given input stream.
+
+	~CountingInputStream();
+		/// Destroys the stream.
+};
+
+
+class Foundation_API CountingOutputStream: public CountingIOS, public std::ostream
+	/// This stream counts all characters and lines
+	/// going through it.
+{
+public:
+	CountingOutputStream();
+		/// Creates an unconnected CountingOutputStream.
+	
+	CountingOutputStream(std::ostream& ostr);
+		/// Creates the CountingOutputStream and connects it
+		/// to the given output stream.
+
+	~CountingOutputStream();
+		/// Destroys the CountingOutputStream.
+};
+
+
+//
+// inlines
+//
+inline int CountingStreamBuf::chars() const
+{
+	return _chars;
+}
+
+
+inline int CountingStreamBuf::lines() const
+{
+	return _lines;
+}
+
+
+inline int CountingStreamBuf::pos() const
+{
+	return _pos;
+}
+
+
+inline int CountingStreamBuf::getCurrentLineNumber() const
+{
+	return _lines;
+}
+
+
+inline int CountingIOS::chars() const
+{
+	return _buf.chars();
+}
+
+
+inline int CountingIOS::lines() const
+{
+	return _buf.lines();
+}
+
+
+inline int CountingIOS::pos() const
+{
+	return _buf.pos();
+}
+
+
+inline int CountingIOS::getCurrentLineNumber() const
+{
+	return _buf.getCurrentLineNumber();
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_CountingStream_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/DateTime.h b/base/poco/Foundation/include/Poco/DateTime.h
new file mode 100644
index 00000000000..ab69894719b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/DateTime.h
@@ -0,0 +1,415 @@
+//
+// DateTime.h
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  DateTime
+//
+// Definition of the DateTime class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_DateTime_INCLUDED
+#define Foundation_DateTime_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Timestamp.h"
+#include "Poco/Timespan.h"
+
+
+namespace Poco {
+
+
+class Foundation_API DateTime
+	/// This class represents an instant in time, expressed
+	/// in years, months, days, hours, minutes, seconds
+	/// and milliseconds based on the Gregorian calendar.
+	/// The class is mainly useful for conversions between
+	/// UTC, Julian day and Gregorian calendar dates.
+	///
+	/// The date and time stored in a DateTime is always in UTC
+	/// (Coordinated Universal Time) and thus independent of the 
+	/// timezone in effect on the system.
+	///
+	/// Conversion calculations are based on algorithms
+	/// collected and described by Peter Baum at
+	/// http://vsg.cape.com/~pbaum/date/date0.htm
+	///
+	/// Internally, this class stores a date/time in two
+	/// forms (UTC and broken down) for performance reasons. Only use 
+	/// this class for conversions between date/time representations.
+	/// Use the Timestamp class for everything else.
+	///
+	/// Notes:
+	///   * Zero is a valid year (in accordance with ISO 8601 and astronomical year numbering)
+	///   * Year zero (0) is a leap year
+	///   * Negative years (years preceding 1 BC) are not supported
+	///
+	/// For more information, please see:
+	///   * http://en.wikipedia.org/wiki/Gregorian_Calendar
+	///   * http://en.wikipedia.org/wiki/Julian_day
+	///   * http://en.wikipedia.org/wiki/UTC
+	///   * http://en.wikipedia.org/wiki/ISO_8601
+{
+public:
+	enum Months
+		/// Symbolic names for month numbers (1 to 12).
+	{
+		JANUARY = 1,
+		FEBRUARY,
+		MARCH,
+		APRIL,
+		MAY,
+		JUNE,
+		JULY,
+		AUGUST,
+		SEPTEMBER,
+		OCTOBER,
+		NOVEMBER,
+		DECEMBER
+	};
+	
+	enum DaysOfWeek
+		/// Symbolic names for week day numbers (0 to 6).
+	{
+		SUNDAY = 0,
+		MONDAY,
+		TUESDAY,
+		WEDNESDAY,
+		THURSDAY,
+		FRIDAY,
+		SATURDAY
+	};
+		
+	DateTime();
+		/// Creates a DateTime for the current date and time.
+
+	DateTime(const Timestamp& timestamp);
+		/// Creates a DateTime for the date and time given in
+		/// a Timestamp.
+		
+	DateTime(int year, int month, int day, int hour = 0, int minute = 0, int second = 0, int millisecond = 0, int microsecond = 0);
+		/// Creates a DateTime for the given Gregorian date and time.
+		///   * year is from 0 to 9999.
+		///   * month is from 1 to 12.
+		///   * day is from 1 to 31.
+		///   * hour is from 0 to 23.
+		///   * minute is from 0 to 59.
+		///   * second is from 0 to 60 (allowing leap seconds).
+		///   * millisecond is from 0 to 999.
+		///   * microsecond is from 0 to 999.
+
+	DateTime(double julianDay);
+		/// Creates a DateTime for the given Julian day.
+
+	DateTime(Timestamp::UtcTimeVal utcTime, Timestamp::TimeDiff diff);
+		/// Creates a DateTime from an UtcTimeVal and a TimeDiff.
+		///
+		/// Mainly used internally by DateTime and friends.
+
+	DateTime(const DateTime& dateTime);
+		/// Copy constructor. Creates the DateTime from another one.
+
+	~DateTime();
+		/// Destroys the DateTime.
+
+	DateTime& operator = (const DateTime& dateTime);
+		/// Assigns another DateTime.
+		
+	DateTime& operator = (const Timestamp& timestamp);
+		/// Assigns a Timestamp.
+
+	DateTime& operator = (double julianDay);
+		/// Assigns a Julian day.
+
+	DateTime& assign(int year, int month, int day, int hour = 0, int minute = 0, int second = 0, int millisecond = 0, int microseconds = 0);
+		/// Assigns a Gregorian date and time.
+		///   * year is from 0 to 9999.
+		///   * month is from 1 to 12.
+		///   * day is from 1 to 31.
+		///   * hour is from 0 to 23.
+		///   * minute is from 0 to 59.
+		///   * second is from 0 to 60 (allowing leap seconds).
+		///   * millisecond is from 0 to 999.
+		///   * microsecond is from 0 to 999.
+
+	void swap(DateTime& dateTime);
+		/// Swaps the DateTime with another one.
+
+	int year() const;
+		/// Returns the year.
+		
+	int month() const;
+		/// Returns the month (1 to 12).
+	
+	int week(int firstDayOfWeek = MONDAY) const;
+		/// Returns the week number within the year.
+		/// FirstDayOfWeek should be either SUNDAY (0) or MONDAY (1).
+		/// The returned week number will be from 0 to 53. Week number 1 is the week 
+		/// containing January 4. This is in accordance to ISO 8601.
+		/// 
+		/// The following example assumes that firstDayOfWeek is MONDAY. For 2005, which started
+		/// on a Saturday, week 1 will be the week starting on Monday, January 3.
+		/// January 1 and 2 will fall within week 0 (or the last week of the previous year).
+		///
+		/// For 2007, which starts on a Monday, week 1 will be the week startung on Monday, January 1.
+		/// There will be no week 0 in 2007.
+	
+	int day() const;
+		/// Returns the day witin the month (1 to 31).
+		
+	int dayOfWeek() const;
+		/// Returns the weekday (0 to 6, where
+		/// 0 = Sunday, 1 = Monday, ..., 6 = Saturday).
+	
+	int dayOfYear() const;
+		/// Returns the number of the day in the year.
+		/// January 1 is 1, February 1 is 32, etc.
+	
+	int hour() const;
+		/// Returns the hour (0 to 23).
+		
+	int hourAMPM() const;
+		/// Returns the hour (0 to 12).
+	
+	bool isAM() const;
+		/// Returns true if hour < 12;
+
+	bool isPM() const;
+		/// Returns true if hour >= 12.
+		
+	int minute() const;
+		/// Returns the minute (0 to 59).
+		
+	int second() const;
+		/// Returns the second (0 to 59).
+		
+	int millisecond() const;
+		/// Returns the millisecond (0 to 999)
+	
+	int microsecond() const;
+		/// Returns the microsecond (0 to 999)
+	
+	double julianDay() const;
+		/// Returns the julian day for the date and time.
+		
+	Timestamp timestamp() const;
+		/// Returns the date and time expressed as a Timestamp.
+
+	Timestamp::UtcTimeVal utcTime() const;
+		/// Returns the date and time expressed in UTC-based
+		/// time. UTC base time is midnight, October 15, 1582.
+		/// Resolution is 100 nanoseconds.
+		
+	bool operator == (const DateTime& dateTime) const;	
+	bool operator != (const DateTime& dateTime) const;	
+	bool operator <  (const DateTime& dateTime) const;	
+	bool operator <= (const DateTime& dateTime) const;	
+	bool operator >  (const DateTime& dateTime) const;	
+	bool operator >= (const DateTime& dateTime) const;	
+
+	DateTime  operator +  (const Timespan& span) const;
+	DateTime  operator -  (const Timespan& span) const;
+	Timespan  operator -  (const DateTime& dateTime) const;
+	DateTime& operator += (const Timespan& span);
+	DateTime& operator -= (const Timespan& span);
+	
+	void makeUTC(int tzd);
+		/// Converts a local time into UTC, by applying the given time zone differential.
+		
+	void makeLocal(int tzd);
+		/// Converts a UTC time into a local time, by applying the given time zone differential.
+	
+	static bool isLeapYear(int year);
+		/// Returns true if the given year is a leap year;
+		/// false otherwise.
+		
+	static int daysOfMonth(int year, int month);
+		/// Returns the number of days in the given month
+		/// and year. Month is from 1 to 12.
+		
+	static bool isValid(int year, int month, int day, int hour = 0, int minute = 0, int second = 0, int millisecond = 0, int microsecond = 0);
+		/// Checks if the given date and time is valid
+		/// (all arguments are within a proper range).
+		///
+		/// Returns true if all arguments are valid, false otherwise.
+		
+protected:	
+	static double toJulianDay(Timestamp::UtcTimeVal utcTime);
+		/// Computes the Julian day for an UTC time.
+	
+	static double toJulianDay(int year, int month, int day, int hour = 0, int minute = 0, int second = 0, int millisecond = 0, int microsecond = 0);
+		/// Computes the Julian day for a gregorian calendar date and time.
+		/// See <http://vsg.cape.com/~pbaum/date/jdimp.htm>, section 2.3.1 for the algorithm.
+	
+	static Timestamp::UtcTimeVal toUtcTime(double julianDay);
+		/// Computes the UTC time for a Julian day.
+		
+	void computeGregorian(double julianDay);
+		/// Computes the Gregorian date for the given Julian day.
+		/// See <http://vsg.cape.com/~pbaum/date/injdimp.htm>, section 3.3.1 for the algorithm.
+
+	void computeDaytime();
+		/// Extracts the daytime (hours, minutes, seconds, etc.) from the stored utcTime.
+
+private:
+	void checkLimit(short& lower, short& higher, short limit);
+	void normalize();
+		///utility functions used to correct the overflow in computeGregorian
+
+	Timestamp::UtcTimeVal _utcTime;
+	short  _year;
+	short  _month;
+	short  _day;
+	short  _hour;
+	short  _minute;
+	short  _second;
+	short  _millisecond;
+	short  _microsecond;
+};
+
+
+//
+// inlines
+//
+inline Timestamp DateTime::timestamp() const
+{
+	return Timestamp::fromUtcTime(_utcTime);
+}
+
+
+inline Timestamp::UtcTimeVal DateTime::utcTime() const
+{
+	return _utcTime;
+}
+
+
+inline int DateTime::year() const
+{
+	return _year;
+}
+
+	
+inline int DateTime::month() const
+{
+	return _month;
+}
+
+	
+inline int DateTime::day() const
+{
+	return _day;
+}
+
+	
+inline int DateTime::hour() const
+{
+	return _hour;
+}
+
+
+inline int DateTime::hourAMPM() const
+{
+	if (_hour < 1)
+		return 12;
+	else if (_hour > 12)
+		return _hour - 12;
+	else
+		return _hour;
+}
+
+
+inline bool DateTime::isAM() const
+{
+	return _hour < 12;
+}
+
+
+inline bool DateTime::isPM() const
+{
+	return _hour >= 12;
+}
+
+	
+inline int DateTime::minute() const
+{
+	return _minute;
+}
+
+	
+inline int DateTime::second() const
+{
+	return _second;
+}
+
+	
+inline int DateTime::millisecond() const
+{
+	return _millisecond;
+}
+
+
+inline int DateTime::microsecond() const
+{
+	return _microsecond;
+}
+
+
+inline bool DateTime::operator == (const DateTime& dateTime) const
+{
+	return _utcTime == dateTime._utcTime;
+}
+
+
+inline bool DateTime::operator != (const DateTime& dateTime) const	
+{
+	return _utcTime != dateTime._utcTime;
+}
+
+
+inline bool DateTime::operator <  (const DateTime& dateTime) const	
+{
+	return _utcTime < dateTime._utcTime;
+}
+
+
+inline bool DateTime::operator <= (const DateTime& dateTime) const
+{
+	return _utcTime <= dateTime._utcTime;
+}
+
+
+inline bool DateTime::operator >  (const DateTime& dateTime) const
+{
+	return _utcTime > dateTime._utcTime;
+}
+
+
+inline bool DateTime::operator >= (const DateTime& dateTime) const	
+{
+	return _utcTime >= dateTime._utcTime;
+}
+
+
+inline bool DateTime::isLeapYear(int year)
+{
+	return (year % 4) == 0 && ((year % 100) != 0 || (year % 400) == 0);
+}
+
+
+inline void swap(DateTime& d1, DateTime& d2)
+{
+	d1.swap(d2);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_DateTime_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/DateTimeFormat.h b/base/poco/Foundation/include/Poco/DateTimeFormat.h
new file mode 100644
index 00000000000..8f222d091f1
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/DateTimeFormat.h
@@ -0,0 +1,109 @@
+//
+// DateTimeFormat.h
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  DateTimeFormat
+//
+// Definition of the DateTimeFormat class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_DateTimeFormat_INCLUDED
+#define Foundation_DateTimeFormat_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API DateTimeFormat
+	/// Definition of date/time formats and various
+	/// constants used by DateTimeFormatter and DateTimeParser.
+{
+public:
+	// predefined date formats
+	static const std::string ISO8601_FORMAT;
+		/// The date/time format defined in the ISO 8601 standard.
+		///
+		/// Examples: 
+		///   2005-01-01T12:00:00+01:00
+		///   2005-01-01T11:00:00Z
+
+	static const std::string ISO8601_FRAC_FORMAT;
+		/// The date/time format defined in the ISO 8601 standard,
+		/// with fractional seconds.
+		///
+		/// Examples: 
+		///   2005-01-01T12:00:00.000000+01:00
+		///   2005-01-01T11:00:00.000000Z
+	
+	static const std::string RFC822_FORMAT;
+		/// The date/time format defined in RFC 822 (obsoleted by RFC 1123).
+		///
+		/// Examples: 
+		///   Sat, 1 Jan 05 12:00:00 +0100
+		///   Sat, 1 Jan 05 11:00:00 GMT
+
+	static const std::string RFC1123_FORMAT;
+		/// The date/time format defined in RFC 1123 (obsoletes RFC 822).
+		///
+		/// Examples: 
+		///   Sat, 1 Jan 2005 12:00:00 +0100
+		///   Sat, 1 Jan 2005 11:00:00 GMT
+
+	static const std::string HTTP_FORMAT;
+		/// The date/time format defined in the HTTP specification (RFC 2616),
+		/// which is basically a variant of RFC 1036 with a zero-padded day field.
+		///
+		/// Examples: 
+		///   Sat, 01 Jan 2005 12:00:00 +0100
+		///   Sat, 01 Jan 2005 11:00:00 GMT
+
+	static const std::string RFC850_FORMAT;
+		/// The date/time format defined in RFC 850 (obsoleted by RFC 1036).
+		///
+		/// Examples: 
+		///   Saturday, 1-Jan-05 12:00:00 +0100
+		///   Saturday, 1-Jan-05 11:00:00 GMT
+
+	static const std::string RFC1036_FORMAT;
+		/// The date/time format defined in RFC 1036 (obsoletes RFC 850).
+		///
+		/// Examples: 
+		///   Saturday, 1 Jan 05 12:00:00 +0100
+		///   Saturday, 1 Jan 05 11:00:00 GMT
+
+	static const std::string ASCTIME_FORMAT;
+		/// The date/time format produced by the ANSI C asctime() function.
+		///
+		/// Example: 
+		///   Sat Jan  1 12:00:00 2005
+
+	static const std::string SORTABLE_FORMAT;
+		/// A simple, sortable date/time format.
+		///
+		/// Example:
+		///   2005-01-01 12:00:00
+
+
+	// names used by formatter and parser
+	static const std::string WEEKDAY_NAMES[7];
+		/// English names of week days (Sunday, Monday, Tuesday, ...).
+		
+	static const std::string MONTH_NAMES[12];
+		/// English names of months (January, February, ...).	
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_DateTimeFormat_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/DateTimeFormatter.h b/base/poco/Foundation/include/Poco/DateTimeFormatter.h
new file mode 100644
index 00000000000..3d6e5ed805e
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/DateTimeFormatter.h
@@ -0,0 +1,215 @@
+//
+// DateTimeFormatter.h
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  DateTimeFormatter
+//
+// Definition of the DateTimeFormatter class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_DateTimeFormatter_INCLUDED
+#define Foundation_DateTimeFormatter_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/DateTime.h"
+#include "Poco/LocalDateTime.h"
+
+
+namespace Poco {
+
+
+class Timestamp;
+class Timespan;
+
+
+class Foundation_API DateTimeFormatter
+	/// This class converts dates and times into strings, supporting a  
+	/// variety of standard and custom formats.
+	///
+	/// There are two kind of static member functions:
+	///    * format* functions return a std::string containing
+	///      the formatted value.
+	///    * append* functions append the formatted value to
+	///      an existing string.
+{
+public:
+	enum
+	{
+		UTC = 0xFFFF /// Special value for timeZoneDifferential denoting UTC. 
+	};
+
+	static std::string format(const Timestamp& timestamp, const std::string& fmt, int timeZoneDifferential = UTC);
+		/// Formats the given timestamp according to the given format.
+		/// The format string is used as a template to format the date and
+		/// is copied character by character except for the following special characters,
+		/// which are replaced by the corresponding value.
+		///
+		///   * %w - abbreviated weekday (Mon, Tue, ...)
+		///   * %W - full weekday (Monday, Tuesday, ...)
+		///   * %b - abbreviated month (Jan, Feb, ...)
+		///   * %B - full month (January, February, ...)
+		///   * %d - zero-padded day of month (01 .. 31)
+		///   * %e - day of month (1 .. 31)
+		///   * %f - space-padded day of month ( 1 .. 31)
+		///   * %m - zero-padded month (01 .. 12)
+		///   * %n - month (1 .. 12)
+		///   * %o - space-padded month ( 1 .. 12)
+		///   * %y - year without century (70)
+		///   * %Y - year with century (1970)
+		///   * %H - hour (00 .. 23)
+		///   * %h - hour (00 .. 12)
+		///   * %a - am/pm
+		///   * %A - AM/PM
+		///   * %M - minute (00 .. 59)
+		///   * %S - second (00 .. 59)
+		///   * %s - seconds and microseconds (equivalent to %S.%F)
+		///   * %i - millisecond (000 .. 999)
+		///   * %c - centisecond (0 .. 9)
+		///   * %F - fractional seconds/microseconds (000000 - 999999)
+		///   * %z - time zone differential in ISO 8601 format (Z or +NN.NN)
+		///   * %Z - time zone differential in RFC format (GMT or +NNNN)
+		///   * %% - percent sign
+		///
+		/// Class DateTimeFormat defines format strings for various standard date/time formats.
+
+	static std::string format(const DateTime& dateTime, const std::string& fmt, int timeZoneDifferential = UTC);
+		/// Formats the given date and time according to the given format.
+		/// See format(const Timestamp&, const std::string&, int) for more information.
+
+	static std::string format(const LocalDateTime& dateTime, const std::string& fmt);
+		/// Formats the given local date and time according to the given format.
+		/// See format(const Timestamp&, const std::string&, int) for more information.
+
+	static std::string format(const Timespan& timespan, const std::string& fmt = "%dd %H:%M:%S.%i");
+		/// Formats the given timespan according to the given format.
+		/// The format string is used as a template to format the date and
+		/// is copied character by character except for the following special characters,
+		/// which are replaced by the corresponding value.
+		///
+		///   * %d - days
+		///   * %H - hours	 (00 .. 23)
+		///   * %h - total hours (0 .. n)
+		///   * %M - minutes (00 .. 59)
+		///   * %m - total minutes (0 .. n)
+		///   * %S - seconds (00 .. 59)
+		///   * %s - total seconds (0 .. n)
+		///   * %i - milliseconds (000 .. 999)
+		///   * %c - centisecond (0 .. 9)
+		///   * %F - fractional seconds/microseconds (000000 - 999999)
+		///   * %% - percent sign
+
+	static void append(std::string& str, const Timestamp& timestamp, const std::string& fmt, int timeZoneDifferential = UTC);
+		/// Formats the given timestamp according to the given format and appends it to str.
+		///
+		/// See format() for documentation of the formatting string.
+
+	static void append(std::string& str, const DateTime& dateTime, const std::string& fmt, int timeZoneDifferential = UTC);
+		/// Formats the given date and time according to the given format and appends it to str.
+		///
+		/// See format() for documentation of the formatting string.
+
+	static void append(std::string& str, const LocalDateTime& dateTime, const std::string& fmt);
+		/// Formats the given local date and time according to the given format and appends it to str.
+		///
+		/// See format() for documentation of the formatting string.
+
+	static void append(std::string& str, const Timespan& timespan, const std::string& fmt = "%dd %H:%M:%S.%i");
+		/// Formats the given timespan according to the given format and appends it to str.
+		///
+		/// See format() for documentation of the formatting string.
+
+	static std::string tzdISO(int timeZoneDifferential);
+		/// Formats the given timezone differential in ISO format.
+		/// If timeZoneDifferential is UTC, "Z" is returned,
+		/// otherwise, +HH.MM (or -HH.MM) is returned.
+		
+	static std::string tzdRFC(int timeZoneDifferential);
+		/// Formats the given timezone differential in RFC format.
+		/// If timeZoneDifferential is UTC, "GMT" is returned,
+		/// otherwise ++HHMM (or -HHMM) is returned.
+
+	static void tzdISO(std::string& str, int timeZoneDifferential);
+		/// Formats the given timezone differential in ISO format
+		/// and appends it to the given string.
+		/// If timeZoneDifferential is UTC, "Z" is returned,
+		/// otherwise, +HH.MM (or -HH.MM) is returned.
+		
+	static void tzdRFC(std::string& str, int timeZoneDifferential);
+		/// Formats the given timezone differential in RFC format
+		/// and appends it to the given string.
+		/// If timeZoneDifferential is UTC, "GMT" is returned,
+		/// otherwise ++HHMM (or -HHMM) is returned.
+};
+
+
+//
+// inlines
+//
+inline std::string DateTimeFormatter::format(const Timestamp& timestamp, const std::string& fmt, int timeZoneDifferential)
+{
+	DateTime dateTime(timestamp);
+	return format(dateTime, fmt, timeZoneDifferential);
+}
+
+
+inline std::string DateTimeFormatter::format(const DateTime& dateTime, const std::string& fmt, int timeZoneDifferential)
+{
+	std::string result;
+	result.reserve(64);
+	append(result, dateTime, fmt, timeZoneDifferential);
+	return result;
+}
+
+
+inline std::string DateTimeFormatter::format(const LocalDateTime& dateTime, const std::string& fmt)
+{
+	return format(dateTime._dateTime, fmt, dateTime._tzd);
+}
+
+
+inline std::string DateTimeFormatter::format(const Timespan& timespan, const std::string& fmt)
+{
+	std::string result;
+	result.reserve(32);
+	append(result, timespan, fmt);
+	return result;
+}
+
+
+inline void DateTimeFormatter::append(std::string& str, const Timestamp& timestamp, const std::string& fmt, int timeZoneDifferential)
+{
+	DateTime dateTime(timestamp);
+	append(str, dateTime, fmt, timeZoneDifferential);
+}
+
+
+inline std::string DateTimeFormatter::tzdISO(int timeZoneDifferential)
+{
+	std::string result;
+	result.reserve(8);
+	tzdISO(result, timeZoneDifferential);
+	return result;
+}
+
+
+inline std::string DateTimeFormatter::tzdRFC(int timeZoneDifferential)
+{
+	std::string result;
+	result.reserve(8);
+	tzdRFC(result, timeZoneDifferential);
+	return result;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_DateTimeFormatter_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/DateTimeParser.h b/base/poco/Foundation/include/Poco/DateTimeParser.h
new file mode 100644
index 00000000000..28ebbe75628
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/DateTimeParser.h
@@ -0,0 +1,116 @@
+//
+// DateTimeParser.h
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  DateTimeParser
+//
+// Definition of the DateTimeParser class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_DateTimeParser_INCLUDED
+#define Foundation_DateTimeParser_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/DateTime.h"
+
+
+namespace Poco {
+
+
+class Foundation_API DateTimeParser
+	/// This class provides a method for parsing dates and times
+	/// from strings. All parsing methods do their best to
+	/// parse a meaningful result, even from malformed input
+	/// strings.
+	///
+	/// The returned DateTime will always contain a time in the same
+	/// timezone as the time in the string. Call DateTime::makeUTC()
+	/// with the timeZoneDifferential returned by parse() to convert
+	/// the DateTime to UTC.
+	///
+	/// Note: When parsing a time in 12-hour (AM/PM) format, the hour
+	/// (%h) must be parsed before the AM/PM designator (%a, %A),
+	/// otherwise the AM/PM designator will be ignored.
+	///
+	/// See the DateTimeFormatter class for a list of supported format specifiers.
+	/// In addition to the format specifiers supported by DateTimeFormatter, an
+	/// additional specifier is supported: %r will parse a year given by either
+	/// two or four digits. Years 69-00 are interpreted in the 20th century
+	/// (1969-2000), years 01-68 in the 21th century (2001-2068).
+	///
+	/// Note that in the current implementation all characters other than format specifiers in 
+	/// the format string are ignored/not matched against the date/time string. This may
+	/// lead to non-error results even with nonsense input strings.
+	/// This may change in a future version to a more strict behavior.
+	/// If more strict format validation of date/time strings is required, a regular
+	/// expression could be used for initial validation, before passing the string
+	/// to DateTimeParser.
+{
+public:
+	static void parse(const std::string& fmt, const std::string& str, DateTime& dateTime, int& timeZoneDifferential);
+		/// Parses a date and time in the given format from the given string.
+		/// Throws a SyntaxException if the string cannot be successfully parsed.
+		/// Please see DateTimeFormatter::format() for a description of the format string.
+		/// Class DateTimeFormat defines format strings for various standard date/time formats.
+
+	static DateTime parse(const std::string& fmt, const std::string& str, int& timeZoneDifferential);
+		/// Parses a date and time in the given format from the given string.
+		/// Throws a SyntaxException if the string cannot be successfully parsed.
+		/// Please see DateTimeFormatter::format() for a description of the format string.
+		/// Class DateTimeFormat defines format strings for various standard date/time formats.
+		
+	static bool tryParse(const std::string& fmt, const std::string& str, DateTime& dateTime, int& timeZoneDifferential);
+		/// Parses a date and time in the given format from the given string.
+		/// Returns true if the string has been successfully parsed, false otherwise.
+		/// Please see DateTimeFormatter::format() for a description of the format string.
+		/// Class DateTimeFormat defines format strings for various standard date/time formats.
+		
+	static void parse(const std::string& str, DateTime& dateTime, int& timeZoneDifferential);
+		/// Parses a date and time from the given dateTime string. Before parsing, the method
+		/// examines the dateTime string for a known date/time format.
+		/// Throws a SyntaxException if the string cannot be successfully parsed.
+		/// Please see DateTimeFormatter::format() for a description of the format string.
+		/// Class DateTimeFormat defines format strings for various standard date/time formats.
+
+	static DateTime parse(const std::string& str, int& timeZoneDifferential);
+		/// Parses a date and time from the given dateTime string. Before parsing, the method
+		/// examines the dateTime string for a known date/time format.
+		/// Please see DateTimeFormatter::format() for a description of the format string.
+		/// Class DateTimeFormat defines format strings for various standard date/time formats.
+		
+	static bool tryParse(const std::string& str, DateTime& dateTime, int& timeZoneDifferential);
+		/// Parses a date and time from the given dateTime string. Before parsing, the method
+		/// examines the dateTime string for a known date/time format.
+		/// Please see DateTimeFormatter::format() for a description of the format string.
+		/// Class DateTimeFormat defines format strings for various standard date/time formats.
+
+	static int parseMonth(std::string::const_iterator& it, const std::string::const_iterator& end);
+		/// Tries to interpret the given range as a month name. The range must be at least
+		/// three characters long. 
+		/// Returns the month number (1 .. 12) if the month name is valid. Otherwise throws
+		/// a SyntaxException.
+
+	static int parseDayOfWeek(std::string::const_iterator& it, const std::string::const_iterator& end);
+		/// Tries to interpret the given range as a weekday name. The range must be at least
+		/// three characters long. 
+		/// Returns the weekday number (0 .. 6, where 0 = Synday, 1 = Monday, etc.) if the 
+		/// weekday name is valid. Otherwise throws a SyntaxException.
+		
+protected:
+	static int parseTZD(std::string::const_iterator& it, const std::string::const_iterator& end);
+	static int parseAMPM(std::string::const_iterator& it, const std::string::const_iterator& end, int hour);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_DateTimeParser_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Debugger.h b/base/poco/Foundation/include/Poco/Debugger.h
new file mode 100644
index 00000000000..f1de9fc38bb
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Debugger.h
@@ -0,0 +1,70 @@
+//
+// Debugger.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Debugger
+//
+// Definition of the Debugger class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Debugger_INCLUDED
+#define Foundation_Debugger_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Debugger
+	/// The Debugger class provides an interface to the debugger.
+	/// The presence of a debugger can be checked for,
+	/// messages can be written to the debugger's log window
+	/// and a break into the debugger can be enforced.
+	/// The methods only work if the program is compiled
+	/// in debug mode (the macro _DEBUG is defined).
+{
+public:
+	static bool isAvailable();
+		/// Returns true if a debugger is available, false otherwise.
+		/// On Windows, this function uses the IsDebuggerPresent()
+		/// function.
+		/// On Unix, this function returns true if the environment
+		/// variable POCO_ENABLE_DEBUGGER is set.
+
+	static void message(const std::string& msg);
+		/// Writes a message to the debugger log, if available, otherwise to
+		/// standard error output.
+
+	static void message(const std::string& msg, const char* file, int line);
+		/// Writes a message to the debugger log, if available, otherwise to
+		/// standard error output.
+
+	static void enter();
+		/// Breaks into the debugger, if it is available.
+		/// On Windows, this is done using the DebugBreak() function.
+		/// On Unix, the SIGINT signal is raised.
+
+	static void enter(const std::string& msg);
+		/// Writes a debug message to the debugger log and breaks into it.
+
+	static void enter(const std::string& msg, const char* file, int line);
+		/// Writes a debug message to the debugger log and breaks into it.
+
+	static void enter(const char* file, int line);
+		/// Writes a debug message to the debugger log and breaks into it.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Debugger_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/DefaultStrategy.h b/base/poco/Foundation/include/Poco/DefaultStrategy.h
new file mode 100644
index 00000000000..6a095114eb0
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/DefaultStrategy.h
@@ -0,0 +1,226 @@
+//
+// DefaultStrategy.h
+//
+// Library: Foundation
+// Package: Events
+// Module:  DefaultStrategy
+//
+// Implementation of the DefaultStrategy template.
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_DefaultStrategy_INCLUDED
+#define Foundation_DefaultStrategy_INCLUDED
+
+
+#include "Poco/NotificationStrategy.h"
+#include "Poco/SharedPtr.h"
+#include <vector>
+
+
+namespace Poco {
+
+
+template <class TArgs, class TDelegate> 
+class DefaultStrategy: public NotificationStrategy<TArgs, TDelegate>
+	/// Default notification strategy.
+	///
+	/// Internally, a std::vector<> is used to store
+	/// delegate objects. Delegates are invoked in the
+	/// order in which they have been registered.
+{
+public:
+	typedef TDelegate*                   DelegateHandle;
+	typedef SharedPtr<TDelegate>         DelegatePtr;
+	typedef std::vector<DelegatePtr>     Delegates;
+	typedef typename Delegates::iterator Iterator;
+
+public:
+	DefaultStrategy()
+	{
+	}
+
+	DefaultStrategy(const DefaultStrategy& s):
+		_delegates(s._delegates)
+	{
+	}
+
+	~DefaultStrategy()
+	{
+	}
+
+	void notify(const void* sender, TArgs& arguments)
+	{
+		for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
+		{
+			(*it)->notify(sender, arguments);
+		}
+	}
+
+	DelegateHandle add(const TDelegate& delegate)
+	{
+		DelegatePtr pDelegate(static_cast<TDelegate*>(delegate.clone()));
+		_delegates.push_back(pDelegate);
+		return pDelegate.get();
+	}
+
+	void remove(const TDelegate& delegate)
+	{
+		for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
+		{
+			if (delegate.equals(**it))
+			{
+				(*it)->disable();
+				_delegates.erase(it);
+				return;
+			}
+		}
+	}
+	
+	void remove(DelegateHandle delegateHandle)
+	{
+		for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
+		{
+			if (*it == delegateHandle)
+			{
+				(*it)->disable();
+				_delegates.erase(it);
+				return;
+			}
+		}
+	}
+
+	DefaultStrategy& operator = (const DefaultStrategy& s)
+	{
+		if (this != &s)
+		{
+			_delegates = s._delegates;
+		}
+		return *this;
+	}
+
+	void clear()
+	{
+		for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
+		{
+			(*it)->disable();
+		}
+		_delegates.clear();
+	}
+
+	bool empty() const
+	{
+		return _delegates.empty();
+	}
+
+protected:
+	Delegates _delegates;
+};
+
+
+template <class TDelegate>
+class DefaultStrategy<void,TDelegate>: public NotificationStrategy<void, TDelegate>
+	/// Default notification strategy.
+	///
+	/// Internally, a std::vector<> is used to store
+	/// delegate objects. Delegates are invoked in the
+	/// order in which they have been registered.
+{
+public:
+	typedef TDelegate*                   DelegateHandle;
+	typedef SharedPtr<TDelegate>         DelegatePtr;
+	typedef std::vector<DelegatePtr>     Delegates;
+	typedef typename Delegates::iterator Iterator;
+
+public:
+	DefaultStrategy()
+	{
+	}
+
+	DefaultStrategy(const DefaultStrategy& s):
+		_delegates(s._delegates)
+	{
+	}
+
+	~DefaultStrategy()
+	{
+	}
+
+	void notify(const void* sender)
+	{
+		for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
+		{
+			(*it)->notify(sender);
+		}
+	}
+
+	DelegateHandle add(const TDelegate& delegate)
+	{
+		DelegatePtr pDelegate(static_cast<TDelegate*>(delegate.clone()));
+		_delegates.push_back(pDelegate);
+		return pDelegate.get();
+	}
+
+	void remove(const TDelegate& delegate)
+	{
+		for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
+		{
+			if (delegate.equals(**it))
+			{
+				(*it)->disable();
+				_delegates.erase(it);
+				return;
+			}
+		}
+	}
+
+	void remove(DelegateHandle delegateHandle)
+	{
+		for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
+		{
+			if (*it == delegateHandle)
+			{
+				(*it)->disable();
+				_delegates.erase(it);
+				return;
+			}
+		}
+	}
+
+	DefaultStrategy& operator = (const DefaultStrategy& s)
+	{
+		if (this != &s)
+		{
+			_delegates = s._delegates;
+		}
+		return *this;
+	}
+
+	void clear()
+	{
+		for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
+		{
+			(*it)->disable();
+		}
+		_delegates.clear();
+	}
+
+	bool empty() const
+	{
+		return _delegates.empty();
+	}
+
+protected:
+	Delegates _delegates;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_DefaultStrategy_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/DeflatingStream.h b/base/poco/Foundation/include/Poco/DeflatingStream.h
new file mode 100644
index 00000000000..f7acb899f83
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/DeflatingStream.h
@@ -0,0 +1,201 @@
+//
+// DeflatingStream.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  ZLibStream
+//
+// Definition of the DeflatingStream class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_DeflatingStream_INCLUDED
+#define Foundation_DeflatingStream_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/BufferedStreamBuf.h"
+#include <istream>
+#include <ostream>
+#if defined(POCO_UNBUNDLED_ZLIB)
+#include <zlib.h>
+#else
+#include "Poco/zlib.h"
+#endif
+
+
+namespace Poco {
+
+
+class Foundation_API DeflatingStreamBuf: public BufferedStreamBuf
+	/// This is the streambuf class used by DeflatingInputStream and DeflatingOutputStream.
+	/// The actual work is delegated to zlib (see http://zlib.net).
+	/// Both zlib (deflate) streams and gzip streams are supported.
+	/// Output streams should always call close() to ensure
+	/// proper completion of compression.
+	/// A compression level (0 to 9) can be specified in the constructor.
+{
+public:
+	enum StreamType
+	{
+		STREAM_ZLIB, /// Create a zlib header, use Adler-32 checksum.
+		STREAM_GZIP  /// Create a gzip header, use CRC-32 checksum.
+	};
+
+	DeflatingStreamBuf(std::istream& istr, StreamType type, int level);
+		/// Creates a DeflatingStreamBuf for compressing data read
+		/// from the given input stream.
+
+	DeflatingStreamBuf(std::istream& istr, int windowBits, int level);
+		/// Creates a DeflatingStreamBuf for compressing data read
+		/// from the given input stream.
+		///
+		/// Please refer to the zlib documentation of deflateInit2() for a description
+		/// of the windowBits parameter.
+		
+	DeflatingStreamBuf(std::ostream& ostr, StreamType type, int level);
+		/// Creates a DeflatingStreamBuf for compressing data passed
+		/// through and forwarding it to the given output stream.
+
+	DeflatingStreamBuf(std::ostream& ostr, int windowBits, int level);
+		/// Creates a DeflatingStreamBuf for compressing data passed
+		/// through and forwarding it to the given output stream.
+		///
+		/// Please refer to the zlib documentation of deflateInit2() for a description
+		/// of the windowBits parameter.
+		
+	~DeflatingStreamBuf();
+		/// Destroys the DeflatingStreamBuf.
+		
+	int close();
+		/// Finishes up the stream.
+		///
+		/// Must be called when deflating to an output stream.
+
+protected:
+	int readFromDevice(char* buffer, std::streamsize length);
+	int writeToDevice(const char* buffer, std::streamsize length);
+	virtual int sync();
+
+private:
+	enum
+	{
+		STREAM_BUFFER_SIZE  = 1024,
+		DEFLATE_BUFFER_SIZE = 32768
+	};
+
+	std::istream* _pIstr;
+	std::ostream* _pOstr;
+	char*    _buffer;
+	z_stream _zstr;
+	bool     _eof;
+};
+
+
+class Foundation_API DeflatingIOS: public virtual std::ios
+	/// The base class for DeflatingOutputStream and DeflatingInputStream.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	DeflatingIOS(std::ostream& ostr, DeflatingStreamBuf::StreamType type = DeflatingStreamBuf::STREAM_ZLIB, int level = Z_DEFAULT_COMPRESSION);
+		/// Creates a DeflatingIOS for compressing data passed
+		/// through and forwarding it to the given output stream.
+
+	DeflatingIOS(std::ostream& ostr, int windowBits, int level);
+		/// Creates a DeflatingIOS for compressing data passed
+		/// through and forwarding it to the given output stream.
+		///
+		/// Please refer to the zlib documentation of deflateInit2() for a description
+		/// of the windowBits parameter.
+
+	DeflatingIOS(std::istream& istr, DeflatingStreamBuf::StreamType type = DeflatingStreamBuf::STREAM_ZLIB, int level = Z_DEFAULT_COMPRESSION);
+		/// Creates a DeflatingIOS for compressing data read
+		/// from the given input stream.
+
+	DeflatingIOS(std::istream& istr, int windowBits, int level);
+		/// Creates a DeflatingIOS for compressing data read
+		/// from the given input stream.
+		///
+		/// Please refer to the zlib documentation of deflateInit2() for a description
+		/// of the windowBits parameter.
+
+	~DeflatingIOS();
+		/// Destroys the DeflatingIOS.
+		
+	DeflatingStreamBuf* rdbuf();
+		/// Returns a pointer to the underlying stream buffer.
+		
+protected:
+	DeflatingStreamBuf _buf;
+};
+
+
+class Foundation_API DeflatingOutputStream: public std::ostream, public DeflatingIOS
+	/// This stream compresses all data passing through it
+	/// using zlib's deflate algorithm.
+	/// After all data has been written to the stream, close()
+	/// must be called to ensure completion of compression.
+	/// Example:
+	///     std::ofstream ostr("data.gz", std::ios::binary);
+	///     DeflatingOutputStream deflater(ostr, DeflatingStreamBuf::STREAM_GZIP);
+	///     deflater << "Hello, world!" << std::endl;
+	///     deflater.close();
+	///     ostr.close();
+{
+public:
+	DeflatingOutputStream(std::ostream& ostr, DeflatingStreamBuf::StreamType type = DeflatingStreamBuf::STREAM_ZLIB, int level = Z_DEFAULT_COMPRESSION);
+		/// Creates a DeflatingOutputStream for compressing data passed
+		/// through and forwarding it to the given output stream.
+
+	DeflatingOutputStream(std::ostream& ostr, int windowBits, int level);
+		/// Creates a DeflatingOutputStream for compressing data passed
+		/// through and forwarding it to the given output stream.
+		///
+		/// Please refer to the zlib documentation of deflateInit2() for a description
+		/// of the windowBits parameter.
+
+	~DeflatingOutputStream();
+		/// Destroys the DeflatingOutputStream.
+		
+	int close();
+		/// Finishes up the stream.
+		///
+		/// Must be called when deflating to an output stream.
+
+protected:
+	virtual int sync();
+};
+
+
+class Foundation_API DeflatingInputStream: public std::istream, public DeflatingIOS
+	/// This stream compresses all data passing through it
+	/// using zlib's deflate algorithm.
+{
+public:
+	DeflatingInputStream(std::istream& istr, DeflatingStreamBuf::StreamType type = DeflatingStreamBuf::STREAM_ZLIB, int level = Z_DEFAULT_COMPRESSION);
+		/// Creates a DeflatingIOS for compressing data read
+		/// from the given input stream.
+
+	DeflatingInputStream(std::istream& istr, int windowBits, int level);
+		/// Creates a DeflatingIOS for compressing data read
+		/// from the given input stream.
+		///
+		/// Please refer to the zlib documentation of deflateInit2() for a description
+		/// of the windowBits parameter.
+
+	~DeflatingInputStream();
+		/// Destroys the DeflatingInputStream.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_DeflatingStream_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Delegate.h b/base/poco/Foundation/include/Poco/Delegate.h
new file mode 100644
index 00000000000..b0b2c7615a7
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Delegate.h
@@ -0,0 +1,452 @@
+//
+// Delegate.h
+//
+// Library: Foundation
+// Package: Events
+// Module:  Delegate
+//
+// Implementation of the Delegate template.
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Delegate_INCLUDED
+#define Foundation_Delegate_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/AbstractDelegate.h"
+#include "Poco/FunctionDelegate.h"
+#include "Poco/Expire.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+
+
+template <class TObj, class TArgs, bool withSender = true>
+class Delegate: public AbstractDelegate<TArgs>
+{
+public:
+	typedef void (TObj::*NotifyMethod)(const void*, TArgs&);
+
+	Delegate(TObj* obj, NotifyMethod method):
+		_receiverObject(obj),
+		_receiverMethod(method)
+	{
+	}
+
+	Delegate(const Delegate& delegate):
+		AbstractDelegate<TArgs>(delegate),
+		_receiverObject(delegate._receiverObject),
+		_receiverMethod(delegate._receiverMethod)
+	{
+	}
+
+	~Delegate()
+	{
+	}
+
+	Delegate& operator = (const Delegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_receiverObject = delegate._receiverObject;
+			this->_receiverMethod = delegate._receiverMethod;
+		}
+		return *this;
+	}
+
+	bool notify(const void* sender, TArgs& arguments)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_receiverObject)
+		{
+			(_receiverObject->*_receiverMethod)(sender, arguments);
+			return true;
+		}
+		else return false;
+	}
+
+	bool equals(const AbstractDelegate<TArgs>& other) const
+	{
+		const Delegate* pOtherDelegate = dynamic_cast<const Delegate*>(other.unwrap());
+		return pOtherDelegate && _receiverObject == pOtherDelegate->_receiverObject && _receiverMethod == pOtherDelegate->_receiverMethod;
+	}
+
+	AbstractDelegate<TArgs>* clone() const
+	{
+		return new Delegate(*this);
+	}
+
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_receiverObject = 0;
+	}
+
+protected:
+	TObj*        _receiverObject;
+	NotifyMethod _receiverMethod;
+	Mutex        _mutex;
+
+private:
+	Delegate();
+};
+
+
+template <class TObj, class TArgs>
+class Delegate<TObj, TArgs, false>: public AbstractDelegate<TArgs>
+{
+public:
+	typedef void (TObj::*NotifyMethod)(TArgs&);
+
+	Delegate(TObj* obj, NotifyMethod method):
+		_receiverObject(obj),
+		_receiverMethod(method)
+	{
+	}
+
+	Delegate(const Delegate& delegate):
+		AbstractDelegate<TArgs>(delegate),
+		_receiverObject(delegate._receiverObject),
+		_receiverMethod(delegate._receiverMethod)
+	{
+	}
+
+	~Delegate()
+	{
+	}
+
+	Delegate& operator = (const Delegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_receiverObject = delegate._receiverObject;
+			this->_receiverMethod = delegate._receiverMethod;
+		}
+		return *this;
+	}
+
+	bool notify(const void*, TArgs& arguments)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_receiverObject)
+		{
+			(_receiverObject->*_receiverMethod)(arguments);
+			return true;
+		}
+		else return false;
+	}
+
+	bool equals(const AbstractDelegate<TArgs>& other) const
+	{
+		const Delegate* pOtherDelegate = dynamic_cast<const Delegate*>(other.unwrap());
+		return pOtherDelegate && _receiverObject == pOtherDelegate->_receiverObject && _receiverMethod == pOtherDelegate->_receiverMethod;
+	}
+
+	AbstractDelegate<TArgs>* clone() const
+	{
+		return new Delegate(*this);
+	}
+
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_receiverObject = 0;
+	}
+
+protected:
+	TObj*        _receiverObject;
+	NotifyMethod _receiverMethod;
+	Mutex        _mutex;
+
+private:
+	Delegate();
+};
+
+
+template <class TObj, class TArgs>
+inline Delegate<TObj, TArgs, true> delegate(TObj* pObj, void (TObj::*NotifyMethod)(const void*, TArgs&))
+{
+	return Delegate<TObj, TArgs, true>(pObj, NotifyMethod);
+}
+
+
+template <class TObj, class TArgs>
+inline Delegate<TObj, TArgs, false> delegate(TObj* pObj, void (TObj::*NotifyMethod)(TArgs&))
+{
+	return Delegate<TObj, TArgs, false>(pObj, NotifyMethod);
+}
+
+
+template <class TObj, class TArgs>
+inline Expire<TArgs> delegate(TObj* pObj, void (TObj::*NotifyMethod)(const void*, TArgs&), Timestamp::TimeDiff expireMillisecs)
+{
+	return Expire<TArgs>(Delegate<TObj, TArgs, true>(pObj, NotifyMethod), expireMillisecs);
+}
+
+
+template <class TObj, class TArgs>
+inline Expire<TArgs> delegate(TObj* pObj, void (TObj::*NotifyMethod)(TArgs&), Timestamp::TimeDiff expireMillisecs)
+{
+	return Expire<TArgs>(Delegate<TObj, TArgs, false>(pObj, NotifyMethod), expireMillisecs);
+}
+
+
+template <class TArgs>
+inline Expire<TArgs> delegate(void (*NotifyMethod)(const void*, TArgs&), Timestamp::TimeDiff expireMillisecs)
+{
+	return Expire<TArgs>(FunctionDelegate<TArgs, true, true>(NotifyMethod), expireMillisecs);
+}
+
+
+template <class TArgs>
+inline Expire<TArgs> delegate(void (*NotifyMethod)(void*, TArgs&), Timestamp::TimeDiff expireMillisecs)
+{
+	return Expire<TArgs>(FunctionDelegate<TArgs, true, false>(NotifyMethod), expireMillisecs);
+}
+
+
+template <class TArgs>
+inline Expire<TArgs> delegate(void (*NotifyMethod)(TArgs&), Timestamp::TimeDiff expireMillisecs)
+{
+	return Expire<TArgs>(FunctionDelegate<TArgs, false>(NotifyMethod), expireMillisecs);
+}
+
+
+template <class TArgs>
+inline FunctionDelegate<TArgs, true, true> delegate(void (*NotifyMethod)(const void*, TArgs&))
+{
+	return FunctionDelegate<TArgs, true, true>(NotifyMethod);
+}
+
+
+template <class TArgs>
+inline FunctionDelegate<TArgs, true, false> delegate(void (*NotifyMethod)(void*, TArgs&))
+{
+	return FunctionDelegate<TArgs, true, false>(NotifyMethod);
+}
+
+
+template <class TArgs>
+inline FunctionDelegate<TArgs, false> delegate(void (*NotifyMethod)(TArgs&))
+{
+	return FunctionDelegate<TArgs, false>(NotifyMethod);
+}
+
+
+template <class TObj>
+class Delegate<TObj,void,true>: public AbstractDelegate<void>
+{
+public:
+	typedef void (TObj::*NotifyMethod)(const void*);
+
+	Delegate(TObj* obj, NotifyMethod method):
+		_receiverObject(obj),
+		_receiverMethod(method)
+	{
+	}
+
+	Delegate(const Delegate& delegate):
+		AbstractDelegate<void>(delegate),
+		_receiverObject(delegate._receiverObject),
+		_receiverMethod(delegate._receiverMethod)
+	{
+	}
+
+	~Delegate()
+	{
+	}
+
+	Delegate& operator = (const Delegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_receiverObject = delegate._receiverObject;
+			this->_receiverMethod = delegate._receiverMethod;
+		}
+		return *this;
+	}
+
+	bool notify(const void* sender)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_receiverObject)
+		{
+			(_receiverObject->*_receiverMethod)(sender);
+			return true;
+		}
+		else return false;
+	}
+
+	bool equals(const AbstractDelegate<void>& other) const
+	{
+		const Delegate* pOtherDelegate = dynamic_cast<const Delegate*>(other.unwrap());
+		return pOtherDelegate && _receiverObject == pOtherDelegate->_receiverObject && _receiverMethod == pOtherDelegate->_receiverMethod;
+	}
+
+	AbstractDelegate<void>* clone() const
+	{
+		return new Delegate(*this);
+	}
+
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_receiverObject = 0;
+	}
+
+protected:
+	TObj*        _receiverObject;
+	NotifyMethod _receiverMethod;
+	Mutex        _mutex;
+
+private:
+	Delegate();
+};
+
+
+template <class TObj>
+class Delegate<TObj, void, false>: public AbstractDelegate<void>
+{
+public:
+	typedef void (TObj::*NotifyMethod)();
+
+	Delegate(TObj* obj, NotifyMethod method):
+		_receiverObject(obj),
+		_receiverMethod(method)
+	{
+	}
+
+	Delegate(const Delegate& delegate):
+		AbstractDelegate<void>(delegate),
+		_receiverObject(delegate._receiverObject),
+		_receiverMethod(delegate._receiverMethod)
+	{
+	}
+
+	~Delegate()
+	{
+	}
+
+	Delegate& operator = (const Delegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_receiverObject = delegate._receiverObject;
+			this->_receiverMethod = delegate._receiverMethod;
+		}
+		return *this;
+	}
+
+	bool notify(const void*)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_receiverObject)
+		{
+			(_receiverObject->*_receiverMethod)();
+			return true;
+		}
+		else return false;
+	}
+
+	bool equals(const AbstractDelegate<void>& other) const
+	{
+		const Delegate* pOtherDelegate = dynamic_cast<const Delegate*>(other.unwrap());
+		return pOtherDelegate && _receiverObject == pOtherDelegate->_receiverObject && _receiverMethod == pOtherDelegate->_receiverMethod;
+	}
+
+	AbstractDelegate<void>* clone() const
+	{
+		return new Delegate(*this);
+	}
+
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_receiverObject = 0;
+	}
+
+protected:
+	TObj*        _receiverObject;
+	NotifyMethod _receiverMethod;
+	Mutex        _mutex;
+
+private:
+	Delegate();
+};
+
+
+template <class TObj>
+inline Delegate<TObj, void, true> delegate(TObj* pObj, void (TObj::*NotifyMethod)(const void*))
+{
+	return Delegate<TObj, void, true>(pObj, NotifyMethod);
+}
+
+
+template <class TObj>
+inline Delegate<TObj, void, false> delegate(TObj* pObj, void (TObj::*NotifyMethod)())
+{
+	return Delegate<TObj, void, false>(pObj, NotifyMethod);
+}
+
+
+template <class TObj>
+inline Expire<void> delegate(TObj* pObj, void (TObj::*NotifyMethod)(const void*), Timestamp::TimeDiff expireMillisecs)
+{
+	return Expire<void>(Delegate<TObj, void, true>(pObj, NotifyMethod), expireMillisecs);
+}
+
+
+template <class TObj>
+inline Expire<void> delegate(TObj* pObj, void (TObj::*NotifyMethod)(), Timestamp::TimeDiff expireMillisecs)
+{
+	return Expire<void>(Delegate<TObj, void, false>(pObj, NotifyMethod), expireMillisecs);
+}
+
+
+inline Expire<void> delegate(void (*NotifyMethod)(const void*), Timestamp::TimeDiff expireMillisecs)
+{
+	return Expire<void>(FunctionDelegate<void, true, true>(NotifyMethod), expireMillisecs);
+}
+
+
+inline Expire<void> delegate(void (*NotifyMethod)(void*), Timestamp::TimeDiff expireMillisecs)
+{
+	return Expire<void>(FunctionDelegate<void, true, false>(NotifyMethod), expireMillisecs);
+}
+
+
+inline Expire<void> delegate(void (*NotifyMethod)(), Timestamp::TimeDiff expireMillisecs)
+{
+	return Expire<void>(FunctionDelegate<void, false>(NotifyMethod), expireMillisecs);
+}
+
+
+inline FunctionDelegate<void, true, true> delegate(void (*NotifyMethod)(const void*))
+{
+	return FunctionDelegate<void, true, true>(NotifyMethod);
+}
+
+
+inline FunctionDelegate<void, true, false> delegate(void (*NotifyMethod)(void*))
+{
+	return FunctionDelegate<void, true, false>(NotifyMethod);
+}
+
+
+inline FunctionDelegate<void, false> delegate(void (*NotifyMethod)())
+{
+	return FunctionDelegate<void, false>(NotifyMethod);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Delegate_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/DigestEngine.h b/base/poco/Foundation/include/Poco/DigestEngine.h
new file mode 100644
index 00000000000..b22ab6d8937
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/DigestEngine.h
@@ -0,0 +1,111 @@
+//
+// DigestEngine.h
+//
+// Library: Foundation
+// Package: Crypt
+// Module:  DigestEngine
+//
+// Definition of class DigestEngine.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_DigestEngine_INCLUDED
+#define Foundation_DigestEngine_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <vector>
+
+
+namespace Poco {
+
+
+class Foundation_API DigestEngine
+	/// This class is an abstract base class
+	/// for all classes implementing a message
+	/// digest algorithm, like MD5Engine
+	/// and SHA1Engine.
+	/// Call update() repeatedly with data to
+	/// compute the digest from. When done,
+	/// call digest() to obtain the message
+	/// digest.
+{
+public:
+	typedef std::vector<unsigned char> Digest;
+
+	DigestEngine();
+	virtual ~DigestEngine();
+
+	void update(const void* data, std::size_t length);
+	void update(char data);
+	void update(const std::string& data);
+		/// Updates the digest with the given data.
+
+	virtual std::size_t digestLength() const = 0;
+		/// Returns the length of the digest in bytes.
+
+	virtual void reset() = 0;
+		/// Resets the engine so that a new
+		/// digest can be computed.
+
+	virtual const Digest& digest() = 0;
+		/// Finishes the computation of the digest and
+		/// returns the message digest. Resets the engine
+		/// and can thus only be called once for every digest.
+		/// The returned reference is valid until the next
+		/// time digest() is called, or the engine object is destroyed.
+
+	static std::string digestToHex(const Digest& bytes);
+		/// Converts a message digest into a string of hexadecimal numbers.
+
+	static Digest digestFromHex(const std::string& digest);
+		/// Converts a string created by digestToHex back to its Digest presentation
+
+	static bool constantTimeEquals(const Digest& d1, const Digest& d2);
+		/// Compares two Digest values using a constant-time comparison
+		/// algorithm. This can be used to prevent timing attacks
+		/// (as discussed in <https://codahale.com/a-lesson-in-timing-attacks/>).
+
+protected:
+	virtual void updateImpl(const void* data, std::size_t length) = 0;
+		/// Updates the digest with the given data. Must be implemented
+		/// by subclasses.
+
+private:
+	DigestEngine(const DigestEngine&);
+	DigestEngine& operator = (const DigestEngine&);
+};
+
+
+//
+// inlines
+//
+
+
+inline void DigestEngine::update(const void* data, std::size_t length)
+{
+	updateImpl(data, length);
+}
+
+
+inline void DigestEngine::update(char data)
+{
+	updateImpl(&data, 1);
+}
+
+
+inline void DigestEngine::update(const std::string& data)
+{
+	updateImpl(data.data(), data.size());
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_DigestEngine_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/DigestStream.h b/base/poco/Foundation/include/Poco/DigestStream.h
new file mode 100644
index 00000000000..6976e01aa49
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/DigestStream.h
@@ -0,0 +1,100 @@
+//
+// DigestStream.h
+//
+// Library: Foundation
+// Package: Crypt
+// Module:  DigestStream
+//
+// Definition of classes DigestInputStream and DigestOutputStream.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_DigestStream_INCLUDED
+#define Foundation_DigestStream_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/BufferedStreamBuf.h"
+#include "Poco/DigestEngine.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+
+
+class Foundation_API DigestBuf: public BufferedStreamBuf
+	/// This streambuf computes a digest of all data going
+	/// through it.
+{
+public:
+	DigestBuf(DigestEngine& eng);
+	DigestBuf(DigestEngine& eng, std::istream& istr);
+	DigestBuf(DigestEngine& eng, std::ostream& ostr);
+	~DigestBuf();	
+	int readFromDevice(char* buffer, std::streamsize length);
+	int writeToDevice(const char* buffer, std::streamsize length);
+	void close();
+
+private:
+	DigestEngine& _eng;
+	std::istream* _pIstr;
+	std::ostream* _pOstr;
+	static const int BUFFER_SIZE;
+};
+
+
+class Foundation_API DigestIOS: public virtual std::ios
+	/// The base class for DigestInputStream and DigestOutputStream.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	DigestIOS(DigestEngine& eng);
+	DigestIOS(DigestEngine& eng, std::istream& istr);
+	DigestIOS(DigestEngine& eng, std::ostream& ostr);
+	~DigestIOS();
+	DigestBuf* rdbuf();
+
+protected:
+	DigestBuf _buf;
+};
+
+
+class Foundation_API DigestInputStream: public DigestIOS, public std::istream
+	/// This istream computes a digest of
+	/// all the data passing through it,
+	/// using a DigestEngine.
+{
+public:
+	DigestInputStream(DigestEngine& eng, std::istream& istr);
+	~DigestInputStream();
+};
+
+
+class Foundation_API DigestOutputStream: public DigestIOS, public std::ostream
+	/// This ostream computes a digest of
+	/// all the data passing through it,
+	/// using a DigestEngine.
+	/// To ensure that all data has been incorporated
+	/// into the digest, call close() or flush() before 
+	/// you obtain the digest from the digest engine.
+{
+public:
+	DigestOutputStream(DigestEngine& eng);
+	DigestOutputStream(DigestEngine& eng, std::ostream& ostr);
+	~DigestOutputStream();
+	void close();
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_DigestStream_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/DirectoryIterator.h b/base/poco/Foundation/include/Poco/DirectoryIterator.h
new file mode 100644
index 00000000000..c3cedf3f4e8
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/DirectoryIterator.h
@@ -0,0 +1,153 @@
+//
+// DirectoryIterator.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  DirectoryIterator
+//
+// Definition of the DirectoryIterator class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_DirectoryIterator_INCLUDED
+#define Foundation_DirectoryIterator_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/File.h"
+#include "Poco/Path.h"
+
+
+namespace Poco {
+
+
+class DirectoryIteratorImpl;
+
+
+class Foundation_API DirectoryIterator
+	/// The DirectoryIterator class is used to enumerate
+	/// all files in a directory.
+	///
+	/// DirectoryIterator has some limitations:
+	///   * only forward iteration (++) is supported
+	///   * an iterator copied from another one will always
+	///     point to the same file as the original iterator,
+	///     even is the original iterator has been advanced
+	///     (all copies of an iterator share their state with
+	///     the original iterator)
+	///   * because of this you should only use the prefix 
+	///     increment operator
+{
+public:
+	DirectoryIterator();
+		/// Creates the end iterator.
+		
+	DirectoryIterator(const std::string& path);
+		/// Creates a directory iterator for the given path.
+
+	DirectoryIterator(const DirectoryIterator& iterator);
+		/// Creates a directory iterator for the given path.
+		
+	DirectoryIterator(const File& file);
+		/// Creates a directory iterator for the given file.
+
+	DirectoryIterator(const Path& path);
+		/// Creates a directory iterator for the given path.
+
+	virtual ~DirectoryIterator();
+		/// Destroys the DirectoryIterator.
+
+	const std::string& name() const;
+		/// Returns the current filename.
+		
+	const Path& path() const;
+		/// Returns the current path.
+
+	DirectoryIterator& operator = (const DirectoryIterator& it);
+	DirectoryIterator& operator = (const File& file);
+	DirectoryIterator& operator = (const Path& path);
+	DirectoryIterator& operator = (const std::string& path);
+	
+	virtual DirectoryIterator& operator ++ ();   // prefix
+	
+	//@ deprecated
+	DirectoryIterator operator ++ (int); // postfix
+		/// Please use the prefix increment operator instead.
+	
+	const File& operator * () const;
+	File& operator * ();
+	const File* operator -> () const;
+	File* operator -> ();
+	
+	bool operator == (const DirectoryIterator& iterator) const;
+	bool operator != (const DirectoryIterator& iterator) const;
+
+protected:
+	Path _path;
+	File _file;
+
+private:
+	DirectoryIteratorImpl* _pImpl;
+};
+
+
+//
+// inlines
+//
+inline const std::string& DirectoryIterator::name() const
+{
+	return _path.getFileName();
+}
+
+	
+inline const Path& DirectoryIterator::path() const
+{
+	return _path;
+}
+
+
+inline const File& DirectoryIterator::operator * () const
+{
+	return _file;
+}
+
+
+inline File& DirectoryIterator::operator * ()
+{
+	return _file;
+}
+
+
+inline const File* DirectoryIterator::operator -> () const
+{
+	return &_file;
+}
+
+
+inline File* DirectoryIterator::operator -> ()
+{
+	return &_file;
+}
+
+
+inline bool DirectoryIterator::operator == (const DirectoryIterator& iterator) const
+{
+	return name() == iterator.name();
+}
+
+
+inline bool DirectoryIterator::operator != (const DirectoryIterator& iterator) const
+{
+	return name() != iterator.name();
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_DirectoryIterator_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/DirectoryIteratorStrategy.h b/base/poco/Foundation/include/Poco/DirectoryIteratorStrategy.h
new file mode 100644
index 00000000000..4591f7c6077
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/DirectoryIteratorStrategy.h
@@ -0,0 +1,92 @@
+//
+// RecursiveDirectoryIteratorStategies.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  RecursiveDirectoryIterator
+//
+// Definitions of the RecursiveDirectoryIterator stategy classes.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_RecursiveDirectoryIteratorStrategy_INCLUDED
+#define Foundation_RecursiveDirectoryIteratorStrategy_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/DirectoryIterator.h"
+#include <stack>
+#include <queue>
+#include <functional>
+
+
+namespace Poco {
+
+
+class Foundation_API TraverseBase
+{
+public:
+	typedef std::stack<DirectoryIterator> Stack;
+	typedef std::function<UInt16(const Stack&)> DepthFunPtr;
+
+	enum
+	{
+		D_INFINITE = 0 /// Special value for infinite traverse depth.
+	};
+
+	TraverseBase(DepthFunPtr depthDeterminer, UInt16 maxDepth = D_INFINITE);
+
+protected:
+	bool isFiniteDepth();
+	bool isDirectory(Poco::File& file);
+
+	DepthFunPtr _depthDeterminer;
+	UInt16 _maxDepth;
+	DirectoryIterator _itEnd;
+
+private:
+	TraverseBase();
+	TraverseBase(const TraverseBase&);
+	TraverseBase& operator=(const TraverseBase&);
+};
+
+
+class Foundation_API ChildrenFirstTraverse: public TraverseBase
+{
+public:
+	ChildrenFirstTraverse(DepthFunPtr depthDeterminer, UInt16 maxDepth = D_INFINITE);
+
+	const std::string next(Stack* itStack, bool* isFinished);
+
+private:
+	ChildrenFirstTraverse();
+	ChildrenFirstTraverse(const ChildrenFirstTraverse&);
+	ChildrenFirstTraverse& operator=(const ChildrenFirstTraverse&);
+};
+
+
+class Foundation_API SiblingsFirstTraverse: public TraverseBase
+{
+public:
+	SiblingsFirstTraverse(DepthFunPtr depthDeterminer, UInt16 maxDepth = D_INFINITE);
+
+	const std::string next(Stack* itStack, bool* isFinished);
+
+private:
+	SiblingsFirstTraverse();
+	SiblingsFirstTraverse(const SiblingsFirstTraverse&);
+	SiblingsFirstTraverse& operator=(const SiblingsFirstTraverse&);
+
+	std::stack<std::queue<std::string> > _dirsStack;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_RecursiveDirectoryIteratorStrategy_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/DirectoryIterator_UNIX.h b/base/poco/Foundation/include/Poco/DirectoryIterator_UNIX.h
new file mode 100644
index 00000000000..d21f711921a
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/DirectoryIterator_UNIX.h
@@ -0,0 +1,72 @@
+//
+// DirectoryIterator_UNIX.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  DirectoryIterator
+//
+// Definition of the DirectoryIteratorImpl class for UNIX.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_DirectoryIterator_UNIX_INCLUDED
+#define Foundation_DirectoryIterator_UNIX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <dirent.h>
+
+
+namespace Poco {
+
+
+class Foundation_API DirectoryIteratorImpl
+{
+public:
+	DirectoryIteratorImpl(const std::string& path);
+	~DirectoryIteratorImpl();
+	
+	void duplicate();
+	void release();
+	
+	const std::string& get() const;
+	const std::string& next();
+	
+private:
+	DIR*        _pDir;
+	std::string _current;
+	int _rc;
+};
+
+
+//
+// inlines
+//
+const std::string& DirectoryIteratorImpl::get() const
+{
+	return _current;
+}
+
+
+inline void DirectoryIteratorImpl::duplicate()
+{
+	++_rc;
+}
+
+
+inline void DirectoryIteratorImpl::release()
+{
+	if (--_rc == 0)
+		delete this;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_DirectoryIterator_UNIX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/DirectoryIterator_WIN32.h b/base/poco/Foundation/include/Poco/DirectoryIterator_WIN32.h
new file mode 100644
index 00000000000..068cac36759
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/DirectoryIterator_WIN32.h
@@ -0,0 +1,73 @@
+//
+// DirectoryIterator_WIN32.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  DirectoryIterator
+//
+// Definition of the DirectoryIteratorImpl class for WIN32.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_DirectoryIterator_WIN32_INCLUDED
+#define Foundation_DirectoryIterator_WIN32_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API DirectoryIteratorImpl
+{
+public:
+	DirectoryIteratorImpl(const std::string& path);
+	~DirectoryIteratorImpl();
+	
+	void duplicate();
+	void release();
+	
+	const std::string& get() const;
+	const std::string& next();
+	
+private:
+	HANDLE          _fh;
+	WIN32_FIND_DATA _fd;
+	std::string     _current;
+	int _rc;
+};
+
+
+//
+// inlines
+//
+const std::string& DirectoryIteratorImpl::get() const
+{
+	return _current;
+}
+
+
+inline void DirectoryIteratorImpl::duplicate()
+{
+	++_rc;
+}
+
+
+inline void DirectoryIteratorImpl::release()
+{
+	if (--_rc == 0)
+		delete this;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_DirectoryIterator_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/DirectoryIterator_WIN32U.h b/base/poco/Foundation/include/Poco/DirectoryIterator_WIN32U.h
new file mode 100644
index 00000000000..496842c7f92
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/DirectoryIterator_WIN32U.h
@@ -0,0 +1,73 @@
+//
+// DirectoryIterator_WIN32U.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  DirectoryIterator
+//
+// Definition of the DirectoryIteratorImpl class for WIN32.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_DirectoryIterator_WIN32U_INCLUDED
+#define Foundation_DirectoryIterator_WIN32U_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API DirectoryIteratorImpl
+{
+public:
+	DirectoryIteratorImpl(const std::string& path);
+	~DirectoryIteratorImpl();
+	
+	void duplicate();
+	void release();
+	
+	const std::string& get() const;
+	const std::string& next();
+	
+private:
+	HANDLE           _fh;
+	WIN32_FIND_DATAW _fd;
+	std::string      _current;
+	int _rc;
+};
+
+
+//
+// inlines
+//
+const std::string& DirectoryIteratorImpl::get() const
+{
+	return _current;
+}
+
+
+inline void DirectoryIteratorImpl::duplicate()
+{
+	++_rc;
+}
+
+
+inline void DirectoryIteratorImpl::release()
+{
+	if (--_rc == 0)
+		delete this;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_DirectoryIterator_WIN32U_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/DirectoryWatcher.h b/base/poco/Foundation/include/Poco/DirectoryWatcher.h
new file mode 100644
index 00000000000..6e3a492fd59
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/DirectoryWatcher.h
@@ -0,0 +1,232 @@
+//
+// DirectoryWatcher.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  DirectoryWatcher
+//
+// Definition of the DirectoryWatcher class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_DirectoryWatcher_INCLUDED
+#define Foundation_DirectoryWatcher_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+#ifndef POCO_NO_INOTIFY
+
+
+#include "Poco/File.h"
+#include "Poco/BasicEvent.h"
+#include "Poco/Runnable.h"
+#include "Poco/Thread.h"
+#include "Poco/AtomicCounter.h"
+
+
+namespace Poco {
+
+
+class DirectoryWatcherStrategy;
+
+
+class Foundation_API DirectoryWatcher: protected Runnable
+	/// This class is used to get notifications about changes
+	/// to the filesystem, more specifically, to a specific
+	/// directory. Changes to a directory are reported via
+	/// events.
+	///
+	/// A thread will be created that watches the specified
+	/// directory for changes. Events are reported in the context
+	/// of this thread. 
+	///
+	/// Note that changes to files in subdirectories of the watched
+	/// directory are not reported. Separate DirectoryWatcher objects
+	/// must be created for these directories if they should be watched.
+	///
+	/// Changes to file attributes are not reported.
+	///
+	/// On Windows, this class is implemented using FindFirstChangeNotification()/FindNextChangeNotification().
+	/// On Linux, this class is implemented using inotify.
+	/// On FreeBSD and Darwin (Mac OS X, iOS), this class uses kevent/kqueue.
+	/// On all other platforms, the watched directory is periodically scanned
+	/// for changes. This can negatively affect performance if done too often.
+	/// Therefore, the interval in which scans are done can be specified in
+	/// the constructor. Note that periodic scanning will also be done on FreeBSD
+	/// and Darwin if events for changes to files (DW_ITEM_MODIFIED) are enabled.
+	///
+	/// DW_ITEM_MOVED_FROM and DW_ITEM_MOVED_TO events will only be reported
+	/// on Linux. On other platforms, a file rename or move operation
+	/// will be reported via a DW_ITEM_REMOVED and a DW_ITEM_ADDED event.
+	/// The order of these two events is not defined.
+	///
+	/// An event mask can be specified to enable only certain events.
+{
+public:
+	enum DirectoryEventType
+	{
+		DW_ITEM_ADDED = 1,
+			/// A new item has been created and added to the directory.
+			
+		DW_ITEM_REMOVED = 2,
+			/// An item has been removed from the directory.
+
+		DW_ITEM_MODIFIED = 4,
+			/// An item has been modified.
+
+		DW_ITEM_MOVED_FROM = 8,
+			/// An item has been renamed or moved. This event delivers the old name.
+
+		DW_ITEM_MOVED_TO = 16
+			/// An item has been renamed or moved. This event delivers the new name.
+	};
+
+	enum DirectoryEventMask
+	{
+		DW_FILTER_ENABLE_ALL = 31,
+			/// Enables all event types.
+
+		DW_FILTER_DISABLE_ALL = 0
+			/// Disables all event types.
+	};
+	
+	enum
+	{
+		DW_DEFAULT_SCAN_INTERVAL = 5 /// Default scan interval for platforms that don't provide a native notification mechanism.
+	};
+	
+	struct DirectoryEvent
+	{
+		DirectoryEvent(const File& f, DirectoryEventType ev):
+			item(f),
+			event(ev)
+		{
+		}
+
+		const File& item;          /// The directory or file that has been changed.
+		DirectoryEventType event;  /// The kind of event.
+	};
+	
+	BasicEvent<const DirectoryEvent> itemAdded;
+		/// Fired when a file or directory has been created or added to the directory.
+		
+	BasicEvent<const DirectoryEvent> itemRemoved;
+		/// Fired when a file or directory has been removed from the directory.
+		
+	BasicEvent<const DirectoryEvent> itemModified;
+		/// Fired when a file or directory has been modified.
+
+	BasicEvent<const DirectoryEvent> itemMovedFrom;
+		/// Fired when a file or directory has been renamed. This event delivers the old name.
+
+	BasicEvent<const DirectoryEvent> itemMovedTo;
+		/// Fired when a file or directory has been moved. This event delivers the new name.
+		
+	BasicEvent<const Exception> scanError;
+		/// Fired when an error occurs while scanning for changes.
+	
+	DirectoryWatcher(const std::string& path, int eventMask = DW_FILTER_ENABLE_ALL, int scanInterval = DW_DEFAULT_SCAN_INTERVAL);
+		/// Creates a DirectoryWatcher for the directory given in path.
+		/// To enable only specific events, an eventMask can be specified by
+		/// OR-ing the desired event IDs (e.g., DW_ITEM_ADDED | DW_ITEM_MODIFIED).
+		/// On platforms where no native filesystem notifications are available,
+		/// scanInterval specifies the interval in seconds between scans
+		/// of the directory.
+		
+	DirectoryWatcher(const File& directory, int eventMask = DW_FILTER_ENABLE_ALL, int scanInterval = DW_DEFAULT_SCAN_INTERVAL);
+		/// Creates a DirectoryWatcher for the specified directory
+		/// To enable only specific events, an eventMask can be specified by
+		/// OR-ing the desired event IDs (e.g., DW_ITEM_ADDED | DW_ITEM_MODIFIED).
+		/// On platforms where no native filesystem notifications are available,
+		/// scanInterval specifies the interval in seconds between scans
+		/// of the directory.
+
+	~DirectoryWatcher();
+		/// Destroys the DirectoryWatcher.
+		
+	void suspendEvents();
+		/// Suspends sending of events. Can be called multiple times, but every
+		/// call to suspendEvent() must be matched by a call to resumeEvents().
+		
+	void resumeEvents();
+		/// Resumes events, after they have been suspended with a call to suspendEvents().
+		
+	bool eventsSuspended() const;
+		/// Returns true iff events are suspended.
+		
+	int eventMask() const;
+		/// Returns the value of the eventMask passed to the constructor.
+		
+	int scanInterval() const;
+		/// Returns the scan interval in seconds.
+		
+	const File& directory() const;
+		/// Returns the directory being watched.
+		
+	bool supportsMoveEvents() const;
+		/// Returns true iff the platform supports DW_ITEM_MOVED_FROM/itemMovedFrom and
+		/// DW_ITEM_MOVED_TO/itemMovedTo events.
+	
+protected:
+	void init();
+	void stop();
+	void run();
+
+private:
+	DirectoryWatcher();
+	DirectoryWatcher(const DirectoryWatcher&);
+	DirectoryWatcher& operator = (const DirectoryWatcher&);
+
+	Thread _thread;
+	File _directory;
+	int _eventMask;
+	AtomicCounter _eventsSuspended;
+	int _scanInterval;
+	DirectoryWatcherStrategy* _pStrategy;
+};
+
+
+//
+// inlines
+//
+
+
+inline bool DirectoryWatcher::eventsSuspended() const
+{
+	return _eventsSuspended.value() > 0;
+}
+
+
+inline int DirectoryWatcher::eventMask() const
+{
+	return _eventMask;
+}
+
+
+inline int DirectoryWatcher::scanInterval() const
+{
+	return _scanInterval;
+}
+
+
+inline const File& DirectoryWatcher::directory() const
+{
+	return _directory;
+}
+
+
+} // namespace Poco
+
+
+#endif // POCO_NO_INOTIFY
+
+
+#endif // Foundation_DirectoryWatcher_INCLUDED
+
diff --git a/base/poco/Foundation/include/Poco/Dynamic/Pair.h b/base/poco/Foundation/include/Poco/Dynamic/Pair.h
new file mode 100644
index 00000000000..c64eececeb0
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Dynamic/Pair.h
@@ -0,0 +1,412 @@
+//
+// Pair.h
+//
+// Library: Foundation
+// Package: Dynamic
+// Module:  Pair
+//
+// Definition of the Pair class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Pair_INCLUDED
+#define Foundation_Pair_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Dynamic/Var.h"
+#include "Poco/Dynamic/VarHolder.h"
+#include <utility>
+
+
+namespace Poco {
+namespace Dynamic {
+
+
+template <typename K>
+class Pair
+	/// Pair allows to define a pair of values.
+{
+public:
+	typedef typename std::pair<K, Var> Data;
+
+	Pair(): _data()
+		/// Creates an empty Pair
+	{
+	}
+
+	Pair(const Pair& other): _data(other._data)
+		/// Creates the Pair from another pair.
+	{
+	}
+
+	Pair(const Data& val): _data(val)
+		/// Creates the Pair from the given value.
+	{
+	}
+
+	template <typename T>
+	Pair(const std::pair<K, T>& val): _data(std::make_pair(val.first, val.second))
+		/// Creates Pair form standard pair.
+	{
+	}
+
+	template <typename T>
+	Pair(const K& first, const T& second): _data(std::make_pair(first, second))
+		/// Creates pair from two values.
+	{
+	}
+
+	virtual ~Pair()
+		/// Destroys the Pair.
+	{
+	}
+
+	Pair& swap(Pair& other)
+		/// Swaps the content of the two Pairs.
+	{
+		std::swap(_data, other._data);
+		return *this;
+	}
+
+	Pair& operator = (const Pair& other)
+		/// Copy constructs Pair from another pair.
+	{
+		Pair(other).swap(*this);
+		return *this;
+	}
+
+	inline const K& first() const
+		/// Returns the first member of the pair.
+	{
+		return _data.first;
+	}
+
+	inline const Var& second() const
+		/// Returns the second member of the pair.
+	{
+		return _data.second;
+	}
+
+	std::string toString()
+	{
+		std::string str;
+		Var(*this).convert<std::string>(str);
+		return str;
+	}
+
+private:
+	Data _data;
+};
+
+
+template <>
+class VarHolderImpl<Pair<std::string> >: public VarHolder
+{
+public:
+	VarHolderImpl(const Pair<std::string>& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+	
+	const std::type_info& type() const
+	{
+		return typeid(Pair<std::string>);
+	}
+
+	void convert(Int8& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to Int8");
+	}
+
+	void convert(Int16& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to Int16");
+	}
+	
+	void convert(Int32& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to Int32");
+	}
+
+	void convert(Int64& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to Int64");
+	}
+
+	void convert(UInt8& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to UInt8");
+	}
+
+	void convert(UInt16& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to UInt16");
+	}
+	
+	void convert(UInt32& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to UInt32");
+	}
+
+	void convert(UInt64& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to UInt64");
+	}
+
+	void convert(bool& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to bool");
+	}
+
+	void convert(float& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to float");
+	}
+
+	void convert(double& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to double");
+	}
+
+	void convert(char& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to char");
+	}
+
+	void convert(std::string& val) const
+	{
+		// Serialize in JSON format: equals an object
+		// JSON format definition: { string ':' value } string:value pair n-times, sep. by ','
+		val.append("{ ");
+		Var key(_val.first());
+		Impl::appendJSONKey(val, key);
+		val.append(" : ");
+		Impl::appendJSONValue(val, _val.second());
+		val.append(" }");	
+	}
+
+	void convert(Poco::DateTime&) const
+	{
+		throw BadCastException("Pair -> Poco::DateTime");
+	}
+
+	void convert(Poco::LocalDateTime&) const
+	{
+		throw BadCastException("Pair -> Poco::LocalDateTime");
+	}
+
+	void convert(Poco::Timestamp&) const
+	{
+		throw BadCastException("Pair -> Poco::Timestamp");
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+	
+	const Pair<std::string>& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return false;
+	}
+
+	bool isSigned() const
+	{
+		return false;
+	}
+
+	bool isNumeric() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	Pair<std::string> _val;
+};
+
+
+template <>
+class VarHolderImpl<Pair<int> >: public VarHolder
+{
+public:
+	VarHolderImpl(const Pair<int>& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+	
+	const std::type_info& type() const
+	{
+		return typeid(Pair<int>);
+	}
+
+	void convert(Int8& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to Int8");
+	}
+
+	void convert(Int16& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to Int16");
+	}
+	
+	void convert(Int32& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to Int32");
+	}
+
+	void convert(Int64& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to Int64");
+	}
+
+	void convert(UInt8& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to UInt8");
+	}
+
+	void convert(UInt16& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to UInt16");
+	}
+	
+	void convert(UInt32& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to UInt32");
+	}
+
+	void convert(UInt64& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to UInt64");
+	}
+
+	void convert(bool& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to bool");
+	}
+
+	void convert(float& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to float");
+	}
+
+	void convert(double& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to double");
+	}
+
+	void convert(char& val) const
+	{
+		throw BadCastException("Cannot cast Pair type to char");
+	}
+
+	void convert(std::string& val) const
+	{
+		// Serialize in JSON format: equals an object
+		// JSON format definition: { string ':' value } string:value pair n-times, sep. by ','
+		val.append("{ ");
+		Var key(_val.first());
+		Impl::appendJSONKey(val, key);
+		val.append(" : ");
+		Impl::appendJSONValue(val, _val.second());
+		val.append(" }");	
+	}
+
+	void convert(Poco::DateTime&) const
+	{
+		throw BadCastException("Pair -> Poco::DateTime");
+	}
+
+	void convert(Poco::LocalDateTime&) const
+	{
+		throw BadCastException("Pair -> Poco::LocalDateTime");
+	}
+
+	void convert(Poco::Timestamp&) const
+	{
+		throw BadCastException("Pair -> Poco::Timestamp");
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+	
+	const Pair<int>& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return false;
+	}
+
+	bool isSigned() const
+	{
+		return false;
+	}
+
+	bool isNumeric() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	Pair<int> _val;
+};
+
+
+} // namespace Dynamic
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Pair_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Dynamic/Struct.h b/base/poco/Foundation/include/Poco/Dynamic/Struct.h
new file mode 100644
index 00000000000..d510115244e
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Dynamic/Struct.h
@@ -0,0 +1,567 @@
+//
+// Struct.h
+//
+// Library: Foundation
+// Package: Dynamic
+// Module:  Struct
+//
+// Definition of the Struct class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Struct_INCLUDED
+#define Foundation_Struct_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Dynamic/Var.h"
+#include "Poco/Dynamic/VarHolder.h"
+#include "Poco/SharedPtr.h"
+#include <map>
+#include <set>
+
+
+namespace Poco {
+namespace Dynamic {
+
+
+template <typename K>
+class Struct
+	/// Struct allows to define a named collection of Var objects.
+{
+public:
+	typedef typename std::map<K, Var> Data;
+	typedef typename std::set<K> NameSet;
+	typedef typename Data::iterator Iterator;
+	typedef typename Data::const_iterator ConstIterator;
+	typedef typename Struct<K>::Data::value_type ValueType;
+	typedef typename Struct<K>::Data::size_type SizeType;
+	typedef typename std::pair<typename Struct<K>::Iterator, bool> InsRetVal;
+	typedef typename Poco::SharedPtr<Struct<K> > Ptr;
+
+	Struct(): _data()
+		/// Creates an empty Struct
+	{
+	}
+
+	Struct(const Data& val): _data(val)
+		/// Creates the Struct from the given value.
+	{
+	}
+
+	template <typename T>
+	Struct(const std::map<K, T>& val)
+	{
+		typedef typename std::map<K, T>::const_iterator MapConstIterator;
+
+		MapConstIterator it = val.begin();
+		MapConstIterator end = val.end();
+		for (; it != end; ++it) _data.insert(ValueType(it->first, Var(it->second)));
+	}
+
+	virtual ~Struct()
+		/// Destroys the Struct.
+	{
+	}
+
+	inline Var& operator [] (const K& name)
+		/// Returns the Var with the given name, creates an entry if not found.
+	{
+		return _data[name];
+	}
+
+	const Var& operator [] (const K& name) const
+		/// Returns the Var with the given name, throws a
+		/// NotFoundException if the data member is not found.
+	{
+		ConstIterator it = find(name);
+		if (it == end()) throw NotFoundException(name);
+		return it->second;
+	}
+
+	inline bool contains(const K& name) const
+		/// Returns true if the Struct contains a member with the given name
+	{
+		return find(name) != end();
+	}
+
+	inline Iterator find(const K& name)
+		/// Returns an iterator, pointing to the <name,Var> pair containing
+		/// the element, or it returns end() if the member was not found
+	{
+		return _data.find(name);
+	}
+
+	inline ConstIterator find(const K& name) const
+		/// Returns a const iterator, pointing to the <name,Var> pair containing
+		/// the element, or it returns end() if the member was not found
+	{
+		return _data.find(name);
+	}
+
+	inline Iterator end()
+		/// Returns the end iterator for the Struct
+	{
+		return _data.end();
+	}
+
+	inline ConstIterator end() const
+		/// Returns the end const iterator for the Struct
+	{
+		return _data.end();
+	}
+
+	inline Iterator begin()
+		/// Returns the begin iterator for the Struct
+	{
+		return _data.begin();
+	}
+
+	inline ConstIterator begin() const
+		/// Returns the begin const iterator for the Struct
+	{
+		return _data.begin();
+	}
+
+	template <typename T>
+	inline InsRetVal insert(const K& key, const T& value)
+		/// Inserts a <name, Var> pair into the Struct,
+		/// returns a pair containing the iterator and a boolean which
+		/// indicates success or not (is true, when insert succeeded, false,
+		/// when already another element was present, in this case Iterator
+		/// points to that other element)
+	{
+		// fix: SunPro C++ is silly ...
+		ValueType valueType(key, value);
+		return insert(valueType);
+	}
+
+	inline InsRetVal insert(const ValueType& aPair)
+		/// Inserts a <name, Var> pair into the Struct,
+		/// returns a pair containing the iterator and a boolean which
+		/// indicates success or not (is true, when insert succeeded, false,
+		/// when already another element was present, in this case Iterator
+		/// points to that other element)
+	{
+		return _data.insert(aPair);
+	}
+
+	inline SizeType erase(const K& key)
+		/// Erases the element if found, returns number of elements deleted
+	{
+		return _data.erase(key);
+	}
+
+	inline void erase(Iterator& it)
+		/// Erases the element at the given position
+	{
+		_data.erase(it);
+	}
+
+	inline bool empty() const
+		/// Returns true if the Struct doesn't contain any members
+	{
+		return _data.empty();
+	}
+
+	inline void clear()
+		/// Clears the Struct contents
+	{
+		_data.clear();
+	}
+
+	SizeType size() const
+		/// Returns the number of members the Struct contains
+	{
+		return _data.size();
+	}
+
+	inline NameSet members() const
+		/// Returns a sorted collection containing all member names
+	{
+		NameSet keys;
+		ConstIterator it = begin();
+		ConstIterator itEnd = end();
+		for (; it != itEnd; ++it) keys.insert(it->first);
+		return keys;
+	}
+
+	std::string toString()
+	{
+		std::string str;
+		Var(*this).convert<std::string>(str);
+		return str;
+	}
+
+private:
+	Data _data;
+};
+
+
+template <>
+class VarHolderImpl<Struct<std::string> >: public VarHolder
+{
+public:
+	VarHolderImpl(const Struct<std::string>& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+	
+	const std::type_info& type() const
+	{
+		return typeid(Struct<std::string>);
+	}
+
+	void convert(Int8&) const
+	{
+		throw BadCastException("Cannot cast Struct type to Int8");
+	}
+
+	void convert(Int16&) const
+	{
+		throw BadCastException("Cannot cast Struct type to Int16");
+	}
+	
+	void convert(Int32&) const
+	{
+		throw BadCastException("Cannot cast Struct type to Int32");
+	}
+
+	void convert(Int64&) const
+	{
+		throw BadCastException("Cannot cast Struct type to Int64");
+	}
+
+	void convert(UInt8&) const
+	{
+		throw BadCastException("Cannot cast Struct type to UInt8");
+	}
+
+	void convert(UInt16&) const
+	{
+		throw BadCastException("Cannot cast Struct type to UInt16");
+	}
+	
+	void convert(UInt32&) const
+	{
+		throw BadCastException("Cannot cast Struct type to UInt32");
+	}
+
+	void convert(UInt64&) const
+	{
+		throw BadCastException("Cannot cast Struct type to UInt64");
+	}
+
+	void convert(bool&) const
+	{
+		throw BadCastException("Cannot cast Struct type to bool");
+	}
+
+	void convert(float&) const
+	{
+		throw BadCastException("Cannot cast Struct type to float");
+	}
+
+	void convert(double&) const
+	{
+		throw BadCastException("Cannot cast Struct type to double");
+	}
+
+	void convert(char&) const
+	{
+		throw BadCastException("Cannot cast Struct type to char");
+	}
+
+	void convert(std::string& val) const
+	{
+		val.append("{ ");
+		Struct<std::string>::ConstIterator it = _val.begin();
+		Struct<std::string>::ConstIterator itEnd = _val.end();
+		if (!_val.empty())
+		{
+			Var key(it->first);
+			Impl::appendJSONKey(val, key);
+			val.append(" : ");
+			Impl::appendJSONValue(val, it->second);
+			++it;
+		}
+		for (; it != itEnd; ++it)
+		{
+			val.append(", ");
+			Var key(it->first);
+			Impl::appendJSONKey(val, key);
+			val.append(" : ");
+			Impl::appendJSONValue(val, it->second);
+		}
+		val.append(" }");
+	}
+
+	void convert(Poco::DateTime&) const
+	{
+		throw BadCastException("Struct -> Poco::DateTime");
+	}
+
+	void convert(Poco::LocalDateTime&) const
+	{
+		throw BadCastException("Struct -> Poco::LocalDateTime");
+	}
+
+	void convert(Poco::Timestamp&) const
+	{
+		throw BadCastException("Struct -> Poco::Timestamp");
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+	
+	const Struct<std::string>& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return true;
+	}
+
+	bool isInteger() const
+	{
+		return false;
+	}
+
+	bool isSigned() const
+	{
+		return false;
+	}
+
+	bool isNumeric() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+	
+	std::size_t size() const
+	{
+		return _val.size();
+	}
+
+	Var& operator [] (const std::string& name)
+	{
+		return _val[name];
+	}
+
+	const Var& operator [] (const std::string& name) const
+	{
+		return _val[name];
+	}
+
+private:
+	Struct<std::string> _val;
+};
+
+
+template <>
+class VarHolderImpl<Struct<int> >: public VarHolder
+{
+public:
+	VarHolderImpl(const Struct<int>& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+	
+	const std::type_info& type() const
+	{
+		return typeid(Struct<int>);
+	}
+
+	void convert(Int8&) const
+	{
+		throw BadCastException("Cannot cast Struct type to Int8");
+	}
+
+	void convert(Int16&) const
+	{
+		throw BadCastException("Cannot cast Struct type to Int16");
+	}
+	
+	void convert(Int32&) const
+	{
+		throw BadCastException("Cannot cast Struct type to Int32");
+	}
+
+	void convert(Int64&) const
+	{
+		throw BadCastException("Cannot cast Struct type to Int64");
+	}
+
+	void convert(UInt8&) const
+	{
+		throw BadCastException("Cannot cast Struct type to UInt8");
+	}
+
+	void convert(UInt16&) const
+	{
+		throw BadCastException("Cannot cast Struct type to UInt16");
+	}
+	
+	void convert(UInt32&) const
+	{
+		throw BadCastException("Cannot cast Struct type to UInt32");
+	}
+
+	void convert(UInt64&) const
+	{
+		throw BadCastException("Cannot cast Struct type to UInt64");
+	}
+
+	void convert(bool&) const
+	{
+		throw BadCastException("Cannot cast Struct type to bool");
+	}
+
+	void convert(float&) const
+	{
+		throw BadCastException("Cannot cast Struct type to float");
+	}
+
+	void convert(double&) const
+	{
+		throw BadCastException("Cannot cast Struct type to double");
+	}
+
+	void convert(char&) const
+	{
+		throw BadCastException("Cannot cast Struct type to char");
+	}
+
+	void convert(std::string& val) const
+	{
+		val.append("{ ");
+		Struct<int>::ConstIterator it = _val.begin();
+		Struct<int>::ConstIterator itEnd = _val.end();
+		if (!_val.empty())
+		{
+			Var key(it->first);
+			Impl::appendJSONKey(val, key);
+			val.append(" : ");
+			Impl::appendJSONValue(val, it->second);
+			++it;
+		}
+		for (; it != itEnd; ++it)
+		{
+			val.append(", ");
+			Var key(it->first);
+			Impl::appendJSONKey(val, key);
+			val.append(" : ");
+			Impl::appendJSONValue(val, it->second);
+		}
+		val.append(" }");	
+	}
+
+	void convert(Poco::DateTime&) const
+	{
+		throw BadCastException("Struct -> Poco::DateTime");
+	}
+
+	void convert(Poco::LocalDateTime&) const
+	{
+		throw BadCastException("Struct -> Poco::LocalDateTime");
+	}
+
+	void convert(Poco::Timestamp&) const
+	{
+		throw BadCastException("Struct -> Poco::Timestamp");
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+	
+	const Struct<int>& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return true;
+	}
+
+	bool isInteger() const
+	{
+		return false;
+	}
+
+	bool isSigned() const
+	{
+		return false;
+	}
+
+	bool isNumeric() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+	std::size_t size() const
+	{
+		return _val.size();
+	}
+
+	Var& operator [] (int name)
+	{
+		return _val[name];
+	}
+
+	const Var& operator [] (int name) const
+	{
+		return _val[name];
+	}
+
+private:
+	Struct<int> _val;
+};
+
+
+} // namespace Dynamic
+
+
+typedef Dynamic::Struct<std::string> DynamicStruct;
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Struct_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Dynamic/Var.h b/base/poco/Foundation/include/Poco/Dynamic/Var.h
new file mode 100644
index 00000000000..bd06afe54bb
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Dynamic/Var.h
@@ -0,0 +1,2228 @@
+//
+// Var.h
+//
+// Library: Foundation
+// Package: Dynamic
+// Module:  Var
+//
+// Definition of the Var class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Var_INCLUDED
+#define Foundation_Var_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Format.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Dynamic/VarHolder.h"
+#include "Poco/Dynamic/VarIterator.h"
+#include <typeinfo>
+
+
+namespace Poco {
+namespace Dynamic {
+
+
+template <typename T>
+class Struct;
+
+
+class Foundation_API Var
+	/// Var allows to store data of different types and to convert between these types transparently.
+	/// Var puts forth the best effort to provide intuitive and reasonable conversion semantics and prevent 
+	/// unexpected data loss, particularly when performing narrowing or signedness conversions of numeric data types.
+	///
+	/// An attempt to convert or extract from a non-initialized ("empty") Var variable shall result
+	/// in an exception being thrown.
+	///
+	/// Loss of signedness is not allowed for numeric values. This means that if an attempt is made to convert 
+	/// the internal value which is a negative signed integer to an unsigned integer type storage, a RangeException is thrown. 
+	/// Overflow is not allowed, so if the internal value is a larger number than the target numeric type size can accommodate, 
+	/// a RangeException is thrown.
+	///
+	/// Precision loss, such as in conversion from floating-point types to integers or from double to float on platforms
+	/// where they differ in size (provided internal actual value fits in float min/max range), is allowed.
+	/// 
+	/// String truncation is allowed -- it is possible to convert between string and character when string length is 
+	/// greater than 1. An empty string gets converted to the char '\0', a non-empty string is truncated to the first character. 
+	///
+	/// Boolean conversion is performed as follows:
+	///
+	/// A string value "false" (not case sensitive), "0" or "" (empty string) can be converted to a boolean value false,
+	/// any other string not being false by the above criteria evaluates to true (e.g: "hi" -> true).
+	/// Integer 0 values are false, everything else is true.
+	/// Floating point values equal to the minimal FP representation on a given platform are false, everything else is true.
+	///
+	/// Arithmetic operations with POD types as well as between Var's are supported, subject to following
+	/// limitations:
+	/// 
+	/// 	- for std::string and const char* values, only '+' and '+=' operations are supported
+	/// 
+	/// 	- for integral and floating point numeric values, following operations are supported:
+	/// 	  '+', '+=', '-', '-=', '*', '*=' , '/' and '/=' 
+	///
+	/// 	- for integral values, following operations are supported:
+	///		  prefix and postfix increment (++) and decrement (--)
+	/// 
+	/// 	- for all other types, InvalidArgumentException is thrown upon attempt of an arithmetic operation
+	/// 
+	/// A Var can be created from and converted to a value of any type for which a specialization of 
+	/// VarHolderImpl is available. For supported types, see VarHolder documentation.
+{
+public:
+	typedef SharedPtr<Var>             Ptr;
+	typedef Poco::Dynamic::VarIterator Iterator;
+	typedef const VarIterator          ConstIterator;
+
+	Var();
+		/// Creates an empty Var.
+
+	template <typename T> 
+	Var(const T& val)
+		/// Creates the Var from the given value.
+#ifdef POCO_NO_SOO
+		: _pHolder(new VarHolderImpl<T>(val))
+	{
+	}
+#else
+	{
+		construct(val);
+	}
+#endif
+
+	Var(const char* pVal);
+		// Convenience constructor for const char* which gets mapped to a std::string internally, i.e. pVal is deep-copied.
+
+	Var(const Var& other);
+		/// Copy constructor.
+
+	~Var();
+		/// Destroys the Var.
+
+	void swap(Var& other);
+		/// Swaps the content of the this Var with the other Var.
+
+	ConstIterator begin() const;
+		/// Returns the const Var iterator.
+
+	ConstIterator end() const;
+		/// Returns the const Var iterator.
+
+	Iterator begin();
+		/// Returns the Var iterator.
+
+	Iterator end();
+		/// Returns the Var iterator.
+
+	template <typename T> 
+	void convert(T& val) const
+		/// Invoke this method to perform a safe conversion.
+		///
+		/// Example usage:
+		///     Var any("42");
+		///     int i;
+		///     any.convert(i);
+		///
+		/// Throws a RangeException if the value does not fit
+		/// into the result variable.
+		/// Throws a NotImplementedException if conversion is
+		/// not available for the given type.
+		/// Throws InvalidAccessException if Var is empty.
+	{
+		VarHolder* pHolder = content();
+
+		if (!pHolder)
+			throw InvalidAccessException("Can not convert empty value.");
+
+		pHolder->convert(val);
+	}
+	
+	template <typename T> 
+	T convert() const
+		/// Invoke this method to perform a safe conversion.
+		///
+		/// Example usage:
+		///     Var any("42");
+		///     int i = any.convert<int>();
+		///
+		/// Throws a RangeException if the value does not fit
+		/// into the result variable.
+		/// Throws a NotImplementedException if conversion is
+		/// not available for the given type.
+		/// Throws InvalidAccessException if Var is empty.
+	{
+		VarHolder* pHolder = content();
+
+		if (!pHolder)
+			throw InvalidAccessException("Can not convert empty value.");
+
+		if (typeid(T) == pHolder->type()) return extract<T>();
+
+		T result;
+		pHolder->convert(result);
+		return result;
+	}
+	
+	template <typename T>
+	operator T () const
+		/// Safe conversion operator for implicit type
+		/// conversions. If the requested type T is same as the 
+		/// type being held, the operation performed is direct 
+		/// extraction, otherwise it is the conversion of the value
+		/// from type currently held to the one requested.
+		///
+		/// Throws a RangeException if the value does not fit
+		/// into the result variable.
+		/// Throws a NotImplementedException if conversion is
+		/// not available for the given type.
+		/// Throws InvalidAccessException if Var is empty.
+	{
+		VarHolder* pHolder = content();
+
+		if (!pHolder)
+				throw InvalidAccessException("Can not convert empty value.");
+
+		if (typeid(T) == pHolder->type())
+			return extract<T>();
+		else
+		{
+			T result;
+			pHolder->convert(result);
+			return result;
+		}
+	}
+
+	template <typename T>
+	const T& extract() const
+		/// Returns a const reference to the actual value.
+		///
+		/// Must be instantiated with the exact type of
+		/// the stored value, otherwise a BadCastException
+		/// is thrown.
+		/// Throws InvalidAccessException if Var is empty.
+	{
+		VarHolder* pHolder = content();
+
+		if (pHolder && pHolder->type() == typeid(T))
+		{
+			VarHolderImpl<T>* pHolderImpl = static_cast<VarHolderImpl<T>*>(pHolder);
+			return pHolderImpl->value();
+		}
+		else if (!pHolder)
+			throw InvalidAccessException("Can not extract empty value.");
+		else
+			throw BadCastException(format("Can not convert %s to %s.",
+				std::string(pHolder->type().name()),
+				std::string(typeid(T).name())));
+	}
+
+	template <typename T> 
+	Var& operator = (const T& other)
+		/// Assignment operator for assigning POD to Var
+	{
+#ifdef POCO_NO_SOO
+		Var tmp(other);
+		swap(tmp);
+#else
+		construct(other);
+#endif
+		return *this;
+	}
+
+	bool operator ! () const;
+		/// Logical NOT operator.
+
+	Var& operator = (const Var& other);
+		/// Assignment operator specialization for Var
+
+	template <typename T>
+	const Var operator + (const T& other) const
+		/// Addition operator for adding POD to Var
+	{
+		return convert<T>() + other;
+	}
+
+	const Var operator + (const Var& other) const;
+		/// Addition operator specialization for Var
+
+	const Var operator + (const char* other) const;
+		/// Addition operator specialization for adding const char* to Var
+
+	Var& operator ++ ();
+		/// Pre-increment operator
+
+	const Var operator ++ (int);
+		/// Post-increment operator
+
+	Var& operator -- ();
+		/// Pre-decrement operator
+
+	const Var operator -- (int);
+		/// Post-decrement operator
+
+	template <typename T> 
+	Var& operator += (const T& other)
+		/// Addition assignment operator for addition/assignment of POD to Var.
+	{
+		return *this = convert<T>() + other;
+	}
+
+	Var& operator += (const Var& other);
+		/// Addition assignment operator overload for Var
+
+	Var& operator += (const char* other);
+		/// Addition assignment operator overload for const char*
+
+	template <typename T> 
+	const Var operator - (const T& other) const
+		/// Subtraction operator for subtracting POD from Var
+	{
+		return convert<T>() - other;
+	}
+
+	const Var operator - (const Var& other) const;
+		/// Subtraction operator overload for Var
+
+	template <typename T> 
+	Var& operator -= (const T& other)
+		/// Subtraction assignment operator
+	{
+		return *this = convert<T>() - other;
+	}
+
+	Var& operator -= (const Var& other);
+		/// Subtraction assignment operator overload for Var
+
+	template <typename T> 
+	const Var operator * (const T& other) const
+		/// Multiplication operator for multiplying Var with POD
+	{
+		return convert<T>() * other;
+	}
+
+	const Var operator * (const Var& other) const;
+		/// Multiplication operator overload for Var
+
+	template <typename T> 
+	Var& operator *= (const T& other)
+		/// Multiplication assignment operator
+	{
+		return *this = convert<T>() * other;
+	}
+
+	Var& operator *= (const Var& other);
+		/// Multiplication assignment operator overload for Var
+
+	template <typename T> 
+	const Var operator / (const T& other) const
+		/// Division operator for dividing Var with POD
+	{
+		return convert<T>() / other;
+	}
+
+	const Var operator / (const Var& other) const;
+		/// Division operator overload for Var
+
+	template <typename T> 
+	Var& operator /= (const T& other)
+		/// Division assignment operator
+	{
+		return *this = convert<T>() / other;
+	}
+
+	Var& operator /= (const Var& other);
+		/// Division assignment operator specialization for Var
+
+	template <typename T> 
+	bool operator == (const T& other) const
+		/// Equality operator
+	{
+		if (isEmpty()) return false;
+		return convert<T>() == other;
+	}
+
+	bool operator == (const char* other) const;
+		/// Equality operator overload for const char*
+
+	bool operator == (const Var& other) const;
+		/// Equality operator overload for Var
+
+	template <typename T> 
+	bool operator != (const T& other) const
+		/// Inequality operator
+	{
+		if (isEmpty()) return true;
+		return convert<T>() != other;
+	}
+
+	bool operator != (const Var& other) const;
+		/// Inequality operator overload for Var
+
+	bool operator != (const char* other) const;
+		/// Inequality operator overload for const char*
+
+	template <typename T> 
+	bool operator < (const T& other) const
+		/// Less than operator
+	{
+		if (isEmpty()) return false;
+		return convert<T>() < other;
+	}
+
+	bool operator < (const Var& other) const;
+		/// Less than operator overload for Var
+
+	template <typename T> 
+	bool operator <= (const T& other) const
+		/// Less than or equal operator
+	{
+		if (isEmpty()) return false;
+		return convert<T>() <= other;
+	}
+
+	bool operator <= (const Var& other) const;
+		/// Less than or equal operator overload for Var
+
+	template <typename T> 
+	bool operator > (const T& other) const
+		/// Greater than operator
+	{
+		if (isEmpty()) return false;
+		return convert<T>() > other;
+	}
+
+	bool operator > (const Var& other) const;
+		/// Greater than operator overload for Var
+
+	template <typename T> 
+	bool operator >= (const T& other) const
+		/// Greater than or equal operator
+	{
+		if (isEmpty()) return false;
+		return convert<T>() >= other;
+	}
+
+	bool operator >= (const Var& other) const;
+		/// Greater than or equal operator overload for Var
+
+	template <typename T>
+	bool operator || (const T& other) const
+		/// Logical OR operator
+	{
+		if (isEmpty()) return false;
+		return convert<bool>() || other;
+	}
+
+	bool operator || (const Var& other) const;
+		/// Logical OR operator operator overload for Var
+
+	template <typename T>
+	bool operator && (const T& other) const
+		/// Logical AND operator.
+	{
+		if (isEmpty()) return false;
+		return convert<bool>() && other;
+	}
+
+	bool operator && (const Var& other) const;
+		/// Logical AND operator operator overload for Var.
+
+	bool isArray() const;
+		/// Returns true if Var is an array.
+
+	bool isVector() const;
+		/// Returns true if Var represents a vector.
+
+	bool isList() const;
+		/// Returns true if Var represents a list.
+
+	bool isDeque() const;
+		/// Returns true if Var represents a deque.
+
+	bool isStruct() const;
+		/// Returns true if Var represents a struct.
+
+	char& at(std::size_t n);
+		/// Returns character at position n. This function only works with
+		/// Var containing a std::string.
+
+
+	template <typename T>
+	Var& operator [] (const T& n)
+	{
+		return getAt(n);
+	}
+
+	template <typename T>
+	const Var& operator [] (const T& n) const
+	{
+		return const_cast<Var*>(this)->getAt(n);
+	}
+
+	Var& operator [] (const std::string& name);
+		/// Index operator by name, only use on Vars where isStruct
+		/// returns true! In all other cases InvalidAccessException is thrown.
+
+	const Var& operator [] (const std::string& name) const;
+		/// Index operator by name, only use on Vars where isStruct
+		/// returns true! In all other cases InvalidAccessException is thrown.
+
+	const std::type_info& type() const;
+		/// Returns the type information of the stored content.
+
+	//@ deprecated
+	void empty();
+		/// Empties Var.
+		/// This function is deprecated and will be removed.
+		/// Please use clear().
+
+	void clear();
+		/// Empties Var.
+
+	bool isEmpty() const;
+		/// Returns true if empty.
+
+	bool isInteger() const;
+		/// Returns true if stored value is integer.
+
+	bool isSigned() const;
+		/// Returns true if stored value is signed.
+
+	bool isNumeric() const;
+		/// Returns true if stored value is numeric.
+		/// Returns false for numeric strings (e.g. "123" is string, not number)
+
+	bool isBoolean() const;
+		/// Returns true if stored value is boolean.
+		/// Returns false for boolean strings (e.g. "true" is string, not number)
+
+	bool isString() const;
+		/// Returns true if stored value is std::string.
+
+	bool isDate() const;
+		/// Returns true if stored value represents a date.
+
+	bool isTime() const;
+		/// Returns true if stored value represents time or date/time.
+
+	bool isDateTime() const;
+		/// Returns true if stored value represents a date/time.
+
+	std::size_t size() const;
+		/// Returns the size of this Var.
+		/// This function returns 0 when Var is empty, 1 for POD or the size (i.e. length)
+		/// for held container.
+
+	std::string toString() const
+		/// Returns the stored value as string.
+	{
+		VarHolder* pHolder = content();
+
+		if (!pHolder)
+				throw InvalidAccessException("Can not convert empty value.");
+
+		if (typeid(std::string) == pHolder->type())
+			return extract<std::string>();
+		else
+		{
+			std::string result;
+			pHolder->convert(result);
+			return result;
+		}
+	}
+
+	static Var parse(const std::string& val);
+		/// Parses the string which must be in JSON format
+
+	static std::string toString(const Var& var);
+		/// Converts the Var to a string in JSON format. Note that toString(const Var&) will return
+		/// a different result than Var::convert<std::string>() and Var::toString()!
+	
+private:
+	Var& getAt(std::size_t n);
+	Var& getAt(const std::string& n);
+
+	static Var parse(const std::string& val, std::string::size_type& offset);
+		/// Parses the string which must be in JSON format
+
+	static Var parseObject(const std::string& val, std::string::size_type& pos);
+	static Var parseArray(const std::string& val, std::string::size_type& pos);
+	static std::string parseString(const std::string& val, std::string::size_type& pos);
+	static std::string parseJSONString(const std::string& val, std::string::size_type& pos);
+	static void skipWhiteSpace(const std::string& val, std::string::size_type& pos);
+
+	template <typename T>
+	T add(const Var& other) const
+	{
+		return convert<T>() + other.convert<T>();
+	}
+
+	template <typename T>
+	T subtract(const Var& other) const
+	{
+		return convert<T>() - other.convert<T>();
+	}
+	
+	template <typename T>
+	T multiply(const Var& other) const
+	{
+		return convert<T>() * other.convert<T>();
+	}
+
+	template <typename T>
+	T divide(const Var& other) const
+	{
+		return convert<T>() / other.convert<T>();
+	}
+
+	template <typename T, typename E>
+	VarHolderImpl<T>* holderImpl(const std::string errorMessage = "") const
+	{
+		VarHolder* pHolder = content();
+
+		if (pHolder && pHolder->type() == typeid(T))
+			return static_cast<VarHolderImpl<T>*>(pHolder);
+		else if (!pHolder)
+			throw InvalidAccessException("Can not access empty value.");
+		else
+			throw E(errorMessage);
+	}
+
+	Var& structIndexOperator(VarHolderImpl<Struct<int> >* pStr, int n) const;
+
+#ifdef POCO_NO_SOO
+
+	VarHolder* content() const
+	{
+		return _pHolder;
+	}
+
+	void destruct()
+	{
+		if (!isEmpty()) delete content();
+	}
+
+	VarHolder* _pHolder;
+
+#else
+
+	VarHolder* content() const
+	{
+		return _placeholder.content();
+	}
+
+	template<typename ValueType>
+	void construct(const ValueType& value)
+	{
+		if (sizeof(VarHolderImpl<ValueType>) <= Placeholder<ValueType>::Size::value)
+		{
+			new (reinterpret_cast<VarHolder*>(_placeholder.holder)) VarHolderImpl<ValueType>(value);
+			_placeholder.setLocal(true);
+		}
+		else
+		{
+			_placeholder.pHolder = new VarHolderImpl<ValueType>(value);
+			_placeholder.setLocal(false);
+		}
+	}
+
+	void construct(const char* value)
+	{
+		std::string val(value);
+		if (sizeof(VarHolderImpl<std::string>) <= Placeholder<std::string>::Size::value)
+		{
+			new (reinterpret_cast<VarHolder*>(_placeholder.holder)) VarHolderImpl<std::string>(val);
+			_placeholder.setLocal(true);
+		}
+		else
+		{
+			_placeholder.pHolder = new VarHolderImpl<std::string>(val);
+			_placeholder.setLocal(false);
+		}
+	}
+
+	void construct(const Var& other)
+	{
+		if (!other.isEmpty())
+			other.content()->clone(&_placeholder);
+		else
+			_placeholder.erase();
+	}
+
+	void destruct()
+	{
+		if (!isEmpty())
+		{
+			if (_placeholder.isLocal())
+				content()->~VarHolder();
+			else
+				delete content();
+		}
+	}
+
+	Placeholder<VarHolder> _placeholder;
+
+#endif // POCO_NO_SOO
+};
+
+
+///
+/// inlines
+///
+
+
+///
+/// Var members
+///
+
+inline void Var::swap(Var& other)
+{
+#ifdef POCO_NO_SOO
+
+	std::swap(_pHolder, other._pHolder);
+
+#else
+
+	if (this == &other) return;
+
+	if (!_placeholder.isLocal() && !other._placeholder.isLocal())
+	{
+		std::swap(_placeholder.pHolder, other._placeholder.pHolder);
+	}
+	else
+	{
+		Var tmp(*this);
+		try
+		{
+			if (_placeholder.isLocal()) destruct();
+			construct(other);
+			other = tmp;
+		}
+		catch (...)
+		{
+			construct(tmp);
+			throw;
+		}
+	}
+
+#endif
+}
+
+
+inline const std::type_info& Var::type() const
+{
+	VarHolder* pHolder = content();
+	return pHolder ? pHolder->type() : typeid(void);
+}
+
+
+inline Var::ConstIterator Var::begin() const
+{
+	if (isEmpty()) return ConstIterator(const_cast<Var*>(this), true);
+
+	return ConstIterator(const_cast<Var*>(this), false);
+}
+
+inline Var::ConstIterator Var::end() const
+{
+	return ConstIterator(const_cast<Var*>(this), true);
+}
+
+inline Var::Iterator Var::begin()
+{
+	if (isEmpty()) return Iterator(const_cast<Var*>(this), true);
+
+	return Iterator(const_cast<Var*>(this), false);
+}
+
+inline Var::Iterator Var::end()
+{
+	return Iterator(this, true);
+}
+
+
+inline Var& Var::operator [] (const std::string& name)
+{
+	return getAt(name);
+}
+
+
+inline const Var& Var::operator [] (const std::string& name) const
+{
+	return const_cast<Var*>(this)->getAt(name);
+}
+
+
+inline const Var Var::operator + (const char* other) const
+{
+	return convert<std::string>() + other;
+}
+
+
+inline Var& Var::operator += (const char*other)
+{
+	return *this = convert<std::string>() + other;
+}
+
+
+inline bool Var::operator ! () const
+{
+	return !convert<bool>();
+}
+
+
+inline bool Var::isEmpty() const
+{
+	return 0 == content();
+}
+
+
+inline bool Var::isArray() const
+{
+	if (isEmpty() || 
+		isString()) return false;
+
+	VarHolder* pHolder = content();
+	return pHolder ? pHolder->isArray() : false;
+}
+
+
+inline bool Var::isVector() const
+{
+	VarHolder* pHolder = content();
+	return pHolder ? pHolder->isVector() : false;
+}
+
+
+inline bool Var::isList() const
+{
+	VarHolder* pHolder = content();
+	return pHolder ? pHolder->isList() : false;
+}
+
+
+inline bool Var::isDeque() const
+{
+	VarHolder* pHolder = content();
+	return pHolder ? pHolder->isDeque() : false;
+}
+
+
+inline bool Var::isStruct() const
+{
+	VarHolder* pHolder = content();
+	return pHolder ? pHolder->isStruct() : false;
+}
+
+
+inline bool Var::isInteger() const
+{
+	VarHolder* pHolder = content();
+	return pHolder ? pHolder->isInteger() : false;
+}
+
+
+inline bool Var::isSigned() const
+{
+	VarHolder* pHolder = content();
+	return pHolder ? pHolder->isSigned() : false;
+}
+
+
+inline bool Var::isNumeric() const
+{
+	VarHolder* pHolder = content();
+	return pHolder ? pHolder->isNumeric() : false;
+}
+
+
+inline bool Var::isBoolean() const
+{
+	VarHolder* pHolder = content();
+	return pHolder ? pHolder->isBoolean() : false;
+}
+
+
+inline bool Var::isString() const
+{
+	VarHolder* pHolder = content();
+	return pHolder ? pHolder->isString() : false;
+}
+
+
+inline bool Var::isDate() const
+{
+	VarHolder* pHolder = content();
+	return pHolder ? pHolder->isDate() : false;
+}
+
+
+inline bool Var::isTime() const
+{
+	VarHolder* pHolder = content();
+	return pHolder ? pHolder->isTime() : false;
+}
+
+
+inline bool Var::isDateTime() const
+{
+	VarHolder* pHolder = content();
+	return pHolder ? pHolder->isDateTime() : false;
+}
+
+
+inline std::size_t Var::size() const
+{
+	VarHolder* pHolder = content();
+	return pHolder ? pHolder->size() : 0;
+}
+
+
+///
+/// Var non-member functions
+///
+
+inline const Var operator + (const char* other, const Var& da)
+	/// Addition operator for adding Var to const char*
+{
+	std::string tmp = other;
+	return tmp + da.convert<std::string>();
+}
+
+
+inline char operator + (const char& other, const Var& da)
+	/// Addition operator for adding Var to char
+{
+	return other + da.convert<char>();
+}
+
+
+inline char operator - (const char& other, const Var& da)
+	/// Subtraction operator for subtracting Var from char
+{
+	return other - da.convert<char>();
+}
+
+
+inline char operator * (const char& other, const Var& da)
+	/// Multiplication operator for multiplying Var with char
+{
+	return other * da.convert<char>();
+}
+
+
+inline char operator / (const char& other, const Var& da)
+	/// Division operator for dividing Var with char
+{
+	return other / da.convert<char>();
+}
+
+
+inline char operator += (char& other, const Var& da)
+	/// Addition assignment operator for adding Var to char
+{
+	return other += da.convert<char>();
+}
+
+
+inline char operator -= (char& other, const Var& da)
+	/// Subtraction assignment operator for subtracting Var from char
+{
+	return other -= da.convert<char>();
+}
+
+
+inline char operator *= (char& other, const Var& da)
+	/// Multiplication assignment operator for multiplying Var with char
+{
+	return other *= da.convert<char>();
+}
+
+
+inline char operator /= (char& other, const Var& da)
+	/// Division assignment operator for dividing Var with char
+{
+	return other /= da.convert<char>();
+}
+
+
+inline bool operator == (const char& other, const Var& da)
+	/// Equality operator for comparing Var with char
+{
+	if (da.isEmpty()) return false;
+	return other == da.convert<char>();
+}
+
+
+inline bool operator != (const char& other, const Var& da)
+	/// Inequality operator for comparing Var with char
+{
+	if (da.isEmpty()) return true;
+	return other != da.convert<char>();
+}
+
+
+inline bool operator < (const char& other, const Var& da)
+	/// Less than operator for comparing Var with char
+{
+	if (da.isEmpty()) return false;
+	return other < da.convert<char>();
+}
+
+
+inline bool operator <= (const char& other, const Var& da)
+	/// Less than or equal operator for comparing Var with char
+{
+	if (da.isEmpty()) return false;
+	return other <= da.convert<char>();
+}
+
+
+inline bool operator > (const char& other, const Var& da)
+	/// Greater than operator for comparing Var with char
+{
+	if (da.isEmpty())return false;
+	return other > da.convert<char>();
+}
+
+
+inline bool operator >= (const char& other, const Var& da)
+	/// Greater than or equal operator for comparing Var with char
+{
+	if (da.isEmpty())return false;
+	return other >= da.convert<char>();
+}
+
+
+inline Poco::Int8 operator + (const Poco::Int8& other, const Var& da)
+	/// Addition operator for adding Var to Poco::Int8
+{
+	return other + da.convert<Poco::Int8>();
+}
+
+
+inline Poco::Int8 operator - (const Poco::Int8& other, const Var& da)
+	/// Subtraction operator for subtracting Var from Poco::Int8
+{
+	return other - da.convert<Poco::Int8>();
+}
+
+
+inline Poco::Int8 operator * (const Poco::Int8& other, const Var& da)
+	/// Multiplication operator for multiplying Var with Poco::Int8
+{
+	return other * da.convert<Poco::Int8>();
+}
+
+
+inline Poco::Int8 operator / (const Poco::Int8& other, const Var& da)
+	/// Division operator for dividing Var with Poco::Int8
+{
+	return other / da.convert<Poco::Int8>();
+}
+
+
+inline Poco::Int8 operator += (Poco::Int8& other, const Var& da)
+	/// Addition assignment operator for adding Var to Poco::Int8
+{
+	return other += da.convert<Poco::Int8>();
+}
+
+
+inline Poco::Int8 operator -= (Poco::Int8& other, const Var& da)
+	/// Subtraction assignment operator for subtracting Var from Poco::Int8
+{
+	return other -= da.convert<Poco::Int8>();
+}
+
+
+inline Poco::Int8 operator *= (Poco::Int8& other, const Var& da)
+	/// Multiplication assignment operator for multiplying Var with Poco::Int8
+{
+	return other *= da.convert<Poco::Int8>();
+}
+
+
+inline Poco::Int8 operator /= (Poco::Int8& other, const Var& da)
+	/// Division assignment operator for dividing Var with Poco::Int8
+{
+	return other /= da.convert<Poco::Int8>();
+}
+
+
+inline bool operator == (const Poco::Int8& other, const Var& da)
+	/// Equality operator for comparing Var with Poco::Int8
+{
+	if (da.isEmpty()) return false;
+	return other == da.convert<Poco::Int8>();
+}
+
+
+inline bool operator != (const Poco::Int8& other, const Var& da)
+	/// Inequality operator for comparing Var with Poco::Int8
+{
+	if (da.isEmpty()) return true;
+	return other != da.convert<Poco::Int8>();
+}
+
+
+inline bool operator < (const Poco::Int8& other, const Var& da)
+	/// Less than operator for comparing Var with Poco::Int8
+{
+	if (da.isEmpty()) return false;
+	return other < da.convert<Poco::Int8>();
+}
+
+
+inline bool operator <= (const Poco::Int8& other, const Var& da)
+	/// Less than or equal operator for comparing Var with Poco::Int8
+{
+	if (da.isEmpty()) return false;
+	return other <= da.convert<Poco::Int8>();
+}
+
+
+inline bool operator > (const Poco::Int8& other, const Var& da)
+	/// Greater than operator for comparing Var with Poco::Int8
+{
+	if (da.isEmpty()) return false;
+	return other > da.convert<Poco::Int8>();
+}
+
+
+inline bool operator >= (const Poco::Int8& other, const Var& da)
+	/// Greater than or equal operator for comparing Var with Poco::Int8
+{
+	if (da.isEmpty()) return false;
+	return other >= da.convert<Poco::Int8>();
+}
+
+
+inline Poco::UInt8 operator + (const Poco::UInt8& other, const Var& da)
+	/// Addition operator for adding Var to Poco::UInt8
+{
+	return other + da.convert<Poco::UInt8>();
+}
+
+
+inline Poco::UInt8 operator - (const Poco::UInt8& other, const Var& da)
+	/// Subtraction operator for subtracting Var from Poco::UInt8
+{
+	return other - da.convert<Poco::UInt8>();
+}
+
+
+inline Poco::UInt8 operator * (const Poco::UInt8& other, const Var& da)
+	/// Multiplication operator for multiplying Var with Poco::UInt8
+{
+	return other * da.convert<Poco::UInt8>();
+}
+
+
+inline Poco::UInt8 operator / (const Poco::UInt8& other, const Var& da)
+	/// Division operator for dividing Var with Poco::UInt8
+{
+	return other / da.convert<Poco::UInt8>();
+}
+
+
+inline Poco::UInt8 operator += (Poco::UInt8& other, const Var& da)
+	/// Addition assignment operator for adding Var to Poco::UInt8
+{
+	return other += da.convert<Poco::UInt8>();
+}
+
+
+inline Poco::UInt8 operator -= (Poco::UInt8& other, const Var& da)
+	/// Subtraction assignment operator for subtracting Var from Poco::UInt8
+{
+	return other -= da.convert<Poco::UInt8>();
+}
+
+
+inline Poco::UInt8 operator *= (Poco::UInt8& other, const Var& da)
+	/// Multiplication assignment operator for multiplying Var with Poco::UInt8
+{
+	return other *= da.convert<Poco::UInt8>();
+}
+
+
+inline Poco::UInt8 operator /= (Poco::UInt8& other, const Var& da)
+	/// Division assignment operator for dividing Var with Poco::UInt8
+{
+	return other /= da.convert<Poco::UInt8>();
+}
+
+
+inline bool operator == (const Poco::UInt8& other, const Var& da)
+	/// Equality operator for comparing Var with Poco::UInt8
+{
+	if (da.isEmpty()) return false;
+	return other == da.convert<Poco::UInt8>();
+}
+
+
+inline bool operator != (const Poco::UInt8& other, const Var& da)
+	/// Inequality operator for comparing Var with Poco::UInt8
+{
+	if (da.isEmpty()) return true;
+	return other != da.convert<Poco::UInt8>();
+}
+
+
+inline bool operator < (const Poco::UInt8& other, const Var& da)
+	/// Less than operator for comparing Var with Poco::UInt8
+{
+	if (da.isEmpty()) return false;
+	return other < da.convert<Poco::UInt8>();
+}
+
+
+inline bool operator <= (const Poco::UInt8& other, const Var& da)
+	/// Less than or equal operator for comparing Var with Poco::UInt8
+{
+	if (da.isEmpty()) return false;
+	return other <= da.convert<Poco::UInt8>();
+}
+
+
+inline bool operator > (const Poco::UInt8& other, const Var& da)
+	/// Greater than operator for comparing Var with Poco::UInt8
+{
+	if (da.isEmpty()) return false;
+	return other > da.convert<Poco::UInt8>();
+}
+
+
+inline bool operator >= (const Poco::UInt8& other, const Var& da)
+	/// Greater than or equal operator for comparing Var with Poco::UInt8
+{
+	if (da.isEmpty()) return false;
+	return other >= da.convert<Poco::UInt8>();
+}
+
+
+inline Poco::Int16 operator + (const Poco::Int16& other, const Var& da)
+	/// Addition operator for adding Var to Poco::Int16
+{
+	return other + da.convert<Poco::Int16>();
+}
+
+
+inline Poco::Int16 operator - (const Poco::Int16& other, const Var& da)
+	/// Subtraction operator for subtracting Var from Poco::Int16
+{
+	return other - da.convert<Poco::Int16>();
+}
+
+
+inline Poco::Int16 operator * (const Poco::Int16& other, const Var& da)
+	/// Multiplication operator for multiplying Var with Poco::Int16
+{
+	return other * da.convert<Poco::Int16>();
+}
+
+
+inline Poco::Int16 operator / (const Poco::Int16& other, const Var& da)
+	/// Division operator for dividing Var with Poco::Int16
+{
+	return other / da.convert<Poco::Int16>();
+}
+
+
+inline Poco::Int16 operator += (Poco::Int16& other, const Var& da)
+	/// Addition assignment operator for adding Var to Poco::Int16
+{
+	return other += da.convert<Poco::Int16>();
+}
+
+
+inline Poco::Int16 operator -= (Poco::Int16& other, const Var& da)
+	/// Subtraction assignment operator for subtracting Var from Poco::Int16
+{
+	return other -= da.convert<Poco::Int16>();
+}
+
+
+inline Poco::Int16 operator *= (Poco::Int16& other, const Var& da)
+	/// Multiplication assignment operator for multiplying Var with Poco::Int16
+{
+	return other *= da.convert<Poco::Int16>();
+}
+
+
+inline Poco::Int16 operator /= (Poco::Int16& other, const Var& da)
+	/// Division assignment operator for dividing Var with Poco::Int16
+{
+	return other /= da.convert<Poco::Int16>();
+}
+
+
+inline bool operator == (const Poco::Int16& other, const Var& da)
+	/// Equality operator for comparing Var with Poco::Int16
+{
+	if (da.isEmpty()) return false;
+	return other == da.convert<Poco::Int16>();
+}
+
+
+inline bool operator != (const Poco::Int16& other, const Var& da)
+	/// Inequality operator for comparing Var with Poco::Int16
+{
+	if (da.isEmpty()) return true;
+	return other != da.convert<Poco::Int16>();
+}
+
+
+inline bool operator < (const Poco::Int16& other, const Var& da)
+	/// Less than operator for comparing Var with Poco::Int16
+{
+	if (da.isEmpty()) return false;
+	return other < da.convert<Poco::Int16>();
+}
+
+
+inline bool operator <= (const Poco::Int16& other, const Var& da)
+	/// Less than or equal operator for comparing Var with Poco::Int16
+{
+	if (da.isEmpty()) return false;
+	return other <= da.convert<Poco::Int16>();
+}
+
+
+inline bool operator > (const Poco::Int16& other, const Var& da)
+	/// Greater than operator for comparing Var with Poco::Int16
+{
+	if (da.isEmpty()) return false;
+	return other > da.convert<Poco::Int16>();
+}
+
+
+inline bool operator >= (const Poco::Int16& other, const Var& da)
+	/// Greater than or equal operator for comparing Var with Poco::Int16
+{
+	if (da.isEmpty()) return false;
+	return other >= da.convert<Poco::Int16>();
+}
+
+
+inline Poco::UInt16 operator + (const Poco::UInt16& other, const Var& da)
+	/// Addition operator for adding Var to Poco::UInt16
+{
+	return other + da.convert<Poco::UInt16>();
+}
+
+
+inline Poco::UInt16 operator - (const Poco::UInt16& other, const Var& da)
+	/// Subtraction operator for subtracting Var from Poco::UInt16
+{
+	return other - da.convert<Poco::UInt16>();
+}
+
+
+inline Poco::UInt16 operator * (const Poco::UInt16& other, const Var& da)
+	/// Multiplication operator for multiplying Var with Poco::UInt16
+{
+	return other * da.convert<Poco::UInt16>();
+}
+
+
+inline Poco::UInt16 operator / (const Poco::UInt16& other, const Var& da)
+	/// Division operator for dividing Var with Poco::UInt16
+{
+	return other / da.convert<Poco::UInt16>();
+}
+
+
+inline Poco::UInt16 operator += (Poco::UInt16& other, const Var& da)
+	/// Addition assignment operator for adding Var to Poco::UInt16
+{
+	return other += da.convert<Poco::UInt16>();
+}
+
+
+inline Poco::UInt16 operator -= (Poco::UInt16& other, const Var& da)
+	/// Subtraction assignment operator for subtracting Var from Poco::UInt16
+{
+	return other -= da.convert<Poco::UInt16>();
+}
+
+
+inline Poco::UInt16 operator *= (Poco::UInt16& other, const Var& da)
+	/// Multiplication assignment operator for multiplying Var with Poco::UInt16
+{
+	return other *= da.convert<Poco::UInt16>();
+}
+
+
+inline Poco::UInt16 operator /= (Poco::UInt16& other, const Var& da)
+	/// Division assignment operator for dividing Var with Poco::UInt16
+{
+	return other /= da.convert<Poco::UInt16>();
+}
+
+
+inline bool operator == (const Poco::UInt16& other, const Var& da)
+	/// Equality operator for comparing Var with Poco::UInt16
+{
+	if (da.isEmpty()) return false;
+	return other == da.convert<Poco::UInt16>();
+}
+
+
+inline bool operator != (const Poco::UInt16& other, const Var& da)
+	/// Inequality operator for comparing Var with Poco::UInt16
+{
+	if (da.isEmpty()) return true;
+	return other != da.convert<Poco::UInt16>();
+}
+
+
+inline bool operator < (const Poco::UInt16& other, const Var& da)
+	/// Less than operator for comparing Var with Poco::UInt16
+{
+	if (da.isEmpty()) return false;
+	return other < da.convert<Poco::UInt16>();
+}
+
+
+inline bool operator <= (const Poco::UInt16& other, const Var& da)
+	/// Less than or equal operator for comparing Var with Poco::UInt16
+{
+	if (da.isEmpty()) return false;
+	return other <= da.convert<Poco::UInt16>();
+}
+
+
+inline bool operator > (const Poco::UInt16& other, const Var& da)
+	/// Greater than operator for comparing Var with Poco::UInt16
+{
+	if (da.isEmpty()) return false;
+	return other > da.convert<Poco::UInt16>();
+}
+
+
+inline bool operator >= (const Poco::UInt16& other, const Var& da)
+	/// Greater than or equal operator for comparing Var with Poco::UInt16
+{
+	if (da.isEmpty()) return false;
+	return other >= da.convert<Poco::UInt16>();
+}
+
+
+inline Poco::Int32 operator + (const Poco::Int32& other, const Var& da)
+	/// Addition operator for adding Var to Poco::Int32
+{
+	return other + da.convert<Poco::Int32>();
+}
+
+
+inline Poco::Int32 operator - (const Poco::Int32& other, const Var& da)
+	/// Subtraction operator for subtracting Var from Poco::Int32
+{
+	return other - da.convert<Poco::Int32>();
+}
+
+
+inline Poco::Int32 operator * (const Poco::Int32& other, const Var& da)
+	/// Multiplication operator for multiplying Var with Poco::Int32
+{
+	return other * da.convert<Poco::Int32>();
+}
+
+
+inline Poco::Int32 operator / (const Poco::Int32& other, const Var& da)
+	/// Division operator for dividing Var with Poco::Int32
+{
+	return other / da.convert<Poco::Int32>();
+}
+
+
+inline Poco::Int32 operator += (Poco::Int32& other, const Var& da)
+	/// Addition assignment operator for adding Var to Poco::Int32
+{
+	return other += da.convert<Poco::Int32>();
+}
+
+
+inline Poco::Int32 operator -= (Poco::Int32& other, const Var& da)
+	/// Subtraction assignment operator for subtracting Var from Poco::Int32
+{
+	return other -= da.convert<Poco::Int32>();
+}
+
+
+inline Poco::Int32 operator *= (Poco::Int32& other, const Var& da)
+	/// Multiplication assignment operator for multiplying Var with Poco::Int32
+{
+	return other *= da.convert<Poco::Int32>();
+}
+
+
+inline Poco::Int32 operator /= (Poco::Int32& other, const Var& da)
+	/// Division assignment operator for dividing Var with Poco::Int32
+{
+	return other /= da.convert<Poco::Int32>();
+}
+
+
+inline bool operator == (const Poco::Int32& other, const Var& da)
+	/// Equality operator for comparing Var with Poco::Int32
+{
+	if (da.isEmpty()) return false;
+	return other == da.convert<Poco::Int32>();
+}
+
+
+inline bool operator != (const Poco::Int32& other, const Var& da)
+	/// Inequality operator for comparing Var with Poco::Int32
+{
+	if (da.isEmpty()) return true;
+	return other != da.convert<Poco::Int32>();
+}
+
+
+inline bool operator < (const Poco::Int32& other, const Var& da)
+	/// Less than operator for comparing Var with Poco::Int32
+{
+	if (da.isEmpty()) return false;
+	return other < da.convert<Poco::Int32>();
+}
+
+
+inline bool operator <= (const Poco::Int32& other, const Var& da)
+	/// Less than or equal operator for comparing Var with Poco::Int32
+{
+	if (da.isEmpty()) return false;
+	return other <= da.convert<Poco::Int32>();
+}
+
+
+inline bool operator > (const Poco::Int32& other, const Var& da)
+	/// Greater than operator for comparing Var with Poco::Int32
+{
+	if (da.isEmpty()) return false;
+	return other > da.convert<Poco::Int32>();
+}
+
+
+inline bool operator >= (const Poco::Int32& other, const Var& da)
+	/// Greater than or equal operator for comparing Var with Poco::Int32
+{
+	if (da.isEmpty()) return false;
+	return other >= da.convert<Poco::Int32>();
+}
+
+
+inline Poco::UInt32 operator + (const Poco::UInt32& other, const Var& da)
+	/// Addition operator for adding Var to Poco::UInt32
+{
+	return other + da.convert<Poco::UInt32>();
+}
+
+
+inline Poco::UInt32 operator - (const Poco::UInt32& other, const Var& da)
+	/// Subtraction operator for subtracting Var from Poco::UInt32
+{
+	return other - da.convert<Poco::UInt32>();
+}
+
+
+inline Poco::UInt32 operator * (const Poco::UInt32& other, const Var& da)
+	/// Multiplication operator for multiplying Var with Poco::UInt32
+{
+	return other * da.convert<Poco::UInt32>();
+}
+
+
+inline Poco::UInt32 operator / (const Poco::UInt32& other, const Var& da)
+	/// Division operator for dividing Var with Poco::UInt32
+{
+	return other / da.convert<Poco::UInt32>();
+}
+
+
+inline Poco::UInt32 operator += (Poco::UInt32& other, const Var& da)
+	/// Addition assignment operator for adding Var to Poco::UInt32
+{
+	return other += da.convert<Poco::UInt32>();
+}
+
+
+inline Poco::UInt32 operator -= (Poco::UInt32& other, const Var& da)
+	/// Subtraction assignment operator for subtracting Var from Poco::UInt32
+{
+	return other -= da.convert<Poco::UInt32>();
+}
+
+
+inline Poco::UInt32 operator *= (Poco::UInt32& other, const Var& da)
+	/// Multiplication assignment operator for multiplying Var with Poco::UInt32
+{
+	return other *= da.convert<Poco::UInt32>();
+}
+
+
+inline Poco::UInt32 operator /= (Poco::UInt32& other, const Var& da)
+	/// Division assignment operator for dividing Var with Poco::UInt32
+{
+	return other /= da.convert<Poco::UInt32>();
+}
+
+
+inline bool operator == (const Poco::UInt32& other, const Var& da)
+	/// Equality operator for comparing Var with Poco::UInt32
+{
+	if (da.isEmpty()) return false;
+	return other == da.convert<Poco::UInt32>();
+}
+
+
+inline bool operator != (const Poco::UInt32& other, const Var& da)
+	/// Inequality operator for comparing Var with Poco::UInt32
+{
+	if (da.isEmpty()) return true;
+	return other != da.convert<Poco::UInt32>();
+}
+
+
+inline bool operator < (const Poco::UInt32& other, const Var& da)
+	/// Less than operator for comparing Var with Poco::UInt32
+{
+	if (da.isEmpty()) return false;
+	return other < da.convert<Poco::UInt32>();
+}
+
+
+inline bool operator <= (const Poco::UInt32& other, const Var& da)
+	/// Less than or equal operator for comparing Var with Poco::UInt32
+{
+	if (da.isEmpty()) return false;
+	return other <= da.convert<Poco::UInt32>();
+}
+
+
+inline bool operator > (const Poco::UInt32& other, const Var& da)
+	/// Greater than operator for comparing Var with Poco::UInt32
+{
+	if (da.isEmpty()) return false;
+	return other > da.convert<Poco::UInt32>();
+}
+
+
+inline bool operator >= (const Poco::UInt32& other, const Var& da)
+	/// Greater than or equal operator for comparing Var with Poco::UInt32
+{
+	if (da.isEmpty()) return false;
+	return other >= da.convert<Poco::UInt32>();
+}
+
+
+inline Poco::Int64 operator + (const Poco::Int64& other, const Var& da)
+	/// Addition operator for adding Var to Poco::Int64
+{
+	return other + da.convert<Poco::Int64>();
+}
+
+
+inline Poco::Int64 operator - (const Poco::Int64& other, const Var& da)
+	/// Subtraction operator for subtracting Var from Poco::Int64
+{
+	return other - da.convert<Poco::Int64>();
+}
+
+
+inline Poco::Int64 operator * (const Poco::Int64& other, const Var& da)
+	/// Multiplication operator for multiplying Var with Poco::Int64
+{
+	return other * da.convert<Poco::Int64>();
+}
+
+
+inline Poco::Int64 operator / (const Poco::Int64& other, const Var& da)
+	/// Division operator for dividing Var with Poco::Int64
+{
+	return other / da.convert<Poco::Int64>();
+}
+
+
+inline Poco::Int64 operator += (Poco::Int64& other, const Var& da)
+	/// Addition assignment operator for adding Var to Poco::Int64
+{
+	return other += da.convert<Poco::Int64>();
+}
+
+
+inline Poco::Int64 operator -= (Poco::Int64& other, const Var& da)
+	/// Subtraction assignment operator for subtracting Var from Poco::Int64
+{
+	return other -= da.convert<Poco::Int64>();
+}
+
+
+inline Poco::Int64 operator *= (Poco::Int64& other, const Var& da)
+	/// Multiplication assignment operator for multiplying Var with Poco::Int64
+{
+	return other *= da.convert<Poco::Int64>();
+}
+
+
+inline Poco::Int64 operator /= (Poco::Int64& other, const Var& da)
+	/// Division assignment operator for dividing Var with Poco::Int64
+{
+	return other /= da.convert<Poco::Int64>();
+}
+
+
+inline bool operator == (const Poco::Int64& other, const Var& da)
+	/// Equality operator for comparing Var with Poco::Int64
+{
+	if (da.isEmpty()) return false;
+	return other == da.convert<Poco::Int64>();
+}
+
+
+inline bool operator != (const Poco::Int64& other, const Var& da)
+	/// Inequality operator for comparing Var with Poco::Int64
+{
+	if (da.isEmpty()) return true;
+	return other != da.convert<Poco::Int64>();
+}
+
+
+inline bool operator < (const Poco::Int64& other, const Var& da)
+	/// Less than operator for comparing Var with Poco::Int64
+{
+	if (da.isEmpty()) return false;
+	return other < da.convert<Poco::Int64>();
+}
+
+
+inline bool operator <= (const Poco::Int64& other, const Var& da)
+	/// Less than or equal operator for comparing Var with Poco::Int64
+{
+	if (da.isEmpty()) return false;
+	return other <= da.convert<Poco::Int64>();
+}
+
+
+inline bool operator > (const Poco::Int64& other, const Var& da)
+	/// Greater than operator for comparing Var with Poco::Int64
+{
+	if (da.isEmpty()) return false;
+	return other > da.convert<Poco::Int64>();
+}
+
+
+inline bool operator >= (const Poco::Int64& other, const Var& da)
+	/// Greater than or equal operator for comparing Var with Poco::Int64
+{
+	if (da.isEmpty()) return false;
+	return other >= da.convert<Poco::Int64>();
+}
+
+
+inline Poco::UInt64 operator + (const Poco::UInt64& other, const Var& da)
+	/// Addition operator for adding Var to Poco::UInt64
+{
+	return other + da.convert<Poco::UInt64>();
+}
+
+
+inline Poco::UInt64 operator - (const Poco::UInt64& other, const Var& da)
+	/// Subtraction operator for subtracting Var from Poco::UInt64
+{
+	return other - da.convert<Poco::UInt64>();
+}
+
+
+inline Poco::UInt64 operator * (const Poco::UInt64& other, const Var& da)
+	/// Multiplication operator for multiplying Var with Poco::UInt64
+{
+	return other * da.convert<Poco::UInt64>();
+}
+
+
+inline Poco::UInt64 operator / (const Poco::UInt64& other, const Var& da)
+	/// Division operator for dividing Var with Poco::UInt64
+{
+	return other / da.convert<Poco::UInt64>();
+}
+
+
+inline Poco::UInt64 operator += (Poco::UInt64& other, const Var& da)
+	/// Addition assignment operator for adding Var to Poco::UInt64
+{
+	return other += da.convert<Poco::UInt64>();
+}
+
+
+inline Poco::UInt64 operator -= (Poco::UInt64& other, const Var& da)
+	/// Subtraction assignment operator for subtracting Var from Poco::UInt64
+{
+	return other -= da.convert<Poco::UInt64>();
+}
+
+
+inline Poco::UInt64 operator *= (Poco::UInt64& other, const Var& da)
+	/// Multiplication assignment operator for multiplying Var with Poco::UInt64
+{
+	return other *= da.convert<Poco::UInt64>();
+}
+
+
+inline Poco::UInt64 operator /= (Poco::UInt64& other, const Var& da)
+	/// Division assignment operator for dividing Var with Poco::UInt64
+{
+	return other /= da.convert<Poco::UInt64>();
+}
+
+
+inline bool operator == (const Poco::UInt64& other, const Var& da)
+	/// Equality operator for comparing Var with Poco::UInt64
+{
+	if (da.isEmpty()) return false;
+	return other == da.convert<Poco::UInt64>();
+}
+
+
+inline bool operator != (const Poco::UInt64& other, const Var& da)
+	/// Inequality operator for comparing Var with Poco::UInt64
+{
+	if (da.isEmpty()) return true;
+	return other != da.convert<Poco::UInt64>();
+}
+
+
+inline bool operator < (const Poco::UInt64& other, const Var& da)
+	/// Less than operator for comparing Var with Poco::UInt64
+{
+	if (da.isEmpty()) return false;
+	return other < da.convert<Poco::UInt64>();
+}
+
+
+inline bool operator <= (const Poco::UInt64& other, const Var& da)
+	/// Less than or equal operator for comparing Var with Poco::UInt64
+{
+	if (da.isEmpty()) return false;
+	return other <= da.convert<Poco::UInt64>();
+}
+
+
+inline bool operator > (const Poco::UInt64& other, const Var& da)
+	/// Greater than operator for comparing Var with Poco::UInt64
+{
+	if (da.isEmpty()) return false;
+	return other > da.convert<Poco::UInt64>();
+}
+
+
+inline bool operator >= (const Poco::UInt64& other, const Var& da)
+	/// Greater than or equal operator for comparing Var with Poco::UInt64
+{
+	if (da.isEmpty()) return false;
+	return other >= da.convert<Poco::UInt64>();
+}
+
+
+inline float operator + (const float& other, const Var& da)
+	/// Addition operator for adding Var to float
+{
+	return other + da.convert<float>();
+}
+
+
+inline float operator - (const float& other, const Var& da)
+	/// Subtraction operator for subtracting Var from float
+{
+	return other - da.convert<float>();
+}
+
+
+inline float operator * (const float& other, const Var& da)
+	/// Multiplication operator for multiplying Var with float
+{
+	return other * da.convert<float>();
+}
+
+
+inline float operator / (const float& other, const Var& da)
+	/// Division operator for dividing Var with float
+{
+	return other / da.convert<float>();
+}
+
+
+inline float operator += (float& other, const Var& da)
+	/// Addition assignment operator for adding Var to float
+{
+	return other += da.convert<float>();
+}
+
+
+inline float operator -= (float& other, const Var& da)
+	/// Subtraction assignment operator for subtracting Var from float
+{
+	return other -= da.convert<float>();
+}
+
+
+inline float operator *= (float& other, const Var& da)
+	/// Multiplication assignment operator for multiplying Var with float
+{
+	return other *= da.convert<float>();
+}
+
+
+inline float operator /= (float& other, const Var& da)
+	/// Division assignment operator for dividing Var with float
+{
+	return other /= da.convert<float>();
+}
+
+
+inline bool operator == (const float& other, const Var& da)
+	/// Equality operator for comparing Var with float
+{
+	if (da.isEmpty()) return false;
+	return other == da.convert<float>();
+}
+
+
+inline bool operator != (const float& other, const Var& da)
+	/// Inequality operator for comparing Var with float
+{
+	if (da.isEmpty()) return true;
+	return other != da.convert<float>();
+}
+
+
+inline bool operator < (const float& other, const Var& da)
+	/// Less than operator for comparing Var with float
+{
+	if (da.isEmpty()) return false;
+	return other < da.convert<float>();
+}
+
+
+inline bool operator <= (const float& other, const Var& da)
+	/// Less than or equal operator for comparing Var with float
+{
+	if (da.isEmpty()) return false;
+	return other <= da.convert<float>();
+}
+
+
+inline bool operator > (const float& other, const Var& da)
+	/// Greater than operator for comparing Var with float
+{
+	if (da.isEmpty()) return false;
+	return other > da.convert<float>();
+}
+
+
+inline bool operator >= (const float& other, const Var& da)
+	/// Greater than or equal operator for comparing Var with float
+{
+	if (da.isEmpty()) return false;
+	return other >= da.convert<float>();
+}
+
+
+inline double operator + (const double& other, const Var& da)
+	/// Addition operator for adding Var to double
+{
+	return other + da.convert<double>();
+}
+
+
+inline double operator - (const double& other, const Var& da)
+	/// Subtraction operator for subtracting Var from double
+{
+	return other - da.convert<double>();
+}
+
+
+inline double operator * (const double& other, const Var& da)
+	/// Multiplication operator for multiplying Var with double
+{
+	return other * da.convert<double>();
+}
+
+
+inline double operator / (const double& other, const Var& da)
+	/// Division operator for dividing Var with double
+{
+	return other / da.convert<double>();
+}
+
+
+inline double operator += (double& other, const Var& da)
+	/// Addition assignment operator for adding Var to double
+{
+	return other += da.convert<double>();
+}
+
+
+inline double operator -= (double& other, const Var& da)
+	/// Subtraction assignment operator for subtracting Var from double
+{
+	return other -= da.convert<double>();
+}
+
+
+inline double operator *= (double& other, const Var& da)
+	/// Multiplication assignment operator for multiplying Var with double
+{
+	return other *= da.convert<double>();
+}
+
+
+inline double operator /= (double& other, const Var& da)
+	/// Division assignment operator for dividing Var with double
+{
+	return other /= da.convert<double>();
+}
+
+
+inline bool operator == (const double& other, const Var& da)
+	/// Equality operator for comparing Var with double
+{
+	if (da.isEmpty()) return false;
+	return other == da.convert<double>();
+}
+
+
+inline bool operator != (const double& other, const Var& da)
+	/// Inequality operator for comparing Var with double
+{
+	if (da.isEmpty()) return true;
+	return other != da.convert<double>();
+}
+
+
+inline bool operator < (const double& other, const Var& da)
+	/// Less than operator for comparing Var with double
+{
+	if (da.isEmpty()) return false;
+	return other < da.convert<double>();
+}
+
+
+inline bool operator <= (const double& other, const Var& da)
+	/// Less than or equal operator for comparing Var with double
+{
+	if (da.isEmpty()) return false;
+	return other <= da.convert<double>();
+}
+
+
+inline bool operator > (const double& other, const Var& da)
+	/// Greater than operator for comparing Var with double
+{
+	if (da.isEmpty()) return false;
+	return other > da.convert<double>();
+}
+
+
+inline bool operator >= (const double& other, const Var& da)
+	/// Greater than or equal operator for comparing Var with double
+{
+	if (da.isEmpty()) return false;
+	return other >= da.convert<double>();
+}
+
+
+inline bool operator == (const bool& other, const Var& da)
+	/// Equality operator for comparing Var with bool
+{
+	if (da.isEmpty()) return false;
+	return other == da.convert<bool>();
+}
+
+
+inline bool operator != (const bool& other, const Var& da)
+	/// Inequality operator for comparing Var with bool
+{
+	if (da.isEmpty()) return true;
+	return other != da.convert<bool>();
+}
+
+
+inline bool operator == (const std::string& other, const Var& da)
+	/// Equality operator for comparing Var with std::string
+{
+	if (da.isEmpty()) return false;
+	return other == da.convert<std::string>();
+}
+
+
+inline bool operator != (const std::string& other, const Var& da)
+	/// Inequality operator for comparing Var with std::string
+{
+	if (da.isEmpty()) return true;
+	return other != da.convert<std::string>();
+}
+
+
+inline bool operator == (const UTF16String& other, const Var& da)
+	/// Equality operator for comparing Var with UTF16String
+{
+	if (da.isEmpty()) return false;
+	return other == da.convert<UTF16String>();
+}
+
+
+inline bool operator != (const UTF16String& other, const Var& da)
+	/// Inequality operator for comparing Var with UTF16String
+{
+	if (da.isEmpty()) return true;
+	return other != da.convert<UTF16String>();
+}
+
+
+inline bool operator == (const char* other, const Var& da)
+	/// Equality operator for comparing Var with const char*
+{
+	if (da.isEmpty()) return false;
+	return da.convert<std::string>() == other;
+}
+
+
+inline bool operator != (const char* other, const Var& da)
+	/// Inequality operator for comparing Var with const char*
+{
+	if (da.isEmpty()) return true;
+	return da.convert<std::string>() != other;
+}
+
+
+#ifndef POCO_LONG_IS_64_BIT
+
+
+inline long operator + (const long& other, const Var& da)
+	/// Addition operator for adding Var to long
+{
+	return other + da.convert<long>();
+}
+
+
+inline long operator - (const long& other, const Var& da)
+	/// Subtraction operator for subtracting Var from long
+{
+	return other - da.convert<long>();
+}
+
+
+inline long operator * (const long& other, const Var& da)
+	/// Multiplication operator for multiplying Var with long
+{
+	return other * da.convert<long>();
+}
+
+
+inline long operator / (const long& other, const Var& da)
+	/// Division operator for dividing Var with long
+{
+	return other / da.convert<long>();
+}
+
+
+inline long operator += (long& other, const Var& da)
+	/// Addition assignment operator for adding Var to long
+{
+	return other += da.convert<long>();
+}
+
+
+inline long operator -= (long& other, const Var& da)
+	/// Subtraction assignment operator for subtracting Var from long
+{
+	return other -= da.convert<long>();
+}
+
+
+inline long operator *= (long& other, const Var& da)
+	/// Multiplication assignment operator for multiplying Var with long
+{
+	return other *= da.convert<long>();
+}
+
+
+inline long operator /= (long& other, const Var& da)
+	/// Division assignment operator for dividing Var with long
+{
+	return other /= da.convert<long>();
+}
+
+
+inline bool operator == (const long& other, const Var& da)
+	/// Equality operator for comparing Var with long
+{
+	if (da.isEmpty()) return false;
+	return other == da.convert<long>();
+}
+
+
+inline bool operator != (const long& other, const Var& da)
+	/// Inequality operator for comparing Var with long
+{
+	if (da.isEmpty()) return true;
+	return other != da.convert<long>();
+}
+
+
+inline bool operator < (const long& other, const Var& da)
+	/// Less than operator for comparing Var with long
+{
+	if (da.isEmpty()) return false;
+	return other < da.convert<long>();
+}
+
+
+inline bool operator <= (const long& other, const Var& da)
+	/// Less than or equal operator for comparing Var with long
+{
+	if (da.isEmpty()) return false;
+	return other <= da.convert<long>();
+}
+
+
+inline bool operator > (const long& other, const Var& da)
+	/// Greater than operator for comparing Var with long
+{
+	if (da.isEmpty()) return false;
+	return other > da.convert<long>();
+}
+
+
+inline bool operator >= (const long& other, const Var& da)
+	/// Greater than or equal operator for comparing Var with long
+{
+	if (da.isEmpty()) return false;
+	return other >= da.convert<long>();
+}
+
+
+#endif // POCO_LONG_IS_64_BIT
+
+
+} // namespace Dynamic
+
+
+//@ deprecated
+typedef Dynamic::Var DynamicAny;
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Var_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Dynamic/VarHolder.h b/base/poco/Foundation/include/Poco/Dynamic/VarHolder.h
new file mode 100644
index 00000000000..e0af6a6d593
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Dynamic/VarHolder.h
@@ -0,0 +1,4186 @@
+//
+// VarHolder.h
+//
+// Library: Foundation
+// Package: Dynamic
+// Module:  VarHolder
+//
+// Definition of the VarHolder class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_VarHolder_INCLUDED
+#define Foundation_VarHolder_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/NumberParser.h"
+#include "Poco/DateTime.h"
+#include "Poco/Timestamp.h"
+#include "Poco/LocalDateTime.h"
+#include "Poco/DateTimeFormat.h"
+#include "Poco/DateTimeFormatter.h"
+#include "Poco/DateTimeParser.h"
+#include "Poco/String.h"
+#include "Poco/UnicodeConverter.h"
+#include "Poco/UTFString.h"
+#include "Poco/UTF8String.h"
+#include "Poco/Any.h"
+#include "Poco/Exception.h"
+#include <vector>
+#include <list>
+#include <deque>
+#include <typeinfo>
+#undef min
+#undef max
+#include <limits>
+
+
+namespace Poco {
+namespace Dynamic {
+
+
+class Var;
+
+
+namespace Impl {
+
+
+bool Foundation_API isJSONString(const Var& any);
+	/// Returns true for values that should be JSON-formatted as string.
+
+
+void Foundation_API appendJSONKey(std::string& val, const Var& any);
+	/// Converts the any to a JSON key (i.e. wraps it into double quotes 
+	/// regardless of the underlying type) and appends it to val.
+
+
+void Foundation_API appendJSONString(std::string& val, const Var& any);
+	/// Converts the any to a JSON string (i.e. wraps it into double quotes) 
+	/// regardless of the underlying type) and appends it to val.
+
+
+void Foundation_API appendJSONValue(std::string& val, const Var& any);
+	/// Converts the any to a JSON value (if underlying type qualifies 
+	/// as string - see isJSONString() - , it is wrapped into double quotes) 
+	/// and appends it to val
+
+
+template <typename C>
+void containerToJSON(C& cont, std::string& val)
+{
+	// Serialize in JSON format. Note: although this is a vector<T>, the code only 
+	// supports vector<Var>. Total specialization is not possible
+	// because of the cyclic dependency between Var and VarHolder
+
+	// JSON format definition: [ n times: elem ',' ], no ',' for last elem
+	val.append("[ ");
+	typename C::const_iterator it = cont.begin();
+	typename C::const_iterator itEnd = cont.end();
+	if (!cont.empty())
+	{
+		appendJSONValue(val, *it);
+		++it;
+	}
+	for (; it != itEnd; ++it)
+	{
+		val.append(", ");
+		appendJSONValue(val, *it);
+	}
+	val.append(" ]");
+}
+
+
+} // namespace Impl
+
+
+class Foundation_API VarHolder
+	/// Interface for a data holder used by the Var class. 
+	/// Provides methods to convert between data types.
+	/// Only data types for which VarHolder specialization exists are supported.
+	/// 
+	/// Provided are specializations for all C++ built-in types with addition of 
+	/// std::string, Poco::UTF16String, DateTime, LocalDateTime, Timestamp, std::vector<Var> and DynamicStruct.
+	///
+	/// Additional types can be supported by adding specializations. When implementing specializations,
+	/// the only condition is that they reside in Poco namespace and implement the pure virtual functions
+	/// clone() and type().
+	///
+	/// Those conversions that are not implemented shall fail back to this base
+	/// class implementation. All the convert() function overloads in this class
+	/// throw BadCastException.
+{
+public:
+	typedef Var ArrayValueType;
+
+	virtual ~VarHolder();
+		/// Destroys the VarHolder.
+
+	virtual VarHolder* clone(Placeholder<VarHolder>* pHolder = 0) const = 0;
+		/// Implementation must implement this function to
+		/// deep-copy the VarHolder.
+		/// If small object optimization is enabled (i.e. if 
+		/// POCO_NO_SOO is not defined), VarHolder will be
+		/// instantiated in-place if it's size is smaller
+		/// than POCO_SMALL_OBJECT_SIZE.
+
+	virtual const std::type_info& type() const = 0;
+		/// Implementation must return the type information
+		/// (typeid) for the stored content.
+
+	virtual void convert(Int8& val) const;
+		/// Throws BadCastException. Must be overriden in a type
+		/// specialization in order to support the conversion.
+
+	virtual void convert(Int16& val) const;
+		/// Throws BadCastException. Must be overriden in a type
+		/// specialization in order to support the conversion.
+
+	virtual void convert(Int32& val) const;
+		/// Throws BadCastException. Must be overriden in a type
+		/// specialization in order to support the conversion.
+
+	virtual void convert(Int64& val) const;
+		/// Throws BadCastException. Must be overriden in a type
+		/// specialization in order to support the conversion.
+
+	virtual void convert(UInt8& val) const;
+		/// Throws BadCastException. Must be overriden in a type
+		/// specialization in order to support the conversion.
+
+	virtual void convert(UInt16& val) const;
+		/// Throws BadCastException. Must be overriden in a type
+		/// specialization in order to support the conversion.
+
+	virtual void convert(UInt32& val) const;
+		/// Throws BadCastException. Must be overriden in a type
+		/// specialization in order to support the conversion.
+
+	virtual void convert(UInt64& val) const;
+		/// Throws BadCastException. Must be overriden in a type
+		/// specialization in order to support the conversion.
+
+	virtual void convert(DateTime& val) const;
+		/// Throws BadCastException. Must be overriden in a type
+		/// specialization in order to support the conversion.
+
+	virtual void convert(LocalDateTime& val) const;
+		/// Throws BadCastException. Must be overriden in a type
+		/// specialization in order to support the conversion.
+
+	virtual void convert(Timestamp& val) const;
+		/// Throws BadCastException. Must be overriden in a type
+		/// specialization in order to support the conversion.
+
+#ifndef POCO_LONG_IS_64_BIT
+
+	void convert(long& val) const;
+		/// Calls convert(Int32).
+
+	void convert(unsigned long& val) const;
+		/// Calls convert(UInt32).
+
+#else
+
+	virtual void convert(long long& val) const;
+		/// Throws BadCastException. Must be overriden in a type
+		/// specialization in order to suport the conversion.
+
+	virtual void convert(unsigned long long & val) const;
+		/// Throws BadCastException. Must be overriden in a type
+		/// specialization in order to suport the conversion.
+
+#endif
+
+	virtual void convert(bool& val) const;
+		/// Throws BadCastException. Must be overriden in a type
+		/// specialization in order to support the conversion.
+
+	virtual void convert(float& val) const;
+		/// Throws BadCastException. Must be overriden in a type
+		/// specialization in order to support the conversion.
+
+	virtual void convert(double& val) const;
+		/// Throws BadCastException. Must be overriden in a type
+		/// specialization in order to support the conversion.
+
+	virtual void convert(char& val) const;
+		/// Throws BadCastException. Must be overriden in a type
+		/// specialization in order to support the conversion.
+
+	virtual void convert(std::string& val) const;
+		/// Throws BadCastException. Must be overriden in a type
+		/// specialization in order to support the conversion.
+
+	virtual void convert(Poco::UTF16String& val) const;
+	/// Throws BadCastException. Must be overriden in a type
+	/// specialization in order to support the conversion.
+
+	virtual bool isArray() const;
+		/// Returns true.
+
+	virtual bool isVector() const;
+		/// Returns false. Must be properly overriden in a type
+		/// specialization in order to support the diagnostic.
+
+	virtual bool isList() const;
+		/// Returns false. Must be properly overriden in a type
+		/// specialization in order to support the diagnostic.
+
+	virtual bool isDeque() const;
+		/// Returns false. Must be properly overriden in a type
+		/// specialization in order to support the diagnostic.
+
+	virtual bool isStruct() const;
+		/// Returns false. Must be properly overriden in a type
+		/// specialization in order to support the diagnostic.
+
+	virtual bool isInteger() const;
+		/// Returns false. Must be properly overriden in a type
+		/// specialization in order to support the diagnostic.
+
+	virtual bool isSigned() const;
+		/// Returns false. Must be properly overriden in a type
+		/// specialization in order to support the diagnostic.
+
+	virtual bool isNumeric() const;
+		/// Returns false. Must be properly overriden in a type
+		/// specialization in order to support the diagnostic.
+
+	virtual bool isBoolean() const;
+		/// Returns false. Must be properly overriden in a type
+		/// specialization in order to support the diagnostic.
+
+	virtual bool isString() const;
+		/// Returns false. Must be properly overriden in a type
+		/// specialization in order to support the diagnostic.
+
+	virtual bool isDate() const;
+		/// Returns false. Must be properly overriden in a type
+		/// specialization in order to support the diagnostic.
+
+	virtual bool isTime() const;
+		/// Returns false. Must be properly overriden in a type
+		/// specialization in order to support the diagnostic.
+
+	virtual bool isDateTime() const;
+		/// Returns false. Must be properly overriden in a type
+		/// specialization in order to support the diagnostic.
+
+	virtual std::size_t size() const;
+		/// Returns 1 iff Var is not empty or this function overriden.
+
+protected:
+	VarHolder();
+		/// Creates the VarHolder.
+
+	template <typename T>
+	VarHolder* cloneHolder(Placeholder<VarHolder>* pVarHolder, const T& val) const
+		/// Instantiates value holder wrapper. If size of the wrapper is
+		/// larger than POCO_SMALL_OBJECT_SIZE, holder is instantiated on
+		/// the heap, otherwise it is instantiated in-place (in the 
+		/// pre-allocated buffer inside the holder).
+		/// 
+		/// Called from clone() member function of the implementation when
+		/// small object optimization is enabled.
+	{
+#ifdef POCO_NO_SOO
+		(void)pVarHolder;
+		return new VarHolderImpl<T>(val);
+#else
+		poco_check_ptr (pVarHolder);
+		if ((sizeof(VarHolderImpl<T>) <= Placeholder<T>::Size::value))
+		{
+			new ((VarHolder*) pVarHolder->holder) VarHolderImpl<T>(val);
+			pVarHolder->setLocal(true);
+			return (VarHolder*) pVarHolder->holder;
+		}
+		else
+		{
+			pVarHolder->pHolder = new VarHolderImpl<T>(val);
+			pVarHolder->setLocal(false);
+			return pVarHolder->pHolder;
+		}
+#endif
+	}
+
+	template <typename F, typename T>
+	void convertToSmaller(const F& from, T& to) const
+		/// This function is meant to convert signed numeric values from
+		/// larger to smaller type. It checks the upper and lower bound and
+		/// if from value is within limits of type T (i.e. check calls do not throw), 
+		/// it is converted.
+	{
+		poco_static_assert (std::numeric_limits<F>::is_specialized);
+		poco_static_assert (std::numeric_limits<T>::is_specialized);
+		poco_static_assert (std::numeric_limits<F>::is_signed);
+		poco_static_assert (std::numeric_limits<T>::is_signed);
+
+		if (std::numeric_limits<F>::is_integer)
+		{
+			checkUpperLimit<F,T>(from); 
+			checkLowerLimit<F,T>(from);
+		}
+		else
+		{
+			checkUpperLimitFloat<F,T>(from); 
+			checkLowerLimitFloat<F,T>(from); 
+		}
+		
+		to = static_cast<T>(from);
+	}
+
+	template <typename F, typename T>
+	void convertToSmallerUnsigned(const F& from, T& to) const
+		/// This function is meant for converting unsigned integral data types,
+		/// from larger to smaller type. Since lower limit is always 0 for unsigned types,
+		/// only the upper limit is checked, thus saving some cycles compared to the signed
+		/// version of the function. If the value to be converted is smaller than
+		/// the maximum value for the target type, the conversion is performed.
+	{
+		poco_static_assert (std::numeric_limits<F>::is_specialized);
+		poco_static_assert (std::numeric_limits<T>::is_specialized);
+		poco_static_assert (!std::numeric_limits<F>::is_signed);
+		poco_static_assert (!std::numeric_limits<T>::is_signed);
+
+		checkUpperLimit<F,T>(from); 
+		to = static_cast<T>(from);
+	}
+
+	template <typename F, typename T>
+	void convertSignedToUnsigned(const F& from, T& to) const
+		/// This function is meant for converting signed integral data types to
+		/// unsigned data types. Negative values can not be converted and if one
+		/// is encountered, RangeException is thrown.
+		/// If upper limit is within the target data type limits, the conversion is performed.
+	{
+		poco_static_assert (std::numeric_limits<F>::is_specialized);
+		poco_static_assert (std::numeric_limits<T>::is_specialized);
+		poco_static_assert (std::numeric_limits<F>::is_signed);
+		poco_static_assert (!std::numeric_limits<T>::is_signed);
+
+		if (from < 0)
+			throw RangeException("Value too small.");
+		checkUpperLimit<F,T>(from); 
+		to = static_cast<T>(from);
+	}
+
+	template <typename F, typename T>
+	void convertSignedFloatToUnsigned(const F& from, T& to) const
+		/// This function is meant for converting floating point data types to
+		/// unsigned integral data types. Negative values can not be converted and if one
+		/// is encountered, RangeException is thrown.
+		/// If upper limit is within the target data type limits, the conversion is performed.
+	{
+		poco_static_assert (std::numeric_limits<F>::is_specialized);
+		poco_static_assert (std::numeric_limits<T>::is_specialized);
+		poco_static_assert (!std::numeric_limits<F>::is_integer);
+		poco_static_assert (std::numeric_limits<T>::is_integer);
+		poco_static_assert (!std::numeric_limits<T>::is_signed);
+
+		if (from < 0)
+			throw RangeException("Value too small.");
+		checkUpperLimitFloat<F,T>(from); 
+		to = static_cast<T>(from);
+	}
+
+	template <typename F, typename T>
+	void convertUnsignedToSigned(const F& from, T& to) const
+		/// This function is meant for converting unsigned integral data types to
+		/// signed integral data types. Negative values can not be converted and if one
+		/// is encountered, RangeException is thrown.
+		/// If upper limit is within the target data type limits, the conversion is performed.
+	{
+		poco_static_assert (std::numeric_limits<F>::is_specialized);
+		poco_static_assert (std::numeric_limits<T>::is_specialized);
+		poco_static_assert (!std::numeric_limits<F>::is_signed);
+		poco_static_assert (std::numeric_limits<T>::is_signed);
+
+		checkUpperLimit<F,T>(from);
+		to = static_cast<T>(from);
+	}
+
+private:
+	template <typename F, typename T>
+	void checkUpperLimit(const F& from) const
+	{
+		if ((sizeof(T) < sizeof(F)) &&
+			(from > static_cast<F>(std::numeric_limits<T>::max())))
+		{
+			throw RangeException("Value too large.");
+		}
+		else
+		if (from > std::numeric_limits<T>::max())
+		{
+			throw RangeException("Value too large.");
+		}
+	}
+
+	template <typename F, typename T>
+	void checkUpperLimitFloat(const F& from) const
+	{
+		if (from > std::numeric_limits<T>::max())
+			throw RangeException("Value too large.");
+	}
+
+	template <typename F, typename T>
+	void checkLowerLimitFloat(const F& from) const
+	{
+		if (from < -std::numeric_limits<T>::max()) 
+			throw RangeException("Value too small.");
+	}
+
+	template <typename F, typename T>
+	void checkLowerLimit(const F& from) const
+	{
+		if (from < std::numeric_limits<T>::min()) 
+			throw RangeException("Value too small.");
+	}
+};
+
+
+//
+// inlines
+//
+
+
+inline void VarHolder::convert(Int8& /*val*/) const
+{
+	throw BadCastException("Can not convert to Int8");
+}
+
+
+inline void VarHolder::convert(Int16& /*val*/) const
+{
+	throw BadCastException("Can not convert to Int16");
+}
+
+
+inline void VarHolder::convert(Int32& /*val*/) const
+{
+	throw BadCastException("Can not convert to Int32");
+}
+
+
+inline void VarHolder::convert(Int64& /*val*/) const
+{
+	throw BadCastException("Can not convert to Int64");
+}
+
+
+inline void VarHolder::convert(UInt8& /*val*/) const
+{
+	throw BadCastException("Can not convert to UInt8");
+}
+
+
+inline void VarHolder::convert(UInt16& /*val*/) const
+{
+	throw BadCastException("Can not convert to UInt16");
+}
+
+
+inline void VarHolder::convert(UInt32& /*val*/) const
+{
+	throw BadCastException("Can not convert to UInt32");
+}
+
+
+inline void VarHolder::convert(UInt64& /*val*/) const
+{
+	throw BadCastException("Can not convert to UInt64");
+}
+
+
+inline void VarHolder::convert(DateTime& /*val*/) const
+{
+	throw BadCastException("Can not convert to DateTime");
+}
+
+
+inline void VarHolder::convert(LocalDateTime& /*val*/) const
+{
+	throw BadCastException("Can not convert to LocalDateTime");
+}
+
+
+inline void VarHolder::convert(Timestamp& /*val*/) const
+{
+	throw BadCastException("Can not convert to Timestamp");
+}
+
+#ifndef POCO_LONG_IS_64_BIT
+
+inline void VarHolder::convert(long& val) const
+{
+	Int32 tmp;
+	convert(tmp);
+	val = tmp;
+}
+
+
+inline void VarHolder::convert(unsigned long& val) const
+{
+	UInt32 tmp;
+	convert(tmp);
+	val = tmp;
+}
+
+#else
+
+inline void VarHolder::convert(long long& /*val*/) const
+{
+	throw BadCastException("Can not convert to long long");
+}
+
+
+inline void VarHolder::convert(unsigned long long& /*val*/) const
+{
+	throw BadCastException("Can not convert to unsigned long long");
+}
+
+#endif
+
+inline void VarHolder::convert(bool& /*val*/) const
+{
+	throw BadCastException("Can not convert to bool");
+}
+
+
+inline void VarHolder::convert(float& /*val*/) const
+{
+	throw BadCastException("Can not convert to float");
+}
+
+
+inline void VarHolder::convert(double& /*val*/) const
+{
+	throw BadCastException("Can not convert to double");
+}
+
+
+inline void VarHolder::convert(char& /*val*/) const
+{
+	throw BadCastException("Can not convert to char");
+}
+
+
+inline void VarHolder::convert(std::string& /*val*/) const
+{
+	throw BadCastException("Can not convert to std::string");
+}
+
+
+inline void VarHolder::convert(Poco::UTF16String& /*val*/) const
+{
+	throw BadCastException("Can not convert to Poco::UTF16String");
+}
+
+
+inline bool VarHolder::isArray() const
+{
+	return true;
+}
+
+
+inline bool VarHolder::isVector() const
+{
+	return false;
+}
+
+
+inline bool VarHolder::isList() const
+{
+	return false;
+}
+
+
+inline bool VarHolder::isDeque() const
+{
+	return false;
+}
+
+
+inline bool VarHolder::isStruct() const
+{
+	return false;
+}
+
+inline bool VarHolder::isInteger() const
+{
+	return false;
+}
+
+
+inline bool VarHolder::isSigned() const
+{
+	return false;
+}
+
+
+inline bool VarHolder::isNumeric() const
+{
+	return false;
+}
+
+
+inline bool VarHolder::isBoolean() const
+{
+	return false;
+}
+
+
+inline bool VarHolder::isString() const
+{
+	return false;
+}
+
+
+inline bool VarHolder::isDate() const
+{
+	return false;
+}
+
+
+inline bool VarHolder::isTime() const
+{
+	return false;
+}
+
+
+inline bool VarHolder::isDateTime() const
+{
+	return false;
+}
+
+inline std::size_t VarHolder::size() const
+{
+	return 1u;
+}
+
+
+template <typename T>
+class VarHolderImpl: public VarHolder
+	/// Template based implementation of a VarHolder. 
+	/// This class provides type storage for user-defined types
+	/// that do not have VarHolderImpl specialization.
+	///
+	/// The actual conversion work happens in the template specializations
+	/// of this class.
+	///
+	/// VarHolderImpl throws following exceptions:
+	///		BadCastException (if the requested conversion is not implemented)
+	///		RangeException (if an attempt is made to assign a numeric value outside of the target min/max limits
+	///		SyntaxException (if an attempt is made to convert a string containing non-numeric characters to number)
+	///
+	/// In order to support efficient direct extraction of the held value,
+	/// all specializations must additionally implement a public member function:
+	///
+	///     const T& value() const
+	///
+	/// returning a const reference to the actual stored value.
+{
+public:
+	VarHolderImpl(const T& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(T);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const T& value() const
+	{
+		return _val;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	T _val;
+};
+
+
+template <>
+class VarHolderImpl<Int8>: public VarHolder
+{
+public:
+	VarHolderImpl(Int8 val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+	
+	const std::type_info& type() const
+	{
+		return typeid(Int8);
+	}
+
+	void convert(Int8& val) const
+	{
+		val = _val;
+	}
+
+	void convert(Int16& val) const
+	{
+		val = _val;
+	}
+	
+	void convert(Int32& val) const
+	{
+		val = _val;
+	}
+
+	void convert(Int64& val) const
+	{
+		val = _val;
+	}
+
+	void convert(UInt8& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+	void convert(UInt16& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+	
+	void convert(UInt32& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+	void convert(UInt64& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	void convert(long long& val) const
+	{
+		val = _val;
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+#endif
+
+	void convert(bool& val) const
+	{
+		val = (_val != 0);
+	}
+
+	void convert(float& val) const
+	{
+		val = static_cast<float>(_val);
+	}
+
+	void convert(double& val) const
+	{
+		val = static_cast<double>(_val);
+	}
+
+	void convert(char& val) const
+	{
+		val = static_cast<char>(_val);
+	}
+
+	void convert(std::string& val) const
+	{
+		val = NumberFormatter::format(_val);
+	}
+
+	void convert(Poco::UTF16String& val) const
+	{
+		std::string str = NumberFormatter::format(_val);
+		Poco::UnicodeConverter::convert(str, val);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+	
+	const Int8& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return std::numeric_limits<Int8>::is_integer;
+	}
+
+	bool isSigned() const
+	{
+		return std::numeric_limits<Int8>::is_signed;
+	}
+
+	bool isNumeric() const
+	{
+		return std::numeric_limits<Int8>::is_specialized;
+	}
+
+	bool isBoolean() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	Int8 _val;
+};
+
+
+template <>
+class VarHolderImpl<Int16>: public VarHolder
+{
+public:
+	VarHolderImpl(Int16 val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+	
+	const std::type_info& type() const
+	{
+		return typeid(Int16);
+	}
+
+	void convert(Int8& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+
+	void convert(Int16& val) const
+	{
+		val = _val;
+	}
+	
+	void convert(Int32& val) const
+	{
+		val = _val;
+	}
+
+	void convert(Int64& val) const
+	{
+		val = _val;
+	}
+
+	void convert(UInt8& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+	void convert(UInt16& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+	
+	void convert(UInt32& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+	void convert(UInt64& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	void convert(long long& val) const
+	{
+		val = _val;
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+#endif
+
+	void convert(bool& val) const
+	{
+		val = (_val != 0);
+	}
+
+	void convert(float& val) const
+	{
+		val = static_cast<float>(_val);
+	}
+
+	void convert(double& val) const
+	{
+		val = static_cast<double>(_val);
+	}
+
+	void convert(char& val) const
+	{
+		UInt8 tmp;
+		convert(tmp);
+		val = static_cast<char>(tmp);
+	}
+
+	void convert(std::string& val) const
+	{
+		val = NumberFormatter::format(_val);
+	}
+
+	void convert(Poco::UTF16String& val) const
+	{
+		std::string str = NumberFormatter::format(_val);
+		Poco::UnicodeConverter::convert(str, val);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const Int16& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return std::numeric_limits<Int16>::is_integer;
+	}
+
+	bool isSigned() const
+	{
+		return std::numeric_limits<Int16>::is_signed;
+	}
+
+	bool isNumeric() const
+	{
+		return std::numeric_limits<Int16>::is_specialized;
+	}
+
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	Int16 _val;
+};
+
+
+template <>
+class VarHolderImpl<Int32>: public VarHolder
+{
+public:
+	VarHolderImpl(Int32 val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(Int32);
+	}
+
+	void convert(Int8& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+
+	void convert(Int16& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+	
+	void convert(Int32& val) const
+	{
+		val = _val;
+	}
+
+	void convert(Int64& val) const
+	{
+		val = _val;
+	}
+
+	void convert(UInt8& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+	void convert(UInt16& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+	
+	void convert(UInt32& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+	void convert(UInt64& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	void convert(long long& val) const
+	{
+		val = _val;
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+#endif
+
+	void convert(bool& val) const
+	{
+		val = (_val != 0);
+	}
+
+	void convert(float& val) const
+	{
+		val = static_cast<float>(_val);
+	}
+
+	void convert(double& val) const
+	{
+		val = static_cast<double>(_val);
+	}
+
+	void convert(char& val) const
+	{
+		UInt8 tmp;
+		convert(tmp);
+		val = static_cast<char>(tmp);
+	}
+
+	void convert(std::string& val) const
+	{
+		val = NumberFormatter::format(_val);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const Int32& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return std::numeric_limits<Int32>::is_integer;
+	}
+
+	bool isSigned() const
+	{
+		return std::numeric_limits<Int32>::is_signed;
+	}
+
+	bool isNumeric() const
+	{
+		return std::numeric_limits<Int32>::is_specialized;
+	}
+
+	bool isBoolean() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	Int32 _val;
+};
+
+
+template <>
+class VarHolderImpl<Int64>: public VarHolder
+{
+public:
+	VarHolderImpl(Int64 val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(Int64);
+	}
+
+	void convert(Int8& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+
+	void convert(Int16& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+	
+	void convert(Int32& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+
+	void convert(Int64& val) const
+	{
+		val = _val;
+	}
+
+	void convert(UInt8& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+	void convert(UInt16& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+	
+	void convert(UInt32& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+	void convert(UInt64& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	void convert(long long& val) const
+	{
+		val = _val;
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+#endif
+
+	void convert(bool& val) const
+	{
+		val = (_val != 0);
+	}
+
+	void convert(float& val) const
+	{
+		val = static_cast<float>(_val);
+	}
+
+	void convert(double& val) const
+	{
+		val = static_cast<double>(_val);
+	}
+
+	void convert(char& val) const
+	{
+		UInt8 tmp;
+		convert(tmp);
+		val = static_cast<char>(tmp);
+	}
+
+	void convert(std::string& val) const
+	{
+		val = NumberFormatter::format(_val);
+	}
+
+	void convert(DateTime& dt) const
+	{
+		dt = Timestamp(_val);
+	}
+
+	void convert(LocalDateTime& ldt) const
+	{
+		ldt = Timestamp(_val);
+	}
+
+	void convert(Timestamp& val) const
+	{
+		val = Timestamp(_val);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const Int64& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return std::numeric_limits<Int64>::is_integer;
+	}
+
+	bool isSigned() const
+	{
+		return std::numeric_limits<Int64>::is_signed;
+	}
+
+	bool isNumeric() const
+	{
+		return std::numeric_limits<Int64>::is_specialized;
+	}
+
+	bool isBoolean() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	Int64 _val;
+};
+
+
+template <>
+class VarHolderImpl<UInt8>: public VarHolder
+{
+public:
+	VarHolderImpl(UInt8 val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+	
+	const std::type_info& type() const
+	{
+		return typeid(UInt8);
+	}
+
+	void convert(Int8& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(Int16& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+	
+	void convert(Int32& val) const
+	{
+		val = static_cast<Int32>(_val);
+	}
+
+	void convert(Int64& val) const
+	{
+		val = static_cast<Int64>(_val);
+	}
+
+	void convert(UInt8& val) const
+	{
+		val = _val;
+	}
+
+	void convert(UInt16& val) const
+	{
+		val = _val;
+	}
+	
+	void convert(UInt32& val) const
+	{
+		val = _val;
+	}
+
+	void convert(UInt64& val) const
+	{
+		val = _val;
+	}
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	void convert(long long& val) const
+	{
+		val = static_cast<long long>(_val);
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		val = _val;
+	}
+
+#endif
+
+	void convert(bool& val) const
+	{
+		val = (_val != 0);
+	}
+
+	void convert(float& val) const
+	{
+		val = static_cast<float>(_val);
+	}
+
+	void convert(double& val) const
+	{
+		val = static_cast<double>(_val);
+	}
+
+	void convert(char& val) const
+	{
+		UInt8 tmp;
+		convert(tmp);
+		val = static_cast<char>(tmp);
+	}
+
+	void convert(std::string& val) const
+	{
+		val = NumberFormatter::format(_val);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const UInt8& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return std::numeric_limits<UInt8>::is_integer;
+	}
+
+	bool isSigned() const
+	{
+		return std::numeric_limits<UInt8>::is_signed;
+	}
+
+	bool isNumeric() const
+	{
+		return std::numeric_limits<UInt8>::is_specialized;
+	}
+
+	bool isBoolean() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	UInt8 _val;
+};
+
+
+template <>
+class VarHolderImpl<UInt16>: public VarHolder
+{
+public:
+	VarHolderImpl(UInt16 val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(UInt16);
+	}
+
+	void convert(Int8& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(Int16& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+	
+	void convert(Int32& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(Int64& val) const
+	{
+		val = static_cast<Int64>(_val);
+	}
+
+	void convert(UInt8& val) const
+	{
+		convertToSmallerUnsigned(_val, val);
+	}
+
+	void convert(UInt16& val) const
+	{
+		val = _val;
+	}
+	
+	void convert(UInt32& val) const
+	{
+		val = _val;
+	}
+
+	void convert(UInt64& val) const
+	{
+		val = _val;
+	}
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	void convert(long long& val) const
+	{
+		val = static_cast<long long>(_val);
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		val = _val;
+	}
+
+#endif
+
+	void convert(bool& val) const
+	{
+		val = (_val != 0);
+	}
+
+	void convert(float& val) const
+	{
+		val = static_cast<float>(_val);
+	}
+
+	void convert(double& val) const
+	{
+		val = static_cast<double>(_val);
+	}
+
+	void convert(char& val) const
+	{
+		UInt8 tmp;
+		convert(tmp);
+		val = static_cast<char>(tmp);
+	}
+
+	void convert(std::string& val) const
+	{
+		val = NumberFormatter::format(_val);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const UInt16& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return std::numeric_limits<UInt16>::is_integer;
+	}
+
+	bool isSigned() const
+	{
+		return std::numeric_limits<UInt16>::is_signed;
+	}
+
+	bool isNumeric() const
+	{
+		return std::numeric_limits<UInt16>::is_specialized;
+	}
+
+	bool isBoolean() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	UInt16 _val;
+};
+
+
+template <>
+class VarHolderImpl<UInt32>: public VarHolder
+{
+public:
+	VarHolderImpl(UInt32 val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(UInt32);
+	}
+
+	void convert(Int8& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(Int16& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+	
+	void convert(Int32& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(Int64& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(UInt8& val) const
+	{
+		convertToSmallerUnsigned(_val, val);
+	}
+
+	void convert(UInt16& val) const
+	{
+		convertToSmallerUnsigned(_val, val);
+	}
+	
+	void convert(UInt32& val) const
+	{
+		val = _val;
+	}
+
+	void convert(UInt64& val) const
+	{
+		val = _val;
+	}
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	void convert(long long& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		val = _val;
+	}
+
+#endif
+
+	void convert(bool& val) const
+	{
+		val = (_val != 0);
+	}
+
+	void convert(float& val) const
+	{
+		val = static_cast<float>(_val);
+	}
+
+	void convert(double& val) const
+	{
+		val = static_cast<double>(_val);
+	}
+
+	void convert(char& val) const
+	{
+		UInt8 tmp;
+		convert(tmp);
+		val = static_cast<char>(tmp);
+	}
+
+	void convert(std::string& val) const
+	{
+		val = NumberFormatter::format(_val);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const UInt32& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return std::numeric_limits<UInt32>::is_integer;
+	}
+
+	bool isSigned() const
+	{
+		return std::numeric_limits<UInt32>::is_signed;
+	}
+
+	bool isNumeric() const
+	{
+		return std::numeric_limits<UInt32>::is_specialized;
+	}
+
+	bool isBoolean() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	UInt32 _val;
+};
+
+
+template <>
+class VarHolderImpl<UInt64>: public VarHolder
+{
+public:
+	VarHolderImpl(UInt64 val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(UInt64);
+	}
+
+	void convert(Int8& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(Int16& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+	
+	void convert(Int32& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(Int64& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(UInt8& val) const
+	{
+		convertToSmallerUnsigned(_val, val);
+	}
+
+	void convert(UInt16& val) const
+	{
+		convertToSmallerUnsigned(_val, val);
+	}
+	
+	void convert(UInt32& val) const
+	{
+		convertToSmallerUnsigned(_val, val);
+	}
+
+	void convert(UInt64& val) const
+	{
+		val = _val;
+	}
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	void convert(long long& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		val = _val;
+	}
+
+#endif
+
+	void convert(bool& val) const
+	{
+		val = (_val != 0);
+	}
+
+	void convert(float& val) const
+	{
+		val = static_cast<float>(_val);
+	}
+
+	void convert(double& val) const
+	{
+		val = static_cast<double>(_val);
+	}
+
+	void convert(char& val) const
+	{
+		UInt8 tmp;
+		convert(tmp);
+		val = static_cast<char>(tmp);
+	}
+
+	void convert(std::string& val) const
+	{
+		val = NumberFormatter::format(_val);
+	}
+
+	void convert(DateTime& dt) const
+	{
+		Int64 val;
+		convertUnsignedToSigned(_val, val);
+		dt = Timestamp(val);
+	}
+
+	void convert(LocalDateTime& ldt) const
+	{
+		Int64 val;
+		convertUnsignedToSigned(_val, val);
+		ldt = Timestamp(val);
+	}
+
+	void convert(Timestamp& val) const
+	{
+		Int64 tmp;
+		convertUnsignedToSigned(_val, tmp);
+		val = Timestamp(tmp);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const UInt64& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return std::numeric_limits<UInt64>::is_integer;
+	}
+
+	bool isSigned() const
+	{
+		return std::numeric_limits<UInt64>::is_signed;
+	}
+
+	bool isNumeric() const
+	{
+		return std::numeric_limits<UInt64>::is_specialized;
+	}
+
+	bool isBoolean() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	UInt64 _val;
+};
+
+
+template <>
+class VarHolderImpl<bool>: public VarHolder
+{
+public:
+	VarHolderImpl(bool val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(bool);
+	}
+
+	void convert(Int8& val) const
+	{
+		val = static_cast<Int8>(_val ? 1 : 0);
+	}
+
+	void convert(Int16& val) const
+	{
+		val = static_cast<Int16>(_val ? 1 : 0);
+	}
+	
+	void convert(Int32& val) const
+	{
+		val = static_cast<Int32>(_val ? 1 : 0);
+	}
+
+	void convert(Int64& val) const
+	{
+		val = static_cast<Int64>(_val ? 1 : 0);
+	}
+
+	void convert(UInt8& val) const
+	{
+		val = static_cast<UInt8>(_val ? 1 : 0);
+	}
+
+	void convert(UInt16& val) const
+	{
+		val = static_cast<UInt16>(_val ? 1 : 0);
+	}
+	
+	void convert(UInt32& val) const
+	{
+		val = static_cast<UInt32>(_val ? 1 : 0);
+	}
+
+	void convert(UInt64& val) const
+	{
+		val = static_cast<UInt64>(_val ? 1 : 0);
+	}
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	void convert(long long& val) const
+	{
+		val = static_cast<long long>(_val ? 1 : 0);
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		val = static_cast<unsigned long long>(_val ? 1 : 0);
+	}
+
+#endif
+
+	void convert(bool& val) const
+	{
+		val = _val;
+	}
+
+	void convert(float& val) const
+	{
+		val = (_val ? 1.0f : 0.0f);
+	}
+
+	void convert(double& val) const
+	{
+		val = (_val ? 1.0 : 0.0);
+	}
+
+	void convert(char& val) const
+	{
+		val = static_cast<char>(_val ? 1 : 0);
+	}
+
+	void convert(std::string& val) const
+	{
+		val = (_val ? "true" : "false");
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const bool& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return std::numeric_limits<bool>::is_integer;
+	}
+
+	bool isSigned() const
+	{
+		return std::numeric_limits<bool>::is_signed;
+	}
+
+	bool isNumeric() const
+	{
+		return std::numeric_limits<bool>::is_specialized;
+	}
+
+	bool isBoolean() const
+	{
+		return true;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	bool _val;
+};
+
+
+template <>
+class VarHolderImpl<float>: public VarHolder
+{
+public:
+	VarHolderImpl(float val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(float);
+	}
+
+	void convert(Int8& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+
+	void convert(Int16& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+	
+	void convert(Int32& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+
+	void convert(Int64& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+
+	void convert(UInt8& val) const
+	{
+		convertSignedFloatToUnsigned(_val, val);
+	}
+
+	void convert(UInt16& val) const
+	{
+		convertSignedFloatToUnsigned(_val, val);
+	}
+	
+	void convert(UInt32& val) const
+	{
+		convertSignedFloatToUnsigned(_val, val);
+	}
+
+	void convert(UInt64& val) const
+	{
+		convertSignedFloatToUnsigned(_val, val);
+	}
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	void convert(long long& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		convertSignedFloatToUnsigned(_val, val);
+	}
+
+#endif
+
+	void convert(bool& val) const
+	{
+		val = !(_val <= std::numeric_limits<float>::min() && 
+			_val >= -1 * std::numeric_limits<float>::min());
+	}
+
+	void convert(float& val) const
+	{
+		val = _val;
+	}
+
+	void convert(double& val) const
+	{
+		val = _val;
+	}
+
+	void convert(char& val) const
+	{
+		UInt8 tmp;
+		convert(tmp);
+		val = static_cast<char>(tmp);
+	}
+
+	void convert(std::string& val) const
+	{
+		val = NumberFormatter::format(_val);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const float& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return std::numeric_limits<float>::is_integer;
+	}
+
+	bool isSigned() const
+	{
+		return std::numeric_limits<float>::is_signed;
+	}
+
+	bool isNumeric() const
+	{
+		return std::numeric_limits<float>::is_specialized;
+	}
+
+	bool isBoolean() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	float _val;
+};
+
+
+template <>
+class VarHolderImpl<double>: public VarHolder
+{
+public:
+	VarHolderImpl(double val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(double);
+	}
+
+	void convert(Int8& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+
+	void convert(Int16& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+	
+	void convert(Int32& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+
+	void convert(Int64& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+
+	void convert(UInt8& val) const
+	{
+		convertSignedFloatToUnsigned(_val, val);
+	}
+
+	void convert(UInt16& val) const
+	{
+		convertSignedFloatToUnsigned(_val, val);
+	}
+	
+	void convert(UInt32& val) const
+	{
+		convertSignedFloatToUnsigned(_val, val);
+	}
+
+	void convert(UInt64& val) const
+	{
+		convertSignedFloatToUnsigned(_val, val);
+	}
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	void convert(long long& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		convertSignedFloatToUnsigned(_val, val);
+	}
+
+#endif
+
+	void convert(bool& val) const
+	{
+		val = !(_val <= std::numeric_limits<double>::min() && 
+			_val >= -1 * std::numeric_limits<double>::min());
+	}
+
+	void convert(float& val) const
+	{
+		double fMin = -1 * std::numeric_limits<float>::max();
+		double fMax = std::numeric_limits<float>::max();
+
+		if (_val < fMin) throw RangeException("Value too small.");
+		if (_val > fMax) throw RangeException("Value too large.");
+
+		val = static_cast<float>(_val);
+	}
+
+	void convert(double& val) const
+	{
+		val = _val;
+	}
+
+	void convert(char& val) const
+	{
+		UInt8 tmp;
+		convert(tmp);
+		val = static_cast<char>(tmp);
+	}
+
+	void convert(std::string& val) const
+	{
+		val = NumberFormatter::format(_val);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const double& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return std::numeric_limits<double>::is_integer;
+	}
+
+	bool isSigned() const
+	{
+		return std::numeric_limits<double>::is_signed;
+	}
+
+	bool isNumeric() const
+	{
+		return std::numeric_limits<double>::is_specialized;
+	}
+
+	bool isBoolean() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	double _val;
+};
+
+
+template <>
+class VarHolderImpl<char>: public VarHolder
+{
+public:
+	VarHolderImpl(char val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(char);
+	}
+
+	void convert(Int8& val) const
+	{
+		val = static_cast<Int8>(_val);
+	}
+
+	void convert(Int16& val) const
+	{
+		val = static_cast<UInt8>(_val);
+	}
+	
+	void convert(Int32& val) const
+	{
+		val = static_cast<UInt8>(_val);
+	}
+
+	void convert(Int64& val) const
+	{
+		val = static_cast<UInt8>(_val);
+	}
+
+	void convert(UInt8& val) const
+	{
+		val = static_cast<UInt8>(_val);
+	}
+
+	void convert(UInt16& val) const
+	{
+		val = static_cast<UInt8>(_val);
+	}
+	
+	void convert(UInt32& val) const
+	{
+		val = static_cast<UInt8>(_val);
+	}
+
+	void convert(UInt64& val) const
+	{
+		val = static_cast<UInt8>(_val);
+	}
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	void convert(long long& val) const
+	{
+		val = static_cast<long long>(_val);
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		val = static_cast<unsigned long long>(_val);
+	}
+
+#endif
+
+	void convert(bool& val) const
+	{
+		val = (_val != '\0');
+	}
+
+	void convert(float& val) const
+	{
+		val = static_cast<float>(_val);
+	}
+
+	void convert(double& val) const
+	{
+		val = static_cast<double>(_val);
+	}
+
+	void convert(char& val) const
+	{
+		val = _val;
+	}
+
+	void convert(std::string& val) const
+	{
+		val = std::string(1, _val);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const char& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return std::numeric_limits<char>::is_integer;
+	}
+
+	bool isSigned() const
+	{
+		return std::numeric_limits<char>::is_signed;
+	}
+
+	bool isNumeric() const
+	{
+		return std::numeric_limits<char>::is_specialized;
+	}
+
+	bool isBoolean() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	char _val;
+};
+
+
+template <>
+class VarHolderImpl<std::string>: public VarHolder
+{
+public:
+	VarHolderImpl(const char* pVal): _val(pVal)
+	{
+	}
+
+	VarHolderImpl(const std::string& val) : _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(std::string);
+	}
+
+	void convert(Int8& val) const
+	{
+		int v = NumberParser::parse(_val);
+		convertToSmaller(v, val);
+	}
+
+	void convert(Int16& val) const
+	{
+		int v = NumberParser::parse(_val);
+		convertToSmaller(v, val);
+	}
+	
+	void convert(Int32& val) const
+	{
+		val = NumberParser::parse(_val);
+	}
+
+	void convert(Int64& val) const
+	{
+		val = NumberParser::parse64(_val);
+	}
+
+	void convert(UInt8& val) const
+	{
+		unsigned int v = NumberParser::parseUnsigned(_val);
+		convertToSmallerUnsigned(v, val);
+	}
+
+	void convert(UInt16& val) const
+	{
+		unsigned int v = NumberParser::parseUnsigned(_val);
+		convertToSmallerUnsigned(v, val);
+	}
+	
+	void convert(UInt32& val) const
+	{
+		val = NumberParser::parseUnsigned(_val);
+	}
+
+	void convert(UInt64& val) const
+	{
+		val = NumberParser::parseUnsigned64(_val);
+	}
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	void convert(long long& val) const
+	{
+		val = NumberParser::parse64(_val);
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		val = NumberParser::parseUnsigned64(_val);
+	}
+
+#endif
+
+	void convert(bool& val) const
+	{
+		if (_val.empty())
+		{
+			val = false;
+			return;
+		}
+
+		static const std::string VAL_FALSE("false");
+		static const std::string VAL_INT_FALSE("0");
+		val = (_val != VAL_INT_FALSE &&
+			(icompare(_val, VAL_FALSE) != 0));
+	}
+
+	void convert(float& val) const
+	{
+		double v = NumberParser::parseFloat(_val);
+		convertToSmaller(v, val);
+	}
+
+	void convert(double& val) const
+	{
+		val = NumberParser::parseFloat(_val);
+	}
+
+	void convert(char& val) const
+	{
+		if (_val.empty())
+			val = '\0';
+		else
+			val = _val[0];
+	}
+
+	void convert(std::string& val) const
+	{
+		val = _val;
+	}
+
+	void convert(Poco::UTF16String& val) const
+	{
+		Poco::UnicodeConverter::convert(_val, val);
+	}
+
+	void convert(DateTime& val) const
+	{
+		int tzd = 0;
+		if (!DateTimeParser::tryParse(DateTimeFormat::ISO8601_FORMAT, _val, val, tzd))
+			throw BadCastException("string -> DateTime");
+	}
+
+	void convert(LocalDateTime& ldt) const
+	{
+		int tzd = 0;
+		DateTime tmp;
+		if (!DateTimeParser::tryParse(DateTimeFormat::ISO8601_FORMAT, _val, tmp, tzd))
+			throw BadCastException("string -> LocalDateTime");
+
+		ldt = LocalDateTime(tzd, tmp, false);
+	}
+
+	void convert(Timestamp& ts) const
+	{
+		int tzd = 0;
+		DateTime tmp;
+		if (!DateTimeParser::tryParse(DateTimeFormat::ISO8601_FORMAT, _val, tmp, tzd))
+			throw BadCastException("string -> Timestamp");
+
+		ts = tmp.timestamp();
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const std:: string& value() const
+	{
+		return _val;
+	}
+
+	bool isString() const
+	{
+		return true;
+	}
+
+	std::size_t size() const
+	{
+		return _val.length();
+	}
+
+	char& operator[](std::string::size_type n)
+	{
+		if (n < size()) return _val.operator[](n);
+
+		throw RangeException("String index out of range");
+	}
+
+	const char& operator[](std::string::size_type n) const
+	{
+		if (n < size()) return _val.operator[](n);
+
+		throw RangeException("String index out of range");
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	std::string _val;
+};
+
+
+template <>
+class VarHolderImpl<UTF16String>: public VarHolder
+{
+public:
+	VarHolderImpl(const char* pVal) : _val(Poco::UnicodeConverter::to<UTF16String>(pVal))
+	{
+	}
+
+	VarHolderImpl(const Poco::UTF16String& val) : _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(Poco::UTF16String);
+	}
+
+	void convert(Int8& val) const
+	{
+		int v = NumberParser::parse(toStdString());
+		convertToSmaller(v, val);
+	}
+
+	void convert(Int16& val) const
+	{
+		int v = NumberParser::parse(toStdString());
+		convertToSmaller(v, val);
+	}
+
+	void convert(Int32& val) const
+	{
+		val = NumberParser::parse(toStdString());
+	}
+
+	void convert(Int64& val) const
+	{
+		val = NumberParser::parse64(toStdString());
+	}
+
+	void convert(UInt8& val) const
+	{
+		unsigned int v = NumberParser::parseUnsigned(toStdString());
+		convertToSmallerUnsigned(v, val);
+	}
+
+	void convert(UInt16& val) const
+	{
+		unsigned int v = NumberParser::parseUnsigned(toStdString());
+		convertToSmallerUnsigned(v, val);
+	}
+
+	void convert(UInt32& val) const
+	{
+		val = NumberParser::parseUnsigned(toStdString());
+	}
+
+	void convert(UInt64& val) const
+	{
+		val = NumberParser::parseUnsigned64(toStdString());
+	}
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	void convert(long long& val) const
+	{
+		val = NumberParser::parse64(toStdString());
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		val = NumberParser::parseUnsigned64(toStdString());
+	}
+
+#endif
+
+	void convert(bool& val) const
+	{
+		static const std::string VAL_FALSE("false");
+		static const std::string VAL_INT_FALSE("0");
+
+		if (_val.empty()) val = false;
+
+		std::string str;
+		UnicodeConverter::convert(_val, str);
+		val = (str != VAL_INT_FALSE &&
+			(icompare(str, VAL_FALSE) != 0));
+	}
+
+	void convert(float& val) const
+	{
+		double v = NumberParser::parseFloat(toStdString());
+		convertToSmaller(v, val);
+	}
+
+	void convert(double& val) const
+	{
+		val = NumberParser::parseFloat(toStdString());
+	}
+
+	void convert(char& val) const
+	{
+		if (_val.empty())
+			val = '\0';
+		else
+		{
+			std::string s;
+			UnicodeConverter::convert(_val, s);
+			val = s[0];
+		}
+	}
+
+	void convert(Poco::UTF16String& val) const
+	{
+		val = _val;
+	}
+
+	void convert(std::string& val) const
+	{
+		UnicodeConverter::convert(_val, val);
+	}
+
+	void convert(DateTime& val) const
+	{
+		int tzd = 0;
+		if (!DateTimeParser::tryParse(DateTimeFormat::ISO8601_FORMAT, toStdString(), val, tzd))
+			throw BadCastException("string -> DateTime");
+	}
+
+	void convert(LocalDateTime& ldt) const
+	{
+		int tzd = 0;
+		DateTime tmp;
+		if (!DateTimeParser::tryParse(DateTimeFormat::ISO8601_FORMAT, toStdString(), tmp, tzd))
+			throw BadCastException("string -> LocalDateTime");
+
+		ldt = LocalDateTime(tzd, tmp, false);
+	}
+
+	void convert(Timestamp& ts) const
+	{
+		int tzd = 0;
+		DateTime tmp;
+		if (!DateTimeParser::tryParse(DateTimeFormat::ISO8601_FORMAT, toStdString(), tmp, tzd))
+			throw BadCastException("string -> Timestamp");
+
+		ts = tmp.timestamp();
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const Poco::UTF16String& value() const
+	{
+		return _val;
+	}
+
+	bool isString() const
+	{
+		return true;
+	}
+
+	std::size_t size() const
+	{
+		return _val.length();
+	}
+
+	UTF16Char& operator[](Poco::UTF16String::size_type n)
+	{
+		if (n < size()) return _val.operator[](n);
+
+		throw RangeException("String index out of range");
+	}
+
+	const UTF16Char& operator[](Poco::UTF16String::size_type n) const
+	{
+		if (n < size()) return _val.operator[](n);
+
+		throw RangeException("String index out of range");
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	std::string toStdString() const
+	{
+		std::string str;
+		UnicodeConverter::convert(_val, str);
+		return str;
+	}
+
+	Poco::UTF16String _val;
+};
+
+
+#ifndef POCO_LONG_IS_64_BIT
+
+
+template <>
+class VarHolderImpl<long>: public VarHolder
+{
+public:
+	VarHolderImpl(long val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(long);
+	}
+
+	void convert(Int8& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+
+	void convert(Int16& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+	
+	void convert(Int32& val) const
+	{
+		val = static_cast<Int32>(_val);
+	}
+
+	void convert(Int64& val) const
+	{
+		val = static_cast<Int64>(_val);
+	}
+
+	void convert(UInt8& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+	void convert(UInt16& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+	
+	void convert(UInt32& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+	void convert(UInt64& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+	void convert(bool& val) const
+	{
+		val = (_val != 0);
+	}
+
+	void convert(float& val) const
+	{
+		val = static_cast<float>(_val);
+	}
+
+	void convert(double& val) const
+	{
+		val = static_cast<double>(_val);
+	}
+
+	void convert(char& val) const
+	{
+		UInt8 tmp;
+		convert(tmp);
+		val = static_cast<char>(tmp);
+	}
+
+	void convert(std::string& val) const
+	{
+		val = NumberFormatter::format(_val);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const long& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return std::numeric_limits<long>::is_integer;
+	}
+
+	bool isSigned() const
+	{
+		return std::numeric_limits<long>::is_signed;
+	}
+
+	bool isNumeric() const
+	{
+		return std::numeric_limits<long>::is_specialized;
+	}
+
+	bool isBoolean() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	long _val;
+};
+
+
+template <>
+class VarHolderImpl<unsigned long>: public VarHolder
+{
+public:
+	VarHolderImpl(unsigned long val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(unsigned long);
+	}
+
+	void convert(Int8& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(Int16& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+	
+	void convert(Int32& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(Int64& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(UInt8& val) const
+	{
+		convertToSmallerUnsigned(_val, val);
+	}
+
+	void convert(UInt16& val) const
+	{
+		convertToSmallerUnsigned(_val, val);
+	}
+	
+	void convert(UInt32& val) const
+	{
+		convertToSmallerUnsigned(_val, val);
+	}
+
+	void convert(UInt64& val) const
+	{
+		val = static_cast<UInt64>(_val);
+	}
+
+	void convert(bool& val) const
+	{
+		val = (_val != 0);
+	}
+
+	void convert(float& val) const
+	{
+		val = static_cast<float>(_val);
+	}
+
+	void convert(double& val) const
+	{
+		val = static_cast<double>(_val);
+	}
+
+	void convert(char& val) const
+	{
+		UInt8 tmp;
+		convert(tmp);
+		val = static_cast<char>(tmp);
+	}
+
+	void convert(std::string& val) const
+	{
+		val = NumberFormatter::format(_val);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const unsigned long& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return std::numeric_limits<unsigned long>::is_integer;
+	}
+
+	bool isSigned() const
+	{
+		return std::numeric_limits<unsigned long>::is_signed;
+	}
+
+	bool isNumeric() const
+	{
+		return std::numeric_limits<unsigned long>::is_specialized;
+	}
+
+	bool isBoolean() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	unsigned long _val;
+};
+
+
+#else // if defined (POCO_LONG_IS_64_BIT)
+
+
+template <>
+class VarHolderImpl<long long>: public VarHolder
+{
+public:
+	VarHolderImpl(long long val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(long long);
+	}
+
+	void convert(Int8& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+
+	void convert(Int16& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+
+	void convert(Int32& val) const
+	{
+		convertToSmaller(_val, val);
+	}
+
+	void convert(Int64& val) const
+	{
+		val = static_cast<Int64>(_val);
+	}
+
+	void convert(UInt8& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+	void convert(UInt16& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+	void convert(UInt32& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+	void convert(UInt64& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+	void convert(long long& val) const
+	{
+		val = _val;
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		convertSignedToUnsigned(_val, val);
+	}
+
+	void convert(bool& val) const
+	{
+		val = (_val != 0);
+	}
+
+	void convert(float& val) const
+	{
+		val = static_cast<float>(_val);
+	}
+
+	void convert(double& val) const
+	{
+		val = static_cast<double>(_val);
+	}
+
+	void convert(char& val) const
+	{
+		UInt8 tmp;
+		convert(tmp);
+		val = static_cast<char>(tmp);
+	}
+
+	void convert(std::string& val) const
+	{
+		val = NumberFormatter::format(_val);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const long long& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return std::numeric_limits<long long>::is_integer;
+	}
+
+	bool isSigned() const
+	{
+		return std::numeric_limits<long long>::is_signed;
+	}
+
+	bool isNumeric() const
+	{
+		return std::numeric_limits<long long>::is_specialized;
+	}
+
+	bool isBoolean() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	long long _val;
+};
+
+
+template <>
+class VarHolderImpl<unsigned long long>: public VarHolder
+{
+public:
+	VarHolderImpl(unsigned long long val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(unsigned long long);
+	}
+
+	void convert(Int8& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(Int16& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(Int32& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(Int64& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(UInt8& val) const
+	{
+		convertToSmallerUnsigned(_val, val);
+	}
+
+	void convert(UInt16& val) const
+	{
+		convertToSmallerUnsigned(_val, val);
+	}
+
+	void convert(UInt32& val) const
+	{
+		convertToSmallerUnsigned(_val, val);
+	}
+
+	void convert(UInt64& val) const
+	{
+		val = static_cast<UInt64>(_val);
+	}
+
+	void convert(long long& val) const
+	{
+		convertUnsignedToSigned(_val, val);
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		val = _val;
+	}
+
+	void convert(bool& val) const
+	{
+		val = (_val != 0);
+	}
+
+	void convert(float& val) const
+	{
+		val = static_cast<float>(_val);
+	}
+
+	void convert(double& val) const
+	{
+		val = static_cast<double>(_val);
+	}
+
+	void convert(char& val) const
+	{
+		UInt8 tmp;
+		convert(tmp);
+		val = static_cast<char>(tmp);
+	}
+
+	void convert(std::string& val) const
+	{
+		val = NumberFormatter::format(_val);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const unsigned long long& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return std::numeric_limits<unsigned long long>::is_integer;
+	}
+
+	bool isSigned() const
+	{
+		return std::numeric_limits<unsigned long long>::is_signed;
+	}
+
+	bool isNumeric() const
+	{
+		return std::numeric_limits<unsigned long long>::is_specialized;
+	}
+
+	bool isBoolean() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	unsigned long long _val;
+};
+
+
+#endif // 64bit
+
+
+template <typename T>
+class VarHolderImpl<std::vector<T> >: public VarHolder
+{
+public:
+	VarHolderImpl(const std::vector<T>& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+	
+	const std::type_info& type() const
+	{
+		return typeid(std::vector<T>);
+	}
+
+	void convert(std::string& val) const
+	{
+		Impl::containerToJSON(_val, val);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+	
+	const std::vector<T>& value() const
+	{
+		return _val;
+	}
+
+	bool isVector() const
+	{
+		return true;
+	}
+
+	std::size_t size() const
+	{
+		return _val.size();
+	}
+
+	T& operator[](typename std::vector<T>::size_type n)
+	{
+		if (n < size()) return _val.operator[](n);
+
+		throw RangeException("List index out of range");
+	}
+
+	const T& operator[](typename std::vector<T>::size_type n) const
+	{
+		if (n < size()) return _val.operator[](n);
+
+		throw RangeException("List index out of range");
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	std::vector<T> _val;
+};
+
+
+template <typename T>
+class VarHolderImpl<std::list<T> >: public VarHolder
+{
+public:
+	VarHolderImpl(const std::list<T>& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+	
+	const std::type_info& type() const
+	{
+		return typeid(std::list<T>);
+	}
+
+	void convert(std::string& val) const
+	{
+		Impl::containerToJSON(_val, val);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+	
+	const std::list<T>& value() const
+	{
+		return _val;
+	}
+
+	bool isList() const
+	{
+		return true;
+	}
+
+	std::size_t size() const
+	{
+		return _val.size();
+	}
+
+	T& operator[](typename std::list<T>::size_type n)
+	{
+		if (n >= size())
+			throw RangeException("List index out of range");
+
+		typename std::list<T>::size_type counter = 0;
+		typename std::list<T>::iterator it = _val.begin();
+		for (; counter < n; ++counter) ++it;
+
+		return *it;
+	}
+
+	const T& operator[](typename std::list<T>::size_type n) const
+	{
+		if (n >= size())
+			throw RangeException("List index out of range");
+
+		typename std::list<T>::size_type counter = 0;
+		typename std::list<T>::const_iterator it = _val.begin();
+		for (; counter < n; ++counter) ++it;
+
+		return *it;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	std::list<T> _val;
+};
+
+
+template <typename T>
+class VarHolderImpl<std::deque<T> >: public VarHolder
+{
+public:
+	VarHolderImpl(const std::deque<T>& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+	
+	const std::type_info& type() const
+	{
+		return typeid(std::deque<T>);
+	}
+
+	void convert(std::string& val) const
+	{
+		Impl::containerToJSON(_val, val);
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+	
+	const std::deque<T>& value() const
+	{
+		return _val;
+	}
+
+	bool isDeque() const
+	{
+		return true;
+	}
+
+	std::size_t size() const
+	{
+		return _val.size();
+	}
+
+	T& operator[](typename std::deque<T>::size_type n)
+	{
+		if (n < size()) return _val.operator[](n);
+
+		throw RangeException("List index out of range");
+	}
+
+	const T& operator[](typename std::deque<T>::size_type n) const
+	{
+		if (n < size()) return _val.operator[](n);
+
+		throw RangeException("List index out of range");
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	std::deque<T> _val;
+};
+
+
+template <>
+class VarHolderImpl<DateTime>: public VarHolder
+{
+public:
+	VarHolderImpl(const DateTime& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+	
+	const std::type_info& type() const
+	{
+		return typeid(DateTime);
+	}
+
+	void convert(Int8& /*val*/) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(Int16& /*val*/) const
+	{
+		throw BadCastException();
+	}
+	
+	void convert(Int32& /*val*/) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(Int64& val) const
+	{
+		val = _val.timestamp().epochMicroseconds();
+	}
+
+	void convert(UInt64& val) const
+	{
+		val = _val.timestamp().epochMicroseconds();
+	}
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	void convert(long long& val) const
+	{
+		val = _val.timestamp().epochMicroseconds();
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		val = _val.timestamp().epochMicroseconds();
+	}
+
+#endif
+
+	void convert(std::string& val) const
+	{
+		val = DateTimeFormatter::format(_val, Poco::DateTimeFormat::ISO8601_FORMAT);
+	}
+
+	void convert(DateTime& val) const
+	{
+		val = _val;
+	}
+
+	void convert(LocalDateTime& ldt) const
+	{
+		ldt = _val.timestamp();
+	}
+
+	void convert(Timestamp& ts) const
+	{
+		ts = _val.timestamp();
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+	
+	const DateTime& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return false;
+	}
+
+	bool isSigned() const
+	{
+		return false;
+	}
+
+	bool isNumeric() const
+	{
+		return false;
+	}
+
+	bool isBoolean() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+	bool isDate() const
+	{
+		return true;
+	}
+
+	bool isTime() const
+	{
+		return true;
+	}
+
+	bool isDateTime() const
+	{
+		return true;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	DateTime _val;
+};
+
+
+template <>
+class VarHolderImpl<LocalDateTime>: public VarHolder
+{
+public:
+	VarHolderImpl(const LocalDateTime& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+	
+	const std::type_info& type() const
+	{
+		return typeid(LocalDateTime);
+	}
+
+	void convert(Int64& val) const
+	{
+		val = _val.timestamp().epochMicroseconds();
+	}
+
+	void convert(UInt64& val) const
+	{
+		val = _val.timestamp().epochMicroseconds();
+	}
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	void convert(long long& val) const
+	{
+		val = _val.timestamp().epochMicroseconds();
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		val = _val.timestamp().epochMicroseconds();
+	}
+
+#endif
+
+	void convert(std::string& val) const
+	{
+		val = DateTimeFormatter::format(_val, Poco::DateTimeFormat::ISO8601_FORMAT);
+	}
+
+	void convert(DateTime& val) const
+	{
+		val = _val.timestamp();
+	}
+
+	void convert(LocalDateTime& ldt) const
+	{
+		ldt = _val;
+	}
+
+	void convert(Timestamp& ts) const
+	{
+		ts = _val.timestamp();
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+	
+	const LocalDateTime& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return false;
+	}
+
+	bool isSigned() const
+	{
+		return false;
+	}
+
+	bool isNumeric() const
+	{
+		return false;
+	}
+
+	bool isBoolean() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+	bool isDate() const
+	{
+		return true;
+	}
+
+	bool isTime() const
+	{
+		return true;
+	}
+
+	bool isDateTime() const
+	{
+		return true;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	LocalDateTime _val;
+};
+
+
+template <>
+class VarHolderImpl<Timestamp>: public VarHolder
+{
+public:
+	VarHolderImpl(const Timestamp& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+	
+	const std::type_info& type() const
+	{
+		return typeid(Timestamp);
+	}
+
+	void convert(Int64& val) const
+	{
+		val = _val.epochMicroseconds();
+	}
+
+	void convert(UInt64& val) const
+	{
+		val = _val.epochMicroseconds();
+	}
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	void convert(long long& val) const
+	{
+		val = _val.epochMicroseconds();
+	}
+
+	void convert(unsigned long long& val) const
+	{
+		val = _val.epochMicroseconds();
+	}
+
+#endif
+
+	void convert(std::string& val) const
+	{
+		val = DateTimeFormatter::format(_val, Poco::DateTimeFormat::ISO8601_FORMAT);
+	}
+
+	void convert(DateTime& val) const
+	{
+		val = _val;
+	}
+
+	void convert(LocalDateTime& ldt) const
+	{
+		ldt = _val;
+	}
+
+	void convert(Timestamp& ts) const
+	{
+		ts = _val;
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+	
+	const Timestamp& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isStruct() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return false;
+	}
+
+	bool isSigned() const
+	{
+		return false;
+	}
+
+	bool isNumeric() const
+	{
+		return false;
+	}
+
+	bool isBoolean() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+	bool isDate() const
+	{
+		return true;
+	}
+
+	bool isTime() const
+	{
+		return true;
+	}
+
+	bool isDateTime() const
+	{
+		return true;
+	}
+
+private:
+	VarHolderImpl();
+	VarHolderImpl(const VarHolderImpl&);
+	VarHolderImpl& operator = (const VarHolderImpl&);
+
+	Timestamp _val;
+};
+
+
+typedef std::vector<Var> Vector;
+typedef std::deque<Var>  Deque;
+typedef std::list<Var>   List;
+typedef Vector           Array;
+
+
+} } // namespace Poco::Dynamic
+
+
+#endif // Foundation_VarHolder_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Dynamic/VarIterator.h b/base/poco/Foundation/include/Poco/Dynamic/VarIterator.h
new file mode 100644
index 00000000000..a91bb3a6a2c
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Dynamic/VarIterator.h
@@ -0,0 +1,150 @@
+//
+// VarIterator.h
+//
+// Library: Foundation
+// Package: Dynamic
+// Module:  VarIterator
+//
+// Definition of the VarIterator class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_VarIterator_INCLUDED
+#define Foundation_VarIterator_INCLUDED
+
+
+#include "Poco/Exception.h"
+#include <iterator>
+#include <algorithm>
+
+
+namespace Poco {
+namespace Dynamic {
+
+
+class Var;
+
+
+class Foundation_API VarIterator
+	/// VarIterator class.
+{
+public:
+	typedef std::bidirectional_iterator_tag iterator_category;
+	typedef Var                             value_type;
+	typedef std::ptrdiff_t                  difference_type;
+	typedef Var*                            pointer;
+	typedef Var&                            reference;
+
+	static const std::size_t POSITION_END;
+		/// End position indicator.
+
+	VarIterator(Var* pVar, bool positionEnd);
+		/// Creates the VarIterator and positions it at the end of
+		/// the recordset if positionEnd is true. Otherwise, it is
+		/// positioned at the beginning.
+
+	VarIterator(const VarIterator& other);
+		/// Creates a copy of other VarIterator.
+
+	~VarIterator();
+		/// Destroys the VarIterator.
+
+	VarIterator& operator = (const VarIterator& other);
+		/// Assigns the other VarIterator.
+
+	bool operator == (const VarIterator& other) const;
+		/// Equality operator.
+
+	bool operator != (const VarIterator& other) const;
+		/// Inequality operator.
+
+	Var& operator * () const;
+		/// Returns value at the current position.
+
+	Var* operator -> () const;
+		/// Returns pointer to the value at current position.
+
+	const VarIterator& operator ++ () const;
+		/// Advances by one position and returns current position.
+
+	VarIterator operator ++ (int) const;
+		/// Advances by one position and returns copy of the iterator with 
+		/// previous current position.
+
+	const VarIterator& operator -- () const;
+		/// Goes back by one position and returns copy of the iterator with 
+		/// previous current position.
+
+	VarIterator operator -- (int) const;
+		/// Goes back by one position and returns previous current position.
+
+	VarIterator operator + (std::size_t diff) const;
+		/// Returns a copy the VarIterator advanced by diff positions.
+
+	VarIterator operator - (std::size_t diff) const;
+		/// Returns a copy the VarIterator backed by diff positions.
+		/// Throws RangeException if diff is larger than current position.
+
+	void swap(VarIterator& other);
+		/// Swaps the VarIterator with another one.
+
+private:
+	VarIterator();
+
+	void increment() const;
+		/// Increments the iterator position by one. 
+		/// Throws RangeException if position is out of range.
+
+	void decrement() const;
+		/// Decrements the iterator position by one. 
+		/// Throws RangeException if position is out of range.
+
+	void setPosition(std::size_t pos) const;
+		/// Sets the iterator position. 
+		/// Throws RangeException if position is out of range.
+
+	Var*                _pVar;
+	mutable std::size_t _position;
+
+	friend class Var;
+};
+
+
+///
+/// inlines
+///
+
+
+inline bool VarIterator::operator == (const VarIterator& other) const
+{
+	return _pVar == other._pVar && _position == other._position;
+}
+
+
+inline bool VarIterator::operator != (const VarIterator& other) const
+{
+	return _pVar != other._pVar || _position != other._position;
+}
+
+
+} } // namespace Poco::Dynamic
+
+
+namespace std
+{
+	template<>
+	inline void swap<Poco::Dynamic::VarIterator>(Poco::Dynamic::VarIterator& s1, 
+		Poco::Dynamic::VarIterator& s2)
+		/// Full template specialization of std:::swap for VarIterator
+	{
+		s1.swap(s2);
+	}
+}
+
+
+#endif // Foundation_VarIterator_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/DynamicAny.h b/base/poco/Foundation/include/Poco/DynamicAny.h
new file mode 100644
index 00000000000..214a2967924
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/DynamicAny.h
@@ -0,0 +1,24 @@
+//
+// DynamicAny.h
+//
+// Library: Foundation
+// Package: Dynamic
+// Module:  Var
+//
+// Forward header for Var class to maintain backward compatibility.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_DynamicAny_INCLUDED
+#define Foundation_DynamicAny_INCLUDED
+
+//@ deprecated
+#include "Poco/Dynamic/Var.h"
+
+
+#endif // Foundation_DynamicAny_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/DynamicAnyHolder.h b/base/poco/Foundation/include/Poco/DynamicAnyHolder.h
new file mode 100644
index 00000000000..4400af3ec9b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/DynamicAnyHolder.h
@@ -0,0 +1,24 @@
+//
+// DynamicAnyHolder.h
+//
+// Library: Foundation
+// Package: Dynamic
+// Module:  VarHolder
+//
+// Forward header for VarHolder class to maintain backward compatibility
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_DynamicAnyHolder_INCLUDED
+#define Foundation_DynamicAnyHolder_INCLUDED
+
+//@ deprecated
+#include "Poco/Dynamic/VarHolder.h"
+
+
+#endif // Foundation_DynamicAnyHolder_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/DynamicFactory.h b/base/poco/Foundation/include/Poco/DynamicFactory.h
new file mode 100644
index 00000000000..5f94204930f
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/DynamicFactory.h
@@ -0,0 +1,141 @@
+//
+// DynamicFactory.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  DynamicFactory
+//
+// Definition of the DynamicFactory class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_DynamicFactory_INCLUDED
+#define Foundation_DynamicFactory_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Instantiator.h"
+#include "Poco/Exception.h"
+#include "Poco/Mutex.h"
+#include <map>
+#include <memory>
+
+
+namespace Poco {
+
+
+template <class Base>
+class DynamicFactory
+	/// A factory that creates objects by class name.
+{
+public:
+	typedef AbstractInstantiator<Base> AbstractFactory;
+
+	DynamicFactory()
+		/// Creates the DynamicFactory.
+	{
+	}
+
+	~DynamicFactory()
+		/// Destroys the DynamicFactory and deletes the instantiators for 
+		/// all registered classes.
+	{
+		for (typename FactoryMap::iterator it = _map.begin(); it != _map.end(); ++it)
+		{
+			delete it->second;
+		}
+	}
+	
+	Base* createInstance(const std::string& className) const
+		/// Creates a new instance of the class with the given name.
+		/// The class must have been registered with registerClass.
+		/// If the class name is unknown, a NotFoundException is thrown.
+	{
+		FastMutex::ScopedLock lock(_mutex);
+
+		typename FactoryMap::const_iterator it = _map.find(className);
+		if (it != _map.end())
+			return it->second->createInstance();
+		else
+			throw NotFoundException(className);
+	}
+	
+	template <class C> 
+	void registerClass(const std::string& className)
+		/// Registers the instantiator for the given class with the DynamicFactory.
+		/// The DynamicFactory takes ownership of the instantiator and deletes
+		/// it when it's no longer used.
+		/// If the class has already been registered, an ExistsException is thrown
+		/// and the instantiator is deleted.
+	{
+		registerClass(className, new Instantiator<C, Base>);
+	}
+	
+	void registerClass(const std::string& className, AbstractFactory* pAbstractFactory)
+		/// Registers the instantiator for the given class with the DynamicFactory.
+		/// The DynamicFactory takes ownership of the instantiator and deletes
+		/// it when it's no longer used.
+		/// If the class has already been registered, an ExistsException is thrown
+		/// and the instantiator is deleted.
+	{
+		poco_check_ptr (pAbstractFactory);
+
+		FastMutex::ScopedLock lock(_mutex);
+
+#ifndef POCO_ENABLE_CPP11
+		std::auto_ptr<AbstractFactory> ptr(pAbstractFactory);
+#else
+		std::unique_ptr<AbstractFactory> ptr(pAbstractFactory);
+#endif // POCO_ENABLE_CPP11
+
+		typename FactoryMap::iterator it = _map.find(className);
+		if (it == _map.end())
+			_map[className] = ptr.release();
+		else
+			throw ExistsException(className);
+	}
+	
+	void unregisterClass(const std::string& className)
+		/// Unregisters the given class and deletes the instantiator
+		/// for the class.
+		/// Throws a NotFoundException if the class has not been registered.
+	{
+		FastMutex::ScopedLock lock(_mutex);
+
+		typename FactoryMap::iterator it = _map.find(className);
+		if (it != _map.end())
+		{
+			delete it->second;
+			_map.erase(it);
+		}
+		else throw NotFoundException(className);
+	}
+	
+	bool isClass(const std::string& className) const
+		/// Returns true iff the given class has been registered.
+	{
+		FastMutex::ScopedLock lock(_mutex);
+
+		return _map.find(className) != _map.end();
+	}
+
+private:
+	DynamicFactory(const DynamicFactory&);
+	DynamicFactory& operator = (const DynamicFactory&);
+
+	typedef std::map<std::string, AbstractFactory*> FactoryMap;
+	
+	FactoryMap _map;
+	mutable FastMutex _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_DynamicFactory_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/DynamicStruct.h b/base/poco/Foundation/include/Poco/DynamicStruct.h
new file mode 100644
index 00000000000..1f0fb56b759
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/DynamicStruct.h
@@ -0,0 +1,24 @@
+//
+// DynamicStruct.h
+//
+// Library: Foundation
+// Package: Dynamic
+// Module:  Struct
+//
+// Forward header for Struct class to maintain backward compatibility.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_DynamicStruct_INCLUDED
+#define Foundation_DynamicStruct_INCLUDED
+
+//@ deprecated
+#include "Poco/Dynamic/Struct.h"
+
+
+#endif // Foundation_DynamicStruct_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Environment.h b/base/poco/Foundation/include/Poco/Environment.h
new file mode 100644
index 00000000000..a422109129b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Environment.h
@@ -0,0 +1,123 @@
+//
+// Environment.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Environment
+//
+// Definition of the Environment class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Environment_INCLUDED
+#define Foundation_Environment_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Environment
+	/// This class provides access to environment variables
+	/// and some general system information.
+{
+public:
+	typedef UInt8 NodeId[6]; /// Ethernet address.
+
+	static std::string get(const std::string& name);
+		/// Returns the value of the environment variable
+		/// with the given name. Throws a NotFoundException
+		/// if the variable does not exist.
+
+	static std::string get(const std::string& name, const std::string& defaultValue);
+		/// Returns the value of the environment variable
+		/// with the given name. If the environment variable
+		/// is undefined, returns defaultValue instead.
+
+	static bool has(const std::string& name);
+		/// Returns true iff an environment variable
+		/// with the given name is defined.
+
+	static void set(const std::string& name, const std::string& value);
+		/// Sets the environment variable with the given name
+		/// to the given value.
+
+	static std::string osName();
+		/// Returns the operating system name.
+
+	static std::string osDisplayName();
+		/// Returns the operating system name in a
+		/// "user-friendly" way.
+		///
+		/// Currently this is only implemented for
+		/// Windows. There it will return names like
+		/// "Windows XP" or "Windows 7/Server 2008 SP2".
+		/// On other platforms, returns the same as
+		/// osName().
+
+	static std::string osVersion();
+		/// Returns the operating system version.
+
+	static std::string osArchitecture();
+		/// Returns the operating system architecture.
+
+	static std::string nodeName();
+		/// Returns the node (or host) name.
+
+	static void nodeId(NodeId& id);
+		/// Returns the Ethernet address of the first Ethernet
+		/// adapter found on the system.
+		///
+		/// Throws a SystemException if no Ethernet adapter is available.
+
+	static std::string nodeId();
+		/// Returns the Ethernet address (format "xx:xx:xx:xx:xx:xx")
+		/// of the first Ethernet adapter found on the system.
+		///
+		/// Throws a SystemException if no Ethernet adapter is available.
+
+	static unsigned processorCount();
+		/// Returns the number of processors installed in the system.
+		///
+		/// If the number of processors cannot be determined, returns 1.
+
+	static Poco::UInt32 libraryVersion();
+		/// Returns the POCO C++ Libraries version as a hexadecimal
+		/// number in format 0xAABBCCDD, where
+		///    - AA is the major version number,
+		///    - BB is the minor version number,
+		///    - CC is the revision number, and
+		///    - DD is the patch level number.
+		///
+		/// Some patch level ranges have special meanings:
+		///    - Dx mark development releases,
+		///    - Ax mark alpha releases, and
+		///    - Bx mark beta releases.
+
+	static Poco::Int32 os();
+		/// Return the operating system as defined
+		/// in the include Foundation/Platform.h (POCO_OS)
+
+	static Poco::Int32 arch();
+		/// Return the underlying cpu architecture that runs this operating system
+		/// as defined in Foundation/Platform (POCO_ARCH)
+
+	static bool isUnix();
+		/// Return true if the operating system belongs to the Linux family
+
+	static bool isWindows();
+		/// Return true if the operating system belongs to the Windows family
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Environment_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Environment_UNIX.h b/base/poco/Foundation/include/Poco/Environment_UNIX.h
new file mode 100644
index 00000000000..d6ae543ff9f
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Environment_UNIX.h
@@ -0,0 +1,56 @@
+//
+// Environment_UNIX.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Environment
+//
+// Definition of the EnvironmentImpl class for Unix.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Environment_UNIX_INCLUDED
+#define Foundation_Environment_UNIX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Mutex.h"
+#include <map>
+
+
+namespace Poco {
+
+
+class Foundation_API EnvironmentImpl
+{
+public:
+	typedef UInt8 NodeId[6]; /// Ethernet address.
+
+	static std::string getImpl(const std::string& name);	
+	static bool hasImpl(const std::string& name);	
+	static void setImpl(const std::string& name, const std::string& value);
+	static std::string osNameImpl();
+	static std::string osDisplayNameImpl();
+	static std::string osVersionImpl();
+	static std::string osArchitectureImpl();
+	static std::string nodeNameImpl();
+	static void nodeIdImpl(NodeId& id);
+	static unsigned processorCountImpl();
+
+private:
+	typedef std::map<std::string, std::string> StringMap;
+	
+	static StringMap _map;
+	static FastMutex _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Environment_UNIX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Environment_VX.h b/base/poco/Foundation/include/Poco/Environment_VX.h
new file mode 100644
index 00000000000..8eb178d03bf
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Environment_VX.h
@@ -0,0 +1,56 @@
+//
+// Environment_VX.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Environment
+//
+// Definition of the EnvironmentImpl class for VxWorks.
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Environment_VX_INCLUDED
+#define Foundation_Environment_VX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Mutex.h"
+#include <map>
+
+
+namespace Poco {
+
+
+class Foundation_API EnvironmentImpl
+{
+public:
+	typedef UInt8 NodeId[6]; /// Ethernet address.
+
+	static std::string getImpl(const std::string& name);	
+	static bool hasImpl(const std::string& name);	
+	static void setImpl(const std::string& name, const std::string& value);
+	static std::string osNameImpl();
+	static std::string osDisplayNameImpl();
+	static std::string osVersionImpl();
+	static std::string osArchitectureImpl();
+	static std::string nodeNameImpl();
+	static void nodeIdImpl(NodeId& id);
+	static unsigned processorCountImpl();
+
+private:
+	typedef std::map<std::string, std::string> StringMap;
+	
+	static StringMap _map;
+	static FastMutex _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Environment_VX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Environment_WIN32.h b/base/poco/Foundation/include/Poco/Environment_WIN32.h
new file mode 100644
index 00000000000..bfac7c590bb
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Environment_WIN32.h
@@ -0,0 +1,48 @@
+//
+// Environment_WIN32.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Environment
+//
+// Definition of the EnvironmentImpl class for WIN32.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Environment_WIN32_INCLUDED
+#define Foundation_Environment_WIN32_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API EnvironmentImpl
+{
+public:
+	typedef UInt8 NodeId[6]; /// Ethernet address.
+
+	static std::string getImpl(const std::string& name);	
+	static bool hasImpl(const std::string& name);	
+	static void setImpl(const std::string& name, const std::string& value);
+	static std::string osNameImpl();
+	static std::string osDisplayNameImpl();
+	static std::string osVersionImpl();
+	static std::string osArchitectureImpl();
+	static std::string nodeNameImpl();
+	static void nodeIdImpl(NodeId& id);
+	static unsigned processorCountImpl();
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Environment_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Environment_WIN32U.h b/base/poco/Foundation/include/Poco/Environment_WIN32U.h
new file mode 100644
index 00000000000..b54afb2e89b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Environment_WIN32U.h
@@ -0,0 +1,48 @@
+//
+// Environment_WIN32U.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Environment
+//
+// Definition of the EnvironmentImpl class for WIN32.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Environment_WIN32U_INCLUDED
+#define Foundation_Environment_WIN32U_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API EnvironmentImpl
+{
+public:
+	typedef UInt8 NodeId[6]; /// Ethernet address.
+
+	static std::string getImpl(const std::string& name);	
+	static bool hasImpl(const std::string& name);	
+	static void setImpl(const std::string& name, const std::string& value);
+	static std::string osNameImpl();	
+	static std::string osDisplayNameImpl();
+	static std::string osVersionImpl();
+	static std::string osArchitectureImpl();
+	static std::string nodeNameImpl();
+	static void nodeIdImpl(NodeId& id);
+	static unsigned processorCountImpl();
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Environment_WIN32U_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Environment_WINCE.h b/base/poco/Foundation/include/Poco/Environment_WINCE.h
new file mode 100644
index 00000000000..0c92bc540c4
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Environment_WINCE.h
@@ -0,0 +1,59 @@
+//
+// Environment_WINCE.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Environment
+//
+// Definition of the EnvironmentImpl class for WINCE.
+//
+// Copyright (c) 2009-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Environment_WINCE_INCLUDED
+#define Foundation_Environment_WINCE_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API EnvironmentImpl
+{
+public:
+	typedef UInt8 NodeId[6]; /// Ethernet address.
+
+	static std::string getImpl(const std::string& name);	
+	static bool hasImpl(const std::string& name);	
+	static void setImpl(const std::string& name, const std::string& value);
+	static std::string osNameImpl();	
+	static std::string osDisplayNameImpl();
+	static std::string osVersionImpl();
+	static std::string osArchitectureImpl();
+	static std::string nodeNameImpl();
+	static void nodeIdImpl(NodeId& id);
+	static unsigned processorCountImpl();
+	
+private:
+	static bool envVar(const std::string& name, std::string* value);
+	
+	static const std::string TEMP;
+	static const std::string TMP;
+	static const std::string HOMEPATH;
+	static const std::string COMPUTERNAME;
+	static const std::string OS;
+	static const std::string NUMBER_OF_PROCESSORS;
+	static const std::string PROCESSOR_ARCHITECTURE;	
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Environment_WINCE_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Error.h b/base/poco/Foundation/include/Poco/Error.h
new file mode 100644
index 00000000000..935ee223437
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Error.h
@@ -0,0 +1,52 @@
+//
+// Error.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Error
+//
+// Definition of the Error class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Error_INCLUDED
+#define Foundation_Error_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Error
+	/// The Error class provides utility functions
+	/// for error reporting.
+{
+public:
+
+#ifdef POCO_OS_FAMILY_WINDOWS
+	static DWORD last();
+		/// Utility function returning the last error.
+
+	static std::string getMessage(DWORD errorCode);
+		/// Utility function translating numeric error code to string.
+#else
+	static int last();
+		/// Utility function returning the last error.
+
+	static std::string getMessage(int errorCode);
+		/// Utility function translating numeric error code to string.
+#endif
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Error_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ErrorHandler.h b/base/poco/Foundation/include/Poco/ErrorHandler.h
new file mode 100644
index 00000000000..a3eea3b1434
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ErrorHandler.h
@@ -0,0 +1,120 @@
+//
+// ErrorHandler.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  ErrorHandler
+//
+// Definition of the ErrorHandler class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ErrorHandler_INCLUDED
+#define Foundation_ErrorHandler_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+
+
+class Foundation_API ErrorHandler
+	/// This is the base class for thread error handlers.
+	///
+	/// An unhandled exception that causes a thread to terminate is usually
+	/// silently ignored, since the class library cannot do anything meaningful
+	/// about it.
+	/// 
+	/// The Thread class provides the possibility to register a
+	/// global ErrorHandler that is invoked whenever a thread has
+	/// been terminated by an unhandled exception.
+	/// The ErrorHandler must be derived from this class and can
+	/// provide implementations of all three exception() overloads.
+	///
+	/// The ErrorHandler is always invoked within the context of
+	/// the offending thread.
+{
+public:
+	ErrorHandler();
+		/// Creates the ErrorHandler.
+
+	virtual ~ErrorHandler();
+		/// Destroys the ErrorHandler.
+
+	virtual void exception(const Exception& exc);
+		/// Called when a Poco::Exception (or a subclass)
+		/// caused the thread to terminate.
+		///
+		/// This method should not throw any exception - it would
+		/// be silently ignored.
+		///
+		/// The default implementation just breaks into the debugger.
+		
+	virtual void exception(const std::exception& exc);
+		/// Called when a std::exception (or a subclass)
+		/// caused the thread to terminate.		
+		///
+		/// This method should not throw any exception - it would
+		/// be silently ignored.
+		///
+		/// The default implementation just breaks into the debugger.
+
+	virtual void exception();
+		/// Called when an exception that is neither a
+		/// Poco::Exception nor a std::exception caused
+		/// the thread to terminate.
+		///
+		/// This method should not throw any exception - it would
+		/// be silently ignored.
+		///
+		/// The default implementation just breaks into the debugger.
+		
+	static void handle(const Exception& exc);
+		/// Invokes the currently registered ErrorHandler.
+		
+	static void handle(const std::exception& exc);
+		/// Invokes the currently registered ErrorHandler.
+	
+	static void handle();
+		/// Invokes the currently registered ErrorHandler.
+	
+	static ErrorHandler* set(ErrorHandler* pHandler);
+		/// Registers the given handler as the current error handler.
+		///
+		/// Returns the previously registered handler.
+
+	static ErrorHandler* get();
+		/// Returns a pointer to the currently registered
+		/// ErrorHandler.
+
+protected:	
+	static ErrorHandler* defaultHandler();
+		/// Returns the default ErrorHandler.	
+		
+private:
+	static ErrorHandler* _pHandler;
+	static FastMutex     _mutex;
+};
+
+
+//
+// inlines
+//
+inline ErrorHandler* ErrorHandler::get()
+{
+	return _pHandler;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ErrorHandler_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Event.h b/base/poco/Foundation/include/Poco/Event.h
new file mode 100644
index 00000000000..c6e20b65aa2
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Event.h
@@ -0,0 +1,123 @@
+//
+// Event.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Event
+//
+// Definition of the Event class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Event_INCLUDED
+#define Foundation_Event_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#include "Poco/Event_WIN32.h"
+#elif defined(POCO_VXWORKS)
+#include "Poco/Event_VX.h"
+#else
+#include "Poco/Event_POSIX.h"
+#endif
+
+
+namespace Poco {
+
+
+class Foundation_API Event: private EventImpl
+	/// An Event is a synchronization object that
+	/// allows one thread to signal one or more
+	/// other threads that a certain event
+	/// has happened.
+	/// Usually, one thread signals an event,
+	/// while one or more other threads wait
+	/// for an event to become signalled.
+{
+public:
+	Event(bool autoReset = true);
+		/// Creates the event. If autoReset is true,
+		/// the event is automatically reset after
+		/// a wait() successfully returns.
+		
+	~Event();
+		/// Destroys the event.
+
+	void set();
+		/// Signals the event. If autoReset is true,
+		/// only one thread waiting for the event 
+		/// can resume execution.
+		/// If autoReset is false, all waiting threads
+		/// can resume execution.
+
+	void wait();
+		/// Waits for the event to become signalled.
+
+	void wait(long milliseconds);
+		/// Waits for the event to become signalled.
+		/// Throws a TimeoutException if the event
+		/// does not become signalled within the specified
+		/// time interval.
+
+	bool tryWait(long milliseconds);
+		/// Waits for the event to become signalled.
+		/// Returns true if the event
+		/// became signalled within the specified
+		/// time interval, false otherwise.
+
+	void reset();
+		/// Resets the event to unsignalled state.
+	
+private:
+	Event(const Event&);
+	Event& operator = (const Event&);
+};
+
+
+//
+// inlines
+//
+inline void Event::set()
+{
+	setImpl();
+}
+
+
+inline void Event::wait()
+{
+	waitImpl();
+}
+
+
+inline void Event::wait(long milliseconds)
+{
+	if (!waitImpl(milliseconds))
+		throw TimeoutException();
+}
+
+
+inline bool Event::tryWait(long milliseconds)
+{
+	return waitImpl(milliseconds);
+}
+
+
+inline void Event::reset()
+{
+	resetImpl();
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Event_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/EventArgs.h b/base/poco/Foundation/include/Poco/EventArgs.h
new file mode 100644
index 00000000000..0066790706f
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/EventArgs.h
@@ -0,0 +1,45 @@
+//
+// EventArgs.h
+//
+// Library: Foundation
+// Package: Events
+// Module:  EventArgs
+//
+// Definition of EventArgs.
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_EventArgs_INCLUDED
+#define Foundation_EventArgs_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API EventArgs
+	/// The purpose of the EventArgs class is to be used as parameter
+	/// when one doesn't want to send any data.
+	///
+	/// One can use EventArgs as a base class for one's own event arguments
+	/// but with the arguments being a template parameter this is not
+	/// necessary.
+{
+public:
+	EventArgs();
+	
+	virtual ~EventArgs();
+};
+
+
+} // namespace Poco
+
+
+#endif
diff --git a/base/poco/Foundation/include/Poco/EventChannel.h b/base/poco/Foundation/include/Poco/EventChannel.h
new file mode 100644
index 00000000000..07975167ddc
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/EventChannel.h
@@ -0,0 +1,54 @@
+//
+// EventChannel.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  EventChannel
+//
+// Definition of the EventChannel class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_EventChannel_INCLUDED
+#define Foundation_EventChannel_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Channel.h"
+#include "Poco/Message.h"
+#include "Poco/BasicEvent.h"
+
+
+namespace Poco {
+
+
+class Foundation_API EventChannel: public Channel
+	/// The EventChannel fires the messageLogged event for every log message
+	/// received. This can be used to hook custom log message processing into
+	/// the logging framework. 
+{
+public:
+	Poco::BasicEvent<const Message> messageLogged;
+		/// Fired when a message is logged by calling the log() method.
+
+	EventChannel();
+		/// Creates the EventChannel.
+
+	void log(const Message& msg);
+		/// Fires the messageLogged event.
+
+protected:
+	~EventChannel();
+		/// Destroys the EventChannel.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_EventChannel_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/EventLogChannel.h b/base/poco/Foundation/include/Poco/EventLogChannel.h
new file mode 100644
index 00000000000..bcaf3a42e54
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/EventLogChannel.h
@@ -0,0 +1,105 @@
+//
+// EventLogChannel.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  EventLogChannel
+//
+// Definition of the EventLogChannel class specific to WIN32.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_EventLogChannel_INCLUDED
+#define Foundation_EventLogChannel_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Channel.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API EventLogChannel: public Channel
+	/// This Windows-only channel works with the Windows NT Event Log
+	/// service.
+	///
+	/// To work properly, the EventLogChannel class requires that either
+	/// the PocoFoundation.dll or the PocoMsg.dll Dynamic Link Library
+	/// containing the message definition resources can be found in $PATH.
+{
+public:
+	EventLogChannel();
+		/// Creates the EventLogChannel.
+		/// The name of the current application (or more correctly,
+		/// the name of its executable) is taken as event source name.
+		
+	EventLogChannel(const std::string& name);
+		/// Creates the EventLogChannel with the given event source name.
+		
+	EventLogChannel(const std::string& name, const std::string& host);
+		/// Creates an EventLogChannel with the given event source
+		/// name that routes messages to the given host.
+		
+	void open();
+		/// Opens the EventLogChannel. If necessary, the
+		/// required registry entries to register a
+		/// message resource DLL are made.
+		
+	void close();
+		/// Closes the EventLogChannel.
+	
+	void log(const Message& msg);
+		/// Logs the given message to the Windows Event Log.
+		///
+		/// The message type and priority are mapped to
+		/// appropriate values for Event Log type and category.
+		
+	void setProperty(const std::string& name, const std::string& value);
+		/// Sets or changes a configuration property. 
+		///
+		/// The following properties are supported:
+		///
+		///   * name:    The name of the event source.
+		///   * loghost: The name of the host where the Event Log service is running.
+		///              The default is "localhost".
+		///   * host:    same as host.
+		///   * logfile: The name of the log file. The default is "Application".
+		
+	std::string getProperty(const std::string& name) const;
+		/// Returns the value of the given property.
+
+	static const std::string PROP_NAME;
+	static const std::string PROP_HOST;
+	static const std::string PROP_LOGHOST;
+	static const std::string PROP_LOGFILE;
+
+protected:
+	~EventLogChannel();
+	static int getType(const Message& msg);
+	static int getCategory(const Message& msg);
+	void setUpRegistry() const;
+#if defined(POCO_WIN32_UTF8)
+	static std::wstring findLibrary(const wchar_t* name);
+#else
+	static std::string findLibrary(const char* name);
+#endif
+
+private:
+	std::string _name;
+	std::string _host;
+	std::string _logFile;
+	HANDLE      _h;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_EventLogChannel_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Event_POSIX.h b/base/poco/Foundation/include/Poco/Event_POSIX.h
new file mode 100644
index 00000000000..b7eb83aa6ec
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Event_POSIX.h
@@ -0,0 +1,77 @@
+//
+// Event_POSIX.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Event
+//
+// Definition of the EventImpl class for POSIX Threads.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Event_POSIX_INCLUDED
+#define Foundation_Event_POSIX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include <pthread.h>
+#include <errno.h>
+
+
+namespace Poco {
+
+
+class Foundation_API EventImpl
+{
+protected:
+	EventImpl(bool autoReset);		
+	~EventImpl();
+	void setImpl();
+	void waitImpl();
+	bool waitImpl(long milliseconds);
+	void resetImpl();
+	
+private:
+	bool            _auto;
+	volatile bool   _state;
+	pthread_mutex_t _mutex;
+	pthread_cond_t  _cond;
+};
+
+
+//
+// inlines
+//
+inline void EventImpl::setImpl()
+{
+	if (pthread_mutex_lock(&_mutex))	
+		throw SystemException("cannot signal event (lock)");
+	_state = true;
+	if (pthread_cond_broadcast(&_cond))
+	{
+		pthread_mutex_unlock(&_mutex);
+		throw SystemException("cannot signal event");
+	}
+	pthread_mutex_unlock(&_mutex);
+}
+
+
+inline void EventImpl::resetImpl()
+{
+	if (pthread_mutex_lock(&_mutex))	
+		throw SystemException("cannot reset event");
+	_state = false;
+	pthread_mutex_unlock(&_mutex);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Event_POSIX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Event_VX.h b/base/poco/Foundation/include/Poco/Event_VX.h
new file mode 100644
index 00000000000..9dd23c75e4e
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Event_VX.h
@@ -0,0 +1,49 @@
+//
+// Event_VX.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Event
+//
+// Definition of the EventImpl class for VxWorks.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Event_VX_INCLUDED
+#define Foundation_Event_VX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include <semLib.h>
+
+
+namespace Poco {
+
+
+class Foundation_API EventImpl
+{
+protected:
+	EventImpl(bool autoReset);		
+	~EventImpl();
+	void setImpl();
+	void waitImpl();
+	bool waitImpl(long milliseconds);
+	void resetImpl();
+	
+private:
+	bool          _auto;
+	volatile bool _state;
+	SEM_ID        _sem;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Event_VX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Event_WIN32.h b/base/poco/Foundation/include/Poco/Event_WIN32.h
new file mode 100644
index 00000000000..07fdb09847a
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Event_WIN32.h
@@ -0,0 +1,68 @@
+//
+// Event_WIN32.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Event
+//
+// Definition of the EventImpl class for WIN32.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Event_WIN32_INCLUDED
+#define Foundation_Event_WIN32_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API EventImpl
+{
+protected:
+	EventImpl(bool autoReset);		
+	~EventImpl();
+	void setImpl();
+	void waitImpl();
+	bool waitImpl(long milliseconds);
+	void resetImpl();
+	
+private:
+	HANDLE _event;
+};
+
+
+//
+// inlines
+//
+inline void EventImpl::setImpl()
+{
+	if (!SetEvent(_event))
+	{
+		throw SystemException("cannot signal event");
+	}
+}
+
+
+inline void EventImpl::resetImpl()
+{
+	if (!ResetEvent(_event))
+	{
+		throw SystemException("cannot reset event");
+	}
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Event_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Exception.h b/base/poco/Foundation/include/Poco/Exception.h
new file mode 100644
index 00000000000..bd8e6ed13a2
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Exception.h
@@ -0,0 +1,264 @@
+//
+// Exception.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Exception
+//
+// Definition of various Poco exception classes.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Exception_INCLUDED
+#define Foundation_Exception_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <stdexcept>
+
+
+namespace Poco {
+
+
+class Foundation_API Exception: public std::exception
+	/// This is the base class for all exceptions defined
+	/// in the Poco class library.
+{
+public:
+	Exception(const std::string& msg, int code = 0);
+		/// Creates an exception.
+
+    Exception(std::string&& msg, int code = 0);
+    /// Creates an exception.
+
+	Exception(const std::string& msg, const std::string& arg, int code = 0);
+		/// Creates an exception.
+
+	Exception(const std::string& msg, const Exception& nested, int code = 0);
+		/// Creates an exception and stores a clone
+		/// of the nested exception.
+
+	Exception(const Exception& exc);
+		/// Copy constructor.
+		
+	~Exception() throw();
+		/// Destroys the exception and deletes the nested exception.
+
+	Exception& operator = (const Exception& exc);
+		/// Assignment operator.
+
+	virtual const char* name() const throw();
+		/// Returns a static string describing the exception.
+		
+	virtual const char* className() const throw();
+		/// Returns the name of the exception class.
+		
+	virtual const char* what() const throw();
+		/// Returns a static string describing the exception.
+		///
+		/// Same as name(), but for compatibility with std::exception.
+		
+	const Exception* nested() const;
+		/// Returns a pointer to the nested exception, or
+		/// null if no nested exception exists.
+			
+	const std::string& message() const;
+		/// Returns the message text.
+			
+	int code() const;
+		/// Returns the exception code if defined.
+		
+	virtual std::string displayText() const;
+		/// Returns a string consisting of the
+		/// message name and the message text.
+
+	virtual Exception* clone() const;
+		/// Creates an exact copy of the exception.
+		///
+		/// The copy can later be thrown again by
+		/// invoking rethrow() on it.
+		
+	virtual void rethrow() const;
+		/// (Re)Throws the exception.
+		///
+		/// This is useful for temporarily storing a
+		/// copy of an exception (see clone()), then
+		/// throwing it again.
+
+protected:
+	Exception(int code = 0);
+		/// Standard constructor.
+
+	void message(const std::string& msg);
+		/// Sets the message for the exception.
+
+	void extendedMessage(const std::string& arg);
+		/// Sets the extended message for the exception.
+		
+private:
+	std::string _msg;
+	Exception*  _pNested;
+	int			_code;
+};
+
+
+//
+// inlines
+//
+inline const Exception* Exception::nested() const
+{
+	return _pNested;
+}
+
+
+inline const std::string& Exception::message() const
+{
+	return _msg;
+}
+
+
+inline void Exception::message(const std::string& msg)
+{
+	_msg = msg;
+}
+
+
+inline int Exception::code() const
+{
+	return _code;
+}
+
+
+//
+// Macros for quickly declaring and implementing exception classes.
+// Unfortunately, we cannot use a template here because character
+// pointers (which we need for specifying the exception name)
+// are not allowed as template arguments.
+//
+#define POCO_DECLARE_EXCEPTION_CODE(API, CLS, BASE, CODE) \
+	class API CLS: public BASE														\
+	{																				\
+	public:																			\
+		CLS(int code = CODE);														\
+		CLS(const std::string& msg, int code = CODE);								\
+		CLS(const std::string& msg, const std::string& arg, int code = CODE);		\
+		CLS(const std::string& msg, const Poco::Exception& exc, int code = CODE);	\
+		CLS(const CLS& exc);														\
+		~CLS() throw();																\
+		CLS& operator = (const CLS& exc);											\
+		const char* name() const throw();											\
+		const char* className() const throw();										\
+		Poco::Exception* clone() const;												\
+		void rethrow() const;														\
+	};
+
+#define POCO_DECLARE_EXCEPTION(API, CLS, BASE) \
+	POCO_DECLARE_EXCEPTION_CODE(API, CLS, BASE, 0)
+
+#define POCO_IMPLEMENT_EXCEPTION(CLS, BASE, NAME)													\
+	CLS::CLS(int code): BASE(code)																	\
+	{																								\
+	}																								\
+	CLS::CLS(const std::string& msg, int code): BASE(msg, code)										\
+	{																								\
+	}																								\
+	CLS::CLS(const std::string& msg, const std::string& arg, int code): BASE(msg, arg, code)		\
+	{																								\
+	}																								\
+	CLS::CLS(const std::string& msg, const Poco::Exception& exc, int code): BASE(msg, exc, code)	\
+	{																								\
+	}																								\
+	CLS::CLS(const CLS& exc): BASE(exc)																\
+	{																								\
+	}																								\
+	CLS::~CLS() throw()																				\
+	{																								\
+	}																								\
+	CLS& CLS::operator = (const CLS& exc)															\
+	{																								\
+		BASE::operator = (exc);																		\
+		return *this;																				\
+	}																								\
+	const char* CLS::name() const throw()															\
+	{																								\
+		return NAME;																				\
+	}																								\
+	const char* CLS::className() const throw()														\
+	{																								\
+		return typeid(*this).name();																\
+	}																								\
+	Poco::Exception* CLS::clone() const																\
+	{																								\
+		return new CLS(*this);																		\
+	}																								\
+	void CLS::rethrow() const																		\
+	{																								\
+		throw *this;																				\
+	}
+
+
+//
+// Standard exception classes
+//
+POCO_DECLARE_EXCEPTION(Foundation_API, LogicException, Exception)
+POCO_DECLARE_EXCEPTION(Foundation_API, AssertionViolationException, LogicException)
+POCO_DECLARE_EXCEPTION(Foundation_API, NullPointerException, LogicException)
+POCO_DECLARE_EXCEPTION(Foundation_API, NullValueException, LogicException)
+POCO_DECLARE_EXCEPTION(Foundation_API, BugcheckException, LogicException)
+POCO_DECLARE_EXCEPTION(Foundation_API, InvalidArgumentException, LogicException)
+POCO_DECLARE_EXCEPTION(Foundation_API, NotImplementedException, LogicException)
+POCO_DECLARE_EXCEPTION(Foundation_API, RangeException, LogicException)
+POCO_DECLARE_EXCEPTION(Foundation_API, IllegalStateException, LogicException)
+POCO_DECLARE_EXCEPTION(Foundation_API, InvalidAccessException, LogicException)
+POCO_DECLARE_EXCEPTION(Foundation_API, SignalException, LogicException)
+POCO_DECLARE_EXCEPTION(Foundation_API, UnhandledException, LogicException)
+
+POCO_DECLARE_EXCEPTION(Foundation_API, RuntimeException, Exception)
+POCO_DECLARE_EXCEPTION(Foundation_API, NotFoundException, RuntimeException)
+POCO_DECLARE_EXCEPTION(Foundation_API, ExistsException, RuntimeException)
+POCO_DECLARE_EXCEPTION(Foundation_API, TimeoutException, RuntimeException)
+POCO_DECLARE_EXCEPTION(Foundation_API, SystemException, RuntimeException)
+POCO_DECLARE_EXCEPTION(Foundation_API, RegularExpressionException, RuntimeException)
+POCO_DECLARE_EXCEPTION(Foundation_API, LibraryLoadException, RuntimeException)
+POCO_DECLARE_EXCEPTION(Foundation_API, LibraryAlreadyLoadedException, RuntimeException)
+POCO_DECLARE_EXCEPTION(Foundation_API, NoThreadAvailableException, RuntimeException)
+POCO_DECLARE_EXCEPTION(Foundation_API, PropertyNotSupportedException, RuntimeException)
+POCO_DECLARE_EXCEPTION(Foundation_API, PoolOverflowException, RuntimeException)
+POCO_DECLARE_EXCEPTION(Foundation_API, NoPermissionException, RuntimeException)
+POCO_DECLARE_EXCEPTION(Foundation_API, OutOfMemoryException, RuntimeException)
+POCO_DECLARE_EXCEPTION(Foundation_API, DataException, RuntimeException)
+
+POCO_DECLARE_EXCEPTION(Foundation_API, DataFormatException, DataException)
+POCO_DECLARE_EXCEPTION(Foundation_API, SyntaxException, DataException)
+POCO_DECLARE_EXCEPTION(Foundation_API, CircularReferenceException, DataException)
+POCO_DECLARE_EXCEPTION(Foundation_API, PathSyntaxException, SyntaxException)
+POCO_DECLARE_EXCEPTION(Foundation_API, IOException, RuntimeException)
+POCO_DECLARE_EXCEPTION(Foundation_API, ProtocolException, IOException)
+POCO_DECLARE_EXCEPTION(Foundation_API, FileException, IOException)
+POCO_DECLARE_EXCEPTION(Foundation_API, FileExistsException, FileException)
+POCO_DECLARE_EXCEPTION(Foundation_API, FileNotFoundException, FileException)
+POCO_DECLARE_EXCEPTION(Foundation_API, PathNotFoundException, FileException)
+POCO_DECLARE_EXCEPTION(Foundation_API, FileReadOnlyException, FileException)
+POCO_DECLARE_EXCEPTION(Foundation_API, FileAccessDeniedException, FileException)
+POCO_DECLARE_EXCEPTION(Foundation_API, CreateFileException, FileException)
+POCO_DECLARE_EXCEPTION(Foundation_API, OpenFileException, FileException)
+POCO_DECLARE_EXCEPTION(Foundation_API, WriteFileException, FileException)
+POCO_DECLARE_EXCEPTION(Foundation_API, ReadFileException, FileException)
+POCO_DECLARE_EXCEPTION(Foundation_API, DirectoryNotEmptyException, FileException)
+POCO_DECLARE_EXCEPTION(Foundation_API, UnknownURISchemeException, RuntimeException)
+POCO_DECLARE_EXCEPTION(Foundation_API, TooManyURIRedirectsException, RuntimeException)
+POCO_DECLARE_EXCEPTION(Foundation_API, URISyntaxException, SyntaxException)
+
+POCO_DECLARE_EXCEPTION(Foundation_API, ApplicationException, Exception)
+POCO_DECLARE_EXCEPTION(Foundation_API, BadCastException, RuntimeException)
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Exception_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ExpirationDecorator.h b/base/poco/Foundation/include/Poco/ExpirationDecorator.h
new file mode 100644
index 00000000000..2e9d40a6381
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ExpirationDecorator.h
@@ -0,0 +1,92 @@
+//
+// ExpirationDecorator.h
+//
+// Library: Foundation
+// Package: Events
+// Module:  ExpirationDecorator
+//
+// Implementation of the ExpirationDecorator template.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ExpirationDecorator_INCLUDED
+#define Foundation_ExpirationDecorator_INCLUDED
+
+
+#include "Poco/Timestamp.h"
+#include "Poco/Timespan.h"
+
+
+namespace Poco {
+
+
+template <typename TArgs>
+class ExpirationDecorator
+	/// ExpirationDecorator adds an expiration method to values so that they can be used
+	/// with the UniqueExpireCache.
+{
+public:
+	ExpirationDecorator():
+		_value(),
+		_expiresAt()
+	{
+	}
+
+	ExpirationDecorator(const TArgs& p, const Poco::Timespan::TimeDiff& diffInMs):
+			/// Creates an element that will expire in diff milliseconds
+		_value(p),
+		_expiresAt()
+	{
+		_expiresAt += (diffInMs*1000);
+	}
+
+	ExpirationDecorator(const TArgs& p, const Poco::Timespan& timeSpan):
+		/// Creates an element that will expire after the given timeSpan
+		_value(p),
+		_expiresAt()
+	{
+		_expiresAt += timeSpan.totalMicroseconds();
+	}
+
+	ExpirationDecorator(const TArgs& p, const Poco::Timestamp& timeStamp):
+		/// Creates an element that will expire at the given time point
+		_value(p),
+		_expiresAt(timeStamp)
+	{
+	}
+
+
+	~ExpirationDecorator()
+	{
+	}
+	
+	const Poco::Timestamp& getExpiration() const
+	{
+		return _expiresAt;
+	}
+
+	const TArgs& value() const
+	{
+		return _value;
+	}
+
+	TArgs& value()
+	{
+		return _value;
+	}
+
+private:
+	TArgs     _value;
+	Timestamp _expiresAt;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ExpirationDecorator_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Expire.h b/base/poco/Foundation/include/Poco/Expire.h
new file mode 100644
index 00000000000..73f82b4b0d7
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Expire.h
@@ -0,0 +1,194 @@
+//
+// Expire.h
+//
+// Library: Foundation
+// Package: Events
+// Module:  Expire
+//
+// Implementation of the Expire template.
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Expire_INCLUDED
+#define Foundation_Expire_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/AbstractDelegate.h"
+#include "Poco/Timestamp.h"
+
+
+namespace Poco {
+
+
+template <class TArgs>
+class Expire: public AbstractDelegate<TArgs>
+	/// Decorator for AbstractDelegate adding automatic 
+	/// expiration of registrations to AbstractDelegate's.
+{
+public:
+	Expire(const AbstractDelegate<TArgs>& p, Timestamp::TimeDiff expireMillisecs):
+		_pDelegate(p.clone()), 
+		_expire(expireMillisecs*1000)
+	{
+	}
+
+	Expire(const Expire& expire):
+		AbstractDelegate<TArgs>(expire),
+		_pDelegate(expire._pDelegate->clone()),
+		_expire(expire._expire),
+		_creationTime(expire._creationTime)
+	{
+	}
+
+	~Expire()
+	{
+		delete _pDelegate;
+	}
+	
+	Expire& operator = (const Expire& expire)
+	{
+		if (&expire != this)
+		{
+			delete this->_pDelegate;
+			this->_pDelegate    = expire._pDelegate->clone();
+			this->_expire       = expire._expire;
+			this->_creationTime = expire._creationTime;
+			this->_pTarget = expire._pTarget;
+		}
+		return *this;
+	}
+
+	bool notify(const void* sender, TArgs& arguments)
+	{
+		if (!expired())
+			return this->_pDelegate->notify(sender, arguments);
+		else
+			return false;
+	}
+
+	bool equals(const AbstractDelegate<TArgs>& other) const
+	{
+		return other.equals(*_pDelegate);
+	}
+
+	AbstractDelegate<TArgs>* clone() const
+	{
+		return new Expire(*this);
+	}
+	
+	void disable()
+	{
+		_pDelegate->disable();
+	}
+
+	const AbstractDelegate<TArgs>* unwrap() const
+	{
+		return this->_pDelegate;
+	}
+
+protected:
+	bool expired() const
+	{
+		return _creationTime.isElapsed(_expire);
+	}
+
+	AbstractDelegate<TArgs>* _pDelegate;
+	Timestamp::TimeDiff _expire;
+	Timestamp _creationTime;
+
+private:
+	Expire();
+};
+
+
+template <>
+class Expire<void>: public AbstractDelegate<void>
+	/// Decorator for AbstractDelegate adding automatic 
+	/// expiration of registrations to AbstractDelegate's.
+{
+public:
+	Expire(const AbstractDelegate<void>& p, Timestamp::TimeDiff expireMillisecs):
+		_pDelegate(p.clone()), 
+		_expire(expireMillisecs*1000)
+	{
+	}
+
+	Expire(const Expire& expire):
+		AbstractDelegate<void>(expire),
+		_pDelegate(expire._pDelegate->clone()),
+		_expire(expire._expire),
+		_creationTime(expire._creationTime)
+	{
+	}
+
+	~Expire()
+	{
+		delete _pDelegate;
+	}
+	
+	Expire& operator = (const Expire& expire)
+	{
+		if (&expire != this)
+		{
+			delete this->_pDelegate;
+			this->_pDelegate    = expire._pDelegate->clone();
+			this->_expire       = expire._expire;
+			this->_creationTime = expire._creationTime;
+			//this->_pTarget = expire._pTarget;
+		}
+		return *this;
+	}
+
+	bool notify(const void* sender)
+	{
+		if (!expired())
+			return this->_pDelegate->notify(sender);
+		else
+			return false;
+	}
+
+	bool equals(const AbstractDelegate<void>& other) const
+	{
+		return other.equals(*_pDelegate);
+	}
+
+	AbstractDelegate<void>* clone() const
+	{
+		return new Expire(*this);
+	}
+	
+	void disable()
+	{
+		_pDelegate->disable();
+	}
+
+	const AbstractDelegate<void>* unwrap() const
+	{
+		return this->_pDelegate;
+	}
+
+protected:
+	bool expired() const
+	{
+		return _creationTime.isElapsed(_expire);
+	}
+
+	AbstractDelegate<void>* _pDelegate;
+	Timestamp::TimeDiff _expire;
+	Timestamp _creationTime;
+
+private:
+	Expire();
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Expire_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ExpireCache.h b/base/poco/Foundation/include/Poco/ExpireCache.h
new file mode 100644
index 00000000000..41f0482b303
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ExpireCache.h
@@ -0,0 +1,65 @@
+//
+// ExpireCache.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  ExpireCache
+//
+// Definition of the ExpireCache class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ExpireCache_INCLUDED
+#define Foundation_ExpireCache_INCLUDED
+
+
+#include "Poco/AbstractCache.h"
+#include "Poco/ExpireStrategy.h"
+
+
+namespace Poco {
+
+
+template <
+	class TKey, 
+	class TValue, 
+	class TMutex = FastMutex, 
+	class TEventMutex = FastMutex
+> 
+class ExpireCache: public AbstractCache<TKey, TValue, ExpireStrategy<TKey, TValue>, TMutex, TEventMutex>
+	/// An ExpireCache caches entries for a fixed time period (per default 10 minutes).
+	/// Entries expire independently of the access pattern, i.e. after a constant time.
+	/// If you require your objects to expire after they were not accessed for a given time
+	/// period use a Poco::AccessExpireCache.
+	///
+	/// Be careful when using an ExpireCache. A cache is often used
+	/// like cache.has(x) followed by cache.get x). Note that it could happen
+	/// that the "has" call works, then the current execution thread gets descheduled, time passes,
+	/// the entry gets invalid, thus leading to an empty SharedPtr being returned 
+	/// when "get" is invoked.
+{
+public:
+	ExpireCache(Timestamp::TimeDiff expire = 600000): 
+		AbstractCache<TKey, TValue, ExpireStrategy<TKey, TValue>, TMutex, TEventMutex>(ExpireStrategy<TKey, TValue>(expire))
+	{
+	}
+
+	~ExpireCache()
+	{
+	}
+
+private:
+	ExpireCache(const ExpireCache& aCache);
+	ExpireCache& operator = (const ExpireCache& aCache);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ExpireCache_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ExpireLRUCache.h b/base/poco/Foundation/include/Poco/ExpireLRUCache.h
new file mode 100644
index 00000000000..d79281a8e8e
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ExpireLRUCache.h
@@ -0,0 +1,62 @@
+//
+// ExpireLRUCache.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  ExpireLRUCache
+//
+// Definition of the ExpireLRUCache class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ExpireLRUCache_INCLUDED
+#define Foundation_ExpireLRUCache_INCLUDED
+
+
+#include "Poco/AbstractCache.h"
+#include "Poco/StrategyCollection.h"
+#include "Poco/ExpireStrategy.h"
+#include "Poco/LRUStrategy.h"
+
+
+namespace Poco {
+
+
+template < 
+	class TKey,
+	class TValue,
+	class TMutex = FastMutex, 
+	class TEventMutex = FastMutex
+>
+class ExpireLRUCache: public AbstractCache<TKey, TValue, StrategyCollection<TKey, TValue>, TMutex, TEventMutex>
+	/// An ExpireLRUCache combines LRU caching and time based expire caching.
+	/// It cache entries for a fixed time period (per default 10 minutes)
+	/// but also limits the size of the cache (per default: 1024).
+{
+public:
+	ExpireLRUCache(long cacheSize = 1024, Timestamp::TimeDiff expire = 600000): 
+		AbstractCache<TKey, TValue, StrategyCollection<TKey, TValue>, TMutex, TEventMutex>(StrategyCollection<TKey, TValue>())
+	{
+		this->_strategy.pushBack(new LRUStrategy<TKey, TValue>(cacheSize));
+		this->_strategy.pushBack(new ExpireStrategy<TKey, TValue>(expire));
+	}
+
+	~ExpireLRUCache()
+	{
+	}
+
+private:
+	ExpireLRUCache(const ExpireLRUCache& aCache);
+	ExpireLRUCache& operator = (const ExpireLRUCache& aCache);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ExpireLRUCache_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ExpireStrategy.h b/base/poco/Foundation/include/Poco/ExpireStrategy.h
new file mode 100644
index 00000000000..27e471fd068
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ExpireStrategy.h
@@ -0,0 +1,132 @@
+//
+// ExpireStrategy.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  ExpireStrategy
+//
+// Definition of the ExpireStrategy class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ExpireStrategy_INCLUDED
+#define Foundation_ExpireStrategy_INCLUDED
+
+
+#include "Poco/KeyValueArgs.h"
+#include "Poco/ValidArgs.h"
+#include "Poco/AbstractStrategy.h"
+#include "Poco/Bugcheck.h"
+#include "Poco/Timestamp.h"
+#include "Poco/EventArgs.h"
+#include <set>
+#include <map>
+
+
+namespace Poco {
+
+
+template < 
+	class TKey,
+	class TValue
+>
+class ExpireStrategy: public AbstractStrategy<TKey, TValue>
+	/// An ExpireStrategy implements time based expiration of cache entries
+{
+public:
+	typedef std::multimap<Timestamp, TKey>     TimeIndex;
+	typedef typename TimeIndex::iterator       IndexIterator;
+	typedef typename TimeIndex::const_iterator ConstIndexIterator;
+	typedef std::map<TKey, IndexIterator>      Keys;
+	typedef typename Keys::iterator            Iterator;
+
+public:
+	ExpireStrategy(Timestamp::TimeDiff expireTimeInMilliSec): _expireTime(expireTimeInMilliSec * 1000)
+		/// Create an expire strategy. Note that the smallest allowed caching time is 25ms.
+		/// Anything lower than that is not useful with current operating systems.
+	{
+		if (_expireTime < 25000) throw InvalidArgumentException("expireTime must be at least 25 ms");  
+	}
+
+	~ExpireStrategy()
+	{
+	}
+
+	void onAdd(const void*, const KeyValueArgs <TKey, TValue>& args)
+	{
+		Timestamp now;
+		typename TimeIndex::value_type tiValue(now, args.key());
+		IndexIterator it = _keyIndex.insert(tiValue);
+		typename Keys::value_type kValue(args.key(), it);
+		std::pair<Iterator, bool> stat = _keys.insert(kValue);
+		if (!stat.second)
+		{
+			_keyIndex.erase(stat.first->second);
+			stat.first->second = it;
+		}
+	}
+
+	void onRemove(const void*, const TKey& key)
+	{
+		Iterator it = _keys.find(key);
+		if (it != _keys.end())
+		{
+			_keyIndex.erase(it->second);
+			_keys.erase(it);
+		}
+	}
+
+	void onGet(const void*, const TKey& key)
+	{
+		// get triggers no changes in an expire
+	}
+
+	void onClear(const void*, const EventArgs& args)
+	{
+		_keys.clear();
+		_keyIndex.clear();
+	}
+
+	void onIsValid(const void*, ValidArgs<TKey>& args)
+	{
+		Iterator it = _keys.find(args.key());
+		if (it != _keys.end())
+		{
+			if (it->second->first.isElapsed(_expireTime))
+			{
+				args.invalidate();
+			}
+		}
+		else //not found: probably removed by onReplace
+			args.invalidate();
+	}
+
+	void onReplace(const void*, std::set<TKey>& elemsToRemove)
+	{
+		// Note: replace only informs the cache which elements
+		// it would like to remove!
+		// it does not remove them on its own!
+		IndexIterator it = _keyIndex.begin();
+		while (it != _keyIndex.end() && it->first.isElapsed(_expireTime))
+		{
+			elemsToRemove.insert(it->second);
+			++it;
+		}
+	}
+
+protected:
+	Timestamp::TimeDiff _expireTime;
+	Keys      _keys;     /// For faster replacement of keys, the iterator points to the _keyIndex map
+	TimeIndex _keyIndex; /// Maps time to key value
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ExpireStrategy_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FIFOBuffer.h b/base/poco/Foundation/include/Poco/FIFOBuffer.h
new file mode 100644
index 00000000000..7fc85ca7e82
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FIFOBuffer.h
@@ -0,0 +1,556 @@
+//
+// FIFOBuffer.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  FIFOBuffer
+//
+// Definition of the FIFOBuffer class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FIFOBuffer_INCLUDED
+#define Foundation_FIFOBuffer_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include "Poco/Buffer.h"
+#include "Poco/BasicEvent.h"
+#include "Poco/Mutex.h"
+#include "Poco/Format.h"
+
+
+namespace Poco {
+
+
+template <class T>
+class BasicFIFOBuffer
+	/// A simple buffer class with support for re-entrant,
+	/// FIFO-style read/write operations, as well as (optional)
+	/// empty/non-empty/full (i.e. writable/readable) transition
+	/// notifications. Buffer can be flagged with end-of-file and
+	/// error flags, which renders it un-readable/writable.
+	///
+	/// Critical portions of code are protected by a recursive mutex.
+	/// However, to achieve thread-safety in cases where multiple
+	/// member function calls are involved and have to be atomic,
+	/// the mutex must be locked externally.
+	/// 
+	/// Buffer size, as well as amount of unread data and
+	/// available space introspections are supported as well.
+	///
+	/// This class is useful anywhere where a FIFO functionality
+	/// is needed.
+{
+public:
+	typedef T Type;
+
+	mutable Poco::BasicEvent<bool> writable;
+		/// Event indicating "writability" of the buffer,
+		/// triggered as follows:
+		///
+		///	* when buffer transitions from non-full to full, 
+		///	  Writable event observers are notified, with 
+		///	  false value as the argument
+		///
+		///	* when buffer transitions from full to non-full,
+		///	  Writable event observers are notified, with 
+		///	  true value as the argument
+
+	mutable Poco::BasicEvent<bool> readable;
+		/// Event indicating "readability" of the buffer,
+		/// triggered as follows:
+		///
+		///	* when buffer transitions from non-empty to empty,
+		///	  Readable event observers are notified, with false  
+		///	  value as the argument
+		///
+		///	* when FIFOBuffer transitions from empty to non-empty,
+		///	  Readable event observers are notified, with true value
+		///	  as the argument
+
+	BasicFIFOBuffer(std::size_t size, bool notify = false):
+		_buffer(size),
+		_begin(0),
+		_used(0),
+		_notify(notify),
+		_eof(false),
+		_error(false)
+		/// Creates the FIFOBuffer.
+	{
+	}
+
+	BasicFIFOBuffer(T* pBuffer, std::size_t size, bool notify = false):
+		_buffer(pBuffer, size),
+		_begin(0),
+		_used(0),
+		_notify(notify),
+		_eof(false),
+		_error(false)
+		/// Creates the FIFOBuffer.
+	{
+	}
+
+	BasicFIFOBuffer(const T* pBuffer, std::size_t size, bool notify = false):
+		_buffer(pBuffer, size),
+		_begin(0),
+		_used(size),
+		_notify(notify),
+		_eof(false),
+		_error(false)
+		/// Creates the FIFOBuffer.
+	{
+	}
+
+	~BasicFIFOBuffer()
+		/// Destroys the FIFOBuffer.
+	{
+	}
+	
+	void resize(std::size_t newSize, bool preserveContent = true)
+		/// Resizes the buffer. If preserveContent is true,
+		/// the content of the old buffer is preserved.
+		/// New size can be larger or smaller than
+		/// the current size, but it must not be 0.
+		/// Additionally, if the new length is smaller
+		/// than currently used length and preserveContent
+		/// is true, InvalidAccessException is thrown.
+	{
+		Mutex::ScopedLock lock(_mutex);
+
+		if (preserveContent && (newSize < _used))
+			throw InvalidAccessException("Can not resize FIFO without data loss.");
+		
+		std::size_t usedBefore = _used;
+		_buffer.resize(newSize, preserveContent);
+		if (!preserveContent) _used = 0;
+		if (_notify) notify(usedBefore);
+	}
+	
+	std::size_t peek(T* pBuffer, std::size_t length) const
+		/// Peeks into the data currently in the FIFO
+		/// without actually extracting it.
+		/// If length is zero, the return is immediate.
+		/// If length is greater than used length,
+		/// it is substituted with the the current FIFO 
+		/// used length.
+		/// 
+		/// Returns the number of elements copied in the 
+		/// supplied buffer.
+	{
+		if (0 == length) return 0;
+		Mutex::ScopedLock lock(_mutex);
+		if (!isReadable()) return 0;
+		if (length > _used) length = _used;
+		std::memcpy(pBuffer, _buffer.begin() + _begin, length * sizeof(T));
+		return length;
+	}
+	
+	std::size_t peek(Poco::Buffer<T>& buffer, std::size_t length = 0) const
+		/// Peeks into the data currently in the FIFO
+		/// without actually extracting it.
+		/// Resizes the supplied buffer to the size of
+		/// data written to it. If length is not
+		/// supplied by the caller or is greater than length 
+		/// of currently used data, the current FIFO used 
+		/// data length is substituted for it.
+		/// 
+		/// Returns the number of elements copied in the 
+		/// supplied buffer.
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (!isReadable()) return 0;
+		if (0 == length || length > _used) length = _used;
+		buffer.resize(length);
+		return peek(buffer.begin(), length);
+	}
+	
+	std::size_t read(T* pBuffer, std::size_t length)
+		/// Copies the data currently in the FIFO
+		/// into the supplied buffer, which must be
+		/// preallocated to at least the length size
+		/// before calling this function.
+		/// 
+		/// Returns the size of the copied data.
+	{
+		if (0 == length) return 0;
+		Mutex::ScopedLock lock(_mutex);
+		if (!isReadable()) return 0;
+		std::size_t usedBefore = _used;
+		std::size_t readLen = peek(pBuffer, length);
+		poco_assert (_used >= readLen);
+		_used -= readLen;
+		if (0 == _used) _begin = 0;
+		else _begin += length;
+
+		if (_notify) notify(usedBefore);
+
+		return readLen;
+	}
+	
+	std::size_t read(Poco::Buffer<T>& buffer, std::size_t length = 0)
+		/// Copies the data currently in the FIFO
+		/// into the supplied buffer.
+		/// Resizes the supplied buffer to the size of
+		/// data written to it.
+		/// 
+		/// Returns the size of the copied data.
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (!isReadable()) return 0;
+		std::size_t usedBefore = _used;
+		std::size_t readLen = peek(buffer, length);
+		poco_assert (_used >= readLen);
+		_used -= readLen;
+		if (0 == _used) _begin = 0;
+		else _begin += length;
+
+		if (_notify) notify(usedBefore);
+
+		return readLen;
+	}
+
+	std::size_t write(const T* pBuffer, std::size_t length)
+		/// Writes data from supplied buffer to the FIFO buffer.
+		/// If there is no sufficient space for the whole
+		/// buffer to be written, data up to available 
+		/// length is written.
+		/// The length of data to be written is determined from the
+		/// length argument. Function does nothing and returns zero
+		/// if length argument is equal to zero.
+		/// 
+		/// Returns the length of data written.
+	{
+		if (0 == length) return 0;
+
+		Mutex::ScopedLock lock(_mutex);
+		
+		if (!isWritable()) return 0;
+		
+		if (_buffer.size() - (_begin + _used) < length)
+		{
+			std::memmove(_buffer.begin(), begin(), _used * sizeof(T));
+			_begin = 0;
+		}
+
+		std::size_t usedBefore = _used;
+		std::size_t available =  _buffer.size() - _used - _begin;
+		std::size_t len = length > available ? available : length;
+		std::memcpy(begin() + _used, pBuffer, len * sizeof(T));
+		_used += len;
+		poco_assert (_used <= _buffer.size());
+		if (_notify) notify(usedBefore);
+
+		return len;
+	}
+
+	std::size_t write(const Buffer<T>& buffer, std::size_t length = 0)
+		/// Writes data from supplied buffer to the FIFO buffer.
+		/// If there is no sufficient space for the whole
+		/// buffer to be written, data up to available 
+		/// length is written.
+		/// The length of data to be written is determined from the
+		/// length argument or buffer size (when length argument is
+		/// default zero or greater than buffer size).
+		/// 
+		/// Returns the length of data written.
+	{
+		if (length == 0 || length > buffer.size())
+			length = buffer.size();
+
+		return write(buffer.begin(), length);
+	}
+
+	std::size_t size() const
+		/// Returns the size of the buffer.
+	{
+		return _buffer.size();
+	}
+	
+	std::size_t used() const
+		/// Returns the size of the used portion of the buffer.
+	{
+		return _used;
+	}
+	
+	std::size_t available() const
+		/// Returns the size of the available portion of the buffer.
+	{
+		return size() - _used;
+	}
+
+	void drain(std::size_t length = 0)
+		/// Drains length number of elements from the buffer.
+		/// If length is zero or greater than buffer current
+		/// content length, buffer is emptied.
+	{
+		Mutex::ScopedLock lock(_mutex);
+
+		std::size_t usedBefore = _used;
+
+		if (0 == length || length >= _used)
+		{
+			_begin = 0;
+			_used = 0;
+		}
+		else
+		{
+			_begin += length;
+			_used -= length;
+		}
+
+		if (_notify) notify(usedBefore);
+	}
+
+	void copy(const T* ptr, std::size_t length)
+		/// Copies the supplied data to the buffer and adjusts
+		/// the used buffer size.
+	{
+		poco_check_ptr(ptr);
+		if (0 == length) return;
+
+		Mutex::ScopedLock lock(_mutex);
+		
+		if (length > available())
+			throw Poco::InvalidAccessException("Cannot extend buffer.");
+		
+		if (!isWritable())
+			throw Poco::InvalidAccessException("Buffer not writable.");
+
+		std::memcpy(begin() + _used, ptr, length * sizeof(T));
+		std::size_t usedBefore = _used;
+		_used += length;
+		if (_notify) notify(usedBefore);
+	}
+
+	void advance(std::size_t length)
+		/// Advances buffer by length elements.
+		/// Should be called AFTER the data 
+		/// was copied into the buffer.
+	{
+		Mutex::ScopedLock lock(_mutex);
+
+		if (length > available())
+			throw Poco::InvalidAccessException("Cannot extend buffer.");
+		
+		if (!isWritable())
+			throw Poco::InvalidAccessException("Buffer not writable.");
+
+		if (_buffer.size() - (_begin + _used) < length)
+		{
+			std::memmove(_buffer.begin(), begin(), _used * sizeof(T));
+			_begin = 0;
+		}
+
+		std::size_t usedBefore = _used;
+		_used += length;
+		if (_notify) notify(usedBefore);
+	}
+
+	T* begin()
+		/// Returns the pointer to the beginning of the buffer.
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_begin != 0)
+		{
+			// Move the data to the start of the buffer so begin() and next()
+			// always return consistent pointers with each other and allow writing
+			// to the end of the buffer.
+			std::memmove(_buffer.begin(), _buffer.begin() + _begin, _used * sizeof(T));
+			_begin = 0;
+		}
+		return _buffer.begin();
+	}
+
+	T* next()
+		/// Returns the pointer to the next available position in the buffer.
+	{
+		Mutex::ScopedLock lock(_mutex);
+		return begin() + _used;
+	}
+
+	T& operator [] (std::size_t index)
+		/// Returns value at index position.
+		/// Throws InvalidAccessException if index is larger than 
+		/// the last valid (used) buffer position.
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (index >= _used)
+			throw InvalidAccessException(format("Index out of bounds: %z (max index allowed: %z)", index, _used - 1));
+
+		return _buffer[_begin + index];
+	}
+
+	const T& operator [] (std::size_t index) const
+		/// Returns value at index position.
+		/// Throws InvalidAccessException if index is larger than 
+		/// the last valid (used) buffer position.
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (index >= _used)
+			throw InvalidAccessException(format("Index out of bounds: %z (max index allowed: %z)", index, _used - 1));
+
+		return _buffer[_begin + index];
+	}
+
+	const Buffer<T>& buffer() const
+		/// Returns const reference to the underlying buffer.
+	{
+		return _buffer;
+	}
+	
+	void setError(bool error = true)
+		/// Sets the error flag on the buffer and empties it.
+		/// If notifications are enabled, they will be triggered 
+		/// if appropriate.
+		/// 
+		/// Setting error flag to true prevents reading and writing
+		/// to the buffer; to re-enable FIFOBuffer for reading/writing,
+		/// the error flag must be set to false.
+	{
+		if (error)
+		{
+			bool f = false;
+			Mutex::ScopedLock lock(_mutex);
+			if (error && isReadable() && _notify) readable.notify(this, f);
+			if (error && isWritable() && _notify) writable.notify(this, f);
+			_error = error;
+			_used = 0;
+		}
+		else
+		{
+			bool t = true;
+			Mutex::ScopedLock lock(_mutex);
+			_error = false;
+			if (_notify && !_eof) writable.notify(this, t);
+		}
+	}
+
+	bool isValid() const
+		/// Returns true if error flag is not set on the buffer,
+		/// otherwise returns false.
+	{
+		return !_error;
+	}
+
+	void setEOF(bool eof = true)
+		/// Sets end-of-file flag on the buffer.
+		/// 
+		/// Setting EOF flag to true prevents writing to the
+		/// buffer; reading from the buffer will still be
+		/// allowed until all data present in the buffer at the 
+		/// EOF set time is drained. After that, to re-enable 
+		/// FIFOBuffer for reading/writing, EOF must be
+		/// set to false.
+		/// 
+		/// Setting EOF flag to false clears EOF state if it
+		/// was previously set. If EOF was not set, it has no
+		/// effect.
+	{
+		Mutex::ScopedLock lock(_mutex);
+		bool flag = !eof;
+		if (_notify) writable.notify(this, flag);
+		_eof = eof;
+	}
+
+	bool hasEOF() const
+		/// Returns true if EOF flag has been set.
+	{
+		return _eof;
+	}
+
+	bool isEOF() const
+		/// Returns true if EOF flag has been set and buffer is empty.
+	{
+		return isEmpty() && _eof;
+	}
+
+	bool isEmpty() const
+		/// Returns true is buffer is empty, false otherwise.
+	{
+		return 0 == _used;
+	}
+
+	bool isFull() const
+		/// Returns true is buffer is full, false otherwise.
+	{
+		return size() == _used;
+	}
+
+	bool isReadable() const
+		/// Returns true if buffer contains data and is not
+		/// in error state.
+	{
+		return !isEmpty() && isValid();
+	}
+
+	bool isWritable() const
+		/// Returns true if buffer is not full and is not
+		/// in error state.
+	{
+		return !isFull() && isValid() && !_eof;
+	}
+
+	void setNotify(bool notify = true)
+		/// Enables/disables notifications.
+	{
+		_notify = notify;
+	}
+
+	bool getNotify() const
+		/// Returns true if notifications are enabled, false otherwise.
+	{
+		return _notify;
+	}
+
+	Mutex& mutex()
+		/// Returns reference to mutex.
+	{
+		return _mutex;
+	}
+
+private:
+	void notify(std::size_t usedBefore)
+	{
+		bool t = true, f = false;
+		if (usedBefore == 0 && _used > 0)
+			readable.notify(this, t);
+		else if (usedBefore > 0 && 0 == _used)
+			readable.notify(this, f);
+		
+		if (usedBefore == _buffer.size() && _used < _buffer.size())
+			writable.notify(this, t);
+		else if (usedBefore < _buffer.size() && _used == _buffer.size())
+			writable.notify(this, f);
+	}
+
+	BasicFIFOBuffer();
+	BasicFIFOBuffer(const BasicFIFOBuffer&);
+	BasicFIFOBuffer& operator = (const BasicFIFOBuffer&);
+
+	Buffer<T>     _buffer;
+	std::size_t   _begin;
+	std::size_t   _used;
+	bool          _notify;
+	mutable Mutex _mutex;
+	bool          _eof;
+	bool          _error;
+};
+
+
+//
+// We provide an instantiation for char
+//
+typedef BasicFIFOBuffer<char> FIFOBuffer;
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FIFOBuffer_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FIFOBufferStream.h b/base/poco/Foundation/include/Poco/FIFOBufferStream.h
new file mode 100644
index 00000000000..6c1e1eb7872
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FIFOBufferStream.h
@@ -0,0 +1,154 @@
+//
+// FIFOBufferStream.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  FIFOBufferStream
+//
+// Definition of the FIFOBufferStream class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FIFOBufferStream_INCLUDED
+#define Foundation_FIFOBufferStream_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/FIFOBuffer.h"
+#include "Poco/BufferedBidirectionalStreamBuf.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+
+
+class Foundation_API FIFOBufferStreamBuf: public BufferedBidirectionalStreamBuf
+	/// This is the streambuf class used for reading from and writing to a FIFOBuffer.
+	/// FIFOBuffer is enabled for emtpy/non-empty/full state transitions notifications.
+{
+public:
+	
+	FIFOBufferStreamBuf();
+		/// Creates a FIFOBufferStreamBuf.
+
+	explicit FIFOBufferStreamBuf(FIFOBuffer& fifoBuffer);
+		/// Creates a FIFOBufferStreamBuf and assigns the given buffer to it.
+
+	FIFOBufferStreamBuf(char* pBuffer, std::size_t length);
+		/// Creates a FIFOBufferStreamBuf and assigns the given buffer to it.
+
+	FIFOBufferStreamBuf(const char* pBuffer, std::size_t length);
+		/// Creates a FIFOBufferStreamBuf and assigns the given buffer to it.
+
+	explicit FIFOBufferStreamBuf(std::size_t length);
+		/// Creates a FIFOBufferStreamBuf of the given length.
+
+	~FIFOBufferStreamBuf();
+		/// Destroys the FIFOBufferStreamBuf.
+
+	FIFOBuffer& fifoBuffer();
+		/// Returns the underlying FIFO buffer reference.
+
+protected:
+	int readFromDevice(char* buffer, std::streamsize length);
+	int writeToDevice(const char* buffer, std::streamsize length);
+
+private:
+	enum 
+	{
+		STREAM_BUFFER_SIZE = 1024
+	};
+
+	FIFOBuffer* _pFIFOBuffer;
+	FIFOBuffer& _fifoBuffer;
+};
+
+
+class Foundation_API FIFOIOS: public virtual std::ios
+	/// The base class for FIFOBufferInputStream and
+	/// FIFOBufferStream.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	explicit FIFOIOS(FIFOBuffer& buffer);
+		/// Creates a FIFOIOS and assigns the given buffer to it.
+
+	FIFOIOS(char* pBuffer, std::size_t length);
+		/// Creates a FIFOIOS and assigns the given buffer to it.
+
+	FIFOIOS(const char* pBuffer, std::size_t length);
+		/// Creates a FIFOIOS and assigns the given buffer to it.
+
+	explicit FIFOIOS(std::size_t length);
+		/// Creates a FIFOIOS of the given length.
+		
+	~FIFOIOS();
+		/// Destroys the FIFOIOS.
+		///
+		/// Flushes the buffer.
+		
+	FIFOBufferStreamBuf* rdbuf();
+		/// Returns a pointer to the internal FIFOBufferStreamBuf.
+		
+	void close();
+		/// Flushes the stream.
+
+protected:
+	FIFOBufferStreamBuf _buf;
+};
+
+
+class Foundation_API FIFOBufferStream: public FIFOIOS, public std::iostream
+	/// An output stream for writing to a FIFO.
+{
+public:
+	Poco::BasicEvent<bool>& readable;
+	Poco::BasicEvent<bool>& writable;
+
+	explicit FIFOBufferStream(FIFOBuffer& buffer);
+		/// Creates the FIFOBufferStream with supplied buffer as initial value.
+
+	FIFOBufferStream(char* pBuffer, std::size_t length);
+		/// Creates a FIFOBufferStream and assigns the given buffer to it.
+
+	FIFOBufferStream(const char* pBuffer, std::size_t length);
+		/// Creates a FIFOBufferStream and assigns the given buffer to it.
+
+	explicit FIFOBufferStream(std::size_t length);
+		/// Creates a FIFOBufferStream of the given length.
+
+	~FIFOBufferStream();
+		/// Destroys the FIFOBufferStream.
+		///
+		/// Flushes the buffer.
+
+private:
+	FIFOBufferStream();
+	FIFOBufferStream(const FIFOBufferStream& other);
+	FIFOBufferStream& operator =(const FIFOBufferStream& other);
+};
+
+
+///
+/// inlines
+///
+
+
+inline FIFOBuffer& FIFOBufferStreamBuf::fifoBuffer()
+{
+	return _fifoBuffer;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FIFOBufferStream_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FIFOEvent.h b/base/poco/Foundation/include/Poco/FIFOEvent.h
new file mode 100644
index 00000000000..404044c3922
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FIFOEvent.h
@@ -0,0 +1,63 @@
+//
+// FIFOEvent.h
+//
+// Library: Foundation
+// Package: Events
+// Module:  FIFOEvent
+//
+// Implementation of the FIFOEvent template.
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FIFOEvent_INCLUDED
+#define Foundation_FIFOEvent_INCLUDED
+
+
+#include "Poco/AbstractEvent.h"
+#include "Poco/FIFOStrategy.h"
+#include "Poco/AbstractDelegate.h"
+
+
+namespace Poco {
+
+
+//@ deprecated
+template <class TArgs, class TMutex = FastMutex> 
+class FIFOEvent: public AbstractEvent < 
+	TArgs, 
+	FIFOStrategy<TArgs, AbstractDelegate<TArgs> >,
+	AbstractDelegate<TArgs>,
+	TMutex
+>
+	/// A FIFOEvent uses internally a FIFOStrategy which guarantees
+	/// that delegates are invoked in the order they were added to
+	/// the event.
+	///
+	/// Note that as of release 1.4.2, this is the default behavior
+	/// implemented by BasicEvent, so this class is provided
+	/// for backwards compatibility only.
+{
+public:
+	FIFOEvent()
+	{
+	}
+
+	~FIFOEvent()
+	{
+	}
+
+private:
+	FIFOEvent(const FIFOEvent& e);
+	FIFOEvent& operator = (const FIFOEvent& e);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FIFOEvent_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FIFOStrategy.h b/base/poco/Foundation/include/Poco/FIFOStrategy.h
new file mode 100644
index 00000000000..79c2276043a
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FIFOStrategy.h
@@ -0,0 +1,59 @@
+//
+// FIFOStrategy.h
+//
+// Library: Foundation
+// Package: Events
+// Module:  FIFOStragegy
+//
+// Implementation of the FIFOStrategy template.
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FIFOStrategy_INCLUDED
+#define Foundation_FIFOStrategy_INCLUDED
+
+
+#include "Poco/DefaultStrategy.h"
+
+
+namespace Poco {
+
+
+//@ deprecated
+template <class TArgs, class TDelegate> 
+class FIFOStrategy: public DefaultStrategy<TArgs, TDelegate>
+	/// Note: As of release 1.4.2, DefaultStrategy already 
+	/// implements FIFO behavior, so this class is provided
+	/// for backwards compatibility only.
+{
+public:
+	FIFOStrategy()
+	{
+	}
+
+	FIFOStrategy(const FIFOStrategy& s):
+		DefaultStrategy<TArgs, TDelegate>(s)
+	{
+	}
+
+	~FIFOStrategy()
+	{
+	}
+
+	FIFOStrategy& operator = (const FIFOStrategy& s)
+	{
+		DefaultStrategy<TArgs, TDelegate>::operator = (s);
+		return *this;
+	}
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FIFOStrategy_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FPEnvironment.h b/base/poco/Foundation/include/Poco/FPEnvironment.h
new file mode 100644
index 00000000000..4602f57f91e
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FPEnvironment.h
@@ -0,0 +1,207 @@
+//
+// FPEnvironment.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  FPEnvironment
+//
+// Definitions of class FPEnvironment.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FPEnvironment_INCLUDED
+#define Foundation_FPEnvironment_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+#if defined(POCO_NO_FPENVIRONMENT)
+#include "Poco/FPEnvironment_DUMMY.h"
+#elif defined(__osf__)
+#include "Poco/FPEnvironment_DEC.h"
+#elif defined(sun) || defined(__sun)
+#include "Poco/FPEnvironment_SUN.h"
+#elif defined(__QNX__)
+#include "Poco/FPEnvironment_QNX.h"
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include "Poco/FPEnvironment_C99.h"
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "Poco/FPEnvironment_WIN32.h"
+#else
+#include "Poco/FPEnvironment_DUMMY.h"
+#endif
+
+
+namespace Poco {
+
+
+class Foundation_API FPEnvironment: private FPEnvironmentImpl
+	/// Instances of this class can be used to save
+	/// and later restore the current floating
+	/// point environment (consisting of rounding
+	/// mode and floating-point flags).
+	/// The class also provides various static
+	/// methods to query certain properties
+	/// of a floating-point number.
+{
+public:
+	enum RoundingMode
+	{
+		FP_ROUND_DOWNWARD   = FP_ROUND_DOWNWARD_IMPL,
+		FP_ROUND_UPWARD     = FP_ROUND_UPWARD_IMPL,
+		FP_ROUND_TONEAREST  = FP_ROUND_TONEAREST_IMPL,
+		FP_ROUND_TOWARDZERO = FP_ROUND_TOWARDZERO_IMPL
+	};
+
+	enum Flag
+	{
+		FP_DIVIDE_BY_ZERO = FP_DIVIDE_BY_ZERO_IMPL,
+		FP_INEXACT        = FP_INEXACT_IMPL,
+		FP_OVERFLOW       = FP_OVERFLOW_IMPL,
+		FP_UNDERFLOW      = FP_UNDERFLOW_IMPL,
+		FP_INVALID        = FP_INVALID_IMPL
+	};
+
+	FPEnvironment();
+		/// Standard constructor.
+		/// Remembers the current environment.
+
+	FPEnvironment(RoundingMode mode);
+		/// Remembers the current environment and
+		/// sets the given rounding mode.
+
+	FPEnvironment(const FPEnvironment& env);
+		/// Copy constructor.
+
+	~FPEnvironment();
+		/// Restores the previous environment (unless
+		/// keepCurrent() has been called previously)
+
+	FPEnvironment& operator = (const FPEnvironment& env);
+		/// Assignment operator
+
+	void keepCurrent();
+		/// Keep the current environment even after
+		/// destroying the FPEnvironment object.
+
+	static void clearFlags();
+		/// Resets all flags.
+
+	static bool isFlag(Flag flag);
+		/// Returns true iff the given flag is set.
+
+	static void setRoundingMode(RoundingMode mode);
+		/// Sets the rounding mode.
+
+	static RoundingMode getRoundingMode();
+		/// Returns the current rounding mode.
+
+	static bool isInfinite(float value);
+	static bool isInfinite(double value);
+	static bool isInfinite(long double value);
+		/// Returns true iff the given number is infinite.
+
+	static bool isNaN(float value);
+	static bool isNaN(double value);
+	static bool isNaN(long double value);
+		/// Returns true iff the given number is NaN.
+
+	static float copySign(float target, float source);
+	static double copySign(double target, double source);
+	static long double copySign(long double target, long double source);
+		/// Copies the sign from source to target.
+};
+
+
+//
+// For convenience, we provide a shorter name for
+// the FPEnvironment class.
+//
+typedef FPEnvironment FPE;
+
+
+//
+// inline's
+//
+inline bool FPEnvironment::isFlag(Flag flag)
+{
+	return isFlagImpl(FlagImpl(flag));
+}
+
+
+inline void FPEnvironment::setRoundingMode(RoundingMode mode)
+{
+	setRoundingModeImpl(RoundingModeImpl(mode));
+}
+
+
+inline FPEnvironment::RoundingMode FPEnvironment::getRoundingMode()
+{
+	return RoundingMode(getRoundingModeImpl());
+}
+
+
+inline bool FPEnvironment::isInfinite(float value)
+{
+	return isInfiniteImpl(value);
+}
+
+
+inline bool FPEnvironment::isInfinite(double value)
+{
+	return isInfiniteImpl(value);
+}
+
+
+inline bool FPEnvironment::isInfinite(long double value)
+{
+	return isInfiniteImpl(value);
+}
+
+
+inline bool FPEnvironment::isNaN(float value)
+{
+	return isNaNImpl(value);
+}
+
+
+inline bool FPEnvironment::isNaN(double value)
+{
+	return isNaNImpl(value);
+}
+
+
+inline bool FPEnvironment::isNaN(long double value)
+{
+	return isNaNImpl(value);
+}
+
+
+inline float FPEnvironment::copySign(float target, float source)
+{
+	return copySignImpl(target, source);
+}
+
+
+inline double FPEnvironment::copySign(double target, double source)
+{
+	return copySignImpl(target, source);
+}
+
+
+inline long double FPEnvironment::copySign(long double target, long double source)
+{
+	return copySignImpl(target, source);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FPEnvironment_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FPEnvironment_C99.h b/base/poco/Foundation/include/Poco/FPEnvironment_C99.h
new file mode 100644
index 00000000000..0b192f5a1ca
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FPEnvironment_C99.h
@@ -0,0 +1,125 @@
+//
+// FPEnvironment_C99.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  FPEnvironment
+//
+// Definitions of class FPEnvironmentImpl for C99.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FPEnvironment_C99_INCLUDED
+#define Foundation_FPEnvironment_C99_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <fenv.h>
+#include <cmath>
+
+
+namespace Poco {
+
+
+class FPEnvironmentImpl
+{
+protected:
+	enum RoundingModeImpl
+	{
+		FP_ROUND_DOWNWARD_IMPL   = FE_DOWNWARD,
+		FP_ROUND_UPWARD_IMPL     = FE_UPWARD,
+		FP_ROUND_TONEAREST_IMPL  = FE_TONEAREST,
+		FP_ROUND_TOWARDZERO_IMPL = FE_TOWARDZERO
+	};
+	enum FlagImpl
+	{
+		FP_DIVIDE_BY_ZERO_IMPL = FE_DIVBYZERO,
+		FP_INEXACT_IMPL        = FE_INEXACT,
+		FP_OVERFLOW_IMPL       = FE_OVERFLOW,
+		FP_UNDERFLOW_IMPL      = FE_UNDERFLOW,
+		FP_INVALID_IMPL        = FE_INVALID
+	};
+	FPEnvironmentImpl();
+	FPEnvironmentImpl(const FPEnvironmentImpl& env);
+	~FPEnvironmentImpl();
+	FPEnvironmentImpl& operator = (const FPEnvironmentImpl& env);
+	void keepCurrentImpl();		
+	static void clearFlagsImpl();
+	static bool isFlagImpl(FlagImpl flag);	
+	static void setRoundingModeImpl(RoundingModeImpl mode);
+	static RoundingModeImpl getRoundingModeImpl();
+	static bool isInfiniteImpl(float value);		
+	static bool isInfiniteImpl(double value);
+	static bool isInfiniteImpl(long double value);
+	static bool isNaNImpl(float value);		
+	static bool isNaNImpl(double value);
+	static bool isNaNImpl(long double value);
+	static float copySignImpl(float target, float source);		
+	static double copySignImpl(double target, double source);
+	static long double copySignImpl(long double target, long double source);
+
+private:
+	fenv_t _env;
+};
+
+
+//
+// inlines
+//
+inline bool FPEnvironmentImpl::isInfiniteImpl(float value)
+{
+	return std::isinf(value) != 0;
+}
+
+
+inline bool FPEnvironmentImpl::isInfiniteImpl(double value)
+{
+	return std::isinf(value) != 0;
+}
+
+
+inline bool FPEnvironmentImpl::isInfiniteImpl(long double value)
+{
+	return std::isinf((double) value) != 0;
+}
+
+
+inline bool FPEnvironmentImpl::isNaNImpl(float value)
+{
+	return std::isnan(value) != 0;
+}
+
+
+inline bool FPEnvironmentImpl::isNaNImpl(double value)
+{
+	return std::isnan(value) != 0;
+}
+
+
+inline bool FPEnvironmentImpl::isNaNImpl(long double value)
+{
+	return std::isnan((double) value) != 0;
+}
+
+
+inline float FPEnvironmentImpl::copySignImpl(float target, float source)
+{
+	return copysignf(target, source);
+}
+
+
+inline double FPEnvironmentImpl::copySignImpl(double target, double source)
+{
+	return copysign(target, source);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FPEnvironment_C99_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FPEnvironment_DEC.h b/base/poco/Foundation/include/Poco/FPEnvironment_DEC.h
new file mode 100644
index 00000000000..b55794a519d
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FPEnvironment_DEC.h
@@ -0,0 +1,89 @@
+//
+// FPEnvironment_DEC.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  FPEnvironment
+//
+// Definitions of class FPEnvironmentImpl for Tru64 and OpenVMS Alpha.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FPEnvironment_DEC_INCLUDED
+#define Foundation_FPEnvironment_DEC_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#if defined(__VMS)
+#include <ieeedef.h>
+#else
+#include <machine/fpu.h>
+#endif
+
+
+namespace Poco {
+
+
+class FPEnvironmentImpl
+{
+protected:
+	enum RoundingModeImpl
+	{
+		FP_ROUND_DOWNWARD_IMPL   = 0,
+		FP_ROUND_UPWARD_IMPL     = 0,
+		FP_ROUND_TONEAREST_IMPL  = 0,
+		FP_ROUND_TOWARDZERO_IMPL = 0
+	};
+	enum FlagImpl
+	{
+#if defined(__VMS)
+		FP_DIVIDE_BY_ZERO_IMPL = IEEE$M_STATUS_DZE,
+		FP_INEXACT_IMPL        = IEEE$M_STATUS_INE,
+		FP_OVERFLOW_IMPL       = IEEE$M_STATUS_OVF,
+		FP_UNDERFLOW_IMPL      = IEEE$M_STATUS_UNF,
+		FP_INVALID_IMPL        = IEEE$M_STATUS_INV
+#else
+		FP_DIVIDE_BY_ZERO_IMPL = IEEE_STATUS_DZE,
+		FP_INEXACT_IMPL        = IEEE_STATUS_INE,
+		FP_OVERFLOW_IMPL       = IEEE_STATUS_OVF,
+		FP_UNDERFLOW_IMPL      = IEEE_STATUS_UNF,
+		FP_INVALID_IMPL        = IEEE_STATUS_INV
+#endif
+	};
+	FPEnvironmentImpl();
+	FPEnvironmentImpl(const FPEnvironmentImpl& env);
+	~FPEnvironmentImpl();
+	FPEnvironmentImpl& operator = (const FPEnvironmentImpl& env);
+	void keepCurrentImpl();		
+	static void clearFlagsImpl();
+	static bool isFlagImpl(FlagImpl flag);	
+	static void setRoundingModeImpl(RoundingModeImpl mode);
+	static RoundingModeImpl getRoundingModeImpl();
+	static bool isInfiniteImpl(float value);		
+	static bool isInfiniteImpl(double value);
+	static bool isInfiniteImpl(long double value);
+	static bool isNaNImpl(float value);		
+	static bool isNaNImpl(double value);
+	static bool isNaNImpl(long double value);
+	static float copySignImpl(float target, float source);		
+	static double copySignImpl(double target, double source);
+	static long double copySignImpl(long double target, long double source);
+
+private:
+#if defined(__VMS)
+	struct _ieee _env;
+#else
+	unsigned long _env;
+#endif
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FPEnvironment_DEC_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FPEnvironment_DUMMY.h b/base/poco/Foundation/include/Poco/FPEnvironment_DUMMY.h
new file mode 100644
index 00000000000..5571c128c2c
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FPEnvironment_DUMMY.h
@@ -0,0 +1,125 @@
+//
+// FPEnvironment_DUMMY.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  FPEnvironment
+//
+// Definition of class FPEnvironmentImpl for platforms that do not
+// support IEEE 754 extensions.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FPEnvironment_DUMMY_INCLUDED
+#define Foundation_FPEnvironment_DUMMY_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <cmath>
+
+
+namespace Poco {
+
+
+class Foundation_API FPEnvironmentImpl
+{
+protected:
+	enum RoundingModeImpl
+	{
+		FP_ROUND_DOWNWARD_IMPL,
+		FP_ROUND_UPWARD_IMPL,
+		FP_ROUND_TONEAREST_IMPL,
+		FP_ROUND_TOWARDZERO_IMPL
+	};
+	enum FlagImpl
+	{
+		FP_DIVIDE_BY_ZERO_IMPL,
+		FP_INEXACT_IMPL,
+		FP_OVERFLOW_IMPL,
+		FP_UNDERFLOW_IMPL,
+		FP_INVALID_IMPL
+	};
+	FPEnvironmentImpl();
+	FPEnvironmentImpl(const FPEnvironmentImpl& env);
+	~FPEnvironmentImpl();
+	FPEnvironmentImpl& operator = (const FPEnvironmentImpl& env);
+	void keepCurrentImpl();
+	static void clearFlagsImpl();
+	static bool isFlagImpl(FlagImpl flag);
+	static void setRoundingModeImpl(RoundingModeImpl mode);
+	static RoundingModeImpl getRoundingModeImpl();
+	static bool isInfiniteImpl(float value);
+	static bool isInfiniteImpl(double value);
+	static bool isInfiniteImpl(long double value);
+	static bool isNaNImpl(float value);
+	static bool isNaNImpl(double value);
+	static bool isNaNImpl(long double value);
+	static float copySignImpl(float target, float source);
+	static double copySignImpl(double target, double source);
+	static long double copySignImpl(long double target, long double source);
+
+private:
+	static RoundingModeImpl _roundingMode;
+};
+
+
+//
+// inlines
+//
+inline bool FPEnvironmentImpl::isInfiniteImpl(float value)
+{
+	return std::isinf(value) != 0;
+}
+
+
+inline bool FPEnvironmentImpl::isInfiniteImpl(double value)
+{
+	return std::isinf(value) != 0;
+}
+
+
+inline bool FPEnvironmentImpl::isInfiniteImpl(long double value)
+{
+	return std::isinf((double) value) != 0;
+}
+
+
+inline bool FPEnvironmentImpl::isNaNImpl(float value)
+{
+	return std::isnan(value) != 0;
+}
+
+
+inline bool FPEnvironmentImpl::isNaNImpl(double value)
+{
+	return std::isnan(value) != 0;
+}
+
+
+inline bool FPEnvironmentImpl::isNaNImpl(long double value)
+{
+	return std::isnan((double) value) != 0;
+}
+
+
+inline float FPEnvironmentImpl::copySignImpl(float target, float source)
+{
+	return copysignf(target, source);
+}
+
+
+inline double FPEnvironmentImpl::copySignImpl(double target, double source)
+{
+	return copysign(target, source);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FPEnvironment_DUMMY_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FPEnvironment_QNX.h b/base/poco/Foundation/include/Poco/FPEnvironment_QNX.h
new file mode 100644
index 00000000000..1eef8259d32
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FPEnvironment_QNX.h
@@ -0,0 +1,133 @@
+//
+// FPEnvironment_QNX.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  FPEnvironment
+//
+// Definitions of class FPEnvironmentImpl for QNX.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FPEnvironment_QNX_INCLUDED
+#define Foundation_FPEnvironment_QNX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <fenv.h>
+#include <cmath>
+
+
+namespace Poco {
+
+
+class FPEnvironmentImpl
+{
+protected:
+	enum RoundingModeImpl
+	{
+		FP_ROUND_DOWNWARD_IMPL   = FE_DOWNWARD,
+		FP_ROUND_UPWARD_IMPL     = FE_UPWARD,
+		FP_ROUND_TONEAREST_IMPL  = FE_TONEAREST,
+		FP_ROUND_TOWARDZERO_IMPL = FE_TOWARDZERO
+	};
+	enum FlagImpl
+	{
+		FP_DIVIDE_BY_ZERO_IMPL = FE_DIVBYZERO,
+		FP_INEXACT_IMPL        = FE_INEXACT,
+		FP_OVERFLOW_IMPL       = FE_OVERFLOW,
+		FP_UNDERFLOW_IMPL      = FE_UNDERFLOW,
+		FP_INVALID_IMPL        = FE_INVALID
+	};
+	FPEnvironmentImpl();
+	FPEnvironmentImpl(const FPEnvironmentImpl& env);
+	~FPEnvironmentImpl();
+	FPEnvironmentImpl& operator = (const FPEnvironmentImpl& env);
+	void keepCurrentImpl();		
+	static void clearFlagsImpl();
+	static bool isFlagImpl(FlagImpl flag);	
+	static void setRoundingModeImpl(RoundingModeImpl mode);
+	static RoundingModeImpl getRoundingModeImpl();
+	static bool isInfiniteImpl(float value);		
+	static bool isInfiniteImpl(double value);
+	static bool isInfiniteImpl(long double value);
+	static bool isNaNImpl(float value);		
+	static bool isNaNImpl(double value);
+	static bool isNaNImpl(long double value);
+	static float copySignImpl(float target, float source);		
+	static double copySignImpl(double target, double source);
+	static long double copySignImpl(long double target, long double source);
+
+private:
+	fenv_t _env;
+};
+
+
+//
+// inlines
+//
+inline bool FPEnvironmentImpl::isInfiniteImpl(float value)
+{
+	using namespace std;
+	return isinf(value) != 0;
+}
+
+
+inline bool FPEnvironmentImpl::isInfiniteImpl(double value)
+{
+	using namespace std;
+	return isinf(value) != 0;
+}
+
+
+inline bool FPEnvironmentImpl::isInfiniteImpl(long double value)
+{
+	using namespace std;
+	return isinf((double) value) != 0;
+}
+
+
+inline bool FPEnvironmentImpl::isNaNImpl(float value)
+{
+	using namespace std;
+	return isnan(value) != 0;
+}
+
+
+inline bool FPEnvironmentImpl::isNaNImpl(double value)
+{
+	using namespace std;
+	return isnan(value) != 0;
+}
+
+
+inline bool FPEnvironmentImpl::isNaNImpl(long double value)
+{
+	using namespace std;
+	return isnan((double) value) != 0;
+}
+
+
+inline float FPEnvironmentImpl::copySignImpl(float target, float source)
+{
+	using namespace std;
+	return copysignf(target, source);
+}
+
+
+inline double FPEnvironmentImpl::copySignImpl(double target, double source)
+{
+	using namespace std;
+	return copysign(target, source);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FPEnvironment_QNX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FPEnvironment_SUN.h b/base/poco/Foundation/include/Poco/FPEnvironment_SUN.h
new file mode 100644
index 00000000000..d9755006d69
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FPEnvironment_SUN.h
@@ -0,0 +1,74 @@
+//
+// FPEnvironment_SUN.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  FPEnvironment
+//
+// Definitions of class FPEnvironmentImpl for Solaris.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FPEnvironment_SUN_INCLUDED
+#define Foundation_FPEnvironment_SUN_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <ieeefp.h>
+
+
+namespace Poco {
+
+
+class FPEnvironmentImpl
+{
+protected:
+	enum RoundingModeImpl
+	{
+		FP_ROUND_DOWNWARD_IMPL   = FP_RM,
+		FP_ROUND_UPWARD_IMPL     = FP_RP,
+		FP_ROUND_TONEAREST_IMPL  = FP_RN,
+		FP_ROUND_TOWARDZERO_IMPL = FP_RZ
+	};
+	enum FlagImpl
+	{
+		FP_DIVIDE_BY_ZERO_IMPL = FP_X_DZ,
+		FP_INEXACT_IMPL        = FP_X_IMP,
+		FP_OVERFLOW_IMPL       = FP_X_OFL,
+		FP_UNDERFLOW_IMPL      = FP_X_UFL,
+		FP_INVALID_IMPL        = FP_X_INV
+	};
+	FPEnvironmentImpl();
+	FPEnvironmentImpl(const FPEnvironmentImpl& env);
+	~FPEnvironmentImpl();
+	FPEnvironmentImpl& operator = (const FPEnvironmentImpl& env);
+	void keepCurrentImpl();		
+	static void clearFlagsImpl();
+	static bool isFlagImpl(FlagImpl flag);	
+	static void setRoundingModeImpl(RoundingModeImpl mode);
+	static RoundingModeImpl getRoundingModeImpl();
+	static bool isInfiniteImpl(float value);		
+	static bool isInfiniteImpl(double value);
+	static bool isInfiniteImpl(long double value);
+	static bool isNaNImpl(float value);		
+	static bool isNaNImpl(double value);
+	static bool isNaNImpl(long double value);
+	static float copySignImpl(float target, float source);		
+	static double copySignImpl(double target, double source);
+	static long double copySignImpl(long double target, long double source);
+
+private:
+	fp_rnd    _rnd;
+	fp_except _exc;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FPEnvironment_SUN_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FPEnvironment_WIN32.h b/base/poco/Foundation/include/Poco/FPEnvironment_WIN32.h
new file mode 100644
index 00000000000..2c46ce76333
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FPEnvironment_WIN32.h
@@ -0,0 +1,150 @@
+//
+// FPEnvironment_WIN32.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  FPEnvironment
+//
+// Definitions of class FPEnvironmentImpl for WIN32.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FPEnvironment_WIN32_INCLUDED
+#define Foundation_FPEnvironment_WIN32_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <float.h>
+#include <math.h>
+
+#ifndef _SW_INEXACT
+#	define _SW_INEXACT 0x00000001 // inexact (precision)
+#endif
+#ifndef _SW_UNDERFLOW
+#	define _SW_UNDERFLOW 0x00000002 // underflow
+#endif
+#ifndef _SW_OVERFLOW
+#	define _SW_OVERFLOW 0x00000004 // overflow
+#endif
+#ifndef _SW_ZERODIVIDE
+#	define _SW_ZERODIVIDE 0x00000008 // zero divide
+#endif
+#ifndef _SW_INVALID
+#	define _SW_INVALID 0x00000010 // invalid
+#endif
+#ifndef _SW_DENORMAL
+#	define _SW_DENORMAL 0x00080000 // denormal status bit
+#endif
+
+
+namespace Poco {
+
+
+class Foundation_API FPEnvironmentImpl
+{
+protected:
+	enum RoundingModeImpl
+	{
+		FP_ROUND_DOWNWARD_IMPL   = _RC_DOWN,
+		FP_ROUND_UPWARD_IMPL     = _RC_UP,
+		FP_ROUND_TONEAREST_IMPL  = _RC_NEAR,
+		FP_ROUND_TOWARDZERO_IMPL = _RC_CHOP
+	};
+	enum FlagImpl
+	{
+		FP_DIVIDE_BY_ZERO_IMPL = _SW_ZERODIVIDE,
+		FP_INEXACT_IMPL        = _SW_INEXACT,
+		FP_OVERFLOW_IMPL       = _SW_OVERFLOW,
+		FP_UNDERFLOW_IMPL      = _SW_UNDERFLOW,
+		FP_INVALID_IMPL        = _SW_INVALID
+	};
+	FPEnvironmentImpl();
+	FPEnvironmentImpl(const FPEnvironmentImpl& env);
+	~FPEnvironmentImpl();
+	FPEnvironmentImpl& operator = (const FPEnvironmentImpl& env);
+	void keepCurrentImpl();
+	static void clearFlagsImpl();
+	static bool isFlagImpl(FlagImpl flag);	
+	static void setRoundingModeImpl(RoundingModeImpl mode);
+	static RoundingModeImpl getRoundingModeImpl();
+	static bool isInfiniteImpl(float value);		
+	static bool isInfiniteImpl(double value);
+	static bool isInfiniteImpl(long double value);
+	static bool isNaNImpl(float value);		
+	static bool isNaNImpl(double value);
+	static bool isNaNImpl(long double value);
+	static float copySignImpl(float target, float source);		
+	static double copySignImpl(double target, double source);
+	static long double copySignImpl(long double target, long double source);
+
+private:
+	unsigned _env;
+};
+
+
+//
+// inlines
+//
+inline bool FPEnvironmentImpl::isInfiniteImpl(float value)
+{
+	return _finite(value) == 0;
+}
+
+
+inline bool FPEnvironmentImpl::isInfiniteImpl(double value)
+{
+	return _finite(value) == 0;
+}
+
+
+inline bool FPEnvironmentImpl::isInfiniteImpl(long double value)
+{
+	return _finite(value) == 0;
+}
+
+
+inline bool FPEnvironmentImpl::isNaNImpl(float value)
+{
+	return _isnan(value) != 0;
+}
+
+
+inline bool FPEnvironmentImpl::isNaNImpl(double value)
+{
+	return _isnan(value) != 0;
+}
+
+
+inline bool FPEnvironmentImpl::isNaNImpl(long double value)
+{
+	return _isnan(value) != 0;
+}
+
+
+inline float FPEnvironmentImpl::copySignImpl(float target, float source)
+{
+	return float(_copysign(target, source));
+}
+
+
+inline double FPEnvironmentImpl::copySignImpl(double target, double source)
+{
+	return _copysign(target, source);
+}
+
+
+inline long double FPEnvironmentImpl::copySignImpl(long double target, long double source)
+{
+	return (source > 0 && target > 0) || (source < 0 && target < 0) ? target : -target;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FPEnvironment_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/File.h b/base/poco/Foundation/include/Poco/File.h
new file mode 100644
index 00000000000..afecf321261
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/File.h
@@ -0,0 +1,315 @@
+//
+// File.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  File
+//
+// Definition of the File class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_File_INCLUDED
+#define Foundation_File_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Timestamp.h"
+#include <vector>
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS) && defined(POCO_WIN32_UTF8)
+#if defined(_WIN32_WCE)
+#include "File_WINCE.h"
+#else
+#include "Poco/File_WIN32U.h"
+#endif
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "Poco/File_WIN32.h"
+#elif defined(POCO_VXWORKS)
+#include "Poco/File_VX.h"
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include "Poco/File_UNIX.h"
+#endif
+
+
+namespace Poco {
+
+
+class Path;
+
+
+class Foundation_API File: private FileImpl
+	/// The File class provides methods for working with a file.
+	///
+	/// Regarding paths passed to the various methods, note that
+	/// platform-specific limitations regarding maximum length
+	/// of the entire path and its components apply.
+	///
+	/// On Windows, if compiled with UTF-8 support (POCO_WIN32_UTF8)
+	/// the implementation tries to work around the rather low
+	/// 260 characters MAX_PATH limit by adding the "\\?\" prefix if
+	/// a path is absolute and exceeds MAX_PATH characters in length.
+	/// Note that various limitations regarding usage of the "\\?\"
+	/// prefix apply in that case, e.g. the path must
+	/// not contain relative components ("." and "..") and must not
+	/// use the forward slash ("/") as directory separator.
+{
+public:
+	typedef FileSizeImpl FileSize;
+
+	enum LinkType
+		/// Type of link for linkTo().
+	{
+		LINK_HARD     = 0, /// hard link
+		LINK_SYMBOLIC = 1  /// symbolic link
+	};
+
+	File();
+		/// Creates the file.
+
+	File(const std::string& path);
+		/// Creates the file.
+
+	File(const char* path);
+		/// Creates the file.
+
+	File(const Path& path);
+		/// Creates the file.
+
+	File(const File& file);
+		/// Copy constructor.
+
+	virtual ~File();
+		/// Destroys the file.
+
+	File& operator = (const File& file);
+		/// Assignment operator.
+
+	File& operator = (const std::string& path);
+		/// Assignment operator.
+
+	File& operator = (const char* path);
+		/// Assignment operator.
+
+	File& operator = (const Path& path);
+		/// Assignment operator.
+
+	void swap(File& file);
+		/// Swaps the file with another one.
+
+	const std::string& path() const;
+		/// Returns the path.
+
+	bool exists() const;
+		/// Returns true iff the file exists.
+
+	bool canRead() const;
+		/// Returns true iff the file is readable.
+
+	bool canWrite() const;
+		/// Returns true iff the file is writeable.
+
+	bool canExecute() const;
+		/// Returns true iff the file is executable.
+		///
+		/// On Windows, the file must have
+		/// the extension ".EXE" to be executable.
+		/// On Unix platforms, the executable permission
+		/// bit must be set.
+
+	bool isFile() const;
+		/// Returns true iff the file is a regular file.
+
+	bool isLink() const;
+		/// Returns true iff the file is a symbolic link.
+
+	bool isDirectory() const;
+		/// Returns true iff the file is a directory.
+
+	bool isDevice() const;
+		/// Returns true iff the file is a device.
+
+	bool isHidden() const;
+		/// Returns true if the file is hidden.
+		///
+		/// On Windows platforms, the file's hidden
+		/// attribute is set for this to be true.
+		///
+		/// On Unix platforms, the file name must
+		/// begin with a period for this to be true.
+
+	Timestamp created() const;
+		/// Returns the creation date of the file.
+		///
+		/// Not all platforms or filesystems (e.g. Linux and most Unix
+		/// platforms with the exception of FreeBSD and Mac OS X)
+		/// maintain the creation date of a file.
+		/// On such platforms, created() returns
+		/// the time of the last inode modification.
+
+	Timestamp getLastModified() const;
+		/// Returns the modification date of the file.
+
+	File& setLastModified(const Timestamp& ts);
+		/// Sets the modification date of the file.
+
+	FileSize getSize() const;
+		/// Returns the size of the file in bytes.
+
+	File& setSize(FileSize size);
+		/// Sets the size of the file in bytes. Can be used
+		/// to truncate a file.
+
+	File& setWriteable(bool flag = true);
+		/// Makes the file writeable (if flag is true), or
+		/// non-writeable (if flag is false) by setting the
+		/// file's flags in the filesystem accordingly.
+
+	File& setReadOnly(bool flag = true);
+		/// Makes the file non-writeable (if flag is true), or
+		/// writeable (if flag is false) by setting the
+		/// file's flags in the filesystem accordingly.
+
+	File& setExecutable(bool flag = true);
+		/// Makes the file executable (if flag is true), or
+		/// non-executable (if flag is false) by setting
+		/// the file's permission bits accordingly.
+		///
+		/// Does nothing on Windows.
+
+	void copyTo(const std::string& path) const;
+		/// Copies the file (or directory) to the given path.
+		/// The target path can be a directory.
+		///
+		/// A directory is copied recursively.
+
+	void moveTo(const std::string& path);
+		/// Copies the file (or directory) to the given path and
+		/// removes the original file. The target path can be a directory.
+
+	void renameTo(const std::string& path);
+		/// Renames the file to the new name.
+
+	void linkTo(const std::string& path, LinkType type = LINK_SYMBOLIC) const;
+		/// Creates a link (symbolic or hard, depending on type argument)
+		/// at the given path to the file or directory.
+		///
+		/// May not be supported on all platforms.
+		/// Furthermore, some operating systems do not allow creating
+		/// hard links to directories.
+
+	void remove(bool recursive = false);
+		/// Deletes the file. If recursive is true and the
+		/// file is a directory, recursively deletes all
+		/// files in the directory.
+
+	bool createFile();
+		/// Creates a new, empty file in an atomic operation.
+		/// Returns true if the file has been created and false
+		/// if the file already exists. Throws an exception if
+		/// an error occurs.
+
+	bool createDirectory();
+		/// Creates a directory. Returns true if the directory
+		/// has been created and false if it already exists.
+		/// Throws an exception if an error occurs.
+
+	void createDirectories();
+		/// Creates a directory (and all parent directories
+		/// if necessary).
+
+	void list(std::vector<std::string>& files) const;
+		/// Fills the vector with the names of all
+		/// files in the directory.
+
+	void list(std::vector<File>& files) const;
+		/// Fills the vector with the names of all
+		/// files in the directory.
+
+	FileSize totalSpace() const;
+		/// Returns the total size in bytes of the partition containing this path.
+
+	FileSize usableSpace() const;
+		/// Returns the number of usable free bytes on the partition containing this path.
+
+	FileSize freeSpace() const;
+		/// Returns the number of free bytes on the partition containing this path.
+
+	bool operator == (const File& file) const;
+	bool operator != (const File& file) const;
+	bool operator <  (const File& file) const;
+	bool operator <= (const File& file) const;
+	bool operator >  (const File& file) const;
+	bool operator >= (const File& file) const;
+
+	static void handleLastError(const std::string& path);
+		/// For internal use only. Throws an appropriate
+		/// exception for the last file-related error.
+
+protected:
+	void copyDirectory(const std::string& path) const;
+		/// Copies a directory. Used internally by copyTo().
+};
+
+
+//
+// inlines
+//
+inline const std::string& File::path() const
+{
+	return getPathImpl();
+}
+
+
+inline bool File::operator == (const File& file) const
+{
+	return getPathImpl() == file.getPathImpl();
+}
+
+
+inline bool File::operator != (const File& file) const
+{
+	return getPathImpl() != file.getPathImpl();
+}
+
+
+inline bool File::operator < (const File& file) const
+{
+	return getPathImpl() < file.getPathImpl();
+}
+
+
+inline bool File::operator <= (const File& file) const
+{
+	return getPathImpl() <= file.getPathImpl();
+}
+
+
+inline bool File::operator > (const File& file) const
+{
+	return getPathImpl() > file.getPathImpl();
+}
+
+
+inline bool File::operator >= (const File& file) const
+{
+	return getPathImpl() >= file.getPathImpl();
+}
+
+
+inline void swap(File& f1, File& f2)
+{
+	f1.swap(f2);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_File_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FileChannel.h b/base/poco/Foundation/include/Poco/FileChannel.h
new file mode 100644
index 00000000000..3068a215248
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FileChannel.h
@@ -0,0 +1,276 @@
+//
+// FileChannel.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  FileChannel
+//
+// Definition of the FileChannel class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FileChannel_INCLUDED
+#define Foundation_FileChannel_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Channel.h"
+#include "Poco/Timestamp.h"
+#include "Poco/Timespan.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+
+
+class LogFile;
+class RotateStrategy;
+class ArchiveStrategy;
+class PurgeStrategy;
+
+
+class Foundation_API FileChannel: public Channel
+	/// A Channel that writes to a file. This class supports
+	/// flexible log file rotation and archiving, as well
+	/// as automatic purging of archived log files.
+	///
+	/// Only the message's text is written, followed
+	/// by a newline.
+	///
+	/// Chain this channel to a FormattingChannel with an
+	/// appropriate Formatter to control what is in the text. 
+	///
+	/// The FileChannel support log file rotation based
+	/// on log file size or time intervals.
+	/// Archived log files can be compressed in gzip format.
+	/// Older archived files can be automatically deleted
+	/// (purged).
+	///
+	/// The rotation strategy can be specified with the
+	/// "rotation" property, which can take one of the
+	/// follwing values:
+	///
+	///   * never:         no log rotation
+	///   * [day,][hh]:mm: the file is rotated on specified day/time
+	///                    day - day is specified as long or short day name (Monday|Mon, Tuesday|Tue, ... );
+	///                          day can be omitted, in which case log is rotated every day
+	///                    hh  - valid hour range is 00-23;
+	///                          hour can be omitted, in which case log is rotated every hour
+	///                    mm  - valid minute range is 00-59;
+	///                          minute must be specified
+	///   * daily:         the file is rotated daily
+	///   * weekly:        the file is rotated every seven days
+	///   * monthly:       the file is rotated every 30 days
+	///   * <n> minutes:   the file is rotated every <n> minutes, 
+	///                    where <n> is an integer greater than zero.
+	///   * <n> hours:     the file is rotated every <n> hours, where
+	///                    <n> is an integer greater than zero.
+	///   * <n> days:      the file is rotated every <n> days, where
+	///                    <n> is an integer greater than zero.
+	///   * <n> weeks:     the file is rotated every <n> weeks, where
+	///                    <n> is an integer greater than zero.
+	///   * <n> months:    the file is rotated every <n> months, where
+	///                    <n> is an integer greater than zero and
+	///                    a month has 30 days.
+	///   * <n>:           the file is rotated when its size exceeds
+	///                    <n> bytes.
+	///   * <n> K:         the file is rotated when its size exceeds
+	///                    <n> Kilobytes.
+	///   * <n> M:         the file is rotated when its size exceeds
+	///                    <n> Megabytes.
+	///
+	/// NOTE: For periodic log file rotation (daily, weekly, monthly, etc.),
+	/// the date and time of log file creation or last rotation is
+	/// written into the first line of the log file. This is because
+	/// there is no reliable way to find out the real creation date of
+	/// a file on many platforms (e.g., most Unix platforms do not
+	/// provide the creation date, and Windows has its own issues
+	/// with its "File System Tunneling Capabilities").
+	///
+	/// Using the "archive" property it is possible to specify
+	/// how archived log files are named. The following values
+	/// for the "archive" property are supported:
+	///
+	///   * number:     A number, starting with 0, is appended to
+	///                 the name of archived log files. The newest
+	///                 archived log file always has the number 0.
+	///                 For example, if the log file is named
+	///                 "access.log", and it fulfils the criteria
+	///                 for rotation, the file is renamed to
+	///                 "access.log.0". If a file named "access.log.0"
+	///                 already exists, it is renamed to "access.log.1",
+	///                 and so on.
+	///   * timestamp:  A timestamp is appended to the log file name.
+	///                 For example, if the log file is named
+	///                 "access.log", and it fulfils the criteria
+	///                 for rotation, the file is renamed to
+	///                 "access.log.20050802110300".
+	///
+	/// Using the "times" property it is possible to specify
+	/// time mode for the day/time based rotation. The following values
+	/// for the "times" property are supported:
+	///
+	///   * utc:        Rotation strategy is based on UTC time (default).
+	///   * local:      Rotation strategy is based on local time.
+	///
+	/// Archived log files can be compressed using the gzip compression
+	/// method. Compressing can be controlled with the "compress"
+	/// property. The following values for the "compress" property
+	/// are supported:
+	///
+	///   * true:       Compress archived log files.
+	///   * false:      Do not compress archived log files.
+	///
+	/// Archived log files can be automatically purged, either if
+	/// they reach a certain age, or if the number of archived
+	/// log files reaches a given maximum number. This is 
+	/// controlled by the purgeAge and purgeCount properties.
+	///
+	/// The purgeAge property can have the following values:
+	///
+	///   * <n> [seconds]: the maximum age is <n> seconds.
+	///   * <n> minutes:   the maximum age is <n> minutes.
+	///   * <n> hours:     the maximum age is <n> hours.
+	///   * <n> days:      the maximum age is <n> days.
+	///   * <n> weeks:     the maximum age is <n> weeks.
+	///   * <n> months:    the maximum age is <n> months, where a month has 30 days.
+	///
+	/// The purgeCount property has an integer value that specifies the maximum number
+	/// of archived log files. If the number is exceeded, archived log files are
+	/// deleted, starting with the oldest. When "none" or empty string are
+	/// supplied, they reset purgeCount to none (no purging).
+	///
+	/// The flush property specifies whether each log message is flushed
+	/// immediately to the log file (which may hurt application performance,
+	/// but ensures that everything is in the log in case of a system crash),
+	//  or whether it's allowed to stay in the system's file buffer for some time. 
+	/// Valid values are:
+	///
+	///   * true:  Every essages is immediately flushed to the log file (default).
+	///   * false: Messages are not immediately flushed to the log file.
+	///
+	/// The rotateOnOpen property specifies whether an existing log file should be 
+	/// rotated (and archived) when the channel is opened. Valid values are:
+	///
+	///   * true:  The log file is rotated (and archived) when the channel is opened.
+	///   * false: Log messages will be appended to an existing log file,
+	///            if it exists (unless other conditions for a rotation are met). 
+	///            This is the default.
+	///
+	/// For a more lightweight file channel class, see SimpleFileChannel.
+{
+public:
+	FileChannel();
+		/// Creates the FileChannel.
+
+	FileChannel(const std::string& path);
+		/// Creates the FileChannel for a file with the given path.
+
+	void open();
+		/// Opens the FileChannel and creates the log file if necessary.
+		
+	void close();
+		/// Closes the FileChannel.
+
+	void log(const Message& msg);
+		/// Logs the given message to the file.
+		
+	void setProperty(const std::string& name, const std::string& value);
+		/// Sets the property with the given name. 
+		/// 
+		/// The following properties are supported:
+		///   * path:         The log file's path.
+		///   * rotation:     The log file's rotation mode. See the 
+		///                   FileChannel class for details.
+		///   * archive:      The log file's archive mode. See the
+		///                   FileChannel class for details.
+		///   * times:        The log file's time mode. See the
+		///                   FileChannel class for details.
+		///   * compress:     Enable or disable compression of
+		///                   archived files. See the FileChannel class
+		///                   for details.
+		///   * purgeAge:     Maximum age of an archived log file before
+		///                   it is purged. See the FileChannel class for
+		///                   details.
+		///   * purgeCount:   Maximum number of archived log files before
+		///                   files are purged. See the FileChannel class
+		///                   for details.
+		///   * flush:        Specifies whether messages are immediately
+		///                   flushed to the log file. See the FileChannel class
+		///                   for details.
+		///   * rotateOnOpen: Specifies whether an existing log file should be 
+		///                   rotated and archived when the channel is opened.
+
+	std::string getProperty(const std::string& name) const;
+		/// Returns the value of the property with the given name.
+		/// See setProperty() for a description of the supported
+		/// properties.
+
+	Timestamp creationDate() const;
+		/// Returns the log file's creation date.
+		
+	UInt64 size() const;
+		/// Returns the log file's current size in bytes.
+
+	const std::string& path() const;
+		/// Returns the log file's path.
+
+	static const std::string PROP_PATH;
+	static const std::string PROP_ROTATION;
+	static const std::string PROP_ARCHIVE;
+	static const std::string PROP_TIMES;
+	static const std::string PROP_COMPRESS;
+	static const std::string PROP_STREAMCOMPRESS;
+	static const std::string PROP_PURGEAGE;
+	static const std::string PROP_PURGECOUNT;
+	static const std::string PROP_FLUSH;
+	static const std::string PROP_ROTATEONOPEN;
+
+protected:
+	~FileChannel();
+	void setRotation(const std::string& rotation);
+	void setArchive(const std::string& archive);
+	void setCompress(const std::string& compress);
+	void setStreamCompress(const std::string& streamCompress);
+	void setPurgeAge(const std::string& age);
+	void setPurgeCount(const std::string& count);
+	void setFlush(const std::string& flush);
+	void setRotateOnOpen(const std::string& rotateOnOpen);
+	void purge();
+	void unsafeOpen();
+
+private:
+	LogFile * newLogFile();
+	void archiveCorrupted(const std::string& path);
+	bool setNoPurge(const std::string& value);
+	int extractDigit(const std::string& value, std::string::const_iterator* nextToDigit = NULL) const;
+	void setPurgeStrategy(PurgeStrategy* strategy);
+	Timespan::TimeDiff extractFactor(const std::string& value, std::string::const_iterator start) const;
+
+	std::string      _path;
+	std::string      _times;
+	std::string      _rotation;
+	std::string      _archive;
+	bool             _compress;
+	bool             _streamCompress;
+	std::string      _purgeAge;
+	std::string      _purgeCount;
+	bool             _flush;
+	bool             _rotateOnOpen;
+	LogFile*         _pFile;
+	RotateStrategy*  _pRotateStrategy;
+	ArchiveStrategy* _pArchiveStrategy;
+	PurgeStrategy*   _pPurgeStrategy;
+	FastMutex        _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FileChannel_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FileStream.h b/base/poco/Foundation/include/Poco/FileStream.h
new file mode 100644
index 00000000000..cea56c9476f
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FileStream.h
@@ -0,0 +1,176 @@
+//
+// FileStream.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  FileStream
+//
+// Definition of the FileStreamBuf, FileInputStream and FileOutputStream classes.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FileStream_INCLUDED
+#define Foundation_FileStream_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#include "Poco/FileStream_WIN32.h"
+#else
+#include "Poco/FileStream_POSIX.h"
+#endif
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+
+
+class Foundation_API FileIOS: public virtual std::ios
+	/// The base class for FileInputStream and FileOutputStream.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+	///
+	/// Files are always opened in binary mode, a text mode
+	/// with CR-LF translation is not supported. Thus, the
+	/// file is always opened as if the std::ios::binary flag
+	/// was specified.
+	/// Use an InputLineEndingConverter or OutputLineEndingConverter
+	/// if you require CR-LF translation.
+	///
+	/// On Windows platforms, if POCO_WIN32_UTF8 is #define'd,
+	/// UTF-8 encoded Unicode paths are correctly handled.
+{
+public:
+	FileIOS(std::ios::openmode defaultMode);
+		/// Creates the basic stream.
+		
+	~FileIOS();
+		/// Destroys the stream.
+
+	void open(const std::string& path, std::ios::openmode mode);
+		/// Opens the file specified by path, using the given mode.
+		///
+		/// Throws a FileException (or a similar exception) if the file 
+		/// does not exist or is not accessible for other reasons and
+		/// a new file cannot be created.
+
+	void close();
+		/// Closes the file stream.
+		///
+		/// If, for an output stream, the close operation fails (because
+		/// the contents of the stream buffer cannot synced back to
+		/// the filesystem), the bad bit is set in the stream state.
+
+	FileStreamBuf* rdbuf();
+		/// Returns a pointer to the underlying streambuf.
+
+protected:
+	FileStreamBuf _buf;
+	std::ios::openmode _defaultMode;
+};
+
+
+class Foundation_API FileInputStream: public FileIOS, public std::istream
+	/// An input stream for reading from a file.
+	///
+	/// Files are always opened in binary mode, a text mode
+	/// with CR-LF translation is not supported. Thus, the
+	/// file is always opened as if the std::ios::binary flag
+	/// was specified.
+	/// Use an InputLineEndingConverter if you require CR-LF translation.
+	///
+	/// On Windows platforms, if POCO_WIN32_UTF8 is #define'd,
+	/// UTF-8 encoded Unicode paths are correctly handled.
+{
+public:
+	FileInputStream();
+		/// Creates an unopened FileInputStream.
+	
+	FileInputStream(const std::string& path, std::ios::openmode mode = std::ios::in);
+		/// Creates the FileInputStream for the file given by path, using
+		/// the given mode.
+		///
+		/// The std::ios::in flag is always set, regardless of the actual
+		/// value specified for mode.
+		///
+		/// Throws a FileNotFoundException (or a similar exception) if the file 
+		/// does not exist or is not accessible for other reasons.
+
+	~FileInputStream();
+		/// Destroys the stream.
+};
+
+
+class Foundation_API FileOutputStream: public FileIOS, public std::ostream
+	/// An output stream for writing to a file.
+	///
+	/// Files are always opened in binary mode, a text mode
+	/// with CR-LF translation is not supported. Thus, the
+	/// file is always opened as if the std::ios::binary flag
+	/// was specified.
+	/// Use an OutputLineEndingConverter if you require CR-LF translation.
+	///
+	/// On Windows platforms, if POCO_WIN32_UTF8 is #define'd,
+	/// UTF-8 encoded Unicode paths are correctly handled.
+{
+public:
+	FileOutputStream();
+		/// Creats an unopened FileOutputStream.
+		
+	FileOutputStream(const std::string& path, std::ios::openmode mode = std::ios::out | std::ios::trunc);
+		/// Creates the FileOutputStream for the file given by path, using
+		/// the given mode.
+		///
+		/// The std::ios::out is always set, regardless of the actual 
+		/// value specified for mode.
+		///
+		/// Throws a FileException (or a similar exception) if the file 
+		/// does not exist or is not accessible for other reasons and
+		/// a new file cannot be created.
+
+	~FileOutputStream();
+		/// Destroys the FileOutputStream.
+};
+
+
+class Foundation_API FileStream: public FileIOS, public std::iostream
+	/// A stream for reading from and writing to a file.
+	///
+	/// Files are always opened in binary mode, a text mode
+	/// with CR-LF translation is not supported. Thus, the
+	/// file is always opened as if the std::ios::binary flag
+	/// was specified.
+	/// Use an InputLineEndingConverter or OutputLineEndingConverter
+	/// if you require CR-LF translation.
+	///
+	/// A seek (seekg() or seekp()) operation will always set the 
+	/// read position and the write position simultaneously to the
+	/// same value.
+	///
+	/// On Windows platforms, if POCO_WIN32_UTF8 is #define'd,
+	/// UTF-8 encoded Unicode paths are correctly handled.
+{
+public:
+	FileStream();
+		/// Creats an unopened FileStream.
+	
+	FileStream(const std::string& path, std::ios::openmode mode = std::ios::out | std::ios::in);
+		/// Creates the FileStream for the file given by path, using
+		/// the given mode.
+
+	~FileStream();
+		/// Destroys the FileOutputStream.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FileStream_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FileStreamFactory.h b/base/poco/Foundation/include/Poco/FileStreamFactory.h
new file mode 100644
index 00000000000..01364cf1da1
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FileStreamFactory.h
@@ -0,0 +1,61 @@
+//
+// FileStreamFactory.h
+//
+// Library: Foundation
+// Package: URI
+// Module:  FileStreamFactory
+//
+// Definition of the FileStreamFactory class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FileStreamFactory_INCLUDED
+#define Foundation_FileStreamFactory_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/URIStreamFactory.h"
+
+
+namespace Poco {
+
+
+class Path;
+
+
+class Foundation_API FileStreamFactory: public URIStreamFactory
+	/// An implementation of the URIStreamFactory interface
+	/// that handles file URIs.
+{
+public:
+	FileStreamFactory();
+		/// Creates the FileStreamFactory.
+
+	~FileStreamFactory();
+		/// Destroys the FileStreamFactory.
+		
+	std::istream* open(const URI& uri);
+		/// Creates and opens a file stream in binary mode for the given URI.
+		/// The URI must be either a file URI or a relative URI reference
+		/// containing a path to a local file.
+		///
+		/// Throws an FileNotFound exception if the file cannot
+		/// be opened.
+		
+	std::istream* open(const Path& path);
+		/// Creates and opens a file stream in binary mode for the given path.
+		///
+		/// Throws an FileNotFound exception if the file cannot
+		/// be opened.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FileStreamFactory_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FileStream_POSIX.h b/base/poco/Foundation/include/Poco/FileStream_POSIX.h
new file mode 100644
index 00000000000..f5fa25cb8ad
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FileStream_POSIX.h
@@ -0,0 +1,72 @@
+//
+// FileStream_POSIX.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  FileStream
+//
+// Definition of the FileStreamBuf, FileInputStream and FileOutputStream classes.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FileStream_POSIX_INCLUDED
+#define Foundation_FileStream_POSIX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/BufferedBidirectionalStreamBuf.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+
+
+class Foundation_API FileStreamBuf: public BufferedBidirectionalStreamBuf
+	/// This stream buffer handles Fileio
+{
+public:
+	FileStreamBuf();
+		/// Creates a FileStreamBuf.
+		
+	~FileStreamBuf();
+		/// Destroys the FileStream.
+
+	void open(const std::string& path, std::ios::openmode mode);
+		/// Opens the given file in the given mode.
+
+	bool close();
+		/// Closes the File stream buffer. Returns true if successful,
+		/// false otherwise.
+
+	std::streampos seekoff(std::streamoff off, std::ios::seekdir dir, std::ios::openmode mode = std::ios::in | std::ios::out);
+		/// Change position by offset, according to way and mode.
+
+	std::streampos seekpos(std::streampos pos, std::ios::openmode mode = std::ios::in | std::ios::out);
+		/// Change to specified position, according to mode.
+
+protected:
+	enum
+	{
+		BUFFER_SIZE = 4096
+	};
+
+	int readFromDevice(char* buffer, std::streamsize length);
+	int writeToDevice(const char* buffer, std::streamsize length);
+
+private:
+	std::string _path;
+	int _fd;
+	std::streamoff _pos;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FileStream_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FileStream_WIN32.h b/base/poco/Foundation/include/Poco/FileStream_WIN32.h
new file mode 100644
index 00000000000..5382f84db3b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FileStream_WIN32.h
@@ -0,0 +1,71 @@
+//
+// FileStream_WIN32.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  FileStream
+//
+// Definition of the FileStreamBuf, FileInputStream and FileOutputStream classes.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FileStream_WIN32_INCLUDED
+#define Foundation_FileStream_WIN32_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/BufferedBidirectionalStreamBuf.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API FileStreamBuf: public BufferedBidirectionalStreamBuf
+	/// This stream buffer handles Fileio
+{
+public:
+	FileStreamBuf();
+		/// Creates a FileStreamBuf.
+
+	~FileStreamBuf();
+		/// Destroys the FileStream.
+
+	void open(const std::string& path, std::ios::openmode mode);
+		/// Opens the given file in the given mode.
+
+	bool close();
+		/// Closes the File stream buffer. Returns true if successful,
+		/// false otherwise.
+
+	std::streampos seekoff(std::streamoff off, std::ios::seekdir dir, std::ios::openmode mode = std::ios::in | std::ios::out);
+		/// change position by offset, according to way and mode
+
+	std::streampos seekpos(std::streampos pos, std::ios::openmode mode = std::ios::in | std::ios::out);
+		/// change to specified position, according to mode
+
+protected:
+	enum
+	{
+		BUFFER_SIZE = 4096
+	};
+
+	int readFromDevice(char* buffer, std::streamsize length);
+	int writeToDevice(const char* buffer, std::streamsize length);
+
+private:
+	std::string _path;
+	HANDLE _handle;
+	UInt64 _pos;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FileStream_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/File_UNIX.h b/base/poco/Foundation/include/Poco/File_UNIX.h
new file mode 100644
index 00000000000..34a15c573d7
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/File_UNIX.h
@@ -0,0 +1,86 @@
+//
+// File_UNIX.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  File
+//
+// Definition of the FileImpl class for Unix.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_File_UNIX_INCLUDED
+#define Foundation_File_UNIX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class FileImpl
+{
+protected:
+	typedef UInt64 FileSizeImpl;
+
+	FileImpl();
+	FileImpl(const std::string& path);
+	virtual ~FileImpl();
+	void swapImpl(FileImpl& file);
+	void setPathImpl(const std::string& path);
+	const std::string& getPathImpl() const;
+	bool existsImpl() const;
+	bool canReadImpl() const;
+	bool canWriteImpl() const;
+	bool canExecuteImpl() const;
+	bool isFileImpl() const;
+	bool isDirectoryImpl() const;
+	bool isLinkImpl() const;
+	bool isDeviceImpl() const;
+	bool isHiddenImpl() const;
+	Timestamp createdImpl() const;
+	Timestamp getLastModifiedImpl() const;
+	void setLastModifiedImpl(const Timestamp& ts);
+	FileSizeImpl getSizeImpl() const;
+	void setSizeImpl(FileSizeImpl size);
+	void setWriteableImpl(bool flag = true);
+	void setExecutableImpl(bool flag = true);
+	void copyToImpl(const std::string& path) const;
+	void renameToImpl(const std::string& path);
+	void linkToImpl(const std::string& path, int type) const;
+	void removeImpl();
+	bool createFileImpl();
+	bool createDirectoryImpl();
+	FileSizeImpl totalSpaceImpl() const;
+	FileSizeImpl usableSpaceImpl() const;
+	FileSizeImpl freeSpaceImpl() const;
+	static void handleLastErrorImpl(const std::string& path);
+
+private:
+	std::string _path;
+
+	friend class DirectoryIteratorImpl;
+	friend class LinuxDirectoryWatcherStrategy;
+	friend class BSDDirectoryWatcherStrategy;
+};
+
+
+//
+// inlines
+//
+inline const std::string& FileImpl::getPathImpl() const
+{
+	return _path;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_File_UNIX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/File_VX.h b/base/poco/Foundation/include/Poco/File_VX.h
new file mode 100644
index 00000000000..3d66f96647d
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/File_VX.h
@@ -0,0 +1,84 @@
+//
+// File_VX.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  File
+//
+// Definition of the FileImpl class for VxWorks.
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_File_VX_INCLUDED
+#define Foundation_File_VX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class FileImpl
+{
+protected:
+	typedef UInt64 FileSizeImpl;
+
+	FileImpl();
+	FileImpl(const std::string& path);
+	virtual ~FileImpl();
+	void swapImpl(FileImpl& file);
+	void setPathImpl(const std::string& path);
+	const std::string& getPathImpl() const;
+	bool existsImpl() const;
+	bool canReadImpl() const;
+	bool canWriteImpl() const;
+	bool canExecuteImpl() const;
+	bool isFileImpl() const;
+	bool isDirectoryImpl() const;
+	bool isLinkImpl() const;
+	bool isDeviceImpl() const;
+	bool isHiddenImpl() const;
+	Timestamp createdImpl() const;
+	Timestamp getLastModifiedImpl() const;
+	void setLastModifiedImpl(const Timestamp& ts);
+	FileSizeImpl getSizeImpl() const;
+	void setSizeImpl(FileSizeImpl size);
+	void setWriteableImpl(bool flag = true);
+	void setExecutableImpl(bool flag = true);
+	void copyToImpl(const std::string& path) const;
+	void renameToImpl(const std::string& path);
+	void linkToImpl(const std::string& path, int type) const;
+	void removeImpl();
+	bool createFileImpl();
+	bool createDirectoryImpl();
+	FileSizeImpl totalSpaceImpl() const;
+	FileSizeImpl usableSpaceImpl() const;
+	FileSizeImpl freeSpaceImpl() const;
+	static void handleLastErrorImpl(const std::string& path);
+
+private:
+	std::string _path;
+
+	friend class DirectoryIteratorImpl;
+};
+
+
+//
+// inlines
+//
+inline const std::string& FileImpl::getPathImpl() const
+{
+	return _path;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_File_VX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/File_WIN32.h b/base/poco/Foundation/include/Poco/File_WIN32.h
new file mode 100644
index 00000000000..2d8b8880745
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/File_WIN32.h
@@ -0,0 +1,87 @@
+//
+// File_WIN32.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  File
+//
+// Definition of the FileImpl class for WIN32.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_File_WIN32_INCLUDED
+#define Foundation_File_WIN32_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Timestamp.h"
+
+
+namespace Poco {
+
+
+class Foundation_API FileImpl
+{
+protected:
+	typedef UInt64 FileSizeImpl;
+
+	FileImpl();
+	FileImpl(const std::string& path);
+	virtual ~FileImpl();
+	void swapImpl(FileImpl& file);
+	void setPathImpl(const std::string& path);
+	const std::string& getPathImpl() const;
+	bool existsImpl() const;
+	bool canReadImpl() const;
+	bool canWriteImpl() const;
+	bool canExecuteImpl() const;
+	bool isFileImpl() const;
+	bool isDirectoryImpl() const;
+	bool isLinkImpl() const;
+	bool isDeviceImpl() const;
+	bool isHiddenImpl() const;
+	Timestamp createdImpl() const;
+	Timestamp getLastModifiedImpl() const;
+	void setLastModifiedImpl(const Timestamp& ts);
+	FileSizeImpl getSizeImpl() const;
+	void setSizeImpl(FileSizeImpl size);
+	void setWriteableImpl(bool flag = true);
+	void setExecutableImpl(bool flag = true);
+	void copyToImpl(const std::string& path) const;
+	void renameToImpl(const std::string& path);
+	void linkToImpl(const std::string& path, int type) const;
+	void removeImpl();
+	bool createFileImpl();
+	bool createDirectoryImpl();
+	FileSizeImpl totalSpaceImpl() const;
+	FileSizeImpl usableSpaceImpl() const;
+	FileSizeImpl freeSpaceImpl() const;
+	static void handleLastErrorImpl(const std::string& path);
+
+private:
+	std::string _path;
+
+	friend class FileHandle;
+	friend class DirectoryIteratorImpl;
+	friend class WindowsDirectoryWatcherStrategy;
+};
+
+
+//
+// inlines
+//
+inline const std::string& FileImpl::getPathImpl() const
+{
+	return _path;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_File_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/File_WIN32U.h b/base/poco/Foundation/include/Poco/File_WIN32U.h
new file mode 100644
index 00000000000..835da87a15c
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/File_WIN32U.h
@@ -0,0 +1,91 @@
+//
+// File_WIN32U.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  File
+//
+// Definition of the Unicode FileImpl class for WIN32.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_File_WIN32U_INCLUDED
+#define Foundation_File_WIN32U_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Timestamp.h"
+
+
+namespace Poco {
+
+
+class Foundation_API FileImpl
+{
+protected:
+	typedef UInt64 FileSizeImpl;
+
+	FileImpl();
+	FileImpl(const std::string& path);
+	virtual ~FileImpl();
+	void swapImpl(FileImpl& file);
+	void setPathImpl(const std::string& path);
+	const std::string& getPathImpl() const;
+	bool existsImpl() const;
+	bool canReadImpl() const;
+	bool canWriteImpl() const;
+	bool canExecuteImpl() const;
+	bool isFileImpl() const;
+	bool isDirectoryImpl() const;
+	bool isLinkImpl() const;
+	bool isDeviceImpl() const;
+	bool isHiddenImpl() const;
+	Timestamp createdImpl() const;
+	Timestamp getLastModifiedImpl() const;
+	void setLastModifiedImpl(const Timestamp& ts);
+	FileSizeImpl getSizeImpl() const;
+	void setSizeImpl(FileSizeImpl size);
+	void setWriteableImpl(bool flag = true);
+	void setExecutableImpl(bool flag = true);
+	void copyToImpl(const std::string& path) const;
+	void renameToImpl(const std::string& path);
+	void linkToImpl(const std::string& path, int type) const;
+	void removeImpl();
+	bool createFileImpl();
+	bool createDirectoryImpl();
+	FileSizeImpl totalSpaceImpl() const;
+	FileSizeImpl usableSpaceImpl() const;
+	FileSizeImpl freeSpaceImpl() const;
+	static void handleLastErrorImpl(const std::string& path);
+	static void convertPath(const std::string& utf8Path, std::wstring& utf16Path);
+
+private:
+	std::string  _path;
+	std::wstring _upath;
+
+	friend class FileHandle;
+	friend class DirectoryIteratorImpl;
+	friend class WindowsDirectoryWatcherStrategy;
+	friend class FileStreamBuf;
+	friend class LogFileImpl;
+};
+
+
+//
+// inlines
+//
+inline const std::string& FileImpl::getPathImpl() const
+{
+	return _path;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_File_WIN32U_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/File_WINCE.h b/base/poco/Foundation/include/Poco/File_WINCE.h
new file mode 100644
index 00000000000..c1ba4f35078
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/File_WINCE.h
@@ -0,0 +1,90 @@
+//
+// File_WIN32U.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  File
+//
+// Definition of the Unicode FileImpl class for WIN32.
+//
+// Copyright (c) 2006-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_File_WINCE_INCLUDED
+#define Foundation_File_WINCE_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Timestamp.h"
+
+
+namespace Poco {
+
+
+class Foundation_API FileImpl
+{
+protected:
+	typedef UInt64 FileSizeImpl;
+
+	FileImpl();
+	FileImpl(const std::string& path);
+	virtual ~FileImpl();
+	void swapImpl(FileImpl& file);
+	void setPathImpl(const std::string& path);
+	const std::string& getPathImpl() const;
+	bool existsImpl() const;
+	bool canReadImpl() const;
+	bool canWriteImpl() const;
+	bool canExecuteImpl() const;
+	bool isFileImpl() const;
+	bool isDirectoryImpl() const;
+	bool isLinkImpl() const;
+	bool isDeviceImpl() const;
+	bool isHiddenImpl() const;
+	Timestamp createdImpl() const;
+	Timestamp getLastModifiedImpl() const;
+	void setLastModifiedImpl(const Timestamp& ts);
+	FileSizeImpl getSizeImpl() const;
+	void setSizeImpl(FileSizeImpl size);
+	void setWriteableImpl(bool flag = true);
+	void setExecutableImpl(bool flag = true);
+	void copyToImpl(const std::string& path) const;
+	void renameToImpl(const std::string& path);
+	void linkToImpl(const std::string& path, int type) const;
+	void removeImpl();
+	bool createFileImpl();
+	bool createDirectoryImpl();
+	FileSizeImpl totalSpaceImpl() const;
+	FileSizeImpl usableSpaceImpl() const;
+	FileSizeImpl freeSpaceImpl() const;
+	static void handleLastErrorImpl(const std::string& path);
+	static void convertPath(const std::string& utf8Path, std::wstring& utf16Path);
+
+private:
+	std::string  _path;
+	std::wstring _upath;
+
+	friend class FileHandle;
+	friend class DirectoryIteratorImpl;
+	friend class FileStreamBuf;
+	friend class LogFileImpl;
+};
+
+
+//
+// inlines
+//
+inline const std::string& FileImpl::getPathImpl() const
+{
+	return _path;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_File_WINCE_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Format.h b/base/poco/Foundation/include/Poco/Format.h
new file mode 100644
index 00000000000..e4b093a407c
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Format.h
@@ -0,0 +1,138 @@
+//
+// Format.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Format
+//
+// Definition of the format freestanding function.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Format_INCLUDED
+#define Foundation_Format_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Any.h"
+#include <vector>
+
+
+namespace Poco {
+
+
+std::string Foundation_API format(const std::string& fmt, const Any& value);
+	/// This function implements sprintf-style formatting in a typesafe way.
+	/// Various variants of the function are available, supporting a
+	/// different number of arguments (up to six).
+	///
+	/// The formatting is controlled by the format string in fmt.
+	/// Format strings are quite similar to those of the std::printf() function, but
+	/// there are some minor differences.
+	///
+	/// The format string can consist of any sequence of characters; certain
+	/// characters have a special meaning. Characters without a special meaning
+	/// are copied verbatim to the result. A percent sign (%) marks the beginning
+	/// of a format specification. Format specifications have the following syntax:
+	///
+	///   %[<index>][<flags>][<width>][.<precision>][<modifier>]<type>
+	///
+	/// Index, flags, width, precision and prefix are optional. The only required part of
+	/// the format specification, apart from the percent sign, is the type.
+	///
+	/// The optional index argument has the format "[<n>]" and allows to
+	/// address an argument by its zero-based position (see the example below).
+	///
+	/// Following are valid type specifications and their meaning:
+	///
+	///   * b boolean (true = 1, false = 0)
+	///   * c character
+	///   * d signed decimal integer
+	///   * i signed decimal integer
+	///   * o unsigned octal integer
+	///   * u unsigned decimal integer
+	///   * x unsigned hexadecimal integer (lower case)
+	///   * X unsigned hexadecimal integer (upper case)
+	///   * e signed floating-point value in the form [-]d.dddde[<sign>]dd[d]
+	///   * E signed floating-point value in the form [-]d.ddddE[<sign>]dd[d]
+	///   * f signed floating-point value in the form [-]dddd.dddd
+	///   * s std::string
+	///   * z std::size_t
+	///
+	/// The following flags are supported:
+	///
+	///   * - left align the result within the given field width
+	///   * + prefix the output value with a sign (+ or -) if the output value is of a signed type
+	///   * 0 if width is prefixed with 0, zeros are added until the minimum width is reached
+	///   * # For o, x, X, the # flag prefixes any nonzero output value with 0, 0x, or 0X, respectively; 
+	///     for e, E, f, the # flag forces the output value to contain a decimal point in all cases.
+	///
+	/// The following modifiers are supported:
+	///
+	///   * (none) argument is char (c), int (d, i), unsigned (o, u, x, X) double (e, E, f, g, G) or string (s)
+	///   * l      argument is long (d, i), unsigned long (o, u, x, X) or long double (e, E, f, g, G)
+	///   * L      argument is long long (d, i), unsigned long long (o, u, x, X)
+	///   * h      argument is short (d, i), unsigned short (o, u, x, X) or float (e, E, f, g, G)
+	///   * ?      argument is any signed or unsigned int, short, long, or 64-bit integer (d, i, o, x, X)
+	///
+	/// The width argument is a nonnegative decimal integer controlling the minimum number of characters printed.
+	/// If the number of characters in the output value is less than the specified width, blanks or
+	/// leading zeros are added, according to the specified flags (-, +, 0).
+	///
+	/// Precision is a nonnegative decimal integer, preceded by a period (.), which specifies the number of characters 
+	/// to be printed, the number of decimal places, or the number of significant digits.
+	///
+	/// Throws an InvalidArgumentException if an argument index is out of range.
+	///
+	/// Starting with release 1.4.3, an argument that does not match the format
+	/// specifier no longer results in a BadCastException. The string [ERRFMT] is 
+	/// written to the result string instead.
+	/// 
+	/// If there are more format specifiers than values, the format specifiers without a corresponding value
+	/// are copied verbatim to output.
+	///
+	/// If there are more values than format specifiers, the superfluous values are ignored.
+	///
+	/// Usage Examples:
+	///     std::string s1 = format("The answer to life, the universe, and everything is %d", 42);
+	///     std::string s2 = format("second: %[1]d, first: %[0]d", 1, 2);
+
+std::string Foundation_API format(const std::string& fmt, const Any& value1, const Any& value2);
+std::string Foundation_API format(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3);
+std::string Foundation_API format(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4);
+std::string Foundation_API format(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5);
+std::string Foundation_API format(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6);
+std::string Foundation_API format(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7);
+std::string Foundation_API format(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8);
+std::string Foundation_API format(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9);
+std::string Foundation_API format(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10);
+
+
+void Foundation_API format(std::string& result, const std::string& fmt, const Any& value);
+	/// Appends the formatted string to result.
+	
+void Foundation_API format(std::string& result, const std::string& fmt, const Any& value1, const Any& value2);
+void Foundation_API format(std::string& result, const std::string& fmt, const Any& value1, const Any& value2, const Any& value3);
+void Foundation_API format(std::string& result, const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4);
+void Foundation_API format(std::string& result, const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5);
+void Foundation_API format(std::string& result, const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6);
+void Foundation_API format(std::string& result, const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7);
+void Foundation_API format(std::string& result, const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8);
+void Foundation_API format(std::string& result, const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9);
+void Foundation_API format(std::string& result, const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10);
+
+
+void Foundation_API format(std::string& result, const std::string& fmt, const std::vector<Any>& values);
+	/// Supports a variable number of arguments and is used by
+	/// all other variants of format().
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Format_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Formatter.h b/base/poco/Foundation/include/Poco/Formatter.h
new file mode 100644
index 00000000000..678d594b72e
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Formatter.h
@@ -0,0 +1,74 @@
+//
+// Formatter.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  Formatter
+//
+// Definition of the Formatter class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Formatter_INCLUDED
+#define Foundation_Formatter_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Configurable.h"
+#include "Poco/RefCountedObject.h"
+
+
+namespace Poco {
+
+
+class Message;
+
+
+class Foundation_API Formatter: public Configurable, public RefCountedObject
+	/// The base class for all Formatter classes.
+	///
+	/// A formatter basically takes a Message object
+	/// and formats it into a string. How the formatting
+	/// is exactly done is up to the implementation of
+	/// Formatter. For example, a very simple implementation
+	/// might simply take the message's Text (see Message::getText()).
+	/// A useful implementation should at least take the Message's
+	/// Time, Priority and Text fields and put them into a string.
+	///
+	/// The Formatter class supports the Configurable
+	/// interface, so the behaviour of certain formatters
+	/// is configurable.
+	/// 
+	/// Trivial implementations of of getProperty() and 
+	/// setProperty() are provided.
+	///
+	/// Subclasses must at least provide a format() method.
+{
+public:
+	Formatter();
+		/// Creates the formatter.
+		
+	virtual ~Formatter();
+		/// Destroys the formatter.
+
+	virtual void format(const Message& msg, std::string& text) = 0;
+		/// Formats the message and places the result in text. 
+		/// Subclasses must override this method.
+		
+	void setProperty(const std::string& name, const std::string& value);
+		/// Throws a PropertyNotSupportedException.
+
+	std::string getProperty(const std::string& name) const;
+		/// Throws a PropertyNotSupportedException.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Formatter_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FormattingChannel.h b/base/poco/Foundation/include/Poco/FormattingChannel.h
new file mode 100644
index 00000000000..f4dfded2a79
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FormattingChannel.h
@@ -0,0 +1,96 @@
+//
+// FormattingChannel.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  Formatter
+//
+// Definition of the FormattingChannel class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FormattingChannel_INCLUDED
+#define Foundation_FormattingChannel_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Channel.h"
+
+
+namespace Poco {
+
+
+class Formatter;
+
+
+class Foundation_API FormattingChannel: public Channel
+	/// The FormattingChannel is a filter channel that routes
+	/// a Message through a Formatter before passing it on
+	/// to the destination channel.
+{
+public:
+	FormattingChannel();
+		/// Creates a FormattingChannel.
+		
+	FormattingChannel(Formatter* pFormatter);
+		/// Creates a FormattingChannel and attaches a Formatter.
+		
+	FormattingChannel(Formatter* pFormatter, Channel* pChannel);
+		/// Creates a FormattingChannel and attaches a Formatter
+		/// and a Channel.
+		
+	void setFormatter(Formatter* pFormatter);
+		/// Sets the Formatter used to format the messages
+		/// before they are passed on. If null, the message
+		/// is passed on unmodified.
+		
+	Formatter* getFormatter() const;
+		/// Returns the Formatter used to format messages,
+		/// which may be null.
+
+	void setChannel(Channel* pChannel);
+		/// Sets the destination channel to which the formatted 
+		/// messages are passed on.
+		
+	Channel* getChannel() const;
+		/// Returns the channel to which the formatted
+		/// messages are passed on.
+		
+	void log(const Message& msg);
+		/// Formats the given Message using the Formatter and
+		/// passes the formatted message on to the destination
+		/// Channel.
+
+	void setProperty(const std::string& name, const std::string& value);
+		/// Sets or changes a configuration property.
+		///
+		/// Only the "channel" and "formatter" properties are supported, which allow
+		/// setting the target channel and formatter, respectively, via the LoggingRegistry.
+		/// The "channel" and "formatter" properties are set-only.
+		///
+		/// Unsupported properties are passed to the attached Channel.
+
+	void open();
+		/// Opens the attached channel.
+		
+	void close();
+		/// Closes the attached channel.
+
+protected:
+	~FormattingChannel();
+
+private:
+	Formatter* _pFormatter;
+	Channel* _pChannel;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FormattingChannel_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Foundation.h b/base/poco/Foundation/include/Poco/Foundation.h
new file mode 100644
index 00000000000..750c7775e7c
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Foundation.h
@@ -0,0 +1,168 @@
+//
+// Foundation.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Foundation
+//
+// Basic definitions for the POCO Foundation library.
+// This file must be the first file included by every other Foundation
+// header file.
+//
+// Copyright (c) 2004-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Foundation_INCLUDED
+#define Foundation_Foundation_INCLUDED
+
+
+//
+// Include library configuration
+//
+#include "Poco/Config.h"
+
+
+//
+// Ensure that POCO_DLL is default unless POCO_STATIC is defined
+//
+#if defined(_WIN32) && defined(_DLL)
+	#if !defined(POCO_DLL) && !defined(POCO_STATIC)
+		#define POCO_DLL
+	#endif
+#endif
+
+
+//
+// The following block is the standard way of creating macros which make exporting
+// from a DLL simpler. All files within this DLL are compiled with the Foundation_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any project
+// that uses this DLL. This way any other project whose source files include this file see
+// Foundation_API functions as being imported from a DLL, wheras this DLL sees symbols
+// defined with this macro as being exported.
+//
+#if (defined(_WIN32) || defined(_WIN32_WCE)) && defined(POCO_DLL)
+	#if defined(Foundation_EXPORTS)
+		#define Foundation_API __declspec(dllexport)
+	#else
+		#define Foundation_API __declspec(dllimport)
+	#endif
+#endif
+
+
+#if !defined(Foundation_API)
+	#if !defined(POCO_NO_GCC_API_ATTRIBUTE) && defined (__GNUC__) && (__GNUC__ >= 4)
+		#define Foundation_API __attribute__ ((visibility ("default")))
+	#else
+		#define Foundation_API
+	#endif
+#endif
+
+
+//
+// Automatically link Foundation library.
+//
+#if defined(_MSC_VER)
+	#if defined(POCO_DLL)
+		#if defined(_DEBUG)
+			#define POCO_LIB_SUFFIX "d.lib"
+		#else
+			#define POCO_LIB_SUFFIX ".lib"
+		#endif
+	#elif defined(_DLL)
+		#if defined(_DEBUG)
+			#define POCO_LIB_SUFFIX "mdd.lib"
+		#else
+			#define POCO_LIB_SUFFIX "md.lib"
+		#endif
+	#else
+		#if defined(_DEBUG)
+			#define POCO_LIB_SUFFIX "mtd.lib"
+		#else
+			#define POCO_LIB_SUFFIX "mt.lib"
+		#endif
+	#endif
+
+	#if !defined(POCO_NO_AUTOMATIC_LIBS) && !defined(Foundation_EXPORTS)
+		#pragma comment(lib, "PocoFoundation" POCO_LIB_SUFFIX)
+	#endif
+#endif
+
+
+//
+// Include platform-specific definitions
+//
+#include "Poco/Platform.h"
+#if defined(_WIN32)
+	#include "Poco/Platform_WIN32.h"
+#elif defined(POCO_VXWORKS)
+	#include "Poco/Platform_VX.h"
+#elif defined(POCO_OS_FAMILY_UNIX)
+	#include "Poco/Platform_POSIX.h"
+#endif
+
+
+//
+// Include alignment settings early
+//
+#include "Poco/Alignment.h"
+
+//
+// Cleanup inconsistencies
+//
+#ifdef POCO_OS_FAMILY_WINDOWS
+	#if defined(POCO_WIN32_UTF8) && defined(POCO_NO_WSTRING)
+		#error POCO_WIN32_UTF8 and POCO_NO_WSTRING are mutually exclusive.
+	#endif
+#else
+	#ifdef POCO_WIN32_UTF8
+		#undef POCO_WIN32_UTF8
+	#endif
+#endif
+
+
+//
+// POCO_JOIN
+//
+// The following piece of macro magic joins the two
+// arguments together, even when one of the arguments is
+// itself a macro (see 16.3.1 in C++ standard).  The key
+// is that macro expansion of macro arguments does not
+// occur in POCO_DO_JOIN2 but does in POCO_DO_JOIN.
+//
+#define POCO_JOIN(X, Y) POCO_DO_JOIN(X, Y)
+#define POCO_DO_JOIN(X, Y) POCO_DO_JOIN2(X, Y)
+#define POCO_DO_JOIN2(X, Y) X##Y
+
+
+//
+// POCO_DEPRECATED
+//
+// A macro expanding to a compiler-specific clause to
+// mark a class or function as deprecated.
+//
+#if defined(POCO_NO_DEPRECATED)
+#define POCO_DEPRECATED
+#elif defined(_GNUC_)
+#define POCO_DEPRECATED __attribute__((deprecated))
+#elif defined(__clang__)
+#define POCO_DEPRECATED __attribute__((deprecated))
+#elif defined(_MSC_VER)
+#define POCO_DEPRECATED __declspec(deprecated)
+#else
+#define POCO_DEPRECATED
+#endif
+
+
+//
+// Pull in basic definitions
+//
+#include "Poco/Bugcheck.h"
+#include "Poco/Types.h"
+#include <string>
+
+
+#endif // Foundation_Foundation_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FunctionDelegate.h b/base/poco/Foundation/include/Poco/FunctionDelegate.h
new file mode 100644
index 00000000000..9aec96d950b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FunctionDelegate.h
@@ -0,0 +1,438 @@
+//
+// FunctionDelegate.h
+//
+// Library: Foundation
+// Package: Events
+// Module:  FunctionDelegate
+//
+// Implementation of the FunctionDelegate template.
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FunctionDelegate_INCLUDED
+#define Foundation_FunctionDelegate_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/AbstractDelegate.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+
+
+template <class TArgs, bool hasSender = true, bool senderIsConst = true> 
+class FunctionDelegate: public AbstractDelegate<TArgs>
+	/// Wraps a freestanding function or static member function 
+	/// for use as a Delegate.
+{
+public:
+	typedef void (*NotifyFunction)(const void*, TArgs&);
+
+	FunctionDelegate(NotifyFunction function):
+		_function(function)
+	{
+	}
+
+	FunctionDelegate(const FunctionDelegate& delegate):
+		AbstractDelegate<TArgs>(delegate),
+		_function(delegate._function)
+	{
+	}
+
+	~FunctionDelegate()
+	{
+	}
+	
+	FunctionDelegate& operator = (const FunctionDelegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_function = delegate._function;
+		}
+		return *this;
+	}
+
+	bool notify(const void* sender, TArgs& arguments)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_function)
+		{
+			(*_function)(sender, arguments);
+			return true;
+		}
+		else return false;
+	}
+
+	bool equals(const AbstractDelegate<TArgs>& other) const
+	{
+		const FunctionDelegate* pOtherDelegate = dynamic_cast<const FunctionDelegate*>(other.unwrap());
+		return pOtherDelegate && _function == pOtherDelegate->_function;
+	}
+
+	AbstractDelegate<TArgs>* clone() const
+	{
+		return new FunctionDelegate(*this);
+	}
+	
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_function = 0;
+	}
+
+protected:
+	NotifyFunction _function;
+	Mutex _mutex;
+
+private:
+	FunctionDelegate();
+};
+
+
+template <class TArgs> 
+class FunctionDelegate<TArgs, true, false>: public AbstractDelegate<TArgs>
+{
+public:
+	typedef void (*NotifyFunction)(void*, TArgs&);
+
+	FunctionDelegate(NotifyFunction function):
+		_function(function)
+	{
+	}
+
+	FunctionDelegate(const FunctionDelegate& delegate):
+		AbstractDelegate<TArgs>(delegate),
+		_function(delegate._function)
+	{
+	}
+
+	~FunctionDelegate()
+	{
+	}
+	
+	FunctionDelegate& operator = (const FunctionDelegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_function = delegate._function;
+		}
+		return *this;
+	}
+
+	bool notify(const void* sender, TArgs& arguments)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_function)
+		{
+			(*_function)(const_cast<void*>(sender), arguments);
+			return true;
+		}
+		else return false;
+	}
+
+	bool equals(const AbstractDelegate<TArgs>& other) const
+	{
+		const FunctionDelegate* pOtherDelegate = dynamic_cast<const FunctionDelegate*>(other.unwrap());
+		return pOtherDelegate && _function == pOtherDelegate->_function;
+	}
+
+	AbstractDelegate<TArgs>* clone() const
+	{
+		return new FunctionDelegate(*this);
+	}
+
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_function = 0;
+	}
+
+protected:
+	NotifyFunction _function;
+	Mutex _mutex;
+
+private:
+	FunctionDelegate();
+};
+
+
+template <class TArgs, bool senderIsConst> 
+class FunctionDelegate<TArgs, false, senderIsConst>: public AbstractDelegate<TArgs>
+{
+public:
+	typedef void (*NotifyFunction)(TArgs&);
+
+	FunctionDelegate(NotifyFunction function):
+		_function(function)
+	{
+	}
+
+	FunctionDelegate(const FunctionDelegate& delegate):
+		AbstractDelegate<TArgs>(delegate),
+		_function(delegate._function)
+	{
+	}
+
+	~FunctionDelegate()
+	{
+	}
+	
+	FunctionDelegate& operator = (const FunctionDelegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_function = delegate._function;
+		}
+		return *this;
+	}
+
+	bool notify(const void* /*sender*/, TArgs& arguments)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_function)
+		{
+			(*_function)(arguments);
+			return true; 
+		}
+		else return false;
+	}
+
+	bool equals(const AbstractDelegate<TArgs>& other) const
+	{
+		const FunctionDelegate* pOtherDelegate = dynamic_cast<const FunctionDelegate*>(other.unwrap());
+		return pOtherDelegate && _function == pOtherDelegate->_function;
+	}
+
+	AbstractDelegate<TArgs>* clone() const
+	{
+		return new FunctionDelegate(*this);
+	}
+
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_function = 0;
+	}
+
+protected:
+	NotifyFunction _function;
+	Mutex _mutex;
+
+private:
+	FunctionDelegate();
+};
+
+
+template <> 
+class FunctionDelegate<void, true, true>: public AbstractDelegate<void>
+	/// Wraps a freestanding function or static member function 
+	/// for use as a Delegate.
+{
+public:
+	typedef void (*NotifyFunction)(const void*);
+
+	FunctionDelegate(NotifyFunction function):
+		_function(function)
+	{
+	}
+
+	FunctionDelegate(const FunctionDelegate& delegate):
+		AbstractDelegate<void>(delegate),
+		_function(delegate._function)
+	{
+	}
+
+	~FunctionDelegate()
+	{
+	}
+	
+	FunctionDelegate& operator = (const FunctionDelegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_function = delegate._function;
+		}
+		return *this;
+	}
+
+	bool notify(const void* sender)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_function)
+		{
+			(*_function)(sender);
+			return true;
+		}
+		else return false;
+	}
+
+	bool equals(const AbstractDelegate<void>& other) const
+	{
+		const FunctionDelegate* pOtherDelegate = dynamic_cast<const FunctionDelegate*>(other.unwrap());
+		return pOtherDelegate && _function == pOtherDelegate->_function;
+	}
+
+	AbstractDelegate<void>* clone() const
+	{
+		return new FunctionDelegate(*this);
+	}
+	
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_function = 0;
+	}
+
+protected:
+	NotifyFunction _function;
+	Mutex _mutex;
+
+private:
+	FunctionDelegate();
+};
+
+
+template <> 
+class FunctionDelegate<void, true, false>: public AbstractDelegate<void>
+{
+public:
+	typedef void (*NotifyFunction)(void*);
+
+	FunctionDelegate(NotifyFunction function):
+		_function(function)
+	{
+	}
+
+	FunctionDelegate(const FunctionDelegate& delegate):
+		AbstractDelegate<void>(delegate),
+		_function(delegate._function)
+	{
+	}
+
+	~FunctionDelegate()
+	{
+	}
+	
+	FunctionDelegate& operator = (const FunctionDelegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_function = delegate._function;
+		}
+		return *this;
+	}
+
+	bool notify(const void* sender)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_function)
+		{
+			(*_function)(const_cast<void*>(sender));
+			return true;
+		}
+		else return false;
+	}
+
+	bool equals(const AbstractDelegate<void>& other) const
+	{
+		const FunctionDelegate* pOtherDelegate = dynamic_cast<const FunctionDelegate*>(other.unwrap());
+		return pOtherDelegate && _function == pOtherDelegate->_function;
+	}
+
+	AbstractDelegate<void>* clone() const
+	{
+		return new FunctionDelegate(*this);
+	}
+
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_function = 0;
+	}
+
+protected:
+	NotifyFunction _function;
+	Mutex _mutex;
+
+private:
+	FunctionDelegate();
+};
+
+
+template <bool senderIsConst> 
+class FunctionDelegate<void, false, senderIsConst>: public AbstractDelegate<void>
+{
+public:
+	typedef void (*NotifyFunction)();
+
+	FunctionDelegate(NotifyFunction function):
+		_function(function)
+	{
+	}
+
+	FunctionDelegate(const FunctionDelegate& delegate):
+		AbstractDelegate<void>(delegate),
+		_function(delegate._function)
+	{
+	}
+
+	~FunctionDelegate()
+	{
+	}
+	
+	FunctionDelegate& operator = (const FunctionDelegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_function = delegate._function;
+		}
+		return *this;
+	}
+
+	bool notify(const void* /*sender*/)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_function)
+		{
+			(*_function)();
+			return true; 
+		}
+		else return false;
+	}
+
+	bool equals(const AbstractDelegate<void>& other) const
+	{
+		const FunctionDelegate* pOtherDelegate = dynamic_cast<const FunctionDelegate*>(other.unwrap());
+		return pOtherDelegate && _function == pOtherDelegate->_function;
+	}
+
+	AbstractDelegate<void>* clone() const
+	{
+		return new FunctionDelegate(*this);
+	}
+
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_function = 0;
+	}
+
+protected:
+	NotifyFunction _function;
+	Mutex _mutex;
+
+private:
+	FunctionDelegate();
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FunctionDelegate_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/FunctionPriorityDelegate.h b/base/poco/Foundation/include/Poco/FunctionPriorityDelegate.h
new file mode 100644
index 00000000000..60e6592048e
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/FunctionPriorityDelegate.h
@@ -0,0 +1,450 @@
+//
+// FunctionPriorityDelegate.h
+//
+// Library: Foundation
+// Package: Events
+// Module:  FunctionPriorityDelegate
+//
+// Implementation of the FunctionPriorityDelegate template.
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_FunctionPriorityDelegate_INCLUDED
+#define Foundation_FunctionPriorityDelegate_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/AbstractPriorityDelegate.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+
+
+template <class TArgs, bool useSender = true, bool senderIsConst = true> 
+class FunctionPriorityDelegate: public AbstractPriorityDelegate<TArgs>
+	/// Wraps a freestanding function or static member function 
+	/// for use as a PriorityDelegate.
+{
+public:
+	typedef void (*NotifyFunction)(const void*, TArgs&);
+
+	FunctionPriorityDelegate(NotifyFunction function, int prio):
+		AbstractPriorityDelegate<TArgs>(prio),
+		_function(function)
+	{
+	}
+	
+	FunctionPriorityDelegate(const FunctionPriorityDelegate& delegate):
+		AbstractPriorityDelegate<TArgs>(delegate),
+		_function(delegate._function)
+	{
+	}
+	
+	FunctionPriorityDelegate& operator = (const FunctionPriorityDelegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_function = delegate._function;
+			this->_priority = delegate._priority;
+		}
+		return *this;
+	}
+
+	~FunctionPriorityDelegate()
+	{
+	}
+
+	bool notify(const void* sender, TArgs& arguments)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_function)
+		{
+			(*_function)(sender, arguments);
+			return true;
+		}
+		else return false;
+	}
+
+	bool equals(const AbstractDelegate<TArgs>& other) const
+	{
+		const FunctionPriorityDelegate* pOtherDelegate = dynamic_cast<const FunctionPriorityDelegate*>(other.unwrap());
+		return pOtherDelegate && this->priority() == pOtherDelegate->priority() && _function == pOtherDelegate->_function;
+	}
+
+	AbstractDelegate<TArgs>* clone() const
+	{
+		return new FunctionPriorityDelegate(*this);
+	}
+
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_function = 0;
+	}
+
+protected:
+	NotifyFunction _function;
+	Mutex _mutex;
+
+private:
+	FunctionPriorityDelegate();
+};
+
+
+template <class TArgs> 
+class FunctionPriorityDelegate<TArgs, true, false>: public AbstractPriorityDelegate<TArgs>
+{
+public:
+	typedef void (*NotifyFunction)(void*, TArgs&);
+
+	FunctionPriorityDelegate(NotifyFunction function, int prio):
+		AbstractPriorityDelegate<TArgs>(prio),
+		_function(function)
+	{
+	}
+	
+	FunctionPriorityDelegate(const FunctionPriorityDelegate& delegate):
+		AbstractPriorityDelegate<TArgs>(delegate),
+		_function(delegate._function)
+	{
+	}
+	
+	FunctionPriorityDelegate& operator = (const FunctionPriorityDelegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_function = delegate._function;
+			this->_priority = delegate._priority;
+		}
+		return *this;
+	}
+
+	~FunctionPriorityDelegate()
+	{
+	}
+
+	bool notify(const void* sender, TArgs& arguments)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_function)
+		{
+			(*_function)(const_cast<void*>(sender), arguments);
+			return true;
+		}
+		else return false;
+	}
+
+	bool equals(const AbstractDelegate<TArgs>& other) const
+	{
+		const FunctionPriorityDelegate* pOtherDelegate = dynamic_cast<const FunctionPriorityDelegate*>(other.unwrap());
+		return pOtherDelegate && this->priority() == pOtherDelegate->priority() && _function == pOtherDelegate->_function;
+	}
+
+	AbstractDelegate<TArgs>* clone() const
+	{
+		return new FunctionPriorityDelegate(*this);
+	}
+
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_function = 0;
+	}
+
+protected:
+	NotifyFunction _function;
+	Mutex _mutex;
+
+private:
+	FunctionPriorityDelegate();
+};
+
+
+template <class TArgs> 
+class FunctionPriorityDelegate<TArgs, false>: public AbstractPriorityDelegate<TArgs>
+{
+public:
+	typedef void (*NotifyFunction)(TArgs&);
+
+	FunctionPriorityDelegate(NotifyFunction function, int prio):
+		AbstractPriorityDelegate<TArgs>(prio),
+		_function(function)
+	{
+	}
+	
+	FunctionPriorityDelegate(const FunctionPriorityDelegate& delegate):
+		AbstractPriorityDelegate<TArgs>(delegate),
+		_function(delegate._function)
+	{
+	}
+	
+	FunctionPriorityDelegate& operator = (const FunctionPriorityDelegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_function = delegate._function;
+			this->_priority = delegate._priority;
+		}
+		return *this;
+	}
+
+	~FunctionPriorityDelegate()
+	{
+	}
+
+	bool notify(const void* sender, TArgs& arguments)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_function)
+		{
+			(*_function)(arguments);
+			return true;
+		}
+		else return false;
+	}
+
+	bool equals(const AbstractDelegate<TArgs>& other) const
+	{
+		const FunctionPriorityDelegate* pOtherDelegate = dynamic_cast<const FunctionPriorityDelegate*>(other.unwrap());
+		return pOtherDelegate && this->priority() == pOtherDelegate->priority() && _function == pOtherDelegate->_function;
+	}
+
+	AbstractDelegate<TArgs>* clone() const
+	{
+		return new FunctionPriorityDelegate(*this);
+	}
+
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_function = 0;
+	}
+
+protected:
+	NotifyFunction _function;
+	Mutex _mutex;
+
+private:
+	FunctionPriorityDelegate();
+};
+
+
+template <>
+class FunctionPriorityDelegate<void, true, true>: public AbstractPriorityDelegate<void>
+	/// Wraps a freestanding function or static member function
+	/// for use as a PriorityDelegate.
+{
+public:
+	typedef void (*NotifyFunction)(const void*);
+
+	FunctionPriorityDelegate(NotifyFunction function, int prio):
+		AbstractPriorityDelegate<void>(prio),
+		_function(function)
+	{
+	}
+
+	FunctionPriorityDelegate(const FunctionPriorityDelegate& delegate):
+		AbstractPriorityDelegate<void>(delegate),
+		_function(delegate._function)
+	{
+	}
+
+	FunctionPriorityDelegate& operator = (const FunctionPriorityDelegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_function = delegate._function;
+			this->_priority = delegate._priority;
+		}
+		return *this;
+	}
+
+	~FunctionPriorityDelegate()
+	{
+	}
+
+	bool notify(const void* sender)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_function)
+		{
+			(*_function)(sender);
+			return true;
+		}
+		else return false;
+	}
+
+	bool equals(const AbstractDelegate<void>& other) const
+	{
+		const FunctionPriorityDelegate* pOtherDelegate = dynamic_cast<const FunctionPriorityDelegate*>(other.unwrap());
+		return pOtherDelegate && this->priority() == pOtherDelegate->priority() && _function == pOtherDelegate->_function;
+	}
+
+	AbstractDelegate<void>* clone() const
+	{
+		return new FunctionPriorityDelegate(*this);
+	}
+
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_function = 0;
+	}
+
+protected:
+	NotifyFunction _function;
+	Mutex _mutex;
+
+private:
+	FunctionPriorityDelegate();
+};
+
+
+template <>
+class FunctionPriorityDelegate<void, true, false>: public AbstractPriorityDelegate<void>
+{
+public:
+	typedef void (*NotifyFunction)(void*);
+
+	FunctionPriorityDelegate(NotifyFunction function, int prio):
+		AbstractPriorityDelegate<void>(prio),
+		_function(function)
+	{
+	}
+
+	FunctionPriorityDelegate(const FunctionPriorityDelegate& delegate):
+		AbstractPriorityDelegate<void>(delegate),
+		_function(delegate._function)
+	{
+	}
+
+	FunctionPriorityDelegate& operator = (const FunctionPriorityDelegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_function = delegate._function;
+			this->_priority = delegate._priority;
+		}
+		return *this;
+	}
+
+	~FunctionPriorityDelegate()
+	{
+	}
+
+	bool notify(const void* sender)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_function)
+		{
+			(*_function)(const_cast<void*>(sender));
+			return true;
+		}
+		else return false;
+	}
+
+	bool equals(const AbstractDelegate<void>& other) const
+	{
+		const FunctionPriorityDelegate* pOtherDelegate = dynamic_cast<const FunctionPriorityDelegate*>(other.unwrap());
+		return pOtherDelegate && this->priority() == pOtherDelegate->priority() && _function == pOtherDelegate->_function;
+	}
+
+	AbstractDelegate<void>* clone() const
+	{
+		return new FunctionPriorityDelegate(*this);
+	}
+
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_function = 0;
+	}
+
+protected:
+	NotifyFunction _function;
+	Mutex _mutex;
+
+private:
+	FunctionPriorityDelegate();
+};
+
+
+template <>
+class FunctionPriorityDelegate<void, false>: public AbstractPriorityDelegate<void>
+{
+public:
+	typedef void (*NotifyFunction)();
+
+	FunctionPriorityDelegate(NotifyFunction function, int prio):
+		AbstractPriorityDelegate<void>(prio),
+		_function(function)
+	{
+	}
+
+	FunctionPriorityDelegate(const FunctionPriorityDelegate& delegate):
+		AbstractPriorityDelegate<void>(delegate),
+		_function(delegate._function)
+	{
+	}
+
+	FunctionPriorityDelegate& operator = (const FunctionPriorityDelegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_function = delegate._function;
+			this->_priority = delegate._priority;
+		}
+		return *this;
+	}
+
+	~FunctionPriorityDelegate()
+	{
+	}
+
+	bool notify(const void* sender)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_function)
+		{
+			(*_function)();
+			return true;
+		}
+		else return false;
+	}
+
+	bool equals(const AbstractDelegate<void>& other) const
+	{
+		const FunctionPriorityDelegate* pOtherDelegate = dynamic_cast<const FunctionPriorityDelegate*>(other.unwrap());
+		return pOtherDelegate && this->priority() == pOtherDelegate->priority() && _function == pOtherDelegate->_function;
+	}
+
+	AbstractDelegate<void>* clone() const
+	{
+		return new FunctionPriorityDelegate(*this);
+	}
+
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_function = 0;
+	}
+
+protected:
+	NotifyFunction _function;
+	Mutex _mutex;
+
+private:
+	FunctionPriorityDelegate();
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_FunctionPriorityDelegate_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Glob.h b/base/poco/Foundation/include/Poco/Glob.h
new file mode 100644
index 00000000000..bdaccc6059e
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Glob.h
@@ -0,0 +1,152 @@
+//
+// Glob.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  Glob
+//
+// Definition of the Glob class.
+//
+// Copyright (c) 2004-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Glob_INCLUDED
+#define Foundation_Glob_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/TextIterator.h"
+#include <set>
+
+
+namespace Poco {
+
+
+class Path;
+
+
+class Foundation_API Glob
+	/// This class implements glob-style pattern matching
+	/// as known from Unix shells.
+	///
+	/// In the pattern string, '*' matches any sequence of characters,
+	/// '?' matches any single character, [SET] matches any single character 
+	/// in the specified set, [!SET] matches any character not in the  
+	/// specified set.
+	///
+	/// A set is composed of characters or ranges; a range looks like
+	/// character hyphen character (as in 0-9 or A-Z).
+	/// [0-9a-zA-Z_] is the set of characters allowed in C identifiers.
+	/// Any other character in the pattern must be matched exactly.
+	///
+	/// To suppress the special syntactic significance of any of '[]*?!-\',
+	/// and match the character exactly, precede it with a backslash.
+	///
+	/// All strings are assumed to be UTF-8 encoded.
+{
+public:
+	enum Options
+		/// Flags that modify the matching behavior.
+	{
+		GLOB_DEFAULT         = 0x00, /// default behavior
+		GLOB_DOT_SPECIAL     = 0x01, /// '*' and '?' do not match '.' at beginning of subject
+		GLOB_FOLLOW_SYMLINKS = 0x02, /// follow symbolic links
+		GLOB_CASELESS        = 0x04, /// ignore case when comparing characters
+		GLOB_DIRS_ONLY       = 0x80  /// only glob for directories (for internal use only)
+	};
+	
+	Glob(const std::string& pattern, int options = 0);
+		/// Creates the Glob, using the given pattern. The pattern
+		/// must not be an empty string.
+		///
+		/// If the GLOB_DOT_SPECIAL option is specified, '*' and '?' do 
+		/// not match '.' at the beginning of a matched subject. This is useful for
+		/// making dot-files invisible in good old Unix-style.
+
+	~Glob();
+		/// Destroys the Glob.
+		
+	bool match(const std::string& subject);
+		/// Matches the given subject against the glob pattern.
+		/// Returns true if the subject matches the pattern, false
+		/// otherwise.
+		
+	static void glob(const std::string& pathPattern, std::set<std::string>& files, int options = 0);
+		/// Creates a set of files that match the given pathPattern.
+		///
+		/// The path may be give in either Unix, Windows or VMS syntax and
+		/// is automatically expanded by calling Path::expand().
+		///
+		/// The pattern may contain wildcard expressions even in intermediate
+		/// directory names (e.g. /usr/include/*/*.h).
+		///
+		/// Note that, for obvious reasons, escaping characters in a pattern
+		/// with a backslash does not work in Windows-style paths.
+		///
+		/// Directories that for whatever reason cannot be traversed are
+		/// ignored.
+
+	static void glob(const char* pathPattern, std::set<std::string>& files, int options = 0);
+		/// Creates a set of files that match the given pathPattern.
+		///
+		/// The path may be give in either Unix, Windows or VMS syntax and
+		/// is automatically expanded by calling Path::expand().
+		///
+		/// The pattern may contain wildcard expressions even in intermediate
+		/// directory names (e.g. /usr/include/*/*.h).
+		///
+		/// Note that, for obvious reasons, escaping characters in a pattern
+		/// with a backslash does not work in Windows-style paths.
+		///
+		/// Directories that for whatever reason cannot be traversed are
+		/// ignored.
+
+	static void glob(const Path& pathPattern, std::set<std::string>& files, int options = 0);
+		/// Creates a set of files that match the given pathPattern.
+		///
+		/// The pattern may contain wildcard expressions even in intermediate
+		/// directory names (e.g. /usr/include/*/*.h).
+		///
+		/// Note that, for obvious reasons, escaping characters in a pattern
+		/// with a backslash does not work in Windows-style paths.
+		///
+		/// Directories that for whatever reason cannot be traversed are
+		/// ignored.
+
+	static void glob(const Path& pathPattern, const Path& basePath, std::set<std::string>& files, int options = 0);
+		/// Creates a set of files that match the given pathPattern, starting from basePath.
+		///
+		/// The pattern may contain wildcard expressions even in intermediate
+		/// directory names (e.g. /usr/include/*/*.h).
+		///
+		/// Note that, for obvious reasons, escaping characters in a pattern
+		/// with a backslash does not work in Windows-style paths.
+		///
+		/// Directories that for whatever reason cannot be traversed are
+		/// ignored.
+
+protected:
+	bool match(TextIterator& itp, const TextIterator& endp, TextIterator& its, const TextIterator& ends);
+	bool matchAfterAsterisk(TextIterator itp, const TextIterator& endp, TextIterator its, const TextIterator& ends);
+	bool matchSet(TextIterator& itp, const TextIterator& endp, int c);
+	static void collect(const Path& pathPattern, const Path& base, const Path& current, const std::string& pattern, std::set<std::string>& files, int options);
+	static bool isDirectory(const Path& path, bool followSymlink);
+	
+private:
+	std::string _pattern;
+	int         _options;
+
+	Glob();
+	Glob(const Glob&);
+	Glob& operator = (const Glob&);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Glob_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/HMACEngine.h b/base/poco/Foundation/include/Poco/HMACEngine.h
new file mode 100644
index 00000000000..0593e7d2c17
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/HMACEngine.h
@@ -0,0 +1,146 @@
+//
+// HMACEngine.h
+//
+// Library: Foundation
+// Package: Crypt
+// Module:  HMACEngine
+//
+// Definition of the HMACEngine class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_HMACEngine_INCLUDED
+#define Foundation_HMACEngine_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/DigestEngine.h"
+#include <cstring>
+
+
+namespace Poco {
+
+
+template <class Engine>
+class HMACEngine: public DigestEngine
+	/// This class implementes the HMAC message
+	/// authentication code algorithm, as specified
+	/// in RFC 2104. The underlying DigestEngine
+	/// (MD5Engine, SHA1Engine, etc.) must be given as 
+	/// template argument.
+	/// Since the HMACEngine is a DigestEngine, it can
+	/// be used with the DigestStream class to create
+	/// a HMAC for a stream.
+{
+public:
+	enum
+	{
+		BLOCK_SIZE  = Engine::BLOCK_SIZE,
+		DIGEST_SIZE = Engine::DIGEST_SIZE
+	};
+	
+	HMACEngine(const std::string& passphrase)
+	{
+		init(passphrase.data(), passphrase.length());
+	}
+	
+	HMACEngine(const char* passphrase, std::size_t length)
+	{
+		poco_check_ptr (passphrase);
+
+		init(passphrase, length);
+	}
+	
+	~HMACEngine()
+	{
+		std::memset(_ipad, 0, BLOCK_SIZE);
+		std::memset(_opad, 0, BLOCK_SIZE);
+		delete [] _ipad;
+		delete [] _opad;
+	}
+		
+	std::size_t digestLength() const
+	{
+		return DIGEST_SIZE;
+	}
+	
+	void reset()
+	{
+		_engine.reset();
+		_engine.update(_ipad, BLOCK_SIZE);
+	}
+	
+	const DigestEngine::Digest& digest()
+	{
+		const DigestEngine::Digest& d = _engine.digest();
+		char db[DIGEST_SIZE];
+		char* pdb = db;
+		for (DigestEngine::Digest::const_iterator it = d.begin(); it != d.end(); ++it)
+			*pdb++ = *it;
+		_engine.reset();
+		_engine.update(_opad, BLOCK_SIZE);
+		_engine.update(db, DIGEST_SIZE);
+		const DigestEngine::Digest& result = _engine.digest();
+		reset();
+		return result;
+	}
+
+protected:
+	void init(const char* passphrase, std::size_t length)
+	{
+		_ipad = new char[BLOCK_SIZE];
+		_opad = new char[BLOCK_SIZE];
+		std::memset(_ipad, 0, BLOCK_SIZE);
+		std::memset(_opad, 0, BLOCK_SIZE);
+		if (length > BLOCK_SIZE)
+		{
+			_engine.reset();
+			_engine.update(passphrase, length);
+			const DigestEngine::Digest& d = _engine.digest();
+			char* ipad = _ipad;
+			char* opad = _opad;
+			int n = BLOCK_SIZE;
+			for (DigestEngine::Digest::const_iterator it = d.begin(); it != d.end() && n-- > 0; ++it)
+			{
+				*ipad++ = *it;
+				*opad++ = *it;
+			}
+		}
+		else
+		{
+			std::memcpy(_ipad, passphrase, length);
+			std::memcpy(_opad, passphrase, length);
+		}
+		for (int i = 0; i < BLOCK_SIZE; ++i)
+		{
+			_ipad[i] ^= 0x36;
+			_opad[i] ^= 0x5c;
+		}
+		reset();
+	}
+	
+	void updateImpl(const void* data, std::size_t length)
+	{
+		_engine.update(data, length);
+	}
+
+private:
+	HMACEngine();
+	HMACEngine(const HMACEngine&);
+	HMACEngine& operator = (const HMACEngine&);
+
+	Engine _engine;
+	char*  _ipad;
+	char*  _opad;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_HMACEngine_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Hash.h b/base/poco/Foundation/include/Poco/Hash.h
new file mode 100644
index 00000000000..7aafb66a69b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Hash.h
@@ -0,0 +1,105 @@
+//
+// Hash.h
+//
+// Library: Foundation
+// Package: Hashing
+// Module:  Hash
+//
+// Definition of the Hash class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Hash_INCLUDED
+#define Foundation_Hash_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <cstddef>
+
+
+namespace Poco {
+
+
+std::size_t Foundation_API hash(Int8 n);
+std::size_t Foundation_API hash(UInt8 n);
+std::size_t Foundation_API hash(Int16 n);
+std::size_t Foundation_API hash(UInt16 n);
+std::size_t Foundation_API hash(Int32 n);
+std::size_t Foundation_API hash(UInt32 n);
+std::size_t Foundation_API hash(Int64 n);
+std::size_t Foundation_API hash(UInt64 n);
+std::size_t Foundation_API hash(const std::string& str);
+
+
+template <class T>
+struct Hash
+	/// A generic hash function.
+{
+	std::size_t operator () (T value) const
+		/// Returns the hash for the given value.
+	{
+		return Poco::hash(value);
+	}
+};
+
+
+//
+// inlines
+//
+inline std::size_t hash(Int8 n)
+{
+	return static_cast<std::size_t>(n)*2654435761U; 
+}
+
+
+inline std::size_t hash(UInt8 n)
+{
+	return static_cast<std::size_t>(n)*2654435761U; 
+}
+
+
+inline std::size_t hash(Int16 n)
+{
+	return static_cast<std::size_t>(n)*2654435761U; 
+}
+
+
+inline std::size_t hash(UInt16 n)
+{
+	return static_cast<std::size_t>(n)*2654435761U; 
+}
+
+
+inline std::size_t hash(Int32 n)
+{
+	return static_cast<std::size_t>(n)*2654435761U; 
+}
+
+
+inline std::size_t hash(UInt32 n)
+{
+	return static_cast<std::size_t>(n)*2654435761U; 
+}
+
+
+inline std::size_t hash(Int64 n)
+{
+	return static_cast<std::size_t>(n)*2654435761U; 
+}
+
+
+inline std::size_t hash(UInt64 n)
+{
+	return static_cast<std::size_t>(n)*2654435761U; 
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Hash_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/HashFunction.h b/base/poco/Foundation/include/Poco/HashFunction.h
new file mode 100644
index 00000000000..c451d0699d3
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/HashFunction.h
@@ -0,0 +1,57 @@
+//
+// HashFunction.h
+//
+// Library: Foundation
+// Package: Hashing
+// Module:  HashFunction
+//
+// Definition of the HashFunction class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_HashFunction_INCLUDED
+#define Foundation_HashFunction_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Hash.h"
+
+
+namespace Poco {
+
+
+//@ deprecated
+template <class T>
+struct HashFunction
+	/// A generic hash function.
+{
+	UInt32 operator () (T key, UInt32 maxValue) const
+		/// Returns the hash value for the given key.
+	{
+		return static_cast<UInt32>(Poco::hash(key)) % maxValue;
+	}
+};
+
+
+//@ deprecated
+template <>
+struct HashFunction<std::string>
+	/// A generic hash function.
+{
+	UInt32 operator () (const std::string& key, UInt32 maxValue) const
+		/// Returns the hash value for the given key.
+	{
+		return static_cast<UInt32>(Poco::hash(key)) % maxValue;
+	}
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_HashFunctions_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/HashMap.h b/base/poco/Foundation/include/Poco/HashMap.h
new file mode 100644
index 00000000000..5153f2b164e
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/HashMap.h
@@ -0,0 +1,228 @@
+//
+// HashMap.h
+//
+// Library: Foundation
+// Package: Hashing
+// Module:  HashMap
+//
+// Definition of the HashMap class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_HashMap_INCLUDED
+#define Foundation_HashMap_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/LinearHashTable.h"
+#include "Poco/Exception.h"
+#include <utility>
+
+
+namespace Poco {
+
+
+template <class Key, class Value>
+struct HashMapEntry
+	/// This class template is used internally by HashMap.
+{
+	Key   first;
+	Value second;
+	
+	HashMapEntry():
+		first(),
+		second()
+	{
+	}
+	
+	HashMapEntry(const Key& key):
+		first(key),
+		second()
+	{
+	}
+
+	HashMapEntry(const Key& key, const Value& value):
+		first(key),
+		second(value)
+	{
+	}
+	
+	bool operator == (const HashMapEntry& entry) const
+	{
+		return first == entry.first;
+	}
+
+	bool operator != (const HashMapEntry& entry) const
+	{
+		return first != entry.first;
+	}
+};
+
+
+template <class HME, class KeyHashFunc>
+struct HashMapEntryHash
+	/// This class template is used internally by HashMap.
+{
+	std::size_t operator () (const HME& entry) const
+	{
+		return _func(entry.first);
+	}
+
+private:
+	KeyHashFunc _func;
+};
+
+
+template <class Key, class Mapped, class HashFunc = Hash<Key> >
+class HashMap
+	/// This class implements a map using a LinearHashTable.
+	///
+	/// A HashMap can be used just like a std::map.
+{
+public:
+	typedef Key                 KeyType;
+	typedef Mapped              MappedType;
+	typedef Mapped&             Reference;
+	typedef const Mapped&       ConstReference;
+	typedef Mapped*             Pointer;
+	typedef const Mapped*       ConstPointer;
+	
+	typedef HashMapEntry<Key, Mapped>      ValueType;
+	typedef std::pair<KeyType, MappedType> PairType;
+	
+	typedef HashMapEntryHash<ValueType, HashFunc> HashType;
+	typedef LinearHashTable<ValueType, HashType>  HashTable;
+	
+	typedef typename HashTable::Iterator      Iterator;
+	typedef typename HashTable::ConstIterator ConstIterator;
+	
+	HashMap()
+		/// Creates an empty HashMap.
+	{
+	}
+	
+	HashMap(std::size_t initialReserve):
+		_table(initialReserve)
+		/// Creates the HashMap with room for initialReserve entries.
+	{
+	}
+	
+	HashMap& operator = (const HashMap& map)
+		/// Assigns another HashMap.
+	{
+		HashMap tmp(map);
+		swap(tmp);
+		return *this;
+	}
+	
+	void swap(HashMap& map)
+		/// Swaps the HashMap with another one.
+	{
+		_table.swap(map._table);
+	}
+	
+	ConstIterator begin() const
+	{
+		return _table.begin();
+	}
+	
+	ConstIterator end() const
+	{
+		return _table.end();
+	}
+	
+	Iterator begin()
+	{
+		return _table.begin();
+	}
+	
+	Iterator end()
+	{
+		return _table.end();
+	}
+	
+	ConstIterator find(const KeyType& key) const
+	{
+		ValueType value(key);
+		return _table.find(value);
+	}
+
+	Iterator find(const KeyType& key)
+	{
+		ValueType value(key);
+		return _table.find(value);
+	}
+
+	std::size_t count(const KeyType& key) const
+	{
+		ValueType value(key);
+		return _table.find(value) != _table.end() ? 1 : 0;
+	}
+
+	std::pair<Iterator, bool> insert(const PairType& pair)
+	{
+		ValueType value(pair.first, pair.second);
+		return _table.insert(value);
+	}
+
+	std::pair<Iterator, bool> insert(const ValueType& value)
+	{
+		return _table.insert(value);
+	}
+	
+	void erase(Iterator it)
+	{
+		_table.erase(it);
+	}
+	
+	void erase(const KeyType& key)
+	{
+		Iterator it = find(key);
+		_table.erase(it);
+	}
+	
+	void clear()
+	{
+		_table.clear();
+	}
+
+	std::size_t size() const
+	{
+		return _table.size();
+	}
+
+	bool empty() const
+	{
+		return _table.empty();
+	}
+
+	ConstReference operator [] (const KeyType& key) const
+	{
+		ConstIterator it = _table.find(key);
+		if (it != _table.end())
+			return it->second;
+		else
+			throw NotFoundException();
+	}
+
+	Reference operator [] (const KeyType& key)
+	{
+		ValueType value(key);
+		std::pair<Iterator, bool> res = _table.insert(value);
+		return res.first->second;
+	}
+
+private:
+	HashTable _table;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_HashMap_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/HashSet.h b/base/poco/Foundation/include/Poco/HashSet.h
new file mode 100644
index 00000000000..e24560c001d
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/HashSet.h
@@ -0,0 +1,177 @@
+//
+// HashSet.h
+//
+// Library: Foundation
+// Package: Hashing
+// Module:  HashSet
+//
+// Definition of the HashSet class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_HashSet_INCLUDED
+#define Foundation_HashSet_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/LinearHashTable.h"
+
+
+namespace Poco {
+
+
+template <class Value, class HashFunc = Hash<Value> >
+class HashSet
+	/// This class implements a set using a LinearHashTable.
+	///
+	/// A HashSet can be used just like a std::set.
+{
+public:
+	typedef Value        ValueType;
+	typedef Value&       Reference;
+	typedef const Value& ConstReference;
+	typedef Value*       Pointer;
+	typedef const Value* ConstPointer;
+	typedef HashFunc     Hash;
+	
+	typedef LinearHashTable<ValueType, Hash> HashTable;
+	
+	typedef typename HashTable::Iterator      Iterator;
+	typedef typename HashTable::ConstIterator ConstIterator;
+
+	HashSet()
+		/// Creates an empty HashSet.
+	{
+	}
+
+	HashSet(std::size_t initialReserve): 
+		_table(initialReserve)
+		/// Creates the HashSet, using the given initialReserve.
+	{
+	}
+	
+	HashSet(const HashSet& set):
+		_table(set._table)
+		/// Creates the HashSet by copying another one.
+	{
+	}
+	
+	~HashSet()
+		/// Destroys the HashSet.
+	{
+	}
+	
+	HashSet& operator = (const HashSet& table)
+		/// Assigns another HashSet.
+	{
+		HashSet tmp(table);
+		swap(tmp);
+		return *this;
+	}
+	
+	void swap(HashSet& set)
+		/// Swaps the HashSet with another one.
+	{
+		_table.swap(set._table);
+	}
+	
+	ConstIterator begin() const
+		/// Returns an iterator pointing to the first entry, if one exists.
+	{
+		return _table.begin();
+	}
+	
+	ConstIterator end() const
+		/// Returns an iterator pointing to the end of the table.
+	{
+		return _table.end();
+	}
+	
+	Iterator begin()
+		/// Returns an iterator pointing to the first entry, if one exists.
+	{
+		return _table.begin();
+	}
+	
+	Iterator end()
+		/// Returns an iterator pointing to the end of the table.
+	{
+		return _table.end();
+	}
+		
+	ConstIterator find(const ValueType& value) const
+		/// Finds an entry in the table.
+	{
+		return _table.find(value);
+	}
+
+	Iterator find(const ValueType& value)
+		/// Finds an entry in the table.
+	{
+		return _table.find(value);
+	}
+	
+	std::size_t count(const ValueType& value) const
+		/// Returns the number of elements with the given
+		/// value, with is either 1 or 0.
+	{
+		return _table.count(value);
+	}
+	
+	std::pair<Iterator, bool> insert(const ValueType& value)
+		/// Inserts an element into the set.
+		///
+		/// If the element already exists in the set,
+		/// a pair(iterator, false) with iterator pointing to the 
+		/// existing element is returned.
+		/// Otherwise, the element is inserted an a 
+		/// pair(iterator, true) with iterator
+		/// pointing to the new element is returned.
+	{
+		return _table.insert(value);
+	}
+	
+	void erase(Iterator it)
+		/// Erases the element pointed to by it.
+	{
+		_table.erase(it);
+	}
+	
+	void erase(const ValueType& value)
+		/// Erases the element with the given value, if it exists.
+	{
+		_table.erase(value);
+	}
+	
+	void clear()
+		/// Erases all elements.
+	{
+		_table.clear();
+	}
+	
+	std::size_t size() const
+		/// Returns the number of elements in the table.
+	{
+		return _table.size();
+	}
+	
+	bool empty() const
+		/// Returns true iff the table is empty.
+	{
+		return _table.empty();
+	}
+
+private:
+	HashTable _table;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_HashSet_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/HashStatistic.h b/base/poco/Foundation/include/Poco/HashStatistic.h
new file mode 100644
index 00000000000..ac413fb09a1
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/HashStatistic.h
@@ -0,0 +1,126 @@
+//
+// HashStatistic.h
+//
+// Library: Foundation
+// Package: Hashing
+// Module:  HashStatistic
+//
+// Definition of the HashStatistic class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_HashStatistic_INCLUDED
+#define Foundation_HashStatistic_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <vector>
+
+
+namespace Poco {
+
+
+//@ deprecated
+class Foundation_API HashStatistic
+	/// HashStatistic class bundles statistical information on the current state of a HashTable
+{
+public:
+	HashStatistic(
+		UInt32 tableSize, 
+		UInt32 numEntries, 
+		UInt32 numZeroEntries, 
+		UInt32 maxEntry, 
+		std::vector<UInt32> details = std::vector<UInt32>());
+		/// Creates the HashStatistic.
+
+	virtual ~HashStatistic();
+		/// Destroys the HashStatistic.
+
+	UInt32 maxPositionsOfTable() const;
+		/// Returns the maximum number of different hash values possible for the table
+
+	UInt32 numberOfEntries() const;
+		/// Returns the total number of entries currently stored in the HashTable
+
+	UInt32 numberOfZeroPositions() const;
+		/// Returns the number of hash positions that contain no entry.
+
+	double avgEntriesPerHash() const;
+		/// Returns the average number of entries per position in the Hashtable, the higher this value the less efficient
+		/// performs hashing. If a large value is returned and getNumberOfZeroPositions also returns a large value, this
+		/// indicates an inefficient hashing function. If the number of zero entries is low, resizing the HashTable, should
+		/// be enough to improve performance
+
+	double avgEntriesPerHashExclZeroEntries() const;
+		/// Same as getAvgEntriesPerHash but hash values that contain no entry are ignored,
+		/// getAvgEntriesPerHashExclZeroEntries >= getAvgEntriesPerHash will always be true.
+
+	UInt32 maxEntriesPerHash() const;
+		/// Returns the maximum number of entries per hash value found in the current table.
+
+	const std::vector<UInt32> detailedEntriesPerHash() const;
+		/// Will either be an empty vector or will contain for each possible hash value, the number of entries currently stored
+
+	std::string toString() const;
+		/// Converts the whole data structure into a string.
+
+private:
+	UInt32 _sizeOfTable;
+	UInt32 _numberOfEntries;
+	UInt32 _numZeroEntries;
+	UInt32 _maxEntriesPerHash;
+	std::vector<UInt32> _detailedEntriesPerHash;
+};
+
+
+inline UInt32 HashStatistic::maxPositionsOfTable() const
+{
+	return _sizeOfTable;
+}
+
+
+inline UInt32 HashStatistic::numberOfEntries() const
+{
+	return _numberOfEntries;
+}
+
+
+inline UInt32 HashStatistic::numberOfZeroPositions() const
+{
+	return _numZeroEntries;
+}
+
+
+inline double HashStatistic::avgEntriesPerHash() const
+{
+	return ((double) numberOfEntries()) / maxPositionsOfTable();
+}
+
+
+inline double HashStatistic::avgEntriesPerHashExclZeroEntries() const
+{
+	return ((double) numberOfEntries()) / (maxPositionsOfTable() - numberOfZeroPositions());
+}
+
+
+inline UInt32 HashStatistic::maxEntriesPerHash() const
+{
+	return _maxEntriesPerHash;
+}
+
+
+inline const std::vector<UInt32> HashStatistic::detailedEntriesPerHash() const
+{
+	return _detailedEntriesPerHash;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_HashStatistic_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/HashTable.h b/base/poco/Foundation/include/Poco/HashTable.h
new file mode 100644
index 00000000000..e71af1e12c6
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/HashTable.h
@@ -0,0 +1,369 @@
+//
+// HashTable.h
+//
+// Library: Foundation
+// Package: Hashing
+// Module:  HashTable
+//
+// Definition of the HashTable class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_HashTable_INCLUDED
+#define Foundation_HashTable_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include "Poco/HashFunction.h"
+#include "Poco/HashStatistic.h"
+#include <vector>
+#include <map>
+#include <cstddef>
+#include <cstring>
+
+
+namespace Poco {
+
+
+//@ deprecated
+template <class Key, class Value, class KeyHashFunction = HashFunction<Key> >
+class HashTable
+	/// A HashTable stores a key value pair that can be looked up via a hashed key.
+	///
+	/// Collision handling is done via overflow maps(!). With small hash tables performance of this
+	/// data struct will be closer to that a map than a hash table, i.e. slower. On the plus side,
+	/// this class offers remove operations. Also HashTable full errors are not possible. If a fast
+	/// HashTable implementation is needed and the remove operation is not required, use SimpleHashTable
+	/// instead.
+	///
+	/// This class is NOT thread safe.
+{
+public:
+	typedef std::map<Key, Value> HashEntryMap;
+	typedef HashEntryMap**       HashTableVector;
+
+	typedef typename HashEntryMap::const_iterator ConstIterator;
+	typedef typename HashEntryMap::iterator Iterator;
+
+	HashTable(UInt32 initialSize = 251): 
+		_entries(0), 
+		_size(0), 
+		_maxCapacity(initialSize)
+		/// Creates the HashTable.
+	{
+		_entries = new HashEntryMap*[initialSize];
+		memset(_entries, '\0', sizeof(HashEntryMap*)*initialSize);
+	}
+
+	HashTable(const HashTable& ht):
+		_entries(new HashEntryMap*[ht._maxCapacity]),
+		_size(ht._size),
+		_maxCapacity(ht._maxCapacity)
+	{
+		for (UInt32 i = 0; i < _maxCapacity; ++i)
+		{
+			if (ht._entries[i])
+				_entries[i] = new HashEntryMap(ht._entries[i]->begin(), ht._entries[i]->end());
+			else
+				_entries[i] = 0;
+		}
+	}
+
+	~HashTable()
+		/// Destroys the HashTable.
+	{
+		clear();
+	}
+
+	HashTable& operator = (const HashTable& ht)
+	{
+		if (this != &ht)
+		{
+			clear();
+			_maxCapacity = ht._maxCapacity;
+			poco_assert_dbg (_entries == 0);
+			_entries = new HashEntryMap*[_maxCapacity];
+			_size = ht._size;
+
+			for (UInt32 i = 0; i < _maxCapacity; ++i)
+			{
+				if (ht._entries[i])
+					_entries[i] = new HashEntryMap(ht._entries[i]->begin(), ht._entries[i]->end());
+				else
+					_entries[i] = 0;
+			}
+		}
+		return *this;
+	}
+
+	void clear()
+	{
+		if (!_entries)
+			return;
+		for (UInt32 i = 0; i < _maxCapacity; ++i)
+		{
+			delete _entries[i];
+		}
+		delete[] _entries;
+		_entries     = 0;
+		_size        = 0;
+		_maxCapacity = 0;
+	}
+
+	UInt32 insert(const Key& key, const Value& value)
+		/// Returns the hash value of the inserted item.
+		/// Throws an exception if the entry was already inserted
+	{
+		UInt32 hsh = hash(key);
+		insertRaw(key, hsh, value);
+		return hsh;
+	}
+
+	Value& insertRaw(const Key& key, UInt32 hsh, const Value& value)
+		/// Returns the hash value of the inserted item.
+		/// Throws an exception if the entry was already inserted
+	{
+		if (!_entries[hsh])
+			_entries[hsh] = new HashEntryMap();
+		std::pair<typename HashEntryMap::iterator, bool> res(_entries[hsh]->insert(std::make_pair(key, value)));
+		if (!res.second)
+			throw InvalidArgumentException("HashTable::insert, key already exists.");
+		_size++;
+		return res.first->second;
+	}
+
+	UInt32 update(const Key& key, const Value& value)
+		/// Returns the hash value of the inserted item.
+		/// Replaces an existing entry if it finds one
+	{
+		UInt32 hsh = hash(key);
+		updateRaw(key, hsh, value);
+		return hsh;
+	}
+
+	void updateRaw(const Key& key, UInt32 hsh, const Value& value)
+		/// Returns the hash value of the inserted item.
+		/// Replaces an existing entry if it finds one
+	{
+		if (!_entries[hsh])
+			_entries[hsh] = new HashEntryMap();
+		std::pair<Iterator, bool> res = _entries[hsh]->insert(std::make_pair(key, value));
+		if (res.second == false)
+			res.first->second = value;
+		else
+			_size++;
+	}
+
+	void remove(const Key& key)
+	{
+		UInt32 hsh = hash(key);
+		removeRaw(key, hsh);
+	}
+
+	void removeRaw(const Key& key, UInt32 hsh)
+		/// Performance version, allows to specify the hash value
+	{
+		if (_entries[hsh])
+		{
+			_size -= _entries[hsh]->erase(key);
+		}
+	}
+
+	UInt32 hash(const Key& key) const
+	{
+		return _hash(key, _maxCapacity);
+	}
+
+	const Value& get(const Key& key) const
+		/// Throws an exception if the value does not exist
+	{
+		UInt32 hsh = hash(key);
+		return getRaw(key, hsh);
+	}
+
+	const Value& getRaw(const Key& key, UInt32 hsh) const
+		/// Throws an exception if the value does not exist
+	{
+		if (!_entries[hsh])
+			throw InvalidArgumentException("key not found");
+
+		ConstIterator it = _entries[hsh]->find(key);
+		if (it == _entries[hsh]->end())
+			throw InvalidArgumentException("key not found");
+
+		return it->second;
+	}
+
+	Value& get(const Key& key)
+		/// Throws an exception if the value does not exist
+	{
+		UInt32 hsh = hash(key);
+		return const_cast<Value&>(getRaw(key, hsh));
+	}
+
+	const Value& operator [] (const Key& key) const
+	{
+		return get(key);
+	}
+	
+	Value& operator [] (const Key& key)
+	{
+		UInt32 hsh = hash(key);
+
+		if (!_entries[hsh])
+			return insertRaw(key, hsh, Value());
+			
+		ConstIterator it = _entries[hsh]->find(key);
+		if (it == _entries[hsh]->end())
+			return insertRaw(key, hsh, Value());
+
+		return it->second;
+	}
+	
+	const Key& getKeyRaw(const Key& key, UInt32 hsh)
+		/// Throws an exception if the key does not exist. returns a reference to the internally
+		/// stored key. Useful when someone does an insert and wants for performance reason only to store
+		/// a pointer to the key in another collection
+	{
+		if (!_entries[hsh])
+			throw InvalidArgumentException("key not found");
+		ConstIterator it = _entries[hsh]->find(key);
+		if (it == _entries[hsh]->end())
+			throw InvalidArgumentException("key not found");
+		return it->first;
+	}
+
+	bool get(const Key& key, Value& v) const
+		/// Sets v to the found value, returns false if no value was found
+	{
+		UInt32 hsh = hash(key);
+		return getRaw(key, hsh, v);
+	}
+
+	bool getRaw(const Key& key, UInt32 hsh, Value& v) const
+		/// Sets v to the found value, returns false if no value was found
+	{
+		if (!_entries[hsh])
+			return false;
+
+		ConstIterator it = _entries[hsh]->find(key);
+		if (it == _entries[hsh]->end())
+			return false;
+
+		v = it->second;
+		return true;
+	}
+
+	bool exists(const Key& key)
+	{
+		UInt32 hsh = hash(key);
+		return existsRaw(key, hsh);
+	}
+
+	bool existsRaw(const Key& key, UInt32 hsh)
+	{
+		return _entries[hsh] && (_entries[hsh]->end() != _entries[hsh]->find(key));
+	}
+
+	std::size_t size() const
+		/// Returns the number of elements already inserted into the HashTable
+	{
+		return _size;
+	}
+	
+	UInt32 maxCapacity() const
+	{
+		return _maxCapacity;
+	}
+
+	void resize(UInt32 newSize)
+		/// Resizes the hashtable, rehashes all existing entries. Expensive!
+	{
+		if (_maxCapacity != newSize)
+		{
+			HashTableVector cpy = _entries;
+			_entries = 0;
+			UInt32 oldSize = _maxCapacity;
+			_maxCapacity = newSize;
+			_entries = new HashEntryMap*[_maxCapacity];
+			memset(_entries, '\0', sizeof(HashEntryMap*)*_maxCapacity);
+
+			if (_size == 0)
+			{
+				// no data was yet inserted
+				delete[] cpy;
+				return;
+			}
+			_size = 0;
+			for (UInt32 i = 0; i < oldSize; ++i)
+			{
+				if (cpy[i])
+				{
+					ConstIterator it = cpy[i]->begin();
+					ConstIterator itEnd = cpy[i]->end();
+					for (; it != itEnd; ++it)
+					{
+						insert(it->first, it->second);
+					}
+					delete cpy[i];
+				}
+			}
+			delete[] cpy;
+		}
+	}
+
+	HashStatistic currentState(bool details = false) const
+		/// Returns the current internal state
+	{
+		UInt32 numberOfEntries = (UInt32)_size;
+		UInt32 numZeroEntries = 0;
+		UInt32 maxEntriesPerHash = 0;
+		std::vector<UInt32> detailedEntriesPerHash;
+	#ifdef _DEBUG
+		UInt32 totalSize = 0;
+	#endif
+		for (UInt32 i = 0; i < _maxCapacity; ++i)
+		{
+			if (_entries[i])
+			{
+				UInt32 size = (UInt32)_entries[i]->size();
+				poco_assert_dbg(size != 0);
+				if (size > maxEntriesPerHash)
+					maxEntriesPerHash = size;
+				if (details)
+					detailedEntriesPerHash.push_back(size);
+	#ifdef _DEBUG
+				totalSize += size;
+	#endif
+			}
+			else
+			{
+				numZeroEntries++;
+				if (details)
+					detailedEntriesPerHash.push_back(0);
+			}
+		}
+	#ifdef _DEBUG
+		poco_assert_dbg(totalSize == numberOfEntries);
+	#endif
+		return HashStatistic(_maxCapacity, numberOfEntries, numZeroEntries, maxEntriesPerHash, detailedEntriesPerHash);
+	}
+
+private:
+	HashTableVector _entries;
+	std::size_t     _size;
+	UInt32          _maxCapacity;
+	KeyHashFunction _hash;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_HashTable_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/HexBinaryDecoder.h b/base/poco/Foundation/include/Poco/HexBinaryDecoder.h
new file mode 100644
index 00000000000..7aab0f6cd22
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/HexBinaryDecoder.h
@@ -0,0 +1,94 @@
+//
+// HexBinaryDecoder.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  HexBinary
+//
+// Definition of the HexBinaryDecoder class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_HexBinaryDecoder_INCLUDED
+#define Foundation_HexBinaryDecoder_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include <istream>
+
+
+namespace Poco {
+
+
+class Foundation_API HexBinaryDecoderBuf: public UnbufferedStreamBuf
+	/// This streambuf decodes all hexBinary-encoded data read
+	/// from the istream connected to it.
+	/// In hexBinary encoding, each binary octet is encoded as a character tuple,  
+	/// consisting of two hexadecimal digits ([0-9a-fA-F]) representing the octet code.
+	/// See also: XML Schema Part 2: Datatypes (http://www.w3.org/TR/xmlschema-2/),
+	/// section 3.2.15.
+	///
+	/// Note: For performance reasons, the characters 
+	/// are read directly from the given istream's 
+	/// underlying streambuf, so the state
+	/// of the istream will not reflect that of
+	/// its streambuf.
+{
+public:
+	HexBinaryDecoderBuf(std::istream& istr);
+	~HexBinaryDecoderBuf();
+	
+private:
+	int readFromDevice();
+	int readOne();
+
+	std::streambuf& _buf;
+};
+
+
+class Foundation_API HexBinaryDecoderIOS: public virtual std::ios
+	/// The base class for HexBinaryDecoder.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	HexBinaryDecoderIOS(std::istream& istr);
+	~HexBinaryDecoderIOS();
+	HexBinaryDecoderBuf* rdbuf();
+
+protected:
+	HexBinaryDecoderBuf _buf;
+};
+
+
+class Foundation_API HexBinaryDecoder: public HexBinaryDecoderIOS, public std::istream
+	/// This istream decodes all hexBinary-encoded data read
+	/// from the istream connected to it.
+	/// In hexBinary encoding, each binary octet is encoded as a character tuple,  
+	/// consisting of two hexadecimal digits ([0-9a-fA-F]) representing the octet code.
+	/// See also: XML Schema Part 2: Datatypes (http://www.w3.org/TR/xmlschema-2/),
+	/// section 3.2.15.
+	///
+	/// Note: For performance reasons, the characters 
+	/// are read directly from the given istream's 
+	/// underlying streambuf, so the state
+	/// of the istream will not reflect that of
+	/// its streambuf.
+{
+public:
+	HexBinaryDecoder(std::istream& istr);
+	~HexBinaryDecoder();
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_HexBinaryDecoder_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/HexBinaryEncoder.h b/base/poco/Foundation/include/Poco/HexBinaryEncoder.h
new file mode 100644
index 00000000000..453c3cd821c
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/HexBinaryEncoder.h
@@ -0,0 +1,117 @@
+//
+// HexBinaryEncoder.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  HexBinary
+//
+// Definition of the HexBinaryEncoder class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_HexBinaryEncoder_INCLUDED
+#define Foundation_HexBinaryEncoder_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include <ostream>
+
+
+namespace Poco {
+
+
+class Foundation_API HexBinaryEncoderBuf: public UnbufferedStreamBuf
+	/// This streambuf encodes all data written
+	/// to it in hexBinary encoding and forwards it to a connected
+	/// ostream. 
+	/// In hexBinary encoding, each binary octet is encoded as a character tuple,  
+	/// consisting of two hexadecimal digits ([0-9a-fA-F]) representing the octet code.
+	/// See also: XML Schema Part 2: Datatypes (http://www.w3.org/TR/xmlschema-2/),
+	/// section 3.2.15.
+	///
+	/// Note: The characters are directly written
+	/// to the ostream's streambuf, thus bypassing
+	/// the ostream. The ostream's state is therefore
+	/// not updated to match the buffer's state.
+{
+public:
+	HexBinaryEncoderBuf(std::ostream& ostr);
+	~HexBinaryEncoderBuf();
+	
+	int close();
+		/// Closes the stream buffer.
+	
+	void setLineLength(int lineLength);
+		/// Specify the line length.
+		///
+		/// After the given number of characters have been written, 
+		/// a newline character will be written.
+		///
+		/// Specify 0 for an unlimited line length.
+		
+	int getLineLength() const;
+		/// Returns the currently set line length.
+		
+	void setUppercase(bool flag = true);
+		/// Specify whether hex digits a-f are written in upper or lower case.
+	
+private:
+	int writeToDevice(char c);
+
+	int _pos;
+	int _lineLength;
+	int _uppercase;
+	std::streambuf& _buf;
+};
+
+
+class Foundation_API HexBinaryEncoderIOS: public virtual std::ios
+	/// The base class for HexBinaryEncoder.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	HexBinaryEncoderIOS(std::ostream& ostr);
+	~HexBinaryEncoderIOS();
+	int close();
+	HexBinaryEncoderBuf* rdbuf();
+
+protected:
+	HexBinaryEncoderBuf _buf;
+};
+
+
+class Foundation_API HexBinaryEncoder: public HexBinaryEncoderIOS, public std::ostream
+	/// This ostream encodes all data
+	/// written to it in BinHex encoding and forwards it to
+	/// a connected ostream.
+	/// Always call close() when done
+	/// writing data, to ensure proper
+	/// completion of the encoding operation.
+	/// In hexBinary encoding, each binary octet is encoded as a character tuple,  
+	/// consisting of two hexadecimal digits ([0-9a-fA-F]) representing the octet code.
+	/// See also: XML Schema Part 2: Datatypes (http://www.w3.org/TR/xmlschema-2/),
+	/// section 3.2.15.
+	///
+	/// Note: The characters are directly written
+	/// to the ostream's streambuf, thus bypassing
+	/// the ostream. The ostream's state is therefore
+	/// not updated to match the buffer's state.
+{
+public:
+	HexBinaryEncoder(std::ostream& ostr);
+	~HexBinaryEncoder();
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_HexBinaryEncoder_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/InflatingStream.h b/base/poco/Foundation/include/Poco/InflatingStream.h
new file mode 100644
index 00000000000..b8ea021e6c6
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/InflatingStream.h
@@ -0,0 +1,211 @@
+//
+// InflatingStream.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  ZLibStream
+//
+// Definition of the InflatingInputStream and InflatingOutputStream classes.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_InflatingStream_INCLUDED
+#define Foundation_InflatingStream_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/BufferedStreamBuf.h"
+#include <istream>
+#include <ostream>
+#if defined(POCO_UNBUNDLED_ZLIB)
+#include <zlib.h>
+#else
+#include "Poco/zlib.h"
+#endif
+
+
+namespace Poco {
+
+
+class Foundation_API InflatingStreamBuf: public BufferedStreamBuf
+	/// This is the streambuf class used by InflatingInputStream and InflatingOutputStream.
+	/// The actual work is delegated to zlib (see http://zlib.net).
+	/// Both zlib (deflate) streams and gzip streams are supported.
+	/// Output streams should always call close() to ensure
+	/// proper completion of decompression.
+{
+public:
+	enum StreamType
+	{
+		STREAM_ZLIB, /// Expect a zlib header, use Adler-32 checksum.
+		STREAM_GZIP, /// Expect a gzip header, use CRC-32 checksum.
+		STREAM_ZIP   /// STREAM_ZIP is handled as STREAM_ZLIB, except that we do not check the ADLER32 value (must be checked by caller)
+	};
+
+	InflatingStreamBuf(std::istream& istr, StreamType type);
+		/// Creates an InflatingStreamBuf for expanding the compressed data read from
+		/// the give input stream.
+
+	InflatingStreamBuf(std::istream& istr, int windowBits);
+		/// Creates an InflatingStreamBuf for expanding the compressed data read from
+		/// the given input stream.
+		///
+		/// Please refer to the zlib documentation of inflateInit2() for a description
+		/// of the windowBits parameter.
+
+	InflatingStreamBuf(std::ostream& ostr, StreamType type);
+		/// Creates an InflatingStreamBuf for expanding the compressed data passed through
+		/// and forwarding it to the given output stream.
+
+	InflatingStreamBuf(std::ostream& ostr, int windowBits);
+		/// Creates an InflatingStreamBuf for expanding the compressed data passed through
+		/// and forwarding it to the given output stream.
+		///
+		/// Please refer to the zlib documentation of inflateInit2() for a description
+		/// of the windowBits parameter.
+
+	~InflatingStreamBuf();
+		/// Destroys the InflatingStreamBuf.
+		
+	int close();
+		/// Finishes up the stream.
+		///
+		/// Must be called when inflating to an output stream.
+		
+	void reset();
+		/// Resets the stream buffer.
+		
+protected:
+	int readFromDevice(char* buffer, std::streamsize length);
+	int writeToDevice(const char* buffer, std::streamsize length);
+	int sync();
+
+private:
+	enum
+	{
+		STREAM_BUFFER_SIZE  = 1024,
+		INFLATE_BUFFER_SIZE = 32768
+	};
+	
+	std::istream*  _pIstr;
+	std::ostream*  _pOstr;
+	char*    _buffer;
+	z_stream _zstr;
+	bool     _eof;
+	bool     _check;
+};
+
+
+class Foundation_API InflatingIOS: public virtual std::ios
+	/// The base class for InflatingOutputStream and InflatingInputStream.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	InflatingIOS(std::ostream& ostr, InflatingStreamBuf::StreamType type = InflatingStreamBuf::STREAM_ZLIB);
+		/// Creates an InflatingIOS for expanding the compressed data passed through
+		/// and forwarding it to the given output stream.
+		
+	InflatingIOS(std::ostream& ostr, int windowBits);
+		/// Creates an InflatingIOS for expanding the compressed data passed through
+		/// and forwarding it to the given output stream.
+		///
+		/// Please refer to the zlib documentation of inflateInit2() for a description
+		/// of the windowBits parameter.
+
+	InflatingIOS(std::istream& istr, InflatingStreamBuf::StreamType type = InflatingStreamBuf::STREAM_ZLIB);
+		/// Creates an InflatingIOS for expanding the compressed data read from
+		/// the given input stream.
+
+	InflatingIOS(std::istream& istr, int windowBits);
+		/// Creates an InflatingIOS for expanding the compressed data read from
+		/// the given input stream.
+		///
+		/// Please refer to the zlib documentation of inflateInit2() for a description
+		/// of the windowBits parameter.
+
+	~InflatingIOS();
+		/// Destroys the InflatingIOS.
+		
+	InflatingStreamBuf* rdbuf();
+		/// Returns a pointer to the underlying stream buffer.
+		
+protected:
+	InflatingStreamBuf _buf;
+};
+
+
+class Foundation_API InflatingOutputStream: public std::ostream, public InflatingIOS
+	/// This stream decompresses all data passing through it
+	/// using zlib's inflate algorithm.
+	///
+	/// After all data has been written to the stream, close()
+	/// must be called to ensure completion of decompression.
+{
+public:
+	InflatingOutputStream(std::ostream& ostr, InflatingStreamBuf::StreamType type = InflatingStreamBuf::STREAM_ZLIB);
+		/// Creates an InflatingOutputStream for expanding the compressed data passed through
+		/// and forwarding it to the given output stream.
+		
+	InflatingOutputStream(std::ostream& ostr, int windowBits);
+		/// Creates an InflatingOutputStream for expanding the compressed data passed through
+		/// and forwarding it to the given output stream.
+		///
+		/// Please refer to the zlib documentation of inflateInit2() for a description
+		/// of the windowBits parameter.
+
+	~InflatingOutputStream();
+		/// Destroys the InflatingOutputStream.
+		
+	int close();
+		/// Finishes up the stream.
+		///
+		/// Must be called to ensure all data is properly written to
+		/// the target output stream.
+};
+
+
+class Foundation_API InflatingInputStream: public std::istream, public InflatingIOS
+	/// This stream decompresses all data passing through it
+	/// using zlib's inflate algorithm.
+	/// Example:
+	///     std::ifstream istr("data.gz", std::ios::binary);
+	///     InflatingInputStream inflater(istr, InflatingStreamBuf::STREAM_GZIP);
+	///     std::string data;
+	///     inflater >> data;
+	///
+	/// The underlying input stream can contain more than one gzip/deflate stream.
+	/// After a gzip/deflate stream has been processed, reset() can be called
+	/// to inflate the next stream.
+{
+public:
+	InflatingInputStream(std::istream& istr, InflatingStreamBuf::StreamType type = InflatingStreamBuf::STREAM_ZLIB);
+		/// Creates an InflatingInputStream for expanding the compressed data read from
+		/// the given input stream.
+
+	InflatingInputStream(std::istream& istr, int windowBits);
+		/// Creates an InflatingInputStream for expanding the compressed data read from
+		/// the given input stream.
+		///
+		/// Please refer to the zlib documentation of inflateInit2() for a description
+		/// of the windowBits parameter.
+
+	~InflatingInputStream();
+		/// Destroys the InflatingInputStream.
+		
+	void reset();
+		/// Resets the zlib machinery so that another zlib stream can be read from
+		/// the same underlying input stream.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_InflatingStream_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Instantiator.h b/base/poco/Foundation/include/Poco/Instantiator.h
new file mode 100644
index 00000000000..ce21ebc12ec
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Instantiator.h
@@ -0,0 +1,82 @@
+//
+// Instantiator.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Instantiator
+//
+// Definition of the Instantiator class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Instantiator_INCLUDED
+#define Foundation_Instantiator_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+template <class Base>
+class AbstractInstantiator
+	/// The common base class for all Instantiator instantiations.
+	/// Used by DynamicFactory.
+{
+public:
+	AbstractInstantiator()
+		/// Creates the AbstractInstantiator.
+	{
+	}
+	
+	virtual ~AbstractInstantiator()
+		/// Destroys the AbstractInstantiator.
+	{
+	}
+	
+	virtual Base* createInstance() const = 0;
+		/// Creates an instance of a concrete subclass of Base.	
+
+private:
+	AbstractInstantiator(const AbstractInstantiator&);
+	AbstractInstantiator& operator = (const AbstractInstantiator&);
+};
+
+
+template <class C, class Base>
+class Instantiator: public AbstractInstantiator<Base>
+	/// A template class for the easy instantiation of 
+	/// instantiators. 
+	///
+	/// For the Instantiator to work, the class of which
+	/// instances are to be instantiated must have a no-argument
+	/// constructor.
+{
+public:
+	Instantiator()
+		/// Creates the Instantiator.
+	{
+	}
+	
+	virtual ~Instantiator()
+		/// Destroys the Instantiator.
+	{
+	}
+
+	Base* createInstance() const
+	{
+		return new C;
+	}
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Instantiator_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/JSONString.h b/base/poco/Foundation/include/Poco/JSONString.h
new file mode 100644
index 00000000000..b4446efce7e
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/JSONString.h
@@ -0,0 +1,93 @@
+//
+// JSONString.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  String
+//
+// JSONString utility functions.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_JSONString_INCLUDED
+#define Foundation_JSONString_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+enum JSONOptions
+{
+	JSON_PRESERVE_KEY_ORDER = 1,
+		/// Applies to JSON::Object. If specified, the Object will
+		/// preserve the items insertion order. Otherwise, items
+		/// will be sorted by keys.
+		///
+		/// Has no effect on toJSON() function.
+
+	JSON_ESCAPE_UNICODE = 2,
+		/// If specified, when the object is stringified, all
+		/// unicode characters will be escaped in the resulting
+		/// string.
+
+	JSON_WRAP_STRINGS = 4
+		/// If specified, the object will preserve the items
+		/// insertion order. Otherwise, items will be sorted
+		/// by keys.
+	};
+
+
+//@ deprecated
+void Foundation_API toJSON(const std::string& value, std::ostream& out, bool wrap = true);
+	/// Formats string value into the supplied output stream by
+	/// escaping control and ALL Unicode characters.
+	/// If wrap is true, the resulting string is enclosed in double quotes.
+	///
+	/// This function is deprecated, please use
+	///
+	/// void Poco::toJSON(const std::string&, std::ostream&, int)
+
+
+//@ deprecated
+std::string Foundation_API toJSON(const std::string& value, bool wrap = true);
+	/// Formats string value by escaping control and ALL Unicode characters.
+	/// If wrap is true, the resulting string is enclosed in double quotes
+	///
+	/// Returns formatted string.
+	///
+	/// This function is deprecated, please use
+	///
+	/// std::string Poco::toJSON(const std::string&, int)
+
+
+void Foundation_API toJSON(const std::string& value, std::ostream& out, int options);
+	/// Formats string value into the supplied output stream by
+	/// escaping control characters.
+	/// If JSON_WRAP_STRINGS is in options, the resulting strings is enclosed in double quotes
+	/// If JSON_ESCAPE_UNICODE is in options, all unicode characters will be escaped, otherwise
+	/// only the compulsory ones.
+
+
+std::string Foundation_API toJSON(const std::string& value, int options);
+	/// Formats string value by escaping control characters.
+	/// If JSON_WRAP_STRINGS is in options, the resulting string is enclosed in double quotes
+	/// If JSON_ESCAPE_UNICODE is in options, all unicode characters will be escaped, otherwise
+	/// only the compulsory ones.
+	///
+	/// Returns formatted string.
+	/// If escapeAllUnicode is true, all unicode characters will be escaped, otherwise only the compulsory ones.
+
+
+
+} // namespace Poco
+
+
+#endif // Foundation_JSONString_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/KeyValueArgs.h b/base/poco/Foundation/include/Poco/KeyValueArgs.h
new file mode 100644
index 00000000000..cdcc4e1cecc
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/KeyValueArgs.h
@@ -0,0 +1,73 @@
+//
+// KeyValueArgs.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  KeyValueArgs
+//
+// Definition of the KeyValueArgs class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_KeyValueArgs_INCLUDED
+#define Foundation_KeyValueArgs_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+template <class TKey, class TValue> 
+class KeyValueArgs
+	/// Simply event arguments class to transfer a key and a value via an event call.
+	/// Note that key and value are *NOT* copied, only references to them are stored.
+{
+public:
+	KeyValueArgs(const TKey& aKey, const TValue& aVal): 
+		_key(aKey), 
+		_value(aVal)
+	{
+	}
+
+	KeyValueArgs(const KeyValueArgs& args):
+		_key(args._key), 
+		_value(args._value)
+	{
+	}
+
+	~KeyValueArgs()
+	{
+	}
+
+	const TKey& key() const
+		/// Returns a reference to the key,
+	{
+		return _key;
+	}
+
+	const TValue& value() const
+		/// Returns a Reference to the value.
+	{
+		return _value;
+	}
+
+protected:
+	const TKey&   _key;
+	const TValue& _value;
+
+private:
+	KeyValueArgs& operator = (const KeyValueArgs& args);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_KeyValueArgs_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/LRUCache.h b/base/poco/Foundation/include/Poco/LRUCache.h
new file mode 100644
index 00000000000..7f8f0debd9c
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/LRUCache.h
@@ -0,0 +1,56 @@
+//
+// LRUCache.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  LRUCache
+//
+// Definition of the LRUCache class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_LRUCache_INCLUDED
+#define Foundation_LRUCache_INCLUDED
+
+
+#include "Poco/AbstractCache.h"
+#include "Poco/LRUStrategy.h"
+
+
+namespace Poco {
+
+
+template <
+	class TKey, 
+	class TValue,
+	class TMutex = FastMutex, 
+	class TEventMutex = FastMutex
+> 
+class LRUCache: public AbstractCache<TKey, TValue, LRUStrategy<TKey, TValue>, TMutex, TEventMutex>
+	/// An LRUCache implements Least Recently Used caching. The default size for a cache is 1024 entries.
+{
+public:
+	LRUCache(long size = 1024):
+		AbstractCache<TKey, TValue, LRUStrategy<TKey, TValue>, TMutex, TEventMutex>(LRUStrategy<TKey, TValue>(size))
+	{
+	}
+
+	~LRUCache()
+	{
+	}
+
+private:
+	LRUCache(const LRUCache& aCache);
+	LRUCache& operator = (const LRUCache& aCache);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_LRUCache_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/LRUStrategy.h b/base/poco/Foundation/include/Poco/LRUStrategy.h
new file mode 100644
index 00000000000..c7180bd88ed
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/LRUStrategy.h
@@ -0,0 +1,140 @@
+//
+// LRUStrategy.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  LRUStrategy
+//
+// Definition of the LRUStrategy class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_LRUStrategy_INCLUDED
+#define Foundation_LRUStrategy_INCLUDED
+
+
+#include "Poco/KeyValueArgs.h"
+#include "Poco/ValidArgs.h"
+#include "Poco/AbstractStrategy.h"
+#include "Poco/EventArgs.h"
+#include "Poco/Exception.h"
+#include <list>
+#include <map>
+#include <cstddef>
+
+
+namespace Poco {
+
+
+template <class TKey, class TValue>
+class LRUStrategy: public AbstractStrategy<TKey, TValue>
+	/// An LRUStrategy implements least recently used cache replacement.
+{
+public:
+	typedef std::list<TKey>                   Keys;
+	typedef typename Keys::iterator           Iterator;
+	typedef typename Keys::const_iterator     ConstIterator;
+	typedef std::map<TKey, Iterator>          KeyIndex;
+	typedef typename KeyIndex::iterator       IndexIterator;
+	typedef typename KeyIndex::const_iterator ConstIndexIterator;
+
+public:
+	LRUStrategy(std::size_t size): 
+		_size(size)
+	{
+		if (_size < 1) throw InvalidArgumentException("size must be > 0");
+	}
+
+	~LRUStrategy()
+	{
+	}
+
+	void onAdd(const void*, const KeyValueArgs <TKey, TValue>& args)
+	{
+		_keys.push_front(args.key());
+		std::pair<IndexIterator, bool> stat = _keyIndex.insert(std::make_pair(args.key(), _keys.begin()));
+		if (!stat.second)
+		{
+			stat.first->second = _keys.begin();
+		}
+	}
+
+	void onRemove(const void*, const TKey& key)
+	{
+		IndexIterator it = _keyIndex.find(key);
+
+		if (it != _keyIndex.end())
+		{
+			_keys.erase(it->second);
+			_keyIndex.erase(it);
+		}
+	}
+
+	void onGet(const void*, const TKey& key)
+	{
+		// LRU: in case of an hit, move to begin
+		IndexIterator it = _keyIndex.find(key);
+
+		if (it != _keyIndex.end())
+		{
+			_keys.splice(_keys.begin(), _keys, it->second); //_keys.erase(it->second)+_keys.push_front(key);
+			it->second = _keys.begin();
+		}
+	}
+
+	void onClear(const void*, const EventArgs& args)
+	{
+		_keys.clear();
+		_keyIndex.clear();
+	}
+
+	void onIsValid(const void*, ValidArgs<TKey>& args)
+	{
+		if (_keyIndex.find(args.key()) == _keyIndex.end())
+		{
+			args.invalidate();
+		}
+	}
+
+	void onReplace(const void*, std::set<TKey>& elemsToRemove)
+	{
+		// Note: replace only informs the cache which elements
+		// it would like to remove!
+		// it does not remove them on its own!
+		std::size_t curSize = _keyIndex.size();
+
+		if (curSize < _size)
+		{
+			return;
+		}
+
+		std::size_t diff = curSize - _size;
+		Iterator it = --_keys.end(); //--keys can never be invoked on an empty list due to the minSize==1 requirement of LRU
+		std::size_t i = 0;
+
+		while (i++ < diff) 
+		{
+			elemsToRemove.insert(*it);
+			if (it != _keys.begin())
+			{
+				--it;
+			}
+		}
+	}
+
+protected:
+	std::size_t _size;     /// Number of keys the cache can store.
+	Keys        _keys;
+	KeyIndex    _keyIndex; /// For faster access to _keys
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_LRUStrategy_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Latin1Encoding.h b/base/poco/Foundation/include/Poco/Latin1Encoding.h
new file mode 100644
index 00000000000..b1b987e0a7a
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Latin1Encoding.h
@@ -0,0 +1,51 @@
+//
+// Latin1Encoding.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  Latin1Encoding
+//
+// Definition of the Latin1Encoding class.
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Latin1Encoding_INCLUDED
+#define Foundation_Latin1Encoding_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/TextEncoding.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Latin1Encoding: public TextEncoding
+	/// ISO Latin-1 (8859-1) text encoding.
+{
+public:
+	Latin1Encoding();
+	~Latin1Encoding();
+	const char* canonicalName() const;
+	bool isA(const std::string& encodingName) const;
+	const CharacterMap& characterMap() const;
+	int convert(const unsigned char* bytes) const;
+	int convert(int ch, unsigned char* bytes, int length) const;
+	int queryConvert(const unsigned char* bytes, int length) const;
+	int sequenceLength(const unsigned char* bytes, int length) const;
+	
+private:
+	static const char* _names[];
+	static const CharacterMap _charMap;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Latin1Encoding_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Latin2Encoding.h b/base/poco/Foundation/include/Poco/Latin2Encoding.h
new file mode 100644
index 00000000000..ac1cfecde33
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Latin2Encoding.h
@@ -0,0 +1,54 @@
+//
+// Latin2Encoding.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  Latin2Encoding
+//
+// Definition of the Latin2Encoding class.
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Latin2Encoding_INCLUDED
+#define Foundation_Latin2Encoding_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/TextEncoding.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Latin2Encoding: public TextEncoding
+	/// ISO Latin-2 (8859-2) text encoding.
+	///
+	/// Latin-2 is basically Latin-1 with the EURO sign plus
+	/// some other minor changes.
+{
+public:
+	Latin2Encoding();
+	virtual ~Latin2Encoding();
+	const char* canonicalName() const;
+	bool isA(const std::string& encodingName) const;
+	const CharacterMap& characterMap() const;
+	int convert(const unsigned char* bytes) const;
+	int convert(int ch, unsigned char* bytes, int length) const;
+	int queryConvert(const unsigned char* bytes, int length) const;
+	int sequenceLength(const unsigned char* bytes, int length) const;
+	
+private:
+	static const char* _names[];
+	static const CharacterMap _charMap;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Latin2Encoding_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Latin9Encoding.h b/base/poco/Foundation/include/Poco/Latin9Encoding.h
new file mode 100644
index 00000000000..d2b7a1ca79c
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Latin9Encoding.h
@@ -0,0 +1,54 @@
+//
+// Latin9Encoding.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  Latin9Encoding
+//
+// Definition of the Latin9Encoding class.
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Latin9Encoding_INCLUDED
+#define Foundation_Latin9Encoding_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/TextEncoding.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Latin9Encoding: public TextEncoding
+	/// ISO Latin-9 (8859-15) text encoding.
+	///
+	/// Latin-9 is basically Latin-1 with the EURO sign plus
+	/// some other minor changes.
+{
+public:
+	Latin9Encoding();
+	~Latin9Encoding();
+	const char* canonicalName() const;
+	bool isA(const std::string& encodingName) const;
+	const CharacterMap& characterMap() const;
+	int convert(const unsigned char* bytes) const;
+	int convert(int ch, unsigned char* bytes, int length) const;
+	int queryConvert(const unsigned char* bytes, int length) const;
+	int sequenceLength(const unsigned char* bytes, int length) const;
+	
+private:
+	static const char* _names[];
+	static const CharacterMap _charMap;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Latin9Encoding_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/LineEndingConverter.h b/base/poco/Foundation/include/Poco/LineEndingConverter.h
new file mode 100644
index 00000000000..d23414c3570
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/LineEndingConverter.h
@@ -0,0 +1,181 @@
+//
+// LineEndingConverter.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  LineEndingConverter
+//
+// Definition of the LineEndingConverter class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_LineEndingConverter_INCLUDED
+#define Foundation_LineEndingConverter_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+
+
+class Foundation_API LineEnding
+	/// This class defines valid line ending sequences
+	/// for InputLineEndingConverter and OutputLineEndingConverter.
+{
+public:
+	static const std::string NEWLINE_DEFAULT;
+	static const std::string NEWLINE_CR;
+	static const std::string NEWLINE_CRLF;
+	static const std::string NEWLINE_LF;
+};
+
+
+class Foundation_API LineEndingConverterStreamBuf: public UnbufferedStreamBuf
+	/// This stream buffer performs line ending conversion
+	/// on text streams. The converter can convert from and to 
+	/// the Unix (LF), Mac (CR) and DOS/Windows/Network (CF-LF) endings.
+	///
+	/// Any newline sequence in the source will be replaced by the
+	/// target newline sequence.
+{
+public:
+	LineEndingConverterStreamBuf(std::istream& istr);
+		/// Creates the LineEndingConverterStreamBuf and connects it
+		/// to the given input stream.
+
+	LineEndingConverterStreamBuf(std::ostream& ostr);
+		/// Creates the LineEndingConverterStreamBuf and connects it
+		/// to the given output stream.
+
+	~LineEndingConverterStreamBuf();
+		/// Destroys the LineEndingConverterStream.
+		
+	void setNewLine(const std::string& newLineCharacters);
+		/// Sets the target line ending for the converter.
+		///
+		/// Possible values are:
+		///   * NEWLINE_DEFAULT (whatever is appropriate for the current platform)
+		///   * NEWLINE_CRLF    (Windows),
+		///   * NEWLINE_LF      (Unix),
+		///   * NEWLINE_CR      (Macintosh)
+		///
+		/// In theory, any character sequence can be used as newline sequence.
+		/// In practice, however, only the above three make sense.
+
+	const std::string& getNewLine() const;
+		/// Returns the line ending currently in use.
+
+protected:
+	int readFromDevice();
+	int writeToDevice(char c);
+
+private:
+	std::istream*               _pIstr;
+	std::ostream*               _pOstr;
+	std::string                 _newLine;
+	std::string::const_iterator _it;
+	char                        _lastChar;
+};
+
+
+class Foundation_API LineEndingConverterIOS: public virtual std::ios
+	/// The base class for InputLineEndingConverter and OutputLineEndingConverter.
+	///
+	/// This class provides common methods and is also needed to ensure 
+	/// the correct initialization order of the stream buffer and base classes.
+{
+public:
+	LineEndingConverterIOS(std::istream& istr);
+		/// Creates the LineEndingConverterIOS and connects it
+		/// to the given input stream.
+
+	LineEndingConverterIOS(std::ostream& ostr);
+		/// Creates the LineEndingConverterIOS and connects it
+		/// to the given output stream.
+
+	~LineEndingConverterIOS();
+		/// Destroys the stream.
+
+	void setNewLine(const std::string& newLineCharacters);
+		/// Sets the target line ending for the converter.
+		///
+		/// Possible values are:
+		///   * NEWLINE_DEFAULT (whatever is appropriate for the current platform)
+		///   * NEWLINE_CRLF    (Windows),
+		///   * NEWLINE_LF      (Unix),
+		///   * NEWLINE_CR      (Macintosh)
+		///
+		/// In theory, any character sequence can be used as newline sequence.
+		/// In practice, however, only the above three make sense.
+		///
+		/// If an empty string is given, all newline characters are removed from
+		/// the stream.
+
+	const std::string& getNewLine() const;
+		/// Returns the line ending currently in use.
+
+	LineEndingConverterStreamBuf* rdbuf();
+		/// Returns a pointer to the underlying streambuf.
+
+protected:
+	LineEndingConverterStreamBuf _buf;
+};
+
+
+class Foundation_API InputLineEndingConverter: public LineEndingConverterIOS, public std::istream
+	/// InputLineEndingConverter performs line ending conversion
+	/// on text input streams. The converter can convert from and to 
+	/// the Unix (LF), Mac (CR) and DOS/Windows/Network (CF-LF) endings.
+	///
+	/// Any newline sequence in the source will be replaced by the
+	/// target newline sequence.
+{
+public:
+	InputLineEndingConverter(std::istream& istr);
+		/// Creates the LineEndingConverterInputStream and connects it
+		/// to the given input stream.
+
+	InputLineEndingConverter(std::istream& istr, const std::string& newLineCharacters);
+		/// Creates the LineEndingConverterInputStream and connects it
+		/// to the given input stream.
+
+	~InputLineEndingConverter();
+		/// Destroys the stream.
+};
+
+
+class Foundation_API OutputLineEndingConverter: public LineEndingConverterIOS, public std::ostream
+	/// OutputLineEndingConverter performs line ending conversion
+	/// on text output streams. The converter can convert from and to 
+	/// the Unix (LF), Mac (CR) and DOS/Windows/Network (CF-LF) endings.
+	///
+	/// Any newline sequence in the source will be replaced by the
+	/// target newline sequence.
+{
+public:
+	OutputLineEndingConverter(std::ostream& ostr);
+		/// Creates the LineEndingConverterOutputStream and connects it
+		/// to the given input stream.
+
+	OutputLineEndingConverter(std::ostream& ostr, const std::string& newLineCharacters);
+		/// Creates the LineEndingConverterOutputStream and connects it
+		/// to the given input stream.
+
+	~OutputLineEndingConverter();
+		/// Destroys the LineEndingConverterOutputStream.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_LineEndingConverter_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/LinearHashTable.h b/base/poco/Foundation/include/Poco/LinearHashTable.h
new file mode 100644
index 00000000000..ac18b4b95aa
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/LinearHashTable.h
@@ -0,0 +1,503 @@
+//
+// LinearHashTable.h
+//
+// Library: Foundation
+// Package: Hashing
+// Module:  LinearHashTable
+//
+// Definition of the LinearHashTable class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_LinearHashTable_INCLUDED
+#define Foundation_LinearHashTable_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Hash.h"
+#include <functional>
+#include <algorithm>
+#include <vector>
+#include <utility>
+#include <cstddef>
+
+
+namespace Poco {
+
+
+template <class Value, class HashFunc = Hash<Value> >
+class LinearHashTable
+	/// This class implements a linear hash table.
+	///
+	/// In a linear hash table, the available address space
+	/// grows or shrinks dynamically. A linar hash table thus
+	/// supports any number of insertions or deletions without
+	/// lookup or insertion performance deterioration.
+	///
+	/// Linear hashing was discovered by Witold Litwin in 1980
+	/// and described in the paper LINEAR HASHING: A NEW TOOL FOR FILE AND TABLE ADDRESSING.
+	///
+	/// For more information on linear hashing, see <http://en.wikipedia.org/wiki/Linear_hash>.
+	///
+	/// The LinearHashTable is not thread safe.
+	///
+	/// Value must support comparison for equality.
+	///
+	/// Find, insert and delete operations are basically O(1) with regard
+	/// to the total number of elements in the table, and O(N) with regard
+	/// to the number of elements in the bucket where the element is stored.
+	/// On average, every bucket stores one element; the exact number depends
+	/// on the quality of the hash function. In most cases, the maximum number of
+	/// elements in a bucket should not exceed 3.
+{
+public:
+	typedef Value               ValueType;
+	typedef Value&              Reference;
+	typedef const Value&        ConstReference;
+	typedef Value*              Pointer;
+	typedef const Value*        ConstPointer;
+	typedef HashFunc            Hash;
+	typedef std::vector<Value>  Bucket;
+	typedef std::vector<Bucket> BucketVec;
+	typedef typename Bucket::iterator    BucketIterator;
+	typedef typename BucketVec::iterator BucketVecIterator;
+
+	class ConstIterator: public std::iterator<std::forward_iterator_tag, Value>
+	{
+	public:
+		ConstIterator(): _initialized(false)
+		{
+		}
+		
+		ConstIterator(const BucketVecIterator& vecIt, const BucketVecIterator& endIt, const BucketIterator& buckIt):
+			_vecIt(vecIt),
+			_endIt(endIt),
+			_buckIt(buckIt),
+			_initialized(true)
+		{
+		}
+
+		ConstIterator(const ConstIterator& it):
+			_vecIt(it._vecIt),
+			_endIt(it._endIt),
+			_buckIt(it._buckIt),
+			_initialized(it._initialized)
+
+		{
+		}
+		
+		ConstIterator& operator = (const ConstIterator& it)
+		{
+			ConstIterator tmp(it);
+			swap(tmp);
+			return *this;
+		}
+		
+		void swap(ConstIterator& it)
+		{
+			using std::swap;
+			// uninitialized iterators crash when swapped
+			if (_initialized)
+			{
+				swap(_vecIt, it._vecIt);
+				swap(_endIt, it._endIt);
+				swap(_buckIt, it._buckIt);
+				swap(_initialized, it._initialized);
+			}
+			else 
+			{
+				_vecIt = it._vecIt;
+				_endIt = it._endIt;
+				_buckIt = it._buckIt;
+				_initialized = it._initialized;
+			}
+		}
+		
+		bool operator == (const ConstIterator& it) const
+		{
+			return _vecIt == it._vecIt && (_vecIt == _endIt || _buckIt == it._buckIt);
+		}
+
+		bool operator != (const ConstIterator& it) const
+		{
+			return _vecIt != it._vecIt || (_vecIt != _endIt && _buckIt != it._buckIt);
+		}
+		
+		const typename Bucket::value_type& operator * () const
+		{
+			return *_buckIt;
+		}
+
+		const typename Bucket::value_type* operator -> () const
+		{
+			return &*_buckIt;
+		}
+		
+		ConstIterator& operator ++ () // prefix
+		{
+			if (_vecIt != _endIt)
+			{
+				++_buckIt;
+				while (_vecIt != _endIt && _buckIt == _vecIt->end())
+				{
+					++_vecIt;
+					if (_vecIt != _endIt) _buckIt = _vecIt->begin();
+				}
+			}
+			return *this;
+		}
+		
+		ConstIterator operator ++ (int) // postfix
+		{
+			ConstIterator tmp(*this);
+			++*this;
+			return tmp;
+		}
+		
+	protected:
+		BucketVecIterator _vecIt;
+		BucketVecIterator _endIt;
+		BucketIterator    _buckIt;
+		bool              _initialized;
+		
+		friend class LinearHashTable;
+	};
+	
+	class Iterator: public ConstIterator
+	{
+	public:
+		Iterator()
+		{
+		}
+		
+		Iterator(const BucketVecIterator& vecIt, const BucketVecIterator& endIt, const BucketIterator& buckIt):
+			ConstIterator(vecIt, endIt, buckIt)
+		{
+		}
+
+		Iterator(const Iterator& it):
+			ConstIterator(it)
+		{
+		}
+		
+		Iterator& operator = (const Iterator& it)
+		{
+			Iterator tmp(it);
+			ConstIterator::swap(tmp);
+			return *this;
+		}
+		
+		void swap(Iterator& it)
+		{
+			ConstIterator::swap(it);
+		}
+				
+		typename Bucket::value_type& operator * ()
+		{
+			return *this->_buckIt;
+		}
+
+		const typename Bucket::value_type& operator * () const
+		{
+			return *this->_buckIt;
+		}
+
+		typename Bucket::value_type* operator -> ()
+		{
+			return &*this->_buckIt;
+		}
+
+		const typename Bucket::value_type* operator -> () const
+		{
+			return &*this->_buckIt;
+		}
+		
+		Iterator& operator ++ () // prefix
+		{
+			ConstIterator::operator ++ ();
+			return *this;
+		}
+		
+		Iterator operator ++ (int) // postfix
+		{
+			Iterator tmp(*this);
+			++*this;
+			return tmp;
+		}
+
+		friend class LinearHashTable;
+	};
+	
+	LinearHashTable(std::size_t initialReserve = 64): 
+		_split(0),
+		_front(1),
+		_size(0)
+		/// Creates the LinearHashTable, using the given initialReserve.
+	{
+		_buckets.reserve(calcSize(initialReserve));
+		_buckets.push_back(Bucket());
+	}
+	
+	LinearHashTable(const LinearHashTable& table):
+		_buckets(table._buckets),
+		_split(table._split),
+		_front(table._front),
+		_size(table._size)
+		/// Creates the LinearHashTable by copying another one.
+	{
+	}
+	
+	~LinearHashTable()
+		/// Destroys the LinearHashTable.
+	{
+	}
+	
+	LinearHashTable& operator = (const LinearHashTable& table)
+		/// Assigns another LinearHashTable.
+	{
+		LinearHashTable tmp(table);
+		swap(tmp);
+		return *this;
+	}
+	
+	void swap(LinearHashTable& table)
+		/// Swaps the LinearHashTable with another one.
+	{
+		using std::swap;
+		swap(_buckets, table._buckets);
+		swap(_split, table._split);
+		swap(_front, table._front);
+		swap(_size, table._size);
+	}
+	
+	ConstIterator begin() const
+		/// Returns an iterator pointing to the first entry, if one exists.
+	{
+		BucketVecIterator it(_buckets.begin());
+		BucketVecIterator end(_buckets.end());
+		while (it != end && it->empty())
+		{
+			++it;
+		}
+		if (it == end)
+			return this->end();
+		else
+			return ConstIterator(it, end, it->begin());
+	}
+	
+	ConstIterator end() const
+		/// Returns an iterator pointing to the end of the table.
+	{
+		return ConstIterator(_buckets.end(), _buckets.end(), _buckets.front().end());
+	}
+	
+	Iterator begin()
+		/// Returns an iterator pointing to the first entry, if one exists.
+	{
+		BucketVecIterator it(_buckets.begin());
+		BucketVecIterator end(_buckets.end());
+		while (it != end && it->empty())
+		{
+			++it;
+		}
+		if (it == end)
+			return this->end();
+		else
+			return Iterator(it, end, it->begin());
+	}
+	
+	Iterator end()
+		/// Returns an iterator pointing to the end of the table.
+	{
+		return Iterator(_buckets.end(), _buckets.end(), _buckets.front().end());
+	}
+		
+	ConstIterator find(const Value& value) const
+		/// Finds an entry in the table.
+	{
+		std::size_t addr = bucketAddress(value);
+		BucketVecIterator it(_buckets.begin() + addr);
+		BucketIterator buckIt(std::find(it->begin(), it->end(), value));
+		if (buckIt != it->end())
+			return ConstIterator(it, _buckets.end(), buckIt);
+		else
+			return end();
+	}
+
+	Iterator find(const Value& value)
+		/// Finds an entry in the table.
+	{
+		std::size_t addr = bucketAddress(value);
+		BucketVecIterator it(_buckets.begin() + addr);
+		BucketIterator buckIt(std::find(it->begin(), it->end(), value));
+		if (buckIt != it->end())
+			return Iterator(it, _buckets.end(), buckIt);
+		else
+			return end();
+	}
+	
+	std::size_t count(const Value& value) const
+		/// Returns the number of elements with the given
+		/// value, with is either 1 or 0.
+	{
+		return find(value) != end() ? 1 : 0;
+	}
+	
+	std::pair<Iterator, bool> insert(const Value& value)
+		/// Inserts an element into the table.
+		///
+		/// If the element already exists in the table,
+		/// a pair(iterator, false) with iterator pointing to the 
+		/// existing element is returned.
+		/// Otherwise, the element is inserted an a 
+		/// pair(iterator, true) with iterator
+		/// pointing to the new element is returned.
+	{
+		std::size_t hash = _hash(value);
+		std::size_t addr = bucketAddressForHash(hash);
+		BucketVecIterator it(_buckets.begin() + addr);
+		BucketIterator buckIt(std::find(it->begin(), it->end(), value));
+		if (buckIt == it->end())
+		{
+			split();
+			addr = bucketAddressForHash(hash);
+			it = _buckets.begin() + addr;
+			buckIt = it->insert(it->end(), value);
+			++_size;
+			return std::make_pair(Iterator(it, _buckets.end(), buckIt), true);
+		}
+		else
+		{
+			return std::make_pair(Iterator(it, _buckets.end(), buckIt), false);
+		}
+	}
+	
+	void erase(Iterator it)
+		/// Erases the element pointed to by it.
+	{
+		if (it != end())
+		{
+			it._vecIt->erase(it._buckIt);
+			--_size;
+			merge();
+		}
+	}
+	
+	void erase(const Value& value)
+		/// Erases the element with the given value, if it exists.
+	{
+		Iterator it = find(value);
+		erase(it);
+	}
+	
+	void clear()
+		/// Erases all elements.
+	{
+		LinearHashTable empty;
+		swap(empty);
+	}
+	
+	std::size_t size() const
+		/// Returns the number of elements in the table.
+	{
+		return _size;
+	}
+	
+	bool empty() const
+		/// Returns true iff the table is empty.
+	{
+		return _size == 0;
+	}
+	
+	std::size_t buckets() const
+		/// Returns the number of allocated buckets.
+	{
+		return _buckets.size();
+	}
+	
+protected:
+	std::size_t bucketAddress(const Value& value) const
+	{
+		std::size_t n = _hash(value);
+		if (n % _front >= _split)
+			return n % _front;
+		else
+			return n % (2*_front);
+	}
+	
+	std::size_t bucketAddressForHash(std::size_t hash)
+	{
+		if (hash % _front >= _split)
+			return hash % _front;
+		else
+			return hash % (2*_front);
+	}
+	
+	void split()
+	{
+		if (_split == _front)
+		{
+			_split = 0;
+			_front *= 2;
+			_buckets.reserve(_front*2);
+		}
+		Bucket tmp;
+		_buckets.push_back(tmp);
+		_buckets[_split].swap(tmp);
+		++_split;
+		for (BucketIterator it = tmp.begin(); it != tmp.end(); ++it)
+		{
+			using std::swap;
+			std::size_t addr = bucketAddress(*it);
+			_buckets[addr].push_back(Value());
+			swap(*it, _buckets[addr].back());
+		}
+	}
+	
+	void merge()
+	{
+		if (_split == 0)
+		{
+			_front /= 2;
+			_split = _front;
+		}
+		--_split;
+		Bucket tmp;
+		tmp.swap(_buckets.back());
+		_buckets.pop_back();
+		for (BucketIterator it = tmp.begin(); it != tmp.end(); ++it)
+		{
+			using std::swap;
+			std::size_t addr = bucketAddress(*it);
+			_buckets[addr].push_back(Value());
+			swap(*it, _buckets[addr].back());
+		}
+	}
+	
+	static std::size_t calcSize(std::size_t initialSize)
+	{
+		std::size_t size = 32;
+		while (size < initialSize) size *= 2;
+		return size;
+	}
+	
+private:
+	// Evil hack: _buckets must be mutable because both ConstIterator and Iterator hold 
+	// ordinary iterator's (not const_iterator's).
+	mutable BucketVec _buckets;
+	std::size_t _split;
+	std::size_t _front;
+	std::size_t _size;
+	HashFunc    _hash;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_LinearHashTable_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ListMap.h b/base/poco/Foundation/include/Poco/ListMap.h
new file mode 100644
index 00000000000..03c056d810f
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ListMap.h
@@ -0,0 +1,246 @@
+//
+// ListMap.h
+//
+// Library: Foundation
+// Package: Hashing
+// Module:  ListMap
+//
+// Definition of the ListMap class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ListMap_INCLUDED
+#define Foundation_ListMap_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/String.h"
+#include "Poco/Exception.h"
+#include <list>
+#include <utility>
+
+
+namespace Poco {
+
+
+template <class Key, class Mapped, class Container = std::list<std::pair<Key, Mapped> >, bool CaseSensitive = false >
+class ListMap
+	/// This class implements a multimap in terms of a sequential container.
+	/// The use for this type of associative container is wherever automatic
+	/// ordering of elements is not desirable. Naturally, this container will
+	/// have inferior data retrieval performance and it is not recommended for
+	/// use with large datasets. The main purpose within POCO is for Internet
+	/// messages (email message, http headers etc), to prevent automatic 
+	/// header entry reordering.
+{
+public:
+	typedef Key                 KeyType;
+	typedef Mapped              MappedType;
+	typedef Mapped&             Reference;
+	typedef const Mapped&       ConstReference;
+	typedef Mapped*             Pointer;
+	typedef const Mapped*       ConstPointer;
+	
+	typedef typename Container::value_type     ValueType;
+	typedef typename Container::size_type      SizeType;
+	typedef typename Container::iterator       Iterator;
+	typedef typename Container::const_iterator ConstIterator;
+	
+	ListMap()
+		/// Creates an empty ListMap.
+	{
+	}
+	
+	ListMap(std::size_t initialReserve):
+		_list(initialReserve)
+		/// Creates the ListMap with room for initialReserve entries.
+	{
+	}
+	
+	ListMap& operator = (const ListMap& map)
+		/// Assigns another ListMap.
+	{
+		ListMap tmp(map);
+		swap(tmp);
+		return *this;
+	}
+	
+	void swap(ListMap& map)
+		/// Swaps the ListMap with another one.
+	{
+		_list.swap(map._list);
+	}
+	
+	ConstIterator begin() const
+		/// Returns the beginning of the map.
+	{
+		return _list.begin();
+	}
+	
+	ConstIterator end() const
+		/// Returns the end of the map.
+	{
+		return _list.end();
+	}
+	
+	Iterator begin()
+		/// Returns the beginning of the map.
+	{
+		return _list.begin();
+	}
+	
+	Iterator end()
+		/// Returns the end of the map.
+	{
+		return _list.end();
+	}
+	
+	ConstIterator find(const KeyType& key) const
+		/// Finds the first occurrence of the key and
+		/// returns iterator pointing to the found entry
+		/// or iterator pointing to the end if entry is
+		/// not found.
+	{
+		typename Container::const_iterator it = _list.begin();
+		typename Container::const_iterator itEnd = _list.end();
+		for(; it != itEnd; ++it)
+		{
+			if (isEqual(it->first, key)) return it;
+		}
+		return itEnd;
+	}
+
+	Iterator find(const KeyType& key)
+		/// Finds the first occurrence of the key and
+		/// returns iterator pointing to the found entry
+		/// or iterator pointing to the end if entry is
+		/// not found.
+	{
+		typename Container::iterator it = _list.begin();
+		typename Container::iterator itEnd = _list.end();
+		for(; it != itEnd; ++it)
+		{
+			if (isEqual(it->first, key)) return it;
+		}
+		return itEnd;
+	}
+
+	Iterator insert(const ValueType& val)
+		/// Inserts the value into the map. If one or more values 
+		/// already exist, new value is inserted at the end of the 
+		/// block. Thus, all the equal value entries are located
+		/// sequentially at all times.
+		/// Returns iterator pointing to the newly inserted value 
+	{
+		Iterator it = find(val.first);
+		while (it != _list.end() && isEqual(it->first, val.first)) ++it;
+		return _list.insert(it, val);
+	}
+	
+	void erase(Iterator it)
+	{
+		_list.erase(it);
+	}
+	
+	SizeType erase(const KeyType& key)
+	{
+		SizeType count = 0;
+		Iterator it = find(key);
+		bool removed = false;
+		while (it != _list.end())
+		{
+			if (isEqual(it->first, key))
+			{
+				++count;
+				it = _list.erase(it);
+				removed = true;
+			}
+			else
+			{
+				if (removed) return count;
+				++it;
+			}
+		}
+		return count;
+	}
+	
+	void clear()
+	{
+		_list.clear();
+	}
+
+	std::size_t size() const
+	{
+		return _list.size();
+	}
+
+	bool empty() const
+	{
+		return _list.empty();
+	}
+
+	ConstReference operator [] (const KeyType& key) const
+	{
+		ConstIterator it = find(key);
+		if (it != _list.end())
+			return it->second;
+		else
+			throw NotFoundException();
+	}
+
+	Reference operator [] (const KeyType& key)
+	{
+		Iterator it = find(key);
+		if (it != _list.end())
+			return it->second;
+		else
+		{
+			ValueType value(key, Mapped());
+			Iterator itInsert = insert(value);
+			return itInsert->second;
+		}
+	}
+
+private:
+	template <typename T1, typename T2>
+	bool isEqual(T1 val1, T2 val2) const
+	{
+		return val1 == val2;
+	}
+
+	bool isEqual(const std::string& s1, const std::string& s2) const
+	{
+		if (!CaseSensitive)
+			return Poco::icompare(s1, s2) == 0;
+		else
+			return s1 == s2;
+	}
+
+	bool isEqual(const std::string& s1, const char* s2) const
+	{
+		return isEqual(s1, std::string(s2));
+	}
+
+	bool isEqual(const char* s1, const std::string& s2) const
+	{
+		return isEqual(std::string(s1), s2);
+	}
+
+	bool isEqual(const char* s1, const char* s2) const
+	{
+		return isEqual(std::string(s1), std::string(s2));
+	}
+
+	Container _list;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ListMap_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/LocalDateTime.h b/base/poco/Foundation/include/Poco/LocalDateTime.h
new file mode 100644
index 00000000000..08c90b6582b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/LocalDateTime.h
@@ -0,0 +1,388 @@
+//
+// LocalDateTime.h
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  LocalDateTime
+//
+// Definition of the LocalDateTime class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_LocalDateTime_INCLUDED
+#define Foundation_LocalDateTime_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/DateTime.h"
+
+
+namespace Poco {
+
+
+class Foundation_API LocalDateTime
+	/// This class represents an instant in local time
+	/// (as opposed to UTC), expressed in years, months, days, 
+	/// hours, minutes, seconds and milliseconds based on the 
+	/// Gregorian calendar.
+	///
+	/// In addition to the date and time, the class also 
+	/// maintains a time zone differential, which denotes
+	/// the difference in seconds from UTC to local time,
+	/// i.e. UTC = local time - time zone differential.
+	///
+	/// Although LocalDateTime supports relational and arithmetic
+	/// operators, all date/time comparisons and date/time arithmetics
+	/// should be done in UTC, using the DateTime or Timestamp
+	/// class for better performance. The relational operators
+	/// normalize the dates/times involved to UTC before carrying out
+	/// the comparison.
+	///
+	/// The time zone differential is based on the input date and
+	/// time and current time zone. A number of constructors accept
+	/// an explicit time zone differential parameter. These should
+	/// not be used since daylight savings time processing is impossible
+	/// since the time zone is unknown. Each of the constructors
+	/// accepting a tzd parameter have been marked as deprecated and
+	/// may be removed in a future revision.
+{
+public:
+	LocalDateTime();
+		/// Creates a LocalDateTime with the current date/time 
+		/// for the current time zone.
+
+	LocalDateTime(int year, int month, int day, int hour = 0, int minute = 0, int second = 0, int millisecond = 0, int microsecond = 0);
+		/// Creates a LocalDateTime for the given Gregorian local date and time.
+		///   * year is from 0 to 9999.
+		///   * month is from 1 to 12.
+		///   * day is from 1 to 31.
+		///   * hour is from 0 to 23.
+		///   * minute is from 0 to 59.
+		///   * second is from 0 to 60 (allowing leap seconds).
+		///   * millisecond is from 0 to 999.
+		///   * microsecond is from 0 to 999.
+
+	//@ deprecated
+	LocalDateTime(int tzd, int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond);
+		/// Creates a LocalDateTime for the given Gregorian date and time in the
+		/// time zone denoted by the time zone differential in tzd.
+		///   * tzd is in seconds.
+		///   * year is from 0 to 9999.
+		///   * month is from 1 to 12.
+		///   * day is from 1 to 31.
+		///   * hour is from 0 to 23.
+		///   * minute is from 0 to 59.
+		///   * second is from 0 to 60 (allowing leap seconds).
+		///   * millisecond is from 0 to 999.
+		///   * microsecond is from 0 to 999.
+
+	LocalDateTime(const DateTime& dateTime);
+		/// Creates a LocalDateTime from the UTC time given in dateTime,
+		/// using the time zone differential of the current time zone.
+
+	//@ deprecated
+	LocalDateTime(int tzd, const DateTime& dateTime);
+		/// Creates a LocalDateTime from the UTC time given in dateTime,
+		/// using the given time zone differential. Adjusts dateTime
+		/// for the given time zone differential.
+
+	//@ deprecated
+	LocalDateTime(int tzd, const DateTime& dateTime, bool adjust);
+		/// Creates a LocalDateTime from the UTC time given in dateTime,
+		/// using the given time zone differential. If adjust is true, 
+		/// adjusts dateTime for the given time zone differential.
+
+	LocalDateTime(double julianDay);
+		/// Creates a LocalDateTime for the given Julian day in the local time zone.
+
+	//@ deprecated
+	LocalDateTime(int tzd, double julianDay);
+		/// Creates a LocalDateTime for the given Julian day in the time zone
+		/// denoted by the time zone differential in tzd.
+
+	LocalDateTime(const LocalDateTime& dateTime);
+		/// Copy constructor. Creates the LocalDateTime from another one.
+		
+	~LocalDateTime();
+		/// Destroys the LocalDateTime.
+		
+	LocalDateTime& operator = (const LocalDateTime& dateTime);
+		/// Assigns another LocalDateTime.
+	
+	LocalDateTime& operator = (const Timestamp& timestamp);
+		/// Assigns a timestamp
+
+	LocalDateTime& operator = (double julianDay);
+		/// Assigns a Julian day in the local time zone.
+	
+	LocalDateTime& assign(int year, int month, int day, int hour = 0, int minute = 0, int second = 0, int millisecond = 0, int microseconds = 0);
+		/// Assigns a Gregorian local date and time.
+		///   * year is from 0 to 9999.
+		///   * month is from 1 to 12.
+		///   * day is from 1 to 31.
+		///   * hour is from 0 to 23.
+		///   * minute is from 0 to 59.
+		///   * second is from 0 to 60 (allowing leap seconds).
+		///   * millisecond is from 0 to 999.
+		///   * microsecond is from 0 to 999.
+
+	//@ deprecated
+	LocalDateTime& assign(int tzd, int year, int month, int day, int hour, int minute, int second, int millisecond, int microseconds);
+		/// Assigns a Gregorian local date and time in the time zone denoted by
+		/// the time zone differential in tzd.
+		///   * tzd is in seconds.
+		///   * year is from 0 to 9999.
+		///   * month is from 1 to 12.
+		///   * day is from 1 to 31.
+		///   * hour is from 0 to 23.
+		///   * minute is from 0 to 59.
+		///   * second is from 0 to 60 (allowing leap seconds).
+		///   * millisecond is from 0 to 999.
+		///   * microsecond is from 0 to 999.
+
+	//@ deprecated
+	LocalDateTime& assign(int tzd, double julianDay);
+		/// Assigns a Julian day in the time zone denoted by the
+		/// time zone differential in tzd.
+
+	void swap(LocalDateTime& dateTime);
+		/// Swaps the LocalDateTime with another one.
+
+	int year() const;
+		/// Returns the year.
+		
+	int month() const;
+		/// Returns the month (1 to 12).
+	
+	int week(int firstDayOfWeek = DateTime::MONDAY) const;
+		/// Returns the week number within the year.
+		/// FirstDayOfWeek should be either SUNDAY (0) or MONDAY (1).
+		/// The returned week number will be from 0 to 53. Week number 1 is the week 
+		/// containing January 4. This is in accordance to ISO 8601.
+		/// 
+		/// The following example assumes that firstDayOfWeek is MONDAY. For 2005, which started
+		/// on a Saturday, week 1 will be the week starting on Monday, January 3.
+		/// January 1 and 2 will fall within week 0 (or the last week of the previous year).
+		///
+		/// For 2007, which starts on a Monday, week 1 will be the week startung on Monday, January 1.
+		/// There will be no week 0 in 2007.
+	
+	int day() const;
+		/// Returns the day witin the month (1 to 31).
+		
+	int dayOfWeek() const;
+		/// Returns the weekday (0 to 6, where
+		/// 0 = Sunday, 1 = Monday, ..., 6 = Saturday).
+	
+	int dayOfYear() const;
+		/// Returns the number of the day in the year.
+		/// January 1 is 1, February 1 is 32, etc.
+	
+	int hour() const;
+		/// Returns the hour (0 to 23).
+		
+	int hourAMPM() const;
+		/// Returns the hour (0 to 12).
+	
+	bool isAM() const;
+		/// Returns true if hour < 12;
+
+	bool isPM() const;
+		/// Returns true if hour >= 12.
+		
+	int minute() const;
+		/// Returns the minute (0 to 59).
+		
+	int second() const;
+		/// Returns the second (0 to 59).
+		
+	int millisecond() const;
+		/// Returns the millisecond (0 to 999)
+	
+	int microsecond() const;
+		/// Returns the microsecond (0 to 999)
+	
+	double julianDay() const;
+		/// Returns the julian day for the date.
+
+	int tzd() const;
+		/// Returns the time zone differential.
+		
+	DateTime utc() const;
+		/// Returns the UTC equivalent for the local date and time.
+
+	Timestamp timestamp() const;
+		/// Returns the date and time expressed as a Timestamp.
+
+	Timestamp::UtcTimeVal utcTime() const;
+		/// Returns the UTC equivalent for the local date and time.
+
+	bool operator == (const LocalDateTime& dateTime) const;	
+	bool operator != (const LocalDateTime& dateTime) const;	
+	bool operator <  (const LocalDateTime& dateTime) const;	
+	bool operator <= (const LocalDateTime& dateTime) const;	
+	bool operator >  (const LocalDateTime& dateTime) const;	
+	bool operator >= (const LocalDateTime& dateTime) const;	
+
+	LocalDateTime  operator +  (const Timespan& span) const;
+	LocalDateTime  operator -  (const Timespan& span) const;
+	Timespan       operator -  (const LocalDateTime& dateTime) const;
+	LocalDateTime& operator += (const Timespan& span);
+	LocalDateTime& operator -= (const Timespan& span);
+
+protected:
+	LocalDateTime(Timestamp::UtcTimeVal utcTime, Timestamp::TimeDiff diff, int tzd);
+		
+	void determineTzd(bool adjust = false);
+		/// Recalculate the tzd based on the _dateTime member based
+		/// on the current timezone using the Standard C runtime functions.
+		/// If adjust is true, then adjustForTzd() is called after the
+		/// differential is calculated.
+		
+	void adjustForTzd();
+		/// Adjust the _dateTime member based on the _tzd member.
+		
+	std::time_t dstOffset(int& dstOffset) const;
+		/// Determine the DST offset for the current date/time.
+	
+private:
+	DateTime _dateTime;
+	int      _tzd;
+	
+	friend class DateTimeFormatter;
+	friend class DateTimeParser;
+};
+
+
+//
+// inlines
+//
+inline int LocalDateTime::year() const
+{
+	return _dateTime.year();
+}
+
+
+inline int LocalDateTime::month() const
+{
+	return _dateTime.month();
+}
+
+
+inline int LocalDateTime::week(int firstDayOfWeek) const
+{
+	return _dateTime.week(firstDayOfWeek);
+}
+
+
+inline int LocalDateTime::day() const
+{
+	return _dateTime.day();
+}
+
+	
+inline int LocalDateTime::dayOfWeek() const
+{
+	return _dateTime.dayOfWeek();
+}
+
+
+inline int LocalDateTime::dayOfYear() const
+{
+	return _dateTime.dayOfYear();
+}
+
+
+inline int LocalDateTime::hour() const
+{
+	return _dateTime.hour();
+}
+
+	
+inline int LocalDateTime::hourAMPM() const
+{
+	return _dateTime.hourAMPM();
+}
+
+
+inline bool LocalDateTime::isAM() const
+{
+	return _dateTime.isAM();
+}
+
+
+inline bool LocalDateTime::isPM() const
+{
+	return _dateTime.isPM();
+}
+
+	
+inline int LocalDateTime::minute() const
+{
+	return _dateTime.minute();
+}
+
+	
+inline int LocalDateTime::second() const
+{
+	return _dateTime.second();
+}
+
+	
+inline int LocalDateTime::millisecond() const
+{
+	return _dateTime.millisecond();
+}
+
+
+inline int LocalDateTime::microsecond() const
+{
+	return _dateTime.microsecond();
+}
+
+
+inline double LocalDateTime::julianDay() const
+{
+	return _dateTime.julianDay();
+}
+
+
+inline int LocalDateTime::tzd() const
+{
+	return _tzd;
+}
+
+
+inline Timestamp LocalDateTime::timestamp() const
+{
+	return Timestamp::fromUtcTime(_dateTime.utcTime());
+}
+
+
+inline Timestamp::UtcTimeVal LocalDateTime::utcTime() const
+{
+	return _dateTime.utcTime() - ((Timestamp::TimeDiff) _tzd)*10000000;
+}
+
+
+inline void LocalDateTime::adjustForTzd()
+{
+	_dateTime += Timespan(((Timestamp::TimeDiff) _tzd)*Timespan::SECONDS);
+}
+
+
+inline void swap(LocalDateTime& d1, LocalDateTime& d2)
+{
+	d1.swap(d2);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_LocalDateTime_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/LogFile.h b/base/poco/Foundation/include/Poco/LogFile.h
new file mode 100644
index 00000000000..b4080b6e3ed
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/LogFile.h
@@ -0,0 +1,104 @@
+//
+// LogFile.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  LogFile
+//
+// Definition of the LogFile class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_LogFile_INCLUDED
+#define Foundation_LogFile_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS) && defined(POCO_WIN32_UTF8)
+#include "Poco/LogFile_WIN32U.h"
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "Poco/LogFile_WIN32.h"
+#else
+#include "Poco/LogFile_STD.h"
+#endif
+
+
+namespace Poco {
+
+
+class Foundation_API LogFile: public LogFileImpl
+	/// This class is used by FileChannel to work
+	/// with a log file.
+{
+public:
+	LogFile(const std::string& path);
+		/// Creates the LogFile.
+
+	virtual ~LogFile();
+		/// Destroys the LogFile.
+
+	virtual void write(const std::string& text, bool flush = true);
+		/// Writes the given text to the log file.
+		/// If flush is true, the text will be immediately
+		/// flushed to the file.
+
+	void writeBinary(const char * data, size_t size, bool flush = true);
+		/// Writes the given bytes to the log file.
+		/// If flush is true, the text will be immediately
+		/// flushed to the file.
+
+	UInt64 size() const;
+		/// Returns the current size in bytes of the log file.
+
+	Timestamp creationDate() const;
+		/// Returns the date and time the log file was created.
+
+	const std::string& path() const;
+		/// Returns the path given in the constructor.
+};
+
+
+//
+// inlines
+//
+inline void LogFile::write(const std::string& text, bool flush)
+{
+	writeImpl(text, flush);
+}
+
+
+inline void LogFile::writeBinary(const char * data, size_t data_size, bool flush)
+{
+	writeBinaryImpl(data, data_size, flush);
+}
+
+
+inline UInt64 LogFile::size() const
+{
+	return sizeImpl();
+}
+
+
+inline Timestamp LogFile::creationDate() const
+{
+	return creationDateImpl();
+}
+
+
+inline const std::string& LogFile::path() const
+{
+	return pathImpl();
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_LogFile_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/LogFile_STD.h b/base/poco/Foundation/include/Poco/LogFile_STD.h
new file mode 100644
index 00000000000..2689f312625
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/LogFile_STD.h
@@ -0,0 +1,53 @@
+//
+// LogFile_STD.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  LogFile
+//
+// Definition of the LogFileImpl class using iostreams.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_LogFile_STD_INCLUDED
+#define Foundation_LogFile_STD_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Timestamp.h"
+#include "Poco/FileStream.h"
+
+
+namespace Poco {
+
+
+class Foundation_API LogFileImpl
+	/// The implementation of LogFile for non-Windows platforms.
+	/// The native filesystem APIs are used for
+	/// total control over locking behavior.
+{
+public:
+	LogFileImpl(const std::string& path);
+	~LogFileImpl();
+	void writeImpl(const std::string& text, bool flush);
+	void writeBinaryImpl(const char * data, size_t size, bool flush);
+	UInt64 sizeImpl() const;
+	Timestamp creationDateImpl() const;
+	const std::string& pathImpl() const;
+
+private:
+	std::string _path;
+	mutable Poco::FileOutputStream _str;
+	Timestamp _creationDate;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_LogFile_STD_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/LogFile_WIN32.h b/base/poco/Foundation/include/Poco/LogFile_WIN32.h
new file mode 100644
index 00000000000..cadc08e65fd
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/LogFile_WIN32.h
@@ -0,0 +1,55 @@
+//
+// LogFile_WIN32.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  LogFile
+//
+// Definition of the LogFileImpl class using the Windows file APIs.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_LogFile_WIN32_INCLUDED
+#define Foundation_LogFile_WIN32_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Timestamp.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API LogFileImpl
+	/// The implementation of LogFile for Windows.
+	/// The native filesystem APIs are used for
+	/// total control over locking behavior.
+{
+public:
+	LogFileImpl(const std::string& path);
+	~LogFileImpl();
+	void writeImpl(const std::string& text, bool flush);
+	void writeBinaryImpl(const char * data, size_t size, bool flush);
+	UInt64 sizeImpl() const;
+	Timestamp creationDateImpl() const;
+	const std::string& pathImpl() const;
+
+private:
+	void createFile();
+
+	std::string _path;
+	HANDLE      _hFile;
+	Timestamp   _creationDate;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_LogFile_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/LogFile_WIN32U.h b/base/poco/Foundation/include/Poco/LogFile_WIN32U.h
new file mode 100644
index 00000000000..9e73122249e
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/LogFile_WIN32U.h
@@ -0,0 +1,55 @@
+//
+// LogFile_WIN32U.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  LogFile
+//
+// Definition of the LogFileImpl class using the Windows file APIs.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_LogFile_WIN32U_INCLUDED
+#define Foundation_LogFile_WIN32U_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Timestamp.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API LogFileImpl
+	/// The implementation of LogFile for Windows.
+	/// The native filesystem APIs are used for
+	/// total control over locking behavior.
+{
+public:
+	LogFileImpl(const std::string& path);
+	~LogFileImpl();
+	void writeImpl(const std::string& text, bool flush);
+	void writeBinaryImpl(const char * data, size_t size, bool flush);
+	UInt64 sizeImpl() const;
+	Timestamp creationDateImpl() const;
+	const std::string& pathImpl() const;
+
+private:
+	void createFile();
+
+	std::string _path;
+	HANDLE      _hFile;
+	Timestamp   _creationDate;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_LogFile_WIN32U_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/LogStream.h b/base/poco/Foundation/include/Poco/LogStream.h
new file mode 100644
index 00000000000..c3d3f0850a3
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/LogStream.h
@@ -0,0 +1,192 @@
+//
+// LogStream.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  LogStream
+//
+// Definition of the LogStream class.
+//
+// Copyright (c) 2006-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_LogStream_INCLUDED
+#define Foundation_LogStream_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Logger.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include <istream>
+
+
+namespace Poco {
+
+
+class Foundation_API LogStreamBuf: public UnbufferedStreamBuf
+	/// This class implements a streambuf interface
+	/// to a Logger.
+	///
+	/// The streambuf appends all characters written to it
+	/// to a string. As soon as a CR or LF (std::endl) is written,
+	/// the string is sent to the Logger, with the set
+	/// priority.
+{
+public:
+	LogStreamBuf(Logger& logger, Message::Priority priority);
+		/// Creates the LogStream.
+
+	~LogStreamBuf();
+		/// Destroys the LogStream.
+		
+	void setPriority(Message::Priority priority);
+		/// Sets the priority for log messages.
+		
+	Message::Priority getPriority() const;
+		/// Returns the priority for log messages.
+
+	Logger& logger() const;
+		/// Returns a reference to the Logger.
+
+private:
+	int writeToDevice(char c);
+
+private:
+	Logger&           _logger;
+	Message::Priority _priority;
+	std::string       _message;
+};
+
+
+class Foundation_API LogIOS: public virtual std::ios
+	/// The base class for LogStream.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	LogIOS(Logger& logger, Message::Priority priority);
+	~LogIOS();
+	LogStreamBuf* rdbuf();
+
+protected:
+	LogStreamBuf _buf;
+};
+
+
+class Foundation_API LogStream: public LogIOS, public std::ostream
+	/// This class implements an ostream interface
+	/// to a Logger.
+	///
+	/// The stream's buffer appends all characters written to it
+	/// to a string. As soon as a CR or LF (std::endl) is written,
+	/// the string is sent to the Logger, with the current
+	/// priority.
+	///
+	/// Usage example:
+	///     LogStream ls(someLogger);
+	///     ls << "Some informational message" << std::endl;
+	///     ls.error() << "Some error message" << std::endl;
+{
+public:
+	LogStream(Logger& logger, Message::Priority priority = Message::PRIO_INFORMATION);
+		/// Creates the LogStream, using the given logger and priority.
+
+	LogStream(const std::string& loggerName, Message::Priority priority = Message::PRIO_INFORMATION);
+		/// Creates the LogStream, using the logger identified
+		/// by loggerName, and sets the priority.
+		
+	~LogStream();
+		/// Destroys the LogStream.
+		
+	LogStream& fatal();
+		/// Sets the priority for log messages to Message::PRIO_FATAL.
+		
+	LogStream& fatal(const std::string& message);
+		/// Sets the priority for log messages to Message::PRIO_FATAL
+		/// and writes the given message.
+		
+	LogStream& critical();
+		/// Sets the priority for log messages to Message::PRIO_CRITICAL.
+
+	LogStream& critical(const std::string& message);
+		/// Sets the priority for log messages to Message::PRIO_CRITICAL
+		/// and writes the given message.
+
+	LogStream& error();
+		/// Sets the priority for log messages to Message::PRIO_ERROR.
+
+	LogStream& error(const std::string& message);
+		/// Sets the priority for log messages to Message::PRIO_ERROR
+		/// and writes the given message.
+
+	LogStream& warning();
+		/// Sets the priority for log messages to Message::PRIO_WARNING.
+
+	LogStream& warning(const std::string& message);
+		/// Sets the priority for log messages to Message::PRIO_WARNING
+		/// and writes the given message.
+
+	LogStream& notice();
+		/// Sets the priority for log messages to Message::PRIO_NOTICE.
+
+	LogStream& notice(const std::string& message);
+		/// Sets the priority for log messages to Message::PRIO_NOTICE
+		/// and writes the given message.
+
+	LogStream& information();
+		/// Sets the priority for log messages to Message::PRIO_INFORMATION.
+
+	LogStream& information(const std::string& message);
+		/// Sets the priority for log messages to Message::PRIO_INFORMATION
+		/// and writes the given message.
+
+	LogStream& debug();
+		/// Sets the priority for log messages to Message::PRIO_DEBUG.
+
+	LogStream& debug(const std::string& message);
+		/// Sets the priority for log messages to Message::PRIO_DEBUG
+		/// and writes the given message.
+
+	LogStream& trace();
+		/// Sets the priority for log messages to Message::PRIO_TRACE.
+
+	LogStream& trace(const std::string& message);
+		/// Sets the priority for log messages to Message::PRIO_TRACE
+		/// and writes the given message.
+
+	LogStream& test();
+		/// Sets the priority for log messages to Message::PRIO_TEST.
+
+	LogStream& test(const std::string& message);
+		/// Sets the priority for log messages to Message::PRIO_TEST
+		/// and writes the given message.
+
+	LogStream& priority(Message::Priority priority);
+		/// Sets the priority for log messages.
+};
+
+
+//
+// inlines
+//
+inline Message::Priority LogStreamBuf::getPriority() const
+{
+	return _priority;
+}
+
+
+inline Logger& LogStreamBuf::logger() const
+{
+	return _logger;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_LogStream_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Logger.h b/base/poco/Foundation/include/Poco/Logger.h
new file mode 100644
index 00000000000..8dbf8327c88
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Logger.h
@@ -0,0 +1,1447 @@
+//
+// Logger.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  Logger
+//
+// Definition of the Logger class.
+//
+// Copyright (c) 2004-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Logger_INCLUDED
+#define Foundation_Logger_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Channel.h"
+#include "Poco/Message.h"
+#include "Poco/Format.h"
+#include <map>
+#include <vector>
+#include <cstddef>
+#include <atomic>
+
+
+namespace Poco {
+
+
+class Exception;
+
+
+class Foundation_API Logger: public Channel
+	/// Logger is a special Channel that acts as the main
+	/// entry point into the logging framework.
+	///
+	/// An application uses instances of the Logger class to generate its log messages
+	/// and send them on their way to their final destination. Logger instances
+	/// are organized in a hierarchical, tree-like manner and are maintained by
+	/// the framework. Every Logger object has exactly one direct ancestor, with
+	/// the exception of the root logger. A newly created logger inherits its properties -
+	/// channel and level - from its direct ancestor. Every logger is connected
+	/// to a channel, to which it passes on its messages. Furthermore, every logger
+	/// has a log level, which is used for filtering messages based on their priority.
+	/// Only messages with a priority equal to or higher than the specified level
+	/// are passed on. For example, if the level of a logger is set to three (PRIO_ERROR),
+	/// only messages with priority PRIO_ERROR, PRIO_CRITICAL and PRIO_FATAL will
+	/// propagate. If the level is set to zero, the logger is effectively disabled.
+	///
+	/// The name of a logger determines the logger's place within the logger hierarchy.
+	/// The name of the root logger is always "", the empty string. For all other
+	/// loggers, the name is made up of one or more components, separated by a period.
+	/// For example, the loggers with the name HTTPServer.RequestHandler and HTTPServer.Listener
+	/// are descendants of the logger HTTPServer, which itself is a descendant of
+	/// the root logger. There is not limit as to how deep
+	/// the logger hierarchy can become. Once a logger has been created and it has
+	/// inherited the channel and level from its ancestor, it loses the connection
+	/// to it. So changes to the level or channel of a logger do not affect its
+	/// descendants. This greatly simplifies the implementation of the framework
+	/// and is no real restriction, because almost always levels and channels are
+	/// set up at application startup and never changed afterwards. Nevertheless,
+	/// there are methods to simultaneously change the level and channel of all
+	/// loggers in a certain hierarchy.
+	///
+	/// There are also convenience macros available that wrap the actual
+	/// logging statement into a check whether the Logger's log level
+	/// is sufficient to actually log the message. This allows to increase
+	/// the application performance if many complex log statements
+	/// are used. The macros also add the source file path and line
+	/// number into the log message so that it is available to formatters.
+	/// Variants of these macros that allow message formatting with Poco::format()
+	/// are also available. Up to four arguments are supported.
+	///
+	/// Examples:
+	///     poco_warning(logger, "This is a warning");
+	///     poco_information_f2(logger, "An informational message with args: %d, %d", 1, 2);
+{
+public:
+	const std::string& name() const;
+		/// Returns the name of the logger, which is set as the
+		/// message source on all messages created by the logger.
+
+	void setChannel(Channel* pChannel);
+		/// Attaches the given Channel to the Logger.
+		
+	Channel* getChannel() const;
+		/// Returns the Channel attached to the logger.
+		
+	void setLevel(int level);
+		/// Sets the Logger's log level.
+		///
+		/// See Message::Priority for valid log levels.
+		/// Setting the log level to zero turns off
+		/// logging for that Logger.
+		
+	int getLevel() const;
+		/// Returns the Logger's log level.
+		
+	void setLevel(const std::string& level);
+		/// Sets the Logger's log level using a symbolic value.
+		///
+		/// Valid values are:
+		///   - none (turns off logging)
+		///   - fatal
+		///   - critical
+		///   - error
+		///   - warning
+		///   - notice
+		///   - information
+		///   - debug
+		///   - trace
+
+	void setProperty(const std::string& name, const std::string& value);
+		/// Sets or changes a configuration property.
+		///
+		/// Only the "channel" and "level" properties are supported, which allow
+		/// setting the target channel and log level, respectively, via the LoggingRegistry.
+		/// The "channel" and "level" properties are set-only.
+
+	void log(const Message& msg);
+		/// Logs the given message if its priority is
+		/// greater than or equal to the Logger's log level.
+		
+	void log(const Exception& exc);
+		/// Logs the given exception with priority PRIO_ERROR.	
+
+	void log(const Exception& exc, const char* file, int line);
+		/// Logs the given exception with priority PRIO_ERROR.	
+		///
+		/// File must be a static string, such as the value of
+		/// the __FILE__ macro. The string is not copied
+		/// internally for performance reasons.	
+		
+	void fatal(const std::string& msg);
+		/// If the Logger's log level is at least PRIO_FATAL,
+		/// creates a Message with priority PRIO_FATAL
+		/// and the given message text and sends it
+		/// to the attached channel.
+
+	void fatal(const std::string& msg, const char* file, int line);
+		/// If the Logger's log level is at least PRIO_FATAL,
+		/// creates a Message with priority PRIO_FATAL
+		/// and the given message text and sends it
+		/// to the attached channel.
+		///
+		/// File must be a static string, such as the value of
+		/// the __FILE__ macro. The string is not copied
+		/// internally for performance reasons.	
+
+	void fatal(const std::string& fmt, const Any& value1);
+	void fatal(const std::string& fmt, const Any& value1, const Any& value2);
+	void fatal(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3);
+	void fatal(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4);
+	void fatal(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5);
+	void fatal(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6);
+	void fatal(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7);
+	void fatal(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8);
+	void fatal(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9);
+	void fatal(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10);
+
+	void critical(const std::string& msg);
+		/// If the Logger's log level is at least PRIO_CRITICAL,
+		/// creates a Message with priority PRIO_CRITICAL
+		/// and the given message text and sends it
+		/// to the attached channel.
+
+	void critical(const std::string& msg, const char* file, int line);
+		/// If the Logger's log level is at least PRIO_CRITICAL,
+		/// creates a Message with priority PRIO_CRITICAL
+		/// and the given message text and sends it
+		/// to the attached channel.
+		///
+		/// File must be a static string, such as the value of
+		/// the __FILE__ macro. The string is not copied
+		/// internally for performance reasons.	
+
+	void critical(const std::string& fmt, const Any& value1);
+	void critical(const std::string& fmt, const Any& value1, const Any& value2);
+	void critical(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3);
+	void critical(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4);
+	void critical(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5);
+	void critical(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6);
+	void critical(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7);
+	void critical(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8);
+	void critical(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9);
+	void critical(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10);
+
+	void error(const std::string& msg);
+		/// If the Logger's log level is at least PRIO_ERROR,
+		/// creates a Message with priority PRIO_ERROR
+		/// and the given message text and sends it
+		/// to the attached channel.
+
+	void error(const std::string& msg, const char* file, int line);
+		/// If the Logger's log level is at least PRIO_ERROR,
+		/// creates a Message with priority PRIO_ERROR
+		/// and the given message text and sends it
+		/// to the attached channel.
+		///
+		/// File must be a static string, such as the value of
+		/// the __FILE__ macro. The string is not copied
+		/// internally for performance reasons.	
+
+	void error(const std::string& fmt, const Any& value1);
+	void error(const std::string& fmt, const Any& value1, const Any& value2);
+	void error(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3);
+	void error(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4);
+	void error(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5);
+	void error(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6);
+	void error(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7);
+	void error(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8);
+	void error(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9);
+	void error(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10);
+
+	void warning(const std::string& msg);
+		/// If the Logger's log level is at least PRIO_WARNING,
+		/// creates a Message with priority PRIO_WARNING
+		/// and the given message text and sends it
+		/// to the attached channel.
+
+	void warning(const std::string& msg, const char* file, int line);
+		/// If the Logger's log level is at least PRIO_WARNING,
+		/// creates a Message with priority PRIO_WARNING
+		/// and the given message text and sends it
+		/// to the attached channel.
+		///
+		/// File must be a static string, such as the value of
+		/// the __FILE__ macro. The string is not copied
+		/// internally for performance reasons.	
+
+	void warning(const std::string& fmt, const Any& value1);
+	void warning(const std::string& fmt, const Any& value1, const Any& value2);
+	void warning(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3);
+	void warning(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4);
+	void warning(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5);
+	void warning(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6);
+	void warning(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7);
+	void warning(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8);
+	void warning(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9);
+	void warning(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10);
+
+	void notice(const std::string& msg);
+		/// If the Logger's log level is at least PRIO_NOTICE,
+		/// creates a Message with priority PRIO_NOTICE
+		/// and the given message text and sends it
+		/// to the attached channel.
+
+	void notice(const std::string& msg, const char* file, int line);
+		/// If the Logger's log level is at least PRIO_NOTICE,
+		/// creates a Message with priority PRIO_NOTICE
+		/// and the given message text and sends it
+		/// to the attached channel.
+		///
+		/// File must be a static string, such as the value of
+		/// the __FILE__ macro. The string is not copied
+		/// internally for performance reasons.	
+
+	void notice(const std::string& fmt, const Any& value1);
+	void notice(const std::string& fmt, const Any& value1, const Any& value2);
+	void notice(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3);
+	void notice(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4);
+	void notice(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5);
+	void notice(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6);
+	void notice(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7);
+	void notice(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8);
+	void notice(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9);
+	void notice(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10);
+
+	void information(const std::string& msg);
+		/// If the Logger's log level is at least PRIO_INFORMATION,
+		/// creates a Message with priority PRIO_INFORMATION
+		/// and the given message text and sends it
+		/// to the attached channel.
+
+	void information(const std::string& msg, const char* file, int line);
+		/// If the Logger's log level is at least PRIO_INFORMATION,
+		/// creates a Message with priority PRIO_INFORMATION
+		/// and the given message text and sends it
+		/// to the attached channel.
+		///
+		/// File must be a static string, such as the value of
+		/// the __FILE__ macro. The string is not copied
+		/// internally for performance reasons.	
+
+	void information(const std::string& fmt, const Any& value1);
+	void information(const std::string& fmt, const Any& value1, const Any& value2);
+	void information(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3);
+	void information(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4);
+	void information(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5);
+	void information(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6);
+	void information(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7);
+	void information(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8);
+	void information(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9);
+	void information(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10);
+
+	void debug(const std::string& msg);
+		/// If the Logger's log level is at least PRIO_DEBUG,
+		/// creates a Message with priority PRIO_DEBUG
+		/// and the given message text and sends it
+		/// to the attached channel.
+
+	void debug(const std::string& msg, const char* file, int line);
+		/// If the Logger's log level is at least PRIO_DEBUG,
+		/// creates a Message with priority PRIO_DEBUG
+		/// and the given message text and sends it
+		/// to the attached channel.
+		///
+		/// File must be a static string, such as the value of
+		/// the __FILE__ macro. The string is not copied
+		/// internally for performance reasons.	
+
+	void debug(const std::string& fmt, const Any& value1);
+	void debug(const std::string& fmt, const Any& value1, const Any& value2);
+	void debug(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3);
+	void debug(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4);
+	void debug(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5);
+	void debug(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6);
+	void debug(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7);
+	void debug(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8);
+	void debug(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9);
+	void debug(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10);
+
+	void trace(const std::string& msg);
+		/// If the Logger's log level is at least PRIO_TRACE,
+		/// creates a Message with priority PRIO_TRACE
+		/// and the given message text and sends it
+		/// to the attached channel.
+
+	void trace(const std::string& msg, const char* file, int line);
+		/// If the Logger's log level is at least PRIO_TRACE,
+		/// creates a Message with priority PRIO_TRACE
+		/// and the given message text and sends it
+		/// to the attached channel.
+		///
+		/// File must be a static string, such as the value of
+		/// the __FILE__ macro. The string is not copied
+		/// internally for performance reasons.	
+
+	void trace(const std::string& fmt, const Any& value1);
+	void trace(const std::string& fmt, const Any& value1, const Any& value2);
+	void trace(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3);
+	void trace(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4);
+	void trace(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5);
+	void trace(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6);
+	void trace(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7);
+	void trace(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8);
+	void trace(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9);
+	void trace(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10);
+
+	void test(const std::string& msg);
+		/// If the Logger's log level is at least PRIO_TEST,
+		/// creates a Message with priority PRIO_TEST
+		/// and the given message text and sends it
+		/// to the attached channel.
+
+	void test(const std::string& msg, const char* file, int line);
+		/// If the Logger's log level is at least PRIO_TEST,
+		/// creates a Message with priority PRIO_TEST
+		/// and the given message text and sends it
+		/// to the attached channel.
+		///
+		/// File must be a static string, such as the value of
+		/// the __FILE__ macro. The string is not copied
+		/// internally for performance reasons.
+
+	void test(const std::string& fmt, const Any& value1);
+	void test(const std::string& fmt, const Any& value1, const Any& value2);
+	void test(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3);
+	void test(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4);
+	void test(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5);
+	void test(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6);
+	void test(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7);
+	void test(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8);
+	void test(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9);
+	void test(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10);
+
+
+	void dump(const std::string& msg, const void* buffer, std::size_t length, Message::Priority prio = Message::PRIO_DEBUG);
+		/// Logs the given message, followed by the data in buffer.
+		///
+		/// The data in buffer is written in canonical hex+ASCII form:
+		/// Offset (4 bytes) in hexadecimal, followed by sixteen 
+		/// space-separated, two column, hexadecimal bytes,
+		/// followed by the same sixteen bytes as ASCII characters.
+		/// For bytes outside the range 32 .. 127, a dot is printed.
+
+	bool is(int level) const;
+		/// Returns true if at least the given log level is set.
+		
+	bool fatal() const;
+		/// Returns true if the log level is at least PRIO_FATAL.
+		
+	bool critical() const;
+		/// Returns true if the log level is at least PRIO_CRITICAL.
+
+	bool error() const;
+		/// Returns true if the log level is at least PRIO_ERROR.
+
+	bool warning() const;
+		/// Returns true if the log level is at least PRIO_WARNING.
+
+	bool notice() const;
+		/// Returns true if the log level is at least PRIO_NOTICE.
+
+	bool information() const;
+		/// Returns true if the log level is at least PRIO_INFORMATION.
+
+	bool debug() const;
+		/// Returns true if the log level is at least PRIO_DEBUG.
+
+	bool trace() const;
+		/// Returns true if the log level is at least PRIO_TRACE.
+
+    bool test() const;
+		/// Returns true if the log level is at least PRIO_TEST.
+
+	static std::string format(const std::string& fmt, const std::string& arg);
+		/// Replaces all occurences of $0 in fmt with the string given in arg and
+		/// returns the result. To include a dollar sign in the result string,
+		/// specify two dollar signs ($$) in the format string.
+		
+	static std::string format(const std::string& fmt, const std::string& arg0, const std::string& arg1);
+		/// Replaces all occurences of $<n> in fmt with the string given in arg<n> and
+		/// returns the result. To include a dollar sign in the result string,
+		/// specify two dollar signs ($$) in the format string.
+
+	static std::string format(const std::string& fmt, const std::string& arg0, const std::string& arg1, const std::string& arg2);	
+		/// Replaces all occurences of $<n> in fmt with the string given in arg<n> and
+		/// returns the result. To include a dollar sign in the result string,
+		/// specify two dollar signs ($$) in the format string.
+
+	static std::string format(const std::string& fmt, const std::string& arg0, const std::string& arg1, const std::string& arg2, const std::string& arg3);	
+		/// Replaces all occurences of $<n> in fmt with the string given in arg<n> and
+		/// returns the result. To include a dollar sign in the result string,
+		/// specify two dollar signs ($$) in the format string.
+
+	static void formatDump(std::string& message, const void* buffer, std::size_t length);
+		/// Creates a hex-dump of the given buffer and appends it to the
+		/// given message string.
+		
+	static void setLevel(const std::string& name, int level);
+		/// Sets the given log level on all loggers that are
+		/// descendants of the Logger with the given name.
+		
+	static void setChannel(const std::string& name, Channel* pChannel);
+		/// Attaches the given Channel to all loggers that are
+		/// descendants of the Logger with the given name.
+
+	static void setProperty(const std::string& loggerName, const std::string& propertyName, const std::string& value);
+		/// Sets or changes a configuration property for all loggers
+		/// that are descendants of the Logger with the given name.
+
+	static Logger& get(const std::string& name);
+		/// Returns a reference to the Logger with the given name.
+		/// If the Logger does not yet exist, it is created, based
+		/// on its parent logger.
+
+	static Logger& unsafeGet(const std::string& name);
+		/// Returns a reference to the Logger with the given name.
+		/// If the Logger does not yet exist, it is created, based
+		/// on its parent logger.
+		///
+		/// WARNING: This method is not thread safe. You should
+		/// probably use get() instead.
+		/// The only time this method should be used is during
+		/// program initialization, when only one thread is running.
+		
+	static Logger& create(const std::string& name, Channel* pChannel, int level = Message::PRIO_INFORMATION);
+		/// Creates and returns a reference to a Logger with the
+		/// given name. The Logger's Channel and log level as set as
+		/// specified.
+		
+	static Logger& root();
+		/// Returns a reference to the root logger, which is the ultimate
+		/// ancestor of all Loggers.
+		
+	static Logger* has(const std::string& name);
+		/// Returns a pointer to the Logger with the given name if it
+		/// exists, or a null pointer otherwse.
+		
+	static void destroy(const std::string& name);
+		/// Destroys the logger with the specified name. Does nothing
+		/// if the logger is not found.
+		///
+		/// After a logger has been destroyed, all references to it
+		/// become invalid.	
+		
+	static void shutdown();
+		/// Shuts down the logging framework and releases all
+		/// Loggers.
+		
+	static void names(std::vector<std::string>& names);
+		/// Fills the given vector with the names
+		/// of all currently defined loggers.
+		
+	static int parseLevel(const std::string& level);
+		/// Parses a symbolic log level from a string and
+		/// returns the resulting numeric level.
+		///
+		/// Valid symbolic levels are:
+		///   - none (turns off logging)
+		///   - fatal
+		///   - critical
+		///   - error
+		///   - warning
+		///   - notice
+		///   - information
+		///   - debug
+		///   - trace
+		///   - test
+		///
+		/// The level is not case sensitive.
+		
+	static const std::string ROOT; /// The name of the root logger ("").	
+		
+protected:
+	typedef std::map<std::string, Logger*> LoggerMap;
+
+	Logger(const std::string& name, Channel* pChannel, int level);
+	~Logger();
+	
+	void log(const std::string& text, Message::Priority prio);
+	void log(const std::string& text, Message::Priority prio, const char* file, int line);
+
+	static std::string format(const std::string& fmt, int argc, std::string argv[]);
+	static Logger& parent(const std::string& name);
+	static void add(Logger* pLogger);
+	static Logger* find(const std::string& name);
+
+private:
+	Logger();
+	Logger(const Logger&);
+	Logger& operator = (const Logger&);
+	
+	std::string _name;
+	Channel*    _pChannel;
+	std::atomic_int   _level;
+
+	static LoggerMap* _pLoggerMap;
+	static Mutex      _mapMtx;
+};
+
+
+//
+// convenience macros
+//
+#define poco_fatal(logger, msg) \
+	if ((logger).fatal()) (logger).fatal(msg, __FILE__, __LINE__); else (void) 0
+
+#define poco_fatal_f1(logger, fmt, arg1) \
+	if ((logger).fatal()) (logger).fatal(Poco::format((fmt), arg1), __FILE__, __LINE__); else (void) 0
+
+#define poco_fatal_f2(logger, fmt, arg1, arg2) \
+	if ((logger).fatal()) (logger).fatal(Poco::format((fmt), (arg1), (arg2)), __FILE__, __LINE__); else (void) 0
+
+#define poco_fatal_f3(logger, fmt, arg1, arg2, arg3) \
+	if ((logger).fatal()) (logger).fatal(Poco::format((fmt), (arg1), (arg2), (arg3)), __FILE__, __LINE__); else (void) 0
+
+#define poco_fatal_f4(logger, fmt, arg1, arg2, arg3, arg4) \
+	if ((logger).fatal()) (logger).fatal(Poco::format((fmt), (arg1), (arg2), (arg3), (arg4)), __FILE__, __LINE__); else (void) 0
+
+#define poco_critical(logger, msg) \
+	if ((logger).critical()) (logger).critical(msg, __FILE__, __LINE__); else (void) 0
+
+#define poco_critical_f1(logger, fmt, arg1) \
+	if ((logger).critical()) (logger).critical(Poco::format((fmt), (arg1)), __FILE__, __LINE__); else (void) 0
+
+#define poco_critical_f2(logger, fmt, arg1, arg2) \
+	if ((logger).critical()) (logger).critical(Poco::format((fmt), (arg1), (arg2)), __FILE__, __LINE__); else (void) 0
+
+#define poco_critical_f3(logger, fmt, arg1, arg2, arg3) \
+	if ((logger).critical()) (logger).critical(Poco::format((fmt), (arg1), (arg2), (arg3)), __FILE__, __LINE__); else (void) 0
+
+#define poco_critical_f4(logger, fmt, arg1, arg2, arg3, arg4) \
+	if ((logger).critical()) (logger).critical(Poco::format((fmt), (arg1), (arg2), (arg3), (arg4)), __FILE__, __LINE__); else (void) 0
+
+#define poco_error(logger, msg) \
+	if ((logger).error()) (logger).error(msg, __FILE__, __LINE__); else (void) 0
+
+#define poco_error_f1(logger, fmt, arg1) \
+	if ((logger).error()) (logger).error(Poco::format((fmt), (arg1)), __FILE__, __LINE__); else (void) 0
+
+#define poco_error_f2(logger, fmt, arg1, arg2) \
+	if ((logger).error()) (logger).error(Poco::format((fmt), (arg1), (arg2)), __FILE__, __LINE__); else (void) 0
+
+#define poco_error_f3(logger, fmt, arg1, arg2, arg3) \
+	if ((logger).error()) (logger).error(Poco::format((fmt), (arg1), (arg2), (arg3)), __FILE__, __LINE__); else (void) 0
+
+#define poco_error_f4(logger, fmt, arg1, arg2, arg3, arg4) \
+	if ((logger).error()) (logger).error(Poco::format((fmt), (arg1), (arg2), (arg3), (arg4)), __FILE__, __LINE__); else (void) 0
+
+#define poco_warning(logger, msg) \
+	if ((logger).warning()) (logger).warning(msg, __FILE__, __LINE__); else (void) 0
+
+#define poco_warning_f1(logger, fmt, arg1) \
+	if ((logger).warning()) (logger).warning(Poco::format((fmt), (arg1)), __FILE__, __LINE__); else (void) 0
+
+#define poco_warning_f2(logger, fmt, arg1, arg2) \
+	if ((logger).warning()) (logger).warning(Poco::format((fmt), (arg1), (arg2)), __FILE__, __LINE__); else (void) 0
+
+#define poco_warning_f3(logger, fmt, arg1, arg2, arg3) \
+	if ((logger).warning()) (logger).warning(Poco::format((fmt), (arg1), (arg2), (arg3)), __FILE__, __LINE__); else (void) 0
+
+#define poco_warning_f4(logger, fmt, arg1, arg2, arg3, arg4) \
+	if ((logger).warning()) (logger).warning(Poco::format((fmt), (arg1), (arg2), (arg3), (arg4)), __FILE__, __LINE__); else (void) 0
+	
+#define poco_notice(logger, msg) \
+	if ((logger).notice()) (logger).notice(msg, __FILE__, __LINE__); else (void) 0
+
+#define poco_notice_f1(logger, fmt, arg1) \
+	if ((logger).notice()) (logger).notice(Poco::format((fmt), (arg1)), __FILE__, __LINE__); else (void) 0
+
+#define poco_notice_f2(logger, fmt, arg1, arg2) \
+	if ((logger).notice()) (logger).notice(Poco::format((fmt), (arg1), (arg2)), __FILE__, __LINE__); else (void) 0
+
+#define poco_notice_f3(logger, fmt, arg1, arg2, arg3) \
+	if ((logger).notice()) (logger).notice(Poco::format((fmt), (arg1), (arg2), (arg3)), __FILE__, __LINE__); else (void) 0
+
+#define poco_notice_f4(logger, fmt, arg1, arg2, arg3, arg4) \
+	if ((logger).notice()) (logger).notice(Poco::format((fmt), (arg1), (arg2), (arg3), (arg4)), __FILE__, __LINE__); else (void) 0
+
+#define poco_information(logger, msg) \
+	if ((logger).information()) (logger).information(msg, __FILE__, __LINE__); else (void) 0
+
+#define poco_information_f1(logger, fmt, arg1) \
+	if ((logger).information()) (logger).information(Poco::format((fmt), (arg1)), __FILE__, __LINE__); else (void) 0
+
+#define poco_information_f2(logger, fmt, arg1, arg2) \
+	if ((logger).information()) (logger).information(Poco::format((fmt), (arg1), (arg2)), __FILE__, __LINE__); else (void) 0
+
+#define poco_information_f3(logger, fmt, arg1, arg2, arg3) \
+	if ((logger).information()) (logger).information(Poco::format((fmt), (arg1), (arg2), (arg3)), __FILE__, __LINE__); else (void) 0
+
+#define poco_information_f4(logger, fmt, arg1, arg2, arg3, arg4) \
+	if ((logger).information()) (logger).information(Poco::format((fmt), (arg1), (arg2), (arg3), (arg4)), __FILE__, __LINE__); else (void) 0
+
+#if defined(_DEBUG) || defined(POCO_LOG_DEBUG)
+	#define poco_debug(logger, msg) \
+		if ((logger).debug()) (logger).debug(msg, __FILE__, __LINE__); else (void) 0
+
+	#define poco_debug_f1(logger, fmt, arg1) \
+		if ((logger).debug()) (logger).debug(Poco::format((fmt), (arg1)), __FILE__, __LINE__); else (void) 0
+
+	#define poco_debug_f2(logger, fmt, arg1, arg2) \
+		if ((logger).debug()) (logger).debug(Poco::format((fmt), (arg1), (arg2)), __FILE__, __LINE__); else (void) 0
+
+	#define poco_debug_f3(logger, fmt, arg1, arg2, arg3) \
+		if ((logger).debug()) (logger).debug(Poco::format((fmt), (arg1), (arg2), (arg3)), __FILE__, __LINE__); else (void) 0
+
+	#define poco_debug_f4(logger, fmt, arg1, arg2, arg3, arg4) \
+		if ((logger).debug()) (logger).debug(Poco::format((fmt), (arg1), (arg2), (arg3), (arg4)), __FILE__, __LINE__); else (void) 0
+
+	#define poco_trace(logger, msg) \
+		if ((logger).trace()) (logger).trace(msg, __FILE__, __LINE__); else (void) 0
+
+	#define poco_trace_f1(logger, fmt, arg1) \
+		if ((logger).trace()) (logger).trace(Poco::format((fmt), (arg1)), __FILE__, __LINE__); else (void) 0
+
+	#define poco_trace_f2(logger, fmt, arg1, arg2) \
+		if ((logger).trace()) (logger).trace(Poco::format((fmt), (arg1), (arg2)), __FILE__, __LINE__); else (void) 0
+
+	#define poco_trace_f3(logger, fmt, arg1, arg2, arg3) \
+		if ((logger).trace()) (logger).trace(Poco::format((fmt), (arg1), (arg2), (arg3)), __FILE__, __LINE__); else (void) 0
+
+	#define poco_trace_f4(logger, fmt, arg1, arg2, arg3, arg4) \
+		if ((logger).trace()) (logger).trace(Poco::format((fmt), (arg1), (arg2), (arg3), (arg4)), __FILE__, __LINE__); else (void) 0
+
+	#define poco_test(logger, msg) \
+		if ((logger).test()) (logger).test(msg, __FILE__, __LINE__); else (void) 0
+
+	#define poco_test_f1(logger, fmt, arg1) \
+		if ((logger).test()) (logger).test(Poco::format((fmt), (arg1)), __FILE__, __LINE__); else (void) 0
+
+	#define poco_test_f2(logger, fmt, arg1, arg2) \
+		if ((logger).test()) (logger).test(Poco::format((fmt), (arg1), (arg2)), __FILE__, __LINE__); else (void) 0
+
+	#define poco_test_f3(logger, fmt, arg1, arg2, arg3) \
+		if ((logger).test()) (logger).test(Poco::format((fmt), (arg1), (arg2), (arg3)), __FILE__, __LINE__); else (void) 0
+
+	#define poco_test_f4(logger, fmt, arg1, arg2, arg3, arg4) \
+		if ((logger).test()) (logger).test(Poco::format((fmt), (arg1), (arg2), (arg3), (arg4)), __FILE__, __LINE__); else (void) 0
+#else
+	#define poco_debug(logger, msg)
+	#define poco_debug_f1(logger, fmt, arg1)
+	#define poco_debug_f2(logger, fmt, arg1, arg2)
+	#define poco_debug_f3(logger, fmt, arg1, arg2, arg3)
+	#define poco_debug_f4(logger, fmt, arg1, arg2, arg3, arg4)
+	#define poco_trace(logger, msg)
+	#define poco_trace_f1(logger, fmt, arg1)
+	#define poco_trace_f2(logger, fmt, arg1, arg2)
+	#define poco_trace_f3(logger, fmt, arg1, arg2, arg3)
+	#define poco_trace_f4(logger, fmt, arg1, arg2, arg3, arg4)
+	#define poco_test(logger, msg)
+	#define poco_test_f1(logger, fmt, arg1)
+	#define poco_test_f2(logger, fmt, arg1, arg2)
+	#define poco_test_f3(logger, fmt, arg1, arg2, arg3)
+	#define poco_test_f4(logger, fmt, arg1, arg2, arg3, arg4)
+#endif
+
+
+//
+// inlines
+//
+inline const std::string& Logger::name() const
+{
+	return _name;
+}
+
+
+inline int Logger::getLevel() const
+{
+	return _level;
+}
+
+
+inline void Logger::log(const std::string& text, Message::Priority prio)
+{
+	if (_level >= prio && _pChannel)
+	{
+		_pChannel->log(Message(_name, text, prio));
+	}
+}
+
+
+inline void Logger::log(const std::string& text, Message::Priority prio, const char* file, int line)
+{
+	if (_level >= prio && _pChannel)
+	{
+		_pChannel->log(Message(_name, text, prio, file, line));
+	}
+}
+
+
+inline void Logger::fatal(const std::string& msg)
+{
+	log(msg, Message::PRIO_FATAL);
+}
+
+
+inline void Logger::fatal(const std::string& msg, const char* file, int line)
+{
+	log(msg, Message::PRIO_FATAL, file, line);
+}
+
+
+inline void Logger::fatal(const std::string& fmt, const Any& value1)
+{
+	log(Poco::format(fmt, value1), Message::PRIO_FATAL);
+}
+
+
+inline void Logger::fatal(const std::string& fmt, const Any& value1, const Any& value2)
+{
+	log(Poco::format(fmt, value1, value2), Message::PRIO_FATAL);
+}
+
+
+inline void Logger::fatal(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3)
+{
+	log(Poco::format(fmt, value1, value2, value3), Message::PRIO_FATAL);
+}
+
+
+inline void Logger::fatal(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4), Message::PRIO_FATAL);
+}
+
+
+inline void Logger::fatal(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5), Message::PRIO_FATAL);
+}
+
+
+inline void Logger::fatal(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6), Message::PRIO_FATAL);
+}
+
+
+inline void Logger::fatal(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7), Message::PRIO_FATAL);
+}
+
+
+inline void Logger::fatal(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8), Message::PRIO_FATAL);
+}
+
+
+inline void Logger::fatal(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9), Message::PRIO_FATAL);
+}
+
+
+inline void Logger::fatal(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10), Message::PRIO_FATAL);
+}
+
+
+inline void Logger::critical(const std::string& msg)
+{
+	log(msg, Message::PRIO_CRITICAL);
+}
+
+
+inline void Logger::critical(const std::string& msg, const char* file, int line)
+{
+	log(msg, Message::PRIO_CRITICAL, file, line);
+}
+
+
+inline void Logger::critical(const std::string& fmt, const Any& value1)
+{
+	log(Poco::format(fmt, value1), Message::PRIO_CRITICAL);
+}
+
+
+inline void Logger::critical(const std::string& fmt, const Any& value1, const Any& value2)
+{
+	log(Poco::format(fmt, value1, value2), Message::PRIO_CRITICAL);
+}
+
+
+inline void Logger::critical(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3)
+{
+	log(Poco::format(fmt, value1, value2, value3), Message::PRIO_CRITICAL);
+}
+
+
+inline void Logger::critical(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4), Message::PRIO_CRITICAL);
+}
+
+
+inline void Logger::critical(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5), Message::PRIO_CRITICAL);
+}
+
+
+inline void Logger::critical(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6), Message::PRIO_CRITICAL);
+}
+
+
+inline void Logger::critical(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7), Message::PRIO_CRITICAL);
+}
+
+
+inline void Logger::critical(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8), Message::PRIO_CRITICAL);
+}
+
+
+inline void Logger::critical(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9), Message::PRIO_CRITICAL);
+}
+
+
+inline void Logger::critical(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10), Message::PRIO_CRITICAL);
+}
+
+
+inline void Logger::error(const std::string& msg)
+{
+	log(msg, Message::PRIO_ERROR);
+}
+
+
+inline void Logger::error(const std::string& msg, const char* file, int line)
+{
+	log(msg, Message::PRIO_ERROR, file, line);
+}
+
+
+inline void Logger::error(const std::string& fmt, const Any& value1)
+{
+	log(Poco::format(fmt, value1), Message::PRIO_ERROR);
+}
+
+
+inline void Logger::error(const std::string& fmt, const Any& value1, const Any& value2)
+{
+	log(Poco::format(fmt, value1, value2), Message::PRIO_ERROR);
+}
+
+
+inline void Logger::error(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3)
+{
+	log(Poco::format(fmt, value1, value2, value3), Message::PRIO_ERROR);
+}
+
+
+inline void Logger::error(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4), Message::PRIO_ERROR);
+}
+
+
+inline void Logger::error(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5), Message::PRIO_ERROR);
+}
+
+
+inline void Logger::error(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6), Message::PRIO_ERROR);
+}
+
+
+inline void Logger::error(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7), Message::PRIO_ERROR);
+}
+
+
+inline void Logger::error(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8), Message::PRIO_ERROR);
+}
+
+
+inline void Logger::error(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9), Message::PRIO_ERROR);
+}
+
+
+inline void Logger::error(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10), Message::PRIO_ERROR);
+}
+
+
+inline void Logger::warning(const std::string& msg)
+{
+	log(msg, Message::PRIO_WARNING);
+}
+
+
+inline void Logger::warning(const std::string& msg, const char* file, int line)
+{
+	log(msg, Message::PRIO_WARNING, file, line);
+}
+
+
+inline void Logger::warning(const std::string& fmt, const Any& value1)
+{
+	log(Poco::format(fmt, value1), Message::PRIO_WARNING);
+}
+
+
+inline void Logger::warning(const std::string& fmt, const Any& value1, const Any& value2)
+{
+	log(Poco::format(fmt, value1, value2), Message::PRIO_WARNING);
+}
+
+
+inline void Logger::warning(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3)
+{
+	log(Poco::format(fmt, value1, value2, value3), Message::PRIO_WARNING);
+}
+
+
+inline void Logger::warning(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4), Message::PRIO_WARNING);
+}
+
+
+inline void Logger::warning(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5), Message::PRIO_WARNING);
+}
+
+
+inline void Logger::warning(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6), Message::PRIO_WARNING);
+}
+
+
+inline void Logger::warning(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7), Message::PRIO_WARNING);
+}
+
+
+inline void Logger::warning(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8), Message::PRIO_WARNING);
+}
+
+
+inline void Logger::warning(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9), Message::PRIO_WARNING);
+}
+
+
+inline void Logger::warning(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10), Message::PRIO_WARNING);
+}
+
+
+inline void Logger::notice(const std::string& msg)
+{
+	log(msg, Message::PRIO_NOTICE);
+}
+
+
+inline void Logger::notice(const std::string& msg, const char* file, int line)
+{
+	log(msg, Message::PRIO_NOTICE, file, line);
+}
+
+
+inline void Logger::notice(const std::string& fmt, const Any& value1)
+{
+	log(Poco::format(fmt, value1), Message::PRIO_NOTICE);
+}
+
+
+inline void Logger::notice(const std::string& fmt, const Any& value1, const Any& value2)
+{
+	log(Poco::format(fmt, value1, value2), Message::PRIO_NOTICE);
+}
+
+
+inline void Logger::notice(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3)
+{
+	log(Poco::format(fmt, value1, value2, value3), Message::PRIO_NOTICE);
+}
+
+
+inline void Logger::notice(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4), Message::PRIO_NOTICE);
+}
+
+
+inline void Logger::notice(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5), Message::PRIO_NOTICE);
+}
+
+
+inline void Logger::notice(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6), Message::PRIO_NOTICE);
+}
+
+
+inline void Logger::notice(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7), Message::PRIO_NOTICE);
+}
+
+
+inline void Logger::notice(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8), Message::PRIO_NOTICE);
+}
+
+
+inline void Logger::notice(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9), Message::PRIO_NOTICE);
+}
+
+
+inline void Logger::notice(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10), Message::PRIO_NOTICE);
+}
+
+
+inline void Logger::information(const std::string& msg)
+{
+	log(msg, Message::PRIO_INFORMATION);
+}
+
+
+inline void Logger::information(const std::string& msg, const char* file, int line)
+{
+	log(msg, Message::PRIO_INFORMATION, file, line);
+}
+
+
+inline void Logger::information(const std::string& fmt, const Any& value1)
+{
+	log(Poco::format(fmt, value1), Message::PRIO_INFORMATION);
+}
+
+
+inline void Logger::information(const std::string& fmt, const Any& value1, const Any& value2)
+{
+	log(Poco::format(fmt, value1, value2), Message::PRIO_INFORMATION);
+}
+
+
+inline void Logger::information(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3)
+{
+	log(Poco::format(fmt, value1, value2, value3), Message::PRIO_INFORMATION);
+}
+
+
+inline void Logger::information(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4), Message::PRIO_INFORMATION);
+}
+
+
+inline void Logger::information(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5), Message::PRIO_INFORMATION);
+}
+
+
+inline void Logger::information(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6), Message::PRIO_INFORMATION);
+}
+
+
+inline void Logger::information(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7), Message::PRIO_INFORMATION);
+}
+
+
+inline void Logger::information(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8), Message::PRIO_INFORMATION);
+}
+
+
+inline void Logger::information(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9), Message::PRIO_INFORMATION);
+}
+
+
+inline void Logger::information(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10), Message::PRIO_INFORMATION);
+}
+
+
+inline void Logger::debug(const std::string& msg)
+{
+	log(msg, Message::PRIO_DEBUG);
+}
+
+
+inline void Logger::debug(const std::string& msg, const char* file, int line)
+{
+	log(msg, Message::PRIO_DEBUG, file, line);
+}
+
+
+inline void Logger::debug(const std::string& fmt, const Any& value1)
+{
+	log(Poco::format(fmt, value1), Message::PRIO_DEBUG);
+}
+
+
+inline void Logger::debug(const std::string& fmt, const Any& value1, const Any& value2)
+{
+	log(Poco::format(fmt, value1, value2), Message::PRIO_DEBUG);
+}
+
+
+inline void Logger::debug(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3)
+{
+	log(Poco::format(fmt, value1, value2, value3), Message::PRIO_DEBUG);
+}
+
+
+inline void Logger::debug(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4), Message::PRIO_DEBUG);
+}
+
+
+inline void Logger::debug(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5), Message::PRIO_DEBUG);
+}
+
+
+inline void Logger::debug(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6), Message::PRIO_DEBUG);
+}
+
+
+inline void Logger::debug(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7), Message::PRIO_DEBUG);
+}
+
+
+inline void Logger::debug(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8), Message::PRIO_DEBUG);
+}
+
+
+inline void Logger::debug(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9), Message::PRIO_DEBUG);
+}
+
+
+inline void Logger::debug(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10), Message::PRIO_DEBUG);
+}
+
+
+inline void Logger::trace(const std::string& msg)
+{
+	log(msg, Message::PRIO_TRACE);
+}
+
+
+inline void Logger::trace(const std::string& msg, const char* file, int line)
+{
+	log(msg, Message::PRIO_TRACE, file, line);
+}
+
+
+inline void Logger::trace(const std::string& fmt, const Any& value1)
+{
+	log(Poco::format(fmt, value1), Message::PRIO_TRACE);
+}
+
+
+inline void Logger::trace(const std::string& fmt, const Any& value1, const Any& value2)
+{
+	log(Poco::format(fmt, value1, value2), Message::PRIO_TRACE);
+}
+
+
+inline void Logger::trace(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3)
+{
+	log(Poco::format(fmt, value1, value2, value3), Message::PRIO_TRACE);
+}
+
+
+inline void Logger::trace(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4), Message::PRIO_TRACE);
+}
+
+
+inline void Logger::trace(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5), Message::PRIO_TRACE);
+}
+
+
+inline void Logger::trace(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6), Message::PRIO_TRACE);
+}
+
+
+inline void Logger::trace(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7), Message::PRIO_TRACE);
+}
+
+
+inline void Logger::trace(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8), Message::PRIO_TRACE);
+}
+
+
+inline void Logger::trace(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9), Message::PRIO_TRACE);
+}
+
+
+inline void Logger::trace(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10), Message::PRIO_TRACE);
+}
+
+inline void Logger::test(const std::string& msg)
+{
+	log(msg, Message::PRIO_TEST);
+}
+
+
+inline void Logger::test(const std::string& msg, const char* file, int line)
+{
+	log(msg, Message::PRIO_TEST, file, line);
+}
+
+
+inline void Logger::test(const std::string& fmt, const Any& value1)
+{
+	log(Poco::format(fmt, value1), Message::PRIO_TEST);
+}
+
+
+inline void Logger::test(const std::string& fmt, const Any& value1, const Any& value2)
+{
+	log(Poco::format(fmt, value1, value2), Message::PRIO_TEST);
+}
+
+
+inline void Logger::test(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3)
+{
+	log(Poco::format(fmt, value1, value2, value3), Message::PRIO_TEST);
+}
+
+
+inline void Logger::test(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4), Message::PRIO_TEST);
+}
+
+
+inline void Logger::test(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5), Message::PRIO_TEST);
+}
+
+
+inline void Logger::test(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6), Message::PRIO_TEST);
+}
+
+
+inline void Logger::test(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7), Message::PRIO_TEST);
+}
+
+
+inline void Logger::test(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8), Message::PRIO_TEST);
+}
+
+
+inline void Logger::test(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9), Message::PRIO_TEST);
+}
+
+
+inline void Logger::test(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10)
+{
+	log(Poco::format(fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10), Message::PRIO_TEST);
+}
+
+
+inline bool Logger::is(int level) const
+{
+	return _level >= level;
+}
+
+
+inline bool Logger::fatal() const
+{
+	return _level >= Message::PRIO_FATAL;
+}
+
+
+inline bool Logger::critical() const
+{
+	return _level >= Message::PRIO_CRITICAL;
+}
+
+
+inline bool Logger::error() const
+{
+	return _level >= Message::PRIO_ERROR;
+}
+
+
+inline bool Logger::warning() const
+{
+	return _level >= Message::PRIO_WARNING;
+}
+
+
+inline bool Logger::notice() const
+{
+	return _level >= Message::PRIO_NOTICE;
+}
+
+
+inline bool Logger::information() const
+{
+	return _level >= Message::PRIO_INFORMATION;
+}
+
+
+inline bool Logger::debug() const
+{
+	return _level >= Message::PRIO_DEBUG;
+}
+
+
+inline bool Logger::trace() const
+{
+	return _level >= Message::PRIO_TRACE;
+}
+
+inline bool Logger::test() const
+{
+	return _level >= Message::PRIO_TEST;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Logger_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/LoggingFactory.h b/base/poco/Foundation/include/Poco/LoggingFactory.h
new file mode 100644
index 00000000000..c851c3f907c
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/LoggingFactory.h
@@ -0,0 +1,92 @@
+//
+// LoggingFactory.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  LoggingFactory
+//
+// Definition of the LoggingFactory class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_LoggingFactory_INCLUDED
+#define Foundation_LoggingFactory_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/DynamicFactory.h"
+#include "Poco/Channel.h"
+#include "Poco/Formatter.h"
+
+
+namespace Poco {
+
+
+class Foundation_API LoggingFactory
+	/// An extensible factory for channels and formatters.
+	///
+	/// The following channel classes are pre-registered:
+	///   - AsyncChannel
+	///   - ConsoleChannel
+	///   - EventLogChannel (Windows platforms only)
+	///   - FileChannel
+	///   - FormattingChannel
+	///   - NullChannel
+	///   - SplitterChannel
+	///   - SyslogChannel (Unix platforms only)
+	///
+	/// The following formatter classes are pre-registered:
+	///   - PatternFormatter
+{
+public:
+	typedef AbstractInstantiator<Channel>   ChannelInstantiator;
+	typedef AbstractInstantiator<Formatter> FormatterFactory;
+
+	LoggingFactory();
+		/// Creates the LoggingFactory.
+		///
+		/// Automatically registers class factories for the
+		/// built-in channel and formatter classes.
+
+	~LoggingFactory();
+		/// Destroys the LoggingFactory.
+
+	void registerChannelClass(const std::string& className, ChannelInstantiator* pFactory);
+		/// Registers a channel class with the LoggingFactory.
+
+	void registerFormatterClass(const std::string& className, FormatterFactory* pFactory);
+		/// Registers a formatter class with the LoggingFactory.
+
+	Channel* createChannel(const std::string& className) const;
+		/// Creates a new Channel instance from specified class.
+		///
+		/// Throws a NotFoundException if the specified channel class
+		/// has not been registered.
+
+	Formatter* createFormatter(const std::string& className) const;
+		/// Creates a new Formatter instance from specified class.
+		///
+		/// Throws a NotFoundException if the specified formatter class
+		/// has not been registered.
+
+	static LoggingFactory& defaultFactory();
+		/// Returns a reference to the default
+		/// LoggingFactory.
+
+private:
+	void registerBuiltins();
+
+	DynamicFactory<Channel>   _channelFactory;
+	DynamicFactory<Formatter> _formatterFactory;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_LoggingFactory_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/LoggingRegistry.h b/base/poco/Foundation/include/Poco/LoggingRegistry.h
new file mode 100644
index 00000000000..82bb2c85881
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/LoggingRegistry.h
@@ -0,0 +1,99 @@
+//
+// LoggingRegistry.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  LoggingRegistry
+//
+// Definition of the LoggingRegistry class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_LoggingRegistry_INCLUDED
+#define Foundation_LoggingRegistry_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/AutoPtr.h"
+#include "Poco/Channel.h"
+#include "Poco/Formatter.h"
+#include "Poco/Mutex.h"
+#include <map>
+
+
+namespace Poco {
+
+
+class Foundation_API LoggingRegistry
+	/// A registry for channels and formatters.
+	///
+	/// The LoggingRegistry class is used for configuring
+	/// the logging framework.
+{
+public:
+	LoggingRegistry();
+		/// Creates the LoggingRegistry.
+
+	~LoggingRegistry();
+		/// Destroys the LoggingRegistry.
+
+	Channel* channelForName(const std::string& name) const;
+		/// Returns the Channel object which has been registered
+		/// under the given name.
+		///
+		/// Throws a NotFoundException if the name is unknown.
+
+	Formatter* formatterForName(const std::string& name) const;
+		/// Returns the Formatter object which has been registered
+		/// under the given name.
+		///
+		/// Throws a NotFoundException if the name is unknown.
+
+	void registerChannel(const std::string& name, Channel* pChannel);
+		/// Registers a channel under a given name.
+		/// It is okay to re-register a different channel under an
+		/// already existing name.
+		
+	void registerFormatter(const std::string& name, Formatter* pFormatter);
+		/// Registers a formatter under a given name.
+		/// It is okay to re-register a different formatter under an
+		/// already existing name.
+
+	void unregisterChannel(const std::string& name);
+		/// Unregisters the given channel.
+		///
+		/// Throws a NotFoundException if the name is unknown.
+
+	void unregisterFormatter(const std::string& name);
+		/// Unregisters the given formatter.
+		///
+		/// Throws a NotFoundException if the name is unknown.
+
+	void clear();
+		/// Unregisters all registered channels and formatters.
+
+	static LoggingRegistry& defaultRegistry();
+		/// Returns a reference to the default
+		/// LoggingRegistry.
+
+private:
+	typedef AutoPtr<Channel>   ChannelPtr;
+	typedef AutoPtr<Formatter> FormatterPtr;
+	typedef std::map<std::string, ChannelPtr> ChannelMap;
+	typedef std::map<std::string, FormatterPtr> FormatterMap;
+	
+	ChannelMap   _channelMap;
+	FormatterMap _formatterMap;
+	mutable FastMutex _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_LoggingRegistry_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/MD4Engine.h b/base/poco/Foundation/include/Poco/MD4Engine.h
new file mode 100644
index 00000000000..644575e06c9
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/MD4Engine.h
@@ -0,0 +1,95 @@
+//
+// MD4Engine.h
+//
+// Library: Foundation
+// Package: Crypt
+// Module:  MD4Engine
+//
+// Definition of class MD4Engine.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+//
+// MD4 (RFC 1320) algorithm:
+// Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+// rights reserved.
+//
+// License to copy and use this software is granted provided that it
+// is identified as the "RSA Data Security, Inc. MD4 Message-Digest
+// Algorithm" in all material mentioning or referencing this software
+// or this function.
+//
+// License is also granted to make and use derivative works provided
+// that such works are identified as "derived from the RSA Data
+// Security, Inc. MD4 Message-Digest Algorithm" in all material
+// mentioning or referencing the derived work.
+//
+// RSA Data Security, Inc. makes no representations concerning either
+// the merchantability of this software or the suitability of this
+// software for any particular purpose. It is provided "as is"
+// without express or implied warranty of any kind.
+//
+// These notices must be retained in any copies of any part of this
+// documentation and/or software.
+//
+
+
+#ifndef Foundation_MD4Engine_INCLUDED
+#define Foundation_MD4Engine_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/DigestEngine.h"
+
+
+namespace Poco {
+
+
+class Foundation_API MD4Engine: public DigestEngine
+	/// This class implementes the MD4 message digest algorithm,
+	/// described in RFC 1320.
+{
+public:
+	enum
+	{
+		BLOCK_SIZE  = 64,
+		DIGEST_SIZE = 16
+	};
+
+	MD4Engine();
+	~MD4Engine();
+		
+	std::size_t digestLength() const;
+	void reset();
+	const DigestEngine::Digest& digest();
+
+protected:
+	void updateImpl(const void* data, std::size_t length);
+
+private:
+	static void transform(UInt32 state[4], const unsigned char block[64]);
+	static void encode(unsigned char* output, const UInt32* input, std::size_t len);
+	static void decode(UInt32* output, const unsigned char* input, std::size_t len);
+
+	struct Context
+	{
+		UInt32 state[4];          // state (ABCD)
+		UInt32 count[2];          // number of bits, modulo 2^64 (lsb first)
+		unsigned char buffer[64]; // input buffer
+	};
+
+	Context _context;
+	DigestEngine::Digest _digest;
+
+	MD4Engine(const MD4Engine&);
+	MD4Engine& operator = (const MD4Engine&);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_MD5Engine_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/MD5Engine.h b/base/poco/Foundation/include/Poco/MD5Engine.h
new file mode 100644
index 00000000000..7835ff61298
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/MD5Engine.h
@@ -0,0 +1,95 @@
+//
+// MD5Engine.h
+//
+// Library: Foundation
+// Package: Crypt
+// Module:  MD5Engine
+//
+// Definition of class MD5Engine.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+//
+// MD5 (RFC 1321) algorithm:
+// Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+// rights reserved.
+// 
+// License to copy and use this software is granted provided that it
+// is identified as the "RSA Data Security, Inc. MD5 Message-Digest
+// Algorithm" in all material mentioning or referencing this software
+// or this function.
+//
+// License is also granted to make and use derivative works provided
+// that such works are identified as "derived from the RSA Data
+// Security, Inc. MD5 Message-Digest Algorithm" in all material
+// mentioning or referencing the derived work.
+//
+// RSA Data Security, Inc. makes no representations concerning either
+// the merchantability of this software or the suitability of this
+// software for any particular purpose. It is provided "as is"
+// without express or implied warranty of any kind.
+//
+// These notices must be retained in any copies of any part of this
+// documentation and/or software.
+//
+
+
+#ifndef Foundation_MD5Engine_INCLUDED
+#define Foundation_MD5Engine_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/DigestEngine.h"
+
+
+namespace Poco {
+
+
+class Foundation_API MD5Engine: public DigestEngine
+	/// This class implementes the MD5 message digest algorithm,
+	/// described in RFC 1321.
+{
+public:
+	enum
+	{
+		BLOCK_SIZE  = 64,
+		DIGEST_SIZE = 16
+	};
+
+	MD5Engine();
+	~MD5Engine();
+		
+	std::size_t digestLength() const;
+	void reset();
+	const DigestEngine::Digest& digest();
+
+protected:
+	void updateImpl(const void* data, std::size_t length);
+
+private:
+	static void transform(UInt32 state[4], const unsigned char block[64]);
+	static void encode(unsigned char* output, const UInt32* input, std::size_t len);
+	static void decode(UInt32* output, const unsigned char* input, std::size_t len);
+
+	struct Context
+	{
+		UInt32 state[4];          // state (ABCD)
+		UInt32 count[2];          // number of bits, modulo 2^64 (lsb first)
+		unsigned char buffer[64]; // input buffer
+	};
+
+	Context _context;
+	DigestEngine::Digest _digest;
+
+	MD5Engine(const MD5Engine&);
+	MD5Engine& operator = (const MD5Engine&);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_MD5Engine_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Manifest.h b/base/poco/Foundation/include/Poco/Manifest.h
new file mode 100644
index 00000000000..f2d36e76e85
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Manifest.h
@@ -0,0 +1,180 @@
+//
+// Manifest.h
+//
+// Library: Foundation
+// Package: SharedLibrary
+// Module:  ClassLoader
+//
+// Definition of the Manifest class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Manifest_INCLUDED
+#define Foundation_Manifest_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/MetaObject.h"
+#include <map>
+#include <typeinfo>
+
+
+namespace Poco {
+
+
+class Foundation_API ManifestBase
+	/// ManifestBase is a common base class for
+	/// all instantiations of Manifest.
+{
+public:
+	ManifestBase();
+	virtual ~ManifestBase();
+
+	virtual const char* className() const = 0;
+		/// Returns the type name of the manifest's class.
+};
+
+
+template <class B>
+class Manifest: public ManifestBase
+	/// A Manifest maintains a list of all classes
+	/// contained in a dynamically loadable class
+	/// library.
+	/// Internally, the information is held
+	/// in a map. An iterator is provided to
+	/// iterate over all the classes in a Manifest.
+{
+public:
+	typedef AbstractMetaObject<B> Meta;
+	typedef std::map<std::string, const Meta*> MetaMap;
+
+	class Iterator
+		/// The Manifest's very own iterator class.
+	{
+	public:
+		Iterator(const typename MetaMap::const_iterator& it)
+		{
+			_it = it;
+		}
+		Iterator(const Iterator& it)
+		{
+			_it = it._it;
+		}
+		~Iterator()
+		{
+		}
+		Iterator& operator = (const Iterator& it)
+		{
+			_it = it._it;
+			return *this;
+		}
+		inline bool operator == (const Iterator& it) const
+		{
+			return _it == it._it;
+		}
+		inline bool operator != (const Iterator& it) const
+		{
+			return _it != it._it;
+		}
+		Iterator& operator ++ () // prefix
+		{
+			++_it;
+			return *this;
+		}
+		Iterator operator ++ (int) // postfix
+		{
+			Iterator result(_it);
+			++_it;
+			return result;
+		}
+		inline const Meta* operator * () const
+		{
+			return _it->second;
+		}
+		inline const Meta* operator -> () const
+		{
+			return _it->second;
+		}
+		
+	private:
+		typename MetaMap::const_iterator _it;
+	};
+
+	Manifest()
+		/// Creates an empty Manifest.
+	{
+	}
+
+	virtual ~Manifest()
+		/// Destroys the Manifest.
+	{
+		clear();
+	}
+
+	Iterator find(const std::string& className) const
+		/// Returns an iterator pointing to the MetaObject
+		/// for the given class. If the MetaObject cannot
+		/// be found, the iterator points to end().
+	{
+		return Iterator(_metaMap.find(className));
+	}
+
+	Iterator begin() const
+	{
+		return Iterator(_metaMap.begin());
+	}
+
+	Iterator end() const
+	{
+		return Iterator(_metaMap.end());
+	}
+
+	bool insert(const Meta* pMeta)
+		/// Inserts a MetaObject. Returns true if insertion
+		/// was successful, false if a class with the same
+		/// name already exists.
+	{
+		return _metaMap.insert(typename MetaMap::value_type(pMeta->name(), pMeta)).second;
+	}
+
+	void clear()
+		/// Removes all MetaObjects from the manifest.
+	{
+		for (typename MetaMap::iterator it = _metaMap.begin(); it != _metaMap.end(); ++it)
+		{
+			delete it->second;
+		}
+		_metaMap.clear();
+	}
+
+	int size() const
+		/// Returns the number of MetaObjects in the Manifest.
+	{
+		return int(_metaMap.size());
+	}
+
+	bool empty() const
+		/// Returns true iff the Manifest does not contain any MetaObjects.
+	{
+		return _metaMap.empty();
+	}
+
+	const char* className() const
+	{
+		return typeid(*this).name();
+	}
+
+private:
+	MetaMap _metaMap;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Manifest_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/MemoryPool.h b/base/poco/Foundation/include/Poco/MemoryPool.h
new file mode 100644
index 00000000000..55f238d991b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/MemoryPool.h
@@ -0,0 +1,115 @@
+//
+// MemoryPool.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  MemoryPool
+//
+// Definition of the MemoryPool class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_MemoryPool_INCLUDED
+#define Foundation_MemoryPool_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Mutex.h"
+#include <vector>
+#include <cstddef>
+
+
+namespace Poco {
+
+
+class Foundation_API MemoryPool
+	/// A simple pool for fixed-size memory blocks.
+	///
+	/// The main purpose of this class is to speed-up
+	/// memory allocations, as well as to reduce memory
+	/// fragmentation in situations where the same blocks
+	/// are allocated all over again, such as in server
+	/// applications.
+	///
+	/// All allocated blocks are retained for future use.
+	/// A limit on the number of blocks can be specified.
+	/// Blocks can be preallocated.
+{
+public:
+	MemoryPool(std::size_t blockSize, int preAlloc = 0, int maxAlloc = 0);
+		/// Creates a MemoryPool for blocks with the given blockSize.
+		/// The number of blocks given in preAlloc are preallocated.
+		
+	~MemoryPool();
+
+	void* get();
+		/// Returns a memory block. If there are no more blocks
+		/// in the pool, a new block will be allocated.
+		///
+		/// If maxAlloc blocks are already allocated, an
+		/// OutOfMemoryException is thrown.
+		
+	void release(void* ptr);
+		/// Releases a memory block and returns it to the pool.
+	
+	std::size_t blockSize() const;
+		/// Returns the block size.
+		
+	int allocated() const;
+		/// Returns the number of allocated blocks.
+		
+	int available() const;
+		/// Returns the number of available blocks in the pool.
+
+private:
+	MemoryPool();
+	MemoryPool(const MemoryPool&);
+	MemoryPool& operator = (const MemoryPool&);
+	
+	void clear();
+	
+	enum
+	{
+		BLOCK_RESERVE = 128
+	};
+	
+	typedef std::vector<char*> BlockVec;
+	
+	std::size_t _blockSize;
+	int         _maxAlloc;
+	int         _allocated;
+	BlockVec    _blocks;
+	FastMutex   _mutex;
+};
+
+
+//
+// inlines
+//
+inline std::size_t MemoryPool::blockSize() const
+{
+	return _blockSize;
+}
+
+
+inline int MemoryPool::allocated() const
+{
+	return _allocated;
+}
+
+
+inline int MemoryPool::available() const
+{
+	return (int) _blocks.size();
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_MemoryPool_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/MemoryStream.h b/base/poco/Foundation/include/Poco/MemoryStream.h
new file mode 100644
index 00000000000..819f1609420
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/MemoryStream.h
@@ -0,0 +1,246 @@
+//
+// MemoryStream.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  MemoryStream
+//
+// Definition of MemoryStreamBuf, MemoryInputStream, MemoryOutputStream
+//
+// Copyright (c) 2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_MemoryStream_INCLUDED
+#define Foundation_MemoryStream_INCLUDED
+
+
+#include "Poco/Bugcheck.h"
+#include "Poco/Foundation.h"
+#include "Poco/StreamUtil.h"
+#include <streambuf>
+#include <iosfwd>
+#include <ios>
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+
+
+template <typename ch, typename tr> 
+class BasicMemoryStreamBuf: public std::basic_streambuf<ch, tr>
+	/// BasicMemoryStreamBuf is a simple implementation of a 
+	/// stream buffer for reading and writing from a memory area.
+	///
+	/// This streambuf only supports unidirectional streams.
+	/// In other words, the BasicMemoryStreamBuf can be
+	/// used for the implementation of an istream or an
+	/// ostream, but not for an iostream.
+{
+protected:
+	typedef std::basic_streambuf<ch, tr> Base;
+	typedef std::basic_ios<ch, tr> IOS;
+	typedef ch char_type;
+	typedef tr char_traits;
+	typedef typename Base::int_type int_type;
+	typedef typename Base::pos_type pos_type;
+	typedef typename Base::off_type off_type;
+
+public:
+	BasicMemoryStreamBuf(char_type* pBuffer, std::streamsize bufferSize):
+		_pBuffer(pBuffer),
+		_bufferSize(bufferSize)
+	{
+		this->setg(_pBuffer, _pBuffer, _pBuffer + _bufferSize);
+		this->setp(_pBuffer, _pBuffer + _bufferSize);
+	}
+
+	~BasicMemoryStreamBuf()
+	{
+	}
+
+	virtual int_type overflow(int_type /*c*/)
+	{
+		return char_traits::eof();
+	}
+
+	virtual int_type underflow()
+	{
+		return char_traits::eof();
+	}
+
+	virtual pos_type seekoff(off_type off, std::ios_base::seekdir way, std::ios_base::openmode which = std::ios_base::in | std::ios_base::out)
+	{
+		const pos_type fail = off_type(-1);
+		off_type newoff = off_type(-1);
+
+		if ((which & std::ios_base::in) != 0)
+		{
+			if (this->gptr() == 0)
+				return fail;
+
+			if (way == std::ios_base::beg)
+			{
+				newoff = 0;
+			}
+			else if (way == std::ios_base::cur)
+			{
+				// cur is not valid if both in and out are specified (Condition 3)
+				if ((which & std::ios_base::out) != 0)
+					return fail;
+				newoff = this->gptr() - this->eback();
+			}
+			else if (way == std::ios_base::end)
+			{
+				newoff = this->egptr() - this->eback();
+			}
+			else
+			{
+				poco_bugcheck();
+			}
+
+			if ((newoff + off) < 0 || (this->egptr() - this->eback()) < (newoff + off))
+				return fail;
+			this->setg(this->eback(), this->eback() + newoff + off, this->egptr());
+		}
+
+		if ((which & std::ios_base::out) != 0)
+		{
+			if (this->pptr() == 0)
+				return fail;
+
+			if (way == std::ios_base::beg)
+			{
+				newoff = 0;
+			}
+			else if (way == std::ios_base::cur)
+			{
+				// cur is not valid if both in and out are specified (Condition 3)
+				if ((which & std::ios_base::in) != 0)
+					return fail;
+				newoff = this->pptr() - this->pbase();
+			}
+			else if (way == std::ios_base::end)
+			{
+				newoff = this->epptr() - this->pbase();
+			}
+			else
+			{
+				poco_bugcheck();
+			}
+
+			if (newoff + off < 0 || (this->epptr() - this->pbase()) < newoff + off)
+				return fail;
+			this->pbump((int)(newoff + off - (this->pptr() - this->pbase())));
+		}
+
+		return newoff;
+	}
+
+	virtual int sync()
+	{
+		return 0;
+	}
+	
+	std::streamsize charsWritten() const
+	{
+		return static_cast<std::streamsize>(this->pptr() - this->pbase());
+	}
+
+	void reset()
+		/// Resets the buffer so that current read and write positions
+		/// will be set to the beginning of the buffer.
+	{
+		this->setg(_pBuffer, _pBuffer, _pBuffer + _bufferSize);
+		this->setp(_pBuffer, _pBuffer + _bufferSize);
+	}
+		
+private:
+	char_type*      _pBuffer;
+	std::streamsize _bufferSize;
+
+	BasicMemoryStreamBuf();
+	BasicMemoryStreamBuf(const BasicMemoryStreamBuf&);
+	BasicMemoryStreamBuf& operator = (const BasicMemoryStreamBuf&);
+};
+
+
+//
+// We provide an instantiation for char
+//
+typedef BasicMemoryStreamBuf<char, std::char_traits<char> > MemoryStreamBuf;
+
+
+class Foundation_API MemoryIOS: public virtual std::ios
+	/// The base class for MemoryInputStream and MemoryOutputStream.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	MemoryIOS(char* pBuffer, std::streamsize bufferSize);
+		/// Creates the basic stream.
+		
+	~MemoryIOS();
+		/// Destroys the stream.
+
+	MemoryStreamBuf* rdbuf();
+		/// Returns a pointer to the underlying streambuf.
+		
+protected:
+	MemoryStreamBuf _buf;
+};
+
+
+class Foundation_API MemoryInputStream: public MemoryIOS, public std::istream
+	/// An input stream for reading from a memory area.
+{
+public:
+	MemoryInputStream(const char* pBuffer, std::streamsize bufferSize);
+		/// Creates a MemoryInputStream for the given memory area,
+		/// ready for reading.
+	
+	~MemoryInputStream();
+		/// Destroys the MemoryInputStream.
+};
+
+
+class Foundation_API MemoryOutputStream: public MemoryIOS, public std::ostream
+	/// An input stream for reading from a memory area.
+{
+public:
+	MemoryOutputStream(char* pBuffer, std::streamsize bufferSize);
+		/// Creates a MemoryOutputStream for the given memory area,
+		/// ready for writing.
+	
+	~MemoryOutputStream();
+		/// Destroys the MemoryInputStream.
+
+	std::streamsize charsWritten() const;
+		/// Returns the number of chars written to the buffer.
+};
+
+
+//
+// inlines
+//
+inline MemoryStreamBuf* MemoryIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+inline std::streamsize MemoryOutputStream::charsWritten() const
+{
+	return _buf.charsWritten();
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_MemoryStream_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Message.h b/base/poco/Foundation/include/Poco/Message.h
new file mode 100644
index 00000000000..97600ae6393
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Message.h
@@ -0,0 +1,270 @@
+//
+// Message.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  Message
+//
+// Definition of the Message class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Message_INCLUDED
+#define Foundation_Message_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Timestamp.h"
+#include <map>
+
+
+namespace Poco {
+
+
+class Foundation_API Message
+	/// This class represents a log message that is sent through a
+	/// chain of log channels.
+	///
+	/// A Message contains a priority denoting the severity of the
+	/// message, a source describing its origin, a text describing
+	/// its meaning, the time of its creation, and an identifier of
+	/// the process and thread that created the message.
+	///
+	/// Optionally a Message can also contain the source file path
+	/// and line number of the statement generating the message.
+	///
+	/// A Message can also contain any number of named parameters
+	/// that contain additional information about the event that
+	/// caused the message.
+{
+public:
+	enum Priority
+	{
+		PRIO_FATAL = 1,   /// A fatal error. The application will most likely terminate. This is the highest priority.
+		PRIO_CRITICAL,    /// A critical error. The application might not be able to continue running successfully.
+		PRIO_ERROR,       /// An error. An operation did not complete successfully, but the application as a whole is not affected.
+		PRIO_WARNING,     /// A warning. An operation completed with an unexpected result.
+		PRIO_NOTICE,      /// A notice, which is an information with just a higher priority.
+		PRIO_INFORMATION, /// An informational message, usually denoting the successful completion of an operation.
+		PRIO_DEBUG,       /// A debugging message.
+		PRIO_TRACE,       /// A tracing message. This is the lowest priority useful for production.
+		PRIO_TEST         /// A message for test environment.
+	};
+	
+	Message();
+		/// Creates an empty Message.
+		/// The thread and process ids are set.
+		
+	Message(const std::string& source, const std::string& text, Priority prio);
+		/// Creates a Message with the given source, text and priority.
+		/// The thread and process ids are set.
+
+	Message(const std::string& source, const std::string& text, Priority prio, const char* file, int line, std::string_view fmt_str = {});
+		/// Creates a Message with the given source, text, priority,
+		/// source file path and line. 
+		///
+		/// The source file path must be a 
+		/// static string with a lifetime that's at least the lifetime
+		/// of the message object (the string is not copied internally).
+		/// Usually, this will be the path string obtained from the 
+		/// __FILE__ macro.
+		///
+		/// The thread and process ids are set.
+		
+	Message(const Message& msg);
+		/// Creates a Message by copying another one.
+		
+	Message(const Message& msg, const std::string& text);
+		/// Creates a Message by copying all but the text from another message.
+		
+	~Message();
+		/// Destroys the Message.
+	
+	Message& operator = (const Message& msg);
+		/// Assignment operator.
+		
+	void swap(Message& msg);
+		/// Swaps the message with another one.	
+		
+	void setSource(const std::string& src);
+		/// Sets the source of the message.
+		
+	const std::string& getSource() const;
+		/// Returns the source of the message.
+		
+	void setText(const std::string& text);
+		/// Sets the text of the message.
+		
+	const std::string& getText() const;
+		/// Returns the text of the message.
+		
+	void setPriority(Priority prio);
+		/// Sets the priority of the message.
+		
+	Priority getPriority() const;
+		/// Returns the priority of the message.
+	
+	void setTime(const Timestamp& time);
+		/// Sets the time of the message.
+		
+	const Timestamp& getTime() const;
+		/// Returns the time of the message.
+		
+	void setThread(const std::string& thread);
+		/// Sets the thread identifier for the message.
+		
+	const std::string& getThread() const;
+		/// Returns the thread identifier for the message.
+
+	void setTid(long pid);
+		/// Sets the numeric thread identifier for the message.
+		
+	long getTid() const;
+		/// Returns the numeric thread identifier for the message.
+	
+	void setPid(long pid);
+		/// Sets the process identifier for the message.
+		
+	long getPid() const;
+		/// Returns the process identifier for the message.
+		
+	void setSourceFile(const char* file);
+		/// Sets the source file path of the statement
+		/// generating the log message.
+		///
+		/// File must be a static string, such as the value of
+		/// the __FILE__ macro. The string is not copied
+		/// internally for performance reasons.	
+		
+	const char* getSourceFile() const;
+		/// Returns the source file path of the code creating
+		/// the message. May be 0 if not set.
+		
+	void setSourceLine(int line);
+		/// Sets the source file line of the statement
+		/// generating the log message.
+		///
+		/// This is usually the result of the __LINE__
+		/// macro.
+
+    std::string_view getFormatString() const;
+    void setFormatString(std::string_view fmt_str);
+		
+	int getSourceLine() const;
+		/// Returns the source file line of the statement
+		/// generating the log message. May be 0
+		/// if not set.
+
+	bool has(const std::string& param) const;
+		/// Returns true if a parameter with the given name exists.
+
+	const std::string& get(const std::string& param) const;
+		/// Returns a const reference to the value of the parameter
+		/// with the given name. Throws a NotFoundException if the
+		/// parameter does not exist.
+
+	const std::string& get(const std::string& param, const std::string& defaultValue) const;
+		/// Returns a const reference to the value of the parameter
+		/// with the given name. If the parameter with the given name
+		/// does not exist, then defaultValue is returned.
+
+	void set(const std::string& param, const std::string& value);
+		/// Sets the value for a parameter. If the parameter does
+		/// not exist, then it is created.
+
+	const std::string& operator [] (const std::string& param) const;
+		/// Returns a const reference to the value of the parameter
+		/// with the given name. Throws a NotFoundException if the
+		/// parameter does not exist.
+		
+	std::string& operator [] (const std::string& param);
+		/// Returns a reference to the value of the parameter with the
+		/// given name. This can be used to set the parameter's value.
+		/// If the parameter does not exist, it is created with an
+		/// empty string value.
+
+protected:
+	void init();
+	typedef std::map<std::string, std::string> StringMap;
+
+private:	
+	std::string _source;
+	std::string _text;
+	Priority    _prio;
+	Timestamp   _time;
+	long        _tid;
+	std::string _thread;
+	mutable long _pid = -1;
+	const char* _file;
+	int         _line;
+	StringMap*  _pMap;
+    std::string_view _fmt_str;
+};
+
+
+//
+// inlines
+//
+inline const std::string& Message::getSource() const
+{
+	return _source;
+}
+
+
+inline const std::string& Message::getText() const
+{
+	return _text;
+}
+
+
+inline Message::Priority Message::getPriority() const
+{
+	return _prio;
+}
+
+
+inline const Timestamp& Message::getTime() const
+{
+	return _time;
+}
+
+
+inline const std::string& Message::getThread() const
+{
+	return _thread;
+}
+
+
+inline long Message::getTid() const
+{
+	return _tid;
+}
+
+
+inline const char* Message::getSourceFile() const
+{
+	return _file;
+}
+
+
+inline int Message::getSourceLine() const
+{
+	return _line;
+}
+
+
+inline void swap(Message& m1, Message& m2)
+{
+	m1.swap(m2);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Message_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/MetaObject.h b/base/poco/Foundation/include/Poco/MetaObject.h
new file mode 100644
index 00000000000..b3b0d242e80
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/MetaObject.h
@@ -0,0 +1,201 @@
+//
+// MetaObject.h
+//
+// Library: Foundation
+// Package: SharedLibrary
+// Module:  ClassLoader
+//
+// Definition of the MetaObject class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_MetaObject_INCLUDED
+#define Foundation_MetaObject_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include "Poco/SingletonHolder.h"
+#include <set>
+
+
+namespace Poco {
+
+
+template <class B>
+class AbstractMetaObject
+	/// A MetaObject stores some information
+	/// about a C++ class. The MetaObject class
+	/// is used by the Manifest class.
+	/// AbstractMetaObject is a common base class
+	/// for all MetaObject in a rooted class hierarchy.
+	/// A MetaObject can also be used as an object
+	/// factory for its class.
+{
+public:
+	AbstractMetaObject(const char* name): _name(name)
+	{
+	}
+
+	virtual ~AbstractMetaObject()
+	{
+		for (typename ObjectSet::iterator it = _deleteSet.begin(); it != _deleteSet.end(); ++it)
+		{
+			delete *it;
+		}
+	}
+
+	const char* name() const
+	{
+		return _name;
+	}
+
+	virtual B* create() const = 0;
+		/// Create a new instance of a class.
+		/// Cannot be used for singletons.
+		
+	virtual B& instance() const = 0;
+		/// Returns a reference to the only instance
+		/// of the class. Used for singletons only.
+
+	virtual bool canCreate() const = 0;
+		/// Returns true iff the create method can be used
+		/// to create instances of the class.
+		/// Returns false if the class is a singleton.
+
+	virtual void destroy(B* pObject) const
+		/// If pObject was owned by meta object, the
+		/// ownership of the deleted object is removed
+		/// and the object is deleted.
+	{
+		typename ObjectSet::iterator it = _deleteSet.find(pObject);
+		
+		if (it != _deleteSet.end())
+		{
+			_deleteSet.erase(pObject);
+			delete pObject;
+		}
+	}
+
+	B* autoDelete(B* pObject) const
+		/// Give ownership of pObject to the meta object.
+		/// The meta object will delete all objects it owns
+		/// when it is destroyed.
+		///
+		/// Returns pObject.
+	{
+		if (this->canCreate()) // guard against singleton
+		{
+			poco_check_ptr (pObject);
+			_deleteSet.insert(pObject);
+		}
+		else throw InvalidAccessException("Cannot take ownership of", this->name());
+
+		return pObject;
+	}
+
+	virtual bool isAutoDelete(B* pObject) const
+		/// Returns true if the object is owned
+		/// by meta object.
+		///
+		/// Overloaded in MetaSingleton - returns true
+		/// if the class is a singleton.
+	{
+		return _deleteSet.find(pObject) != _deleteSet.end();
+	}
+
+private:
+	AbstractMetaObject();
+	AbstractMetaObject(const AbstractMetaObject&);
+	AbstractMetaObject& operator = (const AbstractMetaObject&);
+
+	typedef std::set<B*> ObjectSet;
+	
+	const char* _name;
+	mutable ObjectSet _deleteSet;
+};
+
+
+template <class C, class B>
+class MetaObject: public AbstractMetaObject<B>
+	/// A MetaObject stores some information
+	/// about a C++ class. The MetaObject class
+	/// is used by the Manifest class.
+	/// A MetaObject can also be used as an object
+	/// factory for its class.
+{
+public:
+	MetaObject(const char* name): AbstractMetaObject<B>(name)
+	{
+	}
+
+	~MetaObject()
+	{
+	}
+
+	B* create() const
+	{
+		return new C;
+	}
+	
+	B& instance() const
+	{
+		throw InvalidAccessException("Not a singleton. Use create() to create instances of", this->name());
+	}
+	
+	bool canCreate() const
+	{
+		return true;
+	}
+};
+
+
+template <class C, class B> 
+class MetaSingleton: public AbstractMetaObject<B> 
+	/// A SingletonMetaObject disables the create() method
+	/// and instead offers an instance() method to access
+	/// the single instance of its class. 
+{ 
+public: 
+	MetaSingleton(const char* name): AbstractMetaObject<B>(name) 
+	{
+	}
+	
+	~MetaSingleton() 
+	{
+	}
+	
+	B* create() const
+	{
+		throw InvalidAccessException("Cannot create instances of a singleton class. Use instance() to obtain a", this->name());
+	}
+	
+	bool canCreate() const
+	{
+		return false;
+	}
+
+	B& instance() const
+	{
+		return *_object.get();
+	}
+
+	bool isAutoDelete(B* /*pObject*/) const
+	{
+		return true;
+	}
+
+private: 
+	mutable SingletonHolder<C> _object; 
+}; 
+
+
+} // namespace Poco
+
+
+#endif // Foundation_MetaObject_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/MetaProgramming.h b/base/poco/Foundation/include/Poco/MetaProgramming.h
new file mode 100644
index 00000000000..ba68fe054cb
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/MetaProgramming.h
@@ -0,0 +1,144 @@
+//
+// MetaProgramming.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  MetaProgramming
+//
+// Common definitions useful for Meta Template Programming
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_MetaProgramming_INCLUDED
+#define Foundation_MetaProgramming_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+template <typename T>
+struct IsReference
+	/// Use this struct to determine if a template type is a reference.
+{
+	enum
+	{
+		VALUE = 0
+	};
+};
+
+
+template <typename T>
+struct IsReference<T&>
+{
+	enum 
+	{
+		VALUE = 1
+	};
+};
+
+
+template <typename T>
+struct IsReference<const T&>
+{
+	enum 
+	{
+		VALUE = 1
+	};
+};
+
+
+template <typename T>
+struct IsConst
+	/// Use this struct to determine if a template type is a const type.
+{
+	enum
+	{
+		VALUE = 0
+	};
+};
+
+
+template <typename T>
+struct IsConst<const T&>
+{
+	enum 
+	{
+		VALUE = 1
+	};
+};
+
+
+template <typename T>
+struct IsConst<const T>
+{
+	enum 
+	{
+		VALUE = 1
+	};
+};
+
+
+template <typename T, int i>
+struct IsConst<const T[i]>
+	/// Specialization for const char arrays
+{
+	enum
+	{
+		VALUE = 1
+	};
+};
+
+
+template <typename T>
+struct TypeWrapper
+	/// Use the type wrapper if you want to decouple constness and references from template types.
+{
+	typedef T TYPE;
+	typedef const T CONSTTYPE;
+	typedef T& REFTYPE;
+	typedef const T& CONSTREFTYPE;
+};
+
+
+template <typename T>
+struct TypeWrapper<const T>
+{
+	typedef T TYPE;
+	typedef const T CONSTTYPE;
+	typedef T& REFTYPE;
+	typedef const T& CONSTREFTYPE;
+};
+
+
+template <typename T>
+struct TypeWrapper<const T&>
+{
+	typedef T TYPE;
+	typedef const T CONSTTYPE;
+	typedef T& REFTYPE;
+	typedef const T& CONSTREFTYPE;
+};
+
+
+template <typename T>
+struct TypeWrapper<T&>
+{
+	typedef T TYPE;
+	typedef const T CONSTTYPE;
+	typedef T& REFTYPE;
+	typedef const T& CONSTREFTYPE;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_MetaProgramming_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Mutex.h b/base/poco/Foundation/include/Poco/Mutex.h
new file mode 100644
index 00000000000..64d0efc06db
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Mutex.h
@@ -0,0 +1,270 @@
+//
+// Mutex.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Mutex
+//
+// Definition of the Mutex and FastMutex classes.
+//
+// Copyright (c) 2004-2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Mutex_INCLUDED
+#define Foundation_Mutex_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include "Poco/ScopedLock.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#if defined(_WIN32_WCE)
+#include "Poco/Mutex_WINCE.h"
+#else
+#include "Poco/Mutex_WIN32.h"
+#endif
+#elif defined(POCO_VXWORKS)
+#include "Poco/Mutex_VX.h"
+#else
+#include "Poco/Mutex_POSIX.h"
+#endif
+
+
+namespace Poco {
+
+
+class Foundation_API Mutex: private MutexImpl
+	/// A Mutex (mutual exclusion) is a synchronization 
+	/// mechanism used to control access to a shared resource
+	/// in a concurrent (multithreaded) scenario.
+	/// Mutexes are recursive, that is, the same mutex can be 
+	/// locked multiple times by the same thread (but, of course,
+	/// not by other threads).
+	/// Using the ScopedLock class is the preferred way to automatically
+	/// lock and unlock a mutex.
+{
+public:
+	typedef Poco::ScopedLock<Mutex> ScopedLock;
+	
+	Mutex();
+		/// creates the Mutex.
+		
+	~Mutex();
+		/// destroys the Mutex.
+
+	void lock();
+		/// Locks the mutex. Blocks if the mutex
+		/// is held by another thread.
+		
+	void lock(long milliseconds);
+		/// Locks the mutex. Blocks up to the given number of milliseconds
+		/// if the mutex is held by another thread. Throws a TimeoutException
+		/// if the mutex can not be locked within the given timeout.
+		///
+		/// Performance Note: On most platforms (including Windows), this member function is 
+		/// implemented using a loop calling (the equivalent of) tryLock() and Thread::sleep().
+		/// On POSIX platforms that support pthread_mutex_timedlock(), this is used.
+
+	bool tryLock();
+		/// Tries to lock the mutex. Returns false immediately
+		/// if the mutex is already held by another thread.
+		/// Returns true if the mutex was successfully locked.
+
+	bool tryLock(long milliseconds);
+		/// Locks the mutex. Blocks up to the given number of milliseconds
+		/// if the mutex is held by another thread.
+		/// Returns true if the mutex was successfully locked.
+		///
+		/// Performance Note: On most platforms (including Windows), this member function is 
+		/// implemented using a loop calling (the equivalent of) tryLock() and Thread::sleep().
+		/// On POSIX platforms that support pthread_mutex_timedlock(), this is used.
+
+	void unlock();
+		/// Unlocks the mutex so that it can be acquired by
+		/// other threads.
+	
+private:
+	Mutex(const Mutex&);
+	Mutex& operator = (const Mutex&);
+};
+
+
+class Foundation_API FastMutex: private FastMutexImpl
+	/// A FastMutex (mutual exclusion) is similar to a Mutex.
+	/// Unlike a Mutex, however, a FastMutex is not recursive,
+	/// which means that a deadlock will occur if the same
+	/// thread tries to lock a mutex it has already locked again.
+	/// Locking a FastMutex is faster than locking a recursive Mutex.
+	/// Using the ScopedLock class is the preferred way to automatically
+	/// lock and unlock a mutex.
+{
+public:
+	typedef Poco::ScopedLock<FastMutex> ScopedLock;
+
+	FastMutex();
+		/// creates the Mutex.
+		
+	~FastMutex();
+		/// destroys the Mutex.
+
+	void lock();
+		/// Locks the mutex. Blocks if the mutex
+		/// is held by another thread.
+
+	void lock(long milliseconds);
+		/// Locks the mutex. Blocks up to the given number of milliseconds
+		/// if the mutex is held by another thread. Throws a TimeoutException
+		/// if the mutex can not be locked within the given timeout.
+		///
+		/// Performance Note: On most platforms (including Windows), this member function is 
+		/// implemented using a loop calling (the equivalent of) tryLock() and Thread::sleep().
+		/// On POSIX platforms that support pthread_mutex_timedlock(), this is used.
+
+	bool tryLock();
+		/// Tries to lock the mutex. Returns false immediately
+		/// if the mutex is already held by another thread.
+		/// Returns true if the mutex was successfully locked.
+
+	bool tryLock(long milliseconds);
+		/// Locks the mutex. Blocks up to the given number of milliseconds
+		/// if the mutex is held by another thread.
+		/// Returns true if the mutex was successfully locked.
+		///
+		/// Performance Note: On most platforms (including Windows), this member function is 
+		/// implemented using a loop calling (the equivalent of) tryLock() and Thread::sleep().
+		/// On POSIX platforms that support pthread_mutex_timedlock(), this is used.
+
+	void unlock();
+		/// Unlocks the mutex so that it can be acquired by
+		/// other threads.
+	
+private:
+	FastMutex(const FastMutex&);
+	FastMutex& operator = (const FastMutex&);
+};
+
+
+class Foundation_API NullMutex
+	/// A NullMutex is an empty mutex implementation
+	/// which performs no locking at all. Useful in policy driven design
+	/// where the type of mutex used can be now a template parameter allowing the user to switch
+	/// between thread-safe and not thread-safe depending on his need
+	/// Works with the ScopedLock class
+{
+public:
+	typedef Poco::ScopedLock<NullMutex> ScopedLock;
+	
+	NullMutex()
+		/// Creates the NullMutex.
+	{
+	}
+		
+	~NullMutex()
+		/// Destroys the NullMutex.
+	{
+	}
+
+	void lock()
+		/// Does nothing.
+	{
+	}
+		
+	void lock(long)
+		/// Does nothing.
+	{
+	}
+
+	bool tryLock()
+		/// Does nothing and always returns true.
+	{
+		return true;
+	}
+
+	bool tryLock(long)
+		/// Does nothing and always returns true.
+	{
+		return true;
+	}
+
+	void unlock()
+		/// Does nothing.
+	{
+	}
+};
+
+
+//
+// inlines
+//
+inline void Mutex::lock()
+{
+	lockImpl();
+}
+
+
+inline void Mutex::lock(long milliseconds)
+{
+	if (!tryLockImpl(milliseconds))
+		throw TimeoutException();
+}
+
+
+inline bool Mutex::tryLock()
+{
+	return tryLockImpl();
+}
+
+
+inline bool Mutex::tryLock(long milliseconds)
+{
+	return tryLockImpl(milliseconds);
+}
+
+
+inline void Mutex::unlock()
+{
+	unlockImpl();
+}
+
+
+inline void FastMutex::lock()
+{
+	lockImpl();
+}
+
+
+inline void FastMutex::lock(long milliseconds)
+{
+	if (!tryLockImpl(milliseconds))
+		throw TimeoutException();
+}
+
+
+inline bool FastMutex::tryLock()
+{
+	return tryLockImpl();
+}
+
+
+inline bool FastMutex::tryLock(long milliseconds)
+{
+	return tryLockImpl(milliseconds);
+}
+
+
+inline void FastMutex::unlock()
+{
+	unlockImpl();
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Mutex_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Mutex_POSIX.h b/base/poco/Foundation/include/Poco/Mutex_POSIX.h
new file mode 100644
index 00000000000..12f61dd689a
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Mutex_POSIX.h
@@ -0,0 +1,86 @@
+//
+// Mutex_POSIX.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Mutex
+//
+// Definition of the MutexImpl and FastMutexImpl classes for POSIX Threads.
+//
+// Copyright (c) 2004-2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Mutex_POSIX_INCLUDED
+#define Foundation_Mutex_POSIX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include <pthread.h>
+#include <errno.h>
+
+
+namespace Poco {
+
+
+class Foundation_API MutexImpl
+{
+protected:
+	MutexImpl();
+	MutexImpl(bool fast);
+	~MutexImpl();
+	void lockImpl();
+	bool tryLockImpl();
+	bool tryLockImpl(long milliseconds);
+	void unlockImpl();
+	
+private:
+	pthread_mutex_t _mutex;
+};
+
+
+class Foundation_API FastMutexImpl: public MutexImpl
+{
+protected:
+	FastMutexImpl();
+	~FastMutexImpl();
+};
+
+
+//
+// inlines
+//
+inline void MutexImpl::lockImpl()
+{
+	if (pthread_mutex_lock(&_mutex)) 
+		throw SystemException("cannot lock mutex");
+}
+
+
+inline bool MutexImpl::tryLockImpl()
+{
+	int rc = pthread_mutex_trylock(&_mutex);
+	if (rc == 0)
+		return true;
+	else if (rc == EBUSY)
+		return false;
+	else
+		throw SystemException("cannot lock mutex");
+}
+
+
+inline void MutexImpl::unlockImpl()
+{
+	if (pthread_mutex_unlock(&_mutex))
+		throw SystemException("cannot unlock mutex");
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Mutex_POSIX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Mutex_VX.h b/base/poco/Foundation/include/Poco/Mutex_VX.h
new file mode 100644
index 00000000000..f0f43eac3a1
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Mutex_VX.h
@@ -0,0 +1,80 @@
+//
+// Mutex_VX.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Mutex
+//
+// Definition of the MutexImpl and FastMutexImpl classes for VxWorks.
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Mutex_VX_INCLUDED
+#define Foundation_Mutex_VX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include <semLib.h>
+#include <errno.h>
+
+
+namespace Poco {
+
+
+class Foundation_API MutexImpl
+{
+protected:
+	MutexImpl();
+	MutexImpl(bool fast);
+	~MutexImpl();
+	void lockImpl();
+	bool tryLockImpl();
+	bool tryLockImpl(long milliseconds);
+	void unlockImpl();
+	
+private:
+	SEM_ID _sem;
+};
+
+
+class Foundation_API FastMutexImpl: public MutexImpl
+{
+protected:
+	FastMutexImpl();
+	~FastMutexImpl();
+};
+
+
+//
+// inlines
+//
+inline void MutexImpl::lockImpl()
+{
+	if (semTake(_sem, WAIT_FOREVER) != OK)
+		throw SystemException("cannot lock mutex");
+}
+
+
+inline bool MutexImpl::tryLockImpl()
+{
+	return semTake(_sem, NO_WAIT) == OK;
+}
+
+
+inline void MutexImpl::unlockImpl()
+{
+	if (semGive(_sem) != OK)
+		throw SystemException("cannot unlock mutex");
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Mutex_VX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Mutex_WIN32.h b/base/poco/Foundation/include/Poco/Mutex_WIN32.h
new file mode 100644
index 00000000000..8e18c527eaa
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Mutex_WIN32.h
@@ -0,0 +1,85 @@
+//
+// Mutex_WIN32.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Mutex
+//
+// Definition of the MutexImpl and FastMutexImpl classes for WIN32.
+//
+// Copyright (c) 2004-2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Mutex_WIN32_INCLUDED
+#define Foundation_Mutex_WIN32_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API MutexImpl
+{
+protected:
+	MutexImpl();
+	~MutexImpl();
+	void lockImpl();
+	bool tryLockImpl();
+	bool tryLockImpl(long milliseconds);
+	void unlockImpl();
+	
+private:
+	CRITICAL_SECTION _cs;
+};
+
+
+typedef MutexImpl FastMutexImpl;
+
+
+//
+// inlines
+//
+inline void MutexImpl::lockImpl()
+{
+	try
+	{
+		EnterCriticalSection(&_cs);
+	}
+	catch (...)
+	{
+		throw SystemException("cannot lock mutex");
+	}
+}
+
+
+inline bool MutexImpl::tryLockImpl()
+{
+	try
+	{
+		return TryEnterCriticalSection(&_cs) != 0;
+	}
+	catch (...)
+	{
+	}
+	throw SystemException("cannot lock mutex");
+}
+
+
+inline void MutexImpl::unlockImpl()
+{
+	LeaveCriticalSection(&_cs);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Mutex_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Mutex_WINCE.h b/base/poco/Foundation/include/Poco/Mutex_WINCE.h
new file mode 100644
index 00000000000..27200680f19
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Mutex_WINCE.h
@@ -0,0 +1,50 @@
+//
+// Mutex_WIN32.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Mutex
+//
+// Definition of the MutexImpl and FastMutexImpl classes for WIN32.
+//
+// Copyright (c) 2004-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Mutex_WINCE_INCLUDED
+#define Foundation_Mutex_WINCE_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API MutexImpl
+{
+protected:
+	MutexImpl();
+	~MutexImpl();
+	void lockImpl();
+	bool tryLockImpl();
+	bool tryLockImpl(long milliseconds);
+	void unlockImpl();
+	
+private:
+	HANDLE _mutex;
+};
+
+
+typedef MutexImpl FastMutexImpl;
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Mutex_WINCE_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NObserver.h b/base/poco/Foundation/include/Poco/NObserver.h
new file mode 100644
index 00000000000..8b5106c8b0e
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NObserver.h
@@ -0,0 +1,126 @@
+//
+// NObserver.h
+//
+// Library: Foundation
+// Package: Notifications
+// Module:  NotificationCenter
+//
+// Definition of the NObserver class template.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NObserver_INCLUDED
+#define Foundation_NObserver_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/AbstractObserver.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+
+
+template <class C, class N>
+class NObserver: public AbstractObserver
+	/// This template class implements an adapter that sits between
+	/// a NotificationCenter and an object receiving notifications
+	/// from it. It is quite similar in concept to the 
+	/// RunnableAdapter, but provides some NotificationCenter
+	/// specific additional methods.
+	/// See the NotificationCenter class for information on how
+	/// to use this template class.
+	///
+	/// This class template is quite similar to the Observer class
+	/// template. The only difference is that the NObserver
+	/// expects the callback function to accept a const AutoPtr& 
+	/// instead of a plain pointer as argument, thus simplifying memory
+	/// management.
+{
+public:
+	typedef AutoPtr<N> NotificationPtr;
+	typedef void (C::*Callback)(const NotificationPtr&);
+
+	NObserver(C& object, Callback method): 
+		_pObject(&object), 
+		_method(method)
+	{
+	}
+	
+	NObserver(const NObserver& observer):
+		AbstractObserver(observer),
+		_pObject(observer._pObject), 
+		_method(observer._method)
+	{
+	}
+	
+	~NObserver()
+	{
+	}
+	
+	NObserver& operator = (const NObserver& observer)
+	{
+		if (&observer != this)
+		{
+			_pObject = observer._pObject;
+			_method  = observer._method;
+		}
+		return *this;
+	}
+	
+	void notify(Notification* pNf) const
+	{
+		Poco::Mutex::ScopedLock lock(_mutex);
+
+		if (_pObject)
+		{
+			N* pCastNf = dynamic_cast<N*>(pNf);
+			if (pCastNf)
+			{
+				NotificationPtr ptr(pCastNf, true);
+				(_pObject->*_method)(ptr);
+			}
+		}
+	}
+	
+	bool equals(const AbstractObserver& abstractObserver) const
+	{
+		const NObserver* pObs = dynamic_cast<const NObserver*>(&abstractObserver);
+		return pObs && pObs->_pObject == _pObject && pObs->_method == _method;
+	}
+
+	bool accepts(Notification* pNf) const
+	{
+		return dynamic_cast<N*>(pNf) != 0;
+	}
+	
+	AbstractObserver* clone() const
+	{
+		return new NObserver(*this);
+	}
+	
+	void disable()
+	{
+		Poco::Mutex::ScopedLock lock(_mutex);
+		
+		_pObject = 0;
+	}
+
+private:
+	NObserver();
+
+	C*       _pObject;
+	Callback _method;
+	mutable Poco::Mutex _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NObserver_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NamedEvent.h b/base/poco/Foundation/include/Poco/NamedEvent.h
new file mode 100644
index 00000000000..b473be108bb
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NamedEvent.h
@@ -0,0 +1,96 @@
+//
+// NamedEvent.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedEvent
+//
+// Definition of the NamedEvent class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NamedEvent_INCLUDED
+#define Foundation_NamedEvent_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS) && defined(POCO_WIN32_UTF8)
+#include "Poco/NamedEvent_WIN32U.h"
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "Poco/NamedEvent_WIN32.h"
+#elif POCO_OS == POCO_OS_ANDROID
+#include "Poco/NamedEvent_Android.h"
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include "Poco/NamedEvent_UNIX.h"
+#endif
+
+
+namespace Poco {
+
+
+class Foundation_API NamedEvent: public NamedEventImpl
+	/// An NamedEvent is a global synchronization object
+	/// that allows one process or thread to signal an
+	/// other process or thread that a certain event
+	/// has happened.
+	///
+	/// Unlike an Event, which itself is the unit of synchronization,
+	/// a NamedEvent refers to a named operating system resource being the
+	/// unit of synchronization.
+	/// In other words, there can be multiple instances of NamedEvent referring
+	/// to the same actual synchronization object.
+	///
+	/// NamedEvents are always autoresetting.
+	///
+	/// There should not be more than one instance of NamedEvent for
+	/// a given name in a process. Otherwise, the instances may
+	/// interfere with each other.
+{
+public:
+	NamedEvent(const std::string& name);
+		/// Creates the event.
+
+	~NamedEvent();
+		/// Destroys the event.
+
+	void set();
+		/// Signals the event.
+		/// The one thread or process waiting for the event
+		/// can resume execution.
+
+	void wait();
+		/// Waits for the event to become signalled.
+
+private:
+	NamedEvent();
+	NamedEvent(const NamedEvent&);
+	NamedEvent& operator = (const NamedEvent&);
+};
+
+
+//
+// inlines
+//
+inline void NamedEvent::set()
+{
+	setImpl();
+}
+
+
+inline void NamedEvent::wait()
+{
+	waitImpl();
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NamedEvent_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NamedEvent_Android.h b/base/poco/Foundation/include/Poco/NamedEvent_Android.h
new file mode 100644
index 00000000000..910c8a46e02
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NamedEvent_Android.h
@@ -0,0 +1,40 @@
+//
+// NamedEvent_Android.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedEvent
+//
+// Definition of the NamedEventImpl class for Android.
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NamedEvent_Android_INCLUDED
+#define Foundation_NamedEvent_Android_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API NamedEventImpl
+{
+protected:
+	NamedEventImpl(const std::string& name);	
+	~NamedEventImpl();
+	void setImpl();
+	void waitImpl();
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NamedEvent_Android_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NamedEvent_UNIX.h b/base/poco/Foundation/include/Poco/NamedEvent_UNIX.h
new file mode 100644
index 00000000000..e593790d655
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NamedEvent_UNIX.h
@@ -0,0 +1,53 @@
+//
+// NamedEvent_UNIX.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedEvent
+//
+// Definition of the NamedEventImpl class for Unix.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NamedEvent_UNIX_INCLUDED
+#define Foundation_NamedEvent_UNIX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#if defined(sun) || defined(__APPLE__) || defined(__osf__) || defined(__QNX__) || defined(_AIX)
+#include <semaphore.h>
+#endif
+
+
+namespace Poco {
+
+
+class Foundation_API NamedEventImpl
+{
+protected:
+	NamedEventImpl(const std::string& name);	
+	~NamedEventImpl();
+	void setImpl();
+	void waitImpl();
+	
+private:
+	std::string getFileName();
+
+	std::string _name;
+#if defined(sun) || defined(__APPLE__) || defined(__osf__) || defined(__QNX__) || defined(_AIX)
+	sem_t* _sem;
+#else
+	int _semid;  // semaphore id
+#endif
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NamedEvent_UNIX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NamedEvent_WIN32.h b/base/poco/Foundation/include/Poco/NamedEvent_WIN32.h
new file mode 100644
index 00000000000..4d09f90a8e1
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NamedEvent_WIN32.h
@@ -0,0 +1,45 @@
+//
+// NamedEvent_WIN32.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedEvent
+//
+// Definition of the NamedEventImpl class for Windows.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NamedEvent_WIN32_INCLUDED
+#define Foundation_NamedEvent_WIN32_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API NamedEventImpl
+{
+protected:
+	NamedEventImpl(const std::string& name);	
+	~NamedEventImpl();
+	void setImpl();
+	void waitImpl();
+	
+private:
+	std::string _name;
+	HANDLE      _event;	
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NamedEvent_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NamedEvent_WIN32U.h b/base/poco/Foundation/include/Poco/NamedEvent_WIN32U.h
new file mode 100644
index 00000000000..b2936c416c5
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NamedEvent_WIN32U.h
@@ -0,0 +1,46 @@
+//
+// NamedEvent_WIN32U.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedEvent
+//
+// Definition of the NamedEventImpl class for Windows.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NamedEvent_WIN32U_INCLUDED
+#define Foundation_NamedEvent_WIN32U_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API NamedEventImpl
+{
+protected:
+	NamedEventImpl(const std::string& name);	
+	~NamedEventImpl();
+	void setImpl();
+	void waitImpl();
+	
+private:
+	std::string  _name;
+	std::wstring _uname;
+	HANDLE      _event;	
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NamedEvent_WIN32U_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NamedMutex.h b/base/poco/Foundation/include/Poco/NamedMutex.h
new file mode 100644
index 00000000000..421f018e266
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NamedMutex.h
@@ -0,0 +1,110 @@
+//
+// NamedMutex.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedMutex
+//
+// Definition of the NamedMutex class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NamedMutex_INCLUDED
+#define Foundation_NamedMutex_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/ScopedLock.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS) && defined(POCO_WIN32_UTF8)
+#include "Poco/NamedMutex_WIN32U.h"
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "Poco/NamedMutex_WIN32.h"
+#elif POCO_OS == POCO_OS_ANDROID
+#include "Poco/NamedMutex_Android.h"
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include "Poco/NamedMutex_UNIX.h"
+#endif
+
+
+namespace Poco {
+
+
+class Foundation_API NamedMutex: private NamedMutexImpl
+	/// A NamedMutex (mutual exclusion) is a global synchronization
+	/// mechanism used to control access to a shared resource
+	/// in a concurrent (multi process) scenario.
+	/// Using the ScopedLock class is the preferred way to automatically
+	/// lock and unlock a mutex.
+	///
+	/// Unlike a Mutex or a FastMutex, which itself is the unit of synchronization,
+	/// a NamedMutex refers to a named operating system resource being the
+	/// unit of synchronization.
+	/// In other words, there can be multiple instances of NamedMutex referring
+	/// to the same actual synchronization object.
+	///
+	///
+	/// There should not be more than one instance of NamedMutex for
+	/// a given name in a process. Otherwise, the instances may
+	/// interfere with each other.
+{
+public:
+	typedef Poco::ScopedLock<NamedMutex> ScopedLock;
+
+	NamedMutex(const std::string& name);
+		/// creates the Mutex.
+
+	~NamedMutex();
+		/// destroys the Mutex.
+
+	void lock();
+		/// Locks the mutex. Blocks if the mutex
+		/// is held by another process or thread.
+
+	bool tryLock();
+		/// Tries to lock the mutex. Returns false immediately
+		/// if the mutex is already held by another process or thread.
+		/// Returns true if the mutex was successfully locked.
+
+	void unlock();
+		/// Unlocks the mutex so that it can be acquired by
+		/// other threads.
+
+private:
+	NamedMutex();
+	NamedMutex(const NamedMutex&);
+	NamedMutex& operator = (const NamedMutex&);
+};
+
+
+//
+// inlines
+//
+inline void NamedMutex::lock()
+{
+	lockImpl();
+}
+
+
+inline bool NamedMutex::tryLock()
+{
+	return tryLockImpl();
+}
+
+
+inline void NamedMutex::unlock()
+{
+	unlockImpl();
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NamedMutex_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NamedMutex_Android.h b/base/poco/Foundation/include/Poco/NamedMutex_Android.h
new file mode 100644
index 00000000000..c570b862924
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NamedMutex_Android.h
@@ -0,0 +1,41 @@
+//
+// NamedMutex_Android.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedMutex
+//
+// Definition of the NamedMutexImpl class for Android.
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NamedMutex_Android_INCLUDED
+#define Foundation_NamedMutex_Android_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API NamedMutexImpl
+{
+protected:
+	NamedMutexImpl(const std::string& name);
+	~NamedMutexImpl();
+	void lockImpl();
+	bool tryLockImpl();
+	void unlockImpl();
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NamedMutex_Android_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NamedMutex_UNIX.h b/base/poco/Foundation/include/Poco/NamedMutex_UNIX.h
new file mode 100644
index 00000000000..da77a32eef1
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NamedMutex_UNIX.h
@@ -0,0 +1,57 @@
+//
+// NamedMutex_UNIX.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedMutex
+//
+// Definition of the NamedMutexImpl class for Unix.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NamedMutex_UNIX_INCLUDED
+#define Foundation_NamedMutex_UNIX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#if defined(sun) || defined(__APPLE__) || defined(__osf__) || defined(__QNX__) || defined(_AIX)
+#include <semaphore.h>
+#endif
+
+
+namespace Poco {
+
+
+class Foundation_API NamedMutexImpl
+{
+protected:
+	NamedMutexImpl(const std::string& name);
+	~NamedMutexImpl();
+	void lockImpl();
+	bool tryLockImpl();
+	void unlockImpl();
+	
+private:
+	std::string getFileName();
+
+	std::string _name;
+#if defined(sun) || defined(__APPLE__) || defined(__osf__) || defined(__QNX__) || defined(_AIX)
+	sem_t* _sem;
+#else
+	int _semid;  // semaphore id
+	bool _owned;
+#endif
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NamedMutex_UNIX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NamedMutex_WIN32.h b/base/poco/Foundation/include/Poco/NamedMutex_WIN32.h
new file mode 100644
index 00000000000..c43dd353458
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NamedMutex_WIN32.h
@@ -0,0 +1,46 @@
+//
+// NamedMutex_WIN32.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedMutex
+//
+// Definition of the NamedMutexImpl class for Windows.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NamedMutex_WIN32_INCLUDED
+#define Foundation_NamedMutex_WIN32_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API NamedMutexImpl
+{
+protected:
+	NamedMutexImpl(const std::string& name);
+	~NamedMutexImpl();
+	void lockImpl();
+	bool tryLockImpl();
+	void unlockImpl();
+	
+private:
+	std::string _name;
+	HANDLE      _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NamedMutex_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NamedMutex_WIN32U.h b/base/poco/Foundation/include/Poco/NamedMutex_WIN32U.h
new file mode 100644
index 00000000000..8ee31586584
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NamedMutex_WIN32U.h
@@ -0,0 +1,47 @@
+//
+// NamedMutex_WIN32U.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedMutex
+//
+// Definition of the NamedMutexImpl class for Windows.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NamedMutex_WIN32U_INCLUDED
+#define Foundation_NamedMutex_WIN32U_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API NamedMutexImpl
+{
+protected:
+	NamedMutexImpl(const std::string& name);
+	~NamedMutexImpl();
+	void lockImpl();
+	bool tryLockImpl();
+	void unlockImpl();
+	
+private:
+	std::string  _name;
+	std::wstring _uname;
+	HANDLE       _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NamedMutex_WIN32U_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NamedTuple.h b/base/poco/Foundation/include/Poco/NamedTuple.h
new file mode 100644
index 00000000000..9a193575d6f
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NamedTuple.h
@@ -0,0 +1,4462 @@
+//
+// NamedTuple.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  NamedTuple
+//
+// Definition of the NamedTuple class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NamedTuple_INCLUDED
+#define Foundation_NamedTuple_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Tuple.h"
+#include "Poco/TypeList.h"
+#include "Poco/DynamicAny.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Format.h"
+
+
+namespace Poco {
+
+
+template<class T0, 
+	class T1 = NullTypeList,
+	class T2 = NullTypeList,
+	class T3 = NullTypeList,
+	class T4 = NullTypeList,
+	class T5 = NullTypeList,
+	class T6 = NullTypeList,
+	class T7 = NullTypeList, 
+	class T8 = NullTypeList,
+	class T9 = NullTypeList,
+	class T10 = NullTypeList,
+	class T11 = NullTypeList,
+	class T12 = NullTypeList,
+	class T13 = NullTypeList,
+	class T14 = NullTypeList,
+	class T15 = NullTypeList,
+	class T16 = NullTypeList,
+	class T17 = NullTypeList,
+	class T18 = NullTypeList,
+	class T19 = NullTypeList>
+struct NamedTuple: public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>
+{
+	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19> TupleType;
+	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::Type Type;
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17), 
+		typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18), 
+		typename TypeWrapper<T19>::CONSTTYPE& t19 = POCO_TYPEWRAPPER_DEFAULTVALUE(T19)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18,t19), 
+		_pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17), 
+		typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18), 
+		typename TypeWrapper<T19>::CONSTTYPE& t19 = POCO_TYPEWRAPPER_DEFAULTVALUE(T19)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18,t19)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		const std::string& n11 = "L",
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		const std::string& n12 = "M",
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		const std::string& n13 = "N",
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
+		const std::string& n14 = "O",
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
+		const std::string& n15 = "P",
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
+		const std::string& n16 = "Q",
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16),
+		const std::string& n17 = "R",
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17),
+		const std::string& n18 = "S",
+		typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18),
+		const std::string& n19 = "T",
+		typename TypeWrapper<T19>::CONSTTYPE& t19 = POCO_TYPEWRAPPER_DEFAULTVALUE(T19)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18,t19), 
+		_pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17,n18,n19);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
+					case 10: return TupleType::template get<10>();
+					case 11: return TupleType::template get<11>();
+					case 12: return TupleType::template get<12>();
+					case 13: return TupleType::template get<13>();
+					case 14: return TupleType::template get<14>();
+					case 15: return TupleType::template get<15>();
+					case 16: return TupleType::template get<16>();
+					case 17: return TupleType::template get<17>();
+					case 18: return TupleType::template get<18>();
+					case 19: return TupleType::template get<19>();
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K",
+		const std::string& n11 = "L",
+		const std::string& n12 = "M",
+		const std::string& n13 = "N",
+		const std::string& n14 = "O",
+		const std::string& n15 = "P",
+		const std::string& n16 = "Q",
+		const std::string& n17 = "R",
+		const std::string& n18 = "S",
+		const std::string& n19 = "T")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
+			_pNames->push_back(n10); 
+			_pNames->push_back(n11); 
+			_pNames->push_back(n12); 
+			_pNames->push_back(n13); 
+			_pNames->push_back(n14); 
+			_pNames->push_back(n15); 
+			_pNames->push_back(n16); 
+			_pNames->push_back(n17); 
+			_pNames->push_back(n18); 
+			_pNames->push_back(n19); 
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0, 
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18>
+struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,NullTypeList>:
+	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>
+{
+	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18> TupleType;
+	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::Type Type;
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17), 
+		typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18), 
+		_pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17), 
+		typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		const std::string& n11 = "L",
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		const std::string& n12 = "M",
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		const std::string& n13 = "N",
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
+		const std::string& n14 = "O",
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
+		const std::string& n15 = "P",
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
+		const std::string& n16 = "Q",
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16),
+		const std::string& n17 = "R",
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17),
+		const std::string& n18 = "S",
+		typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17,t18), 
+		_pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17,n18);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
+					case 10: return TupleType::template get<10>();
+					case 11: return TupleType::template get<11>();
+					case 12: return TupleType::template get<12>();
+					case 13: return TupleType::template get<13>();
+					case 14: return TupleType::template get<14>();
+					case 15: return TupleType::template get<15>();
+					case 16: return TupleType::template get<16>();
+					case 17: return TupleType::template get<17>();
+					case 18: return TupleType::template get<18>();
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K",
+		const std::string& n11 = "L",
+		const std::string& n12 = "M",
+		const std::string& n13 = "N",
+		const std::string& n14 = "O",
+		const std::string& n15 = "P",
+		const std::string& n16 = "Q",
+		const std::string& n17 = "R",
+		const std::string& n18 = "S")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
+			_pNames->push_back(n10); 
+			_pNames->push_back(n11); 
+			_pNames->push_back(n12); 
+			_pNames->push_back(n13); 
+			_pNames->push_back(n14); 
+			_pNames->push_back(n15); 
+			_pNames->push_back(n16); 
+			_pNames->push_back(n17); 
+			_pNames->push_back(n18); 
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0, 
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17>
+struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,NullTypeList>:
+	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>
+{
+	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> TupleType;
+	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::Type Type;
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17), 
+		_pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16), 
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		const std::string& n11 = "L",
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		const std::string& n12 = "M",
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		const std::string& n13 = "N",
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
+		const std::string& n14 = "O",
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
+		const std::string& n15 = "P",
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
+		const std::string& n16 = "Q",
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16),
+		const std::string& n17 = "R",
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16,t17), 
+		_pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16,n17);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
+					case 10: return TupleType::template get<10>();
+					case 11: return TupleType::template get<11>();
+					case 12: return TupleType::template get<12>();
+					case 13: return TupleType::template get<13>();
+					case 14: return TupleType::template get<14>();
+					case 15: return TupleType::template get<15>();
+					case 16: return TupleType::template get<16>();
+					case 17: return TupleType::template get<17>();
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K",
+		const std::string& n11 = "L",
+		const std::string& n12 = "M",
+		const std::string& n13 = "N",
+		const std::string& n14 = "O",
+		const std::string& n15 = "P",
+		const std::string& n16 = "Q",
+		const std::string& n17 = "R")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
+			_pNames->push_back(n10); 
+			_pNames->push_back(n11); 
+			_pNames->push_back(n12); 
+			_pNames->push_back(n13); 
+			_pNames->push_back(n14); 
+			_pNames->push_back(n15); 
+			_pNames->push_back(n16); 
+			_pNames->push_back(n17); 
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0, 
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16>
+struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,NullTypeList>:
+	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>
+{
+	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> TupleType;
+	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::Type Type;
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16), 
+		_pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15), 
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		const std::string& n11 = "L",
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		const std::string& n12 = "M",
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		const std::string& n13 = "N",
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
+		const std::string& n14 = "O",
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
+		const std::string& n15 = "P",
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
+		const std::string& n16 = "Q",
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15,t16), 
+		_pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15,n16);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
+					case 10: return TupleType::template get<10>();
+					case 11: return TupleType::template get<11>();
+					case 12: return TupleType::template get<12>();
+					case 13: return TupleType::template get<13>();
+					case 14: return TupleType::template get<14>();
+					case 15: return TupleType::template get<15>();
+					case 16: return TupleType::template get<16>();
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K",
+		const std::string& n11 = "L",
+		const std::string& n12 = "M",
+		const std::string& n13 = "N",
+		const std::string& n14 = "O",
+		const std::string& n15 = "P",
+		const std::string& n16 = "Q")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
+			_pNames->push_back(n10); 
+			_pNames->push_back(n11); 
+			_pNames->push_back(n12); 
+			_pNames->push_back(n13); 
+			_pNames->push_back(n14); 
+			_pNames->push_back(n15); 
+			_pNames->push_back(n16); 
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0, 
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15>
+struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,NullTypeList>:
+	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>
+{
+	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> TupleType;
+	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::Type Type;
+
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15), 
+		_pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14), 
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		const std::string& n11 = "L",
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		const std::string& n12 = "M",
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		const std::string& n13 = "N",
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
+		const std::string& n14 = "O",
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
+		const std::string& n15 = "P",
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14,t15), 
+		_pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14,n15);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
+					case 10: return TupleType::template get<10>();
+					case 11: return TupleType::template get<11>();
+					case 12: return TupleType::template get<12>();
+					case 13: return TupleType::template get<13>();
+					case 14: return TupleType::template get<14>();
+					case 15: return TupleType::template get<15>();
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K",
+		const std::string& n11 = "L",
+		const std::string& n12 = "M",
+		const std::string& n13 = "N",
+		const std::string& n14 = "O",
+		const std::string& n15 = "P")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
+			_pNames->push_back(n10); 
+			_pNames->push_back(n11); 
+			_pNames->push_back(n12); 
+			_pNames->push_back(n13); 
+			_pNames->push_back(n14); 
+			_pNames->push_back(n15); 
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0, 
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14>
+struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,NullTypeList>:
+	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>
+{
+	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> TupleType;
+	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>::Type Type;
+
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14), 
+		_pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13), 
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		const std::string& n11 = "L",
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		const std::string& n12 = "M",
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		const std::string& n13 = "N",
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
+		const std::string& n14 = "O",
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13,t14), 
+		_pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13,n14);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
+					case 10: return TupleType::template get<10>();
+					case 11: return TupleType::template get<11>();
+					case 12: return TupleType::template get<12>();
+					case 13: return TupleType::template get<13>();
+					case 14: return TupleType::template get<14>();
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K",
+		const std::string& n11 = "L",
+		const std::string& n12 = "M",
+		const std::string& n13 = "N",
+		const std::string& n14 = "O")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
+			_pNames->push_back(n10); 
+			_pNames->push_back(n11); 
+			_pNames->push_back(n12); 
+			_pNames->push_back(n13); 
+			_pNames->push_back(n14); 
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0, 
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13>
+struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,NullTypeList>:
+	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>
+{
+	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> TupleType;
+	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>::Type Type;
+
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13), 
+		_pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12), 
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		const std::string& n11 = "L",
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		const std::string& n12 = "M",
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		const std::string& n13 = "N",
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12,t13), 
+		_pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12,n13);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
+					case 10: return TupleType::template get<10>();
+					case 11: return TupleType::template get<11>();
+					case 12: return TupleType::template get<12>();
+					case 13: return TupleType::template get<13>();
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K",
+		const std::string& n11 = "L",
+		const std::string& n12 = "M",
+		const std::string& n13 = "N")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
+			_pNames->push_back(n10); 
+			_pNames->push_back(n11); 
+			_pNames->push_back(n12); 
+			_pNames->push_back(n13); 
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0, 
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12>
+struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,NullTypeList>:
+	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>
+{
+	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> TupleType;
+	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>::Type Type;
+
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12), 
+		_pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11), 
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		const std::string& n11 = "L",
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		const std::string& n12 = "M",
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12)): 
+	TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11,t12), _pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11,n12);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
+					case 10: return TupleType::template get<10>();
+					case 11: return TupleType::template get<11>();
+					case 12: return TupleType::template get<12>();
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K",
+		const std::string& n11 = "L",
+		const std::string& n12 = "M")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
+			_pNames->push_back(n10); 
+			_pNames->push_back(n11); 
+			_pNames->push_back(n12); 
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0, 
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9,
+	class T10,
+	class T11>
+struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,NullTypeList>:
+	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>
+{
+	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> TupleType;
+	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::Type Type;
+
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11), 
+		_pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10), 
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		const std::string& n11 = "L",
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10,t11), 
+		_pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10,n11);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
+					case 10: return TupleType::template get<10>();
+					case 11: return TupleType::template get<11>();
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K",
+		const std::string& n11 = "L")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
+			_pNames->push_back(n10); 
+			_pNames->push_back(n11); 
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0, 
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9,
+	class T10>
+struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,NullTypeList>:
+	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
+{
+	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> TupleType;
+	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::Type Type;
+
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10), 
+		_pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9), 
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		const std::string& n10 = "K",
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10)): 
+	TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9,t10), _pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9,n10);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
+					case 10: return TupleType::template get<10>();
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J",
+		const std::string& n10 = "K")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
+			_pNames->push_back(n10); 
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0, 
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8,
+	class T9>
+struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,NullTypeList>:
+	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>
+{
+	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> TupleType;
+	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>::Type Type;
+
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9), 
+		_pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8), 
+		const std::string& n9 = "J",
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8,t9), 
+		_pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8,n9);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					case 9: return TupleType::template get<9>();
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I",
+		const std::string& n9 = "J")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+			_pNames->push_back(n9); 
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0, 
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7, 
+	class T8>
+struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,NullTypeList>:
+	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8>
+{
+	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8> TupleType;
+	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8>::Type Type;
+
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8), 
+		_pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		const std::string& n8 = "I",
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7,t8), 
+		_pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7,n8);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					case 8: return TupleType::template get<8>();
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H",
+		const std::string& n8 = "I")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+			_pNames->push_back(n8);
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0, 
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7>
+struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,NullTypeList>:
+	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7>
+{
+	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7> TupleType;
+	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6,T7>::Type Type;
+
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7), 
+		_pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6), 
+		const std::string& n7 = "H",
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7)): 
+		TupleType(t0,t1,t2,t3,t4,t5,t6,t7), 
+		_pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5,n6,n7);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					case 7: return TupleType::template get<7>(); 
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G",
+		const std::string& n7 = "H")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+			_pNames->push_back(n7);
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0, 
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6>
+struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,NullTypeList>:
+	public Tuple<T0,T1,T2,T3,T4,T5,T6>
+{
+	typedef Tuple<T0,T1,T2,T3,T4,T5,T6> TupleType;
+	typedef typename Tuple<T0,T1,T2,T3,T4,T5,T6>::Type Type;
+
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6)): 
+	TupleType(t0,t1,t2,t3,t4,t5,t6), _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5), 
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6)): 
+	TupleType(t0,t1,t2,t3,t4,t5,t6)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		const std::string& n6 = "G",
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6)): 
+	TupleType(t0,t1,t2,t3,t4,t5,t6), _pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5,n6);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					case 6: return TupleType::template get<6>();
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F", 
+		const std::string& n6 = "G")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+			_pNames->push_back(n6);
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0, 
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5>
+struct NamedTuple<T0,T1,T2,T3,T4,T5,NullTypeList>:
+	public Tuple<T0,T1,T2,T3,T4,T5>
+{
+	typedef Tuple<T0,T1,T2,T3,T4,T5> TupleType;
+	typedef typename Tuple<T0,T1,T2,T3,T4,T5>::Type Type;
+
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5)): 
+	TupleType(t0,t1,t2,t3,t4,t5), _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5)): 
+	TupleType(t0,t1,t2,t3,t4,t5)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4), 
+		const std::string& n5 = "F",
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5)): 
+	TupleType(t0,t1,t2,t3,t4,t5), _pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4,n5);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					case 5: return TupleType::template get<5>();
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E",
+		const std::string& n5 = "F")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+			_pNames->push_back(n5);
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0, 
+	class T1,
+	class T2,
+	class T3,
+	class T4>
+struct NamedTuple<T0,T1,T2,T3,T4,NullTypeList>:
+	public Tuple<T0,T1,T2,T3,T4>
+{
+	typedef Tuple<T0,T1,T2,T3,T4> TupleType;
+	typedef typename Tuple<T0,T1,T2,T3,T4>::Type Type;
+
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4)): 
+		TupleType(t0,t1,t2,t3,t4), 
+		_pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4)): 
+		TupleType(t0,t1,t2,t3,t4)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		const std::string& n4 = "E",
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4)): 
+		TupleType(t0,t1,t2,t3,t4), 
+		_pNames(0) 
+	{
+		init(n0,n1,n2,n3,n4);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					case 4: return TupleType::template get<4>();
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D",
+		const std::string& n4 = "E")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+			_pNames->push_back(n4);
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0, 
+	class T1,
+	class T2,
+	class T3>
+struct NamedTuple<T0,T1,T2,T3,NullTypeList>:
+	public Tuple<T0,T1,T2,T3>
+{
+	typedef Tuple<T0,T1,T2,T3> TupleType;
+	typedef typename Tuple<T0,T1,T2,T3>::Type Type;
+
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3)): 
+		TupleType(t0,t1,t2,t3), 
+		_pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3)): 
+		TupleType(t0,t1,t2,t3)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2), 
+		const std::string& n3 = "D",
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3)): 
+	TupleType(t0,t1,t2,t3), _pNames(0) 
+	{
+		init(n0,n1,n2,n3);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					case 3: return TupleType::template get<3>(); 
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C",
+		const std::string& n3 = "D")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+			_pNames->push_back(n3); 
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0, 
+	class T1,
+	class T2>
+struct NamedTuple<T0,T1,T2,NullTypeList>:
+	public Tuple<T0,T1,T2>
+{
+	typedef Tuple<T0,T1,T2> TupleType;
+	typedef typename Tuple<T0,T1,T2>::Type Type;
+
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1), 
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2)): 
+		TupleType(t0,t1,t2), 
+		_pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2)): 
+		TupleType(t0,t1,t2)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		const std::string& n2 = "C",
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2)): 
+		TupleType(t0,t1,t2), 
+		_pNames(0) 
+	{
+		init(n0,n1,n2);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					case 2: return TupleType::template get<2>();
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B",
+		const std::string& n2 = "C")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+			_pNames->push_back(n2);
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0, 
+	class T1>
+struct NamedTuple<T0,T1,NullTypeList>:
+	public Tuple<T0,T1>
+{
+	typedef Tuple<T0,T1> TupleType;
+	typedef typename Tuple<T0,T1>::Type Type;
+
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1)): 
+		TupleType(t0,t1), 
+		_pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1)): 
+		TupleType(t0,t1)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0,
+		typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		const std::string& n1 = "B",
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1)): 
+		TupleType(t0,t1), 
+		_pNames(0) 
+	{
+		init(n0,n1);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					case 1: return TupleType::template get<1>();
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A",
+		const std::string& n1 = "B")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+			_pNames->push_back(n1);
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+template<class T0>
+struct NamedTuple<T0,NullTypeList>:
+	public Tuple<T0>
+{
+	typedef Tuple<T0> TupleType;
+	typedef typename Tuple<T0>::Type Type;
+
+	typedef std::vector<std::string> NameVec; 
+	typedef SharedPtr<NameVec> NameVecPtr; 
+
+	NamedTuple(): _pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames) 
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(typename TypeWrapper<T0>::CONSTTYPE& t0): 
+		TupleType(t0), 
+		_pNames(0)
+	{
+		init();
+	}
+
+	NamedTuple(const NameVecPtr& rNames, 
+		typename TypeWrapper<T0>::CONSTTYPE& t0): 
+		TupleType(t0)
+	{
+		if (rNames->size() != TupleType::length)
+			throw InvalidArgumentException("Wrong names vector length."); 
+
+		_pNames = rNames;
+	}
+
+	NamedTuple(const std::string& n0, typename TypeWrapper<T0>::CONSTTYPE& t0): 
+		TupleType(t0), 
+		_pNames(0) 
+	{
+		init(n0);
+	}
+
+	const DynamicAny get(const std::string& name) const
+	{
+		NameVec::const_iterator it = _pNames->begin(); 
+		NameVec::const_iterator itEnd = _pNames->end();
+
+		for(std::size_t counter = 0; it != itEnd; ++it, ++counter)
+		{
+			if (name == *it)
+			{
+				switch (counter)
+				{ 
+					case 0: return TupleType::template get<0>();
+					default: throw RangeException();
+				}
+			}
+		} 
+
+		throw NotFoundException("Name not found: " + name);
+	}
+
+	const DynamicAny operator [] (const std::string& name) const
+	{
+		return get(name);
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const 
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return TupleType::template get<N>();
+	}
+
+	template<int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		return TupleType::template set<N>(val);
+	}
+
+	const NameVecPtr& names()
+	{
+		return _pNames; 
+	}
+
+	void setName(std::size_t index, const std::string& name)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		(*_pNames)[index] = name;
+	}
+
+	const std::string& getName(std::size_t index)
+	{
+		if (index >= _pNames->size())
+			throw InvalidArgumentException(format("Invalid index: %z", index));
+
+		return (*_pNames)[index];
+	}
+
+	bool operator == (const NamedTuple& other) const
+	{
+		return TupleType(*this) == TupleType(other) && _pNames == other._pNames;
+	}
+
+	bool operator != (const NamedTuple& other) const 
+	{
+		return !(*this == other);
+	}
+
+	bool operator < (const NamedTuple& other) const
+	{
+		TupleType th(*this);
+		TupleType oth(other); 
+
+		return (th < oth && _pNames == other._pNames) || 
+			(th == oth && _pNames < other._pNames) ||
+			(th < oth && _pNames < other._pNames);
+	}
+
+private:
+	void init(const std::string& n0 = "A")
+	{ 
+		if (!_pNames)
+		{
+			_pNames = new NameVec;
+			_pNames->push_back(n0);
+		}
+	}
+
+	NameVecPtr _pNames;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Tuple_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NestedDiagnosticContext.h b/base/poco/Foundation/include/Poco/NestedDiagnosticContext.h
new file mode 100644
index 00000000000..ccb29a56a96
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NestedDiagnosticContext.h
@@ -0,0 +1,181 @@
+//
+// NestedDiagnosticContext.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  NestedDiagnosticContext
+//
+// Definition of the NestedDiagnosticContext class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NestedDiagnosticContext_INCLUDED
+#define Foundation_NestedDiagnosticContext_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <vector>
+#include <ostream>
+
+
+namespace Poco {
+
+
+class NDCScope;
+
+
+class Foundation_API NestedDiagnosticContext
+	/// This class implements a Nested Diagnostic Context (NDC),
+	/// as described in Neil Harrison's article "Patterns for Logging 
+	/// Diagnostic Messages" in "Pattern Languages of Program Design 3"
+	/// (Addison-Wesley).
+	///
+	/// A NDC maintains a stack of context information, consisting of
+	/// an informational string (e.g., a method name), as well as an
+	/// optional source code line number and file name.
+	/// NDCs are especially useful for tagging log messages with
+	/// context information which is very helpful in a multithreaded
+	/// server scenario.
+	/// Every thread has its own private NDC, which is automatically
+	/// created when needed and destroyed when the thread terminates.
+	///
+	/// The NDCScope (or NDC::Scope) class can be used to automatically
+	/// push information at the beginning of a scope, and to pop it
+	/// at the end.
+	/// The poco_ndc(info) macro augments the information with a
+	/// source code line number and file name.
+{
+public:
+	typedef NDCScope Scope;
+
+	NestedDiagnosticContext();
+		/// Creates the NestedDiagnosticContext.
+
+	NestedDiagnosticContext(const NestedDiagnosticContext& ctx);
+		/// Copy constructor.
+
+	~NestedDiagnosticContext();
+		/// Destroys the NestedDiagnosticContext.
+		
+	NestedDiagnosticContext& operator = (const NestedDiagnosticContext& ctx);
+		/// Assignment operator.
+		
+	void push(const std::string& info);
+		/// Pushes a context (without line number and filename) onto the stack.
+		
+	void push(const std::string& info, int line, const char* filename);
+		/// Pushes a context (including line number and filename) 
+		/// onto the stack. Filename must be a static string, such as the
+		/// one produced by the __FILE__ preprocessor macro.
+
+	void pop();
+		/// Pops the top-most context off the stack.
+		
+	int depth() const;
+		/// Returns the depth (number of contexts) of the stack.
+	
+	std::string toString() const;
+		/// Returns the stack as a string with entries
+		/// delimited by colons. The string does not contain
+		/// line numbers and filenames.
+		
+	void dump(std::ostream& ostr) const;
+		/// Dumps the stack (including line number and filenames)
+		/// to the given stream. The entries are delimited by
+		/// a newline.
+
+	void dump(std::ostream& ostr, const std::string& delimiter) const;
+		/// Dumps the stack (including line number and filenames)
+		/// to the given stream.
+		
+	void clear();
+		/// Clears the NDC stack.
+	
+	static NestedDiagnosticContext& current();
+		/// Returns the current thread's NDC.
+
+private:
+	struct Context
+	{
+		std::string info;
+		const char* file;
+		int         line;
+	};
+	typedef std::vector<Context> Stack;
+	
+	Stack _stack;
+};
+
+
+typedef NestedDiagnosticContext NDC;
+
+
+class Foundation_API NDCScope
+	/// This class can be used to automatically push a context onto
+	/// the NDC stack at the beginning of a scope, and to pop
+	/// the context at the end of the scope.
+{
+public:
+	NDCScope(const std::string& info);
+		/// Pushes a context on the stack.
+		
+	NDCScope(const std::string& info, int line, const char* filename);
+		/// Pushes a context on the stack.
+
+	~NDCScope();
+		/// Pops the top-most context off the stack.
+};
+
+
+//
+// inlines
+//
+inline NDCScope::NDCScope(const std::string& info)
+{
+	NestedDiagnosticContext::current().push(info);
+}
+
+	
+inline NDCScope::NDCScope(const std::string& info, int line, const char* filename)
+{
+	NestedDiagnosticContext::current().push(info, line, filename);
+}
+
+
+inline NDCScope::~NDCScope()
+{
+	try
+	{
+		NestedDiagnosticContext::current().pop();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+//
+// helper macros
+//
+#define poco_ndc(func) \
+	Poco::NDCScope _theNdcScope(#func, __LINE__, __FILE__)
+
+
+#if defined(_DEBUG)
+	#define poco_ndc_dbg(func) \
+		Poco::NDCScope _theNdcScope(#func, __LINE__, __FILE__)
+#else
+	#define poco_ndc_dbg(func)
+#endif
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NestedDiagnosticContext_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Notification.h b/base/poco/Foundation/include/Poco/Notification.h
new file mode 100644
index 00000000000..f5f20a1ccd8
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Notification.h
@@ -0,0 +1,55 @@
+//
+// Notification.h
+//
+// Library: Foundation
+// Package: Notifications
+// Module:  Notification
+//
+// Definition of the Notification class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Notification_INCLUDED
+#define Foundation_Notification_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Mutex.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Notification: public RefCountedObject
+	/// The base class for all notification classes used
+	/// with the NotificationCenter and the NotificationQueue
+	/// classes.
+	/// The Notification class can be used with the AutoPtr
+	/// template class.
+{
+public:
+	typedef AutoPtr<Notification> Ptr;
+	
+	Notification();
+		/// Creates the notification.
+
+	virtual std::string name() const;
+		/// Returns the name of the notification.
+		/// The default implementation returns the class name.
+
+protected:
+	virtual ~Notification();
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Notification_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NotificationCenter.h b/base/poco/Foundation/include/Poco/NotificationCenter.h
new file mode 100644
index 00000000000..411bba8944f
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NotificationCenter.h
@@ -0,0 +1,139 @@
+//
+// NotificationCenter.h
+//
+// Library: Foundation
+// Package: Notifications
+// Module:  NotificationCenter
+//
+// Definition of the NotificationCenter class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NotificationCenter_INCLUDED
+#define Foundation_NotificationCenter_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Notification.h"
+#include "Poco/Mutex.h"
+#include "Poco/SharedPtr.h"
+#include <vector>
+#include <cstddef>
+
+
+namespace Poco {
+
+
+class AbstractObserver;
+
+
+class Foundation_API NotificationCenter
+	/// A NotificationCenter is essentially a notification dispatcher. 
+	/// It notifies all observers of notifications meeting specific criteria.
+	/// This information is encapsulated in Notification objects.
+	/// Client objects register themselves with the notification center as observers of 
+	/// specific notifications posted by other objects. When an event occurs, an object 
+	/// posts an appropriate notification to the notification center. The notification  
+	/// center invokes the registered method on each matching observer, passing the notification 
+	/// as argument.
+	///
+	/// The order in which observers receive notifications is undefined. 
+	/// It is possible for the posting object and the observing object to be the same.
+	/// The NotificationCenter delivers notifications to observers synchronously. 
+	/// In other words the postNotification() method does not return until all observers have 
+	/// received and processed the notification. 
+	/// If an observer throws an exception while handling a notification, the NotificationCenter
+	/// stops dispatching the notification and postNotification() rethrows the exception.
+	///
+	/// In a multithreaded scenario, notifications are always delivered in the thread in which the 
+	/// notification was posted, which may not be the same thread in which an observer registered itself.
+	///
+	/// The NotificationCenter class is basically a C++ implementation of the NSNotificationCenter class
+	/// found in Apple's Cocoa (or OpenStep).
+	///
+	/// While handling a notification, an observer can unregister itself from the notification center,
+	/// or it can register or unregister other observers. Observers added during a dispatch cycle
+	/// will not receive the current notification.
+	///
+	/// The method receiving the notification must be implemented as
+	///     void handleNotification(MyNotification* pNf);
+	/// The handler method gets co-ownership of the Notification object
+	/// and must release it when done. This is best done with an AutoPtr:
+	///     void MyClass::handleNotification(MyNotification* pNf)
+	///     {
+	///         AutoPtr<MyNotification> nf(pNf);
+	///         ...
+	///     }
+	///
+	/// Alternatively, the NObserver class template can be used to register a callback
+	/// method. In this case, the callback method receives the Notification in an
+	/// AutoPtr and thus does not have to deal with object ownership issues:
+	///     void MyClass::handleNotification(const AutoPtr<MyNotification>& pNf)
+	///     {
+	///         ...
+	///     }
+{
+public:
+	NotificationCenter();
+		/// Creates the NotificationCenter.
+
+	~NotificationCenter();
+		/// Destroys the NotificationCenter.
+
+	void addObserver(const AbstractObserver& observer);
+		/// Registers an observer with the NotificationCenter.
+		/// Usage:
+		///     Observer<MyClass, MyNotification> obs(*this, &MyClass::handleNotification);
+		///     notificationCenter.addObserver(obs);
+		///
+		/// Alternatively, the NObserver template class can be used instead of Observer.
+
+	void removeObserver(const AbstractObserver& observer);
+		/// Unregisters an observer with the NotificationCenter.
+
+	bool hasObserver(const AbstractObserver& observer) const;
+		/// Returns true if the observer is registered with this NotificationCenter.
+
+	void postNotification(Notification::Ptr pNotification);
+		/// Posts a notification to the NotificationCenter.
+		/// The NotificationCenter then delivers the notification
+		/// to all interested observers.
+		/// If an observer throws an exception, dispatching terminates
+		/// and the exception is rethrown to the caller.
+		/// Ownership of the notification object is claimed and the
+		/// notification is released before returning. Therefore,
+		/// a call like
+		///    notificationCenter.postNotification(new MyNotification);
+		/// does not result in a memory leak.
+
+	bool hasObservers() const;
+		/// Returns true iff there is at least one registered observer.
+		///
+		/// Can be used to improve performance if an expensive notification
+		/// shall only be created and posted if there are any observers.
+		
+	std::size_t countObservers() const;
+		/// Returns the number of registered observers.
+		
+	static NotificationCenter& defaultCenter();
+		/// Returns a reference to the default
+		/// NotificationCenter.
+
+private:
+	typedef SharedPtr<AbstractObserver> AbstractObserverPtr;
+	typedef std::vector<AbstractObserverPtr> ObserverList;
+
+	ObserverList  _observers;
+	mutable Mutex _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NotificationCenter_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NotificationQueue.h b/base/poco/Foundation/include/Poco/NotificationQueue.h
new file mode 100644
index 00000000000..3194dddd4db
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NotificationQueue.h
@@ -0,0 +1,155 @@
+//
+// NotificationQueue.h
+//
+// Library: Foundation
+// Package: Notifications
+// Module:  NotificationQueue
+//
+// Definition of the NotificationQueue class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NotificationQueue_INCLUDED
+#define Foundation_NotificationQueue_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Notification.h"
+#include "Poco/Mutex.h"
+#include "Poco/Event.h"
+#include <deque>
+
+
+namespace Poco {
+
+
+class NotificationCenter;
+
+
+class Foundation_API NotificationQueue
+	/// A NotificationQueue object provides a way to implement asynchronous
+	/// notifications. This is especially useful for sending notifications
+	/// from one thread to another, for example from a background thread to 
+	/// the main (user interface) thread. 
+	/// 
+	/// The NotificationQueue can also be used to distribute work from
+	/// a controlling thread to one or more worker threads. Each worker thread
+	/// repeatedly calls waitDequeueNotification() and processes the
+	/// returned notification. Special care must be taken when shutting
+	/// down a queue with worker threads waiting for notifications.
+	/// The recommended sequence to shut down and destroy the queue is to
+	///   1. set a termination flag for every worker thread
+	///   2. call the wakeUpAll() method
+	///   3. join each worker thread
+	///   4. destroy the notification queue.
+{
+public:
+	NotificationQueue();
+		/// Creates the NotificationQueue.
+
+	~NotificationQueue();
+		/// Destroys the NotificationQueue.
+
+	void enqueueNotification(Notification::Ptr pNotification);
+		/// Enqueues the given notification by adding it to
+		/// the end of the queue (FIFO).
+		/// The queue takes ownership of the notification, thus
+		/// a call like
+		///     notificationQueue.enqueueNotification(new MyNotification);
+		/// does not result in a memory leak.
+		
+	void enqueueUrgentNotification(Notification::Ptr pNotification);
+		/// Enqueues the given notification by adding it to
+		/// the front of the queue (LIFO). The event therefore gets processed
+		/// before all other events already in the queue.
+		/// The queue takes ownership of the notification, thus
+		/// a call like
+		///     notificationQueue.enqueueUrgentNotification(new MyNotification);
+		/// does not result in a memory leak.
+
+	Notification* dequeueNotification();
+		/// Dequeues the next pending notification.
+		/// Returns 0 (null) if no notification is available.
+		/// The caller gains ownership of the notification and
+		/// is expected to release it when done with it.
+		///
+		/// It is highly recommended that the result is immediately
+		/// assigned to a Notification::Ptr, to avoid potential
+		/// memory management issues.
+
+	Notification* waitDequeueNotification();
+		/// Dequeues the next pending notification.
+		/// If no notification is available, waits for a notification
+		/// to be enqueued. 
+		/// The caller gains ownership of the notification and
+		/// is expected to release it when done with it.
+		/// This method returns 0 (null) if wakeUpWaitingThreads()
+		/// has been called by another thread.
+		///
+		/// It is highly recommended that the result is immediately
+		/// assigned to a Notification::Ptr, to avoid potential
+		/// memory management issues.
+
+	Notification* waitDequeueNotification(long milliseconds);
+		/// Dequeues the next pending notification.
+		/// If no notification is available, waits for a notification
+		/// to be enqueued up to the specified time.
+		/// Returns 0 (null) if no notification is available.
+		/// The caller gains ownership of the notification and
+		/// is expected to release it when done with it.
+		///
+		/// It is highly recommended that the result is immediately
+		/// assigned to a Notification::Ptr, to avoid potential
+		/// memory management issues.
+
+	void dispatch(NotificationCenter& notificationCenter);
+		/// Dispatches all queued notifications to the given
+		/// notification center.
+
+	void wakeUpAll();
+		/// Wakes up all threads that wait for a notification.
+	
+	bool empty() const;
+		/// Returns true iff the queue is empty.
+		
+	int size() const;
+		/// Returns the number of notifications in the queue.
+
+	void clear();
+		/// Removes all notifications from the queue.
+		
+	bool hasIdleThreads() const;	
+		/// Returns true if the queue has at least one thread waiting 
+		/// for a notification.
+		
+	static NotificationQueue& defaultQueue();
+		/// Returns a reference to the default
+		/// NotificationQueue.
+
+protected:
+	Notification::Ptr dequeueOne();
+	
+private:
+	typedef std::deque<Notification::Ptr> NfQueue;
+	struct WaitInfo
+	{
+		Notification::Ptr pNf;
+		Event             nfAvailable;
+	};
+	typedef std::deque<WaitInfo*> WaitQueue;
+
+	NfQueue           _nfQueue;
+	WaitQueue         _waitQueue;
+	mutable FastMutex _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NotificationQueue_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NotificationStrategy.h b/base/poco/Foundation/include/Poco/NotificationStrategy.h
new file mode 100644
index 00000000000..d36fbe28b03
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NotificationStrategy.h
@@ -0,0 +1,112 @@
+//
+// NotificationStrategy.h
+//
+// Library: Foundation
+// Package: Events
+// Module:  NotificationStrategy
+//
+// Definition of the NotificationStrategy interface.
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NotificationStrategy_INCLUDED
+#define Foundation_NotificationStrategy_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+template <class TArgs, class TDelegate> 
+class NotificationStrategy
+	/// The interface that all notification strategies must implement.
+	/// 
+	/// Note: Event is based on policy-driven design, so every strategy implementation
+	/// must provide all the methods from this interface (otherwise: compile errors)
+	/// but does not need to inherit from NotificationStrategy.
+{
+public:
+	typedef TDelegate* DelegateHandle;
+
+	NotificationStrategy()
+	{
+	}
+
+	virtual ~NotificationStrategy()
+	{
+	}
+
+	virtual void notify(const void* sender, TArgs& arguments) = 0;
+		/// Sends a notification to all registered delegates.
+
+	virtual DelegateHandle add(const TDelegate& delegate) = 0;
+		/// Adds a delegate to the strategy.
+
+	virtual void remove(const TDelegate& delegate) = 0;
+		/// Removes a delegate from the strategy, if found.
+		/// Does nothing if the delegate has not been added.
+
+	virtual void remove(DelegateHandle delegateHandle) = 0;
+		/// Removes a delegate from the strategy, if found.
+		/// Does nothing if the delegate has not been added.
+
+	virtual void clear() = 0;
+		/// Removes all delegates from the strategy.
+
+	virtual bool empty() const = 0;
+		/// Returns false if the strategy contains at least one delegate.
+};
+
+
+template <class TDelegate> 
+class NotificationStrategy<void, TDelegate>
+	/// The interface that all notification strategies must implement.
+	/// 
+	/// Note: Event is based on policy-driven design, so every strategy implementation
+	/// must provide all the methods from this interface (otherwise: compile errors)
+	/// but does not need to inherit from NotificationStrategy.
+{
+public:
+	typedef TDelegate* DelegateHandle;
+
+	NotificationStrategy()
+	{
+	}
+
+	virtual ~NotificationStrategy()
+	{
+	}
+
+	virtual void notify(const void* sender) = 0;
+		/// Sends a notification to all registered delegates.
+
+	virtual DelegateHandle add(const TDelegate& delegate) = 0;
+		/// Adds a delegate to the strategy.
+
+	virtual void remove(const TDelegate& delegate) = 0;
+		/// Removes a delegate from the strategy, if found.
+		/// Does nothing if the delegate has not been added.
+
+	virtual void remove(DelegateHandle delegateHandle) = 0;
+		/// Removes a delegate from the strategy, if found.
+		/// Does nothing if the delegate has not been added.
+
+	virtual void clear() = 0;
+		/// Removes all delegates from the strategy.
+
+	virtual bool empty() const = 0;
+		/// Returns false if the strategy contains at least one delegate.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NotificationStrategy_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NullChannel.h b/base/poco/Foundation/include/Poco/NullChannel.h
new file mode 100644
index 00000000000..8384dcf4b61
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NullChannel.h
@@ -0,0 +1,55 @@
+//
+// NullChannel.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  NullChannel
+//
+// Definition of the NullChannel class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NullChannel_INCLUDED
+#define Foundation_NullChannel_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Channel.h"
+
+
+namespace Poco {
+
+
+class Foundation_API NullChannel: public Channel
+	/// The NullChannel is the /dev/null of Channels.
+	///
+	/// A NullChannel discards all information sent to it.
+	/// Furthermore, its setProperty() method ignores 
+	/// all properties, so it the NullChannel has the
+	/// nice feature that it can stand in for any
+	/// other channel class in a logging configuration.
+{
+public:
+	NullChannel();
+		/// Creates the NullChannel.
+
+	~NullChannel();
+		/// Destroys the NullChannel.
+
+	void log(const Message& msg);
+		/// Does nothing.
+
+	void setProperty(const std::string& name, const std::string& value);
+		/// Ignores both name and value.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NullChannel_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NullStream.h b/base/poco/Foundation/include/Poco/NullStream.h
new file mode 100644
index 00000000000..52c292dff53
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NullStream.h
@@ -0,0 +1,90 @@
+//
+// NullStream.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  NullStream
+//
+// Definition of the NullStreamBuf, NullInputStream and NullOutputStream classes.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NullStream_INCLUDED
+#define Foundation_NullStream_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+
+
+class Foundation_API NullStreamBuf: public UnbufferedStreamBuf
+	/// This stream buffer discards all characters written to it.
+	/// Any read operation immediately yields EOF.
+{
+public:
+	NullStreamBuf();
+		/// Creates a NullStreamBuf.
+	
+	~NullStreamBuf();
+		/// Destroys the NullStreamBuf.
+		
+protected:
+	int readFromDevice();
+	int writeToDevice(char c);
+};
+
+
+class Foundation_API NullIOS: public virtual std::ios
+	/// The base class for NullInputStream and NullOutputStream.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	NullIOS();
+	~NullIOS();
+
+protected:
+	NullStreamBuf _buf;
+};
+
+
+class Foundation_API NullInputStream: public NullIOS, public std::istream
+	/// Any read operation from this stream immediately
+	/// yields EOF.
+{
+public:
+	NullInputStream();
+		/// Creates the NullInputStream.
+
+	~NullInputStream();
+		/// Destroys the NullInputStream.
+};
+
+
+class Foundation_API NullOutputStream: public NullIOS, public std::ostream
+	/// This stream discards all characters written to it.
+{
+public:
+	NullOutputStream();
+		/// Creates the NullOutputStream.
+	
+	~NullOutputStream();
+		/// Destroys the NullOutputStream.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NullStream_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Nullable.h b/base/poco/Foundation/include/Poco/Nullable.h
new file mode 100644
index 00000000000..d113256cf2a
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Nullable.h
@@ -0,0 +1,323 @@
+//
+// Nullable.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Nullable
+//
+// Definition of the Nullable template class.
+//
+// Copyright (c) 2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Nullable_INCLUDED
+#define Foundation_Nullable_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include <algorithm>
+#include <iostream>
+
+
+namespace Poco {
+
+
+enum NullType
+{
+	NULL_GENERIC = 0
+};
+
+
+template <typename C>
+class Nullable
+	/// Nullable is a simple wrapper class for value types
+	/// that allows objects or native type variables 
+	/// to have "null" value.
+	///
+	/// The class is useful for passing parameters to functions
+	/// when parameters are optional and no default values 
+	/// should be used or when a non-assigned state is needed,
+	/// such as in e.g. fetching null values from database.
+	///
+	/// A Nullable can be default constructed. In this case, 
+	/// the Nullable will have a Null value and isNull() will
+	/// return true. Calling value() (without default value) on
+	/// a Null object will throw a NullValueException.
+	///
+	/// A Nullable can also be constructed from a value.
+	/// It is possible to assign a value to a Nullable, and
+	/// to reset a Nullable to contain a Null value by calling
+	/// clear().
+	///
+	/// For use with Nullable, the value type should support
+	/// default construction.
+{
+public:
+	Nullable(): 
+		/// Creates an empty Nullable.
+		_value(),
+		_isNull(true),
+		_null()
+	{
+	}
+
+	Nullable(const NullType&): 
+		/// Creates an empty Nullable.
+		_value(),
+		_isNull(true),
+		_null()
+	{
+	}
+
+	Nullable(const C& value): 
+		/// Creates a Nullable with the given value.
+		_value(value), 
+		_isNull(false),
+		_null()
+	{
+	}
+	
+	Nullable(const Nullable& other):
+		/// Creates a Nullable by copying another one.
+		_value(other._value),
+		_isNull(other._isNull),
+		_null()
+	{
+	}
+
+	~Nullable()
+		/// Destroys the Nullable.
+	{
+	}
+
+	Nullable& assign(const C& value)
+		/// Assigns a value to the Nullable.
+	{
+		_value  = value;
+		_isNull = false;
+		return *this;
+	}
+	
+	Nullable& assign(const Nullable& other)
+		/// Assigns another Nullable.
+	{
+		Nullable tmp(other);
+		swap(tmp);
+		return *this;
+	}
+	
+	Nullable& assign(NullType)
+		/// Sets value to null.
+	{
+		_isNull = true;
+		return *this;
+	}
+	
+	Nullable& operator = (const C& value)
+		/// Assigns a value to the Nullable.
+	{
+		return assign(value);
+	}
+
+	Nullable& operator = (const Nullable& other)
+		/// Assigns another Nullable.
+	{
+		return assign(other);
+	}
+
+	Nullable& operator = (NullType)
+		/// Assigns another Nullable.
+	{
+		_isNull = true;
+		return *this;
+	}
+
+	void swap(Nullable& other)
+		/// Swaps this Nullable with other.
+	{
+		std::swap(_value, other._value);
+		std::swap(_isNull, other._isNull);
+	}
+
+	bool operator == (const Nullable<C>& other) const
+		/// Compares two Nullables for equality
+	{
+		return (_isNull && other._isNull) || (_isNull == other._isNull && _value == other._value);
+	}
+
+	bool operator == (const C& value) const
+		/// Compares Nullable with value for equality
+	{
+		return (!_isNull && _value == value);
+	}
+
+	bool operator == (const NullType&) const
+		/// Compares Nullable with NullData for equality
+	{
+		return _isNull;
+	}
+
+	bool operator != (const C& value) const
+		/// Compares Nullable with value for non equality
+	{
+		return !(*this == value);
+	}
+
+	bool operator != (const Nullable<C>& other) const
+		/// Compares two Nullables for non equality
+	{
+		return !(*this == other);
+	}
+
+	bool operator != (const NullType&) const
+		/// Compares with NullData for non equality
+	{
+		return !_isNull;
+	}
+
+	bool operator < (const Nullable<C>& other) const
+		/// Compares two Nullable objects. Return true if this object's
+		/// value is smaler than the other object's value.
+		/// Null value is smaller than a non-null value.
+	{
+		if (_isNull && other._isNull) return false;
+
+		if (!_isNull && !other._isNull)
+			return (_value < other._value);
+
+		if (_isNull && !other._isNull) return true;
+
+		return false;
+	}
+
+	bool operator > (const Nullable<C>& other) const
+		/// Compares two Nullable objects. Return true if this object's
+		/// value is greater than the other object's value.
+		/// A non-null value is greater than a null value.
+	{
+		return !(*this == other) && !(*this < other);
+	}
+
+	C& value()
+		/// Returns the Nullable's value.
+		///
+		/// Throws a NullValueException if the Nullable is empty.
+	{
+		if (!_isNull)
+			return _value;
+		else
+			throw NullValueException();
+	}
+
+	const C& value() const
+		/// Returns the Nullable's value.
+		///
+		/// Throws a NullValueException if the Nullable is empty.
+	{
+		if (!_isNull)
+			return _value;
+		else
+			throw NullValueException();
+	}
+
+	const C& value(const C& deflt) const
+		/// Returns the Nullable's value, or the
+		/// given default value if the Nullable is empty.
+	{
+		return _isNull ? deflt : _value;
+	}
+
+	operator C& ()
+		/// Get reference to the value
+	{
+		return value();
+	}
+
+	operator const C& () const
+		/// Get const reference to the value
+	{
+		return value();
+	}
+
+	operator NullType& ()
+		/// Get reference to the value
+	{
+
+		return _null;
+	}
+
+	bool isNull() const
+		/// Returns true if the Nullable is empty.
+	{
+		return _isNull;
+	}
+	
+	void clear()
+		/// Clears the Nullable.
+	{
+		_isNull = true;
+	}
+
+private:
+	C        _value;
+	bool     _isNull;
+	NullType _null;
+};
+
+
+template <typename C>
+inline void swap(Nullable<C>& n1, Nullable<C>& n2)
+{
+	n1.swap(n2);
+}
+
+
+template <typename C>
+std::ostream& operator<<(std::ostream& out, const Nullable<C>& obj) 
+{
+	if (!obj.isNull()) out << obj.value();
+	return out;
+}
+
+
+template <typename C>
+bool operator == (const NullType&, const Nullable<C>& n)
+	/// Returns true if this Nullable is null.
+{
+	return n.isNull();
+}
+
+
+template <typename C>
+bool operator != (const C& c, const Nullable<C>& n)
+	/// Compares Nullable with value for non equality
+{
+	return !(n == c);
+}
+
+
+template <typename C>
+bool operator == (const C& c, const Nullable<C>& n)
+	/// Compares Nullable with NullData for equality
+{
+	return (n == c);
+}
+
+
+template <typename C>
+bool operator != (const NullType&, const Nullable<C>& n)
+	/// Returns true if this Nullable is not null.
+{
+	return !n.isNull();
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Nullable_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NumberFormatter.h b/base/poco/Foundation/include/Poco/NumberFormatter.h
new file mode 100644
index 00000000000..ff8d13c465b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NumberFormatter.h
@@ -0,0 +1,907 @@
+//
+// NumberFormatter.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  NumberFormatter
+//
+// Definition of the NumberFormatter class.
+//
+// Copyright (c) 2004-2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NumberFormatter_INCLUDED
+#define Foundation_NumberFormatter_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/NumericString.h"
+
+
+namespace Poco {
+
+
+class Foundation_API NumberFormatter
+	/// The NumberFormatter class provides static methods
+	/// for formatting numeric values into strings.
+	///
+	/// There are two kind of static member functions:
+	///    * format* functions return a std::string containing
+	///      the formatted value.
+	///    * append* functions append the formatted value to
+	///      an existing string.
+{
+public:
+	enum BoolFormat
+	{
+		FMT_TRUE_FALSE,
+		FMT_YES_NO,
+		FMT_ON_OFF
+	};
+
+	static const unsigned NF_MAX_INT_STRING_LEN = 32; // increase for 64-bit binary formatting support
+	static const unsigned NF_MAX_FLT_STRING_LEN = POCO_MAX_FLT_STRING_LEN;
+
+	static std::string format(int value);
+		/// Formats an integer value in decimal notation.
+
+	static std::string format(int value, int width);
+		/// Formats an integer value in decimal notation,
+		/// right justified in a field having at least
+		/// the specified width.
+
+	static std::string format0(int value, int width);
+		/// Formats an integer value in decimal notation,
+		/// right justified and zero-padded in a field
+		/// having at least the specified width.
+
+	static std::string formatHex(int value, bool prefix = false);
+		/// Formats an int value in hexadecimal notation.
+		/// If prefix is true, "0x" prefix is prepended to the 
+		/// resulting string.
+		/// The value is treated as unsigned.
+
+	static std::string formatHex(int value, int width, bool prefix = false);
+		/// Formats a int value in hexadecimal notation,
+		/// right justified and zero-padded in
+		/// a field having at least the specified width.
+		/// If prefix is true, "0x" prefix is prepended to the 
+		/// resulting string.
+		/// The value is treated as unsigned.
+
+	static std::string format(unsigned value);
+		/// Formats an unsigned int value in decimal notation.
+
+	static std::string format(unsigned value, int width);
+		/// Formats an unsigned long int in decimal notation,
+		/// right justified in a field having at least the
+		/// specified width.
+
+	static std::string format0(unsigned int value, int width);
+		/// Formats an unsigned int value in decimal notation,
+		/// right justified and zero-padded in a field having at
+		/// least the specified width.
+
+	static std::string formatHex(unsigned value, bool prefix = false);
+		/// Formats an unsigned int value in hexadecimal notation.
+		/// If prefix is true, "0x" prefix is prepended to the 
+		/// resulting string.
+
+	static std::string formatHex(unsigned value, int width, bool prefix = false);
+		/// Formats a int value in hexadecimal notation,
+		/// right justified and zero-padded in
+		/// a field having at least the specified width.
+		/// If prefix is true, "0x" prefix is prepended to the 
+		/// resulting string.
+
+	static std::string format(long value);
+		/// Formats a long value in decimal notation.
+
+	static std::string format(long value, int width);
+		/// Formats a long value in decimal notation,
+		/// right justified in a field having at least the
+		/// specified width.
+
+	static std::string format0(long value, int width);
+		/// Formats a long value in decimal notation,
+		/// right justified and zero-padded in a field
+		/// having at least the specified width.
+
+	static std::string formatHex(long value, bool prefix = false);
+		/// Formats an unsigned long value in hexadecimal notation.
+		/// If prefix is true, "0x" prefix is prepended to the 
+		/// resulting string.
+		/// The value is treated as unsigned.
+
+	static std::string formatHex(long value, int width, bool prefix = false);
+		/// Formats an unsigned long value in hexadecimal notation,
+		/// right justified and zero-padded in a field having at least the
+		/// specified width.
+		/// If prefix is true, "0x" prefix is prepended to the 
+		/// resulting string.
+		/// The value is treated as unsigned.
+
+	static std::string format(unsigned long value);
+		/// Formats an unsigned long value in decimal notation.
+
+	static std::string format(unsigned long value, int width);
+		/// Formats an unsigned long value in decimal notation,
+		/// right justified in a field having at least the specified
+		/// width.
+
+	static std::string format0(unsigned long value, int width);
+		/// Formats an unsigned long value in decimal notation,
+		/// right justified and zero-padded
+		/// in a field having at least the specified width.
+
+	static std::string formatHex(unsigned long value, bool prefix = false);
+		/// Formats an unsigned long value in hexadecimal notation.
+		/// If prefix is true, "0x" prefix is prepended to the 
+		/// resulting string.
+
+	static std::string formatHex(unsigned long value, int width, bool prefix = false);
+		/// Formats an unsigned long value in hexadecimal notation,
+		/// right justified and zero-padded in a field having at least the
+		/// specified width.
+		/// If prefix is true, "0x" prefix is prepended to the 
+		/// resulting string.
+
+#ifdef POCO_HAVE_INT64
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	static std::string format(long long value);
+		/// Formats a 64-bit integer value in decimal notation.
+
+	static std::string format(long long value, int width);
+		/// Formats a 64-bit integer value in decimal notation,
+		/// right justified in a field having at least the specified width.
+
+	static std::string format0(long long value, int width);
+		/// Formats a 64-bit integer value in decimal notation,
+		/// right justified and zero-padded in a field having at least
+		/// the specified width.
+
+	static std::string formatHex(long long value, bool prefix = false);
+		/// Formats a 64-bit integer value in hexadecimal notation.
+		/// If prefix is true, "0x" prefix is prepended to the 
+		/// resulting string.
+		/// The value is treated as unsigned.
+
+	static std::string formatHex(long long value, int width, bool prefix = false);
+		/// Formats a 64-bit integer value in hexadecimal notation,
+		/// right justified and zero-padded in a field having at least
+		/// the specified width.
+		/// The value is treated as unsigned.
+		/// If prefix is true, "0x" prefix is prepended to the resulting string.
+
+	static std::string format(unsigned long long value);
+		/// Formats an unsigned 64-bit integer value in decimal notation.
+
+	static std::string format(unsigned long long value, int width);
+		/// Formats an unsigned 64-bit integer value in decimal notation,
+		/// right justified in a field having at least the specified width.
+
+	static std::string format0(unsigned long long value, int width);
+		/// Formats an unsigned 64-bit integer value in decimal notation,
+		/// right justified and zero-padded in a field having at least the
+		/// specified width.
+
+	static std::string formatHex(unsigned long long value, bool prefix = false);
+		/// Formats a 64-bit integer value in hexadecimal notation.
+		/// If prefix is true, "0x" prefix is prepended to the 
+		/// resulting string.
+
+	static std::string formatHex(unsigned long long value, int width, bool prefix = false);
+		/// Formats a 64-bit integer value in hexadecimal notation,
+		/// right justified and zero-padded in a field having at least
+		/// the specified width. If prefix is true, "0x" prefix is
+		/// prepended to the resulting string.
+
+#else // ifndef POCO_LONG_IS_64_BIT
+
+	static std::string format(Int64 value);
+		/// Formats a 64-bit integer value in decimal notation.
+
+	static std::string format(Int64 value, int width);
+		/// Formats a 64-bit integer value in decimal notation,
+		/// right justified in a field having at least the specified width.
+
+	static std::string format0(Int64 value, int width);
+		/// Formats a 64-bit integer value in decimal notation,
+		/// right justified and zero-padded in a field having at least
+		/// the specified width.
+
+	static std::string formatHex(Int64 value, bool prefix = false);
+		/// Formats a 64-bit integer value in hexadecimal notation.
+		/// If prefix is true, "0x" prefix is prepended to the 
+		/// resulting string.
+		/// The value is treated as unsigned.
+
+	static std::string formatHex(Int64 value, int width, bool prefix = false);
+		/// Formats a 64-bit integer value in hexadecimal notation,
+		/// right justified and zero-padded in a field having at least
+		/// the specified width.
+		/// The value is treated as unsigned.
+		/// If prefix is true, "0x" prefix is prepended to the resulting string.
+
+	static std::string format(UInt64 value);
+		/// Formats an unsigned 64-bit integer value in decimal notation.
+
+	static std::string format(UInt64 value, int width);
+		/// Formats an unsigned 64-bit integer value in decimal notation,
+		/// right justified in a field having at least the specified width.
+
+	static std::string format0(UInt64 value, int width);
+		/// Formats an unsigned 64-bit integer value in decimal notation,
+		/// right justified and zero-padded in a field having at least the
+		/// specified width.
+
+	static std::string formatHex(UInt64 value, bool prefix = false);
+		/// Formats a 64-bit integer value in hexadecimal notation.
+		/// If prefix is true, "0x" prefix is prepended to the 
+		/// resulting string.
+
+	static std::string formatHex(UInt64 value, int width, bool prefix = false);
+		/// Formats a 64-bit integer value in hexadecimal notation,
+		/// right justified and zero-padded in a field having at least
+		/// the specified width. If prefix is true, "0x" prefix is
+		/// prepended to the resulting string.
+
+#endif // ifdef POCO_LONG_IS_64_BIT
+
+#endif // ifdef POCO_HAVE_INT64
+
+	static std::string format(float value);
+		/// Formats a float value in decimal floating-point notation,
+		/// according to std::printf's %g format with a precision of 8 fractional digits.
+
+	static std::string format(float value, int precision);
+		/// Formats a double value in decimal floating-point notation,
+		/// according to std::printf's %f format with the given precision.
+
+	static std::string format(float value, int width, int precision);
+		/// Formats a double value in decimal floating-point notation,
+		/// right justified in a field of the specified width,
+		/// with the number of fractional digits given in precision.
+
+	static std::string format(double value);
+		/// Formats a double value in decimal floating-point notation,
+		/// according to std::printf's %g format with a precision of 16 fractional digits.
+
+	static std::string format(double value, int precision);
+		/// Formats a double value in decimal floating-point notation,
+		/// according to std::printf's %f format with the given precision.
+
+	static std::string format(double value, int width, int precision);
+		/// Formats a double value in decimal floating-point notation,
+		/// right justified in a field of the specified width,
+		/// with the number of fractional digits given in precision.
+
+	static std::string format(const void* ptr);
+		/// Formats a pointer in an eight (32-bit architectures) or
+		/// sixteen (64-bit architectures) characters wide
+		/// field in hexadecimal notation.
+
+	static std::string format(bool value, BoolFormat format = FMT_TRUE_FALSE);
+		/// Formats a bool value in decimal/text notation,
+		/// according to format parameter.
+
+	static void append(std::string& str, int value);
+		/// Formats an integer value in decimal notation.
+
+	static void append(std::string& str, int value, int width);
+		/// Formats an integer value in decimal notation,
+		/// right justified in a field having at least
+		/// the specified width.
+
+	static void append0(std::string& str, int value, int width);
+		/// Formats an integer value in decimal notation,
+		/// right justified and zero-padded in a field
+		/// having at least the specified width.
+
+	static void appendHex(std::string& str, int value);
+		/// Formats an int value in hexadecimal notation.
+		/// The value is treated as unsigned.
+
+	static void appendHex(std::string& str, int value, int width);
+		/// Formats a int value in hexadecimal notation,
+		/// right justified and zero-padded in
+		/// a field having at least the specified width.
+		/// The value is treated as unsigned.
+
+	static void append(std::string& str, unsigned value);
+		/// Formats an unsigned int value in decimal notation.
+
+	static void append(std::string& str, unsigned value, int width);
+		/// Formats an unsigned long int in decimal notation,
+		/// right justified in a field having at least the
+		/// specified width.
+
+	static void append0(std::string& str, unsigned int value, int width);
+		/// Formats an unsigned int value in decimal notation,
+		/// right justified and zero-padded in a field having at
+		/// least the specified width.
+
+	static void appendHex(std::string& str, unsigned value);
+		/// Formats an unsigned int value in hexadecimal notation.
+
+	static void appendHex(std::string& str, unsigned value, int width);
+		/// Formats a int value in hexadecimal notation,
+		/// right justified and zero-padded in
+		/// a field having at least the specified width.
+
+	static void append(std::string& str, long value);
+		/// Formats a long value in decimal notation.
+
+	static void append(std::string& str, long value, int width);
+		/// Formats a long value in decimal notation,
+		/// right justified in a field having at least the
+		/// specified width.
+
+	static void append0(std::string& str, long value, int width);
+		/// Formats a long value in decimal notation,
+		/// right justified and zero-padded in a field
+		/// having at least the specified width.
+
+	static void appendHex(std::string& str, long value);
+		/// Formats an unsigned long value in hexadecimal notation.
+		/// The value is treated as unsigned.
+
+	static void appendHex(std::string& str, long value, int width);
+		/// Formats an unsigned long value in hexadecimal notation,
+		/// right justified and zero-padded in a field having at least the
+		/// specified width.
+		/// The value is treated as unsigned.
+
+	static void append(std::string& str, unsigned long value);
+		/// Formats an unsigned long value in decimal notation.
+
+	static void append(std::string& str, unsigned long value, int width);
+		/// Formats an unsigned long value in decimal notation,
+		/// right justified in a field having at least the specified
+		/// width.
+
+	static void append0(std::string& str, unsigned long value, int width);
+		/// Formats an unsigned long value in decimal notation,
+		/// right justified and zero-padded
+		/// in a field having at least the specified width.
+
+	static void appendHex(std::string& str, unsigned long value);
+		/// Formats an unsigned long value in hexadecimal notation.
+
+	static void appendHex(std::string& str, unsigned long value, int width);
+		/// Formats an unsigned long value in hexadecimal notation,
+		/// right justified and zero-padded in a field having at least the
+		/// specified width.
+
+#ifdef POCO_HAVE_INT64
+
+#ifdef POCO_LONG_IS_64_BIT
+
+	static void append(std::string& str, long long value);
+		/// Formats a 64-bit integer value in decimal notation.
+
+	static void append(std::string& str, long long value, int width);
+		/// Formats a 64-bit integer value in decimal notation,
+		/// right justified in a field having at least the specified width.
+
+	static void append0(std::string& str, long long value, int width);
+		/// Formats a 64-bit integer value in decimal notation,
+		/// right justified and zero-padded in a field having at least
+		/// the specified width.
+
+	static void appendHex(std::string& str, long long value);
+		/// Formats a 64-bit integer value in hexadecimal notation.
+		/// The value is treated as unsigned.
+
+	static void appendHex(std::string& str, long long value, int width);
+		/// Formats a 64-bit integer value in hexadecimal notation,
+		/// right justified and zero-padded in a field having at least
+		/// the specified width.
+		/// The value is treated as unsigned.
+
+	static void append(std::string& str, unsigned long long value);
+		/// Formats an unsigned 64-bit integer value in decimal notation.
+
+	static void append(std::string& str, unsigned long long value, int width);
+		/// Formats an unsigned 64-bit integer value in decimal notation,
+		/// right justified in a field having at least the specified width.
+
+	static void append0(std::string& str, unsigned long long value, int width);
+		/// Formats an unsigned 64-bit integer value in decimal notation,
+		/// right justified and zero-padded in a field having at least the
+		/// specified width.
+
+	static void appendHex(std::string& str, unsigned long long value);
+		/// Formats a 64-bit integer value in hexadecimal notation.
+
+	static void appendHex(std::string& str, unsigned long long value, int width);
+		/// Formats a 64-bit integer value in hexadecimal notation,
+		/// right justified and zero-padded in a field having at least
+		/// the specified width.
+
+#else // ifndef POCO_LONG_IS_64_BIT
+
+	static void append(std::string& str, Int64 value);
+		/// Formats a 64-bit integer value in decimal notation.
+
+	static void append(std::string& str, Int64 value, int width);
+		/// Formats a 64-bit integer value in decimal notation,
+		/// right justified in a field having at least the specified width.
+
+	static void append0(std::string& str, Int64 value, int width);
+		/// Formats a 64-bit integer value in decimal notation,
+		/// right justified and zero-padded in a field having at least
+		/// the specified width.
+
+	static void appendHex(std::string& str, Int64 value);
+		/// Formats a 64-bit integer value in hexadecimal notation.
+		/// The value is treated as unsigned.
+
+	static void appendHex(std::string& str, Int64 value, int width);
+		/// Formats a 64-bit integer value in hexadecimal notation,
+		/// right justified and zero-padded in a field having at least
+		/// the specified width.
+		/// The value is treated as unsigned.
+
+	static void append(std::string& str, UInt64 value);
+		/// Formats an unsigned 64-bit integer value in decimal notation.
+
+	static void append(std::string& str, UInt64 value, int width);
+		/// Formats an unsigned 64-bit integer value in decimal notation,
+		/// right justified in a field having at least the specified width.
+
+	static void append0(std::string& str, UInt64 value, int width);
+		/// Formats an unsigned 64-bit integer value in decimal notation,
+		/// right justified and zero-padded in a field having at least the
+		/// specified width.
+
+	static void appendHex(std::string& str, UInt64 value);
+		/// Formats a 64-bit integer value in hexadecimal notation.
+
+	static void appendHex(std::string& str, UInt64 value, int width);
+		/// Formats a 64-bit integer value in hexadecimal notation,
+		/// right justified and zero-padded in a field having at least
+		/// the specified width.
+
+#endif // ifdef POCO_LONG_IS_64_BIT
+
+#endif // ifdef POCO_HAVE_INT64
+
+	static void append(std::string& str, float value);
+		/// Formats a float value in decimal floating-point notation,
+		/// according to std::printf's %g format with a precision of 8 fractional digits.
+
+	static void append(std::string& str, float value, int precision);
+		/// Formats a double value in decimal floating-point notation,
+		/// according to std::printf's %f format with the given precision.
+
+	static void append(std::string& str, float value, int width, int precision);
+		/// Formats a double value in decimal floating-point notation,
+		/// right justified in a field of the specified width,
+		/// with the number of fractional digits given in precision.
+
+	static void append(std::string& str, double value);
+		/// Formats a double value in decimal floating-point notation,
+		/// according to std::printf's %g format with a precision of 16 fractional digits.
+
+	static void append(std::string& str, double value, int precision);
+		/// Formats a double value in decimal floating-point notation,
+		/// according to std::printf's %f format with the given precision.
+
+	static void append(std::string& str, double value, int width, int precision);
+		/// Formats a double value in decimal floating-point notation,
+		/// right justified in a field of the specified width,
+		/// with the number of fractional digits given in precision.
+
+	static void append(std::string& str, const void* ptr);
+		/// Formats a pointer in an eight (32-bit architectures) or
+		/// sixteen (64-bit architectures) characters wide
+		/// field in hexadecimal notation.
+
+private:
+};
+
+
+//
+// inlines
+//
+
+inline std::string NumberFormatter::format(int value)
+{
+	std::string result;
+	intToStr(value, 10, result);
+	return result;
+}
+
+
+inline std::string NumberFormatter::format(int value, int width)
+{
+	std::string result;
+	intToStr(value, 10, result, false, width, ' ');
+	return result;
+}
+
+
+inline std::string NumberFormatter::format0(int value, int width)
+{
+	std::string result;
+	intToStr(value, 10, result, false, width, '0');
+	return result;
+}
+
+
+inline std::string NumberFormatter::formatHex(int value, bool prefix)
+{
+	std::string result;
+	uIntToStr(static_cast<unsigned int>(value), 0x10, result, prefix);
+	return result;
+}
+
+
+inline std::string NumberFormatter::formatHex(int value, int width, bool prefix)
+{
+	std::string result;
+	uIntToStr(static_cast<unsigned int>(value), 0x10, result, prefix, width, '0');
+	return result;
+}
+
+
+inline std::string NumberFormatter::format(unsigned value)
+{
+	std::string result;
+	uIntToStr(value, 10, result);
+	return result;
+}
+
+
+inline std::string NumberFormatter::format(unsigned value, int width)
+{
+	std::string result;
+	uIntToStr(value, 10, result, false, width, ' ');
+	return result;
+}
+
+
+inline std::string NumberFormatter::format0(unsigned int value, int width)
+{
+	std::string result;
+	uIntToStr(value, 10, result, false, width, '0');
+	return result;
+}
+
+
+inline std::string NumberFormatter::formatHex(unsigned value, bool prefix)
+{
+	std::string result;
+	uIntToStr(value, 0x10, result, prefix);
+	return result;
+}
+
+
+inline std::string NumberFormatter::formatHex(unsigned value, int width, bool prefix)
+{
+	std::string result;
+	uIntToStr(value, 0x10, result, prefix, width, '0');
+	return result;
+}
+
+
+inline std::string NumberFormatter::format(long value)
+{
+	std::string result;
+	intToStr(value, 10, result);
+	return result;
+}
+
+
+inline std::string NumberFormatter::format(long value, int width)
+{
+	std::string result;
+	intToStr(value, 10, result, false, width, ' ');
+	return result;
+}
+
+
+inline std::string NumberFormatter::format0(long value, int width)
+{
+	std::string result;
+	intToStr(value, 10, result, false, width, '0');
+	return result;
+}
+
+
+inline std::string NumberFormatter::formatHex(long value, bool prefix)
+{
+	std::string result;
+	uIntToStr(static_cast<unsigned long>(value), 0x10, result, prefix);
+	return result;
+}
+
+
+inline std::string NumberFormatter::formatHex(long value, int width, bool prefix)
+{
+	std::string result;
+	uIntToStr(static_cast<unsigned long>(value), 0x10, result, prefix, width, '0');
+	return result;
+}
+
+
+inline std::string NumberFormatter::format(unsigned long value)
+{
+	std::string result;
+	uIntToStr(value, 10, result);
+	return result;
+}
+
+
+inline std::string NumberFormatter::format(unsigned long value, int width)
+{
+	std::string result;
+	uIntToStr(value, 10, result, false, width, ' ');
+	return result;
+}
+
+
+inline std::string NumberFormatter::format0(unsigned long value, int width)
+{
+	std::string result;
+	uIntToStr(value, 10, result, false, width, '0');
+	return result;
+}
+
+
+inline std::string NumberFormatter::formatHex(unsigned long value, bool prefix)
+{
+	std::string result;
+	uIntToStr(value, 0x10, result, prefix);
+	return result;
+}
+
+
+inline std::string NumberFormatter::formatHex(unsigned long value, int width, bool prefix)
+{
+	std::string result;
+	uIntToStr(value, 0x10, result, prefix, width, '0');
+	return result;
+}
+
+
+#ifdef POCO_HAVE_INT64
+
+#ifdef POCO_LONG_IS_64_BIT
+
+
+inline std::string NumberFormatter::format(long long value)
+{
+	std::string result;
+	intToStr(value, 10, result);
+	return result;
+}
+
+
+inline std::string NumberFormatter::format(long long value, int width)
+{
+	std::string result;
+	intToStr(value, 10, result, false, width, ' ');
+	return result;
+}
+
+
+inline std::string NumberFormatter::format0(long long value, int width)
+{
+	std::string result;
+	intToStr(value, 10, result, false, width, '0');
+	return result;
+}
+
+
+inline std::string NumberFormatter::formatHex(long long value, bool prefix)
+{
+	std::string result;
+	uIntToStr(static_cast<unsigned long long>(value), 0x10, result, prefix);
+	return result;
+}
+
+
+inline std::string NumberFormatter::formatHex(long long value, int width, bool prefix)
+{
+	std::string result;
+	uIntToStr(static_cast<unsigned long long>(value), 0x10, result, prefix, width, '0');
+	return result;
+}
+
+
+inline std::string NumberFormatter::format(unsigned long long value)
+{
+	std::string result;
+	uIntToStr(value, 10, result);
+	return result;
+}
+
+
+inline std::string NumberFormatter::format(unsigned long long value, int width)
+{
+	std::string result;
+	uIntToStr(value, 10, result, false, width, ' ');
+	return result;
+}
+
+
+inline std::string NumberFormatter::format0(unsigned long long value, int width)
+{
+	std::string result;
+	uIntToStr(value, 10, result, false, width, '0');
+	return result;
+}
+
+
+inline std::string NumberFormatter::formatHex(unsigned long long value, bool prefix)
+{
+	std::string result;
+	uIntToStr(value, 0x10, result, prefix);
+	return result;
+}
+
+
+inline std::string NumberFormatter::formatHex(unsigned long long value, int width, bool prefix)
+{
+	std::string result;
+	uIntToStr(value, 0x10, result, prefix, width, '0');
+	return result;
+}
+
+
+#else // ifndef POCO_LONG_IS_64_BIT
+
+
+inline std::string NumberFormatter::format(Int64 value)
+{
+	std::string result;
+	intToStr(value, 10, result);
+	return result;
+}
+
+
+inline std::string NumberFormatter::format(Int64 value, int width)
+{
+	std::string result;
+	intToStr(value, 10, result, false, width, ' ');
+	return result;
+}
+
+
+inline std::string NumberFormatter::format0(Int64 value, int width)
+{
+	std::string result;
+	intToStr(value, 10, result, false, width, '0');
+	return result;
+}
+
+
+inline std::string NumberFormatter::formatHex(Int64 value, bool prefix)
+{
+	std::string result;
+	uIntToStr(static_cast<UInt64>(value), 0x10, result, prefix);
+	return result;
+}
+
+
+inline std::string NumberFormatter::formatHex(Int64 value, int width, bool prefix)
+{
+	std::string result;
+	uIntToStr(static_cast<UInt64>(value), 0x10, result, prefix, width, '0');
+	return result;
+}
+
+
+inline std::string NumberFormatter::format(UInt64 value)
+{
+	std::string result;
+	uIntToStr(value, 10, result);
+	return result;
+}
+
+
+inline std::string NumberFormatter::format(UInt64 value, int width)
+{
+	std::string result;
+	uIntToStr(value, 10, result, false, width, ' ');
+	return result;
+}
+
+
+inline std::string NumberFormatter::format0(UInt64 value, int width)
+{
+	std::string result;
+	uIntToStr(value, 10, result, false, width, '0');
+	return result;
+}
+
+
+inline std::string NumberFormatter::formatHex(UInt64 value, bool prefix)
+{
+	std::string result;
+	uIntToStr(value, 0x10, result, prefix);
+	return result;
+}
+
+
+inline std::string NumberFormatter::formatHex(UInt64 value, int width, bool prefix)
+{
+	std::string result;
+	uIntToStr(value, 0x10, result, prefix, width, '0');
+	return result;
+}
+
+
+#endif // ifdef POCO_LONG_IS_64_BIT
+
+#endif // ifdef POCO_HAVE_INT64
+
+
+inline std::string NumberFormatter::format(float value)
+{
+	char buffer[POCO_MAX_FLT_STRING_LEN];
+	floatToStr(buffer, POCO_MAX_FLT_STRING_LEN, value);
+	return std::string(buffer);
+}
+
+
+inline std::string NumberFormatter::format(float value, int precision)
+{
+	char buffer[POCO_MAX_FLT_STRING_LEN];
+	floatToFixedStr(buffer, POCO_MAX_FLT_STRING_LEN, value, precision);
+	return std::string(buffer);
+}
+
+
+inline std::string NumberFormatter::format(float value, int width, int precision)
+{
+	std::string result;
+	floatToFixedStr(result, value, precision, width);
+	return result;
+}
+
+
+inline std::string NumberFormatter::format(double value)
+{
+	char buffer[POCO_MAX_FLT_STRING_LEN];
+	doubleToStr(buffer, POCO_MAX_FLT_STRING_LEN, value);
+	return std::string(buffer);
+}
+
+
+inline std::string NumberFormatter::format(double value, int precision)
+{
+	char buffer[POCO_MAX_FLT_STRING_LEN];
+	doubleToFixedStr(buffer, POCO_MAX_FLT_STRING_LEN, value, precision);
+	return std::string(buffer);
+}
+
+
+inline std::string NumberFormatter::format(double value, int width, int precision)
+{
+	std::string result;
+	doubleToFixedStr(result, value, precision, width);
+	return result;
+}
+
+
+inline std::string NumberFormatter::format(const void* ptr)
+{
+	std::string result;
+	append(result, ptr);
+	return result;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NumberFormatter_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NumberParser.h b/base/poco/Foundation/include/Poco/NumberParser.h
new file mode 100644
index 00000000000..c58ed4f3595
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NumberParser.h
@@ -0,0 +1,156 @@
+//
+// NumberParser.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  NumberParser
+//
+// Definition of the NumberParser class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NumberParser_INCLUDED
+#define Foundation_NumberParser_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <string>
+#undef min
+#undef max
+#include <limits>
+
+
+namespace Poco {
+
+
+class Foundation_API NumberParser
+	/// The NumberParser class provides static methods
+	/// for parsing numbers out of strings.
+	///
+	/// Note that leading or trailing whitespace is not allowed
+	/// in the string. Poco::trim() or Poco::trimInPlace()
+	/// can be used to remove leading or trailing whitespace.
+{
+public:
+	static const unsigned short NUM_BASE_OCT = 010;
+	static const unsigned short NUM_BASE_DEC = 10;
+	static const unsigned short NUM_BASE_HEX = 0x10;
+
+	static int parse(const std::string& s, char thousandSeparator = ',');
+		/// Parses an integer value in decimal notation from the given string.
+		/// Throws a SyntaxException if the string does not hold a number in decimal notation.
+	
+	static bool tryParse(const std::string& s, int& value, char thousandSeparator = ',');
+		/// Parses an integer value in decimal notation from the given string.
+		/// Returns true if a valid integer has been found, false otherwise. 
+		/// If parsing was not successful, value is undefined.
+	
+	static unsigned parseUnsigned(const std::string& s, char thousandSeparator = ',');
+		/// Parses an unsigned integer value in decimal notation from the given string.
+		/// Throws a SyntaxException if the string does not hold a number in decimal notation.
+
+	static bool tryParseUnsigned(const std::string& s, unsigned& value, char thousandSeparator = ',');
+		/// Parses an unsigned integer value in decimal notation from the given string.
+		/// Returns true if a valid integer has been found, false otherwise. 
+		/// If parsing was not successful, value is undefined.
+
+	static unsigned parseHex(const std::string& s);
+		/// Parses an integer value in hexadecimal notation from the given string.
+		/// Throws a SyntaxException if the string does not hold a number in
+		/// hexadecimal notation.
+
+	static bool tryParseHex(const std::string& s, unsigned& value);
+		/// Parses an unsigned integer value in hexadecimal notation from the given string.
+		/// Returns true if a valid integer has been found, false otherwise. 
+		/// If parsing was not successful, value is undefined.
+
+	static unsigned parseOct(const std::string& s);
+		/// Parses an integer value in octal notation from the given string.
+		/// Throws a SyntaxException if the string does not hold a number in
+		/// hexadecimal notation.
+
+	static bool tryParseOct(const std::string& s, unsigned& value);
+		/// Parses an unsigned integer value in octal notation from the given string.
+		/// Returns true if a valid integer has been found, false otherwise. 
+		/// If parsing was not successful, value is undefined.
+
+#if defined(POCO_HAVE_INT64)
+
+	static Int64 parse64(const std::string& s, char thousandSeparator = ',');
+		/// Parses a 64-bit integer value in decimal notation from the given string.
+		/// Throws a SyntaxException if the string does not hold a number in decimal notation.
+
+	static bool tryParse64(const std::string& s, Int64& value, char thousandSeparator = ',');
+		/// Parses a 64-bit integer value in decimal notation from the given string.
+		/// Returns true if a valid integer has been found, false otherwise. 
+		/// If parsing was not successful, value is undefined.
+
+	static UInt64 parseUnsigned64(const std::string& s, char thousandSeparator = ',');
+		/// Parses an unsigned 64-bit integer value in decimal notation from the given string.
+		/// Throws a SyntaxException if the string does not hold a number in decimal notation.
+
+	static bool tryParseUnsigned64(const std::string& s, UInt64& value, char thousandSeparator = ',');
+		/// Parses an unsigned 64-bit integer value in decimal notation from the given string.
+		/// Returns true if a valid integer has been found, false otherwise. 
+		/// If parsing was not successful, value is undefined.
+
+	static UInt64 parseHex64(const std::string& s);
+		/// Parses a 64 bit-integer value in hexadecimal notation from the given string.
+		/// Throws a SyntaxException if the string does not hold a number in hexadecimal notation.
+
+	static bool tryParseHex64(const std::string& s, UInt64& value);
+		/// Parses an unsigned 64-bit integer value in hexadecimal notation from the given string.
+		/// Returns true if a valid integer has been found, false otherwise. 
+		/// If parsing was not successful, value is undefined.
+
+	static UInt64 parseOct64(const std::string& s);
+		/// Parses a 64 bit-integer value in octal notation from the given string.
+		/// Throws a SyntaxException if the string does not hold a number in hexadecimal notation.
+
+	static bool tryParseOct64(const std::string& s, UInt64& value);
+		/// Parses an unsigned 64-bit integer value in octal notation from the given string.
+		/// Returns true if a valid integer has been found, false otherwise. 
+		/// If parsing was not successful, value is undefined.
+
+#endif // defined(POCO_HAVE_INT64)
+
+	static double parseFloat(const std::string& s, char decimalSeparator = '.', char thousandSeparator = ',');
+		/// Parses a double value in decimal floating point notation
+		/// from the given string.
+		/// Throws a SyntaxException if the string does not hold a floating-point 
+		/// number in decimal notation.
+		
+	static bool tryParseFloat(const std::string& s, double& value, char decimalSeparator = '.', char thousandSeparator = ',');
+		/// Parses a double value in decimal floating point notation
+		/// from the given string.
+		/// Returns true if a valid floating point number has been found,
+		/// false otherwise.
+		/// If parsing was not successful, value is undefined.
+
+	static bool parseBool(const std::string& s);
+		/// Parses a bool value in decimal or string notation
+		/// from the given string.
+		/// Valid forms are: "0", "1", "true", "on", false", "yes", "no", "off".
+		/// String forms are NOT case sensitive.
+		/// Throws a SyntaxException if the string does not hold a valid bool number
+
+	static bool tryParseBool(const std::string& s, bool& value);
+		/// Parses a bool value in decimal or string notation
+		/// from the given string.
+		/// Valid forms are: "0", "1", "true", "on", false", "yes", "no", "off".
+		/// String forms are NOT case sensitive.
+		/// Returns true if a valid bool number has been found,
+		/// false otherwise.
+		/// If parsing was not successful, value is undefined.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NumberParser_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/NumericString.h b/base/poco/Foundation/include/Poco/NumericString.h
new file mode 100644
index 00000000000..5600432d298
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/NumericString.h
@@ -0,0 +1,560 @@
+//
+// NumericString.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  NumericString
+//
+// Numeric string utility functions.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_NumericString_INCLUDED
+#define Foundation_NumericString_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Buffer.h"
+#include "Poco/FPEnvironment.h"
+#ifdef min
+	#undef min
+#endif
+#ifdef max
+	#undef max
+#endif
+#include <limits>
+#include <cmath>
+#include <cctype>
+#if !defined(POCO_NO_LOCALE)
+	#include <locale>
+#endif
+
+
+// binary numbers are supported, thus 64 (bits) + 1 (string terminating zero)
+#define POCO_MAX_INT_STRING_LEN 65
+// value from strtod.cc (double_conversion::kMaxSignificantDecimalDigits)
+#define POCO_MAX_FLT_STRING_LEN 780
+
+#define POCO_FLT_INF "inf"
+#define POCO_FLT_NAN "nan"
+#define POCO_FLT_EXP 'e'
+
+
+namespace Poco {
+
+
+inline char decimalSeparator()
+	/// Returns decimal separator from global locale or
+	/// default '.' for platforms where locale is unavailable.
+{
+#if !defined(POCO_NO_LOCALE)
+	return std::use_facet<std::numpunct<char> >(std::locale()).decimal_point();
+#else
+	return '.';
+#endif
+}
+
+
+inline char thousandSeparator()
+	/// Returns thousand separator from global locale or
+	/// default ',' for platforms where locale is unavailable.
+{
+#if !defined(POCO_NO_LOCALE)
+	return std::use_facet<std::numpunct<char> >(std::locale()).thousands_sep();
+#else
+	return ',';
+#endif
+}
+
+
+//
+// String to Number Conversions
+//
+
+template <typename I>
+bool strToInt(const char* pStr, I& result, short base, char thSep = ',')
+	/// Converts zero-terminated character array to integer number;
+	/// Thousand separators are recognized for base10 and current locale;
+	/// it is silently skipped but not verified for correct positioning.
+	/// Function returns true if successful. If parsing was unsuccessful,
+	/// the return value is false with the result value undetermined.
+{
+	if (!pStr) return false;
+	while (std::isspace(*pStr)) ++pStr;
+	if (*pStr == '\0') return false;
+	short sign = 1;
+	if ((base == 10) && (*pStr == '-'))
+	{
+		// Unsigned types can't be negative so abort parsing
+		if (std::numeric_limits<I>::min() >= 0) return false;
+		sign = -1;
+		++pStr;
+	}
+	else if (*pStr == '+') ++pStr;
+
+	// parser states:
+	const char STATE_SIGNIFICANT_DIGITS = 1;
+	char state = 0;
+	
+	result = 0;
+	I limitCheck = std::numeric_limits<I>::max() / base;
+	for (; *pStr != '\0'; ++pStr)
+	{
+		switch (*pStr)
+		{
+		case '0': 
+			if (state < STATE_SIGNIFICANT_DIGITS) break;
+
+		case '1': case '2': case '3': case '4':
+		case '5': case '6': case '7':
+			if (state < STATE_SIGNIFICANT_DIGITS) state = STATE_SIGNIFICANT_DIGITS;
+			if (result > limitCheck) return false;
+			result = result * base + (*pStr - '0');
+
+			break;
+
+		case '8': case '9':
+			if ((base == 10) || (base == 0x10))
+			{
+				if (state < STATE_SIGNIFICANT_DIGITS) state = STATE_SIGNIFICANT_DIGITS;
+				if (result > limitCheck) return false;
+				result = result * base + (*pStr - '0');
+			}
+			else return false;
+
+			break;
+
+		case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
+			if (base != 0x10) return false;
+			if (state < STATE_SIGNIFICANT_DIGITS) state = STATE_SIGNIFICANT_DIGITS;
+			if (result > limitCheck) return false;
+			result = result * base + (10 + *pStr - 'a');
+
+			break;
+
+		case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
+			if (base != 0x10) return false;
+			if (state < STATE_SIGNIFICANT_DIGITS) state = STATE_SIGNIFICANT_DIGITS;
+			if (result > limitCheck) return false;
+			result = result * base + (10 + *pStr - 'A');
+
+			break;
+
+		case '.':
+			if ((base == 10) && (thSep == '.')) break;
+			else return false;
+
+		case ',':
+			if ((base == 10) && (thSep == ',')) break;
+			else return false;
+
+		case ' ':
+			if ((base == 10) && (thSep == ' ')) break;
+			// fallthrough
+
+		default:
+			return false;
+		}
+	}
+
+	if ((sign < 0) && (base == 10)) result *= sign;
+
+	return true;
+}
+
+
+template <typename I>
+bool strToInt(const std::string& str, I& result, short base, char thSep = ',')
+	/// Converts string to integer number;
+	/// This is a wrapper function, for details see see the
+	/// bool strToInt(const char*, I&, short, char) implementation.
+{
+	return strToInt(str.c_str(), result, base, thSep);
+}
+
+
+//
+// Number to String Conversions
+//
+
+namespace Impl {
+
+	class Ptr
+		/// Utility char pointer wrapper class.
+		/// Class ensures increment/decrement remain within boundaries.
+	{
+	public:
+		Ptr(char* ptr, std::size_t offset): _beg(ptr), _cur(ptr), _end(ptr + offset)
+		{
+		}
+	
+		char*& operator ++ () // prefix
+		{
+			checkBounds(_cur + 1);
+			return ++_cur;
+		}
+
+		char* operator ++ (int) // postfix
+		{
+			checkBounds(_cur + 1);
+			char* tmp = _cur++;
+			return tmp;
+		}
+	
+		char*& operator -- () // prefix
+		{
+			checkBounds(_cur - 1);
+			return --_cur;
+		}
+
+		char* operator -- (int) // postfix
+		{
+			checkBounds(_cur - 1);
+			char* tmp = _cur--;
+			return tmp;
+		}
+
+		char*& operator += (int incr)
+		{
+			checkBounds(_cur + incr);
+			return _cur += incr;
+		}
+
+		char*& operator -= (int decr)
+		{
+			checkBounds(_cur - decr);
+			return _cur -= decr;
+		}
+
+		operator char* () const
+		{
+			return _cur;
+		}
+
+		std::size_t span() const
+		{
+			return _end - _beg;
+		}
+
+	private:
+		void checkBounds(char* ptr)
+		{
+			if (ptr > _end) throw RangeException();
+		}
+
+		const char* _beg;
+		char*       _cur;
+		const char* _end;
+};	
+
+} // namespace Impl
+
+
+template <typename T>
+bool intToStr(T value,
+	unsigned short base,
+	char* result,
+	std::size_t& size,
+	bool prefix = false,
+	int width = -1,
+	char fill = ' ',
+	char thSep = 0)
+	/// Converts integer to string. Numeric bases from binary to hexadecimal are supported.
+	/// If width is non-zero, it pads the return value with fill character to the specified width.
+	/// When padding is zero character ('0'), it is prepended to the number itself; all other
+	/// paddings are prepended to the formatted result with minus sign or base prefix included
+	/// If prefix is true and base is octal or hexadecimal, respective prefix ('0' for octal, 
+	/// "0x" for hexadecimal) is prepended. For all other bases, prefix argument is ignored.
+	/// Formatted string has at least [width] total length.
+{
+	if (base < 2 || base > 0x10)
+	{
+		*result = '\0';
+		return false;
+	}
+
+	Impl::Ptr ptr(result, size);
+	int thCount = 0;
+	T tmpVal;
+	do
+	{
+		tmpVal = value;
+		value /= base;
+		*ptr++ = "FEDCBA9876543210123456789ABCDEF"[15 + (tmpVal - value * base)];
+		if (thSep && (base == 10) && (++thCount == 3))
+		{
+			*ptr++ = thSep;
+			thCount = 0;
+		}
+	} while (value);
+
+	if ('0' == fill)
+	{
+		if (tmpVal < 0) --width;
+		if (prefix && base == 010) --width;
+		if (prefix && base == 0x10) width -= 2;
+		while ((ptr - result) < width) *ptr++ = fill;
+	}
+
+	if (prefix && base == 010) *ptr++ = '0';
+	else if (prefix && base == 0x10)
+	{
+		*ptr++ = 'x';
+		*ptr++ = '0';
+	}
+
+	if (tmpVal < 0) *ptr++ = '-';
+
+	if ('0' != fill)
+	{
+		while ((ptr - result) < width) *ptr++ = fill;
+	}
+
+	size = ptr - result;
+	poco_assert_dbg (size <= ptr.span());
+	poco_assert_dbg ((-1 == width) || (size >= std::size_t(width)));
+	*ptr-- = '\0';
+
+	char* ptrr = result;
+	char tmp;
+	while(ptrr < ptr)
+	{
+		 tmp    = *ptr;
+		*ptr--  = *ptrr;
+		*ptrr++ = tmp;
+	}
+
+	return true;
+}
+
+
+template <typename T>
+bool uIntToStr(T value,
+	unsigned short base,
+	char* result,
+	std::size_t& size,
+	bool prefix = false,
+	int width = -1,
+	char fill = ' ',
+	char thSep = 0)
+	/// Converts unsigned integer to string. Numeric bases from binary to hexadecimal are supported.
+	/// If width is non-zero, it pads the return value with fill character to the specified width.
+	/// When padding is zero character ('0'), it is prepended to the number itself; all other
+	/// paddings are prepended to the formatted result with minus sign or base prefix included
+	/// If prefix is true and base is octal or hexadecimal, respective prefix ('0' for octal,
+	/// "0x" for hexadecimal) is prepended. For all other bases, prefix argument is ignored.
+	/// Formatted string has at least [width] total length.
+{
+	if (base < 2 || base > 0x10)
+	{
+		*result = '\0';
+		return false;
+	}
+	
+	Impl::Ptr ptr(result, size);
+	int thCount = 0;
+	T tmpVal;
+	do
+	{
+		tmpVal = value;
+		value /= base;
+		*ptr++ = "FEDCBA9876543210123456789ABCDEF"[15 + (tmpVal - value * base)];
+		if (thSep && (base == 10) && (++thCount == 3))
+		{
+			*ptr++ = thSep;
+			thCount = 0;
+		}
+	} while (value);
+	
+	if ('0' == fill)
+	{
+		if (prefix && base == 010) --width;
+		if (prefix && base == 0x10) width -= 2;
+		while ((ptr - result) < width) *ptr++ = fill;
+	}
+	
+	if (prefix && base == 010) *ptr++ = '0';
+	else if (prefix && base == 0x10)
+	{
+		*ptr++ = 'x';
+		*ptr++ = '0';
+	}
+	
+	if ('0' != fill)
+	{
+		while ((ptr - result) < width) *ptr++ = fill;
+	}
+	
+	size = ptr - result;
+	poco_assert_dbg (size <= ptr.span());
+	poco_assert_dbg ((-1 == width) || (size >= std::size_t(width)));
+	*ptr-- = '\0';
+	
+	char* ptrr = result;
+	char tmp;
+	while(ptrr < ptr)
+	{
+		tmp    = *ptr;
+		*ptr--  = *ptrr;
+		*ptrr++ = tmp;
+	}
+	
+	return true;
+}
+
+
+template <typename T>
+bool intToStr (T number, unsigned short base, std::string& result, bool prefix = false, int width = -1, char fill = ' ', char thSep = 0)
+	/// Converts integer to string; This is a wrapper function, for details see see the
+	/// bool intToStr(T, unsigned short, char*, int, int, char, char) implementation.
+{
+	char res[POCO_MAX_INT_STRING_LEN] = {0};
+	std::size_t size = POCO_MAX_INT_STRING_LEN;
+	bool ret = intToStr(number, base, res, size, prefix, width, fill, thSep);
+	result.assign(res, size);
+	return ret;
+}
+	
+	
+template <typename T>
+bool uIntToStr (T number, unsigned short base, std::string& result, bool prefix = false, int width = -1, char fill = ' ', char thSep = 0)
+	/// Converts unsigned integer to string; This is a wrapper function, for details see see the
+	/// bool uIntToStr(T, unsigned short, char*, int, int, char, char) implementation.
+{
+	char res[POCO_MAX_INT_STRING_LEN] = {0};
+	std::size_t size = POCO_MAX_INT_STRING_LEN;
+	bool ret = uIntToStr(number, base, res, size, prefix, width, fill, thSep);
+	result.assign(res, size);
+	return ret;
+}
+
+
+//
+// Wrappers for double-conversion library (http://code.google.com/p/double-conversion/).
+//
+// Library is the implementation of the algorithm described in Florian Loitsch's paper:
+// http://florian.loitsch.com/publications/dtoa-pldi2010.pdf
+//
+
+
+Foundation_API void floatToStr(char* buffer,
+	int bufferSize,
+	float value,
+	int lowDec = -std::numeric_limits<float>::digits10,
+	int highDec = std::numeric_limits<float>::digits10);
+	/// Converts a float value to string. Converted string must be shorter than bufferSize.
+	/// Conversion is done by computing the shortest string of digits that correctly represents
+	/// the input number. Depending on lowDec and highDec values, the function returns
+	/// decimal or exponential representation.
+
+Foundation_API void floatToFixedStr(char* buffer,
+	int bufferSize,
+	float value,
+	int precision);
+	/// Converts a float value to string. Converted string must be shorter than bufferSize.
+	/// Computes a decimal representation with a fixed number of digits after the
+  	/// decimal point.
+
+
+Foundation_API std::string& floatToStr(std::string& str,
+	float value,
+	int precision = -1,
+	int width = 0,
+	char thSep = 0,
+	char decSep = 0);
+	/// Converts a float value, assigns it to the supplied string and returns the reference.
+	/// This function calls floatToStr(char*, int, float, int, int) and formats the result according to
+	/// precision (total number of digits after the decimal point, -1 means ignore precision argument) 
+	/// and width (total length of formatted string).
+
+
+Foundation_API std::string& floatToFixedStr(std::string& str,
+	float value,
+	int precision,
+	int width = 0,
+	char thSep = 0,
+	char decSep = 0);
+	/// Converts a float value, assigns it to the supplied string and returns the reference.
+	/// This function calls floatToFixedStr(char*, int, float, int) and formats the result according to
+	/// precision (total number of digits after the decimal point) and width (total length of formatted string).
+
+
+Foundation_API void doubleToStr(char* buffer,
+	int bufferSize,
+	double value,
+	int lowDec = -std::numeric_limits<double>::digits10,
+	int highDec = std::numeric_limits<double>::digits10);
+	/// Converts a double value to string. Converted string must be shorter than bufferSize.
+	/// Conversion is done by computing the shortest string of digits that correctly represents
+	/// the input number. Depending on lowDec and highDec values, the function returns
+	/// decimal or exponential representation.
+
+
+Foundation_API void doubleToFixedStr(char* buffer,
+	int bufferSize,
+	double value,
+	int precision);
+	/// Converts a double value to string. Converted string must be shorter than bufferSize.
+	/// Computes a decimal representation with a fixed number of digits after the
+  	/// decimal point.
+
+
+Foundation_API std::string& doubleToStr(std::string& str,
+	double value,
+	int precision = -1,
+	int width = 0,
+	char thSep = 0,
+	char decSep = 0);
+	/// Converts a double value, assigns it to the supplied string and returns the reference.
+	/// This function calls doubleToStr(char*, int, double, int, int) and formats the result according to
+	/// precision (total number of digits after the decimal point, -1 means ignore precision argument) 
+	/// and width (total length of formatted string).
+
+
+Foundation_API std::string& doubleToFixedStr(std::string& str,
+	double value,
+	int precision = -1,
+	int width = 0,
+	char thSep = 0,
+	char decSep = 0);
+	/// Converts a double value, assigns it to the supplied string and returns the reference.
+	/// This function calls doubleToFixedStr(char*, int, double, int) and formats the result according to
+	/// precision (total number of digits after the decimal point) and width (total length of formatted string).
+
+
+Foundation_API float strToFloat(const char* str);
+	/// Converts the string of characters into single-precision floating point number.
+	/// Function uses double_convesrion::DoubleToStringConverter to do the conversion.
+
+
+Foundation_API bool strToFloat(const std::string&, float& result, char decSep = '.', char thSep = ',');
+	/// Converts the string of characters into single-precision floating point number.
+	/// The conversion result is assigned to the result parameter.
+	/// If decimal separator and/or thousand separator are different from defaults, they should be
+	/// supplied to ensure proper conversion.
+	/// 
+	/// Returns true if successful, false otherwise.
+
+
+Foundation_API double strToDouble(const char* str);
+	/// Converts the string of characters into double-precision floating point number.
+
+
+Foundation_API bool strToDouble(const std::string& str, double& result, char decSep = '.', char thSep = ',');
+	/// Converts the string of characters into double-precision floating point number.
+	/// The conversion result is assigned to the result parameter.
+	/// If decimal separator and/or thousand separator are different from defaults, they should be
+	/// supplied to ensure proper conversion.
+	/// 
+	/// Returns true if successful, false otherwise.
+
+
+} // namespace Poco
+
+
+#endif // Foundation_NumericString_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ObjectPool.h b/base/poco/Foundation/include/Poco/ObjectPool.h
new file mode 100644
index 00000000000..af3d7bab051
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ObjectPool.h
@@ -0,0 +1,332 @@
+//
+// ObjectPool.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  ObjectPool
+//
+// Definition of the ObjectPool template class and friends.
+//
+// Copyright (c) 2010-2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ObjectPool_INCLUDED
+#define Foundation_ObjectPool_INCLUDED
+
+
+#include "Poco/Poco.h"
+#include "Poco/Mutex.h"
+#include "Poco/Condition.h"
+#include "Poco/AutoPtr.h"
+#include "Poco/SharedPtr.h"
+#include <vector>
+#include <cctype>
+
+
+namespace Poco {
+
+
+template <class C, class P = C*>
+class PoolableObjectFactory
+	/// A PoolableObjectFactory is responsible for creating and resetting
+	/// objects managed by an ObjectPool.
+	///
+	/// Together with an ObjectPool, a PoolableObjectFactory is used as
+	/// a policy class to change the behavior of the ObjectPool when
+	/// creating new objects, returning used objects back to the pool
+	/// and destroying objects, when the pool itself is destroyed or
+	/// shrunk.
+{
+public:
+	P createObject()
+		/// Create and return a new object.
+	{
+		return new C;
+	}
+	
+	bool validateObject(P pObject)
+		/// Checks whether the object is still valid
+		/// and can be reused.
+		///
+		/// Returns true if the object is valid,
+		/// false otherwise.
+		///
+		/// To maintain the integrity of the pool, this method
+		/// must not throw an exception.
+	{
+		return true;
+	}
+	
+	void activateObject(P pObject)
+		/// Called before an object is handed out by the pool.
+		/// Also called for newly created objects, before
+		/// they are given out for the first time.
+	{
+	}
+	
+	void deactivateObject(P pObject)
+		/// Called after an object has been given back to the
+		/// pool and the object is still valid (a prior call
+		/// to validateObject() returned true).
+		///
+		/// To maintain the integrity of the pool, this method
+		/// must not throw an exception.
+	{
+	}
+	
+	void destroyObject(P pObject)
+		/// Destroy an object.
+		///
+		/// To maintain the integrity of the pool, this method
+		/// must not throw an exception.
+	{
+		delete pObject;
+	}
+};
+
+
+template <class C>
+class PoolableObjectFactory <C, Poco::AutoPtr<C> >
+{
+public:
+	Poco::AutoPtr<C> createObject()
+	{
+		return new C;
+	}
+	
+	bool validateObject(Poco::AutoPtr<C> pObject)
+	{
+		return true;
+	}
+	
+	void activateObject(Poco::AutoPtr<C> pObject)
+	{
+	}
+	
+	void deactivateObject(Poco::AutoPtr<C> pObject)
+	{
+	}
+	
+	void destroyObject(Poco::AutoPtr<C> pObject)
+	{
+	}
+};
+
+
+template <class C>
+class PoolableObjectFactory <C, Poco::SharedPtr<C> >
+{
+public:
+	Poco::SharedPtr<C> createObject()
+	{
+		return new C;
+	}
+	
+	bool validateObject(Poco::SharedPtr<C> pObject)
+	{
+		return true;
+	}
+	
+	void activateObject(Poco::SharedPtr<C> pObject)
+	{
+	}
+	
+	void deactivateObject(Poco::SharedPtr<C> pObject)
+	{
+	}
+	
+	void destroyObject(Poco::SharedPtr<C> pObject)
+	{
+	}
+};
+
+
+template <class C, class P = C*, class F = PoolableObjectFactory<C, P> >
+class ObjectPool
+	/// An ObjectPool manages a pool of objects of a certain class.
+	///
+	/// The number of objects managed by the pool can be restricted.
+	///
+	/// When an object is requested from the pool:
+	///   - If an object is available from the pool, an object from the pool is
+	///     removed from the pool, activated (using the factory) and returned.
+	///   - Otherwise, if the peak capacity of the pool has not yet been reached,
+	///     a new object is created and activated, using the object factory, and returned.
+	///   - If the peak capacity has already been reached, null is returned after timeout.
+	///
+	/// When an object is returned to the pool:
+	///   - If the object is valid (checked by calling validateObject()
+	///     from the object factory), the object is deactivated. If the
+	///     number of objects in the pool is below the capacity,
+	///     the object is added to the pool. Otherwise it is destroyed.
+	///   - If the object is not valid, it is destroyed immediately.
+{
+public:
+	ObjectPool(std::size_t capacity, std::size_t peakCapacity):
+		/// Creates a new ObjectPool with the given capacity
+		/// and peak capacity.
+		///
+		/// The PoolableObjectFactory must have a public default constructor.
+		_capacity(capacity),
+		_peakCapacity(peakCapacity),
+		_size(0)
+	{
+		poco_assert (capacity <= peakCapacity);
+	}
+	
+	ObjectPool(const F& factory, std::size_t capacity, std::size_t peakCapacity):
+		/// Creates a new ObjectPool with the given PoolableObjectFactory,
+		/// capacity and peak capacity. The PoolableObjectFactory must have
+		/// a public copy constructor.
+		_factory(factory),
+		_capacity(capacity),
+		_peakCapacity(peakCapacity),
+		_size(0)
+	{
+		poco_assert (capacity <= peakCapacity);
+	}
+	
+	~ObjectPool()
+		/// Destroys the ObjectPool.
+	{
+		try
+		{
+			for (typename std::vector<P>::iterator it = _pool.begin(); it != _pool.end(); ++it)
+			{
+				_factory.destroyObject(*it);
+			}
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	}
+		
+	P borrowObject(long timeoutMilliseconds = 0)
+		/// Obtains an object from the pool, or creates a new object if
+		/// possible.
+		///
+		/// Returns null if no object is available after timeout.
+		///
+		/// If activating the object fails, the object is destroyed and
+		/// the exception is passed on to the caller.
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+
+		if (!_pool.empty())
+		{
+			P pObject = _pool.back();
+			_pool.pop_back();
+			return activateObject(pObject);
+		}
+
+		if (_size >= _peakCapacity)
+		{
+			if (timeoutMilliseconds == 0)
+			{
+				return 0;
+			}
+			while (_size >= _peakCapacity)
+			{
+				if ( !_availableCondition.tryWait(_mutex, timeoutMilliseconds))
+				{
+					// timeout
+					return 0;
+				}
+			}
+		}
+
+		// _size < _peakCapacity
+		P pObject = _factory.createObject();
+		activateObject(pObject);
+		_size++;
+		return pObject;
+	}
+
+	void returnObject(P pObject)
+		/// Returns an object to the pool.
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+
+		if (_factory.validateObject(pObject))
+		{
+			_factory.deactivateObject(pObject);
+			if (_pool.size() < _capacity)
+			{
+				try
+				{
+					_pool.push_back(pObject);
+					return;
+				}
+				catch (...)
+				{
+				}
+			}
+		}
+		_factory.destroyObject(pObject);
+		_size--;
+		_availableCondition.signal();
+	}
+
+	std::size_t capacity() const
+	{
+		return _capacity;
+	}
+	
+	std::size_t peakCapacity() const
+	{
+		return _peakCapacity;
+	}
+	
+	std::size_t size() const
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+		
+		return _size;
+	}
+	
+	std::size_t available() const
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+
+		return _pool.size() + _peakCapacity - _size;
+	}
+
+protected:
+	P activateObject(P pObject)
+	{
+		try
+		{
+			_factory.activateObject(pObject);
+		}
+		catch (...)
+		{
+			_factory.destroyObject(pObject);
+			throw;
+		}
+		return pObject;
+	}
+	
+private:
+	ObjectPool();
+	ObjectPool(const ObjectPool&);
+	ObjectPool& operator = (const ObjectPool&);
+	
+	F _factory;
+	std::size_t _capacity;
+	std::size_t _peakCapacity;
+	std::size_t _size;
+	std::vector<P> _pool;
+	mutable Poco::FastMutex _mutex;
+	Poco::Condition _availableCondition;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ObjectPool_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Observer.h b/base/poco/Foundation/include/Poco/Observer.h
new file mode 100644
index 00000000000..98d94e0621d
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Observer.h
@@ -0,0 +1,124 @@
+//
+// Observer.h
+//
+// Library: Foundation
+// Package: Notifications
+// Module:  NotificationCenter
+//
+// Definition of the Observer class template.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Observer_INCLUDED
+#define Foundation_Observer_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/AbstractObserver.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+
+
+template <class C, class N>
+class Observer: public AbstractObserver
+	/// This template class implements an adapter that sits between
+	/// a NotificationCenter and an object receiving notifications
+	/// from it. It is quite similar in concept to the 
+	/// RunnableAdapter, but provides some NotificationCenter
+	/// specific additional methods.
+	/// See the NotificationCenter class for information on how
+	/// to use this template class.
+	///
+	/// Instead of the Observer class template, you might want to
+	/// use the NObserver class template, which uses an AutoPtr to
+	/// pass the Notification to the callback function, thus freeing
+	/// you from memory management issues.
+{
+public:
+	typedef void (C::*Callback)(N*);
+
+	Observer(C& object, Callback method): 
+		_pObject(&object), 
+		_method(method)
+	{
+	}
+	
+	Observer(const Observer& observer):
+		AbstractObserver(observer),
+		_pObject(observer._pObject), 
+		_method(observer._method)
+	{
+	}
+	
+	~Observer()
+	{
+	}
+	
+	Observer& operator = (const Observer& observer)
+	{
+		if (&observer != this)
+		{
+			_pObject = observer._pObject;
+			_method  = observer._method;
+		}
+		return *this;
+	}
+	
+	void notify(Notification* pNf) const
+	{
+		Poco::Mutex::ScopedLock lock(_mutex);
+
+		if (_pObject)
+		{
+			N* pCastNf = dynamic_cast<N*>(pNf);
+			if (pCastNf)
+			{
+				pCastNf->duplicate();
+				(_pObject->*_method)(pCastNf);
+			}
+		}
+	}
+	
+	bool equals(const AbstractObserver& abstractObserver) const
+	{
+		const Observer* pObs = dynamic_cast<const Observer*>(&abstractObserver);
+		return pObs && pObs->_pObject == _pObject && pObs->_method == _method;
+	}
+
+	bool accepts(Notification* pNf) const
+	{
+		return dynamic_cast<N*>(pNf) != 0;
+	}
+	
+	AbstractObserver* clone() const
+	{
+		return new Observer(*this);
+	}
+	
+	void disable()
+	{
+		Poco::Mutex::ScopedLock lock(_mutex);
+		
+		_pObject = 0;
+	}
+	
+private:
+	Observer();
+
+	C*       _pObject;
+	Callback _method;
+	mutable Poco::Mutex _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Observer_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Optional.h b/base/poco/Foundation/include/Poco/Optional.h
new file mode 100644
index 00000000000..54593b16cc5
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Optional.h
@@ -0,0 +1,161 @@
+//
+// Optional.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Optional
+//
+// Definition of the Optional class template.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Optional_INCLUDED
+#define Foundation_Optional_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include <algorithm>
+
+
+namespace Poco {
+
+
+template <typename C>
+class Optional
+	/// Optional is a simple wrapper class for value types
+	/// that allows to introduce a specified/unspecified state
+	/// to value objects.
+	///
+	/// An Optional can be default constructed. In this case, 
+	/// the Optional will have a Null value and isSpecified() will
+	/// return false. Calling value()(without default value) on
+	/// a Null object will throw a NullValueException.
+	///
+	/// An Optional can also be constructed from a value.
+	/// It is possible to assign a value to an Optional, and
+	/// to reset an Optional to contain a Null value by calling
+	/// clear().
+	///
+	/// For use with Optional, the value type should support
+	/// default construction.
+	///
+	/// Note that the Optional class is basically the same as
+	/// Nullable. However, serializers may treat Nullable
+	/// and Optional differently. An example is XML serialization based
+	/// on XML Schema, where Optional would be used for an element with
+	/// minOccurs == 0, whereas Nullable would be used on an element with
+	/// nillable == true.
+{
+public:
+	Optional(): 
+		/// Creates an empty Optional.
+		_value(),
+		_isSpecified(false)
+	{
+	}
+
+	Optional(const C& value): 
+		/// Creates a Optional with the given value.
+		_value(value), 
+		_isSpecified(true)
+	{
+	}
+	
+	Optional(const Optional& other):
+		/// Creates a Optional by copying another one.
+		_value(other._value),
+		_isSpecified(other._isSpecified)
+	{
+	}
+
+	~Optional()
+		/// Destroys the Optional.
+	{
+	}
+
+	Optional& assign(const C& value)
+		/// Assigns a value to the Optional.
+	{
+		_value  = value;
+		_isSpecified = true;
+		return *this;
+	}
+	
+	Optional& assign(const Optional& other)
+		/// Assigns another Optional.
+	{
+		Optional tmp(other);
+		swap(tmp);
+		return *this;
+	}
+	
+	Optional& operator = (const C& value)
+	{
+		return assign(value);
+	}
+
+	Optional& operator = (const Optional& other)
+	{
+		return assign(other);
+	}
+
+	void swap(Optional& other)
+	{
+		std::swap(_value, other._value);
+		std::swap(_isSpecified, other._isSpecified);
+	}
+
+	const C& value() const
+		/// Returns the Optional's value.
+		///
+		/// Throws a Poco::NullValueException if the value has not been specified.
+	{
+		if (_isSpecified)
+			return _value;
+		else
+			throw Poco::NullValueException();
+	}
+
+	const C& value(const C& deflt) const
+		/// Returns the Optional's value, or the
+		/// given default value if the Optional's 
+		/// value has not been specified.
+	{
+		return _isSpecified ? _value : deflt;
+	}
+
+	bool isSpecified() const
+		/// Returns true iff the Optional's value has been specified.
+	{
+		return _isSpecified;
+	}
+	
+	void clear()
+		/// Clears the Optional.
+	{
+		_isSpecified = false;
+	}
+
+private:
+	C _value;
+	bool _isSpecified;
+};
+
+
+template <typename C>
+inline void swap(Optional<C>& n1, Optional<C>& n2)
+{
+	n1.swap(n2);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Optional_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/PBKDF2Engine.h b/base/poco/Foundation/include/Poco/PBKDF2Engine.h
new file mode 100644
index 00000000000..357d482afe4
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/PBKDF2Engine.h
@@ -0,0 +1,149 @@
+//
+// PBKDF2Engine.h
+//
+// Library: Foundation
+// Package: Crypt
+// Module:  PBKDF2Engine
+//
+// Definition of the PBKDF2Engine class.
+//
+// Copyright (c) 2014, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_PBKDF2Engine_INCLUDED
+#define Foundation_PBKDF2Engine_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/DigestEngine.h"
+#include "Poco/ByteOrder.h"
+#include <algorithm>
+
+
+namespace Poco {
+
+
+template <class PRF>
+class PBKDF2Engine: public DigestEngine
+	/// This class implementes the Password-Based Key Derivation Function 2,
+	/// as specified in RFC 2898. The underlying DigestEngine (HMACEngine, etc.),
+	/// which must accept the passphrase as constructor argument (std::string), 
+	/// must be given as template argument. 
+	///
+	/// PBKDF2 (Password-Based Key Derivation Function 2) is a key derivation function 
+	/// that is part of RSA Laboratories' Public-Key Cryptography Standards (PKCS) series, 
+	/// specifically PKCS #5 v2.0, also published as Internet Engineering Task Force's 
+	/// RFC 2898. It replaces an earlier standard, PBKDF1, which could only produce 
+	/// derived keys up to 160 bits long.
+	///
+	/// PBKDF2 applies a pseudorandom function, such as a cryptographic hash, cipher, or 
+	/// HMAC to the input password or passphrase along with a salt value and repeats the 
+	/// process many times to produce a derived key, which can then be used as a 
+	/// cryptographic key in subsequent operations. The added computational work makes 
+	/// password cracking much more difficult, and is known as key stretching. 
+	/// When the standard was written in 2000, the recommended minimum number of 
+	/// iterations was 1000, but the parameter is intended to be increased over time as 
+	/// CPU speeds increase. Having a salt added to the password reduces the ability to 
+	/// use precomputed hashes (rainbow tables) for attacks, and means that multiple 
+	/// passwords have to be tested individually, not all at once. The standard 
+	/// recommends a salt length of at least 64 bits. [Wikipedia]
+	///
+	/// The PBKDF2 algorithm is implemented as a DigestEngine. The passphrase is specified
+	/// by calling update().
+	///
+	/// Example (WPA2):
+	///     PBKDF2Engine<HMACEngine<SHA1Engine> > pbkdf2(ssid, 4096, 256);
+	///     pbkdf2.update(passphrase);
+	///     DigestEngine::Digest d = pbkdf2.digest();
+{
+public:
+	enum
+	{
+		PRF_DIGEST_SIZE = PRF::DIGEST_SIZE
+	};
+	
+	PBKDF2Engine(const std::string& salt, unsigned c = 4096, Poco::UInt32 dkLen = PRF_DIGEST_SIZE):
+		_s(salt),
+		_c(c),
+		_dkLen(dkLen)
+	{		
+		_result.reserve(_dkLen + PRF_DIGEST_SIZE);
+	}
+	
+	~PBKDF2Engine()
+	{
+	}
+		
+	std::size_t digestLength() const
+	{
+		return _dkLen;
+	}
+	
+	void reset()
+	{
+		_p.clear();
+		_result.clear();
+	}
+	
+	const DigestEngine::Digest& digest()
+	{
+		Poco::UInt32 i = 1;
+		while (_result.size() < _dkLen)
+		{
+			f(i++);
+		}
+		_result.resize(_dkLen);
+		return _result;
+	}
+
+protected:
+	void updateImpl(const void* data, std::size_t length)
+	{
+		_p.append(reinterpret_cast<const char*>(data), length);
+	}
+	
+	void f(Poco::UInt32 i)
+	{
+		PRF prf(_p);
+		prf.update(_s);
+		Poco::UInt32 iBE = Poco::ByteOrder::toBigEndian(i);
+		prf.update(&iBE, sizeof(iBE));
+		Poco::DigestEngine::Digest up = prf.digest();
+		Poco::DigestEngine::Digest ux = up;
+		poco_assert_dbg(ux.size() == PRF_DIGEST_SIZE);
+		for (unsigned k = 1; k < _c; k++)
+		{
+			prf.reset();
+			prf.update(&up[0], up.size());
+			Poco::DigestEngine::Digest u = prf.digest();
+			poco_assert_dbg(u.size() == PRF_DIGEST_SIZE);
+			for (int ui = 0; ui < PRF_DIGEST_SIZE; ui++)
+			{
+				ux[ui] ^= u[ui];
+			}
+			std::swap(up, u);
+		}
+		_result.insert(_result.end(), ux.begin(), ux.end());
+	}
+
+private:
+	PBKDF2Engine();
+	PBKDF2Engine(const PBKDF2Engine&);
+	PBKDF2Engine& operator = (const PBKDF2Engine&);
+
+	std::string _p;
+	std::string _s;
+	unsigned _c;
+	Poco::UInt32 _dkLen;
+	DigestEngine::Digest _result;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_PBKDF2Engine_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Path.h b/base/poco/Foundation/include/Poco/Path.h
new file mode 100644
index 00000000000..c50c1a1a862
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Path.h
@@ -0,0 +1,501 @@
+//
+// Path.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  Path
+//
+// Definition of the Path class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Path_INCLUDED
+#define Foundation_Path_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <vector>
+
+
+namespace Poco {
+
+
+class Foundation_API Path
+	/// This class represents filesystem paths in a 
+	/// platform-independent manner.
+	/// Unix, Windows and OpenVMS all use a different
+	/// syntax for filesystem paths.
+	/// This class can work with all three formats.
+	/// A path is made up of an optional node name
+	/// (only Windows and OpenVMS), an optional
+	/// device name (also only Windows and OpenVMS),
+	/// a list of directory names and an optional
+	/// filename.
+{
+public:
+	enum Style
+	{
+		PATH_UNIX,    /// Unix-style path
+		PATH_WINDOWS, /// Windows-style path
+		PATH_VMS,     /// VMS-style path
+		PATH_NATIVE,  /// The current platform's native style
+		PATH_GUESS    /// Guess the style by examining the path
+	};
+	
+	typedef std::vector<std::string> StringVec;
+
+	Path();
+		/// Creates an empty relative path.
+
+	Path(bool absolute);
+		/// Creates an empty absolute or relative path.
+
+	Path(const char* path);
+		/// Creates a path from a string.
+
+	Path(const char* path, Style style);
+		/// Creates a path from a string.
+
+	Path(const std::string& path);
+		/// Creates a path from a string.
+
+	Path(const std::string& path, Style style);
+		/// Creates a path from a string.
+
+	Path(const Path& path);
+		/// Copy constructor
+
+	Path(const Path& parent, const std::string& fileName);
+		/// Creates a path from a parent path and a filename.
+		/// The parent path is expected to reference a directory.
+
+	Path(const Path& parent, const char* fileName);
+		/// Creates a path from a parent path and a filename.
+		/// The parent path is expected to reference a directory.
+
+	Path(const Path& parent, const Path& relative);
+		/// Creates a path from a parent path and a relative path.
+		/// The parent path is expected to reference a directory.
+		/// The relative path is appended to the parent path.
+
+	~Path();
+		/// Destroys the Path.
+		
+	Path& operator = (const Path& path);
+		/// Assignment operator.
+		
+	Path& operator = (const std::string& path);
+		/// Assigns a string containing a path in native format.
+
+	Path& operator = (const char* path);
+		/// Assigns a string containing a path in native format.
+
+	void swap(Path& path);
+		/// Swaps the path with another one.
+
+	Path& assign(const std::string& path);
+		/// Assigns a string containing a path in native format.
+		
+	Path& assign(const std::string& path, Style style);
+		/// Assigns a string containing a path.
+
+	Path& assign(const Path& path);
+		/// Assigns the given path.
+		
+	Path& assign(const char* path);
+		/// Assigns a string containing a path.
+
+	std::string toString() const;
+		/// Returns a string containing the path in native format.
+		
+	std::string toString(Style style) const;
+		/// Returns a string containing the path in the given format.
+		
+	Path& parse(const std::string& path);
+		/// Same as assign().
+
+	Path& parse(const std::string& path, Style style);
+		/// Assigns a string containing a path.
+
+	bool tryParse(const std::string& path);
+		/// Tries to interpret the given string as a path
+		/// in native format.
+		/// If the path is syntactically valid, assigns the
+		/// path and returns true. Otherwise leaves the 
+		/// object unchanged and returns false.
+
+	bool tryParse(const std::string& path, Style style);
+		/// Tries to interpret the given string as a path,
+		/// according to the given style.
+		/// If the path is syntactically valid, assigns the
+		/// path and returns true. Otherwise leaves the
+		/// object unchanged and returns false.
+
+	Path& parseDirectory(const std::string& path);
+		/// The resulting path always refers to a directory and
+		/// the filename part is empty.
+
+	Path& parseDirectory(const std::string& path, Style style);
+		/// The resulting path always refers to a directory and
+		/// the filename part is empty.
+
+	Path& makeDirectory();
+		/// If the path contains a filename, the filename is appended
+		/// to the directory list and cleared. Thus the resulting path
+		/// always refers to a directory.
+
+	Path& makeFile();
+		/// If the path contains no filename, the last directory
+		/// becomes the filename.
+
+	Path& makeParent();
+		/// Makes the path refer to its parent.
+		
+	Path& makeAbsolute();
+		/// Makes the path absolute if it is relative.
+		/// The current working directory is taken as base directory.
+
+	Path& makeAbsolute(const Path& base);
+		/// Makes the path absolute if it is relative.
+		/// The given path is taken as base. 
+
+	Path& append(const Path& path);
+		/// Appends the given path.
+		
+	Path& resolve(const Path& path);
+		/// Resolves the given path agains the current one.
+		///
+		/// If the given path is absolute, it replaces the current one.
+		/// Otherwise, the relative path is appended to the current path.
+
+	bool isAbsolute() const;
+		/// Returns true iff the path is absolute.
+		
+	bool isRelative() const;
+		/// Returns true iff the path is relative.
+	
+	bool isDirectory() const;
+		/// Returns true iff the path references a directory
+		/// (the filename part is empty).
+		
+	bool isFile() const;
+		/// Returns true iff the path references a file
+		/// (the filename part is not empty).
+	
+	Path& setNode(const std::string& node);
+		/// Sets the node name.
+		/// Setting a non-empty node automatically makes
+		/// the path an absolute one.
+		
+	const std::string& getNode() const;
+		/// Returns the node name.
+		
+	Path& setDevice(const std::string& device);
+		/// Sets the device name.
+		/// Setting a non-empty device automatically makes
+		/// the path an absolute one.
+		
+	const std::string& getDevice() const;
+		/// Returns the device name.
+	
+	int depth() const;
+		/// Returns the number of directories in the directory list.
+
+	const std::string& directory(int n) const;
+		/// Returns the n'th directory in the directory list.
+		/// If n == depth(), returns the filename.
+		
+	const std::string& operator [] (int n) const;
+		/// Returns the n'th directory in the directory list.
+		/// If n == depth(), returns the filename.
+		
+	Path& pushDirectory(const std::string& dir);
+		/// Adds a directory to the directory list.
+		
+	Path& popDirectory();
+		/// Removes the last directory from the directory list.
+		
+	Path& popFrontDirectory();
+		/// Removes the first directory from the directory list.
+		
+	Path& setFileName(const std::string& name);
+		/// Sets the filename.
+		
+	const std::string& getFileName() const;
+		/// Returns the filename.
+
+	Path& setBaseName(const std::string& name);
+		/// Sets the basename part of the filename and
+		/// does not change the extension.
+
+	std::string getBaseName() const;
+		/// Returns the basename (the filename sans
+		/// extension) of the path.
+
+	Path& setExtension(const std::string& extension);
+		/// Sets the filename extension.
+				
+	std::string getExtension() const;
+		/// Returns the filename extension.
+		
+	const std::string& version() const;
+		/// Returns the file version. VMS only.
+		
+	Path& clear();
+		/// Clears all components.
+
+	Path parent() const;
+		/// Returns a path referring to the path's
+		/// directory.
+		
+	Path absolute() const;
+		/// Returns an absolute variant of the path,
+		/// taking the current working directory as base.
+
+	Path absolute(const Path& base) const;
+		/// Returns an absolute variant of the path,
+		/// taking the given path as base.
+
+	static Path forDirectory(const std::string& path);
+		/// Creates a path referring to a directory.
+
+	static Path forDirectory(const std::string& path, Style style);
+		/// Creates a path referring to a directory.
+
+	static char separator();
+		/// Returns the platform's path name separator, which separates
+		/// the components (names) in a path. 
+		///
+		/// On Unix systems, this is the slash '/'. On Windows systems, 
+		/// this is the backslash '\'. On OpenVMS systems, this is the
+		/// period '.'.
+		
+	static char pathSeparator();
+		/// Returns the platform's path separator, which separates
+		/// single paths in a list of paths.
+		///
+		/// On Unix systems, this is the colon ':'. On Windows systems,
+		/// this is the semicolon ';'. On OpenVMS systems, this is the
+		/// comma ','.
+
+	static std::string current();
+		/// Returns the current working directory.
+		
+	static std::string home();
+		/// Returns the user's home directory.
+
+	static std::string configHome();
+		/// Returns the user's config directory.
+		///
+		/// On Unix systems, this is the '~/.config/'. On Windows systems,
+		/// this is '%APPDATA%'.
+
+	static std::string dataHome();
+		/// Returns the user's data directory.
+		///
+		/// On Unix systems, this is the '~/.local/share/'. On Windows systems,
+		/// this is '%APPDATA%'.
+
+	static std::string tempHome();
+		/// Returns the user's temp directory.
+		///
+		/// On Unix systems, this is the '~/.local/temp/'.
+
+	static std::string cacheHome();
+		/// Returns the user's cache directory.
+		///
+		/// On Unix systems, this is the '~/.cache/'. On Windows systems,
+		/// this is '%APPDATA%'.
+
+	static std::string temp();
+		/// Returns the temporary directory.
+		
+	static std::string config();
+		/// Returns the systemwide config directory.
+		///
+		/// On Unix systems, this is the '/etc/'.
+		
+	static std::string null();
+		/// Returns the name of the null device.
+		
+	static std::string expand(const std::string& path);
+		/// Expands all environment variables contained in the path.
+		///
+		/// On Unix, a tilde as first character in the path is
+		/// replaced with the path to user's home directory.
+
+	static void listRoots(std::vector<std::string>& roots);
+		/// Fills the vector with all filesystem roots available on the
+		/// system. On Unix, there is exactly one root, "/".
+		/// On Windows, the roots are the drive letters.
+		/// On OpenVMS, the roots are the mounted disks.
+		
+	static bool find(StringVec::const_iterator it, StringVec::const_iterator end, const std::string& name, Path& path);
+		/// Searches the file with the given name in the locations (paths) specified
+		/// by it and end. A relative path may be given in name.
+		///
+		/// If the file is found in one of the locations, the complete
+		/// path of the file is stored in the path given as argument and true is returned. 
+		/// Otherwise false is returned and the path argument remains unchanged.
+
+	static bool find(const std::string& pathList, const std::string& name, Path& path);
+		/// Searches the file with the given name in the locations (paths) specified
+		/// in pathList. The paths in pathList must be delimited by the platform's
+		/// path separator (see pathSeparator()). A relative path may be given in name.
+		///
+		/// If the file is found in one of the locations, the complete
+		/// path of the file is stored in the path given as argument and true is returned. 
+		/// Otherwise false is returned and the path argument remains unchanged.
+		
+	static std::string transcode(const std::string& path);
+		/// On Windows, if POCO has been compiled with Windows UTF-8 support 
+		/// (POCO_WIN32_UTF8), this function converts a string (usually containing a path) 
+		/// encoded in UTF-8 into a string encoded in the current Windows code page.
+		/// 
+		/// This function should be used for every string passed as a file name to
+		/// a string stream or fopen().
+		///
+		/// On all other platforms, or if POCO has not been compiled with Windows UTF-8
+		/// support, this function returns the string unchanged.
+
+protected:
+	void parseUnix(const std::string& path);
+	void parseWindows(const std::string& path);
+	void parseVMS(const std::string& path);
+	void parseGuess(const std::string& path);
+	std::string buildUnix() const;
+	std::string buildWindows() const;
+	std::string buildVMS() const;
+
+private:
+	std::string _node;
+	std::string _device;
+	std::string _name;
+	std::string _version;
+	StringVec   _dirs;
+	bool        _absolute;
+};
+
+
+//
+// inlines
+//
+inline bool Path::isAbsolute() const
+{
+	return _absolute;
+}
+
+	
+inline bool Path::isRelative() const
+{
+	return !_absolute;
+}
+
+
+inline bool Path::isDirectory() const
+{
+	return _name.empty();
+}
+
+
+inline bool Path::isFile() const
+{
+	return !_name.empty();
+}
+
+
+inline Path& Path::parse(const std::string& path)
+{
+	return assign(path);
+}
+
+
+inline Path& Path::parse(const std::string& path, Style style)
+{
+	return assign(path, style);
+}
+
+
+inline const std::string& Path::getNode() const
+{
+	return _node;
+}
+
+
+inline const std::string& Path::getDevice() const
+{
+	return _device;
+}
+
+
+inline const std::string& Path::getFileName() const
+{
+	return _name;
+}
+
+
+inline int Path::depth() const
+{
+	return int(_dirs.size());
+}
+
+
+inline const std::string& Path::version() const
+{
+	return _version;
+}
+
+
+inline Path Path::forDirectory(const std::string& path)
+{
+	Path p;
+	return p.parseDirectory(path);
+}
+	
+
+inline Path Path::forDirectory(const std::string& path, Style style)
+{
+	Path p;
+	return p.parseDirectory(path, style);
+}
+
+
+inline char Path::separator()
+{
+#if defined(POCO_OS_FAMILY_VMS)
+	return '.';
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+	return '\\';
+#else
+	return '/';
+#endif
+}
+
+
+inline char Path::pathSeparator()
+{
+#if defined(POCO_OS_FAMILY_VMS)
+	return ',';
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+	return ';';
+#else
+	return ':';
+#endif
+}
+
+
+inline void swap(Path& p1, Path& p2)
+{
+	p1.swap(p2);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Path_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Path_UNIX.h b/base/poco/Foundation/include/Poco/Path_UNIX.h
new file mode 100644
index 00000000000..50a6478b926
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Path_UNIX.h
@@ -0,0 +1,48 @@
+//
+// Path_UNIX.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  Path
+//
+// Definition of the PathImpl class fo rUnix.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Path_UNIX_INCLUDED
+#define Foundation_Path_UNIX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <vector>
+
+
+namespace Poco {
+
+
+class PathImpl
+{
+public:
+	static std::string currentImpl();
+	static std::string homeImpl();
+	static std::string configHomeImpl();
+	static std::string dataHomeImpl();
+	static std::string tempHomeImpl();
+	static std::string cacheHomeImpl();
+	static std::string tempImpl();
+	static std::string configImpl();
+	static std::string nullImpl();
+	static std::string expandImpl(const std::string& path);
+	static void listRootsImpl(std::vector<std::string>& roots);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Path_UNIX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Path_WIN32.h b/base/poco/Foundation/include/Poco/Path_WIN32.h
new file mode 100644
index 00000000000..02a3a5b281b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Path_WIN32.h
@@ -0,0 +1,49 @@
+//
+// Path_WIN32.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  Path
+//
+// Definition of the PathImpl class for WIN32.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Path_WIN32_INCLUDED
+#define Foundation_Path_WIN32_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <vector>
+
+
+namespace Poco {
+
+
+class Foundation_API PathImpl
+{
+public:
+	static std::string currentImpl();
+	static std::string homeImpl();
+	static std::string configHomeImpl();
+	static std::string dataHomeImpl();
+	static std::string cacheHomeImpl();
+	static std::string tempHomeImpl();
+	static std::string tempImpl();
+	static std::string configImpl();
+	static std::string nullImpl();
+	static std::string systemImpl();
+	static std::string expandImpl(const std::string& path);
+	static void listRootsImpl(std::vector<std::string>& roots);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Path_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Path_WIN32U.h b/base/poco/Foundation/include/Poco/Path_WIN32U.h
new file mode 100644
index 00000000000..94fca2b0a78
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Path_WIN32U.h
@@ -0,0 +1,54 @@
+//
+// Path_WIN32U.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  Path
+//
+// Definition of the PathImpl class for WIN32.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Path_WIN32U_INCLUDED
+#define Foundation_Path_WIN32U_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <vector>
+
+
+namespace Poco {
+
+
+class Foundation_API PathImpl
+{
+public:
+	static std::string currentImpl();
+	static std::string homeImpl();
+	static std::string configHomeImpl();
+	static std::string dataHomeImpl();
+	static std::string cacheHomeImpl();
+	static std::string tempHomeImpl();
+	static std::string tempImpl();
+	static std::string configImpl();
+	static std::string nullImpl();
+	static std::string systemImpl();
+	static std::string expandImpl(const std::string& path);
+	static void listRootsImpl(std::vector<std::string>& roots);
+	
+	enum
+	{
+		MAX_PATH_LEN = 32767
+	};
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Path_WIN32U_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Path_WINCE.h b/base/poco/Foundation/include/Poco/Path_WINCE.h
new file mode 100644
index 00000000000..a32e3316ad8
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Path_WINCE.h
@@ -0,0 +1,54 @@
+//
+// Path_WINCE.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  Path
+//
+// Definition of the PathImpl class for WIN32.
+//
+// Copyright (c) 2006-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Path_WINCE_INCLUDED
+#define Foundation_Path_WINCE_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <vector>
+
+
+namespace Poco {
+
+
+class Foundation_API PathImpl
+{
+public:
+	static std::string currentImpl();
+	static std::string homeImpl();
+	static std::string configHomeImpl();
+	static std::string dataHomeImpl();
+	static std::string cacheHomeImpl();
+	static std::string tempHomeImpl();
+	static std::string tempImpl();
+	static std::string configImpl();
+	static std::string nullImpl();
+	static std::string systemImpl();
+	static std::string expandImpl(const std::string& path);
+	static void listRootsImpl(std::vector<std::string>& roots);
+	
+	enum
+	{
+		MAX_PATH_LEN = 32767
+	};
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Path_WINCE_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/PatternFormatter.h b/base/poco/Foundation/include/Poco/PatternFormatter.h
new file mode 100644
index 00000000000..cdbb0f08dbc
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/PatternFormatter.h
@@ -0,0 +1,148 @@
+//
+// PatternFormatter.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  PatternFormatter
+//
+// Definition of the PatternFormatter class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_PatternFormatter_INCLUDED
+#define Foundation_PatternFormatter_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Formatter.h"
+#include "Poco/Message.h"
+
+#include <vector>
+
+namespace Poco {
+
+
+class Foundation_API PatternFormatter: public Formatter
+	/// This Formatter allows for custom formatting of
+	/// log messages based on format patterns.
+	///
+	/// The format pattern is used as a template to format the message and
+	/// is copied character by character except for the following special characters,
+	/// which are replaced by the corresponding value.
+	///
+	///   * %s - message source
+	///   * %t - message text
+	///   * %l - message priority level (1 .. 7)
+	///   * %p - message priority (Fatal, Critical, Error, Warning, Notice, Information, Debug, Trace)
+	///   * %q - abbreviated message priority (F, C, E, W, N, I, D, T)
+	///   * %P - message process identifier
+	///   * %T - message thread name
+	///   * %I - message thread identifier (numeric)
+	///   * %N - node or host name
+	///   * %U - message source file path (empty string if not set)
+	///   * %u - message source line number (0 if not set)
+	///   * %w - message date/time abbreviated weekday (Mon, Tue, ...)
+	///   * %W - message date/time full weekday (Monday, Tuesday, ...)
+	///   * %b - message date/time abbreviated month (Jan, Feb, ...)
+	///   * %B - message date/time full month (January, February, ...)
+	///   * %d - message date/time zero-padded day of month (01 .. 31)
+	///   * %e - message date/time day of month (1 .. 31)
+	///   * %f - message date/time space-padded day of month ( 1 .. 31)
+	///   * %m - message date/time zero-padded month (01 .. 12)
+	///   * %n - message date/time month (1 .. 12)
+	///   * %o - message date/time space-padded month ( 1 .. 12)
+	///   * %y - message date/time year without century (70)
+	///   * %Y - message date/time year with century (1970)
+	///   * %H - message date/time hour (00 .. 23)
+	///   * %h - message date/time hour (00 .. 12)
+	///   * %a - message date/time am/pm
+	///   * %A - message date/time AM/PM
+	///   * %M - message date/time minute (00 .. 59)
+	///   * %S - message date/time second (00 .. 59)
+	///   * %i - message date/time millisecond (000 .. 999)
+	///   * %c - message date/time centisecond (0 .. 9)
+	///   * %F - message date/time fractional seconds/microseconds (000000 - 999999)
+	///   * %z - time zone differential in ISO 8601 format (Z or +NN.NN)
+	///   * %Z - time zone differential in RFC format (GMT or +NNNN)
+	///   * %L - convert time to local time (must be specified before any date/time specifier; does not itself output anything)
+	///   * %E - epoch time (UTC, seconds since midnight, January 1, 1970)
+	///   * %v[width] - the message source (%s) but text length is padded/cropped to 'width'
+	///   * %[name] - the value of the message parameter with the given name
+	///   * %% - percent sign
+
+{
+public:
+	PatternFormatter();
+		/// Creates a PatternFormatter.
+		/// The format pattern must be specified with
+		/// a call to setProperty.
+
+	PatternFormatter(const std::string& format);
+		/// Creates a PatternFormatter that uses the
+		/// given format pattern.
+
+	~PatternFormatter();
+		/// Destroys the PatternFormatter.
+
+	void format(const Message& msg, std::string& text);
+		/// Formats the message according to the specified
+		/// format pattern and places the result in text. 
+		
+	void setProperty(const std::string& name, const std::string& value);
+		/// Sets the property with the given name to the given value.
+		///
+		/// The following properties are supported:
+		/// 
+		///     * pattern: The format pattern. See the PatternFormatter class
+		///       for details.
+		///     * times: Specifies whether times are adjusted for local time
+		///       or taken as they are in UTC. Supported values are "local" and "UTC".
+		///
+		/// If any other property name is given, a PropertyNotSupported
+		/// exception is thrown.
+
+	std::string getProperty(const std::string& name) const;
+		/// Returns the value of the property with the given name or
+		/// throws a PropertyNotSupported exception if the given
+		/// name is not recognized.
+
+	static const std::string PROP_PATTERN;
+	static const std::string PROP_TIMES;
+
+protected:
+	static const std::string& getPriorityName(int);
+		/// Returns a string for the given priority value.
+	
+private:
+	struct PatternAction
+	{
+		PatternAction(): key(0), length(0) 
+		{
+		}
+
+		char key;
+		int length;
+		std::string property;
+		std::string prepend;
+	};
+
+	void parsePattern();
+		/// Will parse the _pattern string into the vector of PatternActions,
+		/// which contains the message key, any text that needs to be written first
+		/// a proprety in case of %[] and required length.
+
+	std::vector<PatternAction> _patternActions;
+	bool _localTime;
+	std::string _pattern;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_PatternFormatter_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Pipe.h b/base/poco/Foundation/include/Poco/Pipe.h
new file mode 100644
index 00000000000..89704b12bcf
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Pipe.h
@@ -0,0 +1,142 @@
+//
+// Pipe.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  Pipe
+//
+// Definition of the Pipe class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Pipe_INCLUDED
+#define Foundation_Pipe_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/PipeImpl.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Pipe
+	/// This class implements an anonymous pipe.
+	///
+	/// Pipes are a common method of inter-process communication -
+	/// on Unix, pipes are the oldest form of IPC.
+	///
+	/// A pipe is a half-duplex communication channel, which means
+	/// that data only flows in one direction.
+	/// Pipes have a read-end and a write-end. One process writes to
+	/// the pipe and another process reads the data written by
+	/// its peer. 
+	/// Read and write operations are always synchronous. A read will
+	/// block until data is available and a write will block until
+	/// the reader reads the data.
+	///
+	/// The sendBytes() and readBytes() methods of Pipe are usually
+	/// used through a PipeOutputStream or PipeInputStream and are
+	/// not called directly.
+	///
+	/// Pipe objects have value semantics; the actual work is delegated
+	/// to a reference-counted PipeImpl object.
+{
+public:
+	typedef PipeImpl::Handle Handle; /// The read/write handle or file descriptor.
+	
+	enum CloseMode /// used by close()
+	{
+		CLOSE_READ  = 0x01, /// Close reading end of pipe.
+		CLOSE_WRITE = 0x02, /// Close writing end of pipe.
+		CLOSE_BOTH  = 0x03  /// Close both ends of pipe.
+	};
+	
+	Pipe();
+		/// Creates the Pipe.
+		///
+		/// Throws a CreateFileException if the pipe cannot be
+		/// created.
+		
+	Pipe(const Pipe& pipe);
+		/// Creates the Pipe using the PipeImpl from another one.
+
+	~Pipe();
+		/// Closes and destroys the Pipe.
+
+	Pipe& operator = (const Pipe& pipe);
+		/// Releases the Pipe's PipeImpl and assigns another one.
+
+	int writeBytes(const void* buffer, int length);
+		/// Sends the contents of the given buffer through
+		/// the pipe. Blocks until the receiver is ready
+		/// to read the data.
+		///
+		/// Returns the number of bytes sent.
+		///
+		/// Throws a WriteFileException if the data cannot be written.
+
+	int readBytes(void* buffer, int length);
+		/// Receives data from the pipe and stores it
+		/// in buffer. Up to length bytes are received.
+		/// Blocks until data becomes available.
+		///
+		/// Returns the number of bytes received, or 0
+		/// if the pipe has been closed.
+		///
+		/// Throws a ReadFileException if nothing can be read.
+
+	Handle readHandle() const;
+		/// Returns the read handle or file descriptor
+		/// for the Pipe. For internal use only.
+		
+	Handle writeHandle() const;
+		/// Returns the write handle or file descriptor
+		/// for the Pipe. For internal use only.
+
+	void close(CloseMode mode = CLOSE_BOTH);
+		/// Depending on the argument, closes either the
+		/// reading end, the writing end, or both ends
+		/// of the Pipe.
+		
+private:
+	PipeImpl* _pImpl;
+};
+
+
+//
+// inlines
+//
+inline int Pipe::writeBytes(const void* buffer, int length)
+{
+	return _pImpl->writeBytes(buffer, length);
+}
+
+
+inline int Pipe::readBytes(void* buffer, int length)
+{
+	return _pImpl->readBytes(buffer, length);
+}
+
+
+inline Pipe::Handle Pipe::readHandle() const
+{
+	return _pImpl->readHandle();
+}
+
+
+inline Pipe::Handle Pipe::writeHandle() const
+{
+	return _pImpl->writeHandle();
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Pipe_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/PipeImpl.h b/base/poco/Foundation/include/Poco/PipeImpl.h
new file mode 100644
index 00000000000..b0b7183705d
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/PipeImpl.h
@@ -0,0 +1,37 @@
+//
+// PipeImpl.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  PipeImpl
+//
+// Definition of the PipeImpl class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_PipeImpl_INCLUDED
+#define Foundation_PipeImpl_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#if defined(_WIN32_WCE)
+#include "PipeImpl_DUMMY.h"
+#else
+#include "Poco/PipeImpl_WIN32.h"
+#endif
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include "Poco/PipeImpl_POSIX.h"
+#else
+#include "Poco/PipeImpl_DUMMY.h"
+#endif
+
+
+#endif // Foundation_PipeImpl_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/PipeImpl_DUMMY.h b/base/poco/Foundation/include/Poco/PipeImpl_DUMMY.h
new file mode 100644
index 00000000000..e7616ff6c27
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/PipeImpl_DUMMY.h
@@ -0,0 +1,49 @@
+//
+// PipeImpl_DUMMY.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  PipeImpl
+//
+// Definition of the PipeImpl_DUMMY class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_PipeImpl_DUMMY_INCLUDED
+#define Foundation_PipeImpl_DUMMY_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/RefCountedObject.h"
+
+
+namespace Poco {
+
+
+class Foundation_API PipeImpl: public RefCountedObject
+	/// A dummy implementation of PipeImpl for platforms
+	/// that do not support pipes.
+{
+public:
+	typedef int Handle;
+
+	PipeImpl();
+	~PipeImpl();
+	int writeBytes(const void* buffer, int length);
+	int readBytes(void* buffer, int length);
+	Handle readHandle() const;
+	Handle writeHandle() const;
+	void closeRead();
+	void closeWrite();
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_PipeImpl_DUMMY_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/PipeImpl_POSIX.h b/base/poco/Foundation/include/Poco/PipeImpl_POSIX.h
new file mode 100644
index 00000000000..448e616efee
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/PipeImpl_POSIX.h
@@ -0,0 +1,53 @@
+//
+// PipeImpl_POSIX.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  PipeImpl
+//
+// Definition of the PipeImpl class for POSIX.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_PipeImpl_POSIX_INCLUDED
+#define Foundation_PipeImpl_POSIX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/RefCountedObject.h"
+
+
+namespace Poco {
+
+
+class Foundation_API PipeImpl: public RefCountedObject
+	/// A dummy implementation of PipeImpl for platforms
+	/// that do not support pipes.
+{
+public:
+	typedef int Handle;
+
+	PipeImpl();
+	~PipeImpl();
+	int writeBytes(const void* buffer, int length);
+	int readBytes(void* buffer, int length);
+	Handle readHandle() const;
+	Handle writeHandle() const;
+	void closeRead();
+	void closeWrite();
+	
+private:
+	int _readfd;
+	int _writefd;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_PipeImpl_POSIX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/PipeImpl_WIN32.h b/base/poco/Foundation/include/Poco/PipeImpl_WIN32.h
new file mode 100644
index 00000000000..936817987a5
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/PipeImpl_WIN32.h
@@ -0,0 +1,54 @@
+//
+// PipeImpl_WIN32.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  PipeImpl
+//
+// Definition of the PipeImpl class for WIN32.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_PipeImpl_WIN32_INCLUDED
+#define Foundation_PipeImpl_WIN32_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API PipeImpl: public RefCountedObject
+	/// A dummy implementation of PipeImpl for platforms
+	/// that do not support pipes.
+{
+public:
+	typedef HANDLE Handle;
+
+	PipeImpl();
+	~PipeImpl();
+	int writeBytes(const void* buffer, int length);
+	int readBytes(void* buffer, int length);
+	Handle readHandle() const;
+	Handle writeHandle() const;
+	void closeRead();
+	void closeWrite();
+	
+private:
+	HANDLE _readHandle;
+	HANDLE _writeHandle;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_PipeImpl_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/PipeStream.h b/base/poco/Foundation/include/Poco/PipeStream.h
new file mode 100644
index 00000000000..96b602aeab6
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/PipeStream.h
@@ -0,0 +1,120 @@
+//
+// PipeStream.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  PipeStream
+//
+// Definition of the PipeStream class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_PipeStream_INCLUDED
+#define Foundation_PipeStream_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Pipe.h"
+#include "Poco/BufferedStreamBuf.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+
+
+class Foundation_API PipeStreamBuf: public BufferedStreamBuf
+	/// This is the streambuf class used for reading from and writing to a Pipe.
+{
+public:
+	typedef BufferedStreamBuf::openmode openmode;
+	
+	PipeStreamBuf(const Pipe& pipe, openmode mode);
+		/// Creates a PipeStreamBuf with the given Pipe.
+
+	~PipeStreamBuf();
+		/// Destroys the PipeStreamBuf.
+		
+	void close();
+		/// Closes the pipe.
+		
+protected:
+	int readFromDevice(char* buffer, std::streamsize length);
+	int writeToDevice(const char* buffer, std::streamsize length);
+
+private:
+	enum 
+	{
+		STREAM_BUFFER_SIZE = 1024
+	};
+
+	Pipe _pipe;
+};
+
+
+class Foundation_API PipeIOS: public virtual std::ios
+	/// The base class for PipeInputStream and
+	/// PipeOutputStream.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	PipeIOS(const Pipe& pipe, openmode mode);
+		/// Creates the PipeIOS with the given Pipe.
+		
+	~PipeIOS();
+		/// Destroys the PipeIOS.
+		///
+		/// Flushes the buffer, but does not close the pipe.
+		
+	PipeStreamBuf* rdbuf();
+		/// Returns a pointer to the internal PipeStreamBuf.
+		
+	void close();
+		/// Flushes the stream and closes the pipe.
+
+protected:
+	PipeStreamBuf _buf;
+};
+
+
+class Foundation_API PipeOutputStream: public PipeIOS, public std::ostream
+	/// An output stream for writing to a Pipe.
+{
+public:
+	PipeOutputStream(const Pipe& pipe);
+		/// Creates the PipeOutputStream with the given Pipe.
+
+	~PipeOutputStream();
+		/// Destroys the PipeOutputStream.
+		///
+		/// Flushes the buffer, but does not close the pipe.
+};
+
+
+class Foundation_API PipeInputStream: public PipeIOS, public std::istream
+	/// An input stream for reading from a Pipe.
+	///
+	/// Using formatted input from a PipeInputStream
+	/// is not recommended, due to the read-ahead behavior of
+	/// istream with formatted reads.
+{
+public:
+	PipeInputStream(const Pipe& pipe);
+		/// Creates the PipeInputStream with the given Pipe.
+
+	~PipeInputStream();
+		/// Destroys the PipeInputStream.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_PipeStream_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Platform.h b/base/poco/Foundation/include/Poco/Platform.h
new file mode 100644
index 00000000000..799db417e7f
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Platform.h
@@ -0,0 +1,284 @@
+//
+// Platform.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Platform
+//
+// Platform and architecture identification macros.
+//
+// NOTE: This file may be included from both C++ and C code, so it
+//       must not contain any C++ specific things.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Platform_INCLUDED
+#define Foundation_Platform_INCLUDED
+
+
+//
+// Platform Identification
+//
+#define POCO_OS_FREE_BSD      0x0001
+#define POCO_OS_AIX           0x0002
+#define POCO_OS_HPUX          0x0003
+#define POCO_OS_TRU64         0x0004
+#define POCO_OS_LINUX         0x0005
+#define POCO_OS_MAC_OS_X      0x0006
+#define POCO_OS_NET_BSD       0x0007
+#define POCO_OS_OPEN_BSD      0x0008
+#define POCO_OS_IRIX          0x0009
+#define POCO_OS_SOLARIS       0x000a
+#define POCO_OS_QNX           0x000b
+#define POCO_OS_VXWORKS       0x000c
+#define POCO_OS_CYGWIN        0x000d
+#define POCO_OS_NACL	      0x000e
+#define POCO_OS_ANDROID       0x000f
+#define POCO_OS_UNKNOWN_UNIX  0x00ff
+#define POCO_OS_WINDOWS_NT    0x1001
+#define POCO_OS_WINDOWS_CE    0x1011
+#define POCO_OS_VMS           0x2001
+
+
+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+	#define POCO_OS_FAMILY_UNIX 1
+	#define POCO_OS_FAMILY_BSD 1
+	#define POCO_OS POCO_OS_FREE_BSD
+#elif defined(_AIX) || defined(__TOS_AIX__)
+	#define POCO_OS_FAMILY_UNIX 1
+	#define POCO_OS POCO_OS_AIX
+#elif defined(hpux) || defined(_hpux) || defined(__hpux)
+	#define POCO_OS_FAMILY_UNIX 1
+	#define POCO_OS POCO_OS_HPUX
+#elif defined(__digital__) || defined(__osf__)
+	#define POCO_OS_FAMILY_UNIX 1
+	#define POCO_OS POCO_OS_TRU64
+#elif defined(__NACL__)
+	#define POCO_OS_FAMILY_UNIX 1
+	#define POCO_OS POCO_OS_NACL
+#elif defined(linux) || defined(__linux) || defined(__linux__) || defined(__TOS_LINUX__) || defined(EMSCRIPTEN)
+	#define POCO_OS_FAMILY_UNIX 1
+	#if defined(__ANDROID__)
+		#define POCO_OS POCO_OS_ANDROID
+	#else
+		#define POCO_OS POCO_OS_LINUX
+	#endif
+#elif defined(__APPLE__) || defined(__TOS_MACOS__)
+	#define POCO_OS_FAMILY_UNIX 1
+	#define POCO_OS_FAMILY_BSD 1
+	#define POCO_OS POCO_OS_MAC_OS_X
+#elif defined(__NetBSD__)
+	#define POCO_OS_FAMILY_UNIX 1
+	#define POCO_OS_FAMILY_BSD 1
+	#define POCO_OS POCO_OS_NET_BSD
+#elif defined(__OpenBSD__)
+	#define POCO_OS_FAMILY_UNIX 1
+	#define POCO_OS_FAMILY_BSD 1
+	#define POCO_OS POCO_OS_OPEN_BSD
+#elif defined(sgi) || defined(__sgi)
+	#define POCO_OS_FAMILY_UNIX 1
+	#define POCO_OS POCO_OS_IRIX
+#elif defined(sun) || defined(__sun)
+	#define POCO_OS_FAMILY_UNIX 1
+	#define POCO_OS POCO_OS_SOLARIS
+#elif defined(__QNX__)
+	#define POCO_OS_FAMILY_UNIX 1
+	#define POCO_OS POCO_OS_QNX
+#elif defined(__CYGWIN__)
+	#define POCO_OS_FAMILY_UNIX 1
+	#define POCO_OS POCO_OS_CYGWIN
+#elif defined(POCO_VXWORKS)
+	#define POCO_OS_FAMILY_UNIX 1
+	#define POCO_OS POCO_OS_VXWORKS
+#elif defined(unix) || defined(__unix) || defined(__unix__)
+	#define POCO_OS_FAMILY_UNIX 1
+	#define POCO_OS POCO_OS_UNKNOWN_UNIX
+#elif defined(_WIN32_WCE)
+	#define POCO_OS_FAMILY_WINDOWS 1
+	#define POCO_OS POCO_OS_WINDOWS_CE
+#elif defined(_WIN32) || defined(_WIN64)
+	#define POCO_OS_FAMILY_WINDOWS 1
+	#define POCO_OS POCO_OS_WINDOWS_NT
+#elif defined(__VMS)
+	#define POCO_OS_FAMILY_VMS 1
+	#define POCO_OS POCO_OS_VMS
+#endif
+
+
+#if !defined(POCO_OS)
+	#error "Unknown Platform."
+#endif
+
+
+//
+// Hardware Architecture and Byte Order
+//
+#define POCO_ARCH_ALPHA   0x01
+#define POCO_ARCH_IA32    0x02
+#define POCO_ARCH_IA64    0x03
+#define POCO_ARCH_MIPS    0x04
+#define POCO_ARCH_HPPA    0x05
+#define POCO_ARCH_PPC     0x06
+#define POCO_ARCH_POWER   0x07
+#define POCO_ARCH_SPARC   0x08
+#define POCO_ARCH_AMD64   0x09
+#define POCO_ARCH_ARM     0x0a
+#define POCO_ARCH_M68K    0x0b
+#define POCO_ARCH_S390    0x0c
+#define POCO_ARCH_SH      0x0d
+#define POCO_ARCH_NIOS2   0x0e
+#define POCO_ARCH_AARCH64 0x0f
+#define POCO_ARCH_ARM64   0x0f // same as POCO_ARCH_AARCH64
+#define POCO_ARCH_RISCV64 0x10
+
+
+#if defined(__ALPHA) || defined(__alpha) || defined(__alpha__) || defined(_M_ALPHA)
+	#define POCO_ARCH POCO_ARCH_ALPHA
+	#define POCO_ARCH_LITTLE_ENDIAN 1
+#elif defined(i386) || defined(__i386) || defined(__i386__) || defined(_M_IX86) || defined(EMSCRIPTEN)
+	#define POCO_ARCH POCO_ARCH_IA32
+	#define POCO_ARCH_LITTLE_ENDIAN 1
+#elif defined(_IA64) || defined(__IA64__) || defined(__ia64__) || defined(__ia64) || defined(_M_IA64)
+	#define POCO_ARCH POCO_ARCH_IA64
+	#if defined(hpux) || defined(_hpux)
+		#define POCO_ARCH_BIG_ENDIAN 1
+	#else
+		#define POCO_ARCH_LITTLE_ENDIAN 1
+	#endif
+#elif defined(__x86_64__) || defined(_M_X64)
+	#define POCO_ARCH POCO_ARCH_AMD64
+	#define POCO_ARCH_LITTLE_ENDIAN 1
+#elif defined(__mips__) || defined(__mips) || defined(__MIPS__) || defined(_M_MRX000)
+	#define POCO_ARCH POCO_ARCH_MIPS
+	#if defined(POCO_OS_FAMILY_WINDOWS)
+		// Is this OK? Supports windows only little endian??
+		#define POCO_ARCH_LITTLE_ENDIAN 1
+	#elif defined(__MIPSEB__) || defined(_MIPSEB) || defined(__MIPSEB)
+		#define POCO_ARCH_BIG_ENDIAN 1
+	#elif defined(__MIPSEL__) || defined(_MIPSEL) || defined(__MIPSEL)
+		#define POCO_ARCH_LITTLE_ENDIAN 1
+	#else
+		#error "MIPS but neither MIPSEL nor MIPSEB?"
+	#endif
+#elif defined(__hppa) || defined(__hppa__)
+	#define POCO_ARCH POCO_ARCH_HPPA
+	#define POCO_ARCH_BIG_ENDIAN 1
+#elif defined(__PPC) || defined(__POWERPC__) || defined(__powerpc) || defined(__PPC__) || \
+      defined(__powerpc__) || defined(__ppc__) || defined(__ppc) || defined(_ARCH_PPC) || defined(_M_PPC)
+	#define POCO_ARCH POCO_ARCH_PPC
+	#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+		#define POCO_ARCH_LITTLE_ENDIAN 1
+	#else
+		#define POCO_ARCH_BIG_ENDIAN 1
+	#endif
+#elif defined(_POWER) || defined(_ARCH_PWR) || defined(_ARCH_PWR2) || defined(_ARCH_PWR3) || \
+      defined(_ARCH_PWR4) || defined(__THW_RS6000)
+	#define POCO_ARCH POCO_ARCH_POWER
+	#define POCO_ARCH_BIG_ENDIAN 1
+#elif defined(__sparc__) || defined(__sparc) || defined(sparc)
+	#define POCO_ARCH POCO_ARCH_SPARC
+	#define POCO_ARCH_BIG_ENDIAN 1
+#elif defined(__arm__) || defined(__arm) || defined(ARM) || defined(_ARM_) || defined(__ARM__) || defined(_M_ARM)
+	#define POCO_ARCH POCO_ARCH_ARM
+	#if defined(__ARMEB__)
+		#define POCO_ARCH_BIG_ENDIAN 1
+	#else
+		#define POCO_ARCH_LITTLE_ENDIAN 1
+	#endif
+#elif defined(__arm64__) || defined(__arm64)
+	#define POCO_ARCH POCO_ARCH_ARM64
+	#if defined(__ARMEB__)
+		#define POCO_ARCH_BIG_ENDIAN 1
+	#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+		#define POCO_ARCH_BIG_ENDIAN 1
+	#else
+		#define POCO_ARCH_LITTLE_ENDIAN 1
+	#endif
+#elif defined(__m68k__)
+	#define POCO_ARCH POCO_ARCH_M68K
+	#define POCO_ARCH_BIG_ENDIAN 1
+#elif defined(__s390__)
+	#define POCO_ARCH POCO_ARCH_S390
+	#define POCO_ARCH_BIG_ENDIAN 1
+#elif defined(__sh__) || defined(__sh) || defined(SHx) || defined(_SHX_)
+	#define POCO_ARCH POCO_ARCH_SH
+	#if defined(__LITTLE_ENDIAN__) || (POCO_OS == POCO_OS_WINDOWS_CE)
+		#define POCO_ARCH_LITTLE_ENDIAN 1
+	#else
+		#define POCO_ARCH_BIG_ENDIAN 1
+	#endif
+#elif defined (nios2) || defined(__nios2) || defined(__nios2__)
+	#define POCO_ARCH POCO_ARCH_NIOS2
+	#if defined(__nios2_little_endian) || defined(nios2_little_endian) || defined(__nios2_little_endian__)
+		#define POCO_ARCH_LITTLE_ENDIAN 1
+	#else
+		#define POCO_ARCH_BIG_ENDIAN 1
+	#endif
+#elif defined(__AARCH64EL__)
+	#define POCO_ARCH POCO_ARCH_AARCH64
+	#define POCO_ARCH_LITTLE_ENDIAN 1
+#elif defined(__AARCH64EB__)
+	#define POCO_ARCH POCO_ARCH_AARCH64
+	#define POCO_ARCH_BIG_ENDIAN 1
+#elif defined(__riscv) && (__riscv_xlen == 64)
+	#define POCO_ARCH POCO_ARCH_RISCV64
+	#define POCO_ARCH_LITTLE_ENDIAN 1
+#endif
+
+
+#if defined(__clang__)
+	#define POCO_COMPILER_CLANG
+#elif defined(_MSC_VER)
+	#define POCO_COMPILER_MSVC
+#elif defined (__GNUC__)
+	#define POCO_COMPILER_GCC
+#elif defined (__MINGW32__) || defined (__MINGW64__)
+	#define POCO_COMPILER_MINGW
+#elif defined (__INTEL_COMPILER) || defined(__ICC) || defined(__ECC) || defined(__ICL)
+	#define POCO_COMPILER_INTEL
+#elif defined (__SUNPRO_CC)
+	#define POCO_COMPILER_SUN
+#elif defined (__MWERKS__) || defined(__CWCC__)
+	#define POCO_COMPILER_CODEWARRIOR
+#elif defined (__sgi) || defined(sgi)
+	#define POCO_COMPILER_SGI
+#elif defined (__HP_aCC)
+	#define POCO_COMPILER_HP_ACC
+#elif defined (__BORLANDC__) || defined(__CODEGEARC__)
+	#define POCO_COMPILER_CBUILDER
+#elif defined (__DMC__)
+	#define POCO_COMPILER_DMARS
+#elif defined (__DECCXX)
+	#define POCO_COMPILER_COMPAC
+#elif (defined (__xlc__) || defined (__xlC__)) && defined(__IBMCPP__)
+	#define POCO_COMPILER_IBM_XLC // IBM XL C++
+#elif defined (__IBMCPP__) && defined(__COMPILER_VER__)
+	#define POCO_COMPILER_IBM_XLC_ZOS // IBM z/OS C++
+#endif
+
+
+#ifdef __GNUC__
+#define POCO_UNUSED __attribute__((unused))
+#else
+#define POCO_UNUSED
+#endif // __GNUC__
+
+
+#if !defined(POCO_ARCH)
+	#error "Unknown Hardware Architecture."
+#endif
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+	#define POCO_DEFAULT_NEWLINE_CHARS "\r\n"
+#else
+	#define POCO_DEFAULT_NEWLINE_CHARS "\n"
+#endif
+
+
+#endif // Foundation_Platform_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Platform_POSIX.h b/base/poco/Foundation/include/Poco/Platform_POSIX.h
new file mode 100644
index 00000000000..699735ea2b2
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Platform_POSIX.h
@@ -0,0 +1,53 @@
+//
+// Platform_POSIX.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Platform
+//
+// Platform and architecture identification macros
+// and platform-specific definitions for various POSIX platforms
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Platform_POSIX_INCLUDED
+#define Foundation_Platform_POSIX_INCLUDED
+
+
+//
+// PA-RISC based HP-UX platforms have some issues...
+//
+#if defined(hpux) || defined(_hpux)
+	#if defined(__hppa) || defined(__hppa__)
+		#define POCO_NO_SYS_SELECT_H 1
+		#if defined(__HP_aCC)
+			#define POCO_NO_TEMPLATE_ICOMPARE 1
+		#endif
+	#endif
+#endif
+
+
+//
+// Thread-safety of local static initialization
+//
+#if __cplusplus >= 201103L || __GNUC__ >= 4 || defined(__clang__)
+	#ifndef POCO_LOCAL_STATIC_INIT_IS_THREADSAFE
+		#define POCO_LOCAL_STATIC_INIT_IS_THREADSAFE 1
+	#endif
+#endif
+
+
+//
+// No syslog.h on QNX/BB10
+//
+#if defined(__QNXNTO__)
+	#define POCO_NO_SYSLOGCHANNEL
+#endif
+
+
+#endif // Foundation_Platform_POSIX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Platform_VX.h b/base/poco/Foundation/include/Poco/Platform_VX.h
new file mode 100644
index 00000000000..f21e822fdd6
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Platform_VX.h
@@ -0,0 +1,29 @@
+//
+// Platform_VX.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Platform
+//
+// Platform and architecture identification macros
+// and platform-specific definitions for VxWorks
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Platform_VX_INCLUDED
+#define Foundation_Platform_VX_INCLUDED
+
+
+#define POCO_NO_SYS_SELECT_H 
+#define POCO_NO_FPENVIRONMENT
+#define POCO_NO_WSTRING 
+#define POCO_NO_SHAREDMEMORY
+#define POCO_NO_SYSLOGCHANNEL
+
+
+#endif // Foundation_Platform_VX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Platform_WIN32.h b/base/poco/Foundation/include/Poco/Platform_WIN32.h
new file mode 100644
index 00000000000..ab5c791d0c2
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Platform_WIN32.h
@@ -0,0 +1,216 @@
+//
+// Platform_WIN32.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Platform
+//
+// Platform and architecture identification macros
+// and platform-specific definitions for Windows.
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Platform_WIN32_INCLUDED
+#define Foundation_Platform_WIN32_INCLUDED
+
+
+#include "Poco/UnWindows.h"
+
+
+#ifndef POCO_FORCE_MIN_WINDOWS_OS_SUPPORT
+	// Determine the real version.
+	// This setting can be forced from UnWindows.h
+	#if defined (_WIN32_WINNT_WINBLUE)
+		//Windows 8.1 _WIN32_WINNT_WINBLUE (0x0602)
+		#ifdef _WIN32_WINNT
+			#undef _WIN32_WINNT
+		#endif
+		#define _WIN32_WINNT _WIN32_WINNT_WINBLUE
+		#ifdef NTDDI_VERSION
+			#undef NTDDI_VERSION
+		#endif
+		#define NTDDI_VERSION NTDDI_WINBLUE
+	#elif defined (_WIN32_WINNT_WIN8)
+		//Windows 8	_WIN32_WINNT_WIN8 (0x0602)
+		#ifdef _WIN32_WINNT
+			#undef _WIN32_WINNT
+		#endif
+		#define _WIN32_WINNT _WIN32_WINNT_WIN8
+		#ifdef NTDDI_VERSION
+			#undef NTDDI_VERSION
+		#endif
+		#define NTDDI_VERSION NTDDI_WIN8
+	#elif defined (_WIN32_WINNT_WIN7)
+		//Windows 7	_WIN32_WINNT_WIN7 (0x0601)
+		#ifdef _WIN32_WINNT
+			#undef _WIN32_WINNT
+		#endif
+		#define _WIN32_WINNT _WIN32_WINNT_WIN7
+		#ifdef NTDDI_VERSION
+			#undef NTDDI_VERSION
+		#endif
+		#define NTDDI_VERSION NTDDI_WIN7
+	#elif defined (_WIN32_WINNT_WS08)
+		//Windows Server 2008 _WIN32_WINNT_WS08 (0x0600)
+		#ifdef _WIN32_WINNT
+			#undef _WIN32_WINNT
+		#endif
+		#define _WIN32_WINNT _WIN32_WINNT_WS08
+		#ifdef NTDDI_VERSION
+			#undef NTDDI_VERSION
+		#endif
+		#define NTDDI_VERSION NTDDI_WS08
+	#elif defined (_WIN32_WINNT_VISTA)
+		//Windows Vista	_WIN32_WINNT_VISTA (0x0600)
+		#ifdef _WIN32_WINNT
+			#undef _WIN32_WINNT
+		#endif
+		#define _WIN32_WINNT _WIN32_WINNT_VISTA
+		#ifdef NTDDI_VERSION
+			#undef NTDDI_VERSION
+		#endif
+		#define NTDDI_VERSION NTDDI_VISTA
+	#elif defined (_WIN32_WINNT_LONGHORN)
+		//Windows Vista	and server 2008 Development _WIN32_WINNT_LONGHORN (0x0600)
+		#ifdef _WIN32_WINNT
+			#undef _WIN32_WINNT
+		#endif
+		#define _WIN32_WINNT _WIN32_WINNT_LONGHORN
+		#ifdef NTDDI_VERSION
+			#undef NTDDI_VERSION
+		#endif
+		#define NTDDI_VERSION 0x06000000 // hardcoded, VS90 can't find NTDDI_* macros
+	#elif defined (_WIN32_WINNT_WS03)
+		//Windows Server 2003 with SP1,
+		//Windows XP with SP2 _WIN32_WINNT_WS03 (0x0502)
+		#ifdef _WIN32_WINNT
+			#undef _WIN32_WINNT
+		#endif
+		#define _WIN32_WINNT _WIN32_WINNT_WS03
+		#ifdef NTDDI_VERSION
+			#undef NTDDI_VERSION
+		#endif
+		#define NTDDI_VERSION NTDDI_WS03
+	#elif defined (_WIN32_WINNT_WINXP)
+		//Windows Server 2003, Windows XP _WIN32_WINNT_WINXP (0x0501)
+		#ifdef _WIN32_WINNT
+			#undef _WIN32_WINNT
+		#endif
+		#define _WIN32_WINNT _WIN32_WINNT_WINXP
+		#ifdef NTDDI_VERSION
+			#undef NTDDI_VERSION
+		#endif
+		#define NTDDI_VERSION NTDDI_WINXP
+	#elif defined (_WIN32_WINNT_WIN2K)
+		//Windows 2000 _WIN32_WINNT_WIN2K (0x0500)
+		#ifdef _WIN32_WINNT
+			#undef _WIN32_WINNT
+		#endif
+		#define _WIN32_WINNT _WIN32_WINNT_WIN2K
+	#elif defined (WINVER)
+		// fail back on WINVER
+		#ifdef _WIN32_WINNT
+			#undef _WIN32_WINNT
+		#endif
+		#define _WIN32_WINNT WINVER
+	#elif !defined(_WIN32_WINNT)
+		// last resort = Win XP, SP2 is minimum supported
+		#define _WIN32_WINNT 0x0502
+		#ifdef NTDDI_VERSION
+			#undef NTDDI_VERSION
+		#endif
+		#define NTDDI_VERSION 0x05020000
+	#endif
+#endif // POCO_FORCE_MIN_WINDOWS_OS_SUPPORT
+
+
+#if defined(_MSC_VER) && !defined(POCO_MSVC_SECURE_WARNINGS) && !defined(_CRT_SECURE_NO_DEPRECATE)
+	#define _CRT_SECURE_NO_DEPRECATE
+#endif 
+
+
+// Verify that we're built with the multithreaded 
+// versions of the runtime libraries
+#if defined(_MSC_VER) && !defined(_MT)
+	#error Must compile with /MD, /MDd, /MT or /MTd
+#endif
+
+
+// Check debug/release settings consistency
+#if defined(NDEBUG) && defined(_DEBUG)
+	#error Inconsistent build settings (check for /MD[d])
+#endif
+
+
+#if (_MSC_VER >= 1300) && (_MSC_VER < 1400)   // Visual Studio 2003, MSVC++ 7.1
+	#define POCO_MSVS_VERSION 2003
+	#define POCO_MSVC_VERSION 71
+#elif (_MSC_VER >= 1400) && (_MSC_VER < 1500) // Visual Studio 2005, MSVC++ 8.0
+	#define POCO_MSVS_VERSION 2005
+	#define POCO_MSVC_VERSION 80
+#elif (_MSC_VER >= 1500) && (_MSC_VER < 1600) // Visual Studio 2008, MSVC++ 9.0
+	#define POCO_MSVS_VERSION 2008
+	#define POCO_MSVC_VERSION 90
+#elif (_MSC_VER >= 1600) && (_MSC_VER < 1700) // Visual Studio 2010, MSVC++ 10.0
+	#define POCO_MSVS_VERSION 2010
+	#define POCO_MSVC_VERSION 100
+#elif (_MSC_VER >= 1700) && (_MSC_VER < 1800) // Visual Studio 2012, MSVC++ 11.0
+	#define POCO_MSVS_VERSION 2012
+	#define POCO_MSVC_VERSION 110
+#elif (_MSC_VER >= 1800) && (_MSC_VER < 1900) // Visual Studio 2013, MSVC++ 12.0
+	#define POCO_MSVS_VERSION 2013
+	#define POCO_MSVC_VERSION 120
+#elif (_MSC_VER >= 1900) && (_MSC_VER < 1910) // Visual Studio 2015, MSVC++ 14.0
+	#define POCO_MSVS_VERSION 2015
+	#define POCO_MSVC_VERSION 140
+#elif (_MSC_VER >= 1910) && (_MSC_VER < 2000) // Visual Studio 2017, MSVC++ 14.1
+	#define POCO_MSVS_VERSION 2017
+	#define POCO_MSVC_VERSION 141
+#endif
+
+
+// Unicode Support
+#if defined(UNICODE) && !defined(POCO_WIN32_UTF8)
+	#define POCO_WIN32_UTF8
+#endif
+
+
+#if !defined(POCO_WIN32_UTF8)
+	#pragma message("Compiling POCO on Windows without #define POCO_WIN32_UTF8 is deprecated.")
+#endif
+
+
+// Turn off some annoying warnings
+#if defined(_MSC_VER)
+	#pragma warning(disable:4018)	// signed/unsigned comparison
+	#pragma warning(disable:4250)	// VC++ 11.0: inheriting from std stream classes produces C4250 warning;
+									// see <http://connect.microsoft.com/VisualStudio/feedback/details/733720/inheriting-from-std-fstream-produces-c4250-warning>
+	#pragma warning(disable:4251)	// ... needs to have dll-interface warning
+	#pragma warning(disable:4275)	// non dll-interface class 'std::exception' used as base for dll-interface class 'Poco::Exception'
+	#pragma warning(disable:4344)	// behavior change: use of explicit template arguments results in call to '...' but '...' is a better match
+	#pragma warning(disable:4351)	// new behavior: elements of array '...' will be default initialized
+	#pragma warning(disable:4355)	// 'this' : used in base member initializer list
+	#pragma warning(disable:4675)	// resolved overload was found by argument-dependent lookup
+	#pragma warning(disable:4996)	// VC++ 8.0 deprecation warnings
+#endif
+
+
+// Enable C++11 support for VS 2010 and newer
+#if defined(_MSC_VER) && (_MSC_VER >= 1700) && !defined(POCO_ENABLE_CPP11)
+	#define POCO_ENABLE_CPP11
+#endif
+
+
+#if defined(__INTEL_COMPILER)
+	#pragma warning(disable:1738) // base class dllexport/dllimport specification differs from that of the derived class
+	#pragma warning(disable:1478) // function ... was declared "deprecated"
+	#pragma warning(disable:1744) // field of class type without a DLL interface used in a class with a DLL interface
+#endif
+
+
+#endif // Foundation_Platform_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Poco.h b/base/poco/Foundation/include/Poco/Poco.h
new file mode 100644
index 00000000000..cc5dd0ee17c
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Poco.h
@@ -0,0 +1,24 @@
+//
+// Poco.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Foundation
+//
+// Basic definitions for the POCO libraries.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Poco_INCLUDED
+#define Foundation_Poco_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+#endif // Foundation_Poco_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/PriorityDelegate.h b/base/poco/Foundation/include/Poco/PriorityDelegate.h
new file mode 100644
index 00000000000..7c776b94060
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/PriorityDelegate.h
@@ -0,0 +1,464 @@
+//
+// PriorityDelegate.h
+//
+// Library: Foundation
+// Package: Events
+// Module:  PriorityDelegate
+//
+// Implementation of the PriorityDelegate template.
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_PriorityDelegate_INCLUDED
+#define Foundation_PriorityDelegate_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/AbstractPriorityDelegate.h"
+#include "Poco/PriorityExpire.h"
+#include "Poco/FunctionPriorityDelegate.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+
+
+template <class TObj, class TArgs, bool useSender = true> 
+class PriorityDelegate: public AbstractPriorityDelegate<TArgs>
+{
+public:
+	typedef void (TObj::*NotifyMethod)(const void*, TArgs&);
+
+	PriorityDelegate(TObj* obj, NotifyMethod method, int prio):
+		AbstractPriorityDelegate<TArgs>(prio),
+		_receiverObject(obj),
+		_receiverMethod(method)
+	{
+	}
+	
+	PriorityDelegate(const PriorityDelegate& delegate):
+		AbstractPriorityDelegate<TArgs>(delegate),
+		_receiverObject(delegate._receiverObject),
+		_receiverMethod(delegate._receiverMethod)
+	{
+	}
+	
+	PriorityDelegate& operator = (const PriorityDelegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_pTarget        = delegate._pTarget;
+			this->_receiverObject = delegate._receiverObject;
+			this->_receiverMethod = delegate._receiverMethod;
+			this->_priority       = delegate._priority;
+		}
+		return *this;
+	}
+
+	~PriorityDelegate()
+	{
+	}
+
+	bool notify(const void* sender, TArgs& arguments)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_receiverObject)
+		{
+			(_receiverObject->*_receiverMethod)(sender, arguments);
+			return true; 
+		}
+		else return false;
+	}
+
+	bool equals(const AbstractDelegate<TArgs>& other) const
+	{
+		const PriorityDelegate* pOtherDelegate = dynamic_cast<const PriorityDelegate*>(other.unwrap());
+		return pOtherDelegate && this->priority() == pOtherDelegate->priority() && _receiverObject == pOtherDelegate->_receiverObject && _receiverMethod == pOtherDelegate->_receiverMethod;
+	}
+
+	AbstractDelegate<TArgs>* clone() const
+	{
+		return new PriorityDelegate(*this);
+	}
+
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_receiverObject = 0;
+	}
+	
+protected:
+	TObj*        _receiverObject;
+	NotifyMethod _receiverMethod;
+	Mutex _mutex;
+
+private:
+	PriorityDelegate();
+};
+
+
+template <class TObj, class TArgs> 
+class PriorityDelegate<TObj, TArgs, false>: public AbstractPriorityDelegate<TArgs>
+{
+public:
+	typedef void (TObj::*NotifyMethod)(TArgs&);
+
+	PriorityDelegate(TObj* obj, NotifyMethod method, int prio):
+		AbstractPriorityDelegate<TArgs>(prio),
+		_receiverObject(obj),
+		_receiverMethod(method)
+	{
+	}
+	
+	PriorityDelegate(const PriorityDelegate& delegate):
+		AbstractPriorityDelegate<TArgs>(delegate),
+		_receiverObject(delegate._receiverObject),
+		_receiverMethod(delegate._receiverMethod)
+	{
+	}
+	
+	PriorityDelegate& operator = (const PriorityDelegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_pTarget        = delegate._pTarget;
+			this->_receiverObject = delegate._receiverObject;
+			this->_receiverMethod = delegate._receiverMethod;
+			this->_priority       = delegate._priority;
+		}
+		return *this;
+	}
+
+	~PriorityDelegate()
+	{
+	}
+
+	bool notify(const void* sender, TArgs& arguments)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_receiverObject)
+		{
+			(_receiverObject->*_receiverMethod)(arguments);
+			return true;
+		}
+		return false;
+	}
+
+	bool equals(const AbstractDelegate<TArgs>& other) const
+	{
+		const PriorityDelegate* pOtherDelegate = dynamic_cast<const PriorityDelegate*>(other.unwrap());
+		return pOtherDelegate && this->priority() == pOtherDelegate->priority() && _receiverObject == pOtherDelegate->_receiverObject && _receiverMethod == pOtherDelegate->_receiverMethod;
+	}
+
+	AbstractDelegate<TArgs>* clone() const
+	{
+		return new PriorityDelegate(*this);
+	}
+
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_receiverObject = 0;
+	}
+
+protected:
+	TObj*        _receiverObject;
+	NotifyMethod _receiverMethod;
+	Mutex _mutex;
+
+private:
+	PriorityDelegate();
+};
+
+
+template <class TObj>
+class PriorityDelegate<TObj, void, true>: public AbstractPriorityDelegate<void>
+{
+public:
+	typedef void (TObj::*NotifyMethod)(const void*);
+
+	PriorityDelegate(TObj* obj, NotifyMethod method, int prio):
+		AbstractPriorityDelegate<void>(prio),
+		_receiverObject(obj),
+		_receiverMethod(method)
+	{
+	}
+
+	PriorityDelegate(const PriorityDelegate& delegate):
+		AbstractPriorityDelegate<void>(delegate),
+		_receiverObject(delegate._receiverObject),
+		_receiverMethod(delegate._receiverMethod)
+	{
+	}
+
+	PriorityDelegate& operator = (const PriorityDelegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_pTarget        = delegate._pTarget;
+			this->_receiverObject = delegate._receiverObject;
+			this->_receiverMethod = delegate._receiverMethod;
+			this->_priority       = delegate._priority;
+		}
+		return *this;
+	}
+
+	~PriorityDelegate()
+	{
+	}
+
+	bool notify(const void* sender)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_receiverObject)
+		{
+			(_receiverObject->*_receiverMethod)(sender);
+			return true;
+		}
+		else return false;
+	}
+
+	bool equals(const AbstractDelegate<void>& other) const
+	{
+		const PriorityDelegate* pOtherDelegate = dynamic_cast<const PriorityDelegate*>(other.unwrap());
+		return pOtherDelegate && this->priority() == pOtherDelegate->priority() && _receiverObject == pOtherDelegate->_receiverObject && _receiverMethod == pOtherDelegate->_receiverMethod;
+	}
+
+	AbstractDelegate<void>* clone() const
+	{
+		return new PriorityDelegate(*this);
+	}
+
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_receiverObject = 0;
+	}
+
+protected:
+	TObj*        _receiverObject;
+	NotifyMethod _receiverMethod;
+	Mutex _mutex;
+
+private:
+	PriorityDelegate();
+};
+
+
+template <class TObj>
+class PriorityDelegate<TObj, void, false>: public AbstractPriorityDelegate<void>
+{
+public:
+	typedef void (TObj::*NotifyMethod)();
+
+	PriorityDelegate(TObj* obj, NotifyMethod method, int prio):
+		AbstractPriorityDelegate<void>(prio),
+		_receiverObject(obj),
+		_receiverMethod(method)
+	{
+	}
+
+	PriorityDelegate(const PriorityDelegate& delegate):
+		AbstractPriorityDelegate<void>(delegate),
+		_receiverObject(delegate._receiverObject),
+		_receiverMethod(delegate._receiverMethod)
+	{
+	}
+
+	PriorityDelegate& operator = (const PriorityDelegate& delegate)
+	{
+		if (&delegate != this)
+		{
+			this->_pTarget        = delegate._pTarget;
+			this->_receiverObject = delegate._receiverObject;
+			this->_receiverMethod = delegate._receiverMethod;
+			this->_priority       = delegate._priority;
+		}
+		return *this;
+	}
+
+	~PriorityDelegate()
+	{
+	}
+
+	bool notify(const void* sender)
+	{
+		Mutex::ScopedLock lock(_mutex);
+		if (_receiverObject)
+		{
+			(_receiverObject->*_receiverMethod)();
+			return true;
+		}
+		return false;
+	}
+
+	bool equals(const AbstractDelegate<void>& other) const
+	{
+		const PriorityDelegate* pOtherDelegate = dynamic_cast<const PriorityDelegate*>(other.unwrap());
+		return pOtherDelegate && this->priority() == pOtherDelegate->priority() && _receiverObject == pOtherDelegate->_receiverObject && _receiverMethod == pOtherDelegate->_receiverMethod;
+	}
+
+	AbstractDelegate<void>* clone() const
+	{
+		return new PriorityDelegate(*this);
+	}
+
+	void disable()
+	{
+		Mutex::ScopedLock lock(_mutex);
+		_receiverObject = 0;
+	}
+
+protected:
+	TObj*        _receiverObject;
+	NotifyMethod _receiverMethod;
+	Mutex _mutex;
+
+private:
+	PriorityDelegate();
+};
+
+
+template <class TObj, class TArgs>
+static PriorityDelegate<TObj, TArgs, true> priorityDelegate(TObj* pObj, void (TObj::*NotifyMethod)(const void*, TArgs&), int prio)
+{
+	return PriorityDelegate<TObj, TArgs, true>(pObj, NotifyMethod, prio);
+}
+
+
+template <class TObj, class TArgs>
+static PriorityDelegate<TObj, TArgs, false> priorityDelegate(TObj* pObj, void (TObj::*NotifyMethod)(TArgs&), int prio)
+{
+	return PriorityDelegate<TObj, TArgs, false>(pObj, NotifyMethod, prio);
+}
+
+
+template <class TObj, class TArgs>
+static PriorityExpire<TArgs> priorityDelegate(TObj* pObj, void (TObj::*NotifyMethod)(const void*, TArgs&), int prio, Timestamp::TimeDiff expireMilliSec)
+{
+	return PriorityExpire<TArgs>(PriorityDelegate<TObj, TArgs, true>(pObj, NotifyMethod, prio), expireMilliSec);
+}
+
+
+template <class TObj, class TArgs>
+static PriorityExpire<TArgs> priorityDelegate(TObj* pObj, void (TObj::*NotifyMethod)(TArgs&), int prio, Timestamp::TimeDiff expireMilliSec)
+{
+	return PriorityExpire<TArgs>(PriorityDelegate<TObj, TArgs, false>(pObj, NotifyMethod, prio), expireMilliSec);
+}
+
+
+template <class TArgs>
+static PriorityExpire<TArgs> priorityDelegate(void (*NotifyMethod)(const void*, TArgs&), int prio, Timestamp::TimeDiff expireMilliSec)
+{
+	return PriorityExpire<TArgs>(FunctionPriorityDelegate<TArgs, true, true>(NotifyMethod, prio), expireMilliSec);
+}
+
+
+template <class TArgs>
+static PriorityExpire<TArgs> priorityDelegate(void (*NotifyMethod)(void*, TArgs&), int prio, Timestamp::TimeDiff expireMilliSec)
+{
+	return PriorityExpire<TArgs>(FunctionPriorityDelegate<TArgs, true, false>(NotifyMethod, prio), expireMilliSec);
+}
+
+
+template <class TArgs>
+static PriorityExpire<TArgs> priorityDelegate(void (*NotifyMethod)(TArgs&), int prio, Timestamp::TimeDiff expireMilliSec)
+{
+	return PriorityExpire<TArgs>(FunctionPriorityDelegate<TArgs, false>(NotifyMethod, prio), expireMilliSec);
+}
+
+
+template <class TArgs>
+static FunctionPriorityDelegate<TArgs, true, true> priorityDelegate(void (*NotifyMethod)(const void*, TArgs&), int prio)
+{
+	return FunctionPriorityDelegate<TArgs, true, true>(NotifyMethod, prio);
+}
+
+
+template <class TArgs>
+static FunctionPriorityDelegate<TArgs, true, false> priorityDelegate(void (*NotifyMethod)(void*, TArgs&), int prio)
+{
+	return FunctionPriorityDelegate<TArgs, true, false>(NotifyMethod, prio);
+}
+
+
+template <class TArgs>
+static FunctionPriorityDelegate<TArgs, false> priorityDelegate(void (*NotifyMethod)(TArgs&), int prio)
+{
+	return FunctionPriorityDelegate<TArgs, false>(NotifyMethod, prio);
+}
+
+
+template <class TObj>
+static PriorityDelegate<TObj, void, true> priorityDelegate(TObj* pObj, void (TObj::*NotifyMethod)(const void*), int prio)
+{
+	return PriorityDelegate<TObj, void, true>(pObj, NotifyMethod, prio);
+}
+
+
+template <class TObj>
+static PriorityDelegate<TObj, void, false> priorityDelegate(TObj* pObj, void (TObj::*NotifyMethod)(), int prio)
+{
+	return PriorityDelegate<TObj, void, false>(pObj, NotifyMethod, prio);
+}
+
+
+template <class TObj>
+static PriorityExpire<void> priorityDelegate(TObj* pObj, void (TObj::*NotifyMethod)(const void*), int prio, Timestamp::TimeDiff expireMilliSec)
+{
+	return PriorityExpire<void>(PriorityDelegate<TObj, void, true>(pObj, NotifyMethod, prio), expireMilliSec);
+}
+
+
+template <class TObj>
+static PriorityExpire<void> priorityDelegate(TObj* pObj, void (TObj::*NotifyMethod)(), int prio, Timestamp::TimeDiff expireMilliSec)
+{
+	return PriorityExpire<void>(PriorityDelegate<TObj, void, false>(pObj, NotifyMethod, prio), expireMilliSec);
+}
+
+
+inline PriorityExpire<void> priorityDelegate(void (*NotifyMethod)(const void*), int prio, Timestamp::TimeDiff expireMilliSec)
+{
+	return PriorityExpire<void>(FunctionPriorityDelegate<void, true, true>(NotifyMethod, prio), expireMilliSec);
+}
+
+
+inline PriorityExpire<void> priorityDelegate(void (*NotifyMethod)(void*), int prio, Timestamp::TimeDiff expireMilliSec)
+{
+	return PriorityExpire<void>(FunctionPriorityDelegate<void, true, false>(NotifyMethod, prio), expireMilliSec);
+}
+
+
+inline PriorityExpire<void> priorityDelegate(void (*NotifyMethod)(), int prio, Timestamp::TimeDiff expireMilliSec)
+{
+	return PriorityExpire<void>(FunctionPriorityDelegate<void, false>(NotifyMethod, prio), expireMilliSec);
+}
+
+
+inline FunctionPriorityDelegate<void, true, true> priorityDelegate(void (*NotifyMethod)(const void*), int prio)
+{
+	return FunctionPriorityDelegate<void, true, true>(NotifyMethod, prio);
+}
+
+
+inline FunctionPriorityDelegate<void, true, false> priorityDelegate(void (*NotifyMethod)(void*), int prio)
+{
+	return FunctionPriorityDelegate<void, true, false>(NotifyMethod, prio);
+}
+
+
+inline FunctionPriorityDelegate<void, false> priorityDelegate(void (*NotifyMethod)(), int prio)
+{
+	return FunctionPriorityDelegate<void, false>(NotifyMethod, prio);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_PriorityDelegate_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/PriorityEvent.h b/base/poco/Foundation/include/Poco/PriorityEvent.h
new file mode 100644
index 00000000000..48b9f604f63
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/PriorityEvent.h
@@ -0,0 +1,61 @@
+//
+// PriorityEvent.h
+//
+// Library: Foundation
+// Package: Events
+// Module:  PriorityEvent
+//
+// Implementation of the PriorityEvent template.
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_PriorityEvent_INCLUDED
+#define Foundation_PriorityEvent_INCLUDED
+
+
+#include "Poco/AbstractEvent.h"
+#include "Poco/PriorityStrategy.h"
+#include "Poco/AbstractPriorityDelegate.h"
+
+
+namespace Poco {
+
+
+template <class TArgs, class TMutex = FastMutex> 
+class PriorityEvent: public AbstractEvent < 
+	TArgs,
+	PriorityStrategy<TArgs, AbstractPriorityDelegate<TArgs> >,
+	AbstractPriorityDelegate<TArgs>,
+	TMutex
+>
+	/// A PriorityEvent uses internally a PriorityStrategy which 
+	/// invokes delegates in order of priority (lower priorities first).
+	/// PriorityEvent's can only be used together with PriorityDelegate's.
+	/// PriorityDelegate's are sorted according to the priority value, when
+	/// two delegates have the same priority, they are invoked in
+	/// an arbitrary manner.
+{
+public:
+	PriorityEvent()
+	{
+	}
+
+	~PriorityEvent()
+	{
+	}
+
+private:
+	PriorityEvent(const PriorityEvent&);
+	PriorityEvent& operator = (const PriorityEvent&);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_PriorityEvent_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/PriorityExpire.h b/base/poco/Foundation/include/Poco/PriorityExpire.h
new file mode 100644
index 00000000000..9491445f071
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/PriorityExpire.h
@@ -0,0 +1,195 @@
+//
+// PriorityExpire.h
+//
+// Library: Foundation
+// Package: Events
+// Module:  PriorityExpire
+//
+// Implementation of the PriorityExpire template.
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_PriorityExpire_INCLUDED
+#define Foundation_PriorityExpire_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Timestamp.h"
+#include "Poco/AbstractPriorityDelegate.h"
+
+
+namespace Poco {
+
+
+template <class TArgs>
+class PriorityExpire: public AbstractPriorityDelegate<TArgs>
+	/// Decorator for AbstractPriorityDelegate adding automatic 
+	/// expiring of registrations to AbstractPriorityDelegate.
+{
+public:
+	PriorityExpire(const AbstractPriorityDelegate<TArgs>& p, Timestamp::TimeDiff expireMilliSec):
+		AbstractPriorityDelegate<TArgs>(p),
+		_pDelegate(static_cast<AbstractPriorityDelegate<TArgs>*>(p.clone())), 
+		_expire(expireMilliSec*1000)
+	{
+	}
+	
+	PriorityExpire(const PriorityExpire& expire):
+		AbstractPriorityDelegate<TArgs>(expire),
+		_pDelegate(static_cast<AbstractPriorityDelegate<TArgs>*>(expire._pDelegate->clone())),
+		_expire(expire._expire),
+		_creationTime(expire._creationTime)
+	{
+	}
+
+	~PriorityExpire()
+	{
+		delete _pDelegate;
+	}
+	
+	PriorityExpire& operator = (const PriorityExpire& expire)
+	{
+		if (&expire != this)
+		{
+			delete this->_pDelegate;
+			this->_pTarget      = expire._pTarget;
+			this->_pDelegate    = expire._pDelegate->clone();
+			this->_expire       = expire._expire;
+			this->_creationTime = expire._creationTime;
+		}
+		return *this; 
+	}
+
+	bool notify(const void* sender, TArgs& arguments)
+	{
+		if (!expired())
+			return this->_pDelegate->notify(sender, arguments);
+		else
+			return false;
+	}
+
+	bool equals(const AbstractDelegate<TArgs>& other) const
+	{
+		return other.equals(*_pDelegate);
+	}
+
+	AbstractPriorityDelegate<TArgs>* clone() const
+	{
+		return new PriorityExpire(*this);
+	}
+
+	void disable()
+	{
+		_pDelegate->disable();
+	}
+
+	const AbstractPriorityDelegate<TArgs>* unwrap() const
+	{
+		return this->_pDelegate;
+	}
+
+protected:
+	bool expired() const
+	{
+		return _creationTime.isElapsed(_expire);
+	}
+
+	AbstractPriorityDelegate<TArgs>* _pDelegate;
+	Timestamp::TimeDiff _expire;
+	Timestamp _creationTime;
+
+private:
+	PriorityExpire();
+};
+
+
+template <>
+class PriorityExpire<void>: public AbstractPriorityDelegate<void>
+	/// Decorator for AbstractPriorityDelegate adding automatic
+	/// expiring of registrations to AbstractPriorityDelegate.
+{
+public:
+	PriorityExpire(const AbstractPriorityDelegate<void>& p, Timestamp::TimeDiff expireMilliSec):
+		AbstractPriorityDelegate<void>(p),
+		_pDelegate(static_cast<AbstractPriorityDelegate<void>*>(p.clone())),
+		_expire(expireMilliSec*1000)
+	{
+	}
+
+	PriorityExpire(const PriorityExpire& expire):
+		AbstractPriorityDelegate<void>(expire),
+		_pDelegate(static_cast<AbstractPriorityDelegate<void>*>(expire._pDelegate->clone())),
+		_expire(expire._expire),
+		_creationTime(expire._creationTime)
+	{
+	}
+
+	~PriorityExpire()
+	{
+		delete _pDelegate;
+	}
+
+	PriorityExpire& operator = (const PriorityExpire& expire)
+	{
+		if (&expire != this)
+		{
+			delete this->_pDelegate;
+			this->_pDelegate    = static_cast<AbstractPriorityDelegate<void>*>(expire._pDelegate->clone());
+			this->_expire       = expire._expire;
+			this->_creationTime = expire._creationTime;
+		}
+		return *this;
+	}
+
+	bool notify(const void* sender)
+	{
+		if (!expired())
+			return this->_pDelegate->notify(sender);
+		else
+			return false;
+	}
+
+	bool equals(const AbstractDelegate<void>& other) const
+	{
+		return other.equals(*_pDelegate);
+	}
+
+	AbstractPriorityDelegate<void>* clone() const
+	{
+		return new PriorityExpire(*this);
+	}
+
+	void disable()
+	{
+		_pDelegate->disable();
+	}
+
+	const AbstractPriorityDelegate<void>* unwrap() const
+	{
+		return this->_pDelegate;
+	}
+
+protected:
+	bool expired() const
+	{
+		return _creationTime.isElapsed(_expire);
+	}
+
+	AbstractPriorityDelegate<void>* _pDelegate;
+	Timestamp::TimeDiff _expire;
+	Timestamp _creationTime;
+
+private:
+	PriorityExpire();
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_PriorityExpire_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/PriorityNotificationQueue.h b/base/poco/Foundation/include/Poco/PriorityNotificationQueue.h
new file mode 100644
index 00000000000..e5269ab8546
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/PriorityNotificationQueue.h
@@ -0,0 +1,158 @@
+//
+// PriorityNotificationQueue.h
+//
+// Library: Foundation
+// Package: Notifications
+// Module:  PriorityNotificationQueue
+//
+// Definition of the PriorityNotificationQueue class.
+//
+// Copyright (c) 2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_PriorityNotificationQueue_INCLUDED
+#define Foundation_PriorityNotificationQueue_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Notification.h"
+#include "Poco/Mutex.h"
+#include "Poco/Event.h"
+#include <map>
+#include <deque>
+
+
+namespace Poco {
+
+
+class NotificationCenter;
+
+
+class Foundation_API PriorityNotificationQueue
+	/// A PriorityNotificationQueue object provides a way to implement asynchronous
+	/// notifications. This is especially useful for sending notifications
+	/// from one thread to another, for example from a background thread to 
+	/// the main (user interface) thread. 
+	///
+	/// The PriorityNotificationQueue is quite similar to the NotificationQueue class.
+	/// The only difference to NotificationQueue is that each Notification is tagged
+	/// with a priority value. When inserting a Notification into the queue, the
+	/// Notification is inserted according to the given priority value, with 
+	/// lower priority values being inserted before higher priority
+	/// values. Therefore, the lower the numerical priority value, the higher
+	/// the actual notification priority. 
+	///
+	/// Notifications are dequeued in order of their priority.
+	/// 
+	/// The PriorityNotificationQueue can also be used to distribute work from
+	/// a controlling thread to one or more worker threads. Each worker thread
+	/// repeatedly calls waitDequeueNotification() and processes the
+	/// returned notification. Special care must be taken when shutting
+	/// down a queue with worker threads waiting for notifications.
+	/// The recommended sequence to shut down and destroy the queue is to
+	///   1. set a termination flag for every worker thread
+	///   2. call the wakeUpAll() method
+	///   3. join each worker thread
+	///   4. destroy the notification queue.
+{
+public:
+	PriorityNotificationQueue();
+		/// Creates the PriorityNotificationQueue.
+
+	~PriorityNotificationQueue();
+		/// Destroys the PriorityNotificationQueue.
+
+	void enqueueNotification(Notification::Ptr pNotification, int priority);
+		/// Enqueues the given notification by adding it to
+		/// the queue according to the given priority.
+		/// Lower priority values are inserted before higher priority values.
+		/// The queue takes ownership of the notification, thus
+		/// a call like
+		///     notificationQueue.enqueueNotification(new MyNotification, 1);
+		/// does not result in a memory leak.
+		
+	Notification* dequeueNotification();
+		/// Dequeues the next pending notification.
+		/// Returns 0 (null) if no notification is available.
+		/// The caller gains ownership of the notification and
+		/// is expected to release it when done with it.
+		///
+		/// It is highly recommended that the result is immediately
+		/// assigned to a Notification::Ptr, to avoid potential
+		/// memory management issues.
+
+	Notification* waitDequeueNotification();
+		/// Dequeues the next pending notification.
+		/// If no notification is available, waits for a notification
+		/// to be enqueued. 
+		/// The caller gains ownership of the notification and
+		/// is expected to release it when done with it.
+		/// This method returns 0 (null) if wakeUpAll()
+		/// has been called by another thread.
+		///
+		/// It is highly recommended that the result is immediately
+		/// assigned to a Notification::Ptr, to avoid potential
+		/// memory management issues.
+
+	Notification* waitDequeueNotification(long milliseconds);
+		/// Dequeues the next pending notification.
+		/// If no notification is available, waits for a notification
+		/// to be enqueued up to the specified time.
+		/// Returns 0 (null) if no notification is available.
+		/// The caller gains ownership of the notification and
+		/// is expected to release it when done with it.
+		///
+		/// It is highly recommended that the result is immediately
+		/// assigned to a Notification::Ptr, to avoid potential
+		/// memory management issues.
+
+	void dispatch(NotificationCenter& notificationCenter);
+		/// Dispatches all queued notifications to the given
+		/// notification center.
+
+	void wakeUpAll();
+		/// Wakes up all threads that wait for a notification.
+	
+	bool empty() const;
+		/// Returns true iff the queue is empty.
+		
+	int size() const;
+		/// Returns the number of notifications in the queue.
+
+	void clear();
+		/// Removes all notifications from the queue.
+		
+	bool hasIdleThreads() const;	
+		/// Returns true if the queue has at least one thread waiting 
+		/// for a notification.
+		
+	static PriorityNotificationQueue& defaultQueue();
+		/// Returns a reference to the default
+		/// PriorityNotificationQueue.
+
+protected:
+	Notification::Ptr dequeueOne();
+	
+private:
+	typedef std::multimap<int, Notification::Ptr> NfQueue;
+	struct WaitInfo
+	{
+		Notification::Ptr pNf;
+		Event nfAvailable;
+	};
+	typedef std::deque<WaitInfo*> WaitQueue;
+
+	NfQueue           _nfQueue;
+	WaitQueue         _waitQueue;
+	mutable FastMutex _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_PriorityNotificationQueue_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/PriorityStrategy.h b/base/poco/Foundation/include/Poco/PriorityStrategy.h
new file mode 100644
index 00000000000..65d67a4491a
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/PriorityStrategy.h
@@ -0,0 +1,230 @@
+//
+// PriorityStrategy.h
+//
+// Library: Foundation
+// Package: Events
+// Module:  PrioritytStrategy
+//
+// Implementation of the DefaultStrategy template.
+//
+// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_PriorityStrategy_INCLUDED
+#define Foundation_PriorityStrategy_INCLUDED
+
+
+#include "Poco/NotificationStrategy.h"
+#include "Poco/SharedPtr.h"
+#include <vector>
+
+
+namespace Poco {
+
+
+template <class TArgs, class TDelegate> 
+class PriorityStrategy: public NotificationStrategy<TArgs, TDelegate>
+	/// NotificationStrategy for PriorityEvent.
+	///
+	/// Delegates are kept in a std::vector<>, ordered
+	/// by their priority.
+{
+public:
+	typedef TDelegate*                   DelegateHandle;
+	typedef SharedPtr<TDelegate>         DelegatePtr;
+	typedef std::vector<DelegatePtr>     Delegates;
+	typedef typename Delegates::iterator Iterator;
+
+public:
+	PriorityStrategy()
+	{
+	}
+
+	PriorityStrategy(const PriorityStrategy& s):
+		_delegates(s._delegates)
+	{
+	}
+
+	~PriorityStrategy()
+	{
+	}
+
+	void notify(const void* sender, TArgs& arguments)
+	{
+		for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
+		{
+			(*it)->notify(sender, arguments);
+		}
+	}
+
+	DelegateHandle add(const TDelegate& delegate)
+	{
+		for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
+		{
+			if ((*it)->priority() > delegate.priority())
+			{
+				DelegatePtr pDelegate(static_cast<TDelegate*>(delegate.clone()));
+				_delegates.insert(it, pDelegate);
+				return pDelegate.get();
+			}
+		}
+		DelegatePtr pDelegate(static_cast<TDelegate*>(delegate.clone()));
+		_delegates.push_back(pDelegate);
+		return pDelegate.get();
+	}
+
+	void remove(const TDelegate& delegate)
+	{
+		for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
+		{
+			if (delegate.equals(**it))
+			{
+				(*it)->disable();
+				_delegates.erase(it);
+				return;
+			}
+		}
+	}
+
+	void remove(DelegateHandle delegateHandle)
+	{
+		for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
+		{
+			if (*it == delegateHandle)
+			{
+				(*it)->disable();
+				_delegates.erase(it);
+				return;
+			}
+		}
+	}
+
+	PriorityStrategy& operator = (const PriorityStrategy& s)
+	{
+		if (this != &s)
+		{
+			_delegates = s._delegates;
+		}
+		return *this;
+	}
+
+	void clear()
+	{
+		for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
+		{
+			(*it)->disable();
+		}
+		_delegates.clear();
+	}
+
+	bool empty() const
+	{
+		return _delegates.empty();
+	}
+
+protected:
+	Delegates _delegates;
+};
+
+
+template <class TDelegate>
+class PriorityStrategy<void, TDelegate>
+	/// NotificationStrategy for PriorityEvent.
+	///
+	/// Delegates are kept in a std::vector<>, ordered
+	/// by their priority.
+{
+public:
+	typedef TDelegate*                   DelegateHandle;
+	typedef SharedPtr<TDelegate>         DelegatePtr;
+	typedef std::vector<DelegatePtr>     Delegates;
+	typedef typename Delegates::iterator Iterator;
+
+public:
+
+	void notify(const void* sender)
+	{
+		for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
+		{
+			(*it)->notify(sender);
+		}
+	}
+
+	DelegateHandle add(const TDelegate& delegate)
+	{
+		for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
+		{
+			if ((*it)->priority() > delegate.priority())
+			{
+				DelegatePtr pDelegate(static_cast<TDelegate*>(delegate.clone()));
+				_delegates.insert(it, pDelegate);
+				return pDelegate.get();
+			}
+		}
+		DelegatePtr pDelegate(static_cast<TDelegate*>(delegate.clone()));
+		_delegates.push_back(pDelegate);
+		return pDelegate.get();
+	}
+
+	void remove(const TDelegate& delegate)
+	{
+		for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
+		{
+			if (delegate.equals(**it))
+			{
+				(*it)->disable();
+				_delegates.erase(it);
+				return;
+			}
+		}
+	}
+
+	void remove(DelegateHandle delegateHandle)
+	{
+		for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
+		{
+			if (*it == delegateHandle)
+			{
+				(*it)->disable();
+				_delegates.erase(it);
+				return;
+			}
+		}
+	}
+
+	PriorityStrategy& operator = (const PriorityStrategy& s)
+	{
+		if (this != &s)
+		{
+			_delegates = s._delegates;
+		}
+		return *this;
+	}
+
+	void clear()
+	{
+		for (Iterator it = _delegates.begin(); it != _delegates.end(); ++it)
+		{
+			(*it)->disable();
+		}
+		_delegates.clear();
+	}
+
+	bool empty() const
+	{
+		return _delegates.empty();
+	}
+
+protected:
+	Delegates _delegates;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_PriorityStrategy_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Process.h b/base/poco/Foundation/include/Poco/Process.h
new file mode 100644
index 00000000000..f9fefc524bd
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Process.h
@@ -0,0 +1,266 @@
+//
+// Process.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  Process
+//
+// Definition of the Process class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Process_INCLUDED
+#define Foundation_Process_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS) && defined(POCO_WIN32_UTF8)
+#if defined(_WIN32_WCE)
+#include "Process_WINCE.h"
+#else
+#include "Poco/Process_WIN32U.h"
+#endif
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "Poco/Process_WIN32.h"
+#elif defined(POCO_VXWORKS)
+#include "Poco/Process_VX.h"
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include "Poco/Process_UNIX.h"
+#endif
+
+
+namespace Poco {
+
+
+class Pipe;
+
+
+class Foundation_API ProcessHandle
+	/// A handle for a process created with Process::launch().
+	///
+	/// This handle can be used to determine the process ID of
+	/// the newly created process and it can be used to wait for
+	/// the completion of a process.
+{
+public:
+	typedef ProcessImpl::PIDImpl PID;
+
+	ProcessHandle(const ProcessHandle& handle);
+		/// Creates a ProcessHandle by copying another one.
+
+	~ProcessHandle();
+		/// Destroys the ProcessHandle.
+
+	ProcessHandle& operator = (const ProcessHandle& handle);
+		/// Assigns another handle.
+
+	PID id() const;
+		/// Returns the process ID.
+
+	int wait() const;
+		/// Waits for the process to terminate
+		/// and returns the exit code of the process.
+
+protected:
+	ProcessHandle(ProcessHandleImpl* pImpl);
+
+private:
+	ProcessHandle();
+
+	ProcessHandleImpl* _pImpl;
+
+	friend class Process;
+};
+
+
+class Foundation_API Process: public ProcessImpl
+	/// This class provides methods for working with processes.
+{
+public:
+	typedef PIDImpl  PID;
+	typedef ArgsImpl Args;
+	typedef EnvImpl  Env;
+
+	static PID id();
+		/// Returns the process ID of the current process.
+
+	static void times(long& userTime, long& kernelTime);
+		/// Returns the number of seconds spent by the
+		/// current process in user and kernel mode.
+
+	static ProcessHandle launch(const std::string& command, const Args& args);
+		/// Creates a new process for the given command and returns
+		/// a ProcessHandle of the new process. The given arguments are
+		/// passed to the command on the command line.
+
+	static ProcessHandle launch(
+		const std::string& command,
+		const Args& args,
+		const std::string& initialDirectory);
+		/// Creates a new process for the given command and returns
+		/// a ProcessHandle of the new process. The given arguments are
+		/// passed to the command on the command line.
+		/// The process starts executing in the specified initial directory.
+
+	static ProcessHandle launch(
+		const std::string& command,
+		const Args& args,
+		Pipe* inPipe,
+		Pipe* outPipe,
+		Pipe* errPipe);
+		/// Creates a new process for the given command and returns
+		/// a ProcessHandle of the new process. The given arguments are
+		/// passed to the command on the command line.
+		///
+		/// If inPipe, outPipe or errPipe is non-null, the corresponding
+		/// standard input, standard output or standard error stream
+		/// of the launched process is redirected to the Pipe.
+		/// PipeInputStream or PipeOutputStream can be used to
+		/// send receive data from, or send data to the process.
+		///
+		/// Note: the same Pipe can be used for both outPipe and errPipe.
+		///
+		/// After a Pipe has been passed as inPipe, only write operations
+		/// are valid. After a Pipe has been passed as outPipe or errPipe,
+		/// only read operations are valid.
+		///
+		/// It is forbidden to pass the same pipe as inPipe and outPipe or errPipe.
+		///
+		/// Usage example:
+		///     Pipe outPipe;
+		///     Process::Args args;
+		///     ProcessHandle ph(launch("/bin/ps", args, 0, &outPipe, 0));
+		///     PipeInputStream istr(outPipe);
+		///     ... // read output of ps from istr
+		///     int rc = ph.wait();
+
+	static ProcessHandle launch(
+		const std::string& command,
+		const Args& args,
+		const std::string& initialDirectory,
+		Pipe* inPipe,
+		Pipe* outPipe,
+		Pipe* errPipe);
+		/// Creates a new process for the given command and returns
+		/// a ProcessHandle of the new process. The given arguments are
+		/// passed to the command on the command line.
+		/// The process starts executing in the specified initial directory.
+		///
+		/// If inPipe, outPipe or errPipe is non-null, the corresponding
+		/// standard input, standard output or standard error stream
+		/// of the launched process is redirected to the Pipe.
+		/// PipeInputStream or PipeOutputStream can be used to
+		/// send receive data from, or send data to the process.
+		///
+		/// Note: the same Pipe can be used for both outPipe and errPipe.
+		///
+		/// After a Pipe has been passed as inPipe, only write operations
+		/// are valid. After a Pipe has been passed as outPipe or errPipe,
+		/// only read operations are valid.
+		///
+		/// It is forbidden to pass the same pipe as inPipe and outPipe or errPipe.
+		///
+		/// Usage example:
+		///     Pipe outPipe;
+		///     Process::Args args;
+		///     ProcessHandle ph(launch("/bin/ps", args, 0, &outPipe, 0));
+		///     PipeInputStream istr(outPipe);
+		///     ... // read output of ps from istr
+		///     int rc = ph.wait();
+
+	static ProcessHandle launch(
+		const std::string& command,
+		const Args& args,
+		Pipe* inPipe,
+		Pipe* outPipe,
+		Pipe* errPipe,
+		const Env& env);
+		/// Creates a new process for the given command and returns
+		/// a ProcessHandle of the new process. The given arguments are
+		/// passed to the command on the command line.
+		///
+		/// If inPipe, outPipe or errPipe is non-null, the corresponding
+		/// standard input, standard output or standard error stream
+		/// of the launched process is redirected to the Pipe.
+		///
+		/// The launched process is given the specified environment variables.
+
+	static ProcessHandle launch(
+		const std::string& command,
+		const Args& args,
+		const std::string& initialDirectory,
+		Pipe* inPipe,
+		Pipe* outPipe,
+		Pipe* errPipe,
+		const Env& env);
+		/// Creates a new process for the given command and returns
+		/// a ProcessHandle of the new process. The given arguments are
+		/// passed to the command on the command line.
+		/// The process starts executing in the specified initial directory.
+		/// If inPipe, outPipe or errPipe is non-null, the corresponding
+		/// standard input, standard output or standard error stream
+		/// of the launched process is redirected to the Pipe.
+		/// The launched process is given the specified environment variables.
+
+	static int wait(const ProcessHandle& handle);
+		/// Waits for the process specified by handle to terminate
+		/// and returns the exit code of the process.
+
+	static bool isRunning(const ProcessHandle& handle);
+		/// check if the process specified by handle is running or not
+		///
+		/// This is preferable on Windows where process IDs
+		/// may be reused.
+
+	static bool isRunning(PID pid);
+		/// Check if the process specified by given pid is running or not.
+
+	static void kill(ProcessHandle& handle);
+		/// Kills the process specified by handle.
+		///
+		/// This is preferable on Windows where process IDs
+		/// may be reused.
+
+	static void kill(PID pid);
+		/// Kills the process with the given pid.
+
+	static void requestTermination(PID pid);
+		/// Requests termination of the process with the give PID.
+		///
+		/// On Unix platforms, this will send a SIGINT to the
+		/// process and thus work with arbitrary processes.
+		///
+		/// On other platforms, a global event flag
+		/// will be set. Setting the flag will cause
+		/// Util::ServerApplication::waitForTerminationRequest() to
+		/// return. Therefore this will only work with applications
+		/// based on Util::ServerApplication.
+};
+
+
+//
+// inlines
+//
+inline Process::PID Process::id()
+{
+	return ProcessImpl::idImpl();
+}
+
+
+inline void Process::times(long& userTime, long& kernelTime)
+{
+	ProcessImpl::timesImpl(userTime, kernelTime);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Process_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Process_UNIX.h b/base/poco/Foundation/include/Poco/Process_UNIX.h
new file mode 100644
index 00000000000..b33dd082108
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Process_UNIX.h
@@ -0,0 +1,86 @@
+//
+// Process_UNIX.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  Process
+//
+// Definition of the ProcessImpl class for Unix.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Process_UNIX_INCLUDED
+#define Foundation_Process_UNIX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/RefCountedObject.h"
+#include <unistd.h>
+#include <vector>
+#include <map>
+
+
+namespace Poco {
+
+
+class Pipe;
+
+
+class Foundation_API ProcessHandleImpl: public RefCountedObject
+{
+public:
+	ProcessHandleImpl(pid_t pid);
+	~ProcessHandleImpl();
+	
+	pid_t id() const;
+	int wait() const;
+	
+private:
+	pid_t _pid;
+};
+
+
+class Foundation_API ProcessImpl
+{
+public:
+	typedef pid_t PIDImpl;
+	typedef std::vector<std::string> ArgsImpl;
+	typedef std::map<std::string, std::string> EnvImpl;
+	
+	static PIDImpl idImpl();
+	static void timesImpl(long& userTime, long& kernelTime);
+	static ProcessHandleImpl* launchImpl(
+		const std::string& command, 
+		const ArgsImpl& args, 
+		const std::string& initialDirectory,
+		Pipe* inPipe, 
+		Pipe* outPipe, 
+		Pipe* errPipe,
+		const EnvImpl& env);
+	static void killImpl(ProcessHandleImpl& handle);
+	static void killImpl(PIDImpl pid);
+	static bool isRunningImpl(const ProcessHandleImpl& handle);
+	static bool isRunningImpl(PIDImpl pid);
+	static void requestTerminationImpl(PIDImpl pid);
+
+private:
+	static ProcessHandleImpl* launchByForkExecImpl(
+		const std::string& command, 
+		const ArgsImpl& args, 
+		const std::string& initialDirectory,
+		Pipe* inPipe, 
+		Pipe* outPipe, 
+		Pipe* errPipe,
+		const EnvImpl& env);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Process_UNIX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Process_VX.h b/base/poco/Foundation/include/Poco/Process_VX.h
new file mode 100644
index 00000000000..0ac9bcef235
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Process_VX.h
@@ -0,0 +1,78 @@
+//
+// Process_VX.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  Process
+//
+// Definition of the ProcessImpl class for VxWorks.
+//
+// Copyright (c) 2004-20011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Process_VX_INCLUDED
+#define Foundation_Process_VX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/RefCountedObject.h"
+#include <vector>
+#include <map>
+
+
+#undef PID
+
+
+namespace Poco {
+
+
+class Pipe;
+
+
+class Foundation_API ProcessHandleImpl: public RefCountedObject
+{
+public:
+	ProcessHandleImpl(int pid);
+	~ProcessHandleImpl();
+	
+	int id() const;
+	int wait() const;
+	
+private:
+	int _pid;
+};
+
+
+class Foundation_API ProcessImpl
+{
+public:
+	typedef int PIDImpl;
+	typedef std::vector<std::string> ArgsImpl;
+	typedef std::map<std::string, std::string> EnvImpl;
+	
+	static PIDImpl idImpl();
+	static void timesImpl(long& userTime, long& kernelTime);
+	static ProcessHandleImpl* launchImpl(
+		const std::string& command, 
+		const ArgsImpl& args, 
+		const std::string& initialDirectory,
+		Pipe* inPipe, 
+		Pipe* outPipe, 
+		Pipe* errPipe,
+		const EnvImpl& env);
+	static void killImpl(ProcessHandleImpl& handle);
+	static void killImpl(PIDImpl pid);
+	static bool isRunningImpl(const ProcessHandleImpl& handle);
+	static bool isRunningImpl(PIDImpl pid);
+	static void requestTerminationImpl(PIDImpl pid);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Process_UNIX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Process_WIN32.h b/base/poco/Foundation/include/Poco/Process_WIN32.h
new file mode 100644
index 00000000000..afed42c25a8
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Process_WIN32.h
@@ -0,0 +1,83 @@
+//
+// Process_WIN32.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  Process
+//
+// Definition of the ProcessImpl class for WIN32.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Process_WIN32_INCLUDED
+#define Foundation_Process_WIN32_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/RefCountedObject.h"
+#include <vector>
+#include <map>
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Pipe;
+
+
+class Foundation_API ProcessHandleImpl: public RefCountedObject
+{
+public:
+	ProcessHandleImpl(HANDLE _hProcess, UInt32 pid);
+	~ProcessHandleImpl();
+	
+	UInt32 id() const;
+	HANDLE process() const;
+	int wait() const;
+	void closeHandle();
+
+private:
+	HANDLE _hProcess;
+	UInt32 _pid;
+	
+	ProcessHandleImpl(const ProcessHandleImpl&);
+	ProcessHandleImpl& operator = (const ProcessHandleImpl&);
+};
+
+
+class Foundation_API ProcessImpl
+{
+public:
+	typedef UInt32 PIDImpl;
+	typedef std::vector<std::string> ArgsImpl;
+	typedef std::map<std::string, std::string> EnvImpl;
+	
+	static PIDImpl idImpl();
+	static void timesImpl(long& userTime, long& kernelTime);
+	static ProcessHandleImpl* launchImpl(
+		const std::string& command, 
+		const ArgsImpl& args, 
+		const std::string& initialDirectory,
+		Pipe* inPipe, 
+		Pipe* outPipe, 
+		Pipe* errPipe,
+		const EnvImpl& env);
+	static void killImpl(ProcessHandleImpl& handle);
+	static void killImpl(PIDImpl pid);
+	static bool isRunningImpl(const ProcessHandleImpl& handle);
+	static bool isRunningImpl(PIDImpl pid);
+	static void requestTerminationImpl(PIDImpl pid);
+	static std::string terminationEventName(PIDImpl pid);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Process_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Process_WIN32U.h b/base/poco/Foundation/include/Poco/Process_WIN32U.h
new file mode 100644
index 00000000000..bb520136076
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Process_WIN32U.h
@@ -0,0 +1,83 @@
+//
+// Process_WIN32U.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  Process
+//
+// Definition of the ProcessImpl class for WIN32.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Process_WIN32U_INCLUDED
+#define Foundation_Process_WIN32U_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/RefCountedObject.h"
+#include <vector>
+#include <map>
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Pipe;
+
+
+class Foundation_API ProcessHandleImpl: public RefCountedObject
+{
+public:
+	ProcessHandleImpl(HANDLE _hProcess, UInt32 pid);
+	~ProcessHandleImpl();
+	
+	UInt32 id() const;
+	HANDLE process() const;
+	int wait() const;
+	void closeHandle();
+
+private:
+	HANDLE _hProcess;
+	UInt32 _pid;
+
+	ProcessHandleImpl(const ProcessHandleImpl&);
+	ProcessHandleImpl& operator = (const ProcessHandleImpl&);
+};
+
+
+class Foundation_API ProcessImpl
+{
+public:
+	typedef UInt32 PIDImpl;
+	typedef std::vector<std::string> ArgsImpl;
+	typedef std::map<std::string, std::string> EnvImpl;
+	
+	static PIDImpl idImpl();
+	static void timesImpl(long& userTime, long& kernelTime);
+	static ProcessHandleImpl* launchImpl(
+		const std::string& command, 
+		const ArgsImpl& args, 
+		const std::string& initialDirectory,
+		Pipe* inPipe, 
+		Pipe* outPipe, 
+		Pipe* errPipe,
+		const EnvImpl& env);
+	static void killImpl(ProcessHandleImpl& handle);
+	static void killImpl(PIDImpl pid);
+	static bool isRunningImpl(const ProcessHandleImpl& handle);
+	static bool isRunningImpl(PIDImpl pid);
+	static void requestTerminationImpl(PIDImpl pid);
+	static std::string terminationEventName(PIDImpl pid);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Process_WIN32U_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Process_WINCE.h b/base/poco/Foundation/include/Poco/Process_WINCE.h
new file mode 100644
index 00000000000..f754c577ab8
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Process_WINCE.h
@@ -0,0 +1,83 @@
+//
+// Process_WINCE.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  Process
+//
+// Definition of the ProcessImpl class for WIN32.
+//
+// Copyright (c) 2004-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Process_WINCE_INCLUDED
+#define Foundation_Process_WINCE_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/RefCountedObject.h"
+#include <vector>
+#include <map>
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Pipe;
+
+
+class Foundation_API ProcessHandleImpl: public RefCountedObject
+{
+public:
+	ProcessHandleImpl(HANDLE _hProcess, UInt32 pid);
+	~ProcessHandleImpl();
+	
+	UInt32 id() const;
+	HANDLE process() const;
+	int wait() const;
+	void closeHandle();
+
+private:
+	HANDLE _hProcess;
+	UInt32 _pid;
+
+	ProcessHandleImpl(const ProcessHandleImpl&);
+	ProcessHandleImpl& operator = (const ProcessHandleImpl&);
+};
+
+
+class Foundation_API ProcessImpl
+{
+public:
+	typedef UInt32 PIDImpl;
+	typedef std::vector<std::string> ArgsImpl;
+	typedef std::map<std::string, std::string> EnvImpl;
+	
+	static PIDImpl idImpl();
+	static void timesImpl(long& userTime, long& kernelTime);
+	static ProcessHandleImpl* launchImpl(
+		const std::string& command, 
+		const ArgsImpl& args, 
+		const std::string& initialDirectory,
+		Pipe* inPipe, 
+		Pipe* outPipe, 
+		Pipe* errPipe,
+		const EnvImpl& env);
+	static void killImpl(ProcessHandleImpl& handle);
+	static void killImpl(PIDImpl pid);
+	static bool isRunningImpl(const ProcessHandleImpl& handle);
+	static bool isRunningImpl(PIDImpl pid);
+	static void requestTerminationImpl(PIDImpl pid);
+	static std::string terminationEventName(PIDImpl pid);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Process_WINCE_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/PurgeStrategy.h b/base/poco/Foundation/include/Poco/PurgeStrategy.h
new file mode 100644
index 00000000000..eb9a9299852
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/PurgeStrategy.h
@@ -0,0 +1,107 @@
+//
+// PurgeStrategy.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  FileChannel
+//
+// Definition of the PurgeStrategy class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_PurgeStrategy_INCLUDED
+#define Foundation_PurgeStrategy_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/File.h"
+#include "Poco/Timespan.h"
+#include <vector>
+
+
+namespace Poco {
+
+
+class Foundation_API PurgeStrategy
+	/// The PurgeStrategy is used by FileChannel
+	/// to purge archived log files.
+{
+public:
+	PurgeStrategy();
+	virtual ~PurgeStrategy();
+
+	virtual void purge(const std::string& path) = 0;
+		/// Purges archived log files. The path to the
+		/// current "hot" log file is given.
+		/// To find archived log files, look for files
+		/// with a name consisting of the given path
+		/// plus any suffix (e.g., .1, .20050929081500, .1.gz).
+		/// A list of archived files can be obtained by calling
+		/// the list() method.
+
+protected:
+	void list(const std::string& path, std::vector<File>& files);
+		/// Fills the given vector with a list of archived log
+		/// files. The path of the current "hot" log file is
+		/// given in path.
+		///
+		/// All files with the same name as the one given in path,
+		/// plus some suffix (e.g., .1, .20050929081500, .1.gz) are
+		/// considered archived files.
+
+private:
+	PurgeStrategy(const PurgeStrategy&);
+	PurgeStrategy& operator = (const PurgeStrategy&);
+};
+
+
+class Foundation_API PurgeByAgeStrategy: public PurgeStrategy
+	/// This purge strategy purges all files that have
+	/// exceeded a given age (given in seconds).
+{
+public:
+	PurgeByAgeStrategy(const Timespan& age);
+	~PurgeByAgeStrategy();
+
+	void purge(const std::string& path);
+
+private:
+	Timespan _age;
+};
+
+
+class Foundation_API PurgeByCountStrategy: public PurgeStrategy
+	/// This purge strategy ensures that a maximum number
+	/// of archived files is not exceeded. Files are deleted
+	/// based on their age, with oldest files deleted first.
+{
+public:
+	PurgeByCountStrategy(int count);
+	~PurgeByCountStrategy();
+
+	void purge(const std::string& path);
+
+private:
+	int _count;
+};
+
+
+class Foundation_API PurgeOneFileStrategy: public PurgeStrategy
+	/// This purge strategy unconditionally purges one oldest file.
+	/// If there are no archived files, it will truncate current "hot" log file.
+	/// Intended usage: when there are no space left on device with logs.
+{
+public:
+	void purge(const std::string& path);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_PurgeStrategy_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/RWLock.h b/base/poco/Foundation/include/Poco/RWLock.h
new file mode 100644
index 00000000000..23b3b16cb22
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/RWLock.h
@@ -0,0 +1,203 @@
+//
+// RWLock.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  RWLock
+//
+// Definition of the RWLock class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_RWLock_INCLUDED
+#define Foundation_RWLock_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#if defined(_WIN32_WCE)
+#include "Poco/RWLock_WINCE.h"
+#else
+#include "Poco/RWLock_WIN32.h"
+#endif
+#elif POCO_OS == POCO_OS_ANDROID
+#include "Poco/RWLock_Android.h"
+#elif defined(POCO_VXWORKS)
+#include "Poco/RWLock_VX.h"
+#else
+#include "Poco/RWLock_POSIX.h"
+#endif
+
+
+namespace Poco {
+
+
+class ScopedRWLock;
+class ScopedReadRWLock;
+class ScopedWriteRWLock;
+
+
+class Foundation_API RWLock: private RWLockImpl
+	/// A reader writer lock allows multiple concurrent
+	/// readers or one exclusive writer.
+{
+public:
+	typedef ScopedRWLock ScopedLock;
+	typedef ScopedReadRWLock ScopedReadLock;
+	typedef ScopedWriteRWLock ScopedWriteLock;
+
+	RWLock();
+		/// Creates the Reader/Writer lock.
+		
+	~RWLock();
+		/// Destroys the Reader/Writer lock.
+	
+	void readLock();
+		/// Acquires a read lock. If another thread currently holds a write lock,
+		/// waits until the write lock is released.
+
+	bool tryReadLock();
+		/// Tries to acquire a read lock. Immediately returns true if successful, or
+		/// false if another thread currently holds a write lock.
+
+	void writeLock();
+		/// Acquires a write lock. If one or more other threads currently hold 
+		/// locks, waits until all locks are released. The results are undefined
+		/// if the same thread already holds a read or write lock
+
+	bool tryWriteLock();
+		/// Tries to acquire a write lock. Immediately returns true if successful,
+		/// or false if one or more other threads currently hold 
+		/// locks. The result is undefined if the same thread already
+		/// holds a read or write lock.
+
+	void unlock();
+		/// Releases the read or write lock.
+
+private:
+	RWLock(const RWLock&);
+	RWLock& operator = (const RWLock&);
+};
+
+
+class Foundation_API ScopedRWLock
+	/// A variant of ScopedLock for reader/writer locks.
+{
+public:
+	ScopedRWLock(RWLock& rwl, bool write = false);
+	~ScopedRWLock();
+
+private:
+	RWLock& _rwl;
+
+	ScopedRWLock();
+	ScopedRWLock(const ScopedRWLock&);
+	ScopedRWLock& operator = (const ScopedRWLock&);
+};
+
+
+class Foundation_API ScopedReadRWLock : public ScopedRWLock
+	/// A variant of ScopedLock for reader locks.
+{
+public:
+	ScopedReadRWLock(RWLock& rwl);
+	~ScopedReadRWLock();
+};
+
+
+class Foundation_API ScopedWriteRWLock : public ScopedRWLock
+	/// A variant of ScopedLock for writer locks.
+{
+public:
+	ScopedWriteRWLock(RWLock& rwl);
+	~ScopedWriteRWLock();
+};
+
+
+//
+// inlines
+//
+inline void RWLock::readLock()
+{
+	readLockImpl();
+}
+
+
+inline bool RWLock::tryReadLock()
+{
+	return tryReadLockImpl();
+}
+
+
+inline void RWLock::writeLock()
+{
+	writeLockImpl();
+}
+
+
+inline bool RWLock::tryWriteLock()
+{
+	return tryWriteLockImpl();
+}
+
+
+inline void RWLock::unlock()
+{
+	unlockImpl();
+}
+
+
+inline ScopedRWLock::ScopedRWLock(RWLock& rwl, bool write): _rwl(rwl)
+{
+	if (write)
+		_rwl.writeLock();
+	else
+		_rwl.readLock();
+}
+
+
+inline ScopedRWLock::~ScopedRWLock()
+{
+	try
+	{
+		_rwl.unlock();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+inline ScopedReadRWLock::ScopedReadRWLock(RWLock& rwl): ScopedRWLock(rwl, false)
+{
+}
+
+
+inline ScopedReadRWLock::~ScopedReadRWLock()
+{
+}
+
+
+inline ScopedWriteRWLock::ScopedWriteRWLock(RWLock& rwl): ScopedRWLock(rwl, true)
+{
+}
+
+
+inline ScopedWriteRWLock::~ScopedWriteRWLock()
+{
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_RWLock_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/RWLock_Android.h b/base/poco/Foundation/include/Poco/RWLock_Android.h
new file mode 100644
index 00000000000..c6dfc4e5bf3
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/RWLock_Android.h
@@ -0,0 +1,97 @@
+//
+// RWLock_Android.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  RWLock
+//
+// Definition of the RWLockImpl class for Android Threads.
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_RWLock_Android_INCLUDED
+#define Foundation_RWLock_Android_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include <pthread.h>
+#include <errno.h>
+
+
+namespace Poco {
+
+
+class Foundation_API RWLockImpl
+{
+protected:
+	RWLockImpl();
+	~RWLockImpl();
+	void readLockImpl();
+	bool tryReadLockImpl();
+	void writeLockImpl();
+	bool tryWriteLockImpl();
+	void unlockImpl();
+	
+private:
+	pthread_mutex_t _mutex;
+};
+
+
+//
+// inlines
+//
+inline void RWLockImpl::readLockImpl()
+{
+	if (pthread_mutex_lock(&_mutex)) 
+		throw SystemException("cannot lock reader/writer lock");
+}
+
+
+inline bool RWLockImpl::tryReadLockImpl()
+{
+	int rc = pthread_mutex_trylock(&_mutex);
+	if (rc == 0)
+		return true;
+	else if (rc == EBUSY)
+		return false;
+	else
+		throw SystemException("cannot lock reader/writer lock");
+}
+
+
+inline void RWLockImpl::writeLockImpl()
+{
+	if (pthread_mutex_lock(&_mutex)) 
+		throw SystemException("cannot lock reader/writer lock");
+}
+
+
+inline bool RWLockImpl::tryWriteLockImpl()
+{
+	int rc = pthread_mutex_trylock(&_mutex);
+	if (rc == 0)
+		return true;
+	else if (rc == EBUSY)
+		return false;
+	else
+		throw SystemException("cannot lock reader/writer lock");
+}
+
+
+inline void RWLockImpl::unlockImpl()
+{
+	if (pthread_mutex_unlock(&_mutex))
+		throw SystemException("cannot unlock reader/writer lock");
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_RWLock_Android_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/RWLock_POSIX.h b/base/poco/Foundation/include/Poco/RWLock_POSIX.h
new file mode 100644
index 00000000000..be4d11beb44
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/RWLock_POSIX.h
@@ -0,0 +1,99 @@
+//
+// RWLock_POSIX.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  RWLock
+//
+// Definition of the RWLockImpl class for POSIX Threads.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_RWLock_POSIX_INCLUDED
+#define Foundation_RWLock_POSIX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include <pthread.h>
+#include <errno.h>
+
+
+namespace Poco {
+
+
+class Foundation_API RWLockImpl
+{
+protected:
+	RWLockImpl();
+	~RWLockImpl();
+	void readLockImpl();
+	bool tryReadLockImpl();
+	void writeLockImpl();
+	bool tryWriteLockImpl();
+	void unlockImpl();
+	
+private:
+	pthread_rwlock_t _rwl;
+};
+
+
+//
+// inlines
+//
+inline void RWLockImpl::readLockImpl()
+{
+	if (pthread_rwlock_rdlock(&_rwl)) 
+		throw SystemException("cannot lock reader/writer lock");
+}
+
+
+inline bool RWLockImpl::tryReadLockImpl()
+{
+	int rc = pthread_rwlock_tryrdlock(&_rwl);
+	if (rc == 0)
+		return true;
+	else if (rc == EBUSY)
+		return false;
+	else
+		throw SystemException("cannot lock reader/writer lock");
+
+}
+
+
+inline void RWLockImpl::writeLockImpl()
+{
+	if (pthread_rwlock_wrlock(&_rwl)) 
+		throw SystemException("cannot lock reader/writer lock");
+}
+
+
+inline bool RWLockImpl::tryWriteLockImpl()
+{
+	int rc = pthread_rwlock_trywrlock(&_rwl);
+	if (rc == 0)
+		return true;
+	else if (rc == EBUSY)
+		return false;
+	else
+		throw SystemException("cannot lock reader/writer lock");
+
+}
+
+
+inline void RWLockImpl::unlockImpl()
+{
+	if (pthread_rwlock_unlock(&_rwl))
+		throw SystemException("cannot unlock mutex");
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_RWLock_POSIX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/RWLock_VX.h b/base/poco/Foundation/include/Poco/RWLock_VX.h
new file mode 100644
index 00000000000..bdc4af2fe2b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/RWLock_VX.h
@@ -0,0 +1,92 @@
+//
+// RWLock_VX.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  RWLock
+//
+// Definition of the RWLockImpl class for POSIX Threads (VxWorks).
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_RWLock_VX_INCLUDED
+#define Foundation_RWLock_VX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include <pthread.h>
+#include <errno.h>
+
+
+namespace Poco {
+
+
+class Foundation_API RWLockImpl
+{
+protected:
+	RWLockImpl();
+	~RWLockImpl();
+	void readLockImpl();
+	bool tryReadLockImpl();
+	void writeLockImpl();
+	bool tryWriteLockImpl();
+	void unlockImpl();
+	
+private:
+	pthread_mutex_t _mutex;
+};
+
+
+//
+// inlines
+//
+inline void RWLockImpl::readLockImpl()
+{
+	if (pthread_mutex_lock(&_mutex)) 
+		throw SystemException("cannot lock mutex");
+}
+
+
+inline bool RWLockImpl::tryReadLockImpl()
+{
+	int rc = pthread_mutex_trylock(&_mutex);
+	if (rc == 0)
+		return true;
+	else if (rc == EBUSY)
+		return false;
+	else
+		throw SystemException("cannot lock mutex");
+
+}
+
+
+inline void RWLockImpl::writeLockImpl()
+{
+	readLockImpl();
+}
+
+
+inline bool RWLockImpl::tryWriteLockImpl()
+{
+	return tryReadLockImpl();
+
+}
+
+
+inline void RWLockImpl::unlockImpl()
+{
+	if (pthread_mutex_unlock(&_mutex))
+		throw SystemException("cannot unlock mutex");
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_RWLock_VX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/RWLock_WIN32.h b/base/poco/Foundation/include/Poco/RWLock_WIN32.h
new file mode 100644
index 00000000000..e50856e1b4b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/RWLock_WIN32.h
@@ -0,0 +1,57 @@
+//
+// RWLock_WIN32.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  RWLock
+//
+// Definition of the RWLockImpl class for WIN32.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_RWLock_WIN32_INCLUDED
+#define Foundation_RWLock_WIN32_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API RWLockImpl
+{
+protected:
+	RWLockImpl();
+	~RWLockImpl();
+	void readLockImpl();
+	bool tryReadLockImpl();
+	void writeLockImpl();
+	bool tryWriteLockImpl();
+	void unlockImpl();
+	
+private:
+	void addWriter();
+	void removeWriter();
+	DWORD tryReadLockOnce();
+
+	HANDLE   _mutex;
+	HANDLE   _readEvent;
+	HANDLE   _writeEvent;
+	unsigned _readers;
+	unsigned _writersWaiting;
+	unsigned _writers;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_RWLock_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/RWLock_WINCE.h b/base/poco/Foundation/include/Poco/RWLock_WINCE.h
new file mode 100644
index 00000000000..d6c8314b243
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/RWLock_WINCE.h
@@ -0,0 +1,61 @@
+//
+// RWLock_WINCE.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  RWLock
+//
+// Definition of the RWLockImpl class for WINCE.
+//
+// Copyright (c) 2009-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_RWLock_WINCE_INCLUDED
+#define Foundation_RWLock_WINCE_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API RWLockImpl
+	/// This implementation is based on the one from Stone Steps Inc,
+	/// licensed under the BSD license.
+	/// http://forums.stonesteps.ca/thread.asp?t=105
+	///
+	/// Note that with this implementation, writers always take
+	/// precedence over readers.
+{
+protected:
+	RWLockImpl();
+	~RWLockImpl();
+	void readLockImpl();
+	bool tryReadLockImpl(DWORD timeout = 1);
+	void writeLockImpl();
+	bool tryWriteLockImpl(DWORD timeout = 1);
+	void unlockImpl();
+	
+private:
+	DWORD _readerCount;
+	DWORD _readerWaiting;
+	DWORD _writerCount;
+	DWORD _writerWaiting;
+	HANDLE _readerGreen;
+	HANDLE _writerGreen;
+	CRITICAL_SECTION _cs;
+	bool _writeLock;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_RWLock_WINCE_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Random.h b/base/poco/Foundation/include/Poco/Random.h
new file mode 100644
index 00000000000..3db078e131b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Random.h
@@ -0,0 +1,165 @@
+//
+// Random.h
+//
+// Library: Foundation
+// Package: Crypt
+// Module:  Random
+//
+// Definition of class Random.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+//
+// Based on the FreeBSD random number generator.
+// src/lib/libc/stdlib/random.c,v 1.25 
+//
+// Copyright (c) 1983, 1993
+// The Regents of the University of California.  All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 4. Neither the name of the University nor the names of its contributors
+//    may be used to endorse or promote products derived from this software
+//    without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+// SUCH DAMAGE.
+//
+
+
+#ifndef Foundation_Random_INCLUDED
+#define Foundation_Random_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Random
+	/// A better random number generator.
+	/// Random implements a pseudo random number generator
+	/// (PRNG). The PRNG is a nonlinear additive
+	/// feedback random number generator using 256 bytes
+	/// of state information and a period of up to 2^69.
+{
+public:
+	enum Type
+	{
+		RND_STATE_0   =   8,  /// linear congruential
+		RND_STATE_32  =  32,  /// x**7 + x**3 + 1
+		RND_STATE_64  =  64,  /// x**15 + x + 1
+		RND_STATE_128 = 128,  /// x**31 + x**3 + 1
+		RND_STATE_256 = 256   /// x**63 + x + 1
+	};
+
+	Random(int stateSize = 256);
+		/// Creates and initializes the PRNG.
+		/// Specify either a state buffer size
+		/// (8 to 256 bytes) or one of the Type values.
+
+	~Random();
+		/// Destroys the PRNG.
+
+	void seed(UInt32 seed);
+		/// Seeds the pseudo random generator with the given seed.
+
+	void seed();
+		/// Seeds the pseudo random generator with a random seed
+		/// obtained from a RandomInputStream.
+
+	UInt32 next();
+		/// Returns the next 31-bit pseudo random number.
+
+	UInt32 next(UInt32 n);
+		/// Returns the next 31-bit pseudo random number modulo n.
+	
+	char nextChar();
+		/// Returns the next pseudo random character.
+	
+	bool nextBool();
+		/// Returns the next boolean pseudo random value.
+		
+	float nextFloat();
+		/// Returns the next float pseudo random number between 0.0 and 1.0.
+		
+	double nextDouble();
+		/// Returns the next double pseudo random number between 0.0 and 1.0.
+
+protected:
+	void initState(UInt32 seed, char* arg_state, Int32 n);
+	static UInt32 goodRand(Int32 x);
+
+private:
+	enum
+	{
+		MAX_TYPES = 5,
+		NSHUFF    = 50
+	};
+
+	UInt32* _fptr;
+	UInt32* _rptr;
+	UInt32* _state;
+	int     _randType;
+	int     _randDeg;
+	int     _randSep;
+	UInt32* _endPtr;
+	char*  _pBuffer;
+};
+
+
+//
+// inlines
+//
+inline UInt32 Random::next(UInt32 n)
+{
+	return next() % n;
+}
+
+
+inline char Random::nextChar()
+{
+	return char((next() >> 3) & 0xFF);
+}
+
+
+inline bool Random::nextBool()
+{
+	return (next() & 0x1000) != 0;
+}
+
+	
+inline float Random::nextFloat()
+{
+	return float(next()) / 0x7FFFFFFF;
+}
+
+	
+inline double Random::nextDouble()
+{
+	return double(next()) / 0x7FFFFFFF;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Random_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/RandomStream.h b/base/poco/Foundation/include/Poco/RandomStream.h
new file mode 100644
index 00000000000..152b95c835b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/RandomStream.h
@@ -0,0 +1,73 @@
+//
+// RandomStream.h
+//
+// Library: Foundation
+// Package: Crypt
+// Module:  RandomStream
+//
+// Definition of class RandomInputStream.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_RandomStream_INCLUDED
+#define Foundation_RandomStream_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/BufferedStreamBuf.h"
+#include <istream>
+
+
+namespace Poco {
+
+
+class Foundation_API RandomBuf: public BufferedStreamBuf
+	/// This streambuf generates random data.
+	/// On Windows NT, the cryptographic API is used.
+	/// On Unix, /dev/random is used, if available.
+	/// Otherwise, a random number generator, some
+	/// more-or-less random data and a SHA-1 digest
+	/// is used to generate random data.
+{
+public:
+	RandomBuf();
+	~RandomBuf();
+	int readFromDevice(char* buffer, std::streamsize length);
+};
+
+
+class Foundation_API RandomIOS: public virtual std::ios
+	/// The base class for RandomInputStream.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	RandomIOS();
+	~RandomIOS();
+	RandomBuf* rdbuf();
+
+protected:
+	RandomBuf _buf;
+};
+
+
+class Foundation_API RandomInputStream: public RandomIOS, public std::istream
+	/// This istream generates random data
+	/// using the RandomBuf.
+{
+public:
+	RandomInputStream();
+	~RandomInputStream();
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_RandomStream_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/RecursiveDirectoryIterator.h b/base/poco/Foundation/include/Poco/RecursiveDirectoryIterator.h
new file mode 100644
index 00000000000..c0ce2285eee
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/RecursiveDirectoryIterator.h
@@ -0,0 +1,254 @@
+//
+// RecursiveDirectoryIterator.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  RecursiveDirectoryIterator
+//
+// Definition of the RecursiveDirectoryIterator class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_RecursiveDirectoryIterator_INCLUDED
+#define Foundation_RecursiveDirectoryIterator_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/File.h"
+#include "Poco/Path.h"
+#include "Poco/RecursiveDirectoryIteratorImpl.h"
+#include "Poco/DirectoryIteratorStrategy.h"
+
+
+namespace Poco {
+
+
+class DirectoryIterator;
+
+
+template<class TTravStr>
+class RecursiveDirectoryIteratorImpl;
+
+
+template<class TTravStr = ChildrenFirstTraverse>
+class RecursiveDirectoryIterator
+	/// The RecursiveDirectoryIterator class is used to enumerate
+	/// all files in a directory and its subdirectories.
+	///
+	/// RecursiveDirectoryIterator has some limitations:
+	///   * only forward iteration (++) is supported
+	///   * an iterator copied from another one will always
+	///     point to the same file as the original iterator,
+	///     even is the original iterator has been advanced
+	///     (all copies of an iterator share their state with
+	///     the original iterator)
+	///
+	/// The class can follow different traversal strategies:
+	///     * depth-first strategy;
+	///     * siblings-first strategy.
+	/// The stategies are set by template parameter.
+	/// There are two corresponding typedefs:
+	///     * SimpleRecursiveDirectoryIterator;
+	///     * SiblingsFirstRecursiveDirectoryIterator.
+	///
+	/// The depth of traversal can be limited by constructor
+	/// parameter maxDepth (which sets the infinite depth by default).
+{
+public:
+	typedef RecursiveDirectoryIterator<TTravStr> MyType;
+
+	enum
+	{
+		D_INFINITE = 0 /// Constant for infinite traverse depth.
+	};
+
+	RecursiveDirectoryIterator()
+		/// Creates the end iterator.
+		: _pImpl(0)
+	{
+	}
+
+	RecursiveDirectoryIterator(const std::string& path, UInt16 maxDepth = D_INFINITE)
+		/// Creates a recursive directory iterator for the given path.
+		: _pImpl(new ImplType(path, maxDepth)), _path(Path(_pImpl->get())), _file(_path)
+	{
+	}
+
+	RecursiveDirectoryIterator(const MyType& iterator):
+		/// Creates a copy of another recursive directory iterator.
+		_pImpl(iterator._pImpl), _path(iterator._path), _file(iterator._file)
+	{
+	}
+
+	RecursiveDirectoryIterator(const DirectoryIterator& iterator, UInt16 maxDepth = D_INFINITE):
+		/// Creates a recursive directory iterator for the path of
+		/// non-recursive directory iterator.
+		_pImpl(new ImplType(iterator->path(), maxDepth)), _path(Path(_pImpl->get())), _file(_path)
+	{
+	}
+
+	RecursiveDirectoryIterator(const File& file, UInt16 maxDepth = D_INFINITE):
+		/// Creates a recursive directory iterator for the given path.
+		_pImpl(new ImplType(file.path(), maxDepth)), _path(Path(_pImpl->get())), _file(_path)
+	{
+	}
+
+	RecursiveDirectoryIterator(const Path& path, UInt16 maxDepth = D_INFINITE):
+		/// Creates a recursive directory iterator for the given path.
+		_pImpl(new ImplType(path.toString(), maxDepth)), _path(Path(_pImpl->get())), _file(_path)
+	{
+	}
+
+	~RecursiveDirectoryIterator()
+		/// Destroys the DirectoryIterator.
+	{
+		if (_pImpl)
+			_pImpl->release();
+	}
+
+	const std::string& name() const
+		/// Returns the current filename.
+	{
+		return _path.getFileName();
+	}
+
+	const Poco::Path& path() const
+		/// Returns the current path.
+	{
+		return _path;
+	}
+
+	UInt16 depth() const
+		/// Depth of recursion (counting from 1).
+	{
+		return _pImpl->depth();
+	}
+
+	UInt16 maxDepth() const
+		/// Max depth of recursion (counting from 1).
+	{
+		return _pImpl->maxDepth();
+	}
+
+
+	MyType& operator = (const MyType& it)
+	{
+		if (_pImpl)
+			_pImpl->release();
+		_pImpl = it._pImpl;
+		if (_pImpl)
+		{
+			_pImpl->duplicate();
+			_path = it._path;
+			_file = _path;
+		}
+		return *this;
+	}
+
+	MyType& operator = (const File& file)
+	{
+		if (_pImpl)
+			_pImpl->release();
+		_pImpl = new ImplType(file.path());
+		_path = Path(_pImpl->get());
+		_file = _path;
+		return *this;
+	}
+
+
+	MyType& operator = (const Path& path)
+	{
+		if (_pImpl)
+			_pImpl->release();
+		_pImpl = new ImplType(path.toString());
+		_path = Path(_pImpl->get());
+		_file = _path;
+		return *this;
+	}
+
+	MyType& operator = (const std::string& path)
+	{
+		if (_pImpl)
+			_pImpl->release();
+		_pImpl = new ImplType(path);
+		_path = Path(_pImpl->get());
+		_file = _path;
+		return *this;
+	}
+
+	MyType& operator ++ ()
+	{
+		if (_pImpl)
+		{
+			_path = Path(_pImpl->next());
+			_file = _path;
+		}
+		return *this;
+	}
+
+	const File& operator * () const
+	{
+		return _file;
+	}
+
+	File& operator *()
+	{
+		return _file;
+	}
+
+	const File* operator -> () const
+	{
+		return &_file;
+	}
+
+	File* operator -> ()
+	{
+		return &_file;
+	}
+
+	template<class T1, class T2>
+	friend inline bool operator ==(const RecursiveDirectoryIterator<T1>& a, const RecursiveDirectoryIterator<T2>& b);
+	template<class T1, class T2>
+	friend inline bool operator !=(const RecursiveDirectoryIterator<T1>& a, const RecursiveDirectoryIterator<T2>& b);
+
+private:
+	typedef RecursiveDirectoryIteratorImpl<TTravStr> ImplType;
+
+	ImplType* _pImpl;
+	Path _path;
+	File _file;
+};
+
+
+//
+// friend comparsion operators
+//
+template<class T1, class T2>
+inline bool operator ==(const RecursiveDirectoryIterator<T1>& a, const RecursiveDirectoryIterator<T2>& b)
+{
+	return a.path().toString() == b.path().toString();;
+}
+
+template<class T1, class T2>
+inline bool operator !=(const RecursiveDirectoryIterator<T1>& a, const RecursiveDirectoryIterator<T2>& b)
+{
+	return a.path().toString() != b.path().toString();;
+}
+
+
+//
+// typedefs
+//
+typedef RecursiveDirectoryIterator<ChildrenFirstTraverse> SimpleRecursiveDirectoryIterator;
+typedef RecursiveDirectoryIterator<SiblingsFirstTraverse> SiblingsFirstRecursiveDirectoryIterator;
+
+
+} // namespace Poco
+
+
+#endif // Foundation_RecursiveDirectoryIterator_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/RecursiveDirectoryIteratorImpl.h b/base/poco/Foundation/include/Poco/RecursiveDirectoryIteratorImpl.h
new file mode 100644
index 00000000000..fb2d4670490
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/RecursiveDirectoryIteratorImpl.h
@@ -0,0 +1,111 @@
+//
+// RecursiveDirectoryIteratorImpl.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  RecursiveDirectoryIterator
+//
+// Definition of the RecursiveDirectoryIteratorImpl class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_RecursiveDirectoryIteratorImpl_INCLUDED
+#define Foundation_RecursiveDirectoryIteratorImpl_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/DirectoryIteratorStrategy.h"
+#include <stack>
+#include <functional>
+
+
+namespace Poco {
+
+
+class ChildrenFirstTraverse;
+class SiblingsFirstTraverse;
+
+
+template<class TTraverseStrategy = ChildrenFirstTraverse>
+class RecursiveDirectoryIteratorImpl
+{
+public:
+	enum
+	{
+		D_INFINITE = 0 /// Special value for infinite traverse depth.
+	};
+
+	RecursiveDirectoryIteratorImpl(const std::string& path, UInt16 maxDepth = D_INFINITE)
+		: _maxDepth(maxDepth), _traverseStrategy(std::ptr_fun(depthFun), _maxDepth), _isFinished(false), _rc(1)
+	{
+		_itStack.push(DirectoryIterator(path));
+		_current = _itStack.top()->path();
+	}
+
+	~RecursiveDirectoryIteratorImpl()
+	{
+	}
+
+	inline void duplicate()
+	{
+		++_rc;
+	}
+
+	inline void release()
+	{
+		if (--_rc == 0)
+			delete this;
+	}
+
+	inline UInt16 depth() const
+	{
+		return depthFun(_itStack);
+	}
+
+	inline UInt16 maxDepth() const
+	{
+		return _maxDepth;
+	}
+
+	inline const std::string& get() const
+	{
+		return _current;
+	}
+	const std::string& next()
+	{
+		if (_isFinished)
+			return _current;
+
+		_current = _traverseStrategy.next(&_itStack, &_isFinished);
+
+		return _current;
+	}
+
+private:
+	typedef std::stack<DirectoryIterator> Stack;
+
+	static UInt16 depthFun(const Stack& stack)
+		/// Function which implements the logic of determining
+		/// recursion depth.
+	{
+		return static_cast<Poco::UInt16>(stack.size());
+	}
+
+	UInt16 _maxDepth;
+	TTraverseStrategy _traverseStrategy;
+	bool _isFinished;
+	Stack _itStack;
+	std::string _current;
+	int _rc;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_RecursiveDirectoryIteratorImpl_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/RefCountedObject.h b/base/poco/Foundation/include/Poco/RefCountedObject.h
new file mode 100644
index 00000000000..083cdfb2ef1
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/RefCountedObject.h
@@ -0,0 +1,94 @@
+//
+// RefCountedObject.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  RefCountedObject
+//
+// Definition of the RefCountedObject class.
+//
+// Copyright (c) 2004-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_RefCountedObject_INCLUDED
+#define Foundation_RefCountedObject_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/AtomicCounter.h"
+
+
+namespace Poco {
+
+
+class Foundation_API RefCountedObject
+	/// A base class for objects that employ
+	/// reference counting based garbage collection.
+	///
+	/// Reference-counted objects inhibit construction
+	/// by copying and assignment.
+{
+public:
+	RefCountedObject();
+		/// Creates the RefCountedObject.
+		/// The initial reference count is one.
+
+	void duplicate() const;
+		/// Increments the object's reference count.
+		
+	void release() const throw();
+		/// Decrements the object's reference count
+		/// and deletes the object if the count
+		/// reaches zero.
+		
+	int referenceCount() const;
+		/// Returns the reference count.
+
+protected:
+	virtual ~RefCountedObject();
+		/// Destroys the RefCountedObject.
+
+private:
+	RefCountedObject(const RefCountedObject&);
+	RefCountedObject& operator = (const RefCountedObject&);
+
+	mutable AtomicCounter _counter;
+};
+
+
+//
+// inlines
+//
+inline int RefCountedObject::referenceCount() const
+{
+	return _counter.value();
+}
+
+
+inline void RefCountedObject::duplicate() const
+{
+	++_counter;
+}
+
+
+inline void RefCountedObject::release() const throw()
+{
+	try
+	{
+		if (--_counter == 0) delete this;
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_RefCountedObject_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/RegularExpression.h b/base/poco/Foundation/include/Poco/RegularExpression.h
new file mode 100644
index 00000000000..638b99e11b1
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/RegularExpression.h
@@ -0,0 +1,247 @@
+//
+// RegularExpression.h
+//
+// Library: Foundation
+// Package: RegExp
+// Module:  RegularExpression
+//
+// Definitions of class RegularExpression.
+//
+// A wrapper class for Philip Hazel's PCRE - Perl Compatible Regular Expressions
+// library (http://www.pcre.org).
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_RegularExpression_INCLUDED
+#define Foundation_RegularExpression_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <vector>
+
+
+namespace Poco {
+
+
+class Foundation_API RegularExpression
+	/// A class for working with regular expressions.
+	/// Implemented using PCRE, the Perl Compatible
+	/// Regular Expressions library by Philip Hazel
+	/// (see http://www.pcre.org).
+{
+public:
+	enum Options // These must match the corresponding options in pcre.h!
+		/// Some of the following options can only be passed to the constructor;
+		/// some can be passed only to matching functions, and some can be used
+		/// everywhere.
+		/// 
+		///   * Options marked [ctor] can be passed to the constructor.
+		///   * Options marked [match] can be passed to match, extract, split and subst.
+		///   * Options marked [subst] can be passed to subst.
+		///
+		/// See the PCRE documentation for more information.
+	{
+		RE_CASELESS        = 0x00000001, /// case insensitive matching (/i) [ctor]
+		RE_MULTILINE       = 0x00000002, /// enable multi-line mode; affects ^ and $ (/m) [ctor]
+		RE_DOTALL          = 0x00000004, /// dot matches all characters, including newline (/s) [ctor]
+		RE_EXTENDED        = 0x00000008, /// totally ignore whitespace (/x) [ctor]
+		RE_ANCHORED        = 0x00000010, /// treat pattern as if it starts with a ^ [ctor, match]
+		RE_DOLLAR_ENDONLY  = 0x00000020, /// dollar matches end-of-string only, not last newline in string [ctor]
+		RE_EXTRA           = 0x00000040, /// enable optional PCRE functionality [ctor]
+		RE_NOTBOL          = 0x00000080, /// circumflex does not match beginning of string [match]
+		RE_NOTEOL          = 0x00000100, /// $ does not match end of string [match]
+		RE_UNGREEDY        = 0x00000200, /// make quantifiers ungreedy [ctor]
+		RE_NOTEMPTY        = 0x00000400, /// empty string never matches [match]
+		RE_UTF8            = 0x00000800, /// assume pattern and subject is UTF-8 encoded [ctor]
+		RE_NO_AUTO_CAPTURE = 0x00001000, /// disable numbered capturing parentheses [ctor, match]
+		RE_NO_UTF8_CHECK   = 0x00002000, /// do not check validity of UTF-8 code sequences [match]
+		RE_FIRSTLINE       = 0x00040000, /// an  unanchored  pattern  is  required  to  match
+		                                 /// before  or  at  the  first  newline  in  the subject string, 
+		                                 /// though the matched text may continue over the newline [ctor]
+		RE_DUPNAMES        = 0x00080000, /// names used to identify capturing  subpatterns  need not be unique [ctor]
+		RE_NEWLINE_CR      = 0x00100000, /// assume newline is CR ('\r'), the default [ctor] 
+		RE_NEWLINE_LF      = 0x00200000, /// assume newline is LF ('\n') [ctor]
+		RE_NEWLINE_CRLF    = 0x00300000, /// assume newline is CRLF ("\r\n") [ctor]
+		RE_NEWLINE_ANY     = 0x00400000, /// assume newline is any valid Unicode newline character [ctor]
+		RE_NEWLINE_ANYCRLF = 0x00500000, /// assume newline is any of CR, LF, CRLF [ctor]
+		RE_GLOBAL          = 0x10000000, /// replace all occurences (/g) [subst]
+		RE_NO_VARS         = 0x20000000  /// treat dollar in replacement string as ordinary character [subst]
+	};
+	
+	struct Match
+	{
+		std::string::size_type offset; /// zero based offset (std::string::npos if subexpr does not match)
+		std::string::size_type length; /// length of substring
+	};
+	typedef std::vector<Match> MatchVec;
+	
+	RegularExpression(const std::string& pattern, int options = 0, bool study = true);
+		/// Creates a regular expression and parses the given pattern.
+		/// If study is true, the pattern is analyzed and optimized. This
+		/// is mainly useful if the pattern is used more than once.
+		/// For a description of the options, please see the PCRE documentation.
+		/// Throws a RegularExpressionException if the patter cannot be compiled.
+		
+	~RegularExpression();
+		/// Destroys the regular expression.
+
+	int match(const std::string& subject, Match& mtch, int options = 0) const;
+		/// Matches the given subject string against the pattern. Returns the position
+		/// of the first captured substring in mtch.
+		/// If no part of the subject matches the pattern, mtch.offset is std::string::npos and
+		/// mtch.length is 0.
+		/// Throws a RegularExpressionException in case of an error.
+		/// Returns the number of matches.
+
+	int match(const std::string& subject, std::string::size_type offset, Match& mtch, int options = 0) const;
+		/// Matches the given subject string, starting at offset, against the pattern. 
+		/// Returns the position of the captured substring in mtch.
+		/// If no part of the subject matches the pattern, mtch.offset is std::string::npos and
+		/// mtch.length is 0.
+		/// Throws a RegularExpressionException in case of an error.
+		/// Returns the number of matches.
+
+	int match(const std::string& subject, std::string::size_type offset, MatchVec& matches, int options = 0) const;
+		/// Matches the given subject string against the pattern. 
+		/// The first entry in matches contains the position of the captured substring.
+		/// The following entries identify matching subpatterns. See the PCRE documentation
+		/// for a more detailed explanation.
+		/// If no part of the subject matches the pattern, matches is empty.
+		/// Throws a RegularExpressionException in case of an error.
+		/// Returns the number of matches.
+
+	bool match(const std::string& subject, std::string::size_type offset = 0) const;
+		/// Returns true if and only if the subject matches the regular expression.
+		///
+		/// Internally, this method sets the RE_ANCHORED and RE_NOTEMPTY options for
+		/// matching, which means that the empty string will never match and
+		/// the pattern is treated as if it starts with a ^.
+
+	bool match(const std::string& subject, std::string::size_type offset, int options) const;
+		/// Returns true if and only if the subject matches the regular expression.
+
+	bool operator == (const std::string& subject) const;
+		/// Returns true if and only if the subject matches the regular expression.
+		///
+		/// Internally, this method sets the RE_ANCHORED and RE_NOTEMPTY options for
+		/// matching, which means that the empty string will never match and
+		/// the pattern is treated as if it starts with a ^.
+
+	bool operator != (const std::string& subject) const;
+		/// Returns true if and only if the subject does not match the regular expression.
+		///
+		/// Internally, this method sets the RE_ANCHORED and RE_NOTEMPTY options for
+		/// matching, which means that the empty string will never match and
+		/// the pattern is treated as if it starts with a ^.
+
+	int extract(const std::string& subject, std::string& str, int options = 0) const;
+		/// Matches the given subject string against the pattern. 
+		/// Returns the captured string.
+		/// Throws a RegularExpressionException in case of an error.
+		/// Returns the number of matches.
+
+	int extract(const std::string& subject, std::string::size_type offset, std::string& str, int options = 0) const;
+		/// Matches the given subject string, starting at offset, against the pattern. 
+		/// Returns the captured string.
+		/// Throws a RegularExpressionException in case of an error.
+		/// Returns the number of matches.
+
+	int split(const std::string& subject, std::vector<std::string>& strings, int options = 0) const;
+		/// Matches the given subject string against the pattern. 
+		/// The first entry in captured is the captured substring.
+		/// The following entries contain substrings matching subpatterns. See the PCRE documentation
+		/// for a more detailed explanation.
+		/// If no part of the subject matches the pattern, captured is empty.
+		/// Throws a RegularExpressionException in case of an error.
+		/// Returns the number of matches.
+
+	int split(const std::string& subject, std::string::size_type offset, std::vector<std::string>& strings, int options = 0) const;
+		/// Matches the given subject string against the pattern. 
+		/// The first entry in captured is the captured substring.
+		/// The following entries contain substrings matching subpatterns. See the PCRE documentation
+		/// for a more detailed explanation.
+		/// If no part of the subject matches the pattern, captured is empty.
+		/// Throws a RegularExpressionException in case of an error.
+		/// Returns the number of matches.
+	
+	int subst(std::string& subject, const std::string& replacement, int options = 0) const;
+		/// Substitute in subject all matches of the pattern with replacement.
+		/// If RE_GLOBAL is specified as option, all matches are replaced. Otherwise,
+		/// only the first match is replaced.
+		/// Occurrences of $<n> (for example, $1, $2, ...) in replacement are replaced
+		/// with the corresponding captured string. $0 is the original subject string.
+		/// Returns the number of replaced occurrences.
+
+	int subst(std::string& subject, std::string::size_type offset, const std::string& replacement, int options = 0) const;
+		/// Substitute in subject all matches of the pattern with replacement,
+		/// starting at offset.
+		/// If RE_GLOBAL is specified as option, all matches are replaced. Otherwise,
+		/// only the first match is replaced.
+		/// Unless RE_NO_VARS is specified, occurrences of $<n> (for example, $0, $1, $2, ... $9)
+		/// in replacement are replaced with the corresponding captured string. 
+		/// $0 is the captured substring. $1 ... $n are the substrings matching the subpatterns.
+		/// Returns the number of replaced occurrences.
+
+	static bool match(const std::string& subject, const std::string& pattern, int options = 0);
+		/// Matches the given subject string against the regular expression given in pattern,
+		/// using the given options.
+
+protected:
+	std::string::size_type substOne(std::string& subject, std::string::size_type offset, const std::string& replacement, int options) const;
+
+private:
+	// Note: to avoid a dependency on the pcre.h header the following are 
+	// declared as void* and casted to the correct type in the implementation file.
+	void* _pcre;  // Actual type is pcre*
+	void* _extra; // Actual type is struct pcre_extra*
+	
+	static const int OVEC_SIZE;
+	
+	RegularExpression();
+	RegularExpression(const RegularExpression&);
+	RegularExpression& operator = (const RegularExpression&);
+};
+
+
+//
+// inlines
+//
+inline int RegularExpression::match(const std::string& subject, Match& mtch, int options) const
+{
+	return match(subject, 0, mtch, options);
+}
+
+
+inline int RegularExpression::split(const std::string& subject, std::vector<std::string>& strings, int options) const
+{
+	return split(subject, 0, strings, options);
+}
+
+
+inline int RegularExpression::subst(std::string& subject, const std::string& replacement, int options) const
+{
+	return subst(subject, 0, replacement, options);
+}
+
+
+inline bool RegularExpression::operator == (const std::string& subject) const
+{
+	return match(subject);
+}
+
+
+inline bool RegularExpression::operator != (const std::string& subject) const
+{
+	return !match(subject);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_RegularExpression_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/RotateStrategy.h b/base/poco/Foundation/include/Poco/RotateStrategy.h
new file mode 100644
index 00000000000..82c331f1f6f
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/RotateStrategy.h
@@ -0,0 +1,165 @@
+//
+// RotateStrategy.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  FileChannel
+//
+// Definition of the RotateStrategy class and subclasses.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_RotateStrategy_INCLUDED
+#define Foundation_RotateStrategy_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Timespan.h"
+#include "Poco/Timestamp.h"
+#include "Poco/Exception.h"
+#include "Poco/LogFile.h"
+#include "Poco/StringTokenizer.h"
+#include "Poco/DateTimeParser.h"
+#include "Poco/NumberParser.h"
+
+
+namespace Poco {
+
+
+class Foundation_API RotateStrategy
+	/// The RotateStrategy is used by LogFile to determine when
+	/// a file must be rotated.
+{
+public:
+	RotateStrategy();
+	virtual ~RotateStrategy();
+
+	virtual bool mustRotate(LogFile* pFile) = 0;
+		/// Returns true if the given log file must
+		/// be rotated, false otherwise.
+		
+private:
+	RotateStrategy(const RotateStrategy&);
+	RotateStrategy& operator = (const RotateStrategy&);
+};
+
+
+template <class DT>
+class RotateAtTimeStrategy: public RotateStrategy
+	/// The file is rotated at specified [day,][hour]:minute
+{
+public:
+	RotateAtTimeStrategy(const std::string& rtime):
+		_day(-1), 
+		_hour(-1), 
+		_minute(0)
+	{
+		if (rtime.empty()) 
+			throw InvalidArgumentException("Rotation time must be specified.");
+
+		if ((rtime.find(',') != rtime.npos) && (rtime.find(':') == rtime.npos)) 
+			throw InvalidArgumentException("Invalid rotation time specified.");
+
+		StringTokenizer timestr(rtime, ",:", StringTokenizer::TOK_TRIM | StringTokenizer::TOK_IGNORE_EMPTY);
+		int index = 0;
+
+		switch (timestr.count())
+		{
+		case 3: // day,hh:mm
+			{
+				std::string::const_iterator it = timestr[index].begin();
+				_day = DateTimeParser::parseDayOfWeek(it, timestr[index].end());
+				++index;
+			}
+		case 2: // hh:mm
+			_hour = NumberParser::parse(timestr[index]);
+			++index;
+		case 1: // mm
+			_minute = NumberParser::parse(timestr[index]);
+			break;
+		default:
+			throw InvalidArgumentException("Invalid rotation time specified.");
+		}
+		getNextRollover();
+	}
+	
+	~RotateAtTimeStrategy()
+	{
+	}
+	
+	bool mustRotate(LogFile* /*pFile*/)
+	{
+		if (DT() >= _threshold)
+		{
+			getNextRollover();
+			return true;
+		}
+		return false;
+	}
+
+private:
+	void getNextRollover()
+	{
+		Timespan tsp(0, 0, 1, 0, 1000); // 0,00:01:00.001
+		do
+		{
+			_threshold += tsp;
+		}
+		while (!(_threshold.minute() == _minute &&
+		        (-1 == _hour || _threshold.hour() == _hour) && 
+		        (-1 == _day  || _threshold.dayOfWeek() == _day)));
+		// round to :00.0 seconds
+		_threshold.assign(_threshold.year(), _threshold.month(), _threshold.day(), _threshold.hour(), _threshold.minute());
+	}
+
+	DT  _threshold;
+	int _day;
+	int _hour;
+	int _minute;
+};
+
+
+class Foundation_API RotateByIntervalStrategy: public RotateStrategy
+	/// The file is rotated when the log file 
+	/// exceeds a given age.
+	///
+	/// For this to work reliably across all platforms and file systems
+	/// (there are severe issues on most platforms finding out the real
+	/// creation date of a file), the creation date of the file is
+	/// written into the log file as the first entry.
+{
+public:
+	RotateByIntervalStrategy(const Timespan& span);
+	~RotateByIntervalStrategy();
+	bool mustRotate(LogFile* pFile);
+
+private:
+	Timespan _span;
+	Timestamp _lastRotate;
+	static const std::string ROTATE_TEXT;
+};
+
+
+class Foundation_API RotateBySizeStrategy: public RotateStrategy
+	/// The file is rotated when the log file
+	/// exceeds a given size.
+{
+public:
+	RotateBySizeStrategy(UInt64 size);
+	~RotateBySizeStrategy();
+	bool mustRotate(LogFile* pFile);
+
+private:
+	UInt64 _size;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_RotateStrategy_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Runnable.h b/base/poco/Foundation/include/Poco/Runnable.h
new file mode 100644
index 00000000000..c87a6281701
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Runnable.h
@@ -0,0 +1,45 @@
+//
+// Runnable.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Thread
+//
+// Definition of the Runnable class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Runnable_INCLUDED
+#define Foundation_Runnable_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Runnable
+	/// The Runnable interface with the run() method
+	/// must be implemented by classes that provide
+	/// an entry point for a thread.
+{
+public:	
+	Runnable();
+	virtual ~Runnable();
+	
+	virtual void run() = 0;
+		/// Do whatever the thread needs to do. Must
+		/// be overridden by subclasses.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Runnable_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/RunnableAdapter.h b/base/poco/Foundation/include/Poco/RunnableAdapter.h
new file mode 100644
index 00000000000..571871be989
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/RunnableAdapter.h
@@ -0,0 +1,78 @@
+//
+// RunnableAdapter.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Thread
+//
+// Definition of the RunnableAdapter template class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_RunnableAdapter_INCLUDED
+#define Foundation_RunnableAdapter_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Runnable.h"
+
+
+namespace Poco {
+
+
+template <class C>
+class RunnableAdapter: public Runnable
+	/// This adapter simplifies using ordinary methods as
+	/// targets for threads.
+	/// Usage:
+	///    RunnableAdapter<MyClass> ra(myObject, &MyObject::doSomething));
+	///    Thread thr;
+	///    thr.Start(ra);
+	///
+	/// For using a freestanding or static member function as a thread
+	/// target, please see the ThreadTarget class.
+{
+public:
+	typedef void (C::*Callback)();
+	
+	RunnableAdapter(C& object, Callback method): _pObject(&object), _method(method)
+	{
+	}
+	
+	RunnableAdapter(const RunnableAdapter& ra): _pObject(ra._pObject), _method(ra._method)
+	{
+	}
+
+	~RunnableAdapter()
+	{
+	}
+
+	RunnableAdapter& operator = (const RunnableAdapter& ra)
+	{
+		_pObject = ra._pObject;
+		_method  = ra._method;
+		return *this;
+	}
+
+	void run()
+	{
+		(_pObject->*_method)();
+	}
+	
+private:
+	RunnableAdapter();
+
+	C*       _pObject;
+	Callback _method;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_RunnableAdapter_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SHA1Engine.h b/base/poco/Foundation/include/Poco/SHA1Engine.h
new file mode 100644
index 00000000000..81c8a4d9ea2
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SHA1Engine.h
@@ -0,0 +1,81 @@
+//
+// SHA1Engine.h
+//
+// Library: Foundation
+// Package: Crypt
+// Module:  SHA1Engine
+//
+// Definition of class SHA1Engine.
+//
+// Secure Hash Standard SHA-1 algorithm
+// (FIPS 180-1, see http://www.itl.nist.gov/fipspubs/fip180-1.htm)
+//
+// Based on the public domain implementation by Peter C. Gutmann
+// on 2 Sep 1992, modified by Carl Ellison to be SHA-1.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SHA1Engine_INCLUDED
+#define Foundation_SHA1Engine_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/DigestEngine.h"
+
+
+namespace Poco {
+
+
+class Foundation_API SHA1Engine: public DigestEngine
+	/// This class implementes the SHA-1 message digest algorithm.
+	/// (FIPS 180-1, see http://www.itl.nist.gov/fipspubs/fip180-1.htm)
+{
+public:
+	enum
+	{
+		BLOCK_SIZE  = 64,
+		DIGEST_SIZE = 20
+	};
+
+	SHA1Engine();
+	~SHA1Engine();
+		
+	std::size_t digestLength() const;
+	void reset();
+	const DigestEngine::Digest& digest();
+
+protected:
+	void updateImpl(const void* data, std::size_t length);
+
+private:
+	void transform();
+	static void byteReverse(UInt32* buffer, int byteCount);
+
+	typedef UInt8 BYTE;
+
+	struct Context
+	{
+		UInt32 digest[5]; // Message digest
+		UInt32 countLo;   // 64-bit bit count
+		UInt32 countHi;
+		UInt32 data[16];  // SHA data buffer
+		UInt32 slop;      // # of bytes saved in data[]
+	};
+
+	Context _context;
+	DigestEngine::Digest _digest;
+
+	SHA1Engine(const SHA1Engine&);
+	SHA1Engine& operator = (const SHA1Engine&);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_SHA1Engine_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ScopedLock.h b/base/poco/Foundation/include/Poco/ScopedLock.h
new file mode 100644
index 00000000000..8415c3808cb
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ScopedLock.h
@@ -0,0 +1,121 @@
+//
+// ScopedLock.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Mutex
+//
+// Definition of the ScopedLock template class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ScopedLock_INCLUDED
+#define Foundation_ScopedLock_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+template <class M>
+class ScopedLock
+	/// A class that simplifies thread synchronization
+	/// with a mutex.
+	/// The constructor accepts a Mutex (and optionally
+	/// a timeout value in milliseconds) and locks it.
+	/// The destructor unlocks the mutex.
+{
+public:
+	explicit ScopedLock(M& mutex): _mutex(mutex)
+	{
+		_mutex.lock();
+	}
+	
+	ScopedLock(M& mutex, long milliseconds): _mutex(mutex)
+	{
+		_mutex.lock(milliseconds);
+	}
+	
+	~ScopedLock()
+	{
+		try
+		{
+			_mutex.unlock();
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	}
+
+private:
+	M& _mutex;
+
+	ScopedLock();
+	ScopedLock(const ScopedLock&);
+	ScopedLock& operator = (const ScopedLock&);
+};
+
+
+template <class M>
+class ScopedLockWithUnlock
+	/// A class that simplifies thread synchronization
+	/// with a mutex.
+	/// The constructor accepts a Mutex (and optionally
+	/// a timeout value in milliseconds) and locks it.
+	/// The destructor unlocks the mutex.
+	/// The unlock() member function allows for manual
+	/// unlocking of the mutex.
+{
+public:
+	explicit ScopedLockWithUnlock(M& mutex): _pMutex(&mutex)
+	{
+		_pMutex->lock();
+	}
+	
+	ScopedLockWithUnlock(M& mutex, long milliseconds): _pMutex(&mutex)
+	{
+		_pMutex->lock(milliseconds);
+	}
+	
+	~ScopedLockWithUnlock()
+	{
+		try
+		{
+			unlock();
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	}
+	
+	void unlock()
+	{
+		if (_pMutex)
+		{
+			_pMutex->unlock();
+			_pMutex = 0;
+		}
+	}
+
+private:
+	M* _pMutex;
+
+	ScopedLockWithUnlock();
+	ScopedLockWithUnlock(const ScopedLockWithUnlock&);
+	ScopedLockWithUnlock& operator = (const ScopedLockWithUnlock&);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ScopedLock_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ScopedUnlock.h b/base/poco/Foundation/include/Poco/ScopedUnlock.h
new file mode 100644
index 00000000000..a62fbb33b01
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ScopedUnlock.h
@@ -0,0 +1,64 @@
+//
+// ScopedUnlock.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Mutex
+//
+// Definition of the ScopedUnlock template class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ScopedUnlock_INCLUDED
+#define Foundation_ScopedUnlock_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+template <class M>
+class ScopedUnlock
+	/// A class that simplifies thread synchronization
+	/// with a mutex.
+	/// The constructor accepts a Mutex and unlocks it.
+	/// The destructor locks the mutex.
+{
+public:
+	inline ScopedUnlock(M& mutex, bool unlockNow = true): _mutex(mutex)
+	{
+		if (unlockNow)
+			_mutex.unlock();
+	}
+	inline ~ScopedUnlock()
+	{
+		try
+		{
+			_mutex.lock();
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	}
+
+private:
+	M& _mutex;
+
+	ScopedUnlock();
+	ScopedUnlock(const ScopedUnlock&);
+	ScopedUnlock& operator = (const ScopedUnlock&);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ScopedUnlock_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Semaphore.h b/base/poco/Foundation/include/Poco/Semaphore.h
new file mode 100644
index 00000000000..7c10c4afe4c
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Semaphore.h
@@ -0,0 +1,137 @@
+//
+// Semaphore.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Semaphore
+//
+// Definition of the Semaphore class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Semaphore_INCLUDED
+#define Foundation_Semaphore_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#include "Poco/Semaphore_WIN32.h"
+#elif defined(POCO_VXWORKS)
+#include "Poco/Semaphore_VX.h"
+#else
+#include "Poco/Semaphore_POSIX.h"
+#endif
+
+
+namespace Poco {
+
+
+class Foundation_API Semaphore: private SemaphoreImpl
+	/// A Semaphore is a synchronization object with the following 
+	/// characteristics:
+	/// A semaphore has a value that is constrained to be a non-negative
+	/// integer and two atomic operations. The allowable operations are V 
+	/// (here called set()) and P (here called wait()). A V (set()) operation 
+	/// increases the value of the semaphore by one. 
+	/// A P (wait()) operation decreases the value of the semaphore by one, 
+	/// provided that can be done without violating the constraint that the 
+	/// value be non-negative. A P (wait()) operation that is initiated when 
+	/// the value of the semaphore is 0 suspends the calling thread. 
+	/// The calling thread may continue when the value becomes positive again.
+{
+public:
+	Semaphore(int n);
+	Semaphore(int n, int max);
+		/// Creates the semaphore. The current value
+		/// of the semaphore is given in n. The
+		/// maximum value of the semaphore is given
+		/// in max.
+		/// If only n is given, it must be greater than
+		/// zero.
+		/// If both n and max are given, max must be
+		/// greater than zero, n must be greater than
+		/// or equal to zero and less than or equal
+		/// to max.
+		
+	~Semaphore();
+		/// Destroys the semaphore.
+
+	void set();
+		/// Increments the semaphore's value by one and
+		/// thus signals the semaphore. Another thread
+		/// waiting for the semaphore will be able
+		/// to continue.
+
+	void wait();
+		/// Waits for the semaphore to become signalled.
+		/// To become signalled, a semaphore's value must
+		/// be greater than zero. 
+		/// Decrements the semaphore's value by one.
+
+	void wait(long milliseconds);
+		/// Waits for the semaphore to become signalled.
+		/// To become signalled, a semaphore's value must
+		/// be greater than zero.
+		/// Throws a TimeoutException if the semaphore
+		/// does not become signalled within the specified
+		/// time interval.
+		/// Decrements the semaphore's value by one
+		/// if successful.
+
+	bool tryWait(long milliseconds);
+		/// Waits for the semaphore to become signalled.
+		/// To become signalled, a semaphore's value must
+		/// be greater than zero.
+		/// Returns true if the semaphore
+		/// became signalled within the specified
+		/// time interval, false otherwise.
+		/// Decrements the semaphore's value by one
+		/// if successful.
+	
+private:
+	Semaphore();
+	Semaphore(const Semaphore&);
+	Semaphore& operator = (const Semaphore&);
+};
+
+
+//
+// inlines
+//
+inline void Semaphore::set()
+{
+	setImpl();
+}
+
+
+inline void Semaphore::wait()
+{
+	waitImpl();
+}
+
+
+inline void Semaphore::wait(long milliseconds)
+{
+	if (!waitImpl(milliseconds))
+		throw TimeoutException();
+}
+
+
+inline bool Semaphore::tryWait(long milliseconds)
+{
+	return waitImpl(milliseconds);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Semaphore_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Semaphore_POSIX.h b/base/poco/Foundation/include/Poco/Semaphore_POSIX.h
new file mode 100644
index 00000000000..3fc0897faf6
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Semaphore_POSIX.h
@@ -0,0 +1,75 @@
+//
+// Semaphore_POSIX.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Semaphore
+//
+// Definition of the SemaphoreImpl class for POSIX Threads.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Semaphore_POSIX_INCLUDED
+#define Foundation_Semaphore_POSIX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include <pthread.h>
+#include <errno.h>
+
+
+namespace Poco {
+
+
+class Foundation_API SemaphoreImpl
+{
+protected:
+	SemaphoreImpl(int n, int max);		
+	~SemaphoreImpl();
+	void setImpl();
+	void waitImpl();
+	bool waitImpl(long milliseconds);
+	
+private:
+	volatile int    _n;
+	int             _max;
+	pthread_mutex_t _mutex;
+	pthread_cond_t  _cond;
+};
+
+
+//
+// inlines
+//
+inline void SemaphoreImpl::setImpl()
+{
+	if (pthread_mutex_lock(&_mutex))	
+		throw SystemException("cannot signal semaphore (lock)");
+	if (_n < _max)
+	{
+		++_n;
+	}
+	else
+	{
+		pthread_mutex_unlock(&_mutex);
+		throw SystemException("cannot signal semaphore: count would exceed maximum");
+	}	
+	if (pthread_cond_signal(&_cond))
+	{
+		pthread_mutex_unlock(&_mutex);
+		throw SystemException("cannot signal semaphore");
+	}
+	pthread_mutex_unlock(&_mutex);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Semaphore_POSIX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Semaphore_VX.h b/base/poco/Foundation/include/Poco/Semaphore_VX.h
new file mode 100644
index 00000000000..181afe2f5cb
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Semaphore_VX.h
@@ -0,0 +1,56 @@
+//
+// Semaphore_VX.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Semaphore
+//
+// Definition of the SemaphoreImpl class for VxWorks.
+//
+// Copyright (c) 2004-20011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Semaphore_VX_INCLUDED
+#define Foundation_Semaphore_VX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include <semLib.h>
+
+
+namespace Poco {
+
+
+class Foundation_API SemaphoreImpl
+{
+protected:
+	SemaphoreImpl(int n, int max);		
+	~SemaphoreImpl();
+	void setImpl();
+	void waitImpl();
+	bool waitImpl(long milliseconds);
+	
+private:
+	SEM_ID _sem;
+};
+
+
+//
+// inlines
+//
+inline void SemaphoreImpl::setImpl()
+{
+	if (semGive(_sem) != OK)
+		throw SystemException("cannot signal semaphore");
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Semaphore_VX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Semaphore_WIN32.h b/base/poco/Foundation/include/Poco/Semaphore_WIN32.h
new file mode 100644
index 00000000000..ac9c31356bb
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Semaphore_WIN32.h
@@ -0,0 +1,58 @@
+//
+// Semaphore_WIN32.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Semaphore
+//
+// Definition of the SemaphoreImpl class for WIN32.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Semaphore_WIN32_INCLUDED
+#define Foundation_Semaphore_WIN32_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API SemaphoreImpl
+{
+protected:
+	SemaphoreImpl(int n, int max);		
+	~SemaphoreImpl();
+	void setImpl();
+	void waitImpl();
+	bool waitImpl(long milliseconds);
+	
+private:
+	HANDLE _sema;
+};
+
+
+//
+// inlines
+//
+inline void SemaphoreImpl::setImpl()
+{
+	if (!ReleaseSemaphore(_sema, 1, NULL))
+	{
+		throw SystemException("cannot signal semaphore");
+	}
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Semaphore_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SharedLibrary.h b/base/poco/Foundation/include/Poco/SharedLibrary.h
new file mode 100644
index 00000000000..52292c741e9
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SharedLibrary.h
@@ -0,0 +1,144 @@
+//
+// SharedLibrary.h
+//
+// Library: Foundation
+// Package: SharedLibrary
+// Module:  SharedLibrary
+//
+// Definition of the SharedLibrary class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SharedLibrary_INCLUDED
+#define Foundation_SharedLibrary_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+#if defined(hpux) || defined(_hpux)
+#include "Poco/SharedLibrary_HPUX.h"
+#elif defined(POCO_VXWORKS)
+#include "Poco/SharedLibrary_VX.h"
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include "Poco/SharedLibrary_UNIX.h"
+#elif defined(POCO_OS_FAMILY_WINDOWS) && defined(POCO_WIN32_UTF8)
+#include "Poco/SharedLibrary_WIN32U.h"
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "Poco/SharedLibrary_WIN32.h"
+#endif
+
+
+namespace Poco {
+
+
+class Foundation_API SharedLibrary: private SharedLibraryImpl
+	/// The SharedLibrary class dynamically
+	/// loads shared libraries at run-time.
+{
+public:
+	enum Flags
+	{
+		SHLIB_GLOBAL = 1,
+			/// On platforms that use dlopen(), use RTLD_GLOBAL. This is the default
+			/// if no flags are given.
+			///
+			/// This flag is ignored on platforms that do not use dlopen().
+
+		SHLIB_LOCAL  = 2
+			/// On platforms that use dlopen(), use RTLD_LOCAL instead of RTLD_GLOBAL.
+			///
+			/// Note that if this flag is specified, RTTI (including dynamic_cast and throw) will
+			/// not work for types defined in the shared library with GCC and possibly other
+			/// compilers as well. See http://gcc.gnu.org/faq.html#dso for more information.
+			///
+			/// This flag is ignored on platforms that do not use dlopen().
+	};
+
+	SharedLibrary();
+		/// Creates a SharedLibrary object.
+
+	SharedLibrary(const std::string& path);
+		/// Creates a SharedLibrary object and loads a library
+		/// from the given path.
+
+	SharedLibrary(const std::string& path, int flags);
+		/// Creates a SharedLibrary object and loads a library
+		/// from the given path, using the given flags.
+		/// See the Flags enumeration for valid values.
+
+	virtual ~SharedLibrary();
+		/// Destroys the SharedLibrary. The actual library
+		/// remains loaded.
+
+	void load(const std::string& path);
+		/// Loads a shared library from the given path.
+		/// Throws a LibraryAlreadyLoadedException if
+		/// a library has already been loaded.
+		/// Throws a LibraryLoadException if the library
+		/// cannot be loaded.
+
+	void load(const std::string& path, int flags);
+		/// Loads a shared library from the given path,
+		/// using the given flags. See the Flags enumeration
+		/// for valid values.
+		/// Throws a LibraryAlreadyLoadedException if
+		/// a library has already been loaded.
+		/// Throws a LibraryLoadException if the library
+		/// cannot be loaded.
+
+	void unload();
+		/// Unloads a shared library.
+
+	bool isLoaded() const;
+		/// Returns true iff a library has been loaded.
+
+	bool hasSymbol(const std::string& name);
+		/// Returns true iff the loaded library contains
+		/// a symbol with the given name.
+
+	void* getSymbol(const std::string& name);
+		/// Returns the address of the symbol with
+		/// the given name. For functions, this
+		/// is the entry point of the function.
+		/// Throws a NotFoundException if the symbol
+		/// does not exist.
+
+	const std::string& getPath() const;
+		/// Returns the path of the library, as
+		/// specified in a call to load() or the
+		/// constructor.
+
+	static std::string suffix();
+		/// Returns the platform-specific filename suffix
+		/// for shared libraries (including the period).
+		/// In debug mode, the suffix also includes a
+		/// "d" to specify the debug version of a library
+		/// (e.g., "d.so", "d.dll") unless the library has
+		/// been compiled with -DPOCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX.
+
+	static bool setSearchPath(const std::string& path);
+		/// Adds the given path to the list of paths shared libraries
+		/// are searched in.
+		///
+		/// Returns true if the path was set, otherwise false.
+		///
+		/// Currently only supported on Windows, where it calls
+		/// SetDllDirectory(). On all other platforms, does not
+		/// do anything and returns false.
+
+private:
+	SharedLibrary(const SharedLibrary&);
+	SharedLibrary& operator = (const SharedLibrary&);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_SharedLibrary_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SharedLibrary_HPUX.h b/base/poco/Foundation/include/Poco/SharedLibrary_HPUX.h
new file mode 100644
index 00000000000..06a6f51bcf5
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SharedLibrary_HPUX.h
@@ -0,0 +1,52 @@
+//
+// SharedLibrary_HPUX.h
+//
+// Library: Foundation
+// Package: SharedLibrary
+// Module:  SharedLibrary
+//
+// Definition of the SharedLibraryImpl class for HP-UX.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SharedLibrary_HPUX_INCLUDED
+#define Foundation_SharedLibrary_HPUX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Mutex.h"
+#include <dl.h>
+
+
+namespace Poco {
+
+
+class Foundation_API SharedLibraryImpl
+{
+protected:
+	SharedLibraryImpl();
+	~SharedLibraryImpl();
+	void loadImpl(const std::string& path, int flags);
+	void unloadImpl();
+	bool isLoadedImpl() const;
+	void* findSymbolImpl(const std::string& name);
+	const std::string& getPathImpl() const;
+	static std::string suffixImpl();
+	static bool setSearchPathImpl(const std::string& path);
+
+private:
+	std::string _path;
+	shl_t _handle;
+	static FastMutex _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_SharedLibrary_HPUX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SharedLibrary_UNIX.h b/base/poco/Foundation/include/Poco/SharedLibrary_UNIX.h
new file mode 100644
index 00000000000..1f0c288ad50
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SharedLibrary_UNIX.h
@@ -0,0 +1,57 @@
+//
+// SharedLibrary_UNIX.h
+//
+// Library: Foundation
+// Package: SharedLibrary
+// Module:  SharedLibrary
+//
+// Definition of the SharedLibraryImpl class for UNIX (dlopen).
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SharedLibrary_UNIX_INCLUDED
+#define Foundation_SharedLibrary_UNIX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+
+
+class Foundation_API SharedLibraryImpl
+{
+protected:
+	enum Flags
+	{
+		SHLIB_GLOBAL_IMPL = 1,
+		SHLIB_LOCAL_IMPL  = 2
+	};
+
+	SharedLibraryImpl();
+	~SharedLibraryImpl();
+	void loadImpl(const std::string& path, int flags);
+	void unloadImpl();
+	bool isLoadedImpl() const;
+	void* findSymbolImpl(const std::string& name);
+	const std::string& getPathImpl() const;
+	static std::string suffixImpl();
+	static bool setSearchPathImpl(const std::string& path);
+
+private:
+	std::string _path;
+	void* _handle;
+	static FastMutex _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_SharedLibrary_UNIX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SharedLibrary_VX.h b/base/poco/Foundation/include/Poco/SharedLibrary_VX.h
new file mode 100644
index 00000000000..916edad47ee
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SharedLibrary_VX.h
@@ -0,0 +1,52 @@
+//
+// SharedLibrary_VX.h
+//
+// Library: Foundation
+// Package: SharedLibrary
+// Module:  SharedLibrary
+//
+// Definition of the SharedLibraryImpl class for VxWorks.
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SharedLibrary_VX_INCLUDED
+#define Foundation_SharedLibrary_VX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Mutex.h"
+#include <moduleLib.h>
+
+
+namespace Poco {
+
+
+class Foundation_API SharedLibraryImpl
+{
+protected:
+	SharedLibraryImpl();
+	~SharedLibraryImpl();
+	void loadImpl(const std::string& path, int flags);
+	void unloadImpl();
+	bool isLoadedImpl() const;
+	void* findSymbolImpl(const std::string& name);
+	const std::string& getPathImpl() const;
+	static std::string suffixImpl();
+	static bool setSearchPathImpl(const std::string& path);
+
+private:
+	std::string _path;
+	MODULE_ID _moduleId;
+	static FastMutex _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_SharedLibrary_VX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SharedLibrary_WIN32.h b/base/poco/Foundation/include/Poco/SharedLibrary_WIN32.h
new file mode 100644
index 00000000000..6b7fc29459c
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SharedLibrary_WIN32.h
@@ -0,0 +1,51 @@
+//
+// SharedLibrary_WIN32.h
+//
+// Library: Foundation
+// Package: SharedLibrary
+// Module:  SharedLibrary
+//
+// Definition of the SharedLibraryImpl class for Win32.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SharedLibrary_WIN32_INCLUDED
+#define Foundation_SharedLibrary_WIN32_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+
+
+class Foundation_API SharedLibraryImpl
+{
+protected:
+	SharedLibraryImpl();
+	~SharedLibraryImpl();
+	void loadImpl(const std::string& path, int flags);
+	void unloadImpl();
+	bool isLoadedImpl() const;
+	void* findSymbolImpl(const std::string& name);
+	const std::string& getPathImpl() const;
+	static std::string suffixImpl();
+	static bool setSearchPathImpl(const std::string& path);
+
+private:
+	std::string _path;
+	void* _handle;
+	static FastMutex _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_SharedLibrary_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SharedLibrary_WIN32U.h b/base/poco/Foundation/include/Poco/SharedLibrary_WIN32U.h
new file mode 100644
index 00000000000..3e51c9c95d1
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SharedLibrary_WIN32U.h
@@ -0,0 +1,51 @@
+//
+// SharedLibrary_WIN32U.h
+//
+// Library: Foundation
+// Package: SharedLibrary
+// Module:  SharedLibrary
+//
+// Definition of the SharedLibraryImpl class for Win32.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SharedLibrary_WIN32U_INCLUDED
+#define Foundation_SharedLibrary_WIN32U_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+
+
+class Foundation_API SharedLibraryImpl
+{
+protected:
+	SharedLibraryImpl();
+	~SharedLibraryImpl();
+	void loadImpl(const std::string& path, int flags);
+	void unloadImpl();
+	bool isLoadedImpl() const;
+	void* findSymbolImpl(const std::string& name);
+	const std::string& getPathImpl() const;
+	static std::string suffixImpl();
+	static bool setSearchPathImpl(const std::string& path);
+
+private:
+	std::string _path;
+	void* _handle;
+	static FastMutex _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_SharedLibrary_WIN32U_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SharedMemory.h b/base/poco/Foundation/include/Poco/SharedMemory.h
new file mode 100644
index 00000000000..233856787b9
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SharedMemory.h
@@ -0,0 +1,113 @@
+//
+// SharedMemory.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  SharedMemory
+//
+// Definition of the SharedMemory class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SharedMemory_INCLUDED
+#define Foundation_SharedMemory_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <algorithm>
+#include <cstddef>
+
+
+namespace Poco {
+
+
+class SharedMemoryImpl;
+class File;
+
+
+class Foundation_API SharedMemory
+	/// Create and manage a shared memory object.
+	///
+	/// A SharedMemory object has value semantics, but
+	/// is implemented using a handle/implementation idiom.
+	/// Therefore, multiple SharedMemory objects can share
+	/// a single, reference counted SharedMemoryImpl object.
+{
+public:
+	enum AccessMode
+	{
+		AM_READ = 0,
+		AM_WRITE
+	};
+
+	SharedMemory();
+		/// Default constructor creates an unmapped SharedMemory object. 
+		/// No clients can connect to an unmapped SharedMemory object.
+
+	SharedMemory(const std::string& name, std::size_t size, AccessMode mode, const void* addrHint = 0, bool server = true);
+		/// Creates or connects to a shared memory object with the given name.
+		///
+		/// For maximum portability, name should be a valid Unix filename and not
+		/// contain any slashes or backslashes.
+		///
+		/// An address hint can be passed to the system, specifying the desired
+		/// start address of the shared memory area. Whether the hint
+		/// is actually honored is, however, up to the system. Windows platform
+		/// will generally ignore the hint.
+		///
+		/// If server is set to true, the shared memory region will be unlinked
+		/// by calling shm_unlink() (on POSIX platforms) when the SharedMemory object is destroyed.
+		/// The server parameter is ignored on Windows platforms.
+
+	SharedMemory(const File& file, AccessMode mode, const void* addrHint = 0);
+		/// Maps the entire contents of file into a shared memory segment.
+		///
+		/// An address hint can be passed to the system, specifying the desired
+		/// start address of the shared memory area. Whether the hint
+		/// is actually honored is, however, up to the system. Windows platform
+		/// will generally ignore the hint.
+
+	SharedMemory(const SharedMemory& other);
+		/// Creates a SharedMemory object by copying another one.
+
+	~SharedMemory();
+		/// Destroys the SharedMemory.
+
+	SharedMemory& operator = (const SharedMemory& other);
+		/// Assigns another SharedMemory object.
+
+	void swap(SharedMemory& other);
+		/// Swaps the SharedMemory object with another one.
+
+	char* begin() const;
+		/// Returns the start address of the shared memory segment.
+		/// Will be NULL for illegal segments.
+
+	char* end() const;
+		/// Returns the one-past-end end address of the shared memory segment. 
+		/// Will be NULL for illegal segments.
+
+private:
+	SharedMemoryImpl* _pImpl;
+};
+
+
+//
+// inlines
+//
+inline void SharedMemory::swap(SharedMemory& other)
+{
+	using std::swap;
+	swap(_pImpl, other._pImpl);
+}
+
+
+} // namespace Poco::Poco
+
+
+#endif // Foundation_SharedMemory_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SharedMemory_DUMMY.h b/base/poco/Foundation/include/Poco/SharedMemory_DUMMY.h
new file mode 100644
index 00000000000..5a487a0f783
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SharedMemory_DUMMY.h
@@ -0,0 +1,88 @@
+//
+// SharedMemoryImpl.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  SharedMemoryImpl
+//
+// Definition of the SharedMemoryImpl class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SharedMemoryImpl_INCLUDED
+#define Foundation_SharedMemoryImpl_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/SharedMemory.h"
+#include "Poco/RefCountedObject.h"
+
+
+namespace Poco {
+
+
+class Foundation_API SharedMemoryImpl: public RefCountedObject
+	/// A dummy implementation of shared memory, for systems
+	/// that do not have shared memory support.
+{
+public:
+	SharedMemoryImpl(const std::string& id, std::size_t size, SharedMemory::AccessMode mode, const void* addr, bool server);
+		/// Creates or connects to a shared memory object with the given name.
+		///
+		/// For maximum portability, name should be a valid Unix filename and not
+		/// contain any slashes or backslashes.
+		///
+		/// An address hint can be passed to the system, specifying the desired
+		/// start address of the shared memory area. Whether the hint
+		/// is actually honored is, however, up to the system. Windows platform
+		/// will generally ignore the hint.
+
+	SharedMemoryImpl(const Poco::File& aFile, SharedMemory::AccessMode mode, const void* addr);
+		/// Maps the entire contents of file into a shared memory segment.
+		///
+		/// An address hint can be passed to the system, specifying the desired
+		/// start address of the shared memory area. Whether the hint
+		/// is actually honored is, however, up to the system. Windows platform
+		/// will generally ignore the hint.
+
+	char* begin() const;
+		/// Returns the start address of the shared memory segment.
+
+	char* end() const;
+		/// Returns the one-past-end end address of the shared memory segment. 
+
+protected:
+	~SharedMemoryImpl();
+		/// Destroys the SharedMemoryImpl.
+
+private:
+	SharedMemoryImpl();
+	SharedMemoryImpl(const SharedMemoryImpl&);
+	SharedMemoryImpl& operator = (const SharedMemoryImpl&);
+};
+
+
+//
+// inlines
+//
+inline char* SharedMemoryImpl::begin() const
+{
+	return 0;
+}
+
+
+inline char* SharedMemoryImpl::end() const
+{
+	return 0;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_SharedMemoryImpl_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SharedMemory_POSIX.h b/base/poco/Foundation/include/Poco/SharedMemory_POSIX.h
new file mode 100644
index 00000000000..4ba6ab5e80b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SharedMemory_POSIX.h
@@ -0,0 +1,107 @@
+//
+// SharedMemoryImpl.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  SharedMemoryImpl
+//
+// Definition of the SharedMemoryImpl class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SharedMemoryImpl_INCLUDED
+#define Foundation_SharedMemoryImpl_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/SharedMemory.h"
+#include "Poco/RefCountedObject.h"
+
+
+namespace Poco {
+
+
+class Foundation_API SharedMemoryImpl: public RefCountedObject
+	/// Shared memory implementation for POSIX platforms.
+{
+public:
+	SharedMemoryImpl(const std::string& name, std::size_t size, SharedMemory::AccessMode mode, const void* addrHint, bool server);
+		/// Creates or connects to a shared memory object with the given name.
+		///
+		/// For maximum portability, name should be a valid Unix filename and not
+		/// contain any slashes or backslashes.
+		///
+		/// An address hint can be passed to the system, specifying the desired
+		/// start address of the shared memory area. Whether the hint
+		/// is actually honored is, however, up to the system. Windows platform
+		/// will generally ignore the hint.
+		///
+		/// If server is set to false, the shared memory region will be unlinked
+		/// by calling shm_unlink when the SharedMemory object is destroyed.
+
+	SharedMemoryImpl(const Poco::File& file, SharedMemory::AccessMode mode, const void* addrHint);
+		/// Maps the entire contents of file into a shared memory segment.
+		///
+		/// An address hint can be passed to the system, specifying the desired
+		/// start address of the shared memory area. Whether the hint
+		/// is actually honored is, however, up to the system. Windows platform
+		/// will generally ignore the hint.
+
+	char* begin() const;
+		/// Returns the start address of the shared memory segment.
+
+	char* end() const;
+		/// Returns the one-past-end end address of the shared memory segment. 
+
+protected:
+	void map(const void* addrHint);
+		/// Maps the shared memory object.
+
+	void unmap();
+		/// Unmaps the shared memory object.
+
+	void close();
+		/// Releases the handle for the shared memory segment.
+
+	~SharedMemoryImpl();
+		/// Destroys the SharedMemoryImpl.
+
+private:
+	SharedMemoryImpl();
+	SharedMemoryImpl(const SharedMemoryImpl&);
+	SharedMemoryImpl& operator = (const SharedMemoryImpl&);
+
+	std::size_t _size;
+	int         _fd;
+	char*       _address;
+	SharedMemory::AccessMode _access;
+	std::string _name;
+	bool        _fileMapped;
+	bool        _server;
+};
+
+
+//
+// inlines
+//
+inline char* SharedMemoryImpl::begin() const
+{
+	return _address;
+}
+
+
+inline char* SharedMemoryImpl::end() const
+{
+	return _address + _size;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_SharedMemoryImpl_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SharedMemory_WIN32.h b/base/poco/Foundation/include/Poco/SharedMemory_WIN32.h
new file mode 100644
index 00000000000..bd48b6932a8
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SharedMemory_WIN32.h
@@ -0,0 +1,103 @@
+//
+// SharedMemoryImpl.h
+//
+// Library: Foundation
+// Package: Processes
+// Module:  SharedMemoryImpl
+//
+// Definition of the SharedMemoryImpl class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SharedMemoryImpl_INCLUDED
+#define Foundation_SharedMemoryImpl_INCLUDED
+
+
+#include "Poco/Poco.h"
+#include "Poco/SharedMemory.h"
+#include "Poco/RefCountedObject.h"
+
+
+namespace Poco {
+
+
+class Foundation_API SharedMemoryImpl: public RefCountedObject
+	/// Shared memory implementation for Windows platforms.
+{
+public:
+	SharedMemoryImpl(const std::string& name, std::size_t size, SharedMemory::AccessMode mode, const void* addrHint, bool server);
+		/// Creates or connects to a shared memory object with the given name.
+		///
+		/// For maximum portability, name should be a valid Unix filename and not
+		/// contain any slashes or backslashes.
+		///
+		/// An address hint can be passed to the system, specifying the desired
+		/// start address of the shared memory area. Whether the hint
+		/// is actually honored is, however, up to the system. Windows platform
+		/// will generally ignore the hint.
+
+	SharedMemoryImpl(const Poco::File& file, SharedMemory::AccessMode mode, const void* addrHint);
+		/// Maps the entire contents of file into a shared memory segment.
+		///
+		/// An address hint can be passed to the system, specifying the desired
+		/// start address of the shared memory area. Whether the hint
+		/// is actually honored is, however, up to the system. Windows platform
+		/// will generally ignore the hint.
+
+	char* begin() const;
+		/// Returns the beginn address of the SharedMemory segment. Will be null for illegal segments.
+
+	char* end() const;
+		/// Points past the last byte of the end address of the SharedMemory segment. Will be null for illegal segments.
+
+protected:
+	void map();
+		/// Maps the shared memory object.
+
+	void unmap();
+		/// Unmaps the shared memory object.
+
+	void close();
+		/// Releases the handle for the shared memory segment.
+
+	~SharedMemoryImpl();
+		/// Destroys the SharedMemoryImpl.
+
+private:
+	SharedMemoryImpl();
+	SharedMemoryImpl(const SharedMemoryImpl&);
+	SharedMemoryImpl& operator = (const SharedMemoryImpl&);
+
+	std::string _name;
+	HANDLE  _memHandle;
+	HANDLE  _fileHandle;
+	DWORD   _size;
+	DWORD   _mode;
+	char*   _address;
+};
+
+
+//
+// inlines
+//
+inline char* SharedMemoryImpl::begin() const
+{
+	return _address;
+}
+
+
+inline char* SharedMemoryImpl::end() const
+{
+	return _address + _size;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_SharedMemoryImpl_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SharedPtr.h b/base/poco/Foundation/include/Poco/SharedPtr.h
new file mode 100644
index 00000000000..e5303d3fe53
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SharedPtr.h
@@ -0,0 +1,448 @@
+//
+// SharedPtr.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  SharedPtr
+//
+// Definition of the SharedPtr template class.
+//
+// Copyright (c) 2005-2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SharedPtr_INCLUDED
+#define Foundation_SharedPtr_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include "Poco/AtomicCounter.h"
+#include <algorithm>
+
+
+namespace Poco {
+
+
+class ReferenceCounter
+	/// Simple ReferenceCounter object, does not delete itself when count reaches 0.
+{
+public:
+	ReferenceCounter(): _cnt(1)
+	{
+	}
+
+	void duplicate()
+	{
+		++_cnt;
+	}
+
+	int release()
+	{
+		return --_cnt;
+	}
+	
+	int referenceCount() const
+	{
+		return _cnt.value();
+	}
+
+private:
+	AtomicCounter _cnt;
+};
+
+
+template <class C>
+class ReleasePolicy
+	/// The default release policy for SharedPtr, which
+	/// simply uses the delete operator to delete an object.
+{
+public:
+	static void release(C* pObj)
+		/// Delete the object.
+		/// Note that pObj can be 0.
+	{
+		delete pObj;
+	}
+};
+
+
+template <class C>
+class ReleaseArrayPolicy
+	/// The release policy for SharedPtr holding arrays.
+{
+public:
+	static void release(C* pObj)
+		/// Delete the object.
+		/// Note that pObj can be 0.
+	{
+		delete [] pObj;
+	}
+};
+
+
+template <class C, class RC = ReferenceCounter, class RP = ReleasePolicy<C> >
+class SharedPtr
+	/// SharedPtr is a "smart" pointer for classes implementing
+	/// reference counting based garbage collection.
+	/// SharedPtr is thus similar to AutoPtr. Unlike the
+	/// AutoPtr template, which can only be used with
+	/// classes that support reference counting, SharedPtr
+	/// can be used with any class. For this to work, a
+	/// SharedPtr manages a reference count for the object
+	/// it manages.
+	/// 
+	/// SharedPtr works in the following way:
+	/// If an SharedPtr is assigned an ordinary pointer to
+	/// an object (via the constructor or the assignment operator),
+	/// it takes ownership of the object and the object's reference 
+	/// count is initialized to one.
+	/// If the SharedPtr is assigned another SharedPtr, the
+	/// object's reference count is incremented by one.
+	/// The destructor of SharedPtr decrements the object's
+	/// reference count by one and deletes the object if the
+	/// reference count reaches zero.
+	/// SharedPtr supports dereferencing with both the ->
+	/// and the * operator. An attempt to dereference a null
+	/// SharedPtr results in a NullPointerException being thrown.
+	/// SharedPtr also implements all relational operators and
+	/// a cast operator in case dynamic casting of the encapsulated data types
+	/// is required.
+{
+public:
+	SharedPtr(): _pCounter(new RC), _ptr(0)
+	{
+	}
+
+	SharedPtr(C* ptr)
+	try:
+		_pCounter(new RC), 
+		_ptr(ptr)
+	{
+	}
+	catch (...) 
+	{
+		RP::release(ptr);
+	}
+
+	template <class Other, class OtherRP> 
+	SharedPtr(const SharedPtr<Other, RC, OtherRP>& ptr): _pCounter(ptr._pCounter), _ptr(const_cast<Other*>(ptr.get()))
+	{
+		_pCounter->duplicate();
+	}
+
+	SharedPtr(const SharedPtr& ptr): _pCounter(ptr._pCounter), _ptr(ptr._ptr)
+	{
+		_pCounter->duplicate();
+	}
+
+	~SharedPtr()
+	{
+		try
+		{
+			release();
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	} // NOLINT
+
+	SharedPtr& assign(C* ptr)
+	{
+		if (get() != ptr)
+		{
+			SharedPtr tmp(ptr);
+			swap(tmp);
+		}
+		return *this;
+	}
+	
+	SharedPtr& assign(const SharedPtr& ptr)
+	{
+		if (&ptr != this)
+		{
+			SharedPtr tmp(ptr);
+			swap(tmp);
+		}
+		return *this;
+	}
+	
+	template <class Other, class OtherRP>
+	SharedPtr& assign(const SharedPtr<Other, RC, OtherRP>& ptr)
+	{
+		if (ptr.get() != _ptr)
+		{
+			SharedPtr tmp(ptr);
+			swap(tmp);
+		}
+		return *this;
+	}
+
+	void reset()
+	{
+		assign(0);
+	}
+
+	void reset(C* ptr)
+	{
+		assign(ptr);
+	}
+
+	void reset(const SharedPtr& ptr)
+	{
+		assign(ptr);
+	}
+
+	template <class Other, class OtherRP>
+	void reset(const SharedPtr<Other, RC, OtherRP>& ptr)
+	{
+		assign<Other, OtherRP>(ptr);
+	}
+
+	SharedPtr& operator = (C* ptr)
+	{
+		return assign(ptr);
+	}
+
+	SharedPtr& operator = (const SharedPtr& ptr)
+	{
+		return assign(ptr);
+	}
+
+	template <class Other, class OtherRP>
+	SharedPtr& operator = (const SharedPtr<Other, RC, OtherRP>& ptr)
+	{
+		return assign<Other>(ptr);
+	}
+
+	void swap(SharedPtr& ptr)
+	{
+		std::swap(_ptr, ptr._ptr);
+		std::swap(_pCounter, ptr._pCounter);
+	}
+
+	template <class Other> 
+	SharedPtr<Other, RC, RP> cast() const
+		/// Casts the SharedPtr via a dynamic cast to the given type.
+		/// Returns an SharedPtr containing NULL if the cast fails.
+		/// Example: (assume class Sub: public Super)
+		///    SharedPtr<Super> super(new Sub());
+		///    SharedPtr<Sub> sub = super.cast<Sub>();
+		///    poco_assert (sub.get());
+	{
+		Other* pOther = dynamic_cast<Other*>(_ptr);
+		if (pOther)
+			return SharedPtr<Other, RC, RP>(_pCounter, pOther);
+		return SharedPtr<Other, RC, RP>();
+	}
+
+	template <class Other> 
+	SharedPtr<Other, RC, RP> unsafeCast() const
+		/// Casts the SharedPtr via a static cast to the given type.
+		/// Example: (assume class Sub: public Super)
+		///    SharedPtr<Super> super(new Sub());
+		///    SharedPtr<Sub> sub = super.unsafeCast<Sub>();
+		///    poco_assert (sub.get());
+	{
+		Other* pOther = static_cast<Other*>(_ptr);
+		return SharedPtr<Other, RC, RP>(_pCounter, pOther);
+	}
+
+	C* operator -> ()
+	{
+		return deref();
+	}
+
+	const C* operator -> () const
+	{
+		return deref();
+	}
+
+	C& operator * ()
+	{
+		return *deref();
+	}
+
+	const C& operator * () const
+	{
+		return *deref();
+	}
+
+	C* get()
+	{
+		return _ptr;
+	}
+
+	const C* get() const
+	{
+		return _ptr;
+	}
+
+	operator C* ()
+	{
+		return _ptr;
+	}
+	
+	operator const C* () const
+	{
+		return _ptr;
+	}
+
+	bool operator ! () const
+	{
+		return _ptr == 0;
+	}
+
+	bool isNull() const
+	{
+		return _ptr == 0;
+	}
+
+	bool operator == (const SharedPtr& ptr) const
+	{
+		return get() == ptr.get();
+	}
+
+	bool operator == (const C* ptr) const
+	{
+		return get() == ptr;
+	}
+
+	bool operator == (C* ptr) const
+	{
+		return get() == ptr;
+	}
+
+	bool operator != (const SharedPtr& ptr) const
+	{
+		return get() != ptr.get();
+	}
+
+	bool operator != (const C* ptr) const
+	{
+		return get() != ptr;
+	}
+
+	bool operator != (C* ptr) const
+	{
+		return get() != ptr;
+	}
+
+	bool operator < (const SharedPtr& ptr) const
+	{
+		return get() < ptr.get();
+	}
+
+	bool operator < (const C* ptr) const
+	{
+		return get() < ptr;
+	}
+
+	bool operator < (C* ptr) const
+	{
+		return get() < ptr;
+	}
+
+	bool operator <= (const SharedPtr& ptr) const
+	{
+		return get() <= ptr.get();
+	}
+
+	bool operator <= (const C* ptr) const
+	{
+		return get() <= ptr;
+	}
+
+	bool operator <= (C* ptr) const
+	{
+		return get() <= ptr;
+	}
+
+	bool operator > (const SharedPtr& ptr) const
+	{
+		return get() > ptr.get();
+	}
+
+	bool operator > (const C* ptr) const
+	{
+		return get() > ptr;
+	}
+
+	bool operator > (C* ptr) const
+	{
+		return get() > ptr;
+	}
+
+	bool operator >= (const SharedPtr& ptr) const
+	{
+		return get() >= ptr.get();
+	}
+
+	bool operator >= (const C* ptr) const
+	{
+		return get() >= ptr;
+	}
+
+	bool operator >= (C* ptr) const
+	{
+		return get() >= ptr;
+	}
+	
+	int referenceCount() const
+	{
+		return _pCounter->referenceCount();
+	}
+
+private:
+	C* deref() const
+	{
+		if (!_ptr)
+			throw NullPointerException();
+
+		return _ptr;
+	}
+
+	void release()
+	{
+		poco_assert_dbg (_pCounter);
+		int i = _pCounter->release();
+		if (i == 0)
+		{
+			RP::release(_ptr);
+			_ptr = 0;
+
+			delete _pCounter;
+			_pCounter = 0;
+		}
+	}
+
+	SharedPtr(RC* pCounter, C* ptr): _pCounter(pCounter), _ptr(ptr)
+		/// for cast operation
+	{
+		poco_assert_dbg (_pCounter);
+		_pCounter->duplicate();
+	}
+
+private:
+	RC* _pCounter;
+	C*  _ptr;
+
+	template <class OtherC, class OtherRC, class OtherRP> friend class SharedPtr;
+};
+
+
+template <class C, class RC, class RP>
+inline void swap(SharedPtr<C, RC, RP>& p1, SharedPtr<C, RC, RP>& p2)
+{
+	p1.swap(p2);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_SharedPtr_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SignalHandler.h b/base/poco/Foundation/include/Poco/SignalHandler.h
new file mode 100644
index 00000000000..22b5f167344
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SignalHandler.h
@@ -0,0 +1,129 @@
+//
+// SignalHandler.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  SignalHandler
+//
+// Definition of the SignalHandler class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SignalHandler_INCLUDED
+#define Foundation_SignalHandler_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+#if defined(POCO_OS_FAMILY_UNIX) && !defined(POCO_VXWORKS)
+
+
+#include <vector>
+#include <setjmp.h>
+
+
+namespace Poco {
+
+
+class Foundation_API SignalHandler
+	/// This helper class simplifies the handling of POSIX signals.
+	///
+	/// The class provides a signal handler (installed with
+	/// installHandlers()) that translates certain POSIX
+	/// signals (SIGILL, SIGBUS, SIGSEGV, SIGSYS) into 
+	/// C++ exceptions.
+	///
+	/// Internally, a stack of sigjmp_buf structs is maintained for
+	/// each thread. The constructor pushes a new sigjmp_buf onto
+	/// the current thread's stack. The destructor pops the sigjmp_buf
+	/// from the stack.
+	///
+	/// The poco_throw_on_signal macro creates an instance of SignalHandler
+	/// on the stack, which results in a new sigjmp_buf being created.
+	/// The sigjmp_buf is then set-up with sigsetjmp().
+	///
+	/// The handleSignal() method, which is invoked when a signal arrives,
+	/// checks if a sigjmp_buf is available for the current thread.
+	/// If so, siglongjmp() is used to jump out of the signal handler.
+	///
+	/// Typical usage is as follows:
+	///
+	///     try
+	///     {
+	///          poco_throw_on_signal;
+	///          ...
+	///     }
+	///     catch (Poco::SignalException&)
+	///     {
+	///         ...
+	///     }
+	///
+	/// The best way to deal with a SignalException is to log as much context
+	/// information as possible, to aid in debugging, and then to exit.
+	///
+	/// The SignalHandler can be disabled globally by compiling POCO and client
+	/// code with the POCO_NO_SIGNAL_HANDLER macro defined.
+{
+public:
+	SignalHandler();
+		/// Creates the SignalHandler.
+
+	~SignalHandler();
+		/// Destroys the SignalHandler.
+
+	sigjmp_buf& jumpBuffer();
+		/// Returns the top-most sigjmp_buf for the current thread.
+
+	static void throwSignalException(int sig);
+		/// Throws a SignalException with a textual description  
+		/// of the given signal as argument. 
+	
+	static void install();
+		/// Installs signal handlers for SIGILL, SIGBUS, SIGSEGV
+		/// and SIGSYS.
+
+protected:
+	static void handleSignal(int sig);
+		/// The actual signal handler.
+
+	struct JumpBuffer
+		/// sigjmp_buf cannot be used to instantiate a std::vector,
+		/// so we provide a wrapper struct.
+	{
+		sigjmp_buf buf;
+	};
+	typedef std::vector<JumpBuffer> JumpBufferVec;
+
+	static JumpBufferVec& jumpBufferVec();
+		/// Returns the JumpBufferVec for the current thread.
+
+private:
+	static JumpBufferVec _jumpBufferVec;
+	
+	friend class ThreadImpl;
+};
+
+
+#ifndef POCO_NO_SIGNAL_HANDLER
+#define poco_throw_on_signal \
+	Poco::SignalHandler _poco_signalHandler; \
+	int _poco_signal = sigsetjmp(_poco_signalHandler.jumpBuffer(), 1); \
+	if (_poco_signal) _poco_signalHandler.throwSignalException(_poco_signal);
+#else
+#define poco_throw_on_signal
+#endif
+
+
+} // namespace Poco
+
+
+#endif // POCO_OS_FAMILY_UNIX
+
+
+#endif // Foundation_SignalHandler_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SimpleFileChannel.h b/base/poco/Foundation/include/Poco/SimpleFileChannel.h
new file mode 100644
index 00000000000..29882f45b57
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SimpleFileChannel.h
@@ -0,0 +1,150 @@
+//
+// SimpleFileChannel.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  SimpleFileChannel
+//
+// Definition of the SimpleFileChannel class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SimpleFileChannel_INCLUDED
+#define Foundation_SimpleFileChannel_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Channel.h"
+#include "Poco/Timestamp.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+
+
+class LogFile;
+
+
+class Foundation_API SimpleFileChannel: public Channel
+	/// A Channel that writes to a file. This class only
+	/// supports simple log file rotation.
+	///
+	/// For more features, see the FileChannel class.
+	///
+	/// Only the message's text is written, followed
+	/// by a newline.
+	///
+	/// Chain this channel to a FormattingChannel with an
+	/// appropriate Formatter to control what is in the text. 
+	///
+	/// Log file rotation based on log file size is supported.
+	///
+	/// If rotation is enabled, the SimpleFileChannel will 
+	/// alternate between two log files. If the size of
+	/// the primary log file exceeds a specified limit,
+	/// the secondary log file will be used, and vice
+	/// versa. 
+	///
+	/// Log rotation is configured with the "rotation"
+	/// property, which supports the following values:
+	///   * never:         no log rotation
+	///   * <n>:           the file is rotated when its size exceeds
+	///                    <n> bytes.
+	///   * <n> K:         the file is rotated when its size exceeds
+	///                    <n> Kilobytes.
+	///   * <n> M:         the file is rotated when its size exceeds
+	///                    <n> Megabytes.
+	///
+	/// The path of the (primary) log file can be specified with
+	/// the "path" property. Optionally, the path of the secondary
+	/// log file can be specified with the "secondaryPath" property.
+	///
+	/// If no secondary path is specified, the secondary path will
+	/// default to <primaryPath>.1.
+	///
+	/// The flush property specifies whether each log message is flushed
+	/// immediately to the log file (which may hurt application performance,
+	/// but ensures that everything is in the log in case of a system crash),
+	//  or whether it's allowed to stay in the system's file buffer for some time.
+	/// Valid values are:
+	///
+	///   * true:   Every essages is immediately flushed to the log file (default).
+	///   * false:  Messages are not immediately flushed to the log file.
+	///
+{
+public:
+	SimpleFileChannel();
+		/// Creates the FileChannel.
+
+	SimpleFileChannel(const std::string& path);
+		/// Creates the FileChannel for a file with the given path.
+
+	void open();
+		/// Opens the FileChannel and creates the log file if necessary.
+		
+	void close();
+		/// Closes the FileChannel.
+
+	void log(const Message& msg);
+		/// Logs the given message to the file.
+		
+	void setProperty(const std::string& name, const std::string& value);
+		/// Sets the property with the given name. 
+		/// 
+		/// The following properties are supported:
+		///   * path:          The primary log file's path.
+		///   * secondaryPath: The secondary log file's path.
+		///   * rotation:      The log file's rotation mode. See the 
+		///                    SimpleFileChannel class for details.
+		///   * flush:         Specifies whether messages are immediately
+		///                    flushed to the log file. See the SimpleFileChannel
+		///                    class for details.
+
+	std::string getProperty(const std::string& name) const;
+		/// Returns the value of the property with the given name.
+		/// See setProperty() for a description of the supported
+		/// properties.
+
+	Timestamp creationDate() const;
+		/// Returns the log file's creation date.
+		
+	UInt64 size() const;
+		/// Returns the log file's current size in bytes.
+
+	const std::string& path() const;
+		/// Returns the log file's primary path.
+
+	const std::string& secondaryPath() const;
+		/// Returns the log file's secondary path.
+
+	static const std::string PROP_PATH;
+	static const std::string PROP_SECONDARYPATH;
+	static const std::string PROP_ROTATION;
+	static const std::string PROP_FLUSH;
+
+protected:
+	~SimpleFileChannel();
+	void setRotation(const std::string& rotation);
+	void setFlush(const std::string& flush);
+	void rotate();
+
+private:
+	std::string      _path;
+	std::string      _secondaryPath;
+	std::string      _rotation;
+	UInt64           _limit;
+	bool             _flush;
+	LogFile*         _pFile;
+	FastMutex        _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_SimpleFileChannel_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SimpleHashTable.h b/base/poco/Foundation/include/Poco/SimpleHashTable.h
new file mode 100644
index 00000000000..c149cd6b7e8
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SimpleHashTable.h
@@ -0,0 +1,398 @@
+//
+// SimpleHashTable.h
+//
+// Library: Foundation
+// Package: Hashing
+// Module:  SimpleHashTable
+//
+// Definition of the SimpleHashTable class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SimpleHashTable_INCLUDED
+#define Foundation_SimpleHashTable_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include "Poco/HashFunction.h"
+#include "Poco/HashStatistic.h"
+#include <vector>
+#include <map>
+#include <cstddef>
+#include <algorithm>
+
+
+namespace Poco {
+
+
+//@ deprecated
+template <class Key, class Value, class KeyHashFunction = HashFunction<Key> >
+class SimpleHashTable
+	/// A SimpleHashTable stores a key value pair that can be looked up via a hashed key.
+	///
+	/// In comparision to a HashTable, this class handles collisions by sequentially searching the next
+	/// free location. This also means that the maximum size of this table is limited, i.e. if the hash table
+	/// is full, it will throw an exception and that this class does not support remove operations.
+	/// On the plus side it is faster than the HashTable.
+	///
+	/// This class is NOT thread safe.
+{
+public:
+	class HashEntry
+	{
+	public:
+		Key   key;
+		Value value;
+		HashEntry(const Key k, const Value v): key(k), value(v)
+		{
+		}
+	};
+
+	typedef std::vector<HashEntry*> HashTableVector;
+
+	SimpleHashTable(UInt32 capacity = 251): _entries(capacity, 0), _size(0), _capacity(capacity)
+		/// Creates the SimpleHashTable.
+	{
+	}
+
+	SimpleHashTable(const SimpleHashTable& ht):
+		_size(ht._size),
+		_capacity(ht._capacity)
+	{
+		_entries.reserve(ht._capacity);
+		for (typename HashTableVector::iterator it = ht._entries.begin(); it != ht._entries.end(); ++it)
+		{
+			if (*it) 
+				_entries.push_back(new HashEntry(*it));
+			else
+				_entries.push_back(0);
+		}
+	}
+
+	~SimpleHashTable()
+		/// Destroys the SimpleHashTable.
+	{
+		clear();
+	}
+
+	SimpleHashTable& operator = (const SimpleHashTable& ht)
+	{
+		if (this != &ht)
+		{
+			SimpleHashTable tmp(ht);
+			swap(tmp);
+		}
+		return *this;
+	}
+	
+	void swap(SimpleHashTable& ht)
+	{
+		using std::swap;
+		swap(_entries, ht._entries);
+		swap(_size, ht._size);
+		swap(_capacity, ht._capacity);
+	}
+
+	void clear()
+	{
+		for (typename HashTableVector::iterator it = _entries.begin(); it != _entries.end(); ++it)
+		{
+			delete *it;
+			*it = 0;
+		}
+		_size = 0;
+	}
+
+	UInt32 insert(const Key& key, const Value& value)
+		/// Returns the hash value of the inserted item.
+		/// Throws an exception if the entry was already inserted
+	{
+		UInt32 hsh = hash(key);
+		insertRaw(key, hsh, value);
+		return hsh;
+	}
+
+	Value& insertRaw(const Key& key, UInt32 hsh, const Value& value)
+		/// Returns the hash value of the inserted item.
+		/// Throws an exception if the entry was already inserted
+	{
+		UInt32 pos = hsh;
+		if (!_entries[pos])
+			_entries[pos] = new HashEntry(key, value);
+		else
+		{
+			UInt32 origHash = hsh;
+			while (_entries[hsh % _capacity])
+			{
+				if (_entries[hsh % _capacity]->key == key)
+					throw ExistsException();
+				if (hsh - origHash > _capacity)
+					throw PoolOverflowException("SimpleHashTable full");
+				hsh++;
+			}
+			pos = hsh % _capacity;
+			_entries[pos] = new HashEntry(key, value);
+		}
+		_size++;
+		return _entries[pos]->value;
+	}
+
+	UInt32 update(const Key& key, const Value& value)
+		/// Returns the hash value of the inserted item.
+		/// Replaces an existing entry if it finds one
+	{
+		UInt32 hsh = hash(key);
+		updateRaw(key, hsh, value);
+		return hsh;
+	}
+
+	void updateRaw(const Key& key, UInt32 hsh, const Value& value)
+		/// Returns the hash value of the inserted item.
+		/// Replaces an existing entry if it finds one
+	{
+		if (!_entries[hsh])
+			_entries[hsh] = new HashEntry(key, value);
+		else
+		{
+			UInt32 origHash = hsh;
+			while (_entries[hsh % _capacity])
+			{
+				if (_entries[hsh % _capacity]->key == key)
+				{
+					_entries[hsh % _capacity]->value = value;
+					return;
+				}
+				if (hsh - origHash > _capacity)
+					throw PoolOverflowException("SimpleHashTable full");
+				hsh++;
+			}
+			_entries[hsh % _capacity] = new HashEntry(key, value);
+		}
+		_size++;
+	}
+
+	UInt32 hash(const Key& key) const
+	{
+		return _hash(key, _capacity);
+	}
+
+	const Value& get(const Key& key) const
+		/// Throws an exception if the value does not exist
+	{
+		UInt32 hsh = hash(key);
+		return getRaw(key, hsh);
+	}
+
+	const Value& getRaw(const Key& key, UInt32 hsh) const
+		/// Throws an exception if the value does not exist
+	{
+		UInt32 origHash = hsh;
+		while (true)
+		{
+			if (_entries[hsh % _capacity])
+			{
+				if (_entries[hsh % _capacity]->key == key)
+				{
+					return _entries[hsh % _capacity]->value;
+				}
+			}
+			else
+				throw InvalidArgumentException("value not found");
+			if (hsh - origHash > _capacity)
+				throw InvalidArgumentException("value not found");
+			hsh++;
+		}
+	}
+
+	Value& get(const Key& key)
+		/// Throws an exception if the value does not exist
+	{
+		UInt32 hsh = hash(key);
+		return const_cast<Value&>(getRaw(key, hsh));
+	}
+	
+	const Value& operator [] (const Key& key) const
+	{
+		return get(key);
+	}
+	
+	Value& operator [] (const Key& key)
+	{
+		UInt32 hsh = hash(key);
+		UInt32 origHash = hsh;
+		while (true)
+		{
+			if (_entries[hsh % _capacity])
+			{
+				if (_entries[hsh % _capacity]->key == key)
+				{
+					return _entries[hsh % _capacity]->value;
+				}
+			}
+			else return insertRaw(key, hsh, Value());
+			if (hsh - origHash > _capacity)
+				return insertRaw(key, hsh, Value());
+			hsh++;
+		}
+	}
+
+	const Key& getKeyRaw(const Key& key, UInt32 hsh)
+		/// Throws an exception if the key does not exist. returns a reference to the internally
+		/// stored key. Useful when someone does an insert and wants for performance reason only to store
+		/// a pointer to the key in another collection
+	{
+		UInt32 origHash = hsh;
+		while (true)
+		{
+			if (_entries[hsh % _capacity])
+			{
+				if (_entries[hsh % _capacity]->key == key)
+				{
+					return _entries[hsh % _capacity]->key;
+				}
+			}
+			else
+				throw InvalidArgumentException("key not found");
+
+			if (hsh - origHash > _capacity)
+				throw InvalidArgumentException("key not found");
+			hsh++;
+		}
+	}
+
+	bool get(const Key& key, Value& v) const
+		/// Sets v to the found value, returns false if no value was found
+	{
+		UInt32 hsh = hash(key);
+		return getRaw(key, hsh, v);
+	}
+
+	bool getRaw(const Key& key, UInt32 hsh, Value& v) const
+		/// Sets v to the found value, returns false if no value was found
+	{
+		UInt32 origHash = hsh;
+		while (true)
+		{
+			if (_entries[hsh % _capacity])
+			{
+				if (_entries[hsh % _capacity]->key == key)
+				{
+					v = _entries[hsh % _capacity]->value;
+					return true;
+				}
+			}
+			else
+				return false;
+			if (hsh - origHash > _capacity)
+				return false;
+			hsh++;
+		}
+	}
+
+	bool exists(const Key& key) const
+	{
+		UInt32 hsh = hash(key);
+		return existsRaw(key, hsh);
+	}
+
+	bool existsRaw(const Key& key, UInt32 hsh) const
+	{
+		UInt32 origHash = hsh;
+		while (true)
+		{
+			if (_entries[hsh % _capacity])
+			{
+				if (_entries[hsh % _capacity]->key == key)
+				{
+					return true;
+				}
+			}
+			else
+				return false;
+			if (hsh - origHash > _capacity)
+				return false;
+			hsh++;
+		}
+	}
+
+	std::size_t size() const
+		/// Returns the number of elements already inserted into the SimpleHashTable
+	{
+		return _size;
+	}
+	
+	UInt32 capacity() const
+	{
+		return _capacity;
+	}
+
+	void resize(UInt32 newSize)
+		/// Resizes the hashtable, rehashes all existing entries. Expensive!
+	{
+		if (_capacity != newSize)
+		{
+			SimpleHashTable tmp(newSize);
+			swap(tmp);
+			for (typename HashTableVector::const_iterator it = tmp._entries.begin(); it != tmp._entries.end(); ++it)
+			{
+				if (*it)
+				{
+					insertRaw((*it)->key, hash((*it)->key), (*it)->value);
+				}
+			}
+		}
+	}
+
+	HashStatistic currentState(bool details = false) const
+		/// Returns the current internal state
+	{
+		UInt32 numberOfEntries = (UInt32)_size;
+		UInt32 numZeroEntries = 0;
+		UInt32 maxEntriesPerHash = 0;
+		std::vector<UInt32> detailedEntriesPerHash;
+	#ifdef _DEBUG
+		UInt32 totalSize = 0;
+	#endif
+		for (int i=0; i < _capacity; ++i)
+		{
+			if (_entries[i])
+			{
+				maxEntriesPerHash = 1;
+				UInt32 size = 1;
+				if (details)
+					detailedEntriesPerHash.push_back(size);
+	#ifdef _DEBUG
+				totalSize += size;
+	#endif
+			}
+			else
+			{
+				numZeroEntries++;
+				if (details)
+					detailedEntriesPerHash.push_back(0);
+			}
+		}
+	#ifdef _DEBUG
+		poco_assert_dbg(totalSize == numberOfEntries);
+	#endif
+		return HashStatistic(_capacity, numberOfEntries, numZeroEntries, maxEntriesPerHash, detailedEntriesPerHash);
+	}
+
+private:
+	HashTableVector _entries;
+	std::size_t     _size;
+	UInt32          _capacity;
+	KeyHashFunction _hash;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_HashTable_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SingletonHolder.h b/base/poco/Foundation/include/Poco/SingletonHolder.h
new file mode 100644
index 00000000000..8735f114b59
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SingletonHolder.h
@@ -0,0 +1,77 @@
+//
+// SingletonHolder.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  SingletonHolder
+//
+// Definition of the SingletonHolder template.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SingletonHolder_INCLUDED
+#define Foundation_SingletonHolder_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+
+
+template <class S>
+class SingletonHolder
+	/// This is a helper template class for managing
+	/// singleton objects allocated on the heap.
+	/// The class ensures proper deletion (including
+	/// calling of the destructor) of singleton objects
+	/// when the application that created them terminates.
+{
+public:
+	SingletonHolder():
+		_pS(0)
+		/// Creates the SingletonHolder.
+	{
+	}
+	
+	~SingletonHolder()
+		/// Destroys the SingletonHolder and the singleton
+		/// object that it holds.
+	{
+		delete _pS;
+	}
+	
+	S* get()
+		/// Returns a pointer to the singleton object
+		/// hold by the SingletonHolder. The first call
+		/// to get will create the singleton.
+	{
+		FastMutex::ScopedLock lock(_m);
+		if (!_pS) _pS = new S;
+		return _pS;
+	}
+	
+	void reset()
+		/// Deletes the singleton object.
+	{
+		FastMutex::ScopedLock lock(_m);
+		delete _pS;
+		_pS = 0;
+	}
+	
+private:
+	S* _pS;
+	FastMutex _m;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_SingletonHolder_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SortedDirectoryIterator.h b/base/poco/Foundation/include/Poco/SortedDirectoryIterator.h
new file mode 100644
index 00000000000..94c822be412
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SortedDirectoryIterator.h
@@ -0,0 +1,70 @@
+//
+// SortedDirectoryIterator.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  DirectoryIterator
+//
+// Definition of the SortedDirectoryIterator class.
+//
+// Copyright (c) 2004-2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SortedDirectoryIterator_INCLUDED
+#define Foundation_SortedDirectoryIterator_INCLUDED
+
+#include "Poco/Foundation.h"
+#include "Poco/File.h"
+#include "Poco/Path.h"
+#include "Poco/DirectoryIterator.h"
+#include <deque>
+
+
+namespace Poco
+{
+
+class Foundation_API SortedDirectoryIterator: public DirectoryIterator
+	/// The SortedDirectoryIterator class is similar to
+	/// DirectoryIterator class, but places directories before files
+	/// and sorts content alphabetically.
+{
+public:
+	SortedDirectoryIterator();
+		/// Creates the end iterator.
+
+	SortedDirectoryIterator(const std::string& path);
+		/// Creates a directory iterator for the given path.
+
+	SortedDirectoryIterator(const DirectoryIterator& iterator);
+		/// Creates a directory iterator for the given path.
+
+	SortedDirectoryIterator(const File& file);
+		/// Creates a directory iterator for the given file.
+
+	SortedDirectoryIterator(const Path& path);
+		/// Creates a directory iterator for the given path.
+
+	virtual ~SortedDirectoryIterator();
+		/// Destroys the DirsFirstDirectoryIterator.
+
+	virtual SortedDirectoryIterator& operator ++();   // prefix
+
+private:
+	bool _is_finished;
+	std::deque<std::string> _directories;
+	std::deque<std::string> _files;
+
+	void next();
+		/// Take next item
+	void scan();
+		/// Scan directory to collect its children directories and files
+};
+
+
+} // namespace Poco
+
+#endif //Foundation_SortedDirectoryIterator_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SplitterChannel.h b/base/poco/Foundation/include/Poco/SplitterChannel.h
new file mode 100644
index 00000000000..75aa33b20ac
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SplitterChannel.h
@@ -0,0 +1,77 @@
+//
+// SplitterChannel.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  SplitterChannel
+//
+// Definition of the SplitterChannel class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SplitterChannel_INCLUDED
+#define Foundation_SplitterChannel_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Channel.h"
+#include "Poco/Mutex.h"
+#include <vector>
+
+
+namespace Poco {
+
+
+class Foundation_API SplitterChannel: public Channel
+	/// This channel sends a message to multiple
+	/// channels simultaneously.
+{
+public:
+	SplitterChannel();
+		/// Creates the SplitterChannel.
+
+	void addChannel(Channel* pChannel);
+		/// Attaches a channel, which may not be null.
+		
+	void removeChannel(Channel* pChannel);
+		/// Removes a channel.
+
+	void log(const Message& msg);
+		/// Sends the given Message to all
+		/// attaches channels. 
+
+	void setProperty(const std::string& name, const std::string& value);
+		/// Sets or changes a configuration property.
+		///
+		/// Only the "channel" property is supported, which allows
+		/// adding a comma-separated list of channels via the LoggingRegistry.
+		/// The "channel" property is set-only.
+		/// To simplify file-based configuration, all property
+		/// names starting with "channel" are treated as "channel".
+
+	void close();
+		/// Removes all channels.
+		
+	int count() const;
+		/// Returns the number of channels in the SplitterChannel.
+
+protected:
+	~SplitterChannel();
+
+private:
+	typedef std::vector<Channel*> ChannelVec;
+	
+	ChannelVec        _channels;
+	mutable FastMutex _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_SplitterChannel_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Stopwatch.h b/base/poco/Foundation/include/Poco/Stopwatch.h
new file mode 100644
index 00000000000..6bc27fc92be
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Stopwatch.h
@@ -0,0 +1,108 @@
+//
+// Stopwatch.h
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  Stopwatch
+//
+// Definition of the Stopwatch class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Stopwatch_INCLUDED
+#define Foundation_Stopwatch_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Clock.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Stopwatch
+	/// A simple facility to measure time intervals
+	/// with microsecond resolution.
+{
+public:
+	Stopwatch();
+	~Stopwatch();
+
+	void start();
+		/// Starts (or restarts) the stopwatch.
+		
+	void stop();
+		/// Stops or pauses the stopwatch.
+	
+	void reset();
+		/// Resets the stopwatch.
+		
+	void restart();
+		/// Resets and starts the stopwatch.
+		
+	Clock::ClockDiff elapsed() const;
+		/// Returns the elapsed time in microseconds
+		/// since the stopwatch started.
+		
+	int elapsedSeconds() const;
+		/// Returns the number of seconds elapsed
+		/// since the stopwatch started.
+
+	static Clock::ClockVal resolution();
+		/// Returns the resolution of the stopwatch.
+
+private:
+	Stopwatch(const Stopwatch&);
+	Stopwatch& operator = (const Stopwatch&);
+
+	Clock            _start;
+	Clock::ClockDiff _elapsed;
+	bool             _running;
+};
+
+
+//
+// inlines
+//
+inline void Stopwatch::start()
+{
+	if (!_running)
+	{
+		_start.update();
+		_running = true;
+	}
+}
+
+
+inline void Stopwatch::stop()
+{
+	if (_running)
+	{
+		Clock current;
+		_elapsed += current - _start;
+		_running = false;
+	}
+}
+
+
+inline int Stopwatch::elapsedSeconds() const
+{
+	return int(elapsed()/resolution());
+}
+
+
+inline Clock::ClockVal Stopwatch::resolution()
+{
+	return Clock::resolution();
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Stopwatch_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/StrategyCollection.h b/base/poco/Foundation/include/Poco/StrategyCollection.h
new file mode 100644
index 00000000000..6372d466209
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/StrategyCollection.h
@@ -0,0 +1,133 @@
+//
+// StrategyCollection.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  StrategyCollection
+//
+// Definition of the StrategyCollection class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_StrategyCollection_INCLUDED
+#define Foundation_StrategyCollection_INCLUDED
+
+
+#include "Poco/KeyValueArgs.h"
+#include "Poco/ValidArgs.h"
+#include "Poco/AbstractStrategy.h"
+#include "Poco/SharedPtr.h"
+#include <vector>
+
+
+namespace Poco {
+
+
+template <class TKey, class TValue> 
+class StrategyCollection: public AbstractStrategy<TKey, TValue>
+	/// An StrategyCollection is a decorator masking n collections as a single one.
+{
+public:
+	typedef std::vector<SharedPtr<AbstractStrategy<TKey, TValue> > > Strategies;
+	typedef typename Strategies::iterator       Iterator;
+	typedef typename Strategies::const_iterator ConstIterator;
+
+public:
+	StrategyCollection()
+	{
+	}
+
+	~StrategyCollection()
+	{
+	}
+
+	void pushBack(AbstractStrategy<TKey, TValue>* pStrat)
+		/// Adds an AbstractStrategy to the collection. Class takes ownership of pointer
+	{
+		_strategies.push_back(SharedPtr<AbstractStrategy<TKey, TValue> >(pStrat));
+	}
+
+	void popBack()
+		/// Removes the last added AbstractStrategy from the collection.
+	{
+		_strategies.pop_back();
+	}
+
+	void onAdd(const void* pSender, const KeyValueArgs <TKey, TValue>& key)
+		/// Adds the key to the strategy.
+		/// If for the key already an entry exists, it will be overwritten.
+	{
+		Iterator it = _strategies.begin();
+		Iterator endIt = _strategies.end();
+		for (; it != endIt; ++it)
+		{
+			(*it)->onAdd(pSender, key);
+		}
+	}
+
+	void onRemove(const void* pSender, const TKey& key)
+		/// Removes an entry from the strategy. If the entry is not found
+		/// the remove is ignored.
+	{
+		Iterator it = _strategies.begin();
+		Iterator endIt = _strategies.end();
+		for (; it != endIt; ++it)
+		{
+			(*it)->onRemove(pSender, key);
+		}
+	}
+
+	void onGet(const void* pSender, const TKey& key)
+	{
+		Iterator it = _strategies.begin();
+		Iterator endIt = _strategies.end();
+		for (; it != endIt; ++it)
+		{
+			(*it)->onGet(pSender, key);
+		}
+	}
+
+	void onClear(const void* pSender, const EventArgs& args)
+	{
+		Iterator it = _strategies.begin();
+		Iterator endIt = _strategies.end();
+		for (; it != endIt; ++it)
+		{
+			(*it)->onClear(pSender, args);
+		}
+	}
+
+	void onIsValid(const void* pSender, ValidArgs<TKey>& key)
+	{
+		Iterator it = _strategies.begin();
+		Iterator endIt = _strategies.end();
+		for (; it != endIt && key.isValid(); ++it)
+		{
+			(*it)->onIsValid(pSender, key);
+		}
+	}
+
+	void onReplace(const void* pSender, std::set<TKey>& elemsToRemove)
+	{
+		Iterator it = _strategies.begin();
+		Iterator endIt = _strategies.end();
+		for (; it != endIt; ++it)
+		{
+			(*it)->onReplace(pSender, elemsToRemove);
+		}
+	}
+
+protected:
+	Strategies _strategies;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_StrategyCollection_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/StreamChannel.h b/base/poco/Foundation/include/Poco/StreamChannel.h
new file mode 100644
index 00000000000..8ecf50a7732
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/StreamChannel.h
@@ -0,0 +1,59 @@
+//
+// StreamChannel.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  StreamChannel
+//
+// Definition of the StreamChannel class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_StreamChannel_INCLUDED
+#define Foundation_StreamChannel_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Channel.h"
+#include "Poco/Mutex.h"
+#include <ostream>
+
+
+namespace Poco {
+
+
+class Foundation_API StreamChannel: public Channel
+	/// A channel that writes to an ostream.
+	///
+	/// Only the message's text is written, followed
+	/// by a newline.
+	///
+	/// Chain this channel to a FormattingChannel with an
+	/// appropriate Formatter to control what is contained 
+	/// in the text.
+{
+public:
+	StreamChannel(std::ostream& str);
+		/// Creates the channel.
+
+	void log(const Message& msg);
+		/// Logs the given message to the channel's stream.
+		
+protected:
+	virtual ~StreamChannel();
+
+private:
+	std::ostream& _str;
+	FastMutex     _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_StreamChannel_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/StreamConverter.h b/base/poco/Foundation/include/Poco/StreamConverter.h
new file mode 100644
index 00000000000..c880e2632ff
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/StreamConverter.h
@@ -0,0 +1,128 @@
+//
+// StreamConverter.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  StreamConverter
+//
+// Definition of the StreamConverter class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_StreamConverter_INCLUDED
+#define Foundation_StreamConverter_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/TextEncoding.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+
+
+class Foundation_API StreamConverterBuf: public UnbufferedStreamBuf
+	/// A StreamConverter converts streams from one encoding (inEncoding)
+	/// into another (outEncoding).
+	/// If a character cannot be represented in outEncoding, defaultChar
+	/// is used instead.
+	/// If a byte sequence is not valid in inEncoding, defaultChar is used
+	/// instead and the encoding error count is incremented.
+{
+public:
+	StreamConverterBuf(std::istream& istr, const TextEncoding& inEncoding, const TextEncoding& outEncoding, int defaultChar = '?');
+		/// Creates the StreamConverterBuf and connects it
+		/// to the given input stream.
+
+	StreamConverterBuf(std::ostream& ostr, const TextEncoding& inEncoding, const TextEncoding& outEncoding, int defaultChar = '?');
+		/// Creates the StreamConverterBuf and connects it
+		/// to the given output stream.
+
+	~StreamConverterBuf();
+		/// Destroys the StreamConverterBuf.
+
+	int errors() const;
+		/// Returns the number of encoding errors encountered.
+
+protected:
+	int readFromDevice();
+	int writeToDevice(char c);
+
+private:
+	std::istream*       _pIstr;
+	std::ostream*       _pOstr;
+	const TextEncoding& _inEncoding;
+	const TextEncoding& _outEncoding;
+	int                 _defaultChar;
+	unsigned char       _buffer[TextEncoding::MAX_SEQUENCE_LENGTH];
+	int                 _sequenceLength;
+	int                 _pos;
+	int                 _errors;
+};
+
+
+class Foundation_API StreamConverterIOS: public virtual std::ios
+	/// The base class for InputStreamConverter and OutputStreamConverter.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	StreamConverterIOS(std::istream& istr, const TextEncoding& inEncoding, const TextEncoding& outEncoding, int defaultChar = '?');
+	StreamConverterIOS(std::ostream& ostr, const TextEncoding& inEncoding, const TextEncoding& outEncoding, int defaultChar = '?');
+	~StreamConverterIOS();
+	StreamConverterBuf* rdbuf();
+	int errors() const;
+
+protected:
+	StreamConverterBuf _buf;
+};
+
+
+class Foundation_API InputStreamConverter: public StreamConverterIOS, public std::istream
+	/// This stream converts all characters read from the
+	/// underlying istream from one character encoding into another.
+	/// If a character cannot be represented in outEncoding, defaultChar
+	/// is used instead.
+	/// If a byte sequence read from the underlying stream is not valid in inEncoding, 
+	/// defaultChar is used instead and the encoding error count is incremented.
+{
+public:
+	InputStreamConverter(std::istream& istr, const TextEncoding& inEncoding, const TextEncoding& outEncoding, int defaultChar = '?');
+		/// Creates the InputStreamConverter and connects it
+		/// to the given input stream.
+
+	~InputStreamConverter();
+		/// Destroys the stream.
+};
+
+
+class Foundation_API OutputStreamConverter: public StreamConverterIOS, public std::ostream
+	/// This stream converts all characters written to the
+	/// underlying ostream from one character encoding into another.
+	/// If a character cannot be represented in outEncoding, defaultChar
+	/// is used instead.
+	/// If a byte sequence written to the stream is not valid in inEncoding, 
+	/// defaultChar is used instead and the encoding error count is incremented.
+{
+public:
+	OutputStreamConverter(std::ostream& ostr, const TextEncoding& inEncoding, const TextEncoding& outEncoding, int defaultChar = '?');
+		/// Creates the OutputStreamConverter and connects it
+		/// to the given input stream.
+
+	~OutputStreamConverter();
+		/// Destroys the CountingOutputStream.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_StreamConverter_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/StreamCopier.h b/base/poco/Foundation/include/Poco/StreamCopier.h
new file mode 100644
index 00000000000..fda660c43c4
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/StreamCopier.h
@@ -0,0 +1,85 @@
+//
+// StreamCopier.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  StreamCopier
+//
+// Definition of class StreamCopier.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_StreamCopier_INCLUDED
+#define Foundation_StreamCopier_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <istream>
+#include <ostream>
+#include <cstddef>
+
+
+namespace Poco {
+
+
+class Foundation_API StreamCopier
+	/// This class provides static methods to copy the contents from one stream
+	/// into another.
+{
+public:
+	static std::streamsize copyStream(std::istream& istr, std::ostream& ostr, std::size_t bufferSize = 8192);
+		/// Writes all bytes readable from istr to ostr, using an internal buffer.
+		///
+		/// Returns the number of bytes copied.
+
+#if defined(POCO_HAVE_INT64)
+	static Poco::UInt64 copyStream64(std::istream& istr, std::ostream& ostr, std::size_t bufferSize = 8192);
+		/// Writes all bytes readable from istr to ostr, using an internal buffer.
+		///
+		/// Returns the number of bytes copied as a 64-bit unsigned integer.
+		///
+		/// Note: the only difference to copyStream() is that a 64-bit unsigned
+		/// integer is used to count the number of bytes copied.
+#endif
+
+	static std::streamsize copyStreamUnbuffered(std::istream& istr, std::ostream& ostr);
+		/// Writes all bytes readable from istr to ostr.
+		///
+		/// Returns the number of bytes copied.
+
+#if defined(POCO_HAVE_INT64)
+	static Poco::UInt64 copyStreamUnbuffered64(std::istream& istr, std::ostream& ostr);
+		/// Writes all bytes readable from istr to ostr.
+		///
+		/// Returns the number of bytes copied as a 64-bit unsigned integer.
+		///
+		/// Note: the only difference to copyStreamUnbuffered() is that a 64-bit unsigned
+		/// integer is used to count the number of bytes copied.
+#endif
+
+	static std::streamsize copyToString(std::istream& istr, std::string& str, std::size_t bufferSize = 8192);
+		/// Appends all bytes readable from istr to the given string, using an internal buffer.
+		///
+		/// Returns the number of bytes copied.
+
+#if defined(POCO_HAVE_INT64)
+	static Poco::UInt64 copyToString64(std::istream& istr, std::string& str, std::size_t bufferSize = 8192);
+		/// Appends all bytes readable from istr to the given string, using an internal buffer.
+		///
+		/// Returns the number of bytes copied as a 64-bit unsigned integer.
+		///
+		/// Note: the only difference to copyToString() is that a 64-bit unsigned
+		/// integer is used to count the number of bytes copied.
+#endif
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_StreamCopier_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/StreamTokenizer.h b/base/poco/Foundation/include/Poco/StreamTokenizer.h
new file mode 100644
index 00000000000..3c5b6964100
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/StreamTokenizer.h
@@ -0,0 +1,97 @@
+//
+// StreamTokenizer.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  StreamTokenizer
+//
+// Definition of the StreamTokenizer class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_StreamTokenizer_INCLUDED
+#define Foundation_StreamTokenizer_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Token.h"
+#include <istream>
+#include <vector>
+
+
+namespace Poco {
+
+
+class Foundation_API StreamTokenizer
+	/// A stream tokenizer splits an input stream
+	/// into a sequence of tokens of different kinds.
+	/// Various token kinds can be registered with
+	/// the tokenizer.
+{
+public:
+	StreamTokenizer();
+		/// Creates a StreamTokenizer with no attached stream.
+
+	StreamTokenizer(std::istream& istr);
+		/// Creates a StreamTokenizer with no attached stream.
+
+	virtual ~StreamTokenizer();
+		/// Destroys the StreamTokenizer and deletes all
+		/// registered tokens.
+
+	void attachToStream(std::istream& istr);
+		/// Attaches the tokenizer to an input stream.
+
+	void addToken(Token* pToken);
+		/// Adds a token class to the tokenizer. The
+		/// tokenizer takes ownership of the token and
+		/// deletes it when no longer needed. Comment
+		/// and whitespace tokens will be marked as
+		/// ignorable, which means that next() will not
+		/// return them.
+	
+	void addToken(Token* pToken, bool ignore);
+		/// Adds a token class to the tokenizer. The
+		/// tokenizer takes ownership of the token and
+		/// deletes it when no longer needed.
+		/// If ignore is true, the token will be marked
+		/// as ignorable, which means that next() will
+		/// not return it.
+		
+	const Token* next();
+		/// Extracts the next token from the input stream.
+		/// Returns a pointer to an EOFToken if there are
+		/// no more characters to read. 
+		/// Returns a pointer to an InvalidToken if an
+		/// invalid character is encountered.
+		/// If a token is marked as ignorable, it will not
+		/// be returned, and the next token will be
+		/// examined.
+		/// Never returns a NULL pointer.
+		/// You must not delete the token returned by next().
+
+private:
+	struct TokenInfo
+	{
+		Token* pToken;
+		bool   ignore;
+	};
+	
+	typedef std::vector<TokenInfo> TokenVec;
+	
+	TokenVec      _tokens;
+	std::istream* _pIstr;
+	InvalidToken  _invalidToken;
+	EOFToken      _eofToken;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_StreamTokenizer_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/StreamUtil.h b/base/poco/Foundation/include/Poco/StreamUtil.h
new file mode 100644
index 00000000000..79c94f54942
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/StreamUtil.h
@@ -0,0 +1,92 @@
+//
+// StreamUtil.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  StreamUtil
+//
+// Stream implementation support.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_StreamUtil_INCLUDED
+#define Foundation_StreamUtil_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+// poco_ios_init
+//
+// This is a workaround for a bug in the Dinkumware
+// implementation of iostreams.
+//
+// Calling basic_ios::init() multiple times for the
+// same basic_ios instance results in a memory leak
+// caused by the ios' locale being allocated more than
+// once, each time overwriting the old pointer.
+// This usually occurs in the following scenario:
+//
+// class MyStreamBuf: public std::streambuf
+// {
+//     ...
+// };
+//
+// class MyIOS: public virtual std::ios
+// {
+// public:
+//     MyIOS()
+//     {
+//         init(&_buf);
+//     }
+// protected:
+//     MyStreamBuf _buf;
+// };
+//
+// class MyIStream: public MyIOS, public std::istream
+// {
+//     ...
+// };
+//
+// In this scenario, std::ios::init() is called twice
+// (the first time by the MyIOS constructor, the second
+// time by the std::istream constructor), resulting in 
+// two locale objects being allocated, the pointer second 
+// one overwriting the pointer to the first one and thus 
+// causing a memory leak.
+// 
+// The workaround is to call init() only once for each
+// stream object - by the istream, ostream or iostream
+// constructor, and not calling init() in ios-derived
+// base classes.
+//
+// Some stream implementations, however, require that
+// init() is called in the MyIOS constructor.
+// Therefore we replace each call to init() with
+// the poco_ios_init macro defined below.
+
+
+#if !defined(POCO_IOS_INIT_HACK)
+	// Microsoft Visual Studio with Dinkumware STL (but not STLport)
+#	if defined(_MSC_VER) && (!defined(_STLP_MSVC) || defined(_STLP_NO_OWN_IOSTREAMS))
+#		define POCO_IOS_INIT_HACK 1
+    // QNX with Dinkumware but not GNU C++ Library
+#	elif defined(__QNX__) && !defined(__GLIBCPP__)
+#		define POCO_IOS_INIT_HACK 1
+#	endif
+#endif
+
+
+#if defined(POCO_IOS_INIT_HACK)
+#	define poco_ios_init(buf)
+#else
+#	define poco_ios_init(buf) init(buf)
+#endif
+
+
+#endif // Foundation_StreamUtil_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/String.h b/base/poco/Foundation/include/Poco/String.h
new file mode 100644
index 00000000000..fcf10d6de53
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/String.h
@@ -0,0 +1,706 @@
+//
+// String.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  String
+//
+// String utility functions.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_String_INCLUDED
+#define Foundation_String_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Ascii.h"
+#include <cstring>
+#include <algorithm>
+
+
+namespace Poco {
+
+
+template <class S>
+S trimLeft(const S& str)
+	/// Returns a copy of str with all leading
+	/// whitespace removed.
+{
+	typename S::const_iterator it  = str.begin();
+	typename S::const_iterator end = str.end();
+
+	while (it != end && Ascii::isSpace(*it)) ++it;
+	return S(it, end);
+}
+
+
+template <class S>
+S& trimLeftInPlace(S& str)
+	/// Removes all leading whitespace in str.
+{
+	typename S::iterator it  = str.begin();
+	typename S::iterator end = str.end();
+
+	while (it != end && Ascii::isSpace(*it)) ++it;
+	str.erase(str.begin(), it);
+	return str;
+}
+
+
+template <class S>
+S trimRight(const S& str)
+	/// Returns a copy of str with all trailing
+	/// whitespace removed.
+{
+	int pos = int(str.size()) - 1;
+
+	while (pos >= 0 && Ascii::isSpace(str[pos])) --pos;
+	return S(str, 0, pos + 1);
+}
+
+
+template <class S>
+S& trimRightInPlace(S& str)
+	/// Removes all trailing whitespace in str.
+{
+	int pos = int(str.size()) - 1;
+
+	while (pos >= 0 && Ascii::isSpace(str[pos])) --pos;
+	str.resize(pos + 1);
+
+	return str;
+}
+
+
+template <class S>
+S trim(const S& str)
+	/// Returns a copy of str with all leading and
+	/// trailing whitespace removed.
+{
+	int first = 0;
+	int last  = int(str.size()) - 1;
+
+	while (first <= last && Ascii::isSpace(str[first])) ++first;
+	while (last >= first && Ascii::isSpace(str[last])) --last;
+
+	return S(str, first, last - first + 1);
+}
+
+
+template <class S>
+S& trimInPlace(S& str)
+	/// Removes all leading and trailing whitespace in str.
+{
+	int first = 0;
+	int last  = int(str.size()) - 1;
+
+	while (first <= last && Ascii::isSpace(str[first])) ++first;
+	while (last >= first && Ascii::isSpace(str[last])) --last;
+
+	str.resize(last + 1);
+	str.erase(0, first);
+
+	return str;
+}
+
+
+template <class S>
+S toUpper(const S& str)
+	/// Returns a copy of str containing all upper-case characters.
+{
+	typename S::const_iterator it  = str.begin();
+	typename S::const_iterator end = str.end();
+
+	S result;
+	result.reserve(str.size());
+	while (it != end) result += static_cast<typename S::value_type>(Ascii::toUpper(*it++));
+	return result;
+}
+
+
+template <class S>
+S& toUpperInPlace(S& str)
+	/// Replaces all characters in str with their upper-case counterparts.
+{
+	typename S::iterator it  = str.begin();
+	typename S::iterator end = str.end();
+
+	while (it != end) { *it = static_cast<typename S::value_type>(Ascii::toUpper(*it)); ++it; }
+	return str;
+}
+
+
+template <class S>
+S toLower(const S& str)
+	/// Returns a copy of str containing all lower-case characters.
+{
+	typename S::const_iterator it  = str.begin();
+	typename S::const_iterator end = str.end();
+
+	S result;
+	result.reserve(str.size());
+	while (it != end) result += static_cast<typename S::value_type>(Ascii::toLower(*it++));
+	return result;
+}
+
+
+template <class S>
+S& toLowerInPlace(S& str)
+	/// Replaces all characters in str with their lower-case counterparts.
+{
+	typename S::iterator it  = str.begin();
+	typename S::iterator end = str.end();
+
+	while (it != end) { *it = static_cast<typename S::value_type>(Ascii::toLower(*it)); ++it; }
+	return str;
+}
+
+
+#if !defined(POCO_NO_TEMPLATE_ICOMPARE)
+
+
+template <class S, class It>
+int icompare(
+	const S& str,
+	typename S::size_type pos,
+	typename S::size_type n,
+	It it2,
+	It end2)
+	/// Case-insensitive string comparison
+{
+	typename S::size_type sz = str.size();
+	if (pos > sz) pos = sz;
+	if (pos + n > sz) n = sz - pos;
+	It it1  = str.begin() + pos;
+	It end1 = str.begin() + pos + n;
+	while (it1 != end1 && it2 != end2)
+	{
+		typename S::value_type c1(static_cast<typename S::value_type>(Ascii::toLower(*it1)));
+		typename S::value_type c2(static_cast<typename S::value_type>(Ascii::toLower(*it2)));
+		if (c1 < c2)
+			return -1;
+		else if (c1 > c2)
+			return 1;
+		++it1; ++it2;
+	}
+
+	if (it1 == end1)
+		return it2 == end2 ? 0 : -1;
+	else
+		return 1;
+}
+
+
+template <class S>
+int icompare(const S& str1, const S& str2)
+	// A special optimization for an often used case.
+{
+	typename S::const_iterator it1(str1.begin());
+	typename S::const_iterator end1(str1.end());
+	typename S::const_iterator it2(str2.begin());
+	typename S::const_iterator end2(str2.end());
+	while (it1 != end1 && it2 != end2)
+	{
+		typename S::value_type c1(static_cast<typename S::value_type>(Ascii::toLower(*it1)));
+		typename S::value_type c2(static_cast<typename S::value_type>(Ascii::toLower(*it2)));
+		if (c1 < c2)
+			return -1;
+		else if (c1 > c2)
+			return 1;
+		++it1; ++it2;
+	}
+
+	if (it1 == end1)
+		return it2 == end2 ? 0 : -1;
+	else
+		return 1;
+}
+
+
+template <class S>
+int icompare(const S& str1, typename S::size_type n1, const S& str2, typename S::size_type n2)
+{
+	if (n2 > str2.size()) n2 = str2.size();
+	return icompare(str1, 0, n1, str2.begin(), str2.begin() + n2);
+}
+
+
+template <class S>
+int icompare(const S& str1, typename S::size_type n, const S& str2)
+{
+	if (n > str2.size()) n = str2.size();
+	return icompare(str1, 0, n, str2.begin(), str2.begin() + n);
+}
+
+
+template <class S>
+int icompare(const S& str1, typename S::size_type pos, typename S::size_type n, const S& str2)
+{
+	return icompare(str1, pos, n, str2.begin(), str2.end());
+}
+
+
+template <class S>
+int icompare(
+	const S& str1,
+	typename S::size_type pos1,
+	typename S::size_type n1,
+	const S& str2,
+	typename S::size_type pos2,
+	typename S::size_type n2)
+{
+	typename S::size_type sz2 = str2.size();
+	if (pos2 > sz2) pos2 = sz2;
+	if (pos2 + n2 > sz2) n2 = sz2 - pos2;
+	return icompare(str1, pos1, n1, str2.begin() + pos2, str2.begin() + pos2 + n2);
+}
+
+
+template <class S>
+int icompare(
+	const S& str1,
+	typename S::size_type pos1,
+	typename S::size_type n,
+	const S& str2,
+	typename S::size_type pos2)
+{
+	typename S::size_type sz2 = str2.size();
+	if (pos2 > sz2) pos2 = sz2;
+	if (pos2 + n > sz2) n = sz2 - pos2;
+	return icompare(str1, pos1, n, str2.begin() + pos2, str2.begin() + pos2 + n);
+}
+
+
+template <class S>
+int icompare(
+	const S& str,
+	typename S::size_type pos,
+	typename S::size_type n,
+	const typename S::value_type* ptr)
+{
+	poco_check_ptr (ptr);
+	typename S::size_type sz = str.size();
+	if (pos > sz) pos = sz;
+	if (pos + n > sz) n = sz - pos;
+	typename S::const_iterator it  = str.begin() + pos;
+	typename S::const_iterator end = str.begin() + pos + n;
+	while (it != end && *ptr)
+	{
+		typename S::value_type c1(static_cast<typename S::value_type>(Ascii::toLower(*it)));
+		typename S::value_type c2(static_cast<typename S::value_type>(Ascii::toLower(*ptr)));
+		if (c1 < c2)
+			return -1;
+		else if (c1 > c2)
+			return 1;
+		++it; ++ptr;
+	}
+
+	if (it == end)
+		return *ptr == 0 ? 0 : -1;
+	else
+		return 1;
+}
+
+
+template <class S>
+int icompare(
+	const S& str,
+	typename S::size_type pos,
+	const typename S::value_type* ptr)
+{
+	return icompare(str, pos, str.size() - pos, ptr);
+}
+
+
+template <class S>
+int icompare(
+	const S& str,
+	const typename S::value_type* ptr)
+{
+	return icompare(str, 0, str.size(), ptr);
+}
+
+
+#else
+
+
+int Foundation_API icompare(const std::string& str, std::string::size_type pos, std::string::size_type n, std::string::const_iterator it2, std::string::const_iterator end2);
+int Foundation_API icompare(const std::string& str1, const std::string& str2);
+int Foundation_API icompare(const std::string& str1, std::string::size_type n1, const std::string& str2, std::string::size_type n2);
+int Foundation_API icompare(const std::string& str1, std::string::size_type n, const std::string& str2);
+int Foundation_API icompare(const std::string& str1, std::string::size_type pos, std::string::size_type n, const std::string& str2);
+int Foundation_API icompare(const std::string& str1, std::string::size_type pos1, std::string::size_type n1, const std::string& str2, std::string::size_type pos2, std::string::size_type n2);
+int Foundation_API icompare(const std::string& str1, std::string::size_type pos1, std::string::size_type n, const std::string& str2, std::string::size_type pos2);
+int Foundation_API icompare(const std::string& str, std::string::size_type pos, std::string::size_type n, const std::string::value_type* ptr);
+int Foundation_API icompare(const std::string& str, std::string::size_type pos, const std::string::value_type* ptr);
+int Foundation_API icompare(const std::string& str, const std::string::value_type* ptr);
+
+
+#endif
+
+
+template <class S>
+S translate(const S& str, const S& from, const S& to)
+	/// Returns a copy of str with all characters in
+	/// from replaced by the corresponding (by position)
+	/// characters in to. If there is no corresponding
+	/// character in to, the character is removed from
+	/// the copy.
+{
+	S result;
+	result.reserve(str.size());
+	typename S::const_iterator it  = str.begin();
+	typename S::const_iterator end = str.end();
+	typename S::size_type toSize = to.size();
+	while (it != end)
+	{
+		typename S::size_type pos = from.find(*it);
+		if (pos == S::npos)
+		{
+			result += *it;
+		}
+		else
+		{
+			if (pos < toSize) result += to[pos];
+		}
+		++it;
+	}
+	return result;
+}
+
+
+template <class S>
+S translate(const S& str, const typename S::value_type* from, const typename S::value_type* to)
+{
+	poco_check_ptr (from);
+	poco_check_ptr (to);
+	return translate(str, S(from), S(to));
+}
+
+
+template <class S>
+S& translateInPlace(S& str, const S& from, const S& to)
+	/// Replaces in str all occurrences of characters in from
+	/// with the corresponding (by position) characters in to.
+	/// If there is no corresponding character, the character
+	/// is removed.
+{
+	str = translate(str, from, to);
+	return str;
+}
+
+
+template <class S>
+S translateInPlace(S& str, const typename S::value_type* from, const typename S::value_type* to)
+{
+	poco_check_ptr (from);
+	poco_check_ptr (to);
+	str = translate(str, S(from), S(to));
+#if defined(__SUNPRO_CC)
+// Fix around the RVO bug in SunStudio 12.4
+	S ret(str);
+	return ret;
+#else
+	return str;
+#endif
+}
+
+
+#if !defined(POCO_NO_TEMPLATE_ICOMPARE)
+
+
+template <class S>
+S& replaceInPlace(S& str, const S& from, const S& to, typename S::size_type start = 0)
+{
+	poco_assert (from.size() > 0);
+
+	S result;
+	typename S::size_type pos = 0;
+	result.append(str, 0, start);
+	do
+	{
+		pos = str.find(from, start);
+		if (pos != S::npos)
+		{
+			result.append(str, start, pos - start);
+			result.append(to);
+			start = pos + from.length();
+		}
+		else result.append(str, start, str.size() - start);
+	}
+	while (pos != S::npos);
+	str.swap(result);
+	return str;
+}
+
+
+template <class S>
+S& replaceInPlace(S& str, const typename S::value_type* from, const typename S::value_type* to, typename S::size_type start = 0)
+{
+	poco_assert (*from);
+
+	S result;
+	typename S::size_type pos = 0;
+	typename S::size_type fromLen = std::strlen(from);
+	result.append(str, 0, start);
+	do
+	{
+		pos = str.find(from, start);
+		if (pos != S::npos)
+		{
+			result.append(str, start, pos - start);
+			result.append(to);
+			start = pos + fromLen;
+		}
+		else result.append(str, start, str.size() - start);
+	}
+	while (pos != S::npos);
+	str.swap(result);
+	return str;
+}
+
+
+template <class S>
+S& replaceInPlace(S& str, const typename S::value_type from, const typename S::value_type to = 0, typename S::size_type start = 0)
+{
+	if (from == to) return str;
+
+	typename S::size_type pos = 0;
+	do
+	{
+		pos = str.find(from, start);
+		if (pos != S::npos)
+		{
+			if (to) str[pos] = to;
+			else str.erase(pos, 1);
+		}
+	} while (pos != S::npos);
+
+	return str;
+}
+
+
+template <class S>
+S& removeInPlace(S& str, const typename S::value_type ch, typename S::size_type start = 0)
+{
+	return replaceInPlace(str, ch, 0, start);
+}
+
+
+template <class S>
+S replace(const S& str, const S& from, const S& to, typename S::size_type start = 0)
+	/// Replace all occurrences of from (which must not be the empty string)
+	/// in str with to, starting at position start.
+{
+	S result(str);
+	replaceInPlace(result, from, to, start);
+	return result;
+}
+
+
+template <class S>
+S replace(const S& str, const typename S::value_type* from, const typename S::value_type* to, typename S::size_type start = 0)
+{
+	S result(str);
+	replaceInPlace(result, from, to, start);
+	return result;
+}
+
+
+template <class S>
+S replace(const S& str, const typename S::value_type from, const typename S::value_type to = 0, typename S::size_type start = 0)
+{
+	S result(str);
+	replaceInPlace(result, from, to, start);
+	return result;
+}
+
+
+template <class S>
+S remove(const S& str, const typename S::value_type ch, typename S::size_type start = 0)
+{
+	S result(str);
+	replaceInPlace(result, ch, 0, start);
+	return result;
+}
+
+
+#else
+
+
+Foundation_API std::string replace(const std::string& str, const std::string& from, const std::string& to, std::string::size_type start = 0);
+Foundation_API std::string replace(const std::string& str, const std::string::value_type* from, const std::string::value_type* to, std::string::size_type start = 0);
+Foundation_API std::string replace(const std::string& str, const std::string::value_type from, const std::string::value_type to = 0, std::string::size_type start = 0);
+Foundation_API std::string remove(const std::string& str, const std::string::value_type ch, std::string::size_type start = 0);
+Foundation_API std::string& replaceInPlace(std::string& str, const std::string& from, const std::string& to, std::string::size_type start = 0);
+Foundation_API std::string& replaceInPlace(std::string& str, const std::string::value_type* from, const std::string::value_type* to, std::string::size_type start = 0);
+Foundation_API std::string& replaceInPlace(std::string& str, const std::string::value_type from, const std::string::value_type to = 0, std::string::size_type start = 0);
+Foundation_API std::string& removeInPlace(std::string& str, const std::string::value_type ch, std::string::size_type start = 0);
+
+
+#endif
+
+
+template <class S>
+S cat(const S& s1, const S& s2)
+	/// Concatenates two strings.
+{
+	S result = s1;
+	result.reserve(s1.size() + s2.size());
+	result.append(s2);
+	return result;
+}
+
+
+template <class S>
+S cat(const S& s1, const S& s2, const S& s3)
+	/// Concatenates three strings.
+{
+	S result = s1;
+	result.reserve(s1.size() + s2.size() + s3.size());
+	result.append(s2);
+	result.append(s3);
+	return result;
+}
+
+
+template <class S>
+S cat(const S& s1, const S& s2, const S& s3, const S& s4)
+	/// Concatenates four strings.
+{
+	S result = s1;
+	result.reserve(s1.size() + s2.size() + s3.size() + s4.size());
+	result.append(s2);
+	result.append(s3);
+	result.append(s4);
+	return result;
+}
+
+
+template <class S>
+S cat(const S& s1, const S& s2, const S& s3, const S& s4, const S& s5)
+	/// Concatenates five strings.
+{
+	S result = s1;
+	result.reserve(s1.size() + s2.size() + s3.size() + s4.size() + s5.size());
+	result.append(s2);
+	result.append(s3);
+	result.append(s4);
+	result.append(s5);
+	return result;
+}
+
+
+template <class S>
+S cat(const S& s1, const S& s2, const S& s3, const S& s4, const S& s5, const S& s6)
+	/// Concatenates six strings.
+{
+	S result = s1;
+	result.reserve(s1.size() + s2.size() + s3.size() + s4.size() + s5.size() + s6.size());
+	result.append(s2);
+	result.append(s3);
+	result.append(s4);
+	result.append(s5);
+	result.append(s6);
+	return result;
+}
+
+
+template <class S, class It>
+S cat(const S& delim, const It& begin, const It& end)
+	/// Concatenates a sequence of strings, delimited
+	/// by the string given in delim.
+{
+	S result;
+	for (It it = begin; it != end; ++it)
+	{
+		if (!result.empty()) result.append(delim);
+		result += *it;
+	}
+	return result;
+}
+
+
+//
+// case-insensitive string equality
+//
+
+
+template <typename charT>
+struct i_char_traits : public std::char_traits<charT>
+{
+	inline static bool eq(charT c1, charT c2)
+	{
+		return Ascii::toLower(c1) == Ascii::toLower(c2);
+	}
+
+	inline static bool ne(charT c1, charT c2)
+	{
+		return !eq(c1, c2);
+	}
+
+	inline static bool lt(charT c1, charT c2)
+	{
+		return Ascii::toLower(c1) < Ascii::toLower(c2);
+	}
+
+	static int compare(const charT* s1, const charT* s2, std::size_t n)
+	{
+		for (int i = 0; i < n && s1 && s2; ++i, ++s1, ++s2)
+		{
+			if (Ascii::toLower(*s1) == Ascii::toLower(*s2)) continue;
+			else if (Ascii::toLower(*s1) < Ascii::toLower(*s2)) return -1;
+			else return 1;
+		}
+
+		return 0;
+	}
+
+	static const charT* find(const charT* s, int n, charT a)
+	{
+		while(n-- > 0 && Ascii::toLower(*s) != Ascii::toLower(a)) { ++s; }
+		return s;
+	}
+};
+
+
+typedef std::basic_string<char, i_char_traits<char> > istring;
+	/// Case-insensitive std::string counterpart.
+
+
+template<typename T>
+std::size_t isubstr(const T& str, const T& sought)
+	/// Case-insensitive substring; searches for a substring
+	/// without regards to case.
+{
+	typename T::const_iterator it = std::search(str.begin(), str.end(),
+		sought.begin(), sought.end(),
+		i_char_traits<typename T::value_type>::eq);
+
+	if (it != str.end()) return it - str.begin();
+	else return static_cast<std::size_t>(T::npos);
+}
+
+
+struct CILess
+	/// Case-insensitive less-than functor; useful for standard maps
+	/// and sets with std::strings keys and case-insensitive ordering
+	/// requirement.
+{
+	inline bool operator() (const std::string& s1, const std::string& s2) const
+	{
+		return icompare(s1, s2) < 0;
+	}
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_String_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/StringTokenizer.h b/base/poco/Foundation/include/Poco/StringTokenizer.h
new file mode 100644
index 00000000000..e4bfd469f23
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/StringTokenizer.h
@@ -0,0 +1,135 @@
+//
+// StringTokenizer.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  StringTokenizer
+//
+// Definition of the StringTokenizer class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_StringTokenizer_INCLUDED
+#define Foundation_StringTokenizer_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Exception.h"
+#include <vector>
+#include <cstddef>
+
+
+namespace Poco {
+
+
+class Foundation_API StringTokenizer
+	/// A simple tokenizer that splits a string into
+	/// tokens, which are separated by separator characters.
+	/// An iterator is used to iterate over all tokens.
+{
+public:
+	enum Options
+	{
+		TOK_IGNORE_EMPTY = 1, /// ignore empty tokens
+		TOK_TRIM	 = 2  /// remove leading and trailing whitespace from tokens
+	};
+	
+	typedef std::vector<std::string> TokenVec;
+	typedef TokenVec::const_iterator Iterator;
+	
+	StringTokenizer(const std::string& str, const std::string& separators, int options = 0);
+		/// Splits the given string into tokens. The tokens are expected to be
+		/// separated by one of the separator characters given in separators.
+		/// Additionally, options can be specified:
+		///   * TOK_IGNORE_EMPTY: empty tokens are ignored
+		///   * TOK_TRIM: trailing and leading whitespace is removed from tokens.
+
+	~StringTokenizer();
+		/// Destroys the tokenizer.
+	
+	Iterator begin() const;
+	Iterator end() const;
+	
+	const std::string& operator [] (std::size_t index) const;
+		/// Returns const reference the index'th token.
+		/// Throws a RangeException if the index is out of range.
+
+	std::string& operator [] (std::size_t index);
+		/// Returns reference to the index'th token.
+		/// Throws a RangeException if the index is out of range.
+
+	bool has(const std::string& token) const;
+		/// Returns true if token exists, false otherwise.
+
+	std::string::size_type find(const std::string& token, std::string::size_type pos = 0) const;
+		/// Returns the index of the first occurence of the token
+		/// starting at position pos.
+		/// Throws a NotFoundException if the token is not found.
+
+	std::size_t replace(const std::string& oldToken, const std::string& newToken, std::string::size_type pos = 0);
+		/// Starting at position pos, replaces all subsequent tokens having value 
+		/// equal to oldToken with newToken.
+		/// Returns the number of modified tokens.
+		
+	std::size_t count() const;
+		/// Returns the total number of tokens.
+
+	std::size_t count(const std::string& token) const;
+		/// Returns the number of tokens equal to the specified token.
+
+private:
+	StringTokenizer(const StringTokenizer&);
+	StringTokenizer& operator = (const StringTokenizer&);
+	
+	void trim(std::string& token);
+
+	TokenVec _tokens;
+};
+
+
+//
+// inlines
+//
+
+
+inline StringTokenizer::Iterator StringTokenizer::begin() const
+{
+	return _tokens.begin();
+}
+
+
+inline StringTokenizer::Iterator StringTokenizer::end() const
+{
+	return _tokens.end();
+}
+
+
+inline std::string& StringTokenizer::operator [] (std::size_t index)
+{
+	if (index >= _tokens.size()) throw RangeException();
+	return _tokens[index];
+}
+
+
+inline const std::string& StringTokenizer::operator [] (std::size_t index) const
+{
+	if (index >= _tokens.size()) throw RangeException();
+	return _tokens[index];
+}
+
+
+inline std::size_t StringTokenizer::count() const
+{
+	return _tokens.size();
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_StringTokenizer_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SynchronizedObject.h b/base/poco/Foundation/include/Poco/SynchronizedObject.h
new file mode 100644
index 00000000000..b697f48e66c
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SynchronizedObject.h
@@ -0,0 +1,131 @@
+//
+// SynchronizedObject.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  SynchronizedObject
+//
+// Definition of the SynchronizedObject class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SynchronizedObject_INCLUDED
+#define Foundation_SynchronizedObject_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Mutex.h"
+#include "Poco/Event.h"
+
+
+namespace Poco {
+
+
+class Foundation_API SynchronizedObject
+	/// This class aggregates a Mutex and an Event
+	/// and can act as a base class for all objects
+	/// requiring synchronization in a multithreaded
+	/// scenario.
+{
+public:
+	typedef Poco::ScopedLock<SynchronizedObject> ScopedLock;
+	
+	SynchronizedObject();
+		/// Creates the object.
+		
+	virtual ~SynchronizedObject();
+		/// Destroys the object.
+
+	void lock() const;
+		/// Locks the object. Blocks if the object
+		/// is locked by another thread.
+
+	bool tryLock() const;
+		/// Tries to lock the object. Returns false immediately
+		/// if the object is already locked by another thread
+		/// Returns true if the object was successfully locked.
+	
+	void unlock() const;
+		/// Unlocks the object so that it can be locked by
+		/// other threads.
+		
+	void notify() const;
+		/// Signals the object. 
+		/// Exactly only one thread waiting for the object 
+		/// can resume execution.
+
+	void wait() const;
+		/// Waits for the object to become signalled.
+
+	void wait(long milliseconds) const;
+		/// Waits for the object to become signalled.
+		/// Throws a TimeoutException if the object
+		/// does not become signalled within the specified
+		/// time interval.
+
+	bool tryWait(long milliseconds) const;
+		/// Waits for the object to become signalled.
+		/// Returns true if the object
+		/// became signalled within the specified
+		/// time interval, false otherwise.
+
+private:
+	mutable Mutex _mutex;
+	mutable Event _event;
+};
+
+
+//
+// inlines
+//
+inline void SynchronizedObject::lock() const
+{
+	_mutex.lock();
+}
+
+
+inline bool SynchronizedObject::tryLock() const
+{
+	return _mutex.tryLock();
+}
+
+
+inline void SynchronizedObject::unlock() const
+{
+	_mutex.unlock();
+}
+
+
+inline void SynchronizedObject::notify() const
+{
+	_event.set();
+}
+
+
+inline void SynchronizedObject::wait() const
+{
+	_event.wait();
+}
+
+
+inline void SynchronizedObject::wait(long milliseconds) const
+{
+	_event.wait(milliseconds);
+}
+
+
+inline bool SynchronizedObject::tryWait(long milliseconds) const
+{
+	return _event.tryWait(milliseconds);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_SynchronizedObject_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/SyslogChannel.h b/base/poco/Foundation/include/Poco/SyslogChannel.h
new file mode 100644
index 00000000000..4c304e8c0d2
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/SyslogChannel.h
@@ -0,0 +1,109 @@
+//
+// SyslogChannel.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  SyslogChannel
+//
+// Definition of the SyslogChannel class specific to UNIX.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_SyslogChannel_INCLUDED
+#define Foundation_SyslogChannel_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Channel.h"
+
+
+namespace Poco {
+
+
+class Foundation_API SyslogChannel: public Channel
+	/// This Unix-only channel works with the Unix syslog service.
+{
+public:
+	enum Option
+	{
+		SYSLOG_PID    = 0x01, /// log the pid with each message
+		SYSLOG_CONS   = 0x02, /// log on the console if errors in sending
+		SYSLOG_NDELAY = 0x08, /// don't delay open
+		SYSLOG_PERROR = 0x20  /// log to stderr as well (not supported on all platforms)
+	};
+	
+	enum Facility
+	{
+		SYSLOG_KERN     = ( 0<<3), /// kernel messages
+		SYSLOG_USER     = ( 1<<3), /// random user-level messages
+		SYSLOG_MAIL     = ( 2<<3), /// mail system
+		SYSLOG_DAEMON   = ( 3<<3), /// system daemons
+		SYSLOG_AUTH     = ( 4<<3), /// security/authorization messages
+		SYSLOG_SYSLOG   = ( 5<<3), /// messages generated internally by syslogd
+		SYSLOG_LPR      = ( 6<<3), /// line printer subsystem
+		SYSLOG_NEWS     = ( 7<<3), /// network news subsystem
+		SYSLOG_UUCP     = ( 8<<3), /// UUCP subsystem
+		SYSLOG_CRON     = ( 9<<3), /// clock daemon
+		SYSLOG_AUTHPRIV = (10<<3), /// security/authorization messages (private)
+		SYSLOG_FTP      = (11<<3), /// ftp daemon
+		SYSLOG_LOCAL0   = (16<<3), /// reserved for local use
+		SYSLOG_LOCAL1   = (17<<3), /// reserved for local use
+		SYSLOG_LOCAL2   = (18<<3), /// reserved for local use
+		SYSLOG_LOCAL3   = (19<<3), /// reserved for local use
+		SYSLOG_LOCAL4   = (20<<3), /// reserved for local use
+		SYSLOG_LOCAL5   = (21<<3), /// reserved for local use
+		SYSLOG_LOCAL6   = (22<<3), /// reserved for local use
+		SYSLOG_LOCAL7   = (23<<3)  /// reserved for local use
+	};
+	
+	SyslogChannel();
+		/// Creates a SyslogChannel.
+		
+	SyslogChannel(const std::string& name, int options = SYSLOG_CONS, int facility = SYSLOG_USER);
+		/// Creates a SyslogChannel with the given name, options and facility.
+	
+	void open();
+		/// Opens the SyslogChannel.
+		
+	void close();
+		/// Closes the SyslogChannel.
+		
+	void log(const Message& msg);
+		/// Sens the message's text to the syslog service.
+		
+	void setProperty(const std::string& name, const std::string& value);
+		/// Sets the property with the given value.
+		///
+		/// The following properties are supported:
+		///     * name:     The name used to identify the source of log messages.
+		///     * facility: The facility added to each log message. See the Facility enumeration for a list of supported values.
+		///     * options:  The logging options. See the Option enumeration for a list of supported values.
+		
+	std::string getProperty(const std::string& name) const;
+		/// Returns the value of the property with the given name.
+
+	static const std::string PROP_NAME;
+	static const std::string PROP_FACILITY;
+	static const std::string PROP_OPTIONS;
+
+protected:
+	~SyslogChannel();
+	static int getPrio(const Message& msg);
+
+private:
+	std::string _name;
+	int  _options;
+	int  _facility;
+	bool _open;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_SyslogChannel_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Task.h b/base/poco/Foundation/include/Poco/Task.h
new file mode 100644
index 00000000000..e05e3215da7
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Task.h
@@ -0,0 +1,190 @@
+//
+// Task.h
+//
+// Library: Foundation
+// Package: Tasks
+// Module:  Tasks
+//
+// Definition of the Task class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Task_INCLUDED
+#define Foundation_Task_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Runnable.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/Mutex.h"
+#include "Poco/Event.h"
+
+#include <atomic>
+
+namespace Poco {
+
+
+class TaskManager;
+class Notification;
+class NotificationCenter;
+
+
+class Foundation_API Task: public Runnable, public RefCountedObject
+	/// A Task is a subclass of Runnable that has a name
+	/// and supports progress reporting and cancellation.
+	///
+	/// A TaskManager object can be used to take care of the
+	/// lifecycle of a Task.
+{
+public:
+	enum TaskState
+	{
+		TASK_IDLE,
+		TASK_STARTING,
+		TASK_RUNNING,
+		TASK_CANCELLING,
+		TASK_FINISHED
+	};
+	
+	Task(const std::string& name);
+		/// Creates the Task.
+
+	const std::string& name() const;
+		/// Returns the task's name.	
+		
+	float progress() const;
+		/// Returns the task's progress.
+		/// The value will be between 0.0 (just started)
+		/// and 1.0 (completed).
+
+	virtual void cancel();
+		/// Requests the task to cancel itself. For cancellation
+		/// to work, the task's runTask() method must periodically
+		/// call isCancelled() and react accordingly.
+		///
+		/// Can be overridden to implement custom behavior,
+		/// but the base class implementation of cancel() should
+		/// be called to ensure proper behavior.
+
+	bool isCancelled() const;
+		/// Returns true if cancellation of the task has been
+		/// requested.
+		///
+		/// A Task's runTask() method should periodically
+		/// call this method and stop whatever it is doing in an
+		/// orderly way when this method returns true.
+
+	TaskState state() const;
+		/// Returns the task's current state.
+
+	void reset();
+		/// Sets the task's progress to zero and clears the
+		/// cancel flag.
+		
+	virtual void runTask() = 0;
+		/// Do whatever the task needs to do. Must
+		/// be overridden by subclasses.
+		
+	void run();
+		/// Calls the task's runTask() method and notifies the owner
+		/// of the task's start and completion.
+
+protected:
+	bool sleep(long milliseconds);
+		/// Suspends the current thread for the specified
+		/// amount of time.
+		///
+		/// If the task is cancelled while it is sleeping,
+		/// sleep() will return immediately and the return
+		/// value will be true. If the time interval
+		/// passes without the task being cancelled, the
+		/// return value is false.
+		///
+		/// A Task should use this method in favor of Thread::sleep().
+
+	void setProgress(float progress);
+		/// Sets the task's progress.
+		/// The value should be between 0.0 (just started)
+		/// and 1.0 (completed).
+
+	virtual void postNotification(Notification* pNf);
+		/// Posts a notification to the task manager's
+		/// notification center.
+		///
+		/// A task can use this method to post custom
+		/// notifications about its progress.
+
+	void setOwner(TaskManager* pOwner);
+		/// Sets the (optional) owner of the task.
+		
+	TaskManager* getOwner() const;
+		/// Returns the owner of the task, which may be NULL.
+
+	void setState(TaskState state);
+		/// Sets the task's state.
+
+	virtual ~Task();
+		/// Destroys the Task.
+		
+private:
+	Task();
+	Task(const Task&);
+	Task& operator = (const Task&);
+	
+	std::string       _name;
+	TaskManager*      _pOwner;
+	float             _progress;
+	std::atomic<TaskState>         _state;
+	Event             _cancelEvent;
+	mutable FastMutex _mutex;
+	
+	friend class TaskManager;
+};
+
+
+//
+// inlines
+//
+inline const std::string& Task::name() const
+{
+	return _name;
+}
+
+
+inline float Task::progress() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	return _progress;
+}
+
+
+inline bool Task::isCancelled() const
+{
+	return _state == TASK_CANCELLING;
+}
+
+
+inline Task::TaskState Task::state() const
+{
+	return _state;
+}
+
+
+inline TaskManager* Task::getOwner() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	return _pOwner;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Task_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/TaskManager.h b/base/poco/Foundation/include/Poco/TaskManager.h
new file mode 100644
index 00000000000..3d6e7f1cc1b
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/TaskManager.h
@@ -0,0 +1,137 @@
+//
+// TaskManager.h
+//
+// Library: Foundation
+// Package: Tasks
+// Module:  Tasks
+//
+// Definition of the TaskManager class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_TaskManager_INCLUDED
+#define Foundation_TaskManager_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Mutex.h"
+#include "Poco/Task.h"
+#include "Poco/AutoPtr.h"
+#include "Poco/NotificationCenter.h"
+#include "Poco/Timestamp.h"
+#include <list>
+
+
+namespace Poco {
+
+
+class Notification;
+class ThreadPool;
+class Exception;
+
+
+class Foundation_API TaskManager
+	/// The TaskManager manages a collection of tasks
+	/// and monitors their lifetime.
+	///
+	/// A TaskManager has a built-in NotificationCenter that
+	/// is used to send out notifications on task progress
+	/// and task states. See the TaskNotification class and its
+	/// subclasses for the various events that result in a notification.
+	/// To keep the number of notifications small, a TaskProgressNotification
+	/// will only be sent out once in 100 milliseconds.
+{
+public:
+	typedef AutoPtr<Task>      TaskPtr;
+	typedef std::list<TaskPtr> TaskList;
+
+	TaskManager();
+		/// Creates the TaskManager, using the
+		/// default ThreadPool.
+
+	TaskManager(ThreadPool& pool);
+		/// Creates the TaskManager, using the
+		/// given ThreadPool.
+
+	~TaskManager();
+		/// Destroys the TaskManager.
+
+	void start(Task* pTask);
+		/// Starts the given task in a thread obtained
+		/// from the thread pool.
+		///
+		/// The TaskManager takes ownership of the Task object
+		/// and deletes it when it it finished.
+
+	void cancelAll();
+		/// Requests cancellation of all tasks.
+		
+	void joinAll();
+		/// Waits for the completion of all the threads
+		/// in the TaskManager's thread pool.
+		///
+		/// Note: joinAll() will wait for ALL tasks in the
+		/// TaskManager's ThreadPool to complete. If the
+		/// ThreadPool has threads created by other
+		/// facilities, these threads must also complete
+		/// before joinAll() can return.
+
+	TaskList taskList() const;
+		/// Returns a copy of the internal task list.
+
+	int count() const;
+		/// Returns the number of tasks in the internal task list.
+
+	void addObserver(const AbstractObserver& observer);
+		/// Registers an observer with the NotificationCenter.
+		/// Usage:
+		///     Observer<MyClass, MyNotification> obs(*this, &MyClass::handleNotification);
+		///     notificationCenter.addObserver(obs);
+
+	void removeObserver(const AbstractObserver& observer);
+		/// Unregisters an observer with the NotificationCenter.
+
+	static const int MIN_PROGRESS_NOTIFICATION_INTERVAL;
+
+protected:
+	void postNotification(const Notification::Ptr& pNf);
+		/// Posts a notification to the task manager's 
+		/// notification center.
+
+	void taskStarted(Task* pTask);
+	void taskProgress(Task* pTask, float progress);
+	void taskCancelled(Task* pTask);
+	void taskFinished(Task* pTask);
+	void taskFailed(Task* pTask, const Exception& exc);
+
+private:
+	ThreadPool&        _threadPool;
+	TaskList           _taskList;
+	Timestamp          _lastProgressNotification;
+	NotificationCenter _nc;
+	mutable FastMutex  _mutex;
+
+	friend class Task;
+};
+
+
+//
+// inlines
+//
+inline int TaskManager::count() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	return (int) _taskList.size();
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_TaskManager_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/TaskNotification.h b/base/poco/Foundation/include/Poco/TaskNotification.h
new file mode 100644
index 00000000000..92d8a95821d
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/TaskNotification.h
@@ -0,0 +1,170 @@
+//
+// TaskNotification.h
+//
+// Library: Foundation
+// Package: Tasks
+// Module:  Tasks
+//
+// Definition of the TaskNotification class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_TaskNotification_INCLUDED
+#define Foundation_TaskNotification_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Notification.h"
+#include "Poco/Task.h"
+
+
+namespace Poco {
+
+
+class Foundation_API TaskNotification: public Notification
+	/// Base class for TaskManager notifications.
+{
+public:
+	TaskNotification(Task* pTask);
+		/// Creates the TaskNotification.
+
+	Task* task() const;
+		/// Returns the subject of the notification.
+
+protected:
+	virtual ~TaskNotification();
+		/// Destroys the TaskNotification.
+
+private:
+	Task* _pTask;
+};
+
+
+class Foundation_API TaskStartedNotification: public TaskNotification
+	/// This notification is posted by the TaskManager for
+	/// every task that has been started.
+{
+public:
+	TaskStartedNotification(Task* pTask);
+	
+protected:
+	~TaskStartedNotification();
+};
+
+
+class Foundation_API TaskCancelledNotification: public TaskNotification
+	/// This notification is posted by the TaskManager for
+	/// every task that has been cancelled.
+{
+public:
+	TaskCancelledNotification(Task* pTask);
+
+protected:
+	~TaskCancelledNotification();
+};
+
+
+class Foundation_API TaskFinishedNotification: public TaskNotification
+	/// This notification is posted by the TaskManager for
+	/// every task that has finished.
+{
+public:
+	TaskFinishedNotification(Task* pTask);
+
+protected:
+	~TaskFinishedNotification();
+};
+
+
+class Foundation_API TaskFailedNotification: public TaskNotification
+	/// This notification is posted by the TaskManager for
+	/// every task that has failed with an exception.
+{
+public:
+	TaskFailedNotification(Task* pTask, const Exception& exc);
+
+	const Exception& reason() const;
+
+protected:
+	~TaskFailedNotification();
+	
+private:
+	Exception* _pException;
+};
+
+
+class Foundation_API TaskProgressNotification: public TaskNotification
+	/// This notification is posted by the TaskManager for
+	/// a task when its progress changes.
+{
+public:
+	TaskProgressNotification(Task* pTask, float progress);
+
+	float progress() const;
+
+protected:
+	~TaskProgressNotification();
+	
+private:
+	float _progress;
+};
+
+
+template <class C>
+class TaskCustomNotification: public TaskNotification
+	/// This is a template for "custom" notification.
+	/// Unlike other notifications, this notification
+	/// is instantiated and posted by the task itself.
+	/// The purpose is to provide generic notifiation
+	/// mechanism between the task and its observer(s).
+{
+public:
+	TaskCustomNotification(Task* pTask, const C& custom):
+		TaskNotification(pTask),
+		_custom(custom)
+	{
+	}
+
+	const C& custom() const
+	{
+		return _custom;
+	}
+
+protected:
+	~TaskCustomNotification(){};
+	
+private:
+	C _custom;
+};
+
+
+//
+// inlines
+//
+inline Task* TaskNotification::task() const
+{
+	return _pTask;
+}
+
+
+inline const Exception& TaskFailedNotification::reason() const
+{
+	return *_pException;
+}
+
+
+inline float TaskProgressNotification::progress() const
+{
+	return _progress;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_TaskNotification_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/TeeStream.h b/base/poco/Foundation/include/Poco/TeeStream.h
new file mode 100644
index 00000000000..07744d83413
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/TeeStream.h
@@ -0,0 +1,132 @@
+//
+// TeeStream.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  TeeStream
+//
+// Definition of the TeeStream class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_TeeStream_INCLUDED
+#define Foundation_TeeStream_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include <vector>
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+
+
+class Foundation_API TeeStreamBuf: public UnbufferedStreamBuf
+	/// This stream buffer copies all data written to or
+	/// read from it to one or multiple output streams.
+{
+public:
+	TeeStreamBuf();
+		/// Creates an unconnected CountingStreamBuf.
+		/// Use addStream() to attach output streams.
+	
+	TeeStreamBuf(std::istream& istr);
+		/// Creates the CountingStreamBuf and connects it
+		/// to the given input stream.
+
+	TeeStreamBuf(std::ostream& ostr);
+		/// Creates the CountingStreamBuf and connects it
+		/// to the given output stream.
+
+	~TeeStreamBuf();
+		/// Destroys the CountingStream.
+
+	void addStream(std::ostream& ostr);
+		/// Adds the given output stream.
+
+protected:
+	int readFromDevice();
+	int writeToDevice(char c);
+
+private:
+	typedef std::vector<std::ostream*> StreamVec;
+	
+	std::istream* _pIstr;
+	StreamVec     _streams;
+};
+
+
+class Foundation_API TeeIOS: public virtual std::ios
+	/// The base class for TeeInputStream and TeeOutputStream.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	TeeIOS();
+		/// Creates the basic stream and leaves it unconnected.
+
+	TeeIOS(std::istream& istr);
+		/// Creates the basic stream and connects it
+		/// to the given input stream.
+
+	TeeIOS(std::ostream& ostr);
+		/// Creates the basic stream and connects it
+		/// to the given output stream.
+
+	~TeeIOS();
+		/// Destroys the stream.
+
+	void addStream(std::ostream& ostr);
+		/// Adds the given output stream.
+
+	TeeStreamBuf* rdbuf();
+		/// Returns a pointer to the underlying streambuf.
+
+protected:
+	TeeStreamBuf _buf;
+};
+
+
+class Foundation_API TeeInputStream: public TeeIOS, public std::istream
+	/// This stream copies all characters read through it
+	/// to one or multiple output streams.
+{
+public:
+	TeeInputStream(std::istream& istr);
+		/// Creates the TeeInputStream and connects it
+		/// to the given input stream.
+
+	~TeeInputStream();
+		/// Destroys the TeeInputStream.
+};
+
+
+class Foundation_API TeeOutputStream: public TeeIOS, public std::ostream
+	/// This stream copies all characters written to it
+	/// to one or multiple output streams.
+{
+public:
+	TeeOutputStream();
+		/// Creates an unconnected TeeOutputStream.
+	
+	TeeOutputStream(std::ostream& ostr);
+		/// Creates the TeeOutputStream and connects it
+		/// to the given input stream.
+
+	~TeeOutputStream();
+		/// Destroys the TeeOutputStream.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_TeeStream_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/TemporaryFile.h b/base/poco/Foundation/include/Poco/TemporaryFile.h
new file mode 100644
index 00000000000..9246846c293
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/TemporaryFile.h
@@ -0,0 +1,84 @@
+//
+// TemporaryFile.h
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  TemporaryFile
+//
+// Definition of the TemporaryFile class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_TemporaryFile_INCLUDED
+#define Foundation_TemporaryFile_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/File.h"
+
+
+namespace Poco {
+
+
+class Foundation_API TemporaryFile: public File
+	/// The TemporaryFile class helps with the handling
+	/// of temporary files.
+	/// A unique name for the temporary file is
+	/// automatically chosen and the file is placed
+	/// in the directory reserved for temporary
+	/// files (see Path::temp()).
+	/// Obtain the path by calling the path() method
+	/// (inherited from File).
+	///
+	/// The TemporaryFile class does not actually
+	/// create the file - this is up to the application.
+	/// The class does, however, delete the temporary
+	/// file - either in the destructor, or immediately
+	/// before the application terminates.
+{
+public:
+	TemporaryFile();
+		/// Creates the TemporaryFile.
+
+	TemporaryFile(const std::string& tempDir);
+		/// Creates the TemporaryFile using the given directory.
+
+	~TemporaryFile();
+		/// Destroys the TemporaryFile and
+		/// deletes the corresponding file on
+		/// disk unless keep() or keepUntilExit()
+		/// has been called.
+
+	void keep();
+		/// Disables automatic deletion of the file in
+		/// the destructor.
+
+	void keepUntilExit();
+		/// Disables automatic deletion of the file in
+		/// the destructor, but registers the file
+		/// for deletion at process termination.
+
+	static void registerForDeletion(const std::string& path);
+		/// Registers the given file for deletion
+		/// at process termination.
+
+	static std::string tempName(const std::string& tempDir = "");
+		/// Returns a unique path name for a temporary
+		/// file in the system's scratch directory (see Path::temp())
+		/// if tempDir is empty or in the directory specified in tempDir
+		/// otherwise.
+
+private:
+	bool _keep;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_TemporaryFile_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/TextBufferIterator.h b/base/poco/Foundation/include/Poco/TextBufferIterator.h
new file mode 100644
index 00000000000..d8eda841753
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/TextBufferIterator.h
@@ -0,0 +1,145 @@
+//
+// TextBufferIterator.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  TextBufferIterator
+//
+// Definition of the TextBufferIterator class.
+//
+// Copyright (c) 2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_TextBufferIterator_INCLUDED
+#define Foundation_TextBufferIterator_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <cstdlib>
+
+
+namespace Poco {
+
+
+class TextEncoding;
+
+
+class Foundation_API TextBufferIterator
+	/// An unidirectional iterator for iterating over characters in a buffer.
+	/// The TextBufferIterator uses a TextEncoding object to
+	/// work with multi-byte character encodings like UTF-8.
+	/// Characters are reported in Unicode.
+	///
+	/// Example: Count the number of UTF-8 characters in a buffer.
+	///
+	///     UTF8Encoding utf8Encoding;
+	///     char buffer[] = "...";
+	///     TextBufferIterator it(buffer, utf8Encoding);
+	///     TextBufferIterator end(it.end());
+	///     int n = 0;
+	///     while (it != end) { ++n; ++it; }
+	///
+	/// NOTE: When an UTF-16 encoding is used, surrogate pairs will be
+	/// reported as two separate characters, due to restrictions of
+	/// the TextEncoding class.
+	///
+	/// For iterating over the characters in a std::string, see the
+	/// TextIterator class.
+{
+public:
+	TextBufferIterator();
+		/// Creates an uninitialized TextBufferIterator.
+		
+	TextBufferIterator(const char* begin, const TextEncoding& encoding);
+		/// Creates a TextBufferIterator for the given buffer, which must be 0-terminated.
+		/// The encoding object must not be deleted as long as the iterator
+		/// is in use.
+
+	TextBufferIterator(const char* begin, std::size_t size, const TextEncoding& encoding);
+		/// Creates a TextBufferIterator for the given buffer with the given size.
+		/// The encoding object must not be deleted as long as the iterator
+		/// is in use.
+
+	TextBufferIterator(const char* begin, const char* end, const TextEncoding& encoding);
+		/// Creates a TextBufferIterator for the given range.
+		/// The encoding object must not be deleted as long as the iterator
+		/// is in use.
+
+	TextBufferIterator(const char* end);
+		/// Creates an end TextBufferIterator for the given buffer.
+
+	~TextBufferIterator();
+		/// Destroys the TextBufferIterator.
+	
+	TextBufferIterator(const TextBufferIterator& it);
+		/// Copy constructor.
+	
+	TextBufferIterator& operator = (const TextBufferIterator& it);
+		/// Assignment operator.
+		
+	void swap(TextBufferIterator& it);
+		/// Swaps the iterator with another one.
+	
+	int operator * () const;
+		/// Returns the Unicode value of the current character.
+		/// If there is no valid character at the current position,
+		/// -1 is returned.
+		
+	TextBufferIterator& operator ++ (); 
+		/// Prefix increment operator.
+
+	TextBufferIterator operator ++ (int);		
+		/// Postfix increment operator.
+
+	bool operator == (const TextBufferIterator& it) const;
+		/// Compares two iterators for equality.
+		
+	bool operator != (const TextBufferIterator& it) const;
+		/// Compares two iterators for inequality.
+
+	TextBufferIterator end() const;
+		/// Returns the end iterator for the range handled
+		/// by the iterator.
+		
+private:
+	const TextEncoding* _pEncoding;
+	const char* _it;
+	const char* _end;
+};
+
+
+//
+// inlines
+//
+inline bool TextBufferIterator::operator == (const TextBufferIterator& it) const
+{
+	return _it == it._it;
+}
+
+
+inline bool TextBufferIterator::operator != (const TextBufferIterator& it) const
+{
+	return _it != it._it;
+}
+
+
+inline void swap(TextBufferIterator& it1, TextBufferIterator& it2)
+{
+	it1.swap(it2);
+}
+
+
+inline TextBufferIterator TextBufferIterator::end() const
+{
+	return TextBufferIterator(_end);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_TextBufferIterator_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/TextConverter.h b/base/poco/Foundation/include/Poco/TextConverter.h
new file mode 100644
index 00000000000..ebf978fa6b4
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/TextConverter.h
@@ -0,0 +1,93 @@
+//
+// TextConverter.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  TextConverter
+//
+// Definition of the TextConverter class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_TextConverter_INCLUDED
+#define Foundation_TextConverter_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class TextEncoding;
+
+
+class Foundation_API TextConverter
+	/// A TextConverter converts strings from one encoding
+	/// into another.
+{
+public:
+	typedef int (*Transform)(int);
+		/// Transform function for convert.
+		
+	TextConverter(const TextEncoding& inEncoding, const TextEncoding& outEncoding, int defaultChar = '?');
+		/// Creates the TextConverter. The encoding objects must not be deleted while the
+		/// TextConverter is in use.
+
+	~TextConverter();
+		/// Destroys the TextConverter.
+		
+	int convert(const std::string& source, std::string& destination, Transform trans);
+		/// Converts the source string from inEncoding to outEncoding
+		/// and appends the result to destination. Every character is
+		/// passed to the transform function.
+		/// If a character cannot be represented in outEncoding, defaultChar
+		/// is used instead.
+		/// Returns the number of encoding errors (invalid byte sequences
+		/// in source).
+
+	int convert(const void* source, int length, std::string& destination, Transform trans);
+		/// Converts the source buffer from inEncoding to outEncoding
+		/// and appends the result to destination. Every character is
+		/// passed to the transform function.
+		/// If a character cannot be represented in outEncoding, defaultChar
+		/// is used instead.
+		/// Returns the number of encoding errors (invalid byte sequences
+		/// in source).
+
+	int convert(const std::string& source, std::string& destination);
+		/// Converts the source string from inEncoding to outEncoding
+		/// and appends the result to destination.
+		/// If a character cannot be represented in outEncoding, defaultChar
+		/// is used instead.
+		/// Returns the number of encoding errors (invalid byte sequences
+		/// in source).
+
+	int convert(const void* source, int length, std::string& destination);
+		/// Converts the source buffer from inEncoding to outEncoding
+		/// and appends the result to destination.
+		/// If a character cannot be represented in outEncoding, defaultChar
+		/// is used instead.
+		/// Returns the number of encoding errors (invalid byte sequences
+		/// in source).
+
+private:
+	TextConverter();
+	TextConverter(const TextConverter&);
+	TextConverter& operator = (const TextConverter&);
+
+	const TextEncoding& _inEncoding;
+	const TextEncoding& _outEncoding;
+	int                 _defaultChar;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_TextConverter_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/TextEncoding.h b/base/poco/Foundation/include/Poco/TextEncoding.h
new file mode 100644
index 00000000000..40d64b7c933
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/TextEncoding.h
@@ -0,0 +1,185 @@
+//
+// TextEncoding.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  TextEncoding
+//
+// Definition of the abstract TextEncoding class.
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_TextEncoding_INCLUDED
+#define Foundation_TextEncoding_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/SharedPtr.h"
+
+
+namespace Poco {
+
+
+class TextEncodingManager;
+
+
+class Foundation_API TextEncoding
+	/// An abstract base class for implementing text encodings
+	/// like UTF-8 or ISO 8859-1.
+	///
+	/// Subclasses must override the canonicalName(), isA(),
+	/// characterMap() and convert() methods and need to be
+	/// thread safe and stateless.
+	///
+	/// TextEncoding also provides static member functions
+	/// for managing mappings from encoding names to
+	/// TextEncoding objects.
+{
+public:
+	typedef SharedPtr<TextEncoding> Ptr;
+
+	enum
+	{
+		MAX_SEQUENCE_LENGTH = 4 /// The maximum character byte sequence length supported.
+	};
+
+	typedef int CharacterMap[256];
+		/// The map[b] member gives information about byte sequences
+		/// whose first byte is b.
+		/// If map[b] is c where c is >= 0, then b by itself encodes the Unicode scalar value c.
+		/// If map[b] is -1, then the byte sequence is malformed.
+		/// If map[b] is -n, where n >= 2, then b is the first byte of an n-byte
+		/// sequence that encodes a single Unicode scalar value. Byte sequences up
+		/// to 4 bytes in length are supported.
+
+	virtual ~TextEncoding();
+		/// Destroys the encoding.
+
+	virtual const char* canonicalName() const = 0;
+		/// Returns the canonical name of this encoding,
+		/// e.g. "ISO-8859-1". Encoding name comparisons are case
+		/// insensitive.
+
+	virtual bool isA(const std::string& encodingName) const = 0;
+		/// Returns true if the given name is one of the names of this encoding.
+		/// For example, the "ISO-8859-1" encoding is also known as "Latin-1".
+		///
+		/// Encoding name comparisions are case insensitive.
+
+	virtual const CharacterMap& characterMap() const = 0;
+		/// Returns the CharacterMap for the encoding.
+		/// The CharacterMap should be kept in a static member. As
+		/// characterMap() can be called frequently, it should be
+		/// implemented in such a way that it just returns a static
+		/// map. If the map is built at runtime, this should be
+		/// done in the constructor.
+
+	virtual int convert(const unsigned char* bytes) const;
+		/// The convert function is used to convert multibyte sequences;
+		/// bytes will point to a byte sequence of n bytes where
+		/// sequenceLength(bytes, length) == -n, with length >= n.
+		///
+		/// The convert function must return the Unicode scalar value
+		/// represented by this byte sequence or -1 if the byte sequence is malformed.
+		///
+		/// The default implementation returns (int) bytes[0].
+
+	virtual	int queryConvert(const unsigned char* bytes, int length) const;
+		/// The queryConvert function is used to convert single byte characters
+		/// or multibyte sequences;
+		/// bytes will point to a byte sequence of length bytes.
+		///
+		/// The queryConvert function must return the Unicode scalar value
+		/// represented by this byte sequence or -1 if the byte sequence is malformed
+		/// or -n where n is number of bytes requested for the sequence, if length is
+		/// shorter than the sequence.
+		/// The length of the sequence might not be determined by the first byte,
+		/// in which case the conversion becomes an iterative process:
+		/// First call with length == 1 might return -2,
+		/// Then a second call with length == 2 might return -4
+		/// Eventually, the third call with length == 4 should return either a
+		/// Unicode scalar value, or -1 if the byte sequence is malformed.
+		///
+		/// The default implementation returns (int) bytes[0].
+
+	virtual int sequenceLength(const unsigned char* bytes, int length) const;
+		/// The sequenceLength function is used to get the lenth of the sequence pointed
+		/// by bytes. The length parameter should be greater or equal to the length of
+		/// the sequence.
+		///
+		/// The sequenceLength function must return the length of the sequence
+		/// represented by this byte sequence or a negative value -n if length is
+		/// shorter than the sequence, where n is the number of byte requested
+		/// to determine the length of the sequence.
+		/// The length of the sequence might not be determined by the first byte,
+		/// in which case the conversion becomes an iterative process as long as the
+		/// result is negative:
+		/// First call with length == 1 might return -2,
+		/// Then a second call with length == 2 might return -4
+		/// Eventually, the third call with length == 4 should return 4.
+		/// The default implementation returns 1.
+
+	virtual int convert(int ch, unsigned char* bytes, int length) const;
+		/// Transform the Unicode character ch into the encoding's
+		/// byte sequence. The method returns the number of bytes
+		/// used. The method must not use more than length characters.
+		/// Bytes and length can also be null - in this case only the number
+		/// of bytes required to represent ch is returned.
+		/// If the character cannot be converted, 0 is returned and
+		/// the byte sequence remains unchanged.
+		/// The default implementation simply returns 0.
+
+	static TextEncoding& byName(const std::string& encodingName);
+		/// Returns the TextEncoding object for the given encoding name.
+		///
+		/// Throws a NotFoundException if the encoding with given name is not available.
+
+	static TextEncoding::Ptr find(const std::string& encodingName);
+		/// Returns a pointer to the TextEncoding object for the given encodingName,
+		/// or NULL if no such TextEncoding object exists.
+
+	static void add(TextEncoding::Ptr encoding);
+		/// Adds the given TextEncoding to the table of text encodings,
+		/// under the encoding's canonical name.
+		///
+		/// If an encoding with the given name is already registered,
+		/// it is replaced.
+
+	static void add(TextEncoding::Ptr encoding, const std::string& name);
+		/// Adds the given TextEncoding to the table of text encodings,
+		/// under the given name.
+		///
+		/// If an encoding with the given name is already registered,
+		/// it is replaced.
+
+	static void remove(const std::string& encodingName);
+		/// Removes the encoding with the given name from the table
+		/// of text encodings.
+
+	static TextEncoding::Ptr global(TextEncoding::Ptr encoding);
+		/// Sets global TextEncoding object.
+		///
+		/// This function sets the global encoding to the argument and returns a
+		/// reference of the previous global encoding.
+
+	static TextEncoding& global();
+		/// Return the current global TextEncoding object
+
+	static const std::string GLOBAL;
+		/// Name of the global TextEncoding, which is the empty string.
+
+protected:
+	static TextEncodingManager& manager();
+		/// Returns the TextEncodingManager.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_TextEncoding_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/TextIterator.h b/base/poco/Foundation/include/Poco/TextIterator.h
new file mode 100644
index 00000000000..17f48a4ab11
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/TextIterator.h
@@ -0,0 +1,141 @@
+//
+// TextIterator.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  TextIterator
+//
+// Definition of the TextIterator class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_TextIterator_INCLUDED
+#define Foundation_TextIterator_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class TextEncoding;
+
+
+class Foundation_API TextIterator
+	/// An unidirectional iterator for iterating over characters in a string.
+	/// The TextIterator uses a TextEncoding object to
+	/// work with multi-byte character encodings like UTF-8.
+	/// Characters are reported in Unicode.
+	///
+	/// Example: Count the number of UTF-8 characters in a string.
+	///
+	///     UTF8Encoding utf8Encoding;
+	///     std::string utf8String("....");
+	///     TextIterator it(utf8String, utf8Encoding);
+	///     TextIterator end(utf8String);
+	///     int n = 0;
+	///     while (it != end) { ++n; ++it; }
+	///
+	/// NOTE: When an UTF-16 encoding is used, surrogate pairs will be
+	/// reported as two separate characters, due to restrictions of
+	/// the TextEncoding class.
+	///
+	/// For iterating over char buffers, see the TextBufferIterator class.
+{
+public:
+	TextIterator();
+		/// Creates an uninitialized TextIterator.
+		
+	TextIterator(const std::string& str, const TextEncoding& encoding);
+		/// Creates a TextIterator for the given string.
+		/// The encoding object must not be deleted as long as the iterator
+		/// is in use.
+
+	TextIterator(const std::string::const_iterator& begin, const std::string::const_iterator& end, const TextEncoding& encoding);
+		/// Creates a TextIterator for the given range.
+		/// The encoding object must not be deleted as long as the iterator
+		/// is in use.
+
+	TextIterator(const std::string& str);
+		/// Creates an end TextIterator for the given string.
+
+	TextIterator(const std::string::const_iterator& end);
+		/// Creates an end TextIterator.
+
+	~TextIterator();
+		/// Destroys the TextIterator.
+	
+	TextIterator(const TextIterator& it);
+		/// Copy constructor.
+	
+	TextIterator& operator = (const TextIterator& it);
+		/// Assignment operator.
+		
+	void swap(TextIterator& it);
+		/// Swaps the iterator with another one.
+	
+	int operator * () const;
+		/// Returns the Unicode value of the current character.
+		/// If there is no valid character at the current position,
+		/// -1 is returned.
+		
+	TextIterator& operator ++ (); 
+		/// Prefix increment operator.
+
+	TextIterator operator ++ (int);		
+		/// Postfix increment operator.
+
+	bool operator == (const TextIterator& it) const;
+		/// Compares two iterators for equality.
+		
+	bool operator != (const TextIterator& it) const;
+		/// Compares two iterators for inequality.
+		
+	TextIterator end() const;
+		/// Returns the end iterator for the range handled
+		/// by the iterator.
+		
+private:
+	const TextEncoding*         _pEncoding;
+	std::string::const_iterator _it;
+	std::string::const_iterator _end;
+};
+
+
+//
+// inlines
+//
+inline bool TextIterator::operator == (const TextIterator& it) const
+{
+	return _it == it._it;
+}
+
+
+inline bool TextIterator::operator != (const TextIterator& it) const
+{
+	return _it != it._it;
+}
+
+
+inline void swap(TextIterator& it1, TextIterator& it2)
+{
+	it1.swap(it2);
+}
+
+
+inline TextIterator TextIterator::end() const
+{
+	return TextIterator(_end);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_TextIterator_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Thread.h b/base/poco/Foundation/include/Poco/Thread.h
new file mode 100644
index 00000000000..bfd6f031fd2
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Thread.h
@@ -0,0 +1,367 @@
+//
+// Thread.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Thread
+//
+// Definition of the Thread class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Thread_INCLUDED
+#define Foundation_Thread_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Event.h"
+#include "Poco/Mutex.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#if defined(_WIN32_WCE)
+#include "Poco/Thread_WINCE.h"
+#else
+#include "Poco/Thread_WIN32.h"
+#endif
+#elif defined(POCO_VXWORKS)
+#include "Poco/Thread_VX.h"
+#else
+#include "Poco/Thread_POSIX.h"
+#endif
+
+
+namespace Poco {
+
+
+class Runnable;
+class ThreadLocalStorage;
+
+
+class Foundation_API Thread: private ThreadImpl
+	/// This class implements a platform-independent
+	/// wrapper to an operating system thread.
+	///
+	/// Every Thread object gets a unique (within
+	/// its process) numeric thread ID.
+	/// Furthermore, a thread can be assigned a name.
+	/// The name of a thread can be changed at any time.
+{
+public:	
+	typedef ThreadImpl::TIDImpl TID;
+
+	using ThreadImpl::Callable;
+
+	enum Priority
+		/// Thread priorities.
+	{
+		PRIO_LOWEST  = PRIO_LOWEST_IMPL, /// The lowest thread priority.
+		PRIO_LOW     = PRIO_LOW_IMPL,    /// A lower than normal thread priority.
+		PRIO_NORMAL  = PRIO_NORMAL_IMPL, /// The normal thread priority.
+		PRIO_HIGH    = PRIO_HIGH_IMPL,   /// A higher than normal thread priority.
+		PRIO_HIGHEST = PRIO_HIGHEST_IMPL /// The highest thread priority.
+	};
+	
+	enum Policy
+	{
+		POLICY_DEFAULT = POLICY_DEFAULT_IMPL
+	};
+
+	Thread();
+		/// Creates a thread. Call start() to start it.
+		
+	Thread(const std::string& name);
+		/// Creates a named thread. Call start() to start it.
+		
+	~Thread();
+		/// Destroys the thread.
+
+	int id() const;
+		/// Returns the unique thread ID of the thread.
+
+	TID tid() const;
+		/// Returns the native thread ID of the thread.
+
+	std::string name() const;
+		/// Returns the name of the thread.
+
+	std::string getName() const;
+		/// Returns the name of the thread.
+
+	void setName(const std::string& name);
+		/// Sets the name of the thread.
+
+	void setPriority(Priority prio);
+		/// Sets the thread's priority.
+		///
+		/// Some platform only allow changing a thread's priority
+		/// if the process has certain privileges.
+
+	Priority getPriority() const;
+		/// Returns the thread's priority.
+
+	void setOSPriority(int prio, int policy = POLICY_DEFAULT);
+		/// Sets the thread's priority, using an operating system specific
+		/// priority value. Use getMinOSPriority() and getMaxOSPriority() to
+		/// obtain mininum and maximum priority values. Additionally,
+		/// a scheduling policy can be specified. The policy is currently
+		/// only used on POSIX platforms where the values SCHED_OTHER (default),
+		/// SCHED_FIFO and SCHED_RR are supported.
+		
+	int getOSPriority() const;
+		/// Returns the thread's priority, expressed as an operating system
+		/// specific priority value.
+		///
+		/// May return 0 if the priority has not been explicitly set.
+		
+	static int getMinOSPriority(int policy = POLICY_DEFAULT);
+		/// Returns the minimum operating system-specific priority value,
+		/// which can be passed to setOSPriority() for the given policy.
+		
+	static int getMaxOSPriority(int policy = POLICY_DEFAULT);
+		/// Returns the maximum operating system-specific priority value,
+		/// which can be passed to setOSPriority() for the given policy.
+
+	void setStackSize(int size);
+		/// Sets the thread's stack size in bytes.
+		/// Setting the stack size to 0 will use the default stack size.
+		/// Typically, the real stack size is rounded up to the nearest
+		/// page size multiple.
+
+	int getStackSize() const;
+		/// Returns the thread's stack size in bytes.
+		/// If the default stack size is used, 0 is returned.
+
+	void start(Runnable& target);
+		/// Starts the thread with the given target.
+		///
+		/// Note that the given Runnable object must remain
+		/// valid during the entire lifetime of the thread, as
+		/// only a reference to it is stored internally.
+
+	void start(Callable target, void* pData = 0);
+		/// Starts the thread with the given target and parameter.
+
+	template <class Functor>
+	void startFunc(Functor fn)
+		/// Starts the thread with the given functor object or lambda.
+	{
+		startImpl(new FunctorRunnable<Functor>(fn));
+	}
+
+	void join();
+		/// Waits until the thread completes execution.	
+		/// If multiple threads try to join the same
+		/// thread, the result is undefined.
+		
+	void join(long milliseconds);
+		/// Waits for at most the given interval for the thread
+		/// to complete. Throws a TimeoutException if the thread
+		/// does not complete within the specified time interval.
+		
+	bool tryJoin(long milliseconds);
+		/// Waits for at most the given interval for the thread
+		/// to complete. Returns true if the thread has finished,
+		/// false otherwise.
+
+	bool isRunning() const;
+		/// Returns true if the thread is running.
+
+	static bool trySleep(long milliseconds);
+		/// Starts an interruptible sleep. When trySleep() is called,
+		/// the thread will remain suspended until:
+		///   - the timeout expires or 
+		///   - wakeUp() is called
+		/// 
+		/// Function returns true if sleep attempt was completed, false
+		/// if sleep was interrupted by a wakeUp() call.
+		/// A frequent scenario where trySleep()/wakeUp() pair of functions
+		/// is useful is with threads spending most of the time idle,
+		/// with periodic activity between the idle times; trying to sleep
+		/// (as opposed to sleeping) allows immediate ending of idle thread
+		/// from the outside.
+		/// 
+		/// The trySleep() and wakeUp() calls should be used with 
+		/// understanding that the suspended state is not a true sleep, 
+		/// but rather a state of waiting for an event, with timeout 
+		/// expiration. This makes order of calls significant; calling 
+		/// wakeUp() before calling trySleep() will prevent the next  
+		/// trySleep() call to actually suspend the thread (which, in 
+		/// some scenarios, may be desirable behavior).
+
+	void wakeUp();
+		/// Wakes up the thread which is in the state of interruptible
+		/// sleep. For threads that are not suspended, calling this
+		/// function has the effect of preventing the subsequent
+		/// trySleep() call to put thread in a suspended state.
+
+	static void sleep(long milliseconds);
+		/// Suspends the current thread for the specified
+		/// amount of time.
+
+	static void yield();
+		/// Yields cpu to other threads.
+
+	static Thread* current();
+		/// Returns the Thread object for the currently active thread.
+		/// If the current thread is the main thread, 0 is returned.
+
+ 	static TID currentTid();
+ 		/// Returns the native thread ID for the current thread.    
+
+protected:
+	ThreadLocalStorage& tls();
+		/// Returns a reference to the thread's local storage.
+
+	void clearTLS();
+		/// Clears the thread's local storage.
+
+	std::string makeName();
+		/// Creates a unique name for a thread.
+		
+	static int uniqueId();
+		/// Creates and returns a unique id for a thread.
+
+	template <class Functor>
+	class FunctorRunnable: public Runnable
+	{
+	public:
+		FunctorRunnable(const Functor& functor):
+			_functor(functor)
+		{
+		}
+
+		~FunctorRunnable()
+		{
+		}
+
+		void run()
+		{
+			_functor();
+		}
+	
+	private:
+		Functor _functor;
+	};
+
+private:
+	Thread(const Thread&);
+	Thread& operator = (const Thread&);
+
+	int                 _id;
+	std::string         _name;
+	ThreadLocalStorage* _pTLS;
+	Event               _event;
+	mutable FastMutex   _mutex;
+
+	friend class ThreadLocalStorage;
+	friend class PooledThread;
+};
+
+
+//
+// inlines
+//
+inline Thread::TID Thread::tid() const
+{
+	return tidImpl();
+}
+
+
+inline int Thread::id() const
+{
+	return _id;
+}
+
+
+inline std::string Thread::name() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	return _name;
+}
+
+
+inline std::string Thread::getName() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	return _name;
+}
+
+
+inline bool Thread::isRunning() const
+{
+	return isRunningImpl();
+}
+
+
+inline void Thread::sleep(long milliseconds)
+{
+	sleepImpl(milliseconds);
+}
+
+
+inline void Thread::yield()
+{
+	yieldImpl();
+}
+
+
+inline Thread* Thread::current()
+{
+	return static_cast<Thread*>(currentImpl());
+}
+
+
+inline void Thread::setOSPriority(int prio, int policy)
+{
+	setOSPriorityImpl(prio, policy);	
+}
+
+	
+inline int Thread::getOSPriority() const
+{
+	return getOSPriorityImpl();
+}
+
+	
+inline int Thread::getMinOSPriority(int policy)
+{
+	return ThreadImpl::getMinOSPriorityImpl(policy);
+}
+
+	
+inline int Thread::getMaxOSPriority(int policy)
+{
+	return ThreadImpl::getMaxOSPriorityImpl(policy);
+}
+
+
+inline void Thread::setStackSize(int size)
+{
+	setStackSizeImpl(size);
+}
+
+
+inline int Thread::getStackSize() const
+{
+	return getStackSizeImpl();
+}
+
+
+inline Thread::TID Thread::currentTid()
+{
+	return currentTidImpl();
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Thread_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ThreadLocal.h b/base/poco/Foundation/include/Poco/ThreadLocal.h
new file mode 100644
index 00000000000..cea17d5c12e
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ThreadLocal.h
@@ -0,0 +1,157 @@
+//
+// ThreadLocal.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Thread
+//
+// Definition of the ThreadLocal template and related classes.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ThreadLocal_INCLUDED
+#define Foundation_ThreadLocal_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <map>
+
+
+namespace Poco {
+
+
+class Foundation_API TLSAbstractSlot
+	/// This is the base class for all objects
+	/// that the ThreadLocalStorage class manages.
+{
+public:
+	TLSAbstractSlot();
+	virtual ~TLSAbstractSlot();
+};
+
+
+template <class C>
+class TLSSlot: public TLSAbstractSlot
+	/// The Slot template wraps another class
+	/// so that it can be stored in a ThreadLocalStorage
+	/// object. This class is used internally, and you
+	/// must not create instances of it yourself.
+{
+public:
+	TLSSlot():
+		_value()
+	{
+	}
+	
+	~TLSSlot()
+	{
+	}
+	
+	C& value()
+	{
+		return _value;
+	}
+	
+private:
+	TLSSlot(const TLSSlot&);
+	TLSSlot& operator = (const TLSSlot&);
+
+	C _value;
+};
+
+
+class Foundation_API ThreadLocalStorage
+	/// This class manages the local storage for each thread.
+	/// Never use this class directly, always use the
+	/// ThreadLocal template for managing thread local storage.
+{
+public:
+	ThreadLocalStorage();
+		/// Creates the TLS.
+		
+	~ThreadLocalStorage();
+		/// Deletes the TLS.
+
+	TLSAbstractSlot*& get(const void* key);
+		/// Returns the slot for the given key.
+		
+	static ThreadLocalStorage& current();
+		/// Returns the TLS object for the current thread
+		/// (which may also be the main thread).
+		
+	static void clear();
+		/// Clears the current thread's TLS object.
+		/// Does nothing in the main thread.
+	
+private:
+	typedef std::map<const void*, TLSAbstractSlot*> TLSMap;
+	
+	TLSMap _map;
+
+	friend class Thread;
+};
+
+
+template <class C>
+class ThreadLocal
+	/// This template is used to declare type safe thread
+	/// local variables. It can basically be used like
+	/// a smart pointer class with the special feature
+	/// that it references a different object
+	/// in every thread. The underlying object will
+	/// be created when it is referenced for the first
+	/// time.
+	/// See the NestedDiagnosticContext class for an
+	/// example how to use this template.
+	/// Every thread only has access to its own
+	/// thread local data. There is no way for a thread
+	/// to access another thread's local data.
+{
+	typedef TLSSlot<C> Slot;
+
+public:
+	ThreadLocal()
+	{
+	}
+	
+	~ThreadLocal()
+	{
+	}
+	
+	C* operator -> ()
+	{
+		return &get();
+	}
+	
+	C& operator * ()
+		/// "Dereferences" the smart pointer and returns a reference
+		/// to the underlying data object. The reference can be used
+		/// to modify the object.
+	{
+		return get();
+	}
+
+	C& get()
+		/// Returns a reference to the underlying data object.
+		/// The reference can be used to modify the object.
+	{
+		TLSAbstractSlot*& p = ThreadLocalStorage::current().get(this);
+		if (!p) p = new Slot;
+		return static_cast<Slot*>(p)->value();
+	}
+	
+private:
+	ThreadLocal(const ThreadLocal&);
+	ThreadLocal& operator = (const ThreadLocal&);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ThreadLocal_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ThreadPool.h b/base/poco/Foundation/include/Poco/ThreadPool.h
new file mode 100644
index 00000000000..fa8bc6cf5c1
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ThreadPool.h
@@ -0,0 +1,208 @@
+//
+// ThreadPool.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  ThreadPool
+//
+// Definition of the ThreadPool class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ThreadPool_INCLUDED
+#define Foundation_ThreadPool_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Thread.h"
+#include "Poco/Mutex.h"
+#include <vector>
+
+
+namespace Poco {
+
+
+class Runnable;
+class PooledThread;
+
+
+class Foundation_API ThreadPool
+	/// A thread pool always keeps a number of threads running, ready
+	/// to accept work.
+	/// Creating and starting a threads can impose a significant runtime
+	/// overhead to an application. A thread pool helps to improve
+	/// the performance of an application by reducing the number
+	/// of threads that have to be created (and destroyed again).
+	/// Threads in a thread pool are re-used once they become
+	/// available again.
+	/// The thread pool always keeps a minimum number of threads
+	/// running. If the demans for threads increases, additional
+	/// threads are created. Once the demand for threads sinks
+	/// again, no-longer used threads are stopped and removed
+	/// from the pool.
+{
+public:
+	ThreadPool(int minCapacity = 2,
+		int maxCapacity = 16,
+		int idleTime = 60,
+		int stackSize = POCO_THREAD_STACK_SIZE);
+		/// Creates a thread pool with minCapacity threads.
+		/// If required, up to maxCapacity threads are created
+		/// a NoThreadAvailableException exception is thrown.
+		/// If a thread is running idle for more than idleTime seconds,
+		/// and more than minCapacity threads are running, the thread
+		/// is killed. Threads are created with given stack size.
+
+	ThreadPool(const std::string& name,
+		int minCapacity = 2,
+		int maxCapacity = 16,
+		int idleTime = 60,
+		int stackSize = POCO_THREAD_STACK_SIZE);
+		/// Creates a thread pool with the given name and minCapacity threads.
+		/// If required, up to maxCapacity threads are created
+		/// a NoThreadAvailableException exception is thrown.
+		/// If a thread is running idle for more than idleTime seconds,
+		/// and more than minCapacity threads are running, the thread
+		/// is killed. Threads are created with given stack size.
+
+	~ThreadPool();
+		/// Currently running threads will remain active
+		/// until they complete. 
+	
+	void addCapacity(int n);
+		/// Increases (or decreases, if n is negative)
+		/// the maximum number of threads.
+
+	int capacity() const;
+		/// Returns the maximum capacity of threads.
+
+	void setStackSize(int stackSize);
+		/// Sets the stack size for threads.
+		/// New stack size applies only for newly created threads.
+
+	int getStackSize() const;
+		/// Returns the stack size used to create new threads.
+
+	int used() const;
+		/// Returns the number of currently used threads.
+
+	int allocated() const;
+		/// Returns the number of currently allocated threads.
+
+	int available() const;
+		/// Returns the number available threads.
+
+	void start(Runnable& target);
+		/// Obtains a thread and starts the target.
+		/// Throws a NoThreadAvailableException if no more
+		/// threads are available.
+
+	void start(Runnable& target, const std::string& name);
+		/// Obtains a thread and starts the target.
+		/// Assigns the given name to the thread.
+		/// Throws a NoThreadAvailableException if no more
+		/// threads are available.
+
+	void startWithPriority(Thread::Priority priority, Runnable& target);
+		/// Obtains a thread, adjusts the thread's priority, and starts the target.
+		/// Throws a NoThreadAvailableException if no more
+		/// threads are available.
+
+	void startWithPriority(Thread::Priority priority, Runnable& target, const std::string& name);
+		/// Obtains a thread, adjusts the thread's priority, and starts the target.
+		/// Assigns the given name to the thread.
+		/// Throws a NoThreadAvailableException if no more
+		/// threads are available.
+
+	void stopAll();
+		/// Stops all running threads and waits for their completion.
+		///
+		/// Will also delete all thread objects.
+		/// If used, this method should be the last action before
+		/// the thread pool is deleted.
+		///
+		/// Note: If a thread fails to stop within 10 seconds 
+		/// (due to a programming error, for example), the
+		/// underlying thread object will not be deleted and
+		/// this method will return anyway. This allows for a
+		/// more or less graceful shutdown in case of a misbehaving
+		/// thread.
+
+	void joinAll();
+		/// Waits for all threads to complete.
+		///
+		/// Note that this will not actually join() the underlying
+		/// thread, but rather wait for the thread's runnables
+		/// to finish.
+
+	void collect();
+		/// Stops and removes no longer used threads from the
+		/// thread pool. Can be called at various times in an
+		/// application's life time to help the thread pool
+		/// manage its threads. Calling this method is optional,
+		/// as the thread pool is also implicitly managed in
+		/// calls to start(), addCapacity() and joinAll().
+
+	const std::string& name() const;
+		/// Returns the name of the thread pool,
+		/// or an empty string if no name has been
+		/// specified in the constructor.
+
+	static ThreadPool& defaultPool();
+		/// Returns a reference to the default
+		/// thread pool.
+
+protected:
+	PooledThread* getThread();
+	PooledThread* createThread();
+
+	void housekeep();
+
+private:
+	ThreadPool(const ThreadPool& pool);
+	ThreadPool& operator = (const ThreadPool& pool);
+
+	typedef std::vector<PooledThread*> ThreadVec;
+
+	std::string _name;
+	int _minCapacity;
+	int _maxCapacity;
+	int _idleTime;
+	int _serial;
+	int _age;
+	int _stackSize;
+	ThreadVec _threads;
+	mutable FastMutex _mutex;
+};
+
+
+//
+// inlines
+//
+inline void ThreadPool::setStackSize(int stackSize)
+{
+	_stackSize = stackSize;
+}
+
+
+inline int ThreadPool::getStackSize() const
+{
+	return _stackSize;
+}
+
+
+inline const std::string& ThreadPool::name() const
+{
+	return _name;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ThreadPool_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ThreadTarget.h b/base/poco/Foundation/include/Poco/ThreadTarget.h
new file mode 100644
index 00000000000..88452694c9a
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ThreadTarget.h
@@ -0,0 +1,87 @@
+//
+// ThreadTarget.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  ThreadTarget
+//
+// Definition of the ThreadTarget class.
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ThreadTarget_INCLUDED
+#define Foundation_ThreadTarget_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Runnable.h"
+
+
+namespace Poco {
+
+
+class Foundation_API ThreadTarget: public Runnable
+	/// This adapter simplifies using static member functions as well as 
+	/// standalone functions as targets for threads.
+	/// Note that it is possible to pass those entities directly to Thread::start().
+	/// This adapter is provided as a convenience for higher abstraction level
+	/// scenarios where Runnable abstract class is used.
+	///
+	/// For using a non-static member function as a thread target, please
+	/// see the RunnableAdapter class.
+	/// 
+	/// Usage:
+	///    class MyObject
+	///    {
+	///        static void doSomething() {}
+	///    };
+	///    ThreadTarget ra(&MyObject::doSomething);
+	///    Thread thr;
+	///    thr.start(ra);
+	///
+	/// or:
+	/// 
+	///    void doSomething() {}
+	/// 
+	///    ThreadTarget ra(doSomething);
+	///    Thread thr;
+	///    thr.start(ra);
+{
+public:
+	typedef void (*Callback)();
+	
+	ThreadTarget(Callback method);
+	
+	ThreadTarget(const ThreadTarget& te);
+
+	~ThreadTarget();
+
+	ThreadTarget& operator = (const ThreadTarget& te);
+
+	void run();
+	
+private:
+	ThreadTarget();
+
+	Callback _method;
+};
+
+
+//
+// inlines
+//
+inline void ThreadTarget::run()
+{
+	_method();
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ThreadTarget_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Thread_POSIX.h b/base/poco/Foundation/include/Poco/Thread_POSIX.h
new file mode 100644
index 00000000000..6b70907ed6c
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Thread_POSIX.h
@@ -0,0 +1,198 @@
+//
+// Thread_POSIX.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Thread
+//
+// Definition of the ThreadImpl class for POSIX Threads.
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Thread_POSIX_INCLUDED
+#define Foundation_Thread_POSIX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Runnable.h"
+#include "Poco/SignalHandler.h"
+#include "Poco/Event.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include "Poco/SharedPtr.h"
+#include <pthread.h>
+// must be limits.h (not <climits>) for PTHREAD_STACK_MIN on Solaris
+#include <limits.h>
+#if !defined(POCO_NO_SYS_SELECT_H)
+#include <sys/select.h>
+#endif
+#include <errno.h>
+#if defined(POCO_VXWORKS)
+#include <cstring>
+#endif
+
+
+namespace Poco {
+
+
+class Foundation_API ThreadImpl
+{
+public:
+	typedef pthread_t TIDImpl;
+	typedef void (*Callable)(void*);
+
+	enum Priority
+	{
+		PRIO_LOWEST_IMPL,
+		PRIO_LOW_IMPL,
+		PRIO_NORMAL_IMPL,
+		PRIO_HIGH_IMPL,
+		PRIO_HIGHEST_IMPL
+	};
+
+	enum Policy
+	{
+		POLICY_DEFAULT_IMPL = SCHED_OTHER
+	};
+	
+	ThreadImpl();
+	~ThreadImpl();
+
+	TIDImpl tidImpl() const;
+	void setPriorityImpl(int prio);
+	int getPriorityImpl() const;
+	void setOSPriorityImpl(int prio, int policy = SCHED_OTHER);
+	int getOSPriorityImpl() const;
+	static int getMinOSPriorityImpl(int policy);
+	static int getMaxOSPriorityImpl(int policy);
+	void setStackSizeImpl(int size);
+	int getStackSizeImpl() const;
+	void startImpl(SharedPtr<Runnable> pTarget);
+	void joinImpl();
+	bool joinImpl(long milliseconds);
+	bool isRunningImpl() const;
+	static void sleepImpl(long milliseconds);
+	static void yieldImpl();
+	static ThreadImpl* currentImpl();
+	static TIDImpl currentTidImpl();
+
+protected:
+	static void* runnableEntry(void* pThread);
+	static int mapPrio(int prio, int policy = SCHED_OTHER);
+	static int reverseMapPrio(int osPrio, int policy = SCHED_OTHER);
+
+private:
+	class CurrentThreadHolder
+	{
+	public:
+		CurrentThreadHolder()
+		{
+			if (pthread_key_create(&_key, NULL))
+				throw SystemException("cannot allocate thread context key");
+		}
+		~CurrentThreadHolder()
+		{
+			pthread_key_delete(_key);
+		}
+		ThreadImpl* get() const
+		{
+			return reinterpret_cast<ThreadImpl*>(pthread_getspecific(_key));
+		}
+		void set(ThreadImpl* pThread)
+		{
+			pthread_setspecific(_key, pThread);
+		}
+
+	private:
+		pthread_key_t _key;
+	};
+
+	struct ThreadData: public RefCountedObject
+	{
+		ThreadData():
+			thread(0),
+			prio(PRIO_NORMAL_IMPL),
+			osPrio(),
+			policy(SCHED_OTHER),
+			done(false),
+			stackSize(POCO_THREAD_STACK_SIZE),
+			started(false),
+			joined(false)
+		{
+		#if defined(POCO_VXWORKS)
+			// This workaround is for VxWorks 5.x where
+			// pthread_init() won't properly initialize the thread.
+			std::memset(&thread, 0, sizeof(thread));
+		#endif
+		}
+
+		SharedPtr<Runnable> pRunnableTarget;
+		pthread_t     thread;
+		int           prio;
+		int           osPrio;
+		int           policy;
+		Event         done;
+		std::size_t   stackSize;
+		bool          started;
+		bool          joined;
+	};
+
+	AutoPtr<ThreadData> _pData;
+
+	static CurrentThreadHolder _currentThreadHolder;
+	
+#if defined(POCO_OS_FAMILY_UNIX) && !defined(POCO_VXWORKS)
+	SignalHandler::JumpBufferVec _jumpBufferVec;
+	friend class SignalHandler;
+#endif
+};
+
+
+//
+// inlines
+//
+inline int ThreadImpl::getPriorityImpl() const
+{
+	return _pData->prio;
+}
+
+
+inline int ThreadImpl::getOSPriorityImpl() const
+{
+	return _pData->osPrio;
+}
+
+
+inline bool ThreadImpl::isRunningImpl() const
+{
+	return !_pData->pRunnableTarget.isNull();
+}
+
+
+inline void ThreadImpl::yieldImpl()
+{
+	sched_yield();
+}
+
+
+inline int ThreadImpl::getStackSizeImpl() const
+{
+	return static_cast<int>(_pData->stackSize);
+}
+
+
+inline ThreadImpl::TIDImpl ThreadImpl::tidImpl() const
+{
+	return _pData->thread;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Thread_POSIX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Thread_VX.h b/base/poco/Foundation/include/Poco/Thread_VX.h
new file mode 100644
index 00000000000..a6dad9d1f76
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Thread_VX.h
@@ -0,0 +1,169 @@
+//
+// Thread_VX.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Thread
+//
+// Definition of the ThreadImpl class for VxWorks tasks.
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Thread_VX_INCLUDED
+#define Foundation_Thread_VX_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Runnable.h"
+#include "Poco/SignalHandler.h"
+#include "Poco/Event.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include <taskLib.h>
+#include <taskVarLib.h>
+
+
+namespace Poco {
+
+
+class Foundation_API ThreadImpl
+{
+public:	
+	typedef int TIDImpl;
+	typedef void (*Callable)(void*);
+
+	enum Priority
+	{
+		PRIO_LOWEST_IMPL,
+		PRIO_LOW_IMPL,
+		PRIO_NORMAL_IMPL,
+		PRIO_HIGH_IMPL,
+		PRIO_HIGHEST_IMPL
+	};
+
+	enum Policy
+	{
+		POLICY_DEFAULT_IMPL = 0
+	};
+
+	enum
+	{
+		DEFAULT_THREAD_STACK_SIZE = 65536
+	};
+
+	struct CallbackData: public RefCountedObject
+	{
+		CallbackData(): callback(0), pData(0)
+		{
+		}
+
+		Callable  callback;
+		void*     pData; 
+	};
+
+	ThreadImpl();
+	~ThreadImpl();
+
+	TIDImpl tidImpl() const;
+	void setPriorityImpl(int prio);
+	int getPriorityImpl() const;
+	void setOSPriorityImpl(int prio, int policy = 0);
+	int getOSPriorityImpl() const;
+	static int getMinOSPriorityImpl(int policy);
+	static int getMaxOSPriorityImpl(int policy);
+	void setStackSizeImpl(int size);
+	int getStackSizeImpl() const;
+	void startImpl(Runnable& target);
+	void startImpl(Callable target, void* pData = 0);
+
+	void joinImpl();
+	bool joinImpl(long milliseconds);
+	bool isRunningImpl() const;
+	static void sleepImpl(long milliseconds);
+	static void yieldImpl();
+	static ThreadImpl* currentImpl();
+	static TIDImpl currentTidImpl();
+
+protected:
+	static void runnableEntry(void* pThread, int, int, int, int, int, int, int, int, int);
+	static void callableEntry(void* pThread, int, int, int, int, int, int, int, int, int);
+	static int mapPrio(int prio);
+	static int reverseMapPrio(int osPrio);
+
+	struct ThreadData: public RefCountedObject
+	{
+		ThreadData():
+			pRunnableTarget(0),
+			pCallbackTarget(0),
+			task(0),
+			prio(PRIO_NORMAL_IMPL),
+			osPrio(127),
+			done(false),
+			stackSize(POCO_THREAD_STACK_SIZE)
+		{
+		}
+
+		Runnable* pRunnableTarget;
+		AutoPtr<CallbackData> pCallbackTarget;
+		int       task;
+		int       prio;
+		int       osPrio;
+		Event     done;
+		int       stackSize;
+	};
+
+private:
+	AutoPtr<ThreadData> _pData;
+	static ThreadImpl* _pCurrent;
+};
+
+
+//
+// inlines
+//
+inline int ThreadImpl::getPriorityImpl() const
+{
+	return _pData->prio;
+}
+
+
+inline int ThreadImpl::getOSPriorityImpl() const
+{
+	return _pData->osPrio;
+}
+
+
+inline bool ThreadImpl::isRunningImpl() const
+{
+	return _pData->pRunnableTarget != 0 ||
+		(_pData->pCallbackTarget.get() != 0 && _pData->pCallbackTarget->callback != 0);
+}
+
+
+inline void ThreadImpl::yieldImpl()
+{
+	taskDelay(0);
+}
+
+
+inline int ThreadImpl::getStackSizeImpl() const
+{
+	return _pData->stackSize;
+}
+
+
+inline ThreadImpl::TIDImpl ThreadImpl::tidImpl() const
+{
+	return _pData->task;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Thread_VX_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Thread_WIN32.h b/base/poco/Foundation/include/Poco/Thread_WIN32.h
new file mode 100644
index 00000000000..194b0a3b70d
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Thread_WIN32.h
@@ -0,0 +1,183 @@
+//
+// Thread_WIN32.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Thread
+//
+// Definition of the ThreadImpl class for WIN32.
+//
+// Copyright (c) 2004-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Thread_WIN32_INCLUDED
+#define Foundation_Thread_WIN32_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Runnable.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API ThreadImpl
+{
+public:	
+	typedef DWORD TIDImpl;
+	typedef void (*Callable)(void*);
+
+#if defined(_DLL)
+	typedef DWORD (WINAPI *Entry)(LPVOID);
+#else
+	typedef unsigned (__stdcall *Entry)(void*);
+#endif
+
+	enum Priority
+	{
+		PRIO_LOWEST_IMPL  = THREAD_PRIORITY_LOWEST,
+		PRIO_LOW_IMPL     = THREAD_PRIORITY_BELOW_NORMAL,
+		PRIO_NORMAL_IMPL  = THREAD_PRIORITY_NORMAL,
+		PRIO_HIGH_IMPL    = THREAD_PRIORITY_ABOVE_NORMAL,
+		PRIO_HIGHEST_IMPL = THREAD_PRIORITY_HIGHEST
+	};
+
+	enum Policy
+	{
+		POLICY_DEFAULT_IMPL = 0
+	};
+
+	ThreadImpl();				
+	~ThreadImpl();
+
+	TIDImpl tidImpl() const;
+	void setPriorityImpl(int prio);
+	int getPriorityImpl() const;
+	void setOSPriorityImpl(int prio, int policy = 0);
+	int getOSPriorityImpl() const;
+	static int getMinOSPriorityImpl(int policy);
+	static int getMaxOSPriorityImpl(int policy);
+	void setStackSizeImpl(int size);
+	int getStackSizeImpl() const;
+	void startImpl(SharedPtr<Runnable> pTarget);
+	void joinImpl();
+	bool joinImpl(long milliseconds);
+	bool isRunningImpl() const;
+	static void sleepImpl(long milliseconds);
+	static void yieldImpl();
+	static ThreadImpl* currentImpl();
+	static TIDImpl currentTidImpl();
+    
+protected:
+#if defined(_DLL)
+	static DWORD WINAPI runnableEntry(LPVOID pThread);
+#else
+	static unsigned __stdcall runnableEntry(void* pThread);
+#endif
+
+	void createImpl(Entry ent, void* pData);
+	void threadCleanup();
+
+private:
+	class CurrentThreadHolder
+	{
+	public:
+		CurrentThreadHolder(): _slot(TlsAlloc())
+		{
+			if (_slot == TLS_OUT_OF_INDEXES)
+				throw SystemException("cannot allocate thread context key");
+		}
+		~CurrentThreadHolder()
+		{
+			TlsFree(_slot);
+		}
+		ThreadImpl* get() const
+		{
+			return reinterpret_cast<ThreadImpl*>(TlsGetValue(_slot));
+		}
+		void set(ThreadImpl* pThread)
+		{
+			TlsSetValue(_slot, pThread);
+		}
+	
+	private:
+		DWORD _slot;
+	};
+
+	SharedPtr<Runnable> _pRunnableTarget;
+	HANDLE _thread;
+	DWORD _threadId;
+	int _prio;
+	int _stackSize;
+
+	static CurrentThreadHolder _currentThreadHolder;
+};
+
+
+//
+// inlines
+//
+inline int ThreadImpl::getPriorityImpl() const
+{
+	return _prio;
+}
+
+
+inline int ThreadImpl::getOSPriorityImpl() const
+{
+	return _prio;
+}
+
+
+inline int ThreadImpl::getMinOSPriorityImpl(int /* policy */)
+{
+	return PRIO_LOWEST_IMPL;
+}
+
+
+inline int ThreadImpl::getMaxOSPriorityImpl(int /* policy */)
+{
+	return PRIO_HIGHEST_IMPL;
+}
+
+
+inline void ThreadImpl::sleepImpl(long milliseconds)
+{
+	Sleep(DWORD(milliseconds));
+}
+
+
+inline void ThreadImpl::yieldImpl()
+{
+	Sleep(0);
+}
+
+
+inline void ThreadImpl::setStackSizeImpl(int size)
+{
+	_stackSize = size;
+}
+
+
+inline int ThreadImpl::getStackSizeImpl() const
+{
+	return _stackSize;
+}
+
+
+inline ThreadImpl::TIDImpl ThreadImpl::tidImpl() const
+{
+	return _threadId;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Thread_WIN32_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Thread_WINCE.h b/base/poco/Foundation/include/Poco/Thread_WINCE.h
new file mode 100644
index 00000000000..29f08aa3454
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Thread_WINCE.h
@@ -0,0 +1,179 @@
+//
+// Thread_WINCE.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Thread
+//
+// Definition of the ThreadImpl class for WIN32.
+//
+// Copyright (c) 2004-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Thread_WINCE_INCLUDED
+#define Foundation_Thread_WINCE_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Runnable.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/UnWindows.h"
+
+
+#if !defined(TLS_OUT_OF_INDEXES) // Windows CE 5.x does not define this
+#define TLS_OUT_OF_INDEXES 0xFFFFFFFF
+#endif
+
+
+namespace Poco {
+
+
+class Foundation_API ThreadImpl
+{
+public:	
+    typedef DWORD TIDImpl;
+	typedef void (*Callable)(void*);
+	typedef DWORD (WINAPI *Entry)(LPVOID);
+
+	enum Priority
+	{
+		PRIO_LOWEST_IMPL  = THREAD_PRIORITY_LOWEST,
+		PRIO_LOW_IMPL     = THREAD_PRIORITY_BELOW_NORMAL,
+		PRIO_NORMAL_IMPL  = THREAD_PRIORITY_NORMAL,
+		PRIO_HIGH_IMPL    = THREAD_PRIORITY_ABOVE_NORMAL,
+		PRIO_HIGHEST_IMPL = THREAD_PRIORITY_HIGHEST
+	};
+
+	enum Policy
+	{
+		POLICY_DEFAULT_IMPL = 0
+	};
+
+	ThreadImpl();				
+	~ThreadImpl();
+
+	TIDImpl tidImpl() const;
+	void setPriorityImpl(int prio);
+	int getPriorityImpl() const;
+	void setOSPriorityImpl(int prio, int policy = 0);
+	int getOSPriorityImpl() const;
+	static int getMinOSPriorityImpl(int policy);
+	static int getMaxOSPriorityImpl(int policy);
+	void setStackSizeImpl(int size);
+	int getStackSizeImpl() const;
+	void startImpl(SharedPtr<Runnable> pTarget);
+	void joinImpl();
+	bool joinImpl(long milliseconds);
+	bool isRunningImpl() const;
+	static void sleepImpl(long milliseconds);
+	static void yieldImpl();
+	static ThreadImpl* currentImpl();
+	static TIDImpl currentTidImpl();
+
+protected:
+	static DWORD WINAPI runnableEntry(LPVOID pThread);
+
+	void createImpl(Entry ent, void* pData);
+	void threadCleanup();
+
+private:
+	class CurrentThreadHolder
+	{
+	public:
+		CurrentThreadHolder(): _slot(TlsAlloc())
+		{
+			if (_slot == TLS_OUT_OF_INDEXES)
+				throw SystemException("cannot allocate thread context key");
+		}
+		~CurrentThreadHolder()
+		{
+			TlsFree(_slot);
+		}
+		ThreadImpl* get() const
+		{
+			return reinterpret_cast<ThreadImpl*>(TlsGetValue(_slot));
+		}
+		void set(ThreadImpl* pThread)
+		{
+			TlsSetValue(_slot, pThread);
+		}
+	
+	private:
+		DWORD _slot;
+	};
+
+	SharedPtr<Runnable> _pRunnableTarget;
+	HANDLE       _thread;
+	DWORD        _threadId;
+	int          _prio;
+	int          _stackSize;
+
+	static CurrentThreadHolder _currentThreadHolder;
+};
+
+
+//
+// inlines
+//
+inline int ThreadImpl::getPriorityImpl() const
+{
+	return _prio;
+}
+
+
+inline int ThreadImpl::getOSPriorityImpl() const
+{
+	return _prio;
+}
+
+
+inline int ThreadImpl::getMinOSPriorityImpl(int /* policy */)
+{
+	return PRIO_LOWEST_IMPL;
+}
+
+
+inline int ThreadImpl::getMaxOSPriorityImpl(int /* policy */)
+{
+	return PRIO_HIGHEST_IMPL;
+}
+
+
+inline void ThreadImpl::sleepImpl(long milliseconds)
+{
+	Sleep(DWORD(milliseconds));
+}
+
+
+inline void ThreadImpl::yieldImpl()
+{
+	Sleep(0);
+}
+
+
+inline void ThreadImpl::setStackSizeImpl(int size)
+{
+	_stackSize = size;
+}
+
+
+inline int ThreadImpl::getStackSizeImpl() const
+{
+	return _stackSize;
+}
+
+
+inline ThreadImpl::TIDImpl ThreadImpl::tidImpl() const
+{
+	return _threadId;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Thread_WINCE_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/TimedNotificationQueue.h b/base/poco/Foundation/include/Poco/TimedNotificationQueue.h
new file mode 100644
index 00000000000..841ace6b0aa
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/TimedNotificationQueue.h
@@ -0,0 +1,143 @@
+//
+// TimedNotificationQueue.h
+//
+// Library: Foundation
+// Package: Notifications
+// Module:  TimedNotificationQueue
+//
+// Definition of the TimedNotificationQueue class.
+//
+// Copyright (c) 2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_TimedNotificationQueue_INCLUDED
+#define Foundation_TimedNotificationQueue_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Notification.h"
+#include "Poco/Mutex.h"
+#include "Poco/Event.h"
+#include "Poco/Timestamp.h"
+#include "Poco/Clock.h"
+#include <map>
+
+
+namespace Poco {
+
+
+class Foundation_API TimedNotificationQueue
+	/// A TimedNotificationQueue object provides a way to implement timed, asynchronous
+	/// notifications. This is especially useful for sending notifications
+	/// from one thread to another, for example from a background thread to 
+	/// the main (user interface) thread. 
+	///
+	/// The TimedNotificationQueue is quite similar to the NotificationQueue class.
+	/// The only difference to NotificationQueue is that each Notification is tagged
+	/// with a Timestamp. When inserting a Notification into the queue, the
+	/// Notification is inserted according to the given Timestamp, with 
+	/// lower Timestamp values being inserted before higher ones.
+	///
+	/// Notifications are dequeued in order of their timestamps.
+	///
+	/// TimedNotificationQueue has some restrictions regarding multithreaded use.
+	/// While multiple threads may enqueue notifications, only one thread at a
+	/// time may dequeue notifications from the queue.
+	///
+	/// If two threads try to dequeue a notification simultaneously, the results
+	/// are undefined.
+{
+public:
+	TimedNotificationQueue();
+		/// Creates the TimedNotificationQueue.
+
+	~TimedNotificationQueue();
+		/// Destroys the TimedNotificationQueue.
+
+	void enqueueNotification(Notification::Ptr pNotification, Timestamp timestamp);
+		/// Enqueues the given notification by adding it to
+		/// the queue according to the given timestamp.
+		/// Lower timestamp values are inserted before higher ones.
+		/// The queue takes ownership of the notification, thus
+		/// a call like
+		///     notificationQueue.enqueueNotification(new MyNotification, someTime);
+		/// does not result in a memory leak.
+		///
+		/// The Timestamp is converted to an equivalent Clock value.
+
+	void enqueueNotification(Notification::Ptr pNotification, Clock clock);
+		/// Enqueues the given notification by adding it to
+		/// the queue according to the given clock value.
+		/// Lower clock values are inserted before higher ones.
+		/// The queue takes ownership of the notification, thus
+		/// a call like
+		///     notificationQueue.enqueueNotification(new MyNotification, someTime);
+		/// does not result in a memory leak.
+
+	Notification* dequeueNotification();
+		/// Dequeues the next pending notification with a timestamp
+		/// less than or equal to the current time.
+		/// Returns 0 (null) if no notification is available.
+		/// The caller gains ownership of the notification and
+		/// is expected to release it when done with it.
+		///
+		/// It is highly recommended that the result is immediately
+		/// assigned to a Notification::Ptr, to avoid potential
+		/// memory management issues.
+		
+	Notification* waitDequeueNotification();
+		/// Dequeues the next pending notification.
+		/// If no notification is available, waits for a notification
+		/// to be enqueued. 
+		/// The caller gains ownership of the notification and
+		/// is expected to release it when done with it.
+		///
+		/// It is highly recommended that the result is immediately
+		/// assigned to a Notification::Ptr, to avoid potential
+		/// memory management issues.
+
+	Notification* waitDequeueNotification(long milliseconds);
+		/// Dequeues the next pending notification.
+		/// If no notification is available, waits for a notification
+		/// to be enqueued up to the specified time.
+		/// Returns 0 (null) if no notification is available.
+		/// The caller gains ownership of the notification and
+		/// is expected to release it when done with it.
+		///
+		/// It is highly recommended that the result is immediately
+		/// assigned to a Notification::Ptr, to avoid potential
+		/// memory management issues.
+
+	bool empty() const;
+		/// Returns true iff the queue is empty.
+		
+	int size() const;
+		/// Returns the number of notifications in the queue.
+
+	void clear();
+		/// Removes all notifications from the queue.
+		///
+		/// Calling clear() while another thread executes one of
+		/// the dequeue member functions will result in undefined
+		/// behavior.
+
+protected:
+	typedef std::multimap<Clock, Notification::Ptr> NfQueue;
+	Notification::Ptr dequeueOne(NfQueue::iterator& it);
+	bool wait(Clock::ClockDiff interval);
+	
+private:
+	NfQueue _nfQueue;
+	Event   _nfAvailable;
+	mutable FastMutex _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_TimedNotificationQueue_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Timer.h b/base/poco/Foundation/include/Poco/Timer.h
new file mode 100644
index 00000000000..d9f7fc25630
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Timer.h
@@ -0,0 +1,229 @@
+//
+// Timer.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Timer
+//
+// Definition of the Timer and related classes.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Timer_INCLUDED
+#define Foundation_Timer_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Runnable.h"
+#include "Poco/Mutex.h"
+#include "Poco/Event.h"
+#include "Poco/Thread.h"
+#include "Poco/Clock.h"
+
+
+namespace Poco {
+
+
+class AbstractTimerCallback;
+class ThreadPool;
+
+
+class Foundation_API Timer: protected Runnable
+	/// This class implements a thread-based timer.
+	/// A timer starts a thread that first waits for a given start interval.
+	/// Once that interval expires, the timer callback is called repeatedly
+	/// in the given periodic interval. If the interval is 0, the timer is only
+	/// called once.
+	/// The timer callback method can stop the timer by setting the 
+	/// timer's periodic interval to 0.
+	///
+	/// The timer callback runs in its own thread, so multithreading
+	/// issues (proper synchronization) have to be considered when writing 
+	/// the callback method.
+	///
+	/// The exact interval at which the callback is called depends on many 
+	/// factors like operating system, CPU performance and system load and
+	/// may differ from the specified interval.
+	///
+	/// The time needed to execute the timer callback is not included
+	/// in the interval between invocations. For example, if the interval
+	/// is 500 milliseconds, and the callback needs 400 milliseconds to
+	/// execute, the callback function is nevertheless called every 500
+	/// milliseconds. If the callback takes longer to execute than the
+	/// interval, the callback function will not be called until the next
+	/// proper interval. The number of skipped invocations since the last
+	/// invocation will be recorded and can be obtained by the callback
+	/// by calling skipped().
+	///
+	/// The timer thread is taken from a thread pool, so
+	/// there is a limit to the number of available concurrent timers.
+{
+public:
+	Timer(long startInterval = 0, long periodicInterval = 0);
+		/// Creates a new timer object. StartInterval and periodicInterval
+		/// are given in milliseconds. If a periodicInterval of zero is 
+		/// specified, the callback will only be called once, after the
+		/// startInterval expires.
+		/// To start the timer, call the Start() method.
+
+	virtual ~Timer();
+		/// Stops and destroys the timer.
+
+	void start(const AbstractTimerCallback& method);
+		/// Starts the timer.
+		/// Create the TimerCallback as follows:
+		///     TimerCallback<MyClass> callback(*this, &MyClass::onTimer);
+		///     timer.start(callback);
+		///
+		/// The timer thread is taken from the global default thread pool.
+
+	void start(const AbstractTimerCallback& method, Thread::Priority priority);
+		/// Starts the timer in a thread with the given priority.
+		/// Create the TimerCallback as follows:
+		///     TimerCallback<MyClass> callback(*this, &MyClass::onTimer);
+		///     timer.start(callback);
+		///
+		/// The timer thread is taken from the global default thread pool.
+
+	void start(const AbstractTimerCallback& method, ThreadPool& threadPool);
+		/// Starts the timer.
+		/// Create the TimerCallback as follows:
+		///     TimerCallback<MyClass> callback(*this, &MyClass::onTimer);
+		///     timer.start(callback);
+
+	void start(const AbstractTimerCallback& method, Thread::Priority priority, ThreadPool& threadPool);
+		/// Starts the timer in a thread with the given priority.
+		/// Create the TimerCallback as follows:
+		///     TimerCallback<MyClass> callback(*this, &MyClass::onTimer);
+		///     timer.start(callback);
+		
+	void stop();
+		/// Stops the timer. If the callback method is currently running
+		/// it will be allowed to finish first.
+		/// WARNING: Never call this method from within the callback method,
+		/// as a deadlock would result. To stop the timer from within the
+		/// callback method, call restart(0).
+
+	void restart();
+		/// Restarts the periodic interval. If the callback method is already running,
+		/// nothing will happen.
+
+	void restart(long milliseconds);
+		/// Sets a new periodic interval and restarts the timer.
+		/// An interval of 0 will stop the timer.
+
+	long getStartInterval() const;
+		/// Returns the start interval.
+
+	void setStartInterval(long milliseconds);
+		/// Sets the start interval. Will only be 
+		/// effective before start() is called.
+
+	long getPeriodicInterval() const;
+		/// Returns the periodic interval.
+
+	void setPeriodicInterval(long milliseconds);
+		/// Sets the periodic interval. If the timer is already running
+		/// the new interval will be effective when the current interval
+		/// expires.
+		
+	long skipped() const;
+		/// Returns the number of skipped invocations since the last invocation.
+		/// Skipped invocations happen if the timer callback function takes
+		/// longer to execute than the timer interval.
+
+protected:
+	void run();
+
+private:
+	volatile long _startInterval;
+	volatile long _periodicInterval;
+	Event         _wakeUp;
+	Event         _done;
+	long          _skipped;
+	AbstractTimerCallback* _pCallback;
+	Clock                  _nextInvocation;
+	mutable FastMutex      _mutex;
+	
+	Timer(const Timer&);
+	Timer& operator = (const Timer&);
+};
+
+
+class Foundation_API AbstractTimerCallback
+	/// This is the base class for all instantiations of
+	/// the TimerCallback template.
+{
+public:
+	AbstractTimerCallback();
+	AbstractTimerCallback(const AbstractTimerCallback& callback);
+	virtual ~AbstractTimerCallback();
+	
+	AbstractTimerCallback& operator = (const AbstractTimerCallback& callback);
+
+	virtual void invoke(Timer& timer) const = 0;
+	virtual AbstractTimerCallback* clone() const = 0;
+};
+
+
+template <class C> 
+class TimerCallback: public AbstractTimerCallback
+	/// This template class implements an adapter that sits between
+	/// a Timer and an object's method invoked by the timer.
+	/// It is quite similar in concept to the RunnableAdapter, but provides 
+	/// some Timer specific additional methods.
+	/// See the Timer class for information on how
+	/// to use this template class.
+{
+public:
+	typedef void (C::*Callback)(Timer&);
+
+	TimerCallback(C& object, Callback method): _pObject(&object), _method(method)
+	{
+	}
+
+	TimerCallback(const TimerCallback& callback): _pObject(callback._pObject), _method(callback._method)
+	{
+	}
+
+	~TimerCallback()
+	{
+	}
+
+	TimerCallback& operator = (const TimerCallback& callback)
+	{
+		if (&callback != this)
+		{
+			_pObject = callback._pObject;
+			_method  = callback._method;
+		}
+		return *this;
+	}
+
+	void invoke(Timer& timer) const
+	{
+		(_pObject->*_method)(timer);
+	}
+
+	AbstractTimerCallback* clone() const
+	{
+		return new TimerCallback(*this);
+	}
+
+private:
+	TimerCallback();
+
+	C*       _pObject;
+	Callback _method;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Timer_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Timespan.h b/base/poco/Foundation/include/Poco/Timespan.h
new file mode 100644
index 00000000000..fcd742bbff9
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Timespan.h
@@ -0,0 +1,303 @@
+//
+// Timespan.h
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  Timespan
+//
+// Definition of the Timespan class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Timespan_INCLUDED
+#define Foundation_Timespan_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Timestamp.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Timespan
+	/// A class that represents time spans up to microsecond resolution.
+{
+public:
+	typedef Timestamp::TimeDiff TimeDiff;
+
+	Timespan();
+		/// Creates a zero Timespan.
+		
+	Timespan(TimeDiff microseconds);
+		/// Creates a Timespan.
+	
+	Timespan(long seconds, long microseconds);
+		/// Creates a Timespan. Useful for creating
+		/// a Timespan from a struct timeval.
+	
+	Timespan(int days, int hours, int minutes, int seconds, int microSeconds);
+		/// Creates a Timespan.
+
+	Timespan(const Timespan& timespan);
+		/// Creates a Timespan from another one.
+
+	~Timespan();
+		/// Destroys the Timespan.
+
+	Timespan& operator = (const Timespan& timespan);
+		/// Assignment operator.
+
+	Timespan& operator = (TimeDiff microseconds);
+		/// Assignment operator.
+		
+	Timespan& assign(int days, int hours, int minutes, int seconds, int microSeconds);
+		/// Assigns a new span.
+		
+	Timespan& assign(long seconds, long microseconds);
+		/// Assigns a new span. Useful for assigning
+		/// from a struct timeval.
+
+	void swap(Timespan& timespan);
+		/// Swaps the Timespan with another one.
+
+	bool operator == (const Timespan& ts) const;
+	bool operator != (const Timespan& ts) const;
+	bool operator >  (const Timespan& ts) const;
+	bool operator >= (const Timespan& ts) const;
+	bool operator <  (const Timespan& ts) const;
+	bool operator <= (const Timespan& ts) const;
+
+	bool operator == (TimeDiff microSeconds) const;
+	bool operator != (TimeDiff microSeconds) const;
+	bool operator >  (TimeDiff microSeconds) const;
+	bool operator >= (TimeDiff microSeconds) const;
+	bool operator <  (TimeDiff microSeconds) const;
+	bool operator <= (TimeDiff microSeconds) const;
+	
+	Timespan operator + (const Timespan& d) const;
+	Timespan operator - (const Timespan& d) const;
+	Timespan& operator += (const Timespan& d);
+	Timespan& operator -= (const Timespan& d);
+
+	Timespan operator + (TimeDiff microSeconds) const;
+	Timespan operator - (TimeDiff microSeconds) const;
+	Timespan& operator += (TimeDiff microSeconds);
+	Timespan& operator -= (TimeDiff microSeconds);
+
+	int days() const;
+		/// Returns the number of days.
+		
+	int hours() const;
+		/// Returns the number of hours (0 to 23).
+		
+	int totalHours() const;
+		/// Returns the total number of hours.
+		
+	int minutes() const;
+		/// Returns the number of minutes (0 to 59).
+		
+	int totalMinutes() const;
+		/// Returns the total number of minutes.
+		
+	int seconds() const;
+		/// Returns the number of seconds (0 to 59).
+		
+	int totalSeconds() const;
+		/// Returns the total number of seconds.
+		
+	int milliseconds() const;
+		/// Returns the number of milliseconds (0 to 999).
+		
+	TimeDiff totalMilliseconds() const;
+		/// Returns the total number of milliseconds.
+		
+	int microseconds() const;
+		/// Returns the fractions of a millisecond
+		/// in microseconds (0 to 999).
+		
+	int useconds() const;
+		/// Returns the fractions of a second
+		/// in microseconds (0 to 999999).
+		
+	TimeDiff totalMicroseconds() const;
+		/// Returns the total number of microseconds.
+
+	static const TimeDiff MILLISECONDS; /// The number of microseconds in a millisecond.
+	static const TimeDiff SECONDS;      /// The number of microseconds in a second.
+	static const TimeDiff MINUTES;      /// The number of microseconds in a minute.
+	static const TimeDiff HOURS;        /// The number of microseconds in a hour.
+	static const TimeDiff DAYS;         /// The number of microseconds in a day.
+
+private:
+	TimeDiff _span;
+};
+
+
+//
+// inlines
+//
+inline int Timespan::days() const
+{
+	return int(_span/DAYS);
+}
+
+
+inline int Timespan::hours() const
+{
+	return int((_span/HOURS) % 24);
+}
+
+	
+inline int Timespan::totalHours() const
+{
+	return int(_span/HOURS);
+}
+
+	
+inline int Timespan::minutes() const
+{
+	return int((_span/MINUTES) % 60);
+}
+
+	
+inline int Timespan::totalMinutes() const
+{
+	return int(_span/MINUTES);
+}
+
+	
+inline int Timespan::seconds() const
+{
+	return int((_span/SECONDS) % 60);
+}
+
+	
+inline int Timespan::totalSeconds() const
+{
+	return int(_span/SECONDS);
+}
+
+	
+inline int Timespan::milliseconds() const
+{
+	return int((_span/MILLISECONDS) % 1000);
+}
+
+	
+inline Timespan::TimeDiff Timespan::totalMilliseconds() const
+{
+	return _span/MILLISECONDS;
+}
+
+	
+inline int Timespan::microseconds() const
+{
+	return int(_span % 1000);
+}
+
+
+inline int Timespan::useconds() const
+{
+	return int(_span % 1000000);
+}
+
+	
+inline Timespan::TimeDiff Timespan::totalMicroseconds() const
+{
+	return _span;
+}
+
+
+inline bool Timespan::operator == (const Timespan& ts) const
+{
+	return _span == ts._span;
+}
+
+
+inline bool Timespan::operator != (const Timespan& ts) const
+{
+	return _span != ts._span;
+}
+
+
+inline bool Timespan::operator >  (const Timespan& ts) const
+{
+	return _span > ts._span;
+}
+
+
+inline bool Timespan::operator >= (const Timespan& ts) const
+{
+	return _span >= ts._span;
+}
+
+
+inline bool Timespan::operator <  (const Timespan& ts) const
+{
+	return _span < ts._span;
+}
+
+
+inline bool Timespan::operator <= (const Timespan& ts) const
+{
+	return _span <= ts._span;
+}
+
+
+inline bool Timespan::operator == (TimeDiff microSeconds) const
+{
+	return _span == microSeconds;
+}
+
+
+inline bool Timespan::operator != (TimeDiff microSeconds) const
+{
+	return _span != microSeconds;
+}
+
+
+inline bool Timespan::operator >  (TimeDiff microSeconds) const
+{
+	return _span > microSeconds;
+}
+
+
+inline bool Timespan::operator >= (TimeDiff microSeconds) const
+{
+	return _span >= microSeconds;
+}
+
+
+inline bool Timespan::operator <  (TimeDiff microSeconds) const
+{
+	return _span < microSeconds;
+}
+
+
+inline bool Timespan::operator <= (TimeDiff microSeconds) const
+{
+	return _span <= microSeconds;
+}
+
+
+inline void swap(Timespan& s1, Timespan& s2)
+{
+	s1.swap(s2);
+}
+
+
+inline Timespan::~Timespan()
+{
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Timespan_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Timestamp.h b/base/poco/Foundation/include/Poco/Timestamp.h
new file mode 100644
index 00000000000..3fd5d9738e8
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Timestamp.h
@@ -0,0 +1,277 @@
+//
+// Timestamp.h
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  Timestamp
+//
+// Definition of the Timestamp class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Timestamp_INCLUDED
+#define Foundation_Timestamp_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <ctime>
+
+
+namespace Poco {
+
+class Timespan;
+
+
+class Foundation_API Timestamp
+	/// A Timestamp stores a monotonic* time value
+	/// with (theoretical) microseconds resolution.
+	/// Timestamps can be compared with each other
+	/// and simple arithmetics are supported.
+	///
+	/// [*] Note that Timestamp values are only monotonic as
+	/// long as the systems's clock is monotonic as well
+	/// (and not, e.g. set back due to time synchronization
+	/// or other reasons).
+	///
+	/// Timestamps are UTC (Coordinated Universal Time)
+	/// based and thus independent of the timezone
+	/// in effect on the system.
+	///
+	/// The internal reference time is the Unix epoch, 
+	/// midnight, January 1, 1970.
+{
+public:
+	typedef Int64 TimeVal; 
+		/// Monotonic UTC time value in microsecond resolution,
+		/// with base time midnight, January 1, 1970.
+		
+	typedef Int64 UtcTimeVal; 
+		/// Monotonic UTC time value in 100 nanosecond resolution,
+		/// with base time midnight, October 15, 1582.
+		
+	typedef Int64 TimeDiff;
+		/// Difference between two TimeVal values in microseconds.
+
+	static const TimeVal TIMEVAL_MIN; /// Minimum timestamp value.
+	static const TimeVal TIMEVAL_MAX; /// Maximum timestamp value.
+
+	Timestamp();
+		/// Creates a timestamp with the current time.
+		
+	Timestamp(TimeVal tv);
+		/// Creates a timestamp from the given time value
+		/// (microseconds since midnight, January 1, 1970).
+		
+	Timestamp(const Timestamp& other);
+		/// Copy constructor.
+		
+	~Timestamp();
+		/// Destroys the timestamp
+		
+	Timestamp& operator = (const Timestamp& other);
+	Timestamp& operator = (TimeVal tv);
+	
+	void swap(Timestamp& timestamp);
+		/// Swaps the Timestamp with another one.
+	
+	void update();
+		/// Updates the Timestamp with the current time.
+
+	bool operator == (const Timestamp& ts) const;
+	bool operator != (const Timestamp& ts) const;
+	bool operator >  (const Timestamp& ts) const;
+	bool operator >= (const Timestamp& ts) const;
+	bool operator <  (const Timestamp& ts) const;
+	bool operator <= (const Timestamp& ts) const;
+	
+	Timestamp  operator +  (TimeDiff d) const;
+	Timestamp  operator +  (const Timespan& span) const;
+	Timestamp  operator -  (TimeDiff d) const;
+	Timestamp  operator -  (const Timespan& span) const;
+	TimeDiff   operator -  (const Timestamp& ts) const;
+	Timestamp& operator += (TimeDiff d);
+	Timestamp& operator += (const Timespan& span);
+	Timestamp& operator -= (TimeDiff d);
+	Timestamp& operator -= (const Timespan& span);
+	
+	std::time_t epochTime() const;
+		/// Returns the timestamp expressed in time_t.
+		/// time_t base time is midnight, January 1, 1970.
+		/// Resolution is one second.
+		
+	UtcTimeVal utcTime() const;
+		/// Returns the timestamp expressed in UTC-based
+		/// time. UTC base time is midnight, October 15, 1582.
+		/// Resolution is 100 nanoseconds.
+	
+	TimeVal epochMicroseconds() const;
+		/// Returns the timestamp expressed in microseconds
+		/// since the Unix epoch, midnight, January 1, 1970.
+	
+	TimeDiff elapsed() const;
+		/// Returns the time elapsed since the time denoted by
+		/// the timestamp. Equivalent to Timestamp() - *this.
+	
+	bool isElapsed(TimeDiff interval) const;
+		/// Returns true iff the given interval has passed
+		/// since the time denoted by the timestamp.
+
+	TimeVal raw() const;
+		/// Returns the raw time value.
+		///
+		/// Same as epochMicroseconds().
+	
+	static Timestamp fromEpochTime(std::time_t t);
+		/// Creates a timestamp from a std::time_t.
+		
+	static Timestamp fromUtcTime(UtcTimeVal val);
+		/// Creates a timestamp from a UTC time value
+		/// (100 nanosecond intervals since midnight,
+		/// October 15, 1582).
+		
+	static TimeDiff resolution();
+		/// Returns the resolution in units per second.
+		/// Since the timestamp has microsecond resolution,
+		/// the returned value is always 1000000.
+
+#if defined(_WIN32)
+	static Timestamp fromFileTimeNP(UInt32 fileTimeLow, UInt32 fileTimeHigh);
+	void toFileTimeNP(UInt32& fileTimeLow, UInt32& fileTimeHigh) const;
+#endif
+
+private:
+	TimeVal _ts;
+};
+
+
+//
+// inlines
+//
+inline bool Timestamp::operator == (const Timestamp& ts) const
+{
+	return _ts == ts._ts;
+}
+
+
+inline bool Timestamp::operator != (const Timestamp& ts) const
+{
+	return _ts != ts._ts;
+}
+
+
+inline bool Timestamp::operator >  (const Timestamp& ts) const
+{
+	return _ts > ts._ts;
+}
+
+
+inline bool Timestamp::operator >= (const Timestamp& ts) const
+{
+	return _ts >= ts._ts;
+}
+
+
+inline bool Timestamp::operator <  (const Timestamp& ts) const
+{
+	return _ts < ts._ts;
+}
+
+
+inline bool Timestamp::operator <= (const Timestamp& ts) const
+{
+	return _ts <= ts._ts;
+}
+
+
+inline Timestamp Timestamp::operator + (Timestamp::TimeDiff d) const
+{
+	return Timestamp(_ts + d);
+}
+
+
+inline Timestamp Timestamp::operator - (Timestamp::TimeDiff d) const
+{
+	return Timestamp(_ts - d);
+}
+
+
+inline Timestamp::TimeDiff Timestamp::operator - (const Timestamp& ts) const
+{
+	return _ts - ts._ts;
+}
+
+
+inline Timestamp& Timestamp::operator += (Timestamp::TimeDiff d)
+{
+	_ts += d;
+	return *this;
+}
+
+
+inline Timestamp& Timestamp::operator -= (Timestamp::TimeDiff d)
+{
+	_ts -= d;
+	return *this;
+}
+
+
+inline std::time_t Timestamp::epochTime() const
+{
+	return std::time_t(_ts/resolution());
+}
+
+
+inline Timestamp::UtcTimeVal Timestamp::utcTime() const
+{
+	return _ts*10 + (TimeDiff(0x01b21dd2) << 32) + 0x13814000;
+}
+
+
+inline Timestamp::TimeVal Timestamp::epochMicroseconds() const
+{
+	return _ts;
+}
+
+
+inline Timestamp::TimeDiff Timestamp::elapsed() const
+{
+	Timestamp now;
+	return now - *this;
+}
+
+
+inline bool Timestamp::isElapsed(Timestamp::TimeDiff interval) const
+{
+	Timestamp now;
+	Timestamp::TimeDiff diff = now - *this;
+	return diff >= interval;
+}
+
+
+inline Timestamp::TimeDiff Timestamp::resolution()
+{
+	return 1000000;
+}
+
+
+inline void swap(Timestamp& s1, Timestamp& s2)
+{
+	s1.swap(s2);
+}
+
+
+inline Timestamp::TimeVal Timestamp::raw() const
+{
+	return _ts;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Timestamp_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Timezone.h b/base/poco/Foundation/include/Poco/Timezone.h
new file mode 100644
index 00000000000..c273f32f5bd
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Timezone.h
@@ -0,0 +1,67 @@
+//
+// Timezone.h
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  Timezone
+//
+// Definition of the Timezone class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Timezone_INCLUDED
+#define Foundation_Timezone_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Timestamp.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Timezone
+	/// This class provides information about the current timezone.
+{
+public:
+	static int utcOffset();
+		/// Returns the offset of local time to UTC, in seconds.
+		///     local time = UTC + utcOffset() + dst().
+		
+	static int dst();
+		/// Returns the daylight saving time offset in seconds if
+		/// daylight saving time is in use.
+		///     local time = UTC + utcOffset() + dst().
+	
+	static bool isDst(const Timestamp& timestamp);
+		/// Returns true if daylight saving time is in effect
+		/// for the given time. Depending on the operating system
+		/// platform this might only work reliably for certain
+		/// date ranges, as the C library's localtime() function
+		/// is used.
+		
+	static int tzd();
+		/// Returns the time zone differential for the current timezone.
+		/// The timezone differential is computed as utcOffset() + dst()
+		/// and is expressed in seconds.
+	
+	static std::string name();
+		/// Returns the timezone name currently in effect.
+		
+	static std::string standardName();
+		/// Returns the timezone name if not daylight saving time is in effect.
+		
+	static std::string dstName();
+		/// Returns the timezone name if daylight saving time is in effect.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Timezone_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Token.h b/base/poco/Foundation/include/Poco/Token.h
new file mode 100644
index 00000000000..13540af914d
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Token.h
@@ -0,0 +1,172 @@
+//
+// Token.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  StreamTokenizer
+//
+// Definition of the Token class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Token_INCLUDED
+#define Foundation_Token_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <istream>
+
+
+namespace Poco {
+
+
+class Foundation_API Token
+	/// The base class for all token classes that can be
+	/// registered with the StreamTokenizer.
+{
+public:
+	enum Class
+	{
+		IDENTIFIER_TOKEN,
+		KEYWORD_TOKEN,
+		SEPARATOR_TOKEN,
+		OPERATOR_TOKEN,
+		STRING_LITERAL_TOKEN,
+		CHAR_LITERAL_TOKEN,
+		INTEGER_LITERAL_TOKEN,
+		LONG_INTEGER_LITERAL_TOKEN,
+		FLOAT_LITERAL_TOKEN,
+		DOUBLE_LITERAL_TOKEN,
+		COMMENT_TOKEN,
+		SPECIAL_COMMENT_TOKEN,
+		PREPROCESSOR_TOKEN,
+		WHITESPACE_TOKEN,
+		EOF_TOKEN,
+		INVALID_TOKEN,
+		USER_TOKEN
+	};
+	
+	Token();
+		/// Creates the Token.
+
+	virtual ~Token();
+		/// Destroys the Token.
+		
+	virtual bool start(char c, std::istream& istr);
+		/// Checks if the given character (and, optionally,
+		/// the next character in the input stream) start
+		/// a valid token. Returns true if so, false
+		/// otherwise.
+		///
+		/// The current read position in istr must not be
+		/// changed. In other words, only the peek() method
+		/// of istream may be used.
+		///
+		/// If the character starts the token, it should
+		/// be set as the token's value.
+
+	virtual void finish(std::istream& istr);
+		/// Builds the token by reading and appending 
+		/// the remaining characters from istr.
+		
+	virtual Class tokenClass() const;
+		/// Returns the kind of the token.
+	
+	const std::string& tokenString() const;
+		/// Returns the token's raw string.
+	
+	virtual std::string asString() const;
+		/// Returns a string representation of the token.
+	
+#if defined(POCO_HAVE_INT64)
+	virtual Int64 asInteger64() const;
+        /// Returns a 64-bit integer representation of the token.
+
+	virtual UInt64 asUnsignedInteger64() const;
+        /// Returns an unsigned 64-bit integer representation of the token.
+#endif
+
+	virtual int asInteger() const;
+		/// Returns an integer representation of the token.
+
+	virtual unsigned asUnsignedInteger() const;
+		/// Returns an unsigned integer representation of the token.
+
+	virtual double asFloat() const;
+		/// Returns a floating-point representation of the token.
+
+	virtual char asChar() const;
+		/// Returns a char representation of the token.
+
+	bool is(Class tokenClass) const;
+		/// Returns true iff the token has the given class.
+
+protected:
+	std::string _value;
+	
+private:
+	Token(const Token&);
+	Token& operator = (const Token&);
+};
+
+
+class Foundation_API InvalidToken: public Token
+	/// This token class is used for signalling that
+	/// an invalid character sequence has been encountered
+	/// in the input stream.
+{
+public:
+	InvalidToken();
+	~InvalidToken();
+	Class tokenClass() const;
+};
+
+
+class Foundation_API EOFToken: public Token
+	/// This token class is used to signal the
+	/// end of the input stream.
+{
+public:
+	EOFToken();
+	~EOFToken();
+	Class tokenClass() const;
+};
+
+
+class Foundation_API WhitespaceToken: public Token
+	/// This pseudo token class is used to eat
+	/// up whitespace in between real tokens.
+{
+public:
+	WhitespaceToken();
+	~WhitespaceToken();
+	Class tokenClass() const;
+	bool start(char c, std::istream& istr);
+	void finish(std::istream& istr);
+};
+
+
+//
+// inlines
+//
+inline const std::string& Token::tokenString() const
+{
+	return _value;
+}
+
+
+inline bool Token::is(Token::Class cls) const
+{
+	return tokenClass() == cls;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Token_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Tuple.h b/base/poco/Foundation/include/Poco/Tuple.h
new file mode 100644
index 00000000000..2111bf8a9ce
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Tuple.h
@@ -0,0 +1,1747 @@
+//
+// Tuple.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Tuple
+//
+// Definition of the Tuple class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Tuple_INCLUDED
+#define Foundation_Tuple_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/TypeList.h"
+
+
+namespace Poco {
+
+
+#if defined(_MSC_VER) 
+#define POCO_TYPEWRAPPER_DEFAULTVALUE(T) TypeWrapper<T>::TYPE()
+#else
+#define POCO_TYPEWRAPPER_DEFAULTVALUE(T) typename TypeWrapper<T>::TYPE()
+#endif
+
+
+template <class T0,
+	class T1 = NullTypeList,
+	class T2 = NullTypeList,
+	class T3 = NullTypeList,
+	class T4 = NullTypeList,
+	class T5 = NullTypeList,
+	class T6 = NullTypeList,
+	class T7 = NullTypeList,
+	class T8 = NullTypeList,
+	class T9 = NullTypeList,
+	class T10 = NullTypeList,
+	class T11 = NullTypeList,
+	class T12 = NullTypeList,
+	class T13 = NullTypeList,
+	class T14 = NullTypeList,
+	class T15 = NullTypeList,
+	class T16 = NullTypeList,
+	class T17 = NullTypeList,
+	class T18 = NullTypeList,
+	class T19 = NullTypeList>
+struct Tuple
+{
+	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0,
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16),
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17),
+		typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18),
+		typename TypeWrapper<T19>::CONSTTYPE& t19 = POCO_TYPEWRAPPER_DEFAULTVALUE(T19)):
+		_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
+			(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
+			(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
+			(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
+			(t4, typename TypeListType<T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
+			(t5, typename TypeListType<T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
+			(t6, typename TypeListType<T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
+			(t7, typename TypeListType<T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
+			(t8, typename TypeListType<T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
+			(t9, typename TypeListType<T10,T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
+			(t10, typename TypeListType<T11,T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
+			(t11, typename TypeListType<T12,T13,T14,T15,T16,T17,T18,T19>::HeadType
+			(t12, typename TypeListType<T13,T14,T15,T16,T17,T18,T19>::HeadType
+			(t13, typename TypeListType<T14,T15,T16,T17,T18,T19>::HeadType
+			(t14, typename TypeListType<T15,T16,T17,T18,T19>::HeadType
+			(t15, typename TypeListType<T16,T17,T18,T19>::HeadType
+			(t16, typename TypeListType<T17,T18,T19>::HeadType
+			(t17, typename TypeListType<T18,T19>::HeadType
+			(t18, typename TypeListType<T19>::HeadType
+			(t19, NullTypeList()))))))))))))))))))))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17,
+	class T18>
+struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18,NullTypeList>
+{
+	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16),
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17),
+		typename TypeWrapper<T18>::CONSTTYPE& t18 = POCO_TYPEWRAPPER_DEFAULTVALUE(T18)):
+		_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
+			(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
+			(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
+			(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
+			(t4, typename TypeListType<T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
+			(t5, typename TypeListType<T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
+			(t6, typename TypeListType<T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
+			(t7, typename TypeListType<T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
+			(t8, typename TypeListType<T9,T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
+			(t9, typename TypeListType<T10,T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
+			(t10, typename TypeListType<T11,T12,T13,T14,T15,T16,T17,T18>::HeadType
+			(t11, typename TypeListType<T12,T13,T14,T15,T16,T17,T18>::HeadType
+			(t12, typename TypeListType<T13,T14,T15,T16,T17,T18>::HeadType
+			(t13, typename TypeListType<T14,T15,T16,T17,T18>::HeadType
+			(t14, typename TypeListType<T15,T16,T17,T18>::HeadType
+			(t15, typename TypeListType<T16,T17,T18>::HeadType
+			(t16, typename TypeListType<T17,T18>::HeadType
+			(t17, typename TypeListType<T18>::HeadType
+			(t18, NullTypeList())))))))))))))))))))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16,
+	class T17>
+struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,NullTypeList>
+{
+	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16),
+		typename TypeWrapper<T17>::CONSTTYPE& t17 = POCO_TYPEWRAPPER_DEFAULTVALUE(T17)):
+		_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
+			(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
+			(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
+			(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
+			(t4, typename TypeListType<T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
+			(t5, typename TypeListType<T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
+			(t6, typename TypeListType<T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
+			(t7, typename TypeListType<T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
+			(t8, typename TypeListType<T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
+			(t9, typename TypeListType<T10,T11,T12,T13,T14,T15,T16,T17>::HeadType
+			(t10, typename TypeListType<T11,T12,T13,T14,T15,T16,T17>::HeadType
+			(t11, typename TypeListType<T12,T13,T14,T15,T16,T17>::HeadType
+			(t12, typename TypeListType<T13,T14,T15,T16,T17>::HeadType
+			(t13, typename TypeListType<T14,T15,T16,T17>::HeadType
+			(t14, typename TypeListType<T15,T16,T17>::HeadType
+			(t15, typename TypeListType<T16,T17>::HeadType
+			(t16, typename TypeListType<T17>::HeadType
+			(t17, NullTypeList()))))))))))))))))))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15,
+	class T16>
+struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,NullTypeList>
+{
+	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15),
+		typename TypeWrapper<T16>::CONSTTYPE& t16 = POCO_TYPEWRAPPER_DEFAULTVALUE(T16)):
+		_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType
+			(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType
+			(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType
+			(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType
+			(t4, typename TypeListType<T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType
+			(t5, typename TypeListType<T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType
+			(t6, typename TypeListType<T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType
+			(t7, typename TypeListType<T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType
+			(t8, typename TypeListType<T9,T10,T11,T12,T13,T14,T15,T16>::HeadType
+			(t9, typename TypeListType<T10,T11,T12,T13,T14,T15,T16>::HeadType
+			(t10, typename TypeListType<T11,T12,T13,T14,T15,T16>::HeadType
+			(t11, typename TypeListType<T12,T13,T14,T15,T16>::HeadType
+			(t12, typename TypeListType<T13,T14,T15,T16>::HeadType
+			(t13, typename TypeListType<T14,T15,T16>::HeadType
+			(t14, typename TypeListType<T15,T16>::HeadType
+			(t15, typename TypeListType<T16>::HeadType
+			(t16, NullTypeList())))))))))))))))))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14,
+	class T15>
+struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,NullTypeList>
+{
+	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14),
+		typename TypeWrapper<T15>::CONSTTYPE& t15 = POCO_TYPEWRAPPER_DEFAULTVALUE(T15)):
+		_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::HeadType
+			(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::HeadType
+			(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::HeadType
+			(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::HeadType
+			(t4, typename TypeListType<T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::HeadType
+			(t5, typename TypeListType<T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::HeadType
+			(t6, typename TypeListType<T7,T8,T9,T10,T11,T12,T13,T14,T15>::HeadType
+			(t7, typename TypeListType<T8,T9,T10,T11,T12,T13,T14,T15>::HeadType
+			(t8, typename TypeListType<T9,T10,T11,T12,T13,T14,T15>::HeadType
+			(t9, typename TypeListType<T10,T11,T12,T13,T14,T15>::HeadType
+			(t10, typename TypeListType<T11,T12,T13,T14,T15>::HeadType
+			(t11, typename TypeListType<T12,T13,T14,T15>::HeadType
+			(t12, typename TypeListType<T13,T14,T15>::HeadType
+			(t13, typename TypeListType<T14,T15>::HeadType
+			(t14, typename TypeListType<T15>::HeadType
+			(t15, NullTypeList()))))))))))))))))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13,
+	class T14>
+struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,NullTypeList>
+{
+	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13),
+		typename TypeWrapper<T14>::CONSTTYPE& t14 = POCO_TYPEWRAPPER_DEFAULTVALUE(T14)):
+		_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>::HeadType
+			(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>::HeadType
+			(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>::HeadType
+			(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>::HeadType
+			(t4, typename TypeListType<T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>::HeadType
+			(t5, typename TypeListType<T6,T7,T8,T9,T10,T11,T12,T13,T14>::HeadType
+			(t6, typename TypeListType<T7,T8,T9,T10,T11,T12,T13,T14>::HeadType
+			(t7, typename TypeListType<T8,T9,T10,T11,T12,T13,T14>::HeadType
+			(t8, typename TypeListType<T9,T10,T11,T12,T13,T14>::HeadType
+			(t9, typename TypeListType<T10,T11,T12,T13,T14>::HeadType
+			(t10, typename TypeListType<T11,T12,T13,T14>::HeadType
+			(t11, typename TypeListType<T12,T13,T14>::HeadType
+			(t12, typename TypeListType<T13,T14>::HeadType
+			(t13, typename TypeListType<T14>::HeadType
+			(t14, NullTypeList())))))))))))))))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12,
+	class T13>
+struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,NullTypeList>
+{
+	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12),
+		typename TypeWrapper<T13>::CONSTTYPE& t13 = POCO_TYPEWRAPPER_DEFAULTVALUE(T13)):
+		_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>::HeadType
+			(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>::HeadType
+			(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>::HeadType
+			(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>::HeadType
+			(t4, typename TypeListType<T5,T6,T7,T8,T9,T10,T11,T12,T13>::HeadType
+			(t5, typename TypeListType<T6,T7,T8,T9,T10,T11,T12,T13>::HeadType
+			(t6, typename TypeListType<T7,T8,T9,T10,T11,T12,T13>::HeadType
+			(t7, typename TypeListType<T8,T9,T10,T11,T12,T13>::HeadType
+			(t8, typename TypeListType<T9,T10,T11,T12,T13>::HeadType
+			(t9, typename TypeListType<T10,T11,T12,T13>::HeadType
+			(t10, typename TypeListType<T11,T12,T13>::HeadType
+			(t11, typename TypeListType<T12,T13>::HeadType
+			(t12, typename TypeListType<T13>::HeadType
+			(t13, NullTypeList()))))))))))))))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11,
+	class T12>
+struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12, NullTypeList>
+{
+	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11),
+		typename TypeWrapper<T12>::CONSTTYPE& t12 = POCO_TYPEWRAPPER_DEFAULTVALUE(T12)):
+		_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>::HeadType
+			(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>::HeadType
+			(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>::HeadType
+			(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10,T11,T12>::HeadType
+			(t4, typename TypeListType<T5,T6,T7,T8,T9,T10,T11,T12>::HeadType
+			(t5, typename TypeListType<T6,T7,T8,T9,T10,T11,T12>::HeadType
+			(t6, typename TypeListType<T7,T8,T9,T10,T11,T12>::HeadType
+			(t7, typename TypeListType<T8,T9,T10,T11,T12>::HeadType
+			(t8, typename TypeListType<T9,T10,T11,T12>::HeadType
+			(t9, typename TypeListType<T10,T11,T12>::HeadType
+			(t10, typename TypeListType<T11,T12>::HeadType
+			(t11, typename TypeListType<T12>::HeadType
+			(t12, NullTypeList())))))))))))))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10,
+	class T11>
+struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,NullTypeList>
+{
+	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10),
+		typename TypeWrapper<T11>::CONSTTYPE& t11 = POCO_TYPEWRAPPER_DEFAULTVALUE(T11)):
+		_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::HeadType
+			(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::HeadType
+			(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10,T11>::HeadType
+			(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10,T11>::HeadType
+			(t4, typename TypeListType<T5,T6,T7,T8,T9,T10,T11>::HeadType
+			(t5, typename TypeListType<T6,T7,T8,T9,T10,T11>::HeadType
+			(t6, typename TypeListType<T7,T8,T9,T10,T11>::HeadType
+			(t7, typename TypeListType<T8,T9,T10,T11>::HeadType
+			(t8, typename TypeListType<T9,T10,T11>::HeadType
+			(t9, typename TypeListType<T10,T11>::HeadType
+			(t10, typename TypeListType<T11>::HeadType
+			(t11, NullTypeList()))))))))))))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9,
+	class T10>
+struct Tuple<T0, T1,T2,T3,T4,T5,T6,T7,T8,T9,T10, NullTypeList>
+{
+	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9),
+		typename TypeWrapper<T10>::CONSTTYPE& t10 = POCO_TYPEWRAPPER_DEFAULTVALUE(T10)):
+		_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::HeadType
+			(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9,T10>::HeadType
+			(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9,T10>::HeadType
+			(t3, typename TypeListType<T4,T5,T6,T7,T8,T9,T10>::HeadType
+			(t4, typename TypeListType<T5,T6,T7,T8,T9,T10>::HeadType
+			(t5, typename TypeListType<T6,T7,T8,T9,T10>::HeadType
+			(t6, typename TypeListType<T7,T8,T9,T10>::HeadType
+			(t7, typename TypeListType<T8,T9,T10>::HeadType
+			(t8, typename TypeListType<T9,T10>::HeadType
+			(t9, typename TypeListType<T10>::HeadType
+			(t10, NullTypeList())))))))))))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8,
+	class T9>
+struct Tuple<T0, T1,T2,T3,T4,T5,T6,T7,T8,T9, NullTypeList>
+{
+	typedef typename TypeListType<T0, T1,T2,T3,T4,T5,T6,T7,T8,T9>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8),
+		typename TypeWrapper<T9>::CONSTTYPE& t9 = POCO_TYPEWRAPPER_DEFAULTVALUE(T9)):
+		_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8,T9>::HeadType
+			(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8,T9>::HeadType
+			(t2, typename TypeListType<T3,T4,T5,T6,T7,T8,T9>::HeadType
+			(t3, typename TypeListType<T4,T5,T6,T7,T8,T9>::HeadType
+			(t4, typename TypeListType<T5,T6,T7,T8,T9>::HeadType
+			(t5, typename TypeListType<T6,T7,T8,T9>::HeadType
+			(t6, typename TypeListType<T7,T8,T9>::HeadType
+			(t7, typename TypeListType<T8,T9>::HeadType
+			(t8, typename TypeListType<T9>::HeadType
+			(t9, NullTypeList()))))))))))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7,
+	class T8>
+struct Tuple<T0, T1,T2,T3,T4,T5,T6,T7,T8, NullTypeList>
+{
+	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7),
+		typename TypeWrapper<T8>::CONSTTYPE& t8 = POCO_TYPEWRAPPER_DEFAULTVALUE(T8)):
+		_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7,T8>::HeadType
+			(t1, typename TypeListType<T2,T3,T4,T5,T6,T7,T8>::HeadType
+			(t2, typename TypeListType<T3,T4,T5,T6,T7,T8>::HeadType
+			(t3, typename TypeListType<T4,T5,T6,T7,T8>::HeadType
+			(t4, typename TypeListType<T5,T6,T7,T8>::HeadType
+			(t5, typename TypeListType<T6,T7,T8>::HeadType
+			(t6, typename TypeListType<T7,T8>::HeadType
+			(t7, typename TypeListType<T8>::HeadType
+			(t8, NullTypeList())))))))))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6,
+	class T7>
+struct Tuple<T0, T1,T2,T3,T4,T5,T6,T7, NullTypeList>
+{
+	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6),
+		typename TypeWrapper<T7>::CONSTTYPE& t7 = POCO_TYPEWRAPPER_DEFAULTVALUE(T7)):
+		_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6,T7>::HeadType
+			(t1, typename TypeListType<T2,T3,T4,T5,T6,T7>::HeadType
+			(t2, typename TypeListType<T3,T4,T5,T6,T7>::HeadType
+			(t3, typename TypeListType<T4,T5,T6,T7>::HeadType
+			(t4, typename TypeListType<T5,T6,T7>::HeadType
+			(t5, typename TypeListType<T6,T7>::HeadType
+			(t6, typename TypeListType<T7>::HeadType
+			(t7, NullTypeList()))))))))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5,
+	class T6>
+struct Tuple<T0, T1,T2,T3,T4,T5,T6, NullTypeList>
+{
+	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5),
+		typename TypeWrapper<T6>::CONSTTYPE& t6 = POCO_TYPEWRAPPER_DEFAULTVALUE(T6)):
+		_data(t0, typename TypeListType<T1,T2,T3,T4,T5,T6>::HeadType
+			(t1, typename TypeListType<T2,T3,T4,T5,T6>::HeadType
+			(t2, typename TypeListType<T3,T4,T5,T6>::HeadType
+			(t3, typename TypeListType<T4,T5,T6>::HeadType
+			(t4, typename TypeListType<T5,T6>::HeadType
+			(t5, typename TypeListType<T6>::HeadType
+			(t6, NullTypeList())))))))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4,
+	class T5>
+struct Tuple<T0, T1,T2,T3,T4,T5, NullTypeList>
+{
+	typedef typename TypeListType<T0,T1,T2,T3,T4,T5>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4),
+		typename TypeWrapper<T5>::CONSTTYPE& t5 = POCO_TYPEWRAPPER_DEFAULTVALUE(T5)):
+		_data(t0, typename TypeListType<T1,T2,T3,T4,T5>::HeadType
+			(t1, typename TypeListType<T2,T3,T4,T5>::HeadType
+			(t2, typename TypeListType<T3,T4,T5>::HeadType
+			(t3, typename TypeListType<T4,T5>::HeadType
+			(t4, typename TypeListType<T5>::HeadType
+			(t5, NullTypeList()))))))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3,
+	class T4>
+struct Tuple<T0, T1,T2,T3,T4, NullTypeList>
+{
+	typedef typename TypeListType<T0,T1,T2,T3,T4>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3),
+		typename TypeWrapper<T4>::CONSTTYPE& t4 = POCO_TYPEWRAPPER_DEFAULTVALUE(T4)):
+		_data(t0, typename TypeListType<T1,T2,T3,T4>::HeadType
+			(t1, typename TypeListType<T2,T3,T4>::HeadType
+			(t2, typename TypeListType<T3,T4>::HeadType
+			(t3, typename TypeListType<T4>::HeadType
+			(t4, NullTypeList())))))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0,
+	class T1,
+	class T2,
+	class T3>
+struct Tuple<T0, T1,T2,T3, NullTypeList>
+{
+	typedef typename TypeListType<T0,T1,T2,T3>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2),
+		typename TypeWrapper<T3>::CONSTTYPE& t3 = POCO_TYPEWRAPPER_DEFAULTVALUE(T3)):
+		_data(t0, typename TypeListType<T1,T2,T3>::HeadType
+			(t1, typename TypeListType<T2,T3>::HeadType
+			(t2, typename TypeListType<T3>::HeadType
+			(t3, NullTypeList()))))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0,
+	class T1,
+	class T2>
+struct Tuple<T0, T1,T2, NullTypeList>
+{
+	typedef typename TypeListType<T0,T1,T2>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1),
+		typename TypeWrapper<T2>::CONSTTYPE& t2 = POCO_TYPEWRAPPER_DEFAULTVALUE(T2)):
+		_data(t0, typename TypeListType<T1,T2>::HeadType
+			(t1, typename TypeListType<T2>::HeadType
+			(t2, NullTypeList())))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0,
+	class T1>
+struct Tuple<T0, T1, NullTypeList>
+{
+	typedef typename TypeListType<T0,T1>::HeadType Type;
+
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0, 
+		typename TypeWrapper<T1>::CONSTTYPE& t1 = POCO_TYPEWRAPPER_DEFAULTVALUE(T1)):
+		_data(t0, typename TypeListType<T1>::HeadType(t1, NullTypeList()))
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+template <class T0>
+struct Tuple<T0, NullTypeList>
+{
+	typedef TypeList<T0, NullTypeList> Type;
+	
+	enum TupleLengthType
+	{
+		length = Type::length
+	};
+
+	Tuple():_data()
+	{
+	}
+
+	Tuple(typename TypeWrapper<T0>::CONSTTYPE& t0):
+		_data(t0, NullTypeList())
+	{
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::ConstHeadType& get() const
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	typename TypeGetter<N, Type>::HeadType& get()
+	{
+		return Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data);
+	}
+
+	template <int N>
+	void set(typename TypeGetter<N, Type>::ConstHeadType& val)
+	{
+		Getter<N>::template get<typename TypeGetter<N, Type>::HeadType, typename Type::HeadType, typename Type::TailType>(_data) = val;
+	}
+
+	bool operator == (const Tuple& other) const
+	{
+		return _data == other._data;
+	}
+
+	bool operator != (const Tuple& other) const
+	{
+		return !(_data == other._data);
+	}
+
+	bool operator < (const Tuple& other) const
+	{
+		return _data < other._data;
+	}
+
+private:
+	Type _data;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Tuple_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/TypeList.h b/base/poco/Foundation/include/Poco/TypeList.h
new file mode 100644
index 00000000000..352696f8e01
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/TypeList.h
@@ -0,0 +1,483 @@
+//
+// TypeList.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  TypeList
+//
+// Implementation of the TypeList template.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Portions extracted and adapted from
+// The Loki Library
+// Copyright (c) 2001 by Andrei Alexandrescu
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_TypeList_INCLUDED
+#define Foundation_TypeList_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/MetaProgramming.h"
+
+
+namespace Poco {
+
+
+template <class Head, class Tail> 
+struct TypeList;
+
+
+struct NullTypeList
+{
+	enum
+	{
+		length = 0
+	};
+
+	bool operator == (const NullTypeList&) const
+	{
+		return true;
+	}
+
+	bool operator != (const NullTypeList&) const
+	{
+		return false;
+	}
+
+	bool operator < (const NullTypeList&) const
+	{
+		return false;
+	}
+};
+
+
+template <class Head, class Tail> 
+struct TypeList
+	/// Compile Time List of Types
+{
+	typedef Head HeadType;
+	typedef Tail TailType;
+	typedef typename TypeWrapper<HeadType>::CONSTTYPE ConstHeadType;
+	typedef typename TypeWrapper<TailType>::CONSTTYPE ConstTailType;
+	enum
+	{
+		length = TailType::length+1
+	};
+
+	TypeList():head(), tail()
+	{
+	}
+
+	TypeList(ConstHeadType& h, ConstTailType& t):head(h), tail(t)
+	{
+	}
+
+	TypeList(const TypeList& tl): head(tl.head), tail(tl.tail)
+	{
+	}
+
+	TypeList& operator = (const TypeList& tl)
+	{
+		if (this != &tl)
+		{
+			head = tl.head;
+			tail = tl.tail;
+		}
+		return *this;
+	}
+
+	bool operator == (const TypeList& tl) const
+	{
+		return tl.head == head && tl.tail == tail;
+	}
+
+	bool operator != (const TypeList& tl) const
+	{
+		return !(*this == tl);
+	}
+
+	bool operator < (const TypeList& tl) const
+	{
+		if (head < tl.head)
+			return true;
+		else if (head == tl.head)
+			return tail < tl.tail;
+		return false;
+	}
+	
+	HeadType head;
+	TailType tail;
+};
+
+
+template <typename T0  = NullTypeList,
+	typename T1  = NullTypeList,
+	typename T2  = NullTypeList,
+	typename T3  = NullTypeList,
+	typename T4  = NullTypeList,
+	typename T5  = NullTypeList,
+	typename T6  = NullTypeList,
+	typename T7  = NullTypeList,
+	typename T8  = NullTypeList,
+	typename T9  = NullTypeList,
+	typename T10 = NullTypeList,
+	typename T11 = NullTypeList,
+	typename T12 = NullTypeList,
+	typename T13 = NullTypeList,
+	typename T14 = NullTypeList,
+	typename T15 = NullTypeList,
+	typename T16 = NullTypeList,
+	typename T17 = NullTypeList,
+	typename T18 = NullTypeList,
+	typename T19 = NullTypeList,
+	typename T20 = NullTypeList,
+	typename T21 = NullTypeList,
+	typename T22 = NullTypeList,
+	typename T23 = NullTypeList,
+	typename T24 = NullTypeList,
+	typename T25 = NullTypeList,
+	typename T26 = NullTypeList,
+	typename T27 = NullTypeList,
+	typename T28 = NullTypeList,
+	typename T29 = NullTypeList,
+	typename T30 = NullTypeList,
+	typename T31 = NullTypeList,
+	typename T32 = NullTypeList,
+	typename T33 = NullTypeList,
+	typename T34 = NullTypeList,
+	typename T35 = NullTypeList,
+	typename T36 = NullTypeList,
+	typename T37 = NullTypeList,
+	typename T38 = NullTypeList,
+	typename T39 = NullTypeList>
+struct TypeListType
+	/// TypeListType takes 1 - 40 typename arguments.
+	/// Usage:
+	///
+	/// TypeListType<T0, T1, ... , Tn>::HeadType typeList;
+	///
+	/// typeList is a TypeList of T0, T1, ... , Tn
+{
+private:
+	typedef typename
+		TypeListType<T1,T2, T3, T4, T5, T6, T7, T8, T9, T10,
+					T11,T12,T13,T14,T15,T16,T17,T18,T19,T20,
+					T21,T22,T23,T24,T25,T26,T27,T28,T29,T30,
+					T31,T32,T33,T34,T35,T36,T37,T38,T39>::HeadType TailType;
+
+public:
+	typedef TypeList<T0, TailType> HeadType;
+};
+
+
+template <>
+struct TypeListType<>
+{
+	typedef NullTypeList HeadType;
+};
+
+
+template <int n> 
+struct Getter
+{
+	template <class Ret, class Head, class Tail>
+	inline static Ret& get(TypeList<Head, Tail>& val)
+	{
+		return Getter<n-1>::template get<Ret, typename Tail::HeadType, typename Tail::TailType>(val.tail);
+	}
+
+	template <class Ret, class Head, class Tail>
+	inline static const Ret& get(const TypeList<Head, Tail>& val)
+	{
+		return Getter<n-1>::template get<Ret, typename Tail::HeadType, typename Tail::TailType>(val.tail);
+	}
+};
+
+
+template <> 
+struct Getter<0>
+{
+	template <class Ret, class Head, class Tail>
+	inline static Ret& get(TypeList<Head, Tail>& val)
+	{
+		return val.head;
+	}
+
+	template <class Ret, class Head, class Tail>
+	inline static const Ret& get(const TypeList<Head, Tail>& val)
+	{
+		return val.head;
+	}
+};
+
+
+template <int N, class Head> 
+struct TypeGetter;
+
+
+template <int N, class Head, class Tail> 
+struct TypeGetter<N, TypeList<Head, Tail> >
+{
+	typedef typename TypeGetter<N-1, Tail>::HeadType HeadType;
+	typedef typename TypeWrapper<HeadType>::CONSTTYPE ConstHeadType;
+};
+
+
+template <class Head, class Tail> 
+struct TypeGetter<0, TypeList<Head, Tail> >
+{
+	typedef typename TypeList<Head, Tail>::HeadType HeadType;
+	typedef typename TypeWrapper<HeadType>::CONSTTYPE ConstHeadType;
+};
+
+
+template <class Head, class T>
+struct TypeLocator;
+	/// TypeLocator returns the first occurrence of the type T in Head
+	/// or -1 if the type is not found.
+	///
+	/// Usage example:
+	///
+	/// TypeLocator<Head, int>::HeadType TypeLoc;
+	///
+	/// if (2 == TypeLoc.value) ...
+	///
+	
+
+template <class T>
+struct TypeLocator<NullTypeList, T>
+{
+	enum { value = -1 };
+};
+
+
+template <class T, class Tail>
+struct TypeLocator<TypeList<T, Tail>, T>
+{
+	enum { value = 0 };
+};
+
+
+template <class Head, class Tail, class T>
+struct TypeLocator<TypeList<Head, Tail>, T>
+{
+private:
+	enum { tmp = TypeLocator<Tail, T>::value };
+public:
+	enum { value = tmp == -1 ? -1 : 1 + tmp };
+};
+
+
+template <class Head, class T> 
+struct TypeAppender;
+	/// TypeAppender appends T (type or a TypeList) to Head.
+	///
+	/// Usage:
+	///
+	/// typedef TypeListType<char>::HeadType Type1;
+	/// typedef TypeAppender<Type1, int>::HeadType Type2;
+	/// (Type2 is a TypeList of char,int)
+	///
+	///	typedef TypeListType<float, double>::HeadType Type3;
+	/// typedef TypeAppender<Type2, Type3>::HeadType Type4;
+	/// (Type4 is a TypeList of char,int,float,double)
+	///
+
+
+template <>
+struct TypeAppender<NullTypeList, NullTypeList>
+{
+	typedef NullTypeList HeadType;
+};
+
+
+template <class T>
+struct TypeAppender<NullTypeList, T>
+{
+	typedef TypeList<T, NullTypeList> HeadType;
+};
+
+
+template <class Head, class Tail>
+struct TypeAppender<NullTypeList, TypeList<Head, Tail> >
+{
+	typedef TypeList<Head, Tail> HeadType;
+};
+
+
+template <class Head, class Tail, class T>
+struct TypeAppender<TypeList<Head, Tail>, T>
+{
+	typedef TypeList<Head, typename TypeAppender<Tail, T>::HeadType> HeadType;
+};
+
+
+template <class Head, class T> 
+struct TypeOneEraser;
+	/// TypeOneEraser erases the first occurence of the type T in Head.
+	/// Usage:
+	///
+	/// typedef TypeListType<char, int, float>::HeadType Type3;
+	/// typedef TypeOneEraser<Type3, int>::HeadType Type2;
+	/// (Type2 is a TypeList of char,float)
+	///
+
+
+template <class T>
+struct TypeOneEraser<NullTypeList, T>
+{
+	typedef NullTypeList HeadType;
+};
+
+
+template <class T, class Tail>
+struct TypeOneEraser<TypeList<T, Tail>, T>
+{
+	typedef Tail HeadType;
+};
+
+
+template <class Head, class Tail, class T>
+struct TypeOneEraser<TypeList<Head, Tail>, T>
+{
+	typedef TypeList <Head, typename TypeOneEraser<Tail, T>::HeadType> HeadType;
+};
+
+
+template <class Head, class T> 
+struct TypeAllEraser;
+	/// TypeAllEraser erases all the occurences of the type T in Head.
+	/// Usage:
+	///
+	/// typedef TypeListType<char, int, float, int>::HeadType Type4;
+	/// typedef TypeAllEraser<Type4, int>::HeadType Type2;
+	/// (Type2 is a TypeList of char,float)
+	///
+
+
+template <class T>
+struct TypeAllEraser<NullTypeList, T>
+{
+	typedef NullTypeList HeadType;
+};
+
+
+template <class T, class Tail>
+struct TypeAllEraser<TypeList<T, Tail>, T>
+{
+	typedef typename TypeAllEraser<Tail, T>::HeadType HeadType;
+};
+
+
+template <class Head, class Tail, class T>
+struct TypeAllEraser<TypeList<Head, Tail>, T>
+{
+	typedef TypeList <Head, typename TypeAllEraser<Tail, T>::HeadType> HeadType;
+};
+
+
+template <class Head> 
+struct TypeDuplicateEraser;
+	/// TypeDuplicateEraser erases all but the first occurence of the type T in Head.
+	/// Usage:
+	///
+	/// typedef TypeListType<char, int, float, int>::HeadType Type4;
+	/// typedef TypeDuplicateEraser<Type4, int>::HeadType Type3;
+	/// (Type3 is a TypeList of char,int,float)
+	///
+
+
+template <> 
+struct TypeDuplicateEraser<NullTypeList>
+{
+	typedef NullTypeList HeadType;
+};
+
+
+template <class Head, class Tail>
+struct TypeDuplicateEraser<TypeList<Head, Tail> >
+{
+private:
+	typedef typename TypeDuplicateEraser<Tail>::HeadType L1;
+	typedef typename TypeOneEraser<L1, Head>::HeadType L2;
+public:
+	typedef TypeList<Head, L2> HeadType;
+};
+
+
+template <class Head, class T, class R>
+struct TypeOneReplacer;
+	/// TypeOneReplacer replaces the first occurence 
+	/// of the type T in Head with type R.
+	/// Usage:
+	///
+	/// typedef TypeListType<char, int, float, int>::HeadType Type4;
+	/// typedef TypeOneReplacer<Type4, int, double>::HeadType TypeR;
+	/// (TypeR is a TypeList of char,double,float,int)
+	///
+
+
+template <class T, class R>
+struct TypeOneReplacer<NullTypeList, T, R>
+{
+	typedef NullTypeList HeadType;
+};
+
+
+template <class T, class Tail, class R>
+struct TypeOneReplacer<TypeList<T, Tail>, T, R>
+{
+	typedef TypeList<R, Tail> HeadType;
+};
+
+
+template <class Head, class Tail, class T, class R>
+struct TypeOneReplacer<TypeList<Head, Tail>, T, R>
+{
+	typedef TypeList<Head, typename TypeOneReplacer<Tail, T, R>::HeadType> HeadType;
+};
+
+
+template <class Head, class T, class R>
+struct TypeAllReplacer;
+	/// TypeAllReplacer replaces all the occurences 
+	/// of the type T in Head with type R.
+	/// Usage:
+	///
+	/// typedef TypeListType<char, int, float, int>::HeadType Type4;
+	/// typedef TypeAllReplacer<Type4, int, double>::HeadType TypeR;
+	/// (TypeR is a TypeList of char,double,float,double)
+	///
+
+
+template <class T, class R>
+struct TypeAllReplacer<NullTypeList, T, R>
+{
+	typedef NullTypeList HeadType;
+};
+
+
+template <class T, class Tail, class R>
+struct TypeAllReplacer<TypeList<T, Tail>, T, R>
+{
+	typedef TypeList<R, typename TypeAllReplacer<Tail, T, R>::HeadType> HeadType;
+};
+
+
+template <class Head, class Tail, class T, class R>
+struct TypeAllReplacer<TypeList<Head, Tail>, T, R>
+{
+	typedef TypeList<Head, typename TypeAllReplacer<Tail, T, R>::HeadType> HeadType;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_TypeList_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Types.h b/base/poco/Foundation/include/Poco/Types.h
new file mode 100644
index 00000000000..f3d2ebc0045
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Types.h
@@ -0,0 +1,201 @@
+//
+// Types.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Types
+//
+// Definitions of fixed-size integer types for various platforms
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Types_INCLUDED
+#define Foundation_Types_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+#if defined(_MSC_VER)
+	//
+	// Windows/Visual C++
+	//
+	typedef signed char            Int8;
+	typedef unsigned char          UInt8;
+	typedef signed short           Int16;
+	typedef unsigned short         UInt16;
+	typedef signed int             Int32;
+	typedef unsigned int           UInt32;
+	typedef signed __int64         Int64;
+	typedef unsigned __int64       UInt64;
+	#if defined(_WIN64)
+		#define POCO_PTR_IS_64_BIT 1
+		typedef signed __int64     IntPtr;
+		typedef unsigned __int64   UIntPtr;
+	#else
+		typedef signed long        IntPtr;
+		typedef unsigned long      UIntPtr;
+	#endif
+	#define POCO_HAVE_INT64 1
+#elif defined(__GNUC__) || defined(__clang__)
+	//
+	// Unix/GCC/Clang
+	//
+	typedef signed char            Int8;
+	typedef unsigned char          UInt8;
+	typedef signed short           Int16;
+	typedef unsigned short         UInt16;
+	typedef signed int             Int32;
+	typedef unsigned int           UInt32;
+	#if defined(_WIN64)
+		#define POCO_PTR_IS_64_BIT 1
+		typedef signed long long   IntPtr;
+		typedef unsigned long long UIntPtr;
+		typedef signed long long   Int64;
+		typedef unsigned long long UInt64;
+	#else
+		typedef signed long        IntPtr;
+		typedef unsigned long      UIntPtr;
+		#if defined(__LP64__)
+			#define POCO_PTR_IS_64_BIT 1
+			#define POCO_LONG_IS_64_BIT 1
+			typedef signed long        Int64;
+			typedef unsigned long      UInt64;
+		#else
+			typedef signed long long   Int64;
+			typedef unsigned long long UInt64;
+		#endif
+	#endif
+	#define POCO_HAVE_INT64 1
+#elif defined(__DECCXX)
+	//
+	// Compaq C++
+	//
+	typedef signed char            Int8;
+	typedef unsigned char          UInt8;
+	typedef signed short           Int16;
+	typedef unsigned short         UInt16;
+	typedef signed int             Int32;
+	typedef unsigned int           UInt32;
+	typedef signed __int64         Int64;
+	typedef unsigned __int64       UInt64;
+	typedef signed long        IntPtr;
+	typedef unsigned long      UIntPtr;
+	#define POCO_PTR_IS_64_BIT 1
+	#define POCO_LONG_IS_64_BIT 1
+	#define POCO_HAVE_INT64 1
+#elif defined(__HP_aCC)
+	//
+	// HP Ansi C++
+	//
+	typedef signed char            Int8;
+	typedef unsigned char          UInt8;
+	typedef signed short           Int16;
+	typedef unsigned short         UInt16;
+	typedef signed int             Int32;
+	typedef unsigned int           UInt32;
+	typedef signed long            IntPtr;
+	typedef unsigned long          UIntPtr;
+	#if defined(__LP64__)
+		#define POCO_PTR_IS_64_BIT 1
+		#define POCO_LONG_IS_64_BIT 1
+		typedef signed long        Int64;
+		typedef unsigned long      UInt64;
+	#else
+		typedef signed long long   Int64;
+		typedef unsigned long long UInt64;
+	#endif
+	#define POCO_HAVE_INT64 1
+#elif defined(__SUNPRO_CC)
+	//
+	// SUN Forte C++
+	//
+	typedef signed char            Int8;
+	typedef unsigned char          UInt8;
+	typedef signed short           Int16;
+	typedef unsigned short         UInt16;
+	typedef signed int             Int32;
+	typedef unsigned int           UInt32;
+	typedef signed long            IntPtr;
+	typedef unsigned long          UIntPtr;
+	#if defined(__sparcv9)
+		#define POCO_PTR_IS_64_BIT 1
+		#define POCO_LONG_IS_64_BIT 1
+		typedef signed long        Int64;
+		typedef unsigned long      UInt64;
+	#else
+		typedef signed long long   Int64;
+		typedef unsigned long long UInt64;
+	#endif
+	#define POCO_HAVE_INT64 1
+#elif defined(__IBMCPP__)
+	//
+	// IBM XL C++
+	//
+	typedef signed char            Int8;
+	typedef unsigned char          UInt8;
+	typedef signed short           Int16;
+	typedef unsigned short         UInt16;
+	typedef signed int             Int32;
+	typedef unsigned int           UInt32;
+	typedef signed long            IntPtr;
+	typedef unsigned long          UIntPtr;
+	#if defined(__64BIT__)
+		#define POCO_PTR_IS_64_BIT 1
+		#define POCO_LONG_IS_64_BIT 1
+		typedef signed long        Int64;
+		typedef unsigned long      UInt64;
+	#else
+		typedef signed long long   Int64;
+		typedef unsigned long long UInt64;
+	#endif
+	#define POCO_HAVE_INT64 1
+#elif defined(__sgi)
+	//
+	// MIPSpro C++
+	//
+	typedef signed char            Int8;
+	typedef unsigned char          UInt8;
+	typedef signed short           Int16;
+	typedef unsigned short         UInt16;
+	typedef signed int             Int32;
+	typedef unsigned int           UInt32;
+	typedef signed long            IntPtr;
+	typedef unsigned long          UIntPtr;
+	#if _MIPS_SZLONG == 64
+		#define POCO_PTR_IS_64_BIT 1
+		#define POCO_LONG_IS_64_BIT 1
+		typedef signed long        Int64;
+		typedef unsigned long      UInt64;
+	#else
+		typedef signed long long   Int64;
+		typedef unsigned long long UInt64;
+	#endif
+	#define POCO_HAVE_INT64 1
+#elif defined(_DIAB_TOOL)
+	typedef signed char        Int8;
+	typedef unsigned char      UInt8;
+	typedef signed short       Int16;
+	typedef unsigned short     UInt16;
+	typedef signed int         Int32;
+	typedef unsigned int       UInt32;
+	typedef signed long        IntPtr;
+	typedef unsigned long      UIntPtr;
+	typedef signed long long   Int64;
+	typedef unsigned long long UInt64;
+	#define POCO_HAVE_INT64 1
+#endif
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Types_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/URI.h b/base/poco/Foundation/include/Poco/URI.h
new file mode 100644
index 00000000000..b6d41de93d1
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/URI.h
@@ -0,0 +1,406 @@
+//
+// URI.h
+//
+// Library: Foundation
+// Package: URI
+// Module:  URI
+//
+// Definition of the URI class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_URI_INCLUDED
+#define Foundation_URI_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <vector>
+#include <utility>
+
+
+namespace Poco {
+
+
+class Path;
+
+
+class Foundation_API URI
+	/// A Uniform Resource Identifier, as specified in RFC 3986.
+	/// 
+	/// The URI class provides methods for building URIs from their
+	/// parts, as well as for splitting URIs into their parts.
+	/// Furthermore, the class provides methods for resolving
+	/// relative URIs against base URIs.
+	///
+	/// The class automatically performs a few normalizations on
+	/// all URIs and URI parts passed to it:
+	///   * scheme identifiers are converted to lower case
+	///   * percent-encoded characters are decoded (except for the query string)
+	///   * optionally, dot segments are removed from paths (see normalize())
+	///
+	/// Note that dealing with query strings requires some precautions, as, internally,
+	/// query strings are stored in percent-encoded form, while all other parts of the URI
+	/// are stored in decoded form. While parsing query strings from properly encoded URLs
+	/// generally works, explicitly setting query strings with setQuery() or extracting
+	/// query strings with getQuery() may lead to ambiguities. See the descriptions of
+	/// setQuery(), setRawQuery(), getQuery() and getRawQuery() for more information.
+{
+public:
+	typedef std::vector<std::pair<std::string, std::string> > QueryParameters;
+
+	URI();
+		/// Creates an empty URI.
+
+	explicit URI(const std::string& uri);
+		/// Parses an URI from the given string. Throws a
+		/// SyntaxException if the uri is not valid.
+		
+	explicit URI(const char* uri);
+		/// Parses an URI from the given string. Throws a
+		/// SyntaxException if the uri is not valid.
+		
+	URI(const std::string& scheme, const std::string& pathEtc);
+		/// Creates an URI from its parts.
+		
+	URI(const std::string& scheme, const std::string& authority, const std::string& pathEtc);
+		/// Creates an URI from its parts.
+
+	URI(const std::string& scheme, const std::string& authority, const std::string& path, const std::string& query);
+		/// Creates an URI from its parts.
+
+	URI(const std::string& scheme, const std::string& authority, const std::string& path, const std::string& query, const std::string& fragment);
+		/// Creates an URI from its parts.
+
+	URI(const URI& uri);
+		/// Copy constructor. Creates an URI from another one.
+		
+	URI(const URI& baseURI, const std::string& relativeURI);
+		/// Creates an URI from a base URI and a relative URI, according to
+		/// the algorithm in section 5.2 of RFC 3986.
+
+	explicit URI(const Path& path);
+		/// Creates a URI from a path.
+		///
+		/// The path will be made absolute, and a file:// URI
+		/// will be built from it.
+
+	~URI();
+		/// Destroys the URI.
+	
+	URI& operator = (const URI& uri);
+		/// Assignment operator.
+		
+	URI& operator = (const std::string& uri);
+		/// Parses and assigns an URI from the given string. Throws a
+		/// SyntaxException if the uri is not valid.
+
+	URI& operator = (const char* uri);
+		/// Parses and assigns an URI from the given string. Throws a
+		/// SyntaxException if the uri is not valid.
+		
+	void swap(URI& uri);
+		/// Swaps the URI with another one.	
+		
+	void clear();
+		/// Clears all parts of the URI.
+	
+	std::string toString() const;
+		/// Returns a string representation of the URI.
+		///
+		/// Characters in the path, query and fragment parts will be 
+		/// percent-encoded as necessary.
+	
+	const std::string& getScheme() const;
+		/// Returns the scheme part of the URI.
+		
+	void setScheme(const std::string& scheme);
+		/// Sets the scheme part of the URI. The given scheme
+		/// is converted to lower-case.
+		///
+		/// A list of registered URI schemes can be found
+		/// at <http://www.iana.org/assignments/uri-schemes>.
+		
+	const std::string& getUserInfo() const;
+		/// Returns the user-info part of the URI.
+		
+	void setUserInfo(const std::string& userInfo);
+		/// Sets the user-info part of the URI.
+		
+	const std::string& getHost() const;
+		/// Returns the host part of the URI.
+		
+	void setHost(const std::string& host);
+		/// Sets the host part of the URI.
+		
+	unsigned short getPort() const;
+		/// Returns the port number part of the URI.
+		///
+		/// If no port number (0) has been specified, the
+		/// well-known port number (e.g., 80 for http) for
+		/// the given scheme is returned if it is known.
+		/// Otherwise, 0 is returned.
+		
+	void setPort(unsigned short port);
+		/// Sets the port number part of the URI.
+		
+	std::string getAuthority() const;
+		/// Returns the authority part (userInfo, host and port)
+		/// of the URI. 
+		///
+		/// If the port number is a well-known port
+		/// number for the given scheme (e.g., 80 for http), it
+		/// is not included in the authority.
+		
+	void setAuthority(const std::string& authority);
+		/// Parses the given authority part for the URI and sets
+		/// the user-info, host, port components accordingly.
+		
+	const std::string& getPath() const;
+		/// Returns the decoded path part of the URI.
+		
+	void setPath(const std::string& path);
+		/// Sets the path part of the URI.
+	
+	std::string getQuery() const;
+		/// Returns the decoded query part of the URI.
+		///
+		/// Note that encoded ampersand characters ('&', "%26") 
+		/// will be decoded, which could cause ambiguities if the query 
+		/// string contains multiple parameters and a parameter name
+		/// or value contains an ampersand as well.
+		/// In such a case it's better to use getRawQuery() or
+		/// getQueryParameters().
+		
+	void setQuery(const std::string& query);	
+		/// Sets the query part of the URI.
+		///
+		/// The query string will be percent-encoded. If the query
+		/// already contains percent-encoded characters, these
+		/// will be double-encoded, which is probably not what's
+		/// intended by the caller. Furthermore, ampersand ('&')
+		/// characters in the query will not be encoded. This could
+		/// lead to ambiguity issues if the query string contains multiple
+		/// name-value parameters separated by ampersand, and if any
+		/// name or value also contains an ampersand. In such a 
+		/// case, it's better to use setRawQuery() with a properly
+		/// percent-encoded query string, or use addQueryParameter()
+		/// or setQueryParameters(), which take care of appropriate 
+		/// percent encoding of parameter names and values.
+
+	void addQueryParameter(const std::string& param, const std::string& val = "");
+		/// Adds "param=val" to the query; "param" may not be empty.
+		/// If val is empty, only '=' is appended to the parameter.
+		/// 
+		/// In addition to regular encoding, function also encodes '&' and '=',
+		/// if found in param or val.
+
+	const std::string& getRawQuery() const;
+		/// Returns the query string in raw form, which usually
+		/// means percent encoded.
+		
+	void setRawQuery(const std::string& query);	
+		/// Sets the query part of the URI.
+		///
+		/// The given query string must be properly percent-encoded.
+	
+	QueryParameters getQueryParameters() const;
+		/// Returns the decoded query string parameters as a vector
+		/// of name-value pairs.
+
+	void setQueryParameters(const QueryParameters& params);
+		/// Sets the query part of the URI from a vector
+		/// of query parameters.
+		///
+		/// Calls addQueryParameter() for each parameter name and value.
+
+	const std::string& getFragment() const;
+		/// Returns the fragment part of the URI.
+		
+	void setFragment(const std::string& fragment);
+		/// Sets the fragment part of the URI.
+		
+	void setPathEtc(const std::string& pathEtc);
+		/// Sets the path, query and fragment parts of the URI.
+		
+	std::string getPathEtc() const;
+		/// Returns the encoded path, query and fragment parts of the URI.
+		
+	std::string getPathAndQuery() const;
+		/// Returns the encoded path and query parts of the URI.	
+		
+	void resolve(const std::string& relativeURI);
+		/// Resolves the given relative URI against the base URI.
+		/// See section 5.2 of RFC 3986 for the algorithm used.
+
+	void resolve(const URI& relativeURI);
+		/// Resolves the given relative URI against the base URI.
+		/// See section 5.2 of RFC 3986 for the algorithm used.
+
+	bool isRelative() const;
+		/// Returns true if the URI is a relative reference, false otherwise.
+		///
+		/// A relative reference does not contain a scheme identifier.
+		/// Relative references are usually resolved against an absolute
+		/// base reference.
+	
+	bool empty() const;
+		/// Returns true if the URI is empty, false otherwise.
+		
+	bool operator == (const URI& uri) const;
+		/// Returns true if both URIs are identical, false otherwise.
+		///
+		/// Two URIs are identical if their scheme, authority,
+		/// path, query and fragment part are identical.
+
+	bool operator == (const std::string& uri) const;
+		/// Parses the given URI and returns true if both URIs are identical,
+		/// false otherwise.
+
+	bool operator != (const URI& uri) const;
+		/// Returns true if both URIs are identical, false otherwise.
+
+	bool operator != (const std::string& uri) const;
+		/// Parses the given URI and returns true if both URIs are identical,
+		/// false otherwise.
+		
+	void normalize();
+		/// Normalizes the URI by removing all but leading . and .. segments from the path.
+		///
+		/// If the first path segment in a relative path contains a colon (:), 
+		/// such as in a Windows path containing a drive letter, a dot segment (./) 
+		/// is prepended in accordance with section 3.3 of RFC 3986.
+	
+	void getPathSegments(std::vector<std::string>& segments);
+		/// Places the single path segments (delimited by slashes) into the
+		/// given vector.
+	
+	static void encode(const std::string& str, const std::string& reserved, std::string& encodedStr);
+		/// URI-encodes the given string by escaping reserved and non-ASCII
+		/// characters. The encoded string is appended to encodedStr.
+		
+	static void decode(const std::string& str, std::string& decodedStr, bool plusAsSpace = false);
+		/// URI-decodes the given string by replacing percent-encoded
+		/// characters with the actual character. The decoded string
+		/// is appended to decodedStr.
+		///
+		/// When plusAsSpace is true, non-encoded plus signs in the query are decoded as spaces.
+		/// (http://www.w3.org/TR/html401/interact/forms.html#h-17.13.4.1)
+
+protected:
+	bool equals(const URI& uri) const;
+		/// Returns true if both uri's are equivalent.
+	
+	bool isWellKnownPort() const;
+		/// Returns true if the URI's port number is a well-known one
+		/// (for example, 80, if the scheme is http).
+		
+	unsigned short getWellKnownPort() const;
+		/// Returns the well-known port number for the URI's scheme,
+		/// or 0 if the port number is not known.
+		
+	void parse(const std::string& uri);
+		/// Parses and assigns an URI from the given string. Throws a
+		/// SyntaxException if the uri is not valid.
+
+	void parseAuthority(std::string::const_iterator& it, const std::string::const_iterator& end);
+		/// Parses and sets the user-info, host and port from the given data.
+
+	void parseHostAndPort(std::string::const_iterator& it, const std::string::const_iterator& end);
+		/// Parses and sets the host and port from the given data.
+
+	void parsePath(std::string::const_iterator& it, const std::string::const_iterator& end);
+		/// Parses and sets the path from the given data.
+
+	void parsePathEtc(std::string::const_iterator& it, const std::string::const_iterator& end);
+		/// Parses and sets the path, query and fragment from the given data.
+
+	void parseQuery(std::string::const_iterator& it, const std::string::const_iterator& end);
+		/// Parses and sets the query from the given data.
+
+	void parseFragment(std::string::const_iterator& it, const std::string::const_iterator& end);
+		/// Parses and sets the fragment from the given data.
+
+	void mergePath(const std::string& path);
+		/// Appends a path to the URI's path.
+
+	void removeDotSegments(bool removeLeading = true);
+		/// Removes all dot segments from the path.
+
+	static void getPathSegments(const std::string& path, std::vector<std::string>& segments);
+		/// Places the single path segments (delimited by slashes) into the
+		/// given vector.
+
+	void buildPath(const std::vector<std::string>& segments, bool leadingSlash, bool trailingSlash);
+		/// Builds the path from the given segments.
+
+	static const std::string RESERVED_PATH;
+	static const std::string RESERVED_QUERY;
+	static const std::string RESERVED_QUERY_PARAM;
+	static const std::string RESERVED_FRAGMENT;
+	static const std::string ILLEGAL;
+	
+private:
+	std::string    _scheme;
+	std::string    _userInfo;
+	std::string    _host;
+	unsigned short _port;
+	std::string    _path;
+	std::string    _query;
+	std::string    _fragment;
+};
+
+
+//
+// inlines
+//
+inline const std::string& URI::getScheme() const
+{
+	return _scheme;
+}
+	
+
+inline const std::string& URI::getUserInfo() const
+{
+	return _userInfo;
+}
+
+	
+inline const std::string& URI::getHost() const
+{
+	return _host;
+}
+
+	
+inline const std::string& URI::getPath() const
+{
+	return _path;
+}
+
+	
+inline const std::string& URI::getRawQuery() const
+{
+	return _query;
+}
+
+	
+inline const std::string& URI::getFragment() const
+{
+	return _fragment;
+}
+
+
+inline void swap(URI& u1, URI& u2)
+{
+	u1.swap(u2);
+}
+
+	
+} // namespace Poco
+
+
+#endif // Foundation_URI_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/URIStreamFactory.h b/base/poco/Foundation/include/Poco/URIStreamFactory.h
new file mode 100644
index 00000000000..c5efa22bdd8
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/URIStreamFactory.h
@@ -0,0 +1,97 @@
+//
+// URIStreamFactory.h
+//
+// Library: Foundation
+// Package: URI
+// Module:  URIStreamFactory
+//
+// Definition of the URIStreamFactory class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_URIStreamFactory_INCLUDED
+#define Foundation_URIStreamFactory_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include <istream>
+
+
+namespace Poco {
+
+
+class URI;
+
+
+class Foundation_API URIStreamFactory
+	/// This class defines the interface that all
+	/// URI stream factories must implement.
+	///
+	/// Subclasses must implement the open() method.
+{
+public:
+	URIStreamFactory();
+		/// Creates the URIStreamFactory.
+
+	virtual std::istream* open(const URI& uri) = 0;
+		/// Tries to create and open an input stream for the
+		/// resource specified by the given URI.
+		///
+		/// If the stream cannot be opened for whatever reason,
+		/// an appropriate IOException must be thrown.
+		///
+		/// If opening the stream results in a redirect, a
+		/// URIRedirection exception should be thrown.
+
+protected:
+	virtual ~URIStreamFactory();
+		/// Destroys the URIStreamFactory.
+
+private:
+	URIStreamFactory(const URIStreamFactory&);
+	URIStreamFactory& operator = (const URIStreamFactory&);
+	
+	friend class URIStreamOpener;
+};
+
+
+class Foundation_API URIRedirection
+	/// An instance of URIRedirection is thrown by a URIStreamFactory::open()
+	/// if opening the original URI resulted in a redirection response
+	/// (such as a MOVED PERMANENTLY in HTTP).
+{
+public:
+	URIRedirection(const std::string& uri);
+	URIRedirection(const URIRedirection& redir);
+	
+	URIRedirection& operator = (const URIRedirection& redir);
+	void swap(URIRedirection& redir);
+	
+	const std::string& uri() const;
+		/// Returns the new URI.
+	
+private:
+	URIRedirection();
+	
+	std::string _uri;
+};
+
+
+//
+// inlines
+//
+inline const std::string& URIRedirection::uri() const
+{
+	return _uri;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_URIStreamFactory_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/URIStreamOpener.h b/base/poco/Foundation/include/Poco/URIStreamOpener.h
new file mode 100644
index 00000000000..85de22b1ab8
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/URIStreamOpener.h
@@ -0,0 +1,135 @@
+//
+// URIStreamOpener.h
+//
+// Library: Foundation
+// Package: URI
+// Module:  URIStreamOpener
+//
+// Definition of the URIStreamOpener class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_URIStreamOpener_INCLUDED
+#define Foundation_URIStreamOpener_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Mutex.h"
+#include <istream>
+#include <map>
+
+
+namespace Poco {
+
+
+class URI;
+class URIStreamFactory;
+class Path;
+
+
+class Foundation_API URIStreamOpener
+	/// The URIStreamOpener class is used to create and open input streams
+	/// for resourced identified by Uniform Resource Identifiers.
+	///
+	/// For every URI scheme used, a URIStreamFactory must be registered.
+	/// A FileStreamFactory is automatically registered for file URIs.
+{
+public:
+	enum
+	{
+		MAX_REDIRECTS = 10
+	};
+	
+	URIStreamOpener();
+		/// Creates the URIStreamOpener and registers a FileStreamFactory
+		/// for file URIs.
+
+	~URIStreamOpener();
+		/// Destroys the URIStreamOpener and deletes all registered
+		/// URI stream factories.
+
+	std::istream* open(const URI& uri) const;
+		/// Tries to create and open an input stream for the resource specified
+		/// by the given uniform resource identifier.
+		///
+		/// If no URIStreamFactory has been registered for the URI's
+		/// scheme, a UnknownURIScheme exception is thrown.
+		/// If the stream cannot be opened for any reason, an
+		/// IOException is thrown.
+		///
+		/// The given URI must be a valid one. This excludes file system paths.
+		///
+		/// Whoever calls the method is responsible for deleting
+		/// the returned stream.
+
+	std::istream* open(const std::string& pathOrURI) const;
+		/// Tries to create and open an input stream for the resource specified
+		/// by the given path or uniform resource identifier.
+		///
+		/// If the stream cannot be opened for any reason, an
+		/// Exception is thrown.
+		///
+		/// The method first tries to interpret the given pathOrURI as an URI.
+		/// If this fails, the pathOrURI is treated as local filesystem path.
+		/// If this also fails, an exception is thrown.
+		///
+		/// Whoever calls the method is responsible for deleting
+		/// the returned stream.
+
+	std::istream* open(const std::string& basePathOrURI, const std::string& pathOrURI) const;
+		/// Tries to create and open an input stream for the resource specified
+		/// by the given path or uniform resource identifier.
+		///
+		/// pathOrURI is resolved against basePathOrURI (see URI::resolve() and
+		/// Path::resolve() for more information).
+		///
+		/// If the stream cannot be opened for any reason, an
+		/// Exception is thrown.
+		///
+		/// Whoever calls the method is responsible for deleting
+		/// the returned stream.
+		
+	void registerStreamFactory(const std::string& scheme, URIStreamFactory* pFactory);
+		/// Registers a URIStreamFactory for the given scheme. If another factory
+		/// has already been registered for the scheme, an ExistsException is thrown.
+		///
+		/// The URIStreamOpener takes ownership of the factory and deletes it when it is
+		/// no longer needed (in other words, when the URIStreamOpener is deleted).
+
+	void unregisterStreamFactory(const std::string& scheme);
+		/// Unregisters and deletes the URIStreamFactory for the given scheme.
+		///
+		/// Throws a NotFoundException if no URIStreamFactory has been registered
+		/// for the given scheme.
+		
+	bool supportsScheme(const std::string& scheme);
+		/// Returns true iff a URIStreamFactory for the given scheme
+		/// has been registered.
+
+	static URIStreamOpener& defaultOpener();
+		/// Returns a reference to the default URIStreamOpener.
+
+protected:
+	std::istream* openFile(const Path& path) const;
+	std::istream* openURI(const std::string& scheme, const URI& uri) const;
+
+private:
+	URIStreamOpener(const URIStreamOpener&);
+	URIStreamOpener& operator = (const URIStreamOpener&);
+
+	typedef std::map<std::string, URIStreamFactory*> FactoryMap;
+	
+	FactoryMap        _map;
+	mutable FastMutex _mutex;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_URIStreamOpener_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/UTF16Encoding.h b/base/poco/Foundation/include/Poco/UTF16Encoding.h
new file mode 100644
index 00000000000..0d38a71ddf1
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/UTF16Encoding.h
@@ -0,0 +1,85 @@
+//
+// UTF16Encoding.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  UTF16Encoding
+//
+// Definition of the UTF16Encoding class.
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_UTF16Encoding_INCLUDED
+#define Foundation_UTF16Encoding_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/TextEncoding.h"
+
+
+namespace Poco {
+
+
+class Foundation_API UTF16Encoding: public TextEncoding
+	/// UTF-16 text encoding, as defined in RFC 2781.
+	///
+	/// When converting from UTF-16 to Unicode, surrogates are
+	/// reported as they are - in other words, surrogate pairs
+	/// are not combined into one Unicode character. 
+	/// When converting from Unicode to UTF-16, however, characters
+	/// outside the 16-bit range are converted into a low and
+	/// high surrogate.
+{
+public:
+	enum ByteOrderType
+	{
+		BIG_ENDIAN_BYTE_ORDER,
+		LITTLE_ENDIAN_BYTE_ORDER,
+		NATIVE_BYTE_ORDER
+	};
+	
+	UTF16Encoding(ByteOrderType byteOrder = NATIVE_BYTE_ORDER);
+		/// Creates and initializes the encoding for the given byte order.
+		
+	UTF16Encoding(int byteOrderMark);
+		/// Creates and initializes the encoding for the byte-order
+		/// indicated by the given byte-order mark, which is the Unicode
+		/// character 0xFEFF.
+		
+	~UTF16Encoding();
+	
+	ByteOrderType getByteOrder() const;
+		/// Returns the byte-order currently in use.
+		
+	void setByteOrder(ByteOrderType byteOrder);
+		/// Sets the byte order.
+		
+	void setByteOrder(int byteOrderMark);
+		/// Sets the byte order according to the given
+		/// byte order mark, which is the Unicode
+		/// character 0xFEFF.
+	
+	const char* canonicalName() const;
+	bool isA(const std::string& encodingName) const;
+	const CharacterMap& characterMap() const;
+	int convert(const unsigned char* bytes) const;
+	int convert(int ch, unsigned char* bytes, int length) const;
+	int queryConvert(const unsigned char* bytes, int length) const;
+	int sequenceLength(const unsigned char* bytes, int length) const;
+	
+private:
+	bool _flipBytes;
+	static const char* _names[];
+	static const CharacterMap _charMap;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_UTF16Encoding_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/UTF32Encoding.h b/base/poco/Foundation/include/Poco/UTF32Encoding.h
new file mode 100644
index 00000000000..6f8af525a66
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/UTF32Encoding.h
@@ -0,0 +1,82 @@
+//
+// UTF32Encoding.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  UTF32Encoding
+//
+// Definition of the UTF32Encoding class.
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_UTF32Encoding_INCLUDED
+#define Foundation_UTF32Encoding_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/TextEncoding.h"
+
+
+namespace Poco {
+
+
+class Foundation_API UTF32Encoding: public TextEncoding
+	/// UTF-32 text encoding, as defined in RFC 2781.
+	///
+	/// When converting from UTF-32 to Unicode, surrogates are
+	/// reported as they are - in other words, surrogate pairs
+	/// are not combined into one Unicode character. 
+{
+public:
+	enum ByteOrderType
+	{
+		BIG_ENDIAN_BYTE_ORDER,
+		LITTLE_ENDIAN_BYTE_ORDER,
+		NATIVE_BYTE_ORDER
+	};
+	
+	UTF32Encoding(ByteOrderType byteOrder = NATIVE_BYTE_ORDER);
+		/// Creates and initializes the encoding for the given byte order.
+		
+	UTF32Encoding(int byteOrderMark);
+		/// Creates and initializes the encoding for the byte-order
+		/// indicated by the given byte-order mark, which is the Unicode
+		/// character 0xFEFF.
+		
+	~UTF32Encoding();
+	
+	ByteOrderType getByteOrder() const;
+		/// Returns the byte-order currently in use.
+		
+	void setByteOrder(ByteOrderType byteOrder);
+		/// Sets the byte order.
+		
+	void setByteOrder(int byteOrderMark);
+		/// Sets the byte order according to the given
+		/// byte order mark, which is the Unicode
+		/// character 0xFEFF.
+	
+	const char* canonicalName() const;
+	bool isA(const std::string& encodingName) const;
+	const CharacterMap& characterMap() const;
+	int convert(const unsigned char* bytes) const;
+	int convert(int ch, unsigned char* bytes, int length) const;
+	int queryConvert(const unsigned char* bytes, int length) const;
+	int sequenceLength(const unsigned char* bytes, int length) const;
+	
+private:
+	bool _flipBytes;
+	static const char* _names[];
+	static const CharacterMap _charMap;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_UTF32Encoding_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/UTF8Encoding.h b/base/poco/Foundation/include/Poco/UTF8Encoding.h
new file mode 100644
index 00000000000..66e29d2d00e
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/UTF8Encoding.h
@@ -0,0 +1,61 @@
+//
+// UTF8Encoding.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  UTF8Encoding
+//
+// Definition of the UTF8Encoding class.
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_UTF8Encoding_INCLUDED
+#define Foundation_UTF8Encoding_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/TextEncoding.h"
+
+
+namespace Poco {
+
+
+class Foundation_API UTF8Encoding: public TextEncoding
+	/// UTF-8 text encoding, as defined in RFC 2279.
+{
+public:
+	UTF8Encoding();
+	~UTF8Encoding();
+	const char* canonicalName() const;
+	bool isA(const std::string& encodingName) const;
+	const CharacterMap& characterMap() const;
+	int convert(const unsigned char* bytes) const;
+	int convert(int ch, unsigned char* bytes, int length) const;
+	int queryConvert(const unsigned char* bytes, int length) const;
+	int sequenceLength(const unsigned char* bytes, int length) const;
+
+	static bool isLegal(const unsigned char *bytes, int length);
+		/// Utility routine to tell whether a sequence of bytes is legal UTF-8.
+		/// This must be called with the length pre-determined by the first byte.
+		/// The sequence is illegal right away if there aren't enough bytes 
+		/// available. If presented with a length > 4, this function returns false.
+		/// The Unicode definition of UTF-8 goes up to 4-byte sequences.
+		/// 
+		/// Adapted from ftp://ftp.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.c
+		/// Copyright 2001-2004 Unicode, Inc.
+
+private:
+	static const char* _names[];
+	static const CharacterMap _charMap;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_UTF8Encoding_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/UTF8String.h b/base/poco/Foundation/include/Poco/UTF8String.h
new file mode 100644
index 00000000000..73898c65c10
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/UTF8String.h
@@ -0,0 +1,83 @@
+//
+// UTF8String.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  UTF8String
+//
+// Definition of the UTF8 string functions.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_UTF8String_INCLUDED
+#define Foundation_UTF8String_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+struct Foundation_API UTF8
+	/// This class provides static methods that are UTF-8 capable variants
+	/// of the same functions in Poco/String.h.
+	///
+	/// The various variants of icompare() provide case insensitive comparison
+	/// for UTF-8 encoded strings.
+	///
+	/// toUpper(), toUpperInPlace(), toLower() and toLowerInPlace() provide
+	/// Unicode-based character case transformation for UTF-8 encoded strings.
+	///
+	/// removeBOM() removes the UTF-8 Byte Order Mark sequence (0xEF, 0xBB, 0xBF)
+	/// from the beginning of the given string, if it's there.
+{
+	static int icompare(const std::string& str, std::string::size_type pos, std::string::size_type n, std::string::const_iterator it2, std::string::const_iterator end2);
+	static int icompare(const std::string& str1, const std::string& str2);
+	static int icompare(const std::string& str1, std::string::size_type n1, const std::string& str2, std::string::size_type n2);
+	static int icompare(const std::string& str1, std::string::size_type n, const std::string& str2);
+	static int icompare(const std::string& str1, std::string::size_type pos, std::string::size_type n, const std::string& str2);
+	static int icompare(const std::string& str1, std::string::size_type pos1, std::string::size_type n1, const std::string& str2, std::string::size_type pos2, std::string::size_type n2);
+	static int icompare(const std::string& str1, std::string::size_type pos1, std::string::size_type n, const std::string& str2, std::string::size_type pos2);
+	static int icompare(const std::string& str, std::string::size_type pos, std::string::size_type n, const std::string::value_type* ptr);
+	static int icompare(const std::string& str, std::string::size_type pos, const std::string::value_type* ptr);
+	static int icompare(const std::string& str, const std::string::value_type* ptr);
+
+	static std::string toUpper(const std::string& str);
+	static std::string& toUpperInPlace(std::string& str);
+	static std::string toLower(const std::string& str);
+	static std::string& toLowerInPlace(std::string& str);
+	
+	static void removeBOM(std::string& str);
+		/// Remove the UTF-8 Byte Order Mark sequence (0xEF, 0xBB, 0xBF)
+		/// from the beginning of the string, if it's there.
+
+	static std::string escape(const std::string& s, bool strictJSON = false);
+		/// Escapes a string. Special characters like tab, backslash, ... are
+		/// escaped. Unicode characters are escaped to \uxxxx.
+		/// If strictJSON is true, \a and \v will be escaped to \\u0007 and \\u000B
+		/// instead of \\a and \\v for strict JSON conformance.
+
+	static std::string escape(const std::string::const_iterator& begin, const std::string::const_iterator& end, bool strictJSON = false);
+		/// Escapes a string. Special characters like tab, backslash, ... are
+		/// escaped. Unicode characters are escaped to \uxxxx.
+		/// If strictJSON is true, \a and \v will be escaped to \\u0007 and \\u000B
+		/// instead of \\a and \\v for strict JSON conformance.
+
+	static std::string unescape(const std::string& s);
+		/// Creates an UTF8 string from a string that contains escaped characters.
+
+	static std::string unescape(const std::string::const_iterator& begin, const std::string::const_iterator& end);
+		/// Creates an UTF8 string from a string that contains escaped characters.
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_UTF8String_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/UTFString.h b/base/poco/Foundation/include/Poco/UTFString.h
new file mode 100644
index 00000000000..7364583e79f
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/UTFString.h
@@ -0,0 +1,305 @@
+//
+// UTFString.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  UTFString
+//
+// Definitions of strings for UTF encodings.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_UTFString_INCLUDED
+#define Foundation_UTFString_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Types.h"
+#include <string>
+
+
+namespace Poco {
+
+
+struct UTF16CharTraits
+{
+	typedef std::fpos<std::mbstate_t> u16streampos;
+	typedef UInt16                    char_type;
+	typedef int                       int_type;
+	typedef std::streamoff            off_type;
+	typedef u16streampos              pos_type;
+	typedef std::mbstate_t            state_type;
+
+	static void assign(char_type& c1, const char_type& c2)
+	{
+		c1 = c2;
+	}
+	
+	static bool eq(char_type c1, char_type c2)
+	{
+		return c1 == c2;
+	}
+	
+	static bool lt(char_type c1, char_type c2)
+	{
+		return c1 < c2;
+	}
+
+	static int compare(const char_type* s1, const char_type* s2, std::size_t n)
+	{
+		for (; n; --n, ++s1, ++s2)
+		{
+			if (lt(*s1, *s2))
+				return -1;
+			if (lt(*s2, *s1))
+				return 1;
+		}
+		return 0;
+	}
+
+	static std::size_t length(const char_type* s)
+	{
+		std::size_t len = 0;
+		for (; !eq(*s, char_type(0)); ++s)
+			++len;
+		return len;
+	}
+
+	static const char_type* find(const char_type* s, std::size_t n, const char_type& a)
+	{
+		for (; n; --n)
+		{
+			if (eq(*s, a))
+				return s;
+			++s;
+		}
+		return 0;
+	}
+
+	static char_type* move(char_type* s1, const char_type* s2, std::size_t n)
+	{
+		char_type* r = s1;
+		if (s1 < s2)
+		{
+			for (; n; --n, ++s1, ++s2)
+				assign(*s1, *s2);
+		}
+		else if (s2 < s1)
+		{
+			s1 += n;
+			s2 += n;
+			for (; n; --n)
+				assign(*--s1, *--s2);
+		}
+		return r;
+	}
+
+	static char_type* copy(char_type* s1, const char_type* s2, std::size_t n)
+	{
+		poco_assert(s2 < s1 || s2 >= s1 + n);
+		char_type* r = s1;
+		for (; n; --n, ++s1, ++s2)
+			assign(*s1, *s2);
+		return r;
+	}
+
+	static char_type* assign(char_type* s, std::size_t n, char_type a)
+	{
+		char_type* r = s;
+		for (; n; --n, ++s)
+			assign(*s, a);
+		return r;
+	}
+
+	static int_type  not_eof(int_type c)
+	{
+		return eq_int_type(c, eof()) ? ~eof() : c;
+	}
+	
+	static char_type to_char_type(int_type c)
+	{
+		return char_type(c);
+	}
+	
+	static int_type to_int_type(char_type c)
+	{
+		return int_type(c);
+	}
+	
+	static bool eq_int_type(int_type c1, int_type c2)
+	{
+		return c1 == c2;
+	}
+	
+	static int_type eof()
+	{
+		return int_type(0xDFFF);
+	}
+};
+
+
+struct UTF32CharTraits
+{
+	typedef std::fpos<std::mbstate_t> u32streampos;
+	typedef UInt32                    char_type;
+	typedef int                       int_type;
+	typedef std::streamoff            off_type;
+	typedef u32streampos              pos_type;
+	typedef std::mbstate_t            state_type;
+
+	static void assign(char_type& c1, const char_type& c2)
+	{
+		c1 = c2;
+	}
+	
+	static bool eq(char_type c1, char_type c2)
+	{
+		return c1 == c2;
+	}
+	
+	static bool lt(char_type c1, char_type c2)
+	{
+		return c1 < c2;
+	}
+
+	static int compare(const char_type* s1, const char_type* s2, std::size_t n)
+	{
+		for (; n; --n, ++s1, ++s2)
+		{
+			if (lt(*s1, *s2))
+				return -1;
+			if (lt(*s2, *s1))
+				return 1;
+		}
+		return 0;
+	}
+
+	static std::size_t length(const char_type* s)
+	{
+		std::size_t len = 0;
+		for (; !eq(*s, char_type(0)); ++s)
+			++len;
+		return len;
+	}
+
+	static const char_type* find(const char_type* s, std::size_t n, const char_type& a)
+	{
+		for (; n; --n)
+		{
+			if (eq(*s, a))
+				return s;
+			++s;
+		}
+		return 0;
+	}
+
+	static char_type* move(char_type* s1, const char_type* s2, std::size_t n)
+	{
+		char_type* r = s1;
+		if (s1 < s2)
+		{
+			for (; n; --n, ++s1, ++s2)
+				assign(*s1, *s2);
+		}
+		else if (s2 < s1)
+		{
+			s1 += n;
+			s2 += n;
+			for (; n; --n)
+				assign(*--s1, *--s2);
+		}
+		return r;
+	}
+
+	static char_type* copy(char_type* s1, const char_type* s2, std::size_t n)
+	{
+		poco_assert(s2 < s1 || s2 >= s1 + n);
+		char_type* r = s1;
+		for (; n; --n, ++s1, ++s2)
+			assign(*s1, *s2);
+		return r;
+	}
+
+	static char_type* assign(char_type* s, std::size_t n, char_type a)
+	{
+		char_type* r = s;
+		for (; n; --n, ++s)
+			assign(*s, a);
+		return r;
+	}
+
+	static int_type  not_eof(int_type c)
+	{
+		return eq_int_type(c, eof()) ? ~eof() : c;
+	}
+	
+	static char_type to_char_type(int_type c)
+	{
+		return char_type(c);
+	}
+	
+	static int_type to_int_type(char_type c)
+	{
+		return int_type(c);
+	}
+	
+	static bool eq_int_type(int_type c1, int_type c2)
+	{
+		return c1 == c2;
+	}
+	
+	static int_type eof()
+	{
+		return int_type(0xDFFF);
+	}
+};
+
+
+//#if defined(POCO_ENABLE_CPP11) //TODO
+	//	typedef char16_t       UTF16Char;
+	//	typedef std::u16string UTF16String;
+	//	typedef char32_t       UTF32Char;
+	//	typedef std::u32string UTF32String;
+//#else
+	#ifdef POCO_NO_WSTRING
+		typedef Poco::UInt16                                  UTF16Char;
+		typedef std::basic_string<UTF16Char, UTF16CharTraits> UTF16String;
+		typedef UInt32                                        UTF32Char;
+		typedef std::basic_string<UTF32Char, UTF32CharTraits> UTF32String;
+	#else // POCO_NO_WSTRING
+		#if defined(POCO_OS_FAMILY_WINDOWS)
+			typedef wchar_t                                       UTF16Char;
+			typedef std::wstring                                  UTF16String;
+			typedef UInt32                                        UTF32Char;
+			typedef std::basic_string<UTF32Char, UTF32CharTraits> UTF32String;
+		#elif defined(__SIZEOF_WCHAR_T__) //gcc
+			#if (__SIZEOF_WCHAR_T__ == 2)
+				typedef wchar_t                                       UTF16Char;
+				typedef std::wstring                                  UTF16String;
+				typedef UInt32                                        UTF32Char;
+				typedef std::basic_string<UTF32Char, UTF32CharTraits> UTF32String;
+			#elif (__SIZEOF_WCHAR_T__ == 4)
+				typedef Poco::UInt16                                  UTF16Char;
+				typedef std::basic_string<UTF16Char, UTF16CharTraits> UTF16String;
+				typedef wchar_t                                       UTF32Char;
+				typedef std::wstring                                  UTF32String;
+			#endif
+		#else // default to 32-bit wchar_t
+			typedef Poco::UInt16                                  UTF16Char;
+			typedef std::basic_string<UTF16Char, UTF16CharTraits> UTF16String;
+			typedef wchar_t                                       UTF32Char;
+			typedef std::wstring                                  UTF32String;
+		#endif //POCO_OS_FAMILY_WINDOWS
+	#endif //POCO_NO_WSTRING
+//#endif // POCO_ENABLE_CPP11
+
+
+} // namespace Poco
+
+
+#endif // Foundation_UTFString_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/UUID.h b/base/poco/Foundation/include/Poco/UUID.h
new file mode 100644
index 00000000000..2708a0003ab
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/UUID.h
@@ -0,0 +1,219 @@
+//
+// UUID.h
+//
+// Library: Foundation
+// Package: UUID
+// Module:  UUID
+//
+// Definition of the UUID class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_UUID_INCLUDED
+#define Foundation_UUID_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API UUID
+	/// A UUID is an identifier that is unique across both space and time,
+	/// with respect to the space of all UUIDs. Since a UUID is a fixed
+	/// size and contains a time field, it is possible for values to
+	/// rollover (around A.D. 3400, depending on the specific algorithm
+	/// used). A UUID can be used for multiple purposes, from tagging
+	/// objects with an extremely short lifetime, to reliably identifying
+	/// very persistent objects across a network.
+	///
+	/// This class implements a Universal Unique Identifier,
+	/// as specified in Appendix A of the DCE 1.1 Remote Procedure
+	/// Call Specification (http://www.opengroup.org/onlinepubs/9629399/),
+	/// RFC 2518 (WebDAV), section 6.4.1 and the UUIDs and GUIDs internet
+	/// draft by Leach/Salz from February, 1998 
+	/// (http://www.ics.uci.edu/~ejw/authoring/uuid-guid/draft-leach-uuids-guids-01.txt)
+	/// and also http://tools.ietf.org/html/draft-mealling-uuid-urn-05
+{
+public:
+	enum Version
+	{
+		UUID_TIME_BASED      = 0x01,
+		UUID_DCE_UID         = 0x02,
+		UUID_NAME_BASED      = 0x03,
+		UUID_RANDOM          = 0x04,
+		UUID_NAME_BASED_SHA1 = 0x05
+		
+	};
+
+	UUID();
+		/// Creates a nil (all zero) UUID.
+		
+	UUID(const UUID& uuid);
+		/// Copy constructor.
+
+	explicit UUID(const std::string& uuid);
+		/// Parses the UUID from a string.
+		
+	explicit UUID(const char* uuid);
+		/// Parses the UUID from a string.
+
+	~UUID();
+		/// Destroys the UUID.
+
+	UUID& operator = (const UUID& uuid);
+		/// Assignment operator.
+		
+	void swap(UUID& uuid);
+		/// Swaps the UUID with another one.	
+		
+	void parse(const std::string& uuid);
+		/// Parses the UUID from its string representation.
+
+	bool tryParse(const std::string& uuid);
+		/// Tries to interpret the given string as an UUID.
+		/// If the UUID is syntactically valid, assigns the
+		/// members and returns true. Otherwise leaves the 
+		/// object unchanged and returns false.
+
+	std::string toString() const;
+		/// Returns a string representation of the UUID consisting
+		/// of groups of hexadecimal digits separated by hyphens.
+
+	void copyFrom(const char* buffer);
+		/// Copies the UUID (16 bytes) from a buffer or byte array.
+		/// The UUID fields are expected to be
+		/// stored in network byte order.
+		/// The buffer need not be aligned.
+
+	void copyTo(char* buffer) const;
+		/// Copies the UUID to the buffer. The fields
+		/// are in network byte order.
+		/// The buffer need not be aligned.
+		/// There must have room for at least 16 bytes.
+
+	Version version() const;
+		/// Returns the version of the UUID.
+		
+	int variant() const;
+		/// Returns the variant number of the UUID:
+		///   - 0 reserved for NCS backward compatibility
+		///   - 2 the Leach-Salz variant (used by this class)
+		///   - 6 reserved, Microsoft Corporation backward compatibility
+		///   - 7 reserved for future definition
+
+	bool operator == (const UUID& uuid) const;
+	bool operator != (const UUID& uuid) const;
+	bool operator <  (const UUID& uuid) const;
+	bool operator <= (const UUID& uuid) const;
+	bool operator >  (const UUID& uuid) const;
+	bool operator >= (const UUID& uuid) const;
+	
+	bool isNull() const;
+		/// Returns true iff the UUID is nil (in other words,
+		/// consists of all zeros).
+
+	static const UUID& null();
+		/// Returns a null/nil UUID.
+
+	static const UUID& dns();
+		/// Returns the namespace identifier for the DNS namespace.
+		
+	static const UUID& uri();
+		/// Returns the namespace identifier for the URI (former URL) namespace.
+
+	static const UUID& oid();
+		/// Returns the namespace identifier for the OID namespace.
+
+	static const UUID& x500();
+		/// Returns the namespace identifier for the X500 namespace.
+
+protected:
+	UUID(UInt32 timeLow, UInt32 timeMid, UInt32 timeHiAndVersion, UInt16 clockSeq, UInt8 node[]);
+	UUID(const char* bytes, Version version);
+	int compare(const UUID& uuid) const;
+	static void appendHex(std::string& str, UInt8 n);
+	static void appendHex(std::string& str, UInt16 n);
+	static void appendHex(std::string& str, UInt32 n);
+	static Int16 nibble(char hex);
+	void fromNetwork();
+	void toNetwork();
+
+private:
+	UInt32 _timeLow;
+	UInt16 _timeMid;
+	UInt16 _timeHiAndVersion;
+	UInt16 _clockSeq;
+	UInt8  _node[6];
+	
+	friend class UUIDGenerator;
+};
+
+
+//
+// inlines
+//
+inline bool UUID::operator == (const UUID& uuid) const
+{
+	return compare(uuid) == 0;
+}
+
+
+inline bool UUID::operator != (const UUID& uuid) const
+{
+	return compare(uuid) != 0;
+}
+
+
+inline bool UUID::operator < (const UUID& uuid) const
+{
+	return compare(uuid) < 0;
+}
+
+
+inline bool UUID::operator <= (const UUID& uuid) const
+{
+	return compare(uuid) <= 0;
+}
+
+
+inline bool UUID::operator > (const UUID& uuid) const
+{
+	return compare(uuid) > 0;
+}
+
+
+inline bool UUID::operator >= (const UUID& uuid) const
+{
+	return compare(uuid) >= 0;
+}
+
+
+inline UUID::Version UUID::version() const
+{
+	return Version(_timeHiAndVersion >> 12);
+}
+
+
+inline bool UUID::isNull() const
+{
+	return compare(null()) == 0;
+}
+
+
+inline void swap(UUID& u1, UUID& u2)
+{
+	u1.swap(u2);
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_UUID_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/UUIDGenerator.h b/base/poco/Foundation/include/Poco/UUIDGenerator.h
new file mode 100644
index 00000000000..517417de933
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/UUIDGenerator.h
@@ -0,0 +1,104 @@
+//
+// UUIDGenerator.h
+//
+// Library: Foundation
+// Package: UUID
+// Module:  UUID
+//
+// Definition of the UUIDGenerator class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_UUIDGenerator_INCLUDED
+#define Foundation_UUIDGenerator_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UUID.h"
+#include "Poco/Mutex.h"
+#include "Poco/Random.h"
+#include "Poco/Timestamp.h"
+#include "Poco/Environment.h"
+
+
+namespace Poco {
+
+
+class DigestEngine;
+
+
+class Foundation_API UUIDGenerator
+	/// This class implements a generator for Universal Unique Identifiers,
+	/// as specified in Appendix A of the DCE 1.1 Remote Procedure
+	/// Call Specification (http://www.opengroup.org/onlinepubs/9629399/),
+	/// RFC 2518 (WebDAV), section 6.4.1 and the UUIDs and GUIDs internet
+	/// draft by Leach/Salz from February, 1998 
+	/// (http://ftp.ics.uci.edu/pub/ietf/webdav/uuid-guid/draft-leach-uuids-guids-01.txt)
+{
+public:
+	UUIDGenerator();
+		/// Creates the UUIDGenerator.
+
+	~UUIDGenerator();
+		/// Destroys the UUIDGenerator.
+
+	UUID create();
+		/// Creates a new time-based UUID, using the MAC address of
+		/// one of the system's ethernet adapters.
+		///
+		/// Throws a SystemException if no MAC address can be
+		/// obtained.
+	
+	UUID createFromName(const UUID& nsid, const std::string& name);
+		/// Creates a name-based UUID.
+
+	UUID createFromName(const UUID& nsid, const std::string& name, DigestEngine& de);
+		/// Creates a name-based UUID, using the given digest engine.
+		///
+		/// Note: in order to create a standard-compliant UUID, the given DigestEngine
+		/// must be either an instance of MD5Engine or SHA1Engine. The version field of
+		/// the UUID will be set accordingly.
+
+	UUID createFromName(const UUID& nsid, const std::string& name, DigestEngine& de, UUID::Version version);
+		/// Creates a name-based UUID, using the given digest engine and version.
+		
+	UUID createRandom();
+		/// Creates a random UUID.
+		
+	UUID createOne();
+		/// Tries to create and return a time-based UUID (see create()), and, 
+		/// if that does not work due to the unavailability of a MAC address,
+		/// creates and returns a random UUID (see createRandom()).
+		///
+		/// The UUID::version() method can be used to determine the actual kind of
+		/// the UUID generated.
+
+	static UUIDGenerator& defaultGenerator();
+		/// Returns a reference to the default UUIDGenerator.
+		
+protected:
+	Timestamp::UtcTimeVal timeStamp();
+	void getNode();
+
+private:
+	FastMutex           _mutex;
+	Random              _random;
+	Timestamp           _lastTime;
+	int                 _ticks;
+	Environment::NodeId _node;
+	bool                _haveNode;
+	
+	UUIDGenerator(const UUIDGenerator&);
+	UUIDGenerator& operator = (const UUIDGenerator&);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_UUIDGenerator_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/UnWindows.h b/base/poco/Foundation/include/Poco/UnWindows.h
new file mode 100644
index 00000000000..a54b4a94c59
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/UnWindows.h
@@ -0,0 +1,142 @@
+//
+// UnWindows.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  UnWindows
+//
+// A wrapper around the <windows.h> header file that #undef's some
+// of the macros for function names defined by <windows.h> that
+// are a frequent source of conflicts (e.g., GetUserName).
+//
+// Remember, that most of the WIN32 API functions come in two variants,
+// an Unicode variant (e.g., GetUserNameA) and an ASCII variant (GetUserNameW).
+// There is also a macro (GetUserName) that's either defined to be the Unicode
+// name or the ASCII name, depending on whether the UNICODE macro is #define'd
+// or not. POCO always calls the Unicode or ASCII functions directly (depending
+// on whether POCO_WIN32_UTF8 is #define'd or not), so the macros are not ignored.
+//
+// These macro definitions are a frequent case of problems and naming conflicts,
+// especially for C++ programmers. Say, you define a class with a member function named
+// GetUserName. Depending on whether "Poco/UnWindows.h" has been included by a particular
+// translation unit or not, this might be changed to GetUserNameA/GetUserNameW, or not.
+// While, due to naming conventions used, this is less of a problem in POCO, some
+// of the users of POCO might use a different naming convention where this can become
+// a problem.
+//
+// To disable the #undef's, compile POCO with the POCO_NO_UNWINDOWS macro #define'd.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_UnWindows_INCLUDED
+#define Foundation_UnWindows_INCLUDED
+
+
+// Reduce bloat
+#if defined(_WIN32)
+	#if !defined(WIN32_LEAN_AND_MEAN) && !defined(POCO_BLOATED_WIN32)
+		#define WIN32_LEAN_AND_MEAN
+	#endif
+#endif
+
+
+// Microsoft Visual C++ includes copies of the Windows header files 
+// that were current at the time Visual C++ was released.
+// The Windows header files use macros to indicate which versions 
+// of Windows support many programming elements. Therefore, you must 
+// define these macros to use new functionality introduced in each 
+// major operating system release. (Individual header files may use 
+// different macros; therefore, if compilation problems occur, check 
+// the header file that contains the definition for conditional 
+// definitions.) For more information, see SdkDdkVer.h.
+
+
+#if !defined(_WIN32_WCE)
+#if defined(_WIN32_WINNT)
+	#if (_WIN32_WINNT < 0x0502)
+		#error Unsupported Windows version.
+	#endif
+#elif defined(NTDDI_VERSION)
+	#if (NTDDI_VERSION < 0x05020000)
+		#error Unsupported Windows version.
+	#endif
+#elif !defined(_WIN32_WINNT)
+	// Define minimum supported version.
+	// This can be changed, if needed.
+	// If allowed (see POCO_MIN_WINDOWS_OS_SUPPORT
+	// below), Platform_WIN32.h will do its
+	// best to determine the appropriate values
+	// and may redefine these. See Platform_WIN32.h
+	// for details.
+	#define _WIN32_WINNT 0x0502
+	#define NTDDI_VERSION 0x05020000
+#endif
+#endif
+
+
+// To prevent Platform_WIN32.h to modify version defines,
+// uncomment this, otherwise versions will be automatically
+// discovered in Platform_WIN32.h.
+// #define POCO_FORCE_MIN_WINDOWS_OS_SUPPORT
+
+
+#include <windows.h>
+
+
+#if !defined(POCO_NO_UNWINDOWS)
+// A list of annoying macros to #undef.
+// Extend as required.
+#undef GetBinaryType
+#undef GetShortPathName
+#undef GetLongPathName
+#undef GetEnvironmentStrings
+#undef SetEnvironmentStrings
+#undef FreeEnvironmentStrings
+#undef FormatMessage
+#undef EncryptFile
+#undef DecryptFile
+#undef CreateMutex
+#undef OpenMutex
+#undef CreateEvent
+#undef OpenEvent
+#undef CreateSemaphore
+#undef OpenSemaphore
+#undef LoadLibrary
+#undef GetModuleFileName
+#undef CreateProcess
+#undef GetCommandLine
+#undef GetEnvironmentVariable
+#undef SetEnvironmentVariable
+#undef ExpandEnvironmentStrings
+#undef OutputDebugString
+#undef FindResource
+#undef UpdateResource
+#undef FindAtom
+#undef AddAtom
+#undef GetSystemDirectory
+#undef GetTempPath
+#undef GetTempFileName
+#undef SetCurrentDirectory
+#undef GetCurrentDirectory
+#undef CreateDirectory
+#undef RemoveDirectory
+#undef CreateFile
+#undef DeleteFile
+#undef SearchPath
+#undef CopyFile
+#undef MoveFile
+#undef ReplaceFile
+#undef GetComputerName
+#undef SetComputerName
+#undef GetUserName
+#undef LogonUser
+#undef GetVersion
+#undef GetObject
+#endif // POCO_NO_UNWINDOWS
+
+#endif // Foundation_UnWindows_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/UnbufferedStreamBuf.h b/base/poco/Foundation/include/Poco/UnbufferedStreamBuf.h
new file mode 100644
index 00000000000..ed56cb83ec1
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/UnbufferedStreamBuf.h
@@ -0,0 +1,179 @@
+//
+// UnufferedStreamBuf.h
+//
+// Library: Foundation
+// Package: Streams
+// Module:  StreamBuf
+//
+// Definition of template BasicUnbufferedStreamBuf and class UnbufferedStreamBuf.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_UnbufferedStreamBuf_INCLUDED
+#define Foundation_UnbufferedStreamBuf_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/StreamUtil.h"
+#include <streambuf>
+#include <iosfwd>
+#include <ios>
+
+
+namespace Poco {
+
+
+template <typename ch, typename tr> 
+class BasicUnbufferedStreamBuf: public std::basic_streambuf<ch, tr>
+	/// This is an implementation of an unbuffered streambuf
+	/// that greatly simplifies the implementation of
+	/// custom streambufs of various kinds.
+	/// Derived classes only have to override the methods
+	/// readFromDevice() or writeToDevice().
+{
+protected:
+	typedef std::basic_streambuf<ch, tr> Base;
+	typedef std::basic_ios<ch, tr> IOS;
+	typedef ch char_type;
+	typedef tr char_traits;
+	typedef typename Base::int_type int_type;
+	typedef typename Base::pos_type pos_type;
+	typedef typename Base::off_type off_type;
+	typedef typename IOS::openmode openmode;
+
+public:
+	BasicUnbufferedStreamBuf():
+		_pb(char_traits::eof()),
+		_ispb(false)
+	{
+		this->setg(0, 0, 0);
+		this->setp(0, 0);
+	}
+
+	~BasicUnbufferedStreamBuf()
+	{
+	}
+
+	virtual int_type overflow(int_type c)
+	{
+		if (c != char_traits::eof()) 
+			return writeToDevice(char_traits::to_char_type(c));
+		else
+			return c;
+	}
+
+	virtual int_type underflow()
+	{
+		if (_ispb)
+		{
+			return _pb;
+		}
+		else
+		{
+			int_type c = readFromDevice();
+			if (c != char_traits::eof())
+			{
+				_ispb = true;
+				_pb   = c;
+			}
+			return c;
+		}
+	}
+
+	virtual int_type uflow()
+	{
+		if (_ispb)
+		{
+			_ispb = false;
+			return _pb;
+		}
+		else
+		{
+			int_type c = readFromDevice();
+			if (c != char_traits::eof())
+			{
+				_pb = c;
+			}
+			return c;
+		}
+	}
+
+	virtual int_type pbackfail(int_type c)
+	{
+		if (_ispb)
+		{
+			return char_traits::eof();
+		}
+		else
+		{
+			_ispb = true;
+			_pb   = c;
+			return c;
+		}
+	}
+	
+	virtual std::streamsize xsgetn(char_type* p, std::streamsize count)
+		/// Some platforms (for example, Compaq C++) have buggy implementations of 
+		/// xsgetn that handle null buffers incorrectly.
+		/// Anyway, it does not hurt to provide an optimized implementation
+		/// of xsgetn for this streambuf implementation.
+	{
+		std::streamsize copied = 0;
+		while (count > 0)
+		{
+			int_type c = uflow();
+			if (c == char_traits::eof()) break;
+			*p++ = char_traits::to_char_type(c);
+			++copied;
+			--count;
+		}
+		return copied;
+	}
+
+protected:
+	static int_type charToInt(char_type c)
+	{
+		return char_traits::to_int_type(c);
+	}
+
+private:
+	virtual int_type readFromDevice()
+	{
+		return char_traits::eof();
+	}
+	
+	virtual int_type writeToDevice(char_type)
+	{
+		return char_traits::eof();
+	}
+
+	int_type _pb;
+	bool     _ispb;
+	
+	BasicUnbufferedStreamBuf(const BasicUnbufferedStreamBuf&);
+	BasicUnbufferedStreamBuf& operator = (const BasicUnbufferedStreamBuf&);
+};
+
+
+//
+// We provide an instantiation for char.
+//
+// Visual C++ needs a workaround - explicitly importing the template
+// instantiation - to avoid duplicate symbols due to multiple
+// instantiations in different libraries.
+//
+#if defined(_MSC_VER) && defined(POCO_DLL) && !defined(Foundation_EXPORTS)
+template class Foundation_API BasicUnbufferedStreamBuf<char, std::char_traits<char> >;
+#endif
+typedef BasicUnbufferedStreamBuf<char, std::char_traits<char> > UnbufferedStreamBuf;
+
+
+} // namespace Poco
+
+
+#endif // Foundation_UnbufferedStreamBuf_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Unicode.h b/base/poco/Foundation/include/Poco/Unicode.h
new file mode 100644
index 00000000000..b6d027685ab
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Unicode.h
@@ -0,0 +1,327 @@
+//
+// Unicode.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  Unicode
+//
+// Definition of the Unicode class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Unicode_INCLUDED
+#define Foundation_Unicode_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Unicode
+	/// This class contains enumerations and static
+	/// utility functions for dealing with Unicode characters
+	/// and their properties.
+	///
+	/// For more information on Unicode, see <http://www.unicode.org>.
+	///
+	/// The implementation is based on the Unicode support
+	/// functions in PCRE.
+{
+public:
+	// Implementation note: the following definitions must be kept
+	// in sync with those from ucp.h (PCRE).
+	enum CharacterCategory
+		/// Unicode character categories.
+	{
+		UCP_OTHER,
+		UCP_LETTER,
+		UCP_MARK,
+		UCP_NUMBER,
+		UCP_PUNCTUATION,
+		UCP_SYMBOL,
+		UCP_SEPARATOR
+	};
+
+	enum CharacterType
+		/// Unicode character types.
+	{
+		UCP_CONTROL,
+		UCP_FORMAT,
+		UCP_UNASSIGNED,
+		UCP_PRIVATE_USE,
+		UCP_SURROGATE,
+		UCP_LOWER_CASE_LETTER,
+		UCP_MODIFIER_LETTER,
+		UCP_OTHER_LETTER,
+		UCP_TITLE_CASE_LETTER,
+		UCP_UPPER_CASE_LETTER,
+		UCP_SPACING_MARK,
+		UCP_ENCLOSING_MARK,
+		UCP_NON_SPACING_MARK,
+		UCP_DECIMAL_NUMBER,
+		UCP_LETTER_NUMBER,
+		UCP_OTHER_NUMBER,
+		UCP_CONNECTOR_PUNCTUATION,
+		UCP_DASH_PUNCTUATION,
+		UCP_CLOSE_PUNCTUATION,
+		UCP_FINAL_PUNCTUATION,
+		UCP_INITIAL_PUNCTUATION,
+		UCP_OTHER_PUNCTUATION,
+		UCP_OPEN_PUNCTUATION,
+		UCP_CURRENCY_SYMBOL,
+		UCP_MODIFIER_SYMBOL,
+		UCP_MATHEMATICAL_SYMBOL,
+		UCP_OTHER_SYMBOL,
+		UCP_LINE_SEPARATOR,
+		UCP_PARAGRAPH_SEPARATOR,
+		UCP_SPACE_SEPARATOR
+	};
+	
+	enum Script
+		/// Unicode 7.0 script identifiers.
+	{
+		UCP_ARABIC,
+		UCP_ARMENIAN,
+		UCP_BENGALI,
+		UCP_BOPOMOFO,
+		UCP_BRAILLE,
+		UCP_BUGINESE,
+		UCP_BUHID,
+		UCP_CANADIAN_ABORIGINAL,
+		UCP_CHEROKEE,
+		UCP_COMMON,
+		UCP_COPTIC,
+		UCP_CYPRIOT,
+		UCP_CYRILLIC,
+		UCP_DESERET,
+		UCP_DEVANAGARI,
+		UCP_ETHIOPIC,
+		UCP_GEORGIAN,
+		UCP_GLAGOLITIC,
+		UCP_GOTHIC,
+		UCP_GREEK,
+		UCP_GUJARATI,
+		UCP_GURMUKHI,
+		UCP_HAN,
+		UCP_HANGUL,
+		UCP_HANUNOO,
+		UCP_HEBREW,
+		UCP_HIRAGANA,
+		UCP_INHERITED,
+		UCP_KANNADA,
+		UCP_KATAKANA,
+		UCP_KHAROSHTHI,
+		UCP_KHMER,
+		UCP_LAO,
+		UCP_LATIN,
+		UCP_LIMBU,
+		UCP_LINEAR_B,
+		UCP_MALAYALAM,
+		UCP_MONGOLIAN,
+		UCP_MYANMAR,
+		UCP_NEW_TAI_LUE,
+		UCP_OGHAM,
+		UCP_OLD_ITALIC,
+		UCP_OLD_PERSIAN,
+		UCP_ORIYA,
+		UCP_OSMANYA,
+		UCP_RUNIC,
+		UCP_SHAVIAN,
+		UCP_SINHALA,
+		UCP_SYLOTI_NAGRI,
+		UCP_SYRIAC,
+		UCP_TAGALOG,
+		UCP_TAGBANWA,
+		UCP_TAI_LE,
+		UCP_TAMIL,
+		UCP_TELUGU,
+		UCP_THAANA,
+		UCP_THAI,
+		UCP_TIBETAN,
+		UCP_TIFINAGH,
+		UCP_UGARITIC,
+		UCP_YI,
+		// Unicode 5.0
+		UCP_BALINESE,
+		UCP_CUNEIFORM,
+		UCP_NKO,
+		UCP_PHAGS_PA,
+		UCP_PHOENICIAN,
+		// Unicode 5.1
+		UCP_CARIAN,
+		UCP_CHAM,
+		UCP_KAYAH_LI,
+		UCP_LEPCHA,
+		UCP_LYCIAN,
+		UCP_LYDIAN,
+		UCP_OL_CHIKI,
+		UCP_REJANG,
+		UCP_SAURASHTRA,
+		UCP_SUNDANESE,
+		UCP_VAI,
+		// Unicode 5.2
+		UCP_AVESTAN,
+		UCP_BAMUM,
+		UCP_EGYPTIAN_HIEROGLYPHS,
+		UCP_IMPERIAL_ARAMAIC,
+		UCP_INSCRIPTIONAL_PAHLAVI,
+		UCP_INSCRIPTIONAL_PARTHIAN,
+		UCP_JAVANESE,
+		UCP_KAITHI,
+		UCP_LISU,
+		UCP_MEETEI_MAYEK,
+		UCP_OLD_SOUTH_ARABIAN,
+		UCP_OLD_TURKIC,
+		UCP_SAMARITAN,
+		UCP_TAI_THAM,
+		UCP_TAI_VIET,
+		// Unicode 6.0
+		UCP_BATAK,
+		UCP_BRAHMI,
+		UCP_MANDAIC,
+		// Unicode 6.1
+		UCP_CHAKMA,
+		UCP_MEROITIC_CURSIVE,
+		UCP_MEROITIC_HIEROGLYPHS,
+		UCP_MIAO,
+		UCP_SHARADA,
+		UCP_SORA_SOMPENG,
+		UCP_TAKRI,
+		// Unicode 7.0
+		UCP_BASSA_VAH,
+		UCP_CAUCASIAN_ALBANIAN,
+		UCP_DUPLOYAN,
+		UCP_ELBASAN,
+		UCP_GRANTHA,
+		UCP_KHOJKI,
+		UCP_KHUDAWADI,
+		UCP_LINEAR_A,
+		UCP_MAHAJANI,
+		UCP_MANICHAEAN,
+		UCP_MENDE_KIKAKUI,
+		UCP_MODI,
+		UCP_MRO,
+		UCP_NABATAEAN,
+		UCP_OLD_NORTH_ARABIAN,
+		UCP_OLD_PERMIC,
+		UCP_PAHAWH_HMONG,
+		UCP_PALMYRENE,
+		UCP_PSALTER_PAHLAVI,
+		UCP_PAU_CIN_HAU,
+		UCP_SIDDHAM,
+		UCP_TIRHUTA,
+		UCP_WARANG_CITI
+	};
+	
+	enum
+	{
+		UCP_MAX_CODEPOINT = 0x10FFFF
+	};
+	
+	struct CharacterProperties
+		/// This structure holds the character properties
+		/// of an Unicode character.
+	{
+		CharacterCategory category;
+		CharacterType     type;
+		Script            script;
+	};
+
+	static void properties(int ch, CharacterProperties& props);
+		/// Return the Unicode character properties for the
+		/// character with the given Unicode value.
+		
+	static bool isSpace(int ch);
+		/// Returns true iff the given character is a separator.
+		
+	static bool isDigit(int ch);
+		/// Returns true iff the given character is a numeric character.
+		
+	static bool isPunct(int ch);
+		/// Returns true iff the given character is a punctuation character.
+		
+	static bool isAlpha(int ch);
+		/// Returns true iff the given character is a letter.	
+		
+	static bool isLower(int ch);
+		/// Returns true iff the given character is a lowercase
+		/// character.
+		
+	static bool isUpper(int ch);
+		/// Returns true iff the given character is an uppercase
+		/// character.
+		
+	static int toLower(int ch);
+		/// If the given character is an uppercase character,
+		/// return its lowercase counterpart, otherwise return
+		/// the character.
+
+	static int toUpper(int ch);
+		/// If the given character is a lowercase character,
+		/// return its uppercase counterpart, otherwise return
+		/// the character.
+};
+
+
+//
+// inlines
+//
+inline bool Unicode::isSpace(int ch)
+{
+	CharacterProperties props;
+	properties(ch, props);
+	return props.category == UCP_SEPARATOR;
+}
+
+
+inline bool Unicode::isDigit(int ch)
+{
+	CharacterProperties props;
+	properties(ch, props);
+	return props.category == UCP_NUMBER;
+}
+
+
+inline bool Unicode::isPunct(int ch)
+{
+	CharacterProperties props;
+	properties(ch, props);
+	return props.category == UCP_PUNCTUATION;
+}
+
+
+inline bool Unicode::isAlpha(int ch)
+{
+	CharacterProperties props;
+	properties(ch, props);
+	return props.category == UCP_LETTER;
+}
+
+
+inline bool Unicode::isLower(int ch)
+{
+	CharacterProperties props;
+	properties(ch, props);
+	return props.category == UCP_LETTER && props.type == UCP_LOWER_CASE_LETTER;
+}
+
+	
+inline bool Unicode::isUpper(int ch)
+{
+	CharacterProperties props;
+	properties(ch, props);
+	return props.category == UCP_LETTER && props.type == UCP_UPPER_CASE_LETTER;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Unicode_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/UnicodeConverter.h b/base/poco/Foundation/include/Poco/UnicodeConverter.h
new file mode 100644
index 00000000000..0733b67b7d9
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/UnicodeConverter.h
@@ -0,0 +1,141 @@
+//
+// UnicodeConverter.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  UnicodeConverter
+//
+// Definition of the UnicodeConverter class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_UnicodeConverter_INCLUDED
+#define Foundation_UnicodeConverter_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UTFString.h"
+
+
+namespace Poco {
+
+
+class Foundation_API UnicodeConverter
+	/// A convenience class that converts strings from
+	/// UTF-8 encoded std::strings to UTF-16 or UTF-32 encoded std::wstrings
+	/// and vice-versa.
+	///
+	/// This class is mainly used for working with the Unicode Windows APIs
+	/// and probably won't be of much use anywhere else ???
+{
+public:
+	static void convert(const std::string& utf8String, UTF32String& utf32String);
+		/// Converts the given UTF-8 encoded string into an UTF-32 encoded wide string.
+
+	static void convert(const char* utf8String,  std::size_t length, UTF32String& utf32String);
+		/// Converts the given UTF-8 encoded character sequence into an UTF-32 encoded wide string.
+
+	static void convert(const char* utf8String, UTF32String& utf32String);
+		/// Converts the given zero-terminated UTF-8 encoded character sequence into an UTF-32 encoded wide string.
+
+	static void convert(const std::string& utf8String, UTF16String& utf16String);
+		/// Converts the given UTF-8 encoded string into an UTF-16 encoded wide string.
+
+	static void convert(const char* utf8String,  std::size_t length, UTF16String& utf16String);	
+		/// Converts the given UTF-8 encoded character sequence into an UTF-16 encoded wide string.
+
+	static void convert(const char* utf8String, UTF16String& utf16String);	
+		/// Converts the given zero-terminated UTF-8 encoded character sequence into an UTF-16 encoded wide string.
+
+	static void convert(const UTF16String& utf16String, std::string& utf8String);
+		/// Converts the given UTF-16 encoded wide string into an UTF-8 encoded string.
+
+	static void convert(const UTF32String& utf32String, std::string& utf8String);
+		/// Converts the given UTF-32 encoded wide string into an UTF-8 encoded string.
+
+	static void convert(const UTF16Char* utf16String,  std::size_t length, std::string& utf8String);
+		/// Converts the given zero-terminated UTF-16 encoded wide character sequence into an UTF-8 encoded string.
+
+	static void convert(const UTF32Char* utf16String, std::size_t length, std::string& utf8String);
+		/// Converts the given zero-terminated UTF-32 encoded wide character sequence into an UTF-8 encoded string.
+
+	static void convert(const UTF16Char* utf16String, std::string& utf8String);
+		/// Converts the given UTF-16 encoded zero terminated character sequence into an UTF-8 encoded string.
+
+	static void convert(const UTF32Char* utf32String, std::string& utf8String);
+		/// Converts the given UTF-32 encoded zero terminated character sequence into an UTF-8 encoded string.
+
+	template <typename F, typename T>
+	static void toUTF32(const F& f, T& t)
+	{
+		convert(f, t);
+	}
+
+	template <typename F, typename T>
+	static void toUTF32(const F& f, std::size_t l, T& t)
+	{
+		convert(f, l, t);
+	}
+
+	template <typename F, typename T>
+	static void toUTF16(const F& f, T& t)
+	{
+		convert(f, t);
+	}
+
+	template <typename F, typename T>
+	static void toUTF16(const F& f, std::size_t l, T& t)
+	{
+		convert(f, l, t);
+	}
+
+	template <typename F, typename T>
+	static void toUTF8(const F& f, T& t)
+	{
+		convert(f, t);
+	}
+
+	template <typename F, typename T>
+	static void toUTF8(const F& f, std::size_t l, T& t)
+	{
+		convert(f, l, t);
+	}
+
+	template <typename T>
+	static T to(const char* pChar)
+	{
+		T utfStr;
+		Poco::UnicodeConverter::convert(pChar, utfStr);
+		return utfStr;
+	}
+
+
+	template <typename T>
+	static T to(const std::string& str)
+	{
+		T utfStr;
+		Poco::UnicodeConverter::convert(str, utfStr);
+		return utfStr;
+	}
+
+	template <typename T>
+	static std::size_t UTFStrlen(const T* ptr)
+		/// Returns the length (in characters) of a zero-terminated UTF string.
+	{
+		if (ptr == 0) return 0;
+		const T* p;
+		for (p = ptr; *p; ++p);
+		return p - ptr;
+	}
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_UnicodeConverter_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/UniqueAccessExpireCache.h b/base/poco/Foundation/include/Poco/UniqueAccessExpireCache.h
new file mode 100644
index 00000000000..a2d58f64330
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/UniqueAccessExpireCache.h
@@ -0,0 +1,73 @@
+//
+// UniqueAccessExpireCache.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  UniqueAccessExpireCache
+//
+// Definition of the UniqueAccessExpireCache class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_UniqueAccessExpireCache_INCLUDED
+#define Foundation_UniqueAccessExpireCache_INCLUDED
+
+
+#include "Poco/AbstractCache.h"
+#include "Poco/UniqueAccessExpireStrategy.h"
+
+
+namespace Poco {
+
+
+template <
+	class TKey, 
+	class TValue,
+	class TMutex = FastMutex, 
+	class TEventMutex = FastMutex
+> 
+class UniqueAccessExpireCache: public AbstractCache<TKey, TValue, UniqueAccessExpireStrategy<TKey, TValue>, TMutex, TEventMutex>
+	/// An UniqueAccessExpireCache caches entries for a given time span. In contrast
+	/// to ExpireCache which only allows to set a per cache expiration value, it allows to define 
+	/// expiration per CacheEntry.
+	/// Each TValue object must thus offer the following method:
+	///    
+	///    const Poco::Timespan& getTimeout() const;
+	///    
+	/// which returns the relative timespan for how long the entry should be valid without being accessed!
+	/// The absolute expire timepoint is calculated as now() + getTimeout().
+	/// Accessing an object will update this absolute expire timepoint.
+	/// You can use the Poco::AccessExpirationDecorator to add the getExpiration
+	/// method to values that do not have a getExpiration function.
+	///
+	/// Be careful when using an UniqueAccessExpireCache. A cache is often used
+	/// like cache.has(x) followed by cache.get x). Note that it could happen
+	/// that the "has" call works, then the current execution thread gets descheduled, time passes,
+	/// the entry gets invalid, thus leading to an empty SharedPtr being returned 
+	/// when "get" is invoked.
+{
+public:
+	UniqueAccessExpireCache():
+		AbstractCache<TKey, TValue, UniqueAccessExpireStrategy<TKey, TValue>, TMutex, TEventMutex>(UniqueAccessExpireStrategy<TKey, TValue>())
+	{
+	}
+
+	~UniqueAccessExpireCache()
+	{
+	}
+
+private:
+	UniqueAccessExpireCache(const UniqueAccessExpireCache& aCache);
+	UniqueAccessExpireCache& operator = (const UniqueAccessExpireCache& aCache);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_UniqueAccessExpireCache_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/UniqueAccessExpireLRUCache.h b/base/poco/Foundation/include/Poco/UniqueAccessExpireLRUCache.h
new file mode 100644
index 00000000000..6e7a366670f
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/UniqueAccessExpireLRUCache.h
@@ -0,0 +1,71 @@
+//
+// UniqueAccessExpireLRUCache.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  UniqueAccessExpireLRUCache
+//
+// Definition of the UniqueAccessExpireLRUCache class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_UniqueAccessExpireLRUCache_INCLUDED
+#define Foundation_UniqueAccessExpireLRUCache_INCLUDED
+
+
+#include "Poco/AbstractCache.h"
+#include "Poco/StrategyCollection.h"
+#include "Poco/UniqueAccessExpireStrategy.h"
+#include "Poco/LRUStrategy.h"
+
+
+namespace Poco {
+
+
+template < 
+	class TKey,
+	class TValue,
+	class TMutex = FastMutex, 
+	class TEventMutex = FastMutex
+>
+class UniqueAccessExpireLRUCache: public AbstractCache<TKey, TValue, StrategyCollection<TKey, TValue>, TMutex, TEventMutex>
+	/// A UniqueAccessExpireLRUCache combines LRU caching and time based per entry expire caching.
+	/// One can define for each cache entry a seperate timepoint
+	/// but also limit the size of the cache (per default: 1024).
+	/// Each TValue object must thus offer the following method:
+	///    
+	///    const Poco::Timespan& getTimeout() const;
+	///    
+	/// which returns the relative timespan for how long the entry should be valid without being accessed!
+	/// The absolute expire timepoint is calculated as now() + getTimeout().
+	/// Accessing an object will update this absolute expire timepoint.
+	/// You can use the Poco::AccessExpirationDecorator to add the getExpiration
+	/// method to values that do not have a getExpiration function.
+{
+public:
+	UniqueAccessExpireLRUCache(long cacheSize = 1024): 
+		AbstractCache<TKey, TValue, StrategyCollection<TKey, TValue>, TMutex, TEventMutex>(StrategyCollection<TKey, TValue>())
+	{
+		this->_strategy.pushBack(new LRUStrategy<TKey, TValue>(cacheSize));
+		this->_strategy.pushBack(new UniqueAccessExpireStrategy<TKey, TValue>());
+	}
+
+	~UniqueAccessExpireLRUCache()
+	{
+	}
+
+private:
+	UniqueAccessExpireLRUCache(const UniqueAccessExpireLRUCache& aCache);
+	UniqueAccessExpireLRUCache& operator = (const UniqueAccessExpireLRUCache& aCache);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_UniqueAccessExpireLRUCache_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/UniqueAccessExpireStrategy.h b/base/poco/Foundation/include/Poco/UniqueAccessExpireStrategy.h
new file mode 100644
index 00000000000..d20f2185e03
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/UniqueAccessExpireStrategy.h
@@ -0,0 +1,156 @@
+//
+// UniqueAccessExpireStrategy.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  UniqueAccessExpireStrategy
+//
+// Definition of the UniqueAccessExpireStrategy class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_UniqueAccessExpireStrategy_INCLUDED
+#define Foundation_UniqueAccessExpireStrategy_INCLUDED
+
+
+#include "Poco/KeyValueArgs.h"
+#include "Poco/ValidArgs.h"
+#include "Poco/AbstractStrategy.h"
+#include "Poco/Bugcheck.h"
+#include "Poco/Timestamp.h"
+#include "Poco/Timespan.h"
+#include "Poco/EventArgs.h"
+#include "Poco/UniqueExpireStrategy.h"
+#include <set>
+#include <map>
+
+
+namespace Poco {
+
+
+template < 
+	class TKey,
+	class TValue
+>
+class UniqueAccessExpireStrategy: public AbstractStrategy<TKey, TValue>
+	/// An UniqueExpireStrategy implements time based expiration of cache entries. In contrast
+	/// to ExpireStrategy which only allows to set a per cache expiration value, it allows to define 
+	/// expiration per CacheEntry.
+	/// Each TValue object must thus offer the following method:
+	///    
+	///    const Poco::Timestamp& getTimeout() const;
+	///    
+	/// which returns the timespan for how long an object will be valid without being accessed.
+{
+public:
+	typedef std::pair<TKey, Timespan>           KeyExpire;
+	typedef std::multimap<Timestamp, KeyExpire> TimeIndex;
+	typedef typename TimeIndex::iterator        IndexIterator;
+	typedef typename TimeIndex::const_iterator  ConstIndexIterator;
+	typedef std::map<TKey, IndexIterator>       Keys;
+	typedef typename Keys::iterator             Iterator;
+
+public:
+	UniqueAccessExpireStrategy()
+		/// Create an unique expire strategy.
+	{
+	}
+
+	~UniqueAccessExpireStrategy()
+	{
+	}
+
+	void onAdd(const void*, const KeyValueArgs <TKey, TValue>& args)
+	{
+		// the expire value defines how many millisecs in the future the
+		// value will expire, even insert negative values!
+		Timestamp expire;
+		expire += args.value().getTimeout().totalMicroseconds();
+		
+		IndexIterator it = _keyIndex.insert(std::make_pair(expire, std::make_pair(args.key(), args.value().getTimeout())));
+		std::pair<Iterator, bool> stat = _keys.insert(std::make_pair(args.key(), it));
+		if (!stat.second)
+		{
+			_keyIndex.erase(stat.first->second);
+			stat.first->second = it;
+		}
+	}
+
+	void onRemove(const void*, const TKey& key)
+	{
+		Iterator it = _keys.find(key);
+		if (it != _keys.end())
+		{
+			_keyIndex.erase(it->second);
+			_keys.erase(it);
+		}
+	}
+
+	void onGet(const void*, const TKey& key)
+	{
+		// get updates the expiration time stamp
+		Iterator it = _keys.find(key);
+		if (it != _keys.end())
+		{
+			KeyExpire ke = it->second->second;
+			// gen new absolute expire value
+			Timestamp expire;
+			expire += ke.second.totalMicroseconds();
+			// delete old index
+			_keyIndex.erase(it->second);
+			IndexIterator itt = _keyIndex.insert(std::make_pair(expire, ke));
+			// update iterator
+			it->second = itt;
+		}
+	}
+
+	void onClear(const void*, const EventArgs& args)
+	{
+		_keys.clear();
+		_keyIndex.clear();
+	}
+
+	void onIsValid(const void*, ValidArgs<TKey>& args)
+	{
+		Iterator it = _keys.find(args.key());
+		if (it != _keys.end())
+		{
+			Timestamp now;
+			if (it->second->first <= now)
+			{
+				args.invalidate();
+			}
+		}
+		else //not found: probably removed by onReplace
+			args.invalidate();
+	}
+
+	void onReplace(const void*, std::set<TKey>& elemsToRemove)
+	{
+		// Note: replace only informs the cache which elements
+		// it would like to remove!
+		// it does not remove them on its own!
+		IndexIterator it = _keyIndex.begin();
+		Timestamp now;
+		while (it != _keyIndex.end() && it->first < now)
+		{
+			elemsToRemove.insert(it->second.first);
+			++it;
+		}
+	}
+
+protected:
+	Keys      _keys;     /// For faster replacement of keys, the iterator points to the _keyIndex map
+	TimeIndex _keyIndex; /// Maps time to key value
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_UniqueAccessExpireStrategy_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/UniqueExpireCache.h b/base/poco/Foundation/include/Poco/UniqueExpireCache.h
new file mode 100644
index 00000000000..613f9e215c3
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/UniqueExpireCache.h
@@ -0,0 +1,72 @@
+//
+// UniqueExpireCache.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  UniqueExpireCache
+//
+// Definition of the UniqueExpireCache class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_UniqueExpireCache_INCLUDED
+#define Foundation_UniqueExpireCache_INCLUDED
+
+
+#include "Poco/AbstractCache.h"
+#include "Poco/UniqueExpireStrategy.h"
+
+
+namespace Poco {
+
+
+template <
+	class TKey, 
+	class TValue,
+	class TMutex = FastMutex, 
+	class TEventMutex = FastMutex
+> 
+class UniqueExpireCache: public AbstractCache<TKey, TValue, UniqueExpireStrategy<TKey, TValue>, TMutex, TEventMutex>
+	/// An UniqueExpireCache caches entries for a given time amount. In contrast
+	/// to ExpireCache which only allows to set a per cache expiration value, it allows to define 
+	/// expiration per CacheEntry.
+	/// Each TValue object must thus offer the following method:
+	///    
+	///    const Poco::Timestamp& getExpiration() const;
+	///    
+	/// which returns the absolute timepoint when the entry will be invalidated.
+	/// Accessing an object will NOT update this absolute expire timepoint.
+	/// You can use the Poco::ExpirationDecorator to add the getExpiration
+	/// method to values that do not have a getExpiration function.
+	///
+	/// Be careful when using an UniqueExpireCache. A cache is often used
+	/// like cache.has(x) followed by cache.get x). Note that it could happen
+	/// that the "has" call works, then the current execution thread gets descheduled, time passes,
+	/// the entry gets invalid, thus leading to an empty SharedPtr being returned 
+	/// when "get" is invoked.
+{
+public:
+	UniqueExpireCache():
+		AbstractCache<TKey, TValue, UniqueExpireStrategy<TKey, TValue>, TMutex, TEventMutex>(UniqueExpireStrategy<TKey, TValue>())
+	{
+	}
+
+	~UniqueExpireCache()
+	{
+	}
+
+private:
+	UniqueExpireCache(const UniqueExpireCache& aCache);
+	UniqueExpireCache& operator = (const UniqueExpireCache& aCache);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_UniqueExpireCache_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/UniqueExpireLRUCache.h b/base/poco/Foundation/include/Poco/UniqueExpireLRUCache.h
new file mode 100644
index 00000000000..c59bf0f7a41
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/UniqueExpireLRUCache.h
@@ -0,0 +1,70 @@
+//
+// UniqueExpireLRUCache.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  UniqueExpireLRUCache
+//
+// Definition of the UniqueExpireLRUCache class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_UniqueExpireLRUCache_INCLUDED
+#define Foundation_UniqueExpireLRUCache_INCLUDED
+
+
+#include "Poco/AbstractCache.h"
+#include "Poco/StrategyCollection.h"
+#include "Poco/UniqueExpireStrategy.h"
+#include "Poco/LRUStrategy.h"
+
+
+namespace Poco {
+
+
+template < 
+	class TKey,
+	class TValue,
+	class TMutex = FastMutex, 
+	class TEventMutex = FastMutex
+>
+class UniqueExpireLRUCache: public AbstractCache<TKey, TValue, StrategyCollection<TKey, TValue>, TMutex, TEventMutex>
+	/// A UniqueExpireLRUCache combines LRU caching and time based per entry expire caching.
+	/// One can define for each cache entry a seperate timepoint
+	/// but also limit the size of the cache (per default: 1024).
+	/// Each TValue object must thus offer the following method:
+	///    
+	///    const Poco::Timestamp& getExpiration() const;
+	///    
+	/// which returns the absolute timepoint when the entry will be invalidated.
+	/// Accessing an object will NOT update this absolute expire timepoint.
+	/// You can use the Poco::ExpirationDecorator to add the getExpiration
+	/// method to values that do not have a getExpiration function.
+{
+public:
+	UniqueExpireLRUCache(long cacheSize = 1024): 
+		AbstractCache<TKey, TValue, StrategyCollection<TKey, TValue>, TMutex, TEventMutex>(StrategyCollection<TKey, TValue>())
+	{
+		this->_strategy.pushBack(new LRUStrategy<TKey, TValue>(cacheSize));
+		this->_strategy.pushBack(new UniqueExpireStrategy<TKey, TValue>());
+	}
+
+	~UniqueExpireLRUCache()
+	{
+	}
+
+private:
+	UniqueExpireLRUCache(const UniqueExpireLRUCache& aCache);
+	UniqueExpireLRUCache& operator = (const UniqueExpireLRUCache& aCache);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_UniqueExpireLRUCache_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/UniqueExpireStrategy.h b/base/poco/Foundation/include/Poco/UniqueExpireStrategy.h
new file mode 100644
index 00000000000..6ae79945b12
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/UniqueExpireStrategy.h
@@ -0,0 +1,138 @@
+//
+// UniqueExpireStrategy.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  UniqueExpireStrategy
+//
+// Definition of the UniqueExpireStrategy class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_UniqueExpireStrategy_INCLUDED
+#define Foundation_UniqueExpireStrategy_INCLUDED
+
+
+#include "Poco/KeyValueArgs.h"
+#include "Poco/ValidArgs.h"
+#include "Poco/AbstractStrategy.h"
+#include "Poco/Bugcheck.h"
+#include "Poco/Timestamp.h"
+#include "Poco/EventArgs.h"
+#include <set>
+#include <map>
+
+
+namespace Poco {
+
+
+template < 
+	class TKey,
+	class TValue
+>
+class UniqueExpireStrategy: public AbstractStrategy<TKey, TValue>
+	/// An UniqueExpireStrategy implements time based expiration of cache entries. In contrast
+	/// to ExpireStrategy which only allows to set a per cache expiration value, it allows to define 
+	/// expiration per CacheEntry.
+	/// Each TValue object must thus offer the following method:
+	///    
+	///    const Poco::Timestamp& getExpiration() const;
+	///    
+	/// which returns the absolute timepoint when the entry will be invalidated.
+{
+public:
+	typedef std::multimap<Timestamp, TKey>     TimeIndex;
+	typedef typename TimeIndex::iterator       IndexIterator;
+	typedef typename TimeIndex::const_iterator ConstIndexIterator;
+	typedef std::map<TKey, IndexIterator>      Keys;
+	typedef typename Keys::iterator            Iterator;
+
+public:
+	UniqueExpireStrategy()
+		/// Create an unique expire strategy.
+	{
+	}
+
+	~UniqueExpireStrategy()
+	{
+	}
+
+	void onAdd(const void*, const KeyValueArgs <TKey, TValue>& args)
+	{
+		// note: we have to insert even if the expire timepoint is in the past (for StrategyCollection classes to avoid inconsistency with LRU)
+		// no problem: will be removed with next get
+		const Timestamp& expire = args.value().getExpiration();
+		IndexIterator it = _keyIndex.insert(std::make_pair(expire, args.key()));
+		std::pair<Iterator, bool> stat = _keys.insert(std::make_pair(args.key(), it));
+		if (!stat.second)
+		{
+			_keyIndex.erase(stat.first->second);
+			stat.first->second = it;
+		}
+	}
+
+	void onRemove(const void*, const TKey& key)
+	{
+		Iterator it = _keys.find(key);
+		if (it != _keys.end())
+		{
+			_keyIndex.erase(it->second);
+			_keys.erase(it);
+		}
+	}
+
+	void onGet(const void*, const TKey& key)
+	{
+		// get triggers no changes in an expire
+	}
+
+	void onClear(const void*, const EventArgs& args)
+	{
+		_keys.clear();
+		_keyIndex.clear();
+	}
+
+	void onIsValid(const void*, ValidArgs<TKey>& args)
+	{
+		Iterator it = _keys.find(args.key());
+		if (it != _keys.end())
+		{
+			Timestamp now;
+			if (it->second->first <= now)
+			{
+				args.invalidate();
+			}
+		}
+		else //not found: probably removed by onReplace
+			args.invalidate();
+	}
+
+	void onReplace(const void*, std::set<TKey>& elemsToRemove)
+	{
+		// Note: replace only informs the cache which elements
+		// it would like to remove!
+		// it does not remove them on its own!
+		IndexIterator it = _keyIndex.begin();
+		Timestamp now;
+		while (it != _keyIndex.end() && it->first < now)
+		{
+			elemsToRemove.insert(it->second);
+			++it;
+		}
+	}
+
+protected:
+	Keys      _keys;     /// For faster replacement of keys, the iterator points to the _keyIndex map
+	TimeIndex _keyIndex; /// Maps time to key value
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_UniqueExpireStrategy_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/ValidArgs.h b/base/poco/Foundation/include/Poco/ValidArgs.h
new file mode 100644
index 00000000000..7928a0fe8bc
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/ValidArgs.h
@@ -0,0 +1,74 @@
+//
+// ValidArgs.h
+//
+// Library: Foundation
+// Package: Cache
+// Module:  ValidArgs
+//
+// Definition of the ValidArgs class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_ValidArgs_INCLUDED
+#define Foundation_ValidArgs_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+template <class TKey>
+class ValidArgs
+{
+public:
+	ValidArgs(const TKey& key):
+		_key(key), 
+		_isValid(true)
+	{
+	}
+
+	ValidArgs(const ValidArgs& args): 
+		_key(args._key), 
+		_isValid(args._isValid)
+	{
+	}
+
+	~ValidArgs()
+	{
+	}
+	
+	const TKey&	key() const
+	{
+		return _key;
+	}
+
+	bool isValid() const
+	{
+		return _isValid;
+	}
+
+	void invalidate()
+	{
+		_isValid = false;
+	}
+
+protected:
+	const TKey& _key;
+	bool        _isValid;
+
+private:
+	ValidArgs& operator = (const ValidArgs& args);
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_ValidArgs_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Version.h b/base/poco/Foundation/include/Poco/Version.h
new file mode 100644
index 00000000000..7fb17bc6e60
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Version.h
@@ -0,0 +1,42 @@
+//
+// Version.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Version
+//
+// Version information for the POCO C++ Libraries.
+//
+// Copyright (c) 2004-2016, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Version_INCLUDED
+#define Foundation_Version_INCLUDED
+
+
+//
+// Version Information
+//
+// Since 1.6.0, we're using Semantic Versioning 2.0
+// (http://semver.org/spec/v2.0.0.html)
+//
+// Version format is 0xAABBCCDD, where
+//    - AA is the major version number,
+//    - BB is the minor version number,
+//    - CC is the patch	version number, and
+//    - DD is the pre-release designation/number.
+//      The pre-release designation hex digits have a special meaning:
+//      00: final/stable releases
+//      Dx: development releases
+//      Ax: alpha releases
+//      Bx: beta releases
+//
+#define POCO_VERSION 0x01090300
+
+#define POCO_CLICKHOUSE_PATCH 1
+
+#endif // Foundation_Version_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Void.h b/base/poco/Foundation/include/Poco/Void.h
new file mode 100644
index 00000000000..fa0cd31afd4
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Void.h
@@ -0,0 +1,73 @@
+//
+// Void.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  Void
+//
+// Definition of the Void class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Void_INCLUDED
+#define Foundation_Void_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Void
+	/// A dummy class with value-type semantics, 
+	/// mostly useful as a template argument.
+	///
+	/// This class is typically used together with ActiveMethod,
+	/// if no argument or return value is needed.
+{
+public:
+	Void();
+		/// Creates the Void.
+
+	Void(const Void& v);
+		/// Creates the Void from another Void.
+		///
+		/// The philosophical aspects of this operation 
+		/// remain undiscussed for now.
+		
+	~Void();
+		/// Destroys the Void.
+
+	Void& operator = (const Void& v);
+		/// Assigns another void.
+
+	bool operator ==(const Void& v) const;
+		/// Will return always true due to Voids having no members.
+
+	bool operator !=(const Void& v) const;
+		/// Will return always false due to Voids having no members.
+};
+
+
+inline bool Void::operator ==(const Void& /*v*/) const
+{
+	return true;
+}
+
+
+inline bool Void::operator !=(const Void& /*v*/) const
+{
+	return false;
+}
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Void_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Windows1250Encoding.h b/base/poco/Foundation/include/Poco/Windows1250Encoding.h
new file mode 100644
index 00000000000..c40a4288481
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Windows1250Encoding.h
@@ -0,0 +1,52 @@
+//
+// Windows1250Encoding.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  Windows1250Encoding
+//
+// Definition of the Windows1250Encoding class.
+//
+// Copyright (c) 2005-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Windows1250Encoding_INCLUDED
+#define Foundation_Windows1250Encoding_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/TextEncoding.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Windows1250Encoding: public TextEncoding
+	/// Windows Codepage 1250 text encoding.
+	/// Based on: http://msdn.microsoft.com/en-us/goglobal/cc305143
+{
+public:
+	Windows1250Encoding();
+	~Windows1250Encoding();
+	const char* canonicalName() const;
+	bool isA(const std::string& encodingName) const;
+	const CharacterMap& characterMap() const;
+	int convert(const unsigned char* bytes) const;
+	int convert(int ch, unsigned char* bytes, int length) const;
+	int queryConvert(const unsigned char* bytes, int length) const;
+	int sequenceLength(const unsigned char* bytes, int length) const;
+	
+private:
+	static const char* _names[];
+	static const CharacterMap _charMap;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Windows1250Encoding_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Windows1251Encoding.h b/base/poco/Foundation/include/Poco/Windows1251Encoding.h
new file mode 100644
index 00000000000..87510a9d9d4
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Windows1251Encoding.h
@@ -0,0 +1,52 @@
+//
+// Windows1251Encoding.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  Windows1251Encoding
+//
+// Definition of the Windows1251Encoding class.
+//
+// Copyright (c) 2005-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Windows1251Encoding_INCLUDED
+#define Foundation_Windows1251Encoding_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/TextEncoding.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Windows1251Encoding: public TextEncoding
+	/// Windows Codepage 1251 text encoding.
+	/// Based on: http://msdn.microsoft.com/en-us/goglobal/cc305144
+{
+public:
+	Windows1251Encoding();
+	~Windows1251Encoding();
+	const char* canonicalName() const;
+	bool isA(const std::string& encodingName) const;
+	const CharacterMap& characterMap() const;
+	int convert(const unsigned char* bytes) const;
+	int convert(int ch, unsigned char* bytes, int length) const;
+	int queryConvert(const unsigned char* bytes, int length) const;
+	int sequenceLength(const unsigned char* bytes, int length) const;
+	
+private:
+	static const char* _names[];
+	static const CharacterMap _charMap;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Windows1251Encoding_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/Windows1252Encoding.h b/base/poco/Foundation/include/Poco/Windows1252Encoding.h
new file mode 100644
index 00000000000..a5e29014123
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/Windows1252Encoding.h
@@ -0,0 +1,51 @@
+//
+// Windows1252Encoding.h
+//
+// Library: Foundation
+// Package: Text
+// Module:  Windows1252Encoding
+//
+// Definition of the Windows1252Encoding class.
+//
+// Copyright (c) 2005-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_Windows1252Encoding_INCLUDED
+#define Foundation_Windows1252Encoding_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/TextEncoding.h"
+
+
+namespace Poco {
+
+
+class Foundation_API Windows1252Encoding: public TextEncoding
+	/// Windows Codepage 1252 text encoding.
+{
+public:
+	Windows1252Encoding();
+	~Windows1252Encoding();
+	const char* canonicalName() const;
+	bool isA(const std::string& encodingName) const;
+	const CharacterMap& characterMap() const;
+	int convert(const unsigned char* bytes) const;
+	int convert(int ch, unsigned char* bytes, int length) const;
+	int queryConvert(const unsigned char* bytes, int length) const;
+	int sequenceLength(const unsigned char* bytes, int length) const;
+	
+private:
+	static const char* _names[];
+	static const CharacterMap _charMap;
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_Windows1252Encoding_INCLUDED
diff --git a/base/poco/Foundation/include/Poco/WindowsConsoleChannel.h b/base/poco/Foundation/include/Poco/WindowsConsoleChannel.h
new file mode 100644
index 00000000000..b395c26d0ad
--- /dev/null
+++ b/base/poco/Foundation/include/Poco/WindowsConsoleChannel.h
@@ -0,0 +1,183 @@
+//
+// WindowsConsoleChannel.h
+//
+// Library: Foundation
+// Package: Logging
+// Module:  WindowsConsoleChannel
+//
+// Definition of the WindowsConsoleChannel class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Foundation_WindowsConsoleChannel_INCLUDED
+#define Foundation_WindowsConsoleChannel_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Channel.h"
+#include "Poco/Mutex.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class Foundation_API WindowsConsoleChannel: public Channel
+	/// A channel that writes to the Windows console.
+	///
+	/// Only the message's text is written, followed
+	/// by a newline.
+	///
+	/// If POCO has been compiled with POCO_WIN32_UTF8,
+	/// log messages are assumed to be UTF-8 encoded, and
+	/// are converted to UTF-16 prior to writing them to the
+	/// console. This is the main difference to the ConsoleChannel
+	/// class, which cannot handle UTF-8 encoded messages on Windows.
+	///
+	/// Chain this channel to a FormattingChannel with an
+	/// appropriate Formatter to control what is contained 
+	/// in the text.
+	///
+	/// Only available on Windows platforms.
+{
+public:
+	WindowsConsoleChannel();
+		/// Creates the WindowsConsoleChannel.
+
+	void log(const Message& msg);
+		/// Logs the given message to the channel's stream.
+		
+protected:
+	~WindowsConsoleChannel();
+
+private:
+	HANDLE _hConsole;
+	bool   _isFile;
+};
+
+
+class Foundation_API WindowsColorConsoleChannel: public Channel
+	/// A channel that writes to the Windows console.
+	///
+	/// Only the message's text is written, followed
+	/// by a newline.
+	///
+	/// If POCO has been compiled with POCO_WIN32_UTF8,
+	/// log messages are assumed to be UTF-8 encoded, and
+	/// are converted to UTF-16 prior to writing them to the
+	/// console. This is the main difference to the ConsoleChannel
+	/// class, which cannot handle UTF-8 encoded messages on Windows.
+	///
+	/// Messages can be colored depending on priority.
+	///
+	/// To enable message coloring, set the "enableColors"
+	/// property to true (default). Furthermore, colors can be
+	/// configured by setting the following properties
+	/// (default values are given in parenthesis):
+	/// 
+	///   * traceColor (gray)
+	///   * debugColor (gray)
+	///   * informationColor (default)
+	///   * noticeColor (default)
+	///   * warningColor (yellow)
+	///   * errorColor (lightRed)
+	///   * criticalColor (lightRed)
+	///   * fatalColor (lightRed)
+	///
+	/// The following color values are supported:
+	/// 
+	///   * default
+	///   * black
+	///   * red
+	///   * green
+	///   * brown
+	///   * blue
+	///   * magenta
+	///   * cyan
+	///   * gray
+	///   * darkgray
+	///   * lightRed
+	///   * lightGreen
+	///   * yellow
+	///   * lightBlue
+	///   * lightMagenta
+	///   * lightCyan
+	///   * white
+	///
+	/// Chain this channel to a FormattingChannel with an
+	/// appropriate Formatter to control what is contained 
+	/// in the text.
+	///
+	/// Only available on Windows platforms.
+{
+public:
+	WindowsColorConsoleChannel();
+		/// Creates the WindowsConsoleChannel.
+
+	void log(const Message& msg);
+		/// Logs the given message to the channel's stream.
+
+	void setProperty(const std::string& name, const std::string& value);
+		/// Sets the property with the given name. 
+		/// 
+		/// The following properties are supported:
+		///   * enableColors:      Enable or disable colors.
+		///   * traceColor:        Specify color for trace messages.
+		///   * debugColor:        Specify color for debug messages.
+		///   * informationColor:  Specify color for information messages.
+		///   * noticeColor:       Specify color for notice messages.
+		///   * warningColor:      Specify color for warning messages.
+		///   * errorColor:        Specify color for error messages.
+		///   * criticalColor:     Specify color for critical messages.
+		///   * fatalColor:        Specify color for fatal messages.
+		///
+		/// See the class documentation for a list of supported color values.
+
+	std::string getProperty(const std::string& name) const;
+		/// Returns the value of the property with the given name.
+		/// See setProperty() for a description of the supported
+		/// properties.
+		
+protected:
+	enum Color
+	{
+		CC_BLACK        = 0x0000,
+		CC_RED          = 0x0004,
+		CC_GREEN        = 0x0002,
+		CC_BROWN        = 0x0006,
+		CC_BLUE         = 0x0001,
+		CC_MAGENTA      = 0x0005,
+		CC_CYAN         = 0x0003,
+		CC_GRAY         = 0x0007,
+		CC_DARKGRAY     = 0x0008,
+		CC_LIGHTRED     = 0x000C,
+		CC_LIGHTGREEN   = 0x000A,
+		CC_YELLOW       = 0x000E,
+		CC_LIGHTBLUE    = 0x0009,
+		CC_LIGHTMAGENTA = 0x000D,
+		CC_LIGHTCYAN    = 0x000B,
+		CC_WHITE        = 0x000F
+	};
+
+	~WindowsColorConsoleChannel();
+	WORD parseColor(const std::string& color) const;
+	std::string formatColor(WORD color) const;
+	void initColors();
+
+private:
+	bool _enableColors;
+	HANDLE _hConsole;
+	bool   _isFile;
+	WORD   _colors[9];
+};
+
+
+} // namespace Poco
+
+
+#endif // Foundation_WindowsConsoleChannel_INCLUDED
diff --git a/base/poco/Foundation/src/ASCIIEncoding.cpp b/base/poco/Foundation/src/ASCIIEncoding.cpp
new file mode 100644
index 00000000000..cccd39062fd
--- /dev/null
+++ b/base/poco/Foundation/src/ASCIIEncoding.cpp
@@ -0,0 +1,116 @@
+//
+// ASCIIEncoding.cpp
+//
+// Library: Foundation
+// Package: Text
+// Module:  ASCIIEncoding
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/ASCIIEncoding.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+
+
+const char* ASCIIEncoding::_names[] =
+{
+	"ASCII",
+	NULL
+};
+
+
+const TextEncoding::CharacterMap ASCIIEncoding::_charMap = 
+{
+	/* 00 */	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 
+	/* 10 */	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 
+	/* 20 */	0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 
+	/* 30 */	0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 
+	/* 40 */	0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 
+	/* 50 */	0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 
+	/* 60 */	0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 
+	/* 70 */	0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 
+	/* 80 */	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
+	/* 90 */	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
+	/* a0 */	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
+	/* b0 */	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
+	/* c0 */	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
+	/* d0 */	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
+	/* e0 */	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
+	/* f0 */	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1, 
+};
+
+
+ASCIIEncoding::ASCIIEncoding()
+{
+}
+
+
+ASCIIEncoding::~ASCIIEncoding()
+{
+}
+
+
+const char* ASCIIEncoding::canonicalName() const
+{
+	return _names[0];
+}
+
+
+bool ASCIIEncoding::isA(const std::string& encodingName) const
+{
+	for (const char** name = _names; *name; ++name)
+	{
+		if (Poco::icompare(encodingName, *name) == 0)
+			return true;
+	}
+	return false;
+}
+
+
+const TextEncoding::CharacterMap& ASCIIEncoding::characterMap() const
+{
+	return _charMap;
+}
+
+
+int ASCIIEncoding::convert(const unsigned char* bytes) const
+{
+	return _charMap[*bytes];
+}
+
+
+int ASCIIEncoding::convert(int ch, unsigned char* bytes, int length) const
+{
+	if (ch >= 0 && ch <= 127)
+	{
+		if (bytes && length >= 1)
+			*bytes = (unsigned char) ch;
+		return 1;
+	}
+	else return 0;
+}
+
+
+int ASCIIEncoding::queryConvert(const unsigned char* bytes, int length) const
+{
+	if (1 <= length)
+		return _charMap [*bytes];
+	else
+		return -1;
+}
+
+
+int ASCIIEncoding::sequenceLength(const unsigned char* bytes, int length) const
+{
+	return 1;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/AbstractObserver.cpp b/base/poco/Foundation/src/AbstractObserver.cpp
new file mode 100644
index 00000000000..f4baacbb7a9
--- /dev/null
+++ b/base/poco/Foundation/src/AbstractObserver.cpp
@@ -0,0 +1,42 @@
+//
+// AbstractObserver.cpp
+//
+// Library: Foundation
+// Package: Notifications
+// Module:  NotificationCenter
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/AbstractObserver.h"
+
+
+namespace Poco {
+
+
+AbstractObserver::AbstractObserver()
+{
+}
+
+
+AbstractObserver::AbstractObserver(const AbstractObserver& observer)
+{
+}
+
+
+AbstractObserver::~AbstractObserver()
+{
+}
+
+	
+AbstractObserver& AbstractObserver::operator = (const AbstractObserver& observer)
+{
+	return *this;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/ActiveDispatcher.cpp b/base/poco/Foundation/src/ActiveDispatcher.cpp
new file mode 100644
index 00000000000..a50bd2fcf48
--- /dev/null
+++ b/base/poco/Foundation/src/ActiveDispatcher.cpp
@@ -0,0 +1,116 @@
+//
+// ActiveDispatcher.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  ActiveObjects
+//
+// Copyright (c) 2006-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/ActiveDispatcher.h"
+#include "Poco/Notification.h"
+#include "Poco/AutoPtr.h"
+
+
+namespace Poco {
+
+
+namespace
+{
+	class MethodNotification: public Notification
+	{
+	public:
+		MethodNotification(ActiveRunnableBase::Ptr pRunnable):
+			_pRunnable(pRunnable)
+		{
+		}
+		
+		ActiveRunnableBase::Ptr runnable() const
+		{
+			return _pRunnable;
+		}
+		
+	private:
+		ActiveRunnableBase::Ptr _pRunnable;
+	};
+	
+	class StopNotification: public Notification
+	{
+	};
+}
+
+
+ActiveDispatcher::ActiveDispatcher()
+{
+}
+
+
+ActiveDispatcher::ActiveDispatcher(Thread::Priority prio)
+{
+	_thread.setPriority(prio);
+}
+
+
+ActiveDispatcher::~ActiveDispatcher()
+{
+	try
+	{
+		stop();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+void ActiveDispatcher::start(ActiveRunnableBase::Ptr pRunnable)
+{
+	poco_check_ptr (pRunnable);
+
+    if (!_thread.isRunning())
+    {
+        _thread.start(*this);
+    }
+
+    _queue.enqueueNotification(new MethodNotification(pRunnable));
+}
+
+
+void ActiveDispatcher::cancel()
+{
+	_queue.clear();
+}
+
+
+void ActiveDispatcher::run()
+{
+	AutoPtr<Notification> pNf = _queue.waitDequeueNotification();
+	while (pNf && !dynamic_cast<StopNotification*>(pNf.get()))
+	{
+		MethodNotification* pMethodNf = dynamic_cast<MethodNotification*>(pNf.get());
+		poco_check_ptr (pMethodNf);
+		ActiveRunnableBase::Ptr pRunnable = pMethodNf->runnable();
+		pRunnable->duplicate(); // run will release
+		pRunnable->run();
+		pRunnable = 0;
+		pNf = 0;
+		pNf = _queue.waitDequeueNotification();
+	}
+}
+
+
+void ActiveDispatcher::stop()
+{
+	_queue.clear();
+	_queue.wakeUpAll();
+	_queue.enqueueNotification(new StopNotification);
+	_thread.join();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/ArchiveStrategy.cpp b/base/poco/Foundation/src/ArchiveStrategy.cpp
new file mode 100644
index 00000000000..27802edc295
--- /dev/null
+++ b/base/poco/Foundation/src/ArchiveStrategy.cpp
@@ -0,0 +1,212 @@
+//
+// ArchiveStrategy.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  FileChannel
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/ArchiveStrategy.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/File.h"
+#include "Poco/Path.h"
+#include "Poco/DeflatingStream.h"
+#include "Poco/StreamCopier.h"
+#include "Poco/Exception.h"
+#include "Poco/ActiveDispatcher.h"
+#include "Poco/ActiveMethod.h"
+#include "Poco/Void.h"
+#include "Poco/FileStream.h"
+
+
+namespace Poco {
+
+
+//
+// ArchiveCompressor
+//
+
+
+class ArchiveCompressor: public ActiveDispatcher
+{
+public:
+	ArchiveCompressor():
+		compress(this, &ArchiveCompressor::compressImpl)
+	{
+	}
+	
+	~ArchiveCompressor()
+	{
+	}
+	
+	ActiveMethod<void, std::string, ArchiveCompressor, ActiveStarter<ActiveDispatcher> > compress;
+
+protected:
+	void compressImpl(const std::string& path)
+	{
+		std::string gzPath(path);
+		gzPath.append(".gz");
+		FileInputStream istr(path);
+		FileOutputStream ostr(gzPath);
+		try
+		{
+			DeflatingOutputStream deflater(ostr, DeflatingStreamBuf::STREAM_GZIP);
+			StreamCopier::copyStream(istr, deflater);
+			if (!deflater.good() || !ostr.good()) throw WriteFileException(gzPath);
+			deflater.close();
+			ostr.close();
+			istr.close();
+		}
+		catch (Poco::Exception&)
+		{
+			// deflating failed - remove gz file and leave uncompressed log file
+			ostr.close();
+			Poco::File gzf(gzPath);
+			gzf.remove();
+			return;
+		}
+		File f(path);
+		f.remove();
+		return;
+	}
+};
+
+
+//
+// ArchiveStrategy
+//
+
+
+ArchiveStrategy::ArchiveStrategy(): 
+	_compress(false),
+	_pCompressor(0)
+{
+}
+
+
+ArchiveStrategy::~ArchiveStrategy()
+{
+	delete _pCompressor;
+}
+
+
+void ArchiveStrategy::compress(bool flag)
+{
+	_compress = flag;
+}
+
+
+void ArchiveStrategy::moveFile(const std::string& oldPath, const std::string& newPath)
+{
+	bool compressed = false;
+	Path p(oldPath);
+	File f(oldPath);
+	if (!f.exists())
+	{
+		f = oldPath + ".gz";
+		compressed = true;
+	}
+	std::string mvPath(newPath);
+	if (_compress || compressed)
+		mvPath.append(".gz");
+	if (!_compress || compressed)
+	{
+		f.renameTo(mvPath);
+	}
+	else
+	{
+		f.renameTo(newPath);
+		if (!_pCompressor) _pCompressor = new ArchiveCompressor;
+		_pCompressor->compress(newPath);
+	}
+}
+
+
+bool ArchiveStrategy::exists(const std::string& name)
+{
+	File f(name);
+	if (f.exists())
+	{
+		return true;
+	}
+	else if (_compress)
+	{
+		std::string gzName(name);
+		gzName.append(".gz");
+		File gzf(gzName);
+		return gzf.exists();
+	}
+	else return false;
+}
+
+
+//
+// ArchiveByNumberStrategy
+//
+
+
+ArchiveByNumberStrategy::ArchiveByNumberStrategy()
+{
+}
+
+
+ArchiveByNumberStrategy::~ArchiveByNumberStrategy()
+{
+}
+
+
+LogFile* ArchiveByNumberStrategy::archive(LogFile* pFile, bool streamCompress)
+{
+	std::string base = pFile->path();
+	std::string ext = "";
+
+	if (base.ends_with(".lz4"))
+	{
+		base.resize(base.size() - 4);
+		ext = ".lz4";
+	}
+
+	delete pFile;
+	int n = -1;
+	std::string path;
+	do
+	{
+		path = base;
+		path.append(".");
+		NumberFormatter::append(path, ++n);
+		path.append(ext);
+	}
+	while (exists(path));
+	
+	while (n >= 0)
+	{
+		std::string oldPath = base;
+		if (n > 0)
+		{
+			oldPath.append(".");
+			NumberFormatter::append(oldPath, n - 1);
+		}
+		oldPath.append(ext);
+
+		std::string newPath = base;
+		newPath.append(".");
+		NumberFormatter::append(newPath, n);
+		newPath.append(ext);
+		moveFile(oldPath, newPath);
+		--n;
+	}
+
+	if (streamCompress)
+		return new CompressedLogFile(base);
+	else
+		return new LogFile(base);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Ascii.cpp b/base/poco/Foundation/src/Ascii.cpp
new file mode 100644
index 00000000000..676b2db8eb3
--- /dev/null
+++ b/base/poco/Foundation/src/Ascii.cpp
@@ -0,0 +1,154 @@
+//
+// Ascii.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  Ascii
+//
+// Copyright (c) 2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Ascii.h"
+
+
+namespace Poco {
+
+
+const int Ascii::CHARACTER_PROPERTIES[128] = 
+{
+	/* 00 . */ ACP_CONTROL,
+	/* 01 . */ ACP_CONTROL,
+	/* 02 . */ ACP_CONTROL,
+	/* 03 . */ ACP_CONTROL,
+	/* 04 . */ ACP_CONTROL,
+	/* 05 . */ ACP_CONTROL,
+	/* 06 . */ ACP_CONTROL,
+	/* 07 . */ ACP_CONTROL,
+	/* 08 . */ ACP_CONTROL,
+	/* 09 . */ ACP_CONTROL | ACP_SPACE,
+	/* 0a . */ ACP_CONTROL | ACP_SPACE,
+	/* 0b . */ ACP_CONTROL | ACP_SPACE,
+	/* 0c . */ ACP_CONTROL | ACP_SPACE,
+	/* 0d . */ ACP_CONTROL | ACP_SPACE,
+	/* 0e . */ ACP_CONTROL,
+	/* 0f . */ ACP_CONTROL,
+	/* 10 . */ ACP_CONTROL,
+	/* 11 . */ ACP_CONTROL,
+	/* 12 . */ ACP_CONTROL,
+	/* 13 . */ ACP_CONTROL,
+	/* 14 . */ ACP_CONTROL,
+	/* 15 . */ ACP_CONTROL,
+	/* 16 . */ ACP_CONTROL,
+	/* 17 . */ ACP_CONTROL,
+	/* 18 . */ ACP_CONTROL,
+	/* 19 . */ ACP_CONTROL,
+	/* 1a . */ ACP_CONTROL,
+	/* 1b . */ ACP_CONTROL,
+	/* 1c . */ ACP_CONTROL,
+	/* 1d . */ ACP_CONTROL,
+	/* 1e . */ ACP_CONTROL,
+	/* 1f . */ ACP_CONTROL,
+	/* 20   */ ACP_SPACE | ACP_PRINT,
+	/* 21 ! */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 22 " */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 23 # */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 24 $ */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 25 % */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 26 & */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 27 ' */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 28 ( */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 29 ) */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 2a * */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 2b + */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 2c , */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 2d - */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 2e . */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 2f / */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 30 0 */ ACP_DIGIT | ACP_HEXDIGIT | ACP_GRAPH | ACP_PRINT,
+	/* 31 1 */ ACP_DIGIT | ACP_HEXDIGIT | ACP_GRAPH | ACP_PRINT,
+	/* 32 2 */ ACP_DIGIT | ACP_HEXDIGIT | ACP_GRAPH | ACP_PRINT,
+	/* 33 3 */ ACP_DIGIT | ACP_HEXDIGIT | ACP_GRAPH | ACP_PRINT,
+	/* 34 4 */ ACP_DIGIT | ACP_HEXDIGIT | ACP_GRAPH | ACP_PRINT,
+	/* 35 5 */ ACP_DIGIT | ACP_HEXDIGIT | ACP_GRAPH | ACP_PRINT,
+	/* 36 6 */ ACP_DIGIT | ACP_HEXDIGIT | ACP_GRAPH | ACP_PRINT,
+	/* 37 7 */ ACP_DIGIT | ACP_HEXDIGIT | ACP_GRAPH | ACP_PRINT,
+	/* 38 8 */ ACP_DIGIT | ACP_HEXDIGIT | ACP_GRAPH | ACP_PRINT,
+	/* 39 9 */ ACP_DIGIT | ACP_HEXDIGIT | ACP_GRAPH | ACP_PRINT,
+	/* 3a : */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 3b ; */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 3c < */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 3d = */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 3e > */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 3f ? */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 40 @ */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 41 A */ ACP_HEXDIGIT | ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 42 B */ ACP_HEXDIGIT | ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 43 C */ ACP_HEXDIGIT | ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 44 D */ ACP_HEXDIGIT | ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 45 E */ ACP_HEXDIGIT | ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 46 F */ ACP_HEXDIGIT | ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 47 G */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 48 H */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 49 I */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 4a J */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 4b K */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 4c L */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 4d M */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 4e N */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 4f O */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 50 P */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 51 Q */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 52 R */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 53 S */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 54 T */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 55 U */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 56 V */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 57 W */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 58 X */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 59 Y */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 5a Z */ ACP_ALPHA | ACP_UPPER | ACP_GRAPH | ACP_PRINT,
+	/* 5b [ */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 5c \ */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 5d ] */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 5e ^ */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 5f _ */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 60 ` */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 61 a */ ACP_HEXDIGIT | ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 62 b */ ACP_HEXDIGIT | ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 63 c */ ACP_HEXDIGIT | ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 64 d */ ACP_HEXDIGIT | ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 65 e */ ACP_HEXDIGIT | ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 66 f */ ACP_HEXDIGIT | ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 67 g */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 68 h */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 69 i */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 6a j */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 6b k */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 6c l */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 6d m */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 6e n */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 6f o */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 70 p */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 71 q */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 72 r */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 73 s */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 74 t */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 75 u */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 76 v */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 77 w */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 78 x */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 79 y */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 7a z */ ACP_ALPHA | ACP_LOWER | ACP_GRAPH | ACP_PRINT,
+	/* 7b { */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 7c | */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 7d } */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 7e ~ */ ACP_PUNCT | ACP_GRAPH | ACP_PRINT,
+	/* 7f . */ ACP_CONTROL
+};
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/AsyncChannel.cpp b/base/poco/Foundation/src/AsyncChannel.cpp
new file mode 100644
index 00000000000..adfadf4d090
--- /dev/null
+++ b/base/poco/Foundation/src/AsyncChannel.cpp
@@ -0,0 +1,168 @@
+//
+// AsyncChannel.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  AsyncChannel
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/AsyncChannel.h"
+#include "Poco/Notification.h"
+#include "Poco/Message.h"
+#include "Poco/Formatter.h"
+#include "Poco/AutoPtr.h"
+#include "Poco/LoggingRegistry.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+
+class MessageNotification: public Notification
+{
+public:
+	MessageNotification(const Message& msg):
+		_msg(msg)
+	{
+	}
+	
+	~MessageNotification()
+	{
+	}
+	
+	const Message& message() const
+	{
+		return _msg;
+	}
+	
+private:
+	Message _msg;
+};
+
+
+AsyncChannel::AsyncChannel(Channel* pChannel, Thread::Priority prio): 
+	_pChannel(pChannel), 
+	_thread("AsyncChannel")
+{
+	if (_pChannel) _pChannel->duplicate();
+	_thread.setPriority(prio);
+}
+
+
+AsyncChannel::~AsyncChannel()
+{
+	try
+	{
+		close();
+		if (_pChannel) _pChannel->release();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void AsyncChannel::setChannel(Channel* pChannel)
+{
+	FastMutex::ScopedLock lock(_channelMutex);
+	
+	if (_pChannel) _pChannel->release();
+	_pChannel = pChannel;
+	if (_pChannel) _pChannel->duplicate();
+}
+
+
+Channel* AsyncChannel::getChannel() const
+{
+	return _pChannel;
+}
+
+
+void AsyncChannel::open()
+{
+	FastMutex::ScopedLock lock(_threadMutex);
+
+	if (!_thread.isRunning())
+		_thread.start(*this);
+}
+
+
+void AsyncChannel::close()
+{
+	if (_thread.isRunning())
+	{
+		while (!_queue.empty()) Thread::sleep(100);
+		
+		do 
+		{
+			_queue.wakeUpAll(); 
+		}
+		while (!_thread.tryJoin(100));
+	}
+}
+
+
+void AsyncChannel::log(const Message& msg)
+{
+	open();
+
+	_queue.enqueueNotification(new MessageNotification(msg));
+}
+
+
+void AsyncChannel::setProperty(const std::string& name, const std::string& value)
+{
+	if (name == "channel")
+		setChannel(LoggingRegistry::defaultRegistry().channelForName(value));
+	else if (name == "priority")
+		setPriority(value);
+	else
+		Channel::setProperty(name, value);
+}
+
+
+void AsyncChannel::run()
+{
+	AutoPtr<Notification> nf = _queue.waitDequeueNotification();
+	while (nf)
+	{
+		MessageNotification* pNf = dynamic_cast<MessageNotification*>(nf.get());
+		{
+			FastMutex::ScopedLock lock(_channelMutex);
+
+			if (pNf && _pChannel) _pChannel->log(pNf->message());
+		}
+		nf = _queue.waitDequeueNotification();
+	}
+}
+		
+		
+void AsyncChannel::setPriority(const std::string& value)
+{
+	Thread::Priority prio = Thread::PRIO_NORMAL;
+	
+	if (value == "lowest")
+		prio = Thread::PRIO_LOWEST;
+	else if (value == "low")
+		prio = Thread::PRIO_LOW;
+	else if (value == "normal")
+		prio = Thread::PRIO_NORMAL;
+	else if (value == "high")
+		prio = Thread::PRIO_HIGH;
+	else if (value == "highest")
+		prio = Thread::PRIO_HIGHEST;
+	else
+		throw InvalidArgumentException("thread priority", value);
+		
+	_thread.setPriority(prio);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/AtomicCounter.cpp b/base/poco/Foundation/src/AtomicCounter.cpp
new file mode 100644
index 00000000000..ef94e02d1ab
--- /dev/null
+++ b/base/poco/Foundation/src/AtomicCounter.cpp
@@ -0,0 +1,231 @@
+//
+// AtomicCounter.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  AtomicCounter
+//
+// Copyright (c) 2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/AtomicCounter.h"
+
+
+namespace Poco {
+
+
+#if defined(POCO_HAVE_STD_ATOMICS)
+//
+// C++11 atomics
+//
+AtomicCounter::AtomicCounter():
+	_counter(0)
+{
+}
+
+	
+AtomicCounter::AtomicCounter(AtomicCounter::ValueType initialValue):
+	_counter(initialValue)
+{
+}
+
+
+AtomicCounter::AtomicCounter(const AtomicCounter& counter):
+	_counter(counter.value())
+{
+}
+
+
+AtomicCounter::~AtomicCounter()
+{
+}
+
+
+AtomicCounter& AtomicCounter::operator = (const AtomicCounter& counter)
+{
+	_counter.store(counter._counter.load());
+	return *this;
+}
+
+	
+AtomicCounter& AtomicCounter::operator = (AtomicCounter::ValueType value)
+{
+	_counter.store(value);
+	return *this;
+}
+
+
+#elif POCO_OS == POCO_OS_WINDOWS_NT
+//
+// Windows
+//
+AtomicCounter::AtomicCounter():
+	_counter(0)
+{
+}
+
+	
+AtomicCounter::AtomicCounter(AtomicCounter::ValueType initialValue):
+	_counter(initialValue)
+{
+}
+
+
+AtomicCounter::AtomicCounter(const AtomicCounter& counter):
+	_counter(counter.value())
+{
+}
+
+
+AtomicCounter::~AtomicCounter()
+{
+}
+
+
+AtomicCounter& AtomicCounter::operator = (const AtomicCounter& counter)
+{
+	InterlockedExchange(&_counter, counter.value());
+	return *this;
+}
+
+	
+AtomicCounter& AtomicCounter::operator = (AtomicCounter::ValueType value)
+{
+	InterlockedExchange(&_counter, value);
+	return *this;
+}
+
+
+#elif POCO_OS == POCO_OS_MAC_OS_X
+//
+// Mac OS X
+//
+AtomicCounter::AtomicCounter():
+	_counter(0)
+{
+}
+
+	
+AtomicCounter::AtomicCounter(AtomicCounter::ValueType initialValue):
+	_counter(initialValue)
+{
+}
+
+
+AtomicCounter::AtomicCounter(const AtomicCounter& counter):
+	_counter(counter.value())
+{
+}
+
+
+AtomicCounter::~AtomicCounter()
+{
+}
+
+
+AtomicCounter& AtomicCounter::operator = (const AtomicCounter& counter)
+{
+	_counter = counter.value();
+	return *this;
+}
+
+	
+AtomicCounter& AtomicCounter::operator = (AtomicCounter::ValueType value)
+{
+	_counter = value;
+	return *this;
+}
+
+
+#elif defined(POCO_HAVE_GCC_ATOMICS)
+//
+// GCC 4.1+ atomic builtins.
+//
+AtomicCounter::AtomicCounter():
+	_counter(0)
+{
+}
+
+	
+AtomicCounter::AtomicCounter(AtomicCounter::ValueType initialValue):
+	_counter(initialValue)
+{
+}
+
+
+AtomicCounter::AtomicCounter(const AtomicCounter& counter):
+	_counter(counter.value())
+{
+}
+
+
+AtomicCounter::~AtomicCounter()
+{
+}
+
+
+AtomicCounter& AtomicCounter::operator = (const AtomicCounter& counter)
+{
+	__sync_lock_test_and_set(&_counter, counter.value());
+	return *this;
+}
+
+	
+AtomicCounter& AtomicCounter::operator = (AtomicCounter::ValueType value)
+{
+	__sync_lock_test_and_set(&_counter, value);
+	return *this;
+}
+
+
+#else
+//
+// Generic implementation based on FastMutex
+//
+AtomicCounter::AtomicCounter()
+{
+	_counter.value = 0;
+}
+
+	
+AtomicCounter::AtomicCounter(AtomicCounter::ValueType initialValue)
+{
+	_counter.value = initialValue;
+}
+
+
+AtomicCounter::AtomicCounter(const AtomicCounter& counter)
+{
+	_counter.value = counter.value();
+}
+
+
+AtomicCounter::~AtomicCounter()
+{
+}
+
+
+AtomicCounter& AtomicCounter::operator = (const AtomicCounter& counter)
+{
+	FastMutex::ScopedLock lock(_counter.mutex);
+	_counter.value = counter.value();
+	return *this;
+}
+
+	
+AtomicCounter& AtomicCounter::operator = (AtomicCounter::ValueType value)
+{
+	FastMutex::ScopedLock lock(_counter.mutex);
+	_counter.value = value;
+	return *this;
+}
+
+
+#endif // POCO_OS
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Base32Decoder.cpp b/base/poco/Foundation/src/Base32Decoder.cpp
new file mode 100644
index 00000000000..ba9f9db5958
--- /dev/null
+++ b/base/poco/Foundation/src/Base32Decoder.cpp
@@ -0,0 +1,160 @@
+//
+// Base32Decoder.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  Base32
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Base32Decoder.h"
+#include "Poco/Base32Encoder.h"
+#include "Poco/Exception.h"
+#include "Poco/Mutex.h"
+#include <cstring>
+
+
+namespace Poco {
+
+
+unsigned char Base32DecoderBuf::IN_ENCODING[256];
+bool Base32DecoderBuf::IN_ENCODING_INIT = false;
+
+
+namespace
+{
+	static FastMutex mutex;
+}
+
+
+Base32DecoderBuf::Base32DecoderBuf(std::istream& istr): 
+	_groupLength(0),
+	_groupIndex(0),
+	_buf(*istr.rdbuf())
+{
+	FastMutex::ScopedLock lock(mutex);
+	if (!IN_ENCODING_INIT)
+	{
+		for (unsigned i = 0; i < sizeof(IN_ENCODING); i++)
+		{
+			IN_ENCODING[i] = 0xFF;
+		}
+		for (unsigned i = 0; i < sizeof(Base32EncoderBuf::OUT_ENCODING); i++)
+		{
+			IN_ENCODING[Base32EncoderBuf::OUT_ENCODING[i]] = i;
+		}
+		IN_ENCODING[static_cast<unsigned char>('=')] = '\0';
+		IN_ENCODING_INIT = true;
+	}
+}
+
+
+Base32DecoderBuf::~Base32DecoderBuf()
+{
+}
+
+
+int Base32DecoderBuf::readFromDevice()
+{
+	if (_groupIndex < _groupLength) 
+	{
+		return _group[_groupIndex++];
+	}
+	else
+	{
+		unsigned char buffer[8];
+		std::memset(buffer, '=', sizeof(buffer));
+		int c;
+
+		// per RFC-4648, Section 6, permissible block lengths are:
+		// 2, 4, 5, 7, and 8 bytes. Any other length is malformed.
+		//
+		do {
+			if ((c = readOne()) == -1) return -1;
+			buffer[0] = (unsigned char) c;
+			if (IN_ENCODING[buffer[0]] == 0xFF) throw DataFormatException();
+			if ((c = readOne()) == -1) throw DataFormatException();
+			buffer[1] = (unsigned char) c;
+			if (IN_ENCODING[buffer[1]] == 0xFF) throw DataFormatException();
+			if ((c = readOne()) == -1) break;
+			buffer[2] = (unsigned char) c;
+			if (IN_ENCODING[buffer[2]] == 0xFF) throw DataFormatException();
+			if ((c = readOne()) == -1) throw DataFormatException();
+			buffer[3] = (unsigned char) c;
+			if (IN_ENCODING[buffer[3]] == 0xFF) throw DataFormatException();
+			if ((c = readOne()) == -1) break;
+			buffer[4] = (unsigned char) c;
+			if (IN_ENCODING[buffer[4]] == 0xFF) throw DataFormatException();
+			if ((c = readOne()) == -1) break;
+			buffer[5] = (unsigned char) c;
+			if (IN_ENCODING[buffer[5]] == 0xFF) throw DataFormatException();
+			if ((c = readOne()) == -1) throw DataFormatException();
+			buffer[6] = (unsigned char) c;
+			if (IN_ENCODING[buffer[6]] == 0xFF) throw DataFormatException();
+			if ((c = readOne()) == -1) break;
+			buffer[7] = (unsigned char) c;
+			if (IN_ENCODING[buffer[7]] == 0xFF) throw DataFormatException();
+		} while (false);
+
+		_group[0] = (IN_ENCODING[buffer[0]] << 3) | (IN_ENCODING[buffer[1]] >> 2);
+		_group[1] = ((IN_ENCODING[buffer[1]] & 0x03) << 6) | (IN_ENCODING[buffer[2]] << 1) | (IN_ENCODING[buffer[3]] >> 4);
+		_group[2] = ((IN_ENCODING[buffer[3]] & 0x0F) << 4) | (IN_ENCODING[buffer[4]] >> 1);
+		_group[3] = ((IN_ENCODING[buffer[4]] & 0x01) << 7) | (IN_ENCODING[buffer[5]] << 2) | (IN_ENCODING[buffer[6]] >> 3);
+		_group[4] = ((IN_ENCODING[buffer[6]] & 0x07) << 5) | IN_ENCODING[buffer[7]];
+
+		if (buffer[2] == '=')
+			_groupLength = 1;
+		else if (buffer[4] == '=') 
+			_groupLength = 2;
+		else if (buffer[5] == '=') 
+			_groupLength = 3;
+		else if (buffer[7] == '=') 
+			_groupLength = 4;
+		else
+			_groupLength = 5;
+		_groupIndex = 1;
+		return _group[0];
+	}
+}
+
+
+int Base32DecoderBuf::readOne()
+{
+	int ch = _buf.sbumpc();
+	return ch;
+}
+
+
+Base32DecoderIOS::Base32DecoderIOS(std::istream& istr): _buf(istr)
+{
+	poco_ios_init(&_buf);
+}
+
+
+Base32DecoderIOS::~Base32DecoderIOS()
+{
+}
+
+
+Base32DecoderBuf* Base32DecoderIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+Base32Decoder::Base32Decoder(std::istream& istr): Base32DecoderIOS(istr), std::istream(&_buf)
+{
+}
+
+
+Base32Decoder::~Base32Decoder()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Base32Encoder.cpp b/base/poco/Foundation/src/Base32Encoder.cpp
new file mode 100644
index 00000000000..dbac2c977f8
--- /dev/null
+++ b/base/poco/Foundation/src/Base32Encoder.cpp
@@ -0,0 +1,202 @@
+//
+// Base32Encoder.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  Base32
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Base32Encoder.h"
+
+
+namespace Poco {
+
+
+const unsigned char Base32EncoderBuf::OUT_ENCODING[32] =
+{
+	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+	'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+	'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+	'Y', 'Z', '2', '3', '4', '5', '6', '7',
+};
+
+
+Base32EncoderBuf::Base32EncoderBuf(std::ostream& ostr, bool padding): 
+	_groupLength(0),
+	_buf(*ostr.rdbuf()),
+	_doPadding(padding)
+{
+}
+
+
+Base32EncoderBuf::~Base32EncoderBuf()
+{
+	try
+	{
+		close();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+
+int Base32EncoderBuf::writeToDevice(char c)
+{
+	static const int eof = std::char_traits<char>::eof();
+
+	_group[_groupLength++] = (unsigned char) c;
+	if (_groupLength == 5)
+	{
+		unsigned char idx;
+		idx = _group[0] >> 3;
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[0] & 0x07) << 2) | (_group[1] >> 6);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[1] & 0x3E) >> 1);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[1] & 0x01) << 4) | (_group[2] >> 4);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[2] & 0x0F) << 1) | (_group[3] >> 7);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[3] & 0x7C) >> 2);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[3] & 0x03) << 3) | (_group[4] >> 5);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = (_group[4] & 0x1F);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		_groupLength = 0;
+	}
+	return charToInt(c);
+}
+
+
+int Base32EncoderBuf::close()
+{
+	static const int eof = std::char_traits<char>::eof();
+
+	if (sync() == eof) return eof;
+	if (_groupLength == 1)
+	{
+		_group[1] = 0;
+		unsigned char idx;
+		idx = _group[0] >> 3;
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[0] & 0x07) << 2);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		if (_doPadding) {
+			if (_buf.sputc('=') == eof) return eof;
+			if (_buf.sputc('=') == eof) return eof;
+			if (_buf.sputc('=') == eof) return eof;
+			if (_buf.sputc('=') == eof) return eof;
+			if (_buf.sputc('=') == eof) return eof;
+			if (_buf.sputc('=') == eof) return eof;
+		}
+	}
+	else if (_groupLength == 2)
+	{
+		_group[2] = 0;
+		unsigned char idx;
+		idx = _group[0] >> 3;
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[0] & 0x07) << 2) | (_group[1] >> 6);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[1] & 0x3E) >> 1);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[1] & 0x01) << 4);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		if (_doPadding) {
+			if (_buf.sputc('=') == eof) return eof;
+			if (_buf.sputc('=') == eof) return eof;
+			if (_buf.sputc('=') == eof) return eof;
+			if (_buf.sputc('=') == eof) return eof;
+		}
+	}
+	else if (_groupLength == 3)
+	{
+		_group[3] = 0;
+		unsigned char idx;
+		idx = _group[0] >> 3;
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[0] & 0x07) << 2) | (_group[1] >> 6);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[1] & 0x3E) >> 1);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[1] & 0x01) << 4) | (_group[2] >> 4);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[2] & 0x0F) << 1);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		if (_doPadding) {
+			if (_buf.sputc('=') == eof) return eof;
+			if (_buf.sputc('=') == eof) return eof;
+			if (_buf.sputc('=') == eof) return eof;
+		}
+	}
+	else if (_groupLength == 4)
+	{
+		_group[4] = 0;
+		unsigned char idx;
+		idx = _group[0] >> 3;
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[0] & 0x07) << 2) | (_group[1] >> 6);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[1] & 0x3E) >> 1);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[1] & 0x01) << 4) | (_group[2] >> 4);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[2] & 0x0F) << 1) | (_group[3] >> 7);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[3] & 0x7C) >> 2);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		idx = ((_group[3] & 0x03) << 3);
+		if (_buf.sputc(OUT_ENCODING[idx]) == eof) return eof;
+		if (_doPadding && _buf.sputc('=') == eof) return eof;
+	}
+	_groupLength = 0;
+	return _buf.pubsync();
+}
+
+
+Base32EncoderIOS::Base32EncoderIOS(std::ostream& ostr, bool padding):
+	_buf(ostr, padding)
+{
+	poco_ios_init(&_buf);
+}
+
+
+Base32EncoderIOS::~Base32EncoderIOS()
+{
+}
+
+
+int Base32EncoderIOS::close()
+{
+	return _buf.close();
+}
+
+
+Base32EncoderBuf* Base32EncoderIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+Base32Encoder::Base32Encoder(std::ostream& ostr, bool padding):
+	Base32EncoderIOS(ostr, padding), std::ostream(&_buf)
+{
+}
+
+
+Base32Encoder::~Base32Encoder()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Base64Decoder.cpp b/base/poco/Foundation/src/Base64Decoder.cpp
new file mode 100644
index 00000000000..d433e51b8eb
--- /dev/null
+++ b/base/poco/Foundation/src/Base64Decoder.cpp
@@ -0,0 +1,178 @@
+//
+// Base64Decoder.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  Base64
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Base64Decoder.h"
+#include "Poco/Base64Encoder.h"
+#include "Poco/Exception.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+
+
+unsigned char Base64DecoderBuf::IN_ENCODING[256];
+bool Base64DecoderBuf::IN_ENCODING_INIT = false;
+unsigned char Base64DecoderBuf::IN_ENCODING_URL[256];
+bool Base64DecoderBuf::IN_ENCODING_URL_INIT = false;
+
+
+namespace
+{
+	static FastMutex mutex;
+}
+
+
+Base64DecoderBuf::Base64DecoderBuf(std::istream& istr, int options):
+	_options(options),
+	_groupLength(0),
+	_groupIndex(0),
+	_buf(*istr.rdbuf()),
+	_pInEncoding((options & BASE64_URL_ENCODING) ? IN_ENCODING_URL : IN_ENCODING)
+{
+	FastMutex::ScopedLock lock(mutex);
+	if (options & BASE64_URL_ENCODING)
+	{
+		if (!IN_ENCODING_URL_INIT)
+		{
+			for (unsigned i = 0; i < sizeof(IN_ENCODING_URL); i++)
+			{
+				IN_ENCODING_URL[i] = 0xFF;
+			}
+			for (unsigned i = 0; i < sizeof(Base64EncoderBuf::OUT_ENCODING_URL); i++)
+			{
+				IN_ENCODING_URL[Base64EncoderBuf::OUT_ENCODING_URL[i]] = i;
+			}
+			IN_ENCODING_URL[static_cast<unsigned char>('=')] = '\0';
+			IN_ENCODING_URL_INIT = true;
+		}
+	}
+	else
+	{
+		if (!IN_ENCODING_INIT)
+		{
+			for (unsigned i = 0; i < sizeof(IN_ENCODING); i++)
+			{
+				IN_ENCODING[i] = 0xFF;
+			}
+			for (unsigned i = 0; i < sizeof(Base64EncoderBuf::OUT_ENCODING); i++)
+			{
+				IN_ENCODING[Base64EncoderBuf::OUT_ENCODING[i]] = i;
+			}
+			IN_ENCODING[static_cast<unsigned char>('=')] = '\0';
+			IN_ENCODING_INIT = true;
+		}
+	}
+}
+
+
+Base64DecoderBuf::~Base64DecoderBuf()
+{
+}
+
+
+int Base64DecoderBuf::readFromDevice()
+{
+	if (_groupIndex < _groupLength)
+	{
+		return _group[_groupIndex++];
+	}
+	else
+	{
+		unsigned char buffer[4];
+		int c;
+		if ((c = readOne()) == -1) return -1;
+		buffer[0] = (unsigned char) c;
+		if (_pInEncoding[buffer[0]] == 0xFF) throw DataFormatException();
+		if ((c = readOne()) == -1) return -1;
+		buffer[1] = (unsigned char) c;
+		if (_pInEncoding[buffer[1]] == 0xFF) throw DataFormatException();
+		if (_options & BASE64_NO_PADDING)
+		{
+			if ((c = readOne()) != -1)
+				buffer[2] = c;
+			else
+				buffer[2] = '=';
+			if (_pInEncoding[buffer[2]] == 0xFF) throw DataFormatException();
+			if ((c = readOne()) != -1)
+				buffer[3] = c;
+			else
+				buffer[3] = '=';
+			if (_pInEncoding[buffer[3]] == 0xFF) throw DataFormatException();
+		}
+		else
+		{
+			if ((c = readOne()) == -1) throw DataFormatException();
+			buffer[2] = c;
+			if (_pInEncoding[buffer[2]] == 0xFF) throw DataFormatException();
+			if ((c = readOne()) == -1) throw DataFormatException();
+			buffer[3] = c;
+			if (_pInEncoding[buffer[3]] == 0xFF) throw DataFormatException();
+		}
+
+		_group[0] = (_pInEncoding[buffer[0]] << 2) | (_pInEncoding[buffer[1]] >> 4);
+		_group[1] = ((_pInEncoding[buffer[1]] & 0x0F) << 4) | (_pInEncoding[buffer[2]] >> 2);
+		_group[2] = (_pInEncoding[buffer[2]] << 6) | _pInEncoding[buffer[3]];
+
+		if (buffer[2] == '=')
+			_groupLength = 1;
+		else if (buffer[3] == '=')
+			_groupLength = 2;
+		else
+			_groupLength = 3;
+		_groupIndex = 1;
+		return _group[0];
+	}
+}
+
+
+int Base64DecoderBuf::readOne()
+{
+	int ch = _buf.sbumpc();
+	if (!(_options & BASE64_URL_ENCODING))
+	{
+		while (ch == ' ' || ch == '\r' || ch == '\t' || ch == '\n')
+			ch = _buf.sbumpc();
+	}
+	return ch;
+}
+
+
+Base64DecoderIOS::Base64DecoderIOS(std::istream& istr, int options): _buf(istr, options)
+{
+	poco_ios_init(&_buf);
+}
+
+
+Base64DecoderIOS::~Base64DecoderIOS()
+{
+}
+
+
+Base64DecoderBuf* Base64DecoderIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+Base64Decoder::Base64Decoder(std::istream& istr, int options): Base64DecoderIOS(istr, options), std::istream(&_buf)
+{
+}
+
+
+Base64Decoder::~Base64Decoder()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Base64Encoder.cpp b/base/poco/Foundation/src/Base64Encoder.cpp
new file mode 100644
index 00000000000..8f76f6cffb5
--- /dev/null
+++ b/base/poco/Foundation/src/Base64Encoder.cpp
@@ -0,0 +1,183 @@
+//
+// Base64Encoder.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  Base64
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Base64Encoder.h"
+
+
+namespace Poco {
+
+
+const unsigned char Base64EncoderBuf::OUT_ENCODING[64] =
+{
+	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+	'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+	'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+	'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+	'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+	'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+	'w', 'x', 'y', 'z', '0', '1', '2', '3',
+	'4', '5', '6', '7', '8', '9', '+', '/'
+};
+
+
+const unsigned char Base64EncoderBuf::OUT_ENCODING_URL[64] =
+{
+	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+	'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+	'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+	'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+	'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+	'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+	'w', 'x', 'y', 'z', '0', '1', '2', '3',
+	'4', '5', '6', '7', '8', '9', '-', '_'
+};
+
+
+Base64EncoderBuf::Base64EncoderBuf(std::ostream& ostr, int options):
+	_options(options),
+	_groupLength(0),
+	_pos(0),
+	_lineLength((options & BASE64_URL_ENCODING) ? 0 : 72),
+	_buf(*ostr.rdbuf()),
+	_pOutEncoding((options & BASE64_URL_ENCODING) ? OUT_ENCODING_URL : OUT_ENCODING)
+{
+}
+
+
+Base64EncoderBuf::~Base64EncoderBuf()
+{
+	try
+	{
+		close();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+void Base64EncoderBuf::setLineLength(int lineLength)
+{
+	_lineLength = lineLength;
+}
+
+
+int Base64EncoderBuf::getLineLength() const
+{
+	return _lineLength;
+}
+
+
+int Base64EncoderBuf::writeToDevice(char c)
+{
+	static const int eof = std::char_traits<char>::eof();
+
+	_group[_groupLength++] = (unsigned char) c;
+	if (_groupLength == 3)
+	{
+		unsigned char idx;
+		idx = _group[0] >> 2;
+		if (_buf.sputc(_pOutEncoding[idx]) == eof) return eof;
+		idx = ((_group[0] & 0x03) << 4) | (_group[1] >> 4);
+		if (_buf.sputc(_pOutEncoding[idx]) == eof) return eof;
+		idx = ((_group[1] & 0x0F) << 2) | (_group[2] >> 6);
+		if (_buf.sputc(_pOutEncoding[idx]) == eof) return eof;
+		idx = _group[2] & 0x3F;
+		if (_buf.sputc(_pOutEncoding[idx]) == eof) return eof;
+		_pos += 4;
+		if (_lineLength > 0 && _pos >= _lineLength)
+		{
+			if (_buf.sputc('\r') == eof) return eof;
+			if (_buf.sputc('\n') == eof) return eof;
+			_pos = 0;
+		}
+		_groupLength = 0;
+	}
+	return charToInt(c);
+}
+
+
+int Base64EncoderBuf::close()
+{
+	static const int eof = std::char_traits<char>::eof();
+
+	if (sync() == eof) return eof;
+	if (_groupLength == 1)
+	{
+		_group[1] = 0;
+		unsigned char idx;
+		idx = _group[0] >> 2;
+		if (_buf.sputc(_pOutEncoding[idx]) == eof) return eof;
+		idx = ((_group[0] & 0x03) << 4) | (_group[1] >> 4);
+		if (_buf.sputc(_pOutEncoding[idx]) == eof) return eof;
+		if (!(_options & BASE64_NO_PADDING))
+		{
+			if (_buf.sputc('=') == eof) return eof;
+			if (_buf.sputc('=') == eof) return eof;
+		}
+	}
+	else if (_groupLength == 2)
+	{
+		_group[2] = 0;
+		unsigned char idx;
+		idx = _group[0] >> 2;
+		if (_buf.sputc(_pOutEncoding[idx]) == eof) return eof;
+		idx = ((_group[0] & 0x03) << 4) | (_group[1] >> 4);
+		if (_buf.sputc(_pOutEncoding[idx]) == eof) return eof;
+		idx = ((_group[1] & 0x0F) << 2) | (_group[2] >> 6);
+		if (_buf.sputc(_pOutEncoding[idx]) == eof) return eof;
+		if (!(_options & BASE64_NO_PADDING))
+		{
+			if (_buf.sputc('=') == eof) return eof;
+		}
+	}
+	_groupLength = 0;
+	return _buf.pubsync();
+}
+
+
+Base64EncoderIOS::Base64EncoderIOS(std::ostream& ostr, int options): _buf(ostr, options)
+{
+	poco_ios_init(&_buf);
+}
+
+
+Base64EncoderIOS::~Base64EncoderIOS()
+{
+}
+
+
+int Base64EncoderIOS::close()
+{
+	return _buf.close();
+}
+
+
+Base64EncoderBuf* Base64EncoderIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+Base64Encoder::Base64Encoder(std::ostream& ostr, int options): Base64EncoderIOS(ostr, options), std::ostream(&_buf)
+{
+}
+
+
+Base64Encoder::~Base64Encoder()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/BinaryReader.cpp b/base/poco/Foundation/src/BinaryReader.cpp
new file mode 100644
index 00000000000..fb57371fbc3
--- /dev/null
+++ b/base/poco/Foundation/src/BinaryReader.cpp
@@ -0,0 +1,287 @@
+//
+// BinaryReader.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  BinaryReaderWriter
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/BinaryReader.h"
+#include "Poco/ByteOrder.h"
+#include "Poco/TextEncoding.h"
+#include "Poco/TextConverter.h"
+#include <algorithm>
+
+
+namespace Poco {
+
+
+BinaryReader::BinaryReader(std::istream& istr, StreamByteOrder byteOrder):
+	_istr(istr),
+	_pTextConverter(0)
+{
+#if defined(POCO_ARCH_BIG_ENDIAN)
+	_flipBytes = (byteOrder == LITTLE_ENDIAN_BYTE_ORDER);
+#else
+	_flipBytes = (byteOrder == BIG_ENDIAN_BYTE_ORDER);
+#endif
+}
+
+
+BinaryReader::BinaryReader(std::istream& istr, TextEncoding& encoding, StreamByteOrder byteOrder):
+	_istr(istr),
+	_pTextConverter(new TextConverter(encoding, Poco::TextEncoding::global()))
+{
+#if defined(POCO_ARCH_BIG_ENDIAN)
+	_flipBytes = (byteOrder == LITTLE_ENDIAN_BYTE_ORDER);
+#else
+	_flipBytes = (byteOrder == BIG_ENDIAN_BYTE_ORDER);
+#endif
+}
+
+
+BinaryReader::~BinaryReader()
+{
+	delete _pTextConverter;
+}
+
+
+BinaryReader& BinaryReader::operator >> (bool& value)
+{
+	_istr.read((char*) &value, sizeof(value));
+	return *this;
+}
+
+
+BinaryReader& BinaryReader::operator >> (char& value)
+{
+	_istr.read((char*) &value, sizeof(value));
+	return *this;
+}
+
+
+BinaryReader& BinaryReader::operator >> (unsigned char& value)
+{
+	_istr.read((char*) &value, sizeof(value));
+	return *this;
+}
+
+
+BinaryReader& BinaryReader::operator >> (signed char& value)
+{
+	_istr.read((char*) &value, sizeof(value));
+	return *this;
+}
+
+
+BinaryReader& BinaryReader::operator >> (short& value)
+{
+	_istr.read((char*) &value, sizeof(value));
+	if (_flipBytes) value = ByteOrder::flipBytes(value);
+	return *this;
+}
+
+
+BinaryReader& BinaryReader::operator >> (unsigned short& value)
+{
+	_istr.read((char*) &value, sizeof(value));
+	if (_flipBytes) value = ByteOrder::flipBytes(value);
+	return *this;
+}
+
+
+BinaryReader& BinaryReader::operator >> (int& value)
+{
+	_istr.read((char*) &value, sizeof(value));
+	if (_flipBytes) value = ByteOrder::flipBytes(value);
+	return *this;
+}
+
+
+BinaryReader& BinaryReader::operator >> (unsigned int& value)
+{
+	_istr.read((char*) &value, sizeof(value));
+	if (_flipBytes) value = ByteOrder::flipBytes(value);
+	return *this;
+}
+
+
+BinaryReader& BinaryReader::operator >> (long& value)
+{
+	_istr.read((char*) &value, sizeof(value));
+#if defined(POCO_LONG_IS_64_BIT)
+	if (_flipBytes) value = ByteOrder::flipBytes((Int64) value);
+#else
+	if (_flipBytes) value = ByteOrder::flipBytes((Int32) value);
+#endif
+	return *this;
+}
+
+
+BinaryReader& BinaryReader::operator >> (unsigned long& value)
+{
+	_istr.read((char*) &value, sizeof(value));
+#if defined(POCO_LONG_IS_64_BIT)
+	if (_flipBytes) value = ByteOrder::flipBytes((UInt64) value);
+#else
+	if (_flipBytes) value = ByteOrder::flipBytes((UInt32) value);
+#endif
+	return *this;
+}
+
+
+BinaryReader& BinaryReader::operator >> (float& value)
+{
+	if (_flipBytes)
+	{
+		char* ptr = (char*) &value;
+		ptr += sizeof(value);
+		for (unsigned i = 0; i < sizeof(value); ++i)
+			_istr.read(--ptr, 1);
+	}
+	else
+	{
+		_istr.read((char*) &value, sizeof(value));
+	}
+	return *this;
+}
+
+
+BinaryReader& BinaryReader::operator >> (double& value)
+{
+	if (_flipBytes)
+	{
+		char* ptr = (char*) &value;
+		ptr += sizeof(value);
+		for (unsigned i = 0; i < sizeof(value); ++i)
+			_istr.read(--ptr, 1);
+	}
+	else
+	{
+		_istr.read((char*) &value, sizeof(value));
+	}
+	return *this;
+}
+
+
+#if defined(POCO_HAVE_INT64) && !defined(POCO_LONG_IS_64_BIT)
+
+
+BinaryReader& BinaryReader::operator >> (Int64& value)
+{
+	_istr.read((char*) &value, sizeof(value));
+	if (_flipBytes) value = ByteOrder::flipBytes(value);
+	return *this;
+}
+
+
+BinaryReader& BinaryReader::operator >> (UInt64& value)
+{
+	_istr.read((char*) &value, sizeof(value));
+	if (_flipBytes) value = ByteOrder::flipBytes(value);
+	return *this;
+}
+
+
+#endif
+
+
+BinaryReader& BinaryReader::operator >> (std::string& value)
+{
+	UInt32 size = 0;
+	read7BitEncoded(size);
+	value.clear();
+	if (!_istr.good()) return *this;
+	value.reserve(size);
+	while (size--)
+	{
+		char c;
+		if (!_istr.read(&c, 1).good()) break;
+		value += c;
+	}
+	if (_pTextConverter)
+	{
+		std::string converted;
+		_pTextConverter->convert(value, converted);
+		std::swap(value, converted);
+	}
+	return *this;
+}
+
+
+void BinaryReader::read7BitEncoded(UInt32& value)
+{
+	char c;
+	value = 0;
+	int s = 0;
+	do
+	{
+		c = 0;
+		_istr.read(&c, 1);
+		UInt32 x = (c & 0x7F);
+		x <<= s;
+		value += x;
+		s += 7;
+	}
+	while (c & 0x80);
+}
+
+
+#if defined(POCO_HAVE_INT64)
+
+
+void BinaryReader::read7BitEncoded(UInt64& value)
+{
+	char c;
+	value = 0;
+	int s = 0;
+	do
+	{
+		c = 0;
+		_istr.read(&c, 1);
+		UInt64 x = (c & 0x7F);
+		x <<= s;
+		value += x;
+		s += 7;
+	}
+	while (c & 0x80);
+}
+
+
+#endif
+
+
+void BinaryReader::readRaw(std::streamsize length, std::string& value)
+{
+	value.clear();
+	value.reserve(static_cast<std::string::size_type>(length));
+	while (length--)
+	{
+		char c;
+		if (!_istr.read(&c, 1).good()) break;
+		value += c;
+	}
+}
+
+
+void BinaryReader::readRaw(char* buffer, std::streamsize length)
+{
+	_istr.read(buffer, length);
+}
+
+
+void BinaryReader::readBOM()
+{
+	UInt16 bom;
+	_istr.read((char*) &bom, sizeof(bom));
+	_flipBytes = bom != 0xFEFF;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/BinaryWriter.cpp b/base/poco/Foundation/src/BinaryWriter.cpp
new file mode 100644
index 00000000000..62e1adfe373
--- /dev/null
+++ b/base/poco/Foundation/src/BinaryWriter.cpp
@@ -0,0 +1,351 @@
+//
+// BinaryWriter.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  BinaryReaderWriter
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/BinaryWriter.h"
+#include "Poco/ByteOrder.h"
+#include "Poco/TextEncoding.h"
+#include "Poco/TextConverter.h"
+#include <cstring>
+
+
+namespace Poco {
+
+
+BinaryWriter::BinaryWriter(std::ostream& ostr, StreamByteOrder byteOrder):
+	_ostr(ostr),
+	_pTextConverter(0)
+{
+#if defined(POCO_ARCH_BIG_ENDIAN)
+	_flipBytes = (byteOrder == LITTLE_ENDIAN_BYTE_ORDER);
+#else
+	_flipBytes = (byteOrder == BIG_ENDIAN_BYTE_ORDER);
+#endif
+}
+
+
+BinaryWriter::BinaryWriter(std::ostream& ostr, TextEncoding& encoding, StreamByteOrder byteOrder):
+	_ostr(ostr),
+	_pTextConverter(new TextConverter(Poco::TextEncoding::global(), encoding))
+{
+#if defined(POCO_ARCH_BIG_ENDIAN)
+	_flipBytes = (byteOrder == LITTLE_ENDIAN_BYTE_ORDER);
+#else
+	_flipBytes = (byteOrder == BIG_ENDIAN_BYTE_ORDER);
+#endif
+}
+
+
+BinaryWriter::~BinaryWriter()
+{
+	delete _pTextConverter;
+}
+
+
+BinaryWriter& BinaryWriter::operator << (bool value)
+{
+	_ostr.write((const char*) &value, sizeof(value));
+	return *this;
+}
+
+
+BinaryWriter& BinaryWriter::operator << (char value)
+{
+	_ostr.write((const char*) &value, sizeof(value));
+	return *this;
+}
+
+
+BinaryWriter& BinaryWriter::operator << (unsigned char value)
+{
+	_ostr.write((const char*) &value, sizeof(value));
+	return *this;
+}
+
+
+BinaryWriter& BinaryWriter::operator << (signed char value)
+{
+	_ostr.write((const char*) &value, sizeof(value));
+	return *this;
+}
+
+
+BinaryWriter& BinaryWriter::operator << (short value)
+{
+	if (_flipBytes)
+	{
+		short fValue = ByteOrder::flipBytes(value);
+		_ostr.write((const char*) &fValue, sizeof(fValue));
+	}
+	else
+	{
+		_ostr.write((const char*) &value, sizeof(value));
+	}
+	return *this;
+}
+
+
+BinaryWriter& BinaryWriter::operator << (unsigned short value)
+{
+	if (_flipBytes)
+	{
+		unsigned short fValue = ByteOrder::flipBytes(value);
+		_ostr.write((const char*) &fValue, sizeof(fValue));
+	}
+	else
+	{
+		_ostr.write((const char*) &value, sizeof(value));
+	}
+	return *this;
+}
+
+
+BinaryWriter& BinaryWriter::operator << (int value)
+{
+	if (_flipBytes)
+	{
+		int fValue = ByteOrder::flipBytes(value);
+		_ostr.write((const char*) &fValue, sizeof(fValue));
+	}
+	else
+	{
+		_ostr.write((const char*) &value, sizeof(value));
+	}
+	return *this;
+}
+
+
+BinaryWriter& BinaryWriter::operator << (unsigned int value)
+{
+	if (_flipBytes)
+	{
+		unsigned int fValue = ByteOrder::flipBytes(value);
+		_ostr.write((const char*) &fValue, sizeof(fValue));
+	}
+	else
+	{
+		_ostr.write((const char*) &value, sizeof(value));
+	}
+	return *this;
+}
+
+
+BinaryWriter& BinaryWriter::operator << (long value)
+{
+	if (_flipBytes)
+	{
+#if defined(POCO_LONG_IS_64_BIT)
+		long fValue = ByteOrder::flipBytes((Int64) value);
+#else
+		long fValue = ByteOrder::flipBytes((Int32) value);
+#endif
+		_ostr.write((const char*) &fValue, sizeof(fValue));
+	}
+	else
+	{
+		_ostr.write((const char*) &value, sizeof(value));
+	}
+	return *this;
+}
+
+
+BinaryWriter& BinaryWriter::operator << (unsigned long value)
+{
+	if (_flipBytes)
+	{
+#if defined(POCO_LONG_IS_64_BIT)
+		long fValue = ByteOrder::flipBytes((UInt64) value);
+#else
+		long fValue = ByteOrder::flipBytes((UInt32) value);
+#endif
+		_ostr.write((const char*) &fValue, sizeof(fValue));
+	}
+	else
+	{
+		_ostr.write((const char*) &value, sizeof(value));
+	}
+	return *this;
+}
+
+
+BinaryWriter& BinaryWriter::operator << (float value)
+{
+	if (_flipBytes)
+	{
+		const char* ptr = (const char*) &value;
+		ptr += sizeof(value);
+		for (unsigned i = 0; i < sizeof(value); ++i)
+			_ostr.write(--ptr, 1);
+	}
+	else
+	{
+		_ostr.write((const char*) &value, sizeof(value));
+	}
+	return *this;
+}
+
+
+BinaryWriter& BinaryWriter::operator << (double value)
+{
+	if (_flipBytes)
+	{
+		const char* ptr = (const char*) &value;
+		ptr += sizeof(value);
+		for (unsigned i = 0; i < sizeof(value); ++i)
+			_ostr.write(--ptr, 1);
+	}
+	else
+	{
+		_ostr.write((const char*) &value, sizeof(value));
+	}
+	return *this;
+}
+
+
+#if defined(POCO_HAVE_INT64) && !defined(POCO_LONG_IS_64_BIT)
+
+
+BinaryWriter& BinaryWriter::operator << (Int64 value)
+{
+	if (_flipBytes)
+	{
+		Int64 fValue = ByteOrder::flipBytes(value);
+		_ostr.write((const char*) &fValue, sizeof(fValue));
+	}
+	else
+	{
+		_ostr.write((const char*) &value, sizeof(value));
+	}
+	return *this;
+}
+
+
+BinaryWriter& BinaryWriter::operator << (UInt64 value)
+{
+	if (_flipBytes)
+	{
+		UInt64 fValue = ByteOrder::flipBytes(value);
+		_ostr.write((const char*) &fValue, sizeof(fValue));
+	}
+	else
+	{
+		_ostr.write((const char*) &value, sizeof(value));
+	}
+	return *this;
+}
+
+
+#endif
+
+
+BinaryWriter& BinaryWriter::operator << (const std::string& value)
+{
+	if (_pTextConverter)
+	{
+		std::string converted;
+		_pTextConverter->convert(value, converted);
+		UInt32 length = (UInt32) converted.size();
+		write7BitEncoded(length);
+		_ostr.write(converted.data(), length);
+	}
+	else
+	{
+		UInt32 length = (UInt32) value.size();
+		write7BitEncoded(length);
+		_ostr.write(value.data(), length);
+	}
+	return *this;
+}
+
+
+BinaryWriter& BinaryWriter::operator << (const char* value)
+{
+	poco_check_ptr (value);
+	
+	if (_pTextConverter)
+	{
+		std::string converted;
+		_pTextConverter->convert(value, static_cast<int>(std::strlen(value)), converted);
+		UInt32 length = (UInt32) converted.size();
+		write7BitEncoded(length);
+		_ostr.write(converted.data(), length);
+	}
+	else
+	{
+		UInt32 length = static_cast<UInt32>(std::strlen(value));
+		write7BitEncoded(length);
+		_ostr.write(value, length);
+	}
+	return *this;
+}
+
+
+void BinaryWriter::write7BitEncoded(UInt32 value)
+{
+	do
+	{
+		unsigned char c = (unsigned char) (value & 0x7F);
+		value >>= 7;
+		if (value) c |= 0x80;
+		_ostr.write((const char*) &c, 1);
+	}
+	while (value);
+}
+
+
+#if defined(POCO_HAVE_INT64)
+
+
+void BinaryWriter::write7BitEncoded(UInt64 value)
+{
+	do
+	{
+		unsigned char c = (unsigned char) (value & 0x7F);
+		value >>= 7;
+		if (value) c |= 0x80;
+		_ostr.write((const char*) &c, 1);
+	}
+	while (value);
+}
+
+
+#endif
+
+
+void BinaryWriter::writeRaw(const std::string& rawData)
+{
+	_ostr.write(rawData.data(), (std::streamsize) rawData.length());
+}
+
+
+void BinaryWriter::writeRaw(const char* buffer, std::streamsize length)
+{
+	_ostr.write(buffer, length);
+}
+
+
+void BinaryWriter::writeBOM()
+{
+	UInt16 value = 0xFEFF;
+	if (_flipBytes) value = ByteOrder::flipBytes(value);
+	_ostr.write((const char*) &value, sizeof(value));
+}
+
+
+void BinaryWriter::flush()
+{
+	_ostr.flush();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Bugcheck.cpp b/base/poco/Foundation/src/Bugcheck.cpp
new file mode 100644
index 00000000000..14f5170c842
--- /dev/null
+++ b/base/poco/Foundation/src/Bugcheck.cpp
@@ -0,0 +1,119 @@
+//
+// Bugcheck.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  Bugcheck
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Bugcheck.h"
+#include "Poco/Debugger.h"
+#include "Poco/Exception.h"
+#include <sstream>
+
+
+namespace Poco {
+
+
+void Bugcheck::assertion(const char* cond, const char* file, int line, const char* text)
+{
+	std::string message("Assertion violation: ");
+	message += cond;
+	if (text)
+	{
+		message += " (";
+		message += text;
+		message += ")";
+	}
+	Debugger::enter(message, file, line);
+	throw AssertionViolationException(what(cond, file, line, text));
+}
+
+
+void Bugcheck::nullPointer(const char* ptr, const char* file, int line)
+{
+	Debugger::enter(std::string("NULL pointer: ") + ptr, file, line);
+	throw NullPointerException(what(ptr, file, line));
+}
+
+
+void Bugcheck::bugcheck(const char* file, int line)
+{
+	Debugger::enter("Bugcheck", file, line);
+	throw BugcheckException(what(0, file, line));
+}
+
+
+void Bugcheck::bugcheck(const char* msg, const char* file, int line)
+{
+	std::string m("Bugcheck");
+	if (msg)
+	{
+		m.append(": ");
+		m.append(msg);
+	}
+	Debugger::enter(m, file, line);
+	throw BugcheckException(what(msg, file, line));
+}
+
+
+void Bugcheck::unexpected(const char* file, int line)
+{
+#ifdef _DEBUG
+	try
+	{
+		std::string msg("Unexpected exception in noexcept function or destructor: ");
+		try
+		{
+			throw;
+		}
+		catch (Poco::Exception& exc)
+		{
+			msg += exc.displayText();
+		}
+		catch (std::exception& exc)
+		{
+			msg += exc.what();
+		}
+		catch (...)
+		{
+			msg += "unknown exception";
+		}
+		Debugger::enter(msg, file, line);
+	}
+	catch (...)
+	{
+	}
+#endif	
+}
+
+
+void Bugcheck::debugger(const char* file, int line)
+{
+	Debugger::enter(file, line);
+}
+
+
+void Bugcheck::debugger(const char* msg, const char* file, int line)
+{
+	Debugger::enter(msg, file, line);
+}
+
+
+std::string Bugcheck::what(const char* msg, const char* file, int line, const char* text)
+{
+	std::ostringstream str;
+	if (msg) str << msg << " ";
+   if (text != NULL) str << "(" << text << ") ";
+	str << "in file \"" << file << "\", line " << line;
+	return str.str();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/ByteOrder.cpp b/base/poco/Foundation/src/ByteOrder.cpp
new file mode 100644
index 00000000000..dd627bcb6ab
--- /dev/null
+++ b/base/poco/Foundation/src/ByteOrder.cpp
@@ -0,0 +1,15 @@
+//
+// ByteOrder.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  ByteOrder
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/ByteOrder.h"
diff --git a/base/poco/Foundation/src/Channel.cpp b/base/poco/Foundation/src/Channel.cpp
new file mode 100644
index 00000000000..02b163083d8
--- /dev/null
+++ b/base/poco/Foundation/src/Channel.cpp
@@ -0,0 +1,53 @@
+//
+// Channel.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  Channel
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Channel.h"
+
+
+namespace Poco {
+
+
+Channel::Channel()
+{
+}
+
+
+Channel::~Channel()
+{
+}
+
+
+void Channel::open()
+{
+}
+
+
+void Channel::close()
+{
+}
+
+
+void Channel::setProperty(const std::string& name, const std::string& value)
+{
+	throw PropertyNotSupportedException(name);
+}
+
+
+std::string Channel::getProperty(const std::string& name) const
+{
+	throw PropertyNotSupportedException(name);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Checksum.cpp b/base/poco/Foundation/src/Checksum.cpp
new file mode 100644
index 00000000000..097ffd9e736
--- /dev/null
+++ b/base/poco/Foundation/src/Checksum.cpp
@@ -0,0 +1,58 @@
+//
+// Checksum.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  Checksum
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Checksum.h"
+#if defined(POCO_UNBUNDLED)
+#include <zlib.h>
+#else
+#include "Poco/zlib.h"
+#endif
+
+
+namespace Poco {
+
+
+Checksum::Checksum():
+	_type(TYPE_CRC32),
+	_value(crc32(0L, Z_NULL, 0))
+{
+}
+
+
+Checksum::Checksum(Type t):
+	_type(t),
+	_value(0)
+{
+	if (t == TYPE_CRC32)
+		_value = crc32(0L, Z_NULL, 0);
+	else
+		_value = adler32(0L, Z_NULL, 0);
+}
+
+
+Checksum::~Checksum()
+{
+}
+
+
+void Checksum::update(const char* data, unsigned length)
+{
+	if (_type == TYPE_ADLER32)
+		_value = adler32(_value, reinterpret_cast<const Bytef*>(data), length);
+	else
+		_value = crc32(_value, reinterpret_cast<const Bytef*>(data), length);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Clock.cpp b/base/poco/Foundation/src/Clock.cpp
new file mode 100644
index 00000000000..e52cd5db453
--- /dev/null
+++ b/base/poco/Foundation/src/Clock.cpp
@@ -0,0 +1,231 @@
+//
+// Clock.cpp
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  Clock
+//
+// Copyright (c) 2013, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Clock.h"
+#include "Poco/Exception.h"
+#include "Poco/Timestamp.h"
+#if defined(__MACH__)
+#include <mach/mach.h>
+#include <mach/clock.h>
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include <time.h>
+#include <unistd.h>
+#elif defined(POCO_VXWORKS)
+#include <timers.h>
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "Poco/UnWindows.h"
+#endif
+#include <algorithm>
+#undef min
+#undef max
+#include <limits>
+
+
+#ifndef POCO_HAVE_CLOCK_GETTIME
+	#if (defined(_POSIX_TIMERS) && defined(CLOCK_REALTIME)) || defined(POCO_VXWORKS) || defined(__QNX__)
+		#ifndef __APPLE__ // See GitHub issue #1453 - not available before Mac OS 10.12/iOS 10
+			#define POCO_HAVE_CLOCK_GETTIME
+		#endif
+	#endif
+#endif
+
+
+namespace Poco {
+
+
+const Clock::ClockVal Clock::CLOCKVAL_MIN = std::numeric_limits<Clock::ClockVal>::min();
+const Clock::ClockVal Clock::CLOCKVAL_MAX = std::numeric_limits<Clock::ClockVal>::max();
+
+
+Clock::Clock()
+{
+	update();
+}
+
+
+Clock::Clock(ClockVal tv)
+{
+	_clock = tv;
+}
+
+
+Clock::Clock(const Clock& other)
+{
+	_clock = other._clock;
+}
+
+
+Clock::~Clock()
+{
+}
+
+
+Clock& Clock::operator = (const Clock& other)
+{
+	_clock = other._clock;
+	return *this;
+}
+
+
+Clock& Clock::operator = (ClockVal tv)
+{
+	_clock = tv;
+	return *this;
+}
+
+
+void Clock::swap(Clock& timestamp)
+{
+	std::swap(_clock, timestamp._clock);
+}
+
+
+void Clock::update()
+{
+#if defined(POCO_OS_FAMILY_WINDOWS)
+
+	LARGE_INTEGER perfCounter;
+	LARGE_INTEGER perfFreq;
+	if (QueryPerformanceCounter(&perfCounter) && QueryPerformanceFrequency(&perfFreq))
+	{
+		_clock = resolution()*(perfCounter.QuadPart/perfFreq.QuadPart);
+		_clock += (perfCounter.QuadPart % perfFreq.QuadPart)*resolution()/perfFreq.QuadPart;
+	}
+	else throw Poco::SystemException("cannot get system clock");
+
+#elif defined(__MACH__)
+
+	clock_serv_t cs;
+	mach_timespec_t ts;
+
+	host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cs);
+	clock_get_time(cs, &ts);
+	mach_port_deallocate(mach_task_self(), cs);
+	
+	_clock = ClockVal(ts.tv_sec)*resolution() + ts.tv_nsec/1000;
+
+#elif defined(POCO_VXWORKS)
+
+	struct timespec ts;
+#if defined(CLOCK_MONOTONIC) // should be in VxWorks 6.x
+	if (clock_gettime(CLOCK_MONOTONIC, &ts))
+		throw SystemException("cannot get system clock");
+#else
+	if (clock_gettime(CLOCK_REALTIME, &ts))
+		throw SystemException("cannot get system clock");
+#endif
+	_clock = ClockVal(ts.tv_sec)*resolution() + ts.tv_nsec/1000;
+
+#elif defined(POCO_HAVE_CLOCK_GETTIME)
+
+	struct timespec ts;
+	if (clock_gettime(CLOCK_MONOTONIC, &ts))
+		throw SystemException("cannot get system clock");
+	_clock = ClockVal(ts.tv_sec)*resolution() + ts.tv_nsec/1000;
+
+#else
+
+	Poco::Timestamp now;
+	_clock = now.epochMicroseconds();
+	
+#endif
+}
+
+
+Clock::ClockDiff Clock::accuracy()
+{
+#if defined(POCO_OS_FAMILY_WINDOWS)
+
+	LARGE_INTEGER perfFreq;
+	if (QueryPerformanceFrequency(&perfFreq) && perfFreq.QuadPart > 0)
+	{
+		ClockVal acc = resolution()/perfFreq.QuadPart;
+		return acc > 0 ? acc : 1;
+	}
+	else throw Poco::SystemException("cannot get system clock accuracy");
+
+#elif defined(__MACH__)
+
+	clock_serv_t cs;
+	int nanosecs;
+	mach_msg_type_number_t n = 1;
+
+	host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cs);
+	clock_get_attributes(cs, CLOCK_GET_TIME_RES, (clock_attr_t)&nanosecs, &n);
+	mach_port_deallocate(mach_task_self(), cs);
+	
+	ClockVal acc = nanosecs/1000;
+	return acc > 0 ? acc : 1;
+
+#elif defined(POCO_VXWORKS)
+
+	struct timespec ts;
+#if defined(CLOCK_MONOTONIC) // should be in VxWorks 6.x
+	if (clock_getres(CLOCK_MONOTONIC, &ts))
+		throw SystemException("cannot get system clock");
+#else
+	if (clock_getres(CLOCK_REALTIME, &ts))
+		throw SystemException("cannot get system clock");
+#endif
+	ClockVal acc = ClockVal(ts.tv_sec)*resolution() + ts.tv_nsec/1000;
+	return acc > 0 ? acc : 1;
+
+#elif defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK)
+
+	struct timespec ts;
+	if (clock_getres(CLOCK_MONOTONIC, &ts))
+		throw SystemException("cannot get system clock");
+	
+	ClockVal acc = ClockVal(ts.tv_sec)*resolution() + ts.tv_nsec/1000;
+	return acc > 0 ? acc : 1;
+
+#else
+
+	return 1000;
+	
+#endif
+}
+
+	
+bool Clock::monotonic()
+{
+#if defined(POCO_OS_FAMILY_WINDOWS)
+
+	return true;
+
+#elif defined(__MACH__)
+
+	return true;
+
+#elif defined(POCO_VXWORKS)
+
+#if defined(CLOCK_MONOTONIC) // should be in VxWorks 6.x
+	return true;
+#else
+	return false;
+#endif
+
+#elif defined(_POSIX_TIMERS) && defined(_POSIX_MONOTONIC_CLOCK)
+
+	return true;
+
+#else
+
+	return false;
+	
+#endif
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/CompressedLogFile.cpp b/base/poco/Foundation/src/CompressedLogFile.cpp
new file mode 100644
index 00000000000..28e7b280f0d
--- /dev/null
+++ b/base/poco/Foundation/src/CompressedLogFile.cpp
@@ -0,0 +1,112 @@
+//
+// CompressedLogFile.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  CompressedLogFile
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/CompressedLogFile.h"
+
+namespace Poco {
+
+
+CompressedLogFile::CompressedLogFile(const std::string& path): 
+	LogFile(path + ".lz4"),
+	_buffer(0)
+{
+	memset(&_kPrefs, 0, sizeof(_kPrefs));
+
+	size_t ret = LZ4F_createCompressionContext(&_ctx, LZ4F_VERSION);
+
+	if (LZ4F_isError(ret))
+		throw IOException(LZ4F_getErrorName(ret));
+
+	/// That should be enough
+	_buffer.setCapacity(LZ4F_compressBound(16 * 1024, &_kPrefs));
+
+	/// Write frame header and check for errors
+	size_t header_size = LZ4F_compressBegin(_ctx, static_cast<void *>(_buffer.begin()), _buffer.capacity(), &_kPrefs);
+
+	if (LZ4F_isError(header_size))
+		throw IOException(LZ4F_getErrorName(header_size));
+
+	writeBinary(_buffer.begin(), header_size, true);
+}
+
+CompressedLogFile::~CompressedLogFile()
+{
+	/// Compression end
+	size_t end_size = LZ4F_compressEnd(_ctx, static_cast<void *>(_buffer.begin()), _buffer.capacity(), nullptr);
+
+	if (!LZ4F_isError(end_size))
+		writeBinary(_buffer.begin(), end_size, true);
+	
+	LZ4F_freeCompressionContext(_ctx);
+}
+
+void CompressedLogFile::write(const std::string& text, bool flush)
+{
+	size_t in_capacity = text.size();
+	const char * in_data = text.data();
+
+	while (in_capacity > 0)
+	{
+		/// LZ4F_compressUpdate compresses whole input buffer at once so we need to shink it manually
+		size_t cur_buffer_size = in_capacity;
+
+		while (_buffer.capacity() < LZ4F_compressBound(cur_buffer_size, &_kPrefs))
+			cur_buffer_size /= 2;
+
+		size_t compressed_size = LZ4F_compressUpdate(
+			_ctx,
+			static_cast<void *>(_buffer.begin()),
+			_buffer.capacity(),
+			static_cast<const void *>(in_data),
+			cur_buffer_size,
+			nullptr);
+
+		if (LZ4F_isError(compressed_size))
+			throw IOException(LZ4F_getErrorName(compressed_size));
+		
+		if (compressed_size > 0)
+			writeBinary(_buffer.begin(), compressed_size, false);
+
+		in_capacity -= cur_buffer_size;
+		in_data += cur_buffer_size;
+	}
+
+	char newline = '\n';
+
+	size_t compressed_size = LZ4F_compressUpdate(
+		_ctx,
+		static_cast<void *>(_buffer.begin()),
+		_buffer.capacity(),
+		&newline,
+		sizeof(newline),
+		nullptr);
+
+	if (LZ4F_isError(compressed_size))
+		throw IOException(LZ4F_getErrorName(compressed_size));
+	
+	if (compressed_size == 0 && flush)
+	{
+		compressed_size = LZ4F_flush(_ctx, static_cast<void *>(_buffer.begin()), _buffer.capacity(), nullptr);
+
+		if (LZ4F_isError(compressed_size))
+			throw IOException(LZ4F_getErrorName(compressed_size));
+	}
+		
+
+	if (compressed_size > 0)
+		writeBinary(_buffer.begin(), compressed_size, flush);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Condition.cpp b/base/poco/Foundation/src/Condition.cpp
new file mode 100644
index 00000000000..0acb9d1bba5
--- /dev/null
+++ b/base/poco/Foundation/src/Condition.cpp
@@ -0,0 +1,79 @@
+//
+// Condition.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Condition
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Condition.h"
+
+
+namespace Poco {
+
+
+Condition::Condition()
+{
+}
+
+Condition::~Condition()
+{
+}
+
+
+void Condition::signal()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	if (!_waitQueue.empty())
+	{
+		_waitQueue.front()->set();
+		dequeue();
+	}
+}
+
+
+void Condition::broadcast()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	for (WaitQueue::iterator it = _waitQueue.begin(); it != _waitQueue.end(); ++it)
+	{
+		(*it)->set();
+	}
+	_waitQueue.clear();
+}
+
+
+void Condition::enqueue(Event& event)
+{
+	_waitQueue.push_back(&event);
+}
+
+
+void Condition::dequeue()
+{
+	_waitQueue.pop_front();
+}
+
+
+void Condition::dequeue(Event& event)
+{
+	for (WaitQueue::iterator it = _waitQueue.begin(); it != _waitQueue.end(); ++it)
+	{
+		if (*it == &event)
+		{
+			_waitQueue.erase(it);
+			break;
+		}
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Configurable.cpp b/base/poco/Foundation/src/Configurable.cpp
new file mode 100644
index 00000000000..822ecab24a2
--- /dev/null
+++ b/base/poco/Foundation/src/Configurable.cpp
@@ -0,0 +1,31 @@
+//
+// Configurable.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  Configurable
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Configurable.h"
+
+
+namespace Poco {
+
+
+Configurable::Configurable()
+{
+}
+
+
+Configurable::~Configurable()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/ConsoleChannel.cpp b/base/poco/Foundation/src/ConsoleChannel.cpp
new file mode 100644
index 00000000000..056e3fa4be7
--- /dev/null
+++ b/base/poco/Foundation/src/ConsoleChannel.cpp
@@ -0,0 +1,281 @@
+//
+// ConsoleChannel.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  ConsoleChannel
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/ConsoleChannel.h"
+#include "Poco/Message.h"
+#include "Poco/String.h"
+#include "Poco/Exception.h"
+#include <iostream>
+
+
+namespace Poco {
+
+
+FastMutex ConsoleChannel::_mutex;
+
+
+ConsoleChannel::ConsoleChannel(): _str(std::clog)
+{
+}
+
+
+ConsoleChannel::ConsoleChannel(std::ostream& str): _str(str)
+{
+}
+
+
+ConsoleChannel::~ConsoleChannel()
+{
+}
+
+
+void ConsoleChannel::log(const Message& msg)
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	_str << msg.getText() << std::endl;
+}
+
+
+FastMutex ColorConsoleChannel::_mutex;
+const std::string ColorConsoleChannel::CSI("\033[");
+
+
+ColorConsoleChannel::ColorConsoleChannel(): 
+	_str(std::clog),
+	_enableColors(true)
+{
+	initColors();
+}
+
+
+ColorConsoleChannel::ColorConsoleChannel(std::ostream& str): 
+	_str(str),
+	_enableColors(true)
+{
+	initColors();
+}
+
+
+ColorConsoleChannel::~ColorConsoleChannel()
+{
+}
+
+
+void ColorConsoleChannel::log(const Message& msg)
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	if (_enableColors)
+	{
+		int color = _colors[msg.getPriority()];
+		if (color & 0x100)
+		{
+			_str << CSI << "1m";
+		}
+		color &= 0xff;
+		_str << CSI << color << "m";
+	}
+	
+	_str << msg.getText();
+	
+	if (_enableColors)
+	{
+		_str << CSI << "0m";
+	}
+	
+	_str << std::endl;
+}
+
+
+void ColorConsoleChannel::setProperty(const std::string& name, const std::string& value)
+{
+	if (name == "enableColors")
+	{
+		_enableColors = icompare(value, "true") == 0;
+	}
+	else if (name == "testColor")
+	{
+		_colors[Message::PRIO_TEST] = parseColor(value);
+	}
+	else if (name == "traceColor")
+	{
+		_colors[Message::PRIO_TRACE] = parseColor(value);
+	}
+	else if (name == "debugColor")
+	{
+		_colors[Message::PRIO_DEBUG] = parseColor(value);
+	}
+	else if (name == "informationColor")
+	{
+		_colors[Message::PRIO_INFORMATION] = parseColor(value);
+	}
+	else if (name == "noticeColor")
+	{
+		_colors[Message::PRIO_NOTICE] = parseColor(value);
+	}
+	else if (name == "warningColor")
+	{
+		_colors[Message::PRIO_WARNING] = parseColor(value);
+	}
+	else if (name == "errorColor")
+	{
+		_colors[Message::PRIO_ERROR] = parseColor(value);
+	}
+	else if (name == "criticalColor")
+	{
+		_colors[Message::PRIO_CRITICAL] = parseColor(value);
+	}
+	else if (name == "fatalColor")
+	{
+		_colors[Message::PRIO_FATAL] = parseColor(value);
+	}
+	else
+	{
+		Channel::setProperty(name, value);
+	}
+}
+
+
+std::string ColorConsoleChannel::getProperty(const std::string& name) const
+{
+	if (name == "enableColors")
+	{
+		return _enableColors ? "true" : "false";
+	}
+	else if (name == "testColor")
+	{
+		return formatColor(_colors[Message::PRIO_TEST]);
+	}
+	else if (name == "traceColor")
+	{
+		return formatColor(_colors[Message::PRIO_TRACE]);
+	}
+	else if (name == "debugColor")
+	{
+		return formatColor(_colors[Message::PRIO_DEBUG]);
+	}
+	else if (name == "informationColor")
+	{
+		return formatColor(_colors[Message::PRIO_INFORMATION]);
+	}
+	else if (name == "noticeColor")
+	{
+		return formatColor(_colors[Message::PRIO_NOTICE]);
+	}
+	else if (name == "warningColor")
+	{
+		return formatColor(_colors[Message::PRIO_WARNING]);
+	}
+	else if (name == "errorColor")
+	{
+		return formatColor(_colors[Message::PRIO_ERROR]);
+	}
+	else if (name == "criticalColor")
+	{
+		return formatColor(_colors[Message::PRIO_CRITICAL]);
+	}
+	else if (name == "fatalColor")
+	{
+		return formatColor(_colors[Message::PRIO_FATAL]);
+	}
+	else
+	{
+		return Channel::getProperty(name);
+	}
+}
+
+
+ColorConsoleChannel::Color ColorConsoleChannel::parseColor(const std::string& color) const
+{
+	if (icompare(color, "default") == 0)
+		return CC_DEFAULT;
+	else if (icompare(color, "black") == 0)
+		return CC_BLACK;
+	else if (icompare(color, "red") == 0)
+		return CC_RED;
+	else if (icompare(color, "green") == 0)
+		return CC_GREEN;
+	else if (icompare(color, "brown") == 0)
+		return CC_BROWN;
+	else if (icompare(color, "blue") == 0)
+		return CC_BLUE;
+	else if (icompare(color, "magenta") == 0)
+		return CC_MAGENTA;
+	else if (icompare(color, "cyan") == 0)
+		return CC_CYAN;
+	else if (icompare(color, "gray") == 0)
+		return CC_GRAY;
+	else if (icompare(color, "darkGray") == 0)
+		return CC_DARKGRAY;
+	else if (icompare(color, "lightRed") == 0)
+		return CC_LIGHTRED;
+	else if (icompare(color, "lightGreen") == 0)
+		return CC_LIGHTGREEN;
+	else if (icompare(color, "yellow") == 0)
+		return CC_YELLOW;
+	else if (icompare(color, "lightBlue") == 0)
+		return CC_LIGHTBLUE;
+	else if (icompare(color, "lightMagenta") == 0)
+		return CC_LIGHTMAGENTA;
+	else if (icompare(color, "lightCyan") == 0)
+		return CC_LIGHTCYAN;
+	else if (icompare(color, "white") == 0)
+		return CC_WHITE;
+	else throw InvalidArgumentException("Invalid color value", color);
+}
+
+
+std::string ColorConsoleChannel::formatColor(Color color) const
+{
+	switch (color)
+	{
+	case CC_DEFAULT:      return "default";
+	case CC_BLACK:        return "black";
+	case CC_RED:          return "red";
+	case CC_GREEN:        return "green";
+	case CC_BROWN:        return "brown";
+	case CC_BLUE:         return "blue";
+	case CC_MAGENTA:      return "magenta";
+	case CC_CYAN:         return "cyan";
+	case CC_GRAY:         return "gray";
+	case CC_DARKGRAY:     return "darkGray";
+	case CC_LIGHTRED:     return "lightRed";
+	case CC_LIGHTGREEN:   return "lightGreen";
+	case CC_YELLOW:       return "yellow";
+	case CC_LIGHTBLUE:    return "lightBlue";
+	case CC_LIGHTMAGENTA: return "lightMagenta";
+	case CC_LIGHTCYAN:    return "lightCyan";
+	case CC_WHITE:        return "white";
+	default:              return "invalid";
+	}
+}
+
+
+void ColorConsoleChannel::initColors()
+{
+	_colors[0] = CC_DEFAULT; // unused
+	_colors[Message::PRIO_FATAL]       = CC_LIGHTRED;
+	_colors[Message::PRIO_CRITICAL]    = CC_LIGHTRED;
+	_colors[Message::PRIO_ERROR]       = CC_LIGHTRED;
+	_colors[Message::PRIO_WARNING]     = CC_YELLOW;
+	_colors[Message::PRIO_NOTICE]      = CC_DEFAULT;
+	_colors[Message::PRIO_INFORMATION] = CC_DEFAULT;
+	_colors[Message::PRIO_DEBUG]       = CC_GRAY;
+	_colors[Message::PRIO_TRACE]       = CC_GRAY;
+	_colors[Message::PRIO_TEST]        = CC_GRAY;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/CountingStream.cpp b/base/poco/Foundation/src/CountingStream.cpp
new file mode 100644
index 00000000000..b6e8e990961
--- /dev/null
+++ b/base/poco/Foundation/src/CountingStream.cpp
@@ -0,0 +1,199 @@
+//
+// CountingStream.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  CountingStream
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/CountingStream.h"
+
+
+namespace Poco {
+
+
+CountingStreamBuf::CountingStreamBuf(): 
+	_pIstr(0), 
+	_pOstr(0), 
+	_chars(0), 
+	_lines(0), 
+	_pos(0)
+{
+}
+
+
+CountingStreamBuf::CountingStreamBuf(std::istream& istr): 
+	_pIstr(&istr), 
+	_pOstr(0), 
+	_chars(0), 
+	_lines(0), 
+	_pos(0)
+{
+}
+
+
+CountingStreamBuf::CountingStreamBuf(std::ostream& ostr): 
+	_pIstr(0), 
+	_pOstr(&ostr), 
+	_chars(0), 
+	_lines(0), 
+	_pos(0)
+{
+}
+
+
+CountingStreamBuf::~CountingStreamBuf()
+{
+}
+
+
+int CountingStreamBuf::readFromDevice()
+{
+	if (_pIstr)
+	{
+		int c = _pIstr->get();
+		if (c != -1)
+		{
+			++_chars;
+			if (_pos++ == 0) ++_lines;
+			if (c == '\n') _pos = 0;
+		}
+		return c;
+	}
+	return -1;
+}
+
+
+int CountingStreamBuf::writeToDevice(char c)
+{
+	++_chars;
+	if (_pos++ == 0) ++_lines;
+	if (c == '\n') _pos = 0;
+	if (_pOstr) _pOstr->put(c);
+	return charToInt(c);
+}
+
+
+void CountingStreamBuf::reset()
+{
+	_chars = 0;
+	_lines = 0;
+	_pos   = 0;
+}
+
+
+void CountingStreamBuf::setCurrentLineNumber(int line)
+{
+	_lines = line;
+}
+
+
+void CountingStreamBuf::addChars(int chars)
+{
+	_chars += chars;
+}
+
+		
+void CountingStreamBuf::addLines(int lines)
+{
+	_lines += lines;
+}
+
+		
+void CountingStreamBuf::addPos(int pos)
+{
+	_pos += pos;
+}
+
+
+CountingIOS::CountingIOS()
+{
+	poco_ios_init(&_buf);
+}
+
+
+CountingIOS::CountingIOS(std::istream& istr): _buf(istr)
+{
+	poco_ios_init(&_buf);
+}
+
+
+CountingIOS::CountingIOS(std::ostream& ostr): _buf(ostr)
+{
+	poco_ios_init(&_buf);
+}
+
+
+CountingIOS::~CountingIOS()
+{
+}
+
+
+void CountingIOS::reset()
+{
+	_buf.reset();
+}
+
+
+void CountingIOS::setCurrentLineNumber(int line)
+{
+	_buf.setCurrentLineNumber(line);
+}
+
+
+void CountingIOS::addChars(int chars)
+{
+	_buf.addChars(chars);
+}
+
+		
+void CountingIOS::addLines(int lines)
+{
+	_buf.addLines(lines);
+}
+
+		
+void CountingIOS::addPos(int pos)
+{
+	_buf.addPos(pos);
+}
+
+
+CountingStreamBuf* CountingIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+CountingInputStream::CountingInputStream(std::istream& istr): CountingIOS(istr), std::istream(&_buf)
+{
+}
+
+
+CountingInputStream::~CountingInputStream()
+{
+}
+
+
+CountingOutputStream::CountingOutputStream(): std::ostream(&_buf)
+{
+}
+
+
+CountingOutputStream::CountingOutputStream(std::ostream& ostr): CountingIOS(ostr), std::ostream(&_buf)
+{
+}
+
+
+CountingOutputStream::~CountingOutputStream()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/DateTime.cpp b/base/poco/Foundation/src/DateTime.cpp
new file mode 100644
index 00000000000..7c17acefabc
--- /dev/null
+++ b/base/poco/Foundation/src/DateTime.cpp
@@ -0,0 +1,432 @@
+//
+// DateTime.cpp
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  DateTime
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DateTime.h"
+#include "Poco/Timespan.h"
+#include <algorithm>
+#include <cmath>
+
+
+namespace Poco {
+
+
+inline double DateTime::toJulianDay(Timestamp::UtcTimeVal utcTime)
+{
+	double utcDays = double(utcTime)/864000000000.0;
+	return utcDays + 2299160.5; // first day of Gregorian reform (Oct 15 1582)
+}
+
+
+inline Timestamp::UtcTimeVal DateTime::toUtcTime(double julianDay)
+{
+	return Timestamp::UtcTimeVal((julianDay - 2299160.5)*864000000000.0);
+}
+
+
+DateTime::DateTime()
+{
+	Timestamp now;
+	_utcTime = now.utcTime();
+	computeGregorian(julianDay());
+	computeDaytime();
+}
+
+
+DateTime::DateTime(const Timestamp& timestamp):
+	_utcTime(timestamp.utcTime())
+{
+	computeGregorian(julianDay());
+	computeDaytime();
+}
+
+	
+DateTime::DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond):
+	_year(year),
+	_month(month),
+	_day(day),
+	_hour(hour),
+	_minute(minute),
+	_second(second),
+	_millisecond(millisecond),
+	_microsecond(microsecond)
+{
+	poco_assert (year >= 0 && year <= 9999);
+	poco_assert (month >= 1 && month <= 12);
+	poco_assert (day >= 1 && day <= daysOfMonth(year, month));
+	poco_assert (hour >= 0 && hour <= 23);
+	poco_assert (minute >= 0 && minute <= 59);
+	poco_assert (second >= 0 && second <= 60); // allow leap seconds
+	poco_assert (millisecond >= 0 && millisecond <= 999);
+	poco_assert (microsecond >= 0 && microsecond <= 999);
+	
+	_utcTime = toUtcTime(toJulianDay(year, month, day)) + 10*(hour*Timespan::HOURS + minute*Timespan::MINUTES + second*Timespan::SECONDS + millisecond*Timespan::MILLISECONDS + microsecond);
+}
+
+
+DateTime::DateTime(double julianDay):
+	_utcTime(toUtcTime(julianDay))
+{
+	computeGregorian(julianDay);
+}
+
+
+DateTime::DateTime(Timestamp::UtcTimeVal utcTime, Timestamp::TimeDiff diff):
+	_utcTime(utcTime + diff*10)
+{
+	computeGregorian(julianDay());
+	computeDaytime();
+}
+
+
+DateTime::DateTime(const DateTime& dateTime):
+	_utcTime(dateTime._utcTime),
+	_year(dateTime._year),
+	_month(dateTime._month),
+	_day(dateTime._day),
+	_hour(dateTime._hour),
+	_minute(dateTime._minute),
+	_second(dateTime._second),
+	_millisecond(dateTime._millisecond),
+	_microsecond(dateTime._microsecond)
+{
+}
+
+
+DateTime::~DateTime()
+{
+}
+
+
+DateTime& DateTime::operator = (const DateTime& dateTime)
+{
+	if (&dateTime != this)
+	{
+		_utcTime     = dateTime._utcTime;
+		_year        = dateTime._year;
+		_month       = dateTime._month;
+		_day         = dateTime._day;
+		_hour        = dateTime._hour;
+		_minute      = dateTime._minute;
+		_second      = dateTime._second;
+		_millisecond = dateTime._millisecond;
+		_microsecond = dateTime._microsecond;
+	}
+	return *this;
+}
+
+	
+DateTime& DateTime::operator = (const Timestamp& timestamp)
+{
+	_utcTime = timestamp.utcTime();
+	computeGregorian(julianDay());
+	computeDaytime();
+	return *this;
+}
+
+
+DateTime& DateTime::operator = (double julianDay)
+{
+	_utcTime = toUtcTime(julianDay);
+	computeGregorian(julianDay);
+	return *this;
+}
+
+
+DateTime& DateTime::assign(int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond)
+{
+	poco_assert (year >= 0 && year <= 9999);
+	poco_assert (month >= 1 && month <= 12);
+	poco_assert (day >= 1 && day <= daysOfMonth(year, month));
+	poco_assert (hour >= 0 && hour <= 23);
+	poco_assert (minute >= 0 && minute <= 59);
+	poco_assert (second >= 0 && second <= 60); // allow leap seconds
+	poco_assert (millisecond >= 0 && millisecond <= 999);
+	poco_assert (microsecond >= 0 && microsecond <= 999);
+
+	_utcTime     = toUtcTime(toJulianDay(year, month, day)) + 10*(hour*Timespan::HOURS + minute*Timespan::MINUTES + second*Timespan::SECONDS + millisecond*Timespan::MILLISECONDS + microsecond);
+	_year        = year;
+	_month       = month;
+	_day         = day;
+	_hour        = hour;
+	_minute      = minute;
+	_second      = second;
+	_millisecond = millisecond;
+	_microsecond = microsecond;
+	
+	return *this;
+}
+
+
+void DateTime::swap(DateTime& dateTime)
+{
+	std::swap(_utcTime, dateTime._utcTime);
+	std::swap(_year, dateTime._year);
+	std::swap(_month, dateTime._month);
+	std::swap(_day, dateTime._day);
+	std::swap(_hour, dateTime._hour);
+	std::swap(_minute, dateTime._minute);
+	std::swap(_second, dateTime._second);
+	std::swap(_millisecond, dateTime._millisecond);
+	std::swap(_microsecond, dateTime._microsecond);
+}
+
+
+int DateTime::dayOfWeek() const
+{
+	return int((std::floor(julianDay() + 1.5))) % 7;
+}
+
+
+int DateTime::dayOfYear() const
+{
+	int doy = 0;
+	for (int month = 1; month < _month; ++month)
+		doy += daysOfMonth(_year, month);
+	doy += _day;
+	return doy;
+}
+
+
+int DateTime::daysOfMonth(int year, int month)
+{
+	poco_assert (month >= 1 && month <= 12);
+
+	static int daysOfMonthTable[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+	
+	if (month == 2 && isLeapYear(year))
+		return 29;
+	else
+		return daysOfMonthTable[month];
+}
+
+
+bool DateTime::isValid(int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond)
+{
+	return
+		(year >= 0 && year <= 9999) &&
+		(month >= 1 && month <= 12) &&
+		(day >= 1 && day <= daysOfMonth(year, month)) &&
+		(hour >= 0 && hour <= 23) &&
+		(minute >= 0 && minute <= 59) &&
+		(second >= 0 && second <= 60) &&
+		(millisecond >= 0 && millisecond <= 999) &&
+		(microsecond >= 0 && microsecond <= 999);
+}
+
+
+int DateTime::week(int firstDayOfWeek) const
+{
+	poco_assert (firstDayOfWeek >= 0 && firstDayOfWeek <= 6);
+
+	/// find the first firstDayOfWeek.
+	int baseDay = 1;
+	while (DateTime(_year, 1, baseDay).dayOfWeek() != firstDayOfWeek) ++baseDay;
+
+	int doy  = dayOfYear();
+	int offs = baseDay <= 4 ? 0 : 1; 
+	if (doy < baseDay)
+		return offs;
+	else
+		return (doy - baseDay)/7 + 1 + offs;
+}
+
+
+double DateTime::julianDay() const
+{
+	return toJulianDay(_utcTime);
+}
+
+
+DateTime DateTime::operator + (const Timespan& span) const
+{
+	return DateTime(_utcTime, span.totalMicroseconds());
+}
+
+
+DateTime DateTime::operator - (const Timespan& span) const
+{
+	return DateTime(_utcTime, -span.totalMicroseconds());
+}
+
+
+Timespan DateTime::operator - (const DateTime& dateTime) const
+{
+	return Timespan((_utcTime - dateTime._utcTime)/10);
+}
+
+
+DateTime& DateTime::operator += (const Timespan& span)
+{
+	_utcTime += span.totalMicroseconds()*10;
+	computeGregorian(julianDay());
+	computeDaytime();
+	return *this;
+}
+
+
+DateTime& DateTime::operator -= (const Timespan& span)
+{
+	_utcTime -= span.totalMicroseconds()*10;
+	computeGregorian(julianDay());
+	computeDaytime();
+	return *this;
+}
+
+
+void DateTime::makeUTC(int tzd)
+{
+	operator -= (Timespan(((Timestamp::TimeDiff) tzd)*Timespan::SECONDS));
+}
+
+	
+void DateTime::makeLocal(int tzd)
+{
+	operator += (Timespan(((Timestamp::TimeDiff) tzd)*Timespan::SECONDS));
+}
+
+
+double DateTime::toJulianDay(int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond)
+{
+	// lookup table for (153*month - 457)/5 - note that 3 <= month <= 14.
+	static int lookup[] = {-91, -60, -30, 0, 31, 61, 92, 122, 153, 184, 214, 245, 275, 306, 337};
+ 
+	// day to double
+	double dday = double(day) + ((double((hour*60 + minute)*60 + second)*1000 + millisecond)*1000 + microsecond)/86400000000.0;
+	if (month < 3)
+	{
+		month += 12;
+		--year;
+	}
+	double dyear = double(year);
+	return dday + lookup[month] + 365*year + std::floor(dyear/4) - std::floor(dyear/100) + std::floor(dyear/400) + 1721118.5;
+}
+
+
+void DateTime::checkLimit(short& lower, short& higher, short limit)
+{
+	if (lower >= limit)
+	{
+		higher += short(lower / limit);
+		lower   = short(lower % limit);
+	}
+}
+
+
+void DateTime::normalize()
+{
+	checkLimit(_microsecond, _millisecond, 1000);
+	checkLimit(_millisecond, _second, 1000);
+	checkLimit(_second, _minute, 60);
+	checkLimit(_minute, _hour, 60);
+	checkLimit(_hour, _day, 24);
+
+	if (_day > daysOfMonth(_year, _month))
+	{
+		_day -= daysOfMonth(_year, _month);
+		if (++_month > 12)
+		{
+			++_year;
+			_month -= 12;
+		}
+	}
+}
+
+
+void DateTime::computeGregorian(double julianDay)
+{
+	double z    = std::floor(julianDay - 1721118.5);
+	double r    = julianDay - 1721118.5 - z;
+	double g    = z - 0.25;
+	double a    = std::floor(g / 36524.25);
+	double b    = a - std::floor(a/4);
+	_year       = short(std::floor((b + g)/365.25));
+	double c    = b + z - std::floor(365.25*_year);
+	_month      = short(std::floor((5*c + 456)/153));
+	double dday = c - std::floor((153.0*_month - 457)/5) + r;
+	_day        = short(dday);
+	if (_month > 12)
+	{
+		++_year;
+		_month -= 12;
+	}
+	r      *= 24;
+	_hour   = short(std::floor(r));
+	r      -= std::floor(r);
+	r      *= 60;
+	_minute = short(std::floor(r));
+	r      -= std::floor(r);
+	r      *= 60;
+	_second = short(std::floor(r));
+	r      -= std::floor(r);
+	r      *= 1000;
+	_millisecond = short(std::floor(r));
+	r      -= std::floor(r);
+	r      *= 1000;
+	_microsecond = short(r + 0.5);
+
+	normalize();
+
+	poco_assert_dbg (_month >= 1 && _month <= 12);
+	poco_assert_dbg (_day >= 1 && _day <= daysOfMonth(_year, _month));
+	poco_assert_dbg (_hour >= 0 && _hour <= 23);
+	poco_assert_dbg (_minute >= 0 && _minute <= 59);
+	poco_assert_dbg (_second >= 0 && _second <= 59);
+	poco_assert_dbg (_millisecond >= 0 && _millisecond <= 999);
+	poco_assert_dbg (_microsecond >= 0 && _microsecond <= 999);
+}
+
+
+void DateTime::computeDaytime()
+{
+	Timespan span(_utcTime/10);
+	int hour = span.hours();
+	// Due to double rounding issues, the previous call to computeGregorian()
+	// may have crossed into the next or previous day. We need to correct that.
+	if (hour == 23 && _hour == 0)
+	{
+		_day--;
+		if (_day == 0)
+		{
+			_month--;
+			if (_month == 0)
+			{
+				_month = 12;
+				_year--;
+			}
+			_day = daysOfMonth(_year, _month);
+		}
+	}
+	else if (hour == 0 && _hour == 23)
+	{
+		_day++;
+		if (_day > daysOfMonth(_year, _month))
+		{
+			_month++;
+			if (_month > 12)
+			{
+				_month = 1;
+				_year++;
+			}
+			_day = 1;
+		}
+	}
+	_hour        = hour;
+	_minute      = span.minutes();
+	_second      = span.seconds();
+	_millisecond = span.milliseconds();
+	_microsecond = span.microseconds();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/DateTimeFormat.cpp b/base/poco/Foundation/src/DateTimeFormat.cpp
new file mode 100644
index 00000000000..9f16a392ea1
--- /dev/null
+++ b/base/poco/Foundation/src/DateTimeFormat.cpp
@@ -0,0 +1,61 @@
+//
+// DateTimeFormat.cpp
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  DateTimeFormat
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DateTimeFormat.h"
+
+
+namespace Poco {
+
+
+const std::string DateTimeFormat::ISO8601_FORMAT("%Y-%m-%dT%H:%M:%S%z");
+const std::string DateTimeFormat::ISO8601_FRAC_FORMAT("%Y-%m-%dT%H:%M:%s%z");
+const std::string DateTimeFormat::RFC822_FORMAT("%w, %e %b %y %H:%M:%S %Z");
+const std::string DateTimeFormat::RFC1123_FORMAT("%w, %e %b %Y %H:%M:%S %Z");
+const std::string DateTimeFormat::HTTP_FORMAT("%w, %d %b %Y %H:%M:%S %Z");
+const std::string DateTimeFormat::RFC850_FORMAT("%W, %e-%b-%y %H:%M:%S %Z");
+const std::string DateTimeFormat::RFC1036_FORMAT("%W, %e %b %y %H:%M:%S %Z");
+const std::string DateTimeFormat::ASCTIME_FORMAT("%w %b %f %H:%M:%S %Y");
+const std::string DateTimeFormat::SORTABLE_FORMAT("%Y-%m-%d %H:%M:%S");
+
+
+const std::string DateTimeFormat::WEEKDAY_NAMES[] =
+{
+	"Sunday",
+	"Monday",
+	"Tuesday",
+	"Wednesday",
+	"Thursday",
+	"Friday",
+	"Saturday"
+};
+
+
+const std::string DateTimeFormat::MONTH_NAMES[] =
+{
+	"January",
+	"February",
+	"March",
+	"April",
+	"May",
+	"June",
+	"July",
+	"August",
+	"September",
+	"October",
+	"November",
+	"December"
+};
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/DateTimeFormatter.cpp b/base/poco/Foundation/src/DateTimeFormatter.cpp
new file mode 100644
index 00000000000..25ce6b01fff
--- /dev/null
+++ b/base/poco/Foundation/src/DateTimeFormatter.cpp
@@ -0,0 +1,155 @@
+//
+// DateTimeFormatter.cpp
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  DateTimeFormatter
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DateTimeFormatter.h"
+#include "Poco/DateTimeFormat.h"
+#include "Poco/Timestamp.h"
+#include "Poco/NumberFormatter.h"
+
+
+namespace Poco {
+
+
+void DateTimeFormatter::append(std::string& str, const LocalDateTime& dateTime, const std::string& fmt)
+{
+	DateTimeFormatter::append(str, dateTime._dateTime, fmt, dateTime.tzd());
+}
+
+
+void DateTimeFormatter::append(std::string& str, const DateTime& dateTime, const std::string& fmt, int timeZoneDifferential)
+{
+	std::string::const_iterator it  = fmt.begin();
+	std::string::const_iterator end = fmt.end();
+	while (it != end)
+	{
+		if (*it == '%')
+		{
+			if (++it != end)
+			{
+				switch (*it)
+				{
+				case 'w': str.append(DateTimeFormat::WEEKDAY_NAMES[dateTime.dayOfWeek()], 0, 3); break;
+				case 'W': str.append(DateTimeFormat::WEEKDAY_NAMES[dateTime.dayOfWeek()]); break;
+				case 'b': str.append(DateTimeFormat::MONTH_NAMES[dateTime.month() - 1], 0, 3); break;
+				case 'B': str.append(DateTimeFormat::MONTH_NAMES[dateTime.month() - 1]); break;
+				case 'd': NumberFormatter::append0(str, dateTime.day(), 2); break;
+				case 'e': NumberFormatter::append(str, dateTime.day()); break;
+				case 'f': NumberFormatter::append(str, dateTime.day(), 2); break;
+				case 'm': NumberFormatter::append0(str, dateTime.month(), 2); break;
+				case 'n': NumberFormatter::append(str, dateTime.month()); break;
+				case 'o': NumberFormatter::append(str, dateTime.month(), 2); break;
+				case 'y': NumberFormatter::append0(str, dateTime.year() % 100, 2); break;
+				case 'Y': NumberFormatter::append0(str, dateTime.year(), 4); break;
+				case 'H': NumberFormatter::append0(str, dateTime.hour(), 2); break;
+				case 'h': NumberFormatter::append0(str, dateTime.hourAMPM(), 2); break;
+				case 'a': str.append(dateTime.isAM() ? "am" : "pm"); break;
+				case 'A': str.append(dateTime.isAM() ? "AM" : "PM"); break;
+				case 'M': NumberFormatter::append0(str, dateTime.minute(), 2); break;
+				case 'S': NumberFormatter::append0(str, dateTime.second(), 2); break;
+				case 's': NumberFormatter::append0(str, dateTime.second(), 2); 
+				          str += '.'; 
+				          NumberFormatter::append0(str, dateTime.millisecond()*1000 + dateTime.microsecond(), 6); 
+				          break;
+				case 'i': NumberFormatter::append0(str, dateTime.millisecond(), 3); break;
+				case 'c': NumberFormatter::append(str, dateTime.millisecond()/100); break;
+				case 'F': NumberFormatter::append0(str, dateTime.millisecond()*1000 + dateTime.microsecond(), 6); break;
+				case 'z': tzdISO(str, timeZoneDifferential); break;
+				case 'Z': tzdRFC(str, timeZoneDifferential); break;
+				default:  str += *it;
+				}
+				++it;
+			}
+		}
+		else str += *it++;
+	}
+}
+
+
+void DateTimeFormatter::append(std::string& str, const Timespan& timespan, const std::string& fmt)
+{
+	std::string::const_iterator it  = fmt.begin();
+	std::string::const_iterator end = fmt.end();
+	while (it != end)
+	{
+		if (*it == '%')
+		{
+			if (++it != end)
+			{
+				switch (*it)
+				{
+				case 'd': NumberFormatter::append(str, timespan.days()); break;
+				case 'H': NumberFormatter::append0(str, timespan.hours(), 2); break;
+				case 'h': NumberFormatter::append(str, timespan.totalHours()); break;
+				case 'M': NumberFormatter::append0(str, timespan.minutes(), 2); break;
+				case 'm': NumberFormatter::append(str, timespan.totalMinutes()); break;
+				case 'S': NumberFormatter::append0(str, timespan.seconds(), 2); break;
+				case 's': NumberFormatter::append(str, timespan.totalSeconds()); break;
+				case 'i': NumberFormatter::append0(str, timespan.milliseconds(), 3); break;
+				case 'c': NumberFormatter::append(str, timespan.milliseconds()/100); break;
+				case 'F': NumberFormatter::append0(str, timespan.milliseconds()*1000 + timespan.microseconds(), 6); break;
+				default:  str += *it;
+				}
+				++it;
+			}
+		}
+		else str += *it++;
+	}
+}
+
+
+void DateTimeFormatter::tzdISO(std::string& str, int timeZoneDifferential)
+{
+	if (timeZoneDifferential != UTC)
+	{
+		if (timeZoneDifferential >= 0)
+		{
+			str += '+';
+			NumberFormatter::append0(str, timeZoneDifferential/3600, 2);
+			str += ':';
+			NumberFormatter::append0(str, (timeZoneDifferential%3600)/60, 2);
+		}
+		else
+		{
+			str += '-';
+			NumberFormatter::append0(str, -timeZoneDifferential/3600, 2);
+			str += ':';
+			NumberFormatter::append0(str, (-timeZoneDifferential%3600)/60, 2);
+		}
+	}
+	else str += 'Z';
+}
+
+
+void DateTimeFormatter::tzdRFC(std::string& str, int timeZoneDifferential)
+{
+	if (timeZoneDifferential != UTC)
+	{
+		if (timeZoneDifferential >= 0)
+		{
+			str += '+';
+			NumberFormatter::append0(str, timeZoneDifferential/3600, 2);
+			NumberFormatter::append0(str, (timeZoneDifferential%3600)/60, 2);
+		}
+		else
+		{
+			str += '-';
+			NumberFormatter::append0(str, -timeZoneDifferential/3600, 2);
+			NumberFormatter::append0(str, (-timeZoneDifferential%3600)/60, 2);
+		}		
+	}
+	else str += "GMT";
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/DateTimeParser.cpp b/base/poco/Foundation/src/DateTimeParser.cpp
new file mode 100644
index 00000000000..b58482c7b33
--- /dev/null
+++ b/base/poco/Foundation/src/DateTimeParser.cpp
@@ -0,0 +1,393 @@
+//
+// DateTimeParser.cpp
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  DateTimeParser
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DateTimeParser.h"
+#include "Poco/DateTimeFormat.h"
+#include "Poco/DateTime.h"
+#include "Poco/Exception.h"
+#include "Poco/Ascii.h"
+
+
+namespace Poco {
+
+
+#define SKIP_JUNK() \
+	while (it != end && !Ascii::isDigit(*it)) ++it
+
+
+#define SKIP_DIGITS() \
+	while (it != end && Ascii::isDigit(*it)) ++it
+
+
+#define PARSE_NUMBER(var) \
+	while (it != end && Ascii::isDigit(*it)) var = var*10 + ((*it++) - '0')
+
+
+#define PARSE_NUMBER_N(var, n) \
+	{ int i = 0; while (i++ < n && it != end && Ascii::isDigit(*it)) var = var*10 + ((*it++) - '0'); }
+
+
+#define PARSE_FRACTIONAL_N(var, n) \
+	{ int i = 0; while (i < n && it != end && Ascii::isDigit(*it)) { var = var*10 + ((*it++) - '0'); i++; } while (i++ < n) var *= 10; }
+
+
+void DateTimeParser::parse(const std::string& fmt, const std::string& str, DateTime& dateTime, int& timeZoneDifferential)
+{
+	if (fmt.empty() || str.empty())
+		throw SyntaxException("Empty string.");
+
+	int year   = 0;
+	int month  = 0;
+	int day    = 0;
+	int hour   = 0;
+	int minute = 0;
+	int second = 0;
+	int millis = 0;
+	int micros = 0;
+	int tzd    = 0;
+
+	std::string::const_iterator it   = str.begin();
+	std::string::const_iterator end  = str.end();
+	std::string::const_iterator itf  = fmt.begin();
+	std::string::const_iterator endf = fmt.end();
+
+	while (itf != endf && it != end)
+	{
+		if (*itf == '%')
+		{
+			if (++itf != endf)
+			{
+				switch (*itf)
+				{
+				case 'w':
+				case 'W':
+					while (it != end && Ascii::isSpace(*it)) ++it;
+					while (it != end && Ascii::isAlpha(*it)) ++it;
+					break;
+				case 'b':
+				case 'B':
+					month = parseMonth(it, end);
+					break;
+				case 'd':
+				case 'e':
+				case 'f':
+					SKIP_JUNK();
+					PARSE_NUMBER_N(day, 2);
+					break;
+				case 'm':
+				case 'n':
+				case 'o':
+					SKIP_JUNK();
+					PARSE_NUMBER_N(month, 2);
+					break;					 
+				case 'y':
+					SKIP_JUNK();
+					PARSE_NUMBER_N(year, 2);
+					if (year >= 69) 
+						year += 1900;
+					else
+						year += 2000;
+					break;
+				case 'Y':
+					SKIP_JUNK();
+					PARSE_NUMBER_N(year, 4);
+					break;
+				case 'r':
+					SKIP_JUNK();
+					PARSE_NUMBER(year);
+					if (year < 1000)
+					{
+						if (year >= 69) 
+							year += 1900;
+						else
+							year += 2000;
+					}
+					break;
+				case 'H':
+				case 'h':
+					SKIP_JUNK();
+					PARSE_NUMBER_N(hour, 2);
+					break;
+				case 'a':
+				case 'A':
+					hour = parseAMPM(it, end, hour);
+					break;
+				case 'M':
+					SKIP_JUNK();
+					PARSE_NUMBER_N(minute, 2);
+					break;
+				case 'S':
+					SKIP_JUNK();
+					PARSE_NUMBER_N(second, 2);
+					break;
+				case 's':
+					SKIP_JUNK();
+					PARSE_NUMBER_N(second, 2);
+					if (it != end && (*it == '.' || *it == ','))
+					{
+						++it;
+						PARSE_FRACTIONAL_N(millis, 3);
+						PARSE_FRACTIONAL_N(micros, 3);
+						SKIP_DIGITS();
+					}
+					break;
+				case 'i':
+					SKIP_JUNK();
+					PARSE_NUMBER_N(millis, 3);
+					break;
+				case 'c':
+					SKIP_JUNK();
+					PARSE_NUMBER_N(millis, 1);
+					millis *= 100;
+					break;
+				case 'F':
+					SKIP_JUNK();
+					PARSE_FRACTIONAL_N(millis, 3);
+					PARSE_FRACTIONAL_N(micros, 3);
+					SKIP_DIGITS();
+					break;
+				case 'z':
+				case 'Z':
+					tzd = parseTZD(it, end);
+					break;
+				}
+				++itf;
+			}
+		}
+		else ++itf;
+	}
+	if (month == 0) month = 1;
+	if (day == 0) day = 1;
+	if (DateTime::isValid(year, month, day, hour, minute, second, millis, micros))
+		dateTime.assign(year, month, day, hour, minute, second, millis, micros);
+	else 
+		throw SyntaxException("date/time component out of range");
+	timeZoneDifferential = tzd;
+}
+
+
+DateTime DateTimeParser::parse(const std::string& fmt, const std::string& str, int& timeZoneDifferential)
+{
+	DateTime result;
+	parse(fmt, str, result, timeZoneDifferential);
+	return result;
+}
+
+	
+bool DateTimeParser::tryParse(const std::string& fmt, const std::string& str, DateTime& dateTime, int& timeZoneDifferential)
+{
+	try
+	{
+		parse(fmt, str, dateTime, timeZoneDifferential);
+	}
+	catch (Exception&)
+	{
+		return false;
+	}
+	return true;
+}
+
+
+void DateTimeParser::parse(const std::string& str, DateTime& dateTime, int& timeZoneDifferential)
+{
+	if (!tryParse(str, dateTime, timeZoneDifferential))
+		throw SyntaxException("Unsupported or invalid date/time format");
+}
+
+	
+DateTime DateTimeParser::parse(const std::string& str, int& timeZoneDifferential)
+{
+	DateTime result;
+	if (tryParse(str, result, timeZoneDifferential))
+		return result;
+	else
+		throw SyntaxException("Unsupported or invalid date/time format");
+}
+
+	
+bool DateTimeParser::tryParse(const std::string& str, DateTime& dateTime, int& timeZoneDifferential)
+{
+	if (str.length() < 4) return false;
+	
+	if (str[3] == ',')
+		return tryParse("%w, %e %b %r %H:%M:%S %Z", str, dateTime, timeZoneDifferential);
+	else if (str[3] == ' ')
+		return tryParse(DateTimeFormat::ASCTIME_FORMAT, str, dateTime, timeZoneDifferential);
+	else if (str.find(',') < 10)
+		return tryParse("%W, %e %b %r %H:%M:%S %Z", str, dateTime, timeZoneDifferential);
+	else if (Ascii::isDigit(str[0]))
+	{
+		if (str.find(' ') != std::string::npos || str.length() == 10)
+			return tryParse(DateTimeFormat::SORTABLE_FORMAT, str, dateTime, timeZoneDifferential);
+		else if (str.find('.') != std::string::npos || str.find(',') != std::string::npos)
+			return tryParse(DateTimeFormat::ISO8601_FRAC_FORMAT, str, dateTime, timeZoneDifferential);
+		else
+			return tryParse(DateTimeFormat::ISO8601_FORMAT, str, dateTime, timeZoneDifferential);
+	}
+	else return false;
+}
+
+
+int DateTimeParser::parseTZD(std::string::const_iterator& it, const std::string::const_iterator& end)
+{
+	struct Zone
+	{
+		const char* designator;
+		int         timeZoneDifferential;
+	};
+
+	static Zone zones[] =
+	{
+		{"Z",           0},
+		{"UT",          0},
+		{"GMT",         0},
+		{"BST",    1*3600},
+		{"IST",    1*3600},
+		{"WET",         0},
+		{"WEST",   1*3600},
+		{"CET",    1*3600},
+		{"CEST",   2*3600},
+		{"EET",    2*3600},
+		{"EEST",   3*3600},
+		{"MSK",    3*3600},
+		{"MSD",    4*3600},
+		{"NST",   -3*3600-1800},
+		{"NDT",   -2*3600-1800},
+		{"AST",   -4*3600},
+		{"ADT",   -3*3600},
+		{"EST",   -5*3600},
+		{"EDT",   -4*3600},
+		{"CST",   -6*3600},
+		{"CDT",   -5*3600},
+		{"MST",   -7*3600},
+		{"MDT",   -6*3600},
+		{"PST",   -8*3600},
+		{"PDT",   -7*3600},
+		{"AKST",  -9*3600},
+		{"AKDT",  -8*3600},
+		{"HST",  -10*3600},
+		{"AEST",  10*3600},
+		{"AEDT",  11*3600},
+		{"ACST",   9*3600+1800},
+		{"ACDT",  10*3600+1800},
+		{"AWST",   8*3600},
+		{"AWDT",   9*3600}
+	};
+
+	int tzd = 0;
+	while (it != end && Ascii::isSpace(*it)) ++it;
+	if (it != end)
+	{
+		if (Ascii::isAlpha(*it))
+		{
+			std::string designator;
+			designator += *it++;
+			if (it != end && Ascii::isAlpha(*it)) designator += *it++;
+			if (it != end && Ascii::isAlpha(*it)) designator += *it++;
+			if (it != end && Ascii::isAlpha(*it)) designator += *it++;
+			for (unsigned i = 0; i < sizeof(zones)/sizeof(Zone); ++i)
+			{
+				if (designator == zones[i].designator)
+				{
+					tzd = zones[i].timeZoneDifferential;
+					break;
+				}
+			}
+		}
+		if (it != end && (*it == '+' || *it == '-'))
+		{
+			int sign = *it == '+' ? 1 : -1;
+			++it;
+			int hours = 0;
+			PARSE_NUMBER_N(hours, 2);
+			if (it != end && *it == ':') ++it;
+			int minutes = 0;
+			PARSE_NUMBER_N(minutes, 2);
+			tzd += sign*(hours*3600 + minutes*60);
+		}
+	}
+	return tzd;
+}
+
+
+int DateTimeParser::parseMonth(std::string::const_iterator& it, const std::string::const_iterator& end)
+{
+	std::string month;
+	while (it != end && (Ascii::isSpace(*it) || Ascii::isPunct(*it))) ++it;
+	bool isFirst = true;
+	while (it != end && Ascii::isAlpha(*it)) 
+	{
+		char ch = (*it++);
+		if (isFirst) { month += Ascii::toUpper(ch); isFirst = false; }
+		else month += Ascii::toLower(ch);
+	}
+	if (month.length() < 3) throw SyntaxException("Month name must be at least three characters long", month);
+	for (int i = 0; i < 12; ++i) 
+	{
+		if (DateTimeFormat::MONTH_NAMES[i].find(month) == 0)
+			return i + 1;
+	}
+	throw SyntaxException("Not a valid month name", month);
+}
+
+
+int DateTimeParser::parseDayOfWeek(std::string::const_iterator& it, const std::string::const_iterator& end)
+{
+	std::string dow;
+	while (it != end && (Ascii::isSpace(*it) || Ascii::isPunct(*it))) ++it;
+	bool isFirst = true;
+	while (it != end && Ascii::isAlpha(*it)) 
+	{
+		char ch = (*it++);
+		if (isFirst) { dow += Ascii::toUpper(ch); isFirst = false; }
+		else dow += Ascii::toLower(ch);
+	}
+	if (dow.length() < 3) throw SyntaxException("Weekday name must be at least three characters long", dow);
+	for (int i = 0; i < 7; ++i) 
+	{
+		if (DateTimeFormat::WEEKDAY_NAMES[i].find(dow) == 0)
+			return i;
+	}
+	throw SyntaxException("Not a valid weekday name", dow);
+}
+
+
+int DateTimeParser::parseAMPM(std::string::const_iterator& it, const std::string::const_iterator& end, int hour)
+{
+	std::string ampm;
+	while (it != end && (Ascii::isSpace(*it) || Ascii::isPunct(*it))) ++it;
+	while (it != end && Ascii::isAlpha(*it)) 
+	{
+		char ch = (*it++);
+		ampm += Ascii::toUpper(ch);
+	}
+	if (ampm == "AM")
+	{
+		if (hour == 12)
+			return 0;
+		else
+			return hour;
+	}
+	else if (ampm == "PM")
+	{
+		if (hour < 12)
+			return hour + 12;
+		else
+			return hour;
+	}
+	else throw SyntaxException("Not a valid AM/PM designator", ampm);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Debugger.cpp b/base/poco/Foundation/src/Debugger.cpp
new file mode 100644
index 00000000000..c9efe5eac1f
--- /dev/null
+++ b/base/poco/Foundation/src/Debugger.cpp
@@ -0,0 +1,150 @@
+//
+// Debugger.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  Debugger
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Debugger.h"
+#include <sstream>
+#include <cstdlib>
+#include <cstdio>
+#if defined(POCO_OS_FAMILY_WINDOWS)
+	#include "Poco/UnWindows.h"
+#elif defined(POCO_OS_FAMILY_UNIX) && !defined(POCO_VXWORKS)
+	#include <unistd.h>
+	#include <signal.h>
+#endif
+#if defined(POCO_WIN32_UTF8) && !defined(POCO_NO_WSTRING)
+#include "Poco/UnicodeConverter.h"
+#endif
+
+
+// NOTE: In this module, we use the C library functions (fputs) for,
+// output since, at the time we're called, the C++ iostream objects std::cout, etc.
+// might not have been initialized yet.
+
+
+namespace Poco {
+
+
+bool Debugger::isAvailable()
+{
+#if defined(_DEBUG)
+	#if defined(POCO_OS_FAMILY_WINDOWS)
+		#if defined(_WIN32_WCE)
+			#if (_WIN32_WCE >= 0x600)
+				BOOL isDebuggerPresent;
+				if (CheckRemoteDebuggerPresent(GetCurrentProcess(), &isDebuggerPresent))
+				{
+					return isDebuggerPresent ? true : false;
+				}
+				return false;
+			#else
+				return false;
+			#endif
+		#else
+			return IsDebuggerPresent() ? true : false;
+		#endif
+	#elif defined(POCO_VXWORKS)
+		return false;
+	#elif defined(POCO_OS_FAMILY_UNIX)
+		return std::getenv("POCO_ENABLE_DEBUGGER") ? true : false;
+	#endif
+#else
+	return false;
+#endif
+}
+
+
+void Debugger::message(const std::string& msg)
+{
+#if defined(_DEBUG)
+	std::fputs("\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", stderr);
+	std::fputs(msg.c_str(), stderr);
+	std::fputs("\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n", stderr);
+	#if defined(POCO_OS_FAMILY_WINDOWS)
+	if (isAvailable())
+	{
+		#if defined(POCO_WIN32_UTF8) && !defined(POCO_NO_WSTRING)
+		std::wstring umsg;
+		UnicodeConverter::toUTF16(msg, umsg);
+		umsg += '\n';
+		OutputDebugStringW(umsg.c_str());
+		#else
+		OutputDebugStringA(msg.c_str());
+		OutputDebugStringA("\n");
+		#endif
+	}
+	#endif
+#endif
+}
+
+
+void Debugger::message(const std::string& msg, const char* file, int line)
+{
+#if defined(_DEBUG)
+	std::ostringstream str;
+	str << msg << " [in file \"" << file << "\", line " << line << "]";
+	message(str.str());
+#endif
+}
+
+
+void Debugger::enter()
+{
+#if defined(_DEBUG)
+	#if defined(POCO_OS_FAMILY_WINDOWS)
+	if (isAvailable())
+	{
+		DebugBreak();
+	}
+	#elif defined(POCO_VXWORKS)
+	{
+		// not supported
+	}
+	#elif defined(POCO_OS_FAMILY_UNIX)
+	if (isAvailable())
+	{
+		kill(getpid(), SIGINT);
+	}
+	#endif
+#endif
+}
+
+
+void Debugger::enter(const std::string& msg)
+{
+#if defined(_DEBUG)
+	message(msg);
+	enter();
+#endif
+}
+
+
+void Debugger::enter(const std::string& msg, const char* file, int line)
+{
+#if defined(_DEBUG)
+	message(msg, file, line);
+	enter();
+#endif
+}
+
+
+void Debugger::enter(const char* file, int line)
+{
+#if defined(_DEBUG)
+	message("BREAK", file, line);
+	enter();
+#endif
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/DeflatingStream.cpp b/base/poco/Foundation/src/DeflatingStream.cpp
new file mode 100644
index 00000000000..7349118354d
--- /dev/null
+++ b/base/poco/Foundation/src/DeflatingStream.cpp
@@ -0,0 +1,390 @@
+//
+// DeflatingStream.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  ZLibStream
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DeflatingStream.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+
+DeflatingStreamBuf::DeflatingStreamBuf(std::istream& istr, StreamType type, int level):
+	BufferedStreamBuf(STREAM_BUFFER_SIZE, std::ios::in),
+	_pIstr(&istr),
+	_pOstr(0),
+	_eof(false)
+{
+	_zstr.next_in   = 0;
+	_zstr.avail_in  = 0;
+	_zstr.total_in  = 0;
+	_zstr.next_out  = 0;
+	_zstr.avail_out = 0;
+	_zstr.total_out = 0;
+	_zstr.msg       = 0;
+	_zstr.state     = 0;
+	_zstr.zalloc    = Z_NULL;
+	_zstr.zfree     = Z_NULL;
+	_zstr.opaque    = Z_NULL;
+	_zstr.data_type = 0;
+	_zstr.adler     = 0;
+	_zstr.reserved  = 0;
+
+	_buffer = new char[DEFLATE_BUFFER_SIZE];
+
+	int rc = deflateInit2(&_zstr, level, Z_DEFLATED, 15 + (type == STREAM_GZIP ? 16 : 0), 8, Z_DEFAULT_STRATEGY);
+	if (rc != Z_OK)
+	{
+		delete [] _buffer;
+		throw IOException(zError(rc));
+	}
+}
+
+
+DeflatingStreamBuf::DeflatingStreamBuf(std::istream& istr, int windowBits, int level):
+	BufferedStreamBuf(STREAM_BUFFER_SIZE, std::ios::in),
+	_pIstr(&istr),
+	_pOstr(0),
+	_eof(false)
+{
+	_zstr.zalloc    = Z_NULL;
+	_zstr.zfree     = Z_NULL;
+	_zstr.opaque    = Z_NULL;
+	_zstr.next_in   = 0;
+	_zstr.avail_in  = 0;
+	_zstr.next_out  = 0;
+	_zstr.avail_out = 0;
+
+	_buffer = new char[DEFLATE_BUFFER_SIZE];
+
+	int rc = deflateInit2(&_zstr, level, Z_DEFLATED, windowBits, 8, Z_DEFAULT_STRATEGY);
+	if (rc != Z_OK)
+	{
+		delete [] _buffer;
+		throw IOException(zError(rc));
+	}
+}
+
+
+DeflatingStreamBuf::DeflatingStreamBuf(std::ostream& ostr, StreamType type, int level):
+	BufferedStreamBuf(STREAM_BUFFER_SIZE, std::ios::out),
+	_pIstr(0),
+	_pOstr(&ostr),
+	_eof(false)
+{
+	_zstr.zalloc    = Z_NULL;
+	_zstr.zfree     = Z_NULL;
+	_zstr.opaque    = Z_NULL;
+	_zstr.next_in   = 0;
+	_zstr.avail_in  = 0;
+	_zstr.next_out  = 0;
+	_zstr.avail_out = 0;
+
+	_buffer = new char[DEFLATE_BUFFER_SIZE];
+
+	int rc = deflateInit2(&_zstr, level, Z_DEFLATED, 15 + (type == STREAM_GZIP ? 16 : 0), 8, Z_DEFAULT_STRATEGY);
+	if (rc != Z_OK)
+	{
+		delete [] _buffer;
+		throw IOException(zError(rc));
+	}
+}
+
+
+DeflatingStreamBuf::DeflatingStreamBuf(std::ostream& ostr, int windowBits, int level):
+	BufferedStreamBuf(STREAM_BUFFER_SIZE, std::ios::out),
+	_pIstr(0),
+	_pOstr(&ostr),
+	_eof(false)
+{
+	_zstr.zalloc    = Z_NULL;
+	_zstr.zfree     = Z_NULL;
+	_zstr.opaque    = Z_NULL;
+	_zstr.next_in   = 0;
+	_zstr.avail_in  = 0;
+	_zstr.next_out  = 0;
+	_zstr.avail_out = 0;
+
+	_buffer = new char[DEFLATE_BUFFER_SIZE];
+
+	int rc = deflateInit2(&_zstr, level, Z_DEFLATED, windowBits, 8, Z_DEFAULT_STRATEGY);
+	if (rc != Z_OK)
+	{
+		delete [] _buffer;
+		throw IOException(zError(rc));
+	}
+}
+
+
+DeflatingStreamBuf::~DeflatingStreamBuf()
+{
+	try
+	{
+		close();
+	}
+	catch (...)
+	{
+	}
+	delete [] _buffer;
+	deflateEnd(&_zstr);
+}
+
+
+int DeflatingStreamBuf::close()
+{
+	BufferedStreamBuf::sync();
+	_pIstr = 0;
+	if (_pOstr)
+	{
+		if (_zstr.next_out)
+		{
+			int rc = deflate(&_zstr, Z_FINISH);
+			if (rc != Z_OK && rc != Z_STREAM_END) throw IOException(zError(rc));
+			_pOstr->write(_buffer, DEFLATE_BUFFER_SIZE - _zstr.avail_out);
+			if (!_pOstr->good()) throw IOException(zError(rc));
+			_zstr.next_out  = (unsigned char*) _buffer;
+			_zstr.avail_out = DEFLATE_BUFFER_SIZE;
+			while (rc != Z_STREAM_END)
+			{
+				rc = deflate(&_zstr, Z_FINISH);
+				if (rc != Z_OK && rc != Z_STREAM_END) throw IOException(zError(rc));
+				_pOstr->write(_buffer, DEFLATE_BUFFER_SIZE - _zstr.avail_out);
+				if (!_pOstr->good()) throw IOException(zError(rc));
+				_zstr.next_out  = (unsigned char*) _buffer;
+				_zstr.avail_out = DEFLATE_BUFFER_SIZE;
+			}
+		}
+		_pOstr->flush();
+		_pOstr = 0;
+	}
+	return 0;
+}
+
+
+int DeflatingStreamBuf::sync()
+{
+	if (BufferedStreamBuf::sync())
+		return -1;
+
+	if (_pOstr)
+	{
+		if (_zstr.next_out)
+		{
+			int rc = deflate(&_zstr, Z_SYNC_FLUSH);
+			if (rc != Z_OK) throw IOException(zError(rc));
+			_pOstr->write(_buffer, DEFLATE_BUFFER_SIZE - _zstr.avail_out);
+			if (!_pOstr->good()) throw IOException(zError(rc));
+			while (_zstr.avail_out == 0)
+			{
+				_zstr.next_out  = (unsigned char*) _buffer;
+				_zstr.avail_out = DEFLATE_BUFFER_SIZE;
+				rc = deflate(&_zstr, Z_SYNC_FLUSH);
+				if (rc != Z_OK) throw IOException(zError(rc));
+				_pOstr->write(_buffer, DEFLATE_BUFFER_SIZE - _zstr.avail_out);
+				if (!_pOstr->good()) throw IOException(zError(rc));
+			};
+			_zstr.next_out  = (unsigned char*) _buffer;
+			_zstr.avail_out = DEFLATE_BUFFER_SIZE;
+		}
+		// NOTE: This breaks the Zip library and causes corruption in some files.
+		// See GH #1828
+		// _pOstr->flush();
+	}
+	return 0;
+}
+
+
+int DeflatingStreamBuf::readFromDevice(char* buffer, std::streamsize length)
+{
+	if (!_pIstr) return 0;
+	if (_zstr.avail_in == 0 && !_eof)
+	{
+		int n = 0;
+		if (_pIstr->good())
+		{
+			_pIstr->read(_buffer, DEFLATE_BUFFER_SIZE);
+			n = static_cast<int>(_pIstr->gcount());
+		}
+		if (n > 0)
+		{
+			_zstr.next_in  = (unsigned char*) _buffer;
+			_zstr.avail_in = n;
+		}
+		else
+		{
+			_zstr.next_in  = 0;
+			_zstr.avail_in = 0;
+			_eof = true;
+		}
+	}
+	_zstr.next_out  = (unsigned char*) buffer;
+	_zstr.avail_out = static_cast<unsigned>(length);
+	for (;;)
+	{
+		int rc = deflate(&_zstr, _eof ? Z_FINISH : Z_NO_FLUSH);
+		if (_eof && rc == Z_STREAM_END)
+		{
+			_pIstr = 0;
+			return static_cast<int>(length) - _zstr.avail_out;
+		}
+		if (rc != Z_OK) throw IOException(zError(rc));
+		if (_zstr.avail_out == 0)
+		{
+			return static_cast<int>(length);
+		}
+		if (_zstr.avail_in == 0)
+		{
+			int n = 0;
+			if (_pIstr->good())
+			{
+				_pIstr->read(_buffer, DEFLATE_BUFFER_SIZE);
+				n = static_cast<int>(_pIstr->gcount());
+			}
+			if (n > 0)
+			{
+				_zstr.next_in  = (unsigned char*) _buffer;
+				_zstr.avail_in = n;
+			}
+			else
+			{
+				_zstr.next_in  = 0;
+				_zstr.avail_in = 0;
+				_eof = true;
+			}
+		}
+	}
+}
+
+
+int DeflatingStreamBuf::writeToDevice(const char* buffer, std::streamsize length)
+{
+	if (length == 0 || !_pOstr) return 0;
+
+	_zstr.next_in   = (unsigned char*) buffer;
+	_zstr.avail_in  = static_cast<unsigned>(length);
+	_zstr.next_out  = (unsigned char*) _buffer;
+	_zstr.avail_out = DEFLATE_BUFFER_SIZE;
+	for (;;)
+	{
+		int rc = deflate(&_zstr, Z_NO_FLUSH);
+		if (rc != Z_OK) throw IOException(zError(rc));
+		if (_zstr.avail_out == 0)
+		{
+			_pOstr->write(_buffer, DEFLATE_BUFFER_SIZE);
+			if (!_pOstr->good()) throw IOException(zError(rc));
+			_zstr.next_out  = (unsigned char*) _buffer;
+			_zstr.avail_out = DEFLATE_BUFFER_SIZE;
+		}
+		if (_zstr.avail_in == 0)
+		{
+			_pOstr->write(_buffer, DEFLATE_BUFFER_SIZE - _zstr.avail_out);
+			if (!_pOstr->good()) throw IOException(zError(rc));
+			_zstr.next_out  = (unsigned char*) _buffer;
+			_zstr.avail_out = DEFLATE_BUFFER_SIZE;
+			break;
+		}
+	}
+	return static_cast<int>(length);
+}
+
+
+DeflatingIOS::DeflatingIOS(std::ostream& ostr, DeflatingStreamBuf::StreamType type, int level):
+	_buf(ostr, type, level)
+{
+	poco_ios_init(&_buf);
+}
+
+
+DeflatingIOS::DeflatingIOS(std::ostream& ostr, int windowBits, int level):
+	_buf(ostr, windowBits, level)
+{
+	poco_ios_init(&_buf);
+}
+
+
+DeflatingIOS::DeflatingIOS(std::istream& istr, DeflatingStreamBuf::StreamType type, int level):
+	_buf(istr, type, level)
+{
+	poco_ios_init(&_buf);
+}
+
+
+DeflatingIOS::DeflatingIOS(std::istream& istr, int windowBits, int level):
+	_buf(istr, windowBits, level)
+{
+	poco_ios_init(&_buf);
+}
+
+
+DeflatingIOS::~DeflatingIOS()
+{
+}
+
+
+DeflatingStreamBuf* DeflatingIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+DeflatingOutputStream::DeflatingOutputStream(std::ostream& ostr, DeflatingStreamBuf::StreamType type, int level):
+	std::ostream(&_buf),
+	DeflatingIOS(ostr, type, level)
+{
+}
+
+
+DeflatingOutputStream::DeflatingOutputStream(std::ostream& ostr, int windowBits, int level):
+	std::ostream(&_buf),
+	DeflatingIOS(ostr, windowBits, level)
+{
+}
+
+
+DeflatingOutputStream::~DeflatingOutputStream()
+{
+}
+
+
+int DeflatingOutputStream::close()
+{
+	return _buf.close();
+}
+
+
+int DeflatingOutputStream::sync()
+{
+	return _buf.pubsync();
+}
+
+
+DeflatingInputStream::DeflatingInputStream(std::istream& istr, DeflatingStreamBuf::StreamType type, int level):
+	std::istream(&_buf),
+	DeflatingIOS(istr, type, level)
+{
+}
+
+
+DeflatingInputStream::DeflatingInputStream(std::istream& istr, int windowBits, int level):
+	std::istream(&_buf),
+	DeflatingIOS(istr, windowBits, level)
+{
+}
+
+
+DeflatingInputStream::~DeflatingInputStream()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/DigestEngine.cpp b/base/poco/Foundation/src/DigestEngine.cpp
new file mode 100644
index 00000000000..2c01eb6b871
--- /dev/null
+++ b/base/poco/Foundation/src/DigestEngine.cpp
@@ -0,0 +1,99 @@
+//
+// DigestEngine.cpp
+//
+// Library: Foundation
+// Package: Crypt
+// Module:  DigestEngine
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DigestEngine.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco
+{
+
+DigestEngine::DigestEngine()
+{
+}
+
+
+DigestEngine::~DigestEngine()
+{
+}
+
+
+std::string DigestEngine::digestToHex(const Digest& bytes)
+{
+	static const char digits[] = "0123456789abcdef";
+	std::string result;
+	result.reserve(bytes.size() * 2);
+	for (Digest::const_iterator it = bytes.begin(); it != bytes.end(); ++it)
+	{
+		unsigned char c = *it;
+		result += digits[(c >> 4) & 0xF];
+		result += digits[c & 0xF];
+	}
+	return result;
+}
+
+
+DigestEngine::Digest DigestEngine::digestFromHex(const std::string& digest)
+{
+	if (digest.size() % 2 != 0)
+		throw DataFormatException();
+	Digest result;
+	result.reserve(digest.size() / 2);
+	for (std::size_t i = 0; i < digest.size(); ++i)
+	{
+		int c = 0;
+		// first upper 4 bits
+		if (digest[i] >= '0' && digest[i] <= '9')
+			c = digest[i] - '0';
+		else if (digest[i] >= 'a' && digest[i] <= 'f')
+			c = digest[i] - 'a' + 10;
+		else if (digest[i] >= 'A' && digest[i] <= 'F')
+			c = digest[i] - 'A' + 10;
+		else
+			throw DataFormatException();
+		c <<= 4;
+		++i;
+		if (digest[i] >= '0' && digest[i] <= '9')
+			c += digest[i] - '0';
+		else if (digest[i] >= 'a' && digest[i] <= 'f')
+			c += digest[i] - 'a' + 10;
+		else if (digest[i] >= 'A' && digest[i] <= 'F')
+			c += digest[i] - 'A' + 10;
+		else
+			throw DataFormatException();
+
+		result.push_back(static_cast<unsigned char>(c));
+	}
+	return result;
+}
+
+
+bool DigestEngine::constantTimeEquals(const Digest& d1, const Digest& d2)
+{
+	if (d1.size() != d2.size()) return false;
+
+	int result = 0;
+	Digest::const_iterator it1 = d1.begin();
+	Digest::const_iterator it2 = d2.begin();
+	Digest::const_iterator end1 = d1.end();
+	while (it1 != end1)
+	{
+		result |= *it1++ ^ *it2++;
+	}
+	return result == 0;
+}
+
+
+} // namespace Poco
+
diff --git a/base/poco/Foundation/src/DigestStream.cpp b/base/poco/Foundation/src/DigestStream.cpp
new file mode 100644
index 00000000000..c5ec7b23bc7
--- /dev/null
+++ b/base/poco/Foundation/src/DigestStream.cpp
@@ -0,0 +1,150 @@
+//
+// DigestStream.cpp
+//
+// Library: Foundation
+// Package: Crypt
+// Module:  DigestStream
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DigestStream.h"
+
+
+namespace Poco {
+
+
+const int DigestBuf::BUFFER_SIZE = 256;
+
+
+DigestBuf::DigestBuf(DigestEngine& eng): 
+	BufferedStreamBuf(BUFFER_SIZE, std::ios::out), 
+	_eng(eng), 
+	_pIstr(0),
+	_pOstr(0) 
+{
+}
+
+
+DigestBuf::DigestBuf(DigestEngine& eng, std::istream& istr): 
+	BufferedStreamBuf(BUFFER_SIZE, std::ios::in), 
+	_eng(eng), 
+	_pIstr(&istr), 
+	_pOstr(0)
+{
+}
+
+
+DigestBuf::DigestBuf(DigestEngine& eng, std::ostream& ostr): 
+	BufferedStreamBuf(BUFFER_SIZE, std::ios::out), 
+	_eng(eng), 
+	_pIstr(0), 
+	_pOstr(&ostr)
+{
+}
+
+
+DigestBuf::~DigestBuf()
+{
+}
+
+
+int DigestBuf::readFromDevice(char* buffer, std::streamsize length)
+{
+	if (_pIstr && _pIstr->good())
+	{
+		_pIstr->read(buffer, length);
+		std::streamsize n = _pIstr->gcount();
+		if (n > 0) _eng.update(buffer, static_cast<unsigned>(n));
+		return static_cast<int>(n);
+	}
+	return -1;
+}
+
+
+int DigestBuf::writeToDevice(const char* buffer, std::streamsize length)
+{
+	_eng.update(buffer, (unsigned) length);
+	if (_pOstr) _pOstr->write(buffer, length);
+	return static_cast<int>(length);
+}
+
+
+void DigestBuf::close()
+{
+	sync();
+	if (_pOstr) _pOstr->flush();
+}
+
+
+DigestIOS::DigestIOS(DigestEngine& eng): _buf(eng)
+{
+	poco_ios_init(&_buf);
+}
+
+
+DigestIOS::DigestIOS(DigestEngine& eng, std::istream& istr): _buf(eng, istr)
+{
+	poco_ios_init(&_buf);
+}
+
+
+DigestIOS::DigestIOS(DigestEngine& eng, std::ostream& ostr): _buf(eng, ostr)
+{
+	poco_ios_init(&_buf);
+}
+
+
+DigestIOS::~DigestIOS()
+{
+}
+
+
+DigestBuf* DigestIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+DigestInputStream::DigestInputStream(DigestEngine& eng, std::istream& istr): 
+	DigestIOS(eng, istr), 
+	std::istream(&_buf)
+{
+}
+
+
+DigestInputStream::~DigestInputStream()
+{
+}
+
+
+DigestOutputStream::DigestOutputStream(DigestEngine& eng): 
+	DigestIOS(eng), 
+	std::ostream(&_buf)
+{
+}
+
+
+DigestOutputStream::DigestOutputStream(DigestEngine& eng, std::ostream& ostr): 
+	DigestIOS(eng, ostr), 
+	std::ostream(&_buf)
+{
+}
+
+
+DigestOutputStream::~DigestOutputStream()
+{
+}
+
+
+void DigestOutputStream::close()
+{
+	_buf.close();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/DirectoryIterator.cpp b/base/poco/Foundation/src/DirectoryIterator.cpp
new file mode 100644
index 00000000000..28d29e0d2d7
--- /dev/null
+++ b/base/poco/Foundation/src/DirectoryIterator.cpp
@@ -0,0 +1,145 @@
+//
+// DirectoryIterator.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  DirectoryIterator
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DirectoryIterator.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS) && defined(POCO_WIN32_UTF8)
+#include "DirectoryIterator_WIN32U.cpp"
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "DirectoryIterator_WIN32.cpp"
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include "DirectoryIterator_UNIX.cpp"
+#endif
+
+
+namespace Poco {
+
+
+DirectoryIterator::DirectoryIterator(): _pImpl(0)
+{
+}
+
+
+DirectoryIterator::DirectoryIterator(const std::string& path): _path(path), _pImpl(new DirectoryIteratorImpl(path))
+{
+	_path.makeDirectory();
+	_path.setFileName(_pImpl->get());
+	_file = _path;
+}
+
+
+DirectoryIterator::DirectoryIterator(const DirectoryIterator& iterator): _path(iterator._path), _pImpl(iterator._pImpl)
+{
+	if (_pImpl)
+	{
+		_pImpl->duplicate();
+		_file = _path;
+	}
+}
+
+
+DirectoryIterator::DirectoryIterator(const File& file): _path(file.path()), _pImpl(new DirectoryIteratorImpl(file.path()))
+{
+	_path.makeDirectory();
+	_path.setFileName(_pImpl->get());
+	_file = _path;
+}
+
+
+DirectoryIterator::DirectoryIterator(const Path& path): _path(path), _pImpl(new DirectoryIteratorImpl(path.toString()))
+{
+	_path.makeDirectory();
+	_path.setFileName(_pImpl->get());
+	_file = _path;
+}
+
+
+DirectoryIterator::~DirectoryIterator()
+{
+	if (_pImpl) _pImpl->release();
+}
+
+
+DirectoryIterator& DirectoryIterator::operator = (const DirectoryIterator& it)
+{
+	if (_pImpl) _pImpl->release();
+	_pImpl = it._pImpl;
+	if (_pImpl)
+	{
+		_pImpl->duplicate();
+		_path = it._path;
+		_file = _path;
+	}
+	return *this;
+}
+
+
+DirectoryIterator& DirectoryIterator::operator = (const File& file)
+{
+	if (_pImpl) _pImpl->release();
+	_pImpl = new DirectoryIteratorImpl(file.path());
+	_path.parseDirectory(file.path());
+	_path.setFileName(_pImpl->get());
+	_file = _path;
+	return *this;
+}
+
+
+DirectoryIterator& DirectoryIterator::operator = (const Path& path)
+{
+	if (_pImpl) _pImpl->release();
+	_pImpl = new DirectoryIteratorImpl(path.toString());
+	_path = path;
+	_path.makeDirectory();
+	_path.setFileName(_pImpl->get());
+	_file = _path;
+	return *this;
+}
+
+
+DirectoryIterator& DirectoryIterator::operator = (const std::string& path)
+{
+	if (_pImpl) _pImpl->release();
+	_pImpl = new DirectoryIteratorImpl(path);
+	_path.parseDirectory(path);
+	_path.setFileName(_pImpl->get());
+	_file = _path;
+	return *this;
+}
+
+
+DirectoryIterator& DirectoryIterator::operator ++ ()
+{
+	if (_pImpl)
+	{
+		_path.setFileName(_pImpl->next());
+		_file = _path;
+	}
+	return *this;
+}
+
+
+DirectoryIterator DirectoryIterator::operator ++ (int dummy)
+{
+	if (_pImpl)
+	{
+		_path.setFileName(_pImpl->next());
+		_file = _path;
+	}
+	return *this;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/DirectoryIteratorStrategy.cpp b/base/poco/Foundation/src/DirectoryIteratorStrategy.cpp
new file mode 100644
index 00000000000..21c9755bb4b
--- /dev/null
+++ b/base/poco/Foundation/src/DirectoryIteratorStrategy.cpp
@@ -0,0 +1,168 @@
+//
+// RecursiveDirectoryIteratorStategies.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  RecursiveDirectoryIterator
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DirectoryIteratorStrategy.h"
+
+
+namespace Poco {
+
+
+//
+// TraverseBase
+//
+TraverseBase::TraverseBase(DepthFunPtr depthDeterminer, UInt16 maxDepth)
+	: _depthDeterminer(depthDeterminer), _maxDepth(maxDepth)
+{
+}
+
+
+inline bool TraverseBase::isFiniteDepth()
+{
+	return _maxDepth != D_INFINITE;
+}
+
+
+bool TraverseBase::isDirectory(Poco::File& file)
+{
+	try
+	{
+		return file.isDirectory();
+	}
+	catch (...)
+	{
+		return false;
+	}
+}
+
+
+//
+// ChildrenFirstTraverse
+//
+ChildrenFirstTraverse::ChildrenFirstTraverse(DepthFunPtr depthDeterminer, UInt16 maxDepth)
+	: TraverseBase(depthDeterminer, maxDepth)
+{
+}
+
+
+const std::string ChildrenFirstTraverse::next(Stack* itStack, bool* isFinished)
+{
+	// pointer mustn't point to NULL and iteration mustn't be finished
+	poco_check_ptr(isFinished);
+	poco_assert(!(*isFinished));
+
+	std::stack<DirectoryIterator> it;
+
+	//_depthDeterminer(it);
+
+	// go deeper into not empty directory
+	// (if depth limit allows)
+	bool isDepthLimitReached = isFiniteDepth() && _depthDeterminer(*itStack) >= _maxDepth;
+	if (!isDepthLimitReached && isDirectory(*itStack->top()))
+	{
+		DirectoryIterator child_it(itStack->top().path());
+		// check if directory is empty
+		if (child_it != _itEnd)
+		{
+			itStack->push(child_it);
+			return child_it->path();
+		}
+	}
+
+	++(itStack->top());
+
+	poco_assert(!itStack->empty());
+	// return up until there isn't right sibling
+	while (itStack->top() == _itEnd)
+	{
+		itStack->pop();
+
+		// detect end of traversal
+		if (itStack->empty())
+		{
+			*isFinished = true;
+			return _itEnd->path();
+		}
+		else
+		{
+			++(itStack->top());
+		}
+	}
+
+	return itStack->top()->path();
+}
+
+
+//
+// SiblingsFirstTraverse
+//
+SiblingsFirstTraverse::SiblingsFirstTraverse(DepthFunPtr depthDeterminer, UInt16 maxDepth)
+	: TraverseBase(depthDeterminer, maxDepth)
+{
+	_dirsStack.push(std::queue<std::string>());
+}
+
+
+const std::string SiblingsFirstTraverse::next(Stack* itStack, bool* isFinished)
+{
+	// pointer mustn't point to NULL and iteration mustn't be finished
+	poco_check_ptr(isFinished);
+	poco_assert(!(*isFinished));
+
+	// add dirs to queue (if depth limit allows)
+	bool isDepthLimitReached = isFiniteDepth() && _depthDeterminer(*itStack) >= _maxDepth;
+	if (!isDepthLimitReached && isDirectory(*itStack->top()))
+	{
+		const std::string& p = itStack->top()->path();
+		_dirsStack.top().push(p);
+	}
+
+	++(itStack->top());
+
+	poco_assert(!itStack->empty());
+	// return up until there isn't right sibling
+	while (itStack->top() == _itEnd)
+	{
+		// try to find first not empty directory and go deeper
+		while (!_dirsStack.top().empty())
+		{
+			std::string dir = _dirsStack.top().front();
+			_dirsStack.top().pop();
+			DirectoryIterator child_it(dir);
+
+			// check if directory is empty
+			if (child_it != _itEnd)
+			{
+				itStack->push(child_it);
+				_dirsStack.push(std::queue<std::string>());
+				return child_it->path();
+			}
+		}
+
+		// if fail go upper
+		itStack->pop();
+		_dirsStack.pop();
+
+		// detect end of traversal
+		if (itStack->empty())
+		{
+			*isFinished = true;
+			return _itEnd->path();
+		}
+	}
+
+	return itStack->top()->path();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/DirectoryIterator_UNIX.cpp b/base/poco/Foundation/src/DirectoryIterator_UNIX.cpp
new file mode 100644
index 00000000000..16be5051eab
--- /dev/null
+++ b/base/poco/Foundation/src/DirectoryIterator_UNIX.cpp
@@ -0,0 +1,64 @@
+//
+// DirectoryIterator_UNIX.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  DirectoryIterator
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DirectoryIterator_UNIX.h"
+#if defined(POCO_VXWORKS)
+#include "Poco/File_VX.h"
+#else
+#include "Poco/File_UNIX.h"
+#endif
+#include "Poco/Path.h"
+
+
+namespace Poco {
+
+
+DirectoryIteratorImpl::DirectoryIteratorImpl(const std::string& path): _pDir(0), _rc(1)
+{
+	Path p(path);
+	p.makeFile();
+
+#if defined(POCO_VXWORKS)
+	_pDir = opendir(const_cast<char*>(p.toString().c_str()));
+#else
+	_pDir = opendir(p.toString().c_str());
+#endif
+	if (!_pDir) File::handleLastError(path);
+
+	next();
+}
+
+
+DirectoryIteratorImpl::~DirectoryIteratorImpl()
+{
+	if (_pDir) closedir(_pDir);
+}
+
+
+const std::string& DirectoryIteratorImpl::next()
+{
+	do
+	{
+		struct dirent* pEntry = readdir(_pDir);
+		if (pEntry)
+			_current = pEntry->d_name;
+		else
+			_current.clear();
+	}
+	while (_current == "." || _current == "..");
+	return _current;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/DirectoryIterator_WIN32.cpp b/base/poco/Foundation/src/DirectoryIterator_WIN32.cpp
new file mode 100644
index 00000000000..e7ebfc859b0
--- /dev/null
+++ b/base/poco/Foundation/src/DirectoryIterator_WIN32.cpp
@@ -0,0 +1,66 @@
+//
+// DirectoryIterator_WIN32.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  DirectoryIterator
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DirectoryIterator_WIN32.h"
+#include "Poco/File_WIN32.h"
+#include "Poco/Path.h"
+
+
+namespace Poco {
+
+
+DirectoryIteratorImpl::DirectoryIteratorImpl(const std::string& path): _fh(INVALID_HANDLE_VALUE), _rc(1)
+{
+	Path p(path);
+	p.makeDirectory();
+	std::string findPath = p.toString();
+	findPath.append("*");
+
+	_fh = FindFirstFile(findPath.c_str(), &_fd);
+	if (_fh == INVALID_HANDLE_VALUE)
+	{
+		if (GetLastError() != ERROR_NO_MORE_FILES)
+			File::handleLastError(path);
+	}
+	else
+	{
+		_current = _fd.cFileName;
+		if (_current == "." || _current == "..")	
+			next();
+	}
+}
+
+
+DirectoryIteratorImpl::~DirectoryIteratorImpl()
+{
+	if (_fh != INVALID_HANDLE_VALUE)
+		FindClose(_fh);
+}
+
+
+const std::string& DirectoryIteratorImpl::next()
+{
+	do
+	{
+		if (FindNextFile(_fh, &_fd) != 0)
+			_current = _fd.cFileName;
+		else
+			_current.clear();
+	}
+	while (_current == "." || _current == "..");
+	return _current;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/DirectoryIterator_WIN32U.cpp b/base/poco/Foundation/src/DirectoryIterator_WIN32U.cpp
new file mode 100644
index 00000000000..8f17bc31441
--- /dev/null
+++ b/base/poco/Foundation/src/DirectoryIterator_WIN32U.cpp
@@ -0,0 +1,75 @@
+//
+// DirectoryIterator_WIN32U.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  DirectoryIterator
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DirectoryIterator_WIN32U.h"
+#if defined(_WIN32_WCE)
+#include "Poco/File_WINCE.h"
+#else
+#include "Poco/File_WIN32U.h"
+#endif
+#include "Poco/Path.h"
+#include "Poco/UnicodeConverter.h"
+#include <cstring>
+
+
+namespace Poco {
+
+
+DirectoryIteratorImpl::DirectoryIteratorImpl(const std::string& path): _fh(INVALID_HANDLE_VALUE), _rc(1)
+{
+	Path p(path);
+	p.makeDirectory();
+	std::string findPath = p.toString();
+	findPath.append("*");
+	std::wstring uFindPath;
+	FileImpl::convertPath(findPath, uFindPath);
+
+	_fh = FindFirstFileW(uFindPath.c_str(), &_fd);
+	if (_fh == INVALID_HANDLE_VALUE)
+	{
+		if (GetLastError() != ERROR_NO_MORE_FILES)
+			File::handleLastError(path);
+	}
+	else
+	{
+		UnicodeConverter::toUTF8(_fd.cFileName, _current);
+		if (_current == "." || _current == "..")	
+			next();
+	}
+}
+
+
+DirectoryIteratorImpl::~DirectoryIteratorImpl()
+{
+	if (_fh != INVALID_HANDLE_VALUE)
+		FindClose(_fh);
+}
+
+
+const std::string& DirectoryIteratorImpl::next()
+{
+	do
+	{
+		_current.clear();
+		if (FindNextFileW(_fh, &_fd) != 0)
+		{
+			UnicodeConverter::toUTF8(_fd.cFileName, _current);
+		}
+	}
+	while (_current == "." || _current == "..");
+	return _current;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/DirectoryWatcher.cpp b/base/poco/Foundation/src/DirectoryWatcher.cpp
new file mode 100644
index 00000000000..f54262ee23e
--- /dev/null
+++ b/base/poco/Foundation/src/DirectoryWatcher.cpp
@@ -0,0 +1,608 @@
+//
+// DirectoryWatcher.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  DirectoryWatcher
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DirectoryWatcher.h"
+
+
+#ifndef POCO_NO_INOTIFY
+
+
+#include "Poco/Path.h"
+#include "Poco/Glob.h"
+#include "Poco/DirectoryIterator.h"
+#include "Poco/Event.h"
+#include "Poco/Exception.h"
+#include "Poco/Buffer.h"
+#if POCO_OS == POCO_OS_LINUX || POCO_OS == POCO_OS_ANDROID
+	#include <sys/inotify.h>
+	#include <sys/select.h>
+	#include <unistd.h>
+#elif POCO_OS == POCO_OS_MAC_OS_X || POCO_OS == POCO_OS_FREE_BSD
+	#include <fcntl.h>
+	#include <sys/types.h>
+	#include <sys/event.h>
+	#include <sys/time.h>
+	#include <unistd.h>
+	#if (POCO_OS == POCO_OS_FREE_BSD) && !defined(O_EVTONLY)
+		#define O_EVTONLY 0x8000
+	#endif
+#endif
+#include <algorithm>
+#include <atomic>
+#include <map>
+
+namespace Poco {
+
+
+class DirectoryWatcherStrategy
+{
+public:
+	DirectoryWatcherStrategy(DirectoryWatcher& owner):
+		_owner(owner)
+	{
+	}
+
+	virtual ~DirectoryWatcherStrategy()
+	{
+	}
+
+	DirectoryWatcher& owner()
+	{
+		return _owner;
+	}
+	
+	virtual void run() = 0;
+	virtual void stop() = 0;
+	virtual bool supportsMoveEvents() const = 0;
+
+protected:
+	struct ItemInfo
+	{
+		ItemInfo():
+			size(0)
+		{
+		}
+		
+		ItemInfo(const ItemInfo& other):
+			path(other.path),
+			size(other.size),
+			lastModified(other.lastModified)
+		{
+		}
+		
+		explicit ItemInfo(const File& f):
+			path(f.path()),
+			size(f.isFile() ? f.getSize() : 0),
+			lastModified(f.getLastModified())
+		{
+		}
+		
+		std::string path;
+		File::FileSize size;
+		Timestamp lastModified;
+	};
+	typedef std::map<std::string, ItemInfo> ItemInfoMap;
+
+	void scan(ItemInfoMap& entries)
+	{
+		DirectoryIterator it(owner().directory());
+		DirectoryIterator end;
+		while (it != end)
+		{
+			entries[it.path().getFileName()] = ItemInfo(*it);
+			++it;
+		}
+	}
+	
+	void compare(ItemInfoMap& oldEntries, ItemInfoMap& newEntries)
+	{
+		for (ItemInfoMap::iterator itn = newEntries.begin(); itn != newEntries.end(); ++itn)
+		{
+			ItemInfoMap::iterator ito = oldEntries.find(itn->first);
+			if (ito != oldEntries.end())
+			{
+				if ((owner().eventMask() & DirectoryWatcher::DW_ITEM_MODIFIED) && !owner().eventsSuspended())
+				{
+					if (itn->second.size != ito->second.size || itn->second.lastModified != ito->second.lastModified)
+					{
+						Poco::File f(itn->second.path);
+						DirectoryWatcher::DirectoryEvent ev(f, DirectoryWatcher::DW_ITEM_MODIFIED);
+						owner().itemModified(&owner(), ev);
+					}
+				}
+				oldEntries.erase(ito);
+			}
+			else if ((owner().eventMask() & DirectoryWatcher::DW_ITEM_ADDED) && !owner().eventsSuspended())
+			{
+				Poco::File f(itn->second.path);
+				DirectoryWatcher::DirectoryEvent ev(f, DirectoryWatcher::DW_ITEM_ADDED);
+				owner().itemAdded(&owner(), ev);
+			}
+		}
+		if ((owner().eventMask() & DirectoryWatcher::DW_ITEM_REMOVED) && !owner().eventsSuspended())
+		{
+			for (ItemInfoMap::iterator it = oldEntries.begin(); it != oldEntries.end(); ++it)
+			{
+				Poco::File f(it->second.path);
+				DirectoryWatcher::DirectoryEvent ev(f, DirectoryWatcher::DW_ITEM_REMOVED);
+				owner().itemRemoved(&owner(), ev);
+			}
+		}
+	}
+
+private:
+	DirectoryWatcherStrategy();
+	DirectoryWatcherStrategy(const DirectoryWatcherStrategy&);
+	DirectoryWatcherStrategy& operator = (const DirectoryWatcherStrategy&);
+	
+	DirectoryWatcher& _owner;
+};
+
+
+#if POCO_OS == POCO_OS_WINDOWS_NT
+
+
+class WindowsDirectoryWatcherStrategy: public DirectoryWatcherStrategy
+{
+public:
+	WindowsDirectoryWatcherStrategy(DirectoryWatcher& owner):
+		DirectoryWatcherStrategy(owner)
+	{
+		_hStopped = CreateEventW(NULL, FALSE, FALSE, NULL);
+		if (!_hStopped)
+			throw SystemException("cannot create event");
+	}
+	
+	~WindowsDirectoryWatcherStrategy()
+	{
+		CloseHandle(_hStopped);
+	}
+	
+	void run()
+	{
+		ItemInfoMap entries;
+		scan(entries);
+		
+		DWORD filter = FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME;
+		if (owner().eventMask() & DirectoryWatcher::DW_ITEM_MODIFIED)
+			filter |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE;
+		
+		std::string path(owner().directory().path());
+#if defined(POCO_WIN32_UTF8)
+		std::wstring upath;
+		FileImpl::convertPath(path.c_str(), upath);
+		HANDLE hChange = FindFirstChangeNotificationW(upath.c_str(), FALSE, filter);
+#else
+		HANDLE hChange = FindFirstChangeNotificationA(path.c_str(), FALSE, filter);
+#endif
+
+		if (hChange == INVALID_HANDLE_VALUE)
+		{
+			try
+			{
+				FileImpl::handleLastErrorImpl(path);
+			}
+			catch (Poco::Exception& exc)
+			{
+				owner().scanError(&owner(), exc);
+			}
+			return;
+		}
+		
+		bool stopped = false;
+		while (!stopped)
+		{
+			try
+			{
+				HANDLE h[2];
+				h[0] = _hStopped;
+				h[1] = hChange;
+				switch (WaitForMultipleObjects(2, h, FALSE, INFINITE))
+				{
+				case WAIT_OBJECT_0:
+					stopped = true;
+					break;
+				case WAIT_OBJECT_0 + 1:
+					{
+						ItemInfoMap newEntries;
+						scan(newEntries);
+						compare(entries, newEntries);
+						std::swap(entries, newEntries);
+						if (FindNextChangeNotification(hChange) == FALSE)
+						{
+							FileImpl::handleLastErrorImpl(path);
+						}
+					}
+					break;
+				default:
+					throw SystemException("failed to wait for directory changes");
+				}
+			}
+			catch (Poco::Exception& exc)
+			{
+				owner().scanError(&owner(), exc);
+			}			
+		}
+		FindCloseChangeNotification(hChange);
+	}
+	
+	void stop()
+	{
+		SetEvent(_hStopped);
+	}
+	
+	bool supportsMoveEvents() const
+	{
+		return false;
+	}
+	
+private:
+	HANDLE _hStopped;
+};
+
+
+#elif POCO_OS == POCO_OS_LINUX || POCO_OS == POCO_OS_ANDROID
+
+
+class LinuxDirectoryWatcherStrategy: public DirectoryWatcherStrategy
+{
+public:
+	LinuxDirectoryWatcherStrategy(DirectoryWatcher& owner):
+		DirectoryWatcherStrategy(owner),
+		_fd(-1),
+		_stopped(false)
+	{
+		_fd = inotify_init();
+		if (_fd == -1) throw Poco::IOException("cannot initialize inotify", errno);
+	}
+	
+	~LinuxDirectoryWatcherStrategy()
+	{
+		close(_fd);
+	}
+	
+	void run()
+	{
+		int mask = 0;
+		if (owner().eventMask() & DirectoryWatcher::DW_ITEM_ADDED)
+			mask |= IN_CREATE;
+		if (owner().eventMask() & DirectoryWatcher::DW_ITEM_REMOVED)
+			mask |= IN_DELETE;
+		if (owner().eventMask() & DirectoryWatcher::DW_ITEM_MODIFIED)
+			mask |= IN_MODIFY;
+		if (owner().eventMask() & DirectoryWatcher::DW_ITEM_MOVED_FROM)
+			mask |= IN_MOVED_FROM;
+		if (owner().eventMask() & DirectoryWatcher::DW_ITEM_MOVED_TO)
+			mask |= IN_MOVED_TO;
+		int wd = inotify_add_watch(_fd, owner().directory().path().c_str(), mask);
+		if (wd == -1)
+		{
+			try
+			{
+				FileImpl::handleLastErrorImpl(owner().directory().path());
+			}
+			catch (Poco::Exception& exc)
+			{
+				owner().scanError(&owner(), exc);
+			}
+		}
+		
+		Poco::Buffer<char> buffer(4096);
+		while (!_stopped.load(std::memory_order_relaxed))
+		{
+			fd_set fds;
+			FD_ZERO(&fds);
+			FD_SET(_fd, &fds);
+
+			struct timeval tv;
+			tv.tv_sec  = 0;
+			tv.tv_usec = 200000;
+
+			if (select(_fd + 1, &fds, NULL, NULL, &tv) == 1)
+			{
+				int n = read(_fd, buffer.begin(), buffer.size());
+				int i = 0;
+				if (n > 0)
+				{
+					while (n > 0)
+					{
+						struct inotify_event* pEvent = reinterpret_cast<struct inotify_event*>(buffer.begin() + i);
+						
+						if (pEvent->len > 0)
+						{						
+							if (!owner().eventsSuspended())
+							{
+								Poco::Path p(owner().directory().path());
+								p.makeDirectory();
+								p.setFileName(pEvent->name);
+								Poco::File f(p.toString());
+	
+								if ((pEvent->mask & IN_CREATE) && (owner().eventMask() & DirectoryWatcher::DW_ITEM_ADDED))
+								{
+									DirectoryWatcher::DirectoryEvent ev(f, DirectoryWatcher::DW_ITEM_ADDED);
+									owner().itemAdded(&owner(), ev);
+								}
+								if ((pEvent->mask & IN_DELETE) && (owner().eventMask() & DirectoryWatcher::DW_ITEM_REMOVED))
+								{
+									DirectoryWatcher::DirectoryEvent ev(f, DirectoryWatcher::DW_ITEM_REMOVED);
+									owner().itemRemoved(&owner(), ev);
+								}
+								if ((pEvent->mask & IN_MODIFY) && (owner().eventMask() & DirectoryWatcher::DW_ITEM_MODIFIED))
+								{
+									DirectoryWatcher::DirectoryEvent ev(f, DirectoryWatcher::DW_ITEM_MODIFIED);
+									owner().itemModified(&owner(), ev);
+								}
+								if ((pEvent->mask & IN_MOVED_FROM) && (owner().eventMask() & DirectoryWatcher::DW_ITEM_MOVED_FROM))
+								{
+									DirectoryWatcher::DirectoryEvent ev(f, DirectoryWatcher::DW_ITEM_MOVED_FROM);
+									owner().itemMovedFrom(&owner(), ev);
+								}
+								if ((pEvent->mask & IN_MOVED_TO) && (owner().eventMask() & DirectoryWatcher::DW_ITEM_MOVED_TO))
+								{
+									DirectoryWatcher::DirectoryEvent ev(f, DirectoryWatcher::DW_ITEM_MOVED_TO);
+									owner().itemMovedTo(&owner(), ev);
+								}
+							}
+						}
+						
+						i += sizeof(inotify_event) + pEvent->len;
+						n -= sizeof(inotify_event) + pEvent->len;
+					}
+				}
+			}
+		}
+	}
+	
+	void stop()
+	{
+		_stopped.store(true, std::memory_order_relaxed);
+	}
+	
+	bool supportsMoveEvents() const
+	{
+		return true;
+	}
+
+private:
+	int _fd;
+	std::atomic<bool> _stopped;
+};
+
+
+#elif POCO_OS == POCO_OS_MAC_OS_X || POCO_OS == POCO_OS_FREE_BSD
+
+
+class BSDDirectoryWatcherStrategy: public DirectoryWatcherStrategy
+{
+public:
+	BSDDirectoryWatcherStrategy(DirectoryWatcher& owner):
+		DirectoryWatcherStrategy(owner),
+		_queueFD(-1),
+		_dirFD(-1),
+		_stopped(false)
+	{
+		_dirFD = open(owner.directory().path().c_str(), O_EVTONLY);
+		if (_dirFD < 0) throw Poco::FileNotFoundException(owner.directory().path());
+		_queueFD = kqueue();
+		if (_queueFD < 0)
+		{
+			close(_dirFD);
+			throw Poco::SystemException("Cannot create kqueue", errno);
+		}
+	}
+
+	~BSDDirectoryWatcherStrategy()
+	{
+		close(_dirFD);
+		close(_queueFD);
+	}
+
+	void run()
+	{
+		Poco::Timestamp lastScan;
+		ItemInfoMap entries;
+		scan(entries);
+
+		while (!_stopped.load(std::memory_order_relaxed))
+		{
+			struct timespec timeout;
+			timeout.tv_sec = 0;
+			timeout.tv_nsec = 200000000;
+			unsigned eventFilter = NOTE_WRITE;
+			struct kevent event;
+			struct kevent eventData;
+			EV_SET(&event, _dirFD, EVFILT_VNODE, EV_ADD | EV_CLEAR, eventFilter, 0, 0);
+			int nEvents = kevent(_queueFD, &event, 1, &eventData, 1, &timeout);
+			if (nEvents < 0 || eventData.flags == EV_ERROR)
+			{
+				try
+				{
+					FileImpl::handleLastErrorImpl(owner().directory().path());
+				}
+				catch (Poco::Exception& exc)
+				{
+					owner().scanError(&owner(), exc);
+				}
+			}
+			else if (nEvents > 0 || ((owner().eventMask() & DirectoryWatcher::DW_ITEM_MODIFIED) && lastScan.isElapsed(owner().scanInterval()*1000000)))
+			{
+				ItemInfoMap newEntries;
+				scan(newEntries);
+				compare(entries, newEntries);
+				std::swap(entries, newEntries);
+				lastScan.update();
+			}
+		}
+	}
+
+	void stop()
+	{
+		_stopped.store(true, std::memory_order_relaxed);
+	}
+
+	bool supportsMoveEvents() const
+	{
+		return false;
+	}
+
+private:
+	int _queueFD;
+	int _dirFD;
+	std::atomic<bool> _stopped;
+};
+
+
+#else
+
+
+class PollingDirectoryWatcherStrategy: public DirectoryWatcherStrategy
+{
+public:
+	PollingDirectoryWatcherStrategy(DirectoryWatcher& owner):
+		DirectoryWatcherStrategy(owner)
+	{
+	}
+	
+	~PollingDirectoryWatcherStrategy()
+	{
+	}
+	
+	void run()
+	{
+		ItemInfoMap entries;
+		scan(entries);
+		while (!_stopped.tryWait(1000*owner().scanInterval()))
+		{
+			try
+			{
+				ItemInfoMap newEntries;
+				scan(newEntries);
+				compare(entries, newEntries);
+				std::swap(entries, newEntries);
+			}
+			catch (Poco::Exception& exc)
+			{
+				owner().scanError(&owner(), exc);
+			}
+		}
+	}
+	
+	void stop()
+	{
+		_stopped.set();
+	}
+
+	bool supportsMoveEvents() const
+	{
+		return false;
+	}
+
+private:
+	Poco::Event _stopped;
+};
+
+
+#endif
+
+
+DirectoryWatcher::DirectoryWatcher(const std::string& path, int eventMask, int scanInterval):
+	_directory(path),
+	_eventMask(eventMask),
+	_scanInterval(scanInterval)
+{
+	init();
+}
+
+	
+DirectoryWatcher::DirectoryWatcher(const Poco::File& directory, int eventMask, int scanInterval):
+	_directory(directory),
+	_eventMask(eventMask),
+	_scanInterval(scanInterval)
+{
+	init();
+}
+
+
+DirectoryWatcher::~DirectoryWatcher()
+{
+	try
+	{
+		stop();
+		delete _pStrategy;
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+	
+void DirectoryWatcher::suspendEvents()
+{
+	poco_assert (_eventsSuspended > 0);
+	
+	_eventsSuspended--;
+}
+
+
+void DirectoryWatcher::resumeEvents()
+{
+	_eventsSuspended++;
+}
+
+
+void DirectoryWatcher::init()
+{
+	if (!_directory.exists())
+		throw Poco::FileNotFoundException(_directory.path());
+		
+	if (!_directory.isDirectory())
+		throw Poco::InvalidArgumentException("not a directory", _directory.path());
+
+#if POCO_OS == POCO_OS_WINDOWS_NT
+	_pStrategy = new WindowsDirectoryWatcherStrategy(*this);
+#elif POCO_OS == POCO_OS_LINUX || POCO_OS == POCO_OS_ANDROID
+	_pStrategy = new LinuxDirectoryWatcherStrategy(*this);
+#elif POCO_OS == POCO_OS_MAC_OS_X || POCO_OS == POCO_OS_FREE_BSD
+	_pStrategy = new BSDDirectoryWatcherStrategy(*this);
+#else
+	_pStrategy = new PollingDirectoryWatcherStrategy(*this);
+#endif
+	_thread.start(*this);
+}
+
+	
+void DirectoryWatcher::run()
+{
+	_pStrategy->run();
+}
+
+
+void DirectoryWatcher::stop()
+{
+	_pStrategy->stop();
+	_thread.join();
+}
+
+
+bool DirectoryWatcher::supportsMoveEvents() const
+{
+	return _pStrategy->supportsMoveEvents();
+}
+
+
+} // namespace Poco
+
+
+#endif // POCO_NO_INOTIFY
diff --git a/base/poco/Foundation/src/Environment.cpp b/base/poco/Foundation/src/Environment.cpp
new file mode 100644
index 00000000000..32753efc5ab
--- /dev/null
+++ b/base/poco/Foundation/src/Environment.cpp
@@ -0,0 +1,160 @@
+//
+// Environment.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  Environment
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Environment.h"
+#include "Poco/Version.h"
+#include <cstdlib>
+#include <cstdio> // sprintf()
+
+
+#if defined(POCO_VXWORKS)
+#include "Environment_VX.cpp"
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include "Environment_UNIX.cpp"
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#if defined(_WIN32_WCE)
+#include "Environment_WINCE.cpp"
+#else
+#include "Environment_WIN32.cpp"
+#endif
+#endif
+
+
+namespace Poco {
+
+
+std::string Environment::get(const std::string& name)
+{
+	return EnvironmentImpl::getImpl(name);
+}
+
+
+std::string Environment::get(const std::string& name, const std::string& defaultValue)
+{
+	if (has(name))
+		return get(name);
+	else
+		return defaultValue;
+}
+
+
+bool Environment::has(const std::string& name)
+{
+	return EnvironmentImpl::hasImpl(name);
+}
+
+
+void Environment::set(const std::string& name, const std::string& value)
+{
+	EnvironmentImpl::setImpl(name, value);
+}
+
+
+std::string Environment::osName()
+{
+	return EnvironmentImpl::osNameImpl();
+}
+
+
+std::string Environment::osDisplayName()
+{
+	return EnvironmentImpl::osDisplayNameImpl();
+}
+
+
+std::string Environment::osVersion()
+{
+	return EnvironmentImpl::osVersionImpl();
+}
+
+
+std::string Environment::osArchitecture()
+{
+	return EnvironmentImpl::osArchitectureImpl();
+}
+
+
+std::string Environment::nodeName()
+{
+	return EnvironmentImpl::nodeNameImpl();
+}
+
+
+std::string Environment::nodeId()
+{
+	NodeId id;
+	nodeId(id);
+	char result[18];
+	std::sprintf(result, "%02x:%02x:%02x:%02x:%02x:%02x",
+		id[0],
+		id[1],
+		id[2],
+		id[3],
+		id[4],
+		id[5]);
+	return std::string(result);
+}
+
+
+void Environment::nodeId(NodeId& id)
+{
+	return EnvironmentImpl::nodeIdImpl(id);
+}
+
+
+unsigned Environment::processorCount()
+{
+	return EnvironmentImpl::processorCountImpl();
+}
+
+
+Poco::UInt32 Environment::libraryVersion()
+{
+	return POCO_VERSION;
+}
+
+
+Poco::Int32 Environment::os()
+{
+	return POCO_OS;
+}
+
+
+Poco::Int32 Environment::arch()
+{
+	return POCO_ARCH;
+}
+
+
+bool Environment::isUnix()
+{
+#if defined(POCO_OS_FAMILY_UNIX)
+	return true;
+#else
+	return false;
+#endif
+}
+
+
+bool Environment::isWindows()
+{
+#if defined(POCO_OS_FAMILY_WINDOWS)
+	return true;
+#else
+	return false;
+#endif
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Environment_UNIX.cpp b/base/poco/Foundation/src/Environment_UNIX.cpp
new file mode 100644
index 00000000000..b7e57e4314c
--- /dev/null
+++ b/base/poco/Foundation/src/Environment_UNIX.cpp
@@ -0,0 +1,332 @@
+
+// Environment_UNIX.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  Environment
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Environment_UNIX.h"
+#include "Poco/Exception.h"
+#include "Poco/Buffer.h"
+#include <cstring>
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/utsname.h>
+#include <sys/param.h>
+#if defined(POCO_OS_FAMILY_BSD)
+#include <sys/sysctl.h>
+#elif POCO_OS == POCO_OS_HPUX
+#include <pthread.h>
+#endif
+
+
+namespace Poco {
+
+
+EnvironmentImpl::StringMap EnvironmentImpl::_map;
+FastMutex EnvironmentImpl::_mutex;
+
+
+std::string EnvironmentImpl::getImpl(const std::string& name)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	const char* val = getenv(name.c_str());
+	if (val)
+		return std::string(val);
+	else
+		throw NotFoundException(name);
+}
+
+
+bool EnvironmentImpl::hasImpl(const std::string& name)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	return getenv(name.c_str()) != 0;
+}
+
+
+void EnvironmentImpl::setImpl(const std::string& name, const std::string& value)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	std::string var = name;
+	var.append("=");
+	var.append(value);
+	std::swap(_map[name], var);
+	if (putenv((char*) _map[name].c_str()))
+	{
+		std::string msg = "cannot set environment variable: ";
+		msg.append(name);
+		throw SystemException(msg);
+	}
+}
+
+
+std::string EnvironmentImpl::osNameImpl()
+{
+	struct utsname uts;
+	uname(&uts);
+	return uts.sysname;
+}
+
+
+std::string EnvironmentImpl::osDisplayNameImpl()
+{
+	return osNameImpl();
+}
+
+
+std::string EnvironmentImpl::osVersionImpl()
+{
+	struct utsname uts;
+	uname(&uts);
+	return uts.release;
+}
+
+
+std::string EnvironmentImpl::osArchitectureImpl()
+{
+	struct utsname uts;
+	uname(&uts);
+	return uts.machine;
+}
+
+
+std::string EnvironmentImpl::nodeNameImpl()
+{
+	struct utsname uts;
+	uname(&uts);
+	return uts.nodename;
+}
+
+
+unsigned EnvironmentImpl::processorCountImpl()
+{
+#if defined(_SC_NPROCESSORS_ONLN)
+	int count = sysconf(_SC_NPROCESSORS_ONLN);
+	if (count <= 0) count = 1;
+	return static_cast<int>(count);
+#elif defined(POCO_OS_FAMILY_BSD)
+	unsigned count;
+	std::size_t size = sizeof(count);
+	if (sysctlbyname("hw.ncpu", &count, &size, 0, 0))
+		return 1;
+	else
+		return count;
+#elif POCO_OS == POCO_OS_HPUX
+	return pthread_num_processors_np();
+#else
+	return 1;
+#endif
+}
+
+
+} // namespace Poco
+
+
+//
+// nodeIdImpl
+//
+#if defined(POCO_OS_FAMILY_BSD) || POCO_OS == POCO_OS_QNX
+//
+// BSD variants
+//
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <ifaddrs.h>
+#include <net/if_dl.h>
+
+
+namespace Poco {
+
+
+void EnvironmentImpl::nodeIdImpl(NodeId& id)
+{
+	std::memset(&id, 0, sizeof(id));
+	struct ifaddrs* ifaphead;
+	int rc = getifaddrs(&ifaphead);
+	if (rc) return;
+
+	for (struct ifaddrs* ifap = ifaphead; ifap; ifap = ifap->ifa_next)
+	{
+		if (ifap->ifa_addr && ifap->ifa_addr->sa_family == AF_LINK)
+		{
+			struct sockaddr_dl* sdl = reinterpret_cast<struct sockaddr_dl*>(ifap->ifa_addr);
+			caddr_t ap = LLADDR(sdl);
+			int alen = sdl->sdl_alen;
+			if (ap && alen > 0)
+			{
+				std::memcpy(&id, ap, sizeof(id));
+				break;
+			}
+		}
+	}
+	freeifaddrs(ifaphead);
+}
+
+
+} // namespace Poco
+
+
+#elif defined(__CYGWIN__) || POCO_OS == POCO_OS_LINUX || POCO_OS == POCO_OS_ANDROID
+//
+// Linux, Cygwin
+//
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <net/if.h>
+#ifndef __CYGWIN__
+#include <net/if_arp.h>
+#else // workaround for Cygwin, which does not have if_arp.h
+#define ARPHRD_ETHER 1 /* Ethernet 10Mbps */
+#endif
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <cstdio>
+
+
+namespace Poco {
+
+
+void EnvironmentImpl::nodeIdImpl(NodeId& id)
+{
+	std::memset(&id, 0, sizeof(id));
+
+	// ideally, the following code should be rewritten
+	// to use netlink
+
+	// first try to obtain the MAC address of eth0 using /sys/class/net
+	int fd = open("/sys/class/net/eth0/address", O_RDONLY);
+	if (fd >= 0)
+	{
+		char buffer[18];
+		int n = read(fd, buffer, 17);
+		close(fd);
+		if (n == 17)
+		{
+			buffer[n] = 0;
+			if (std::sscanf(buffer, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", &id[0], &id[1], &id[2], &id[3], &id[4], &id[5]) == 6)
+				return;
+		}
+	}
+
+	// if that did not work, search active interfaces
+	int sock = socket(PF_INET, SOCK_DGRAM, 0);
+	if (sock == -1) return;
+
+	// the following code is loosely based
+	// on W. Richard Stevens, UNIX Network Programming, pp 434ff.
+	int lastlen = 0;
+	int len = 100*sizeof(struct ifreq);
+	struct ifconf ifc;
+	char* buf = 0;
+	for (;;)
+	{
+		buf = new char[len];
+		ifc.ifc_len = len;
+		ifc.ifc_buf = buf;
+		if (::ioctl(sock, SIOCGIFCONF, &ifc) < 0)
+		{
+			if (errno != EINVAL || lastlen != 0)
+			{
+				close(sock);
+				delete [] buf;
+				return;
+			}
+		}
+		else
+		{
+			if (ifc.ifc_len == lastlen)
+				break;
+			lastlen = ifc.ifc_len;
+		}
+		len += 10*sizeof(struct ifreq);
+		delete [] buf;
+	}
+	for (const char* ptr = buf; ptr < buf + ifc.ifc_len;)
+	{
+		const struct ifreq* ifr = reinterpret_cast<const struct ifreq*>(ptr);
+		int rc = ioctl(sock, SIOCGIFHWADDR, ifr);
+		if (rc != -1)
+		{
+			const struct sockaddr* sa = reinterpret_cast<const struct sockaddr*>(&ifr->ifr_hwaddr);
+			if (sa->sa_family == ARPHRD_ETHER)
+			{
+				std::memcpy(&id, sa->sa_data, sizeof(id));
+				break;
+			}
+		}
+		ptr += sizeof(struct ifreq);
+	}
+	close(sock);
+	delete [] buf;
+}
+
+
+} // namespace Poco
+
+
+#elif defined(POCO_OS_FAMILY_UNIX)
+//
+// General Unix
+//
+#include <sys/ioctl.h>
+#if defined(sun) || defined(__sun)
+#include <sys/sockio.h>
+#endif
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <net/if.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <unistd.h>
+
+
+namespace Poco {
+
+
+void EnvironmentImpl::nodeIdImpl(NodeId& id)
+{
+	std::memset(&id, 0, sizeof(id));
+	char name[MAXHOSTNAMELEN];
+	if (gethostname(name, sizeof(name)))
+		return;
+
+	struct hostent* pHost = gethostbyname(name);
+	if (!pHost) return;
+
+	int s = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
+	if (s == -1) return;
+
+	struct arpreq ar;
+	std::memset(&ar, 0, sizeof(ar));
+	struct sockaddr_in* pAddr = reinterpret_cast<struct sockaddr_in*>(&ar.arp_pa);
+	pAddr->sin_family = AF_INET;
+	std::memcpy(&pAddr->sin_addr, *pHost->h_addr_list, sizeof(struct in_addr));
+	int rc = ioctl(s, SIOCGARP, &ar);
+	close(s);
+	if (rc < 0) return;
+	std::memcpy(&id, ar.arp_ha.sa_data, sizeof(id));
+}
+
+
+} // namespace Poco
+
+
+#endif
diff --git a/base/poco/Foundation/src/Environment_VX.cpp b/base/poco/Foundation/src/Environment_VX.cpp
new file mode 100644
index 00000000000..f6869bab563
--- /dev/null
+++ b/base/poco/Foundation/src/Environment_VX.cpp
@@ -0,0 +1,159 @@
+
+// Environment_VX.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  Environment
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Environment_VX.h"
+#include "Poco/Exception.h"
+#include "Poco/Buffer.h"
+#include <VxWorks.h>
+#include <envLib.h>
+#include <hostLib.h>
+#include <ifLib.h>
+#include <sockLib.h>
+#include <ioLib.h>
+#include <version.h>
+#include <cstring>
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <net/if.h>
+#include <arpa/inet.h>
+#include <netinet/if_ether.h>
+#include <ifLib.h>
+#include <unistd.h>
+
+
+namespace Poco {
+
+
+EnvironmentImpl::StringMap EnvironmentImpl::_map;
+FastMutex EnvironmentImpl::_mutex;
+
+
+std::string EnvironmentImpl::getImpl(const std::string& name)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	const char* val = getenv(name.c_str());
+	if (val)
+		return std::string(val);
+	else
+		throw NotFoundException(name);
+}
+
+
+bool EnvironmentImpl::hasImpl(const std::string& name)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	return getenv(name.c_str()) != 0;
+}
+
+
+void EnvironmentImpl::setImpl(const std::string& name, const std::string& value)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	std::string var = name;
+	var.append("=");
+	var.append(value);
+	std::swap(_map[name], var);
+	if (putenv((char*) _map[name].c_str()))
+	{
+		std::string msg = "cannot set environment variable: ";
+		msg.append(name);
+		throw SystemException(msg);
+	}
+}
+
+
+std::string EnvironmentImpl::osNameImpl()
+{
+	return runtimeName;
+}
+
+
+std::string EnvironmentImpl::osDisplayNameImpl()
+{
+	return osNameImpl();
+}
+
+
+std::string EnvironmentImpl::osVersionImpl()
+{
+	return runtimeVersion;
+}
+
+
+std::string EnvironmentImpl::osArchitectureImpl()
+{
+#if POCO_ARCH == POCO_ARCH_IA32
+	return "i386";
+#elif POCO_ARCH == POCO_ARCH_MIPS
+	return "mips";
+#elif POCO_ARCH == POCO_ARCH_PPC
+	return "ppc";
+#elif POCO_ARCH == POCO_ARCH_ARM
+	return "arm";
+#elif POCO_ARCH == POCO_ARCH_SH
+	return "sh";
+#else
+	return "unknown";
+#endif
+}
+
+
+std::string EnvironmentImpl::nodeNameImpl()
+{
+	char buffer[64];
+	if (gethostname(buffer, sizeof(buffer)) == OK)
+		return buffer;
+	else
+		return "unknown";
+}
+
+
+unsigned EnvironmentImpl::processorCountImpl()
+{
+	return 1;
+}
+
+
+void EnvironmentImpl::nodeIdImpl(NodeId& id)
+{
+	std::memset(&id, 0, sizeof(id));
+
+	int ifIndex = 1;
+	char ifName[32];
+	for (;;)
+	{
+		if (ifIndexToIfName(ifIndex, ifName) == OK)
+		{
+			struct ifnet* pIf = ifunit(ifName);
+			if (pIf)
+			{
+				std::memcpy(&id, ((struct arpcom *) pIf)->ac_enaddr, sizeof(id));
+				return;
+			}
+		}
+		else break;
+		++ifIndex;
+	}
+	throw SystemException("cannot get Ethernet hardware address");
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Environment_WIN32.cpp b/base/poco/Foundation/src/Environment_WIN32.cpp
new file mode 100644
index 00000000000..62845fab029
--- /dev/null
+++ b/base/poco/Foundation/src/Environment_WIN32.cpp
@@ -0,0 +1,221 @@
+//
+// Environment_WIN32.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  Environment
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Environment_WIN32.h"
+#include "Poco/Exception.h"
+#include <sstream>
+#include <cstring>
+#include "Poco/UnWindows.h"
+#include <winsock2.h>
+#include <wincrypt.h>
+#include <ws2ipdef.h>
+#include <iphlpapi.h>
+
+
+namespace Poco {
+
+
+std::string EnvironmentImpl::getImpl(const std::string& name)
+{
+	DWORD len = GetEnvironmentVariableA(name.c_str(), 0, 0);
+	if (len == 0) throw NotFoundException(name);
+	char* buffer = new char[len];
+	GetEnvironmentVariableA(name.c_str(), buffer, len);
+	std::string result(buffer);
+	delete [] buffer;
+	return result;
+}
+
+
+bool EnvironmentImpl::hasImpl(const std::string& name)
+{
+	DWORD len = GetEnvironmentVariableA(name.c_str(), 0, 0);
+	return len > 0;
+}
+
+
+void EnvironmentImpl::setImpl(const std::string& name, const std::string& value)
+{
+	if (SetEnvironmentVariableA(name.c_str(), value.c_str()) == 0)
+	{
+		std::string msg = "cannot set environment variable: ";
+		msg.append(name);
+		throw SystemException(msg);
+	}
+}
+
+
+std::string EnvironmentImpl::osNameImpl()
+{
+	OSVERSIONINFO vi;
+	vi.dwOSVersionInfoSize = sizeof(vi);
+	if (GetVersionEx(&vi) == 0) throw SystemException("Cannot get OS version information");
+	switch (vi.dwPlatformId)
+	{
+	case VER_PLATFORM_WIN32s:
+		return "Windows 3.x";
+	case VER_PLATFORM_WIN32_WINDOWS:
+		return vi.dwMinorVersion == 0 ? "Windows 95" : "Windows 98";
+	case VER_PLATFORM_WIN32_NT:
+		return "Windows NT";
+	default:
+		return "Unknown";
+	}
+}
+
+
+std::string EnvironmentImpl::osDisplayNameImpl()
+{
+	OSVERSIONINFOEX vi;	// OSVERSIONINFOEX is supported starting at Windows 2000 
+	vi.dwOSVersionInfoSize = sizeof(vi);
+	if (GetVersionEx((OSVERSIONINFO*) &vi) == 0) throw SystemException("Cannot get OS version information");
+	switch (vi.dwMajorVersion)
+	{
+	case 10:
+		switch (vi.dwMinorVersion)
+		{
+		case 0:
+			return vi.wProductType == VER_NT_WORKSTATION ? "Windows 10" : "Windows Server 2016";
+		}
+	case 6:
+		switch (vi.dwMinorVersion)
+		{
+		case 0:
+			return vi.wProductType == VER_NT_WORKSTATION ? "Windows Vista" : "Windows Server 2008";
+		case 1:
+			return vi.wProductType == VER_NT_WORKSTATION ? "Windows 7" : "Windows Server 2008 R2";
+		case 2:
+			return vi.wProductType == VER_NT_WORKSTATION ? "Windows 8" : "Windows Server 2012";
+		case 3:
+			return vi.wProductType == VER_NT_WORKSTATION ? "Windows 8.1" : "Windows Server 2012 R2";
+		default:
+			return "Unknown";
+		}
+	case 5:
+		switch (vi.dwMinorVersion)
+		{
+		case 0:
+			return "Windows 2000";
+		case 1:
+			return "Windows XP";
+		case 2:
+			return "Windows Server 2003/Windows Server 2003 R2";
+		default:
+			return "Unknown";
+		}
+	default:
+		return "Unknown";
+	}
+}
+
+
+std::string EnvironmentImpl::osVersionImpl()
+{
+	OSVERSIONINFO vi;
+	vi.dwOSVersionInfoSize = sizeof(vi);
+	if (GetVersionEx(&vi) == 0) throw SystemException("Cannot get OS version information");
+	std::ostringstream str;
+	str << vi.dwMajorVersion << "." << vi.dwMinorVersion << " (Build " << (vi.dwBuildNumber & 0xFFFF);
+	if (vi.szCSDVersion[0]) str << ": " << vi.szCSDVersion;
+	str << ")";
+	return str.str();
+}
+
+
+std::string EnvironmentImpl::osArchitectureImpl()
+{
+	SYSTEM_INFO si;
+	GetSystemInfo(&si);
+	switch (si.wProcessorArchitecture)
+	{
+	case PROCESSOR_ARCHITECTURE_INTEL:
+		return "IA32";
+	case PROCESSOR_ARCHITECTURE_MIPS:
+		return "MIPS";
+	case PROCESSOR_ARCHITECTURE_ALPHA:
+		return "ALPHA";
+	case PROCESSOR_ARCHITECTURE_PPC:
+		return "PPC";
+	case PROCESSOR_ARCHITECTURE_IA64:
+		return "IA64";
+#ifdef PROCESSOR_ARCHITECTURE_IA32_ON_WIN64
+	case PROCESSOR_ARCHITECTURE_IA32_ON_WIN64:
+		return "IA64/32";
+#endif
+#ifdef PROCESSOR_ARCHITECTURE_AMD64
+	case PROCESSOR_ARCHITECTURE_AMD64:
+		return "AMD64";
+#endif
+	default:
+		return "Unknown";
+	}
+}
+
+
+std::string EnvironmentImpl::nodeNameImpl()
+{
+	char name[MAX_COMPUTERNAME_LENGTH + 1];
+	DWORD size = sizeof(name);
+	if (GetComputerNameA(name, &size) == 0) throw SystemException("Cannot get computer name");
+	return std::string(name);
+}
+
+
+void EnvironmentImpl::nodeIdImpl(NodeId& id)
+{
+	std::memset(&id, 0, sizeof(id));
+
+	PIP_ADAPTER_INFO pAdapterInfo;
+	PIP_ADAPTER_INFO pAdapter = 0;
+	ULONG len    = sizeof(IP_ADAPTER_INFO);
+	pAdapterInfo = reinterpret_cast<IP_ADAPTER_INFO*>(new char[len]);
+	// Make an initial call to GetAdaptersInfo to get
+	// the necessary size into len
+	DWORD rc = GetAdaptersInfo(pAdapterInfo, &len);
+	if (rc == ERROR_BUFFER_OVERFLOW) 
+	{
+		delete [] reinterpret_cast<char*>(pAdapterInfo);
+		pAdapterInfo = reinterpret_cast<IP_ADAPTER_INFO*>(new char[len]);
+	}
+	else if (rc != ERROR_SUCCESS)
+	{
+		return;
+	}
+	if (GetAdaptersInfo(pAdapterInfo, &len) == NO_ERROR) 
+	{
+		pAdapter = pAdapterInfo;
+		bool found = false;
+		while (pAdapter && !found) 
+		{
+			if (pAdapter->Type == MIB_IF_TYPE_ETHERNET && pAdapter->AddressLength == sizeof(id))
+			{
+				found = true;
+				std::memcpy(&id, pAdapter->Address, pAdapter->AddressLength);
+			}
+			pAdapter = pAdapter->Next;
+		}
+	}
+	delete [] reinterpret_cast<char*>(pAdapterInfo);
+}
+
+
+unsigned EnvironmentImpl::processorCountImpl()
+{
+	SYSTEM_INFO si;
+	GetSystemInfo(&si);
+	return si.dwNumberOfProcessors;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Environment_WIN32U.cpp b/base/poco/Foundation/src/Environment_WIN32U.cpp
new file mode 100644
index 00000000000..624ff83c8ce
--- /dev/null
+++ b/base/poco/Foundation/src/Environment_WIN32U.cpp
@@ -0,0 +1,235 @@
+//
+// Environment_WIN32U.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  Environment
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Environment_WIN32U.h"
+#include "Poco/Exception.h"
+#include "Poco/UnicodeConverter.h"
+#include "Poco/Buffer.h"
+#include <sstream>
+#include <cstring>
+#include "Poco/UnWindows.h"
+#include <winsock2.h>
+#include <wincrypt.h>
+#include <ws2ipdef.h>
+#include <iphlpapi.h>
+
+
+namespace Poco {
+
+
+std::string EnvironmentImpl::getImpl(const std::string& name)
+{
+	std::wstring uname;
+	UnicodeConverter::toUTF16(name, uname);
+	DWORD len = GetEnvironmentVariableW(uname.c_str(), 0, 0);
+	if (len == 0) throw NotFoundException(name);
+	Buffer<wchar_t> buffer(len);
+	GetEnvironmentVariableW(uname.c_str(), buffer.begin(), len);
+	std::string result;
+	UnicodeConverter::toUTF8(buffer.begin(), len - 1, result);
+	return result;
+}
+
+
+bool EnvironmentImpl::hasImpl(const std::string& name)
+{
+	std::wstring uname;
+	UnicodeConverter::toUTF16(name, uname);
+	DWORD len = GetEnvironmentVariableW(uname.c_str(), 0, 0);
+	return len > 0;
+}
+
+
+void EnvironmentImpl::setImpl(const std::string& name, const std::string& value)
+{
+	std::wstring uname;
+	std::wstring uvalue;
+	UnicodeConverter::toUTF16(name, uname);
+	UnicodeConverter::toUTF16(value, uvalue);
+	if (SetEnvironmentVariableW(uname.c_str(), uvalue.c_str()) == 0)
+	{
+		std::string msg = "cannot set environment variable: ";
+		msg.append(name);
+		throw SystemException(msg);
+	}
+}
+
+
+std::string EnvironmentImpl::osNameImpl()
+{
+	OSVERSIONINFO vi;
+	vi.dwOSVersionInfoSize = sizeof(vi);
+	if (GetVersionEx(&vi) == 0) throw SystemException("Cannot get OS version information");
+	switch (vi.dwPlatformId)
+	{
+	case VER_PLATFORM_WIN32s:
+		return "Windows 3.x";
+	case VER_PLATFORM_WIN32_WINDOWS:
+		return vi.dwMinorVersion == 0 ? "Windows 95" : "Windows 98";
+	case VER_PLATFORM_WIN32_NT:
+		return "Windows NT";
+	default:
+		return "Unknown";
+	}
+}
+
+
+std::string EnvironmentImpl::osDisplayNameImpl()
+{
+	OSVERSIONINFOEX vi;	// OSVERSIONINFOEX is supported starting at Windows 2000 
+	vi.dwOSVersionInfoSize = sizeof(vi);
+	if (GetVersionEx((OSVERSIONINFO*) &vi) == 0) throw SystemException("Cannot get OS version information");
+	switch (vi.dwMajorVersion)
+	{
+	case 10:
+		switch (vi.dwMinorVersion)
+		{
+		case 0:
+			return vi.wProductType == VER_NT_WORKSTATION ? "Windows 10" : "Windows Server 2016";
+		}
+	case 6:
+		switch (vi.dwMinorVersion)
+		{
+		case 0:
+			return vi.wProductType == VER_NT_WORKSTATION ? "Windows Vista" : "Windows Server 2008";
+		case 1:
+			return vi.wProductType == VER_NT_WORKSTATION ? "Windows 7" : "Windows Server 2008 R2";
+		case 2:
+			return vi.wProductType == VER_NT_WORKSTATION ? "Windows 8" : "Windows Server 2012";
+		case 3:
+			return vi.wProductType == VER_NT_WORKSTATION ? "Windows 8.1" : "Windows Server 2012 R2";
+		default:
+			return "Unknown";
+		}
+	case 5:
+		switch (vi.dwMinorVersion)
+		{
+		case 0:
+			return "Windows 2000";
+		case 1:
+			return "Windows XP";
+		case 2:
+			return "Windows Server 2003/Windows Server 2003 R2";
+		default:
+			return "Unknown";
+		}
+	default:
+		return "Unknown";
+	}
+}
+
+
+std::string EnvironmentImpl::osVersionImpl()
+{
+	OSVERSIONINFOW vi;
+	vi.dwOSVersionInfoSize = sizeof(vi);
+	if (GetVersionExW(&vi) == 0) throw SystemException("Cannot get OS version information");
+	std::ostringstream str;
+	str << vi.dwMajorVersion << "." << vi.dwMinorVersion << " (Build " << (vi.dwBuildNumber & 0xFFFF);
+	std::string version;
+	UnicodeConverter::toUTF8(vi.szCSDVersion, version);
+	if (!version.empty()) str << ": " << version;
+	str << ")";
+	return str.str();
+}
+
+
+std::string EnvironmentImpl::osArchitectureImpl()
+{
+	SYSTEM_INFO si;
+	GetSystemInfo(&si);
+	switch (si.wProcessorArchitecture)
+	{
+	case PROCESSOR_ARCHITECTURE_INTEL:
+		return "IA32";
+	case PROCESSOR_ARCHITECTURE_MIPS:
+		return "MIPS";
+	case PROCESSOR_ARCHITECTURE_ALPHA:
+		return "ALPHA";
+	case PROCESSOR_ARCHITECTURE_PPC:
+		return "PPC";
+	case PROCESSOR_ARCHITECTURE_IA64:
+		return "IA64";
+#ifdef PROCESSOR_ARCHITECTURE_IA32_ON_WIN64
+	case PROCESSOR_ARCHITECTURE_IA32_ON_WIN64:
+		return "IA64/32";
+#endif
+#ifdef PROCESSOR_ARCHITECTURE_AMD64
+	case PROCESSOR_ARCHITECTURE_AMD64:
+		return "AMD64";
+#endif
+	default:
+		return "Unknown";
+	}
+}
+
+
+std::string EnvironmentImpl::nodeNameImpl()
+{
+	wchar_t name[MAX_COMPUTERNAME_LENGTH + 1];
+	DWORD size = MAX_COMPUTERNAME_LENGTH + 1;
+	if (GetComputerNameW(name, &size) == 0) throw SystemException("Cannot get computer name");
+	std::string result;
+	UnicodeConverter::toUTF8(name, result);
+	return result;
+}
+
+
+void EnvironmentImpl::nodeIdImpl(NodeId& id)
+{
+	std::memset(&id, 0, sizeof(id));
+
+	PIP_ADAPTER_INFO pAdapterInfo;
+	PIP_ADAPTER_INFO pAdapter = 0;
+	ULONG len    = sizeof(IP_ADAPTER_INFO);
+	pAdapterInfo = reinterpret_cast<IP_ADAPTER_INFO*>(new char[len]);
+	// Make an initial call to GetAdaptersInfo to get
+	// the necessary size into len
+	DWORD rc = GetAdaptersInfo(pAdapterInfo, &len);
+	if (rc == ERROR_BUFFER_OVERFLOW) 
+	{
+		delete [] reinterpret_cast<char*>(pAdapterInfo);
+		pAdapterInfo = reinterpret_cast<IP_ADAPTER_INFO*>(new char[len]);
+	}
+	else if (rc != ERROR_SUCCESS)
+	{
+		return;
+	}
+	if (GetAdaptersInfo(pAdapterInfo, &len) == NO_ERROR) 
+	{
+		pAdapter = pAdapterInfo;
+		bool found = false;
+		while (pAdapter && !found) 
+		{
+			if (pAdapter->Type == MIB_IF_TYPE_ETHERNET && pAdapter->AddressLength == sizeof(id))
+			{
+				found = true;
+				std::memcpy(&id, pAdapter->Address, pAdapter->AddressLength);
+			}
+			pAdapter = pAdapter->Next;
+		}
+	}
+	delete [] reinterpret_cast<char*>(pAdapterInfo);
+}
+
+
+unsigned EnvironmentImpl::processorCountImpl()
+{
+	SYSTEM_INFO si;
+	GetSystemInfo(&si);
+	return si.dwNumberOfProcessors;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Environment_WINCE.cpp b/base/poco/Foundation/src/Environment_WINCE.cpp
new file mode 100644
index 00000000000..afa59b68d35
--- /dev/null
+++ b/base/poco/Foundation/src/Environment_WINCE.cpp
@@ -0,0 +1,243 @@
+//
+// Environment_WINCE.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  Environment
+//
+// Copyright (c) 2009-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Environment_WINCE.h"
+#include "Poco/Exception.h"
+#include "Poco/UnicodeConverter.h"
+#include "Poco/String.h"
+#include "Poco/Path.h"
+#include "Poco/NumberFormatter.h"
+#include <sstream>
+#include <cstring>
+#include <windows.h>
+#include <iphlpapi.h>
+
+
+namespace Poco {
+
+
+const std::string EnvironmentImpl::TEMP("TEMP");
+const std::string EnvironmentImpl::TMP("TMP");
+const std::string EnvironmentImpl::HOMEPATH("HOMEPATH");
+const std::string EnvironmentImpl::COMPUTERNAME("COMPUTERNAME");
+const std::string EnvironmentImpl::OS("OS");
+const std::string EnvironmentImpl::NUMBER_OF_PROCESSORS("NUMBER_OF_PROCESSORS");
+const std::string EnvironmentImpl::PROCESSOR_ARCHITECTURE("PROCESSOR_ARCHITECTURE");
+
+
+std::string EnvironmentImpl::getImpl(const std::string& name)
+{
+	std::string value;
+	if (!envVar(name, &value)) throw NotFoundException(name);
+	return value;
+}
+
+
+bool EnvironmentImpl::hasImpl(const std::string& name)
+{
+	return envVar(name, 0);
+}
+
+
+void EnvironmentImpl::setImpl(const std::string& name, const std::string& value)
+{
+	throw NotImplementedException("Cannot set environment variables on Windows CE");
+}
+
+
+std::string EnvironmentImpl::osNameImpl()
+{
+	return "Windows CE";
+}
+
+
+std::string EnvironmentImpl::osDisplayNameImpl()
+{
+	return osNameImpl();
+}
+
+
+std::string EnvironmentImpl::osVersionImpl()
+{
+	OSVERSIONINFOW vi;
+	vi.dwOSVersionInfoSize = sizeof(vi);
+	if (GetVersionExW(&vi) == 0) throw SystemException("Cannot get OS version information");
+	std::ostringstream str;
+	str << vi.dwMajorVersion << "." << vi.dwMinorVersion << " (Build " << (vi.dwBuildNumber & 0xFFFF);
+	std::string version;
+	UnicodeConverter::toUTF8(vi.szCSDVersion, version);
+	if (!version.empty()) str << ": " << version;
+	str << ")";
+	return str.str();
+}
+
+
+std::string EnvironmentImpl::osArchitectureImpl()
+{
+	SYSTEM_INFO si;
+	GetSystemInfo(&si);
+	switch (si.wProcessorArchitecture)
+	{
+	case PROCESSOR_ARCHITECTURE_INTEL:
+		return "IA32";
+	case PROCESSOR_ARCHITECTURE_MIPS:
+		return "MIPS";
+	case PROCESSOR_ARCHITECTURE_ALPHA:
+		return "ALPHA";
+	case PROCESSOR_ARCHITECTURE_PPC:
+		return "PPC";
+	case PROCESSOR_ARCHITECTURE_IA64:
+		return "IA64";
+#ifdef PROCESSOR_ARCHITECTURE_IA32_ON_WIN64
+	case PROCESSOR_ARCHITECTURE_IA32_ON_WIN64:
+		return "IA64/32";
+#endif
+#ifdef PROCESSOR_ARCHITECTURE_AMD64
+	case PROCESSOR_ARCHITECTURE_AMD64:
+		return "AMD64";
+#endif
+	case PROCESSOR_ARCHITECTURE_SHX:
+		return "SHX";
+	case PROCESSOR_ARCHITECTURE_ARM:
+		return "ARM";
+	default:
+		return "Unknown";
+	}
+}
+
+
+std::string EnvironmentImpl::nodeNameImpl()
+{
+    HKEY hKey;
+	DWORD dwDisposition;
+    if (RegCreateKeyExW(HKEY_LOCAL_MACHINE, L"\\Ident", 0, 0, 0, 0, 0, &hKey, &dwDisposition) != ERROR_SUCCESS) 
+		throw SystemException("Cannot get node name", "registry key not found");
+
+	std::string value;
+    DWORD dwType;
+    BYTE bData[1026];
+    DWORD dwData = sizeof(bData);
+	if (RegQueryValueExW(hKey, L"Name", 0, &dwType, bData, &dwData) == ERROR_SUCCESS)
+	{
+		switch (dwType) 
+		{
+		case REG_SZ:
+			UnicodeConverter::toUTF8(reinterpret_cast<wchar_t*>(bData), value);
+			break;
+
+		default:
+			RegCloseKey(hKey);
+			throw SystemException("Cannot get node name", "registry value has wrong type");
+		}
+	}
+	else
+	{
+	    RegCloseKey(hKey);
+		throw SystemException("Cannot get node name", "registry value not found");
+	}
+    RegCloseKey(hKey);
+	return value;
+}
+
+
+void EnvironmentImpl::nodeIdImpl(NodeId& id)
+{
+	PIP_ADAPTER_INFO pAdapterInfo;
+	PIP_ADAPTER_INFO pAdapter = 0;
+	ULONG len    = sizeof(IP_ADAPTER_INFO);
+	pAdapterInfo = reinterpret_cast<IP_ADAPTER_INFO*>(new char[len]);
+	// Make an initial call to GetAdaptersInfo to get
+	// the necessary size into len
+	DWORD rc = GetAdaptersInfo(pAdapterInfo, &len);
+	if (rc == ERROR_BUFFER_OVERFLOW) 
+	{
+		delete [] reinterpret_cast<char*>(pAdapterInfo);
+		pAdapterInfo = reinterpret_cast<IP_ADAPTER_INFO*>(new char[len]);
+	}
+	else if (rc != ERROR_SUCCESS)
+	{
+		throw SystemException("cannot get network adapter list");
+	}
+	try
+	{
+		bool found = false;
+		if (GetAdaptersInfo(pAdapterInfo, &len) == NO_ERROR) 
+		{
+			pAdapter = pAdapterInfo;
+			while (pAdapter && !found) 
+			{
+				if (pAdapter->Type == MIB_IF_TYPE_ETHERNET && pAdapter->AddressLength == sizeof(id))
+				{
+					std::memcpy(&id, pAdapter->Address, pAdapter->AddressLength);
+					found = true;
+				}
+				pAdapter = pAdapter->Next;
+			}
+		}
+		else throw SystemException("cannot get network adapter list");
+		if (!found) throw SystemException("no Ethernet adapter found");
+	}
+	catch (Exception&)
+	{
+		delete [] reinterpret_cast<char*>(pAdapterInfo);
+		throw;
+	}
+	delete [] reinterpret_cast<char*>(pAdapterInfo);
+}
+
+
+unsigned EnvironmentImpl::processorCountImpl()
+{
+	SYSTEM_INFO si;
+	GetSystemInfo(&si);
+	return si.dwNumberOfProcessors;
+}
+
+
+bool EnvironmentImpl::envVar(const std::string& name, std::string* value)
+{
+	if (icompare(name, TEMP) == 0)
+	{
+		if (value) *value = Path::temp();
+	}
+	else if (icompare(name, TMP) == 0)
+	{
+		if (value) *value = Path::temp();
+	}
+	else if (icompare(name, HOMEPATH) == 0)
+	{
+		if (value) *value = Path::home();
+	}
+	else if (icompare(name, COMPUTERNAME) == 0)
+	{
+		if (value) *value = nodeNameImpl();
+	}
+	else if (icompare(name, OS) == 0)
+	{
+		if (value) *value = osNameImpl();
+	}
+	else if (icompare(name, NUMBER_OF_PROCESSORS) == 0)
+	{
+		if (value) *value = NumberFormatter::format(processorCountImpl());
+	}
+	else if (icompare(name, PROCESSOR_ARCHITECTURE) == 0)
+	{
+		if (value) *value = osArchitectureImpl();
+	}
+	else return false;
+	return true;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Error.cpp b/base/poco/Foundation/src/Error.cpp
new file mode 100644
index 00000000000..fbd3673f6bc
--- /dev/null
+++ b/base/poco/Foundation/src/Error.cpp
@@ -0,0 +1,117 @@
+//
+// Error.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  Error
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Foundation.h"
+#include "Poco/UnicodeConverter.h"
+#include "Poco/Error.h"
+#include <string>
+#include <string.h>
+#include <errno.h>
+
+
+namespace Poco {
+
+
+#ifdef POCO_OS_FAMILY_WINDOWS
+
+
+	DWORD Error::last()
+	{
+		return GetLastError();
+	}
+
+
+	std::string Error::getMessage(DWORD errorCode)
+	{
+		std::string errMsg;
+		DWORD dwFlg = FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS;
+	#if defined(POCO_WIN32_UTF8) && !defined(POCO_NO_WSTRING)
+		LPWSTR lpMsgBuf = 0;
+		if (FormatMessageW(dwFlg, 0, errorCode, 0, (LPWSTR) & lpMsgBuf, 0, NULL))
+			UnicodeConverter::toUTF8(lpMsgBuf, errMsg);
+	#else
+		LPTSTR lpMsgBuf = 0;
+		if (FormatMessageA(dwFlg, 0, errorCode, 0, (LPTSTR) & lpMsgBuf, 0, NULL))
+			errMsg = lpMsgBuf;
+	#endif
+		LocalFree(lpMsgBuf);
+		return errMsg;
+	}
+
+
+#else
+
+
+	int Error::last()
+	{
+		return errno;
+	}
+
+
+	class StrErrorHelper
+		/// This little hack magically handles all variants
+		/// of strerror_r() (POSIX and GLIBC) and strerror().
+	{
+	public:
+		explicit StrErrorHelper(int err)
+		{
+			_buffer[0] = 0;
+
+#if (_XOPEN_SOURCE >= 600) || POCO_OS == POCO_OS_ANDROID || __APPLE__
+			setMessage(strerror_r(err, _buffer, sizeof(_buffer)));
+#elif _GNU_SOURCE
+			setMessage(strerror_r(err, _buffer, sizeof(_buffer)));
+#else
+			setMessage(strerror(err));
+#endif		
+		}
+		
+		~StrErrorHelper()
+		{
+		}
+		
+		const std::string& message() const
+		{
+			return _message;
+		}
+		
+	protected:
+		void setMessage(int rc)
+			/// Handles POSIX variant
+		{
+			_message = _buffer;
+		}
+		
+		void setMessage(const char* msg)
+			/// Handles GLIBC variant
+		{
+			_message = msg;
+		}
+		
+	private:
+		char _buffer[256];
+		std::string _message;
+	};
+
+	std::string Error::getMessage(int errorCode)
+	{
+		StrErrorHelper helper(errorCode);
+		return helper.message();
+	}
+
+
+#endif
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/ErrorHandler.cpp b/base/poco/Foundation/src/ErrorHandler.cpp
new file mode 100644
index 00000000000..d0af8ea8a12
--- /dev/null
+++ b/base/poco/Foundation/src/ErrorHandler.cpp
@@ -0,0 +1,114 @@
+//
+// ErrorHandler.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  ErrorHandler
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/ErrorHandler.h"
+#include "Poco/SingletonHolder.h"
+
+
+namespace Poco {
+
+
+ErrorHandler* ErrorHandler::_pHandler = ErrorHandler::defaultHandler();
+FastMutex ErrorHandler::_mutex;
+
+
+ErrorHandler::ErrorHandler()
+{
+}
+
+
+ErrorHandler::~ErrorHandler()
+{
+}
+
+
+void ErrorHandler::exception(const Exception& exc)
+{
+	poco_debugger_msg(exc.what());
+}
+
+	
+void ErrorHandler::exception(const std::exception& exc)
+{
+	poco_debugger_msg(exc.what());
+}
+
+
+void ErrorHandler::exception()
+{
+	poco_debugger_msg("unknown exception");
+}
+
+
+void ErrorHandler::handle(const Exception& exc)
+{
+	FastMutex::ScopedLock lock(_mutex);
+	try
+	{
+		_pHandler->exception(exc);
+	}
+	catch (...)
+	{
+	}
+}
+
+	
+void ErrorHandler::handle(const std::exception& exc)
+{
+	FastMutex::ScopedLock lock(_mutex);
+	try
+	{
+		_pHandler->exception(exc);
+	}
+	catch (...)
+	{
+	}
+}
+
+
+void ErrorHandler::handle()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	try
+	{
+		_pHandler->exception();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+ErrorHandler* ErrorHandler::set(ErrorHandler* pHandler)
+{
+	poco_check_ptr(pHandler);
+
+	FastMutex::ScopedLock lock(_mutex);
+	ErrorHandler* pOld = _pHandler;
+	_pHandler = pHandler;
+	return pOld;
+}
+
+
+ErrorHandler* ErrorHandler::defaultHandler()
+{
+	// NOTE: Since this is called to initialize the static _pHandler
+	// variable, sh has to be a local static, otherwise we run
+	// into static initialization order issues.
+	static SingletonHolder<ErrorHandler> sh;
+	return sh.get();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Event.cpp b/base/poco/Foundation/src/Event.cpp
new file mode 100644
index 00000000000..c8e8fa0b9e1
--- /dev/null
+++ b/base/poco/Foundation/src/Event.cpp
@@ -0,0 +1,40 @@
+//
+// Event.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Event
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Event.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#include "Event_WIN32.cpp"
+#elif defined(POCO_VXWORKS)
+#include "Event_VX.cpp"
+#else
+#include "Event_POSIX.cpp"
+#endif
+
+
+namespace Poco {
+
+
+Event::Event(bool autoReset): EventImpl(autoReset)
+{
+}
+
+
+Event::~Event()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/EventArgs.cpp b/base/poco/Foundation/src/EventArgs.cpp
new file mode 100644
index 00000000000..f5be955ddf3
--- /dev/null
+++ b/base/poco/Foundation/src/EventArgs.cpp
@@ -0,0 +1,33 @@
+//
+// EventArgs.cpp
+//
+// Library: Foundation
+// Package: Events
+// Module:  EventArgs
+//
+// Implementation of EventArgs
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/EventArgs.h"
+
+
+namespace Poco {
+
+
+EventArgs::EventArgs()
+{
+}
+
+
+EventArgs::~EventArgs()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/EventChannel.cpp b/base/poco/Foundation/src/EventChannel.cpp
new file mode 100644
index 00000000000..dc5bce726a0
--- /dev/null
+++ b/base/poco/Foundation/src/EventChannel.cpp
@@ -0,0 +1,37 @@
+//
+// EventChannel.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  EventChannel
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/EventChannel.h"
+
+
+namespace Poco {
+
+
+EventChannel::EventChannel()
+{
+}
+
+
+EventChannel::~EventChannel()
+{
+}
+
+
+void EventChannel::log(const Message& msg)
+{
+	messageLogged(this, msg);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/EventLogChannel.cpp b/base/poco/Foundation/src/EventLogChannel.cpp
new file mode 100644
index 00000000000..ed4e25a6dc5
--- /dev/null
+++ b/base/poco/Foundation/src/EventLogChannel.cpp
@@ -0,0 +1,319 @@
+//
+// EventLogChannel.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  EventLogChannel
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/EventLogChannel.h"
+#include "Poco/Message.h"
+#include "Poco/String.h"
+#include "pocomsg.h"
+#if defined(POCO_WIN32_UTF8)
+#include "Poco/UnicodeConverter.h"
+#endif
+
+
+namespace Poco {
+
+
+const std::string EventLogChannel::PROP_NAME    = "name";
+const std::string EventLogChannel::PROP_HOST    = "host";
+const std::string EventLogChannel::PROP_LOGHOST = "loghost";
+const std::string EventLogChannel::PROP_LOGFILE = "logfile";
+
+
+EventLogChannel::EventLogChannel(): 
+	_logFile("Application"),
+	_h(0)
+{
+	const DWORD maxPathLen = MAX_PATH + 1;
+#if defined(POCO_WIN32_UTF8)
+	wchar_t name[maxPathLen];
+	int n = GetModuleFileNameW(NULL, name, maxPathLen);
+	if (n > 0)
+	{
+		wchar_t* end = name + n - 1;
+		while (end > name && *end != '\\') --end;
+		if (*end == '\\') ++end;
+		std::wstring uname(end);
+		UnicodeConverter::toUTF8(uname, _name);
+	}
+#else
+	char name[maxPathLen];
+	int n = GetModuleFileNameA(NULL, name, maxPathLen);
+	if (n > 0)
+	{
+		char* end = name + n - 1;
+		while (end > name && *end != '\\') --end;
+		if (*end == '\\') ++end;
+		_name = end;
+	}
+#endif
+}
+
+
+EventLogChannel::EventLogChannel(const std::string& name): 
+	_name(name), 
+	_logFile("Application"),
+	_h(0)
+{
+}
+
+
+EventLogChannel::EventLogChannel(const std::string& name, const std::string& host): 
+	_name(name), 
+	_host(host),
+	_logFile("Application"),
+	_h(0)
+{
+}
+
+
+EventLogChannel::~EventLogChannel()
+{
+	try
+	{
+		close();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void EventLogChannel::open()
+{
+	setUpRegistry();
+#if defined(POCO_WIN32_UTF8)
+	std::wstring uhost;
+	UnicodeConverter::toUTF16(_host, uhost);
+	std::wstring uname;
+	UnicodeConverter::toUTF16(_name, uname);
+	_h = RegisterEventSourceW(uhost.empty() ? NULL : uhost.c_str(), uname.c_str());
+#else
+	_h = RegisterEventSource(_host.empty() ? NULL : _host.c_str(), _name.c_str());
+#endif
+	if (!_h) throw SystemException("cannot register event source");
+}
+
+
+void EventLogChannel::close()
+{
+	if (_h) DeregisterEventSource(_h);
+	_h = 0;
+}
+
+
+void EventLogChannel::log(const Message& msg)
+{
+	if (!_h) open();
+#if defined(POCO_WIN32_UTF8)
+	std::wstring utext;
+	UnicodeConverter::toUTF16(msg.getText(), utext);
+	const wchar_t* pMsg = utext.c_str();
+	ReportEventW(_h, getType(msg), getCategory(msg), POCO_MSG_LOG, NULL, 1, 0, &pMsg, NULL); 
+#else
+	const char* pMsg = msg.getText().c_str();
+	ReportEvent(_h, getType(msg), getCategory(msg), POCO_MSG_LOG, NULL, 1, 0, &pMsg, NULL); 
+#endif
+}
+
+
+void EventLogChannel::setProperty(const std::string& name, const std::string& value)
+{
+	if (icompare(name, PROP_NAME) == 0)
+		_name = value;
+	else if (icompare(name, PROP_HOST) == 0)
+		_host = value;
+	else if (icompare(name, PROP_LOGHOST) == 0)
+		_host = value;
+	else if (icompare(name, PROP_LOGFILE) == 0)
+		_logFile = value;
+	else
+		Channel::setProperty(name, value);
+}
+
+
+std::string EventLogChannel::getProperty(const std::string& name) const
+{
+	if (icompare(name, PROP_NAME) == 0)
+		return _name;
+	else if (icompare(name, PROP_HOST) == 0)
+		return _host;
+	else if (icompare(name, PROP_LOGHOST) == 0)
+		return _host;
+	else if (icompare(name, PROP_LOGFILE) == 0)
+		return _logFile;
+	else
+		return Channel::getProperty(name);
+}
+
+
+int EventLogChannel::getType(const Message& msg)
+{
+	switch (msg.getPriority())
+	{
+	case Message::PRIO_TRACE:
+	case Message::PRIO_DEBUG:
+	case Message::PRIO_INFORMATION:
+		return EVENTLOG_INFORMATION_TYPE;
+	case Message::PRIO_NOTICE:
+	case Message::PRIO_WARNING:
+		return EVENTLOG_WARNING_TYPE;
+	default:
+		return EVENTLOG_ERROR_TYPE;
+	}
+}
+
+
+int EventLogChannel::getCategory(const Message& msg)
+{
+	switch (msg.getPriority())
+	{
+	case Message::PRIO_TRACE:
+		return POCO_CTG_TRACE;
+	case Message::PRIO_DEBUG:
+		return POCO_CTG_DEBUG;
+	case Message::PRIO_INFORMATION:
+		return POCO_CTG_INFORMATION;
+	case Message::PRIO_NOTICE:
+		return POCO_CTG_NOTICE;
+	case Message::PRIO_WARNING:
+		return POCO_CTG_WARNING;
+	case Message::PRIO_ERROR:
+		return POCO_CTG_ERROR;
+	case Message::PRIO_CRITICAL:
+		return POCO_CTG_CRITICAL;
+	case Message::PRIO_FATAL:
+		return POCO_CTG_FATAL;
+	default:
+		return 0;
+	}
+}
+
+
+void EventLogChannel::setUpRegistry() const
+{
+	std::string key = "SYSTEM\\CurrentControlSet\\Services\\EventLog\\";
+	key.append(_logFile);
+	key.append("\\");
+	key.append(_name);
+	HKEY hKey;
+	DWORD disp;
+#if defined(POCO_WIN32_UTF8)
+	std::wstring ukey;
+	UnicodeConverter::toUTF16(key, ukey);
+	DWORD rc = RegCreateKeyExW(HKEY_LOCAL_MACHINE, ukey.c_str(), 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &disp);
+#else
+	DWORD rc = RegCreateKeyEx(HKEY_LOCAL_MACHINE, key.c_str(), 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &disp);
+#endif
+	if (rc != ERROR_SUCCESS) return;
+	
+	if (disp == REG_CREATED_NEW_KEY)
+	{
+#if defined(POCO_WIN32_UTF8)
+		std::wstring path;
+		#if defined(POCO_DLL)
+			#if defined(_DEBUG)
+				#if defined(_WIN64)
+					path = findLibrary(L"PocoFoundation64d.dll");
+				#else
+					path = findLibrary(L"PocoFoundationd.dll");
+				#endif
+			#else
+				#if defined(_WIN64)
+					path = findLibrary(L"PocoFoundation64.dll");
+				#else
+					path = findLibrary(L"PocoFoundation.dll");
+				#endif
+			#endif
+		#endif
+		
+		if (path.empty())
+			path = findLibrary(L"PocoMsg.dll");
+#else
+		std::string path;
+		#if defined(POCO_DLL)
+			#if defined(_DEBUG)
+				#if defined(_WIN64)
+					path = findLibrary("PocoFoundation64d.dll");
+				#else
+					path = findLibrary("PocoFoundationd.dll");
+				#endif
+			#else
+				#if defined(_WIN64)
+					path = findLibrary("PocoFoundation64.dll");
+				#else
+					path = findLibrary("PocoFoundation.dll");
+				#endif
+			#endif
+		#endif
+		
+		if (path.empty())
+			path = findLibrary("PocoMsg.dll");
+#endif
+		
+		if (!path.empty())
+		{
+			DWORD count = 8;
+			DWORD types = 7;
+#if defined(POCO_WIN32_UTF8)
+			RegSetValueExW(hKey, L"CategoryMessageFile", 0, REG_SZ, (const BYTE*) path.c_str(), static_cast<DWORD>(sizeof(wchar_t)*(path.size() + 1)));
+			RegSetValueExW(hKey, L"EventMessageFile", 0, REG_SZ, (const BYTE*) path.c_str(), static_cast<DWORD>(sizeof(wchar_t)*(path.size() + 1)));
+			RegSetValueExW(hKey, L"CategoryCount", 0, REG_DWORD, (const BYTE*) &count, static_cast<DWORD>(sizeof(count)));
+			RegSetValueExW(hKey, L"TypesSupported", 0, REG_DWORD, (const BYTE*) &types, static_cast<DWORD>(sizeof(types)));
+#else
+			RegSetValueEx(hKey, "CategoryMessageFile", 0, REG_SZ, (const BYTE*) path.c_str(), static_cast<DWORD>(path.size() + 1));
+			RegSetValueEx(hKey, "EventMessageFile", 0, REG_SZ, (const BYTE*) path.c_str(), static_cast<DWORD>(path.size() + 1));
+			RegSetValueEx(hKey, "CategoryCount", 0, REG_DWORD, (const BYTE*) &count, static_cast<DWORD>(sizeof(count)));
+			RegSetValueEx(hKey, "TypesSupported", 0, REG_DWORD, (const BYTE*) &types, static_cast<DWORD>(sizeof(types)));
+#endif
+		}
+	}
+	RegCloseKey(hKey);
+}
+
+
+#if defined(POCO_WIN32_UTF8)
+std::wstring EventLogChannel::findLibrary(const wchar_t* name)
+{
+	std::wstring path;
+	HMODULE dll = LoadLibraryW(name);
+	if (dll)
+	{
+		const DWORD maxPathLen = MAX_PATH + 1;
+		wchar_t name[maxPathLen];
+		int n = GetModuleFileNameW(dll, name, maxPathLen);
+		if (n > 0) path = name;
+		FreeLibrary(dll);
+	}
+	return path;
+}
+#else
+std::string EventLogChannel::findLibrary(const char* name)
+{
+	std::string path;
+	HMODULE dll = LoadLibraryA(name);
+	if (dll)
+	{
+		const DWORD maxPathLen = MAX_PATH + 1;
+		char name[maxPathLen];
+		int n = GetModuleFileNameA(dll, name, maxPathLen);
+		if (n > 0) path = name;
+		FreeLibrary(dll);
+	}
+	return path;
+}
+#endif
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Event_POSIX.cpp b/base/poco/Foundation/src/Event_POSIX.cpp
new file mode 100644
index 00000000000..50fb6f78a82
--- /dev/null
+++ b/base/poco/Foundation/src/Event_POSIX.cpp
@@ -0,0 +1,170 @@
+//
+// Event_POSIX.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Event
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Event_POSIX.h"
+#if defined(POCO_VXWORKS)
+#include <timers.h>
+#include <cstring>
+#else
+#include <time.h>
+#include <sys/time.h>
+#endif
+
+
+//
+// Note: pthread_cond_timedwait() with CLOCK_MONOTONIC is supported
+// on Linux and QNX, as well as on Android >= 5.0 (API level 21).
+// On Android < 5.0, HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC is defined
+// to indicate availability of non-standard pthread_cond_timedwait_monotonic().
+//
+#ifndef POCO_HAVE_MONOTONIC_PTHREAD_COND_TIMEDWAIT
+	#if (defined(__linux__) || defined(__QNX__)) && !(defined(__ANDROID__) && (defined(HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC) || __ANDROID_API__ <= 21))
+		#define POCO_HAVE_MONOTONIC_PTHREAD_COND_TIMEDWAIT 1
+	#endif
+#endif
+
+
+#ifndef POCO_HAVE_CLOCK_GETTIME
+	#if (defined(_POSIX_TIMERS) && defined(CLOCK_REALTIME)) || defined(POCO_VXWORKS) || defined(__QNX__)
+		#ifndef __APPLE__ // See GitHub issue #1453 - not available before Mac OS 10.12/iOS 10
+			#define POCO_HAVE_CLOCK_GETTIME
+		#endif
+	#endif
+#endif
+
+
+namespace Poco {
+
+
+EventImpl::EventImpl(bool autoReset): _auto(autoReset), _state(false)
+{
+#if defined(POCO_VXWORKS)
+	// This workaround is for VxWorks 5.x where
+	// pthread_mutex_init() won't properly initialize the mutex
+	// resulting in a subsequent freeze in pthread_mutex_destroy()
+	// if the mutex has never been used.
+	std::memset(&_mutex, 0, sizeof(_mutex));
+#endif
+
+	if (pthread_mutex_init(&_mutex, NULL))
+		throw SystemException("cannot create event (mutex)");
+
+#if defined(POCO_HAVE_MONOTONIC_PTHREAD_COND_TIMEDWAIT)
+	pthread_condattr_t attr;
+	if (pthread_condattr_init(&attr))
+	{
+		pthread_mutex_destroy(&_mutex);
+		throw SystemException("cannot create event (condition attribute)");
+	}
+	if (pthread_condattr_setclock(&attr, CLOCK_MONOTONIC))
+    {
+		pthread_condattr_destroy(&attr);
+		pthread_mutex_destroy(&_mutex);
+		throw SystemException("cannot create event (condition attribute clock)");
+    }
+	if (pthread_cond_init(&_cond, &attr))
+	{
+		pthread_condattr_destroy(&attr);
+		pthread_mutex_destroy(&_mutex);
+		throw SystemException("cannot create event (condition)");
+	}
+	pthread_condattr_destroy(&attr);
+#else
+	if (pthread_cond_init(&_cond, NULL))
+	{
+		pthread_mutex_destroy(&_mutex);
+		throw SystemException("cannot create event (condition)");
+	}
+#endif
+}
+
+
+EventImpl::~EventImpl()
+{
+	pthread_cond_destroy(&_cond);
+	pthread_mutex_destroy(&_mutex);
+}
+
+
+void EventImpl::waitImpl()
+{
+	if (pthread_mutex_lock(&_mutex))
+		throw SystemException("wait for event failed (lock)");
+	while (!_state)
+	{
+		if (pthread_cond_wait(&_cond, &_mutex))
+		{
+			pthread_mutex_unlock(&_mutex);
+			throw SystemException("wait for event failed");
+		}
+	}
+	if (_auto)
+		_state = false;
+	pthread_mutex_unlock(&_mutex);
+}
+
+
+bool EventImpl::waitImpl(long milliseconds)
+{
+	int rc = 0;
+	struct timespec abstime;
+
+#if defined(POCO_HAVE_MONOTONIC_PTHREAD_COND_TIMEDWAIT)
+	clock_gettime(CLOCK_MONOTONIC, &abstime);
+	abstime.tv_sec  += milliseconds / 1000;
+	abstime.tv_nsec += (milliseconds % 1000)*1000000;
+	if (abstime.tv_nsec >= 1000000000)
+	{
+		abstime.tv_nsec -= 1000000000;
+		abstime.tv_sec++;
+	}
+#elif defined(POCO_HAVE_CLOCK_GETTIME)
+	clock_gettime(CLOCK_REALTIME, &abstime);
+	abstime.tv_sec  += milliseconds / 1000;
+	abstime.tv_nsec += (milliseconds % 1000)*1000000;
+	if (abstime.tv_nsec >= 1000000000)
+	{
+		abstime.tv_nsec -= 1000000000;
+		abstime.tv_sec++;
+	}
+#else
+	struct timeval tv;
+	gettimeofday(&tv, NULL);
+	abstime.tv_sec  = tv.tv_sec + milliseconds / 1000;
+	abstime.tv_nsec = tv.tv_usec*1000 + (milliseconds % 1000)*1000000;
+	if (abstime.tv_nsec >= 1000000000)
+	{
+		abstime.tv_nsec -= 1000000000;
+		abstime.tv_sec++;
+	}
+#endif
+
+	if (pthread_mutex_lock(&_mutex) != 0)
+		throw SystemException("wait for event failed (lock)");
+	while (!_state)
+	{
+		if ((rc = pthread_cond_timedwait(&_cond, &_mutex, &abstime)))
+		{
+			if (rc == ETIMEDOUT) break;
+			pthread_mutex_unlock(&_mutex);
+			throw SystemException("cannot wait for event");
+		}
+	}
+	if (rc == 0 && _auto) _state = false;
+	pthread_mutex_unlock(&_mutex);
+	return rc == 0;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Event_VX.cpp b/base/poco/Foundation/src/Event_VX.cpp
new file mode 100644
index 00000000000..18f667156ed
--- /dev/null
+++ b/base/poco/Foundation/src/Event_VX.cpp
@@ -0,0 +1,79 @@
+//
+// Event_POSIX.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Event
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Event_VX.h"
+#include <sysLib.h>
+
+
+namespace Poco {
+
+
+EventImpl::EventImpl(bool autoReset): _auto(autoReset), _state(false)
+{
+	_sem = semCCreate(SEM_Q_PRIORITY, 0);
+	if (_sem == 0)
+		throw Poco::SystemException("cannot create event");
+}
+
+
+EventImpl::~EventImpl()
+{
+	semDelete(_sem);
+}
+
+
+void EventImpl::setImpl()
+{
+	if (_auto)
+	{
+		if (semGive(_sem) != OK)
+			throw SystemException("cannot set event");
+	}
+	else
+	{
+		_state = true;
+		if (semFlush(_sem) != OK)
+			throw SystemException("cannot set event");
+	}
+}
+
+
+void EventImpl::resetImpl()
+{
+	_state = false;
+}
+
+
+void EventImpl::waitImpl()
+{
+	if (!_state)
+	{
+		if (semTake(_sem, WAIT_FOREVER) != OK)
+			throw SystemException("cannot wait for event");
+	}
+}
+
+
+bool EventImpl::waitImpl(long milliseconds)
+{
+	if (!_state)
+	{
+		int ticks = milliseconds*sysClkRateGet()/1000;
+		return semTake(_sem, ticks) == OK;
+	}
+	else return true;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Event_WIN32.cpp b/base/poco/Foundation/src/Event_WIN32.cpp
new file mode 100644
index 00000000000..256951870a9
--- /dev/null
+++ b/base/poco/Foundation/src/Event_WIN32.cpp
@@ -0,0 +1,61 @@
+//
+// Event_WIN32.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Event
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Event_WIN32.h"
+
+
+namespace Poco {
+
+
+EventImpl::EventImpl(bool autoReset)
+{
+	_event = CreateEventW(NULL, autoReset ? FALSE : TRUE, FALSE, NULL);
+	if (!_event)
+		throw SystemException("cannot create event");
+}
+
+
+EventImpl::~EventImpl()
+{
+	CloseHandle(_event);
+}
+
+
+void EventImpl::waitImpl()
+{
+	switch (WaitForSingleObject(_event, INFINITE))
+	{
+	case WAIT_OBJECT_0:
+		return;
+	default:
+		throw SystemException("wait for event failed");
+	}
+}
+
+
+bool EventImpl::waitImpl(long milliseconds)
+{
+	switch (WaitForSingleObject(_event, milliseconds + 1))
+	{
+	case WAIT_TIMEOUT:
+		return false;
+	case WAIT_OBJECT_0:
+		return true;
+	default:
+		throw SystemException("wait for event failed");		
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Exception.cpp b/base/poco/Foundation/src/Exception.cpp
new file mode 100644
index 00000000000..535b49222ef
--- /dev/null
+++ b/base/poco/Foundation/src/Exception.cpp
@@ -0,0 +1,185 @@
+//
+// Exception.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  Exception
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Exception.h"
+#include <typeinfo>
+
+
+namespace Poco {
+
+
+Exception::Exception(int code): _pNested(0), _code(code)
+{
+}
+
+
+Exception::Exception(const std::string& msg, int code): _msg(msg), _pNested(0), _code(code)
+{
+}
+
+Exception::Exception(std::string&& msg, int code): _msg(msg), _pNested(0), _code(code)
+{
+}
+
+
+Exception::Exception(const std::string& msg, const std::string& arg, int code): _msg(msg), _pNested(0), _code(code)
+{
+	if (!arg.empty())
+	{
+		_msg.append(": ");
+		_msg.append(arg);
+	}
+}
+
+
+Exception::Exception(const std::string& msg, const Exception& nested, int code): _msg(msg), _pNested(nested.clone()), _code(code)
+{
+}
+
+
+Exception::Exception(const Exception& exc):
+	std::exception(exc),
+	_msg(exc._msg),
+	_code(exc._code)
+{
+	_pNested = exc._pNested ? exc._pNested->clone() : 0;
+}
+
+	
+Exception::~Exception() throw()
+{
+	delete _pNested;
+}
+
+
+Exception& Exception::operator = (const Exception& exc)
+{
+	if (&exc != this)
+	{
+		Exception* newPNested = exc._pNested ? exc._pNested->clone() : 0;
+		delete _pNested;
+		_msg     = exc._msg;
+		_pNested = newPNested;
+		_code    = exc._code;
+	}
+	return *this;
+}
+
+
+const char* Exception::name() const throw()
+{
+	return "Exception";
+}
+
+
+const char* Exception::className() const throw()
+{
+	return typeid(*this).name();
+}
+
+	
+const char* Exception::what() const throw()
+{
+	return name();
+}
+
+	
+std::string Exception::displayText() const
+{
+	std::string txt = name();
+	if (!_msg.empty())
+	{
+		txt.append(": ");
+		txt.append(_msg);
+	}
+	return txt;
+}
+
+
+void Exception::extendedMessage(const std::string& arg)
+{
+	if (!arg.empty())
+	{
+		if (!_msg.empty()) _msg.append(": ");
+		_msg.append(arg);
+	}
+}
+
+
+Exception* Exception::clone() const
+{
+	return new Exception(*this);
+}
+
+
+void Exception::rethrow() const
+{
+	throw *this;
+}
+
+
+POCO_IMPLEMENT_EXCEPTION(LogicException, Exception, "Logic exception")
+POCO_IMPLEMENT_EXCEPTION(AssertionViolationException, LogicException, "Assertion violation")
+POCO_IMPLEMENT_EXCEPTION(NullPointerException, LogicException, "Null pointer")
+POCO_IMPLEMENT_EXCEPTION(NullValueException, LogicException, "Null value")
+POCO_IMPLEMENT_EXCEPTION(BugcheckException, LogicException, "Bugcheck")
+POCO_IMPLEMENT_EXCEPTION(InvalidArgumentException, LogicException, "Invalid argument")
+POCO_IMPLEMENT_EXCEPTION(NotImplementedException, LogicException, "Not implemented")
+POCO_IMPLEMENT_EXCEPTION(RangeException, LogicException, "Out of range")
+POCO_IMPLEMENT_EXCEPTION(IllegalStateException, LogicException, "Illegal state")
+POCO_IMPLEMENT_EXCEPTION(InvalidAccessException, LogicException, "Invalid access")
+POCO_IMPLEMENT_EXCEPTION(SignalException, LogicException, "Signal received")
+POCO_IMPLEMENT_EXCEPTION(UnhandledException, LogicException, "Unhandled exception")
+
+POCO_IMPLEMENT_EXCEPTION(RuntimeException, Exception, "Runtime exception")
+POCO_IMPLEMENT_EXCEPTION(NotFoundException, RuntimeException, "Not found")
+POCO_IMPLEMENT_EXCEPTION(ExistsException, RuntimeException, "Exists")
+POCO_IMPLEMENT_EXCEPTION(TimeoutException, RuntimeException, "Timeout")
+POCO_IMPLEMENT_EXCEPTION(SystemException, RuntimeException, "System exception")
+POCO_IMPLEMENT_EXCEPTION(RegularExpressionException, RuntimeException, "Error in regular expression")
+POCO_IMPLEMENT_EXCEPTION(LibraryLoadException, RuntimeException, "Cannot load library")
+POCO_IMPLEMENT_EXCEPTION(LibraryAlreadyLoadedException, RuntimeException, "Library already loaded")
+POCO_IMPLEMENT_EXCEPTION(NoThreadAvailableException, RuntimeException, "No thread available")
+POCO_IMPLEMENT_EXCEPTION(PropertyNotSupportedException, RuntimeException, "Property not supported")
+POCO_IMPLEMENT_EXCEPTION(PoolOverflowException, RuntimeException, "Pool overflow")
+POCO_IMPLEMENT_EXCEPTION(NoPermissionException, RuntimeException, "No permission")
+POCO_IMPLEMENT_EXCEPTION(OutOfMemoryException, RuntimeException, "Out of memory")
+POCO_IMPLEMENT_EXCEPTION(DataException, RuntimeException, "Data error")
+
+POCO_IMPLEMENT_EXCEPTION(DataFormatException, DataException, "Bad data format")
+POCO_IMPLEMENT_EXCEPTION(SyntaxException, DataException, "Syntax error")
+POCO_IMPLEMENT_EXCEPTION(CircularReferenceException, DataException, "Circular reference")
+POCO_IMPLEMENT_EXCEPTION(PathSyntaxException, SyntaxException, "Bad path syntax")
+POCO_IMPLEMENT_EXCEPTION(IOException, RuntimeException, "I/O error")
+POCO_IMPLEMENT_EXCEPTION(ProtocolException, IOException, "Protocol error")
+POCO_IMPLEMENT_EXCEPTION(FileException, IOException, "File access error")
+POCO_IMPLEMENT_EXCEPTION(FileExistsException, FileException, "File exists")
+POCO_IMPLEMENT_EXCEPTION(FileNotFoundException, FileException, "File not found")
+POCO_IMPLEMENT_EXCEPTION(PathNotFoundException, FileException, "Path not found")
+POCO_IMPLEMENT_EXCEPTION(FileReadOnlyException, FileException, "File is read-only")
+POCO_IMPLEMENT_EXCEPTION(FileAccessDeniedException, FileException, "Access to file denied")
+POCO_IMPLEMENT_EXCEPTION(CreateFileException, FileException, "Cannot create file")
+POCO_IMPLEMENT_EXCEPTION(OpenFileException, FileException, "Cannot open file")
+POCO_IMPLEMENT_EXCEPTION(WriteFileException, FileException, "Cannot write file")
+POCO_IMPLEMENT_EXCEPTION(ReadFileException, FileException, "Cannot read file")
+POCO_IMPLEMENT_EXCEPTION(DirectoryNotEmptyException, FileException, "Directory not empty")
+POCO_IMPLEMENT_EXCEPTION(UnknownURISchemeException, RuntimeException, "Unknown URI scheme")
+POCO_IMPLEMENT_EXCEPTION(TooManyURIRedirectsException, RuntimeException, "Too many URI redirects")
+POCO_IMPLEMENT_EXCEPTION(URISyntaxException, SyntaxException, "Bad URI syntax")
+
+POCO_IMPLEMENT_EXCEPTION(ApplicationException, Exception, "Application exception")
+POCO_IMPLEMENT_EXCEPTION(BadCastException, RuntimeException, "Bad cast exception")
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/FIFOBufferStream.cpp b/base/poco/Foundation/src/FIFOBufferStream.cpp
new file mode 100644
index 00000000000..232bc4811e8
--- /dev/null
+++ b/base/poco/Foundation/src/FIFOBufferStream.cpp
@@ -0,0 +1,186 @@
+//
+// FIFOBufferStream.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  FIFOBufferStream
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/FIFOBufferStream.h"
+
+
+namespace Poco {
+
+
+//
+// FIFOBufferStreamBuf
+//
+
+
+FIFOBufferStreamBuf::FIFOBufferStreamBuf():
+	BufferedBidirectionalStreamBuf(STREAM_BUFFER_SIZE + 4, std::ios::in | std::ios::out),
+	_pFIFOBuffer(new FIFOBuffer(STREAM_BUFFER_SIZE, true)),
+	_fifoBuffer(*_pFIFOBuffer)
+{
+}
+
+
+FIFOBufferStreamBuf::FIFOBufferStreamBuf(FIFOBuffer& fifoBuffer):
+	BufferedBidirectionalStreamBuf(fifoBuffer.size() + 4, std::ios::in | std::ios::out),
+	_pFIFOBuffer(0),
+	_fifoBuffer(fifoBuffer)
+{
+	fifoBuffer.setNotify(true);
+}
+
+
+FIFOBufferStreamBuf::FIFOBufferStreamBuf(char* pBuffer, std::size_t length):
+	BufferedBidirectionalStreamBuf(length + 4, std::ios::in | std::ios::out),
+	_pFIFOBuffer(new FIFOBuffer(pBuffer, length, true)),
+	_fifoBuffer(*_pFIFOBuffer)
+{
+}
+
+
+FIFOBufferStreamBuf::FIFOBufferStreamBuf(const char* pBuffer, std::size_t length):
+	BufferedBidirectionalStreamBuf(length + 4, std::ios::in | std::ios::out),
+	_pFIFOBuffer(new FIFOBuffer(pBuffer, length, true)),
+	_fifoBuffer(*_pFIFOBuffer)
+{
+}
+
+
+FIFOBufferStreamBuf::FIFOBufferStreamBuf(std::size_t length):
+	BufferedBidirectionalStreamBuf(length + 4, std::ios::in | std::ios::out),
+	_pFIFOBuffer(new FIFOBuffer(length, true)),
+	_fifoBuffer(*_pFIFOBuffer)
+{
+}
+
+
+FIFOBufferStreamBuf::~FIFOBufferStreamBuf()
+{
+	delete _pFIFOBuffer;
+}
+
+
+int FIFOBufferStreamBuf::readFromDevice(char* buffer, std::streamsize length)
+{
+	poco_assert (length > 0);
+	return static_cast<int>(_fifoBuffer.read(buffer, static_cast<std::size_t>(length)));
+}
+
+
+int FIFOBufferStreamBuf::writeToDevice(const char* buffer, std::streamsize length)
+{
+	poco_assert (length > 0);
+	return static_cast<int>(_fifoBuffer.write(buffer, static_cast<std::size_t>(length)));
+}
+
+
+//
+// FIFOIOS
+//
+
+
+FIFOIOS::FIFOIOS(FIFOBuffer& fifoBuffer): _buf(fifoBuffer)
+{
+	poco_ios_init(&_buf);
+}
+
+
+FIFOIOS::FIFOIOS(char* pBuffer, std::size_t length): _buf(pBuffer, length)
+{
+	poco_ios_init(&_buf);
+}
+
+
+FIFOIOS::FIFOIOS(const char* pBuffer, std::size_t length): _buf(pBuffer, length)
+{
+	poco_ios_init(&_buf);
+}
+
+
+FIFOIOS::FIFOIOS(std::size_t length): _buf(length)
+{
+	poco_ios_init(&_buf);
+}
+
+
+FIFOIOS::~FIFOIOS()
+{
+	try
+	{
+		_buf.sync();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+FIFOBufferStreamBuf* FIFOIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+void FIFOIOS::close()
+{
+	_buf.sync();
+}
+
+
+//
+// FIFOBufferStream
+//
+
+
+FIFOBufferStream::FIFOBufferStream(FIFOBuffer& fifoBuffer):
+	FIFOIOS(fifoBuffer),
+    std::iostream(&_buf),
+	readable(_buf.fifoBuffer().readable),
+	writable(_buf.fifoBuffer().writable)
+{
+}
+
+
+FIFOBufferStream::FIFOBufferStream(char* pBuffer, std::size_t length):
+	FIFOIOS(pBuffer, length),
+    std::iostream(&_buf),
+	readable(_buf.fifoBuffer().readable),
+	writable(_buf.fifoBuffer().writable)
+{
+}
+
+
+FIFOBufferStream::FIFOBufferStream(const char* pBuffer, std::size_t length):
+	FIFOIOS(pBuffer, length),
+    std::iostream(&_buf),
+	readable(_buf.fifoBuffer().readable),
+	writable(_buf.fifoBuffer().writable)
+{
+}
+
+
+FIFOBufferStream::FIFOBufferStream(std::size_t length):
+	FIFOIOS(length),
+    std::iostream(&_buf),
+	readable(_buf.fifoBuffer().readable),
+	writable(_buf.fifoBuffer().writable)
+{
+}
+
+
+FIFOBufferStream::~FIFOBufferStream()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/FPEnvironment.cpp b/base/poco/Foundation/src/FPEnvironment.cpp
new file mode 100644
index 00000000000..4617b7841a0
--- /dev/null
+++ b/base/poco/Foundation/src/FPEnvironment.cpp
@@ -0,0 +1,83 @@
+//
+// FPEnvironment.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  FPEnvironment
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+// pull in platform identification macros needed below
+#include "Poco/Platform.h"
+#include "Poco/FPEnvironment.h"
+
+
+#if defined(POCO_NO_FPENVIRONMENT)
+#include "FPEnvironment_DUMMY.cpp"
+#elif defined(__osf__)
+#include "FPEnvironment_DEC.cpp"
+#elif defined(sun) || defined(__sun)
+#include "FPEnvironment_SUN.cpp"
+#elif defined(__QNX__)
+#include "FPEnvironment_QNX.cpp"
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include "FPEnvironment_C99.cpp"
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "FPEnvironment_WIN32.cpp"
+#else
+#include "FPEnvironment_DUMMY.cpp"
+#endif
+
+
+namespace Poco {
+
+
+FPEnvironment::FPEnvironment()
+{
+}
+
+
+FPEnvironment::FPEnvironment(RoundingMode rm)
+{
+	setRoundingMode(rm);
+}
+
+
+FPEnvironment::FPEnvironment(const FPEnvironment& env): FPEnvironmentImpl(env)
+{
+}
+
+
+FPEnvironment::~FPEnvironment()
+{
+}
+
+
+FPEnvironment& FPEnvironment::operator = (const FPEnvironment& env)
+{
+	if (&env != this)
+	{
+		FPEnvironmentImpl::operator = (env);
+	}
+	return *this;
+}
+
+
+void FPEnvironment::keepCurrent()
+{
+	keepCurrentImpl();
+}
+
+
+void FPEnvironment::clearFlags()
+{
+	clearFlagsImpl();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/FPEnvironment_C99.cpp b/base/poco/Foundation/src/FPEnvironment_C99.cpp
new file mode 100644
index 00000000000..4bd3e31ba93
--- /dev/null
+++ b/base/poco/Foundation/src/FPEnvironment_C99.cpp
@@ -0,0 +1,82 @@
+//
+// FPEnvironment_C99.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  FPEnvironment
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/FPEnvironment_C99.h"
+
+
+namespace Poco {
+
+
+FPEnvironmentImpl::FPEnvironmentImpl()
+{
+	fegetenv(&_env);
+}
+
+
+FPEnvironmentImpl::FPEnvironmentImpl(const FPEnvironmentImpl& env)
+{
+	_env = env._env;
+}
+
+
+FPEnvironmentImpl::~FPEnvironmentImpl()
+{
+	fesetenv(&_env);
+}
+
+
+FPEnvironmentImpl& FPEnvironmentImpl::operator = (const FPEnvironmentImpl& env)
+{
+	_env = env._env;
+	return *this;
+}
+
+
+void FPEnvironmentImpl::keepCurrentImpl()
+{
+	fegetenv(&_env);
+}
+
+
+void FPEnvironmentImpl::clearFlagsImpl()
+{
+	feclearexcept(FE_ALL_EXCEPT);
+}
+
+
+bool FPEnvironmentImpl::isFlagImpl(FlagImpl flag)
+{
+	return fetestexcept(flag) != 0;
+}
+
+
+void FPEnvironmentImpl::setRoundingModeImpl(RoundingModeImpl mode)
+{
+	fesetround(mode);
+}
+
+
+FPEnvironmentImpl::RoundingModeImpl FPEnvironmentImpl::getRoundingModeImpl()
+{
+	return (RoundingModeImpl) fegetround();
+}
+
+
+long double FPEnvironmentImpl::copySignImpl(long double target, long double source)
+{
+	return (source >= 0 && target >= 0) || (source < 0 && target < 0) ? target : -target;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/FPEnvironment_DEC.cpp b/base/poco/Foundation/src/FPEnvironment_DEC.cpp
new file mode 100644
index 00000000000..037e28df76c
--- /dev/null
+++ b/base/poco/Foundation/src/FPEnvironment_DEC.cpp
@@ -0,0 +1,195 @@
+//
+// FPEnvironment_DEC.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  FPEnvironment
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+//
+// _XOPEN_SOURCE disables the ieee fp functions
+// in <math.h>, therefore we undefine it for this file.
+//
+#undef _XOPEN_SOURCE
+
+
+#include <math.h>
+#include <fp.h>
+#include <fp_class.h>
+#if defined(__VMS)
+#include <starlet.h>
+#endif
+#include "Poco/FPEnvironment_DEC.h"
+
+
+namespace Poco {
+
+
+FPEnvironmentImpl::FPEnvironmentImpl()
+{
+#if defined(__VMS)
+	#pragma pointer_size save
+	#pragma pointer_size 32
+	struct _ieee env;
+	sys$ieee_set_fp_control(0, 0, &env);
+	#pragma pointer_size restore
+	_env = env;
+#else
+	_env = ieee_get_fp_control();
+#endif
+}
+
+
+FPEnvironmentImpl::FPEnvironmentImpl(const FPEnvironmentImpl& env)
+{
+	_env = env._env;
+}
+
+
+FPEnvironmentImpl::~FPEnvironmentImpl()
+{
+#if defined(__VMS)
+	#pragma pointer_size save
+	#pragma pointer_size 32
+	struct _ieee mask;
+	mask.ieee$q_flags = 0xFFFFFFFFFFFFFFFF;
+	struct _ieee env = _env;
+	sys$ieee_set_fp_control(&mask, &env, 0);
+	#pragma pointer_size restore
+#else
+	ieee_set_fp_control(_env);
+#endif
+}
+
+
+FPEnvironmentImpl& FPEnvironmentImpl::operator = (const FPEnvironmentImpl& env)
+{
+	_env = env._env;
+	return *this;
+}
+
+
+bool FPEnvironmentImpl::isInfiniteImpl(float value)
+{
+	int cls = fp_classf(value);
+	return cls == FP_POS_INF || cls == FP_NEG_INF;
+}
+
+
+bool FPEnvironmentImpl::isInfiniteImpl(double value)
+{
+	int cls = fp_class(value);
+	return cls == FP_POS_INF || cls == FP_NEG_INF;
+}
+
+
+bool FPEnvironmentImpl::isInfiniteImpl(long double value)
+{
+	int cls = fp_classl(value);
+	return cls == FP_POS_INF || cls == FP_NEG_INF;
+}
+
+
+bool FPEnvironmentImpl::isNaNImpl(float value)
+{
+	return isnanf(value) != 0;
+}
+
+
+bool FPEnvironmentImpl::isNaNImpl(double value)
+{
+	return isnan(value) != 0;
+}
+
+
+bool FPEnvironmentImpl::isNaNImpl(long double value)
+{
+	return isnanl(value) != 0;
+}
+
+
+float FPEnvironmentImpl::copySignImpl(float target, float source)
+{
+	return copysignf(target, source);
+}
+
+
+double FPEnvironmentImpl::copySignImpl(double target, double source)
+{
+	return copysign(target, source);
+}
+
+
+long double FPEnvironmentImpl::copySignImpl(long double target, long double source)
+{
+	return copysignl(target, source);
+}
+
+
+void FPEnvironmentImpl::keepCurrentImpl()
+{
+#if defined(__VMS)
+	#pragma pointer_size save
+	#pragma pointer_size 32
+	struct _ieee env;
+	sys$ieee_set_fp_control(0, 0, &env);
+	#pragma pointer_size restore
+	_env = env;
+#else
+	ieee_set_fp_control(_env);
+#endif
+}
+
+
+void FPEnvironmentImpl::clearFlagsImpl()
+{
+#if defined(__VMS)
+	#pragma pointer_size save
+	#pragma pointer_size 32
+	struct _ieee mask;
+	mask.ieee$q_flags = 0xFFFFFFFFFFFFFFFF;
+	struct _ieee clr;
+	clr.ieee$q_flags  = 0;
+	sys$ieee_set_fp_control(&mask, &clr, 0);
+	#pragma pointer_size restore
+#else
+	ieee_set_fp_control(0);
+#endif
+}
+
+
+bool FPEnvironmentImpl::isFlagImpl(FlagImpl flag)
+{
+#if defined(__VMS)
+	#pragma pointer_size save
+	#pragma pointer_size 32
+	struct _ieee flags;
+	sys$ieee_set_fp_control(0, 0, &flags);
+	return (flags.ieee$q_flags & flag) != 0;
+	#pragma pointer_size restore
+#else
+	return (ieee_get_fp_control() & flag) != 0;
+#endif
+}
+
+
+void FPEnvironmentImpl::setRoundingModeImpl(RoundingModeImpl mode)
+{
+	// not supported
+}
+
+
+FPEnvironmentImpl::RoundingModeImpl FPEnvironmentImpl::getRoundingModeImpl()
+{
+	// not supported
+	return FPEnvironmentImpl::RoundingModeImpl(0);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/FPEnvironment_DUMMY.cpp b/base/poco/Foundation/src/FPEnvironment_DUMMY.cpp
new file mode 100644
index 00000000000..b473d0dfb93
--- /dev/null
+++ b/base/poco/Foundation/src/FPEnvironment_DUMMY.cpp
@@ -0,0 +1,79 @@
+//
+// FPEnvironment_C99.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  FPEnvironment
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/FPEnvironment_DUMMY.h"
+
+
+namespace Poco {
+
+
+FPEnvironmentImpl::RoundingModeImpl FPEnvironmentImpl::_roundingMode;
+
+
+FPEnvironmentImpl::FPEnvironmentImpl()
+{
+}
+
+
+FPEnvironmentImpl::FPEnvironmentImpl(const FPEnvironmentImpl& env)
+{
+}
+
+
+FPEnvironmentImpl::~FPEnvironmentImpl()
+{
+}
+
+
+FPEnvironmentImpl& FPEnvironmentImpl::operator = (const FPEnvironmentImpl& env)
+{
+	return *this;
+}
+
+
+void FPEnvironmentImpl::keepCurrentImpl()
+{
+}
+
+
+void FPEnvironmentImpl::clearFlagsImpl()
+{
+}
+
+
+bool FPEnvironmentImpl::isFlagImpl(FlagImpl flag)
+{
+	return false;
+}
+
+
+void FPEnvironmentImpl::setRoundingModeImpl(RoundingModeImpl mode)
+{
+	_roundingMode = mode;
+}
+
+
+FPEnvironmentImpl::RoundingModeImpl FPEnvironmentImpl::getRoundingModeImpl()
+{
+	return _roundingMode;
+}
+
+
+long double FPEnvironmentImpl::copySignImpl(long double target, long double source)
+{
+	return (source >= 0 && target >= 0) || (source < 0 && target < 0) ? target : -target;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/FPEnvironment_QNX.cpp b/base/poco/Foundation/src/FPEnvironment_QNX.cpp
new file mode 100644
index 00000000000..057eb8eb7bc
--- /dev/null
+++ b/base/poco/Foundation/src/FPEnvironment_QNX.cpp
@@ -0,0 +1,82 @@
+//
+// FPEnvironment_QNX.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  FPEnvironment
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/FPEnvironment_QNX.h"
+
+
+namespace Poco {
+
+
+FPEnvironmentImpl::FPEnvironmentImpl()
+{
+	fegetenv(&_env);
+}
+
+
+FPEnvironmentImpl::FPEnvironmentImpl(const FPEnvironmentImpl& env)
+{
+	_env = env._env;
+}
+
+
+FPEnvironmentImpl::~FPEnvironmentImpl()
+{
+	fesetenv(&_env);
+}
+
+
+FPEnvironmentImpl& FPEnvironmentImpl::operator = (const FPEnvironmentImpl& env)
+{
+	_env = env._env;
+	return *this;
+}
+
+
+void FPEnvironmentImpl::keepCurrentImpl()
+{
+	fegetenv(&_env);
+}
+
+
+void FPEnvironmentImpl::clearFlagsImpl()
+{
+	feclearexcept(FE_ALL_EXCEPT);
+}
+
+
+bool FPEnvironmentImpl::isFlagImpl(FlagImpl flag)
+{
+	return fetestexcept(flag) != 0;
+}
+
+
+void FPEnvironmentImpl::setRoundingModeImpl(RoundingModeImpl mode)
+{
+	fesetround(mode);
+}
+
+
+FPEnvironmentImpl::RoundingModeImpl FPEnvironmentImpl::getRoundingModeImpl()
+{
+	return (RoundingModeImpl) fegetround();
+}
+
+
+long double FPEnvironmentImpl::copySignImpl(long double target, long double source)
+{
+	return (source >= 0 && target >= 0) || (source < 0 && target < 0) ? target : -target;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/FPEnvironment_SUN.cpp b/base/poco/Foundation/src/FPEnvironment_SUN.cpp
new file mode 100644
index 00000000000..36ee36431df
--- /dev/null
+++ b/base/poco/Foundation/src/FPEnvironment_SUN.cpp
@@ -0,0 +1,139 @@
+//
+// FPEnvironment_SUN.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  FPEnvironment
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include <math.h>
+#include "Poco/FPEnvironment_SUN.h"
+
+
+namespace Poco {
+
+
+FPEnvironmentImpl::FPEnvironmentImpl()
+{
+	_rnd = fpgetround();
+	_exc = fpgetmask();
+}
+
+
+FPEnvironmentImpl::FPEnvironmentImpl(const FPEnvironmentImpl& env)
+{
+	_rnd = env._rnd;
+	_exc = env._exc;
+}
+
+
+FPEnvironmentImpl::~FPEnvironmentImpl()
+{
+	fpsetround(_rnd);
+	fpsetmask(_exc);
+}
+
+
+FPEnvironmentImpl& FPEnvironmentImpl::operator = (const FPEnvironmentImpl& env)
+{
+	_rnd = env._rnd;
+	_exc = env._exc;
+	return *this;
+}
+
+
+bool FPEnvironmentImpl::isInfiniteImpl(float value)
+{
+	int cls = fpclass(value);
+	return cls == FP_PINF || cls == FP_NINF;
+}
+
+
+bool FPEnvironmentImpl::isInfiniteImpl(double value)
+{
+	int cls = fpclass(value);
+	return cls == FP_PINF || cls == FP_NINF;
+}
+
+
+bool FPEnvironmentImpl::isInfiniteImpl(long double value)
+{
+	int cls = fpclass(value);
+	return cls == FP_PINF || cls == FP_NINF;
+}
+
+
+bool FPEnvironmentImpl::isNaNImpl(float value)
+{
+	return isnanf(value) != 0;
+}
+
+
+bool FPEnvironmentImpl::isNaNImpl(double value)
+{
+	return isnan(value) != 0;
+}
+
+
+bool FPEnvironmentImpl::isNaNImpl(long double value)
+{
+	return isnan((double) value) != 0;
+}
+
+
+float FPEnvironmentImpl::copySignImpl(float target, float source)
+{
+	return (float) copysign(target, source);
+}
+
+
+double FPEnvironmentImpl::copySignImpl(double target, double source)
+{
+	return (float) copysign(target, source);
+}
+
+
+long double FPEnvironmentImpl::copySignImpl(long double target, long double source)
+{
+	return (source > 0 && target > 0) || (source < 0 && target < 0) ? target : -target;
+}
+
+
+void FPEnvironmentImpl::keepCurrentImpl()
+{
+	fpsetround(_rnd);
+	fpsetmask(_exc);
+}
+
+
+void FPEnvironmentImpl::clearFlagsImpl()
+{
+	fpsetsticky(0);
+}
+
+
+bool FPEnvironmentImpl::isFlagImpl(FlagImpl flag)
+{
+	return (fpgetsticky() & flag) != 0;
+}
+
+
+void FPEnvironmentImpl::setRoundingModeImpl(RoundingModeImpl mode)
+{
+	fpsetround((fp_rnd) mode);
+}
+
+
+FPEnvironmentImpl::RoundingModeImpl FPEnvironmentImpl::getRoundingModeImpl()
+{
+	return (FPEnvironmentImpl::RoundingModeImpl) fpgetround();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/FPEnvironment_WIN32.cpp b/base/poco/Foundation/src/FPEnvironment_WIN32.cpp
new file mode 100644
index 00000000000..32c7f65e7b7
--- /dev/null
+++ b/base/poco/Foundation/src/FPEnvironment_WIN32.cpp
@@ -0,0 +1,76 @@
+//
+// FPEnvironment_WIN32.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  FPEnvironment
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/FPEnvironment_WIN32.h"
+
+
+namespace Poco {
+
+
+FPEnvironmentImpl::FPEnvironmentImpl()
+{
+	_env = _controlfp(0, 0);
+}
+
+
+FPEnvironmentImpl::FPEnvironmentImpl(const FPEnvironmentImpl& env)
+{
+	_env = env._env;
+}
+
+
+FPEnvironmentImpl::~FPEnvironmentImpl()
+{
+	_controlfp(_env, _MCW_RC);
+}
+
+
+FPEnvironmentImpl& FPEnvironmentImpl::operator = (const FPEnvironmentImpl& env)
+{
+	_env = env._env;
+	return *this;
+}
+
+
+void FPEnvironmentImpl::keepCurrentImpl()
+{
+	_env = _controlfp(0, 0);
+}
+
+
+void FPEnvironmentImpl::clearFlagsImpl()
+{
+	_clearfp();
+}
+
+
+bool FPEnvironmentImpl::isFlagImpl(FlagImpl flag)
+{
+	return (_statusfp() & flag) != 0;
+}
+
+
+void FPEnvironmentImpl::setRoundingModeImpl(RoundingModeImpl mode)
+{
+	_controlfp(mode, _MCW_RC);
+}
+
+
+FPEnvironmentImpl::RoundingModeImpl FPEnvironmentImpl::getRoundingModeImpl()
+{
+	return RoundingModeImpl(_controlfp(0, 0) & _MCW_RC);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/File.cpp b/base/poco/Foundation/src/File.cpp
new file mode 100644
index 00000000000..ec198d13909
--- /dev/null
+++ b/base/poco/Foundation/src/File.cpp
@@ -0,0 +1,394 @@
+//
+// File.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  File
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/File.h"
+#include "Poco/Path.h"
+#include "Poco/DirectoryIterator.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS) && defined(POCO_WIN32_UTF8)
+#if defined(_WIN32_WCE)
+#include "File_WINCE.cpp"
+#else
+#include "File_WIN32U.cpp"
+#endif
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "File_WIN32.cpp"
+#elif defined(POCO_VXWORKS)
+#include "File_VX.cpp"
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include "File_UNIX.cpp"
+#endif
+#include "Poco/Thread.h"
+
+
+namespace Poco {
+
+
+File::File()
+{
+}
+
+
+File::File(const std::string& path): FileImpl(path)
+{
+}
+
+
+File::File(const char* path): FileImpl(std::string(path))
+{
+}
+
+
+File::File(const Path& path): FileImpl(path.toString())
+{
+}
+
+
+File::File(const File& file): FileImpl(file.getPathImpl())
+{
+}
+
+
+File::~File()
+{
+}
+
+
+File& File::operator = (const File& file)
+{
+	setPathImpl(file.getPathImpl());
+	return *this;
+}
+
+
+File& File::operator = (const std::string& path)
+{
+	setPathImpl(path);
+	return *this;
+}
+
+
+File& File::operator = (const char* path)
+{
+	poco_check_ptr (path);
+	setPathImpl(path);
+	return *this;
+}
+
+
+File& File::operator = (const Path& path)
+{
+	setPathImpl(path.toString());
+	return *this;
+}
+
+
+void File::swap(File& file)
+{
+	swapImpl(file);
+}
+
+
+bool File::exists() const
+{
+	return existsImpl();
+}
+
+
+bool File::canRead() const
+{
+	return canReadImpl();
+}
+
+
+bool File::canWrite() const
+{
+	return canWriteImpl();
+}
+
+
+bool File::canExecute() const
+{
+	return canExecuteImpl();
+}
+
+
+bool File::isFile() const
+{
+	return isFileImpl();
+}
+
+
+bool File::isDirectory() const
+{
+	return isDirectoryImpl();
+}
+
+
+bool File::isLink() const
+{
+	return isLinkImpl();
+}
+
+
+bool File::isDevice() const
+{
+	return isDeviceImpl();
+}
+
+
+bool File::isHidden() const
+{
+	return isHiddenImpl();
+}
+
+
+Timestamp File::created() const
+{
+	return createdImpl();
+}
+
+
+Timestamp File::getLastModified() const
+{
+	return getLastModifiedImpl();
+}
+
+
+File& File::setLastModified(const Timestamp& ts)
+{
+	setLastModifiedImpl(ts);
+	return *this;
+}
+
+
+File::FileSize File::getSize() const
+{
+	return getSizeImpl();
+}
+
+
+File& File::setSize(FileSizeImpl size)
+{
+	setSizeImpl(size);
+	return *this;
+}
+
+
+File& File::setWriteable(bool flag)
+{
+	setWriteableImpl(flag);
+	return *this;
+}
+
+
+File& File::setReadOnly(bool flag)
+{
+	setWriteableImpl(!flag);
+	return *this;
+}
+
+
+File& File::setExecutable(bool flag)
+{
+	setExecutableImpl(flag);
+	return *this;
+}
+
+
+void File::copyTo(const std::string& path) const
+{
+	Path src(getPathImpl());
+	Path dest(path);
+	File destFile(path);
+	if ((destFile.exists() && destFile.isDirectory()) || dest.isDirectory())
+	{
+		dest.makeDirectory();
+		dest.setFileName(src.getFileName());
+	}
+	if (isDirectory())
+		copyDirectory(dest.toString());
+	else
+		copyToImpl(dest.toString());
+}
+
+
+void File::copyDirectory(const std::string& path) const
+{
+	File target(path);
+	target.createDirectories();
+
+	Path src(getPathImpl());
+	src.makeFile();
+	DirectoryIterator it(src);
+	DirectoryIterator end;
+	for (; it != end; ++it)
+	{
+		it->copyTo(path);
+	}
+}
+
+
+void File::moveTo(const std::string& path)
+{
+	copyTo(path);
+	remove(true);
+	setPathImpl(path);
+}
+
+
+void File::renameTo(const std::string& path)
+{
+	renameToImpl(path);
+	setPathImpl(path);
+}
+
+
+void File::linkTo(const std::string& path, LinkType type) const
+{
+	linkToImpl(path, type);
+}
+
+
+void File::remove(bool recursive)
+{
+	if (recursive && !isLink() && isDirectory())
+	{
+		std::vector<File> files;
+		list(files);
+		for (std::vector<File>::iterator it = files.begin(); it != files.end(); ++it)
+		{
+			it->remove(true);
+		}
+
+		// Note: On Windows, removing a directory may not succeed at first
+		// try because deleting files is not a synchronous operation. Files
+		// are merely marked as deleted, and actually removed at a later time.
+		//
+		// An alternate strategy would be moving files to a different directory
+		// first (on the same drive, but outside the deleted tree), and marking
+		// them as hidden, before deleting them, but this could lead to other issues.
+		// So we simply retry after some time until we succeed, or give up.
+
+		int retry = 8;
+		long sleep = 10;
+		while (retry > 0)
+		{
+			try
+			{
+				removeImpl();
+				retry = 0;
+			}
+			catch (DirectoryNotEmptyException&)
+			{
+				if (--retry == 0) throw;
+				Poco::Thread::sleep(sleep);
+				sleep *= 2;
+			}
+		}
+	}
+	else
+	{
+		removeImpl();
+	}
+}
+
+
+bool File::createFile()
+{
+	return createFileImpl();
+}
+
+
+bool File::createDirectory()
+{
+	return createDirectoryImpl();
+}
+
+
+void File::createDirectories()
+{
+	if (!exists())
+	{
+		Path p(getPathImpl());
+		p.makeDirectory();
+		if (p.depth() > 1)
+		{
+			p.makeParent();
+			File f(p);
+			f.createDirectories();
+		}
+		try
+		{
+			createDirectoryImpl();
+		}
+		catch (FileExistsException&)
+		{
+		}
+	}
+}
+
+
+void File::list(std::vector<std::string>& files) const
+{
+	files.clear();
+	DirectoryIterator it(*this);
+	DirectoryIterator end;
+	while (it != end)
+	{
+		files.push_back(it.name());
+		++it;
+	}
+}
+
+
+File::FileSize File::totalSpace() const
+{
+	return totalSpaceImpl();
+}
+
+
+File::FileSize File::usableSpace() const
+{
+	return usableSpaceImpl();
+}
+
+
+File::FileSize File::freeSpace() const
+{
+	return freeSpaceImpl();
+}
+
+
+void File::list(std::vector<File>& files) const
+{
+	files.clear();
+	DirectoryIterator it(*this);
+	DirectoryIterator end;
+	while (it != end)
+	{
+		files.push_back(*it);
+		++it;
+	}
+}
+
+
+void File::handleLastError(const std::string& path)
+{
+	handleLastErrorImpl(path);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/FileChannel.cpp b/base/poco/Foundation/src/FileChannel.cpp
new file mode 100644
index 00000000000..caea1b54ade
--- /dev/null
+++ b/base/poco/Foundation/src/FileChannel.cpp
@@ -0,0 +1,570 @@
+//
+// FileChannel.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  FileChannel
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/FileChannel.h"
+#include "Poco/ArchiveStrategy.h"
+#include "Poco/RotateStrategy.h"
+#include "Poco/PurgeStrategy.h"
+#include "Poco/Message.h"
+#include "Poco/NumberParser.h"
+#include "Poco/DateTimeFormatter.h"
+#include "Poco/DateTime.h"
+#include "Poco/LocalDateTime.h"
+#include "Poco/String.h"
+#include "Poco/Exception.h"
+#include "Poco/Ascii.h"
+
+
+namespace Poco {
+
+
+const std::string FileChannel::PROP_PATH           = "path";
+const std::string FileChannel::PROP_ROTATION       = "rotation";
+const std::string FileChannel::PROP_ARCHIVE        = "archive";
+const std::string FileChannel::PROP_TIMES          = "times";
+const std::string FileChannel::PROP_COMPRESS       = "compress";
+const std::string FileChannel::PROP_STREAMCOMPRESS = "streamCompress";
+const std::string FileChannel::PROP_PURGEAGE       = "purgeAge";
+const std::string FileChannel::PROP_PURGECOUNT     = "purgeCount";
+const std::string FileChannel::PROP_FLUSH          = "flush";
+const std::string FileChannel::PROP_ROTATEONOPEN   = "rotateOnOpen";
+
+FileChannel::FileChannel(): 
+	_times("utc"),
+	_compress(false),
+	_streamCompress(false),
+	_flush(true),
+	_rotateOnOpen(false),
+	_pFile(0),
+	_pRotateStrategy(0),
+	_pArchiveStrategy(new ArchiveByNumberStrategy),
+	_pPurgeStrategy(0)
+{
+}
+
+
+FileChannel::FileChannel(const std::string& path):
+	_path(path),
+	_times("utc"),
+	_compress(false),
+	_streamCompress(false),
+	_flush(true),
+	_rotateOnOpen(false),
+	_pFile(0),
+	_pRotateStrategy(0),
+	_pArchiveStrategy(new ArchiveByNumberStrategy),
+	_pPurgeStrategy(0)
+{
+}
+
+
+FileChannel::~FileChannel()
+{
+	try
+	{
+		close();
+		delete _pRotateStrategy;
+		delete _pArchiveStrategy;
+		delete _pPurgeStrategy;
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void FileChannel::open()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	unsafeOpen();
+}
+
+
+void FileChannel::close()
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	delete _pFile;
+	_pFile = 0;
+}
+
+
+void FileChannel::log(const Message& msg)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	unsafeOpen();
+
+	if (_pRotateStrategy && _pArchiveStrategy && _pRotateStrategy->mustRotate(_pFile))
+	{
+		try
+		{
+			_pFile = _pArchiveStrategy->archive(_pFile, _streamCompress);
+			purge();
+		}
+		catch (...)
+		{
+			_pFile = newLogFile();
+		}
+		// we must call mustRotate() again to give the
+		// RotateByIntervalStrategy a chance to write its timestamp
+		// to the new file.
+		_pRotateStrategy->mustRotate(_pFile);
+	}
+
+	try
+	{
+	_pFile->write(msg.getText(), _flush);
+    }
+    catch (const WriteFileException & e)
+    {
+        // In case of no space left on device,
+        // we try to purge old files or truncate current file.
+
+        // NOTE: error reason is not preserved in WriteFileException, we need to check errno manually.
+        // NOTE: other reasons like quota exceeded are not handled.
+        // NOTE: current log message will be lost.
+
+        if (errno == ENOSPC)
+        {
+            PurgeOneFileStrategy().purge(_path);
+        }
+    }
+}
+
+	
+void FileChannel::setProperty(const std::string& name, const std::string& value)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (name == PROP_TIMES)
+	{
+		_times = value;
+
+		if (!_rotation.empty())
+			setRotation(_rotation);
+
+		if (!_archive.empty())
+			setArchive(_archive);
+	}
+	else if (name == PROP_PATH)
+		_path = value;
+	else if (name == PROP_ROTATION)
+		setRotation(value);
+	else if (name == PROP_ARCHIVE)
+		setArchive(value);
+	else if (name == PROP_COMPRESS)
+		setCompress(value);
+	else if (name == PROP_STREAMCOMPRESS)
+		setStreamCompress(value);
+	else if (name == PROP_PURGEAGE)
+		setPurgeAge(value);
+	else if (name == PROP_PURGECOUNT)
+		setPurgeCount(value);
+	else if (name == PROP_FLUSH)
+		setFlush(value);
+	else if (name == PROP_ROTATEONOPEN)
+		setRotateOnOpen(value);
+	else
+		Channel::setProperty(name, value);
+}
+
+
+std::string FileChannel::getProperty(const std::string& name) const
+{
+	if (name == PROP_TIMES)
+		return _times;
+	else if (name == PROP_PATH)
+		return _path;
+	else if (name == PROP_ROTATION)
+		return _rotation;
+	else if (name == PROP_ARCHIVE)
+		return _archive;
+	else if (name == PROP_COMPRESS)
+		return std::string(_compress ? "true" : "false");
+	else if (name == PROP_STREAMCOMPRESS)
+		return std::string(_streamCompress ? "true" : "false");
+	else if (name == PROP_PURGEAGE)
+		return _purgeAge;
+	else if (name == PROP_PURGECOUNT)
+		return _purgeCount;
+	else if (name == PROP_FLUSH)
+		return std::string(_flush ? "true" : "false");
+	else if (name == PROP_ROTATEONOPEN)
+		return std::string(_rotateOnOpen ? "true" : "false");
+	else
+		return Channel::getProperty(name);
+}
+
+
+Timestamp FileChannel::creationDate() const
+{
+	if (_pFile)
+		return _pFile->creationDate();
+	else
+		return 0;
+}
+
+	
+UInt64 FileChannel::size() const
+{
+	if (_pFile)
+		return _pFile->size();
+	else
+		return 0;
+}
+
+
+const std::string& FileChannel::path() const
+{
+	return _path;
+}
+
+
+void FileChannel::setRotation(const std::string& rotation)
+{
+	std::string::const_iterator it  = rotation.begin();
+	std::string::const_iterator end = rotation.end();
+	UInt64 n = 0;
+	while (it != end && Ascii::isSpace(*it)) ++it;
+	while (it != end && Ascii::isDigit(*it)) { n *= 10; n += *it++ - '0'; }
+	while (it != end && Ascii::isSpace(*it)) ++it;
+	std::string unit;
+	while (it != end && Ascii::isAlpha(*it)) unit += *it++;
+	
+	RotateStrategy* pStrategy = 0;
+	if ((rotation.find(',') != std::string::npos) || (rotation.find(':') != std::string::npos))
+	{
+		if (_times == "utc")
+			pStrategy = new RotateAtTimeStrategy<DateTime>(rotation);
+		else if (_times == "local")
+			pStrategy = new RotateAtTimeStrategy<LocalDateTime>(rotation);
+		else
+			throw PropertyNotSupportedException("times", _times);
+	}
+	else if (unit == "daily")
+		pStrategy = new RotateByIntervalStrategy(Timespan(1*Timespan::DAYS));
+	else if (unit == "weekly")
+		pStrategy = new RotateByIntervalStrategy(Timespan(7*Timespan::DAYS));
+	else if (unit == "monthly")
+		pStrategy = new RotateByIntervalStrategy(Timespan(30*Timespan::DAYS));
+	else if (unit == "seconds") // for testing only
+		pStrategy = new RotateByIntervalStrategy(Timespan(n*Timespan::SECONDS));
+	else if (unit == "minutes")
+		pStrategy = new RotateByIntervalStrategy(Timespan(n*Timespan::MINUTES));
+	else if (unit == "hours")
+		pStrategy = new RotateByIntervalStrategy(Timespan(n*Timespan::HOURS));
+	else if (unit == "days")
+		pStrategy = new RotateByIntervalStrategy(Timespan(n*Timespan::DAYS));
+	else if (unit == "weeks")
+		pStrategy = new RotateByIntervalStrategy(Timespan(n*7*Timespan::DAYS));
+	else if (unit == "months")
+		pStrategy = new RotateByIntervalStrategy(Timespan(n*30*Timespan::DAYS));
+	else if (unit == "K")
+		pStrategy = new RotateBySizeStrategy(n*1024);
+	else if (unit == "M")
+		pStrategy = new RotateBySizeStrategy(n*1024*1024);
+	else if (unit == "G")
+		pStrategy = new RotateBySizeStrategy(n*1024*1024*1024);
+	else if (unit.empty())
+		pStrategy = new RotateBySizeStrategy(n);
+	else if (unit != "never")
+		throw InvalidArgumentException("rotation", rotation);
+	delete _pRotateStrategy;
+	_pRotateStrategy = pStrategy;
+	_rotation = rotation;
+}
+
+
+void FileChannel::setArchive(const std::string& archive)
+{
+	ArchiveStrategy* pStrategy = 0;
+	if (archive == "number")
+	{
+		pStrategy = new ArchiveByNumberStrategy;
+	}
+	else if (archive == "timestamp")
+	{
+		if (_times == "utc")
+			pStrategy = new ArchiveByTimestampStrategy<DateTime>;
+		else if (_times == "local")
+			pStrategy = new ArchiveByTimestampStrategy<LocalDateTime>;
+		else
+			throw PropertyNotSupportedException("times", _times);
+	}
+	else throw InvalidArgumentException("archive", archive);
+	delete _pArchiveStrategy;
+	pStrategy->compress(_compress && !_streamCompress);
+	_pArchiveStrategy = pStrategy;
+	_archive = archive;
+}
+
+
+void FileChannel::setCompress(const std::string& compress)
+{
+	_compress = icompare(compress, "true") == 0;
+	if (_pArchiveStrategy)
+		_pArchiveStrategy->compress(_compress && !_streamCompress);
+}
+
+
+void FileChannel::setStreamCompress(const std::string& streamCompress)
+{
+	_streamCompress = icompare(streamCompress, "true") == 0;
+
+	if (_pArchiveStrategy)
+		_pArchiveStrategy->compress(_compress && !_streamCompress);
+}
+
+
+void FileChannel::setPurgeAge(const std::string& age)
+{
+	if (setNoPurge(age)) return;
+
+	std::string::const_iterator nextToDigit;
+	int num = extractDigit(age, &nextToDigit);
+	Timespan::TimeDiff factor = extractFactor(age, nextToDigit);
+
+	setPurgeStrategy(new PurgeByAgeStrategy(Timespan(num * factor)));
+	_purgeAge = age;
+}
+
+
+void FileChannel::setPurgeCount(const std::string& count)
+{
+	if (setNoPurge(count)) return;
+
+	setPurgeStrategy(new PurgeByCountStrategy(extractDigit(count)));
+	_purgeCount = count;
+}
+
+
+void FileChannel::setFlush(const std::string& flush)
+{
+	_flush = icompare(flush, "true") == 0;
+}
+
+
+void FileChannel::setRotateOnOpen(const std::string& rotateOnOpen)
+{
+	_rotateOnOpen = icompare(rotateOnOpen, "true") == 0;
+}
+
+
+void FileChannel::purge()
+{
+	if (_pPurgeStrategy)
+	{
+		try
+		{
+			_pPurgeStrategy->purge(_path);
+		}
+		catch (...)
+		{
+		}
+	}
+}
+
+
+void FileChannel::unsafeOpen()
+{
+	if (!_pFile)
+	{
+		_pFile = newLogFile();
+		if (_rotateOnOpen && _pFile->size() > 0)
+		{
+			try
+			{
+				_pFile = _pArchiveStrategy->archive(_pFile, _streamCompress);
+				purge();
+			}
+			catch (...)
+			{
+				_pFile = newLogFile();
+			}
+		}
+	}
+}
+
+
+void archiveByNumber(const std::string& basePath)
+	/// A monotonic increasing number is appended to the
+	/// log file name. The most recent archived file
+	/// always has the number zero.
+{
+	std::string base = basePath;
+	std::string ext = "";
+
+	if (base.ends_with(".lz4"))
+	{
+		base.resize(base.size() - 4);
+		ext = ".lz4";
+	}
+	
+	int n = -1;
+	std::string path;
+	File f;
+	do
+	{
+		path = base;
+		path.append(".");
+		NumberFormatter::append(path, ++n);
+		path.append(ext);
+		f = path;
+	}
+	while (f.exists());
+	
+	while (n >= 0)
+	{
+		std::string oldPath = base;
+		if (n > 0)
+		{
+			oldPath.append(".");
+			NumberFormatter::append(oldPath, n - 1);
+		}
+		oldPath.append(ext);
+
+		std::string newPath = base;
+		newPath.append(".");
+		NumberFormatter::append(newPath, n);
+		newPath.append(ext);
+		f = oldPath;
+		if (f.exists())
+			f.renameTo(newPath);
+		--n;
+	}
+}
+
+
+void FileChannel::archiveCorrupted(const std::string& path)
+{
+	Poco::File file(path + ".lz4");
+	if (file.exists())
+	{
+		Poco::File::FileSize size = file.getSize();
+		if (size > 0)
+		{
+			bool err = false;
+
+			if (size < 4)
+			{
+				err = true;
+			}
+			else
+			{
+				Poco::Buffer<char> buffer(4);
+				Poco::FileInputStream istr(path + ".lz4");
+				istr.seekg(-4, std::ios_base::end);
+				istr.read(buffer.begin(), 4);
+
+				if (istr.gcount() != size)
+					err = true;
+
+				if (std::memcmp(buffer.begin(), "\0\0\0\0", 4) != 0)
+					err = true;
+			}
+
+			if (err)
+			{
+				file.renameTo(path + ".incomplete.lz4");
+				archiveByNumber(path + ".incomplete.lz4");
+			}
+				
+		}
+	}
+}
+
+LogFile * FileChannel::newLogFile()
+{
+	if (_streamCompress) {
+		archiveCorrupted(_path);
+		return new CompressedLogFile(_path);
+	}
+	else
+	{
+		return new LogFile(_path);
+	}
+}
+
+
+bool FileChannel::setNoPurge(const std::string& value)
+{
+	if (value.empty() || 0 == icompare(value, "none"))
+	{
+		delete _pPurgeStrategy;
+		_pPurgeStrategy = 0;
+		_purgeAge = "none";
+		return true;
+	}
+	else return false;
+}
+
+
+int FileChannel::extractDigit(const std::string& value, std::string::const_iterator* nextToDigit) const
+{
+	std::string::const_iterator it  = value.begin();
+	std::string::const_iterator end = value.end();
+	int digit 						= 0;
+
+	while (it != end && Ascii::isSpace(*it)) ++it;
+	while (it != end && Ascii::isDigit(*it))
+	{ 
+		digit *= 10;
+		digit += *it++ - '0';
+	}
+
+	if (digit == 0)
+		throw InvalidArgumentException("Zero is not valid purge age.");	
+
+	if (nextToDigit) *nextToDigit = it;
+	return digit;
+}
+
+
+void FileChannel::setPurgeStrategy(PurgeStrategy* strategy)
+{
+	delete _pPurgeStrategy;
+	_pPurgeStrategy = strategy;
+}
+
+
+Timespan::TimeDiff FileChannel::extractFactor(const std::string& value, std::string::const_iterator start) const
+{
+	while (start != value.end() && Ascii::isSpace(*start)) ++start;
+
+	std::string unit;
+	while (start != value.end() && Ascii::isAlpha(*start)) unit += *start++;
+ 
+	if (unit == "seconds")
+		return Timespan::SECONDS;
+	if (unit == "minutes")
+		return Timespan::MINUTES;
+	else if (unit == "hours")
+		return Timespan::HOURS;
+	else if (unit == "days")
+		return Timespan::DAYS;
+	else if (unit == "weeks")
+		return 7 * Timespan::DAYS;
+	else if (unit == "months")
+		return 30 * Timespan::DAYS;
+	else throw InvalidArgumentException("purgeAge", value);
+
+	return Timespan::TimeDiff();
+}
+
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/FileStream.cpp b/base/poco/Foundation/src/FileStream.cpp
new file mode 100644
index 00000000000..4f94a249087
--- /dev/null
+++ b/base/poco/Foundation/src/FileStream.cpp
@@ -0,0 +1,121 @@
+//
+// FileStream.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  FileStream
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/FileStream.h"
+#include "Poco/Exception.h"
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#include "FileStream_WIN32.cpp"
+#else
+#include "FileStream_POSIX.cpp"
+#endif
+
+
+namespace Poco {
+
+
+FileIOS::FileIOS(std::ios::openmode defaultMode):
+	_defaultMode(defaultMode)
+{
+	poco_ios_init(&_buf);
+}
+
+
+FileIOS::~FileIOS()
+{
+}
+
+
+void FileIOS::open(const std::string& path, std::ios::openmode mode)
+{
+	clear();
+	_buf.open(path, mode | _defaultMode);
+}
+
+
+void FileIOS::close()
+{
+	if (!_buf.close())
+	{
+		setstate(ios_base::badbit);
+	}
+}
+
+
+FileStreamBuf* FileIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+FileInputStream::FileInputStream():
+	FileIOS(std::ios::in),
+	std::istream(&_buf)
+{
+}
+
+
+FileInputStream::FileInputStream(const std::string& path, std::ios::openmode mode):
+	FileIOS(std::ios::in),
+	std::istream(&_buf)
+{
+	open(path, mode);
+}
+
+
+FileInputStream::~FileInputStream()
+{
+}
+
+
+FileOutputStream::FileOutputStream():
+	FileIOS(std::ios::out),
+	std::ostream(&_buf)
+{
+}
+
+
+FileOutputStream::FileOutputStream(const std::string& path, std::ios::openmode mode):
+	FileIOS(std::ios::out),
+	std::ostream(&_buf)
+{
+	open(path, mode);
+}
+
+
+FileOutputStream::~FileOutputStream()
+{
+}
+
+
+FileStream::FileStream():
+	FileIOS(std::ios::in | std::ios::out),
+	std::iostream(&_buf)
+{
+}
+
+
+FileStream::FileStream(const std::string& path, std::ios::openmode mode):
+	FileIOS(std::ios::in | std::ios::out),
+	std::iostream(&_buf)
+{
+	open(path, mode);
+}
+
+
+FileStream::~FileStream()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/FileStreamFactory.cpp b/base/poco/Foundation/src/FileStreamFactory.cpp
new file mode 100644
index 00000000000..472559c95a8
--- /dev/null
+++ b/base/poco/Foundation/src/FileStreamFactory.cpp
@@ -0,0 +1,64 @@
+//
+// FileStreamFactory.cpp
+//
+// Library: Foundation
+// Package: URI
+// Module:  FileStreamFactory
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/FileStreamFactory.h"
+#include "Poco/URI.h"
+#include "Poco/Path.h"
+#include "Poco/File.h"
+#include "Poco/Exception.h"
+#include "Poco/FileStream.h"
+
+
+namespace Poco {
+
+
+FileStreamFactory::FileStreamFactory()
+{
+}
+
+
+FileStreamFactory::~FileStreamFactory()
+{
+}
+
+
+std::istream* FileStreamFactory::open(const URI& uri)
+{
+	poco_assert (uri.isRelative() || uri.getScheme() == "file");
+
+	std::string uriPath = uri.getPath();
+	if (uriPath.substr(0, 2) == "./")
+		uriPath.erase(0, 2);
+	Path p(uriPath, Path::PATH_UNIX);
+	p.setNode(uri.getHost());
+	return open(p);
+}
+
+
+std::istream* FileStreamFactory::open(const Path& path)
+{
+	File file(path);
+	if (!file.exists()) throw FileNotFoundException(path.toString());
+	
+	FileInputStream* istr = new FileInputStream(path.toString(), std::ios::binary);
+	if (!istr->good())
+	{
+		delete istr;
+		throw OpenFileException(path.toString());
+	}	
+	return istr;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/FileStream_POSIX.cpp b/base/poco/Foundation/src/FileStream_POSIX.cpp
new file mode 100644
index 00000000000..848d7c367e2
--- /dev/null
+++ b/base/poco/Foundation/src/FileStream_POSIX.cpp
@@ -0,0 +1,170 @@
+//
+// FileStream_POSIX.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  FileStream
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/FileStream.h"
+#include "Poco/File.h"
+#include "Poco/Exception.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+
+namespace Poco {
+
+
+FileStreamBuf::FileStreamBuf():
+	BufferedBidirectionalStreamBuf(BUFFER_SIZE, std::ios::in | std::ios::out),
+	_fd(-1),
+	_pos(0)
+{
+}
+
+
+FileStreamBuf::~FileStreamBuf()
+{
+	close();
+}
+
+
+void FileStreamBuf::open(const std::string& path, std::ios::openmode mode)
+{
+	poco_assert (_fd == -1);
+
+	_pos = 0;
+	_path = path;
+	setMode(mode);
+	resetBuffers();
+
+	int flags(0);
+	if (mode & std::ios::trunc)
+		flags |= O_TRUNC;
+	if (mode & std::ios::app)
+		flags |= O_APPEND;
+	if (mode & std::ios::out)
+		flags |= O_CREAT;
+	if ((mode & std::ios::in) && (mode & std::ios::out))
+		flags |= O_RDWR;
+	else if (mode & std::ios::in)
+		flags |= O_RDONLY;
+	else
+		flags |= O_WRONLY;
+			
+	_fd = ::open(path.c_str(), flags, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+	if (_fd == -1)
+		File::handleLastError(_path);
+		
+	if ((mode & std::ios::app) || (mode & std::ios::ate))
+		seekoff(0, std::ios::end, mode);
+}
+
+
+int FileStreamBuf::readFromDevice(char* buffer, std::streamsize length)
+{
+	if (_fd == -1) return -1;
+	
+	if (getMode() & std::ios::out)
+		sync();
+	
+	int n = read(_fd, buffer, length);
+	if (n == -1)
+		File::handleLastError(_path);
+	_pos += n;
+	return n;
+}
+
+
+int FileStreamBuf::writeToDevice(const char* buffer, std::streamsize length)
+{
+	if (_fd == -1) return -1;
+
+#if defined(POCO_VXWORKS)
+	int n = write(_fd, const_cast<char*>(buffer), length);
+#else
+	int n = write(_fd, buffer, length);
+#endif
+	if (n == -1)
+		File::handleLastError(_path);
+	_pos += n;
+	return n;
+}
+
+
+bool FileStreamBuf::close()
+{
+	bool success = true;
+	if (_fd != -1)
+	{
+		try
+		{
+			sync();
+		}
+		catch (...)
+		{
+			success = false;
+		}
+		::close(_fd);
+		_fd = -1;
+	}
+	return success;
+}
+
+
+std::streampos FileStreamBuf::seekoff(std::streamoff off, std::ios::seekdir dir, std::ios::openmode mode)
+{
+	if (_fd == -1 || !(getMode() & mode)) 
+		return -1;
+
+	if (getMode() & std::ios::out)
+		sync();
+
+	std::streamoff adj;
+	if (mode & std::ios::in)
+		adj = static_cast<std::streamoff>(egptr() - gptr());
+	else
+		adj = 0;
+
+	resetBuffers();
+
+	int whence = SEEK_SET;
+	if (dir == std::ios::cur)
+	{
+		whence = SEEK_CUR;
+		off -= adj;
+	}
+	else if (dir == std::ios::end)
+	{
+		whence = SEEK_END;
+	}
+	_pos = lseek(_fd, off, whence);
+	return _pos;
+}
+
+
+std::streampos FileStreamBuf::seekpos(std::streampos pos, std::ios::openmode mode)
+{
+	if (_fd == -1 || !(getMode() & mode)) 
+		return -1;
+
+	if (getMode() & std::ios::out)
+		sync();
+
+	resetBuffers();
+
+	_pos = lseek(_fd, pos, SEEK_SET);
+	return _pos;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/FileStream_WIN32.cpp b/base/poco/Foundation/src/FileStream_WIN32.cpp
new file mode 100644
index 00000000000..28f53c9d403
--- /dev/null
+++ b/base/poco/Foundation/src/FileStream_WIN32.cpp
@@ -0,0 +1,208 @@
+//
+// FileStream.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  FileStream
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/FileStream.h"
+#include "Poco/File.h"
+#include "Poco/Exception.h"
+#if defined (POCO_WIN32_UTF8)
+#include "Poco/UnicodeConverter.h"
+#endif
+
+
+namespace Poco {
+
+
+FileStreamBuf::FileStreamBuf():
+	BufferedBidirectionalStreamBuf(BUFFER_SIZE, std::ios::in | std::ios::out),
+	_handle(INVALID_HANDLE_VALUE),
+	_pos(0)
+{
+}
+
+
+FileStreamBuf::~FileStreamBuf()
+{
+	close();
+}
+
+
+void FileStreamBuf::open(const std::string& path, std::ios::openmode mode)
+{
+	poco_assert (_handle == INVALID_HANDLE_VALUE);
+
+	_path = path;
+	_pos = 0;
+	setMode(mode);
+	resetBuffers();
+
+	DWORD access = 0;
+	if (mode & std::ios::in)
+		access |= GENERIC_READ;
+	if (mode & std::ios::out)
+		access |= GENERIC_WRITE;
+
+	DWORD shareMode = FILE_SHARE_READ;
+	if (!(mode & std::ios::out))
+		shareMode |= FILE_SHARE_WRITE;
+		
+	DWORD creationDisp = OPEN_EXISTING;
+	if (mode & std::ios::trunc)
+		creationDisp = CREATE_ALWAYS;
+	else if (mode & std::ios::out)
+		creationDisp = OPEN_ALWAYS;
+
+	DWORD flags = FILE_ATTRIBUTE_NORMAL;
+	
+#if defined (POCO_WIN32_UTF8)
+	std::wstring utf16Path;
+	FileImpl::convertPath(path, utf16Path);
+	_handle = CreateFileW(utf16Path.c_str(), access, shareMode, NULL, creationDisp, flags, NULL);
+#else
+	_handle = CreateFileA(path.c_str(), access, shareMode, NULL, creationDisp, flags, NULL);
+#endif
+
+	if (_handle == INVALID_HANDLE_VALUE)
+		File::handleLastError(_path);
+		
+	if ((mode & std::ios::ate) || (mode & std::ios::app))
+		seekoff(0, std::ios::end, mode);
+}
+
+
+int FileStreamBuf::readFromDevice(char* buffer, std::streamsize length)
+{
+	if (INVALID_HANDLE_VALUE == _handle || !(getMode() & std::ios::in))
+		return -1;
+
+	if (getMode() & std::ios::out)
+		sync();
+	
+	DWORD bytesRead(0);
+	BOOL rc = ReadFile(_handle, buffer, static_cast<DWORD>(length), &bytesRead, NULL);
+	if (rc == 0)
+		File::handleLastError(_path);
+
+	_pos += bytesRead;
+
+	return static_cast<int>(bytesRead);
+}
+
+
+int FileStreamBuf::writeToDevice(const char* buffer, std::streamsize length)
+{
+	if (INVALID_HANDLE_VALUE == _handle || !(getMode() & std::ios::out))
+		return -1;
+
+	if (getMode() & std::ios::app)
+	{
+		LARGE_INTEGER li;
+		li.QuadPart = 0;
+		li.LowPart  = SetFilePointer(_handle, li.LowPart, &li.HighPart, FILE_END);
+		if (li.LowPart == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
+			File::handleLastError(_path);
+		_pos = li.QuadPart;
+	}
+
+	DWORD bytesWritten(0);
+	BOOL rc = WriteFile(_handle, buffer, static_cast<DWORD>(length), &bytesWritten, NULL);
+	if (rc == 0)
+		File::handleLastError(_path);
+		
+	_pos += bytesWritten;
+
+	return static_cast<int>(bytesWritten);
+}
+
+
+bool FileStreamBuf::close()
+{
+	bool success = true;
+	if (_handle != INVALID_HANDLE_VALUE)
+	{
+		try
+		{
+			if (getMode() & std::ios::out)
+				sync();
+		}
+		catch (...)
+		{
+			success = false;
+		}
+		CloseHandle(_handle);
+		_handle = INVALID_HANDLE_VALUE;
+	}
+	return success;
+}
+
+
+std::streampos FileStreamBuf::seekoff(std::streamoff off, std::ios::seekdir dir, std::ios::openmode mode)
+{
+	if (INVALID_HANDLE_VALUE == _handle || !(getMode() & mode))
+		return -1;
+	
+	if (getMode() & std::ios::out)
+		sync();
+
+	std::streamoff adj;
+	if (mode & std::ios::in)
+		adj = static_cast<std::streamoff>(egptr() - gptr());
+	else
+		adj = 0;
+
+	resetBuffers();
+
+	DWORD offset = FILE_BEGIN;
+	if (dir == std::ios::cur)
+	{
+		offset = FILE_CURRENT;
+		off -= adj;
+	}
+	else if (dir == std::ios::end)
+	{
+		offset = FILE_END;
+	}
+	
+	LARGE_INTEGER li;
+	li.QuadPart = off;
+	li.LowPart  = SetFilePointer(_handle, li.LowPart, &li.HighPart, offset);
+
+	if (li.LowPart == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
+		File::handleLastError(_path);
+	_pos = li.QuadPart;
+	return std::streampos(static_cast<std::streamoff>(_pos));
+}
+
+
+std::streampos FileStreamBuf::seekpos(std::streampos pos, std::ios::openmode mode)
+{
+	if (INVALID_HANDLE_VALUE == _handle || !(getMode() & mode))
+		return -1;
+
+	if (getMode() & std::ios::out)
+		sync();
+
+	resetBuffers();
+
+	LARGE_INTEGER li;
+	li.QuadPart = pos;
+	li.LowPart  = SetFilePointer(_handle, li.LowPart, &li.HighPart, FILE_BEGIN);
+
+	if (li.LowPart == INVALID_SET_FILE_POINTER && GetLastError() != NO_ERROR)
+		File::handleLastError(_path);
+	_pos = li.QuadPart;
+	return std::streampos(static_cast<std::streamoff>(_pos));
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/File_UNIX.cpp b/base/poco/Foundation/src/File_UNIX.cpp
new file mode 100644
index 00000000000..7878f0294f5
--- /dev/null
+++ b/base/poco/Foundation/src/File_UNIX.cpp
@@ -0,0 +1,527 @@
+//
+// File_UNIX.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  File
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/File_UNIX.h"
+#include "Poco/Buffer.h"
+#include "Poco/Exception.h"
+#include "Poco/Error.h"
+#include <algorithm>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#if defined(POCO_OS_FAMILY_BSD)
+#include <sys/param.h>
+#include <sys/mount.h>
+#elif (POCO_OS == POCO_OS_SOLARIS)
+#include <sys/statvfs.h>
+#else
+#include <sys/statfs.h>
+#endif
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <utime.h>
+#include <cstring>
+
+#if (POCO_OS == POCO_OS_SOLARIS)
+#define STATFSFN statvfs
+#define STATFSSTRUCT statvfs
+#else
+#define STATFSFN statfs
+#define STATFSSTRUCT statfs
+#endif
+
+
+namespace Poco {
+
+
+FileImpl::FileImpl()
+{
+}
+
+
+FileImpl::FileImpl(const std::string& path): _path(path)
+{
+	std::string::size_type n = _path.size();
+	if (n > 1 && _path[n - 1] == '/')
+		_path.resize(n - 1);
+}
+
+
+FileImpl::~FileImpl()
+{
+}
+
+
+void FileImpl::swapImpl(FileImpl& file)
+{
+	std::swap(_path, file._path);
+}
+
+
+void FileImpl::setPathImpl(const std::string& path)
+{
+	_path = path;
+	std::string::size_type n = _path.size();
+	if (n > 1 && _path[n - 1] == '/')
+		_path.resize(n - 1);
+}
+
+
+bool FileImpl::existsImpl() const
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	return stat(_path.c_str(), &st) == 0;
+}
+
+
+bool FileImpl::canReadImpl() const
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	if (stat(_path.c_str(), &st) == 0)
+	{
+		if (st.st_uid == geteuid())
+			return (st.st_mode & S_IRUSR) != 0;
+		else if (st.st_gid == getegid())
+			return (st.st_mode & S_IRGRP) != 0;
+		else
+			return (st.st_mode & S_IROTH) != 0 || geteuid() == 0;
+	}
+	else handleLastErrorImpl(_path);
+	return false;
+}
+
+
+bool FileImpl::canWriteImpl() const
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	if (stat(_path.c_str(), &st) == 0)
+	{
+		if (st.st_uid == geteuid())
+			return (st.st_mode & S_IWUSR) != 0;
+		else if (st.st_gid == getegid())
+			return (st.st_mode & S_IWGRP) != 0;
+		else
+			return (st.st_mode & S_IWOTH) != 0 || geteuid() == 0;
+	}
+	else handleLastErrorImpl(_path);
+	return false;
+}
+
+
+bool FileImpl::canExecuteImpl() const
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	if (stat(_path.c_str(), &st) == 0)
+	{
+		if (st.st_uid == geteuid() || geteuid() == 0)
+			return (st.st_mode & S_IXUSR) != 0;
+		else if (st.st_gid == getegid())
+			return (st.st_mode & S_IXGRP) != 0;
+		else
+			return (st.st_mode & S_IXOTH) != 0;
+	}
+	else handleLastErrorImpl(_path);
+	return false;
+}
+
+
+bool FileImpl::isFileImpl() const
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	if (stat(_path.c_str(), &st) == 0)
+		return S_ISREG(st.st_mode);
+	else
+		handleLastErrorImpl(_path);
+	return false;
+}
+
+
+bool FileImpl::isDirectoryImpl() const
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	if (stat(_path.c_str(), &st) == 0)
+		return S_ISDIR(st.st_mode);
+	else
+		handleLastErrorImpl(_path);
+	return false;
+}
+
+
+bool FileImpl::isLinkImpl() const
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	if (lstat(_path.c_str(), &st) == 0)
+		return S_ISLNK(st.st_mode);
+	else
+		handleLastErrorImpl(_path);
+	return false;
+}
+
+
+bool FileImpl::isDeviceImpl() const
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	if (stat(_path.c_str(), &st) == 0)
+		return S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode);
+	else
+		handleLastErrorImpl(_path);
+	return false;
+}
+
+
+bool FileImpl::isHiddenImpl() const
+{
+	poco_assert (!_path.empty());
+	Path p(_path);
+	p.makeFile();
+
+	return p.getFileName()[0] == '.';
+}
+
+
+Timestamp FileImpl::createdImpl() const
+{
+	poco_assert (!_path.empty());
+
+#if defined(__APPLE__) && defined(st_birthtime) && !defined(POCO_NO_STAT64) // st_birthtime is available only on 10.5
+	struct stat64 st;
+	if (stat64(_path.c_str(), &st) == 0)
+		return Timestamp::fromEpochTime(st.st_birthtime);
+#elif defined(__FreeBSD__)
+	struct stat st;
+	if (stat(_path.c_str(), &st) == 0)
+		return Timestamp::fromEpochTime(st.st_birthtime);
+#else
+	struct stat st;
+	if (stat(_path.c_str(), &st) == 0)
+		return Timestamp::fromEpochTime(st.st_ctime);
+#endif
+	else
+		handleLastErrorImpl(_path);
+	return 0;
+}
+
+
+Timestamp FileImpl::getLastModifiedImpl() const
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	if (stat(_path.c_str(), &st) == 0)
+		return Timestamp::fromEpochTime(st.st_mtime);
+	else
+		handleLastErrorImpl(_path);
+	return 0;
+}
+
+
+void FileImpl::setLastModifiedImpl(const Timestamp& ts)
+{
+	poco_assert (!_path.empty());
+
+	struct utimbuf tb;
+	tb.actime  = ts.epochTime();
+	tb.modtime = ts.epochTime();
+	if (utime(_path.c_str(), &tb) != 0)
+		handleLastErrorImpl(_path);
+}
+
+
+FileImpl::FileSizeImpl FileImpl::getSizeImpl() const
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	if (stat(_path.c_str(), &st) == 0)
+		return st.st_size;
+	else
+		handleLastErrorImpl(_path);
+	return 0;
+}
+
+
+void FileImpl::setSizeImpl(FileSizeImpl size)
+{
+	poco_assert (!_path.empty());
+
+	if (truncate(_path.c_str(), size) != 0)
+		handleLastErrorImpl(_path);
+}
+
+
+void FileImpl::setWriteableImpl(bool flag)
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	if (stat(_path.c_str(), &st) != 0)
+		handleLastErrorImpl(_path);
+	mode_t mode;
+	if (flag)
+	{
+		mode = st.st_mode | S_IWUSR;
+	}
+	else
+	{
+		mode_t wmask = S_IWUSR | S_IWGRP | S_IWOTH;
+		mode = st.st_mode & ~wmask;
+	}
+	if (chmod(_path.c_str(), mode) != 0)
+		handleLastErrorImpl(_path);
+}
+
+
+void FileImpl::setExecutableImpl(bool flag)
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	if (stat(_path.c_str(), &st) != 0)
+		handleLastErrorImpl(_path);
+	mode_t mode;
+	if (flag)
+	{
+		mode = st.st_mode | S_IXUSR;
+		if (st.st_mode & S_IRGRP)
+			mode |= S_IXGRP;
+		if (st.st_mode & S_IROTH)
+			mode |= S_IXOTH;
+	}
+	else
+	{
+		mode_t wmask = S_IXUSR | S_IXGRP | S_IXOTH;
+		mode = st.st_mode & ~wmask;
+	}
+	if (chmod(_path.c_str(), mode) != 0)
+		handleLastErrorImpl(_path);
+}
+
+
+void FileImpl::copyToImpl(const std::string& path) const
+{
+	poco_assert (!_path.empty());
+
+	int sd = open(_path.c_str(), O_RDONLY);
+	if (sd == -1) handleLastErrorImpl(_path);
+
+	struct stat st;
+	if (fstat(sd, &st) != 0)
+	{
+		close(sd);
+		handleLastErrorImpl(_path);
+	}
+	const long blockSize = st.st_blksize;
+
+	int dd = open(path.c_str(), O_CREAT | O_TRUNC | O_WRONLY, st.st_mode);
+	if (dd == -1)
+	{
+		close(sd);
+		handleLastErrorImpl(path);
+	}
+	Buffer<char> buffer(blockSize);
+	try
+	{
+		int n;
+		while ((n = read(sd, buffer.begin(), blockSize)) > 0)
+		{
+			if (write(dd, buffer.begin(), n) != n)
+				handleLastErrorImpl(path);
+		}
+		if (n < 0)
+			handleLastErrorImpl(_path);
+	}
+	catch (...)
+	{
+		close(sd);
+		close(dd);
+		throw;
+	}
+	close(sd);
+	if (fsync(dd) != 0)
+	{
+		close(dd);
+		handleLastErrorImpl(path);
+	}
+	if (close(dd) != 0)
+		handleLastErrorImpl(path);
+}
+
+
+void FileImpl::renameToImpl(const std::string& path)
+{
+	poco_assert (!_path.empty());
+
+	if (rename(_path.c_str(), path.c_str()) != 0)
+		handleLastErrorImpl(_path);
+}
+
+
+void FileImpl::linkToImpl(const std::string& path, int type) const
+{
+	poco_assert (!_path.empty());
+
+	if (type == 0)
+	{
+		if (link(_path.c_str(), path.c_str()) != 0)
+			handleLastErrorImpl(_path);
+	}
+	else
+	{
+		if (symlink(_path.c_str(), path.c_str()) != 0)
+			handleLastErrorImpl(_path);
+	}
+}
+
+
+void FileImpl::removeImpl()
+{
+	poco_assert (!_path.empty());
+
+	int rc;
+	if (!isLinkImpl() && isDirectoryImpl())
+		rc = rmdir(_path.c_str());
+	else
+		rc = unlink(_path.c_str());
+	if (rc) handleLastErrorImpl(_path);
+}
+
+
+bool FileImpl::createFileImpl()
+{
+	poco_assert (!_path.empty());
+
+	int n = open(_path.c_str(), O_WRONLY | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+	if (n != -1)
+	{
+		close(n);
+		return true;
+	}
+	if (n == -1 && errno == EEXIST)
+		return false;
+	else
+		handleLastErrorImpl(_path);
+	return false;
+}
+
+
+bool FileImpl::createDirectoryImpl()
+{
+	poco_assert (!_path.empty());
+
+	if (existsImpl() && isDirectoryImpl())
+		return false;
+	if (mkdir(_path.c_str(), S_IRWXU | S_IRWXG | S_IRWXO) != 0)
+	{
+		if (errno == EEXIST && isDirectoryImpl())
+			return false;
+		handleLastErrorImpl(_path);
+	}
+	return true;
+}
+
+
+FileImpl::FileSizeImpl FileImpl::totalSpaceImpl() const
+{
+	poco_assert(!_path.empty());
+
+	struct STATFSSTRUCT stats;
+	if (STATFSFN(const_cast<char*>(_path.c_str()), &stats) != 0)
+		handleLastErrorImpl(_path);
+
+	return (FileSizeImpl)stats.f_blocks * (FileSizeImpl)stats.f_bsize;
+}
+
+
+FileImpl::FileSizeImpl FileImpl::usableSpaceImpl() const
+{
+	poco_assert(!_path.empty());
+
+	struct STATFSSTRUCT stats;
+	if (STATFSFN(const_cast<char*>(_path.c_str()), &stats) != 0)
+		handleLastErrorImpl(_path);
+
+	return (FileSizeImpl)stats.f_bavail * (FileSizeImpl)stats.f_bsize;
+}
+
+
+FileImpl::FileSizeImpl FileImpl::freeSpaceImpl() const
+{
+	poco_assert(!_path.empty());
+
+	struct STATFSSTRUCT stats;
+	if (STATFSFN(const_cast<char*>(_path.c_str()), &stats) != 0)
+		handleLastErrorImpl(_path);
+
+	return (FileSizeImpl)stats.f_bfree * (FileSizeImpl)stats.f_bsize;
+}
+
+
+void FileImpl::handleLastErrorImpl(const std::string& path)
+{
+	switch (errno)
+	{
+	case EIO:
+		throw IOException(path, errno);
+	case EPERM:
+		throw FileAccessDeniedException("insufficient permissions", path, errno);
+	case EACCES:
+		throw FileAccessDeniedException(path, errno);
+	case ENOENT:
+		throw FileNotFoundException(path, errno);
+	case ENOTDIR:
+		throw OpenFileException("not a directory", path, errno);
+	case EISDIR:
+		throw OpenFileException("not a file", path, errno);
+	case EROFS:
+		throw FileReadOnlyException(path, errno);
+	case EEXIST:
+		throw FileExistsException(path, errno);
+	case ENOSPC:
+		throw FileException("no space left on device", path, errno);
+	case EDQUOT:
+		throw FileException("disk quota exceeded", path, errno);
+#if !defined(_AIX)
+	case ENOTEMPTY:
+		throw DirectoryNotEmptyException(path, errno);
+#endif
+	case ENAMETOOLONG:
+		throw PathSyntaxException(path, errno);
+	case ENFILE:
+	case EMFILE:
+		throw FileException("too many open files", path, errno);
+	default:
+		throw FileException(Error::getMessage(errno), path, errno);
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/File_VX.cpp b/base/poco/Foundation/src/File_VX.cpp
new file mode 100644
index 00000000000..9f59b478a88
--- /dev/null
+++ b/base/poco/Foundation/src/File_VX.cpp
@@ -0,0 +1,408 @@
+//
+// File_VX.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  File
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/File_VX.h"
+#include "Poco/Buffer.h"
+#include "Poco/Exception.h"
+#include <algorithm>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <utime.h>
+#include <cstring>
+
+
+namespace Poco {
+
+
+FileImpl::FileImpl()
+{
+}
+
+
+FileImpl::FileImpl(const std::string& path): _path(path)
+{
+	std::string::size_type n = _path.size();
+	if (n > 1 && _path[n - 1] == '/')
+		_path.resize(n - 1);
+}
+
+
+FileImpl::~FileImpl()
+{
+}
+
+
+void FileImpl::swapImpl(FileImpl& file)
+{
+	std::swap(_path, file._path);
+}
+
+
+void FileImpl::setPathImpl(const std::string& path)
+{
+	_path = path;
+	std::string::size_type n = _path.size();
+	if (n > 1 && _path[n - 1] == '/')
+		_path.resize(n - 1);
+}
+
+
+bool FileImpl::existsImpl() const
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	return stat(const_cast<char*>(_path.c_str()), &st) == 0;
+}
+
+
+bool FileImpl::canReadImpl() const
+{
+	poco_assert (!_path.empty());
+
+	return true;
+}
+
+
+bool FileImpl::canWriteImpl() const
+{
+	poco_assert (!_path.empty());
+
+	return true;
+}
+
+
+bool FileImpl::canExecuteImpl() const
+{
+	return false;
+}
+
+
+bool FileImpl::isFileImpl() const
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	if (stat(const_cast<char*>(_path.c_str()), &st) == 0)
+		return S_ISREG(st.st_mode);
+	else
+		handleLastErrorImpl(_path);
+	return false;
+}
+
+
+bool FileImpl::isDirectoryImpl() const
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	if (stat(const_cast<char*>(_path.c_str()), &st) == 0)
+		return S_ISDIR(st.st_mode);
+	else
+		handleLastErrorImpl(_path);
+	return false;
+}
+
+
+bool FileImpl::isLinkImpl() const
+{
+	return false;
+}
+
+
+bool FileImpl::isDeviceImpl() const
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	if (stat(const_cast<char*>(_path.c_str()), &st) == 0)
+		return S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode);
+	else
+		handleLastErrorImpl(_path);
+	return false;
+}
+
+
+bool FileImpl::isHiddenImpl() const
+{
+	poco_assert (!_path.empty());
+	Path p(_path);
+	p.makeFile();
+
+	return p.getFileName()[0] == '.';
+}
+
+
+Timestamp FileImpl::createdImpl() const
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	if (stat(const_cast<char*>(_path.c_str()), &st) == 0)
+		return Timestamp::fromEpochTime(st.st_ctime);
+	else
+		handleLastErrorImpl(_path);
+	return 0;
+}
+
+
+Timestamp FileImpl::getLastModifiedImpl() const
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	if (stat(const_cast<char*>(_path.c_str()), &st) == 0)
+		return Timestamp::fromEpochTime(st.st_mtime);
+	else
+		handleLastErrorImpl(_path);
+	return 0;
+}
+
+
+void FileImpl::setLastModifiedImpl(const Timestamp& ts)
+{
+	poco_assert (!_path.empty());
+
+	struct utimbuf tb;
+	tb.actime  = ts.epochTime();
+	tb.modtime = ts.epochTime();
+	if (utime(const_cast<char*>(_path.c_str()), &tb) != 0)
+		handleLastErrorImpl(_path);
+}
+
+
+FileImpl::FileSizeImpl FileImpl::getSizeImpl() const
+{
+	poco_assert (!_path.empty());
+
+	struct stat st;
+	if (stat(const_cast<char*>(_path.c_str()), &st) == 0)
+		return st.st_size;
+	else
+		handleLastErrorImpl(_path);
+	return 0;
+}
+
+
+void FileImpl::setSizeImpl(FileSizeImpl size)
+{
+	poco_assert (!_path.empty());
+
+	int fd = open(_path.c_str(), O_WRONLY, S_IRWXU);
+	if (fd != -1)
+	{
+		try
+		{
+			if (ftruncate(fd, size) != 0)
+				handleLastErrorImpl(_path);
+		}
+		catch (...)
+		{
+			close(fd);
+			throw;
+		}
+	}
+}
+
+
+void FileImpl::setWriteableImpl(bool flag)
+{
+	poco_assert (!_path.empty());
+}
+
+
+void FileImpl::setExecutableImpl(bool flag)
+{
+	poco_assert (!_path.empty());
+}
+
+
+void FileImpl::copyToImpl(const std::string& path) const
+{
+	poco_assert (!_path.empty());
+
+	int sd = open(_path.c_str(), O_RDONLY, 0);
+	if (sd == -1) handleLastErrorImpl(_path);
+
+	struct stat st;
+	if (fstat(sd, &st) != 0)
+	{
+		close(sd);
+		handleLastErrorImpl(_path);
+	}
+	const long blockSize = st.st_blksize;
+
+	int dd = open(path.c_str(), O_CREAT | O_TRUNC | O_WRONLY, st.st_mode & S_IRWXU);
+	if (dd == -1)
+	{
+		close(sd);
+		handleLastErrorImpl(path);
+	}
+	Buffer<char> buffer(blockSize);
+	try
+	{
+		int n;
+		while ((n = read(sd, buffer.begin(), blockSize)) > 0)
+		{
+			if (write(dd, buffer.begin(), n) != n)
+				handleLastErrorImpl(path);
+		}
+		if (n < 0)
+			handleLastErrorImpl(_path);
+	}
+	catch (...)
+	{
+		close(sd);
+		close(dd);
+		throw;
+	}
+	close(sd);
+	close(dd);
+}
+
+
+void FileImpl::renameToImpl(const std::string& path)
+{
+	poco_assert (!_path.empty());
+
+	if (rename(_path.c_str(), path.c_str()) != 0)
+		handleLastErrorImpl(_path);
+}
+
+
+void FileImpl::linkToImpl(const std::string& path, int type) const
+{
+	throw Poco::NotImplementedException("File::linkTo() is not available on this platform");
+}
+
+
+void FileImpl::removeImpl()
+{
+	poco_assert (!_path.empty());
+
+	int rc;
+	if (!isLinkImpl() && isDirectoryImpl())
+		rc = rmdir(_path.c_str());
+	else
+		rc = unlink(const_cast<char*>(_path.c_str()));
+	if (rc) handleLastErrorImpl(_path);
+}
+
+
+bool FileImpl::createFileImpl()
+{
+	poco_assert (!_path.empty());
+
+	int n = open(_path.c_str(), O_WRONLY | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+	if (n != -1)
+	{
+		close(n);
+		return true;
+	}
+	if (n == -1 && errno == EEXIST)
+		return false;
+	else
+		handleLastErrorImpl(_path);
+	return false;
+}
+
+
+bool FileImpl::createDirectoryImpl()
+{
+	poco_assert (!_path.empty());
+
+	if (existsImpl() && isDirectoryImpl())
+		return false;
+	if (mkdir(_path.c_str()) != 0)
+		handleLastErrorImpl(_path);
+	return true;
+}
+
+
+FileImpl::FileSizeImpl FileImpl::totalSpaceImpl() const
+{
+	poco_assert(!_path.empty());
+
+	struct statfs stats;
+	if (statfs(_path.c_str(), &stats) != 0)
+		handleLastErrorImpl(_path);
+
+	return (FileSizeImpl)stats.f_blocks * (FileSizeImpl)stats.f_bsize;
+}
+
+
+FileImpl::FileSizeImpl FileImpl::usableSpaceImpl() const
+{
+	poco_assert(!_path.empty());
+
+	struct statfs stats;
+	if (statfs(_path.c_str(), &stats) != 0)
+		handleLastErrorImpl(_path);
+
+	return (FileSizeImpl)stats.f_bavail * (FileSizeImpl)stats.f_bsize;
+}
+
+
+FileImpl::FileSizeImpl FileImpl::freeSpaceImpl() const
+{
+	poco_assert(!_path.empty());
+
+	struct statfs stats;
+	if (statfs(_path.c_str(), &stats) != 0)
+		handleLastErrorImpl(_path);
+
+	return (FileSizeImpl)stats.f_bfree * (FileSizeImpl)stats.f_bsize;
+}
+
+
+void FileImpl::handleLastErrorImpl(const std::string& path)
+{
+	switch (errno)
+	{
+	case EIO:
+		throw IOException(path);
+	case EPERM:
+		throw FileAccessDeniedException("insufficient permissions", path);
+	case EACCES:
+		throw FileAccessDeniedException(path);
+	case ENOENT:
+		throw FileNotFoundException(path);
+	case ENOTDIR:
+		throw OpenFileException("not a directory", path);
+	case EISDIR:
+		throw OpenFileException("not a file", path);
+	case EROFS:
+		throw FileReadOnlyException(path);
+	case EEXIST:
+		throw FileExistsException(path);
+	case ENOSPC:
+		throw FileException("no space left on device", path);
+	case ENOTEMPTY:
+		throw DirectoryNotEmptyException(path);
+	case ENAMETOOLONG:
+		throw PathSyntaxException(path);
+	case ENFILE:
+	case EMFILE:
+		throw FileException("too many open files", path);
+	default:
+		throw FileException(std::strerror(errno), path);
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/File_WIN32.cpp b/base/poco/Foundation/src/File_WIN32.cpp
new file mode 100644
index 00000000000..2c569e36976
--- /dev/null
+++ b/base/poco/Foundation/src/File_WIN32.cpp
@@ -0,0 +1,465 @@
+//
+// File_WIN32.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  File
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/File_WIN32.h"
+#include "Poco/Exception.h"
+#include "Poco/String.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class FileHandle
+{
+public:
+	FileHandle(const std::string& path, DWORD access, DWORD share, DWORD disp)
+	{
+		_h = CreateFileA(path.c_str(), access, share, 0, disp, 0, 0);
+		if (_h == INVALID_HANDLE_VALUE)
+		{
+			FileImpl::handleLastErrorImpl(path);
+		}
+	}
+
+	~FileHandle()
+	{
+		if (_h != INVALID_HANDLE_VALUE) CloseHandle(_h);
+	}
+
+	HANDLE get() const
+	{
+		return _h;
+	}
+
+private:
+	HANDLE _h;
+};
+
+
+FileImpl::FileImpl()
+{
+}
+
+
+FileImpl::FileImpl(const std::string& path): _path(path)
+{
+	std::string::size_type n = _path.size();
+	if (n > 1 && (_path[n - 1] == '\\' || _path[n - 1] == '/') && !((n == 3 && _path[1]==':')))
+	{
+		_path.resize(n - 1);
+	}
+}
+
+
+FileImpl::~FileImpl()
+{
+}
+
+
+void FileImpl::swapImpl(FileImpl& file)
+{
+	std::swap(_path, file._path);
+}
+
+
+void FileImpl::setPathImpl(const std::string& path)
+{
+	_path = path;
+	std::string::size_type n = _path.size();
+	if (n > 1 && (_path[n - 1] == '\\' || _path[n - 1] == '/') && !((n == 3 && _path[1]==':')))
+	{
+		_path.resize(n - 1);
+	}
+}
+
+
+bool FileImpl::existsImpl() const
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributes(_path.c_str());
+	if (attr == INVALID_FILE_ATTRIBUTES)
+	{
+		switch (GetLastError())
+		{
+		case ERROR_FILE_NOT_FOUND:
+		case ERROR_PATH_NOT_FOUND:
+		case ERROR_NOT_READY:
+		case ERROR_INVALID_DRIVE:
+			return false;
+		default:
+			handleLastErrorImpl(_path);
+		}
+	}
+	return true;
+}
+
+
+bool FileImpl::canReadImpl() const
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributes(_path.c_str());
+	if (attr == INVALID_FILE_ATTRIBUTES)
+	{
+		switch (GetLastError())
+		{
+		case ERROR_ACCESS_DENIED:
+			return false;
+		default:
+			handleLastErrorImpl(_path);
+		}
+	}
+	return true;
+}
+
+
+bool FileImpl::canWriteImpl() const
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributes(_path.c_str());
+	if (attr == INVALID_FILE_ATTRIBUTES)
+		handleLastErrorImpl(_path);
+	return (attr & FILE_ATTRIBUTE_READONLY) == 0;
+}
+
+
+bool FileImpl::canExecuteImpl() const
+{
+	Path p(_path);
+	return icompare(p.getExtension(), "exe") == 0;
+}
+
+
+bool FileImpl::isFileImpl() const
+{
+	return !isDirectoryImpl() && !isDeviceImpl();
+}
+
+
+bool FileImpl::isDirectoryImpl() const
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributes(_path.c_str());
+	if (attr == INVALID_FILE_ATTRIBUTES)
+		handleLastErrorImpl(_path);
+	return (attr & FILE_ATTRIBUTE_DIRECTORY) != 0;
+}
+
+
+bool FileImpl::isLinkImpl() const
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributes(_path.c_str());
+	if (attr == INVALID_FILE_ATTRIBUTES)
+		handleLastErrorImpl(_path);
+	return (attr & FILE_ATTRIBUTE_DIRECTORY) == 0 && (attr & FILE_ATTRIBUTE_REPARSE_POINT) != 0;
+}
+
+
+
+bool FileImpl::isDeviceImpl() const
+{
+	return
+		_path.compare(0, 4, "\\\\.\\") == 0 ||
+		icompare(_path, "CON") == 0 ||
+		icompare(_path, "PRN") == 0 ||
+		icompare(_path, "AUX") == 0 ||
+		icompare(_path, "NUL") == 0 ||
+		( (icompare(_path, 0, 3, "LPT") == 0 || icompare(_path, 0, 3, "COM") == 0) &&
+		   _path.size() == 4 &&
+		   _path[3] > 0x30   &&
+		   isdigit(_path[3])
+		);
+}
+
+
+bool FileImpl::isHiddenImpl() const
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributes(_path.c_str());
+	if (attr == INVALID_FILE_ATTRIBUTES)
+		handleLastErrorImpl(_path);
+	return (attr & FILE_ATTRIBUTE_HIDDEN) != 0;
+}
+
+
+Timestamp FileImpl::createdImpl() const
+{
+	poco_assert (!_path.empty());
+
+	WIN32_FILE_ATTRIBUTE_DATA fad;
+	if (GetFileAttributesEx(_path.c_str(), GetFileExInfoStandard, &fad) == 0)
+		handleLastErrorImpl(_path);
+	return Timestamp::fromFileTimeNP(fad.ftCreationTime.dwLowDateTime, fad.ftCreationTime.dwHighDateTime);
+}
+
+
+Timestamp FileImpl::getLastModifiedImpl() const
+{
+	poco_assert (!_path.empty());
+
+	WIN32_FILE_ATTRIBUTE_DATA fad;
+	if (GetFileAttributesEx(_path.c_str(), GetFileExInfoStandard, &fad) == 0)
+		handleLastErrorImpl(_path);
+	return Timestamp::fromFileTimeNP(fad.ftLastWriteTime.dwLowDateTime, fad.ftLastWriteTime.dwHighDateTime);
+}
+
+
+void FileImpl::setLastModifiedImpl(const Timestamp& ts)
+{
+	poco_assert (!_path.empty());
+
+	UInt32 low;
+	UInt32 high;
+	ts.toFileTimeNP(low, high);
+	FILETIME ft;
+	ft.dwLowDateTime  = low;
+	ft.dwHighDateTime = high;
+	FileHandle fh(_path, FILE_WRITE_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE, OPEN_EXISTING);
+	if (SetFileTime(fh.get(), 0, &ft, &ft) == 0)
+		handleLastErrorImpl(_path);
+}
+
+
+FileImpl::FileSizeImpl FileImpl::getSizeImpl() const
+{
+	poco_assert (!_path.empty());
+
+	WIN32_FILE_ATTRIBUTE_DATA fad;
+	if (GetFileAttributesEx(_path.c_str(), GetFileExInfoStandard, &fad) == 0)
+		handleLastErrorImpl(_path);
+	LARGE_INTEGER li;
+	li.LowPart  = fad.nFileSizeLow;
+	li.HighPart = fad.nFileSizeHigh;
+	return li.QuadPart;
+}
+
+
+void FileImpl::setSizeImpl(FileSizeImpl size)
+{
+	poco_assert (!_path.empty());
+
+	FileHandle fh(_path, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, OPEN_EXISTING);
+	LARGE_INTEGER li;
+	li.QuadPart = size;
+	if (SetFilePointer(fh.get(), li.LowPart, &li.HighPart, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
+		handleLastErrorImpl(_path);
+	if (SetEndOfFile(fh.get()) == 0)
+		handleLastErrorImpl(_path);
+}
+
+
+void FileImpl::setWriteableImpl(bool flag)
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributes(_path.c_str());
+	if (attr == -1)
+		handleLastErrorImpl(_path);
+	if (flag)
+		attr &= ~FILE_ATTRIBUTE_READONLY;
+	else
+		attr |= FILE_ATTRIBUTE_READONLY;
+	if (SetFileAttributes(_path.c_str(), attr) == 0)
+		handleLastErrorImpl(_path);
+}
+
+
+void FileImpl::setExecutableImpl(bool flag)
+{
+	// not supported
+}
+
+
+void FileImpl::copyToImpl(const std::string& path) const
+{
+	poco_assert (!_path.empty());
+
+	if (CopyFileA(_path.c_str(), path.c_str(), FALSE) == 0)
+		handleLastErrorImpl(_path);
+}
+
+
+void FileImpl::renameToImpl(const std::string& path)
+{
+	poco_assert (!_path.empty());
+
+	if (MoveFileExA(_path.c_str(), path.c_str(), MOVEFILE_REPLACE_EXISTING) == 0)
+		handleLastErrorImpl(_path);
+}
+
+
+void FileImpl::linkToImpl(const std::string& path, int type) const
+{
+	poco_assert (!_path.empty());
+
+	if (type == 0)
+	{
+		if (CreateHardLinkA(path.c_str(), _path.c_str(), NULL) == 0)
+			handleLastErrorImpl(_path);
+	}
+	else
+	{
+#if _WIN32_WINNT >= 0x0600 && defined(SYMBOLIC_LINK_FLAG_DIRECTORY)
+		DWORD flags = 0;
+		if (isDirectoryImpl()) flags |= SYMBOLIC_LINK_FLAG_DIRECTORY;
+#ifdef SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE
+		flags |= SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE;
+#endif
+		if (CreateSymbolicLinkA(path.c_str(), _path.c_str(), flags) == 0)
+			handleLastErrorImpl(_path);
+#else
+		throw Poco::NotImplementedException("Symbolic link support not available in used version of the Windows SDK")
+#endif
+
+	}
+}
+
+
+void FileImpl::removeImpl()
+{
+	poco_assert (!_path.empty());
+
+	if (isDirectoryImpl())
+	{
+		if (RemoveDirectoryA(_path.c_str()) == 0)
+			handleLastErrorImpl(_path);
+	}
+	else
+	{
+		if (DeleteFileA(_path.c_str()) == 0)
+			handleLastErrorImpl(_path);
+	}
+}
+
+
+bool FileImpl::createFileImpl()
+{
+	poco_assert (!_path.empty());
+
+	HANDLE hFile = CreateFileA(_path.c_str(), GENERIC_WRITE, 0, 0, CREATE_NEW, 0, 0);
+	if (hFile != INVALID_HANDLE_VALUE)
+	{
+		CloseHandle(hFile);
+		return true;
+	}
+	else if (GetLastError() == ERROR_FILE_EXISTS)
+		return false;
+	else
+		handleLastErrorImpl(_path);
+	return false;
+}
+
+
+bool FileImpl::createDirectoryImpl()
+{
+	poco_assert (!_path.empty());
+
+	if (existsImpl() && isDirectoryImpl())
+		return false;
+	if (CreateDirectoryA(_path.c_str(), 0) == 0)
+		handleLastErrorImpl(_path);
+	return true;
+}
+
+
+FileImpl::FileSizeImpl FileImpl::totalSpaceImpl() const
+{
+	poco_assert(!_path.empty());
+
+	ULARGE_INTEGER space;
+	if (!GetDiskFreeSpaceExA(_path.c_str(), NULL, &space, NULL))
+		handleLastErrorImpl(_path);
+	return space.QuadPart;
+}
+
+
+FileImpl::FileSizeImpl FileImpl::usableSpaceImpl() const
+{
+	poco_assert(!_path.empty());
+
+	ULARGE_INTEGER space;
+	if (!GetDiskFreeSpaceExA(upath.c_str(), &space, NULL, NULL))
+		handleLastErrorImpl(_path);
+	return space.QuadPart;
+}
+
+
+FileImpl::FileSizeImpl FileImpl::freeSpaceImpl() const
+{
+	poco_assert(!_path.empty());
+
+	ULARGE_INTEGER space;
+	if (!GetDiskFreeSpaceExA(_path.c_str(), NULL, NULL, &space))
+		handleLastErrorImpl(_path);
+	return space.QuadPart;
+}
+
+
+void FileImpl::handleLastErrorImpl(const std::string& path)
+{
+	DWORD err = GetLastError();
+	switch (err)
+	{
+	case ERROR_FILE_NOT_FOUND:
+		throw FileNotFoundException(path, err);
+	case ERROR_PATH_NOT_FOUND:
+	case ERROR_BAD_NETPATH:
+	case ERROR_CANT_RESOLVE_FILENAME:
+	case ERROR_INVALID_DRIVE:
+		throw PathNotFoundException(path, err);
+	case ERROR_ACCESS_DENIED:
+		throw FileAccessDeniedException(path, err);
+	case ERROR_ALREADY_EXISTS:
+	case ERROR_FILE_EXISTS:
+		throw FileExistsException(path, err);
+	case ERROR_INVALID_NAME:
+	case ERROR_DIRECTORY:
+	case ERROR_FILENAME_EXCED_RANGE:
+	case ERROR_BAD_PATHNAME:
+		throw PathSyntaxException(path, err);
+	case ERROR_FILE_READ_ONLY:
+		throw FileReadOnlyException(path, err);
+	case ERROR_CANNOT_MAKE:
+		throw CreateFileException(path, err);
+	case ERROR_DIR_NOT_EMPTY:
+		throw DirectoryNotEmptyException(path, err);
+	case ERROR_WRITE_FAULT:
+		throw WriteFileException(path, err);
+	case ERROR_READ_FAULT:
+		throw ReadFileException(path, err);
+	case ERROR_SHARING_VIOLATION:
+		throw FileException("sharing violation", path, err);
+	case ERROR_LOCK_VIOLATION:
+		throw FileException("lock violation", path, err);
+	case ERROR_HANDLE_EOF:
+		throw ReadFileException("EOF reached", path, err);
+	case ERROR_HANDLE_DISK_FULL:
+	case ERROR_DISK_FULL:
+		throw WriteFileException("disk is full", path, err);
+	case ERROR_NEGATIVE_SEEK:
+		throw FileException("negative seek", path, err);
+	default:
+		throw FileException(path, err);
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/File_WIN32U.cpp b/base/poco/Foundation/src/File_WIN32U.cpp
new file mode 100644
index 00000000000..f8609f17c09
--- /dev/null
+++ b/base/poco/Foundation/src/File_WIN32U.cpp
@@ -0,0 +1,492 @@
+//
+// File_WIN32U.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  File
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/File_WIN32U.h"
+#include "Poco/Exception.h"
+#include "Poco/String.h"
+#include "Poco/UnicodeConverter.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class FileHandle
+{
+public:
+	FileHandle(const std::string& path, const std::wstring& upath, DWORD access, DWORD share, DWORD disp)
+	{
+		_h = CreateFileW(upath.c_str(), access, share, 0, disp, 0, 0);
+		if (_h == INVALID_HANDLE_VALUE)
+		{
+			FileImpl::handleLastErrorImpl(path);
+		}
+	}
+
+	~FileHandle()
+	{
+		if (_h != INVALID_HANDLE_VALUE) CloseHandle(_h);
+	}
+
+	HANDLE get() const
+	{
+		return _h;
+	}
+
+private:
+	HANDLE _h;
+};
+
+
+FileImpl::FileImpl()
+{
+}
+
+
+FileImpl::FileImpl(const std::string& path): _path(path)
+{
+	std::string::size_type n = _path.size();
+	if (n > 1 && (_path[n - 1] == '\\' || _path[n - 1] == '/') && !((n == 3 && _path[1]==':')))
+	{
+		_path.resize(n - 1);
+	}
+	convertPath(_path, _upath);
+}
+
+
+FileImpl::~FileImpl()
+{
+}
+
+
+void FileImpl::swapImpl(FileImpl& file)
+{
+	std::swap(_path, file._path);
+	std::swap(_upath, file._upath);
+}
+
+
+void FileImpl::setPathImpl(const std::string& path)
+{
+	_path = path;
+	std::string::size_type n = _path.size();
+	if (n > 1 && (_path[n - 1] == '\\' || _path[n - 1] == '/') && !((n == 3 && _path[1]==':')))
+	{
+		_path.resize(n - 1);
+	}
+	convertPath(_path, _upath);
+}
+
+
+bool FileImpl::existsImpl() const
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributesW(_upath.c_str());
+	if (attr == INVALID_FILE_ATTRIBUTES)
+	{
+		switch (GetLastError())
+		{
+		case ERROR_FILE_NOT_FOUND:
+		case ERROR_PATH_NOT_FOUND:
+		case ERROR_NOT_READY:
+		case ERROR_INVALID_DRIVE:
+			return false;
+		default:
+			handleLastErrorImpl(_path);
+		}
+	}
+	return true;
+}
+
+
+bool FileImpl::canReadImpl() const
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributesW(_upath.c_str());
+	if (attr == INVALID_FILE_ATTRIBUTES)
+	{
+		switch (GetLastError())
+		{
+		case ERROR_ACCESS_DENIED:
+			return false;
+		default:
+			handleLastErrorImpl(_path);
+		}
+	}
+	return true;
+}
+
+
+bool FileImpl::canWriteImpl() const
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributesW(_upath.c_str());
+	if (attr == INVALID_FILE_ATTRIBUTES)
+		handleLastErrorImpl(_path);
+	return (attr & FILE_ATTRIBUTE_READONLY) == 0;
+}
+
+
+bool FileImpl::canExecuteImpl() const
+{
+	Path p(_path);
+	return icompare(p.getExtension(), "exe") == 0;
+}
+
+
+bool FileImpl::isFileImpl() const
+{
+	return !isDirectoryImpl() && !isDeviceImpl();
+}
+
+
+bool FileImpl::isDirectoryImpl() const
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributesW(_upath.c_str());
+	if (attr == INVALID_FILE_ATTRIBUTES)
+		handleLastErrorImpl(_path);
+	return (attr & FILE_ATTRIBUTE_DIRECTORY) != 0;
+}
+
+
+bool FileImpl::isLinkImpl() const
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributesW(_upath.c_str());
+	if (attr == INVALID_FILE_ATTRIBUTES)
+		handleLastErrorImpl(_path);
+	return (attr & FILE_ATTRIBUTE_DIRECTORY) == 0 && (attr & FILE_ATTRIBUTE_REPARSE_POINT) != 0;
+}
+
+
+bool FileImpl::isDeviceImpl() const
+{
+	return
+		_path.compare(0, 4, "\\\\.\\") == 0 ||
+		icompare(_path, "CON") == 0 ||
+		icompare(_path, "PRN") == 0 ||
+		icompare(_path, "AUX") == 0 ||
+		icompare(_path, "NUL") == 0 ||
+		( (icompare(_path, 0, 3, "LPT") == 0 || icompare(_path, 0, 3, "COM") == 0) &&
+		   _path.size() == 4 &&
+		   _path[3] > 0x30   &&
+		   isdigit(_path[3])
+		);
+}
+
+
+bool FileImpl::isHiddenImpl() const
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributesW(_upath.c_str());
+	if (attr == INVALID_FILE_ATTRIBUTES)
+		handleLastErrorImpl(_path);
+	return (attr & FILE_ATTRIBUTE_HIDDEN) != 0;
+}
+
+
+Timestamp FileImpl::createdImpl() const
+{
+	poco_assert (!_path.empty());
+
+	WIN32_FILE_ATTRIBUTE_DATA fad;
+	if (GetFileAttributesExW(_upath.c_str(), GetFileExInfoStandard, &fad) == 0)
+		handleLastErrorImpl(_path);
+	return Timestamp::fromFileTimeNP(fad.ftCreationTime.dwLowDateTime, fad.ftCreationTime.dwHighDateTime);
+}
+
+
+Timestamp FileImpl::getLastModifiedImpl() const
+{
+	poco_assert (!_path.empty());
+
+	WIN32_FILE_ATTRIBUTE_DATA fad;
+	if (GetFileAttributesExW(_upath.c_str(), GetFileExInfoStandard, &fad) == 0)
+		handleLastErrorImpl(_path);
+	return Timestamp::fromFileTimeNP(fad.ftLastWriteTime.dwLowDateTime, fad.ftLastWriteTime.dwHighDateTime);
+}
+
+
+void FileImpl::setLastModifiedImpl(const Timestamp& ts)
+{
+	poco_assert (!_path.empty());
+
+	UInt32 low;
+	UInt32 high;
+	ts.toFileTimeNP(low, high);
+	FILETIME ft;
+	ft.dwLowDateTime  = low;
+	ft.dwHighDateTime = high;
+	FileHandle fh(_path, _upath, FILE_WRITE_ATTRIBUTES, FILE_SHARE_READ | FILE_SHARE_WRITE, OPEN_EXISTING);
+	if (SetFileTime(fh.get(), 0, &ft, &ft) == 0)
+		handleLastErrorImpl(_path);
+}
+
+
+FileImpl::FileSizeImpl FileImpl::getSizeImpl() const
+{
+	poco_assert (!_path.empty());
+
+	WIN32_FILE_ATTRIBUTE_DATA fad;
+	if (GetFileAttributesExW(_upath.c_str(), GetFileExInfoStandard, &fad) == 0)
+		handleLastErrorImpl(_path);
+	LARGE_INTEGER li;
+	li.LowPart  = fad.nFileSizeLow;
+	li.HighPart = fad.nFileSizeHigh;
+	return li.QuadPart;
+}
+
+
+void FileImpl::setSizeImpl(FileSizeImpl size)
+{
+	poco_assert (!_path.empty());
+
+	FileHandle fh(_path, _upath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, OPEN_EXISTING);
+	LARGE_INTEGER li;
+	li.QuadPart = size;
+	if (SetFilePointer(fh.get(), li.LowPart, &li.HighPart, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
+		handleLastErrorImpl(_path);
+	if (SetEndOfFile(fh.get()) == 0)
+		handleLastErrorImpl(_path);
+}
+
+
+void FileImpl::setWriteableImpl(bool flag)
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributesW(_upath.c_str());
+	if (attr == -1)
+		handleLastErrorImpl(_path);
+	if (flag)
+		attr &= ~FILE_ATTRIBUTE_READONLY;
+	else
+		attr |= FILE_ATTRIBUTE_READONLY;
+	if (SetFileAttributesW(_upath.c_str(), attr) == 0)
+		handleLastErrorImpl(_path);
+}
+
+
+void FileImpl::setExecutableImpl(bool flag)
+{
+	// not supported
+}
+
+
+void FileImpl::copyToImpl(const std::string& path) const
+{
+	poco_assert (!_path.empty());
+
+	std::wstring upath;
+	convertPath(path, upath);
+	if (CopyFileW(_upath.c_str(), upath.c_str(), FALSE) == 0)
+		handleLastErrorImpl(_path);
+}
+
+
+void FileImpl::renameToImpl(const std::string& path)
+{
+	poco_assert (!_path.empty());
+
+	std::wstring upath;
+	convertPath(path, upath);
+	if (MoveFileExW(_upath.c_str(), upath.c_str(), MOVEFILE_REPLACE_EXISTING) == 0)
+		handleLastErrorImpl(_path);
+}
+
+
+void FileImpl::linkToImpl(const std::string& path, int type) const
+{
+	poco_assert (!_path.empty());
+
+	std::wstring upath;
+	convertPath(path, upath);
+
+	if (type == 0)
+	{
+		if (CreateHardLinkW(upath.c_str(), _upath.c_str(), NULL) == 0)
+			handleLastErrorImpl(_path);
+	}
+	else
+	{
+#if _WIN32_WINNT >= 0x0600 && defined(SYMBOLIC_LINK_FLAG_DIRECTORY)
+		DWORD flags = 0;
+		if (isDirectoryImpl()) flags |= SYMBOLIC_LINK_FLAG_DIRECTORY;
+#ifdef SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE
+		flags |= SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE;
+#endif
+		if (CreateSymbolicLinkW(upath.c_str(), _upath.c_str(), flags) == 0)
+			handleLastErrorImpl(_path);
+#else
+		throw Poco::NotImplementedException("Symbolic link support not available in used version of the Windows SDK");
+#endif
+	}
+}
+
+
+void FileImpl::removeImpl()
+{
+	poco_assert (!_path.empty());
+
+	if (isDirectoryImpl())
+	{
+		if (RemoveDirectoryW(_upath.c_str()) == 0)
+			handleLastErrorImpl(_path);
+	}
+	else
+	{
+		if (DeleteFileW(_upath.c_str()) == 0)
+			handleLastErrorImpl(_path);
+	}
+}
+
+
+bool FileImpl::createFileImpl()
+{
+	poco_assert (!_path.empty());
+
+	HANDLE hFile = CreateFileW(_upath.c_str(), GENERIC_WRITE, 0, 0, CREATE_NEW, 0, 0);
+	if (hFile != INVALID_HANDLE_VALUE)
+	{
+		CloseHandle(hFile);
+		return true;
+	}
+	else if (GetLastError() == ERROR_FILE_EXISTS)
+		return false;
+	else
+		handleLastErrorImpl(_path);
+	return false;
+}
+
+
+bool FileImpl::createDirectoryImpl()
+{
+	poco_assert (!_path.empty());
+
+	if (existsImpl() && isDirectoryImpl())
+		return false;
+	if (CreateDirectoryW(_upath.c_str(), 0) == 0)
+		handleLastErrorImpl(_path);
+	return true;
+}
+
+
+FileImpl::FileSizeImpl FileImpl::totalSpaceImpl() const
+{
+	poco_assert(!_path.empty());
+
+	ULARGE_INTEGER space;
+	if (!GetDiskFreeSpaceExW(_upath.c_str(), NULL, &space, NULL))
+		handleLastErrorImpl(_path);
+	return space.QuadPart;
+}
+
+
+FileImpl::FileSizeImpl FileImpl::usableSpaceImpl() const
+{
+	poco_assert(!_path.empty());
+
+	ULARGE_INTEGER space;
+	if (!GetDiskFreeSpaceExW(_upath.c_str(), &space, NULL, NULL))
+		handleLastErrorImpl(_path);
+	return space.QuadPart;
+}
+
+
+FileImpl::FileSizeImpl FileImpl::freeSpaceImpl() const
+{
+	poco_assert(!_path.empty());
+
+	ULARGE_INTEGER space;
+	if (!GetDiskFreeSpaceExW(_upath.c_str(), NULL, NULL, &space))
+		handleLastErrorImpl(_path);
+	return space.QuadPart;
+}
+
+
+void FileImpl::handleLastErrorImpl(const std::string& path)
+{
+	DWORD err = GetLastError();
+	switch (err)
+	{
+	case ERROR_FILE_NOT_FOUND:
+		throw FileNotFoundException(path, err);
+	case ERROR_PATH_NOT_FOUND:
+	case ERROR_BAD_NETPATH:
+	case ERROR_CANT_RESOLVE_FILENAME:
+	case ERROR_INVALID_DRIVE:
+		throw PathNotFoundException(path, err);
+	case ERROR_ACCESS_DENIED:
+		throw FileAccessDeniedException(path, err);
+	case ERROR_ALREADY_EXISTS:
+	case ERROR_FILE_EXISTS:
+		throw FileExistsException(path, err);
+	case ERROR_INVALID_NAME:
+	case ERROR_DIRECTORY:
+	case ERROR_FILENAME_EXCED_RANGE:
+	case ERROR_BAD_PATHNAME:
+		throw PathSyntaxException(path, err);
+	case ERROR_FILE_READ_ONLY:
+		throw FileReadOnlyException(path, err);
+	case ERROR_CANNOT_MAKE:
+		throw CreateFileException(path, err);
+	case ERROR_DIR_NOT_EMPTY:
+		throw DirectoryNotEmptyException(path, err);
+	case ERROR_WRITE_FAULT:
+		throw WriteFileException(path, err);
+	case ERROR_READ_FAULT:
+		throw ReadFileException(path, err);
+	case ERROR_SHARING_VIOLATION:
+		throw FileException("sharing violation", path, err);
+	case ERROR_LOCK_VIOLATION:
+		throw FileException("lock violation", path, err);
+	case ERROR_HANDLE_EOF:
+		throw ReadFileException("EOF reached", path, err);
+	case ERROR_HANDLE_DISK_FULL:
+	case ERROR_DISK_FULL:
+		throw WriteFileException("disk is full", path, err);
+	case ERROR_NEGATIVE_SEEK:
+		throw FileException("negative seek", path, err);
+	default:
+		throw FileException(path, err);
+	}
+}
+
+
+void FileImpl::convertPath(const std::string& utf8Path, std::wstring& utf16Path)
+{
+	UnicodeConverter::toUTF16(utf8Path, utf16Path);
+	if (utf16Path.size() > MAX_PATH - 12) // Note: CreateDirectory has a limit of MAX_PATH - 12 (room for 8.3 file name)
+	{
+		if (utf16Path[0] == '\\' || utf16Path[1] == ':')
+		{
+			if (utf16Path.compare(0, 4, L"\\\\?\\", 4) != 0)
+			{
+				if (utf16Path[1] == '\\')
+					utf16Path.insert(0, L"\\\\?\\UNC\\", 8);
+				else
+					utf16Path.insert(0, L"\\\\?\\", 4);
+			}
+		}
+	}
+}
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/File_WINCE.cpp b/base/poco/Foundation/src/File_WINCE.cpp
new file mode 100644
index 00000000000..ea726c4bcf3
--- /dev/null
+++ b/base/poco/Foundation/src/File_WINCE.cpp
@@ -0,0 +1,441 @@
+//
+// File_WIN32U.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  File
+//
+// Copyright (c) 2006-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/File_WINCE.h"
+#include "Poco/Exception.h"
+#include "Poco/String.h"
+#include "Poco/UnicodeConverter.h"
+#include "Poco/Path.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+class FileHandle
+{
+public:
+	FileHandle(const std::string& path, const std::wstring& upath, DWORD access, DWORD share, DWORD disp)
+	{
+		_h = CreateFileW(upath.c_str(), access, share, 0, disp, 0, 0);
+		if (_h == INVALID_HANDLE_VALUE)
+		{
+			FileImpl::handleLastErrorImpl(path);
+		}
+	}
+
+	~FileHandle()
+	{
+		if (_h != INVALID_HANDLE_VALUE) CloseHandle(_h);
+	}
+
+	HANDLE get() const
+	{
+		return _h;
+	}
+
+private:
+	HANDLE _h;
+};
+
+
+FileImpl::FileImpl()
+{
+}
+
+
+FileImpl::FileImpl(const std::string& path): _path(path)
+{
+	std::string::size_type n = _path.size();
+	if (n > 1 && (_path[n - 1] == '\\' || _path[n - 1] == '/') && !((n == 3 && _path[1]==':')))
+	{
+		_path.resize(n - 1);
+	}
+	convertPath(_path, _upath);
+}
+
+
+FileImpl::~FileImpl()
+{
+}
+
+
+void FileImpl::swapImpl(FileImpl& file)
+{
+	std::swap(_path, file._path);
+	std::swap(_upath, file._upath);
+}
+
+
+void FileImpl::setPathImpl(const std::string& path)
+{
+	_path = path;
+	std::string::size_type n = _path.size();
+	if (n > 1 && (_path[n - 1] == '\\' || _path[n - 1] == '/') && !((n == 3 && _path[1]==':')))
+	{
+		_path.resize(n - 1);
+	}
+	convertPath(_path, _upath);
+}
+
+
+bool FileImpl::existsImpl() const
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributesW(_upath.c_str());
+	if (attr == INVALID_FILE_ATTRIBUTES)
+	{
+		switch (GetLastError())
+		{
+		case ERROR_FILE_NOT_FOUND:
+		case ERROR_PATH_NOT_FOUND:
+		case ERROR_NOT_READY:
+		case ERROR_INVALID_DRIVE:
+			return false;
+		default:
+			handleLastErrorImpl(_path);
+		}
+	}
+	return true;
+}
+
+
+bool FileImpl::canReadImpl() const
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributesW(_upath.c_str());
+	if (attr == INVALID_FILE_ATTRIBUTES)
+	{
+		switch (GetLastError())
+		{
+		case ERROR_ACCESS_DENIED:
+			return false;
+		default:
+			handleLastErrorImpl(_path);
+		}
+	}
+	return true;
+}
+
+
+bool FileImpl::canWriteImpl() const
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributesW(_upath.c_str());
+	if (attr == INVALID_FILE_ATTRIBUTES)
+		handleLastErrorImpl(_path);
+	return (attr & FILE_ATTRIBUTE_READONLY) == 0;
+}
+
+
+bool FileImpl::canExecuteImpl() const
+{
+	Path p(_path);
+	return icompare(p.getExtension(), "exe") == 0;
+}
+
+
+bool FileImpl::isFileImpl() const
+{
+	return !isDirectoryImpl() && !isDeviceImpl();
+}
+
+
+bool FileImpl::isDirectoryImpl() const
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributesW(_upath.c_str());
+	if (attr == INVALID_FILE_ATTRIBUTES)
+		handleLastErrorImpl(_path);
+	return (attr & FILE_ATTRIBUTE_DIRECTORY) != 0;
+}
+
+
+bool FileImpl::isLinkImpl() const
+{
+	return false;
+}
+
+
+bool FileImpl::isDeviceImpl() const
+{
+	return false;
+}
+
+
+bool FileImpl::isHiddenImpl() const
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributesW(_upath.c_str());
+	if (attr == INVALID_FILE_ATTRIBUTES)
+		handleLastErrorImpl(_path);
+	return (attr & FILE_ATTRIBUTE_HIDDEN) != 0;
+}
+
+
+Timestamp FileImpl::createdImpl() const
+{
+	poco_assert (!_path.empty());
+
+	WIN32_FILE_ATTRIBUTE_DATA fad;
+	if (GetFileAttributesExW(_upath.c_str(), GetFileExInfoStandard, &fad) == 0)
+		handleLastErrorImpl(_path);
+	return Timestamp::fromFileTimeNP(fad.ftCreationTime.dwLowDateTime, fad.ftCreationTime.dwHighDateTime);
+}
+
+
+Timestamp FileImpl::getLastModifiedImpl() const
+{
+	poco_assert (!_path.empty());
+
+	WIN32_FILE_ATTRIBUTE_DATA fad;
+	if (GetFileAttributesExW(_upath.c_str(), GetFileExInfoStandard, &fad) == 0)
+		handleLastErrorImpl(_path);
+	return Timestamp::fromFileTimeNP(fad.ftLastWriteTime.dwLowDateTime, fad.ftLastWriteTime.dwHighDateTime);
+}
+
+
+void FileImpl::setLastModifiedImpl(const Timestamp& ts)
+{
+	poco_assert (!_path.empty());
+
+	UInt32 low;
+	UInt32 high;
+	ts.toFileTimeNP(low, high);
+	FILETIME ft;
+	ft.dwLowDateTime  = low;
+	ft.dwHighDateTime = high;
+	FileHandle fh(_path, _upath, GENERIC_WRITE, FILE_SHARE_WRITE, OPEN_EXISTING);
+	if (SetFileTime(fh.get(), 0, &ft, &ft) == 0)
+		handleLastErrorImpl(_path);
+}
+
+
+FileImpl::FileSizeImpl FileImpl::getSizeImpl() const
+{
+	poco_assert (!_path.empty());
+
+	WIN32_FILE_ATTRIBUTE_DATA fad;
+	if (GetFileAttributesExW(_upath.c_str(), GetFileExInfoStandard, &fad) == 0)
+		handleLastErrorImpl(_path);
+	LARGE_INTEGER li;
+	li.LowPart  = fad.nFileSizeLow;
+	li.HighPart = fad.nFileSizeHigh;
+	return li.QuadPart;
+}
+
+
+void FileImpl::setSizeImpl(FileSizeImpl size)
+{
+	poco_assert (!_path.empty());
+
+	FileHandle fh(_path, _upath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, OPEN_EXISTING);
+	LARGE_INTEGER li;
+	li.QuadPart = size;
+	if (SetFilePointer(fh.get(), li.LowPart, &li.HighPart, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
+		handleLastErrorImpl(_path);
+	if (SetEndOfFile(fh.get()) == 0)
+		handleLastErrorImpl(_path);
+}
+
+
+void FileImpl::setWriteableImpl(bool flag)
+{
+	poco_assert (!_path.empty());
+
+	DWORD attr = GetFileAttributesW(_upath.c_str());
+	if (attr == -1)
+		handleLastErrorImpl(_path);
+	if (flag)
+		attr &= ~FILE_ATTRIBUTE_READONLY;
+	else
+		attr |= FILE_ATTRIBUTE_READONLY;
+	if (SetFileAttributesW(_upath.c_str(), attr) == 0)
+		handleLastErrorImpl(_path);
+}
+
+
+void FileImpl::setExecutableImpl(bool flag)
+{
+	// not supported
+}
+
+
+void FileImpl::copyToImpl(const std::string& path) const
+{
+	poco_assert (!_path.empty());
+
+	std::wstring upath;
+	convertPath(path, upath);
+	if (CopyFileW(_upath.c_str(), upath.c_str(), FALSE) == 0)
+		handleLastErrorImpl(_path);
+}
+
+
+void FileImpl::renameToImpl(const std::string& path)
+{
+	poco_assert (!_path.empty());
+
+	std::wstring upath;
+	convertPath(path, upath);
+	if (MoveFileW(_upath.c_str(), upath.c_str()) == 0)
+		handleLastErrorImpl(_path);
+}
+
+
+void FileImpl::linkToImpl(const std::string& path, int type) const
+{
+	throw Poco::NotImplementedException("File::linkTo() is not available on this platform");
+}
+
+
+void FileImpl::removeImpl()
+{
+	poco_assert (!_path.empty());
+
+	if (isDirectoryImpl())
+	{
+		if (RemoveDirectoryW(_upath.c_str()) == 0)
+			handleLastErrorImpl(_path);
+	}
+	else
+	{
+		if (DeleteFileW(_upath.c_str()) == 0)
+			handleLastErrorImpl(_path);
+	}
+}
+
+
+bool FileImpl::createFileImpl()
+{
+	poco_assert (!_path.empty());
+
+	HANDLE hFile = CreateFileW(_upath.c_str(), GENERIC_WRITE, 0, 0, CREATE_NEW, 0, 0);
+	if (hFile != INVALID_HANDLE_VALUE)
+	{
+		CloseHandle(hFile);
+		return true;
+	}
+	else if (GetLastError() == ERROR_FILE_EXISTS)
+		return false;
+	else
+		handleLastErrorImpl(_path);
+	return false;
+}
+
+
+bool FileImpl::createDirectoryImpl()
+{
+	poco_assert (!_path.empty());
+
+	if (existsImpl() && isDirectoryImpl())
+		return false;
+	if (CreateDirectoryW(_upath.c_str(), 0) == 0)
+		handleLastErrorImpl(_path);
+	return true;
+}
+
+
+FileImpl::FileSizeImpl FileImpl::totalSpaceImpl() const
+{
+	poco_assert(!_path.empty());
+
+	ULARGE_INTEGER space;
+	if (!GetDiskFreeSpaceExW(_upath.c_str(), NULL, &space, NULL))
+		handleLastErrorImpl(_path);
+	return space.QuadPart;
+}
+
+
+FileImpl::FileSizeImpl FileImpl::usableSpaceImpl() const
+{
+	poco_assert(!_path.empty());
+
+	ULARGE_INTEGER space;
+	if (!GetDiskFreeSpaceExW(_upath.c_str(), &space, NULL, NULL))
+		handleLastErrorImpl(_path);
+	return space.QuadPart;
+}
+
+
+FileImpl::FileSizeImpl FileImpl::freeSpaceImpl() const
+{
+	poco_assert(!_path.empty());
+
+	ULARGE_INTEGER space;
+	if (!GetDiskFreeSpaceExW(_upath.c_str(), NULL, NULL, &space))
+		handleLastErrorImpl(_path);
+	return space.QuadPart;
+}
+
+
+void FileImpl::handleLastErrorImpl(const std::string& path)
+{
+	switch (GetLastError())
+	{
+	case ERROR_FILE_NOT_FOUND:
+		throw FileNotFoundException(path);
+	case ERROR_PATH_NOT_FOUND:
+	case ERROR_BAD_NETPATH:
+	case ERROR_CANT_RESOLVE_FILENAME:
+	case ERROR_INVALID_DRIVE:
+		throw PathNotFoundException(path);
+	case ERROR_ACCESS_DENIED:
+		throw FileAccessDeniedException(path);
+	case ERROR_ALREADY_EXISTS:
+	case ERROR_FILE_EXISTS:
+		throw FileExistsException(path);
+	case ERROR_INVALID_NAME:
+	case ERROR_DIRECTORY:
+	case ERROR_FILENAME_EXCED_RANGE:
+	case ERROR_BAD_PATHNAME:
+		throw PathSyntaxException(path);
+	case ERROR_FILE_READ_ONLY:
+		throw FileReadOnlyException(path);
+	case ERROR_CANNOT_MAKE:
+		throw CreateFileException(path);
+	case ERROR_DIR_NOT_EMPTY:
+		throw DirectoryNotEmptyException(path);
+	case ERROR_WRITE_FAULT:
+		throw WriteFileException(path);
+	case ERROR_READ_FAULT:
+		throw ReadFileException(path);
+	case ERROR_SHARING_VIOLATION:
+		throw FileException("sharing violation", path);
+	case ERROR_LOCK_VIOLATION:
+		throw FileException("lock violation", path);
+	case ERROR_HANDLE_EOF:
+		throw ReadFileException("EOF reached", path);
+	case ERROR_HANDLE_DISK_FULL:
+	case ERROR_DISK_FULL:
+		throw WriteFileException("disk is full", path);
+	case ERROR_NEGATIVE_SEEK:
+		throw FileException("negative seek", path);
+	default:
+		throw FileException(path);
+	}
+}
+
+
+void FileImpl::convertPath(const std::string& utf8Path, std::wstring& utf16Path)
+{
+	UnicodeConverter::toUTF16(utf8Path, utf16Path);
+}
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Format.cpp b/base/poco/Foundation/src/Format.cpp
new file mode 100644
index 00000000000..ed5db5c21b2
--- /dev/null
+++ b/base/poco/Foundation/src/Format.cpp
@@ -0,0 +1,476 @@
+//
+// Format.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  Format
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Format.h"
+#include "Poco/Exception.h"
+#include "Poco/Ascii.h"
+#include <sstream>
+#if !defined(POCO_NO_LOCALE)
+#include <locale>
+#endif
+#include <cstddef>
+
+
+namespace Poco {
+
+
+namespace
+{
+	void parseFlags(std::ostream& str, std::string::const_iterator& itFmt, const std::string::const_iterator& endFmt)
+	{
+		bool isFlag = true;
+		while (isFlag && itFmt != endFmt)
+		{
+			switch (*itFmt)
+			{
+			case '-': str.setf(std::ios::left); ++itFmt; break;
+			case '+': str.setf(std::ios::showpos); ++itFmt; break;
+			case '0': str.fill('0'); str.setf(std::ios::internal); ++itFmt; break;
+			case '#': str.setf(std::ios::showpoint | std::ios::showbase); ++itFmt; break;
+			default:  isFlag = false; break;
+			}
+		}
+	}
+
+
+	void parseWidth(std::ostream& str, std::string::const_iterator& itFmt, const std::string::const_iterator& endFmt)
+	{
+		int width = 0;
+		while (itFmt != endFmt && Ascii::isDigit(*itFmt))
+		{
+			width = 10*width + *itFmt - '0';
+			++itFmt;
+		}
+		if (width != 0) str.width(width);
+	}
+	
+	
+	void parsePrec(std::ostream& str, std::string::const_iterator& itFmt, const std::string::const_iterator& endFmt)
+	{
+		if (itFmt != endFmt && *itFmt == '.')
+		{
+			++itFmt;
+			int prec = 0;
+			while (itFmt != endFmt && Ascii::isDigit(*itFmt))
+			{
+				prec = 10*prec + *itFmt - '0';
+				++itFmt;
+			}
+			if (prec >= 0) str.precision(prec);
+		}
+	}
+	
+	char parseMod(std::string::const_iterator& itFmt, const std::string::const_iterator& endFmt)
+	{
+		char mod = 0;
+		if (itFmt != endFmt)
+		{
+			switch (*itFmt)
+			{
+			case 'l':
+			case 'h':
+			case 'L': 
+			case '?': mod = *itFmt++; break;
+			}
+		}
+		return mod;
+	}
+	
+	std::size_t parseIndex(std::string::const_iterator& itFmt, const std::string::const_iterator& endFmt)
+	{
+		int index = 0;
+		while (itFmt != endFmt && Ascii::isDigit(*itFmt))
+		{
+			index = 10*index + *itFmt - '0';
+			++itFmt;
+		}
+		if (itFmt != endFmt && *itFmt == ']') ++itFmt;
+		return index;
+	}
+
+	void prepareFormat(std::ostream& str, char type)
+	{
+		switch (type)
+		{
+		case 'd':
+		case 'i': str << std::dec; break;
+		case 'o': str << std::oct; break;
+		case 'x': str << std::hex; break;
+		case 'X': str << std::hex << std::uppercase; break;
+		case 'e': str << std::scientific; break;
+		case 'E': str << std::scientific << std::uppercase; break;
+		case 'f': str << std::fixed; break;
+		}
+	}
+	
+	
+	void writeAnyInt(std::ostream& str, const Any& any)
+	{
+		if (any.type() == typeid(char))
+			str << static_cast<int>(AnyCast<char>(any));
+		else if (any.type() == typeid(signed char))
+			str << static_cast<int>(AnyCast<signed char>(any));
+		else if (any.type() == typeid(unsigned char))
+			str << static_cast<unsigned>(AnyCast<unsigned char>(any));
+		else if (any.type() == typeid(short))
+			str << AnyCast<short>(any);
+		else if (any.type() == typeid(unsigned short))
+			str << AnyCast<unsigned short>(any);
+		else if (any.type() == typeid(int))
+			str << AnyCast<int>(any);
+		else if (any.type() == typeid(unsigned int))
+			str << AnyCast<unsigned int>(any);
+		else if (any.type() == typeid(long))
+			str << AnyCast<long>(any);
+		else if (any.type() == typeid(unsigned long))
+			str << AnyCast<unsigned long>(any);
+		else if (any.type() == typeid(Int64))
+			str << AnyCast<Int64>(any);
+		else if (any.type() == typeid(UInt64))
+			str << AnyCast<UInt64>(any);
+		else if (any.type() == typeid(bool))
+			str << AnyCast<bool>(any);
+	}
+
+
+	void formatOne(std::string& result, std::string::const_iterator& itFmt, const std::string::const_iterator& endFmt, std::vector<Any>::const_iterator& itVal)
+	{
+		std::ostringstream str;
+#if !defined(POCO_NO_LOCALE)
+		str.imbue(std::locale::classic());
+#endif
+		try
+		{
+			parseFlags(str, itFmt, endFmt);
+			parseWidth(str, itFmt, endFmt);
+			parsePrec(str, itFmt, endFmt);
+			char mod = parseMod(itFmt, endFmt);
+			if (itFmt != endFmt)
+			{
+				char type = *itFmt++;
+				prepareFormat(str, type);
+				switch (type)
+				{
+				case 'b':
+					str << AnyCast<bool>(*itVal++);
+					break;
+				case 'c':
+					str << AnyCast<char>(*itVal++);
+					break;
+				case 'd':
+				case 'i':
+					switch (mod)
+					{
+					case 'l': str << AnyCast<long>(*itVal++); break;
+					case 'L': str << AnyCast<Int64>(*itVal++); break;
+					case 'h': str << AnyCast<short>(*itVal++); break;
+					case '?': writeAnyInt(str, *itVal++); break;
+					default:  str << AnyCast<int>(*itVal++); break;
+					}
+					break;
+				case 'o':
+				case 'u':
+				case 'x':
+				case 'X':
+					switch (mod)
+					{
+					case 'l': str << AnyCast<unsigned long>(*itVal++); break;
+					case 'L': str << AnyCast<UInt64>(*itVal++); break;
+					case 'h': str << AnyCast<unsigned short>(*itVal++); break;
+					case '?': writeAnyInt(str, *itVal++); break;
+					default:  str << AnyCast<unsigned>(*itVal++); break;
+					}
+					break;
+				case 'e':
+				case 'E':
+				case 'f':
+					switch (mod)
+					{
+					case 'l': str << AnyCast<long double>(*itVal++); break;
+					case 'L': str << AnyCast<long double>(*itVal++); break;
+					case 'h': str << AnyCast<float>(*itVal++); break;
+					default:  str << AnyCast<double>(*itVal++); break;
+					}
+					break;
+				case 's':
+					str << RefAnyCast<std::string>(*itVal++);
+					break;
+				case 'z':
+					str << AnyCast<std::size_t>(*itVal++); 
+					break;
+				case 'I':
+				case 'D':
+				default:
+					str << type;
+				}
+			}
+		}
+		catch (Poco::BadCastException&)
+		{
+			str << "[ERRFMT]";
+		}
+		result.append(str.str());
+	}
+}
+
+
+std::string format(const std::string& fmt, const Any& value)
+{
+	std::string result;
+	format(result, fmt, value);
+	return result;
+}
+
+
+std::string format(const std::string& fmt, const Any& value1, const Any& value2)
+{
+	std::string result;
+	format(result, fmt, value1, value2);
+	return result;
+}
+
+
+std::string format(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3)
+{
+	std::string result;
+	format(result, fmt, value1, value2, value3);
+	return result;
+}
+
+
+std::string format(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4)
+{
+	std::string result;
+	format(result, fmt, value1, value2, value3, value4);
+	return result;
+}
+
+
+std::string format(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5)
+{
+	std::string result;
+	format(result, fmt, value1, value2, value3, value4, value5);
+	return result;
+}
+
+
+std::string format(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6)
+{
+	std::string result;
+	format(result, fmt, value1, value2, value3, value4, value5, value6);
+	return result;
+}
+
+
+std::string format(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7)
+{
+	std::string result;
+	format(result, fmt, value1, value2, value3, value4, value5, value6, value7);
+	return result;
+}
+
+
+std::string format(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8)
+{
+	std::string result;
+	format(result, fmt, value1, value2, value3, value4, value5, value6, value7, value8);
+	return result;
+}
+
+
+std::string format(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9)
+{
+	std::string result;
+	format(result, fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9);
+	return result;
+}
+
+
+std::string format(const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10)
+{
+	std::string result;
+	format(result, fmt, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10);
+	return result;
+}
+
+
+void format(std::string& result, const std::string& fmt, const Any& value)
+{
+	std::vector<Any> args;
+	args.push_back(value);
+	format(result, fmt, args);
+}
+
+
+void format(std::string& result, const std::string& fmt, const Any& value1, const Any& value2)
+{
+	std::vector<Any> args;
+	args.push_back(value1);
+	args.push_back(value2);
+	format(result, fmt, args);
+}
+
+
+void format(std::string& result, const std::string& fmt, const Any& value1, const Any& value2, const Any& value3)
+{
+	std::vector<Any> args;
+	args.push_back(value1);
+	args.push_back(value2);
+	args.push_back(value3);
+	format(result, fmt, args);
+}
+
+
+void format(std::string& result, const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4)
+{
+	std::vector<Any> args;
+	args.push_back(value1);
+	args.push_back(value2);
+	args.push_back(value3);
+	args.push_back(value4);
+	format(result, fmt, args);
+}
+
+
+void format(std::string& result, const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5)
+{
+	std::vector<Any> args;
+	args.push_back(value1);
+	args.push_back(value2);
+	args.push_back(value3);
+	args.push_back(value4);
+	args.push_back(value5);
+	format(result, fmt, args);
+}
+
+
+void format(std::string& result, const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6)
+{
+	std::vector<Any> args;
+	args.push_back(value1);
+	args.push_back(value2);
+	args.push_back(value3);
+	args.push_back(value4);
+	args.push_back(value5);
+	args.push_back(value6);
+	format(result, fmt, args);
+}
+
+
+void format(std::string& result, const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7)
+{
+	std::vector<Any> args;
+	args.push_back(value1);
+	args.push_back(value2);
+	args.push_back(value3);
+	args.push_back(value4);
+	args.push_back(value5);
+	args.push_back(value6);
+	args.push_back(value7);
+	format(result, fmt, args);
+}
+
+
+void format(std::string& result, const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8)
+{
+	std::vector<Any> args;
+	args.push_back(value1);
+	args.push_back(value2);
+	args.push_back(value3);
+	args.push_back(value4);
+	args.push_back(value5);
+	args.push_back(value6);
+	args.push_back(value7);
+	args.push_back(value8);
+	format(result, fmt, args);
+}
+
+
+void format(std::string& result, const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9)
+{
+	std::vector<Any> args;
+	args.push_back(value1);
+	args.push_back(value2);
+	args.push_back(value3);
+	args.push_back(value4);
+	args.push_back(value5);
+	args.push_back(value6);
+	args.push_back(value7);
+	args.push_back(value8);
+	args.push_back(value9);
+	format(result, fmt, args);
+}
+
+
+void format(std::string& result, const std::string& fmt, const Any& value1, const Any& value2, const Any& value3, const Any& value4, const Any& value5, const Any& value6, const Any& value7, const Any& value8, const Any& value9, const Any& value10)
+{
+	std::vector<Any> args;
+	args.push_back(value1);
+	args.push_back(value2);
+	args.push_back(value3);
+	args.push_back(value4);
+	args.push_back(value5);
+	args.push_back(value6);
+	args.push_back(value7);
+	args.push_back(value8);
+	args.push_back(value9);
+	args.push_back(value10);
+	format(result, fmt, args);
+}
+
+
+void format(std::string& result, const std::string& fmt, const std::vector<Any>& values)
+{
+	std::string::const_iterator itFmt  = fmt.begin();
+	std::string::const_iterator endFmt = fmt.end();
+	std::vector<Any>::const_iterator itVal  = values.begin();
+	std::vector<Any>::const_iterator endVal = values.end(); 
+	while (itFmt != endFmt)
+	{
+		switch (*itFmt)
+		{
+		case '%':
+			++itFmt;
+			if (itFmt != endFmt && (itVal != endVal || *itFmt == '['))
+			{
+				if (*itFmt == '[')
+				{
+					++itFmt;
+					std::size_t index = parseIndex(itFmt, endFmt);
+					if (index < values.size())
+					{
+						std::vector<Any>::const_iterator it = values.begin() + index;
+						formatOne(result, itFmt, endFmt, it);
+					}
+					else throw InvalidArgumentException("format argument index out of range", fmt);
+				}
+				else
+				{
+					formatOne(result, itFmt, endFmt, itVal);
+				}
+			}
+			else if (itFmt != endFmt)
+			{
+				result += *itFmt++;
+			}
+			break;
+		default:
+			result += *itFmt;
+			++itFmt;
+		}
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Formatter.cpp b/base/poco/Foundation/src/Formatter.cpp
new file mode 100644
index 00000000000..2a1ac5f452d
--- /dev/null
+++ b/base/poco/Foundation/src/Formatter.cpp
@@ -0,0 +1,44 @@
+//
+// Formatter.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  Formatter
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Formatter.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+
+Formatter::Formatter()
+{
+}
+
+
+Formatter::~Formatter()
+{
+}
+
+
+void Formatter::setProperty(const std::string& name, const std::string& value)
+{
+	throw PropertyNotSupportedException();
+}
+
+
+std::string Formatter::getProperty(const std::string& name) const
+{
+	throw PropertyNotSupportedException();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/FormattingChannel.cpp b/base/poco/Foundation/src/FormattingChannel.cpp
new file mode 100644
index 00000000000..be6c0ae180c
--- /dev/null
+++ b/base/poco/Foundation/src/FormattingChannel.cpp
@@ -0,0 +1,126 @@
+//
+// FormattingChannel.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  Formatter
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/FormattingChannel.h"
+#include "Poco/Formatter.h"
+#include "Poco/Message.h"
+#include "Poco/LoggingRegistry.h"
+
+
+namespace Poco {
+
+
+FormattingChannel::FormattingChannel(): 
+	_pFormatter(0), 
+	_pChannel(0)
+{
+}
+
+
+FormattingChannel::FormattingChannel(Formatter* pFormatter): 
+	_pFormatter(pFormatter), 
+	_pChannel(0)
+{
+	if (_pFormatter) _pFormatter->duplicate();
+}
+
+
+FormattingChannel::FormattingChannel(Formatter* pFormatter, Channel* pChannel): 
+	_pFormatter(pFormatter), 
+	_pChannel(pChannel)
+{
+	if (_pFormatter) _pFormatter->duplicate();
+	if (_pChannel)   _pChannel->duplicate();
+}
+
+
+FormattingChannel::~FormattingChannel()
+{
+	if (_pChannel)   _pChannel->release();
+	if (_pFormatter) _pFormatter->release();
+}
+
+
+void FormattingChannel::setFormatter(Formatter* pFormatter)
+{
+	if (_pFormatter) _pFormatter->release();
+	_pFormatter = pFormatter;
+	if (_pFormatter) _pFormatter->duplicate();
+}
+
+
+Formatter* FormattingChannel::getFormatter() const
+{
+	return _pFormatter;
+}
+
+
+void FormattingChannel::setChannel(Channel* pChannel)
+{
+	if (_pChannel) _pChannel->release();
+	_pChannel = pChannel;
+	if (_pChannel) _pChannel->duplicate();
+}
+
+
+Channel* FormattingChannel::getChannel() const
+{
+	return _pChannel;
+}
+
+
+void FormattingChannel::log(const Message& msg)
+{
+	if (_pChannel)
+	{
+		if (_pFormatter)
+		{
+			std::string text;
+			_pFormatter->format(msg, text);
+			_pChannel->log(Message(msg, text));
+		}
+		else
+		{
+			_pChannel->log(msg);
+		}
+	}
+}
+
+
+void FormattingChannel::setProperty(const std::string& name, const std::string& value)
+{
+	if (name == "channel")
+		setChannel(LoggingRegistry::defaultRegistry().channelForName(value));
+	else if (name == "formatter")
+		setFormatter(LoggingRegistry::defaultRegistry().formatterForName(value));
+	else if (_pChannel)
+		_pChannel->setProperty(name, value);
+}
+
+
+void FormattingChannel::open()
+{
+	if (_pChannel)
+		_pChannel->open();
+}
+
+	
+void FormattingChannel::close()
+{
+	if (_pChannel)
+		_pChannel->close();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Glob.cpp b/base/poco/Foundation/src/Glob.cpp
new file mode 100644
index 00000000000..4ca64debc99
--- /dev/null
+++ b/base/poco/Foundation/src/Glob.cpp
@@ -0,0 +1,285 @@
+//
+// Glob.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  Glob
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Glob.h"
+#include "Poco/Path.h"
+#include "Poco/Exception.h"
+#include "Poco/DirectoryIterator.h"
+#include "Poco/File.h"
+#include "Poco/UTF8Encoding.h"
+#include "Poco/Unicode.h"
+
+
+namespace Poco {
+
+
+Glob::Glob(const std::string& pattern, int options)
+	: _pattern(pattern), _options(options)
+{
+}
+
+
+Glob::~Glob()
+{
+}
+
+
+bool Glob::match(const std::string& subject)
+{
+	UTF8Encoding utf8;
+	TextIterator itp(_pattern, utf8);
+	TextIterator endp(_pattern);
+	TextIterator its(subject, utf8);
+	TextIterator ends(subject);
+	
+	if ((_options & GLOB_DOT_SPECIAL) && its != ends && *its == '.' && (*itp == '?' || *itp == '*'))
+		return false;
+	else
+		return match(itp, endp, its, ends);
+}
+
+
+void Glob::glob(const std::string& pathPattern, std::set<std::string>& files, int options)
+{
+	glob(Path(Path::expand(pathPattern), Path::PATH_GUESS), files, options);
+}
+
+
+void Glob::glob(const char* pathPattern, std::set<std::string>& files, int options)
+{
+	glob(Path(Path::expand(pathPattern), Path::PATH_GUESS), files, options);
+}
+
+
+void Glob::glob(const Path& pathPattern, std::set<std::string>& files, int options)
+{
+	Path pattern(pathPattern);
+	pattern.makeDirectory(); // to simplify pattern handling later on
+	Path base(pattern);
+	Path absBase(base);
+	absBase.makeAbsolute();
+	// In case of UNC paths we must not pop the topmost directory
+	// (which must not contain wildcards), otherwise collect() will fail
+	// as one cannot create a DirectoryIterator with only a node name ("\\srv\").
+	int minDepth = base.getNode().empty() ? 0 : 1;
+	while (base.depth() > minDepth && base[base.depth() - 1] != "..")
+	{
+		base.popDirectory();
+		absBase.popDirectory();
+	}
+	if (pathPattern.isDirectory())
+		options |= GLOB_DIRS_ONLY;
+	collect(pattern, absBase, base, pathPattern[base.depth()], files, options);
+}
+
+
+void Glob::glob(const Path& pathPattern, const Path& basePath, std::set<std::string>& files, int options)
+{
+	Path pattern(pathPattern);
+	pattern.makeDirectory(); // to simplify pattern handling later on
+	Path absBase(basePath);
+	absBase.makeAbsolute();
+	if (pathPattern.isDirectory())
+		options |= GLOB_DIRS_ONLY;
+	collect(pattern, absBase, basePath, pathPattern[basePath.depth()], files, options);
+}
+
+
+bool Glob::match(TextIterator& itp, const TextIterator& endp, TextIterator& its, const TextIterator& ends)
+{
+	while (itp != endp)
+	{
+		if (its == ends)
+		{
+			while (itp != endp && *itp == '*') ++itp;
+			break;
+		}
+		switch (*itp)
+		{
+		case '?':
+			++itp; ++its;
+			break;
+		case '*':
+			if (++itp != endp)
+			{
+				while (its != ends && !matchAfterAsterisk(itp, endp, its, ends)) ++its;
+				return its != ends;
+			}
+			return true;
+		case '[':
+			if (++itp != endp) 
+			{
+				bool invert = *itp == '!';
+				if (invert) ++itp;
+				if (itp != endp)
+				{
+					bool mtch = matchSet(itp, endp, *its++);
+					if ((invert && mtch) || (!invert && !mtch)) return false;
+					break;
+				}
+			}
+			throw SyntaxException("bad range syntax in glob pattern");
+		case '\\':
+			if (++itp == endp) throw SyntaxException("backslash must be followed by character in glob pattern");
+			// fallthrough
+		default:
+			if (_options & GLOB_CASELESS)
+			{
+				if (Unicode::toLower(*itp) != Unicode::toLower(*its)) return false;
+			}
+			else
+			{
+				if (*itp != *its) return false;
+			}
+			++itp; ++its;
+		}
+	}
+	return itp == endp && its == ends;
+}
+
+
+bool Glob::matchAfterAsterisk(TextIterator itp, const TextIterator& endp, TextIterator its, const TextIterator& ends)
+{
+	return match(itp, endp, its, ends);
+}
+
+
+bool Glob::matchSet(TextIterator& itp, const TextIterator& endp, int c)
+{
+	if (_options & GLOB_CASELESS)
+		c = Unicode::toLower(c);
+
+	while (itp != endp)
+	{
+		switch (*itp)
+		{
+		case ']':
+			++itp; 
+			return false;
+		case '\\':
+			if (++itp == endp) throw SyntaxException("backslash must be followed by character in glob pattern");
+		}
+		int first = *itp;
+		int last  = first;
+		if (++itp != endp && *itp == '-')
+		{
+			if (++itp != endp)
+				last = *itp++;
+			else
+				throw SyntaxException("bad range syntax in glob pattern");
+		}
+		if (_options & GLOB_CASELESS)
+		{
+			first = Unicode::toLower(first);
+			last  = Unicode::toLower(last);
+		}
+		if (first <= c && c <= last)
+		{
+			while (itp != endp)
+			{
+				switch (*itp)
+				{
+				case ']':
+					++itp;
+					return true;
+				case '\\':
+					if (++itp == endp) break;
+				default:
+					++itp;
+				}
+			}
+			throw SyntaxException("range must be terminated by closing bracket in glob pattern");
+		}
+	}
+	return false;
+}
+
+
+void Glob::collect(const Path& pathPattern, const Path& base, const Path& current, const std::string& pattern, std::set<std::string>& files, int options)
+{
+	try
+	{
+		std::string pp = pathPattern.toString();
+		std::string basep = base.toString();
+		std::string curp  = current.toString();
+		Glob g(pattern, options);
+		DirectoryIterator it(base);
+		DirectoryIterator end;
+		while (it != end)
+		{
+			const std::string& name = it.name();
+			if (g.match(name))
+			{
+				Path p(current);
+				if (p.depth() < pathPattern.depth() - 1)
+				{
+					p.pushDirectory(name);
+					collect(pathPattern, it.path(), p, pathPattern[p.depth()], files, options);
+				}
+				else
+				{
+					p.setFileName(name);
+					if (isDirectory(p, (options & GLOB_FOLLOW_SYMLINKS) != 0))
+					{
+						p.makeDirectory();
+						files.insert(p.toString());
+					}
+					else if (!(options & GLOB_DIRS_ONLY))
+					{
+						files.insert(p.toString());
+					}
+				}
+			}
+			++it;
+		}
+	}
+	catch (Exception&)
+	{
+	}
+}
+
+
+bool Glob::isDirectory(const Path& path, bool followSymlink)
+{
+	File f(path);
+	bool isDir = false;
+	try
+	{
+		isDir = f.isDirectory();
+	}
+	catch (Poco::Exception&)
+	{
+		return false;
+	}
+	if (isDir)
+	{
+		return true;
+	}
+	else if (followSymlink && f.isLink())
+	{
+		try
+		{
+			// Test if link resolves to a directory.
+			DirectoryIterator it(f);
+			return true;
+		}
+		catch (Exception&)
+		{
+		}
+	}
+	return false;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Hash.cpp b/base/poco/Foundation/src/Hash.cpp
new file mode 100644
index 00000000000..c8a2772f59a
--- /dev/null
+++ b/base/poco/Foundation/src/Hash.cpp
@@ -0,0 +1,34 @@
+//
+// Hash.cpp
+//
+// Library: Foundation
+// Package: Hashing
+// Module:  Hash
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Hash.h"
+
+
+namespace Poco {
+
+
+std::size_t hash(const std::string& str)
+{
+	std::size_t h = 0;
+	std::string::const_iterator it  = str.begin();
+	std::string::const_iterator end = str.end();
+	while (it != end)
+	{
+		h = h * 0xf4243 ^ *it++;
+	}
+	return h;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/HashStatistic.cpp b/base/poco/Foundation/src/HashStatistic.cpp
new file mode 100644
index 00000000000..52f618d7aaa
--- /dev/null
+++ b/base/poco/Foundation/src/HashStatistic.cpp
@@ -0,0 +1,64 @@
+//
+// HashStatistic.cpp
+//
+// Library: Foundation
+// Package: Hashing
+// Module:  HashStatistic
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/HashStatistic.h"
+#include <sstream>
+
+namespace Poco {
+
+
+HashStatistic::HashStatistic(
+	UInt32 tableSize, 
+	UInt32 numEntries, 
+	UInt32 numZeroEntries, 
+	UInt32 maxEntry, 
+	std::vector<UInt32> details):
+	_sizeOfTable(tableSize),
+	_numberOfEntries(numEntries),
+	_numZeroEntries(numZeroEntries),
+	_maxEntriesPerHash(maxEntry),
+	_detailedEntriesPerHash(details)
+{
+}
+
+
+HashStatistic::~HashStatistic()
+{
+}
+
+
+std::string HashStatistic::toString() const
+{
+	std::ostringstream str;
+	str << "HashTable of size " << _sizeOfTable << " containing " << _numberOfEntries << " entries:\n";
+	str << "  NumberOfZeroEntries: " << _numZeroEntries << "\n";
+	str << "  MaxEntry: " << _maxEntriesPerHash << "\n";
+	str << "  AvgEntry: " << avgEntriesPerHash() << ", excl Zero slots: " << avgEntriesPerHashExclZeroEntries() << "\n";
+	str << "  DetailedStatistics: \n";
+	for (int i = 0; i < _detailedEntriesPerHash.size(); ++i)
+	{
+		// 10 entries per line
+		if (i % 10 == 0)
+		{
+			str << "\n  " << i << ":";
+		}
+		str << " " << _detailedEntriesPerHash[i];
+	}
+	str << "\n";
+	str.flush();
+	return str.str();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/HexBinaryDecoder.cpp b/base/poco/Foundation/src/HexBinaryDecoder.cpp
new file mode 100644
index 00000000000..7c80ac83389
--- /dev/null
+++ b/base/poco/Foundation/src/HexBinaryDecoder.cpp
@@ -0,0 +1,94 @@
+//
+// HexBinaryDecoder.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  HexBinary
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/HexBinaryDecoder.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+
+HexBinaryDecoderBuf::HexBinaryDecoderBuf(std::istream& istr): 
+	_buf(*istr.rdbuf())
+{
+}
+
+
+HexBinaryDecoderBuf::~HexBinaryDecoderBuf()
+{
+}
+
+
+int HexBinaryDecoderBuf::readFromDevice()
+{
+	int c;
+	int n;
+	if ((n = readOne()) == -1) return -1;
+	if (n >= '0' && n <= '9')
+		c = n - '0';
+	else if (n >= 'A' && n <= 'F')
+		c = n - 'A' + 10;
+	else if (n >= 'a' && n <= 'f')
+		c = n - 'a' + 10;
+	else throw DataFormatException();
+	c <<= 4;
+	if ((n = readOne()) == -1) throw DataFormatException();
+	if (n >= '0' && n <= '9')
+		c |= n - '0';
+	else if (n >= 'A' && n <= 'F')
+		c |= n - 'A' + 10;
+	else if (n >= 'a' && n <= 'f')
+		c |= n - 'a' + 10;
+	else throw DataFormatException();
+	return c;
+}
+
+
+int HexBinaryDecoderBuf::readOne()
+{
+	int ch = _buf.sbumpc();
+	while (ch == ' ' || ch == '\r' || ch == '\t' || ch == '\n')
+		ch = _buf.sbumpc();
+	return ch;
+}
+
+
+HexBinaryDecoderIOS::HexBinaryDecoderIOS(std::istream& istr): _buf(istr)
+{
+	poco_ios_init(&_buf);
+}
+
+
+HexBinaryDecoderIOS::~HexBinaryDecoderIOS()
+{
+}
+
+
+HexBinaryDecoderBuf* HexBinaryDecoderIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+HexBinaryDecoder::HexBinaryDecoder(std::istream& istr): HexBinaryDecoderIOS(istr), std::istream(&_buf)
+{
+}
+
+
+HexBinaryDecoder::~HexBinaryDecoder()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/HexBinaryEncoder.cpp b/base/poco/Foundation/src/HexBinaryEncoder.cpp
new file mode 100644
index 00000000000..728a2bfdfcd
--- /dev/null
+++ b/base/poco/Foundation/src/HexBinaryEncoder.cpp
@@ -0,0 +1,117 @@
+//
+// HexBinaryEncoder.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  HexBinary
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/HexBinaryEncoder.h"
+
+
+namespace Poco {
+
+
+HexBinaryEncoderBuf::HexBinaryEncoderBuf(std::ostream& ostr): 
+	_pos(0),
+	_lineLength(72),
+	_uppercase(0),
+	_buf(*ostr.rdbuf())
+{
+}
+
+
+HexBinaryEncoderBuf::~HexBinaryEncoderBuf()
+{
+	try
+	{
+		close();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+void HexBinaryEncoderBuf::setLineLength(int lineLength)
+{
+	_lineLength = lineLength;
+}
+
+
+int HexBinaryEncoderBuf::getLineLength() const
+{
+	return _lineLength;
+}
+
+
+void HexBinaryEncoderBuf::setUppercase(bool flag)
+{
+	_uppercase = flag ? 16 : 0;
+}
+
+
+int HexBinaryEncoderBuf::writeToDevice(char c)
+{
+	static const int eof = std::char_traits<char>::eof();
+	static const char digits[] = "0123456789abcdef0123456789ABCDEF";
+	
+	if (_buf.sputc(digits[_uppercase + ((c >> 4) & 0xF)]) == eof) return eof;
+	++_pos;
+	if (_buf.sputc(digits[_uppercase + (c & 0xF)]) == eof) return eof;
+	if (++_pos >= _lineLength && _lineLength > 0) 
+	{
+		if (_buf.sputc('\n') == eof) return eof;
+		_pos = 0;
+	}
+	return charToInt(c);
+}
+
+
+int HexBinaryEncoderBuf::close()
+{
+	sync();
+	return _buf.pubsync();
+}
+
+
+HexBinaryEncoderIOS::HexBinaryEncoderIOS(std::ostream& ostr): _buf(ostr)
+{
+	poco_ios_init(&_buf);
+}
+
+
+HexBinaryEncoderIOS::~HexBinaryEncoderIOS()
+{
+}
+
+
+int HexBinaryEncoderIOS::close()
+{
+	return _buf.close();
+}
+
+
+HexBinaryEncoderBuf* HexBinaryEncoderIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+HexBinaryEncoder::HexBinaryEncoder(std::ostream& ostr): HexBinaryEncoderIOS(ostr), std::ostream(&_buf)
+{
+}
+
+
+HexBinaryEncoder::~HexBinaryEncoder()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/InflatingStream.cpp b/base/poco/Foundation/src/InflatingStream.cpp
new file mode 100644
index 00000000000..68ba17763ab
--- /dev/null
+++ b/base/poco/Foundation/src/InflatingStream.cpp
@@ -0,0 +1,360 @@
+//
+// InflatingStream.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  ZLibStream
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/InflatingStream.h"
+#include "Poco/Exception.h"
+#include <cstring>
+
+
+namespace Poco {
+
+
+InflatingStreamBuf::InflatingStreamBuf(std::istream& istr, StreamType type): 
+	BufferedStreamBuf(STREAM_BUFFER_SIZE, std::ios::in),
+	_pIstr(&istr),
+	_pOstr(0),
+	_eof(false),
+	_check(type != STREAM_ZIP)
+{
+	_zstr.next_in   = 0;
+	_zstr.avail_in  = 0;
+	_zstr.total_in  = 0;
+	_zstr.next_out  = 0;
+	_zstr.avail_out = 0;
+	_zstr.total_out = 0;
+	_zstr.msg       = 0;
+	_zstr.state     = 0;
+	_zstr.zalloc    = Z_NULL;
+	_zstr.zfree     = Z_NULL;
+	_zstr.opaque    = Z_NULL;
+	_zstr.data_type = 0;
+	_zstr.adler     = 0;
+	_zstr.reserved  = 0;
+
+	_buffer = new char[INFLATE_BUFFER_SIZE];
+
+	int rc = inflateInit2(&_zstr, 15 + (type == STREAM_GZIP ? 16 : 0));
+	if (rc != Z_OK) 
+	{
+		delete [] _buffer;
+		throw IOException(zError(rc)); 
+	}
+}
+
+
+InflatingStreamBuf::InflatingStreamBuf(std::istream& istr, int windowBits): 
+	BufferedStreamBuf(STREAM_BUFFER_SIZE, std::ios::in),
+	_pIstr(&istr),
+	_pOstr(0),
+	_eof(false),
+	_check(false)
+{
+	_zstr.zalloc    = Z_NULL;
+	_zstr.zfree     = Z_NULL;
+	_zstr.opaque    = Z_NULL;
+	_zstr.next_in   = 0;
+	_zstr.avail_in  = 0;
+	_zstr.next_out  = 0;
+	_zstr.avail_out = 0;
+
+	_buffer = new char[INFLATE_BUFFER_SIZE];
+
+	int rc = inflateInit2(&_zstr, windowBits);
+	if (rc != Z_OK) 
+	{
+		delete [] _buffer;
+		throw IOException(zError(rc)); 
+	}
+}
+
+
+InflatingStreamBuf::InflatingStreamBuf(std::ostream& ostr, StreamType type): 
+	BufferedStreamBuf(STREAM_BUFFER_SIZE, std::ios::out),
+	_pIstr(0),
+	_pOstr(&ostr),
+	_eof(false),
+	_check(type != STREAM_ZIP)
+{
+	_zstr.zalloc    = Z_NULL;
+	_zstr.zfree     = Z_NULL;
+	_zstr.opaque    = Z_NULL;
+	_zstr.next_in   = 0;
+	_zstr.avail_in  = 0;
+	_zstr.next_out  = 0;
+	_zstr.avail_out = 0;
+
+	_buffer = new char[INFLATE_BUFFER_SIZE];
+
+	int rc = inflateInit2(&_zstr, 15 + (type == STREAM_GZIP ? 16 : 0));
+	if (rc != Z_OK) 
+	{
+		delete [] _buffer;
+		throw IOException(zError(rc));
+	}
+}
+
+
+InflatingStreamBuf::InflatingStreamBuf(std::ostream& ostr, int windowBits): 
+	BufferedStreamBuf(STREAM_BUFFER_SIZE, std::ios::out),
+	_pIstr(0),
+	_pOstr(&ostr),
+	_eof(false),
+	_check(false)
+{
+	_zstr.zalloc    = Z_NULL;
+	_zstr.zfree     = Z_NULL;
+	_zstr.opaque    = Z_NULL;
+	_zstr.next_in   = 0;
+	_zstr.avail_in  = 0;
+	_zstr.next_out  = 0;
+	_zstr.avail_out = 0;
+
+	_buffer = new char[INFLATE_BUFFER_SIZE];
+
+	int rc = inflateInit2(&_zstr, windowBits);
+	if (rc != Z_OK) 
+	{
+		delete [] _buffer;
+		throw IOException(zError(rc));
+	}
+}
+
+
+InflatingStreamBuf::~InflatingStreamBuf()
+{
+	try
+	{
+		close();
+	}
+	catch (...)
+	{
+	}
+	delete [] _buffer;
+	inflateEnd(&_zstr);
+}
+
+
+int InflatingStreamBuf::close()
+{
+	sync();
+	_pIstr = 0;
+	_pOstr = 0;
+	return 0;
+}
+
+
+void InflatingStreamBuf::reset()
+{
+	int rc = inflateReset(&_zstr);
+	if (rc == Z_OK)
+		_eof = false;
+	else
+		throw IOException(zError(rc));
+}
+
+
+int InflatingStreamBuf::readFromDevice(char* buffer, std::streamsize length)
+{
+	if (_eof || !_pIstr) return 0;
+
+	if (_zstr.avail_in == 0)
+	{
+		int n = 0;
+		if (_pIstr->good())
+		{
+			_pIstr->read(_buffer, INFLATE_BUFFER_SIZE);
+			n = static_cast<int>(_pIstr->gcount());
+		}
+		_zstr.next_in   = (unsigned char*) _buffer;
+		_zstr.avail_in  = n;
+	}
+	_zstr.next_out  = (unsigned char*) buffer;
+	_zstr.avail_out = static_cast<unsigned>(length);
+	for (;;)
+	{
+		int rc = inflate(&_zstr, Z_NO_FLUSH);
+		if (rc == Z_DATA_ERROR && !_check)
+		{
+			if (_zstr.avail_in == 0)
+			{
+				if (_pIstr->good())
+					rc = Z_OK;
+				else
+					rc = Z_STREAM_END;
+			}
+		}
+		if (rc == Z_STREAM_END)
+		{
+			_eof = true;
+			return static_cast<int>(length) - _zstr.avail_out;
+		}
+		if (rc != Z_OK) throw IOException(zError(rc));
+		if (_zstr.avail_out == 0)
+			return static_cast<int>(length);
+		if (_zstr.avail_in == 0)
+		{
+			int n = 0;
+			if (_pIstr->good())
+			{
+				_pIstr->read(_buffer, INFLATE_BUFFER_SIZE);
+				n = static_cast<int>(_pIstr->gcount());
+			}
+			if (n > 0)
+			{
+				_zstr.next_in  = (unsigned char*) _buffer;
+				_zstr.avail_in = n;
+			} 
+			else return static_cast<int>(length) - _zstr.avail_out;
+		}
+	}
+}
+
+
+int InflatingStreamBuf::writeToDevice(const char* buffer, std::streamsize length)
+{
+	if (length == 0 || !_pOstr) return 0;
+	
+	_zstr.next_in   = (unsigned char*) buffer;
+	_zstr.avail_in  = static_cast<unsigned>(length);
+	_zstr.next_out  = (unsigned char*) _buffer;
+	_zstr.avail_out = INFLATE_BUFFER_SIZE;
+	for (;;)
+	{
+		int rc = inflate(&_zstr, Z_NO_FLUSH);
+		if (rc == Z_STREAM_END)
+		{
+			_pOstr->write(_buffer, INFLATE_BUFFER_SIZE - _zstr.avail_out);
+			if (!_pOstr->good()) throw IOException(zError(rc));
+			break;
+		}
+		if (rc != Z_OK) throw IOException(zError(rc)); 
+		if (_zstr.avail_out == 0)
+		{
+			_pOstr->write(_buffer, INFLATE_BUFFER_SIZE);
+			if (!_pOstr->good()) throw IOException(zError(rc));
+			_zstr.next_out  = (unsigned char*) _buffer;
+			_zstr.avail_out = INFLATE_BUFFER_SIZE;
+		}
+		if (_zstr.avail_in == 0)
+		{
+			_pOstr->write(_buffer, INFLATE_BUFFER_SIZE - _zstr.avail_out);
+			if (!_pOstr->good()) throw IOException(zError(rc)); 
+			_zstr.next_out  = (unsigned char*) _buffer;
+			_zstr.avail_out = INFLATE_BUFFER_SIZE;
+			break;
+		}
+	}
+	return static_cast<int>(length);
+}
+
+
+int InflatingStreamBuf::sync()
+{
+	int n = BufferedStreamBuf::sync();
+	if (!n && _pOstr) _pOstr->flush();
+	return n;
+}
+
+
+InflatingIOS::InflatingIOS(std::ostream& ostr, InflatingStreamBuf::StreamType type):
+	_buf(ostr, type)
+{
+	poco_ios_init(&_buf);
+}
+
+
+InflatingIOS::InflatingIOS(std::ostream& ostr, int windowBits):
+	_buf(ostr, windowBits)
+{
+	poco_ios_init(&_buf);
+}
+
+
+InflatingIOS::InflatingIOS(std::istream& istr, InflatingStreamBuf::StreamType type):
+	_buf(istr, type)
+{
+	poco_ios_init(&_buf);
+}
+
+
+InflatingIOS::InflatingIOS(std::istream& istr, int windowBits):
+	_buf(istr, windowBits)
+{
+	poco_ios_init(&_buf);
+}
+
+
+InflatingIOS::~InflatingIOS()
+{
+}
+
+
+InflatingStreamBuf* InflatingIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+InflatingOutputStream::InflatingOutputStream(std::ostream& ostr, InflatingStreamBuf::StreamType type):
+	std::ostream(&_buf),
+	InflatingIOS(ostr, type)
+{
+}
+
+
+InflatingOutputStream::InflatingOutputStream(std::ostream& ostr, int windowBits):
+	std::ostream(&_buf),
+	InflatingIOS(ostr, windowBits)
+{
+}
+
+
+InflatingOutputStream::~InflatingOutputStream()
+{
+}
+
+
+int InflatingOutputStream::close()
+{
+	return _buf.close();
+}
+
+
+InflatingInputStream::InflatingInputStream(std::istream& istr, InflatingStreamBuf::StreamType type):
+	std::istream(&_buf),
+	InflatingIOS(istr, type)
+{
+}
+
+
+InflatingInputStream::InflatingInputStream(std::istream& istr, int windowBits):
+	std::istream(&_buf),
+	InflatingIOS(istr, windowBits)
+{
+}
+
+
+InflatingInputStream::~InflatingInputStream()
+{
+}
+
+
+void InflatingInputStream::reset()
+{
+	_buf.reset();
+	clear();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/JSONString.cpp b/base/poco/Foundation/src/JSONString.cpp
new file mode 100644
index 00000000000..16049765d50
--- /dev/null
+++ b/base/poco/Foundation/src/JSONString.cpp
@@ -0,0 +1,101 @@
+//
+// String.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  String
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+#include "Poco/JSONString.h"
+#include "Poco/UTF8String.h"
+#include <ostream>
+
+
+namespace {
+
+
+template<typename T, typename S>
+struct WriteFunc
+{
+	typedef T& (T::*Type)(const char* s, S n);
+};
+
+
+
+template<typename T, typename S>
+void writeString(const std::string &value, T& obj, typename WriteFunc<T, S>::Type write, int options)
+{
+	bool wrap = ((options & Poco::JSON_WRAP_STRINGS) != 0);
+	bool escapeAllUnicode = ((options & Poco::JSON_ESCAPE_UNICODE) != 0);
+
+	if (value.size() == 0)
+	{
+		if(wrap) (obj.*write)("\"\"", 2);
+		return;
+	}
+
+	if(wrap) (obj.*write)("\"", 1);
+	if(escapeAllUnicode)
+	{
+		std::string str = Poco::UTF8::escape(value.begin(), value.end(), true);
+		(obj.*write)(str.c_str(), str.size());
+	}
+	else
+	{
+		for(std::string::const_iterator it = value.begin(), end = value.end(); it != end; ++it)
+		{
+			// Forward slash isn't strictly required by JSON spec, but some parsers expect it
+			if((*it >= 0 && *it <= 31) || (*it == '"') || (*it == '\\') || (*it == '/'))
+			{
+				std::string str = Poco::UTF8::escape(it, it + 1, true);
+				(obj.*write)(str.c_str(), str.size());
+			}else (obj.*write)(&(*it), 1);
+		}
+	}
+	if(wrap) (obj.*write)("\"", 1);
+};
+
+
+}
+
+
+namespace Poco {
+
+
+void toJSON(const std::string& value, std::ostream& out, bool wrap)
+{
+	int options = (wrap ? Poco::JSON_WRAP_STRINGS : 0);
+	writeString<std::ostream, std::streamsize>(value, out, &std::ostream::write, options);
+}
+
+
+std::string toJSON(const std::string& value, bool wrap)
+{
+	int options = (wrap ? Poco::JSON_WRAP_STRINGS : 0);
+	std::string ret;
+	writeString<std::string,
+				std::string::size_type>(value, ret, &std::string::append, options);
+	return ret;
+}
+
+
+void toJSON(const std::string& value, std::ostream& out, int options)
+{
+	writeString<std::ostream, std::streamsize>(value, out, &std::ostream::write, options);
+}
+
+
+std::string toJSON(const std::string& value, int options)
+{
+	std::string ret;
+	writeString<std::string, std::string::size_type>(value, ret, &std::string::append, options);
+	return ret;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Latin1Encoding.cpp b/base/poco/Foundation/src/Latin1Encoding.cpp
new file mode 100644
index 00000000000..c5aa00d745a
--- /dev/null
+++ b/base/poco/Foundation/src/Latin1Encoding.cpp
@@ -0,0 +1,119 @@
+//
+// Latin1Encoding.cpp
+//
+// Library: Foundation
+// Package: Text
+// Module:  Latin1Encoding
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Latin1Encoding.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+
+
+const char* Latin1Encoding::_names[] =
+{
+	"ISO-8859-1",
+	"Latin1",
+	"Latin-1",
+	NULL
+};
+
+
+const TextEncoding::CharacterMap Latin1Encoding::_charMap = 
+{
+	/*          00    01    02    03    04    05    06    07    08    09    0a    0b    0c    0d    0e    0f   */
+	/* 00 */	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 
+	/* 10 */	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 
+	/* 20 */	0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 
+	/* 30 */	0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 
+	/* 40 */	0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 
+	/* 50 */	0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 
+	/* 60 */	0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 
+	/* 70 */	0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 
+	/* 80 */	0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 
+	/* 90 */	0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 
+	/* a0 */	0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 
+	/* b0 */	0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 
+	/* c0 */	0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 
+	/* d0 */	0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 
+	/* e0 */	0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 
+	/* f0 */	0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, 
+};
+
+
+Latin1Encoding::Latin1Encoding()
+{
+}
+
+
+Latin1Encoding::~Latin1Encoding()
+{
+}
+
+
+const char* Latin1Encoding::canonicalName() const
+{
+	return _names[0];
+}
+
+
+bool Latin1Encoding::isA(const std::string& encodingName) const
+{
+	for (const char** name = _names; *name; ++name)
+	{
+		if (Poco::icompare(encodingName, *name) == 0)
+			return true;
+	}
+	return false;
+}
+
+
+const TextEncoding::CharacterMap& Latin1Encoding::characterMap() const
+{
+	return _charMap;
+}
+
+
+int Latin1Encoding::convert(const unsigned char* bytes) const
+{
+	return *bytes;
+}
+
+
+int Latin1Encoding::convert(int ch, unsigned char* bytes, int length) const
+{
+	if (ch >= 0 && ch <= 255)
+	{
+		if (bytes && length >= 1)
+			*bytes = (unsigned char) ch;
+		return 1;
+	}
+	else return 0;
+}
+
+
+int Latin1Encoding::queryConvert(const unsigned char* bytes, int length) const
+{
+	if (1 <= length)
+		return *bytes;
+	else
+		return -1;
+}
+
+
+int Latin1Encoding::sequenceLength(const unsigned char* bytes, int length) const
+{
+	return 1;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Latin2Encoding.cpp b/base/poco/Foundation/src/Latin2Encoding.cpp
new file mode 100644
index 00000000000..a0c77150099
--- /dev/null
+++ b/base/poco/Foundation/src/Latin2Encoding.cpp
@@ -0,0 +1,179 @@
+//
+// Latin2Encoding.cpp
+//
+// Library: Foundation
+// Package: Text
+// Module:  Latin2Encoding
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Latin2Encoding.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+
+
+const char* Latin2Encoding::_names[] =
+{
+	"ISO-8859-2",
+	"Latin2",
+	"Latin-2",
+	NULL
+};
+
+
+const TextEncoding::CharacterMap Latin2Encoding::_charMap = 
+{
+	/*          00      01      02      03      04      05      06      07      08      09      0a      0b      0c      0d      0e      0f   */
+	/* 00 */	0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f, 
+	/* 10 */	0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f, 
+	/* 20 */	0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f, 
+	/* 30 */	0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f, 
+	/* 40 */	0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f, 
+	/* 50 */	0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f, 
+	/* 60 */	0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f, 
+	/* 70 */	0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f, 
+	/* 80 */	0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 
+	/* 90 */	0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 
+	/* a0 */	0x00a0, 0x0104, 0x02d8, 0x0141, 0x00a4, 0x013d, 0x015a, 0x00a7, 0x00a8, 0x0160, 0x015e, 0x0164, 0x0179, 0x00ad, 0x017d, 0x017b,
+	/* b0 */	0x00b0, 0x0105, 0x02db, 0x0142, 0x00b4, 0x013e, 0x015b, 0x02c7, 0x00b8, 0x0161, 0x015f, 0x0165, 0x017a, 0x02dd, 0x017e, 0x017c,
+	/* c0 */	0x0154, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0139, 0x0106, 0x00c7, 0x010c, 0x00c9, 0x0118, 0x00cb, 0x011a, 0x00cd, 0x00ce, 0x010e,
+	/* d0 */	0x0110, 0x0143, 0x0147, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x00d7, 0x0158, 0x016e, 0x00da, 0x0170, 0x00dc, 0x00dd, 0x0162, 0x00df,
+	/* e0 */	0x0155, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x013a, 0x0107, 0x00e7, 0x010d, 0x00e9, 0x0119, 0x00eb, 0x011b, 0x00ed, 0x00ee, 0x010f,
+	/* f0 */	0x0111, 0x0144, 0x0148, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x00f7, 0x0159, 0x016f, 0x00fa, 0x0171, 0x00fc, 0x00fd, 0x0163, 0x02d9,
+};
+
+
+Latin2Encoding::Latin2Encoding()
+{
+}
+
+
+Latin2Encoding::~Latin2Encoding()
+{
+}
+
+
+const char* Latin2Encoding::canonicalName() const
+{
+	return _names[0];
+}
+
+
+bool Latin2Encoding::isA(const std::string& encodingName) const
+{
+	for (const char** name = _names; *name; ++name)
+	{
+		if (Poco::icompare(encodingName, *name) == 0)
+			return true;
+	}
+	return false;
+}
+
+
+const TextEncoding::CharacterMap& Latin2Encoding::characterMap() const
+{
+	return _charMap;
+}
+
+
+int Latin2Encoding::convert(const unsigned char* bytes) const
+{
+	return _charMap[*bytes];
+}
+
+
+int Latin2Encoding::convert(int ch, unsigned char* bytes, int length) const
+{
+	if (ch >= 0 && ch <= 255 && _charMap[ch] == ch)
+	{
+		if (bytes && length >= 1)
+			*bytes = (unsigned char) ch;
+		return 1;
+	}
+	switch(ch)
+	{
+	case 0x0104: if (bytes && length >= 1) *bytes = 0xa1; return 1;
+	case 0x02d8: if (bytes && length >= 1) *bytes = 0xa2; return 1;
+	case 0x0141: if (bytes && length >= 1) *bytes = 0xa3; return 1;
+	case 0x013d: if (bytes && length >= 1) *bytes = 0xa5; return 1;
+	case 0x015a: if (bytes && length >= 1) *bytes = 0xa6; return 1;
+	case 0x0160: if (bytes && length >= 1) *bytes = 0xa9; return 1;
+	case 0x015e: if (bytes && length >= 1) *bytes = 0xaa; return 1;
+	case 0x0164: if (bytes && length >= 1) *bytes = 0xab; return 1;
+	case 0x0179: if (bytes && length >= 1) *bytes = 0xac; return 1;
+	case 0x017d: if (bytes && length >= 1) *bytes = 0xae; return 1;
+	case 0x017b: if (bytes && length >= 1) *bytes = 0xaf; return 1;
+	case 0x0105: if (bytes && length >= 1) *bytes = 0xb1; return 1;
+	case 0x02db: if (bytes && length >= 1) *bytes = 0xb2; return 1;
+	case 0x0142: if (bytes && length >= 1) *bytes = 0xb3; return 1;
+	case 0x013e: if (bytes && length >= 1) *bytes = 0xb5; return 1;
+	case 0x015b: if (bytes && length >= 1) *bytes = 0xb6; return 1;
+	case 0x02c7: if (bytes && length >= 1) *bytes = 0xb7; return 1;
+	case 0x0161: if (bytes && length >= 1) *bytes = 0xb9; return 1;
+	case 0x015f: if (bytes && length >= 1) *bytes = 0xba; return 1;
+	case 0x0165: if (bytes && length >= 1) *bytes = 0xbb; return 1;
+	case 0x017a: if (bytes && length >= 1) *bytes = 0xbc; return 1;
+	case 0x02dd: if (bytes && length >= 1) *bytes = 0xbd; return 1;
+	case 0x017e: if (bytes && length >= 1) *bytes = 0xbe; return 1;
+	case 0x017c: if (bytes && length >= 1) *bytes = 0xbf; return 1;
+	case 0x0154: if (bytes && length >= 1) *bytes = 0xc0; return 1;
+	case 0x0102: if (bytes && length >= 1) *bytes = 0xc3; return 1;
+	case 0x0139: if (bytes && length >= 1) *bytes = 0xc5; return 1;
+	case 0x0106: if (bytes && length >= 1) *bytes = 0xc6; return 1;
+	case 0x010c: if (bytes && length >= 1) *bytes = 0xc8; return 1;
+	case 0x0118: if (bytes && length >= 1) *bytes = 0xca; return 1;
+	case 0x011a: if (bytes && length >= 1) *bytes = 0xcc; return 1;
+	case 0x010e: if (bytes && length >= 1) *bytes = 0xcf; return 1;
+	case 0x0110: if (bytes && length >= 1) *bytes = 0xd0; return 1;
+	case 0x0143: if (bytes && length >= 1) *bytes = 0xd1; return 1;
+	case 0x0147: if (bytes && length >= 1) *bytes = 0xd2; return 1;
+	case 0x0150: if (bytes && length >= 1) *bytes = 0xd5; return 1;
+	case 0x0158: if (bytes && length >= 1) *bytes = 0xd8; return 1;
+	case 0x016e: if (bytes && length >= 1) *bytes = 0xd9; return 1;
+	case 0x0170: if (bytes && length >= 1) *bytes = 0xdb; return 1;
+	case 0x0162: if (bytes && length >= 1) *bytes = 0xde; return 1;
+	case 0x0155: if (bytes && length >= 1) *bytes = 0xe0; return 1;
+	case 0x0103: if (bytes && length >= 1) *bytes = 0xe3; return 1;
+	case 0x013a: if (bytes && length >= 1) *bytes = 0xe5; return 1;
+	case 0x0107: if (bytes && length >= 1) *bytes = 0xe6; return 1;
+	case 0x010d: if (bytes && length >= 1) *bytes = 0xe8; return 1;
+	case 0x0119: if (bytes && length >= 1) *bytes = 0xea; return 1;
+	case 0x011b: if (bytes && length >= 1) *bytes = 0xec; return 1;
+	case 0x010f: if (bytes && length >= 1) *bytes = 0xef; return 1;
+	case 0x0111: if (bytes && length >= 1) *bytes = 0xf0; return 1;
+	case 0x0144: if (bytes && length >= 1) *bytes = 0xf1; return 1;
+	case 0x0148: if (bytes && length >= 1) *bytes = 0xf2; return 1;
+	case 0x0151: if (bytes && length >= 1) *bytes = 0xf5; return 1;
+	case 0x0159: if (bytes && length >= 1) *bytes = 0xf8; return 1;
+	case 0x016f: if (bytes && length >= 1) *bytes = 0xf9; return 1;
+	case 0x0171: if (bytes && length >= 1) *bytes = 0xfb; return 1;
+	case 0x0163: if (bytes && length >= 1) *bytes = 0xfe; return 1;
+	case 0x02d9: if (bytes && length >= 1) *bytes = 0xff; return 1;
+	default: return 0;
+	}
+}
+
+
+int Latin2Encoding::queryConvert(const unsigned char* bytes, int length) const
+{
+	if (1 <= length)
+		return _charMap[*bytes];
+	else
+		return -1;
+}
+
+
+int Latin2Encoding::sequenceLength(const unsigned char* bytes, int length) const
+{
+	return 1;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Latin9Encoding.cpp b/base/poco/Foundation/src/Latin9Encoding.cpp
new file mode 100644
index 00000000000..eadc71f30e0
--- /dev/null
+++ b/base/poco/Foundation/src/Latin9Encoding.cpp
@@ -0,0 +1,130 @@
+//
+// Latin9Encoding.cpp
+//
+// Library: Foundation
+// Package: Text
+// Module:  Latin9Encoding
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Latin9Encoding.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+
+
+const char* Latin9Encoding::_names[] =
+{
+	"ISO-8859-15",
+	"Latin9",
+	"Latin-9",
+	NULL
+};
+
+
+const TextEncoding::CharacterMap Latin9Encoding::_charMap = 
+{
+	/*          00      01      02      03      04      05      06      07      08      09      0a      0b      0c      0d      0e      0f   */
+	/* 00 */	0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f, 
+	/* 10 */	0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f, 
+	/* 20 */	0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f, 
+	/* 30 */	0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f, 
+	/* 40 */	0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f, 
+	/* 50 */	0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f, 
+	/* 60 */	0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f, 
+	/* 70 */	0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f, 
+	/* 80 */	0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x0085, 0x0086, 0x0087, 0x0088, 0x0089, 0x008a, 0x008b, 0x008c, 0x008d, 0x008e, 0x008f, 
+	/* 90 */	0x0090, 0x0091, 0x0092, 0x0093, 0x0094, 0x0095, 0x0096, 0x0097, 0x0098, 0x0099, 0x009a, 0x009b, 0x009c, 0x009d, 0x009e, 0x009f, 
+	/* a0 */	0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x20ac, 0x00a5, 0x0160, 0x00a7, 0x0161, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af, 
+	/* b0 */	0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x017d, 0x00b5, 0x00b6, 0x00b7, 0x017e, 0x00b9, 0x00ba, 0x00bb, 0x0152, 0x0153, 0x0178, 0x00bf, 
+	/* c0 */	0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf, 
+	/* d0 */	0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df, 
+	/* e0 */	0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 
+	/* f0 */	0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff, 
+};
+
+
+Latin9Encoding::Latin9Encoding()
+{
+}
+
+
+Latin9Encoding::~Latin9Encoding()
+{
+}
+
+
+const char* Latin9Encoding::canonicalName() const
+{
+	return _names[0];
+}
+
+
+bool Latin9Encoding::isA(const std::string& encodingName) const
+{
+	for (const char** name = _names; *name; ++name)
+	{
+		if (Poco::icompare(encodingName, *name) == 0)
+			return true;
+	}
+	return false;
+}
+
+
+const TextEncoding::CharacterMap& Latin9Encoding::characterMap() const
+{
+	return _charMap;
+}
+
+
+int Latin9Encoding::convert(const unsigned char* bytes) const
+{
+	return _charMap[*bytes];
+}
+
+
+int Latin9Encoding::convert(int ch, unsigned char* bytes, int length) const
+{
+	if (ch >= 0 && ch <= 255 && _charMap[ch] == ch)
+	{
+		if (bytes && length >= 1)
+			*bytes = ch;
+		return 1;
+	}
+	else switch (ch)
+	{
+	case 0x0152: if (bytes && length >= 1) *bytes = 0xbc; return 1;
+	case 0x0153: if (bytes && length >= 1) *bytes = 0xbd; return 1;
+	case 0x0160: if (bytes && length >= 1) *bytes = 0xa6; return 1;
+	case 0x0161: if (bytes && length >= 1) *bytes = 0xa8; return 1;
+	case 0x017d: if (bytes && length >= 1) *bytes = 0xb4; return 1;
+	case 0x017e: if (bytes && length >= 1) *bytes = 0xb8; return 1;
+	case 0x0178: if (bytes && length >= 1) *bytes = 0xbe; return 1;
+	case 0x20ac: if (bytes && length >= 1) *bytes = 0xa4; return 1;
+	default: return 0;
+	}
+}
+
+
+int Latin9Encoding::queryConvert(const unsigned char* bytes, int length) const
+{
+	if (1 <= length)
+		return _charMap[*bytes];
+	else
+		return -1;
+}
+
+
+int Latin9Encoding::sequenceLength(const unsigned char* bytes, int length) const
+{
+	return 1;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/LineEndingConverter.cpp b/base/poco/Foundation/src/LineEndingConverter.cpp
new file mode 100644
index 00000000000..49b4b712293
--- /dev/null
+++ b/base/poco/Foundation/src/LineEndingConverter.cpp
@@ -0,0 +1,175 @@
+//
+// LineEndingConverter.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  LineEndingConverter
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/LineEndingConverter.h"
+
+
+namespace Poco {
+
+
+const std::string LineEnding::NEWLINE_DEFAULT(POCO_DEFAULT_NEWLINE_CHARS);
+const std::string LineEnding::NEWLINE_CR("\r");
+const std::string LineEnding::NEWLINE_CRLF("\r\n");
+const std::string LineEnding::NEWLINE_LF("\n");
+
+
+LineEndingConverterStreamBuf::LineEndingConverterStreamBuf(std::istream& istr): 
+	_pIstr(&istr), 
+	_pOstr(0), 
+	_newLine(LineEnding::NEWLINE_DEFAULT),
+	_lastChar(0)
+{
+	_it = _newLine.end();
+}
+
+
+LineEndingConverterStreamBuf::LineEndingConverterStreamBuf(std::ostream& ostr): 
+	_pIstr(0), 
+	_pOstr(&ostr), 
+	_newLine(LineEnding::NEWLINE_DEFAULT),
+	_lastChar(0)
+{
+	_it = _newLine.end();
+}
+
+
+LineEndingConverterStreamBuf::~LineEndingConverterStreamBuf()
+{
+}
+
+
+void LineEndingConverterStreamBuf::setNewLine(const std::string& newLineCharacters)
+{
+	_newLine = newLineCharacters;
+	_it      = _newLine.end();
+}
+
+
+const std::string& LineEndingConverterStreamBuf::getNewLine() const
+{
+	return _newLine;
+}
+
+
+int LineEndingConverterStreamBuf::readFromDevice()
+{
+	poco_assert_dbg (_pIstr);
+
+	while (_it == _newLine.end())
+	{
+		int c = _pIstr->get();
+		if (c == '\r')
+		{
+			if (_pIstr->peek() == '\n') _pIstr->get();
+			_it = _newLine.begin();
+		}
+		else if (c == '\n')
+		{
+			_it = _newLine.begin();
+		}
+		else return c;
+	}
+	return *_it++;
+}
+
+
+int LineEndingConverterStreamBuf::writeToDevice(char c)
+{
+	poco_assert_dbg (_pOstr);
+
+	if (c == '\r' || (c == '\n' && _lastChar != '\r'))
+		_pOstr->write(_newLine.data(), (std::streamsize) _newLine.length());
+	if (c != '\n' && c != '\r')
+		_pOstr->put(c);
+	_lastChar = c;
+	return charToInt(c);
+}
+
+
+LineEndingConverterIOS::LineEndingConverterIOS(std::istream& istr): _buf(istr)
+{
+	poco_ios_init(&_buf);
+}
+
+
+LineEndingConverterIOS::LineEndingConverterIOS(std::ostream& ostr): _buf(ostr)
+{
+	poco_ios_init(&_buf);
+}
+
+
+LineEndingConverterIOS::~LineEndingConverterIOS()
+{
+}
+
+
+void LineEndingConverterIOS::setNewLine(const std::string& newLineCharacters)
+{
+	_buf.setNewLine(newLineCharacters);
+}
+
+
+const std::string& LineEndingConverterIOS::getNewLine() const
+{
+	return _buf.getNewLine();
+}
+
+
+LineEndingConverterStreamBuf* LineEndingConverterIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+InputLineEndingConverter::InputLineEndingConverter(std::istream& istr): 
+	LineEndingConverterIOS(istr), 
+	std::istream(&_buf)
+{
+}
+
+
+InputLineEndingConverter::InputLineEndingConverter(std::istream& istr, const std::string& newLineCharacters): 
+	LineEndingConverterIOS(istr), 
+	std::istream(&_buf)
+{
+	setNewLine(newLineCharacters);
+}
+
+
+InputLineEndingConverter::~InputLineEndingConverter()
+{
+}
+
+
+OutputLineEndingConverter::OutputLineEndingConverter(std::ostream& ostr): 
+	LineEndingConverterIOS(ostr), 
+	std::ostream(&_buf)
+{
+}
+
+
+OutputLineEndingConverter::OutputLineEndingConverter(std::ostream& ostr, const std::string& newLineCharacters): 
+	LineEndingConverterIOS(ostr), 
+	std::ostream(&_buf)
+{
+	setNewLine(newLineCharacters);
+}
+
+
+OutputLineEndingConverter::~OutputLineEndingConverter()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/LocalDateTime.cpp b/base/poco/Foundation/src/LocalDateTime.cpp
new file mode 100644
index 00000000000..720f41a4d27
--- /dev/null
+++ b/base/poco/Foundation/src/LocalDateTime.cpp
@@ -0,0 +1,317 @@
+//
+// LocalDateTime.cpp
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  LocalDateTime
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/LocalDateTime.h"
+#include "Poco/Timezone.h"
+#include "Poco/Timespan.h"
+#include "Poco/Exception.h"
+#include <algorithm>
+#include <ctime>
+#if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
+#include "wce_time.h"
+#endif
+
+
+namespace Poco {
+
+
+LocalDateTime::LocalDateTime()
+{
+	determineTzd(true);
+}
+
+
+LocalDateTime::LocalDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond):
+	_dateTime(year, month, day, hour, minute, second, millisecond, microsecond)
+{
+	determineTzd();
+}
+
+
+LocalDateTime::LocalDateTime(int tzd, int year, int month, int day, int hour, int minute, int second, int millisecond, int microsecond):
+	_dateTime(year, month, day, hour, minute, second, millisecond, microsecond),
+	_tzd(tzd)
+{
+}
+
+
+LocalDateTime::LocalDateTime(double julianDay):
+	_dateTime(julianDay)
+{
+	determineTzd(true);
+}
+
+
+LocalDateTime::LocalDateTime(int tzd, double julianDay):
+	_dateTime(julianDay),
+	_tzd(tzd)
+{
+	adjustForTzd();
+}
+
+
+LocalDateTime::LocalDateTime(const DateTime& dateTime):
+	_dateTime(dateTime)
+{
+	determineTzd(true);
+}
+
+
+LocalDateTime::LocalDateTime(int tzd, const DateTime& dateTime):
+	_dateTime(dateTime),
+	_tzd(tzd)
+{
+	adjustForTzd();
+}
+
+
+LocalDateTime::LocalDateTime(int tzd, const DateTime& dateTime, bool adjust):
+	_dateTime(dateTime),
+	_tzd(tzd)
+{
+	if (adjust)
+		adjustForTzd();
+}
+
+
+LocalDateTime::LocalDateTime(const LocalDateTime& dateTime):
+	_dateTime(dateTime._dateTime),
+	_tzd(dateTime._tzd)
+{
+}
+
+
+LocalDateTime::LocalDateTime(Timestamp::UtcTimeVal utcTime, Timestamp::TimeDiff diff, int tzd):
+	_dateTime(utcTime, diff),
+	_tzd(tzd)
+{
+	adjustForTzd();
+}
+
+	
+LocalDateTime::~LocalDateTime()
+{
+}
+
+
+LocalDateTime& LocalDateTime::operator = (const LocalDateTime& dateTime)
+{
+	if (&dateTime != this)
+	{
+		_dateTime = dateTime._dateTime;
+		_tzd      = dateTime._tzd;
+	}
+	return *this;
+}
+
+
+LocalDateTime& LocalDateTime::operator = (const Timestamp& timestamp)
+{
+	if (timestamp != this->timestamp())
+	{
+		_dateTime = timestamp;
+		determineTzd(true);
+	}
+	return *this;
+}
+
+
+LocalDateTime& LocalDateTime::operator = (double julianDay)
+{
+	_dateTime = julianDay;
+	determineTzd(true);
+	return *this;
+}
+
+
+LocalDateTime& LocalDateTime::assign(int year, int month, int day, int hour, int minute, int second, int millisecond, int microseconds)
+{
+	_dateTime.assign(year, month, day, hour, minute, second, millisecond, microseconds);
+	determineTzd(false);
+	return *this;
+}
+
+
+LocalDateTime& LocalDateTime::assign(int tzd, int year, int month, int day, int hour, int minute, int second, int millisecond, int microseconds)
+{
+	_dateTime.assign(year, month, day, hour, minute, second, millisecond, microseconds);
+	_tzd = tzd;
+	return *this;
+}
+
+
+LocalDateTime& LocalDateTime::assign(int tzd, double julianDay)
+{
+	_tzd      = tzd;
+	_dateTime = julianDay;
+	adjustForTzd();
+	return *this;
+}
+
+
+void LocalDateTime::swap(LocalDateTime& dateTime)
+{
+	_dateTime.swap(dateTime._dateTime);
+	std::swap(_tzd, dateTime._tzd);
+}
+
+
+DateTime LocalDateTime::utc() const
+{
+	return DateTime(_dateTime.utcTime(), -((Timestamp::TimeDiff) _tzd)*Timespan::SECONDS);
+}
+
+
+bool LocalDateTime::operator == (const LocalDateTime& dateTime) const
+{
+	return utcTime() == dateTime.utcTime();
+}
+
+
+bool LocalDateTime::operator != (const LocalDateTime& dateTime) const	
+{
+	return utcTime() != dateTime.utcTime();
+}
+
+
+bool LocalDateTime::operator <  (const LocalDateTime& dateTime) const	
+{
+	return utcTime() < dateTime.utcTime();
+}
+
+
+bool LocalDateTime::operator <= (const LocalDateTime& dateTime) const	
+{
+	return utcTime() <= dateTime.utcTime();
+}
+
+
+bool LocalDateTime::operator >  (const LocalDateTime& dateTime) const	
+{
+	return utcTime() > dateTime.utcTime();
+}
+
+
+bool LocalDateTime::operator >= (const LocalDateTime& dateTime) const	
+{
+	return utcTime() >= dateTime.utcTime();
+}
+
+
+LocalDateTime LocalDateTime::operator + (const Timespan& span) const
+{
+	// First calculate the adjusted UTC time, then calculate the
+	// locally adjusted time by constructing a new LocalDateTime.
+	DateTime tmp(utcTime(), span.totalMicroseconds());
+	return LocalDateTime(tmp);
+}
+
+
+LocalDateTime LocalDateTime::operator - (const Timespan& span) const
+{
+	// First calculate the adjusted UTC time, then calculate the
+	// locally adjusted time by constructing a new LocalDateTime.
+	DateTime tmp(utcTime(), -span.totalMicroseconds());
+	return LocalDateTime(tmp);
+}
+
+
+Timespan LocalDateTime::operator - (const LocalDateTime& dateTime) const
+{
+	return Timespan((utcTime() - dateTime.utcTime())/10);
+}
+
+
+LocalDateTime& LocalDateTime::operator += (const Timespan& span)
+{
+	// Use the same trick as in operator+. Create a UTC time, adjust
+	// it for the span, and convert back to LocalDateTime. This will
+	// recalculate the tzd correctly in the case where the addition
+	// crosses a DST boundary.
+	*this = DateTime(utcTime(), span.totalMicroseconds());
+	return *this;
+}
+
+
+LocalDateTime& LocalDateTime::operator -= (const Timespan& span)
+{
+	// Use the same trick as in operator-. Create a UTC time, adjust
+	// it for the span, and convert back to LocalDateTime. This will
+	// recalculate the tzd correctly in the case where the subtraction
+	// crosses a DST boundary.
+	*this = DateTime(utcTime(), -span.totalMicroseconds());
+	return *this;
+}
+
+
+void LocalDateTime::determineTzd(bool adjust)
+{
+	if (adjust)
+	{
+		std::time_t epochTime = _dateTime.timestamp().epochTime();
+#if defined(_WIN32) || defined(POCO_NO_POSIX_TSF)
+#if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
+		std::tm* broken = wceex_localtime(&epochTime);
+#else
+		std::tm* broken = std::localtime(&epochTime);
+#endif
+		if (!broken) throw Poco::SystemException("cannot get local time");
+		_tzd = (Timezone::utcOffset() + ((broken->tm_isdst == 1) ? 3600 : 0));
+#else
+		std::tm broken;
+#if defined(POCO_VXWORKS)
+		if (localtime_r(&epochTime, &broken) != OK)
+			throw Poco::SystemException("cannot get local time");
+#else
+		if (!localtime_r(&epochTime, &broken))
+			throw Poco::SystemException("cannot get local time");
+#endif
+		_tzd = (Timezone::utcOffset() + ((broken.tm_isdst == 1) ? 3600 : 0));
+#endif
+		adjustForTzd();
+	}
+	else
+	{
+		int dst;
+		dstOffset(dst);
+		_tzd = (Timezone::utcOffset() + dst);
+	}
+}
+
+
+std::time_t LocalDateTime::dstOffset(int& dstOffset) const
+{
+	std::time_t local;
+	std::tm     broken;
+
+	broken.tm_year  = (_dateTime.year() - 1900);
+	broken.tm_mon   = (_dateTime.month() - 1);
+	broken.tm_mday  = _dateTime.day();
+	broken.tm_hour  = _dateTime.hour();
+	broken.tm_min   = _dateTime.minute();
+	broken.tm_sec   = _dateTime.second();
+	broken.tm_isdst = -1;
+#if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
+	local = wceex_mktime(&broken);
+#else
+	local = std::mktime(&broken);
+#endif
+	
+	dstOffset = (broken.tm_isdst == 1) ? 3600 : 0;
+	return local;
+}
+
+
+} // namespace Poco
+
diff --git a/base/poco/Foundation/src/LogFile.cpp b/base/poco/Foundation/src/LogFile.cpp
new file mode 100644
index 00000000000..2aaaf8c5698
--- /dev/null
+++ b/base/poco/Foundation/src/LogFile.cpp
@@ -0,0 +1,40 @@
+//
+// LogFile.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  LogFile
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/LogFile.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS) && defined(POCO_WIN32_UTF8)
+#include "LogFile_WIN32U.cpp"
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "LogFile_WIN32.cpp"
+#else
+#include "LogFile_STD.cpp"
+#endif
+
+
+namespace Poco {
+
+
+LogFile::LogFile(const std::string& path): LogFileImpl(path)
+{
+}
+
+
+LogFile::~LogFile()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/LogFile_STD.cpp b/base/poco/Foundation/src/LogFile_STD.cpp
new file mode 100644
index 00000000000..034ccabfb62
--- /dev/null
+++ b/base/poco/Foundation/src/LogFile_STD.cpp
@@ -0,0 +1,76 @@
+//
+// LogFile_STD.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  LogFile
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/LogFile_STD.h"
+#include "Poco/File.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+
+LogFileImpl::LogFileImpl(const std::string& path): 
+	_path(path),
+	_str(_path, std::ios::app)
+{
+	if (sizeImpl() == 0)
+		_creationDate = File(path).getLastModified();
+	else
+		_creationDate = File(path).created();
+}
+
+
+LogFileImpl::~LogFileImpl()
+{
+}
+
+
+void LogFileImpl::writeImpl(const std::string& text, bool flush)
+{
+	_str << text;
+	if (flush)
+		_str << std::endl;
+	else
+		_str << "\n";
+	if (!_str.good()) throw WriteFileException(_path);
+}
+
+void LogFileImpl::writeBinaryImpl(const char * data, size_t size, bool flush)
+{
+	_str.write(data, size);
+	if (flush) _str.flush();
+	if (!_str.good()) throw WriteFileException(_path);
+}
+
+UInt64 LogFileImpl::sizeImpl() const
+{
+	if (!_str.good())
+        	throw FileException(_path);
+	return (UInt64) _str.tellp();
+}
+
+
+Timestamp LogFileImpl::creationDateImpl() const
+{
+	return _creationDate;
+}
+
+
+const std::string& LogFileImpl::pathImpl() const
+{
+	return _path;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/LogFile_WIN32.cpp b/base/poco/Foundation/src/LogFile_WIN32.cpp
new file mode 100644
index 00000000000..df1d403c44f
--- /dev/null
+++ b/base/poco/Foundation/src/LogFile_WIN32.cpp
@@ -0,0 +1,125 @@
+//
+// LogFile_WIN32.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  LogFile
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/LogFile_WIN32.h"
+#include "Poco/File.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+
+LogFileImpl::LogFileImpl(const std::string& path): _path(path), _hFile(INVALID_HANDLE_VALUE)
+{
+	File file(path);
+	if (file.exists())
+	{
+		if (0 == sizeImpl())
+			_creationDate = file.getLastModified();
+		else
+			_creationDate = file.created();
+	}
+}
+
+
+LogFileImpl::~LogFileImpl()
+{
+	CloseHandle(_hFile);
+}
+
+
+void LogFileImpl::writeImpl(const std::string& text, bool flush)
+{
+	if (INVALID_HANDLE_VALUE == _hFile)	createFile();
+
+	DWORD bytesWritten;
+	BOOL res = WriteFile(_hFile, text.data(), (DWORD) text.size(), &bytesWritten, NULL);
+	if (!res) throw WriteFileException(_path);
+	res = WriteFile(_hFile, "\r\n", 2, &bytesWritten, NULL);
+	if (!res) throw WriteFileException(_path);
+	if (flush)
+	{
+		res = FlushFileBuffers(_hFile);
+		if (!res) throw WriteFileException(_path);
+	}
+}
+
+void LogFileImpl::writeBinaryImpl(const char * data, size_t size, bool flush)
+{
+	if (INVALID_HANDLE_VALUE == _hFile)	createFile();
+
+	DWORD bytesWritten;
+	BOOL res = WriteFile(_hFile, text.data(), (DWORD) text.size(), &bytesWritten, NULL);
+	if (!res) throw WriteFileException(_path);
+	if (flush)
+	{
+		res = FlushFileBuffers(_hFile);
+		if (!res) throw WriteFileException(_path);
+	}
+}
+
+
+UInt64 LogFileImpl::sizeImpl() const
+{
+	if (INVALID_HANDLE_VALUE == _hFile)
+	{
+		File file(_path);
+		if (file.exists()) return file.getSize();
+		else return 0;
+	}
+
+	LARGE_INTEGER li;
+	li.HighPart = 0;
+	li.LowPart  = SetFilePointer(_hFile, 0, &li.HighPart, FILE_CURRENT);
+	return li.QuadPart;
+}
+
+
+Timestamp LogFileImpl::creationDateImpl() const
+{
+	return _creationDate;
+}
+
+
+const std::string& LogFileImpl::pathImpl() const
+{
+	return _path;
+}
+
+
+void LogFileImpl::createFile()
+{
+	_hFile = CreateFileA(_path.c_str(), GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+	if (_hFile == INVALID_HANDLE_VALUE) throw OpenFileException(_path);
+	SetFilePointer(_hFile, 0, 0, FILE_END);
+	// There seems to be a strange "optimization" in the Windows NTFS
+	// filesystem that causes it to reuse directory entries of deleted
+	// files. Example:
+	// 1. create a file named "test.dat"
+	//    note the file's creation date
+	// 2. delete the file "test.dat"
+	// 3. wait a few seconds
+	// 4. create a file named "test.dat"
+	//    the new file will have the same creation
+	//    date as the old one.
+	// We work around this bug by taking the file's
+	// modification date as a reference when the
+	// file is empty.
+	if (sizeImpl() == 0)
+		_creationDate = File(_path).getLastModified();
+	else
+		_creationDate = File(_path).created();
+}
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/LogFile_WIN32U.cpp b/base/poco/Foundation/src/LogFile_WIN32U.cpp
new file mode 100644
index 00000000000..c85e6086a4a
--- /dev/null
+++ b/base/poco/Foundation/src/LogFile_WIN32U.cpp
@@ -0,0 +1,130 @@
+//
+// LogFile_WIN32U.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  LogFile
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/LogFile_WIN32U.h"
+#include "Poco/File.h"
+#include "Poco/Exception.h"
+#include "Poco/UnicodeConverter.h"
+
+
+namespace Poco {
+
+
+LogFileImpl::LogFileImpl(const std::string& path): _path(path), _hFile(INVALID_HANDLE_VALUE)
+{
+	File file(path);
+	if (file.exists())
+	{
+		if (0 == sizeImpl())
+			_creationDate = file.getLastModified();
+		else
+			_creationDate = file.created();
+	}
+}
+
+
+LogFileImpl::~LogFileImpl()
+{
+	CloseHandle(_hFile);
+}
+
+
+void LogFileImpl::writeImpl(const std::string& text, bool flush)
+{
+	if (INVALID_HANDLE_VALUE == _hFile)	createFile();
+
+	DWORD bytesWritten;
+	BOOL res = WriteFile(_hFile, text.data(), (DWORD) text.size(), &bytesWritten, NULL);
+	if (!res) throw WriteFileException(_path);
+	res = WriteFile(_hFile, "\r\n", 2, &bytesWritten, NULL);
+	if (!res) throw WriteFileException(_path);
+	if (flush)
+	{
+		res = FlushFileBuffers(_hFile);
+		if (!res) throw WriteFileException(_path);
+	}
+}
+
+void LogFileImpl::writeBinaryImpl(const char * data, size_t size, bool flush)
+{
+	if (INVALID_HANDLE_VALUE == _hFile)	createFile();
+
+	DWORD bytesWritten;
+	BOOL res = WriteFile(_hFile, data, (DWORD) size, &bytesWritten, NULL);
+	if (!res) throw WriteFileException(_path);
+	if (flush)
+	{
+		res = FlushFileBuffers(_hFile);
+		if (!res) throw WriteFileException(_path);
+	}
+}
+
+
+UInt64 LogFileImpl::sizeImpl() const
+{
+	if (INVALID_HANDLE_VALUE == _hFile)
+	{
+		File file(_path);
+		if (file.exists()) return file.getSize();
+		else return 0;
+	}
+
+	LARGE_INTEGER li;
+	li.HighPart = 0;
+	li.LowPart  = SetFilePointer(_hFile, 0, &li.HighPart, FILE_CURRENT);
+	return li.QuadPart;
+}
+
+
+Timestamp LogFileImpl::creationDateImpl() const
+{
+	return _creationDate;
+}
+
+
+const std::string& LogFileImpl::pathImpl() const
+{
+	return _path;
+}
+
+
+void LogFileImpl::createFile()
+{
+	std::wstring upath;
+	FileImpl::convertPath(_path, upath);
+	
+	_hFile = CreateFileW(upath.c_str(), GENERIC_WRITE, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+	if (_hFile == INVALID_HANDLE_VALUE) throw OpenFileException(_path);
+	SetFilePointer(_hFile, 0, 0, FILE_END);
+	// There seems to be a strange "optimization" in the Windows NTFS
+	// filesystem that causes it to reuse directory entries of deleted
+	// files. Example:
+	// 1. create a file named "test.dat"
+	//    note the file's creation date
+	// 2. delete the file "test.dat"
+	// 3. wait a few seconds
+	// 4. create a file named "test.dat"
+	//    the new file will have the same creation
+	//    date as the old one.
+	// We work around this bug by taking the file's
+	// modification date as a reference when the
+	// file is empty.
+	if (sizeImpl() == 0)
+		_creationDate = File(_path).getLastModified();
+	else
+		_creationDate = File(_path).created();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/LogStream.cpp b/base/poco/Foundation/src/LogStream.cpp
new file mode 100644
index 00000000000..00e100b6bcc
--- /dev/null
+++ b/base/poco/Foundation/src/LogStream.cpp
@@ -0,0 +1,231 @@
+//
+// LogStream.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  LogStream
+//
+// Copyright (c) 2006-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/LogStream.h"
+
+
+namespace Poco {
+
+
+//
+// LogStreamBuf
+//
+
+
+LogStreamBuf::LogStreamBuf(Logger& logger, Message::Priority priority):
+	_logger(logger),
+	_priority(priority)
+{
+}
+
+
+LogStreamBuf::~LogStreamBuf()
+{
+}
+
+
+void LogStreamBuf::setPriority(Message::Priority priority)
+{
+	_priority = priority;
+}
+
+
+int LogStreamBuf::writeToDevice(char c)
+{
+	if (c == '\n' || c == '\r')
+	{
+		if (_message.find_first_not_of("\r\n") != std::string::npos)
+		{
+			Message msg(_logger.name(), _message, _priority);
+			_message.clear();
+			_logger.log(msg);
+		}
+	}
+	else _message += c;
+	return c;
+}
+
+
+//
+// LogIOS
+//
+
+
+LogIOS::LogIOS(Logger& logger, Message::Priority priority):
+	_buf(logger, priority)
+{
+	poco_ios_init(&_buf);
+}
+
+
+LogIOS::~LogIOS()
+{
+}
+
+
+LogStreamBuf* LogIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+//
+// LogStream
+//
+
+
+LogStream::LogStream(Logger& logger, Message::Priority priority):
+	LogIOS(logger, priority),
+	std::ostream(&_buf)
+{
+}
+
+
+LogStream::LogStream(const std::string& loggerName, Message::Priority priority):
+	LogIOS(Logger::get(loggerName), priority),
+	std::ostream(&_buf)
+{
+}
+
+	
+LogStream::~LogStream()
+{
+}
+
+	
+LogStream& LogStream::fatal()
+{
+	return priority(Message::PRIO_FATAL);
+}
+
+
+LogStream& LogStream::fatal(const std::string& message)
+{
+	_buf.logger().fatal(message);
+	return priority(Message::PRIO_FATAL);
+}
+
+	
+LogStream& LogStream::critical()
+{
+	return priority(Message::PRIO_CRITICAL);
+}
+
+
+LogStream& LogStream::critical(const std::string& message)
+{
+	_buf.logger().critical(message);
+	return priority(Message::PRIO_CRITICAL);
+}
+
+
+LogStream& LogStream::error()
+{
+	return priority(Message::PRIO_ERROR);
+}
+
+
+LogStream& LogStream::error(const std::string& message)
+{
+	_buf.logger().error(message);
+	return priority(Message::PRIO_ERROR);
+}
+
+
+LogStream& LogStream::warning()
+{
+	return priority(Message::PRIO_WARNING);
+}
+
+
+LogStream& LogStream::warning(const std::string& message)
+{
+	_buf.logger().warning(message);
+	return priority(Message::PRIO_WARNING);
+}
+
+
+LogStream& LogStream::notice()
+{
+	return priority(Message::PRIO_NOTICE);
+}
+
+
+LogStream& LogStream::notice(const std::string& message)
+{
+	_buf.logger().notice(message);
+	return priority(Message::PRIO_NOTICE);
+}
+
+
+LogStream& LogStream::information()
+{
+	return priority(Message::PRIO_INFORMATION);
+}
+
+
+LogStream& LogStream::information(const std::string& message)
+{
+	_buf.logger().information(message);
+	return priority(Message::PRIO_INFORMATION);
+}
+
+
+LogStream& LogStream::debug()
+{
+	return priority(Message::PRIO_DEBUG);
+}
+
+
+LogStream& LogStream::debug(const std::string& message)
+{
+	_buf.logger().debug(message);
+	return priority(Message::PRIO_DEBUG);
+}
+
+
+LogStream& LogStream::trace()
+{
+	return priority(Message::PRIO_TRACE);
+}
+
+
+LogStream& LogStream::trace(const std::string& message)
+{
+	_buf.logger().trace(message);
+	return priority(Message::PRIO_TRACE);
+}
+
+
+LogStream& LogStream::test()
+{
+	return priority(Message::PRIO_TEST);
+}
+
+
+LogStream& LogStream::test(const std::string& message)
+{
+	_buf.logger().test(message);
+	return priority(Message::PRIO_TEST);
+}
+
+
+LogStream& LogStream::priority(Message::Priority priority)
+{
+	_buf.setPriority(priority);
+	return *this;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Logger.cpp b/base/poco/Foundation/src/Logger.cpp
new file mode 100644
index 00000000000..445ba52ae1a
--- /dev/null
+++ b/base/poco/Foundation/src/Logger.cpp
@@ -0,0 +1,485 @@
+//
+// Logger.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  Logger
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Logger.h"
+#include "Poco/Formatter.h"
+#include "Poco/LoggingRegistry.h"
+#include "Poco/Exception.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/NumberParser.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+
+
+Logger::LoggerMap* Logger::_pLoggerMap = 0;
+Mutex Logger::_mapMtx;
+const std::string Logger::ROOT;
+
+
+Logger::Logger(const std::string& name, Channel* pChannel, int level): _name(name), _pChannel(pChannel), _level(level)
+{
+	if (pChannel) pChannel->duplicate();
+}
+
+
+Logger::~Logger()
+{
+	if (_pChannel) _pChannel->release();
+}
+
+
+void Logger::setChannel(Channel* pChannel)
+{
+	if (_pChannel) _pChannel->release();
+	_pChannel = pChannel;
+	if (_pChannel) _pChannel->duplicate();
+}
+
+
+Channel* Logger::getChannel() const
+{
+	return _pChannel;
+}
+
+
+void Logger::setLevel(int level)
+{
+	_level = level;
+}
+
+
+void Logger::setLevel(const std::string& level)
+{
+	setLevel(parseLevel(level));
+}
+
+
+void Logger::setProperty(const std::string& name, const std::string& value)
+{
+	if (name == "channel")
+		setChannel(LoggingRegistry::defaultRegistry().channelForName(value));
+	else if (name == "level")
+		setLevel(value);
+	else 
+		Channel::setProperty(name, value);
+}
+
+
+void Logger::log(const Message& msg)
+{
+	if (_level >= msg.getPriority() && _pChannel)
+	{
+		_pChannel->log(msg);
+	}
+}
+
+
+void Logger::log(const Exception& exc)
+{
+	error(exc.displayText());
+}
+
+
+void Logger::log(const Exception& exc, const char* file, int line)
+{
+	error(exc.displayText(), file, line);
+}
+
+
+void Logger::dump(const std::string& msg, const void* buffer, std::size_t length, Message::Priority prio)
+{
+	if (_level >= prio && _pChannel)
+	{
+		std::string text(msg);
+		formatDump(text, buffer, length);
+		_pChannel->log(Message(_name, text, prio));
+	}
+}
+
+
+void Logger::setLevel(const std::string& name, int level)
+{
+	Mutex::ScopedLock lock(_mapMtx);
+
+	if (_pLoggerMap)
+	{
+		std::string::size_type len = name.length();
+		for (LoggerMap::iterator it = _pLoggerMap->begin(); it != _pLoggerMap->end(); ++it)
+		{
+			if (len == 0 || 
+				(it->first.compare(0, len, name) == 0 && (it->first.length() == len || it->first[len] == '.')))
+			{
+				it->second->setLevel(level);
+			}
+		}
+	}
+}
+
+
+void Logger::setChannel(const std::string& name, Channel* pChannel)
+{
+	Mutex::ScopedLock lock(_mapMtx);
+
+	if (_pLoggerMap)
+	{
+		std::string::size_type len = name.length();
+		for (LoggerMap::iterator it = _pLoggerMap->begin(); it != _pLoggerMap->end(); ++it)
+		{
+			if (len == 0 ||
+				(it->first.compare(0, len, name) == 0 && (it->first.length() == len || it->first[len] == '.')))
+			{
+				it->second->setChannel(pChannel);
+			}
+		}
+	}
+}
+
+
+void Logger::setProperty(const std::string& loggerName, const std::string& propertyName, const std::string& value)
+{
+	Mutex::ScopedLock lock(_mapMtx);
+
+	if (_pLoggerMap)
+	{
+		std::string::size_type len = loggerName.length();
+		for (LoggerMap::iterator it = _pLoggerMap->begin(); it != _pLoggerMap->end(); ++it)
+		{
+			if (len == 0 ||
+				(it->first.compare(0, len, loggerName) == 0 && (it->first.length() == len || it->first[len] == '.')))
+			{
+				it->second->setProperty(propertyName, value);
+			}
+		}
+	}
+}
+
+
+std::string Logger::format(const std::string& fmt, const std::string& arg)
+{
+	std::string args[] =
+	{
+		arg
+	};
+	return format(fmt, 1, args);
+}
+
+
+std::string Logger::format(const std::string& fmt, const std::string& arg0, const std::string& arg1)
+{
+	std::string args[] =
+	{
+		arg0,
+		arg1
+	};
+	return format(fmt, 2, args);
+}
+
+
+std::string Logger::format(const std::string& fmt, const std::string& arg0, const std::string& arg1, const std::string& arg2)
+{
+	std::string args[] =
+	{
+		arg0,
+		arg1,
+		arg2
+	};
+	return format(fmt, 3, args);
+}
+
+
+std::string Logger::format(const std::string& fmt, const std::string& arg0, const std::string& arg1, const std::string& arg2, const std::string& arg3)
+{
+	std::string args[] =
+	{
+		arg0,
+		arg1,
+		arg2,
+		arg3
+	};
+	return format(fmt, 4, args);
+}
+
+
+std::string Logger::format(const std::string& fmt, int argc, std::string argv[])
+{
+	std::string result;
+	std::string::const_iterator it = fmt.begin();
+	while (it != fmt.end())
+	{
+		if (*it == '$')
+		{
+			++it;
+			if (*it == '$')
+			{
+				result += '$';
+			}
+			else if (*it >= '0' && *it <= '9')
+			{
+				int i = *it - '0';
+				if (i < argc)
+					result += argv[i];
+			}
+			else
+			{
+				result += '$';
+				result += *it;
+			}
+		}
+		else result += *it;
+		++it;
+	}
+	return result;
+}
+
+
+void Logger::formatDump(std::string& message, const void* buffer, std::size_t length)
+{
+	const int BYTES_PER_LINE = 16;
+
+	message.reserve(message.size() + length*6);
+	if (!message.empty()) message.append("\n");
+	unsigned char* base = (unsigned char*) buffer;
+	int addr = 0;
+	while (addr < length)
+	{
+		if (addr > 0) message.append("\n");
+		message.append(NumberFormatter::formatHex(addr, 4));
+		message.append("  ");
+		int offset = 0;
+		while (addr + offset < length && offset < BYTES_PER_LINE)
+		{
+			message.append(NumberFormatter::formatHex(base[addr + offset], 2));
+			message.append(offset == 7 ? "  " : " ");
+			++offset;
+		}
+		if (offset < 7) message.append(" ");
+		while (offset < BYTES_PER_LINE) { message.append("   "); ++offset; }
+		message.append(" ");
+		offset = 0;
+		while (addr + offset < length && offset < BYTES_PER_LINE)
+		{
+			unsigned char c = base[addr + offset];
+			message += (c >= 32 && c < 127) ? (char) c : '.';
+			++offset;
+		}
+		addr += BYTES_PER_LINE;
+	}
+}
+
+
+Logger& Logger::get(const std::string& name)
+{
+	Mutex::ScopedLock lock(_mapMtx);
+
+	return unsafeGet(name);
+}
+
+
+Logger& Logger::unsafeGet(const std::string& name)
+{
+	Logger* pLogger = find(name);
+	if (!pLogger)
+	{
+		if (name == ROOT)
+		{
+			pLogger = new Logger(name, 0, Message::PRIO_INFORMATION);
+		}
+		else
+		{
+			Logger& par = parent(name);
+			pLogger = new Logger(name, par.getChannel(), par.getLevel());
+		}
+		add(pLogger);
+	}
+	return *pLogger;
+}
+
+
+Logger& Logger::create(const std::string& name, Channel* pChannel, int level)
+{
+	Mutex::ScopedLock lock(_mapMtx);
+
+	if (find(name)) throw ExistsException();
+	Logger* pLogger = new Logger(name, pChannel, level);
+	add(pLogger);
+	return *pLogger;
+}
+
+
+Logger& Logger::root()
+{
+	Mutex::ScopedLock lock(_mapMtx);
+
+	return unsafeGet(ROOT);
+}
+
+
+Logger* Logger::has(const std::string& name)
+{
+	Mutex::ScopedLock lock(_mapMtx);
+
+	return find(name);
+}
+
+
+void Logger::shutdown()
+{
+	Mutex::ScopedLock lock(_mapMtx);
+
+	if (_pLoggerMap)
+	{
+		for (LoggerMap::iterator it = _pLoggerMap->begin(); it != _pLoggerMap->end(); ++it)
+		{
+			it->second->release();
+		}
+		delete _pLoggerMap;
+		_pLoggerMap = 0;
+	}
+}
+
+
+Logger* Logger::find(const std::string& name)
+{
+	if (_pLoggerMap)
+	{
+		LoggerMap::iterator it = _pLoggerMap->find(name);
+		if (it != _pLoggerMap->end())
+			return it->second;
+	}
+	return 0;
+}
+
+
+void Logger::destroy(const std::string& name)
+{
+	Mutex::ScopedLock lock(_mapMtx);
+
+	if (_pLoggerMap)
+	{
+		LoggerMap::iterator it = _pLoggerMap->find(name);
+		if (it != _pLoggerMap->end())
+		{
+			it->second->release();
+			_pLoggerMap->erase(it);
+		}
+	}
+}
+
+
+void Logger::names(std::vector<std::string>& names)
+{
+	Mutex::ScopedLock lock(_mapMtx);
+
+	names.clear();
+	if (_pLoggerMap)
+	{
+		for (LoggerMap::const_iterator it = _pLoggerMap->begin(); it != _pLoggerMap->end(); ++it)
+		{
+			names.push_back(it->first);
+		}
+	}
+}
+
+
+Logger& Logger::parent(const std::string& name)
+{
+	std::string::size_type pos = name.rfind('.');
+	if (pos != std::string::npos)
+	{
+		std::string pname = name.substr(0, pos);
+		Logger* pParent = find(pname);
+		if (pParent)
+			return *pParent;
+		else
+			return parent(pname);
+	}
+	else return unsafeGet(ROOT);
+}
+
+
+int Logger::parseLevel(const std::string& level)
+{
+	if (icompare(level, "none") == 0)
+		return 0;
+	else if (icompare(level, "fatal") == 0)
+		return Message::PRIO_FATAL;
+	else if (icompare(level, "critical") == 0)
+		return Message::PRIO_CRITICAL;
+	else if (icompare(level, "error") == 0)
+		return Message::PRIO_ERROR;
+	else if (icompare(level, "warning") == 0)
+		return Message::PRIO_WARNING;
+	else if (icompare(level, "notice") == 0)
+		return Message::PRIO_NOTICE;
+	else if (icompare(level, "information") == 0)
+		return Message::PRIO_INFORMATION;
+	else if (icompare(level, "debug") == 0)
+		return Message::PRIO_DEBUG;
+	else if (icompare(level, "trace") == 0)
+		return Message::PRIO_TRACE;
+	else if (icompare(level, "test") == 0)
+		return Message::PRIO_TEST;
+	else
+	{
+		int numLevel;
+		if (Poco::NumberParser::tryParse(level, numLevel))
+		{
+			if (numLevel > 0 && numLevel < 10)
+				return numLevel;
+			else
+				throw InvalidArgumentException("Log level out of range ", level);
+		}
+		else
+			throw InvalidArgumentException("Not a valid log level", level);
+	}
+}
+
+
+class AutoLoggerShutdown
+{
+public:
+	AutoLoggerShutdown()
+	{
+	}
+	~AutoLoggerShutdown()
+	{
+		try
+		{
+			Logger::shutdown();
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	}
+};
+
+
+namespace
+{
+	static AutoLoggerShutdown als;
+}
+
+
+void Logger::add(Logger* pLogger)
+{
+	if (!_pLoggerMap)
+		_pLoggerMap = new LoggerMap;
+	_pLoggerMap->insert(LoggerMap::value_type(pLogger->name(), pLogger));
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/LoggingFactory.cpp b/base/poco/Foundation/src/LoggingFactory.cpp
new file mode 100644
index 00000000000..f3e067a6111
--- /dev/null
+++ b/base/poco/Foundation/src/LoggingFactory.cpp
@@ -0,0 +1,117 @@
+//
+// LoggingFactory.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  LoggingFactory
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/LoggingFactory.h"
+#include "Poco/SingletonHolder.h"
+#include "Poco/AsyncChannel.h"
+#include "Poco/ConsoleChannel.h"
+#include "Poco/FileChannel.h"
+#include "Poco/FormattingChannel.h"
+#include "Poco/SplitterChannel.h"
+#include "Poco/NullChannel.h"
+#include "Poco/EventChannel.h"
+#if defined(POCO_OS_FAMILY_UNIX) && !defined(POCO_NO_SYSLOGCHANNEL)
+#include "Poco/SyslogChannel.h"
+#endif
+#if defined(POCO_OS_FAMILY_WINDOWS) && !defined(_WIN32_WCE)
+#include "Poco/EventLogChannel.h"
+#include "Poco/WindowsConsoleChannel.h"
+#endif
+#include "Poco/PatternFormatter.h"
+
+
+namespace Poco {
+
+
+LoggingFactory::LoggingFactory()
+{
+	registerBuiltins();
+}
+
+
+LoggingFactory::~LoggingFactory()
+{
+}
+
+
+void LoggingFactory::registerChannelClass(const std::string& className, ChannelInstantiator* pFactory)
+{
+	_channelFactory.registerClass(className, pFactory);
+}
+
+
+void LoggingFactory::registerFormatterClass(const std::string& className, FormatterFactory* pFactory)
+{
+	_formatterFactory.registerClass(className, pFactory);
+}
+
+
+Channel* LoggingFactory::createChannel(const std::string& className) const
+{
+	return _channelFactory.createInstance(className);
+}
+
+
+Formatter* LoggingFactory::createFormatter(const std::string& className) const
+{
+	return _formatterFactory.createInstance(className);
+}
+
+
+namespace
+{
+	static SingletonHolder<LoggingFactory> sh;
+}
+
+
+LoggingFactory& LoggingFactory::defaultFactory()
+{
+	return *sh.get();
+}
+
+
+void LoggingFactory::registerBuiltins()
+{
+	_channelFactory.registerClass("AsyncChannel", new Instantiator<AsyncChannel, Channel>);
+#if defined(POCO_OS_FAMILY_WINDOWS) && !defined(_WIN32_WCE)
+	_channelFactory.registerClass("ConsoleChannel", new Instantiator<WindowsConsoleChannel, Channel>);
+	_channelFactory.registerClass("ColorConsoleChannel", new Instantiator<WindowsColorConsoleChannel, Channel>);
+#else
+	_channelFactory.registerClass("ConsoleChannel", new Instantiator<ConsoleChannel, Channel>);
+	_channelFactory.registerClass("ColorConsoleChannel", new Instantiator<ColorConsoleChannel, Channel>);
+#endif
+#ifndef POCO_NO_FILECHANNEL
+	_channelFactory.registerClass("FileChannel", new Instantiator<FileChannel, Channel>);
+#endif
+	_channelFactory.registerClass("FormattingChannel", new Instantiator<FormattingChannel, Channel>);
+#ifndef POCO_NO_SPLITTERCHANNEL
+	_channelFactory.registerClass("SplitterChannel", new Instantiator<SplitterChannel, Channel>);
+#endif
+	_channelFactory.registerClass("NullChannel", new Instantiator<NullChannel, Channel>);
+	_channelFactory.registerClass("EventChannel", new Instantiator<EventChannel, Channel>);
+
+#if defined(POCO_OS_FAMILY_UNIX)
+#ifndef POCO_NO_SYSLOGCHANNEL
+	_channelFactory.registerClass("SyslogChannel", new Instantiator<SyslogChannel, Channel>);
+#endif
+#endif
+#if defined(POCO_OS_FAMILY_WINDOWS) && !defined(_WIN32_WCE)
+	_channelFactory.registerClass("EventLogChannel", new Instantiator<EventLogChannel, Channel>);
+#endif
+
+	_formatterFactory.registerClass("PatternFormatter", new Instantiator<PatternFormatter, Formatter>);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/LoggingRegistry.cpp b/base/poco/Foundation/src/LoggingRegistry.cpp
new file mode 100644
index 00000000000..9d7edfef475
--- /dev/null
+++ b/base/poco/Foundation/src/LoggingRegistry.cpp
@@ -0,0 +1,117 @@
+//
+// LoggingRegistry.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  LoggingRegistry
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/LoggingRegistry.h"
+#include "Poco/SingletonHolder.h"
+
+
+namespace Poco {
+
+
+LoggingRegistry::LoggingRegistry()
+{
+}
+
+
+LoggingRegistry::~LoggingRegistry()
+{
+}
+
+
+Channel* LoggingRegistry::channelForName(const std::string& name) const
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	ChannelMap::const_iterator it = _channelMap.find(name);
+	if (it != _channelMap.end())
+		return const_cast<Channel*>(it->second.get());
+	else
+		throw NotFoundException("logging channel", name);
+}
+
+
+Formatter* LoggingRegistry::formatterForName(const std::string& name) const
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	FormatterMap::const_iterator it = _formatterMap.find(name);
+	if (it != _formatterMap.end())
+		return const_cast<Formatter*>(it->second.get());
+	else
+		throw NotFoundException("logging formatter", name);
+}
+
+
+void LoggingRegistry::registerChannel(const std::string& name, Channel* pChannel)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	_channelMap[name] = ChannelPtr(pChannel, true);
+}
+
+	
+void LoggingRegistry::registerFormatter(const std::string& name, Formatter* pFormatter)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	_formatterMap[name] = FormatterPtr(pFormatter, true);
+}
+
+
+void LoggingRegistry::unregisterChannel(const std::string& name)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	ChannelMap::iterator it = _channelMap.find(name);
+	if (it != _channelMap.end())
+		_channelMap.erase(it);
+	else
+		throw NotFoundException("logging channel", name);
+}
+
+
+void LoggingRegistry::unregisterFormatter(const std::string& name)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	FormatterMap::iterator it = _formatterMap.find(name);
+	if (it != _formatterMap.end())
+		_formatterMap.erase(it);
+	else
+		throw NotFoundException("logging formatter", name);
+}
+
+
+void LoggingRegistry::clear()
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	_channelMap.clear();
+	_formatterMap.clear();
+}
+
+
+namespace
+{
+	static SingletonHolder<LoggingRegistry> sh;
+}
+
+
+LoggingRegistry& LoggingRegistry::defaultRegistry()
+{
+	return *sh.get();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/MD4Engine.cpp b/base/poco/Foundation/src/MD4Engine.cpp
new file mode 100644
index 00000000000..cab90623185
--- /dev/null
+++ b/base/poco/Foundation/src/MD4Engine.cpp
@@ -0,0 +1,278 @@
+//
+// MD4Engine.cpp
+//
+// Library: Foundation
+// Package: Crypt
+// Module:  MD4Engine
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+//
+// MD4 (RFC 1320) algorithm:
+// Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+// rights reserved.
+//
+// License to copy and use this software is granted provided that it
+// is identified as the "RSA Data Security, Inc. MD4 Message-Digest
+// Algorithm" in all material mentioning or referencing this software
+// or this function.
+//
+// License is also granted to make and use derivative works provided
+// that such works are identified as "derived from the RSA Data
+// Security, Inc. MD4 Message-Digest Algorithm" in all material
+// mentioning or referencing the derived work.
+//
+// RSA Data Security, Inc. makes no representations concerning either
+// the merchantability of this software or the suitability of this
+// software for any particular purpose. It is provided "as is"
+// without express or implied warranty of any kind.
+//
+// These notices must be retained in any copies of any part of this
+// documentation and/or software.
+//
+
+
+#include "Poco/MD4Engine.h"
+#include <cstring>
+
+
+namespace Poco {
+
+
+MD4Engine::MD4Engine()
+{
+	_digest.reserve(16);
+	reset();
+}
+
+
+MD4Engine::~MD4Engine()
+{
+	reset();
+}
+
+	
+void MD4Engine::updateImpl(const void* input_, std::size_t inputLen)
+{
+	const unsigned char* input = (const unsigned char*) input_;
+	unsigned int i, index, partLen;
+
+	/* Compute number of bytes mod 64 */
+	index = (unsigned int)((_context.count[0] >> 3) & 0x3F);
+
+	/* Update number of bits */
+	if ((_context.count[0] += ((UInt32) inputLen << 3)) < ((UInt32) inputLen << 3))
+		_context.count[1]++;
+	_context.count[1] += ((UInt32) inputLen >> 29);
+
+	partLen = 64 - index;
+
+	/* Transform as many times as possible. */
+	if (inputLen >= partLen) 
+	{
+		std::memcpy(&_context.buffer[index], input, partLen);
+		transform(_context.state, _context.buffer);
+
+		for (i = partLen; i + 63 < inputLen; i += 64)
+			transform(_context.state, &input[i]);
+
+		index = 0;
+	}
+	else i = 0;
+
+	/* Buffer remaining input */
+	std::memcpy(&_context.buffer[index], &input[i], inputLen-i);
+}
+
+
+std::size_t MD4Engine::digestLength() const
+{
+	return DIGEST_SIZE;
+}
+
+
+void MD4Engine::reset()
+{
+	std::memset(&_context, 0, sizeof(_context));
+	_context.count[0] = _context.count[1] = 0;
+	_context.state[0] = 0x67452301;
+	_context.state[1] = 0xefcdab89;
+	_context.state[2] = 0x98badcfe;
+	_context.state[3] = 0x10325476;
+}
+
+
+const DigestEngine::Digest& MD4Engine::digest()
+{
+	static const unsigned char PADDING[64] = 
+	{
+		0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+	};
+	unsigned char bits[8];
+	unsigned int index, padLen;
+
+	/* Save number of bits */
+	encode(bits, _context.count, 8);
+
+	/* Pad out to 56 mod 64. */
+	index = (unsigned int)((_context.count[0] >> 3) & 0x3f);
+	padLen = (index < 56) ? (56 - index) : (120 - index);
+	update(PADDING, padLen);
+
+	/* Append length (before padding) */
+	update(bits, 8);
+
+	/* Store state in digest */
+	unsigned char digest[16];
+	encode(digest, _context.state, 16);
+	_digest.clear();
+	_digest.insert(_digest.begin(), digest, digest + sizeof(digest));
+
+	/* Zeroize sensitive information. */
+	std::memset(&_context, 0, sizeof (_context));
+	reset();
+	return _digest;
+}
+
+
+/* Constants for MD4Transform routine. */
+#define S11 3
+#define S12 7
+#define S13 11
+#define S14 19
+#define S21 3
+#define S22 5
+#define S23 9
+#define S24 13
+#define S31 3
+#define S32 9
+#define S33 11
+#define S34 15
+
+
+/* F, G and H are basic MD4 functions. */
+#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
+#define G(x, y, z) (((x) & (y)) | ((x) & (z)) | ((y) & (z)))
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+
+
+/* ROTATE_LEFT rotates x left n bits. */
+#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
+
+
+/* FF, GG and HH are transformations for rounds 1, 2 and 3 */
+/* Rotation is separate from addition to prevent recomputation */
+#define FF(a, b, c, d, x, s) { \
+    (a) += F ((b), (c), (d)) + (x); \
+    (a) = ROTATE_LEFT ((a), (s)); \
+  }
+#define GG(a, b, c, d, x, s) { \
+    (a) += G ((b), (c), (d)) + (x) + (UInt32)0x5a827999; \
+    (a) = ROTATE_LEFT ((a), (s)); \
+  }
+#define HH(a, b, c, d, x, s) { \
+    (a) += H ((b), (c), (d)) + (x) + (UInt32)0x6ed9eba1; \
+    (a) = ROTATE_LEFT ((a), (s)); \
+  }
+
+
+void MD4Engine::transform (UInt32 state[4], const unsigned char block[64])
+{
+	UInt32 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
+
+	decode(x, block, 64);
+
+	/* Round 1 */
+	FF (a, b, c, d, x[ 0], S11); /* 1 */
+	FF (d, a, b, c, x[ 1], S12); /* 2 */
+	FF (c, d, a, b, x[ 2], S13); /* 3 */
+	FF (b, c, d, a, x[ 3], S14); /* 4 */
+	FF (a, b, c, d, x[ 4], S11); /* 5 */
+	FF (d, a, b, c, x[ 5], S12); /* 6 */
+	FF (c, d, a, b, x[ 6], S13); /* 7 */
+	FF (b, c, d, a, x[ 7], S14); /* 8 */
+	FF (a, b, c, d, x[ 8], S11); /* 9 */
+	FF (d, a, b, c, x[ 9], S12); /* 10 */
+	FF (c, d, a, b, x[10], S13); /* 11 */
+	FF (b, c, d, a, x[11], S14); /* 12 */
+	FF (a, b, c, d, x[12], S11); /* 13 */
+	FF (d, a, b, c, x[13], S12); /* 14 */
+	FF (c, d, a, b, x[14], S13); /* 15 */
+	FF (b, c, d, a, x[15], S14); /* 16 */
+
+	/* Round 2 */
+	GG (a, b, c, d, x[ 0], S21); /* 17 */
+	GG (d, a, b, c, x[ 4], S22); /* 18 */
+	GG (c, d, a, b, x[ 8], S23); /* 19 */
+	GG (b, c, d, a, x[12], S24); /* 20 */
+	GG (a, b, c, d, x[ 1], S21); /* 21 */
+	GG (d, a, b, c, x[ 5], S22); /* 22 */
+	GG (c, d, a, b, x[ 9], S23); /* 23 */
+	GG (b, c, d, a, x[13], S24); /* 24 */
+	GG (a, b, c, d, x[ 2], S21); /* 25 */
+	GG (d, a, b, c, x[ 6], S22); /* 26 */
+	GG (c, d, a, b, x[10], S23); /* 27 */
+	GG (b, c, d, a, x[14], S24); /* 28 */
+	GG (a, b, c, d, x[ 3], S21); /* 29 */
+	GG (d, a, b, c, x[ 7], S22); /* 30 */
+	GG (c, d, a, b, x[11], S23); /* 31 */
+	GG (b, c, d, a, x[15], S24); /* 32 */
+
+	/* Round 3 */
+	HH (a, b, c, d, x[ 0], S31); /* 33 */
+	HH (d, a, b, c, x[ 8], S32); /* 34 */
+	HH (c, d, a, b, x[ 4], S33); /* 35 */
+	HH (b, c, d, a, x[12], S34); /* 36 */
+	HH (a, b, c, d, x[ 2], S31); /* 37 */
+	HH (d, a, b, c, x[10], S32); /* 38 */
+	HH (c, d, a, b, x[ 6], S33); /* 39 */
+	HH (b, c, d, a, x[14], S34); /* 40 */
+	HH (a, b, c, d, x[ 1], S31); /* 41 */
+	HH (d, a, b, c, x[ 9], S32); /* 42 */
+	HH (c, d, a, b, x[ 5], S33); /* 43 */
+	HH (b, c, d, a, x[13], S34); /* 44 */
+	HH (a, b, c, d, x[ 3], S31); /* 45 */
+	HH (d, a, b, c, x[11], S32); /* 46 */
+	HH (c, d, a, b, x[ 7], S33); /* 47 */
+	HH (b, c, d, a, x[15], S34); /* 48 */
+
+	state[0] += a;
+	state[1] += b;
+	state[2] += c;
+	state[3] += d;
+
+	/* Zeroize sensitive information. */
+	std::memset(x, 0, sizeof(x));
+}
+
+
+void MD4Engine::encode(unsigned char* output, const UInt32* input, std::size_t len)
+{
+	unsigned int i, j;
+
+	for (i = 0, j = 0; j < len; i++, j += 4)
+	{
+		output[j]   = (unsigned char)(input[i] & 0xff);
+		output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
+		output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
+		output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
+	}
+}
+
+
+void MD4Engine::decode(UInt32* output, const unsigned char* input, std::size_t len)
+{
+	unsigned int i, j;
+
+	for (i = 0, j = 0; j < len; i++, j += 4)
+		output[i] = ((UInt32)input[j]) | (((UInt32)input[j+1]) << 8) |
+		            (((UInt32)input[j+2]) << 16) | (((UInt32)input[j+3]) << 24);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/MD5Engine.cpp b/base/poco/Foundation/src/MD5Engine.cpp
new file mode 100644
index 00000000000..7ac89f0bd37
--- /dev/null
+++ b/base/poco/Foundation/src/MD5Engine.cpp
@@ -0,0 +1,309 @@
+//
+// MD5Engine.cpp
+//
+// Library: Foundation
+// Package: Crypt
+// Module:  MD5Engine
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+//
+// MD5 (RFC 1321) algorithm:
+// Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+// rights reserved.
+// 
+// License to copy and use this software is granted provided that it
+// is identified as the "RSA Data Security, Inc. MD5 Message-Digest
+// Algorithm" in all material mentioning or referencing this software
+// or this function.
+//
+// License is also granted to make and use derivative works provided
+// that such works are identified as "derived from the RSA Data
+// Security, Inc. MD5 Message-Digest Algorithm" in all material
+// mentioning or referencing the derived work.
+//
+// RSA Data Security, Inc. makes no representations concerning either
+// the merchantability of this software or the suitability of this
+// software for any particular purpose. It is provided "as is"
+// without express or implied warranty of any kind.
+//
+// These notices must be retained in any copies of any part of this
+// documentation and/or software.
+//
+
+
+#include "Poco/MD5Engine.h"
+#include <cstring>
+
+
+namespace Poco {
+
+
+MD5Engine::MD5Engine()
+{
+	_digest.reserve(16);
+	reset();
+}
+
+
+MD5Engine::~MD5Engine()
+{
+	reset();
+}
+
+	
+void MD5Engine::updateImpl(const void* input_, std::size_t inputLen)
+{
+	const unsigned char* input = (const unsigned char*) input_;
+	unsigned int i, index, partLen;
+
+	/* Compute number of bytes mod 64 */
+	index = (unsigned int)((_context.count[0] >> 3) & 0x3F);
+
+	/* Update number of bits */
+	if ((_context.count[0] += ((UInt32) inputLen << 3)) < ((UInt32) inputLen << 3))
+		_context.count[1]++;
+	_context.count[1] += ((UInt32) inputLen >> 29);
+
+	partLen = 64 - index;
+
+	/* Transform as many times as possible. */
+	if (inputLen >= partLen) 
+	{
+		std::memcpy(&_context.buffer[index], input, partLen);
+		transform(_context.state, _context.buffer);
+
+		for (i = partLen; i + 63 < inputLen; i += 64)
+			transform(_context.state, &input[i]);
+
+		index = 0;
+	}
+	else i = 0;
+
+	/* Buffer remaining input */
+	std::memcpy(&_context.buffer[index], &input[i],inputLen-i);
+}
+
+
+std::size_t MD5Engine::digestLength() const
+{
+	return DIGEST_SIZE;
+}
+
+
+void MD5Engine::reset()
+{
+	std::memset(&_context, 0, sizeof(_context));
+	_context.count[0] = _context.count[1] = 0;
+	_context.state[0] = 0x67452301;
+	_context.state[1] = 0xefcdab89;
+	_context.state[2] = 0x98badcfe;
+	_context.state[3] = 0x10325476;
+}
+
+
+const DigestEngine::Digest& MD5Engine::digest()
+{
+	static const unsigned char PADDING[64] = 
+	{
+		0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+	};
+	unsigned char bits[8];
+	unsigned int index, padLen;
+
+	/* Save number of bits */
+	encode(bits, _context.count, 8);
+
+	/* Pad out to 56 mod 64. */
+	index = (unsigned int)((_context.count[0] >> 3) & 0x3f);
+	padLen = (index < 56) ? (56 - index) : (120 - index);
+	update(PADDING, padLen);
+
+	/* Append length (before padding) */
+	update(bits, 8);
+
+	/* Store state in digest */
+	unsigned char digest[16];
+	encode(digest, _context.state, 16);
+	_digest.clear();
+	_digest.insert(_digest.begin(), digest, digest + sizeof(digest));
+
+	/* Zeroize sensitive information. */
+	std::memset(&_context, 0, sizeof (_context));
+	reset();
+	return _digest;
+}
+
+
+/* Constants for MD5Transform routine. */
+#define S11 7
+#define S12 12
+#define S13 17
+#define S14 22
+#define S21 5
+#define S22 9
+#define S23 14
+#define S24 20
+#define S31 4
+#define S32 11
+#define S33 16
+#define S34 23
+#define S41 6
+#define S42 10
+#define S43 15
+#define S44 21
+
+
+/* F, G, H and I are basic MD5 functions. */
+#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
+#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+#define I(x, y, z) ((y) ^ ((x) | (~z)))
+
+
+/* ROTATE_LEFT rotates x left n bits. */
+#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
+
+
+/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
+   Rotation is separate from addition to prevent recomputation. */
+#define FF(a, b, c, d, x, s, ac) { \
+ (a) += F ((b), (c), (d)) + (x) + (UInt32)(ac); \
+ (a) = ROTATE_LEFT ((a), (s)); \
+ (a) += (b); \
+  }
+#define GG(a, b, c, d, x, s, ac) { \
+ (a) += G ((b), (c), (d)) + (x) + (UInt32)(ac); \
+ (a) = ROTATE_LEFT ((a), (s)); \
+ (a) += (b); \
+  }
+#define HH(a, b, c, d, x, s, ac) { \
+ (a) += H ((b), (c), (d)) + (x) + (UInt32)(ac); \
+ (a) = ROTATE_LEFT ((a), (s)); \
+ (a) += (b); \
+  }
+#define II(a, b, c, d, x, s, ac) { \
+ (a) += I ((b), (c), (d)) + (x) + (UInt32)(ac); \
+ (a) = ROTATE_LEFT ((a), (s)); \
+ (a) += (b); \
+  }
+
+
+void MD5Engine::transform (UInt32 state[4], const unsigned char block[64])
+{
+	UInt32 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
+
+	decode(x, block, 64);
+
+	/* Round 1 */
+	FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
+	FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
+	FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
+	FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
+	FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
+	FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
+	FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
+	FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
+	FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
+	FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
+	FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
+	FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
+	FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
+	FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
+	FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
+	FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
+
+	/* Round 2 */
+	GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
+	GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
+	GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
+	GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
+	GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
+	GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
+	GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
+	GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
+	GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
+	GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
+	GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
+	GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
+	GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
+	GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
+	GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
+	GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
+
+	/* Round 3 */
+	HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
+	HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
+	HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
+	HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
+	HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
+	HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
+	HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
+	HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
+	HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
+	HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
+	HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
+	HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
+	HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
+	HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
+	HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
+	HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
+
+	/* Round 4 */
+	II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
+	II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
+	II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
+	II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
+	II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
+	II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
+	II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
+	II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
+	II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
+	II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
+	II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
+	II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
+	II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
+	II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
+	II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
+	II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
+
+	state[0] += a;
+	state[1] += b;
+	state[2] += c;
+	state[3] += d;
+
+	/* Zeroize sensitive information. */
+	std::memset(x, 0, sizeof(x));
+}
+
+
+void MD5Engine::encode(unsigned char* output, const UInt32* input, std::size_t len)
+{
+	unsigned int i, j;
+
+	for (i = 0, j = 0; j < len; i++, j += 4) 
+	{
+		output[j]   = (unsigned char)(input[i] & 0xff);
+		output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
+		output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
+		output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
+	}
+}
+
+
+void MD5Engine::decode(UInt32* output, const unsigned char* input, std::size_t len)
+{
+	unsigned int i, j;
+
+	for (i = 0, j = 0; j < len; i++, j += 4)
+		output[i] = ((UInt32)input[j]) | (((UInt32)input[j+1]) << 8) |
+		            (((UInt32)input[j+2]) << 16) | (((UInt32)input[j+3]) << 24);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Manifest.cpp b/base/poco/Foundation/src/Manifest.cpp
new file mode 100644
index 00000000000..c4e828c5e97
--- /dev/null
+++ b/base/poco/Foundation/src/Manifest.cpp
@@ -0,0 +1,31 @@
+//
+// Manifest.cpp
+//
+// Library: Foundation
+// Package: SharedLibrary
+// Module:  ClassLoader
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Manifest.h"
+
+
+namespace Poco {
+
+
+ManifestBase::ManifestBase()
+{
+}
+
+
+ManifestBase::~ManifestBase()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/MemoryPool.cpp b/base/poco/Foundation/src/MemoryPool.cpp
new file mode 100644
index 00000000000..01c477be525
--- /dev/null
+++ b/base/poco/Foundation/src/MemoryPool.cpp
@@ -0,0 +1,105 @@
+//
+// MemoryPool.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  MemoryPool
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MemoryPool.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+
+MemoryPool::MemoryPool(std::size_t blockSize, int preAlloc, int maxAlloc):
+	_blockSize(blockSize),
+	_maxAlloc(maxAlloc),
+	_allocated(preAlloc)
+{
+	poco_assert (maxAlloc == 0 || maxAlloc >= preAlloc);
+	poco_assert (preAlloc >= 0 && maxAlloc >= 0);
+
+	int r = BLOCK_RESERVE;
+	if (preAlloc > r)
+		r = preAlloc;
+	if (maxAlloc > 0 && maxAlloc < r)
+		r = maxAlloc;
+	_blocks.reserve(r);
+	
+	try
+	{
+		for (int i = 0; i < preAlloc; ++i)
+		{
+			_blocks.push_back(new char[_blockSize]);
+		}
+	}
+	catch (...)
+	{
+		clear();
+		throw;
+	}
+}
+
+	
+MemoryPool::~MemoryPool()
+{
+	clear();
+}
+
+
+void MemoryPool::clear()
+{
+	for (BlockVec::iterator it = _blocks.begin(); it != _blocks.end(); ++it)
+	{
+		delete [] *it;
+	}
+	_blocks.clear();
+}
+
+
+void* MemoryPool::get()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	if (_blocks.empty())
+	{
+		if (_maxAlloc == 0 || _allocated < _maxAlloc)
+		{
+			++_allocated;
+			return new char[_blockSize];
+		}
+		else throw OutOfMemoryException("MemoryPool exhausted");
+	}
+	else
+	{
+		char* ptr = _blocks.back();
+		_blocks.pop_back();
+		return ptr;
+	}
+}
+
+	
+void MemoryPool::release(void* ptr)
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	try
+	{
+		_blocks.push_back(reinterpret_cast<char*>(ptr));
+	}
+	catch (...)
+	{
+		delete [] reinterpret_cast<char*>(ptr);
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/MemoryStream.cpp b/base/poco/Foundation/src/MemoryStream.cpp
new file mode 100644
index 00000000000..cf3f4c32561
--- /dev/null
+++ b/base/poco/Foundation/src/MemoryStream.cpp
@@ -0,0 +1,57 @@
+//
+// MemoryStream.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  MemoryStream
+//
+// Copyright (c) 2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MemoryStream.h"
+
+
+namespace Poco {
+
+
+MemoryIOS::MemoryIOS(char* pBuffer, std::streamsize bufferSize):
+	_buf(pBuffer, bufferSize)
+{
+	poco_ios_init(&_buf);
+}
+
+
+MemoryIOS::~MemoryIOS()
+{
+}
+
+
+MemoryInputStream::MemoryInputStream(const char* pBuffer, std::streamsize bufferSize): 
+	MemoryIOS(const_cast<char*>(pBuffer), bufferSize), 
+	std::istream(&_buf)
+{
+}
+
+
+MemoryInputStream::~MemoryInputStream()
+{
+}
+
+
+MemoryOutputStream::MemoryOutputStream(char* pBuffer, std::streamsize bufferSize): 
+	MemoryIOS(pBuffer, bufferSize), 
+	std::ostream(&_buf)
+{
+}
+
+
+MemoryOutputStream::~MemoryOutputStream()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Message.cpp b/base/poco/Foundation/src/Message.cpp
new file mode 100644
index 00000000000..e7e86c4b34a
--- /dev/null
+++ b/base/poco/Foundation/src/Message.cpp
@@ -0,0 +1,289 @@
+//
+// Message.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  Message
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Message.h"
+#include "Poco/Exception.h"
+#if !defined(POCO_VXWORKS)
+#include "Poco/Process.h"
+#endif
+#include "Poco/Thread.h"
+#include <algorithm>
+
+
+namespace Poco {
+
+
+Message::Message(): 
+	_prio(PRIO_FATAL), 
+	_tid(0), 
+	_file(0),
+	_line(0),
+	_pMap(0),
+    _fmt_str(0)
+{
+	init();
+}
+
+
+Message::Message(const std::string& source, const std::string& text, Priority prio): 
+	_source(source), 
+	_text(text), 
+	_prio(prio), 
+	_tid(0),
+	_file(0),
+	_line(0),
+	_pMap(0)
+{
+	init();
+}
+
+
+Message::Message(const std::string& source, const std::string& text, Priority prio, const char* file, int line, std::string_view fmt_str):
+	_source(source), 
+	_text(text), 
+	_prio(prio), 
+	_tid(0),
+	_file(file),
+	_line(line),
+	_pMap(0),
+    _fmt_str(fmt_str)
+{
+	init();
+}
+
+
+Message::Message(const Message& msg):
+	_source(msg._source),
+	_text(msg._text),
+	_prio(msg._prio),
+	_time(msg._time),
+	_tid(msg._tid),
+	_thread(msg._thread),
+	_pid(msg._pid),
+	_file(msg._file),
+	_line(msg._line),
+    _fmt_str(msg._fmt_str)
+{
+	if (msg._pMap)
+		_pMap = new StringMap(*msg._pMap);
+	else
+		_pMap = 0;
+}
+
+
+Message::Message(const Message& msg, const std::string& text):
+	_source(msg._source),
+	_text(text),
+	_prio(msg._prio),
+	_time(msg._time),
+	_tid(msg._tid),
+	_thread(msg._thread),
+	_pid(msg._pid),
+	_file(msg._file),
+	_line(msg._line),
+    _fmt_str(msg._fmt_str)
+{
+	if (msg._pMap)
+		_pMap = new StringMap(*msg._pMap);
+	else
+		_pMap = 0;
+}
+
+
+Message::~Message()
+{
+	delete _pMap;
+}
+
+
+void Message::init()
+{
+#if !defined(POCO_VXWORKS)
+	_pid = Process::id();
+#endif
+	Thread* pThread = Thread::current();
+	if (pThread)
+	{
+		_tid    = pThread->id();
+		_thread = pThread->name();
+	}
+}
+
+
+Message& Message::operator = (const Message& msg)
+{
+	if (&msg != this)
+	{
+		Message tmp(msg);
+		swap(tmp);
+	}
+	return *this;
+}
+
+
+void Message::swap(Message& msg)
+{
+	using std::swap;
+	swap(_source, msg._source);
+	swap(_text, msg._text);
+	swap(_prio, msg._prio);
+	swap(_time, msg._time);
+	swap(_tid, msg._tid);
+	swap(_thread, msg._thread);
+	swap(_pid, msg._pid);
+	swap(_file, msg._file);
+	swap(_line, msg._line);
+	swap(_pMap, msg._pMap);
+	swap(_fmt_str, msg._fmt_str);
+}
+
+
+void Message::setSource(const std::string& src)
+{
+	_source = src;
+}
+
+
+void Message::setText(const std::string& text)
+{
+	_text = text;
+}
+
+
+void Message::setPriority(Priority prio)
+{
+	_prio = prio;
+}
+
+
+void Message::setTime(const Timestamp& t)
+{
+	_time = t;
+}
+
+
+void Message::setThread(const std::string& thread)
+{
+	_thread = thread;
+}
+
+
+void Message::setTid(long tid)
+{
+	_tid = tid;
+}
+
+
+void Message::setPid(long pid)
+{
+	_pid = pid;
+}
+
+
+void Message::setSourceFile(const char* file)
+{
+	_file = file;
+}
+
+
+void Message::setSourceLine(int line)
+{
+	_line = line;
+}
+
+std::string_view Message::getFormatString() const
+{
+    return _fmt_str;
+}
+
+void Message::setFormatString(std::string_view fmt_str)
+{
+    _fmt_str = fmt_str;
+}
+
+
+bool Message::has(const std::string& param) const
+{
+	return _pMap && (_pMap->find(param) != _pMap->end());
+}
+
+
+const std::string& Message::get(const std::string& param) const
+{
+	if (_pMap)
+	{
+		StringMap::const_iterator it = _pMap->find(param);
+		if (it != _pMap->end())
+	 		return it->second;
+	}
+
+	throw NotFoundException();
+}
+
+
+const std::string& Message::get(const std::string& param, const std::string& defaultValue) const
+{
+	if (_pMap)
+	{
+		StringMap::const_iterator it = _pMap->find(param);
+		if (it != _pMap->end())
+	 		return it->second;
+	}
+
+	return defaultValue;
+}
+
+
+long Message::getPid() const
+{
+#if !defined(POCO_VXWORKS)
+	if (_pid < 0)
+		_pid = Process::id();
+#endif
+	return _pid;
+}
+
+
+void Message::set(const std::string& param, const std::string& value)
+{
+	if (!_pMap)
+		_pMap = new StringMap;
+
+	std::pair<StringMap::iterator, bool> result =
+		_pMap->insert(std::make_pair(param, value));
+	if (!result.second)
+	{
+		result.first->second = value;
+	}
+}
+
+
+const std::string& Message::operator [] (const std::string& param) const
+{
+	if (_pMap)
+		return (*_pMap)[param];
+	else
+		throw NotFoundException();
+}
+
+
+std::string& Message::operator [] (const std::string& param)
+{
+	if (!_pMap)
+		_pMap = new StringMap;
+	return (*_pMap)[param];
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Mutex.cpp b/base/poco/Foundation/src/Mutex.cpp
new file mode 100644
index 00000000000..cb101150880
--- /dev/null
+++ b/base/poco/Foundation/src/Mutex.cpp
@@ -0,0 +1,54 @@
+//
+// Mutex.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Mutex
+//
+// Copyright (c) 2004-2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Mutex.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#if defined(_WIN32_WCE)
+#include "Mutex_WINCE.cpp"
+#else
+#include "Mutex_WIN32.cpp"
+#endif
+#elif defined(POCO_VXWORKS)
+#include "Mutex_VX.cpp"
+#else
+#include "Mutex_POSIX.cpp"
+#endif
+
+
+namespace Poco {
+
+
+Mutex::Mutex()
+{
+}
+
+
+Mutex::~Mutex()
+{
+}
+
+
+FastMutex::FastMutex()
+{
+}
+
+
+FastMutex::~FastMutex()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Mutex_POSIX.cpp b/base/poco/Foundation/src/Mutex_POSIX.cpp
new file mode 100644
index 00000000000..56132ef5d58
--- /dev/null
+++ b/base/poco/Foundation/src/Mutex_POSIX.cpp
@@ -0,0 +1,175 @@
+//
+// Mutex_POSIX.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Mutex
+//
+// Copyright (c) 2004-2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Mutex_POSIX.h"
+#include "Poco/Timestamp.h"
+#if !defined(POCO_NO_SYS_SELECT_H)
+#include <sys/select.h>
+#endif
+#include <unistd.h>
+#if defined(POCO_VXWORKS)
+#include <timers.h>
+#include <cstring>
+#else
+#include <sys/time.h>
+#endif
+
+
+#if defined(_POSIX_TIMEOUTS) && (_POSIX_TIMEOUTS - 200112L) >= 0L
+	#if defined(_POSIX_THREADS) && (_POSIX_THREADS - 200112L) >= 0L
+		#define POCO_HAVE_MUTEX_TIMEOUT
+	#endif
+#endif
+
+
+#ifndef POCO_HAVE_CLOCK_GETTIME
+	#if (defined(_POSIX_TIMERS) && defined(CLOCK_REALTIME)) || defined(POCO_VXWORKS) || defined(__QNX__)
+		#ifndef __APPLE__ // See GitHub issue #1453 - not available before Mac OS 10.12/iOS 10
+			#define POCO_HAVE_CLOCK_GETTIME
+		#endif
+	#endif
+#endif
+
+
+namespace Poco {
+
+
+MutexImpl::MutexImpl()
+{
+#if defined(POCO_VXWORKS)
+	// This workaround is for VxWorks 5.x where
+	// pthread_mutex_init() won't properly initialize the mutex
+	// resulting in a subsequent freeze in pthread_mutex_destroy()
+	// if the mutex has never been used.
+	std::memset(&_mutex, 0, sizeof(_mutex));
+#endif
+	pthread_mutexattr_t attr;
+	pthread_mutexattr_init(&attr);
+#if defined(PTHREAD_MUTEX_RECURSIVE_NP)
+	pthread_mutexattr_settype_np(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
+#elif !defined(POCO_VXWORKS)
+	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+#endif
+	if (pthread_mutex_init(&_mutex, &attr))
+	{
+		pthread_mutexattr_destroy(&attr);
+		throw SystemException("cannot create mutex");
+	}
+	pthread_mutexattr_destroy(&attr);
+}
+
+
+MutexImpl::MutexImpl(bool fast)
+{
+#if defined(POCO_VXWORKS)
+	// This workaround is for VxWorks 5.x where
+	// pthread_mutex_init() won't properly initialize the mutex
+	// resulting in a subsequent freeze in pthread_mutex_destroy()
+	// if the mutex has never been used.
+	std::memset(&_mutex, 0, sizeof(_mutex));
+#endif
+	pthread_mutexattr_t attr;
+	pthread_mutexattr_init(&attr);
+#if defined(PTHREAD_MUTEX_RECURSIVE_NP)
+	pthread_mutexattr_settype_np(&attr, fast ? PTHREAD_MUTEX_NORMAL_NP : PTHREAD_MUTEX_RECURSIVE_NP);
+#elif !defined(POCO_VXWORKS)
+	pthread_mutexattr_settype(&attr, fast ? PTHREAD_MUTEX_NORMAL : PTHREAD_MUTEX_RECURSIVE);
+#endif
+	if (pthread_mutex_init(&_mutex, &attr))
+	{
+		pthread_mutexattr_destroy(&attr);
+		throw SystemException("cannot create mutex");
+	}
+	pthread_mutexattr_destroy(&attr);
+}
+
+
+MutexImpl::~MutexImpl()
+{
+	pthread_mutex_destroy(&_mutex);
+}
+
+
+bool MutexImpl::tryLockImpl(long milliseconds)
+{
+#if defined(POCO_HAVE_MUTEX_TIMEOUT)
+	struct timespec abstime;
+#if defined(POCO_HAVE_CLOCK_GETTIME)
+	clock_gettime(CLOCK_REALTIME, &abstime);
+	abstime.tv_sec  += milliseconds / 1000;
+	abstime.tv_nsec += (milliseconds % 1000)*1000000;
+	if (abstime.tv_nsec >= 1000000000)
+	{
+		abstime.tv_nsec -= 1000000000;
+		abstime.tv_sec++;
+	}
+#else
+	struct timeval tv;
+	gettimeofday(&tv, NULL);
+	abstime.tv_sec  = tv.tv_sec + milliseconds / 1000;
+	abstime.tv_nsec = tv.tv_usec*1000 + (milliseconds % 1000)*1000000;
+	if (abstime.tv_nsec >= 1000000000)
+	{
+		abstime.tv_nsec -= 1000000000;
+		abstime.tv_sec++;
+	}
+#endif
+	int rc = pthread_mutex_timedlock(&_mutex, &abstime);
+	if (rc == 0)
+		return true;
+	else if (rc == ETIMEDOUT)
+		return false;
+	else
+		throw SystemException("cannot lock mutex");
+#else
+	const int sleepMillis = 5;
+	Timestamp now;
+	Timestamp::TimeDiff diff(Timestamp::TimeDiff(milliseconds)*1000);
+	do
+	{
+		int rc = pthread_mutex_trylock(&_mutex);
+		if (rc == 0)
+			return true;
+		else if (rc != EBUSY)
+			throw SystemException("cannot lock mutex");
+#if defined(POCO_VXWORKS)
+		struct timespec ts;
+		ts.tv_sec = 0;
+		ts.tv_nsec = sleepMillis*1000000;
+		nanosleep(&ts, NULL);
+
+#else
+		struct timeval tv;
+		tv.tv_sec  = 0;
+		tv.tv_usec = sleepMillis * 1000;
+		select(0, NULL, NULL, NULL, &tv);
+#endif
+	}
+	while (!now.isElapsed(diff));
+	return false;
+#endif
+}
+
+
+FastMutexImpl::FastMutexImpl(): MutexImpl(true)
+{
+}
+
+
+FastMutexImpl::~FastMutexImpl()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Mutex_VX.cpp b/base/poco/Foundation/src/Mutex_VX.cpp
new file mode 100644
index 00000000000..a4b32acbbf6
--- /dev/null
+++ b/base/poco/Foundation/src/Mutex_VX.cpp
@@ -0,0 +1,68 @@
+//
+// Mutex_VX.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Mutex
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Mutex_VX.h"
+#include <sysLib.h>
+
+
+namespace Poco {
+
+
+MutexImpl::MutexImpl()
+{
+	_sem = semMCreate(SEM_INVERSION_SAFE | SEM_Q_PRIORITY);
+	if (_sem == 0)
+		throw Poco::SystemException("cannot create mutex");
+}
+
+
+MutexImpl::MutexImpl(bool fast)
+{
+	if (fast)
+	{
+		_sem = semBCreate(SEM_Q_PRIORITY, SEM_FULL);
+	}
+	else
+	{
+		_sem = semMCreate(SEM_INVERSION_SAFE | SEM_Q_PRIORITY);
+	}
+	if (_sem == 0)
+		throw Poco::SystemException("cannot create mutex");
+}
+
+
+MutexImpl::~MutexImpl()
+{
+	semDelete(_sem);
+}
+
+
+bool MutexImpl::tryLockImpl(long milliseconds)
+{
+	int ticks = milliseconds*sysClkRateGet()/1000;
+	return semTake(_sem, ticks) == OK;
+}
+
+
+FastMutexImpl::FastMutexImpl(): MutexImpl(true)
+{
+}
+
+
+FastMutexImpl::~FastMutexImpl()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Mutex_WIN32.cpp b/base/poco/Foundation/src/Mutex_WIN32.cpp
new file mode 100644
index 00000000000..446f4affcef
--- /dev/null
+++ b/base/poco/Foundation/src/Mutex_WIN32.cpp
@@ -0,0 +1,59 @@
+//
+// Mutex_WIN32.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Mutex
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Mutex_WIN32.h"
+#include "Poco/Timestamp.h"
+
+
+namespace Poco {
+
+
+MutexImpl::MutexImpl()
+{
+	// the fct has a boolean return value under WInnNt/2000/XP but not on Win98
+	// the return only checks if the input address of &_cs was valid, so it is safe to omit it
+	InitializeCriticalSectionAndSpinCount(&_cs, 4000);
+}
+
+
+MutexImpl::~MutexImpl()
+{
+	DeleteCriticalSection(&_cs);
+}
+
+
+bool MutexImpl::tryLockImpl(long milliseconds)
+{
+	const int sleepMillis = 5;
+	Timestamp now;
+	Timestamp::TimeDiff diff(Timestamp::TimeDiff(milliseconds)*1000);
+	do
+	{
+		try
+		{
+			if (TryEnterCriticalSection(&_cs) == TRUE)
+				return true;
+		}
+		catch (...)
+		{
+			throw SystemException("cannot lock mutex");
+		}
+		Sleep(sleepMillis);
+	}
+	while (!now.isElapsed(diff));
+	return false;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Mutex_WINCE.cpp b/base/poco/Foundation/src/Mutex_WINCE.cpp
new file mode 100644
index 00000000000..90ea6956d88
--- /dev/null
+++ b/base/poco/Foundation/src/Mutex_WINCE.cpp
@@ -0,0 +1,80 @@
+//
+// Mutex_WINCE.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Mutex
+//
+// Copyright (c) 2004-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Mutex_WINCE.h"
+
+
+namespace Poco {
+
+
+MutexImpl::MutexImpl()
+{
+	_mutex = CreateMutexW(NULL, FALSE, NULL);
+	if (!_mutex) throw SystemException("cannot create mutex");
+}
+
+
+MutexImpl::~MutexImpl()
+{
+	CloseHandle(_mutex);
+}
+
+
+void MutexImpl::lockImpl()
+{
+	switch (WaitForSingleObject(_mutex, INFINITE))
+	{
+	case WAIT_OBJECT_0:
+		return;
+	default:
+		throw SystemException("cannot lock mutex");
+	}
+}
+
+
+bool MutexImpl::tryLockImpl()
+{
+	switch (WaitForSingleObject(_mutex, 0))
+	{
+	case WAIT_TIMEOUT:
+		return false;
+	case WAIT_OBJECT_0:
+		return true;
+	default:
+		throw SystemException("cannot lock mutex");		
+	}
+}
+
+
+bool MutexImpl::tryLockImpl(long milliseconds)
+{
+	switch (WaitForSingleObject(_mutex, milliseconds + 1))
+	{
+	case WAIT_TIMEOUT:
+		return false;
+	case WAIT_OBJECT_0:
+		return true;
+	default:
+		throw SystemException("cannot lock mutex");		
+	}
+}
+
+
+void MutexImpl::unlockImpl()
+{
+	ReleaseMutex(_mutex);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/NamedEvent.cpp b/base/poco/Foundation/src/NamedEvent.cpp
new file mode 100644
index 00000000000..6615ca8f048
--- /dev/null
+++ b/base/poco/Foundation/src/NamedEvent.cpp
@@ -0,0 +1,43 @@
+//
+// NamedEvent.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedEvent
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/NamedEvent.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS) && defined(POCO_WIN32_UTF8)
+#include "NamedEvent_WIN32U.cpp"
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "NamedEvent_WIN32.cpp"
+#elif POCO_OS == POCO_OS_ANDROID
+#include "NamedEvent_Android.cpp"
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include "NamedEvent_UNIX.cpp"
+#endif
+
+
+namespace Poco {
+
+
+NamedEvent::NamedEvent(const std::string& name):
+	NamedEventImpl(name)
+{
+}
+
+
+NamedEvent::~NamedEvent()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/NamedEvent_Android.cpp b/base/poco/Foundation/src/NamedEvent_Android.cpp
new file mode 100644
index 00000000000..f8dfb0468b8
--- /dev/null
+++ b/base/poco/Foundation/src/NamedEvent_Android.cpp
@@ -0,0 +1,44 @@
+//
+// NamedEvent_Android.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedEvent
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/NamedEvent_Android.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+
+NamedEventImpl::NamedEventImpl(const std::string&)
+{
+}
+
+
+NamedEventImpl::~NamedEventImpl()
+{
+}
+
+
+void NamedEventImpl::setImpl()
+{
+	throw NotImplementedException("NamedEvent::set() not available on Android");
+}
+
+
+void NamedEventImpl::waitImpl()
+{
+	throw NotImplementedException("NamedEvent::wait() not available on Android");
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/NamedEvent_UNIX.cpp b/base/poco/Foundation/src/NamedEvent_UNIX.cpp
new file mode 100644
index 00000000000..978e6e0bc02
--- /dev/null
+++ b/base/poco/Foundation/src/NamedEvent_UNIX.cpp
@@ -0,0 +1,148 @@
+//
+// NamedEvent_UNIX.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedEvent
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/NamedEvent_UNIX.h"
+#include "Poco/Format.h"
+#include "Poco/Exception.h"
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <errno.h>
+#if defined(sun) || defined(__APPLE__) || defined(__osf__) || defined(__QNX__) || defined(_AIX)
+#include <semaphore.h>
+#else
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/sem.h>
+#endif
+
+
+namespace Poco {
+
+
+#if (POCO_OS == POCO_OS_LINUX) || (POCO_OS == POCO_OS_ANDROID) || (POCO_OS == POCO_OS_CYGWIN) || (POCO_OS == POCO_OS_FREE_BSD)
+	union semun
+	{
+		int                 val;
+		struct semid_ds*    buf;
+		unsigned short int* array;
+		struct seminfo*     __buf;
+	};
+#elif (POCO_OS == POCO_OS_HPUX)
+	union semun
+	{
+		int              val;
+		struct semid_ds* buf;
+		ushort*          array;
+	};
+#endif
+
+
+NamedEventImpl::NamedEventImpl(const std::string& name):
+	_name(name)
+{
+	std::string fileName = getFileName();
+#if defined(sun) || defined(__APPLE__) || defined(__osf__) || defined(__QNX__) || defined(_AIX)
+	_sem = sem_open(fileName.c_str(), O_CREAT, S_IRWXU | S_IRWXG | S_IRWXO, 0);
+	if ((long) _sem == (long) SEM_FAILED)
+		throw SystemException(Poco::format("cannot create named mutex %s (sem_open() failed, errno=%d)", fileName, errno), _name);
+#else
+	int fd = open(fileName.c_str(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+	if (fd != -1)
+		close(fd);
+	else
+		throw SystemException(Poco::format("cannot create named event %s (lockfile)", fileName), _name);
+	key_t key = ftok(fileName.c_str(), 'p');
+	if (key == -1)
+		throw SystemException(Poco::format("cannot create named mutex %s (ftok() failed, errno=%d)", fileName, errno), _name);
+	_semid = semget(key, 1, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH | IPC_CREAT | IPC_EXCL);
+	if (_semid >= 0)
+	{
+		union semun arg;
+		arg.val = 0;
+		semctl(_semid, 0, SETVAL, arg);
+	}
+	else if (errno == EEXIST)
+	{
+		_semid = semget(key, 1, 0);
+	}
+	else throw SystemException(Poco::format("cannot create named mutex %s (semget() failed, errno=%d)", fileName, errno), _name);
+#endif // defined(sun) || defined(__APPLE__) || defined(__osf__) || defined(__QNX__) || defined(_AIX)
+}
+
+
+NamedEventImpl::~NamedEventImpl()
+{
+#if defined(sun) || defined(__APPLE__) || defined(__osf__) || defined(__QNX__) || defined(_AIX)
+	sem_close(_sem);
+#endif
+}
+
+
+void NamedEventImpl::setImpl()
+{
+#if defined(sun) || defined(__APPLE__) || defined(__osf__) || defined(__QNX__) || defined(_AIX)
+	if (sem_post(_sem) != 0)
+	   	throw SystemException("cannot set named event", _name);
+#else
+	struct sembuf op;
+	op.sem_num = 0;
+	op.sem_op  = 1;
+	op.sem_flg = 0;
+	if (semop(_semid, &op, 1) != 0)
+	   	throw SystemException("cannot set named event", _name);
+#endif
+}
+
+
+void NamedEventImpl::waitImpl()
+{
+#if defined(sun) || defined(__APPLE__) || defined(__osf__) || defined(__QNX__) || defined(_AIX)
+	int err;
+	do
+	{
+		err = sem_wait(_sem);
+	}
+	while (err && errno == EINTR);
+	if (err) throw SystemException("cannot wait for named event", _name);
+#else
+	struct sembuf op;
+	op.sem_num = 0;
+	op.sem_op  = -1;
+	op.sem_flg = 0;
+	int err;
+	do
+	{
+		err = semop(_semid, &op, 1);
+	}
+	while (err && errno == EINTR);
+	if (err) throw SystemException("cannot wait for named event", _name);
+#endif
+}
+
+
+std::string NamedEventImpl::getFileName()
+{
+#if defined(sun) || defined(__APPLE__) || defined(__QNX__)
+	std::string fn = "/";
+#else
+	std::string fn = "/tmp/";
+#endif
+	fn.append(_name);
+	fn.append(".event");
+	return fn;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/NamedEvent_WIN32.cpp b/base/poco/Foundation/src/NamedEvent_WIN32.cpp
new file mode 100644
index 00000000000..0aee72c5fb9
--- /dev/null
+++ b/base/poco/Foundation/src/NamedEvent_WIN32.cpp
@@ -0,0 +1,61 @@
+//
+// NamedEvent_WIN32.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedEvent
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/NamedEvent_WIN32.h"
+#include "Poco/Error.h"
+#include "Poco/Exception.h"
+#include "Poco/Format.h"
+
+
+namespace Poco {
+
+
+NamedEventImpl::NamedEventImpl(const std::string& name):
+	_name(name)
+{
+	_event = CreateEventA(NULL, FALSE, FALSE, _name.c_str());
+	if (!_event)
+	{
+		DWORD dwRetVal = GetLastError();
+		throw SystemException(format("cannot create named event %s [Error %d: %s]", _name, (int)dwRetVal, Error::getMessage(dwRetVal)));
+	}
+}
+
+
+NamedEventImpl::~NamedEventImpl()
+{
+	CloseHandle(_event);
+}
+
+
+void NamedEventImpl::setImpl()
+{
+	if (!SetEvent(_event))
+		throw SystemException("cannot signal named event", _name);
+}
+
+
+void NamedEventImpl::waitImpl()
+{
+	switch (WaitForSingleObject(_event, INFINITE))
+	{
+	case WAIT_OBJECT_0:
+		return;
+	default:
+		throw SystemException("wait for named event failed", _name);
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/NamedEvent_WIN32U.cpp b/base/poco/Foundation/src/NamedEvent_WIN32U.cpp
new file mode 100644
index 00000000000..8a7ad1c1820
--- /dev/null
+++ b/base/poco/Foundation/src/NamedEvent_WIN32U.cpp
@@ -0,0 +1,63 @@
+//
+// NamedEvent_WIN32.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedEvent
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/NamedEvent_WIN32U.h"
+#include "Poco/Error.h"
+#include "Poco/Exception.h"
+#include "Poco/Format.h"
+#include "Poco/UnicodeConverter.h"
+
+
+namespace Poco {
+
+
+NamedEventImpl::NamedEventImpl(const std::string& name):
+	_name(name)
+{
+	UnicodeConverter::toUTF16(_name, _uname);
+	_event = CreateEventW(NULL, FALSE, FALSE, _uname.c_str());
+	if (!_event)
+	{
+		DWORD dwRetVal = GetLastError(); 
+		throw SystemException(format("cannot create named event %s [Error %d: %s]", _name, (int)dwRetVal, Error::getMessage(dwRetVal)));
+	}
+}
+
+
+NamedEventImpl::~NamedEventImpl()
+{
+	CloseHandle(_event);
+}
+
+
+void NamedEventImpl::setImpl()
+{
+	if (!SetEvent(_event))
+		throw SystemException("cannot signal named event", _name);
+}
+
+
+void NamedEventImpl::waitImpl()
+{
+	switch (WaitForSingleObject(_event, INFINITE))
+	{
+	case WAIT_OBJECT_0:
+		return;
+	default:
+		throw SystemException("wait for named event failed", _name);
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/NamedMutex.cpp b/base/poco/Foundation/src/NamedMutex.cpp
new file mode 100644
index 00000000000..77fd672c640
--- /dev/null
+++ b/base/poco/Foundation/src/NamedMutex.cpp
@@ -0,0 +1,43 @@
+//
+// NamedMutex.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedMutex
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/NamedMutex.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS) && defined(POCO_WIN32_UTF8)
+#include "NamedMutex_WIN32U.cpp"
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "NamedMutex_WIN32.cpp"
+#elif POCO_OS == POCO_OS_ANDROID
+#include "NamedMutex_Android.cpp"
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include "NamedMutex_UNIX.cpp"
+#endif
+
+
+namespace Poco {
+
+
+NamedMutex::NamedMutex(const std::string& name):
+	NamedMutexImpl(name)
+{
+}
+
+
+NamedMutex::~NamedMutex()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/NamedMutex_Android.cpp b/base/poco/Foundation/src/NamedMutex_Android.cpp
new file mode 100644
index 00000000000..892839cd86b
--- /dev/null
+++ b/base/poco/Foundation/src/NamedMutex_Android.cpp
@@ -0,0 +1,50 @@
+//
+// NamedMutex_Android.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedMutex
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/NamedMutex_Android.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+
+NamedMutexImpl::NamedMutexImpl(const std::string&)
+{
+}
+
+
+NamedMutexImpl::~NamedMutexImpl()
+{
+}
+
+
+void NamedMutexImpl::lockImpl()
+{
+	throw NotImplementedException("NamedMutex::lock() is not supported on Android");
+}
+
+
+bool NamedMutexImpl::tryLockImpl()
+{
+	throw NotImplementedException("NamedMutex::tryLock() is not supported on Android");
+}
+
+
+void NamedMutexImpl::unlockImpl()
+{
+	throw NotImplementedException("NamedMutex::unlock() is not supported on Android");
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/NamedMutex_UNIX.cpp b/base/poco/Foundation/src/NamedMutex_UNIX.cpp
new file mode 100644
index 00000000000..6cfa1369c9d
--- /dev/null
+++ b/base/poco/Foundation/src/NamedMutex_UNIX.cpp
@@ -0,0 +1,170 @@
+//
+// NamedMutex_UNIX.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedMutex
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/NamedMutex_UNIX.h"
+#include "Poco/Format.h"
+#include "Poco/Exception.h"
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <errno.h>
+#if defined(sun) || defined(__APPLE__) || defined(__osf__) || defined(_AIX)
+#include <semaphore.h>
+#else
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/ipc.h>
+#include <sys/sem.h>
+#endif
+
+
+namespace Poco {
+
+
+#if (POCO_OS == POCO_OS_LINUX) || (POCO_OS == POCO_OS_ANDROID) || (POCO_OS == POCO_OS_CYGWIN) || (POCO_OS == POCO_OS_FREE_BSD)
+	union semun
+	{
+		int                 val;
+		struct semid_ds*    buf;
+		unsigned short int* array;
+		struct seminfo*     __buf;
+	};
+#elif (POCO_OS == POCO_OS_HPUX)
+	union semun
+	{
+		int              val;
+		struct semid_ds* buf;
+		ushort*          array;
+	};
+#endif
+
+
+NamedMutexImpl::NamedMutexImpl(const std::string& name):
+	_name(name)
+{
+	std::string fileName = getFileName();
+#if defined(sun) || defined(__APPLE__) || defined(__osf__) || defined(__QNX__) || defined(_AIX)
+	_sem = sem_open(fileName.c_str(), O_CREAT, S_IRWXU | S_IRWXG | S_IRWXO, 1);
+	if ((long) _sem == (long) SEM_FAILED)
+		throw SystemException(Poco::format("cannot create named mutex %s (sem_open() failed, errno=%d)", fileName, errno), _name);
+#else
+	int fd = open(fileName.c_str(), O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+	if (fd != -1)
+		close(fd);
+	else
+		throw SystemException(Poco::format("cannot create named mutex %s (lockfile)", fileName), _name);
+	key_t key = ftok(fileName.c_str(), 'p');
+	if (key == -1)
+		throw SystemException(Poco::format("cannot create named mutex %s (ftok() failed, errno=%d)", fileName, errno), _name);
+	_semid = semget(key, 1, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH | IPC_CREAT | IPC_EXCL);
+	if (_semid >= 0)
+	{
+		union semun arg;
+		arg.val = 1;
+		semctl(_semid, 0, SETVAL, arg);
+		_owned = true;
+		return;
+	}
+	else if (errno == EEXIST)
+	{
+		_semid = semget(key, 1, 0);
+		_owned = false;
+		if (_semid >= 0) return;
+	}
+
+	throw SystemException(Poco::format("cannot create named mutex %s (semget() failed, errno=%d)", fileName, errno), _name);
+#endif // defined(sun) || defined(__APPLE__) || defined(__osf__) || defined(__QNX__) || defined(_AIX)
+}
+
+
+NamedMutexImpl::~NamedMutexImpl()
+{
+#if defined(sun) || defined(__APPLE__) || defined(__osf__) || defined(__QNX__) || defined(_AIX)
+	sem_close(_sem);
+#else
+	if (_owned) semctl(_semid, 0, IPC_RMID, 0);
+#endif
+}
+
+
+void NamedMutexImpl::lockImpl()
+{
+#if defined(sun) || defined(__APPLE__) || defined(__osf__) || defined(__QNX__) || defined(_AIX)
+	int err;
+	do
+	{
+		err = sem_wait(_sem);
+	}
+	while (err && errno == EINTR);
+	if (err) throw SystemException("cannot lock named mutex", _name);
+#else
+	struct sembuf op;
+	op.sem_num = 0;
+	op.sem_op  = -1;
+	op.sem_flg = SEM_UNDO;
+	int err;
+	do
+	{
+		err = semop(_semid, &op, 1);
+	}
+	while (err && errno == EINTR);
+	if (err) throw SystemException("cannot lock named mutex", _name);
+#endif
+}
+
+
+bool NamedMutexImpl::tryLockImpl()
+{
+#if defined(sun) || defined(__APPLE__) || defined(__osf__) || defined(__QNX__) || defined(_AIX)
+	return sem_trywait(_sem) == 0;
+#else
+	struct sembuf op;
+	op.sem_num = 0;
+	op.sem_op  = -1;
+	op.sem_flg = SEM_UNDO | IPC_NOWAIT;
+	return semop(_semid, &op, 1) == 0;
+#endif
+}
+
+
+void NamedMutexImpl::unlockImpl()
+{
+#if defined(sun) || defined(__APPLE__) || defined(__osf__) || defined(__QNX__) || defined(_AIX)
+	if (sem_post(_sem) != 0)
+	   	throw SystemException("cannot unlock named mutex", _name);
+#else
+	struct sembuf op;
+	op.sem_num = 0;
+	op.sem_op  = 1;
+	op.sem_flg = SEM_UNDO;
+	if (semop(_semid, &op, 1) != 0)
+	   	throw SystemException("cannot unlock named mutex", _name);
+#endif
+}
+
+
+std::string NamedMutexImpl::getFileName()
+{
+#if defined(sun) || defined(__APPLE__) || defined(__QNX__)
+	std::string fn = "/";
+#else
+	std::string fn = "/tmp/";
+#endif
+	fn.append(_name);
+	fn.append(".mutex");
+	return fn;
+}
+
+
+} // namespace Poco
+
diff --git a/base/poco/Foundation/src/NamedMutex_WIN32.cpp b/base/poco/Foundation/src/NamedMutex_WIN32.cpp
new file mode 100644
index 00000000000..6d2a5c383f6
--- /dev/null
+++ b/base/poco/Foundation/src/NamedMutex_WIN32.cpp
@@ -0,0 +1,73 @@
+//
+// NamedMutex_WIN32.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedMutex
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/NamedMutex_WIN32.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+
+NamedMutexImpl::NamedMutexImpl(const std::string& name):
+	_name(name)
+{
+	_mutex = CreateMutexA(NULL, FALSE, _name.c_str());
+	if (!_mutex) 
+		throw SystemException("cannot create named mutex", _name);
+}
+
+
+NamedMutexImpl::~NamedMutexImpl()
+{
+	CloseHandle(_mutex);
+}
+
+
+void NamedMutexImpl::lockImpl()
+{
+	switch (WaitForSingleObject(_mutex, INFINITE))
+	{
+	case WAIT_OBJECT_0:
+		return;
+	case WAIT_ABANDONED:
+		throw SystemException("cannot lock named mutex (abadoned)", _name);
+	default:
+		throw SystemException("cannot lock named mutex", _name);
+	}
+}
+
+
+bool NamedMutexImpl::tryLockImpl()
+{
+	switch (WaitForSingleObject(_mutex, 0))
+	{
+	case WAIT_OBJECT_0:
+		return true;
+	case WAIT_TIMEOUT:
+		return false;
+	case WAIT_ABANDONED:
+		throw SystemException("cannot lock named mutex (abadoned)", _name);
+	default:
+		throw SystemException("cannot lock named mutex", _name);
+	}
+}
+
+
+void NamedMutexImpl::unlockImpl()
+{
+	ReleaseMutex(_mutex);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/NamedMutex_WIN32U.cpp b/base/poco/Foundation/src/NamedMutex_WIN32U.cpp
new file mode 100644
index 00000000000..1358658b961
--- /dev/null
+++ b/base/poco/Foundation/src/NamedMutex_WIN32U.cpp
@@ -0,0 +1,75 @@
+//
+// NamedMutex_WIN32.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  NamedMutex
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/NamedMutex_WIN32U.h"
+#include "Poco/Exception.h"
+#include "Poco/UnicodeConverter.h"
+
+
+namespace Poco {
+
+
+NamedMutexImpl::NamedMutexImpl(const std::string& name):
+	_name(name)
+{
+	UnicodeConverter::toUTF16(_name, _uname);
+	_mutex = CreateMutexW(NULL, FALSE, _uname.c_str());
+	if (!_mutex) 
+		throw SystemException("cannot create named mutex", _name);
+}
+
+
+NamedMutexImpl::~NamedMutexImpl()
+{
+	CloseHandle(_mutex);
+}
+
+
+void NamedMutexImpl::lockImpl()
+{
+	switch (WaitForSingleObject(_mutex, INFINITE))
+	{
+	case WAIT_OBJECT_0:
+		return;
+	case WAIT_ABANDONED:
+		throw SystemException("cannot lock named mutex (abadoned)", _name);
+	default:
+		throw SystemException("cannot lock named mutex", _name);
+	}
+}
+
+
+bool NamedMutexImpl::tryLockImpl()
+{
+	switch (WaitForSingleObject(_mutex, 0))
+	{
+	case WAIT_OBJECT_0:
+		return true;
+	case WAIT_TIMEOUT:
+		return false;
+	case WAIT_ABANDONED:
+		throw SystemException("cannot lock named mutex (abadoned)", _name);
+	default:
+		throw SystemException("cannot lock named mutex", _name);
+	}
+}
+
+
+void NamedMutexImpl::unlockImpl()
+{
+	ReleaseMutex(_mutex);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/NestedDiagnosticContext.cpp b/base/poco/Foundation/src/NestedDiagnosticContext.cpp
new file mode 100644
index 00000000000..dcbae13a0af
--- /dev/null
+++ b/base/poco/Foundation/src/NestedDiagnosticContext.cpp
@@ -0,0 +1,129 @@
+//
+// NestedDiagnosticContext.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  NestedDiagnosticContext
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/NestedDiagnosticContext.h"
+#include "Poco/SingletonHolder.h"
+#include "Poco/ThreadLocal.h"
+
+
+namespace Poco {
+
+
+NestedDiagnosticContext::NestedDiagnosticContext()
+{
+}
+
+
+NestedDiagnosticContext::NestedDiagnosticContext(const NestedDiagnosticContext& ctx)
+{
+	_stack = ctx._stack;
+}
+
+
+NestedDiagnosticContext::~NestedDiagnosticContext()
+{
+}
+
+
+NestedDiagnosticContext& NestedDiagnosticContext::operator = (const NestedDiagnosticContext& ctx)
+{
+	if (&ctx != this)
+		_stack = ctx._stack;
+	return *this;
+}
+
+	
+void NestedDiagnosticContext::push(const std::string& info)
+{
+	Context ctx;
+	ctx.info = info;
+	ctx.line = -1;
+	ctx.file = 0;
+	_stack.push_back(ctx);
+}
+
+	
+void NestedDiagnosticContext::push(const std::string& info, int line, const char* filename)
+{
+	Context ctx;
+	ctx.info = info;
+	ctx.line = line;
+	ctx.file = filename;
+	_stack.push_back(ctx);
+}
+
+
+void NestedDiagnosticContext::pop()
+{
+	if (!_stack.empty())
+		_stack.pop_back();
+}
+
+	
+int NestedDiagnosticContext::depth() const
+{
+	return int(_stack.size());
+}
+
+
+std::string NestedDiagnosticContext::toString() const
+{
+	std::string result;
+	for (Stack::const_iterator it = _stack.begin(); it != _stack.end(); ++it)
+	{
+		if (!result.empty())
+			result.append(":");
+		result.append(it->info);
+	}
+	return result;
+}
+
+	
+void NestedDiagnosticContext::dump(std::ostream& ostr) const
+{
+	dump(ostr, "\n");
+}
+
+
+void NestedDiagnosticContext::dump(std::ostream& ostr, const std::string& delimiter) const
+{
+	for (Stack::const_iterator it = _stack.begin(); it != _stack.end(); ++it)
+	{
+		ostr << it->info;
+		if (it->file)
+			ostr << " (in \"" << it->file << "\", line " << it->line << ")";
+		ostr << delimiter;
+	}
+}
+
+
+void NestedDiagnosticContext::clear()
+{
+	_stack.clear();
+}
+
+
+namespace
+{
+	static ThreadLocal<NestedDiagnosticContext> ndc;
+}
+
+
+NestedDiagnosticContext& NestedDiagnosticContext::current()
+{
+	return ndc.get();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Notification.cpp b/base/poco/Foundation/src/Notification.cpp
new file mode 100644
index 00000000000..b2d6b489a65
--- /dev/null
+++ b/base/poco/Foundation/src/Notification.cpp
@@ -0,0 +1,38 @@
+//
+// Notification.cpp
+//
+// Library: Foundation
+// Package: Notifications
+// Module:  Notification
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Notification.h"
+#include <typeinfo>
+
+
+namespace Poco {
+
+
+Notification::Notification()
+{
+}
+
+
+Notification::~Notification()
+{
+}
+
+
+std::string Notification::name() const
+{
+	return typeid(*this).name();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/NotificationCenter.cpp b/base/poco/Foundation/src/NotificationCenter.cpp
new file mode 100644
index 00000000000..3b024fa7300
--- /dev/null
+++ b/base/poco/Foundation/src/NotificationCenter.cpp
@@ -0,0 +1,109 @@
+//
+// NotificationCenter.cpp
+//
+// Library: Foundation
+// Package: Notifications
+// Module:  NotificationCenter
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/NotificationCenter.h"
+#include "Poco/Notification.h"
+#include "Poco/Observer.h"
+#include "Poco/AutoPtr.h"
+#include "Poco/SingletonHolder.h"
+
+
+namespace Poco {
+
+
+NotificationCenter::NotificationCenter()
+{
+}
+
+
+NotificationCenter::~NotificationCenter()
+{
+}
+
+
+void NotificationCenter::addObserver(const AbstractObserver& observer)
+{
+	Mutex::ScopedLock lock(_mutex);
+	_observers.push_back(observer.clone());
+}
+
+
+void NotificationCenter::removeObserver(const AbstractObserver& observer)
+{
+	Mutex::ScopedLock lock(_mutex);
+	for (ObserverList::iterator it = _observers.begin(); it != _observers.end(); ++it)
+	{
+		if (observer.equals(**it))
+		{
+			(*it)->disable();
+			_observers.erase(it);
+			return;
+		}
+	}
+}
+
+
+bool NotificationCenter::hasObserver(const AbstractObserver& observer) const
+{
+	Mutex::ScopedLock lock(_mutex);
+	for (ObserverList::const_iterator it = _observers.begin(); it != _observers.end(); ++it)
+		if (observer.equals(**it)) return true;
+
+	return false;
+}
+
+
+void NotificationCenter::postNotification(Notification::Ptr pNotification)
+{
+	poco_check_ptr (pNotification);
+
+	ScopedLockWithUnlock<Mutex> lock(_mutex);
+	ObserverList observersToNotify(_observers);
+	lock.unlock();
+	for (ObserverList::iterator it = observersToNotify.begin(); it != observersToNotify.end(); ++it)
+	{
+		(*it)->notify(pNotification);
+	}
+}
+
+
+bool NotificationCenter::hasObservers() const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	return !_observers.empty();
+}
+
+
+std::size_t NotificationCenter::countObservers() const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	return _observers.size();
+}
+
+
+namespace
+{
+	static SingletonHolder<NotificationCenter> sh;
+}
+
+
+NotificationCenter& NotificationCenter::defaultCenter()
+{
+	return *sh.get();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/NotificationQueue.cpp b/base/poco/Foundation/src/NotificationQueue.cpp
new file mode 100644
index 00000000000..670d11ec3a1
--- /dev/null
+++ b/base/poco/Foundation/src/NotificationQueue.cpp
@@ -0,0 +1,211 @@
+//
+// NotificationQueue.cpp
+//
+// Library: Foundation
+// Package: Notifications
+// Module:  NotificationQueue
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/NotificationQueue.h"
+#include "Poco/NotificationCenter.h"
+#include "Poco/Notification.h"
+#include "Poco/SingletonHolder.h"
+
+
+namespace Poco {
+
+
+NotificationQueue::NotificationQueue()
+{
+}
+
+
+NotificationQueue::~NotificationQueue()
+{
+	try
+	{
+		clear();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void NotificationQueue::enqueueNotification(Notification::Ptr pNotification)
+{
+	poco_check_ptr (pNotification);
+	FastMutex::ScopedLock lock(_mutex);
+	if (_waitQueue.empty())
+	{
+		_nfQueue.push_back(pNotification);
+	}
+	else
+	{
+		WaitInfo* pWI = _waitQueue.front();
+		_waitQueue.pop_front();
+		pWI->pNf = pNotification;
+		pWI->nfAvailable.set();
+	}	
+}
+
+
+void NotificationQueue::enqueueUrgentNotification(Notification::Ptr pNotification)
+{
+	poco_check_ptr (pNotification);
+	FastMutex::ScopedLock lock(_mutex);
+	if (_waitQueue.empty())
+	{
+		_nfQueue.push_front(pNotification);
+	}
+	else
+	{
+		WaitInfo* pWI = _waitQueue.front();
+		_waitQueue.pop_front();
+		pWI->pNf = pNotification;
+		pWI->nfAvailable.set();
+	}	
+}
+
+
+Notification* NotificationQueue::dequeueNotification()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	return dequeueOne().duplicate();
+}
+
+
+Notification* NotificationQueue::waitDequeueNotification()
+{
+	Notification::Ptr pNf;
+	WaitInfo* pWI = 0;
+	{
+		FastMutex::ScopedLock lock(_mutex);
+		pNf = dequeueOne();
+		if (pNf) return pNf.duplicate();
+		pWI = new WaitInfo;
+		_waitQueue.push_back(pWI);
+	}
+	pWI->nfAvailable.wait();
+	pNf = pWI->pNf;
+	delete pWI;
+	return pNf.duplicate();
+}
+
+
+Notification* NotificationQueue::waitDequeueNotification(long milliseconds)
+{
+	Notification::Ptr pNf;
+	WaitInfo* pWI = 0;
+	{
+		FastMutex::ScopedLock lock(_mutex);
+		pNf = dequeueOne();
+		if (pNf) return pNf.duplicate();
+		pWI = new WaitInfo;
+		_waitQueue.push_back(pWI);
+	}
+	if (pWI->nfAvailable.tryWait(milliseconds))
+	{
+		pNf = pWI->pNf;
+	}
+	else
+	{
+		FastMutex::ScopedLock lock(_mutex);
+		pNf = pWI->pNf;
+		for (WaitQueue::iterator it = _waitQueue.begin(); it != _waitQueue.end(); ++it)
+		{
+			if (*it == pWI)
+			{
+				_waitQueue.erase(it);
+				break;
+			}
+		}
+	}
+	delete pWI;
+	return pNf.duplicate();
+}
+
+
+void NotificationQueue::dispatch(NotificationCenter& notificationCenter)
+{
+	FastMutex::ScopedLock lock(_mutex);
+	Notification::Ptr pNf = dequeueOne();
+	while (pNf)
+	{
+		notificationCenter.postNotification(pNf);
+		pNf = dequeueOne();
+	}
+}
+
+
+void NotificationQueue::wakeUpAll()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	for (WaitQueue::iterator it = _waitQueue.begin(); it != _waitQueue.end(); ++it)
+	{
+		(*it)->nfAvailable.set();
+	}
+	_waitQueue.clear();
+}
+
+
+bool NotificationQueue::empty() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+	return _nfQueue.empty();
+}
+
+	
+int NotificationQueue::size() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+	return static_cast<int>(_nfQueue.size());
+}
+
+
+void NotificationQueue::clear()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	_nfQueue.clear();	
+}
+
+
+bool NotificationQueue::hasIdleThreads() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+	return !_waitQueue.empty();
+}
+
+
+Notification::Ptr NotificationQueue::dequeueOne()
+{
+	Notification::Ptr pNf;
+	if (!_nfQueue.empty())
+	{
+		pNf = _nfQueue.front();
+		_nfQueue.pop_front();
+	}
+	return pNf;
+}
+
+
+namespace
+{
+	static SingletonHolder<NotificationQueue> sh;
+}
+
+
+NotificationQueue& NotificationQueue::defaultQueue()
+{
+	return *sh.get();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/NullChannel.cpp b/base/poco/Foundation/src/NullChannel.cpp
new file mode 100644
index 00000000000..605151cd549
--- /dev/null
+++ b/base/poco/Foundation/src/NullChannel.cpp
@@ -0,0 +1,41 @@
+//
+// NullChannel.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  NullChannel
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/NullChannel.h"
+
+
+namespace Poco {
+
+
+NullChannel::NullChannel()
+{
+}
+
+
+NullChannel::~NullChannel()
+{
+}
+
+
+void NullChannel::log(const Message&)
+{
+}
+
+
+void NullChannel::setProperty(const std::string&, const std::string&)
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/NullStream.cpp b/base/poco/Foundation/src/NullStream.cpp
new file mode 100644
index 00000000000..e27042587c4
--- /dev/null
+++ b/base/poco/Foundation/src/NullStream.cpp
@@ -0,0 +1,74 @@
+//
+// NullStream.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  NullStream
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/NullStream.h"
+
+
+namespace Poco {
+
+
+NullStreamBuf::NullStreamBuf()
+{
+}
+
+
+NullStreamBuf::~NullStreamBuf()
+{
+}
+
+	
+int NullStreamBuf::readFromDevice()
+{
+	return -1;
+}
+
+
+int NullStreamBuf::writeToDevice(char c)
+{
+	return charToInt(c);
+}
+
+
+NullIOS::NullIOS()
+{
+	poco_ios_init(&_buf);
+}
+
+
+NullIOS::~NullIOS()
+{
+}
+
+
+NullInputStream::NullInputStream(): std::istream(&_buf)
+{
+}
+
+
+NullInputStream::~NullInputStream()
+{
+}
+
+
+NullOutputStream::NullOutputStream(): std::ostream(&_buf)
+{
+}
+
+
+NullOutputStream::~NullOutputStream()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/NumberFormatter.cpp b/base/poco/Foundation/src/NumberFormatter.cpp
new file mode 100644
index 00000000000..5c8126e9b0a
--- /dev/null
+++ b/base/poco/Foundation/src/NumberFormatter.cpp
@@ -0,0 +1,492 @@
+//
+// NumberFormatter.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  NumberFormatter
+//
+// Copyright (c) 2004-2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/NumberFormatter.h"
+#include "Poco/MemoryStream.h"
+#include <iomanip>
+#if !defined(POCO_NO_LOCALE)
+#include <locale>
+#endif
+#include <cstdio>
+
+
+#if defined(_MSC_VER) || defined(__MINGW32__)
+	#define I64_FMT "I64"
+#elif defined(__APPLE__) 
+	#define I64_FMT "q"
+#else
+	#define I64_FMT "ll"
+#endif
+
+
+namespace Poco {
+
+
+std::string NumberFormatter::format(bool value, BoolFormat format)
+{
+	switch(format)
+	{
+		default:
+		case FMT_TRUE_FALSE:
+			if (value == true)
+				return "true";
+			return "false";
+		case FMT_YES_NO:
+			if (value == true)
+				return "yes";
+			return "no";
+		case FMT_ON_OFF:
+			if (value == true)
+				return "on";
+			return "off";
+	}
+}
+
+
+void NumberFormatter::append(std::string& str, int value)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	intToStr(value, 10, result, sz);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append(std::string& str, int value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	intToStr(value, 10, result, sz, false, width);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append0(std::string& str, int value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	intToStr(value, 10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::appendHex(std::string& str, int value)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(static_cast<unsigned int>(value), 0x10, result, sz);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::appendHex(std::string& str, int value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(static_cast<unsigned int>(value), 0x10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append(std::string& str, unsigned value)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 10, result, sz);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append(std::string& str, unsigned value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 10, result, sz, false, width);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append0(std::string& str, unsigned int value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::appendHex(std::string& str, unsigned value)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 0x10, result, sz);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::appendHex(std::string& str, unsigned value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 0x10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append(std::string& str, long value)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	intToStr(value, 10, result, sz);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append(std::string& str, long value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	intToStr(value, 10, result, sz, false, width);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append0(std::string& str, long value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	intToStr(value, 10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::appendHex(std::string& str, long value)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(static_cast<unsigned long>(value), 0x10, result, sz);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::appendHex(std::string& str, long value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(static_cast<unsigned long>(value), 0x10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append(std::string& str, unsigned long value)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 10, result, sz);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append(std::string& str, unsigned long value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append0(std::string& str, unsigned long value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::appendHex(std::string& str, unsigned long value)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 0x10, result, sz);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::appendHex(std::string& str, unsigned long value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 0x10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+#ifdef POCO_HAVE_INT64
+
+#ifdef POCO_LONG_IS_64_BIT
+
+
+void NumberFormatter::append(std::string& str, long long value)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	intToStr(value, 10, result, sz);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append(std::string& str, long long value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	intToStr(value, 10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append0(std::string& str, long long value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	intToStr(value, 10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::appendHex(std::string& str, long long value)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(static_cast<unsigned long long>(value), 0x10, result, sz);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::appendHex(std::string& str, long long value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(static_cast<unsigned long long>(value), 0x10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append(std::string& str, unsigned long long value)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 10, result, sz);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append(std::string& str, unsigned long long value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append0(std::string& str, unsigned long long value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::appendHex(std::string& str, unsigned long long value)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 0x10, result, sz);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::appendHex(std::string& str, unsigned long long value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 0x10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+#else // ifndef POCO_LONG_IS_64_BIT
+
+
+void NumberFormatter::append(std::string& str, Int64 value)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	intToStr(value, 10, result, sz);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append(std::string& str, Int64 value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	intToStr(value, 10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append0(std::string& str, Int64 value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	intToStr(value, 10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::appendHex(std::string& str, Int64 value)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(static_cast<UInt64>(value), 0x10, result, sz);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::appendHex(std::string& str, Int64 value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(static_cast<UInt64>(value), 0x10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append(std::string& str, UInt64 value)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 10, result, sz);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append(std::string& str, UInt64 value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::append0(std::string& str, UInt64 value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::appendHex(std::string& str, UInt64 value)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 0x10, result, sz);
+	str.append(result, sz);
+}
+
+
+void NumberFormatter::appendHex(std::string& str, UInt64 value, int width)
+{
+	char result[NF_MAX_INT_STRING_LEN];
+	std::size_t sz = NF_MAX_INT_STRING_LEN;
+	uIntToStr(value, 0x10, result, sz, false, width, '0');
+	str.append(result, sz);
+}
+
+
+#endif // ifdef POCO_LONG_IS_64_BIT
+
+#endif // ifdef POCO_HAVE_INT64
+
+
+void NumberFormatter::append(std::string& str, float value)
+{
+	char buffer[NF_MAX_FLT_STRING_LEN];
+	floatToStr(buffer, POCO_MAX_FLT_STRING_LEN, value);
+	str.append(buffer);
+}
+
+
+void NumberFormatter::append(std::string& str, float value, int precision)
+{
+	char buffer[NF_MAX_FLT_STRING_LEN];
+	floatToFixedStr(buffer, POCO_MAX_FLT_STRING_LEN, value, precision);
+	str.append(buffer);
+}
+
+
+void NumberFormatter::append(std::string& str, float value, int width, int precision)
+{
+	std::string result;
+	str.append(floatToFixedStr(result, value, precision, width));
+}
+
+
+void NumberFormatter::append(std::string& str, double value)
+{
+	char buffer[NF_MAX_FLT_STRING_LEN];
+	doubleToStr(buffer, POCO_MAX_FLT_STRING_LEN, value);
+	str.append(buffer);
+}
+
+
+void NumberFormatter::append(std::string& str, double value, int precision)
+{
+	char buffer[NF_MAX_FLT_STRING_LEN];
+	doubleToFixedStr(buffer, POCO_MAX_FLT_STRING_LEN, value, precision);
+	str.append(buffer);
+}
+
+
+void NumberFormatter::append(std::string& str, double value, int width, int precision)
+{
+	std::string result;
+	str.append(doubleToFixedStr(result, value, precision, width));
+}
+
+
+void NumberFormatter::append(std::string& str, const void* ptr)
+{
+	char buffer[24];
+#if defined(POCO_PTR_IS_64_BIT)
+	#if defined(POCO_LONG_IS_64_BIT)
+		std::sprintf(buffer, "%016lX", (UIntPtr) ptr);
+	#else
+		std::sprintf(buffer, "%016" I64_FMT "X", (UIntPtr) ptr);
+	#endif
+#else
+	std::sprintf(buffer, "%08lX", (UIntPtr) ptr);
+#endif
+	str.append(buffer);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/NumberParser.cpp b/base/poco/Foundation/src/NumberParser.cpp
new file mode 100644
index 00000000000..56eeb167595
--- /dev/null
+++ b/base/poco/Foundation/src/NumberParser.cpp
@@ -0,0 +1,250 @@
+//
+// NumberParser.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  NumberParser
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/NumberParser.h"
+#include "Poco/Exception.h"
+#include "Poco/String.h"
+#include "Poco/NumericString.h"
+#include <cstdio>
+#include <cctype>
+#include <stdlib.h>
+#if !defined(POCO_NO_LOCALE)
+	#include <locale>
+#endif
+
+
+#if defined(POCO_LONG_IS_64_BIT)
+	#define I64_FMT "l"
+#elif defined(_MSC_VER) || defined(__MINGW32__)
+	#define I64_FMT "I64"
+#elif defined(__APPLE__) 
+	#define I64_FMT "q"
+#else
+	#define I64_FMT "ll"
+#endif
+
+
+namespace Poco {
+
+
+int NumberParser::parse(const std::string& s, char thSep)
+{
+	int result;
+	if (tryParse(s, result, thSep))
+		return result;
+	else
+		throw SyntaxException("Not a valid integer", s);
+}
+
+
+bool NumberParser::tryParse(const std::string& s, int& value, char thSep)
+{
+	return strToInt(s.c_str(), value, NUM_BASE_DEC, thSep);
+}
+
+
+unsigned NumberParser::parseUnsigned(const std::string& s, char thSep)
+{
+	unsigned result;
+	if (tryParseUnsigned(s, result, thSep))
+		return result;
+	else
+		throw SyntaxException("Not a valid unsigned integer", s);
+}
+
+
+bool NumberParser::tryParseUnsigned(const std::string& s, unsigned& value, char thSep)
+{
+	return strToInt(s.c_str(), value, NUM_BASE_DEC, thSep);
+}
+
+
+unsigned NumberParser::parseHex(const std::string& s)
+{
+	unsigned result;
+	if (tryParseHex(s, result))
+		return result;
+	else
+		throw SyntaxException("Not a valid hexadecimal integer", s);
+}
+
+
+bool NumberParser::tryParseHex(const std::string& s, unsigned& value)
+{
+	int offset = 0;
+	if (s.size() > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) offset = 2;
+	return strToInt(s.c_str() + offset, value, NUM_BASE_HEX);
+}
+
+
+unsigned NumberParser::parseOct(const std::string& s)
+{
+	unsigned result;
+	if (tryParseOct(s, result))
+		return result;
+	else
+		throw SyntaxException("Not a valid hexadecimal integer", s);
+}
+
+
+bool NumberParser::tryParseOct(const std::string& s, unsigned& value)
+{
+	return strToInt(s.c_str(), value, NUM_BASE_OCT);
+}
+
+
+#if defined(POCO_HAVE_INT64)
+
+
+Int64 NumberParser::parse64(const std::string& s, char thSep)
+{
+	Int64 result;
+	if (tryParse64(s, result, thSep))
+		return result;
+	else
+		throw SyntaxException("Not a valid integer", s);
+}
+
+
+bool NumberParser::tryParse64(const std::string& s, Int64& value, char thSep)
+{
+	return strToInt(s.c_str(), value, NUM_BASE_DEC, thSep);
+}
+
+
+UInt64 NumberParser::parseUnsigned64(const std::string& s, char thSep)
+{
+	UInt64 result;
+	if (tryParseUnsigned64(s, result, thSep))
+		return result;
+	else
+		throw SyntaxException("Not a valid unsigned integer", s);
+}
+
+
+bool NumberParser::tryParseUnsigned64(const std::string& s, UInt64& value, char thSep)
+{
+	return strToInt(s.c_str(), value, NUM_BASE_DEC, thSep);
+}
+
+
+UInt64 NumberParser::parseHex64(const std::string& s)
+{
+	UInt64 result;
+	if (tryParseHex64(s, result))
+		return result;
+	else
+		throw SyntaxException("Not a valid hexadecimal integer", s);
+}
+
+
+bool NumberParser::tryParseHex64(const std::string& s, UInt64& value)
+{
+	int offset = 0;
+	if (s.size() > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X')) offset = 2;
+	return strToInt(s.c_str() + offset, value, NUM_BASE_HEX);
+}
+
+
+UInt64 NumberParser::parseOct64(const std::string& s)
+{
+	UInt64 result;
+	if (tryParseOct64(s, result))
+		return result;
+	else
+		throw SyntaxException("Not a valid hexadecimal integer", s);
+}
+
+
+bool NumberParser::tryParseOct64(const std::string& s, UInt64& value)
+{
+	return strToInt(s.c_str(), value, NUM_BASE_OCT);
+}
+
+
+#endif // defined(POCO_HAVE_INT64)
+
+
+double NumberParser::parseFloat(const std::string& s, char decSep, char thSep)
+{
+	double result;
+	if (tryParseFloat(s, result, decSep, thSep))
+		return result;
+	else
+		throw SyntaxException("Not a valid floating-point number", s);
+}
+
+
+bool NumberParser::tryParseFloat(const std::string& s, double& value, char decSep, char thSep)
+{
+	return strToDouble(s.c_str(), value, decSep, thSep);
+}
+
+
+bool NumberParser::parseBool(const std::string& s)
+{
+	bool result;
+	if (tryParseBool(s, result))
+		return result;
+	else
+		throw SyntaxException("Not a valid bool number", s);
+}
+
+	
+bool NumberParser::tryParseBool(const std::string& s, bool& value)
+{
+	int n;
+	if (NumberParser::tryParse(s, n))
+	{
+		value = (n != 0);
+		return true;
+	}
+
+	if (icompare(s, "true") == 0)
+	{
+		value = true;
+		return true;
+	}
+	else if (icompare(s, "yes") == 0)
+	{
+		value = true;
+		return true;
+	}
+	else if (icompare(s, "on") == 0)
+	{
+		value = true;
+		return true;
+	}
+	
+	if (icompare(s, "false") == 0)
+	{
+		value = false;
+		return true;
+	}
+	else if (icompare(s, "no") == 0)
+	{
+		value = false;
+		return true;
+	}
+	else if (icompare(s, "off") == 0)
+	{
+		value = false;
+		return true;
+	}
+	
+	return false;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/NumericString.cpp b/base/poco/Foundation/src/NumericString.cpp
new file mode 100644
index 00000000000..90b943015d6
--- /dev/null
+++ b/base/poco/Foundation/src/NumericString.cpp
@@ -0,0 +1,316 @@
+//
+// NumericString.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  NumericString
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Bugcheck.h"
+
+
+// +++ double conversion +++
+#define double_conversion poco_double_conversion	// don't collide with standalone double_conversion library
+#define UNREACHABLE poco_bugcheck
+#define UNIMPLEMENTED poco_bugcheck
+#include "diy-fp.cc"
+#include "cached-powers.cc"
+#include "bignum-dtoa.cc"
+#include "bignum.cc"
+#include "fast-dtoa.cc"
+#include "fixed-dtoa.cc"
+#include "strtod.cc"
+#include "double-conversion.cc"
+// --- double conversion ---
+
+#include "Poco/NumericString.h"
+poco_static_assert(POCO_MAX_FLT_STRING_LEN == double_conversion::kMaxSignificantDecimalDigits);
+#include "Poco/String.h"
+#include <memory>
+#include <cctype>
+
+
+namespace {
+
+
+void pad(std::string& str, int precision, int width, char prefix = ' ', char decSep = '.')
+	/// Pads the string with prefix space and postfix 0.
+	/// Alternative prefix (e.g. zero instead of space) can be supplied by caller.
+	/// Used only internally.
+{
+	// these cases should never happen, if they do, it's a library bug
+	poco_assert_dbg (precision > 0);
+	poco_assert_dbg (str.length());
+
+	std::string::size_type decSepPos = str.find(decSep);
+	if (decSepPos == std::string::npos)
+	{
+		str.append(1, '.');
+		decSepPos = str.size() - 1;
+	}
+
+	std::string::size_type frac = str.length() - decSepPos - 1;
+
+	std::string::size_type ePos = str.find_first_of("eE");
+#ifndef POCO_ENABLE_CPP11
+	std::auto_ptr<std::string> eStr;
+#else
+	std::unique_ptr<std::string> eStr;
+#endif // POCO_ENABLE_CPP11
+	if (ePos != std::string::npos)
+	{
+		eStr.reset(new std::string(str.substr(ePos, std::string::npos)));
+		frac -= eStr->length();
+		str = str.substr(0, str.length() - eStr->length());
+	}
+
+	if (frac != precision)
+	{
+		if (frac < precision)
+			str.append(precision - frac, '0');
+		else if ((frac > precision) && (decSepPos != std::string::npos)) 
+			str = str.substr(0, decSepPos + 1 + precision);
+	}
+
+	if (eStr.get()) str += *eStr;
+
+	if (width && (str.length() < width)) str.insert(str.begin(), width - str.length(), prefix);
+}
+
+
+void insertThousandSep(std::string& str, char thSep, char decSep = '.')
+	/// Inserts thousand separators.
+	/// Used only internally.
+{
+	poco_assert (decSep != thSep);
+	if (str.size() == 0) return;
+
+	std::string::size_type exPos = str.find('e');
+	if (exPos == std::string::npos) exPos = str.find('E');
+	std::string::size_type decPos = str.find(decSep);
+	// there's no rinsert, using forward iterator to go backwards
+	std::string::iterator it = str.end();
+	if (exPos != std::string::npos) it -= str.size() - exPos;
+
+	if (decPos != std::string::npos)
+	{
+		while (it != str.begin())
+		{
+			--it;
+			if (*it == decSep) break;
+		}
+	}
+	int thCount = 0;
+	if (it == str.end()) --it;
+	for (; it != str.begin();)
+	{
+		std::string::iterator pos = it;
+		std::string::value_type chr = *it;
+		std::string::value_type prevChr = *--it;
+
+		if (!std::isdigit(chr)) continue;
+
+		if (++thCount == 3 && std::isdigit(prevChr))
+			it = str.insert(pos, thSep);
+
+		if (thCount == 3) thCount = 0;
+	}
+}
+
+
+} // namespace
+
+
+namespace Poco {
+
+
+void floatToStr(char* buffer, int bufferSize, float value, int lowDec, int highDec)
+{
+	using namespace double_conversion;
+
+	StringBuilder builder(buffer, bufferSize);
+	int flags = DoubleToStringConverter::UNIQUE_ZERO |
+		DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN;
+	DoubleToStringConverter dc(flags, POCO_FLT_INF, POCO_FLT_NAN, POCO_FLT_EXP, lowDec, highDec, 0, 0);
+	dc.ToShortestSingle(value, &builder);
+	builder.Finalize();
+}
+
+
+void floatToFixedStr(char* buffer, int bufferSize, float value, int precision)
+{
+	using namespace double_conversion;
+
+	StringBuilder builder(buffer, bufferSize);
+	int flags = DoubleToStringConverter::UNIQUE_ZERO |
+		DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN;
+	DoubleToStringConverter dc(flags, POCO_FLT_INF, POCO_FLT_NAN, POCO_FLT_EXP, -std::numeric_limits<float>::digits10, std::numeric_limits<float>::digits10, 0, 0);
+	dc.ToFixed(value, precision, &builder);
+	builder.Finalize();
+}
+
+
+std::string& floatToStr(std::string& str, float value, int precision, int width, char thSep, char decSep)
+{
+	if (!decSep) decSep = '.';
+	if (precision == 0) value = std::floor(value);
+
+	char buffer[POCO_MAX_FLT_STRING_LEN];
+	floatToStr(buffer, POCO_MAX_FLT_STRING_LEN, value);
+	str = buffer;
+	
+	if (decSep && (decSep != '.') && (str.find('.') != std::string::npos))
+		replaceInPlace(str, '.', decSep);
+
+	if (thSep) insertThousandSep(str, thSep, decSep);
+	if (precision > 0 || width) pad(str, precision, width, ' ', decSep ? decSep : '.');
+	return str;
+}
+
+
+std::string& floatToFixedStr(std::string& str, float value, int precision, int width, char thSep, char decSep)
+{
+	if (!decSep) decSep = '.';
+	if (precision == 0) value = std::floor(value);
+
+	char buffer[POCO_MAX_FLT_STRING_LEN];
+	floatToFixedStr(buffer, POCO_MAX_FLT_STRING_LEN, value, precision);
+	str = buffer;
+	
+	if (decSep && (decSep != '.') && (str.find('.') != std::string::npos))
+		replaceInPlace(str, '.', decSep);
+
+	if (thSep) insertThousandSep(str, thSep, decSep);
+	if (precision > 0 || width) pad(str, precision, width, ' ', decSep ? decSep : '.');
+	return str;
+}
+
+
+void doubleToStr(char* buffer, int bufferSize, double value, int lowDec, int highDec)
+{
+	using namespace double_conversion;
+
+	StringBuilder builder(buffer, bufferSize);
+	int flags = DoubleToStringConverter::UNIQUE_ZERO |
+		DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN;
+	DoubleToStringConverter dc(flags, POCO_FLT_INF, POCO_FLT_NAN, POCO_FLT_EXP, lowDec, highDec, 0, 0);
+	dc.ToShortest(value, &builder);
+	builder.Finalize();
+}
+
+
+void doubleToFixedStr(char* buffer, int bufferSize, double value, int precision)
+{
+	using namespace double_conversion;
+
+	StringBuilder builder(buffer, bufferSize);
+	int flags = DoubleToStringConverter::UNIQUE_ZERO |
+		DoubleToStringConverter::EMIT_POSITIVE_EXPONENT_SIGN;
+	DoubleToStringConverter dc(flags, POCO_FLT_INF, POCO_FLT_NAN, POCO_FLT_EXP, -std::numeric_limits<double>::digits10, std::numeric_limits<double>::digits10, 0, 0);
+	dc.ToFixed(value, precision, &builder);
+	builder.Finalize();
+}
+
+
+std::string& doubleToStr(std::string& str, double value, int precision, int width, char thSep, char decSep)
+{
+	if (!decSep) decSep = '.';
+	if (precision == 0) value = std::floor(value);
+
+	char buffer[POCO_MAX_FLT_STRING_LEN];
+	doubleToStr(buffer, POCO_MAX_FLT_STRING_LEN, value);
+		
+	str = buffer;
+	
+	if (decSep && (decSep != '.') && (str.find('.') != std::string::npos))
+		replaceInPlace(str, '.', decSep);
+
+	if (thSep) insertThousandSep(str, thSep, decSep);
+	if (precision > 0 || width) pad(str, precision, width, ' ', decSep ? decSep : '.');
+	return str;
+}
+
+
+std::string& doubleToFixedStr(std::string& str, double value, int precision, int width, char thSep, char decSep)
+{
+	if (!decSep) decSep = '.';
+	if (precision == 0) value = std::floor(value);
+
+	char buffer[POCO_MAX_FLT_STRING_LEN];
+	doubleToFixedStr(buffer, POCO_MAX_FLT_STRING_LEN, value, precision);
+		
+	str = buffer;
+	
+	if (decSep && (decSep != '.') && (str.find('.') != std::string::npos))
+		replaceInPlace(str, '.', decSep);
+
+	if (thSep) insertThousandSep(str, thSep, decSep);
+	if (precision > 0 || width) pad(str, precision, width, ' ', decSep ? decSep : '.');
+	return str;
+}
+
+
+float strToFloat(const char* str)
+{
+	using namespace double_conversion;
+
+	int processed;
+	int flags = StringToDoubleConverter::ALLOW_LEADING_SPACES |
+		StringToDoubleConverter::ALLOW_TRAILING_SPACES;
+	StringToDoubleConverter converter(flags, 0.0, Single::NaN(), POCO_FLT_INF, POCO_FLT_NAN);
+	float result = converter.StringToFloat(str, static_cast<int>(strlen(str)), &processed);
+	return result;
+}
+
+
+double strToDouble(const char* str)
+{
+	using namespace double_conversion;
+	int processed;
+	int flags = StringToDoubleConverter::ALLOW_LEADING_SPACES |
+		StringToDoubleConverter::ALLOW_TRAILING_SPACES;
+	StringToDoubleConverter converter(flags, 0.0, Double::NaN(), POCO_FLT_INF, POCO_FLT_NAN);
+	double result = converter.StringToDouble(str, static_cast<int>(strlen(str)), &processed);
+	return result;
+}
+
+
+bool strToFloat(const std::string& str, float& result, char decSep, char thSep)
+{
+	using namespace double_conversion;
+
+	std::string tmp(str);
+	trimInPlace(tmp);
+	removeInPlace(tmp, thSep);
+	removeInPlace(tmp, 'f');
+	replaceInPlace(tmp, decSep, '.');
+	result = strToFloat(tmp.c_str());
+	return !FPEnvironment::isInfinite(result) &&
+		!FPEnvironment::isNaN(result);
+}
+
+
+bool strToDouble(const std::string& str, double& result, char decSep, char thSep)
+{
+	if (str.empty()) return false;
+
+	using namespace double_conversion;
+
+	std::string tmp(str);
+	trimInPlace(tmp);
+	removeInPlace(tmp, thSep);
+	replaceInPlace(tmp, decSep, '.');
+	removeInPlace(tmp, 'f');
+	result = strToDouble(tmp.c_str());
+	return !FPEnvironment::isInfinite(result) &&
+		!FPEnvironment::isNaN(result);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Path.cpp b/base/poco/Foundation/src/Path.cpp
new file mode 100644
index 00000000000..6b26ca04667
--- /dev/null
+++ b/base/poco/Foundation/src/Path.cpp
@@ -0,0 +1,1064 @@
+//
+// Path.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  Path
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Path.h"
+#include "Poco/File.h"
+#include "Poco/Exception.h"
+#include "Poco/StringTokenizer.h"
+#if defined(_WIN32) && defined(POCO_WIN32_UTF8)
+#include "Poco/UnicodeConverter.h"
+#include "Poco/Buffer.h"
+#endif
+#include <algorithm>
+
+
+#if defined(POCO_OS_FAMILY_UNIX)
+#include "Path_UNIX.cpp"
+#elif defined(POCO_OS_FAMILY_WINDOWS) && defined(POCO_WIN32_UTF8)
+#if defined(_WIN32_WCE)
+#include "Path_WINCE.cpp"
+#else
+#include "Path_WIN32U.cpp"
+#endif
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "Path_WIN32.cpp"
+#endif
+
+
+namespace Poco {
+
+
+Path::Path(): _absolute(false)
+{
+}
+
+
+Path::Path(bool absolute): _absolute(absolute)
+{
+}
+
+
+Path::Path(const std::string& path)
+{
+	assign(path);
+}
+
+
+Path::Path(const std::string& path, Style style)
+{
+	assign(path, style);
+}
+
+
+Path::Path(const char* path)
+{
+	poco_check_ptr(path);
+	assign(path);
+}
+
+
+Path::Path(const char* path, Style style)
+{
+	poco_check_ptr(path);
+	assign(path, style);
+}
+
+
+Path::Path(const Path& path):
+	_node(path._node),
+	_device(path._device),
+	_name(path._name),
+	_version(path._version),
+	_dirs(path._dirs),
+	_absolute(path._absolute)
+{
+}
+
+
+Path::Path(const Path& parent, const std::string& fileName):
+	_node(parent._node),
+	_device(parent._device),
+	_name(parent._name),
+	_version(parent._version),
+	_dirs(parent._dirs),
+	_absolute(parent._absolute)
+{
+	makeDirectory();
+	_name = fileName;
+}
+
+
+Path::Path(const Path& parent, const char* fileName):
+	_node(parent._node),
+	_device(parent._device),
+	_name(parent._name),
+	_version(parent._version),
+	_dirs(parent._dirs),
+	_absolute(parent._absolute)
+{
+	makeDirectory();
+	_name = fileName;
+}
+
+
+Path::Path(const Path& parent, const Path& relative):
+	_node(parent._node),
+	_device(parent._device),
+	_name(parent._name),
+	_version(parent._version),
+	_dirs(parent._dirs),
+	_absolute(parent._absolute)
+{
+	resolve(relative);
+}
+
+
+Path::~Path()
+{
+}
+
+
+Path& Path::operator = (const Path& path)
+{
+	return assign(path);
+}
+
+
+Path& Path::operator = (const std::string& path)
+{
+	return assign(path);
+}
+
+
+Path& Path::operator = (const char* path)
+{
+	poco_check_ptr(path);
+	return assign(path);
+}
+
+
+void Path::swap(Path& path)
+{
+	std::swap(_node, path._node);
+	std::swap(_device, path._device);
+	std::swap(_name, path._name);
+	std::swap(_version, path._version);
+	std::swap(_dirs, path._dirs);
+	std::swap(_absolute, path._absolute);
+}
+
+
+Path& Path::assign(const Path& path)
+{
+	if (&path != this)
+	{
+		_node     = path._node;
+		_device   = path._device;
+		_name     = path._name;
+		_version  = path._version;
+		_dirs     = path._dirs;
+		_absolute = path._absolute;
+	}
+	return *this;
+}
+
+
+Path& Path::assign(const std::string& path)
+{
+#if defined(POCO_OS_FAMILY_WINDOWS)
+	parseWindows(path);
+#else
+	parseUnix(path);
+#endif
+	return *this;
+}
+
+
+Path& Path::assign(const std::string& path, Style style)
+{
+	switch (style)
+	{
+	case PATH_UNIX:
+		parseUnix(path);
+		break;
+	case PATH_WINDOWS:
+		parseWindows(path);
+		break;
+	case PATH_VMS:
+		parseVMS(path);
+		break;
+	case PATH_NATIVE:
+		assign(path);
+		break;
+	case PATH_GUESS:
+		parseGuess(path);
+		break;
+	default:
+		poco_bugcheck();
+	}
+	return *this;
+}
+
+
+Path& Path::assign(const char* path)
+{
+	return assign(std::string(path));
+}
+
+
+std::string Path::toString() const
+{
+#if defined(POCO_OS_FAMILY_WINDOWS)
+	return buildWindows();
+#else
+	return buildUnix();
+#endif
+}
+
+
+std::string Path::toString(Style style) const
+{
+	switch (style)
+	{
+	case PATH_UNIX:
+		return buildUnix();
+	case PATH_WINDOWS:
+		return buildWindows();
+	case PATH_VMS:
+		return buildVMS();
+	case PATH_NATIVE:
+	case PATH_GUESS:
+		return toString();
+	default:
+		poco_bugcheck();
+	}
+	return std::string();
+}
+
+
+bool Path::tryParse(const std::string& path)
+{
+	try
+	{
+		Path p;
+		p.parse(path);
+		assign(p);
+		return true;
+	}
+	catch (...)
+	{
+		return false;
+	}
+}
+
+
+bool Path::tryParse(const std::string& path, Style style)
+{
+	try
+	{
+		Path p;
+		p.parse(path, style);
+		assign(p);
+		return true;
+	}
+	catch (...)
+	{
+		return false;
+	}
+}
+
+
+Path& Path::parseDirectory(const std::string& path)
+{
+	assign(path);
+	return makeDirectory();
+}
+
+
+Path& Path::parseDirectory(const std::string& path, Style style)
+{
+	assign(path, style);
+	return makeDirectory();
+}
+
+
+Path& Path::makeDirectory()
+{
+	pushDirectory(_name);
+	_name.clear();
+	_version.clear();
+	return *this;
+}
+
+
+Path& Path::makeFile()
+{
+	if (!_dirs.empty() && _name.empty())
+	{
+		_name = _dirs.back();
+		_dirs.pop_back();
+	}
+	return *this;
+}
+
+
+Path& Path::makeAbsolute()
+{
+	return makeAbsolute(current());
+}
+
+
+Path& Path::makeAbsolute(const Path& base)
+{
+	if (!_absolute)
+	{
+		Path tmp = base;
+		tmp.makeDirectory();
+		for (StringVec::const_iterator it = _dirs.begin(); it != _dirs.end(); ++it)
+		{
+			tmp.pushDirectory(*it);
+		}
+		_node     = tmp._node;
+		_device   = tmp._device;
+		_dirs     = tmp._dirs;
+		_absolute = base._absolute;
+	}
+	return *this;
+}
+
+
+Path Path::absolute() const
+{
+	Path result(*this);
+	if (!result._absolute)
+	{
+		result.makeAbsolute();
+	}
+	return result;
+}
+
+
+Path Path::absolute(const Path& base) const
+{
+	Path result(*this);
+	if (!result._absolute)
+	{
+		result.makeAbsolute(base);
+	}
+	return result;
+}
+
+
+Path Path::parent() const
+{
+	Path p(*this);
+	return p.makeParent();
+}
+
+
+Path& Path::makeParent()
+{
+	if (_name.empty())
+	{
+		if (_dirs.empty())
+		{
+			if (!_absolute)
+				_dirs.push_back("..");
+		}
+		else
+		{
+			if (_dirs.back() == "..")
+				_dirs.push_back("..");
+			else
+				_dirs.pop_back();
+		}
+	}
+	else
+	{
+		_name.clear();
+		_version.clear();
+	}
+	return *this;
+}
+
+
+Path& Path::append(const Path& path)
+{
+	makeDirectory();
+	_dirs.insert(_dirs.end(), path._dirs.begin(), path._dirs.end());
+	_name = path._name;
+	_version = path._version;
+	return *this;
+}
+
+
+Path& Path::resolve(const Path& path)
+{
+	if (path.isAbsolute())
+	{
+		assign(path);
+	}
+	else
+	{
+		for (int i = 0; i < path.depth(); ++i)
+			pushDirectory(path[i]);
+		_name = path._name;
+	}
+	return *this;
+}
+
+
+Path& Path::setNode(const std::string& node)
+{
+	_node     = node;
+	_absolute = _absolute || !node.empty();
+	return *this;
+}
+
+
+Path& Path::setDevice(const std::string& device)
+{
+	_device   = device;
+	_absolute = _absolute || !device.empty();
+	return *this;
+}
+
+
+const std::string& Path::directory(int n) const
+{
+	poco_assert (0 <= n && n <= _dirs.size());
+
+	if (n < _dirs.size())
+		return _dirs[n];
+	else
+		return _name;
+}
+
+
+const std::string& Path::operator [] (int n) const
+{
+	poco_assert (0 <= n && n <= _dirs.size());
+
+	if (n < _dirs.size())
+		return _dirs[n];
+	else
+		return _name;
+}
+
+
+Path& Path::pushDirectory(const std::string& dir)
+{
+	if (!dir.empty() && dir != ".")
+	{
+		if (dir == "..")
+		{
+			if (!_dirs.empty() && _dirs.back() != "..")
+				_dirs.pop_back();
+			else if (!_absolute)
+				_dirs.push_back(dir);
+		}
+		else _dirs.push_back(dir);
+	}
+	return *this;
+}
+
+
+Path& Path::popDirectory()
+{
+	poco_assert (!_dirs.empty());
+
+	_dirs.pop_back();
+	return *this;
+}
+
+
+Path& Path::popFrontDirectory()
+{
+	poco_assert (!_dirs.empty());
+
+	StringVec::iterator it = _dirs.begin();
+	_dirs.erase(it);
+	return *this;
+}
+
+
+Path& Path::setFileName(const std::string& name)
+{
+	_name = name;
+	return *this;
+}
+
+
+Path& Path::setBaseName(const std::string& name)
+{
+	std::string ext = getExtension();
+	_name = name;
+	if (!ext.empty())
+	{
+		_name.append(".");
+		_name.append(ext);
+	}
+	return *this;
+}
+
+
+std::string Path::getBaseName() const
+{
+	std::string::size_type pos = _name.rfind('.');
+	if (pos != std::string::npos)
+		return _name.substr(0, pos);
+	else
+		return _name;
+}
+
+
+Path& Path::setExtension(const std::string& extension)
+{
+	_name = getBaseName();
+	if (!extension.empty())
+	{
+		_name.append(".");
+		_name.append(extension);
+	}
+	return *this;
+}
+
+
+std::string Path::getExtension() const
+{
+	std::string::size_type pos = _name.rfind('.');
+	if (pos != std::string::npos)
+		return _name.substr(pos + 1);
+	else
+		return std::string();
+}
+
+
+Path& Path::clear()
+{
+	_node.clear();
+	_device.clear();
+	_name.clear();
+	_dirs.clear();
+	_version.clear();
+	_absolute = false;
+	return *this;
+}
+
+
+std::string Path::current()
+{
+	return PathImpl::currentImpl();
+}
+
+
+std::string Path::home()
+{
+	return PathImpl::homeImpl();
+}
+
+
+std::string Path::configHome()
+{
+#if defined(POCO_OS_FAMILY_UNIX) || defined(POCO_OS_FAMILY_WINDOWS)
+	return PathImpl::configHomeImpl();
+#else
+	return PathImpl::homeImpl();
+#endif
+}
+
+	
+std::string Path::dataHome()
+{
+#if defined(POCO_OS_FAMILY_UNIX) || defined(POCO_OS_FAMILY_WINDOWS)
+	return PathImpl::dataHomeImpl();
+#else
+	return PathImpl::homeImpl();
+#endif
+}
+
+	
+std::string Path::tempHome()
+{
+#if defined(POCO_OS_FAMILY_UNIX) || defined(POCO_OS_FAMILY_WINDOWS)
+	return PathImpl::tempHomeImpl();
+#else
+	return PathImpl::tempImpl();
+#endif
+}
+
+	
+std::string Path::cacheHome()
+{
+#if defined(POCO_OS_FAMILY_UNIX) || defined(POCO_OS_FAMILY_WINDOWS)
+	return PathImpl::cacheHomeImpl();
+#else
+	return PathImpl::homeImpl();
+#endif
+}
+
+
+std::string Path::temp()
+{
+	return PathImpl::tempImpl();
+}
+
+
+std::string Path::config()
+{
+#if defined(POCO_OS_FAMILY_UNIX) || defined(POCO_OS_FAMILY_WINDOWS)
+	return PathImpl::configImpl();
+#else
+	return PathImpl::currentImpl();
+#endif
+}
+
+
+std::string Path::null()
+{
+	return PathImpl::nullImpl();
+}
+
+
+std::string Path::expand(const std::string& path)
+{
+	return PathImpl::expandImpl(path);
+}
+
+
+void Path::listRoots(std::vector<std::string>& roots)
+{
+	PathImpl::listRootsImpl(roots);
+}
+
+
+bool Path::find(StringVec::const_iterator it, StringVec::const_iterator end, const std::string& name, Path& path)
+{
+	while (it != end)
+	{
+#if defined(WIN32)
+		std::string cleanPath(*it);
+		if (cleanPath.size() > 1 && cleanPath[0] == '"' && cleanPath[cleanPath.size() - 1] == '"')
+		{
+			cleanPath = cleanPath.substr(1, cleanPath.size() - 2);
+		}
+		Path p(cleanPath);
+#else
+		Path p(*it);
+#endif
+		p.makeDirectory();
+		p.resolve(Path(name));
+		File f(p);
+		if (f.exists())
+		{
+			path = p;
+			return true;
+		}
+		++it;
+	}
+	return false;
+}
+
+
+bool Path::find(const std::string& pathList, const std::string& name, Path& path)
+{
+	StringTokenizer st(pathList, std::string(1, pathSeparator()), StringTokenizer::TOK_IGNORE_EMPTY + StringTokenizer::TOK_TRIM);
+	return find(st.begin(), st.end(), name, path);
+}
+
+
+void Path::parseUnix(const std::string& path)
+{
+	clear();
+
+	std::string::const_iterator it  = path.begin();
+	std::string::const_iterator end = path.end();
+
+	if (it != end)
+	{
+		if (*it == '/')
+		{
+			_absolute = true; ++it;
+		}
+		else if (*it == '~')
+		{
+			++it;
+			if (it == end || *it == '/')
+			{
+				Path cwd(home());
+				_dirs = cwd._dirs;
+				_absolute = true;
+			}
+			else --it;
+		}
+
+		while (it != end)
+		{
+			std::string name;
+			while (it != end && *it != '/') name += *it++;
+			if (it != end)
+			{
+				if (_dirs.empty())
+				{
+					if (!name.empty() && *(name.rbegin()) == ':')
+					{
+						_absolute = true;
+						_device.assign(name, 0, name.length() - 1);
+					}
+					else
+					{
+						pushDirectory(name);
+					}
+				}
+				else pushDirectory(name);
+			}
+			else _name = name;
+			if (it != end) ++it;
+		}
+	}
+}
+
+
+void Path::parseWindows(const std::string& path)
+{
+	clear();
+
+	std::string::const_iterator it  = path.begin();
+	std::string::const_iterator end = path.end();
+
+	if (it != end)
+	{
+		if (*it == '\\' || *it == '/') { _absolute = true; ++it; }
+		if (_absolute && it != end && (*it == '\\' || *it == '/')) // UNC
+		{
+			++it;
+			while (it != end && *it != '\\' && *it != '/') _node += *it++;
+			if (it != end) ++it;
+		}
+		else if (it != end)
+		{
+			char d = *it++;
+			if (it != end && *it == ':') // drive letter
+			{
+				if (_absolute || !((d >= 'a' && d <= 'z') || (d >= 'A' && d <= 'Z'))) throw PathSyntaxException(path);
+				_absolute = true;
+				_device += d;
+				++it;
+				if (it == end || (*it != '\\' && *it != '/')) throw PathSyntaxException(path);
+				++it;
+			}
+			else --it;
+		}
+		while (it != end)
+		{
+			std::string name;
+			while (it != end && *it != '\\' && *it != '/') name += *it++;
+			if (it != end)
+				pushDirectory(name);
+			else
+				_name = name;
+			if (it != end) ++it;
+		}
+	}
+	if (!_node.empty() && _dirs.empty() && !_name.empty())
+		makeDirectory();
+}
+
+
+void Path::parseVMS(const std::string& path)
+{
+	clear();
+
+	std::string::const_iterator it  = path.begin();
+	std::string::const_iterator end = path.end();
+
+	if (it != end)
+	{
+		std::string name;
+		while (it != end && *it != ':' && *it != '[' && *it != ';') name += *it++;
+		if (it != end)
+		{
+			if (*it == ':')
+			{
+				++it;
+				if (it != end && *it == ':')
+				{
+					_node = name;
+					++it;
+				}
+				else _device = name;
+				_absolute = true;
+				name.clear();
+			}
+			if (it != end)
+			{
+				if (_device.empty() && *it != '[')
+				{
+					while (it != end && *it != ':' && *it != ';') name += *it++;
+					if (it != end)
+					{
+						if (*it == ':')
+						{
+							_device = name;
+							_absolute = true;
+							name.clear();
+							++it;
+						}
+					}
+				}
+			}
+			if (name.empty())
+			{
+				if (it != end && *it == '[')
+				{
+					++it;
+					if (it != end)
+					{
+						_absolute = true;
+						if (*it == '.')
+							{ _absolute = false; ++it; }
+						else if (*it == ']' || *it == '-')
+							_absolute = false;
+						while (it != end && *it != ']')
+						{
+							name.clear();
+							if (*it == '-')
+								name = "-";
+							else
+								while (it != end && *it != '.' && *it != ']') name += *it++;
+							if (!name.empty())
+							{
+								if (name == "-")
+								{
+									if (_dirs.empty() || _dirs.back() == "..")
+										_dirs.push_back("..");
+									else
+										_dirs.pop_back();
+								}
+								else _dirs.push_back(name);
+							}
+							if (it != end && *it != ']') ++it;
+						}
+						if (it == end) throw PathSyntaxException(path);
+						++it;
+						if (it != end && *it == '[')
+						{
+							if (!_absolute) throw PathSyntaxException(path);
+							++it;
+							if (it != end && *it == '.') throw PathSyntaxException(path);
+							int d = int(_dirs.size());
+							while (it != end && *it != ']')
+							{
+								name.clear();
+								if (*it == '-')
+									name = "-";
+								else
+									while (it != end && *it != '.' && *it != ']') name += *it++;
+								if (!name.empty())
+								{
+									if (name == "-")
+									{
+										if (_dirs.size() > d)
+											_dirs.pop_back();
+									}
+									else _dirs.push_back(name);
+								}
+								if (it != end && *it != ']') ++it;
+							}
+							if (it == end) throw PathSyntaxException(path);
+							++it;
+						}
+					}
+					_name.clear();
+				}
+				while (it != end && *it != ';') _name += *it++;
+			}
+			else _name = name;
+			if (it != end && *it == ';')
+			{
+				++it;
+				while (it != end) _version += *it++;
+			}
+		}
+		else _name = name;
+	}
+}
+
+
+void Path::parseGuess(const std::string& path)
+{
+	bool hasBackslash   = false;
+	bool hasSlash       = false;
+	bool hasOpenBracket = false;
+	bool hasClosBracket = false;
+	bool isWindows      = path.length() > 2 && path[1] == ':' && (path[2] == '/' || path[2] == '\\');
+	std::string::const_iterator end    = path.end();
+	std::string::const_iterator semiIt = end;
+	if (!isWindows)
+	{
+		for (std::string::const_iterator it = path.begin(); it != end; ++it)
+		{
+			switch (*it)
+			{
+			case '\\': hasBackslash = true; break;
+			case '/':  hasSlash = true; break;
+			case '[':  hasOpenBracket = true;
+			case ']':  hasClosBracket = hasOpenBracket;
+			case ';':  semiIt = it; break;
+			}
+		}
+	}
+	if (hasBackslash || isWindows)
+	{
+		parseWindows(path);
+	}
+	else if (hasSlash)
+	{
+		parseUnix(path);
+	}
+	else
+	{
+		bool isVMS = hasClosBracket;
+		if (!isVMS && semiIt != end)
+		{
+			isVMS = true;
+			++semiIt;
+			while (semiIt != end)
+			{
+				if (*semiIt < '0' || *semiIt > '9')
+				{
+					isVMS = false; break;
+				}
+				++semiIt;
+			}
+		}
+		if (isVMS)
+			parseVMS(path);
+		else
+			parseUnix(path);
+	}
+}
+
+
+std::string Path::buildUnix() const
+{
+	std::string result;
+	if (!_device.empty())
+	{
+		result.append("/");
+		result.append(_device);
+		result.append(":/");
+	}
+	else if (_absolute)
+	{
+		result.append("/");
+	}
+	for (StringVec::const_iterator it = _dirs.begin(); it != _dirs.end(); ++it)
+	{
+		result.append(*it);
+		result.append("/");
+	}
+	result.append(_name);
+	return result;
+}
+
+
+std::string Path::buildWindows() const
+{
+	std::string result;
+	if (!_node.empty())
+	{
+		result.append("\\\\");
+		result.append(_node);
+		result.append("\\");
+	}
+	else if (!_device.empty())
+	{
+		result.append(_device);
+		result.append(":\\");
+	}
+	else if (_absolute)
+	{
+		result.append("\\");
+	}
+	for (StringVec::const_iterator it = _dirs.begin(); it != _dirs.end(); ++it)
+	{
+		result.append(*it);
+		result.append("\\");
+	}
+	result.append(_name);
+	return result;
+}
+
+
+std::string Path::buildVMS() const
+{
+	std::string result;
+	if (!_node.empty())
+	{
+		result.append(_node);
+		result.append("::");
+	}
+	if (!_device.empty())
+	{
+		result.append(_device);
+		result.append(":");
+	}
+	if (!_dirs.empty())
+	{
+		result.append("[");
+		if (!_absolute && _dirs[0] != "..")
+			result.append(".");
+		for (StringVec::const_iterator it = _dirs.begin(); it != _dirs.end(); ++it)
+		{
+			if (it != _dirs.begin() && *it != "..")
+				result.append(".");
+			if (*it == "..")
+				result.append("-");
+			else
+				result.append(*it);
+		}
+		result.append("]");
+	}
+	result.append(_name);
+	if (!_version.empty())
+	{
+		result.append(";");
+		result.append(_version);
+	}
+	return result;
+}
+
+
+std::string Path::transcode(const std::string& path)
+{
+#if defined(_WIN32) && defined(POCO_WIN32_UTF8)
+	std::wstring uniPath;
+	UnicodeConverter::toUTF16(path, uniPath);
+	DWORD len = WideCharToMultiByte(CP_ACP, WC_NO_BEST_FIT_CHARS, uniPath.c_str(), static_cast<int>(uniPath.length()), NULL, 0, NULL, NULL);
+	if (len > 0)
+	{
+		Buffer<char> buffer(len);
+		DWORD rc = WideCharToMultiByte(CP_ACP, WC_NO_BEST_FIT_CHARS, uniPath.c_str(), static_cast<int>(uniPath.length()), buffer.begin(), static_cast<int>(buffer.size()), NULL, NULL);
+		if (rc)
+		{
+			return std::string(buffer.begin(), buffer.size());
+		}
+	}
+#endif
+	return path;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Path_UNIX.cpp b/base/poco/Foundation/src/Path_UNIX.cpp
new file mode 100644
index 00000000000..a6096f89d89
--- /dev/null
+++ b/base/poco/Foundation/src/Path_UNIX.cpp
@@ -0,0 +1,265 @@
+//
+// Path_UNIX.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  Path
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Path_UNIX.h"
+#include "Poco/Exception.h"
+#include "Poco/Environment_UNIX.h"
+#include "Poco/Ascii.h"
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#if !defined(POCO_VXWORKS)
+#include <pwd.h>
+#endif
+#include <climits>
+
+
+#ifndef PATH_MAX
+#define PATH_MAX 1024 // fallback
+#endif
+
+
+namespace Poco {
+
+
+std::string PathImpl::currentImpl()
+{
+	std::string path;
+	char cwd[PATH_MAX];
+	if (getcwd(cwd, sizeof(cwd)))
+		path = cwd;
+	else
+		throw SystemException("cannot get current directory");
+	std::string::size_type n = path.size();
+	if (n > 0 && path[n - 1] != '/') path.append("/");
+	return path;
+}
+
+
+std::string PathImpl::homeImpl()
+{
+#if defined(POCO_VXWORKS)
+	if (EnvironmentImpl::hasImpl("HOME"))
+		return EnvironmentImpl::getImpl("HOME");
+	else
+		return "/";
+#else
+	std::string path;
+#if defined(_POSIX_C_SOURCE) || defined(_BSD_SOURCE) || defined(_POSIX_C_SOURCE)
+	size_t buf_size = 1024;     // Same as glibc use for getpwuid
+	std::vector<char> buf(buf_size);
+	struct passwd res;
+	struct passwd* pwd = nullptr;
+
+	getpwuid_r(getuid(), &res, buf.data(), buf_size, &pwd);
+#else
+	struct passwd* pwd = getpwuid(getuid());
+#endif
+	if (pwd)
+		path = pwd->pw_dir;
+	else
+	{
+#if defined(_POSIX_C_SOURCE) || defined(_BSD_SOURCE) || defined(_POSIX_C_SOURCE)
+		getpwuid_r(getuid(), &res, buf.data(), buf_size, &pwd);
+#else
+		pwd = getpwuid(geteuid());
+#endif
+		if (pwd)
+			path = pwd->pw_dir;
+		else
+			path = EnvironmentImpl::getImpl("HOME");
+	}
+	std::string::size_type n = path.size();
+	if (n > 0 && path[n - 1] != '/') path.append("/");
+	return path;
+#endif
+}
+
+
+std::string PathImpl::configHomeImpl()
+{
+#if defined(POCO_VXWORKS)
+	return PathImpl::homeImpl();
+#else
+	std::string path = PathImpl::homeImpl();
+	std::string::size_type n = path.size();
+	if (n > 0 && path[n - 1] == '/') 
+#if POCO_OS == POCO_OS_MAC_OS_X
+	  path.append("Library/Preferences/");
+#else
+	  path.append(".config/");
+#endif
+
+	return path;
+#endif
+}
+
+
+std::string PathImpl::dataHomeImpl()
+{
+#if defined(POCO_VXWORKS)
+	return PathImpl::homeImpl();
+#else
+	std::string path = PathImpl::homeImpl();
+	std::string::size_type n = path.size();
+	if (n > 0 && path[n - 1] == '/') 
+#if POCO_OS == POCO_OS_MAC_OS_X
+	  path.append("Library/Application Support/");
+#else
+	  path.append(".local/share/");
+#endif
+
+	return path;
+#endif
+}
+
+
+std::string PathImpl::cacheHomeImpl()
+{
+#if defined(POCO_VXWORKS)
+	return PathImpl::tempImpl();
+#else
+	std::string path = PathImpl::homeImpl();
+	std::string::size_type n = path.size();
+	if (n > 0 && path[n - 1] == '/') 
+#if POCO_OS == POCO_OS_MAC_OS_X
+	  path.append("Library/Caches/");
+#else
+	  path.append(".cache/");
+#endif
+
+	return path;
+#endif
+}
+
+
+std::string PathImpl::tempHomeImpl()
+{
+#if defined(POCO_VXWORKS)
+	return PathImpl::tempImpl();
+#else
+	std::string path = PathImpl::homeImpl();
+	std::string::size_type n = path.size();
+	if (n > 0 && path[n - 1] == '/') 
+#if POCO_OS == POCO_OS_MAC_OS_X
+	  path.append("Library/Caches/");
+#else
+	  path.append(".local/tmp/");
+#endif
+
+	return path;
+#endif
+}
+
+
+std::string PathImpl::tempImpl()
+{
+	std::string path;
+	char* tmp = getenv("TMPDIR");
+	if (tmp)
+	{
+		path = tmp;
+		std::string::size_type n = path.size();
+		if (n > 0 && path[n - 1] != '/') path.append("/");
+	}
+	else
+	{
+		path = "/tmp/";
+	}
+	return path;
+}
+
+
+std::string PathImpl::configImpl()
+{
+	std::string path;
+	
+#if POCO_OS == POCO_OS_MAC_OS_X
+	  path = "/Library/Preferences/";
+#else
+	  path = "/etc/";
+#endif
+	return path;
+}
+
+
+std::string PathImpl::nullImpl()
+{
+#if defined(POCO_VXWORKS)
+	return "/null";
+#else
+	return "/dev/null";
+#endif
+}
+
+
+std::string PathImpl::expandImpl(const std::string& path)
+{
+	std::string result;
+	std::string::const_iterator it  = path.begin();
+	std::string::const_iterator end = path.end();
+	if (it != end && *it == '~')
+	{
+		++it;
+		if (it != end && *it == '/')
+		{
+			const char* homeEnv = getenv("HOME");
+			if (homeEnv)
+			{
+				result += homeEnv;
+				std::string::size_type resultSize = result.size();
+				if (resultSize > 0 && result[resultSize - 1] != '/')
+					result.append("/");
+			}
+			else
+			{
+				result += homeImpl();
+			}
+			++it;
+		}
+		else result += '~';
+	}
+	while (it != end)
+	{
+		if (*it == '$')
+		{
+			std::string var;
+			++it;
+			if (it != end && *it == '{')
+			{
+				++it;
+				while (it != end && *it != '}') var += *it++;
+				if (it != end) ++it;
+			}
+			else
+			{
+				while (it != end && (Ascii::isAlphaNumeric(*it) || *it == '_')) var += *it++;
+			}
+			char* val = getenv(var.c_str());
+			if (val) result += val;
+		}
+		else result += *it++;
+	}
+	return result;
+}
+
+
+void PathImpl::listRootsImpl(std::vector<std::string>& roots)
+{
+	roots.clear();
+	roots.push_back("/");
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Path_WIN32.cpp b/base/poco/Foundation/src/Path_WIN32.cpp
new file mode 100644
index 00000000000..9d8b357a319
--- /dev/null
+++ b/base/poco/Foundation/src/Path_WIN32.cpp
@@ -0,0 +1,203 @@
+//
+// Path_WIN32.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  Path
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Path_WIN32.h"
+#include "Poco/Environment_WIN32.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+std::string PathImpl::currentImpl()
+{
+	char buffer[MAX_PATH];
+	DWORD n = GetCurrentDirectoryA(sizeof(buffer), buffer);
+	if (n > 0 && n < sizeof(buffer))
+	{
+		std::string result(buffer, n);
+		if (result[n - 1] != '\\')
+			result.append("\\");
+		return result;
+	}
+	else throw SystemException("Cannot get current directory");
+}
+
+
+std::string PathImpl::systemImpl()
+{
+	char buffer[MAX_PATH];
+	DWORD n = GetSystemDirectoryA(buffer, sizeof(buffer));
+	if (n > 0 && n < sizeof(buffer))
+	{
+		std::string result(buffer, n);
+		if (result[n - 1] != '\\')
+			result.append("\\");
+		return result;
+	}
+	else throw SystemException("Cannot get system directory");
+}
+
+
+std::string PathImpl::homeImpl()
+{
+	std::string result;
+	if (EnvironmentImpl::hasImpl("USERPROFILE"))
+	{
+		result = EnvironmentImpl::getImpl("USERPROFILE");
+	}
+	else if (EnvironmentImpl::hasImpl("HOMEDRIVE") && EnvironmentImpl::hasImpl("HOMEPATH"))
+	{
+		result = EnvironmentImpl::getImpl("HOMEDRIVE");
+		result.append(EnvironmentImpl::getImpl("HOMEPATH"));
+	}
+	else
+	{
+		result = systemImpl();
+	}
+
+	std::string::size_type n = result.size();
+	if (n > 0 && result[n - 1] != '\\')
+		result.append("\\");
+	return result;
+}
+
+
+std::string PathImpl::configHomeImpl()
+{
+	std::string result;
+
+	// if APPDATA environment variable not exist, return home directory instead
+	try
+	{
+		result = EnvironmentImpl::getImpl("APPDATA");
+	}
+	catch (NotFoundException&)
+	{
+		result = homeImpl();
+	}
+
+	std::string::size_type n = result.size();
+	if (n > 0 && result[n - 1] != '\\')
+		result.append("\\");
+	return result;
+}
+
+
+std::string PathImpl::dataHomeImpl()
+{
+	std::string result;
+
+	// if LOCALAPPDATA environment variable not exist, return config home instead
+	try
+	{
+		result = EnvironmentImpl::getImpl("LOCALAPPDATA");
+	}
+	catch (NotFoundException&)
+	{
+		result = configHomeImpl();
+	}
+
+	std::string::size_type n = result.size();
+	if (n > 0 && result[n - 1] != '\\')
+		result.append("\\");
+	return result;
+}
+
+
+std::string PathImpl::cacheHomeImpl()
+{
+	return tempImpl();
+}
+
+
+std::string PathImpl::tempHomeImpl()
+{
+	return tempImpl();
+}
+
+
+std::string PathImpl::tempImpl()
+{
+	char buffer[MAX_PATH];
+	DWORD n = GetTempPathA(sizeof(buffer), buffer);
+	if (n > 0 && n < sizeof(buffer))
+	{
+		n = GetLongPathNameA(buffer, buffer, static_cast<DWORD>(sizeof buffer));
+		if (n <= 0) throw SystemException("Cannot get temporary directory long path name");
+		std::string result(buffer, n);
+		if (result[n - 1] != '\\')
+			result.append("\\");
+		return result;
+	}
+	else throw SystemException("Cannot get temporary directory");
+}
+
+
+std::string PathImpl::configImpl()
+{
+	std::string result;
+
+	// if PROGRAMDATA environment variable not exist, return system directory instead
+	try
+	{
+		result = EnvironmentImpl::getImpl("PROGRAMDATA");
+	}
+	catch (NotFoundException&)
+	{
+		result = systemImpl();
+	}
+
+	std::string::size_type n = result.size();
+	if (n > 0 && result[n - 1] != '\\')
+		result.append("\\");
+	return result;
+}
+
+
+std::string PathImpl::nullImpl()
+{
+	return "NUL:";
+}
+
+
+std::string PathImpl::expandImpl(const std::string& path)
+{
+	char buffer[MAX_PATH];
+	DWORD n = ExpandEnvironmentStringsA(path.c_str(), buffer, sizeof(buffer));
+	if (n > 0 && n < sizeof(buffer))
+		return std::string(buffer, n - 1);
+	else
+		return path;
+}
+
+
+void PathImpl::listRootsImpl(std::vector<std::string>& roots)
+{
+	roots.clear();
+	char buffer[128];
+	DWORD n = GetLogicalDriveStrings(sizeof(buffer) - 1, buffer);
+	char* it = buffer;
+	char* end = buffer + (n > sizeof(buffer) ? sizeof(buffer) : n);
+	while (it < end)
+	{
+		std::string dev;
+		while (it < end && *it) dev += *it++;
+		roots.push_back(dev);
+		++it;
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Path_WIN32U.cpp b/base/poco/Foundation/src/Path_WIN32U.cpp
new file mode 100644
index 00000000000..ac757d6eab8
--- /dev/null
+++ b/base/poco/Foundation/src/Path_WIN32U.cpp
@@ -0,0 +1,222 @@
+//
+// Path_WIN32U.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  Path
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Path_WIN32U.h"
+#include "Poco/Environment_WIN32.h"
+#include "Poco/UnicodeConverter.h"
+#include "Poco/Buffer.h"
+#include "Poco/Exception.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+std::string PathImpl::currentImpl()
+{
+	std::string result;
+	DWORD len = GetCurrentDirectoryW(0, NULL);
+	if (len > 0)
+	{
+		Buffer<wchar_t> buffer(len);
+		DWORD n = GetCurrentDirectoryW(len, buffer.begin());
+		if (n > 0 && n <= len)
+		{
+			UnicodeConverter::toUTF8(buffer.begin(), result);
+			if (result[result.size() - 1] != '\\')
+				result.append("\\");
+			return result;
+		}
+	}
+	throw SystemException("Cannot get current directory");
+}
+
+
+std::string PathImpl::systemImpl()
+{
+	Buffer<wchar_t> buffer(MAX_PATH_LEN);
+	DWORD n = GetSystemDirectoryW(buffer.begin(), static_cast<DWORD>(buffer.size()));
+	if (n > 0)
+	{
+		n = GetLongPathNameW(buffer.begin(), buffer.begin(), static_cast<DWORD>(buffer.size()));
+		if (n <= 0) throw SystemException("Cannot get system directory long path name");
+		std::string result;
+		UnicodeConverter::toUTF8(buffer.begin(), result);
+		if (result[result.size() - 1] != '\\') result.append("\\");
+		return result;
+	}
+	throw SystemException("Cannot get temporary directory path");
+}
+
+
+std::string PathImpl::homeImpl()
+{
+	std::string result;
+	if (EnvironmentImpl::hasImpl("USERPROFILE"))
+	{
+		result = EnvironmentImpl::getImpl("USERPROFILE");
+	}
+	else if (EnvironmentImpl::hasImpl("HOMEDRIVE") && EnvironmentImpl::hasImpl("HOMEPATH"))
+	{
+		result = EnvironmentImpl::getImpl("HOMEDRIVE");
+		result.append(EnvironmentImpl::getImpl("HOMEPATH"));
+	}
+	else
+	{
+		result = systemImpl();
+	}
+
+	std::string::size_type n = result.size();
+	if (n > 0 && result[n - 1] != '\\')
+		result.append("\\");
+	return result;
+}
+
+
+std::string PathImpl::configHomeImpl()
+{
+	std::string result;
+
+	// if APPDATA environment variable no exist, return home directory instead
+	try
+	{
+		result = EnvironmentImpl::getImpl("APPDATA");
+	}
+	catch (NotFoundException&)
+	{
+		result = homeImpl();
+	}
+
+	std::string::size_type n = result.size();
+	if (n > 0 && result[n - 1] != '\\')
+		result.append("\\");
+	return result;
+}
+
+
+std::string PathImpl::dataHomeImpl()
+{
+	std::string result;
+
+	// if LOCALAPPDATA environment variable no exist, return config home instead
+	try
+	{
+		result = EnvironmentImpl::getImpl("LOCALAPPDATA");
+	}
+	catch (NotFoundException&)
+	{
+		result = configHomeImpl();
+	}
+
+	std::string::size_type n = result.size();
+	if (n > 0 && result[n - 1] != '\\')
+		result.append("\\");
+	return result;
+}
+
+
+std::string PathImpl::cacheHomeImpl()
+{
+	return tempImpl();
+}
+
+
+std::string PathImpl::tempHomeImpl()
+{
+	return tempImpl();
+}
+
+
+std::string PathImpl::tempImpl()
+{
+	Buffer<wchar_t> buffer(MAX_PATH_LEN);
+	DWORD n = GetTempPathW(static_cast<DWORD>(buffer.size()), buffer.begin());
+	if (n > 0)
+	{
+		n = GetLongPathNameW(buffer.begin(), buffer.begin(), static_cast<DWORD>(buffer.size()));
+		if (n <= 0) throw SystemException("Cannot get temporary directory long path name");
+		std::string result;
+		UnicodeConverter::toUTF8(buffer.begin(), result);
+		if (result[result.size() - 1] != '\\')
+			result.append("\\");
+		return result;
+	}
+	throw SystemException("Cannot get temporary directory path");
+}
+
+
+std::string PathImpl::configImpl()
+{
+	std::string result;
+
+	// if PROGRAMDATA environment variable not exist, return system directory instead
+	try
+	{
+		result = EnvironmentImpl::getImpl("PROGRAMDATA");
+	}
+	catch (NotFoundException&)
+	{
+		result = systemImpl();
+	}
+
+	std::string::size_type n = result.size();
+	if (n > 0 && result[n - 1] != '\\')
+		result.append("\\");
+	return result;
+}
+
+
+std::string PathImpl::nullImpl()
+{
+	return "NUL:";
+}
+
+
+std::string PathImpl::expandImpl(const std::string& path)
+{
+	std::wstring upath;
+	UnicodeConverter::toUTF16(path, upath);
+	Buffer<wchar_t> buffer(MAX_PATH_LEN);
+	DWORD n = ExpandEnvironmentStringsW(upath.c_str(), buffer.begin(), static_cast<DWORD>(buffer.size()));
+	if (n > 0 && n < buffer.size() - 1)
+	{
+		buffer[n + 1] = 0;
+		std::string result;
+		UnicodeConverter::toUTF8(buffer.begin(), result);
+		return result;
+	}
+	else return path;
+}
+
+
+void PathImpl::listRootsImpl(std::vector<std::string>& roots)
+{
+	roots.clear();
+	wchar_t buffer[128];
+	DWORD n = GetLogicalDriveStringsW(sizeof(buffer)/sizeof(wchar_t) - 1, buffer);
+	wchar_t* it  = buffer;
+	wchar_t* end = buffer + (n > sizeof(buffer) ? sizeof(buffer) : n);
+	while (it < end)
+	{
+		std::wstring udev;
+		while (it < end && *it) udev += *it++;
+		std::string dev;
+		UnicodeConverter::toUTF8(udev, dev);
+		roots.push_back(dev);
+		++it;
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Path_WINCE.cpp b/base/poco/Foundation/src/Path_WINCE.cpp
new file mode 100644
index 00000000000..750f18dda6f
--- /dev/null
+++ b/base/poco/Foundation/src/Path_WINCE.cpp
@@ -0,0 +1,144 @@
+//
+// Path_WIN32U.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  Path
+//
+// Copyright (c) 2006-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Path_WINCE.h"
+#include "Poco/Environment_WINCE.h"
+#include "Poco/UnicodeConverter.h"
+#include "Poco/Buffer.h"
+#include "Poco/Environment.h"
+#include "Poco/Exception.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+std::string PathImpl::currentImpl()
+{
+	return("\\");
+}
+
+std::string PathImpl::homeImpl()
+{
+	return("\\");
+}
+
+std::string PathImpl::configHomeImpl()
+{
+  return homeImpl();
+}
+
+std::string PathImpl::dataHomeImpl()
+{
+  return homeImpl();
+}
+
+std::string PathImpl::cacheHomeImpl()
+{
+  return homeImpl();
+}
+
+
+std::string PathImpl::tempHomeImpl()
+{
+  return tempImpl();
+}
+
+
+std::string PathImpl::configImpl()
+{
+  return("\\");
+}
+
+std::string PathImpl::systemImpl()
+{
+	return("\\");
+}
+
+
+std::string PathImpl::nullImpl()
+{
+	return "NUL:";
+}
+
+
+std::string PathImpl::tempImpl()
+{
+	return "\\Temp\\";
+}
+
+
+std::string PathImpl::expandImpl(const std::string& path)
+{
+	std::string result;
+	std::string::const_iterator it  = path.begin();
+	std::string::const_iterator end = path.end();
+	while (it != end)
+	{
+		if (*it == '%')
+		{
+			++it;
+			if (it != end && *it == '%')
+			{
+				result += '%';
+			}
+			else
+			{
+				std::string var;
+				while (it != end && *it != '%') var += *it++;
+				if (it != end) ++it;
+				result += Environment::get(var, "");
+			}
+		}
+		else result += *it++;
+	}
+	return result;
+}
+
+
+void PathImpl::listRootsImpl(std::vector<std::string>& roots)
+{
+	roots.clear();
+	roots.push_back("\\");
+
+	WIN32_FIND_DATAW fd;
+	HANDLE hFind = FindFirstFileW(L"\\*.*", &fd);
+	if (hFind != INVALID_HANDLE_VALUE)
+	{
+		do
+		{
+			if ((fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
+				(fd.dwFileAttributes & FILE_ATTRIBUTE_TEMPORARY))
+			{
+				std::wstring name(fd.cFileName);
+				name += L"\\Vol:";
+				HANDLE h = CreateFileW(name.c_str(), GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+				if (h != INVALID_HANDLE_VALUE)
+				{
+					// its a device volume
+					CloseHandle(h);
+					std::string name;
+					UnicodeConverter::toUTF8(fd.cFileName, name);
+					std::string root = "\\" + name;
+					roots.push_back(root);
+				}
+			}
+		} 
+		while (FindNextFileW(hFind, &fd));
+		FindClose(hFind);
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/PatternFormatter.cpp b/base/poco/Foundation/src/PatternFormatter.cpp
new file mode 100644
index 00000000000..bf47077d94c
--- /dev/null
+++ b/base/poco/Foundation/src/PatternFormatter.cpp
@@ -0,0 +1,247 @@
+//
+// PatternFormatter.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  PatternFormatter
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/PatternFormatter.h"
+#include "Poco/Message.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/DateTimeFormat.h"
+#include "Poco/DateTimeFormatter.h"
+#include "Poco/DateTime.h"
+#include "Poco/Timestamp.h"
+#include "Poco/Timezone.h"
+#include "Poco/Environment.h"
+#include "Poco/NumberParser.h"
+
+
+namespace Poco {
+
+
+const std::string PatternFormatter::PROP_PATTERN = "pattern";
+const std::string PatternFormatter::PROP_TIMES   = "times";
+
+
+PatternFormatter::PatternFormatter():
+	_localTime(false)
+{
+}
+
+
+PatternFormatter::PatternFormatter(const std::string& format):
+	_localTime(false),
+	_pattern(format)
+{
+	parsePattern();
+}
+
+
+PatternFormatter::~PatternFormatter()
+{
+}
+
+
+void PatternFormatter::format(const Message& msg, std::string& text)
+{
+	Timestamp timestamp = msg.getTime();
+	bool localTime = _localTime;
+	if (localTime)
+	{
+		timestamp += Timezone::utcOffset()*Timestamp::resolution();
+		timestamp += Timezone::dst()*Timestamp::resolution();
+	}
+	DateTime dateTime = timestamp;
+	for (std::vector<PatternAction>::iterator ip = _patternActions.begin(); ip != _patternActions.end(); ++ip)
+	{
+		text.append(ip->prepend);
+		switch (ip->key)
+		{
+		case 's': text.append(msg.getSource()); break;
+		case 't': text.append(msg.getText()); break;
+		case 'l': NumberFormatter::append(text, (int) msg.getPriority()); break;
+		case 'p': text.append(getPriorityName((int) msg.getPriority())); break;
+		case 'q': text += getPriorityName((int) msg.getPriority()).at(0); break;
+		case 'P': NumberFormatter::append(text, msg.getPid()); break;
+		case 'T': text.append(msg.getThread()); break;
+		case 'I': NumberFormatter::append(text, msg.getTid()); break;
+		case 'N': text.append(Environment::nodeName()); break;
+		case 'U': text.append(msg.getSourceFile() ? msg.getSourceFile() : ""); break;
+		case 'u': NumberFormatter::append(text, msg.getSourceLine()); break;
+		case 'w': text.append(DateTimeFormat::WEEKDAY_NAMES[dateTime.dayOfWeek()], 0, 3); break;
+		case 'W': text.append(DateTimeFormat::WEEKDAY_NAMES[dateTime.dayOfWeek()]); break;
+		case 'b': text.append(DateTimeFormat::MONTH_NAMES[dateTime.month() - 1], 0, 3); break;
+		case 'B': text.append(DateTimeFormat::MONTH_NAMES[dateTime.month() - 1]); break;
+		case 'd': NumberFormatter::append0(text, dateTime.day(), 2); break;
+		case 'e': NumberFormatter::append(text, dateTime.day()); break;
+		case 'f': NumberFormatter::append(text, dateTime.day(), 2); break;
+		case 'm': NumberFormatter::append0(text, dateTime.month(), 2); break;
+		case 'n': NumberFormatter::append(text, dateTime.month()); break;
+		case 'o': NumberFormatter::append(text, dateTime.month(), 2); break;
+		case 'y': NumberFormatter::append0(text, dateTime.year() % 100, 2); break;
+		case 'Y': NumberFormatter::append0(text, dateTime.year(), 4); break;
+		case 'H': NumberFormatter::append0(text, dateTime.hour(), 2); break;
+		case 'h': NumberFormatter::append0(text, dateTime.hourAMPM(), 2); break;
+		case 'a': text.append(dateTime.isAM() ? "am" : "pm"); break;
+		case 'A': text.append(dateTime.isAM() ? "AM" : "PM"); break;
+		case 'M': NumberFormatter::append0(text, dateTime.minute(), 2); break;
+		case 'S': NumberFormatter::append0(text, dateTime.second(), 2); break;
+		case 'i': NumberFormatter::append0(text, dateTime.millisecond(), 3); break;
+		case 'c': NumberFormatter::append(text, dateTime.millisecond()/100); break;
+		case 'F': NumberFormatter::append0(text, dateTime.millisecond()*1000 + dateTime.microsecond(), 6); break;
+		case 'z': text.append(DateTimeFormatter::tzdISO(localTime ? Timezone::tzd() : DateTimeFormatter::UTC)); break;
+		case 'Z': text.append(DateTimeFormatter::tzdRFC(localTime ? Timezone::tzd() : DateTimeFormatter::UTC)); break;
+		case 'E': NumberFormatter::append(text, msg.getTime().epochTime()); break;
+		case 'v':
+			if (ip->length > msg.getSource().length())	//append spaces
+				text.append(msg.getSource()).append(ip->length - msg.getSource().length(), ' ');
+			else if (ip->length && ip->length < msg.getSource().length()) // crop
+				text.append(msg.getSource(), msg.getSource().length()-ip->length, ip->length);
+			else
+				text.append(msg.getSource());
+			break;
+		case 'x':
+			try
+			{
+				text.append(msg[ip->property]);
+			}
+			catch (...)
+			{
+			}
+			break;
+		case 'L':
+			if (!localTime)
+			{
+				localTime = true;
+				timestamp += Timezone::utcOffset()*Timestamp::resolution();
+				timestamp += Timezone::dst()*Timestamp::resolution();
+				dateTime = timestamp;
+			}
+			break;
+		}
+	}
+}
+
+
+void PatternFormatter::parsePattern()
+{
+	_patternActions.clear();
+	std::string::const_iterator it  = _pattern.begin();
+	std::string::const_iterator end = _pattern.end();
+	PatternAction endAct;
+	while (it != end)
+	{
+		if (*it == '%')
+		{
+			if (++it != end)
+			{
+				PatternAction act;
+				act.prepend = endAct.prepend;
+				endAct.prepend.clear();
+
+				if (*it == '[')
+				{
+					act.key = 'x';
+					++it;
+					std::string prop;
+					while (it != end && *it != ']') prop += *it++;
+					if (it == end) --it;
+					act.property = prop;
+				}
+				else
+				{
+					act.key = *it;
+					if ((it + 1) != end && *(it + 1) == '[')
+					{
+						it += 2;
+						std::string number;
+						while (it != end && *it != ']') number += *it++;
+						if (it == end) --it;
+						try
+						{
+							act.length = NumberParser::parse(number);
+						}
+						catch (...)
+						{
+						}
+					}
+				}
+				_patternActions.push_back(act);
+				++it;
+			}
+		}
+		else
+		{
+			endAct.prepend += *it++;
+		}
+	}
+	if (endAct.prepend.size())
+	{
+		_patternActions.push_back(endAct);
+	}
+}
+
+	
+void PatternFormatter::setProperty(const std::string& name, const std::string& value)
+{
+	if (name == PROP_PATTERN)
+	{
+		_pattern = value;
+		parsePattern();
+	}
+	else if (name == PROP_TIMES)
+	{
+		_localTime = (value == "local");
+	}
+	else 
+	{
+		Formatter::setProperty(name, value);
+	}
+}
+
+
+std::string PatternFormatter::getProperty(const std::string& name) const
+{
+	if (name == PROP_PATTERN)
+		return _pattern;
+	else if (name == PROP_TIMES)
+		return _localTime ? "local" : "UTC";
+	else
+		return Formatter::getProperty(name);
+}
+
+
+namespace
+{
+	static std::string priorities[] = 
+	{
+		"",
+		"Fatal",
+		"Critical",
+		"Error",
+		"Warning",
+		"Notice",
+		"Information",
+		"Debug",
+		"Trace",
+		"Test"
+	};
+}
+
+
+const std::string& PatternFormatter::getPriorityName(int prio)
+{
+	poco_assert (1 <= prio && prio <= 9);
+	return priorities[prio];
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Pipe.cpp b/base/poco/Foundation/src/Pipe.cpp
new file mode 100644
index 00000000000..8cd9eb244dd
--- /dev/null
+++ b/base/poco/Foundation/src/Pipe.cpp
@@ -0,0 +1,70 @@
+//
+// Pipe.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  Pipe
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Pipe.h"
+
+
+namespace Poco {
+
+
+Pipe::Pipe():
+	_pImpl(new PipeImpl)
+{
+}
+
+	
+Pipe::Pipe(const Pipe& pipe):
+	_pImpl(pipe._pImpl)
+{
+	_pImpl->duplicate();
+}
+
+
+Pipe::~Pipe()
+{
+	_pImpl->release();
+}
+
+
+Pipe& Pipe::operator = (const Pipe& pipe)
+{
+	if (this != &pipe)
+	{
+		_pImpl->release();
+		_pImpl = pipe._pImpl;
+		_pImpl->duplicate();
+	}
+	return *this;
+}
+
+
+void Pipe::close(CloseMode mode)
+{
+	switch (mode)
+	{
+	case CLOSE_READ:
+		_pImpl->closeRead();
+		break;
+	case CLOSE_WRITE:
+		_pImpl->closeWrite();
+		break;
+	default:
+		_pImpl->closeRead();
+		_pImpl->closeWrite();
+		break;
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/PipeImpl.cpp b/base/poco/Foundation/src/PipeImpl.cpp
new file mode 100644
index 00000000000..0f43b45ba1d
--- /dev/null
+++ b/base/poco/Foundation/src/PipeImpl.cpp
@@ -0,0 +1,28 @@
+//
+// PipeImpl.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  PipeImpl
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/PipeImpl.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#if defined(_WIN32_WCE)
+#include "PipeImpl_DUMMY.cpp"
+#else
+#include "PipeImpl_WIN32.cpp"
+#endif
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include "PipeImpl_POSIX.cpp"
+#else
+#include "PipeImpl_DUMMY.cpp"
+#endif
diff --git a/base/poco/Foundation/src/PipeImpl_DUMMY.cpp b/base/poco/Foundation/src/PipeImpl_DUMMY.cpp
new file mode 100644
index 00000000000..b0faf7b68ba
--- /dev/null
+++ b/base/poco/Foundation/src/PipeImpl_DUMMY.cpp
@@ -0,0 +1,65 @@
+//
+// PipeImpl_DUMMY.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  PipeImpl
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/PipeImpl_DUMMY.h"
+
+
+namespace Poco {
+
+
+PipeImpl::PipeImpl()
+{
+}
+
+
+PipeImpl::~PipeImpl()
+{
+}
+
+
+int PipeImpl::writeBytes(const void* buffer, int length)
+{
+	return 0;
+}
+
+
+int PipeImpl::readBytes(void* buffer, int length)
+{
+	return 0;
+}
+
+
+PipeImpl::Handle PipeImpl::readHandle() const
+{
+	return 0;
+}
+
+
+PipeImpl::Handle PipeImpl::writeHandle() const
+{
+	return 0;
+}
+
+
+void PipeImpl::closeRead()
+{
+}
+
+
+void PipeImpl::closeWrite()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/PipeImpl_POSIX.cpp b/base/poco/Foundation/src/PipeImpl_POSIX.cpp
new file mode 100644
index 00000000000..6a3edd32df5
--- /dev/null
+++ b/base/poco/Foundation/src/PipeImpl_POSIX.cpp
@@ -0,0 +1,111 @@
+//
+// PipeImpl_POSIX.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  PipeImpl
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/PipeImpl_POSIX.h"
+#include "Poco/Exception.h"
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+
+
+namespace Poco {
+
+
+PipeImpl::PipeImpl()
+{
+	int fds[2];
+	int rc = pipe(fds);
+	if (rc == 0)
+	{
+		_readfd  = fds[0];
+		_writefd = fds[1];
+	}
+	else throw CreateFileException("anonymous pipe");
+}
+
+
+PipeImpl::~PipeImpl()
+{
+	closeRead();
+	closeWrite();
+}
+
+
+int PipeImpl::writeBytes(const void* buffer, int length)
+{
+	poco_assert (_writefd != -1);
+
+	int n;
+	do
+	{
+		n = write(_writefd, buffer, length);
+	}
+	while (n < 0 && errno == EINTR);
+	if (n >= 0)
+		return n;
+	else
+		throw WriteFileException("anonymous pipe");
+}
+
+
+int PipeImpl::readBytes(void* buffer, int length)
+{
+	poco_assert (_readfd != -1);
+
+	int n;
+	do
+	{
+		n = read(_readfd, buffer, length);
+	}
+	while (n < 0 && errno == EINTR);
+	if (n >= 0)
+		return n;
+	else
+		throw ReadFileException("anonymous pipe");
+}
+
+
+PipeImpl::Handle PipeImpl::readHandle() const
+{
+	return _readfd;
+}
+
+
+PipeImpl::Handle PipeImpl::writeHandle() const
+{
+	return _writefd;
+}
+
+
+void PipeImpl::closeRead()
+{
+	if (_readfd != -1)
+	{
+		close(_readfd);
+		_readfd = -1;
+	}
+}
+
+
+void PipeImpl::closeWrite()
+{
+	if (_writefd != -1)
+	{
+		close(_writefd);
+		_writefd = -1;
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/PipeImpl_WIN32.cpp b/base/poco/Foundation/src/PipeImpl_WIN32.cpp
new file mode 100644
index 00000000000..87dbbbf3e51
--- /dev/null
+++ b/base/poco/Foundation/src/PipeImpl_WIN32.cpp
@@ -0,0 +1,97 @@
+//
+// PipeImpl_WIN32.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  PipeImpl
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/PipeImpl_WIN32.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+
+PipeImpl::PipeImpl()
+{
+	SECURITY_ATTRIBUTES attr;
+	attr.nLength              = sizeof(attr);
+	attr.lpSecurityDescriptor = NULL;
+	attr.bInheritHandle       = FALSE;
+	
+	if (!CreatePipe(&_readHandle, &_writeHandle, &attr, 0))
+		throw CreateFileException("anonymous pipe");
+}
+
+
+PipeImpl::~PipeImpl()
+{
+	closeRead();
+	closeWrite();
+}
+
+
+int PipeImpl::writeBytes(const void* buffer, int length)
+{
+	poco_assert (_writeHandle != INVALID_HANDLE_VALUE);
+
+	DWORD bytesWritten = 0;
+	if (!WriteFile(_writeHandle, buffer, length, &bytesWritten, NULL))
+		throw WriteFileException("anonymous pipe");
+	return bytesWritten;
+}
+
+
+int PipeImpl::readBytes(void* buffer, int length)
+{
+	poco_assert (_readHandle != INVALID_HANDLE_VALUE);
+
+	DWORD bytesRead = 0;
+	BOOL ok = ReadFile(_readHandle, buffer, length, &bytesRead, NULL);
+	if (ok || GetLastError() == ERROR_BROKEN_PIPE)
+		return bytesRead;
+	else
+		throw ReadFileException("anonymous pipe");
+}
+
+
+PipeImpl::Handle PipeImpl::readHandle() const
+{
+	return _readHandle;
+}
+
+
+PipeImpl::Handle PipeImpl::writeHandle() const
+{
+	return _writeHandle;
+}
+
+
+void PipeImpl::closeRead()
+{
+	if (_readHandle != INVALID_HANDLE_VALUE)
+	{
+		CloseHandle(_readHandle);
+		_readHandle = INVALID_HANDLE_VALUE;
+	}
+}
+
+
+void PipeImpl::closeWrite()
+{
+	if (_writeHandle != INVALID_HANDLE_VALUE)
+	{
+		CloseHandle(_writeHandle);
+		_writeHandle = INVALID_HANDLE_VALUE;
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/PipeStream.cpp b/base/poco/Foundation/src/PipeStream.cpp
new file mode 100644
index 00000000000..96fb323581d
--- /dev/null
+++ b/base/poco/Foundation/src/PipeStream.cpp
@@ -0,0 +1,127 @@
+//
+// PipeStream.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  PipeStream
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/PipeStream.h"
+
+
+namespace Poco {
+
+
+//
+// PipeStreamBuf
+//
+
+
+PipeStreamBuf::PipeStreamBuf(const Pipe& pipe, openmode mode): 
+	BufferedStreamBuf(STREAM_BUFFER_SIZE, mode),
+	_pipe(pipe)
+{
+}
+
+
+PipeStreamBuf::~PipeStreamBuf()
+{
+}
+
+
+int PipeStreamBuf::readFromDevice(char* buffer, std::streamsize length)
+{
+	return _pipe.readBytes(buffer, (int) length);
+}
+
+
+int PipeStreamBuf::writeToDevice(const char* buffer, std::streamsize length)
+{
+	return _pipe.writeBytes(buffer, (int) length);
+}
+
+
+void PipeStreamBuf::close()
+{
+	_pipe.close(Pipe::CLOSE_BOTH);
+}
+
+
+//
+// PipeIOS
+//
+
+
+PipeIOS::PipeIOS(const Pipe& pipe, openmode mode):
+	_buf(pipe, mode)
+{
+	poco_ios_init(&_buf);
+}
+
+
+PipeIOS::~PipeIOS()
+{
+	try
+	{
+		_buf.sync();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+PipeStreamBuf* PipeIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+void PipeIOS::close()
+{
+	_buf.sync();
+	_buf.close();
+}
+
+
+//
+// PipeOutputStream
+//
+
+
+PipeOutputStream::PipeOutputStream(const Pipe& pipe):
+	PipeIOS(pipe, std::ios::out),
+	std::ostream(&_buf)
+{
+}
+
+
+PipeOutputStream::~PipeOutputStream()
+{
+}
+
+
+//
+// PipeInputStream
+//
+
+
+PipeInputStream::PipeInputStream(const Pipe& pipe):
+	PipeIOS(pipe, std::ios::in),
+	std::istream(&_buf)
+{
+}
+
+
+PipeInputStream::~PipeInputStream()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/PriorityNotificationQueue.cpp b/base/poco/Foundation/src/PriorityNotificationQueue.cpp
new file mode 100644
index 00000000000..b0e5523ce21
--- /dev/null
+++ b/base/poco/Foundation/src/PriorityNotificationQueue.cpp
@@ -0,0 +1,195 @@
+//
+// PriorityNotificationQueue.cpp
+//
+// Library: Foundation
+// Package: Notifications
+// Module:  PriorityNotificationQueue
+//
+// Copyright (c) 2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/PriorityNotificationQueue.h"
+#include "Poco/NotificationCenter.h"
+#include "Poco/Notification.h"
+#include "Poco/SingletonHolder.h"
+
+
+namespace Poco {
+
+
+PriorityNotificationQueue::PriorityNotificationQueue()
+{
+}
+
+
+PriorityNotificationQueue::~PriorityNotificationQueue()
+{
+	try
+	{
+		clear();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void PriorityNotificationQueue::enqueueNotification(Notification::Ptr pNotification, int priority)
+{
+	poco_check_ptr (pNotification);
+	FastMutex::ScopedLock lock(_mutex);
+	if (_waitQueue.empty())
+	{
+		_nfQueue.insert(NfQueue::value_type(priority, pNotification));
+	}
+	else
+	{
+		poco_assert_dbg(_nfQueue.empty());
+		WaitInfo* pWI = _waitQueue.front();
+		_waitQueue.pop_front();
+		pWI->pNf = pNotification;
+		pWI->nfAvailable.set();
+	}	
+}
+
+
+Notification* PriorityNotificationQueue::dequeueNotification()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	return dequeueOne().duplicate();
+}
+
+
+Notification* PriorityNotificationQueue::waitDequeueNotification()
+{
+	Notification::Ptr pNf;
+	WaitInfo* pWI = 0;
+	{
+		FastMutex::ScopedLock lock(_mutex);
+		pNf = dequeueOne();
+		if (pNf) return pNf.duplicate();
+		pWI = new WaitInfo;
+		_waitQueue.push_back(pWI);
+	}
+	pWI->nfAvailable.wait();
+	pNf = pWI->pNf;
+	delete pWI;
+	return pNf.duplicate();
+}
+
+
+Notification* PriorityNotificationQueue::waitDequeueNotification(long milliseconds)
+{
+	Notification::Ptr pNf;
+	WaitInfo* pWI = 0;
+	{
+		FastMutex::ScopedLock lock(_mutex);
+		pNf = dequeueOne();
+		if (pNf) return pNf.duplicate();
+		pWI = new WaitInfo;
+		_waitQueue.push_back(pWI);
+	}
+	if (pWI->nfAvailable.tryWait(milliseconds))
+	{
+		pNf = pWI->pNf;
+	}
+	else
+	{
+		FastMutex::ScopedLock lock(_mutex);
+		pNf = pWI->pNf;
+		for (WaitQueue::iterator it = _waitQueue.begin(); it != _waitQueue.end(); ++it)
+		{
+			if (*it == pWI)
+			{
+				_waitQueue.erase(it);
+				break;
+			}
+		}
+	}
+	delete pWI;
+	return pNf.duplicate();
+}
+
+
+void PriorityNotificationQueue::dispatch(NotificationCenter& notificationCenter)
+{
+	FastMutex::ScopedLock lock(_mutex);
+	Notification::Ptr pNf = dequeueOne();
+	while (pNf)
+	{
+		notificationCenter.postNotification(pNf);
+		pNf = dequeueOne();
+	}
+}
+
+
+void PriorityNotificationQueue::wakeUpAll()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	for (WaitQueue::iterator it = _waitQueue.begin(); it != _waitQueue.end(); ++it)
+	{
+		(*it)->nfAvailable.set();
+	}
+	_waitQueue.clear();
+}
+
+
+bool PriorityNotificationQueue::empty() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+	return _nfQueue.empty();
+}
+
+	
+int PriorityNotificationQueue::size() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+	return static_cast<int>(_nfQueue.size());
+}
+
+
+void PriorityNotificationQueue::clear()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	_nfQueue.clear();	
+}
+
+
+bool PriorityNotificationQueue::hasIdleThreads() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+	return !_waitQueue.empty();
+}
+
+
+Notification::Ptr PriorityNotificationQueue::dequeueOne()
+{
+	Notification::Ptr pNf;
+	NfQueue::iterator it = _nfQueue.begin();
+	if (it != _nfQueue.end())
+	{
+		pNf = it->second;
+		_nfQueue.erase(it);
+	}
+	return pNf;
+}
+
+
+namespace
+{
+	static SingletonHolder<PriorityNotificationQueue> sh;
+}
+
+
+PriorityNotificationQueue& PriorityNotificationQueue::defaultQueue()
+{
+	return *sh.get();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Process.cpp b/base/poco/Foundation/src/Process.cpp
new file mode 100644
index 00000000000..6cc0b7e6b9d
--- /dev/null
+++ b/base/poco/Foundation/src/Process.cpp
@@ -0,0 +1,197 @@
+//
+// Process.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  Process
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Process.h"
+#include "Poco/Environment.h"
+
+
+namespace
+{
+	std::vector<char> getEnvironmentVariablesBuffer(const Poco::Process::Env& env)
+	{
+		std::vector<char> envbuf;
+		std::size_t pos = 0;
+
+		for (Poco::Process::Env::const_iterator it = env.begin(); it != env.end(); ++it)
+		{
+			std::size_t envlen = it->first.length() + it->second.length() + 1;
+
+			envbuf.resize(pos + envlen + 1);
+			std::copy(it->first.begin(), it->first.end(), &envbuf[pos]);
+			pos += it->first.length();
+			envbuf[pos] = '=';
+			++pos;
+			std::copy(it->second.begin(), it->second.end(), &envbuf[pos]);
+			pos += it->second.length();
+
+			envbuf[pos] = '\0';
+			++pos;
+		}
+
+		envbuf.resize(pos + 1);
+		envbuf[pos] = '\0';
+
+		return envbuf;
+	}
+}
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS) && defined(POCO_WIN32_UTF8)
+#if defined(_WIN32_WCE)
+#include "Process_WINCE.cpp"
+#else
+#include "Process_WIN32U.cpp"
+#endif
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "Process_WIN32.cpp"
+#elif defined(POCO_VXWORKS)
+#include "Process_VX.cpp"
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include "Process_UNIX.cpp"
+#endif
+
+
+namespace Poco {
+
+
+//
+// ProcessHandle
+//
+ProcessHandle::ProcessHandle(const ProcessHandle& handle):
+	_pImpl(handle._pImpl)
+{
+	_pImpl->duplicate();
+}
+
+
+ProcessHandle::~ProcessHandle()
+{
+	_pImpl->release();
+}
+
+
+ProcessHandle::ProcessHandle(ProcessHandleImpl* pImpl):
+	_pImpl(pImpl)
+{
+	poco_check_ptr (_pImpl);
+}
+
+
+ProcessHandle& ProcessHandle::operator = (const ProcessHandle& handle)
+{
+	if (&handle != this)
+	{
+		_pImpl->release();
+		_pImpl = handle._pImpl;
+		_pImpl->duplicate();
+	}
+	return *this;
+}
+
+
+ProcessHandle::PID ProcessHandle::id() const
+{
+	return _pImpl->id();
+}
+
+
+int ProcessHandle::wait() const
+{
+	return _pImpl->wait();
+}
+
+
+//
+// Process
+//
+ProcessHandle Process::launch(const std::string& command, const Args& args)
+{
+	std::string initialDirectory;
+	Env env;
+	return ProcessHandle(launchImpl(command, args, initialDirectory, 0, 0, 0, env));
+}
+
+
+ProcessHandle Process::launch(const std::string& command, const Args& args, const std::string& initialDirectory)
+{
+	Env env;
+	return ProcessHandle(launchImpl(command, args, initialDirectory, 0, 0, 0, env));
+}
+
+
+ProcessHandle Process::launch(const std::string& command, const Args& args, Pipe* inPipe, Pipe* outPipe, Pipe* errPipe)
+{
+	poco_assert (inPipe == 0 || (inPipe != outPipe && inPipe != errPipe));
+	std::string initialDirectory;
+	Env env;
+	return ProcessHandle(launchImpl(command, args, initialDirectory, inPipe, outPipe, errPipe, env));
+}
+
+
+ProcessHandle Process::launch(const std::string& command, const Args& args, const std::string& initialDirectory, Pipe* inPipe, Pipe* outPipe, Pipe* errPipe)
+{
+	poco_assert (inPipe == 0 || (inPipe != outPipe && inPipe != errPipe));
+	Env env;
+	return ProcessHandle(launchImpl(command, args, initialDirectory, inPipe, outPipe, errPipe, env));
+}
+
+
+ProcessHandle Process::launch(const std::string& command, const Args& args, Pipe* inPipe, Pipe* outPipe, Pipe* errPipe, const Env& env)
+{
+	poco_assert (inPipe == 0 || (inPipe != outPipe && inPipe != errPipe));
+	std::string initialDirectory;
+	return ProcessHandle(launchImpl(command, args, initialDirectory, inPipe, outPipe, errPipe, env));
+}
+
+
+ProcessHandle Process::launch(const std::string& command, const Args& args, const std::string& initialDirectory, Pipe* inPipe, Pipe* outPipe, Pipe* errPipe, const Env& env)
+{
+	poco_assert (inPipe == 0 || (inPipe != outPipe && inPipe != errPipe));
+	return ProcessHandle(launchImpl(command, args, initialDirectory, inPipe, outPipe, errPipe, env));
+}
+
+
+int Process::wait(const ProcessHandle& handle)
+{
+	return handle.wait();
+}
+
+
+void Process::kill(ProcessHandle& handle)
+{
+	killImpl(*handle._pImpl);
+}
+
+
+void Process::kill(PID pid)
+{
+	killImpl(pid);
+}
+
+bool Process::isRunning(const ProcessHandle& handle)
+{
+	return isRunningImpl(*handle._pImpl);
+}
+bool Process::isRunning(PID pid)
+{
+	return isRunningImpl(pid);
+}
+
+void Process::requestTermination(PID pid)
+{
+	requestTerminationImpl(pid);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Process_UNIX.cpp b/base/poco/Foundation/src/Process_UNIX.cpp
new file mode 100644
index 00000000000..4671278e1d8
--- /dev/null
+++ b/base/poco/Foundation/src/Process_UNIX.cpp
@@ -0,0 +1,280 @@
+//
+// Process_UNIX.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  Process
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Process_UNIX.h"
+#include "Poco/Exception.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/Pipe.h"
+#include <errno.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+
+
+#if defined(__QNX__)
+#include <process.h>
+#include <spawn.h>
+#include <cstring>
+#endif
+
+
+namespace Poco {
+
+
+//
+// ProcessHandleImpl
+//
+ProcessHandleImpl::ProcessHandleImpl(pid_t pid):
+	_pid(pid)
+{
+}
+
+
+ProcessHandleImpl::~ProcessHandleImpl()
+{
+}
+
+
+pid_t ProcessHandleImpl::id() const
+{
+	return _pid;
+}
+
+
+int ProcessHandleImpl::wait() const
+{
+	int status;
+	int rc;
+	do
+	{
+		rc = waitpid(_pid, &status, 0);
+	}
+	while (rc < 0 && errno == EINTR);
+	if (rc != _pid)
+		throw SystemException("Cannot wait for process", NumberFormatter::format(_pid));
+	return WEXITSTATUS(status);
+}
+
+
+//
+// ProcessImpl
+//
+ProcessImpl::PIDImpl ProcessImpl::idImpl()
+{
+	return getpid();
+}
+
+
+void ProcessImpl::timesImpl(long& userTime, long& kernelTime)
+{
+	struct rusage usage;
+	getrusage(RUSAGE_SELF, &usage);
+	userTime   = usage.ru_utime.tv_sec;
+	kernelTime = usage.ru_stime.tv_sec;
+}
+
+
+ProcessHandleImpl* ProcessImpl::launchImpl(const std::string& command, const ArgsImpl& args, const std::string& initialDirectory, Pipe* inPipe, Pipe* outPipe, Pipe* errPipe, const EnvImpl& env)
+{
+#if defined(__QNX__)
+	if (initialDirectory.empty())
+	{
+		/// use QNX's spawn system call which is more efficient than fork/exec.
+		char** argv = new char*[args.size() + 2];
+		int i = 0;
+		argv[i++] = const_cast<char*>(command.c_str());
+		for (ArgsImpl::const_iterator it = args.begin(); it != args.end(); ++it) 
+			argv[i++] = const_cast<char*>(it->c_str());
+		argv[i] = NULL;
+		struct inheritance inherit;
+		std::memset(&inherit, 0, sizeof(inherit));
+		inherit.flags = SPAWN_ALIGN_DEFAULT | SPAWN_CHECK_SCRIPT | SPAWN_SEARCH_PATH;
+		int fdmap[3];
+		fdmap[0] = inPipe  ? inPipe->readHandle()   : 0;
+		fdmap[1] = outPipe ? outPipe->writeHandle() : 1;
+		fdmap[2] = errPipe ? errPipe->writeHandle() : 2;
+	
+		char** envPtr = 0;
+		std::vector<char> envChars;
+		std::vector<char*> envPtrs;
+		if (!env.empty())
+		{
+			envChars = getEnvironmentVariablesBuffer(env);
+			envPtrs.reserve(env.size() + 1);
+			char* p = &envChars[0];
+			while (*p)
+			{
+				envPtrs.push_back(p);
+				while (*p) ++p;
+				++p;
+			}
+			envPtrs.push_back(0);
+			envPtr = &envPtrs[0];
+		}
+	
+		int pid = spawn(command.c_str(), 3, fdmap, &inherit, argv, envPtr);
+		delete [] argv;
+		if (pid == -1) 
+			throw SystemException("cannot spawn", command);
+
+		if (inPipe)  inPipe->close(Pipe::CLOSE_READ);
+		if (outPipe) outPipe->close(Pipe::CLOSE_WRITE);
+		if (errPipe) errPipe->close(Pipe::CLOSE_WRITE);
+		return new ProcessHandleImpl(pid);
+	}
+	else
+	{
+		return launchByForkExecImpl(command, args, initialDirectory, inPipe, outPipe, errPipe, env);
+	}
+#else
+	return launchByForkExecImpl(command, args, initialDirectory, inPipe, outPipe, errPipe, env);
+#endif
+}
+
+
+ProcessHandleImpl* ProcessImpl::launchByForkExecImpl(const std::string& command, const ArgsImpl& args, const std::string& initialDirectory, Pipe* inPipe, Pipe* outPipe, Pipe* errPipe, const EnvImpl& env)
+{
+#if !defined(POCO_NO_FORK_EXEC)
+	// We must not allocated memory after fork(),
+	// therefore allocate all required buffers first.
+	std::vector<char> envChars = getEnvironmentVariablesBuffer(env);
+	std::vector<char*> argv(args.size() + 2);
+	int i = 0;
+	argv[i++] = const_cast<char*>(command.c_str());
+	for (ArgsImpl::const_iterator it = args.begin(); it != args.end(); ++it) 
+	{
+		argv[i++] = const_cast<char*>(it->c_str());
+	}
+	argv[i] = NULL;
+	
+	const char* pInitialDirectory = initialDirectory.empty() ? 0 : initialDirectory.c_str();
+
+	int pid = fork();
+	if (pid < 0)
+	{
+		throw SystemException("Cannot fork process for", command);		
+	}
+	else if (pid == 0)
+	{
+		if (pInitialDirectory)
+		{
+			if (chdir(pInitialDirectory) != 0)
+			{
+				_exit(72);
+			}
+		}
+
+		// set environment variables
+		char* p = &envChars[0];
+		while (*p)
+		{
+			putenv(p);
+			while (*p) ++p;
+			++p;
+		}
+
+		// setup redirection
+		if (inPipe)
+		{
+			dup2(inPipe->readHandle(), STDIN_FILENO);
+			inPipe->close(Pipe::CLOSE_BOTH);
+		}
+		// outPipe and errPipe may be the same, so we dup first and close later
+		if (outPipe) dup2(outPipe->writeHandle(), STDOUT_FILENO);
+		if (errPipe) dup2(errPipe->writeHandle(), STDERR_FILENO);
+		if (outPipe) outPipe->close(Pipe::CLOSE_BOTH);
+		if (errPipe) errPipe->close(Pipe::CLOSE_BOTH);
+		// close all open file descriptors other than stdin, stdout, stderr
+		for (int i = 3; i < sysconf(_SC_OPEN_MAX); ++i)
+		{
+			close(i);
+		}
+
+		execvp(argv[0], &argv[0]);
+		_exit(72);
+	}
+
+	if (inPipe)  inPipe->close(Pipe::CLOSE_READ);
+	if (outPipe) outPipe->close(Pipe::CLOSE_WRITE);
+	if (errPipe) errPipe->close(Pipe::CLOSE_WRITE);
+	return new ProcessHandleImpl(pid);
+#else
+	throw Poco::NotImplementedException("platform does not allow fork/exec");
+#endif
+}
+
+
+void ProcessImpl::killImpl(ProcessHandleImpl& handle)
+{
+	killImpl(handle.id());
+}
+
+
+void ProcessImpl::killImpl(PIDImpl pid)
+{
+	if (kill(pid, SIGKILL) != 0)
+	{
+		switch (errno)
+		{
+		case ESRCH:
+			throw NotFoundException("cannot kill process");
+		case EPERM:
+			throw NoPermissionException("cannot kill process");
+		default:
+			throw SystemException("cannot kill process");
+		}
+	}
+}
+
+
+bool ProcessImpl::isRunningImpl(const ProcessHandleImpl& handle)
+{
+	return isRunningImpl(handle.id());
+}
+
+
+bool ProcessImpl::isRunningImpl(PIDImpl pid)  
+{
+	if (kill(pid, 0) == 0) 
+	{
+		return true;
+	} 
+	else 
+	{
+		return false;
+	}
+}
+
+				
+void ProcessImpl::requestTerminationImpl(PIDImpl pid)
+{
+	if (kill(pid, SIGINT) != 0)
+	{
+		switch (errno)
+		{
+		case ESRCH:
+			throw NotFoundException("cannot terminate process");
+		case EPERM:
+			throw NoPermissionException("cannot terminate process");
+		default:
+			throw SystemException("cannot terminate process");
+		}
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Process_VX.cpp b/base/poco/Foundation/src/Process_VX.cpp
new file mode 100644
index 00000000000..699feb9be71
--- /dev/null
+++ b/base/poco/Foundation/src/Process_VX.cpp
@@ -0,0 +1,100 @@
+//
+// Process_VX.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  Process
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Process_VX.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+
+//
+// ProcessHandleImpl
+//
+ProcessHandleImpl::ProcessHandleImpl(int pid):
+	_pid(pid)
+{
+}
+
+
+ProcessHandleImpl::~ProcessHandleImpl()
+{
+}
+
+
+int ProcessHandleImpl::id() const
+{
+	return _pid;
+}
+
+
+int ProcessHandleImpl::wait() const
+{
+	throw Poco::NotImplementedException("Process::wait()");
+}
+
+
+//
+// ProcessImpl
+//
+ProcessImpl::PIDImpl ProcessImpl::idImpl()
+{
+	return 0;
+}
+
+
+void ProcessImpl::timesImpl(long& userTime, long& kernelTime)
+{
+	userTime   = 0;
+	kernelTime = 0;
+}
+
+
+ProcessHandleImpl* ProcessImpl::launchImpl(const std::string& command, const ArgsImpl& args, const std::string& initialDirectory,Pipe* inPipe, Pipe* outPipe, Pipe* errPipe, const EnvImpl& env)
+{
+	throw Poco::NotImplementedException("Process::launch()");
+}
+
+
+void ProcessImpl::killImpl(ProcessHandleImpl& handle)
+{
+	throw Poco::NotImplementedException("Process::kill()");
+}
+
+
+void ProcessImpl::killImpl(PIDImpl pid)
+{
+	throw Poco::NotImplementedException("Process::kill()");
+}
+
+
+bool ProcessImpl::isRunningImpl(const ProcessHandleImpl& handle) 
+{
+	throw Poco::NotImplementedException("Process::is_running()");
+}
+
+
+bool ProcessImpl::isRunningImpl(PIDImpl pid) 
+{
+	throw Poco::NotImplementedException("Process::is_running()");
+}
+
+
+void ProcessImpl::requestTerminationImpl(PIDImpl pid)
+{
+	throw Poco::NotImplementedException("Process::requestTermination()");
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Process_WIN32.cpp b/base/poco/Foundation/src/Process_WIN32.cpp
new file mode 100644
index 00000000000..d698a9726e8
--- /dev/null
+++ b/base/poco/Foundation/src/Process_WIN32.cpp
@@ -0,0 +1,349 @@
+//
+// Process_WIN32.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  Process
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Process_WIN32.h"
+#include "Poco/Exception.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/NamedEvent.h"
+#include "Poco/Pipe.h"
+
+
+namespace Poco {
+
+
+//
+// ProcessHandleImpl
+//
+ProcessHandleImpl::ProcessHandleImpl(HANDLE hProcess, UInt32 pid) :
+	_hProcess(hProcess),
+	_pid(pid)
+{
+}
+
+
+ProcessHandleImpl::~ProcessHandleImpl()
+{
+	closeHandle();
+}
+
+
+void ProcessHandleImpl::closeHandle()
+{
+	if (_hProcess)
+	{
+		CloseHandle(_hProcess);
+		_hProcess = NULL;
+	}
+}
+
+
+UInt32 ProcessHandleImpl::id() const
+{
+	return _pid;
+}
+
+
+HANDLE ProcessHandleImpl::process() const
+{
+	return _hProcess;
+}
+
+
+int ProcessHandleImpl::wait() const
+{
+	DWORD rc = WaitForSingleObject(_hProcess, INFINITE);
+	if (rc != WAIT_OBJECT_0)
+		throw SystemException("Wait failed for process", NumberFormatter::format(_pid));
+
+	DWORD exitCode;
+	if (GetExitCodeProcess(_hProcess, &exitCode) == 0)
+		throw SystemException("Cannot get exit code for process", NumberFormatter::format(_pid));
+
+	return exitCode;
+}
+
+
+//
+// ProcessImpl
+//
+ProcessImpl::PIDImpl ProcessImpl::idImpl()
+{
+	return GetCurrentProcessId();
+}
+
+
+void ProcessImpl::timesImpl(long& userTime, long& kernelTime)
+{
+	FILETIME ftCreation;
+	FILETIME ftExit;
+	FILETIME ftKernel;
+	FILETIME ftUser;
+
+	if (GetProcessTimes(GetCurrentProcess(), &ftCreation, &ftExit, &ftKernel, &ftUser) != 0)
+	{
+		ULARGE_INTEGER time;
+		time.LowPart = ftKernel.dwLowDateTime;
+		time.HighPart = ftKernel.dwHighDateTime;
+		kernelTime = long(time.QuadPart / 10000000L);
+		time.LowPart = ftUser.dwLowDateTime;
+		time.HighPart = ftUser.dwHighDateTime;
+		userTime = long(time.QuadPart / 10000000L);
+	} 
+	else
+	{
+		userTime = kernelTime = -1;
+	}
+}
+
+
+static bool argNeedsEscaping(const std::string& arg)
+{
+	bool containsQuotableChar = std::string::npos != arg.find_first_of(" \t\n\v\"");
+	// Assume args that start and end with quotes are already quoted and do not require further quoting.
+	// There is probably code out there written before launch() escaped the arguments that does its own
+	// escaping of arguments. This ensures we do not interfere with those arguments.
+	bool isAlreadyQuoted = arg.size() > 1 && '\"' == arg[0] && '\"' == arg[arg.size() - 1];
+	return containsQuotableChar && !isAlreadyQuoted;
+}
+
+
+// Based on code from https://blogs.msdn.microsoft.com/twistylittlepassagesallalike/2011/04/23/everyone-quotes-command-line-arguments-the-wrong-way/
+static std::string escapeArg(const std::string& arg)
+{
+	if (argNeedsEscaping(arg))
+	{
+		std::string quotedArg("\"");
+		for (std::string::const_iterator it = arg.begin(); ; ++it)
+		{
+			unsigned backslashCount = 0;
+			while (it != arg.end() && '\\' == *it)
+			{
+				++it;
+				++backslashCount;
+			}
+
+			if (it == arg.end())
+			{
+				quotedArg.append(2 * backslashCount, '\\');
+				break;
+			} 
+			else if ('"' == *it)
+			{
+				quotedArg.append(2 * backslashCount + 1, '\\');
+				quotedArg.push_back('"');
+			} 
+			else
+			{
+				quotedArg.append(backslashCount, '\\');
+				quotedArg.push_back(*it);
+			}
+		}
+		quotedArg.push_back('"');
+		return quotedArg;
+	} 
+	else
+	{
+		return arg;
+	}
+}
+
+
+ProcessHandleImpl* ProcessImpl::launchImpl(const std::string& command, const ArgsImpl& args, const std::string& initialDirectory, Pipe* inPipe, Pipe* outPipe, Pipe* errPipe, const EnvImpl& env)
+{
+	std::string commandLine = command;
+	for (ArgsImpl::const_iterator it = args.begin(); it != args.end(); ++it)
+	{
+		commandLine.append(" ");
+		commandLine.append(escapeArg(*it));
+	}
+
+	STARTUPINFOA startupInfo;
+	GetStartupInfoA(&startupInfo); // take defaults from current process
+	startupInfo.cb = sizeof(STARTUPINFOA);
+	startupInfo.lpReserved = NULL;
+	startupInfo.lpDesktop = NULL;
+	startupInfo.lpTitle = NULL;
+	startupInfo.dwFlags = STARTF_FORCEOFFFEEDBACK;
+	startupInfo.cbReserved2 = 0;
+	startupInfo.lpReserved2 = NULL;
+
+	HANDLE hProc = GetCurrentProcess();
+	bool mustInheritHandles = false;
+	if (inPipe)
+	{
+		DuplicateHandle(hProc, inPipe->readHandle(), hProc, &startupInfo.hStdInput, 0, TRUE, DUPLICATE_SAME_ACCESS);
+		mustInheritHandles = true;
+		inPipe->close(Pipe::CLOSE_READ);
+	} 
+	else if (GetStdHandle(STD_INPUT_HANDLE))
+	{
+		DuplicateHandle(hProc, GetStdHandle(STD_INPUT_HANDLE), hProc, &startupInfo.hStdInput, 0, TRUE, DUPLICATE_SAME_ACCESS);
+		mustInheritHandles = true;
+	} 
+	else
+	{
+		startupInfo.hStdInput = 0;
+	}
+	// outPipe may be the same as errPipe, so we duplicate first and close later.
+	if (outPipe)
+	{
+		DuplicateHandle(hProc, outPipe->writeHandle(), hProc, &startupInfo.hStdOutput, 0, TRUE, DUPLICATE_SAME_ACCESS);
+		mustInheritHandles = true;
+	} 
+	else if (GetStdHandle(STD_OUTPUT_HANDLE))
+	{
+		DuplicateHandle(hProc, GetStdHandle(STD_OUTPUT_HANDLE), hProc, &startupInfo.hStdOutput, 0, TRUE, DUPLICATE_SAME_ACCESS);
+		mustInheritHandles = true;
+	} 
+	else
+	{
+		startupInfo.hStdOutput = 0;
+	}
+	if (errPipe)
+	{
+		DuplicateHandle(hProc, errPipe->writeHandle(), hProc, &startupInfo.hStdError, 0, TRUE, DUPLICATE_SAME_ACCESS);
+		mustInheritHandles = true;
+	} 
+	else if (GetStdHandle(STD_ERROR_HANDLE))
+	{
+		DuplicateHandle(hProc, GetStdHandle(STD_ERROR_HANDLE), hProc, &startupInfo.hStdError, 0, TRUE, DUPLICATE_SAME_ACCESS);
+		mustInheritHandles = true;
+	} 
+	else
+	{
+		startupInfo.hStdError = 0;
+	}
+	if (outPipe) outPipe->close(Pipe::CLOSE_WRITE);
+	if (errPipe) errPipe->close(Pipe::CLOSE_WRITE);
+
+	if (mustInheritHandles)
+	{
+		startupInfo.dwFlags |= STARTF_USESTDHANDLES;
+	}
+
+	const char* workingDirectory = initialDirectory.empty() ? 0 : initialDirectory.c_str();
+
+	const char* pEnv = 0;
+	std::vector<char> envChars;
+	if (!env.empty())
+	{
+		envChars = getEnvironmentVariablesBuffer(env);
+		pEnv = &envChars[0];
+	}
+
+	PROCESS_INFORMATION processInfo;
+	DWORD creationFlags = GetConsoleWindow() ? 0 : CREATE_NO_WINDOW;
+	BOOL rc = CreateProcessA(
+		NULL,
+		const_cast<char*>(commandLine.c_str()),
+		NULL, // processAttributes
+		NULL, // threadAttributes
+		mustInheritHandles,
+		creationFlags,
+		(LPVOID)pEnv,
+		workingDirectory,
+		&startupInfo,
+		&processInfo
+	);
+	if (startupInfo.hStdInput) CloseHandle(startupInfo.hStdInput);
+	if (startupInfo.hStdOutput) CloseHandle(startupInfo.hStdOutput);
+	if (startupInfo.hStdError) CloseHandle(startupInfo.hStdError);
+	if (rc)
+	{
+		CloseHandle(processInfo.hThread);
+		return new ProcessHandleImpl(processInfo.hProcess, processInfo.dwProcessId);
+	} 
+	else throw SystemException("Cannot launch process", command);
+}
+
+
+void ProcessImpl::killImpl(ProcessHandleImpl& handle)
+{
+	if (handle.process())
+	{
+		if (TerminateProcess(handle.process(), 0) == 0)
+		{
+			handle.closeHandle();
+			throw SystemException("cannot kill process");
+		}
+		handle.closeHandle();
+	}
+}
+
+void ProcessImpl::killImpl(PIDImpl pid)
+{
+	HANDLE hProc = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
+	if (hProc)
+	{
+		if (TerminateProcess(hProc, 0) == 0)
+		{
+			CloseHandle(hProc);
+			throw SystemException("cannot kill process");
+		}
+		CloseHandle(hProc);
+	} 
+	else
+	{
+		switch (GetLastError())
+		{
+		case ERROR_ACCESS_DENIED:
+			throw NoPermissionException("cannot kill process");
+		case ERROR_NOT_FOUND: 
+			throw NotFoundException("cannot kill process");
+		case ERROR_INVALID_PARAMETER:
+			throw NotFoundException("cannot kill process");
+		default:
+			throw SystemException("cannot kill process");
+		}
+	}
+}
+
+
+bool ProcessImpl::isRunningImpl(const ProcessHandleImpl& handle)
+{
+	bool result = true;
+	DWORD exitCode;
+	BOOL rc = GetExitCodeProcess(handle.process(), &exitCode);
+	if (!rc || exitCode != STILL_ACTIVE) result = false;
+	return result;
+}
+
+
+bool ProcessImpl::isRunningImpl(PIDImpl pid)
+{
+	HANDLE hProc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);
+	bool result = true;
+	DWORD exitCode;
+	BOOL rc = GetExitCodeProcess(hProc, &exitCode);
+	if (!rc || exitCode != STILL_ACTIVE) result = false;
+	return result;
+}
+
+
+void ProcessImpl::requestTerminationImpl(PIDImpl pid)
+{
+	NamedEvent ev(terminationEventName(pid));
+	ev.set();
+}
+
+
+std::string ProcessImpl::terminationEventName(PIDImpl pid)
+{
+	std::string evName("POCOTRM");
+	NumberFormatter::appendHex(evName, pid, 8);
+	return evName;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Process_WIN32U.cpp b/base/poco/Foundation/src/Process_WIN32U.cpp
new file mode 100644
index 00000000000..2a81a8dd468
--- /dev/null
+++ b/base/poco/Foundation/src/Process_WIN32U.cpp
@@ -0,0 +1,371 @@
+//
+// Process_WIN32U.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  Process
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Process_WIN32U.h"
+#include "Poco/Exception.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/NamedEvent.h"
+#include "Poco/UnicodeConverter.h"
+#include "Poco/Pipe.h"
+#include "Poco/File.h"
+#include "Poco/Path.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+
+
+//
+// ProcessHandleImpl
+//
+ProcessHandleImpl::ProcessHandleImpl(HANDLE hProcess, UInt32 pid) :
+	_hProcess(hProcess),
+	_pid(pid)
+{
+}
+
+
+ProcessHandleImpl::~ProcessHandleImpl()
+{
+	closeHandle();
+}
+
+
+void ProcessHandleImpl::closeHandle()
+{
+	if (_hProcess)
+	{
+		CloseHandle(_hProcess);
+		_hProcess = NULL;
+	}
+}
+
+
+UInt32 ProcessHandleImpl::id() const
+{
+	return _pid;
+}
+
+
+HANDLE ProcessHandleImpl::process() const
+{
+	return _hProcess;
+}
+
+
+int ProcessHandleImpl::wait() const
+{
+	DWORD rc = WaitForSingleObject(_hProcess, INFINITE);
+	if (rc != WAIT_OBJECT_0)
+		throw SystemException("Wait failed for process", NumberFormatter::format(_pid));
+
+	DWORD exitCode;
+	if (GetExitCodeProcess(_hProcess, &exitCode) == 0)
+		throw SystemException("Cannot get exit code for process", NumberFormatter::format(_pid));
+
+	return exitCode;
+}
+
+
+//
+// ProcessImpl
+//
+ProcessImpl::PIDImpl ProcessImpl::idImpl()
+{
+	return GetCurrentProcessId();
+}
+
+
+void ProcessImpl::timesImpl(long& userTime, long& kernelTime)
+{
+	FILETIME ftCreation;
+	FILETIME ftExit;
+	FILETIME ftKernel;
+	FILETIME ftUser;
+
+	if (GetProcessTimes(GetCurrentProcess(), &ftCreation, &ftExit, &ftKernel, &ftUser) != 0)
+	{
+		ULARGE_INTEGER time;
+		time.LowPart = ftKernel.dwLowDateTime;
+		time.HighPart = ftKernel.dwHighDateTime;
+		kernelTime = long(time.QuadPart / 10000000L);
+		time.LowPart = ftUser.dwLowDateTime;
+		time.HighPart = ftUser.dwHighDateTime;
+		userTime = long(time.QuadPart / 10000000L);
+	} 
+	else
+	{
+		userTime = kernelTime = -1;
+	}
+}
+
+
+static bool argNeedsEscaping(const std::string& arg)
+{
+	bool containsQuotableChar = std::string::npos != arg.find_first_of(" \t\n\v\"");
+	// Assume args that start and end with quotes are already quoted and do not require further quoting.
+	// There is probably code out there written before launch() escaped the arguments that does its own
+	// escaping of arguments. This ensures we do not interfere with those arguments.
+	bool isAlreadyQuoted = arg.size() > 1 && '\"' == arg[0] && '\"' == arg[arg.size() - 1];
+	return containsQuotableChar && !isAlreadyQuoted;
+}
+
+
+// Based on code from https://blogs.msdn.microsoft.com/twistylittlepassagesallalike/2011/04/23/everyone-quotes-command-line-arguments-the-wrong-way/
+static std::string escapeArg(const std::string& arg)
+{
+	if (argNeedsEscaping(arg))
+	{
+		std::string quotedArg("\"");
+		for (std::string::const_iterator it = arg.begin(); ; ++it)
+		{
+			unsigned backslashCount = 0;
+			while (it != arg.end() && '\\' == *it)
+			{
+				++it;
+				++backslashCount;
+			}
+
+			if (it == arg.end())
+			{
+				quotedArg.append(2 * backslashCount, '\\');
+				break;
+			} 
+			else if ('"' == *it)
+			{
+				quotedArg.append(2 * backslashCount + 1, '\\');
+				quotedArg.push_back('"');
+			} 
+			else
+			{
+				quotedArg.append(backslashCount, '\\');
+				quotedArg.push_back(*it);
+			}
+		}
+		quotedArg.push_back('"');
+		return quotedArg;
+	} 
+	else
+	{
+		return arg;
+	}
+}
+
+
+ProcessHandleImpl* ProcessImpl::launchImpl(const std::string& command, const ArgsImpl& args, const std::string& initialDirectory, Pipe* inPipe, Pipe* outPipe, Pipe* errPipe, const EnvImpl& env)
+{
+	std::string commandLine = escapeArg(command);
+	for (ArgsImpl::const_iterator it = args.begin(); it != args.end(); ++it)
+	{
+		commandLine.append(" ");
+		commandLine.append(escapeArg(*it));
+	}
+
+	std::wstring ucommandLine;
+	UnicodeConverter::toUTF16(commandLine, ucommandLine);
+
+	const wchar_t* applicationName = 0;
+	std::wstring uapplicationName;
+	if (command.size() > MAX_PATH)
+	{
+		Poco::Path p(command);
+		if (p.isAbsolute())
+		{
+			UnicodeConverter::toUTF16(command, uapplicationName);
+			if (p.getExtension().empty()) uapplicationName += L".EXE";
+			applicationName = uapplicationName.c_str();
+		}
+	}
+
+	STARTUPINFOW startupInfo;
+	GetStartupInfoW(&startupInfo); // take defaults from current process
+	startupInfo.cb = sizeof(STARTUPINFOW);
+	startupInfo.lpReserved = NULL;
+	startupInfo.lpDesktop = NULL;
+	startupInfo.lpTitle = NULL;
+	startupInfo.dwFlags = STARTF_FORCEOFFFEEDBACK;
+	startupInfo.cbReserved2 = 0;
+	startupInfo.lpReserved2 = NULL;
+
+	HANDLE hProc = GetCurrentProcess();
+	bool mustInheritHandles = false;
+	if (inPipe)
+	{
+		DuplicateHandle(hProc, inPipe->readHandle(), hProc, &startupInfo.hStdInput, 0, TRUE, DUPLICATE_SAME_ACCESS);
+		mustInheritHandles = true;
+		inPipe->close(Pipe::CLOSE_READ);
+	} 
+	else if (GetStdHandle(STD_INPUT_HANDLE))
+	{
+		DuplicateHandle(hProc, GetStdHandle(STD_INPUT_HANDLE), hProc, &startupInfo.hStdInput, 0, TRUE, DUPLICATE_SAME_ACCESS);
+		mustInheritHandles = true;
+	} 
+	else
+	{
+		startupInfo.hStdInput = 0;
+	}
+	// outPipe may be the same as errPipe, so we duplicate first and close later.
+	if (outPipe)
+	{
+		DuplicateHandle(hProc, outPipe->writeHandle(), hProc, &startupInfo.hStdOutput, 0, TRUE, DUPLICATE_SAME_ACCESS);
+		mustInheritHandles = true;
+	} 
+	else if (GetStdHandle(STD_OUTPUT_HANDLE))
+	{
+		DuplicateHandle(hProc, GetStdHandle(STD_OUTPUT_HANDLE), hProc, &startupInfo.hStdOutput, 0, TRUE, DUPLICATE_SAME_ACCESS);
+		mustInheritHandles = true;
+	} 
+	else
+	{
+		startupInfo.hStdOutput = 0;
+	}
+	if (errPipe)
+	{
+		DuplicateHandle(hProc, errPipe->writeHandle(), hProc, &startupInfo.hStdError, 0, TRUE, DUPLICATE_SAME_ACCESS);
+		mustInheritHandles = true;
+	} 
+	else if (GetStdHandle(STD_ERROR_HANDLE))
+	{
+		DuplicateHandle(hProc, GetStdHandle(STD_ERROR_HANDLE), hProc, &startupInfo.hStdError, 0, TRUE, DUPLICATE_SAME_ACCESS);
+		mustInheritHandles = true;
+	} 
+	else
+	{
+		startupInfo.hStdError = 0;
+	}
+	if (outPipe) outPipe->close(Pipe::CLOSE_WRITE);
+	if (errPipe) errPipe->close(Pipe::CLOSE_WRITE);
+
+	if (mustInheritHandles)
+	{
+		startupInfo.dwFlags |= STARTF_USESTDHANDLES;
+	}
+
+	std::wstring uinitialDirectory;
+	UnicodeConverter::toUTF16(initialDirectory, uinitialDirectory);
+	const wchar_t* workingDirectory = uinitialDirectory.empty() ? 0 : uinitialDirectory.c_str();
+
+	const char* pEnv = 0;
+	std::vector<char> envChars;
+	if (!env.empty())
+	{
+		envChars = getEnvironmentVariablesBuffer(env);
+		pEnv = &envChars[0];
+	}
+
+	PROCESS_INFORMATION processInfo;
+	DWORD creationFlags = GetConsoleWindow() ? 0 : CREATE_NO_WINDOW;
+	BOOL rc = CreateProcessW(
+		applicationName,
+		const_cast<wchar_t*>(ucommandLine.c_str()),
+		NULL, // processAttributes
+		NULL, // threadAttributes
+		mustInheritHandles,
+		creationFlags,
+		(LPVOID)pEnv,
+		workingDirectory,
+		&startupInfo,
+		&processInfo
+	);
+	if (startupInfo.hStdInput) CloseHandle(startupInfo.hStdInput);
+	if (startupInfo.hStdOutput) CloseHandle(startupInfo.hStdOutput);
+	if (startupInfo.hStdError) CloseHandle(startupInfo.hStdError);
+	if (rc)
+	{
+		CloseHandle(processInfo.hThread);
+		return new ProcessHandleImpl(processInfo.hProcess, processInfo.dwProcessId);
+	} 
+	else throw SystemException("Cannot launch process", command);
+}
+
+
+void ProcessImpl::killImpl(ProcessHandleImpl& handle)
+{
+	if (handle.process())
+	{
+		if (TerminateProcess(handle.process(), 0) == 0)
+		{
+			handle.closeHandle();
+			throw SystemException("cannot kill process");
+		}
+		handle.closeHandle();
+	}
+}
+
+void ProcessImpl::killImpl(PIDImpl pid)
+{
+	HANDLE hProc = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
+	if (hProc)
+	{
+		if (TerminateProcess(hProc, 0) == 0)
+		{
+			CloseHandle(hProc);
+			throw SystemException("cannot kill process");
+		}
+		CloseHandle(hProc);
+	} 
+	else
+	{
+		switch (GetLastError())
+		{
+		case ERROR_ACCESS_DENIED:
+			throw NoPermissionException("cannot kill process");
+		case ERROR_NOT_FOUND: 
+			throw NotFoundException("cannot kill process");
+		case ERROR_INVALID_PARAMETER:
+			throw NotFoundException("cannot kill process");
+		default:
+			throw SystemException("cannot kill process");
+		}
+	}
+}
+
+
+bool ProcessImpl::isRunningImpl(const ProcessHandleImpl& handle)
+{
+	bool result = true;
+	DWORD exitCode;
+	BOOL rc = GetExitCodeProcess(handle.process(), &exitCode);
+	if (!rc || exitCode != STILL_ACTIVE) result = false;
+	return result;
+}
+
+
+bool ProcessImpl::isRunningImpl(PIDImpl pid)
+{
+	HANDLE hProc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);
+	bool result = true;
+	DWORD exitCode;
+	BOOL rc = GetExitCodeProcess(hProc, &exitCode);
+	if (!rc || exitCode != STILL_ACTIVE) result = false;
+	return result;
+}
+
+
+void ProcessImpl::requestTerminationImpl(PIDImpl pid)
+{
+	NamedEvent ev(terminationEventName(pid));
+	ev.set();
+}
+
+
+std::string ProcessImpl::terminationEventName(PIDImpl pid)
+{
+	std::string evName("POCOTRM");
+	NumberFormatter::appendHex(evName, pid, 8);
+	return evName;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Process_WINCE.cpp b/base/poco/Foundation/src/Process_WINCE.cpp
new file mode 100644
index 00000000000..e640f3be3d5
--- /dev/null
+++ b/base/poco/Foundation/src/Process_WINCE.cpp
@@ -0,0 +1,223 @@
+//
+// Process_WINCE.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  Process
+//
+// Copyright (c) 2004-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Process_WINCE.h"
+#include "Poco/Exception.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/NamedEvent.h"
+#include "Poco/UnicodeConverter.h"
+#include "Poco/Pipe.h"
+
+
+namespace Poco {
+
+
+//
+// ProcessHandleImpl
+//
+ProcessHandleImpl::ProcessHandleImpl(HANDLE hProcess, UInt32 pid):
+	_hProcess(hProcess),
+	_pid(pid)
+{
+}
+
+
+ProcessHandleImpl::~ProcessHandleImpl()
+{
+	closeHandle();
+}
+
+void ProcessHandleImpl::closeHandle()
+{
+	if (_hProcess)
+	{
+		CloseHandle(_hProcess);
+		_hProcess = NULL;
+	}
+}
+
+UInt32 ProcessHandleImpl::id() const
+{
+	return _pid;
+}
+
+
+HANDLE ProcessHandleImpl::process() const
+{
+	return _hProcess;
+}
+
+
+int ProcessHandleImpl::wait() const
+{
+	DWORD rc = WaitForSingleObject(_hProcess, INFINITE);
+	if (rc != WAIT_OBJECT_0)
+		throw SystemException("Wait failed for process", NumberFormatter::format(_pid));
+
+	DWORD exitCode;
+	if (GetExitCodeProcess(_hProcess, &exitCode) == 0)
+		throw SystemException("Cannot get exit code for process", NumberFormatter::format(_pid));
+
+	return exitCode;
+}
+
+
+//
+// ProcessImpl
+//
+ProcessImpl::PIDImpl ProcessImpl::idImpl()
+{
+	return GetCurrentProcessId(); 
+}
+
+
+void ProcessImpl::timesImpl(long& userTime, long& kernelTime)
+{
+	FILETIME ftCreation;
+	FILETIME ftExit;
+	FILETIME ftKernel;
+	FILETIME ftUser;
+
+	if (GetThreadTimes(GetCurrentThread(), &ftCreation, &ftExit, &ftKernel, &ftUser) != 0)
+	{
+		ULARGE_INTEGER time;
+		time.LowPart  = ftKernel.dwLowDateTime;
+		time.HighPart = ftKernel.dwHighDateTime;
+		kernelTime    = long(time.QuadPart/10000000L);
+		time.LowPart  = ftUser.dwLowDateTime;
+		time.HighPart = ftUser.dwHighDateTime;
+		userTime      = long(time.QuadPart/10000000L);
+	}
+	else
+	{
+		userTime = kernelTime = -1;
+	}
+}
+
+
+ProcessHandleImpl* ProcessImpl::launchImpl(const std::string& command, const ArgsImpl& args, const std::string& initialDirectory, Pipe* inPipe, Pipe* outPipe, Pipe* errPipe, const EnvImpl& env)
+{
+	std::wstring ucommand;
+	UnicodeConverter::toUTF16(command, ucommand);
+	
+	std::string commandLine;
+	for (ArgsImpl::const_iterator it = args.begin(); it != args.end(); ++it)
+	{
+		if (it != args.begin()) commandLine.append(" ");
+		commandLine.append(*it);
+	}		
+
+	std::wstring ucommandLine;
+	UnicodeConverter::toUTF16(commandLine, ucommandLine);
+
+	PROCESS_INFORMATION processInfo;
+	BOOL rc = CreateProcessW(
+		ucommand.c_str(), 
+		const_cast<wchar_t*>(ucommandLine.c_str()), 
+		NULL, 
+		NULL, 
+		FALSE, 
+		0, 
+		NULL, 
+		NULL, 
+		NULL/*&startupInfo*/, 
+		&processInfo
+	);
+
+	if (rc)
+	{
+		CloseHandle(processInfo.hThread);
+		return new ProcessHandleImpl(processInfo.hProcess, processInfo.dwProcessId);
+	}
+	else throw SystemException("Cannot launch process", command);
+}
+
+
+void ProcessImpl::killImpl(ProcessHandleImpl& handle)
+{
+	if (handle.process()) 
+	{
+		if (TerminateProcess(handle.process(), 0) == 0)
+		{
+			handle.closeHandle();
+			throw SystemException("cannot kill process");
+		}
+		handle.closeHandle();
+	}
+}
+
+
+void ProcessImpl::killImpl(PIDImpl pid)
+{
+	HANDLE hProc = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
+	if (hProc)
+	{
+		if (TerminateProcess(hProc, 0) == 0)
+		{
+			CloseHandle(hProc);
+			throw SystemException("cannot kill process");
+		}
+		CloseHandle(hProc);
+	}
+	else
+	{
+		switch (GetLastError())
+		{
+		case ERROR_ACCESS_DENIED:
+			throw NoPermissionException("cannot kill process");
+		case ERROR_NOT_FOUND: 
+			throw NotFoundException("cannot kill process");
+		default:
+			throw SystemException("cannot kill process");
+		}
+	}
+}
+
+
+bool ProcessImpl::isRunningImpl(const ProcessHandleImpl& handle) 
+{
+	bool result = true;
+	DWORD exitCode;
+	BOOL rc = GetExitCodeProcess(handle.process(), &exitCode);
+	if (!rc || exitCode != STILL_ACTIVE) result = false;
+	return result;
+}
+
+
+bool ProcessImpl::isRunningImpl(PIDImpl pid) 
+{
+	HANDLE hProc = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);
+	bool result = true;
+	DWORD exitCode;
+	BOOL rc = GetExitCodeProcess(hProc, &exitCode);
+	if (!rc || exitCode != STILL_ACTIVE) result = false;
+	return result;}
+
+
+void ProcessImpl::requestTerminationImpl(PIDImpl pid)
+{
+	NamedEvent ev(terminationEventName(pid));
+	ev.set();
+}
+
+
+std::string ProcessImpl::terminationEventName(PIDImpl pid)
+{
+	std::string evName("POCOTRM");
+	NumberFormatter::appendHex(evName, pid, 8);
+	return evName;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/PurgeStrategy.cpp b/base/poco/Foundation/src/PurgeStrategy.cpp
new file mode 100644
index 00000000000..8e46506d7c4
--- /dev/null
+++ b/base/poco/Foundation/src/PurgeStrategy.cpp
@@ -0,0 +1,154 @@
+//
+// PurgeStrategy.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  FileChannel
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/PurgeStrategy.h"
+#include "Poco/Path.h"
+#include "Poco/DirectoryIterator.h"
+#include "Poco/Timestamp.h"
+
+
+namespace Poco {
+
+
+//
+// PurgeStrategy
+//
+
+
+PurgeStrategy::PurgeStrategy()
+{
+}
+
+
+PurgeStrategy::~PurgeStrategy()
+{
+}
+
+
+void PurgeStrategy::list(const std::string& path, std::vector<File>& files)
+{
+	Path p(path);
+	p.makeAbsolute();
+	Path parent = p.parent();
+	std::string baseName = p.getFileName();
+	baseName.append(".");
+
+	DirectoryIterator it(parent);
+	DirectoryIterator end;
+	while (it != end)
+	{
+		if (it.name().compare(0, baseName.size(), baseName) == 0
+			&& it.name().find(".incomplete") == std::string::npos)
+		{
+			files.push_back(*it);
+		}
+		++it;
+	}
+}
+
+
+//
+// PurgeByAgeStrategy
+//
+
+
+PurgeByAgeStrategy::PurgeByAgeStrategy(const Timespan& age): _age(age)
+{
+}
+
+
+PurgeByAgeStrategy::~PurgeByAgeStrategy()
+{
+}
+
+
+void PurgeByAgeStrategy::purge(const std::string& path)
+{
+	std::vector<File> files;
+	list(path, files);
+	for (std::vector<File>::iterator it = files.begin(); it != files.end(); ++it)
+	{
+		if (it->getLastModified().isElapsed(_age.totalMicroseconds()))
+		{
+			it->remove();
+		}
+	}
+}
+
+
+//
+// PurgeByCountStrategy
+//
+
+
+PurgeByCountStrategy::PurgeByCountStrategy(int count): _count(count)
+{
+	poco_assert(count > 0);
+}
+
+
+PurgeByCountStrategy::~PurgeByCountStrategy()
+{
+}
+
+
+void PurgeByCountStrategy::purge(const std::string& path)
+{
+	std::vector<File> files;
+	list(path, files);
+	while (files.size() > _count)
+	{
+		std::vector<File>::iterator it = files.begin();
+		std::vector<File>::iterator purgeIt = it;
+		Timestamp purgeTS = purgeIt->getLastModified();
+		++it;
+		while (it != files.end())
+		{
+			Timestamp md(it->getLastModified());
+			if (md <= purgeTS)
+			{
+				purgeTS = md;
+				purgeIt = it;
+			}
+			++it;
+		}
+		purgeIt->remove();
+		files.erase(purgeIt);
+	}
+}
+
+
+void PurgeOneFileStrategy::purge(const std::string& path)
+{
+	std::vector<File> files;
+	list(path, files);
+
+    if (files.empty())
+    {
+        File(path).setSize(0);
+        return;
+    }
+
+    auto purge_it = files.begin();
+    auto it = files.begin();
+    for (++it; it != files.end(); ++it)
+        if (it->getLastModified() < purge_it->getLastModified())
+            purge_it = it;
+
+	purge_it->remove();
+}
+
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/RWLock.cpp b/base/poco/Foundation/src/RWLock.cpp
new file mode 100644
index 00000000000..ba3f7d14253
--- /dev/null
+++ b/base/poco/Foundation/src/RWLock.cpp
@@ -0,0 +1,46 @@
+//
+// RWLock.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  RWLock
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/RWLock.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#if defined(_WIN32_WCE)
+#include "RWLock_WINCE.cpp"
+#else
+#include "RWLock_WIN32.cpp"
+#endif
+#elif POCO_OS == POCO_OS_ANDROID
+#include "RWLock_Android.cpp"
+#elif defined(POCO_VXWORKS)
+#include "RWLock_VX.cpp"
+#else
+#include "RWLock_POSIX.cpp"
+#endif
+
+
+namespace Poco {
+
+
+RWLock::RWLock()
+{
+}
+
+	
+RWLock::~RWLock()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/RWLock_Android.cpp b/base/poco/Foundation/src/RWLock_Android.cpp
new file mode 100644
index 00000000000..7f1ef96657b
--- /dev/null
+++ b/base/poco/Foundation/src/RWLock_Android.cpp
@@ -0,0 +1,39 @@
+//
+// RWLock_Android.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  RWLock
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/RWLock_Android.h"
+
+
+namespace Poco {
+
+
+RWLockImpl::RWLockImpl()
+{
+	pthread_mutexattr_t attr;
+	pthread_mutexattr_init(&attr);
+	if (pthread_mutex_init(&_mutex, &attr))
+	{
+		pthread_mutexattr_destroy(&attr);
+		throw SystemException("cannot create mutex");
+	}
+	pthread_mutexattr_destroy(&attr);}
+
+
+RWLockImpl::~RWLockImpl()
+{
+	pthread_mutex_destroy(&_mutex);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/RWLock_POSIX.cpp b/base/poco/Foundation/src/RWLock_POSIX.cpp
new file mode 100644
index 00000000000..9b729e796b5
--- /dev/null
+++ b/base/poco/Foundation/src/RWLock_POSIX.cpp
@@ -0,0 +1,34 @@
+//
+// RWLock_POSIX.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  RWLock
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/RWLock_POSIX.h"
+
+
+namespace Poco {
+
+
+RWLockImpl::RWLockImpl()
+{
+	if (pthread_rwlock_init(&_rwl, NULL))
+		throw SystemException("cannot create reader/writer lock");
+}
+
+
+RWLockImpl::~RWLockImpl()
+{
+	pthread_rwlock_destroy(&_rwl);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/RWLock_VX.cpp b/base/poco/Foundation/src/RWLock_VX.cpp
new file mode 100644
index 00000000000..44167d97e64
--- /dev/null
+++ b/base/poco/Foundation/src/RWLock_VX.cpp
@@ -0,0 +1,48 @@
+//
+// RWLock_VX.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  RWLock
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/RWLock_VX.h"
+#include <cstring>
+
+
+namespace Poco {
+
+
+RWLockImpl::RWLockImpl()
+{
+#if defined(POCO_VXWORKS)
+	// This workaround is for VxWorks 5.x where
+	// pthread_mutex_init() won't properly initialize the mutex
+	// resulting in a subsequent freeze in pthread_mutex_destroy()
+	// if the mutex has never been used.
+	std::memset(&_mutex, 0, sizeof(_mutex));
+#endif
+	pthread_mutexattr_t attr;
+	pthread_mutexattr_init(&attr);
+	if (pthread_mutex_init(&_mutex, &attr))
+	{
+		pthread_mutexattr_destroy(&attr);
+		throw SystemException("cannot create mutex");
+	}
+	pthread_mutexattr_destroy(&attr);
+}
+
+
+RWLockImpl::~RWLockImpl()
+{
+	pthread_mutex_destroy(&_mutex);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/RWLock_WIN32.cpp b/base/poco/Foundation/src/RWLock_WIN32.cpp
new file mode 100644
index 00000000000..973b0ae3c5a
--- /dev/null
+++ b/base/poco/Foundation/src/RWLock_WIN32.cpp
@@ -0,0 +1,207 @@
+//
+// RWLock_WIN32.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  RWLock
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/RWLock_WIN32.h"
+
+
+namespace Poco {
+
+
+RWLockImpl::RWLockImpl(): _readers(0), _writersWaiting(0), _writers(0)
+{
+	_mutex = CreateMutexW(NULL, FALSE, NULL);
+	if (_mutex == NULL)
+		throw SystemException("cannot create reader/writer lock");
+
+	_readEvent = CreateEventW(NULL, TRUE, TRUE, NULL);
+	if (_readEvent == NULL)
+		throw SystemException("cannot create reader/writer lock");
+
+	_writeEvent = CreateEventW(NULL, TRUE, TRUE, NULL);
+	if (_writeEvent == NULL)
+		throw SystemException("cannot create reader/writer lock");
+}
+
+
+RWLockImpl::~RWLockImpl()
+{
+	CloseHandle(_mutex);
+	CloseHandle(_readEvent);
+	CloseHandle(_writeEvent);
+}
+
+
+inline void RWLockImpl::addWriter()
+{
+	switch (WaitForSingleObject(_mutex, INFINITE))
+	{
+	case WAIT_OBJECT_0:
+		if (++_writersWaiting == 1) ResetEvent(_readEvent);
+		ReleaseMutex(_mutex);
+		break;
+	default:
+		throw SystemException("cannot lock reader/writer lock");
+	}
+}
+
+
+inline void RWLockImpl::removeWriter()
+{
+	switch (WaitForSingleObject(_mutex, INFINITE))
+	{
+	case WAIT_OBJECT_0:
+		if (--_writersWaiting == 0 && _writers == 0) SetEvent(_readEvent);
+		ReleaseMutex(_mutex);
+		break;
+	default:
+		throw SystemException("cannot lock reader/writer lock");
+	}
+}
+
+
+void RWLockImpl::readLockImpl()
+{
+	HANDLE h[2];
+	h[0] = _mutex;
+	h[1] = _readEvent;
+	switch (WaitForMultipleObjects(2, h, TRUE, INFINITE))
+	{
+	case WAIT_OBJECT_0:
+	case WAIT_OBJECT_0 + 1:
+		++_readers;
+		ResetEvent(_writeEvent);
+		ReleaseMutex(_mutex);
+		poco_assert_dbg(_writers == 0);
+		break;
+	default:
+		throw SystemException("cannot lock reader/writer lock");
+	}
+}
+
+
+bool RWLockImpl::tryReadLockImpl()
+{
+	for (;;)
+	{
+		if (_writers != 0 || _writersWaiting != 0)
+			return false;
+
+		DWORD result = tryReadLockOnce();
+		switch (result)
+		{
+		case WAIT_OBJECT_0:
+		case WAIT_OBJECT_0 + 1:
+			return true;
+		case WAIT_TIMEOUT:
+			continue; // try again
+		default:
+			throw SystemException("cannot lock reader/writer lock");
+		}
+	}
+}
+
+
+void RWLockImpl::writeLockImpl()
+{
+	addWriter();
+	HANDLE h[2];
+	h[0] = _mutex;
+	h[1] = _writeEvent;
+	switch (WaitForMultipleObjects(2, h, TRUE, INFINITE))
+	{
+	case WAIT_OBJECT_0:
+	case WAIT_OBJECT_0 + 1:
+		--_writersWaiting;
+		++_readers;
+		++_writers;
+		ResetEvent(_readEvent);
+		ResetEvent(_writeEvent);
+		ReleaseMutex(_mutex);
+		poco_assert_dbg(_writers == 1);
+		break;
+	default:
+		removeWriter();
+		throw SystemException("cannot lock reader/writer lock");
+	}
+}
+
+
+bool RWLockImpl::tryWriteLockImpl()
+{
+	addWriter();
+	HANDLE h[2];
+	h[0] = _mutex;
+	h[1] = _writeEvent;
+	switch (WaitForMultipleObjects(2, h, TRUE, 1))
+	{
+	case WAIT_OBJECT_0:
+	case WAIT_OBJECT_0 + 1:
+		--_writersWaiting;
+		++_readers;
+		++_writers;
+		ResetEvent(_readEvent);
+		ResetEvent(_writeEvent);
+		ReleaseMutex(_mutex);
+		poco_assert_dbg(_writers == 1);
+		return true;
+	case WAIT_TIMEOUT:
+		removeWriter();
+		return false;
+	default:
+		removeWriter();
+		throw SystemException("cannot lock reader/writer lock");
+	}
+}
+
+
+void RWLockImpl::unlockImpl()
+{
+	switch (WaitForSingleObject(_mutex, INFINITE))
+	{
+	case WAIT_OBJECT_0:
+		_writers = 0;
+		if (_writersWaiting == 0) SetEvent(_readEvent);
+		if (--_readers == 0) SetEvent(_writeEvent);
+		ReleaseMutex(_mutex);
+		break;
+	default:
+		throw SystemException("cannot unlock reader/writer lock");
+	}
+}
+
+
+DWORD RWLockImpl::tryReadLockOnce()
+{
+	HANDLE h[2];
+	h[0] = _mutex;
+	h[1] = _readEvent;
+	DWORD result = WaitForMultipleObjects(2, h, TRUE, 1); 
+	switch (result)
+	{
+	case WAIT_OBJECT_0:
+	case WAIT_OBJECT_0 + 1:
+		++_readers;
+		ResetEvent(_writeEvent);
+		ReleaseMutex(_mutex);
+		poco_assert_dbg(_writers == 0);
+		return result;
+	case WAIT_TIMEOUT:
+		return result;
+	default:
+		throw SystemException("cannot lock reader/writer lock");
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/RWLock_WINCE.cpp b/base/poco/Foundation/src/RWLock_WINCE.cpp
new file mode 100644
index 00000000000..f383a9da5d1
--- /dev/null
+++ b/base/poco/Foundation/src/RWLock_WINCE.cpp
@@ -0,0 +1,174 @@
+//
+// RWLock_WINCE.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  RWLock
+//
+// Copyright (c) 2009-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/RWLock_WINCE.h"
+#include "Poco/Thread.h"
+
+
+namespace Poco {
+
+
+RWLockImpl::RWLockImpl(): 
+	_readerCount(0),
+	_readerWaiting(0),
+	_writerCount(0),
+	_writerWaiting(0),
+	_writeLock(false)
+	
+{
+	InitializeCriticalSection(&_cs);
+	_readerGreen = CreateEventW(NULL, FALSE, TRUE, NULL);
+	if (!_readerGreen) throw SystemException("Cannot create RWLock");
+	_writerGreen = CreateEventW(NULL, FALSE, TRUE, NULL);
+	if (!_writerGreen)
+	{
+		CloseHandle(_readerGreen);
+		throw SystemException("Cannot create RWLock");
+	}
+}
+
+
+RWLockImpl::~RWLockImpl()
+{
+	CloseHandle(_readerGreen);
+	CloseHandle(_writerGreen);
+	DeleteCriticalSection(&_cs);
+}
+
+
+void RWLockImpl::readLockImpl()
+{
+	tryReadLockImpl(INFINITE);
+}
+
+
+bool RWLockImpl::tryReadLockImpl(DWORD timeout)
+{
+	bool wait = false;
+	do 
+	{
+		EnterCriticalSection(&_cs);
+		if (!_writerCount && !_writerWaiting)
+		{
+			if (wait)
+			{
+				_readerWaiting--;
+				wait = false;
+			}
+			_readerCount++;
+		}
+		else 
+		{
+			if (!wait) 
+			{
+				_readerWaiting++;
+				wait = true;
+			}
+			ResetEvent(_readerGreen);
+		}
+		LeaveCriticalSection(&_cs); 
+		if (wait) 
+		{
+			if (WaitForSingleObject(_readerGreen, timeout) != WAIT_OBJECT_0) 
+			{
+				EnterCriticalSection(&_cs);
+				_readerWaiting--;
+				SetEvent(_readerGreen); 
+				SetEvent(_writerGreen);
+				LeaveCriticalSection(&_cs);
+				return false;
+			}
+		}
+	} 
+	while (wait);
+   
+	return true;
+}
+
+
+void RWLockImpl::writeLockImpl()
+{
+	tryWriteLockImpl(INFINITE);
+}
+
+
+bool RWLockImpl::tryWriteLockImpl(DWORD timeout)
+{
+	bool wait = false;
+
+	do 
+	{
+		EnterCriticalSection(&_cs);
+		if (!_readerCount && !_writerCount)
+		{
+			if (wait) 
+			{
+				_writerWaiting--;
+				wait = false;
+			}
+			_writerCount++;
+		}
+		else 
+		{
+			if (!wait) 
+			{
+				_writerWaiting++;
+				wait = true;
+			}
+			ResetEvent(_writerGreen);
+		}
+		LeaveCriticalSection(&_cs);
+		if (wait) 
+		{
+			if (WaitForSingleObject(_writerGreen, timeout) != WAIT_OBJECT_0) 
+			{
+				EnterCriticalSection(&_cs);
+				_writerWaiting--;
+				SetEvent(_readerGreen);
+				SetEvent(_writerGreen);
+				LeaveCriticalSection(&_cs);
+				return false;
+			}
+		}
+	}
+	while (wait);
+	
+	_writeLock = true;
+	return true;
+}
+
+
+void RWLockImpl::unlockImpl()
+{
+	EnterCriticalSection(&_cs);
+	
+	if (_writeLock)
+	{
+		_writeLock = false;
+		_writerCount--;
+	}
+	else
+	{
+		_readerCount--;
+	}
+	if (_writerWaiting)
+		SetEvent(_writerGreen);
+	else if (_readerWaiting)
+		SetEvent(_readerGreen);   
+		  
+	LeaveCriticalSection(&_cs);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Random.cpp b/base/poco/Foundation/src/Random.cpp
new file mode 100644
index 00000000000..43dd31eb166
--- /dev/null
+++ b/base/poco/Foundation/src/Random.cpp
@@ -0,0 +1,364 @@
+//
+// Random.cpp
+//
+// Library: Foundation
+// Package: Crypt
+// Module:  Random
+//
+// Definition of class Random.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+//
+// Based on the FreeBSD random number generator.
+// src/lib/libc/stdlib/random.c,v 1.25 
+//
+// Copyright (c) 1983, 1993
+// The Regents of the University of California.  All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+// 4. Neither the name of the University nor the names of its contributors
+//    may be used to endorse or promote products derived from this software
+//    without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+// SUCH DAMAGE.
+//
+
+
+#include "Poco/Random.h"
+#include "Poco/RandomStream.h"
+#include <ctime>
+#if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
+#include "wce_time.h"
+#endif
+
+
+/*
+ * random.c:
+ *
+ * An improved random number generation package.  In addition to the standard
+ * rand()/srand() like interface, this package also has a special state info
+ * interface.  The initstate() routine is called with a seed, an array of
+ * bytes, and a count of how many bytes are being passed in; this array is
+ * then initialized to contain information for random number generation with
+ * that much state information.  Good sizes for the amount of state
+ * information are 32, 64, 128, and 256 bytes.  The state can be switched by
+ * calling the setstate() routine with the same array as was initiallized
+ * with initstate().  By default, the package runs with 128 bytes of state
+ * information and generates far better random numbers than a linear
+ * congruential generator.  If the amount of state information is less than
+ * 32 bytes, a simple linear congruential R.N.G. is used.
+ *
+ * Internally, the state information is treated as an array of uint32_t's; the
+ * zeroeth element of the array is the type of R.N.G. being used (small
+ * integer); the remainder of the array is the state information for the
+ * R.N.G.  Thus, 32 bytes of state information will give 7 ints worth of
+ * state information, which will allow a degree seven polynomial.  (Note:
+ * the zeroeth word of state information also has some other information
+ * stored in it -- see setstate() for details).
+ *
+ * The random number generation technique is a linear feedback shift register
+ * approach, employing trinomials (since there are fewer terms to sum up that
+ * way).  In this approach, the least significant bit of all the numbers in
+ * the state table will act as a linear feedback shift register, and will
+ * have period 2^deg - 1 (where deg is the degree of the polynomial being
+ * used, assuming that the polynomial is irreducible and primitive).  The
+ * higher order bits will have longer periods, since their values are also
+ * influenced by pseudo-random carries out of the lower bits.  The total
+ * period of the generator is approximately deg*(2**deg - 1); thus doubling
+ * the amount of state information has a vast influence on the period of the
+ * generator.  Note: the deg*(2**deg - 1) is an approximation only good for
+ * large deg, when the period of the shift is the dominant factor.
+ * With deg equal to seven, the period is actually much longer than the
+ * 7*(2**7 - 1) predicted by this formula.
+ *
+ * Modified 28 December 1994 by Jacob S. Rosenberg.
+ * The following changes have been made:
+ * All references to the type u_int have been changed to unsigned long.
+ * All references to type int have been changed to type long.  Other
+ * cleanups have been made as well.  A warning for both initstate and
+ * setstate has been inserted to the effect that on Sparc platforms
+ * the 'arg_state' variable must be forced to begin on word boundaries.
+ * This can be easily done by casting a long integer array to char *.
+ * The overall logic has been left STRICTLY alone.  This software was
+ * tested on both a VAX and Sun SpacsStation with exactly the same
+ * results.  The new version and the original give IDENTICAL results.
+ * The new version is somewhat faster than the original.  As the
+ * documentation says:  "By default, the package runs with 128 bytes of
+ * state information and generates far better random numbers than a linear
+ * congruential generator.  If the amount of state information is less than
+ * 32 bytes, a simple linear congruential R.N.G. is used."  For a buffer of
+ * 128 bytes, this new version runs about 19 percent faster and for a 16
+ * byte buffer it is about 5 percent faster.
+ */
+
+
+/*
+ * For each of the currently supported random number generators, we have a
+ * break value on the amount of state information (you need at least this
+ * many bytes of state info to support this random number generator), a degree
+ * for the polynomial (actually a trinomial) that the R.N.G. is based on, and
+ * the separation between the two lower order coefficients of the trinomial.
+ */
+#define	TYPE_0		0		/* linear congruential */
+#define	BREAK_0		8
+#define	DEG_0		0
+#define	SEP_0		0
+
+#define	TYPE_1		1		/* x**7 + x**3 + 1 */
+#define	BREAK_1		32
+#define	DEG_1		7
+#define	SEP_1		3
+
+#define	TYPE_2		2		/* x**15 + x + 1 */
+#define	BREAK_2		64
+#define	DEG_2		15
+#define	SEP_2		1
+
+#define	TYPE_3		3		/* x**31 + x**3 + 1 */
+#define	BREAK_3		128
+#define	DEG_3		31
+#define	SEP_3		3
+
+#define	TYPE_4		4		/* x**63 + x + 1 */
+#define	BREAK_4		256
+#define	DEG_4		63
+#define	SEP_4		1
+
+
+namespace Poco {
+
+
+Random::Random(int stateSize)
+{
+	poco_assert (BREAK_0 <= stateSize && stateSize <= BREAK_4);
+
+	_pBuffer = new char[stateSize];
+#if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
+	initState((UInt32) wceex_time(NULL), _pBuffer, stateSize);
+#else
+	initState((UInt32) std::time(NULL), _pBuffer, stateSize);
+#endif
+}
+
+
+Random::~Random()
+{
+	delete [] _pBuffer;
+}
+
+
+/*
+ * Compute x = (7^5 * x) mod (2^31 - 1)
+ * wihout overflowing 31 bits:
+ *      (2^31 - 1) = 127773 * (7^5) + 2836
+ * From "Random number generators: good ones are hard to find",
+ * Park and Miller, Communications of the ACM, vol. 31, no. 10,
+ * October 1988, p. 1195.
+ */
+inline UInt32 Random::goodRand(Int32 x)
+{
+	Int32 hi, lo;
+
+	if (x == 0) x = 123459876;
+	hi = x / 127773;
+	lo = x % 127773;
+	x = 16807 * lo - 2836 * hi;
+	if (x < 0) x += 0x7FFFFFFF;
+
+	return x;
+}
+
+
+/*
+ * Initialize the random number generator based on the given seed.  If the
+ * type is the trivial no-state-information type, just remember the seed.
+ * Otherwise, initializes state[] based on the given "seed" via a linear
+ * congruential generator.  Then, the pointers are set to known locations
+ * that are exactly rand_sep places apart.  Lastly, it cycles the state
+ * information a given number of times to get rid of any initial dependencies
+ * introduced by the L.C.R.N.G.  Note that the initialization of randtbl[]
+ * for default usage relies on values produced by this routine.
+ */
+void Random::seed(UInt32 x)
+{
+	int i, lim;
+
+	_state[0] = x;
+	if (_randType == TYPE_0)
+		lim = NSHUFF;
+	else 
+	{
+		for (i = 1; i < _randDeg; i++)
+			_state[i] = goodRand(_state[i - 1]);
+		_fptr = &_state[_randSep];
+		_rptr = &_state[0];
+		lim = 10 * _randDeg;
+	}
+	for (i = 0; i < lim; i++)
+		next();
+}
+
+
+/*
+ * Many programs choose the seed value in a totally predictable manner.
+ * This often causes problems.  We seed the generator using the much more
+ * secure random(4) interface.  Note that this particular seeding
+ * procedure can generate states which are impossible to reproduce by
+ * calling srandom() with any value, since the succeeding terms in the
+ * state buffer are no longer derived from the LC algorithm applied to
+ * a fixed seed.
+ */
+void Random::seed()
+{
+	std::streamsize len;
+
+	if (_randType == TYPE_0)
+		len = sizeof _state[0];
+	else
+		len = _randDeg * sizeof _state[0];
+
+	RandomInputStream rstr;
+	rstr.read((char*) _state, len);
+}
+
+
+/*
+ * Initialize the state information in the given array of n bytes for future
+ * random number generation.  Based on the number of bytes we are given, and
+ * the break values for the different R.N.G.'s, we choose the best (largest)
+ * one we can and set things up for it.  srandom() is then called to
+ * initialize the state information.
+ *
+ * Note that on return from srandom(), we set state[-1] to be the type
+ * multiplexed with the current value of the rear pointer; this is so
+ * successive calls to initstate() won't lose this information and will be
+ * able to restart with setstate().
+ *
+ * Note: the first thing we do is save the current state, if any, just like
+ * setstate() so that it doesn't matter when initstate is called.
+ *
+ * Returns a pointer to the old state.
+ *
+ * Note: The Sparc platform requires that arg_state begin on an int
+ * word boundary; otherwise a bus error will occur. Even so, lint will
+ * complain about mis-alignment, but you should disregard these messages.
+ */
+void Random::initState(UInt32 s, char* argState, Int32 n)
+{
+	UInt32* intArgState = (UInt32*) argState;
+
+	if (n < BREAK_0) 
+	{
+		poco_bugcheck_msg("not enough state");
+		return;
+	}
+	if (n < BREAK_1) 
+	{
+		_randType = TYPE_0;
+		_randDeg  = DEG_0;
+		_randSep  = SEP_0;
+	} 
+	else if (n < BREAK_2) 
+	{
+		_randType = TYPE_1;
+		_randDeg  = DEG_1;
+		_randSep  = SEP_1;
+	} 
+	else if (n < BREAK_3) 
+	{
+		_randType = TYPE_2;
+		_randDeg  = DEG_2;
+		_randSep  = SEP_2;
+	} 
+	else if (n < BREAK_4) 
+	{
+		_randType = TYPE_3;
+		_randDeg  = DEG_3;
+		_randSep  = SEP_3;
+	} 
+	else 
+	{
+		_randType = TYPE_4;
+		_randDeg = DEG_4;
+		_randSep = SEP_4;
+	}
+	_state  = intArgState + 1; /* first location */
+	_endPtr = &_state[_randDeg];	/* must set end_ptr before seed */
+	seed(s);
+	if (_randType == TYPE_0)
+		intArgState[0] = _randType;
+	else
+		intArgState[0] = MAX_TYPES * (int) (_rptr - _state) + _randType;
+}
+
+
+/*
+ * Next:
+ *
+ * If we are using the trivial TYPE_0 R.N.G., just do the old linear
+ * congruential bit.  Otherwise, we do our fancy trinomial stuff, which is
+ * the same in all the other cases due to all the global variables that have
+ * been set up.  The basic operation is to add the number at the rear pointer
+ * into the one at the front pointer.  Then both pointers are advanced to
+ * the next location cyclically in the table.  The value returned is the sum
+ * generated, reduced to 31 bits by throwing away the "least random" low bit.
+ *
+ * Note: the code takes advantage of the fact that both the front and
+ * rear pointers can't wrap on the same call by not testing the rear
+ * pointer if the front one has wrapped.
+ *
+ * Returns a 31-bit random number.
+ */
+UInt32 Random::next()
+{
+	UInt32 i;
+	UInt32 *f, *r;
+
+	if (_randType == TYPE_0) 
+	{
+		i = _state[0];
+		_state[0] = i = goodRand(i) & 0x7FFFFFFF;
+	} 
+	else 
+	{
+		/*
+		 * Use local variables rather than static variables for speed.
+		 */
+		f = _fptr; r = _rptr;
+		*f += *r;
+		i = (*f >> 1) & 0x7FFFFFFF;	/* chucking least random bit */
+		if (++f >= _endPtr) {
+			f = _state;
+			++r;
+		}
+		else if (++r >= _endPtr) {
+			r = _state;
+		}
+
+		_fptr = f; _rptr = r;
+	}
+	return i;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/RandomStream.cpp b/base/poco/Foundation/src/RandomStream.cpp
new file mode 100644
index 00000000000..7a490eb603d
--- /dev/null
+++ b/base/poco/Foundation/src/RandomStream.cpp
@@ -0,0 +1,127 @@
+//
+// RandomStream.cpp
+//
+// Library: Foundation
+// Package: Crypt
+// Module:  RandomStream
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/RandomStream.h"
+#include "Poco/Random.h"
+#include "Poco/SHA1Engine.h"
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#include "Poco/UnWindows.h"
+#include <wincrypt.h>
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include <fcntl.h>
+#include <unistd.h>
+#endif
+#include <ctime>
+
+
+namespace Poco {
+
+
+RandomBuf::RandomBuf(): BufferedStreamBuf(256, std::ios::in)
+{
+}
+
+
+RandomBuf::~RandomBuf()
+{
+}
+
+
+int RandomBuf::readFromDevice(char* buffer, std::streamsize length)
+{
+	int n = 0;
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+	HCRYPTPROV hProvider = 0;
+	CryptAcquireContext(&hProvider, 0, 0, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
+	CryptGenRandom(hProvider, (DWORD) length, (BYTE*) buffer);
+	CryptReleaseContext(hProvider, 0);
+	n = static_cast<int>(length);
+#else
+	#if defined(POCO_OS_FAMILY_UNIX)
+	int fd = open("/dev/urandom", O_RDONLY, 0);
+	if (fd >= 0) 
+	{
+		n = read(fd, buffer, length);
+		close(fd);
+	}
+	#endif
+	if (n <= 0)
+	{
+		// x is here as a source of randomness, so it does not make
+		// much sense to protect it with a Mutex.
+		static UInt32 x = 0;
+		Random rnd1(256);
+		Random rnd2(64);
+		x += rnd1.next();
+ 
+		n = 0;
+		SHA1Engine engine;
+		UInt32 t = (UInt32) std::time(NULL);
+		engine.update(&t, sizeof(t));
+		void* p = this;
+		engine.update(&p, sizeof(p));
+		engine.update(buffer, length);
+		UInt32 junk[32];
+		engine.update(junk, sizeof(junk));
+		while (n < length)
+		{
+			for (int i = 0; i < 100; ++i)
+			{
+				UInt32 r = rnd2.next();
+				engine.update(&r, sizeof(r));
+				engine.update(&x, sizeof(x));
+				x += rnd1.next();
+			}
+			DigestEngine::Digest d = engine.digest();
+			for (DigestEngine::Digest::const_iterator it = d.begin(); it != d.end() && n < length; ++it, ++n)
+			{
+				engine.update(*it);
+				*buffer++ = *it++;
+			}
+		}
+	}
+#endif
+	return n;
+}
+
+
+RandomIOS::RandomIOS()
+{
+	poco_ios_init(&_buf);
+}
+
+
+RandomIOS::~RandomIOS()
+{
+}
+
+
+RandomBuf* RandomIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+RandomInputStream::RandomInputStream(): std::istream(&_buf)
+{
+}
+
+
+RandomInputStream::~RandomInputStream()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/RefCountedObject.cpp b/base/poco/Foundation/src/RefCountedObject.cpp
new file mode 100644
index 00000000000..4f3317ead14
--- /dev/null
+++ b/base/poco/Foundation/src/RefCountedObject.cpp
@@ -0,0 +1,31 @@
+//
+// RefCountedObject.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  RefCountedObject
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/RefCountedObject.h"
+
+
+namespace Poco {
+
+
+RefCountedObject::RefCountedObject(): _counter(1)
+{
+}
+
+
+RefCountedObject::~RefCountedObject()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/RegularExpression.cpp b/base/poco/Foundation/src/RegularExpression.cpp
new file mode 100644
index 00000000000..5331bac9fa8
--- /dev/null
+++ b/base/poco/Foundation/src/RegularExpression.cpp
@@ -0,0 +1,284 @@
+//
+// RegularExpression.h
+//
+// Library: Foundation
+// Package: RegExp
+// Module:  RegularExpression
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/RegularExpression.h"
+#include "Poco/Exception.h"
+#include <sstream>
+#if defined(POCO_UNBUNDLED_PCRE)
+#include <pcre.h>
+#else
+#include "pcre_config.h"
+#include "pcre.h"
+#endif
+
+
+namespace Poco {
+
+
+const int RegularExpression::OVEC_SIZE = 63; // must be multiple of 3
+
+
+RegularExpression::RegularExpression(const std::string& pattern, int options, bool study): _pcre(0), _extra(0)
+{
+	const char* error;
+	int offs;
+	_pcre = pcre_compile(pattern.c_str(), options, &error, &offs, 0);
+	if (!_pcre)
+	{
+		std::ostringstream msg;
+		msg << error << " (at offset " << offs << ")";
+		throw RegularExpressionException(msg.str());
+	}
+	if (study)
+		_extra = pcre_study(reinterpret_cast<pcre*>(_pcre), 0, &error);
+}
+
+
+RegularExpression::~RegularExpression()
+{
+	if (_pcre)  pcre_free(reinterpret_cast<pcre*>(_pcre));
+	if (_extra) pcre_free(reinterpret_cast<struct pcre_extra*>(_extra));
+}
+
+
+int RegularExpression::match(const std::string& subject, std::string::size_type offset, Match& mtch, int options) const
+{
+	poco_assert (offset <= subject.length());
+
+	int ovec[OVEC_SIZE];
+	int rc = pcre_exec(reinterpret_cast<pcre*>(_pcre), reinterpret_cast<struct pcre_extra*>(_extra), subject.c_str(), int(subject.size()), int(offset), options & 0xFFFF, ovec, OVEC_SIZE);
+	if (rc == PCRE_ERROR_NOMATCH)
+	{
+		mtch.offset = std::string::npos;
+		mtch.length = 0;
+		return 0;
+	}
+	else if (rc == PCRE_ERROR_BADOPTION)
+	{
+		throw RegularExpressionException("bad option");
+	}
+	else if (rc == 0)
+	{
+		throw RegularExpressionException("too many captured substrings");
+	}
+	else if (rc < 0)
+	{
+		std::ostringstream msg;
+		msg << "PCRE error " << rc;
+		throw RegularExpressionException(msg.str());
+	}
+	mtch.offset = ovec[0] < 0 ? std::string::npos : ovec[0];
+	mtch.length = ovec[1] - mtch.offset;
+	return rc;
+}
+
+
+int RegularExpression::match(const std::string& subject, std::string::size_type offset, MatchVec& matches, int options) const
+{
+	poco_assert (offset <= subject.length());
+
+	matches.clear();
+
+	int ovec[OVEC_SIZE];
+	int rc = pcre_exec(reinterpret_cast<pcre*>(_pcre), reinterpret_cast<struct pcre_extra*>(_extra), subject.c_str(), int(subject.size()), int(offset), options & 0xFFFF, ovec, OVEC_SIZE);
+	if (rc == PCRE_ERROR_NOMATCH)
+	{
+		return 0;
+	}
+	else if (rc == PCRE_ERROR_BADOPTION)
+	{
+		throw RegularExpressionException("bad option");
+	}
+	else if (rc == 0)
+	{
+		throw RegularExpressionException("too many captured substrings");
+	}
+	else if (rc < 0)
+	{
+		std::ostringstream msg;
+		msg << "PCRE error " << rc;
+		throw RegularExpressionException(msg.str());
+	}
+	matches.reserve(rc);
+	for (int i = 0; i < rc; ++i)
+	{
+		Match m;
+		m.offset = ovec[i*2] < 0 ? std::string::npos : ovec[i*2] ;
+		m.length = ovec[i*2 + 1] - m.offset;
+		matches.push_back(m);
+	}
+	return rc;
+}
+
+
+bool RegularExpression::match(const std::string& subject, std::string::size_type offset) const
+{
+	Match mtch;
+	match(subject, offset, mtch, RE_ANCHORED | RE_NOTEMPTY);
+	return mtch.offset == offset && mtch.length == subject.length() - offset;
+}
+
+
+bool RegularExpression::match(const std::string& subject, std::string::size_type offset, int options) const
+{
+	Match mtch;
+	match(subject, offset, mtch, options);
+	return mtch.offset == offset && mtch.length == subject.length() - offset;
+}
+
+
+int RegularExpression::extract(const std::string& subject, std::string& str, int options) const
+{
+	Match mtch;
+	int rc = match(subject, 0, mtch, options);
+	if (mtch.offset != std::string::npos)
+		str.assign(subject, mtch.offset, mtch.length);
+	else
+		str.clear();
+	return rc;
+}
+
+
+int RegularExpression::extract(const std::string& subject, std::string::size_type offset, std::string& str, int options) const
+{
+	Match mtch;
+	int rc = match(subject, offset, mtch, options);
+	if (mtch.offset != std::string::npos)
+		str.assign(subject, mtch.offset, mtch.length);
+	else
+		str.clear();
+	return rc;
+}
+
+
+int RegularExpression::split(const std::string& subject, std::string::size_type offset, std::vector<std::string>& strings, int options) const
+{
+	MatchVec matches;
+	strings.clear();
+	int rc = match(subject, offset, matches, options);
+	strings.reserve(matches.size());
+	for (MatchVec::const_iterator it = matches.begin(); it != matches.end(); ++it)
+	{
+		if (it->offset != std::string::npos)
+			strings.push_back(subject.substr(it->offset, it->length));
+		else
+			strings.push_back(std::string());
+	}
+	return rc;
+}
+
+
+int RegularExpression::subst(std::string& subject, std::string::size_type offset, const std::string& replacement, int options) const
+{
+	if (options & RE_GLOBAL)
+	{
+		int rc = 0;
+		std::string::size_type pos = substOne(subject, offset, replacement, options);
+		while (pos != std::string::npos)
+		{
+			++rc;
+			pos = substOne(subject, pos, replacement, options);
+		}
+		return rc;
+	}
+	else
+	{
+		return substOne(subject, offset, replacement, options) != std::string::npos ? 1 : 0;
+	}
+}
+
+
+std::string::size_type RegularExpression::substOne(std::string& subject, std::string::size_type offset, const std::string& replacement, int options) const
+{
+	if (offset >= subject.length()) return std::string::npos;
+
+	int ovec[OVEC_SIZE];
+	int rc = pcre_exec(reinterpret_cast<pcre*>(_pcre), reinterpret_cast<struct pcre_extra*>(_extra), subject.c_str(), int(subject.size()), int(offset), options & 0xFFFF, ovec, OVEC_SIZE);
+	if (rc == PCRE_ERROR_NOMATCH)
+	{
+		return std::string::npos;
+	}
+	else if (rc == PCRE_ERROR_BADOPTION)
+	{
+		throw RegularExpressionException("bad option");
+	}
+	else if (rc == 0)
+	{
+		throw RegularExpressionException("too many captured substrings");
+	}
+	else if (rc < 0)
+	{
+		std::ostringstream msg;
+		msg << "PCRE error " << rc;
+		throw RegularExpressionException(msg.str());
+	}
+	std::string result;
+	std::string::size_type len = subject.length();
+	std::string::size_type pos = 0;
+	std::string::size_type rp = std::string::npos;
+	while (pos < len)
+	{
+		if (ovec[0] == pos)
+		{
+			std::string::const_iterator it  = replacement.begin();
+			std::string::const_iterator end = replacement.end();
+			while (it != end)
+			{
+				if (*it == '$' && !(options & RE_NO_VARS))
+				{
+					++it;
+					if (it != end)
+					{
+						char d = *it;
+						if (d >= '0' && d <= '9')
+						{
+							int c = d - '0';
+							if (c < rc)
+							{
+								int o = ovec[c*2];
+								int l = ovec[c*2 + 1] - o;
+								result.append(subject, o, l);
+							}
+						}
+						else
+						{
+							result += '$';
+							result += d;
+						}
+						++it;
+					}
+					else result += '$';
+				}
+				else result += *it++;
+			}
+			pos = ovec[1];
+			rp = result.length();
+		}
+		else result += subject[pos++];
+	}
+	subject = result;
+	return rp;
+}
+
+
+bool RegularExpression::match(const std::string& subject, const std::string& pattern, int options)
+{
+	int ctorOptions = options & (RE_CASELESS | RE_MULTILINE | RE_DOTALL | RE_EXTENDED | RE_ANCHORED | RE_DOLLAR_ENDONLY | RE_EXTRA | RE_UNGREEDY | RE_UTF8 | RE_NO_AUTO_CAPTURE);
+	int mtchOptions = options & (RE_ANCHORED | RE_NOTBOL | RE_NOTEOL | RE_NOTEMPTY | RE_NO_AUTO_CAPTURE | RE_NO_UTF8_CHECK);
+	RegularExpression re(pattern, ctorOptions, false);
+	return re.match(subject, 0, mtchOptions);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/RotateStrategy.cpp b/base/poco/Foundation/src/RotateStrategy.cpp
new file mode 100644
index 00000000000..0019ff91193
--- /dev/null
+++ b/base/poco/Foundation/src/RotateStrategy.cpp
@@ -0,0 +1,113 @@
+//
+// RotateStrategy.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  FileChannel
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/RotateStrategy.h"
+#include "Poco/FileStream.h"
+#include "Poco/DateTimeParser.h"
+#include "Poco/DateTimeFormatter.h"
+#include "Poco/DateTimeFormat.h"
+
+
+namespace Poco {
+
+
+//
+// RotateStrategy
+//
+
+
+RotateStrategy::RotateStrategy()
+{
+}
+
+
+RotateStrategy::~RotateStrategy()
+{
+}
+
+
+//
+// RotateByIntervalStrategy
+//
+
+
+const std::string RotateByIntervalStrategy::ROTATE_TEXT("# Log file created/rotated ");
+
+
+RotateByIntervalStrategy::RotateByIntervalStrategy(const Timespan& span): 
+	_span(span),
+	_lastRotate(0)
+{
+	if (span.totalMicroseconds() <= 0) throw InvalidArgumentException("time span must be greater than zero");
+}
+
+
+RotateByIntervalStrategy::~RotateByIntervalStrategy()
+{
+}
+
+
+bool RotateByIntervalStrategy::mustRotate(LogFile* pFile)
+{
+	if (_lastRotate == 0 || pFile->size() == 0)
+	{
+		if (pFile->size() != 0)
+		{
+			Poco::FileInputStream istr(pFile->path());
+			std::string tag;
+			std::getline(istr, tag);
+			if (tag.compare(0, ROTATE_TEXT.size(), ROTATE_TEXT) == 0)
+			{
+				std::string timestamp(tag, ROTATE_TEXT.size());
+				int tzd;
+				_lastRotate = DateTimeParser::parse(DateTimeFormat::RFC1036_FORMAT, timestamp, tzd).timestamp();
+			}
+			else _lastRotate = pFile->creationDate();
+		}
+		else
+		{
+			_lastRotate.update();
+			std::string tag(ROTATE_TEXT);
+			DateTimeFormatter::append(tag, _lastRotate, DateTimeFormat::RFC1036_FORMAT);
+			pFile->write(tag);
+		}
+	}
+	Timestamp now;
+	return _span <= now - _lastRotate;
+}
+
+
+//
+// RotateBySizeStrategy
+//
+
+
+RotateBySizeStrategy::RotateBySizeStrategy(UInt64 size): _size(size)
+{
+	if (size == 0) throw InvalidArgumentException("size must be greater than zero");
+}
+
+
+RotateBySizeStrategy::~RotateBySizeStrategy()
+{
+}
+
+
+bool RotateBySizeStrategy::mustRotate(LogFile* pFile)
+{
+	return pFile->size() >= _size;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Runnable.cpp b/base/poco/Foundation/src/Runnable.cpp
new file mode 100644
index 00000000000..5bc17ffcf8a
--- /dev/null
+++ b/base/poco/Foundation/src/Runnable.cpp
@@ -0,0 +1,32 @@
+//
+// Runnable.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Thread
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Runnable.h"
+#include "Poco/Thread.h"
+
+
+namespace Poco {
+
+
+Runnable::Runnable()
+{
+}
+
+
+Runnable::~Runnable()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/SHA1Engine.cpp b/base/poco/Foundation/src/SHA1Engine.cpp
new file mode 100644
index 00000000000..fb945a6f57c
--- /dev/null
+++ b/base/poco/Foundation/src/SHA1Engine.cpp
@@ -0,0 +1,283 @@
+//
+// SHA1Engine.cpp
+//
+// Library: Foundation
+// Package: Crypt
+// Module:  SHA1Engine
+//
+// Based on the public domain implementation by Peter C. Gutmann
+// on 2 Sep 1992, modified by Carl Ellison to be SHA-1.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SHA1Engine.h"
+#include <cstring>
+
+
+#ifdef POCO_ARCH_LITTLE_ENDIAN
+	#define SHA1_BYTE_REVERSE(x, y) byteReverse(x, y)
+#else
+	#define SHA1_BYTE_REVERSE(x, y)
+#endif
+
+
+namespace Poco {
+
+
+SHA1Engine::SHA1Engine()
+{
+	_digest.reserve(16);
+	reset();
+}
+
+
+SHA1Engine::~SHA1Engine()
+{
+	reset();
+}
+
+
+inline void SHA1Engine::byteReverse(UInt32* buffer, int byteCount)
+{
+#ifdef POCO_ARCH_LITTLE_ENDIAN
+	byteCount /= sizeof(UInt32);
+	for(int count = 0; count < byteCount; count++)
+	{
+		UInt32 value = (buffer[ count ] << 16) | (buffer[ count ] >> 16);
+		buffer[count] = ((value & 0xFF00FF00L) >> 8) | ((value & 0x00FF00FFL) << 8);
+	}
+#endif // POCO_ARCH_LITTLE_ENDIAN
+}
+
+	
+void SHA1Engine::updateImpl(const void* buffer_, std::size_t count)
+{
+	const BYTE* buffer = (const BYTE*) buffer_;
+	BYTE* db = (BYTE*) &_context.data[0];
+
+	/* Update bitcount */
+	if ((_context.countLo + ((UInt32) count << 3)) < _context.countLo)
+		_context.countHi++; /* Carry from low to high bitCount */
+	_context.countLo += ((UInt32) count << 3);
+	_context.countHi += ((UInt32 ) count >> 29);
+
+	/* Process data in BLOCK_SIZE chunks */
+	while (count-- > 0)
+	{
+		db[_context.slop++] = *(buffer++);
+		if (_context.slop == BLOCK_SIZE)
+		{ 
+			/* transform this one block */
+			SHA1_BYTE_REVERSE(_context.data, BLOCK_SIZE);
+			transform();
+			_context.slop = 0 ;	/* no slop left */
+		}
+	}
+}
+
+
+std::size_t SHA1Engine::digestLength() const
+{
+	return DIGEST_SIZE;
+}
+
+
+void SHA1Engine::reset()
+{
+	_context.digest[0] = 0x67452301L;
+	_context.digest[1] = 0xEFCDAB89L;
+	_context.digest[2] = 0x98BADCFEL;
+	_context.digest[3] = 0x10325476L;
+	_context.digest[4] = 0xC3D2E1F0L;
+	_context.countLo   = 0;
+	_context.countHi   = 0;
+	_context.slop      = 0;
+	std::memset(_context.data, 0, sizeof(_context.data));
+}
+
+
+const DigestEngine::Digest& SHA1Engine::digest()
+{
+	int count;
+	UInt32 lowBitcount  = _context.countLo;
+	UInt32 highBitcount = _context.countHi;
+
+	/* Compute number of bytes mod 64 */
+	count = (int) ((_context.countLo >> 3) & 0x3F);
+
+	/* Set the first char of padding to 0x80.  This is safe since there is
+		always at least one byte free */
+	((BYTE*) _context.data)[count++] = 0x80;
+
+	/* Pad out to 56 mod 64 */
+	if (count > 56)
+	{
+		/* Two lots of padding:  Pad the first block to 64 bytes */
+		std::memset((BYTE*) &_context.data + count, 0, 64 - count);
+		SHA1_BYTE_REVERSE(_context.data, BLOCK_SIZE);
+		transform();
+
+		/* Now fill the next block with 56 bytes */
+		std::memset(&_context.data, 0, 56);
+	}
+	else
+	{
+		/* Pad block to 56 bytes */
+		std::memset((BYTE*) &_context.data + count, 0, 56 - count);
+	}
+	SHA1_BYTE_REVERSE(_context.data, BLOCK_SIZE);
+
+	/* Append length in bits and transform */
+	_context.data[14] = highBitcount;
+	_context.data[15] = lowBitcount;
+
+	transform();
+	SHA1_BYTE_REVERSE(_context.data, DIGEST_SIZE);
+
+	unsigned char hash[DIGEST_SIZE];
+	for (count = 0; count < DIGEST_SIZE; count++)
+		hash[count] = (BYTE) ((_context.digest[count>>2]) >> (8*(3-(count & 0x3)))) & 0xff;
+	_digest.clear();
+	_digest.insert(_digest.begin(), hash, hash + DIGEST_SIZE);
+	reset();
+	return _digest;
+}
+
+
+/* The SHA f()-functions */
+#define f1(x,y,z)   ( ( x & y ) | ( ~x & z ) )              /* Rounds  0-19 */
+#define f2(x,y,z)   ( x ^ y ^ z )                           /* Rounds 20-39 */
+#define f3(x,y,z)   ( ( x & y ) | ( x & z ) | ( y & z ) )   /* Rounds 40-59 */
+#define f4(x,y,z)   ( x ^ y ^ z )                           /* Rounds 60-79 */
+
+
+/* The SHA Mysterious Constants */
+#define K1  0x5A827999L     /* Rounds  0-19 */
+#define K2  0x6ED9EBA1L     /* Rounds 20-39 */
+#define K3  0x8F1BBCDCL     /* Rounds 40-59 */
+#define K4  0xCA62C1D6L     /* Rounds 60-79 */
+
+
+/* 32-bit rotate - kludged with shifts */
+typedef UInt32 UL;	/* to save space */
+
+
+#define S(n,X)  ( ( ((UL)X) << n ) | ( ((UL)X) >> ( 32 - n ) ) )
+
+
+/* The initial expanding function */
+#define expand(count)   W[ count ] = S(1,(W[ count - 3 ] ^ W[ count - 8 ] ^ W[ count - 14 ] ^ W[ count - 16 ]))	/* to make this SHA-1 */
+
+
+/* The four SHA sub-rounds */
+#define subRound1(count)    \
+{ \
+    temp = S( 5, A ) + f1( B, C, D ) + E + W[ count ] + K1; \
+    E = D; \
+    D = C; \
+    C = S( 30, B ); \
+    B = A; \
+    A = temp; \
+}
+
+#define subRound2(count)    \
+{ \
+    temp = S( 5, A ) + f2( B, C, D ) + E + W[ count ] + K2; \
+    E = D; \
+    D = C; \
+    C = S( 30, B ); \
+    B = A; \
+    A = temp; \
+}
+
+#define subRound3(count)    \
+{ \
+    temp = S( 5, A ) + f3( B, C, D ) + E + W[ count ] + K3; \
+    E = D; \
+    D = C; \
+    C = S( 30, B ); \
+    B = A; \
+    A = temp; \
+}
+
+#define subRound4(count)    \
+{ \
+    temp = S( 5, A ) + f4( B, C, D ) + E + W[ count ] + K4; \
+    E = D; \
+    D = C; \
+    C = S( 30, B ); \
+    B = A; \
+    A = temp; \
+}
+
+
+void SHA1Engine::transform()
+{
+	UInt32 W[80];
+	UInt32 temp;
+	UInt32 A, B, C, D, E;
+	int i;
+
+	/* Step A.  Copy the data buffer into the local work buffer */
+	for( i = 0; i < 16; i++ )
+	W[ i ] = _context.data[ i ];
+
+	/* Step B.  Expand the 16 words into 64 temporary data words */
+	expand( 16 ); expand( 17 ); expand( 18 ); expand( 19 ); expand( 20 );
+	expand( 21 ); expand( 22 ); expand( 23 ); expand( 24 ); expand( 25 );
+	expand( 26 ); expand( 27 ); expand( 28 ); expand( 29 ); expand( 30 );
+	expand( 31 ); expand( 32 ); expand( 33 ); expand( 34 ); expand( 35 );
+	expand( 36 ); expand( 37 ); expand( 38 ); expand( 39 ); expand( 40 );
+	expand( 41 ); expand( 42 ); expand( 43 ); expand( 44 ); expand( 45 );
+	expand( 46 ); expand( 47 ); expand( 48 ); expand( 49 ); expand( 50 );
+	expand( 51 ); expand( 52 ); expand( 53 ); expand( 54 ); expand( 55 );
+	expand( 56 ); expand( 57 ); expand( 58 ); expand( 59 ); expand( 60 );
+	expand( 61 ); expand( 62 ); expand( 63 ); expand( 64 ); expand( 65 );
+	expand( 66 ); expand( 67 ); expand( 68 ); expand( 69 ); expand( 70 );
+	expand( 71 ); expand( 72 ); expand( 73 ); expand( 74 ); expand( 75 );
+	expand( 76 ); expand( 77 ); expand( 78 ); expand( 79 );
+
+	/* Step C.  Set up first buffer */
+	A = _context.digest[ 0 ];
+	B = _context.digest[ 1 ];
+	C = _context.digest[ 2 ];
+	D = _context.digest[ 3 ];
+	E = _context.digest[ 4 ];
+
+	/* Step D.  Serious mangling, divided into four sub-rounds */
+	subRound1( 0 ); subRound1( 1 ); subRound1( 2 ); subRound1( 3 );
+	subRound1( 4 ); subRound1( 5 ); subRound1( 6 ); subRound1( 7 );
+	subRound1( 8 ); subRound1( 9 ); subRound1( 10 ); subRound1( 11 );
+	subRound1( 12 ); subRound1( 13 ); subRound1( 14 ); subRound1( 15 );
+	subRound1( 16 ); subRound1( 17 ); subRound1( 18 ); subRound1( 19 );
+	subRound2( 20 ); subRound2( 21 ); subRound2( 22 ); subRound2( 23 );
+	subRound2( 24 ); subRound2( 25 ); subRound2( 26 ); subRound2( 27 );
+	subRound2( 28 ); subRound2( 29 ); subRound2( 30 ); subRound2( 31 );
+	subRound2( 32 ); subRound2( 33 ); subRound2( 34 ); subRound2( 35 );
+	subRound2( 36 ); subRound2( 37 ); subRound2( 38 ); subRound2( 39 );
+	subRound3( 40 ); subRound3( 41 ); subRound3( 42 ); subRound3( 43 );
+	subRound3( 44 ); subRound3( 45 ); subRound3( 46 ); subRound3( 47 );
+	subRound3( 48 ); subRound3( 49 ); subRound3( 50 ); subRound3( 51 );
+	subRound3( 52 ); subRound3( 53 ); subRound3( 54 ); subRound3( 55 );
+	subRound3( 56 ); subRound3( 57 ); subRound3( 58 ); subRound3( 59 );
+	subRound4( 60 ); subRound4( 61 ); subRound4( 62 ); subRound4( 63 );
+	subRound4( 64 ); subRound4( 65 ); subRound4( 66 ); subRound4( 67 );
+	subRound4( 68 ); subRound4( 69 ); subRound4( 70 ); subRound4( 71 );
+	subRound4( 72 ); subRound4( 73 ); subRound4( 74 ); subRound4( 75 );
+	subRound4( 76 ); subRound4( 77 ); subRound4( 78 ); subRound4( 79 );
+
+	/* Step E.  Build message digest */
+	_context.digest[ 0 ] += A;
+	_context.digest[ 1 ] += B;
+	_context.digest[ 2 ] += C;
+	_context.digest[ 3 ] += D;
+	_context.digest[ 4 ] += E;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Semaphore.cpp b/base/poco/Foundation/src/Semaphore.cpp
new file mode 100644
index 00000000000..3403125bdcc
--- /dev/null
+++ b/base/poco/Foundation/src/Semaphore.cpp
@@ -0,0 +1,45 @@
+//
+// Semaphore.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Semaphore
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Semaphore.h"
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#include "Semaphore_WIN32.cpp"
+#elif defined(POCO_VXWORKS)
+#include "Semaphore_VX.cpp"
+#else
+#include "Semaphore_POSIX.cpp"
+#endif
+
+
+namespace Poco {
+
+
+Semaphore::Semaphore(int n): SemaphoreImpl(n, n)
+{
+}
+
+
+Semaphore::Semaphore(int n, int max): SemaphoreImpl(n, max)
+{
+}
+
+
+Semaphore::~Semaphore()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Semaphore_POSIX.cpp b/base/poco/Foundation/src/Semaphore_POSIX.cpp
new file mode 100644
index 00000000000..f4818af2004
--- /dev/null
+++ b/base/poco/Foundation/src/Semaphore_POSIX.cpp
@@ -0,0 +1,170 @@
+//
+// Semaphore_POSIX.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Semaphore
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Semaphore_POSIX.h"
+#if defined(POCO_VXWORKS)
+#include <timers.h>
+#include <cstring>
+#else
+#include <time.h>
+#include <sys/time.h>
+#endif
+
+
+//
+// Note: pthread_cond_timedwait() with CLOCK_MONOTONIC is supported
+// on Linux and QNX, as well as on Android >= 5.0 (API level 21).
+// On Android < 5.0, HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC is defined
+// to indicate availability of non-standard pthread_cond_timedwait_monotonic().
+//
+#ifndef POCO_HAVE_MONOTONIC_PTHREAD_COND_TIMEDWAIT
+	#if (defined(__linux__) || defined(__QNX__)) && !(defined(__ANDROID__) && (defined(HAVE_PTHREAD_COND_TIMEDWAIT_MONOTONIC) || __ANDROID_API__ <= 21))
+		#define POCO_HAVE_MONOTONIC_PTHREAD_COND_TIMEDWAIT 1
+	#endif
+#endif
+
+
+#ifndef POCO_HAVE_CLOCK_GETTIME
+	#if (defined(_POSIX_TIMERS) && defined(CLOCK_REALTIME)) || defined(POCO_VXWORKS) || defined(__QNX__)
+		#ifndef __APPLE__ // See GitHub issue #1453 - not available before Mac OS 10.12/iOS 10
+			#define POCO_HAVE_CLOCK_GETTIME
+		#endif
+	#endif
+#endif
+
+
+namespace Poco {
+
+
+SemaphoreImpl::SemaphoreImpl(int n, int max): _n(n), _max(max)
+{
+	poco_assert (n >= 0 && max > 0 && n <= max);
+
+#if defined(POCO_VXWORKS)
+	// This workaround is for VxWorks 5.x where
+	// pthread_mutex_init() won't properly initialize the mutex
+	// resulting in a subsequent freeze in pthread_mutex_destroy()
+	// if the mutex has never been used.
+	std::memset(&_mutex, 0, sizeof(_mutex));
+#endif
+	if (pthread_mutex_init(&_mutex, NULL))
+		throw SystemException("cannot create semaphore (mutex)");
+
+#if defined(POCO_HAVE_MONOTONIC_PTHREAD_COND_TIMEDWAIT)
+	pthread_condattr_t attr;
+	if (pthread_condattr_init(&attr))
+	{
+		pthread_mutex_destroy(&_mutex);
+		throw SystemException("cannot create semaphore (condition attribute)");
+	}
+	if (pthread_condattr_setclock(&attr, CLOCK_MONOTONIC))
+    {
+		pthread_condattr_destroy(&attr);
+		pthread_mutex_destroy(&_mutex);
+		throw SystemException("cannot create semaphore (condition attribute clock)");
+    }
+	if (pthread_cond_init(&_cond, &attr))
+	{
+		pthread_condattr_destroy(&attr);
+		pthread_mutex_destroy(&_mutex);
+		throw SystemException("cannot create semaphore (condition)");
+	}
+	pthread_condattr_destroy(&attr);
+#else
+	if (pthread_cond_init(&_cond, NULL))
+	{
+		pthread_mutex_destroy(&_mutex);
+		throw SystemException("cannot create semaphore (condition)");
+	}
+#endif
+}
+
+
+SemaphoreImpl::~SemaphoreImpl()
+{
+	pthread_cond_destroy(&_cond);
+	pthread_mutex_destroy(&_mutex);
+}
+
+
+void SemaphoreImpl::waitImpl()
+{
+	if (pthread_mutex_lock(&_mutex))
+		throw SystemException("wait for semaphore failed (lock)");
+	while (_n < 1)
+	{
+		if (pthread_cond_wait(&_cond, &_mutex))
+		{
+			pthread_mutex_unlock(&_mutex);
+			throw SystemException("wait for semaphore failed");
+		}
+	}
+	--_n;
+	pthread_mutex_unlock(&_mutex);
+}
+
+
+bool SemaphoreImpl::waitImpl(long milliseconds)
+{
+	int rc = 0;
+	struct timespec abstime;
+
+#if defined(POCO_HAVE_MONOTONIC_PTHREAD_COND_TIMEDWAIT)
+	clock_gettime(CLOCK_MONOTONIC, &abstime);
+	abstime.tv_sec  += milliseconds / 1000;
+	abstime.tv_nsec += (milliseconds % 1000)*1000000;
+	if (abstime.tv_nsec >= 1000000000)
+	{
+		abstime.tv_nsec -= 1000000000;
+		abstime.tv_sec++;
+	}
+#elif defined(POCO_HAVE_CLOCK_GETTIME)
+	clock_gettime(CLOCK_REALTIME, &abstime);
+	abstime.tv_sec  += milliseconds / 1000;
+	abstime.tv_nsec += (milliseconds % 1000)*1000000;
+	if (abstime.tv_nsec >= 1000000000)
+	{
+		abstime.tv_nsec -= 1000000000;
+		abstime.tv_sec++;
+	}
+#else
+	struct timeval tv;
+	gettimeofday(&tv, NULL);
+	abstime.tv_sec  = tv.tv_sec + milliseconds / 1000;
+	abstime.tv_nsec = tv.tv_usec*1000 + (milliseconds % 1000)*1000000;
+	if (abstime.tv_nsec >= 1000000000)
+	{
+		abstime.tv_nsec -= 1000000000;
+		abstime.tv_sec++;
+	}
+#endif
+
+	if (pthread_mutex_lock(&_mutex) != 0)
+		throw SystemException("wait for semaphore failed (lock)");
+	while (_n < 1)
+	{
+		if ((rc = pthread_cond_timedwait(&_cond, &_mutex, &abstime)))
+		{
+			if (rc == ETIMEDOUT) break;
+			pthread_mutex_unlock(&_mutex);
+			throw SystemException("cannot wait for semaphore");
+		}
+	}
+	if (rc == 0) --_n;
+	pthread_mutex_unlock(&_mutex);
+	return rc == 0;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Semaphore_VX.cpp b/base/poco/Foundation/src/Semaphore_VX.cpp
new file mode 100644
index 00000000000..5bc63b530c7
--- /dev/null
+++ b/base/poco/Foundation/src/Semaphore_VX.cpp
@@ -0,0 +1,52 @@
+//
+// Semaphore_VX.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Semaphore
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Semaphore_VX.h"
+#include <sysLib.h>
+
+
+namespace Poco {
+
+
+SemaphoreImpl::SemaphoreImpl(int n, int max)
+{
+	poco_assert (n >= 0 && max > 0 && n <= max);
+
+	_sem = semCCreate(SEM_Q_PRIORITY, n);
+	if (_sem == 0)
+		throw Poco::SystemException("cannot create semaphore");
+}
+
+
+SemaphoreImpl::~SemaphoreImpl()
+{
+	semDelete(_sem);
+}
+
+
+void SemaphoreImpl::waitImpl()
+{
+	if (semTake(_sem, WAIT_FOREVER) != OK)
+		throw SystemException("cannot wait for semaphore");
+}
+
+
+bool SemaphoreImpl::waitImpl(long milliseconds)
+{
+	int ticks = milliseconds*sysClkRateGet()/1000;
+	return semTake(_sem, ticks) == OK;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Semaphore_WIN32.cpp b/base/poco/Foundation/src/Semaphore_WIN32.cpp
new file mode 100644
index 00000000000..2ec04a8c02d
--- /dev/null
+++ b/base/poco/Foundation/src/Semaphore_WIN32.cpp
@@ -0,0 +1,65 @@
+//
+// Semaphore_WIN32.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Semaphore
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Semaphore_WIN32.h"
+
+
+namespace Poco {
+
+
+SemaphoreImpl::SemaphoreImpl(int n, int max)
+{
+	poco_assert (n >= 0 && max > 0 && n <= max);
+
+	_sema = CreateSemaphoreW(NULL, n, max, NULL);
+	if (!_sema)
+	{
+		throw SystemException("cannot create semaphore");
+	}
+}
+
+
+SemaphoreImpl::~SemaphoreImpl()
+{
+	CloseHandle(_sema);
+}
+
+
+void SemaphoreImpl::waitImpl()
+{
+	switch (WaitForSingleObject(_sema, INFINITE))
+	{
+	case WAIT_OBJECT_0:
+		return;
+	default:
+		throw SystemException("wait for semaphore failed");
+	}
+}
+
+
+bool SemaphoreImpl::waitImpl(long milliseconds)
+{
+	switch (WaitForSingleObject(_sema, milliseconds + 1))
+	{
+	case WAIT_TIMEOUT:
+		return false;
+	case WAIT_OBJECT_0:
+		return true;
+	default:
+		throw SystemException("wait for semaphore failed");		
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/SharedLibrary.cpp b/base/poco/Foundation/src/SharedLibrary.cpp
new file mode 100644
index 00000000000..542f9e81029
--- /dev/null
+++ b/base/poco/Foundation/src/SharedLibrary.cpp
@@ -0,0 +1,115 @@
+//
+// SharedLibrary.cpp
+//
+// Library: Foundation
+// Package: SharedLibrary
+// Module:  SharedLibrary
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SharedLibrary.h"
+#include "Poco/Exception.h"
+
+
+#if defined(hpux) || defined(_hpux)
+#include "SharedLibrary_HPUX.cpp"
+#elif defined(POCO_VXWORKS)
+#include "SharedLibrary_VX.cpp"
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include "SharedLibrary_UNIX.cpp"
+#elif defined(POCO_OS_FAMILY_WINDOWS) && defined(POCO_WIN32_UTF8)
+#include "SharedLibrary_WIN32U.cpp"
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "SharedLibrary_WIN32.cpp"
+#endif
+
+
+namespace Poco {
+
+
+SharedLibrary::SharedLibrary()
+{
+}
+
+
+SharedLibrary::SharedLibrary(const std::string& path)
+{
+	loadImpl(path, 0);
+}
+
+
+SharedLibrary::SharedLibrary(const std::string& path, int flags)
+{
+	loadImpl(path, flags);
+}
+
+
+SharedLibrary::~SharedLibrary()
+{
+}
+
+
+void SharedLibrary::load(const std::string& path)
+{
+	loadImpl(path, 0);
+}
+
+
+void SharedLibrary::load(const std::string& path, int flags)
+{
+	loadImpl(path, flags);
+}
+
+
+void SharedLibrary::unload()
+{
+	unloadImpl();
+}
+
+
+bool SharedLibrary::isLoaded() const
+{
+	return isLoadedImpl();
+}
+
+
+bool SharedLibrary::hasSymbol(const std::string& name)
+{
+	return findSymbolImpl(name) != 0;
+}
+
+
+void* SharedLibrary::getSymbol(const std::string& name)
+{
+	void* result = findSymbolImpl(name);
+	if (result)
+		return result;
+	else
+		throw NotFoundException(name);
+}
+
+
+const std::string& SharedLibrary::getPath() const
+{
+	return getPathImpl();
+}
+
+
+std::string SharedLibrary::suffix()
+{
+	return suffixImpl();
+}
+
+
+bool SharedLibrary::setSearchPath(const std::string& path)
+{
+	return setSearchPathImpl(path);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/SharedLibrary_HPUX.cpp b/base/poco/Foundation/src/SharedLibrary_HPUX.cpp
new file mode 100644
index 00000000000..668bb5f64dd
--- /dev/null
+++ b/base/poco/Foundation/src/SharedLibrary_HPUX.cpp
@@ -0,0 +1,100 @@
+//
+// SharedLibrary_HPUX.cpp
+//
+// Library: Foundation
+// Package: SharedLibrary
+// Module:  SharedLibrary
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SharedLibrary_HPUX.h"
+#include <dl.h>
+
+
+namespace Poco {
+
+
+FastMutex SharedLibraryImpl::_mutex;
+
+
+SharedLibraryImpl::SharedLibraryImpl()
+{
+	_handle = 0;
+}
+
+
+SharedLibraryImpl::~SharedLibraryImpl()
+{
+}
+
+
+void SharedLibraryImpl::loadImpl(const std::string& path, int /*flags*/)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (_handle) throw LibraryAlreadyLoadedException(path);
+	_handle = shl_load(path.c_str(), BIND_DEFERRED, 0);
+	if (!_handle) throw LibraryLoadException(path);
+	_path = path;
+}
+
+
+void SharedLibraryImpl::unloadImpl()
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (_handle)
+	{
+		shl_unload(_handle);
+		_handle = 0;
+		_path.clear();
+	}
+}
+
+
+bool SharedLibraryImpl::isLoadedImpl() const
+{
+	return _handle != 0;
+}
+
+
+void* SharedLibraryImpl::findSymbolImpl(const std::string& name)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	void* result = 0;
+	if (_handle && shl_findsym(&_handle, name.c_str(), TYPE_UNDEFINED, &result) !=  -1)
+		return result;
+	else
+		return 0;
+}
+
+
+const std::string& SharedLibraryImpl::getPathImpl() const
+{
+	return _path;
+}
+
+
+std::string SharedLibraryImpl::suffixImpl()
+{
+#if defined(_DEBUG) && !defined(POCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX)
+	return "d.sl";
+#else
+	return ".sl";
+#endif
+}
+
+
+bool SharedLibraryImpl::setSearchPathImpl(const std::string&)
+{
+	return false;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/SharedLibrary_UNIX.cpp b/base/poco/Foundation/src/SharedLibrary_UNIX.cpp
new file mode 100644
index 00000000000..4a3dc2ffb0b
--- /dev/null
+++ b/base/poco/Foundation/src/SharedLibrary_UNIX.cpp
@@ -0,0 +1,136 @@
+//
+// SharedLibrary_UNIX.cpp
+//
+// Library: Foundation
+// Package: SharedLibrary
+// Module:  SharedLibrary
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SharedLibrary_UNIX.h"
+#include "Poco/Exception.h"
+#include <dlfcn.h>
+
+
+// Note: cygwin is missing RTLD_LOCAL, set it to 0
+#if defined(__CYGWIN__) && !defined(RTLD_LOCAL)
+#define RTLD_LOCAL 0
+#endif
+
+
+namespace Poco {
+
+
+FastMutex SharedLibraryImpl::_mutex;
+
+
+SharedLibraryImpl::SharedLibraryImpl()
+{
+	_handle = 0;
+}
+
+
+SharedLibraryImpl::~SharedLibraryImpl()
+{
+}
+
+
+void SharedLibraryImpl::loadImpl(const std::string& path, int flags)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (_handle) throw LibraryAlreadyLoadedException(path);
+	int realFlags = RTLD_LAZY;
+	if (flags & SHLIB_LOCAL_IMPL)
+		realFlags |= RTLD_LOCAL;
+	else
+		realFlags |= RTLD_GLOBAL;
+	_handle = dlopen(path.c_str(), realFlags);
+	if (!_handle)
+	{
+		const char* err = dlerror();
+		throw LibraryLoadException(err ? std::string(err) : path);
+	}
+	_path = path;
+}
+
+
+void SharedLibraryImpl::unloadImpl()
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (_handle)
+	{
+		dlclose(_handle);
+		_handle = 0;
+	}
+}
+
+
+bool SharedLibraryImpl::isLoadedImpl() const
+{
+	return _handle != 0;
+}
+
+
+void* SharedLibraryImpl::findSymbolImpl(const std::string& name)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	void* result = 0;
+	if (_handle)
+	{
+		result = dlsym(_handle, name.c_str());
+	}
+	return result;
+}
+
+
+const std::string& SharedLibraryImpl::getPathImpl() const
+{
+	return _path;
+}
+
+
+std::string SharedLibraryImpl::suffixImpl()
+{
+#if defined(__APPLE__)
+	#if defined(_DEBUG) && !defined(POCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX)
+		return "d.dylib";
+	#else
+		return ".dylib";
+	#endif
+#elif defined(hpux) || defined(_hpux)
+	#if defined(_DEBUG) && !defined(POCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX)
+		return "d.sl";
+	#else
+		return ".sl";
+	#endif
+#elif defined(__CYGWIN__)
+	#if defined(_DEBUG) && !defined(POCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX)
+		return "d.dll";
+	#else
+		return ".dll";
+	#endif
+#else
+	#if defined(_DEBUG) && !defined(POCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX)
+		return "d.so";
+	#else
+		return ".so";
+	#endif
+#endif
+}
+
+
+bool SharedLibraryImpl::setSearchPathImpl(const std::string&)
+{
+	return false;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/SharedLibrary_VX.cpp b/base/poco/Foundation/src/SharedLibrary_VX.cpp
new file mode 100644
index 00000000000..bb2b14681ed
--- /dev/null
+++ b/base/poco/Foundation/src/SharedLibrary_VX.cpp
@@ -0,0 +1,141 @@
+//
+// SharedLibrary_VX.cpp
+//
+// Library: Foundation
+// Package: SharedLibrary
+// Module:  SharedLibrary
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SharedLibrary_VX.h"
+#include "Poco/Exception.h"
+#include "Poco/Format.h"
+#include <loadLib.h>
+#include <unldLib.h>
+#include <ioLib.h>
+#include <symLib.h>
+#include <sysSymTbl.h>
+#include <cstring>
+
+
+struct SymLookup
+{
+	const char* name;
+	int         group;
+	void*       addr;
+};
+
+
+extern "C" bool lookupFunc(char* name, int val, SYM_TYPE type, int arg, UINT16 group)
+{
+	SymLookup* symLookup = reinterpret_cast<SymLookup*>(arg);
+	if (group == symLookup->group && std::strcmp(name, symLookup->name) == 0)
+	{
+		symLookup->addr = reinterpret_cast<void*>(val);
+		return TRUE;
+	}
+	else return FALSE;
+}
+
+
+namespace Poco {
+
+
+FastMutex SharedLibraryImpl::_mutex;
+
+
+SharedLibraryImpl::SharedLibraryImpl():
+	_moduleId(0)
+{
+}
+
+
+SharedLibraryImpl::~SharedLibraryImpl()
+{
+}
+
+
+void SharedLibraryImpl::loadImpl(const std::string& path, int /*flags*/)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (_moduleId) throw LibraryAlreadyLoadedException(path);
+	int fd = open(const_cast<char*>(path.c_str()), O_RDONLY, 0);
+	if (fd)
+	{
+		_moduleId = loadModule(fd, LOAD_GLOBAL_SYMBOLS);
+		if (!_moduleId)
+		{
+			int err = errno;
+			close(fd);
+			throw LibraryLoadException(Poco::format("error %d", err));
+		}
+	}
+	else
+	{
+		int err = errno;
+		throw LibraryLoadException(Poco::format("cannot open library (error %d)", err));
+	}
+	_path = path;
+}
+
+
+void SharedLibraryImpl::unloadImpl()
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (_moduleId)
+	{
+		unldByModuleId(_moduleId, 0);
+		_moduleId = 0;
+	}
+}
+
+
+bool SharedLibraryImpl::isLoadedImpl() const
+{
+	return _moduleId != 0;
+}
+
+
+void* SharedLibraryImpl::findSymbolImpl(const std::string& name)
+{
+	poco_assert (_moduleId != 0);
+
+	FastMutex::ScopedLock lock(_mutex);
+
+	MODULE_INFO mi;
+	if (!moduleInfoGet(_moduleId, &mi)) return 0;
+	SymLookup symLookup;
+	symLookup.name  = name.c_str();
+	symLookup.group = mi.group;
+	symLookup.addr  = 0;
+	symEach(sysSymTbl, reinterpret_cast<FUNCPTR>(lookupFunc), reinterpret_cast<int>(&symLookup));
+	return symLookup.addr;
+}
+
+
+const std::string& SharedLibraryImpl::getPathImpl() const
+{
+	return _path;
+}
+
+
+std::string SharedLibraryImpl::suffixImpl()
+{
+	return ".out";
+}
+
+
+bool SharedLibraryImpl::setSearchPathImpl(const std::string&)
+{
+	return false;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/SharedLibrary_WIN32.cpp b/base/poco/Foundation/src/SharedLibrary_WIN32.cpp
new file mode 100644
index 00000000000..340a742e8f5
--- /dev/null
+++ b/base/poco/Foundation/src/SharedLibrary_WIN32.cpp
@@ -0,0 +1,108 @@
+//
+// SharedLibrary_WIN32.cpp
+//
+// Library: Foundation
+// Package: SharedLibrary
+// Module:  SharedLibrary
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SharedLibrary_WIN32.h"
+#include "Poco/Path.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+FastMutex SharedLibraryImpl::_mutex;
+
+
+SharedLibraryImpl::SharedLibraryImpl()
+{
+	_handle = 0;
+}
+
+
+SharedLibraryImpl::~SharedLibraryImpl()
+{
+}
+
+
+void SharedLibraryImpl::loadImpl(const std::string& path, int /*flags*/)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (_handle) throw LibraryAlreadyLoadedException(_path);
+	DWORD flags(0);
+	Path p(path);
+	if (p.isAbsolute()) flags |= LOAD_WITH_ALTERED_SEARCH_PATH;
+	_handle = LoadLibraryExA(path.c_str(), 0, flags);
+	if (!_handle) throw LibraryLoadException(path);
+	_path = path;
+}
+
+
+void SharedLibraryImpl::unloadImpl()
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (_handle)
+	{
+		FreeLibrary((HMODULE) _handle);
+		_handle = 0;
+	}
+	_path.clear();
+}
+
+
+bool SharedLibraryImpl::isLoadedImpl() const
+{
+	return _handle != 0;
+}
+
+
+void* SharedLibraryImpl::findSymbolImpl(const std::string& name)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (_handle)
+	{
+		return (void*) GetProcAddress((HMODULE) _handle, name.c_str());
+	}
+	else return 0;
+}
+
+
+const std::string& SharedLibraryImpl::getPathImpl() const
+{
+	return _path;
+}
+
+
+std::string SharedLibraryImpl::suffixImpl()
+{
+#if defined(_DEBUG) && !defined(POCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX)
+	return "d.dll";
+#else
+	return ".dll";
+#endif
+}
+
+
+bool SharedLibraryImpl::setSearchPathImpl(const std::string& path)
+{
+#if _WIN32_WINNT >= 0x0502
+	return SetDllDirectoryA(path.c_str()) != 0;
+#else
+	return false;
+#endif
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/SharedLibrary_WIN32U.cpp b/base/poco/Foundation/src/SharedLibrary_WIN32U.cpp
new file mode 100644
index 00000000000..b4f697ea0ac
--- /dev/null
+++ b/base/poco/Foundation/src/SharedLibrary_WIN32U.cpp
@@ -0,0 +1,121 @@
+//
+// SharedLibrary_WIN32U.cpp
+//
+// Library: Foundation
+// Package: SharedLibrary
+// Module:  SharedLibrary
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SharedLibrary_WIN32U.h"
+#include "Poco/UnicodeConverter.h"
+#include "Poco/Path.h"
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+FastMutex SharedLibraryImpl::_mutex;
+
+
+SharedLibraryImpl::SharedLibraryImpl()
+{
+	_handle = 0;
+}
+
+
+SharedLibraryImpl::~SharedLibraryImpl()
+{
+}
+
+
+void SharedLibraryImpl::loadImpl(const std::string& path, int /*flags*/)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (_handle) throw LibraryAlreadyLoadedException(_path);
+	DWORD flags(0);
+#if !defined(_WIN32_WCE)
+	Path p(path);
+	if (p.isAbsolute()) flags |= LOAD_WITH_ALTERED_SEARCH_PATH;
+#endif
+	std::wstring upath;
+	UnicodeConverter::toUTF16(path, upath);
+	_handle = LoadLibraryExW(upath.c_str(), 0, flags);
+	if (!_handle) throw LibraryLoadException(path);
+	_path = path;
+}
+
+
+void SharedLibraryImpl::unloadImpl()
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (_handle)
+	{
+		FreeLibrary((HMODULE) _handle);
+		_handle = 0;
+	}
+	_path.clear();
+}
+
+
+bool SharedLibraryImpl::isLoadedImpl() const
+{
+	return _handle != 0;
+}
+
+
+void* SharedLibraryImpl::findSymbolImpl(const std::string& name)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (_handle)
+	{
+#if defined(_WIN32_WCE)
+		std::wstring uname;
+		UnicodeConverter::toUTF16(name, uname);
+		return (void*) GetProcAddressW((HMODULE) _handle, uname.c_str());
+#else
+		return (void*) GetProcAddress((HMODULE) _handle, name.c_str());
+#endif
+	}
+	else return 0;
+}
+
+
+const std::string& SharedLibraryImpl::getPathImpl() const
+{
+	return _path;
+}
+
+
+std::string SharedLibraryImpl::suffixImpl()
+{
+#if defined(_DEBUG) && !defined(POCO_NO_SHARED_LIBRARY_DEBUG_SUFFIX)
+	return "d.dll";
+#else
+	return ".dll";
+#endif
+}
+
+
+bool SharedLibraryImpl::setSearchPathImpl(const std::string& path)
+{
+#if _WIN32_WINNT >= 0x0502
+	std::wstring wpath;
+	Poco::UnicodeConverter::toUTF16(path, wpath);
+	return SetDllDirectoryW(wpath.c_str()) != 0;
+#else
+	return false;
+#endif
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/SharedMemory.cpp b/base/poco/Foundation/src/SharedMemory.cpp
new file mode 100644
index 00000000000..da43a421c02
--- /dev/null
+++ b/base/poco/Foundation/src/SharedMemory.cpp
@@ -0,0 +1,90 @@
+//
+// SharedMemory.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  SharedMemory
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SharedMemory.h"
+#include "Poco/Exception.h"
+#if defined(POCO_NO_SHAREDMEMORY)
+#include "SharedMemory_DUMMY.cpp"
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "SharedMemory_WIN32.cpp"
+#elif defined(POCO_OS_FAMILY_UNIX)
+#include "SharedMemory_POSIX.cpp"
+#else
+#include "SharedMemory_DUMMY.cpp"
+#endif
+
+
+namespace Poco {
+
+
+SharedMemory::SharedMemory():
+	_pImpl(0)
+{
+}
+
+
+SharedMemory::SharedMemory(const std::string& name, std::size_t size, AccessMode mode, const void* addrHint, bool server):
+	_pImpl(new SharedMemoryImpl(name, size, mode, addrHint, server))
+{
+}
+
+
+SharedMemory::SharedMemory(const Poco::File& file, AccessMode mode, const void* addrHint):
+	_pImpl(new SharedMemoryImpl(file, mode, addrHint))
+{
+}
+
+
+SharedMemory::SharedMemory(const SharedMemory& other):
+	_pImpl(other._pImpl)
+{
+	if (_pImpl)
+		_pImpl->duplicate();
+}
+
+
+SharedMemory::~SharedMemory()
+{
+	if (_pImpl)
+		_pImpl->release();
+}
+
+
+SharedMemory& SharedMemory::operator = (const SharedMemory& other)
+{
+	SharedMemory tmp(other);
+	swap(tmp);
+	return *this;
+}
+
+
+char* SharedMemory::begin() const
+{
+	if (_pImpl)
+		return _pImpl->begin();
+	else
+		return 0;
+}
+
+
+char* SharedMemory::end() const
+{
+	if (_pImpl)
+		return _pImpl->end();
+	else
+		return 0;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/SharedMemory_DUMMY.cpp b/base/poco/Foundation/src/SharedMemory_DUMMY.cpp
new file mode 100644
index 00000000000..38586323806
--- /dev/null
+++ b/base/poco/Foundation/src/SharedMemory_DUMMY.cpp
@@ -0,0 +1,36 @@
+//
+// SharedMemoryImpl.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  SharedMemoryImpl
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SharedMemory_DUMMY.h"
+
+
+namespace Poco {
+
+
+SharedMemoryImpl::SharedMemoryImpl(const std::string&, std::size_t, SharedMemory::AccessMode, const void*, bool)
+{
+}
+
+
+SharedMemoryImpl::SharedMemoryImpl(const Poco::File&, SharedMemory::AccessMode, const void*)
+{
+}
+
+
+SharedMemoryImpl::~SharedMemoryImpl()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/SharedMemory_POSIX.cpp b/base/poco/Foundation/src/SharedMemory_POSIX.cpp
new file mode 100644
index 00000000000..edeb4f53662
--- /dev/null
+++ b/base/poco/Foundation/src/SharedMemory_POSIX.cpp
@@ -0,0 +1,134 @@
+//
+// SharedMemoryImpl.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  SharedMemoryImpl
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SharedMemory_POSIX.h"
+#include "Poco/Exception.h"
+#include "Poco/File.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+
+namespace Poco {
+
+
+SharedMemoryImpl::SharedMemoryImpl(const std::string& name, std::size_t size, SharedMemory::AccessMode mode, const void* addrHint, bool server):
+	_size(size),
+	_fd(-1),
+	_address(0),
+	_access(mode),
+	_name("/"),
+	_fileMapped(false),
+	_server(server)
+{
+#if POCO_OS == POCO_OS_HPUX
+	_name.append("tmp/");
+#endif
+
+	_name.append(name);
+
+	int flags = _server ? O_CREAT : 0;
+	if (_access == SharedMemory::AM_WRITE)
+		flags |= O_RDWR;
+	else
+		flags |= O_RDONLY;
+
+	// open the shared memory segment
+	_fd = ::shm_open(_name.c_str(), flags, S_IRUSR | S_IWUSR);
+	if (_fd == -1)
+		throw SystemException("Cannot create shared memory object", _name);
+
+	// now set the correct size for the segment
+	if (_server && -1 == ::ftruncate(_fd, size))
+	{
+		::close(_fd);
+		_fd = -1;
+		::shm_unlink(_name.c_str());
+		throw SystemException("Cannot resize shared memory object", _name);
+	}
+	map(addrHint);
+}
+
+
+SharedMemoryImpl::SharedMemoryImpl(const Poco::File& file, SharedMemory::AccessMode mode, const void* addrHint):
+	_size(0),
+	_fd(-1),
+	_address(0),
+	_access(mode),
+	_name(file.path()),
+	_fileMapped(true),
+	_server(false)
+{
+	if (!file.exists() || !file.isFile())
+		throw FileNotFoundException(file.path());
+
+	_size = file.getSize();
+	int flag = O_RDONLY;
+	if (mode == SharedMemory::AM_WRITE)
+		flag = O_RDWR;
+	_fd = ::open(_name.c_str(), flag);
+	if (-1 == _fd)
+		throw OpenFileException("Cannot open memory mapped file", _name);
+
+	map(addrHint);
+}
+
+
+SharedMemoryImpl::~SharedMemoryImpl()
+{
+	unmap();
+	close();
+}
+
+
+void SharedMemoryImpl::map(const void* addrHint)
+{
+	int access = PROT_READ;
+	if (_access == SharedMemory::AM_WRITE)
+		access |= PROT_WRITE;
+
+	void* addr = ::mmap(const_cast<void*>(addrHint), _size, access, MAP_SHARED, _fd, 0);
+	if (addr == MAP_FAILED)
+		throw SystemException("Cannot map file into shared memory", _name);
+
+	_address = static_cast<char*>(addr);
+}
+
+
+void SharedMemoryImpl::unmap()
+{
+	if (_address)
+	{
+		::munmap(_address, _size);
+	}
+}
+
+
+void SharedMemoryImpl::close()
+{
+	if (_fd != -1)
+	{
+		::close(_fd);
+		_fd = -1;
+	}
+	if (!_fileMapped && _server)
+	{
+		::shm_unlink(_name.c_str());
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/SharedMemory_WIN32.cpp b/base/poco/Foundation/src/SharedMemory_WIN32.cpp
new file mode 100644
index 00000000000..1e86d7d10ed
--- /dev/null
+++ b/base/poco/Foundation/src/SharedMemory_WIN32.cpp
@@ -0,0 +1,168 @@
+//
+// SharedMemoryImpl.cpp
+//
+// Library: Foundation
+// Package: Processes
+// Module:  SharedMemoryImpl
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SharedMemory_WIN32.h"
+#include "Poco/Error.h"
+#include "Poco/Exception.h"
+#include "Poco/File.h"
+#include "Poco/Format.h"
+#if defined (POCO_WIN32_UTF8)
+#include "Poco/UnicodeConverter.h"
+#endif
+#include "Poco/UnWindows.h"
+
+
+namespace Poco {
+
+
+SharedMemoryImpl::SharedMemoryImpl(const std::string& name, std::size_t size, SharedMemory::AccessMode mode, const void*, bool):
+	_name(name),
+	_memHandle(INVALID_HANDLE_VALUE),
+	_fileHandle(INVALID_HANDLE_VALUE),
+	_size(static_cast<DWORD>(size)),
+	_mode(PAGE_READONLY),
+	_address(0)
+{
+	if (mode == SharedMemory::AM_WRITE)
+		_mode = PAGE_READWRITE;
+
+#if defined (POCO_WIN32_UTF8)
+	std::wstring utf16name;
+	UnicodeConverter::toUTF16(_name, utf16name);
+	_memHandle = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL, _mode, 0, _size, utf16name.c_str());
+#else
+	_memHandle = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, _mode, 0, _size, _name.c_str());
+#endif
+
+	if (!_memHandle)
+	{
+		DWORD dwRetVal = GetLastError();
+#if defined (_WIN32_WCE)
+		throw SystemException(format("Cannot create shared memory object %s [Error %d: %s]", _name, static_cast<int>(dwRetVal), Error::getMessage(dwRetVal)));
+#else
+		if (_mode != PAGE_READONLY || dwRetVal != 5)
+			throw SystemException(format("Cannot create shared memory object %s [Error %d: %s]", _name, static_cast<int>(dwRetVal), Error::getMessage(dwRetVal)));
+
+#if defined (POCO_WIN32_UTF8)
+		_memHandle = OpenFileMappingW(PAGE_READONLY, FALSE, utf16name.c_str());
+#else
+		_memHandle = OpenFileMappingA(PAGE_READONLY, FALSE, _name.c_str());
+#endif
+		if (!_memHandle)
+		{
+			dwRetVal = GetLastError();
+			throw SystemException(format("Cannot open shared memory object %s [Error %d: %s]", _name, static_cast<int>(dwRetVal), Error::getMessage(dwRetVal)));
+		}
+#endif 
+	}
+	map();
+}
+
+
+SharedMemoryImpl::SharedMemoryImpl(const Poco::File& file, SharedMemory::AccessMode mode, const void*):
+	_name(file.path()),
+	_memHandle(INVALID_HANDLE_VALUE),
+	_fileHandle(INVALID_HANDLE_VALUE),
+	_size(0),
+	_mode(PAGE_READONLY),
+	_address(0)
+{
+	if (!file.exists() || !file.isFile())
+		throw FileNotFoundException(_name);
+
+	_size = static_cast<DWORD>(file.getSize());
+
+	DWORD shareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
+	DWORD fileMode  = GENERIC_READ;
+
+	if (mode == SharedMemory::AM_WRITE)
+	{
+		_mode = PAGE_READWRITE;
+		fileMode |= GENERIC_WRITE;
+	}
+
+#if defined (POCO_WIN32_UTF8)
+	std::wstring utf16name;
+	UnicodeConverter::toUTF16(_name, utf16name);
+	_fileHandle = CreateFileW(utf16name.c_str(), fileMode, shareMode, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+#else
+	_fileHandle = CreateFileA(_name.c_str(), fileMode, shareMode, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+#endif
+
+	if (_fileHandle == INVALID_HANDLE_VALUE)
+		throw OpenFileException("Cannot open memory mapped file", _name);
+
+	_memHandle = CreateFileMapping(_fileHandle, NULL, _mode, 0, 0, NULL);
+	if (!_memHandle)
+	{
+		DWORD dwRetVal = GetLastError();
+		CloseHandle(_fileHandle);
+		_fileHandle = INVALID_HANDLE_VALUE;
+		throw SystemException(format("Cannot map file into shared memory %s [Error %d: %s]", _name, (int)dwRetVal, Error::getMessage(dwRetVal)));
+	}
+	map();
+}
+
+
+SharedMemoryImpl::~SharedMemoryImpl()
+{
+	unmap();
+	close();
+}
+
+
+void SharedMemoryImpl::map()
+{
+	DWORD access = FILE_MAP_READ;
+	if (_mode == PAGE_READWRITE)
+		access = FILE_MAP_WRITE;
+	LPVOID addr = MapViewOfFile(_memHandle, access, 0, 0, _size);
+	if (!addr)
+	{
+		DWORD dwRetVal = GetLastError();
+		throw SystemException(format("Cannot map shared memory object %s [Error %d: %s]", _name, (int)dwRetVal, Error::getMessage(dwRetVal)));
+	}
+
+	_address = static_cast<char*>(addr);
+}
+
+
+void SharedMemoryImpl::unmap()
+{
+	if (_address)
+	{
+		UnmapViewOfFile(_address);
+		_address = 0;
+		return;
+	}
+}
+
+
+void SharedMemoryImpl::close()
+{
+	if (_memHandle != INVALID_HANDLE_VALUE)
+	{
+		CloseHandle(_memHandle);
+		_memHandle = INVALID_HANDLE_VALUE;
+	}
+
+	if (_fileHandle != INVALID_HANDLE_VALUE)
+	{
+		CloseHandle(_fileHandle);
+		_fileHandle = INVALID_HANDLE_VALUE;
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/SignalHandler.cpp b/base/poco/Foundation/src/SignalHandler.cpp
new file mode 100644
index 00000000000..eaa1dc7ec8c
--- /dev/null
+++ b/base/poco/Foundation/src/SignalHandler.cpp
@@ -0,0 +1,111 @@
+//
+// SignalHandler.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  SignalHandler
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SignalHandler.h"
+
+
+#if defined(POCO_OS_FAMILY_UNIX) && !defined(POCO_VXWORKS)
+
+
+#include "Poco/Thread.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/Exception.h"
+#include <cstdlib>
+#include <signal.h>
+
+
+namespace Poco {
+
+
+SignalHandler::JumpBufferVec SignalHandler::_jumpBufferVec;
+
+
+SignalHandler::SignalHandler()
+{
+	JumpBufferVec& jbv = jumpBufferVec();
+	JumpBuffer buf;
+	jbv.push_back(buf);
+}
+
+
+SignalHandler::~SignalHandler()
+{
+	jumpBufferVec().pop_back();
+}
+
+
+sigjmp_buf& SignalHandler::jumpBuffer()
+{
+	return jumpBufferVec().back().buf;
+}
+
+
+void SignalHandler::throwSignalException(int sig)
+{
+	switch (sig)
+	{
+	case SIGILL:
+		throw SignalException("Illegal instruction");
+	case SIGBUS:
+		throw SignalException("Bus error");
+	case SIGSEGV:
+		throw SignalException("Segmentation violation");
+	case SIGSYS:
+		throw SignalException("Invalid system call");
+	default:
+		throw SignalException(NumberFormatter::formatHex(sig));
+	}
+}
+
+
+void SignalHandler::install()
+{
+#ifndef POCO_NO_SIGNAL_HANDLER
+	struct sigaction sa;
+	sa.sa_handler = handleSignal;
+	sa.sa_flags   = 0;
+	sigemptyset(&sa.sa_mask);
+	sigaction(SIGILL,  &sa, 0);
+	sigaction(SIGBUS,  &sa, 0);
+	sigaction(SIGSEGV, &sa, 0);
+	sigaction(SIGSYS,  &sa, 0);
+#endif
+}
+
+
+void SignalHandler::handleSignal(int sig)
+{
+	JumpBufferVec& jb = jumpBufferVec();
+	if (!jb.empty())
+		siglongjmp(jb.back().buf, sig);
+		
+	// Abort if no jump buffer registered
+	std::abort();
+}
+
+
+SignalHandler::JumpBufferVec& SignalHandler::jumpBufferVec()
+{
+	ThreadImpl* pThread = ThreadImpl::currentImpl();
+	if (pThread)
+		return pThread->_jumpBufferVec;
+	else
+		return _jumpBufferVec;
+}
+
+
+} // namespace Poco
+
+
+#endif // POCO_OS_FAMILY_UNIX
diff --git a/base/poco/Foundation/src/SimpleFileChannel.cpp b/base/poco/Foundation/src/SimpleFileChannel.cpp
new file mode 100644
index 00000000000..81a0deb12d1
--- /dev/null
+++ b/base/poco/Foundation/src/SimpleFileChannel.cpp
@@ -0,0 +1,227 @@
+//
+// SimpleFileChannel.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  SimpleFileChannel
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SimpleFileChannel.h"
+#include "Poco/LogFile.h"
+#include "Poco/File.h"
+#include "Poco/Message.h"
+#include "Poco/Exception.h"
+#include "Poco/Ascii.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+
+
+const std::string SimpleFileChannel::PROP_PATH          = "path";
+const std::string SimpleFileChannel::PROP_SECONDARYPATH = "secondaryPath";
+const std::string SimpleFileChannel::PROP_ROTATION      = "rotation";
+const std::string SimpleFileChannel::PROP_FLUSH         = "flush";
+
+
+SimpleFileChannel::SimpleFileChannel(): 
+	_limit(0),
+	_flush(true),
+	_pFile(0)
+{
+}
+
+
+SimpleFileChannel::SimpleFileChannel(const std::string& path):
+	_path(path),
+	_secondaryPath(path + ".0"),
+	_limit(0),
+	_flush(true),
+	_pFile(0)
+{
+}
+
+
+SimpleFileChannel::~SimpleFileChannel()
+{
+	try
+	{
+		close();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void SimpleFileChannel::open()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	if (!_pFile)
+	{
+		File primary(_path);
+		File secondary(_secondaryPath);
+		Timestamp pt = primary.exists() ? primary.getLastModified() : 0;
+		Timestamp st = secondary.exists() ? secondary.getLastModified() : 0;
+		std::string path;
+		if (pt >= st)
+			path = _path;
+		else
+			path = _secondaryPath;
+		_pFile = new LogFile(path);
+	}
+}
+
+
+void SimpleFileChannel::close()
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	delete _pFile;
+	_pFile = 0;
+}
+
+
+void SimpleFileChannel::log(const Message& msg)
+{
+	open();
+
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (_limit > 0 && _pFile->size() >= _limit)
+	{
+		rotate();
+	}
+	_pFile->write(msg.getText(), _flush);
+}
+
+	
+void SimpleFileChannel::setProperty(const std::string& name, const std::string& value)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (name == PROP_PATH)
+	{
+		_path = value;
+		if (_secondaryPath.empty())
+			_secondaryPath = _path + ".0";
+	}
+	else if (name == PROP_SECONDARYPATH)
+		_secondaryPath = value;
+	else if (name == PROP_ROTATION)
+		setRotation(value);
+	else if (name == PROP_FLUSH)
+		setFlush(value);
+	else
+		Channel::setProperty(name, value);
+}
+
+
+std::string SimpleFileChannel::getProperty(const std::string& name) const
+{
+	if (name == PROP_PATH)
+		return _path;
+	else if (name == PROP_SECONDARYPATH)
+		return _secondaryPath;
+	else if (name == PROP_ROTATION)
+		return _rotation;
+	else if (name == PROP_FLUSH)
+		return std::string(_flush ? "true" : "false");
+	else
+		return Channel::getProperty(name);
+}
+
+
+Timestamp SimpleFileChannel::creationDate() const
+{
+	if (_pFile)
+		return _pFile->creationDate();
+	else
+		return 0;
+}
+
+	
+UInt64 SimpleFileChannel::size() const
+{
+	if (_pFile)
+		return _pFile->size();
+	else
+		return 0;
+}
+
+
+const std::string& SimpleFileChannel::path() const
+{
+	return _path;
+}
+
+
+const std::string& SimpleFileChannel::secondaryPath() const
+{
+	return _secondaryPath;
+}
+
+
+void SimpleFileChannel::setRotation(const std::string& rotation)
+{
+	std::string::const_iterator it  = rotation.begin();
+	std::string::const_iterator end = rotation.end();
+	UInt64 n = 0;
+	while (it != end && Ascii::isSpace(*it)) ++it;
+	while (it != end && Ascii::isDigit(*it)) { n *= 10; n += *it++ - '0'; }
+	while (it != end && Ascii::isSpace(*it)) ++it;
+	std::string unit;
+	while (it != end && Ascii::isAlpha(*it)) unit += *it++;
+	
+	if (unit == "K")
+		_limit = n*1024;
+	else if (unit == "M")
+		_limit = n*1024*1024;
+	else if (unit.empty())
+		_limit = n;
+	else if (unit == "never")
+		_limit = 0;
+	else
+		throw InvalidArgumentException("rotation", rotation);
+	_rotation = rotation;
+}
+
+
+void SimpleFileChannel::setFlush(const std::string& flush)
+{
+	_flush = icompare(flush, "true") == 0;
+}
+
+
+void SimpleFileChannel::rotate()
+{
+	std::string newPath;
+	if (_pFile->path() == _path)
+		newPath = _secondaryPath;
+	else
+		newPath = _path;
+	File f(newPath);
+	if (f.exists())
+	{
+		try
+		{
+			f.remove();
+		}
+		catch (...)
+		{
+		}
+	}
+	delete _pFile;
+	_pFile = new LogFile(newPath);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/SortedDirectoryIterator.cpp b/base/poco/Foundation/src/SortedDirectoryIterator.cpp
new file mode 100644
index 00000000000..3d2a84ef82f
--- /dev/null
+++ b/base/poco/Foundation/src/SortedDirectoryIterator.cpp
@@ -0,0 +1,122 @@
+//
+// SortedDirectoryIterator.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  DirectoryIterator
+//
+// Copyright (c) 2004-2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+#include "Poco/SortedDirectoryIterator.h"
+#include <algorithm>
+
+
+namespace Poco {
+
+
+SortedDirectoryIterator::SortedDirectoryIterator()
+	: DirectoryIterator(), _is_finished(true)
+{
+}
+
+
+SortedDirectoryIterator::SortedDirectoryIterator(const std::string& path)
+	: DirectoryIterator(path), _is_finished(false)
+{
+	scan();
+	next();
+}
+
+
+SortedDirectoryIterator::SortedDirectoryIterator(const DirectoryIterator& iterator)
+	: DirectoryIterator(iterator), _is_finished(false)
+{
+	scan();
+	next();
+}
+
+
+SortedDirectoryIterator::SortedDirectoryIterator(const File& file)
+	: DirectoryIterator(file), _is_finished(false)
+{
+	scan();
+	next();
+}
+
+
+SortedDirectoryIterator::SortedDirectoryIterator(const Path& path)
+	: DirectoryIterator(path), _is_finished(false)
+{
+	scan();
+	next();
+}
+
+
+SortedDirectoryIterator::~SortedDirectoryIterator()
+{
+}
+
+
+SortedDirectoryIterator& SortedDirectoryIterator::operator ++()
+{
+	if (!_is_finished)
+	{
+		next();
+	}
+	return *this;
+}
+
+
+void SortedDirectoryIterator::scan()
+{
+	DirectoryIterator end_it;
+	while (*this != end_it)
+	{
+		bool isDir = false;
+		try
+		{
+			isDir = (*this)->isDirectory();
+		}
+		catch (...) {}
+		if (isDir)
+			_directories.push_back(_path.toString());
+		else
+			_files.push_back(_path.toString());
+
+		DirectoryIterator::operator++();
+	}
+
+	std::sort(_directories.begin(), _directories.end());
+	std::sort(_files.begin(), _files.end());
+}
+
+
+void SortedDirectoryIterator::next()
+{
+	DirectoryIterator end_it;
+	if (!_directories.empty())
+	{
+		_path.assign(_directories.front());
+		_directories.pop_front();
+		_file = _path;
+	}
+	else if (!_files.empty())
+	{
+		_path.assign(_files.front());
+		_files.pop_front();
+		_file = _path;
+	}
+	else
+	{
+		_is_finished = true;
+		_path = end_it.path();
+		_file = _path;
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/SplitterChannel.cpp b/base/poco/Foundation/src/SplitterChannel.cpp
new file mode 100644
index 00000000000..69ba36a2409
--- /dev/null
+++ b/base/poco/Foundation/src/SplitterChannel.cpp
@@ -0,0 +1,113 @@
+//
+// SplitterChannel.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  SplitterChannel
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SplitterChannel.h"
+#include "Poco/LoggingRegistry.h"
+#include "Poco/StringTokenizer.h"
+
+
+namespace Poco {
+
+
+SplitterChannel::SplitterChannel()
+{
+}
+
+
+SplitterChannel::~SplitterChannel()
+{
+	try
+	{
+		close();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void SplitterChannel::addChannel(Channel* pChannel)
+{
+	poco_check_ptr (pChannel);
+
+	FastMutex::ScopedLock lock(_mutex);
+	
+	pChannel->duplicate();
+	_channels.push_back(pChannel);
+}
+
+
+void SplitterChannel::removeChannel(Channel* pChannel)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	for (ChannelVec::iterator it = _channels.begin(); it != _channels.end(); ++it)
+	{
+		if (*it == pChannel)
+		{
+			pChannel->release();
+			_channels.erase(it);
+			break;
+		}
+	}
+}
+
+
+void SplitterChannel::setProperty(const std::string& name, const std::string& value)
+{
+	if (name.compare(0, 7, "channel") == 0)
+	{
+		StringTokenizer tokenizer(value, ",;", StringTokenizer::TOK_IGNORE_EMPTY | StringTokenizer::TOK_TRIM);
+		for (StringTokenizer::Iterator it = tokenizer.begin(); it != tokenizer.end(); ++it)
+		{
+			addChannel(LoggingRegistry::defaultRegistry().channelForName(*it));
+		}
+	}
+	else Channel::setProperty(name, value);
+}
+
+
+void SplitterChannel::log(const Message& msg)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	for (ChannelVec::iterator it = _channels.begin(); it != _channels.end(); ++it)
+	{
+		(*it)->log(msg);
+	}
+}
+
+
+void SplitterChannel::close()
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	for (ChannelVec::iterator it = _channels.begin(); it != _channels.end(); ++it)
+	{
+		(*it)->release();
+	}
+	_channels.clear();
+}
+
+
+int SplitterChannel::count() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	return (int) _channels.size();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Stopwatch.cpp b/base/poco/Foundation/src/Stopwatch.cpp
new file mode 100644
index 00000000000..4ce02e577b5
--- /dev/null
+++ b/base/poco/Foundation/src/Stopwatch.cpp
@@ -0,0 +1,60 @@
+//
+// Stopwatch.cpp
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  Stopwatch
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Stopwatch.h"
+
+
+namespace Poco {
+
+
+Stopwatch::Stopwatch(): _elapsed(0), _running(false)
+{
+}
+
+
+Stopwatch::~Stopwatch()
+{
+}
+
+
+Clock::ClockDiff Stopwatch::elapsed() const
+{
+	if (_running)
+	{
+		Clock current;
+		return _elapsed + (current - _start);
+	}
+	else
+	{
+		return _elapsed;
+	}
+}
+
+
+void Stopwatch::reset()
+{
+	_elapsed = 0;
+	_running = false;
+}
+
+
+void Stopwatch::restart()
+{
+	_elapsed = 0;
+	_start.update();
+	_running = true;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/StreamChannel.cpp b/base/poco/Foundation/src/StreamChannel.cpp
new file mode 100644
index 00000000000..817c047a65a
--- /dev/null
+++ b/base/poco/Foundation/src/StreamChannel.cpp
@@ -0,0 +1,40 @@
+//
+// StreamChannel.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  StreamChannel
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/StreamChannel.h"
+#include "Poco/Message.h"
+
+
+namespace Poco {
+
+
+StreamChannel::StreamChannel(std::ostream& str): _str(str)
+{
+}
+
+
+StreamChannel::~StreamChannel()
+{
+}
+
+
+void StreamChannel::log(const Message& msg)
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	_str << msg.getText() << std::endl;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/StreamConverter.cpp b/base/poco/Foundation/src/StreamConverter.cpp
new file mode 100644
index 00000000000..452abd7f2fb
--- /dev/null
+++ b/base/poco/Foundation/src/StreamConverter.cpp
@@ -0,0 +1,192 @@
+//
+// StreamConverter.cpp
+//
+// Library: Foundation
+// Package: Text
+// Module:  StreamConverter
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/StreamConverter.h"
+#include "Poco/TextEncoding.h"
+
+
+namespace Poco {
+
+
+StreamConverterBuf::StreamConverterBuf(std::istream& istr, const TextEncoding& inEncoding, const TextEncoding& outEncoding, int defaultChar):
+	_pIstr(&istr),
+	_pOstr(0),
+	_inEncoding(inEncoding),
+	_outEncoding(outEncoding),
+	_defaultChar(defaultChar),
+	_sequenceLength(0),
+	_pos(0),
+	_errors(0)
+{
+}
+
+
+StreamConverterBuf::StreamConverterBuf(std::ostream& ostr, const TextEncoding& inEncoding, const TextEncoding& outEncoding, int defaultChar):
+	_pIstr(0),
+	_pOstr(&ostr),
+	_inEncoding(inEncoding),
+	_outEncoding(outEncoding),
+	_defaultChar(defaultChar),
+	_sequenceLength(0),
+	_pos(0),
+	_errors(0)
+{
+}
+
+
+StreamConverterBuf::~StreamConverterBuf()
+{
+}
+
+
+int StreamConverterBuf::readFromDevice()
+{
+	poco_assert_dbg (_pIstr);
+
+	if (_pos < _sequenceLength) return _buffer[_pos++];
+
+	_pos = 0;
+	_sequenceLength = 0;
+	int c = _pIstr->get();
+	if (c == -1) return -1;	
+
+	poco_assert (c < 256);
+	int uc;
+	_buffer [0] = (unsigned char) c;
+	int n = _inEncoding.queryConvert(_buffer, 1);
+	int read = 1;
+
+	while (-1 > n)
+	{
+		poco_assert_dbg(-n <= sizeof(_buffer));
+		_pIstr->read((char*) _buffer + read, -n - read);
+		read = -n;
+		n = _inEncoding.queryConvert(_buffer, -n);
+	}
+
+	if (-1 >= n)
+	{
+		uc = _defaultChar;
+		++_errors;
+	}
+	else
+	{
+		uc = n;
+	}
+
+	_sequenceLength = _outEncoding.convert(uc, _buffer, sizeof(_buffer));
+	if (_sequenceLength == 0)
+		_sequenceLength = _outEncoding.convert(_defaultChar, _buffer, sizeof(_buffer));
+	if (_sequenceLength == 0)
+		return -1;
+	else
+		return _buffer[_pos++];
+}
+
+
+int StreamConverterBuf::writeToDevice(char c)
+{
+	poco_assert_dbg (_pOstr);
+
+	_buffer[_pos++] = (unsigned char) c;
+	if (_sequenceLength == 0 || _sequenceLength == _pos)
+	{
+		int n = _inEncoding.queryConvert(_buffer, _pos);
+		if (-1 <= n)
+		{
+			int uc = n;
+			if (-1 == n)
+			{
+				++_errors;
+				return -1;
+			}
+			int n = _outEncoding.convert(uc, _buffer, sizeof(_buffer));
+			if (n == 0) n = _outEncoding.convert(_defaultChar, _buffer, sizeof(_buffer));
+			poco_assert_dbg (n <= sizeof(_buffer));
+			_pOstr->write((char*) _buffer, n);
+			_sequenceLength = 0;
+			_pos = 0;
+		}
+		else
+		{
+			_sequenceLength = -n;
+		}
+	}
+
+	return charToInt(c);
+}
+
+
+int StreamConverterBuf::errors() const
+{
+	return _errors;
+}
+
+
+StreamConverterIOS::StreamConverterIOS(std::istream& istr, const TextEncoding& inEncoding, const TextEncoding& outEncoding, int defaultChar): 
+	_buf(istr, inEncoding, outEncoding, defaultChar)
+{
+	poco_ios_init(&_buf);
+}
+
+
+StreamConverterIOS::StreamConverterIOS(std::ostream& ostr, const TextEncoding& inEncoding, const TextEncoding& outEncoding, int defaultChar): 
+	_buf(ostr, inEncoding, outEncoding, defaultChar)
+{
+	poco_ios_init(&_buf);
+}
+
+
+StreamConverterIOS::~StreamConverterIOS()
+{
+}
+
+
+StreamConverterBuf* StreamConverterIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+int StreamConverterIOS::errors() const
+{
+	return _buf.errors();
+}
+
+
+InputStreamConverter::InputStreamConverter(std::istream& istr, const TextEncoding& inEncoding, const TextEncoding& outEncoding, int defaultChar): 
+	StreamConverterIOS(istr, inEncoding, outEncoding, defaultChar),
+	std::istream(&_buf)
+{
+}
+
+
+InputStreamConverter::~InputStreamConverter()
+{
+}
+
+
+OutputStreamConverter::OutputStreamConverter(std::ostream& ostr, const TextEncoding& inEncoding, const TextEncoding& outEncoding, int defaultChar): 
+	StreamConverterIOS(ostr, inEncoding, outEncoding, defaultChar),
+	std::ostream(&_buf)
+{
+}
+
+
+OutputStreamConverter::~OutputStreamConverter()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/StreamCopier.cpp b/base/poco/Foundation/src/StreamCopier.cpp
new file mode 100644
index 00000000000..6f34cc233a2
--- /dev/null
+++ b/base/poco/Foundation/src/StreamCopier.cpp
@@ -0,0 +1,150 @@
+//
+// StreamCopier.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  StreamCopier
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/StreamCopier.h"
+#include "Poco/Buffer.h"
+
+
+namespace Poco {
+
+
+std::streamsize StreamCopier::copyStream(std::istream& istr, std::ostream& ostr, std::size_t bufferSize)
+{
+	poco_assert (bufferSize > 0);
+
+	Buffer<char> buffer(bufferSize);
+	std::streamsize len = 0;
+	istr.read(buffer.begin(), bufferSize);
+	std::streamsize n = istr.gcount();
+	while (n > 0)
+	{
+		len += n;
+		ostr.write(buffer.begin(), n);
+		if (istr && ostr)
+		{
+			istr.read(buffer.begin(), bufferSize);
+			n = istr.gcount();
+		}
+		else n = 0;
+	}
+	return len;
+}
+
+
+#if defined(POCO_HAVE_INT64)
+Poco::UInt64 StreamCopier::copyStream64(std::istream& istr, std::ostream& ostr, std::size_t bufferSize)
+{
+	poco_assert (bufferSize > 0);
+
+	Buffer<char> buffer(bufferSize);
+	Poco::UInt64 len = 0;
+	istr.read(buffer.begin(), bufferSize);
+	std::streamsize n = istr.gcount();
+	while (n > 0)
+	{
+		len += n;
+		ostr.write(buffer.begin(), n);
+		if (istr && ostr)
+		{
+			istr.read(buffer.begin(), bufferSize);
+			n = istr.gcount();
+		}
+		else n = 0;
+	}
+	return len;
+}
+#endif
+
+
+std::streamsize StreamCopier::copyToString(std::istream& istr, std::string& str, std::size_t bufferSize)
+{
+	poco_assert (bufferSize > 0);
+
+	Buffer<char> buffer(bufferSize);
+	std::streamsize len = 0;
+	istr.read(buffer.begin(), bufferSize);
+	std::streamsize n = istr.gcount();
+	while (n > 0)
+	{
+		len += n;
+		str.append(buffer.begin(), static_cast<std::string::size_type>(n));
+		if (istr)
+		{
+			istr.read(buffer.begin(), bufferSize);
+			n = istr.gcount();
+		}
+		else n = 0;
+	}
+	return len;
+}
+
+
+#if defined(POCO_HAVE_INT64)
+Poco::UInt64 StreamCopier::copyToString64(std::istream& istr, std::string& str, std::size_t bufferSize)
+{
+	poco_assert (bufferSize > 0);
+
+	Buffer<char> buffer(bufferSize);
+	Poco::UInt64 len = 0;
+	istr.read(buffer.begin(), bufferSize);
+	std::streamsize n = istr.gcount();
+	while (n > 0)
+	{
+		len += n;
+		str.append(buffer.begin(), static_cast<std::string::size_type>(n));
+		if (istr)
+		{
+			istr.read(buffer.begin(), bufferSize);
+			n = istr.gcount();
+		}
+		else n = 0;
+	}
+	return len;
+}
+#endif
+
+
+std::streamsize StreamCopier::copyStreamUnbuffered(std::istream& istr, std::ostream& ostr)
+{
+	char c = 0;
+	std::streamsize len = 0;
+	istr.get(c);
+	while (istr && ostr)
+	{
+		++len;
+		ostr.put(c);
+		istr.get(c);
+	}
+	return len;
+}
+
+
+#if defined(POCO_HAVE_INT64)
+Poco::UInt64 StreamCopier::copyStreamUnbuffered64(std::istream& istr, std::ostream& ostr)
+{
+	char c = 0;
+	Poco::UInt64 len = 0;
+	istr.get(c);
+	while (istr && ostr)
+	{
+		++len;
+		ostr.put(c);
+		istr.get(c);
+	}
+	return len;
+}
+#endif
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/StreamTokenizer.cpp b/base/poco/Foundation/src/StreamTokenizer.cpp
new file mode 100644
index 00000000000..1b6e936274e
--- /dev/null
+++ b/base/poco/Foundation/src/StreamTokenizer.cpp
@@ -0,0 +1,105 @@
+//
+// StreamTokenizer.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  StreamTokenizer
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/StreamTokenizer.h"
+
+
+namespace Poco {
+
+
+StreamTokenizer::StreamTokenizer():
+	_pIstr(0)
+{
+}
+
+
+StreamTokenizer::StreamTokenizer(std::istream& istr):
+	_pIstr(&istr)
+{
+}
+
+
+StreamTokenizer::~StreamTokenizer()
+{
+	for (TokenVec::iterator it = _tokens.begin(); it != _tokens.end(); ++it)
+	{
+		delete it->pToken;
+	}
+}
+
+
+void StreamTokenizer::attachToStream(std::istream& istr)
+{
+	_pIstr = &istr;
+}
+
+
+void StreamTokenizer::addToken(Token* pToken)
+{
+	poco_check_ptr (pToken);
+
+	TokenInfo ti;
+	ti.pToken = pToken;
+	ti.ignore = (pToken->tokenClass() == Token::COMMENT_TOKEN || pToken->tokenClass() == Token::WHITESPACE_TOKEN);
+	_tokens.push_back(ti);
+}
+
+
+void StreamTokenizer::addToken(Token* pToken, bool ignore)
+{
+	poco_check_ptr (pToken);
+
+	TokenInfo ti;
+	ti.pToken = pToken;
+	ti.ignore = ignore;
+	_tokens.push_back(ti);
+}
+
+	
+const Token* StreamTokenizer::next()
+{
+	poco_check_ptr (_pIstr);
+	
+	static const int eof = std::char_traits<char>::eof();
+
+	int first = _pIstr->get();
+	TokenVec::const_iterator it = _tokens.begin();
+	while (first != eof && it != _tokens.end())
+	{
+		const TokenInfo& ti = *it;
+		if (ti.pToken->start((char) first, *_pIstr))
+		{
+			ti.pToken->finish(*_pIstr);
+			if (ti.ignore) 
+			{
+				first = _pIstr->get();
+				it = _tokens.begin();
+			}
+			else return ti.pToken;
+		}
+		else ++it;
+	}
+	if (first == eof)
+	{
+		return &_eofToken;
+	}
+	else
+	{
+		_invalidToken.start((char) first, *_pIstr);
+		return &_invalidToken;
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/String.cpp b/base/poco/Foundation/src/String.cpp
new file mode 100644
index 00000000000..91b21087ea8
--- /dev/null
+++ b/base/poco/Foundation/src/String.cpp
@@ -0,0 +1,240 @@
+//
+// String.h
+//
+// Library: Foundation
+// Package: Core
+// Module:  String
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/String.h"
+
+
+namespace Poco {
+
+
+#if defined(POCO_NO_TEMPLATE_ICOMPARE)
+
+
+int icompare(const std::string& str, std::string::size_type pos, std::string::size_type n, std::string::const_iterator it2, std::string::const_iterator end2)
+{
+	std::string::size_type sz = str.size();
+	if (pos > sz) pos = sz;
+	if (pos + n > sz) n = sz - pos;
+	std::string::const_iterator it1  = str.begin() + pos; 
+	std::string::const_iterator end1 = str.begin() + pos + n;
+	while (it1 != end1 && it2 != end2)
+	{
+	std::string::value_type c1 = Ascii::toLower(*it1);
+	std::string::value_type c2 = Ascii::toLower(*it2);
+	if (c1 < c2)
+		return -1;
+	else if (c1 > c2)
+		return 1;
+	++it1; ++it2;
+	}
+
+	if (it1 == end1)
+		return it2 == end2 ? 0 : -1;
+	else
+	return 1;
+}
+
+
+int icompare(const std::string& str1, const std::string& str2)
+{
+	return icompare(str1, 0, str1.size(), str2.begin(), str2.end());
+}
+
+
+int icompare(const std::string& str1, std::string::size_type n1, const std::string& str2, std::string::size_type n2)
+{
+	if (n2 > str2.size()) n2 = str2.size();
+	return icompare(str1, 0, n1, str2.begin(), str2.begin() + n2);
+}
+
+
+int icompare(const std::string& str1, std::string::size_type n, const std::string& str2)
+{
+	if (n > str2.size()) n = str2.size();
+	return icompare(str1, 0, n, str2.begin(), str2.begin() + n);
+}
+
+
+int icompare(const std::string& str1, std::string::size_type pos, std::string::size_type n, const std::string& str2)
+{
+	return icompare(str1, pos, n, str2.begin(), str2.end());
+}
+
+
+int icompare(const std::string& str1, std::string::size_type pos1, std::string::size_type n1, const std::string& str2, std::string::size_type pos2, std::string::size_type n2)
+{
+	std::string::size_type sz2 = str2.size();
+	if (pos2 > sz2) pos2 = sz2;
+	if (pos2 + n2 > sz2) n2 = sz2 - pos2;
+	return icompare(str1, pos1, n1, str2.begin() + pos2, str2.begin() + pos2 + n2);
+}
+
+
+int icompare(const std::string& str1, std::string::size_type pos1, std::string::size_type n, const std::string& str2, std::string::size_type pos2)
+{
+	std::string::size_type sz2 = str2.size();
+	if (pos2 > sz2) pos2 = sz2;
+	if (pos2 + n > sz2) n = sz2 - pos2;
+	return icompare(str1, pos1, n, str2.begin() + pos2, str2.begin() + pos2 + n);
+}
+
+
+int icompare(const std::string& str, std::string::size_type pos, std::string::size_type n, const std::string::value_type* ptr)
+{
+	poco_check_ptr (ptr);
+	std::string::size_type sz = str.size();
+	if (pos > sz) pos = sz;
+	if (pos + n > sz) n = sz - pos;
+	std::string::const_iterator it  = str.begin() + pos; 
+	std::string::const_iterator end = str.begin() + pos + n;
+	while (it != end && *ptr)
+	{
+	std::string::value_type c1 = Ascii::toLower(*it);
+	std::string::value_type c2 = Ascii::toLower(*ptr);
+	if (c1 < c2)
+		return -1;
+	else if (c1 > c2)
+		return 1;
+	++it; ++ptr;
+	}
+
+	if (it == end)
+		return *ptr == 0 ? 0 : -1;
+	else
+	return 1;
+}
+
+
+int icompare(const std::string& str, std::string::size_type pos, const std::string::value_type* ptr)
+{
+	return icompare(str, pos, str.size() - pos, ptr);
+}
+
+
+int icompare(const std::string& str, const std::string::value_type* ptr)
+{
+	return icompare(str, 0, str.size(), ptr);
+}
+
+
+std::string replace(const std::string& str, const std::string& from, const std::string& to, std::string::size_type start)
+{
+	std::string result(str);
+	replaceInPlace(result, from, to, start);
+	return result;
+}
+
+
+std::string replace(const std::string& str, const std::string::value_type* from, const std::string::value_type* to, std::string::size_type start)
+{
+	std::string result(str);
+	replaceInPlace(result, from, to, start);
+	return result;
+}
+
+
+std::string replace(const std::string& str, const std::string::value_type from, const std::string::value_type to, std::string::size_type start)
+{
+	std::string result(str);
+	replaceInPlace(result, from, to, start);
+	return result;
+}
+
+
+std::string remove(const std::string& str, const std::string::value_type ch, std::string::size_type start)
+{
+	std::string result(str);
+	replaceInPlace(result, ch, 0, start);
+	return result;
+}
+
+	
+std::string& replaceInPlace(std::string& str, const std::string& from, const std::string& to, std::string::size_type start)
+{
+	poco_assert (from.size() > 0);
+	
+	std::string result;
+	std::string::size_type pos = 0;
+	result.append(str, 0, start);
+	do
+	{
+		pos = str.find(from, start);
+		if (pos != std::string::npos)
+		{
+			result.append(str, start, pos - start);
+			result.append(to);
+			start = pos + from.length();
+		}
+		else result.append(str, start, str.size() - start);
+	}
+	while (pos != std::string::npos);
+	str.swap(result);
+	return str;
+}
+
+
+std::string& replaceInPlace(std::string& str, const std::string::value_type* from, const std::string::value_type* to, std::string::size_type start)
+{
+	poco_assert (*from);
+
+	std::string result;
+	std::string::size_type pos = 0;
+	std::string::size_type fromLen = std::strlen(from);
+	result.append(str, 0, start);
+	do
+	{
+		pos = str.find(from, start);
+		if (pos != std::string::npos)
+		{
+			result.append(str, start, pos - start);
+			result.append(to);
+			start = pos + fromLen;
+		}
+		else result.append(str, start, str.size() - start);
+	}
+	while (pos != std::string::npos);
+	str.swap(result);
+	return str;
+}
+
+
+std::string& replaceInPlace(std::string& str, const std::string::value_type from, const std::string::value_type to, std::string::size_type start)
+{
+	if (from == to) return str;
+
+	std::string::size_type pos = 0;
+	do
+	{
+		pos = str.find(from, start);
+		if (pos != std::string::npos)
+		{
+			if (to) str[pos] = to;
+			else str.erase(pos, 1);
+		}
+	} while (pos != std::string::npos);
+
+	return str;
+}
+
+
+std::string& removeInPlace(std::string& str, const std::string::value_type ch, std::string::size_type start)
+{
+	return replaceInPlace(str, ch, 0, start);
+}
+
+
+#endif
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/StringTokenizer.cpp b/base/poco/Foundation/src/StringTokenizer.cpp
new file mode 100644
index 00000000000..dea7f07d57f
--- /dev/null
+++ b/base/poco/Foundation/src/StringTokenizer.cpp
@@ -0,0 +1,135 @@
+//
+// StringTokenizer.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:	StringTokenizer
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/StringTokenizer.h"
+#include "Poco/Ascii.h"
+#include <algorithm>
+
+
+namespace Poco {
+
+
+StringTokenizer::StringTokenizer(const std::string& str, const std::string& separators, int options)
+{
+	std::string::const_iterator it = str.begin();
+	std::string::const_iterator end = str.end();
+	std::string token;
+	bool doTrim = ((options & TOK_TRIM) != 0);
+	bool ignoreEmpty = ((options & TOK_IGNORE_EMPTY) != 0);
+	bool lastToken = false;
+
+	for (; it != end; ++it)
+	{
+		if (separators.find(*it) != std::string::npos) 
+		{
+			if (doTrim) trim(token);
+			if (!token.empty() || !ignoreEmpty) _tokens.push_back(token);
+			if (!ignoreEmpty) lastToken = true;
+			token.clear();
+		}
+		else
+		{
+			token += *it;
+			lastToken = false;
+		}
+	}
+
+	if (!token.empty())
+	{
+		if (doTrim) trim(token);
+		if (!token.empty() || !ignoreEmpty) _tokens.push_back(token);
+	}
+	else if (lastToken) 
+	{
+		_tokens.push_back(std::string());
+	}
+}
+
+
+StringTokenizer::~StringTokenizer()
+{
+}
+
+
+void StringTokenizer::trim(std::string& token)
+{
+	std::string::size_type front = 0;
+	std::string::size_type back = 0;
+	std::string::size_type length = token.length();
+	std::string::const_iterator tIt = token.begin();
+	std::string::const_iterator tEnd = token.end();
+	for (; tIt != tEnd; ++tIt, ++front)
+	{
+		if (!Ascii::isSpace(*tIt)) break;
+	}
+	if (tIt != tEnd)
+	{
+		std::string::const_reverse_iterator tRit = token.rbegin();
+		std::string::const_reverse_iterator tRend = token.rend();
+		for (; tRit != tRend; ++tRit, ++back)
+		{
+			if (!Ascii::isSpace(*tRit)) break;
+		}
+	}
+	token = token.substr(front, length - back - front);
+}
+
+
+std::size_t StringTokenizer::count(const std::string& token) const
+{
+	std::size_t result = 0;
+	TokenVec::const_iterator it = std::find(_tokens.begin(), _tokens.end(), token);
+	while (it != _tokens.end())
+	{
+		result++;
+		it = std::find(++it, _tokens.end(), token);
+	}
+	return result;
+}
+
+
+std::string::size_type StringTokenizer::find(const std::string& token, std::string::size_type pos) const
+{	
+	TokenVec::const_iterator it = std::find(_tokens.begin() + pos, _tokens.end(), token);
+	if (it != _tokens.end())
+	{
+		return it - _tokens.begin();
+	}
+	throw NotFoundException(token);
+}
+
+
+bool StringTokenizer::has(const std::string& token) const
+{
+	TokenVec::const_iterator it = std::find(_tokens.begin(), _tokens.end(), token);
+	return it != _tokens.end();
+}
+
+
+std::size_t StringTokenizer::replace(const std::string& oldToken, const std::string& newToken, std::string::size_type pos)
+{
+	std::size_t result = 0;
+	TokenVec::iterator it = std::find(_tokens.begin() + pos, _tokens.end(), oldToken);
+	while (it != _tokens.end())
+	{
+		result++;
+		*it = newToken;
+		it = std::find(++it, _tokens.end(), oldToken);
+	}
+	return result;
+}
+
+
+} // namespace Poco
+
diff --git a/base/poco/Foundation/src/SynchronizedObject.cpp b/base/poco/Foundation/src/SynchronizedObject.cpp
new file mode 100644
index 00000000000..6a42e6594dc
--- /dev/null
+++ b/base/poco/Foundation/src/SynchronizedObject.cpp
@@ -0,0 +1,31 @@
+//
+// SynchronizedObject.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  SynchronizedObject
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SynchronizedObject.h"
+
+
+namespace Poco {
+
+
+SynchronizedObject::SynchronizedObject()
+{
+}
+
+	
+SynchronizedObject::~SynchronizedObject()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/SyslogChannel.cpp b/base/poco/Foundation/src/SyslogChannel.cpp
new file mode 100644
index 00000000000..c3d3c15f922
--- /dev/null
+++ b/base/poco/Foundation/src/SyslogChannel.cpp
@@ -0,0 +1,257 @@
+//
+// SyslogChannel.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  SyslogChannel
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SyslogChannel.h"
+#include "Poco/Message.h"
+#include "Poco/StringTokenizer.h"
+#include <syslog.h>
+
+
+namespace Poco {
+
+
+const std::string SyslogChannel::PROP_NAME     = "name";
+const std::string SyslogChannel::PROP_FACILITY = "facility";
+const std::string SyslogChannel::PROP_OPTIONS  = "options";
+
+
+SyslogChannel::SyslogChannel(): 
+	_options(SYSLOG_CONS), 
+	_facility(SYSLOG_USER), 
+	_open(false)
+{
+}
+
+
+SyslogChannel::SyslogChannel(const std::string& name, int options, int facility): 
+	_name(name), 
+	_options(options), 
+	_facility(facility), 
+	_open(false)
+{
+}
+
+
+SyslogChannel::~SyslogChannel()
+{
+	close();
+}
+
+
+void SyslogChannel::open()
+{
+	openlog(_name.c_str(), _options, _facility);
+	_open = true;
+}
+
+
+void SyslogChannel::close()
+{
+	if (_open)
+	{
+		closelog();
+		_open = false;
+	}
+}
+
+
+void SyslogChannel::log(const Message& msg)
+{
+	if (!_open) open();
+	syslog(getPrio(msg), "%s", msg.getText().c_str());
+}
+
+
+void SyslogChannel::setProperty(const std::string& name, const std::string& value)
+{
+	if (name == PROP_NAME)
+	{
+		_name = value;
+	}
+	else if (name == PROP_FACILITY)
+	{
+		if (value == "LOG_KERN")
+			_facility = SYSLOG_KERN;
+		else if (value == "LOG_USER")
+			_facility = SYSLOG_USER;
+		else if (value == "LOG_MAIL")
+			_facility = SYSLOG_MAIL;
+		else if (value == "LOG_DAEMON")
+			_facility = SYSLOG_DAEMON;
+		else if (value == "LOG_AUTH")
+			_facility = SYSLOG_AUTH;
+		else if (value == "LOG_AUTHPRIV")
+			_facility = SYSLOG_AUTHPRIV;
+		else if (value == "LOG_SYSLOG")
+			_facility = SYSLOG_SYSLOG;
+		else if (value == "LOG_LPR")
+			_facility = SYSLOG_LPR;
+		else if (value == "LOG_NEWS")
+			_facility = SYSLOG_NEWS;
+		else if (value == "LOG_UUCP")
+			_facility = SYSLOG_UUCP;
+		else if (value == "LOG_CRON")
+			_facility = SYSLOG_CRON;
+		else if (value == "LOG_FTP")
+			_facility = SYSLOG_FTP;
+		else if (value == "LOG_LOCAL0")
+			_facility = SYSLOG_LOCAL0;
+		else if (value == "LOG_LOCAL1")
+			_facility = SYSLOG_LOCAL1;
+		else if (value == "LOG_LOCAL2")
+			_facility = SYSLOG_LOCAL2;
+		else if (value == "LOG_LOCAL3")
+			_facility = SYSLOG_LOCAL3;
+		else if (value == "LOG_LOCAL4")
+			_facility = SYSLOG_LOCAL4;
+		else if (value == "LOG_LOCAL5")
+			_facility = SYSLOG_LOCAL5;
+		else if (value == "LOG_LOCAL6")
+			_facility = SYSLOG_LOCAL6;
+		else if (value == "LOG_LOCAL7")
+			_facility = SYSLOG_LOCAL7;
+	}
+	else if (name == PROP_OPTIONS)
+	{
+		_options = 0;
+		StringTokenizer tokenizer(value, "|+:;,", StringTokenizer::TOK_IGNORE_EMPTY | StringTokenizer::TOK_TRIM);
+		for (StringTokenizer::Iterator it = tokenizer.begin(); it != tokenizer.end(); ++it)
+		{
+			if (*it == "LOG_CONS")
+				_options |= SYSLOG_CONS;
+			else if (*it == "LOG_NDELAY")
+				_options |= SYSLOG_NDELAY;
+			else if (*it == "LOG_PERROR")
+				_options |= SYSLOG_PERROR;
+			else if (*it == "LOG_PID")
+				_options |= SYSLOG_PID;
+		}
+	}
+	else
+	{
+		Channel::setProperty(name, value);
+	}
+}
+
+
+std::string SyslogChannel::getProperty(const std::string& name) const
+{
+	if (name == PROP_NAME)
+	{
+		return _name;
+	}
+	else if (name == PROP_FACILITY)
+	{
+		if (_facility == SYSLOG_KERN)
+			return "LOG_KERN";
+		else if (_facility == SYSLOG_USER)
+			return "LOG_USER";
+		else if (_facility == SYSLOG_MAIL)
+			return "LOG_MAIL";
+		else if (_facility == SYSLOG_DAEMON)
+			return "LOG_DAEMON";
+		else if (_facility == SYSLOG_AUTH)
+			return "LOG_AUTH";
+		else if (_facility == SYSLOG_AUTHPRIV)
+			return "LOG_AUTHPRIV";
+		else if (_facility == SYSLOG_SYSLOG)
+			return "LOG_SYSLOG";
+		else if (_facility == SYSLOG_LPR)
+			return "LOG_LPR";
+		else if (_facility == SYSLOG_NEWS)
+			return "LOG_NEWS";
+		else if (_facility == SYSLOG_UUCP)
+			return "LOG_UUCP";
+		else if (_facility == SYSLOG_CRON)
+			return "LOG_CRON";
+		else if (_facility == SYSLOG_FTP)
+			return "LOG_FTP";
+		else if (_facility == SYSLOG_LOCAL0)
+			return "LOG_LOCAL0";
+		else if (_facility == SYSLOG_LOCAL1)
+			return "LOG_LOCAL1";
+		else if (_facility == SYSLOG_LOCAL2)
+			return "LOG_LOCAL2";
+		else if (_facility == SYSLOG_LOCAL3)
+			return "LOG_LOCAL3";
+		else if (_facility == SYSLOG_LOCAL4)
+			return "LOG_LOCAL4";
+		else if (_facility == SYSLOG_LOCAL5)
+			return "LOG_LOCAL5";
+		else if (_facility == SYSLOG_LOCAL6)
+			return "LOG_LOCAL6";
+		else if (_facility == SYSLOG_LOCAL7)
+			return "LOG_LOCAL7";
+		else
+			return "";
+	}
+	else if (name == PROP_OPTIONS)
+	{
+		std::string result;
+		if (_options & SYSLOG_CONS)
+		{
+			if (!result.empty()) result.append("|");
+			result.append("LOG_CONS");
+		}
+		if (_options & SYSLOG_NDELAY)
+		{
+			if (!result.empty()) result.append("|");
+			result.append("LOG_NDELAY");
+		}
+		if (_options & SYSLOG_PERROR)
+		{
+			if (!result.empty()) result.append("|");
+			result.append("LOG_PERROR");
+		}
+		if (_options & SYSLOG_PID)
+		{
+			if (!result.empty()) result.append("|");
+			result.append("LOG_PID");
+		}
+		return result;
+	}
+	else
+	{
+		return Channel::getProperty(name);
+	}
+}
+
+
+int SyslogChannel::getPrio(const Message& msg)
+{
+	switch (msg.getPriority())
+	{
+	case Message::PRIO_TEST:
+	case Message::PRIO_TRACE:
+	case Message::PRIO_DEBUG:
+		return LOG_DEBUG;
+	case Message::PRIO_INFORMATION:
+		return LOG_INFO;
+	case Message::PRIO_NOTICE:
+		return LOG_NOTICE;
+	case Message::PRIO_WARNING:
+		return LOG_WARNING;
+	case Message::PRIO_ERROR:
+		return LOG_ERR;
+	case Message::PRIO_CRITICAL:
+		return LOG_CRIT;
+	case Message::PRIO_FATAL:
+		return LOG_ALERT;
+	default:
+		return 0;
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Task.cpp b/base/poco/Foundation/src/Task.cpp
new file mode 100644
index 00000000000..a850ae37eff
--- /dev/null
+++ b/base/poco/Foundation/src/Task.cpp
@@ -0,0 +1,146 @@
+//
+// Task.cpp
+//
+// Library: Foundation
+// Package: Tasks
+// Module:  Tasks
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Task.h"
+#include "Poco/TaskManager.h"
+#include "Poco/Exception.h"
+
+#include <iostream>
+#include <array>
+
+
+namespace Poco {
+
+
+Task::Task(const std::string& name):
+	_name(name),
+	_pOwner(0),
+	_progress(0),
+	_state(TASK_IDLE),
+	_cancelEvent(false)
+{
+}
+
+
+Task::~Task()
+{
+}
+
+
+void Task::cancel()
+{
+	_state = TASK_CANCELLING;
+	_cancelEvent.set();
+	if (_pOwner)
+		_pOwner->taskCancelled(this);
+}
+
+
+void Task::reset()
+{
+	_progress = 0.0;
+	_state    = TASK_IDLE;
+	_cancelEvent.reset();
+}
+
+
+void Task::run()
+{
+	TaskManager* pOwner = getOwner();
+	if (pOwner)
+		pOwner->taskStarted(this);		
+	try
+	{
+		/** Task can be already cancelled.
+		 *  To prevent endless executing already cancelled task _state is assigned to TASK_RUNNING only if _state != TASK_CANCELLING
+		 */
+		#pragma clang diagnostic push
+		#pragma clang diagnostic ignored "-Wmissing-braces"
+		std::array<TaskState, 3> allowed_states{TASK_IDLE, TASK_STARTING, TASK_FINISHED};
+		#pragma clang diagnostic pop
+		for (auto & expected : allowed_states)
+			if (_state.compare_exchange_strong(expected, TASK_RUNNING))
+				break;
+
+		if (_state == TASK_RUNNING)
+		runTask();
+	}
+	catch (Exception& exc)
+	{
+		if (pOwner)
+			pOwner->taskFailed(this, exc);
+	}
+	catch (std::exception& exc)
+	{
+		if (pOwner)
+			pOwner->taskFailed(this, SystemException(exc.what()));
+	}
+	catch (...)
+	{
+		if (pOwner)
+			pOwner->taskFailed(this, SystemException("unknown exception"));
+	}
+	_state = TASK_FINISHED;
+	if (pOwner)
+		pOwner->taskFinished(this);
+}
+
+
+bool Task::sleep(long milliseconds)
+{
+	return _cancelEvent.tryWait(milliseconds);
+}
+
+
+void Task::setProgress(float progress)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (_progress != progress)
+	{
+		_progress = progress;
+		if (_pOwner)
+			_pOwner->taskProgress(this, _progress);
+	}
+}
+
+
+void Task::setOwner(TaskManager* pOwner)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	_pOwner = pOwner;
+}
+
+
+void Task::setState(TaskState state)
+{
+	_state = state;
+}
+
+
+void Task::postNotification(Notification* pNf)
+{
+	poco_check_ptr (pNf);
+
+	FastMutex::ScopedLock lock(_mutex);
+	
+	if (_pOwner)
+	{
+		_pOwner->postNotification(pNf);
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/TaskManager.cpp b/base/poco/Foundation/src/TaskManager.cpp
new file mode 100644
index 00000000000..8bf1cb34035
--- /dev/null
+++ b/base/poco/Foundation/src/TaskManager.cpp
@@ -0,0 +1,156 @@
+//
+// TaskManager.cpp
+//
+// Library: Foundation
+// Package: Tasks
+// Module:  Tasks
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/TaskManager.h"
+#include "Poco/TaskNotification.h"
+#include "Poco/ThreadPool.h"
+
+
+namespace Poco {
+
+
+const int TaskManager::MIN_PROGRESS_NOTIFICATION_INTERVAL = 100000; // 100 milliseconds
+
+
+TaskManager::TaskManager():
+	_threadPool(ThreadPool::defaultPool())
+{
+}
+
+
+TaskManager::TaskManager(ThreadPool& pool):
+	_threadPool(pool)
+{
+}
+
+
+TaskManager::~TaskManager()
+{
+}
+
+
+void TaskManager::start(Task* pTask)
+{
+	TaskPtr pAutoTask(pTask); // take ownership immediately
+	FastMutex::ScopedLock lock(_mutex);
+
+	pAutoTask->setOwner(this);
+	pAutoTask->setState(Task::TASK_STARTING);
+	_taskList.push_back(pAutoTask);
+	try
+	{
+		_threadPool.start(*pAutoTask, pAutoTask->name());
+	}
+	catch (...)
+	{
+		// Make sure that we don't act like we own the task since
+		// we never started it.  If we leave the task on our task
+		// list, the size of the list is incorrect.
+		_taskList.pop_back();
+		throw;
+	}
+}
+
+
+void TaskManager::cancelAll()
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	for (TaskList::iterator it = _taskList.begin(); it != _taskList.end(); ++it)
+	{
+		(*it)->cancel();
+	}
+}
+
+
+void TaskManager::joinAll()
+{
+	_threadPool.joinAll();
+}
+
+
+TaskManager::TaskList TaskManager::taskList() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	return _taskList;
+}
+
+
+void TaskManager::addObserver(const AbstractObserver& observer)
+{
+	_nc.addObserver(observer);
+}
+
+
+void TaskManager::removeObserver(const AbstractObserver& observer)
+{
+	_nc.removeObserver(observer);
+}
+
+
+void TaskManager::postNotification(const Notification::Ptr& pNf)
+{
+	_nc.postNotification(pNf);
+}
+
+
+void TaskManager::taskStarted(Task* pTask)
+{
+	_nc.postNotification(new TaskStartedNotification(pTask));
+}
+
+
+void TaskManager::taskProgress(Task* pTask, float progress)
+{
+	ScopedLockWithUnlock<FastMutex> lock(_mutex);
+
+	if (_lastProgressNotification.isElapsed(MIN_PROGRESS_NOTIFICATION_INTERVAL))
+	{
+		_lastProgressNotification.update();
+		lock.unlock();
+		_nc.postNotification(new TaskProgressNotification(pTask, progress));
+	}
+}
+
+
+void TaskManager::taskCancelled(Task* pTask)
+{
+	_nc.postNotification(new TaskCancelledNotification(pTask));
+}
+
+
+void TaskManager::taskFinished(Task* pTask)
+{
+	_nc.postNotification(new TaskFinishedNotification(pTask));
+	
+	FastMutex::ScopedLock lock(_mutex);
+	for (TaskList::iterator it = _taskList.begin(); it != _taskList.end(); ++it)
+	{
+		if (*it == pTask)
+		{
+			_taskList.erase(it);
+			break;
+		}
+	}
+}
+
+
+void TaskManager::taskFailed(Task* pTask, const Exception& exc)
+{
+	_nc.postNotification(new TaskFailedNotification(pTask, exc));
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/TaskNotification.cpp b/base/poco/Foundation/src/TaskNotification.cpp
new file mode 100644
index 00000000000..cbb7d4d8934
--- /dev/null
+++ b/base/poco/Foundation/src/TaskNotification.cpp
@@ -0,0 +1,92 @@
+//
+// TaskNotification.cpp
+//
+// Library: Foundation
+// Package: Tasks
+// Module:  Tasks
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/TaskNotification.h"
+
+
+namespace Poco {
+
+
+TaskNotification::TaskNotification(Task* pTask):
+	_pTask(pTask)
+{
+	if (_pTask) _pTask->duplicate();
+}
+
+
+TaskNotification::~TaskNotification()
+{
+	if (_pTask) _pTask->release();
+}
+
+
+TaskStartedNotification::TaskStartedNotification(Task* pTask):
+	TaskNotification(pTask)
+{
+}
+
+	
+TaskStartedNotification::~TaskStartedNotification()
+{
+}
+
+
+TaskCancelledNotification::TaskCancelledNotification(Task* pTask):
+	TaskNotification(pTask)
+{
+}
+
+	
+TaskCancelledNotification::~TaskCancelledNotification()
+{
+}
+
+
+TaskFinishedNotification::TaskFinishedNotification(Task* pTask):
+	TaskNotification(pTask)
+{
+}
+
+	
+TaskFinishedNotification::~TaskFinishedNotification()
+{
+}
+
+
+TaskFailedNotification::TaskFailedNotification(Task* pTask, const Exception& exc):
+	TaskNotification(pTask),
+	_pException(exc.clone())
+{
+}
+
+	
+TaskFailedNotification::~TaskFailedNotification()
+{
+	delete _pException;
+}
+
+
+TaskProgressNotification::TaskProgressNotification(Task* pTask, float progress):
+	TaskNotification(pTask),
+	_progress(progress)
+{
+}
+
+	
+TaskProgressNotification::~TaskProgressNotification()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/TeeStream.cpp b/base/poco/Foundation/src/TeeStream.cpp
new file mode 100644
index 00000000000..12ae7d0da7d
--- /dev/null
+++ b/base/poco/Foundation/src/TeeStream.cpp
@@ -0,0 +1,133 @@
+//
+// TeeStream.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  TeeStream
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/TeeStream.h"
+
+
+namespace Poco {
+
+
+TeeStreamBuf::TeeStreamBuf(): 
+	_pIstr(0)
+{
+}
+
+
+TeeStreamBuf::TeeStreamBuf(std::istream& istr): 
+	_pIstr(&istr)
+{
+}
+
+
+TeeStreamBuf::TeeStreamBuf(std::ostream& ostr): 
+	_pIstr(0)
+{
+	_streams.push_back(&ostr);
+}
+
+
+TeeStreamBuf::~TeeStreamBuf()
+{
+}
+
+
+void TeeStreamBuf::addStream(std::ostream& ostr)
+{
+	_streams.push_back(&ostr);
+}
+
+
+int TeeStreamBuf::readFromDevice()
+{
+	if (_pIstr)
+	{
+		int c = _pIstr->get();
+		if (c != -1) writeToDevice((char) c);
+		return c;
+	}
+	return -1;
+}
+
+
+int TeeStreamBuf::writeToDevice(char c)
+{
+	for (StreamVec::iterator it = _streams.begin(); it != _streams.end(); ++it)
+	{
+		(*it)->put(c);
+	}
+	return charToInt(c);
+}
+
+
+TeeIOS::TeeIOS()
+{
+	poco_ios_init(&_buf);
+}
+
+
+TeeIOS::TeeIOS(std::istream& istr): _buf(istr)
+{
+	poco_ios_init(&_buf);
+}
+
+
+TeeIOS::TeeIOS(std::ostream& ostr): _buf(ostr)
+{
+	poco_ios_init(&_buf);
+}
+
+
+TeeIOS::~TeeIOS()
+{
+}
+
+
+void TeeIOS::addStream(std::ostream& ostr)
+{
+	_buf.addStream(ostr);
+}
+
+
+TeeStreamBuf* TeeIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+TeeInputStream::TeeInputStream(std::istream& istr): TeeIOS(istr), std::istream(&_buf)
+{
+}
+
+
+TeeInputStream::~TeeInputStream()
+{
+}
+
+
+TeeOutputStream::TeeOutputStream(): std::ostream(&_buf)
+{
+}
+
+
+TeeOutputStream::TeeOutputStream(std::ostream& ostr): TeeIOS(ostr), std::ostream(&_buf)
+{
+}
+
+
+TeeOutputStream::~TeeOutputStream()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/TemporaryFile.cpp b/base/poco/Foundation/src/TemporaryFile.cpp
new file mode 100644
index 00000000000..e89c970f337
--- /dev/null
+++ b/base/poco/Foundation/src/TemporaryFile.cpp
@@ -0,0 +1,167 @@
+//
+// TemporaryFile.cpp
+//
+// Library: Foundation
+// Package: Filesystem
+// Module:  TemporaryFile
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/TemporaryFile.h"
+#include "Poco/Path.h"
+#include "Poco/Exception.h"
+#if !defined(POCO_VXWORKS)
+#include "Poco/Process.h"
+#endif
+#include "Poco/Mutex.h"
+#include <set>
+#include <sstream>
+
+
+namespace Poco {
+
+
+class TempFileCollector
+{
+public:
+	TempFileCollector()
+	{
+	}
+
+	~TempFileCollector()
+	{
+		try
+		{
+			for (std::set<std::string>::iterator it = _files.begin(); it != _files.end(); ++it)
+			{
+				try
+				{
+					File f(*it);
+					if (f.exists())
+						f.remove(true);
+				}
+				catch (Exception&)
+				{
+				}
+			}
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	}
+
+	void registerFile(const std::string& path)
+	{
+		FastMutex::ScopedLock lock(_mutex);
+
+		Path p(path);
+		_files.insert(p.absolute().toString());
+	}
+
+private:
+	std::set<std::string> _files;
+	FastMutex _mutex;
+};
+
+
+TemporaryFile::TemporaryFile(): 
+	File(tempName()), 
+	_keep(false)
+{
+}
+
+
+TemporaryFile::TemporaryFile(const std::string& tempDir): 
+	File(tempName(tempDir)), 
+	_keep(false)
+{
+}
+
+
+TemporaryFile::~TemporaryFile()
+{
+	try
+	{
+		if (!_keep)
+		{
+			try
+			{
+				if (exists())
+					remove(true);
+			}
+			catch (Exception&)
+			{
+			}
+		}
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void TemporaryFile::keep()
+{
+	_keep = true;
+}
+
+
+void TemporaryFile::keepUntilExit()
+{
+	_keep = true;
+	registerForDeletion(path());
+}
+
+
+namespace 
+{
+	static TempFileCollector fc;
+}
+
+
+void TemporaryFile::registerForDeletion(const std::string& path)
+{
+	fc.registerFile(path);
+}
+
+
+namespace
+{
+	static FastMutex mutex;
+}
+
+
+std::string TemporaryFile::tempName(const std::string& tempDir)
+{
+	std::ostringstream name;
+	static unsigned long count = 0;
+	mutex.lock();
+	unsigned long n = count++;
+	mutex.unlock();
+	name << (tempDir.empty() ? Path::temp() : tempDir);
+	if (name.str().at(name.str().size() - 1) != Path::separator())
+	{
+		name << Path::separator();
+	}
+#if defined(POCO_VXWORKS)
+	name << "tmp";
+#else
+	name << "tmp" << Process::id();
+#endif
+	for (int i = 0; i < 6; ++i)
+	{
+		name << char('a' + (n % 26));
+		n /= 26;
+	}
+	return name.str();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/TextBufferIterator.cpp b/base/poco/Foundation/src/TextBufferIterator.cpp
new file mode 100644
index 00000000000..f6338ab2676
--- /dev/null
+++ b/base/poco/Foundation/src/TextBufferIterator.cpp
@@ -0,0 +1,178 @@
+//
+// TextBufferIterator.cpp
+//
+// Library: Foundation
+// Package: Text
+// Module:  TextBufferIterator
+//
+// Copyright (c) 2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/TextBufferIterator.h"
+#include "Poco/TextEncoding.h"
+#include <algorithm>
+#include <cstring>
+
+
+namespace Poco {
+
+
+TextBufferIterator::TextBufferIterator():
+	_pEncoding(0),
+	_it(0),
+	_end(0)
+{
+}
+
+
+TextBufferIterator::TextBufferIterator(const char* begin, const TextEncoding& encoding):
+	_pEncoding(&encoding),
+	_it(begin),
+	_end(begin + std::strlen(begin))
+{
+}
+
+
+TextBufferIterator::TextBufferIterator(const char* begin, std::size_t size, const TextEncoding& encoding):
+	_pEncoding(&encoding),
+	_it(begin),
+	_end(begin + size)
+{
+}
+
+
+TextBufferIterator::TextBufferIterator(const char* begin, const char* end, const TextEncoding& encoding):
+	_pEncoding(&encoding),
+	_it(begin),
+	_end(end)
+{
+}
+
+
+TextBufferIterator::TextBufferIterator(const char* end):
+	_pEncoding(0),
+	_it(end),
+	_end(end)
+{
+}
+
+
+TextBufferIterator::~TextBufferIterator()
+{
+}
+
+
+TextBufferIterator::TextBufferIterator(const TextBufferIterator& it):
+	_pEncoding(it._pEncoding),
+	_it(it._it),
+	_end(it._end)
+{
+}
+
+
+TextBufferIterator& TextBufferIterator::operator = (const TextBufferIterator& it)
+{
+	if (&it != this)
+	{
+		_pEncoding = it._pEncoding;
+		_it        = it._it;
+		_end       = it._end;
+	}
+	return *this;
+}
+
+
+void TextBufferIterator::swap(TextBufferIterator& it)
+{
+	std::swap(_pEncoding, it._pEncoding);
+	std::swap(_it, it._it);
+	std::swap(_end, it._end);
+}
+
+
+int TextBufferIterator::operator * () const
+{
+	poco_check_ptr (_pEncoding);
+	poco_assert (_it != _end);
+	const char* it = _it;
+	
+	unsigned char buffer[TextEncoding::MAX_SEQUENCE_LENGTH];
+	unsigned char* p = buffer;
+
+	if (it != _end)
+		*p++ = *it++;
+	else
+		*p++ = 0;
+
+	int read = 1;
+	int n = _pEncoding->queryConvert(buffer, 1);
+
+	while (-1 > n && (_end - it) >= -n - read)
+	{
+		while (read < -n && it != _end)
+		{ 
+			*p++ = *it++; 
+			read++; 
+		}
+		n = _pEncoding->queryConvert(buffer, read);
+	}
+
+	if (-1 > n)
+	{
+		return -1;
+	}
+	else
+	{
+		return n;
+	}
+}
+
+	
+TextBufferIterator& TextBufferIterator::operator ++ ()
+{
+	poco_check_ptr (_pEncoding);
+	poco_assert (_it != _end);
+	
+	unsigned char buffer[TextEncoding::MAX_SEQUENCE_LENGTH];
+	unsigned char* p = buffer;
+
+	if (_it != _end)
+		*p++ = *_it++;
+	else
+		*p++ = 0;
+
+	int read = 1;
+	int n = _pEncoding->sequenceLength(buffer, 1);
+
+	while (-1 > n && (_end - _it) >= -n - read)
+	{
+		while (read < -n && _it != _end)
+		{ 
+			*p++ = *_it++; 
+			read++; 
+		}
+		n = _pEncoding->sequenceLength(buffer, read);
+	}
+	while (read < n && _it != _end)
+	{ 
+		_it++; 
+		read++; 
+	}
+
+	return *this;
+}
+
+
+TextBufferIterator TextBufferIterator::operator ++ (int)
+{
+	TextBufferIterator prev(*this);
+	operator ++ ();
+	return prev;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/TextConverter.cpp b/base/poco/Foundation/src/TextConverter.cpp
new file mode 100644
index 00000000000..59194ed77cd
--- /dev/null
+++ b/base/poco/Foundation/src/TextConverter.cpp
@@ -0,0 +1,128 @@
+//
+// TextConverter.cpp
+//
+// Library: Foundation
+// Package: Text
+// Module:  TextConverter
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/TextConverter.h"
+#include "Poco/TextIterator.h"
+#include "Poco/TextEncoding.h"
+
+
+namespace {
+	int nullTransform(int ch)
+	{
+		return ch;
+	}
+}
+
+
+namespace Poco {
+
+
+TextConverter::TextConverter(const TextEncoding& inEncoding, const TextEncoding& outEncoding, int defaultChar):
+	_inEncoding(inEncoding),
+	_outEncoding(outEncoding),
+	_defaultChar(defaultChar)
+{
+}
+
+
+TextConverter::~TextConverter()
+{
+}
+
+
+int TextConverter::convert(const std::string& source, std::string& destination, Transform trans)
+{
+	int errors = 0;
+	TextIterator it(source, _inEncoding);
+	TextIterator end(source);
+	unsigned char buffer[TextEncoding::MAX_SEQUENCE_LENGTH];
+
+	while (it != end)
+	{
+		int c = *it;
+		if (c == -1) { ++errors; c = _defaultChar; }
+		c = trans(c);
+		int n = _outEncoding.convert(c, buffer, sizeof(buffer));
+		if (n == 0) n = _outEncoding.convert(_defaultChar, buffer, sizeof(buffer));
+		poco_assert (n <= sizeof(buffer));
+		destination.append((const char*) buffer, n);
+		++it;
+	}
+	return errors;
+}
+
+
+int TextConverter::convert(const void* source, int length, std::string& destination, Transform trans)
+{
+	poco_check_ptr (source);
+
+	int errors = 0;
+	const unsigned char* it  = (const unsigned char*) source;
+	const unsigned char* end = (const unsigned char*) source + length;
+	unsigned char buffer[TextEncoding::MAX_SEQUENCE_LENGTH];
+	
+	while (it < end)
+	{
+		int n = _inEncoding.queryConvert(it, 1);
+		int uc;
+		int read = 1;
+
+		while (-1 > n && (end - it) >= -n)
+		{
+			read = -n;
+			n = _inEncoding.queryConvert(it, read);
+		}
+
+		if (-1 > n)
+		{
+			it = end;
+		}
+		else
+		{
+			it += read;
+		}
+
+		if (-1 >= n)
+		{
+			uc = _defaultChar;
+			++errors;
+		}
+		else
+		{
+			uc = n;
+		}
+
+		uc = trans(uc);
+		n = _outEncoding.convert(uc, buffer, sizeof(buffer));
+		if (n == 0) n = _outEncoding.convert(_defaultChar, buffer, sizeof(buffer));
+		poco_assert (n <= sizeof(buffer));
+		destination.append((const char*) buffer, n);
+	}
+	return errors;
+}
+
+
+int TextConverter::convert(const std::string& source, std::string& destination)
+{
+	return convert(source, destination, nullTransform);
+}
+
+
+int TextConverter::convert(const void* source, int length, std::string& destination)
+{
+	return convert(source, length, destination, nullTransform);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/TextEncoding.cpp b/base/poco/Foundation/src/TextEncoding.cpp
new file mode 100644
index 00000000000..cfd1c77ef95
--- /dev/null
+++ b/base/poco/Foundation/src/TextEncoding.cpp
@@ -0,0 +1,208 @@
+//
+// TextEncoding.cpp
+//
+// Library: Foundation
+// Package: Text
+// Module:  TextEncoding
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/TextEncoding.h"
+#include "Poco/Exception.h"
+#include "Poco/String.h"
+#include "Poco/ASCIIEncoding.h"
+#include "Poco/Latin1Encoding.h"
+#include "Poco/Latin2Encoding.h"
+#include "Poco/Latin9Encoding.h"
+#include "Poco/UTF32Encoding.h"
+#include "Poco/UTF16Encoding.h"
+#include "Poco/UTF8Encoding.h"
+#include "Poco/Windows1250Encoding.h"
+#include "Poco/Windows1251Encoding.h"
+#include "Poco/Windows1252Encoding.h"
+#include "Poco/RWLock.h"
+#include "Poco/SingletonHolder.h"
+#include <map>
+
+
+namespace Poco {
+
+
+//
+// TextEncodingManager
+//
+
+
+class TextEncodingManager
+{
+public:
+	TextEncodingManager()
+	{
+		TextEncoding::Ptr pUtf8Encoding(new UTF8Encoding);
+		add(pUtf8Encoding, TextEncoding::GLOBAL);
+
+		add(new ASCIIEncoding);
+		add(new Latin1Encoding);
+		add(new Latin2Encoding);
+		add(new Latin9Encoding);
+		add(pUtf8Encoding);
+		add(new UTF16Encoding);
+		add(new UTF32Encoding);
+		add(new Windows1250Encoding);
+		add(new Windows1251Encoding);
+		add(new Windows1252Encoding);
+	}
+
+	~TextEncodingManager()
+	{
+	}
+
+	void add(TextEncoding::Ptr pEncoding)
+	{
+		add(pEncoding, pEncoding->canonicalName());
+	}
+
+	void add(TextEncoding::Ptr pEncoding, const std::string& name)
+	{
+		RWLock::ScopedLock lock(_lock, true);
+	
+		_encodings[name] = pEncoding;
+	}
+
+	void remove(const std::string& name)
+	{
+		RWLock::ScopedLock lock(_lock, true);
+	
+		_encodings.erase(name);
+	}
+	
+	TextEncoding::Ptr find(const std::string& name) const
+	{
+		RWLock::ScopedLock lock(_lock);
+		
+		EncodingMap::const_iterator it = _encodings.find(name);
+		if (it != _encodings.end())
+			return it->second;
+		
+		for (it = _encodings.begin(); it != _encodings.end(); ++it)
+		{
+			if (it->second->isA(name))
+				return it->second;
+		}
+		return TextEncoding::Ptr();
+	}
+
+private:
+	TextEncodingManager(const TextEncodingManager&);
+	TextEncodingManager& operator = (const TextEncodingManager&);
+	
+	typedef std::map<std::string, TextEncoding::Ptr, CILess> EncodingMap;
+	
+	EncodingMap    _encodings;
+	mutable RWLock _lock;
+};
+
+
+//
+// TextEncoding
+//
+
+
+const std::string TextEncoding::GLOBAL;
+
+
+TextEncoding::~TextEncoding()
+{
+}
+
+
+int TextEncoding::convert(const unsigned char* bytes) const
+{
+	return static_cast<int>(*bytes);
+}
+
+
+int TextEncoding::convert(int ch, unsigned char* bytes, int length) const
+{
+	return 0;
+}
+
+
+int TextEncoding::queryConvert(const unsigned char* bytes, int length) const
+{
+	return (int) *bytes;
+}
+
+
+int TextEncoding::sequenceLength(const unsigned char* bytes, int length) const
+{
+	return 1;
+}
+
+
+TextEncoding& TextEncoding::byName(const std::string& encodingName)
+{
+	TextEncoding* pEncoding = manager().find(encodingName);
+	if (pEncoding)
+		return *pEncoding;
+	else
+		throw NotFoundException(encodingName);
+}
+
+	
+TextEncoding::Ptr TextEncoding::find(const std::string& encodingName)
+{
+	return manager().find(encodingName);
+}
+
+
+void TextEncoding::add(TextEncoding::Ptr pEncoding)
+{
+	manager().add(pEncoding, pEncoding->canonicalName());
+}
+
+
+void TextEncoding::add(TextEncoding::Ptr pEncoding, const std::string& name)
+{
+	manager().add(pEncoding, name);
+}
+
+
+void TextEncoding::remove(const std::string& encodingName)
+{
+	manager().remove(encodingName);
+}
+
+
+TextEncoding::Ptr TextEncoding::global(TextEncoding::Ptr encoding)
+{
+	TextEncoding::Ptr prev = find(GLOBAL);
+	add(encoding, GLOBAL);
+	return prev;
+}
+
+
+TextEncoding& TextEncoding::global()
+{
+	return byName(GLOBAL);
+}
+
+
+namespace
+{
+	static SingletonHolder<TextEncodingManager> sh;
+}
+
+
+TextEncodingManager& TextEncoding::manager()
+{
+	return *sh.get();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/TextIterator.cpp b/base/poco/Foundation/src/TextIterator.cpp
new file mode 100644
index 00000000000..2f6a5c10205
--- /dev/null
+++ b/base/poco/Foundation/src/TextIterator.cpp
@@ -0,0 +1,175 @@
+//
+// TextIterator.cpp
+//
+// Library: Foundation
+// Package: Text
+// Module:  TextIterator
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/TextIterator.h"
+#include "Poco/TextEncoding.h"
+#include <algorithm>
+
+
+namespace Poco {
+
+
+TextIterator::TextIterator():
+	_pEncoding(0)
+{
+}
+
+
+TextIterator::TextIterator(const std::string& str, const TextEncoding& encoding):
+	_pEncoding(&encoding),
+	_it(str.begin()),
+	_end(str.end())
+{
+}
+
+
+TextIterator::TextIterator(const std::string::const_iterator& begin, const std::string::const_iterator& end, const TextEncoding& encoding):
+	_pEncoding(&encoding),
+	_it(begin),
+	_end(end)
+{
+}
+
+
+TextIterator::TextIterator(const std::string& str):
+	_pEncoding(0),
+	_it(str.end()),
+	_end(str.end())
+{
+}
+
+
+TextIterator::TextIterator(const std::string::const_iterator& end):
+	_pEncoding(0),
+	_it(end),
+	_end(end)
+{
+}
+
+
+TextIterator::~TextIterator()
+{
+}
+
+
+TextIterator::TextIterator(const TextIterator& it):
+	_pEncoding(it._pEncoding),
+	_it(it._it),
+	_end(it._end)
+{
+}
+
+
+TextIterator& TextIterator::operator = (const TextIterator& it)
+{
+	if (&it != this)
+	{
+		_pEncoding = it._pEncoding;
+		_it        = it._it;
+		_end       = it._end;
+	}
+	return *this;
+}
+
+
+void TextIterator::swap(TextIterator& it)
+{
+	std::swap(_pEncoding, it._pEncoding);
+	std::swap(_it, it._it);
+	std::swap(_end, it._end);
+}
+
+
+int TextIterator::operator * () const
+{
+	poco_check_ptr (_pEncoding);
+	poco_assert (_it != _end);
+	std::string::const_iterator it = _it;
+	
+	unsigned char buffer[TextEncoding::MAX_SEQUENCE_LENGTH];
+	unsigned char* p = buffer;
+
+	if (it != _end)
+		*p++ = *it++;
+	else
+		*p++ = 0;
+
+	int read = 1;
+	int n = _pEncoding->queryConvert(buffer, 1);
+
+	while (-1 > n && (_end - it) >= -n - read)
+	{
+		while (read < -n && it != _end)
+		{ 
+			*p++ = *it++; 
+			read++; 
+		}
+		n = _pEncoding->queryConvert(buffer, read);
+	}
+
+	if (-1 > n)
+	{
+		return -1;
+	}
+	else
+	{
+		return n;
+	}
+}
+
+	
+TextIterator& TextIterator::operator ++ ()
+{
+	poco_check_ptr (_pEncoding);
+	poco_assert (_it != _end);
+	
+	unsigned char buffer[TextEncoding::MAX_SEQUENCE_LENGTH];
+	unsigned char* p = buffer;
+
+	if (_it != _end)
+		*p++ = *_it++;
+	else
+		*p++ = 0;
+
+	int read = 1;
+	int n = _pEncoding->sequenceLength(buffer, 1);
+
+	while (-1 > n && (_end - _it) >= -n - read)
+	{
+		while (read < -n && _it != _end)
+		{ 
+			*p++ = *_it++; 
+			read++; 
+		}
+		n = _pEncoding->sequenceLength(buffer, read);
+	}
+	while (read < n && _it != _end)
+	{ 
+		_it++; 
+		read++; 
+	}
+
+	return *this;
+}
+
+
+TextIterator TextIterator::operator ++ (int)
+{
+	TextIterator prev(*this);
+	operator ++ ();
+	return prev;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Thread.cpp b/base/poco/Foundation/src/Thread.cpp
new file mode 100644
index 00000000000..2f16bbed7f6
--- /dev/null
+++ b/base/poco/Foundation/src/Thread.cpp
@@ -0,0 +1,212 @@
+//
+// Thread.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Thread
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Thread.h"
+#include "Poco/Mutex.h"
+#include "Poco/Exception.h"
+#include "Poco/ThreadLocal.h"
+#include "Poco/AtomicCounter.h"
+#include <sstream>
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#if defined(_WIN32_WCE)
+#include "Thread_WINCE.cpp"
+#else
+#include "Thread_WIN32.cpp"
+#endif
+#elif defined(POCO_VXWORKS)
+#include "Thread_VX.cpp"
+#else
+#include "Thread_POSIX.cpp"
+#endif
+
+
+namespace Poco {
+
+
+namespace {
+
+class RunnableHolder: public Runnable
+{
+public:
+	RunnableHolder(Runnable& target):
+		_target(target)
+	{
+	}
+
+	~RunnableHolder()
+	{
+	}
+
+	void run()
+	{
+		_target.run();
+	}
+
+private:
+	Runnable& _target;
+};
+
+
+class CallableHolder: public Runnable
+{
+public:
+	CallableHolder(Thread::Callable callable, void* pData):
+		_callable(callable),
+		_pData(pData)
+	{
+	}
+
+	~CallableHolder()
+	{
+	}
+
+	void run()
+	{
+		_callable(_pData);
+	}
+
+private:
+	Thread::Callable _callable;
+	void* _pData;
+};
+
+
+} // namespace
+
+
+Thread::Thread(): 
+	_id(uniqueId()), 
+	_name(makeName()), 
+	_pTLS(0),
+	_event(true)
+{
+}
+
+
+Thread::Thread(const std::string& name): 
+	_id(uniqueId()), 
+	_name(name), 
+	_pTLS(0),
+	_event(true)
+{
+}
+
+
+Thread::~Thread()
+{
+	delete _pTLS;
+}
+
+
+void Thread::setPriority(Priority prio)
+{
+	setPriorityImpl(prio);
+}
+
+
+Thread::Priority Thread::getPriority() const
+{
+	return Priority(getPriorityImpl());
+}
+
+
+void Thread::start(Runnable& target)
+{
+	startImpl(new RunnableHolder(target));
+}
+
+
+void Thread::start(Callable target, void* pData)
+{
+	startImpl(new CallableHolder(target, pData));
+}
+
+
+void Thread::join()
+{
+	joinImpl();
+}
+
+
+void Thread::join(long milliseconds)
+{
+	if (!joinImpl(milliseconds))
+		throw TimeoutException();
+}
+
+
+bool Thread::tryJoin(long milliseconds)
+{
+	return joinImpl(milliseconds);
+}
+
+
+bool Thread::trySleep(long milliseconds)
+{
+	Thread* pT = Thread::current();
+	poco_check_ptr(pT);
+	return !(pT->_event.tryWait(milliseconds));
+}
+
+
+void Thread::wakeUp()
+{
+	_event.set();
+}
+
+
+ThreadLocalStorage& Thread::tls()
+{
+	if (!_pTLS)
+		_pTLS = new ThreadLocalStorage;
+	return *_pTLS;
+}
+
+
+void Thread::clearTLS()
+{
+	if (_pTLS)
+	{
+		delete _pTLS;
+		_pTLS = 0;
+	}
+}
+
+
+std::string Thread::makeName()
+{
+	std::ostringstream name;
+	name << '#' << _id;
+	return name.str();
+}
+
+
+int Thread::uniqueId()
+{
+	static Poco::AtomicCounter counter;
+	return ++counter;
+}
+
+
+void Thread::setName(const std::string& name)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	_name = name;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/ThreadLocal.cpp b/base/poco/Foundation/src/ThreadLocal.cpp
new file mode 100644
index 00000000000..3cc03f6966a
--- /dev/null
+++ b/base/poco/Foundation/src/ThreadLocal.cpp
@@ -0,0 +1,85 @@
+//
+// ThreadLocal.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Thread
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/ThreadLocal.h"
+#include "Poco/SingletonHolder.h"
+#include "Poco/Thread.h"
+
+
+namespace Poco {
+
+
+TLSAbstractSlot::TLSAbstractSlot()
+{
+}
+
+
+TLSAbstractSlot::~TLSAbstractSlot()
+{
+}
+
+
+ThreadLocalStorage::ThreadLocalStorage()
+{
+}
+
+
+ThreadLocalStorage::~ThreadLocalStorage()
+{
+	for (TLSMap::iterator it = _map.begin(); it != _map.end(); ++it)
+	{
+		delete it->second;	
+	}
+}
+
+
+TLSAbstractSlot*& ThreadLocalStorage::get(const void* key)
+{
+	TLSMap::iterator it = _map.find(key);
+	if (it == _map.end())
+		return _map.insert(TLSMap::value_type(key, reinterpret_cast<Poco::TLSAbstractSlot*>(0))).first->second;
+	else
+		return it->second;
+}
+
+
+namespace
+{
+	static SingletonHolder<ThreadLocalStorage> sh;
+}
+
+
+ThreadLocalStorage& ThreadLocalStorage::current()
+{
+	Thread* pThread = Thread::current();
+	if (pThread)
+	{
+		return pThread->tls();
+	}
+	else
+	{
+		return *sh.get();
+	}
+}
+
+
+void ThreadLocalStorage::clear()
+{
+	Thread* pThread = Thread::current();
+	if (pThread)
+		pThread->clearTLS();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/ThreadPool.cpp b/base/poco/Foundation/src/ThreadPool.cpp
new file mode 100644
index 00000000000..39846945042
--- /dev/null
+++ b/base/poco/Foundation/src/ThreadPool.cpp
@@ -0,0 +1,527 @@
+//
+// ThreadPool.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  ThreadPool
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/ThreadPool.h"
+#include "Poco/Runnable.h"
+#include "Poco/Thread.h"
+#include "Poco/Event.h"
+#include "Poco/ThreadLocal.h"
+#include "Poco/ErrorHandler.h"
+#include <sstream>
+#include <ctime>
+#if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
+#include "wce_time.h"
+#endif
+
+
+namespace Poco {
+
+
+class PooledThread: public Runnable
+{
+public:
+	PooledThread(const std::string& name, int stackSize = POCO_THREAD_STACK_SIZE);
+	~PooledThread();
+
+	void start();
+	void start(Thread::Priority priority, Runnable& target);
+	void start(Thread::Priority priority, Runnable& target, const std::string& name);
+	bool idle();
+	int idleTime();
+	void join();
+	void activate();
+	void release();
+	void run();
+
+private:
+	volatile bool        _idle;
+	volatile std::time_t _idleTime;
+	Runnable*            _pTarget;
+	std::string          _name;
+	Thread               _thread;
+	Event                _targetReady;
+	Event                _targetCompleted;
+	Event                _started;
+	FastMutex            _mutex;
+};
+
+
+PooledThread::PooledThread(const std::string& name, int stackSize): 
+	_idle(true), 
+	_idleTime(0), 
+	_pTarget(0), 
+	_name(name), 
+	_thread(name),
+	_targetCompleted(false)
+{
+	poco_assert_dbg (stackSize >= 0);
+	_thread.setStackSize(stackSize);
+#if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
+	_idleTime = wceex_time(NULL);
+#else
+	_idleTime = std::time(NULL);
+#endif
+}
+
+
+PooledThread::~PooledThread()
+{
+}
+
+
+void PooledThread::start()
+{
+	_thread.start(*this);
+	_started.wait();
+}
+
+
+void PooledThread::start(Thread::Priority priority, Runnable& target)
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	poco_assert (_pTarget == 0);
+
+	_pTarget = &target;
+	_thread.setPriority(priority);
+	_targetReady.set();
+}
+
+
+void PooledThread::start(Thread::Priority priority, Runnable& target, const std::string& name)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	std::string fullName(name);
+	if (name.empty())
+	{
+		fullName = _name;
+	}
+	else
+	{
+		fullName.append(" (");
+		fullName.append(_name);
+		fullName.append(")");
+	}
+	_thread.setName(fullName);
+	_thread.setPriority(priority);
+	
+	poco_assert (_pTarget == 0);
+
+	_pTarget = &target;
+	_targetReady.set();
+}
+
+
+inline bool PooledThread::idle()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	return _idle;
+}
+
+
+int PooledThread::idleTime()
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+#if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
+	return (int) (wceex_time(NULL) - _idleTime);
+#else
+	return (int) (time(NULL) - _idleTime);
+#endif	
+}
+
+
+void PooledThread::join()
+{
+	_mutex.lock();
+	Runnable* pTarget = _pTarget;
+	_mutex.unlock();
+	if (pTarget)
+		_targetCompleted.wait();
+}
+
+
+void PooledThread::activate()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	poco_assert (_idle);
+	_idle = false;
+	_targetCompleted.reset();
+}
+
+
+void PooledThread::release()
+{
+	const long JOIN_TIMEOUT = 10000;
+	
+	_mutex.lock();
+	_pTarget = 0;
+	_mutex.unlock();
+	// In case of a statically allocated thread pool (such
+	// as the default thread pool), Windows may have already
+	// terminated the thread before we got here.
+	if (_thread.isRunning())
+		_targetReady.set();
+
+	if (_thread.tryJoin(JOIN_TIMEOUT))
+	{
+		delete this;
+	}
+}
+
+
+void PooledThread::run()
+{
+	_started.set();
+	for (;;)
+	{
+		_targetReady.wait();
+		_mutex.lock();
+		if (_pTarget) // a NULL target means kill yourself
+		{
+			Runnable* pTarget = _pTarget;
+			_mutex.unlock();
+			try
+			{
+				pTarget->run();
+			}
+			catch (Exception& exc)
+			{
+				ErrorHandler::handle(exc);
+			}
+			catch (std::exception& exc)
+			{
+				ErrorHandler::handle(exc);
+			}
+			catch (...)
+			{
+				ErrorHandler::handle();
+			}
+			FastMutex::ScopedLock lock(_mutex);
+			_pTarget  = 0;
+#if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
+			_idleTime = wceex_time(NULL);
+#else
+			_idleTime = time(NULL);
+#endif	
+			_idle     = true;
+			_targetCompleted.set();
+			ThreadLocalStorage::clear();
+			_thread.setName(_name);
+			_thread.setPriority(Thread::PRIO_NORMAL);
+		}
+		else
+		{
+			_mutex.unlock();
+			break;
+		}
+	}
+}
+
+
+ThreadPool::ThreadPool(int minCapacity,
+	int maxCapacity,
+	int idleTime,
+	int stackSize): 
+	_minCapacity(minCapacity), 
+	_maxCapacity(maxCapacity), 
+	_idleTime(idleTime),
+	_serial(0),
+	_age(0),
+	_stackSize(stackSize)
+{
+	poco_assert (minCapacity >= 1 && maxCapacity >= minCapacity && idleTime > 0);
+
+	for (int i = 0; i < _minCapacity; i++)
+	{
+		PooledThread* pThread = createThread();
+		_threads.push_back(pThread);
+		pThread->start();
+	}
+}
+
+
+ThreadPool::ThreadPool(const std::string& name,
+	int minCapacity,
+	int maxCapacity,
+	int idleTime,
+	int stackSize):
+	_name(name),
+	_minCapacity(minCapacity), 
+	_maxCapacity(maxCapacity), 
+	_idleTime(idleTime),
+	_serial(0),
+	_age(0),
+	_stackSize(stackSize)
+{
+	poco_assert (minCapacity >= 1 && maxCapacity >= minCapacity && idleTime > 0);
+
+	for (int i = 0; i < _minCapacity; i++)
+	{
+		PooledThread* pThread = createThread();
+		_threads.push_back(pThread);
+		pThread->start();
+	}
+}
+
+
+ThreadPool::~ThreadPool()
+{
+	try
+	{
+		stopAll();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void ThreadPool::addCapacity(int n)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	poco_assert (_maxCapacity + n >= _minCapacity);
+	_maxCapacity += n;
+	housekeep();
+}
+
+
+int ThreadPool::capacity() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+	return _maxCapacity;
+}
+
+
+int ThreadPool::available() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	int count = 0;
+	for (ThreadVec::const_iterator it = _threads.begin(); it != _threads.end(); ++it)
+	{
+		if ((*it)->idle()) ++count;
+	}
+	return (int) (count + _maxCapacity - _threads.size());
+}
+
+
+int ThreadPool::used() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	int count = 0;
+	for (ThreadVec::const_iterator it = _threads.begin(); it != _threads.end(); ++it)
+	{
+		if (!(*it)->idle()) ++count;
+	}
+	return count;
+}
+
+
+int ThreadPool::allocated() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	return int(_threads.size());
+}
+
+
+void ThreadPool::start(Runnable& target)
+{
+	getThread()->start(Thread::PRIO_NORMAL, target);
+}
+
+
+void ThreadPool::start(Runnable& target, const std::string& name)
+{
+	getThread()->start(Thread::PRIO_NORMAL, target, name);
+}
+
+
+void ThreadPool::startWithPriority(Thread::Priority priority, Runnable& target)
+{
+	getThread()->start(priority, target);
+}
+
+
+void ThreadPool::startWithPriority(Thread::Priority priority, Runnable& target, const std::string& name)
+{
+	getThread()->start(priority, target, name);
+}
+
+
+void ThreadPool::stopAll()
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	for (ThreadVec::iterator it = _threads.begin(); it != _threads.end(); ++it)
+	{
+		(*it)->release();
+	}
+	_threads.clear();
+}
+
+
+void ThreadPool::joinAll()
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	for (ThreadVec::iterator it = _threads.begin(); it != _threads.end(); ++it)
+	{
+		(*it)->join();
+	}
+	housekeep();
+}
+
+
+void ThreadPool::collect()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	housekeep();
+}
+
+
+void ThreadPool::housekeep()
+{
+	_age = 0;
+	if (_threads.size() <= _minCapacity)
+		return;
+
+	ThreadVec idleThreads;
+	ThreadVec expiredThreads;
+	ThreadVec activeThreads;
+	idleThreads.reserve(_threads.size());
+	activeThreads.reserve(_threads.size());
+	
+	for (ThreadVec::iterator it = _threads.begin(); it != _threads.end(); ++it)
+	{
+		if ((*it)->idle())
+		{
+			if ((*it)->idleTime() < _idleTime)
+				idleThreads.push_back(*it);
+			else 
+				expiredThreads.push_back(*it);	
+		}
+		else activeThreads.push_back(*it);
+	}
+	int n = (int) activeThreads.size();
+	int limit = (int) idleThreads.size() + n;
+	if (limit < _minCapacity) limit = _minCapacity;
+	idleThreads.insert(idleThreads.end(), expiredThreads.begin(), expiredThreads.end());
+	_threads.clear();
+	for (ThreadVec::iterator it = idleThreads.begin(); it != idleThreads.end(); ++it)
+	{
+		if (n < limit)
+		{
+			_threads.push_back(*it);
+			++n;
+		}
+		else (*it)->release();
+	}
+	_threads.insert(_threads.end(), activeThreads.begin(), activeThreads.end());
+}
+
+
+PooledThread* ThreadPool::getThread()
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (++_age == 32)
+		housekeep();
+
+	PooledThread* pThread = 0;
+	for (ThreadVec::iterator it = _threads.begin(); !pThread && it != _threads.end(); ++it)
+	{
+		if ((*it)->idle())
+			pThread = *it;
+	}
+	if (!pThread)
+	{
+		if (_threads.size() < _maxCapacity)
+		{
+			pThread = createThread();
+			try
+			{
+				pThread->start();
+				_threads.push_back(pThread);
+			} catch (...)
+			{
+				delete pThread;
+				throw;
+			}
+		}
+		else
+			throw NoThreadAvailableException();
+	}
+	pThread->activate();
+	return pThread;
+}
+
+
+PooledThread* ThreadPool::createThread()
+{
+	std::ostringstream name;
+	name << _name << "[#" << ++_serial << "]";
+	return new PooledThread(name.str(), _stackSize);
+}
+
+
+class ThreadPoolSingletonHolder
+{
+public:
+	ThreadPoolSingletonHolder()
+	{
+		_pPool = 0;
+	}
+	~ThreadPoolSingletonHolder()
+	{
+		delete _pPool;
+	}
+	ThreadPool* pool()
+	{
+		FastMutex::ScopedLock lock(_mutex);
+		
+		if (!_pPool)
+		{
+			_pPool = new ThreadPool("default");
+			if (POCO_THREAD_STACK_SIZE > 0)
+				_pPool->setStackSize(POCO_THREAD_STACK_SIZE);
+		}
+		return _pPool;
+	}
+	
+private:
+	ThreadPool* _pPool;
+	FastMutex   _mutex;
+};
+
+
+namespace
+{
+	static ThreadPoolSingletonHolder sh;
+}
+
+
+ThreadPool& ThreadPool::defaultPool()
+{
+	return *sh.pool();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/ThreadTarget.cpp b/base/poco/Foundation/src/ThreadTarget.cpp
new file mode 100644
index 00000000000..054cee8cbd3
--- /dev/null
+++ b/base/poco/Foundation/src/ThreadTarget.cpp
@@ -0,0 +1,43 @@
+//
+// ThreadTarget.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  ThreadTarget
+//
+// Copyright (c) 2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/ThreadTarget.h"
+
+
+namespace Poco {
+
+
+ThreadTarget::ThreadTarget(Callback method): _method(method)
+{
+}
+
+
+ThreadTarget::ThreadTarget(const ThreadTarget& te): _method(te._method)
+{
+}
+
+
+ThreadTarget& ThreadTarget::operator = (const ThreadTarget& te)
+{
+	_method  = te._method;
+	return *this;
+}
+
+
+ThreadTarget::~ThreadTarget()
+{
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Thread_POSIX.cpp b/base/poco/Foundation/src/Thread_POSIX.cpp
new file mode 100644
index 00000000000..ac3eefdeb70
--- /dev/null
+++ b/base/poco/Foundation/src/Thread_POSIX.cpp
@@ -0,0 +1,412 @@
+//
+// Thread_POSIX.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Thread
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Thread_POSIX.h"
+#include "Poco/Thread.h"
+#include "Poco/Exception.h"
+#include "Poco/ErrorHandler.h"
+#include "Poco/Timespan.h"
+#include "Poco/Timestamp.h"
+#include <signal.h>
+#if defined(__sun) && defined(__SVR4)
+#	if !defined(__EXTENSIONS__)
+#		define __EXTENSIONS__
+#	endif
+#endif
+#if POCO_OS == POCO_OS_LINUX || POCO_OS == POCO_OS_ANDROID || POCO_OS == POCO_OS_MAC_OS_X || POCO_OS == POCO_OS_QNX
+#	include <time.h>
+#endif
+
+//
+// Block SIGPIPE in main thread.
+//
+#if defined(POCO_OS_FAMILY_UNIX) && !defined(POCO_VXWORKS)
+namespace
+{
+	class SignalBlocker
+	{
+	public:
+		SignalBlocker()
+		{
+			sigset_t sset;
+			sigemptyset(&sset);
+			sigaddset(&sset, SIGPIPE);
+			pthread_sigmask(SIG_BLOCK, &sset, 0);
+		}
+		~SignalBlocker()
+		{
+		}
+	};
+
+	static SignalBlocker signalBlocker;
+}
+#endif
+
+
+#if defined(POCO_POSIX_DEBUGGER_THREAD_NAMES)
+
+
+namespace {
+void setThreadName(pthread_t thread, const std::string& threadName)
+{
+#if (POCO_OS == POCO_OS_MAC_OS_X)
+	pthread_setname_np(threadName.c_str()); // __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2)
+#else
+	if (pthread_setname_np(thread, threadName.c_str()) == ERANGE && threadName.size() > 15)
+	{
+		std::string truncName(threadName, 0, 7);
+		truncName.append("~");
+		truncName.append(threadName, threadName.size() - 7, 7);
+		pthread_setname_np(thread, truncName.c_str());
+	}
+#endif
+}
+}
+
+
+#endif
+
+
+namespace Poco {
+
+
+ThreadImpl::CurrentThreadHolder ThreadImpl::_currentThreadHolder;
+
+
+ThreadImpl::ThreadImpl():
+	_pData(new ThreadData)
+{
+}
+
+
+ThreadImpl::~ThreadImpl()
+{
+	if (_pData->started && !_pData->joined)
+	{
+		pthread_detach(_pData->thread);
+	}
+}
+
+
+void ThreadImpl::setPriorityImpl(int prio)
+{
+	if (prio != _pData->prio)
+	{
+		_pData->prio = prio;
+		_pData->policy = SCHED_OTHER;
+		if (isRunningImpl())
+		{
+			struct sched_param par; struct MyStruct
+			{
+
+			};
+			par.sched_priority = mapPrio(_pData->prio, SCHED_OTHER);
+			if (pthread_setschedparam(_pData->thread, SCHED_OTHER, &par))
+				throw SystemException("cannot set thread priority");
+		}
+	}
+}
+
+
+void ThreadImpl::setOSPriorityImpl(int prio, int policy)
+{
+	if (prio != _pData->osPrio || policy != _pData->policy)
+	{
+		if (_pData->pRunnableTarget)
+		{
+			struct sched_param par;
+			par.sched_priority = prio;
+			if (pthread_setschedparam(_pData->thread, policy, &par))
+				throw SystemException("cannot set thread priority");
+		}
+		_pData->prio   = reverseMapPrio(prio, policy);
+		_pData->osPrio = prio;
+		_pData->policy = policy;
+	}
+}
+
+
+int ThreadImpl::getMinOSPriorityImpl(int policy)
+{
+#if defined(POCO_THREAD_PRIORITY_MIN)
+	return POCO_THREAD_PRIORITY_MIN;
+#elif defined(__digital__)
+	return PRI_OTHER_MIN;
+#else
+	return sched_get_priority_min(policy);
+#endif
+}
+
+
+int ThreadImpl::getMaxOSPriorityImpl(int policy)
+{
+#if defined(POCO_THREAD_PRIORITY_MAX)
+	return POCO_THREAD_PRIORITY_MAX;
+#elif defined(__digital__)
+	return PRI_OTHER_MAX;
+#else
+	return sched_get_priority_max(policy);
+#endif
+}
+
+
+void ThreadImpl::setStackSizeImpl(int size)
+{
+#ifndef PTHREAD_STACK_MIN
+	_pData->stackSize = 0;
+#else
+	if (size != 0)
+	{
+#if defined(POCO_OS_FAMILY_BSD)
+		// we must round up to a multiple of the memory page size
+		const int STACK_PAGE_SIZE = 4096;
+		size = ((size + STACK_PAGE_SIZE - 1)/STACK_PAGE_SIZE)*STACK_PAGE_SIZE;
+#endif
+ 		if (size < PTHREAD_STACK_MIN)
+ 			size = PTHREAD_STACK_MIN;
+	}
+ 	_pData->stackSize = size;
+#endif
+}
+
+
+void ThreadImpl::startImpl(SharedPtr<Runnable> pTarget)
+{
+	if (_pData->pRunnableTarget)
+		throw SystemException("thread already running");
+
+	pthread_attr_t attributes;
+	pthread_attr_init(&attributes);
+
+	if (_pData->stackSize != 0)
+	{
+		if (0 != pthread_attr_setstacksize(&attributes, _pData->stackSize))
+		{
+			pthread_attr_destroy(&attributes);
+			throw SystemException("cannot set thread stack size");
+		}
+	}
+
+	_pData->pRunnableTarget = pTarget;
+	if (pthread_create(&_pData->thread, &attributes, runnableEntry, this))
+	{
+		_pData->pRunnableTarget = 0;
+		pthread_attr_destroy(&attributes);
+		throw SystemException("cannot start thread");
+	}
+	_pData->started = true;
+	pthread_attr_destroy(&attributes);
+
+	if (_pData->policy == SCHED_OTHER)
+	{
+		if (_pData->prio != PRIO_NORMAL_IMPL)
+		{
+			struct sched_param par;
+			par.sched_priority = mapPrio(_pData->prio, SCHED_OTHER);
+			if (pthread_setschedparam(_pData->thread, SCHED_OTHER, &par))
+				throw SystemException("cannot set thread priority");
+		}
+	}
+	else
+	{
+		struct sched_param par;
+		par.sched_priority = _pData->osPrio;
+		if (pthread_setschedparam(_pData->thread, _pData->policy, &par))
+			throw SystemException("cannot set thread priority");
+	}
+}
+
+
+void ThreadImpl::joinImpl()
+{
+	if (!_pData->started) return;
+	_pData->done.wait();
+	void* result;
+	if (pthread_join(_pData->thread, &result))
+		throw SystemException("cannot join thread");
+	_pData->joined = true;
+}
+
+
+bool ThreadImpl::joinImpl(long milliseconds)
+{
+	if (_pData->started && _pData->done.tryWait(milliseconds))
+	{
+		void* result;
+		if (pthread_join(_pData->thread, &result))
+			throw SystemException("cannot join thread");
+		_pData->joined = true;
+		return true;
+	}
+	else if (_pData->started) return false;
+	else return true;
+}
+
+
+ThreadImpl* ThreadImpl::currentImpl()
+{
+	return _currentThreadHolder.get();
+}
+
+
+ThreadImpl::TIDImpl ThreadImpl::currentTidImpl()
+{
+	return pthread_self();
+}
+
+
+void ThreadImpl::sleepImpl(long milliseconds)
+{
+#if defined(__digital__)
+		// This is specific to DECThreads
+		struct timespec interval;
+		interval.tv_sec  = milliseconds / 1000;
+		interval.tv_nsec = (milliseconds % 1000)*1000000;
+		pthread_delay_np(&interval);
+#elif POCO_OS == POCO_OS_LINUX || POCO_OS == POCO_OS_ANDROID || POCO_OS == POCO_OS_MAC_OS_X || POCO_OS == POCO_OS_QNX || POCO_OS == POCO_OS_VXWORKS
+	Poco::Timespan remainingTime(1000*Poco::Timespan::TimeDiff(milliseconds));
+	int rc;
+	do
+	{
+		struct timespec ts;
+		ts.tv_sec  = (long) remainingTime.totalSeconds();
+		ts.tv_nsec = (long) remainingTime.useconds()*1000;
+		Poco::Timestamp start;
+		rc = ::nanosleep(&ts, 0);
+		if (rc < 0 && errno == EINTR)
+		{
+			Poco::Timestamp end;
+			Poco::Timespan waited = start.elapsed();
+			if (waited < remainingTime)
+				remainingTime -= waited;
+			else
+				remainingTime = 0;
+		}
+	}
+	while (remainingTime > 0 && rc < 0 && errno == EINTR);
+	if (rc < 0 && remainingTime > 0) throw Poco::SystemException("Thread::sleep(): nanosleep() failed");
+#else
+	Poco::Timespan remainingTime(1000*Poco::Timespan::TimeDiff(milliseconds));
+	int rc;
+	do
+	{
+		struct timeval tv;
+		tv.tv_sec  = (long) remainingTime.totalSeconds();
+		tv.tv_usec = (long) remainingTime.useconds();
+		Poco::Timestamp start;
+		rc = ::select(0, NULL, NULL, NULL, &tv);
+		if (rc < 0 && errno == EINTR)
+		{
+			Poco::Timestamp end;
+			Poco::Timespan waited = start.elapsed();
+			if (waited < remainingTime)
+				remainingTime -= waited;
+			else
+				remainingTime = 0;
+		}
+	}
+	while (remainingTime > 0 && rc < 0 && errno == EINTR);
+	if (rc < 0 && remainingTime > 0) throw Poco::SystemException("Thread::sleep(): select() failed");
+#endif
+}
+
+
+void* ThreadImpl::runnableEntry(void* pThread)
+{
+	_currentThreadHolder.set(reinterpret_cast<ThreadImpl*>(pThread));
+
+#if defined(POCO_OS_FAMILY_UNIX)
+	sigset_t sset;
+	sigemptyset(&sset);
+	sigaddset(&sset, SIGQUIT);
+	sigaddset(&sset, SIGTERM);
+	sigaddset(&sset, SIGPIPE);
+	pthread_sigmask(SIG_BLOCK, &sset, 0);
+#endif
+
+	ThreadImpl* pThreadImpl = reinterpret_cast<ThreadImpl*>(pThread);
+#if defined(POCO_POSIX_DEBUGGER_THREAD_NAMES)
+	setThreadName(pThreadImpl->_pData->thread, reinterpret_cast<Thread*>(pThread)->getName());
+#endif
+	AutoPtr<ThreadData> pData = pThreadImpl->_pData;
+	try
+	{
+		pData->pRunnableTarget->run();
+	}
+	catch (Exception& exc)
+	{
+		ErrorHandler::handle(exc);
+	}
+	catch (std::exception& exc)
+	{
+		ErrorHandler::handle(exc);
+	}
+	catch (...)
+	{
+		ErrorHandler::handle();
+	}
+
+	pData->pRunnableTarget = 0;
+	pData->done.set();
+	return 0;
+}
+
+
+int ThreadImpl::mapPrio(int prio, int policy)
+{
+	int pmin = getMinOSPriorityImpl(policy);
+	int pmax = getMaxOSPriorityImpl(policy);
+
+	switch (prio)
+	{
+	case PRIO_LOWEST_IMPL:
+		return pmin;
+	case PRIO_LOW_IMPL:
+		return pmin + (pmax - pmin)/4;
+	case PRIO_NORMAL_IMPL:
+		return pmin + (pmax - pmin)/2;
+	case PRIO_HIGH_IMPL:
+		return pmin + 3*(pmax - pmin)/4;
+	case PRIO_HIGHEST_IMPL:
+		return pmax;
+	default:
+		poco_bugcheck_msg("invalid thread priority");
+	}
+	return -1; // just to satisfy compiler - we'll never get here anyway
+}
+
+
+int ThreadImpl::reverseMapPrio(int prio, int policy)
+{
+	if (policy == SCHED_OTHER)
+	{
+		int pmin = getMinOSPriorityImpl(policy);
+		int pmax = getMaxOSPriorityImpl(policy);
+		int normal = pmin + (pmax - pmin)/2;
+		if (prio == pmax)
+			return PRIO_HIGHEST_IMPL;
+		if (prio > normal)
+			return PRIO_HIGH_IMPL;
+		else if (prio == normal)
+			return PRIO_NORMAL_IMPL;
+		else if (prio > pmin)
+			return PRIO_LOW_IMPL;
+		else
+			return PRIO_LOWEST_IMPL;
+	}
+	else return PRIO_HIGHEST_IMPL;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Thread_VX.cpp b/base/poco/Foundation/src/Thread_VX.cpp
new file mode 100644
index 00000000000..d1883bf9156
--- /dev/null
+++ b/base/poco/Foundation/src/Thread_VX.cpp
@@ -0,0 +1,273 @@
+//
+// Thread_VX.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Thread
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Thread_VX.h"
+#include "Poco/ErrorHandler.h"
+#include "Poco/Exception.h"
+#include "Poco/Timestamp.h"
+#include "Poco/Timespan.h"
+#include <timers.h>
+
+
+namespace Poco {
+
+
+ThreadImpl* ThreadImpl::_pCurrent(0);
+
+
+ThreadImpl::ThreadImpl():
+	_pData(new ThreadData)
+{
+}
+
+			
+ThreadImpl::~ThreadImpl()
+{
+}
+
+
+void ThreadImpl::setPriorityImpl(int prio)
+{
+	if (prio != _pData->prio)
+	{
+		_pData->prio   = prio;
+		_pData->osPrio = mapPrio(_pData->prio);
+		if (isRunningImpl())
+		{
+			if (taskPrioritySet(_pData->task, _pData->osPrio) != OK)
+				throw SystemException("cannot set task priority");
+		}
+	}
+}
+
+
+void ThreadImpl::setOSPriorityImpl(int prio, int /* policy */)
+{
+	if (prio != _pData->osPrio)
+	{
+		_pData->prio   = reverseMapPrio(prio);
+		_pData->osPrio = prio;
+		if (_pData->pRunnableTarget || _pData->pCallbackTarget)
+		{
+			if (taskPrioritySet(_pData->task, prio) != OK)
+				throw SystemException("cannot set task priority");
+		}
+	}
+}
+
+
+int ThreadImpl::getMinOSPriorityImpl(int /* policy */)
+{
+	return 255;
+}
+
+
+int ThreadImpl::getMaxOSPriorityImpl(int /* policy */)
+{
+	return 0;
+}
+
+
+void ThreadImpl::setStackSizeImpl(int size)
+{
+	_pData->stackSize = size;
+}
+
+
+void ThreadImpl::startImpl(Runnable& target)
+{
+	if (_pData->pRunnableTarget)
+		throw SystemException("thread already running");
+
+	_pData->pRunnableTarget = &target;
+	
+	int stackSize = _pData->stackSize == 0 ? DEFAULT_THREAD_STACK_SIZE : _pData->stackSize;
+	int id = taskSpawn(NULL, _pData->osPrio, VX_FP_TASK, stackSize, reinterpret_cast<FUNCPTR>(runnableEntry), reinterpret_cast<int>(this), 0, 0, 0, 0, 0, 0, 0, 0, 0);
+	if (id == ERROR)
+		throw SystemException("cannot spawn task");
+
+	_pData->task = id;
+}
+
+
+void ThreadImpl::startImpl(Callable target, void* pData)
+{
+	if (_pData->pCallbackTarget && _pData->pCallbackTarget->callback)
+		throw SystemException("thread already running");
+
+	if (0 == _pData->pCallbackTarget.get())
+		_pData->pCallbackTarget = new CallbackData;
+
+	_pData->pCallbackTarget->callback = target;
+	_pData->pCallbackTarget->pData = pData;
+
+	int stackSize = _pData->stackSize == 0 ? DEFAULT_THREAD_STACK_SIZE : _pData->stackSize;
+	int id = taskSpawn(NULL, _pData->osPrio, VX_FP_TASK, stackSize, reinterpret_cast<FUNCPTR>(callableEntry), reinterpret_cast<int>(this), 0, 0, 0, 0, 0, 0, 0, 0, 0);
+	if (id == ERROR)
+		throw SystemException("cannot spawn task");
+
+	_pData->task = id;
+}
+
+
+void ThreadImpl::joinImpl()
+{
+	_pData->done.wait();
+}
+
+
+bool ThreadImpl::joinImpl(long milliseconds)
+{
+	return _pData->done.tryWait(milliseconds);
+}
+
+
+ThreadImpl* ThreadImpl::currentImpl()
+{
+	return _pCurrent;
+}
+
+
+ThreadImpl::TIDImpl ThreadImpl::currentTidImpl()
+{
+    return taskIdSelf();
+}
+
+
+void ThreadImpl::sleepImpl(long milliseconds)
+{
+	Poco::Timespan remainingTime(1000*Poco::Timespan::TimeDiff(milliseconds));
+	int rc;
+	do
+	{
+		struct timespec ts;
+		ts.tv_sec  = (long) remainingTime.totalSeconds();
+		ts.tv_nsec = (long) remainingTime.useconds()*1000;
+		Poco::Timestamp start;
+		rc = ::nanosleep(&ts, 0);
+		if (rc < 0 && errno == EINTR)
+		{
+			Poco::Timestamp end;
+			Poco::Timespan waited = start.elapsed();
+			if (waited < remainingTime)
+				remainingTime -= waited;
+			else
+				remainingTime = 0;
+		}
+	}
+	while (remainingTime > 0 && rc < 0 && errno == EINTR);
+	if (rc < 0 && remainingTime > 0) throw Poco::SystemException("Thread::sleep(): nanosleep() failed");
+}
+
+
+void ThreadImpl::runnableEntry(void* pThread, int, int, int, int, int, int, int, int, int)
+{
+	taskVarAdd(0, reinterpret_cast<int*>(&_pCurrent));
+	_pCurrent = reinterpret_cast<ThreadImpl*>(pThread);
+
+	AutoPtr<ThreadData> pData = _pCurrent->_pData;
+	try
+	{
+		pData->pRunnableTarget->run();
+	}
+	catch (Exception& exc)
+	{
+		ErrorHandler::handle(exc);
+	}
+	catch (std::exception& exc)
+	{
+		ErrorHandler::handle(exc);
+	}
+	catch (...)
+	{
+		ErrorHandler::handle();
+	}
+
+	pData->pRunnableTarget = 0;
+	pData->done.set();
+}
+
+
+void ThreadImpl::callableEntry(void* pThread, int, int, int, int, int, int, int, int, int)
+{
+	taskVarAdd(0, reinterpret_cast<int*>(&_pCurrent));
+	_pCurrent = reinterpret_cast<ThreadImpl*>(pThread);
+
+	AutoPtr<ThreadData> pData = _pCurrent->_pData;
+	try
+	{
+		pData->pCallbackTarget->callback(pData->pCallbackTarget->pData);
+	}
+	catch (Exception& exc)
+	{
+		ErrorHandler::handle(exc);
+	}
+	catch (std::exception& exc)
+	{
+		ErrorHandler::handle(exc);
+	}
+	catch (...)
+	{
+		ErrorHandler::handle();
+	}
+
+	pData->pCallbackTarget->callback = 0;
+	pData->pCallbackTarget->pData = 0;
+	pData->done.set();
+}
+
+
+int ThreadImpl::mapPrio(int prio)
+{
+	int pmin = getMinOSPriorityImpl();
+	int pmax = getMaxOSPriorityImpl();
+
+	switch (prio)
+	{
+	case PRIO_LOWEST_IMPL:
+		return pmin;
+	case PRIO_LOW_IMPL:
+		return pmin + (pmax - pmin)/4;
+	case PRIO_NORMAL_IMPL:
+		return pmin + (pmax - pmin)/2;
+	case PRIO_HIGH_IMPL:
+		return pmin + 3*(pmax - pmin)/4;
+	case PRIO_HIGHEST_IMPL:
+		return pmax;
+	default:
+		poco_bugcheck_msg("invalid thread priority");
+	}
+	return -1; // just to satisfy compiler - we'll never get here anyway
+}
+
+
+int ThreadImpl::reverseMapPrio(int prio)
+{
+	int pmin = getMinOSPriorityImpl();
+	int pmax = getMaxOSPriorityImpl();
+	int normal = pmin + (pmax - pmin)/2;
+	if (prio == pmax)
+		return PRIO_HIGHEST_IMPL;
+	if (prio > normal)
+		return PRIO_HIGH_IMPL;
+	else if (prio == normal)
+		return PRIO_NORMAL_IMPL;
+	else if (prio > pmin)
+		return PRIO_LOW_IMPL;
+	else
+		return PRIO_LOWEST_IMPL;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Thread_WIN32.cpp b/base/poco/Foundation/src/Thread_WIN32.cpp
new file mode 100644
index 00000000000..9bd6d25b976
--- /dev/null
+++ b/base/poco/Foundation/src/Thread_WIN32.cpp
@@ -0,0 +1,223 @@
+//
+// Thread_WIN32.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Thread
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Thread_WIN32.h"
+#include "Poco/Exception.h"
+#include "Poco/ErrorHandler.h"
+#include <process.h>
+
+
+#if defined(POCO_WIN32_DEBUGGER_THREAD_NAMES)
+
+
+namespace
+{
+	/// See <http://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx> 
+	/// and <http://blogs.msdn.com/b/stevejs/archive/2005/12/19/505815.aspx> for
+	/// more information on the code below.
+
+	const DWORD MS_VC_EXCEPTION = 0x406D1388;
+	
+	#pragma pack(push,8)
+	typedef struct tagTHREADNAME_INFO
+	{
+		DWORD dwType;     // Must be 0x1000.
+		LPCSTR szName;    // Pointer to name (in user addr space).
+		DWORD dwThreadID; // Thread ID (-1=caller thread).
+		DWORD dwFlags;    // Reserved for future use, must be zero.
+	} THREADNAME_INFO;
+	#pragma pack(pop)
+	
+	void setThreadName(DWORD dwThreadID, const char* threadName)
+	{
+        THREADNAME_INFO info;
+        info.dwType     = 0x1000;
+        info.szName     = threadName;
+        info.dwThreadID = dwThreadID;
+        info.dwFlags    = 0;
+    
+        __try
+        {
+            RaiseException(MS_VC_EXCEPTION, 0, sizeof(info)/sizeof(ULONG_PTR), (ULONG_PTR*)&info);
+        }
+        __except (EXCEPTION_CONTINUE_EXECUTION)
+        {
+        }
+	}
+}
+
+
+#endif
+
+
+namespace Poco {
+
+
+ThreadImpl::CurrentThreadHolder ThreadImpl::_currentThreadHolder;
+
+
+ThreadImpl::ThreadImpl():
+	_thread(0),
+	_threadId(0),
+	_prio(PRIO_NORMAL_IMPL),
+	_stackSize(POCO_THREAD_STACK_SIZE)
+{
+}
+
+
+ThreadImpl::~ThreadImpl()
+{
+	if (_thread) CloseHandle(_thread);
+}
+
+
+void ThreadImpl::setPriorityImpl(int prio)
+{
+	if (prio != _prio)
+	{
+		_prio = prio;
+		if (_thread)
+		{
+			if (SetThreadPriority(_thread, _prio) == 0)
+				throw SystemException("cannot set thread priority");
+		}
+	}
+}
+
+
+void ThreadImpl::setOSPriorityImpl(int prio, int /* policy */)
+{
+	setPriorityImpl(prio);
+}
+
+
+void ThreadImpl::startImpl(SharedPtr<Runnable> pTarget)
+{
+	if (isRunningImpl())
+		throw SystemException("thread already running");
+
+	_pRunnableTarget = pTarget;
+	createImpl(runnableEntry, this);
+}
+
+
+void ThreadImpl::createImpl(Entry ent, void* pData)
+{
+#if defined(_DLL)
+	_thread = CreateThread(NULL, _stackSize, ent, pData, 0, &_threadId);
+#else
+	unsigned threadId;
+	_thread = (HANDLE) _beginthreadex(NULL, _stackSize, ent, this, 0, &threadId);
+	_threadId = static_cast<DWORD>(threadId);
+#endif
+	if (!_thread)
+		throw SystemException("cannot create thread");
+	if (_prio != PRIO_NORMAL_IMPL && !SetThreadPriority(_thread, _prio))
+		throw SystemException("cannot set thread priority");
+}
+
+
+void ThreadImpl::joinImpl()
+{
+	if (!_thread) return;
+
+	switch (WaitForSingleObject(_thread, INFINITE))
+	{
+	case WAIT_OBJECT_0:
+		threadCleanup();
+		return;
+	default:
+		throw SystemException("cannot join thread");
+	}
+}
+
+
+bool ThreadImpl::joinImpl(long milliseconds)
+{
+	if (!_thread) return true;
+
+	switch (WaitForSingleObject(_thread, milliseconds + 1))
+	{
+	case WAIT_TIMEOUT:
+		return false;
+	case WAIT_OBJECT_0:
+		threadCleanup();
+		return true;
+	default:
+		throw SystemException("cannot join thread");
+	}
+}
+
+
+bool ThreadImpl::isRunningImpl() const
+{
+	if (_thread)
+	{
+		DWORD ec = 0;
+		return GetExitCodeThread(_thread, &ec) && ec == STILL_ACTIVE;
+	}
+	return false;
+}
+
+
+void ThreadImpl::threadCleanup()
+{
+	if (!_thread) return;
+	if (CloseHandle(_thread)) _thread = 0;
+}
+
+
+ThreadImpl* ThreadImpl::currentImpl()
+{
+	return _currentThreadHolder.get();
+}
+
+
+ThreadImpl::TIDImpl ThreadImpl::currentTidImpl()
+{
+	return GetCurrentThreadId();
+}
+
+
+#if defined(_DLL)
+DWORD WINAPI ThreadImpl::runnableEntry(LPVOID pThread)
+#else
+unsigned __stdcall ThreadImpl::runnableEntry(void* pThread)
+#endif
+{
+	_currentThreadHolder.set(reinterpret_cast<ThreadImpl*>(pThread));
+#if defined(POCO_WIN32_DEBUGGER_THREAD_NAMES)
+	setThreadName(-1, reinterpret_cast<Thread*>(pThread)->getName().c_str());
+#endif
+	try
+	{
+		reinterpret_cast<ThreadImpl*>(pThread)->_pRunnableTarget->run();
+	}
+	catch (Exception& exc)
+	{
+		ErrorHandler::handle(exc);
+	}
+	catch (std::exception& exc)
+	{
+		ErrorHandler::handle(exc);
+	}
+	catch (...)
+	{
+		ErrorHandler::handle();
+	}
+	return 0;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Thread_WINCE.cpp b/base/poco/Foundation/src/Thread_WINCE.cpp
new file mode 100644
index 00000000000..d769f88354c
--- /dev/null
+++ b/base/poco/Foundation/src/Thread_WINCE.cpp
@@ -0,0 +1,169 @@
+//
+// Thread_WINCE.h
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Thread
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Thread_WINCE.h"
+#include "Poco/Exception.h"
+#include "Poco/ErrorHandler.h"
+
+
+namespace Poco {
+
+
+ThreadImpl::CurrentThreadHolder ThreadImpl::_currentThreadHolder;
+
+
+ThreadImpl::ThreadImpl():
+	_pRunnableTarget(0),
+	_thread(0),
+	_threadId(0),
+	_prio(PRIO_NORMAL_IMPL),
+	_stackSize(POCO_THREAD_STACK_SIZE)
+{
+}
+
+			
+ThreadImpl::~ThreadImpl()
+{
+	if (_thread) CloseHandle(_thread);
+}
+
+
+void ThreadImpl::setPriorityImpl(int prio)
+{
+	if (prio != _prio)
+	{
+		_prio = prio;
+		if (_thread)
+		{
+			if (SetThreadPriority(_thread, _prio) == 0)
+				throw SystemException("cannot set thread priority");
+		}
+	}
+}
+
+
+void ThreadImpl::setOSPriorityImpl(int prio, int /* policy */)
+{
+	setPriorityImpl(prio);
+}
+
+
+void ThreadImpl::startImpl(SharedPtr<Runnable> pTarget)
+{
+	if (isRunningImpl())
+		throw SystemException("thread already running");
+
+	_pRunnableTarget = pTarget;
+
+	createImpl(runnableEntry, this);
+}
+
+
+void ThreadImpl::createImpl(Entry ent, void* pData)
+{
+	_thread = CreateThread(NULL, _stackSize, ent, pData, 0, &_threadId);
+
+	if (!_thread)
+		throw SystemException("cannot create thread");
+	if (_prio != PRIO_NORMAL_IMPL && !SetThreadPriority(_thread, _prio))
+		throw SystemException("cannot set thread priority");
+}
+
+
+void ThreadImpl::joinImpl()
+{
+	if (!_thread) return;
+
+	switch (WaitForSingleObject(_thread, INFINITE))
+	{
+	case WAIT_OBJECT_0:
+		threadCleanup();
+		return;
+	default:
+		throw SystemException("cannot join thread");
+	}
+}
+
+
+bool ThreadImpl::joinImpl(long milliseconds)
+{
+	if (!_thread) return true;
+
+	switch (WaitForSingleObject(_thread, milliseconds + 1))
+	{
+	case WAIT_TIMEOUT:
+		return false;
+	case WAIT_OBJECT_0:
+		threadCleanup();
+		return true;
+	default:
+		throw SystemException("cannot join thread");
+	}
+}
+
+
+bool ThreadImpl::isRunningImpl() const
+{
+	if (_thread)
+	{
+		DWORD ec = 0;
+		return GetExitCodeThread(_thread, &ec) && ec == STILL_ACTIVE;
+	}
+	return false;
+}
+
+
+void ThreadImpl::threadCleanup()
+{
+	if (!_thread) return;
+	if (CloseHandle(_thread)) _thread = 0;
+}
+
+
+ThreadImpl* ThreadImpl::currentImpl()
+{
+	return _currentThreadHolder.get();
+}
+
+
+ThreadImpl::TIDImpl ThreadImpl::currentTidImpl()
+{
+    return GetCurrentThreadId();
+}
+
+
+DWORD WINAPI ThreadImpl::runnableEntry(LPVOID pThread)
+{
+	_currentThreadHolder.set(reinterpret_cast<ThreadImpl*>(pThread));
+	try
+	{
+		reinterpret_cast<ThreadImpl*>(pThread)->_pRunnableTarget->run();
+	}
+	catch (Exception& exc)
+	{
+		ErrorHandler::handle(exc);
+	}
+	catch (std::exception& exc)
+	{
+		ErrorHandler::handle(exc);
+	}
+	catch (...)
+	{
+		ErrorHandler::handle();
+	}
+	return 0;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/TimedNotificationQueue.cpp b/base/poco/Foundation/src/TimedNotificationQueue.cpp
new file mode 100644
index 00000000000..8160bb90de5
--- /dev/null
+++ b/base/poco/Foundation/src/TimedNotificationQueue.cpp
@@ -0,0 +1,203 @@
+//
+// TimedNotificationQueue.cpp
+//
+// Library: Foundation
+// Package: Notifications
+// Module:  TimedNotificationQueue
+//
+// Copyright (c) 2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/TimedNotificationQueue.h"
+#include "Poco/Notification.h"
+#include <limits>
+
+
+namespace Poco {
+
+
+TimedNotificationQueue::TimedNotificationQueue()
+{
+}
+
+
+TimedNotificationQueue::~TimedNotificationQueue()
+{
+	try
+	{
+		clear();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void TimedNotificationQueue::enqueueNotification(Notification::Ptr pNotification, Timestamp timestamp)
+{
+	poco_check_ptr (pNotification);
+
+	Timestamp tsNow;
+	Clock clock;
+	Timestamp::TimeDiff diff = timestamp - tsNow;
+	clock += diff;
+
+	FastMutex::ScopedLock lock(_mutex);
+	_nfQueue.insert(NfQueue::value_type(clock, pNotification));
+	_nfAvailable.set();
+}
+
+
+void TimedNotificationQueue::enqueueNotification(Notification::Ptr pNotification, Clock clock)
+{
+	poco_check_ptr (pNotification);
+
+	FastMutex::ScopedLock lock(_mutex);
+	_nfQueue.insert(NfQueue::value_type(clock, pNotification));
+	_nfAvailable.set();
+}
+
+
+Notification* TimedNotificationQueue::dequeueNotification()
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	NfQueue::iterator it = _nfQueue.begin();
+	if (it != _nfQueue.end())
+	{
+		Clock::ClockDiff sleep = -it->first.elapsed();
+		if (sleep <= 0)
+		{
+			Notification::Ptr pNf = it->second;
+			_nfQueue.erase(it);
+			return pNf.duplicate();
+		}
+	}
+	return 0;
+}
+
+
+Notification* TimedNotificationQueue::waitDequeueNotification()
+{
+	for (;;)
+	{
+		_mutex.lock();
+		NfQueue::iterator it = _nfQueue.begin();
+		if (it != _nfQueue.end())
+		{
+			_mutex.unlock();
+			Clock::ClockDiff sleep = -it->first.elapsed();
+			if (sleep <= 0)
+			{
+				return dequeueOne(it).duplicate();
+			}
+			else if (!wait(sleep))
+			{
+				return dequeueOne(it).duplicate();
+			}
+			else continue;
+		}
+		else
+		{
+			_mutex.unlock();
+		}
+		_nfAvailable.wait();
+	}
+}
+
+
+Notification* TimedNotificationQueue::waitDequeueNotification(long milliseconds)
+{
+	while (milliseconds >= 0)
+	{
+		_mutex.lock();
+		NfQueue::iterator it = _nfQueue.begin();
+		if (it != _nfQueue.end())
+		{
+			_mutex.unlock();
+			Clock now;
+			Clock::ClockDiff sleep = it->first - now;
+			if (sleep <= 0)
+			{
+				return dequeueOne(it).duplicate();
+			}
+			else if (sleep <= 1000*Clock::ClockDiff(milliseconds))
+			{
+				if (!wait(sleep))
+				{
+					return dequeueOne(it).duplicate();
+				}
+				else 
+				{
+					milliseconds -= static_cast<long>((now.elapsed() + 999)/1000);
+					continue;
+				}
+			}
+		}
+		else
+		{
+			_mutex.unlock();
+		}
+		if (milliseconds > 0)
+		{
+			Clock now;
+			_nfAvailable.tryWait(milliseconds);
+			milliseconds -= static_cast<long>((now.elapsed() + 999)/1000);
+		}
+		else return 0;
+	}
+	return 0;
+}
+
+
+bool TimedNotificationQueue::wait(Clock::ClockDiff interval)
+{
+	const Clock::ClockDiff MAX_SLEEP = 8*60*60*Clock::ClockDiff(1000000); // sleep at most 8 hours at a time
+	while (interval > 0)
+	{
+		Clock now;
+		Clock::ClockDiff sleep = interval <= MAX_SLEEP ? interval : MAX_SLEEP;
+		if (_nfAvailable.tryWait(static_cast<long>((sleep + 999)/1000)))
+			return true;
+		interval -= now.elapsed();
+	}
+	return false;
+}
+
+
+bool TimedNotificationQueue::empty() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+	return _nfQueue.empty();
+}
+
+	
+int TimedNotificationQueue::size() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+	return static_cast<int>(_nfQueue.size());
+}
+
+
+void TimedNotificationQueue::clear()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	_nfQueue.clear();	
+}
+
+
+Notification::Ptr TimedNotificationQueue::dequeueOne(NfQueue::iterator& it)
+{
+	FastMutex::ScopedLock lock(_mutex);
+	Notification::Ptr pNf = it->second;
+	_nfQueue.erase(it);
+	return pNf;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Timer.cpp b/base/poco/Foundation/src/Timer.cpp
new file mode 100644
index 00000000000..df16384556d
--- /dev/null
+++ b/base/poco/Foundation/src/Timer.cpp
@@ -0,0 +1,247 @@
+//
+// Timer.cpp
+//
+// Library: Foundation
+// Package: Threading
+// Module:  Timer
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Timer.h"
+#include "Poco/ThreadPool.h"
+#include "Poco/Exception.h"
+#include "Poco/ErrorHandler.h"
+
+
+namespace Poco {
+
+
+Timer::Timer(long startInterval, long periodicInterval): 
+	_startInterval(startInterval), 
+	_periodicInterval(periodicInterval),
+	_skipped(0),
+	_pCallback(0)
+{
+	poco_assert (startInterval >= 0 && periodicInterval >= 0);
+}
+
+
+Timer::~Timer()
+{
+	try
+	{
+		stop();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void Timer::start(const AbstractTimerCallback& method)
+{
+	start(method, Thread::PRIO_NORMAL, ThreadPool::defaultPool());
+}
+
+
+void Timer::start(const AbstractTimerCallback& method, Thread::Priority priority)
+{
+	start(method, priority, ThreadPool::defaultPool());
+}
+
+
+void Timer::start(const AbstractTimerCallback& method, ThreadPool& threadPool)
+{
+	start(method, Thread::PRIO_NORMAL, threadPool);
+}
+
+
+void Timer::start(const AbstractTimerCallback& method, Thread::Priority priority, ThreadPool& threadPool)
+{
+	Clock nextInvocation;
+	nextInvocation += static_cast<Clock::ClockVal>(_startInterval)*1000;
+	
+	FastMutex::ScopedLock lock(_mutex);	
+
+	if (_pCallback)
+	{
+		throw Poco::IllegalStateException("Timer already running");
+	}
+
+	_nextInvocation = nextInvocation;
+	_pCallback = method.clone();
+	_wakeUp.reset();
+	try
+	{
+		threadPool.startWithPriority(priority, *this);
+	}
+	catch (...)
+	{
+		delete _pCallback;
+		_pCallback = 0;
+		throw;
+	}
+}
+
+
+void Timer::stop()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	if (_pCallback)
+	{
+		_periodicInterval = 0;
+		_mutex.unlock();
+		_wakeUp.set();
+		_done.wait(); // warning: deadlock if called from timer callback
+		_mutex.lock();
+		delete _pCallback;
+		_pCallback = 0;
+	}
+}
+
+
+void Timer::restart()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	if (_pCallback)
+	{
+		_wakeUp.set();
+	}
+}
+
+
+void Timer::restart(long milliseconds)
+{
+	poco_assert (milliseconds >= 0);
+	FastMutex::ScopedLock lock(_mutex);
+	if (_pCallback)
+	{
+		_periodicInterval = milliseconds;
+		_wakeUp.set();
+	}
+}
+
+
+long Timer::getStartInterval() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+	return _startInterval;
+}
+
+
+void Timer::setStartInterval(long milliseconds)
+{
+	poco_assert (milliseconds >= 0);
+	FastMutex::ScopedLock lock(_mutex);
+	_startInterval = milliseconds;
+}
+
+
+long Timer::getPeriodicInterval() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+	return _periodicInterval;
+}
+
+
+void Timer::setPeriodicInterval(long milliseconds)
+{
+	poco_assert (milliseconds >= 0);
+	FastMutex::ScopedLock lock(_mutex);
+	_periodicInterval = milliseconds;
+}
+
+
+void Timer::run()
+{
+	Poco::Clock now;
+	long interval(0);
+	do
+	{
+		long sleep(0);
+		do
+		{
+			now.update();
+			sleep = static_cast<long>((_nextInvocation - now)/1000);
+			if (sleep < 0)
+			{
+				if (interval == 0)
+				{
+					sleep = 0;
+					break;
+				}
+				_nextInvocation += static_cast<Clock::ClockVal>(interval)*1000;
+				++_skipped;
+			}
+		}
+		while (sleep < 0);
+
+		if (_wakeUp.tryWait(sleep))
+		{
+			Poco::FastMutex::ScopedLock lock(_mutex);
+			_nextInvocation.update();
+			interval = _periodicInterval;
+		}
+		else
+		{
+			try
+			{
+				_pCallback->invoke(*this);
+			}
+			catch (Poco::Exception& exc)
+			{
+				Poco::ErrorHandler::handle(exc);
+			}
+			catch (std::exception& exc)
+			{
+				Poco::ErrorHandler::handle(exc);
+			}
+			catch (...)
+			{
+				Poco::ErrorHandler::handle();
+			}
+			Poco::FastMutex::ScopedLock lock(_mutex);
+			interval = _periodicInterval;
+		}
+		_nextInvocation += static_cast<Clock::ClockVal>(interval)*1000;
+		_skipped = 0;
+	}
+	while (interval > 0);
+	_done.set();
+}
+
+
+long Timer::skipped() const
+{
+	return _skipped;
+}
+
+
+AbstractTimerCallback::AbstractTimerCallback()
+{
+}
+
+
+AbstractTimerCallback::AbstractTimerCallback(const AbstractTimerCallback& callback)
+{
+}
+
+
+AbstractTimerCallback::~AbstractTimerCallback()
+{
+}
+
+
+AbstractTimerCallback& AbstractTimerCallback::operator = (const AbstractTimerCallback& callback)
+{
+	return *this;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Timespan.cpp b/base/poco/Foundation/src/Timespan.cpp
new file mode 100644
index 00000000000..4397314cd53
--- /dev/null
+++ b/base/poco/Foundation/src/Timespan.cpp
@@ -0,0 +1,145 @@
+//
+// Timespan.cpp
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  Timespan
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Timespan.h"
+#include <algorithm>
+
+
+namespace Poco {
+
+
+const Timespan::TimeDiff Timespan::MILLISECONDS = 1000;
+const Timespan::TimeDiff Timespan::SECONDS      = 1000*Timespan::MILLISECONDS;
+const Timespan::TimeDiff Timespan::MINUTES      =   60*Timespan::SECONDS;
+const Timespan::TimeDiff Timespan::HOURS        =   60*Timespan::MINUTES;
+const Timespan::TimeDiff Timespan::DAYS         =   24*Timespan::HOURS;
+
+
+Timespan::Timespan():
+	_span(0)
+{
+}
+
+	
+Timespan::Timespan(TimeDiff microSeconds):
+	_span(microSeconds)
+{
+}
+
+
+Timespan::Timespan(long seconds, long microSeconds):
+	_span(TimeDiff(seconds)*SECONDS + microSeconds)
+{
+}
+
+	
+Timespan::Timespan(int days, int hours, int minutes, int seconds, int microSeconds):
+	_span(TimeDiff(microSeconds) + TimeDiff(seconds)*SECONDS + TimeDiff(minutes)*MINUTES + TimeDiff(hours)*HOURS + TimeDiff(days)*DAYS)
+{
+}
+
+
+Timespan::Timespan(const Timespan& timespan):
+	_span(timespan._span)
+{
+}
+
+
+Timespan& Timespan::operator = (const Timespan& timespan)
+{
+	_span = timespan._span;
+	return *this;
+}
+
+
+Timespan& Timespan::operator = (TimeDiff microSeconds)
+{
+	_span = microSeconds;
+	return *this;
+}
+
+
+Timespan& Timespan::assign(int days, int hours, int minutes, int seconds, int microSeconds)
+{
+	_span = TimeDiff(microSeconds) + TimeDiff(seconds)*SECONDS + TimeDiff(minutes)*MINUTES + TimeDiff(hours)*HOURS + TimeDiff(days)*DAYS;
+	return *this;
+}
+
+
+Timespan& Timespan::assign(long seconds, long microSeconds)
+{
+	_span = TimeDiff(seconds)*SECONDS + TimeDiff(microSeconds);
+	return *this;
+}
+
+
+void Timespan::swap(Timespan& timespan)
+{
+	std::swap(_span, timespan._span);
+}
+
+
+Timespan Timespan::operator + (const Timespan& d) const
+{
+	return Timespan(_span + d._span);
+}
+
+
+Timespan Timespan::operator - (const Timespan& d) const
+{
+	return Timespan(_span - d._span);
+}
+
+
+Timespan& Timespan::operator += (const Timespan& d)
+{
+	_span += d._span;
+	return *this;
+}
+
+
+Timespan& Timespan::operator -= (const Timespan& d)
+{
+	_span -= d._span;
+	return *this;
+}
+
+
+Timespan Timespan::operator + (TimeDiff microSeconds) const
+{
+	return Timespan(_span + microSeconds);
+}
+
+
+Timespan Timespan::operator - (TimeDiff microSeconds) const
+{
+	return Timespan(_span - microSeconds);
+}
+
+
+Timespan& Timespan::operator += (TimeDiff microSeconds)
+{
+	_span += microSeconds;
+	return *this;
+}
+
+
+Timespan& Timespan::operator -= (TimeDiff microSeconds)
+{
+	_span -= microSeconds;
+	return *this;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Timestamp.cpp b/base/poco/Foundation/src/Timestamp.cpp
new file mode 100644
index 00000000000..aca1e3494a3
--- /dev/null
+++ b/base/poco/Foundation/src/Timestamp.cpp
@@ -0,0 +1,313 @@
+//
+// Timestamp.cpp
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  Timestamp
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Timestamp.h"
+#include "Poco/Timespan.h"
+#include "Poco/Exception.h"
+#include <algorithm>
+#undef min
+#undef max
+#include <limits>
+#if defined(POCO_OS_FAMILY_UNIX)
+#include <time.h>
+#include <unistd.h>
+#if defined(POCO_VXWORKS)
+#include <timers.h>
+#else
+#include <sys/time.h>
+#include <sys/times.h>
+#endif
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#include "Poco/UnWindows.h"
+#if defined(_WIN32_WCE)
+#include <cmath>
+#endif
+#endif
+
+
+#ifndef POCO_HAVE_CLOCK_GETTIME
+	#if (defined(_POSIX_TIMERS) && defined(CLOCK_REALTIME)) || defined(POCO_VXWORKS) || defined(__QNX__)
+		#ifndef __APPLE__ // See GitHub issue #1453 - not available before Mac OS 10.12/iOS 10
+			#define POCO_HAVE_CLOCK_GETTIME
+		#endif
+	#endif
+#endif
+
+
+#if defined(_WIN32_WCE) && defined(POCO_WINCE_TIMESTAMP_HACK)
+
+
+//
+// See <http://community.opennetcf.com/articles/cf/archive/2007/11/20/getting-a-millisecond-resolution-datetime-under-windows-ce.aspx>
+// for an explanation of the following code.
+//
+// In short: Windows CE system time in most cases only has a resolution of one second.
+// But we want millisecond resolution.
+//
+
+
+namespace {
+
+
+class TickOffset
+{
+public:
+	TickOffset()
+	{
+		SYSTEMTIME st1, st2;
+		std::memset(&st1, 0, sizeof(SYSTEMTIME));
+		std::memset(&st2, 0, sizeof(SYSTEMTIME));
+		GetSystemTime(&st1);
+		while (true)
+		{
+			GetSystemTime(&st2);
+
+			// wait for a rollover
+			if (st1.wSecond != st2.wSecond)
+			{
+				_offset = GetTickCount() % 1000;
+				break;
+			}
+		}
+	}
+
+	void calibrate(int seconds)
+	{
+		SYSTEMTIME st1, st2;
+		systemTime(&st1);
+
+		WORD s = st1.wSecond;
+		int sum = 0;
+		int remaining = seconds;
+		while (remaining > 0)
+		{
+			systemTime(&st2);
+			WORD s2 = st2.wSecond;
+
+			if (s != s2)
+			{
+				remaining--;
+				// store the offset from zero
+				sum += (st2.wMilliseconds > 500) ? (st2.wMilliseconds - 1000) : st2.wMilliseconds;
+				s = st2.wSecond;
+			}
+		}
+
+		// adjust the offset by the average deviation from zero (round to the integer farthest from zero)
+		if (sum < 0)
+			_offset += (int) std::floor(sum / (float)seconds);
+		else
+			_offset += (int) std::ceil(sum / (float)seconds);
+	}
+
+	void systemTime(SYSTEMTIME* pST)
+	{
+		std::memset(pST, 0, sizeof(SYSTEMTIME));
+
+		WORD tick = GetTickCount() % 1000;
+		GetSystemTime(pST);
+		WORD ms = (tick >= _offset) ? (tick - _offset) : (1000 - (_offset - tick));
+		pST->wMilliseconds = ms;
+	}
+
+	void systemTimeAsFileTime(FILETIME* pFT)
+	{
+		SYSTEMTIME st;
+		systemTime(&st);
+		SystemTimeToFileTime(&st, pFT);
+	}
+
+private:
+	WORD _offset;
+};
+
+
+static TickOffset offset;
+
+
+void GetSystemTimeAsFileTimeWithMillisecondResolution(FILETIME* pFT)
+{
+	offset.systemTimeAsFileTime(pFT);
+}
+
+
+} // namespace
+
+
+#endif // defined(_WIN32_WCE) && defined(POCO_WINCE_TIMESTAMP_HACK)
+
+
+namespace Poco {
+
+
+const Timestamp::TimeVal Timestamp::TIMEVAL_MIN = std::numeric_limits<Timestamp::TimeVal>::min();
+const Timestamp::TimeVal Timestamp::TIMEVAL_MAX = std::numeric_limits<Timestamp::TimeVal>::max();
+
+
+Timestamp::Timestamp()
+{
+	update();
+}
+
+
+Timestamp::Timestamp(TimeVal tv)
+{
+	_ts = tv;
+}
+
+
+Timestamp::Timestamp(const Timestamp& other)
+{
+	_ts = other._ts;
+}
+
+
+Timestamp::~Timestamp()
+{
+}
+
+
+Timestamp& Timestamp::operator = (const Timestamp& other)
+{
+	_ts = other._ts;
+	return *this;
+}
+
+
+Timestamp& Timestamp::operator = (TimeVal tv)
+{
+	_ts = tv;
+	return *this;
+}
+
+
+void Timestamp::swap(Timestamp& timestamp)
+{
+	std::swap(_ts, timestamp._ts);
+}
+
+
+Timestamp Timestamp::fromEpochTime(std::time_t t)
+{
+	return Timestamp(TimeVal(t)*resolution());
+}
+
+
+Timestamp Timestamp::fromUtcTime(UtcTimeVal val)
+{
+	val -= (TimeDiff(0x01b21dd2) << 32) + 0x13814000;
+	val /= 10;
+	return Timestamp(val);
+}
+
+
+void Timestamp::update()
+{
+#if defined(POCO_OS_FAMILY_WINDOWS)
+
+	FILETIME ft;
+#if defined(_WIN32_WCE) && defined(POCO_WINCE_TIMESTAMP_HACK)
+	GetSystemTimeAsFileTimeWithMillisecondResolution(&ft);
+#else
+	GetSystemTimeAsFileTime(&ft);
+#endif
+
+	ULARGE_INTEGER epoch; // UNIX epoch (1970-01-01 00:00:00) expressed in Windows NT FILETIME
+	epoch.LowPart  = 0xD53E8000;
+	epoch.HighPart = 0x019DB1DE;
+
+	ULARGE_INTEGER ts;
+	ts.LowPart  = ft.dwLowDateTime;
+	ts.HighPart = ft.dwHighDateTime;
+	ts.QuadPart -= epoch.QuadPart;
+	_ts = ts.QuadPart/10;
+
+#elif defined(POCO_HAVE_CLOCK_GETTIME)
+
+	struct timespec ts;
+	if (clock_gettime(CLOCK_REALTIME, &ts))
+		throw SystemException("cannot get time of day");
+	_ts = TimeVal(ts.tv_sec)*resolution() + ts.tv_nsec/1000;
+
+#else
+
+	struct timeval tv;
+	if (gettimeofday(&tv, NULL))
+		throw SystemException("cannot get time of day");
+	_ts = TimeVal(tv.tv_sec)*resolution() + tv.tv_usec;
+
+#endif
+}
+
+
+Timestamp  Timestamp::operator +  (const Timespan& span) const
+{
+	return *this + span.totalMicroseconds();
+}
+
+
+Timestamp  Timestamp::operator -  (const Timespan& span) const
+{
+	return *this - span.totalMicroseconds();
+}
+
+
+Timestamp& Timestamp::operator += (const Timespan& span)
+{
+	return *this += span.totalMicroseconds();
+}
+
+
+Timestamp& Timestamp::operator -= (const Timespan& span)
+{
+	return *this -= span.totalMicroseconds();
+}
+
+
+#if defined(_WIN32)
+
+
+Timestamp Timestamp::fromFileTimeNP(UInt32 fileTimeLow, UInt32 fileTimeHigh)
+{
+	ULARGE_INTEGER epoch; // UNIX epoch (1970-01-01 00:00:00) expressed in Windows NT FILETIME
+	epoch.LowPart  = 0xD53E8000;
+	epoch.HighPart = 0x019DB1DE;
+
+	ULARGE_INTEGER ts;
+	ts.LowPart  = fileTimeLow;
+	ts.HighPart = fileTimeHigh;
+	ts.QuadPart -= epoch.QuadPart;
+
+	return Timestamp(ts.QuadPart/10);
+}
+
+
+void Timestamp::toFileTimeNP(UInt32& fileTimeLow, UInt32& fileTimeHigh) const
+{
+	ULARGE_INTEGER epoch; // UNIX epoch (1970-01-01 00:00:00) expressed in Windows NT FILETIME
+	epoch.LowPart  = 0xD53E8000;
+	epoch.HighPart = 0x019DB1DE;
+
+	ULARGE_INTEGER ts;
+	ts.QuadPart  = _ts*10;
+	ts.QuadPart += epoch.QuadPart;
+	fileTimeLow  = ts.LowPart;
+	fileTimeHigh = ts.HighPart;
+}
+
+
+#endif
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Timezone.cpp b/base/poco/Foundation/src/Timezone.cpp
new file mode 100644
index 00000000000..fa229cbb221
--- /dev/null
+++ b/base/poco/Foundation/src/Timezone.cpp
@@ -0,0 +1,41 @@
+//
+// Timezone.cpp
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  Timezone
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Timezone.h"
+#include <ctime>
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#if defined(_WIN32_WCE)
+#include "Timezone_WINCE.cpp"
+#else
+#include "Timezone_WIN32.cpp"
+#endif
+#elif defined(POCO_VXWORKS)
+#include "Timezone_VX.cpp"
+#else
+#include "Timezone_UNIX.cpp"
+#endif
+
+
+namespace Poco {
+
+
+int Timezone::tzd()
+{
+	return utcOffset() + dst();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Timezone_UNIX.cpp b/base/poco/Foundation/src/Timezone_UNIX.cpp
new file mode 100644
index 00000000000..118b43465ec
--- /dev/null
+++ b/base/poco/Foundation/src/Timezone_UNIX.cpp
@@ -0,0 +1,110 @@
+//
+// Timezone_UNIX.cpp
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  Timezone
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Timezone.h"
+#include "Poco/Exception.h"
+#include "Poco/Mutex.h"
+#include <ctime>
+
+
+namespace Poco {
+
+
+class TZInfo
+{
+public:
+	TZInfo()
+	{
+		tzset();
+	}
+	
+	int timeZone()
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+
+	#if defined(__APPLE__)  || defined(__FreeBSD__) || defined (__OpenBSD__) || POCO_OS == POCO_OS_ANDROID // no timezone global var
+		std::time_t now = std::time(NULL);
+		struct std::tm t;
+		gmtime_r(&now, &t);
+		std::time_t utc = std::mktime(&t);
+		return now - utc;
+	#elif defined(__CYGWIN__)
+		tzset();
+		return -_timezone;
+	#else
+		tzset();
+		return -timezone;
+	#endif
+	}
+	
+	const char* name(bool dst)
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+
+		tzset();		
+		return tzname[dst ? 1 : 0];
+	}
+		
+private:
+	Poco::FastMutex _mutex;
+};
+
+
+static TZInfo tzInfo;
+
+
+int Timezone::utcOffset()
+{
+	return tzInfo.timeZone();
+}
+
+	
+int Timezone::dst()
+{
+	std::time_t now = std::time(NULL);
+	struct std::tm t;
+	if (!localtime_r(&now, &t))
+		throw Poco::SystemException("cannot get local time DST offset");
+	return t.tm_isdst == 1 ? 3600 : 0;
+}
+
+
+bool Timezone::isDst(const Timestamp& timestamp)
+{
+	std::time_t time = timestamp.epochTime();
+	struct std::tm* tms = std::localtime(&time);
+	if (!tms) throw Poco::SystemException("cannot get local time DST flag");
+	return tms->tm_isdst > 0;
+}
+
+	
+std::string Timezone::name()
+{
+	return std::string(tzInfo.name(dst() != 0));
+}
+
+	
+std::string Timezone::standardName()
+{
+	return std::string(tzInfo.name(false));
+}
+
+	
+std::string Timezone::dstName()
+{
+	return std::string(tzInfo.name(true));
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Timezone_VX.cpp b/base/poco/Foundation/src/Timezone_VX.cpp
new file mode 100644
index 00000000000..18339bffab4
--- /dev/null
+++ b/base/poco/Foundation/src/Timezone_VX.cpp
@@ -0,0 +1,78 @@
+//
+// Timezone_VXX.cpp
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  Timezone
+//
+// Copyright (c) 2004-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Timezone.h"
+#include "Poco/Exception.h"
+#include "Poco/Environment.h"
+#include <ctime>
+
+
+namespace Poco {
+
+
+int Timezone::utcOffset()
+{
+	std::time_t now = std::time(NULL);
+	struct std::tm t;
+	gmtime_r(&now, &t);
+	std::time_t utc = std::mktime(&t);
+	return now - utc;
+}
+
+	
+int Timezone::dst()
+{
+	std::time_t now = std::time(NULL);
+	struct std::tm t;
+	if (localtime_r(&now, &t) != OK)
+		throw Poco::SystemException("cannot get local time DST offset");
+	return t.tm_isdst == 1 ? 3600 : 0;
+}
+
+
+bool Timezone::isDst(const Timestamp& timestamp)
+{
+	std::time_t time = timestamp.epochTime();
+	struct std::tm* tms = std::localtime(&time);
+	if (!tms) throw Poco::SystemException("cannot get local time DST flag");
+	return tms->tm_isdst > 0;
+}
+
+	
+std::string Timezone::name()
+{
+	// format of TIMEZONE environment variable:
+	// name_of_zone:<(unused)>:time_in_minutes_from_UTC:daylight_start:daylight_end
+	std::string tz = Environment::get("TIMEZONE", "UTC");
+	std::string::size_type pos = tz.find(':');
+	if (pos != std::string::npos)
+		return tz.substr(0, pos);
+	else
+		return tz;
+}
+
+	
+std::string Timezone::standardName()
+{
+	return name();
+}
+
+	
+std::string Timezone::dstName()
+{
+	return name();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Timezone_WIN32.cpp b/base/poco/Foundation/src/Timezone_WIN32.cpp
new file mode 100644
index 00000000000..45be02e0a0b
--- /dev/null
+++ b/base/poco/Foundation/src/Timezone_WIN32.cpp
@@ -0,0 +1,101 @@
+//
+// Timezone_WIN32.cpp
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  Timezone
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Timezone.h"
+#include "Poco/UnicodeConverter.h"
+#include "Poco/Exception.h"
+#include "Poco/UnWindows.h"
+#include <ctime>
+
+
+namespace Poco {
+
+
+int Timezone::utcOffset()
+{
+	TIME_ZONE_INFORMATION tzInfo;
+	DWORD dstFlag = GetTimeZoneInformation(&tzInfo);
+	return -tzInfo.Bias*60;
+}
+
+	
+int Timezone::dst()
+{
+	TIME_ZONE_INFORMATION tzInfo;
+	DWORD dstFlag = GetTimeZoneInformation(&tzInfo);
+	return dstFlag == TIME_ZONE_ID_DAYLIGHT ? -tzInfo.DaylightBias*60 : 0;
+}
+
+
+bool Timezone::isDst(const Timestamp& timestamp)
+{
+	std::time_t time = timestamp.epochTime();
+	struct std::tm* tms = std::localtime(&time);
+	if (!tms) throw Poco::SystemException("cannot get local time DST flag");
+	return tms->tm_isdst > 0;
+}
+
+	
+std::string Timezone::name()
+{
+	std::string result;
+	TIME_ZONE_INFORMATION tzInfo;
+	DWORD dstFlag = GetTimeZoneInformation(&tzInfo);
+	WCHAR* ptr = dstFlag == TIME_ZONE_ID_DAYLIGHT ? tzInfo.DaylightName : tzInfo.StandardName;
+#if defined(POCO_WIN32_UTF8)
+	UnicodeConverter::toUTF8(ptr, result);
+#else
+	char buffer[256];
+	DWORD rc = WideCharToMultiByte(CP_ACP, 0, ptr, -1, buffer, sizeof(buffer), NULL, NULL);
+	if (rc) result = buffer;
+#endif
+	return result;
+}
+
+	
+std::string Timezone::standardName()
+{
+	std::string result;
+	TIME_ZONE_INFORMATION tzInfo;
+	DWORD dstFlag = GetTimeZoneInformation(&tzInfo);
+	WCHAR* ptr = tzInfo.StandardName;
+#if defined(POCO_WIN32_UTF8)
+	UnicodeConverter::toUTF8(ptr, result);
+#else
+	char buffer[256];
+	DWORD rc = WideCharToMultiByte(CP_ACP, 0, ptr, -1, buffer, sizeof(buffer), NULL, NULL);
+	if (rc) result = buffer;
+#endif
+	return result;
+}
+
+	
+std::string Timezone::dstName()
+{
+	std::string result;
+	TIME_ZONE_INFORMATION tzInfo;
+	DWORD dstFlag = GetTimeZoneInformation(&tzInfo);
+	WCHAR* ptr = tzInfo.DaylightName;
+#if defined(POCO_WIN32_UTF8)
+	UnicodeConverter::toUTF8(ptr, result);
+#else
+	char buffer[256];
+	DWORD rc = WideCharToMultiByte(CP_ACP, 0, ptr, -1, buffer, sizeof(buffer), NULL, NULL);
+	if (rc) result = buffer;
+#endif
+	return result;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Timezone_WINCE.cpp b/base/poco/Foundation/src/Timezone_WINCE.cpp
new file mode 100644
index 00000000000..fb794f58b4e
--- /dev/null
+++ b/base/poco/Foundation/src/Timezone_WINCE.cpp
@@ -0,0 +1,92 @@
+//
+// Timezone_WINCE.cpp
+//
+// Library: Foundation
+// Package: DateTime
+// Module:  Timezone
+//
+// Copyright (c) 2004-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Timezone.h"
+#include "Poco/UnicodeConverter.h"
+#include "Poco/Exception.h"
+#include "Poco/UnWindows.h"
+#include <ctime>
+#if _WIN32_WCE >= 0x800
+#include "time.h"
+#else
+#include "wce_time.h"
+#endif
+
+
+namespace Poco {
+
+
+int Timezone::utcOffset()
+{
+	TIME_ZONE_INFORMATION tzInfo;
+	DWORD dstFlag = GetTimeZoneInformation(&tzInfo);
+	return -tzInfo.Bias*60;
+}
+
+	
+int Timezone::dst()
+{
+	TIME_ZONE_INFORMATION tzInfo;
+	DWORD dstFlag = GetTimeZoneInformation(&tzInfo);
+	return dstFlag == TIME_ZONE_ID_DAYLIGHT ? -tzInfo.DaylightBias*60 : 0;
+}
+
+
+bool Timezone::isDst(const Timestamp& timestamp)
+{
+	std::time_t time = timestamp.epochTime();
+#if _WIN32_WCE >= 0x800
+	struct std::tm* tms = localtime(&time);
+#else
+	struct std::tm* tms = wceex_localtime(&time);
+#endif
+	if (!tms) throw SystemException("cannot get local time DST flag");
+	return tms->tm_isdst > 0;
+}
+
+	
+std::string Timezone::name()
+{
+	std::string result;
+	TIME_ZONE_INFORMATION tzInfo;
+	DWORD dstFlag = GetTimeZoneInformation(&tzInfo);
+	WCHAR* ptr = dstFlag == TIME_ZONE_ID_DAYLIGHT ? tzInfo.DaylightName : tzInfo.StandardName;
+	UnicodeConverter::toUTF8(ptr, result);
+	return result;
+}
+
+	
+std::string Timezone::standardName()
+{
+	std::string result;
+	TIME_ZONE_INFORMATION tzInfo;
+	DWORD dstFlag = GetTimeZoneInformation(&tzInfo);
+	WCHAR* ptr = tzInfo.StandardName;
+	UnicodeConverter::toUTF8(ptr, result);
+	return result;
+}
+
+	
+std::string Timezone::dstName()
+{
+	std::string result;
+	TIME_ZONE_INFORMATION tzInfo;
+	DWORD dstFlag = GetTimeZoneInformation(&tzInfo);
+	WCHAR* ptr = tzInfo.DaylightName;
+	UnicodeConverter::toUTF8(ptr, result);
+	return result;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Token.cpp b/base/poco/Foundation/src/Token.cpp
new file mode 100644
index 00000000000..98e8bb25e93
--- /dev/null
+++ b/base/poco/Foundation/src/Token.cpp
@@ -0,0 +1,166 @@
+//
+// Token.cpp
+//
+// Library: Foundation
+// Package: Streams
+// Module:  StringTokenizer
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Token.h"
+#include "Poco/NumberParser.h"
+#include "Poco/Ascii.h"
+
+
+namespace Poco {
+
+
+Token::Token()
+{
+}
+
+
+Token::~Token()
+{
+}
+
+
+bool Token::start(char c, std::istream& istr)
+{
+	_value = c;
+	return false;
+}
+
+
+void Token::finish(std::istream& istr)
+{
+}
+
+
+Token::Class Token::tokenClass() const
+{
+	return INVALID_TOKEN;
+}
+
+		
+std::string Token::asString() const
+{
+	return _value;
+}
+
+
+#if defined(POCO_HAVE_INT64)
+Int64 Token::asInteger64() const
+{
+	return NumberParser::parse64(_value);
+}
+
+
+UInt64 Token::asUnsignedInteger64() const
+{
+	return NumberParser::parseUnsigned64(_value);
+}
+#endif
+
+
+int Token::asInteger() const
+{
+	return NumberParser::parse(_value);
+}
+
+
+unsigned Token::asUnsignedInteger() const
+{
+	return NumberParser::parseUnsigned(_value);
+}
+
+
+double Token::asFloat() const
+{
+	return NumberParser::parseFloat(_value);
+}
+
+
+char Token::asChar() const
+{
+	return _value.empty() ? 0 : _value[0];
+}
+
+
+InvalidToken::InvalidToken()
+{
+}
+
+
+InvalidToken::~InvalidToken()
+{
+}
+
+
+Token::Class InvalidToken::tokenClass() const
+{
+	return INVALID_TOKEN;
+}
+
+
+EOFToken::EOFToken()
+{
+}
+
+
+EOFToken::~EOFToken()
+{
+}
+
+
+Token::Class EOFToken::tokenClass() const
+{
+	return EOF_TOKEN;
+}
+
+
+WhitespaceToken::WhitespaceToken()
+{
+}
+
+
+WhitespaceToken::~WhitespaceToken()
+{
+}
+
+
+Token::Class WhitespaceToken::tokenClass() const
+{
+	return WHITESPACE_TOKEN;
+}
+
+
+bool WhitespaceToken::start(char c, std::istream& istr)
+{
+	if (Ascii::isSpace(c))
+	{
+		_value = c;
+		return true;
+	}
+	return false;
+}
+
+
+void WhitespaceToken::finish(std::istream& istr)
+{
+	int c = istr.peek();
+	while (Ascii::isSpace(c))
+	{
+		istr.get();
+		_value += (char) c;
+		c = istr.peek();
+	}
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/URI.cpp b/base/poco/Foundation/src/URI.cpp
new file mode 100644
index 00000000000..5543e02b279
--- /dev/null
+++ b/base/poco/Foundation/src/URI.cpp
@@ -0,0 +1,918 @@
+//
+// URI.cpp
+//
+// Library: Foundation
+// Package: URI
+// Module:  URI
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/URI.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/Exception.h"
+#include "Poco/String.h"
+#include "Poco/NumberParser.h"
+#include "Poco/Path.h"
+
+
+namespace Poco {
+
+
+const std::string URI::RESERVED_PATH        = "?#";
+const std::string URI::RESERVED_QUERY       = "?#/:;+@";
+const std::string URI::RESERVED_QUERY_PARAM = "?#/:;+@&=";
+const std::string URI::RESERVED_FRAGMENT    = "";
+const std::string URI::ILLEGAL              = "%<>{}|\\\"^`!*'()$,[]";
+
+
+URI::URI():
+	_port(0)
+{
+}
+
+
+URI::URI(const std::string& uri):
+	_port(0)
+{
+	parse(uri);
+}
+
+
+URI::URI(const char* uri):
+	_port(0)
+{
+	parse(std::string(uri));
+}
+
+	
+URI::URI(const std::string& scheme, const std::string& pathEtc):
+	_scheme(scheme),
+	_port(0)
+{
+	toLowerInPlace(_scheme);
+	_port = getWellKnownPort();
+	std::string::const_iterator beg = pathEtc.begin();
+	std::string::const_iterator end = pathEtc.end();
+	parsePathEtc(beg, end);
+}
+
+	
+URI::URI(const std::string& scheme, const std::string& authority, const std::string& pathEtc):
+	_scheme(scheme)
+{
+	toLowerInPlace(_scheme);
+	std::string::const_iterator beg = authority.begin();
+	std::string::const_iterator end = authority.end();
+	parseAuthority(beg, end);
+	beg = pathEtc.begin();
+	end = pathEtc.end();
+	parsePathEtc(beg, end);
+}
+
+
+URI::URI(const std::string& scheme, const std::string& authority, const std::string& path, const std::string& query):
+	_scheme(scheme),
+	_path(path),
+	_query(query)
+{
+	toLowerInPlace(_scheme);
+	std::string::const_iterator beg = authority.begin();
+	std::string::const_iterator end = authority.end();
+	parseAuthority(beg, end);
+}
+
+
+URI::URI(const std::string& scheme, const std::string& authority, const std::string& path, const std::string& query, const std::string& fragment):
+	_scheme(scheme),
+	_path(path),
+	_query(query),
+	_fragment(fragment)
+{
+	toLowerInPlace(_scheme);
+	std::string::const_iterator beg = authority.begin();
+	std::string::const_iterator end = authority.end();
+	parseAuthority(beg, end);
+}
+
+
+URI::URI(const URI& uri):
+	_scheme(uri._scheme),
+	_userInfo(uri._userInfo),
+	_host(uri._host),
+	_port(uri._port),
+	_path(uri._path),
+	_query(uri._query),
+	_fragment(uri._fragment)
+{
+}
+
+	
+URI::URI(const URI& baseURI, const std::string& relativeURI):
+	_scheme(baseURI._scheme),
+	_userInfo(baseURI._userInfo),
+	_host(baseURI._host),
+	_port(baseURI._port),
+	_path(baseURI._path),
+	_query(baseURI._query),
+	_fragment(baseURI._fragment)
+{
+	resolve(relativeURI);
+}
+
+
+URI::URI(const Path& path):
+	_scheme("file"),
+	_port(0)
+{
+	Path absolutePath(path);
+	absolutePath.makeAbsolute();
+	_path = absolutePath.toString(Path::PATH_UNIX);
+}
+
+
+URI::~URI()
+{
+}
+
+
+URI& URI::operator = (const URI& uri)
+{
+	if (&uri != this)
+	{
+		_scheme   = uri._scheme;
+		_userInfo = uri._userInfo;
+		_host     = uri._host;
+		_port     = uri._port;
+		_path     = uri._path;
+		_query    = uri._query;
+		_fragment = uri._fragment;
+	}
+	return *this;
+}
+
+	
+URI& URI::operator = (const std::string& uri)
+{
+	clear();
+	parse(uri);
+	return *this;
+}
+
+
+URI& URI::operator = (const char* uri)
+{
+	clear();
+	parse(std::string(uri));
+	return *this;
+}
+
+
+void URI::swap(URI& uri)
+{
+	std::swap(_scheme, uri._scheme);
+	std::swap(_userInfo, uri._userInfo);
+	std::swap(_host, uri._host);
+	std::swap(_port, uri._port);
+	std::swap(_path, uri._path);
+	std::swap(_query, uri._query);
+	std::swap(_fragment, uri._fragment);
+}
+
+
+void URI::clear()
+{
+	_scheme.clear();
+	_userInfo.clear();
+	_host.clear();
+	_port = 0;
+	_path.clear();
+	_query.clear();
+	_fragment.clear();
+}
+
+
+std::string URI::toString() const
+{
+	std::string uri;
+	if (isRelative())
+	{
+		encode(_path, RESERVED_PATH, uri);
+	}
+	else
+	{
+		uri = _scheme;
+		uri += ':';
+		std::string auth = getAuthority();
+		if (!auth.empty() || _scheme == "file")
+		{
+			uri.append("//");
+			uri.append(auth);
+		}
+		if (!_path.empty())
+		{
+			if (!auth.empty() && _path[0] != '/')
+				uri += '/';
+			encode(_path, RESERVED_PATH, uri);
+		}
+		else if (!_query.empty() || !_fragment.empty())
+		{
+			uri += '/';
+		}
+	}
+	if (!_query.empty())
+	{
+		uri += '?';
+		uri.append(_query);
+	}
+	if (!_fragment.empty())
+	{
+		uri += '#';
+		encode(_fragment, RESERVED_FRAGMENT, uri);
+	}
+	return uri;
+}
+
+
+void URI::setScheme(const std::string& scheme)
+{
+	_scheme = scheme;
+	toLowerInPlace(_scheme);
+	if (_port == 0)
+		_port = getWellKnownPort();
+}
+
+	
+void URI::setUserInfo(const std::string& userInfo)
+{
+	_userInfo.clear();
+	decode(userInfo, _userInfo);
+}
+
+	
+void URI::setHost(const std::string& host)
+{
+	_host = host;
+}
+
+
+unsigned short URI::getPort() const
+{
+	if (_port == 0)
+		return getWellKnownPort();
+	else
+		return _port;
+}
+
+
+void URI::setPort(unsigned short port)
+{
+	_port = port;
+}
+
+	
+std::string URI::getAuthority() const
+{
+	std::string auth;
+	if (!_userInfo.empty())
+	{
+		auth.append(_userInfo);
+		auth += '@';
+	}
+	if (_host.find(':') != std::string::npos)
+	{
+		auth += '[';
+		auth += _host;
+		auth += ']';
+	}
+	else auth.append(_host);
+	if (_port && !isWellKnownPort())
+	{
+		auth += ':';
+		NumberFormatter::append(auth, _port);
+	}
+	return auth;
+}
+
+	
+void URI::setAuthority(const std::string& authority)
+{
+	_userInfo.clear();
+	_host.clear();
+	_port = 0;
+	std::string::const_iterator beg = authority.begin();
+	std::string::const_iterator end = authority.end();
+	parseAuthority(beg, end);
+}
+
+	
+void URI::setPath(const std::string& path)
+{
+	_path.clear();
+	decode(path, _path);
+}
+
+	
+void URI::setRawQuery(const std::string& query)
+{
+	_query = query;
+}
+
+
+void URI::setQuery(const std::string& query)
+{
+	_query.clear();
+	encode(query, RESERVED_QUERY, _query);
+}
+
+
+void URI::addQueryParameter(const std::string& param, const std::string& val)
+{
+	if (!_query.empty()) _query += '&';
+	encode(param, RESERVED_QUERY_PARAM, _query);
+	_query += '=';
+	encode(val, RESERVED_QUERY_PARAM, _query);
+}
+
+
+std::string URI::getQuery() const
+{
+	std::string query;
+	decode(_query, query);
+	return query;
+}
+
+
+URI::QueryParameters URI::getQueryParameters() const
+{
+	QueryParameters result;
+	std::string::const_iterator it(_query.begin());
+	std::string::const_iterator end(_query.end());
+	while (it != end)
+	{
+		std::string name;
+		std::string value;
+		while (it != end && *it != '=' && *it != '&')
+		{
+			if (*it == '+')
+				name += ' ';
+			else
+				name += *it;
+			++it;
+		}
+		if (it != end && *it == '=')
+		{
+			++it;
+			while (it != end && *it != '&')
+			{
+				if (*it == '+')
+					value += ' ';
+				else
+					value += *it;
+				++it;
+			}
+		}
+		std::string decodedName;
+		std::string decodedValue;
+		URI::decode(name, decodedName);
+		URI::decode(value, decodedValue);
+		result.push_back(std::make_pair(decodedName, decodedValue));
+		if (it != end && *it == '&') ++it;	
+	}
+	return result;
+}
+
+
+void URI::setQueryParameters(const QueryParameters& params)
+{
+	_query.clear();
+	for (QueryParameters::const_iterator it = params.begin(); it != params.end(); ++it)
+	{
+		addQueryParameter(it->first, it->second);
+	}
+}
+
+
+void URI::setFragment(const std::string& fragment)
+{
+	_fragment.clear();
+	decode(fragment, _fragment);
+}
+
+
+void URI::setPathEtc(const std::string& pathEtc)
+{
+	_path.clear();
+	_query.clear();
+	_fragment.clear();
+	std::string::const_iterator beg = pathEtc.begin();
+	std::string::const_iterator end = pathEtc.end();
+	parsePathEtc(beg, end);
+}
+
+	
+std::string URI::getPathEtc() const
+{
+	std::string pathEtc;
+	encode(_path, RESERVED_PATH, pathEtc);
+	if (!_query.empty())
+	{
+		pathEtc += '?';
+		pathEtc += _query;
+	}
+	if (!_fragment.empty())
+	{
+		pathEtc += '#';
+		encode(_fragment, RESERVED_FRAGMENT, pathEtc);
+	}
+	return pathEtc;
+}
+
+
+std::string URI::getPathAndQuery() const
+{
+	std::string pathAndQuery;
+	encode(_path, RESERVED_PATH, pathAndQuery);
+	if (!_query.empty())
+	{
+		pathAndQuery += '?';
+		pathAndQuery += _query;
+	}
+	return pathAndQuery;
+}
+
+	
+void URI::resolve(const std::string& relativeURI)
+{
+	URI parsedURI(relativeURI);
+	resolve(parsedURI);
+}
+
+
+void URI::resolve(const URI& relativeURI)
+{
+	if (!relativeURI._scheme.empty())
+	{
+		_scheme   = relativeURI._scheme;
+		_userInfo = relativeURI._userInfo;
+		_host     = relativeURI._host;
+		_port     = relativeURI._port;
+		_path     = relativeURI._path;
+		_query    = relativeURI._query;
+		removeDotSegments();
+	}
+	else
+	{
+		if (!relativeURI._host.empty())
+		{
+			_userInfo = relativeURI._userInfo;
+			_host     = relativeURI._host;
+			_port     = relativeURI._port;
+			_path     = relativeURI._path;
+			_query    = relativeURI._query;
+			removeDotSegments();
+		}
+		else
+		{
+			if (relativeURI._path.empty())
+			{
+				if (!relativeURI._query.empty())
+					_query = relativeURI._query;
+			}
+			else
+			{
+				if (relativeURI._path[0] == '/')
+				{
+					_path = relativeURI._path;
+					removeDotSegments();
+				}
+				else
+				{
+					mergePath(relativeURI._path);
+				}
+				_query = relativeURI._query;
+			}
+		}
+	}
+	_fragment = relativeURI._fragment;
+}
+
+
+bool URI::isRelative() const
+{
+	return _scheme.empty();
+}
+
+
+bool URI::empty() const
+{
+	return _scheme.empty() && _host.empty() && _path.empty() && _query.empty() && _fragment.empty();
+}
+
+	
+bool URI::operator == (const URI& uri) const
+{
+	return equals(uri);
+}
+
+
+bool URI::operator == (const std::string& uri) const
+{
+	URI parsedURI(uri);
+	return equals(parsedURI);
+}
+
+
+bool URI::operator != (const URI& uri) const
+{
+	return !equals(uri);
+}
+
+
+bool URI::operator != (const std::string& uri) const
+{
+	URI parsedURI(uri);
+	return !equals(parsedURI);
+}
+
+
+bool URI::equals(const URI& uri) const
+{
+	return _scheme   == uri._scheme
+	    && _userInfo == uri._userInfo
+	    && _host     == uri._host
+	    && getPort() == uri.getPort()
+	    && _path     == uri._path
+	    && _query    == uri._query
+	    && _fragment == uri._fragment;
+}
+
+	
+void URI::normalize()
+{
+	removeDotSegments(!isRelative());
+}
+
+
+void URI::removeDotSegments(bool removeLeading)
+{
+	if (_path.empty()) return;
+	
+	bool leadingSlash  = *(_path.begin()) == '/';
+	bool trailingSlash = *(_path.rbegin()) == '/';
+	std::vector<std::string> segments;
+	std::vector<std::string> normalizedSegments;
+	getPathSegments(segments);
+	for (std::vector<std::string>::const_iterator it = segments.begin(); it != segments.end(); ++it)
+	{
+		if (*it == "..")
+		{
+			if (!normalizedSegments.empty())
+			{
+				if (normalizedSegments.back() == "..")
+					normalizedSegments.push_back(*it);
+				else
+					normalizedSegments.pop_back();
+			}
+			else if (!removeLeading)
+			{
+				normalizedSegments.push_back(*it);
+			}
+		}
+		else if (*it != ".")
+		{
+			normalizedSegments.push_back(*it);
+		}
+	}
+	buildPath(normalizedSegments, leadingSlash, trailingSlash);
+}
+
+
+void URI::getPathSegments(std::vector<std::string>& segments)
+{
+	getPathSegments(_path, segments);
+}
+
+
+void URI::getPathSegments(const std::string& path, std::vector<std::string>& segments)
+{
+	std::string::const_iterator it  = path.begin();
+	std::string::const_iterator end = path.end();
+	std::string seg;
+	while (it != end)
+	{
+		if (*it == '/')
+		{
+			if (!seg.empty())
+			{
+				segments.push_back(seg);
+				seg.clear();
+			}
+		}
+		else seg += *it;
+		++it;
+	}
+	if (!seg.empty())
+		segments.push_back(seg);
+}
+
+
+void URI::encode(const std::string& str, const std::string& reserved, std::string& encodedStr)
+{
+	for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
+	{
+		char c = *it;
+		if ((c >= 'a' && c <= 'z') ||
+		    (c >= 'A' && c <= 'Z') ||
+		    (c >= '0' && c <= '9') ||
+		    c == '-' || c == '_' ||
+		    c == '.' || c == '~')
+		{
+			encodedStr += c;
+		}
+		else if (c <= 0x20 || c >= 0x7F || ILLEGAL.find(c) != std::string::npos || reserved.find(c) != std::string::npos)
+		{
+			encodedStr += '%';
+			encodedStr += NumberFormatter::formatHex((unsigned) (unsigned char) c, 2);
+		}
+		else encodedStr += c;
+	}
+}
+
+	
+void URI::decode(const std::string& str, std::string& decodedStr, bool plusAsSpace)
+{
+	bool inQuery = false;
+	std::string::const_iterator it  = str.begin();
+	std::string::const_iterator end = str.end();
+	while (it != end)
+	{
+		char c = *it++;
+		if (c == '?') inQuery = true;
+		// spaces may be encoded as plus signs in the query
+		if (inQuery && plusAsSpace && c == '+') c = ' ';
+		else if (c == '%')
+		{
+			if (it == end) throw URISyntaxException("URI encoding: no hex digit following percent sign", str);
+			char hi = *it++;
+			if (it == end) throw URISyntaxException("URI encoding: two hex digits must follow percent sign", str);
+			char lo = *it++;
+			if (hi >= '0' && hi <= '9')
+				c = hi - '0';
+			else if (hi >= 'A' && hi <= 'F')
+				c = hi - 'A' + 10;
+			else if (hi >= 'a' && hi <= 'f')
+				c = hi - 'a' + 10;
+			else throw URISyntaxException("URI encoding: not a hex digit");
+			c *= 16;
+			if (lo >= '0' && lo <= '9')
+				c += lo - '0';
+			else if (lo >= 'A' && lo <= 'F')
+				c += lo - 'A' + 10;
+			else if (lo >= 'a' && lo <= 'f')
+				c += lo - 'a' + 10;
+			else throw URISyntaxException("URI encoding: not a hex digit");
+		}
+		decodedStr += c;
+	}
+}
+
+
+bool URI::isWellKnownPort() const
+{
+	return _port == getWellKnownPort();
+}
+
+
+unsigned short URI::getWellKnownPort() const
+{
+	if (_scheme == "ftp")
+		return 21;
+	else if (_scheme == "ssh")
+		return 22;
+	else if (_scheme == "telnet")
+		return 23;
+	else if (_scheme == "http" || _scheme == "ws")
+		return 80;
+	else if (_scheme == "nntp")
+		return 119;
+	else if (_scheme == "ldap")
+		return 389;
+	else if (_scheme == "https" || _scheme == "wss")
+		return 443;
+	else if (_scheme == "rtsp")
+		return 554;
+	else if (_scheme == "sip")
+		return 5060;
+	else if (_scheme == "sips")
+		return 5061;
+	else if (_scheme == "xmpp")
+		return 5222;
+	else
+		return 0;
+}
+
+
+void URI::parse(const std::string& uri)
+{
+	std::for_each(uri.begin(), uri.end(), [] (char ch) {
+		if (static_cast<signed char>(ch) <= 32 || ch == '\x7F')
+			throw URISyntaxException("URI contains invalid characters");
+	});
+
+	std::string::const_iterator it  = uri.begin();
+	std::string::const_iterator end = uri.end();
+	if (it == end) return;
+	if (*it != '/' && *it != '.' && *it != '?' && *it != '#')
+	{
+		std::string scheme;
+		while (it != end && *it != ':' && *it != '?' && *it != '#' && *it != '/') scheme += *it++;
+		if (it != end && *it == ':')
+		{
+			++it;
+			if (it == end) throw URISyntaxException("URI scheme must be followed by authority or path", uri);
+			setScheme(scheme);
+			if (*it == '/')
+			{
+				++it;
+				if (it != end && *it == '/')
+				{
+					++it;
+					parseAuthority(it, end);
+				}
+				else --it;
+			}
+			parsePathEtc(it, end);
+		}
+		else
+		{
+			it = uri.begin();
+			parsePathEtc(it, end);
+		}
+	}
+	else parsePathEtc(it, end);
+}
+
+
+void URI::parseAuthority(std::string::const_iterator& it, const std::string::const_iterator& end)
+{
+	std::string userInfo;
+	std::string part;
+	while (it != end && *it != '/' && *it != '?' && *it != '#')
+	{
+		if (*it == '@')
+		{
+			userInfo = part;
+			part.clear();
+		}
+		else part += *it;
+		++it;
+	}
+	std::string::const_iterator pbeg = part.begin();
+	std::string::const_iterator pend = part.end();
+	parseHostAndPort(pbeg, pend);
+	_userInfo = userInfo;
+}
+
+
+void URI::parseHostAndPort(std::string::const_iterator& it, const std::string::const_iterator& end)
+{
+	if (it == end) return;
+	std::string host;
+	if (*it == '[')
+	{
+		// IPv6 address
+		++it;
+		while (it != end && *it != ']') host += *it++;
+		if (it == end) throw URISyntaxException("unterminated IPv6 address");
+		++it;
+	}
+	else
+	{
+		while (it != end && *it != ':') host += *it++;
+	}
+	if (it != end && *it == ':')
+	{
+		++it;
+		std::string port;
+		while (it != end) port += *it++;
+		if (!port.empty())
+		{
+			int nport = 0;
+			if (NumberParser::tryParse(port, nport) && nport > 0 && nport < 65536)
+				_port = (unsigned short) nport;
+			else
+				throw URISyntaxException("bad or invalid port number", port);
+		}
+		else _port = getWellKnownPort();
+	}
+	else _port = getWellKnownPort();
+	_host = host;
+	toLowerInPlace(_host);
+}
+
+
+void URI::parsePath(std::string::const_iterator& it, const std::string::const_iterator& end)
+{
+	std::string path;
+	while (it != end && *it != '?' && *it != '#') path += *it++;
+	decode(path, _path);
+}
+
+
+void URI::parsePathEtc(std::string::const_iterator& it, const std::string::const_iterator& end)
+{
+	if (it == end) return;
+	if (*it != '?' && *it != '#')
+		parsePath(it, end);
+	if (it != end && *it == '?')
+	{
+		++it;
+		parseQuery(it, end);
+	}
+	if (it != end && *it == '#')
+	{
+		++it;
+		parseFragment(it, end);
+	}	
+}
+
+
+void URI::parseQuery(std::string::const_iterator& it, const std::string::const_iterator& end)
+{
+	_query.clear();
+	while (it != end && *it != '#') _query += *it++;
+}
+
+
+void URI::parseFragment(std::string::const_iterator& it, const std::string::const_iterator& end)
+{
+	std::string fragment;
+	while (it != end) fragment += *it++;
+	decode(fragment, _fragment);
+}
+
+
+void URI::mergePath(const std::string& path)
+{
+	std::vector<std::string> segments;
+	std::vector<std::string> normalizedSegments;
+	bool addLeadingSlash = false;
+	if (!_path.empty())
+	{
+		getPathSegments(segments);
+		bool endsWithSlash = *(_path.rbegin()) == '/';
+		if (!endsWithSlash && !segments.empty())
+			segments.pop_back();
+		addLeadingSlash = _path[0] == '/';
+	}
+	getPathSegments(path, segments);
+	addLeadingSlash = addLeadingSlash || (!path.empty() && path[0] == '/');
+	bool hasTrailingSlash = (!path.empty() && *(path.rbegin()) == '/');
+	bool addTrailingSlash = false;
+	for (std::vector<std::string>::const_iterator it = segments.begin(); it != segments.end(); ++it)
+	{
+		if (*it == "..")
+		{
+			addTrailingSlash = true;
+			if (!normalizedSegments.empty())
+				normalizedSegments.pop_back();
+		}
+		else if (*it != ".")
+		{
+			addTrailingSlash = false;
+			normalizedSegments.push_back(*it);
+		}
+		else addTrailingSlash = true;
+	}
+	buildPath(normalizedSegments, addLeadingSlash, hasTrailingSlash || addTrailingSlash);
+}
+
+
+void URI::buildPath(const std::vector<std::string>& segments, bool leadingSlash, bool trailingSlash)
+{
+	_path.clear();
+	bool first = true;
+	for (std::vector<std::string>::const_iterator it = segments.begin(); it != segments.end(); ++it)
+	{
+		if (first)
+		{
+			first = false;
+			if (leadingSlash)
+				_path += '/';
+			else if (_scheme.empty() && (*it).find(':') != std::string::npos)
+				_path.append("./");
+		}
+		else _path += '/';
+		_path.append(*it);
+	}
+	if (trailingSlash)
+		_path += '/';
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/URIStreamFactory.cpp b/base/poco/Foundation/src/URIStreamFactory.cpp
new file mode 100644
index 00000000000..7d67514db64
--- /dev/null
+++ b/base/poco/Foundation/src/URIStreamFactory.cpp
@@ -0,0 +1,58 @@
+//
+// URIStreamFactory.cpp
+//
+// Library: Foundation
+// Package: URI
+// Module:  URIStreamFactory
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/URIStreamFactory.h"
+#include <algorithm>
+
+
+namespace Poco {
+
+
+URIStreamFactory::URIStreamFactory()
+{
+}
+
+
+URIStreamFactory::~URIStreamFactory()
+{
+}
+
+
+URIRedirection::URIRedirection(const std::string& uri):
+	_uri(uri)
+{
+}
+
+
+URIRedirection::URIRedirection(const URIRedirection& redir):
+	_uri(redir._uri)
+{
+}
+
+
+URIRedirection& URIRedirection::operator = (const URIRedirection& redir)
+{
+	URIRedirection tmp(redir);
+	swap(tmp);
+	return *this;
+}
+
+
+void URIRedirection::swap(URIRedirection& redir)
+{
+	std::swap(_uri, redir._uri);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/URIStreamOpener.cpp b/base/poco/Foundation/src/URIStreamOpener.cpp
new file mode 100644
index 00000000000..1f9631853b1
--- /dev/null
+++ b/base/poco/Foundation/src/URIStreamOpener.cpp
@@ -0,0 +1,211 @@
+//
+// URIStreamOpener.cpp
+//
+// Library: Foundation
+// Package: URI
+// Module:  URIStreamOpener
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/URIStreamOpener.h"
+#include "Poco/URIStreamFactory.h"
+#include "Poco/FileStreamFactory.h"
+#include "Poco/URI.h"
+#include "Poco/Path.h"
+#include "Poco/SingletonHolder.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+
+URIStreamOpener::URIStreamOpener()
+{
+	registerStreamFactory("file", new FileStreamFactory);
+}
+
+
+URIStreamOpener::~URIStreamOpener()
+{
+	for (FactoryMap::iterator it = _map.begin(); it != _map.end(); ++it)
+		delete it->second;
+}
+
+
+std::istream* URIStreamOpener::open(const URI& uri) const
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	std::string scheme;
+	if (uri.isRelative())
+		scheme = "file";
+	else
+		scheme = uri.getScheme();
+	return openURI(scheme, uri);
+}
+
+
+std::istream* URIStreamOpener::open(const std::string& pathOrURI) const
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	try
+	{
+		URI uri(pathOrURI);
+		std::string scheme(uri.getScheme());
+		FactoryMap::const_iterator it = _map.find(scheme);
+		if (it != _map.end())
+		{
+			return openURI(scheme, uri);
+		}
+		else if (scheme.length() <= 1) // could be Windows path
+		{
+			Path path;
+			if (path.tryParse(pathOrURI, Path::PATH_GUESS))
+			{
+				return openFile(path);
+			}
+		}
+		throw UnknownURISchemeException(pathOrURI);
+	}
+	catch (URISyntaxException&)
+	{
+		Path path;
+		if (path.tryParse(pathOrURI, Path::PATH_GUESS))
+			return openFile(path);
+		else 
+			throw;
+	}
+}
+
+
+std::istream* URIStreamOpener::open(const std::string& basePathOrURI, const std::string& pathOrURI) const
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	try
+	{
+		URI uri(basePathOrURI);
+		std::string scheme(uri.getScheme());
+		FactoryMap::const_iterator it = _map.find(scheme);
+		if (it != _map.end())
+		{
+			uri.resolve(pathOrURI);
+			scheme = uri.getScheme();
+			return openURI(scheme, uri);
+		}
+		else if (scheme.length() <= 1) // could be Windows path
+		{
+			Path base;
+			Path path;
+			if (base.tryParse(basePathOrURI, Path::PATH_GUESS) && path.tryParse(pathOrURI, Path::PATH_GUESS))
+			{
+				base.resolve(path);
+				return openFile(base);
+			}
+		}
+		throw UnknownURISchemeException(basePathOrURI);
+	}
+	catch (URISyntaxException&)
+	{
+		Path base;
+		Path path;
+		if (base.tryParse(basePathOrURI, Path::PATH_GUESS) && path.tryParse(pathOrURI, Path::PATH_GUESS))
+		{
+			base.resolve(path);
+			return openFile(base);
+		}
+		else throw;
+	}
+}
+
+	
+void URIStreamOpener::registerStreamFactory(const std::string& scheme, URIStreamFactory* pFactory)
+{
+	poco_check_ptr (pFactory);
+
+	FastMutex::ScopedLock lock(_mutex);
+	if (_map.find(scheme) == _map.end())
+	{
+		_map[scheme] = pFactory;
+	}
+	else throw ExistsException("An URIStreamFactory for the given scheme has already been registered", scheme);
+}
+
+
+void URIStreamOpener::unregisterStreamFactory(const std::string& scheme)
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	FactoryMap::iterator it = _map.find(scheme);
+	if (it != _map.end())
+	{
+		URIStreamFactory* pFactory = it->second;
+		_map.erase(it);
+		delete pFactory;
+	}
+	else throw NotFoundException("No URIStreamFactory has been registered for the given scheme", scheme);
+}
+
+
+bool URIStreamOpener::supportsScheme(const std::string& scheme)
+{
+	FastMutex::ScopedLock lock(_mutex);
+	return _map.find(scheme) != _map.end();
+}
+
+
+namespace
+{
+	static SingletonHolder<URIStreamOpener> sh;
+}
+
+
+URIStreamOpener& URIStreamOpener::defaultOpener()
+{
+	return *sh.get();
+}
+
+
+std::istream* URIStreamOpener::openFile(const Path& path) const
+{
+	FileStreamFactory factory;
+	return factory.open(path);
+}
+
+
+std::istream* URIStreamOpener::openURI(const std::string& scheme, const URI& uri) const
+{
+	std::string actualScheme(scheme);
+	URI actualURI(uri);
+	int redirects = 0;
+	
+	while (redirects < MAX_REDIRECTS)
+	{
+		try
+		{
+			FactoryMap::const_iterator it = _map.find(actualScheme);
+			if (it != _map.end())
+				return it->second->open(actualURI);
+			else if (redirects > 0)
+				throw UnknownURISchemeException(actualURI.toString() + std::string("; redirected from ") + uri.toString());
+			else
+				throw UnknownURISchemeException(actualURI.toString());
+		}
+		catch (URIRedirection& redir)
+		{
+			actualURI = redir.uri();
+			actualScheme = actualURI.getScheme();
+			++redirects;
+		}
+	}
+	throw TooManyURIRedirectsException(uri.toString());
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/UTF16Encoding.cpp b/base/poco/Foundation/src/UTF16Encoding.cpp
new file mode 100644
index 00000000000..ea2ee8fe4f2
--- /dev/null
+++ b/base/poco/Foundation/src/UTF16Encoding.cpp
@@ -0,0 +1,273 @@
+//
+// UTF16Encoding.cpp
+//
+// Library: Foundation
+// Package: Text
+// Module:  UTF16Encoding
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/UTF16Encoding.h"
+#include "Poco/ByteOrder.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+
+
+const char* UTF16Encoding::_names[] =
+{
+	"UTF-16",
+	"UTF16",
+	NULL
+};
+
+
+const TextEncoding::CharacterMap UTF16Encoding::_charMap = 
+{
+	/* 00 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* 10 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* 20 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* 30 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* 40 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* 50 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* 60 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* 70 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* 80 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* 90 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* a0 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* b0 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* c0 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* d0 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* e0 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* f0 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+};
+
+
+UTF16Encoding::UTF16Encoding(ByteOrderType byteOrder)
+{
+	setByteOrder(byteOrder);
+}
+
+	
+UTF16Encoding::UTF16Encoding(int byteOrderMark)
+{
+	setByteOrder(byteOrderMark);
+}
+
+	
+UTF16Encoding::~UTF16Encoding()
+{
+}
+
+
+UTF16Encoding::ByteOrderType UTF16Encoding::getByteOrder() const
+{
+#if defined(POCO_ARCH_BIG_ENDIAN)
+	return _flipBytes ? LITTLE_ENDIAN_BYTE_ORDER : BIG_ENDIAN_BYTE_ORDER;
+#else
+	return _flipBytes ? BIG_ENDIAN_BYTE_ORDER : LITTLE_ENDIAN_BYTE_ORDER;
+#endif
+}
+
+	
+void UTF16Encoding::setByteOrder(ByteOrderType byteOrder)
+{
+#if defined(POCO_ARCH_BIG_ENDIAN)
+	_flipBytes = byteOrder == LITTLE_ENDIAN_BYTE_ORDER;
+#else
+	_flipBytes = byteOrder == BIG_ENDIAN_BYTE_ORDER;;
+#endif
+}
+
+	
+void UTF16Encoding::setByteOrder(int byteOrderMark)
+{
+	_flipBytes = byteOrderMark != 0xFEFF;
+}
+
+
+const char* UTF16Encoding::canonicalName() const
+{
+	return _names[0];
+}
+
+
+bool UTF16Encoding::isA(const std::string& encodingName) const
+{
+	for (const char** name = _names; *name; ++name)
+	{
+		if (Poco::icompare(encodingName, *name) == 0)
+			return true;
+	}
+	return false;
+}
+
+
+const TextEncoding::CharacterMap& UTF16Encoding::characterMap() const
+{
+	return _charMap;
+}
+
+
+int UTF16Encoding::convert(const unsigned char* bytes) const
+{
+	UInt16 uc;
+	unsigned char* p = (unsigned char*) &uc;
+	*p++ = *bytes++;
+	*p++ = *bytes++;
+
+	if (_flipBytes)
+	{
+		ByteOrder::flipBytes(uc);
+	}
+
+	if (uc >= 0xd800 && uc < 0xdc00)
+	{
+		UInt16 uc2;
+		p = (unsigned char*) &uc2;
+		*p++ = *bytes++;
+		*p++ = *bytes++;
+
+		if (_flipBytes)
+		{
+			ByteOrder::flipBytes(uc2);
+		}
+		if (uc2 >= 0xdc00 && uc2 < 0xe000)
+		{
+			return ((uc & 0x3ff) << 10) + (uc2 & 0x3ff) + 0x10000;
+		}
+		else
+		{
+			return -1;
+		}
+	}
+	else
+	{
+		return uc;
+	}
+}
+
+
+int UTF16Encoding::convert(int ch, unsigned char* bytes, int length) const
+{
+	if (ch <= 0xFFFF)
+	{
+		if (bytes && length >= 2)
+		{
+			UInt16 ch1 = _flipBytes ? ByteOrder::flipBytes((UInt16) ch) : (UInt16) ch;
+			unsigned char* p = (unsigned char*) &ch1;
+			*bytes++ = *p++;
+			*bytes++ = *p++;
+		}
+		return 2;
+	}
+	else
+	{
+		if (bytes && length >= 4)
+		{
+			int ch1 = ch - 0x10000;
+			UInt16 w1 = 0xD800 + ((ch1 >> 10) & 0x3FF);
+			UInt16 w2 = 0xDC00 + (ch1 & 0x3FF);
+			if (_flipBytes)
+			{
+				w1 = ByteOrder::flipBytes(w1);
+				w2 = ByteOrder::flipBytes(w2);
+			}
+			unsigned char* p = (unsigned char*) &w1;
+			*bytes++ = *p++;
+			*bytes++ = *p++;
+			p = (unsigned char*) &w2;
+			*bytes++ = *p++;
+			*bytes++ = *p++;
+		}
+		return 4;
+	}
+}
+
+
+int UTF16Encoding::queryConvert(const unsigned char* bytes, int length) const
+{
+	int ret = -2;
+
+	if (length >= 2)
+	{
+		UInt16 uc;
+		unsigned char* p = (unsigned char*) &uc;
+		*p++ = *bytes++;
+		*p++ = *bytes++;
+		if (_flipBytes) 
+			ByteOrder::flipBytes(uc);
+		if (uc >= 0xd800 && uc < 0xdc00)
+		{
+			if (length >= 4)
+			{
+				UInt16 uc2;
+				p = (unsigned char*) &uc2;
+				*p++ = *bytes++;
+				*p++ = *bytes++;
+				if (_flipBytes) 
+					ByteOrder::flipBytes(uc2);
+				if (uc2 >= 0xdc00 && uc < 0xe000)
+				{
+					ret = ((uc & 0x3ff) << 10) + (uc2 & 0x3ff) + 0x10000;
+				}
+				else
+				{
+					ret = -1;	// Malformed sequence
+				}
+			}
+			else
+			{
+				ret = -4;	// surrogate pair, four bytes needed
+			}
+		}
+		else
+		{
+			ret = uc;
+		}
+	}
+
+	return ret;
+}
+
+
+int UTF16Encoding::sequenceLength(const unsigned char* bytes, int length) const
+{
+	int ret = -2;
+
+	if (_flipBytes)
+	{
+		if (length >= 1)
+		{
+			unsigned char c = *bytes;
+			if (c >= 0xd8 && c < 0xdc)
+				ret = 4;
+			else
+				ret = 2;
+		}
+	}
+	else
+	{
+		if (length >= 2)
+		{
+			UInt16 uc;
+			unsigned char* p = (unsigned char*) &uc;
+			*p++ = *bytes++;
+			*p++ = *bytes++;
+			if (uc >= 0xd800 && uc < 0xdc00)
+				ret = 4;
+			else
+				ret = 2;
+		}
+	}
+	return ret;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/UTF32Encoding.cpp b/base/poco/Foundation/src/UTF32Encoding.cpp
new file mode 100644
index 00000000000..ff07006a4fb
--- /dev/null
+++ b/base/poco/Foundation/src/UTF32Encoding.cpp
@@ -0,0 +1,178 @@
+//
+// UTF32Encoding.cpp
+//
+// Library: Foundation
+// Package: Text
+// Module:  UTF32Encoding
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/UTF32Encoding.h"
+#include "Poco/ByteOrder.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+
+
+const char* UTF32Encoding::_names[] =
+{
+	"UTF-32",
+	"UTF32",
+	NULL
+};
+
+
+const TextEncoding::CharacterMap UTF32Encoding::_charMap = 
+{
+	/* 00 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* 10 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* 20 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* 30 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* 40 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* 50 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* 60 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* 70 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* 80 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* 90 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* a0 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* b0 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* c0 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* d0 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* e0 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+	/* f0 */	-2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, 
+};
+
+
+UTF32Encoding::UTF32Encoding(ByteOrderType byteOrder)
+{
+	setByteOrder(byteOrder);
+}
+
+	
+UTF32Encoding::UTF32Encoding(int byteOrderMark)
+{
+	setByteOrder(byteOrderMark);
+}
+
+	
+UTF32Encoding::~UTF32Encoding()
+{
+}
+
+
+UTF32Encoding::ByteOrderType UTF32Encoding::getByteOrder() const
+{
+#if defined(POCO_ARCH_BIG_ENDIAN)
+	return _flipBytes ? LITTLE_ENDIAN_BYTE_ORDER : BIG_ENDIAN_BYTE_ORDER;
+#else
+	return _flipBytes ? BIG_ENDIAN_BYTE_ORDER : LITTLE_ENDIAN_BYTE_ORDER;
+#endif
+}
+
+	
+void UTF32Encoding::setByteOrder(ByteOrderType byteOrder)
+{
+#if defined(POCO_ARCH_BIG_ENDIAN)
+	_flipBytes = byteOrder == LITTLE_ENDIAN_BYTE_ORDER;
+#else
+	_flipBytes = byteOrder == BIG_ENDIAN_BYTE_ORDER;;
+#endif
+}
+
+	
+void UTF32Encoding::setByteOrder(int byteOrderMark)
+{
+	_flipBytes = byteOrderMark != 0xFEFF;
+}
+
+
+const char* UTF32Encoding::canonicalName() const
+{
+	return _names[0];
+}
+
+
+bool UTF32Encoding::isA(const std::string& encodingName) const
+{
+	for (const char** name = _names; *name; ++name)
+	{
+		if (Poco::icompare(encodingName, *name) == 0)
+			return true;
+	}
+	return false;
+}
+
+
+const TextEncoding::CharacterMap& UTF32Encoding::characterMap() const
+{
+	return _charMap;
+}
+
+
+int UTF32Encoding::convert(const unsigned char* bytes) const
+{
+	UInt32 uc;
+	unsigned char* p = (unsigned char*) &uc;
+	*p++ = *bytes++;
+	*p++ = *bytes++;
+	*p++ = *bytes++;
+	*p++ = *bytes++;
+
+	if (_flipBytes)
+	{
+		ByteOrder::flipBytes(uc);
+	}
+
+	return uc;
+}
+
+
+int UTF32Encoding::convert(int ch, unsigned char* bytes, int length) const
+{
+	if (bytes && length >= 4)
+	{
+		UInt32 ch1 = _flipBytes ? ByteOrder::flipBytes((UInt32) ch) : (UInt32) ch;
+		unsigned char* p = (unsigned char*) &ch1;
+		*bytes++ = *p++;
+		*bytes++ = *p++;
+		*bytes++ = *p++;
+		*bytes++ = *p++;
+	}
+	return 4;
+}
+
+
+int UTF32Encoding::queryConvert(const unsigned char* bytes, int length) const
+{
+	int ret = -4;
+
+	if (length >= 4)
+	{
+		UInt32 uc;
+		unsigned char* p = (unsigned char*) &uc;
+		*p++ = *bytes++;
+		*p++ = *bytes++;
+		*p++ = *bytes++;
+		*p++ = *bytes++;
+		if (_flipBytes) 
+			ByteOrder::flipBytes(uc);
+		return uc;
+	}
+
+	return ret;
+}
+
+
+int UTF32Encoding::sequenceLength(const unsigned char* bytes, int length) const
+{
+	return 4;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/UTF8Encoding.cpp b/base/poco/Foundation/src/UTF8Encoding.cpp
new file mode 100644
index 00000000000..78fc6d4a842
--- /dev/null
+++ b/base/poco/Foundation/src/UTF8Encoding.cpp
@@ -0,0 +1,246 @@
+//
+// UTF8Encoding.cpp
+//
+// Library: Foundation
+// Package: Text
+// Module:  UTF8Encoding
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/UTF8Encoding.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+
+
+const char* UTF8Encoding::_names[] =
+{
+	"UTF-8",
+	"UTF8",
+	NULL
+};
+
+
+const TextEncoding::CharacterMap UTF8Encoding::_charMap =
+{
+	/* 00 */	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+	/* 10 */	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+	/* 20 */	0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
+	/* 30 */	0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+	/* 40 */	0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+	/* 50 */	0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
+	/* 60 */	0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
+	/* 70 */	0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
+	/* 80 */	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+	/* 90 */	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+	/* a0 */	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+	/* b0 */	  -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+	/* c0 */	  -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,
+	/* d0 */	  -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,
+	/* e0 */	  -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,   -3,
+	/* f0 */	  -4,   -4,   -4,   -4,   -4,   -4,   -4,   -4,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+};
+
+
+UTF8Encoding::UTF8Encoding()
+{
+}
+
+
+UTF8Encoding::~UTF8Encoding()
+{
+}
+
+
+const char* UTF8Encoding::canonicalName() const
+{
+	return _names[0];
+}
+
+
+bool UTF8Encoding::isA(const std::string& encodingName) const
+{
+	for (const char** name = _names; *name; ++name)
+	{
+		if (Poco::icompare(encodingName, *name) == 0)
+			return true;
+	}
+	return false;
+}
+
+
+const TextEncoding::CharacterMap& UTF8Encoding::characterMap() const
+{
+	return _charMap;
+}
+
+
+int UTF8Encoding::convert(const unsigned char* bytes) const
+{
+	int n = _charMap[*bytes];
+	int uc;
+
+	switch (n)
+	{
+	case -1:
+		return -1;
+	case -4:
+	case -3:
+	case -2:
+		if (!isLegal(bytes, -n)) return -1;
+		uc = *bytes & ((0x07 << (n + 4)) | 0x03);
+		break;
+	default:
+		return n;
+	}
+
+	while (n++ < -1)
+	{
+		uc <<= 6;
+		uc |= (*++bytes & 0x3F);
+	}
+	return uc;
+}
+
+
+int UTF8Encoding::convert(int ch, unsigned char* bytes, int length) const
+{
+	if (ch <= 0x7F)
+	{
+		if (bytes && length >= 1)
+			*bytes = (unsigned char) ch;
+		return 1;
+	}
+	else if (ch <= 0x7FF)
+	{
+		if (bytes && length >= 2)
+		{
+			*bytes++ = (unsigned char) (((ch >> 6) & 0x1F) | 0xC0);
+			*bytes   = (unsigned char) ((ch & 0x3F) | 0x80);
+		}
+		return 2;
+	}
+	else if (ch <= 0xFFFF)
+	{
+		if (bytes && length >= 3)
+		{
+			*bytes++ = (unsigned char) (((ch >> 12) & 0x0F) | 0xE0);
+			*bytes++ = (unsigned char) (((ch >> 6) & 0x3F) | 0x80);
+			*bytes   = (unsigned char) ((ch & 0x3F) | 0x80);
+		}
+		return 3;
+	}
+	else if (ch <= 0x10FFFF)
+	{
+		if (bytes && length >= 4)
+		{
+			*bytes++ = (unsigned char) (((ch >> 18) & 0x07) | 0xF0);
+			*bytes++ = (unsigned char) (((ch >> 12) & 0x3F) | 0x80);
+			*bytes++ = (unsigned char) (((ch >> 6) & 0x3F) | 0x80);
+			*bytes   = (unsigned char) ((ch & 0x3F) | 0x80);
+		}
+		return 4;
+	}
+	else return 0;
+}
+
+
+int UTF8Encoding::queryConvert(const unsigned char* bytes, int length) const
+{
+	int n = _charMap[*bytes];
+	int uc;
+	if (-n > length)
+	{
+		return n;
+	}
+	else
+	{
+		switch (n)
+		{
+		case -1:
+			return -1;
+		case -4:
+		case -3:
+		case -2:
+			if (!isLegal(bytes, -n)) return -1;
+			uc = *bytes & ((0x07 << (n + 4)) | 0x03);
+			break;
+		default:
+			return n;
+		}
+		while (n++ < -1)
+		{
+			uc <<= 6;
+			uc |= (*++bytes & 0x3F);
+		}
+		return uc;
+	}
+}
+
+
+int UTF8Encoding::sequenceLength(const unsigned char* bytes, int length) const
+{
+	if (1 <= length)
+	{
+		int cc = _charMap[*bytes];
+		if (cc >= 0)
+			return 1;
+		else
+			return -cc;
+	}
+	else return -1;
+}
+
+
+bool UTF8Encoding::isLegal(const unsigned char *bytes, int length)
+{
+	// Note: The following is loosely based on the isLegalUTF8 function
+	// from ftp://ftp.unicode.org/Public/PROGRAMS/CVTUTF/ConvertUTF.c
+	// Excuse the ugliness...
+
+	if (0 == bytes || 0 == length) return false;
+
+    unsigned char a;
+    const unsigned char* srcptr = bytes + length;
+    switch (length)
+	{
+	default:
+		return false;
+		// Everything else falls through when true.
+	case 4:
+		if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
+	case 3:
+		if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
+	case 2:
+		a = (*--srcptr);
+		switch (*bytes)
+		{
+		case 0xE0:
+			if (a < 0xA0 || a > 0xBF) return false;
+			break;
+		case 0xED:
+			if (a < 0x80 || a > 0x9F) return false;
+			break;
+		case 0xF0:
+			if (a < 0x90 || a > 0xBF) return false;
+			break;
+		case 0xF4:
+			if (a < 0x80 || a > 0x8F) return false;
+			break;
+		default:
+			if (a < 0x80 || a > 0xBF) return false;
+		}
+	case 1:
+		if (*bytes >= 0x80 && *bytes < 0xC2) return false;
+    }
+	return *bytes <= 0xF4;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/UTF8String.cpp b/base/poco/Foundation/src/UTF8String.cpp
new file mode 100644
index 00000000000..e5020695a4c
--- /dev/null
+++ b/base/poco/Foundation/src/UTF8String.cpp
@@ -0,0 +1,377 @@
+//
+// UTF8String.cpp
+//
+// Library: Foundation
+// Package: Text
+// Module:  UTF8String
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/UTF8String.h"
+#include "Poco/Unicode.h"
+#include "Poco/TextIterator.h"
+#include "Poco/TextConverter.h"
+#include "Poco/UTF8Encoding.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/Ascii.h"
+#include <algorithm>
+
+
+namespace Poco {
+
+
+namespace
+{
+	static UTF8Encoding utf8;
+}
+
+
+int UTF8::icompare(const std::string& str, std::string::size_type pos, std::string::size_type n, std::string::const_iterator it2, std::string::const_iterator end2)
+{	
+	std::string::size_type sz = str.size();
+	if (pos > sz) pos = sz;
+	if (pos + n > sz) n = sz - pos;
+	TextIterator uit1(str.begin() + pos, str.begin() + pos + n, utf8); 
+	TextIterator uend1(str.begin() + pos + n);
+	TextIterator uit2(it2, end2, utf8);
+	TextIterator uend2(end2);
+	while (uit1 != uend1 && uit2 != uend2)
+	{
+        int c1 = Unicode::toLower(*uit1);
+        int c2 = Unicode::toLower(*uit2);
+        if (c1 < c2)
+            return -1;
+        else if (c1 > c2)
+            return 1;
+        ++uit1; ++uit2;
+	}
+    
+    if (uit1 == uend1)
+		return uit2 == uend2 ? 0 : -1;
+    else
+        return 1;
+}
+
+
+int UTF8::icompare(const std::string& str1, const std::string& str2)
+{
+	return icompare(str1, 0, str1.size(), str2.begin(), str2.end());
+}
+
+
+int UTF8::icompare(const std::string& str1, std::string::size_type n1, const std::string& str2, std::string::size_type n2)
+{
+	if (n2 > str2.size()) n2 = str2.size();
+	return icompare(str1, 0, n1, str2.begin(), str2.begin() + n2);
+}
+
+
+int UTF8::icompare(const std::string& str1, std::string::size_type n, const std::string& str2)
+{
+	if (n > str2.size()) n = str2.size();
+	return icompare(str1, 0, n, str2.begin(), str2.begin() + n);
+}
+
+
+int UTF8::icompare(const std::string& str1, std::string::size_type pos, std::string::size_type n, const std::string& str2)
+{
+	return icompare(str1, pos, n, str2.begin(), str2.end());
+}
+
+
+int UTF8::icompare(const std::string& str1, std::string::size_type pos1, std::string::size_type n1, const std::string& str2, std::string::size_type pos2, std::string::size_type n2)
+{
+	std::string::size_type sz2 = str2.size();
+	if (pos2 > sz2) pos2 = sz2;
+	if (pos2 + n2 > sz2) n2 = sz2 - pos2;
+	return icompare(str1, pos1, n1, str2.begin() + pos2, str2.begin() + pos2 + n2);
+}
+
+
+int UTF8::icompare(const std::string& str1, std::string::size_type pos1, std::string::size_type n, const std::string& str2, std::string::size_type pos2)
+{
+	std::string::size_type sz2 = str2.size();
+	if (pos2 > sz2) pos2 = sz2;
+	if (pos2 + n > sz2) n = sz2 - pos2;
+	return icompare(str1, pos1, n, str2.begin() + pos2, str2.begin() + pos2 + n);
+}
+
+
+int UTF8::icompare(const std::string& str, std::string::size_type pos, std::string::size_type n, const std::string::value_type* ptr)
+{
+	poco_check_ptr (ptr);
+	std::string str2(ptr); // TODO: optimize
+	return icompare(str, pos, n, str2.begin(), str2.end());
+}
+
+
+int UTF8::icompare(const std::string& str, std::string::size_type pos, const std::string::value_type* ptr)
+{
+	return icompare(str, pos, str.size() - pos, ptr);
+}
+
+
+int UTF8::icompare(const std::string& str, const std::string::value_type* ptr)
+{
+	return icompare(str, 0, str.size(), ptr);
+}
+
+
+std::string UTF8::toUpper(const std::string& str)
+{
+	std::string result;
+	TextConverter converter(utf8, utf8);
+	converter.convert(str, result, Unicode::toUpper);
+	return result;
+}
+
+
+std::string& UTF8::toUpperInPlace(std::string& str)
+{
+	std::string result;
+	TextConverter converter(utf8, utf8);
+	converter.convert(str, result, Unicode::toUpper);
+	std::swap(str, result);
+	return str;
+}
+
+
+std::string UTF8::toLower(const std::string& str)
+{
+	std::string result;
+	TextConverter converter(utf8, utf8);
+	converter.convert(str, result, Unicode::toLower);
+	return result;
+}
+
+
+std::string& UTF8::toLowerInPlace(std::string& str)
+{
+	std::string result;
+	TextConverter converter(utf8, utf8);
+	converter.convert(str, result, Unicode::toLower);
+	std::swap(str, result);
+	return str;
+}
+
+
+void UTF8::removeBOM(std::string& str)
+{
+	if (str.size() >= 3 
+		&& static_cast<unsigned char>(str[0]) == 0xEF 
+		&& static_cast<unsigned char>(str[1]) == 0xBB 
+		&& static_cast<unsigned char>(str[2]) == 0xBF)
+	{
+		str.erase(0, 3);
+	}
+}
+
+
+std::string UTF8::escape(const std::string &s, bool strictJSON)
+{
+	return escape(s.begin(), s.end(), strictJSON);
+}
+
+
+std::string UTF8::escape(const std::string::const_iterator& begin, const std::string::const_iterator& end, bool strictJSON)
+{
+	static Poco::UInt32 offsetsFromUTF8[6] = {
+		0x00000000UL, 0x00003080UL, 0x000E2080UL,
+		0x03C82080UL, 0xFA082080UL, 0x82082080UL
+	};
+
+	std::string result;
+
+	std::string::const_iterator it = begin;
+
+	while(it != end)
+	{
+		Poco::UInt32 ch = 0;
+		unsigned int sz = 0;
+
+		do
+		{
+			ch <<= 6;
+			ch += (unsigned char)*it++;
+			sz++;
+		}
+		while (it != end && (*it & 0xC0) == 0x80 && sz < 6);
+		ch -= offsetsFromUTF8[sz-1];
+
+		if (ch == '\n') result += "\\n";
+		else if (ch == '\t') result += "\\t";
+		else if (ch == '\r') result += "\\r";
+		else if (ch == '\b') result += "\\b";
+		else if (ch == '\f') result += "\\f";
+		else if (ch == '\v') result += (strictJSON ? "\\u000B" : "\\v");
+		else if (ch == '\a') result += (strictJSON ? "\\u0007" : "\\a");
+		else if (ch == '\\') result +=  "\\\\";
+		else if (ch == '\"') result +=  "\\\"";
+		else if (ch == '/') result +=  "\\/";
+		else if (ch == '\0') result += "\\u0000";
+		else if (ch < 32 || ch == 0x7f)
+		{
+			result += "\\u";
+			NumberFormatter::appendHex(result, (unsigned short) ch, 4);
+		}
+		else if (ch > 0xFFFF)
+		{
+			ch -= 0x10000;
+			result += "\\u";
+			NumberFormatter::appendHex(result, (unsigned short) (( ch >> 10 ) & 0x03ff ) + 0xd800, 4);
+			result += "\\u";
+			NumberFormatter::appendHex(result, (unsigned short) (ch & 0x03ff ) + 0xdc00, 4);
+		}
+		else if (ch >= 0x80 && ch <= 0xFFFF)
+		{
+			result += "\\u";
+			NumberFormatter::appendHex(result, (unsigned short) ch, 4);
+		}
+		else
+		{
+			result += (char) ch;
+		}
+	}
+	return result;
+}
+
+
+std::string UTF8::unescape(const std::string &s)
+{
+	return unescape(s.begin(), s.end());
+}
+
+
+std::string UTF8::unescape(const std::string::const_iterator& begin, const std::string::const_iterator& end)
+{
+	std::string result;
+
+	std::string::const_iterator it = begin;
+
+	while (it != end)
+	{
+		Poco::UInt32 ch = (Poco::UInt32) *it++;
+
+		if (ch == '\\')
+		{
+			if ( it == end )
+			{
+				//Invalid sequence!
+			}
+
+			if (*it == 'n')
+			{
+				ch = '\n';
+				it++;
+			}
+			else if (*it == 't')
+			{
+				ch = '\t';
+				it++;
+			}
+			else if (*it == 'r')
+			{
+				ch = '\r';
+				it++;
+			}
+			else if (*it == 'b')
+			{
+				ch = '\b';
+				it++;
+			}
+			else if (*it == 'f')
+			{
+				ch = '\f';
+				it++;
+			}
+			else if (*it == 'v')
+			{
+				ch = '\v';
+				it++;
+			}
+			else if (*it == 'a')
+			{
+				ch = '\a';
+				it++;
+			}
+			else if (*it == 'u')
+			{
+				char digs[5];
+				std::memset(digs, 0, 5);
+				unsigned int dno = 0;
+
+				it++;
+
+				while (it != end && Ascii::isHexDigit(*it) && dno < 4) digs[dno++] = *it++;
+				if (dno > 0)
+				{
+					ch = std::strtol(digs, NULL, 16);
+				}
+
+				if( ch >= 0xD800 && ch <= 0xDBFF )
+				{
+					if ( it == end || *it != '\\' )
+					{
+						//Invalid sequence!
+					}
+					else
+					{
+						it++;
+						if ( it == end || *it != 'u' )
+						{
+							//Invalid sequence!
+						}
+						else
+						{
+							it++;
+						}
+					}
+
+					// UTF-16 surrogate pair. Go fetch other half
+					std::memset(digs, 0, 5);
+					dno = 0;
+					while (it != end && Ascii::isHexDigit(*it) && dno < 4) digs[dno++] = *it++;
+					if (dno > 0)
+					{
+						Poco::UInt32 temp = std::strtol(digs, NULL, 16);
+						if( temp >= 0xDC00 && temp <= 0xDFFF )
+						{
+							ch = ( ( ( ch - 0xD800 ) << 10 ) | ( temp - 0xDC00 ) ) + 0x10000;
+						}
+					}
+				}
+			}
+			else if (*it == 'U')
+			{
+				char digs[9];
+				std::memset(digs, 0, 9);
+				unsigned int dno = 0;
+
+				it++;
+				while (it != end && Ascii::isHexDigit(*it) && dno < 8)
+				{
+					digs[dno++] = *it++;
+				}
+				if (dno > 0)
+				{
+					ch = std::strtol(digs, NULL, 16);
+				}
+			}
+		}
+
+		unsigned char utf8[4];
+		UTF8Encoding encoding;
+		int sz = encoding.convert(ch, utf8, 4);
+		result.append((char*) utf8, sz);
+	}
+
+	return result;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/UUID.cpp b/base/poco/Foundation/src/UUID.cpp
new file mode 100644
index 00000000000..0fc15dd6d97
--- /dev/null
+++ b/base/poco/Foundation/src/UUID.cpp
@@ -0,0 +1,370 @@
+//
+// UUID.cpp
+//
+// Library: Foundation
+// Package: UUID
+// Module:  UUID
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/UUID.h"
+#include "Poco/ByteOrder.h"
+#include "Poco/Exception.h"
+#include <algorithm>
+#include <cstring>
+
+
+namespace Poco {
+
+
+UUID::UUID(): 
+	_timeLow(0), 
+	_timeMid(0),
+	_timeHiAndVersion(0),
+	_clockSeq(0)
+{
+	std::memset(_node, 0, sizeof(_node));
+}
+
+
+UUID::UUID(const UUID& uuid):
+	_timeLow(uuid._timeLow), 
+	_timeMid(uuid._timeMid),
+	_timeHiAndVersion(uuid._timeHiAndVersion),
+	_clockSeq(uuid._clockSeq)
+{
+	std::memcpy(_node, uuid._node, sizeof(_node));
+}
+
+
+UUID::UUID(const std::string& uuid)
+{
+	parse(uuid);
+}
+
+	
+UUID::UUID(const char* uuid)
+{
+	poco_check_ptr (uuid);
+	parse(std::string(uuid));
+}
+
+
+UUID::UUID(UInt32 timeLow, UInt32 timeMid, UInt32 timeHiAndVersion, UInt16 clockSeq, UInt8 node[]):
+	_timeLow(timeLow),
+	_timeMid(timeMid),
+	_timeHiAndVersion(timeHiAndVersion),
+	_clockSeq(clockSeq)
+{
+	std::memcpy(_node, node, sizeof(_node));
+}
+
+
+UUID::UUID(const char* bytes, Version version)
+{
+	UInt32 i32;
+	UInt16 i16;
+	std::memcpy(&i32, bytes, sizeof(i32));
+	_timeLow = ByteOrder::fromNetwork(i32);
+	bytes += sizeof(i32);
+	std::memcpy(&i16, bytes, sizeof(i16));
+	_timeMid = ByteOrder::fromNetwork(i16);
+	bytes += sizeof(i16);
+	std::memcpy(&i16, bytes, sizeof(i16));
+	_timeHiAndVersion = ByteOrder::fromNetwork(i16);
+	bytes += sizeof(i16);
+	std::memcpy(&i16, bytes, sizeof(i16));
+	_clockSeq = ByteOrder::fromNetwork(i16);
+	bytes += sizeof(i16);
+	std::memcpy(_node, bytes, sizeof(_node));
+
+	_timeHiAndVersion &= 0x0FFF;
+	_timeHiAndVersion |= (version << 12);
+	_clockSeq &= 0x3FFF;
+	_clockSeq |= 0x8000;
+}
+
+
+UUID::~UUID()
+{
+}
+
+
+UUID& UUID::operator = (const UUID& uuid)
+{
+	if (&uuid != this)
+	{
+		_timeLow = uuid._timeLow;
+		_timeMid = uuid._timeMid;
+		_timeHiAndVersion = uuid._timeHiAndVersion;
+		_clockSeq         = uuid._clockSeq;
+		std::memcpy(_node, uuid._node, sizeof(_node));
+	}
+	return *this;
+}
+
+
+void UUID::swap(UUID& uuid)
+{
+	std::swap(_timeLow, uuid._timeLow);
+	std::swap(_timeMid, uuid._timeMid);
+	std::swap(_timeHiAndVersion, uuid._timeHiAndVersion);
+	std::swap(_clockSeq, uuid._clockSeq);
+	std::swap_ranges(_node, _node + 6, &uuid._node[0]);
+}
+
+
+void UUID::parse(const std::string& uuid)
+{
+	if (!tryParse(uuid))
+		throw SyntaxException(uuid);
+}	
+
+
+bool UUID::tryParse(const std::string& uuid)
+{
+	if (uuid.size() < 32)
+		return false;
+
+	bool haveHyphens = false;
+	if (uuid[8] == '-' && uuid[13] == '-' && uuid[18] == '-' && uuid[23] == '-')
+	{
+		if (uuid.size() >= 36) 
+			haveHyphens = true;
+		else
+			return false;
+	}
+	
+	UUID newUUID;
+	std::string::const_iterator it = uuid.begin();
+	newUUID._timeLow = 0;
+	for (int i = 0; i < 8; ++i)
+	{
+		Int16 n = nibble(*it++);
+		if (n < 0) return false;
+		newUUID._timeLow = (newUUID._timeLow << 4) | n;
+	}
+	if (haveHyphens) ++it;
+	newUUID._timeMid = 0;
+	for (int i = 0; i < 4; ++i)
+	{
+		Int16 n = nibble(*it++);
+		if (n < 0) return false;
+		newUUID._timeMid = (newUUID._timeMid << 4) | n;
+	}
+	if (haveHyphens) ++it;
+	newUUID._timeHiAndVersion = 0;
+	for (int i = 0; i < 4; ++i)
+	{
+		Int16 n = nibble(*it++);
+		if (n < 0) return false;
+		newUUID._timeHiAndVersion = (newUUID._timeHiAndVersion << 4) | n;
+	}
+	if (haveHyphens) ++it;
+	newUUID._clockSeq = 0;
+	for (int i = 0; i < 4; ++i)
+	{
+		Int16 n = nibble(*it++);
+		if (n < 0) return false;
+		newUUID._clockSeq = (newUUID._clockSeq << 4) | n;
+	}
+	if (haveHyphens) ++it;
+	for (int i = 0; i < 6; ++i)
+	{
+		Int16 n1 = nibble(*it++);
+		if (n1 < 0) return false;
+		Int16 n2 = nibble(*it++);
+		if (n2 < 0) return false;
+
+		newUUID._node[i] = (n1 << 4) | n2;			
+	}
+	swap(newUUID);
+
+	return true;
+}
+
+
+std::string UUID::toString() const
+{
+	std::string result;
+	result.reserve(36);
+	appendHex(result, _timeLow);
+	result += '-';
+	appendHex(result, _timeMid);
+	result += '-';
+	appendHex(result, _timeHiAndVersion);
+	result += '-';
+	appendHex(result, _clockSeq);
+	result += '-';
+	for (int i = 0; i < sizeof(_node); ++i)
+		appendHex(result, _node[i]);
+	return result;
+}
+
+
+void UUID::copyFrom(const char* buffer)
+{
+	UInt32 i32;
+	UInt16 i16;
+	std::memcpy(&i32, buffer, sizeof(i32));
+	_timeLow = ByteOrder::fromNetwork(i32);
+	buffer += sizeof(i32);
+	std::memcpy(&i16, buffer, sizeof(i16));
+	_timeMid = ByteOrder::fromNetwork(i16);
+	buffer += sizeof(i16);
+	std::memcpy(&i16, buffer, sizeof(i16));
+	_timeHiAndVersion = ByteOrder::fromNetwork(i16);
+	buffer += sizeof(i16);
+	std::memcpy(&i16, buffer, sizeof(i16));
+	_clockSeq = ByteOrder::fromNetwork(i16);
+	buffer += sizeof(i16);
+	std::memcpy(_node, buffer, sizeof(_node));
+}
+
+
+void UUID::copyTo(char* buffer) const
+{
+	UInt32 i32 = ByteOrder::toNetwork(_timeLow);
+	std::memcpy(buffer, &i32, sizeof(i32));
+	buffer += sizeof(i32);
+	UInt16 i16 = ByteOrder::toNetwork(_timeMid);
+	std::memcpy(buffer, &i16, sizeof(i16));
+	buffer += sizeof(i16);
+	i16 = ByteOrder::toNetwork(_timeHiAndVersion);
+	std::memcpy(buffer, &i16, sizeof(i16));
+	buffer += sizeof(i16);
+	i16 = ByteOrder::toNetwork(_clockSeq);
+	std::memcpy(buffer, &i16, sizeof(i16));
+	buffer += sizeof(i16);
+	std::memcpy(buffer, _node, sizeof(_node));
+}
+
+
+int UUID::variant() const
+{
+	int v = _clockSeq >> 13;
+	if ((v & 6) == 6)
+		return v;
+	else if (v & 4)
+		return 2;
+	else
+		return 0;
+}
+
+
+int UUID::compare(const UUID& uuid) const
+{
+	if (_timeLow != uuid._timeLow) return _timeLow < uuid._timeLow ? -1 : 1;
+	if (_timeMid != uuid._timeMid) return _timeMid < uuid._timeMid ? -1 : 1;
+	if (_timeHiAndVersion != uuid._timeHiAndVersion) return _timeHiAndVersion < uuid._timeHiAndVersion ? -1 : 1;
+	if (_clockSeq != uuid._clockSeq) return _clockSeq < uuid._clockSeq ? -1 : 1;
+	for (int i = 0; i < sizeof(_node); ++i)
+	{
+		if (_node[i] < uuid._node[i]) 
+			return -1;
+		else if (_node[i] > uuid._node[i])
+			return 1;	
+	}
+	return 0;
+}
+
+
+void UUID::appendHex(std::string& str, UInt8 n) 
+{
+	static const char* digits = "0123456789abcdef";
+	str += digits[(n >> 4) & 0xF];
+	str += digits[n & 0xF];
+}
+
+
+void UUID::appendHex(std::string& str, UInt16 n)
+{
+	appendHex(str, UInt8(n >> 8));
+	appendHex(str, UInt8(n & 0xFF));
+}
+
+
+void UUID::appendHex(std::string& str, UInt32 n)
+{
+	appendHex(str, UInt16(n >> 16));
+	appendHex(str, UInt16(n & 0xFFFF));
+}
+
+
+Int16 UUID::nibble(char hex)
+{
+	if (hex >= 'a' && hex <= 'f')
+		return hex - 'a' + 10;
+	else if (hex >= 'A' && hex <= 'F')
+		return hex - 'A' + 10;
+	else if (hex >= '0' && hex <= '9')
+		return hex - '0';
+	else
+		return -1;
+}
+
+
+void UUID::fromNetwork()
+{
+	_timeLow = ByteOrder::fromNetwork(_timeLow);
+	_timeMid = ByteOrder::fromNetwork(_timeMid);
+	_timeHiAndVersion = ByteOrder::fromNetwork(_timeHiAndVersion);
+	_clockSeq = ByteOrder::fromNetwork(_clockSeq);
+}
+
+
+void UUID::toNetwork()
+{
+	_timeLow = ByteOrder::toNetwork(_timeLow);
+	_timeMid = ByteOrder::toNetwork(_timeMid);
+	_timeHiAndVersion = ByteOrder::toNetwork(_timeHiAndVersion);
+	_clockSeq = ByteOrder::toNetwork(_clockSeq);
+}
+
+
+namespace
+{
+	static UUID uuidNull;
+	static UUID uuidDNS("6ba7b810-9dad-11d1-80b4-00c04fd430c8");
+	static UUID uuidURI("6ba7b811-9dad-11d1-80b4-00c04fd430c8");
+	static UUID uuidOID("6ba7b812-9dad-11d1-80b4-00c04fd430c8");
+	static UUID uuidX500("6ba7b814-9dad-11d1-80b4-00c04fd430c8");
+}
+
+
+const UUID& UUID::null()
+{
+	return uuidNull;
+}
+
+
+const UUID& UUID::dns()
+{
+	return uuidDNS;
+}
+
+	
+const UUID& UUID::uri()
+{
+	return uuidURI;
+}
+
+
+const UUID& UUID::oid()
+{
+	return uuidOID;
+}
+
+
+const UUID& UUID::x500()
+{
+	return uuidX500;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/UUIDGenerator.cpp b/base/poco/Foundation/src/UUIDGenerator.cpp
new file mode 100644
index 00000000000..1ae72005ac8
--- /dev/null
+++ b/base/poco/Foundation/src/UUIDGenerator.cpp
@@ -0,0 +1,151 @@
+//
+// UUIDGenerator.cpp
+//
+// Library: Foundation
+// Package: UUID
+// Module:  UUID
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/UUIDGenerator.h"
+#include "Poco/Thread.h"
+#include "Poco/RandomStream.h"
+#include "Poco/DigestEngine.h"
+#include "Poco/MD5Engine.h"
+#include "Poco/SHA1Engine.h"
+#include "Poco/SingletonHolder.h"
+#include <cstring>
+
+
+namespace Poco {
+
+
+UUIDGenerator::UUIDGenerator(): _ticks(0), _haveNode(false)
+{
+}
+
+
+UUIDGenerator::~UUIDGenerator()
+{
+}
+
+
+UUID UUIDGenerator::create()
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (!_haveNode)
+	{
+		Environment::nodeId(_node);
+		_haveNode = true;
+	}
+	Timestamp::UtcTimeVal tv = timeStamp();
+	UInt32 timeLow = UInt32(tv & 0xFFFFFFFF);
+	UInt16 timeMid = UInt16((tv >> 32) & 0xFFFF);
+	UInt16 timeHiAndVersion = UInt16((tv >> 48) & 0x0FFF) + (UUID::UUID_TIME_BASED << 12);
+	UInt16 clockSeq = (UInt16(_random.next() >> 4) & 0x3FFF) | 0x8000;
+	return UUID(timeLow, timeMid, timeHiAndVersion, clockSeq, _node);
+}
+
+
+UUID UUIDGenerator::createFromName(const UUID& nsid, const std::string& name)
+{
+	MD5Engine md5;
+	return createFromName(nsid, name, md5);
+}
+
+
+UUID UUIDGenerator::createFromName(const UUID& nsid, const std::string& name, DigestEngine& de)
+{
+	UUID::Version version = UUID::UUID_NAME_BASED;
+	if (dynamic_cast<SHA1Engine*>(&de)) version = UUID::UUID_NAME_BASED_SHA1;
+	return createFromName(nsid, name, de, version);
+}
+
+
+UUID UUIDGenerator::createFromName(const UUID& nsid, const std::string& name, DigestEngine& de, UUID::Version version)
+{
+	poco_assert_dbg (de.digestLength() >= 16);
+
+	UUID netNsid = nsid;
+	netNsid.toNetwork();
+	de.reset();
+	de.update(&netNsid._timeLow, sizeof(netNsid._timeLow));
+	de.update(&netNsid._timeMid, sizeof(netNsid._timeMid));
+	de.update(&netNsid._timeHiAndVersion, sizeof(netNsid._timeHiAndVersion));
+	de.update(&netNsid._clockSeq, sizeof(netNsid._clockSeq));
+	de.update(&netNsid._node[0], sizeof(netNsid._node));
+	de.update(name);
+	char buffer[16];
+	const DigestEngine::Digest& d = de.digest();
+	for (int i = 0; i < 16; ++i)
+	{
+		buffer[i] = d[i];
+	}
+	return UUID(buffer, version);
+}
+
+	
+UUID UUIDGenerator::createRandom()
+{
+	char buffer[16];
+	RandomInputStream ris;
+	ris.read(buffer, sizeof(buffer));
+	return UUID(buffer, UUID::UUID_RANDOM);
+}
+
+
+Timestamp::UtcTimeVal UUIDGenerator::timeStamp()
+{
+	Timestamp now;
+	for (;;)
+	{
+		if (now != _lastTime)
+		{
+			_lastTime = now;
+			_ticks = 0;
+			break;
+		}
+		if (_ticks < 100)
+		{
+			++_ticks;
+			break;
+		}
+		now.update();
+	}
+	Timestamp::UtcTimeVal tv = now.utcTime();
+	return tv + _ticks;
+}
+
+
+UUID UUIDGenerator::createOne()
+{
+	try
+	{
+		return create();
+	}
+	catch (Exception&)
+	{
+		return createRandom();
+	}
+}
+
+
+namespace
+{
+	static SingletonHolder<UUIDGenerator> sh;
+}
+
+
+UUIDGenerator& UUIDGenerator::defaultGenerator()
+{
+	return *sh.get();
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Unicode.cpp b/base/poco/Foundation/src/Unicode.cpp
new file mode 100644
index 00000000000..af78d19cf08
--- /dev/null
+++ b/base/poco/Foundation/src/Unicode.cpp
@@ -0,0 +1,56 @@
+//
+// Unicode.cpp
+//
+// Library: Foundation
+// Package: Text
+// Module:  Unicode
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Unicode.h"
+
+
+extern "C"
+{
+#include "pcre_config.h"
+#include "pcre_internal.h"
+}
+
+
+namespace Poco {
+
+
+void Unicode::properties(int ch, CharacterProperties& props)
+{
+	if (ch < 0 || ch > UCP_MAX_CODEPOINT) ch = 0;
+	const ucd_record* ucd = GET_UCD(ch);
+	props.category = static_cast<CharacterCategory>(_pcre_ucp_gentype[ucd->chartype]);
+	props.type     = static_cast<CharacterType>(ucd->chartype);
+	props.script   = static_cast<Script>(ucd->script);
+}
+
+
+int Unicode::toLower(int ch)
+{
+	if (isUpper(ch))
+		return static_cast<int>(UCD_OTHERCASE(static_cast<unsigned>(ch)));
+	else
+		return ch;
+}
+
+
+int Unicode::toUpper(int ch)
+{
+	if (isLower(ch))
+		return static_cast<int>(UCD_OTHERCASE(static_cast<unsigned>(ch)));
+	else
+		return ch;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/UnicodeConverter.cpp b/base/poco/Foundation/src/UnicodeConverter.cpp
new file mode 100644
index 00000000000..992c644c614
--- /dev/null
+++ b/base/poco/Foundation/src/UnicodeConverter.cpp
@@ -0,0 +1,161 @@
+//
+// UnicodeConverter.cpp
+//
+// Library: Foundation
+// Package: Text
+// Module:  UnicodeConverter
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/UnicodeConverter.h"
+#include "Poco/TextConverter.h"
+#include "Poco/TextIterator.h"
+#include "Poco/UTF8Encoding.h"
+#include "Poco/UTF16Encoding.h"
+#include "Poco/UTF32Encoding.h"
+#include <cstring>
+
+
+namespace Poco {
+
+
+void UnicodeConverter::convert(const std::string& utf8String, UTF32String& utf32String)
+{
+	utf32String.clear();
+	UTF8Encoding utf8Encoding;
+	TextIterator it(utf8String, utf8Encoding);
+	TextIterator end(utf8String);
+
+	while (it != end)
+	{
+		int cc = *it++;
+		utf32String += (UTF32Char) cc;
+	}
+}
+
+
+void UnicodeConverter::convert(const char* utf8String, std::size_t length, UTF32String& utf32String)
+{
+	if (!utf8String || !length)
+	{
+		utf32String.clear();
+		return;
+	}
+
+	convert(std::string(utf8String, utf8String + length), utf32String);
+}
+
+
+void UnicodeConverter::convert(const char* utf8String, UTF32String& utf32String)
+{
+	if (!utf8String || !std::strlen(utf8String))
+	{
+		utf32String.clear();
+		return;
+	}
+
+	convert(utf8String, std::strlen(utf8String), utf32String);
+}
+
+
+void UnicodeConverter::convert(const std::string& utf8String, UTF16String& utf16String)
+{
+	utf16String.clear();
+	UTF8Encoding utf8Encoding;
+	TextIterator it(utf8String, utf8Encoding);
+	TextIterator end(utf8String);
+	while (it != end) 
+	{
+		int cc = *it++;
+		if (cc <= 0xffff)
+		{
+			utf16String += (UTF16Char) cc;
+		}
+		else
+		{
+			cc -= 0x10000;
+			utf16String += (UTF16Char) ((cc >> 10) & 0x3ff) | 0xd800;
+			utf16String += (UTF16Char) (cc & 0x3ff) | 0xdc00;
+		}
+	}
+}
+
+
+void UnicodeConverter::convert(const char* utf8String,  std::size_t length, UTF16String& utf16String)
+{
+	if (!utf8String || !length)
+	{
+		utf16String.clear();
+		return;
+	}
+
+	convert(std::string(utf8String, utf8String + length), utf16String);
+}
+
+
+void UnicodeConverter::convert(const char* utf8String, UTF16String& utf16String)
+{
+	if (!utf8String || !std::strlen(utf8String))
+	{
+		utf16String.clear();
+		return;
+	}
+
+	convert(std::string(utf8String), utf16String);
+}
+
+
+void UnicodeConverter::convert(const UTF16String& utf16String, std::string& utf8String)
+{
+	utf8String.clear();
+	UTF8Encoding utf8Encoding;
+	UTF16Encoding utf16Encoding;
+	TextConverter converter(utf16Encoding, utf8Encoding);
+	converter.convert(utf16String.data(), (int) utf16String.length() * sizeof(UTF16Char), utf8String);
+}
+
+
+void UnicodeConverter::convert(const UTF32String& utf32String, std::string& utf8String)
+{
+	utf8String.clear();
+	UTF8Encoding utf8Encoding;
+	UTF32Encoding utf32Encoding;
+	TextConverter converter(utf32Encoding, utf8Encoding);
+	converter.convert(utf32String.data(), (int) utf32String.length() * sizeof(UTF32Char), utf8String);
+}
+
+
+void UnicodeConverter::convert(const UTF16Char* utf16String,  std::size_t length, std::string& utf8String)
+{
+	utf8String.clear();
+	UTF8Encoding utf8Encoding;
+	UTF16Encoding utf16Encoding;
+	TextConverter converter(utf16Encoding, utf8Encoding);
+	converter.convert(utf16String, (int) length * sizeof(UTF16Char), utf8String);
+}
+
+
+void UnicodeConverter::convert(const UTF32Char* utf32String,  std::size_t length, std::string& utf8String)
+{
+	toUTF8(UTF32String(utf32String, length), utf8String);
+}
+
+
+void UnicodeConverter::convert(const UTF16Char* utf16String, std::string& utf8String)
+{
+	toUTF8(utf16String, UTFStrlen(utf16String), utf8String);
+}
+
+
+void UnicodeConverter::convert(const UTF32Char* utf32String, std::string& utf8String)
+{
+	toUTF8(utf32String, UTFStrlen(utf32String), utf8String);
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Var.cpp b/base/poco/Foundation/src/Var.cpp
new file mode 100644
index 00000000000..03deaef8548
--- /dev/null
+++ b/base/poco/Foundation/src/Var.cpp
@@ -0,0 +1,636 @@
+//
+// Var.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  Var
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Dynamic/Var.h"
+#include "Poco/Dynamic/Struct.h"
+#include <algorithm>
+#include <cctype>
+#include <vector>
+#include <list>
+#include <deque>
+
+
+namespace Poco {
+namespace Dynamic {
+
+
+Var::Var()
+#ifdef POCO_NO_SOO
+	: _pHolder(0)
+#endif
+{
+}
+
+
+Var::Var(const char* pVal)
+#ifdef POCO_NO_SOO 
+	: _pHolder(new VarHolderImpl<std::string>(pVal))
+{
+}
+#else
+{
+	construct(std::string(pVal));
+}
+#endif
+
+
+Var::Var(const Var& other)
+#ifdef POCO_NO_SOO
+	: _pHolder(other._pHolder ? other._pHolder->clone() : 0)
+{
+}
+#else
+{
+	if ((this != &other) && !other.isEmpty())
+			construct(other);
+}
+#endif
+
+
+Var::~Var()
+{
+	destruct();
+}
+
+
+Var& Var::operator = (const Var& rhs)
+{
+#ifdef POCO_NO_SOO
+	Var tmp(rhs);
+	swap(tmp);
+#else
+	if ((this != &rhs) && !rhs.isEmpty())
+		construct(rhs);
+	else if ((this != &rhs) && rhs.isEmpty())
+		_placeholder.erase();
+#endif
+	return *this;
+}
+
+
+const Var Var::operator + (const Var& other) const
+{
+	if (isInteger())
+	{
+		if (isSigned())
+			return add<Poco::Int64>(other);
+		else
+			return add<Poco::UInt64>(other);
+	}
+	else if (isNumeric())
+		return add<double>(other);
+	else if (isString())
+		return add<std::string>(other);
+	else
+		throw InvalidArgumentException("Invalid operation for this data type.");
+}
+
+
+Var& Var::operator += (const Var& other)
+{
+	if (isInteger())
+	{
+		if (isSigned())
+			return *this = add<Poco::Int64>(other);
+		else
+			return *this = add<Poco::UInt64>(other);
+	}
+	else if (isNumeric())
+		return *this = add<double>(other);
+	else if (isString())
+		return *this = add<std::string>(other);
+	else
+		throw InvalidArgumentException("Invalid operation for this data type.");
+}
+
+
+const Var Var::operator - (const Var& other) const
+{
+	if (isInteger())
+	{
+		if (isSigned())
+			return subtract<Poco::Int64>(other);
+		else
+			return subtract<Poco::UInt64>(other);
+	}
+	else if (isNumeric())
+		return subtract<double>(other);
+	else
+		throw InvalidArgumentException("Invalid operation for this data type.");
+}
+
+
+Var& Var::operator -= (const Var& other)
+{
+	if (isInteger())
+	{
+		if (isSigned())
+			return *this = subtract<Poco::Int64>(other);
+		else
+			return *this = subtract<Poco::UInt64>(other);
+	}
+	else if (isNumeric())
+		return *this = subtract<double>(other);
+	else
+		throw InvalidArgumentException("Invalid operation for this data type.");
+}
+
+
+const Var Var::operator * (const Var& other) const
+{
+	if (isInteger())
+	{
+		if (isSigned())
+			return multiply<Poco::Int64>(other);
+		else
+			return multiply<Poco::UInt64>(other);
+	}
+	else if (isNumeric())
+		return multiply<double>(other);
+	else
+		throw InvalidArgumentException("Invalid operation for this data type.");
+}
+
+
+Var& Var::operator *= (const Var& other)
+{
+	if (isInteger())
+	{
+		if (isSigned())
+			return *this = multiply<Poco::Int64>(other);
+		else
+			return *this = multiply<Poco::UInt64>(other);
+	}
+	else if (isNumeric())
+		return *this = multiply<double>(other);
+	else
+		throw InvalidArgumentException("Invalid operation for this data type.");
+}
+
+
+const Var Var::operator / (const Var& other) const
+{
+	if (isInteger())
+	{
+		if (isSigned())
+			return divide<Poco::Int64>(other);
+		else
+			return divide<Poco::UInt64>(other);
+	}
+	else if (isNumeric())
+		return divide<double>(other);
+	else
+		throw InvalidArgumentException("Invalid operation for this data type.");
+}
+
+
+Var& Var::operator /= (const Var& other)
+{
+	if (isInteger())
+	{
+		if (isSigned())
+			return *this = divide<Poco::Int64>(other);
+		else
+			return *this = divide<Poco::UInt64>(other);
+	}
+	else if (isNumeric())
+		return *this = divide<double>(other);
+	else
+		throw InvalidArgumentException("Invalid operation for this data type.");
+}
+
+
+Var& Var::operator ++ ()
+{
+	if (!isInteger())
+		throw InvalidArgumentException("Invalid operation for this data type.");
+
+	return *this = *this + 1;
+}
+
+
+const Var Var::operator ++ (int)
+{
+	if (!isInteger())
+		throw InvalidArgumentException("Invalid operation for this data type.");
+
+	Var tmp(*this);
+	*this += 1;
+	return tmp;
+}
+
+
+Var& Var::operator -- ()
+{
+	if (!isInteger())
+		throw InvalidArgumentException("Invalid operation for this data type.");
+
+	return *this = *this - 1;
+}
+
+
+const Var Var::operator -- (int)
+{
+	if (!isInteger())
+		throw InvalidArgumentException("Invalid operation for this data type.");
+
+	Var tmp(*this);
+	*this -= 1;
+	return tmp;
+}
+
+
+bool Var::operator == (const Var& other) const
+{
+	if (isEmpty() != other.isEmpty()) return false;
+	if (isEmpty() && other.isEmpty()) return true;
+	return convert<std::string>() == other.convert<std::string>();
+}
+
+
+bool Var::operator == (const char* other) const
+{
+	if (isEmpty()) return false;
+	return convert<std::string>() == other;
+}
+
+
+bool Var::operator != (const Var& other) const
+{
+	if (isEmpty() && other.isEmpty()) return false;
+	else if (isEmpty() || other.isEmpty()) return true;
+
+	return convert<std::string>() != other.convert<std::string>();
+}
+
+
+bool Var::operator != (const char* other) const
+{
+	if (isEmpty()) return true;
+	return convert<std::string>() != other;
+}
+
+
+bool Var::operator < (const Var& other) const
+{
+	if (isEmpty() || other.isEmpty()) return false;
+	return convert<std::string>() < other.convert<std::string>();
+}
+
+
+bool Var::operator <= (const Var& other) const
+{
+	if (isEmpty() || other.isEmpty()) return false;
+	return convert<std::string>() <= other.convert<std::string>();
+}
+
+
+bool Var::operator > (const Var& other) const
+{
+	if (isEmpty() || other.isEmpty()) return false;
+	return convert<std::string>() > other.convert<std::string>();
+}
+
+
+bool Var::operator >= (const Var& other) const
+{
+	if (isEmpty() || other.isEmpty()) return false;
+	return convert<std::string>() >= other.convert<std::string>();
+}
+
+
+bool Var::operator || (const Var& other) const
+{
+	if (isEmpty() || other.isEmpty()) return false;
+	return convert<bool>() || other.convert<bool>();
+}
+
+
+bool Var::operator && (const Var& other) const
+{
+	if (isEmpty() || other.isEmpty()) return false;
+	return convert<bool>() && other.convert<bool>();
+}
+
+
+void Var::empty()
+{
+#ifdef POCO_NO_SOO
+	delete _pHolder;
+	_pHolder = 0;
+#else
+	if (_placeholder.isLocal()) this->~Var();
+	else delete content();
+	_placeholder.erase();
+#endif
+}
+
+
+void Var::clear()
+{
+#ifdef POCO_NO_SOO
+	delete _pHolder;
+	_pHolder = 0;
+#else
+	if (_placeholder.isLocal()) this->~Var();
+	else delete content();
+	_placeholder.erase();
+#endif
+}
+
+
+Var& Var::getAt(std::size_t n)
+{
+	if (isVector())
+		return holderImpl<std::vector<Var>,
+			InvalidAccessException>("Not a vector.")->operator[](n);
+	else if (isList())
+		return holderImpl<std::list<Var>,
+			InvalidAccessException>("Not a list.")->operator[](n);
+	else if (isDeque())
+		return holderImpl<std::deque<Var>,
+			InvalidAccessException>("Not a deque.")->operator[](n);
+	else if (isStruct())
+		return structIndexOperator(holderImpl<Struct<int>,
+			InvalidAccessException>("Not a struct."), static_cast<int>(n));
+	else if (!isString() && !isEmpty() && (n == 0))
+		return *this;
+	
+	throw RangeException("Index out of bounds.");
+}
+
+
+char& Var::at(std::size_t n)
+{
+	if (isString())
+	{
+		return holderImpl<std::string,
+			InvalidAccessException>("Not a string.")->operator[](n);
+	}
+
+	throw InvalidAccessException("Not a string.");
+}
+
+
+Var& Var::getAt(const std::string& name)
+{
+	return holderImpl<DynamicStruct,
+		InvalidAccessException>("Not a struct.")->operator[](name);
+}
+
+
+Var Var::parse(const std::string& val)
+{
+	std::string::size_type t = 0;
+	return parse(val, t);
+}
+
+
+Var Var::parse(const std::string& val, std::string::size_type& pos)
+{
+	// { -> an Object==DynamicStruct
+	// [ -> an array
+	// '/" -> a string (strip '/")
+	// other: also treat as string
+	skipWhiteSpace(val, pos);
+	if (pos < val.size())
+	{
+		switch (val[pos])
+		{
+		case '{':
+			return parseObject(val, pos);
+		case '[':
+			return parseArray(val, pos);
+		case '"':
+			return parseJSONString(val, pos);
+		default:
+			{
+				std::string str = parseString(val, pos);
+				if (str == "false")
+					return false;
+
+				if (str == "true")
+					return true;
+
+				bool isNumber = false;
+				bool isSigned = false;
+				int separators = 0;
+				int frac = 0;
+				int index = 0;
+				size_t size = str.size();
+				for (size_t i = 0; i < size ; ++i)
+				{
+					int ch = str[i];
+					if ((ch == '-' || ch == '+') && index == 0)
+					{
+						if (ch == '-')
+							isSigned = true;
+					}
+					else if (Ascii::isDigit(ch))
+					{
+						isNumber |= true;
+					}
+					else if (ch == '.' || ch == ',')
+					{
+						frac = ch;
+						++separators;
+						if (separators > 1)
+							return str;
+					}
+					else
+						return str;
+
+					++index;
+				}
+
+				if (frac && isNumber)
+				{
+					const double number = NumberParser::parseFloat(str, frac);
+					return Var(number);
+				}
+				else if (frac == 0 && isNumber && isSigned)
+				{
+					const Poco::Int64 number = NumberParser::parse64(str);
+					return number;
+				}
+				else if (frac == 0 && isNumber && !isSigned)
+				{
+					const Poco::UInt64 number = NumberParser::parseUnsigned64(str);
+					return number;
+				}
+
+				return str;
+			}
+		}
+	}
+	std::string empty;
+	return empty;
+}
+
+
+Var Var::parseObject(const std::string& val, std::string::size_type& pos)
+{
+	poco_assert_dbg (pos < val.size() && val[pos] == '{');
+	++pos;
+	skipWhiteSpace(val, pos);
+	DynamicStruct aStruct;
+	while (val[pos] != '}' && pos < val.size())
+	{
+		std::string key = parseString(val, pos);
+		skipWhiteSpace(val, pos);
+		if (val[pos] != ':')
+			throw DataFormatException("Incorrect object, must contain: key : value pairs"); 
+		++pos; // skip past :
+		Var value = parse(val, pos);
+		aStruct.insert(key, value);
+		skipWhiteSpace(val, pos);
+		if (val[pos] == ',')
+		{
+			++pos;
+			skipWhiteSpace(val, pos);
+		}
+	}
+	if (val[pos] != '}')
+		throw DataFormatException("Unterminated object"); 
+	++pos;
+	return aStruct;
+}
+
+
+Var Var::parseArray(const std::string& val, std::string::size_type& pos)
+{
+	poco_assert_dbg (pos < val.size() && val[pos] == '[');
+	++pos;
+	skipWhiteSpace(val, pos);
+	std::vector<Var> result;
+	while (val[pos] != ']' && pos < val.size())
+	{
+		result.push_back(parse(val, pos));
+		skipWhiteSpace(val, pos);
+		if (val[pos] == ',')
+		{
+			++pos;
+			skipWhiteSpace(val, pos);
+		}
+	}
+	if (val[pos] != ']')
+		throw DataFormatException("Unterminated array"); 
+	++pos;
+	return result;
+}
+
+
+std::string Var::parseString(const std::string& val, std::string::size_type& pos)
+{
+	poco_assert_dbg (pos < val.size());
+	if (val[pos] == '"')
+	{
+		return parseJSONString(val, pos);
+	}
+	else
+	{
+		std::string result;
+		while (pos < val.size() 
+			&& !Poco::Ascii::isSpace(val[pos]) 
+			&& val[pos] != ','
+			&& val[pos] != ']'
+			&& val[pos] != '}')
+		{
+			result += val[pos++];
+		}
+		return result;
+	}
+}
+
+
+std::string Var::parseJSONString(const std::string& val, std::string::size_type& pos)
+{
+	poco_assert_dbg (pos < val.size() && val[pos] == '"');
+	++pos;
+	std::string result;
+	bool done = false;
+	while (pos < val.size() && !done)
+	{
+		switch (val[pos])
+		{
+		case '"':
+			done = true;
+			++pos;
+			break;
+		case '\\':
+			if (pos < val.size())
+			{
+				++pos;
+				switch (val[pos])
+				{
+				case 'b':
+					result += '\b';
+					break; 
+				case 'f':
+					result += '\f';
+					break; 
+				case 'n':
+					result += '\n';
+					break; 
+				case 'r':
+					result += '\r';
+					break; 
+				case 't':
+					result += '\t';
+					break; 
+				default:
+					result += val[pos];
+					break;
+				}
+				break;
+			}
+			else
+			{
+				result += val[pos];
+			}
+			++pos;
+			break;
+		default:
+			result += val[pos++];
+			break;
+		}
+	}
+	if (!done) throw Poco::DataFormatException("unterminated JSON string");
+	return result;
+}
+
+
+void Var::skipWhiteSpace(const std::string& val, std::string::size_type& pos)
+{
+	poco_assert_dbg (pos < val.size());
+	while (std::isspace(val[pos]) && pos < val.size())
+		++pos;
+}
+
+
+std::string Var::toString(const Var& any)
+{
+	std::string res;
+	Impl::appendJSONValue(res, any);
+	return res;
+}
+
+
+Var& Var::structIndexOperator(VarHolderImpl<Struct<int> >* pStr, int n) const
+{
+	return pStr->operator[](n);
+}
+
+
+} } // namespace Poco::Dynamic
diff --git a/base/poco/Foundation/src/VarHolder.cpp b/base/poco/Foundation/src/VarHolder.cpp
new file mode 100644
index 00000000000..a08d6e08c76
--- /dev/null
+++ b/base/poco/Foundation/src/VarHolder.cpp
@@ -0,0 +1,92 @@
+//
+// VarHolder.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  VarHolder
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Dynamic/VarHolder.h"
+#include "Poco/Dynamic/Var.h"
+#include "Poco/JSONString.h"
+
+
+namespace Poco {
+namespace Dynamic {
+
+
+VarHolder::VarHolder()
+{
+}
+
+
+VarHolder::~VarHolder()
+{
+}
+
+
+namespace Impl {
+
+
+void escape(std::string& target, const std::string& source)
+{
+	target = toJSON(source);
+}
+
+
+bool isJSONString(const Var& any)
+{
+	return any.type() == typeid(std::string) ||
+		any.type() == typeid(char) ||
+		any.type() == typeid(char*) ||
+		any.type() == typeid(Poco::DateTime) ||
+		any.type() == typeid(Poco::LocalDateTime) ||
+		any.type() == typeid(Poco::Timestamp);
+}
+
+
+void appendJSONString(std::string& val, const Var& any)
+{
+	std::string json;
+	escape(json, any.convert<std::string>());
+	val.append(json);
+}
+
+
+void appendJSONKey(std::string& val, const Var& any)
+{
+	return appendJSONString(val, any);
+}
+
+
+void appendJSONValue(std::string& val, const Var& any)
+{
+	if (any.isEmpty())
+	{
+		val.append("null");
+	}
+	else
+	{
+		bool isStr = isJSONString(any);
+		if (isStr)
+		{
+			appendJSONString(val, any.convert<std::string>());
+		}
+		else
+		{
+			val.append(any.convert<std::string>());
+		}
+	}
+}
+
+
+} // namespace Impl
+
+
+} } // namespace Poco::Dynamic
diff --git a/base/poco/Foundation/src/VarIterator.cpp b/base/poco/Foundation/src/VarIterator.cpp
new file mode 100644
index 00000000000..d816c23c4a1
--- /dev/null
+++ b/base/poco/Foundation/src/VarIterator.cpp
@@ -0,0 +1,167 @@
+//
+// VarIterator.cpp
+//
+// Library: Foundation
+// Package: Dynamic
+// Module:  VarIterator
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Dynamic/VarIterator.h"
+#include "Poco/Dynamic/Var.h"
+#include "Poco/Dynamic/Struct.h"
+#undef min
+#undef max
+#include <limits>
+
+
+namespace Poco {
+namespace Dynamic {
+
+
+const std::size_t VarIterator::POSITION_END = std::numeric_limits<std::size_t>::max();
+
+
+VarIterator::VarIterator(Var* pVar, bool positionEnd): 
+	_pVar(pVar),
+	_position(positionEnd ? POSITION_END : 0)
+{
+}
+
+
+VarIterator::VarIterator(const VarIterator& other):
+	_pVar(other._pVar),
+	_position(other._position)
+{
+}
+
+
+VarIterator::~VarIterator()
+{
+}
+
+
+VarIterator& VarIterator::operator = (const VarIterator& other)
+{
+	VarIterator tmp(other);
+	swap(tmp);
+	return *this;
+}
+
+
+void VarIterator::swap(VarIterator& other)
+{
+	using std::swap;
+	
+	swap(_pVar, other._pVar);
+	swap(_position, other._position);
+}
+
+
+void VarIterator::increment() const
+{
+	if (POSITION_END == _position)
+		throw RangeException("End of iterator reached.");
+
+	if (_position < _pVar->size() - 1)
+		++_position;
+	else
+		_position = POSITION_END;
+}
+
+
+void VarIterator::decrement() const
+{
+	if (0 == _position)
+		throw RangeException("Beginning of iterator reached.");
+	else if (POSITION_END == _position)
+		_position = _pVar->size() - 1;
+	else
+		--_position;
+}
+
+
+void VarIterator::setPosition(std::size_t pos) const
+{
+	if (_position == pos) return;
+
+	if (pos < _pVar->size())
+		_position = pos;
+	else if (pos == _pVar->size())
+		_position = POSITION_END;
+	else
+		throw RangeException("Invalid position argument.");
+}
+
+
+Var& VarIterator::operator * () const
+{
+	if (POSITION_END == _position)
+		throw InvalidAccessException("End of iterator reached.");
+
+	return _pVar->operator[](_position);
+}
+
+
+Var* VarIterator::operator -> () const
+{
+	if (POSITION_END == _position)
+		throw InvalidAccessException("End of iterator reached.");
+
+	return &_pVar->operator[](_position);
+}
+
+
+const VarIterator& VarIterator::operator ++ () const
+{
+	increment();
+	return *this;
+}
+
+
+VarIterator VarIterator::operator ++ (int) const
+{
+	VarIterator old(*this);
+	increment();
+	return old;
+}
+
+
+const VarIterator& VarIterator::operator -- () const
+{
+	decrement();
+	return *this;
+}
+
+
+VarIterator VarIterator::operator -- (int) const
+{
+	VarIterator old(*this);
+	decrement();
+	return old;
+}
+
+
+VarIterator VarIterator::operator + (std::size_t diff) const
+{
+	VarIterator ri(*this);
+	ri.setPosition(_position + diff);
+	return ri;
+}
+
+
+VarIterator VarIterator::operator - (std::size_t diff) const
+{
+	if (diff > _position) throw RangeException("Invalid position argument.");
+	VarIterator ri(*this);
+	ri.setPosition(_position - diff);
+	return ri;
+}
+
+
+} } // namespace Poco::Dynamic
diff --git a/base/poco/Foundation/src/Void.cpp b/base/poco/Foundation/src/Void.cpp
new file mode 100644
index 00000000000..7566bc00d09
--- /dev/null
+++ b/base/poco/Foundation/src/Void.cpp
@@ -0,0 +1,42 @@
+//
+// Void.cpp
+//
+// Library: Foundation
+// Package: Core
+// Module:  Void
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Void.h"
+
+
+namespace Poco {
+
+
+Void::Void()
+{
+}
+
+
+Void::Void(const Void&)
+{
+}
+
+
+Void::~Void()
+{
+}
+
+
+Void& Void::operator = (const Void&)
+{
+	return *this;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Windows1250Encoding.cpp b/base/poco/Foundation/src/Windows1250Encoding.cpp
new file mode 100644
index 00000000000..c57eb179ea9
--- /dev/null
+++ b/base/poco/Foundation/src/Windows1250Encoding.cpp
@@ -0,0 +1,196 @@
+//
+// Windows1250Encoding.cpp
+//
+// Library: Foundation
+// Package: Text
+// Module:  Windows1250Encoding
+//
+// Copyright (c) 2005-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Windows1250Encoding.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+
+
+const char* Windows1250Encoding::_names[] =
+{
+	"windows-1250",
+	"Windows-1250",
+	"cp1250",
+	"CP1250",
+	NULL
+};
+
+
+const TextEncoding::CharacterMap Windows1250Encoding::_charMap = 
+{
+	/*          00      01      02      03      04      05      06      07      08      09      0a      0b      0c      0d      0e      0f   */
+	/* 00 */	0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f, 
+	/* 10 */	0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f, 
+	/* 20 */	0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f, 
+	/* 30 */	0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f, 
+	/* 40 */	0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f, 
+	/* 50 */	0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f, 
+	/* 60 */	0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f, 
+	/* 70 */	0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f, 
+	/* 80 */	0x20ac, 0xfffe, 0x201a, 0xfffe, 0x201e, 0x2026, 0x2020, 0x2021, 0xfffe, 0x2030, 0x0160, 0x2039, 0x015a, 0x0164, 0x017d, 0x0179,
+	/* 90 */	0xfffe, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014, 0xfffe, 0x2122, 0x0161, 0x203a, 0x015b, 0x0165, 0x017e, 0x017a,
+	/* a0 */	0x00a0, 0x02c7, 0x02d8, 0x0141, 0x00a4, 0x0104, 0x00a6, 0x00a7, 0x00a8, 0x00a9, 0x015e, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x017b,
+	/* b0 */	0x00b0, 0x00b1, 0x02db, 0x0142, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00b8, 0x0105, 0x015f, 0x00bb, 0x013d, 0x02dd, 0x013e, 0x017c,
+	/* c0 */	0x0154, 0x00c1, 0x00c2, 0x0102, 0x00c4, 0x0139, 0x0106, 0x00c7, 0x010c, 0x00c9, 0x0118, 0x00cb, 0x011a, 0x00cd, 0x00ce, 0x010e,
+	/* d0 */	0x0110, 0x0143, 0x0147, 0x00d3, 0x00d4, 0x0150, 0x00d6, 0x00d7, 0x0158, 0x016e, 0x00da, 0x0170, 0x00dc, 0x00dd, 0x0162, 0x00df,
+	/* e0 */	0x0155, 0x00e1, 0x00e2, 0x0103, 0x00e4, 0x013a, 0x0107, 0x00e7, 0x010d, 0x00e9, 0x0119, 0x00eb, 0x011b, 0x00ed, 0x00ee, 0x010f,
+	/* f0 */	0x0111, 0x0144, 0x0148, 0x00f3, 0x00f4, 0x0151, 0x00f6, 0x00f7, 0x0159, 0x016f, 0x00fa, 0x0171, 0x00fc, 0x00fd, 0x0163, 0x02d9,
+};
+
+
+Windows1250Encoding::Windows1250Encoding()
+{
+}
+
+
+Windows1250Encoding::~Windows1250Encoding()
+{
+}
+
+
+const char* Windows1250Encoding::canonicalName() const
+{
+	return _names[0];
+}
+
+
+bool Windows1250Encoding::isA(const std::string& encodingName) const
+{
+	for (const char** name = _names; *name; ++name)
+	{
+		if (Poco::icompare(encodingName, *name) == 0)
+			return true;
+	}
+	return false;
+}
+
+
+const TextEncoding::CharacterMap& Windows1250Encoding::characterMap() const
+{
+	return _charMap;
+}
+
+
+int Windows1250Encoding::convert(const unsigned char* bytes) const
+{
+	return _charMap[*bytes];
+}
+
+
+int Windows1250Encoding::convert(int ch, unsigned char* bytes, int length) const
+{
+	if (ch >= 0 && ch <= 255 && _charMap[ch] == ch)
+	{
+		if (bytes && length >= 1)
+			*bytes = (unsigned char) ch;
+		return 1;
+	}
+	else switch(ch)
+	{
+	case 0x20ac: if (bytes && length >= 1) *bytes = 0x80; return 1;
+	case 0x201a: if (bytes && length >= 1) *bytes = 0x82; return 1;
+	case 0x201e: if (bytes && length >= 1) *bytes = 0x84; return 1;
+	case 0x2026: if (bytes && length >= 1) *bytes = 0x85; return 1;
+	case 0x2020: if (bytes && length >= 1) *bytes = 0x86; return 1;
+	case 0x2021: if (bytes && length >= 1) *bytes = 0x87; return 1;
+	case 0x2030: if (bytes && length >= 1) *bytes = 0x89; return 1;
+	case 0x0160: if (bytes && length >= 1) *bytes = 0x8a; return 1;
+	case 0x2039: if (bytes && length >= 1) *bytes = 0x8b; return 1;
+	case 0x015a: if (bytes && length >= 1) *bytes = 0x8c; return 1;
+	case 0x0164: if (bytes && length >= 1) *bytes = 0x8d; return 1;
+	case 0x017d: if (bytes && length >= 1) *bytes = 0x8e; return 1;
+	case 0x0179: if (bytes && length >= 1) *bytes = 0x8f; return 1;
+	case 0x2018: if (bytes && length >= 1) *bytes = 0x91; return 1;
+	case 0x2019: if (bytes && length >= 1) *bytes = 0x92; return 1;
+	case 0x201c: if (bytes && length >= 1) *bytes = 0x93; return 1;
+	case 0x201d: if (bytes && length >= 1) *bytes = 0x94; return 1;
+	case 0x2022: if (bytes && length >= 1) *bytes = 0x95; return 1;
+	case 0x2013: if (bytes && length >= 1) *bytes = 0x96; return 1;
+	case 0x2014: if (bytes && length >= 1) *bytes = 0x97; return 1;
+	case 0x2122: if (bytes && length >= 1) *bytes = 0x99; return 1;
+	case 0x0161: if (bytes && length >= 1) *bytes = 0x9a; return 1;
+	case 0x203a: if (bytes && length >= 1) *bytes = 0x9b; return 1;
+	case 0x015b: if (bytes && length >= 1) *bytes = 0x9c; return 1;
+	case 0x0165: if (bytes && length >= 1) *bytes = 0x9d; return 1;
+	case 0x017e: if (bytes && length >= 1) *bytes = 0x9e; return 1;
+	case 0x017a: if (bytes && length >= 1) *bytes = 0x9f; return 1;
+	case 0x02c7: if (bytes && length >= 1) *bytes = 0xa1; return 1;
+	case 0x02d8: if (bytes && length >= 1) *bytes = 0xa2; return 1;
+	case 0x0141: if (bytes && length >= 1) *bytes = 0xa3; return 1;
+	case 0x0104: if (bytes && length >= 1) *bytes = 0xa5; return 1;
+	case 0x015e: if (bytes && length >= 1) *bytes = 0xaa; return 1;
+	case 0x017b: if (bytes && length >= 1) *bytes = 0xaf; return 1;
+	case 0x02db: if (bytes && length >= 1) *bytes = 0xb2; return 1;
+	case 0x0142: if (bytes && length >= 1) *bytes = 0xb3; return 1;
+	case 0x0105: if (bytes && length >= 1) *bytes = 0xb9; return 1;
+	case 0x015f: if (bytes && length >= 1) *bytes = 0xba; return 1;
+	case 0x013d: if (bytes && length >= 1) *bytes = 0xbc; return 1;
+	case 0x02dd: if (bytes && length >= 1) *bytes = 0xbd; return 1;
+	case 0x013e: if (bytes && length >= 1) *bytes = 0xbe; return 1;
+	case 0x017c: if (bytes && length >= 1) *bytes = 0xbf; return 1;
+	case 0x0154: if (bytes && length >= 1) *bytes = 0xc0; return 1;
+	case 0x0102: if (bytes && length >= 1) *bytes = 0xc3; return 1;
+	case 0x0139: if (bytes && length >= 1) *bytes = 0xc5; return 1;
+	case 0x0106: if (bytes && length >= 1) *bytes = 0xc6; return 1;
+	case 0x010c: if (bytes && length >= 1) *bytes = 0xc8; return 1;
+	case 0x0118: if (bytes && length >= 1) *bytes = 0xca; return 1;
+	case 0x011a: if (bytes && length >= 1) *bytes = 0xcc; return 1;
+	case 0x010e: if (bytes && length >= 1) *bytes = 0xcf; return 1;
+	case 0x0110: if (bytes && length >= 1) *bytes = 0xd0; return 1;
+	case 0x0143: if (bytes && length >= 1) *bytes = 0xd1; return 1;
+	case 0x0147: if (bytes && length >= 1) *bytes = 0xd2; return 1;
+	case 0x0150: if (bytes && length >= 1) *bytes = 0xd5; return 1;
+	case 0x0158: if (bytes && length >= 1) *bytes = 0xd8; return 1;
+	case 0x016e: if (bytes && length >= 1) *bytes = 0xd9; return 1;
+	case 0x0170: if (bytes && length >= 1) *bytes = 0xdb; return 1;
+	case 0x0162: if (bytes && length >= 1) *bytes = 0xde; return 1;
+	case 0x0155: if (bytes && length >= 1) *bytes = 0xe0; return 1;
+	case 0x0103: if (bytes && length >= 1) *bytes = 0xe3; return 1;
+	case 0x013a: if (bytes && length >= 1) *bytes = 0xe5; return 1;
+	case 0x0107: if (bytes && length >= 1) *bytes = 0xe6; return 1;
+	case 0x010d: if (bytes && length >= 1) *bytes = 0xe8; return 1;
+	case 0x0119: if (bytes && length >= 1) *bytes = 0xea; return 1;
+	case 0x011b: if (bytes && length >= 1) *bytes = 0xec; return 1;
+	case 0x010f: if (bytes && length >= 1) *bytes = 0xef; return 1;
+	case 0x0111: if (bytes && length >= 1) *bytes = 0xf0; return 1;
+	case 0x0144: if (bytes && length >= 1) *bytes = 0xf1; return 1;
+	case 0x0148: if (bytes && length >= 1) *bytes = 0xf2; return 1;
+	case 0x0151: if (bytes && length >= 1) *bytes = 0xf5; return 1;
+	case 0x0159: if (bytes && length >= 1) *bytes = 0xf8; return 1;
+	case 0x016f: if (bytes && length >= 1) *bytes = 0xf9; return 1;
+	case 0x0171: if (bytes && length >= 1) *bytes = 0xfb; return 1;
+	case 0x0163: if (bytes && length >= 1) *bytes = 0xfe; return 1;
+	default: return 0;
+	}
+}
+
+
+int Windows1250Encoding::queryConvert(const unsigned char* bytes, int length) const
+{
+	if (1 <= length)
+		return _charMap[*bytes];
+	else
+		return -1;
+}
+
+
+int Windows1250Encoding::sequenceLength(const unsigned char* bytes, int length) const
+{
+	return 1;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/Windows1251Encoding.cpp b/base/poco/Foundation/src/Windows1251Encoding.cpp
new file mode 100644
index 00000000000..91f1d23a859
--- /dev/null
+++ b/base/poco/Foundation/src/Windows1251Encoding.cpp
@@ -0,0 +1,237 @@
+//
+// Windows1251Encoding.cpp
+//
+// Library: Foundation
+// Package: Text
+// Module:  Windows1251Encoding
+//
+// Copyright (c) 2005-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Windows1251Encoding.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+
+
+const char* Windows1251Encoding::_names[] =
+{
+	"windows-1251",
+	"Windows-1251",
+	"cp1251",
+	"CP1251",
+	NULL
+};
+
+
+const TextEncoding::CharacterMap Windows1251Encoding::_charMap =
+{
+	/*          00      01      02      03      04      05      06      07      08      09      0a      0b      0c      0d      0e      0f   */
+	/* 00 */	0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f, 
+	/* 10 */	0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f, 
+	/* 20 */	0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f, 
+	/* 30 */	0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f, 
+	/* 40 */	0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f, 
+	/* 50 */	0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f, 
+	/* 60 */	0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f, 
+	/* 70 */	0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f, 
+	/* 80 */	0x0402, 0x0403, 0x201a, 0x0453, 0x201e, 0x2026, 0x2020, 0x2021, 0x20ac, 0x2030, 0x0409, 0x2039, 0x040a, 0x040c, 0x040b, 0x040f,
+	/* 90 */	0x0452, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014, 0xfffe, 0x2122, 0x0459, 0x203a, 0x045a, 0x045c, 0x045b, 0x045f,
+	/* a0 */	0x00a0, 0x040e, 0x045e, 0x0408, 0x00a4, 0x0490, 0x00a6, 0x00a7, 0x0401, 0x00a9, 0x0404, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x0407,
+	/* b0 */	0x00b0, 0x00b1, 0x0406, 0x0456, 0x0491, 0x00b5, 0x00b6, 0x00b7, 0x0451, 0x2116, 0x0454, 0x00bb, 0x0458, 0x0405, 0x0455, 0x0457,
+	/* c0 */	0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041a, 0x041b, 0x041c, 0x041d, 0x041e, 0x041f,
+	/* d0 */	0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042a, 0x042b, 0x042c, 0x042d, 0x042e, 0x042f,
+	/* e0 */	0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043a, 0x043b, 0x043c, 0x043d, 0x043e, 0x043f,
+	/* f0 */	0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044a, 0x044b, 0x044c, 0x044d, 0x044e, 0x044f,
+};
+
+
+Windows1251Encoding::Windows1251Encoding()
+{
+}
+
+
+Windows1251Encoding::~Windows1251Encoding()
+{
+}
+
+
+const char* Windows1251Encoding::canonicalName() const
+{
+	return _names[0];
+}
+
+
+bool Windows1251Encoding::isA(const std::string& encodingName) const
+{
+	for (const char** name = _names; *name; ++name)
+	{
+		if (Poco::icompare(encodingName, *name) == 0)
+			return true;
+	}
+	return false;
+}
+
+
+const TextEncoding::CharacterMap& Windows1251Encoding::characterMap() const
+{
+	return _charMap;
+}
+
+
+int Windows1251Encoding::convert(const unsigned char* bytes) const
+{
+	return _charMap[*bytes];
+}
+
+
+int Windows1251Encoding::convert(int ch, unsigned char* bytes, int length) const
+{
+	if (ch >= 0 && ch <= 255 && _charMap[ch] == ch)
+	{
+		if (bytes && length >= 1)
+			*bytes = (unsigned char) ch;
+		return 1;
+	}
+	else switch(ch)
+	{
+	case 0x0402: if (bytes && length >= 1) *bytes = 0x80; return 1;
+	case 0x0403: if (bytes && length >= 1) *bytes = 0x81; return 1;
+	case 0x201a: if (bytes && length >= 1) *bytes = 0x82; return 1;
+	case 0x0453: if (bytes && length >= 1) *bytes = 0x83; return 1;
+	case 0x201e: if (bytes && length >= 1) *bytes = 0x84; return 1;
+	case 0x2026: if (bytes && length >= 1) *bytes = 0x85; return 1;
+	case 0x2020: if (bytes && length >= 1) *bytes = 0x86; return 1;
+	case 0x2021: if (bytes && length >= 1) *bytes = 0x87; return 1;
+	case 0x20ac: if (bytes && length >= 1) *bytes = 0x88; return 1;
+	case 0x2030: if (bytes && length >= 1) *bytes = 0x89; return 1;
+	case 0x0409: if (bytes && length >= 1) *bytes = 0x8a; return 1;
+	case 0x2039: if (bytes && length >= 1) *bytes = 0x8b; return 1;
+	case 0x040a: if (bytes && length >= 1) *bytes = 0x8c; return 1;
+	case 0x040c: if (bytes && length >= 1) *bytes = 0x8d; return 1;
+	case 0x040b: if (bytes && length >= 1) *bytes = 0x8e; return 1;
+	case 0x040f: if (bytes && length >= 1) *bytes = 0x8f; return 1;
+	case 0x0452: if (bytes && length >= 1) *bytes = 0x90; return 1;
+	case 0x2018: if (bytes && length >= 1) *bytes = 0x91; return 1;
+	case 0x2019: if (bytes && length >= 1) *bytes = 0x92; return 1;
+	case 0x201c: if (bytes && length >= 1) *bytes = 0x93; return 1;
+	case 0x201d: if (bytes && length >= 1) *bytes = 0x94; return 1;
+	case 0x2022: if (bytes && length >= 1) *bytes = 0x95; return 1;
+	case 0x2013: if (bytes && length >= 1) *bytes = 0x96; return 1;
+	case 0x2014: if (bytes && length >= 1) *bytes = 0x97; return 1;
+	case 0xfffe: if (bytes && length >= 1) *bytes = 0x98; return 1;
+	case 0x2122: if (bytes && length >= 1) *bytes = 0x99; return 1;
+	case 0x0459: if (bytes && length >= 1) *bytes = 0x9a; return 1;
+	case 0x203a: if (bytes && length >= 1) *bytes = 0x9b; return 1;
+	case 0x045a: if (bytes && length >= 1) *bytes = 0x9c; return 1;
+	case 0x045c: if (bytes && length >= 1) *bytes = 0x9d; return 1;
+	case 0x045b: if (bytes && length >= 1) *bytes = 0x9e; return 1;
+	case 0x045f: if (bytes && length >= 1) *bytes = 0x9f; return 1;
+	case 0x040e: if (bytes && length >= 1) *bytes = 0xa1; return 1;
+	case 0x045e: if (bytes && length >= 1) *bytes = 0xa2; return 1;
+	case 0x0408: if (bytes && length >= 1) *bytes = 0xa3; return 1;
+	case 0x0490: if (bytes && length >= 1) *bytes = 0xa5; return 1;
+	case 0x0401: if (bytes && length >= 1) *bytes = 0xa8; return 1;
+	case 0x0404: if (bytes && length >= 1) *bytes = 0xaa; return 1;
+	case 0x0407: if (bytes && length >= 1) *bytes = 0xaf; return 1;
+	case 0x0406: if (bytes && length >= 1) *bytes = 0xb2; return 1;
+	case 0x0456: if (bytes && length >= 1) *bytes = 0xb3; return 1;
+	case 0x0491: if (bytes && length >= 1) *bytes = 0xb4; return 1;
+	case 0x0451: if (bytes && length >= 1) *bytes = 0xb8; return 1;
+	case 0x2116: if (bytes && length >= 1) *bytes = 0xb9; return 1;
+	case 0x0454: if (bytes && length >= 1) *bytes = 0xba; return 1;
+	case 0x0458: if (bytes && length >= 1) *bytes = 0xbc; return 1;
+	case 0x0405: if (bytes && length >= 1) *bytes = 0xbd; return 1;
+	case 0x0455: if (bytes && length >= 1) *bytes = 0xbe; return 1;
+	case 0x0457: if (bytes && length >= 1) *bytes = 0xbf; return 1;
+	case 0x0410: if (bytes && length >= 1) *bytes = 0xc0; return 1;
+	case 0x0411: if (bytes && length >= 1) *bytes = 0xc1; return 1;
+	case 0x0412: if (bytes && length >= 1) *bytes = 0xc2; return 1;
+	case 0x0413: if (bytes && length >= 1) *bytes = 0xc3; return 1;
+	case 0x0414: if (bytes && length >= 1) *bytes = 0xc4; return 1;
+	case 0x0415: if (bytes && length >= 1) *bytes = 0xc5; return 1;
+	case 0x0416: if (bytes && length >= 1) *bytes = 0xc6; return 1;
+	case 0x0417: if (bytes && length >= 1) *bytes = 0xc7; return 1;
+	case 0x0418: if (bytes && length >= 1) *bytes = 0xc8; return 1;
+	case 0x0419: if (bytes && length >= 1) *bytes = 0xc9; return 1;
+	case 0x041a: if (bytes && length >= 1) *bytes = 0xca; return 1;
+	case 0x041b: if (bytes && length >= 1) *bytes = 0xcb; return 1;
+	case 0x041c: if (bytes && length >= 1) *bytes = 0xcc; return 1;
+	case 0x041d: if (bytes && length >= 1) *bytes = 0xcd; return 1;
+	case 0x041e: if (bytes && length >= 1) *bytes = 0xce; return 1;
+	case 0x041f: if (bytes && length >= 1) *bytes = 0xcf; return 1;
+	case 0x0420: if (bytes && length >= 1) *bytes = 0xd0; return 1;
+	case 0x0421: if (bytes && length >= 1) *bytes = 0xd1; return 1;
+	case 0x0422: if (bytes && length >= 1) *bytes = 0xd2; return 1;
+	case 0x0423: if (bytes && length >= 1) *bytes = 0xd3; return 1;
+	case 0x0424: if (bytes && length >= 1) *bytes = 0xd4; return 1;
+	case 0x0425: if (bytes && length >= 1) *bytes = 0xd5; return 1;
+	case 0x0426: if (bytes && length >= 1) *bytes = 0xd6; return 1;
+	case 0x0427: if (bytes && length >= 1) *bytes = 0xd7; return 1;
+	case 0x0428: if (bytes && length >= 1) *bytes = 0xd8; return 1;
+	case 0x0429: if (bytes && length >= 1) *bytes = 0xd9; return 1;
+	case 0x042a: if (bytes && length >= 1) *bytes = 0xda; return 1;
+	case 0x042b: if (bytes && length >= 1) *bytes = 0xdb; return 1;
+	case 0x042c: if (bytes && length >= 1) *bytes = 0xdc; return 1;
+	case 0x042d: if (bytes && length >= 1) *bytes = 0xdd; return 1;
+	case 0x042e: if (bytes && length >= 1) *bytes = 0xde; return 1;
+	case 0x042f: if (bytes && length >= 1) *bytes = 0xdf; return 1;
+	case 0x0430: if (bytes && length >= 1) *bytes = 0xe0; return 1;
+	case 0x0431: if (bytes && length >= 1) *bytes = 0xe1; return 1;
+	case 0x0432: if (bytes && length >= 1) *bytes = 0xe2; return 1;
+	case 0x0433: if (bytes && length >= 1) *bytes = 0xe3; return 1;
+	case 0x0434: if (bytes && length >= 1) *bytes = 0xe4; return 1;
+	case 0x0435: if (bytes && length >= 1) *bytes = 0xe5; return 1;
+	case 0x0436: if (bytes && length >= 1) *bytes = 0xe6; return 1;
+	case 0x0437: if (bytes && length >= 1) *bytes = 0xe7; return 1;
+	case 0x0438: if (bytes && length >= 1) *bytes = 0xe8; return 1;
+	case 0x0439: if (bytes && length >= 1) *bytes = 0xe9; return 1;
+	case 0x043a: if (bytes && length >= 1) *bytes = 0xea; return 1;
+	case 0x043b: if (bytes && length >= 1) *bytes = 0xeb; return 1;
+	case 0x043c: if (bytes && length >= 1) *bytes = 0xec; return 1;
+	case 0x043d: if (bytes && length >= 1) *bytes = 0xed; return 1;
+	case 0x043e: if (bytes && length >= 1) *bytes = 0xee; return 1;
+	case 0x043f: if (bytes && length >= 1) *bytes = 0xef; return 1;
+	case 0x0440: if (bytes && length >= 1) *bytes = 0xf0; return 1;
+	case 0x0441: if (bytes && length >= 1) *bytes = 0xf1; return 1;
+	case 0x0442: if (bytes && length >= 1) *bytes = 0xf2; return 1;
+	case 0x0443: if (bytes && length >= 1) *bytes = 0xf3; return 1;
+	case 0x0444: if (bytes && length >= 1) *bytes = 0xf4; return 1;
+	case 0x0445: if (bytes && length >= 1) *bytes = 0xf5; return 1;
+	case 0x0446: if (bytes && length >= 1) *bytes = 0xf6; return 1;
+	case 0x0447: if (bytes && length >= 1) *bytes = 0xf7; return 1;
+	case 0x0448: if (bytes && length >= 1) *bytes = 0xf8; return 1;
+	case 0x0449: if (bytes && length >= 1) *bytes = 0xf9; return 1;
+	case 0x044a: if (bytes && length >= 1) *bytes = 0xfa; return 1;
+	case 0x044b: if (bytes && length >= 1) *bytes = 0xfb; return 1;
+	case 0x044c: if (bytes && length >= 1) *bytes = 0xfc; return 1;
+	case 0x044d: if (bytes && length >= 1) *bytes = 0xfd; return 1;
+	case 0x044e: if (bytes && length >= 1) *bytes = 0xfe; return 1;
+	case 0x044f: if (bytes && length >= 1) *bytes = 0xff; return 1;
+	default: return 0;
+	}
+}
+
+
+int Windows1251Encoding::queryConvert(const unsigned char* bytes, int length) const
+{
+	if (1 <= length)
+		return _charMap[*bytes];
+	else
+		return -1;
+}
+
+
+int Windows1251Encoding::sequenceLength(const unsigned char* bytes, int length) const
+{
+	return 1;
+}
+
+
+} // namespace Poco
+
diff --git a/base/poco/Foundation/src/Windows1252Encoding.cpp b/base/poco/Foundation/src/Windows1252Encoding.cpp
new file mode 100644
index 00000000000..b73a19dd90d
--- /dev/null
+++ b/base/poco/Foundation/src/Windows1252Encoding.cpp
@@ -0,0 +1,151 @@
+//
+// Windows1252Encoding.cpp
+//
+// Library: Foundation
+// Package: Text
+// Module:  Windows1252Encoding
+//
+// Copyright (c) 2005-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Windows1252Encoding.h"
+#include "Poco/String.h"
+#include <map>
+
+
+namespace Poco {
+
+
+const char* Windows1252Encoding::_names[] =
+{
+	"windows-1252",
+	"Windows-1252",
+	"cp1252",
+	"CP1252",
+	NULL
+};
+
+
+const TextEncoding::CharacterMap Windows1252Encoding::_charMap = 
+{
+	/*          00      01      02      03      04      05      06      07      08      09      0a      0b      0c      0d      0e      0f   */
+	/* 00 */	0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008, 0x0009, 0x000a, 0x000b, 0x000c, 0x000d, 0x000e, 0x000f, 
+	/* 10 */	0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017, 0x0018, 0x0019, 0x001a, 0x001b, 0x001c, 0x001d, 0x001e, 0x001f, 
+	/* 20 */	0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f, 
+	/* 30 */	0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f, 
+	/* 40 */	0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f, 
+	/* 50 */	0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005a, 0x005b, 0x005c, 0x005d, 0x005e, 0x005f, 
+	/* 60 */	0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f, 
+	/* 70 */	0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x007f, 
+	/* 80 */	0x20ac, 0x0081, 0x201a, 0x0192, 0x201e, 0x2026, 0x2020, 0x2021, 0x02c6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008d, 0x017d, 0x008f, 
+	/* 90 */	0x0090, 0x2018, 0x2019, 0x201c, 0x201d, 0x2022, 0x2013, 0x2014, 0x02dc, 0x2122, 0x0161, 0x203a, 0x0153, 0x009d, 0x017e, 0x0178, 
+	/* a0 */	0x00a0, 0x00a1, 0x00a2, 0x00a3, 0x00a4, 0x00a5, 0x00a6, 0x00a7, 0x00a8, 0x00a9, 0x00aa, 0x00ab, 0x00ac, 0x00ad, 0x00ae, 0x00af, 
+	/* b0 */	0x00b0, 0x00b1, 0x00b2, 0x00b3, 0x00b4, 0x00b5, 0x00b6, 0x00b7, 0x00b8, 0x00b9, 0x00ba, 0x00bb, 0x00bc, 0x00bd, 0x00be, 0x00bf, 
+	/* c0 */	0x00c0, 0x00c1, 0x00c2, 0x00c3, 0x00c4, 0x00c5, 0x00c6, 0x00c7, 0x00c8, 0x00c9, 0x00ca, 0x00cb, 0x00cc, 0x00cd, 0x00ce, 0x00cf, 
+	/* d0 */	0x00d0, 0x00d1, 0x00d2, 0x00d3, 0x00d4, 0x00d5, 0x00d6, 0x00d7, 0x00d8, 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df, 
+	/* e0 */	0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 
+	/* f0 */	0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff, 
+};
+
+
+Windows1252Encoding::Windows1252Encoding()
+{
+}
+
+
+Windows1252Encoding::~Windows1252Encoding()
+{
+}
+
+
+const char* Windows1252Encoding::canonicalName() const
+{
+	return _names[0];
+}
+
+
+bool Windows1252Encoding::isA(const std::string& encodingName) const
+{
+	for (const char** name = _names; *name; ++name)
+	{
+		if (Poco::icompare(encodingName, *name) == 0)
+			return true;
+	}
+	return false;
+}
+
+
+const TextEncoding::CharacterMap& Windows1252Encoding::characterMap() const
+{
+	return _charMap;
+}
+
+
+int Windows1252Encoding::convert(const unsigned char* bytes) const
+{
+	return _charMap[*bytes];
+}
+
+
+int Windows1252Encoding::convert(int ch, unsigned char* bytes, int length) const
+{
+	if (ch >= 0 && ch <= 255 && _charMap[ch] == ch)
+	{
+		if (bytes && length >= 1)
+			*bytes = ch;
+		return 1;
+	}
+	else switch (ch)
+	{
+	case 0x20ac: if (bytes && length >= 1) *bytes = 0x80; return 1;
+	case 0x201a: if (bytes && length >= 1) *bytes = 0x82; return 1;
+	case 0x0192: if (bytes && length >= 1) *bytes = 0x83; return 1;
+	case 0x201e: if (bytes && length >= 1) *bytes = 0x84; return 1;
+	case 0x2026: if (bytes && length >= 1) *bytes = 0x85; return 1;
+	case 0x2020: if (bytes && length >= 1) *bytes = 0x86; return 1;
+	case 0x2021: if (bytes && length >= 1) *bytes = 0x87; return 1;
+	case 0x02c6: if (bytes && length >= 1) *bytes = 0x88; return 1;
+	case 0x2030: if (bytes && length >= 1) *bytes = 0x89; return 1;
+	case 0x0160: if (bytes && length >= 1) *bytes = 0x8a; return 1;
+	case 0x2039: if (bytes && length >= 1) *bytes = 0x8b; return 1;
+	case 0x0152: if (bytes && length >= 1) *bytes = 0x8c; return 1;
+	case 0x017d: if (bytes && length >= 1) *bytes = 0x8e; return 1;
+	case 0x2018: if (bytes && length >= 1) *bytes = 0x91; return 1;
+	case 0x2019: if (bytes && length >= 1) *bytes = 0x92; return 1;
+	case 0x201c: if (bytes && length >= 1) *bytes = 0x93; return 1;
+	case 0x201d: if (bytes && length >= 1) *bytes = 0x94; return 1;
+	case 0x2022: if (bytes && length >= 1) *bytes = 0x95; return 1;
+	case 0x2013: if (bytes && length >= 1) *bytes = 0x96; return 1;
+	case 0x2014: if (bytes && length >= 1) *bytes = 0x97; return 1;
+	case 0x02dc: if (bytes && length >= 1) *bytes = 0x98; return 1;
+	case 0x2122: if (bytes && length >= 1) *bytes = 0x99; return 1;
+	case 0x0161: if (bytes && length >= 1) *bytes = 0x9a; return 1;
+	case 0x203a: if (bytes && length >= 1) *bytes = 0x9b; return 1;
+	case 0x0153: if (bytes && length >= 1) *bytes = 0x9c; return 1;
+	case 0x017e: if (bytes && length >= 1) *bytes = 0x9e; return 1;
+	case 0x0178: if (bytes && length >= 1) *bytes = 0x9f; return 1;
+	default: return 0;
+	}
+}
+
+
+int Windows1252Encoding::queryConvert(const unsigned char* bytes, int length) const
+{
+	if (1 <= length)
+		return _charMap[*bytes];
+	else
+		return -1;
+}
+
+
+int Windows1252Encoding::sequenceLength(const unsigned char* bytes, int length) const
+{
+	return 1;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/WindowsConsoleChannel.cpp b/base/poco/Foundation/src/WindowsConsoleChannel.cpp
new file mode 100644
index 00000000000..07e352935f2
--- /dev/null
+++ b/base/poco/Foundation/src/WindowsConsoleChannel.cpp
@@ -0,0 +1,302 @@
+//
+// WindowsConsoleChannel.cpp
+//
+// Library: Foundation
+// Package: Logging
+// Module:  WindowsConsoleChannel
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/WindowsConsoleChannel.h"
+#include "Poco/Message.h"
+#if defined(POCO_WIN32_UTF8)
+#include "Poco/UnicodeConverter.h"
+#endif
+#include "Poco/String.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+
+
+WindowsConsoleChannel::WindowsConsoleChannel():
+	_isFile(false),
+	_hConsole(INVALID_HANDLE_VALUE)
+{
+	_hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+	// check whether the console has been redirected
+	DWORD mode;	
+	_isFile = (GetConsoleMode(_hConsole, &mode) == 0);
+}
+
+
+WindowsConsoleChannel::~WindowsConsoleChannel()
+{
+}
+
+
+void WindowsConsoleChannel::log(const Message& msg)
+{
+	std::string text = msg.getText();
+	text += "\r\n";
+	
+#if defined(POCO_WIN32_UTF8)
+	if (_isFile)
+	{
+		DWORD written;
+		WriteFile(_hConsole, text.data(), static_cast<DWORD>(text.size()), &written, NULL);	
+	}
+	else
+	{
+		std::wstring utext;
+		UnicodeConverter::toUTF16(text, utext);
+		DWORD written;
+		WriteConsoleW(_hConsole, utext.data(), static_cast<DWORD>(utext.size()), &written, NULL);
+	}
+#else
+	DWORD written;
+	WriteFile(_hConsole, text.data(), text.size(), &written, NULL);	
+#endif
+}
+
+
+WindowsColorConsoleChannel::WindowsColorConsoleChannel():
+	_enableColors(true),
+	_isFile(false),
+	_hConsole(INVALID_HANDLE_VALUE)
+{
+	_hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+	// check whether the console has been redirected
+	DWORD mode;	
+	_isFile = (GetConsoleMode(_hConsole, &mode) == 0);
+	initColors();
+}
+
+
+WindowsColorConsoleChannel::~WindowsColorConsoleChannel()
+{
+}
+
+
+void WindowsColorConsoleChannel::log(const Message& msg)
+{
+	std::string text = msg.getText();
+	text += "\r\n";
+
+	if (_enableColors && !_isFile)
+	{
+		WORD attr = _colors[0];
+		attr &= 0xFFF0;
+		attr |= _colors[msg.getPriority()];
+		SetConsoleTextAttribute(_hConsole, attr);
+	}
+
+#if defined(POCO_WIN32_UTF8)
+	if (_isFile)
+	{
+		DWORD written;
+		WriteFile(_hConsole, text.data(), static_cast<DWORD>(text.size()), &written, NULL);	
+	}
+	else
+	{
+		std::wstring utext;
+		UnicodeConverter::toUTF16(text, utext);
+		DWORD written;
+		WriteConsoleW(_hConsole, utext.data(), static_cast<DWORD>(utext.size()), &written, NULL);
+	}
+#else
+	DWORD written;
+	WriteFile(_hConsole, text.data(), text.size(), &written, NULL);	
+#endif
+
+	if (_enableColors && !_isFile)
+	{
+		SetConsoleTextAttribute(_hConsole, _colors[0]);
+	}
+}
+
+
+void WindowsColorConsoleChannel::setProperty(const std::string& name, const std::string& value)
+{
+	if (name == "enableColors")
+	{
+		_enableColors = icompare(value, "true") == 0;
+	}
+	else if (name == "traceColor")
+	{
+		_colors[Message::PRIO_TRACE] = parseColor(value);
+	}
+	else if (name == "debugColor")
+	{
+		_colors[Message::PRIO_DEBUG] = parseColor(value);
+	}
+	else if (name == "informationColor")
+	{
+		_colors[Message::PRIO_INFORMATION] = parseColor(value);
+	}
+	else if (name == "noticeColor")
+	{
+		_colors[Message::PRIO_NOTICE] = parseColor(value);
+	}
+	else if (name == "warningColor")
+	{
+		_colors[Message::PRIO_WARNING] = parseColor(value);
+	}
+	else if (name == "errorColor")
+	{
+		_colors[Message::PRIO_ERROR] = parseColor(value);
+	}
+	else if (name == "criticalColor")
+	{
+		_colors[Message::PRIO_CRITICAL] = parseColor(value);
+	}
+	else if (name == "fatalColor")
+	{
+		_colors[Message::PRIO_FATAL] = parseColor(value);
+	}
+	else
+	{
+		Channel::setProperty(name, value);
+	}
+}
+
+
+std::string WindowsColorConsoleChannel::getProperty(const std::string& name) const
+{
+	if (name == "enableColors")
+	{
+		return _enableColors ? "true" : "false";
+	}
+	else if (name == "traceColor")
+	{
+		return formatColor(_colors[Message::PRIO_TRACE]);
+	}
+	else if (name == "debugColor")
+	{
+		return formatColor(_colors[Message::PRIO_DEBUG]);
+	}
+	else if (name == "informationColor")
+	{
+		return formatColor(_colors[Message::PRIO_INFORMATION]);
+	}
+	else if (name == "noticeColor")
+	{
+		return formatColor(_colors[Message::PRIO_NOTICE]);
+	}
+	else if (name == "warningColor")
+	{
+		return formatColor(_colors[Message::PRIO_WARNING]);
+	}
+	else if (name == "errorColor")
+	{
+		return formatColor(_colors[Message::PRIO_ERROR]);
+	}
+	else if (name == "criticalColor")
+	{
+		return formatColor(_colors[Message::PRIO_CRITICAL]);
+	}
+	else if (name == "fatalColor")
+	{
+		return formatColor(_colors[Message::PRIO_FATAL]);
+	}
+	else
+	{
+		return Channel::getProperty(name);
+	}
+}
+
+
+WORD WindowsColorConsoleChannel::parseColor(const std::string& color) const
+{
+	if (icompare(color, "default") == 0)
+		return _colors[0];
+	else if (icompare(color, "black") == 0)
+		return CC_BLACK;
+	else if (icompare(color, "red") == 0)
+		return CC_RED;
+	else if (icompare(color, "green") == 0)
+		return CC_GREEN;
+	else if (icompare(color, "brown") == 0)
+		return CC_BROWN;
+	else if (icompare(color, "blue") == 0)
+		return CC_BLUE;
+	else if (icompare(color, "magenta") == 0)
+		return CC_MAGENTA;
+	else if (icompare(color, "cyan") == 0)
+		return CC_CYAN;
+	else if (icompare(color, "gray") == 0)
+		return CC_GRAY;
+	else if (icompare(color, "darkGray") == 0)
+		return CC_DARKGRAY;
+	else if (icompare(color, "lightRed") == 0)
+		return CC_LIGHTRED;
+	else if (icompare(color, "lightGreen") == 0)
+		return CC_LIGHTGREEN;
+	else if (icompare(color, "yellow") == 0)
+		return CC_YELLOW;
+	else if (icompare(color, "lightBlue") == 0)
+		return CC_LIGHTBLUE;
+	else if (icompare(color, "lightMagenta") == 0)
+		return CC_LIGHTMAGENTA;
+	else if (icompare(color, "lightCyan") == 0)
+		return CC_LIGHTCYAN;
+	else if (icompare(color, "white") == 0)
+		return CC_WHITE;
+	else throw InvalidArgumentException("Invalid color value", color);
+}
+
+
+std::string WindowsColorConsoleChannel::formatColor(WORD color) const
+{
+	switch (color)
+	{
+	case CC_BLACK:        return "black";
+	case CC_RED:          return "red";
+	case CC_GREEN:        return "green";
+	case CC_BROWN:        return "brown";
+	case CC_BLUE:         return "blue";
+	case CC_MAGENTA:      return "magenta";
+	case CC_CYAN:         return "cyan";
+	case CC_GRAY:         return "gray";
+	case CC_DARKGRAY:     return "darkGray";
+	case CC_LIGHTRED:     return "lightRed";
+	case CC_LIGHTGREEN:   return "lightGreen";
+	case CC_YELLOW:       return "yellow";
+	case CC_LIGHTBLUE:    return "lightBlue";
+	case CC_LIGHTMAGENTA: return "lightMagenta";
+	case CC_LIGHTCYAN:    return "lightCyan";
+	case CC_WHITE:        return "white";
+	default:              return "invalid";
+	}
+}
+
+
+void WindowsColorConsoleChannel::initColors()
+{
+	if (!_isFile)
+	{
+		CONSOLE_SCREEN_BUFFER_INFO csbi;
+		GetConsoleScreenBufferInfo(_hConsole, &csbi);
+		_colors[0] = csbi.wAttributes;
+	}
+	else
+	{
+		_colors[0] = CC_WHITE;
+	}
+	_colors[Message::PRIO_FATAL]       = CC_LIGHTRED;
+	_colors[Message::PRIO_CRITICAL]    = CC_LIGHTRED;
+	_colors[Message::PRIO_ERROR]       = CC_LIGHTRED;
+	_colors[Message::PRIO_WARNING]     = CC_YELLOW;
+	_colors[Message::PRIO_NOTICE]      = _colors[0];
+	_colors[Message::PRIO_INFORMATION] = _colors[0];
+	_colors[Message::PRIO_DEBUG]       = CC_GRAY;
+	_colors[Message::PRIO_TRACE]       = CC_GRAY;
+}
+
+
+} // namespace Poco
diff --git a/base/poco/Foundation/src/adler32.c b/base/poco/Foundation/src/adler32.c
new file mode 100644
index 00000000000..8fa49192ada
--- /dev/null
+++ b/base/poco/Foundation/src/adler32.c
@@ -0,0 +1,188 @@
+/* adler32.c -- compute the Adler-32 checksum of a data stream
+ * Copyright (C) 1995-2011, 2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#include "zutil.h"
+
+#define local static
+
+local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
+
+#define BASE 65521U     /* largest prime smaller than 65536 */
+#define NMAX 5552
+/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
+
+#define DO1(buf,i)  {adler += (buf)[i]; sum2 += adler;}
+#define DO2(buf,i)  DO1(buf,i); DO1(buf,i+1);
+#define DO4(buf,i)  DO2(buf,i); DO2(buf,i+2);
+#define DO8(buf,i)  DO4(buf,i); DO4(buf,i+4);
+#define DO16(buf)   DO8(buf,0); DO8(buf,8);
+
+/* use NO_DIVIDE if your processor does not do division in hardware --
+   try it both ways to see which is faster */
+#ifdef NO_DIVIDE
+/* note that this assumes BASE is 65521, where 65536 % 65521 == 15
+   (thank you to John Reiser for pointing this out) */
+#  define CHOP(a) \
+    do { \
+        unsigned long tmp = a >> 16; \
+        a &= 0xffffUL; \
+        a += (tmp << 4) - tmp; \
+    } while (0)
+#  define MOD28(a) \
+    do { \
+        CHOP(a); \
+        if (a >= BASE) a -= BASE; \
+    } while (0)
+#  define MOD(a) \
+    do { \
+        CHOP(a); \
+        MOD28(a); \
+    } while (0)
+#  define MOD63(a) \
+    do { /* this assumes a is not negative */ \
+        z_off64_t tmp = a >> 32; \
+        a &= 0xffffffffL; \
+        a += (tmp << 8) - (tmp << 5) + tmp; \
+        tmp = a >> 16; \
+        a &= 0xffffL; \
+        a += (tmp << 4) - tmp; \
+        tmp = a >> 16; \
+        a &= 0xffffL; \
+        a += (tmp << 4) - tmp; \
+        if (a >= BASE) a -= BASE; \
+    } while (0)
+#else
+#  define MOD(a) a %= BASE
+#  define MOD28(a) a %= BASE
+#  define MOD63(a) a %= BASE
+#endif
+
+/* ========================================================================= */
+uLong ZEXPORT adler32_z(adler, buf, len)
+    uLong adler;
+    const Bytef *buf;
+    z_size_t len;
+{
+    unsigned long sum2;
+    unsigned n;
+
+    /* split Adler-32 into component sums */
+    sum2 = (adler >> 16) & 0xffff;
+    adler &= 0xffff;
+
+    /* in case user likes doing a byte at a time, keep it fast */
+    if (len == 1) {
+        adler += buf[0];
+        if (adler >= BASE)
+            adler -= BASE;
+        sum2 += adler;
+        if (sum2 >= BASE)
+            sum2 -= BASE;
+        return adler | (sum2 << 16);
+    }
+
+    /* initial Adler-32 value (deferred check for len == 1 speed) */
+    if (buf == Z_NULL)
+        return 1L;
+
+    /* in case short lengths are provided, keep it somewhat fast */
+    if (len < 16) {
+        while (len--) {
+            adler += *buf++;
+            sum2 += adler;
+        }
+        if (adler >= BASE)
+            adler -= BASE;
+        MOD28(sum2);            /* only added so many BASE's */
+        return adler | (sum2 << 16);
+    }
+
+    /* do length NMAX blocks -- requires just one modulo operation */
+    while (len >= NMAX) {
+        len -= NMAX;
+        n = NMAX / 16;          /* NMAX is divisible by 16 */
+        do {
+            DO16(buf);          /* 16 sums unrolled */
+            buf += 16;
+        } while (--n);
+        MOD(adler);
+        MOD(sum2);
+    }
+
+    /* do remaining bytes (less than NMAX, still just one modulo) */
+    if (len) {                  /* avoid modulos if none remaining */
+        while (len >= 16) {
+            len -= 16;
+            DO16(buf);
+            buf += 16;
+        }
+        while (len--) {
+            adler += *buf++;
+            sum2 += adler;
+        }
+        MOD(adler);
+        MOD(sum2);
+    }
+
+    /* return recombined sums */
+    return adler | (sum2 << 16);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT adler32(adler, buf, len)
+    uLong adler;
+    const Bytef *buf;
+    uInt len;
+{
+    return adler32_z(adler, buf, len);
+}
+
+/* ========================================================================= */
+local uLong adler32_combine_(adler1, adler2, len2)
+    uLong adler1;
+    uLong adler2;
+    z_off64_t len2;
+{
+    unsigned long sum1;
+    unsigned long sum2;
+    unsigned rem;
+
+    /* for negative len, return invalid adler32 as a clue for debugging */
+    if (len2 < 0)
+        return 0xffffffffUL;
+
+    /* the derivation of this formula is left as an exercise for the reader */
+    MOD63(len2);                /* assumes len2 >= 0 */
+    rem = (unsigned)len2;
+    sum1 = adler1 & 0xffff;
+    sum2 = rem * sum1;
+    MOD(sum2);
+    sum1 += (adler2 & 0xffff) + BASE - 1;
+    sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
+    if (sum1 >= BASE) sum1 -= BASE;
+    if (sum1 >= BASE) sum1 -= BASE;
+    if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1);
+    if (sum2 >= BASE) sum2 -= BASE;
+    return sum1 | (sum2 << 16);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT adler32_combine(adler1, adler2, len2)
+    uLong adler1;
+    uLong adler2;
+    z_off_t len2;
+{
+    return adler32_combine_(adler1, adler2, len2);
+}
+
+uLong ZEXPORT adler32_combine64(adler1, adler2, len2)
+    uLong adler1;
+    uLong adler2;
+    z_off64_t len2;
+{
+    return adler32_combine_(adler1, adler2, len2);
+}
diff --git a/base/poco/Foundation/src/bignum-dtoa.cc b/base/poco/Foundation/src/bignum-dtoa.cc
new file mode 100644
index 00000000000..f1ad7a5ae8d
--- /dev/null
+++ b/base/poco/Foundation/src/bignum-dtoa.cc
@@ -0,0 +1,641 @@
+// Copyright 2010 the V8 project authors. 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 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 Google Inc. 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 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
+// OWNER 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.
+
+#include <math.h>
+
+#include "bignum-dtoa.h"
+
+#include "bignum.h"
+#include "ieee.h"
+
+namespace double_conversion {
+
+static int NormalizedExponent(uint64_t significand, int exponent) {
+  ASSERT(significand != 0);
+  while ((significand & Double::kHiddenBit) == 0) {
+    significand = significand << 1;
+    exponent = exponent - 1;
+  }
+  return exponent;
+}
+
+
+// Forward declarations:
+// Returns an estimation of k such that 10^(k-1) <= v < 10^k.
+static int EstimatePower(int exponent);
+// Computes v / 10^estimated_power exactly, as a ratio of two bignums, numerator
+// and denominator.
+static void InitialScaledStartValues(uint64_t significand,
+                                     int exponent,
+                                     bool lower_boundary_is_closer,
+                                     int estimated_power,
+                                     bool need_boundary_deltas,
+                                     Bignum* numerator,
+                                     Bignum* denominator,
+                                     Bignum* delta_minus,
+                                     Bignum* delta_plus);
+// Multiplies numerator/denominator so that its values lies in the range 1-10.
+// Returns decimal_point s.t.
+//  v = numerator'/denominator' * 10^(decimal_point-1)
+//     where numerator' and denominator' are the values of numerator and
+//     denominator after the call to this function.
+static void FixupMultiply10(int estimated_power, bool is_even,
+                            int* decimal_point,
+                            Bignum* numerator, Bignum* denominator,
+                            Bignum* delta_minus, Bignum* delta_plus);
+// Generates digits from the left to the right and stops when the generated
+// digits yield the shortest decimal representation of v.
+static void GenerateShortestDigits(Bignum* numerator, Bignum* denominator,
+                                   Bignum* delta_minus, Bignum* delta_plus,
+                                   bool is_even,
+                                   Vector<char> buffer, int* length);
+// Generates 'requested_digits' after the decimal point.
+static void BignumToFixed(int requested_digits, int* decimal_point,
+                          Bignum* numerator, Bignum* denominator,
+                          Vector<char>(buffer), int* length);
+// Generates 'count' digits of numerator/denominator.
+// Once 'count' digits have been produced rounds the result depending on the
+// remainder (remainders of exactly .5 round upwards). Might update the
+// decimal_point when rounding up (for example for 0.9999).
+static void GenerateCountedDigits(int count, int* decimal_point,
+                                  Bignum* numerator, Bignum* denominator,
+                                  Vector<char>(buffer), int* length);
+
+
+void BignumDtoa(double v, BignumDtoaMode mode, int requested_digits,
+                Vector<char> buffer, int* length, int* decimal_point) {
+  ASSERT(v > 0);
+  ASSERT(!Double(v).IsSpecial());
+  uint64_t significand;
+  int exponent;
+  bool lower_boundary_is_closer;
+  if (mode == BIGNUM_DTOA_SHORTEST_SINGLE) {
+    float f = static_cast<float>(v);
+    ASSERT(f == v);
+    significand = Single(f).Significand();
+    exponent = Single(f).Exponent();
+    lower_boundary_is_closer = Single(f).LowerBoundaryIsCloser();
+  } else {
+    significand = Double(v).Significand();
+    exponent = Double(v).Exponent();
+    lower_boundary_is_closer = Double(v).LowerBoundaryIsCloser();
+  }
+  bool need_boundary_deltas =
+      (mode == BIGNUM_DTOA_SHORTEST || mode == BIGNUM_DTOA_SHORTEST_SINGLE);
+
+  bool is_even = (significand & 1) == 0;
+  int normalized_exponent = NormalizedExponent(significand, exponent);
+  // estimated_power might be too low by 1.
+  int estimated_power = EstimatePower(normalized_exponent);
+
+  // Shortcut for Fixed.
+  // The requested digits correspond to the digits after the point. If the
+  // number is much too small, then there is no need in trying to get any
+  // digits.
+  if (mode == BIGNUM_DTOA_FIXED && -estimated_power - 1 > requested_digits) {
+    buffer[0] = '\0';
+    *length = 0;
+    // Set decimal-point to -requested_digits. This is what Gay does.
+    // Note that it should not have any effect anyways since the string is
+    // empty.
+    *decimal_point = -requested_digits;
+    return;
+  }
+
+  Bignum numerator;
+  Bignum denominator;
+  Bignum delta_minus;
+  Bignum delta_plus;
+  // Make sure the bignum can grow large enough. The smallest double equals
+  // 4e-324. In this case the denominator needs fewer than 324*4 binary digits.
+  // The maximum double is 1.7976931348623157e308 which needs fewer than
+  // 308*4 binary digits.
+  ASSERT(Bignum::kMaxSignificantBits >= 324*4);
+  InitialScaledStartValues(significand, exponent, lower_boundary_is_closer,
+                           estimated_power, need_boundary_deltas,
+                           &numerator, &denominator,
+                           &delta_minus, &delta_plus);
+  // We now have v = (numerator / denominator) * 10^estimated_power.
+  FixupMultiply10(estimated_power, is_even, decimal_point,
+                  &numerator, &denominator,
+                  &delta_minus, &delta_plus);
+  // We now have v = (numerator / denominator) * 10^(decimal_point-1), and
+  //  1 <= (numerator + delta_plus) / denominator < 10
+  switch (mode) {
+    case BIGNUM_DTOA_SHORTEST:
+    case BIGNUM_DTOA_SHORTEST_SINGLE:
+      GenerateShortestDigits(&numerator, &denominator,
+                             &delta_minus, &delta_plus,
+                             is_even, buffer, length);
+      break;
+    case BIGNUM_DTOA_FIXED:
+      BignumToFixed(requested_digits, decimal_point,
+                    &numerator, &denominator,
+                    buffer, length);
+      break;
+    case BIGNUM_DTOA_PRECISION:
+      GenerateCountedDigits(requested_digits, decimal_point,
+                            &numerator, &denominator,
+                            buffer, length);
+      break;
+    default:
+      UNREACHABLE();
+  }
+  buffer[*length] = '\0';
+}
+
+
+// The procedure starts generating digits from the left to the right and stops
+// when the generated digits yield the shortest decimal representation of v. A
+// decimal representation of v is a number lying closer to v than to any other
+// double, so it converts to v when read.
+//
+// This is true if d, the decimal representation, is between m- and m+, the
+// upper and lower boundaries. d must be strictly between them if !is_even.
+//           m- := (numerator - delta_minus) / denominator
+//           m+ := (numerator + delta_plus) / denominator
+//
+// Precondition: 0 <= (numerator+delta_plus) / denominator < 10.
+//   If 1 <= (numerator+delta_plus) / denominator < 10 then no leading 0 digit
+//   will be produced. This should be the standard precondition.
+static void GenerateShortestDigits(Bignum* numerator, Bignum* denominator,
+                                   Bignum* delta_minus, Bignum* delta_plus,
+                                   bool is_even,
+                                   Vector<char> buffer, int* length) {
+  // Small optimization: if delta_minus and delta_plus are the same just reuse
+  // one of the two bignums.
+  if (Bignum::Equal(*delta_minus, *delta_plus)) {
+    delta_plus = delta_minus;
+  }
+  *length = 0;
+  for (;;) {
+    uint16_t digit;
+    digit = numerator->DivideModuloIntBignum(*denominator);
+    ASSERT(digit <= 9);  // digit is a uint16_t and therefore always positive.
+    // digit = numerator / denominator (integer division).
+    // numerator = numerator % denominator.
+    buffer[(*length)++] = static_cast<char>(digit + '0');
+
+    // Can we stop already?
+    // If the remainder of the division is less than the distance to the lower
+    // boundary we can stop. In this case we simply round down (discarding the
+    // remainder).
+    // Similarly we test if we can round up (using the upper boundary).
+    bool in_delta_room_minus;
+    bool in_delta_room_plus;
+    if (is_even) {
+      in_delta_room_minus = Bignum::LessEqual(*numerator, *delta_minus);
+    } else {
+      in_delta_room_minus = Bignum::Less(*numerator, *delta_minus);
+    }
+    if (is_even) {
+      in_delta_room_plus =
+          Bignum::PlusCompare(*numerator, *delta_plus, *denominator) >= 0;
+    } else {
+      in_delta_room_plus =
+          Bignum::PlusCompare(*numerator, *delta_plus, *denominator) > 0;
+    }
+    if (!in_delta_room_minus && !in_delta_room_plus) {
+      // Prepare for next iteration.
+      numerator->Times10();
+      delta_minus->Times10();
+      // We optimized delta_plus to be equal to delta_minus (if they share the
+      // same value). So don't multiply delta_plus if they point to the same
+      // object.
+      if (delta_minus != delta_plus) {
+        delta_plus->Times10();
+      }
+    } else if (in_delta_room_minus && in_delta_room_plus) {
+      // Let's see if 2*numerator < denominator.
+      // If yes, then the next digit would be < 5 and we can round down.
+      int compare = Bignum::PlusCompare(*numerator, *numerator, *denominator);
+      if (compare < 0) {
+        // Remaining digits are less than .5. -> Round down (== do nothing).
+      } else if (compare > 0) {
+        // Remaining digits are more than .5 of denominator. -> Round up.
+        // Note that the last digit could not be a '9' as otherwise the whole
+        // loop would have stopped earlier.
+        // We still have an assert here in case the preconditions were not
+        // satisfied.
+        ASSERT(buffer[(*length) - 1] != '9');
+        buffer[(*length) - 1]++;
+      } else {
+        // Halfway case.
+        // TODO(floitsch): need a way to solve half-way cases.
+        //   For now let's round towards even (since this is what Gay seems to
+        //   do).
+
+        if ((buffer[(*length) - 1] - '0') % 2 == 0) {
+          // Round down => Do nothing.
+        } else {
+          ASSERT(buffer[(*length) - 1] != '9');
+          buffer[(*length) - 1]++;
+        }
+      }
+      return;
+    } else if (in_delta_room_minus) {
+      // Round down (== do nothing).
+      return;
+    } else {  // in_delta_room_plus
+      // Round up.
+      // Note again that the last digit could not be '9' since this would have
+      // stopped the loop earlier.
+      // We still have an ASSERT here, in case the preconditions were not
+      // satisfied.
+      ASSERT(buffer[(*length) -1] != '9');
+      buffer[(*length) - 1]++;
+      return;
+    }
+  }
+}
+
+
+// Let v = numerator / denominator < 10.
+// Then we generate 'count' digits of d = x.xxxxx... (without the decimal point)
+// from left to right. Once 'count' digits have been produced we decide wether
+// to round up or down. Remainders of exactly .5 round upwards. Numbers such
+// as 9.999999 propagate a carry all the way, and change the
+// exponent (decimal_point), when rounding upwards.
+static void GenerateCountedDigits(int count, int* decimal_point,
+                                  Bignum* numerator, Bignum* denominator,
+                                  Vector<char> buffer, int* length) {
+  ASSERT(count >= 0);
+  for (int i = 0; i < count - 1; ++i) {
+    uint16_t digit;
+    digit = numerator->DivideModuloIntBignum(*denominator);
+    ASSERT(digit <= 9);  // digit is a uint16_t and therefore always positive.
+    // digit = numerator / denominator (integer division).
+    // numerator = numerator % denominator.
+    buffer[i] = static_cast<char>(digit + '0');
+    // Prepare for next iteration.
+    numerator->Times10();
+  }
+  // Generate the last digit.
+  uint16_t digit;
+  digit = numerator->DivideModuloIntBignum(*denominator);
+  if (Bignum::PlusCompare(*numerator, *numerator, *denominator) >= 0) {
+    digit++;
+  }
+  ASSERT(digit <= 10);
+  buffer[count - 1] = static_cast<char>(digit + '0');
+  // Correct bad digits (in case we had a sequence of '9's). Propagate the
+  // carry until we hat a non-'9' or til we reach the first digit.
+  for (int i = count - 1; i > 0; --i) {
+    if (buffer[i] != '0' + 10) break;
+    buffer[i] = '0';
+    buffer[i - 1]++;
+  }
+  if (buffer[0] == '0' + 10) {
+    // Propagate a carry past the top place.
+    buffer[0] = '1';
+    (*decimal_point)++;
+  }
+  *length = count;
+}
+
+
+// Generates 'requested_digits' after the decimal point. It might omit
+// trailing '0's. If the input number is too small then no digits at all are
+// generated (ex.: 2 fixed digits for 0.00001).
+//
+// Input verifies:  1 <= (numerator + delta) / denominator < 10.
+static void BignumToFixed(int requested_digits, int* decimal_point,
+                          Bignum* numerator, Bignum* denominator,
+                          Vector<char>(buffer), int* length) {
+  // Note that we have to look at more than just the requested_digits, since
+  // a number could be rounded up. Example: v=0.5 with requested_digits=0.
+  // Even though the power of v equals 0 we can't just stop here.
+  if (-(*decimal_point) > requested_digits) {
+    // The number is definitively too small.
+    // Ex: 0.001 with requested_digits == 1.
+    // Set decimal-point to -requested_digits. This is what Gay does.
+    // Note that it should not have any effect anyways since the string is
+    // empty.
+    *decimal_point = -requested_digits;
+    *length = 0;
+    return;
+  } else if (-(*decimal_point) == requested_digits) {
+    // We only need to verify if the number rounds down or up.
+    // Ex: 0.04 and 0.06 with requested_digits == 1.
+    ASSERT(*decimal_point == -requested_digits);
+    // Initially the fraction lies in range (1, 10]. Multiply the denominator
+    // by 10 so that we can compare more easily.
+    denominator->Times10();
+    if (Bignum::PlusCompare(*numerator, *numerator, *denominator) >= 0) {
+      // If the fraction is >= 0.5 then we have to include the rounded
+      // digit.
+      buffer[0] = '1';
+      *length = 1;
+      (*decimal_point)++;
+    } else {
+      // Note that we caught most of similar cases earlier.
+      *length = 0;
+    }
+    return;
+  } else {
+    // The requested digits correspond to the digits after the point.
+    // The variable 'needed_digits' includes the digits before the point.
+    int needed_digits = (*decimal_point) + requested_digits;
+    GenerateCountedDigits(needed_digits, decimal_point,
+                          numerator, denominator,
+                          buffer, length);
+  }
+}
+
+
+// Returns an estimation of k such that 10^(k-1) <= v < 10^k where
+// v = f * 2^exponent and 2^52 <= f < 2^53.
+// v is hence a normalized double with the given exponent. The output is an
+// approximation for the exponent of the decimal approimation .digits * 10^k.
+//
+// The result might undershoot by 1 in which case 10^k <= v < 10^k+1.
+// Note: this property holds for v's upper boundary m+ too.
+//    10^k <= m+ < 10^k+1.
+//   (see explanation below).
+//
+// Examples:
+//  EstimatePower(0)   => 16
+//  EstimatePower(-52) => 0
+//
+// Note: e >= 0 => EstimatedPower(e) > 0. No similar claim can be made for e<0.
+static int EstimatePower(int exponent) {
+  // This function estimates log10 of v where v = f*2^e (with e == exponent).
+  // Note that 10^floor(log10(v)) <= v, but v <= 10^ceil(log10(v)).
+  // Note that f is bounded by its container size. Let p = 53 (the double's
+  // significand size). Then 2^(p-1) <= f < 2^p.
+  //
+  // Given that log10(v) == log2(v)/log2(10) and e+(len(f)-1) is quite close
+  // to log2(v) the function is simplified to (e+(len(f)-1)/log2(10)).
+  // The computed number undershoots by less than 0.631 (when we compute log3
+  // and not log10).
+  //
+  // Optimization: since we only need an approximated result this computation
+  // can be performed on 64 bit integers. On x86/x64 architecture the speedup is
+  // not really measurable, though.
+  //
+  // Since we want to avoid overshooting we decrement by 1e10 so that
+  // floating-point imprecisions don't affect us.
+  //
+  // Explanation for v's boundary m+: the computation takes advantage of
+  // the fact that 2^(p-1) <= f < 2^p. Boundaries still satisfy this requirement
+  // (even for denormals where the delta can be much more important).
+
+  const double k1Log10 = 0.30102999566398114;  // 1/lg(10)
+
+  // For doubles len(f) == 53 (don't forget the hidden bit).
+  const int kSignificandSize = Double::kSignificandSize;
+  double estimate = ceil((exponent + kSignificandSize - 1) * k1Log10 - 1e-10);
+  return static_cast<int>(estimate);
+}
+
+
+// See comments for InitialScaledStartValues.
+static void InitialScaledStartValuesPositiveExponent(
+    uint64_t significand, int exponent,
+    int estimated_power, bool need_boundary_deltas,
+    Bignum* numerator, Bignum* denominator,
+    Bignum* delta_minus, Bignum* delta_plus) {
+  // A positive exponent implies a positive power.
+  ASSERT(estimated_power >= 0);
+  // Since the estimated_power is positive we simply multiply the denominator
+  // by 10^estimated_power.
+
+  // numerator = v.
+  numerator->AssignUInt64(significand);
+  numerator->ShiftLeft(exponent);
+  // denominator = 10^estimated_power.
+  denominator->AssignPowerUInt16(10, estimated_power);
+
+  if (need_boundary_deltas) {
+    // Introduce a common denominator so that the deltas to the boundaries are
+    // integers.
+    denominator->ShiftLeft(1);
+    numerator->ShiftLeft(1);
+    // Let v = f * 2^e, then m+ - v = 1/2 * 2^e; With the common
+    // denominator (of 2) delta_plus equals 2^e.
+    delta_plus->AssignUInt16(1);
+    delta_plus->ShiftLeft(exponent);
+    // Same for delta_minus. The adjustments if f == 2^p-1 are done later.
+    delta_minus->AssignUInt16(1);
+    delta_minus->ShiftLeft(exponent);
+  }
+}
+
+
+// See comments for InitialScaledStartValues
+static void InitialScaledStartValuesNegativeExponentPositivePower(
+    uint64_t significand, int exponent,
+    int estimated_power, bool need_boundary_deltas,
+    Bignum* numerator, Bignum* denominator,
+    Bignum* delta_minus, Bignum* delta_plus) {
+  // v = f * 2^e with e < 0, and with estimated_power >= 0.
+  // This means that e is close to 0 (have a look at how estimated_power is
+  // computed).
+
+  // numerator = significand
+  //  since v = significand * 2^exponent this is equivalent to
+  //  numerator = v * / 2^-exponent
+  numerator->AssignUInt64(significand);
+  // denominator = 10^estimated_power * 2^-exponent (with exponent < 0)
+  denominator->AssignPowerUInt16(10, estimated_power);
+  denominator->ShiftLeft(-exponent);
+
+  if (need_boundary_deltas) {
+    // Introduce a common denominator so that the deltas to the boundaries are
+    // integers.
+    denominator->ShiftLeft(1);
+    numerator->ShiftLeft(1);
+    // Let v = f * 2^e, then m+ - v = 1/2 * 2^e; With the common
+    // denominator (of 2) delta_plus equals 2^e.
+    // Given that the denominator already includes v's exponent the distance
+    // to the boundaries is simply 1.
+    delta_plus->AssignUInt16(1);
+    // Same for delta_minus. The adjustments if f == 2^p-1 are done later.
+    delta_minus->AssignUInt16(1);
+  }
+}
+
+
+// See comments for InitialScaledStartValues
+static void InitialScaledStartValuesNegativeExponentNegativePower(
+    uint64_t significand, int exponent,
+    int estimated_power, bool need_boundary_deltas,
+    Bignum* numerator, Bignum* denominator,
+    Bignum* delta_minus, Bignum* delta_plus) {
+  // Instead of multiplying the denominator with 10^estimated_power we
+  // multiply all values (numerator and deltas) by 10^-estimated_power.
+
+  // Use numerator as temporary container for power_ten.
+  Bignum* power_ten = numerator;
+  power_ten->AssignPowerUInt16(10, -estimated_power);
+
+  if (need_boundary_deltas) {
+    // Since power_ten == numerator we must make a copy of 10^estimated_power
+    // before we complete the computation of the numerator.
+    // delta_plus = delta_minus = 10^estimated_power
+    delta_plus->AssignBignum(*power_ten);
+    delta_minus->AssignBignum(*power_ten);
+  }
+
+  // numerator = significand * 2 * 10^-estimated_power
+  //  since v = significand * 2^exponent this is equivalent to
+  // numerator = v * 10^-estimated_power * 2 * 2^-exponent.
+  // Remember: numerator has been abused as power_ten. So no need to assign it
+  //  to itself.
+  ASSERT(numerator == power_ten);
+  numerator->MultiplyByUInt64(significand);
+
+  // denominator = 2 * 2^-exponent with exponent < 0.
+  denominator->AssignUInt16(1);
+  denominator->ShiftLeft(-exponent);
+
+  if (need_boundary_deltas) {
+    // Introduce a common denominator so that the deltas to the boundaries are
+    // integers.
+    numerator->ShiftLeft(1);
+    denominator->ShiftLeft(1);
+    // With this shift the boundaries have their correct value, since
+    // delta_plus = 10^-estimated_power, and
+    // delta_minus = 10^-estimated_power.
+    // These assignments have been done earlier.
+    // The adjustments if f == 2^p-1 (lower boundary is closer) are done later.
+  }
+}
+
+
+// Let v = significand * 2^exponent.
+// Computes v / 10^estimated_power exactly, as a ratio of two bignums, numerator
+// and denominator. The functions GenerateShortestDigits and
+// GenerateCountedDigits will then convert this ratio to its decimal
+// representation d, with the required accuracy.
+// Then d * 10^estimated_power is the representation of v.
+// (Note: the fraction and the estimated_power might get adjusted before
+// generating the decimal representation.)
+//
+// The initial start values consist of:
+//  - a scaled numerator: s.t. numerator/denominator == v / 10^estimated_power.
+//  - a scaled (common) denominator.
+//  optionally (used by GenerateShortestDigits to decide if it has the shortest
+//  decimal converting back to v):
+//  - v - m-: the distance to the lower boundary.
+//  - m+ - v: the distance to the upper boundary.
+//
+// v, m+, m-, and therefore v - m- and m+ - v all share the same denominator.
+//
+// Let ep == estimated_power, then the returned values will satisfy:
+//  v / 10^ep = numerator / denominator.
+//  v's boundarys m- and m+:
+//    m- / 10^ep == v / 10^ep - delta_minus / denominator
+//    m+ / 10^ep == v / 10^ep + delta_plus / denominator
+//  Or in other words:
+//    m- == v - delta_minus * 10^ep / denominator;
+//    m+ == v + delta_plus * 10^ep / denominator;
+//
+// Since 10^(k-1) <= v < 10^k    (with k == estimated_power)
+//  or       10^k <= v < 10^(k+1)
+//  we then have 0.1 <= numerator/denominator < 1
+//           or    1 <= numerator/denominator < 10
+//
+// It is then easy to kickstart the digit-generation routine.
+//
+// The boundary-deltas are only filled if the mode equals BIGNUM_DTOA_SHORTEST
+// or BIGNUM_DTOA_SHORTEST_SINGLE.
+
+static void InitialScaledStartValues(uint64_t significand,
+                                     int exponent,
+                                     bool lower_boundary_is_closer,
+                                     int estimated_power,
+                                     bool need_boundary_deltas,
+                                     Bignum* numerator,
+                                     Bignum* denominator,
+                                     Bignum* delta_minus,
+                                     Bignum* delta_plus) {
+  if (exponent >= 0) {
+    InitialScaledStartValuesPositiveExponent(
+        significand, exponent, estimated_power, need_boundary_deltas,
+        numerator, denominator, delta_minus, delta_plus);
+  } else if (estimated_power >= 0) {
+    InitialScaledStartValuesNegativeExponentPositivePower(
+        significand, exponent, estimated_power, need_boundary_deltas,
+        numerator, denominator, delta_minus, delta_plus);
+  } else {
+    InitialScaledStartValuesNegativeExponentNegativePower(
+        significand, exponent, estimated_power, need_boundary_deltas,
+        numerator, denominator, delta_minus, delta_plus);
+  }
+
+  if (need_boundary_deltas && lower_boundary_is_closer) {
+    // The lower boundary is closer at half the distance of "normal" numbers.
+    // Increase the common denominator and adapt all but the delta_minus.
+    denominator->ShiftLeft(1);  // *2
+    numerator->ShiftLeft(1);    // *2
+    delta_plus->ShiftLeft(1);   // *2
+  }
+}
+
+
+// This routine multiplies numerator/denominator so that its values lies in the
+// range 1-10. That is after a call to this function we have:
+//    1 <= (numerator + delta_plus) /denominator < 10.
+// Let numerator the input before modification and numerator' the argument
+// after modification, then the output-parameter decimal_point is such that
+//  numerator / denominator * 10^estimated_power ==
+//    numerator' / denominator' * 10^(decimal_point - 1)
+// In some cases estimated_power was too low, and this is already the case. We
+// then simply adjust the power so that 10^(k-1) <= v < 10^k (with k ==
+// estimated_power) but do not touch the numerator or denominator.
+// Otherwise the routine multiplies the numerator and the deltas by 10.
+static void FixupMultiply10(int estimated_power, bool is_even,
+                            int* decimal_point,
+                            Bignum* numerator, Bignum* denominator,
+                            Bignum* delta_minus, Bignum* delta_plus) {
+  bool in_range;
+  if (is_even) {
+    // For IEEE doubles half-way cases (in decimal system numbers ending with 5)
+    // are rounded to the closest floating-point number with even significand.
+    in_range = Bignum::PlusCompare(*numerator, *delta_plus, *denominator) >= 0;
+  } else {
+    in_range = Bignum::PlusCompare(*numerator, *delta_plus, *denominator) > 0;
+  }
+  if (in_range) {
+    // Since numerator + delta_plus >= denominator we already have
+    // 1 <= numerator/denominator < 10. Simply update the estimated_power.
+    *decimal_point = estimated_power + 1;
+  } else {
+    *decimal_point = estimated_power;
+    numerator->Times10();
+    if (Bignum::Equal(*delta_minus, *delta_plus)) {
+      delta_minus->Times10();
+      delta_plus->AssignBignum(*delta_minus);
+    } else {
+      delta_minus->Times10();
+      delta_plus->Times10();
+    }
+  }
+}
+
+}  // namespace double_conversion
diff --git a/base/poco/Foundation/src/bignum-dtoa.h b/base/poco/Foundation/src/bignum-dtoa.h
new file mode 100644
index 00000000000..34b961992d6
--- /dev/null
+++ b/base/poco/Foundation/src/bignum-dtoa.h
@@ -0,0 +1,84 @@
+// Copyright 2010 the V8 project authors. 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 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 Google Inc. 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 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
+// OWNER 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.
+
+#ifndef DOUBLE_CONVERSION_BIGNUM_DTOA_H_
+#define DOUBLE_CONVERSION_BIGNUM_DTOA_H_
+
+#include "utils.h"
+
+namespace double_conversion {
+
+enum BignumDtoaMode {
+  // Return the shortest correct representation.
+  // For example the output of 0.299999999999999988897 is (the less accurate but
+  // correct) 0.3.
+  BIGNUM_DTOA_SHORTEST,
+  // Same as BIGNUM_DTOA_SHORTEST but for single-precision floats.
+  BIGNUM_DTOA_SHORTEST_SINGLE,
+  // Return a fixed number of digits after the decimal point.
+  // For instance fixed(0.1, 4) becomes 0.1000
+  // If the input number is big, the output will be big.
+  BIGNUM_DTOA_FIXED,
+  // Return a fixed number of digits, no matter what the exponent is.
+  BIGNUM_DTOA_PRECISION
+};
+
+// Converts the given double 'v' to ascii.
+// The result should be interpreted as buffer * 10^(point-length).
+// The buffer will be null-terminated.
+//
+// The input v must be > 0 and different from NaN, and Infinity.
+//
+// The output depends on the given mode:
+//  - SHORTEST: produce the least amount of digits for which the internal
+//   identity requirement is still satisfied. If the digits are printed
+//   (together with the correct exponent) then reading this number will give
+//   'v' again. The buffer will choose the representation that is closest to
+//   'v'. If there are two at the same distance, than the number is round up.
+//   In this mode the 'requested_digits' parameter is ignored.
+//  - FIXED: produces digits necessary to print a given number with
+//   'requested_digits' digits after the decimal point. The produced digits
+//   might be too short in which case the caller has to fill the gaps with '0's.
+//   Example: toFixed(0.001, 5) is allowed to return buffer="1", point=-2.
+//   Halfway cases are rounded up. The call toFixed(0.15, 2) thus returns
+//     buffer="2", point=0.
+//   Note: the length of the returned buffer has no meaning wrt the significance
+//   of its digits. That is, just because it contains '0's does not mean that
+//   any other digit would not satisfy the internal identity requirement.
+//  - PRECISION: produces 'requested_digits' where the first digit is not '0'.
+//   Even though the length of produced digits usually equals
+//   'requested_digits', the function is allowed to return fewer digits, in
+//   which case the caller has to fill the missing digits with '0's.
+//   Halfway cases are again rounded up.
+// 'BignumDtoa' expects the given buffer to be big enough to hold all digits
+// and a terminating null-character.
+void BignumDtoa(double v, BignumDtoaMode mode, int requested_digits,
+                Vector<char> buffer, int* length, int* point);
+
+}  // namespace double_conversion
+
+#endif  // DOUBLE_CONVERSION_BIGNUM_DTOA_H_
diff --git a/base/poco/Foundation/src/bignum.cc b/base/poco/Foundation/src/bignum.cc
new file mode 100644
index 00000000000..2743d67e8d9
--- /dev/null
+++ b/base/poco/Foundation/src/bignum.cc
@@ -0,0 +1,766 @@
+// Copyright 2010 the V8 project authors. 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 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 Google Inc. 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 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
+// OWNER 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.
+
+#include "bignum.h"
+#include "utils.h"
+
+namespace double_conversion {
+
+Bignum::Bignum()
+    : bigits_(bigits_buffer_, kBigitCapacity), used_digits_(0), exponent_(0) {
+  for (int i = 0; i < kBigitCapacity; ++i) {
+    bigits_[i] = 0;
+  }
+}
+
+
+template<typename S>
+static int BitSize(S value) {
+  (void) value;  // Mark variable as used.
+  return 8 * sizeof(value);
+}
+
+// Guaranteed to lie in one Bigit.
+void Bignum::AssignUInt16(uint16_t value) {
+  ASSERT(kBigitSize >= BitSize(value));
+  Zero();
+  if (value == 0) return;
+
+  EnsureCapacity(1);
+  bigits_[0] = value;
+  used_digits_ = 1;
+}
+
+
+void Bignum::AssignUInt64(uint64_t value) {
+  const int kUInt64Size = 64;
+
+  Zero();
+  if (value == 0) return;
+
+  int needed_bigits = kUInt64Size / kBigitSize + 1;
+  EnsureCapacity(needed_bigits);
+  for (int i = 0; i < needed_bigits; ++i) {
+    bigits_[i] = value & kBigitMask;
+    value = value >> kBigitSize;
+  }
+  used_digits_ = needed_bigits;
+  Clamp();
+}
+
+
+void Bignum::AssignBignum(const Bignum& other) {
+  exponent_ = other.exponent_;
+  for (int i = 0; i < other.used_digits_; ++i) {
+    bigits_[i] = other.bigits_[i];
+  }
+  // Clear the excess digits (if there were any).
+  for (int i = other.used_digits_; i < used_digits_; ++i) {
+    bigits_[i] = 0;
+  }
+  used_digits_ = other.used_digits_;
+}
+
+
+static uint64_t ReadUInt64(Vector<const char> buffer,
+                           int from,
+                           int digits_to_read) {
+  uint64_t result = 0;
+  for (int i = from; i < from + digits_to_read; ++i) {
+    int digit = buffer[i] - '0';
+    ASSERT(0 <= digit && digit <= 9);
+    result = result * 10 + digit;
+  }
+  return result;
+}
+
+
+void Bignum::AssignDecimalString(Vector<const char> value) {
+  // 2^64 = 18446744073709551616 > 10^19
+  const int kMaxUint64DecimalDigits = 19;
+  Zero();
+  int length = value.length();
+  int pos = 0;
+  // Let's just say that each digit needs 4 bits.
+  while (length >= kMaxUint64DecimalDigits) {
+    uint64_t digits = ReadUInt64(value, pos, kMaxUint64DecimalDigits);
+    pos += kMaxUint64DecimalDigits;
+    length -= kMaxUint64DecimalDigits;
+    MultiplyByPowerOfTen(kMaxUint64DecimalDigits);
+    AddUInt64(digits);
+  }
+  uint64_t digits = ReadUInt64(value, pos, length);
+  MultiplyByPowerOfTen(length);
+  AddUInt64(digits);
+  Clamp();
+}
+
+
+static int HexCharValue(char c) {
+  if ('0' <= c && c <= '9') return c - '0';
+  if ('a' <= c && c <= 'f') return 10 + c - 'a';
+  ASSERT('A' <= c && c <= 'F');
+  return 10 + c - 'A';
+}
+
+
+void Bignum::AssignHexString(Vector<const char> value) {
+  Zero();
+  int length = value.length();
+
+  int needed_bigits = length * 4 / kBigitSize + 1;
+  EnsureCapacity(needed_bigits);
+  int string_index = length - 1;
+  for (int i = 0; i < needed_bigits - 1; ++i) {
+    // These bigits are guaranteed to be "full".
+    Chunk current_bigit = 0;
+    for (int j = 0; j < kBigitSize / 4; j++) {
+      current_bigit += HexCharValue(value[string_index--]) << (j * 4);
+    }
+    bigits_[i] = current_bigit;
+  }
+  used_digits_ = needed_bigits - 1;
+
+  Chunk most_significant_bigit = 0;  // Could be = 0;
+  for (int j = 0; j <= string_index; ++j) {
+    most_significant_bigit <<= 4;
+    most_significant_bigit += HexCharValue(value[j]);
+  }
+  if (most_significant_bigit != 0) {
+    bigits_[used_digits_] = most_significant_bigit;
+    used_digits_++;
+  }
+  Clamp();
+}
+
+
+void Bignum::AddUInt64(uint64_t operand) {
+  if (operand == 0) return;
+  Bignum other;
+  other.AssignUInt64(operand);
+  AddBignum(other);
+}
+
+
+void Bignum::AddBignum(const Bignum& other) {
+  ASSERT(IsClamped());
+  ASSERT(other.IsClamped());
+
+  // If this has a greater exponent than other append zero-bigits to this.
+  // After this call exponent_ <= other.exponent_.
+  Align(other);
+
+  // There are two possibilities:
+  //   aaaaaaaaaaa 0000  (where the 0s represent a's exponent)
+  //     bbbbb 00000000
+  //   ----------------
+  //   ccccccccccc 0000
+  // or
+  //    aaaaaaaaaa 0000
+  //  bbbbbbbbb 0000000
+  //  -----------------
+  //  cccccccccccc 0000
+  // In both cases we might need a carry bigit.
+
+  EnsureCapacity(1 + Max(BigitLength(), other.BigitLength()) - exponent_);
+  Chunk carry = 0;
+  int bigit_pos = other.exponent_ - exponent_;
+  ASSERT(bigit_pos >= 0);
+  for (int i = 0; i < other.used_digits_; ++i) {
+    Chunk sum = bigits_[bigit_pos] + other.bigits_[i] + carry;
+    bigits_[bigit_pos] = sum & kBigitMask;
+    carry = sum >> kBigitSize;
+    bigit_pos++;
+  }
+
+  while (carry != 0) {
+    Chunk sum = bigits_[bigit_pos] + carry;
+    bigits_[bigit_pos] = sum & kBigitMask;
+    carry = sum >> kBigitSize;
+    bigit_pos++;
+  }
+  used_digits_ = Max(bigit_pos, used_digits_);
+  ASSERT(IsClamped());
+}
+
+
+void Bignum::SubtractBignum(const Bignum& other) {
+  ASSERT(IsClamped());
+  ASSERT(other.IsClamped());
+  // We require this to be bigger than other.
+  ASSERT(LessEqual(other, *this));
+
+  Align(other);
+
+  int offset = other.exponent_ - exponent_;
+  Chunk borrow = 0;
+  int i;
+  for (i = 0; i < other.used_digits_; ++i) {
+    ASSERT((borrow == 0) || (borrow == 1));
+    Chunk difference = bigits_[i + offset] - other.bigits_[i] - borrow;
+    bigits_[i + offset] = difference & kBigitMask;
+    borrow = difference >> (kChunkSize - 1);
+  }
+  while (borrow != 0) {
+    Chunk difference = bigits_[i + offset] - borrow;
+    bigits_[i + offset] = difference & kBigitMask;
+    borrow = difference >> (kChunkSize - 1);
+    ++i;
+  }
+  Clamp();
+}
+
+
+void Bignum::ShiftLeft(int shift_amount) {
+  if (used_digits_ == 0) return;
+  exponent_ += shift_amount / kBigitSize;
+  int local_shift = shift_amount % kBigitSize;
+  EnsureCapacity(used_digits_ + 1);
+  BigitsShiftLeft(local_shift);
+}
+
+
+void Bignum::MultiplyByUInt32(uint32_t factor) {
+  if (factor == 1) return;
+  if (factor == 0) {
+    Zero();
+    return;
+  }
+  if (used_digits_ == 0) return;
+
+  // The product of a bigit with the factor is of size kBigitSize + 32.
+  // Assert that this number + 1 (for the carry) fits into double chunk.
+  ASSERT(kDoubleChunkSize >= kBigitSize + 32 + 1);
+  DoubleChunk carry = 0;
+  for (int i = 0; i < used_digits_; ++i) {
+    DoubleChunk product = static_cast<DoubleChunk>(factor) * bigits_[i] + carry;
+    bigits_[i] = static_cast<Chunk>(product & kBigitMask);
+    carry = (product >> kBigitSize);
+  }
+  while (carry != 0) {
+    EnsureCapacity(used_digits_ + 1);
+    bigits_[used_digits_] = carry & kBigitMask;
+    used_digits_++;
+    carry >>= kBigitSize;
+  }
+}
+
+
+void Bignum::MultiplyByUInt64(uint64_t factor) {
+  if (factor == 1) return;
+  if (factor == 0) {
+    Zero();
+    return;
+  }
+  ASSERT(kBigitSize < 32);
+  uint64_t carry = 0;
+  uint64_t low = factor & 0xFFFFFFFF;
+  uint64_t high = factor >> 32;
+  for (int i = 0; i < used_digits_; ++i) {
+    uint64_t product_low = low * bigits_[i];
+    uint64_t product_high = high * bigits_[i];
+    uint64_t tmp = (carry & kBigitMask) + product_low;
+    bigits_[i] = tmp & kBigitMask;
+    carry = (carry >> kBigitSize) + (tmp >> kBigitSize) +
+        (product_high << (32 - kBigitSize));
+  }
+  while (carry != 0) {
+    EnsureCapacity(used_digits_ + 1);
+    bigits_[used_digits_] = carry & kBigitMask;
+    used_digits_++;
+    carry >>= kBigitSize;
+  }
+}
+
+
+void Bignum::MultiplyByPowerOfTen(int exponent) {
+  const uint64_t kFive27 = UINT64_2PART_C(0x6765c793, fa10079d);
+  const uint16_t kFive1 = 5;
+  const uint16_t kFive2 = kFive1 * 5;
+  const uint16_t kFive3 = kFive2 * 5;
+  const uint16_t kFive4 = kFive3 * 5;
+  const uint16_t kFive5 = kFive4 * 5;
+  const uint16_t kFive6 = kFive5 * 5;
+  const uint32_t kFive7 = kFive6 * 5;
+  const uint32_t kFive8 = kFive7 * 5;
+  const uint32_t kFive9 = kFive8 * 5;
+  const uint32_t kFive10 = kFive9 * 5;
+  const uint32_t kFive11 = kFive10 * 5;
+  const uint32_t kFive12 = kFive11 * 5;
+  const uint32_t kFive13 = kFive12 * 5;
+  const uint32_t kFive1_to_12[] =
+      { kFive1, kFive2, kFive3, kFive4, kFive5, kFive6,
+        kFive7, kFive8, kFive9, kFive10, kFive11, kFive12 };
+
+  ASSERT(exponent >= 0);
+  if (exponent == 0) return;
+  if (used_digits_ == 0) return;
+
+  // We shift by exponent at the end just before returning.
+  int remaining_exponent = exponent;
+  while (remaining_exponent >= 27) {
+    MultiplyByUInt64(kFive27);
+    remaining_exponent -= 27;
+  }
+  while (remaining_exponent >= 13) {
+    MultiplyByUInt32(kFive13);
+    remaining_exponent -= 13;
+  }
+  if (remaining_exponent > 0) {
+    MultiplyByUInt32(kFive1_to_12[remaining_exponent - 1]);
+  }
+  ShiftLeft(exponent);
+}
+
+
+void Bignum::Square() {
+  ASSERT(IsClamped());
+  int product_length = 2 * used_digits_;
+  EnsureCapacity(product_length);
+
+  // Comba multiplication: compute each column separately.
+  // Example: r = a2a1a0 * b2b1b0.
+  //    r =  1    * a0b0 +
+  //        10    * (a1b0 + a0b1) +
+  //        100   * (a2b0 + a1b1 + a0b2) +
+  //        1000  * (a2b1 + a1b2) +
+  //        10000 * a2b2
+  //
+  // In the worst case we have to accumulate nb-digits products of digit*digit.
+  //
+  // Assert that the additional number of bits in a DoubleChunk are enough to
+  // sum up used_digits of Bigit*Bigit.
+  if ((1 << (2 * (kChunkSize - kBigitSize))) <= used_digits_) {
+    UNIMPLEMENTED();
+  }
+  DoubleChunk accumulator = 0;
+  // First shift the digits so we don't overwrite them.
+  int copy_offset = used_digits_;
+  for (int i = 0; i < used_digits_; ++i) {
+    bigits_[copy_offset + i] = bigits_[i];
+  }
+  // We have two loops to avoid some 'if's in the loop.
+  for (int i = 0; i < used_digits_; ++i) {
+    // Process temporary digit i with power i.
+    // The sum of the two indices must be equal to i.
+    int bigit_index1 = i;
+    int bigit_index2 = 0;
+    // Sum all of the sub-products.
+    while (bigit_index1 >= 0) {
+      Chunk chunk1 = bigits_[copy_offset + bigit_index1];
+      Chunk chunk2 = bigits_[copy_offset + bigit_index2];
+      accumulator += static_cast<DoubleChunk>(chunk1) * chunk2;
+      bigit_index1--;
+      bigit_index2++;
+    }
+    bigits_[i] = static_cast<Chunk>(accumulator) & kBigitMask;
+    accumulator >>= kBigitSize;
+  }
+  for (int i = used_digits_; i < product_length; ++i) {
+    int bigit_index1 = used_digits_ - 1;
+    int bigit_index2 = i - bigit_index1;
+    // Invariant: sum of both indices is again equal to i.
+    // Inner loop runs 0 times on last iteration, emptying accumulator.
+    while (bigit_index2 < used_digits_) {
+      Chunk chunk1 = bigits_[copy_offset + bigit_index1];
+      Chunk chunk2 = bigits_[copy_offset + bigit_index2];
+      accumulator += static_cast<DoubleChunk>(chunk1) * chunk2;
+      bigit_index1--;
+      bigit_index2++;
+    }
+    // The overwritten bigits_[i] will never be read in further loop iterations,
+    // because bigit_index1 and bigit_index2 are always greater
+    // than i - used_digits_.
+    bigits_[i] = static_cast<Chunk>(accumulator) & kBigitMask;
+    accumulator >>= kBigitSize;
+  }
+  // Since the result was guaranteed to lie inside the number the
+  // accumulator must be 0 now.
+  ASSERT(accumulator == 0);
+
+  // Don't forget to update the used_digits and the exponent.
+  used_digits_ = product_length;
+  exponent_ *= 2;
+  Clamp();
+}
+
+
+void Bignum::AssignPowerUInt16(uint16_t base, int power_exponent) {
+  ASSERT(base != 0);
+  ASSERT(power_exponent >= 0);
+  if (power_exponent == 0) {
+    AssignUInt16(1);
+    return;
+  }
+  Zero();
+  int shifts = 0;
+  // We expect base to be in range 2-32, and most often to be 10.
+  // It does not make much sense to implement different algorithms for counting
+  // the bits.
+  while ((base & 1) == 0) {
+    base >>= 1;
+    shifts++;
+  }
+  int bit_size = 0;
+  int tmp_base = base;
+  while (tmp_base != 0) {
+    tmp_base >>= 1;
+    bit_size++;
+  }
+  int final_size = bit_size * power_exponent;
+  // 1 extra bigit for the shifting, and one for rounded final_size.
+  EnsureCapacity(final_size / kBigitSize + 2);
+
+  // Left to Right exponentiation.
+  int mask = 1;
+  while (power_exponent >= mask) mask <<= 1;
+
+  // The mask is now pointing to the bit above the most significant 1-bit of
+  // power_exponent.
+  // Get rid of first 1-bit;
+  mask >>= 2;
+  uint64_t this_value = base;
+
+  bool delayed_multipliciation = false;
+  const uint64_t max_32bits = 0xFFFFFFFF;
+  while (mask != 0 && this_value <= max_32bits) {
+    this_value = this_value * this_value;
+    // Verify that there is enough space in this_value to perform the
+    // multiplication.  The first bit_size bits must be 0.
+    if ((power_exponent & mask) != 0) {
+      uint64_t base_bits_mask =
+          ~((static_cast<uint64_t>(1) << (64 - bit_size)) - 1);
+      bool high_bits_zero = (this_value & base_bits_mask) == 0;
+      if (high_bits_zero) {
+        this_value *= base;
+      } else {
+        delayed_multipliciation = true;
+      }
+    }
+    mask >>= 1;
+  }
+  AssignUInt64(this_value);
+  if (delayed_multipliciation) {
+    MultiplyByUInt32(base);
+  }
+
+  // Now do the same thing as a bignum.
+  while (mask != 0) {
+    Square();
+    if ((power_exponent & mask) != 0) {
+      MultiplyByUInt32(base);
+    }
+    mask >>= 1;
+  }
+
+  // And finally add the saved shifts.
+  ShiftLeft(shifts * power_exponent);
+}
+
+
+// Precondition: this/other < 16bit.
+uint16_t Bignum::DivideModuloIntBignum(const Bignum& other) {
+  ASSERT(IsClamped());
+  ASSERT(other.IsClamped());
+  ASSERT(other.used_digits_ > 0);
+
+  // Easy case: if we have less digits than the divisor than the result is 0.
+  // Note: this handles the case where this == 0, too.
+  if (BigitLength() < other.BigitLength()) {
+    return 0;
+  }
+
+  Align(other);
+
+  uint16_t result = 0;
+
+  // Start by removing multiples of 'other' until both numbers have the same
+  // number of digits.
+  while (BigitLength() > other.BigitLength()) {
+    // This naive approach is extremely inefficient if `this` divided by other
+    // is big. This function is implemented for doubleToString where
+    // the result should be small (less than 10).
+    ASSERT(other.bigits_[other.used_digits_ - 1] >= ((1 << kBigitSize) / 16));
+    ASSERT(bigits_[used_digits_ - 1] < 0x10000);
+    // Remove the multiples of the first digit.
+    // Example this = 23 and other equals 9. -> Remove 2 multiples.
+    result += static_cast<uint16_t>(bigits_[used_digits_ - 1]);
+    SubtractTimes(other, bigits_[used_digits_ - 1]);
+  }
+
+  ASSERT(BigitLength() == other.BigitLength());
+
+  // Both bignums are at the same length now.
+  // Since other has more than 0 digits we know that the access to
+  // bigits_[used_digits_ - 1] is safe.
+  Chunk this_bigit = bigits_[used_digits_ - 1];
+  Chunk other_bigit = other.bigits_[other.used_digits_ - 1];
+
+  if (other.used_digits_ == 1) {
+    // Shortcut for easy (and common) case.
+    int quotient = this_bigit / other_bigit;
+    bigits_[used_digits_ - 1] = this_bigit - other_bigit * quotient;
+    ASSERT(quotient < 0x10000);
+    result += static_cast<uint16_t>(quotient);
+    Clamp();
+    return result;
+  }
+
+  int division_estimate = this_bigit / (other_bigit + 1);
+  ASSERT(division_estimate < 0x10000);
+  result += static_cast<uint16_t>(division_estimate);
+  SubtractTimes(other, division_estimate);
+
+  if (other_bigit * (division_estimate + 1) > this_bigit) {
+    // No need to even try to subtract. Even if other's remaining digits were 0
+    // another subtraction would be too much.
+    return result;
+  }
+
+  while (LessEqual(other, *this)) {
+    SubtractBignum(other);
+    result++;
+  }
+  return result;
+}
+
+
+template<typename S>
+static int SizeInHexChars(S number) {
+  ASSERT(number > 0);
+  int result = 0;
+  while (number != 0) {
+    number >>= 4;
+    result++;
+  }
+  return result;
+}
+
+
+static char HexCharOfValue(int value) {
+  ASSERT(0 <= value && value <= 16);
+  if (value < 10) return static_cast<char>(value + '0');
+  return static_cast<char>(value - 10 + 'A');
+}
+
+
+bool Bignum::ToHexString(char* buffer, int buffer_size) const {
+  ASSERT(IsClamped());
+  // Each bigit must be printable as separate hex-character.
+  ASSERT(kBigitSize % 4 == 0);
+  const int kHexCharsPerBigit = kBigitSize / 4;
+
+  if (used_digits_ == 0) {
+    if (buffer_size < 2) return false;
+    buffer[0] = '0';
+    buffer[1] = '\0';
+    return true;
+  }
+  // We add 1 for the terminating '\0' character.
+  int needed_chars = (BigitLength() - 1) * kHexCharsPerBigit +
+      SizeInHexChars(bigits_[used_digits_ - 1]) + 1;
+  if (needed_chars > buffer_size) return false;
+  int string_index = needed_chars - 1;
+  buffer[string_index--] = '\0';
+  for (int i = 0; i < exponent_; ++i) {
+    for (int j = 0; j < kHexCharsPerBigit; ++j) {
+      buffer[string_index--] = '0';
+    }
+  }
+  for (int i = 0; i < used_digits_ - 1; ++i) {
+    Chunk current_bigit = bigits_[i];
+    for (int j = 0; j < kHexCharsPerBigit; ++j) {
+      buffer[string_index--] = HexCharOfValue(current_bigit & 0xF);
+      current_bigit >>= 4;
+    }
+  }
+  // And finally the last bigit.
+  Chunk most_significant_bigit = bigits_[used_digits_ - 1];
+  while (most_significant_bigit != 0) {
+    buffer[string_index--] = HexCharOfValue(most_significant_bigit & 0xF);
+    most_significant_bigit >>= 4;
+  }
+  return true;
+}
+
+
+Bignum::Chunk Bignum::BigitAt(int index) const {
+  if (index >= BigitLength()) return 0;
+  if (index < exponent_) return 0;
+  return bigits_[index - exponent_];
+}
+
+
+int Bignum::Compare(const Bignum& a, const Bignum& b) {
+  ASSERT(a.IsClamped());
+  ASSERT(b.IsClamped());
+  int bigit_length_a = a.BigitLength();
+  int bigit_length_b = b.BigitLength();
+  if (bigit_length_a < bigit_length_b) return -1;
+  if (bigit_length_a > bigit_length_b) return +1;
+  for (int i = bigit_length_a - 1; i >= Min(a.exponent_, b.exponent_); --i) {
+    Chunk bigit_a = a.BigitAt(i);
+    Chunk bigit_b = b.BigitAt(i);
+    if (bigit_a < bigit_b) return -1;
+    if (bigit_a > bigit_b) return +1;
+    // Otherwise they are equal up to this digit. Try the next digit.
+  }
+  return 0;
+}
+
+
+int Bignum::PlusCompare(const Bignum& a, const Bignum& b, const Bignum& c) {
+  ASSERT(a.IsClamped());
+  ASSERT(b.IsClamped());
+  ASSERT(c.IsClamped());
+  if (a.BigitLength() < b.BigitLength()) {
+    return PlusCompare(b, a, c);
+  }
+  if (a.BigitLength() + 1 < c.BigitLength()) return -1;
+  if (a.BigitLength() > c.BigitLength()) return +1;
+  // The exponent encodes 0-bigits. So if there are more 0-digits in 'a' than
+  // 'b' has digits, then the bigit-length of 'a'+'b' must be equal to the one
+  // of 'a'.
+  if (a.exponent_ >= b.BigitLength() && a.BigitLength() < c.BigitLength()) {
+    return -1;
+  }
+
+  Chunk borrow = 0;
+  // Starting at min_exponent all digits are == 0. So no need to compare them.
+  int min_exponent = Min(Min(a.exponent_, b.exponent_), c.exponent_);
+  for (int i = c.BigitLength() - 1; i >= min_exponent; --i) {
+    Chunk chunk_a = a.BigitAt(i);
+    Chunk chunk_b = b.BigitAt(i);
+    Chunk chunk_c = c.BigitAt(i);
+    Chunk sum = chunk_a + chunk_b;
+    if (sum > chunk_c + borrow) {
+      return +1;
+    } else {
+      borrow = chunk_c + borrow - sum;
+      if (borrow > 1) return -1;
+      borrow <<= kBigitSize;
+    }
+  }
+  if (borrow == 0) return 0;
+  return -1;
+}
+
+
+void Bignum::Clamp() {
+  while (used_digits_ > 0 && bigits_[used_digits_ - 1] == 0) {
+    used_digits_--;
+  }
+  if (used_digits_ == 0) {
+    // Zero.
+    exponent_ = 0;
+  }
+}
+
+
+bool Bignum::IsClamped() const {
+  return used_digits_ == 0 || bigits_[used_digits_ - 1] != 0;
+}
+
+
+void Bignum::Zero() {
+  for (int i = 0; i < used_digits_; ++i) {
+    bigits_[i] = 0;
+  }
+  used_digits_ = 0;
+  exponent_ = 0;
+}
+
+
+void Bignum::Align(const Bignum& other) {
+  if (exponent_ > other.exponent_) {
+    // If "X" represents a "hidden" digit (by the exponent) then we are in the
+    // following case (a == this, b == other):
+    // a:  aaaaaaXXXX   or a:   aaaaaXXX
+    // b:     bbbbbbX      b: bbbbbbbbXX
+    // We replace some of the hidden digits (X) of a with 0 digits.
+    // a:  aaaaaa000X   or a:   aaaaa0XX
+    int zero_digits = exponent_ - other.exponent_;
+    EnsureCapacity(used_digits_ + zero_digits);
+    for (int i = used_digits_ - 1; i >= 0; --i) {
+      bigits_[i + zero_digits] = bigits_[i];
+    }
+    for (int i = 0; i < zero_digits; ++i) {
+      bigits_[i] = 0;
+    }
+    used_digits_ += zero_digits;
+    exponent_ -= zero_digits;
+    ASSERT(used_digits_ >= 0);
+    ASSERT(exponent_ >= 0);
+  }
+}
+
+
+void Bignum::BigitsShiftLeft(int shift_amount) {
+  ASSERT(shift_amount < kBigitSize);
+  ASSERT(shift_amount >= 0);
+  Chunk carry = 0;
+  for (int i = 0; i < used_digits_; ++i) {
+    Chunk new_carry = bigits_[i] >> (kBigitSize - shift_amount);
+    bigits_[i] = ((bigits_[i] << shift_amount) + carry) & kBigitMask;
+    carry = new_carry;
+  }
+  if (carry != 0) {
+    bigits_[used_digits_] = carry;
+    used_digits_++;
+  }
+}
+
+
+void Bignum::SubtractTimes(const Bignum& other, int factor) {
+  ASSERT(exponent_ <= other.exponent_);
+  if (factor < 3) {
+    for (int i = 0; i < factor; ++i) {
+      SubtractBignum(other);
+    }
+    return;
+  }
+  Chunk borrow = 0;
+  int exponent_diff = other.exponent_ - exponent_;
+  for (int i = 0; i < other.used_digits_; ++i) {
+    DoubleChunk product = static_cast<DoubleChunk>(factor) * other.bigits_[i];
+    DoubleChunk remove = borrow + product;
+    Chunk difference = bigits_[i + exponent_diff] - (remove & kBigitMask);
+    bigits_[i + exponent_diff] = difference & kBigitMask;
+    borrow = static_cast<Chunk>((difference >> (kChunkSize - 1)) +
+                                (remove >> kBigitSize));
+  }
+  for (int i = other.used_digits_ + exponent_diff; i < used_digits_; ++i) {
+    if (borrow == 0) return;
+    Chunk difference = bigits_[i] - borrow;
+    bigits_[i] = difference & kBigitMask;
+    borrow = difference >> (kChunkSize - 1);
+  }
+  Clamp();
+}
+
+
+}  // namespace double_conversion
diff --git a/base/poco/Foundation/src/bignum.h b/base/poco/Foundation/src/bignum.h
new file mode 100644
index 00000000000..5ec3544f573
--- /dev/null
+++ b/base/poco/Foundation/src/bignum.h
@@ -0,0 +1,145 @@
+// Copyright 2010 the V8 project authors. 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 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 Google Inc. 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 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
+// OWNER 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.
+
+#ifndef DOUBLE_CONVERSION_BIGNUM_H_
+#define DOUBLE_CONVERSION_BIGNUM_H_
+
+#include "utils.h"
+
+namespace double_conversion {
+
+class Bignum {
+ public:
+  // 3584 = 128 * 28. We can represent 2^3584 > 10^1000 accurately.
+  // This bignum can encode much bigger numbers, since it contains an
+  // exponent.
+  static const int kMaxSignificantBits = 3584;
+
+  Bignum();
+  void AssignUInt16(uint16_t value);
+  void AssignUInt64(uint64_t value);
+  void AssignBignum(const Bignum& other);
+
+  void AssignDecimalString(Vector<const char> value);
+  void AssignHexString(Vector<const char> value);
+
+  void AssignPowerUInt16(uint16_t base, int exponent);
+
+  void AddUInt16(uint16_t operand);
+  void AddUInt64(uint64_t operand);
+  void AddBignum(const Bignum& other);
+  // Precondition: this >= other.
+  void SubtractBignum(const Bignum& other);
+
+  void Square();
+  void ShiftLeft(int shift_amount);
+  void MultiplyByUInt32(uint32_t factor);
+  void MultiplyByUInt64(uint64_t factor);
+  void MultiplyByPowerOfTen(int exponent);
+  void Times10() { return MultiplyByUInt32(10); }
+  // Pseudocode:
+  //  int result = this / other;
+  //  this = this % other;
+  // In the worst case this function is in O(this/other).
+  uint16_t DivideModuloIntBignum(const Bignum& other);
+
+  bool ToHexString(char* buffer, int buffer_size) const;
+
+  // Returns
+  //  -1 if a < b,
+  //   0 if a == b, and
+  //  +1 if a > b.
+  static int Compare(const Bignum& a, const Bignum& b);
+  static bool Equal(const Bignum& a, const Bignum& b) {
+    return Compare(a, b) == 0;
+  }
+  static bool LessEqual(const Bignum& a, const Bignum& b) {
+    return Compare(a, b) <= 0;
+  }
+  static bool Less(const Bignum& a, const Bignum& b) {
+    return Compare(a, b) < 0;
+  }
+  // Returns Compare(a + b, c);
+  static int PlusCompare(const Bignum& a, const Bignum& b, const Bignum& c);
+  // Returns a + b == c
+  static bool PlusEqual(const Bignum& a, const Bignum& b, const Bignum& c) {
+    return PlusCompare(a, b, c) == 0;
+  }
+  // Returns a + b <= c
+  static bool PlusLessEqual(const Bignum& a, const Bignum& b, const Bignum& c) {
+    return PlusCompare(a, b, c) <= 0;
+  }
+  // Returns a + b < c
+  static bool PlusLess(const Bignum& a, const Bignum& b, const Bignum& c) {
+    return PlusCompare(a, b, c) < 0;
+  }
+ private:
+  typedef uint32_t Chunk;
+  typedef uint64_t DoubleChunk;
+
+  static const int kChunkSize = sizeof(Chunk) * 8;
+  static const int kDoubleChunkSize = sizeof(DoubleChunk) * 8;
+  // With bigit size of 28 we loose some bits, but a double still fits easily
+  // into two chunks, and more importantly we can use the Comba multiplication.
+  static const int kBigitSize = 28;
+  static const Chunk kBigitMask = (1 << kBigitSize) - 1;
+  // Every instance allocates kBigitLength chunks on the stack. Bignums cannot
+  // grow. There are no checks if the stack-allocated space is sufficient.
+  static const int kBigitCapacity = kMaxSignificantBits / kBigitSize;
+
+  void EnsureCapacity(int size) {
+    if (size > kBigitCapacity) {
+      UNREACHABLE();
+    }
+  }
+  void Align(const Bignum& other);
+  void Clamp();
+  bool IsClamped() const;
+  void Zero();
+  // Requires this to have enough capacity (no tests done).
+  // Updates used_digits_ if necessary.
+  // shift_amount must be < kBigitSize.
+  void BigitsShiftLeft(int shift_amount);
+  // BigitLength includes the "hidden" digits encoded in the exponent.
+  int BigitLength() const { return used_digits_ + exponent_; }
+  Chunk BigitAt(int index) const;
+  void SubtractTimes(const Bignum& other, int factor);
+
+  Chunk bigits_buffer_[kBigitCapacity];
+  // A vector backed by bigits_buffer_. This way accesses to the array are
+  // checked for out-of-bounds errors.
+  Vector<Chunk> bigits_;
+  int used_digits_;
+  // The Bignum's value equals value(bigits_) * 2^(exponent_ * kBigitSize).
+  int exponent_;
+
+  DISALLOW_COPY_AND_ASSIGN(Bignum);
+};
+
+}  // namespace double_conversion
+
+#endif  // DOUBLE_CONVERSION_BIGNUM_H_
diff --git a/base/poco/Foundation/src/cached-powers.cc b/base/poco/Foundation/src/cached-powers.cc
new file mode 100644
index 00000000000..d1359ffe43e
--- /dev/null
+++ b/base/poco/Foundation/src/cached-powers.cc
@@ -0,0 +1,176 @@
+// Copyright 2006-2008 the V8 project authors. 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 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 Google Inc. 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 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
+// OWNER 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.
+
+#include <stdarg.h>
+#include <limits.h>
+#include <math.h>
+
+#include "utils.h"
+
+#include "cached-powers.h"
+
+namespace double_conversion {
+
+struct CachedPower {
+  uint64_t significand;
+  int16_t binary_exponent;
+  int16_t decimal_exponent;
+};
+
+static const CachedPower kCachedPowers[] = {
+  {UINT64_2PART_C(0xfa8fd5a0, 081c0288), -1220, -348},
+  {UINT64_2PART_C(0xbaaee17f, a23ebf76), -1193, -340},
+  {UINT64_2PART_C(0x8b16fb20, 3055ac76), -1166, -332},
+  {UINT64_2PART_C(0xcf42894a, 5dce35ea), -1140, -324},
+  {UINT64_2PART_C(0x9a6bb0aa, 55653b2d), -1113, -316},
+  {UINT64_2PART_C(0xe61acf03, 3d1a45df), -1087, -308},
+  {UINT64_2PART_C(0xab70fe17, c79ac6ca), -1060, -300},
+  {UINT64_2PART_C(0xff77b1fc, bebcdc4f), -1034, -292},
+  {UINT64_2PART_C(0xbe5691ef, 416bd60c), -1007, -284},
+  {UINT64_2PART_C(0x8dd01fad, 907ffc3c), -980, -276},
+  {UINT64_2PART_C(0xd3515c28, 31559a83), -954, -268},
+  {UINT64_2PART_C(0x9d71ac8f, ada6c9b5), -927, -260},
+  {UINT64_2PART_C(0xea9c2277, 23ee8bcb), -901, -252},
+  {UINT64_2PART_C(0xaecc4991, 4078536d), -874, -244},
+  {UINT64_2PART_C(0x823c1279, 5db6ce57), -847, -236},
+  {UINT64_2PART_C(0xc2109436, 4dfb5637), -821, -228},
+  {UINT64_2PART_C(0x9096ea6f, 3848984f), -794, -220},
+  {UINT64_2PART_C(0xd77485cb, 25823ac7), -768, -212},
+  {UINT64_2PART_C(0xa086cfcd, 97bf97f4), -741, -204},
+  {UINT64_2PART_C(0xef340a98, 172aace5), -715, -196},
+  {UINT64_2PART_C(0xb23867fb, 2a35b28e), -688, -188},
+  {UINT64_2PART_C(0x84c8d4df, d2c63f3b), -661, -180},
+  {UINT64_2PART_C(0xc5dd4427, 1ad3cdba), -635, -172},
+  {UINT64_2PART_C(0x936b9fce, bb25c996), -608, -164},
+  {UINT64_2PART_C(0xdbac6c24, 7d62a584), -582, -156},
+  {UINT64_2PART_C(0xa3ab6658, 0d5fdaf6), -555, -148},
+  {UINT64_2PART_C(0xf3e2f893, dec3f126), -529, -140},
+  {UINT64_2PART_C(0xb5b5ada8, aaff80b8), -502, -132},
+  {UINT64_2PART_C(0x87625f05, 6c7c4a8b), -475, -124},
+  {UINT64_2PART_C(0xc9bcff60, 34c13053), -449, -116},
+  {UINT64_2PART_C(0x964e858c, 91ba2655), -422, -108},
+  {UINT64_2PART_C(0xdff97724, 70297ebd), -396, -100},
+  {UINT64_2PART_C(0xa6dfbd9f, b8e5b88f), -369, -92},
+  {UINT64_2PART_C(0xf8a95fcf, 88747d94), -343, -84},
+  {UINT64_2PART_C(0xb9447093, 8fa89bcf), -316, -76},
+  {UINT64_2PART_C(0x8a08f0f8, bf0f156b), -289, -68},
+  {UINT64_2PART_C(0xcdb02555, 653131b6), -263, -60},
+  {UINT64_2PART_C(0x993fe2c6, d07b7fac), -236, -52},
+  {UINT64_2PART_C(0xe45c10c4, 2a2b3b06), -210, -44},
+  {UINT64_2PART_C(0xaa242499, 697392d3), -183, -36},
+  {UINT64_2PART_C(0xfd87b5f2, 8300ca0e), -157, -28},
+  {UINT64_2PART_C(0xbce50864, 92111aeb), -130, -20},
+  {UINT64_2PART_C(0x8cbccc09, 6f5088cc), -103, -12},
+  {UINT64_2PART_C(0xd1b71758, e219652c), -77, -4},
+  {UINT64_2PART_C(0x9c400000, 00000000), -50, 4},
+  {UINT64_2PART_C(0xe8d4a510, 00000000), -24, 12},
+  {UINT64_2PART_C(0xad78ebc5, ac620000), 3, 20},
+  {UINT64_2PART_C(0x813f3978, f8940984), 30, 28},
+  {UINT64_2PART_C(0xc097ce7b, c90715b3), 56, 36},
+  {UINT64_2PART_C(0x8f7e32ce, 7bea5c70), 83, 44},
+  {UINT64_2PART_C(0xd5d238a4, abe98068), 109, 52},
+  {UINT64_2PART_C(0x9f4f2726, 179a2245), 136, 60},
+  {UINT64_2PART_C(0xed63a231, d4c4fb27), 162, 68},
+  {UINT64_2PART_C(0xb0de6538, 8cc8ada8), 189, 76},
+  {UINT64_2PART_C(0x83c7088e, 1aab65db), 216, 84},
+  {UINT64_2PART_C(0xc45d1df9, 42711d9a), 242, 92},
+  {UINT64_2PART_C(0x924d692c, a61be758), 269, 100},
+  {UINT64_2PART_C(0xda01ee64, 1a708dea), 295, 108},
+  {UINT64_2PART_C(0xa26da399, 9aef774a), 322, 116},
+  {UINT64_2PART_C(0xf209787b, b47d6b85), 348, 124},
+  {UINT64_2PART_C(0xb454e4a1, 79dd1877), 375, 132},
+  {UINT64_2PART_C(0x865b8692, 5b9bc5c2), 402, 140},
+  {UINT64_2PART_C(0xc83553c5, c8965d3d), 428, 148},
+  {UINT64_2PART_C(0x952ab45c, fa97a0b3), 455, 156},
+  {UINT64_2PART_C(0xde469fbd, 99a05fe3), 481, 164},
+  {UINT64_2PART_C(0xa59bc234, db398c25), 508, 172},
+  {UINT64_2PART_C(0xf6c69a72, a3989f5c), 534, 180},
+  {UINT64_2PART_C(0xb7dcbf53, 54e9bece), 561, 188},
+  {UINT64_2PART_C(0x88fcf317, f22241e2), 588, 196},
+  {UINT64_2PART_C(0xcc20ce9b, d35c78a5), 614, 204},
+  {UINT64_2PART_C(0x98165af3, 7b2153df), 641, 212},
+  {UINT64_2PART_C(0xe2a0b5dc, 971f303a), 667, 220},
+  {UINT64_2PART_C(0xa8d9d153, 5ce3b396), 694, 228},
+  {UINT64_2PART_C(0xfb9b7cd9, a4a7443c), 720, 236},
+  {UINT64_2PART_C(0xbb764c4c, a7a44410), 747, 244},
+  {UINT64_2PART_C(0x8bab8eef, b6409c1a), 774, 252},
+  {UINT64_2PART_C(0xd01fef10, a657842c), 800, 260},
+  {UINT64_2PART_C(0x9b10a4e5, e9913129), 827, 268},
+  {UINT64_2PART_C(0xe7109bfb, a19c0c9d), 853, 276},
+  {UINT64_2PART_C(0xac2820d9, 623bf429), 880, 284},
+  {UINT64_2PART_C(0x80444b5e, 7aa7cf85), 907, 292},
+  {UINT64_2PART_C(0xbf21e440, 03acdd2d), 933, 300},
+  {UINT64_2PART_C(0x8e679c2f, 5e44ff8f), 960, 308},
+  {UINT64_2PART_C(0xd433179d, 9c8cb841), 986, 316},
+  {UINT64_2PART_C(0x9e19db92, b4e31ba9), 1013, 324},
+  {UINT64_2PART_C(0xeb96bf6e, badf77d9), 1039, 332},
+  {UINT64_2PART_C(0xaf87023b, 9bf0ee6b), 1066, 340},
+};
+
+static const int kCachedPowersLength = ARRAY_SIZE(kCachedPowers);
+static const int kCachedPowersOffset = 348;  // -1 * the first decimal_exponent.
+static const double kD_1_LOG2_10 = 0.30102999566398114;  //  1 / lg(10)
+// Difference between the decimal exponents in the table above.
+const int PowersOfTenCache::kDecimalExponentDistance = 8;
+const int PowersOfTenCache::kMinDecimalExponent = -348;
+const int PowersOfTenCache::kMaxDecimalExponent = 340;
+
+void PowersOfTenCache::GetCachedPowerForBinaryExponentRange(
+    int min_exponent,
+    int max_exponent,
+    DiyFp* power,
+    int* decimal_exponent) {
+  int kQ = DiyFp::kSignificandSize;
+  double k = ceil((min_exponent + kQ - 1) * kD_1_LOG2_10);
+  int foo = kCachedPowersOffset;
+  int index =
+      (foo + static_cast<int>(k) - 1) / kDecimalExponentDistance + 1;
+  ASSERT(0 <= index && index < kCachedPowersLength);
+  CachedPower cached_power = kCachedPowers[index];
+  ASSERT(min_exponent <= cached_power.binary_exponent);
+  (void) max_exponent;  // Mark variable as used.
+  ASSERT(cached_power.binary_exponent <= max_exponent);
+  *decimal_exponent = cached_power.decimal_exponent;
+  *power = DiyFp(cached_power.significand, cached_power.binary_exponent);
+}
+
+
+void PowersOfTenCache::GetCachedPowerForDecimalExponent(int requested_exponent,
+                                                        DiyFp* power,
+                                                        int* found_exponent) {
+  ASSERT(kMinDecimalExponent <= requested_exponent);
+  ASSERT(requested_exponent < kMaxDecimalExponent + kDecimalExponentDistance);
+  int index =
+      (requested_exponent + kCachedPowersOffset) / kDecimalExponentDistance;
+  CachedPower cached_power = kCachedPowers[index];
+  *power = DiyFp(cached_power.significand, cached_power.binary_exponent);
+  *found_exponent = cached_power.decimal_exponent;
+  ASSERT(*found_exponent <= requested_exponent);
+  ASSERT(requested_exponent < *found_exponent + kDecimalExponentDistance);
+}
+
+}  // namespace double_conversion
diff --git a/base/poco/Foundation/src/cached-powers.h b/base/poco/Foundation/src/cached-powers.h
new file mode 100644
index 00000000000..61a50614cf1
--- /dev/null
+++ b/base/poco/Foundation/src/cached-powers.h
@@ -0,0 +1,64 @@
+// Copyright 2010 the V8 project authors. 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 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 Google Inc. 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 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
+// OWNER 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.
+
+#ifndef DOUBLE_CONVERSION_CACHED_POWERS_H_
+#define DOUBLE_CONVERSION_CACHED_POWERS_H_
+
+#include "diy-fp.h"
+
+namespace double_conversion {
+
+class PowersOfTenCache {
+ public:
+
+  // Not all powers of ten are cached. The decimal exponent of two neighboring
+  // cached numbers will differ by kDecimalExponentDistance.
+  static const int kDecimalExponentDistance;
+
+  static const int kMinDecimalExponent;
+  static const int kMaxDecimalExponent;
+
+  // Returns a cached power-of-ten with a binary exponent in the range
+  // [min_exponent; max_exponent] (boundaries included).
+  static void GetCachedPowerForBinaryExponentRange(int min_exponent,
+                                                   int max_exponent,
+                                                   DiyFp* power,
+                                                   int* decimal_exponent);
+
+  // Returns a cached power of ten x ~= 10^k such that
+  //   k <= decimal_exponent < k + kCachedPowersDecimalDistance.
+  // The given decimal_exponent must satisfy
+  //   kMinDecimalExponent <= requested_exponent, and
+  //   requested_exponent < kMaxDecimalExponent + kDecimalExponentDistance.
+  static void GetCachedPowerForDecimalExponent(int requested_exponent,
+                                               DiyFp* power,
+                                               int* found_exponent);
+};
+
+}  // namespace double_conversion
+
+#endif  // DOUBLE_CONVERSION_CACHED_POWERS_H_
diff --git a/base/poco/Foundation/src/compress.c b/base/poco/Foundation/src/compress.c
new file mode 100644
index 00000000000..e2db404abf8
--- /dev/null
+++ b/base/poco/Foundation/src/compress.c
@@ -0,0 +1,86 @@
+/* compress.c -- compress a memory buffer
+ * Copyright (C) 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#define ZLIB_INTERNAL
+#include "zlib.h"
+
+/* ===========================================================================
+     Compresses the source buffer into the destination buffer. The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer. Upon entry, destLen is the total size of the
+   destination buffer, which must be at least 0.1% larger than sourceLen plus
+   12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
+    Bytef *dest;
+    uLongf *destLen;
+    const Bytef *source;
+    uLong sourceLen;
+    int level;
+{
+    z_stream stream;
+    int err;
+    const uInt max = (uInt)-1;
+    uLong left;
+
+    left = *destLen;
+    *destLen = 0;
+
+    stream.zalloc = (alloc_func)0;
+    stream.zfree = (free_func)0;
+    stream.opaque = (voidpf)0;
+
+    err = deflateInit(&stream, level);
+    if (err != Z_OK) return err;
+
+    stream.next_out = dest;
+    stream.avail_out = 0;
+    stream.next_in = (z_const Bytef *)source;
+    stream.avail_in = 0;
+
+    do {
+        if (stream.avail_out == 0) {
+            stream.avail_out = left > (uLong)max ? max : (uInt)left;
+            left -= stream.avail_out;
+        }
+        if (stream.avail_in == 0) {
+            stream.avail_in = sourceLen > (uLong)max ? max : (uInt)sourceLen;
+            sourceLen -= stream.avail_in;
+        }
+        err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH);
+    } while (err == Z_OK);
+
+    *destLen = stream.total_out;
+    deflateEnd(&stream);
+    return err == Z_STREAM_END ? Z_OK : err;
+}
+
+/* ===========================================================================
+ */
+int ZEXPORT compress (dest, destLen, source, sourceLen)
+    Bytef *dest;
+    uLongf *destLen;
+    const Bytef *source;
+    uLong sourceLen;
+{
+    return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
+}
+
+/* ===========================================================================
+     If the default memLevel or windowBits for deflateInit() is changed, then
+   this function needs to be updated.
+ */
+uLong ZEXPORT compressBound (sourceLen)
+    uLong sourceLen;
+{
+    return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
+           (sourceLen >> 25) + 13;
+}
diff --git a/base/poco/Foundation/src/crc32.c b/base/poco/Foundation/src/crc32.c
new file mode 100644
index 00000000000..a0fe210ab1b
--- /dev/null
+++ b/base/poco/Foundation/src/crc32.c
@@ -0,0 +1,444 @@
+/* crc32.c -- compute the CRC-32 of a data stream
+ * Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * Thanks to Rodney Brown <rbrown64@csc.com.au> for his contribution of faster
+ * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing
+ * tables for updating the shift register in one step with three exclusive-ors
+ * instead of four steps with four exclusive-ors.  This results in about a
+ * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3.
+ */
+
+/* @(#) $Id$ */
+
+/*
+  Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore
+  protection on the static variables used to control the first-use generation
+  of the crc tables.  Therefore, if you #define DYNAMIC_CRC_TABLE, you should
+  first call get_crc_table() to initialize the tables before allowing more than
+  one thread to use crc32().
+
+  DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h.
+ */
+
+#ifdef MAKECRCH
+#  include <stdio.h>
+#  ifndef DYNAMIC_CRC_TABLE
+#    define DYNAMIC_CRC_TABLE
+#  endif /* !DYNAMIC_CRC_TABLE */
+#endif /* MAKECRCH */
+
+#include "zutil.h"      /* for STDC and FAR definitions */
+
+#define local static
+
+/* Definitions for doing the crc four data bytes at a time. */
+#if !defined(NOBYFOUR) && defined(Z_U4)
+#  define BYFOUR
+#endif
+#ifdef BYFOUR
+   local unsigned long crc32_little OF((unsigned long,
+                        const unsigned char FAR *, z_size_t));
+   local unsigned long crc32_big OF((unsigned long,
+                        const unsigned char FAR *, z_size_t));
+#  define TBLS 8
+#else
+#  define TBLS 1
+#endif /* BYFOUR */
+
+/* Local functions for crc concatenation */
+local unsigned long gf2_matrix_times OF((unsigned long *mat,
+                                         unsigned long vec));
+local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
+local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2));
+
+
+#ifdef DYNAMIC_CRC_TABLE
+
+local volatile int crc_table_empty = 1;
+local z_crc_t FAR crc_table[TBLS][256];
+local void make_crc_table OF((void));
+#ifdef MAKECRCH
+   local void write_table OF((FILE *, const z_crc_t FAR *));
+#endif /* MAKECRCH */
+/*
+  Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
+  x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
+
+  Polynomials over GF(2) are represented in binary, one bit per coefficient,
+  with the lowest powers in the most significant bit.  Then adding polynomials
+  is just exclusive-or, and multiplying a polynomial by x is a right shift by
+  one.  If we call the above polynomial p, and represent a byte as the
+  polynomial q, also with the lowest power in the most significant bit (so the
+  byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
+  where a mod b means the remainder after dividing a by b.
+
+  This calculation is done using the shift-register method of multiplying and
+  taking the remainder.  The register is initialized to zero, and for each
+  incoming bit, x^32 is added mod p to the register if the bit is a one (where
+  x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
+  x (which is shifting right by one and adding x^32 mod p if the bit shifted
+  out is a one).  We start with the highest power (least significant bit) of
+  q and repeat for all eight bits of q.
+
+  The first table is simply the CRC of all possible eight bit values.  This is
+  all the information needed to generate CRCs on data a byte at a time for all
+  combinations of CRC register values and incoming bytes.  The remaining tables
+  allow for word-at-a-time CRC calculation for both big-endian and little-
+  endian machines, where a word is four bytes.
+*/
+local void make_crc_table()
+{
+    z_crc_t c;
+    int n, k;
+    z_crc_t poly;                       /* polynomial exclusive-or pattern */
+    /* terms of polynomial defining this crc (except x^32): */
+    static volatile int first = 1;      /* flag to limit concurrent making */
+    static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26};
+
+    /* See if another task is already doing this (not thread-safe, but better
+       than nothing -- significantly reduces duration of vulnerability in
+       case the advice about DYNAMIC_CRC_TABLE is ignored) */
+    if (first) {
+        first = 0;
+
+        /* make exclusive-or pattern from polynomial (0xedb88320UL) */
+        poly = 0;
+        for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++)
+            poly |= (z_crc_t)1 << (31 - p[n]);
+
+        /* generate a crc for every 8-bit value */
+        for (n = 0; n < 256; n++) {
+            c = (z_crc_t)n;
+            for (k = 0; k < 8; k++)
+                c = c & 1 ? poly ^ (c >> 1) : c >> 1;
+            crc_table[0][n] = c;
+        }
+
+#ifdef BYFOUR
+        /* generate crc for each value followed by one, two, and three zeros,
+           and then the byte reversal of those as well as the first table */
+        for (n = 0; n < 256; n++) {
+            c = crc_table[0][n];
+            crc_table[4][n] = ZSWAP32(c);
+            for (k = 1; k < 4; k++) {
+                c = crc_table[0][c & 0xff] ^ (c >> 8);
+                crc_table[k][n] = c;
+                crc_table[k + 4][n] = ZSWAP32(c);
+            }
+        }
+#endif /* BYFOUR */
+
+        crc_table_empty = 0;
+    }
+    else {      /* not first */
+        /* wait for the other guy to finish (not efficient, but rare) */
+        while (crc_table_empty)
+            ;
+    }
+
+#ifdef MAKECRCH
+    /* write out CRC tables to crc32.h */
+    {
+        FILE *out;
+
+        out = fopen("crc32.h", "w");
+        if (out == NULL) return;
+        fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n");
+        fprintf(out, " * Generated automatically by crc32.c\n */\n\n");
+        fprintf(out, "local const z_crc_t FAR ");
+        fprintf(out, "crc_table[TBLS][256] =\n{\n  {\n");
+        write_table(out, crc_table[0]);
+#  ifdef BYFOUR
+        fprintf(out, "#ifdef BYFOUR\n");
+        for (k = 1; k < 8; k++) {
+            fprintf(out, "  },\n  {\n");
+            write_table(out, crc_table[k]);
+        }
+        fprintf(out, "#endif\n");
+#  endif /* BYFOUR */
+        fprintf(out, "  }\n};\n");
+        fclose(out);
+    }
+#endif /* MAKECRCH */
+}
+
+#ifdef MAKECRCH
+local void write_table(out, table)
+    FILE *out;
+    const z_crc_t FAR *table;
+{
+    int n;
+
+    for (n = 0; n < 256; n++)
+        fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : "    ",
+                (unsigned long)(table[n]),
+                n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", "));
+}
+#endif /* MAKECRCH */
+
+#else /* !DYNAMIC_CRC_TABLE */
+/* ========================================================================
+ * Tables of CRC-32s of all single-byte values, made by make_crc_table().
+ */
+#include "crc32.h"
+#endif /* DYNAMIC_CRC_TABLE */
+
+/* =========================================================================
+ * This function can be used by asm versions of crc32()
+ */
+const z_crc_t FAR * ZEXPORT get_crc_table()
+{
+#ifdef DYNAMIC_CRC_TABLE
+    if (crc_table_empty)
+        make_crc_table();
+#endif /* DYNAMIC_CRC_TABLE */
+    return (const z_crc_t FAR *)crc_table;
+}
+
+/* ========================================================================= */
+#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8)
+#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1
+
+/* ========================================================================= */
+unsigned long ZEXPORT crc32_z(crc, buf, len)
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    z_size_t len;
+{
+    if (buf == Z_NULL) return 0UL;
+
+#ifdef DYNAMIC_CRC_TABLE
+    if (crc_table_empty)
+        make_crc_table();
+#endif /* DYNAMIC_CRC_TABLE */
+
+#ifdef BYFOUR
+    if (sizeof(void *) == sizeof(ptrdiff_t)) {
+        z_crc_t endian;
+
+        endian = 1;
+        if (*((unsigned char *)(&endian)))
+            return crc32_little(crc, buf, len);
+        else
+            return crc32_big(crc, buf, len);
+    }
+#endif /* BYFOUR */
+    crc = crc ^ 0xffffffffUL;
+    while (len >= 8) {
+        DO8;
+        len -= 8;
+    }
+    if (len) do {
+        DO1;
+    } while (--len);
+    return crc ^ 0xffffffffUL;
+}
+
+/* ========================================================================= */
+unsigned long ZEXPORT crc32(crc, buf, len)
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    uInt len;
+{
+    return crc32_z(crc, buf, len);
+}
+
+#ifdef BYFOUR
+
+/*
+   This BYFOUR code accesses the passed unsigned char * buffer with a 32-bit
+   integer pointer type. This violates the strict aliasing rule, where a
+   compiler can assume, for optimization purposes, that two pointers to
+   fundamentally different types won't ever point to the same memory. This can
+   manifest as a problem only if one of the pointers is written to. This code
+   only reads from those pointers. So long as this code remains isolated in
+   this compilation unit, there won't be a problem. For this reason, this code
+   should not be copied and pasted into a compilation unit in which other code
+   writes to the buffer that is passed to these routines.
+ */
+
+/* ========================================================================= */
+#define DOLIT4 c ^= *buf4++; \
+        c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \
+            crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24]
+#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4
+
+/* ========================================================================= */
+local unsigned long crc32_little(crc, buf, len)
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    z_size_t len;
+{
+    register z_crc_t c;
+    register const z_crc_t FAR *buf4;
+
+    c = (z_crc_t)crc;
+    c = ~c;
+    while (len && ((ptrdiff_t)buf & 3)) {
+        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
+        len--;
+    }
+
+    buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
+    while (len >= 32) {
+        DOLIT32;
+        len -= 32;
+    }
+    while (len >= 4) {
+        DOLIT4;
+        len -= 4;
+    }
+    buf = (const unsigned char FAR *)buf4;
+
+    if (len) do {
+        c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8);
+    } while (--len);
+    c = ~c;
+    return (unsigned long)c;
+}
+
+/* ========================================================================= */
+#define DOBIG4 c ^= *buf4++; \
+        c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \
+            crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24]
+#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4
+
+/* ========================================================================= */
+local unsigned long crc32_big(crc, buf, len)
+    unsigned long crc;
+    const unsigned char FAR *buf;
+    z_size_t len;
+{
+    register z_crc_t c;
+    register const z_crc_t FAR *buf4;
+
+    c = ZSWAP32((z_crc_t)crc);
+    c = ~c;
+    while (len && ((ptrdiff_t)buf & 3)) {
+        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
+        len--;
+    }
+
+    buf4 = (const z_crc_t FAR *)(const void FAR *)buf;
+    while (len >= 32) {
+        DOBIG32;
+        len -= 32;
+    }
+    while (len >= 4) {
+        DOBIG4;
+        len -= 4;
+    }
+    buf = (const unsigned char FAR *)buf4;
+
+    if (len) do {
+        c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
+    } while (--len);
+    c = ~c;
+    return (unsigned long)(ZSWAP32(c));
+}
+
+#endif /* BYFOUR */
+
+#define GF2_DIM 32      /* dimension of GF(2) vectors (length of CRC) */
+
+/* ========================================================================= */
+local unsigned long gf2_matrix_times(mat, vec)
+    unsigned long *mat;
+    unsigned long vec;
+{
+    unsigned long sum;
+
+    sum = 0;
+    while (vec) {
+        if (vec & 1)
+            sum ^= *mat;
+        vec >>= 1;
+        mat++;
+    }
+    return sum;
+}
+
+/* ========================================================================= */
+local void gf2_matrix_square(square, mat)
+    unsigned long *square;
+    unsigned long *mat;
+{
+    int n;
+
+    for (n = 0; n < GF2_DIM; n++)
+        square[n] = gf2_matrix_times(mat, mat[n]);
+}
+
+/* ========================================================================= */
+local uLong crc32_combine_(crc1, crc2, len2)
+    uLong crc1;
+    uLong crc2;
+    z_off64_t len2;
+{
+    int n;
+    unsigned long row;
+    unsigned long even[GF2_DIM];    /* even-power-of-two zeros operator */
+    unsigned long odd[GF2_DIM];     /* odd-power-of-two zeros operator */
+
+    /* degenerate case (also disallow negative lengths) */
+    if (len2 <= 0)
+        return crc1;
+
+    /* put operator for one zero bit in odd */
+    odd[0] = 0xedb88320UL;          /* CRC-32 polynomial */
+    row = 1;
+    for (n = 1; n < GF2_DIM; n++) {
+        odd[n] = row;
+        row <<= 1;
+    }
+
+    /* put operator for two zero bits in even */
+    gf2_matrix_square(even, odd);
+
+    /* put operator for four zero bits in odd */
+    gf2_matrix_square(odd, even);
+
+    /* apply len2 zeros to crc1 (first square will put the operator for one
+       zero byte, eight zero bits, in even) */
+    do {
+        /* apply zeros operator for this bit of len2 */
+        gf2_matrix_square(even, odd);
+        if (len2 & 1)
+            crc1 = gf2_matrix_times(even, crc1);
+        len2 >>= 1;
+
+        /* if no more bits set, then done */
+        if (len2 == 0)
+            break;
+
+        /* another iteration of the loop with odd and even swapped */
+        gf2_matrix_square(odd, even);
+        if (len2 & 1)
+            crc1 = gf2_matrix_times(odd, crc1);
+        len2 >>= 1;
+
+        /* if no more bits set, then done */
+    } while (len2 != 0);
+
+    /* return combined crc */
+    crc1 ^= crc2;
+    return crc1;
+}
+
+/* ========================================================================= */
+uLong ZEXPORT crc32_combine(crc1, crc2, len2)
+    uLong crc1;
+    uLong crc2;
+    z_off_t len2;
+{
+    return crc32_combine_(crc1, crc2, len2);
+}
+
+uLong ZEXPORT crc32_combine64(crc1, crc2, len2)
+    uLong crc1;
+    uLong crc2;
+    z_off64_t len2;
+{
+    return crc32_combine_(crc1, crc2, len2);
+}
diff --git a/base/poco/Foundation/src/crc32.h b/base/poco/Foundation/src/crc32.h
new file mode 100644
index 00000000000..9e0c7781025
--- /dev/null
+++ b/base/poco/Foundation/src/crc32.h
@@ -0,0 +1,441 @@
+/* crc32.h -- tables for rapid CRC calculation
+ * Generated automatically by crc32.c
+ */
+
+local const z_crc_t FAR crc_table[TBLS][256] =
+{
+  {
+    0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
+    0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
+    0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
+    0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
+    0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
+    0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
+    0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
+    0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
+    0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
+    0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
+    0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
+    0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
+    0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
+    0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
+    0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
+    0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
+    0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
+    0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
+    0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
+    0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
+    0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
+    0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
+    0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
+    0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
+    0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
+    0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
+    0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
+    0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
+    0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
+    0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
+    0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
+    0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
+    0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
+    0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
+    0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
+    0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
+    0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
+    0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
+    0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
+    0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
+    0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
+    0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
+    0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
+    0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
+    0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
+    0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
+    0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
+    0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
+    0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
+    0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
+    0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
+    0x2d02ef8dUL
+#ifdef BYFOUR
+  },
+  {
+    0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL,
+    0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL,
+    0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL,
+    0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL,
+    0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL,
+    0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL,
+    0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL,
+    0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL,
+    0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL,
+    0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL,
+    0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL,
+    0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL,
+    0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL,
+    0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL,
+    0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL,
+    0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL,
+    0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL,
+    0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL,
+    0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL,
+    0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL,
+    0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL,
+    0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL,
+    0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL,
+    0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL,
+    0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL,
+    0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL,
+    0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL,
+    0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL,
+    0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL,
+    0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL,
+    0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL,
+    0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL,
+    0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL,
+    0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL,
+    0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL,
+    0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL,
+    0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL,
+    0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL,
+    0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL,
+    0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL,
+    0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL,
+    0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL,
+    0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL,
+    0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL,
+    0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL,
+    0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL,
+    0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL,
+    0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL,
+    0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL,
+    0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL,
+    0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL,
+    0x9324fd72UL
+  },
+  {
+    0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL,
+    0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL,
+    0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL,
+    0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL,
+    0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL,
+    0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL,
+    0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL,
+    0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL,
+    0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL,
+    0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL,
+    0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL,
+    0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL,
+    0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL,
+    0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL,
+    0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL,
+    0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL,
+    0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL,
+    0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL,
+    0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL,
+    0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL,
+    0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL,
+    0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL,
+    0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL,
+    0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL,
+    0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL,
+    0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL,
+    0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL,
+    0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL,
+    0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL,
+    0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL,
+    0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL,
+    0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL,
+    0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL,
+    0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL,
+    0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL,
+    0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL,
+    0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL,
+    0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL,
+    0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL,
+    0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL,
+    0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL,
+    0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL,
+    0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL,
+    0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL,
+    0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL,
+    0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL,
+    0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL,
+    0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL,
+    0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL,
+    0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL,
+    0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL,
+    0xbe9834edUL
+  },
+  {
+    0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL,
+    0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL,
+    0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL,
+    0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL,
+    0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL,
+    0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL,
+    0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL,
+    0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL,
+    0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL,
+    0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL,
+    0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL,
+    0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL,
+    0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL,
+    0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL,
+    0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL,
+    0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL,
+    0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL,
+    0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL,
+    0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL,
+    0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL,
+    0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL,
+    0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL,
+    0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL,
+    0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL,
+    0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL,
+    0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL,
+    0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL,
+    0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL,
+    0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL,
+    0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL,
+    0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL,
+    0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL,
+    0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL,
+    0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL,
+    0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL,
+    0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL,
+    0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL,
+    0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL,
+    0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL,
+    0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL,
+    0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL,
+    0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL,
+    0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL,
+    0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL,
+    0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL,
+    0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL,
+    0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL,
+    0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL,
+    0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL,
+    0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL,
+    0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL,
+    0xde0506f1UL
+  },
+  {
+    0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL,
+    0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL,
+    0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL,
+    0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL,
+    0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL,
+    0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL,
+    0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL,
+    0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL,
+    0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL,
+    0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL,
+    0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL,
+    0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL,
+    0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL,
+    0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL,
+    0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL,
+    0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL,
+    0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL,
+    0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL,
+    0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL,
+    0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL,
+    0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL,
+    0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL,
+    0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL,
+    0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL,
+    0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL,
+    0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL,
+    0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL,
+    0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL,
+    0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL,
+    0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL,
+    0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL,
+    0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL,
+    0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL,
+    0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL,
+    0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL,
+    0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL,
+    0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL,
+    0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL,
+    0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL,
+    0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL,
+    0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL,
+    0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL,
+    0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL,
+    0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL,
+    0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL,
+    0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL,
+    0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL,
+    0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL,
+    0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL,
+    0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL,
+    0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL,
+    0x8def022dUL
+  },
+  {
+    0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL,
+    0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL,
+    0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL,
+    0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL,
+    0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL,
+    0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL,
+    0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL,
+    0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL,
+    0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL,
+    0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL,
+    0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL,
+    0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL,
+    0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL,
+    0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL,
+    0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL,
+    0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL,
+    0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL,
+    0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL,
+    0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL,
+    0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL,
+    0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL,
+    0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL,
+    0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL,
+    0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL,
+    0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL,
+    0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL,
+    0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL,
+    0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL,
+    0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL,
+    0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL,
+    0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL,
+    0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL,
+    0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL,
+    0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL,
+    0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL,
+    0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL,
+    0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL,
+    0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL,
+    0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL,
+    0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL,
+    0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL,
+    0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL,
+    0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL,
+    0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL,
+    0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL,
+    0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL,
+    0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL,
+    0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL,
+    0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL,
+    0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL,
+    0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL,
+    0x72fd2493UL
+  },
+  {
+    0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL,
+    0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL,
+    0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL,
+    0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL,
+    0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL,
+    0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL,
+    0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL,
+    0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL,
+    0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL,
+    0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL,
+    0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL,
+    0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL,
+    0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL,
+    0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL,
+    0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL,
+    0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL,
+    0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL,
+    0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL,
+    0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL,
+    0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL,
+    0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL,
+    0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL,
+    0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL,
+    0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL,
+    0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL,
+    0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL,
+    0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL,
+    0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL,
+    0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL,
+    0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL,
+    0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL,
+    0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL,
+    0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL,
+    0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL,
+    0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL,
+    0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL,
+    0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL,
+    0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL,
+    0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL,
+    0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL,
+    0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL,
+    0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL,
+    0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL,
+    0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL,
+    0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL,
+    0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL,
+    0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL,
+    0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL,
+    0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL,
+    0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL,
+    0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL,
+    0xed3498beUL
+  },
+  {
+    0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL,
+    0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL,
+    0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL,
+    0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL,
+    0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL,
+    0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL,
+    0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL,
+    0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL,
+    0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL,
+    0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL,
+    0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL,
+    0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL,
+    0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL,
+    0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL,
+    0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL,
+    0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL,
+    0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL,
+    0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL,
+    0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL,
+    0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL,
+    0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL,
+    0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL,
+    0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL,
+    0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL,
+    0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL,
+    0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL,
+    0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL,
+    0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL,
+    0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL,
+    0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL,
+    0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL,
+    0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL,
+    0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL,
+    0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL,
+    0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL,
+    0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL,
+    0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL,
+    0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL,
+    0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL,
+    0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL,
+    0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL,
+    0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL,
+    0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL,
+    0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL,
+    0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL,
+    0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL,
+    0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL,
+    0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL,
+    0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL,
+    0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL,
+    0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL,
+    0xf10605deUL
+#endif
+  }
+};
diff --git a/base/poco/Foundation/src/deflate.c b/base/poco/Foundation/src/deflate.c
new file mode 100644
index 00000000000..1ec761448de
--- /dev/null
+++ b/base/poco/Foundation/src/deflate.c
@@ -0,0 +1,2163 @@
+/* deflate.c -- compress data using the deflation algorithm
+ * Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ *  ALGORITHM
+ *
+ *      The "deflation" process depends on being able to identify portions
+ *      of the input text which are identical to earlier input (within a
+ *      sliding window trailing behind the input currently being processed).
+ *
+ *      The most straightforward technique turns out to be the fastest for
+ *      most input files: try all possible matches and select the longest.
+ *      The key feature of this algorithm is that insertions into the string
+ *      dictionary are very simple and thus fast, and deletions are avoided
+ *      completely. Insertions are performed at each input character, whereas
+ *      string matches are performed only when the previous match ends. So it
+ *      is preferable to spend more time in matches to allow very fast string
+ *      insertions and avoid deletions. The matching algorithm for small
+ *      strings is inspired from that of Rabin & Karp. A brute force approach
+ *      is used to find longer strings when a small match has been found.
+ *      A similar algorithm is used in comic (by Jan-Mark Wams) and freeze
+ *      (by Leonid Broukhis).
+ *         A previous version of this file used a more sophisticated algorithm
+ *      (by Fiala and Greene) which is guaranteed to run in linear amortized
+ *      time, but has a larger average cost, uses more memory and is patented.
+ *      However the F&G algorithm may be faster for some highly redundant
+ *      files if the parameter max_chain_length (described below) is too large.
+ *
+ *  ACKNOWLEDGEMENTS
+ *
+ *      The idea of lazy evaluation of matches is due to Jan-Mark Wams, and
+ *      I found it in 'freeze' written by Leonid Broukhis.
+ *      Thanks to many people for bug reports and testing.
+ *
+ *  REFERENCES
+ *
+ *      Deutsch, L.P.,"DEFLATE Compressed Data Format Specification".
+ *      Available in http://tools.ietf.org/html/rfc1951
+ *
+ *      A description of the Rabin and Karp algorithm is given in the book
+ *         "Algorithms" by R. Sedgewick, Addison-Wesley, p252.
+ *
+ *      Fiala,E.R., and Greene,D.H.
+ *         Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595
+ *
+ */
+
+/* @(#) $Id$ */
+
+#include "deflate.h"
+
+const char deflate_copyright[] =
+   " deflate 1.2.11 Copyright 1995-2017 Jean-loup Gailly and Mark Adler ";
+/*
+  If you use the zlib library in a product, an acknowledgment is welcome
+  in the documentation of your product. If for some reason you cannot
+  include such an acknowledgment, I would appreciate that you keep this
+  copyright string in the executable of your product.
+ */
+
+/* ===========================================================================
+ *  Function prototypes.
+ */
+typedef enum {
+    need_more,      /* block not completed, need more input or more output */
+    block_done,     /* block flush performed */
+    finish_started, /* finish started, need only more output at next deflate */
+    finish_done     /* finish done, accept no more input or output */
+} block_state;
+
+typedef block_state (*compress_func) OF((deflate_state *s, int flush));
+/* Compression function. Returns the block state after the call. */
+
+local int deflateStateCheck      OF((z_streamp strm));
+local void slide_hash     OF((deflate_state *s));
+local void fill_window    OF((deflate_state *s));
+local block_state deflate_stored OF((deflate_state *s, int flush));
+local block_state deflate_fast   OF((deflate_state *s, int flush));
+#ifndef FASTEST
+local block_state deflate_slow   OF((deflate_state *s, int flush));
+#endif
+local block_state deflate_rle    OF((deflate_state *s, int flush));
+local block_state deflate_huff   OF((deflate_state *s, int flush));
+local void lm_init        OF((deflate_state *s));
+local void putShortMSB    OF((deflate_state *s, uInt b));
+local void flush_pending  OF((z_streamp strm));
+local unsigned read_buf   OF((z_streamp strm, Bytef *buf, unsigned size));
+#ifdef ASMV
+#  pragma message("Assembler code may have bugs -- use at your own risk")
+      void match_init OF((void)); /* asm code initialization */
+      uInt longest_match  OF((deflate_state *s, IPos cur_match));
+#else
+local uInt longest_match  OF((deflate_state *s, IPos cur_match));
+#endif
+
+#ifdef ZLIB_DEBUG
+local  void check_match OF((deflate_state *s, IPos start, IPos match,
+                            int length));
+#endif
+
+/* ===========================================================================
+ * Local data
+ */
+
+#define NIL 0
+/* Tail of hash chains */
+
+#ifndef TOO_FAR
+#  define TOO_FAR 4096
+#endif
+/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */
+
+/* Values for max_lazy_match, good_match and max_chain_length, depending on
+ * the desired pack level (0..9). The values given below have been tuned to
+ * exclude worst case performance for pathological files. Better values may be
+ * found for specific files.
+ */
+typedef struct config_s {
+   ush good_length; /* reduce lazy search above this match length */
+   ush max_lazy;    /* do not perform lazy search above this match length */
+   ush nice_length; /* quit search above this match length */
+   ush max_chain;
+   compress_func func;
+} config;
+
+#ifdef FASTEST
+local const config configuration_table[2] = {
+/*      good lazy nice chain */
+/* 0 */ {0,    0,  0,    0, deflate_stored},  /* store only */
+/* 1 */ {4,    4,  8,    4, deflate_fast}}; /* max speed, no lazy matches */
+#else
+local const config configuration_table[10] = {
+/*      good lazy nice chain */
+/* 0 */ {0,    0,  0,    0, deflate_stored},  /* store only */
+/* 1 */ {4,    4,  8,    4, deflate_fast}, /* max speed, no lazy matches */
+/* 2 */ {4,    5, 16,    8, deflate_fast},
+/* 3 */ {4,    6, 32,   32, deflate_fast},
+
+/* 4 */ {4,    4, 16,   16, deflate_slow},  /* lazy matches */
+/* 5 */ {8,   16, 32,   32, deflate_slow},
+/* 6 */ {8,   16, 128, 128, deflate_slow},
+/* 7 */ {8,   32, 128, 256, deflate_slow},
+/* 8 */ {32, 128, 258, 1024, deflate_slow},
+/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */
+#endif
+
+/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4
+ * For deflate_fast() (levels <= 3) good is ignored and lazy has a different
+ * meaning.
+ */
+
+/* rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH */
+#define RANK(f) (((f) * 2) - ((f) > 4 ? 9 : 0))
+
+/* ===========================================================================
+ * Update a hash value with the given input byte
+ * IN  assertion: all calls to UPDATE_HASH are made with consecutive input
+ *    characters, so that a running hash key can be computed from the previous
+ *    key instead of complete recalculation each time.
+ */
+#define UPDATE_HASH(s,h,c) (h = (((h)<<s->hash_shift) ^ (c)) & s->hash_mask)
+
+
+/* ===========================================================================
+ * Insert string str in the dictionary and set match_head to the previous head
+ * of the hash chain (the most recent string with same hash key). Return
+ * the previous length of the hash chain.
+ * If this file is compiled with -DFASTEST, the compression level is forced
+ * to 1, and no hash chains are maintained.
+ * IN  assertion: all calls to INSERT_STRING are made with consecutive input
+ *    characters and the first MIN_MATCH bytes of str are valid (except for
+ *    the last MIN_MATCH-1 bytes of the input file).
+ */
+#ifdef FASTEST
+#define INSERT_STRING(s, str, match_head) \
+   (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
+    match_head = s->head[s->ins_h], \
+    s->head[s->ins_h] = (Pos)(str))
+#else
+#define INSERT_STRING(s, str, match_head) \
+   (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \
+    match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \
+    s->head[s->ins_h] = (Pos)(str))
+#endif
+
+/* ===========================================================================
+ * Initialize the hash table (avoiding 64K overflow for 16 bit systems).
+ * prev[] will be initialized on the fly.
+ */
+#define CLEAR_HASH(s) \
+    s->head[s->hash_size-1] = NIL; \
+    zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head));
+
+/* ===========================================================================
+ * Slide the hash table when sliding the window down (could be avoided with 32
+ * bit values at the expense of memory usage). We slide even when level == 0 to
+ * keep the hash table consistent if we switch back to level > 0 later.
+ */
+local void slide_hash(s)
+    deflate_state *s;
+{
+    unsigned n, m;
+    Posf *p;
+    uInt wsize = s->w_size;
+
+    n = s->hash_size;
+    p = &s->head[n];
+    do {
+        m = *--p;
+        *p = (Pos)(m >= wsize ? m - wsize : NIL);
+    } while (--n);
+    n = wsize;
+#ifndef FASTEST
+    p = &s->prev[n];
+    do {
+        m = *--p;
+        *p = (Pos)(m >= wsize ? m - wsize : NIL);
+        /* If n is not on any hash chain, prev[n] is garbage but
+         * its value will never be used.
+         */
+    } while (--n);
+#endif
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateInit_(strm, level, version, stream_size)
+    z_streamp strm;
+    int level;
+    const char *version;
+    int stream_size;
+{
+    return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL,
+                         Z_DEFAULT_STRATEGY, version, stream_size);
+    /* To do: ignore strm->next_in if we use it as window */
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
+                  version, stream_size)
+    z_streamp strm;
+    int  level;
+    int  method;
+    int  windowBits;
+    int  memLevel;
+    int  strategy;
+    const char *version;
+    int stream_size;
+{
+    deflate_state *s;
+    int wrap = 1;
+    static const char my_version[] = ZLIB_VERSION;
+
+    ushf *overlay;
+    /* We overlay pending_buf and d_buf+l_buf. This works since the average
+     * output size for (length,distance) codes is <= 24 bits.
+     */
+
+    if (version == Z_NULL || version[0] != my_version[0] ||
+        stream_size != sizeof(z_stream)) {
+        return Z_VERSION_ERROR;
+    }
+    if (strm == Z_NULL) return Z_STREAM_ERROR;
+
+    strm->msg = Z_NULL;
+    if (strm->zalloc == (alloc_func)0) {
+#ifdef Z_SOLO
+        return Z_STREAM_ERROR;
+#else
+        strm->zalloc = zcalloc;
+        strm->opaque = (voidpf)0;
+#endif
+    }
+    if (strm->zfree == (free_func)0)
+#ifdef Z_SOLO
+        return Z_STREAM_ERROR;
+#else
+        strm->zfree = zcfree;
+#endif
+
+#ifdef FASTEST
+    if (level != 0) level = 1;
+#else
+    if (level == Z_DEFAULT_COMPRESSION) level = 6;
+#endif
+
+    if (windowBits < 0) { /* suppress zlib wrapper */
+        wrap = 0;
+        windowBits = -windowBits;
+    }
+#ifdef GZIP
+    else if (windowBits > 15) {
+        wrap = 2;       /* write gzip wrapper instead */
+        windowBits -= 16;
+    }
+#endif
+    if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED ||
+        windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
+        strategy < 0 || strategy > Z_FIXED || (windowBits == 8 && wrap != 1)) {
+        return Z_STREAM_ERROR;
+    }
+    if (windowBits == 8) windowBits = 9;  /* until 256-byte window bug fixed */
+    s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state));
+    if (s == Z_NULL) return Z_MEM_ERROR;
+    strm->state = (struct internal_state FAR *)s;
+    s->strm = strm;
+    s->status = INIT_STATE;     /* to pass state test in deflateReset() */
+
+    s->wrap = wrap;
+    s->gzhead = Z_NULL;
+    s->w_bits = (uInt)windowBits;
+    s->w_size = 1 << s->w_bits;
+    s->w_mask = s->w_size - 1;
+
+    s->hash_bits = (uInt)memLevel + 7;
+    s->hash_size = 1 << s->hash_bits;
+    s->hash_mask = s->hash_size - 1;
+    s->hash_shift =  ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH);
+
+    s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte));
+    s->prev   = (Posf *)  ZALLOC(strm, s->w_size, sizeof(Pos));
+    s->head   = (Posf *)  ZALLOC(strm, s->hash_size, sizeof(Pos));
+
+    s->high_water = 0;      /* nothing written to s->window yet */
+
+    s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */
+
+    overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);
+    s->pending_buf = (uchf *) overlay;
+    s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L);
+
+    if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL ||
+        s->pending_buf == Z_NULL) {
+        s->status = FINISH_STATE;
+        strm->msg = ERR_MSG(Z_MEM_ERROR);
+        deflateEnd (strm);
+        return Z_MEM_ERROR;
+    }
+    s->d_buf = overlay + s->lit_bufsize/sizeof(ush);
+    s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;
+
+    s->level = level;
+    s->strategy = strategy;
+    s->method = (Byte)method;
+
+    return deflateReset(strm);
+}
+
+/* =========================================================================
+ * Check for a valid deflate stream state. Return 0 if ok, 1 if not.
+ */
+local int deflateStateCheck (strm)
+    z_streamp strm;
+{
+    deflate_state *s;
+    if (strm == Z_NULL ||
+        strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
+        return 1;
+    s = strm->state;
+    if (s == Z_NULL || s->strm != strm || (s->status != INIT_STATE &&
+#ifdef GZIP
+                                           s->status != GZIP_STATE &&
+#endif
+                                           s->status != EXTRA_STATE &&
+                                           s->status != NAME_STATE &&
+                                           s->status != COMMENT_STATE &&
+                                           s->status != HCRC_STATE &&
+                                           s->status != BUSY_STATE &&
+                                           s->status != FINISH_STATE))
+        return 1;
+    return 0;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
+    z_streamp strm;
+    const Bytef *dictionary;
+    uInt  dictLength;
+{
+    deflate_state *s;
+    uInt str, n;
+    int wrap;
+    unsigned avail;
+    z_const unsigned char *next;
+
+    if (deflateStateCheck(strm) || dictionary == Z_NULL)
+        return Z_STREAM_ERROR;
+    s = strm->state;
+    wrap = s->wrap;
+    if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead)
+        return Z_STREAM_ERROR;
+
+    /* when using zlib wrappers, compute Adler-32 for provided dictionary */
+    if (wrap == 1)
+        strm->adler = adler32(strm->adler, dictionary, dictLength);
+    s->wrap = 0;                    /* avoid computing Adler-32 in read_buf */
+
+    /* if dictionary would fill window, just replace the history */
+    if (dictLength >= s->w_size) {
+        if (wrap == 0) {            /* already empty otherwise */
+            CLEAR_HASH(s);
+            s->strstart = 0;
+            s->block_start = 0L;
+            s->insert = 0;
+        }
+        dictionary += dictLength - s->w_size;  /* use the tail */
+        dictLength = s->w_size;
+    }
+
+    /* insert dictionary into window and hash */
+    avail = strm->avail_in;
+    next = strm->next_in;
+    strm->avail_in = dictLength;
+    strm->next_in = (z_const Bytef *)dictionary;
+    fill_window(s);
+    while (s->lookahead >= MIN_MATCH) {
+        str = s->strstart;
+        n = s->lookahead - (MIN_MATCH-1);
+        do {
+            UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);
+#ifndef FASTEST
+            s->prev[str & s->w_mask] = s->head[s->ins_h];
+#endif
+            s->head[s->ins_h] = (Pos)str;
+            str++;
+        } while (--n);
+        s->strstart = str;
+        s->lookahead = MIN_MATCH-1;
+        fill_window(s);
+    }
+    s->strstart += s->lookahead;
+    s->block_start = (long)s->strstart;
+    s->insert = s->lookahead;
+    s->lookahead = 0;
+    s->match_length = s->prev_length = MIN_MATCH-1;
+    s->match_available = 0;
+    strm->next_in = next;
+    strm->avail_in = avail;
+    s->wrap = wrap;
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateGetDictionary (strm, dictionary, dictLength)
+    z_streamp strm;
+    Bytef *dictionary;
+    uInt  *dictLength;
+{
+    deflate_state *s;
+    uInt len;
+
+    if (deflateStateCheck(strm))
+        return Z_STREAM_ERROR;
+    s = strm->state;
+    len = s->strstart + s->lookahead;
+    if (len > s->w_size)
+        len = s->w_size;
+    if (dictionary != Z_NULL && len)
+        zmemcpy(dictionary, s->window + s->strstart + s->lookahead - len, len);
+    if (dictLength != Z_NULL)
+        *dictLength = len;
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateResetKeep (strm)
+    z_streamp strm;
+{
+    deflate_state *s;
+
+    if (deflateStateCheck(strm)) {
+        return Z_STREAM_ERROR;
+    }
+
+    strm->total_in = strm->total_out = 0;
+    strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */
+    strm->data_type = Z_UNKNOWN;
+
+    s = (deflate_state *)strm->state;
+    s->pending = 0;
+    s->pending_out = s->pending_buf;
+
+    if (s->wrap < 0) {
+        s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */
+    }
+    s->status =
+#ifdef GZIP
+        s->wrap == 2 ? GZIP_STATE :
+#endif
+        s->wrap ? INIT_STATE : BUSY_STATE;
+    strm->adler =
+#ifdef GZIP
+        s->wrap == 2 ? crc32(0L, Z_NULL, 0) :
+#endif
+        adler32(0L, Z_NULL, 0);
+    s->last_flush = Z_NO_FLUSH;
+
+    _tr_init(s);
+
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateReset (strm)
+    z_streamp strm;
+{
+    int ret;
+
+    ret = deflateResetKeep(strm);
+    if (ret == Z_OK)
+        lm_init(strm->state);
+    return ret;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateSetHeader (strm, head)
+    z_streamp strm;
+    gz_headerp head;
+{
+    if (deflateStateCheck(strm) || strm->state->wrap != 2)
+        return Z_STREAM_ERROR;
+    strm->state->gzhead = head;
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflatePending (strm, pending, bits)
+    unsigned *pending;
+    int *bits;
+    z_streamp strm;
+{
+    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
+    if (pending != Z_NULL)
+        *pending = strm->state->pending;
+    if (bits != Z_NULL)
+        *bits = strm->state->bi_valid;
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflatePrime (strm, bits, value)
+    z_streamp strm;
+    int bits;
+    int value;
+{
+    deflate_state *s;
+    int put;
+
+    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
+    s = strm->state;
+    if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3))
+        return Z_BUF_ERROR;
+    do {
+        put = Buf_size - s->bi_valid;
+        if (put > bits)
+            put = bits;
+        s->bi_buf |= (ush)((value & ((1 << put) - 1)) << s->bi_valid);
+        s->bi_valid += put;
+        _tr_flush_bits(s);
+        value >>= put;
+        bits -= put;
+    } while (bits);
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateParams(strm, level, strategy)
+    z_streamp strm;
+    int level;
+    int strategy;
+{
+    deflate_state *s;
+    compress_func func;
+
+    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
+    s = strm->state;
+
+#ifdef FASTEST
+    if (level != 0) level = 1;
+#else
+    if (level == Z_DEFAULT_COMPRESSION) level = 6;
+#endif
+    if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
+        return Z_STREAM_ERROR;
+    }
+    func = configuration_table[s->level].func;
+
+    if ((strategy != s->strategy || func != configuration_table[level].func) &&
+        s->high_water) {
+        /* Flush the last buffer: */
+        int err = deflate(strm, Z_BLOCK);
+        if (err == Z_STREAM_ERROR)
+            return err;
+        if (strm->avail_out == 0)
+            return Z_BUF_ERROR;
+    }
+    if (s->level != level) {
+        if (s->level == 0 && s->matches != 0) {
+            if (s->matches == 1)
+                slide_hash(s);
+            else
+                CLEAR_HASH(s);
+            s->matches = 0;
+        }
+        s->level = level;
+        s->max_lazy_match   = configuration_table[level].max_lazy;
+        s->good_match       = configuration_table[level].good_length;
+        s->nice_match       = configuration_table[level].nice_length;
+        s->max_chain_length = configuration_table[level].max_chain;
+    }
+    s->strategy = strategy;
+    return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain)
+    z_streamp strm;
+    int good_length;
+    int max_lazy;
+    int nice_length;
+    int max_chain;
+{
+    deflate_state *s;
+
+    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
+    s = strm->state;
+    s->good_match = (uInt)good_length;
+    s->max_lazy_match = (uInt)max_lazy;
+    s->nice_match = nice_length;
+    s->max_chain_length = (uInt)max_chain;
+    return Z_OK;
+}
+
+/* =========================================================================
+ * For the default windowBits of 15 and memLevel of 8, this function returns
+ * a close to exact, as well as small, upper bound on the compressed size.
+ * They are coded as constants here for a reason--if the #define's are
+ * changed, then this function needs to be changed as well.  The return
+ * value for 15 and 8 only works for those exact settings.
+ *
+ * For any setting other than those defaults for windowBits and memLevel,
+ * the value returned is a conservative worst case for the maximum expansion
+ * resulting from using fixed blocks instead of stored blocks, which deflate
+ * can emit on compressed data for some combinations of the parameters.
+ *
+ * This function could be more sophisticated to provide closer upper bounds for
+ * every combination of windowBits and memLevel.  But even the conservative
+ * upper bound of about 14% expansion does not seem onerous for output buffer
+ * allocation.
+ */
+uLong ZEXPORT deflateBound(strm, sourceLen)
+    z_streamp strm;
+    uLong sourceLen;
+{
+    deflate_state *s;
+    uLong complen, wraplen;
+
+    /* conservative upper bound for compressed data */
+    complen = sourceLen +
+              ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5;
+
+    /* if can't get parameters, return conservative bound plus zlib wrapper */
+    if (deflateStateCheck(strm))
+        return complen + 6;
+
+    /* compute wrapper length */
+    s = strm->state;
+    switch (s->wrap) {
+    case 0:                                 /* raw deflate */
+        wraplen = 0;
+        break;
+    case 1:                                 /* zlib wrapper */
+        wraplen = 6 + (s->strstart ? 4 : 0);
+        break;
+#ifdef GZIP
+    case 2:                                 /* gzip wrapper */
+        wraplen = 18;
+        if (s->gzhead != Z_NULL) {          /* user-supplied gzip header */
+            Bytef *str;
+            if (s->gzhead->extra != Z_NULL)
+                wraplen += 2 + s->gzhead->extra_len;
+            str = s->gzhead->name;
+            if (str != Z_NULL)
+                do {
+                    wraplen++;
+                } while (*str++);
+            str = s->gzhead->comment;
+            if (str != Z_NULL)
+                do {
+                    wraplen++;
+                } while (*str++);
+            if (s->gzhead->hcrc)
+                wraplen += 2;
+        }
+        break;
+#endif
+    default:                                /* for compiler happiness */
+        wraplen = 6;
+    }
+
+    /* if not default parameters, return conservative bound */
+    if (s->w_bits != 15 || s->hash_bits != 8 + 7)
+        return complen + wraplen;
+
+    /* default settings: return tight bound for that case */
+    return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
+           (sourceLen >> 25) + 13 - 6 + wraplen;
+}
+
+/* =========================================================================
+ * Put a short in the pending buffer. The 16-bit value is put in MSB order.
+ * IN assertion: the stream state is correct and there is enough room in
+ * pending_buf.
+ */
+local void putShortMSB (s, b)
+    deflate_state *s;
+    uInt b;
+{
+    put_byte(s, (Byte)(b >> 8));
+    put_byte(s, (Byte)(b & 0xff));
+}
+
+/* =========================================================================
+ * Flush as much pending output as possible. All deflate() output, except for
+ * some deflate_stored() output, goes through this function so some
+ * applications may wish to modify it to avoid allocating a large
+ * strm->next_out buffer and copying into it. (See also read_buf()).
+ */
+local void flush_pending(strm)
+    z_streamp strm;
+{
+    unsigned len;
+    deflate_state *s = strm->state;
+
+    _tr_flush_bits(s);
+    len = s->pending;
+    if (len > strm->avail_out) len = strm->avail_out;
+    if (len == 0) return;
+
+    zmemcpy(strm->next_out, s->pending_out, len);
+    strm->next_out  += len;
+    s->pending_out  += len;
+    strm->total_out += len;
+    strm->avail_out -= len;
+    s->pending      -= len;
+    if (s->pending == 0) {
+        s->pending_out = s->pending_buf;
+    }
+}
+
+/* ===========================================================================
+ * Update the header CRC with the bytes s->pending_buf[beg..s->pending - 1].
+ */
+#define HCRC_UPDATE(beg) \
+    do { \
+        if (s->gzhead->hcrc && s->pending > (beg)) \
+            strm->adler = crc32(strm->adler, s->pending_buf + (beg), \
+                                s->pending - (beg)); \
+    } while (0)
+
+/* ========================================================================= */
+int ZEXPORT deflate (strm, flush)
+    z_streamp strm;
+    int flush;
+{
+    int old_flush; /* value of flush param for previous deflate call */
+    deflate_state *s;
+
+    if (deflateStateCheck(strm) || flush > Z_BLOCK || flush < 0) {
+        return Z_STREAM_ERROR;
+    }
+    s = strm->state;
+
+    if (strm->next_out == Z_NULL ||
+        (strm->avail_in != 0 && strm->next_in == Z_NULL) ||
+        (s->status == FINISH_STATE && flush != Z_FINISH)) {
+        ERR_RETURN(strm, Z_STREAM_ERROR);
+    }
+    if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
+
+    old_flush = s->last_flush;
+    s->last_flush = flush;
+
+    /* Flush as much pending output as possible */
+    if (s->pending != 0) {
+        flush_pending(strm);
+        if (strm->avail_out == 0) {
+            /* Since avail_out is 0, deflate will be called again with
+             * more output space, but possibly with both pending and
+             * avail_in equal to zero. There won't be anything to do,
+             * but this is not an error situation so make sure we
+             * return OK instead of BUF_ERROR at next call of deflate:
+             */
+            s->last_flush = -1;
+            return Z_OK;
+        }
+
+    /* Make sure there is something to do and avoid duplicate consecutive
+     * flushes. For repeated and useless calls with Z_FINISH, we keep
+     * returning Z_STREAM_END instead of Z_BUF_ERROR.
+     */
+    } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) &&
+               flush != Z_FINISH) {
+        ERR_RETURN(strm, Z_BUF_ERROR);
+    }
+
+    /* User must not provide more input after the first FINISH: */
+    if (s->status == FINISH_STATE && strm->avail_in != 0) {
+        ERR_RETURN(strm, Z_BUF_ERROR);
+    }
+
+    /* Write the header */
+    if (s->status == INIT_STATE) {
+        /* zlib header */
+        uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8;
+        uInt level_flags;
+
+        if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
+            level_flags = 0;
+        else if (s->level < 6)
+            level_flags = 1;
+        else if (s->level == 6)
+            level_flags = 2;
+        else
+            level_flags = 3;
+        header |= (level_flags << 6);
+        if (s->strstart != 0) header |= PRESET_DICT;
+        header += 31 - (header % 31);
+
+        putShortMSB(s, header);
+
+        /* Save the adler32 of the preset dictionary: */
+        if (s->strstart != 0) {
+            putShortMSB(s, (uInt)(strm->adler >> 16));
+            putShortMSB(s, (uInt)(strm->adler & 0xffff));
+        }
+        strm->adler = adler32(0L, Z_NULL, 0);
+        s->status = BUSY_STATE;
+
+        /* Compression must start with an empty pending buffer */
+        flush_pending(strm);
+        if (s->pending != 0) {
+            s->last_flush = -1;
+            return Z_OK;
+        }
+    }
+#ifdef GZIP
+    if (s->status == GZIP_STATE) {
+        /* gzip header */
+        strm->adler = crc32(0L, Z_NULL, 0);
+        put_byte(s, 31);
+        put_byte(s, 139);
+        put_byte(s, 8);
+        if (s->gzhead == Z_NULL) {
+            put_byte(s, 0);
+            put_byte(s, 0);
+            put_byte(s, 0);
+            put_byte(s, 0);
+            put_byte(s, 0);
+            put_byte(s, s->level == 9 ? 2 :
+                     (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
+                      4 : 0));
+            put_byte(s, OS_CODE);
+            s->status = BUSY_STATE;
+
+            /* Compression must start with an empty pending buffer */
+            flush_pending(strm);
+            if (s->pending != 0) {
+                s->last_flush = -1;
+                return Z_OK;
+            }
+        }
+        else {
+            put_byte(s, (s->gzhead->text ? 1 : 0) +
+                     (s->gzhead->hcrc ? 2 : 0) +
+                     (s->gzhead->extra == Z_NULL ? 0 : 4) +
+                     (s->gzhead->name == Z_NULL ? 0 : 8) +
+                     (s->gzhead->comment == Z_NULL ? 0 : 16)
+                     );
+            put_byte(s, (Byte)(s->gzhead->time & 0xff));
+            put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));
+            put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));
+            put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));
+            put_byte(s, s->level == 9 ? 2 :
+                     (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
+                      4 : 0));
+            put_byte(s, s->gzhead->os & 0xff);
+            if (s->gzhead->extra != Z_NULL) {
+                put_byte(s, s->gzhead->extra_len & 0xff);
+                put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);
+            }
+            if (s->gzhead->hcrc)
+                strm->adler = crc32(strm->adler, s->pending_buf,
+                                    s->pending);
+            s->gzindex = 0;
+            s->status = EXTRA_STATE;
+        }
+    }
+    if (s->status == EXTRA_STATE) {
+        if (s->gzhead->extra != Z_NULL) {
+            ulg beg = s->pending;   /* start of bytes to update crc */
+            uInt left = (s->gzhead->extra_len & 0xffff) - s->gzindex;
+            while (s->pending + left > s->pending_buf_size) {
+                uInt copy = s->pending_buf_size - s->pending;
+                zmemcpy(s->pending_buf + s->pending,
+                        s->gzhead->extra + s->gzindex, copy);
+                s->pending = s->pending_buf_size;
+                HCRC_UPDATE(beg);
+                s->gzindex += copy;
+                flush_pending(strm);
+                if (s->pending != 0) {
+                    s->last_flush = -1;
+                    return Z_OK;
+                }
+                beg = 0;
+                left -= copy;
+            }
+            zmemcpy(s->pending_buf + s->pending,
+                    s->gzhead->extra + s->gzindex, left);
+            s->pending += left;
+            HCRC_UPDATE(beg);
+            s->gzindex = 0;
+        }
+        s->status = NAME_STATE;
+    }
+    if (s->status == NAME_STATE) {
+        if (s->gzhead->name != Z_NULL) {
+            ulg beg = s->pending;   /* start of bytes to update crc */
+            int val;
+            do {
+                if (s->pending == s->pending_buf_size) {
+                    HCRC_UPDATE(beg);
+                    flush_pending(strm);
+                    if (s->pending != 0) {
+                        s->last_flush = -1;
+                        return Z_OK;
+                    }
+                    beg = 0;
+                }
+                val = s->gzhead->name[s->gzindex++];
+                put_byte(s, val);
+            } while (val != 0);
+            HCRC_UPDATE(beg);
+            s->gzindex = 0;
+        }
+        s->status = COMMENT_STATE;
+    }
+    if (s->status == COMMENT_STATE) {
+        if (s->gzhead->comment != Z_NULL) {
+            ulg beg = s->pending;   /* start of bytes to update crc */
+            int val;
+            do {
+                if (s->pending == s->pending_buf_size) {
+                    HCRC_UPDATE(beg);
+                    flush_pending(strm);
+                    if (s->pending != 0) {
+                        s->last_flush = -1;
+                        return Z_OK;
+                    }
+                    beg = 0;
+                }
+                val = s->gzhead->comment[s->gzindex++];
+                put_byte(s, val);
+            } while (val != 0);
+            HCRC_UPDATE(beg);
+        }
+        s->status = HCRC_STATE;
+    }
+    if (s->status == HCRC_STATE) {
+        if (s->gzhead->hcrc) {
+            if (s->pending + 2 > s->pending_buf_size) {
+                flush_pending(strm);
+                if (s->pending != 0) {
+                    s->last_flush = -1;
+                    return Z_OK;
+                }
+            }
+            put_byte(s, (Byte)(strm->adler & 0xff));
+            put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
+            strm->adler = crc32(0L, Z_NULL, 0);
+        }
+        s->status = BUSY_STATE;
+
+        /* Compression must start with an empty pending buffer */
+        flush_pending(strm);
+        if (s->pending != 0) {
+            s->last_flush = -1;
+            return Z_OK;
+        }
+    }
+#endif
+
+    /* Start a new block or continue the current one.
+     */
+    if (strm->avail_in != 0 || s->lookahead != 0 ||
+        (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
+        block_state bstate;
+
+        bstate = s->level == 0 ? deflate_stored(s, flush) :
+                 s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
+                 s->strategy == Z_RLE ? deflate_rle(s, flush) :
+                 (*(configuration_table[s->level].func))(s, flush);
+
+        if (bstate == finish_started || bstate == finish_done) {
+            s->status = FINISH_STATE;
+        }
+        if (bstate == need_more || bstate == finish_started) {
+            if (strm->avail_out == 0) {
+                s->last_flush = -1; /* avoid BUF_ERROR next call, see above */
+            }
+            return Z_OK;
+            /* If flush != Z_NO_FLUSH && avail_out == 0, the next call
+             * of deflate should use the same flush parameter to make sure
+             * that the flush is complete. So we don't have to output an
+             * empty block here, this will be done at next call. This also
+             * ensures that for a very small output buffer, we emit at most
+             * one empty block.
+             */
+        }
+        if (bstate == block_done) {
+            if (flush == Z_PARTIAL_FLUSH) {
+                _tr_align(s);
+            } else if (flush != Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */
+                _tr_stored_block(s, (char*)0, 0L, 0);
+                /* For a full flush, this empty block will be recognized
+                 * as a special marker by inflate_sync().
+                 */
+                if (flush == Z_FULL_FLUSH) {
+                    CLEAR_HASH(s);             /* forget history */
+                    if (s->lookahead == 0) {
+                        s->strstart = 0;
+                        s->block_start = 0L;
+                        s->insert = 0;
+                    }
+                }
+            }
+            flush_pending(strm);
+            if (strm->avail_out == 0) {
+              s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */
+              return Z_OK;
+            }
+        }
+    }
+
+    if (flush != Z_FINISH) return Z_OK;
+    if (s->wrap <= 0) return Z_STREAM_END;
+
+    /* Write the trailer */
+#ifdef GZIP
+    if (s->wrap == 2) {
+        put_byte(s, (Byte)(strm->adler & 0xff));
+        put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
+        put_byte(s, (Byte)((strm->adler >> 16) & 0xff));
+        put_byte(s, (Byte)((strm->adler >> 24) & 0xff));
+        put_byte(s, (Byte)(strm->total_in & 0xff));
+        put_byte(s, (Byte)((strm->total_in >> 8) & 0xff));
+        put_byte(s, (Byte)((strm->total_in >> 16) & 0xff));
+        put_byte(s, (Byte)((strm->total_in >> 24) & 0xff));
+    }
+    else
+#endif
+    {
+        putShortMSB(s, (uInt)(strm->adler >> 16));
+        putShortMSB(s, (uInt)(strm->adler & 0xffff));
+    }
+    flush_pending(strm);
+    /* If avail_out is zero, the application will call deflate again
+     * to flush the rest.
+     */
+    if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */
+    return s->pending != 0 ? Z_OK : Z_STREAM_END;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateEnd (strm)
+    z_streamp strm;
+{
+    int status;
+
+    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
+
+    status = strm->state->status;
+
+    /* Deallocate in reverse order of allocations: */
+    TRY_FREE(strm, strm->state->pending_buf);
+    TRY_FREE(strm, strm->state->head);
+    TRY_FREE(strm, strm->state->prev);
+    TRY_FREE(strm, strm->state->window);
+
+    ZFREE(strm, strm->state);
+    strm->state = Z_NULL;
+
+    return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
+}
+
+/* =========================================================================
+ * Copy the source state to the destination state.
+ * To simplify the source, this is not supported for 16-bit MSDOS (which
+ * doesn't have enough memory anyway to duplicate compression states).
+ */
+int ZEXPORT deflateCopy (dest, source)
+    z_streamp dest;
+    z_streamp source;
+{
+#ifdef MAXSEG_64K
+    return Z_STREAM_ERROR;
+#else
+    deflate_state *ds;
+    deflate_state *ss;
+    ushf *overlay;
+
+
+    if (deflateStateCheck(source) || dest == Z_NULL) {
+        return Z_STREAM_ERROR;
+    }
+
+    ss = source->state;
+
+    zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
+
+    ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state));
+    if (ds == Z_NULL) return Z_MEM_ERROR;
+    dest->state = (struct internal_state FAR *) ds;
+    zmemcpy((voidpf)ds, (voidpf)ss, sizeof(deflate_state));
+    ds->strm = dest;
+
+    ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte));
+    ds->prev   = (Posf *)  ZALLOC(dest, ds->w_size, sizeof(Pos));
+    ds->head   = (Posf *)  ZALLOC(dest, ds->hash_size, sizeof(Pos));
+    overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2);
+    ds->pending_buf = (uchf *) overlay;
+
+    if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL ||
+        ds->pending_buf == Z_NULL) {
+        deflateEnd (dest);
+        return Z_MEM_ERROR;
+    }
+    /* following zmemcpy do not work for 16-bit MSDOS */
+    zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte));
+    zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos));
+    zmemcpy((voidpf)ds->head, (voidpf)ss->head, ds->hash_size * sizeof(Pos));
+    zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size);
+
+    ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
+    ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush);
+    ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize;
+
+    ds->l_desc.dyn_tree = ds->dyn_ltree;
+    ds->d_desc.dyn_tree = ds->dyn_dtree;
+    ds->bl_desc.dyn_tree = ds->bl_tree;
+
+    return Z_OK;
+#endif /* MAXSEG_64K */
+}
+
+/* ===========================================================================
+ * Read a new buffer from the current input stream, update the adler32
+ * and total number of bytes read.  All deflate() input goes through
+ * this function so some applications may wish to modify it to avoid
+ * allocating a large strm->next_in buffer and copying from it.
+ * (See also flush_pending()).
+ */
+local unsigned read_buf(strm, buf, size)
+    z_streamp strm;
+    Bytef *buf;
+    unsigned size;
+{
+    unsigned len = strm->avail_in;
+
+    if (len > size) len = size;
+    if (len == 0) return 0;
+
+    strm->avail_in  -= len;
+
+    zmemcpy(buf, strm->next_in, len);
+    if (strm->state->wrap == 1) {
+        strm->adler = adler32(strm->adler, buf, len);
+    }
+#ifdef GZIP
+    else if (strm->state->wrap == 2) {
+        strm->adler = crc32(strm->adler, buf, len);
+    }
+#endif
+    strm->next_in  += len;
+    strm->total_in += len;
+
+    return len;
+}
+
+/* ===========================================================================
+ * Initialize the "longest match" routines for a new zlib stream
+ */
+local void lm_init (s)
+    deflate_state *s;
+{
+    s->window_size = (ulg)2L*s->w_size;
+
+    CLEAR_HASH(s);
+
+    /* Set the default configuration parameters:
+     */
+    s->max_lazy_match   = configuration_table[s->level].max_lazy;
+    s->good_match       = configuration_table[s->level].good_length;
+    s->nice_match       = configuration_table[s->level].nice_length;
+    s->max_chain_length = configuration_table[s->level].max_chain;
+
+    s->strstart = 0;
+    s->block_start = 0L;
+    s->lookahead = 0;
+    s->insert = 0;
+    s->match_length = s->prev_length = MIN_MATCH-1;
+    s->match_available = 0;
+    s->ins_h = 0;
+#ifndef FASTEST
+#ifdef ASMV
+    match_init(); /* initialize the asm code */
+#endif
+#endif
+}
+
+#ifndef FASTEST
+/* ===========================================================================
+ * Set match_start to the longest match starting at the given string and
+ * return its length. Matches shorter or equal to prev_length are discarded,
+ * in which case the result is equal to prev_length and match_start is
+ * garbage.
+ * IN assertions: cur_match is the head of the hash chain for the current
+ *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1
+ * OUT assertion: the match length is not greater than s->lookahead.
+ */
+#ifndef ASMV
+/* For 80x86 and 680x0, an optimized version will be provided in match.asm or
+ * match.S. The code will be functionally equivalent.
+ */
+local uInt longest_match(s, cur_match)
+    deflate_state *s;
+    IPos cur_match;                             /* current match */
+{
+    unsigned chain_length = s->max_chain_length;/* max hash chain length */
+    register Bytef *scan = s->window + s->strstart; /* current string */
+    register Bytef *match;                      /* matched string */
+    register int len;                           /* length of current match */
+    int best_len = (int)s->prev_length;         /* best match length so far */
+    int nice_match = s->nice_match;             /* stop if match long enough */
+    IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
+        s->strstart - (IPos)MAX_DIST(s) : NIL;
+    /* Stop when cur_match becomes <= limit. To simplify the code,
+     * we prevent matches with the string of window index 0.
+     */
+    Posf *prev = s->prev;
+    uInt wmask = s->w_mask;
+
+#ifdef UNALIGNED_OK
+    /* Compare two bytes at a time. Note: this is not always beneficial.
+     * Try with and without -DUNALIGNED_OK to check.
+     */
+    register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
+    register ush scan_start = *(ushf*)scan;
+    register ush scan_end   = *(ushf*)(scan+best_len-1);
+#else
+    register Bytef *strend = s->window + s->strstart + MAX_MATCH;
+    register Byte scan_end1  = scan[best_len-1];
+    register Byte scan_end   = scan[best_len];
+#endif
+
+    /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
+     * It is easy to get rid of this optimization if necessary.
+     */
+    Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
+
+    /* Do not waste too much time if we already have a good match: */
+    if (s->prev_length >= s->good_match) {
+        chain_length >>= 2;
+    }
+    /* Do not look for matches beyond the end of the input. This is necessary
+     * to make deflate deterministic.
+     */
+    if ((uInt)nice_match > s->lookahead) nice_match = (int)s->lookahead;
+
+    Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
+
+    do {
+        Assert(cur_match < s->strstart, "no future");
+        match = s->window + cur_match;
+
+        /* Skip to next match if the match length cannot increase
+         * or if the match length is less than 2.  Note that the checks below
+         * for insufficient lookahead only occur occasionally for performance
+         * reasons.  Therefore uninitialized memory will be accessed, and
+         * conditional jumps will be made that depend on those values.
+         * However the length of the match is limited to the lookahead, so
+         * the output of deflate is not affected by the uninitialized values.
+         */
+#if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
+        /* This code assumes sizeof(unsigned short) == 2. Do not use
+         * UNALIGNED_OK if your compiler uses a different size.
+         */
+        if (*(ushf*)(match+best_len-1) != scan_end ||
+            *(ushf*)match != scan_start) continue;
+
+        /* It is not necessary to compare scan[2] and match[2] since they are
+         * always equal when the other bytes match, given that the hash keys
+         * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
+         * strstart+3, +5, ... up to strstart+257. We check for insufficient
+         * lookahead only every 4th comparison; the 128th check will be made
+         * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
+         * necessary to put more guard bytes at the end of the window, or
+         * to check more often for insufficient lookahead.
+         */
+        Assert(scan[2] == match[2], "scan[2]?");
+        scan++, match++;
+        do {
+        } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+                 *(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
+                 scan < strend);
+        /* The funny "do {}" generates better code on most compilers */
+
+        /* Here, scan <= window+strstart+257 */
+        Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
+        if (*scan == *match) scan++;
+
+        len = (MAX_MATCH - 1) - (int)(strend-scan);
+        scan = strend - (MAX_MATCH-1);
+
+#else /* UNALIGNED_OK */
+
+        if (match[best_len]   != scan_end  ||
+            match[best_len-1] != scan_end1 ||
+            *match            != *scan     ||
+            *++match          != scan[1])      continue;
+
+        /* The check at best_len-1 can be removed because it will be made
+         * again later. (This heuristic is not always a win.)
+         * It is not necessary to compare scan[2] and match[2] since they
+         * are always equal when the other bytes match, given that
+         * the hash keys are equal and that HASH_BITS >= 8.
+         */
+        scan += 2, match++;
+        Assert(*scan == *match, "match[2]?");
+
+        /* We check for insufficient lookahead only every 8th comparison;
+         * the 256th check will be made at strstart+258.
+         */
+        do {
+        } while (*++scan == *++match && *++scan == *++match &&
+                 *++scan == *++match && *++scan == *++match &&
+                 *++scan == *++match && *++scan == *++match &&
+                 *++scan == *++match && *++scan == *++match &&
+                 scan < strend);
+
+        Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
+
+        len = MAX_MATCH - (int)(strend - scan);
+        scan = strend - MAX_MATCH;
+
+#endif /* UNALIGNED_OK */
+
+        if (len > best_len) {
+            s->match_start = cur_match;
+            best_len = len;
+            if (len >= nice_match) break;
+#ifdef UNALIGNED_OK
+            scan_end = *(ushf*)(scan+best_len-1);
+#else
+            scan_end1  = scan[best_len-1];
+            scan_end   = scan[best_len];
+#endif
+        }
+    } while ((cur_match = prev[cur_match & wmask]) > limit
+             && --chain_length != 0);
+
+    if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
+    return s->lookahead;
+}
+#endif /* ASMV */
+
+#else /* FASTEST */
+
+/* ---------------------------------------------------------------------------
+ * Optimized version for FASTEST only
+ */
+local uInt longest_match(s, cur_match)
+    deflate_state *s;
+    IPos cur_match;                             /* current match */
+{
+    register Bytef *scan = s->window + s->strstart; /* current string */
+    register Bytef *match;                       /* matched string */
+    register int len;                           /* length of current match */
+    register Bytef *strend = s->window + s->strstart + MAX_MATCH;
+
+    /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
+     * It is easy to get rid of this optimization if necessary.
+     */
+    Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
+
+    Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
+
+    Assert(cur_match < s->strstart, "no future");
+
+    match = s->window + cur_match;
+
+    /* Return failure if the match length is less than 2:
+     */
+    if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1;
+
+    /* The check at best_len-1 can be removed because it will be made
+     * again later. (This heuristic is not always a win.)
+     * It is not necessary to compare scan[2] and match[2] since they
+     * are always equal when the other bytes match, given that
+     * the hash keys are equal and that HASH_BITS >= 8.
+     */
+    scan += 2, match += 2;
+    Assert(*scan == *match, "match[2]?");
+
+    /* We check for insufficient lookahead only every 8th comparison;
+     * the 256th check will be made at strstart+258.
+     */
+    do {
+    } while (*++scan == *++match && *++scan == *++match &&
+             *++scan == *++match && *++scan == *++match &&
+             *++scan == *++match && *++scan == *++match &&
+             *++scan == *++match && *++scan == *++match &&
+             scan < strend);
+
+    Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
+
+    len = MAX_MATCH - (int)(strend - scan);
+
+    if (len < MIN_MATCH) return MIN_MATCH - 1;
+
+    s->match_start = cur_match;
+    return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead;
+}
+
+#endif /* FASTEST */
+
+#ifdef ZLIB_DEBUG
+
+#define EQUAL 0
+/* result of memcmp for equal strings */
+
+/* ===========================================================================
+ * Check that the match at match_start is indeed a match.
+ */
+local void check_match(s, start, match, length)
+    deflate_state *s;
+    IPos start, match;
+    int length;
+{
+    /* check that the match is indeed a match */
+    if (zmemcmp(s->window + match,
+                s->window + start, length) != EQUAL) {
+        fprintf(stderr, " start %u, match %u, length %d\n",
+                start, match, length);
+        do {
+            fprintf(stderr, "%c%c", s->window[match++], s->window[start++]);
+        } while (--length != 0);
+        z_error("invalid match");
+    }
+    if (z_verbose > 1) {
+        fprintf(stderr,"\\[%d,%d]", start-match, length);
+        do { putc(s->window[start++], stderr); } while (--length != 0);
+    }
+}
+#else
+#  define check_match(s, start, match, length)
+#endif /* ZLIB_DEBUG */
+
+/* ===========================================================================
+ * Fill the window when the lookahead becomes insufficient.
+ * Updates strstart and lookahead.
+ *
+ * IN assertion: lookahead < MIN_LOOKAHEAD
+ * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD
+ *    At least one byte has been read, or avail_in == 0; reads are
+ *    performed for at least two bytes (required for the zip translate_eol
+ *    option -- not supported here).
+ */
+local void fill_window(s)
+    deflate_state *s;
+{
+    unsigned n;
+    unsigned more;    /* Amount of free space at the end of the window. */
+    uInt wsize = s->w_size;
+
+    Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead");
+
+    do {
+        more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart);
+
+        /* Deal with !@#$% 64K limit: */
+        if (sizeof(int) <= 2) {
+            if (more == 0 && s->strstart == 0 && s->lookahead == 0) {
+                more = wsize;
+
+            } else if (more == (unsigned)(-1)) {
+                /* Very unlikely, but possible on 16 bit machine if
+                 * strstart == 0 && lookahead == 1 (input done a byte at time)
+                 */
+                more--;
+            }
+        }
+
+        /* If the window is almost full and there is insufficient lookahead,
+         * move the upper half to the lower one to make room in the upper half.
+         */
+        if (s->strstart >= wsize+MAX_DIST(s)) {
+
+            zmemcpy(s->window, s->window+wsize, (unsigned)wsize - more);
+            s->match_start -= wsize;
+            s->strstart    -= wsize; /* we now have strstart >= MAX_DIST */
+            s->block_start -= (long) wsize;
+            slide_hash(s);
+            more += wsize;
+        }
+        if (s->strm->avail_in == 0) break;
+
+        /* If there was no sliding:
+         *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&
+         *    more == window_size - lookahead - strstart
+         * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)
+         * => more >= window_size - 2*WSIZE + 2
+         * In the BIG_MEM or MMAP case (not yet supported),
+         *   window_size == input_size + MIN_LOOKAHEAD  &&
+         *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.
+         * Otherwise, window_size == 2*WSIZE so more >= 2.
+         * If there was sliding, more >= WSIZE. So in all cases, more >= 2.
+         */
+        Assert(more >= 2, "more < 2");
+
+        n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more);
+        s->lookahead += n;
+
+        /* Initialize the hash value now that we have some input: */
+        if (s->lookahead + s->insert >= MIN_MATCH) {
+            uInt str = s->strstart - s->insert;
+            s->ins_h = s->window[str];
+            UPDATE_HASH(s, s->ins_h, s->window[str + 1]);
+#if MIN_MATCH != 3
+            Call UPDATE_HASH() MIN_MATCH-3 more times
+#endif
+            while (s->insert) {
+                UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]);
+#ifndef FASTEST
+                s->prev[str & s->w_mask] = s->head[s->ins_h];
+#endif
+                s->head[s->ins_h] = (Pos)str;
+                str++;
+                s->insert--;
+                if (s->lookahead + s->insert < MIN_MATCH)
+                    break;
+            }
+        }
+        /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,
+         * but this is not important since only literal bytes will be emitted.
+         */
+
+    } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0);
+
+    /* If the WIN_INIT bytes after the end of the current data have never been
+     * written, then zero those bytes in order to avoid memory check reports of
+     * the use of uninitialized (or uninitialised as Julian writes) bytes by
+     * the longest match routines.  Update the high water mark for the next
+     * time through here.  WIN_INIT is set to MAX_MATCH since the longest match
+     * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.
+     */
+    if (s->high_water < s->window_size) {
+        ulg curr = s->strstart + (ulg)(s->lookahead);
+        ulg init;
+
+        if (s->high_water < curr) {
+            /* Previous high water mark below current data -- zero WIN_INIT
+             * bytes or up to end of window, whichever is less.
+             */
+            init = s->window_size - curr;
+            if (init > WIN_INIT)
+                init = WIN_INIT;
+            zmemzero(s->window + curr, (unsigned)init);
+            s->high_water = curr + init;
+        }
+        else if (s->high_water < (ulg)curr + WIN_INIT) {
+            /* High water mark at or above current data, but below current data
+             * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up
+             * to end of window, whichever is less.
+             */
+            init = (ulg)curr + WIN_INIT - s->high_water;
+            if (init > s->window_size - s->high_water)
+                init = s->window_size - s->high_water;
+            zmemzero(s->window + s->high_water, (unsigned)init);
+            s->high_water += init;
+        }
+    }
+
+    Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,
+           "not enough room for search");
+}
+
+/* ===========================================================================
+ * Flush the current block, with given end-of-file flag.
+ * IN assertion: strstart is set to the end of the current match.
+ */
+#define FLUSH_BLOCK_ONLY(s, last) { \
+   _tr_flush_block(s, (s->block_start >= 0L ? \
+                   (charf *)&s->window[(unsigned)s->block_start] : \
+                   (charf *)Z_NULL), \
+                (ulg)((long)s->strstart - s->block_start), \
+                (last)); \
+   s->block_start = s->strstart; \
+   flush_pending(s->strm); \
+   Tracev((stderr,"[FLUSH]")); \
+}
+
+/* Same but force premature exit if necessary. */
+#define FLUSH_BLOCK(s, last) { \
+   FLUSH_BLOCK_ONLY(s, last); \
+   if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \
+}
+
+/* Maximum stored block length in deflate format (not including header). */
+#define MAX_STORED 65535
+
+/* Minimum of a and b. */
+#define MIN(a, b) ((a) > (b) ? (b) : (a))
+
+/* ===========================================================================
+ * Copy without compression as much as possible from the input stream, return
+ * the current block state.
+ *
+ * In case deflateParams() is used to later switch to a non-zero compression
+ * level, s->matches (otherwise unused when storing) keeps track of the number
+ * of hash table slides to perform. If s->matches is 1, then one hash table
+ * slide will be done when switching. If s->matches is 2, the maximum value
+ * allowed here, then the hash table will be cleared, since two or more slides
+ * is the same as a clear.
+ *
+ * deflate_stored() is written to minimize the number of times an input byte is
+ * copied. It is most efficient with large input and output buffers, which
+ * maximizes the opportunites to have a single copy from next_in to next_out.
+ */
+local block_state deflate_stored(s, flush)
+    deflate_state *s;
+    int flush;
+{
+    /* Smallest worthy block size when not flushing or finishing. By default
+     * this is 32K. This can be as small as 507 bytes for memLevel == 1. For
+     * large input and output buffers, the stored block size will be larger.
+     */
+    unsigned min_block = MIN(s->pending_buf_size - 5, s->w_size);
+
+    /* Copy as many min_block or larger stored blocks directly to next_out as
+     * possible. If flushing, copy the remaining available input to next_out as
+     * stored blocks, if there is enough space.
+     */
+    unsigned len, left, have, last = 0;
+    unsigned used = s->strm->avail_in;
+    do {
+        /* Set len to the maximum size block that we can copy directly with the
+         * available input data and output space. Set left to how much of that
+         * would be copied from what's left in the window.
+         */
+        len = MAX_STORED;       /* maximum deflate stored block length */
+        have = (s->bi_valid + 42) >> 3;         /* number of header bytes */
+        if (s->strm->avail_out < have)          /* need room for header */
+            break;
+            /* maximum stored block length that will fit in avail_out: */
+        have = s->strm->avail_out - have;
+        left = s->strstart - s->block_start;    /* bytes left in window */
+        if (len > (ulg)left + s->strm->avail_in)
+            len = left + s->strm->avail_in;     /* limit len to the input */
+        if (len > have)
+            len = have;                         /* limit len to the output */
+
+        /* If the stored block would be less than min_block in length, or if
+         * unable to copy all of the available input when flushing, then try
+         * copying to the window and the pending buffer instead. Also don't
+         * write an empty block when flushing -- deflate() does that.
+         */
+        if (len < min_block && ((len == 0 && flush != Z_FINISH) ||
+                                flush == Z_NO_FLUSH ||
+                                len != left + s->strm->avail_in))
+            break;
+
+        /* Make a dummy stored block in pending to get the header bytes,
+         * including any pending bits. This also updates the debugging counts.
+         */
+        last = flush == Z_FINISH && len == left + s->strm->avail_in ? 1 : 0;
+        _tr_stored_block(s, (char *)0, 0L, last);
+
+        /* Replace the lengths in the dummy stored block with len. */
+        s->pending_buf[s->pending - 4] = len;
+        s->pending_buf[s->pending - 3] = len >> 8;
+        s->pending_buf[s->pending - 2] = ~len;
+        s->pending_buf[s->pending - 1] = ~len >> 8;
+
+        /* Write the stored block header bytes. */
+        flush_pending(s->strm);
+
+#ifdef ZLIB_DEBUG
+        /* Update debugging counts for the data about to be copied. */
+        s->compressed_len += len << 3;
+        s->bits_sent += len << 3;
+#endif
+
+        /* Copy uncompressed bytes from the window to next_out. */
+        if (left) {
+            if (left > len)
+                left = len;
+            zmemcpy(s->strm->next_out, s->window + s->block_start, left);
+            s->strm->next_out += left;
+            s->strm->avail_out -= left;
+            s->strm->total_out += left;
+            s->block_start += left;
+            len -= left;
+        }
+
+        /* Copy uncompressed bytes directly from next_in to next_out, updating
+         * the check value.
+         */
+        if (len) {
+            read_buf(s->strm, s->strm->next_out, len);
+            s->strm->next_out += len;
+            s->strm->avail_out -= len;
+            s->strm->total_out += len;
+        }
+    } while (last == 0);
+
+    /* Update the sliding window with the last s->w_size bytes of the copied
+     * data, or append all of the copied data to the existing window if less
+     * than s->w_size bytes were copied. Also update the number of bytes to
+     * insert in the hash tables, in the event that deflateParams() switches to
+     * a non-zero compression level.
+     */
+    used -= s->strm->avail_in;      /* number of input bytes directly copied */
+    if (used) {
+        /* If any input was used, then no unused input remains in the window,
+         * therefore s->block_start == s->strstart.
+         */
+        if (used >= s->w_size) {    /* supplant the previous history */
+            s->matches = 2;         /* clear hash */
+            zmemcpy(s->window, s->strm->next_in - s->w_size, s->w_size);
+            s->strstart = s->w_size;
+        }
+        else {
+            if (s->window_size - s->strstart <= used) {
+                /* Slide the window down. */
+                s->strstart -= s->w_size;
+                zmemcpy(s->window, s->window + s->w_size, s->strstart);
+                if (s->matches < 2)
+                    s->matches++;   /* add a pending slide_hash() */
+            }
+            zmemcpy(s->window + s->strstart, s->strm->next_in - used, used);
+            s->strstart += used;
+        }
+        s->block_start = s->strstart;
+        s->insert += MIN(used, s->w_size - s->insert);
+    }
+    if (s->high_water < s->strstart)
+        s->high_water = s->strstart;
+
+    /* If the last block was written to next_out, then done. */
+    if (last)
+        return finish_done;
+
+    /* If flushing and all input has been consumed, then done. */
+    if (flush != Z_NO_FLUSH && flush != Z_FINISH &&
+        s->strm->avail_in == 0 && (long)s->strstart == s->block_start)
+        return block_done;
+
+    /* Fill the window with any remaining input. */
+    have = s->window_size - s->strstart - 1;
+    if (s->strm->avail_in > have && s->block_start >= (long)s->w_size) {
+        /* Slide the window down. */
+        s->block_start -= s->w_size;
+        s->strstart -= s->w_size;
+        zmemcpy(s->window, s->window + s->w_size, s->strstart);
+        if (s->matches < 2)
+            s->matches++;           /* add a pending slide_hash() */
+        have += s->w_size;          /* more space now */
+    }
+    if (have > s->strm->avail_in)
+        have = s->strm->avail_in;
+    if (have) {
+        read_buf(s->strm, s->window + s->strstart, have);
+        s->strstart += have;
+    }
+    if (s->high_water < s->strstart)
+        s->high_water = s->strstart;
+
+    /* There was not enough avail_out to write a complete worthy or flushed
+     * stored block to next_out. Write a stored block to pending instead, if we
+     * have enough input for a worthy block, or if flushing and there is enough
+     * room for the remaining input as a stored block in the pending buffer.
+     */
+    have = (s->bi_valid + 42) >> 3;         /* number of header bytes */
+        /* maximum stored block length that will fit in pending: */
+    have = MIN(s->pending_buf_size - have, MAX_STORED);
+    min_block = MIN(have, s->w_size);
+    left = s->strstart - s->block_start;
+    if (left >= min_block ||
+        ((left || flush == Z_FINISH) && flush != Z_NO_FLUSH &&
+         s->strm->avail_in == 0 && left <= have)) {
+        len = MIN(left, have);
+        last = flush == Z_FINISH && s->strm->avail_in == 0 &&
+               len == left ? 1 : 0;
+        _tr_stored_block(s, (charf *)s->window + s->block_start, len, last);
+        s->block_start += len;
+        flush_pending(s->strm);
+    }
+
+    /* We've done all we can with the available input and output. */
+    return last ? finish_started : need_more;
+}
+
+/* ===========================================================================
+ * Compress as much as possible from the input stream, return the current
+ * block state.
+ * This function does not perform lazy evaluation of matches and inserts
+ * new strings in the dictionary only for unmatched strings or for short
+ * matches. It is used only for the fast compression options.
+ */
+local block_state deflate_fast(s, flush)
+    deflate_state *s;
+    int flush;
+{
+    IPos hash_head;       /* head of the hash chain */
+    int bflush;           /* set if current block must be flushed */
+
+    for (;;) {
+        /* Make sure that we always have enough lookahead, except
+         * at the end of the input file. We need MAX_MATCH bytes
+         * for the next match, plus MIN_MATCH bytes to insert the
+         * string following the next match.
+         */
+        if (s->lookahead < MIN_LOOKAHEAD) {
+            fill_window(s);
+            if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
+                return need_more;
+            }
+            if (s->lookahead == 0) break; /* flush the current block */
+        }
+
+        /* Insert the string window[strstart .. strstart+2] in the
+         * dictionary, and set hash_head to the head of the hash chain:
+         */
+        hash_head = NIL;
+        if (s->lookahead >= MIN_MATCH) {
+            INSERT_STRING(s, s->strstart, hash_head);
+        }
+
+        /* Find the longest match, discarding those <= prev_length.
+         * At this point we have always match_length < MIN_MATCH
+         */
+        if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) {
+            /* To simplify the code, we prevent matches with the string
+             * of window index 0 (in particular we have to avoid a match
+             * of the string with itself at the start of the input file).
+             */
+            s->match_length = longest_match (s, hash_head);
+            /* longest_match() sets match_start */
+        }
+        if (s->match_length >= MIN_MATCH) {
+            check_match(s, s->strstart, s->match_start, s->match_length);
+
+            _tr_tally_dist(s, s->strstart - s->match_start,
+                           s->match_length - MIN_MATCH, bflush);
+
+            s->lookahead -= s->match_length;
+
+            /* Insert new strings in the hash table only if the match length
+             * is not too large. This saves time but degrades compression.
+             */
+#ifndef FASTEST
+            if (s->match_length <= s->max_insert_length &&
+                s->lookahead >= MIN_MATCH) {
+                s->match_length--; /* string at strstart already in table */
+                do {
+                    s->strstart++;
+                    INSERT_STRING(s, s->strstart, hash_head);
+                    /* strstart never exceeds WSIZE-MAX_MATCH, so there are
+                     * always MIN_MATCH bytes ahead.
+                     */
+                } while (--s->match_length != 0);
+                s->strstart++;
+            } else
+#endif
+            {
+                s->strstart += s->match_length;
+                s->match_length = 0;
+                s->ins_h = s->window[s->strstart];
+                UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]);
+#if MIN_MATCH != 3
+                Call UPDATE_HASH() MIN_MATCH-3 more times
+#endif
+                /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not
+                 * matter since it will be recomputed at next deflate call.
+                 */
+            }
+        } else {
+            /* No match, output a literal byte */
+            Tracevv((stderr,"%c", s->window[s->strstart]));
+            _tr_tally_lit (s, s->window[s->strstart], bflush);
+            s->lookahead--;
+            s->strstart++;
+        }
+        if (bflush) FLUSH_BLOCK(s, 0);
+    }
+    s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
+    if (flush == Z_FINISH) {
+        FLUSH_BLOCK(s, 1);
+        return finish_done;
+    }
+    if (s->last_lit)
+        FLUSH_BLOCK(s, 0);
+    return block_done;
+}
+
+#ifndef FASTEST
+/* ===========================================================================
+ * Same as above, but achieves better compression. We use a lazy
+ * evaluation for matches: a match is finally adopted only if there is
+ * no better match at the next window position.
+ */
+local block_state deflate_slow(s, flush)
+    deflate_state *s;
+    int flush;
+{
+    IPos hash_head;          /* head of hash chain */
+    int bflush;              /* set if current block must be flushed */
+
+    /* Process the input block. */
+    for (;;) {
+        /* Make sure that we always have enough lookahead, except
+         * at the end of the input file. We need MAX_MATCH bytes
+         * for the next match, plus MIN_MATCH bytes to insert the
+         * string following the next match.
+         */
+        if (s->lookahead < MIN_LOOKAHEAD) {
+            fill_window(s);
+            if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) {
+                return need_more;
+            }
+            if (s->lookahead == 0) break; /* flush the current block */
+        }
+
+        /* Insert the string window[strstart .. strstart+2] in the
+         * dictionary, and set hash_head to the head of the hash chain:
+         */
+        hash_head = NIL;
+        if (s->lookahead >= MIN_MATCH) {
+            INSERT_STRING(s, s->strstart, hash_head);
+        }
+
+        /* Find the longest match, discarding those <= prev_length.
+         */
+        s->prev_length = s->match_length, s->prev_match = s->match_start;
+        s->match_length = MIN_MATCH-1;
+
+        if (hash_head != NIL && s->prev_length < s->max_lazy_match &&
+            s->strstart - hash_head <= MAX_DIST(s)) {
+            /* To simplify the code, we prevent matches with the string
+             * of window index 0 (in particular we have to avoid a match
+             * of the string with itself at the start of the input file).
+             */
+            s->match_length = longest_match (s, hash_head);
+            /* longest_match() sets match_start */
+
+            if (s->match_length <= 5 && (s->strategy == Z_FILTERED
+#if TOO_FAR <= 32767
+                || (s->match_length == MIN_MATCH &&
+                    s->strstart - s->match_start > TOO_FAR)
+#endif
+                )) {
+
+                /* If prev_match is also MIN_MATCH, match_start is garbage
+                 * but we will ignore the current match anyway.
+                 */
+                s->match_length = MIN_MATCH-1;
+            }
+        }
+        /* If there was a match at the previous step and the current
+         * match is not better, output the previous match:
+         */
+        if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) {
+            uInt max_insert = s->strstart + s->lookahead - MIN_MATCH;
+            /* Do not insert strings in hash table beyond this. */
+
+            check_match(s, s->strstart-1, s->prev_match, s->prev_length);
+
+            _tr_tally_dist(s, s->strstart -1 - s->prev_match,
+                           s->prev_length - MIN_MATCH, bflush);
+
+            /* Insert in hash table all strings up to the end of the match.
+             * strstart-1 and strstart are already inserted. If there is not
+             * enough lookahead, the last two strings are not inserted in
+             * the hash table.
+             */
+            s->lookahead -= s->prev_length-1;
+            s->prev_length -= 2;
+            do {
+                if (++s->strstart <= max_insert) {
+                    INSERT_STRING(s, s->strstart, hash_head);
+                }
+            } while (--s->prev_length != 0);
+            s->match_available = 0;
+            s->match_length = MIN_MATCH-1;
+            s->strstart++;
+
+            if (bflush) FLUSH_BLOCK(s, 0);
+
+        } else if (s->match_available) {
+            /* If there was no match at the previous position, output a
+             * single literal. If there was a match but the current match
+             * is longer, truncate the previous match to a single literal.
+             */
+            Tracevv((stderr,"%c", s->window[s->strstart-1]));
+            _tr_tally_lit(s, s->window[s->strstart-1], bflush);
+            if (bflush) {
+                FLUSH_BLOCK_ONLY(s, 0);
+            }
+            s->strstart++;
+            s->lookahead--;
+            if (s->strm->avail_out == 0) return need_more;
+        } else {
+            /* There is no previous match to compare with, wait for
+             * the next step to decide.
+             */
+            s->match_available = 1;
+            s->strstart++;
+            s->lookahead--;
+        }
+    }
+    Assert (flush != Z_NO_FLUSH, "no flush?");
+    if (s->match_available) {
+        Tracevv((stderr,"%c", s->window[s->strstart-1]));
+        _tr_tally_lit(s, s->window[s->strstart-1], bflush);
+        s->match_available = 0;
+    }
+    s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1;
+    if (flush == Z_FINISH) {
+        FLUSH_BLOCK(s, 1);
+        return finish_done;
+    }
+    if (s->last_lit)
+        FLUSH_BLOCK(s, 0);
+    return block_done;
+}
+#endif /* FASTEST */
+
+/* ===========================================================================
+ * For Z_RLE, simply look for runs of bytes, generate matches only of distance
+ * one.  Do not maintain a hash table.  (It will be regenerated if this run of
+ * deflate switches away from Z_RLE.)
+ */
+local block_state deflate_rle(s, flush)
+    deflate_state *s;
+    int flush;
+{
+    int bflush;             /* set if current block must be flushed */
+    uInt prev;              /* byte at distance one to match */
+    Bytef *scan, *strend;   /* scan goes up to strend for length of run */
+
+    for (;;) {
+        /* Make sure that we always have enough lookahead, except
+         * at the end of the input file. We need MAX_MATCH bytes
+         * for the longest run, plus one for the unrolled loop.
+         */
+        if (s->lookahead <= MAX_MATCH) {
+            fill_window(s);
+            if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) {
+                return need_more;
+            }
+            if (s->lookahead == 0) break; /* flush the current block */
+        }
+
+        /* See how many times the previous byte repeats */
+        s->match_length = 0;
+        if (s->lookahead >= MIN_MATCH && s->strstart > 0) {
+            scan = s->window + s->strstart - 1;
+            prev = *scan;
+            if (prev == *++scan && prev == *++scan && prev == *++scan) {
+                strend = s->window + s->strstart + MAX_MATCH;
+                do {
+                } while (prev == *++scan && prev == *++scan &&
+                         prev == *++scan && prev == *++scan &&
+                         prev == *++scan && prev == *++scan &&
+                         prev == *++scan && prev == *++scan &&
+                         scan < strend);
+                s->match_length = MAX_MATCH - (uInt)(strend - scan);
+                if (s->match_length > s->lookahead)
+                    s->match_length = s->lookahead;
+            }
+            Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan");
+        }
+
+        /* Emit match if have run of MIN_MATCH or longer, else emit literal */
+        if (s->match_length >= MIN_MATCH) {
+            check_match(s, s->strstart, s->strstart - 1, s->match_length);
+
+            _tr_tally_dist(s, 1, s->match_length - MIN_MATCH, bflush);
+
+            s->lookahead -= s->match_length;
+            s->strstart += s->match_length;
+            s->match_length = 0;
+        } else {
+            /* No match, output a literal byte */
+            Tracevv((stderr,"%c", s->window[s->strstart]));
+            _tr_tally_lit (s, s->window[s->strstart], bflush);
+            s->lookahead--;
+            s->strstart++;
+        }
+        if (bflush) FLUSH_BLOCK(s, 0);
+    }
+    s->insert = 0;
+    if (flush == Z_FINISH) {
+        FLUSH_BLOCK(s, 1);
+        return finish_done;
+    }
+    if (s->last_lit)
+        FLUSH_BLOCK(s, 0);
+    return block_done;
+}
+
+/* ===========================================================================
+ * For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.
+ * (It will be regenerated if this run of deflate switches away from Huffman.)
+ */
+local block_state deflate_huff(s, flush)
+    deflate_state *s;
+    int flush;
+{
+    int bflush;             /* set if current block must be flushed */
+
+    for (;;) {
+        /* Make sure that we have a literal to write. */
+        if (s->lookahead == 0) {
+            fill_window(s);
+            if (s->lookahead == 0) {
+                if (flush == Z_NO_FLUSH)
+                    return need_more;
+                break;      /* flush the current block */
+            }
+        }
+
+        /* Output a literal byte */
+        s->match_length = 0;
+        Tracevv((stderr,"%c", s->window[s->strstart]));
+        _tr_tally_lit (s, s->window[s->strstart], bflush);
+        s->lookahead--;
+        s->strstart++;
+        if (bflush) FLUSH_BLOCK(s, 0);
+    }
+    s->insert = 0;
+    if (flush == Z_FINISH) {
+        FLUSH_BLOCK(s, 1);
+        return finish_done;
+    }
+    if (s->last_lit)
+        FLUSH_BLOCK(s, 0);
+    return block_done;
+}
diff --git a/base/poco/Foundation/src/deflate.h b/base/poco/Foundation/src/deflate.h
new file mode 100644
index 00000000000..23ecdd312bc
--- /dev/null
+++ b/base/poco/Foundation/src/deflate.h
@@ -0,0 +1,349 @@
+/* deflate.h -- internal compression state
+ * Copyright (C) 1995-2016 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id$ */
+
+#ifndef DEFLATE_H
+#define DEFLATE_H
+
+#include "zutil.h"
+
+/* define NO_GZIP when compiling if you want to disable gzip header and
+   trailer creation by deflate().  NO_GZIP would be used to avoid linking in
+   the crc code when it is not needed.  For shared libraries, gzip encoding
+   should be left enabled. */
+#ifndef NO_GZIP
+#  define GZIP
+#endif
+
+/* ===========================================================================
+ * Internal compression state.
+ */
+
+#define LENGTH_CODES 29
+/* number of length codes, not counting the special END_BLOCK code */
+
+#define LITERALS  256
+/* number of literal bytes 0..255 */
+
+#define L_CODES (LITERALS+1+LENGTH_CODES)
+/* number of Literal or Length codes, including the END_BLOCK code */
+
+#define D_CODES   30
+/* number of distance codes */
+
+#define BL_CODES  19
+/* number of codes used to transfer the bit lengths */
+
+#define HEAP_SIZE (2*L_CODES+1)
+/* maximum heap size */
+
+#define MAX_BITS 15
+/* All codes must not exceed MAX_BITS bits */
+
+#define Buf_size 16
+/* size of bit buffer in bi_buf */
+
+#define INIT_STATE    42    /* zlib header -> BUSY_STATE */
+#ifdef GZIP
+#  define GZIP_STATE  57    /* gzip header -> BUSY_STATE | EXTRA_STATE */
+#endif
+#define EXTRA_STATE   69    /* gzip extra block -> NAME_STATE */
+#define NAME_STATE    73    /* gzip file name -> COMMENT_STATE */
+#define COMMENT_STATE 91    /* gzip comment -> HCRC_STATE */
+#define HCRC_STATE   103    /* gzip header CRC -> BUSY_STATE */
+#define BUSY_STATE   113    /* deflate -> FINISH_STATE */
+#define FINISH_STATE 666    /* stream complete */
+/* Stream status */
+
+
+/* Data structure describing a single value and its code string. */
+typedef struct ct_data_s {
+    union {
+        ush  freq;       /* frequency count */
+        ush  code;       /* bit string */
+    } fc;
+    union {
+        ush  dad;        /* father node in Huffman tree */
+        ush  len;        /* length of bit string */
+    } dl;
+} FAR ct_data;
+
+#define Freq fc.freq
+#define Code fc.code
+#define Dad  dl.dad
+#define Len  dl.len
+
+typedef struct static_tree_desc_s  static_tree_desc;
+
+typedef struct tree_desc_s {
+    ct_data *dyn_tree;           /* the dynamic tree */
+    int     max_code;            /* largest code with non zero frequency */
+    const static_tree_desc *stat_desc;  /* the corresponding static tree */
+} FAR tree_desc;
+
+typedef ush Pos;
+typedef Pos FAR Posf;
+typedef unsigned IPos;
+
+/* A Pos is an index in the character window. We use short instead of int to
+ * save space in the various tables. IPos is used only for parameter passing.
+ */
+
+typedef struct internal_state {
+    z_streamp strm;      /* pointer back to this zlib stream */
+    int   status;        /* as the name implies */
+    Bytef *pending_buf;  /* output still pending */
+    ulg   pending_buf_size; /* size of pending_buf */
+    Bytef *pending_out;  /* next pending byte to output to the stream */
+    ulg   pending;       /* nb of bytes in the pending buffer */
+    int   wrap;          /* bit 0 true for zlib, bit 1 true for gzip */
+    gz_headerp  gzhead;  /* gzip header information to write */
+    ulg   gzindex;       /* where in extra, name, or comment */
+    Byte  method;        /* can only be DEFLATED */
+    int   last_flush;    /* value of flush param for previous deflate call */
+
+                /* used by deflate.c: */
+
+    uInt  w_size;        /* LZ77 window size (32K by default) */
+    uInt  w_bits;        /* log2(w_size)  (8..16) */
+    uInt  w_mask;        /* w_size - 1 */
+
+    Bytef *window;
+    /* Sliding window. Input bytes are read into the second half of the window,
+     * and move to the first half later to keep a dictionary of at least wSize
+     * bytes. With this organization, matches are limited to a distance of
+     * wSize-MAX_MATCH bytes, but this ensures that IO is always
+     * performed with a length multiple of the block size. Also, it limits
+     * the window size to 64K, which is quite useful on MSDOS.
+     * To do: use the user input buffer as sliding window.
+     */
+
+    ulg window_size;
+    /* Actual size of window: 2*wSize, except when the user input buffer
+     * is directly used as sliding window.
+     */
+
+    Posf *prev;
+    /* Link to older string with same hash index. To limit the size of this
+     * array to 64K, this link is maintained only for the last 32K strings.
+     * An index in this array is thus a window index modulo 32K.
+     */
+
+    Posf *head; /* Heads of the hash chains or NIL. */
+
+    uInt  ins_h;          /* hash index of string to be inserted */
+    uInt  hash_size;      /* number of elements in hash table */
+    uInt  hash_bits;      /* log2(hash_size) */
+    uInt  hash_mask;      /* hash_size-1 */
+
+    uInt  hash_shift;
+    /* Number of bits by which ins_h must be shifted at each input
+     * step. It must be such that after MIN_MATCH steps, the oldest
+     * byte no longer takes part in the hash key, that is:
+     *   hash_shift * MIN_MATCH >= hash_bits
+     */
+
+    long block_start;
+    /* Window position at the beginning of the current output block. Gets
+     * negative when the window is moved backwards.
+     */
+
+    uInt match_length;           /* length of best match */
+    IPos prev_match;             /* previous match */
+    int match_available;         /* set if previous match exists */
+    uInt strstart;               /* start of string to insert */
+    uInt match_start;            /* start of matching string */
+    uInt lookahead;              /* number of valid bytes ahead in window */
+
+    uInt prev_length;
+    /* Length of the best match at previous step. Matches not greater than this
+     * are discarded. This is used in the lazy match evaluation.
+     */
+
+    uInt max_chain_length;
+    /* To speed up deflation, hash chains are never searched beyond this
+     * length.  A higher limit improves compression ratio but degrades the
+     * speed.
+     */
+
+    uInt max_lazy_match;
+    /* Attempt to find a better match only when the current match is strictly
+     * smaller than this value. This mechanism is used only for compression
+     * levels >= 4.
+     */
+#   define max_insert_length  max_lazy_match
+    /* Insert new strings in the hash table only if the match length is not
+     * greater than this length. This saves time but degrades compression.
+     * max_insert_length is used only for compression levels <= 3.
+     */
+
+    int level;    /* compression level (1..9) */
+    int strategy; /* favor or force Huffman coding*/
+
+    uInt good_match;
+    /* Use a faster search when the previous match is longer than this */
+
+    int nice_match; /* Stop searching when current match exceeds this */
+
+                /* used by trees.c: */
+    /* Didn't use ct_data typedef below to suppress compiler warning */
+    struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */
+    struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
+    struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */
+
+    struct tree_desc_s l_desc;               /* desc. for literal tree */
+    struct tree_desc_s d_desc;               /* desc. for distance tree */
+    struct tree_desc_s bl_desc;              /* desc. for bit length tree */
+
+    ush bl_count[MAX_BITS+1];
+    /* number of codes at each bit length for an optimal tree */
+
+    int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */
+    int heap_len;               /* number of elements in the heap */
+    int heap_max;               /* element of largest frequency */
+    /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
+     * The same heap array is used to build all trees.
+     */
+
+    uch depth[2*L_CODES+1];
+    /* Depth of each subtree used as tie breaker for trees of equal frequency
+     */
+
+    uchf *l_buf;          /* buffer for literals or lengths */
+
+    uInt  lit_bufsize;
+    /* Size of match buffer for literals/lengths.  There are 4 reasons for
+     * limiting lit_bufsize to 64K:
+     *   - frequencies can be kept in 16 bit counters
+     *   - if compression is not successful for the first block, all input
+     *     data is still in the window so we can still emit a stored block even
+     *     when input comes from standard input.  (This can also be done for
+     *     all blocks if lit_bufsize is not greater than 32K.)
+     *   - if compression is not successful for a file smaller than 64K, we can
+     *     even emit a stored file instead of a stored block (saving 5 bytes).
+     *     This is applicable only for zip (not gzip or zlib).
+     *   - creating new Huffman trees less frequently may not provide fast
+     *     adaptation to changes in the input data statistics. (Take for
+     *     example a binary file with poorly compressible code followed by
+     *     a highly compressible string table.) Smaller buffer sizes give
+     *     fast adaptation but have of course the overhead of transmitting
+     *     trees more frequently.
+     *   - I can't count above 4
+     */
+
+    uInt last_lit;      /* running index in l_buf */
+
+    ushf *d_buf;
+    /* Buffer for distances. To simplify the code, d_buf and l_buf have
+     * the same number of elements. To use different lengths, an extra flag
+     * array would be necessary.
+     */
+
+    ulg opt_len;        /* bit length of current block with optimal trees */
+    ulg static_len;     /* bit length of current block with static trees */
+    uInt matches;       /* number of string matches in current block */
+    uInt insert;        /* bytes at end of window left to insert */
+
+#ifdef ZLIB_DEBUG
+    ulg compressed_len; /* total bit length of compressed file mod 2^32 */
+    ulg bits_sent;      /* bit length of compressed data sent mod 2^32 */
+#endif
+
+    ush bi_buf;
+    /* Output buffer. bits are inserted starting at the bottom (least
+     * significant bits).
+     */
+    int bi_valid;
+    /* Number of valid bits in bi_buf.  All bits above the last valid bit
+     * are always zero.
+     */
+
+    ulg high_water;
+    /* High water mark offset in window for initialized bytes -- bytes above
+     * this are set to zero in order to avoid memory check warnings when
+     * longest match routines access bytes past the input.  This is then
+     * updated to the new high water mark.
+     */
+
+} FAR deflate_state;
+
+/* Output a byte on the stream.
+ * IN assertion: there is enough room in pending_buf.
+ */
+#define put_byte(s, c) {s->pending_buf[s->pending++] = (Bytef)(c);}
+
+
+#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
+/* Minimum amount of lookahead, except at the end of the input file.
+ * See deflate.c for comments about the MIN_MATCH+1.
+ */
+
+#define MAX_DIST(s)  ((s)->w_size-MIN_LOOKAHEAD)
+/* In order to simplify the code, particularly on 16 bit machines, match
+ * distances are limited to MAX_DIST instead of WSIZE.
+ */
+
+#define WIN_INIT MAX_MATCH
+/* Number of bytes after end of data in window to initialize in order to avoid
+   memory checker errors from longest match routines */
+
+        /* in trees.c */
+void ZLIB_INTERNAL _tr_init OF((deflate_state *s));
+int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
+void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf,
+                        ulg stored_len, int last));
+void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s));
+void ZLIB_INTERNAL _tr_align OF((deflate_state *s));
+void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
+                        ulg stored_len, int last));
+
+#define d_code(dist) \
+   ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
+/* Mapping from a distance to a distance code. dist is the distance - 1 and
+ * must not have side effects. _dist_code[256] and _dist_code[257] are never
+ * used.
+ */
+
+#ifndef ZLIB_DEBUG
+/* Inline versions of _tr_tally for speed: */
+
+#if defined(GEN_TREES_H) || !defined(STDC)
+  extern uch ZLIB_INTERNAL _length_code[];
+  extern uch ZLIB_INTERNAL _dist_code[];
+#else
+  extern const uch ZLIB_INTERNAL _length_code[];
+  extern const uch ZLIB_INTERNAL _dist_code[];
+#endif
+
+# define _tr_tally_lit(s, c, flush) \
+  { uch cc = (c); \
+    s->d_buf[s->last_lit] = 0; \
+    s->l_buf[s->last_lit++] = cc; \
+    s->dyn_ltree[cc].Freq++; \
+    flush = (s->last_lit == s->lit_bufsize-1); \
+   }
+# define _tr_tally_dist(s, distance, length, flush) \
+  { uch len = (uch)(length); \
+    ush dist = (ush)(distance); \
+    s->d_buf[s->last_lit] = dist; \
+    s->l_buf[s->last_lit++] = len; \
+    dist--; \
+    s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
+    s->dyn_dtree[d_code(dist)].Freq++; \
+    flush = (s->last_lit == s->lit_bufsize-1); \
+  }
+#else
+# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
+# define _tr_tally_dist(s, distance, length, flush) \
+              flush = _tr_tally(s, distance, length)
+#endif
+
+#endif /* DEFLATE_H */
diff --git a/base/poco/Foundation/src/diy-fp.cc b/base/poco/Foundation/src/diy-fp.cc
new file mode 100644
index 00000000000..ddd1891b168
--- /dev/null
+++ b/base/poco/Foundation/src/diy-fp.cc
@@ -0,0 +1,57 @@
+// Copyright 2010 the V8 project authors. 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 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 Google Inc. 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 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
+// OWNER 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.
+
+
+#include "diy-fp.h"
+#include "utils.h"
+
+namespace double_conversion {
+
+void DiyFp::Multiply(const DiyFp& other) {
+  // Simply "emulates" a 128 bit multiplication.
+  // However: the resulting number only contains 64 bits. The least
+  // significant 64 bits are only used for rounding the most significant 64
+  // bits.
+  const uint64_t kM32 = 0xFFFFFFFFU;
+  uint64_t a = f_ >> 32;
+  uint64_t b = f_ & kM32;
+  uint64_t c = other.f_ >> 32;
+  uint64_t d = other.f_ & kM32;
+  uint64_t ac = a * c;
+  uint64_t bc = b * c;
+  uint64_t ad = a * d;
+  uint64_t bd = b * d;
+  uint64_t tmp = (bd >> 32) + (ad & kM32) + (bc & kM32);
+  // By adding 1U << 31 to tmp we round the final result.
+  // Halfway cases will be round up.
+  tmp += 1U << 31;
+  uint64_t result_f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);
+  e_ += other.e_ + 64;
+  f_ = result_f;
+}
+
+}  // namespace double_conversion
diff --git a/base/poco/Foundation/src/diy-fp.h b/base/poco/Foundation/src/diy-fp.h
new file mode 100644
index 00000000000..9dcf8fbdba9
--- /dev/null
+++ b/base/poco/Foundation/src/diy-fp.h
@@ -0,0 +1,118 @@
+// Copyright 2010 the V8 project authors. 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 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 Google Inc. 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 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
+// OWNER 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.
+
+#ifndef DOUBLE_CONVERSION_DIY_FP_H_
+#define DOUBLE_CONVERSION_DIY_FP_H_
+
+#include "utils.h"
+
+namespace double_conversion {
+
+// This "Do It Yourself Floating Point" class implements a floating-point number
+// with a uint64 significand and an int exponent. Normalized DiyFp numbers will
+// have the most significant bit of the significand set.
+// Multiplication and Subtraction do not normalize their results.
+// DiyFp are not designed to contain special doubles (NaN and Infinity).
+class DiyFp {
+ public:
+  static const int kSignificandSize = 64;
+
+  DiyFp() : f_(0), e_(0) {}
+  DiyFp(uint64_t f, int e) : f_(f), e_(e) {}
+
+  // this = this - other.
+  // The exponents of both numbers must be the same and the significand of this
+  // must be bigger than the significand of other.
+  // The result will not be normalized.
+  void Subtract(const DiyFp& other) {
+    ASSERT(e_ == other.e_);
+    ASSERT(f_ >= other.f_);
+    f_ -= other.f_;
+  }
+
+  // Returns a - b.
+  // The exponents of both numbers must be the same and this must be bigger
+  // than other. The result will not be normalized.
+  static DiyFp Minus(const DiyFp& a, const DiyFp& b) {
+    DiyFp result = a;
+    result.Subtract(b);
+    return result;
+  }
+
+
+  // this = this * other.
+  void Multiply(const DiyFp& other);
+
+  // returns a * b;
+  static DiyFp Times(const DiyFp& a, const DiyFp& b) {
+    DiyFp result = a;
+    result.Multiply(b);
+    return result;
+  }
+
+  void Normalize() {
+    ASSERT(f_ != 0);
+    uint64_t f = f_;
+    int e = e_;
+
+    // This method is mainly called for normalizing boundaries. In general
+    // boundaries need to be shifted by 10 bits. We thus optimize for this case.
+    const uint64_t k10MSBits = UINT64_2PART_C(0xFFC00000, 00000000);
+    while ((f & k10MSBits) == 0) {
+      f <<= 10;
+      e -= 10;
+    }
+    while ((f & kUint64MSB) == 0) {
+      f <<= 1;
+      e--;
+    }
+    f_ = f;
+    e_ = e;
+  }
+
+  static DiyFp Normalize(const DiyFp& a) {
+    DiyFp result = a;
+    result.Normalize();
+    return result;
+  }
+
+  uint64_t f() const { return f_; }
+  int e() const { return e_; }
+
+  void set_f(uint64_t new_value) { f_ = new_value; }
+  void set_e(int new_value) { e_ = new_value; }
+
+ private:
+  static const uint64_t kUint64MSB = UINT64_2PART_C(0x80000000, 00000000);
+
+  uint64_t f_;
+  int e_;
+};
+
+}  // namespace double_conversion
+
+#endif  // DOUBLE_CONVERSION_DIY_FP_H_
diff --git a/base/poco/Foundation/src/double-conversion.cc b/base/poco/Foundation/src/double-conversion.cc
new file mode 100644
index 00000000000..39ad2461e9b
--- /dev/null
+++ b/base/poco/Foundation/src/double-conversion.cc
@@ -0,0 +1,911 @@
+// Copyright 2010 the V8 project authors. 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 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 Google Inc. 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 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
+// OWNER 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.
+
+#include <limits.h>
+#include <math.h>
+
+#include "double-conversion.h"
+
+#include "bignum-dtoa.h"
+#include "fast-dtoa.h"
+#include "fixed-dtoa.h"
+#include "ieee.h"
+#include "strtod.h"
+#include "utils.h"
+
+namespace double_conversion {
+
+const DoubleToStringConverter& DoubleToStringConverter::EcmaScriptConverter() {
+  int flags = UNIQUE_ZERO | EMIT_POSITIVE_EXPONENT_SIGN;
+  static DoubleToStringConverter converter(flags,
+                                           "Infinity",
+                                           "NaN",
+                                           'e',
+                                           -6, 21,
+                                           6, 0);
+  return converter;
+}
+
+
+bool DoubleToStringConverter::HandleSpecialValues(
+    double value,
+    StringBuilder* result_builder) const {
+  Double double_inspect(value);
+  if (double_inspect.IsInfinite()) {
+    if (infinity_symbol_ == NULL) return false;
+    if (value < 0) {
+      result_builder->AddCharacter('-');
+    }
+    result_builder->AddString(infinity_symbol_);
+    return true;
+  }
+  if (double_inspect.IsNan()) {
+    if (nan_symbol_ == NULL) return false;
+    result_builder->AddString(nan_symbol_);
+    return true;
+  }
+  return false;
+}
+
+
+void DoubleToStringConverter::CreateExponentialRepresentation(
+    const char* decimal_digits,
+    int length,
+    int exponent,
+    StringBuilder* result_builder) const {
+  ASSERT(length != 0);
+  result_builder->AddCharacter(decimal_digits[0]);
+  if (length != 1) {
+    result_builder->AddCharacter('.');
+    result_builder->AddSubstring(&decimal_digits[1], length-1);
+  }
+  result_builder->AddCharacter(exponent_character_);
+  if (exponent < 0) {
+    result_builder->AddCharacter('-');
+    exponent = -exponent;
+  } else {
+    if ((flags_ & EMIT_POSITIVE_EXPONENT_SIGN) != 0) {
+      result_builder->AddCharacter('+');
+    }
+  }
+  if (exponent == 0) {
+    result_builder->AddCharacter('0');
+    return;
+  }
+  ASSERT(exponent < 1e4);
+  const int kMaxExponentLength = 5;
+  char buffer[kMaxExponentLength + 1];
+  buffer[kMaxExponentLength] = '\0';
+  int first_char_pos = kMaxExponentLength;
+  while (exponent > 0) {
+    buffer[--first_char_pos] = '0' + (exponent % 10);
+    exponent /= 10;
+  }
+  result_builder->AddSubstring(&buffer[first_char_pos],
+                               kMaxExponentLength - first_char_pos);
+}
+
+
+void DoubleToStringConverter::CreateDecimalRepresentation(
+    const char* decimal_digits,
+    int length,
+    int decimal_point,
+    int digits_after_point,
+    StringBuilder* result_builder) const {
+  // Create a representation that is padded with zeros if needed.
+  if (decimal_point <= 0) {
+      // "0.00000decimal_rep".
+    result_builder->AddCharacter('0');
+    if (digits_after_point > 0) {
+      result_builder->AddCharacter('.');
+      result_builder->AddPadding('0', -decimal_point);
+      ASSERT(length <= digits_after_point - (-decimal_point));
+      result_builder->AddSubstring(decimal_digits, length);
+      int remaining_digits = digits_after_point - (-decimal_point) - length;
+      result_builder->AddPadding('0', remaining_digits);
+    }
+  } else if (decimal_point >= length) {
+    // "decimal_rep0000.00000" or "decimal_rep.0000"
+    result_builder->AddSubstring(decimal_digits, length);
+    result_builder->AddPadding('0', decimal_point - length);
+    if (digits_after_point > 0) {
+      result_builder->AddCharacter('.');
+      result_builder->AddPadding('0', digits_after_point);
+    }
+  } else {
+    // "decima.l_rep000"
+    ASSERT(digits_after_point > 0);
+    result_builder->AddSubstring(decimal_digits, decimal_point);
+    result_builder->AddCharacter('.');
+    ASSERT(length - decimal_point <= digits_after_point);
+    result_builder->AddSubstring(&decimal_digits[decimal_point],
+                                 length - decimal_point);
+    int remaining_digits = digits_after_point - (length - decimal_point);
+    result_builder->AddPadding('0', remaining_digits);
+  }
+  if (digits_after_point == 0) {
+    if ((flags_ & EMIT_TRAILING_DECIMAL_POINT) != 0) {
+      result_builder->AddCharacter('.');
+    }
+    if ((flags_ & EMIT_TRAILING_ZERO_AFTER_POINT) != 0) {
+      result_builder->AddCharacter('0');
+    }
+  }
+}
+
+
+bool DoubleToStringConverter::ToShortestIeeeNumber(
+    double value,
+    StringBuilder* result_builder,
+    DoubleToStringConverter::DtoaMode mode) const {
+  ASSERT(mode == SHORTEST || mode == SHORTEST_SINGLE);
+  if (Double(value).IsSpecial()) {
+    return HandleSpecialValues(value, result_builder);
+  }
+
+  int decimal_point;
+  bool sign;
+  const int kDecimalRepCapacity = kBase10MaximalLength + 1;
+  char decimal_rep[kDecimalRepCapacity];
+  int decimal_rep_length;
+
+  DoubleToAscii(value, mode, 0, decimal_rep, kDecimalRepCapacity,
+                &sign, &decimal_rep_length, &decimal_point);
+
+  bool unique_zero = (flags_ & UNIQUE_ZERO) != 0;
+  if (sign && (value != 0.0 || !unique_zero)) {
+    result_builder->AddCharacter('-');
+  }
+
+  int exponent = decimal_point - 1;
+  if ((decimal_in_shortest_low_ <= exponent) &&
+      (exponent < decimal_in_shortest_high_)) {
+    CreateDecimalRepresentation(decimal_rep, decimal_rep_length,
+                                decimal_point,
+                                Max(0, decimal_rep_length - decimal_point),
+                                result_builder);
+  } else {
+    CreateExponentialRepresentation(decimal_rep, decimal_rep_length, exponent,
+                                    result_builder);
+  }
+  return true;
+}
+
+
+bool DoubleToStringConverter::ToFixed(double value,
+                                      int requested_digits,
+                                      StringBuilder* result_builder) const {
+  ASSERT(kMaxFixedDigitsBeforePoint == 60);
+  const double kFirstNonFixed = 1e60;
+
+  if (Double(value).IsSpecial()) {
+    return HandleSpecialValues(value, result_builder);
+  }
+
+  if (requested_digits > kMaxFixedDigitsAfterPoint) return false;
+  if (value >= kFirstNonFixed || value <= -kFirstNonFixed) return false;
+
+  // Find a sufficiently precise decimal representation of n.
+  int decimal_point;
+  bool sign;
+  // Add space for the '\0' byte.
+  const int kDecimalRepCapacity =
+      kMaxFixedDigitsBeforePoint + kMaxFixedDigitsAfterPoint + 1;
+  char decimal_rep[kDecimalRepCapacity];
+  int decimal_rep_length;
+  DoubleToAscii(value, FIXED, requested_digits,
+                decimal_rep, kDecimalRepCapacity,
+                &sign, &decimal_rep_length, &decimal_point);
+
+  bool unique_zero = ((flags_ & UNIQUE_ZERO) != 0);
+  if (sign && (value != 0.0 || !unique_zero)) {
+    result_builder->AddCharacter('-');
+  }
+
+  CreateDecimalRepresentation(decimal_rep, decimal_rep_length, decimal_point,
+                              requested_digits, result_builder);
+  return true;
+}
+
+
+bool DoubleToStringConverter::ToExponential(
+    double value,
+    int requested_digits,
+    StringBuilder* result_builder) const {
+  if (Double(value).IsSpecial()) {
+    return HandleSpecialValues(value, result_builder);
+  }
+
+  if (requested_digits < -1) return false;
+  if (requested_digits > kMaxExponentialDigits) return false;
+
+  int decimal_point;
+  bool sign;
+  // Add space for digit before the decimal point and the '\0' character.
+  const int kDecimalRepCapacity = kMaxExponentialDigits + 2;
+  ASSERT(kDecimalRepCapacity > kBase10MaximalLength);
+  char decimal_rep[kDecimalRepCapacity];
+  int decimal_rep_length;
+
+  if (requested_digits == -1) {
+    DoubleToAscii(value, SHORTEST, 0,
+                  decimal_rep, kDecimalRepCapacity,
+                  &sign, &decimal_rep_length, &decimal_point);
+  } else {
+    DoubleToAscii(value, PRECISION, requested_digits + 1,
+                  decimal_rep, kDecimalRepCapacity,
+                  &sign, &decimal_rep_length, &decimal_point);
+    ASSERT(decimal_rep_length <= requested_digits + 1);
+
+    for (int i = decimal_rep_length; i < requested_digits + 1; ++i) {
+      decimal_rep[i] = '0';
+    }
+    decimal_rep_length = requested_digits + 1;
+  }
+
+  bool unique_zero = ((flags_ & UNIQUE_ZERO) != 0);
+  if (sign && (value != 0.0 || !unique_zero)) {
+    result_builder->AddCharacter('-');
+  }
+
+  int exponent = decimal_point - 1;
+  CreateExponentialRepresentation(decimal_rep,
+                                  decimal_rep_length,
+                                  exponent,
+                                  result_builder);
+  return true;
+}
+
+
+bool DoubleToStringConverter::ToPrecision(double value,
+                                          int precision,
+                                          StringBuilder* result_builder) const {
+  if (Double(value).IsSpecial()) {
+    return HandleSpecialValues(value, result_builder);
+  }
+
+  if (precision < kMinPrecisionDigits || precision > kMaxPrecisionDigits) {
+    return false;
+  }
+
+  // Find a sufficiently precise decimal representation of n.
+  int decimal_point;
+  bool sign;
+  // Add one for the terminating null character.
+  const int kDecimalRepCapacity = kMaxPrecisionDigits + 1;
+  char decimal_rep[kDecimalRepCapacity];
+  int decimal_rep_length;
+
+  DoubleToAscii(value, PRECISION, precision,
+                decimal_rep, kDecimalRepCapacity,
+                &sign, &decimal_rep_length, &decimal_point);
+  ASSERT(decimal_rep_length <= precision);
+
+  bool unique_zero = ((flags_ & UNIQUE_ZERO) != 0);
+  if (sign && (value != 0.0 || !unique_zero)) {
+    result_builder->AddCharacter('-');
+  }
+
+  // The exponent if we print the number as x.xxeyyy. That is with the
+  // decimal point after the first digit.
+  int exponent = decimal_point - 1;
+
+  int extra_zero = ((flags_ & EMIT_TRAILING_ZERO_AFTER_POINT) != 0) ? 1 : 0;
+  if ((-decimal_point + 1 > max_leading_padding_zeroes_in_precision_mode_) ||
+      (decimal_point - precision + extra_zero >
+       max_trailing_padding_zeroes_in_precision_mode_)) {
+    // Fill buffer to contain 'precision' digits.
+    // Usually the buffer is already at the correct length, but 'DoubleToAscii'
+    // is allowed to return less characters.
+    for (int i = decimal_rep_length; i < precision; ++i) {
+      decimal_rep[i] = '0';
+    }
+
+    CreateExponentialRepresentation(decimal_rep,
+                                    precision,
+                                    exponent,
+                                    result_builder);
+  } else {
+    CreateDecimalRepresentation(decimal_rep, decimal_rep_length, decimal_point,
+                                Max(0, precision - decimal_point),
+                                result_builder);
+  }
+  return true;
+}
+
+
+static BignumDtoaMode DtoaToBignumDtoaMode(
+    DoubleToStringConverter::DtoaMode dtoa_mode) {
+  switch (dtoa_mode) {
+    case DoubleToStringConverter::SHORTEST:  return BIGNUM_DTOA_SHORTEST;
+    case DoubleToStringConverter::SHORTEST_SINGLE:
+        return BIGNUM_DTOA_SHORTEST_SINGLE;
+    case DoubleToStringConverter::FIXED:     return BIGNUM_DTOA_FIXED;
+    case DoubleToStringConverter::PRECISION: return BIGNUM_DTOA_PRECISION;
+    default:
+      UNREACHABLE();
+	  return BIGNUM_DTOA_SHORTEST;
+  }
+}
+
+
+void DoubleToStringConverter::DoubleToAscii(double v,
+                                            DtoaMode mode,
+                                            int requested_digits,
+                                            char* buffer,
+                                            int buffer_length,
+                                            bool* sign,
+                                            int* length,
+                                            int* point) {
+  Vector<char> vector(buffer, buffer_length);
+  ASSERT(!Double(v).IsSpecial());
+  ASSERT(mode == SHORTEST || mode == SHORTEST_SINGLE || requested_digits >= 0);
+
+  if (Double(v).Sign() < 0) {
+    *sign = true;
+    v = -v;
+  } else {
+    *sign = false;
+  }
+
+  if (mode == PRECISION && requested_digits == 0) {
+    vector[0] = '\0';
+    *length = 0;
+    return;
+  }
+
+  if (v == 0) {
+    vector[0] = '0';
+    vector[1] = '\0';
+    *length = 1;
+    *point = 1;
+    return;
+  }
+
+  bool fast_worked;
+  switch (mode) {
+    case SHORTEST:
+      fast_worked = FastDtoa(v, FAST_DTOA_SHORTEST, 0, vector, length, point);
+      break;
+    case SHORTEST_SINGLE:
+      fast_worked = FastDtoa(v, FAST_DTOA_SHORTEST_SINGLE, 0,
+                             vector, length, point);
+      break;
+    case FIXED:
+      fast_worked = FastFixedDtoa(v, requested_digits, vector, length, point);
+      break;
+    case PRECISION:
+      fast_worked = FastDtoa(v, FAST_DTOA_PRECISION, requested_digits,
+                             vector, length, point);
+      break;
+    default:
+      fast_worked = false;
+      UNREACHABLE();
+  }
+  if (fast_worked) return;
+
+  // If the fast dtoa didn't succeed use the slower bignum version.
+  BignumDtoaMode bignum_mode = DtoaToBignumDtoaMode(mode);
+  BignumDtoa(v, bignum_mode, requested_digits, vector, length, point);
+  vector[*length] = '\0';
+}
+
+
+// Consumes the given substring from the iterator.
+// Returns false, if the substring does not match.
+static bool ConsumeSubString(const char** current,
+                             const char* end,
+                             const char* substring) {
+  ASSERT(**current == *substring);
+  for (substring++; *substring != '\0'; substring++) {
+    ++*current;
+    if (*current == end || **current != *substring) return false;
+  }
+  ++*current;
+  return true;
+}
+
+
+// Maximum number of significant digits in decimal representation.
+// The longest possible double in decimal representation is
+// (2^53 - 1) * 2 ^ -1074 that is (2 ^ 53 - 1) * 5 ^ 1074 / 10 ^ 1074
+// (768 digits). If we parse a number whose first digits are equal to a
+// mean of 2 adjacent doubles (that could have up to 769 digits) the result
+// must be rounded to the bigger one unless the tail consists of zeros, so
+// we don't need to preserve all the digits.
+const int kMaxSignificantDigits = 772;
+
+
+// Returns true if a nonspace found and false if the end has reached.
+static inline bool AdvanceToNonspace(const char** current, const char* end) {
+  while (*current != end) {
+    if (**current != ' ') return true;
+    ++*current;
+  }
+  return false;
+}
+
+
+static bool isDigit(int x, int radix) {
+  return (x >= '0' && x <= '9' && x < '0' + radix)
+      || (radix > 10 && x >= 'a' && x < 'a' + radix - 10)
+      || (radix > 10 && x >= 'A' && x < 'A' + radix - 10);
+}
+
+
+static double SignedZero(bool sign) {
+  return sign ? -0.0 : 0.0;
+}
+
+
+// Returns true if 'c' is a decimal digit that is valid for the given radix.
+//
+// The function is small and could be inlined, but VS2012 emitted a warning
+// because it constant-propagated the radix and concluded that the last
+// condition was always true. By moving it into a separate function the
+// compiler wouldn't warn anymore.
+static bool IsDecimalDigitForRadix(int c, int radix) {
+  return '0' <= c && c <= '9' && (c - '0') < radix;
+}
+
+// Returns true if 'c' is a character digit that is valid for the given radix.
+// The 'a_character' should be 'a' or 'A'.
+//
+// The function is small and could be inlined, but VS2012 emitted a warning
+// because it constant-propagated the radix and concluded that the first
+// condition was always false. By moving it into a separate function the
+// compiler wouldn't warn anymore.
+static bool IsCharacterDigitForRadix(int c, int radix, char a_character) {
+  return radix > 10 && c >= a_character && c < a_character + radix - 10;
+}
+
+
+// Parsing integers with radix 2, 4, 8, 16, 32. Assumes current != end.
+template <int radix_log_2>
+static double RadixStringToIeee(const char* current,
+                                const char* end,
+                                bool sign,
+                                bool allow_trailing_junk,
+                                double junk_string_value,
+                                bool read_as_double,
+                                const char** trailing_pointer) {
+  ASSERT(current != end);
+
+  const int kDoubleSize = Double::kSignificandSize;
+  const int kSingleSize = Single::kSignificandSize;
+  const int kSignificandSize = read_as_double? kDoubleSize: kSingleSize;
+
+  // Skip leading 0s.
+  while (*current == '0') {
+    ++current;
+    if (current == end) {
+      *trailing_pointer = end;
+      return SignedZero(sign);
+    }
+  }
+
+  int64_t number = 0;
+  int exponent = 0;
+  const int radix = (1 << radix_log_2);
+
+  do {
+    int digit;
+    if (IsDecimalDigitForRadix(*current, radix)) {
+      digit = static_cast<char>(*current) - '0';
+    } else if (IsCharacterDigitForRadix(*current, radix, 'a')) {
+      digit = static_cast<char>(*current) - 'a' + 10;
+    } else if (IsCharacterDigitForRadix(*current, radix, 'A')) {
+      digit = static_cast<char>(*current) - 'A' + 10;
+    } else {
+      if (allow_trailing_junk || !AdvanceToNonspace(&current, end)) {
+        break;
+      } else {
+        return junk_string_value;
+      }
+    }
+
+    number = number * radix + digit;
+    int overflow = static_cast<int>(number >> kSignificandSize);
+    if (overflow != 0) {
+      // Overflow occurred. Need to determine which direction to round the
+      // result.
+      int overflow_bits_count = 1;
+      while (overflow > 1) {
+        overflow_bits_count++;
+        overflow >>= 1;
+      }
+
+      int dropped_bits_mask = ((1 << overflow_bits_count) - 1);
+      int dropped_bits = static_cast<int>(number) & dropped_bits_mask;
+      number >>= overflow_bits_count;
+      exponent = overflow_bits_count;
+
+      bool zero_tail = true;
+      for (;;) {
+        ++current;
+        if (current == end || !isDigit(*current, radix)) break;
+        zero_tail = zero_tail && *current == '0';
+        exponent += radix_log_2;
+      }
+
+      if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
+        return junk_string_value;
+      }
+
+      int middle_value = (1 << (overflow_bits_count - 1));
+      if (dropped_bits > middle_value) {
+        number++;  // Rounding up.
+      } else if (dropped_bits == middle_value) {
+        // Rounding to even to consistency with decimals: half-way case rounds
+        // up if significant part is odd and down otherwise.
+        if ((number & 1) != 0 || !zero_tail) {
+          number++;  // Rounding up.
+        }
+      }
+
+      // Rounding up may cause overflow.
+      if ((number & ((int64_t)1 << kSignificandSize)) != 0) {
+        exponent++;
+        number >>= 1;
+      }
+      break;
+    }
+    ++current;
+  } while (current != end);
+
+  ASSERT(number < ((int64_t)1 << kSignificandSize));
+  ASSERT(static_cast<int64_t>(static_cast<double>(number)) == number);
+
+  *trailing_pointer = current;
+
+  if (exponent == 0) {
+    if (sign) {
+      if (number == 0) return -0.0;
+      number = -number;
+    }
+    return static_cast<double>(number);
+  }
+
+  ASSERT(number != 0);
+  return Double(DiyFp(number, exponent)).value();
+}
+
+
+double StringToDoubleConverter::StringToIeee(
+    const char* input,
+    int length,
+    int* processed_characters_count,
+    bool read_as_double) const {
+  const char* current = input;
+  const char* end = input + length;
+
+  *processed_characters_count = 0;
+
+  const bool allow_trailing_junk = (flags_ & ALLOW_TRAILING_JUNK) != 0;
+  const bool allow_leading_spaces = (flags_ & ALLOW_LEADING_SPACES) != 0;
+  const bool allow_trailing_spaces = (flags_ & ALLOW_TRAILING_SPACES) != 0;
+  const bool allow_spaces_after_sign = (flags_ & ALLOW_SPACES_AFTER_SIGN) != 0;
+
+  // To make sure that iterator dereferencing is valid the following
+  // convention is used:
+  // 1. Each '++current' statement is followed by check for equality to 'end'.
+  // 2. If AdvanceToNonspace returned false then current == end.
+  // 3. If 'current' becomes equal to 'end' the function returns or goes to
+  // 'parsing_done'.
+  // 4. 'current' is not dereferenced after the 'parsing_done' label.
+  // 5. Code before 'parsing_done' may rely on 'current != end'.
+  if (current == end) return empty_string_value_;
+
+  if (allow_leading_spaces || allow_trailing_spaces) {
+    if (!AdvanceToNonspace(&current, end)) {
+      *processed_characters_count = static_cast<int>(current - input);
+      return empty_string_value_;
+    }
+    if (!allow_leading_spaces && (input != current)) {
+      // No leading spaces allowed, but AdvanceToNonspace moved forward.
+      return junk_string_value_;
+    }
+  }
+
+  // The longest form of simplified number is: "-<significant digits>.1eXXX\0".
+  const int kBufferSize = kMaxSignificantDigits + 10;
+  char buffer[kBufferSize];  // NOLINT: size is known at compile time.
+  int buffer_pos = 0;
+
+  // Exponent will be adjusted if insignificant digits of the integer part
+  // or insignificant leading zeros of the fractional part are dropped.
+  int exponent = 0;
+  int significant_digits = 0;
+  int insignificant_digits = 0;
+  bool nonzero_digit_dropped = false;
+
+  bool sign = false;
+
+  if (*current == '+' || *current == '-') {
+    sign = (*current == '-');
+    ++current;
+    const char* next_non_space = current;
+    // Skip following spaces (if allowed).
+    if (!AdvanceToNonspace(&next_non_space, end)) return junk_string_value_;
+    if (!allow_spaces_after_sign && (current != next_non_space)) {
+      return junk_string_value_;
+    }
+    current = next_non_space;
+  }
+
+  if (infinity_symbol_ != NULL) {
+    if (*current == infinity_symbol_[0]) {
+      if (!ConsumeSubString(&current, end, infinity_symbol_)) {
+        return junk_string_value_;
+      }
+
+      if (!(allow_trailing_spaces || allow_trailing_junk) && (current != end)) {
+        return junk_string_value_;
+      }
+      if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
+        return junk_string_value_;
+      }
+
+      ASSERT(buffer_pos == 0);
+      *processed_characters_count = static_cast<int>(current - input);
+      return sign ? -Double::Infinity() : Double::Infinity();
+    }
+  }
+
+  if (nan_symbol_ != NULL) {
+    if (*current == nan_symbol_[0]) {
+      if (!ConsumeSubString(&current, end, nan_symbol_)) {
+        return junk_string_value_;
+      }
+
+      if (!(allow_trailing_spaces || allow_trailing_junk) && (current != end)) {
+        return junk_string_value_;
+      }
+      if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
+        return junk_string_value_;
+      }
+
+      ASSERT(buffer_pos == 0);
+      *processed_characters_count = static_cast<int>(current - input);
+      return sign ? -Double::NaN() : Double::NaN();
+    }
+  }
+
+  bool leading_zero = false;
+  if (*current == '0') {
+    ++current;
+    if (current == end) {
+      *processed_characters_count = static_cast<int>(current - input);
+      return SignedZero(sign);
+    }
+
+    leading_zero = true;
+
+    // It could be hexadecimal value.
+    if ((flags_ & ALLOW_HEX) && (*current == 'x' || *current == 'X')) {
+      ++current;
+      if (current == end || !isDigit(*current, 16)) {
+        return junk_string_value_;  // "0x".
+      }
+
+      const char* tail_pointer = NULL;
+      double result = RadixStringToIeee<4>(current,
+                                           end,
+                                           sign,
+                                           allow_trailing_junk,
+                                           junk_string_value_,
+                                           read_as_double,
+                                           &tail_pointer);
+      if (tail_pointer != NULL) {
+        if (allow_trailing_spaces) AdvanceToNonspace(&tail_pointer, end);
+        *processed_characters_count = static_cast<int>(tail_pointer - input);
+      }
+      return result;
+    }
+
+    // Ignore leading zeros in the integer part.
+    while (*current == '0') {
+      ++current;
+      if (current == end) {
+        *processed_characters_count = static_cast<int>(current - input);
+        return SignedZero(sign);
+      }
+    }
+  }
+
+  bool octal = leading_zero && (flags_ & ALLOW_OCTALS) != 0;
+
+  // Copy significant digits of the integer part (if any) to the buffer.
+  while (*current >= '0' && *current <= '9') {
+    if (significant_digits < kMaxSignificantDigits) {
+      ASSERT(buffer_pos < kBufferSize);
+      buffer[buffer_pos++] = static_cast<char>(*current);
+      significant_digits++;
+      // Will later check if it's an octal in the buffer.
+    } else {
+      insignificant_digits++;  // Move the digit into the exponential part.
+      nonzero_digit_dropped = nonzero_digit_dropped || *current != '0';
+    }
+    octal = octal && *current < '8';
+    ++current;
+    if (current == end) goto parsing_done;
+  }
+
+  if (significant_digits == 0) {
+    octal = false;
+  }
+
+  if (*current == '.') {
+    if (octal && !allow_trailing_junk) return junk_string_value_;
+    if (octal) goto parsing_done;
+
+    ++current;
+    if (current == end) {
+      if (significant_digits == 0 && !leading_zero) {
+        return junk_string_value_;
+      } else {
+        goto parsing_done;
+      }
+    }
+
+    if (significant_digits == 0) {
+      // octal = false;
+      // Integer part consists of 0 or is absent. Significant digits start after
+      // leading zeros (if any).
+      while (*current == '0') {
+        ++current;
+        if (current == end) {
+          *processed_characters_count = static_cast<int>(current - input);
+          return SignedZero(sign);
+        }
+        exponent--;  // Move this 0 into the exponent.
+      }
+    }
+
+    // There is a fractional part.
+    // We don't emit a '.', but adjust the exponent instead.
+    while (*current >= '0' && *current <= '9') {
+      if (significant_digits < kMaxSignificantDigits) {
+        ASSERT(buffer_pos < kBufferSize);
+        buffer[buffer_pos++] = static_cast<char>(*current);
+        significant_digits++;
+        exponent--;
+      } else {
+        // Ignore insignificant digits in the fractional part.
+        nonzero_digit_dropped = nonzero_digit_dropped || *current != '0';
+      }
+      ++current;
+      if (current == end) goto parsing_done;
+    }
+  }
+
+  if (!leading_zero && exponent == 0 && significant_digits == 0) {
+    // If leading_zeros is true then the string contains zeros.
+    // If exponent < 0 then string was [+-]\.0*...
+    // If significant_digits != 0 the string is not equal to 0.
+    // Otherwise there are no digits in the string.
+    return junk_string_value_;
+  }
+
+  // Parse exponential part.
+  if (*current == 'e' || *current == 'E') {
+    if (octal && !allow_trailing_junk) return junk_string_value_;
+    if (octal) goto parsing_done;
+    ++current;
+    if (current == end) {
+      if (allow_trailing_junk) {
+        goto parsing_done;
+      } else {
+        return junk_string_value_;
+      }
+    }
+    char sign = '+';
+    if (*current == '+' || *current == '-') {
+      sign = static_cast<char>(*current);
+      ++current;
+      if (current == end) {
+        if (allow_trailing_junk) {
+          goto parsing_done;
+        } else {
+          return junk_string_value_;
+        }
+      }
+    }
+
+    if (current == end || *current < '0' || *current > '9') {
+      if (allow_trailing_junk) {
+        goto parsing_done;
+      } else {
+        return junk_string_value_;
+      }
+    }
+
+    const int max_exponent = INT_MAX / 2;
+    ASSERT(-max_exponent / 2 <= exponent && exponent <= max_exponent / 2);
+    int num = 0;
+    do {
+      // Check overflow.
+      int digit = *current - '0';
+      if (num >= max_exponent / 10
+          && !(num == max_exponent / 10 && digit <= max_exponent % 10)) {
+        num = max_exponent;
+      } else {
+        num = num * 10 + digit;
+      }
+      ++current;
+    } while (current != end && *current >= '0' && *current <= '9');
+
+    exponent += (sign == '-' ? -num : num);
+  }
+
+  if (!(allow_trailing_spaces || allow_trailing_junk) && (current != end)) {
+    return junk_string_value_;
+  }
+  if (!allow_trailing_junk && AdvanceToNonspace(&current, end)) {
+    return junk_string_value_;
+  }
+  if (allow_trailing_spaces) {
+    AdvanceToNonspace(&current, end);
+  }
+
+  parsing_done:
+  exponent += insignificant_digits;
+
+  if (octal) {
+    double result;
+    const char* tail_pointer = NULL;
+    result = RadixStringToIeee<3>(buffer,
+                                  buffer + buffer_pos,
+                                  sign,
+                                  allow_trailing_junk,
+                                  junk_string_value_,
+                                  read_as_double,
+                                  &tail_pointer);
+    ASSERT(tail_pointer != NULL);
+    *processed_characters_count = static_cast<int>(current - input);
+    return result;
+  }
+
+  if (nonzero_digit_dropped) {
+    buffer[buffer_pos++] = '1';
+    exponent--;
+  }
+
+  ASSERT(buffer_pos < kBufferSize);
+  buffer[buffer_pos] = '\0';
+
+  double converted;
+  if (read_as_double) {
+    converted = Strtod(Vector<const char>(buffer, buffer_pos), exponent);
+  } else {
+    converted = Strtof(Vector<const char>(buffer, buffer_pos), exponent);
+  }
+  *processed_characters_count = static_cast<int>(current - input);
+  return sign? -converted: converted;
+}
+
+}  // namespace double_conversion
diff --git a/base/poco/Foundation/src/double-conversion.h b/base/poco/Foundation/src/double-conversion.h
new file mode 100644
index 00000000000..1c3387d4f84
--- /dev/null
+++ b/base/poco/Foundation/src/double-conversion.h
@@ -0,0 +1,536 @@
+// Copyright 2012 the V8 project authors. 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 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 Google Inc. 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 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
+// OWNER 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.
+
+#ifndef DOUBLE_CONVERSION_DOUBLE_CONVERSION_H_
+#define DOUBLE_CONVERSION_DOUBLE_CONVERSION_H_
+
+#include "utils.h"
+
+namespace double_conversion {
+
+class DoubleToStringConverter {
+ public:
+  // When calling ToFixed with a double > 10^kMaxFixedDigitsBeforePoint
+  // or a requested_digits parameter > kMaxFixedDigitsAfterPoint then the
+  // function returns false.
+  static const int kMaxFixedDigitsBeforePoint = 60;
+  static const int kMaxFixedDigitsAfterPoint = 60;
+
+  // When calling ToExponential with a requested_digits
+  // parameter > kMaxExponentialDigits then the function returns false.
+  static const int kMaxExponentialDigits = 120;
+
+  // When calling ToPrecision with a requested_digits
+  // parameter < kMinPrecisionDigits or requested_digits > kMaxPrecisionDigits
+  // then the function returns false.
+  static const int kMinPrecisionDigits = 1;
+  static const int kMaxPrecisionDigits = 120;
+
+  enum Flags {
+    NO_FLAGS = 0,
+    EMIT_POSITIVE_EXPONENT_SIGN = 1,
+    EMIT_TRAILING_DECIMAL_POINT = 2,
+    EMIT_TRAILING_ZERO_AFTER_POINT = 4,
+    UNIQUE_ZERO = 8
+  };
+
+  // Flags should be a bit-or combination of the possible Flags-enum.
+  //  - NO_FLAGS: no special flags.
+  //  - EMIT_POSITIVE_EXPONENT_SIGN: when the number is converted into exponent
+  //    form, emits a '+' for positive exponents. Example: 1.2e+2.
+  //  - EMIT_TRAILING_DECIMAL_POINT: when the input number is an integer and is
+  //    converted into decimal format then a trailing decimal point is appended.
+  //    Example: 2345.0 is converted to "2345.".
+  //  - EMIT_TRAILING_ZERO_AFTER_POINT: in addition to a trailing decimal point
+  //    emits a trailing '0'-character. This flag requires the
+  //    EXMIT_TRAILING_DECIMAL_POINT flag.
+  //    Example: 2345.0 is converted to "2345.0".
+  //  - UNIQUE_ZERO: "-0.0" is converted to "0.0".
+  //
+  // Infinity symbol and nan_symbol provide the string representation for these
+  // special values. If the string is NULL and the special value is encountered
+  // then the conversion functions return false.
+  //
+  // The exponent_character is used in exponential representations. It is
+  // usually 'e' or 'E'.
+  //
+  // When converting to the shortest representation the converter will
+  // represent input numbers in decimal format if they are in the interval
+  // [10^decimal_in_shortest_low; 10^decimal_in_shortest_high[
+  //    (lower boundary included, greater boundary excluded).
+  // Example: with decimal_in_shortest_low = -6 and
+  //               decimal_in_shortest_high = 21:
+  //   ToShortest(0.000001)  -> "0.000001"
+  //   ToShortest(0.0000001) -> "1e-7"
+  //   ToShortest(111111111111111111111.0)  -> "111111111111111110000"
+  //   ToShortest(100000000000000000000.0)  -> "100000000000000000000"
+  //   ToShortest(1111111111111111111111.0) -> "1.1111111111111111e+21"
+  //
+  // When converting to precision mode the converter may add
+  // max_leading_padding_zeroes before returning the number in exponential
+  // format.
+  // Example with max_leading_padding_zeroes_in_precision_mode = 6.
+  //   ToPrecision(0.0000012345, 2) -> "0.0000012"
+  //   ToPrecision(0.00000012345, 2) -> "1.2e-7"
+  // Similarily the converter may add up to
+  // max_trailing_padding_zeroes_in_precision_mode in precision mode to avoid
+  // returning an exponential representation. A zero added by the
+  // EMIT_TRAILING_ZERO_AFTER_POINT flag is counted for this limit.
+  // Examples for max_trailing_padding_zeroes_in_precision_mode = 1:
+  //   ToPrecision(230.0, 2) -> "230"
+  //   ToPrecision(230.0, 2) -> "230."  with EMIT_TRAILING_DECIMAL_POINT.
+  //   ToPrecision(230.0, 2) -> "2.3e2" with EMIT_TRAILING_ZERO_AFTER_POINT.
+  DoubleToStringConverter(int flags,
+                          const char* infinity_symbol,
+                          const char* nan_symbol,
+                          char exponent_character,
+                          int decimal_in_shortest_low,
+                          int decimal_in_shortest_high,
+                          int max_leading_padding_zeroes_in_precision_mode,
+                          int max_trailing_padding_zeroes_in_precision_mode)
+      : flags_(flags),
+        infinity_symbol_(infinity_symbol),
+        nan_symbol_(nan_symbol),
+        exponent_character_(exponent_character),
+        decimal_in_shortest_low_(decimal_in_shortest_low),
+        decimal_in_shortest_high_(decimal_in_shortest_high),
+        max_leading_padding_zeroes_in_precision_mode_(
+            max_leading_padding_zeroes_in_precision_mode),
+        max_trailing_padding_zeroes_in_precision_mode_(
+            max_trailing_padding_zeroes_in_precision_mode) {
+    // When 'trailing zero after the point' is set, then 'trailing point'
+    // must be set too.
+    ASSERT(((flags & EMIT_TRAILING_DECIMAL_POINT) != 0) ||
+        !((flags & EMIT_TRAILING_ZERO_AFTER_POINT) != 0));
+  }
+
+  // Returns a converter following the EcmaScript specification.
+  static const DoubleToStringConverter& EcmaScriptConverter();
+
+  // Computes the shortest string of digits that correctly represent the input
+  // number. Depending on decimal_in_shortest_low and decimal_in_shortest_high
+  // (see constructor) it then either returns a decimal representation, or an
+  // exponential representation.
+  // Example with decimal_in_shortest_low = -6,
+  //              decimal_in_shortest_high = 21,
+  //              EMIT_POSITIVE_EXPONENT_SIGN activated, and
+  //              EMIT_TRAILING_DECIMAL_POINT deactived:
+  //   ToShortest(0.000001)  -> "0.000001"
+  //   ToShortest(0.0000001) -> "1e-7"
+  //   ToShortest(111111111111111111111.0)  -> "111111111111111110000"
+  //   ToShortest(100000000000000000000.0)  -> "100000000000000000000"
+  //   ToShortest(1111111111111111111111.0) -> "1.1111111111111111e+21"
+  //
+  // Note: the conversion may round the output if the returned string
+  // is accurate enough to uniquely identify the input-number.
+  // For example the most precise representation of the double 9e59 equals
+  // "899999999999999918767229449717619953810131273674690656206848", but
+  // the converter will return the shorter (but still correct) "9e59".
+  //
+  // Returns true if the conversion succeeds. The conversion always succeeds
+  // except when the input value is special and no infinity_symbol or
+  // nan_symbol has been given to the constructor.
+  bool ToShortest(double value, StringBuilder* result_builder) const {
+    return ToShortestIeeeNumber(value, result_builder, SHORTEST);
+  }
+
+  // Same as ToShortest, but for single-precision floats.
+  bool ToShortestSingle(float value, StringBuilder* result_builder) const {
+    return ToShortestIeeeNumber(value, result_builder, SHORTEST_SINGLE);
+  }
+
+
+  // Computes a decimal representation with a fixed number of digits after the
+  // decimal point. The last emitted digit is rounded.
+  //
+  // Examples:
+  //   ToFixed(3.12, 1) -> "3.1"
+  //   ToFixed(3.1415, 3) -> "3.142"
+  //   ToFixed(1234.56789, 4) -> "1234.5679"
+  //   ToFixed(1.23, 5) -> "1.23000"
+  //   ToFixed(0.1, 4) -> "0.1000"
+  //   ToFixed(1e30, 2) -> "1000000000000000019884624838656.00"
+  //   ToFixed(0.1, 30) -> "0.100000000000000005551115123126"
+  //   ToFixed(0.1, 17) -> "0.10000000000000001"
+  //
+  // If requested_digits equals 0, then the tail of the result depends on
+  // the EMIT_TRAILING_DECIMAL_POINT and EMIT_TRAILING_ZERO_AFTER_POINT.
+  // Examples, for requested_digits == 0,
+  //   let EMIT_TRAILING_DECIMAL_POINT and EMIT_TRAILING_ZERO_AFTER_POINT be
+  //    - false and false: then 123.45 -> 123
+  //                             0.678 -> 1
+  //    - true and false: then 123.45 -> 123.
+  //                            0.678 -> 1.
+  //    - true and true: then 123.45 -> 123.0
+  //                           0.678 -> 1.0
+  //
+  // Returns true if the conversion succeeds. The conversion always succeeds
+  // except for the following cases:
+  //   - the input value is special and no infinity_symbol or nan_symbol has
+  //     been provided to the constructor,
+  //   - 'value' > 10^kMaxFixedDigitsBeforePoint, or
+  //   - 'requested_digits' > kMaxFixedDigitsAfterPoint.
+  // The last two conditions imply that the result will never contain more than
+  // 1 + kMaxFixedDigitsBeforePoint + 1 + kMaxFixedDigitsAfterPoint characters
+  // (one additional character for the sign, and one for the decimal point).
+  bool ToFixed(double value,
+               int requested_digits,
+               StringBuilder* result_builder) const;
+
+  // Computes a representation in exponential format with requested_digits
+  // after the decimal point. The last emitted digit is rounded.
+  // If requested_digits equals -1, then the shortest exponential representation
+  // is computed.
+  //
+  // Examples with EMIT_POSITIVE_EXPONENT_SIGN deactivated, and
+  //               exponent_character set to 'e'.
+  //   ToExponential(3.12, 1) -> "3.1e0"
+  //   ToExponential(5.0, 3) -> "5.000e0"
+  //   ToExponential(0.001, 2) -> "1.00e-3"
+  //   ToExponential(3.1415, -1) -> "3.1415e0"
+  //   ToExponential(3.1415, 4) -> "3.1415e0"
+  //   ToExponential(3.1415, 3) -> "3.142e0"
+  //   ToExponential(123456789000000, 3) -> "1.235e14"
+  //   ToExponential(1000000000000000019884624838656.0, -1) -> "1e30"
+  //   ToExponential(1000000000000000019884624838656.0, 32) ->
+  //                     "1.00000000000000001988462483865600e30"
+  //   ToExponential(1234, 0) -> "1e3"
+  //
+  // Returns true if the conversion succeeds. The conversion always succeeds
+  // except for the following cases:
+  //   - the input value is special and no infinity_symbol or nan_symbol has
+  //     been provided to the constructor,
+  //   - 'requested_digits' > kMaxExponentialDigits.
+  // The last condition implies that the result will never contain more than
+  // kMaxExponentialDigits + 8 characters (the sign, the digit before the
+  // decimal point, the decimal point, the exponent character, the
+  // exponent's sign, and at most 3 exponent digits).
+  bool ToExponential(double value,
+                     int requested_digits,
+                     StringBuilder* result_builder) const;
+
+  // Computes 'precision' leading digits of the given 'value' and returns them
+  // either in exponential or decimal format, depending on
+  // max_{leading|trailing}_padding_zeroes_in_precision_mode (given to the
+  // constructor).
+  // The last computed digit is rounded.
+  //
+  // Example with max_leading_padding_zeroes_in_precision_mode = 6.
+  //   ToPrecision(0.0000012345, 2) -> "0.0000012"
+  //   ToPrecision(0.00000012345, 2) -> "1.2e-7"
+  // Similarily the converter may add up to
+  // max_trailing_padding_zeroes_in_precision_mode in precision mode to avoid
+  // returning an exponential representation. A zero added by the
+  // EMIT_TRAILING_ZERO_AFTER_POINT flag is counted for this limit.
+  // Examples for max_trailing_padding_zeroes_in_precision_mode = 1:
+  //   ToPrecision(230.0, 2) -> "230"
+  //   ToPrecision(230.0, 2) -> "230."  with EMIT_TRAILING_DECIMAL_POINT.
+  //   ToPrecision(230.0, 2) -> "2.3e2" with EMIT_TRAILING_ZERO_AFTER_POINT.
+  // Examples for max_trailing_padding_zeroes_in_precision_mode = 3, and no
+  //    EMIT_TRAILING_ZERO_AFTER_POINT:
+  //   ToPrecision(123450.0, 6) -> "123450"
+  //   ToPrecision(123450.0, 5) -> "123450"
+  //   ToPrecision(123450.0, 4) -> "123500"
+  //   ToPrecision(123450.0, 3) -> "123000"
+  //   ToPrecision(123450.0, 2) -> "1.2e5"
+  //
+  // Returns true if the conversion succeeds. The conversion always succeeds
+  // except for the following cases:
+  //   - the input value is special and no infinity_symbol or nan_symbol has
+  //     been provided to the constructor,
+  //   - precision < kMinPericisionDigits
+  //   - precision > kMaxPrecisionDigits
+  // The last condition implies that the result will never contain more than
+  // kMaxPrecisionDigits + 7 characters (the sign, the decimal point, the
+  // exponent character, the exponent's sign, and at most 3 exponent digits).
+  bool ToPrecision(double value,
+                   int precision,
+                   StringBuilder* result_builder) const;
+
+  enum DtoaMode {
+    // Produce the shortest correct representation.
+    // For example the output of 0.299999999999999988897 is (the less accurate
+    // but correct) 0.3.
+    SHORTEST,
+    // Same as SHORTEST, but for single-precision floats.
+    SHORTEST_SINGLE,
+    // Produce a fixed number of digits after the decimal point.
+    // For instance fixed(0.1, 4) becomes 0.1000
+    // If the input number is big, the output will be big.
+    FIXED,
+    // Fixed number of digits (independent of the decimal point).
+    PRECISION
+  };
+
+  // The maximal number of digits that are needed to emit a double in base 10.
+  // A higher precision can be achieved by using more digits, but the shortest
+  // accurate representation of any double will never use more digits than
+  // kBase10MaximalLength.
+  // Note that DoubleToAscii null-terminates its input. So the given buffer
+  // should be at least kBase10MaximalLength + 1 characters long.
+  static const int kBase10MaximalLength = 17;
+
+  // Converts the given double 'v' to ascii. 'v' must not be NaN, +Infinity, or
+  // -Infinity. In SHORTEST_SINGLE-mode this restriction also applies to 'v'
+  // after it has been casted to a single-precision float. That is, in this
+  // mode static_cast<float>(v) must not be NaN, +Infinity or -Infinity.
+  //
+  // The result should be interpreted as buffer * 10^(point-length).
+  //
+  // The output depends on the given mode:
+  //  - SHORTEST: produce the least amount of digits for which the internal
+  //   identity requirement is still satisfied. If the digits are printed
+  //   (together with the correct exponent) then reading this number will give
+  //   'v' again. The buffer will choose the representation that is closest to
+  //   'v'. If there are two at the same distance, than the one farther away
+  //   from 0 is chosen (halfway cases - ending with 5 - are rounded up).
+  //   In this mode the 'requested_digits' parameter is ignored.
+  //  - SHORTEST_SINGLE: same as SHORTEST but with single-precision.
+  //  - FIXED: produces digits necessary to print a given number with
+  //   'requested_digits' digits after the decimal point. The produced digits
+  //   might be too short in which case the caller has to fill the remainder
+  //   with '0's.
+  //   Example: toFixed(0.001, 5) is allowed to return buffer="1", point=-2.
+  //   Halfway cases are rounded towards +/-Infinity (away from 0). The call
+  //   toFixed(0.15, 2) thus returns buffer="2", point=0.
+  //   The returned buffer may contain digits that would be truncated from the
+  //   shortest representation of the input.
+  //  - PRECISION: produces 'requested_digits' where the first digit is not '0'.
+  //   Even though the length of produced digits usually equals
+  //   'requested_digits', the function is allowed to return fewer digits, in
+  //   which case the caller has to fill the missing digits with '0's.
+  //   Halfway cases are again rounded away from 0.
+  // DoubleToAscii expects the given buffer to be big enough to hold all
+  // digits and a terminating null-character. In SHORTEST-mode it expects a
+  // buffer of at least kBase10MaximalLength + 1. In all other modes the
+  // requested_digits parameter and the padding-zeroes limit the size of the
+  // output. Don't forget the decimal point, the exponent character and the
+  // terminating null-character when computing the maximal output size.
+  // The given length is only used in debug mode to ensure the buffer is big
+  // enough.
+  static void DoubleToAscii(double v,
+                            DtoaMode mode,
+                            int requested_digits,
+                            char* buffer,
+                            int buffer_length,
+                            bool* sign,
+                            int* length,
+                            int* point);
+
+ private:
+  // Implementation for ToShortest and ToShortestSingle.
+  bool ToShortestIeeeNumber(double value,
+                            StringBuilder* result_builder,
+                            DtoaMode mode) const;
+
+  // If the value is a special value (NaN or Infinity) constructs the
+  // corresponding string using the configured infinity/nan-symbol.
+  // If either of them is NULL or the value is not special then the
+  // function returns false.
+  bool HandleSpecialValues(double value, StringBuilder* result_builder) const;
+  // Constructs an exponential representation (i.e. 1.234e56).
+  // The given exponent assumes a decimal point after the first decimal digit.
+  void CreateExponentialRepresentation(const char* decimal_digits,
+                                       int length,
+                                       int exponent,
+                                       StringBuilder* result_builder) const;
+  // Creates a decimal representation (i.e 1234.5678).
+  void CreateDecimalRepresentation(const char* decimal_digits,
+                                   int length,
+                                   int decimal_point,
+                                   int digits_after_point,
+                                   StringBuilder* result_builder) const;
+
+  const int flags_;
+  const char* const infinity_symbol_;
+  const char* const nan_symbol_;
+  const char exponent_character_;
+  const int decimal_in_shortest_low_;
+  const int decimal_in_shortest_high_;
+  const int max_leading_padding_zeroes_in_precision_mode_;
+  const int max_trailing_padding_zeroes_in_precision_mode_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(DoubleToStringConverter);
+};
+
+
+class StringToDoubleConverter {
+ public:
+  // Enumeration for allowing octals and ignoring junk when converting
+  // strings to numbers.
+  enum Flags {
+    NO_FLAGS = 0,
+    ALLOW_HEX = 1,
+    ALLOW_OCTALS = 2,
+    ALLOW_TRAILING_JUNK = 4,
+    ALLOW_LEADING_SPACES = 8,
+    ALLOW_TRAILING_SPACES = 16,
+    ALLOW_SPACES_AFTER_SIGN = 32
+  };
+
+  // Flags should be a bit-or combination of the possible Flags-enum.
+  //  - NO_FLAGS: no special flags.
+  //  - ALLOW_HEX: recognizes the prefix "0x". Hex numbers may only be integers.
+  //      Ex: StringToDouble("0x1234") -> 4660.0
+  //          In StringToDouble("0x1234.56") the characters ".56" are trailing
+  //          junk. The result of the call is hence dependent on
+  //          the ALLOW_TRAILING_JUNK flag and/or the junk value.
+  //      With this flag "0x" is a junk-string. Even with ALLOW_TRAILING_JUNK,
+  //      the string will not be parsed as "0" followed by junk.
+  //
+  //  - ALLOW_OCTALS: recognizes the prefix "0" for octals:
+  //      If a sequence of octal digits starts with '0', then the number is
+  //      read as octal integer. Octal numbers may only be integers.
+  //      Ex: StringToDouble("01234") -> 668.0
+  //          StringToDouble("012349") -> 12349.0  // Not a sequence of octal
+  //                                               // digits.
+  //          In StringToDouble("01234.56") the characters ".56" are trailing
+  //          junk. The result of the call is hence dependent on
+  //          the ALLOW_TRAILING_JUNK flag and/or the junk value.
+  //          In StringToDouble("01234e56") the characters "e56" are trailing
+  //          junk, too.
+  //  - ALLOW_TRAILING_JUNK: ignore trailing characters that are not part of
+  //      a double literal.
+  //  - ALLOW_LEADING_SPACES: skip over leading spaces.
+  //  - ALLOW_TRAILING_SPACES: ignore trailing spaces.
+  //  - ALLOW_SPACES_AFTER_SIGN: ignore spaces after the sign.
+  //       Ex: StringToDouble("-   123.2") -> -123.2.
+  //           StringToDouble("+   123.2") -> 123.2
+  //
+  // empty_string_value is returned when an empty string is given as input.
+  // If ALLOW_LEADING_SPACES or ALLOW_TRAILING_SPACES are set, then a string
+  // containing only spaces is converted to the 'empty_string_value', too.
+  //
+  // junk_string_value is returned when
+  //  a) ALLOW_TRAILING_JUNK is not set, and a junk character (a character not
+  //     part of a double-literal) is found.
+  //  b) ALLOW_TRAILING_JUNK is set, but the string does not start with a
+  //     double literal.
+  //
+  // infinity_symbol and nan_symbol are strings that are used to detect
+  // inputs that represent infinity and NaN. They can be null, in which case
+  // they are ignored.
+  // The conversion routine first reads any possible signs. Then it compares the
+  // following character of the input-string with the first character of
+  // the infinity, and nan-symbol. If either matches, the function assumes, that
+  // a match has been found, and expects the following input characters to match
+  // the remaining characters of the special-value symbol.
+  // This means that the following restrictions apply to special-value symbols:
+  //  - they must not start with signs ('+', or '-'),
+  //  - they must not have the same first character.
+  //  - they must not start with digits.
+  //
+  // Examples:
+  //  flags = ALLOW_HEX | ALLOW_TRAILING_JUNK,
+  //  empty_string_value = 0.0,
+  //  junk_string_value = NaN,
+  //  infinity_symbol = "infinity",
+  //  nan_symbol = "nan":
+  //    StringToDouble("0x1234") -> 4660.0.
+  //    StringToDouble("0x1234K") -> 4660.0.
+  //    StringToDouble("") -> 0.0  // empty_string_value.
+  //    StringToDouble(" ") -> NaN  // junk_string_value.
+  //    StringToDouble(" 1") -> NaN  // junk_string_value.
+  //    StringToDouble("0x") -> NaN  // junk_string_value.
+  //    StringToDouble("-123.45") -> -123.45.
+  //    StringToDouble("--123.45") -> NaN  // junk_string_value.
+  //    StringToDouble("123e45") -> 123e45.
+  //    StringToDouble("123E45") -> 123e45.
+  //    StringToDouble("123e+45") -> 123e45.
+  //    StringToDouble("123E-45") -> 123e-45.
+  //    StringToDouble("123e") -> 123.0  // trailing junk ignored.
+  //    StringToDouble("123e-") -> 123.0  // trailing junk ignored.
+  //    StringToDouble("+NaN") -> NaN  // NaN string literal.
+  //    StringToDouble("-infinity") -> -inf.  // infinity literal.
+  //    StringToDouble("Infinity") -> NaN  // junk_string_value.
+  //
+  //  flags = ALLOW_OCTAL | ALLOW_LEADING_SPACES,
+  //  empty_string_value = 0.0,
+  //  junk_string_value = NaN,
+  //  infinity_symbol = NULL,
+  //  nan_symbol = NULL:
+  //    StringToDouble("0x1234") -> NaN  // junk_string_value.
+  //    StringToDouble("01234") -> 668.0.
+  //    StringToDouble("") -> 0.0  // empty_string_value.
+  //    StringToDouble(" ") -> 0.0  // empty_string_value.
+  //    StringToDouble(" 1") -> 1.0
+  //    StringToDouble("0x") -> NaN  // junk_string_value.
+  //    StringToDouble("0123e45") -> NaN  // junk_string_value.
+  //    StringToDouble("01239E45") -> 1239e45.
+  //    StringToDouble("-infinity") -> NaN  // junk_string_value.
+  //    StringToDouble("NaN") -> NaN  // junk_string_value.
+  StringToDoubleConverter(int flags,
+                          double empty_string_value,
+                          double junk_string_value,
+                          const char* infinity_symbol,
+                          const char* nan_symbol)
+      : flags_(flags),
+        empty_string_value_(empty_string_value),
+        junk_string_value_(junk_string_value),
+        infinity_symbol_(infinity_symbol),
+        nan_symbol_(nan_symbol) {
+  }
+
+  // Performs the conversion.
+  // The output parameter 'processed_characters_count' is set to the number
+  // of characters that have been processed to read the number.
+  // Spaces than are processed with ALLOW_{LEADING|TRAILING}_SPACES are included
+  // in the 'processed_characters_count'. Trailing junk is never included.
+  double StringToDouble(const char* buffer,
+                        int length,
+                        int* processed_characters_count) const {
+    return StringToIeee(buffer, length, processed_characters_count, true);
+  }
+
+  // Same as StringToDouble but reads a float.
+  // Note that this is not equivalent to static_cast<float>(StringToDouble(...))
+  // due to potential double-rounding.
+  float StringToFloat(const char* buffer,
+                      int length,
+                      int* processed_characters_count) const {
+    return static_cast<float>(StringToIeee(buffer, length,
+                                           processed_characters_count, false));
+  }
+
+ private:
+  const int flags_;
+  const double empty_string_value_;
+  const double junk_string_value_;
+  const char* const infinity_symbol_;
+  const char* const nan_symbol_;
+
+  double StringToIeee(const char* buffer,
+                      int length,
+                      int* processed_characters_count,
+                      bool read_as_double) const;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(StringToDoubleConverter);
+};
+
+}  // namespace double_conversion
+
+#endif  // DOUBLE_CONVERSION_DOUBLE_CONVERSION_H_
diff --git a/base/poco/Foundation/src/fast-dtoa.cc b/base/poco/Foundation/src/fast-dtoa.cc
new file mode 100644
index 00000000000..857a1301472
--- /dev/null
+++ b/base/poco/Foundation/src/fast-dtoa.cc
@@ -0,0 +1,665 @@
+// Copyright 2012 the V8 project authors. 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 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 Google Inc. 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 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
+// OWNER 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.
+
+#include "fast-dtoa.h"
+
+#include "cached-powers.h"
+#include "diy-fp.h"
+#include "ieee.h"
+
+namespace double_conversion {
+
+// The minimal and maximal target exponent define the range of w's binary
+// exponent, where 'w' is the result of multiplying the input by a cached power
+// of ten.
+//
+// A different range might be chosen on a different platform, to optimize digit
+// generation, but a smaller range requires more powers of ten to be cached.
+static const int kMinimalTargetExponent = -60;
+static const int kMaximalTargetExponent = -32;
+
+
+// Adjusts the last digit of the generated number, and screens out generated
+// solutions that may be inaccurate. A solution may be inaccurate if it is
+// outside the safe interval, or if we cannot prove that it is closer to the
+// input than a neighboring representation of the same length.
+//
+// Input: * buffer containing the digits of too_high / 10^kappa
+//        * the buffer's length
+//        * distance_too_high_w == (too_high - w).f() * unit
+//        * unsafe_interval == (too_high - too_low).f() * unit
+//        * rest = (too_high - buffer * 10^kappa).f() * unit
+//        * ten_kappa = 10^kappa * unit
+//        * unit = the common multiplier
+// Output: returns true if the buffer is guaranteed to contain the closest
+//    representable number to the input.
+//  Modifies the generated digits in the buffer to approach (round towards) w.
+static bool RoundWeed(Vector<char> buffer,
+                      int length,
+                      uint64_t distance_too_high_w,
+                      uint64_t unsafe_interval,
+                      uint64_t rest,
+                      uint64_t ten_kappa,
+                      uint64_t unit) {
+  uint64_t small_distance = distance_too_high_w - unit;
+  uint64_t big_distance = distance_too_high_w + unit;
+  // Let w_low  = too_high - big_distance, and
+  //     w_high = too_high - small_distance.
+  // Note: w_low < w < w_high
+  //
+  // The real w (* unit) must lie somewhere inside the interval
+  // ]w_low; w_high[ (often written as "(w_low; w_high)")
+
+  // Basically the buffer currently contains a number in the unsafe interval
+  // ]too_low; too_high[ with too_low < w < too_high
+  //
+  //  too_high - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  //                     ^v 1 unit            ^      ^                 ^      ^
+  //  boundary_high ---------------------     .      .                 .      .
+  //                     ^v 1 unit            .      .                 .      .
+  //   - - - - - - - - - - - - - - - - - - -  +  - - + - - - - - -     .      .
+  //                                          .      .         ^       .      .
+  //                                          .  big_distance  .       .      .
+  //                                          .      .         .       .    rest
+  //                              small_distance     .         .       .      .
+  //                                          v      .         .       .      .
+  //  w_high - - - - - - - - - - - - - - - - - -     .         .       .      .
+  //                     ^v 1 unit                   .         .       .      .
+  //  w ----------------------------------------     .         .       .      .
+  //                     ^v 1 unit                   v         .       .      .
+  //  w_low  - - - - - - - - - - - - - - - - - - - - -         .       .      .
+  //                                                           .       .      v
+  //  buffer --------------------------------------------------+-------+--------
+  //                                                           .       .
+  //                                                  safe_interval    .
+  //                                                           v       .
+  //   - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -     .
+  //                     ^v 1 unit                                     .
+  //  boundary_low -------------------------                     unsafe_interval
+  //                     ^v 1 unit                                     v
+  //  too_low  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  //
+  //
+  // Note that the value of buffer could lie anywhere inside the range too_low
+  // to too_high.
+  //
+  // boundary_low, boundary_high and w are approximations of the real boundaries
+  // and v (the input number). They are guaranteed to be precise up to one unit.
+  // In fact the error is guaranteed to be strictly less than one unit.
+  //
+  // Anything that lies outside the unsafe interval is guaranteed not to round
+  // to v when read again.
+  // Anything that lies inside the safe interval is guaranteed to round to v
+  // when read again.
+  // If the number inside the buffer lies inside the unsafe interval but not
+  // inside the safe interval then we simply do not know and bail out (returning
+  // false).
+  //
+  // Similarly we have to take into account the imprecision of 'w' when finding
+  // the closest representation of 'w'. If we have two potential
+  // representations, and one is closer to both w_low and w_high, then we know
+  // it is closer to the actual value v.
+  //
+  // By generating the digits of too_high we got the largest (closest to
+  // too_high) buffer that is still in the unsafe interval. In the case where
+  // w_high < buffer < too_high we try to decrement the buffer.
+  // This way the buffer approaches (rounds towards) w.
+  // There are 3 conditions that stop the decrementation process:
+  //   1) the buffer is already below w_high
+  //   2) decrementing the buffer would make it leave the unsafe interval
+  //   3) decrementing the buffer would yield a number below w_high and farther
+  //      away than the current number. In other words:
+  //              (buffer{-1} < w_high) && w_high - buffer{-1} > buffer - w_high
+  // Instead of using the buffer directly we use its distance to too_high.
+  // Conceptually rest ~= too_high - buffer
+  // We need to do the following tests in this order to avoid over- and
+  // underflows.
+  ASSERT(rest <= unsafe_interval);
+  while (rest < small_distance &&  // Negated condition 1
+         unsafe_interval - rest >= ten_kappa &&  // Negated condition 2
+         (rest + ten_kappa < small_distance ||  // buffer{-1} > w_high
+          small_distance - rest >= rest + ten_kappa - small_distance)) {
+    buffer[length - 1]--;
+    rest += ten_kappa;
+  }
+
+  // We have approached w+ as much as possible. We now test if approaching w-
+  // would require changing the buffer. If yes, then we have two possible
+  // representations close to w, but we cannot decide which one is closer.
+  if (rest < big_distance &&
+      unsafe_interval - rest >= ten_kappa &&
+      (rest + ten_kappa < big_distance ||
+       big_distance - rest > rest + ten_kappa - big_distance)) {
+    return false;
+  }
+
+  // Weeding test.
+  //   The safe interval is [too_low + 2 ulp; too_high - 2 ulp]
+  //   Since too_low = too_high - unsafe_interval this is equivalent to
+  //      [too_high - unsafe_interval + 4 ulp; too_high - 2 ulp]
+  //   Conceptually we have: rest ~= too_high - buffer
+  return (2 * unit <= rest) && (rest <= unsafe_interval - 4 * unit);
+}
+
+
+// Rounds the buffer upwards if the result is closer to v by possibly adding
+// 1 to the buffer. If the precision of the calculation is not sufficient to
+// round correctly, return false.
+// The rounding might shift the whole buffer in which case the kappa is
+// adjusted. For example "99", kappa = 3 might become "10", kappa = 4.
+//
+// If 2*rest > ten_kappa then the buffer needs to be round up.
+// rest can have an error of +/- 1 unit. This function accounts for the
+// imprecision and returns false, if the rounding direction cannot be
+// unambiguously determined.
+//
+// Precondition: rest < ten_kappa.
+static bool RoundWeedCounted(Vector<char> buffer,
+                             int length,
+                             uint64_t rest,
+                             uint64_t ten_kappa,
+                             uint64_t unit,
+                             int* kappa) {
+  ASSERT(rest < ten_kappa);
+  // The following tests are done in a specific order to avoid overflows. They
+  // will work correctly with any uint64 values of rest < ten_kappa and unit.
+  //
+  // If the unit is too big, then we don't know which way to round. For example
+  // a unit of 50 means that the real number lies within rest +/- 50. If
+  // 10^kappa == 40 then there is no way to tell which way to round.
+  if (unit >= ten_kappa) return false;
+  // Even if unit is just half the size of 10^kappa we are already completely
+  // lost. (And after the previous test we know that the expression will not
+  // over/underflow.)
+  if (ten_kappa - unit <= unit) return false;
+  // If 2 * (rest + unit) <= 10^kappa we can safely round down.
+  if ((ten_kappa - rest > rest) && (ten_kappa - 2 * rest >= 2 * unit)) {
+    return true;
+  }
+  // If 2 * (rest - unit) >= 10^kappa, then we can safely round up.
+  if ((rest > unit) && (ten_kappa - (rest - unit) <= (rest - unit))) {
+    // Increment the last digit recursively until we find a non '9' digit.
+    buffer[length - 1]++;
+    for (int i = length - 1; i > 0; --i) {
+      if (buffer[i] != '0' + 10) break;
+      buffer[i] = '0';
+      buffer[i - 1]++;
+    }
+    // If the first digit is now '0'+ 10 we had a buffer with all '9's. With the
+    // exception of the first digit all digits are now '0'. Simply switch the
+    // first digit to '1' and adjust the kappa. Example: "99" becomes "10" and
+    // the power (the kappa) is increased.
+    if (buffer[0] == '0' + 10) {
+      buffer[0] = '1';
+      (*kappa) += 1;
+    }
+    return true;
+  }
+  return false;
+}
+
+// Returns the biggest power of ten that is less than or equal to the given
+// number. We furthermore receive the maximum number of bits 'number' has.
+//
+// Returns power == 10^(exponent_plus_one-1) such that
+//    power <= number < power * 10.
+// If number_bits == 0 then 0^(0-1) is returned.
+// The number of bits must be <= 32.
+// Precondition: number < (1 << (number_bits + 1)).
+
+// Inspired by the method for finding an integer log base 10 from here:
+// http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10
+static unsigned int const kSmallPowersOfTen[] =
+    {0, 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000,
+     1000000000};
+
+static void BiggestPowerTen(uint32_t number,
+                            int number_bits,
+                            uint32_t* power,
+                            int* exponent_plus_one) {
+  ASSERT(number < (1u << (number_bits + 1)));
+  // 1233/4096 is approximately 1/lg(10).
+  int exponent_plus_one_guess = ((number_bits + 1) * 1233 >> 12);
+  // We increment to skip over the first entry in the kPowersOf10 table.
+  // Note: kPowersOf10[i] == 10^(i-1).
+  exponent_plus_one_guess++;
+  // We don't have any guarantees that 2^number_bits <= number.
+  if (number < kSmallPowersOfTen[exponent_plus_one_guess] && exponent_plus_one_guess > 0) {
+    exponent_plus_one_guess--;
+  }
+  *power = kSmallPowersOfTen[exponent_plus_one_guess];
+  *exponent_plus_one = exponent_plus_one_guess;
+}
+
+// Generates the digits of input number w.
+// w is a floating-point number (DiyFp), consisting of a significand and an
+// exponent. Its exponent is bounded by kMinimalTargetExponent and
+// kMaximalTargetExponent.
+//       Hence -60 <= w.e() <= -32.
+//
+// Returns false if it fails, in which case the generated digits in the buffer
+// should not be used.
+// Preconditions:
+//  * low, w and high are correct up to 1 ulp (unit in the last place). That
+//    is, their error must be less than a unit of their last digits.
+//  * low.e() == w.e() == high.e()
+//  * low < w < high, and taking into account their error: low~ <= high~
+//  * kMinimalTargetExponent <= w.e() <= kMaximalTargetExponent
+// Postconditions: returns false if procedure fails.
+//   otherwise:
+//     * buffer is not null-terminated, but len contains the number of digits.
+//     * buffer contains the shortest possible decimal digit-sequence
+//       such that LOW < buffer * 10^kappa < HIGH, where LOW and HIGH are the
+//       correct values of low and high (without their error).
+//     * if more than one decimal representation gives the minimal number of
+//       decimal digits then the one closest to W (where W is the correct value
+//       of w) is chosen.
+// Remark: this procedure takes into account the imprecision of its input
+//   numbers. If the precision is not enough to guarantee all the postconditions
+//   then false is returned. This usually happens rarely (~0.5%).
+//
+// Say, for the sake of example, that
+//   w.e() == -48, and w.f() == 0x1234567890abcdef
+// w's value can be computed by w.f() * 2^w.e()
+// We can obtain w's integral digits by simply shifting w.f() by -w.e().
+//  -> w's integral part is 0x1234
+//  w's fractional part is therefore 0x567890abcdef.
+// Printing w's integral part is easy (simply print 0x1234 in decimal).
+// In order to print its fraction we repeatedly multiply the fraction by 10 and
+// get each digit. Example the first digit after the point would be computed by
+//   (0x567890abcdef * 10) >> 48. -> 3
+// The whole thing becomes slightly more complicated because we want to stop
+// once we have enough digits. That is, once the digits inside the buffer
+// represent 'w' we can stop. Everything inside the interval low - high
+// represents w. However we have to pay attention to low, high and w's
+// imprecision.
+static bool DigitGen(DiyFp low,
+                     DiyFp w,
+                     DiyFp high,
+                     Vector<char> buffer,
+                     int* length,
+                     int* kappa) {
+  ASSERT(low.e() == w.e() && w.e() == high.e());
+  ASSERT(low.f() + 1 <= high.f() - 1);
+  ASSERT(kMinimalTargetExponent <= w.e() && w.e() <= kMaximalTargetExponent);
+  // low, w and high are imprecise, but by less than one ulp (unit in the last
+  // place).
+  // If we remove (resp. add) 1 ulp from low (resp. high) we are certain that
+  // the new numbers are outside of the interval we want the final
+  // representation to lie in.
+  // Inversely adding (resp. removing) 1 ulp from low (resp. high) would yield
+  // numbers that are certain to lie in the interval. We will use this fact
+  // later on.
+  // We will now start by generating the digits within the uncertain
+  // interval. Later we will weed out representations that lie outside the safe
+  // interval and thus _might_ lie outside the correct interval.
+  uint64_t unit = 1;
+  DiyFp too_low = DiyFp(low.f() - unit, low.e());
+  DiyFp too_high = DiyFp(high.f() + unit, high.e());
+  // too_low and too_high are guaranteed to lie outside the interval we want the
+  // generated number in.
+  DiyFp unsafe_interval = DiyFp::Minus(too_high, too_low);
+  // We now cut the input number into two parts: the integral digits and the
+  // fractionals. We will not write any decimal separator though, but adapt
+  // kappa instead.
+  // Reminder: we are currently computing the digits (stored inside the buffer)
+  // such that:   too_low < buffer * 10^kappa < too_high
+  // We use too_high for the digit_generation and stop as soon as possible.
+  // If we stop early we effectively round down.
+  DiyFp one = DiyFp(static_cast<uint64_t>(1) << -w.e(), w.e());
+  // Division by one is a shift.
+  uint32_t integrals = static_cast<uint32_t>(too_high.f() >> -one.e());
+  // Modulo by one is an and.
+  uint64_t fractionals = too_high.f() & (one.f() - 1);
+  uint32_t divisor;
+  int divisor_exponent_plus_one;
+  BiggestPowerTen(integrals, DiyFp::kSignificandSize - (-one.e()),
+                  &divisor, &divisor_exponent_plus_one);
+  *kappa = divisor_exponent_plus_one;
+  *length = 0;
+  // Loop invariant: buffer = too_high / 10^kappa  (integer division)
+  // The invariant holds for the first iteration: kappa has been initialized
+  // with the divisor exponent + 1. And the divisor is the biggest power of ten
+  // that is smaller than integrals.
+  while (*kappa > 0) {
+    int digit = integrals / divisor;
+    ASSERT(digit <= 9);
+    buffer[*length] = static_cast<char>('0' + digit);
+    (*length)++;
+    integrals %= divisor;
+    (*kappa)--;
+    // Note that kappa now equals the exponent of the divisor and that the
+    // invariant thus holds again.
+    uint64_t rest =
+        (static_cast<uint64_t>(integrals) << -one.e()) + fractionals;
+    // Invariant: too_high = buffer * 10^kappa + DiyFp(rest, one.e())
+    // Reminder: unsafe_interval.e() == one.e()
+    if (rest < unsafe_interval.f()) {
+      // Rounding down (by not emitting the remaining digits) yields a number
+      // that lies within the unsafe interval.
+      return RoundWeed(buffer, *length, DiyFp::Minus(too_high, w).f(),
+                       unsafe_interval.f(), rest,
+                       static_cast<uint64_t>(divisor) << -one.e(), unit);
+    }
+    divisor /= 10;
+  }
+
+  // The integrals have been generated. We are at the point of the decimal
+  // separator. In the following loop we simply multiply the remaining digits by
+  // 10 and divide by one. We just need to pay attention to multiply associated
+  // data (like the interval or 'unit'), too.
+  // Note that the multiplication by 10 does not overflow, because w.e >= -60
+  // and thus one.e >= -60.
+  ASSERT(one.e() >= -60);
+  ASSERT(fractionals < one.f());
+  ASSERT(UINT64_2PART_C(0xFFFFFFFF, FFFFFFFF) / 10 >= one.f());
+  for (;;) {
+    fractionals *= 10;
+    unit *= 10;
+    unsafe_interval.set_f(unsafe_interval.f() * 10);
+    // Integer division by one.
+    int digit = static_cast<int>(fractionals >> -one.e());
+    ASSERT(digit <= 9);
+    buffer[*length] = static_cast<char>('0' + digit);
+    (*length)++;
+    fractionals &= one.f() - 1;  // Modulo by one.
+    (*kappa)--;
+    if (fractionals < unsafe_interval.f()) {
+      return RoundWeed(buffer, *length, DiyFp::Minus(too_high, w).f() * unit,
+                       unsafe_interval.f(), fractionals, one.f(), unit);
+    }
+  }
+}
+
+
+
+// Generates (at most) requested_digits digits of input number w.
+// w is a floating-point number (DiyFp), consisting of a significand and an
+// exponent. Its exponent is bounded by kMinimalTargetExponent and
+// kMaximalTargetExponent.
+//       Hence -60 <= w.e() <= -32.
+//
+// Returns false if it fails, in which case the generated digits in the buffer
+// should not be used.
+// Preconditions:
+//  * w is correct up to 1 ulp (unit in the last place). That
+//    is, its error must be strictly less than a unit of its last digit.
+//  * kMinimalTargetExponent <= w.e() <= kMaximalTargetExponent
+//
+// Postconditions: returns false if procedure fails.
+//   otherwise:
+//     * buffer is not null-terminated, but length contains the number of
+//       digits.
+//     * the representation in buffer is the most precise representation of
+//       requested_digits digits.
+//     * buffer contains at most requested_digits digits of w. If there are less
+//       than requested_digits digits then some trailing '0's have been removed.
+//     * kappa is such that
+//            w = buffer * 10^kappa + eps with |eps| < 10^kappa / 2.
+//
+// Remark: This procedure takes into account the imprecision of its input
+//   numbers. If the precision is not enough to guarantee all the postconditions
+//   then false is returned. This usually happens rarely, but the failure-rate
+//   increases with higher requested_digits.
+static bool DigitGenCounted(DiyFp w,
+                            int requested_digits,
+                            Vector<char> buffer,
+                            int* length,
+                            int* kappa) {
+  ASSERT(kMinimalTargetExponent <= w.e() && w.e() <= kMaximalTargetExponent);
+  ASSERT(kMinimalTargetExponent >= -60);
+  ASSERT(kMaximalTargetExponent <= -32);
+  // w is assumed to have an error less than 1 unit. Whenever w is scaled we
+  // also scale its error.
+  uint64_t w_error = 1;
+  // We cut the input number into two parts: the integral digits and the
+  // fractional digits. We don't emit any decimal separator, but adapt kappa
+  // instead. Example: instead of writing "1.2" we put "12" into the buffer and
+  // increase kappa by 1.
+  DiyFp one = DiyFp(static_cast<uint64_t>(1) << -w.e(), w.e());
+  // Division by one is a shift.
+  uint32_t integrals = static_cast<uint32_t>(w.f() >> -one.e());
+  // Modulo by one is an and.
+  uint64_t fractionals = w.f() & (one.f() - 1);
+  uint32_t divisor;
+  int divisor_exponent_plus_one;
+  BiggestPowerTen(integrals, DiyFp::kSignificandSize - (-one.e()),
+                  &divisor, &divisor_exponent_plus_one);
+  *kappa = divisor_exponent_plus_one;
+  *length = 0;
+
+  // Loop invariant: buffer = w / 10^kappa  (integer division)
+  // The invariant holds for the first iteration: kappa has been initialized
+  // with the divisor exponent + 1. And the divisor is the biggest power of ten
+  // that is smaller than 'integrals'.
+  while (*kappa > 0) {
+    int digit = integrals / divisor;
+    ASSERT(digit <= 9);
+    buffer[*length] = static_cast<char>('0' + digit);
+    (*length)++;
+    requested_digits--;
+    integrals %= divisor;
+    (*kappa)--;
+    // Note that kappa now equals the exponent of the divisor and that the
+    // invariant thus holds again.
+    if (requested_digits == 0) break;
+    divisor /= 10;
+  }
+
+  if (requested_digits == 0) {
+    uint64_t rest =
+        (static_cast<uint64_t>(integrals) << -one.e()) + fractionals;
+    return RoundWeedCounted(buffer, *length, rest,
+                            static_cast<uint64_t>(divisor) << -one.e(), w_error,
+                            kappa);
+  }
+
+  // The integrals have been generated. We are at the point of the decimal
+  // separator. In the following loop we simply multiply the remaining digits by
+  // 10 and divide by one. We just need to pay attention to multiply associated
+  // data (the 'unit'), too.
+  // Note that the multiplication by 10 does not overflow, because w.e >= -60
+  // and thus one.e >= -60.
+  ASSERT(one.e() >= -60);
+  ASSERT(fractionals < one.f());
+  ASSERT(UINT64_2PART_C(0xFFFFFFFF, FFFFFFFF) / 10 >= one.f());
+  while (requested_digits > 0 && fractionals > w_error) {
+    fractionals *= 10;
+    w_error *= 10;
+    // Integer division by one.
+    int digit = static_cast<int>(fractionals >> -one.e());
+    ASSERT(digit <= 9);
+    buffer[*length] = static_cast<char>('0' + digit);
+    (*length)++;
+    requested_digits--;
+    fractionals &= one.f() - 1;  // Modulo by one.
+    (*kappa)--;
+  }
+  if (requested_digits != 0) return false;
+  return RoundWeedCounted(buffer, *length, fractionals, one.f(), w_error,
+                          kappa);
+}
+
+
+// Provides a decimal representation of v.
+// Returns true if it succeeds, otherwise the result cannot be trusted.
+// There will be *length digits inside the buffer (not null-terminated).
+// If the function returns true then
+//        v == (double) (buffer * 10^decimal_exponent).
+// The digits in the buffer are the shortest representation possible: no
+// 0.09999999999999999 instead of 0.1. The shorter representation will even be
+// chosen even if the longer one would be closer to v.
+// The last digit will be closest to the actual v. That is, even if several
+// digits might correctly yield 'v' when read again, the closest will be
+// computed.
+static bool Grisu3(double v,
+                   FastDtoaMode mode,
+                   Vector<char> buffer,
+                   int* length,
+                   int* decimal_exponent) {
+  DiyFp w = Double(v).AsNormalizedDiyFp();
+  // boundary_minus and boundary_plus are the boundaries between v and its
+  // closest floating-point neighbors. Any number strictly between
+  // boundary_minus and boundary_plus will round to v when convert to a double.
+  // Grisu3 will never output representations that lie exactly on a boundary.
+  DiyFp boundary_minus, boundary_plus;
+  if (mode == FAST_DTOA_SHORTEST) {
+    Double(v).NormalizedBoundaries(&boundary_minus, &boundary_plus);
+  } else {
+    ASSERT(mode == FAST_DTOA_SHORTEST_SINGLE);
+    float single_v = static_cast<float>(v);
+    Single(single_v).NormalizedBoundaries(&boundary_minus, &boundary_plus);
+  }
+  ASSERT(boundary_plus.e() == w.e());
+  DiyFp ten_mk;  // Cached power of ten: 10^-k
+  int mk;        // -k
+  int ten_mk_minimal_binary_exponent =
+     kMinimalTargetExponent - (w.e() + DiyFp::kSignificandSize);
+  int ten_mk_maximal_binary_exponent =
+     kMaximalTargetExponent - (w.e() + DiyFp::kSignificandSize);
+  PowersOfTenCache::GetCachedPowerForBinaryExponentRange(
+      ten_mk_minimal_binary_exponent,
+      ten_mk_maximal_binary_exponent,
+      &ten_mk, &mk);
+  ASSERT((kMinimalTargetExponent <= w.e() + ten_mk.e() +
+          DiyFp::kSignificandSize) &&
+         (kMaximalTargetExponent >= w.e() + ten_mk.e() +
+          DiyFp::kSignificandSize));
+  // Note that ten_mk is only an approximation of 10^-k. A DiyFp only contains a
+  // 64 bit significand and ten_mk is thus only precise up to 64 bits.
+
+  // The DiyFp::Times procedure rounds its result, and ten_mk is approximated
+  // too. The variable scaled_w (as well as scaled_boundary_minus/plus) are now
+  // off by a small amount.
+  // In fact: scaled_w - w*10^k < 1ulp (unit in the last place) of scaled_w.
+  // In other words: let f = scaled_w.f() and e = scaled_w.e(), then
+  //           (f-1) * 2^e < w*10^k < (f+1) * 2^e
+  DiyFp scaled_w = DiyFp::Times(w, ten_mk);
+  ASSERT(scaled_w.e() ==
+         boundary_plus.e() + ten_mk.e() + DiyFp::kSignificandSize);
+  // In theory it would be possible to avoid some recomputations by computing
+  // the difference between w and boundary_minus/plus (a power of 2) and to
+  // compute scaled_boundary_minus/plus by subtracting/adding from
+  // scaled_w. However the code becomes much less readable and the speed
+  // enhancements are not terriffic.
+  DiyFp scaled_boundary_minus = DiyFp::Times(boundary_minus, ten_mk);
+  DiyFp scaled_boundary_plus  = DiyFp::Times(boundary_plus,  ten_mk);
+
+  // DigitGen will generate the digits of scaled_w. Therefore we have
+  // v == (double) (scaled_w * 10^-mk).
+  // Set decimal_exponent == -mk and pass it to DigitGen. If scaled_w is not an
+  // integer than it will be updated. For instance if scaled_w == 1.23 then
+  // the buffer will be filled with "123" und the decimal_exponent will be
+  // decreased by 2.
+  int kappa;
+  bool result = DigitGen(scaled_boundary_minus, scaled_w, scaled_boundary_plus,
+                         buffer, length, &kappa);
+  *decimal_exponent = -mk + kappa;
+  return result;
+}
+
+
+// The "counted" version of grisu3 (see above) only generates requested_digits
+// number of digits. This version does not generate the shortest representation,
+// and with enough requested digits 0.1 will at some point print as 0.9999999...
+// Grisu3 is too imprecise for real halfway cases (1.5 will not work) and
+// therefore the rounding strategy for halfway cases is irrelevant.
+static bool Grisu3Counted(double v,
+                          int requested_digits,
+                          Vector<char> buffer,
+                          int* length,
+                          int* decimal_exponent) {
+  DiyFp w = Double(v).AsNormalizedDiyFp();
+  DiyFp ten_mk;  // Cached power of ten: 10^-k
+  int mk;        // -k
+  int ten_mk_minimal_binary_exponent =
+     kMinimalTargetExponent - (w.e() + DiyFp::kSignificandSize);
+  int ten_mk_maximal_binary_exponent =
+     kMaximalTargetExponent - (w.e() + DiyFp::kSignificandSize);
+  PowersOfTenCache::GetCachedPowerForBinaryExponentRange(
+      ten_mk_minimal_binary_exponent,
+      ten_mk_maximal_binary_exponent,
+      &ten_mk, &mk);
+  ASSERT((kMinimalTargetExponent <= w.e() + ten_mk.e() +
+          DiyFp::kSignificandSize) &&
+         (kMaximalTargetExponent >= w.e() + ten_mk.e() +
+          DiyFp::kSignificandSize));
+  // Note that ten_mk is only an approximation of 10^-k. A DiyFp only contains a
+  // 64 bit significand and ten_mk is thus only precise up to 64 bits.
+
+  // The DiyFp::Times procedure rounds its result, and ten_mk is approximated
+  // too. The variable scaled_w (as well as scaled_boundary_minus/plus) are now
+  // off by a small amount.
+  // In fact: scaled_w - w*10^k < 1ulp (unit in the last place) of scaled_w.
+  // In other words: let f = scaled_w.f() and e = scaled_w.e(), then
+  //           (f-1) * 2^e < w*10^k < (f+1) * 2^e
+  DiyFp scaled_w = DiyFp::Times(w, ten_mk);
+
+  // We now have (double) (scaled_w * 10^-mk).
+  // DigitGen will generate the first requested_digits digits of scaled_w and
+  // return together with a kappa such that scaled_w ~= buffer * 10^kappa. (It
+  // will not always be exactly the same since DigitGenCounted only produces a
+  // limited number of digits.)
+  int kappa;
+  bool result = DigitGenCounted(scaled_w, requested_digits,
+                                buffer, length, &kappa);
+  *decimal_exponent = -mk + kappa;
+  return result;
+}
+
+
+bool FastDtoa(double v,
+              FastDtoaMode mode,
+              int requested_digits,
+              Vector<char> buffer,
+              int* length,
+              int* decimal_point) {
+  ASSERT(v > 0);
+  ASSERT(!Double(v).IsSpecial());
+
+  bool result = false;
+  int decimal_exponent = 0;
+  switch (mode) {
+    case FAST_DTOA_SHORTEST:
+    case FAST_DTOA_SHORTEST_SINGLE:
+      result = Grisu3(v, mode, buffer, length, &decimal_exponent);
+      break;
+    case FAST_DTOA_PRECISION:
+      result = Grisu3Counted(v, requested_digits,
+                             buffer, length, &decimal_exponent);
+      break;
+    default:
+      UNREACHABLE();
+  }
+  if (result) {
+    *decimal_point = *length + decimal_exponent;
+    buffer[*length] = '\0';
+  }
+  return result;
+}
+
+}  // namespace double_conversion
diff --git a/base/poco/Foundation/src/fast-dtoa.h b/base/poco/Foundation/src/fast-dtoa.h
new file mode 100644
index 00000000000..5f1e8eee5e5
--- /dev/null
+++ b/base/poco/Foundation/src/fast-dtoa.h
@@ -0,0 +1,88 @@
+// Copyright 2010 the V8 project authors. 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 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 Google Inc. 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 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
+// OWNER 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.
+
+#ifndef DOUBLE_CONVERSION_FAST_DTOA_H_
+#define DOUBLE_CONVERSION_FAST_DTOA_H_
+
+#include "utils.h"
+
+namespace double_conversion {
+
+enum FastDtoaMode {
+  // Computes the shortest representation of the given input. The returned
+  // result will be the most accurate number of this length. Longer
+  // representations might be more accurate.
+  FAST_DTOA_SHORTEST,
+  // Same as FAST_DTOA_SHORTEST but for single-precision floats.
+  FAST_DTOA_SHORTEST_SINGLE,
+  // Computes a representation where the precision (number of digits) is
+  // given as input. The precision is independent of the decimal point.
+  FAST_DTOA_PRECISION
+};
+
+// FastDtoa will produce at most kFastDtoaMaximalLength digits. This does not
+// include the terminating '\0' character.
+static const int kFastDtoaMaximalLength = 17;
+// Same for single-precision numbers.
+static const int kFastDtoaMaximalSingleLength = 9;
+
+// Provides a decimal representation of v.
+// The result should be interpreted as buffer * 10^(point - length).
+//
+// Precondition:
+//   * v must be a strictly positive finite double.
+//
+// Returns true if it succeeds, otherwise the result can not be trusted.
+// There will be *length digits inside the buffer followed by a null terminator.
+// If the function returns true and mode equals
+//   - FAST_DTOA_SHORTEST, then
+//     the parameter requested_digits is ignored.
+//     The result satisfies
+//         v == (double) (buffer * 10^(point - length)).
+//     The digits in the buffer are the shortest representation possible. E.g.
+//     if 0.099999999999 and 0.1 represent the same double then "1" is returned
+//     with point = 0.
+//     The last digit will be closest to the actual v. That is, even if several
+//     digits might correctly yield 'v' when read again, the buffer will contain
+//     the one closest to v.
+//   - FAST_DTOA_PRECISION, then
+//     the buffer contains requested_digits digits.
+//     the difference v - (buffer * 10^(point-length)) is closest to zero for
+//     all possible representations of requested_digits digits.
+//     If there are two values that are equally close, then FastDtoa returns
+//     false.
+// For both modes the buffer must be large enough to hold the result.
+bool FastDtoa(double d,
+              FastDtoaMode mode,
+              int requested_digits,
+              Vector<char> buffer,
+              int* length,
+              int* decimal_point);
+
+}  // namespace double_conversion
+
+#endif  // DOUBLE_CONVERSION_FAST_DTOA_H_
diff --git a/base/poco/Foundation/src/fixed-dtoa.cc b/base/poco/Foundation/src/fixed-dtoa.cc
new file mode 100644
index 00000000000..aef65fdc211
--- /dev/null
+++ b/base/poco/Foundation/src/fixed-dtoa.cc
@@ -0,0 +1,404 @@
+// Copyright 2010 the V8 project authors. 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 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 Google Inc. 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 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
+// OWNER 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.
+
+#include <math.h>
+
+#include "fixed-dtoa.h"
+#include "ieee.h"
+
+namespace double_conversion {
+
+// Represents a 128bit type. This class should be replaced by a native type on
+// platforms that support 128bit integers.
+class UInt128 {
+ public:
+  UInt128() : high_bits_(0), low_bits_(0) { }
+  UInt128(uint64_t high, uint64_t low) : high_bits_(high), low_bits_(low) { }
+
+  void Multiply(uint32_t multiplicand) {
+    uint64_t accumulator;
+
+    accumulator = (low_bits_ & kMask32) * multiplicand;
+    uint32_t part = static_cast<uint32_t>(accumulator & kMask32);
+    accumulator >>= 32;
+    accumulator = accumulator + (low_bits_ >> 32) * multiplicand;
+    low_bits_ = (accumulator << 32) + part;
+    accumulator >>= 32;
+    accumulator = accumulator + (high_bits_ & kMask32) * multiplicand;
+    part = static_cast<uint32_t>(accumulator & kMask32);
+    accumulator >>= 32;
+    accumulator = accumulator + (high_bits_ >> 32) * multiplicand;
+    high_bits_ = (accumulator << 32) + part;
+    ASSERT((accumulator >> 32) == 0);
+  }
+
+  void Shift(int shift_amount) {
+    ASSERT(-64 <= shift_amount && shift_amount <= 64);
+    if (shift_amount == 0) {
+      return;
+    } else if (shift_amount == -64) {
+      high_bits_ = low_bits_;
+      low_bits_ = 0;
+    } else if (shift_amount == 64) {
+      low_bits_ = high_bits_;
+      high_bits_ = 0;
+    } else if (shift_amount <= 0) {
+      high_bits_ <<= -shift_amount;
+      high_bits_ += low_bits_ >> (64 + shift_amount);
+      low_bits_ <<= -shift_amount;
+    } else {
+      low_bits_ >>= shift_amount;
+      low_bits_ += high_bits_ << (64 - shift_amount);
+      high_bits_ >>= shift_amount;
+    }
+  }
+
+  // Modifies *this to *this MOD (2^power).
+  // Returns *this DIV (2^power).
+  int DivModPowerOf2(int power) {
+    if (power >= 64) {
+      int result = static_cast<int>(high_bits_ >> (power - 64));
+      high_bits_ -= static_cast<uint64_t>(result) << (power - 64);
+      return result;
+    } else {
+      uint64_t part_low = low_bits_ >> power;
+      uint64_t part_high = high_bits_ << (64 - power);
+      int result = static_cast<int>(part_low + part_high);
+      high_bits_ = 0;
+      low_bits_ -= part_low << power;
+      return result;
+    }
+  }
+
+  bool IsZero() const {
+    return high_bits_ == 0 && low_bits_ == 0;
+  }
+
+  int BitAt(int position) {
+    if (position >= 64) {
+      return static_cast<int>(high_bits_ >> (position - 64)) & 1;
+    } else {
+      return static_cast<int>(low_bits_ >> position) & 1;
+    }
+  }
+
+ private:
+  static const uint64_t kMask32 = 0xFFFFFFFF;
+  // Value == (high_bits_ << 64) + low_bits_
+  uint64_t high_bits_;
+  uint64_t low_bits_;
+};
+
+
+static const int kDoubleSignificandSize = 53;  // Includes the hidden bit.
+
+
+static void FillDigits32FixedLength(uint32_t number, int requested_length,
+                                    Vector<char> buffer, int* length) {
+  for (int i = requested_length - 1; i >= 0; --i) {
+    buffer[(*length) + i] = '0' + number % 10;
+    number /= 10;
+  }
+  *length += requested_length;
+}
+
+
+static void FillDigits32(uint32_t number, Vector<char> buffer, int* length) {
+  int number_length = 0;
+  // We fill the digits in reverse order and exchange them afterwards.
+  while (number != 0) {
+    int digit = number % 10;
+    number /= 10;
+    buffer[(*length) + number_length] = static_cast<char>('0' + digit);
+    number_length++;
+  }
+  // Exchange the digits.
+  int i = *length;
+  int j = *length + number_length - 1;
+  while (i < j) {
+    char tmp = buffer[i];
+    buffer[i] = buffer[j];
+    buffer[j] = tmp;
+    i++;
+    j--;
+  }
+  *length += number_length;
+}
+
+
+static void FillDigits64FixedLength(uint64_t number,
+                                    Vector<char> buffer, int* length) {
+  const uint32_t kTen7 = 10000000;
+  // For efficiency cut the number into 3 uint32_t parts, and print those.
+  uint32_t part2 = static_cast<uint32_t>(number % kTen7);
+  number /= kTen7;
+  uint32_t part1 = static_cast<uint32_t>(number % kTen7);
+  uint32_t part0 = static_cast<uint32_t>(number / kTen7);
+
+  FillDigits32FixedLength(part0, 3, buffer, length);
+  FillDigits32FixedLength(part1, 7, buffer, length);
+  FillDigits32FixedLength(part2, 7, buffer, length);
+}
+
+
+static void FillDigits64(uint64_t number, Vector<char> buffer, int* length) {
+  const uint32_t kTen7 = 10000000;
+  // For efficiency cut the number into 3 uint32_t parts, and print those.
+  uint32_t part2 = static_cast<uint32_t>(number % kTen7);
+  number /= kTen7;
+  uint32_t part1 = static_cast<uint32_t>(number % kTen7);
+  uint32_t part0 = static_cast<uint32_t>(number / kTen7);
+
+  if (part0 != 0) {
+    FillDigits32(part0, buffer, length);
+    FillDigits32FixedLength(part1, 7, buffer, length);
+    FillDigits32FixedLength(part2, 7, buffer, length);
+  } else if (part1 != 0) {
+    FillDigits32(part1, buffer, length);
+    FillDigits32FixedLength(part2, 7, buffer, length);
+  } else {
+    FillDigits32(part2, buffer, length);
+  }
+}
+
+
+static void RoundUp(Vector<char> buffer, int* length, int* decimal_point) {
+  // An empty buffer represents 0.
+  if (*length == 0) {
+    buffer[0] = '1';
+    *decimal_point = 1;
+    *length = 1;
+    return;
+  }
+  // Round the last digit until we either have a digit that was not '9' or until
+  // we reached the first digit.
+  buffer[(*length) - 1]++;
+  for (int i = (*length) - 1; i > 0; --i) {
+    if (buffer[i] != '0' + 10) {
+      return;
+    }
+    buffer[i] = '0';
+    buffer[i - 1]++;
+  }
+  // If the first digit is now '0' + 10, we would need to set it to '0' and add
+  // a '1' in front. However we reach the first digit only if all following
+  // digits had been '9' before rounding up. Now all trailing digits are '0' and
+  // we simply switch the first digit to '1' and update the decimal-point
+  // (indicating that the point is now one digit to the right).
+  if (buffer[0] == '0' + 10) {
+    buffer[0] = '1';
+    (*decimal_point)++;
+  }
+}
+
+
+// The given fractionals number represents a fixed-point number with binary
+// point at bit (-exponent).
+// Preconditions:
+//   -128 <= exponent <= 0.
+//   0 <= fractionals * 2^exponent < 1
+//   The buffer holds the result.
+// The function will round its result. During the rounding-process digits not
+// generated by this function might be updated, and the decimal-point variable
+// might be updated. If this function generates the digits 99 and the buffer
+// already contained "199" (thus yielding a buffer of "19999") then a
+// rounding-up will change the contents of the buffer to "20000".
+static void FillFractionals(uint64_t fractionals, int exponent,
+                            int fractional_count, Vector<char> buffer,
+                            int* length, int* decimal_point) {
+  ASSERT(-128 <= exponent && exponent <= 0);
+  // 'fractionals' is a fixed-point number, with binary point at bit
+  // (-exponent). Inside the function the non-converted remainder of fractionals
+  // is a fixed-point number, with binary point at bit 'point'.
+  if (-exponent <= 64) {
+    // One 64 bit number is sufficient.
+    ASSERT(fractionals >> 56 == 0);
+    int point = -exponent;
+    for (int i = 0; i < fractional_count; ++i) {
+      if (fractionals == 0) break;
+      // Instead of multiplying by 10 we multiply by 5 and adjust the point
+      // location. This way the fractionals variable will not overflow.
+      // Invariant at the beginning of the loop: fractionals < 2^point.
+      // Initially we have: point <= 64 and fractionals < 2^56
+      // After each iteration the point is decremented by one.
+      // Note that 5^3 = 125 < 128 = 2^7.
+      // Therefore three iterations of this loop will not overflow fractionals
+      // (even without the subtraction at the end of the loop body). At this
+      // time point will satisfy point <= 61 and therefore fractionals < 2^point
+      // and any further multiplication of fractionals by 5 will not overflow.
+      fractionals *= 5;
+      point--;
+      int digit = static_cast<int>(fractionals >> point);
+      ASSERT(digit <= 9);
+      buffer[*length] = static_cast<char>('0' + digit);
+      (*length)++;
+      fractionals -= static_cast<uint64_t>(digit) << point;
+    }
+    // If the first bit after the point is set we have to round up.
+    if (((fractionals >> (point - 1)) & 1) == 1) {
+      RoundUp(buffer, length, decimal_point);
+    }
+  } else {  // We need 128 bits.
+    ASSERT(64 < -exponent && -exponent <= 128);
+    UInt128 fractionals128 = UInt128(fractionals, 0);
+    fractionals128.Shift(-exponent - 64);
+    int point = 128;
+    for (int i = 0; i < fractional_count; ++i) {
+      if (fractionals128.IsZero()) break;
+      // As before: instead of multiplying by 10 we multiply by 5 and adjust the
+      // point location.
+      // This multiplication will not overflow for the same reasons as before.
+      fractionals128.Multiply(5);
+      point--;
+      int digit = fractionals128.DivModPowerOf2(point);
+      ASSERT(digit <= 9);
+      buffer[*length] = static_cast<char>('0' + digit);
+      (*length)++;
+    }
+    if (fractionals128.BitAt(point - 1) == 1) {
+      RoundUp(buffer, length, decimal_point);
+    }
+  }
+}
+
+
+// Removes leading and trailing zeros.
+// If leading zeros are removed then the decimal point position is adjusted.
+static void TrimZeros(Vector<char> buffer, int* length, int* decimal_point) {
+  while (*length > 0 && buffer[(*length) - 1] == '0') {
+    (*length)--;
+  }
+  int first_non_zero = 0;
+  while (first_non_zero < *length && buffer[first_non_zero] == '0') {
+    first_non_zero++;
+  }
+  if (first_non_zero != 0) {
+    for (int i = first_non_zero; i < *length; ++i) {
+      buffer[i - first_non_zero] = buffer[i];
+    }
+    *length -= first_non_zero;
+    *decimal_point -= first_non_zero;
+  }
+}
+
+
+bool FastFixedDtoa(double v,
+                   int fractional_count,
+                   Vector<char> buffer,
+                   int* length,
+                   int* decimal_point) {
+  const uint32_t kMaxUInt32 = 0xFFFFFFFF;
+  uint64_t significand = Double(v).Significand();
+  int exponent = Double(v).Exponent();
+  // v = significand * 2^exponent (with significand a 53bit integer).
+  // If the exponent is larger than 20 (i.e. we may have a 73bit number) then we
+  // don't know how to compute the representation. 2^73 ~= 9.5*10^21.
+  // If necessary this limit could probably be increased, but we don't need
+  // more.
+  if (exponent > 20) return false;
+  if (fractional_count > 20) return false;
+  *length = 0;
+  // At most kDoubleSignificandSize bits of the significand are non-zero.
+  // Given a 64 bit integer we have 11 0s followed by 53 potentially non-zero
+  // bits:  0..11*..0xxx..53*..xx
+  if (exponent + kDoubleSignificandSize > 64) {
+    // The exponent must be > 11.
+    //
+    // We know that v = significand * 2^exponent.
+    // And the exponent > 11.
+    // We simplify the task by dividing v by 10^17.
+    // The quotient delivers the first digits, and the remainder fits into a 64
+    // bit number.
+    // Dividing by 10^17 is equivalent to dividing by 5^17*2^17.
+    const uint64_t kFive17 = UINT64_2PART_C(0xB1, A2BC2EC5);  // 5^17
+    uint64_t divisor = kFive17;
+    int divisor_power = 17;
+    uint64_t dividend = significand;
+    uint32_t quotient;
+    uint64_t remainder;
+    // Let v = f * 2^e with f == significand and e == exponent.
+    // Then need q (quotient) and r (remainder) as follows:
+    //   v            = q * 10^17       + r
+    //   f * 2^e      = q * 10^17       + r
+    //   f * 2^e      = q * 5^17 * 2^17 + r
+    // If e > 17 then
+    //   f * 2^(e-17) = q * 5^17        + r/2^17
+    // else
+    //   f  = q * 5^17 * 2^(17-e) + r/2^e
+    if (exponent > divisor_power) {
+      // We only allow exponents of up to 20 and therefore (17 - e) <= 3
+      dividend <<= exponent - divisor_power;
+      quotient = static_cast<uint32_t>(dividend / divisor);
+      remainder = (dividend % divisor) << divisor_power;
+    } else {
+      divisor <<= divisor_power - exponent;
+      quotient = static_cast<uint32_t>(dividend / divisor);
+      remainder = (dividend % divisor) << exponent;
+    }
+    FillDigits32(quotient, buffer, length);
+    FillDigits64FixedLength(remainder, buffer, length);
+    *decimal_point = *length;
+  } else if (exponent >= 0) {
+    // 0 <= exponent <= 11
+    significand <<= exponent;
+    FillDigits64(significand, buffer, length);
+    *decimal_point = *length;
+  } else if (exponent > -kDoubleSignificandSize) {
+    // We have to cut the number.
+    uint64_t integrals = significand >> -exponent;
+    uint64_t fractionals = significand - (integrals << -exponent);
+    if (integrals > kMaxUInt32) {
+      FillDigits64(integrals, buffer, length);
+    } else {
+      FillDigits32(static_cast<uint32_t>(integrals), buffer, length);
+    }
+    *decimal_point = *length;
+    FillFractionals(fractionals, exponent, fractional_count,
+                    buffer, length, decimal_point);
+  } else if (exponent < -128) {
+    // This configuration (with at most 20 digits) means that all digits must be
+    // 0.
+    ASSERT(fractional_count <= 20);
+    buffer[0] = '\0';
+    *length = 0;
+    *decimal_point = -fractional_count;
+  } else {
+    *decimal_point = 0;
+    FillFractionals(significand, exponent, fractional_count,
+                    buffer, length, decimal_point);
+  }
+  TrimZeros(buffer, length, decimal_point);
+  buffer[*length] = '\0';
+  if ((*length) == 0) {
+    // The string is empty and the decimal_point thus has no importance. Mimick
+    // Gay's dtoa and and set it to -fractional_count.
+    *decimal_point = -fractional_count;
+  }
+  return true;
+}
+
+}  // namespace double_conversion
diff --git a/base/poco/Foundation/src/fixed-dtoa.h b/base/poco/Foundation/src/fixed-dtoa.h
new file mode 100644
index 00000000000..3bdd08e21f5
--- /dev/null
+++ b/base/poco/Foundation/src/fixed-dtoa.h
@@ -0,0 +1,56 @@
+// Copyright 2010 the V8 project authors. 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 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 Google Inc. 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 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
+// OWNER 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.
+
+#ifndef DOUBLE_CONVERSION_FIXED_DTOA_H_
+#define DOUBLE_CONVERSION_FIXED_DTOA_H_
+
+#include "utils.h"
+
+namespace double_conversion {
+
+// Produces digits necessary to print a given number with
+// 'fractional_count' digits after the decimal point.
+// The buffer must be big enough to hold the result plus one terminating null
+// character.
+//
+// The produced digits might be too short in which case the caller has to fill
+// the gaps with '0's.
+// Example: FastFixedDtoa(0.001, 5, ...) is allowed to return buffer = "1", and
+// decimal_point = -2.
+// Halfway cases are rounded towards +/-Infinity (away from 0). The call
+// FastFixedDtoa(0.15, 2, ...) thus returns buffer = "2", decimal_point = 0.
+// The returned buffer may contain digits that would be truncated from the
+// shortest representation of the input.
+//
+// This method only works for some parameters. If it can't handle the input it
+// returns false. The output is null-terminated when the function succeeds.
+bool FastFixedDtoa(double v, int fractional_count,
+                   Vector<char> buffer, int* length, int* decimal_point);
+
+}  // namespace double_conversion
+
+#endif  // DOUBLE_CONVERSION_FIXED_DTOA_H_
diff --git a/base/poco/Foundation/src/gzguts.h b/base/poco/Foundation/src/gzguts.h
new file mode 100644
index 00000000000..75fa55ffc83
--- /dev/null
+++ b/base/poco/Foundation/src/gzguts.h
@@ -0,0 +1,219 @@
+/* gzguts.h -- zlib internal header definitions for gz* operations
+ * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#ifdef _LARGEFILE64_SOURCE
+#  ifndef _LARGEFILE_SOURCE
+#    define _LARGEFILE_SOURCE 1
+#  endif
+#  ifdef _FILE_OFFSET_BITS
+#    undef _FILE_OFFSET_BITS
+#  endif
+#endif
+
+#ifdef HAVE_HIDDEN
+#  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
+#else
+#  define ZLIB_INTERNAL
+#endif
+
+#include <stdio.h>
+#include "zlib.h"
+#ifdef STDC
+#  include <string.h>
+#  include <stdlib.h>
+#  include <limits.h>
+#endif
+
+#ifndef _POSIX_SOURCE
+#  define _POSIX_SOURCE
+#endif
+#include <fcntl.h>
+
+#ifdef _WIN32
+#  include <stddef.h>
+#endif
+
+#ifndef _WIN32_WCE
+#if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32)
+#  include <io.h>
+#endif
+#endif
+#if defined(_WIN32) || defined(__CYGWIN__)
+#  define WIDECHAR
+#endif
+
+#ifdef WINAPI_FAMILY
+#  define open _open
+#  define read _read
+#  define write _write
+#  define close _close
+#endif
+
+#ifdef NO_DEFLATE       /* for compatibility with old definition */
+#  define NO_GZCOMPRESS
+#endif
+
+#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550)
+#  ifndef HAVE_VSNPRINTF
+#    define HAVE_VSNPRINTF
+#  endif
+#endif
+
+#if defined(__CYGWIN__)
+#  ifndef HAVE_VSNPRINTF
+#    define HAVE_VSNPRINTF
+#  endif
+#endif
+
+#if defined(MSDOS) && defined(__BORLANDC__) && (BORLANDC > 0x410)
+#  ifndef HAVE_VSNPRINTF
+#    define HAVE_VSNPRINTF
+#  endif
+#endif
+
+#ifndef HAVE_VSNPRINTF
+#  ifdef MSDOS
+/* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
+   but for now we just assume it doesn't. */
+#    define NO_vsnprintf
+#  endif
+#  ifdef __TURBOC__
+#    define NO_vsnprintf
+#  endif
+#  ifdef WIN32
+/* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
+#    if !defined(vsnprintf) && !defined(NO_vsnprintf)
+#      if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 )
+#         define vsnprintf _vsnprintf
+#      endif
+#    endif
+#  endif
+#  ifdef __SASC
+#    define NO_vsnprintf
+#  endif
+#  ifdef VMS
+#    define NO_vsnprintf
+#  endif
+#  ifdef __OS400__
+#    define NO_vsnprintf
+#  endif
+#  ifdef __MVS__
+#    define NO_vsnprintf
+#  endif
+#endif
+
+/* unlike snprintf (which is required in C99), _snprintf does not guarantee
+   null termination of the result -- however this is only used in gzlib.c where
+   the result is assured to fit in the space provided */
+#if defined(_MSC_VER) && _MSC_VER < 1900
+#  define snprintf _snprintf
+#endif
+
+#ifndef local
+#  define local static
+#endif
+/* since "static" is used to mean two completely different things in C, we
+   define "local" for the non-static meaning of "static", for readability
+   (compile with -Dlocal if your debugger can't find static symbols) */
+
+/* gz* functions always use library allocation functions */
+#ifndef STDC
+  extern voidp  malloc OF((uInt size));
+  extern void   free   OF((voidpf ptr));
+#endif
+
+/* get errno and strerror definition */
+#if defined UNDER_CE
+#  include <windows.h>
+#  define zstrerror() gz_strwinerror((DWORD)GetLastError())
+#else
+#  ifndef NO_STRERROR
+#    include <errno.h>
+#    define zstrerror() strerror(errno)
+#  else
+#    define zstrerror() "stdio error (consult errno)"
+#  endif
+#endif
+
+/* provide prototypes for these when building zlib without LFS */
+#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0
+    ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
+    ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
+    ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
+    ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
+#endif
+
+/* default memLevel */
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+
+/* default i/o buffer size -- double this for output when reading (this and
+   twice this must be able to fit in an unsigned type) */
+#define GZBUFSIZE 8192
+
+/* gzip modes, also provide a little integrity check on the passed structure */
+#define GZ_NONE 0
+#define GZ_READ 7247
+#define GZ_WRITE 31153
+#define GZ_APPEND 1     /* mode set to GZ_WRITE after the file is opened */
+
+/* values for gz_state how */
+#define LOOK 0      /* look for a gzip header */
+#define COPY 1      /* copy input directly */
+#define GZIP 2      /* decompress a gzip stream */
+
+/* internal gzip file state data structure */
+typedef struct {
+        /* exposed contents for gzgetc() macro */
+    struct gzFile_s x;      /* "x" for exposed */
+                            /* x.have: number of bytes available at x.next */
+                            /* x.next: next output data to deliver or write */
+                            /* x.pos: current position in uncompressed data */
+        /* used for both reading and writing */
+    int mode;               /* see gzip modes above */
+    int fd;                 /* file descriptor */
+    char *path;             /* path or fd for error messages */
+    unsigned size;          /* buffer size, zero if not allocated yet */
+    unsigned want;          /* requested buffer size, default is GZBUFSIZE */
+    unsigned char *in;      /* input buffer (double-sized when writing) */
+    unsigned char *out;     /* output buffer (double-sized when reading) */
+    int direct;             /* 0 if processing gzip, 1 if transparent */
+        /* just for reading */
+    int how;                /* 0: get header, 1: copy, 2: decompress */
+    z_off64_t start;        /* where the gzip data started, for rewinding */
+    int eof;                /* true if end of input file reached */
+    int past;               /* true if read requested past end */
+        /* just for writing */
+    int level;              /* compression level */
+    int strategy;           /* compression strategy */
+        /* seek request */
+    z_off64_t skip;         /* amount to skip (already rewound if backwards) */
+    int seek;               /* true if seek request pending */
+        /* error information */
+    int err;                /* error code */
+    char *msg;              /* error message */
+        /* zlib inflate or deflate stream */
+    z_stream strm;          /* stream structure in-place (not a pointer) */
+} gz_state;
+typedef gz_state FAR *gz_statep;
+
+/* shared functions */
+void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *));
+#if defined UNDER_CE
+char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error));
+#endif
+
+/* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t
+   value -- needed when comparing unsigned to z_off64_t, which is signed
+   (possible z_off64_t types off_t, off64_t, and long are all signed) */
+#ifdef INT_MAX
+#  define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX)
+#else
+unsigned ZLIB_INTERNAL gz_intmax OF((void));
+#  define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax())
+#endif
diff --git a/base/poco/Foundation/src/ieee.h b/base/poco/Foundation/src/ieee.h
new file mode 100644
index 00000000000..661141d1a8d
--- /dev/null
+++ b/base/poco/Foundation/src/ieee.h
@@ -0,0 +1,402 @@
+// Copyright 2012 the V8 project authors. 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 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 Google Inc. 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 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
+// OWNER 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.
+
+#ifndef DOUBLE_CONVERSION_DOUBLE_H_
+#define DOUBLE_CONVERSION_DOUBLE_H_
+
+#include "diy-fp.h"
+
+namespace double_conversion {
+
+// We assume that doubles and uint64_t have the same endianness.
+static uint64_t double_to_uint64(double d) { return BitCast<uint64_t>(d); }
+static double uint64_to_double(uint64_t d64) { return BitCast<double>(d64); }
+static uint32_t float_to_uint32(float f) { return BitCast<uint32_t>(f); }
+static float uint32_to_float(uint32_t d32) { return BitCast<float>(d32); }
+
+// Helper functions for doubles.
+class Double {
+ public:
+  static const uint64_t kSignMask = UINT64_2PART_C(0x80000000, 00000000);
+  static const uint64_t kExponentMask = UINT64_2PART_C(0x7FF00000, 00000000);
+  static const uint64_t kSignificandMask = UINT64_2PART_C(0x000FFFFF, FFFFFFFF);
+  static const uint64_t kHiddenBit = UINT64_2PART_C(0x00100000, 00000000);
+  static const int kPhysicalSignificandSize = 52;  // Excludes the hidden bit.
+  static const int kSignificandSize = 53;
+
+  Double() : d64_(0) {}
+  explicit Double(double d) : d64_(double_to_uint64(d)) {}
+  explicit Double(uint64_t d64) : d64_(d64) {}
+  explicit Double(DiyFp diy_fp)
+    : d64_(DiyFpToUint64(diy_fp)) {}
+
+  // The value encoded by this Double must be greater or equal to +0.0.
+  // It must not be special (infinity, or NaN).
+  DiyFp AsDiyFp() const {
+    ASSERT(Sign() > 0);
+    ASSERT(!IsSpecial());
+    return DiyFp(Significand(), Exponent());
+  }
+
+  // The value encoded by this Double must be strictly greater than 0.
+  DiyFp AsNormalizedDiyFp() const {
+    ASSERT(value() > 0.0);
+    uint64_t f = Significand();
+    int e = Exponent();
+
+    // The current double could be a denormal.
+    while ((f & kHiddenBit) == 0) {
+      f <<= 1;
+      e--;
+    }
+    // Do the final shifts in one go.
+    f <<= DiyFp::kSignificandSize - kSignificandSize;
+    e -= DiyFp::kSignificandSize - kSignificandSize;
+    return DiyFp(f, e);
+  }
+
+  // Returns the double's bit as uint64.
+  uint64_t AsUint64() const {
+    return d64_;
+  }
+
+  // Returns the next greater double. Returns +infinity on input +infinity.
+  double NextDouble() const {
+    if (d64_ == kInfinity) return Double(kInfinity).value();
+    if (Sign() < 0 && Significand() == 0) {
+      // -0.0
+      return 0.0;
+    }
+    if (Sign() < 0) {
+      return Double(d64_ - 1).value();
+    } else {
+      return Double(d64_ + 1).value();
+    }
+  }
+
+  double PreviousDouble() const {
+    if (d64_ == (kInfinity | kSignMask)) return -Double::Infinity();
+    if (Sign() < 0) {
+      return Double(d64_ + 1).value();
+    } else {
+      if (Significand() == 0) return -0.0;
+      return Double(d64_ - 1).value();
+    }
+  }
+
+  int Exponent() const {
+    if (IsDenormal()) return kDenormalExponent;
+
+    uint64_t d64 = AsUint64();
+    int biased_e =
+        static_cast<int>((d64 & kExponentMask) >> kPhysicalSignificandSize);
+    return biased_e - kExponentBias;
+  }
+
+  uint64_t Significand() const {
+    uint64_t d64 = AsUint64();
+    uint64_t significand = d64 & kSignificandMask;
+    if (!IsDenormal()) {
+      return significand + kHiddenBit;
+    } else {
+      return significand;
+    }
+  }
+
+  // Returns true if the double is a denormal.
+  bool IsDenormal() const {
+    uint64_t d64 = AsUint64();
+    return (d64 & kExponentMask) == 0;
+  }
+
+  // We consider denormals not to be special.
+  // Hence only Infinity and NaN are special.
+  bool IsSpecial() const {
+    uint64_t d64 = AsUint64();
+    return (d64 & kExponentMask) == kExponentMask;
+  }
+
+  bool IsNan() const {
+    uint64_t d64 = AsUint64();
+    return ((d64 & kExponentMask) == kExponentMask) &&
+        ((d64 & kSignificandMask) != 0);
+  }
+
+  bool IsInfinite() const {
+    uint64_t d64 = AsUint64();
+    return ((d64 & kExponentMask) == kExponentMask) &&
+        ((d64 & kSignificandMask) == 0);
+  }
+
+  int Sign() const {
+    uint64_t d64 = AsUint64();
+    return (d64 & kSignMask) == 0? 1: -1;
+  }
+
+  // Precondition: the value encoded by this Double must be greater or equal
+  // than +0.0.
+  DiyFp UpperBoundary() const {
+    ASSERT(Sign() > 0);
+    return DiyFp(Significand() * 2 + 1, Exponent() - 1);
+  }
+
+  // Computes the two boundaries of this.
+  // The bigger boundary (m_plus) is normalized. The lower boundary has the same
+  // exponent as m_plus.
+  // Precondition: the value encoded by this Double must be greater than 0.
+  void NormalizedBoundaries(DiyFp* out_m_minus, DiyFp* out_m_plus) const {
+    ASSERT(value() > 0.0);
+    DiyFp v = this->AsDiyFp();
+    DiyFp m_plus = DiyFp::Normalize(DiyFp((v.f() << 1) + 1, v.e() - 1));
+    DiyFp m_minus;
+    if (LowerBoundaryIsCloser()) {
+      m_minus = DiyFp((v.f() << 2) - 1, v.e() - 2);
+    } else {
+      m_minus = DiyFp((v.f() << 1) - 1, v.e() - 1);
+    }
+    m_minus.set_f(m_minus.f() << (m_minus.e() - m_plus.e()));
+    m_minus.set_e(m_plus.e());
+    *out_m_plus = m_plus;
+    *out_m_minus = m_minus;
+  }
+
+  bool LowerBoundaryIsCloser() const {
+    // The boundary is closer if the significand is of the form f == 2^p-1 then
+    // the lower boundary is closer.
+    // Think of v = 1000e10 and v- = 9999e9.
+    // Then the boundary (== (v - v-)/2) is not just at a distance of 1e9 but
+    // at a distance of 1e8.
+    // The only exception is for the smallest normal: the largest denormal is
+    // at the same distance as its successor.
+    // Note: denormals have the same exponent as the smallest normals.
+    bool physical_significand_is_zero = ((AsUint64() & kSignificandMask) == 0);
+    return physical_significand_is_zero && (Exponent() != kDenormalExponent);
+  }
+
+  double value() const { return uint64_to_double(d64_); }
+
+  // Returns the significand size for a given order of magnitude.
+  // If v = f*2^e with 2^p-1 <= f <= 2^p then p+e is v's order of magnitude.
+  // This function returns the number of significant binary digits v will have
+  // once it's encoded into a double. In almost all cases this is equal to
+  // kSignificandSize. The only exceptions are denormals. They start with
+  // leading zeroes and their effective significand-size is hence smaller.
+  static int SignificandSizeForOrderOfMagnitude(int order) {
+    if (order >= (kDenormalExponent + kSignificandSize)) {
+      return kSignificandSize;
+    }
+    if (order <= kDenormalExponent) return 0;
+    return order - kDenormalExponent;
+  }
+
+  static double Infinity() {
+    return Double(kInfinity).value();
+  }
+
+  static double NaN() {
+    return Double(kNaN).value();
+  }
+
+ private:
+  static const int kExponentBias = 0x3FF + kPhysicalSignificandSize;
+  static const int kDenormalExponent = -kExponentBias + 1;
+  static const int kMaxExponent = 0x7FF - kExponentBias;
+  static const uint64_t kInfinity = UINT64_2PART_C(0x7FF00000, 00000000);
+  static const uint64_t kNaN = UINT64_2PART_C(0x7FF80000, 00000000);
+
+  const uint64_t d64_;
+
+  static uint64_t DiyFpToUint64(DiyFp diy_fp) {
+    uint64_t significand = diy_fp.f();
+    int exponent = diy_fp.e();
+    while (significand > kHiddenBit + kSignificandMask) {
+      significand >>= 1;
+      exponent++;
+    }
+    if (exponent >= kMaxExponent) {
+      return kInfinity;
+    }
+    if (exponent < kDenormalExponent) {
+      return 0;
+    }
+    while (exponent > kDenormalExponent && (significand & kHiddenBit) == 0) {
+      significand <<= 1;
+      exponent--;
+    }
+    uint64_t biased_exponent;
+    if (exponent == kDenormalExponent && (significand & kHiddenBit) == 0) {
+      biased_exponent = 0;
+    } else {
+      biased_exponent = static_cast<uint64_t>(exponent + kExponentBias);
+    }
+    return (significand & kSignificandMask) |
+        (biased_exponent << kPhysicalSignificandSize);
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(Double);
+};
+
+class Single {
+ public:
+  static const uint32_t kSignMask = 0x80000000;
+  static const uint32_t kExponentMask = 0x7F800000;
+  static const uint32_t kSignificandMask = 0x007FFFFF;
+  static const uint32_t kHiddenBit = 0x00800000;
+  static const int kPhysicalSignificandSize = 23;  // Excludes the hidden bit.
+  static const int kSignificandSize = 24;
+
+  Single() : d32_(0) {}
+  explicit Single(float f) : d32_(float_to_uint32(f)) {}
+  explicit Single(uint32_t d32) : d32_(d32) {}
+
+  // The value encoded by this Single must be greater or equal to +0.0.
+  // It must not be special (infinity, or NaN).
+  DiyFp AsDiyFp() const {
+    ASSERT(Sign() > 0);
+    ASSERT(!IsSpecial());
+    return DiyFp(Significand(), Exponent());
+  }
+
+  // Returns the single's bit as uint64.
+  uint32_t AsUint32() const {
+    return d32_;
+  }
+
+  int Exponent() const {
+    if (IsDenormal()) return kDenormalExponent;
+
+    uint32_t d32 = AsUint32();
+    int biased_e =
+        static_cast<int>((d32 & kExponentMask) >> kPhysicalSignificandSize);
+    return biased_e - kExponentBias;
+  }
+
+  uint32_t Significand() const {
+    uint32_t d32 = AsUint32();
+    uint32_t significand = d32 & kSignificandMask;
+    if (!IsDenormal()) {
+      return significand + kHiddenBit;
+    } else {
+      return significand;
+    }
+  }
+
+  // Returns true if the single is a denormal.
+  bool IsDenormal() const {
+    uint32_t d32 = AsUint32();
+    return (d32 & kExponentMask) == 0;
+  }
+
+  // We consider denormals not to be special.
+  // Hence only Infinity and NaN are special.
+  bool IsSpecial() const {
+    uint32_t d32 = AsUint32();
+    return (d32 & kExponentMask) == kExponentMask;
+  }
+
+  bool IsNan() const {
+    uint32_t d32 = AsUint32();
+    return ((d32 & kExponentMask) == kExponentMask) &&
+        ((d32 & kSignificandMask) != 0);
+  }
+
+  bool IsInfinite() const {
+    uint32_t d32 = AsUint32();
+    return ((d32 & kExponentMask) == kExponentMask) &&
+        ((d32 & kSignificandMask) == 0);
+  }
+
+  int Sign() const {
+    uint32_t d32 = AsUint32();
+    return (d32 & kSignMask) == 0? 1: -1;
+  }
+
+  // Computes the two boundaries of this.
+  // The bigger boundary (m_plus) is normalized. The lower boundary has the same
+  // exponent as m_plus.
+  // Precondition: the value encoded by this Single must be greater than 0.
+  void NormalizedBoundaries(DiyFp* out_m_minus, DiyFp* out_m_plus) const {
+    ASSERT(value() > 0.0);
+    DiyFp v = this->AsDiyFp();
+    DiyFp m_plus = DiyFp::Normalize(DiyFp((v.f() << 1) + 1, v.e() - 1));
+    DiyFp m_minus;
+    if (LowerBoundaryIsCloser()) {
+      m_minus = DiyFp((v.f() << 2) - 1, v.e() - 2);
+    } else {
+      m_minus = DiyFp((v.f() << 1) - 1, v.e() - 1);
+    }
+    m_minus.set_f(m_minus.f() << (m_minus.e() - m_plus.e()));
+    m_minus.set_e(m_plus.e());
+    *out_m_plus = m_plus;
+    *out_m_minus = m_minus;
+  }
+
+  // Precondition: the value encoded by this Single must be greater or equal
+  // than +0.0.
+  DiyFp UpperBoundary() const {
+    ASSERT(Sign() > 0);
+    return DiyFp(Significand() * 2 + 1, Exponent() - 1);
+  }
+
+  bool LowerBoundaryIsCloser() const {
+    // The boundary is closer if the significand is of the form f == 2^p-1 then
+    // the lower boundary is closer.
+    // Think of v = 1000e10 and v- = 9999e9.
+    // Then the boundary (== (v - v-)/2) is not just at a distance of 1e9 but
+    // at a distance of 1e8.
+    // The only exception is for the smallest normal: the largest denormal is
+    // at the same distance as its successor.
+    // Note: denormals have the same exponent as the smallest normals.
+    bool physical_significand_is_zero = ((AsUint32() & kSignificandMask) == 0);
+    return physical_significand_is_zero && (Exponent() != kDenormalExponent);
+  }
+
+  float value() const { return uint32_to_float(d32_); }
+
+  static float Infinity() {
+    return Single(kInfinity).value();
+  }
+
+  static float NaN() {
+    return Single(kNaN).value();
+  }
+
+ private:
+  static const int kExponentBias = 0x7F + kPhysicalSignificandSize;
+  static const int kDenormalExponent = -kExponentBias + 1;
+  static const int kMaxExponent = 0xFF - kExponentBias;
+  static const uint32_t kInfinity = 0x7F800000;
+  static const uint32_t kNaN = 0x7FC00000;
+
+  const uint32_t d32_;
+
+  DISALLOW_COPY_AND_ASSIGN(Single);
+};
+
+}  // namespace double_conversion
+
+#endif  // DOUBLE_CONVERSION_DOUBLE_H_
diff --git a/base/poco/Foundation/src/infback.c b/base/poco/Foundation/src/infback.c
new file mode 100644
index 00000000000..59679ecbfc5
--- /dev/null
+++ b/base/poco/Foundation/src/infback.c
@@ -0,0 +1,640 @@
+/* infback.c -- inflate using a call-back interface
+ * Copyright (C) 1995-2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+   This code is largely copied from inflate.c.  Normally either infback.o or
+   inflate.o would be linked into an application--not both.  The interface
+   with inffast.c is retained so that optimized assembler-coded versions of
+   inflate_fast() can be used with either inflate.c or infback.c.
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+/* function prototypes */
+local void fixedtables OF((struct inflate_state FAR *state));
+
+/*
+   strm provides memory allocation functions in zalloc and zfree, or
+   Z_NULL to use the library memory allocation functions.
+
+   windowBits is in the range 8..15, and window is a user-supplied
+   window and output buffer that is 2**windowBits bytes.
+ */
+int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
+z_streamp strm;
+int windowBits;
+unsigned char FAR *window;
+const char *version;
+int stream_size;
+{
+    struct inflate_state FAR *state;
+
+    if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
+        stream_size != (int)(sizeof(z_stream)))
+        return Z_VERSION_ERROR;
+    if (strm == Z_NULL || window == Z_NULL ||
+        windowBits < 8 || windowBits > 15)
+        return Z_STREAM_ERROR;
+    strm->msg = Z_NULL;                 /* in case we return an error */
+    if (strm->zalloc == (alloc_func)0) {
+#ifdef Z_SOLO
+        return Z_STREAM_ERROR;
+#else
+        strm->zalloc = zcalloc;
+        strm->opaque = (voidpf)0;
+#endif
+    }
+    if (strm->zfree == (free_func)0)
+#ifdef Z_SOLO
+        return Z_STREAM_ERROR;
+#else
+    strm->zfree = zcfree;
+#endif
+    state = (struct inflate_state FAR *)ZALLOC(strm, 1,
+                                               sizeof(struct inflate_state));
+    if (state == Z_NULL) return Z_MEM_ERROR;
+    Tracev((stderr, "inflate: allocated\n"));
+    strm->state = (struct internal_state FAR *)state;
+    state->dmax = 32768U;
+    state->wbits = (uInt)windowBits;
+    state->wsize = 1U << windowBits;
+    state->window = window;
+    state->wnext = 0;
+    state->whave = 0;
+    return Z_OK;
+}
+
+/*
+   Return state with length and distance decoding tables and index sizes set to
+   fixed code decoding.  Normally this returns fixed tables from inffixed.h.
+   If BUILDFIXED is defined, then instead this routine builds the tables the
+   first time it's called, and returns those tables the first time and
+   thereafter.  This reduces the size of the code by about 2K bytes, in
+   exchange for a little execution time.  However, BUILDFIXED should not be
+   used for threaded applications, since the rewriting of the tables and virgin
+   may not be thread-safe.
+ */
+local void fixedtables(state)
+struct inflate_state FAR *state;
+{
+#ifdef BUILDFIXED
+    static int virgin = 1;
+    static code *lenfix, *distfix;
+    static code fixed[544];
+
+    /* build fixed huffman tables if first call (may not be thread safe) */
+    if (virgin) {
+        unsigned sym, bits;
+        static code *next;
+
+        /* literal/length table */
+        sym = 0;
+        while (sym < 144) state->lens[sym++] = 8;
+        while (sym < 256) state->lens[sym++] = 9;
+        while (sym < 280) state->lens[sym++] = 7;
+        while (sym < 288) state->lens[sym++] = 8;
+        next = fixed;
+        lenfix = next;
+        bits = 9;
+        inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
+
+        /* distance table */
+        sym = 0;
+        while (sym < 32) state->lens[sym++] = 5;
+        distfix = next;
+        bits = 5;
+        inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
+
+        /* do this just once */
+        virgin = 0;
+    }
+#else /* !BUILDFIXED */
+#   include "inffixed.h"
+#endif /* BUILDFIXED */
+    state->lencode = lenfix;
+    state->lenbits = 9;
+    state->distcode = distfix;
+    state->distbits = 5;
+}
+
+/* Macros for inflateBack(): */
+
+/* Load returned state from inflate_fast() */
+#define LOAD() \
+    do { \
+        put = strm->next_out; \
+        left = strm->avail_out; \
+        next = strm->next_in; \
+        have = strm->avail_in; \
+        hold = state->hold; \
+        bits = state->bits; \
+    } while (0)
+
+/* Set state from registers for inflate_fast() */
+#define RESTORE() \
+    do { \
+        strm->next_out = put; \
+        strm->avail_out = left; \
+        strm->next_in = next; \
+        strm->avail_in = have; \
+        state->hold = hold; \
+        state->bits = bits; \
+    } while (0)
+
+/* Clear the input bit accumulator */
+#define INITBITS() \
+    do { \
+        hold = 0; \
+        bits = 0; \
+    } while (0)
+
+/* Assure that some input is available.  If input is requested, but denied,
+   then return a Z_BUF_ERROR from inflateBack(). */
+#define PULL() \
+    do { \
+        if (have == 0) { \
+            have = in(in_desc, &next); \
+            if (have == 0) { \
+                next = Z_NULL; \
+                ret = Z_BUF_ERROR; \
+                goto inf_leave; \
+            } \
+        } \
+    } while (0)
+
+/* Get a byte of input into the bit accumulator, or return from inflateBack()
+   with an error if there is no input available. */
+#define PULLBYTE() \
+    do { \
+        PULL(); \
+        have--; \
+        hold += (unsigned long)(*next++) << bits; \
+        bits += 8; \
+    } while (0)
+
+/* Assure that there are at least n bits in the bit accumulator.  If there is
+   not enough available input to do that, then return from inflateBack() with
+   an error. */
+#define NEEDBITS(n) \
+    do { \
+        while (bits < (unsigned)(n)) \
+            PULLBYTE(); \
+    } while (0)
+
+/* Return the low n bits of the bit accumulator (n < 16) */
+#define BITS(n) \
+    ((unsigned)hold & ((1U << (n)) - 1))
+
+/* Remove n bits from the bit accumulator */
+#define DROPBITS(n) \
+    do { \
+        hold >>= (n); \
+        bits -= (unsigned)(n); \
+    } while (0)
+
+/* Remove zero to seven bits as needed to go to a byte boundary */
+#define BYTEBITS() \
+    do { \
+        hold >>= bits & 7; \
+        bits -= bits & 7; \
+    } while (0)
+
+/* Assure that some output space is available, by writing out the window
+   if it's full.  If the write fails, return from inflateBack() with a
+   Z_BUF_ERROR. */
+#define ROOM() \
+    do { \
+        if (left == 0) { \
+            put = state->window; \
+            left = state->wsize; \
+            state->whave = left; \
+            if (out(out_desc, put, left)) { \
+                ret = Z_BUF_ERROR; \
+                goto inf_leave; \
+            } \
+        } \
+    } while (0)
+
+/*
+   strm provides the memory allocation functions and window buffer on input,
+   and provides information on the unused input on return.  For Z_DATA_ERROR
+   returns, strm will also provide an error message.
+
+   in() and out() are the call-back input and output functions.  When
+   inflateBack() needs more input, it calls in().  When inflateBack() has
+   filled the window with output, or when it completes with data in the
+   window, it calls out() to write out the data.  The application must not
+   change the provided input until in() is called again or inflateBack()
+   returns.  The application must not change the window/output buffer until
+   inflateBack() returns.
+
+   in() and out() are called with a descriptor parameter provided in the
+   inflateBack() call.  This parameter can be a structure that provides the
+   information required to do the read or write, as well as accumulated
+   information on the input and output such as totals and check values.
+
+   in() should return zero on failure.  out() should return non-zero on
+   failure.  If either in() or out() fails, than inflateBack() returns a
+   Z_BUF_ERROR.  strm->next_in can be checked for Z_NULL to see whether it
+   was in() or out() that caused in the error.  Otherwise,  inflateBack()
+   returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
+   error, or Z_MEM_ERROR if it could not allocate memory for the state.
+   inflateBack() can also return Z_STREAM_ERROR if the input parameters
+   are not correct, i.e. strm is Z_NULL or the state was not initialized.
+ */
+int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
+z_streamp strm;
+in_func in;
+void FAR *in_desc;
+out_func out;
+void FAR *out_desc;
+{
+    struct inflate_state FAR *state;
+    z_const unsigned char FAR *next;    /* next input */
+    unsigned char FAR *put;     /* next output */
+    unsigned have, left;        /* available input and output */
+    unsigned long hold;         /* bit buffer */
+    unsigned bits;              /* bits in bit buffer */
+    unsigned copy;              /* number of stored or match bytes to copy */
+    unsigned char FAR *from;    /* where to copy match bytes from */
+    code here;                  /* current decoding table entry */
+    code last;                  /* parent table entry */
+    unsigned len;               /* length to copy for repeats, bits to drop */
+    int ret;                    /* return code */
+    static const unsigned short order[19] = /* permutation of code lengths */
+        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+    /* Check that the strm exists and that the state was initialized */
+    if (strm == Z_NULL || strm->state == Z_NULL)
+        return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+
+    /* Reset the state */
+    strm->msg = Z_NULL;
+    state->mode = TYPE;
+    state->last = 0;
+    state->whave = 0;
+    next = strm->next_in;
+    have = next != Z_NULL ? strm->avail_in : 0;
+    hold = 0;
+    bits = 0;
+    put = state->window;
+    left = state->wsize;
+
+    /* Inflate until end of block marked as last */
+    for (;;)
+        switch (state->mode) {
+        case TYPE:
+            /* determine and dispatch block type */
+            if (state->last) {
+                BYTEBITS();
+                state->mode = DONE;
+                break;
+            }
+            NEEDBITS(3);
+            state->last = BITS(1);
+            DROPBITS(1);
+            switch (BITS(2)) {
+            case 0:                             /* stored block */
+                Tracev((stderr, "inflate:     stored block%s\n",
+                        state->last ? " (last)" : ""));
+                state->mode = STORED;
+                break;
+            case 1:                             /* fixed block */
+                fixedtables(state);
+                Tracev((stderr, "inflate:     fixed codes block%s\n",
+                        state->last ? " (last)" : ""));
+                state->mode = LEN;              /* decode codes */
+                break;
+            case 2:                             /* dynamic block */
+                Tracev((stderr, "inflate:     dynamic codes block%s\n",
+                        state->last ? " (last)" : ""));
+                state->mode = TABLE;
+                break;
+            case 3:
+                strm->msg = (char *)"invalid block type";
+                state->mode = BAD;
+            }
+            DROPBITS(2);
+            break;
+
+        case STORED:
+            /* get and verify stored block length */
+            BYTEBITS();                         /* go to byte boundary */
+            NEEDBITS(32);
+            if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
+                strm->msg = (char *)"invalid stored block lengths";
+                state->mode = BAD;
+                break;
+            }
+            state->length = (unsigned)hold & 0xffff;
+            Tracev((stderr, "inflate:       stored length %u\n",
+                    state->length));
+            INITBITS();
+
+            /* copy stored block from input to output */
+            while (state->length != 0) {
+                copy = state->length;
+                PULL();
+                ROOM();
+                if (copy > have) copy = have;
+                if (copy > left) copy = left;
+                zmemcpy(put, next, copy);
+                have -= copy;
+                next += copy;
+                left -= copy;
+                put += copy;
+                state->length -= copy;
+            }
+            Tracev((stderr, "inflate:       stored end\n"));
+            state->mode = TYPE;
+            break;
+
+        case TABLE:
+            /* get dynamic table entries descriptor */
+            NEEDBITS(14);
+            state->nlen = BITS(5) + 257;
+            DROPBITS(5);
+            state->ndist = BITS(5) + 1;
+            DROPBITS(5);
+            state->ncode = BITS(4) + 4;
+            DROPBITS(4);
+#ifndef PKZIP_BUG_WORKAROUND
+            if (state->nlen > 286 || state->ndist > 30) {
+                strm->msg = (char *)"too many length or distance symbols";
+                state->mode = BAD;
+                break;
+            }
+#endif
+            Tracev((stderr, "inflate:       table sizes ok\n"));
+
+            /* get code length code lengths (not a typo) */
+            state->have = 0;
+            while (state->have < state->ncode) {
+                NEEDBITS(3);
+                state->lens[order[state->have++]] = (unsigned short)BITS(3);
+                DROPBITS(3);
+            }
+            while (state->have < 19)
+                state->lens[order[state->have++]] = 0;
+            state->next = state->codes;
+            state->lencode = (code const FAR *)(state->next);
+            state->lenbits = 7;
+            ret = inflate_table(CODES, state->lens, 19, &(state->next),
+                                &(state->lenbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid code lengths set";
+                state->mode = BAD;
+                break;
+            }
+            Tracev((stderr, "inflate:       code lengths ok\n"));
+
+            /* get length and distance code code lengths */
+            state->have = 0;
+            while (state->have < state->nlen + state->ndist) {
+                for (;;) {
+                    here = state->lencode[BITS(state->lenbits)];
+                    if ((unsigned)(here.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                if (here.val < 16) {
+                    DROPBITS(here.bits);
+                    state->lens[state->have++] = here.val;
+                }
+                else {
+                    if (here.val == 16) {
+                        NEEDBITS(here.bits + 2);
+                        DROPBITS(here.bits);
+                        if (state->have == 0) {
+                            strm->msg = (char *)"invalid bit length repeat";
+                            state->mode = BAD;
+                            break;
+                        }
+                        len = (unsigned)(state->lens[state->have - 1]);
+                        copy = 3 + BITS(2);
+                        DROPBITS(2);
+                    }
+                    else if (here.val == 17) {
+                        NEEDBITS(here.bits + 3);
+                        DROPBITS(here.bits);
+                        len = 0;
+                        copy = 3 + BITS(3);
+                        DROPBITS(3);
+                    }
+                    else {
+                        NEEDBITS(here.bits + 7);
+                        DROPBITS(here.bits);
+                        len = 0;
+                        copy = 11 + BITS(7);
+                        DROPBITS(7);
+                    }
+                    if (state->have + copy > state->nlen + state->ndist) {
+                        strm->msg = (char *)"invalid bit length repeat";
+                        state->mode = BAD;
+                        break;
+                    }
+                    while (copy--)
+                        state->lens[state->have++] = (unsigned short)len;
+                }
+            }
+
+            /* handle error breaks in while */
+            if (state->mode == BAD) break;
+
+            /* check for end-of-block code (better have one) */
+            if (state->lens[256] == 0) {
+                strm->msg = (char *)"invalid code -- missing end-of-block";
+                state->mode = BAD;
+                break;
+            }
+
+            /* build code tables -- note: do not change the lenbits or distbits
+               values here (9 and 6) without reading the comments in inftrees.h
+               concerning the ENOUGH constants, which depend on those values */
+            state->next = state->codes;
+            state->lencode = (code const FAR *)(state->next);
+            state->lenbits = 9;
+            ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
+                                &(state->lenbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid literal/lengths set";
+                state->mode = BAD;
+                break;
+            }
+            state->distcode = (code const FAR *)(state->next);
+            state->distbits = 6;
+            ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
+                            &(state->next), &(state->distbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid distances set";
+                state->mode = BAD;
+                break;
+            }
+            Tracev((stderr, "inflate:       codes ok\n"));
+            state->mode = LEN;
+
+        case LEN:
+            /* use inflate_fast() if we have enough input and output */
+            if (have >= 6 && left >= 258) {
+                RESTORE();
+                if (state->whave < state->wsize)
+                    state->whave = state->wsize - left;
+                inflate_fast(strm, state->wsize);
+                LOAD();
+                break;
+            }
+
+            /* get a literal, length, or end-of-block code */
+            for (;;) {
+                here = state->lencode[BITS(state->lenbits)];
+                if ((unsigned)(here.bits) <= bits) break;
+                PULLBYTE();
+            }
+            if (here.op && (here.op & 0xf0) == 0) {
+                last = here;
+                for (;;) {
+                    here = state->lencode[last.val +
+                            (BITS(last.bits + last.op) >> last.bits)];
+                    if ((unsigned)(last.bits + here.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                DROPBITS(last.bits);
+            }
+            DROPBITS(here.bits);
+            state->length = (unsigned)here.val;
+
+            /* process literal */
+            if (here.op == 0) {
+                Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
+                        "inflate:         literal '%c'\n" :
+                        "inflate:         literal 0x%02x\n", here.val));
+                ROOM();
+                *put++ = (unsigned char)(state->length);
+                left--;
+                state->mode = LEN;
+                break;
+            }
+
+            /* process end of block */
+            if (here.op & 32) {
+                Tracevv((stderr, "inflate:         end of block\n"));
+                state->mode = TYPE;
+                break;
+            }
+
+            /* invalid code */
+            if (here.op & 64) {
+                strm->msg = (char *)"invalid literal/length code";
+                state->mode = BAD;
+                break;
+            }
+
+            /* length code -- get extra bits, if any */
+            state->extra = (unsigned)(here.op) & 15;
+            if (state->extra != 0) {
+                NEEDBITS(state->extra);
+                state->length += BITS(state->extra);
+                DROPBITS(state->extra);
+            }
+            Tracevv((stderr, "inflate:         length %u\n", state->length));
+
+            /* get distance code */
+            for (;;) {
+                here = state->distcode[BITS(state->distbits)];
+                if ((unsigned)(here.bits) <= bits) break;
+                PULLBYTE();
+            }
+            if ((here.op & 0xf0) == 0) {
+                last = here;
+                for (;;) {
+                    here = state->distcode[last.val +
+                            (BITS(last.bits + last.op) >> last.bits)];
+                    if ((unsigned)(last.bits + here.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                DROPBITS(last.bits);
+            }
+            DROPBITS(here.bits);
+            if (here.op & 64) {
+                strm->msg = (char *)"invalid distance code";
+                state->mode = BAD;
+                break;
+            }
+            state->offset = (unsigned)here.val;
+
+            /* get distance extra bits, if any */
+            state->extra = (unsigned)(here.op) & 15;
+            if (state->extra != 0) {
+                NEEDBITS(state->extra);
+                state->offset += BITS(state->extra);
+                DROPBITS(state->extra);
+            }
+            if (state->offset > state->wsize - (state->whave < state->wsize ?
+                                                left : 0)) {
+                strm->msg = (char *)"invalid distance too far back";
+                state->mode = BAD;
+                break;
+            }
+            Tracevv((stderr, "inflate:         distance %u\n", state->offset));
+
+            /* copy match from window to output */
+            do {
+                ROOM();
+                copy = state->wsize - state->offset;
+                if (copy < left) {
+                    from = put + copy;
+                    copy = left - copy;
+                }
+                else {
+                    from = put - state->offset;
+                    copy = left;
+                }
+                if (copy > state->length) copy = state->length;
+                state->length -= copy;
+                left -= copy;
+                do {
+                    *put++ = *from++;
+                } while (--copy);
+            } while (state->length != 0);
+            break;
+
+        case DONE:
+            /* inflate stream terminated properly -- write leftover output */
+            ret = Z_STREAM_END;
+            if (left < state->wsize) {
+                if (out(out_desc, state->window, state->wsize - left))
+                    ret = Z_BUF_ERROR;
+            }
+            goto inf_leave;
+
+        case BAD:
+            ret = Z_DATA_ERROR;
+            goto inf_leave;
+
+        default:                /* can't happen, but makes compilers happy */
+            ret = Z_STREAM_ERROR;
+            goto inf_leave;
+        }
+
+    /* Return unused input */
+  inf_leave:
+    strm->next_in = next;
+    strm->avail_in = have;
+    return ret;
+}
+
+int ZEXPORT inflateBackEnd(strm)
+z_streamp strm;
+{
+    if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
+        return Z_STREAM_ERROR;
+    ZFREE(strm, strm->state);
+    strm->state = Z_NULL;
+    Tracev((stderr, "inflate: end\n"));
+    return Z_OK;
+}
diff --git a/base/poco/Foundation/src/inffast.c b/base/poco/Foundation/src/inffast.c
new file mode 100644
index 00000000000..0dbd1dbc09f
--- /dev/null
+++ b/base/poco/Foundation/src/inffast.c
@@ -0,0 +1,323 @@
+/* inffast.c -- fast decoding
+ * Copyright (C) 1995-2017 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+#ifdef ASMINF
+#  pragma message("Assembler code may have bugs -- use at your own risk")
+#else
+
+/*
+   Decode literal, length, and distance codes and write out the resulting
+   literal and match bytes until either not enough input or output is
+   available, an end-of-block is encountered, or a data error is encountered.
+   When large enough input and output buffers are supplied to inflate(), for
+   example, a 16K input buffer and a 64K output buffer, more than 95% of the
+   inflate execution time is spent in this routine.
+
+   Entry assumptions:
+
+        state->mode == LEN
+        strm->avail_in >= 6
+        strm->avail_out >= 258
+        start >= strm->avail_out
+        state->bits < 8
+
+   On return, state->mode is one of:
+
+        LEN -- ran out of enough output space or enough available input
+        TYPE -- reached end of block code, inflate() to interpret next block
+        BAD -- error in block data
+
+   Notes:
+
+    - The maximum input bits used by a length/distance pair is 15 bits for the
+      length code, 5 bits for the length extra, 15 bits for the distance code,
+      and 13 bits for the distance extra.  This totals 48 bits, or six bytes.
+      Therefore if strm->avail_in >= 6, then there is enough input to avoid
+      checking for available input while decoding.
+
+    - The maximum bytes that a single length/distance pair can output is 258
+      bytes, which is the maximum length that can be coded.  inflate_fast()
+      requires strm->avail_out >= 258 for each loop to avoid checking for
+      output space.
+ */
+void ZLIB_INTERNAL inflate_fast(strm, start)
+z_streamp strm;
+unsigned start;         /* inflate()'s starting value for strm->avail_out */
+{
+    struct inflate_state FAR *state;
+    z_const unsigned char FAR *in;      /* local strm->next_in */
+    z_const unsigned char FAR *last;    /* have enough input while in < last */
+    unsigned char FAR *out;     /* local strm->next_out */
+    unsigned char FAR *beg;     /* inflate()'s initial strm->next_out */
+    unsigned char FAR *end;     /* while out < end, enough space available */
+#ifdef INFLATE_STRICT
+    unsigned dmax;              /* maximum distance from zlib header */
+#endif
+    unsigned wsize;             /* window size or zero if not using window */
+    unsigned whave;             /* valid bytes in the window */
+    unsigned wnext;             /* window write index */
+    unsigned char FAR *window;  /* allocated sliding window, if wsize != 0 */
+    unsigned long hold;         /* local strm->hold */
+    unsigned bits;              /* local strm->bits */
+    code const FAR *lcode;      /* local strm->lencode */
+    code const FAR *dcode;      /* local strm->distcode */
+    unsigned lmask;             /* mask for first level of length codes */
+    unsigned dmask;             /* mask for first level of distance codes */
+    code here;                  /* retrieved table entry */
+    unsigned op;                /* code bits, operation, extra bits, or */
+                                /*  window position, window bytes to copy */
+    unsigned len;               /* match length, unused bytes */
+    unsigned dist;              /* match distance */
+    unsigned char FAR *from;    /* where to copy match from */
+
+    /* copy state to local variables */
+    state = (struct inflate_state FAR *)strm->state;
+    in = strm->next_in;
+    last = in + (strm->avail_in - 5);
+    out = strm->next_out;
+    beg = out - (start - strm->avail_out);
+    end = out + (strm->avail_out - 257);
+#ifdef INFLATE_STRICT
+    dmax = state->dmax;
+#endif
+    wsize = state->wsize;
+    whave = state->whave;
+    wnext = state->wnext;
+    window = state->window;
+    hold = state->hold;
+    bits = state->bits;
+    lcode = state->lencode;
+    dcode = state->distcode;
+    lmask = (1U << state->lenbits) - 1;
+    dmask = (1U << state->distbits) - 1;
+
+    /* decode literals and length/distances until end-of-block or not enough
+       input data or output space */
+    do {
+        if (bits < 15) {
+            hold += (unsigned long)(*in++) << bits;
+            bits += 8;
+            hold += (unsigned long)(*in++) << bits;
+            bits += 8;
+        }
+        here = lcode[hold & lmask];
+      dolen:
+        op = (unsigned)(here.bits);
+        hold >>= op;
+        bits -= op;
+        op = (unsigned)(here.op);
+        if (op == 0) {                          /* literal */
+            Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
+                    "inflate:         literal '%c'\n" :
+                    "inflate:         literal 0x%02x\n", here.val));
+            *out++ = (unsigned char)(here.val);
+        }
+        else if (op & 16) {                     /* length base */
+            len = (unsigned)(here.val);
+            op &= 15;                           /* number of extra bits */
+            if (op) {
+                if (bits < op) {
+                    hold += (unsigned long)(*in++) << bits;
+                    bits += 8;
+                }
+                len += (unsigned)hold & ((1U << op) - 1);
+                hold >>= op;
+                bits -= op;
+            }
+            Tracevv((stderr, "inflate:         length %u\n", len));
+            if (bits < 15) {
+                hold += (unsigned long)(*in++) << bits;
+                bits += 8;
+                hold += (unsigned long)(*in++) << bits;
+                bits += 8;
+            }
+            here = dcode[hold & dmask];
+          dodist:
+            op = (unsigned)(here.bits);
+            hold >>= op;
+            bits -= op;
+            op = (unsigned)(here.op);
+            if (op & 16) {                      /* distance base */
+                dist = (unsigned)(here.val);
+                op &= 15;                       /* number of extra bits */
+                if (bits < op) {
+                    hold += (unsigned long)(*in++) << bits;
+                    bits += 8;
+                    if (bits < op) {
+                        hold += (unsigned long)(*in++) << bits;
+                        bits += 8;
+                    }
+                }
+                dist += (unsigned)hold & ((1U << op) - 1);
+#ifdef INFLATE_STRICT
+                if (dist > dmax) {
+                    strm->msg = (char *)"invalid distance too far back";
+                    state->mode = BAD;
+                    break;
+                }
+#endif
+                hold >>= op;
+                bits -= op;
+                Tracevv((stderr, "inflate:         distance %u\n", dist));
+                op = (unsigned)(out - beg);     /* max distance in output */
+                if (dist > op) {                /* see if copy from window */
+                    op = dist - op;             /* distance back in window */
+                    if (op > whave) {
+                        if (state->sane) {
+                            strm->msg =
+                                (char *)"invalid distance too far back";
+                            state->mode = BAD;
+                            break;
+                        }
+#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+                        if (len <= op - whave) {
+                            do {
+                                *out++ = 0;
+                            } while (--len);
+                            continue;
+                        }
+                        len -= op - whave;
+                        do {
+                            *out++ = 0;
+                        } while (--op > whave);
+                        if (op == 0) {
+                            from = out - dist;
+                            do {
+                                *out++ = *from++;
+                            } while (--len);
+                            continue;
+                        }
+#endif
+                    }
+                    from = window;
+                    if (wnext == 0) {           /* very common case */
+                        from += wsize - op;
+                        if (op < len) {         /* some from window */
+                            len -= op;
+                            do {
+                                *out++ = *from++;
+                            } while (--op);
+                            from = out - dist;  /* rest from output */
+                        }
+                    }
+                    else if (wnext < op) {      /* wrap around window */
+                        from += wsize + wnext - op;
+                        op -= wnext;
+                        if (op < len) {         /* some from end of window */
+                            len -= op;
+                            do {
+                                *out++ = *from++;
+                            } while (--op);
+                            from = window;
+                            if (wnext < len) {  /* some from start of window */
+                                op = wnext;
+                                len -= op;
+                                do {
+                                    *out++ = *from++;
+                                } while (--op);
+                                from = out - dist;      /* rest from output */
+                            }
+                        }
+                    }
+                    else {                      /* contiguous in window */
+                        from += wnext - op;
+                        if (op < len) {         /* some from window */
+                            len -= op;
+                            do {
+                                *out++ = *from++;
+                            } while (--op);
+                            from = out - dist;  /* rest from output */
+                        }
+                    }
+                    while (len > 2) {
+                        *out++ = *from++;
+                        *out++ = *from++;
+                        *out++ = *from++;
+                        len -= 3;
+                    }
+                    if (len) {
+                        *out++ = *from++;
+                        if (len > 1)
+                            *out++ = *from++;
+                    }
+                }
+                else {
+                    from = out - dist;          /* copy direct from output */
+                    do {                        /* minimum length is three */
+                        *out++ = *from++;
+                        *out++ = *from++;
+                        *out++ = *from++;
+                        len -= 3;
+                    } while (len > 2);
+                    if (len) {
+                        *out++ = *from++;
+                        if (len > 1)
+                            *out++ = *from++;
+                    }
+                }
+            }
+            else if ((op & 64) == 0) {          /* 2nd level distance code */
+                here = dcode[here.val + (hold & ((1U << op) - 1))];
+                goto dodist;
+            }
+            else {
+                strm->msg = (char *)"invalid distance code";
+                state->mode = BAD;
+                break;
+            }
+        }
+        else if ((op & 64) == 0) {              /* 2nd level length code */
+            here = lcode[here.val + (hold & ((1U << op) - 1))];
+            goto dolen;
+        }
+        else if (op & 32) {                     /* end-of-block */
+            Tracevv((stderr, "inflate:         end of block\n"));
+            state->mode = TYPE;
+            break;
+        }
+        else {
+            strm->msg = (char *)"invalid literal/length code";
+            state->mode = BAD;
+            break;
+        }
+    } while (in < last && out < end);
+
+    /* return unused bytes (on entry, bits < 8, so in won't go too far back) */
+    len = bits >> 3;
+    in -= len;
+    bits -= len << 3;
+    hold &= (1U << bits) - 1;
+
+    /* update state and return */
+    strm->next_in = in;
+    strm->next_out = out;
+    strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last));
+    strm->avail_out = (unsigned)(out < end ?
+                                 257 + (end - out) : 257 - (out - end));
+    state->hold = hold;
+    state->bits = bits;
+    return;
+}
+
+/*
+   inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe):
+   - Using bit fields for code structure
+   - Different op definition to avoid & for extra bits (do & for table bits)
+   - Three separate decoding do-loops for direct, window, and wnext == 0
+   - Special case for distance > 1 copies to do overlapped load and store copy
+   - Explicit branch predictions (based on measured branch probabilities)
+   - Deferring match copy and interspersed it with decoding subsequent codes
+   - Swapping literal/length else
+   - Swapping window/direct else
+   - Larger unrolled copy loops (three is about right)
+   - Moving len -= 3 statement into middle of loop
+ */
+
+#endif /* !ASMINF */
diff --git a/base/poco/Foundation/src/inffast.h b/base/poco/Foundation/src/inffast.h
new file mode 100644
index 00000000000..e5c1aa4ca8c
--- /dev/null
+++ b/base/poco/Foundation/src/inffast.h
@@ -0,0 +1,11 @@
+/* inffast.h -- header to use inffast.c
+ * Copyright (C) 1995-2003, 2010 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start));
diff --git a/base/poco/Foundation/src/inffixed.h b/base/poco/Foundation/src/inffixed.h
new file mode 100644
index 00000000000..d6283277694
--- /dev/null
+++ b/base/poco/Foundation/src/inffixed.h
@@ -0,0 +1,94 @@
+    /* inffixed.h -- table for decoding fixed codes
+     * Generated automatically by makefixed().
+     */
+
+    /* WARNING: this file should *not* be used by applications.
+       It is part of the implementation of this library and is
+       subject to change. Applications should only use zlib.h.
+     */
+
+    static const code lenfix[512] = {
+        {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48},
+        {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128},
+        {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59},
+        {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176},
+        {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20},
+        {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100},
+        {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8},
+        {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216},
+        {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76},
+        {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114},
+        {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},
+        {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148},
+        {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42},
+        {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86},
+        {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15},
+        {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236},
+        {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62},
+        {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
+        {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31},
+        {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162},
+        {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25},
+        {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105},
+        {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4},
+        {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202},
+        {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69},
+        {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125},
+        {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13},
+        {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195},
+        {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35},
+        {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91},
+        {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19},
+        {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246},
+        {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55},
+        {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135},
+        {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99},
+        {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190},
+        {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16},
+        {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96},
+        {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6},
+        {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209},
+        {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},
+        {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116},
+        {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4},
+        {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153},
+        {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44},
+        {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82},
+        {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11},
+        {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
+        {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58},
+        {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138},
+        {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51},
+        {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173},
+        {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30},
+        {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110},
+        {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0},
+        {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195},
+        {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65},
+        {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121},
+        {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},
+        {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258},
+        {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37},
+        {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93},
+        {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23},
+        {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251},
+        {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51},
+        {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
+        {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67},
+        {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183},
+        {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23},
+        {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103},
+        {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9},
+        {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223},
+        {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79},
+        {0,9,255}
+    };
+
+    static const code distfix[32] = {
+        {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025},
+        {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193},
+        {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385},
+        {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577},
+        {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073},
+        {22,5,193},{64,5,0}
+    };
diff --git a/base/poco/Foundation/src/inflate.c b/base/poco/Foundation/src/inflate.c
new file mode 100644
index 00000000000..ac333e8c2ed
--- /dev/null
+++ b/base/poco/Foundation/src/inflate.c
@@ -0,0 +1,1561 @@
+/* inflate.c -- zlib decompression
+ * Copyright (C) 1995-2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ * Change history:
+ *
+ * 1.2.beta0    24 Nov 2002
+ * - First version -- complete rewrite of inflate to simplify code, avoid
+ *   creation of window when not needed, minimize use of window when it is
+ *   needed, make inffast.c even faster, implement gzip decoding, and to
+ *   improve code readability and style over the previous zlib inflate code
+ *
+ * 1.2.beta1    25 Nov 2002
+ * - Use pointers for available input and output checking in inffast.c
+ * - Remove input and output counters in inffast.c
+ * - Change inffast.c entry and loop from avail_in >= 7 to >= 6
+ * - Remove unnecessary second byte pull from length extra in inffast.c
+ * - Unroll direct copy to three copies per loop in inffast.c
+ *
+ * 1.2.beta2    4 Dec 2002
+ * - Change external routine names to reduce potential conflicts
+ * - Correct filename to inffixed.h for fixed tables in inflate.c
+ * - Make hbuf[] unsigned char to match parameter type in inflate.c
+ * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset)
+ *   to avoid negation problem on Alphas (64 bit) in inflate.c
+ *
+ * 1.2.beta3    22 Dec 2002
+ * - Add comments on state->bits assertion in inffast.c
+ * - Add comments on op field in inftrees.h
+ * - Fix bug in reuse of allocated window after inflateReset()
+ * - Remove bit fields--back to byte structure for speed
+ * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths
+ * - Change post-increments to pre-increments in inflate_fast(), PPC biased?
+ * - Add compile time option, POSTINC, to use post-increments instead (Intel?)
+ * - Make MATCH copy in inflate() much faster for when inflate_fast() not used
+ * - Use local copies of stream next and avail values, as well as local bit
+ *   buffer and bit count in inflate()--for speed when inflate_fast() not used
+ *
+ * 1.2.beta4    1 Jan 2003
+ * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings
+ * - Move a comment on output buffer sizes from inffast.c to inflate.c
+ * - Add comments in inffast.c to introduce the inflate_fast() routine
+ * - Rearrange window copies in inflate_fast() for speed and simplification
+ * - Unroll last copy for window match in inflate_fast()
+ * - Use local copies of window variables in inflate_fast() for speed
+ * - Pull out common wnext == 0 case for speed in inflate_fast()
+ * - Make op and len in inflate_fast() unsigned for consistency
+ * - Add FAR to lcode and dcode declarations in inflate_fast()
+ * - Simplified bad distance check in inflate_fast()
+ * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new
+ *   source file infback.c to provide a call-back interface to inflate for
+ *   programs like gzip and unzip -- uses window as output buffer to avoid
+ *   window copying
+ *
+ * 1.2.beta5    1 Jan 2003
+ * - Improved inflateBack() interface to allow the caller to provide initial
+ *   input in strm.
+ * - Fixed stored blocks bug in inflateBack()
+ *
+ * 1.2.beta6    4 Jan 2003
+ * - Added comments in inffast.c on effectiveness of POSTINC
+ * - Typecasting all around to reduce compiler warnings
+ * - Changed loops from while (1) or do {} while (1) to for (;;), again to
+ *   make compilers happy
+ * - Changed type of window in inflateBackInit() to unsigned char *
+ *
+ * 1.2.beta7    27 Jan 2003
+ * - Changed many types to unsigned or unsigned short to avoid warnings
+ * - Added inflateCopy() function
+ *
+ * 1.2.0        9 Mar 2003
+ * - Changed inflateBack() interface to provide separate opaque descriptors
+ *   for the in() and out() functions
+ * - Changed inflateBack() argument and in_func typedef to swap the length
+ *   and buffer address return values for the input function
+ * - Check next_in and next_out for Z_NULL on entry to inflate()
+ *
+ * The history for versions after 1.2.0 are in ChangeLog in zlib distribution.
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+#ifdef MAKEFIXED
+#  ifndef BUILDFIXED
+#    define BUILDFIXED
+#  endif
+#endif
+
+/* function prototypes */
+local int inflateStateCheck OF((z_streamp strm));
+local void fixedtables OF((struct inflate_state FAR *state));
+local int updatewindow OF((z_streamp strm, const unsigned char FAR *end,
+                           unsigned copy));
+#ifdef BUILDFIXED
+   void makefixed OF((void));
+#endif
+local unsigned syncsearch OF((unsigned FAR *have, const unsigned char FAR *buf,
+                              unsigned len));
+
+local int inflateStateCheck(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+    if (strm == Z_NULL ||
+        strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
+        return 1;
+    state = (struct inflate_state FAR *)strm->state;
+    if (state == Z_NULL || state->strm != strm ||
+        state->mode < HEAD || state->mode > SYNC)
+        return 1;
+    return 0;
+}
+
+int ZEXPORT inflateResetKeep(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    strm->total_in = strm->total_out = state->total = 0;
+    strm->msg = Z_NULL;
+    if (state->wrap)        /* to support ill-conceived Java test suite */
+        strm->adler = state->wrap & 1;
+    state->mode = HEAD;
+    state->last = 0;
+    state->havedict = 0;
+    state->dmax = 32768U;
+    state->head = Z_NULL;
+    state->hold = 0;
+    state->bits = 0;
+    state->lencode = state->distcode = state->next = state->codes;
+    state->sane = 1;
+    state->back = -1;
+    Tracev((stderr, "inflate: reset\n"));
+    return Z_OK;
+}
+
+int ZEXPORT inflateReset(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    state->wsize = 0;
+    state->whave = 0;
+    state->wnext = 0;
+    return inflateResetKeep(strm);
+}
+
+int ZEXPORT inflateReset2(strm, windowBits)
+z_streamp strm;
+int windowBits;
+{
+    int wrap;
+    struct inflate_state FAR *state;
+
+    /* get the state */
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+
+    /* extract wrap request from windowBits parameter */
+    if (windowBits < 0) {
+        wrap = 0;
+        windowBits = -windowBits;
+    }
+    else {
+        wrap = (windowBits >> 4) + 5;
+#ifdef GUNZIP
+        if (windowBits < 48)
+            windowBits &= 15;
+#endif
+    }
+
+    /* set number of window bits, free window if different */
+    if (windowBits && (windowBits < 8 || windowBits > 15))
+        return Z_STREAM_ERROR;
+    if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) {
+        ZFREE(strm, state->window);
+        state->window = Z_NULL;
+    }
+
+    /* update state and reset the rest of it */
+    state->wrap = wrap;
+    state->wbits = (unsigned)windowBits;
+    return inflateReset(strm);
+}
+
+int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size)
+z_streamp strm;
+int windowBits;
+const char *version;
+int stream_size;
+{
+    int ret;
+    struct inflate_state FAR *state;
+
+    if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
+        stream_size != (int)(sizeof(z_stream)))
+        return Z_VERSION_ERROR;
+    if (strm == Z_NULL) return Z_STREAM_ERROR;
+    strm->msg = Z_NULL;                 /* in case we return an error */
+    if (strm->zalloc == (alloc_func)0) {
+#ifdef Z_SOLO
+        return Z_STREAM_ERROR;
+#else
+        strm->zalloc = zcalloc;
+        strm->opaque = (voidpf)0;
+#endif
+    }
+    if (strm->zfree == (free_func)0)
+#ifdef Z_SOLO
+        return Z_STREAM_ERROR;
+#else
+        strm->zfree = zcfree;
+#endif
+    state = (struct inflate_state FAR *)
+            ZALLOC(strm, 1, sizeof(struct inflate_state));
+    if (state == Z_NULL) return Z_MEM_ERROR;
+    Tracev((stderr, "inflate: allocated\n"));
+    strm->state = (struct internal_state FAR *)state;
+    state->strm = strm;
+    state->window = Z_NULL;
+    state->mode = HEAD;     /* to pass state test in inflateReset2() */
+    ret = inflateReset2(strm, windowBits);
+    if (ret != Z_OK) {
+        ZFREE(strm, state);
+        strm->state = Z_NULL;
+    }
+    return ret;
+}
+
+int ZEXPORT inflateInit_(strm, version, stream_size)
+z_streamp strm;
+const char *version;
+int stream_size;
+{
+    return inflateInit2_(strm, DEF_WBITS, version, stream_size);
+}
+
+int ZEXPORT inflatePrime(strm, bits, value)
+z_streamp strm;
+int bits;
+int value;
+{
+    struct inflate_state FAR *state;
+
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if (bits < 0) {
+        state->hold = 0;
+        state->bits = 0;
+        return Z_OK;
+    }
+    if (bits > 16 || state->bits + (uInt)bits > 32) return Z_STREAM_ERROR;
+    value &= (1L << bits) - 1;
+    state->hold += (unsigned)value << state->bits;
+    state->bits += (uInt)bits;
+    return Z_OK;
+}
+
+/*
+   Return state with length and distance decoding tables and index sizes set to
+   fixed code decoding.  Normally this returns fixed tables from inffixed.h.
+   If BUILDFIXED is defined, then instead this routine builds the tables the
+   first time it's called, and returns those tables the first time and
+   thereafter.  This reduces the size of the code by about 2K bytes, in
+   exchange for a little execution time.  However, BUILDFIXED should not be
+   used for threaded applications, since the rewriting of the tables and virgin
+   may not be thread-safe.
+ */
+local void fixedtables(state)
+struct inflate_state FAR *state;
+{
+#ifdef BUILDFIXED
+    static int virgin = 1;
+    static code *lenfix, *distfix;
+    static code fixed[544];
+
+    /* build fixed huffman tables if first call (may not be thread safe) */
+    if (virgin) {
+        unsigned sym, bits;
+        static code *next;
+
+        /* literal/length table */
+        sym = 0;
+        while (sym < 144) state->lens[sym++] = 8;
+        while (sym < 256) state->lens[sym++] = 9;
+        while (sym < 280) state->lens[sym++] = 7;
+        while (sym < 288) state->lens[sym++] = 8;
+        next = fixed;
+        lenfix = next;
+        bits = 9;
+        inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work);
+
+        /* distance table */
+        sym = 0;
+        while (sym < 32) state->lens[sym++] = 5;
+        distfix = next;
+        bits = 5;
+        inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work);
+
+        /* do this just once */
+        virgin = 0;
+    }
+#else /* !BUILDFIXED */
+#   include "inffixed.h"
+#endif /* BUILDFIXED */
+    state->lencode = lenfix;
+    state->lenbits = 9;
+    state->distcode = distfix;
+    state->distbits = 5;
+}
+
+#ifdef MAKEFIXED
+#include <stdio.h>
+
+/*
+   Write out the inffixed.h that is #include'd above.  Defining MAKEFIXED also
+   defines BUILDFIXED, so the tables are built on the fly.  makefixed() writes
+   those tables to stdout, which would be piped to inffixed.h.  A small program
+   can simply call makefixed to do this:
+
+    void makefixed(void);
+
+    int main(void)
+    {
+        makefixed();
+        return 0;
+    }
+
+   Then that can be linked with zlib built with MAKEFIXED defined and run:
+
+    a.out > inffixed.h
+ */
+void makefixed()
+{
+    unsigned low, size;
+    struct inflate_state state;
+
+    fixedtables(&state);
+    puts("    /* inffixed.h -- table for decoding fixed codes");
+    puts("     * Generated automatically by makefixed().");
+    puts("     */");
+    puts("");
+    puts("    /* WARNING: this file should *not* be used by applications.");
+    puts("       It is part of the implementation of this library and is");
+    puts("       subject to change. Applications should only use zlib.h.");
+    puts("     */");
+    puts("");
+    size = 1U << 9;
+    printf("    static const code lenfix[%u] = {", size);
+    low = 0;
+    for (;;) {
+        if ((low % 7) == 0) printf("\n        ");
+        printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op,
+               state.lencode[low].bits, state.lencode[low].val);
+        if (++low == size) break;
+        putchar(',');
+    }
+    puts("\n    };");
+    size = 1U << 5;
+    printf("\n    static const code distfix[%u] = {", size);
+    low = 0;
+    for (;;) {
+        if ((low % 6) == 0) printf("\n        ");
+        printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits,
+               state.distcode[low].val);
+        if (++low == size) break;
+        putchar(',');
+    }
+    puts("\n    };");
+}
+#endif /* MAKEFIXED */
+
+/*
+   Update the window with the last wsize (normally 32K) bytes written before
+   returning.  If window does not exist yet, create it.  This is only called
+   when a window is already in use, or when output has been written during this
+   inflate call, but the end of the deflate stream has not been reached yet.
+   It is also called to create a window for dictionary data when a dictionary
+   is loaded.
+
+   Providing output buffers larger than 32K to inflate() should provide a speed
+   advantage, since only the last 32K of output is copied to the sliding window
+   upon return from inflate(), and since all distances after the first 32K of
+   output will fall in the output data, making match copies simpler and faster.
+   The advantage may be dependent on the size of the processor's data caches.
+ */
+local int updatewindow(strm, end, copy)
+z_streamp strm;
+const Bytef *end;
+unsigned copy;
+{
+    struct inflate_state FAR *state;
+    unsigned dist;
+
+    state = (struct inflate_state FAR *)strm->state;
+
+    /* if it hasn't been done already, allocate space for the window */
+    if (state->window == Z_NULL) {
+        state->window = (unsigned char FAR *)
+                        ZALLOC(strm, 1U << state->wbits,
+                               sizeof(unsigned char));
+        if (state->window == Z_NULL) return 1;
+    }
+
+    /* if window not in use yet, initialize */
+    if (state->wsize == 0) {
+        state->wsize = 1U << state->wbits;
+        state->wnext = 0;
+        state->whave = 0;
+    }
+
+    /* copy state->wsize or less output bytes into the circular window */
+    if (copy >= state->wsize) {
+        zmemcpy(state->window, end - state->wsize, state->wsize);
+        state->wnext = 0;
+        state->whave = state->wsize;
+    }
+    else {
+        dist = state->wsize - state->wnext;
+        if (dist > copy) dist = copy;
+        zmemcpy(state->window + state->wnext, end - copy, dist);
+        copy -= dist;
+        if (copy) {
+            zmemcpy(state->window, end - copy, copy);
+            state->wnext = copy;
+            state->whave = state->wsize;
+        }
+        else {
+            state->wnext += dist;
+            if (state->wnext == state->wsize) state->wnext = 0;
+            if (state->whave < state->wsize) state->whave += dist;
+        }
+    }
+    return 0;
+}
+
+/* Macros for inflate(): */
+
+/* check function to use adler32() for zlib or crc32() for gzip */
+#ifdef GUNZIP
+#  define UPDATE(check, buf, len) \
+    (state->flags ? crc32(check, buf, len) : adler32(check, buf, len))
+#else
+#  define UPDATE(check, buf, len) adler32(check, buf, len)
+#endif
+
+/* check macros for header crc */
+#ifdef GUNZIP
+#  define CRC2(check, word) \
+    do { \
+        hbuf[0] = (unsigned char)(word); \
+        hbuf[1] = (unsigned char)((word) >> 8); \
+        check = crc32(check, hbuf, 2); \
+    } while (0)
+
+#  define CRC4(check, word) \
+    do { \
+        hbuf[0] = (unsigned char)(word); \
+        hbuf[1] = (unsigned char)((word) >> 8); \
+        hbuf[2] = (unsigned char)((word) >> 16); \
+        hbuf[3] = (unsigned char)((word) >> 24); \
+        check = crc32(check, hbuf, 4); \
+    } while (0)
+#endif
+
+/* Load registers with state in inflate() for speed */
+#define LOAD() \
+    do { \
+        put = strm->next_out; \
+        left = strm->avail_out; \
+        next = strm->next_in; \
+        have = strm->avail_in; \
+        hold = state->hold; \
+        bits = state->bits; \
+    } while (0)
+
+/* Restore state from registers in inflate() */
+#define RESTORE() \
+    do { \
+        strm->next_out = put; \
+        strm->avail_out = left; \
+        strm->next_in = next; \
+        strm->avail_in = have; \
+        state->hold = hold; \
+        state->bits = bits; \
+    } while (0)
+
+/* Clear the input bit accumulator */
+#define INITBITS() \
+    do { \
+        hold = 0; \
+        bits = 0; \
+    } while (0)
+
+/* Get a byte of input into the bit accumulator, or return from inflate()
+   if there is no input available. */
+#define PULLBYTE() \
+    do { \
+        if (have == 0) goto inf_leave; \
+        have--; \
+        hold += (unsigned long)(*next++) << bits; \
+        bits += 8; \
+    } while (0)
+
+/* Assure that there are at least n bits in the bit accumulator.  If there is
+   not enough available input to do that, then return from inflate(). */
+#define NEEDBITS(n) \
+    do { \
+        while (bits < (unsigned)(n)) \
+            PULLBYTE(); \
+    } while (0)
+
+/* Return the low n bits of the bit accumulator (n < 16) */
+#define BITS(n) \
+    ((unsigned)hold & ((1U << (n)) - 1))
+
+/* Remove n bits from the bit accumulator */
+#define DROPBITS(n) \
+    do { \
+        hold >>= (n); \
+        bits -= (unsigned)(n); \
+    } while (0)
+
+/* Remove zero to seven bits as needed to go to a byte boundary */
+#define BYTEBITS() \
+    do { \
+        hold >>= bits & 7; \
+        bits -= bits & 7; \
+    } while (0)
+
+/*
+   inflate() uses a state machine to process as much input data and generate as
+   much output data as possible before returning.  The state machine is
+   structured roughly as follows:
+
+    for (;;) switch (state) {
+    ...
+    case STATEn:
+        if (not enough input data or output space to make progress)
+            return;
+        ... make progress ...
+        state = STATEm;
+        break;
+    ...
+    }
+
+   so when inflate() is called again, the same case is attempted again, and
+   if the appropriate resources are provided, the machine proceeds to the
+   next state.  The NEEDBITS() macro is usually the way the state evaluates
+   whether it can proceed or should return.  NEEDBITS() does the return if
+   the requested bits are not available.  The typical use of the BITS macros
+   is:
+
+        NEEDBITS(n);
+        ... do something with BITS(n) ...
+        DROPBITS(n);
+
+   where NEEDBITS(n) either returns from inflate() if there isn't enough
+   input left to load n bits into the accumulator, or it continues.  BITS(n)
+   gives the low n bits in the accumulator.  When done, DROPBITS(n) drops
+   the low n bits off the accumulator.  INITBITS() clears the accumulator
+   and sets the number of available bits to zero.  BYTEBITS() discards just
+   enough bits to put the accumulator on a byte boundary.  After BYTEBITS()
+   and a NEEDBITS(8), then BITS(8) would return the next byte in the stream.
+
+   NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return
+   if there is no input available.  The decoding of variable length codes uses
+   PULLBYTE() directly in order to pull just enough bytes to decode the next
+   code, and no more.
+
+   Some states loop until they get enough input, making sure that enough
+   state information is maintained to continue the loop where it left off
+   if NEEDBITS() returns in the loop.  For example, want, need, and keep
+   would all have to actually be part of the saved state in case NEEDBITS()
+   returns:
+
+    case STATEw:
+        while (want < need) {
+            NEEDBITS(n);
+            keep[want++] = BITS(n);
+            DROPBITS(n);
+        }
+        state = STATEx;
+    case STATEx:
+
+   As shown above, if the next state is also the next case, then the break
+   is omitted.
+
+   A state may also return if there is not enough output space available to
+   complete that state.  Those states are copying stored data, writing a
+   literal byte, and copying a matching string.
+
+   When returning, a "goto inf_leave" is used to update the total counters,
+   update the check value, and determine whether any progress has been made
+   during that inflate() call in order to return the proper return code.
+   Progress is defined as a change in either strm->avail_in or strm->avail_out.
+   When there is a window, goto inf_leave will update the window with the last
+   output written.  If a goto inf_leave occurs in the middle of decompression
+   and there is no window currently, goto inf_leave will create one and copy
+   output to the window for the next call of inflate().
+
+   In this implementation, the flush parameter of inflate() only affects the
+   return code (per zlib.h).  inflate() always writes as much as possible to
+   strm->next_out, given the space available and the provided input--the effect
+   documented in zlib.h of Z_SYNC_FLUSH.  Furthermore, inflate() always defers
+   the allocation of and copying into a sliding window until necessary, which
+   provides the effect documented in zlib.h for Z_FINISH when the entire input
+   stream available.  So the only thing the flush parameter actually does is:
+   when flush is set to Z_FINISH, inflate() cannot return Z_OK.  Instead it
+   will return Z_BUF_ERROR if it has not reached the end of the stream.
+ */
+
+int ZEXPORT inflate(strm, flush)
+z_streamp strm;
+int flush;
+{
+    struct inflate_state FAR *state;
+    z_const unsigned char FAR *next;    /* next input */
+    unsigned char FAR *put;     /* next output */
+    unsigned have, left;        /* available input and output */
+    unsigned long hold;         /* bit buffer */
+    unsigned bits;              /* bits in bit buffer */
+    unsigned in, out;           /* save starting available input and output */
+    unsigned copy;              /* number of stored or match bytes to copy */
+    unsigned char FAR *from;    /* where to copy match bytes from */
+    code here;                  /* current decoding table entry */
+    code last;                  /* parent table entry */
+    unsigned len;               /* length to copy for repeats, bits to drop */
+    int ret;                    /* return code */
+#ifdef GUNZIP
+    unsigned char hbuf[4];      /* buffer for gzip header crc calculation */
+#endif
+    static const unsigned short order[19] = /* permutation of code lengths */
+        {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+    if (inflateStateCheck(strm) || strm->next_out == Z_NULL ||
+        (strm->next_in == Z_NULL && strm->avail_in != 0))
+        return Z_STREAM_ERROR;
+
+    state = (struct inflate_state FAR *)strm->state;
+    if (state->mode == TYPE) state->mode = TYPEDO;      /* skip check */
+    LOAD();
+    in = have;
+    out = left;
+    ret = Z_OK;
+    for (;;)
+        switch (state->mode) {
+        case HEAD:
+            if (state->wrap == 0) {
+                state->mode = TYPEDO;
+                break;
+            }
+            NEEDBITS(16);
+#ifdef GUNZIP
+            if ((state->wrap & 2) && hold == 0x8b1f) {  /* gzip header */
+                if (state->wbits == 0)
+                    state->wbits = 15;
+                state->check = crc32(0L, Z_NULL, 0);
+                CRC2(state->check, hold);
+                INITBITS();
+                state->mode = FLAGS;
+                break;
+            }
+            state->flags = 0;           /* expect zlib header */
+            if (state->head != Z_NULL)
+                state->head->done = -1;
+            if (!(state->wrap & 1) ||   /* check if zlib header allowed */
+#else
+            if (
+#endif
+                ((BITS(8) << 8) + (hold >> 8)) % 31) {
+                strm->msg = (char *)"incorrect header check";
+                state->mode = BAD;
+                break;
+            }
+            if (BITS(4) != Z_DEFLATED) {
+                strm->msg = (char *)"unknown compression method";
+                state->mode = BAD;
+                break;
+            }
+            DROPBITS(4);
+            len = BITS(4) + 8;
+            if (state->wbits == 0)
+                state->wbits = len;
+            if (len > 15 || len > state->wbits) {
+                strm->msg = (char *)"invalid window size";
+                state->mode = BAD;
+                break;
+            }
+            state->dmax = 1U << len;
+            Tracev((stderr, "inflate:   zlib header ok\n"));
+            strm->adler = state->check = adler32(0L, Z_NULL, 0);
+            state->mode = hold & 0x200 ? DICTID : TYPE;
+            INITBITS();
+            break;
+#ifdef GUNZIP
+        case FLAGS:
+            NEEDBITS(16);
+            state->flags = (int)(hold);
+            if ((state->flags & 0xff) != Z_DEFLATED) {
+                strm->msg = (char *)"unknown compression method";
+                state->mode = BAD;
+                break;
+            }
+            if (state->flags & 0xe000) {
+                strm->msg = (char *)"unknown header flags set";
+                state->mode = BAD;
+                break;
+            }
+            if (state->head != Z_NULL)
+                state->head->text = (int)((hold >> 8) & 1);
+            if ((state->flags & 0x0200) && (state->wrap & 4))
+                CRC2(state->check, hold);
+            INITBITS();
+            state->mode = TIME;
+        case TIME:
+            NEEDBITS(32);
+            if (state->head != Z_NULL)
+                state->head->time = hold;
+            if ((state->flags & 0x0200) && (state->wrap & 4))
+                CRC4(state->check, hold);
+            INITBITS();
+            state->mode = OS;
+        case OS:
+            NEEDBITS(16);
+            if (state->head != Z_NULL) {
+                state->head->xflags = (int)(hold & 0xff);
+                state->head->os = (int)(hold >> 8);
+            }
+            if ((state->flags & 0x0200) && (state->wrap & 4))
+                CRC2(state->check, hold);
+            INITBITS();
+            state->mode = EXLEN;
+        case EXLEN:
+            if (state->flags & 0x0400) {
+                NEEDBITS(16);
+                state->length = (unsigned)(hold);
+                if (state->head != Z_NULL)
+                    state->head->extra_len = (unsigned)hold;
+                if ((state->flags & 0x0200) && (state->wrap & 4))
+                    CRC2(state->check, hold);
+                INITBITS();
+            }
+            else if (state->head != Z_NULL)
+                state->head->extra = Z_NULL;
+            state->mode = EXTRA;
+        case EXTRA:
+            if (state->flags & 0x0400) {
+                copy = state->length;
+                if (copy > have) copy = have;
+                if (copy) {
+                    if (state->head != Z_NULL &&
+                        state->head->extra != Z_NULL) {
+                        len = state->head->extra_len - state->length;
+                        zmemcpy(state->head->extra + len, next,
+                                len + copy > state->head->extra_max ?
+                                state->head->extra_max - len : copy);
+                    }
+                    if ((state->flags & 0x0200) && (state->wrap & 4))
+                        state->check = crc32(state->check, next, copy);
+                    have -= copy;
+                    next += copy;
+                    state->length -= copy;
+                }
+                if (state->length) goto inf_leave;
+            }
+            state->length = 0;
+            state->mode = NAME;
+        case NAME:
+            if (state->flags & 0x0800) {
+                if (have == 0) goto inf_leave;
+                copy = 0;
+                do {
+                    len = (unsigned)(next[copy++]);
+                    if (state->head != Z_NULL &&
+                            state->head->name != Z_NULL &&
+                            state->length < state->head->name_max)
+                        state->head->name[state->length++] = (Bytef)len;
+                } while (len && copy < have);
+                if ((state->flags & 0x0200) && (state->wrap & 4))
+                    state->check = crc32(state->check, next, copy);
+                have -= copy;
+                next += copy;
+                if (len) goto inf_leave;
+            }
+            else if (state->head != Z_NULL)
+                state->head->name = Z_NULL;
+            state->length = 0;
+            state->mode = COMMENT;
+        case COMMENT:
+            if (state->flags & 0x1000) {
+                if (have == 0) goto inf_leave;
+                copy = 0;
+                do {
+                    len = (unsigned)(next[copy++]);
+                    if (state->head != Z_NULL &&
+                            state->head->comment != Z_NULL &&
+                            state->length < state->head->comm_max)
+                        state->head->comment[state->length++] = (Bytef)len;
+                } while (len && copy < have);
+                if ((state->flags & 0x0200) && (state->wrap & 4))
+                    state->check = crc32(state->check, next, copy);
+                have -= copy;
+                next += copy;
+                if (len) goto inf_leave;
+            }
+            else if (state->head != Z_NULL)
+                state->head->comment = Z_NULL;
+            state->mode = HCRC;
+        case HCRC:
+            if (state->flags & 0x0200) {
+                NEEDBITS(16);
+                if ((state->wrap & 4) && hold != (state->check & 0xffff)) {
+                    strm->msg = (char *)"header crc mismatch";
+                    state->mode = BAD;
+                    break;
+                }
+                INITBITS();
+            }
+            if (state->head != Z_NULL) {
+                state->head->hcrc = (int)((state->flags >> 9) & 1);
+                state->head->done = 1;
+            }
+            strm->adler = state->check = crc32(0L, Z_NULL, 0);
+            state->mode = TYPE;
+            break;
+#endif
+        case DICTID:
+            NEEDBITS(32);
+            strm->adler = state->check = ZSWAP32(hold);
+            INITBITS();
+            state->mode = DICT;
+        case DICT:
+            if (state->havedict == 0) {
+                RESTORE();
+                return Z_NEED_DICT;
+            }
+            strm->adler = state->check = adler32(0L, Z_NULL, 0);
+            state->mode = TYPE;
+        case TYPE:
+            if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave;
+        case TYPEDO:
+            if (state->last) {
+                BYTEBITS();
+                state->mode = CHECK;
+                break;
+            }
+            NEEDBITS(3);
+            state->last = BITS(1);
+            DROPBITS(1);
+            switch (BITS(2)) {
+            case 0:                             /* stored block */
+                Tracev((stderr, "inflate:     stored block%s\n",
+                        state->last ? " (last)" : ""));
+                state->mode = STORED;
+                break;
+            case 1:                             /* fixed block */
+                fixedtables(state);
+                Tracev((stderr, "inflate:     fixed codes block%s\n",
+                        state->last ? " (last)" : ""));
+                state->mode = LEN_;             /* decode codes */
+                if (flush == Z_TREES) {
+                    DROPBITS(2);
+                    goto inf_leave;
+                }
+                break;
+            case 2:                             /* dynamic block */
+                Tracev((stderr, "inflate:     dynamic codes block%s\n",
+                        state->last ? " (last)" : ""));
+                state->mode = TABLE;
+                break;
+            case 3:
+                strm->msg = (char *)"invalid block type";
+                state->mode = BAD;
+            }
+            DROPBITS(2);
+            break;
+        case STORED:
+            BYTEBITS();                         /* go to byte boundary */
+            NEEDBITS(32);
+            if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
+                strm->msg = (char *)"invalid stored block lengths";
+                state->mode = BAD;
+                break;
+            }
+            state->length = (unsigned)hold & 0xffff;
+            Tracev((stderr, "inflate:       stored length %u\n",
+                    state->length));
+            INITBITS();
+            state->mode = COPY_;
+            if (flush == Z_TREES) goto inf_leave;
+        case COPY_:
+            state->mode = COPY;
+        case COPY:
+            copy = state->length;
+            if (copy) {
+                if (copy > have) copy = have;
+                if (copy > left) copy = left;
+                if (copy == 0) goto inf_leave;
+                zmemcpy(put, next, copy);
+                have -= copy;
+                next += copy;
+                left -= copy;
+                put += copy;
+                state->length -= copy;
+                break;
+            }
+            Tracev((stderr, "inflate:       stored end\n"));
+            state->mode = TYPE;
+            break;
+        case TABLE:
+            NEEDBITS(14);
+            state->nlen = BITS(5) + 257;
+            DROPBITS(5);
+            state->ndist = BITS(5) + 1;
+            DROPBITS(5);
+            state->ncode = BITS(4) + 4;
+            DROPBITS(4);
+#ifndef PKZIP_BUG_WORKAROUND
+            if (state->nlen > 286 || state->ndist > 30) {
+                strm->msg = (char *)"too many length or distance symbols";
+                state->mode = BAD;
+                break;
+            }
+#endif
+            Tracev((stderr, "inflate:       table sizes ok\n"));
+            state->have = 0;
+            state->mode = LENLENS;
+        case LENLENS:
+            while (state->have < state->ncode) {
+                NEEDBITS(3);
+                state->lens[order[state->have++]] = (unsigned short)BITS(3);
+                DROPBITS(3);
+            }
+            while (state->have < 19)
+                state->lens[order[state->have++]] = 0;
+            state->next = state->codes;
+            state->lencode = (const code FAR *)(state->next);
+            state->lenbits = 7;
+            ret = inflate_table(CODES, state->lens, 19, &(state->next),
+                                &(state->lenbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid code lengths set";
+                state->mode = BAD;
+                break;
+            }
+            Tracev((stderr, "inflate:       code lengths ok\n"));
+            state->have = 0;
+            state->mode = CODELENS;
+        case CODELENS:
+            while (state->have < state->nlen + state->ndist) {
+                for (;;) {
+                    here = state->lencode[BITS(state->lenbits)];
+                    if ((unsigned)(here.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                if (here.val < 16) {
+                    DROPBITS(here.bits);
+                    state->lens[state->have++] = here.val;
+                }
+                else {
+                    if (here.val == 16) {
+                        NEEDBITS(here.bits + 2);
+                        DROPBITS(here.bits);
+                        if (state->have == 0) {
+                            strm->msg = (char *)"invalid bit length repeat";
+                            state->mode = BAD;
+                            break;
+                        }
+                        len = state->lens[state->have - 1];
+                        copy = 3 + BITS(2);
+                        DROPBITS(2);
+                    }
+                    else if (here.val == 17) {
+                        NEEDBITS(here.bits + 3);
+                        DROPBITS(here.bits);
+                        len = 0;
+                        copy = 3 + BITS(3);
+                        DROPBITS(3);
+                    }
+                    else {
+                        NEEDBITS(here.bits + 7);
+                        DROPBITS(here.bits);
+                        len = 0;
+                        copy = 11 + BITS(7);
+                        DROPBITS(7);
+                    }
+                    if (state->have + copy > state->nlen + state->ndist) {
+                        strm->msg = (char *)"invalid bit length repeat";
+                        state->mode = BAD;
+                        break;
+                    }
+                    while (copy--)
+                        state->lens[state->have++] = (unsigned short)len;
+                }
+            }
+
+            /* handle error breaks in while */
+            if (state->mode == BAD) break;
+
+            /* check for end-of-block code (better have one) */
+            if (state->lens[256] == 0) {
+                strm->msg = (char *)"invalid code -- missing end-of-block";
+                state->mode = BAD;
+                break;
+            }
+
+            /* build code tables -- note: do not change the lenbits or distbits
+               values here (9 and 6) without reading the comments in inftrees.h
+               concerning the ENOUGH constants, which depend on those values */
+            state->next = state->codes;
+            state->lencode = (const code FAR *)(state->next);
+            state->lenbits = 9;
+            ret = inflate_table(LENS, state->lens, state->nlen, &(state->next),
+                                &(state->lenbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid literal/lengths set";
+                state->mode = BAD;
+                break;
+            }
+            state->distcode = (const code FAR *)(state->next);
+            state->distbits = 6;
+            ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist,
+                            &(state->next), &(state->distbits), state->work);
+            if (ret) {
+                strm->msg = (char *)"invalid distances set";
+                state->mode = BAD;
+                break;
+            }
+            Tracev((stderr, "inflate:       codes ok\n"));
+            state->mode = LEN_;
+            if (flush == Z_TREES) goto inf_leave;
+        case LEN_:
+            state->mode = LEN;
+        case LEN:
+            if (have >= 6 && left >= 258) {
+                RESTORE();
+                inflate_fast(strm, out);
+                LOAD();
+                if (state->mode == TYPE)
+                    state->back = -1;
+                break;
+            }
+            state->back = 0;
+            for (;;) {
+                here = state->lencode[BITS(state->lenbits)];
+                if ((unsigned)(here.bits) <= bits) break;
+                PULLBYTE();
+            }
+            if (here.op && (here.op & 0xf0) == 0) {
+                last = here;
+                for (;;) {
+                    here = state->lencode[last.val +
+                            (BITS(last.bits + last.op) >> last.bits)];
+                    if ((unsigned)(last.bits + here.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                DROPBITS(last.bits);
+                state->back += last.bits;
+            }
+            DROPBITS(here.bits);
+            state->back += here.bits;
+            state->length = (unsigned)here.val;
+            if ((int)(here.op) == 0) {
+                Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
+                        "inflate:         literal '%c'\n" :
+                        "inflate:         literal 0x%02x\n", here.val));
+                state->mode = LIT;
+                break;
+            }
+            if (here.op & 32) {
+                Tracevv((stderr, "inflate:         end of block\n"));
+                state->back = -1;
+                state->mode = TYPE;
+                break;
+            }
+            if (here.op & 64) {
+                strm->msg = (char *)"invalid literal/length code";
+                state->mode = BAD;
+                break;
+            }
+            state->extra = (unsigned)(here.op) & 15;
+            state->mode = LENEXT;
+        case LENEXT:
+            if (state->extra) {
+                NEEDBITS(state->extra);
+                state->length += BITS(state->extra);
+                DROPBITS(state->extra);
+                state->back += state->extra;
+            }
+            Tracevv((stderr, "inflate:         length %u\n", state->length));
+            state->was = state->length;
+            state->mode = DIST;
+        case DIST:
+            for (;;) {
+                here = state->distcode[BITS(state->distbits)];
+                if ((unsigned)(here.bits) <= bits) break;
+                PULLBYTE();
+            }
+            if ((here.op & 0xf0) == 0) {
+                last = here;
+                for (;;) {
+                    here = state->distcode[last.val +
+                            (BITS(last.bits + last.op) >> last.bits)];
+                    if ((unsigned)(last.bits + here.bits) <= bits) break;
+                    PULLBYTE();
+                }
+                DROPBITS(last.bits);
+                state->back += last.bits;
+            }
+            DROPBITS(here.bits);
+            state->back += here.bits;
+            if (here.op & 64) {
+                strm->msg = (char *)"invalid distance code";
+                state->mode = BAD;
+                break;
+            }
+            state->offset = (unsigned)here.val;
+            state->extra = (unsigned)(here.op) & 15;
+            state->mode = DISTEXT;
+        case DISTEXT:
+            if (state->extra) {
+                NEEDBITS(state->extra);
+                state->offset += BITS(state->extra);
+                DROPBITS(state->extra);
+                state->back += state->extra;
+            }
+#ifdef INFLATE_STRICT
+            if (state->offset > state->dmax) {
+                strm->msg = (char *)"invalid distance too far back";
+                state->mode = BAD;
+                break;
+            }
+#endif
+            Tracevv((stderr, "inflate:         distance %u\n", state->offset));
+            state->mode = MATCH;
+        case MATCH:
+            if (left == 0) goto inf_leave;
+            copy = out - left;
+            if (state->offset > copy) {         /* copy from window */
+                copy = state->offset - copy;
+                if (copy > state->whave) {
+                    if (state->sane) {
+                        strm->msg = (char *)"invalid distance too far back";
+                        state->mode = BAD;
+                        break;
+                    }
+#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+                    Trace((stderr, "inflate.c too far\n"));
+                    copy -= state->whave;
+                    if (copy > state->length) copy = state->length;
+                    if (copy > left) copy = left;
+                    left -= copy;
+                    state->length -= copy;
+                    do {
+                        *put++ = 0;
+                    } while (--copy);
+                    if (state->length == 0) state->mode = LEN;
+                    break;
+#endif
+                }
+                if (copy > state->wnext) {
+                    copy -= state->wnext;
+                    from = state->window + (state->wsize - copy);
+                }
+                else
+                    from = state->window + (state->wnext - copy);
+                if (copy > state->length) copy = state->length;
+            }
+            else {                              /* copy from output */
+                from = put - state->offset;
+                copy = state->length;
+            }
+            if (copy > left) copy = left;
+            left -= copy;
+            state->length -= copy;
+            do {
+                *put++ = *from++;
+            } while (--copy);
+            if (state->length == 0) state->mode = LEN;
+            break;
+        case LIT:
+            if (left == 0) goto inf_leave;
+            *put++ = (unsigned char)(state->length);
+            left--;
+            state->mode = LEN;
+            break;
+        case CHECK:
+            if (state->wrap) {
+                NEEDBITS(32);
+                out -= left;
+                strm->total_out += out;
+                state->total += out;
+                if ((state->wrap & 4) && out)
+                    strm->adler = state->check =
+                        UPDATE(state->check, put - out, out);
+                out = left;
+                if ((state->wrap & 4) && (
+#ifdef GUNZIP
+                     state->flags ? hold :
+#endif
+                     ZSWAP32(hold)) != state->check) {
+                    strm->msg = (char *)"incorrect data check";
+                    state->mode = BAD;
+                    break;
+                }
+                INITBITS();
+                Tracev((stderr, "inflate:   check matches trailer\n"));
+            }
+#ifdef GUNZIP
+            state->mode = LENGTH;
+        case LENGTH:
+            if (state->wrap && state->flags) {
+                NEEDBITS(32);
+                if (hold != (state->total & 0xffffffffUL)) {
+                    strm->msg = (char *)"incorrect length check";
+                    state->mode = BAD;
+                    break;
+                }
+                INITBITS();
+                Tracev((stderr, "inflate:   length matches trailer\n"));
+            }
+#endif
+            state->mode = DONE;
+        case DONE:
+            ret = Z_STREAM_END;
+            goto inf_leave;
+        case BAD:
+            ret = Z_DATA_ERROR;
+            goto inf_leave;
+        case MEM:
+            return Z_MEM_ERROR;
+        case SYNC:
+        default:
+            return Z_STREAM_ERROR;
+        }
+
+    /*
+       Return from inflate(), updating the total counts and the check value.
+       If there was no progress during the inflate() call, return a buffer
+       error.  Call updatewindow() to create and/or update the window state.
+       Note: a memory error from inflate() is non-recoverable.
+     */
+  inf_leave:
+    RESTORE();
+    if (state->wsize || (out != strm->avail_out && state->mode < BAD &&
+            (state->mode < CHECK || flush != Z_FINISH)))
+        if (updatewindow(strm, strm->next_out, out - strm->avail_out)) {
+            state->mode = MEM;
+            return Z_MEM_ERROR;
+        }
+    in -= strm->avail_in;
+    out -= strm->avail_out;
+    strm->total_in += in;
+    strm->total_out += out;
+    state->total += out;
+    if ((state->wrap & 4) && out)
+        strm->adler = state->check =
+            UPDATE(state->check, strm->next_out - out, out);
+    strm->data_type = (int)state->bits + (state->last ? 64 : 0) +
+                      (state->mode == TYPE ? 128 : 0) +
+                      (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0);
+    if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK)
+        ret = Z_BUF_ERROR;
+    return ret;
+}
+
+int ZEXPORT inflateEnd(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+    if (inflateStateCheck(strm))
+        return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if (state->window != Z_NULL) ZFREE(strm, state->window);
+    ZFREE(strm, strm->state);
+    strm->state = Z_NULL;
+    Tracev((stderr, "inflate: end\n"));
+    return Z_OK;
+}
+
+int ZEXPORT inflateGetDictionary(strm, dictionary, dictLength)
+z_streamp strm;
+Bytef *dictionary;
+uInt *dictLength;
+{
+    struct inflate_state FAR *state;
+
+    /* check state */
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+
+    /* copy dictionary */
+    if (state->whave && dictionary != Z_NULL) {
+        zmemcpy(dictionary, state->window + state->wnext,
+                state->whave - state->wnext);
+        zmemcpy(dictionary + state->whave - state->wnext,
+                state->window, state->wnext);
+    }
+    if (dictLength != Z_NULL)
+        *dictLength = state->whave;
+    return Z_OK;
+}
+
+int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
+z_streamp strm;
+const Bytef *dictionary;
+uInt dictLength;
+{
+    struct inflate_state FAR *state;
+    unsigned long dictid;
+    int ret;
+
+    /* check state */
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if (state->wrap != 0 && state->mode != DICT)
+        return Z_STREAM_ERROR;
+
+    /* check for correct dictionary identifier */
+    if (state->mode == DICT) {
+        dictid = adler32(0L, Z_NULL, 0);
+        dictid = adler32(dictid, dictionary, dictLength);
+        if (dictid != state->check)
+            return Z_DATA_ERROR;
+    }
+
+    /* copy dictionary to window using updatewindow(), which will amend the
+       existing dictionary if appropriate */
+    ret = updatewindow(strm, dictionary + dictLength, dictLength);
+    if (ret) {
+        state->mode = MEM;
+        return Z_MEM_ERROR;
+    }
+    state->havedict = 1;
+    Tracev((stderr, "inflate:   dictionary set\n"));
+    return Z_OK;
+}
+
+int ZEXPORT inflateGetHeader(strm, head)
+z_streamp strm;
+gz_headerp head;
+{
+    struct inflate_state FAR *state;
+
+    /* check state */
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;
+
+    /* save header structure */
+    state->head = head;
+    head->done = 0;
+    return Z_OK;
+}
+
+/*
+   Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff.  Return when found
+   or when out of input.  When called, *have is the number of pattern bytes
+   found in order so far, in 0..3.  On return *have is updated to the new
+   state.  If on return *have equals four, then the pattern was found and the
+   return value is how many bytes were read including the last byte of the
+   pattern.  If *have is less than four, then the pattern has not been found
+   yet and the return value is len.  In the latter case, syncsearch() can be
+   called again with more data and the *have state.  *have is initialized to
+   zero for the first call.
+ */
+local unsigned syncsearch(have, buf, len)
+unsigned FAR *have;
+const unsigned char FAR *buf;
+unsigned len;
+{
+    unsigned got;
+    unsigned next;
+
+    got = *have;
+    next = 0;
+    while (next < len && got < 4) {
+        if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
+            got++;
+        else if (buf[next])
+            got = 0;
+        else
+            got = 4 - got;
+        next++;
+    }
+    *have = got;
+    return next;
+}
+
+int ZEXPORT inflateSync(strm)
+z_streamp strm;
+{
+    unsigned len;               /* number of bytes to look at or looked at */
+    unsigned long in, out;      /* temporary to save total_in and total_out */
+    unsigned char buf[4];       /* to restore bit buffer to byte string */
+    struct inflate_state FAR *state;
+
+    /* check parameters */
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR;
+
+    /* if first time, start search in bit buffer */
+    if (state->mode != SYNC) {
+        state->mode = SYNC;
+        state->hold <<= state->bits & 7;
+        state->bits -= state->bits & 7;
+        len = 0;
+        while (state->bits >= 8) {
+            buf[len++] = (unsigned char)(state->hold);
+            state->hold >>= 8;
+            state->bits -= 8;
+        }
+        state->have = 0;
+        syncsearch(&(state->have), buf, len);
+    }
+
+    /* search available input */
+    len = syncsearch(&(state->have), strm->next_in, strm->avail_in);
+    strm->avail_in -= len;
+    strm->next_in += len;
+    strm->total_in += len;
+
+    /* return no joy or set up to restart inflate() on a new block */
+    if (state->have != 4) return Z_DATA_ERROR;
+    in = strm->total_in;  out = strm->total_out;
+    inflateReset(strm);
+    strm->total_in = in;  strm->total_out = out;
+    state->mode = TYPE;
+    return Z_OK;
+}
+
+/*
+   Returns true if inflate is currently at the end of a block generated by
+   Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP
+   implementation to provide an additional safety check. PPP uses
+   Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored
+   block. When decompressing, PPP checks that at the end of input packet,
+   inflate is waiting for these length bytes.
+ */
+int ZEXPORT inflateSyncPoint(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    return state->mode == STORED && state->bits == 0;
+}
+
+int ZEXPORT inflateCopy(dest, source)
+z_streamp dest;
+z_streamp source;
+{
+    struct inflate_state FAR *state;
+    struct inflate_state FAR *copy;
+    unsigned char FAR *window;
+    unsigned wsize;
+
+    /* check input */
+    if (inflateStateCheck(source) || dest == Z_NULL)
+        return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)source->state;
+
+    /* allocate space */
+    copy = (struct inflate_state FAR *)
+           ZALLOC(source, 1, sizeof(struct inflate_state));
+    if (copy == Z_NULL) return Z_MEM_ERROR;
+    window = Z_NULL;
+    if (state->window != Z_NULL) {
+        window = (unsigned char FAR *)
+                 ZALLOC(source, 1U << state->wbits, sizeof(unsigned char));
+        if (window == Z_NULL) {
+            ZFREE(source, copy);
+            return Z_MEM_ERROR;
+        }
+    }
+
+    /* copy state */
+    zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream));
+    zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state));
+    copy->strm = dest;
+    if (state->lencode >= state->codes &&
+        state->lencode <= state->codes + ENOUGH - 1) {
+        copy->lencode = copy->codes + (state->lencode - state->codes);
+        copy->distcode = copy->codes + (state->distcode - state->codes);
+    }
+    copy->next = copy->codes + (state->next - state->codes);
+    if (window != Z_NULL) {
+        wsize = 1U << state->wbits;
+        zmemcpy(window, state->window, wsize);
+    }
+    copy->window = window;
+    dest->state = (struct internal_state FAR *)copy;
+    return Z_OK;
+}
+
+int ZEXPORT inflateUndermine(strm, subvert)
+z_streamp strm;
+int subvert;
+{
+    struct inflate_state FAR *state;
+
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+    state->sane = !subvert;
+    return Z_OK;
+#else
+    (void)subvert;
+    state->sane = 1;
+    return Z_DATA_ERROR;
+#endif
+}
+
+int ZEXPORT inflateValidate(strm, check)
+z_streamp strm;
+int check;
+{
+    struct inflate_state FAR *state;
+
+    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+    state = (struct inflate_state FAR *)strm->state;
+    if (check)
+        state->wrap |= 4;
+    else
+        state->wrap &= ~4;
+    return Z_OK;
+}
+
+long ZEXPORT inflateMark(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+
+    if (inflateStateCheck(strm))
+        return -(1L << 16);
+    state = (struct inflate_state FAR *)strm->state;
+    return (long)(((unsigned long)((long)state->back)) << 16) +
+        (state->mode == COPY ? state->length :
+            (state->mode == MATCH ? state->was - state->length : 0));
+}
+
+unsigned long ZEXPORT inflateCodesUsed(strm)
+z_streamp strm;
+{
+    struct inflate_state FAR *state;
+    if (inflateStateCheck(strm)) return (unsigned long)-1;
+    state = (struct inflate_state FAR *)strm->state;
+    return (unsigned long)(state->next - state->codes);
+}
diff --git a/base/poco/Foundation/src/inflate.h b/base/poco/Foundation/src/inflate.h
new file mode 100644
index 00000000000..a46cce6b6d0
--- /dev/null
+++ b/base/poco/Foundation/src/inflate.h
@@ -0,0 +1,125 @@
+/* inflate.h -- internal inflate state definition
+ * Copyright (C) 1995-2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* define NO_GZIP when compiling if you want to disable gzip header and
+   trailer decoding by inflate().  NO_GZIP would be used to avoid linking in
+   the crc code when it is not needed.  For shared libraries, gzip decoding
+   should be left enabled. */
+#ifndef NO_GZIP
+#  define GUNZIP
+#endif
+
+/* Possible inflate modes between inflate() calls */
+typedef enum {
+    HEAD = 16180,   /* i: waiting for magic header */
+    FLAGS,      /* i: waiting for method and flags (gzip) */
+    TIME,       /* i: waiting for modification time (gzip) */
+    OS,         /* i: waiting for extra flags and operating system (gzip) */
+    EXLEN,      /* i: waiting for extra length (gzip) */
+    EXTRA,      /* i: waiting for extra bytes (gzip) */
+    NAME,       /* i: waiting for end of file name (gzip) */
+    COMMENT,    /* i: waiting for end of comment (gzip) */
+    HCRC,       /* i: waiting for header crc (gzip) */
+    DICTID,     /* i: waiting for dictionary check value */
+    DICT,       /* waiting for inflateSetDictionary() call */
+        TYPE,       /* i: waiting for type bits, including last-flag bit */
+        TYPEDO,     /* i: same, but skip check to exit inflate on new block */
+        STORED,     /* i: waiting for stored size (length and complement) */
+        COPY_,      /* i/o: same as COPY below, but only first time in */
+        COPY,       /* i/o: waiting for input or output to copy stored block */
+        TABLE,      /* i: waiting for dynamic block table lengths */
+        LENLENS,    /* i: waiting for code length code lengths */
+        CODELENS,   /* i: waiting for length/lit and distance code lengths */
+            LEN_,       /* i: same as LEN below, but only first time in */
+            LEN,        /* i: waiting for length/lit/eob code */
+            LENEXT,     /* i: waiting for length extra bits */
+            DIST,       /* i: waiting for distance code */
+            DISTEXT,    /* i: waiting for distance extra bits */
+            MATCH,      /* o: waiting for output space to copy string */
+            LIT,        /* o: waiting for output space to write literal */
+    CHECK,      /* i: waiting for 32-bit check value */
+    LENGTH,     /* i: waiting for 32-bit length (gzip) */
+    DONE,       /* finished check, done -- remain here until reset */
+    BAD,        /* got a data error -- remain here until reset */
+    MEM,        /* got an inflate() memory error -- remain here until reset */
+    SYNC        /* looking for synchronization bytes to restart inflate() */
+} inflate_mode;
+
+/*
+    State transitions between above modes -
+
+    (most modes can go to BAD or MEM on error -- not shown for clarity)
+
+    Process header:
+        HEAD -> (gzip) or (zlib) or (raw)
+        (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT ->
+                  HCRC -> TYPE
+        (zlib) -> DICTID or TYPE
+        DICTID -> DICT -> TYPE
+        (raw) -> TYPEDO
+    Read deflate blocks:
+            TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK
+            STORED -> COPY_ -> COPY -> TYPE
+            TABLE -> LENLENS -> CODELENS -> LEN_
+            LEN_ -> LEN
+    Read deflate codes in fixed or dynamic block:
+                LEN -> LENEXT or LIT or TYPE
+                LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
+                LIT -> LEN
+    Process trailer:
+        CHECK -> LENGTH -> DONE
+ */
+
+/* State maintained between inflate() calls -- approximately 7K bytes, not
+   including the allocated sliding window, which is up to 32K bytes. */
+struct inflate_state {
+    z_streamp strm;             /* pointer back to this zlib stream */
+    inflate_mode mode;          /* current inflate mode */
+    int last;                   /* true if processing last block */
+    int wrap;                   /* bit 0 true for zlib, bit 1 true for gzip,
+                                   bit 2 true to validate check value */
+    int havedict;               /* true if dictionary provided */
+    int flags;                  /* gzip header method and flags (0 if zlib) */
+    unsigned dmax;              /* zlib header max distance (INFLATE_STRICT) */
+    unsigned long check;        /* protected copy of check value */
+    unsigned long total;        /* protected copy of output count */
+    gz_headerp head;            /* where to save gzip header information */
+        /* sliding window */
+    unsigned wbits;             /* log base 2 of requested window size */
+    unsigned wsize;             /* window size or zero if not using window */
+    unsigned whave;             /* valid bytes in the window */
+    unsigned wnext;             /* window write index */
+    unsigned char FAR *window;  /* allocated sliding window, if needed */
+        /* bit accumulator */
+    unsigned long hold;         /* input bit accumulator */
+    unsigned bits;              /* number of bits in "in" */
+        /* for string and stored block copying */
+    unsigned length;            /* literal or length of data to copy */
+    unsigned offset;            /* distance back to copy string from */
+        /* for table and code decoding */
+    unsigned extra;             /* extra bits needed */
+        /* fixed and dynamic code tables */
+    code const FAR *lencode;    /* starting table for length/literal codes */
+    code const FAR *distcode;   /* starting table for distance codes */
+    unsigned lenbits;           /* index bits for lencode */
+    unsigned distbits;          /* index bits for distcode */
+        /* dynamic table building */
+    unsigned ncode;             /* number of code length code lengths */
+    unsigned nlen;              /* number of length code lengths */
+    unsigned ndist;             /* number of distance code lengths */
+    unsigned have;              /* number of code lengths in lens[] */
+    code FAR *next;             /* next available space in codes[] */
+    unsigned short lens[320];   /* temporary storage for code lengths */
+    unsigned short work[288];   /* work area for code table building */
+    code codes[ENOUGH];         /* space for code tables */
+    int sane;                   /* if false, allow invalid distance too far */
+    int back;                   /* bits back of last unprocessed length/lit */
+    unsigned was;               /* initial length of match */
+};
diff --git a/base/poco/Foundation/src/inftrees.c b/base/poco/Foundation/src/inftrees.c
new file mode 100644
index 00000000000..2ea08fc13ea
--- /dev/null
+++ b/base/poco/Foundation/src/inftrees.c
@@ -0,0 +1,304 @@
+/* inftrees.c -- generate Huffman trees for efficient decoding
+ * Copyright (C) 1995-2017 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+
+#define MAXBITS 15
+
+const char inflate_copyright[] =
+   " inflate 1.2.11 Copyright 1995-2017 Mark Adler ";
+/*
+  If you use the zlib library in a product, an acknowledgment is welcome
+  in the documentation of your product. If for some reason you cannot
+  include such an acknowledgment, I would appreciate that you keep this
+  copyright string in the executable of your product.
+ */
+
+/*
+   Build a set of tables to decode the provided canonical Huffman code.
+   The code lengths are lens[0..codes-1].  The result starts at *table,
+   whose indices are 0..2^bits-1.  work is a writable array of at least
+   lens shorts, which is used as a work area.  type is the type of code
+   to be generated, CODES, LENS, or DISTS.  On return, zero is success,
+   -1 is an invalid code, and +1 means that ENOUGH isn't enough.  table
+   on return points to the next available entry's address.  bits is the
+   requested root table index bits, and on return it is the actual root
+   table index bits.  It will differ if the request is greater than the
+   longest code or if it is less than the shortest code.
+ */
+int ZLIB_INTERNAL inflate_table(type, lens, codes, table, bits, work)
+codetype type;
+unsigned short FAR *lens;
+unsigned codes;
+code FAR * FAR *table;
+unsigned FAR *bits;
+unsigned short FAR *work;
+{
+    unsigned len;               /* a code's length in bits */
+    unsigned sym;               /* index of code symbols */
+    unsigned min, max;          /* minimum and maximum code lengths */
+    unsigned root;              /* number of index bits for root table */
+    unsigned curr;              /* number of index bits for current table */
+    unsigned drop;              /* code bits to drop for sub-table */
+    int left;                   /* number of prefix codes available */
+    unsigned used;              /* code entries in table used */
+    unsigned huff;              /* Huffman code */
+    unsigned incr;              /* for incrementing code, index */
+    unsigned fill;              /* index for replicating entries */
+    unsigned low;               /* low bits for current root entry */
+    unsigned mask;              /* mask for low root bits */
+    code here;                  /* table entry for duplication */
+    code FAR *next;             /* next available space in table */
+    const unsigned short FAR *base;     /* base value table to use */
+    const unsigned short FAR *extra;    /* extra bits table to use */
+    unsigned match;             /* use base and extra for symbol >= match */
+    unsigned short count[MAXBITS+1];    /* number of codes of each length */
+    unsigned short offs[MAXBITS+1];     /* offsets in table for each length */
+    static const unsigned short lbase[31] = { /* Length codes 257..285 base */
+        3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
+        35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
+    static const unsigned short lext[31] = { /* Length codes 257..285 extra */
+        16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18,
+        19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 77, 202};
+    static const unsigned short dbase[32] = { /* Distance codes 0..29 base */
+        1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
+        257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
+        8193, 12289, 16385, 24577, 0, 0};
+    static const unsigned short dext[32] = { /* Distance codes 0..29 extra */
+        16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22,
+        23, 23, 24, 24, 25, 25, 26, 26, 27, 27,
+        28, 28, 29, 29, 64, 64};
+
+    /*
+       Process a set of code lengths to create a canonical Huffman code.  The
+       code lengths are lens[0..codes-1].  Each length corresponds to the
+       symbols 0..codes-1.  The Huffman code is generated by first sorting the
+       symbols by length from short to long, and retaining the symbol order
+       for codes with equal lengths.  Then the code starts with all zero bits
+       for the first code of the shortest length, and the codes are integer
+       increments for the same length, and zeros are appended as the length
+       increases.  For the deflate format, these bits are stored backwards
+       from their more natural integer increment ordering, and so when the
+       decoding tables are built in the large loop below, the integer codes
+       are incremented backwards.
+
+       This routine assumes, but does not check, that all of the entries in
+       lens[] are in the range 0..MAXBITS.  The caller must assure this.
+       1..MAXBITS is interpreted as that code length.  zero means that that
+       symbol does not occur in this code.
+
+       The codes are sorted by computing a count of codes for each length,
+       creating from that a table of starting indices for each length in the
+       sorted table, and then entering the symbols in order in the sorted
+       table.  The sorted table is work[], with that space being provided by
+       the caller.
+
+       The length counts are used for other purposes as well, i.e. finding
+       the minimum and maximum length codes, determining if there are any
+       codes at all, checking for a valid set of lengths, and looking ahead
+       at length counts to determine sub-table sizes when building the
+       decoding tables.
+     */
+
+    /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
+    for (len = 0; len <= MAXBITS; len++)
+        count[len] = 0;
+    for (sym = 0; sym < codes; sym++)
+        count[lens[sym]]++;
+
+    /* bound code lengths, force root to be within code lengths */
+    root = *bits;
+    for (max = MAXBITS; max >= 1; max--)
+        if (count[max] != 0) break;
+    if (root > max) root = max;
+    if (max == 0) {                     /* no symbols to code at all */
+        here.op = (unsigned char)64;    /* invalid code marker */
+        here.bits = (unsigned char)1;
+        here.val = (unsigned short)0;
+        *(*table)++ = here;             /* make a table to force an error */
+        *(*table)++ = here;
+        *bits = 1;
+        return 0;     /* no symbols, but wait for decoding to report error */
+    }
+    for (min = 1; min < max; min++)
+        if (count[min] != 0) break;
+    if (root < min) root = min;
+
+    /* check for an over-subscribed or incomplete set of lengths */
+    left = 1;
+    for (len = 1; len <= MAXBITS; len++) {
+        left <<= 1;
+        left -= count[len];
+        if (left < 0) return -1;        /* over-subscribed */
+    }
+    if (left > 0 && (type == CODES || max != 1))
+        return -1;                      /* incomplete set */
+
+    /* generate offsets into symbol table for each length for sorting */
+    offs[1] = 0;
+    for (len = 1; len < MAXBITS; len++)
+        offs[len + 1] = offs[len] + count[len];
+
+    /* sort symbols by length, by symbol order within each length */
+    for (sym = 0; sym < codes; sym++)
+        if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
+
+    /*
+       Create and fill in decoding tables.  In this loop, the table being
+       filled is at next and has curr index bits.  The code being used is huff
+       with length len.  That code is converted to an index by dropping drop
+       bits off of the bottom.  For codes where len is less than drop + curr,
+       those top drop + curr - len bits are incremented through all values to
+       fill the table with replicated entries.
+
+       root is the number of index bits for the root table.  When len exceeds
+       root, sub-tables are created pointed to by the root entry with an index
+       of the low root bits of huff.  This is saved in low to check for when a
+       new sub-table should be started.  drop is zero when the root table is
+       being filled, and drop is root when sub-tables are being filled.
+
+       When a new sub-table is needed, it is necessary to look ahead in the
+       code lengths to determine what size sub-table is needed.  The length
+       counts are used for this, and so count[] is decremented as codes are
+       entered in the tables.
+
+       used keeps track of how many table entries have been allocated from the
+       provided *table space.  It is checked for LENS and DIST tables against
+       the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in
+       the initial root table size constants.  See the comments in inftrees.h
+       for more information.
+
+       sym increments through all symbols, and the loop terminates when
+       all codes of length max, i.e. all codes, have been processed.  This
+       routine permits incomplete codes, so another loop after this one fills
+       in the rest of the decoding tables with invalid code markers.
+     */
+
+    /* set up for code type */
+    switch (type) {
+    case CODES:
+        base = extra = work;    /* dummy value--not used */
+        match = 20;
+        break;
+    case LENS:
+        base = lbase;
+        extra = lext;
+        match = 257;
+        break;
+    default:    /* DISTS */
+        base = dbase;
+        extra = dext;
+        match = 0;
+    }
+
+    /* initialize state for loop */
+    huff = 0;                   /* starting code */
+    sym = 0;                    /* starting code symbol */
+    len = min;                  /* starting code length */
+    next = *table;              /* current table to fill in */
+    curr = root;                /* current table index bits */
+    drop = 0;                   /* current bits to drop from code for index */
+    low = (unsigned)(-1);       /* trigger new sub-table when len > root */
+    used = 1U << root;          /* use root table entries */
+    mask = used - 1;            /* mask for comparing low */
+
+    /* check available table space */
+    if ((type == LENS && used > ENOUGH_LENS) ||
+        (type == DISTS && used > ENOUGH_DISTS))
+        return 1;
+
+    /* process all codes and make table entries */
+    for (;;) {
+        /* create table entry */
+        here.bits = (unsigned char)(len - drop);
+        if (work[sym] + 1U < match) {
+            here.op = (unsigned char)0;
+            here.val = work[sym];
+        }
+        else if (work[sym] >= match) {
+            here.op = (unsigned char)(extra[work[sym] - match]);
+            here.val = base[work[sym] - match];
+        }
+        else {
+            here.op = (unsigned char)(32 + 64);         /* end of block */
+            here.val = 0;
+        }
+
+        /* replicate for those indices with low len bits equal to huff */
+        incr = 1U << (len - drop);
+        fill = 1U << curr;
+        min = fill;                 /* save offset to next table */
+        do {
+            fill -= incr;
+            next[(huff >> drop) + fill] = here;
+        } while (fill != 0);
+
+        /* backwards increment the len-bit code huff */
+        incr = 1U << (len - 1);
+        while (huff & incr)
+            incr >>= 1;
+        if (incr != 0) {
+            huff &= incr - 1;
+            huff += incr;
+        }
+        else
+            huff = 0;
+
+        /* go to next symbol, update count, len */
+        sym++;
+        if (--(count[len]) == 0) {
+            if (len == max) break;
+            len = lens[work[sym]];
+        }
+
+        /* create new sub-table if needed */
+        if (len > root && (huff & mask) != low) {
+            /* if first time, transition to sub-tables */
+            if (drop == 0)
+                drop = root;
+
+            /* increment past last table */
+            next += min;            /* here min is 1 << curr */
+
+            /* determine length of next table */
+            curr = len - drop;
+            left = (int)(1 << curr);
+            while (curr + drop < max) {
+                left -= count[curr + drop];
+                if (left <= 0) break;
+                curr++;
+                left <<= 1;
+            }
+
+            /* check for enough space */
+            used += 1U << curr;
+            if ((type == LENS && used > ENOUGH_LENS) ||
+                (type == DISTS && used > ENOUGH_DISTS))
+                return 1;
+
+            /* point entry in root table to sub-table */
+            low = huff & mask;
+            (*table)[low].op = (unsigned char)curr;
+            (*table)[low].bits = (unsigned char)root;
+            (*table)[low].val = (unsigned short)(next - *table);
+        }
+    }
+
+    /* fill in remaining table entry if code is incomplete (guaranteed to have
+       at most one remaining entry, since if the code is incomplete, the
+       maximum code length that was allowed to get this far is one bit) */
+    if (huff != 0) {
+        here.op = (unsigned char)64;            /* invalid code marker */
+        here.bits = (unsigned char)(len - drop);
+        here.val = (unsigned short)0;
+        next[huff] = here;
+    }
+
+    /* set return parameters */
+    *table += used;
+    *bits = root;
+    return 0;
+}
diff --git a/base/poco/Foundation/src/inftrees.h b/base/poco/Foundation/src/inftrees.h
new file mode 100644
index 00000000000..baa53a0b1a1
--- /dev/null
+++ b/base/poco/Foundation/src/inftrees.h
@@ -0,0 +1,62 @@
+/* inftrees.h -- header to use inftrees.c
+ * Copyright (C) 1995-2005, 2010 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* Structure for decoding tables.  Each entry provides either the
+   information needed to do the operation requested by the code that
+   indexed that table entry, or it provides a pointer to another
+   table that indexes more bits of the code.  op indicates whether
+   the entry is a pointer to another table, a literal, a length or
+   distance, an end-of-block, or an invalid code.  For a table
+   pointer, the low four bits of op is the number of index bits of
+   that table.  For a length or distance, the low four bits of op
+   is the number of extra bits to get after the code.  bits is
+   the number of bits in this code or part of the code to drop off
+   of the bit buffer.  val is the actual byte to output in the case
+   of a literal, the base length or distance, or the offset from
+   the current table to the next table.  Each entry is four bytes. */
+typedef struct {
+    unsigned char op;           /* operation, extra bits, table bits */
+    unsigned char bits;         /* bits in this part of the code */
+    unsigned short val;         /* offset in table or code value */
+} code;
+
+/* op values as set by inflate_table():
+    00000000 - literal
+    0000tttt - table link, tttt != 0 is the number of table index bits
+    0001eeee - length or distance, eeee is the number of extra bits
+    01100000 - end of block
+    01000000 - invalid code
+ */
+
+/* Maximum size of the dynamic table.  The maximum number of code structures is
+   1444, which is the sum of 852 for literal/length codes and 592 for distance
+   codes.  These values were found by exhaustive searches using the program
+   examples/enough.c found in the zlib distribtution.  The arguments to that
+   program are the number of symbols, the initial root table size, and the
+   maximum bit length of a code.  "enough 286 9 15" for literal/length codes
+   returns returns 852, and "enough 30 6 15" for distance codes returns 592.
+   The initial root table size (9 or 6) is found in the fifth argument of the
+   inflate_table() calls in inflate.c and infback.c.  If the root table size is
+   changed, then these maximum sizes would be need to be recalculated and
+   updated. */
+#define ENOUGH_LENS 852
+#define ENOUGH_DISTS 592
+#define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS)
+
+/* Type of code to build for inflate_table() */
+typedef enum {
+    CODES,
+    LENS,
+    DISTS
+} codetype;
+
+int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens,
+                             unsigned codes, code FAR * FAR *table,
+                             unsigned FAR *bits, unsigned short FAR *work));
diff --git a/base/poco/Foundation/src/pcre.h b/base/poco/Foundation/src/pcre.h
new file mode 100644
index 00000000000..c92cf6a0831
--- /dev/null
+++ b/base/poco/Foundation/src/pcre.h
@@ -0,0 +1,677 @@
+/*************************************************
+*       Perl-Compatible Regular Expressions      *
+*************************************************/
+
+/* This is the public header file for the PCRE library, to be #included by
+applications that call the PCRE functions.
+
+           Copyright (c) 1997-2014 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+#ifndef _PCRE_H
+#define _PCRE_H
+
+/* The current PCRE version information. */
+
+#define PCRE_MAJOR          8
+#define PCRE_MINOR          43
+#define PCRE_PRERELEASE
+#define PCRE_DATE           2019-02-23
+
+/* When an application links to a PCRE DLL in Windows, the symbols that are
+imported have to be identified as such. When building PCRE, the appropriate
+export setting is defined in pcre_internal.h, which includes this file. So we
+don't change existing definitions of PCRE_EXP_DECL and PCRECPP_EXP_DECL. */
+
+#if defined(_WIN32) && !defined(PCRE_STATIC)
+#  ifndef PCRE_EXP_DECL
+#    define PCRE_EXP_DECL  extern __declspec(dllimport)
+#  endif
+#  ifdef __cplusplus
+#    ifndef PCRECPP_EXP_DECL
+#      define PCRECPP_EXP_DECL  extern __declspec(dllimport)
+#    endif
+#    ifndef PCRECPP_EXP_DEFN
+#      define PCRECPP_EXP_DEFN  __declspec(dllimport)
+#    endif
+#  endif
+#endif
+
+/* By default, we use the standard "extern" declarations. */
+
+#ifndef PCRE_EXP_DECL
+#  ifdef __cplusplus
+#    define PCRE_EXP_DECL  extern "C"
+#  else
+#    define PCRE_EXP_DECL  extern
+#  endif
+#endif
+
+#ifdef __cplusplus
+#  ifndef PCRECPP_EXP_DECL
+#    define PCRECPP_EXP_DECL  extern
+#  endif
+#  ifndef PCRECPP_EXP_DEFN
+#    define PCRECPP_EXP_DEFN
+#  endif
+#endif
+
+/* Have to include stdlib.h in order to ensure that size_t is defined;
+it is needed here for malloc. */
+
+#include <stdlib.h>
+
+/* Allow for C++ users */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Public options. Some are compile-time only, some are run-time only, and some
+are both. Most of the compile-time options are saved with the compiled regex so
+that they can be inspected during studying (and therefore JIT compiling). Note
+that pcre_study() has its own set of options. Originally, all the options
+defined here used distinct bits. However, almost all the bits in a 32-bit word
+are now used, so in order to conserve them, option bits that were previously
+only recognized at matching time (i.e. by pcre_exec() or pcre_dfa_exec()) may
+also be used for compile-time options that affect only compiling and are not
+relevant for studying or JIT compiling.
+
+Some options for pcre_compile() change its behaviour but do not affect the
+behaviour of the execution functions. Other options are passed through to the
+execution functions and affect their behaviour, with or without affecting the
+behaviour of pcre_compile().
+
+Options that can be passed to pcre_compile() are tagged Cx below, with these
+variants:
+
+C1   Affects compile only
+C2   Does not affect compile; affects exec, dfa_exec
+C3   Affects compile, exec, dfa_exec
+C4   Affects compile, exec, dfa_exec, study
+C5   Affects compile, exec, study
+
+Options that can be set for pcre_exec() and/or pcre_dfa_exec() are flagged with
+E and D, respectively. They take precedence over C3, C4, and C5 settings passed
+from pcre_compile(). Those that are compatible with JIT execution are flagged
+with J. */
+
+#define PCRE_CASELESS           0x00000001  /* C1       */
+#define PCRE_MULTILINE          0x00000002  /* C1       */
+#define PCRE_DOTALL             0x00000004  /* C1       */
+#define PCRE_EXTENDED           0x00000008  /* C1       */
+#define PCRE_ANCHORED           0x00000010  /* C4 E D   */
+#define PCRE_DOLLAR_ENDONLY     0x00000020  /* C2       */
+#define PCRE_EXTRA              0x00000040  /* C1       */
+#define PCRE_NOTBOL             0x00000080  /*    E D J */
+#define PCRE_NOTEOL             0x00000100  /*    E D J */
+#define PCRE_UNGREEDY           0x00000200  /* C1       */
+#define PCRE_NOTEMPTY           0x00000400  /*    E D J */
+#define PCRE_UTF8               0x00000800  /* C4        )          */
+#define PCRE_UTF16              0x00000800  /* C4        ) Synonyms */
+#define PCRE_UTF32              0x00000800  /* C4        )          */
+#define PCRE_NO_AUTO_CAPTURE    0x00001000  /* C1       */
+#define PCRE_NO_UTF8_CHECK      0x00002000  /* C1 E D J  )          */
+#define PCRE_NO_UTF16_CHECK     0x00002000  /* C1 E D J  ) Synonyms */
+#define PCRE_NO_UTF32_CHECK     0x00002000  /* C1 E D J  )          */
+#define PCRE_AUTO_CALLOUT       0x00004000  /* C1       */
+#define PCRE_PARTIAL_SOFT       0x00008000  /*    E D J  ) Synonyms */
+#define PCRE_PARTIAL            0x00008000  /*    E D J  )          */
+
+/* This pair use the same bit. */
+#define PCRE_NEVER_UTF          0x00010000  /* C1        ) Overlaid */
+#define PCRE_DFA_SHORTEST       0x00010000  /*      D    ) Overlaid */
+
+/* This pair use the same bit. */
+#define PCRE_NO_AUTO_POSSESS    0x00020000  /* C1        ) Overlaid */
+#define PCRE_DFA_RESTART        0x00020000  /*      D    ) Overlaid */
+
+#define PCRE_FIRSTLINE          0x00040000  /* C3       */
+#define PCRE_DUPNAMES           0x00080000  /* C1       */
+#define PCRE_NEWLINE_CR         0x00100000  /* C3 E D   */
+#define PCRE_NEWLINE_LF         0x00200000  /* C3 E D   */
+#define PCRE_NEWLINE_CRLF       0x00300000  /* C3 E D   */
+#define PCRE_NEWLINE_ANY        0x00400000  /* C3 E D   */
+#define PCRE_NEWLINE_ANYCRLF    0x00500000  /* C3 E D   */
+#define PCRE_BSR_ANYCRLF        0x00800000  /* C3 E D   */
+#define PCRE_BSR_UNICODE        0x01000000  /* C3 E D   */
+#define PCRE_JAVASCRIPT_COMPAT  0x02000000  /* C5       */
+#define PCRE_NO_START_OPTIMIZE  0x04000000  /* C2 E D    ) Synonyms */
+#define PCRE_NO_START_OPTIMISE  0x04000000  /* C2 E D    )          */
+#define PCRE_PARTIAL_HARD       0x08000000  /*    E D J */
+#define PCRE_NOTEMPTY_ATSTART   0x10000000  /*    E D J */
+#define PCRE_UCP                0x20000000  /* C3       */
+
+/* Exec-time and get/set-time error codes */
+
+#define PCRE_ERROR_NOMATCH          (-1)
+#define PCRE_ERROR_NULL             (-2)
+#define PCRE_ERROR_BADOPTION        (-3)
+#define PCRE_ERROR_BADMAGIC         (-4)
+#define PCRE_ERROR_UNKNOWN_OPCODE   (-5)
+#define PCRE_ERROR_UNKNOWN_NODE     (-5)  /* For backward compatibility */
+#define PCRE_ERROR_NOMEMORY         (-6)
+#define PCRE_ERROR_NOSUBSTRING      (-7)
+#define PCRE_ERROR_MATCHLIMIT       (-8)
+#define PCRE_ERROR_CALLOUT          (-9)  /* Never used by PCRE itself */
+#define PCRE_ERROR_BADUTF8         (-10)  /* Same for 8/16/32 */
+#define PCRE_ERROR_BADUTF16        (-10)  /* Same for 8/16/32 */
+#define PCRE_ERROR_BADUTF32        (-10)  /* Same for 8/16/32 */
+#define PCRE_ERROR_BADUTF8_OFFSET  (-11)  /* Same for 8/16 */
+#define PCRE_ERROR_BADUTF16_OFFSET (-11)  /* Same for 8/16 */
+#define PCRE_ERROR_PARTIAL         (-12)
+#define PCRE_ERROR_BADPARTIAL      (-13)
+#define PCRE_ERROR_INTERNAL        (-14)
+#define PCRE_ERROR_BADCOUNT        (-15)
+#define PCRE_ERROR_DFA_UITEM       (-16)
+#define PCRE_ERROR_DFA_UCOND       (-17)
+#define PCRE_ERROR_DFA_UMLIMIT     (-18)
+#define PCRE_ERROR_DFA_WSSIZE      (-19)
+#define PCRE_ERROR_DFA_RECURSE     (-20)
+#define PCRE_ERROR_RECURSIONLIMIT  (-21)
+#define PCRE_ERROR_NULLWSLIMIT     (-22)  /* No longer actually used */
+#define PCRE_ERROR_BADNEWLINE      (-23)
+#define PCRE_ERROR_BADOFFSET       (-24)
+#define PCRE_ERROR_SHORTUTF8       (-25)
+#define PCRE_ERROR_SHORTUTF16      (-25)  /* Same for 8/16 */
+#define PCRE_ERROR_RECURSELOOP     (-26)
+#define PCRE_ERROR_JIT_STACKLIMIT  (-27)
+#define PCRE_ERROR_BADMODE         (-28)
+#define PCRE_ERROR_BADENDIANNESS   (-29)
+#define PCRE_ERROR_DFA_BADRESTART  (-30)
+#define PCRE_ERROR_JIT_BADOPTION   (-31)
+#define PCRE_ERROR_BADLENGTH       (-32)
+#define PCRE_ERROR_UNSET           (-33)
+
+/* Specific error codes for UTF-8 validity checks */
+
+#define PCRE_UTF8_ERR0               0
+#define PCRE_UTF8_ERR1               1
+#define PCRE_UTF8_ERR2               2
+#define PCRE_UTF8_ERR3               3
+#define PCRE_UTF8_ERR4               4
+#define PCRE_UTF8_ERR5               5
+#define PCRE_UTF8_ERR6               6
+#define PCRE_UTF8_ERR7               7
+#define PCRE_UTF8_ERR8               8
+#define PCRE_UTF8_ERR9               9
+#define PCRE_UTF8_ERR10             10
+#define PCRE_UTF8_ERR11             11
+#define PCRE_UTF8_ERR12             12
+#define PCRE_UTF8_ERR13             13
+#define PCRE_UTF8_ERR14             14
+#define PCRE_UTF8_ERR15             15
+#define PCRE_UTF8_ERR16             16
+#define PCRE_UTF8_ERR17             17
+#define PCRE_UTF8_ERR18             18
+#define PCRE_UTF8_ERR19             19
+#define PCRE_UTF8_ERR20             20
+#define PCRE_UTF8_ERR21             21
+#define PCRE_UTF8_ERR22             22  /* Unused (was non-character) */
+
+/* Specific error codes for UTF-16 validity checks */
+
+#define PCRE_UTF16_ERR0              0
+#define PCRE_UTF16_ERR1              1
+#define PCRE_UTF16_ERR2              2
+#define PCRE_UTF16_ERR3              3
+#define PCRE_UTF16_ERR4              4  /* Unused (was non-character) */
+
+/* Specific error codes for UTF-32 validity checks */
+
+#define PCRE_UTF32_ERR0              0
+#define PCRE_UTF32_ERR1              1
+#define PCRE_UTF32_ERR2              2  /* Unused (was non-character) */
+#define PCRE_UTF32_ERR3              3
+
+/* Request types for pcre_fullinfo() */
+
+#define PCRE_INFO_OPTIONS            0
+#define PCRE_INFO_SIZE               1
+#define PCRE_INFO_CAPTURECOUNT       2
+#define PCRE_INFO_BACKREFMAX         3
+#define PCRE_INFO_FIRSTBYTE          4
+#define PCRE_INFO_FIRSTCHAR          4  /* For backwards compatibility */
+#define PCRE_INFO_FIRSTTABLE         5
+#define PCRE_INFO_LASTLITERAL        6
+#define PCRE_INFO_NAMEENTRYSIZE      7
+#define PCRE_INFO_NAMECOUNT          8
+#define PCRE_INFO_NAMETABLE          9
+#define PCRE_INFO_STUDYSIZE         10
+#define PCRE_INFO_DEFAULT_TABLES    11
+#define PCRE_INFO_OKPARTIAL         12
+#define PCRE_INFO_JCHANGED          13
+#define PCRE_INFO_HASCRORLF         14
+#define PCRE_INFO_MINLENGTH         15
+#define PCRE_INFO_JIT               16
+#define PCRE_INFO_JITSIZE           17
+#define PCRE_INFO_MAXLOOKBEHIND     18
+#define PCRE_INFO_FIRSTCHARACTER    19
+#define PCRE_INFO_FIRSTCHARACTERFLAGS 20
+#define PCRE_INFO_REQUIREDCHAR      21
+#define PCRE_INFO_REQUIREDCHARFLAGS 22
+#define PCRE_INFO_MATCHLIMIT        23
+#define PCRE_INFO_RECURSIONLIMIT    24
+#define PCRE_INFO_MATCH_EMPTY       25
+
+/* Request types for pcre_config(). Do not re-arrange, in order to remain
+compatible. */
+
+#define PCRE_CONFIG_UTF8                    0
+#define PCRE_CONFIG_NEWLINE                 1
+#define PCRE_CONFIG_LINK_SIZE               2
+#define PCRE_CONFIG_POSIX_MALLOC_THRESHOLD  3
+#define PCRE_CONFIG_MATCH_LIMIT             4
+#define PCRE_CONFIG_STACKRECURSE            5
+#define PCRE_CONFIG_UNICODE_PROPERTIES      6
+#define PCRE_CONFIG_MATCH_LIMIT_RECURSION   7
+#define PCRE_CONFIG_BSR                     8
+#define PCRE_CONFIG_JIT                     9
+#define PCRE_CONFIG_UTF16                  10
+#define PCRE_CONFIG_JITTARGET              11
+#define PCRE_CONFIG_UTF32                  12
+#define PCRE_CONFIG_PARENS_LIMIT           13
+
+/* Request types for pcre_study(). Do not re-arrange, in order to remain
+compatible. */
+
+#define PCRE_STUDY_JIT_COMPILE                0x0001
+#define PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE   0x0002
+#define PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE   0x0004
+#define PCRE_STUDY_EXTRA_NEEDED               0x0008
+
+/* Bit flags for the pcre[16|32]_extra structure. Do not re-arrange or redefine
+these bits, just add new ones on the end, in order to remain compatible. */
+
+#define PCRE_EXTRA_STUDY_DATA             0x0001
+#define PCRE_EXTRA_MATCH_LIMIT            0x0002
+#define PCRE_EXTRA_CALLOUT_DATA           0x0004
+#define PCRE_EXTRA_TABLES                 0x0008
+#define PCRE_EXTRA_MATCH_LIMIT_RECURSION  0x0010
+#define PCRE_EXTRA_MARK                   0x0020
+#define PCRE_EXTRA_EXECUTABLE_JIT         0x0040
+
+/* Types */
+
+struct real_pcre8_or_16;          /* declaration; the definition is private  */
+typedef struct real_pcre8_or_16 pcre;
+
+struct real_pcre8_or_16;          /* declaration; the definition is private  */
+typedef struct real_pcre8_or_16 pcre16;
+
+struct real_pcre32;               /* declaration; the definition is private  */
+typedef struct real_pcre32 pcre32;
+
+struct real_pcre_jit_stack;       /* declaration; the definition is private  */
+typedef struct real_pcre_jit_stack pcre_jit_stack;
+
+struct real_pcre16_jit_stack;     /* declaration; the definition is private  */
+typedef struct real_pcre16_jit_stack pcre16_jit_stack;
+
+struct real_pcre32_jit_stack;     /* declaration; the definition is private  */
+typedef struct real_pcre32_jit_stack pcre32_jit_stack;
+
+/* If PCRE is compiled with 16 bit character support, PCRE_UCHAR16 must contain
+a 16 bit wide signed data type. Otherwise it can be a dummy data type since
+pcre16 functions are not implemented. There is a check for this in pcre_internal.h. */
+#ifndef PCRE_UCHAR16
+#define PCRE_UCHAR16 unsigned short
+#endif
+
+#ifndef PCRE_SPTR16
+#define PCRE_SPTR16 const PCRE_UCHAR16 *
+#endif
+
+/* If PCRE is compiled with 32 bit character support, PCRE_UCHAR32 must contain
+a 32 bit wide signed data type. Otherwise it can be a dummy data type since
+pcre32 functions are not implemented. There is a check for this in pcre_internal.h. */
+#ifndef PCRE_UCHAR32
+#define PCRE_UCHAR32 unsigned int
+#endif
+
+#ifndef PCRE_SPTR32
+#define PCRE_SPTR32 const PCRE_UCHAR32 *
+#endif
+
+/* When PCRE is compiled as a C++ library, the subject pointer type can be
+replaced with a custom type. For conventional use, the public interface is a
+const char *. */
+
+#ifndef PCRE_SPTR
+#define PCRE_SPTR const char *
+#endif
+
+/* The structure for passing additional data to pcre_exec(). This is defined in
+such as way as to be extensible. Always add new fields at the end, in order to
+remain compatible. */
+
+typedef struct pcre_extra {
+  unsigned long int flags;        /* Bits for which fields are set */
+  void *study_data;               /* Opaque data from pcre_study() */
+  unsigned long int match_limit;  /* Maximum number of calls to match() */
+  void *callout_data;             /* Data passed back in callouts */
+  const unsigned char *tables;    /* Pointer to character tables */
+  unsigned long int match_limit_recursion; /* Max recursive calls to match() */
+  unsigned char **mark;           /* For passing back a mark pointer */
+  void *executable_jit;           /* Contains a pointer to a compiled jit code */
+} pcre_extra;
+
+/* Same structure as above, but with 16 bit char pointers. */
+
+typedef struct pcre16_extra {
+  unsigned long int flags;        /* Bits for which fields are set */
+  void *study_data;               /* Opaque data from pcre_study() */
+  unsigned long int match_limit;  /* Maximum number of calls to match() */
+  void *callout_data;             /* Data passed back in callouts */
+  const unsigned char *tables;    /* Pointer to character tables */
+  unsigned long int match_limit_recursion; /* Max recursive calls to match() */
+  PCRE_UCHAR16 **mark;            /* For passing back a mark pointer */
+  void *executable_jit;           /* Contains a pointer to a compiled jit code */
+} pcre16_extra;
+
+/* Same structure as above, but with 32 bit char pointers. */
+
+typedef struct pcre32_extra {
+  unsigned long int flags;        /* Bits for which fields are set */
+  void *study_data;               /* Opaque data from pcre_study() */
+  unsigned long int match_limit;  /* Maximum number of calls to match() */
+  void *callout_data;             /* Data passed back in callouts */
+  const unsigned char *tables;    /* Pointer to character tables */
+  unsigned long int match_limit_recursion; /* Max recursive calls to match() */
+  PCRE_UCHAR32 **mark;            /* For passing back a mark pointer */
+  void *executable_jit;           /* Contains a pointer to a compiled jit code */
+} pcre32_extra;
+
+/* The structure for passing out data via the pcre_callout_function. We use a
+structure so that new fields can be added on the end in future versions,
+without changing the API of the function, thereby allowing old clients to work
+without modification. */
+
+typedef struct pcre_callout_block {
+  int          version;           /* Identifies version of block */
+  /* ------------------------ Version 0 ------------------------------- */
+  int          callout_number;    /* Number compiled into pattern */
+  int         *offset_vector;     /* The offset vector */
+  PCRE_SPTR    subject;           /* The subject being matched */
+  int          subject_length;    /* The length of the subject */
+  int          start_match;       /* Offset to start of this match attempt */
+  int          current_position;  /* Where we currently are in the subject */
+  int          capture_top;       /* Max current capture */
+  int          capture_last;      /* Most recently closed capture */
+  void        *callout_data;      /* Data passed in with the call */
+  /* ------------------- Added for Version 1 -------------------------- */
+  int          pattern_position;  /* Offset to next item in the pattern */
+  int          next_item_length;  /* Length of next item in the pattern */
+  /* ------------------- Added for Version 2 -------------------------- */
+  const unsigned char *mark;      /* Pointer to current mark or NULL    */
+  /* ------------------------------------------------------------------ */
+} pcre_callout_block;
+
+/* Same structure as above, but with 16 bit char pointers. */
+
+typedef struct pcre16_callout_block {
+  int          version;           /* Identifies version of block */
+  /* ------------------------ Version 0 ------------------------------- */
+  int          callout_number;    /* Number compiled into pattern */
+  int         *offset_vector;     /* The offset vector */
+  PCRE_SPTR16  subject;           /* The subject being matched */
+  int          subject_length;    /* The length of the subject */
+  int          start_match;       /* Offset to start of this match attempt */
+  int          current_position;  /* Where we currently are in the subject */
+  int          capture_top;       /* Max current capture */
+  int          capture_last;      /* Most recently closed capture */
+  void        *callout_data;      /* Data passed in with the call */
+  /* ------------------- Added for Version 1 -------------------------- */
+  int          pattern_position;  /* Offset to next item in the pattern */
+  int          next_item_length;  /* Length of next item in the pattern */
+  /* ------------------- Added for Version 2 -------------------------- */
+  const PCRE_UCHAR16 *mark;       /* Pointer to current mark or NULL    */
+  /* ------------------------------------------------------------------ */
+} pcre16_callout_block;
+
+/* Same structure as above, but with 32 bit char pointers. */
+
+typedef struct pcre32_callout_block {
+  int          version;           /* Identifies version of block */
+  /* ------------------------ Version 0 ------------------------------- */
+  int          callout_number;    /* Number compiled into pattern */
+  int         *offset_vector;     /* The offset vector */
+  PCRE_SPTR32  subject;           /* The subject being matched */
+  int          subject_length;    /* The length of the subject */
+  int          start_match;       /* Offset to start of this match attempt */
+  int          current_position;  /* Where we currently are in the subject */
+  int          capture_top;       /* Max current capture */
+  int          capture_last;      /* Most recently closed capture */
+  void        *callout_data;      /* Data passed in with the call */
+  /* ------------------- Added for Version 1 -------------------------- */
+  int          pattern_position;  /* Offset to next item in the pattern */
+  int          next_item_length;  /* Length of next item in the pattern */
+  /* ------------------- Added for Version 2 -------------------------- */
+  const PCRE_UCHAR32 *mark;       /* Pointer to current mark or NULL    */
+  /* ------------------------------------------------------------------ */
+} pcre32_callout_block;
+
+/* Indirection for store get and free functions. These can be set to
+alternative malloc/free functions if required. Special ones are used in the
+non-recursive case for "frames". There is also an optional callout function
+that is triggered by the (?) regex item. For Virtual Pascal, these definitions
+have to take another form. */
+
+#ifndef VPCOMPAT
+PCRE_EXP_DECL void *(*pcre_malloc)(size_t);
+PCRE_EXP_DECL void  (*pcre_free)(void *);
+PCRE_EXP_DECL void *(*pcre_stack_malloc)(size_t);
+PCRE_EXP_DECL void  (*pcre_stack_free)(void *);
+PCRE_EXP_DECL int   (*pcre_callout)(pcre_callout_block *);
+PCRE_EXP_DECL int   (*pcre_stack_guard)(void);
+
+PCRE_EXP_DECL void *(*pcre16_malloc)(size_t);
+PCRE_EXP_DECL void  (*pcre16_free)(void *);
+PCRE_EXP_DECL void *(*pcre16_stack_malloc)(size_t);
+PCRE_EXP_DECL void  (*pcre16_stack_free)(void *);
+PCRE_EXP_DECL int   (*pcre16_callout)(pcre16_callout_block *);
+PCRE_EXP_DECL int   (*pcre16_stack_guard)(void);
+
+PCRE_EXP_DECL void *(*pcre32_malloc)(size_t);
+PCRE_EXP_DECL void  (*pcre32_free)(void *);
+PCRE_EXP_DECL void *(*pcre32_stack_malloc)(size_t);
+PCRE_EXP_DECL void  (*pcre32_stack_free)(void *);
+PCRE_EXP_DECL int   (*pcre32_callout)(pcre32_callout_block *);
+PCRE_EXP_DECL int   (*pcre32_stack_guard)(void);
+#else   /* VPCOMPAT */
+PCRE_EXP_DECL void *pcre_malloc(size_t);
+PCRE_EXP_DECL void  pcre_free(void *);
+PCRE_EXP_DECL void *pcre_stack_malloc(size_t);
+PCRE_EXP_DECL void  pcre_stack_free(void *);
+PCRE_EXP_DECL int   pcre_callout(pcre_callout_block *);
+PCRE_EXP_DECL int   pcre_stack_guard(void);
+
+PCRE_EXP_DECL void *pcre16_malloc(size_t);
+PCRE_EXP_DECL void  pcre16_free(void *);
+PCRE_EXP_DECL void *pcre16_stack_malloc(size_t);
+PCRE_EXP_DECL void  pcre16_stack_free(void *);
+PCRE_EXP_DECL int   pcre16_callout(pcre16_callout_block *);
+PCRE_EXP_DECL int   pcre16_stack_guard(void);
+
+PCRE_EXP_DECL void *pcre32_malloc(size_t);
+PCRE_EXP_DECL void  pcre32_free(void *);
+PCRE_EXP_DECL void *pcre32_stack_malloc(size_t);
+PCRE_EXP_DECL void  pcre32_stack_free(void *);
+PCRE_EXP_DECL int   pcre32_callout(pcre32_callout_block *);
+PCRE_EXP_DECL int   pcre32_stack_guard(void);
+#endif  /* VPCOMPAT */
+
+/* User defined callback which provides a stack just before the match starts. */
+
+typedef pcre_jit_stack *(*pcre_jit_callback)(void *);
+typedef pcre16_jit_stack *(*pcre16_jit_callback)(void *);
+typedef pcre32_jit_stack *(*pcre32_jit_callback)(void *);
+
+/* Exported PCRE functions */
+
+PCRE_EXP_DECL pcre *pcre_compile(const char *, int, const char **, int *,
+                  const unsigned char *);
+PCRE_EXP_DECL pcre16 *pcre16_compile(PCRE_SPTR16, int, const char **, int *,
+                  const unsigned char *);
+PCRE_EXP_DECL pcre32 *pcre32_compile(PCRE_SPTR32, int, const char **, int *,
+                  const unsigned char *);
+PCRE_EXP_DECL pcre *pcre_compile2(const char *, int, int *, const char **,
+                  int *, const unsigned char *);
+PCRE_EXP_DECL pcre16 *pcre16_compile2(PCRE_SPTR16, int, int *, const char **,
+                  int *, const unsigned char *);
+PCRE_EXP_DECL pcre32 *pcre32_compile2(PCRE_SPTR32, int, int *, const char **,
+                  int *, const unsigned char *);
+PCRE_EXP_DECL int  pcre_config(int, void *);
+PCRE_EXP_DECL int  pcre16_config(int, void *);
+PCRE_EXP_DECL int  pcre32_config(int, void *);
+PCRE_EXP_DECL int  pcre_copy_named_substring(const pcre *, const char *,
+                  int *, int, const char *, char *, int);
+PCRE_EXP_DECL int  pcre16_copy_named_substring(const pcre16 *, PCRE_SPTR16,
+                  int *, int, PCRE_SPTR16, PCRE_UCHAR16 *, int);
+PCRE_EXP_DECL int  pcre32_copy_named_substring(const pcre32 *, PCRE_SPTR32,
+                  int *, int, PCRE_SPTR32, PCRE_UCHAR32 *, int);
+PCRE_EXP_DECL int  pcre_copy_substring(const char *, int *, int, int,
+                  char *, int);
+PCRE_EXP_DECL int  pcre16_copy_substring(PCRE_SPTR16, int *, int, int,
+                  PCRE_UCHAR16 *, int);
+PCRE_EXP_DECL int  pcre32_copy_substring(PCRE_SPTR32, int *, int, int,
+                  PCRE_UCHAR32 *, int);
+PCRE_EXP_DECL int  pcre_dfa_exec(const pcre *, const pcre_extra *,
+                  const char *, int, int, int, int *, int , int *, int);
+PCRE_EXP_DECL int  pcre16_dfa_exec(const pcre16 *, const pcre16_extra *,
+                  PCRE_SPTR16, int, int, int, int *, int , int *, int);
+PCRE_EXP_DECL int  pcre32_dfa_exec(const pcre32 *, const pcre32_extra *,
+                  PCRE_SPTR32, int, int, int, int *, int , int *, int);
+PCRE_EXP_DECL int  pcre_exec(const pcre *, const pcre_extra *, PCRE_SPTR,
+                   int, int, int, int *, int);
+PCRE_EXP_DECL int  pcre16_exec(const pcre16 *, const pcre16_extra *,
+                   PCRE_SPTR16, int, int, int, int *, int);
+PCRE_EXP_DECL int  pcre32_exec(const pcre32 *, const pcre32_extra *,
+                   PCRE_SPTR32, int, int, int, int *, int);
+PCRE_EXP_DECL int  pcre_jit_exec(const pcre *, const pcre_extra *,
+                   PCRE_SPTR, int, int, int, int *, int,
+                   pcre_jit_stack *);
+PCRE_EXP_DECL int  pcre16_jit_exec(const pcre16 *, const pcre16_extra *,
+                   PCRE_SPTR16, int, int, int, int *, int,
+                   pcre16_jit_stack *);
+PCRE_EXP_DECL int  pcre32_jit_exec(const pcre32 *, const pcre32_extra *,
+                   PCRE_SPTR32, int, int, int, int *, int,
+                   pcre32_jit_stack *);
+PCRE_EXP_DECL void pcre_free_substring(const char *);
+PCRE_EXP_DECL void pcre16_free_substring(PCRE_SPTR16);
+PCRE_EXP_DECL void pcre32_free_substring(PCRE_SPTR32);
+PCRE_EXP_DECL void pcre_free_substring_list(const char **);
+PCRE_EXP_DECL void pcre16_free_substring_list(PCRE_SPTR16 *);
+PCRE_EXP_DECL void pcre32_free_substring_list(PCRE_SPTR32 *);
+PCRE_EXP_DECL int  pcre_fullinfo(const pcre *, const pcre_extra *, int,
+                  void *);
+PCRE_EXP_DECL int  pcre16_fullinfo(const pcre16 *, const pcre16_extra *, int,
+                  void *);
+PCRE_EXP_DECL int  pcre32_fullinfo(const pcre32 *, const pcre32_extra *, int,
+                  void *);
+PCRE_EXP_DECL int  pcre_get_named_substring(const pcre *, const char *,
+                  int *, int, const char *, const char **);
+PCRE_EXP_DECL int  pcre16_get_named_substring(const pcre16 *, PCRE_SPTR16,
+                  int *, int, PCRE_SPTR16, PCRE_SPTR16 *);
+PCRE_EXP_DECL int  pcre32_get_named_substring(const pcre32 *, PCRE_SPTR32,
+                  int *, int, PCRE_SPTR32, PCRE_SPTR32 *);
+PCRE_EXP_DECL int  pcre_get_stringnumber(const pcre *, const char *);
+PCRE_EXP_DECL int  pcre16_get_stringnumber(const pcre16 *, PCRE_SPTR16);
+PCRE_EXP_DECL int  pcre32_get_stringnumber(const pcre32 *, PCRE_SPTR32);
+PCRE_EXP_DECL int  pcre_get_stringtable_entries(const pcre *, const char *,
+                  char **, char **);
+PCRE_EXP_DECL int  pcre16_get_stringtable_entries(const pcre16 *, PCRE_SPTR16,
+                  PCRE_UCHAR16 **, PCRE_UCHAR16 **);
+PCRE_EXP_DECL int  pcre32_get_stringtable_entries(const pcre32 *, PCRE_SPTR32,
+                  PCRE_UCHAR32 **, PCRE_UCHAR32 **);
+PCRE_EXP_DECL int  pcre_get_substring(const char *, int *, int, int,
+                  const char **);
+PCRE_EXP_DECL int  pcre16_get_substring(PCRE_SPTR16, int *, int, int,
+                  PCRE_SPTR16 *);
+PCRE_EXP_DECL int  pcre32_get_substring(PCRE_SPTR32, int *, int, int,
+                  PCRE_SPTR32 *);
+PCRE_EXP_DECL int  pcre_get_substring_list(const char *, int *, int,
+                  const char ***);
+PCRE_EXP_DECL int  pcre16_get_substring_list(PCRE_SPTR16, int *, int,
+                  PCRE_SPTR16 **);
+PCRE_EXP_DECL int  pcre32_get_substring_list(PCRE_SPTR32, int *, int,
+                  PCRE_SPTR32 **);
+PCRE_EXP_DECL const unsigned char *pcre_maketables(void);
+PCRE_EXP_DECL const unsigned char *pcre16_maketables(void);
+PCRE_EXP_DECL const unsigned char *pcre32_maketables(void);
+PCRE_EXP_DECL int  pcre_refcount(pcre *, int);
+PCRE_EXP_DECL int  pcre16_refcount(pcre16 *, int);
+PCRE_EXP_DECL int  pcre32_refcount(pcre32 *, int);
+PCRE_EXP_DECL pcre_extra *pcre_study(const pcre *, int, const char **);
+PCRE_EXP_DECL pcre16_extra *pcre16_study(const pcre16 *, int, const char **);
+PCRE_EXP_DECL pcre32_extra *pcre32_study(const pcre32 *, int, const char **);
+PCRE_EXP_DECL void pcre_free_study(pcre_extra *);
+PCRE_EXP_DECL void pcre16_free_study(pcre16_extra *);
+PCRE_EXP_DECL void pcre32_free_study(pcre32_extra *);
+PCRE_EXP_DECL const char *pcre_version(void);
+PCRE_EXP_DECL const char *pcre16_version(void);
+PCRE_EXP_DECL const char *pcre32_version(void);
+
+/* Utility functions for byte order swaps. */
+PCRE_EXP_DECL int  pcre_pattern_to_host_byte_order(pcre *, pcre_extra *,
+                  const unsigned char *);
+PCRE_EXP_DECL int  pcre16_pattern_to_host_byte_order(pcre16 *, pcre16_extra *,
+                  const unsigned char *);
+PCRE_EXP_DECL int  pcre32_pattern_to_host_byte_order(pcre32 *, pcre32_extra *,
+                  const unsigned char *);
+PCRE_EXP_DECL int  pcre16_utf16_to_host_byte_order(PCRE_UCHAR16 *,
+                  PCRE_SPTR16, int, int *, int);
+PCRE_EXP_DECL int  pcre32_utf32_to_host_byte_order(PCRE_UCHAR32 *,
+                  PCRE_SPTR32, int, int *, int);
+
+/* JIT compiler related functions. */
+
+PCRE_EXP_DECL pcre_jit_stack *pcre_jit_stack_alloc(int, int);
+PCRE_EXP_DECL pcre16_jit_stack *pcre16_jit_stack_alloc(int, int);
+PCRE_EXP_DECL pcre32_jit_stack *pcre32_jit_stack_alloc(int, int);
+PCRE_EXP_DECL void pcre_jit_stack_free(pcre_jit_stack *);
+PCRE_EXP_DECL void pcre16_jit_stack_free(pcre16_jit_stack *);
+PCRE_EXP_DECL void pcre32_jit_stack_free(pcre32_jit_stack *);
+PCRE_EXP_DECL void pcre_assign_jit_stack(pcre_extra *,
+                  pcre_jit_callback, void *);
+PCRE_EXP_DECL void pcre16_assign_jit_stack(pcre16_extra *,
+                  pcre16_jit_callback, void *);
+PCRE_EXP_DECL void pcre32_assign_jit_stack(pcre32_extra *,
+                  pcre32_jit_callback, void *);
+PCRE_EXP_DECL void pcre_jit_free_unused_memory(void);
+PCRE_EXP_DECL void pcre16_jit_free_unused_memory(void);
+PCRE_EXP_DECL void pcre32_jit_free_unused_memory(void);
+
+#ifdef __cplusplus
+}  /* extern "C" */
+#endif
+
+#endif /* End of pcre.h */
diff --git a/base/poco/Foundation/src/pcre_byte_order.c b/base/poco/Foundation/src/pcre_byte_order.c
new file mode 100644
index 00000000000..f5ba9c76fab
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_byte_order.c
@@ -0,0 +1,315 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2014 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+
+/* This module contains an internal function that tests a compiled pattern to
+see if it was compiled with the opposite endianness. If so, it uses an
+auxiliary local function to flip the appropriate bytes. */
+
+#include "pcre_config.h"
+#include "pcre_internal.h"
+
+
+/*************************************************
+*             Swap byte functions                *
+*************************************************/
+
+/* The following functions swap the bytes of a pcre_uint16
+and pcre_uint32 value.
+
+Arguments:
+  value        any number
+
+Returns:       the byte swapped value
+*/
+
+static pcre_uint32
+swap_uint32(pcre_uint32 value)
+{
+return ((value & 0x000000ff) << 24) |
+       ((value & 0x0000ff00) <<  8) |
+       ((value & 0x00ff0000) >>  8) |
+       (value >> 24);
+}
+
+static pcre_uint16
+swap_uint16(pcre_uint16 value)
+{
+return (value >> 8) | (value << 8);
+}
+
+
+/*************************************************
+*       Test for a byte-flipped compiled regex   *
+*************************************************/
+
+/* This function swaps the bytes of a compiled pattern usually
+loaded form the disk. It also sets the tables pointer, which
+is likely an invalid pointer after reload.
+
+Arguments:
+  argument_re     points to the compiled expression
+  extra_data      points to extra data or is NULL
+  tables          points to the character tables or NULL
+
+Returns:          0 if the swap is successful, negative on error
+*/
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DECL int pcre_pattern_to_host_byte_order(pcre *argument_re,
+  pcre_extra *extra_data, const unsigned char *tables)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DECL int pcre16_pattern_to_host_byte_order(pcre16 *argument_re,
+  pcre16_extra *extra_data, const unsigned char *tables)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DECL int pcre32_pattern_to_host_byte_order(pcre32 *argument_re,
+  pcre32_extra *extra_data, const unsigned char *tables)
+#endif
+{
+REAL_PCRE *re = (REAL_PCRE *)argument_re;
+pcre_study_data *study;
+#ifndef COMPILE_PCRE8
+pcre_uchar *ptr;
+int length;
+#if defined SUPPORT_UTF && defined COMPILE_PCRE16
+BOOL utf;
+BOOL utf16_char;
+#endif /* SUPPORT_UTF && COMPILE_PCRE16 */
+#endif /* !COMPILE_PCRE8 */
+
+if (re == NULL) return PCRE_ERROR_NULL;
+if (re->magic_number == MAGIC_NUMBER)
+  {
+  if ((re->flags & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE;
+  re->tables = tables;
+  return 0;
+  }
+
+if (re->magic_number != REVERSED_MAGIC_NUMBER) return PCRE_ERROR_BADMAGIC;
+if ((swap_uint32(re->flags) & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE;
+
+re->magic_number = MAGIC_NUMBER;
+re->size = swap_uint32(re->size);
+re->options = swap_uint32(re->options);
+re->flags = swap_uint32(re->flags);
+re->limit_match = swap_uint32(re->limit_match);
+re->limit_recursion = swap_uint32(re->limit_recursion);
+
+#if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
+re->first_char = swap_uint16(re->first_char);
+re->req_char = swap_uint16(re->req_char);
+#elif defined COMPILE_PCRE32
+re->first_char = swap_uint32(re->first_char);
+re->req_char = swap_uint32(re->req_char);
+#endif
+
+re->max_lookbehind = swap_uint16(re->max_lookbehind);
+re->top_bracket = swap_uint16(re->top_bracket);
+re->top_backref = swap_uint16(re->top_backref);
+re->name_table_offset = swap_uint16(re->name_table_offset);
+re->name_entry_size = swap_uint16(re->name_entry_size);
+re->name_count = swap_uint16(re->name_count);
+re->ref_count = swap_uint16(re->ref_count);
+re->tables = tables;
+
+if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_STUDY_DATA) != 0)
+  {
+  study = (pcre_study_data *)extra_data->study_data;
+  study->size = swap_uint32(study->size);
+  study->flags = swap_uint32(study->flags);
+  study->minlength = swap_uint32(study->minlength);
+  }
+
+#ifndef COMPILE_PCRE8
+ptr = (pcre_uchar *)re + re->name_table_offset;
+length = re->name_count * re->name_entry_size;
+#if defined SUPPORT_UTF && defined COMPILE_PCRE16
+utf = (re->options & PCRE_UTF16) != 0;
+utf16_char = FALSE;
+#endif /* SUPPORT_UTF && COMPILE_PCRE16 */
+
+while(TRUE)
+  {
+  /* Swap previous characters. */
+  while (length-- > 0)
+    {
+#if defined COMPILE_PCRE16
+    *ptr = swap_uint16(*ptr);
+#elif defined COMPILE_PCRE32
+    *ptr = swap_uint32(*ptr);
+#endif
+    ptr++;
+    }
+#if defined SUPPORT_UTF && defined COMPILE_PCRE16
+  if (utf16_char)
+    {
+    if (HAS_EXTRALEN(ptr[-1]))
+      {
+      /* We know that there is only one extra character in UTF-16. */
+      *ptr = swap_uint16(*ptr);
+      ptr++;
+      }
+    }
+  utf16_char = FALSE;
+#endif /* SUPPORT_UTF */
+
+  /* Get next opcode. */
+  length = 0;
+#if defined COMPILE_PCRE16
+  *ptr = swap_uint16(*ptr);
+#elif defined COMPILE_PCRE32
+  *ptr = swap_uint32(*ptr);
+#endif
+  switch (*ptr)
+    {
+    case OP_END:
+    return 0;
+
+#if defined SUPPORT_UTF && defined COMPILE_PCRE16
+    case OP_CHAR:
+    case OP_CHARI:
+    case OP_NOT:
+    case OP_NOTI:
+    case OP_STAR:
+    case OP_MINSTAR:
+    case OP_PLUS:
+    case OP_MINPLUS:
+    case OP_QUERY:
+    case OP_MINQUERY:
+    case OP_UPTO:
+    case OP_MINUPTO:
+    case OP_EXACT:
+    case OP_POSSTAR:
+    case OP_POSPLUS:
+    case OP_POSQUERY:
+    case OP_POSUPTO:
+    case OP_STARI:
+    case OP_MINSTARI:
+    case OP_PLUSI:
+    case OP_MINPLUSI:
+    case OP_QUERYI:
+    case OP_MINQUERYI:
+    case OP_UPTOI:
+    case OP_MINUPTOI:
+    case OP_EXACTI:
+    case OP_POSSTARI:
+    case OP_POSPLUSI:
+    case OP_POSQUERYI:
+    case OP_POSUPTOI:
+    case OP_NOTSTAR:
+    case OP_NOTMINSTAR:
+    case OP_NOTPLUS:
+    case OP_NOTMINPLUS:
+    case OP_NOTQUERY:
+    case OP_NOTMINQUERY:
+    case OP_NOTUPTO:
+    case OP_NOTMINUPTO:
+    case OP_NOTEXACT:
+    case OP_NOTPOSSTAR:
+    case OP_NOTPOSPLUS:
+    case OP_NOTPOSQUERY:
+    case OP_NOTPOSUPTO:
+    case OP_NOTSTARI:
+    case OP_NOTMINSTARI:
+    case OP_NOTPLUSI:
+    case OP_NOTMINPLUSI:
+    case OP_NOTQUERYI:
+    case OP_NOTMINQUERYI:
+    case OP_NOTUPTOI:
+    case OP_NOTMINUPTOI:
+    case OP_NOTEXACTI:
+    case OP_NOTPOSSTARI:
+    case OP_NOTPOSPLUSI:
+    case OP_NOTPOSQUERYI:
+    case OP_NOTPOSUPTOI:
+    if (utf) utf16_char = TRUE;
+#endif
+    /* Fall through. */
+
+    default:
+    length = PRIV(OP_lengths)[*ptr] - 1;
+    break;
+
+    case OP_CLASS:
+    case OP_NCLASS:
+    /* Skip the character bit map. */
+    ptr += 32/sizeof(pcre_uchar);
+    length = 0;
+    break;
+
+    case OP_XCLASS:
+    /* Reverse the size of the XCLASS instance. */
+    ptr++;
+#if defined COMPILE_PCRE16
+    *ptr = swap_uint16(*ptr);
+#elif defined COMPILE_PCRE32
+    *ptr = swap_uint32(*ptr);
+#endif
+#ifndef COMPILE_PCRE32
+    if (LINK_SIZE > 1)
+      {
+      /* LINK_SIZE can be 1 or 2 in 16 bit mode. */
+      ptr++;
+      *ptr = swap_uint16(*ptr);
+      }
+#endif
+    ptr++;
+    length = (GET(ptr, -LINK_SIZE)) - (1 + LINK_SIZE + 1);
+#if defined COMPILE_PCRE16
+    *ptr = swap_uint16(*ptr);
+#elif defined COMPILE_PCRE32
+    *ptr = swap_uint32(*ptr);
+#endif
+    if ((*ptr & XCL_MAP) != 0)
+      {
+      /* Skip the character bit map. */
+      ptr += 32/sizeof(pcre_uchar);
+      length -= 32/sizeof(pcre_uchar);
+      }
+    break;
+    }
+  ptr++;
+  }
+/* Control should never reach here in 16/32 bit mode. */
+#else  /* In 8-bit mode, the pattern does not need to be processed. */
+return 0;
+#endif /* !COMPILE_PCRE8 */
+}
+
+/* End of pcre_byte_order.c */
diff --git a/base/poco/Foundation/src/pcre_chartables.c b/base/poco/Foundation/src/pcre_chartables.c
new file mode 100644
index 00000000000..b11eb25e477
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_chartables.c
@@ -0,0 +1,195 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* This file contains character tables that are used when no external tables
+are passed to PCRE by the application that calls it. The tables are used only
+for characters whose code values are less than 256.
+
+This is a default version of the tables that assumes ASCII encoding. A program
+called dftables (which is distributed with PCRE) can be used to build
+alternative versions of this file. This is necessary if you are running in an
+EBCDIC environment, or if you want to default to a different encoding, for
+example ISO-8859-1. When dftables is run, it creates these tables in the
+current locale. If PCRE is configured with --enable-rebuild-chartables, this
+happens automatically.
+
+The following #includes are present because without them gcc 4.x may remove the
+array definition from the final binary if PCRE is built into a static library
+and dead code stripping is activated. This leads to link errors. Pulling in the
+header ensures that the array gets flagged as "someone outside this compilation
+unit might reference this" and so it will always be supplied to the linker. */
+
+#include "pcre_config.h"
+#include "pcre_internal.h"
+
+const pcre_uint8 PRIV(default_tables)[] = {
+
+/* This table is a lower casing table. */
+
+    0,  1,  2,  3,  4,  5,  6,  7,
+    8,  9, 10, 11, 12, 13, 14, 15,
+   16, 17, 18, 19, 20, 21, 22, 23,
+   24, 25, 26, 27, 28, 29, 30, 31,
+   32, 33, 34, 35, 36, 37, 38, 39,
+   40, 41, 42, 43, 44, 45, 46, 47,
+   48, 49, 50, 51, 52, 53, 54, 55,
+   56, 57, 58, 59, 60, 61, 62, 63,
+   64, 97, 98, 99,100,101,102,103,
+  104,105,106,107,108,109,110,111,
+  112,113,114,115,116,117,118,119,
+  120,121,122, 91, 92, 93, 94, 95,
+   96, 97, 98, 99,100,101,102,103,
+  104,105,106,107,108,109,110,111,
+  112,113,114,115,116,117,118,119,
+  120,121,122,123,124,125,126,127,
+  128,129,130,131,132,133,134,135,
+  136,137,138,139,140,141,142,143,
+  144,145,146,147,148,149,150,151,
+  152,153,154,155,156,157,158,159,
+  160,161,162,163,164,165,166,167,
+  168,169,170,171,172,173,174,175,
+  176,177,178,179,180,181,182,183,
+  184,185,186,187,188,189,190,191,
+  192,193,194,195,196,197,198,199,
+  200,201,202,203,204,205,206,207,
+  208,209,210,211,212,213,214,215,
+  216,217,218,219,220,221,222,223,
+  224,225,226,227,228,229,230,231,
+  232,233,234,235,236,237,238,239,
+  240,241,242,243,244,245,246,247,
+  248,249,250,251,252,253,254,255,
+
+/* This table is a case flipping table. */
+
+    0,  1,  2,  3,  4,  5,  6,  7,
+    8,  9, 10, 11, 12, 13, 14, 15,
+   16, 17, 18, 19, 20, 21, 22, 23,
+   24, 25, 26, 27, 28, 29, 30, 31,
+   32, 33, 34, 35, 36, 37, 38, 39,
+   40, 41, 42, 43, 44, 45, 46, 47,
+   48, 49, 50, 51, 52, 53, 54, 55,
+   56, 57, 58, 59, 60, 61, 62, 63,
+   64, 97, 98, 99,100,101,102,103,
+  104,105,106,107,108,109,110,111,
+  112,113,114,115,116,117,118,119,
+  120,121,122, 91, 92, 93, 94, 95,
+   96, 65, 66, 67, 68, 69, 70, 71,
+   72, 73, 74, 75, 76, 77, 78, 79,
+   80, 81, 82, 83, 84, 85, 86, 87,
+   88, 89, 90,123,124,125,126,127,
+  128,129,130,131,132,133,134,135,
+  136,137,138,139,140,141,142,143,
+  144,145,146,147,148,149,150,151,
+  152,153,154,155,156,157,158,159,
+  160,161,162,163,164,165,166,167,
+  168,169,170,171,172,173,174,175,
+  176,177,178,179,180,181,182,183,
+  184,185,186,187,188,189,190,191,
+  192,193,194,195,196,197,198,199,
+  200,201,202,203,204,205,206,207,
+  208,209,210,211,212,213,214,215,
+  216,217,218,219,220,221,222,223,
+  224,225,226,227,228,229,230,231,
+  232,233,234,235,236,237,238,239,
+  240,241,242,243,244,245,246,247,
+  248,249,250,251,252,253,254,255,
+
+/* This table contains bit maps for various character classes. Each map is 32
+bytes long and the bits run from the least significant end of each byte. The
+classes that have their own maps are: space, xdigit, digit, upper, lower, word,
+graph, print, punct, and cntrl. Other classes are built from combinations. */
+
+  0x00,0x3e,0x00,0x00,0x01,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+  0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,
+  0x7e,0x00,0x00,0x00,0x7e,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+  0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0xfe,0xff,0xff,0x07,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0x07,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+  0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x03,
+  0xfe,0xff,0xff,0x87,0xfe,0xff,0xff,0x07,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+  0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0xff,
+  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+  0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff,
+  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+  0x00,0x00,0x00,0x00,0xfe,0xff,0x00,0xfc,
+  0x01,0x00,0x00,0xf8,0x01,0x00,0x00,0x78,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+  0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+
+/* This table identifies various classes of character by individual bits:
+  0x01   white space character
+  0x02   letter
+  0x04   decimal digit
+  0x08   hexadecimal digit
+  0x10   alphanumeric or '_'
+  0x80   regular expression metacharacter or binary zero
+*/
+
+  0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7 */
+  0x00,0x01,0x01,0x01,0x01,0x01,0x00,0x00, /*   8- 15 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  16- 23 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31 */
+  0x01,0x00,0x00,0x00,0x80,0x00,0x00,0x00, /*    - '  */
+  0x80,0x80,0x80,0x80,0x00,0x00,0x80,0x00, /*  ( - /  */
+  0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /*  0 - 7  */
+  0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x80, /*  8 - ?  */
+  0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /*  @ - G  */
+  0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  H - O  */
+  0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  P - W  */
+  0x12,0x12,0x12,0x80,0x80,0x00,0x80,0x10, /*  X - _  */
+  0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /*  ` - g  */
+  0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  h - o  */
+  0x12,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  p - w  */
+  0x12,0x12,0x12,0x80,0x80,0x00,0x00,0x00, /*  x -127 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */
+
+/* End of pcre_chartables.c */
diff --git a/base/poco/Foundation/src/pcre_compile.c b/base/poco/Foundation/src/pcre_compile.c
new file mode 100644
index 00000000000..b4b78b418f3
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_compile.c
@@ -0,0 +1,9806 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2018 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+#pragma warning( disable : 4018)  // '<' : signed/unsigned mismatch
+#pragma warning( disable : 4127)  // conditional expression is constant
+#pragma warning( disable : 4244)  // conversion from 'int' to 'unsigned short', possible loss of data
+#pragma warning( disable : 4701)  // local variable 'othercase' may be used without having been initialized
+#pragma warning( disable : 4702)  // unreachable code
+
+/* This module contains the external function pcre_compile(), along with
+supporting internal functions that are not used by other modules. */
+
+#include "pcre_config.h"
+
+#define NLBLOCK cd             /* Block containing newline information */
+#define PSSTART start_pattern  /* Field containing pattern start */
+#define PSEND   end_pattern    /* Field containing pattern end */
+
+#include "pcre_internal.h"
+
+
+/* When PCRE_DEBUG is defined, we need the pcre(16|32)_printint() function, which
+is also used by pcretest. PCRE_DEBUG is not defined when building a production
+library. We do not need to select pcre16_printint.c specially, because the
+COMPILE_PCREx macro will already be appropriately set. */
+
+#ifdef PCRE_DEBUG
+/* pcre_printint.c should not include any headers */
+#define PCRE_INCLUDED
+#include "pcre_printint.c"
+#undef PCRE_INCLUDED
+#endif
+
+
+/* Macro for setting individual bits in class bitmaps. */
+
+#define SETBIT(a,b) a[(b)/8] |= (1 << ((b)&7))
+
+/* Maximum length value to check against when making sure that the integer that
+holds the compiled pattern length does not overflow. We make it a bit less than
+INT_MAX to allow for adding in group terminating bytes, so that we don't have
+to check them every time. */
+
+#define OFLOW_MAX (INT_MAX - 20)
+
+/* Definitions to allow mutual recursion */
+
+static int
+  add_list_to_class(pcre_uint8 *, pcre_uchar **, int, compile_data *,
+    const pcre_uint32 *, unsigned int);
+
+static BOOL
+  compile_regex(int, pcre_uchar **, const pcre_uchar **, int *, BOOL, BOOL, int, int,
+    pcre_uint32 *, pcre_int32 *, pcre_uint32 *, pcre_int32 *, branch_chain *,
+    compile_data *, int *);
+
+
+
+/*************************************************
+*      Code parameters and static tables         *
+*************************************************/
+
+/* This value specifies the size of stack workspace that is used during the
+first pre-compile phase that determines how much memory is required. The regex
+is partly compiled into this space, but the compiled parts are discarded as
+soon as they can be, so that hopefully there will never be an overrun. The code
+does, however, check for an overrun. The largest amount I've seen used is 218,
+so this number is very generous.
+
+The same workspace is used during the second, actual compile phase for
+remembering forward references to groups so that they can be filled in at the
+end. Each entry in this list occupies LINK_SIZE bytes, so even when LINK_SIZE
+is 4 there is plenty of room for most patterns. However, the memory can get
+filled up by repetitions of forward references, for example patterns like
+/(?1){0,1999}(b)/, and one user did hit the limit. The code has been changed so
+that the workspace is expanded using malloc() in this situation. The value
+below is therefore a minimum, and we put a maximum on it for safety. The
+minimum is now also defined in terms of LINK_SIZE so that the use of malloc()
+kicks in at the same number of forward references in all cases. */
+
+#define COMPILE_WORK_SIZE (2048*LINK_SIZE)
+#define COMPILE_WORK_SIZE_MAX (100*COMPILE_WORK_SIZE)
+
+/* This value determines the size of the initial vector that is used for
+remembering named groups during the pre-compile. It is allocated on the stack,
+but if it is too small, it is expanded using malloc(), in a similar way to the
+workspace. The value is the number of slots in the list. */
+
+#define NAMED_GROUP_LIST_SIZE  20
+
+/* The overrun tests check for a slightly smaller size so that they detect the
+overrun before it actually does run off the end of the data block. */
+
+#define WORK_SIZE_SAFETY_MARGIN (100)
+
+/* Private flags added to firstchar and reqchar. */
+
+#define REQ_CASELESS    (1 << 0)        /* Indicates caselessness */
+#define REQ_VARY        (1 << 1)        /* Reqchar followed non-literal item */
+/* Negative values for the firstchar and reqchar flags */
+#define REQ_UNSET       (-2)
+#define REQ_NONE        (-1)
+
+/* Repeated character flags. */
+
+#define UTF_LENGTH     0x10000000l      /* The char contains its length. */
+
+/* Table for handling escaped characters in the range '0'-'z'. Positive returns
+are simple data values; negative values are for special things like \d and so
+on. Zero means further processing is needed (for things like \x), or the escape
+is invalid. */
+
+#ifndef EBCDIC
+
+/* This is the "normal" table for ASCII systems or for EBCDIC systems running
+in UTF-8 mode. */
+
+static const short int escapes[] = {
+     0,                       0,
+     0,                       0,
+     0,                       0,
+     0,                       0,
+     0,                       0,
+     CHAR_COLON,              CHAR_SEMICOLON,
+     CHAR_LESS_THAN_SIGN,     CHAR_EQUALS_SIGN,
+     CHAR_GREATER_THAN_SIGN,  CHAR_QUESTION_MARK,
+     CHAR_COMMERCIAL_AT,      -ESC_A,
+     -ESC_B,                  -ESC_C,
+     -ESC_D,                  -ESC_E,
+     0,                       -ESC_G,
+     -ESC_H,                  0,
+     0,                       -ESC_K,
+     0,                       0,
+     -ESC_N,                  0,
+     -ESC_P,                  -ESC_Q,
+     -ESC_R,                  -ESC_S,
+     0,                       0,
+     -ESC_V,                  -ESC_W,
+     -ESC_X,                  0,
+     -ESC_Z,                  CHAR_LEFT_SQUARE_BRACKET,
+     CHAR_BACKSLASH,          CHAR_RIGHT_SQUARE_BRACKET,
+     CHAR_CIRCUMFLEX_ACCENT,  CHAR_UNDERSCORE,
+     CHAR_GRAVE_ACCENT,       ESC_a,
+     -ESC_b,                  0,
+     -ESC_d,                  ESC_e,
+     ESC_f,                   0,
+     -ESC_h,                  0,
+     0,                       -ESC_k,
+     0,                       0,
+     ESC_n,                   0,
+     -ESC_p,                  0,
+     ESC_r,                   -ESC_s,
+     ESC_tee,                 0,
+     -ESC_v,                  -ESC_w,
+     0,                       0,
+     -ESC_z
+};
+
+#else
+
+/* This is the "abnormal" table for EBCDIC systems without UTF-8 support. */
+
+static const short int escapes[] = {
+/*  48 */     0,     0,      0,     '.',    '<',   '(',    '+',    '|',
+/*  50 */   '&',     0,      0,       0,      0,     0,      0,      0,
+/*  58 */     0,     0,    '!',     '$',    '*',   ')',    ';',    '~',
+/*  60 */   '-',   '/',      0,       0,      0,     0,      0,      0,
+/*  68 */     0,     0,    '|',     ',',    '%',   '_',    '>',    '?',
+/*  70 */     0,     0,      0,       0,      0,     0,      0,      0,
+/*  78 */     0,   '`',    ':',     '#',    '@',  '\'',    '=',    '"',
+/*  80 */     0, ESC_a, -ESC_b,       0, -ESC_d, ESC_e,  ESC_f,      0,
+/*  88 */-ESC_h,     0,      0,     '{',      0,     0,      0,      0,
+/*  90 */     0,     0, -ESC_k,       0,      0, ESC_n,      0, -ESC_p,
+/*  98 */     0, ESC_r,      0,     '}',      0,     0,      0,      0,
+/*  A0 */     0,   '~', -ESC_s, ESC_tee,      0,-ESC_v, -ESC_w,      0,
+/*  A8 */     0,-ESC_z,      0,       0,      0,   '[',      0,      0,
+/*  B0 */     0,     0,      0,       0,      0,     0,      0,      0,
+/*  B8 */     0,     0,      0,       0,      0,   ']',    '=',    '-',
+/*  C0 */   '{',-ESC_A, -ESC_B,  -ESC_C, -ESC_D,-ESC_E,      0, -ESC_G,
+/*  C8 */-ESC_H,     0,      0,       0,      0,     0,      0,      0,
+/*  D0 */   '}',     0, -ESC_K,       0,      0,-ESC_N,      0, -ESC_P,
+/*  D8 */-ESC_Q,-ESC_R,      0,       0,      0,     0,      0,      0,
+/*  E0 */  '\\',     0, -ESC_S,       0,      0,-ESC_V, -ESC_W, -ESC_X,
+/*  E8 */     0,-ESC_Z,      0,       0,      0,     0,      0,      0,
+/*  F0 */     0,     0,      0,       0,      0,     0,      0,      0,
+/*  F8 */     0,     0,      0,       0,      0,     0,      0,      0
+};
+
+/* We also need a table of characters that may follow \c in an EBCDIC
+environment for characters 0-31. */
+
+static unsigned char ebcdic_escape_c[] = "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_";
+
+#endif
+
+
+/* Table of special "verbs" like (*PRUNE). This is a short table, so it is
+searched linearly. Put all the names into a single string, in order to reduce
+the number of relocations when a shared library is dynamically linked. The
+string is built from string macros so that it works in UTF-8 mode on EBCDIC
+platforms. */
+
+typedef struct verbitem {
+  int   len;                 /* Length of verb name */
+  int   op;                  /* Op when no arg, or -1 if arg mandatory */
+  int   op_arg;              /* Op when arg present, or -1 if not allowed */
+} verbitem;
+
+static const char verbnames[] =
+  "\0"                       /* Empty name is a shorthand for MARK */
+  STRING_MARK0
+  STRING_ACCEPT0
+  STRING_COMMIT0
+  STRING_F0
+  STRING_FAIL0
+  STRING_PRUNE0
+  STRING_SKIP0
+  STRING_THEN;
+
+static const verbitem verbs[] = {
+  { 0, -1,        OP_MARK },
+  { 4, -1,        OP_MARK },
+  { 6, OP_ACCEPT, -1 },
+  { 6, OP_COMMIT, -1 },
+  { 1, OP_FAIL,   -1 },
+  { 4, OP_FAIL,   -1 },
+  { 5, OP_PRUNE,  OP_PRUNE_ARG },
+  { 4, OP_SKIP,   OP_SKIP_ARG  },
+  { 4, OP_THEN,   OP_THEN_ARG  }
+};
+
+static const int verbcount = sizeof(verbs)/sizeof(verbitem);
+
+
+/* Substitutes for [[:<:]] and [[:>:]], which mean start and end of word in
+another regex library. */
+
+static const pcre_uchar sub_start_of_word[] = {
+  CHAR_BACKSLASH, CHAR_b, CHAR_LEFT_PARENTHESIS, CHAR_QUESTION_MARK,
+  CHAR_EQUALS_SIGN, CHAR_BACKSLASH, CHAR_w, CHAR_RIGHT_PARENTHESIS, '\0' };
+
+static const pcre_uchar sub_end_of_word[] = {
+  CHAR_BACKSLASH, CHAR_b, CHAR_LEFT_PARENTHESIS, CHAR_QUESTION_MARK,
+  CHAR_LESS_THAN_SIGN, CHAR_EQUALS_SIGN, CHAR_BACKSLASH, CHAR_w,
+  CHAR_RIGHT_PARENTHESIS, '\0' };
+
+
+/* Tables of names of POSIX character classes and their lengths. The names are
+now all in a single string, to reduce the number of relocations when a shared
+library is dynamically loaded. The list of lengths is terminated by a zero
+length entry. The first three must be alpha, lower, upper, as this is assumed
+for handling case independence. The indices for graph, print, and punct are
+needed, so identify them. */
+
+static const char posix_names[] =
+  STRING_alpha0 STRING_lower0 STRING_upper0 STRING_alnum0
+  STRING_ascii0 STRING_blank0 STRING_cntrl0 STRING_digit0
+  STRING_graph0 STRING_print0 STRING_punct0 STRING_space0
+  STRING_word0  STRING_xdigit;
+
+static const pcre_uint8 posix_name_lengths[] = {
+  5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 6, 0 };
+
+#define PC_GRAPH  8
+#define PC_PRINT  9
+#define PC_PUNCT 10
+
+
+/* Table of class bit maps for each POSIX class. Each class is formed from a
+base map, with an optional addition or removal of another map. Then, for some
+classes, there is some additional tweaking: for [:blank:] the vertical space
+characters are removed, and for [:alpha:] and [:alnum:] the underscore
+character is removed. The triples in the table consist of the base map offset,
+second map offset or -1 if no second map, and a non-negative value for map
+addition or a negative value for map subtraction (if there are two maps). The
+absolute value of the third field has these meanings: 0 => no tweaking, 1 =>
+remove vertical space characters, 2 => remove underscore. */
+
+static const int posix_class_maps[] = {
+  cbit_word,  cbit_digit, -2,             /* alpha */
+  cbit_lower, -1,          0,             /* lower */
+  cbit_upper, -1,          0,             /* upper */
+  cbit_word,  -1,          2,             /* alnum - word without underscore */
+  cbit_print, cbit_cntrl,  0,             /* ascii */
+  cbit_space, -1,          1,             /* blank - a GNU extension */
+  cbit_cntrl, -1,          0,             /* cntrl */
+  cbit_digit, -1,          0,             /* digit */
+  cbit_graph, -1,          0,             /* graph */
+  cbit_print, -1,          0,             /* print */
+  cbit_punct, -1,          0,             /* punct */
+  cbit_space, -1,          0,             /* space */
+  cbit_word,  -1,          0,             /* word - a Perl extension */
+  cbit_xdigit,-1,          0              /* xdigit */
+};
+
+/* Table of substitutes for \d etc when PCRE_UCP is set. They are replaced by
+Unicode property escapes. */
+
+#ifdef SUPPORT_UCP
+static const pcre_uchar string_PNd[]  = {
+  CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
+  CHAR_N, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+static const pcre_uchar string_pNd[]  = {
+  CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
+  CHAR_N, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+static const pcre_uchar string_PXsp[] = {
+  CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
+  CHAR_X, CHAR_s, CHAR_p, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+static const pcre_uchar string_pXsp[] = {
+  CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
+  CHAR_X, CHAR_s, CHAR_p, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+static const pcre_uchar string_PXwd[] = {
+  CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
+  CHAR_X, CHAR_w, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+static const pcre_uchar string_pXwd[] = {
+  CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
+  CHAR_X, CHAR_w, CHAR_d, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+
+static const pcre_uchar *substitutes[] = {
+  string_PNd,           /* \D */
+  string_pNd,           /* \d */
+  string_PXsp,          /* \S */   /* Xsp is Perl space, but from 8.34, Perl */
+  string_pXsp,          /* \s */   /* space and POSIX space are the same. */
+  string_PXwd,          /* \W */
+  string_pXwd           /* \w */
+};
+
+/* The POSIX class substitutes must be in the order of the POSIX class names,
+defined above, and there are both positive and negative cases. NULL means no
+general substitute of a Unicode property escape (\p or \P). However, for some
+POSIX classes (e.g. graph, print, punct) a special property code is compiled
+directly. */
+
+static const pcre_uchar string_pL[] =   {
+  CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
+  CHAR_L, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+static const pcre_uchar string_pLl[] =  {
+  CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
+  CHAR_L, CHAR_l, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+static const pcre_uchar string_pLu[] =  {
+  CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
+  CHAR_L, CHAR_u, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+static const pcre_uchar string_pXan[] = {
+  CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
+  CHAR_X, CHAR_a, CHAR_n, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+static const pcre_uchar string_h[] =    {
+  CHAR_BACKSLASH, CHAR_h, '\0' };
+static const pcre_uchar string_pXps[] = {
+  CHAR_BACKSLASH, CHAR_p, CHAR_LEFT_CURLY_BRACKET,
+  CHAR_X, CHAR_p, CHAR_s, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+static const pcre_uchar string_PL[] =   {
+  CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
+  CHAR_L, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+static const pcre_uchar string_PLl[] =  {
+  CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
+  CHAR_L, CHAR_l, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+static const pcre_uchar string_PLu[] =  {
+  CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
+  CHAR_L, CHAR_u, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+static const pcre_uchar string_PXan[] = {
+  CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
+  CHAR_X, CHAR_a, CHAR_n, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+static const pcre_uchar string_H[] =    {
+  CHAR_BACKSLASH, CHAR_H, '\0' };
+static const pcre_uchar string_PXps[] = {
+  CHAR_BACKSLASH, CHAR_P, CHAR_LEFT_CURLY_BRACKET,
+  CHAR_X, CHAR_p, CHAR_s, CHAR_RIGHT_CURLY_BRACKET, '\0' };
+
+static const pcre_uchar *posix_substitutes[] = {
+  string_pL,            /* alpha */
+  string_pLl,           /* lower */
+  string_pLu,           /* upper */
+  string_pXan,          /* alnum */
+  NULL,                 /* ascii */
+  string_h,             /* blank */
+  NULL,                 /* cntrl */
+  string_pNd,           /* digit */
+  NULL,                 /* graph */
+  NULL,                 /* print */
+  NULL,                 /* punct */
+  string_pXps,          /* space */   /* Xps is POSIX space, but from 8.34 */
+  string_pXwd,          /* word  */   /* Perl and POSIX space are the same */
+  NULL,                 /* xdigit */
+  /* Negated cases */
+  string_PL,            /* ^alpha */
+  string_PLl,           /* ^lower */
+  string_PLu,           /* ^upper */
+  string_PXan,          /* ^alnum */
+  NULL,                 /* ^ascii */
+  string_H,             /* ^blank */
+  NULL,                 /* ^cntrl */
+  string_PNd,           /* ^digit */
+  NULL,                 /* ^graph */
+  NULL,                 /* ^print */
+  NULL,                 /* ^punct */
+  string_PXps,          /* ^space */  /* Xps is POSIX space, but from 8.34 */
+  string_PXwd,          /* ^word */   /* Perl and POSIX space are the same */
+  NULL                  /* ^xdigit */
+};
+#define POSIX_SUBSIZE (sizeof(posix_substitutes) / sizeof(pcre_uchar *))
+#endif
+
+#define STRING(a)  # a
+#define XSTRING(s) STRING(s)
+
+/* The texts of compile-time error messages. These are "char *" because they
+are passed to the outside world. Do not ever re-use any error number, because
+they are documented. Always add a new error instead. Messages marked DEAD below
+are no longer used. This used to be a table of strings, but in order to reduce
+the number of relocations needed when a shared library is loaded dynamically,
+it is now one long string. We cannot use a table of offsets, because the
+lengths of inserts such as XSTRING(MAX_NAME_SIZE) are not known. Instead, we
+simply count through to the one we want - this isn't a performance issue
+because these strings are used only when there is a compilation error.
+
+Each substring ends with \0 to insert a null character. This includes the final
+substring, so that the whole string ends with \0\0, which can be detected when
+counting through. */
+
+static const char error_texts[] =
+  "no error\0"
+  "\\ at end of pattern\0"
+  "\\c at end of pattern\0"
+  "unrecognized character follows \\\0"
+  "numbers out of order in {} quantifier\0"
+  /* 5 */
+  "number too big in {} quantifier\0"
+  "missing terminating ] for character class\0"
+  "invalid escape sequence in character class\0"
+  "range out of order in character class\0"
+  "nothing to repeat\0"
+  /* 10 */
+  "internal error: invalid forward reference offset\0"
+  "internal error: unexpected repeat\0"
+  "unrecognized character after (? or (?-\0"
+  "POSIX named classes are supported only within a class\0"
+  "missing )\0"
+  /* 15 */
+  "reference to non-existent subpattern\0"
+  "erroffset passed as NULL\0"
+  "unknown option bit(s) set\0"
+  "missing ) after comment\0"
+  "parentheses nested too deeply\0"  /** DEAD **/
+  /* 20 */
+  "regular expression is too large\0"
+  "failed to get memory\0"
+  "unmatched parentheses\0"
+  "internal error: code overflow\0"
+  "unrecognized character after (?<\0"
+  /* 25 */
+  "lookbehind assertion is not fixed length\0"
+  "malformed number or name after (?(\0"
+  "conditional group contains more than two branches\0"
+  "assertion expected after (?( or (?(?C)\0"
+  "(?R or (?[+-]digits must be followed by )\0"
+  /* 30 */
+  "unknown POSIX class name\0"
+  "POSIX collating elements are not supported\0"
+  "this version of PCRE is compiled without UTF support\0"
+  "spare error\0"  /** DEAD **/
+  "character value in \\x{} or \\o{} is too large\0"
+  /* 35 */
+  "invalid condition (?(0)\0"
+  "\\C not allowed in lookbehind assertion\0"
+  "PCRE does not support \\L, \\l, \\N{name}, \\U, or \\u\0"
+  "number after (?C is > 255\0"
+  "closing ) for (?C expected\0"
+  /* 40 */
+  "recursive call could loop indefinitely\0"
+  "unrecognized character after (?P\0"
+  "syntax error in subpattern name (missing terminator)\0"
+  "two named subpatterns have the same name\0"
+  "invalid UTF-8 string\0"
+  /* 45 */
+  "support for \\P, \\p, and \\X has not been compiled\0"
+  "malformed \\P or \\p sequence\0"
+  "unknown property name after \\P or \\p\0"
+  "subpattern name is too long (maximum " XSTRING(MAX_NAME_SIZE) " characters)\0"
+  "too many named subpatterns (maximum " XSTRING(MAX_NAME_COUNT) ")\0"
+  /* 50 */
+  "repeated subpattern is too long\0"    /** DEAD **/
+  "octal value is greater than \\377 in 8-bit non-UTF-8 mode\0"
+  "internal error: overran compiling workspace\0"
+  "internal error: previously-checked referenced subpattern not found\0"
+  "DEFINE group contains more than one branch\0"
+  /* 55 */
+  "repeating a DEFINE group is not allowed\0"  /** DEAD **/
+  "inconsistent NEWLINE options\0"
+  "\\g is not followed by a braced, angle-bracketed, or quoted name/number or by a plain number\0"
+  "a numbered reference must not be zero\0"
+  "an argument is not allowed for (*ACCEPT), (*FAIL), or (*COMMIT)\0"
+  /* 60 */
+  "(*VERB) not recognized or malformed\0"
+  "number is too big\0"
+  "subpattern name expected\0"
+  "digit expected after (?+\0"
+  "] is an invalid data character in JavaScript compatibility mode\0"
+  /* 65 */
+  "different names for subpatterns of the same number are not allowed\0"
+  "(*MARK) must have an argument\0"
+  "this version of PCRE is not compiled with Unicode property support\0"
+#ifndef EBCDIC
+  "\\c must be followed by an ASCII character\0"
+#else
+  "\\c must be followed by a letter or one of [\\]^_?\0"
+#endif
+  "\\k is not followed by a braced, angle-bracketed, or quoted name\0"
+  /* 70 */
+  "internal error: unknown opcode in find_fixedlength()\0"
+  "\\N is not supported in a class\0"
+  "too many forward references\0"
+  "disallowed Unicode code point (>= 0xd800 && <= 0xdfff)\0"
+  "invalid UTF-16 string\0"
+  /* 75 */
+  "name is too long in (*MARK), (*PRUNE), (*SKIP), or (*THEN)\0"
+  "character value in \\u.... sequence is too large\0"
+  "invalid UTF-32 string\0"
+  "setting UTF is disabled by the application\0"
+  "non-hex character in \\x{} (closing brace missing?)\0"
+  /* 80 */
+  "non-octal character in \\o{} (closing brace missing?)\0"
+  "missing opening brace after \\o\0"
+  "parentheses are too deeply nested\0"
+  "invalid range in character class\0"
+  "group name must start with a non-digit\0"
+  /* 85 */
+  "parentheses are too deeply nested (stack check)\0"
+  "digits missing in \\x{} or \\o{}\0"
+  "regular expression is too complicated\0"
+  ;
+
+/* Table to identify digits and hex digits. This is used when compiling
+patterns. Note that the tables in chartables are dependent on the locale, and
+may mark arbitrary characters as digits - but the PCRE compiling code expects
+to handle only 0-9, a-z, and A-Z as digits when compiling. That is why we have
+a private table here. It costs 256 bytes, but it is a lot faster than doing
+character value tests (at least in some simple cases I timed), and in some
+applications one wants PCRE to compile efficiently as well as match
+efficiently.
+
+For convenience, we use the same bit definitions as in chartables:
+
+  0x04   decimal digit
+  0x08   hexadecimal digit
+
+Then we can use ctype_digit and ctype_xdigit in the code. */
+
+/* Using a simple comparison for decimal numbers rather than a memory read
+is much faster, and the resulting code is simpler (the compiler turns it
+into a subtraction and unsigned comparison). */
+
+#define IS_DIGIT(x) ((x) >= CHAR_0 && (x) <= CHAR_9)
+
+#ifndef EBCDIC
+
+/* This is the "normal" case, for ASCII systems, and EBCDIC systems running in
+UTF-8 mode. */
+
+static const pcre_uint8 digitab[] =
+  {
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   8- 15 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  16- 23 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - '  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  ( - /  */
+  0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /*  0 - 7  */
+  0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00, /*  8 - ?  */
+  0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /*  @ - G  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  H - O  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  P - W  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  X - _  */
+  0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /*  ` - g  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  h - o  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  p - w  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  x -127 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 128-135 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 136-143 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144-151 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 152-159 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160-167 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 168-175 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 176-183 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 192-199 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 200-207 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 208-215 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 216-223 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 224-231 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 232-239 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 240-247 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};/* 248-255 */
+
+#else
+
+/* This is the "abnormal" case, for EBCDIC systems not running in UTF-8 mode. */
+
+static const pcre_uint8 digitab[] =
+  {
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   0-  7  0 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   8- 15    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  16- 23 10 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  32- 39 20 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  40- 47    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  48- 55 30 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  56- 63    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - 71 40 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  72- |     */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  & - 87 50 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  88- 95    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  - -103 60 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 104- ?     */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 70 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- "     */
+  0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /* 128- g  80 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  h -143    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 144- p  90 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  q -159    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 160- x  A0 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  y -175    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  ^ -183 B0 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 184-191    */
+  0x00,0x08,0x08,0x08,0x08,0x08,0x08,0x00, /*  { - G  C0 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  H -207    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  } - P  D0 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  Q -223    */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  \ - X  E0 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  Y -239    */
+  0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c, /*  0 - 7  F0 */
+  0x0c,0x0c,0x00,0x00,0x00,0x00,0x00,0x00};/*  8 -255    */
+
+static const pcre_uint8 ebcdic_chartab[] = { /* chartable partial dup */
+  0x80,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /*   0-  7 */
+  0x00,0x00,0x00,0x00,0x01,0x01,0x00,0x00, /*   8- 15 */
+  0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /*  16- 23 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  24- 31 */
+  0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x00, /*  32- 39 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  40- 47 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  48- 55 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  56- 63 */
+  0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*    - 71 */
+  0x00,0x00,0x00,0x80,0x00,0x80,0x80,0x80, /*  72- |  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  & - 87 */
+  0x00,0x00,0x00,0x80,0x80,0x80,0x00,0x00, /*  88- 95 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  - -103 */
+  0x00,0x00,0x00,0x00,0x00,0x10,0x00,0x80, /* 104- ?  */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 112-119 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 120- "  */
+  0x00,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /* 128- g  */
+  0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  h -143 */
+  0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /* 144- p  */
+  0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  q -159 */
+  0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /* 160- x  */
+  0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  y -175 */
+  0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*  ^ -183 */
+  0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00, /* 184-191 */
+  0x80,0x1a,0x1a,0x1a,0x1a,0x1a,0x1a,0x12, /*  { - G  */
+  0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  H -207 */
+  0x00,0x12,0x12,0x12,0x12,0x12,0x12,0x12, /*  } - P  */
+  0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  Q -223 */
+  0x00,0x00,0x12,0x12,0x12,0x12,0x12,0x12, /*  \ - X  */
+  0x12,0x12,0x00,0x00,0x00,0x00,0x00,0x00, /*  Y -239 */
+  0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c,0x1c, /*  0 - 7  */
+  0x1c,0x1c,0x00,0x00,0x00,0x00,0x00,0x00};/*  8 -255 */
+#endif
+
+
+/* This table is used to check whether auto-possessification is possible
+between adjacent character-type opcodes. The left-hand (repeated) opcode is
+used to select the row, and the right-hand opcode is use to select the column.
+A value of 1 means that auto-possessification is OK. For example, the second
+value in the first row means that \D+\d can be turned into \D++\d.
+
+The Unicode property types (\P and \p) have to be present to fill out the table
+because of what their opcode values are, but the table values should always be
+zero because property types are handled separately in the code. The last four
+columns apply to items that cannot be repeated, so there is no need to have
+rows for them. Note that OP_DIGIT etc. are generated only when PCRE_UCP is
+*not* set. When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */
+
+#define APTROWS (LAST_AUTOTAB_LEFT_OP - FIRST_AUTOTAB_OP + 1)
+#define APTCOLS (LAST_AUTOTAB_RIGHT_OP - FIRST_AUTOTAB_OP + 1)
+
+static const pcre_uint8 autoposstab[APTROWS][APTCOLS] = {
+/* \D \d \S \s \W \w  . .+ \C \P \p \R \H \h \V \v \X \Z \z  $ $M */
+  { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },  /* \D */
+  { 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1 },  /* \d */
+  { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1 },  /* \S */
+  { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },  /* \s */
+  { 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },  /* \W */
+  { 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1 },  /* \w */
+  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0 },  /* .  */
+  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },  /* .+ */
+  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 },  /* \C */
+  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* \P */
+  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },  /* \p */
+  { 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 },  /* \R */
+  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 },  /* \H */
+  { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0 },  /* \h */
+  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0 },  /* \V */
+  { 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0 },  /* \v */
+  { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 }   /* \X */
+};
+
+
+/* This table is used to check whether auto-possessification is possible
+between adjacent Unicode property opcodes (OP_PROP and OP_NOTPROP). The
+left-hand (repeated) opcode is used to select the row, and the right-hand
+opcode is used to select the column. The values are as follows:
+
+  0   Always return FALSE (never auto-possessify)
+  1   Character groups are distinct (possessify if both are OP_PROP)
+  2   Check character categories in the same group (general or particular)
+  3   TRUE if the two opcodes are not the same (PROP vs NOTPROP)
+
+  4   Check left general category vs right particular category
+  5   Check right general category vs left particular category
+
+  6   Left alphanum vs right general category
+  7   Left space vs right general category
+  8   Left word vs right general category
+
+  9   Right alphanum vs left general category
+ 10   Right space vs left general category
+ 11   Right word vs left general category
+
+ 12   Left alphanum vs right particular category
+ 13   Left space vs right particular category
+ 14   Left word vs right particular category
+
+ 15   Right alphanum vs left particular category
+ 16   Right space vs left particular category
+ 17   Right word vs left particular category
+*/
+
+static const pcre_uint8 propposstab[PT_TABSIZE][PT_TABSIZE] = {
+/* ANY LAMP GC  PC  SC ALNUM SPACE PXSPACE WORD CLIST UCNC */
+  { 0,  0,  0,  0,  0,    0,    0,      0,   0,    0,   0 },  /* PT_ANY */
+  { 0,  3,  0,  0,  0,    3,    1,      1,   0,    0,   0 },  /* PT_LAMP */
+  { 0,  0,  2,  4,  0,    9,   10,     10,  11,    0,   0 },  /* PT_GC */
+  { 0,  0,  5,  2,  0,   15,   16,     16,  17,    0,   0 },  /* PT_PC */
+  { 0,  0,  0,  0,  2,    0,    0,      0,   0,    0,   0 },  /* PT_SC */
+  { 0,  3,  6, 12,  0,    3,    1,      1,   0,    0,   0 },  /* PT_ALNUM */
+  { 0,  1,  7, 13,  0,    1,    3,      3,   1,    0,   0 },  /* PT_SPACE */
+  { 0,  1,  7, 13,  0,    1,    3,      3,   1,    0,   0 },  /* PT_PXSPACE */
+  { 0,  0,  8, 14,  0,    0,    1,      1,   3,    0,   0 },  /* PT_WORD */
+  { 0,  0,  0,  0,  0,    0,    0,      0,   0,    0,   0 },  /* PT_CLIST */
+  { 0,  0,  0,  0,  0,    0,    0,      0,   0,    0,   3 }   /* PT_UCNC */
+};
+
+/* This table is used to check whether auto-possessification is possible
+between adjacent Unicode property opcodes (OP_PROP and OP_NOTPROP) when one
+specifies a general category and the other specifies a particular category. The
+row is selected by the general category and the column by the particular
+category. The value is 1 if the particular category is not part of the general
+category. */
+
+static const pcre_uint8 catposstab[7][30] = {
+/* Cc Cf Cn Co Cs Ll Lm Lo Lt Lu Mc Me Mn Nd Nl No Pc Pd Pe Pf Pi Po Ps Sc Sk Sm So Zl Zp Zs */
+  { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },  /* C */
+  { 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },  /* L */
+  { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },  /* M */
+  { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },  /* N */
+  { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1 },  /* P */
+  { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1 },  /* S */
+  { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0 }   /* Z */
+};
+
+/* This table is used when checking ALNUM, (PX)SPACE, SPACE, and WORD against
+a general or particular category. The properties in each row are those
+that apply to the character set in question. Duplication means that a little
+unnecessary work is done when checking, but this keeps things much simpler
+because they can all use the same code. For more details see the comment where
+this table is used.
+
+Note: SPACE and PXSPACE used to be different because Perl excluded VT from
+"space", but from Perl 5.18 it's included, so both categories are treated the
+same here. */
+
+static const pcre_uint8 posspropstab[3][4] = {
+  { ucp_L, ucp_N, ucp_N, ucp_Nl },  /* ALNUM, 3rd and 4th values redundant */
+  { ucp_Z, ucp_Z, ucp_C, ucp_Cc },  /* SPACE and PXSPACE, 2nd value redundant */
+  { ucp_L, ucp_N, ucp_P, ucp_Po }   /* WORD */
+};
+
+/* This table is used when converting repeating opcodes into possessified
+versions as a result of an explicit possessive quantifier such as ++. A zero
+value means there is no possessified version - in those cases the item in
+question must be wrapped in ONCE brackets. The table is truncated at OP_CALLOUT
+because all relevant opcodes are less than that. */
+
+static const pcre_uint8 opcode_possessify[] = {
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   /* 0 - 15  */
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,   /* 16 - 31 */
+
+  0,                       /* NOTI */
+  OP_POSSTAR, 0,           /* STAR, MINSTAR */
+  OP_POSPLUS, 0,           /* PLUS, MINPLUS */
+  OP_POSQUERY, 0,          /* QUERY, MINQUERY */
+  OP_POSUPTO, 0,           /* UPTO, MINUPTO */
+  0,                       /* EXACT */
+  0, 0, 0, 0,              /* POS{STAR,PLUS,QUERY,UPTO} */
+
+  OP_POSSTARI, 0,          /* STARI, MINSTARI */
+  OP_POSPLUSI, 0,          /* PLUSI, MINPLUSI */
+  OP_POSQUERYI, 0,         /* QUERYI, MINQUERYI */
+  OP_POSUPTOI, 0,          /* UPTOI, MINUPTOI */
+  0,                       /* EXACTI */
+  0, 0, 0, 0,              /* POS{STARI,PLUSI,QUERYI,UPTOI} */
+
+  OP_NOTPOSSTAR, 0,        /* NOTSTAR, NOTMINSTAR */
+  OP_NOTPOSPLUS, 0,        /* NOTPLUS, NOTMINPLUS */
+  OP_NOTPOSQUERY, 0,       /* NOTQUERY, NOTMINQUERY */
+  OP_NOTPOSUPTO, 0,        /* NOTUPTO, NOTMINUPTO */
+  0,                       /* NOTEXACT */
+  0, 0, 0, 0,              /* NOTPOS{STAR,PLUS,QUERY,UPTO} */
+
+  OP_NOTPOSSTARI, 0,       /* NOTSTARI, NOTMINSTARI */
+  OP_NOTPOSPLUSI, 0,       /* NOTPLUSI, NOTMINPLUSI */
+  OP_NOTPOSQUERYI, 0,      /* NOTQUERYI, NOTMINQUERYI */
+  OP_NOTPOSUPTOI, 0,       /* NOTUPTOI, NOTMINUPTOI */
+  0,                       /* NOTEXACTI */
+  0, 0, 0, 0,              /* NOTPOS{STARI,PLUSI,QUERYI,UPTOI} */
+
+  OP_TYPEPOSSTAR, 0,       /* TYPESTAR, TYPEMINSTAR */
+  OP_TYPEPOSPLUS, 0,       /* TYPEPLUS, TYPEMINPLUS */
+  OP_TYPEPOSQUERY, 0,      /* TYPEQUERY, TYPEMINQUERY */
+  OP_TYPEPOSUPTO, 0,       /* TYPEUPTO, TYPEMINUPTO */
+  0,                       /* TYPEEXACT */
+  0, 0, 0, 0,              /* TYPEPOS{STAR,PLUS,QUERY,UPTO} */
+
+  OP_CRPOSSTAR, 0,         /* CRSTAR, CRMINSTAR */
+  OP_CRPOSPLUS, 0,         /* CRPLUS, CRMINPLUS */
+  OP_CRPOSQUERY, 0,        /* CRQUERY, CRMINQUERY */
+  OP_CRPOSRANGE, 0,        /* CRRANGE, CRMINRANGE */
+  0, 0, 0, 0,              /* CRPOS{STAR,PLUS,QUERY,RANGE} */
+
+  0, 0, 0,                 /* CLASS, NCLASS, XCLASS */
+  0, 0,                    /* REF, REFI */
+  0, 0,                    /* DNREF, DNREFI */
+  0, 0                     /* RECURSE, CALLOUT */
+};
+
+
+
+/*************************************************
+*            Find an error text                  *
+*************************************************/
+
+/* The error texts are now all in one long string, to save on relocations. As
+some of the text is of unknown length, we can't use a table of offsets.
+Instead, just count through the strings. This is not a performance issue
+because it happens only when there has been a compilation error.
+
+Argument:   the error number
+Returns:    pointer to the error string
+*/
+
+static const char *
+find_error_text(int n)
+{
+const char *s = error_texts;
+for (; n > 0; n--)
+  {
+  while (*s++ != CHAR_NULL) {};
+  if (*s == CHAR_NULL) return "Error text not found (please report)";
+  }
+return s;
+}
+
+
+
+/*************************************************
+*           Expand the workspace                 *
+*************************************************/
+
+/* This function is called during the second compiling phase, if the number of
+forward references fills the existing workspace, which is originally a block on
+the stack. A larger block is obtained from malloc() unless the ultimate limit
+has been reached or the increase will be rather small.
+
+Argument: pointer to the compile data block
+Returns:  0 if all went well, else an error number
+*/
+
+static int
+expand_workspace(compile_data *cd)
+{
+pcre_uchar *newspace;
+int newsize = cd->workspace_size * 2;
+
+if (newsize > COMPILE_WORK_SIZE_MAX) newsize = COMPILE_WORK_SIZE_MAX;
+if (cd->workspace_size >= COMPILE_WORK_SIZE_MAX ||
+    newsize - cd->workspace_size < WORK_SIZE_SAFETY_MARGIN)
+ return ERR72;
+
+newspace = (PUBL(malloc))(IN_UCHARS(newsize));
+if (newspace == NULL) return ERR21;
+memcpy(newspace, cd->start_workspace, cd->workspace_size * sizeof(pcre_uchar));
+cd->hwm = (pcre_uchar *)newspace + (cd->hwm - cd->start_workspace);
+if (cd->workspace_size > COMPILE_WORK_SIZE)
+  (PUBL(free))((void *)cd->start_workspace);
+cd->start_workspace = newspace;
+cd->workspace_size = newsize;
+return 0;
+}
+
+
+
+/*************************************************
+*            Check for counted repeat            *
+*************************************************/
+
+/* This function is called when a '{' is encountered in a place where it might
+start a quantifier. It looks ahead to see if it really is a quantifier or not.
+It is only a quantifier if it is one of the forms {ddd} {ddd,} or {ddd,ddd}
+where the ddds are digits.
+
+Arguments:
+  p         pointer to the first char after '{'
+
+Returns:    TRUE or FALSE
+*/
+
+static BOOL
+is_counted_repeat(const pcre_uchar *p)
+{
+if (!IS_DIGIT(*p)) return FALSE;
+p++;
+while (IS_DIGIT(*p)) p++;
+if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;
+
+if (*p++ != CHAR_COMMA) return FALSE;
+if (*p == CHAR_RIGHT_CURLY_BRACKET) return TRUE;
+
+if (!IS_DIGIT(*p)) return FALSE;
+p++;
+while (IS_DIGIT(*p)) p++;
+
+return (*p == CHAR_RIGHT_CURLY_BRACKET);
+}
+
+
+
+/*************************************************
+*            Handle escapes                      *
+*************************************************/
+
+/* This function is called when a \ has been encountered. It either returns a
+positive value for a simple escape such as \n, or 0 for a data character which
+will be placed in chptr. A backreference to group n is returned as negative n.
+When UTF-8 is enabled, a positive value greater than 255 may be returned in
+chptr. On entry, ptr is pointing at the \. On exit, it is on the final
+character of the escape sequence.
+
+Arguments:
+  ptrptr         points to the pattern position pointer
+  chptr          points to a returned data character
+  errorcodeptr   points to the errorcode variable
+  bracount       number of previous extracting brackets
+  options        the options bits
+  isclass        TRUE if inside a character class
+
+Returns:         zero => a data character
+                 positive => a special escape sequence
+                 negative => a back reference
+                 on error, errorcodeptr is set
+*/
+
+static int
+check_escape(const pcre_uchar **ptrptr, pcre_uint32 *chptr, int *errorcodeptr,
+  int bracount, int options, BOOL isclass)
+{
+/* PCRE_UTF16 has the same value as PCRE_UTF8. */
+BOOL utf = (options & PCRE_UTF8) != 0;
+const pcre_uchar *ptr = *ptrptr + 1;
+pcre_uint32 c;
+int escape = 0;
+int i;
+
+GETCHARINCTEST(c, ptr);           /* Get character value, increment pointer */
+ptr--;                            /* Set pointer back to the last byte */
+
+/* If backslash is at the end of the pattern, it's an error. */
+
+if (c == CHAR_NULL) *errorcodeptr = ERR1;
+
+/* Non-alphanumerics are literals. For digits or letters, do an initial lookup
+in a table. A non-zero result is something that can be returned immediately.
+Otherwise further processing may be required. */
+
+#ifndef EBCDIC  /* ASCII/UTF-8 coding */
+/* Not alphanumeric */
+else if (c < CHAR_0 || c > CHAR_z) {}
+else if ((i = escapes[c - CHAR_0]) != 0)
+  { if (i > 0) c = (pcre_uint32)i; else escape = -i; }
+
+#else           /* EBCDIC coding */
+/* Not alphanumeric */
+else if (c < CHAR_a || (!MAX_255(c) || (ebcdic_chartab[c] & 0x0E) == 0)) {}
+else if ((i = escapes[c - 0x48]) != 0)  { if (i > 0) c = (pcre_uint32)i; else escape = -i; }
+#endif
+
+/* Escapes that need further processing, or are illegal. */
+
+else
+  {
+  const pcre_uchar *oldptr;
+  BOOL braced, negated, overflow;
+  int s;
+
+  switch (c)
+    {
+    /* A number of Perl escapes are not handled by PCRE. We give an explicit
+    error. */
+
+    case CHAR_l:
+    case CHAR_L:
+    *errorcodeptr = ERR37;
+    break;
+
+    case CHAR_u:
+    if ((options & PCRE_JAVASCRIPT_COMPAT) != 0)
+      {
+      /* In JavaScript, \u must be followed by four hexadecimal numbers.
+      Otherwise it is a lowercase u letter. */
+      if (MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0
+        && MAX_255(ptr[2]) && (digitab[ptr[2]] & ctype_xdigit) != 0
+        && MAX_255(ptr[3]) && (digitab[ptr[3]] & ctype_xdigit) != 0
+        && MAX_255(ptr[4]) && (digitab[ptr[4]] & ctype_xdigit) != 0)
+        {
+        c = 0;
+        for (i = 0; i < 4; ++i)
+          {
+          register pcre_uint32 cc = *(++ptr);
+#ifndef EBCDIC  /* ASCII/UTF-8 coding */
+          if (cc >= CHAR_a) cc -= 32;               /* Convert to upper case */
+          c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
+#else           /* EBCDIC coding */
+          if (cc >= CHAR_a && cc <= CHAR_z) cc += 64;  /* Convert to upper case */
+          c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
+#endif
+          }
+
+#if defined COMPILE_PCRE8
+        if (c > (utf ? 0x10ffffU : 0xffU))
+#elif defined COMPILE_PCRE16
+        if (c > (utf ? 0x10ffffU : 0xffffU))
+#elif defined COMPILE_PCRE32
+        if (utf && c > 0x10ffffU)
+#endif
+          {
+          *errorcodeptr = ERR76;
+          }
+        else if (utf && c >= 0xd800 && c <= 0xdfff) *errorcodeptr = ERR73;
+        }
+      }
+    else
+      *errorcodeptr = ERR37;
+    break;
+
+    case CHAR_U:
+    /* In JavaScript, \U is an uppercase U letter. */
+    if ((options & PCRE_JAVASCRIPT_COMPAT) == 0) *errorcodeptr = ERR37;
+    break;
+
+    /* In a character class, \g is just a literal "g". Outside a character
+    class, \g must be followed by one of a number of specific things:
+
+    (1) A number, either plain or braced. If positive, it is an absolute
+    backreference. If negative, it is a relative backreference. This is a Perl
+    5.10 feature.
+
+    (2) Perl 5.10 also supports \g{name} as a reference to a named group. This
+    is part of Perl's movement towards a unified syntax for back references. As
+    this is synonymous with \k{name}, we fudge it up by pretending it really
+    was \k.
+
+    (3) For Oniguruma compatibility we also support \g followed by a name or a
+    number either in angle brackets or in single quotes. However, these are
+    (possibly recursive) subroutine calls, _not_ backreferences. Just return
+    the ESC_g code (cf \k). */
+
+    case CHAR_g:
+    if (isclass) break;
+    if (ptr[1] == CHAR_LESS_THAN_SIGN || ptr[1] == CHAR_APOSTROPHE)
+      {
+      escape = ESC_g;
+      break;
+      }
+
+    /* Handle the Perl-compatible cases */
+
+    if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)
+      {
+      const pcre_uchar *p;
+      for (p = ptr+2; *p != CHAR_NULL && *p != CHAR_RIGHT_CURLY_BRACKET; p++)
+        if (*p != CHAR_MINUS && !IS_DIGIT(*p)) break;
+      if (*p != CHAR_NULL && *p != CHAR_RIGHT_CURLY_BRACKET)
+        {
+        escape = ESC_k;
+        break;
+        }
+      braced = TRUE;
+      ptr++;
+      }
+    else braced = FALSE;
+
+    if (ptr[1] == CHAR_MINUS)
+      {
+      negated = TRUE;
+      ptr++;
+      }
+    else negated = FALSE;
+
+    /* The integer range is limited by the machine's int representation. */
+    s = 0;
+    overflow = FALSE;
+    while (IS_DIGIT(ptr[1]))
+      {
+      if (s > INT_MAX / 10 - 1) /* Integer overflow */
+        {
+        overflow = TRUE;
+        break;
+        }
+      s = s * 10 + (int)(*(++ptr) - CHAR_0);
+      }
+    if (overflow) /* Integer overflow */
+      {
+      while (IS_DIGIT(ptr[1]))
+        ptr++;
+      *errorcodeptr = ERR61;
+      break;
+      }
+
+    if (braced && *(++ptr) != CHAR_RIGHT_CURLY_BRACKET)
+      {
+      *errorcodeptr = ERR57;
+      break;
+      }
+
+    if (s == 0)
+      {
+      *errorcodeptr = ERR58;
+      break;
+      }
+
+    if (negated)
+      {
+      if (s > bracount)
+        {
+        *errorcodeptr = ERR15;
+        break;
+        }
+      s = bracount - (s - 1);
+      }
+
+    escape = -s;
+    break;
+
+    /* The handling of escape sequences consisting of a string of digits
+    starting with one that is not zero is not straightforward. Perl has changed
+    over the years. Nowadays \g{} for backreferences and \o{} for octal are
+    recommended to avoid the ambiguities in the old syntax.
+
+    Outside a character class, the digits are read as a decimal number. If the
+    number is less than 8 (used to be 10), or if there are that many previous
+    extracting left brackets, then it is a back reference. Otherwise, up to
+    three octal digits are read to form an escaped byte. Thus \123 is likely to
+    be octal 123 (cf \0123, which is octal 012 followed by the literal 3). If
+    the octal value is greater than 377, the least significant 8 bits are
+    taken. \8 and \9 are treated as the literal characters 8 and 9.
+
+    Inside a character class, \ followed by a digit is always either a literal
+    8 or 9 or an octal number. */
+
+    case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4: case CHAR_5:
+    case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9:
+
+    if (!isclass)
+      {
+      oldptr = ptr;
+      /* The integer range is limited by the machine's int representation. */
+      s = (int)(c -CHAR_0);
+      overflow = FALSE;
+      while (IS_DIGIT(ptr[1]))
+        {
+        if (s > INT_MAX / 10 - 1) /* Integer overflow */
+          {
+          overflow = TRUE;
+          break;
+          }
+        s = s * 10 + (int)(*(++ptr) - CHAR_0);
+        }
+      if (overflow) /* Integer overflow */
+        {
+        while (IS_DIGIT(ptr[1]))
+          ptr++;
+        *errorcodeptr = ERR61;
+        break;
+        }
+      if (s < 8 || s <= bracount)  /* Check for back reference */
+        {
+        escape = -s;
+        break;
+        }
+      ptr = oldptr;      /* Put the pointer back and fall through */
+      }
+
+    /* Handle a digit following \ when the number is not a back reference. If
+    the first digit is 8 or 9, Perl used to generate a binary zero byte and
+    then treat the digit as a following literal. At least by Perl 5.18 this
+    changed so as not to insert the binary zero. */
+
+    if ((c = *ptr) >= CHAR_8) break;
+
+    /* Fall through with a digit less than 8 */
+
+    /* \0 always starts an octal number, but we may drop through to here with a
+    larger first octal digit. The original code used just to take the least
+    significant 8 bits of octal numbers (I think this is what early Perls used
+    to do). Nowadays we allow for larger numbers in UTF-8 mode and 16-bit mode,
+    but no more than 3 octal digits. */
+
+    case CHAR_0:
+    c -= CHAR_0;
+    while(i++ < 2 && ptr[1] >= CHAR_0 && ptr[1] <= CHAR_7)
+        c = c * 8 + *(++ptr) - CHAR_0;
+#ifdef COMPILE_PCRE8
+    if (!utf && c > 0xff) *errorcodeptr = ERR51;
+#endif
+    break;
+
+    /* \o is a relatively new Perl feature, supporting a more general way of
+    specifying character codes in octal. The only supported form is \o{ddd}. */
+
+    case CHAR_o:
+    if (ptr[1] != CHAR_LEFT_CURLY_BRACKET) *errorcodeptr = ERR81; else
+    if (ptr[2] == CHAR_RIGHT_CURLY_BRACKET) *errorcodeptr = ERR86; else
+      {
+      ptr += 2;
+      c = 0;
+      overflow = FALSE;
+      while (*ptr >= CHAR_0 && *ptr <= CHAR_7)
+        {
+        register pcre_uint32 cc = *ptr++;
+        if (c == 0 && cc == CHAR_0) continue;     /* Leading zeroes */
+#ifdef COMPILE_PCRE32
+        if (c >= 0x20000000l) { overflow = TRUE; break; }
+#endif
+        c = (c << 3) + cc - CHAR_0 ;
+#if defined COMPILE_PCRE8
+        if (c > (utf ? 0x10ffffU : 0xffU)) { overflow = TRUE; break; }
+#elif defined COMPILE_PCRE16
+        if (c > (utf ? 0x10ffffU : 0xffffU)) { overflow = TRUE; break; }
+#elif defined COMPILE_PCRE32
+        if (utf && c > 0x10ffffU) { overflow = TRUE; break; }
+#endif
+        }
+      if (overflow)
+        {
+        while (*ptr >= CHAR_0 && *ptr <= CHAR_7) ptr++;
+        *errorcodeptr = ERR34;
+        }
+      else if (*ptr == CHAR_RIGHT_CURLY_BRACKET)
+        {
+        if (utf && c >= 0xd800 && c <= 0xdfff) *errorcodeptr = ERR73;
+        }
+      else *errorcodeptr = ERR80;
+      }
+    break;
+
+    /* \x is complicated. In JavaScript, \x must be followed by two hexadecimal
+    numbers. Otherwise it is a lowercase x letter. */
+
+    case CHAR_x:
+    if ((options & PCRE_JAVASCRIPT_COMPAT) != 0)
+      {
+      if (MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0
+        && MAX_255(ptr[2]) && (digitab[ptr[2]] & ctype_xdigit) != 0)
+        {
+        c = 0;
+        for (i = 0; i < 2; ++i)
+          {
+          register pcre_uint32 cc = *(++ptr);
+#ifndef EBCDIC  /* ASCII/UTF-8 coding */
+          if (cc >= CHAR_a) cc -= 32;               /* Convert to upper case */
+          c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
+#else           /* EBCDIC coding */
+          if (cc >= CHAR_a && cc <= CHAR_z) cc += 64;  /* Convert to upper case */
+          c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
+#endif
+          }
+        }
+      }    /* End JavaScript handling */
+
+    /* Handle \x in Perl's style. \x{ddd} is a character number which can be
+    greater than 0xff in utf or non-8bit mode, but only if the ddd are hex
+    digits. If not, { used to be treated as a data character. However, Perl
+    seems to read hex digits up to the first non-such, and ignore the rest, so
+    that, for example \x{zz} matches a binary zero. This seems crazy, so PCRE
+    now gives an error. */
+
+    else
+      {
+      if (ptr[1] == CHAR_LEFT_CURLY_BRACKET)
+        {
+        ptr += 2;
+        if (*ptr == CHAR_RIGHT_CURLY_BRACKET)
+          {
+          *errorcodeptr = ERR86;
+          break;
+          }
+        c = 0;
+        overflow = FALSE;
+        while (MAX_255(*ptr) && (digitab[*ptr] & ctype_xdigit) != 0)
+          {
+          register pcre_uint32 cc = *ptr++;
+          if (c == 0 && cc == CHAR_0) continue;     /* Leading zeroes */
+
+#ifdef COMPILE_PCRE32
+          if (c >= 0x10000000l) { overflow = TRUE; break; }
+#endif
+
+#ifndef EBCDIC  /* ASCII/UTF-8 coding */
+          if (cc >= CHAR_a) cc -= 32;               /* Convert to upper case */
+          c = (c << 4) + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
+#else           /* EBCDIC coding */
+          if (cc >= CHAR_a && cc <= CHAR_z) cc += 64;  /* Convert to upper case */
+          c = (c << 4) + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
+#endif
+
+#if defined COMPILE_PCRE8
+          if (c > (utf ? 0x10ffffU : 0xffU)) { overflow = TRUE; break; }
+#elif defined COMPILE_PCRE16
+          if (c > (utf ? 0x10ffffU : 0xffffU)) { overflow = TRUE; break; }
+#elif defined COMPILE_PCRE32
+          if (utf && c > 0x10ffffU) { overflow = TRUE; break; }
+#endif
+          }
+
+        if (overflow)
+          {
+          while (MAX_255(*ptr) && (digitab[*ptr] & ctype_xdigit) != 0) ptr++;
+          *errorcodeptr = ERR34;
+          }
+
+        else if (*ptr == CHAR_RIGHT_CURLY_BRACKET)
+          {
+          if (utf && c >= 0xd800 && c <= 0xdfff) *errorcodeptr = ERR73;
+          }
+
+        /* If the sequence of hex digits does not end with '}', give an error.
+        We used just to recognize this construct and fall through to the normal
+        \x handling, but nowadays Perl gives an error, which seems much more
+        sensible, so we do too. */
+
+        else *errorcodeptr = ERR79;
+        }   /* End of \x{} processing */
+
+      /* Read a single-byte hex-defined char (up to two hex digits after \x) */
+
+      else
+        {
+        c = 0;
+        while (i++ < 2 && MAX_255(ptr[1]) && (digitab[ptr[1]] & ctype_xdigit) != 0)
+          {
+          pcre_uint32 cc;                          /* Some compilers don't like */
+          cc = *(++ptr);                           /* ++ in initializers */
+#ifndef EBCDIC  /* ASCII/UTF-8 coding */
+          if (cc >= CHAR_a) cc -= 32;              /* Convert to upper case */
+          c = c * 16 + cc - ((cc < CHAR_A)? CHAR_0 : (CHAR_A - 10));
+#else           /* EBCDIC coding */
+          if (cc <= CHAR_z) cc += 64;              /* Convert to upper case */
+          c = c * 16 + cc - ((cc >= CHAR_0)? CHAR_0 : (CHAR_A - 10));
+#endif
+          }
+        }     /* End of \xdd handling */
+      }       /* End of Perl-style \x handling */
+    break;
+
+    /* For \c, a following letter is upper-cased; then the 0x40 bit is flipped.
+    An error is given if the byte following \c is not an ASCII character. This
+    coding is ASCII-specific, but then the whole concept of \cx is
+    ASCII-specific. (However, an EBCDIC equivalent has now been added.) */
+
+    case CHAR_c:
+    c = *(++ptr);
+    if (c == CHAR_NULL)
+      {
+      *errorcodeptr = ERR2;
+      break;
+      }
+#ifndef EBCDIC    /* ASCII/UTF-8 coding */
+    if (c > 127)  /* Excludes all non-ASCII in either mode */
+      {
+      *errorcodeptr = ERR68;
+      break;
+      }
+    if (c >= CHAR_a && c <= CHAR_z) c -= 32;
+    c ^= 0x40;
+#else             /* EBCDIC coding */
+    if (c >= CHAR_a && c <= CHAR_z) c += 64;
+    if (c == CHAR_QUESTION_MARK)
+      c = ('\\' == 188 && '`' == 74)? 0x5f : 0xff;
+    else
+      {
+      for (i = 0; i < 32; i++)
+        {
+        if (c == ebcdic_escape_c[i]) break;
+        }
+      if (i < 32) c = i; else *errorcodeptr = ERR68;
+      }
+#endif
+    break;
+
+    /* PCRE_EXTRA enables extensions to Perl in the matter of escapes. Any
+    other alphanumeric following \ is an error if PCRE_EXTRA was set;
+    otherwise, for Perl compatibility, it is a literal. This code looks a bit
+    odd, but there used to be some cases other than the default, and there may
+    be again in future, so I haven't "optimized" it. */
+
+    default:
+    if ((options & PCRE_EXTRA) != 0) switch(c)
+      {
+      default:
+      *errorcodeptr = ERR3;
+      break;
+      }
+    break;
+    }
+  }
+
+/* Perl supports \N{name} for character names, as well as plain \N for "not
+newline". PCRE does not support \N{name}. However, it does support
+quantification such as \N{2,3}. */
+
+if (escape == ESC_N && ptr[1] == CHAR_LEFT_CURLY_BRACKET &&
+     !is_counted_repeat(ptr+2))
+  *errorcodeptr = ERR37;
+
+/* If PCRE_UCP is set, we change the values for \d etc. */
+
+if ((options & PCRE_UCP) != 0 && escape >= ESC_D && escape <= ESC_w)
+  escape += (ESC_DU - ESC_D);
+
+/* Set the pointer to the final character before returning. */
+
+*ptrptr = ptr;
+*chptr = c;
+return escape;
+}
+
+
+
+#ifdef SUPPORT_UCP
+/*************************************************
+*               Handle \P and \p                 *
+*************************************************/
+
+/* This function is called after \P or \p has been encountered, provided that
+PCRE is compiled with support for Unicode properties. On entry, ptrptr is
+pointing at the P or p. On exit, it is pointing at the final character of the
+escape sequence.
+
+Argument:
+  ptrptr         points to the pattern position pointer
+  negptr         points to a boolean that is set TRUE for negation else FALSE
+  ptypeptr       points to an unsigned int that is set to the type value
+  pdataptr       points to an unsigned int that is set to the detailed property value
+  errorcodeptr   points to the error code variable
+
+Returns:         TRUE if the type value was found, or FALSE for an invalid type
+*/
+
+static BOOL
+get_ucp(const pcre_uchar **ptrptr, BOOL *negptr, unsigned int *ptypeptr,
+  unsigned int *pdataptr, int *errorcodeptr)
+{
+pcre_uchar c;
+int i, bot, top;
+const pcre_uchar *ptr = *ptrptr;
+pcre_uchar name[32];
+
+c = *(++ptr);
+if (c == CHAR_NULL) goto ERROR_RETURN;
+
+*negptr = FALSE;
+
+/* \P or \p can be followed by a name in {}, optionally preceded by ^ for
+negation. */
+
+if (c == CHAR_LEFT_CURLY_BRACKET)
+  {
+  if (ptr[1] == CHAR_CIRCUMFLEX_ACCENT)
+    {
+    *negptr = TRUE;
+    ptr++;
+    }
+  for (i = 0; i < (int)(sizeof(name) / sizeof(pcre_uchar)) - 1; i++)
+    {
+    c = *(++ptr);
+    if (c == CHAR_NULL) goto ERROR_RETURN;
+    if (c == CHAR_RIGHT_CURLY_BRACKET) break;
+    name[i] = c;
+    }
+  if (c != CHAR_RIGHT_CURLY_BRACKET) goto ERROR_RETURN;
+  name[i] = 0;
+  }
+
+/* Otherwise there is just one following character */
+
+else
+  {
+  name[0] = c;
+  name[1] = 0;
+  }
+
+*ptrptr = ptr;
+
+/* Search for a recognized property name using binary chop */
+
+bot = 0;
+top = PRIV(utt_size);
+
+while (bot < top)
+  {
+  int r;
+  i = (bot + top) >> 1;
+  r = STRCMP_UC_C8(name, PRIV(utt_names) + PRIV(utt)[i].name_offset);
+  if (r == 0)
+    {
+    *ptypeptr = PRIV(utt)[i].type;
+    *pdataptr = PRIV(utt)[i].value;
+    return TRUE;
+    }
+  if (r > 0) bot = i + 1; else top = i;
+  }
+
+*errorcodeptr = ERR47;
+*ptrptr = ptr;
+return FALSE;
+
+ERROR_RETURN:
+*errorcodeptr = ERR46;
+*ptrptr = ptr;
+return FALSE;
+}
+#endif
+
+
+
+/*************************************************
+*         Read repeat counts                     *
+*************************************************/
+
+/* Read an item of the form {n,m} and return the values. This is called only
+after is_counted_repeat() has confirmed that a repeat-count quantifier exists,
+so the syntax is guaranteed to be correct, but we need to check the values.
+
+Arguments:
+  p              pointer to first char after '{'
+  minp           pointer to int for min
+  maxp           pointer to int for max
+                 returned as -1 if no max
+  errorcodeptr   points to error code variable
+
+Returns:         pointer to '}' on success;
+                 current ptr on error, with errorcodeptr set non-zero
+*/
+
+static const pcre_uchar *
+read_repeat_counts(const pcre_uchar *p, int *minp, int *maxp, int *errorcodeptr)
+{
+int min = 0;
+int max = -1;
+
+while (IS_DIGIT(*p))
+  {
+  min = min * 10 + (int)(*p++ - CHAR_0);
+  if (min > 65535)
+    {
+    *errorcodeptr = ERR5;
+    return p;
+    }
+  }
+
+if (*p == CHAR_RIGHT_CURLY_BRACKET) max = min; else
+  {
+  if (*(++p) != CHAR_RIGHT_CURLY_BRACKET)
+    {
+    max = 0;
+    while(IS_DIGIT(*p))
+      {
+      max = max * 10 + (int)(*p++ - CHAR_0);
+      if (max > 65535)
+        {
+        *errorcodeptr = ERR5;
+        return p;
+        }
+      }
+    if (max < min)
+      {
+      *errorcodeptr = ERR4;
+      return p;
+      }
+    }
+  }
+
+*minp = min;
+*maxp = max;
+return p;
+}
+
+
+
+/*************************************************
+*      Find first significant op code            *
+*************************************************/
+
+/* This is called by several functions that scan a compiled expression looking
+for a fixed first character, or an anchoring op code etc. It skips over things
+that do not influence this. For some calls, it makes sense to skip negative
+forward and all backward assertions, and also the \b assertion; for others it
+does not.
+
+Arguments:
+  code         pointer to the start of the group
+  skipassert   TRUE if certain assertions are to be skipped
+
+Returns:       pointer to the first significant opcode
+*/
+
+static const pcre_uchar*
+first_significant_code(const pcre_uchar *code, BOOL skipassert)
+{
+for (;;)
+  {
+  switch ((int)*code)
+    {
+    case OP_ASSERT_NOT:
+    case OP_ASSERTBACK:
+    case OP_ASSERTBACK_NOT:
+    if (!skipassert) return code;
+    do code += GET(code, 1); while (*code == OP_ALT);
+    code += PRIV(OP_lengths)[*code];
+    break;
+
+    case OP_WORD_BOUNDARY:
+    case OP_NOT_WORD_BOUNDARY:
+    if (!skipassert) return code;
+    /* Fall through */
+
+    case OP_CALLOUT:
+    case OP_CREF:
+    case OP_DNCREF:
+    case OP_RREF:
+    case OP_DNRREF:
+    case OP_DEF:
+    code += PRIV(OP_lengths)[*code];
+    break;
+
+    default:
+    return code;
+    }
+  }
+/* Control never reaches here */
+}
+
+
+
+/*************************************************
+*        Find the fixed length of a branch       *
+*************************************************/
+
+/* Scan a branch and compute the fixed length of subject that will match it,
+if the length is fixed. This is needed for dealing with backward assertions.
+In UTF8 mode, the result is in characters rather than bytes. The branch is
+temporarily terminated with OP_END when this function is called.
+
+This function is called when a backward assertion is encountered, so that if it
+fails, the error message can point to the correct place in the pattern.
+However, we cannot do this when the assertion contains subroutine calls,
+because they can be forward references. We solve this by remembering this case
+and doing the check at the end; a flag specifies which mode we are running in.
+
+Arguments:
+  code     points to the start of the pattern (the bracket)
+  utf      TRUE in UTF-8 / UTF-16 / UTF-32 mode
+  atend    TRUE if called when the pattern is complete
+  cd       the "compile data" structure
+  recurses    chain of recurse_check to catch mutual recursion
+
+Returns:   the fixed length,
+             or -1 if there is no fixed length,
+             or -2 if \C was encountered (in UTF-8 mode only)
+             or -3 if an OP_RECURSE item was encountered and atend is FALSE
+             or -4 if an unknown opcode was encountered (internal error)
+*/
+
+static int
+find_fixedlength(pcre_uchar *code, BOOL utf, BOOL atend, compile_data *cd,
+  recurse_check *recurses)
+{
+int length = -1;
+recurse_check this_recurse;
+register int branchlength = 0;
+register pcre_uchar *cc = code + 1 + LINK_SIZE;
+
+/* Scan along the opcodes for this branch. If we get to the end of the
+branch, check the length against that of the other branches. */
+
+for (;;)
+  {
+  int d;
+  pcre_uchar *ce, *cs;
+  register pcre_uchar op = *cc;
+
+  switch (op)
+    {
+    /* We only need to continue for OP_CBRA (normal capturing bracket) and
+    OP_BRA (normal non-capturing bracket) because the other variants of these
+    opcodes are all concerned with unlimited repeated groups, which of course
+    are not of fixed length. */
+
+    case OP_CBRA:
+    case OP_BRA:
+    case OP_ONCE:
+    case OP_ONCE_NC:
+    case OP_COND:
+    d = find_fixedlength(cc + ((op == OP_CBRA)? IMM2_SIZE : 0), utf, atend, cd,
+      recurses);
+    if (d < 0) return d;
+    branchlength += d;
+    do cc += GET(cc, 1); while (*cc == OP_ALT);
+    cc += 1 + LINK_SIZE;
+    break;
+
+    /* Reached end of a branch; if it's a ket it is the end of a nested call.
+    If it's ALT it is an alternation in a nested call. An ACCEPT is effectively
+    an ALT. If it is END it's the end of the outer call. All can be handled by
+    the same code. Note that we must not include the OP_KETRxxx opcodes here,
+    because they all imply an unlimited repeat. */
+
+    case OP_ALT:
+    case OP_KET:
+    case OP_END:
+    case OP_ACCEPT:
+    case OP_ASSERT_ACCEPT:
+    if (length < 0) length = branchlength;
+      else if (length != branchlength) return -1;
+    if (*cc != OP_ALT) return length;
+    cc += 1 + LINK_SIZE;
+    branchlength = 0;
+    break;
+
+    /* A true recursion implies not fixed length, but a subroutine call may
+    be OK. If the subroutine is a forward reference, we can't deal with
+    it until the end of the pattern, so return -3. */
+
+    case OP_RECURSE:
+    if (!atend) return -3;
+    cs = ce = (pcre_uchar *)cd->start_code + GET(cc, 1);  /* Start subpattern */
+    do ce += GET(ce, 1); while (*ce == OP_ALT);           /* End subpattern */
+    if (cc > cs && cc < ce) return -1;                    /* Recursion */
+    else   /* Check for mutual recursion */
+      {
+      recurse_check *r = recurses;
+      for (r = recurses; r != NULL; r = r->prev) if (r->group == cs) break;
+      if (r != NULL) return -1;   /* Mutual recursion */
+      }
+    this_recurse.prev = recurses;
+    this_recurse.group = cs;
+    d = find_fixedlength(cs + IMM2_SIZE, utf, atend, cd, &this_recurse);
+    if (d < 0) return d;
+    branchlength += d;
+    cc += 1 + LINK_SIZE;
+    break;
+
+    /* Skip over assertive subpatterns */
+
+    case OP_ASSERT:
+    case OP_ASSERT_NOT:
+    case OP_ASSERTBACK:
+    case OP_ASSERTBACK_NOT:
+    do cc += GET(cc, 1); while (*cc == OP_ALT);
+    cc += 1 + LINK_SIZE;
+    break;
+
+    /* Skip over things that don't match chars */
+
+    case OP_MARK:
+    case OP_PRUNE_ARG:
+    case OP_SKIP_ARG:
+    case OP_THEN_ARG:
+    cc += cc[1] + PRIV(OP_lengths)[*cc];
+    break;
+
+    case OP_CALLOUT:
+    case OP_CIRC:
+    case OP_CIRCM:
+    case OP_CLOSE:
+    case OP_COMMIT:
+    case OP_CREF:
+    case OP_DEF:
+    case OP_DNCREF:
+    case OP_DNRREF:
+    case OP_DOLL:
+    case OP_DOLLM:
+    case OP_EOD:
+    case OP_EODN:
+    case OP_FAIL:
+    case OP_NOT_WORD_BOUNDARY:
+    case OP_PRUNE:
+    case OP_REVERSE:
+    case OP_RREF:
+    case OP_SET_SOM:
+    case OP_SKIP:
+    case OP_SOD:
+    case OP_SOM:
+    case OP_THEN:
+    case OP_WORD_BOUNDARY:
+    cc += PRIV(OP_lengths)[*cc];
+    break;
+
+    /* Handle literal characters */
+
+    case OP_CHAR:
+    case OP_CHARI:
+    case OP_NOT:
+    case OP_NOTI:
+    branchlength++;
+    cc += 2;
+#ifdef SUPPORT_UTF
+    if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+#endif
+    break;
+
+    /* Handle exact repetitions. The count is already in characters, but we
+    need to skip over a multibyte character in UTF8 mode.  */
+
+    case OP_EXACT:
+    case OP_EXACTI:
+    case OP_NOTEXACT:
+    case OP_NOTEXACTI:
+    branchlength += (int)GET2(cc,1);
+    cc += 2 + IMM2_SIZE;
+#ifdef SUPPORT_UTF
+    if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+#endif
+    break;
+
+    case OP_TYPEEXACT:
+    branchlength += GET2(cc,1);
+    if (cc[1 + IMM2_SIZE] == OP_PROP || cc[1 + IMM2_SIZE] == OP_NOTPROP)
+      cc += 2;
+    cc += 1 + IMM2_SIZE + 1;
+    break;
+
+    /* Handle single-char matchers */
+
+    case OP_PROP:
+    case OP_NOTPROP:
+    cc += 2;
+    /* Fall through */
+
+    case OP_HSPACE:
+    case OP_VSPACE:
+    case OP_NOT_HSPACE:
+    case OP_NOT_VSPACE:
+    case OP_NOT_DIGIT:
+    case OP_DIGIT:
+    case OP_NOT_WHITESPACE:
+    case OP_WHITESPACE:
+    case OP_NOT_WORDCHAR:
+    case OP_WORDCHAR:
+    case OP_ANY:
+    case OP_ALLANY:
+    branchlength++;
+    cc++;
+    break;
+
+    /* The single-byte matcher isn't allowed. This only happens in UTF-8 mode;
+    otherwise \C is coded as OP_ALLANY. */
+
+    case OP_ANYBYTE:
+    return -2;
+
+    /* Check a class for variable quantification */
+
+    case OP_CLASS:
+    case OP_NCLASS:
+#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+    case OP_XCLASS:
+    /* The original code caused an unsigned overflow in 64 bit systems,
+    so now we use a conditional statement. */
+    if (op == OP_XCLASS)
+      cc += GET(cc, 1);
+    else
+      cc += PRIV(OP_lengths)[OP_CLASS];
+#else
+    cc += PRIV(OP_lengths)[OP_CLASS];
+#endif
+
+    switch (*cc)
+      {
+      case OP_CRSTAR:
+      case OP_CRMINSTAR:
+      case OP_CRPLUS:
+      case OP_CRMINPLUS:
+      case OP_CRQUERY:
+      case OP_CRMINQUERY:
+      case OP_CRPOSSTAR:
+      case OP_CRPOSPLUS:
+      case OP_CRPOSQUERY:
+      return -1;
+
+      case OP_CRRANGE:
+      case OP_CRMINRANGE:
+      case OP_CRPOSRANGE:
+      if (GET2(cc,1) != GET2(cc,1+IMM2_SIZE)) return -1;
+      branchlength += (int)GET2(cc,1);
+      cc += 1 + 2 * IMM2_SIZE;
+      break;
+
+      default:
+      branchlength++;
+      }
+    break;
+
+    /* Anything else is variable length */
+
+    case OP_ANYNL:
+    case OP_BRAMINZERO:
+    case OP_BRAPOS:
+    case OP_BRAPOSZERO:
+    case OP_BRAZERO:
+    case OP_CBRAPOS:
+    case OP_EXTUNI:
+    case OP_KETRMAX:
+    case OP_KETRMIN:
+    case OP_KETRPOS:
+    case OP_MINPLUS:
+    case OP_MINPLUSI:
+    case OP_MINQUERY:
+    case OP_MINQUERYI:
+    case OP_MINSTAR:
+    case OP_MINSTARI:
+    case OP_MINUPTO:
+    case OP_MINUPTOI:
+    case OP_NOTMINPLUS:
+    case OP_NOTMINPLUSI:
+    case OP_NOTMINQUERY:
+    case OP_NOTMINQUERYI:
+    case OP_NOTMINSTAR:
+    case OP_NOTMINSTARI:
+    case OP_NOTMINUPTO:
+    case OP_NOTMINUPTOI:
+    case OP_NOTPLUS:
+    case OP_NOTPLUSI:
+    case OP_NOTPOSPLUS:
+    case OP_NOTPOSPLUSI:
+    case OP_NOTPOSQUERY:
+    case OP_NOTPOSQUERYI:
+    case OP_NOTPOSSTAR:
+    case OP_NOTPOSSTARI:
+    case OP_NOTPOSUPTO:
+    case OP_NOTPOSUPTOI:
+    case OP_NOTQUERY:
+    case OP_NOTQUERYI:
+    case OP_NOTSTAR:
+    case OP_NOTSTARI:
+    case OP_NOTUPTO:
+    case OP_NOTUPTOI:
+    case OP_PLUS:
+    case OP_PLUSI:
+    case OP_POSPLUS:
+    case OP_POSPLUSI:
+    case OP_POSQUERY:
+    case OP_POSQUERYI:
+    case OP_POSSTAR:
+    case OP_POSSTARI:
+    case OP_POSUPTO:
+    case OP_POSUPTOI:
+    case OP_QUERY:
+    case OP_QUERYI:
+    case OP_REF:
+    case OP_REFI:
+    case OP_DNREF:
+    case OP_DNREFI:
+    case OP_SBRA:
+    case OP_SBRAPOS:
+    case OP_SCBRA:
+    case OP_SCBRAPOS:
+    case OP_SCOND:
+    case OP_SKIPZERO:
+    case OP_STAR:
+    case OP_STARI:
+    case OP_TYPEMINPLUS:
+    case OP_TYPEMINQUERY:
+    case OP_TYPEMINSTAR:
+    case OP_TYPEMINUPTO:
+    case OP_TYPEPLUS:
+    case OP_TYPEPOSPLUS:
+    case OP_TYPEPOSQUERY:
+    case OP_TYPEPOSSTAR:
+    case OP_TYPEPOSUPTO:
+    case OP_TYPEQUERY:
+    case OP_TYPESTAR:
+    case OP_TYPEUPTO:
+    case OP_UPTO:
+    case OP_UPTOI:
+    return -1;
+
+    /* Catch unrecognized opcodes so that when new ones are added they
+    are not forgotten, as has happened in the past. */
+
+    default:
+    return -4;
+    }
+  }
+/* Control never gets here */
+}
+
+
+
+/*************************************************
+*    Scan compiled regex for specific bracket    *
+*************************************************/
+
+/* This little function scans through a compiled pattern until it finds a
+capturing bracket with the given number, or, if the number is negative, an
+instance of OP_REVERSE for a lookbehind. The function is global in the C sense
+so that it can be called from pcre_study() when finding the minimum matching
+length.
+
+Arguments:
+  code        points to start of expression
+  utf         TRUE in UTF-8 / UTF-16 / UTF-32 mode
+  number      the required bracket number or negative to find a lookbehind
+
+Returns:      pointer to the opcode for the bracket, or NULL if not found
+*/
+
+const pcre_uchar *
+PRIV(find_bracket)(const pcre_uchar *code, BOOL utf, int number)
+{
+for (;;)
+  {
+  register pcre_uchar c = *code;
+
+  if (c == OP_END) return NULL;
+
+  /* XCLASS is used for classes that cannot be represented just by a bit
+  map. This includes negated single high-valued characters. The length in
+  the table is zero; the actual length is stored in the compiled code. */
+
+  if (c == OP_XCLASS) code += GET(code, 1);
+
+  /* Handle recursion */
+
+  else if (c == OP_REVERSE)
+    {
+    if (number < 0) return (pcre_uchar *)code;
+    code += PRIV(OP_lengths)[c];
+    }
+
+  /* Handle capturing bracket */
+
+  else if (c == OP_CBRA || c == OP_SCBRA ||
+           c == OP_CBRAPOS || c == OP_SCBRAPOS)
+    {
+    int n = (int)GET2(code, 1+LINK_SIZE);
+    if (n == number) return (pcre_uchar *)code;
+    code += PRIV(OP_lengths)[c];
+    }
+
+  /* Otherwise, we can get the item's length from the table, except that for
+  repeated character types, we have to test for \p and \P, which have an extra
+  two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we
+  must add in its length. */
+
+  else
+    {
+    switch(c)
+      {
+      case OP_TYPESTAR:
+      case OP_TYPEMINSTAR:
+      case OP_TYPEPLUS:
+      case OP_TYPEMINPLUS:
+      case OP_TYPEQUERY:
+      case OP_TYPEMINQUERY:
+      case OP_TYPEPOSSTAR:
+      case OP_TYPEPOSPLUS:
+      case OP_TYPEPOSQUERY:
+      if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
+      break;
+
+      case OP_TYPEUPTO:
+      case OP_TYPEMINUPTO:
+      case OP_TYPEEXACT:
+      case OP_TYPEPOSUPTO:
+      if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
+        code += 2;
+      break;
+
+      case OP_MARK:
+      case OP_PRUNE_ARG:
+      case OP_SKIP_ARG:
+      case OP_THEN_ARG:
+      code += code[1];
+      break;
+      }
+
+    /* Add in the fixed length from the table */
+
+    code += PRIV(OP_lengths)[c];
+
+  /* In UTF-8 mode, opcodes that are followed by a character may be followed by
+  a multi-byte character. The length in the table is a minimum, so we have to
+  arrange to skip the extra bytes. */
+
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+    if (utf) switch(c)
+      {
+      case OP_CHAR:
+      case OP_CHARI:
+      case OP_NOT:
+      case OP_NOTI:
+      case OP_EXACT:
+      case OP_EXACTI:
+      case OP_NOTEXACT:
+      case OP_NOTEXACTI:
+      case OP_UPTO:
+      case OP_UPTOI:
+      case OP_NOTUPTO:
+      case OP_NOTUPTOI:
+      case OP_MINUPTO:
+      case OP_MINUPTOI:
+      case OP_NOTMINUPTO:
+      case OP_NOTMINUPTOI:
+      case OP_POSUPTO:
+      case OP_POSUPTOI:
+      case OP_NOTPOSUPTO:
+      case OP_NOTPOSUPTOI:
+      case OP_STAR:
+      case OP_STARI:
+      case OP_NOTSTAR:
+      case OP_NOTSTARI:
+      case OP_MINSTAR:
+      case OP_MINSTARI:
+      case OP_NOTMINSTAR:
+      case OP_NOTMINSTARI:
+      case OP_POSSTAR:
+      case OP_POSSTARI:
+      case OP_NOTPOSSTAR:
+      case OP_NOTPOSSTARI:
+      case OP_PLUS:
+      case OP_PLUSI:
+      case OP_NOTPLUS:
+      case OP_NOTPLUSI:
+      case OP_MINPLUS:
+      case OP_MINPLUSI:
+      case OP_NOTMINPLUS:
+      case OP_NOTMINPLUSI:
+      case OP_POSPLUS:
+      case OP_POSPLUSI:
+      case OP_NOTPOSPLUS:
+      case OP_NOTPOSPLUSI:
+      case OP_QUERY:
+      case OP_QUERYI:
+      case OP_NOTQUERY:
+      case OP_NOTQUERYI:
+      case OP_MINQUERY:
+      case OP_MINQUERYI:
+      case OP_NOTMINQUERY:
+      case OP_NOTMINQUERYI:
+      case OP_POSQUERY:
+      case OP_POSQUERYI:
+      case OP_NOTPOSQUERY:
+      case OP_NOTPOSQUERYI:
+      if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);
+      break;
+      }
+#else
+    (void)(utf);  /* Keep compiler happy by referencing function argument */
+#endif
+    }
+  }
+}
+
+
+
+/*************************************************
+*   Scan compiled regex for recursion reference  *
+*************************************************/
+
+/* This little function scans through a compiled pattern until it finds an
+instance of OP_RECURSE.
+
+Arguments:
+  code        points to start of expression
+  utf         TRUE in UTF-8 / UTF-16 / UTF-32 mode
+
+Returns:      pointer to the opcode for OP_RECURSE, or NULL if not found
+*/
+
+static const pcre_uchar *
+find_recurse(const pcre_uchar *code, BOOL utf)
+{
+for (;;)
+  {
+  register pcre_uchar c = *code;
+  if (c == OP_END) return NULL;
+  if (c == OP_RECURSE) return code;
+
+  /* XCLASS is used for classes that cannot be represented just by a bit
+  map. This includes negated single high-valued characters. The length in
+  the table is zero; the actual length is stored in the compiled code. */
+
+  if (c == OP_XCLASS) code += GET(code, 1);
+
+  /* Otherwise, we can get the item's length from the table, except that for
+  repeated character types, we have to test for \p and \P, which have an extra
+  two bytes of parameters, and for MARK/PRUNE/SKIP/THEN with an argument, we
+  must add in its length. */
+
+  else
+    {
+    switch(c)
+      {
+      case OP_TYPESTAR:
+      case OP_TYPEMINSTAR:
+      case OP_TYPEPLUS:
+      case OP_TYPEMINPLUS:
+      case OP_TYPEQUERY:
+      case OP_TYPEMINQUERY:
+      case OP_TYPEPOSSTAR:
+      case OP_TYPEPOSPLUS:
+      case OP_TYPEPOSQUERY:
+      if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
+      break;
+
+      case OP_TYPEPOSUPTO:
+      case OP_TYPEUPTO:
+      case OP_TYPEMINUPTO:
+      case OP_TYPEEXACT:
+      if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
+        code += 2;
+      break;
+
+      case OP_MARK:
+      case OP_PRUNE_ARG:
+      case OP_SKIP_ARG:
+      case OP_THEN_ARG:
+      code += code[1];
+      break;
+      }
+
+    /* Add in the fixed length from the table */
+
+    code += PRIV(OP_lengths)[c];
+
+    /* In UTF-8 mode, opcodes that are followed by a character may be followed
+    by a multi-byte character. The length in the table is a minimum, so we have
+    to arrange to skip the extra bytes. */
+
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+    if (utf) switch(c)
+      {
+      case OP_CHAR:
+      case OP_CHARI:
+      case OP_NOT:
+      case OP_NOTI:
+      case OP_EXACT:
+      case OP_EXACTI:
+      case OP_NOTEXACT:
+      case OP_NOTEXACTI:
+      case OP_UPTO:
+      case OP_UPTOI:
+      case OP_NOTUPTO:
+      case OP_NOTUPTOI:
+      case OP_MINUPTO:
+      case OP_MINUPTOI:
+      case OP_NOTMINUPTO:
+      case OP_NOTMINUPTOI:
+      case OP_POSUPTO:
+      case OP_POSUPTOI:
+      case OP_NOTPOSUPTO:
+      case OP_NOTPOSUPTOI:
+      case OP_STAR:
+      case OP_STARI:
+      case OP_NOTSTAR:
+      case OP_NOTSTARI:
+      case OP_MINSTAR:
+      case OP_MINSTARI:
+      case OP_NOTMINSTAR:
+      case OP_NOTMINSTARI:
+      case OP_POSSTAR:
+      case OP_POSSTARI:
+      case OP_NOTPOSSTAR:
+      case OP_NOTPOSSTARI:
+      case OP_PLUS:
+      case OP_PLUSI:
+      case OP_NOTPLUS:
+      case OP_NOTPLUSI:
+      case OP_MINPLUS:
+      case OP_MINPLUSI:
+      case OP_NOTMINPLUS:
+      case OP_NOTMINPLUSI:
+      case OP_POSPLUS:
+      case OP_POSPLUSI:
+      case OP_NOTPOSPLUS:
+      case OP_NOTPOSPLUSI:
+      case OP_QUERY:
+      case OP_QUERYI:
+      case OP_NOTQUERY:
+      case OP_NOTQUERYI:
+      case OP_MINQUERY:
+      case OP_MINQUERYI:
+      case OP_NOTMINQUERY:
+      case OP_NOTMINQUERYI:
+      case OP_POSQUERY:
+      case OP_POSQUERYI:
+      case OP_NOTPOSQUERY:
+      case OP_NOTPOSQUERYI:
+      if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);
+      break;
+      }
+#else
+    (void)(utf);  /* Keep compiler happy by referencing function argument */
+#endif
+    }
+  }
+}
+
+
+
+/*************************************************
+*    Scan compiled branch for non-emptiness      *
+*************************************************/
+
+/* This function scans through a branch of a compiled pattern to see whether it
+can match the empty string or not. It is called from could_be_empty()
+below and from compile_branch() when checking for an unlimited repeat of a
+group that can match nothing. Note that first_significant_code() skips over
+backward and negative forward assertions when its final argument is TRUE. If we
+hit an unclosed bracket, we return "empty" - this means we've struck an inner
+bracket whose current branch will already have been scanned.
+
+Arguments:
+  code        points to start of search
+  endcode     points to where to stop
+  utf         TRUE if in UTF-8 / UTF-16 / UTF-32 mode
+  cd          contains pointers to tables etc.
+  recurses    chain of recurse_check to catch mutual recursion
+
+Returns:      TRUE if what is matched could be empty
+*/
+
+static BOOL
+could_be_empty_branch(const pcre_uchar *code, const pcre_uchar *endcode,
+  BOOL utf, compile_data *cd, recurse_check *recurses)
+{
+register pcre_uchar c;
+recurse_check this_recurse;
+
+for (code = first_significant_code(code + PRIV(OP_lengths)[*code], TRUE);
+     code < endcode;
+     code = first_significant_code(code + PRIV(OP_lengths)[c], TRUE))
+  {
+  const pcre_uchar *ccode;
+
+  c = *code;
+
+  /* Skip over forward assertions; the other assertions are skipped by
+  first_significant_code() with a TRUE final argument. */
+
+  if (c == OP_ASSERT)
+    {
+    do code += GET(code, 1); while (*code == OP_ALT);
+    c = *code;
+    continue;
+    }
+
+  /* For a recursion/subroutine call, if its end has been reached, which
+  implies a backward reference subroutine call, we can scan it. If it's a
+  forward reference subroutine call, we can't. To detect forward reference
+  we have to scan up the list that is kept in the workspace. This function is
+  called only when doing the real compile, not during the pre-compile that
+  measures the size of the compiled pattern. */
+
+  if (c == OP_RECURSE)
+    {
+    const pcre_uchar *scode = cd->start_code + GET(code, 1);
+    const pcre_uchar *endgroup = scode;
+    BOOL empty_branch;
+
+    /* Test for forward reference or uncompleted reference. This is disabled
+    when called to scan a completed pattern by setting cd->start_workspace to
+    NULL. */
+
+    if (cd->start_workspace != NULL)
+      {
+      const pcre_uchar *tcode;
+      for (tcode = cd->start_workspace; tcode < cd->hwm; tcode += LINK_SIZE)
+        if ((int)GET(tcode, 0) == (int)(code + 1 - cd->start_code)) return TRUE;
+      if (GET(scode, 1) == 0) return TRUE;    /* Unclosed */
+      }
+
+    /* If the reference is to a completed group, we need to detect whether this
+    is a recursive call, as otherwise there will be an infinite loop. If it is
+    a recursion, just skip over it. Simple recursions are easily detected. For
+    mutual recursions we keep a chain on the stack. */
+
+    do endgroup += GET(endgroup, 1); while (*endgroup == OP_ALT);
+    if (code >= scode && code <= endgroup) continue;  /* Simple recursion */
+    else
+      {
+      recurse_check *r = recurses;
+      for (r = recurses; r != NULL; r = r->prev)
+        if (r->group == scode) break;
+      if (r != NULL) continue;   /* Mutual recursion */
+      }
+
+    /* Completed reference; scan the referenced group, remembering it on the
+    stack chain to detect mutual recursions. */
+
+    empty_branch = FALSE;
+    this_recurse.prev = recurses;
+    this_recurse.group = scode;
+
+    do
+      {
+      if (could_be_empty_branch(scode, endcode, utf, cd, &this_recurse))
+        {
+        empty_branch = TRUE;
+        break;
+        }
+      scode += GET(scode, 1);
+      }
+    while (*scode == OP_ALT);
+
+    if (!empty_branch) return FALSE;  /* All branches are non-empty */
+    continue;
+    }
+
+  /* Groups with zero repeats can of course be empty; skip them. */
+
+  if (c == OP_BRAZERO || c == OP_BRAMINZERO || c == OP_SKIPZERO ||
+      c == OP_BRAPOSZERO)
+    {
+    code += PRIV(OP_lengths)[c];
+    do code += GET(code, 1); while (*code == OP_ALT);
+    c = *code;
+    continue;
+    }
+
+  /* A nested group that is already marked as "could be empty" can just be
+  skipped. */
+
+  if (c == OP_SBRA  || c == OP_SBRAPOS ||
+      c == OP_SCBRA || c == OP_SCBRAPOS)
+    {
+    do code += GET(code, 1); while (*code == OP_ALT);
+    c = *code;
+    continue;
+    }
+
+  /* For other groups, scan the branches. */
+
+  if (c == OP_BRA  || c == OP_BRAPOS ||
+      c == OP_CBRA || c == OP_CBRAPOS ||
+      c == OP_ONCE || c == OP_ONCE_NC ||
+      c == OP_COND || c == OP_SCOND)
+    {
+    BOOL empty_branch;
+    if (GET(code, 1) == 0) return TRUE;    /* Hit unclosed bracket */
+
+    /* If a conditional group has only one branch, there is a second, implied,
+    empty branch, so just skip over the conditional, because it could be empty.
+    Otherwise, scan the individual branches of the group. */
+
+    if (c == OP_COND && code[GET(code, 1)] != OP_ALT)
+      code += GET(code, 1);
+    else
+      {
+      empty_branch = FALSE;
+      do
+        {
+        if (!empty_branch && could_be_empty_branch(code, endcode, utf, cd,
+          recurses)) empty_branch = TRUE;
+        code += GET(code, 1);
+        }
+      while (*code == OP_ALT);
+      if (!empty_branch) return FALSE;   /* All branches are non-empty */
+      }
+
+    c = *code;
+    continue;
+    }
+
+  /* Handle the other opcodes */
+
+  switch (c)
+    {
+    /* Check for quantifiers after a class. XCLASS is used for classes that
+    cannot be represented just by a bit map. This includes negated single
+    high-valued characters. The length in PRIV(OP_lengths)[] is zero; the
+    actual length is stored in the compiled code, so we must update "code"
+    here. */
+
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+    case OP_XCLASS:
+    ccode = code += GET(code, 1);
+    goto CHECK_CLASS_REPEAT;
+#endif
+
+    case OP_CLASS:
+    case OP_NCLASS:
+    ccode = code + PRIV(OP_lengths)[OP_CLASS];
+
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+    CHECK_CLASS_REPEAT:
+#endif
+
+    switch (*ccode)
+      {
+      case OP_CRSTAR:            /* These could be empty; continue */
+      case OP_CRMINSTAR:
+      case OP_CRQUERY:
+      case OP_CRMINQUERY:
+      case OP_CRPOSSTAR:
+      case OP_CRPOSQUERY:
+      break;
+
+      default:                   /* Non-repeat => class must match */
+      case OP_CRPLUS:            /* These repeats aren't empty */
+      case OP_CRMINPLUS:
+      case OP_CRPOSPLUS:
+      return FALSE;
+
+      case OP_CRRANGE:
+      case OP_CRMINRANGE:
+      case OP_CRPOSRANGE:
+      if (GET2(ccode, 1) > 0) return FALSE;  /* Minimum > 0 */
+      break;
+      }
+    break;
+
+    /* Opcodes that must match a character */
+
+    case OP_ANY:
+    case OP_ALLANY:
+    case OP_ANYBYTE:
+
+    case OP_PROP:
+    case OP_NOTPROP:
+    case OP_ANYNL:
+
+    case OP_NOT_HSPACE:
+    case OP_HSPACE:
+    case OP_NOT_VSPACE:
+    case OP_VSPACE:
+    case OP_EXTUNI:
+
+    case OP_NOT_DIGIT:
+    case OP_DIGIT:
+    case OP_NOT_WHITESPACE:
+    case OP_WHITESPACE:
+    case OP_NOT_WORDCHAR:
+    case OP_WORDCHAR:
+
+    case OP_CHAR:
+    case OP_CHARI:
+    case OP_NOT:
+    case OP_NOTI:
+
+    case OP_PLUS:
+    case OP_PLUSI:
+    case OP_MINPLUS:
+    case OP_MINPLUSI:
+
+    case OP_NOTPLUS:
+    case OP_NOTPLUSI:
+    case OP_NOTMINPLUS:
+    case OP_NOTMINPLUSI:
+
+    case OP_POSPLUS:
+    case OP_POSPLUSI:
+    case OP_NOTPOSPLUS:
+    case OP_NOTPOSPLUSI:
+
+    case OP_EXACT:
+    case OP_EXACTI:
+    case OP_NOTEXACT:
+    case OP_NOTEXACTI:
+
+    case OP_TYPEPLUS:
+    case OP_TYPEMINPLUS:
+    case OP_TYPEPOSPLUS:
+    case OP_TYPEEXACT:
+
+    return FALSE;
+
+    /* These are going to continue, as they may be empty, but we have to
+    fudge the length for the \p and \P cases. */
+
+    case OP_TYPESTAR:
+    case OP_TYPEMINSTAR:
+    case OP_TYPEPOSSTAR:
+    case OP_TYPEQUERY:
+    case OP_TYPEMINQUERY:
+    case OP_TYPEPOSQUERY:
+    if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
+    break;
+
+    /* Same for these */
+
+    case OP_TYPEUPTO:
+    case OP_TYPEMINUPTO:
+    case OP_TYPEPOSUPTO:
+    if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
+      code += 2;
+    break;
+
+    /* End of branch */
+
+    case OP_KET:
+    case OP_KETRMAX:
+    case OP_KETRMIN:
+    case OP_KETRPOS:
+    case OP_ALT:
+    return TRUE;
+
+    /* In UTF-8 mode, STAR, MINSTAR, POSSTAR, QUERY, MINQUERY, POSQUERY, UPTO,
+    MINUPTO, and POSUPTO and their caseless and negative versions may be
+    followed by a multibyte character. */
+
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+    case OP_STAR:
+    case OP_STARI:
+    case OP_NOTSTAR:
+    case OP_NOTSTARI:
+
+    case OP_MINSTAR:
+    case OP_MINSTARI:
+    case OP_NOTMINSTAR:
+    case OP_NOTMINSTARI:
+
+    case OP_POSSTAR:
+    case OP_POSSTARI:
+    case OP_NOTPOSSTAR:
+    case OP_NOTPOSSTARI:
+
+    case OP_QUERY:
+    case OP_QUERYI:
+    case OP_NOTQUERY:
+    case OP_NOTQUERYI:
+
+    case OP_MINQUERY:
+    case OP_MINQUERYI:
+    case OP_NOTMINQUERY:
+    case OP_NOTMINQUERYI:
+
+    case OP_POSQUERY:
+    case OP_POSQUERYI:
+    case OP_NOTPOSQUERY:
+    case OP_NOTPOSQUERYI:
+
+    if (utf && HAS_EXTRALEN(code[1])) code += GET_EXTRALEN(code[1]);
+    break;
+
+    case OP_UPTO:
+    case OP_UPTOI:
+    case OP_NOTUPTO:
+    case OP_NOTUPTOI:
+
+    case OP_MINUPTO:
+    case OP_MINUPTOI:
+    case OP_NOTMINUPTO:
+    case OP_NOTMINUPTOI:
+
+    case OP_POSUPTO:
+    case OP_POSUPTOI:
+    case OP_NOTPOSUPTO:
+    case OP_NOTPOSUPTOI:
+
+    if (utf && HAS_EXTRALEN(code[1 + IMM2_SIZE])) code += GET_EXTRALEN(code[1 + IMM2_SIZE]);
+    break;
+#endif
+
+    /* MARK, and PRUNE/SKIP/THEN with an argument must skip over the argument
+    string. */
+
+    case OP_MARK:
+    case OP_PRUNE_ARG:
+    case OP_SKIP_ARG:
+    case OP_THEN_ARG:
+    code += code[1];
+    break;
+
+    /* None of the remaining opcodes are required to match a character. */
+
+    default:
+    break;
+    }
+  }
+
+return TRUE;
+}
+
+
+
+/*************************************************
+*    Scan compiled regex for non-emptiness       *
+*************************************************/
+
+/* This function is called to check for left recursive calls. We want to check
+the current branch of the current pattern to see if it could match the empty
+string. If it could, we must look outwards for branches at other levels,
+stopping when we pass beyond the bracket which is the subject of the recursion.
+This function is called only during the real compile, not during the
+pre-compile.
+
+Arguments:
+  code        points to start of the recursion
+  endcode     points to where to stop (current RECURSE item)
+  bcptr       points to the chain of current (unclosed) branch starts
+  utf         TRUE if in UTF-8 / UTF-16 / UTF-32 mode
+  cd          pointers to tables etc
+
+Returns:      TRUE if what is matched could be empty
+*/
+
+static BOOL
+could_be_empty(const pcre_uchar *code, const pcre_uchar *endcode,
+  branch_chain *bcptr, BOOL utf, compile_data *cd)
+{
+while (bcptr != NULL && bcptr->current_branch >= code)
+  {
+  if (!could_be_empty_branch(bcptr->current_branch, endcode, utf, cd, NULL))
+    return FALSE;
+  bcptr = bcptr->outer;
+  }
+return TRUE;
+}
+
+
+
+/*************************************************
+*        Base opcode of repeated opcodes         *
+*************************************************/
+
+/* Returns the base opcode for repeated single character type opcodes. If the
+opcode is not a repeated character type, it returns with the original value.
+
+Arguments:  c opcode
+Returns:    base opcode for the type
+*/
+
+static pcre_uchar
+get_repeat_base(pcre_uchar c)
+{
+return (c > OP_TYPEPOSUPTO)? c :
+       (c >= OP_TYPESTAR)?   OP_TYPESTAR :
+       (c >= OP_NOTSTARI)?   OP_NOTSTARI :
+       (c >= OP_NOTSTAR)?    OP_NOTSTAR :
+       (c >= OP_STARI)?      OP_STARI :
+                             OP_STAR;
+}
+
+
+
+#ifdef SUPPORT_UCP
+/*************************************************
+*        Check a character and a property        *
+*************************************************/
+
+/* This function is called by check_auto_possessive() when a property item
+is adjacent to a fixed character.
+
+Arguments:
+  c            the character
+  ptype        the property type
+  pdata        the data for the type
+  negated      TRUE if it's a negated property (\P or \p{^)
+
+Returns:       TRUE if auto-possessifying is OK
+*/
+
+static BOOL
+check_char_prop(pcre_uint32 c, unsigned int ptype, unsigned int pdata,
+  BOOL negated)
+{
+const pcre_uint32 *p;
+const ucd_record *prop = GET_UCD(c);
+
+switch(ptype)
+  {
+  case PT_LAMP:
+  return (prop->chartype == ucp_Lu ||
+          prop->chartype == ucp_Ll ||
+          prop->chartype == ucp_Lt) == negated;
+
+  case PT_GC:
+  return (pdata == PRIV(ucp_gentype)[prop->chartype]) == negated;
+
+  case PT_PC:
+  return (pdata == prop->chartype) == negated;
+
+  case PT_SC:
+  return (pdata == prop->script) == negated;
+
+  /* These are specials */
+
+  case PT_ALNUM:
+  return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
+          PRIV(ucp_gentype)[prop->chartype] == ucp_N) == negated;
+
+  /* Perl space used to exclude VT, but from Perl 5.18 it is included, which
+  means that Perl space and POSIX space are now identical. PCRE was changed
+  at release 8.34. */
+
+  case PT_SPACE:    /* Perl space */
+  case PT_PXSPACE:  /* POSIX space */
+  switch(c)
+    {
+    HSPACE_CASES:
+    VSPACE_CASES:
+    return negated;
+
+    default:
+    return (PRIV(ucp_gentype)[prop->chartype] == ucp_Z) == negated;
+    }
+  break;  /* Control never reaches here */
+
+  case PT_WORD:
+  return (PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
+          PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
+          c == CHAR_UNDERSCORE) == negated;
+
+  case PT_CLIST:
+  p = PRIV(ucd_caseless_sets) + prop->caseset;
+  for (;;)
+    {
+    if (c < *p) return !negated;
+    if (c == *p++) return negated;
+    }
+  break;  /* Control never reaches here */
+  }
+
+return FALSE;
+}
+#endif  /* SUPPORT_UCP */
+
+
+
+/*************************************************
+*        Fill the character property list        *
+*************************************************/
+
+/* Checks whether the code points to an opcode that can take part in auto-
+possessification, and if so, fills a list with its properties.
+
+Arguments:
+  code        points to start of expression
+  utf         TRUE if in UTF-8 / UTF-16 / UTF-32 mode
+  fcc         points to case-flipping table
+  list        points to output list
+              list[0] will be filled with the opcode
+              list[1] will be non-zero if this opcode
+                can match an empty character string
+              list[2..7] depends on the opcode
+
+Returns:      points to the start of the next opcode if *code is accepted
+              NULL if *code is not accepted
+*/
+
+static const pcre_uchar *
+get_chr_property_list(const pcre_uchar *code, BOOL utf,
+  const pcre_uint8 *fcc, pcre_uint32 *list)
+{
+pcre_uchar c = *code;
+pcre_uchar base;
+const pcre_uchar *end;
+pcre_uint32 chr;
+
+#ifdef SUPPORT_UCP
+pcre_uint32 *clist_dest;
+const pcre_uint32 *clist_src;
+#else
+utf = utf;  /* Suppress "unused parameter" compiler warning */
+#endif
+
+list[0] = c;
+list[1] = FALSE;
+code++;
+
+if (c >= OP_STAR && c <= OP_TYPEPOSUPTO)
+  {
+  base = get_repeat_base(c);
+  c -= (base - OP_STAR);
+
+  if (c == OP_UPTO || c == OP_MINUPTO || c == OP_EXACT || c == OP_POSUPTO)
+    code += IMM2_SIZE;
+
+  list[1] = (c != OP_PLUS && c != OP_MINPLUS && c != OP_EXACT && c != OP_POSPLUS);
+
+  switch(base)
+    {
+    case OP_STAR:
+    list[0] = OP_CHAR;
+    break;
+
+    case OP_STARI:
+    list[0] = OP_CHARI;
+    break;
+
+    case OP_NOTSTAR:
+    list[0] = OP_NOT;
+    break;
+
+    case OP_NOTSTARI:
+    list[0] = OP_NOTI;
+    break;
+
+    case OP_TYPESTAR:
+    list[0] = *code;
+    code++;
+    break;
+    }
+  c = list[0];
+  }
+
+switch(c)
+  {
+  case OP_NOT_DIGIT:
+  case OP_DIGIT:
+  case OP_NOT_WHITESPACE:
+  case OP_WHITESPACE:
+  case OP_NOT_WORDCHAR:
+  case OP_WORDCHAR:
+  case OP_ANY:
+  case OP_ALLANY:
+  case OP_ANYNL:
+  case OP_NOT_HSPACE:
+  case OP_HSPACE:
+  case OP_NOT_VSPACE:
+  case OP_VSPACE:
+  case OP_EXTUNI:
+  case OP_EODN:
+  case OP_EOD:
+  case OP_DOLL:
+  case OP_DOLLM:
+  return code;
+
+  case OP_CHAR:
+  case OP_NOT:
+  GETCHARINCTEST(chr, code);
+  list[2] = chr;
+  list[3] = NOTACHAR;
+  return code;
+
+  case OP_CHARI:
+  case OP_NOTI:
+  list[0] = (c == OP_CHARI) ? OP_CHAR : OP_NOT;
+  GETCHARINCTEST(chr, code);
+  list[2] = chr;
+
+#ifdef SUPPORT_UCP
+  if (chr < 128 || (chr < 256 && !utf))
+    list[3] = fcc[chr];
+  else
+    list[3] = UCD_OTHERCASE(chr);
+#elif defined SUPPORT_UTF || !defined COMPILE_PCRE8
+  list[3] = (chr < 256) ? fcc[chr] : chr;
+#else
+  list[3] = fcc[chr];
+#endif
+
+  /* The othercase might be the same value. */
+
+  if (chr == list[3])
+    list[3] = NOTACHAR;
+  else
+    list[4] = NOTACHAR;
+  return code;
+
+#ifdef SUPPORT_UCP
+  case OP_PROP:
+  case OP_NOTPROP:
+  if (code[0] != PT_CLIST)
+    {
+    list[2] = code[0];
+    list[3] = code[1];
+    return code + 2;
+    }
+
+  /* Convert only if we have enough space. */
+
+  clist_src = PRIV(ucd_caseless_sets) + code[1];
+  clist_dest = list + 2;
+  code += 2;
+
+  do {
+     if (clist_dest >= list + 8)
+       {
+       /* Early return if there is not enough space. This should never
+       happen, since all clists are shorter than 5 character now. */
+       list[2] = code[0];
+       list[3] = code[1];
+       return code;
+       }
+     *clist_dest++ = *clist_src;
+     }
+  while(*clist_src++ != NOTACHAR);
+
+  /* All characters are stored. The terminating NOTACHAR
+  is copied form the clist itself. */
+
+  list[0] = (c == OP_PROP) ? OP_CHAR : OP_NOT;
+  return code;
+#endif
+
+  case OP_NCLASS:
+  case OP_CLASS:
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+  case OP_XCLASS:
+  if (c == OP_XCLASS)
+    end = code + GET(code, 0) - 1;
+  else
+#endif
+    end = code + 32 / sizeof(pcre_uchar);
+
+  switch(*end)
+    {
+    case OP_CRSTAR:
+    case OP_CRMINSTAR:
+    case OP_CRQUERY:
+    case OP_CRMINQUERY:
+    case OP_CRPOSSTAR:
+    case OP_CRPOSQUERY:
+    list[1] = TRUE;
+    end++;
+    break;
+
+    case OP_CRPLUS:
+    case OP_CRMINPLUS:
+    case OP_CRPOSPLUS:
+    end++;
+    break;
+
+    case OP_CRRANGE:
+    case OP_CRMINRANGE:
+    case OP_CRPOSRANGE:
+    list[1] = (GET2(end, 1) == 0);
+    end += 1 + 2 * IMM2_SIZE;
+    break;
+    }
+  list[2] = (pcre_uint32)(end - code);
+  return end;
+  }
+return NULL;    /* Opcode not accepted */
+}
+
+
+
+/*************************************************
+*    Scan further character sets for match       *
+*************************************************/
+
+/* Checks whether the base and the current opcode have a common character, in
+which case the base cannot be possessified.
+
+Arguments:
+  code        points to the byte code
+  utf         TRUE in UTF-8 / UTF-16 / UTF-32 mode
+  cd          static compile data
+  base_list   the data list of the base opcode
+
+Returns:      TRUE if the auto-possessification is possible
+*/
+
+static BOOL
+compare_opcodes(const pcre_uchar *code, BOOL utf, const compile_data *cd,
+  const pcre_uint32 *base_list, const pcre_uchar *base_end, int *rec_limit)
+{
+pcre_uchar c;
+pcre_uint32 list[8];
+const pcre_uint32 *chr_ptr;
+const pcre_uint32 *ochr_ptr;
+const pcre_uint32 *list_ptr;
+const pcre_uchar *next_code;
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+const pcre_uchar *xclass_flags;
+#endif
+const pcre_uint8 *class_bitset;
+const pcre_uint8 *set1, *set2, *set_end;
+pcre_uint32 chr;
+BOOL accepted, invert_bits;
+BOOL entered_a_group = FALSE;
+
+if (*rec_limit == 0) return FALSE;
+--(*rec_limit);
+
+/* Note: the base_list[1] contains whether the current opcode has greedy
+(represented by a non-zero value) quantifier. This is a different from
+other character type lists, which stores here that the character iterator
+matches to an empty string (also represented by a non-zero value). */
+
+for(;;)
+  {
+  /* All operations move the code pointer forward.
+  Therefore infinite recursions are not possible. */
+
+  c = *code;
+
+  /* Skip over callouts */
+
+  if (c == OP_CALLOUT)
+    {
+    code += PRIV(OP_lengths)[c];
+    continue;
+    }
+
+  if (c == OP_ALT)
+    {
+    do code += GET(code, 1); while (*code == OP_ALT);
+    c = *code;
+    }
+
+  switch(c)
+    {
+    case OP_END:
+    case OP_KETRPOS:
+    /* TRUE only in greedy case. The non-greedy case could be replaced by
+    an OP_EXACT, but it is probably not worth it. (And note that OP_EXACT
+    uses more memory, which we cannot get at this stage.) */
+
+    return base_list[1] != 0;
+
+    case OP_KET:
+    /* If the bracket is capturing, and referenced by an OP_RECURSE, or
+    it is an atomic sub-pattern (assert, once, etc.) the non-greedy case
+    cannot be converted to a possessive form. */
+
+    if (base_list[1] == 0) return FALSE;
+
+    switch(*(code - GET(code, 1)))
+      {
+      case OP_ASSERT:
+      case OP_ASSERT_NOT:
+      case OP_ASSERTBACK:
+      case OP_ASSERTBACK_NOT:
+      case OP_ONCE:
+      case OP_ONCE_NC:
+      /* Atomic sub-patterns and assertions can always auto-possessify their
+      last iterator. However, if the group was entered as a result of checking
+      a previous iterator, this is not possible. */
+
+      return !entered_a_group;
+      }
+
+    code += PRIV(OP_lengths)[c];
+    continue;
+
+    case OP_ONCE:
+    case OP_ONCE_NC:
+    case OP_BRA:
+    case OP_CBRA:
+    next_code = code + GET(code, 1);
+    code += PRIV(OP_lengths)[c];
+
+    while (*next_code == OP_ALT)
+      {
+      if (!compare_opcodes(code, utf, cd, base_list, base_end, rec_limit))
+        return FALSE;
+      code = next_code + 1 + LINK_SIZE;
+      next_code += GET(next_code, 1);
+      }
+
+    entered_a_group = TRUE;
+    continue;
+
+    case OP_BRAZERO:
+    case OP_BRAMINZERO:
+
+    next_code = code + 1;
+    if (*next_code != OP_BRA && *next_code != OP_CBRA
+        && *next_code != OP_ONCE && *next_code != OP_ONCE_NC) return FALSE;
+
+    do next_code += GET(next_code, 1); while (*next_code == OP_ALT);
+
+    /* The bracket content will be checked by the
+    OP_BRA/OP_CBRA case above. */
+    next_code += 1 + LINK_SIZE;
+    if (!compare_opcodes(next_code, utf, cd, base_list, base_end, rec_limit))
+      return FALSE;
+
+    code += PRIV(OP_lengths)[c];
+    continue;
+
+    default:
+    break;
+    }
+
+  /* Check for a supported opcode, and load its properties. */
+
+  code = get_chr_property_list(code, utf, cd->fcc, list);
+  if (code == NULL) return FALSE;    /* Unsupported */
+
+  /* If either opcode is a small character list, set pointers for comparing
+  characters from that list with another list, or with a property. */
+
+  if (base_list[0] == OP_CHAR)
+    {
+    chr_ptr = base_list + 2;
+    list_ptr = list;
+    }
+  else if (list[0] == OP_CHAR)
+    {
+    chr_ptr = list + 2;
+    list_ptr = base_list;
+    }
+
+  /* Character bitsets can also be compared to certain opcodes. */
+
+  else if (base_list[0] == OP_CLASS || list[0] == OP_CLASS
+#ifdef COMPILE_PCRE8
+      /* In 8 bit, non-UTF mode, OP_CLASS and OP_NCLASS are the same. */
+      || (!utf && (base_list[0] == OP_NCLASS || list[0] == OP_NCLASS))
+#endif
+      )
+    {
+#ifdef COMPILE_PCRE8
+    if (base_list[0] == OP_CLASS || (!utf && base_list[0] == OP_NCLASS))
+#else
+    if (base_list[0] == OP_CLASS)
+#endif
+      {
+      set1 = (pcre_uint8 *)(base_end - base_list[2]);
+      list_ptr = list;
+      }
+    else
+      {
+      set1 = (pcre_uint8 *)(code - list[2]);
+      list_ptr = base_list;
+      }
+
+    invert_bits = FALSE;
+    switch(list_ptr[0])
+      {
+      case OP_CLASS:
+      case OP_NCLASS:
+      set2 = (pcre_uint8 *)
+        ((list_ptr == list ? code : base_end) - list_ptr[2]);
+      break;
+
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+      case OP_XCLASS:
+      xclass_flags = (list_ptr == list ? code : base_end) - list_ptr[2] + LINK_SIZE;
+      if ((*xclass_flags & XCL_HASPROP) != 0) return FALSE;
+      if ((*xclass_flags & XCL_MAP) == 0)
+        {
+        /* No bits are set for characters < 256. */
+        if (list[1] == 0) return TRUE;
+        /* Might be an empty repeat. */
+        continue;
+        }
+      set2 = (pcre_uint8 *)(xclass_flags + 1);
+      break;
+#endif
+
+      case OP_NOT_DIGIT:
+      invert_bits = TRUE;
+      /* Fall through */
+      case OP_DIGIT:
+      set2 = (pcre_uint8 *)(cd->cbits + cbit_digit);
+      break;
+
+      case OP_NOT_WHITESPACE:
+      invert_bits = TRUE;
+      /* Fall through */
+      case OP_WHITESPACE:
+      set2 = (pcre_uint8 *)(cd->cbits + cbit_space);
+      break;
+
+      case OP_NOT_WORDCHAR:
+      invert_bits = TRUE;
+      /* Fall through */
+      case OP_WORDCHAR:
+      set2 = (pcre_uint8 *)(cd->cbits + cbit_word);
+      break;
+
+      default:
+      return FALSE;
+      }
+
+    /* Because the sets are unaligned, we need
+    to perform byte comparison here. */
+    set_end = set1 + 32;
+    if (invert_bits)
+      {
+      do
+        {
+        if ((*set1++ & ~(*set2++)) != 0) return FALSE;
+        }
+      while (set1 < set_end);
+      }
+    else
+      {
+      do
+        {
+        if ((*set1++ & *set2++) != 0) return FALSE;
+        }
+      while (set1 < set_end);
+      }
+
+    if (list[1] == 0) return TRUE;
+    /* Might be an empty repeat. */
+    continue;
+    }
+
+  /* Some property combinations also acceptable. Unicode property opcodes are
+  processed specially; the rest can be handled with a lookup table. */
+
+  else
+    {
+    pcre_uint32 leftop, rightop;
+
+    leftop = base_list[0];
+    rightop = list[0];
+
+#ifdef SUPPORT_UCP
+    accepted = FALSE; /* Always set in non-unicode case. */
+    if (leftop == OP_PROP || leftop == OP_NOTPROP)
+      {
+      if (rightop == OP_EOD)
+        accepted = TRUE;
+      else if (rightop == OP_PROP || rightop == OP_NOTPROP)
+        {
+        int n;
+        const pcre_uint8 *p;
+        BOOL same = leftop == rightop;
+        BOOL lisprop = leftop == OP_PROP;
+        BOOL risprop = rightop == OP_PROP;
+        BOOL bothprop = lisprop && risprop;
+
+        /* There's a table that specifies how each combination is to be
+        processed:
+          0   Always return FALSE (never auto-possessify)
+          1   Character groups are distinct (possessify if both are OP_PROP)
+          2   Check character categories in the same group (general or particular)
+          3   Return TRUE if the two opcodes are not the same
+          ... see comments below
+        */
+
+        n = propposstab[base_list[2]][list[2]];
+        switch(n)
+          {
+          case 0: break;
+          case 1: accepted = bothprop; break;
+          case 2: accepted = (base_list[3] == list[3]) != same; break;
+          case 3: accepted = !same; break;
+
+          case 4:  /* Left general category, right particular category */
+          accepted = risprop && catposstab[base_list[3]][list[3]] == same;
+          break;
+
+          case 5:  /* Right general category, left particular category */
+          accepted = lisprop && catposstab[list[3]][base_list[3]] == same;
+          break;
+
+          /* This code is logically tricky. Think hard before fiddling with it.
+          The posspropstab table has four entries per row. Each row relates to
+          one of PCRE's special properties such as ALNUM or SPACE or WORD.
+          Only WORD actually needs all four entries, but using repeats for the
+          others means they can all use the same code below.
+
+          The first two entries in each row are Unicode general categories, and
+          apply always, because all the characters they include are part of the
+          PCRE character set. The third and fourth entries are a general and a
+          particular category, respectively, that include one or more relevant
+          characters. One or the other is used, depending on whether the check
+          is for a general or a particular category. However, in both cases the
+          category contains more characters than the specials that are defined
+          for the property being tested against. Therefore, it cannot be used
+          in a NOTPROP case.
+
+          Example: the row for WORD contains ucp_L, ucp_N, ucp_P, ucp_Po.
+          Underscore is covered by ucp_P or ucp_Po. */
+
+          case 6:  /* Left alphanum vs right general category */
+          case 7:  /* Left space vs right general category */
+          case 8:  /* Left word vs right general category */
+          p = posspropstab[n-6];
+          accepted = risprop && lisprop ==
+            (list[3] != p[0] &&
+             list[3] != p[1] &&
+            (list[3] != p[2] || !lisprop));
+          break;
+
+          case 9:   /* Right alphanum vs left general category */
+          case 10:  /* Right space vs left general category */
+          case 11:  /* Right word vs left general category */
+          p = posspropstab[n-9];
+          accepted = lisprop && risprop ==
+            (base_list[3] != p[0] &&
+             base_list[3] != p[1] &&
+            (base_list[3] != p[2] || !risprop));
+          break;
+
+          case 12:  /* Left alphanum vs right particular category */
+          case 13:  /* Left space vs right particular category */
+          case 14:  /* Left word vs right particular category */
+          p = posspropstab[n-12];
+          accepted = risprop && lisprop ==
+            (catposstab[p[0]][list[3]] &&
+             catposstab[p[1]][list[3]] &&
+            (list[3] != p[3] || !lisprop));
+          break;
+
+          case 15:  /* Right alphanum vs left particular category */
+          case 16:  /* Right space vs left particular category */
+          case 17:  /* Right word vs left particular category */
+          p = posspropstab[n-15];
+          accepted = lisprop && risprop ==
+            (catposstab[p[0]][base_list[3]] &&
+             catposstab[p[1]][base_list[3]] &&
+            (base_list[3] != p[3] || !risprop));
+          break;
+          }
+        }
+      }
+
+    else
+#endif  /* SUPPORT_UCP */
+
+    accepted = leftop >= FIRST_AUTOTAB_OP && leftop <= LAST_AUTOTAB_LEFT_OP &&
+           rightop >= FIRST_AUTOTAB_OP && rightop <= LAST_AUTOTAB_RIGHT_OP &&
+           autoposstab[leftop - FIRST_AUTOTAB_OP][rightop - FIRST_AUTOTAB_OP];
+
+    if (!accepted) return FALSE;
+
+    if (list[1] == 0) return TRUE;
+    /* Might be an empty repeat. */
+    continue;
+    }
+
+  /* Control reaches here only if one of the items is a small character list.
+  All characters are checked against the other side. */
+
+  do
+    {
+    chr = *chr_ptr;
+
+    switch(list_ptr[0])
+      {
+      case OP_CHAR:
+      ochr_ptr = list_ptr + 2;
+      do
+        {
+        if (chr == *ochr_ptr) return FALSE;
+        ochr_ptr++;
+        }
+      while(*ochr_ptr != NOTACHAR);
+      break;
+
+      case OP_NOT:
+      ochr_ptr = list_ptr + 2;
+      do
+        {
+        if (chr == *ochr_ptr)
+          break;
+        ochr_ptr++;
+        }
+      while(*ochr_ptr != NOTACHAR);
+      if (*ochr_ptr == NOTACHAR) return FALSE;   /* Not found */
+      break;
+
+      /* Note that OP_DIGIT etc. are generated only when PCRE_UCP is *not*
+      set. When it is set, \d etc. are converted into OP_(NOT_)PROP codes. */
+
+      case OP_DIGIT:
+      if (chr < 256 && (cd->ctypes[chr] & ctype_digit) != 0) return FALSE;
+      break;
+
+      case OP_NOT_DIGIT:
+      if (chr > 255 || (cd->ctypes[chr] & ctype_digit) == 0) return FALSE;
+      break;
+
+      case OP_WHITESPACE:
+      if (chr < 256 && (cd->ctypes[chr] & ctype_space) != 0) return FALSE;
+      break;
+
+      case OP_NOT_WHITESPACE:
+      if (chr > 255 || (cd->ctypes[chr] & ctype_space) == 0) return FALSE;
+      break;
+
+      case OP_WORDCHAR:
+      if (chr < 255 && (cd->ctypes[chr] & ctype_word) != 0) return FALSE;
+      break;
+
+      case OP_NOT_WORDCHAR:
+      if (chr > 255 || (cd->ctypes[chr] & ctype_word) == 0) return FALSE;
+      break;
+
+      case OP_HSPACE:
+      switch(chr)
+        {
+        HSPACE_CASES: return FALSE;
+        default: break;
+        }
+      break;
+
+      case OP_NOT_HSPACE:
+      switch(chr)
+        {
+        HSPACE_CASES: break;
+        default: return FALSE;
+        }
+      break;
+
+      case OP_ANYNL:
+      case OP_VSPACE:
+      switch(chr)
+        {
+        VSPACE_CASES: return FALSE;
+        default: break;
+        }
+      break;
+
+      case OP_NOT_VSPACE:
+      switch(chr)
+        {
+        VSPACE_CASES: break;
+        default: return FALSE;
+        }
+      break;
+
+      case OP_DOLL:
+      case OP_EODN:
+      switch (chr)
+        {
+        case CHAR_CR:
+        case CHAR_LF:
+        case CHAR_VT:
+        case CHAR_FF:
+        case CHAR_NEL:
+#ifndef EBCDIC
+        case 0x2028:
+        case 0x2029:
+#endif  /* Not EBCDIC */
+        return FALSE;
+        }
+      break;
+
+      case OP_EOD:    /* Can always possessify before \z */
+      break;
+
+#ifdef SUPPORT_UCP
+      case OP_PROP:
+      case OP_NOTPROP:
+      if (!check_char_prop(chr, list_ptr[2], list_ptr[3],
+            list_ptr[0] == OP_NOTPROP))
+        return FALSE;
+      break;
+#endif
+
+      case OP_NCLASS:
+      if (chr > 255) return FALSE;
+      /* Fall through */
+
+      case OP_CLASS:
+      if (chr > 255) break;
+      class_bitset = (pcre_uint8 *)
+        ((list_ptr == list ? code : base_end) - list_ptr[2]);
+      if ((class_bitset[chr >> 3] & (1 << (chr & 7))) != 0) return FALSE;
+      break;
+
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+      case OP_XCLASS:
+      if (PRIV(xclass)(chr, (list_ptr == list ? code : base_end) -
+          list_ptr[2] + LINK_SIZE, utf)) return FALSE;
+      break;
+#endif
+
+      default:
+      return FALSE;
+      }
+
+    chr_ptr++;
+    }
+  while(*chr_ptr != NOTACHAR);
+
+  /* At least one character must be matched from this opcode. */
+
+  if (list[1] == 0) return TRUE;
+  }
+
+/* Control never reaches here. There used to be a fail-save return FALSE; here,
+but some compilers complain about an unreachable statement. */
+
+}
+
+
+
+/*************************************************
+*    Scan compiled regex for auto-possession     *
+*************************************************/
+
+/* Replaces single character iterations with their possessive alternatives
+if appropriate. This function modifies the compiled opcode!
+
+Arguments:
+  code        points to start of the byte code
+  utf         TRUE in UTF-8 / UTF-16 / UTF-32 mode
+  cd          static compile data
+
+Returns:      nothing
+*/
+
+static void
+auto_possessify(pcre_uchar *code, BOOL utf, const compile_data *cd)
+{
+register pcre_uchar c;
+const pcre_uchar *end;
+pcre_uchar *repeat_opcode;
+pcre_uint32 list[8];
+int rec_limit;
+
+for (;;)
+  {
+  c = *code;
+
+  /* When a pattern with bad UTF-8 encoding is compiled with NO_UTF_CHECK,
+  it may compile without complaining, but may get into a loop here if the code
+  pointer points to a bad value. This is, of course a documentated possibility,
+  when NO_UTF_CHECK is set, so it isn't a bug, but we can detect this case and
+  just give up on this optimization. */
+
+  if (c >= OP_TABLE_LENGTH) return;
+
+  if (c >= OP_STAR && c <= OP_TYPEPOSUPTO)
+    {
+    c -= get_repeat_base(c) - OP_STAR;
+    end = (c <= OP_MINUPTO) ?
+      get_chr_property_list(code, utf, cd->fcc, list) : NULL;
+    list[1] = c == OP_STAR || c == OP_PLUS || c == OP_QUERY || c == OP_UPTO;
+
+    rec_limit = 1000;
+    if (end != NULL && compare_opcodes(end, utf, cd, list, end, &rec_limit))
+      {
+      switch(c)
+        {
+        case OP_STAR:
+        *code += OP_POSSTAR - OP_STAR;
+        break;
+
+        case OP_MINSTAR:
+        *code += OP_POSSTAR - OP_MINSTAR;
+        break;
+
+        case OP_PLUS:
+        *code += OP_POSPLUS - OP_PLUS;
+        break;
+
+        case OP_MINPLUS:
+        *code += OP_POSPLUS - OP_MINPLUS;
+        break;
+
+        case OP_QUERY:
+        *code += OP_POSQUERY - OP_QUERY;
+        break;
+
+        case OP_MINQUERY:
+        *code += OP_POSQUERY - OP_MINQUERY;
+        break;
+
+        case OP_UPTO:
+        *code += OP_POSUPTO - OP_UPTO;
+        break;
+
+        case OP_MINUPTO:
+        *code += OP_POSUPTO - OP_MINUPTO;
+        break;
+        }
+      }
+    c = *code;
+    }
+  else if (c == OP_CLASS || c == OP_NCLASS || c == OP_XCLASS)
+    {
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+    if (c == OP_XCLASS)
+      repeat_opcode = code + GET(code, 1);
+    else
+#endif
+      repeat_opcode = code + 1 + (32 / sizeof(pcre_uchar));
+
+    c = *repeat_opcode;
+    if (c >= OP_CRSTAR && c <= OP_CRMINRANGE)
+      {
+      /* end must not be NULL. */
+      end = get_chr_property_list(code, utf, cd->fcc, list);
+
+      list[1] = (c & 1) == 0;
+
+      rec_limit = 1000;
+      if (compare_opcodes(end, utf, cd, list, end, &rec_limit))
+        {
+        switch (c)
+          {
+          case OP_CRSTAR:
+          case OP_CRMINSTAR:
+          *repeat_opcode = OP_CRPOSSTAR;
+          break;
+
+          case OP_CRPLUS:
+          case OP_CRMINPLUS:
+          *repeat_opcode = OP_CRPOSPLUS;
+          break;
+
+          case OP_CRQUERY:
+          case OP_CRMINQUERY:
+          *repeat_opcode = OP_CRPOSQUERY;
+          break;
+
+          case OP_CRRANGE:
+          case OP_CRMINRANGE:
+          *repeat_opcode = OP_CRPOSRANGE;
+          break;
+          }
+        }
+      }
+    c = *code;
+    }
+
+  switch(c)
+    {
+    case OP_END:
+    return;
+
+    case OP_TYPESTAR:
+    case OP_TYPEMINSTAR:
+    case OP_TYPEPLUS:
+    case OP_TYPEMINPLUS:
+    case OP_TYPEQUERY:
+    case OP_TYPEMINQUERY:
+    case OP_TYPEPOSSTAR:
+    case OP_TYPEPOSPLUS:
+    case OP_TYPEPOSQUERY:
+    if (code[1] == OP_PROP || code[1] == OP_NOTPROP) code += 2;
+    break;
+
+    case OP_TYPEUPTO:
+    case OP_TYPEMINUPTO:
+    case OP_TYPEEXACT:
+    case OP_TYPEPOSUPTO:
+    if (code[1 + IMM2_SIZE] == OP_PROP || code[1 + IMM2_SIZE] == OP_NOTPROP)
+      code += 2;
+    break;
+
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+    case OP_XCLASS:
+    code += GET(code, 1);
+    break;
+#endif
+
+    case OP_MARK:
+    case OP_PRUNE_ARG:
+    case OP_SKIP_ARG:
+    case OP_THEN_ARG:
+    code += code[1];
+    break;
+    }
+
+  /* Add in the fixed length from the table */
+
+  code += PRIV(OP_lengths)[c];
+
+  /* In UTF-8 mode, opcodes that are followed by a character may be followed by
+  a multi-byte character. The length in the table is a minimum, so we have to
+  arrange to skip the extra bytes. */
+
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+  if (utf) switch(c)
+    {
+    case OP_CHAR:
+    case OP_CHARI:
+    case OP_NOT:
+    case OP_NOTI:
+    case OP_STAR:
+    case OP_MINSTAR:
+    case OP_PLUS:
+    case OP_MINPLUS:
+    case OP_QUERY:
+    case OP_MINQUERY:
+    case OP_UPTO:
+    case OP_MINUPTO:
+    case OP_EXACT:
+    case OP_POSSTAR:
+    case OP_POSPLUS:
+    case OP_POSQUERY:
+    case OP_POSUPTO:
+    case OP_STARI:
+    case OP_MINSTARI:
+    case OP_PLUSI:
+    case OP_MINPLUSI:
+    case OP_QUERYI:
+    case OP_MINQUERYI:
+    case OP_UPTOI:
+    case OP_MINUPTOI:
+    case OP_EXACTI:
+    case OP_POSSTARI:
+    case OP_POSPLUSI:
+    case OP_POSQUERYI:
+    case OP_POSUPTOI:
+    case OP_NOTSTAR:
+    case OP_NOTMINSTAR:
+    case OP_NOTPLUS:
+    case OP_NOTMINPLUS:
+    case OP_NOTQUERY:
+    case OP_NOTMINQUERY:
+    case OP_NOTUPTO:
+    case OP_NOTMINUPTO:
+    case OP_NOTEXACT:
+    case OP_NOTPOSSTAR:
+    case OP_NOTPOSPLUS:
+    case OP_NOTPOSQUERY:
+    case OP_NOTPOSUPTO:
+    case OP_NOTSTARI:
+    case OP_NOTMINSTARI:
+    case OP_NOTPLUSI:
+    case OP_NOTMINPLUSI:
+    case OP_NOTQUERYI:
+    case OP_NOTMINQUERYI:
+    case OP_NOTUPTOI:
+    case OP_NOTMINUPTOI:
+    case OP_NOTEXACTI:
+    case OP_NOTPOSSTARI:
+    case OP_NOTPOSPLUSI:
+    case OP_NOTPOSQUERYI:
+    case OP_NOTPOSUPTOI:
+    if (HAS_EXTRALEN(code[-1])) code += GET_EXTRALEN(code[-1]);
+    break;
+    }
+#else
+  (void)(utf);  /* Keep compiler happy by referencing function argument */
+#endif
+  }
+}
+
+
+
+/*************************************************
+*           Check for POSIX class syntax         *
+*************************************************/
+
+/* This function is called when the sequence "[:" or "[." or "[=" is
+encountered in a character class. It checks whether this is followed by a
+sequence of characters terminated by a matching ":]" or ".]" or "=]". If we
+reach an unescaped ']' without the special preceding character, return FALSE.
+
+Originally, this function only recognized a sequence of letters between the
+terminators, but it seems that Perl recognizes any sequence of characters,
+though of course unknown POSIX names are subsequently rejected. Perl gives an
+"Unknown POSIX class" error for [:f\oo:] for example, where previously PCRE
+didn't consider this to be a POSIX class. Likewise for [:1234:].
+
+The problem in trying to be exactly like Perl is in the handling of escapes. We
+have to be sure that [abc[:x\]pqr] is *not* treated as containing a POSIX
+class, but [abc[:x\]pqr:]] is (so that an error can be generated). The code
+below handles the special cases \\ and \], but does not try to do any other
+escape processing. This makes it different from Perl for cases such as
+[:l\ower:] where Perl recognizes it as the POSIX class "lower" but PCRE does
+not recognize "l\ower". This is a lesser evil than not diagnosing bad classes
+when Perl does, I think.
+
+A user pointed out that PCRE was rejecting [:a[:digit:]] whereas Perl was not.
+It seems that the appearance of a nested POSIX class supersedes an apparent
+external class. For example, [:a[:digit:]b:] matches "a", "b", ":", or
+a digit.
+
+In Perl, unescaped square brackets may also appear as part of class names. For
+example, [:a[:abc]b:] gives unknown POSIX class "[:abc]b:]". However, for
+[:a[:abc]b][b:] it gives unknown POSIX class "[:abc]b][b:]", which does not
+seem right at all. PCRE does not allow closing square brackets in POSIX class
+names.
+
+Arguments:
+  ptr      pointer to the initial [
+  endptr   where to return the end pointer
+
+Returns:   TRUE or FALSE
+*/
+
+static BOOL
+check_posix_syntax(const pcre_uchar *ptr, const pcre_uchar **endptr)
+{
+pcre_uchar terminator;          /* Don't combine these lines; the Solaris cc */
+terminator = *(++ptr);   /* compiler warns about "non-constant" initializer. */
+for (++ptr; *ptr != CHAR_NULL; ptr++)
+  {
+  if (*ptr == CHAR_BACKSLASH &&
+      (ptr[1] == CHAR_RIGHT_SQUARE_BRACKET ||
+       ptr[1] == CHAR_BACKSLASH))
+    ptr++;
+  else if ((*ptr == CHAR_LEFT_SQUARE_BRACKET && ptr[1] == terminator) ||
+            *ptr == CHAR_RIGHT_SQUARE_BRACKET) return FALSE;
+  else if (*ptr == terminator && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
+    {
+    *endptr = ptr;
+    return TRUE;
+    }
+  }
+return FALSE;
+}
+
+
+
+
+/*************************************************
+*          Check POSIX class name                *
+*************************************************/
+
+/* This function is called to check the name given in a POSIX-style class entry
+such as [:alnum:].
+
+Arguments:
+  ptr        points to the first letter
+  len        the length of the name
+
+Returns:     a value representing the name, or -1 if unknown
+*/
+
+static int
+check_posix_name(const pcre_uchar *ptr, int len)
+{
+const char *pn = posix_names;
+register int yield = 0;
+while (posix_name_lengths[yield] != 0)
+  {
+  if (len == posix_name_lengths[yield] &&
+    STRNCMP_UC_C8(ptr, pn, (unsigned int)len) == 0) return yield;
+  pn += posix_name_lengths[yield] + 1;
+  yield++;
+  }
+return -1;
+}
+
+
+/*************************************************
+*    Adjust OP_RECURSE items in repeated group   *
+*************************************************/
+
+/* OP_RECURSE items contain an offset from the start of the regex to the group
+that is referenced. This means that groups can be replicated for fixed
+repetition simply by copying (because the recursion is allowed to refer to
+earlier groups that are outside the current group). However, when a group is
+optional (i.e. the minimum quantifier is zero), OP_BRAZERO or OP_SKIPZERO is
+inserted before it, after it has been compiled. This means that any OP_RECURSE
+items within it that refer to the group itself or any contained groups have to
+have their offsets adjusted. That one of the jobs of this function. Before it
+is called, the partially compiled regex must be temporarily terminated with
+OP_END.
+
+This function has been extended to cope with forward references for recursions
+and subroutine calls. It must check the list of such references for the
+group we are dealing with. If it finds that one of the recursions in the
+current group is on this list, it does not adjust the value in the reference
+(which is a group number). After the group has been scanned, all the offsets in
+the forward reference list for the group are adjusted.
+
+Arguments:
+  group      points to the start of the group
+  adjust     the amount by which the group is to be moved
+  utf        TRUE in UTF-8 / UTF-16 / UTF-32 mode
+  cd         contains pointers to tables etc.
+  save_hwm_offset   the hwm forward reference offset at the start of the group
+
+Returns:     nothing
+*/
+
+static void
+adjust_recurse(pcre_uchar *group, int adjust, BOOL utf, compile_data *cd,
+  size_t save_hwm_offset)
+{
+int offset;
+pcre_uchar *hc;
+pcre_uchar *ptr = group;
+
+while ((ptr = (pcre_uchar *)find_recurse(ptr, utf)) != NULL)
+  {
+  for (hc = (pcre_uchar *)cd->start_workspace + save_hwm_offset; hc < cd->hwm;
+       hc += LINK_SIZE)
+    {
+    offset = (int)GET(hc, 0);
+    if (cd->start_code + offset == ptr + 1) break;
+    }
+
+  /* If we have not found this recursion on the forward reference list, adjust
+  the recursion's offset if it's after the start of this group. */
+
+  if (hc >= cd->hwm)
+    {
+    offset = (int)GET(ptr, 1);
+    if (cd->start_code + offset >= group) PUT(ptr, 1, offset + adjust);
+    }
+
+  ptr += 1 + LINK_SIZE;
+  }
+
+/* Now adjust all forward reference offsets for the group. */
+
+for (hc = (pcre_uchar *)cd->start_workspace + save_hwm_offset; hc < cd->hwm;
+     hc += LINK_SIZE)
+  {
+  offset = (int)GET(hc, 0);
+  PUT(hc, 0, offset + adjust);
+  }
+}
+
+
+
+/*************************************************
+*        Insert an automatic callout point       *
+*************************************************/
+
+/* This function is called when the PCRE_AUTO_CALLOUT option is set, to insert
+callout points before each pattern item.
+
+Arguments:
+  code           current code pointer
+  ptr            current pattern pointer
+  cd             pointers to tables etc
+
+Returns:         new code pointer
+*/
+
+static pcre_uchar *
+auto_callout(pcre_uchar *code, const pcre_uchar *ptr, compile_data *cd)
+{
+*code++ = OP_CALLOUT;
+*code++ = 255;
+PUT(code, 0, (int)(ptr - cd->start_pattern));  /* Pattern offset */
+PUT(code, LINK_SIZE, 0);                       /* Default length */
+return code + 2 * LINK_SIZE;
+}
+
+
+
+/*************************************************
+*         Complete a callout item                *
+*************************************************/
+
+/* A callout item contains the length of the next item in the pattern, which
+we can't fill in till after we have reached the relevant point. This is used
+for both automatic and manual callouts.
+
+Arguments:
+  previous_callout   points to previous callout item
+  ptr                current pattern pointer
+  cd                 pointers to tables etc
+
+Returns:             nothing
+*/
+
+static void
+complete_callout(pcre_uchar *previous_callout, const pcre_uchar *ptr, compile_data *cd)
+{
+int length = (int)(ptr - cd->start_pattern - GET(previous_callout, 2));
+PUT(previous_callout, 2 + LINK_SIZE, length);
+}
+
+
+
+#ifdef SUPPORT_UCP
+/*************************************************
+*           Get othercase range                  *
+*************************************************/
+
+/* This function is passed the start and end of a class range, in UTF-8 mode
+with UCP support. It searches up the characters, looking for ranges of
+characters in the "other" case. Each call returns the next one, updating the
+start address. A character with multiple other cases is returned on its own
+with a special return value.
+
+Arguments:
+  cptr        points to starting character value; updated
+  d           end value
+  ocptr       where to put start of othercase range
+  odptr       where to put end of othercase range
+
+Yield:        -1 when no more
+               0 when a range is returned
+              >0 the CASESET offset for char with multiple other cases
+                in this case, ocptr contains the original
+*/
+
+static int
+get_othercase_range(pcre_uint32 *cptr, pcre_uint32 d, pcre_uint32 *ocptr,
+  pcre_uint32 *odptr)
+{
+pcre_uint32 c, othercase, next;
+unsigned int co;
+
+/* Find the first character that has an other case. If it has multiple other
+cases, return its case offset value. */
+
+for (c = *cptr; c <= d; c++)
+  {
+  if ((co = UCD_CASESET(c)) != 0)
+    {
+    *ocptr = c++;   /* Character that has the set */
+    *cptr = c;      /* Rest of input range */
+    return (int)co;
+    }
+  if ((othercase = UCD_OTHERCASE(c)) != c) break;
+  }
+
+if (c > d) return -1;  /* Reached end of range */
+
+/* Found a character that has a single other case. Search for the end of the
+range, which is either the end of the input range, or a character that has zero
+or more than one other cases. */
+
+*ocptr = othercase;
+next = othercase + 1;
+
+for (++c; c <= d; c++)
+  {
+  if ((co = UCD_CASESET(c)) != 0 || UCD_OTHERCASE(c) != next) break;
+  next++;
+  }
+
+*odptr = next - 1;     /* End of othercase range */
+*cptr = c;             /* Rest of input range */
+return 0;
+}
+#endif  /* SUPPORT_UCP */
+
+
+
+/*************************************************
+*        Add a character or range to a class     *
+*************************************************/
+
+/* This function packages up the logic of adding a character or range of
+characters to a class. The character values in the arguments will be within the
+valid values for the current mode (8-bit, 16-bit, UTF, etc). This function is
+mutually recursive with the function immediately below.
+
+Arguments:
+  classbits     the bit map for characters < 256
+  uchardptr     points to the pointer for extra data
+  options       the options word
+  cd            contains pointers to tables etc.
+  start         start of range character
+  end           end of range character
+
+Returns:        the number of < 256 characters added
+                the pointer to extra data is updated
+*/
+
+static int
+add_to_class(pcre_uint8 *classbits, pcre_uchar **uchardptr, int options,
+  compile_data *cd, pcre_uint32 start, pcre_uint32 end)
+{
+pcre_uint32 c;
+pcre_uint32 classbits_end = (end <= 0xff ? end : 0xff);
+int n8 = 0;
+
+/* If caseless matching is required, scan the range and process alternate
+cases. In Unicode, there are 8-bit characters that have alternate cases that
+are greater than 255 and vice-versa. Sometimes we can just extend the original
+range. */
+
+if ((options & PCRE_CASELESS) != 0)
+  {
+#ifdef SUPPORT_UCP
+  if ((options & PCRE_UTF8) != 0)
+    {
+    int rc;
+    pcre_uint32 oc, od;
+
+    options &= ~PCRE_CASELESS;   /* Remove for recursive calls */
+    c = start;
+
+    while ((rc = get_othercase_range(&c, end, &oc, &od)) >= 0)
+      {
+      /* Handle a single character that has more than one other case. */
+
+      if (rc > 0) n8 += add_list_to_class(classbits, uchardptr, options, cd,
+        PRIV(ucd_caseless_sets) + rc, oc);
+
+      /* Do nothing if the other case range is within the original range. */
+
+      else if (oc >= start && od <= end) continue;
+
+      /* Extend the original range if there is overlap, noting that if oc < c, we
+      can't have od > end because a subrange is always shorter than the basic
+      range. Otherwise, use a recursive call to add the additional range. */
+
+      else if (oc < start && od >= start - 1) start = oc; /* Extend downwards */
+      else if (od > end && oc <= end + 1)
+        {
+        end = od;       /* Extend upwards */
+        if (end > classbits_end) classbits_end = (end <= 0xff ? end : 0xff);
+        }
+      else n8 += add_to_class(classbits, uchardptr, options, cd, oc, od);
+      }
+    }
+  else
+#endif  /* SUPPORT_UCP */
+
+  /* Not UTF-mode, or no UCP */
+
+  for (c = start; c <= classbits_end; c++)
+    {
+    SETBIT(classbits, cd->fcc[c]);
+    n8++;
+    }
+  }
+
+/* Now handle the original range. Adjust the final value according to the bit
+length - this means that the same lists of (e.g.) horizontal spaces can be used
+in all cases. */
+
+#if defined COMPILE_PCRE8
+#ifdef SUPPORT_UTF
+  if ((options & PCRE_UTF8) == 0)
+#endif
+  if (end > 0xff) end = 0xff;
+
+#elif defined COMPILE_PCRE16
+#ifdef SUPPORT_UTF
+  if ((options & PCRE_UTF16) == 0)
+#endif
+  if (end > 0xffff) end = 0xffff;
+
+#endif /* COMPILE_PCRE[8|16] */
+
+/* Use the bitmap for characters < 256. Otherwise use extra data.*/
+
+for (c = start; c <= classbits_end; c++)
+  {
+  /* Regardless of start, c will always be <= 255. */
+  SETBIT(classbits, c);
+  n8++;
+  }
+
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+if (start <= 0xff) start = 0xff + 1;
+
+if (end >= start)
+  {
+  pcre_uchar *uchardata = *uchardptr;
+#ifdef SUPPORT_UTF
+  if ((options & PCRE_UTF8) != 0)  /* All UTFs use the same flag bit */
+    {
+    if (start < end)
+      {
+      *uchardata++ = XCL_RANGE;
+      uchardata += PRIV(ord2utf)(start, uchardata);
+      uchardata += PRIV(ord2utf)(end, uchardata);
+      }
+    else if (start == end)
+      {
+      *uchardata++ = XCL_SINGLE;
+      uchardata += PRIV(ord2utf)(start, uchardata);
+      }
+    }
+  else
+#endif  /* SUPPORT_UTF */
+
+  /* Without UTF support, character values are constrained by the bit length,
+  and can only be > 256 for 16-bit and 32-bit libraries. */
+
+#ifdef COMPILE_PCRE8
+    {}
+#else
+  if (start < end)
+    {
+    *uchardata++ = XCL_RANGE;
+    *uchardata++ = start;
+    *uchardata++ = end;
+    }
+  else if (start == end)
+    {
+    *uchardata++ = XCL_SINGLE;
+    *uchardata++ = start;
+    }
+#endif
+
+  *uchardptr = uchardata;   /* Updata extra data pointer */
+  }
+#endif /* SUPPORT_UTF || !COMPILE_PCRE8 */
+
+return n8;    /* Number of 8-bit characters */
+}
+
+
+
+
+/*************************************************
+*        Add a list of characters to a class     *
+*************************************************/
+
+/* This function is used for adding a list of case-equivalent characters to a
+class, and also for adding a list of horizontal or vertical whitespace. If the
+list is in order (which it should be), ranges of characters are detected and
+handled appropriately. This function is mutually recursive with the function
+above.
+
+Arguments:
+  classbits     the bit map for characters < 256
+  uchardptr     points to the pointer for extra data
+  options       the options word
+  cd            contains pointers to tables etc.
+  p             points to row of 32-bit values, terminated by NOTACHAR
+  except        character to omit; this is used when adding lists of
+                  case-equivalent characters to avoid including the one we
+                  already know about
+
+Returns:        the number of < 256 characters added
+                the pointer to extra data is updated
+*/
+
+static int
+add_list_to_class(pcre_uint8 *classbits, pcre_uchar **uchardptr, int options,
+  compile_data *cd, const pcre_uint32 *p, unsigned int except)
+{
+int n8 = 0;
+while (p[0] < NOTACHAR)
+  {
+  int n = 0;
+  if (p[0] != except)
+    {
+    while(p[n+1] == p[0] + n + 1) n++;
+    n8 += add_to_class(classbits, uchardptr, options, cd, p[0], p[n]);
+    }
+  p += n + 1;
+  }
+return n8;
+}
+
+
+
+/*************************************************
+*    Add characters not in a list to a class     *
+*************************************************/
+
+/* This function is used for adding the complement of a list of horizontal or
+vertical whitespace to a class. The list must be in order.
+
+Arguments:
+  classbits     the bit map for characters < 256
+  uchardptr     points to the pointer for extra data
+  options       the options word
+  cd            contains pointers to tables etc.
+  p             points to row of 32-bit values, terminated by NOTACHAR
+
+Returns:        the number of < 256 characters added
+                the pointer to extra data is updated
+*/
+
+static int
+add_not_list_to_class(pcre_uint8 *classbits, pcre_uchar **uchardptr,
+  int options, compile_data *cd, const pcre_uint32 *p)
+{
+BOOL utf = (options & PCRE_UTF8) != 0;
+int n8 = 0;
+if (p[0] > 0)
+  n8 += add_to_class(classbits, uchardptr, options, cd, 0, p[0] - 1);
+while (p[0] < NOTACHAR)
+  {
+  while (p[1] == p[0] + 1) p++;
+  n8 += add_to_class(classbits, uchardptr, options, cd, p[0] + 1,
+    (p[1] == NOTACHAR) ? (utf ? 0x10ffffu : 0xffffffffu) : p[1] - 1);
+  p++;
+  }
+return n8;
+}
+
+
+
+/*************************************************
+*           Compile one branch                   *
+*************************************************/
+
+/* Scan the pattern, compiling it into the a vector. If the options are
+changed during the branch, the pointer is used to change the external options
+bits. This function is used during the pre-compile phase when we are trying
+to find out the amount of memory needed, as well as during the real compile
+phase. The value of lengthptr distinguishes the two phases.
+
+Arguments:
+  optionsptr        pointer to the option bits
+  codeptr           points to the pointer to the current code point
+  ptrptr            points to the current pattern pointer
+  errorcodeptr      points to error code variable
+  firstcharptr      place to put the first required character
+  firstcharflagsptr place to put the first character flags, or a negative number
+  reqcharptr        place to put the last required character
+  reqcharflagsptr   place to put the last required character flags, or a negative number
+  bcptr             points to current branch chain
+  cond_depth        conditional nesting depth
+  cd                contains pointers to tables etc.
+  lengthptr         NULL during the real compile phase
+                    points to length accumulator during pre-compile phase
+
+Returns:            TRUE on success
+                    FALSE, with *errorcodeptr set non-zero on error
+*/
+
+static BOOL
+compile_branch(int *optionsptr, pcre_uchar **codeptr,
+  const pcre_uchar **ptrptr, int *errorcodeptr,
+  pcre_uint32 *firstcharptr, pcre_int32 *firstcharflagsptr,
+  pcre_uint32 *reqcharptr, pcre_int32 *reqcharflagsptr,
+  branch_chain *bcptr, int cond_depth,
+  compile_data *cd, int *lengthptr)
+{
+int repeat_type, op_type;
+int repeat_min = 0, repeat_max = 0;      /* To please picky compilers */
+int bravalue = 0;
+int greedy_default, greedy_non_default;
+pcre_uint32 firstchar, reqchar;
+pcre_int32 firstcharflags, reqcharflags;
+pcre_uint32 zeroreqchar, zerofirstchar;
+pcre_int32 zeroreqcharflags, zerofirstcharflags;
+pcre_int32 req_caseopt, reqvary, tempreqvary;
+int options = *optionsptr;               /* May change dynamically */
+int after_manual_callout = 0;
+int length_prevgroup = 0;
+register pcre_uint32 c;
+int escape;
+register pcre_uchar *code = *codeptr;
+pcre_uchar *last_code = code;
+pcre_uchar *orig_code = code;
+pcre_uchar *tempcode;
+BOOL inescq = FALSE;
+BOOL groupsetfirstchar = FALSE;
+const pcre_uchar *ptr = *ptrptr;
+const pcre_uchar *tempptr;
+const pcre_uchar *nestptr = NULL;
+pcre_uchar *previous = NULL;
+pcre_uchar *previous_callout = NULL;
+size_t item_hwm_offset = 0;
+pcre_uint8 classbits[32];
+
+/* We can fish out the UTF-8 setting once and for all into a BOOL, but we
+must not do this for other options (e.g. PCRE_EXTENDED) because they may change
+dynamically as we process the pattern. */
+
+#ifdef SUPPORT_UTF
+/* PCRE_UTF[16|32] have the same value as PCRE_UTF8. */
+BOOL utf = (options & PCRE_UTF8) != 0;
+#ifndef COMPILE_PCRE32
+pcre_uchar utf_chars[6];
+#endif
+#else
+BOOL utf = FALSE;
+#endif
+
+/* Helper variables for OP_XCLASS opcode (for characters > 255). We define
+class_uchardata always so that it can be passed to add_to_class() always,
+though it will not be used in non-UTF 8-bit cases. This avoids having to supply
+alternative calls for the different cases. */
+
+pcre_uchar *class_uchardata;
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+BOOL xclass;
+pcre_uchar *class_uchardata_base;
+#endif
+
+#ifdef PCRE_DEBUG
+if (lengthptr != NULL) DPRINTF((">> start branch\n"));
+#endif
+
+/* Set up the default and non-default settings for greediness */
+
+greedy_default = ((options & PCRE_UNGREEDY) != 0);
+greedy_non_default = greedy_default ^ 1;
+
+/* Initialize no first byte, no required byte. REQ_UNSET means "no char
+matching encountered yet". It gets changed to REQ_NONE if we hit something that
+matches a non-fixed char first char; reqchar just remains unset if we never
+find one.
+
+When we hit a repeat whose minimum is zero, we may have to adjust these values
+to take the zero repeat into account. This is implemented by setting them to
+zerofirstbyte and zeroreqchar when such a repeat is encountered. The individual
+item types that can be repeated set these backoff variables appropriately. */
+
+firstchar = reqchar = zerofirstchar = zeroreqchar = 0;
+firstcharflags = reqcharflags = zerofirstcharflags = zeroreqcharflags = REQ_UNSET;
+
+/* The variable req_caseopt contains either the REQ_CASELESS value
+or zero, according to the current setting of the caseless flag. The
+REQ_CASELESS leaves the lower 28 bit empty. It is added into the
+firstchar or reqchar variables to record the case status of the
+value. This is used only for ASCII characters. */
+
+req_caseopt = ((options & PCRE_CASELESS) != 0)? REQ_CASELESS:0;
+
+/* Switch on next character until the end of the branch */
+
+for (;; ptr++)
+  {
+  BOOL negate_class;
+  BOOL should_flip_negation;
+  BOOL possessive_quantifier;
+  BOOL is_quantifier;
+  BOOL is_recurse;
+  BOOL reset_bracount;
+  int class_has_8bitchar;
+  int class_one_char;
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+  BOOL xclass_has_prop;
+#endif
+  int newoptions;
+  int recno;
+  int refsign;
+  int skipbytes;
+  pcre_uint32 subreqchar, subfirstchar;
+  pcre_int32 subreqcharflags, subfirstcharflags;
+  int terminator;
+  unsigned int mclength;
+  unsigned int tempbracount;
+  pcre_uint32 ec;
+  pcre_uchar mcbuffer[8];
+
+  /* Come here to restart the loop without advancing the pointer. */
+
+  REDO_LOOP:
+
+  /* Get next character in the pattern */
+
+  c = *ptr;
+
+  /* If we are at the end of a nested substitution, revert to the outer level
+  string. Nesting only happens one level deep. */
+
+  if (c == CHAR_NULL && nestptr != NULL)
+    {
+    ptr = nestptr;
+    nestptr = NULL;
+    c = *ptr;
+    }
+
+  /* If we are in the pre-compile phase, accumulate the length used for the
+  previous cycle of this loop. */
+
+  if (lengthptr != NULL)
+    {
+#ifdef PCRE_DEBUG
+    if (code > cd->hwm) cd->hwm = code;                 /* High water info */
+#endif
+    if (code > cd->start_workspace + cd->workspace_size -
+        WORK_SIZE_SAFETY_MARGIN)                       /* Check for overrun */
+      {
+      *errorcodeptr = (code >= cd->start_workspace + cd->workspace_size)?
+        ERR52 : ERR87;
+      goto FAILED;
+      }
+
+    /* There is at least one situation where code goes backwards: this is the
+    case of a zero quantifier after a class (e.g. [ab]{0}). At compile time,
+    the class is simply eliminated. However, it is created first, so we have to
+    allow memory for it. Therefore, don't ever reduce the length at this point.
+    */
+
+    if (code < last_code) code = last_code;
+
+    /* Paranoid check for integer overflow */
+
+    if (OFLOW_MAX - *lengthptr < code - last_code)
+      {
+      *errorcodeptr = ERR20;
+      goto FAILED;
+      }
+
+    *lengthptr += (int)(code - last_code);
+    DPRINTF(("length=%d added %d c=%c (0x%x)\n", *lengthptr,
+      (int)(code - last_code), c, c));
+
+    /* If "previous" is set and it is not at the start of the work space, move
+    it back to there, in order to avoid filling up the work space. Otherwise,
+    if "previous" is NULL, reset the current code pointer to the start. */
+
+    if (previous != NULL)
+      {
+      if (previous > orig_code)
+        {
+        memmove(orig_code, previous, IN_UCHARS(code - previous));
+        code -= previous - orig_code;
+        previous = orig_code;
+        }
+      }
+    else code = orig_code;
+
+    /* Remember where this code item starts so we can pick up the length
+    next time round. */
+
+    last_code = code;
+    }
+
+  /* In the real compile phase, just check the workspace used by the forward
+  reference list. */
+
+  else if (cd->hwm > cd->start_workspace + cd->workspace_size)
+    {
+    *errorcodeptr = ERR52;
+    goto FAILED;
+    }
+
+  /* If in \Q...\E, check for the end; if not, we have a literal. Otherwise an
+  isolated \E is ignored. */
+
+  if (c != CHAR_NULL)
+    {
+    if (c == CHAR_BACKSLASH && ptr[1] == CHAR_E)
+      {
+      inescq = FALSE;
+      ptr++;
+      continue;
+      }
+    else if (inescq)
+      {
+      if (previous_callout != NULL)
+        {
+        if (lengthptr == NULL)  /* Don't attempt in pre-compile phase */
+          complete_callout(previous_callout, ptr, cd);
+        previous_callout = NULL;
+        }
+      if ((options & PCRE_AUTO_CALLOUT) != 0)
+        {
+        previous_callout = code;
+        code = auto_callout(code, ptr, cd);
+        }
+      goto NORMAL_CHAR;
+      }
+
+    /* Check for the start of a \Q...\E sequence. We must do this here rather
+    than later in case it is immediately followed by \E, which turns it into a
+    "do nothing" sequence. */
+
+    if (c == CHAR_BACKSLASH && ptr[1] == CHAR_Q)
+      {
+      inescq = TRUE;
+      ptr++;
+      continue;
+      }
+    }
+
+  /* In extended mode, skip white space and comments. */
+
+  if ((options & PCRE_EXTENDED) != 0)
+    {
+    const pcre_uchar *wscptr = ptr;
+    while (MAX_255(c) && (cd->ctypes[c] & ctype_space) != 0) c = *(++ptr);
+    if (c == CHAR_NUMBER_SIGN)
+      {
+      ptr++;
+      while (*ptr != CHAR_NULL)
+        {
+        if (IS_NEWLINE(ptr))         /* For non-fixed-length newline cases, */
+          {                          /* IS_NEWLINE sets cd->nllen. */
+          ptr += cd->nllen;
+          break;
+          }
+        ptr++;
+#ifdef SUPPORT_UTF
+        if (utf) FORWARDCHAR(ptr);
+#endif
+        }
+      }
+
+    /* If we skipped any characters, restart the loop. Otherwise, we didn't see
+    a comment. */
+
+    if (ptr > wscptr) goto REDO_LOOP;
+    }
+
+  /* Skip over (?# comments. We need to do this here because we want to know if
+  the next thing is a quantifier, and these comments may come between an item
+  and its quantifier. */
+
+  if (c == CHAR_LEFT_PARENTHESIS && ptr[1] == CHAR_QUESTION_MARK &&
+      ptr[2] == CHAR_NUMBER_SIGN)
+    {
+    ptr += 3;
+    while (*ptr != CHAR_NULL && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
+    if (*ptr == CHAR_NULL)
+      {
+      *errorcodeptr = ERR18;
+      goto FAILED;
+      }
+    continue;
+    }
+
+  /* See if the next thing is a quantifier. */
+
+  is_quantifier =
+    c == CHAR_ASTERISK || c == CHAR_PLUS || c == CHAR_QUESTION_MARK ||
+    (c == CHAR_LEFT_CURLY_BRACKET && is_counted_repeat(ptr+1));
+
+  /* Fill in length of a previous callout, except when the next thing is a
+  quantifier or when processing a property substitution string in UCP mode. */
+
+  if (!is_quantifier && previous_callout != NULL && nestptr == NULL &&
+       after_manual_callout-- <= 0)
+    {
+    if (lengthptr == NULL)      /* Don't attempt in pre-compile phase */
+      complete_callout(previous_callout, ptr, cd);
+    previous_callout = NULL;
+    }
+
+  /* Create auto callout, except for quantifiers, or while processing property
+  strings that are substituted for \w etc in UCP mode. */
+
+  if ((options & PCRE_AUTO_CALLOUT) != 0 && !is_quantifier && nestptr == NULL)
+    {
+    previous_callout = code;
+    code = auto_callout(code, ptr, cd);
+    }
+
+  /* Process the next pattern item. */
+
+  switch(c)
+    {
+    /* ===================================================================*/
+    case CHAR_NULL:                /* The branch terminates at string end */
+    case CHAR_VERTICAL_LINE:       /* or | or ) */
+    case CHAR_RIGHT_PARENTHESIS:
+    *firstcharptr = firstchar;
+    *firstcharflagsptr = firstcharflags;
+    *reqcharptr = reqchar;
+    *reqcharflagsptr = reqcharflags;
+    *codeptr = code;
+    *ptrptr = ptr;
+    if (lengthptr != NULL)
+      {
+      if (OFLOW_MAX - *lengthptr < code - last_code)
+        {
+        *errorcodeptr = ERR20;
+        goto FAILED;
+        }
+      *lengthptr += (int)(code - last_code);   /* To include callout length */
+      DPRINTF((">> end branch\n"));
+      }
+    return TRUE;
+
+
+    /* ===================================================================*/
+    /* Handle single-character metacharacters. In multiline mode, ^ disables
+    the setting of any following char as a first character. */
+
+    case CHAR_CIRCUMFLEX_ACCENT:
+    previous = NULL;
+    if ((options & PCRE_MULTILINE) != 0)
+      {
+      if (firstcharflags == REQ_UNSET)
+        zerofirstcharflags = firstcharflags = REQ_NONE;
+      *code++ = OP_CIRCM;
+      }
+    else *code++ = OP_CIRC;
+    break;
+
+    case CHAR_DOLLAR_SIGN:
+    previous = NULL;
+    *code++ = ((options & PCRE_MULTILINE) != 0)? OP_DOLLM : OP_DOLL;
+    break;
+
+    /* There can never be a first char if '.' is first, whatever happens about
+    repeats. The value of reqchar doesn't change either. */
+
+    case CHAR_DOT:
+    if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
+    zerofirstchar = firstchar;
+    zerofirstcharflags = firstcharflags;
+    zeroreqchar = reqchar;
+    zeroreqcharflags = reqcharflags;
+    previous = code;
+    item_hwm_offset = cd->hwm - cd->start_workspace;
+    *code++ = ((options & PCRE_DOTALL) != 0)? OP_ALLANY: OP_ANY;
+    break;
+
+
+    /* ===================================================================*/
+    /* Character classes. If the included characters are all < 256, we build a
+    32-byte bitmap of the permitted characters, except in the special case
+    where there is only one such character. For negated classes, we build the
+    map as usual, then invert it at the end. However, we use a different opcode
+    so that data characters > 255 can be handled correctly.
+
+    If the class contains characters outside the 0-255 range, a different
+    opcode is compiled. It may optionally have a bit map for characters < 256,
+    but those above are are explicitly listed afterwards. A flag byte tells
+    whether the bitmap is present, and whether this is a negated class or not.
+
+    In JavaScript compatibility mode, an isolated ']' causes an error. In
+    default (Perl) mode, it is treated as a data character. */
+
+    case CHAR_RIGHT_SQUARE_BRACKET:
+    if ((cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)
+      {
+      *errorcodeptr = ERR64;
+      goto FAILED;
+      }
+    goto NORMAL_CHAR;
+
+    /* In another (POSIX) regex library, the ugly syntax [[:<:]] and [[:>:]] is
+    used for "start of word" and "end of word". As these are otherwise illegal
+    sequences, we don't break anything by recognizing them. They are replaced
+    by \b(?=\w) and \b(?<=\w) respectively. Sequences like [a[:<:]] are
+    erroneous and are handled by the normal code below. */
+
+    case CHAR_LEFT_SQUARE_BRACKET:
+    if (STRNCMP_UC_C8(ptr+1, STRING_WEIRD_STARTWORD, 6) == 0)
+      {
+      nestptr = ptr + 7;
+      ptr = sub_start_of_word;
+      goto REDO_LOOP;
+      }
+
+    if (STRNCMP_UC_C8(ptr+1, STRING_WEIRD_ENDWORD, 6) == 0)
+      {
+      nestptr = ptr + 7;
+      ptr = sub_end_of_word;
+      goto REDO_LOOP;
+      }
+
+    /* Handle a real character class. */
+
+    previous = code;
+    item_hwm_offset = cd->hwm - cd->start_workspace;
+
+    /* PCRE supports POSIX class stuff inside a class. Perl gives an error if
+    they are encountered at the top level, so we'll do that too. */
+
+    if ((ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||
+         ptr[1] == CHAR_EQUALS_SIGN) &&
+        check_posix_syntax(ptr, &tempptr))
+      {
+      *errorcodeptr = (ptr[1] == CHAR_COLON)? ERR13 : ERR31;
+      goto FAILED;
+      }
+
+    /* If the first character is '^', set the negation flag and skip it. Also,
+    if the first few characters (either before or after ^) are \Q\E or \E we
+    skip them too. This makes for compatibility with Perl. */
+
+    negate_class = FALSE;
+    for (;;)
+      {
+      c = *(++ptr);
+      if (c == CHAR_BACKSLASH)
+        {
+        if (ptr[1] == CHAR_E)
+          ptr++;
+        else if (STRNCMP_UC_C8(ptr + 1, STR_Q STR_BACKSLASH STR_E, 3) == 0)
+          ptr += 3;
+        else
+          break;
+        }
+      else if (!negate_class && c == CHAR_CIRCUMFLEX_ACCENT)
+        negate_class = TRUE;
+      else break;
+      }
+
+    /* Empty classes are allowed in JavaScript compatibility mode. Otherwise,
+    an initial ']' is taken as a data character -- the code below handles
+    that. In JS mode, [] must always fail, so generate OP_FAIL, whereas
+    [^] must match any character, so generate OP_ALLANY. */
+
+    if (c == CHAR_RIGHT_SQUARE_BRACKET &&
+        (cd->external_options & PCRE_JAVASCRIPT_COMPAT) != 0)
+      {
+      *code++ = negate_class? OP_ALLANY : OP_FAIL;
+      if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
+      zerofirstchar = firstchar;
+      zerofirstcharflags = firstcharflags;
+      break;
+      }
+
+    /* If a class contains a negative special such as \S, we need to flip the
+    negation flag at the end, so that support for characters > 255 works
+    correctly (they are all included in the class). */
+
+    should_flip_negation = FALSE;
+
+    /* Extended class (xclass) will be used when characters > 255
+    might match. */
+
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+    xclass = FALSE;
+    class_uchardata = code + LINK_SIZE + 2;   /* For XCLASS items */
+    class_uchardata_base = class_uchardata;   /* Save the start */
+#endif
+
+    /* For optimization purposes, we track some properties of the class:
+    class_has_8bitchar will be non-zero if the class contains at least one <
+    256 character; class_one_char will be 1 if the class contains just one
+    character; xclass_has_prop will be TRUE if unicode property checks
+    are present in the class. */
+
+    class_has_8bitchar = 0;
+    class_one_char = 0;
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+    xclass_has_prop = FALSE;
+#endif
+
+    /* Initialize the 32-char bit map to all zeros. We build the map in a
+    temporary bit of memory, in case the class contains fewer than two
+    8-bit characters because in that case the compiled code doesn't use the bit
+    map. */
+
+    memset(classbits, 0, 32 * sizeof(pcre_uint8));
+
+    /* Process characters until ] is reached. By writing this as a "do" it
+    means that an initial ] is taken as a data character. At the start of the
+    loop, c contains the first byte of the character. */
+
+    if (c != CHAR_NULL) do
+      {
+      const pcre_uchar *oldptr;
+
+#ifdef SUPPORT_UTF
+      if (utf && HAS_EXTRALEN(c))
+        {                           /* Braces are required because the */
+        GETCHARLEN(c, ptr, ptr);    /* macro generates multiple statements */
+        }
+#endif
+
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+      /* In the pre-compile phase, accumulate the length of any extra
+      data and reset the pointer. This is so that very large classes that
+      contain a zillion > 255 characters no longer overwrite the work space
+      (which is on the stack). We have to remember that there was XCLASS data,
+      however. */
+
+      if (class_uchardata > class_uchardata_base) xclass = TRUE;
+
+      if (lengthptr != NULL && class_uchardata > class_uchardata_base)
+        {
+        *lengthptr += (int)(class_uchardata - class_uchardata_base);
+        class_uchardata = class_uchardata_base;
+        }
+#endif
+
+      /* Inside \Q...\E everything is literal except \E */
+
+      if (inescq)
+        {
+        if (c == CHAR_BACKSLASH && ptr[1] == CHAR_E)  /* If we are at \E */
+          {
+          inescq = FALSE;                   /* Reset literal state */
+          ptr++;                            /* Skip the 'E' */
+          continue;                         /* Carry on with next */
+          }
+        goto CHECK_RANGE;                   /* Could be range if \E follows */
+        }
+
+      /* Handle POSIX class names. Perl allows a negation extension of the
+      form [:^name:]. A square bracket that doesn't match the syntax is
+      treated as a literal. We also recognize the POSIX constructions
+      [.ch.] and [=ch=] ("collating elements") and fault them, as Perl
+      5.6 and 5.8 do. */
+
+      if (c == CHAR_LEFT_SQUARE_BRACKET &&
+          (ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||
+           ptr[1] == CHAR_EQUALS_SIGN) && check_posix_syntax(ptr, &tempptr))
+        {
+        BOOL local_negate = FALSE;
+        int posix_class, taboffset, tabopt;
+        register const pcre_uint8 *cbits = cd->cbits;
+        pcre_uint8 pbits[32];
+
+        if (ptr[1] != CHAR_COLON)
+          {
+          *errorcodeptr = ERR31;
+          goto FAILED;
+          }
+
+        ptr += 2;
+        if (*ptr == CHAR_CIRCUMFLEX_ACCENT)
+          {
+          local_negate = TRUE;
+          should_flip_negation = TRUE;  /* Note negative special */
+          ptr++;
+          }
+
+        posix_class = check_posix_name(ptr, (int)(tempptr - ptr));
+        if (posix_class < 0)
+          {
+          *errorcodeptr = ERR30;
+          goto FAILED;
+          }
+
+        /* If matching is caseless, upper and lower are converted to
+        alpha. This relies on the fact that the class table starts with
+        alpha, lower, upper as the first 3 entries. */
+
+        if ((options & PCRE_CASELESS) != 0 && posix_class <= 2)
+          posix_class = 0;
+
+        /* When PCRE_UCP is set, some of the POSIX classes are converted to
+        different escape sequences that use Unicode properties \p or \P. Others
+        that are not available via \p or \P generate XCL_PROP/XCL_NOTPROP
+        directly. */
+
+#ifdef SUPPORT_UCP
+        if ((options & PCRE_UCP) != 0)
+          {
+          unsigned int ptype = 0;
+          int pc = posix_class + ((local_negate)? POSIX_SUBSIZE/2 : 0);
+
+          /* The posix_substitutes table specifies which POSIX classes can be
+          converted to \p or \P items. */
+
+          if (posix_substitutes[pc] != NULL)
+            {
+            nestptr = tempptr + 1;
+            ptr = posix_substitutes[pc] - 1;
+            continue;
+            }
+
+          /* There are three other classes that generate special property calls
+          that are recognized only in an XCLASS. */
+
+          else switch(posix_class)
+            {
+            case PC_GRAPH:
+            ptype = PT_PXGRAPH;
+            /* Fall through */
+            case PC_PRINT:
+            if (ptype == 0) ptype = PT_PXPRINT;
+            /* Fall through */
+            case PC_PUNCT:
+            if (ptype == 0) ptype = PT_PXPUNCT;
+            *class_uchardata++ = local_negate? XCL_NOTPROP : XCL_PROP;
+            *class_uchardata++ = ptype;
+            *class_uchardata++ = 0;
+            xclass_has_prop = TRUE;
+            ptr = tempptr + 1;
+            continue;
+
+            /* For the other POSIX classes (ascii, cntrl, xdigit) we are going
+            to fall through to the non-UCP case and build a bit map for
+            characters with code points less than 256. If we are in a negated
+            POSIX class, characters with code points greater than 255 must
+            either all match or all not match. In the special case where we
+            have not yet generated any xclass data, and this is the final item
+            in the overall class, we need do nothing: later on, the opcode
+            OP_NCLASS will be used to indicate that characters greater than 255
+            are acceptable. If we have already seen an xclass item or one may
+            follow (we have to assume that it might if this is not the end of
+            the class), explicitly list all wide codepoints, which will then
+            either not match or match, depending on whether the class is or is
+            not negated. */
+
+            default:
+            if (local_negate &&
+                (xclass || tempptr[2] != CHAR_RIGHT_SQUARE_BRACKET))
+              {
+              *class_uchardata++ = XCL_RANGE;
+              class_uchardata += PRIV(ord2utf)(0x100, class_uchardata);
+              class_uchardata += PRIV(ord2utf)(0x10ffff, class_uchardata);
+              }
+            break;
+            }
+          }
+#endif
+        /* In the non-UCP case, or when UCP makes no difference, we build the
+        bit map for the POSIX class in a chunk of local store because we may be
+        adding and subtracting from it, and we don't want to subtract bits that
+        may be in the main map already. At the end we or the result into the
+        bit map that is being built. */
+
+        posix_class *= 3;
+
+        /* Copy in the first table (always present) */
+
+        memcpy(pbits, cbits + posix_class_maps[posix_class],
+          32 * sizeof(pcre_uint8));
+
+        /* If there is a second table, add or remove it as required. */
+
+        taboffset = posix_class_maps[posix_class + 1];
+        tabopt = posix_class_maps[posix_class + 2];
+
+        if (taboffset >= 0)
+          {
+          if (tabopt >= 0)
+            for (c = 0; c < 32; c++) pbits[c] |= cbits[c + taboffset];
+          else
+            for (c = 0; c < 32; c++) pbits[c] &= ~cbits[c + taboffset];
+          }
+
+        /* Now see if we need to remove any special characters. An option
+        value of 1 removes vertical space and 2 removes underscore. */
+
+        if (tabopt < 0) tabopt = -tabopt;
+        if (tabopt == 1) pbits[1] &= ~0x3c;
+          else if (tabopt == 2) pbits[11] &= 0x7f;
+
+        /* Add the POSIX table or its complement into the main table that is
+        being built and we are done. */
+
+        if (local_negate)
+          for (c = 0; c < 32; c++) classbits[c] |= ~pbits[c];
+        else
+          for (c = 0; c < 32; c++) classbits[c] |= pbits[c];
+
+        ptr = tempptr + 1;
+        /* Every class contains at least one < 256 character. */
+        class_has_8bitchar = 1;
+        /* Every class contains at least two characters. */
+        class_one_char = 2;
+        continue;    /* End of POSIX syntax handling */
+        }
+
+      /* Backslash may introduce a single character, or it may introduce one
+      of the specials, which just set a flag. The sequence \b is a special
+      case. Inside a class (and only there) it is treated as backspace. We
+      assume that other escapes have more than one character in them, so
+      speculatively set both class_has_8bitchar and class_one_char bigger
+      than one. Unrecognized escapes fall through and are either treated
+      as literal characters (by default), or are faulted if
+      PCRE_EXTRA is set. */
+
+      if (c == CHAR_BACKSLASH)
+        {
+        escape = check_escape(&ptr, &ec, errorcodeptr, cd->bracount, options,
+          TRUE);
+        if (*errorcodeptr != 0) goto FAILED;
+        if (escape == 0) c = ec;
+        else if (escape == ESC_b) c = CHAR_BS; /* \b is backspace in a class */
+        else if (escape == ESC_N)          /* \N is not supported in a class */
+          {
+          *errorcodeptr = ERR71;
+          goto FAILED;
+          }
+        else if (escape == ESC_Q)            /* Handle start of quoted string */
+          {
+          if (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)
+            {
+            ptr += 2; /* avoid empty string */
+            }
+          else inescq = TRUE;
+          continue;
+          }
+        else if (escape == ESC_E) continue;  /* Ignore orphan \E */
+
+        else
+          {
+          register const pcre_uint8 *cbits = cd->cbits;
+          /* Every class contains at least two < 256 characters. */
+          class_has_8bitchar++;
+          /* Every class contains at least two characters. */
+          class_one_char += 2;
+
+          switch (escape)
+            {
+#ifdef SUPPORT_UCP
+            case ESC_du:     /* These are the values given for \d etc */
+            case ESC_DU:     /* when PCRE_UCP is set. We replace the */
+            case ESC_wu:     /* escape sequence with an appropriate \p */
+            case ESC_WU:     /* or \P to test Unicode properties instead */
+            case ESC_su:     /* of the default ASCII testing. */
+            case ESC_SU:
+            nestptr = ptr;
+            ptr = substitutes[escape - ESC_DU] - 1;  /* Just before substitute */
+            class_has_8bitchar--;                /* Undo! */
+            continue;
+#endif
+            case ESC_d:
+            for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_digit];
+            continue;
+
+            case ESC_D:
+            should_flip_negation = TRUE;
+            for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_digit];
+            continue;
+
+            case ESC_w:
+            for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_word];
+            continue;
+
+            case ESC_W:
+            should_flip_negation = TRUE;
+            for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_word];
+            continue;
+
+            /* Perl 5.004 onwards omitted VT from \s, but restored it at Perl
+            5.18. Before PCRE 8.34, we had to preserve the VT bit if it was
+            previously set by something earlier in the character class.
+            Luckily, the value of CHAR_VT is 0x0b in both ASCII and EBCDIC, so
+            we could just adjust the appropriate bit. From PCRE 8.34 we no
+            longer treat \s and \S specially. */
+
+            case ESC_s:
+            for (c = 0; c < 32; c++) classbits[c] |= cbits[c+cbit_space];
+            continue;
+
+            case ESC_S:
+            should_flip_negation = TRUE;
+            for (c = 0; c < 32; c++) classbits[c] |= ~cbits[c+cbit_space];
+            continue;
+
+            /* The rest apply in both UCP and non-UCP cases. */
+
+            case ESC_h:
+            (void)add_list_to_class(classbits, &class_uchardata, options, cd,
+              PRIV(hspace_list), NOTACHAR);
+            continue;
+
+            case ESC_H:
+            (void)add_not_list_to_class(classbits, &class_uchardata, options,
+              cd, PRIV(hspace_list));
+            continue;
+
+            case ESC_v:
+            (void)add_list_to_class(classbits, &class_uchardata, options, cd,
+              PRIV(vspace_list), NOTACHAR);
+            continue;
+
+            case ESC_V:
+            (void)add_not_list_to_class(classbits, &class_uchardata, options,
+              cd, PRIV(vspace_list));
+            continue;
+
+            case ESC_p:
+            case ESC_P:
+#ifdef SUPPORT_UCP
+              {
+              BOOL negated;
+              unsigned int ptype = 0, pdata = 0;
+              if (!get_ucp(&ptr, &negated, &ptype, &pdata, errorcodeptr))
+                goto FAILED;
+              *class_uchardata++ = ((escape == ESC_p) != negated)?
+                XCL_PROP : XCL_NOTPROP;
+              *class_uchardata++ = ptype;
+              *class_uchardata++ = pdata;
+              xclass_has_prop = TRUE;
+              class_has_8bitchar--;                /* Undo! */
+              continue;
+              }
+#else
+            *errorcodeptr = ERR45;
+            goto FAILED;
+#endif
+            /* Unrecognized escapes are faulted if PCRE is running in its
+            strict mode. By default, for compatibility with Perl, they are
+            treated as literals. */
+
+            default:
+            if ((options & PCRE_EXTRA) != 0)
+              {
+              *errorcodeptr = ERR7;
+              goto FAILED;
+              }
+            class_has_8bitchar--;    /* Undo the speculative increase. */
+            class_one_char -= 2;     /* Undo the speculative increase. */
+            c = *ptr;                /* Get the final character and fall through */
+            break;
+            }
+          }
+
+        /* Fall through if the escape just defined a single character (c >= 0).
+        This may be greater than 256. */
+
+        escape = 0;
+
+        }   /* End of backslash handling */
+
+      /* A character may be followed by '-' to form a range. However, Perl does
+      not permit ']' to be the end of the range. A '-' character at the end is
+      treated as a literal. Perl ignores orphaned \E sequences entirely. The
+      code for handling \Q and \E is messy. */
+
+      CHECK_RANGE:
+      while (ptr[1] == CHAR_BACKSLASH && ptr[2] == CHAR_E)
+        {
+        inescq = FALSE;
+        ptr += 2;
+        }
+      oldptr = ptr;
+
+      /* Remember if \r or \n were explicitly used */
+
+      if (c == CHAR_CR || c == CHAR_NL) cd->external_flags |= PCRE_HASCRORLF;
+
+      /* Check for range */
+
+      if (!inescq && ptr[1] == CHAR_MINUS)
+        {
+        pcre_uint32 d;
+        ptr += 2;
+        while (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_E) ptr += 2;
+
+        /* If we hit \Q (not followed by \E) at this point, go into escaped
+        mode. */
+
+        while (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_Q)
+          {
+          ptr += 2;
+          if (*ptr == CHAR_BACKSLASH && ptr[1] == CHAR_E)
+            { ptr += 2; continue; }
+          inescq = TRUE;
+          break;
+          }
+
+        /* Minus (hyphen) at the end of a class is treated as a literal, so put
+        back the pointer and jump to handle the character that preceded it. */
+
+        if (*ptr == CHAR_NULL || (!inescq && *ptr == CHAR_RIGHT_SQUARE_BRACKET))
+          {
+          ptr = oldptr;
+          goto CLASS_SINGLE_CHARACTER;
+          }
+
+        /* Otherwise, we have a potential range; pick up the next character */
+
+#ifdef SUPPORT_UTF
+        if (utf)
+          {                           /* Braces are required because the */
+          GETCHARLEN(d, ptr, ptr);    /* macro generates multiple statements */
+          }
+        else
+#endif
+        d = *ptr;  /* Not UTF-8 mode */
+
+        /* The second part of a range can be a single-character escape
+        sequence, but not any of the other escapes. Perl treats a hyphen as a
+        literal in such circumstances. However, in Perl's warning mode, a
+        warning is given, so PCRE now faults it as it is almost certainly a
+        mistake on the user's part. */
+
+        if (!inescq)
+          {
+          if (d == CHAR_BACKSLASH)
+            {
+            int descape;
+            descape = check_escape(&ptr, &d, errorcodeptr, cd->bracount, options, TRUE);
+            if (*errorcodeptr != 0) goto FAILED;
+
+            /* 0 means a character was put into d; \b is backspace; any other
+            special causes an error. */
+
+            if (descape != 0)
+              {
+              if (descape == ESC_b) d = CHAR_BS; else
+                {
+                *errorcodeptr = ERR83;
+                goto FAILED;
+                }
+              }
+            }
+
+          /* A hyphen followed by a POSIX class is treated in the same way. */
+
+          else if (d == CHAR_LEFT_SQUARE_BRACKET &&
+                   (ptr[1] == CHAR_COLON || ptr[1] == CHAR_DOT ||
+                    ptr[1] == CHAR_EQUALS_SIGN) &&
+                   check_posix_syntax(ptr, &tempptr))
+            {
+            *errorcodeptr = ERR83;
+            goto FAILED;
+            }
+          }
+
+        /* Check that the two values are in the correct order. Optimize
+        one-character ranges. */
+
+        if (d < c)
+          {
+          *errorcodeptr = ERR8;
+          goto FAILED;
+          }
+        if (d == c) goto CLASS_SINGLE_CHARACTER;  /* A few lines below */
+
+        /* We have found a character range, so single character optimizations
+        cannot be done anymore. Any value greater than 1 indicates that there
+        is more than one character. */
+
+        class_one_char = 2;
+
+        /* Remember an explicit \r or \n, and add the range to the class. */
+
+        if (d == CHAR_CR || d == CHAR_NL) cd->external_flags |= PCRE_HASCRORLF;
+
+        class_has_8bitchar +=
+          add_to_class(classbits, &class_uchardata, options, cd, c, d);
+
+        continue;   /* Go get the next char in the class */
+        }
+
+      /* Handle a single character - we can get here for a normal non-escape
+      char, or after \ that introduces a single character or for an apparent
+      range that isn't. Only the value 1 matters for class_one_char, so don't
+      increase it if it is already 2 or more ... just in case there's a class
+      with a zillion characters in it. */
+
+      CLASS_SINGLE_CHARACTER:
+      if (class_one_char < 2) class_one_char++;
+
+      /* If xclass_has_prop is false and class_one_char is 1, we have the first
+      single character in the class, and there have been no prior ranges, or
+      XCLASS items generated by escapes. If this is the final character in the
+      class, we can optimize by turning the item into a 1-character OP_CHAR[I]
+      if it's positive, or OP_NOT[I] if it's negative. In the positive case, it
+      can cause firstchar to be set. Otherwise, there can be no first char if
+      this item is first, whatever repeat count may follow. In the case of
+      reqchar, save the previous value for reinstating. */
+
+      if (!inescq &&
+#ifdef SUPPORT_UCP
+          !xclass_has_prop &&
+#endif
+          class_one_char == 1 && ptr[1] == CHAR_RIGHT_SQUARE_BRACKET)
+        {
+        ptr++;
+        zeroreqchar = reqchar;
+        zeroreqcharflags = reqcharflags;
+
+        if (negate_class)
+          {
+#ifdef SUPPORT_UCP
+          int d;
+#endif
+          if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
+          zerofirstchar = firstchar;
+          zerofirstcharflags = firstcharflags;
+
+          /* For caseless UTF-8 mode when UCP support is available, check
+          whether this character has more than one other case. If so, generate
+          a special OP_NOTPROP item instead of OP_NOTI. */
+
+#ifdef SUPPORT_UCP
+          if (utf && (options & PCRE_CASELESS) != 0 &&
+              (d = UCD_CASESET(c)) != 0)
+            {
+            *code++ = OP_NOTPROP;
+            *code++ = PT_CLIST;
+            *code++ = d;
+            }
+          else
+#endif
+          /* Char has only one other case, or UCP not available */
+
+            {
+            *code++ = ((options & PCRE_CASELESS) != 0)? OP_NOTI: OP_NOT;
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+            if (utf && c > MAX_VALUE_FOR_SINGLE_CHAR)
+              code += PRIV(ord2utf)(c, code);
+            else
+#endif
+              *code++ = c;
+            }
+
+          /* We are finished with this character class */
+
+          goto END_CLASS;
+          }
+
+        /* For a single, positive character, get the value into mcbuffer, and
+        then we can handle this with the normal one-character code. */
+
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+        if (utf && c > MAX_VALUE_FOR_SINGLE_CHAR)
+          mclength = PRIV(ord2utf)(c, mcbuffer);
+        else
+#endif
+          {
+          mcbuffer[0] = c;
+          mclength = 1;
+          }
+        goto ONE_CHAR;
+        }       /* End of 1-char optimization */
+
+      /* There is more than one character in the class, or an XCLASS item
+      has been generated. Add this character to the class. */
+
+      class_has_8bitchar +=
+        add_to_class(classbits, &class_uchardata, options, cd, c, c);
+      }
+
+    /* Loop until ']' reached. This "while" is the end of the "do" far above.
+    If we are at the end of an internal nested string, revert to the outer
+    string. */
+
+    while (((c = *(++ptr)) != CHAR_NULL ||
+           (nestptr != NULL &&
+             (ptr = nestptr, nestptr = NULL, c = *(++ptr)) != CHAR_NULL)) &&
+           (c != CHAR_RIGHT_SQUARE_BRACKET || inescq));
+
+    /* Check for missing terminating ']' */
+
+    if (c == CHAR_NULL)
+      {
+      *errorcodeptr = ERR6;
+      goto FAILED;
+      }
+
+    /* We will need an XCLASS if data has been placed in class_uchardata. In
+    the second phase this is a sufficient test. However, in the pre-compile
+    phase, class_uchardata gets emptied to prevent workspace overflow, so it
+    only if the very last character in the class needs XCLASS will it contain
+    anything at this point. For this reason, xclass gets set TRUE above when
+    uchar_classdata is emptied, and that's why this code is the way it is here
+    instead of just doing a test on class_uchardata below. */
+
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+    if (class_uchardata > class_uchardata_base) xclass = TRUE;
+#endif
+
+    /* If this is the first thing in the branch, there can be no first char
+    setting, whatever the repeat count. Any reqchar setting must remain
+    unchanged after any kind of repeat. */
+
+    if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
+    zerofirstchar = firstchar;
+    zerofirstcharflags = firstcharflags;
+    zeroreqchar = reqchar;
+    zeroreqcharflags = reqcharflags;
+
+    /* If there are characters with values > 255, we have to compile an
+    extended class, with its own opcode, unless there was a negated special
+    such as \S in the class, and PCRE_UCP is not set, because in that case all
+    characters > 255 are in the class, so any that were explicitly given as
+    well can be ignored. If (when there are explicit characters > 255 that must
+    be listed) there are no characters < 256, we can omit the bitmap in the
+    actual compiled code. */
+
+#ifdef SUPPORT_UTF
+    if (xclass && (xclass_has_prop || !should_flip_negation ||
+        (options & PCRE_UCP) != 0))
+#elif !defined COMPILE_PCRE8
+    if (xclass && (xclass_has_prop || !should_flip_negation))
+#endif
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+      {
+      /* For non-UCP wide characters, in a non-negative class containing \S or
+      similar (should_flip_negation is set), all characters greater than 255
+      must be in the class. */
+
+      if (
+#if defined COMPILE_PCRE8
+           utf &&
+#endif
+           should_flip_negation && !negate_class && (options & PCRE_UCP) == 0)
+        {
+        *class_uchardata++ = XCL_RANGE;
+        if (utf)   /* Will always be utf in the 8-bit library */
+          {
+          class_uchardata += PRIV(ord2utf)(0x100, class_uchardata);
+          class_uchardata += PRIV(ord2utf)(0x10ffff, class_uchardata);
+          }
+        else       /* Can only happen for the 16-bit & 32-bit libraries */
+          {
+#if defined COMPILE_PCRE16
+          *class_uchardata++ = 0x100;
+          *class_uchardata++ = 0xffffu;
+#elif defined COMPILE_PCRE32
+          *class_uchardata++ = 0x100;
+          *class_uchardata++ = 0xffffffffu;
+#endif
+          }
+        }
+
+      *class_uchardata++ = XCL_END;    /* Marks the end of extra data */
+      *code++ = OP_XCLASS;
+      code += LINK_SIZE;
+      *code = negate_class? XCL_NOT:0;
+      if (xclass_has_prop) *code |= XCL_HASPROP;
+
+      /* If the map is required, move up the extra data to make room for it;
+      otherwise just move the code pointer to the end of the extra data. */
+
+      if (class_has_8bitchar > 0)
+        {
+        *code++ |= XCL_MAP;
+        memmove(code + (32 / sizeof(pcre_uchar)), code,
+          IN_UCHARS(class_uchardata - code));
+        if (negate_class && !xclass_has_prop)
+          for (c = 0; c < 32; c++) classbits[c] = ~classbits[c];
+        memcpy(code, classbits, 32);
+        code = class_uchardata + (32 / sizeof(pcre_uchar));
+        }
+      else code = class_uchardata;
+
+      /* Now fill in the complete length of the item */
+
+      PUT(previous, 1, (int)(code - previous));
+      break;   /* End of class handling */
+      }
+
+    /* Even though any XCLASS list is now discarded, we must allow for
+    its memory. */
+
+    if (lengthptr != NULL)
+      *lengthptr += (int)(class_uchardata - class_uchardata_base);
+#endif
+
+    /* If there are no characters > 255, or they are all to be included or
+    excluded, set the opcode to OP_CLASS or OP_NCLASS, depending on whether the
+    whole class was negated and whether there were negative specials such as \S
+    (non-UCP) in the class. Then copy the 32-byte map into the code vector,
+    negating it if necessary. */
+
+    *code++ = (negate_class == should_flip_negation) ? OP_CLASS : OP_NCLASS;
+    if (lengthptr == NULL)    /* Save time in the pre-compile phase */
+      {
+      if (negate_class)
+        for (c = 0; c < 32; c++) classbits[c] = ~classbits[c];
+      memcpy(code, classbits, 32);
+      }
+    code += 32 / sizeof(pcre_uchar);
+
+    END_CLASS:
+    break;
+
+
+    /* ===================================================================*/
+    /* Various kinds of repeat; '{' is not necessarily a quantifier, but this
+    has been tested above. */
+
+    case CHAR_LEFT_CURLY_BRACKET:
+    if (!is_quantifier) goto NORMAL_CHAR;
+    ptr = read_repeat_counts(ptr+1, &repeat_min, &repeat_max, errorcodeptr);
+    if (*errorcodeptr != 0) goto FAILED;
+    goto REPEAT;
+
+    case CHAR_ASTERISK:
+    repeat_min = 0;
+    repeat_max = -1;
+    goto REPEAT;
+
+    case CHAR_PLUS:
+    repeat_min = 1;
+    repeat_max = -1;
+    goto REPEAT;
+
+    case CHAR_QUESTION_MARK:
+    repeat_min = 0;
+    repeat_max = 1;
+
+    REPEAT:
+    if (previous == NULL)
+      {
+      *errorcodeptr = ERR9;
+      goto FAILED;
+      }
+
+    if (repeat_min == 0)
+      {
+      firstchar = zerofirstchar;    /* Adjust for zero repeat */
+      firstcharflags = zerofirstcharflags;
+      reqchar = zeroreqchar;        /* Ditto */
+      reqcharflags = zeroreqcharflags;
+      }
+
+    /* Remember whether this is a variable length repeat */
+
+    reqvary = (repeat_min == repeat_max)? 0 : REQ_VARY;
+
+    op_type = 0;                    /* Default single-char op codes */
+    possessive_quantifier = FALSE;  /* Default not possessive quantifier */
+
+    /* Save start of previous item, in case we have to move it up in order to
+    insert something before it. */
+
+    tempcode = previous;
+
+    /* Before checking for a possessive quantifier, we must skip over
+    whitespace and comments in extended mode because Perl allows white space at
+    this point. */
+
+    if ((options & PCRE_EXTENDED) != 0)
+      {
+      const pcre_uchar *p = ptr + 1;
+      for (;;)
+        {
+        while (MAX_255(*p) && (cd->ctypes[*p] & ctype_space) != 0) p++;
+        if (*p != CHAR_NUMBER_SIGN) break;
+        p++;
+        while (*p != CHAR_NULL)
+          {
+          if (IS_NEWLINE(p))         /* For non-fixed-length newline cases, */
+            {                        /* IS_NEWLINE sets cd->nllen. */
+            p += cd->nllen;
+            break;
+            }
+          p++;
+#ifdef SUPPORT_UTF
+          if (utf) FORWARDCHAR(p);
+#endif
+          }           /* Loop for comment characters */
+        }             /* Loop for multiple comments */
+      ptr = p - 1;    /* Character before the next significant one. */
+      }
+
+    /* We also need to skip over (?# comments, which are not dependent on
+    extended mode. */
+
+    if (ptr[1] == CHAR_LEFT_PARENTHESIS && ptr[2] == CHAR_QUESTION_MARK &&
+        ptr[3] == CHAR_NUMBER_SIGN)
+      {
+      ptr += 4;
+      while (*ptr != CHAR_NULL && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
+      if (*ptr == CHAR_NULL)
+        {
+        *errorcodeptr = ERR18;
+        goto FAILED;
+        }
+      }
+
+    /* If the next character is '+', we have a possessive quantifier. This
+    implies greediness, whatever the setting of the PCRE_UNGREEDY option.
+    If the next character is '?' this is a minimizing repeat, by default,
+    but if PCRE_UNGREEDY is set, it works the other way round. We change the
+    repeat type to the non-default. */
+
+    if (ptr[1] == CHAR_PLUS)
+      {
+      repeat_type = 0;                  /* Force greedy */
+      possessive_quantifier = TRUE;
+      ptr++;
+      }
+    else if (ptr[1] == CHAR_QUESTION_MARK)
+      {
+      repeat_type = greedy_non_default;
+      ptr++;
+      }
+    else repeat_type = greedy_default;
+
+    /* If previous was a recursion call, wrap it in atomic brackets so that
+    previous becomes the atomic group. All recursions were so wrapped in the
+    past, but it no longer happens for non-repeated recursions. In fact, the
+    repeated ones could be re-implemented independently so as not to need this,
+    but for the moment we rely on the code for repeating groups. */
+
+    if (*previous == OP_RECURSE)
+      {
+      memmove(previous + 1 + LINK_SIZE, previous, IN_UCHARS(1 + LINK_SIZE));
+      *previous = OP_ONCE;
+      PUT(previous, 1, 2 + 2*LINK_SIZE);
+      previous[2 + 2*LINK_SIZE] = OP_KET;
+      PUT(previous, 3 + 2*LINK_SIZE, 2 + 2*LINK_SIZE);
+      code += 2 + 2 * LINK_SIZE;
+      length_prevgroup = 3 + 3*LINK_SIZE;
+
+      /* When actually compiling, we need to check whether this was a forward
+      reference, and if so, adjust the offset. */
+
+      if (lengthptr == NULL && cd->hwm >= cd->start_workspace + LINK_SIZE)
+        {
+        int offset = GET(cd->hwm, -LINK_SIZE);
+        if (offset == previous + 1 - cd->start_code)
+          PUT(cd->hwm, -LINK_SIZE, offset + 1 + LINK_SIZE);
+        }
+      }
+
+    /* Now handle repetition for the different types of item. */
+
+    /* If previous was a character or negated character match, abolish the item
+    and generate a repeat item instead. If a char item has a minimum of more
+    than one, ensure that it is set in reqchar - it might not be if a sequence
+    such as x{3} is the first thing in a branch because the x will have gone
+    into firstchar instead.  */
+
+    if (*previous == OP_CHAR || *previous == OP_CHARI
+        || *previous == OP_NOT || *previous == OP_NOTI)
+      {
+      switch (*previous)
+        {
+        default: /* Make compiler happy. */
+        case OP_CHAR:  op_type = OP_STAR - OP_STAR; break;
+        case OP_CHARI: op_type = OP_STARI - OP_STAR; break;
+        case OP_NOT:   op_type = OP_NOTSTAR - OP_STAR; break;
+        case OP_NOTI:  op_type = OP_NOTSTARI - OP_STAR; break;
+        }
+
+      /* Deal with UTF characters that take up more than one character. It's
+      easier to write this out separately than try to macrify it. Use c to
+      hold the length of the character in bytes, plus UTF_LENGTH to flag that
+      it's a length rather than a small character. */
+
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+      if (utf && NOT_FIRSTCHAR(code[-1]))
+        {
+        pcre_uchar *lastchar = code - 1;
+        BACKCHAR(lastchar);
+        c = (int)(code - lastchar);     /* Length of UTF-8 character */
+        memcpy(utf_chars, lastchar, IN_UCHARS(c)); /* Save the char */
+        c |= UTF_LENGTH;                /* Flag c as a length */
+        }
+      else
+#endif /* SUPPORT_UTF */
+
+      /* Handle the case of a single charater - either with no UTF support, or
+      with UTF disabled, or for a single character UTF character. */
+        {
+        c = code[-1];
+        if (*previous <= OP_CHARI && repeat_min > 1)
+          {
+          reqchar = c;
+          reqcharflags = req_caseopt | cd->req_varyopt;
+          }
+        }
+
+      goto OUTPUT_SINGLE_REPEAT;   /* Code shared with single character types */
+      }
+
+    /* If previous was a character type match (\d or similar), abolish it and
+    create a suitable repeat item. The code is shared with single-character
+    repeats by setting op_type to add a suitable offset into repeat_type. Note
+    the the Unicode property types will be present only when SUPPORT_UCP is
+    defined, but we don't wrap the little bits of code here because it just
+    makes it horribly messy. */
+
+    else if (*previous < OP_EODN)
+      {
+      pcre_uchar *oldcode;
+      int prop_type, prop_value;
+      op_type = OP_TYPESTAR - OP_STAR;  /* Use type opcodes */
+      c = *previous;
+
+      OUTPUT_SINGLE_REPEAT:
+      if (*previous == OP_PROP || *previous == OP_NOTPROP)
+        {
+        prop_type = previous[1];
+        prop_value = previous[2];
+        }
+      else prop_type = prop_value = -1;
+
+      oldcode = code;
+      code = previous;                  /* Usually overwrite previous item */
+
+      /* If the maximum is zero then the minimum must also be zero; Perl allows
+      this case, so we do too - by simply omitting the item altogether. */
+
+      if (repeat_max == 0) goto END_REPEAT;
+
+      /* Combine the op_type with the repeat_type */
+
+      repeat_type += op_type;
+
+      /* A minimum of zero is handled either as the special case * or ?, or as
+      an UPTO, with the maximum given. */
+
+      if (repeat_min == 0)
+        {
+        if (repeat_max == -1) *code++ = OP_STAR + repeat_type;
+          else if (repeat_max == 1) *code++ = OP_QUERY + repeat_type;
+        else
+          {
+          *code++ = OP_UPTO + repeat_type;
+          PUT2INC(code, 0, repeat_max);
+          }
+        }
+
+      /* A repeat minimum of 1 is optimized into some special cases. If the
+      maximum is unlimited, we use OP_PLUS. Otherwise, the original item is
+      left in place and, if the maximum is greater than 1, we use OP_UPTO with
+      one less than the maximum. */
+
+      else if (repeat_min == 1)
+        {
+        if (repeat_max == -1)
+          *code++ = OP_PLUS + repeat_type;
+        else
+          {
+          code = oldcode;                 /* leave previous item in place */
+          if (repeat_max == 1) goto END_REPEAT;
+          *code++ = OP_UPTO + repeat_type;
+          PUT2INC(code, 0, repeat_max - 1);
+          }
+        }
+
+      /* The case {n,n} is just an EXACT, while the general case {n,m} is
+      handled as an EXACT followed by an UPTO. */
+
+      else
+        {
+        *code++ = OP_EXACT + op_type;  /* NB EXACT doesn't have repeat_type */
+        PUT2INC(code, 0, repeat_min);
+
+        /* If the maximum is unlimited, insert an OP_STAR. Before doing so,
+        we have to insert the character for the previous code. For a repeated
+        Unicode property match, there are two extra bytes that define the
+        required property. In UTF-8 mode, long characters have their length in
+        c, with the UTF_LENGTH bit as a flag. */
+
+        if (repeat_max < 0)
+          {
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+          if (utf && (c & UTF_LENGTH) != 0)
+            {
+            memcpy(code, utf_chars, IN_UCHARS(c & 7));
+            code += c & 7;
+            }
+          else
+#endif
+            {
+            *code++ = c;
+            if (prop_type >= 0)
+              {
+              *code++ = prop_type;
+              *code++ = prop_value;
+              }
+            }
+          *code++ = OP_STAR + repeat_type;
+          }
+
+        /* Else insert an UPTO if the max is greater than the min, again
+        preceded by the character, for the previously inserted code. If the
+        UPTO is just for 1 instance, we can use QUERY instead. */
+
+        else if (repeat_max != repeat_min)
+          {
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+          if (utf && (c & UTF_LENGTH) != 0)
+            {
+            memcpy(code, utf_chars, IN_UCHARS(c & 7));
+            code += c & 7;
+            }
+          else
+#endif
+          *code++ = c;
+          if (prop_type >= 0)
+            {
+            *code++ = prop_type;
+            *code++ = prop_value;
+            }
+          repeat_max -= repeat_min;
+
+          if (repeat_max == 1)
+            {
+            *code++ = OP_QUERY + repeat_type;
+            }
+          else
+            {
+            *code++ = OP_UPTO + repeat_type;
+            PUT2INC(code, 0, repeat_max);
+            }
+          }
+        }
+
+      /* The character or character type itself comes last in all cases. */
+
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+      if (utf && (c & UTF_LENGTH) != 0)
+        {
+        memcpy(code, utf_chars, IN_UCHARS(c & 7));
+        code += c & 7;
+        }
+      else
+#endif
+      *code++ = c;
+
+      /* For a repeated Unicode property match, there are two extra bytes that
+      define the required property. */
+
+#ifdef SUPPORT_UCP
+      if (prop_type >= 0)
+        {
+        *code++ = prop_type;
+        *code++ = prop_value;
+        }
+#endif
+      }
+
+    /* If previous was a character class or a back reference, we put the repeat
+    stuff after it, but just skip the item if the repeat was {0,0}. */
+
+    else if (*previous == OP_CLASS || *previous == OP_NCLASS ||
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+             *previous == OP_XCLASS ||
+#endif
+             *previous == OP_REF   || *previous == OP_REFI ||
+             *previous == OP_DNREF || *previous == OP_DNREFI)
+      {
+      if (repeat_max == 0)
+        {
+        code = previous;
+        goto END_REPEAT;
+        }
+
+      if (repeat_min == 0 && repeat_max == -1)
+        *code++ = OP_CRSTAR + repeat_type;
+      else if (repeat_min == 1 && repeat_max == -1)
+        *code++ = OP_CRPLUS + repeat_type;
+      else if (repeat_min == 0 && repeat_max == 1)
+        *code++ = OP_CRQUERY + repeat_type;
+      else
+        {
+        *code++ = OP_CRRANGE + repeat_type;
+        PUT2INC(code, 0, repeat_min);
+        if (repeat_max == -1) repeat_max = 0;  /* 2-byte encoding for max */
+        PUT2INC(code, 0, repeat_max);
+        }
+      }
+
+    /* If previous was a bracket group, we may have to replicate it in certain
+    cases. Note that at this point we can encounter only the "basic" bracket
+    opcodes such as BRA and CBRA, as this is the place where they get converted
+    into the more special varieties such as BRAPOS and SBRA. A test for >=
+    OP_ASSERT and <= OP_COND includes ASSERT, ASSERT_NOT, ASSERTBACK,
+    ASSERTBACK_NOT, ONCE, ONCE_NC, BRA, BRAPOS, CBRA, CBRAPOS, and COND.
+    Originally, PCRE did not allow repetition of assertions, but now it does,
+    for Perl compatibility. */
+
+    else if (*previous >= OP_ASSERT && *previous <= OP_COND)
+      {
+      register int i;
+      int len = (int)(code - previous);
+      size_t base_hwm_offset = item_hwm_offset;
+      pcre_uchar *bralink = NULL;
+      pcre_uchar *brazeroptr = NULL;
+
+      /* Repeating a DEFINE group is pointless, but Perl allows the syntax, so
+      we just ignore the repeat. */
+
+      if (*previous == OP_COND && previous[LINK_SIZE+1] == OP_DEF)
+        goto END_REPEAT;
+
+      /* There is no sense in actually repeating assertions. The only potential
+      use of repetition is in cases when the assertion is optional. Therefore,
+      if the minimum is greater than zero, just ignore the repeat. If the
+      maximum is not zero or one, set it to 1. */
+
+      if (*previous < OP_ONCE)    /* Assertion */
+        {
+        if (repeat_min > 0) goto END_REPEAT;
+        if (repeat_max < 0 || repeat_max > 1) repeat_max = 1;
+        }
+
+      /* The case of a zero minimum is special because of the need to stick
+      OP_BRAZERO in front of it, and because the group appears once in the
+      data, whereas in other cases it appears the minimum number of times. For
+      this reason, it is simplest to treat this case separately, as otherwise
+      the code gets far too messy. There are several special subcases when the
+      minimum is zero. */
+
+      if (repeat_min == 0)
+        {
+        /* If the maximum is also zero, we used to just omit the group from the
+        output altogether, like this:
+
+        ** if (repeat_max == 0)
+        **   {
+        **   code = previous;
+        **   goto END_REPEAT;
+        **   }
+
+        However, that fails when a group or a subgroup within it is referenced
+        as a subroutine from elsewhere in the pattern, so now we stick in
+        OP_SKIPZERO in front of it so that it is skipped on execution. As we
+        don't have a list of which groups are referenced, we cannot do this
+        selectively.
+
+        If the maximum is 1 or unlimited, we just have to stick in the BRAZERO
+        and do no more at this point. However, we do need to adjust any
+        OP_RECURSE calls inside the group that refer to the group itself or any
+        internal or forward referenced group, because the offset is from the
+        start of the whole regex. Temporarily terminate the pattern while doing
+        this. */
+
+        if (repeat_max <= 1)    /* Covers 0, 1, and unlimited */
+          {
+          *code = OP_END;
+          adjust_recurse(previous, 1, utf, cd, item_hwm_offset);
+          memmove(previous + 1, previous, IN_UCHARS(len));
+          code++;
+          if (repeat_max == 0)
+            {
+            *previous++ = OP_SKIPZERO;
+            goto END_REPEAT;
+            }
+          brazeroptr = previous;    /* Save for possessive optimizing */
+          *previous++ = OP_BRAZERO + repeat_type;
+          }
+
+        /* If the maximum is greater than 1 and limited, we have to replicate
+        in a nested fashion, sticking OP_BRAZERO before each set of brackets.
+        The first one has to be handled carefully because it's the original
+        copy, which has to be moved up. The remainder can be handled by code
+        that is common with the non-zero minimum case below. We have to
+        adjust the value or repeat_max, since one less copy is required. Once
+        again, we may have to adjust any OP_RECURSE calls inside the group. */
+
+        else
+          {
+          int offset;
+          *code = OP_END;
+          adjust_recurse(previous, 2 + LINK_SIZE, utf, cd, item_hwm_offset);
+          memmove(previous + 2 + LINK_SIZE, previous, IN_UCHARS(len));
+          code += 2 + LINK_SIZE;
+          *previous++ = OP_BRAZERO + repeat_type;
+          *previous++ = OP_BRA;
+
+          /* We chain together the bracket offset fields that have to be
+          filled in later when the ends of the brackets are reached. */
+
+          offset = (bralink == NULL)? 0 : (int)(previous - bralink);
+          bralink = previous;
+          PUTINC(previous, 0, offset);
+          }
+
+        repeat_max--;
+        }
+
+      /* If the minimum is greater than zero, replicate the group as many
+      times as necessary, and adjust the maximum to the number of subsequent
+      copies that we need. If we set a first char from the group, and didn't
+      set a required char, copy the latter from the former. If there are any
+      forward reference subroutine calls in the group, there will be entries on
+      the workspace list; replicate these with an appropriate increment. */
+
+      else
+        {
+        if (repeat_min > 1)
+          {
+          /* In the pre-compile phase, we don't actually do the replication. We
+          just adjust the length as if we had. Do some paranoid checks for
+          potential integer overflow. The INT64_OR_DOUBLE type is a 64-bit
+          integer type when available, otherwise double. */
+
+          if (lengthptr != NULL)
+            {
+            int delta = (repeat_min - 1)*length_prevgroup;
+            if ((INT64_OR_DOUBLE)(repeat_min - 1)*
+                  (INT64_OR_DOUBLE)length_prevgroup >
+                    (INT64_OR_DOUBLE)INT_MAX ||
+                OFLOW_MAX - *lengthptr < delta)
+              {
+              *errorcodeptr = ERR20;
+              goto FAILED;
+              }
+            *lengthptr += delta;
+            }
+
+          /* This is compiling for real. If there is a set first byte for
+          the group, and we have not yet set a "required byte", set it. Make
+          sure there is enough workspace for copying forward references before
+          doing the copy. */
+
+          else
+            {
+            if (groupsetfirstchar && reqcharflags < 0)
+              {
+              reqchar = firstchar;
+              reqcharflags = firstcharflags;
+              }
+
+            for (i = 1; i < repeat_min; i++)
+              {
+              pcre_uchar *hc;
+              size_t this_hwm_offset = cd->hwm - cd->start_workspace;
+              memcpy(code, previous, IN_UCHARS(len));
+
+              while (cd->hwm > cd->start_workspace + cd->workspace_size -
+                     WORK_SIZE_SAFETY_MARGIN -
+                     (this_hwm_offset - base_hwm_offset))
+                {
+                *errorcodeptr = expand_workspace(cd);
+                if (*errorcodeptr != 0) goto FAILED;
+                }
+
+              for (hc = (pcre_uchar *)cd->start_workspace + base_hwm_offset;
+                   hc < (pcre_uchar *)cd->start_workspace + this_hwm_offset;
+                   hc += LINK_SIZE)
+                {
+                PUT(cd->hwm, 0, GET(hc, 0) + len);
+                cd->hwm += LINK_SIZE;
+                }
+              base_hwm_offset = this_hwm_offset;
+              code += len;
+              }
+            }
+          }
+
+        if (repeat_max > 0) repeat_max -= repeat_min;
+        }
+
+      /* This code is common to both the zero and non-zero minimum cases. If
+      the maximum is limited, it replicates the group in a nested fashion,
+      remembering the bracket starts on a stack. In the case of a zero minimum,
+      the first one was set up above. In all cases the repeat_max now specifies
+      the number of additional copies needed. Again, we must remember to
+      replicate entries on the forward reference list. */
+
+      if (repeat_max >= 0)
+        {
+        /* In the pre-compile phase, we don't actually do the replication. We
+        just adjust the length as if we had. For each repetition we must add 1
+        to the length for BRAZERO and for all but the last repetition we must
+        add 2 + 2*LINKSIZE to allow for the nesting that occurs. Do some
+        paranoid checks to avoid integer overflow. The INT64_OR_DOUBLE type is
+        a 64-bit integer type when available, otherwise double. */
+
+        if (lengthptr != NULL && repeat_max > 0)
+          {
+          int delta = repeat_max * (length_prevgroup + 1 + 2 + 2*LINK_SIZE) -
+                      2 - 2*LINK_SIZE;   /* Last one doesn't nest */
+          if ((INT64_OR_DOUBLE)repeat_max *
+                (INT64_OR_DOUBLE)(length_prevgroup + 1 + 2 + 2*LINK_SIZE)
+                  > (INT64_OR_DOUBLE)INT_MAX ||
+              OFLOW_MAX - *lengthptr < delta)
+            {
+            *errorcodeptr = ERR20;
+            goto FAILED;
+            }
+          *lengthptr += delta;
+          }
+
+        /* This is compiling for real */
+
+        else for (i = repeat_max - 1; i >= 0; i--)
+          {
+          pcre_uchar *hc;
+          size_t this_hwm_offset = cd->hwm - cd->start_workspace;
+
+          *code++ = OP_BRAZERO + repeat_type;
+
+          /* All but the final copy start a new nesting, maintaining the
+          chain of brackets outstanding. */
+
+          if (i != 0)
+            {
+            int offset;
+            *code++ = OP_BRA;
+            offset = (bralink == NULL)? 0 : (int)(code - bralink);
+            bralink = code;
+            PUTINC(code, 0, offset);
+            }
+
+          memcpy(code, previous, IN_UCHARS(len));
+
+          /* Ensure there is enough workspace for forward references before
+          copying them. */
+
+          while (cd->hwm > cd->start_workspace + cd->workspace_size -
+                 WORK_SIZE_SAFETY_MARGIN -
+                 (this_hwm_offset - base_hwm_offset))
+            {
+            *errorcodeptr = expand_workspace(cd);
+            if (*errorcodeptr != 0) goto FAILED;
+            }
+
+          for (hc = (pcre_uchar *)cd->start_workspace + base_hwm_offset;
+               hc < (pcre_uchar *)cd->start_workspace + this_hwm_offset;
+               hc += LINK_SIZE)
+            {
+            PUT(cd->hwm, 0, GET(hc, 0) + len + ((i != 0)? 2+LINK_SIZE : 1));
+            cd->hwm += LINK_SIZE;
+            }
+          base_hwm_offset = this_hwm_offset;
+          code += len;
+          }
+
+        /* Now chain through the pending brackets, and fill in their length
+        fields (which are holding the chain links pro tem). */
+
+        while (bralink != NULL)
+          {
+          int oldlinkoffset;
+          int offset = (int)(code - bralink + 1);
+          pcre_uchar *bra = code - offset;
+          oldlinkoffset = GET(bra, 1);
+          bralink = (oldlinkoffset == 0)? NULL : bralink - oldlinkoffset;
+          *code++ = OP_KET;
+          PUTINC(code, 0, offset);
+          PUT(bra, 1, offset);
+          }
+        }
+
+      /* If the maximum is unlimited, set a repeater in the final copy. For
+      ONCE brackets, that's all we need to do. However, possessively repeated
+      ONCE brackets can be converted into non-capturing brackets, as the
+      behaviour of (?:xx)++ is the same as (?>xx)++ and this saves having to
+      deal with possessive ONCEs specially.
+
+      Otherwise, when we are doing the actual compile phase, check to see
+      whether this group is one that could match an empty string. If so,
+      convert the initial operator to the S form (e.g. OP_BRA -> OP_SBRA) so
+      that runtime checking can be done. [This check is also applied to ONCE
+      groups at runtime, but in a different way.]
+
+      Then, if the quantifier was possessive and the bracket is not a
+      conditional, we convert the BRA code to the POS form, and the KET code to
+      KETRPOS. (It turns out to be convenient at runtime to detect this kind of
+      subpattern at both the start and at the end.) The use of special opcodes
+      makes it possible to reduce greatly the stack usage in pcre_exec(). If
+      the group is preceded by OP_BRAZERO, convert this to OP_BRAPOSZERO.
+
+      Then, if the minimum number of matches is 1 or 0, cancel the possessive
+      flag so that the default action below, of wrapping everything inside
+      atomic brackets, does not happen. When the minimum is greater than 1,
+      there will be earlier copies of the group, and so we still have to wrap
+      the whole thing. */
+
+      else
+        {
+        pcre_uchar *ketcode = code - 1 - LINK_SIZE;
+        pcre_uchar *bracode = ketcode - GET(ketcode, 1);
+
+        /* Convert possessive ONCE brackets to non-capturing */
+
+        if ((*bracode == OP_ONCE || *bracode == OP_ONCE_NC) &&
+            possessive_quantifier) *bracode = OP_BRA;
+
+        /* For non-possessive ONCE brackets, all we need to do is to
+        set the KET. */
+
+        if (*bracode == OP_ONCE || *bracode == OP_ONCE_NC)
+          *ketcode = OP_KETRMAX + repeat_type;
+
+        /* Handle non-ONCE brackets and possessive ONCEs (which have been
+        converted to non-capturing above). */
+
+        else
+          {
+          /* In the compile phase, check for empty string matching. */
+
+          if (lengthptr == NULL)
+            {
+            pcre_uchar *scode = bracode;
+            do
+              {
+              if (could_be_empty_branch(scode, ketcode, utf, cd, NULL))
+                {
+                *bracode += OP_SBRA - OP_BRA;
+                break;
+                }
+              scode += GET(scode, 1);
+              }
+            while (*scode == OP_ALT);
+            }
+
+          /* A conditional group with only one branch has an implicit empty
+          alternative branch. */
+
+          if (*bracode == OP_COND && bracode[GET(bracode,1)] != OP_ALT)
+            *bracode = OP_SCOND;
+
+          /* Handle possessive quantifiers. */
+
+          if (possessive_quantifier)
+            {
+            /* For COND brackets, we wrap the whole thing in a possessively
+            repeated non-capturing bracket, because we have not invented POS
+            versions of the COND opcodes. Because we are moving code along, we
+            must ensure that any pending recursive references are updated. */
+
+            if (*bracode == OP_COND || *bracode == OP_SCOND)
+              {
+              int nlen = (int)(code - bracode);
+              *code = OP_END;
+              adjust_recurse(bracode, 1 + LINK_SIZE, utf, cd, item_hwm_offset);
+              memmove(bracode + 1 + LINK_SIZE, bracode, IN_UCHARS(nlen));
+              code += 1 + LINK_SIZE;
+              nlen += 1 + LINK_SIZE;
+              *bracode = (*bracode == OP_COND)? OP_BRAPOS : OP_SBRAPOS;
+              *code++ = OP_KETRPOS;
+              PUTINC(code, 0, nlen);
+              PUT(bracode, 1, nlen);
+              }
+
+            /* For non-COND brackets, we modify the BRA code and use KETRPOS. */
+
+            else
+              {
+              *bracode += 1;              /* Switch to xxxPOS opcodes */
+              *ketcode = OP_KETRPOS;
+              }
+
+            /* If the minimum is zero, mark it as possessive, then unset the
+            possessive flag when the minimum is 0 or 1. */
+
+            if (brazeroptr != NULL) *brazeroptr = OP_BRAPOSZERO;
+            if (repeat_min < 2) possessive_quantifier = FALSE;
+            }
+
+          /* Non-possessive quantifier */
+
+          else *ketcode = OP_KETRMAX + repeat_type;
+          }
+        }
+      }
+
+    /* If previous is OP_FAIL, it was generated by an empty class [] in
+    JavaScript mode. The other ways in which OP_FAIL can be generated, that is
+    by (*FAIL) or (?!) set previous to NULL, which gives a "nothing to repeat"
+    error above. We can just ignore the repeat in JS case. */
+
+    else if (*previous == OP_FAIL) goto END_REPEAT;
+
+    /* Else there's some kind of shambles */
+
+    else
+      {
+      *errorcodeptr = ERR11;
+      goto FAILED;
+      }
+
+    /* If the character following a repeat is '+', possessive_quantifier is
+    TRUE. For some opcodes, there are special alternative opcodes for this
+    case. For anything else, we wrap the entire repeated item inside OP_ONCE
+    brackets. Logically, the '+' notation is just syntactic sugar, taken from
+    Sun's Java package, but the special opcodes can optimize it.
+
+    Some (but not all) possessively repeated subpatterns have already been
+    completely handled in the code just above. For them, possessive_quantifier
+    is always FALSE at this stage. Note that the repeated item starts at
+    tempcode, not at previous, which might be the first part of a string whose
+    (former) last char we repeated. */
+
+    if (possessive_quantifier)
+      {
+      int len;
+
+      /* Possessifying an EXACT quantifier has no effect, so we can ignore it.
+      However, QUERY, STAR, or UPTO may follow (for quantifiers such as {5,6},
+      {5,}, or {5,10}). We skip over an EXACT item; if the length of what
+      remains is greater than zero, there's a further opcode that can be
+      handled. If not, do nothing, leaving the EXACT alone. */
+
+      switch(*tempcode)
+        {
+        case OP_TYPEEXACT:
+        tempcode += PRIV(OP_lengths)[*tempcode] +
+          ((tempcode[1 + IMM2_SIZE] == OP_PROP
+          || tempcode[1 + IMM2_SIZE] == OP_NOTPROP)? 2 : 0);
+        break;
+
+        /* CHAR opcodes are used for exacts whose count is 1. */
+
+        case OP_CHAR:
+        case OP_CHARI:
+        case OP_NOT:
+        case OP_NOTI:
+        case OP_EXACT:
+        case OP_EXACTI:
+        case OP_NOTEXACT:
+        case OP_NOTEXACTI:
+        tempcode += PRIV(OP_lengths)[*tempcode];
+#ifdef SUPPORT_UTF
+        if (utf && HAS_EXTRALEN(tempcode[-1]))
+          tempcode += GET_EXTRALEN(tempcode[-1]);
+#endif
+        break;
+
+        /* For the class opcodes, the repeat operator appears at the end;
+        adjust tempcode to point to it. */
+
+        case OP_CLASS:
+        case OP_NCLASS:
+        tempcode += 1 + 32/sizeof(pcre_uchar);
+        break;
+
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+        case OP_XCLASS:
+        tempcode += GET(tempcode, 1);
+        break;
+#endif
+        }
+
+      /* If tempcode is equal to code (which points to the end of the repeated
+      item), it means we have skipped an EXACT item but there is no following
+      QUERY, STAR, or UPTO; the value of len will be 0, and we do nothing. In
+      all other cases, tempcode will be pointing to the repeat opcode, and will
+      be less than code, so the value of len will be greater than 0. */
+
+      len = (int)(code - tempcode);
+      if (len > 0)
+        {
+        unsigned int repcode = *tempcode;
+
+        /* There is a table for possessifying opcodes, all of which are less
+        than OP_CALLOUT. A zero entry means there is no possessified version.
+        */
+
+        if (repcode < OP_CALLOUT && opcode_possessify[repcode] > 0)
+          *tempcode = opcode_possessify[repcode];
+
+        /* For opcode without a special possessified version, wrap the item in
+        ONCE brackets. Because we are moving code along, we must ensure that any
+        pending recursive references are updated. */
+
+        else
+          {
+          *code = OP_END;
+          adjust_recurse(tempcode, 1 + LINK_SIZE, utf, cd, item_hwm_offset);
+          memmove(tempcode + 1 + LINK_SIZE, tempcode, IN_UCHARS(len));
+          code += 1 + LINK_SIZE;
+          len += 1 + LINK_SIZE;
+          tempcode[0] = OP_ONCE;
+          *code++ = OP_KET;
+          PUTINC(code, 0, len);
+          PUT(tempcode, 1, len);
+          }
+        }
+
+#ifdef NEVER
+      if (len > 0) switch (*tempcode)
+        {
+        case OP_STAR:  *tempcode = OP_POSSTAR; break;
+        case OP_PLUS:  *tempcode = OP_POSPLUS; break;
+        case OP_QUERY: *tempcode = OP_POSQUERY; break;
+        case OP_UPTO:  *tempcode = OP_POSUPTO; break;
+
+        case OP_STARI:  *tempcode = OP_POSSTARI; break;
+        case OP_PLUSI:  *tempcode = OP_POSPLUSI; break;
+        case OP_QUERYI: *tempcode = OP_POSQUERYI; break;
+        case OP_UPTOI:  *tempcode = OP_POSUPTOI; break;
+
+        case OP_NOTSTAR:  *tempcode = OP_NOTPOSSTAR; break;
+        case OP_NOTPLUS:  *tempcode = OP_NOTPOSPLUS; break;
+        case OP_NOTQUERY: *tempcode = OP_NOTPOSQUERY; break;
+        case OP_NOTUPTO:  *tempcode = OP_NOTPOSUPTO; break;
+
+        case OP_NOTSTARI:  *tempcode = OP_NOTPOSSTARI; break;
+        case OP_NOTPLUSI:  *tempcode = OP_NOTPOSPLUSI; break;
+        case OP_NOTQUERYI: *tempcode = OP_NOTPOSQUERYI; break;
+        case OP_NOTUPTOI:  *tempcode = OP_NOTPOSUPTOI; break;
+
+        case OP_TYPESTAR:  *tempcode = OP_TYPEPOSSTAR; break;
+        case OP_TYPEPLUS:  *tempcode = OP_TYPEPOSPLUS; break;
+        case OP_TYPEQUERY: *tempcode = OP_TYPEPOSQUERY; break;
+        case OP_TYPEUPTO:  *tempcode = OP_TYPEPOSUPTO; break;
+
+        case OP_CRSTAR:   *tempcode = OP_CRPOSSTAR; break;
+        case OP_CRPLUS:   *tempcode = OP_CRPOSPLUS; break;
+        case OP_CRQUERY:  *tempcode = OP_CRPOSQUERY; break;
+        case OP_CRRANGE:  *tempcode = OP_CRPOSRANGE; break;
+
+        /* Because we are moving code along, we must ensure that any
+        pending recursive references are updated. */
+
+        default:
+        *code = OP_END;
+        adjust_recurse(tempcode, 1 + LINK_SIZE, utf, cd, item_hwm_offset);
+        memmove(tempcode + 1 + LINK_SIZE, tempcode, IN_UCHARS(len));
+        code += 1 + LINK_SIZE;
+        len += 1 + LINK_SIZE;
+        tempcode[0] = OP_ONCE;
+        *code++ = OP_KET;
+        PUTINC(code, 0, len);
+        PUT(tempcode, 1, len);
+        break;
+        }
+#endif
+      }
+
+    /* In all case we no longer have a previous item. We also set the
+    "follows varying string" flag for subsequently encountered reqchars if
+    it isn't already set and we have just passed a varying length item. */
+
+    END_REPEAT:
+    previous = NULL;
+    cd->req_varyopt |= reqvary;
+    break;
+
+
+    /* ===================================================================*/
+    /* Start of nested parenthesized sub-expression, or comment or lookahead or
+    lookbehind or option setting or condition or all the other extended
+    parenthesis forms.  */
+
+    case CHAR_LEFT_PARENTHESIS:
+    ptr++;
+
+    /* Now deal with various "verbs" that can be introduced by '*'. */
+
+    if (ptr[0] == CHAR_ASTERISK && (ptr[1] == ':'
+         || (MAX_255(ptr[1]) && ((cd->ctypes[ptr[1]] & ctype_letter) != 0))))
+      {
+      int i, namelen;
+      int arglen = 0;
+      const char *vn = verbnames;
+      const pcre_uchar *name = ptr + 1;
+      const pcre_uchar *arg = NULL;
+      previous = NULL;
+      ptr++;
+      while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_letter) != 0) ptr++;
+      namelen = (int)(ptr - name);
+
+      /* It appears that Perl allows any characters whatsoever, other than
+      a closing parenthesis, to appear in arguments, so we no longer insist on
+      letters, digits, and underscores. */
+
+      if (*ptr == CHAR_COLON)
+        {
+        arg = ++ptr;
+        while (*ptr != CHAR_NULL && *ptr != CHAR_RIGHT_PARENTHESIS) ptr++;
+        arglen = (int)(ptr - arg);
+        if ((unsigned int)arglen > MAX_MARK)
+          {
+          *errorcodeptr = ERR75;
+          goto FAILED;
+          }
+        }
+
+      if (*ptr != CHAR_RIGHT_PARENTHESIS)
+        {
+        *errorcodeptr = ERR60;
+        goto FAILED;
+        }
+
+      /* Scan the table of verb names */
+
+      for (i = 0; i < verbcount; i++)
+        {
+        if (namelen == verbs[i].len &&
+            STRNCMP_UC_C8(name, vn, namelen) == 0)
+          {
+          int setverb;
+
+          /* Check for open captures before ACCEPT and convert it to
+          ASSERT_ACCEPT if in an assertion. */
+
+          if (verbs[i].op == OP_ACCEPT)
+            {
+            open_capitem *oc;
+            if (arglen != 0)
+              {
+              *errorcodeptr = ERR59;
+              goto FAILED;
+              }
+            cd->had_accept = TRUE;
+            for (oc = cd->open_caps; oc != NULL; oc = oc->next)
+              {
+              if (lengthptr != NULL)
+                {
+#ifdef COMPILE_PCRE8
+                *lengthptr += 1 + IMM2_SIZE;
+#elif defined COMPILE_PCRE16
+                *lengthptr += 2 + IMM2_SIZE;
+#elif defined COMPILE_PCRE32
+                *lengthptr += 4 + IMM2_SIZE;
+#endif
+                }
+              else
+                {
+                *code++ = OP_CLOSE;
+                PUT2INC(code, 0, oc->number);
+                }
+              }
+            setverb = *code++ =
+              (cd->assert_depth > 0)? OP_ASSERT_ACCEPT : OP_ACCEPT;
+
+            /* Do not set firstchar after *ACCEPT */
+            if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
+            }
+
+          /* Handle other cases with/without an argument */
+
+          else if (arglen == 0)
+            {
+            if (verbs[i].op < 0)   /* Argument is mandatory */
+              {
+              *errorcodeptr = ERR66;
+              goto FAILED;
+              }
+            setverb = *code++ = verbs[i].op;
+            }
+
+          else
+            {
+            if (verbs[i].op_arg < 0)   /* Argument is forbidden */
+              {
+              *errorcodeptr = ERR59;
+              goto FAILED;
+              }
+            setverb = *code++ = verbs[i].op_arg;
+            if (lengthptr != NULL)    /* In pass 1 just add in the length */
+              {                       /* to avoid potential workspace */
+              *lengthptr += arglen;   /* overflow. */
+              *code++ = 0;
+              }
+            else
+              {
+              *code++ = arglen;
+              memcpy(code, arg, IN_UCHARS(arglen));
+              code += arglen;
+              }
+            *code++ = 0;
+            }
+
+          switch (setverb)
+            {
+            case OP_THEN:
+            case OP_THEN_ARG:
+            cd->external_flags |= PCRE_HASTHEN;
+            break;
+
+            case OP_PRUNE:
+            case OP_PRUNE_ARG:
+            case OP_SKIP:
+            case OP_SKIP_ARG:
+            cd->had_pruneorskip = TRUE;
+            break;
+            }
+
+          break;  /* Found verb, exit loop */
+          }
+
+        vn += verbs[i].len + 1;
+        }
+
+      if (i < verbcount) continue;    /* Successfully handled a verb */
+      *errorcodeptr = ERR60;          /* Verb not recognized */
+      goto FAILED;
+      }
+
+    /* Initialize for "real" parentheses */
+
+    newoptions = options;
+    skipbytes = 0;
+    bravalue = OP_CBRA;
+    item_hwm_offset = cd->hwm - cd->start_workspace;
+    reset_bracount = FALSE;
+
+    /* Deal with the extended parentheses; all are introduced by '?', and the
+    appearance of any of them means that this is not a capturing group. */
+
+    if (*ptr == CHAR_QUESTION_MARK)
+      {
+      int i, set, unset, namelen;
+      int *optset;
+      const pcre_uchar *name;
+      pcre_uchar *slot;
+
+      switch (*(++ptr))
+        {
+        /* ------------------------------------------------------------ */
+        case CHAR_VERTICAL_LINE:  /* Reset capture count for each branch */
+        reset_bracount = TRUE;
+        cd->dupgroups = TRUE;     /* Record (?| encountered */
+        /* Fall through */
+
+        /* ------------------------------------------------------------ */
+        case CHAR_COLON:          /* Non-capturing bracket */
+        bravalue = OP_BRA;
+        ptr++;
+        break;
+
+
+        /* ------------------------------------------------------------ */
+        case CHAR_LEFT_PARENTHESIS:
+        bravalue = OP_COND;       /* Conditional group */
+        tempptr = ptr;
+
+        /* A condition can be an assertion, a number (referring to a numbered
+        group's having been set), a name (referring to a named group), or 'R',
+        referring to recursion. R<digits> and R&name are also permitted for
+        recursion tests.
+
+        There are ways of testing a named group: (?(name)) is used by Python;
+        Perl 5.10 onwards uses (?(<name>) or (?('name')).
+
+        There is one unfortunate ambiguity, caused by history. 'R' can be the
+        recursive thing or the name 'R' (and similarly for 'R' followed by
+        digits). We look for a name first; if not found, we try the other case.
+
+        For compatibility with auto-callouts, we allow a callout to be
+        specified before a condition that is an assertion. First, check for the
+        syntax of a callout; if found, adjust the temporary pointer that is
+        used to check for an assertion condition. That's all that is needed! */
+
+        if (ptr[1] == CHAR_QUESTION_MARK && ptr[2] == CHAR_C)
+          {
+          for (i = 3;; i++) if (!IS_DIGIT(ptr[i])) break;
+          if (ptr[i] == CHAR_RIGHT_PARENTHESIS)
+            tempptr += i + 1;
+
+          /* tempptr should now be pointing to the opening parenthesis of the
+          assertion condition. */
+
+          if (*tempptr != CHAR_LEFT_PARENTHESIS)
+            {
+            *errorcodeptr = ERR28;
+            goto FAILED;
+            }
+          }
+
+        /* For conditions that are assertions, check the syntax, and then exit
+        the switch. This will take control down to where bracketed groups,
+        including assertions, are processed. */
+
+        if (tempptr[1] == CHAR_QUESTION_MARK &&
+              (tempptr[2] == CHAR_EQUALS_SIGN ||
+               tempptr[2] == CHAR_EXCLAMATION_MARK ||
+                 (tempptr[2] == CHAR_LESS_THAN_SIGN &&
+                   (tempptr[3] == CHAR_EQUALS_SIGN ||
+                    tempptr[3] == CHAR_EXCLAMATION_MARK))))
+          {
+          cd->iscondassert = TRUE;
+          break;
+          }
+
+        /* Other conditions use OP_CREF/OP_DNCREF/OP_RREF/OP_DNRREF, and all
+        need to skip at least 1+IMM2_SIZE bytes at the start of the group. */
+
+        code[1+LINK_SIZE] = OP_CREF;
+        skipbytes = 1+IMM2_SIZE;
+        refsign = -1;     /* => not a number */
+        namelen = -1;     /* => not a name; must set to avoid warning */
+        name = NULL;      /* Always set to avoid warning */
+        recno = 0;        /* Always set to avoid warning */
+
+        /* Check for a test for recursion in a named group. */
+
+        ptr++;
+        if (*ptr == CHAR_R && ptr[1] == CHAR_AMPERSAND)
+          {
+          terminator = -1;
+          ptr += 2;
+          code[1+LINK_SIZE] = OP_RREF;    /* Change the type of test */
+          }
+
+        /* Check for a test for a named group's having been set, using the Perl
+        syntax (?(<name>) or (?('name'), and also allow for the original PCRE
+        syntax of (?(name) or for (?(+n), (?(-n), and just (?(n). */
+
+        else if (*ptr == CHAR_LESS_THAN_SIGN)
+          {
+          terminator = CHAR_GREATER_THAN_SIGN;
+          ptr++;
+          }
+        else if (*ptr == CHAR_APOSTROPHE)
+          {
+          terminator = CHAR_APOSTROPHE;
+          ptr++;
+          }
+        else
+          {
+          terminator = CHAR_NULL;
+          if (*ptr == CHAR_MINUS || *ptr == CHAR_PLUS) refsign = *ptr++;
+            else if (IS_DIGIT(*ptr)) refsign = 0;
+          }
+
+        /* Handle a number */
+
+        if (refsign >= 0)
+          {
+          while (IS_DIGIT(*ptr))
+            {
+            if (recno > INT_MAX / 10 - 1)  /* Integer overflow */
+              {
+              while (IS_DIGIT(*ptr)) ptr++;
+              *errorcodeptr = ERR61;
+              goto FAILED;
+              }
+            recno = recno * 10 + (int)(*ptr - CHAR_0);
+            ptr++;
+            }
+          }
+
+        /* Otherwise we expect to read a name; anything else is an error. When
+        a name is one of a number of duplicates, a different opcode is used and
+        it needs more memory. Unfortunately we cannot tell whether a name is a
+        duplicate in the first pass, so we have to allow for more memory. */
+
+        else
+          {
+          if (IS_DIGIT(*ptr))
+            {
+            *errorcodeptr = ERR84;
+            goto FAILED;
+            }
+          if (!MAX_255(*ptr) || (cd->ctypes[*ptr] & ctype_word) == 0)
+            {
+            *errorcodeptr = ERR28;   /* Assertion expected */
+            goto FAILED;
+            }
+          name = ptr++;
+          while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_word) != 0)
+            {
+            ptr++;
+            }
+          namelen = (int)(ptr - name);
+          if (lengthptr != NULL) skipbytes += IMM2_SIZE;
+          }
+
+        /* Check the terminator */
+
+        if ((terminator > 0 && *ptr++ != (pcre_uchar)terminator) ||
+            *ptr++ != CHAR_RIGHT_PARENTHESIS)
+          {
+          ptr--;                  /* Error offset */
+          *errorcodeptr = ERR26;  /* Malformed number or name */
+          goto FAILED;
+          }
+
+        /* Do no further checking in the pre-compile phase. */
+
+        if (lengthptr != NULL) break;
+
+        /* In the real compile we do the work of looking for the actual
+        reference. If refsign is not negative, it means we have a number in
+        recno. */
+
+        if (refsign >= 0)
+          {
+          if (recno <= 0)
+            {
+            *errorcodeptr = ERR35;
+            goto FAILED;
+            }
+          if (refsign != 0) recno = (refsign == CHAR_MINUS)?
+            cd->bracount - recno + 1 : recno + cd->bracount;
+          if (recno <= 0 || recno > cd->final_bracount)
+            {
+            *errorcodeptr = ERR15;
+            goto FAILED;
+            }
+          PUT2(code, 2+LINK_SIZE, recno);
+          if (recno > cd->top_backref) cd->top_backref = recno;
+          break;
+          }
+
+        /* Otherwise look for the name. */
+
+        slot = cd->name_table;
+        for (i = 0; i < cd->names_found; i++)
+          {
+          if (STRNCMP_UC_UC(name, slot+IMM2_SIZE, namelen) == 0 &&
+            slot[IMM2_SIZE+namelen] == 0) break;
+          slot += cd->name_entry_size;
+          }
+
+        /* Found the named subpattern. If the name is duplicated, add one to
+        the opcode to change CREF/RREF into DNCREF/DNRREF and insert
+        appropriate data values. Otherwise, just insert the unique subpattern
+        number. */
+
+        if (i < cd->names_found)
+          {
+          int offset = i++;
+          int count = 1;
+          recno = GET2(slot, 0);   /* Number from first found */
+          if (recno > cd->top_backref) cd->top_backref = recno;
+          for (; i < cd->names_found; i++)
+            {
+            slot += cd->name_entry_size;
+            if (STRNCMP_UC_UC(name, slot+IMM2_SIZE, namelen) != 0 ||
+              (slot+IMM2_SIZE)[namelen] != 0) break;
+            count++;
+            }
+
+          if (count > 1)
+            {
+            PUT2(code, 2+LINK_SIZE, offset);
+            PUT2(code, 2+LINK_SIZE+IMM2_SIZE, count);
+            skipbytes += IMM2_SIZE;
+            code[1+LINK_SIZE]++;
+            }
+          else  /* Not a duplicated name */
+            {
+            PUT2(code, 2+LINK_SIZE, recno);
+            }
+          }
+
+        /* If terminator == CHAR_NULL it means that the name followed directly
+        after the opening parenthesis [e.g. (?(abc)...] and in this case there
+        are some further alternatives to try. For the cases where terminator !=
+        CHAR_NULL [things like (?(<name>... or (?('name')... or (?(R&name)... ]
+        we have now checked all the possibilities, so give an error. */
+
+        else if (terminator != CHAR_NULL)
+          {
+          *errorcodeptr = ERR15;
+          goto FAILED;
+          }
+
+        /* Check for (?(R) for recursion. Allow digits after R to specify a
+        specific group number. */
+
+        else if (*name == CHAR_R)
+          {
+          recno = 0;
+          for (i = 1; i < namelen; i++)
+            {
+            if (!IS_DIGIT(name[i]))
+              {
+              *errorcodeptr = ERR15;
+              goto FAILED;
+              }
+            if (recno > INT_MAX / 10 - 1)   /* Integer overflow */
+              {
+              *errorcodeptr = ERR61;
+              goto FAILED;
+              }
+            recno = recno * 10 + name[i] - CHAR_0;
+            }
+          if (recno == 0) recno = RREF_ANY;
+          code[1+LINK_SIZE] = OP_RREF;      /* Change test type */
+          PUT2(code, 2+LINK_SIZE, recno);
+          }
+
+        /* Similarly, check for the (?(DEFINE) "condition", which is always
+        false. */
+
+        else if (namelen == 6 && STRNCMP_UC_C8(name, STRING_DEFINE, 6) == 0)
+          {
+          code[1+LINK_SIZE] = OP_DEF;
+          skipbytes = 1;
+          }
+
+        /* Reference to an unidentified subpattern. */
+
+        else
+          {
+          *errorcodeptr = ERR15;
+          goto FAILED;
+          }
+        break;
+
+
+        /* ------------------------------------------------------------ */
+        case CHAR_EQUALS_SIGN:                 /* Positive lookahead */
+        bravalue = OP_ASSERT;
+        cd->assert_depth += 1;
+        ptr++;
+        break;
+
+        /* Optimize (?!) to (*FAIL) unless it is quantified - which is a weird
+        thing to do, but Perl allows all assertions to be quantified, and when
+        they contain capturing parentheses there may be a potential use for
+        this feature. Not that that applies to a quantified (?!) but we allow
+        it for uniformity. */
+
+        /* ------------------------------------------------------------ */
+        case CHAR_EXCLAMATION_MARK:            /* Negative lookahead */
+        ptr++;
+        if (*ptr == CHAR_RIGHT_PARENTHESIS && ptr[1] != CHAR_ASTERISK &&
+             ptr[1] != CHAR_PLUS && ptr[1] != CHAR_QUESTION_MARK &&
+            (ptr[1] != CHAR_LEFT_CURLY_BRACKET || !is_counted_repeat(ptr+2)))
+          {
+          *code++ = OP_FAIL;
+          previous = NULL;
+          continue;
+          }
+        bravalue = OP_ASSERT_NOT;
+        cd->assert_depth += 1;
+        break;
+
+
+        /* ------------------------------------------------------------ */
+        case CHAR_LESS_THAN_SIGN:              /* Lookbehind or named define */
+        switch (ptr[1])
+          {
+          case CHAR_EQUALS_SIGN:               /* Positive lookbehind */
+          bravalue = OP_ASSERTBACK;
+          cd->assert_depth += 1;
+          ptr += 2;
+          break;
+
+          case CHAR_EXCLAMATION_MARK:          /* Negative lookbehind */
+          bravalue = OP_ASSERTBACK_NOT;
+          cd->assert_depth += 1;
+          ptr += 2;
+          break;
+
+          default:                /* Could be name define, else bad */
+          if (MAX_255(ptr[1]) && (cd->ctypes[ptr[1]] & ctype_word) != 0)
+            goto DEFINE_NAME;
+          ptr++;                  /* Correct offset for error */
+          *errorcodeptr = ERR24;
+          goto FAILED;
+          }
+        break;
+
+
+        /* ------------------------------------------------------------ */
+        case CHAR_GREATER_THAN_SIGN:           /* One-time brackets */
+        bravalue = OP_ONCE;
+        ptr++;
+        break;
+
+
+        /* ------------------------------------------------------------ */
+        case CHAR_C:                 /* Callout - may be followed by digits; */
+        previous_callout = code;     /* Save for later completion */
+        after_manual_callout = 1;    /* Skip one item before completing */
+        *code++ = OP_CALLOUT;
+          {
+          int n = 0;
+          ptr++;
+          while(IS_DIGIT(*ptr))
+            n = n * 10 + *ptr++ - CHAR_0;
+          if (*ptr != CHAR_RIGHT_PARENTHESIS)
+            {
+            *errorcodeptr = ERR39;
+            goto FAILED;
+            }
+          if (n > 255)
+            {
+            *errorcodeptr = ERR38;
+            goto FAILED;
+            }
+          *code++ = n;
+          PUT(code, 0, (int)(ptr - cd->start_pattern + 1)); /* Pattern offset */
+          PUT(code, LINK_SIZE, 0);                          /* Default length */
+          code += 2 * LINK_SIZE;
+          }
+        previous = NULL;
+        continue;
+
+
+        /* ------------------------------------------------------------ */
+        case CHAR_P:              /* Python-style named subpattern handling */
+        if (*(++ptr) == CHAR_EQUALS_SIGN ||
+            *ptr == CHAR_GREATER_THAN_SIGN)  /* Reference or recursion */
+          {
+          is_recurse = *ptr == CHAR_GREATER_THAN_SIGN;
+          terminator = CHAR_RIGHT_PARENTHESIS;
+          goto NAMED_REF_OR_RECURSE;
+          }
+        else if (*ptr != CHAR_LESS_THAN_SIGN)  /* Test for Python-style defn */
+          {
+          *errorcodeptr = ERR41;
+          goto FAILED;
+          }
+        /* Fall through to handle (?P< as (?< is handled */
+
+
+        /* ------------------------------------------------------------ */
+        DEFINE_NAME:    /* Come here from (?< handling */
+        case CHAR_APOSTROPHE:
+        terminator = (*ptr == CHAR_LESS_THAN_SIGN)?
+          CHAR_GREATER_THAN_SIGN : CHAR_APOSTROPHE;
+        name = ++ptr;
+        if (IS_DIGIT(*ptr))
+          {
+          *errorcodeptr = ERR84;   /* Group name must start with non-digit */
+          goto FAILED;
+          }
+        while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_word) != 0) ptr++;
+        namelen = (int)(ptr - name);
+
+        /* In the pre-compile phase, do a syntax check, remember the longest
+        name, and then remember the group in a vector, expanding it if
+        necessary. Duplicates for the same number are skipped; other duplicates
+        are checked for validity. In the actual compile, there is nothing to
+        do. */
+
+        if (lengthptr != NULL)
+          {
+          named_group *ng;
+          pcre_uint32 number = cd->bracount + 1;
+
+          if (*ptr != (pcre_uchar)terminator)
+            {
+            *errorcodeptr = ERR42;
+            goto FAILED;
+            }
+
+          if (cd->names_found >= MAX_NAME_COUNT)
+            {
+            *errorcodeptr = ERR49;
+            goto FAILED;
+            }
+
+          if (namelen + IMM2_SIZE + 1 > cd->name_entry_size)
+            {
+            cd->name_entry_size = namelen + IMM2_SIZE + 1;
+            if (namelen > MAX_NAME_SIZE)
+              {
+              *errorcodeptr = ERR48;
+              goto FAILED;
+              }
+            }
+
+          /* Scan the list to check for duplicates. For duplicate names, if the
+          number is the same, break the loop, which causes the name to be
+          discarded; otherwise, if DUPNAMES is not set, give an error.
+          If it is set, allow the name with a different number, but continue
+          scanning in case this is a duplicate with the same number. For
+          non-duplicate names, give an error if the number is duplicated. */
+
+          ng = cd->named_groups;
+          for (i = 0; i < cd->names_found; i++, ng++)
+            {
+            if (namelen == ng->length &&
+                STRNCMP_UC_UC(name, ng->name, namelen) == 0)
+              {
+              if (ng->number == number) break;
+              if ((options & PCRE_DUPNAMES) == 0)
+                {
+                *errorcodeptr = ERR43;
+                goto FAILED;
+                }
+              cd->dupnames = TRUE;  /* Duplicate names exist */
+              }
+            else if (ng->number == number)
+              {
+              *errorcodeptr = ERR65;
+              goto FAILED;
+              }
+            }
+
+          if (i >= cd->names_found)     /* Not a duplicate with same number */
+            {
+            /* Increase the list size if necessary */
+
+            if (cd->names_found >= cd->named_group_list_size)
+              {
+              int newsize = cd->named_group_list_size * 2;
+              named_group *newspace = (PUBL(malloc))
+                (newsize * sizeof(named_group));
+
+              if (newspace == NULL)
+                {
+                *errorcodeptr = ERR21;
+                goto FAILED;
+                }
+
+              memcpy(newspace, cd->named_groups,
+                cd->named_group_list_size * sizeof(named_group));
+              if (cd->named_group_list_size > NAMED_GROUP_LIST_SIZE)
+                (PUBL(free))((void *)cd->named_groups);
+              cd->named_groups = newspace;
+              cd->named_group_list_size = newsize;
+              }
+
+            cd->named_groups[cd->names_found].name = name;
+            cd->named_groups[cd->names_found].length = namelen;
+            cd->named_groups[cd->names_found].number = number;
+            cd->names_found++;
+            }
+          }
+
+        ptr++;                    /* Move past > or ' in both passes. */
+        goto NUMBERED_GROUP;
+
+
+        /* ------------------------------------------------------------ */
+        case CHAR_AMPERSAND:            /* Perl recursion/subroutine syntax */
+        terminator = CHAR_RIGHT_PARENTHESIS;
+        is_recurse = TRUE;
+        /* Fall through */
+
+        /* We come here from the Python syntax above that handles both
+        references (?P=name) and recursion (?P>name), as well as falling
+        through from the Perl recursion syntax (?&name). We also come here from
+        the Perl \k<name> or \k'name' back reference syntax and the \k{name}
+        .NET syntax, and the Oniguruma \g<...> and \g'...' subroutine syntax. */
+
+        NAMED_REF_OR_RECURSE:
+        name = ++ptr;
+        if (IS_DIGIT(*ptr))
+          {
+          *errorcodeptr = ERR84;   /* Group name must start with non-digit */
+          goto FAILED;
+          }
+        while (MAX_255(*ptr) && (cd->ctypes[*ptr] & ctype_word) != 0) ptr++;
+        namelen = (int)(ptr - name);
+
+        /* In the pre-compile phase, do a syntax check. We used to just set
+        a dummy reference number, because it was not used in the first pass.
+        However, with the change of recursive back references to be atomic,
+        we have to look for the number so that this state can be identified, as
+        otherwise the incorrect length is computed. If it's not a backwards
+        reference, the dummy number will do. */
+
+        if (lengthptr != NULL)
+          {
+          named_group *ng;
+          recno = 0;
+
+          if (namelen == 0)
+            {
+            *errorcodeptr = ERR62;
+            goto FAILED;
+            }
+          if (*ptr != (pcre_uchar)terminator)
+            {
+            *errorcodeptr = ERR42;
+            goto FAILED;
+            }
+          if (namelen > MAX_NAME_SIZE)
+            {
+            *errorcodeptr = ERR48;
+            goto FAILED;
+            }
+
+          /* Count named back references. */
+
+          if (!is_recurse) cd->namedrefcount++;
+
+          /* We have to allow for a named reference to a duplicated name (this
+          cannot be determined until the second pass). This needs an extra
+          16-bit data item. */
+
+          *lengthptr += IMM2_SIZE;
+
+          /* If this is a forward reference and we are within a (?|...) group,
+          the reference may end up as the number of a group which we are
+          currently inside, that is, it could be a recursive reference. In the
+          real compile this will be picked up and the reference wrapped with
+          OP_ONCE to make it atomic, so we must space in case this occurs. */
+
+          /* In fact, this can happen for a non-forward reference because
+          another group with the same number might be created later. This
+          issue is fixed "properly" in PCRE2. As PCRE1 is now in maintenance
+          only mode, we finesse the bug by allowing more memory always. */
+
+          *lengthptr += 4 + 4*LINK_SIZE;
+
+          /* It is even worse than that. The current reference may be to an
+          existing named group with a different number (so apparently not
+          recursive) but which later on is also attached to a group with the
+          current number. This can only happen if $(| has been previous
+          encountered. In that case, we allow yet more memory, just in case.
+          (Again, this is fixed "properly" in PCRE2. */
+
+          if (cd->dupgroups) *lengthptr += 4 + 4*LINK_SIZE;
+
+          /* Otherwise, check for recursion here. The name table does not exist
+          in the first pass; instead we must scan the list of names encountered
+          so far in order to get the number. If the name is not found, leave
+          the value of recno as 0 for a forward reference. */
+
+          /* This patch (removing "else") fixes a problem when a reference is
+          to multiple identically named nested groups from within the nest.
+          Once again, it is not the "proper" fix, and it results in an
+          over-allocation of memory. */
+
+          /* else */
+            {
+            ng = cd->named_groups;
+            for (i = 0; i < cd->names_found; i++, ng++)
+              {
+              if (namelen == ng->length &&
+                  STRNCMP_UC_UC(name, ng->name, namelen) == 0)
+                {
+                open_capitem *oc;
+                recno = ng->number;
+                if (is_recurse) break;
+                for (oc = cd->open_caps; oc != NULL; oc = oc->next)
+                  {
+                  if (oc->number == recno)
+                    {
+                    oc->flag = TRUE;
+                    break;
+                    }
+                  }
+                }
+              }
+            }
+          }
+
+        /* In the real compile, search the name table. We check the name
+        first, and then check that we have reached the end of the name in the
+        table. That way, if the name is longer than any in the table, the
+        comparison will fail without reading beyond the table entry. */
+
+        else
+          {
+          slot = cd->name_table;
+          for (i = 0; i < cd->names_found; i++)
+            {
+            if (STRNCMP_UC_UC(name, slot+IMM2_SIZE, namelen) == 0 &&
+                slot[IMM2_SIZE+namelen] == 0)
+              break;
+            slot += cd->name_entry_size;
+            }
+
+          if (i < cd->names_found)
+            {
+            recno = GET2(slot, 0);
+            }
+          else
+            {
+            *errorcodeptr = ERR15;
+            goto FAILED;
+            }
+          }
+
+        /* In both phases, for recursions, we can now go to the code than
+        handles numerical recursion. */
+
+        if (is_recurse) goto HANDLE_RECURSION;
+
+        /* In the second pass we must see if the name is duplicated. If so, we
+        generate a different opcode. */
+
+        if (lengthptr == NULL && cd->dupnames)
+          {
+          int count = 1;
+          unsigned int index = i;
+          pcre_uchar *cslot = slot + cd->name_entry_size;
+
+          for (i++; i < cd->names_found; i++)
+            {
+            if (STRCMP_UC_UC(slot + IMM2_SIZE, cslot + IMM2_SIZE) != 0) break;
+            count++;
+            cslot += cd->name_entry_size;
+            }
+
+          if (count > 1)
+            {
+            if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
+            previous = code;
+            item_hwm_offset = cd->hwm - cd->start_workspace;
+            *code++ = ((options & PCRE_CASELESS) != 0)? OP_DNREFI : OP_DNREF;
+            PUT2INC(code, 0, index);
+            PUT2INC(code, 0, count);
+
+            /* Process each potentially referenced group. */
+
+            for (; slot < cslot; slot += cd->name_entry_size)
+              {
+              open_capitem *oc;
+              recno = GET2(slot, 0);
+              cd->backref_map |= (recno < 32)? (1 << recno) : 1;
+              if (recno > cd->top_backref) cd->top_backref = recno;
+
+              /* Check to see if this back reference is recursive, that it, it
+              is inside the group that it references. A flag is set so that the
+              group can be made atomic. */
+
+              for (oc = cd->open_caps; oc != NULL; oc = oc->next)
+                {
+                if (oc->number == recno)
+                  {
+                  oc->flag = TRUE;
+                  break;
+                  }
+                }
+              }
+
+            continue;  /* End of back ref handling */
+            }
+          }
+
+        /* First pass, or a non-duplicated name. */
+
+        goto HANDLE_REFERENCE;
+
+
+        /* ------------------------------------------------------------ */
+        case CHAR_R:              /* Recursion, same as (?0) */
+        recno = 0;
+        if (*(++ptr) != CHAR_RIGHT_PARENTHESIS)
+          {
+          *errorcodeptr = ERR29;
+          goto FAILED;
+          }
+        goto HANDLE_RECURSION;
+
+
+        /* ------------------------------------------------------------ */
+        case CHAR_MINUS: case CHAR_PLUS:  /* Recursion or subroutine */
+        case CHAR_0: case CHAR_1: case CHAR_2: case CHAR_3: case CHAR_4:
+        case CHAR_5: case CHAR_6: case CHAR_7: case CHAR_8: case CHAR_9:
+          {
+          const pcre_uchar *called;
+          terminator = CHAR_RIGHT_PARENTHESIS;
+
+          /* Come here from the \g<...> and \g'...' code (Oniguruma
+          compatibility). However, the syntax has been checked to ensure that
+          the ... are a (signed) number, so that neither ERR63 nor ERR29 will
+          be called on this path, nor with the jump to OTHER_CHAR_AFTER_QUERY
+          ever be taken. */
+
+          HANDLE_NUMERICAL_RECURSION:
+
+          if ((refsign = *ptr) == CHAR_PLUS)
+            {
+            ptr++;
+            if (!IS_DIGIT(*ptr))
+              {
+              *errorcodeptr = ERR63;
+              goto FAILED;
+              }
+            }
+          else if (refsign == CHAR_MINUS)
+            {
+            if (!IS_DIGIT(ptr[1]))
+              goto OTHER_CHAR_AFTER_QUERY;
+            ptr++;
+            }
+
+          recno = 0;
+          while(IS_DIGIT(*ptr))
+            {
+            if (recno > INT_MAX / 10 - 1) /* Integer overflow */
+              {
+              while (IS_DIGIT(*ptr)) ptr++;
+              *errorcodeptr = ERR61;
+              goto FAILED;
+              }
+            recno = recno * 10 + *ptr++ - CHAR_0;
+            }
+
+          if (*ptr != (pcre_uchar)terminator)
+            {
+            *errorcodeptr = ERR29;
+            goto FAILED;
+            }
+
+          if (refsign == CHAR_MINUS)
+            {
+            if (recno == 0)
+              {
+              *errorcodeptr = ERR58;
+              goto FAILED;
+              }
+            recno = cd->bracount - recno + 1;
+            if (recno <= 0)
+              {
+              *errorcodeptr = ERR15;
+              goto FAILED;
+              }
+            }
+          else if (refsign == CHAR_PLUS)
+            {
+            if (recno == 0)
+              {
+              *errorcodeptr = ERR58;
+              goto FAILED;
+              }
+            recno += cd->bracount;
+            }
+
+          /* Come here from code above that handles a named recursion */
+
+          HANDLE_RECURSION:
+
+          previous = code;
+          item_hwm_offset = cd->hwm - cd->start_workspace;
+          called = cd->start_code;
+
+          /* When we are actually compiling, find the bracket that is being
+          referenced. Temporarily end the regex in case it doesn't exist before
+          this point. If we end up with a forward reference, first check that
+          the bracket does occur later so we can give the error (and position)
+          now. Then remember this forward reference in the workspace so it can
+          be filled in at the end. */
+
+          if (lengthptr == NULL)
+            {
+            *code = OP_END;
+            if (recno != 0)
+              called = PRIV(find_bracket)(cd->start_code, utf, recno);
+
+            /* Forward reference */
+
+            if (called == NULL)
+              {
+              if (recno > cd->final_bracount)
+                {
+                *errorcodeptr = ERR15;
+                goto FAILED;
+                }
+
+              /* Fudge the value of "called" so that when it is inserted as an
+              offset below, what it actually inserted is the reference number
+              of the group. Then remember the forward reference. */
+
+              called = cd->start_code + recno;
+              if (cd->hwm >= cd->start_workspace + cd->workspace_size -
+                  WORK_SIZE_SAFETY_MARGIN)
+                {
+                *errorcodeptr = expand_workspace(cd);
+                if (*errorcodeptr != 0) goto FAILED;
+                }
+              PUTINC(cd->hwm, 0, (int)(code + 1 - cd->start_code));
+              }
+
+            /* If not a forward reference, and the subpattern is still open,
+            this is a recursive call. We check to see if this is a left
+            recursion that could loop for ever, and diagnose that case. We
+            must not, however, do this check if we are in a conditional
+            subpattern because the condition might be testing for recursion in
+            a pattern such as /(?(R)a+|(?R)b)/, which is perfectly valid.
+            Forever loops are also detected at runtime, so those that occur in
+            conditional subpatterns will be picked up then. */
+
+            else if (GET(called, 1) == 0 && cond_depth <= 0 &&
+                     could_be_empty(called, code, bcptr, utf, cd))
+              {
+              *errorcodeptr = ERR40;
+              goto FAILED;
+              }
+            }
+
+          /* Insert the recursion/subroutine item. It does not have a set first
+          character (relevant if it is repeated, because it will then be
+          wrapped with ONCE brackets). */
+
+          *code = OP_RECURSE;
+          PUT(code, 1, (int)(called - cd->start_code));
+          code += 1 + LINK_SIZE;
+          groupsetfirstchar = FALSE;
+          }
+
+        /* Can't determine a first byte now */
+
+        if (firstcharflags == REQ_UNSET) firstcharflags = REQ_NONE;
+		zerofirstchar = firstchar;
+		zerofirstcharflags = firstcharflags;
+        continue;
+
+
+        /* ------------------------------------------------------------ */
+        default:              /* Other characters: check option setting */
+        OTHER_CHAR_AFTER_QUERY:
+        set = unset = 0;
+        optset = &set;
+
+        while (*ptr != CHAR_RIGHT_PARENTHESIS && *ptr != CHAR_COLON)
+          {
+          switch (*ptr++)
+            {
+            case CHAR_MINUS: optset = &unset; break;
+
+            case CHAR_J:    /* Record that it changed in the external options */
+            *optset |= PCRE_DUPNAMES;
+            cd->external_flags |= PCRE_JCHANGED;
+            break;
+
+            case CHAR_i: *optset |= PCRE_CASELESS; break;
+            case CHAR_m: *optset |= PCRE_MULTILINE; break;
+            case CHAR_s: *optset |= PCRE_DOTALL; break;
+            case CHAR_x: *optset |= PCRE_EXTENDED; break;
+            case CHAR_U: *optset |= PCRE_UNGREEDY; break;
+            case CHAR_X: *optset |= PCRE_EXTRA; break;
+
+            default:  *errorcodeptr = ERR12;
+                      ptr--;    /* Correct the offset */
+                      goto FAILED;
+            }
+          }
+
+        /* Set up the changed option bits, but don't change anything yet. */
+
+        newoptions = (options | set) & (~unset);
+
+        /* If the options ended with ')' this is not the start of a nested
+        group with option changes, so the options change at this level.
+        If we are not at the pattern start, reset the greedy defaults and the
+        case value for firstchar and reqchar. */
+
+        if (*ptr == CHAR_RIGHT_PARENTHESIS)
+          {
+          greedy_default = ((newoptions & PCRE_UNGREEDY) != 0);
+          greedy_non_default = greedy_default ^ 1;
+          req_caseopt = ((newoptions & PCRE_CASELESS) != 0)? REQ_CASELESS:0;
+
+          /* Change options at this level, and pass them back for use
+          in subsequent branches. */
+
+          *optionsptr = options = newoptions;
+          previous = NULL;       /* This item can't be repeated */
+          continue;              /* It is complete */
+          }
+
+        /* If the options ended with ':' we are heading into a nested group
+        with possible change of options. Such groups are non-capturing and are
+        not assertions of any kind. All we need to do is skip over the ':';
+        the newoptions value is handled below. */
+
+        bravalue = OP_BRA;
+        ptr++;
+        }     /* End of switch for character following (? */
+      }       /* End of (? handling */
+
+    /* Opening parenthesis not followed by '*' or '?'. If PCRE_NO_AUTO_CAPTURE
+    is set, all unadorned brackets become non-capturing and behave like (?:...)
+    brackets. */
+
+    else if ((options & PCRE_NO_AUTO_CAPTURE) != 0)
+      {
+      bravalue = OP_BRA;
+      }
+
+    /* Else we have a capturing group. */
+
+    else
+      {
+      NUMBERED_GROUP:
+      cd->bracount += 1;
+      PUT2(code, 1+LINK_SIZE, cd->bracount);
+      skipbytes = IMM2_SIZE;
+      }
+
+    /* Process nested bracketed regex. First check for parentheses nested too
+    deeply. */
+
+    if ((cd->parens_depth += 1) > PARENS_NEST_LIMIT)
+      {
+      *errorcodeptr = ERR82;
+      goto FAILED;
+      }
+
+    /* All assertions used not to be repeatable, but this was changed for Perl
+    compatibility. All kinds can now be repeated except for assertions that are
+    conditions (Perl also forbids these to be repeated). We copy code into a
+    non-register variable (tempcode) in order to be able to pass its address
+    because some compilers complain otherwise. At the start of a conditional
+    group whose condition is an assertion, cd->iscondassert is set. We unset it
+    here so as to allow assertions later in the group to be quantified. */
+
+    if (bravalue >= OP_ASSERT && bravalue <= OP_ASSERTBACK_NOT &&
+        cd->iscondassert)
+      {
+      previous = NULL;
+      cd->iscondassert = FALSE;
+      }
+    else
+      {
+      previous = code;
+      item_hwm_offset = cd->hwm - cd->start_workspace;
+      }
+
+    *code = bravalue;
+    tempcode = code;
+    tempreqvary = cd->req_varyopt;        /* Save value before bracket */
+    tempbracount = cd->bracount;          /* Save value before bracket */
+    length_prevgroup = 0;                 /* Initialize for pre-compile phase */
+
+    if (!compile_regex(
+         newoptions,                      /* The complete new option state */
+         &tempcode,                       /* Where to put code (updated) */
+         &ptr,                            /* Input pointer (updated) */
+         errorcodeptr,                    /* Where to put an error message */
+         (bravalue == OP_ASSERTBACK ||
+          bravalue == OP_ASSERTBACK_NOT), /* TRUE if back assert */
+         reset_bracount,                  /* True if (?| group */
+         skipbytes,                       /* Skip over bracket number */
+         cond_depth +
+           ((bravalue == OP_COND)?1:0),   /* Depth of condition subpatterns */
+         &subfirstchar,                   /* For possible first char */
+         &subfirstcharflags,
+         &subreqchar,                     /* For possible last char */
+         &subreqcharflags,
+         bcptr,                           /* Current branch chain */
+         cd,                              /* Tables block */
+         (lengthptr == NULL)? NULL :      /* Actual compile phase */
+           &length_prevgroup              /* Pre-compile phase */
+         ))
+      goto FAILED;
+
+    cd->parens_depth -= 1;
+
+    /* If this was an atomic group and there are no capturing groups within it,
+    generate OP_ONCE_NC instead of OP_ONCE. */
+
+    if (bravalue == OP_ONCE && cd->bracount <= tempbracount)
+      *code = OP_ONCE_NC;
+
+    if (bravalue >= OP_ASSERT && bravalue <= OP_ASSERTBACK_NOT)
+      cd->assert_depth -= 1;
+
+    /* At the end of compiling, code is still pointing to the start of the
+    group, while tempcode has been updated to point past the end of the group.
+    The pattern pointer (ptr) is on the bracket.
+
+    If this is a conditional bracket, check that there are no more than
+    two branches in the group, or just one if it's a DEFINE group. We do this
+    in the real compile phase, not in the pre-pass, where the whole group may
+    not be available. */
+
+    if (bravalue == OP_COND && lengthptr == NULL)
+      {
+      pcre_uchar *tc = code;
+      int condcount = 0;
+
+      do {
+         condcount++;
+         tc += GET(tc,1);
+         }
+      while (*tc != OP_KET);
+
+      /* A DEFINE group is never obeyed inline (the "condition" is always
+      false). It must have only one branch. */
+
+      if (code[LINK_SIZE+1] == OP_DEF)
+        {
+        if (condcount > 1)
+          {
+          *errorcodeptr = ERR54;
+          goto FAILED;
+          }
+        bravalue = OP_DEF;   /* Just a flag to suppress char handling below */
+        }
+
+      /* A "normal" conditional group. If there is just one branch, we must not
+      make use of its firstchar or reqchar, because this is equivalent to an
+      empty second branch. */
+
+      else
+        {
+        if (condcount > 2)
+          {
+          *errorcodeptr = ERR27;
+          goto FAILED;
+          }
+        if (condcount == 1) subfirstcharflags = subreqcharflags = REQ_NONE;
+        }
+      }
+
+    /* Error if hit end of pattern */
+
+    if (*ptr != CHAR_RIGHT_PARENTHESIS)
+      {
+      *errorcodeptr = ERR14;
+      goto FAILED;
+      }
+
+    /* In the pre-compile phase, update the length by the length of the group,
+    less the brackets at either end. Then reduce the compiled code to just a
+    set of non-capturing brackets so that it doesn't use much memory if it is
+    duplicated by a quantifier.*/
+
+    if (lengthptr != NULL)
+      {
+      if (OFLOW_MAX - *lengthptr < length_prevgroup - 2 - 2*LINK_SIZE)
+        {
+        *errorcodeptr = ERR20;
+        goto FAILED;
+        }
+      *lengthptr += length_prevgroup - 2 - 2*LINK_SIZE;
+      code++;   /* This already contains bravalue */
+      PUTINC(code, 0, 1 + LINK_SIZE);
+      *code++ = OP_KET;
+      PUTINC(code, 0, 1 + LINK_SIZE);
+      break;    /* No need to waste time with special character handling */
+      }
+
+    /* Otherwise update the main code pointer to the end of the group. */
+
+    code = tempcode;
+
+    /* For a DEFINE group, required and first character settings are not
+    relevant. */
+
+    if (bravalue == OP_DEF) break;
+
+    /* Handle updating of the required and first characters for other types of
+    group. Update for normal brackets of all kinds, and conditions with two
+    branches (see code above). If the bracket is followed by a quantifier with
+    zero repeat, we have to back off. Hence the definition of zeroreqchar and
+    zerofirstchar outside the main loop so that they can be accessed for the
+    back off. */
+
+    zeroreqchar = reqchar;
+    zeroreqcharflags = reqcharflags;
+    zerofirstchar = firstchar;
+    zerofirstcharflags = firstcharflags;
+    groupsetfirstchar = FALSE;
+
+    if (bravalue >= OP_ONCE)
+      {
+      /* If we have not yet set a firstchar in this branch, take it from the
+      subpattern, remembering that it was set here so that a repeat of more
+      than one can replicate it as reqchar if necessary. If the subpattern has
+      no firstchar, set "none" for the whole branch. In both cases, a zero
+      repeat forces firstchar to "none". */
+
+      if (firstcharflags == REQ_UNSET)
+        {
+        if (subfirstcharflags >= 0)
+          {
+          firstchar = subfirstchar;
+          firstcharflags = subfirstcharflags;
+          groupsetfirstchar = TRUE;
+          }
+        else firstcharflags = REQ_NONE;
+        zerofirstcharflags = REQ_NONE;
+        }
+
+      /* If firstchar was previously set, convert the subpattern's firstchar
+      into reqchar if there wasn't one, using the vary flag that was in
+      existence beforehand. */
+
+      else if (subfirstcharflags >= 0 && subreqcharflags < 0)
+        {
+        subreqchar = subfirstchar;
+        subreqcharflags = subfirstcharflags | tempreqvary;
+        }
+
+      /* If the subpattern set a required byte (or set a first byte that isn't
+      really the first byte - see above), set it. */
+
+      if (subreqcharflags >= 0)
+        {
+        reqchar = subreqchar;
+        reqcharflags = subreqcharflags;
+        }
+      }
+
+    /* For a forward assertion, we take the reqchar, if set, provided that the
+    group has also set a first char. This can be helpful if the pattern that
+    follows the assertion doesn't set a different char. For example, it's
+    useful for /(?=abcde).+/. We can't set firstchar for an assertion, however
+    because it leads to incorrect effect for patterns such as /(?=a)a.+/ when
+    the "real" "a" would then become a reqchar instead of a firstchar. This is
+    overcome by a scan at the end if there's no firstchar, looking for an
+    asserted first char. */
+
+    else if (bravalue == OP_ASSERT && subreqcharflags >= 0 &&
+             subfirstcharflags >= 0)
+      {
+      reqchar = subreqchar;
+      reqcharflags = subreqcharflags;
+      }
+    break;     /* End of processing '(' */
+
+
+    /* ===================================================================*/
+    /* Handle metasequences introduced by \. For ones like \d, the ESC_ values
+    are arranged to be the negation of the corresponding OP_values in the
+    default case when PCRE_UCP is not set. For the back references, the values
+    are negative the reference number. Only back references and those types
+    that consume a character may be repeated. We can test for values between
+    ESC_b and ESC_Z for the latter; this may have to change if any new ones are
+    ever created. */
+
+    case CHAR_BACKSLASH:
+    tempptr = ptr;
+    escape = check_escape(&ptr, &ec, errorcodeptr, cd->bracount, options, FALSE);
+    if (*errorcodeptr != 0) goto FAILED;
+
+    if (escape == 0)                  /* The escape coded a single character */
+      c = ec;
+    else
+      {
+      /* For metasequences that actually match a character, we disable the
+      setting of a first character if it hasn't already been set. */
+
+      if (firstcharflags == REQ_UNSET && escape > ESC_b && escape < ESC_Z)
+        firstcharflags = REQ_NONE;
+
+      /* Set values to reset to if this is followed by a zero repeat. */
+
+      zerofirstchar = firstchar;
+      zerofirstcharflags = firstcharflags;
+      zeroreqchar = reqchar;
+      zeroreqcharflags = reqcharflags;
+
+      /* \g<name> or \g'name' is a subroutine call by name and \g<n> or \g'n'
+      is a subroutine call by number (Oniguruma syntax). In fact, the value
+      ESC_g is returned only for these cases. So we don't need to check for <
+      or ' if the value is ESC_g. For the Perl syntax \g{n} the value is
+      -n, and for the Perl syntax \g{name} the result is ESC_k (as
+      that is a synonym for a named back reference). */
+
+      if (escape == ESC_g)
+        {
+        const pcre_uchar *p;
+        pcre_uint32 cf;
+
+        item_hwm_offset = cd->hwm - cd->start_workspace;   /* Normally this is set when '(' is read */
+        terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?
+          CHAR_GREATER_THAN_SIGN : CHAR_APOSTROPHE;
+
+        /* These two statements stop the compiler for warning about possibly
+        unset variables caused by the jump to HANDLE_NUMERICAL_RECURSION. In
+        fact, because we do the check for a number below, the paths that
+        would actually be in error are never taken. */
+
+        skipbytes = 0;
+        reset_bracount = FALSE;
+
+        /* If it's not a signed or unsigned number, treat it as a name. */
+
+        cf = ptr[1];
+        if (cf != CHAR_PLUS && cf != CHAR_MINUS && !IS_DIGIT(cf))
+          {
+          is_recurse = TRUE;
+          goto NAMED_REF_OR_RECURSE;
+          }
+
+        /* Signed or unsigned number (cf = ptr[1]) is known to be plus or minus
+        or a digit. */
+
+        p = ptr + 2;
+        while (IS_DIGIT(*p)) p++;
+        if (*p != (pcre_uchar)terminator)
+          {
+          *errorcodeptr = ERR57;
+          goto FAILED;
+          }
+        ptr++;
+        goto HANDLE_NUMERICAL_RECURSION;
+        }
+
+      /* \k<name> or \k'name' is a back reference by name (Perl syntax).
+      We also support \k{name} (.NET syntax).  */
+
+      if (escape == ESC_k)
+        {
+        if ((ptr[1] != CHAR_LESS_THAN_SIGN &&
+          ptr[1] != CHAR_APOSTROPHE && ptr[1] != CHAR_LEFT_CURLY_BRACKET))
+          {
+          *errorcodeptr = ERR69;
+          goto FAILED;
+          }
+        is_recurse = FALSE;
+        terminator = (*(++ptr) == CHAR_LESS_THAN_SIGN)?
+          CHAR_GREATER_THAN_SIGN : (*ptr == CHAR_APOSTROPHE)?
+          CHAR_APOSTROPHE : CHAR_RIGHT_CURLY_BRACKET;
+        goto NAMED_REF_OR_RECURSE;
+        }
+
+      /* Back references are handled specially; must disable firstchar if
+      not set to cope with cases like (?=(\w+))\1: which would otherwise set
+      ':' later. */
+
+      if (escape < 0)
+        {
+        open_capitem *oc;
+        recno = -escape;
+
+        /* Come here from named backref handling when the reference is to a
+        single group (i.e. not to a duplicated name. */
+
+        HANDLE_REFERENCE:
+        if (firstcharflags == REQ_UNSET) zerofirstcharflags = firstcharflags = REQ_NONE;
+        previous = code;
+        item_hwm_offset = cd->hwm - cd->start_workspace;
+        *code++ = ((options & PCRE_CASELESS) != 0)? OP_REFI : OP_REF;
+        PUT2INC(code, 0, recno);
+        cd->backref_map |= (recno < 32)? (1 << recno) : 1;
+        if (recno > cd->top_backref) cd->top_backref = recno;
+
+        /* Check to see if this back reference is recursive, that it, it
+        is inside the group that it references. A flag is set so that the
+        group can be made atomic. */
+
+        for (oc = cd->open_caps; oc != NULL; oc = oc->next)
+          {
+          if (oc->number == recno)
+            {
+            oc->flag = TRUE;
+            break;
+            }
+          }
+        }
+
+      /* So are Unicode property matches, if supported. */
+
+#ifdef SUPPORT_UCP
+      else if (escape == ESC_P || escape == ESC_p)
+        {
+        BOOL negated;
+        unsigned int ptype = 0, pdata = 0;
+        if (!get_ucp(&ptr, &negated, &ptype, &pdata, errorcodeptr))
+          goto FAILED;
+        previous = code;
+        item_hwm_offset = cd->hwm - cd->start_workspace;
+        *code++ = ((escape == ESC_p) != negated)? OP_PROP : OP_NOTPROP;
+        *code++ = ptype;
+        *code++ = pdata;
+        }
+#else
+
+      /* If Unicode properties are not supported, \X, \P, and \p are not
+      allowed. */
+
+      else if (escape == ESC_X || escape == ESC_P || escape == ESC_p)
+        {
+        *errorcodeptr = ERR45;
+        goto FAILED;
+        }
+#endif
+
+      /* For the rest (including \X when Unicode properties are supported), we
+      can obtain the OP value by negating the escape value in the default
+      situation when PCRE_UCP is not set. When it *is* set, we substitute
+      Unicode property tests. Note that \b and \B do a one-character
+      lookbehind, and \A also behaves as if it does. */
+
+      else
+        {
+        if ((escape == ESC_b || escape == ESC_B || escape == ESC_A) &&
+             cd->max_lookbehind == 0)
+          cd->max_lookbehind = 1;
+#ifdef SUPPORT_UCP
+        if (escape >= ESC_DU && escape <= ESC_wu)
+          {
+          nestptr = ptr + 1;                   /* Where to resume */
+          ptr = substitutes[escape - ESC_DU] - 1;  /* Just before substitute */
+          }
+        else
+#endif
+        /* In non-UTF-8 mode, we turn \C into OP_ALLANY instead of OP_ANYBYTE
+        so that it works in DFA mode and in lookbehinds. */
+
+          {
+          previous = (escape > ESC_b && escape < ESC_Z)? code : NULL;
+          item_hwm_offset = cd->hwm - cd->start_workspace;
+          *code++ = (!utf && escape == ESC_C)? OP_ALLANY : escape;
+          }
+        }
+      continue;
+      }
+
+    /* We have a data character whose value is in c. In UTF-8 mode it may have
+    a value > 127. We set its representation in the length/buffer, and then
+    handle it as a data character. */
+
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+    if (utf && c > MAX_VALUE_FOR_SINGLE_CHAR)
+      mclength = PRIV(ord2utf)(c, mcbuffer);
+    else
+#endif
+
+     {
+     mcbuffer[0] = c;
+     mclength = 1;
+     }
+    goto ONE_CHAR;
+
+
+    /* ===================================================================*/
+    /* Handle a literal character. It is guaranteed not to be whitespace or #
+    when the extended flag is set. If we are in a UTF mode, it may be a
+    multi-unit literal character. */
+
+    default:
+    NORMAL_CHAR:
+    mclength = 1;
+    mcbuffer[0] = c;
+
+#ifdef SUPPORT_UTF
+    if (utf && HAS_EXTRALEN(c))
+      ACROSSCHAR(TRUE, ptr[1], mcbuffer[mclength++] = *(++ptr));
+#endif
+
+    /* At this point we have the character's bytes in mcbuffer, and the length
+    in mclength. When not in UTF-8 mode, the length is always 1. */
+
+    ONE_CHAR:
+    previous = code;
+    item_hwm_offset = cd->hwm - cd->start_workspace;
+
+    /* For caseless UTF-8 mode when UCP support is available, check whether
+    this character has more than one other case. If so, generate a special
+    OP_PROP item instead of OP_CHARI. */
+
+#ifdef SUPPORT_UCP
+    if (utf && (options & PCRE_CASELESS) != 0)
+      {
+      GETCHAR(c, mcbuffer);
+      if ((c = UCD_CASESET(c)) != 0)
+        {
+        *code++ = OP_PROP;
+        *code++ = PT_CLIST;
+        *code++ = c;
+        if (firstcharflags == REQ_UNSET)
+          firstcharflags = zerofirstcharflags = REQ_NONE;
+        break;
+        }
+      }
+#endif
+
+    /* Caseful matches, or not one of the multicase characters. */
+
+    *code++ = ((options & PCRE_CASELESS) != 0)? OP_CHARI : OP_CHAR;
+    for (c = 0; c < mclength; c++) *code++ = mcbuffer[c];
+
+    /* Remember if \r or \n were seen */
+
+    if (mcbuffer[0] == CHAR_CR || mcbuffer[0] == CHAR_NL)
+      cd->external_flags |= PCRE_HASCRORLF;
+
+    /* Set the first and required bytes appropriately. If no previous first
+    byte, set it from this character, but revert to none on a zero repeat.
+    Otherwise, leave the firstchar value alone, and don't change it on a zero
+    repeat. */
+
+    if (firstcharflags == REQ_UNSET)
+      {
+      zerofirstcharflags = REQ_NONE;
+      zeroreqchar = reqchar;
+      zeroreqcharflags = reqcharflags;
+
+      /* If the character is more than one byte long, we can set firstchar
+      only if it is not to be matched caselessly. */
+
+      if (mclength == 1 || req_caseopt == 0)
+        {
+        firstchar = mcbuffer[0];
+        firstcharflags = req_caseopt;
+
+        if (mclength != 1)
+          {
+          reqchar = code[-1];
+          reqcharflags = cd->req_varyopt;
+          }
+        }
+      else firstcharflags = reqcharflags = REQ_NONE;
+      }
+
+    /* firstchar was previously set; we can set reqchar only if the length is
+    1 or the matching is caseful. */
+
+    else
+      {
+      zerofirstchar = firstchar;
+      zerofirstcharflags = firstcharflags;
+      zeroreqchar = reqchar;
+      zeroreqcharflags = reqcharflags;
+      if (mclength == 1 || req_caseopt == 0)
+        {
+        reqchar = code[-1];
+        reqcharflags = req_caseopt | cd->req_varyopt;
+        }
+      }
+
+    break;            /* End of literal character handling */
+    }
+  }                   /* end of big loop */
+
+
+/* Control never reaches here by falling through, only by a goto for all the
+error states. Pass back the position in the pattern so that it can be displayed
+to the user for diagnosing the error. */
+
+FAILED:
+*ptrptr = ptr;
+return FALSE;
+}
+
+
+
+/*************************************************
+*     Compile sequence of alternatives           *
+*************************************************/
+
+/* On entry, ptr is pointing past the bracket character, but on return it
+points to the closing bracket, or vertical bar, or end of string. The code
+variable is pointing at the byte into which the BRA operator has been stored.
+This function is used during the pre-compile phase when we are trying to find
+out the amount of memory needed, as well as during the real compile phase. The
+value of lengthptr distinguishes the two phases.
+
+Arguments:
+  options           option bits, including any changes for this subpattern
+  codeptr           -> the address of the current code pointer
+  ptrptr            -> the address of the current pattern pointer
+  errorcodeptr      -> pointer to error code variable
+  lookbehind        TRUE if this is a lookbehind assertion
+  reset_bracount    TRUE to reset the count for each branch
+  skipbytes         skip this many bytes at start (for brackets and OP_COND)
+  cond_depth        depth of nesting for conditional subpatterns
+  firstcharptr      place to put the first required character
+  firstcharflagsptr place to put the first character flags, or a negative number
+  reqcharptr        place to put the last required character
+  reqcharflagsptr   place to put the last required character flags, or a negative number
+  bcptr             pointer to the chain of currently open branches
+  cd                points to the data block with tables pointers etc.
+  lengthptr         NULL during the real compile phase
+                    points to length accumulator during pre-compile phase
+
+Returns:            TRUE on success
+*/
+
+static BOOL
+compile_regex(int options, pcre_uchar **codeptr, const pcre_uchar **ptrptr,
+  int *errorcodeptr, BOOL lookbehind, BOOL reset_bracount, int skipbytes,
+  int cond_depth,
+  pcre_uint32 *firstcharptr, pcre_int32 *firstcharflagsptr,
+  pcre_uint32 *reqcharptr, pcre_int32 *reqcharflagsptr,
+  branch_chain *bcptr, compile_data *cd, int *lengthptr)
+{
+const pcre_uchar *ptr = *ptrptr;
+pcre_uchar *code = *codeptr;
+pcre_uchar *last_branch = code;
+pcre_uchar *start_bracket = code;
+pcre_uchar *reverse_count = NULL;
+open_capitem capitem;
+int capnumber = 0;
+pcre_uint32 firstchar, reqchar;
+pcre_int32 firstcharflags, reqcharflags;
+pcre_uint32 branchfirstchar, branchreqchar;
+pcre_int32 branchfirstcharflags, branchreqcharflags;
+int length;
+unsigned int orig_bracount;
+unsigned int max_bracount;
+branch_chain bc;
+size_t save_hwm_offset;
+
+/* If set, call the external function that checks for stack availability. */
+
+if (PUBL(stack_guard) != NULL && PUBL(stack_guard)())
+  {
+  *errorcodeptr= ERR85;
+  return FALSE;
+  }
+
+/* Miscellaneous initialization */
+
+bc.outer = bcptr;
+bc.current_branch = code;
+
+firstchar = reqchar = 0;
+firstcharflags = reqcharflags = REQ_UNSET;
+
+save_hwm_offset = cd->hwm - cd->start_workspace;
+
+/* Accumulate the length for use in the pre-compile phase. Start with the
+length of the BRA and KET and any extra bytes that are required at the
+beginning. We accumulate in a local variable to save frequent testing of
+lenthptr for NULL. We cannot do this by looking at the value of code at the
+start and end of each alternative, because compiled items are discarded during
+the pre-compile phase so that the work space is not exceeded. */
+
+length = 2 + 2*LINK_SIZE + skipbytes;
+
+/* WARNING: If the above line is changed for any reason, you must also change
+the code that abstracts option settings at the start of the pattern and makes
+them global. It tests the value of length for (2 + 2*LINK_SIZE) in the
+pre-compile phase to find out whether anything has yet been compiled or not. */
+
+/* If this is a capturing subpattern, add to the chain of open capturing items
+so that we can detect them if (*ACCEPT) is encountered. This is also used to
+detect groups that contain recursive back references to themselves. Note that
+only OP_CBRA need be tested here; changing this opcode to one of its variants,
+e.g. OP_SCBRAPOS, happens later, after the group has been compiled. */
+
+if (*code == OP_CBRA)
+  {
+  capnumber = GET2(code, 1 + LINK_SIZE);
+  capitem.number = capnumber;
+  capitem.next = cd->open_caps;
+  capitem.flag = FALSE;
+  cd->open_caps = &capitem;
+  }
+
+/* Offset is set zero to mark that this bracket is still open */
+
+PUT(code, 1, 0);
+code += 1 + LINK_SIZE + skipbytes;
+
+/* Loop for each alternative branch */
+
+orig_bracount = max_bracount = cd->bracount;
+for (;;)
+  {
+  /* For a (?| group, reset the capturing bracket count so that each branch
+  uses the same numbers. */
+
+  if (reset_bracount) cd->bracount = orig_bracount;
+
+  /* Set up dummy OP_REVERSE if lookbehind assertion */
+
+  if (lookbehind)
+    {
+    *code++ = OP_REVERSE;
+    reverse_count = code;
+    PUTINC(code, 0, 0);
+    length += 1 + LINK_SIZE;
+    }
+
+  /* Now compile the branch; in the pre-compile phase its length gets added
+  into the length. */
+
+  if (!compile_branch(&options, &code, &ptr, errorcodeptr, &branchfirstchar,
+        &branchfirstcharflags, &branchreqchar, &branchreqcharflags, &bc,
+        cond_depth, cd, (lengthptr == NULL)? NULL : &length))
+    {
+    *ptrptr = ptr;
+    return FALSE;
+    }
+
+  /* Keep the highest bracket count in case (?| was used and some branch
+  has fewer than the rest. */
+
+  if (cd->bracount > max_bracount) max_bracount = cd->bracount;
+
+  /* In the real compile phase, there is some post-processing to be done. */
+
+  if (lengthptr == NULL)
+    {
+    /* If this is the first branch, the firstchar and reqchar values for the
+    branch become the values for the regex. */
+
+    if (*last_branch != OP_ALT)
+      {
+      firstchar = branchfirstchar;
+      firstcharflags = branchfirstcharflags;
+      reqchar = branchreqchar;
+      reqcharflags = branchreqcharflags;
+      }
+
+    /* If this is not the first branch, the first char and reqchar have to
+    match the values from all the previous branches, except that if the
+    previous value for reqchar didn't have REQ_VARY set, it can still match,
+    and we set REQ_VARY for the regex. */
+
+    else
+      {
+      /* If we previously had a firstchar, but it doesn't match the new branch,
+      we have to abandon the firstchar for the regex, but if there was
+      previously no reqchar, it takes on the value of the old firstchar. */
+
+      if (firstcharflags >= 0 &&
+          (firstcharflags != branchfirstcharflags || firstchar != branchfirstchar))
+        {
+        if (reqcharflags < 0)
+          {
+          reqchar = firstchar;
+          reqcharflags = firstcharflags;
+          }
+        firstcharflags = REQ_NONE;
+        }
+
+      /* If we (now or from before) have no firstchar, a firstchar from the
+      branch becomes a reqchar if there isn't a branch reqchar. */
+
+      if (firstcharflags < 0 && branchfirstcharflags >= 0 && branchreqcharflags < 0)
+        {
+        branchreqchar = branchfirstchar;
+        branchreqcharflags = branchfirstcharflags;
+        }
+
+      /* Now ensure that the reqchars match */
+
+      if (((reqcharflags & ~REQ_VARY) != (branchreqcharflags & ~REQ_VARY)) ||
+          reqchar != branchreqchar)
+        reqcharflags = REQ_NONE;
+      else
+        {
+        reqchar = branchreqchar;
+        reqcharflags |= branchreqcharflags; /* To "or" REQ_VARY */
+        }
+      }
+
+    /* If lookbehind, check that this branch matches a fixed-length string, and
+    put the length into the OP_REVERSE item. Temporarily mark the end of the
+    branch with OP_END. If the branch contains OP_RECURSE, the result is -3
+    because there may be forward references that we can't check here. Set a
+    flag to cause another lookbehind check at the end. Why not do it all at the
+    end? Because common, erroneous checks are picked up here and the offset of
+    the problem can be shown. */
+
+    if (lookbehind)
+      {
+      int fixed_length;
+      *code = OP_END;
+      fixed_length = find_fixedlength(last_branch,  (options & PCRE_UTF8) != 0,
+        FALSE, cd, NULL);
+      DPRINTF(("fixed length = %d\n", fixed_length));
+      if (fixed_length == -3)
+        {
+        cd->check_lookbehind = TRUE;
+        }
+      else if (fixed_length < 0)
+        {
+        *errorcodeptr = (fixed_length == -2)? ERR36 :
+                        (fixed_length == -4)? ERR70: ERR25;
+        *ptrptr = ptr;
+        return FALSE;
+        }
+      else
+        {
+        if (fixed_length > cd->max_lookbehind)
+          cd->max_lookbehind = fixed_length;
+        PUT(reverse_count, 0, fixed_length);
+        }
+      }
+    }
+
+  /* Reached end of expression, either ')' or end of pattern. In the real
+  compile phase, go back through the alternative branches and reverse the chain
+  of offsets, with the field in the BRA item now becoming an offset to the
+  first alternative. If there are no alternatives, it points to the end of the
+  group. The length in the terminating ket is always the length of the whole
+  bracketed item. Return leaving the pointer at the terminating char. */
+
+  if (*ptr != CHAR_VERTICAL_LINE)
+    {
+    if (lengthptr == NULL)
+      {
+      int branch_length = (int)(code - last_branch);
+      do
+        {
+        int prev_length = GET(last_branch, 1);
+        PUT(last_branch, 1, branch_length);
+        branch_length = prev_length;
+        last_branch -= branch_length;
+        }
+      while (branch_length > 0);
+      }
+
+    /* Fill in the ket */
+
+    *code = OP_KET;
+    PUT(code, 1, (int)(code - start_bracket));
+    code += 1 + LINK_SIZE;
+
+    /* If it was a capturing subpattern, check to see if it contained any
+    recursive back references. If so, we must wrap it in atomic brackets.
+    Because we are moving code along, we must ensure that any pending recursive
+    references are updated. In any event, remove the block from the chain. */
+
+    if (capnumber > 0)
+      {
+      if (cd->open_caps->flag)
+        {
+        *code = OP_END;
+        adjust_recurse(start_bracket, 1 + LINK_SIZE,
+          (options & PCRE_UTF8) != 0, cd, save_hwm_offset);
+        memmove(start_bracket + 1 + LINK_SIZE, start_bracket,
+          IN_UCHARS(code - start_bracket));
+        *start_bracket = OP_ONCE;
+        code += 1 + LINK_SIZE;
+        PUT(start_bracket, 1, (int)(code - start_bracket));
+        *code = OP_KET;
+        PUT(code, 1, (int)(code - start_bracket));
+        code += 1 + LINK_SIZE;
+        length += 2 + 2*LINK_SIZE;
+        }
+      cd->open_caps = cd->open_caps->next;
+      }
+
+    /* Retain the highest bracket number, in case resetting was used. */
+
+    cd->bracount = max_bracount;
+
+    /* Set values to pass back */
+
+    *codeptr = code;
+    *ptrptr = ptr;
+    *firstcharptr = firstchar;
+    *firstcharflagsptr = firstcharflags;
+    *reqcharptr = reqchar;
+    *reqcharflagsptr = reqcharflags;
+    if (lengthptr != NULL)
+      {
+      if (OFLOW_MAX - *lengthptr < length)
+        {
+        *errorcodeptr = ERR20;
+        return FALSE;
+        }
+      *lengthptr += length;
+      }
+    return TRUE;
+    }
+
+  /* Another branch follows. In the pre-compile phase, we can move the code
+  pointer back to where it was for the start of the first branch. (That is,
+  pretend that each branch is the only one.)
+
+  In the real compile phase, insert an ALT node. Its length field points back
+  to the previous branch while the bracket remains open. At the end the chain
+  is reversed. It's done like this so that the start of the bracket has a
+  zero offset until it is closed, making it possible to detect recursion. */
+
+  if (lengthptr != NULL)
+    {
+    code = *codeptr + 1 + LINK_SIZE + skipbytes;
+    length += 1 + LINK_SIZE;
+    }
+  else
+    {
+    *code = OP_ALT;
+    PUT(code, 1, (int)(code - last_branch));
+    bc.current_branch = last_branch = code;
+    code += 1 + LINK_SIZE;
+    }
+
+  ptr++;
+  }
+/* Control never reaches here */
+}
+
+
+
+
+/*************************************************
+*          Check for anchored expression         *
+*************************************************/
+
+/* Try to find out if this is an anchored regular expression. Consider each
+alternative branch. If they all start with OP_SOD or OP_CIRC, or with a bracket
+all of whose alternatives start with OP_SOD or OP_CIRC (recurse ad lib), then
+it's anchored. However, if this is a multiline pattern, then only OP_SOD will
+be found, because ^ generates OP_CIRCM in that mode.
+
+We can also consider a regex to be anchored if OP_SOM starts all its branches.
+This is the code for \G, which means "match at start of match position, taking
+into account the match offset".
+
+A branch is also implicitly anchored if it starts with .* and DOTALL is set,
+because that will try the rest of the pattern at all possible matching points,
+so there is no point trying again.... er ....
+
+.... except when the .* appears inside capturing parentheses, and there is a
+subsequent back reference to those parentheses. We haven't enough information
+to catch that case precisely.
+
+At first, the best we could do was to detect when .* was in capturing brackets
+and the highest back reference was greater than or equal to that level.
+However, by keeping a bitmap of the first 31 back references, we can catch some
+of the more common cases more precisely.
+
+... A second exception is when the .* appears inside an atomic group, because
+this prevents the number of characters it matches from being adjusted.
+
+Arguments:
+  code           points to start of expression (the bracket)
+  bracket_map    a bitmap of which brackets we are inside while testing; this
+                  handles up to substring 31; after that we just have to take
+                  the less precise approach
+  cd             points to the compile data block
+  atomcount      atomic group level
+
+Returns:     TRUE or FALSE
+*/
+
+static BOOL
+is_anchored(register const pcre_uchar *code, unsigned int bracket_map,
+  compile_data *cd, int atomcount)
+{
+do {
+   const pcre_uchar *scode = first_significant_code(
+     code + PRIV(OP_lengths)[*code], FALSE);
+   register int op = *scode;
+
+   /* Non-capturing brackets */
+
+   if (op == OP_BRA  || op == OP_BRAPOS ||
+       op == OP_SBRA || op == OP_SBRAPOS)
+     {
+     if (!is_anchored(scode, bracket_map, cd, atomcount)) return FALSE;
+     }
+
+   /* Capturing brackets */
+
+   else if (op == OP_CBRA  || op == OP_CBRAPOS ||
+            op == OP_SCBRA || op == OP_SCBRAPOS)
+     {
+     int n = GET2(scode, 1+LINK_SIZE);
+     int new_map = bracket_map | ((n < 32)? (1 << n) : 1);
+     if (!is_anchored(scode, new_map, cd, atomcount)) return FALSE;
+     }
+
+   /* Positive forward assertion */
+
+   else if (op == OP_ASSERT)
+     {
+     if (!is_anchored(scode, bracket_map, cd, atomcount)) return FALSE;
+     }
+
+   /* Condition; not anchored if no second branch */
+   else if (op == OP_COND)
+     {
+     if (scode[GET(scode,1)] != OP_ALT) return FALSE;
+     if (!is_anchored(scode, bracket_map, cd, atomcount)) return FALSE;
+     }
+
+   /* Atomic groups */
+
+   else if (op == OP_ONCE || op == OP_ONCE_NC)
+     {
+     if (!is_anchored(scode, bracket_map, cd, atomcount + 1))
+       return FALSE;
+     }
+
+   /* .* is not anchored unless DOTALL is set (which generates OP_ALLANY) and
+   it isn't in brackets that are or may be referenced or inside an atomic
+   group. */
+
+   else if ((op == OP_TYPESTAR || op == OP_TYPEMINSTAR ||
+             op == OP_TYPEPOSSTAR))
+     {
+     if (scode[1] != OP_ALLANY || (bracket_map & cd->backref_map) != 0 ||
+         atomcount > 0 || cd->had_pruneorskip)
+       return FALSE;
+     }
+
+   /* Check for explicit anchoring */
+
+   else if (op != OP_SOD && op != OP_SOM && op != OP_CIRC) return FALSE;
+
+   code += GET(code, 1);
+   }
+while (*code == OP_ALT);   /* Loop for each alternative */
+return TRUE;
+}
+
+
+
+/*************************************************
+*         Check for starting with ^ or .*        *
+*************************************************/
+
+/* This is called to find out if every branch starts with ^ or .* so that
+"first char" processing can be done to speed things up in multiline
+matching and for non-DOTALL patterns that start with .* (which must start at
+the beginning or after \n). As in the case of is_anchored() (see above), we
+have to take account of back references to capturing brackets that contain .*
+because in that case we can't make the assumption. Also, the appearance of .*
+inside atomic brackets or in an assertion, or in a pattern that contains *PRUNE
+or *SKIP does not count, because once again the assumption no longer holds.
+
+Arguments:
+  code           points to start of expression (the bracket)
+  bracket_map    a bitmap of which brackets we are inside while testing; this
+                  handles up to substring 31; after that we just have to take
+                  the less precise approach
+  cd             points to the compile data
+  atomcount      atomic group level
+  inassert       TRUE if in an assertion
+
+Returns:         TRUE or FALSE
+*/
+
+static BOOL
+is_startline(const pcre_uchar *code, unsigned int bracket_map,
+  compile_data *cd, int atomcount, BOOL inassert)
+{
+do {
+   const pcre_uchar *scode = first_significant_code(
+     code + PRIV(OP_lengths)[*code], FALSE);
+   register int op = *scode;
+
+   /* If we are at the start of a conditional assertion group, *both* the
+   conditional assertion *and* what follows the condition must satisfy the test
+   for start of line. Other kinds of condition fail. Note that there may be an
+   auto-callout at the start of a condition. */
+
+   if (op == OP_COND)
+     {
+     scode += 1 + LINK_SIZE;
+     if (*scode == OP_CALLOUT) scode += PRIV(OP_lengths)[OP_CALLOUT];
+     switch (*scode)
+       {
+       case OP_CREF:
+       case OP_DNCREF:
+       case OP_RREF:
+       case OP_DNRREF:
+       case OP_DEF:
+       case OP_FAIL:
+       return FALSE;
+
+       default:     /* Assertion */
+       if (!is_startline(scode, bracket_map, cd, atomcount, TRUE)) return FALSE;
+       do scode += GET(scode, 1); while (*scode == OP_ALT);
+       scode += 1 + LINK_SIZE;
+       break;
+       }
+     scode = first_significant_code(scode, FALSE);
+     op = *scode;
+     }
+
+   /* Non-capturing brackets */
+
+   if (op == OP_BRA  || op == OP_BRAPOS ||
+       op == OP_SBRA || op == OP_SBRAPOS)
+     {
+     if (!is_startline(scode, bracket_map, cd, atomcount, inassert)) return FALSE;
+     }
+
+   /* Capturing brackets */
+
+   else if (op == OP_CBRA  || op == OP_CBRAPOS ||
+            op == OP_SCBRA || op == OP_SCBRAPOS)
+     {
+     int n = GET2(scode, 1+LINK_SIZE);
+     int new_map = bracket_map | ((n < 32)? (1 << n) : 1);
+     if (!is_startline(scode, new_map, cd, atomcount, inassert)) return FALSE;
+     }
+
+   /* Positive forward assertions */
+
+   else if (op == OP_ASSERT)
+     {
+     if (!is_startline(scode, bracket_map, cd, atomcount, TRUE)) return FALSE;
+     }
+
+   /* Atomic brackets */
+
+   else if (op == OP_ONCE || op == OP_ONCE_NC)
+     {
+     if (!is_startline(scode, bracket_map, cd, atomcount + 1, inassert)) return FALSE;
+     }
+
+   /* .* means "start at start or after \n" if it isn't in atomic brackets or
+   brackets that may be referenced or an assertion, as long as the pattern does
+   not contain *PRUNE or *SKIP, because these break the feature. Consider, for
+   example, /.*?a(*PRUNE)b/ with the subject "aab", which matches "ab", i.e.
+   not at the start of a line. */
+
+   else if (op == OP_TYPESTAR || op == OP_TYPEMINSTAR || op == OP_TYPEPOSSTAR)
+     {
+     if (scode[1] != OP_ANY || (bracket_map & cd->backref_map) != 0 ||
+         atomcount > 0 || cd->had_pruneorskip || inassert)
+       return FALSE;
+     }
+
+   /* Check for explicit circumflex; anything else gives a FALSE result. Note
+   in particular that this includes atomic brackets OP_ONCE and OP_ONCE_NC
+   because the number of characters matched by .* cannot be adjusted inside
+   them. */
+
+   else if (op != OP_CIRC && op != OP_CIRCM) return FALSE;
+
+   /* Move on to the next alternative */
+
+   code += GET(code, 1);
+   }
+while (*code == OP_ALT);  /* Loop for each alternative */
+return TRUE;
+}
+
+
+
+/*************************************************
+*       Check for asserted fixed first char      *
+*************************************************/
+
+/* During compilation, the "first char" settings from forward assertions are
+discarded, because they can cause conflicts with actual literals that follow.
+However, if we end up without a first char setting for an unanchored pattern,
+it is worth scanning the regex to see if there is an initial asserted first
+char. If all branches start with the same asserted char, or with a
+non-conditional bracket all of whose alternatives start with the same asserted
+char (recurse ad lib), then we return that char, with the flags set to zero or
+REQ_CASELESS; otherwise return zero with REQ_NONE in the flags.
+
+Arguments:
+  code       points to start of expression (the bracket)
+  flags      points to the first char flags, or to REQ_NONE
+  inassert   TRUE if in an assertion
+
+Returns:     the fixed first char, or 0 with REQ_NONE in flags
+*/
+
+static pcre_uint32
+find_firstassertedchar(const pcre_uchar *code, pcre_int32 *flags,
+  BOOL inassert)
+{
+register pcre_uint32 c = 0;
+int cflags = REQ_NONE;
+
+*flags = REQ_NONE;
+do {
+   pcre_uint32 d;
+   int dflags;
+   int xl = (*code == OP_CBRA || *code == OP_SCBRA ||
+             *code == OP_CBRAPOS || *code == OP_SCBRAPOS)? IMM2_SIZE:0;
+   const pcre_uchar *scode = first_significant_code(code + 1+LINK_SIZE + xl,
+     TRUE);
+   register pcre_uchar op = *scode;
+
+   switch(op)
+     {
+     default:
+     return 0;
+
+     case OP_BRA:
+     case OP_BRAPOS:
+     case OP_CBRA:
+     case OP_SCBRA:
+     case OP_CBRAPOS:
+     case OP_SCBRAPOS:
+     case OP_ASSERT:
+     case OP_ONCE:
+     case OP_ONCE_NC:
+     d = find_firstassertedchar(scode, &dflags, op == OP_ASSERT);
+     if (dflags < 0)
+       return 0;
+     if (cflags < 0) { c = d; cflags = dflags; } else if (c != d || cflags != dflags) return 0;
+     break;
+
+     case OP_EXACT:
+     scode += IMM2_SIZE;
+     /* Fall through */
+
+     case OP_CHAR:
+     case OP_PLUS:
+     case OP_MINPLUS:
+     case OP_POSPLUS:
+     if (!inassert) return 0;
+     if (cflags < 0) { c = scode[1]; cflags = 0; }
+       else if (c != scode[1]) return 0;
+     break;
+
+     case OP_EXACTI:
+     scode += IMM2_SIZE;
+     /* Fall through */
+
+     case OP_CHARI:
+     case OP_PLUSI:
+     case OP_MINPLUSI:
+     case OP_POSPLUSI:
+     if (!inassert) return 0;
+     if (cflags < 0) { c = scode[1]; cflags = REQ_CASELESS; }
+       else if (c != scode[1]) return 0;
+     break;
+     }
+
+   code += GET(code, 1);
+   }
+while (*code == OP_ALT);
+
+*flags = cflags;
+return c;
+}
+
+
+
+/*************************************************
+*     Add an entry to the name/number table      *
+*************************************************/
+
+/* This function is called between compiling passes to add an entry to the
+name/number table, maintaining alphabetical order. Checking for permitted
+and forbidden duplicates has already been done.
+
+Arguments:
+  cd           the compile data block
+  name         the name to add
+  length       the length of the name
+  groupno      the group number
+
+Returns:       nothing
+*/
+
+static void
+add_name(compile_data *cd, const pcre_uchar *name, int length,
+  unsigned int groupno)
+{
+int i;
+pcre_uchar *slot = cd->name_table;
+
+for (i = 0; i < cd->names_found; i++)
+  {
+  int crc = memcmp(name, slot+IMM2_SIZE, IN_UCHARS(length));
+  if (crc == 0 && slot[IMM2_SIZE+length] != 0)
+    crc = -1; /* Current name is a substring */
+
+  /* Make space in the table and break the loop for an earlier name. For a
+  duplicate or later name, carry on. We do this for duplicates so that in the
+  simple case (when ?(| is not used) they are in order of their numbers. In all
+  cases they are in the order in which they appear in the pattern. */
+
+  if (crc < 0)
+    {
+    memmove(slot + cd->name_entry_size, slot,
+      IN_UCHARS((cd->names_found - i) * cd->name_entry_size));
+    break;
+    }
+
+  /* Continue the loop for a later or duplicate name */
+
+  slot += cd->name_entry_size;
+  }
+
+PUT2(slot, 0, groupno);
+memcpy(slot + IMM2_SIZE, name, IN_UCHARS(length));
+slot[IMM2_SIZE + length] = 0;
+cd->names_found++;
+}
+
+
+
+/*************************************************
+*        Compile a Regular Expression            *
+*************************************************/
+
+/* This function takes a string and returns a pointer to a block of store
+holding a compiled version of the expression. The original API for this
+function had no error code return variable; it is retained for backwards
+compatibility. The new function is given a new name.
+
+Arguments:
+  pattern       the regular expression
+  options       various option bits
+  errorcodeptr  pointer to error code variable (pcre_compile2() only)
+                  can be NULL if you don't want a code value
+  errorptr      pointer to pointer to error text
+  erroroffset   ptr offset in pattern where error was detected
+  tables        pointer to character tables or NULL
+
+Returns:        pointer to compiled data block, or NULL on error,
+                with errorptr and erroroffset set
+*/
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION
+pcre_compile(const char *pattern, int options, const char **errorptr,
+  int *erroroffset, const unsigned char *tables)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN pcre16 * PCRE_CALL_CONVENTION
+pcre16_compile(PCRE_SPTR16 pattern, int options, const char **errorptr,
+  int *erroroffset, const unsigned char *tables)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN pcre32 * PCRE_CALL_CONVENTION
+pcre32_compile(PCRE_SPTR32 pattern, int options, const char **errorptr,
+  int *erroroffset, const unsigned char *tables)
+#endif
+{
+#if defined COMPILE_PCRE8
+return pcre_compile2(pattern, options, NULL, errorptr, erroroffset, tables);
+#elif defined COMPILE_PCRE16
+return pcre16_compile2(pattern, options, NULL, errorptr, erroroffset, tables);
+#elif defined COMPILE_PCRE32
+return pcre32_compile2(pattern, options, NULL, errorptr, erroroffset, tables);
+#endif
+}
+
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN pcre * PCRE_CALL_CONVENTION
+pcre_compile2(const char *pattern, int options, int *errorcodeptr,
+  const char **errorptr, int *erroroffset, const unsigned char *tables)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN pcre16 * PCRE_CALL_CONVENTION
+pcre16_compile2(PCRE_SPTR16 pattern, int options, int *errorcodeptr,
+  const char **errorptr, int *erroroffset, const unsigned char *tables)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN pcre32 * PCRE_CALL_CONVENTION
+pcre32_compile2(PCRE_SPTR32 pattern, int options, int *errorcodeptr,
+  const char **errorptr, int *erroroffset, const unsigned char *tables)
+#endif
+{
+REAL_PCRE *re;
+int length = 1;  /* For final END opcode */
+pcre_int32 firstcharflags, reqcharflags;
+pcre_uint32 firstchar, reqchar;
+pcre_uint32 limit_match = PCRE_UINT32_MAX;
+pcre_uint32 limit_recursion = PCRE_UINT32_MAX;
+int newline;
+int errorcode = 0;
+int skipatstart = 0;
+BOOL utf;
+BOOL never_utf = FALSE;
+size_t size;
+pcre_uchar *code;
+const pcre_uchar *codestart;
+const pcre_uchar *ptr;
+compile_data compile_block;
+compile_data *cd = &compile_block;
+
+/* This space is used for "compiling" into during the first phase, when we are
+computing the amount of memory that is needed. Compiled items are thrown away
+as soon as possible, so that a fairly large buffer should be sufficient for
+this purpose. The same space is used in the second phase for remembering where
+to fill in forward references to subpatterns. That may overflow, in which case
+new memory is obtained from malloc(). */
+
+pcre_uchar cworkspace[COMPILE_WORK_SIZE];
+
+/* This vector is used for remembering name groups during the pre-compile. In a
+similar way to cworkspace, it can be expanded using malloc() if necessary. */
+
+named_group named_groups[NAMED_GROUP_LIST_SIZE];
+
+/* Set this early so that early errors get offset 0. */
+
+ptr = (const pcre_uchar *)pattern;
+
+/* We can't pass back an error message if errorptr is NULL; I guess the best we
+can do is just return NULL, but we can set a code value if there is a code
+pointer. */
+
+if (errorptr == NULL)
+  {
+  if (errorcodeptr != NULL) *errorcodeptr = 99;
+  return NULL;
+  }
+
+*errorptr = NULL;
+if (errorcodeptr != NULL) *errorcodeptr = ERR0;
+
+/* However, we can give a message for this error */
+
+if (erroroffset == NULL)
+  {
+  errorcode = ERR16;
+  goto PCRE_EARLY_ERROR_RETURN2;
+  }
+
+*erroroffset = 0;
+
+/* Set up pointers to the individual character tables */
+
+if (tables == NULL) tables = PRIV(default_tables);
+cd->lcc = tables + lcc_offset;
+cd->fcc = tables + fcc_offset;
+cd->cbits = tables + cbits_offset;
+cd->ctypes = tables + ctypes_offset;
+
+/* Check that all undefined public option bits are zero */
+
+if ((options & ~PUBLIC_COMPILE_OPTIONS) != 0)
+  {
+  errorcode = ERR17;
+  goto PCRE_EARLY_ERROR_RETURN;
+  }
+
+/* If PCRE_NEVER_UTF is set, remember it. */
+
+if ((options & PCRE_NEVER_UTF) != 0) never_utf = TRUE;
+
+/* Check for global one-time settings at the start of the pattern, and remember
+the offset for later. */
+
+cd->external_flags = 0;   /* Initialize here for LIMIT_MATCH/RECURSION */
+
+while (ptr[skipatstart] == CHAR_LEFT_PARENTHESIS &&
+       ptr[skipatstart+1] == CHAR_ASTERISK)
+  {
+  int newnl = 0;
+  int newbsr = 0;
+
+/* For completeness and backward compatibility, (*UTFn) is supported in the
+relevant libraries, but (*UTF) is generic and always supported. Note that
+PCRE_UTF8 == PCRE_UTF16 == PCRE_UTF32. */
+
+#ifdef COMPILE_PCRE8
+  if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF8_RIGHTPAR, 5) == 0)
+    { skipatstart += 7; options |= PCRE_UTF8; continue; }
+#endif
+#ifdef COMPILE_PCRE16
+  if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF16_RIGHTPAR, 6) == 0)
+    { skipatstart += 8; options |= PCRE_UTF16; continue; }
+#endif
+#ifdef COMPILE_PCRE32
+  if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF32_RIGHTPAR, 6) == 0)
+    { skipatstart += 8; options |= PCRE_UTF32; continue; }
+#endif
+
+  else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UTF_RIGHTPAR, 4) == 0)
+    { skipatstart += 6; options |= PCRE_UTF8; continue; }
+  else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_UCP_RIGHTPAR, 4) == 0)
+    { skipatstart += 6; options |= PCRE_UCP; continue; }
+  else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_NO_AUTO_POSSESS_RIGHTPAR, 16) == 0)
+    { skipatstart += 18; options |= PCRE_NO_AUTO_POSSESS; continue; }
+  else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_NO_START_OPT_RIGHTPAR, 13) == 0)
+    { skipatstart += 15; options |= PCRE_NO_START_OPTIMIZE; continue; }
+
+  else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_LIMIT_MATCH_EQ, 12) == 0)
+    {
+    pcre_uint32 c = 0;
+    int p = skipatstart + 14;
+    while (isdigit(ptr[p]))
+      {
+      if (c > PCRE_UINT32_MAX / 10 - 1) break;   /* Integer overflow */
+      c = c*10 + ptr[p++] - CHAR_0;
+      }
+    if (ptr[p++] != CHAR_RIGHT_PARENTHESIS) break;
+    if (c < limit_match)
+      {
+      limit_match = c;
+      cd->external_flags |= PCRE_MLSET;
+      }
+    skipatstart = p;
+    continue;
+    }
+
+  else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_LIMIT_RECURSION_EQ, 16) == 0)
+    {
+    pcre_uint32 c = 0;
+    int p = skipatstart + 18;
+    while (isdigit(ptr[p]))
+      {
+      if (c > PCRE_UINT32_MAX / 10 - 1) break;   /* Integer overflow check */
+      c = c*10 + ptr[p++] - CHAR_0;
+      }
+    if (ptr[p++] != CHAR_RIGHT_PARENTHESIS) break;
+    if (c < limit_recursion)
+      {
+      limit_recursion = c;
+      cd->external_flags |= PCRE_RLSET;
+      }
+    skipatstart = p;
+    continue;
+    }
+
+  if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_CR_RIGHTPAR, 3) == 0)
+    { skipatstart += 5; newnl = PCRE_NEWLINE_CR; }
+  else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_LF_RIGHTPAR, 3)  == 0)
+    { skipatstart += 5; newnl = PCRE_NEWLINE_LF; }
+  else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_CRLF_RIGHTPAR, 5)  == 0)
+    { skipatstart += 7; newnl = PCRE_NEWLINE_CR + PCRE_NEWLINE_LF; }
+  else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_ANY_RIGHTPAR, 4) == 0)
+    { skipatstart += 6; newnl = PCRE_NEWLINE_ANY; }
+  else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_ANYCRLF_RIGHTPAR, 8) == 0)
+    { skipatstart += 10; newnl = PCRE_NEWLINE_ANYCRLF; }
+
+  else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_BSR_ANYCRLF_RIGHTPAR, 12) == 0)
+    { skipatstart += 14; newbsr = PCRE_BSR_ANYCRLF; }
+  else if (STRNCMP_UC_C8(ptr+skipatstart+2, STRING_BSR_UNICODE_RIGHTPAR, 12) == 0)
+    { skipatstart += 14; newbsr = PCRE_BSR_UNICODE; }
+
+  if (newnl != 0)
+    options = (options & ~PCRE_NEWLINE_BITS) | newnl;
+  else if (newbsr != 0)
+    options = (options & ~(PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) | newbsr;
+  else break;
+  }
+
+/* PCRE_UTF(16|32) have the same value as PCRE_UTF8. */
+utf = (options & PCRE_UTF8) != 0;
+if (utf && never_utf)
+  {
+  errorcode = ERR78;
+  goto PCRE_EARLY_ERROR_RETURN2;
+  }
+
+/* Can't support UTF unless PCRE has been compiled to include the code. The
+return of an error code from PRIV(valid_utf)() is a new feature, introduced in
+release 8.13. It is passed back from pcre_[dfa_]exec(), but at the moment is
+not used here. */
+
+#ifdef SUPPORT_UTF
+if (utf && (options & PCRE_NO_UTF8_CHECK) == 0 &&
+     (errorcode = PRIV(valid_utf)((PCRE_PUCHAR)pattern, -1, erroroffset)) != 0)
+  {
+#if defined COMPILE_PCRE8
+  errorcode = ERR44;
+#elif defined COMPILE_PCRE16
+  errorcode = ERR74;
+#elif defined COMPILE_PCRE32
+  errorcode = ERR77;
+#endif
+  goto PCRE_EARLY_ERROR_RETURN2;
+  }
+#else
+if (utf)
+  {
+  errorcode = ERR32;
+  goto PCRE_EARLY_ERROR_RETURN;
+  }
+#endif
+
+/* Can't support UCP unless PCRE has been compiled to include the code. */
+
+#ifndef SUPPORT_UCP
+if ((options & PCRE_UCP) != 0)
+  {
+  errorcode = ERR67;
+  goto PCRE_EARLY_ERROR_RETURN;
+  }
+#endif
+
+/* Check validity of \R options. */
+
+if ((options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) ==
+     (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
+  {
+  errorcode = ERR56;
+  goto PCRE_EARLY_ERROR_RETURN;
+  }
+
+/* Handle different types of newline. The three bits give seven cases. The
+current code allows for fixed one- or two-byte sequences, plus "any" and
+"anycrlf". */
+
+switch (options & PCRE_NEWLINE_BITS)
+  {
+  case 0: newline = NEWLINE; break;   /* Build-time default */
+  case PCRE_NEWLINE_CR: newline = CHAR_CR; break;
+  case PCRE_NEWLINE_LF: newline = CHAR_NL; break;
+  case PCRE_NEWLINE_CR+
+       PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;
+  case PCRE_NEWLINE_ANY: newline = -1; break;
+  case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
+  default: errorcode = ERR56; goto PCRE_EARLY_ERROR_RETURN;
+  }
+
+if (newline == -2)
+  {
+  cd->nltype = NLTYPE_ANYCRLF;
+  }
+else if (newline < 0)
+  {
+  cd->nltype = NLTYPE_ANY;
+  }
+else
+  {
+  cd->nltype = NLTYPE_FIXED;
+  if (newline > 255)
+    {
+    cd->nllen = 2;
+    cd->nl[0] = (newline >> 8) & 255;
+    cd->nl[1] = newline & 255;
+    }
+  else
+    {
+    cd->nllen = 1;
+    cd->nl[0] = newline;
+    }
+  }
+
+/* Maximum back reference and backref bitmap. The bitmap records up to 31 back
+references to help in deciding whether (.*) can be treated as anchored or not.
+*/
+
+cd->top_backref = 0;
+cd->backref_map = 0;
+
+/* Reflect pattern for debugging output */
+
+DPRINTF(("------------------------------------------------------------------\n"));
+#ifdef PCRE_DEBUG
+print_puchar(stdout, (PCRE_PUCHAR)pattern);
+#endif
+DPRINTF(("\n"));
+
+/* Pretend to compile the pattern while actually just accumulating the length
+of memory required. This behaviour is triggered by passing a non-NULL final
+argument to compile_regex(). We pass a block of workspace (cworkspace) for it
+to compile parts of the pattern into; the compiled code is discarded when it is
+no longer needed, so hopefully this workspace will never overflow, though there
+is a test for its doing so. */
+
+cd->bracount = cd->final_bracount = 0;
+cd->names_found = 0;
+cd->name_entry_size = 0;
+cd->name_table = NULL;
+cd->dupnames = FALSE;
+cd->dupgroups = FALSE;
+cd->namedrefcount = 0;
+cd->start_code = cworkspace;
+cd->hwm = cworkspace;
+cd->iscondassert = FALSE;
+cd->start_workspace = cworkspace;
+cd->workspace_size = COMPILE_WORK_SIZE;
+cd->named_groups = named_groups;
+cd->named_group_list_size = NAMED_GROUP_LIST_SIZE;
+cd->start_pattern = (const pcre_uchar *)pattern;
+cd->end_pattern = (const pcre_uchar *)(pattern + STRLEN_UC((const pcre_uchar *)pattern));
+cd->req_varyopt = 0;
+cd->parens_depth = 0;
+cd->assert_depth = 0;
+cd->max_lookbehind = 0;
+cd->external_options = options;
+cd->open_caps = NULL;
+
+/* Now do the pre-compile. On error, errorcode will be set non-zero, so we
+don't need to look at the result of the function here. The initial options have
+been put into the cd block so that they can be changed if an option setting is
+found within the regex right at the beginning. Bringing initial option settings
+outside can help speed up starting point checks. */
+
+ptr += skipatstart;
+code = cworkspace;
+*code = OP_BRA;
+
+(void)compile_regex(cd->external_options, &code, &ptr, &errorcode, FALSE,
+  FALSE, 0, 0, &firstchar, &firstcharflags, &reqchar, &reqcharflags, NULL,
+  cd, &length);
+if (errorcode != 0) goto PCRE_EARLY_ERROR_RETURN;
+
+DPRINTF(("end pre-compile: length=%d workspace=%d\n", length,
+  (int)(cd->hwm - cworkspace)));
+
+if (length > MAX_PATTERN_SIZE)
+  {
+  errorcode = ERR20;
+  goto PCRE_EARLY_ERROR_RETURN;
+  }
+
+/* Compute the size of the data block for storing the compiled pattern. Integer
+overflow should no longer be possible because nowadays we limit the maximum
+value of cd->names_found and cd->name_entry_size. */
+
+size = sizeof(REAL_PCRE) +
+  (length + cd->names_found * cd->name_entry_size) * sizeof(pcre_uchar);
+
+/* Get the memory. */
+
+re = (REAL_PCRE *)(PUBL(malloc))(size);
+if (re == NULL)
+  {
+  errorcode = ERR21;
+  goto PCRE_EARLY_ERROR_RETURN;
+  }
+
+/* Put in the magic number, and save the sizes, initial options, internal
+flags, and character table pointer. NULL is used for the default character
+tables. The nullpad field is at the end; it's there to help in the case when a
+regex compiled on a system with 4-byte pointers is run on another with 8-byte
+pointers. */
+
+re->magic_number = MAGIC_NUMBER;
+re->size = (int)size;
+re->options = cd->external_options;
+re->flags = cd->external_flags;
+re->limit_match = limit_match;
+re->limit_recursion = limit_recursion;
+re->first_char = 0;
+re->req_char = 0;
+re->name_table_offset = sizeof(REAL_PCRE) / sizeof(pcre_uchar);
+re->name_entry_size = cd->name_entry_size;
+re->name_count = cd->names_found;
+re->ref_count = 0;
+re->tables = (tables == PRIV(default_tables))? NULL : tables;
+re->nullpad = NULL;
+#ifdef COMPILE_PCRE32
+re->dummy = 0;
+#else
+re->dummy1 = re->dummy2 = re->dummy3 = 0;
+#endif
+
+/* The starting points of the name/number translation table and of the code are
+passed around in the compile data block. The start/end pattern and initial
+options are already set from the pre-compile phase, as is the name_entry_size
+field. Reset the bracket count and the names_found field. Also reset the hwm
+field; this time it's used for remembering forward references to subpatterns.
+*/
+
+cd->final_bracount = cd->bracount;  /* Save for checking forward references */
+cd->parens_depth = 0;
+cd->assert_depth = 0;
+cd->bracount = 0;
+cd->max_lookbehind = 0;
+cd->name_table = (pcre_uchar *)re + re->name_table_offset;
+codestart = cd->name_table + re->name_entry_size * re->name_count;
+cd->start_code = codestart;
+cd->hwm = (pcre_uchar *)(cd->start_workspace);
+cd->iscondassert = FALSE;
+cd->req_varyopt = 0;
+cd->had_accept = FALSE;
+cd->had_pruneorskip = FALSE;
+cd->check_lookbehind = FALSE;
+cd->open_caps = NULL;
+
+/* If any named groups were found, create the name/number table from the list
+created in the first pass. */
+
+if (cd->names_found > 0)
+  {
+  int i = cd->names_found;
+  named_group *ng = cd->named_groups;
+  cd->names_found = 0;
+  for (; i > 0; i--, ng++)
+    add_name(cd, ng->name, ng->length, ng->number);
+  if (cd->named_group_list_size > NAMED_GROUP_LIST_SIZE)
+    (PUBL(free))((void *)cd->named_groups);
+  }
+
+/* Set up a starting, non-extracting bracket, then compile the expression. On
+error, errorcode will be set non-zero, so we don't need to look at the result
+of the function here. */
+
+ptr = (const pcre_uchar *)pattern + skipatstart;
+code = (pcre_uchar *)codestart;
+*code = OP_BRA;
+(void)compile_regex(re->options, &code, &ptr, &errorcode, FALSE, FALSE, 0, 0,
+  &firstchar, &firstcharflags, &reqchar, &reqcharflags, NULL, cd, NULL);
+re->top_bracket = cd->bracount;
+re->top_backref = cd->top_backref;
+re->max_lookbehind = cd->max_lookbehind;
+re->flags = cd->external_flags | PCRE_MODE;
+
+if (cd->had_accept)
+  {
+  reqchar = 0;              /* Must disable after (*ACCEPT) */
+  reqcharflags = REQ_NONE;
+  }
+
+/* If not reached end of pattern on success, there's an excess bracket. */
+
+if (errorcode == 0 && *ptr != CHAR_NULL) errorcode = ERR22;
+
+/* Fill in the terminating state and check for disastrous overflow, but
+if debugging, leave the test till after things are printed out. */
+
+*code++ = OP_END;
+
+#ifndef PCRE_DEBUG
+if (code - codestart > length) errorcode = ERR23;
+#endif
+
+#ifdef SUPPORT_VALGRIND
+/* If the estimated length exceeds the really used length, mark the extra
+allocated memory as unaddressable, so that any out-of-bound reads can be
+detected. */
+VALGRIND_MAKE_MEM_NOACCESS(code, (length - (code - codestart)) * sizeof(pcre_uchar));
+#endif
+
+/* Fill in any forward references that are required. There may be repeated
+references; optimize for them, as searching a large regex takes time. */
+
+if (cd->hwm > cd->start_workspace)
+  {
+  int prev_recno = -1;
+  const pcre_uchar *groupptr = NULL;
+  while (errorcode == 0 && cd->hwm > cd->start_workspace)
+    {
+    int offset, recno;
+    cd->hwm -= LINK_SIZE;
+    offset = GET(cd->hwm, 0);
+
+    /* Check that the hwm handling hasn't gone wrong. This whole area is
+    rewritten in PCRE2 because there are some obscure cases. */
+
+    if (offset == 0 || codestart[offset-1] != OP_RECURSE)
+      {
+      errorcode = ERR10;
+      break;
+      }
+
+    recno = GET(codestart, offset);
+    if (recno != prev_recno)
+      {
+      groupptr = PRIV(find_bracket)(codestart, utf, recno);
+      prev_recno = recno;
+      }
+    if (groupptr == NULL) errorcode = ERR53;
+      else PUT(((pcre_uchar *)codestart), offset, (int)(groupptr - codestart));
+    }
+  }
+
+/* If the workspace had to be expanded, free the new memory. Set the pointer to
+NULL to indicate that forward references have been filled in. */
+
+if (cd->workspace_size > COMPILE_WORK_SIZE)
+  (PUBL(free))((void *)cd->start_workspace);
+cd->start_workspace = NULL;
+
+/* Give an error if there's back reference to a non-existent capturing
+subpattern. */
+
+if (errorcode == 0 && re->top_backref > re->top_bracket) errorcode = ERR15;
+
+/* Unless disabled, check whether any single character iterators can be
+auto-possessified. The function overwrites the appropriate opcode values, so
+the type of the pointer must be cast. NOTE: the intermediate variable "temp" is
+used in this code because at least one compiler gives a warning about loss of
+"const" attribute if the cast (pcre_uchar *)codestart is used directly in the
+function call. */
+
+if (errorcode == 0 && (options & PCRE_NO_AUTO_POSSESS) == 0)
+  {
+  pcre_uchar *temp = (pcre_uchar *)codestart;
+  auto_possessify(temp, utf, cd);
+  }
+
+/* If there were any lookbehind assertions that contained OP_RECURSE
+(recursions or subroutine calls), a flag is set for them to be checked here,
+because they may contain forward references. Actual recursions cannot be fixed
+length, but subroutine calls can. It is done like this so that those without
+OP_RECURSE that are not fixed length get a diagnosic with a useful offset. The
+exceptional ones forgo this. We scan the pattern to check that they are fixed
+length, and set their lengths. */
+
+if (errorcode == 0 && cd->check_lookbehind)
+  {
+  pcre_uchar *cc = (pcre_uchar *)codestart;
+
+  /* Loop, searching for OP_REVERSE items, and process those that do not have
+  their length set. (Actually, it will also re-process any that have a length
+  of zero, but that is a pathological case, and it does no harm.) When we find
+  one, we temporarily terminate the branch it is in while we scan it. */
+
+  for (cc = (pcre_uchar *)PRIV(find_bracket)(codestart, utf, -1);
+       cc != NULL;
+       cc = (pcre_uchar *)PRIV(find_bracket)(cc, utf, -1))
+    {
+    if (GET(cc, 1) == 0)
+      {
+      int fixed_length;
+      pcre_uchar *be = cc - 1 - LINK_SIZE + GET(cc, -LINK_SIZE);
+      int end_op = *be;
+      *be = OP_END;
+      fixed_length = find_fixedlength(cc, (re->options & PCRE_UTF8) != 0, TRUE,
+        cd, NULL);
+      *be = end_op;
+      DPRINTF(("fixed length = %d\n", fixed_length));
+      if (fixed_length < 0)
+        {
+        errorcode = (fixed_length == -2)? ERR36 :
+                    (fixed_length == -4)? ERR70 : ERR25;
+        break;
+        }
+      if (fixed_length > cd->max_lookbehind) cd->max_lookbehind = fixed_length;
+      PUT(cc, 1, fixed_length);
+      }
+    cc += 1 + LINK_SIZE;
+    }
+  }
+
+/* Failed to compile, or error while post-processing */
+
+if (errorcode != 0)
+  {
+  (PUBL(free))(re);
+  PCRE_EARLY_ERROR_RETURN:
+  *erroroffset = (int)(ptr - (const pcre_uchar *)pattern);
+  PCRE_EARLY_ERROR_RETURN2:
+  *errorptr = find_error_text(errorcode);
+  if (errorcodeptr != NULL) *errorcodeptr = errorcode;
+  return NULL;
+  }
+
+/* If the anchored option was not passed, set the flag if we can determine that
+the pattern is anchored by virtue of ^ characters or \A or anything else, such
+as starting with non-atomic .* when DOTALL is set and there are no occurrences
+of *PRUNE or *SKIP.
+
+Otherwise, if we know what the first byte has to be, save it, because that
+speeds up unanchored matches no end. If not, see if we can set the
+PCRE_STARTLINE flag. This is helpful for multiline matches when all branches
+start with ^. and also when all branches start with non-atomic .* for
+non-DOTALL matches when *PRUNE and SKIP are not present. */
+
+if ((re->options & PCRE_ANCHORED) == 0)
+  {
+  if (is_anchored(codestart, 0, cd, 0)) re->options |= PCRE_ANCHORED;
+  else
+    {
+    if (firstcharflags < 0)
+      firstchar = find_firstassertedchar(codestart, &firstcharflags, FALSE);
+    if (firstcharflags >= 0)   /* Remove caseless flag for non-caseable chars */
+      {
+#if defined COMPILE_PCRE8
+      re->first_char = firstchar & 0xff;
+#elif defined COMPILE_PCRE16
+      re->first_char = firstchar & 0xffff;
+#elif defined COMPILE_PCRE32
+      re->first_char = firstchar;
+#endif
+      if ((firstcharflags & REQ_CASELESS) != 0)
+        {
+#if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
+        /* We ignore non-ASCII first chars in 8 bit mode. */
+        if (utf)
+          {
+          if (re->first_char < 128)
+            {
+            if (cd->fcc[re->first_char] != re->first_char)
+              re->flags |= PCRE_FCH_CASELESS;
+            }
+          else if (UCD_OTHERCASE(re->first_char) != re->first_char)
+            re->flags |= PCRE_FCH_CASELESS;
+          }
+        else
+#endif
+        if (MAX_255(re->first_char)
+            && cd->fcc[re->first_char] != re->first_char)
+          re->flags |= PCRE_FCH_CASELESS;
+        }
+
+      re->flags |= PCRE_FIRSTSET;
+      }
+
+    else if (is_startline(codestart, 0, cd, 0, FALSE)) re->flags |= PCRE_STARTLINE;
+    }
+  }
+
+/* For an anchored pattern, we use the "required byte" only if it follows a
+variable length item in the regex. Remove the caseless flag for non-caseable
+bytes. */
+
+if (reqcharflags >= 0 &&
+     ((re->options & PCRE_ANCHORED) == 0 || (reqcharflags & REQ_VARY) != 0))
+  {
+#if defined COMPILE_PCRE8
+  re->req_char = reqchar & 0xff;
+#elif defined COMPILE_PCRE16
+  re->req_char = reqchar & 0xffff;
+#elif defined COMPILE_PCRE32
+  re->req_char = reqchar;
+#endif
+  if ((reqcharflags & REQ_CASELESS) != 0)
+    {
+#if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
+    /* We ignore non-ASCII first chars in 8 bit mode. */
+    if (utf)
+      {
+      if (re->req_char < 128)
+        {
+        if (cd->fcc[re->req_char] != re->req_char)
+          re->flags |= PCRE_RCH_CASELESS;
+        }
+      else if (UCD_OTHERCASE(re->req_char) != re->req_char)
+        re->flags |= PCRE_RCH_CASELESS;
+      }
+    else
+#endif
+    if (MAX_255(re->req_char) && cd->fcc[re->req_char] != re->req_char)
+      re->flags |= PCRE_RCH_CASELESS;
+    }
+
+  re->flags |= PCRE_REQCHSET;
+  }
+
+/* Print out the compiled data if debugging is enabled. This is never the
+case when building a production library. */
+
+#ifdef PCRE_DEBUG
+printf("Length = %d top_bracket = %d top_backref = %d\n",
+  length, re->top_bracket, re->top_backref);
+
+printf("Options=%08x\n", re->options);
+
+if ((re->flags & PCRE_FIRSTSET) != 0)
+  {
+  pcre_uchar ch = re->first_char;
+  const char *caseless =
+    ((re->flags & PCRE_FCH_CASELESS) == 0)? "" : " (caseless)";
+  if (PRINTABLE(ch)) printf("First char = %c%s\n", ch, caseless);
+    else printf("First char = \\x%02x%s\n", ch, caseless);
+  }
+
+if ((re->flags & PCRE_REQCHSET) != 0)
+  {
+  pcre_uchar ch = re->req_char;
+  const char *caseless =
+    ((re->flags & PCRE_RCH_CASELESS) == 0)? "" : " (caseless)";
+  if (PRINTABLE(ch)) printf("Req char = %c%s\n", ch, caseless);
+    else printf("Req char = \\x%02x%s\n", ch, caseless);
+  }
+
+#if defined COMPILE_PCRE8
+pcre_printint((pcre *)re, stdout, TRUE);
+#elif defined COMPILE_PCRE16
+pcre16_printint((pcre *)re, stdout, TRUE);
+#elif defined COMPILE_PCRE32
+pcre32_printint((pcre *)re, stdout, TRUE);
+#endif
+
+/* This check is done here in the debugging case so that the code that
+was compiled can be seen. */
+
+if (code - codestart > length)
+  {
+  (PUBL(free))(re);
+  *errorptr = find_error_text(ERR23);
+  *erroroffset = ptr - (pcre_uchar *)pattern;
+  if (errorcodeptr != NULL) *errorcodeptr = ERR23;
+  return NULL;
+  }
+#endif   /* PCRE_DEBUG */
+
+/* Check for a pattern than can match an empty string, so that this information
+can be provided to applications. */
+
+do
+  {
+  if (could_be_empty_branch(codestart, code, utf, cd, NULL))
+    {
+    re->flags |= PCRE_MATCH_EMPTY;
+    break;
+    }
+  codestart += GET(codestart, 1);
+  }
+while (*codestart == OP_ALT);
+
+#if defined COMPILE_PCRE8
+return (pcre *)re;
+#elif defined COMPILE_PCRE16
+return (pcre16 *)re;
+#elif defined COMPILE_PCRE32
+return (pcre32 *)re;
+#endif
+}
+
+/* End of pcre_compile.c */
diff --git a/base/poco/Foundation/src/pcre_config.c b/base/poco/Foundation/src/pcre_config.c
new file mode 100644
index 00000000000..35c12dfc2fa
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_config.c
@@ -0,0 +1,187 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2012 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+
+/* This module contains the external function pcre_config(). */
+
+#include "pcre_config.h"
+
+/* Keep the original link size. */
+static int real_link_size = LINK_SIZE;
+
+#include "pcre_internal.h"
+
+
+/*************************************************
+* Return info about what features are configured *
+*************************************************/
+
+/* This function has an extensible interface so that additional items can be
+added compatibly.
+
+Arguments:
+  what             what information is required
+  where            where to put the information
+
+Returns:           0 if data returned, negative on error
+*/
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre_config(int what, void *where)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre16_config(int what, void *where)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre32_config(int what, void *where)
+#endif
+{
+switch (what)
+  {
+  case PCRE_CONFIG_UTF8:
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+  *((int *)where) = 0;
+  return PCRE_ERROR_BADOPTION;
+#else
+#if defined SUPPORT_UTF
+  *((int *)where) = 1;
+#else
+  *((int *)where) = 0;
+#endif
+  break;
+#endif
+
+  case PCRE_CONFIG_UTF16:
+#if defined COMPILE_PCRE8 || defined COMPILE_PCRE32
+  *((int *)where) = 0;
+  return PCRE_ERROR_BADOPTION;
+#else
+#if defined SUPPORT_UTF
+  *((int *)where) = 1;
+#else
+  *((int *)where) = 0;
+#endif
+  break;
+#endif
+
+  case PCRE_CONFIG_UTF32:
+#if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
+  *((int *)where) = 0;
+  return PCRE_ERROR_BADOPTION;
+#else
+#if defined SUPPORT_UTF
+  *((int *)where) = 1;
+#else
+  *((int *)where) = 0;
+#endif
+  break;
+#endif
+
+  case PCRE_CONFIG_UNICODE_PROPERTIES:
+#ifdef SUPPORT_UCP
+  *((int *)where) = 1;
+#else
+  *((int *)where) = 0;
+#endif
+  break;
+
+  case PCRE_CONFIG_JIT:
+#ifdef SUPPORT_JIT
+  *((int *)where) = 1;
+#else
+  *((int *)where) = 0;
+#endif
+  break;
+
+  case PCRE_CONFIG_JITTARGET:
+#ifdef SUPPORT_JIT
+  *((const char **)where) = PRIV(jit_get_target)();
+#else
+  *((const char **)where) = NULL;
+#endif
+  break;
+
+  case PCRE_CONFIG_NEWLINE:
+  *((int *)where) = NEWLINE;
+  break;
+
+  case PCRE_CONFIG_BSR:
+#ifdef BSR_ANYCRLF
+  *((int *)where) = 1;
+#else
+  *((int *)where) = 0;
+#endif
+  break;
+
+  case PCRE_CONFIG_LINK_SIZE:
+  *((int *)where) = real_link_size;
+  break;
+
+  case PCRE_CONFIG_POSIX_MALLOC_THRESHOLD:
+  *((int *)where) = POSIX_MALLOC_THRESHOLD;
+  break;
+
+  case PCRE_CONFIG_PARENS_LIMIT:
+  *((unsigned long int *)where) = PARENS_NEST_LIMIT;
+  break;
+
+  case PCRE_CONFIG_MATCH_LIMIT:
+  *((unsigned long int *)where) = MATCH_LIMIT;
+  break;
+
+  case PCRE_CONFIG_MATCH_LIMIT_RECURSION:
+  *((unsigned long int *)where) = MATCH_LIMIT_RECURSION;
+  break;
+
+  case PCRE_CONFIG_STACKRECURSE:
+#ifdef NO_RECURSE
+  *((int *)where) = 0;
+#else
+  *((int *)where) = 1;
+#endif
+  break;
+
+  default: return PCRE_ERROR_BADOPTION;
+  }
+
+return 0;
+}
+
+/* End of pcre_config.c */
diff --git a/base/poco/Foundation/src/pcre_config.h b/base/poco/Foundation/src/pcre_config.h
new file mode 100644
index 00000000000..7d95bd4f63c
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_config.h
@@ -0,0 +1,413 @@
+/* config.h.  Generated from config.h.in by configure.  */
+/* config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* PCRE is written in Standard C, but there are a few non-standard things it
+can cope with, allowing it to run on SunOS4 and other "close to standard"
+systems.
+
+In environments that support the GNU autotools, config.h.in is converted into
+config.h by the "configure" script. In environments that use CMake,
+config-cmake.in is converted into config.h. If you are going to build PCRE "by
+hand" without using "configure" or CMake, you should copy the distributed
+config.h.generic to config.h, and edit the macro definitions to be the way you
+need them. You must then add -DHAVE_CONFIG_H to all of your compile commands,
+so that config.h is included at the start of every source.
+
+Alternatively, you can avoid editing by using -D on the compiler command line
+to set the macro values. In this case, you do not have to set -DHAVE_CONFIG_H,
+but if you do, default values will be taken from config.h for non-boolean
+macros that are not defined on the command line.
+
+Boolean macros such as HAVE_STDLIB_H and SUPPORT_PCRE8 should either be defined
+(conventionally to 1) for TRUE, and not defined at all for FALSE. All such
+macros are listed as a commented #undef in config.h.generic. Macros such as
+MATCH_LIMIT, whose actual value is relevant, have defaults defined, but are
+surrounded by #ifndef/#endif lines so that the value can be overridden by -D.
+
+PCRE uses memmove() if HAVE_MEMMOVE is defined; otherwise it uses bcopy() if
+HAVE_BCOPY is defined. If your system has neither bcopy() nor memmove(), make
+sure both macros are undefined; an emulation function will then be used. */
+
+/* By default, the \R escape sequence matches any Unicode line ending
+   character or sequence of characters. If BSR_ANYCRLF is defined (to any
+   value), this is changed so that backslash-R matches only CR, LF, or CRLF.
+   The build-time default can be overridden by the user of PCRE at runtime. */
+/* #undef BSR_ANYCRLF */
+
+/* If you are compiling for a system that uses EBCDIC instead of ASCII
+   character codes, define this macro to any value. You must also edit the
+   NEWLINE macro below to set a suitable EBCDIC newline, commonly 21 (0x15).
+   On systems that can use "configure" or CMake to set EBCDIC, NEWLINE is
+   automatically adjusted. When EBCDIC is set, PCRE assumes that all input
+   strings are in EBCDIC. If you do not define this macro, PCRE will assume
+   input strings are ASCII or UTF-8/16/32 Unicode. It is not possible to build
+   a version of PCRE that supports both EBCDIC and UTF-8/16/32. */
+/* #undef EBCDIC */
+
+/* In an EBCDIC environment, define this macro to any value to arrange for the
+   NL character to be 0x25 instead of the default 0x15. NL plays the role that
+   LF does in an ASCII/Unicode environment. The value must also be set in the
+   NEWLINE macro below. On systems that can use "configure" or CMake to set
+   EBCDIC_NL25, the adjustment of NEWLINE is automatic. */
+/* #undef EBCDIC_NL25 */
+
+/* Define to 1 if you have the `bcopy' function. */
+/* #undef HAVE_BCOPY */
+
+/* Define to 1 if you have the <bits/type_traits.h> header file. */
+/* #undef HAVE_BITS_TYPE_TRAITS_H */
+
+/* Define to 1 if you have the <bzlib.h> header file. */
+/* #undef HAVE_BZLIB_H */
+
+/* Define to 1 if you have the <dirent.h> header file. */
+#ifndef HAVE_DIRENT_H
+#define HAVE_DIRENT_H 0
+#endif
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#ifndef HAVE_DLFCN_H
+#define HAVE_DLFCN_H 0
+#endif
+
+/* Define to 1 if you have the <editline/readline.h> header file. */
+#ifndef HAVE_EDITLINE_READLINE_H
+#define HAVE_EDITLINE_READLINE_H 0
+#endif
+
+/* Define to 1 if you have the <edit/readline/readline.h> header file. */
+#ifndef HAVE_EDIT_READLINE_READLINE_H
+#define HAVE_EDIT_READLINE_READLINE_H 0
+#endif
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#ifndef HAVE_INTTYPES_H
+#define HAVE_INTTYPES_H 0
+#endif
+
+/* Define to 1 if you have the <limits.h> header file. */
+/* #undef HAVE_LIMITS_H */
+#ifndef HAVE_LIMITS_H
+#define HAVE_LIMITS_H 1
+#endif
+
+/* Define to 1 if the system has the type `long long'. */
+#ifndef HAVE_LONG_LONG
+#define HAVE_LONG_LONG 0
+#endif
+
+/* Define to 1 if you have the `memmove' function. */
+#ifndef HAVE_MEMMOVE
+#define HAVE_MEMMOVE 0
+#endif
+
+/* Define to 1 if you have the <memory.h> header file. */
+#ifndef HAVE_MEMORY_H
+#define HAVE_MEMORY_H 1
+#endif
+
+/* Define if you have POSIX threads libraries and header files. */
+#ifndef HAVE_PTHREAD
+#define HAVE_PTHREAD 0
+#endif
+
+/* Have PTHREAD_PRIO_INHERIT. */
+#ifndef HAVE_PTHREAD_PRIO_INHERIT
+#define HAVE_PTHREAD_PRIO_INHERIT 0
+#endif
+
+/* Define to 1 if you have the <readline/history.h> header file. */
+#ifndef HAVE_READLINE_HISTORY_H
+#define HAVE_READLINE_HISTORY_H 0
+#endif
+
+/* Define to 1 if you have the <readline/readline.h> header file. */
+#ifndef HAVE_READLINE_READLINE_H
+#define HAVE_READLINE_READLINE_H 0
+#endif
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#ifndef HAVE_STDINT_H
+#define HAVE_STDINT_H 0
+#endif
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#ifndef HAVE_STDLIB_H
+#define HAVE_STDLIB_H 1
+#endif
+
+/* Define to 1 if you have the `strerror' function. */
+#ifndef HAVE_STRERROR
+#define HAVE_STRERROR 0
+#endif
+
+/* Define to 1 if you have the <string> header file. */
+#ifndef HAVE_STRING
+#define HAVE_STRING 0
+#endif
+
+/* Define to 1 if you have the <strings.h> header file. */
+#ifndef HAVE_STRINGS_H
+#define HAVE_STRINGS_H 0
+#endif
+
+/* Define to 1 if you have the <string.h> header file. */
+#ifndef HAVE_STRING_H
+#define HAVE_STRING_H 1
+#endif
+
+/* Define to 1 if you have `strtoimax'. */
+#ifndef HAVE_STRTOIMAX
+#define HAVE_STRTOIMAX 0
+#endif
+
+/* Define to 1 if you have `strtoll'. */
+#ifndef HAVE_STRTOLL
+#define HAVE_STRTOLL 0
+#endif
+
+/* Define to 1 if you have `strtoq'. */
+#ifndef HAVE_STRTOQ
+#define HAVE_STRTOQ 0
+#endif
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#ifndef HAVE_SYS_STAT_H
+#define HAVE_SYS_STAT_H 0
+#endif
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#ifndef HAVE_SYS_TYPES_H
+#define HAVE_SYS_TYPES_H 0
+#endif
+
+/* Define to 1 if you have the <type_traits.h> header file. */
+/* #undef HAVE_TYPE_TRAITS_H */
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#ifndef HAVE_UNISTD_H
+#define HAVE_UNISTD_H 0
+#endif
+
+/* Define to 1 if the system has the type `unsigned long long'. */
+#ifndef HAVE_UNSIGNED_LONG_LONG
+#define HAVE_UNSIGNED_LONG_LONG 0
+#endif
+
+/* Define to 1 if the compiler supports simple visibility declarations. */
+/* #undef HAVE_VISIBILITY */
+
+/* Define to 1 if you have the <windows.h> header file. */
+/* #undef HAVE_WINDOWS_H */
+
+/* Define to 1 if you have the <zlib.h> header file. */
+/* #undef HAVE_ZLIB_H */
+
+/* Define to 1 if you have `_strtoi64'. */
+/* #undef HAVE__STRTOI64 */
+
+/* The value of LINK_SIZE determines the number of bytes used to store links
+   as offsets within the compiled regex. The default is 2, which allows for
+   compiled patterns up to 64K long. This covers the vast majority of cases.
+   However, PCRE can also be compiled to use 3 or 4 bytes instead. This allows
+   for longer patterns in extreme cases. */
+#ifndef LINK_SIZE
+#define LINK_SIZE 2
+#endif
+
+/* Define to the sub-directory in which libtool stores uninstalled libraries.
+   */
+/* This is ignored unless you are using libtool. */
+#ifndef LT_OBJDIR
+#define LT_OBJDIR ".libs/"
+#endif
+
+/* The value of MATCH_LIMIT determines the default number of times the
+   internal match() function can be called during a single execution of
+   pcre_exec(). There is a runtime interface for setting a different limit.
+   The limit exists in order to catch runaway regular expressions that take
+   for ever to determine that they do not match. The default is set very large
+   so that it does not accidentally catch legitimate cases. */
+#ifndef MATCH_LIMIT
+#define MATCH_LIMIT 10000000
+#endif
+
+/* The above limit applies to all calls of match(), whether or not they
+   increase the recursion depth. In some environments it is desirable to limit
+   the depth of recursive calls of match() more strictly, in order to restrict
+   the maximum amount of stack (or heap, if NO_RECURSE is defined) that is
+   used. The value of MATCH_LIMIT_RECURSION applies only to recursive calls of
+   match(). To have any useful effect, it must be less than the value of
+   MATCH_LIMIT. The default is to use the same value as MATCH_LIMIT. There is
+   a runtime method for setting a different limit. */
+#ifndef MATCH_LIMIT_RECURSION
+#define MATCH_LIMIT_RECURSION MATCH_LIMIT
+#endif
+
+/* This limit is parameterized just in case anybody ever wants to change it.
+   Care must be taken if it is increased, because it guards against integer
+   overflow caused by enormously large patterns. */
+#ifndef MAX_NAME_COUNT
+#define MAX_NAME_COUNT 30000
+#endif
+
+/* This limit is parameterized just in case anybody ever wants to change it.
+   Care must be taken if it is increased, because it guards against integer
+   overflow caused by enormously large patterns. */
+#ifndef MAX_NAME_SIZE
+#define MAX_NAME_SIZE 32
+#endif
+
+/* The value of NEWLINE determines the default newline character sequence.
+   PCRE client programs can override this by selecting other values at run
+   time. In ASCII environments, the value can be 10 (LF), 13 (CR), or 3338
+   (CRLF); in EBCDIC environments the value can be 21 or 37 (LF), 13 (CR), or
+   3349 or 3365 (CRLF) because there are two alternative codepoints (0x15 and
+   0x25) that are used as the NL line terminator that is equivalent to ASCII
+   LF. In both ASCII and EBCDIC environments the value can also be -1 (ANY),
+   or -2 (ANYCRLF). */
+#ifndef NEWLINE
+#define NEWLINE 10
+#endif
+
+/* PCRE uses recursive function calls to handle backtracking while matching.
+   This can sometimes be a problem on systems that have stacks of limited
+   size. Define NO_RECURSE to any value to get a version that doesn't use
+   recursion in the match() function; instead it creates its own stack by
+   steam using pcre_recurse_malloc() to obtain memory from the heap. For more
+   detail, see the comments and other stuff just above the match() function.
+   */
+/* #undef NO_RECURSE */
+
+/* Name of package */
+#define PACKAGE "pcre"
+
+/* Define to the address where bug reports for this package should be sent. */
+#define PACKAGE_BUGREPORT ""
+
+/* Define to the full name of this package. */
+#define PACKAGE_NAME "PCRE"
+
+/* Define to the full name and version of this package. */
+#define PACKAGE_STRING "PCRE 8.43"
+
+/* Define to the one symbol short name of this package. */
+#define PACKAGE_TARNAME "pcre"
+
+/* Define to the home page for this package. */
+#define PACKAGE_URL ""
+
+/* Define to the version of this package. */
+#define PACKAGE_VERSION "8.43"
+
+/* The value of PARENS_NEST_LIMIT specifies the maximum depth of nested
+   parentheses (of any kind) in a pattern. This limits the amount of system
+   stack that is used while compiling a pattern. */
+#ifndef PARENS_NEST_LIMIT
+#define PARENS_NEST_LIMIT 250
+#endif
+
+/* The value of PCREGREP_BUFSIZE determines the size of buffer used by
+   pcregrep to hold parts of the file it is searching. This is also the
+   minimum value. The actual amount of memory used by pcregrep is three times
+   this number, because it allows for the buffering of "before" and "after"
+   lines. */
+#ifndef PCREGREP_BUFSIZE
+#define PCREGREP_BUFSIZE 20480
+#endif
+
+/* If you are compiling for a system other than a Unix-like system or
+   Win32, and it needs some magic to be inserted before the definition
+   of a function that is exported by the library, define this macro to
+   contain the relevant magic. If you do not define this macro, a suitable
+    __declspec value is used for Windows systems; in other environments
+   "extern" is used for a C compiler and "extern C" for a C++ compiler.
+   This macro apears at the start of every exported function that is part
+   of the external API. It does not appear on functions that are "external"
+   in the C sense, but which are internal to the library. */
+/* #undef PCRE_EXP_DEFN */
+
+/* Define to any value if linking statically (TODO: make nice with Libtool) */
+#ifndef PCRE_STATIC
+#define PCRE_STATIC 1
+#endif
+
+/* When calling PCRE via the POSIX interface, additional working storage is
+   required for holding the pointers to capturing substrings because PCRE
+   requires three integers per substring, whereas the POSIX interface provides
+   only two. If the number of expected substrings is small, the wrapper
+   function uses space on the stack, because this is faster than using
+   malloc() for each call. The threshold above which the stack is no longer
+   used is defined by POSIX_MALLOC_THRESHOLD. */
+#ifndef POSIX_MALLOC_THRESHOLD
+#define POSIX_MALLOC_THRESHOLD 10
+#endif
+
+/* Define to necessary symbol if this constant uses a non-standard name on
+   your system. */
+/* #undef PTHREAD_CREATE_JOINABLE */
+
+/* Define to 1 if you have the ANSI C header files. */
+#ifndef STDC_HEADERS
+#define STDC_HEADERS 1
+#endif
+
+/* Define to any value to enable support for Just-In-Time compiling. */
+/* #undef SUPPORT_JIT */
+
+/* Define to any value to allow pcregrep to be linked with libbz2, so that it
+   is able to handle .bz2 files. */
+/* #undef SUPPORT_LIBBZ2 */
+
+/* Define to any value to allow pcretest to be linked with libedit. */
+/* #undef SUPPORT_LIBEDIT */
+
+/* Define to any value to allow pcretest to be linked with libreadline. */
+/* #undef SUPPORT_LIBREADLINE */
+
+/* Define to any value to allow pcregrep to be linked with libz, so that it is
+   able to handle .gz files. */
+/* #undef SUPPORT_LIBZ */
+
+/* Define to any value to enable the 16 bit PCRE library. */
+/* #undef SUPPORT_PCRE16 */
+
+/* Define to any value to enable the 32 bit PCRE library. */
+/* #undef SUPPORT_PCRE32 */
+
+/* Define to any value to enable the 8 bit PCRE library. */
+#ifndef SUPPORT_PCRE8
+#define SUPPORT_PCRE8
+#endif
+
+/* Define to any value to enable JIT support in pcregrep. */
+/* #undef SUPPORT_PCREGREP_JIT */
+
+/* Define to any value to enable support for Unicode properties. */
+#ifndef SUPPORT_UCP
+#define SUPPORT_UCP
+#endif
+
+/* Define to any value to enable support for the UTF-8/16/32 Unicode encoding.
+   This will work even in an EBCDIC environment, but it is incompatible with
+   the EBCDIC macro. That is, PCRE can support *either* EBCDIC code *or*
+   ASCII/UTF-8/16/32, but not both at once. */
+#ifndef SUPPORT_UTF8
+#define SUPPORT_UTF8
+#endif
+
+/* Define to any value for valgrind support to find invalid memory reads. */
+/* #undef SUPPORT_VALGRIND */
+
+/* Version number of package */
+#define VERSION "8.43"
+
+/* Define to empty if `const' does not conform to ANSI C. */
+/* #undef const */
+
+/* Define to the type of a signed integer type of width exactly 64 bits if
+   such a type exists and the standard includes do not define it. */
+/* #undef int64_t */
+
+/* Define to `unsigned int' if <sys/types.h> does not define. */
+/* #undef size_t */
diff --git a/base/poco/Foundation/src/pcre_dfa_exec.c b/base/poco/Foundation/src/pcre_dfa_exec.c
new file mode 100644
index 00000000000..ae7c46d7584
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_dfa_exec.c
@@ -0,0 +1,3675 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language (but see
+below for why this module is different).
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2017 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+/* This module contains the external function pcre_dfa_exec(), which is an
+alternative matching function that uses a sort of DFA algorithm (not a true
+FSM). This is NOT Perl-compatible, but it has advantages in certain
+applications. */
+
+
+/* NOTE ABOUT PERFORMANCE: A user of this function sent some code that improved
+the performance of his patterns greatly. I could not use it as it stood, as it
+was not thread safe, and made assumptions about pattern sizes. Also, it caused
+test 7 to loop, and test 9 to crash with a segfault.
+
+The issue is the check for duplicate states, which is done by a simple linear
+search up the state list. (Grep for "duplicate" below to find the code.) For
+many patterns, there will never be many states active at one time, so a simple
+linear search is fine. In patterns that have many active states, it might be a
+bottleneck. The suggested code used an indexing scheme to remember which states
+had previously been used for each character, and avoided the linear search when
+it knew there was no chance of a duplicate. This was implemented when adding
+states to the state lists.
+
+I wrote some thread-safe, not-limited code to try something similar at the time
+of checking for duplicates (instead of when adding states), using index vectors
+on the stack. It did give a 13% improvement with one specially constructed
+pattern for certain subject strings, but on other strings and on many of the
+simpler patterns in the test suite it did worse. The major problem, I think,
+was the extra time to initialize the index. This had to be done for each call
+of internal_dfa_exec(). (The supplied patch used a static vector, initialized
+only once - I suspect this was the cause of the problems with the tests.)
+
+Overall, I concluded that the gains in some cases did not outweigh the losses
+in others, so I abandoned this code. */
+
+#pragma warning( disable : 4244)  // conversion from 'int' to 'unsigned short', possible loss of data
+#pragma warning( disable : 4146)  // unary minus operator applied to unsigned type, result still unsigned
+
+#include "pcre_config.h"
+
+#define NLBLOCK md             /* Block containing newline information */
+#define PSSTART start_subject  /* Field containing processed string start */
+#define PSEND   end_subject    /* Field containing processed string end */
+
+#include "pcre_internal.h"
+
+
+/* For use to indent debugging output */
+
+#define SP "                   "
+
+
+/*************************************************
+*      Code parameters and static tables         *
+*************************************************/
+
+/* These are offsets that are used to turn the OP_TYPESTAR and friends opcodes
+into others, under special conditions. A gap of 20 between the blocks should be
+enough. The resulting opcodes don't have to be less than 256 because they are
+never stored, so we push them well clear of the normal opcodes. */
+
+#define OP_PROP_EXTRA       300
+#define OP_EXTUNI_EXTRA     320
+#define OP_ANYNL_EXTRA      340
+#define OP_HSPACE_EXTRA     360
+#define OP_VSPACE_EXTRA     380
+
+
+/* This table identifies those opcodes that are followed immediately by a
+character that is to be tested in some way. This makes it possible to
+centralize the loading of these characters. In the case of Type * etc, the
+"character" is the opcode for \D, \d, \S, \s, \W, or \w, which will always be a
+small value. Non-zero values in the table are the offsets from the opcode where
+the character is to be found. ***NOTE*** If the start of this table is
+modified, the three tables that follow must also be modified. */
+
+static const pcre_uint8 coptable[] = {
+  0,                             /* End                                    */
+  0, 0, 0, 0, 0,                 /* \A, \G, \K, \B, \b                     */
+  0, 0, 0, 0, 0, 0,              /* \D, \d, \S, \s, \W, \w                 */
+  0, 0, 0,                       /* Any, AllAny, Anybyte                   */
+  0, 0,                          /* \P, \p                                 */
+  0, 0, 0, 0, 0,                 /* \R, \H, \h, \V, \v                     */
+  0,                             /* \X                                     */
+  0, 0, 0, 0, 0, 0,              /* \Z, \z, $, $M, ^, ^M                   */
+  1,                             /* Char                                   */
+  1,                             /* Chari                                  */
+  1,                             /* not                                    */
+  1,                             /* noti                                   */
+  /* Positive single-char repeats                                          */
+  1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */
+  1+IMM2_SIZE, 1+IMM2_SIZE,      /* upto, minupto                          */
+  1+IMM2_SIZE,                   /* exact                                  */
+  1, 1, 1, 1+IMM2_SIZE,          /* *+, ++, ?+, upto+                      */
+  1, 1, 1, 1, 1, 1,              /* *I, *?I, +I, +?I, ?I, ??I              */
+  1+IMM2_SIZE, 1+IMM2_SIZE,      /* upto I, minupto I                      */
+  1+IMM2_SIZE,                   /* exact I                                */
+  1, 1, 1, 1+IMM2_SIZE,          /* *+I, ++I, ?+I, upto+I                  */
+  /* Negative single-char repeats - only for chars < 256                   */
+  1, 1, 1, 1, 1, 1,              /* NOT *, *?, +, +?, ?, ??                */
+  1+IMM2_SIZE, 1+IMM2_SIZE,      /* NOT upto, minupto                      */
+  1+IMM2_SIZE,                   /* NOT exact                              */
+  1, 1, 1, 1+IMM2_SIZE,          /* NOT *+, ++, ?+, upto+                  */
+  1, 1, 1, 1, 1, 1,              /* NOT *I, *?I, +I, +?I, ?I, ??I          */
+  1+IMM2_SIZE, 1+IMM2_SIZE,      /* NOT upto I, minupto I                  */
+  1+IMM2_SIZE,                   /* NOT exact I                            */
+  1, 1, 1, 1+IMM2_SIZE,          /* NOT *+I, ++I, ?+I, upto+I              */
+  /* Positive type repeats                                                 */
+  1, 1, 1, 1, 1, 1,              /* Type *, *?, +, +?, ?, ??               */
+  1+IMM2_SIZE, 1+IMM2_SIZE,      /* Type upto, minupto                     */
+  1+IMM2_SIZE,                   /* Type exact                             */
+  1, 1, 1, 1+IMM2_SIZE,          /* Type *+, ++, ?+, upto+                 */
+  /* Character class & ref repeats                                         */
+  0, 0, 0, 0, 0, 0,              /* *, *?, +, +?, ?, ??                    */
+  0, 0,                          /* CRRANGE, CRMINRANGE                    */
+  0, 0, 0, 0,                    /* Possessive *+, ++, ?+, CRPOSRANGE      */
+  0,                             /* CLASS                                  */
+  0,                             /* NCLASS                                 */
+  0,                             /* XCLASS - variable length               */
+  0,                             /* REF                                    */
+  0,                             /* REFI                                   */
+  0,                             /* DNREF                                  */
+  0,                             /* DNREFI                                 */
+  0,                             /* RECURSE                                */
+  0,                             /* CALLOUT                                */
+  0,                             /* Alt                                    */
+  0,                             /* Ket                                    */
+  0,                             /* KetRmax                                */
+  0,                             /* KetRmin                                */
+  0,                             /* KetRpos                                */
+  0,                             /* Reverse                                */
+  0,                             /* Assert                                 */
+  0,                             /* Assert not                             */
+  0,                             /* Assert behind                          */
+  0,                             /* Assert behind not                      */
+  0, 0,                          /* ONCE, ONCE_NC                          */
+  0, 0, 0, 0, 0,                 /* BRA, BRAPOS, CBRA, CBRAPOS, COND       */
+  0, 0, 0, 0, 0,                 /* SBRA, SBRAPOS, SCBRA, SCBRAPOS, SCOND  */
+  0, 0,                          /* CREF, DNCREF                           */
+  0, 0,                          /* RREF, DNRREF                           */
+  0,                             /* DEF                                    */
+  0, 0, 0,                       /* BRAZERO, BRAMINZERO, BRAPOSZERO        */
+  0, 0, 0,                       /* MARK, PRUNE, PRUNE_ARG                 */
+  0, 0, 0, 0,                    /* SKIP, SKIP_ARG, THEN, THEN_ARG         */
+  0, 0, 0, 0,                    /* COMMIT, FAIL, ACCEPT, ASSERT_ACCEPT    */
+  0, 0                           /* CLOSE, SKIPZERO  */
+};
+
+/* This table identifies those opcodes that inspect a character. It is used to
+remember the fact that a character could have been inspected when the end of
+the subject is reached. ***NOTE*** If the start of this table is modified, the
+two tables that follow must also be modified. */
+
+static const pcre_uint8 poptable[] = {
+  0,                             /* End                                    */
+  0, 0, 0, 1, 1,                 /* \A, \G, \K, \B, \b                     */
+  1, 1, 1, 1, 1, 1,              /* \D, \d, \S, \s, \W, \w                 */
+  1, 1, 1,                       /* Any, AllAny, Anybyte                   */
+  1, 1,                          /* \P, \p                                 */
+  1, 1, 1, 1, 1,                 /* \R, \H, \h, \V, \v                     */
+  1,                             /* \X                                     */
+  0, 0, 0, 0, 0, 0,              /* \Z, \z, $, $M, ^, ^M                   */
+  1,                             /* Char                                   */
+  1,                             /* Chari                                  */
+  1,                             /* not                                    */
+  1,                             /* noti                                   */
+  /* Positive single-char repeats                                          */
+  1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */
+  1, 1, 1,                       /* upto, minupto, exact                   */
+  1, 1, 1, 1,                    /* *+, ++, ?+, upto+                      */
+  1, 1, 1, 1, 1, 1,              /* *I, *?I, +I, +?I, ?I, ??I              */
+  1, 1, 1,                       /* upto I, minupto I, exact I             */
+  1, 1, 1, 1,                    /* *+I, ++I, ?+I, upto+I                  */
+  /* Negative single-char repeats - only for chars < 256                   */
+  1, 1, 1, 1, 1, 1,              /* NOT *, *?, +, +?, ?, ??                */
+  1, 1, 1,                       /* NOT upto, minupto, exact               */
+  1, 1, 1, 1,                    /* NOT *+, ++, ?+, upto+                  */
+  1, 1, 1, 1, 1, 1,              /* NOT *I, *?I, +I, +?I, ?I, ??I          */
+  1, 1, 1,                       /* NOT upto I, minupto I, exact I         */
+  1, 1, 1, 1,                    /* NOT *+I, ++I, ?+I, upto+I              */
+  /* Positive type repeats                                                 */
+  1, 1, 1, 1, 1, 1,              /* Type *, *?, +, +?, ?, ??               */
+  1, 1, 1,                       /* Type upto, minupto, exact              */
+  1, 1, 1, 1,                    /* Type *+, ++, ?+, upto+                 */
+  /* Character class & ref repeats                                         */
+  1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */
+  1, 1,                          /* CRRANGE, CRMINRANGE                    */
+  1, 1, 1, 1,                    /* Possessive *+, ++, ?+, CRPOSRANGE      */
+  1,                             /* CLASS                                  */
+  1,                             /* NCLASS                                 */
+  1,                             /* XCLASS - variable length               */
+  0,                             /* REF                                    */
+  0,                             /* REFI                                   */
+  0,                             /* DNREF                                  */
+  0,                             /* DNREFI                                 */
+  0,                             /* RECURSE                                */
+  0,                             /* CALLOUT                                */
+  0,                             /* Alt                                    */
+  0,                             /* Ket                                    */
+  0,                             /* KetRmax                                */
+  0,                             /* KetRmin                                */
+  0,                             /* KetRpos                                */
+  0,                             /* Reverse                                */
+  0,                             /* Assert                                 */
+  0,                             /* Assert not                             */
+  0,                             /* Assert behind                          */
+  0,                             /* Assert behind not                      */
+  0, 0,                          /* ONCE, ONCE_NC                          */
+  0, 0, 0, 0, 0,                 /* BRA, BRAPOS, CBRA, CBRAPOS, COND       */
+  0, 0, 0, 0, 0,                 /* SBRA, SBRAPOS, SCBRA, SCBRAPOS, SCOND  */
+  0, 0,                          /* CREF, DNCREF                           */
+  0, 0,                          /* RREF, DNRREF                           */
+  0,                             /* DEF                                    */
+  0, 0, 0,                       /* BRAZERO, BRAMINZERO, BRAPOSZERO        */
+  0, 0, 0,                       /* MARK, PRUNE, PRUNE_ARG                 */
+  0, 0, 0, 0,                    /* SKIP, SKIP_ARG, THEN, THEN_ARG         */
+  0, 0, 0, 0,                    /* COMMIT, FAIL, ACCEPT, ASSERT_ACCEPT    */
+  0, 0                           /* CLOSE, SKIPZERO                        */
+};
+
+/* These 2 tables allow for compact code for testing for \D, \d, \S, \s, \W,
+and \w */
+
+static const pcre_uint8 toptable1[] = {
+  0, 0, 0, 0, 0, 0,
+  ctype_digit, ctype_digit,
+  ctype_space, ctype_space,
+  ctype_word,  ctype_word,
+  0, 0                            /* OP_ANY, OP_ALLANY */
+};
+
+static const pcre_uint8 toptable2[] = {
+  0, 0, 0, 0, 0, 0,
+  ctype_digit, 0,
+  ctype_space, 0,
+  ctype_word,  0,
+  1, 1                            /* OP_ANY, OP_ALLANY */
+};
+
+
+/* Structure for holding data about a particular state, which is in effect the
+current data for an active path through the match tree. It must consist
+entirely of ints because the working vector we are passed, and which we put
+these structures in, is a vector of ints. */
+
+typedef struct stateblock {
+  int offset;                     /* Offset to opcode */
+  int count;                      /* Count for repeats */
+  int data;                       /* Some use extra data */
+} stateblock;
+
+#define INTS_PER_STATEBLOCK  (int)(sizeof(stateblock)/sizeof(int))
+
+
+#ifdef PCRE_DEBUG
+/*************************************************
+*             Print character string             *
+*************************************************/
+
+/* Character string printing function for debugging.
+
+Arguments:
+  p            points to string
+  length       number of bytes
+  f            where to print
+
+Returns:       nothing
+*/
+
+static void
+pchars(const pcre_uchar *p, int length, FILE *f)
+{
+pcre_uint32 c;
+while (length-- > 0)
+  {
+  if (isprint(c = *(p++)))
+    fprintf(f, "%c", c);
+  else
+    fprintf(f, "\\x{%02x}", c);
+  }
+}
+#endif
+
+
+
+/*************************************************
+*    Execute a Regular Expression - DFA engine   *
+*************************************************/
+
+/* This internal function applies a compiled pattern to a subject string,
+starting at a given point, using a DFA engine. This function is called from the
+external one, possibly multiple times if the pattern is not anchored. The
+function calls itself recursively for some kinds of subpattern.
+
+Arguments:
+  md                the match_data block with fixed information
+  this_start_code   the opening bracket of this subexpression's code
+  current_subject   where we currently are in the subject string
+  start_offset      start offset in the subject string
+  offsets           vector to contain the matching string offsets
+  offsetcount       size of same
+  workspace         vector of workspace
+  wscount           size of same
+  rlevel            function call recursion level
+
+Returns:            > 0 => number of match offset pairs placed in offsets
+                    = 0 => offsets overflowed; longest matches are present
+                     -1 => failed to match
+                   < -1 => some kind of unexpected problem
+
+The following macros are used for adding states to the two state vectors (one
+for the current character, one for the following character). */
+
+#define ADD_ACTIVE(x,y) \
+  if (active_count++ < wscount) \
+    { \
+    next_active_state->offset = (x); \
+    next_active_state->count  = (y); \
+    next_active_state++; \
+    DPRINTF(("%.*sADD_ACTIVE(%d,%d)\n", rlevel*2-2, SP, (x), (y))); \
+    } \
+  else return PCRE_ERROR_DFA_WSSIZE
+
+#define ADD_ACTIVE_DATA(x,y,z) \
+  if (active_count++ < wscount) \
+    { \
+    next_active_state->offset = (x); \
+    next_active_state->count  = (y); \
+    next_active_state->data   = (z); \
+    next_active_state++; \
+    DPRINTF(("%.*sADD_ACTIVE_DATA(%d,%d,%d)\n", rlevel*2-2, SP, (x), (y), (z))); \
+    } \
+  else return PCRE_ERROR_DFA_WSSIZE
+
+#define ADD_NEW(x,y) \
+  if (new_count++ < wscount) \
+    { \
+    next_new_state->offset = (x); \
+    next_new_state->count  = (y); \
+    next_new_state++; \
+    DPRINTF(("%.*sADD_NEW(%d,%d)\n", rlevel*2-2, SP, (x), (y))); \
+    } \
+  else return PCRE_ERROR_DFA_WSSIZE
+
+#define ADD_NEW_DATA(x,y,z) \
+  if (new_count++ < wscount) \
+    { \
+    next_new_state->offset = (x); \
+    next_new_state->count  = (y); \
+    next_new_state->data   = (z); \
+    next_new_state++; \
+    DPRINTF(("%.*sADD_NEW_DATA(%d,%d,%d) line %d\n", rlevel*2-2, SP, \
+      (x), (y), (z), __LINE__)); \
+    } \
+  else return PCRE_ERROR_DFA_WSSIZE
+
+/* And now, here is the code */
+
+static int
+internal_dfa_exec(
+  dfa_match_data *md,
+  const pcre_uchar *this_start_code,
+  const pcre_uchar *current_subject,
+  int start_offset,
+  int *offsets,
+  int offsetcount,
+  int *workspace,
+  int wscount,
+  int  rlevel)
+{
+stateblock *active_states, *new_states, *temp_states;
+stateblock *next_active_state, *next_new_state;
+
+const pcre_uint8 *ctypes, *lcc, *fcc;
+const pcre_uchar *ptr;
+const pcre_uchar *end_code, *first_op;
+
+dfa_recursion_info new_recursive;
+
+int active_count, new_count, match_count;
+
+/* Some fields in the md block are frequently referenced, so we load them into
+independent variables in the hope that this will perform better. */
+
+const pcre_uchar *start_subject = md->start_subject;
+const pcre_uchar *end_subject = md->end_subject;
+const pcre_uchar *start_code = md->start_code;
+
+#ifdef SUPPORT_UTF
+BOOL utf = (md->poptions & PCRE_UTF8) != 0;
+#else
+BOOL utf = FALSE;
+#endif
+
+BOOL reset_could_continue = FALSE;
+
+rlevel++;
+offsetcount &= (-2);
+
+wscount -= 2;
+wscount = (wscount - (wscount % (INTS_PER_STATEBLOCK * 2))) /
+          (2 * INTS_PER_STATEBLOCK);
+
+DPRINTF(("\n%.*s---------------------\n"
+  "%.*sCall to internal_dfa_exec f=%d\n",
+  rlevel*2-2, SP, rlevel*2-2, SP, rlevel));
+
+ctypes = md->tables + ctypes_offset;
+lcc = md->tables + lcc_offset;
+fcc = md->tables + fcc_offset;
+
+match_count = PCRE_ERROR_NOMATCH;   /* A negative number */
+
+active_states = (stateblock *)(workspace + 2);
+next_new_state = new_states = active_states + wscount;
+new_count = 0;
+
+first_op = this_start_code + 1 + LINK_SIZE +
+  ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA ||
+    *this_start_code == OP_CBRAPOS || *this_start_code == OP_SCBRAPOS)
+    ? IMM2_SIZE:0);
+
+/* The first thing in any (sub) pattern is a bracket of some sort. Push all
+the alternative states onto the list, and find out where the end is. This
+makes is possible to use this function recursively, when we want to stop at a
+matching internal ket rather than at the end.
+
+If the first opcode in the first alternative is OP_REVERSE, we are dealing with
+a backward assertion. In that case, we have to find out the maximum amount to
+move back, and set up each alternative appropriately. */
+
+if (*first_op == OP_REVERSE)
+  {
+  int max_back = 0;
+  int gone_back;
+
+  end_code = this_start_code;
+  do
+    {
+    int back = GET(end_code, 2+LINK_SIZE);
+    if (back > max_back) max_back = back;
+    end_code += GET(end_code, 1);
+    }
+  while (*end_code == OP_ALT);
+
+  /* If we can't go back the amount required for the longest lookbehind
+  pattern, go back as far as we can; some alternatives may still be viable. */
+
+#ifdef SUPPORT_UTF
+  /* In character mode we have to step back character by character */
+
+  if (utf)
+    {
+    for (gone_back = 0; gone_back < max_back; gone_back++)
+      {
+      if (current_subject <= start_subject) break;
+      current_subject--;
+      ACROSSCHAR(current_subject > start_subject, *current_subject, current_subject--);
+      }
+    }
+  else
+#endif
+
+  /* In byte-mode we can do this quickly. */
+
+    {
+    gone_back = (current_subject - max_back < start_subject)?
+      (int)(current_subject - start_subject) : max_back;
+    current_subject -= gone_back;
+    }
+
+  /* Save the earliest consulted character */
+
+  if (current_subject < md->start_used_ptr)
+    md->start_used_ptr = current_subject;
+
+  /* Now we can process the individual branches. */
+
+  end_code = this_start_code;
+  do
+    {
+    int back = GET(end_code, 2+LINK_SIZE);
+    if (back <= gone_back)
+      {
+      int bstate = (int)(end_code - start_code + 2 + 2*LINK_SIZE);
+      ADD_NEW_DATA(-bstate, 0, gone_back - back);
+      }
+    end_code += GET(end_code, 1);
+    }
+  while (*end_code == OP_ALT);
+ }
+
+/* This is the code for a "normal" subpattern (not a backward assertion). The
+start of a whole pattern is always one of these. If we are at the top level,
+we may be asked to restart matching from the same point that we reached for a
+previous partial match. We still have to scan through the top-level branches to
+find the end state. */
+
+else
+  {
+  end_code = this_start_code;
+
+  /* Restarting */
+
+  if (rlevel == 1 && (md->moptions & PCRE_DFA_RESTART) != 0)
+    {
+    do { end_code += GET(end_code, 1); } while (*end_code == OP_ALT);
+    new_count = workspace[1];
+    if (!workspace[0])
+      memcpy(new_states, active_states, new_count * sizeof(stateblock));
+    }
+
+  /* Not restarting */
+
+  else
+    {
+    int length = 1 + LINK_SIZE +
+      ((*this_start_code == OP_CBRA || *this_start_code == OP_SCBRA ||
+        *this_start_code == OP_CBRAPOS || *this_start_code == OP_SCBRAPOS)
+        ? IMM2_SIZE:0);
+    do
+      {
+      ADD_NEW((int)(end_code - start_code + length), 0);
+      end_code += GET(end_code, 1);
+      length = 1 + LINK_SIZE;
+      }
+    while (*end_code == OP_ALT);
+    }
+  }
+
+workspace[0] = 0;    /* Bit indicating which vector is current */
+
+DPRINTF(("%.*sEnd state = %d\n", rlevel*2-2, SP, (int)(end_code - start_code)));
+
+/* Loop for scanning the subject */
+
+ptr = current_subject;
+for (;;)
+  {
+  int i, j;
+  int clen, dlen;
+  pcre_uint32 c, d;
+  int forced_fail = 0;
+  BOOL partial_newline = FALSE;
+  BOOL could_continue = reset_could_continue;
+  reset_could_continue = FALSE;
+
+  /* Make the new state list into the active state list and empty the
+  new state list. */
+
+  temp_states = active_states;
+  active_states = new_states;
+  new_states = temp_states;
+  active_count = new_count;
+  new_count = 0;
+
+  workspace[0] ^= 1;              /* Remember for the restarting feature */
+  workspace[1] = active_count;
+
+#ifdef PCRE_DEBUG
+  printf("%.*sNext character: rest of subject = \"", rlevel*2-2, SP);
+  pchars(ptr, STRLEN_UC(ptr), stdout);
+  printf("\"\n");
+
+  printf("%.*sActive states: ", rlevel*2-2, SP);
+  for (i = 0; i < active_count; i++)
+    printf("%d/%d ", active_states[i].offset, active_states[i].count);
+  printf("\n");
+#endif
+
+  /* Set the pointers for adding new states */
+
+  next_active_state = active_states + active_count;
+  next_new_state = new_states;
+
+  /* Load the current character from the subject outside the loop, as many
+  different states may want to look at it, and we assume that at least one
+  will. */
+
+  if (ptr < end_subject)
+    {
+    clen = 1;        /* Number of data items in the character */
+#ifdef SUPPORT_UTF
+    GETCHARLENTEST(c, ptr, clen);
+#else
+    c = *ptr;
+#endif  /* SUPPORT_UTF */
+    }
+  else
+    {
+    clen = 0;        /* This indicates the end of the subject */
+    c = NOTACHAR;    /* This value should never actually be used */
+    }
+
+  /* Scan up the active states and act on each one. The result of an action
+  may be to add more states to the currently active list (e.g. on hitting a
+  parenthesis) or it may be to put states on the new list, for considering
+  when we move the character pointer on. */
+
+  for (i = 0; i < active_count; i++)
+    {
+    stateblock *current_state = active_states + i;
+    BOOL caseless = FALSE;
+    const pcre_uchar *code;
+    int state_offset = current_state->offset;
+    int codevalue, rrc;
+    int count;
+
+#ifdef PCRE_DEBUG
+    printf ("%.*sProcessing state %d c=", rlevel*2-2, SP, state_offset);
+    if (clen == 0) printf("EOL\n");
+      else if (c > 32 && c < 127) printf("'%c'\n", c);
+        else printf("0x%02x\n", c);
+#endif
+
+    /* A negative offset is a special case meaning "hold off going to this
+    (negated) state until the number of characters in the data field have
+    been skipped". If the could_continue flag was passed over from a previous
+    state, arrange for it to passed on. */
+
+    if (state_offset < 0)
+      {
+      if (current_state->data > 0)
+        {
+        DPRINTF(("%.*sSkipping this character\n", rlevel*2-2, SP));
+        ADD_NEW_DATA(state_offset, current_state->count,
+          current_state->data - 1);
+        if (could_continue) reset_could_continue = TRUE;
+        continue;
+        }
+      else
+        {
+        current_state->offset = state_offset = -state_offset;
+        }
+      }
+
+    /* Check for a duplicate state with the same count, and skip if found.
+    See the note at the head of this module about the possibility of improving
+    performance here. */
+
+    for (j = 0; j < i; j++)
+      {
+      if (active_states[j].offset == state_offset &&
+          active_states[j].count == current_state->count)
+        {
+        DPRINTF(("%.*sDuplicate state: skipped\n", rlevel*2-2, SP));
+        goto NEXT_ACTIVE_STATE;
+        }
+      }
+
+    /* The state offset is the offset to the opcode */
+
+    code = start_code + state_offset;
+    codevalue = *code;
+
+    /* If this opcode inspects a character, but we are at the end of the
+    subject, remember the fact for use when testing for a partial match. */
+
+    if (clen == 0 && poptable[codevalue] != 0)
+      could_continue = TRUE;
+
+    /* If this opcode is followed by an inline character, load it. It is
+    tempting to test for the presence of a subject character here, but that
+    is wrong, because sometimes zero repetitions of the subject are
+    permitted.
+
+    We also use this mechanism for opcodes such as OP_TYPEPLUS that take an
+    argument that is not a data character - but is always one byte long because
+    the values are small. We have to take special action to deal with  \P, \p,
+    \H, \h, \V, \v and \X in this case. To keep the other cases fast, convert
+    these ones to new opcodes. */
+
+    if (coptable[codevalue] > 0)
+      {
+      dlen = 1;
+#ifdef SUPPORT_UTF
+      if (utf) { GETCHARLEN(d, (code + coptable[codevalue]), dlen); } else
+#endif  /* SUPPORT_UTF */
+      d = code[coptable[codevalue]];
+      if (codevalue >= OP_TYPESTAR)
+        {
+        switch(d)
+          {
+          case OP_ANYBYTE: return PCRE_ERROR_DFA_UITEM;
+          case OP_NOTPROP:
+          case OP_PROP: codevalue += OP_PROP_EXTRA; break;
+          case OP_ANYNL: codevalue += OP_ANYNL_EXTRA; break;
+          case OP_EXTUNI: codevalue += OP_EXTUNI_EXTRA; break;
+          case OP_NOT_HSPACE:
+          case OP_HSPACE: codevalue += OP_HSPACE_EXTRA; break;
+          case OP_NOT_VSPACE:
+          case OP_VSPACE: codevalue += OP_VSPACE_EXTRA; break;
+          default: break;
+          }
+        }
+      }
+    else
+      {
+      dlen = 0;         /* Not strictly necessary, but compilers moan */
+      d = NOTACHAR;     /* if these variables are not set. */
+      }
+
+
+    /* Now process the individual opcodes */
+
+    switch (codevalue)
+      {
+/* ========================================================================== */
+      /* These cases are never obeyed. This is a fudge that causes a compile-
+      time error if the vectors coptable or poptable, which are indexed by
+      opcode, are not the correct length. It seems to be the only way to do
+      such a check at compile time, as the sizeof() operator does not work
+      in the C preprocessor. */
+
+      case OP_TABLE_LENGTH:
+      case OP_TABLE_LENGTH +
+        ((sizeof(coptable) == OP_TABLE_LENGTH) &&
+         (sizeof(poptable) == OP_TABLE_LENGTH)):
+      break;
+
+/* ========================================================================== */
+      /* Reached a closing bracket. If not at the end of the pattern, carry
+      on with the next opcode. For repeating opcodes, also add the repeat
+      state. Note that KETRPOS will always be encountered at the end of the
+      subpattern, because the possessive subpattern repeats are always handled
+      using recursive calls. Thus, it never adds any new states.
+
+      At the end of the (sub)pattern, unless we have an empty string and
+      PCRE_NOTEMPTY is set, or PCRE_NOTEMPTY_ATSTART is set and we are at the
+      start of the subject, save the match data, shifting up all previous
+      matches so we always have the longest first. */
+
+      case OP_KET:
+      case OP_KETRMIN:
+      case OP_KETRMAX:
+      case OP_KETRPOS:
+      if (code != end_code)
+        {
+        ADD_ACTIVE(state_offset + 1 + LINK_SIZE, 0);
+        if (codevalue != OP_KET)
+          {
+          ADD_ACTIVE(state_offset - GET(code, 1), 0);
+          }
+        }
+      else
+        {
+        if (ptr > current_subject ||
+            ((md->moptions & PCRE_NOTEMPTY) == 0 &&
+              ((md->moptions & PCRE_NOTEMPTY_ATSTART) == 0 ||
+                current_subject > start_subject + md->start_offset)))
+          {
+          if (match_count < 0) match_count = (offsetcount >= 2)? 1 : 0;
+            else if (match_count > 0 && ++match_count * 2 > offsetcount)
+              match_count = 0;
+          count = ((match_count == 0)? offsetcount : match_count * 2) - 2;
+          if (count > 0) memmove(offsets + 2, offsets, count * sizeof(int));
+          if (offsetcount >= 2)
+            {
+            offsets[0] = (int)(current_subject - start_subject);
+            offsets[1] = (int)(ptr - start_subject);
+            DPRINTF(("%.*sSet matched string = \"%.*s\"\n", rlevel*2-2, SP,
+              offsets[1] - offsets[0], (char *)current_subject));
+            }
+          if ((md->moptions & PCRE_DFA_SHORTEST) != 0)
+            {
+            DPRINTF(("%.*sEnd of internal_dfa_exec %d: returning %d\n"
+              "%.*s---------------------\n\n", rlevel*2-2, SP, rlevel,
+              match_count, rlevel*2-2, SP));
+            return match_count;
+            }
+          }
+        }
+      break;
+
+/* ========================================================================== */
+      /* These opcodes add to the current list of states without looking
+      at the current character. */
+
+      /*-----------------------------------------------------------------*/
+      case OP_ALT:
+      do { code += GET(code, 1); } while (*code == OP_ALT);
+      ADD_ACTIVE((int)(code - start_code), 0);
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_BRA:
+      case OP_SBRA:
+      do
+        {
+        ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0);
+        code += GET(code, 1);
+        }
+      while (*code == OP_ALT);
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_CBRA:
+      case OP_SCBRA:
+      ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE + IMM2_SIZE),  0);
+      code += GET(code, 1);
+      while (*code == OP_ALT)
+        {
+        ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE),  0);
+        code += GET(code, 1);
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_BRAZERO:
+      case OP_BRAMINZERO:
+      ADD_ACTIVE(state_offset + 1, 0);
+      code += 1 + GET(code, 2);
+      while (*code == OP_ALT) code += GET(code, 1);
+      ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0);
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_SKIPZERO:
+      code += 1 + GET(code, 2);
+      while (*code == OP_ALT) code += GET(code, 1);
+      ADD_ACTIVE((int)(code - start_code + 1 + LINK_SIZE), 0);
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_CIRC:
+      if (ptr == start_subject && (md->moptions & PCRE_NOTBOL) == 0)
+        { ADD_ACTIVE(state_offset + 1, 0); }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_CIRCM:
+      if ((ptr == start_subject && (md->moptions & PCRE_NOTBOL) == 0) ||
+          (ptr != end_subject && WAS_NEWLINE(ptr)))
+        { ADD_ACTIVE(state_offset + 1, 0); }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_EOD:
+      if (ptr >= end_subject)
+        {
+        if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
+          could_continue = TRUE;
+        else { ADD_ACTIVE(state_offset + 1, 0); }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_SOD:
+      if (ptr == start_subject) { ADD_ACTIVE(state_offset + 1, 0); }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_SOM:
+      if (ptr == start_subject + start_offset) { ADD_ACTIVE(state_offset + 1, 0); }
+      break;
+
+
+/* ========================================================================== */
+      /* These opcodes inspect the next subject character, and sometimes
+      the previous one as well, but do not have an argument. The variable
+      clen contains the length of the current character and is zero if we are
+      at the end of the subject. */
+
+      /*-----------------------------------------------------------------*/
+      case OP_ANY:
+      if (clen > 0 && !IS_NEWLINE(ptr))
+        {
+        if (ptr + 1 >= md->end_subject &&
+            (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
+            NLBLOCK->nltype == NLTYPE_FIXED &&
+            NLBLOCK->nllen == 2 &&
+            c == NLBLOCK->nl[0])
+          {
+          could_continue = partial_newline = TRUE;
+          }
+        else
+          {
+          ADD_NEW(state_offset + 1, 0);
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_ALLANY:
+      if (clen > 0)
+        { ADD_NEW(state_offset + 1, 0); }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_EODN:
+      if (clen == 0 && (md->moptions & PCRE_PARTIAL_HARD) != 0)
+        could_continue = TRUE;
+      else if (clen == 0 || (IS_NEWLINE(ptr) && ptr == end_subject - md->nllen))
+        { ADD_ACTIVE(state_offset + 1, 0); }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_DOLL:
+      if ((md->moptions & PCRE_NOTEOL) == 0)
+        {
+        if (clen == 0 && (md->moptions & PCRE_PARTIAL_HARD) != 0)
+          could_continue = TRUE;
+        else if (clen == 0 ||
+            ((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr) &&
+               (ptr == end_subject - md->nllen)
+            ))
+          { ADD_ACTIVE(state_offset + 1, 0); }
+        else if (ptr + 1 >= md->end_subject &&
+                 (md->moptions & (PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT)) != 0 &&
+                 NLBLOCK->nltype == NLTYPE_FIXED &&
+                 NLBLOCK->nllen == 2 &&
+                 c == NLBLOCK->nl[0])
+          {
+          if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
+            {
+            reset_could_continue = TRUE;
+            ADD_NEW_DATA(-(state_offset + 1), 0, 1);
+            }
+          else could_continue = partial_newline = TRUE;
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_DOLLM:
+      if ((md->moptions & PCRE_NOTEOL) == 0)
+        {
+        if (clen == 0 && (md->moptions & PCRE_PARTIAL_HARD) != 0)
+          could_continue = TRUE;
+        else if (clen == 0 ||
+            ((md->poptions & PCRE_DOLLAR_ENDONLY) == 0 && IS_NEWLINE(ptr)))
+          { ADD_ACTIVE(state_offset + 1, 0); }
+        else if (ptr + 1 >= md->end_subject &&
+                 (md->moptions & (PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT)) != 0 &&
+                 NLBLOCK->nltype == NLTYPE_FIXED &&
+                 NLBLOCK->nllen == 2 &&
+                 c == NLBLOCK->nl[0])
+          {
+          if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
+            {
+            reset_could_continue = TRUE;
+            ADD_NEW_DATA(-(state_offset + 1), 0, 1);
+            }
+          else could_continue = partial_newline = TRUE;
+          }
+        }
+      else if (IS_NEWLINE(ptr))
+        { ADD_ACTIVE(state_offset + 1, 0); }
+      break;
+
+      /*-----------------------------------------------------------------*/
+
+      case OP_DIGIT:
+      case OP_WHITESPACE:
+      case OP_WORDCHAR:
+      if (clen > 0 && c < 256 &&
+            ((ctypes[c] & toptable1[codevalue]) ^ toptable2[codevalue]) != 0)
+        { ADD_NEW(state_offset + 1, 0); }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_NOT_DIGIT:
+      case OP_NOT_WHITESPACE:
+      case OP_NOT_WORDCHAR:
+      if (clen > 0 && (c >= 256 ||
+            ((ctypes[c] & toptable1[codevalue]) ^ toptable2[codevalue]) != 0))
+        { ADD_NEW(state_offset + 1, 0); }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_WORD_BOUNDARY:
+      case OP_NOT_WORD_BOUNDARY:
+        {
+        int left_word, right_word;
+
+        if (ptr > start_subject)
+          {
+          const pcre_uchar *temp = ptr - 1;
+          if (temp < md->start_used_ptr) md->start_used_ptr = temp;
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+          if (utf) { BACKCHAR(temp); }
+#endif
+          GETCHARTEST(d, temp);
+#ifdef SUPPORT_UCP
+          if ((md->poptions & PCRE_UCP) != 0)
+            {
+            if (d == '_') left_word = TRUE; else
+              {
+              int cat = UCD_CATEGORY(d);
+              left_word = (cat == ucp_L || cat == ucp_N);
+              }
+            }
+          else
+#endif
+          left_word = d < 256 && (ctypes[d] & ctype_word) != 0;
+          }
+        else left_word = FALSE;
+
+        if (clen > 0)
+          {
+#ifdef SUPPORT_UCP
+          if ((md->poptions & PCRE_UCP) != 0)
+            {
+            if (c == '_') right_word = TRUE; else
+              {
+              int cat = UCD_CATEGORY(c);
+              right_word = (cat == ucp_L || cat == ucp_N);
+              }
+            }
+          else
+#endif
+          right_word = c < 256 && (ctypes[c] & ctype_word) != 0;
+          }
+        else right_word = FALSE;
+
+        if ((left_word == right_word) == (codevalue == OP_NOT_WORD_BOUNDARY))
+          { ADD_ACTIVE(state_offset + 1, 0); }
+        }
+      break;
+
+
+      /*-----------------------------------------------------------------*/
+      /* Check the next character by Unicode property. We will get here only
+      if the support is in the binary; otherwise a compile-time error occurs.
+      */
+
+#ifdef SUPPORT_UCP
+      case OP_PROP:
+      case OP_NOTPROP:
+      if (clen > 0)
+        {
+        BOOL OK;
+        const pcre_uint32 *cp;
+        const ucd_record * prop = GET_UCD(c);
+        switch(code[1])
+          {
+          case PT_ANY:
+          OK = TRUE;
+          break;
+
+          case PT_LAMP:
+          OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
+               prop->chartype == ucp_Lt;
+          break;
+
+          case PT_GC:
+          OK = PRIV(ucp_gentype)[prop->chartype] == code[2];
+          break;
+
+          case PT_PC:
+          OK = prop->chartype == code[2];
+          break;
+
+          case PT_SC:
+          OK = prop->script == code[2];
+          break;
+
+          /* These are specials for combination cases. */
+
+          case PT_ALNUM:
+          OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
+               PRIV(ucp_gentype)[prop->chartype] == ucp_N;
+          break;
+
+          /* Perl space used to exclude VT, but from Perl 5.18 it is included,
+          which means that Perl space and POSIX space are now identical. PCRE
+          was changed at release 8.34. */
+
+          case PT_SPACE:    /* Perl space */
+          case PT_PXSPACE:  /* POSIX space */
+          switch(c)
+            {
+            HSPACE_CASES:
+            VSPACE_CASES:
+            OK = TRUE;
+            break;
+
+            default:
+            OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z;
+            break;
+            }
+          break;
+
+          case PT_WORD:
+          OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
+               PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
+               c == CHAR_UNDERSCORE;
+          break;
+
+          case PT_CLIST:
+          cp = PRIV(ucd_caseless_sets) + code[2];
+          for (;;)
+            {
+            if (c < *cp) { OK = FALSE; break; }
+            if (c == *cp++) { OK = TRUE; break; }
+            }
+          break;
+
+          case PT_UCNC:
+          OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
+               c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
+               c >= 0xe000;
+          break;
+
+          /* Should never occur, but keep compilers from grumbling. */
+
+          default:
+          OK = codevalue != OP_PROP;
+          break;
+          }
+
+        if (OK == (codevalue == OP_PROP)) { ADD_NEW(state_offset + 3, 0); }
+        }
+      break;
+#endif
+
+
+
+/* ========================================================================== */
+      /* These opcodes likewise inspect the subject character, but have an
+      argument that is not a data character. It is one of these opcodes:
+      OP_ANY, OP_ALLANY, OP_DIGIT, OP_NOT_DIGIT, OP_WHITESPACE, OP_NOT_SPACE,
+      OP_WORDCHAR, OP_NOT_WORDCHAR. The value is loaded into d. */
+
+      case OP_TYPEPLUS:
+      case OP_TYPEMINPLUS:
+      case OP_TYPEPOSPLUS:
+      count = current_state->count;  /* Already matched */
+      if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
+      if (clen > 0)
+        {
+        if (d == OP_ANY && ptr + 1 >= md->end_subject &&
+            (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
+            NLBLOCK->nltype == NLTYPE_FIXED &&
+            NLBLOCK->nllen == 2 &&
+            c == NLBLOCK->nl[0])
+          {
+          could_continue = partial_newline = TRUE;
+          }
+        else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
+            (c < 256 &&
+              (d != OP_ANY || !IS_NEWLINE(ptr)) &&
+              ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
+          {
+          if (count > 0 && codevalue == OP_TYPEPOSPLUS)
+            {
+            active_count--;            /* Remove non-match possibility */
+            next_active_state--;
+            }
+          count++;
+          ADD_NEW(state_offset, count);
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_TYPEQUERY:
+      case OP_TYPEMINQUERY:
+      case OP_TYPEPOSQUERY:
+      ADD_ACTIVE(state_offset + 2, 0);
+      if (clen > 0)
+        {
+        if (d == OP_ANY && ptr + 1 >= md->end_subject &&
+            (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
+            NLBLOCK->nltype == NLTYPE_FIXED &&
+            NLBLOCK->nllen == 2 &&
+            c == NLBLOCK->nl[0])
+          {
+          could_continue = partial_newline = TRUE;
+          }
+        else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
+            (c < 256 &&
+              (d != OP_ANY || !IS_NEWLINE(ptr)) &&
+              ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
+          {
+          if (codevalue == OP_TYPEPOSQUERY)
+            {
+            active_count--;            /* Remove non-match possibility */
+            next_active_state--;
+            }
+          ADD_NEW(state_offset + 2, 0);
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_TYPESTAR:
+      case OP_TYPEMINSTAR:
+      case OP_TYPEPOSSTAR:
+      ADD_ACTIVE(state_offset + 2, 0);
+      if (clen > 0)
+        {
+        if (d == OP_ANY && ptr + 1 >= md->end_subject &&
+            (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
+            NLBLOCK->nltype == NLTYPE_FIXED &&
+            NLBLOCK->nllen == 2 &&
+            c == NLBLOCK->nl[0])
+          {
+          could_continue = partial_newline = TRUE;
+          }
+        else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
+            (c < 256 &&
+              (d != OP_ANY || !IS_NEWLINE(ptr)) &&
+              ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
+          {
+          if (codevalue == OP_TYPEPOSSTAR)
+            {
+            active_count--;            /* Remove non-match possibility */
+            next_active_state--;
+            }
+          ADD_NEW(state_offset, 0);
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_TYPEEXACT:
+      count = current_state->count;  /* Number already matched */
+      if (clen > 0)
+        {
+        if (d == OP_ANY && ptr + 1 >= md->end_subject &&
+            (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
+            NLBLOCK->nltype == NLTYPE_FIXED &&
+            NLBLOCK->nllen == 2 &&
+            c == NLBLOCK->nl[0])
+          {
+          could_continue = partial_newline = TRUE;
+          }
+        else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
+            (c < 256 &&
+              (d != OP_ANY || !IS_NEWLINE(ptr)) &&
+              ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
+          {
+          if (++count >= (int)GET2(code, 1))
+            { ADD_NEW(state_offset + 1 + IMM2_SIZE + 1, 0); }
+          else
+            { ADD_NEW(state_offset, count); }
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_TYPEUPTO:
+      case OP_TYPEMINUPTO:
+      case OP_TYPEPOSUPTO:
+      ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0);
+      count = current_state->count;  /* Number already matched */
+      if (clen > 0)
+        {
+        if (d == OP_ANY && ptr + 1 >= md->end_subject &&
+            (md->moptions & (PCRE_PARTIAL_HARD)) != 0 &&
+            NLBLOCK->nltype == NLTYPE_FIXED &&
+            NLBLOCK->nllen == 2 &&
+            c == NLBLOCK->nl[0])
+          {
+          could_continue = partial_newline = TRUE;
+          }
+        else if ((c >= 256 && d != OP_DIGIT && d != OP_WHITESPACE && d != OP_WORDCHAR) ||
+            (c < 256 &&
+              (d != OP_ANY || !IS_NEWLINE(ptr)) &&
+              ((ctypes[c] & toptable1[d]) ^ toptable2[d]) != 0))
+          {
+          if (codevalue == OP_TYPEPOSUPTO)
+            {
+            active_count--;           /* Remove non-match possibility */
+            next_active_state--;
+            }
+          if (++count >= (int)GET2(code, 1))
+            { ADD_NEW(state_offset + 2 + IMM2_SIZE, 0); }
+          else
+            { ADD_NEW(state_offset, count); }
+          }
+        }
+      break;
+
+/* ========================================================================== */
+      /* These are virtual opcodes that are used when something like
+      OP_TYPEPLUS has OP_PROP, OP_NOTPROP, OP_ANYNL, or OP_EXTUNI as its
+      argument. It keeps the code above fast for the other cases. The argument
+      is in the d variable. */
+
+#ifdef SUPPORT_UCP
+      case OP_PROP_EXTRA + OP_TYPEPLUS:
+      case OP_PROP_EXTRA + OP_TYPEMINPLUS:
+      case OP_PROP_EXTRA + OP_TYPEPOSPLUS:
+      count = current_state->count;           /* Already matched */
+      if (count > 0) { ADD_ACTIVE(state_offset + 4, 0); }
+      if (clen > 0)
+        {
+        BOOL OK;
+        const pcre_uint32 *cp;
+        const ucd_record * prop = GET_UCD(c);
+        switch(code[2])
+          {
+          case PT_ANY:
+          OK = TRUE;
+          break;
+
+          case PT_LAMP:
+          OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
+            prop->chartype == ucp_Lt;
+          break;
+
+          case PT_GC:
+          OK = PRIV(ucp_gentype)[prop->chartype] == code[3];
+          break;
+
+          case PT_PC:
+          OK = prop->chartype == code[3];
+          break;
+
+          case PT_SC:
+          OK = prop->script == code[3];
+          break;
+
+          /* These are specials for combination cases. */
+
+          case PT_ALNUM:
+          OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
+               PRIV(ucp_gentype)[prop->chartype] == ucp_N;
+          break;
+
+          /* Perl space used to exclude VT, but from Perl 5.18 it is included,
+          which means that Perl space and POSIX space are now identical. PCRE
+          was changed at release 8.34. */
+
+          case PT_SPACE:    /* Perl space */
+          case PT_PXSPACE:  /* POSIX space */
+          switch(c)
+            {
+            HSPACE_CASES:
+            VSPACE_CASES:
+            OK = TRUE;
+            break;
+
+            default:
+            OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z;
+            break;
+            }
+          break;
+
+          case PT_WORD:
+          OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
+               PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
+               c == CHAR_UNDERSCORE;
+          break;
+
+          case PT_CLIST:
+          cp = PRIV(ucd_caseless_sets) + code[3];
+          for (;;)
+            {
+            if (c < *cp) { OK = FALSE; break; }
+            if (c == *cp++) { OK = TRUE; break; }
+            }
+          break;
+
+          case PT_UCNC:
+          OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
+               c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
+               c >= 0xe000;
+          break;
+
+          /* Should never occur, but keep compilers from grumbling. */
+
+          default:
+          OK = codevalue != OP_PROP;
+          break;
+          }
+
+        if (OK == (d == OP_PROP))
+          {
+          if (count > 0 && codevalue == OP_PROP_EXTRA + OP_TYPEPOSPLUS)
+            {
+            active_count--;           /* Remove non-match possibility */
+            next_active_state--;
+            }
+          count++;
+          ADD_NEW(state_offset, count);
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_EXTUNI_EXTRA + OP_TYPEPLUS:
+      case OP_EXTUNI_EXTRA + OP_TYPEMINPLUS:
+      case OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS:
+      count = current_state->count;  /* Already matched */
+      if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
+      if (clen > 0)
+        {
+        int lgb, rgb;
+        const pcre_uchar *nptr = ptr + clen;
+        int ncount = 0;
+        if (count > 0 && codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSPLUS)
+          {
+          active_count--;           /* Remove non-match possibility */
+          next_active_state--;
+          }
+        lgb = UCD_GRAPHBREAK(c);
+        while (nptr < end_subject)
+          {
+          dlen = 1;
+          if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }
+          rgb = UCD_GRAPHBREAK(d);
+          if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
+          ncount++;
+          lgb = rgb;
+          nptr += dlen;
+          }
+        count++;
+        ADD_NEW_DATA(-state_offset, count, ncount);
+        }
+      break;
+#endif
+
+      /*-----------------------------------------------------------------*/
+      case OP_ANYNL_EXTRA + OP_TYPEPLUS:
+      case OP_ANYNL_EXTRA + OP_TYPEMINPLUS:
+      case OP_ANYNL_EXTRA + OP_TYPEPOSPLUS:
+      count = current_state->count;  /* Already matched */
+      if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
+      if (clen > 0)
+        {
+        int ncount = 0;
+        switch (c)
+          {
+          case CHAR_VT:
+          case CHAR_FF:
+          case CHAR_NEL:
+#ifndef EBCDIC
+          case 0x2028:
+          case 0x2029:
+#endif  /* Not EBCDIC */
+          if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
+          goto ANYNL01;
+
+          case CHAR_CR:
+          if (ptr + 1 < end_subject && UCHAR21TEST(ptr + 1) == CHAR_LF) ncount = 1;
+          /* Fall through */
+
+          ANYNL01:
+          case CHAR_LF:
+          if (count > 0 && codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSPLUS)
+            {
+            active_count--;           /* Remove non-match possibility */
+            next_active_state--;
+            }
+          count++;
+          ADD_NEW_DATA(-state_offset, count, ncount);
+          break;
+
+          default:
+          break;
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_VSPACE_EXTRA + OP_TYPEPLUS:
+      case OP_VSPACE_EXTRA + OP_TYPEMINPLUS:
+      case OP_VSPACE_EXTRA + OP_TYPEPOSPLUS:
+      count = current_state->count;  /* Already matched */
+      if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
+      if (clen > 0)
+        {
+        BOOL OK;
+        switch (c)
+          {
+          VSPACE_CASES:
+          OK = TRUE;
+          break;
+
+          default:
+          OK = FALSE;
+          break;
+          }
+
+        if (OK == (d == OP_VSPACE))
+          {
+          if (count > 0 && codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSPLUS)
+            {
+            active_count--;           /* Remove non-match possibility */
+            next_active_state--;
+            }
+          count++;
+          ADD_NEW_DATA(-state_offset, count, 0);
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_HSPACE_EXTRA + OP_TYPEPLUS:
+      case OP_HSPACE_EXTRA + OP_TYPEMINPLUS:
+      case OP_HSPACE_EXTRA + OP_TYPEPOSPLUS:
+      count = current_state->count;  /* Already matched */
+      if (count > 0) { ADD_ACTIVE(state_offset + 2, 0); }
+      if (clen > 0)
+        {
+        BOOL OK;
+        switch (c)
+          {
+          HSPACE_CASES:
+          OK = TRUE;
+          break;
+
+          default:
+          OK = FALSE;
+          break;
+          }
+
+        if (OK == (d == OP_HSPACE))
+          {
+          if (count > 0 && codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSPLUS)
+            {
+            active_count--;           /* Remove non-match possibility */
+            next_active_state--;
+            }
+          count++;
+          ADD_NEW_DATA(-state_offset, count, 0);
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+#ifdef SUPPORT_UCP
+      case OP_PROP_EXTRA + OP_TYPEQUERY:
+      case OP_PROP_EXTRA + OP_TYPEMINQUERY:
+      case OP_PROP_EXTRA + OP_TYPEPOSQUERY:
+      count = 4;
+      goto QS1;
+
+      case OP_PROP_EXTRA + OP_TYPESTAR:
+      case OP_PROP_EXTRA + OP_TYPEMINSTAR:
+      case OP_PROP_EXTRA + OP_TYPEPOSSTAR:
+      count = 0;
+
+      QS1:
+
+      ADD_ACTIVE(state_offset + 4, 0);
+      if (clen > 0)
+        {
+        BOOL OK;
+        const pcre_uint32 *cp;
+        const ucd_record * prop = GET_UCD(c);
+        switch(code[2])
+          {
+          case PT_ANY:
+          OK = TRUE;
+          break;
+
+          case PT_LAMP:
+          OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
+            prop->chartype == ucp_Lt;
+          break;
+
+          case PT_GC:
+          OK = PRIV(ucp_gentype)[prop->chartype] == code[3];
+          break;
+
+          case PT_PC:
+          OK = prop->chartype == code[3];
+          break;
+
+          case PT_SC:
+          OK = prop->script == code[3];
+          break;
+
+          /* These are specials for combination cases. */
+
+          case PT_ALNUM:
+          OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
+               PRIV(ucp_gentype)[prop->chartype] == ucp_N;
+          break;
+
+          /* Perl space used to exclude VT, but from Perl 5.18 it is included,
+          which means that Perl space and POSIX space are now identical. PCRE
+          was changed at release 8.34. */
+
+          case PT_SPACE:    /* Perl space */
+          case PT_PXSPACE:  /* POSIX space */
+          switch(c)
+            {
+            HSPACE_CASES:
+            VSPACE_CASES:
+            OK = TRUE;
+            break;
+
+            default:
+            OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z;
+            break;
+            }
+          break;
+
+          case PT_WORD:
+          OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
+               PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
+               c == CHAR_UNDERSCORE;
+          break;
+
+          case PT_CLIST:
+          cp = PRIV(ucd_caseless_sets) + code[3];
+          for (;;)
+            {
+            if (c < *cp) { OK = FALSE; break; }
+            if (c == *cp++) { OK = TRUE; break; }
+            }
+          break;
+
+          case PT_UCNC:
+          OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
+               c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
+               c >= 0xe000;
+          break;
+
+          /* Should never occur, but keep compilers from grumbling. */
+
+          default:
+          OK = codevalue != OP_PROP;
+          break;
+          }
+
+        if (OK == (d == OP_PROP))
+          {
+          if (codevalue == OP_PROP_EXTRA + OP_TYPEPOSSTAR ||
+              codevalue == OP_PROP_EXTRA + OP_TYPEPOSQUERY)
+            {
+            active_count--;           /* Remove non-match possibility */
+            next_active_state--;
+            }
+          ADD_NEW(state_offset + count, 0);
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_EXTUNI_EXTRA + OP_TYPEQUERY:
+      case OP_EXTUNI_EXTRA + OP_TYPEMINQUERY:
+      case OP_EXTUNI_EXTRA + OP_TYPEPOSQUERY:
+      count = 2;
+      goto QS2;
+
+      case OP_EXTUNI_EXTRA + OP_TYPESTAR:
+      case OP_EXTUNI_EXTRA + OP_TYPEMINSTAR:
+      case OP_EXTUNI_EXTRA + OP_TYPEPOSSTAR:
+      count = 0;
+
+      QS2:
+
+      ADD_ACTIVE(state_offset + 2, 0);
+      if (clen > 0)
+        {
+        int lgb, rgb;
+        const pcre_uchar *nptr = ptr + clen;
+        int ncount = 0;
+        if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSSTAR ||
+            codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSQUERY)
+          {
+          active_count--;           /* Remove non-match possibility */
+          next_active_state--;
+          }
+        lgb = UCD_GRAPHBREAK(c);
+        while (nptr < end_subject)
+          {
+          dlen = 1;
+          if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }
+          rgb = UCD_GRAPHBREAK(d);
+          if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
+          ncount++;
+          lgb = rgb;
+          nptr += dlen;
+          }
+        ADD_NEW_DATA(-(state_offset + count), 0, ncount);
+        }
+      break;
+#endif
+
+      /*-----------------------------------------------------------------*/
+      case OP_ANYNL_EXTRA + OP_TYPEQUERY:
+      case OP_ANYNL_EXTRA + OP_TYPEMINQUERY:
+      case OP_ANYNL_EXTRA + OP_TYPEPOSQUERY:
+      count = 2;
+      goto QS3;
+
+      case OP_ANYNL_EXTRA + OP_TYPESTAR:
+      case OP_ANYNL_EXTRA + OP_TYPEMINSTAR:
+      case OP_ANYNL_EXTRA + OP_TYPEPOSSTAR:
+      count = 0;
+
+      QS3:
+      ADD_ACTIVE(state_offset + 2, 0);
+      if (clen > 0)
+        {
+        int ncount = 0;
+        switch (c)
+          {
+          case CHAR_VT:
+          case CHAR_FF:
+          case CHAR_NEL:
+#ifndef EBCDIC
+          case 0x2028:
+          case 0x2029:
+#endif  /* Not EBCDIC */
+          if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
+          goto ANYNL02;
+
+          case CHAR_CR:
+          if (ptr + 1 < end_subject && UCHAR21TEST(ptr + 1) == CHAR_LF) ncount = 1;
+          /* Fall through */
+
+          ANYNL02:
+          case CHAR_LF:
+          if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSSTAR ||
+              codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSQUERY)
+            {
+            active_count--;           /* Remove non-match possibility */
+            next_active_state--;
+            }
+          ADD_NEW_DATA(-(state_offset + (int)count), 0, ncount);
+          break;
+
+          default:
+          break;
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_VSPACE_EXTRA + OP_TYPEQUERY:
+      case OP_VSPACE_EXTRA + OP_TYPEMINQUERY:
+      case OP_VSPACE_EXTRA + OP_TYPEPOSQUERY:
+      count = 2;
+      goto QS4;
+
+      case OP_VSPACE_EXTRA + OP_TYPESTAR:
+      case OP_VSPACE_EXTRA + OP_TYPEMINSTAR:
+      case OP_VSPACE_EXTRA + OP_TYPEPOSSTAR:
+      count = 0;
+
+      QS4:
+      ADD_ACTIVE(state_offset + 2, 0);
+      if (clen > 0)
+        {
+        BOOL OK;
+        switch (c)
+          {
+          VSPACE_CASES:
+          OK = TRUE;
+          break;
+
+          default:
+          OK = FALSE;
+          break;
+          }
+        if (OK == (d == OP_VSPACE))
+          {
+          if (codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSSTAR ||
+              codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSQUERY)
+            {
+            active_count--;           /* Remove non-match possibility */
+            next_active_state--;
+            }
+          ADD_NEW_DATA(-(state_offset + (int)count), 0, 0);
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_HSPACE_EXTRA + OP_TYPEQUERY:
+      case OP_HSPACE_EXTRA + OP_TYPEMINQUERY:
+      case OP_HSPACE_EXTRA + OP_TYPEPOSQUERY:
+      count = 2;
+      goto QS5;
+
+      case OP_HSPACE_EXTRA + OP_TYPESTAR:
+      case OP_HSPACE_EXTRA + OP_TYPEMINSTAR:
+      case OP_HSPACE_EXTRA + OP_TYPEPOSSTAR:
+      count = 0;
+
+      QS5:
+      ADD_ACTIVE(state_offset + 2, 0);
+      if (clen > 0)
+        {
+        BOOL OK;
+        switch (c)
+          {
+          HSPACE_CASES:
+          OK = TRUE;
+          break;
+
+          default:
+          OK = FALSE;
+          break;
+          }
+
+        if (OK == (d == OP_HSPACE))
+          {
+          if (codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSSTAR ||
+              codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSQUERY)
+            {
+            active_count--;           /* Remove non-match possibility */
+            next_active_state--;
+            }
+          ADD_NEW_DATA(-(state_offset + (int)count), 0, 0);
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+#ifdef SUPPORT_UCP
+      case OP_PROP_EXTRA + OP_TYPEEXACT:
+      case OP_PROP_EXTRA + OP_TYPEUPTO:
+      case OP_PROP_EXTRA + OP_TYPEMINUPTO:
+      case OP_PROP_EXTRA + OP_TYPEPOSUPTO:
+      if (codevalue != OP_PROP_EXTRA + OP_TYPEEXACT)
+        { ADD_ACTIVE(state_offset + 1 + IMM2_SIZE + 3, 0); }
+      count = current_state->count;  /* Number already matched */
+      if (clen > 0)
+        {
+        BOOL OK;
+        const pcre_uint32 *cp;
+        const ucd_record * prop = GET_UCD(c);
+        switch(code[1 + IMM2_SIZE + 1])
+          {
+          case PT_ANY:
+          OK = TRUE;
+          break;
+
+          case PT_LAMP:
+          OK = prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
+            prop->chartype == ucp_Lt;
+          break;
+
+          case PT_GC:
+          OK = PRIV(ucp_gentype)[prop->chartype] == code[1 + IMM2_SIZE + 2];
+          break;
+
+          case PT_PC:
+          OK = prop->chartype == code[1 + IMM2_SIZE + 2];
+          break;
+
+          case PT_SC:
+          OK = prop->script == code[1 + IMM2_SIZE + 2];
+          break;
+
+          /* These are specials for combination cases. */
+
+          case PT_ALNUM:
+          OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
+               PRIV(ucp_gentype)[prop->chartype] == ucp_N;
+          break;
+
+          /* Perl space used to exclude VT, but from Perl 5.18 it is included,
+          which means that Perl space and POSIX space are now identical. PCRE
+          was changed at release 8.34. */
+
+          case PT_SPACE:    /* Perl space */
+          case PT_PXSPACE:  /* POSIX space */
+          switch(c)
+            {
+            HSPACE_CASES:
+            VSPACE_CASES:
+            OK = TRUE;
+            break;
+
+            default:
+            OK = PRIV(ucp_gentype)[prop->chartype] == ucp_Z;
+            break;
+            }
+          break;
+
+          case PT_WORD:
+          OK = PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
+               PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
+               c == CHAR_UNDERSCORE;
+          break;
+
+          case PT_CLIST:
+          cp = PRIV(ucd_caseless_sets) + code[1 + IMM2_SIZE + 2];
+          for (;;)
+            {
+            if (c < *cp) { OK = FALSE; break; }
+            if (c == *cp++) { OK = TRUE; break; }
+            }
+          break;
+
+          case PT_UCNC:
+          OK = c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
+               c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
+               c >= 0xe000;
+          break;
+
+          /* Should never occur, but keep compilers from grumbling. */
+
+          default:
+          OK = codevalue != OP_PROP;
+          break;
+          }
+
+        if (OK == (d == OP_PROP))
+          {
+          if (codevalue == OP_PROP_EXTRA + OP_TYPEPOSUPTO)
+            {
+            active_count--;           /* Remove non-match possibility */
+            next_active_state--;
+            }
+          if (++count >= (int)GET2(code, 1))
+            { ADD_NEW(state_offset + 1 + IMM2_SIZE + 3, 0); }
+          else
+            { ADD_NEW(state_offset, count); }
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_EXTUNI_EXTRA + OP_TYPEEXACT:
+      case OP_EXTUNI_EXTRA + OP_TYPEUPTO:
+      case OP_EXTUNI_EXTRA + OP_TYPEMINUPTO:
+      case OP_EXTUNI_EXTRA + OP_TYPEPOSUPTO:
+      if (codevalue != OP_EXTUNI_EXTRA + OP_TYPEEXACT)
+        { ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); }
+      count = current_state->count;  /* Number already matched */
+      if (clen > 0)
+        {
+        int lgb, rgb;
+        const pcre_uchar *nptr = ptr + clen;
+        int ncount = 0;
+        if (codevalue == OP_EXTUNI_EXTRA + OP_TYPEPOSUPTO)
+          {
+          active_count--;           /* Remove non-match possibility */
+          next_active_state--;
+          }
+        lgb = UCD_GRAPHBREAK(c);
+        while (nptr < end_subject)
+          {
+          dlen = 1;
+          if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }
+          rgb = UCD_GRAPHBREAK(d);
+          if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
+          ncount++;
+          lgb = rgb;
+          nptr += dlen;
+          }
+        if (nptr >= end_subject && (md->moptions & PCRE_PARTIAL_HARD) != 0)
+            reset_could_continue = TRUE;
+        if (++count >= (int)GET2(code, 1))
+          { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, ncount); }
+        else
+          { ADD_NEW_DATA(-state_offset, count, ncount); }
+        }
+      break;
+#endif
+
+      /*-----------------------------------------------------------------*/
+      case OP_ANYNL_EXTRA + OP_TYPEEXACT:
+      case OP_ANYNL_EXTRA + OP_TYPEUPTO:
+      case OP_ANYNL_EXTRA + OP_TYPEMINUPTO:
+      case OP_ANYNL_EXTRA + OP_TYPEPOSUPTO:
+      if (codevalue != OP_ANYNL_EXTRA + OP_TYPEEXACT)
+        { ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); }
+      count = current_state->count;  /* Number already matched */
+      if (clen > 0)
+        {
+        int ncount = 0;
+        switch (c)
+          {
+          case CHAR_VT:
+          case CHAR_FF:
+          case CHAR_NEL:
+#ifndef EBCDIC
+          case 0x2028:
+          case 0x2029:
+#endif  /* Not EBCDIC */
+          if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
+          goto ANYNL03;
+
+          case CHAR_CR:
+          if (ptr + 1 < end_subject && UCHAR21TEST(ptr + 1) == CHAR_LF) ncount = 1;
+          /* Fall through */
+
+          ANYNL03:
+          case CHAR_LF:
+          if (codevalue == OP_ANYNL_EXTRA + OP_TYPEPOSUPTO)
+            {
+            active_count--;           /* Remove non-match possibility */
+            next_active_state--;
+            }
+          if (++count >= (int)GET2(code, 1))
+            { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, ncount); }
+          else
+            { ADD_NEW_DATA(-state_offset, count, ncount); }
+          break;
+
+          default:
+          break;
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_VSPACE_EXTRA + OP_TYPEEXACT:
+      case OP_VSPACE_EXTRA + OP_TYPEUPTO:
+      case OP_VSPACE_EXTRA + OP_TYPEMINUPTO:
+      case OP_VSPACE_EXTRA + OP_TYPEPOSUPTO:
+      if (codevalue != OP_VSPACE_EXTRA + OP_TYPEEXACT)
+        { ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); }
+      count = current_state->count;  /* Number already matched */
+      if (clen > 0)
+        {
+        BOOL OK;
+        switch (c)
+          {
+          VSPACE_CASES:
+          OK = TRUE;
+          break;
+
+          default:
+          OK = FALSE;
+          }
+
+        if (OK == (d == OP_VSPACE))
+          {
+          if (codevalue == OP_VSPACE_EXTRA + OP_TYPEPOSUPTO)
+            {
+            active_count--;           /* Remove non-match possibility */
+            next_active_state--;
+            }
+          if (++count >= (int)GET2(code, 1))
+            { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, 0); }
+          else
+            { ADD_NEW_DATA(-state_offset, count, 0); }
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_HSPACE_EXTRA + OP_TYPEEXACT:
+      case OP_HSPACE_EXTRA + OP_TYPEUPTO:
+      case OP_HSPACE_EXTRA + OP_TYPEMINUPTO:
+      case OP_HSPACE_EXTRA + OP_TYPEPOSUPTO:
+      if (codevalue != OP_HSPACE_EXTRA + OP_TYPEEXACT)
+        { ADD_ACTIVE(state_offset + 2 + IMM2_SIZE, 0); }
+      count = current_state->count;  /* Number already matched */
+      if (clen > 0)
+        {
+        BOOL OK;
+        switch (c)
+          {
+          HSPACE_CASES:
+          OK = TRUE;
+          break;
+
+          default:
+          OK = FALSE;
+          break;
+          }
+
+        if (OK == (d == OP_HSPACE))
+          {
+          if (codevalue == OP_HSPACE_EXTRA + OP_TYPEPOSUPTO)
+            {
+            active_count--;           /* Remove non-match possibility */
+            next_active_state--;
+            }
+          if (++count >= (int)GET2(code, 1))
+            { ADD_NEW_DATA(-(state_offset + 2 + IMM2_SIZE), 0, 0); }
+          else
+            { ADD_NEW_DATA(-state_offset, count, 0); }
+          }
+        }
+      break;
+
+/* ========================================================================== */
+      /* These opcodes are followed by a character that is usually compared
+      to the current subject character; it is loaded into d. We still get
+      here even if there is no subject character, because in some cases zero
+      repetitions are permitted. */
+
+      /*-----------------------------------------------------------------*/
+      case OP_CHAR:
+      if (clen > 0 && c == d) { ADD_NEW(state_offset + dlen + 1, 0); }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_CHARI:
+      if (clen == 0) break;
+
+#ifdef SUPPORT_UTF
+      if (utf)
+        {
+        if (c == d) { ADD_NEW(state_offset + dlen + 1, 0); } else
+          {
+          unsigned int othercase;
+          if (c < 128)
+            othercase = fcc[c];
+          else
+            /* If we have Unicode property support, we can use it to test the
+            other case of the character. */
+#ifdef SUPPORT_UCP
+            othercase = UCD_OTHERCASE(c);
+#else
+            othercase = NOTACHAR;
+#endif
+
+          if (d == othercase) { ADD_NEW(state_offset + dlen + 1, 0); }
+          }
+        }
+      else
+#endif  /* SUPPORT_UTF */
+      /* Not UTF mode */
+        {
+        if (TABLE_GET(c, lcc, c) == TABLE_GET(d, lcc, d))
+          { ADD_NEW(state_offset + 2, 0); }
+        }
+      break;
+
+
+#ifdef SUPPORT_UCP
+      /*-----------------------------------------------------------------*/
+      /* This is a tricky one because it can match more than one character.
+      Find out how many characters to skip, and then set up a negative state
+      to wait for them to pass before continuing. */
+
+      case OP_EXTUNI:
+      if (clen > 0)
+        {
+        int lgb, rgb;
+        const pcre_uchar *nptr = ptr + clen;
+        int ncount = 0;
+        lgb = UCD_GRAPHBREAK(c);
+        while (nptr < end_subject)
+          {
+          dlen = 1;
+          if (!utf) d = *nptr; else { GETCHARLEN(d, nptr, dlen); }
+          rgb = UCD_GRAPHBREAK(d);
+          if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
+          ncount++;
+          lgb = rgb;
+          nptr += dlen;
+          }
+        if (nptr >= end_subject && (md->moptions & PCRE_PARTIAL_HARD) != 0)
+            reset_could_continue = TRUE;
+        ADD_NEW_DATA(-(state_offset + 1), 0, ncount);
+        }
+      break;
+#endif
+
+      /*-----------------------------------------------------------------*/
+      /* This is a tricky like EXTUNI because it too can match more than one
+      character (when CR is followed by LF). In this case, set up a negative
+      state to wait for one character to pass before continuing. */
+
+      case OP_ANYNL:
+      if (clen > 0) switch(c)
+        {
+        case CHAR_VT:
+        case CHAR_FF:
+        case CHAR_NEL:
+#ifndef EBCDIC
+        case 0x2028:
+        case 0x2029:
+#endif  /* Not EBCDIC */
+        if ((md->moptions & PCRE_BSR_ANYCRLF) != 0) break;
+
+        case CHAR_LF:
+        ADD_NEW(state_offset + 1, 0);
+        break;
+
+        case CHAR_CR:
+        if (ptr + 1 >= end_subject)
+          {
+          ADD_NEW(state_offset + 1, 0);
+          if ((md->moptions & PCRE_PARTIAL_HARD) != 0)
+            reset_could_continue = TRUE;
+          }
+        else if (UCHAR21TEST(ptr + 1) == CHAR_LF)
+          {
+          ADD_NEW_DATA(-(state_offset + 1), 0, 1);
+          }
+        else
+          {
+          ADD_NEW(state_offset + 1, 0);
+          }
+        break;
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_NOT_VSPACE:
+      if (clen > 0) switch(c)
+        {
+        VSPACE_CASES:
+        break;
+
+        default:
+        ADD_NEW(state_offset + 1, 0);
+        break;
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_VSPACE:
+      if (clen > 0) switch(c)
+        {
+        VSPACE_CASES:
+        ADD_NEW(state_offset + 1, 0);
+        break;
+
+        default:
+        break;
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_NOT_HSPACE:
+      if (clen > 0) switch(c)
+        {
+        HSPACE_CASES:
+        break;
+
+        default:
+        ADD_NEW(state_offset + 1, 0);
+        break;
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_HSPACE:
+      if (clen > 0) switch(c)
+        {
+        HSPACE_CASES:
+        ADD_NEW(state_offset + 1, 0);
+        break;
+
+        default:
+        break;
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      /* Match a negated single character casefully. */
+
+      case OP_NOT:
+      if (clen > 0 && c != d) { ADD_NEW(state_offset + dlen + 1, 0); }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      /* Match a negated single character caselessly. */
+
+      case OP_NOTI:
+      if (clen > 0)
+        {
+        pcre_uint32 otherd;
+#ifdef SUPPORT_UTF
+        if (utf && d >= 128)
+          {
+#ifdef SUPPORT_UCP
+          otherd = UCD_OTHERCASE(d);
+#else
+          otherd = d;
+#endif  /* SUPPORT_UCP */
+          }
+        else
+#endif  /* SUPPORT_UTF */
+        otherd = TABLE_GET(d, fcc, d);
+        if (c != d && c != otherd)
+          { ADD_NEW(state_offset + dlen + 1, 0); }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_PLUSI:
+      case OP_MINPLUSI:
+      case OP_POSPLUSI:
+      case OP_NOTPLUSI:
+      case OP_NOTMINPLUSI:
+      case OP_NOTPOSPLUSI:
+      caseless = TRUE;
+      codevalue -= OP_STARI - OP_STAR;
+
+      /* Fall through */
+      case OP_PLUS:
+      case OP_MINPLUS:
+      case OP_POSPLUS:
+      case OP_NOTPLUS:
+      case OP_NOTMINPLUS:
+      case OP_NOTPOSPLUS:
+      count = current_state->count;  /* Already matched */
+      if (count > 0) { ADD_ACTIVE(state_offset + dlen + 1, 0); }
+      if (clen > 0)
+        {
+        pcre_uint32 otherd = NOTACHAR;
+        if (caseless)
+          {
+#ifdef SUPPORT_UTF
+          if (utf && d >= 128)
+            {
+#ifdef SUPPORT_UCP
+            otherd = UCD_OTHERCASE(d);
+#endif  /* SUPPORT_UCP */
+            }
+          else
+#endif  /* SUPPORT_UTF */
+          otherd = TABLE_GET(d, fcc, d);
+          }
+        if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))
+          {
+          if (count > 0 &&
+              (codevalue == OP_POSPLUS || codevalue == OP_NOTPOSPLUS))
+            {
+            active_count--;             /* Remove non-match possibility */
+            next_active_state--;
+            }
+          count++;
+          ADD_NEW(state_offset, count);
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_QUERYI:
+      case OP_MINQUERYI:
+      case OP_POSQUERYI:
+      case OP_NOTQUERYI:
+      case OP_NOTMINQUERYI:
+      case OP_NOTPOSQUERYI:
+      caseless = TRUE;
+      codevalue -= OP_STARI - OP_STAR;
+      /* Fall through */
+      case OP_QUERY:
+      case OP_MINQUERY:
+      case OP_POSQUERY:
+      case OP_NOTQUERY:
+      case OP_NOTMINQUERY:
+      case OP_NOTPOSQUERY:
+      ADD_ACTIVE(state_offset + dlen + 1, 0);
+      if (clen > 0)
+        {
+        pcre_uint32 otherd = NOTACHAR;
+        if (caseless)
+          {
+#ifdef SUPPORT_UTF
+          if (utf && d >= 128)
+            {
+#ifdef SUPPORT_UCP
+            otherd = UCD_OTHERCASE(d);
+#endif  /* SUPPORT_UCP */
+            }
+          else
+#endif  /* SUPPORT_UTF */
+          otherd = TABLE_GET(d, fcc, d);
+          }
+        if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))
+          {
+          if (codevalue == OP_POSQUERY || codevalue == OP_NOTPOSQUERY)
+            {
+            active_count--;            /* Remove non-match possibility */
+            next_active_state--;
+            }
+          ADD_NEW(state_offset + dlen + 1, 0);
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_STARI:
+      case OP_MINSTARI:
+      case OP_POSSTARI:
+      case OP_NOTSTARI:
+      case OP_NOTMINSTARI:
+      case OP_NOTPOSSTARI:
+      caseless = TRUE;
+      codevalue -= OP_STARI - OP_STAR;
+      /* Fall through */
+      case OP_STAR:
+      case OP_MINSTAR:
+      case OP_POSSTAR:
+      case OP_NOTSTAR:
+      case OP_NOTMINSTAR:
+      case OP_NOTPOSSTAR:
+      ADD_ACTIVE(state_offset + dlen + 1, 0);
+      if (clen > 0)
+        {
+        pcre_uint32 otherd = NOTACHAR;
+        if (caseless)
+          {
+#ifdef SUPPORT_UTF
+          if (utf && d >= 128)
+            {
+#ifdef SUPPORT_UCP
+            otherd = UCD_OTHERCASE(d);
+#endif  /* SUPPORT_UCP */
+            }
+          else
+#endif  /* SUPPORT_UTF */
+          otherd = TABLE_GET(d, fcc, d);
+          }
+        if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))
+          {
+          if (codevalue == OP_POSSTAR || codevalue == OP_NOTPOSSTAR)
+            {
+            active_count--;            /* Remove non-match possibility */
+            next_active_state--;
+            }
+          ADD_NEW(state_offset, 0);
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_EXACTI:
+      case OP_NOTEXACTI:
+      caseless = TRUE;
+      codevalue -= OP_STARI - OP_STAR;
+      /* Fall through */
+      case OP_EXACT:
+      case OP_NOTEXACT:
+      count = current_state->count;  /* Number already matched */
+      if (clen > 0)
+        {
+        pcre_uint32 otherd = NOTACHAR;
+        if (caseless)
+          {
+#ifdef SUPPORT_UTF
+          if (utf && d >= 128)
+            {
+#ifdef SUPPORT_UCP
+            otherd = UCD_OTHERCASE(d);
+#endif  /* SUPPORT_UCP */
+            }
+          else
+#endif  /* SUPPORT_UTF */
+          otherd = TABLE_GET(d, fcc, d);
+          }
+        if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))
+          {
+          if (++count >= (int)GET2(code, 1))
+            { ADD_NEW(state_offset + dlen + 1 + IMM2_SIZE, 0); }
+          else
+            { ADD_NEW(state_offset, count); }
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_UPTOI:
+      case OP_MINUPTOI:
+      case OP_POSUPTOI:
+      case OP_NOTUPTOI:
+      case OP_NOTMINUPTOI:
+      case OP_NOTPOSUPTOI:
+      caseless = TRUE;
+      codevalue -= OP_STARI - OP_STAR;
+      /* Fall through */
+      case OP_UPTO:
+      case OP_MINUPTO:
+      case OP_POSUPTO:
+      case OP_NOTUPTO:
+      case OP_NOTMINUPTO:
+      case OP_NOTPOSUPTO:
+      ADD_ACTIVE(state_offset + dlen + 1 + IMM2_SIZE, 0);
+      count = current_state->count;  /* Number already matched */
+      if (clen > 0)
+        {
+        pcre_uint32 otherd = NOTACHAR;
+        if (caseless)
+          {
+#ifdef SUPPORT_UTF
+          if (utf && d >= 128)
+            {
+#ifdef SUPPORT_UCP
+            otherd = UCD_OTHERCASE(d);
+#endif  /* SUPPORT_UCP */
+            }
+          else
+#endif  /* SUPPORT_UTF */
+          otherd = TABLE_GET(d, fcc, d);
+          }
+        if ((c == d || c == otherd) == (codevalue < OP_NOTSTAR))
+          {
+          if (codevalue == OP_POSUPTO || codevalue == OP_NOTPOSUPTO)
+            {
+            active_count--;             /* Remove non-match possibility */
+            next_active_state--;
+            }
+          if (++count >= (int)GET2(code, 1))
+            { ADD_NEW(state_offset + dlen + 1 + IMM2_SIZE, 0); }
+          else
+            { ADD_NEW(state_offset, count); }
+          }
+        }
+      break;
+
+
+/* ========================================================================== */
+      /* These are the class-handling opcodes */
+
+      case OP_CLASS:
+      case OP_NCLASS:
+      case OP_XCLASS:
+        {
+        BOOL isinclass = FALSE;
+        int next_state_offset;
+        const pcre_uchar *ecode;
+
+        /* For a simple class, there is always just a 32-byte table, and we
+        can set isinclass from it. */
+
+        if (codevalue != OP_XCLASS)
+          {
+          ecode = code + 1 + (32 / sizeof(pcre_uchar));
+          if (clen > 0)
+            {
+            isinclass = (c > 255)? (codevalue == OP_NCLASS) :
+              ((((pcre_uint8 *)(code + 1))[c/8] & (1 << (c&7))) != 0);
+            }
+          }
+
+        /* An extended class may have a table or a list of single characters,
+        ranges, or both, and it may be positive or negative. There's a
+        function that sorts all this out. */
+
+        else
+         {
+         ecode = code + GET(code, 1);
+         if (clen > 0) isinclass = PRIV(xclass)(c, code + 1 + LINK_SIZE, utf);
+         }
+
+        /* At this point, isinclass is set for all kinds of class, and ecode
+        points to the byte after the end of the class. If there is a
+        quantifier, this is where it will be. */
+
+        next_state_offset = (int)(ecode - start_code);
+
+        switch (*ecode)
+          {
+          case OP_CRSTAR:
+          case OP_CRMINSTAR:
+          case OP_CRPOSSTAR:
+          ADD_ACTIVE(next_state_offset + 1, 0);
+          if (isinclass)
+            {
+            if (*ecode == OP_CRPOSSTAR)
+              {
+              active_count--;           /* Remove non-match possibility */
+              next_active_state--;
+              }
+            ADD_NEW(state_offset, 0);
+            }
+          break;
+
+          case OP_CRPLUS:
+          case OP_CRMINPLUS:
+          case OP_CRPOSPLUS:
+          count = current_state->count;  /* Already matched */
+          if (count > 0) { ADD_ACTIVE(next_state_offset + 1, 0); }
+          if (isinclass)
+            {
+            if (count > 0 && *ecode == OP_CRPOSPLUS)
+              {
+              active_count--;           /* Remove non-match possibility */
+              next_active_state--;
+              }
+            count++;
+            ADD_NEW(state_offset, count);
+            }
+          break;
+
+          case OP_CRQUERY:
+          case OP_CRMINQUERY:
+          case OP_CRPOSQUERY:
+          ADD_ACTIVE(next_state_offset + 1, 0);
+          if (isinclass)
+            {
+            if (*ecode == OP_CRPOSQUERY)
+              {
+              active_count--;           /* Remove non-match possibility */
+              next_active_state--;
+              }
+            ADD_NEW(next_state_offset + 1, 0);
+            }
+          break;
+
+          case OP_CRRANGE:
+          case OP_CRMINRANGE:
+          case OP_CRPOSRANGE:
+          count = current_state->count;  /* Already matched */
+          if (count >= (int)GET2(ecode, 1))
+            { ADD_ACTIVE(next_state_offset + 1 + 2 * IMM2_SIZE, 0); }
+          if (isinclass)
+            {
+            int max = (int)GET2(ecode, 1 + IMM2_SIZE);
+            if (*ecode == OP_CRPOSRANGE && count >= (int)GET2(ecode, 1))
+              {
+              active_count--;           /* Remove non-match possibility */
+              next_active_state--;
+              }
+            if (++count >= max && max != 0)   /* Max 0 => no limit */
+              { ADD_NEW(next_state_offset + 1 + 2 * IMM2_SIZE, 0); }
+            else
+              { ADD_NEW(state_offset, count); }
+            }
+          break;
+
+          default:
+          if (isinclass) { ADD_NEW(next_state_offset, 0); }
+          break;
+          }
+        }
+      break;
+
+/* ========================================================================== */
+      /* These are the opcodes for fancy brackets of various kinds. We have
+      to use recursion in order to handle them. The "always failing" assertion
+      (?!) is optimised to OP_FAIL when compiling, so we have to support that,
+      though the other "backtracking verbs" are not supported. */
+
+      case OP_FAIL:
+      forced_fail++;    /* Count FAILs for multiple states */
+      break;
+
+      case OP_ASSERT:
+      case OP_ASSERT_NOT:
+      case OP_ASSERTBACK:
+      case OP_ASSERTBACK_NOT:
+        {
+        int rc;
+        int local_offsets[2];
+        int local_workspace[1000];
+        const pcre_uchar *endasscode = code + GET(code, 1);
+
+        while (*endasscode == OP_ALT) endasscode += GET(endasscode, 1);
+
+        rc = internal_dfa_exec(
+          md,                                   /* static match data */
+          code,                                 /* this subexpression's code */
+          ptr,                                  /* where we currently are */
+          (int)(ptr - start_subject),           /* start offset */
+          local_offsets,                        /* offset vector */
+          sizeof(local_offsets)/sizeof(int),    /* size of same */
+          local_workspace,                      /* workspace vector */
+          sizeof(local_workspace)/sizeof(int),  /* size of same */
+          rlevel);                              /* function recursion level */
+
+        if (rc == PCRE_ERROR_DFA_UITEM) return rc;
+        if ((rc >= 0) == (codevalue == OP_ASSERT || codevalue == OP_ASSERTBACK))
+            { ADD_ACTIVE((int)(endasscode + LINK_SIZE + 1 - start_code), 0); }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_COND:
+      case OP_SCOND:
+        {
+        int local_offsets[1000];
+        int local_workspace[1000];
+        int codelink = GET(code, 1);
+        int condcode;
+
+        /* Because of the way auto-callout works during compile, a callout item
+        is inserted between OP_COND and an assertion condition. This does not
+        happen for the other conditions. */
+
+        if (code[LINK_SIZE+1] == OP_CALLOUT)
+          {
+          rrc = 0;
+          if (PUBL(callout) != NULL)
+            {
+            PUBL(callout_block) cb;
+            cb.version          = 1;   /* Version 1 of the callout block */
+            cb.callout_number   = code[LINK_SIZE+2];
+            cb.offset_vector    = offsets;
+#if defined COMPILE_PCRE8
+            cb.subject          = (PCRE_SPTR)start_subject;
+#elif defined COMPILE_PCRE16
+            cb.subject          = (PCRE_SPTR16)start_subject;
+#elif defined COMPILE_PCRE32
+            cb.subject          = (PCRE_SPTR32)start_subject;
+#endif
+            cb.subject_length   = (int)(end_subject - start_subject);
+            cb.start_match      = (int)(current_subject - start_subject);
+            cb.current_position = (int)(ptr - start_subject);
+            cb.pattern_position = GET(code, LINK_SIZE + 3);
+            cb.next_item_length = GET(code, 3 + 2*LINK_SIZE);
+            cb.capture_top      = 1;
+            cb.capture_last     = -1;
+            cb.callout_data     = md->callout_data;
+            cb.mark             = NULL;   /* No (*MARK) support */
+            if ((rrc = (*PUBL(callout))(&cb)) < 0) return rrc;   /* Abandon */
+            }
+          if (rrc > 0) break;                      /* Fail this thread */
+          code += PRIV(OP_lengths)[OP_CALLOUT];    /* Skip callout data */
+          }
+
+        condcode = code[LINK_SIZE+1];
+
+        /* Back reference conditions and duplicate named recursion conditions
+        are not supported */
+
+        if (condcode == OP_CREF || condcode == OP_DNCREF ||
+            condcode == OP_DNRREF)
+          return PCRE_ERROR_DFA_UCOND;
+
+        /* The DEFINE condition is always false, and the assertion (?!) is
+        converted to OP_FAIL. */
+
+        if (condcode == OP_DEF || condcode == OP_FAIL)
+          { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
+
+        /* The only supported version of OP_RREF is for the value RREF_ANY,
+        which means "test if in any recursion". We can't test for specifically
+        recursed groups. */
+
+        else if (condcode == OP_RREF)
+          {
+          int value = GET2(code, LINK_SIZE + 2);
+          if (value != RREF_ANY) return PCRE_ERROR_DFA_UCOND;
+          if (md->recursive != NULL)
+            { ADD_ACTIVE(state_offset + LINK_SIZE + 2 + IMM2_SIZE, 0); }
+          else { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
+          }
+
+        /* Otherwise, the condition is an assertion */
+
+        else
+          {
+          int rc;
+          const pcre_uchar *asscode = code + LINK_SIZE + 1;
+          const pcre_uchar *endasscode = asscode + GET(asscode, 1);
+
+          while (*endasscode == OP_ALT) endasscode += GET(endasscode, 1);
+
+          rc = internal_dfa_exec(
+            md,                                   /* fixed match data */
+            asscode,                              /* this subexpression's code */
+            ptr,                                  /* where we currently are */
+            (int)(ptr - start_subject),           /* start offset */
+            local_offsets,                        /* offset vector */
+            sizeof(local_offsets)/sizeof(int),    /* size of same */
+            local_workspace,                      /* workspace vector */
+            sizeof(local_workspace)/sizeof(int),  /* size of same */
+            rlevel);                              /* function recursion level */
+
+          if (rc == PCRE_ERROR_DFA_UITEM) return rc;
+          if ((rc >= 0) ==
+                (condcode == OP_ASSERT || condcode == OP_ASSERTBACK))
+            { ADD_ACTIVE((int)(endasscode + LINK_SIZE + 1 - start_code), 0); }
+          else
+            { ADD_ACTIVE(state_offset + codelink + LINK_SIZE + 1, 0); }
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_RECURSE:
+        {
+        dfa_recursion_info *ri;
+        int local_offsets[1000];
+        int local_workspace[1000];
+        const pcre_uchar *callpat = start_code + GET(code, 1);
+        int recno = (callpat == md->start_code)? 0 :
+          GET2(callpat, 1 + LINK_SIZE);
+        int rc;
+
+        DPRINTF(("%.*sStarting regex recursion\n", rlevel*2-2, SP));
+
+        /* Check for repeating a recursion without advancing the subject
+        pointer. This should catch convoluted mutual recursions. (Some simple
+        cases are caught at compile time.) */
+
+        for (ri = md->recursive; ri != NULL; ri = ri->prevrec)
+          if (recno == ri->group_num && ptr == ri->subject_position)
+            return PCRE_ERROR_RECURSELOOP;
+
+        /* Remember this recursion and where we started it so as to
+        catch infinite loops. */
+
+        new_recursive.group_num = recno;
+        new_recursive.subject_position = ptr;
+        new_recursive.prevrec = md->recursive;
+        md->recursive = &new_recursive;
+
+        rc = internal_dfa_exec(
+          md,                                   /* fixed match data */
+          callpat,                              /* this subexpression's code */
+          ptr,                                  /* where we currently are */
+          (int)(ptr - start_subject),           /* start offset */
+          local_offsets,                        /* offset vector */
+          sizeof(local_offsets)/sizeof(int),    /* size of same */
+          local_workspace,                      /* workspace vector */
+          sizeof(local_workspace)/sizeof(int),  /* size of same */
+          rlevel);                              /* function recursion level */
+
+        md->recursive = new_recursive.prevrec;  /* Done this recursion */
+
+        DPRINTF(("%.*sReturn from regex recursion: rc=%d\n", rlevel*2-2, SP,
+          rc));
+
+        /* Ran out of internal offsets */
+
+        if (rc == 0) return PCRE_ERROR_DFA_RECURSE;
+
+        /* For each successful matched substring, set up the next state with a
+        count of characters to skip before trying it. Note that the count is in
+        characters, not bytes. */
+
+        if (rc > 0)
+          {
+          for (rc = rc*2 - 2; rc >= 0; rc -= 2)
+            {
+            int charcount = local_offsets[rc+1] - local_offsets[rc];
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+            if (utf)
+              {
+              const pcre_uchar *p = start_subject + local_offsets[rc];
+              const pcre_uchar *pp = start_subject + local_offsets[rc+1];
+              while (p < pp) if (NOT_FIRSTCHAR(*p++)) charcount--;
+              }
+#endif
+            if (charcount > 0)
+              {
+              ADD_NEW_DATA(-(state_offset + LINK_SIZE + 1), 0, (charcount - 1));
+              }
+            else
+              {
+              ADD_ACTIVE(state_offset + LINK_SIZE + 1, 0);
+              }
+            }
+          }
+        else if (rc != PCRE_ERROR_NOMATCH) return rc;
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_BRAPOS:
+      case OP_SBRAPOS:
+      case OP_CBRAPOS:
+      case OP_SCBRAPOS:
+      case OP_BRAPOSZERO:
+        {
+        int charcount, matched_count;
+        const pcre_uchar *local_ptr = ptr;
+        BOOL allow_zero;
+
+        if (codevalue == OP_BRAPOSZERO)
+          {
+          allow_zero = TRUE;
+          codevalue = *(++code);  /* Codevalue will be one of above BRAs */
+          }
+        else allow_zero = FALSE;
+
+        /* Loop to match the subpattern as many times as possible as if it were
+        a complete pattern. */
+
+        for (matched_count = 0;; matched_count++)
+          {
+          int local_offsets[2];
+          int local_workspace[1000];
+
+          int rc = internal_dfa_exec(
+            md,                                   /* fixed match data */
+            code,                                 /* this subexpression's code */
+            local_ptr,                            /* where we currently are */
+            (int)(ptr - start_subject),           /* start offset */
+            local_offsets,                        /* offset vector */
+            sizeof(local_offsets)/sizeof(int),    /* size of same */
+            local_workspace,                      /* workspace vector */
+            sizeof(local_workspace)/sizeof(int),  /* size of same */
+            rlevel);                              /* function recursion level */
+
+          /* Failed to match */
+
+          if (rc < 0)
+            {
+            if (rc != PCRE_ERROR_NOMATCH) return rc;
+            break;
+            }
+
+          /* Matched: break the loop if zero characters matched. */
+
+          charcount = local_offsets[1] - local_offsets[0];
+          if (charcount == 0) break;
+          local_ptr += charcount;    /* Advance temporary position ptr */
+          }
+
+        /* At this point we have matched the subpattern matched_count
+        times, and local_ptr is pointing to the character after the end of the
+        last match. */
+
+        if (matched_count > 0 || allow_zero)
+          {
+          const pcre_uchar *end_subpattern = code;
+          int next_state_offset;
+
+          do { end_subpattern += GET(end_subpattern, 1); }
+            while (*end_subpattern == OP_ALT);
+          next_state_offset =
+            (int)(end_subpattern - start_code + LINK_SIZE + 1);
+
+          /* Optimization: if there are no more active states, and there
+          are no new states yet set up, then skip over the subject string
+          right here, to save looping. Otherwise, set up the new state to swing
+          into action when the end of the matched substring is reached. */
+
+          if (i + 1 >= active_count && new_count == 0)
+            {
+            ptr = local_ptr;
+            clen = 0;
+            ADD_NEW(next_state_offset, 0);
+            }
+          else
+            {
+            const pcre_uchar *p = ptr;
+            const pcre_uchar *pp = local_ptr;
+            charcount = (int)(pp - p);
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+            if (utf) while (p < pp) if (NOT_FIRSTCHAR(*p++)) charcount--;
+#endif
+            ADD_NEW_DATA(-next_state_offset, 0, (charcount - 1));
+            }
+          }
+        }
+      break;
+
+      /*-----------------------------------------------------------------*/
+      case OP_ONCE:
+      case OP_ONCE_NC:
+        {
+        int local_offsets[2];
+        int local_workspace[1000];
+
+        int rc = internal_dfa_exec(
+          md,                                   /* fixed match data */
+          code,                                 /* this subexpression's code */
+          ptr,                                  /* where we currently are */
+          (int)(ptr - start_subject),           /* start offset */
+          local_offsets,                        /* offset vector */
+          sizeof(local_offsets)/sizeof(int),    /* size of same */
+          local_workspace,                      /* workspace vector */
+          sizeof(local_workspace)/sizeof(int),  /* size of same */
+          rlevel);                              /* function recursion level */
+
+        if (rc >= 0)
+          {
+          const pcre_uchar *end_subpattern = code;
+          int charcount = local_offsets[1] - local_offsets[0];
+          int next_state_offset, repeat_state_offset;
+
+          do { end_subpattern += GET(end_subpattern, 1); }
+            while (*end_subpattern == OP_ALT);
+          next_state_offset =
+            (int)(end_subpattern - start_code + LINK_SIZE + 1);
+
+          /* If the end of this subpattern is KETRMAX or KETRMIN, we must
+          arrange for the repeat state also to be added to the relevant list.
+          Calculate the offset, or set -1 for no repeat. */
+
+          repeat_state_offset = (*end_subpattern == OP_KETRMAX ||
+                                 *end_subpattern == OP_KETRMIN)?
+            (int)(end_subpattern - start_code - GET(end_subpattern, 1)) : -1;
+
+          /* If we have matched an empty string, add the next state at the
+          current character pointer. This is important so that the duplicate
+          checking kicks in, which is what breaks infinite loops that match an
+          empty string. */
+
+          if (charcount == 0)
+            {
+            ADD_ACTIVE(next_state_offset, 0);
+            }
+
+          /* Optimization: if there are no more active states, and there
+          are no new states yet set up, then skip over the subject string
+          right here, to save looping. Otherwise, set up the new state to swing
+          into action when the end of the matched substring is reached. */
+
+          else if (i + 1 >= active_count && new_count == 0)
+            {
+            ptr += charcount;
+            clen = 0;
+            ADD_NEW(next_state_offset, 0);
+
+            /* If we are adding a repeat state at the new character position,
+            we must fudge things so that it is the only current state.
+            Otherwise, it might be a duplicate of one we processed before, and
+            that would cause it to be skipped. */
+
+            if (repeat_state_offset >= 0)
+              {
+              next_active_state = active_states;
+              active_count = 0;
+              i = -1;
+              ADD_ACTIVE(repeat_state_offset, 0);
+              }
+            }
+          else
+            {
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+            if (utf)
+              {
+              const pcre_uchar *p = start_subject + local_offsets[0];
+              const pcre_uchar *pp = start_subject + local_offsets[1];
+              while (p < pp) if (NOT_FIRSTCHAR(*p++)) charcount--;
+              }
+#endif
+            ADD_NEW_DATA(-next_state_offset, 0, (charcount - 1));
+            if (repeat_state_offset >= 0)
+              { ADD_NEW_DATA(-repeat_state_offset, 0, (charcount - 1)); }
+            }
+          }
+        else if (rc != PCRE_ERROR_NOMATCH) return rc;
+        }
+      break;
+
+
+/* ========================================================================== */
+      /* Handle callouts */
+
+      case OP_CALLOUT:
+      rrc = 0;
+      if (PUBL(callout) != NULL)
+        {
+        PUBL(callout_block) cb;
+        cb.version          = 1;   /* Version 1 of the callout block */
+        cb.callout_number   = code[1];
+        cb.offset_vector    = offsets;
+#if defined COMPILE_PCRE8
+        cb.subject          = (PCRE_SPTR)start_subject;
+#elif defined COMPILE_PCRE16
+        cb.subject          = (PCRE_SPTR16)start_subject;
+#elif defined COMPILE_PCRE32
+        cb.subject          = (PCRE_SPTR32)start_subject;
+#endif
+        cb.subject_length   = (int)(end_subject - start_subject);
+        cb.start_match      = (int)(current_subject - start_subject);
+        cb.current_position = (int)(ptr - start_subject);
+        cb.pattern_position = GET(code, 2);
+        cb.next_item_length = GET(code, 2 + LINK_SIZE);
+        cb.capture_top      = 1;
+        cb.capture_last     = -1;
+        cb.callout_data     = md->callout_data;
+        cb.mark             = NULL;   /* No (*MARK) support */
+        if ((rrc = (*PUBL(callout))(&cb)) < 0) return rrc;   /* Abandon */
+        }
+      if (rrc == 0)
+        { ADD_ACTIVE(state_offset + PRIV(OP_lengths)[OP_CALLOUT], 0); }
+      break;
+
+
+/* ========================================================================== */
+      default:        /* Unsupported opcode */
+      return PCRE_ERROR_DFA_UITEM;
+      }
+
+    NEXT_ACTIVE_STATE: continue;
+
+    }      /* End of loop scanning active states */
+
+  /* We have finished the processing at the current subject character. If no
+  new states have been set for the next character, we have found all the
+  matches that we are going to find. If we are at the top level and partial
+  matching has been requested, check for appropriate conditions.
+
+  The "forced_ fail" variable counts the number of (*F) encountered for the
+  character. If it is equal to the original active_count (saved in
+  workspace[1]) it means that (*F) was found on every active state. In this
+  case we don't want to give a partial match.
+
+  The "could_continue" variable is true if a state could have continued but
+  for the fact that the end of the subject was reached. */
+
+  if (new_count <= 0)
+    {
+    if (rlevel == 1 &&                               /* Top level, and */
+        could_continue &&                            /* Some could go on, and */
+        forced_fail != workspace[1] &&               /* Not all forced fail & */
+        (                                            /* either... */
+        (md->moptions & PCRE_PARTIAL_HARD) != 0      /* Hard partial */
+        ||                                           /* or... */
+        ((md->moptions & PCRE_PARTIAL_SOFT) != 0 &&  /* Soft partial and */
+         match_count < 0)                            /* no matches */
+        ) &&                                         /* And... */
+        (
+        partial_newline ||                           /* Either partial NL */
+          (                                          /* or ... */
+          ptr >= end_subject &&                /* End of subject and */
+          ptr > md->start_used_ptr)            /* Inspected non-empty string */
+          )
+        )
+      match_count = PCRE_ERROR_PARTIAL;
+    DPRINTF(("%.*sEnd of internal_dfa_exec %d: returning %d\n"
+      "%.*s---------------------\n\n", rlevel*2-2, SP, rlevel, match_count,
+      rlevel*2-2, SP));
+    break;        /* In effect, "return", but see the comment below */
+    }
+
+  /* One or more states are active for the next character. */
+
+  ptr += clen;    /* Advance to next subject character */
+  }               /* Loop to move along the subject string */
+
+/* Control gets here from "break" a few lines above. We do it this way because
+if we use "return" above, we have compiler trouble. Some compilers warn if
+there's nothing here because they think the function doesn't return a value. On
+the other hand, if we put a dummy statement here, some more clever compilers
+complain that it can't be reached. Sigh. */
+
+return match_count;
+}
+
+
+
+
+/*************************************************
+*    Execute a Regular Expression - DFA engine   *
+*************************************************/
+
+/* This external function applies a compiled re to a subject string using a DFA
+engine. This function calls the internal function multiple times if the pattern
+is not anchored.
+
+Arguments:
+  argument_re     points to the compiled expression
+  extra_data      points to extra data or is NULL
+  subject         points to the subject string
+  length          length of subject string (may contain binary zeros)
+  start_offset    where to start in the subject string
+  options         option bits
+  offsets         vector of match offsets
+  offsetcount     size of same
+  workspace       workspace vector
+  wscount         size of same
+
+Returns:          > 0 => number of match offset pairs placed in offsets
+                  = 0 => offsets overflowed; longest matches are present
+                   -1 => failed to match
+                 < -1 => some kind of unexpected problem
+*/
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre_dfa_exec(const pcre *argument_re, const pcre_extra *extra_data,
+  const char *subject, int length, int start_offset, int options, int *offsets,
+  int offsetcount, int *workspace, int wscount)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre16_dfa_exec(const pcre16 *argument_re, const pcre16_extra *extra_data,
+  PCRE_SPTR16 subject, int length, int start_offset, int options, int *offsets,
+  int offsetcount, int *workspace, int wscount)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre32_dfa_exec(const pcre32 *argument_re, const pcre32_extra *extra_data,
+  PCRE_SPTR32 subject, int length, int start_offset, int options, int *offsets,
+  int offsetcount, int *workspace, int wscount)
+#endif
+{
+REAL_PCRE *re = (REAL_PCRE *)argument_re;
+dfa_match_data match_block;
+dfa_match_data *md = &match_block;
+BOOL utf, anchored, startline, firstline;
+const pcre_uchar *current_subject, *end_subject;
+const pcre_study_data *study = NULL;
+
+const pcre_uchar *req_char_ptr;
+const pcre_uint8 *start_bits = NULL;
+BOOL has_first_char = FALSE;
+BOOL has_req_char = FALSE;
+pcre_uchar first_char = 0;
+pcre_uchar first_char2 = 0;
+pcre_uchar req_char = 0;
+pcre_uchar req_char2 = 0;
+int newline;
+
+/* Plausibility checks */
+
+if ((options & ~PUBLIC_DFA_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION;
+if (re == NULL || subject == NULL || workspace == NULL ||
+   (offsets == NULL && offsetcount > 0)) return PCRE_ERROR_NULL;
+if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
+if (wscount < 20) return PCRE_ERROR_DFA_WSSIZE;
+if (length < 0) return PCRE_ERROR_BADLENGTH;
+if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;
+
+/* Check that the first field in the block is the magic number. If it is not,
+return with PCRE_ERROR_BADMAGIC. However, if the magic number is equal to
+REVERSED_MAGIC_NUMBER we return with PCRE_ERROR_BADENDIANNESS, which
+means that the pattern is likely compiled with different endianness. */
+
+if (re->magic_number != MAGIC_NUMBER)
+  return re->magic_number == REVERSED_MAGIC_NUMBER?
+    PCRE_ERROR_BADENDIANNESS:PCRE_ERROR_BADMAGIC;
+if ((re->flags & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE;
+
+/* If restarting after a partial match, do some sanity checks on the contents
+of the workspace. */
+
+if ((options & PCRE_DFA_RESTART) != 0)
+  {
+  if ((workspace[0] & (-2)) != 0 || workspace[1] < 1 ||
+    workspace[1] > (wscount - 2)/INTS_PER_STATEBLOCK)
+      return PCRE_ERROR_DFA_BADRESTART;
+  }
+
+/* Set up study, callout, and table data */
+
+md->tables = re->tables;
+md->callout_data = NULL;
+
+if (extra_data != NULL)
+  {
+  unsigned long int flags = extra_data->flags;
+  if ((flags & PCRE_EXTRA_STUDY_DATA) != 0)
+    study = (const pcre_study_data *)extra_data->study_data;
+  if ((flags & PCRE_EXTRA_MATCH_LIMIT) != 0) return PCRE_ERROR_DFA_UMLIMIT;
+  if ((flags & PCRE_EXTRA_MATCH_LIMIT_RECURSION) != 0)
+    return PCRE_ERROR_DFA_UMLIMIT;
+  if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)
+    md->callout_data = extra_data->callout_data;
+  if ((flags & PCRE_EXTRA_TABLES) != 0)
+    md->tables = extra_data->tables;
+  }
+
+/* Set some local values */
+
+current_subject = (const pcre_uchar *)subject + start_offset;
+end_subject = (const pcre_uchar *)subject + length;
+req_char_ptr = current_subject - 1;
+
+#ifdef SUPPORT_UTF
+/* PCRE_UTF(16|32) have the same value as PCRE_UTF8. */
+utf = (re->options & PCRE_UTF8) != 0;
+#else
+utf = FALSE;
+#endif
+
+anchored = (options & (PCRE_ANCHORED|PCRE_DFA_RESTART)) != 0 ||
+  (re->options & PCRE_ANCHORED) != 0;
+
+/* The remaining fixed data for passing around. */
+
+md->start_code = (const pcre_uchar *)argument_re +
+    re->name_table_offset + re->name_count * re->name_entry_size;
+md->start_subject = (const pcre_uchar *)subject;
+md->end_subject = end_subject;
+md->start_offset = start_offset;
+md->moptions = options;
+md->poptions = re->options;
+
+/* If the BSR option is not set at match time, copy what was set
+at compile time. */
+
+if ((md->moptions & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) == 0)
+  {
+  if ((re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) != 0)
+    md->moptions |= re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE);
+#ifdef BSR_ANYCRLF
+  else md->moptions |= PCRE_BSR_ANYCRLF;
+#endif
+  }
+
+/* Handle different types of newline. The three bits give eight cases. If
+nothing is set at run time, whatever was used at compile time applies. */
+
+switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options : (pcre_uint32)options) &
+         PCRE_NEWLINE_BITS)
+  {
+  case 0: newline = NEWLINE; break;   /* Compile-time default */
+  case PCRE_NEWLINE_CR: newline = CHAR_CR; break;
+  case PCRE_NEWLINE_LF: newline = CHAR_NL; break;
+  case PCRE_NEWLINE_CR+
+       PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;
+  case PCRE_NEWLINE_ANY: newline = -1; break;
+  case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
+  default: return PCRE_ERROR_BADNEWLINE;
+  }
+
+if (newline == -2)
+  {
+  md->nltype = NLTYPE_ANYCRLF;
+  }
+else if (newline < 0)
+  {
+  md->nltype = NLTYPE_ANY;
+  }
+else
+  {
+  md->nltype = NLTYPE_FIXED;
+  if (newline > 255)
+    {
+    md->nllen = 2;
+    md->nl[0] = (newline >> 8) & 255;
+    md->nl[1] = newline & 255;
+    }
+  else
+    {
+    md->nllen = 1;
+    md->nl[0] = newline;
+    }
+  }
+
+/* Check a UTF-8 string if required. Unfortunately there's no way of passing
+back the character offset. */
+
+#ifdef SUPPORT_UTF
+if (utf && (options & PCRE_NO_UTF8_CHECK) == 0)
+  {
+  int erroroffset;
+  int errorcode = PRIV(valid_utf)((pcre_uchar *)subject, length, &erroroffset);
+  if (errorcode != 0)
+    {
+    if (offsetcount >= 2)
+      {
+      offsets[0] = erroroffset;
+      offsets[1] = errorcode;
+      }
+#if defined COMPILE_PCRE8
+    return (errorcode <= PCRE_UTF8_ERR5 && (options & PCRE_PARTIAL_HARD) != 0) ?
+      PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
+#elif defined COMPILE_PCRE16
+    return (errorcode <= PCRE_UTF16_ERR1 && (options & PCRE_PARTIAL_HARD) != 0) ?
+      PCRE_ERROR_SHORTUTF16 : PCRE_ERROR_BADUTF16;
+#elif defined COMPILE_PCRE32
+    return PCRE_ERROR_BADUTF32;
+#endif
+    }
+#if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
+  if (start_offset > 0 && start_offset < length &&
+        NOT_FIRSTCHAR(((PCRE_PUCHAR)subject)[start_offset]))
+    return PCRE_ERROR_BADUTF8_OFFSET;
+#endif
+  }
+#endif
+
+/* If the exec call supplied NULL for tables, use the inbuilt ones. This
+is a feature that makes it possible to save compiled regex and re-use them
+in other programs later. */
+
+if (md->tables == NULL) md->tables = PRIV(default_tables);
+
+/* The "must be at the start of a line" flags are used in a loop when finding
+where to start. */
+
+startline = (re->flags & PCRE_STARTLINE) != 0;
+firstline = (re->options & PCRE_FIRSTLINE) != 0;
+
+/* Set up the first character to match, if available. The first_byte value is
+never set for an anchored regular expression, but the anchoring may be forced
+at run time, so we have to test for anchoring. The first char may be unset for
+an unanchored pattern, of course. If there's no first char and the pattern was
+studied, there may be a bitmap of possible first characters. */
+
+if (!anchored)
+  {
+  if ((re->flags & PCRE_FIRSTSET) != 0)
+    {
+    has_first_char = TRUE;
+    first_char = first_char2 = (pcre_uchar)(re->first_char);
+    if ((re->flags & PCRE_FCH_CASELESS) != 0)
+      {
+      first_char2 = TABLE_GET(first_char, md->tables + fcc_offset, first_char);
+#if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
+      if (utf && first_char > 127)
+        first_char2 = UCD_OTHERCASE(first_char);
+#endif
+      }
+    }
+  else
+    {
+    if (!startline && study != NULL &&
+         (study->flags & PCRE_STUDY_MAPPED) != 0)
+      start_bits = study->start_bits;
+    }
+  }
+
+/* For anchored or unanchored matches, there may be a "last known required
+character" set. */
+
+if ((re->flags & PCRE_REQCHSET) != 0)
+  {
+  has_req_char = TRUE;
+  req_char = req_char2 = (pcre_uchar)(re->req_char);
+  if ((re->flags & PCRE_RCH_CASELESS) != 0)
+    {
+    req_char2 = TABLE_GET(req_char, md->tables + fcc_offset, req_char);
+#if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
+    if (utf && req_char > 127)
+      req_char2 = UCD_OTHERCASE(req_char);
+#endif
+    }
+  }
+
+/* Call the main matching function, looping for a non-anchored regex after a
+failed match. If not restarting, perform certain optimizations at the start of
+a match. */
+
+for (;;)
+  {
+  int rc;
+
+  if ((options & PCRE_DFA_RESTART) == 0)
+    {
+    const pcre_uchar *save_end_subject = end_subject;
+
+    /* If firstline is TRUE, the start of the match is constrained to the first
+    line of a multiline string. Implement this by temporarily adjusting
+    end_subject so that we stop scanning at a newline. If the match fails at
+    the newline, later code breaks this loop. */
+
+    if (firstline)
+      {
+      PCRE_PUCHAR t = current_subject;
+#ifdef SUPPORT_UTF
+      if (utf)
+        {
+        while (t < md->end_subject && !IS_NEWLINE(t))
+          {
+          t++;
+          ACROSSCHAR(t < end_subject, *t, t++);
+          }
+        }
+      else
+#endif
+      while (t < md->end_subject && !IS_NEWLINE(t)) t++;
+      end_subject = t;
+      }
+
+    /* There are some optimizations that avoid running the match if a known
+    starting point is not found. However, there is an option that disables
+    these, for testing and for ensuring that all callouts do actually occur.
+    The option can be set in the regex by (*NO_START_OPT) or passed in
+    match-time options. */
+
+    if (((options | re->options) & PCRE_NO_START_OPTIMIZE) == 0)
+      {
+      /* Advance to a known first pcre_uchar (i.e. data item) */
+
+      if (has_first_char)
+        {
+        if (first_char != first_char2)
+          {
+          pcre_uchar csc;
+          while (current_subject < end_subject &&
+                 (csc = UCHAR21TEST(current_subject)) != first_char && csc != first_char2)
+            current_subject++;
+          }
+        else
+          while (current_subject < end_subject &&
+                 UCHAR21TEST(current_subject) != first_char)
+            current_subject++;
+        }
+
+      /* Or to just after a linebreak for a multiline match if possible */
+
+      else if (startline)
+        {
+        if (current_subject > md->start_subject + start_offset)
+          {
+#ifdef SUPPORT_UTF
+          if (utf)
+            {
+            while (current_subject < end_subject &&
+                   !WAS_NEWLINE(current_subject))
+              {
+              current_subject++;
+              ACROSSCHAR(current_subject < end_subject, *current_subject,
+                current_subject++);
+              }
+            }
+          else
+#endif
+          while (current_subject < end_subject && !WAS_NEWLINE(current_subject))
+            current_subject++;
+
+          /* If we have just passed a CR and the newline option is ANY or
+          ANYCRLF, and we are now at a LF, advance the match position by one
+          more character. */
+
+          if (UCHAR21TEST(current_subject - 1) == CHAR_CR &&
+               (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
+               current_subject < end_subject &&
+               UCHAR21TEST(current_subject) == CHAR_NL)
+            current_subject++;
+          }
+        }
+
+      /* Advance to a non-unique first pcre_uchar after study */
+
+      else if (start_bits != NULL)
+        {
+        while (current_subject < end_subject)
+          {
+          register pcre_uint32 c = UCHAR21TEST(current_subject);
+#ifndef COMPILE_PCRE8
+          if (c > 255) c = 255;
+#endif
+          if ((start_bits[c/8] & (1 << (c&7))) != 0) break;
+          current_subject++;
+          }
+        }
+      }
+
+    /* Restore fudged end_subject */
+
+    end_subject = save_end_subject;
+
+    /* The following two optimizations are disabled for partial matching or if
+    disabling is explicitly requested (and of course, by the test above, this
+    code is not obeyed when restarting after a partial match). */
+
+    if (((options | re->options) & PCRE_NO_START_OPTIMIZE) == 0 &&
+        (options & (PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT)) == 0)
+      {
+      /* If the pattern was studied, a minimum subject length may be set. This
+      is a lower bound; no actual string of that length may actually match the
+      pattern. Although the value is, strictly, in characters, we treat it as
+      in pcre_uchar units to avoid spending too much time in this optimization.
+      */
+
+      if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
+          (pcre_uint32)(end_subject - current_subject) < study->minlength)
+        return PCRE_ERROR_NOMATCH;
+
+      /* If req_char is set, we know that that pcre_uchar must appear in the
+      subject for the match to succeed. If the first pcre_uchar is set,
+      req_char must be later in the subject; otherwise the test starts at the
+      match point. This optimization can save a huge amount of work in patterns
+      with nested unlimited repeats that aren't going to match. Writing
+      separate code for cased/caseless versions makes it go faster, as does
+      using an autoincrement and backing off on a match.
+
+      HOWEVER: when the subject string is very, very long, searching to its end
+      can take a long time, and give bad performance on quite ordinary
+      patterns. This showed up when somebody was matching /^C/ on a 32-megabyte
+      string... so we don't do this when the string is sufficiently long. */
+
+      if (has_req_char && end_subject - current_subject < REQ_BYTE_MAX)
+        {
+        register PCRE_PUCHAR p = current_subject + (has_first_char? 1:0);
+
+        /* We don't need to repeat the search if we haven't yet reached the
+        place we found it at last time. */
+
+        if (p > req_char_ptr)
+          {
+          if (req_char != req_char2)
+            {
+            while (p < end_subject)
+              {
+              register pcre_uint32 pp = UCHAR21INCTEST(p);
+              if (pp == req_char || pp == req_char2) { p--; break; }
+              }
+            }
+          else
+            {
+            while (p < end_subject)
+              {
+              if (UCHAR21INCTEST(p) == req_char) { p--; break; }
+              }
+            }
+
+          /* If we can't find the required pcre_uchar, break the matching loop,
+          which will cause a return or PCRE_ERROR_NOMATCH. */
+
+          if (p >= end_subject) break;
+
+          /* If we have found the required pcre_uchar, save the point where we
+          found it, so that we don't search again next time round the loop if
+          the start hasn't passed this point yet. */
+
+          req_char_ptr = p;
+          }
+        }
+      }
+    }   /* End of optimizations that are done when not restarting */
+
+  /* OK, now we can do the business */
+
+  md->start_used_ptr = current_subject;
+  md->recursive = NULL;
+
+  rc = internal_dfa_exec(
+    md,                                /* fixed match data */
+    md->start_code,                    /* this subexpression's code */
+    current_subject,                   /* where we currently are */
+    start_offset,                      /* start offset in subject */
+    offsets,                           /* offset vector */
+    offsetcount,                       /* size of same */
+    workspace,                         /* workspace vector */
+    wscount,                           /* size of same */
+    0);                                /* function recurse level */
+
+  /* Anything other than "no match" means we are done, always; otherwise, carry
+  on only if not anchored. */
+
+  if (rc != PCRE_ERROR_NOMATCH || anchored)
+    {
+    if (rc == PCRE_ERROR_PARTIAL && offsetcount >= 2)
+      {
+      offsets[0] = (int)(md->start_used_ptr - (PCRE_PUCHAR)subject);
+      offsets[1] = (int)(end_subject - (PCRE_PUCHAR)subject);
+      if (offsetcount > 2)
+        offsets[2] = (int)(current_subject - (PCRE_PUCHAR)subject);
+      }
+    return rc;
+    }
+
+  /* Advance to the next subject character unless we are at the end of a line
+  and firstline is set. */
+
+  if (firstline && IS_NEWLINE(current_subject)) break;
+  current_subject++;
+#ifdef SUPPORT_UTF
+  if (utf)
+    {
+    ACROSSCHAR(current_subject < end_subject, *current_subject,
+      current_subject++);
+    }
+#endif
+  if (current_subject > end_subject) break;
+
+  /* If we have just passed a CR and we are now at a LF, and the pattern does
+  not contain any explicit matches for \r or \n, and the newline option is CRLF
+  or ANY or ANYCRLF, advance the match position by one more character. */
+
+  if (UCHAR21TEST(current_subject - 1) == CHAR_CR &&
+      current_subject < end_subject &&
+      UCHAR21TEST(current_subject) == CHAR_NL &&
+      (re->flags & PCRE_HASCRORLF) == 0 &&
+        (md->nltype == NLTYPE_ANY ||
+         md->nltype == NLTYPE_ANYCRLF ||
+         md->nllen == 2))
+    current_subject++;
+
+  }   /* "Bumpalong" loop */
+
+return PCRE_ERROR_NOMATCH;
+}
+
+/* End of pcre_dfa_exec.c */
diff --git a/base/poco/Foundation/src/pcre_exec.c b/base/poco/Foundation/src/pcre_exec.c
new file mode 100644
index 00000000000..c60aad957fd
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_exec.c
@@ -0,0 +1,7174 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2018 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+/* This module contains pcre_exec(), the externally visible function that does
+pattern matching using an NFA algorithm, trying to mimic Perl as closely as
+possible. There are also some static supporting functions. */
+
+#pragma warning( disable : 4127)  // conditional expression is constant
+#pragma warning( disable : 4244)  // conversion from 'int' to 'unsigned short', possible loss of data
+
+#include "pcre_config.h"
+
+#define NLBLOCK md             /* Block containing newline information */
+#define PSSTART start_subject  /* Field containing processed string start */
+#define PSEND   end_subject    /* Field containing processed string end */
+
+#include "pcre_internal.h"
+
+/* Undefine some potentially clashing cpp symbols */
+
+#undef min
+#undef max
+
+/* The md->capture_last field uses the lower 16 bits for the last captured
+substring (which can never be greater than 65535) and a bit in the top half
+to mean "capture vector overflowed". This odd way of doing things was
+implemented when it was realized that preserving and restoring the overflow bit
+whenever the last capture number was saved/restored made for a neater
+interface, and doing it this way saved on (a) another variable, which would
+have increased the stack frame size (a big NO-NO in PCRE) and (b) another
+separate set of save/restore instructions. The following defines are used in
+implementing this. */
+
+#define CAPLMASK    0x0000ffff    /* The bits used for last_capture */
+#define OVFLMASK    0xffff0000    /* The bits used for the overflow flag */
+#define OVFLBIT     0x00010000    /* The bit that is set for overflow */
+
+/* Values for setting in md->match_function_type to indicate two special types
+of call to match(). We do it this way to save on using another stack variable,
+as stack usage is to be discouraged. */
+
+#define MATCH_CONDASSERT     1  /* Called to check a condition assertion */
+#define MATCH_CBEGROUP       2  /* Could-be-empty unlimited repeat group */
+
+/* Non-error returns from the match() function. Error returns are externally
+defined PCRE_ERROR_xxx codes, which are all negative. */
+
+#define MATCH_MATCH        1
+#define MATCH_NOMATCH      0
+
+/* Special internal returns from the match() function. Make them sufficiently
+negative to avoid the external error codes. */
+
+#define MATCH_ACCEPT       (-999)
+#define MATCH_KETRPOS      (-998)
+#define MATCH_ONCE         (-997)
+/* The next 5 must be kept together and in sequence so that a test that checks
+for any one of them can use a range. */
+#define MATCH_COMMIT       (-996)
+#define MATCH_PRUNE        (-995)
+#define MATCH_SKIP         (-994)
+#define MATCH_SKIP_ARG     (-993)
+#define MATCH_THEN         (-992)
+#define MATCH_BACKTRACK_MAX MATCH_THEN
+#define MATCH_BACKTRACK_MIN MATCH_COMMIT
+
+/* Maximum number of ints of offset to save on the stack for recursive calls.
+If the offset vector is bigger, malloc is used. This should be a multiple of 3,
+because the offset vector is always a multiple of 3 long. */
+
+#define REC_STACK_SAVE_MAX 30
+
+/* Min and max values for the common repeats; for the maxima, 0 => infinity */
+
+static const char rep_min[] = { 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, };
+static const char rep_max[] = { 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, };
+
+#ifdef PCRE_DEBUG
+/*************************************************
+*        Debugging function to print chars       *
+*************************************************/
+
+/* Print a sequence of chars in printable format, stopping at the end of the
+subject if the requested.
+
+Arguments:
+  p           points to characters
+  length      number to print
+  is_subject  TRUE if printing from within md->start_subject
+  md          pointer to matching data block, if is_subject is TRUE
+
+Returns:     nothing
+*/
+
+static void
+pchars(const pcre_uchar *p, int length, BOOL is_subject, match_data *md)
+{
+pcre_uint32 c;
+BOOL utf = md->utf;
+if (is_subject && length > md->end_subject - p) length = md->end_subject - p;
+while (length-- > 0)
+  if (isprint(c = UCHAR21INCTEST(p))) printf("%c", (char)c); else printf("\\x{%02x}", c);
+}
+#endif
+
+
+
+/*************************************************
+*          Match a back-reference                *
+*************************************************/
+
+/* Normally, if a back reference hasn't been set, the length that is passed is
+negative, so the match always fails. However, in JavaScript compatibility mode,
+the length passed is zero. Note that in caseless UTF-8 mode, the number of
+subject bytes matched may be different to the number of reference bytes.
+
+Arguments:
+  offset      index into the offset vector
+  eptr        pointer into the subject
+  length      length of reference to be matched (number of bytes)
+  md          points to match data block
+  caseless    TRUE if caseless
+
+Returns:      >= 0 the number of subject bytes matched
+              -1 no match
+              -2 partial match; always given if at end subject
+*/
+
+static int
+match_ref(int offset, register PCRE_PUCHAR eptr, int length, match_data *md,
+  BOOL caseless)
+{
+PCRE_PUCHAR eptr_start = eptr;
+register PCRE_PUCHAR p = md->start_subject + md->offset_vector[offset];
+#if defined SUPPORT_UTF && defined SUPPORT_UCP
+BOOL utf = md->utf;
+#endif
+
+#ifdef PCRE_DEBUG
+if (eptr >= md->end_subject)
+  printf("matching subject <null>");
+else
+  {
+  printf("matching subject ");
+  pchars(eptr, length, TRUE, md);
+  }
+printf(" against backref ");
+pchars(p, length, FALSE, md);
+printf("\n");
+#endif
+
+/* Always fail if reference not set (and not JavaScript compatible - in that
+case the length is passed as zero). */
+
+if (length < 0) return -1;
+
+/* Separate the caseless case for speed. In UTF-8 mode we can only do this
+properly if Unicode properties are supported. Otherwise, we can check only
+ASCII characters. */
+
+if (caseless)
+  {
+#if defined SUPPORT_UTF && defined SUPPORT_UCP
+  if (utf)
+    {
+    /* Match characters up to the end of the reference. NOTE: the number of
+    data units matched may differ, because in UTF-8 there are some characters
+    whose upper and lower case versions code have different numbers of bytes.
+    For example, U+023A (2 bytes in UTF-8) is the upper case version of U+2C65
+    (3 bytes in UTF-8); a sequence of 3 of the former uses 6 bytes, as does a
+    sequence of two of the latter. It is important, therefore, to check the
+    length along the reference, not along the subject (earlier code did this
+    wrong). */
+
+    PCRE_PUCHAR endptr = p + length;
+    while (p < endptr)
+      {
+      pcre_uint32 c, d;
+      const ucd_record *ur;
+      if (eptr >= md->end_subject) return -2;   /* Partial match */
+      GETCHARINC(c, eptr);
+      GETCHARINC(d, p);
+      ur = GET_UCD(d);
+      if (c != d && c != d + ur->other_case)
+        {
+        const pcre_uint32 *pp = PRIV(ucd_caseless_sets) + ur->caseset;
+        for (;;)
+          {
+          if (c < *pp) return -1;
+          if (c == *pp++) break;
+          }
+        }
+      }
+    }
+  else
+#endif
+
+  /* The same code works when not in UTF-8 mode and in UTF-8 mode when there
+  is no UCP support. */
+    {
+    while (length-- > 0)
+      {
+      pcre_uint32 cc, cp;
+      if (eptr >= md->end_subject) return -2;   /* Partial match */
+      cc = UCHAR21TEST(eptr);
+      cp = UCHAR21TEST(p);
+      if (TABLE_GET(cp, md->lcc, cp) != TABLE_GET(cc, md->lcc, cc)) return -1;
+      p++;
+      eptr++;
+      }
+    }
+  }
+
+/* In the caseful case, we can just compare the bytes, whether or not we
+are in UTF-8 mode. */
+
+else
+  {
+  while (length-- > 0)
+    {
+    if (eptr >= md->end_subject) return -2;   /* Partial match */
+    if (UCHAR21INCTEST(p) != UCHAR21INCTEST(eptr)) return -1;
+    }
+  }
+
+return (int)(eptr - eptr_start);
+}
+
+
+
+/***************************************************************************
+****************************************************************************
+                   RECURSION IN THE match() FUNCTION
+
+The match() function is highly recursive, though not every recursive call
+increases the recursive depth. Nevertheless, some regular expressions can cause
+it to recurse to a great depth. I was writing for Unix, so I just let it call
+itself recursively. This uses the stack for saving everything that has to be
+saved for a recursive call. On Unix, the stack can be large, and this works
+fine.
+
+It turns out that on some non-Unix-like systems there are problems with
+programs that use a lot of stack. (This despite the fact that every last chip
+has oodles of memory these days, and techniques for extending the stack have
+been known for decades.) So....
+
+There is a fudge, triggered by defining NO_RECURSE, which avoids recursive
+calls by keeping local variables that need to be preserved in blocks of memory
+obtained from malloc() instead instead of on the stack. Macros are used to
+achieve this so that the actual code doesn't look very different to what it
+always used to.
+
+The original heap-recursive code used longjmp(). However, it seems that this
+can be very slow on some operating systems. Following a suggestion from Stan
+Switzer, the use of longjmp() has been abolished, at the cost of having to
+provide a unique number for each call to RMATCH. There is no way of generating
+a sequence of numbers at compile time in C. I have given them names, to make
+them stand out more clearly.
+
+Crude tests on x86 Linux show a small speedup of around 5-8%. However, on
+FreeBSD, avoiding longjmp() more than halves the time taken to run the standard
+tests. Furthermore, not using longjmp() means that local dynamic variables
+don't have indeterminate values; this has meant that the frame size can be
+reduced because the result can be "passed back" by straight setting of the
+variable instead of being passed in the frame.
+****************************************************************************
+***************************************************************************/
+
+/* Numbers for RMATCH calls. When this list is changed, the code at HEAP_RETURN
+below must be updated in sync.  */
+
+enum { RM1=1, RM2,  RM3,  RM4,  RM5,  RM6,  RM7,  RM8,  RM9,  RM10,
+       RM11,  RM12, RM13, RM14, RM15, RM16, RM17, RM18, RM19, RM20,
+       RM21,  RM22, RM23, RM24, RM25, RM26, RM27, RM28, RM29, RM30,
+       RM31,  RM32, RM33, RM34, RM35, RM36, RM37, RM38, RM39, RM40,
+       RM41,  RM42, RM43, RM44, RM45, RM46, RM47, RM48, RM49, RM50,
+       RM51,  RM52, RM53, RM54, RM55, RM56, RM57, RM58, RM59, RM60,
+       RM61,  RM62, RM63, RM64, RM65, RM66, RM67 };
+
+/* These versions of the macros use the stack, as normal. There are debugging
+versions and production versions. Note that the "rw" argument of RMATCH isn't
+actually used in this definition. */
+
+#ifndef NO_RECURSE
+#define REGISTER register
+
+#ifdef PCRE_DEBUG
+#define RMATCH(ra,rb,rc,rd,re,rw) \
+  { \
+  printf("match() called in line %d\n", __LINE__); \
+  rrc = match(ra,rb,mstart,rc,rd,re,rdepth+1); \
+  printf("to line %d\n", __LINE__); \
+  }
+#define RRETURN(ra) \
+  { \
+  printf("match() returned %d from line %d\n", ra, __LINE__); \
+  return ra; \
+  }
+#else
+#define RMATCH(ra,rb,rc,rd,re,rw) \
+  rrc = match(ra,rb,mstart,rc,rd,re,rdepth+1)
+#define RRETURN(ra) return ra
+#endif
+
+#else
+
+
+/* These versions of the macros manage a private stack on the heap. Note that
+the "rd" argument of RMATCH isn't actually used in this definition. It's the md
+argument of match(), which never changes. */
+
+#define REGISTER
+
+#define RMATCH(ra,rb,rc,rd,re,rw)\
+  {\
+  heapframe *newframe = frame->Xnextframe;\
+  if (newframe == NULL)\
+    {\
+    newframe = (heapframe *)(PUBL(stack_malloc))(sizeof(heapframe));\
+    if (newframe == NULL) RRETURN(PCRE_ERROR_NOMEMORY);\
+    newframe->Xnextframe = NULL;\
+    frame->Xnextframe = newframe;\
+    }\
+  frame->Xwhere = rw;\
+  newframe->Xeptr = ra;\
+  newframe->Xecode = rb;\
+  newframe->Xmstart = mstart;\
+  newframe->Xoffset_top = rc;\
+  newframe->Xeptrb = re;\
+  newframe->Xrdepth = frame->Xrdepth + 1;\
+  newframe->Xprevframe = frame;\
+  frame = newframe;\
+  DPRINTF(("restarting from line %d\n", __LINE__));\
+  goto HEAP_RECURSE;\
+  L_##rw:\
+  DPRINTF(("jumped back to line %d\n", __LINE__));\
+  }
+
+#define RRETURN(ra)\
+  {\
+  heapframe *oldframe = frame;\
+  frame = oldframe->Xprevframe;\
+  if (frame != NULL)\
+    {\
+    rrc = ra;\
+    goto HEAP_RETURN;\
+    }\
+  return ra;\
+  }
+
+
+/* Structure for remembering the local variables in a private frame */
+
+typedef struct heapframe {
+  struct heapframe *Xprevframe;
+  struct heapframe *Xnextframe;
+
+  /* Function arguments that may change */
+
+  PCRE_PUCHAR Xeptr;
+  const pcre_uchar *Xecode;
+  PCRE_PUCHAR Xmstart;
+  int Xoffset_top;
+  eptrblock *Xeptrb;
+  unsigned int Xrdepth;
+
+  /* Function local variables */
+
+  PCRE_PUCHAR Xcallpat;
+#ifdef SUPPORT_UTF
+  PCRE_PUCHAR Xcharptr;
+#endif
+  PCRE_PUCHAR Xdata;
+  PCRE_PUCHAR Xnext;
+  PCRE_PUCHAR Xpp;
+  PCRE_PUCHAR Xprev;
+  PCRE_PUCHAR Xsaved_eptr;
+
+  recursion_info Xnew_recursive;
+
+  BOOL Xcur_is_word;
+  BOOL Xcondition;
+  BOOL Xprev_is_word;
+
+#ifdef SUPPORT_UCP
+  int Xprop_type;
+  unsigned int Xprop_value;
+  int Xprop_fail_result;
+  int Xoclength;
+  pcre_uchar Xocchars[6];
+#endif
+
+  int Xcodelink;
+  int Xctype;
+  unsigned int Xfc;
+  int Xfi;
+  int Xlength;
+  int Xmax;
+  int Xmin;
+  unsigned int Xnumber;
+  int Xoffset;
+  unsigned int Xop;
+  pcre_int32 Xsave_capture_last;
+  int Xsave_offset1, Xsave_offset2, Xsave_offset3;
+  int Xstacksave[REC_STACK_SAVE_MAX];
+
+  eptrblock Xnewptrb;
+
+  /* Where to jump back to */
+
+  int Xwhere;
+
+} heapframe;
+
+#endif
+
+
+/***************************************************************************
+***************************************************************************/
+
+
+
+/*************************************************
+*         Match from current position            *
+*************************************************/
+
+/* This function is called recursively in many circumstances. Whenever it
+returns a negative (error) response, the outer incarnation must also return the
+same response. */
+
+/* These macros pack up tests that are used for partial matching, and which
+appear several times in the code. We set the "hit end" flag if the pointer is
+at the end of the subject and also past the start of the subject (i.e.
+something has been matched). For hard partial matching, we then return
+immediately. The second one is used when we already know we are past the end of
+the subject. */
+
+#define CHECK_PARTIAL()\
+  if (md->partial != 0 && eptr >= md->end_subject && \
+      eptr > md->start_used_ptr) \
+    { \
+    md->hitend = TRUE; \
+    if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL); \
+    }
+
+#define SCHECK_PARTIAL()\
+  if (md->partial != 0 && eptr > md->start_used_ptr) \
+    { \
+    md->hitend = TRUE; \
+    if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL); \
+    }
+
+
+/* Performance note: It might be tempting to extract commonly used fields from
+the md structure (e.g. utf, end_subject) into individual variables to improve
+performance. Tests using gcc on a SPARC disproved this; in the first case, it
+made performance worse.
+
+Arguments:
+   eptr        pointer to current character in subject
+   ecode       pointer to current position in compiled code
+   mstart      pointer to the current match start position (can be modified
+                 by encountering \K)
+   offset_top  current top pointer
+   md          pointer to "static" info for the match
+   eptrb       pointer to chain of blocks containing eptr at start of
+                 brackets - for testing for empty matches
+   rdepth      the recursion depth
+
+Returns:       MATCH_MATCH if matched            )  these values are >= 0
+               MATCH_NOMATCH if failed to match  )
+               a negative MATCH_xxx value for PRUNE, SKIP, etc
+               a negative PCRE_ERROR_xxx value if aborted by an error condition
+                 (e.g. stopped by repeated call or recursion limit)
+*/
+
+static int
+match(REGISTER PCRE_PUCHAR eptr, REGISTER const pcre_uchar *ecode,
+  PCRE_PUCHAR mstart, int offset_top, match_data *md, eptrblock *eptrb,
+  unsigned int rdepth)
+{
+/* These variables do not need to be preserved over recursion in this function,
+so they can be ordinary variables in all cases. Mark some of them with
+"register" because they are used a lot in loops. */
+
+register int  rrc;         /* Returns from recursive calls */
+register int  i;           /* Used for loops not involving calls to RMATCH() */
+register pcre_uint32 c;    /* Character values not kept over RMATCH() calls */
+register BOOL utf;         /* Local copy of UTF flag for speed */
+
+BOOL minimize, possessive; /* Quantifier options */
+BOOL caseless;
+int condcode;
+
+/* When recursion is not being used, all "local" variables that have to be
+preserved over calls to RMATCH() are part of a "frame". We set up the top-level
+frame on the stack here; subsequent instantiations are obtained from the heap
+whenever RMATCH() does a "recursion". See the macro definitions above. Putting
+the top-level on the stack rather than malloc-ing them all gives a performance
+boost in many cases where there is not much "recursion". */
+
+#ifdef NO_RECURSE
+heapframe *frame = (heapframe *)md->match_frames_base;
+
+/* Copy in the original argument variables */
+
+frame->Xeptr = eptr;
+frame->Xecode = ecode;
+frame->Xmstart = mstart;
+frame->Xoffset_top = offset_top;
+frame->Xeptrb = eptrb;
+frame->Xrdepth = rdepth;
+
+/* This is where control jumps back to to effect "recursion" */
+
+HEAP_RECURSE:
+
+/* Macros make the argument variables come from the current frame */
+
+#define eptr               frame->Xeptr
+#define ecode              frame->Xecode
+#define mstart             frame->Xmstart
+#define offset_top         frame->Xoffset_top
+#define eptrb              frame->Xeptrb
+#define rdepth             frame->Xrdepth
+
+/* Ditto for the local variables */
+
+#ifdef SUPPORT_UTF
+#define charptr            frame->Xcharptr
+#endif
+#define callpat            frame->Xcallpat
+#define codelink           frame->Xcodelink
+#define data               frame->Xdata
+#define next               frame->Xnext
+#define pp                 frame->Xpp
+#define prev               frame->Xprev
+#define saved_eptr         frame->Xsaved_eptr
+
+#define new_recursive      frame->Xnew_recursive
+
+#define cur_is_word        frame->Xcur_is_word
+#define condition          frame->Xcondition
+#define prev_is_word       frame->Xprev_is_word
+
+#ifdef SUPPORT_UCP
+#define prop_type          frame->Xprop_type
+#define prop_value         frame->Xprop_value
+#define prop_fail_result   frame->Xprop_fail_result
+#define oclength           frame->Xoclength
+#define occhars            frame->Xocchars
+#endif
+
+#define ctype              frame->Xctype
+#define fc                 frame->Xfc
+#define fi                 frame->Xfi
+#define length             frame->Xlength
+#define max                frame->Xmax
+#define min                frame->Xmin
+#define number             frame->Xnumber
+#define offset             frame->Xoffset
+#define op                 frame->Xop
+#define save_capture_last  frame->Xsave_capture_last
+#define save_offset1       frame->Xsave_offset1
+#define save_offset2       frame->Xsave_offset2
+#define save_offset3       frame->Xsave_offset3
+#define stacksave          frame->Xstacksave
+
+#define newptrb            frame->Xnewptrb
+
+/* When recursion is being used, local variables are allocated on the stack and
+get preserved during recursion in the normal way. In this environment, fi and
+i, and fc and c, can be the same variables. */
+
+#else         /* NO_RECURSE not defined */
+#define fi i
+#define fc c
+
+/* Many of the following variables are used only in small blocks of the code.
+My normal style of coding would have declared them within each of those blocks.
+However, in order to accommodate the version of this code that uses an external
+"stack" implemented on the heap, it is easier to declare them all here, so the
+declarations can be cut out in a block. The only declarations within blocks
+below are for variables that do not have to be preserved over a recursive call
+to RMATCH(). */
+
+#ifdef SUPPORT_UTF
+const pcre_uchar *charptr;
+#endif
+const pcre_uchar *callpat;
+const pcre_uchar *data;
+const pcre_uchar *next;
+PCRE_PUCHAR       pp;
+const pcre_uchar *prev;
+PCRE_PUCHAR       saved_eptr;
+
+recursion_info new_recursive;
+
+BOOL cur_is_word;
+BOOL condition;
+BOOL prev_is_word;
+
+#ifdef SUPPORT_UCP
+int prop_type;
+unsigned int prop_value;
+int prop_fail_result;
+int oclength;
+pcre_uchar occhars[6];
+#endif
+
+int codelink;
+int ctype;
+int length;
+int max;
+int min;
+unsigned int number;
+int offset;
+unsigned int op;
+pcre_int32 save_capture_last;
+int save_offset1, save_offset2, save_offset3;
+int stacksave[REC_STACK_SAVE_MAX];
+
+eptrblock newptrb;
+
+/* There is a special fudge for calling match() in a way that causes it to
+measure the size of its basic stack frame when the stack is being used for
+recursion. The second argument (ecode) being NULL triggers this behaviour. It
+cannot normally ever be NULL. The return is the negated value of the frame
+size. */
+
+if (ecode == NULL)
+  {
+  if (rdepth == 0)
+    return match((PCRE_PUCHAR)&rdepth, NULL, NULL, 0, NULL, NULL, 1);
+  else
+    {
+    int len = (int)((char *)&rdepth - (char *)eptr);
+    return (len > 0)? -len : len;
+    }
+  }
+#endif     /* NO_RECURSE */
+
+/* To save space on the stack and in the heap frame, I have doubled up on some
+of the local variables that are used only in localised parts of the code, but
+still need to be preserved over recursive calls of match(). These macros define
+the alternative names that are used. */
+
+#define allow_zero    cur_is_word
+#define cbegroup      condition
+#define code_offset   codelink
+#define condassert    condition
+#define matched_once  prev_is_word
+#define foc           number
+#define save_mark     data
+
+/* These statements are here to stop the compiler complaining about unitialized
+variables. */
+
+#ifdef SUPPORT_UCP
+prop_value = 0;
+prop_fail_result = 0;
+#endif
+
+
+/* This label is used for tail recursion, which is used in a few cases even
+when NO_RECURSE is not defined, in order to reduce the amount of stack that is
+used. Thanks to Ian Taylor for noticing this possibility and sending the
+original patch. */
+
+TAIL_RECURSE:
+
+/* OK, now we can get on with the real code of the function. Recursive calls
+are specified by the macro RMATCH and RRETURN is used to return. When
+NO_RECURSE is *not* defined, these just turn into a recursive call to match()
+and a "return", respectively (possibly with some debugging if PCRE_DEBUG is
+defined). However, RMATCH isn't like a function call because it's quite a
+complicated macro. It has to be used in one particular way. This shouldn't,
+however, impact performance when true recursion is being used. */
+
+#ifdef SUPPORT_UTF
+utf = md->utf;       /* Local copy of the flag */
+#else
+utf = FALSE;
+#endif
+
+/* First check that we haven't called match() too many times, or that we
+haven't exceeded the recursive call limit. */
+
+if (md->match_call_count++ >= md->match_limit) RRETURN(PCRE_ERROR_MATCHLIMIT);
+if (rdepth >= md->match_limit_recursion) RRETURN(PCRE_ERROR_RECURSIONLIMIT);
+
+/* At the start of a group with an unlimited repeat that may match an empty
+string, the variable md->match_function_type is set to MATCH_CBEGROUP. It is
+done this way to save having to use another function argument, which would take
+up space on the stack. See also MATCH_CONDASSERT below.
+
+When MATCH_CBEGROUP is set, add the current subject pointer to the chain of
+such remembered pointers, to be checked when we hit the closing ket, in order
+to break infinite loops that match no characters. When match() is called in
+other circumstances, don't add to the chain. The MATCH_CBEGROUP feature must
+NOT be used with tail recursion, because the memory block that is used is on
+the stack, so a new one may be required for each match(). */
+
+if (md->match_function_type == MATCH_CBEGROUP)
+  {
+  newptrb.epb_saved_eptr = eptr;
+  newptrb.epb_prev = eptrb;
+  eptrb = &newptrb;
+  md->match_function_type = 0;
+  }
+
+/* Now start processing the opcodes. */
+
+for (;;)
+  {
+  minimize = possessive = FALSE;
+  op = *ecode;
+
+  switch(op)
+    {
+    case OP_MARK:
+    md->nomatch_mark = ecode + 2;
+    md->mark = NULL;    /* In case previously set by assertion */
+    RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top, md,
+      eptrb, RM55);
+    if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
+         md->mark == NULL) md->mark = ecode + 2;
+
+    /* A return of MATCH_SKIP_ARG means that matching failed at SKIP with an
+    argument, and we must check whether that argument matches this MARK's
+    argument. It is passed back in md->start_match_ptr (an overloading of that
+    variable). If it does match, we reset that variable to the current subject
+    position and return MATCH_SKIP. Otherwise, pass back the return code
+    unaltered. */
+
+    else if (rrc == MATCH_SKIP_ARG &&
+        STRCMP_UC_UC_TEST(ecode + 2, md->start_match_ptr) == 0)
+      {
+      md->start_match_ptr = eptr;
+      RRETURN(MATCH_SKIP);
+      }
+    RRETURN(rrc);
+
+    case OP_FAIL:
+    RRETURN(MATCH_NOMATCH);
+
+    case OP_COMMIT:
+    RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
+      eptrb, RM52);
+    if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+    RRETURN(MATCH_COMMIT);
+
+    case OP_PRUNE:
+    RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
+      eptrb, RM51);
+    if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+    RRETURN(MATCH_PRUNE);
+
+    case OP_PRUNE_ARG:
+    md->nomatch_mark = ecode + 2;
+    md->mark = NULL;    /* In case previously set by assertion */
+    RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top, md,
+      eptrb, RM56);
+    if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
+         md->mark == NULL) md->mark = ecode + 2;
+    if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+    RRETURN(MATCH_PRUNE);
+
+    case OP_SKIP:
+    RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
+      eptrb, RM53);
+    if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+    md->start_match_ptr = eptr;   /* Pass back current position */
+    RRETURN(MATCH_SKIP);
+
+    /* Note that, for Perl compatibility, SKIP with an argument does NOT set
+    nomatch_mark. When a pattern match ends with a SKIP_ARG for which there was
+    not a matching mark, we have to re-run the match, ignoring the SKIP_ARG
+    that failed and any that precede it (either they also failed, or were not
+    triggered). To do this, we maintain a count of executed SKIP_ARGs. If a
+    SKIP_ARG gets to top level, the match is re-run with md->ignore_skip_arg
+    set to the count of the one that failed. */
+
+    case OP_SKIP_ARG:
+    md->skip_arg_count++;
+    if (md->skip_arg_count <= md->ignore_skip_arg)
+      {
+      ecode += PRIV(OP_lengths)[*ecode] + ecode[1];
+      break;
+      }
+    RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top, md,
+      eptrb, RM57);
+    if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+
+    /* Pass back the current skip name by overloading md->start_match_ptr and
+    returning the special MATCH_SKIP_ARG return code. This will either be
+    caught by a matching MARK, or get to the top, where it causes a rematch
+    with md->ignore_skip_arg set to the value of md->skip_arg_count. */
+
+    md->start_match_ptr = ecode + 2;
+    RRETURN(MATCH_SKIP_ARG);
+
+    /* For THEN (and THEN_ARG) we pass back the address of the opcode, so that
+    the branch in which it occurs can be determined. Overload the start of
+    match pointer to do this. */
+
+    case OP_THEN:
+    RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
+      eptrb, RM54);
+    if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+    md->start_match_ptr = ecode;
+    RRETURN(MATCH_THEN);
+
+    case OP_THEN_ARG:
+    md->nomatch_mark = ecode + 2;
+    md->mark = NULL;    /* In case previously set by assertion */
+    RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode] + ecode[1], offset_top,
+      md, eptrb, RM58);
+    if ((rrc == MATCH_MATCH || rrc == MATCH_ACCEPT) &&
+         md->mark == NULL) md->mark = ecode + 2;
+    if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+    md->start_match_ptr = ecode;
+    RRETURN(MATCH_THEN);
+
+    /* Handle an atomic group that does not contain any capturing parentheses.
+    This can be handled like an assertion. Prior to 8.13, all atomic groups
+    were handled this way. In 8.13, the code was changed as below for ONCE, so
+    that backups pass through the group and thereby reset captured values.
+    However, this uses a lot more stack, so in 8.20, atomic groups that do not
+    contain any captures generate OP_ONCE_NC, which can be handled in the old,
+    less stack intensive way.
+
+    Check the alternative branches in turn - the matching won't pass the KET
+    for this kind of subpattern. If any one branch matches, we carry on as at
+    the end of a normal bracket, leaving the subject pointer, but resetting
+    the start-of-match value in case it was changed by \K. */
+
+    case OP_ONCE_NC:
+    prev = ecode;
+    saved_eptr = eptr;
+    save_mark = md->mark;
+    do
+      {
+      RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM64);
+      if (rrc == MATCH_MATCH)  /* Note: _not_ MATCH_ACCEPT */
+        {
+        mstart = md->start_match_ptr;
+        break;
+        }
+      if (rrc == MATCH_THEN)
+        {
+        next = ecode + GET(ecode,1);
+        if (md->start_match_ptr < next &&
+            (*ecode == OP_ALT || *next == OP_ALT))
+          rrc = MATCH_NOMATCH;
+        }
+
+      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+      ecode += GET(ecode,1);
+      md->mark = save_mark;
+      }
+    while (*ecode == OP_ALT);
+
+    /* If hit the end of the group (which could be repeated), fail */
+
+    if (*ecode != OP_ONCE_NC && *ecode != OP_ALT) RRETURN(MATCH_NOMATCH);
+
+    /* Continue as from after the group, updating the offsets high water
+    mark, since extracts may have been taken. */
+
+    do ecode += GET(ecode, 1); while (*ecode == OP_ALT);
+
+    offset_top = md->end_offset_top;
+    eptr = md->end_match_ptr;
+
+    /* For a non-repeating ket, just continue at this level. This also
+    happens for a repeating ket if no characters were matched in the group.
+    This is the forcible breaking of infinite loops as implemented in Perl
+    5.005. */
+
+    if (*ecode == OP_KET || eptr == saved_eptr)
+      {
+      ecode += 1+LINK_SIZE;
+      break;
+      }
+
+    /* The repeating kets try the rest of the pattern or restart from the
+    preceding bracket, in the appropriate order. The second "call" of match()
+    uses tail recursion, to avoid using another stack frame. */
+
+    if (*ecode == OP_KETRMIN)
+      {
+      RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM65);
+      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+      ecode = prev;
+      goto TAIL_RECURSE;
+      }
+    else  /* OP_KETRMAX */
+      {
+      RMATCH(eptr, prev, offset_top, md, eptrb, RM66);
+      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+      ecode += 1 + LINK_SIZE;
+      goto TAIL_RECURSE;
+      }
+    /* Control never gets here */
+
+    /* Handle a capturing bracket, other than those that are possessive with an
+    unlimited repeat. If there is space in the offset vector, save the current
+    subject position in the working slot at the top of the vector. We mustn't
+    change the current values of the data slot, because they may be set from a
+    previous iteration of this group, and be referred to by a reference inside
+    the group. A failure to match might occur after the group has succeeded,
+    if something later on doesn't match. For this reason, we need to restore
+    the working value and also the values of the final offsets, in case they
+    were set by a previous iteration of the same bracket.
+
+    If there isn't enough space in the offset vector, treat this as if it were
+    a non-capturing bracket. Don't worry about setting the flag for the error
+    case here; that is handled in the code for KET. */
+
+    case OP_CBRA:
+    case OP_SCBRA:
+    number = GET2(ecode, 1+LINK_SIZE);
+    offset = number << 1;
+
+#ifdef PCRE_DEBUG
+    printf("start bracket %d\n", number);
+    printf("subject=");
+    pchars(eptr, 16, TRUE, md);
+    printf("\n");
+#endif
+
+    if (offset < md->offset_max)
+      {
+      save_offset1 = md->offset_vector[offset];
+      save_offset2 = md->offset_vector[offset+1];
+      save_offset3 = md->offset_vector[md->offset_end - number];
+      save_capture_last = md->capture_last;
+      save_mark = md->mark;
+
+      DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
+      md->offset_vector[md->offset_end - number] =
+        (int)(eptr - md->start_subject);
+
+      for (;;)
+        {
+        if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
+        RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
+          eptrb, RM1);
+        if (rrc == MATCH_ONCE) break;  /* Backing up through an atomic group */
+
+        /* If we backed up to a THEN, check whether it is within the current
+        branch by comparing the address of the THEN that is passed back with
+        the end of the branch. If it is within the current branch, and the
+        branch is one of two or more alternatives (it either starts or ends
+        with OP_ALT), we have reached the limit of THEN's action, so convert
+        the return code to NOMATCH, which will cause normal backtracking to
+        happen from now on. Otherwise, THEN is passed back to an outer
+        alternative. This implements Perl's treatment of parenthesized groups,
+        where a group not containing | does not affect the current alternative,
+        that is, (X) is NOT the same as (X|(*F)). */
+
+        if (rrc == MATCH_THEN)
+          {
+          next = ecode + GET(ecode,1);
+          if (md->start_match_ptr < next &&
+              (*ecode == OP_ALT || *next == OP_ALT))
+            rrc = MATCH_NOMATCH;
+          }
+
+        /* Anything other than NOMATCH is passed back. */
+
+        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        md->capture_last = save_capture_last;
+        ecode += GET(ecode, 1);
+        md->mark = save_mark;
+        if (*ecode != OP_ALT) break;
+        }
+
+      DPRINTF(("bracket %d failed\n", number));
+      md->offset_vector[offset] = save_offset1;
+      md->offset_vector[offset+1] = save_offset2;
+      md->offset_vector[md->offset_end - number] = save_offset3;
+
+      /* At this point, rrc will be one of MATCH_ONCE or MATCH_NOMATCH. */
+
+      RRETURN(rrc);
+      }
+
+    /* FALL THROUGH ... Insufficient room for saving captured contents. Treat
+    as a non-capturing bracket. */
+
+    /* VVVVVVVVVVVVVVVVVVVVVVVVV */
+    /* VVVVVVVVVVVVVVVVVVVVVVVVV */
+
+    DPRINTF(("insufficient capture room: treat as non-capturing\n"));
+
+    /* VVVVVVVVVVVVVVVVVVVVVVVVV */
+    /* VVVVVVVVVVVVVVVVVVVVVVVVV */
+
+    /* Non-capturing or atomic group, except for possessive with unlimited
+    repeat and ONCE group with no captures. Loop for all the alternatives.
+
+    When we get to the final alternative within the brackets, we used to return
+    the result of a recursive call to match() whatever happened so it was
+    possible to reduce stack usage by turning this into a tail recursion,
+    except in the case of a possibly empty group. However, now that there is
+    the possiblity of (*THEN) occurring in the final alternative, this
+    optimization is no longer always possible.
+
+    We can optimize if we know there are no (*THEN)s in the pattern; at present
+    this is the best that can be done.
+
+    MATCH_ONCE is returned when the end of an atomic group is successfully
+    reached, but subsequent matching fails. It passes back up the tree (causing
+    captured values to be reset) until the original atomic group level is
+    reached. This is tested by comparing md->once_target with the start of the
+    group. At this point, the return is converted into MATCH_NOMATCH so that
+    previous backup points can be taken. */
+
+    case OP_ONCE:
+    case OP_BRA:
+    case OP_SBRA:
+    DPRINTF(("start non-capturing bracket\n"));
+
+    for (;;)
+      {
+      if (op >= OP_SBRA || op == OP_ONCE)
+        md->match_function_type = MATCH_CBEGROUP;
+
+      /* If this is not a possibly empty group, and there are no (*THEN)s in
+      the pattern, and this is the final alternative, optimize as described
+      above. */
+
+      else if (!md->hasthen && ecode[GET(ecode, 1)] != OP_ALT)
+        {
+        ecode += PRIV(OP_lengths)[*ecode];
+        goto TAIL_RECURSE;
+        }
+
+      /* In all other cases, we have to make another call to match(). */
+
+      save_mark = md->mark;
+      save_capture_last = md->capture_last;
+      RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md, eptrb,
+        RM2);
+
+      /* See comment in the code for capturing groups above about handling
+      THEN. */
+
+      if (rrc == MATCH_THEN)
+        {
+        next = ecode + GET(ecode,1);
+        if (md->start_match_ptr < next &&
+            (*ecode == OP_ALT || *next == OP_ALT))
+          rrc = MATCH_NOMATCH;
+        }
+
+      if (rrc != MATCH_NOMATCH)
+        {
+        if (rrc == MATCH_ONCE)
+          {
+          const pcre_uchar *scode = ecode;
+          if (*scode != OP_ONCE)           /* If not at start, find it */
+            {
+            while (*scode == OP_ALT) scode += GET(scode, 1);
+            scode -= GET(scode, 1);
+            }
+          if (md->once_target == scode) rrc = MATCH_NOMATCH;
+          }
+        RRETURN(rrc);
+        }
+      ecode += GET(ecode, 1);
+      md->mark = save_mark;
+      if (*ecode != OP_ALT) break;
+      md->capture_last = save_capture_last;
+      }
+
+    RRETURN(MATCH_NOMATCH);
+
+    /* Handle possessive capturing brackets with an unlimited repeat. We come
+    here from BRAZERO with allow_zero set TRUE. The offset_vector values are
+    handled similarly to the normal case above. However, the matching is
+    different. The end of these brackets will always be OP_KETRPOS, which
+    returns MATCH_KETRPOS without going further in the pattern. By this means
+    we can handle the group by iteration rather than recursion, thereby
+    reducing the amount of stack needed. */
+
+    case OP_CBRAPOS:
+    case OP_SCBRAPOS:
+    allow_zero = FALSE;
+
+    POSSESSIVE_CAPTURE:
+    number = GET2(ecode, 1+LINK_SIZE);
+    offset = number << 1;
+
+#ifdef PCRE_DEBUG
+    printf("start possessive bracket %d\n", number);
+    printf("subject=");
+    pchars(eptr, 16, TRUE, md);
+    printf("\n");
+#endif
+
+    if (offset >= md->offset_max) goto POSSESSIVE_NON_CAPTURE;
+
+    matched_once = FALSE;
+    code_offset = (int)(ecode - md->start_code);
+
+    save_offset1 = md->offset_vector[offset];
+    save_offset2 = md->offset_vector[offset+1];
+    save_offset3 = md->offset_vector[md->offset_end - number];
+    save_capture_last = md->capture_last;
+
+    DPRINTF(("saving %d %d %d\n", save_offset1, save_offset2, save_offset3));
+
+    /* Each time round the loop, save the current subject position for use
+    when the group matches. For MATCH_MATCH, the group has matched, so we
+    restart it with a new subject starting position, remembering that we had
+    at least one match. For MATCH_NOMATCH, carry on with the alternatives, as
+    usual. If we haven't matched any alternatives in any iteration, check to
+    see if a previous iteration matched. If so, the group has matched;
+    continue from afterwards. Otherwise it has failed; restore the previous
+    capture values before returning NOMATCH. */
+
+    for (;;)
+      {
+      md->offset_vector[md->offset_end - number] =
+        (int)(eptr - md->start_subject);
+      if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
+      RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
+        eptrb, RM63);
+      if (rrc == MATCH_KETRPOS)
+        {
+        offset_top = md->end_offset_top;
+        ecode = md->start_code + code_offset;
+        save_capture_last = md->capture_last;
+        matched_once = TRUE;
+        mstart = md->start_match_ptr;    /* In case \K changed it */
+        if (eptr == md->end_match_ptr)   /* Matched an empty string */
+          {
+          do ecode += GET(ecode, 1); while (*ecode == OP_ALT);
+          break;
+          }
+        eptr = md->end_match_ptr;
+        continue;
+        }
+
+      /* See comment in the code for capturing groups above about handling
+      THEN. */
+
+      if (rrc == MATCH_THEN)
+        {
+        next = ecode + GET(ecode,1);
+        if (md->start_match_ptr < next &&
+            (*ecode == OP_ALT || *next == OP_ALT))
+          rrc = MATCH_NOMATCH;
+        }
+
+      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+      md->capture_last = save_capture_last;
+      ecode += GET(ecode, 1);
+      if (*ecode != OP_ALT) break;
+      }
+
+    if (!matched_once)
+      {
+      md->offset_vector[offset] = save_offset1;
+      md->offset_vector[offset+1] = save_offset2;
+      md->offset_vector[md->offset_end - number] = save_offset3;
+      }
+
+    if (allow_zero || matched_once)
+      {
+      ecode += 1 + LINK_SIZE;
+      break;
+      }
+
+    RRETURN(MATCH_NOMATCH);
+
+    /* Non-capturing possessive bracket with unlimited repeat. We come here
+    from BRAZERO with allow_zero = TRUE. The code is similar to the above,
+    without the capturing complication. It is written out separately for speed
+    and cleanliness. */
+
+    case OP_BRAPOS:
+    case OP_SBRAPOS:
+    allow_zero = FALSE;
+
+    POSSESSIVE_NON_CAPTURE:
+    matched_once = FALSE;
+    code_offset = (int)(ecode - md->start_code);
+    save_capture_last = md->capture_last;
+
+    for (;;)
+      {
+      if (op >= OP_SBRA) md->match_function_type = MATCH_CBEGROUP;
+      RMATCH(eptr, ecode + PRIV(OP_lengths)[*ecode], offset_top, md,
+        eptrb, RM48);
+      if (rrc == MATCH_KETRPOS)
+        {
+        offset_top = md->end_offset_top;
+        ecode = md->start_code + code_offset;
+        matched_once = TRUE;
+        mstart = md->start_match_ptr;   /* In case \K reset it */
+        if (eptr == md->end_match_ptr)  /* Matched an empty string */
+          {
+          do ecode += GET(ecode, 1); while (*ecode == OP_ALT);
+          break;
+          }
+        eptr = md->end_match_ptr;
+        continue;
+        }
+
+      /* See comment in the code for capturing groups above about handling
+      THEN. */
+
+      if (rrc == MATCH_THEN)
+        {
+        next = ecode + GET(ecode,1);
+        if (md->start_match_ptr < next &&
+            (*ecode == OP_ALT || *next == OP_ALT))
+          rrc = MATCH_NOMATCH;
+        }
+
+      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+      ecode += GET(ecode, 1);
+      if (*ecode != OP_ALT) break;
+      md->capture_last = save_capture_last;
+      }
+
+    if (matched_once || allow_zero)
+      {
+      ecode += 1 + LINK_SIZE;
+      break;
+      }
+    RRETURN(MATCH_NOMATCH);
+
+    /* Control never reaches here. */
+
+    /* Conditional group: compilation checked that there are no more than two
+    branches. If the condition is false, skipping the first branch takes us
+    past the end of the item if there is only one branch, but that's exactly
+    what we want. */
+
+    case OP_COND:
+    case OP_SCOND:
+
+    /* The variable codelink will be added to ecode when the condition is
+    false, to get to the second branch. Setting it to the offset to the ALT
+    or KET, then incrementing ecode achieves this effect. We now have ecode
+    pointing to the condition or callout. */
+
+    codelink = GET(ecode, 1);   /* Offset to the second branch */
+    ecode += 1 + LINK_SIZE;     /* From this opcode */
+
+    /* Because of the way auto-callout works during compile, a callout item is
+    inserted between OP_COND and an assertion condition. */
+
+    if (*ecode == OP_CALLOUT)
+      {
+      if (PUBL(callout) != NULL)
+        {
+        PUBL(callout_block) cb;
+        cb.version          = 2;   /* Version 1 of the callout block */
+        cb.callout_number   = ecode[1];
+        cb.offset_vector    = md->offset_vector;
+#if defined COMPILE_PCRE8
+        cb.subject          = (PCRE_SPTR)md->start_subject;
+#elif defined COMPILE_PCRE16
+        cb.subject          = (PCRE_SPTR16)md->start_subject;
+#elif defined COMPILE_PCRE32
+        cb.subject          = (PCRE_SPTR32)md->start_subject;
+#endif
+        cb.subject_length   = (int)(md->end_subject - md->start_subject);
+        cb.start_match      = (int)(mstart - md->start_subject);
+        cb.current_position = (int)(eptr - md->start_subject);
+        cb.pattern_position = GET(ecode, 2);
+        cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
+        cb.capture_top      = offset_top/2;
+        cb.capture_last     = md->capture_last & CAPLMASK;
+        /* Internal change requires this for API compatibility. */
+        if (cb.capture_last == 0) cb.capture_last = -1;
+        cb.callout_data     = md->callout_data;
+        cb.mark             = md->nomatch_mark;
+        if ((rrc = (*PUBL(callout))(&cb)) > 0) RRETURN(MATCH_NOMATCH);
+        if (rrc < 0) RRETURN(rrc);
+        }
+
+      /* Advance ecode past the callout, so it now points to the condition. We
+      must adjust codelink so that the value of ecode+codelink is unchanged. */
+
+      ecode += PRIV(OP_lengths)[OP_CALLOUT];
+      codelink -= PRIV(OP_lengths)[OP_CALLOUT];
+      }
+
+    /* Test the various possible conditions */
+
+    condition = FALSE;
+    switch(condcode = *ecode)
+      {
+      case OP_RREF:         /* Numbered group recursion test */
+      if (md->recursive != NULL)     /* Not recursing => FALSE */
+        {
+        unsigned int recno = GET2(ecode, 1);   /* Recursion group number*/
+        condition = (recno == RREF_ANY || recno == md->recursive->group_num);
+        }
+      break;
+
+      case OP_DNRREF:       /* Duplicate named group recursion test */
+      if (md->recursive != NULL)
+        {
+        int count = GET2(ecode, 1 + IMM2_SIZE);
+        pcre_uchar *slot = md->name_table + GET2(ecode, 1) * md->name_entry_size;
+        while (count-- > 0)
+          {
+          unsigned int recno = GET2(slot, 0);
+          condition = recno == md->recursive->group_num;
+          if (condition) break;
+          slot += md->name_entry_size;
+          }
+        }
+      break;
+
+      case OP_CREF:         /* Numbered group used test */
+      offset = GET2(ecode, 1) << 1;  /* Doubled ref number */
+      condition = offset < offset_top && md->offset_vector[offset] >= 0;
+      break;
+
+      case OP_DNCREF:      /* Duplicate named group used test */
+        {
+        int count = GET2(ecode, 1 + IMM2_SIZE);
+        pcre_uchar *slot = md->name_table + GET2(ecode, 1) * md->name_entry_size;
+        while (count-- > 0)
+          {
+          offset = GET2(slot, 0) << 1;
+          condition = offset < offset_top && md->offset_vector[offset] >= 0;
+          if (condition) break;
+          slot += md->name_entry_size;
+          }
+        }
+      break;
+
+      case OP_DEF:     /* DEFINE - always false */
+      case OP_FAIL:    /* From optimized (?!) condition */
+      break;
+
+      /* The condition is an assertion. Call match() to evaluate it - setting
+      md->match_function_type to MATCH_CONDASSERT causes it to stop at the end
+      of an assertion. */
+
+      default:
+      md->match_function_type = MATCH_CONDASSERT;
+      RMATCH(eptr, ecode, offset_top, md, NULL, RM3);
+      if (rrc == MATCH_MATCH)
+        {
+        if (md->end_offset_top > offset_top)
+          offset_top = md->end_offset_top;  /* Captures may have happened */
+        condition = TRUE;
+
+        /* Advance ecode past the assertion to the start of the first branch,
+        but adjust it so that the general choosing code below works. If the
+        assertion has a quantifier that allows zero repeats we must skip over
+        the BRAZERO. This is a lunatic thing to do, but somebody did! */
+
+        if (*ecode == OP_BRAZERO) ecode++;
+        ecode += GET(ecode, 1);
+        while (*ecode == OP_ALT) ecode += GET(ecode, 1);
+        ecode += 1 + LINK_SIZE - PRIV(OP_lengths)[condcode];
+        }
+
+      /* PCRE doesn't allow the effect of (*THEN) to escape beyond an
+      assertion; it is therefore treated as NOMATCH. Any other return is an
+      error. */
+
+      else if (rrc != MATCH_NOMATCH && rrc != MATCH_THEN)
+        {
+        RRETURN(rrc);         /* Need braces because of following else */
+        }
+      break;
+      }
+
+    /* Choose branch according to the condition */
+
+    ecode += condition? PRIV(OP_lengths)[condcode] : codelink;
+
+    /* We are now at the branch that is to be obeyed. As there is only one, we
+    can use tail recursion to avoid using another stack frame, except when
+    there is unlimited repeat of a possibly empty group. In the latter case, a
+    recursive call to match() is always required, unless the second alternative
+    doesn't exist, in which case we can just plough on. Note that, for
+    compatibility with Perl, the | in a conditional group is NOT treated as
+    creating two alternatives. If a THEN is encountered in the branch, it
+    propagates out to the enclosing alternative (unless nested in a deeper set
+    of alternatives, of course). */
+
+    if (condition || ecode[-(1+LINK_SIZE)] == OP_ALT)
+      {
+      if (op != OP_SCOND)
+        {
+        goto TAIL_RECURSE;
+        }
+
+      md->match_function_type = MATCH_CBEGROUP;
+      RMATCH(eptr, ecode, offset_top, md, eptrb, RM49);
+      RRETURN(rrc);
+      }
+
+     /* Condition false & no alternative; continue after the group. */
+
+    else
+      {
+      }
+    break;
+
+
+    /* Before OP_ACCEPT there may be any number of OP_CLOSE opcodes,
+    to close any currently open capturing brackets. */
+
+    case OP_CLOSE:
+    number = GET2(ecode, 1);   /* Must be less than 65536 */
+    offset = number << 1;
+
+#ifdef PCRE_DEBUG
+      printf("end bracket %d at *ACCEPT", number);
+      printf("\n");
+#endif
+
+    md->capture_last = (md->capture_last & OVFLMASK) | number;
+    if (offset >= md->offset_max) md->capture_last |= OVFLBIT; else
+      {
+      md->offset_vector[offset] =
+        md->offset_vector[md->offset_end - number];
+      md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
+
+      /* If this group is at or above the current highwater mark, ensure that
+      any groups between the current high water mark and this group are marked
+      unset and then update the high water mark. */
+
+      if (offset >= offset_top)
+        {
+        register int *iptr = md->offset_vector + offset_top;
+        register int *iend = md->offset_vector + offset;
+        while (iptr < iend) *iptr++ = -1;
+        offset_top = offset + 2;
+        }
+      }
+    ecode += 1 + IMM2_SIZE;
+    break;
+
+
+    /* End of the pattern, either real or forced. */
+
+    case OP_END:
+    case OP_ACCEPT:
+    case OP_ASSERT_ACCEPT:
+
+    /* If we have matched an empty string, fail if not in an assertion and not
+    in a recursion if either PCRE_NOTEMPTY is set, or if PCRE_NOTEMPTY_ATSTART
+    is set and we have matched at the start of the subject. In both cases,
+    backtracking will then try other alternatives, if any. */
+
+    if (eptr == mstart && op != OP_ASSERT_ACCEPT &&
+         md->recursive == NULL &&
+         (md->notempty ||
+           (md->notempty_atstart &&
+             mstart == md->start_subject + md->start_offset)))
+      RRETURN(MATCH_NOMATCH);
+
+    /* Otherwise, we have a match. */
+
+    md->end_match_ptr = eptr;           /* Record where we ended */
+    md->end_offset_top = offset_top;    /* and how many extracts were taken */
+    md->start_match_ptr = mstart;       /* and the start (\K can modify) */
+
+    /* For some reason, the macros don't work properly if an expression is
+    given as the argument to RRETURN when the heap is in use. */
+
+    rrc = (op == OP_END)? MATCH_MATCH : MATCH_ACCEPT;
+    RRETURN(rrc);
+
+    /* Assertion brackets. Check the alternative branches in turn - the
+    matching won't pass the KET for an assertion. If any one branch matches,
+    the assertion is true. Lookbehind assertions have an OP_REVERSE item at the
+    start of each branch to move the current point backwards, so the code at
+    this level is identical to the lookahead case. When the assertion is part
+    of a condition, we want to return immediately afterwards. The caller of
+    this incarnation of the match() function will have set MATCH_CONDASSERT in
+    md->match_function type, and one of these opcodes will be the first opcode
+    that is processed. We use a local variable that is preserved over calls to
+    match() to remember this case. */
+
+    case OP_ASSERT:
+    case OP_ASSERTBACK:
+    save_mark = md->mark;
+    if (md->match_function_type == MATCH_CONDASSERT)
+      {
+      condassert = TRUE;
+      md->match_function_type = 0;
+      }
+    else condassert = FALSE;
+
+    /* Loop for each branch */
+
+    do
+      {
+      RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM4);
+
+      /* A match means that the assertion is true; break out of the loop
+      that matches its alternatives. */
+
+      if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
+        {
+        mstart = md->start_match_ptr;   /* In case \K reset it */
+        break;
+        }
+
+      /* If not matched, restore the previous mark setting. */
+
+      md->mark = save_mark;
+
+      /* See comment in the code for capturing groups above about handling
+      THEN. */
+
+      if (rrc == MATCH_THEN)
+        {
+        next = ecode + GET(ecode,1);
+        if (md->start_match_ptr < next &&
+            (*ecode == OP_ALT || *next == OP_ALT))
+          rrc = MATCH_NOMATCH;
+        }
+
+      /* Anything other than NOMATCH causes the entire assertion to fail,
+      passing back the return code. This includes COMMIT, SKIP, PRUNE and an
+      uncaptured THEN, which means they take their normal effect. This
+      consistent approach does not always have exactly the same effect as in
+      Perl. */
+
+      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+      ecode += GET(ecode, 1);
+      }
+    while (*ecode == OP_ALT);   /* Continue for next alternative */
+
+    /* If we have tried all the alternative branches, the assertion has
+    failed. If not, we broke out after a match. */
+
+    if (*ecode == OP_KET) RRETURN(MATCH_NOMATCH);
+
+    /* If checking an assertion for a condition, return MATCH_MATCH. */
+
+    if (condassert) RRETURN(MATCH_MATCH);
+
+    /* Continue from after a successful assertion, updating the offsets high
+    water mark, since extracts may have been taken during the assertion. */
+
+    do ecode += GET(ecode,1); while (*ecode == OP_ALT);
+    ecode += 1 + LINK_SIZE;
+    offset_top = md->end_offset_top;
+    continue;
+
+    /* Negative assertion: all branches must fail to match for the assertion to
+    succeed. */
+
+    case OP_ASSERT_NOT:
+    case OP_ASSERTBACK_NOT:
+    save_mark = md->mark;
+    if (md->match_function_type == MATCH_CONDASSERT)
+      {
+      condassert = TRUE;
+      md->match_function_type = 0;
+      }
+    else condassert = FALSE;
+
+    /* Loop for each alternative branch. */
+
+    do
+      {
+      RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, NULL, RM5);
+      md->mark = save_mark;   /* Always restore the mark setting */
+
+      switch(rrc)
+        {
+        case MATCH_MATCH:            /* A successful match means */
+        case MATCH_ACCEPT:           /* the assertion has failed. */
+        RRETURN(MATCH_NOMATCH);
+
+        case MATCH_NOMATCH:          /* Carry on with next branch */
+        break;
+
+        /* See comment in the code for capturing groups above about handling
+        THEN. */
+
+        case MATCH_THEN:
+        next = ecode + GET(ecode,1);
+        if (md->start_match_ptr < next &&
+            (*ecode == OP_ALT || *next == OP_ALT))
+          {
+          rrc = MATCH_NOMATCH;
+          break;
+          }
+        /* Otherwise fall through. */
+
+        /* COMMIT, SKIP, PRUNE, and an uncaptured THEN cause the whole
+        assertion to fail to match, without considering any more alternatives.
+        Failing to match means the assertion is true. This is a consistent
+        approach, but does not always have the same effect as in Perl. */
+
+        case MATCH_COMMIT:
+        case MATCH_SKIP:
+        case MATCH_SKIP_ARG:
+        case MATCH_PRUNE:
+        do ecode += GET(ecode,1); while (*ecode == OP_ALT);
+        goto NEG_ASSERT_TRUE;   /* Break out of alternation loop */
+
+        /* Anything else is an error */
+
+        default:
+        RRETURN(rrc);
+        }
+
+      /* Continue with next branch */
+
+      ecode += GET(ecode,1);
+      }
+    while (*ecode == OP_ALT);
+
+    /* All branches in the assertion failed to match. */
+
+    NEG_ASSERT_TRUE:
+    if (condassert) RRETURN(MATCH_MATCH);  /* Condition assertion */
+    ecode += 1 + LINK_SIZE;                /* Continue with current branch */
+    continue;
+
+    /* Move the subject pointer back. This occurs only at the start of
+    each branch of a lookbehind assertion. If we are too close to the start to
+    move back, this match function fails. When working with UTF-8 we move
+    back a number of characters, not bytes. */
+
+    case OP_REVERSE:
+#ifdef SUPPORT_UTF
+    if (utf)
+      {
+      i = GET(ecode, 1);
+      while (i-- > 0)
+        {
+        eptr--;
+        if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
+        BACKCHAR(eptr);
+        }
+      }
+    else
+#endif
+
+    /* No UTF-8 support, or not in UTF-8 mode: count is byte count */
+
+      {
+      eptr -= GET(ecode, 1);
+      if (eptr < md->start_subject) RRETURN(MATCH_NOMATCH);
+      }
+
+    /* Save the earliest consulted character, then skip to next op code */
+
+    if (eptr < md->start_used_ptr) md->start_used_ptr = eptr;
+    ecode += 1 + LINK_SIZE;
+    break;
+
+    /* The callout item calls an external function, if one is provided, passing
+    details of the match so far. This is mainly for debugging, though the
+    function is able to force a failure. */
+
+    case OP_CALLOUT:
+    if (PUBL(callout) != NULL)
+      {
+      PUBL(callout_block) cb;
+      cb.version          = 2;   /* Version 1 of the callout block */
+      cb.callout_number   = ecode[1];
+      cb.offset_vector    = md->offset_vector;
+#if defined COMPILE_PCRE8
+      cb.subject          = (PCRE_SPTR)md->start_subject;
+#elif defined COMPILE_PCRE16
+      cb.subject          = (PCRE_SPTR16)md->start_subject;
+#elif defined COMPILE_PCRE32
+      cb.subject          = (PCRE_SPTR32)md->start_subject;
+#endif
+      cb.subject_length   = (int)(md->end_subject - md->start_subject);
+      cb.start_match      = (int)(mstart - md->start_subject);
+      cb.current_position = (int)(eptr - md->start_subject);
+      cb.pattern_position = GET(ecode, 2);
+      cb.next_item_length = GET(ecode, 2 + LINK_SIZE);
+      cb.capture_top      = offset_top/2;
+      cb.capture_last     = md->capture_last & CAPLMASK;
+      /* Internal change requires this for API compatibility. */
+      if (cb.capture_last == 0) cb.capture_last = -1;
+      cb.callout_data     = md->callout_data;
+      cb.mark             = md->nomatch_mark;
+      if ((rrc = (*PUBL(callout))(&cb)) > 0) RRETURN(MATCH_NOMATCH);
+      if (rrc < 0) RRETURN(rrc);
+      }
+    ecode += 2 + 2*LINK_SIZE;
+    break;
+
+    /* Recursion either matches the current regex, or some subexpression. The
+    offset data is the offset to the starting bracket from the start of the
+    whole pattern. (This is so that it works from duplicated subpatterns.)
+
+    The state of the capturing groups is preserved over recursion, and
+    re-instated afterwards. We don't know how many are started and not yet
+    finished (offset_top records the completed total) so we just have to save
+    all the potential data. There may be up to 65535 such values, which is too
+    large to put on the stack, but using malloc for small numbers seems
+    expensive. As a compromise, the stack is used when there are no more than
+    REC_STACK_SAVE_MAX values to store; otherwise malloc is used.
+
+    There are also other values that have to be saved. We use a chained
+    sequence of blocks that actually live on the stack. Thanks to Robin Houston
+    for the original version of this logic. It has, however, been hacked around
+    a lot, so he is not to blame for the current way it works. */
+
+    case OP_RECURSE:
+      {
+      recursion_info *ri;
+      unsigned int recno;
+
+      callpat = md->start_code + GET(ecode, 1);
+      recno = (callpat == md->start_code)? 0 :
+        GET2(callpat, 1 + LINK_SIZE);
+
+      /* Check for repeating a recursion without advancing the subject pointer.
+      This should catch convoluted mutual recursions. (Some simple cases are
+      caught at compile time.) */
+
+      for (ri = md->recursive; ri != NULL; ri = ri->prevrec)
+        if (recno == ri->group_num && eptr == ri->subject_position)
+          RRETURN(PCRE_ERROR_RECURSELOOP);
+
+      /* Add to "recursing stack" */
+
+      new_recursive.group_num = recno;
+      new_recursive.saved_capture_last = md->capture_last;
+      new_recursive.subject_position = eptr;
+      new_recursive.prevrec = md->recursive;
+      md->recursive = &new_recursive;
+
+      /* Where to continue from afterwards */
+
+      ecode += 1 + LINK_SIZE;
+
+      /* Now save the offset data */
+
+      new_recursive.saved_max = md->offset_end;
+      if (new_recursive.saved_max <= REC_STACK_SAVE_MAX)
+        new_recursive.offset_save = stacksave;
+      else
+        {
+        new_recursive.offset_save =
+          (int *)(PUBL(malloc))(new_recursive.saved_max * sizeof(int));
+        if (new_recursive.offset_save == NULL) RRETURN(PCRE_ERROR_NOMEMORY);
+        }
+      memcpy(new_recursive.offset_save, md->offset_vector,
+            new_recursive.saved_max * sizeof(int));
+
+      /* OK, now we can do the recursion. After processing each alternative,
+      restore the offset data and the last captured value. If there were nested
+      recursions, md->recursive might be changed, so reset it before looping.
+      */
+
+      DPRINTF(("Recursing into group %d\n", new_recursive.group_num));
+      cbegroup = (*callpat >= OP_SBRA);
+      do
+        {
+        if (cbegroup) md->match_function_type = MATCH_CBEGROUP;
+        RMATCH(eptr, callpat + PRIV(OP_lengths)[*callpat], offset_top,
+          md, eptrb, RM6);
+        memcpy(md->offset_vector, new_recursive.offset_save,
+            new_recursive.saved_max * sizeof(int));
+        md->capture_last = new_recursive.saved_capture_last;
+        md->recursive = new_recursive.prevrec;
+        if (rrc == MATCH_MATCH || rrc == MATCH_ACCEPT)
+          {
+          DPRINTF(("Recursion matched\n"));
+          if (new_recursive.offset_save != stacksave)
+            (PUBL(free))(new_recursive.offset_save);
+
+          /* Set where we got to in the subject, and reset the start in case
+          it was changed by \K. This *is* propagated back out of a recursion,
+          for Perl compatibility. */
+
+          eptr = md->end_match_ptr;
+          mstart = md->start_match_ptr;
+          goto RECURSION_MATCHED;        /* Exit loop; end processing */
+          }
+
+        /* PCRE does not allow THEN, SKIP, PRUNE or COMMIT to escape beyond a
+        recursion; they cause a NOMATCH for the entire recursion. These codes
+        are defined in a range that can be tested for. */
+
+        if (rrc >= MATCH_BACKTRACK_MIN && rrc <= MATCH_BACKTRACK_MAX)
+          {
+          if (new_recursive.offset_save != stacksave)
+            (PUBL(free))(new_recursive.offset_save);
+          RRETURN(MATCH_NOMATCH);
+          }
+
+        /* Any return code other than NOMATCH is an error. */
+
+        if (rrc != MATCH_NOMATCH)
+          {
+          DPRINTF(("Recursion gave error %d\n", rrc));
+          if (new_recursive.offset_save != stacksave)
+            (PUBL(free))(new_recursive.offset_save);
+          RRETURN(rrc);
+          }
+
+        md->recursive = &new_recursive;
+        callpat += GET(callpat, 1);
+        }
+      while (*callpat == OP_ALT);
+
+      DPRINTF(("Recursion didn't match\n"));
+      md->recursive = new_recursive.prevrec;
+      if (new_recursive.offset_save != stacksave)
+        (PUBL(free))(new_recursive.offset_save);
+      RRETURN(MATCH_NOMATCH);
+      }
+
+    RECURSION_MATCHED:
+    break;
+
+    /* An alternation is the end of a branch; scan along to find the end of the
+    bracketed group and go to there. */
+
+    case OP_ALT:
+    do ecode += GET(ecode,1); while (*ecode == OP_ALT);
+    break;
+
+    /* BRAZERO, BRAMINZERO and SKIPZERO occur just before a bracket group,
+    indicating that it may occur zero times. It may repeat infinitely, or not
+    at all - i.e. it could be ()* or ()? or even (){0} in the pattern. Brackets
+    with fixed upper repeat limits are compiled as a number of copies, with the
+    optional ones preceded by BRAZERO or BRAMINZERO. */
+
+    case OP_BRAZERO:
+    next = ecode + 1;
+    RMATCH(eptr, next, offset_top, md, eptrb, RM10);
+    if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+    do next += GET(next, 1); while (*next == OP_ALT);
+    ecode = next + 1 + LINK_SIZE;
+    break;
+
+    case OP_BRAMINZERO:
+    next = ecode + 1;
+    do next += GET(next, 1); while (*next == OP_ALT);
+    RMATCH(eptr, next + 1+LINK_SIZE, offset_top, md, eptrb, RM11);
+    if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+    ecode++;
+    break;
+
+    case OP_SKIPZERO:
+    next = ecode+1;
+    do next += GET(next,1); while (*next == OP_ALT);
+    ecode = next + 1 + LINK_SIZE;
+    break;
+
+    /* BRAPOSZERO occurs before a possessive bracket group. Don't do anything
+    here; just jump to the group, with allow_zero set TRUE. */
+
+    case OP_BRAPOSZERO:
+    op = *(++ecode);
+    allow_zero = TRUE;
+    if (op == OP_CBRAPOS || op == OP_SCBRAPOS) goto POSSESSIVE_CAPTURE;
+      goto POSSESSIVE_NON_CAPTURE;
+
+    /* End of a group, repeated or non-repeating. */
+
+    case OP_KET:
+    case OP_KETRMIN:
+    case OP_KETRMAX:
+    case OP_KETRPOS:
+    prev = ecode - GET(ecode, 1);
+
+    /* If this was a group that remembered the subject start, in order to break
+    infinite repeats of empty string matches, retrieve the subject start from
+    the chain. Otherwise, set it NULL. */
+
+    if (*prev >= OP_SBRA || *prev == OP_ONCE)
+      {
+      saved_eptr = eptrb->epb_saved_eptr;   /* Value at start of group */
+      eptrb = eptrb->epb_prev;              /* Backup to previous group */
+      }
+    else saved_eptr = NULL;
+
+    /* If we are at the end of an assertion group or a non-capturing atomic
+    group, stop matching and return MATCH_MATCH, but record the current high
+    water mark for use by positive assertions. We also need to record the match
+    start in case it was changed by \K. */
+
+    if ((*prev >= OP_ASSERT && *prev <= OP_ASSERTBACK_NOT) ||
+         *prev == OP_ONCE_NC)
+      {
+      md->end_match_ptr = eptr;      /* For ONCE_NC */
+      md->end_offset_top = offset_top;
+      md->start_match_ptr = mstart;
+      RRETURN(MATCH_MATCH);         /* Sets md->mark */
+      }
+
+    /* For capturing groups we have to check the group number back at the start
+    and if necessary complete handling an extraction by setting the offsets and
+    bumping the high water mark. Whole-pattern recursion is coded as a recurse
+    into group 0, so it won't be picked up here. Instead, we catch it when the
+    OP_END is reached. Other recursion is handled here. We just have to record
+    the current subject position and start match pointer and give a MATCH
+    return. */
+
+    if (*prev == OP_CBRA || *prev == OP_SCBRA ||
+        *prev == OP_CBRAPOS || *prev == OP_SCBRAPOS)
+      {
+      number = GET2(prev, 1+LINK_SIZE);
+      offset = number << 1;
+
+#ifdef PCRE_DEBUG
+      printf("end bracket %d", number);
+      printf("\n");
+#endif
+
+      /* Handle a recursively called group. */
+
+      if (md->recursive != NULL && md->recursive->group_num == number)
+        {
+        md->end_match_ptr = eptr;
+        md->start_match_ptr = mstart;
+        RRETURN(MATCH_MATCH);
+        }
+
+      /* Deal with capturing */
+
+      md->capture_last = (md->capture_last & OVFLMASK) | number;
+      if (offset >= md->offset_max) md->capture_last |= OVFLBIT; else
+        {
+        /* If offset is greater than offset_top, it means that we are
+        "skipping" a capturing group, and that group's offsets must be marked
+        unset. In earlier versions of PCRE, all the offsets were unset at the
+        start of matching, but this doesn't work because atomic groups and
+        assertions can cause a value to be set that should later be unset.
+        Example: matching /(?>(a))b|(a)c/ against "ac". This sets group 1 as
+        part of the atomic group, but this is not on the final matching path,
+        so must be unset when 2 is set. (If there is no group 2, there is no
+        problem, because offset_top will then be 2, indicating no capture.) */
+
+        if (offset > offset_top)
+          {
+          register int *iptr = md->offset_vector + offset_top;
+          register int *iend = md->offset_vector + offset;
+          while (iptr < iend) *iptr++ = -1;
+          }
+
+        /* Now make the extraction */
+
+        md->offset_vector[offset] =
+          md->offset_vector[md->offset_end - number];
+        md->offset_vector[offset+1] = (int)(eptr - md->start_subject);
+        if (offset_top <= offset) offset_top = offset + 2;
+        }
+      }
+
+    /* OP_KETRPOS is a possessive repeating ket. Remember the current position,
+    and return the MATCH_KETRPOS. This makes it possible to do the repeats one
+    at a time from the outer level, thus saving stack. This must precede the
+    empty string test - in this case that test is done at the outer level. */
+
+    if (*ecode == OP_KETRPOS)
+      {
+      md->start_match_ptr = mstart;    /* In case \K reset it */
+      md->end_match_ptr = eptr;
+      md->end_offset_top = offset_top;
+      RRETURN(MATCH_KETRPOS);
+      }
+
+    /* For an ordinary non-repeating ket, just continue at this level. This
+    also happens for a repeating ket if no characters were matched in the
+    group. This is the forcible breaking of infinite loops as implemented in
+    Perl 5.005. For a non-repeating atomic group that includes captures,
+    establish a backup point by processing the rest of the pattern at a lower
+    level. If this results in a NOMATCH return, pass MATCH_ONCE back to the
+    original OP_ONCE level, thereby bypassing intermediate backup points, but
+    resetting any captures that happened along the way. */
+
+    if (*ecode == OP_KET || eptr == saved_eptr)
+      {
+      if (*prev == OP_ONCE)
+        {
+        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM12);
+        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        md->once_target = prev;  /* Level at which to change to MATCH_NOMATCH */
+        RRETURN(MATCH_ONCE);
+        }
+      ecode += 1 + LINK_SIZE;    /* Carry on at this level */
+      break;
+      }
+
+    /* The normal repeating kets try the rest of the pattern or restart from
+    the preceding bracket, in the appropriate order. In the second case, we can
+    use tail recursion to avoid using another stack frame, unless we have an
+    an atomic group or an unlimited repeat of a group that can match an empty
+    string. */
+
+    if (*ecode == OP_KETRMIN)
+      {
+      RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM7);
+      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+      if (*prev == OP_ONCE)
+        {
+        RMATCH(eptr, prev, offset_top, md, eptrb, RM8);
+        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        md->once_target = prev;  /* Level at which to change to MATCH_NOMATCH */
+        RRETURN(MATCH_ONCE);
+        }
+      if (*prev >= OP_SBRA)    /* Could match an empty string */
+        {
+        RMATCH(eptr, prev, offset_top, md, eptrb, RM50);
+        RRETURN(rrc);
+        }
+      ecode = prev;
+      goto TAIL_RECURSE;
+      }
+    else  /* OP_KETRMAX */
+      {
+      RMATCH(eptr, prev, offset_top, md, eptrb, RM13);
+      if (rrc == MATCH_ONCE && md->once_target == prev) rrc = MATCH_NOMATCH;
+      if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+      if (*prev == OP_ONCE)
+        {
+        RMATCH(eptr, ecode + 1 + LINK_SIZE, offset_top, md, eptrb, RM9);
+        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        md->once_target = prev;
+        RRETURN(MATCH_ONCE);
+        }
+      ecode += 1 + LINK_SIZE;
+      goto TAIL_RECURSE;
+      }
+    /* Control never gets here */
+
+    /* Not multiline mode: start of subject assertion, unless notbol. */
+
+    case OP_CIRC:
+    if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);
+
+    /* Start of subject assertion */
+
+    case OP_SOD:
+    if (eptr != md->start_subject) RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    /* Multiline mode: start of subject unless notbol, or after any newline. */
+
+    case OP_CIRCM:
+    if (md->notbol && eptr == md->start_subject) RRETURN(MATCH_NOMATCH);
+    if (eptr != md->start_subject &&
+        (eptr == md->end_subject || !WAS_NEWLINE(eptr)))
+      RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    /* Start of match assertion */
+
+    case OP_SOM:
+    if (eptr != md->start_subject + md->start_offset) RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    /* Reset the start of match point */
+
+    case OP_SET_SOM:
+    mstart = eptr;
+    ecode++;
+    break;
+
+    /* Multiline mode: assert before any newline, or before end of subject
+    unless noteol is set. */
+
+    case OP_DOLLM:
+    if (eptr < md->end_subject)
+      {
+      if (!IS_NEWLINE(eptr))
+        {
+        if (md->partial != 0 &&
+            eptr + 1 >= md->end_subject &&
+            NLBLOCK->nltype == NLTYPE_FIXED &&
+            NLBLOCK->nllen == 2 &&
+            UCHAR21TEST(eptr) == NLBLOCK->nl[0])
+          {
+          md->hitend = TRUE;
+          if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
+          }
+        RRETURN(MATCH_NOMATCH);
+        }
+      }
+    else
+      {
+      if (md->noteol) RRETURN(MATCH_NOMATCH);
+      SCHECK_PARTIAL();
+      }
+    ecode++;
+    break;
+
+    /* Not multiline mode: assert before a terminating newline or before end of
+    subject unless noteol is set. */
+
+    case OP_DOLL:
+    if (md->noteol) RRETURN(MATCH_NOMATCH);
+    if (!md->endonly) goto ASSERT_NL_OR_EOS;
+
+    /* ... else fall through for endonly */
+
+    /* End of subject assertion (\z) */
+
+    case OP_EOD:
+    if (eptr < md->end_subject) RRETURN(MATCH_NOMATCH);
+    SCHECK_PARTIAL();
+    ecode++;
+    break;
+
+    /* End of subject or ending \n assertion (\Z) */
+
+    case OP_EODN:
+    ASSERT_NL_OR_EOS:
+    if (eptr < md->end_subject &&
+        (!IS_NEWLINE(eptr) || eptr != md->end_subject - md->nllen))
+      {
+      if (md->partial != 0 &&
+          eptr + 1 >= md->end_subject &&
+          NLBLOCK->nltype == NLTYPE_FIXED &&
+          NLBLOCK->nllen == 2 &&
+          UCHAR21TEST(eptr) == NLBLOCK->nl[0])
+        {
+        md->hitend = TRUE;
+        if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
+        }
+      RRETURN(MATCH_NOMATCH);
+      }
+
+    /* Either at end of string or \n before end. */
+
+    SCHECK_PARTIAL();
+    ecode++;
+    break;
+
+    /* Word boundary assertions */
+
+    case OP_NOT_WORD_BOUNDARY:
+    case OP_WORD_BOUNDARY:
+      {
+
+      /* Find out if the previous and current characters are "word" characters.
+      It takes a bit more work in UTF-8 mode. Characters > 255 are assumed to
+      be "non-word" characters. Remember the earliest consulted character for
+      partial matching. */
+
+#ifdef SUPPORT_UTF
+      if (utf)
+        {
+        /* Get status of previous character */
+
+        if (eptr == md->start_subject) prev_is_word = FALSE; else
+          {
+          PCRE_PUCHAR lastptr = eptr - 1;
+          BACKCHAR(lastptr);
+          if (lastptr < md->start_used_ptr) md->start_used_ptr = lastptr;
+          GETCHAR(c, lastptr);
+#ifdef SUPPORT_UCP
+          if (md->use_ucp)
+            {
+            if (c == '_') prev_is_word = TRUE; else
+              {
+              int cat = UCD_CATEGORY(c);
+              prev_is_word = (cat == ucp_L || cat == ucp_N);
+              }
+            }
+          else
+#endif
+          prev_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
+          }
+
+        /* Get status of next character */
+
+        if (eptr >= md->end_subject)
+          {
+          SCHECK_PARTIAL();
+          cur_is_word = FALSE;
+          }
+        else
+          {
+          GETCHAR(c, eptr);
+#ifdef SUPPORT_UCP
+          if (md->use_ucp)
+            {
+            if (c == '_') cur_is_word = TRUE; else
+              {
+              int cat = UCD_CATEGORY(c);
+              cur_is_word = (cat == ucp_L || cat == ucp_N);
+              }
+            }
+          else
+#endif
+          cur_is_word = c < 256 && (md->ctypes[c] & ctype_word) != 0;
+          }
+        }
+      else
+#endif
+
+      /* Not in UTF-8 mode, but we may still have PCRE_UCP set, and for
+      consistency with the behaviour of \w we do use it in this case. */
+
+        {
+        /* Get status of previous character */
+
+        if (eptr == md->start_subject) prev_is_word = FALSE; else
+          {
+          if (eptr <= md->start_used_ptr) md->start_used_ptr = eptr - 1;
+#ifdef SUPPORT_UCP
+          if (md->use_ucp)
+            {
+            c = eptr[-1];
+            if (c == '_') prev_is_word = TRUE; else
+              {
+              int cat = UCD_CATEGORY(c);
+              prev_is_word = (cat == ucp_L || cat == ucp_N);
+              }
+            }
+          else
+#endif
+          prev_is_word = MAX_255(eptr[-1])
+            && ((md->ctypes[eptr[-1]] & ctype_word) != 0);
+          }
+
+        /* Get status of next character */
+
+        if (eptr >= md->end_subject)
+          {
+          SCHECK_PARTIAL();
+          cur_is_word = FALSE;
+          }
+        else
+#ifdef SUPPORT_UCP
+        if (md->use_ucp)
+          {
+          c = *eptr;
+          if (c == '_') cur_is_word = TRUE; else
+            {
+            int cat = UCD_CATEGORY(c);
+            cur_is_word = (cat == ucp_L || cat == ucp_N);
+            }
+          }
+        else
+#endif
+        cur_is_word = MAX_255(*eptr)
+          && ((md->ctypes[*eptr] & ctype_word) != 0);
+        }
+
+      /* Now see if the situation is what we want */
+
+      if ((*ecode++ == OP_WORD_BOUNDARY)?
+           cur_is_word == prev_is_word : cur_is_word != prev_is_word)
+        RRETURN(MATCH_NOMATCH);
+      }
+    break;
+
+    /* Match any single character type except newline; have to take care with
+    CRLF newlines and partial matching. */
+
+    case OP_ANY:
+    if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
+    if (md->partial != 0 &&
+        eptr == md->end_subject - 1 &&
+        NLBLOCK->nltype == NLTYPE_FIXED &&
+        NLBLOCK->nllen == 2 &&
+        UCHAR21TEST(eptr) == NLBLOCK->nl[0])
+      {
+      md->hitend = TRUE;
+      if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
+      }
+
+    /* Fall through */
+
+    /* Match any single character whatsoever. */
+
+    case OP_ALLANY:
+    if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */
+      {                            /* not be updated before SCHECK_PARTIAL. */
+      SCHECK_PARTIAL();
+      RRETURN(MATCH_NOMATCH);
+      }
+    eptr++;
+#ifdef SUPPORT_UTF
+    if (utf) ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
+#endif
+    ecode++;
+    break;
+
+    /* Match a single byte, even in UTF-8 mode. This opcode really does match
+    any byte, even newline, independent of the setting of PCRE_DOTALL. */
+
+    case OP_ANYBYTE:
+    if (eptr >= md->end_subject)   /* DO NOT merge the eptr++ here; it must */
+      {                            /* not be updated before SCHECK_PARTIAL. */
+      SCHECK_PARTIAL();
+      RRETURN(MATCH_NOMATCH);
+      }
+    eptr++;
+    ecode++;
+    break;
+
+    case OP_NOT_DIGIT:
+    if (eptr >= md->end_subject)
+      {
+      SCHECK_PARTIAL();
+      RRETURN(MATCH_NOMATCH);
+      }
+    GETCHARINCTEST(c, eptr);
+    if (
+#if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
+       c < 256 &&
+#endif
+       (md->ctypes[c] & ctype_digit) != 0
+       )
+      RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    case OP_DIGIT:
+    if (eptr >= md->end_subject)
+      {
+      SCHECK_PARTIAL();
+      RRETURN(MATCH_NOMATCH);
+      }
+    GETCHARINCTEST(c, eptr);
+    if (
+#if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
+       c > 255 ||
+#endif
+       (md->ctypes[c] & ctype_digit) == 0
+       )
+      RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    case OP_NOT_WHITESPACE:
+    if (eptr >= md->end_subject)
+      {
+      SCHECK_PARTIAL();
+      RRETURN(MATCH_NOMATCH);
+      }
+    GETCHARINCTEST(c, eptr);
+    if (
+#if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
+       c < 256 &&
+#endif
+       (md->ctypes[c] & ctype_space) != 0
+       )
+      RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    case OP_WHITESPACE:
+    if (eptr >= md->end_subject)
+      {
+      SCHECK_PARTIAL();
+      RRETURN(MATCH_NOMATCH);
+      }
+    GETCHARINCTEST(c, eptr);
+    if (
+#if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
+       c > 255 ||
+#endif
+       (md->ctypes[c] & ctype_space) == 0
+       )
+      RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    case OP_NOT_WORDCHAR:
+    if (eptr >= md->end_subject)
+      {
+      SCHECK_PARTIAL();
+      RRETURN(MATCH_NOMATCH);
+      }
+    GETCHARINCTEST(c, eptr);
+    if (
+#if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
+       c < 256 &&
+#endif
+       (md->ctypes[c] & ctype_word) != 0
+       )
+      RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    case OP_WORDCHAR:
+    if (eptr >= md->end_subject)
+      {
+      SCHECK_PARTIAL();
+      RRETURN(MATCH_NOMATCH);
+      }
+    GETCHARINCTEST(c, eptr);
+    if (
+#if defined SUPPORT_UTF || !(defined COMPILE_PCRE8)
+       c > 255 ||
+#endif
+       (md->ctypes[c] & ctype_word) == 0
+       )
+      RRETURN(MATCH_NOMATCH);
+    ecode++;
+    break;
+
+    case OP_ANYNL:
+    if (eptr >= md->end_subject)
+      {
+      SCHECK_PARTIAL();
+      RRETURN(MATCH_NOMATCH);
+      }
+    GETCHARINCTEST(c, eptr);
+    switch(c)
+      {
+      default: RRETURN(MATCH_NOMATCH);
+
+      case CHAR_CR:
+      if (eptr >= md->end_subject)
+        {
+        SCHECK_PARTIAL();
+        }
+      else if (UCHAR21TEST(eptr) == CHAR_LF) eptr++;
+      break;
+
+      case CHAR_LF:
+      break;
+
+      case CHAR_VT:
+      case CHAR_FF:
+      case CHAR_NEL:
+#ifndef EBCDIC
+      case 0x2028:
+      case 0x2029:
+#endif  /* Not EBCDIC */
+      if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+      break;
+      }
+    ecode++;
+    break;
+
+    case OP_NOT_HSPACE:
+    if (eptr >= md->end_subject)
+      {
+      SCHECK_PARTIAL();
+      RRETURN(MATCH_NOMATCH);
+      }
+    GETCHARINCTEST(c, eptr);
+    switch(c)
+      {
+      HSPACE_CASES: RRETURN(MATCH_NOMATCH);  /* Byte and multibyte cases */
+      default: break;
+      }
+    ecode++;
+    break;
+
+    case OP_HSPACE:
+    if (eptr >= md->end_subject)
+      {
+      SCHECK_PARTIAL();
+      RRETURN(MATCH_NOMATCH);
+      }
+    GETCHARINCTEST(c, eptr);
+    switch(c)
+      {
+      HSPACE_CASES: break;  /* Byte and multibyte cases */
+      default: RRETURN(MATCH_NOMATCH);
+      }
+    ecode++;
+    break;
+
+    case OP_NOT_VSPACE:
+    if (eptr >= md->end_subject)
+      {
+      SCHECK_PARTIAL();
+      RRETURN(MATCH_NOMATCH);
+      }
+    GETCHARINCTEST(c, eptr);
+    switch(c)
+      {
+      VSPACE_CASES: RRETURN(MATCH_NOMATCH);
+      default: break;
+      }
+    ecode++;
+    break;
+
+    case OP_VSPACE:
+    if (eptr >= md->end_subject)
+      {
+      SCHECK_PARTIAL();
+      RRETURN(MATCH_NOMATCH);
+      }
+    GETCHARINCTEST(c, eptr);
+    switch(c)
+      {
+      VSPACE_CASES: break;
+      default: RRETURN(MATCH_NOMATCH);
+      }
+    ecode++;
+    break;
+
+#ifdef SUPPORT_UCP
+    /* Check the next character by Unicode property. We will get here only
+    if the support is in the binary; otherwise a compile-time error occurs. */
+
+    case OP_PROP:
+    case OP_NOTPROP:
+    if (eptr >= md->end_subject)
+      {
+      SCHECK_PARTIAL();
+      RRETURN(MATCH_NOMATCH);
+      }
+    GETCHARINCTEST(c, eptr);
+      {
+      const pcre_uint32 *cp;
+      const ucd_record *prop = GET_UCD(c);
+
+      switch(ecode[1])
+        {
+        case PT_ANY:
+        if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);
+        break;
+
+        case PT_LAMP:
+        if ((prop->chartype == ucp_Lu ||
+             prop->chartype == ucp_Ll ||
+             prop->chartype == ucp_Lt) == (op == OP_NOTPROP))
+          RRETURN(MATCH_NOMATCH);
+        break;
+
+        case PT_GC:
+        if ((ecode[2] != PRIV(ucp_gentype)[prop->chartype]) == (op == OP_PROP))
+          RRETURN(MATCH_NOMATCH);
+        break;
+
+        case PT_PC:
+        if ((ecode[2] != prop->chartype) == (op == OP_PROP))
+          RRETURN(MATCH_NOMATCH);
+        break;
+
+        case PT_SC:
+        if ((ecode[2] != prop->script) == (op == OP_PROP))
+          RRETURN(MATCH_NOMATCH);
+        break;
+
+        /* These are specials */
+
+        case PT_ALNUM:
+        if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
+             PRIV(ucp_gentype)[prop->chartype] == ucp_N) == (op == OP_NOTPROP))
+          RRETURN(MATCH_NOMATCH);
+        break;
+
+        /* Perl space used to exclude VT, but from Perl 5.18 it is included,
+        which means that Perl space and POSIX space are now identical. PCRE
+        was changed at release 8.34. */
+
+        case PT_SPACE:    /* Perl space */
+        case PT_PXSPACE:  /* POSIX space */
+        switch(c)
+          {
+          HSPACE_CASES:
+          VSPACE_CASES:
+          if (op == OP_NOTPROP) RRETURN(MATCH_NOMATCH);
+          break;
+
+          default:
+          if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z) ==
+            (op == OP_NOTPROP)) RRETURN(MATCH_NOMATCH);
+          break;
+          }
+        break;
+
+        case PT_WORD:
+        if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
+             PRIV(ucp_gentype)[prop->chartype] == ucp_N ||
+             c == CHAR_UNDERSCORE) == (op == OP_NOTPROP))
+          RRETURN(MATCH_NOMATCH);
+        break;
+
+        case PT_CLIST:
+        cp = PRIV(ucd_caseless_sets) + ecode[2];
+        for (;;)
+          {
+          if (c < *cp)
+            { if (op == OP_PROP) { RRETURN(MATCH_NOMATCH); } else break; }
+          if (c == *cp++)
+            { if (op == OP_PROP) break; else { RRETURN(MATCH_NOMATCH); } }
+          }
+        break;
+
+        case PT_UCNC:
+        if ((c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
+             c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
+             c >= 0xe000) == (op == OP_NOTPROP))
+          RRETURN(MATCH_NOMATCH);
+        break;
+
+        /* This should never occur */
+
+        default:
+        RRETURN(PCRE_ERROR_INTERNAL);
+        }
+
+      ecode += 3;
+      }
+    break;
+
+    /* Match an extended Unicode sequence. We will get here only if the support
+    is in the binary; otherwise a compile-time error occurs. */
+
+    case OP_EXTUNI:
+    if (eptr >= md->end_subject)
+      {
+      SCHECK_PARTIAL();
+      RRETURN(MATCH_NOMATCH);
+      }
+    else
+      {
+      int lgb, rgb;
+      GETCHARINCTEST(c, eptr);
+      lgb = UCD_GRAPHBREAK(c);
+      while (eptr < md->end_subject)
+        {
+        int len = 1;
+        if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
+        rgb = UCD_GRAPHBREAK(c);
+        if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
+        lgb = rgb;
+        eptr += len;
+        }
+      }
+    CHECK_PARTIAL();
+    ecode++;
+    break;
+#endif  /* SUPPORT_UCP */
+
+
+    /* Match a back reference, possibly repeatedly. Look past the end of the
+    item to see if there is repeat information following. The code is similar
+    to that for character classes, but repeated for efficiency. Then obey
+    similar code to character type repeats - written out again for speed.
+    However, if the referenced string is the empty string, always treat
+    it as matched, any number of times (otherwise there could be infinite
+    loops). If the reference is unset, there are two possibilities:
+
+    (a) In the default, Perl-compatible state, set the length negative;
+    this ensures that every attempt at a match fails. We can't just fail
+    here, because of the possibility of quantifiers with zero minima.
+
+    (b) If the JavaScript compatibility flag is set, set the length to zero
+    so that the back reference matches an empty string.
+
+    Otherwise, set the length to the length of what was matched by the
+    referenced subpattern.
+
+    The OP_REF and OP_REFI opcodes are used for a reference to a numbered group
+    or to a non-duplicated named group. For a duplicated named group, OP_DNREF
+    and OP_DNREFI are used. In this case we must scan the list of groups to
+    which the name refers, and use the first one that is set. */
+
+    case OP_DNREF:
+    case OP_DNREFI:
+    caseless = op == OP_DNREFI;
+      {
+      int count = GET2(ecode, 1+IMM2_SIZE);
+      pcre_uchar *slot = md->name_table + GET2(ecode, 1) * md->name_entry_size;
+      ecode += 1 + 2*IMM2_SIZE;
+
+      /* Setting the default length first and initializing 'offset' avoids
+      compiler warnings in the REF_REPEAT code. */
+
+      length = (md->jscript_compat)? 0 : -1;
+      offset = 0;
+
+      while (count-- > 0)
+        {
+        offset = GET2(slot, 0) << 1;
+        if (offset < offset_top && md->offset_vector[offset] >= 0)
+          {
+          length = md->offset_vector[offset+1] - md->offset_vector[offset];
+          break;
+          }
+        slot += md->name_entry_size;
+        }
+      }
+    goto REF_REPEAT;
+
+    case OP_REF:
+    case OP_REFI:
+    caseless = op == OP_REFI;
+    offset = GET2(ecode, 1) << 1;               /* Doubled ref number */
+    ecode += 1 + IMM2_SIZE;
+    if (offset >= offset_top || md->offset_vector[offset] < 0)
+      length = (md->jscript_compat)? 0 : -1;
+    else
+      length = md->offset_vector[offset+1] - md->offset_vector[offset];
+
+    /* Set up for repetition, or handle the non-repeated case */
+
+    REF_REPEAT:
+    switch (*ecode)
+      {
+      case OP_CRSTAR:
+      case OP_CRMINSTAR:
+      case OP_CRPLUS:
+      case OP_CRMINPLUS:
+      case OP_CRQUERY:
+      case OP_CRMINQUERY:
+      c = *ecode++ - OP_CRSTAR;
+      minimize = (c & 1) != 0;
+      min = rep_min[c];                 /* Pick up values from tables; */
+      max = rep_max[c];                 /* zero for max => infinity */
+      if (max == 0) max = INT_MAX;
+      break;
+
+      case OP_CRRANGE:
+      case OP_CRMINRANGE:
+      minimize = (*ecode == OP_CRMINRANGE);
+      min = GET2(ecode, 1);
+      max = GET2(ecode, 1 + IMM2_SIZE);
+      if (max == 0) max = INT_MAX;
+      ecode += 1 + 2 * IMM2_SIZE;
+      break;
+
+      default:               /* No repeat follows */
+      if ((length = match_ref(offset, eptr, length, md, caseless)) < 0)
+        {
+        if (length == -2) eptr = md->end_subject;   /* Partial match */
+        CHECK_PARTIAL();
+        RRETURN(MATCH_NOMATCH);
+        }
+      eptr += length;
+      continue;              /* With the main loop */
+      }
+
+    /* Handle repeated back references. If the length of the reference is
+    zero, just continue with the main loop. If the length is negative, it
+    means the reference is unset in non-Java-compatible mode. If the minimum is
+    zero, we can continue at the same level without recursion. For any other
+    minimum, carrying on will result in NOMATCH. */
+
+    if (length == 0) continue;
+    if (length < 0 && min == 0) continue;
+
+    /* First, ensure the minimum number of matches are present. We get back
+    the length of the reference string explicitly rather than passing the
+    address of eptr, so that eptr can be a register variable. */
+
+    for (i = 1; i <= min; i++)
+      {
+      int slength;
+      if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
+        {
+        if (slength == -2) eptr = md->end_subject;   /* Partial match */
+        CHECK_PARTIAL();
+        RRETURN(MATCH_NOMATCH);
+        }
+      eptr += slength;
+      }
+
+    /* If min = max, continue at the same level without recursion.
+    They are not both allowed to be zero. */
+
+    if (min == max) continue;
+
+    /* If minimizing, keep trying and advancing the pointer */
+
+    if (minimize)
+      {
+      for (fi = min;; fi++)
+        {
+        int slength;
+        RMATCH(eptr, ecode, offset_top, md, eptrb, RM14);
+        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        if (fi >= max) RRETURN(MATCH_NOMATCH);
+        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
+          {
+          if (slength == -2) eptr = md->end_subject;   /* Partial match */
+          CHECK_PARTIAL();
+          RRETURN(MATCH_NOMATCH);
+          }
+        eptr += slength;
+        }
+      /* Control never gets here */
+      }
+
+    /* If maximizing, find the longest string and work backwards */
+
+    else
+      {
+      pp = eptr;
+      for (i = min; i < max; i++)
+        {
+        int slength;
+        if ((slength = match_ref(offset, eptr, length, md, caseless)) < 0)
+          {
+          /* Can't use CHECK_PARTIAL because we don't want to update eptr in
+          the soft partial matching case. */
+
+          if (slength == -2 && md->partial != 0 &&
+              md->end_subject > md->start_used_ptr)
+            {
+            md->hitend = TRUE;
+            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
+            }
+          break;
+          }
+        eptr += slength;
+        }
+
+      while (eptr >= pp)
+        {
+        RMATCH(eptr, ecode, offset_top, md, eptrb, RM15);
+        if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+        eptr -= length;
+        }
+      RRETURN(MATCH_NOMATCH);
+      }
+    /* Control never gets here */
+
+    /* Match a bit-mapped character class, possibly repeatedly. This op code is
+    used when all the characters in the class have values in the range 0-255,
+    and either the matching is caseful, or the characters are in the range
+    0-127 when UTF-8 processing is enabled. The only difference between
+    OP_CLASS and OP_NCLASS occurs when a data character outside the range is
+    encountered.
+
+    First, look past the end of the item to see if there is repeat information
+    following. Then obey similar code to character type repeats - written out
+    again for speed. */
+
+    case OP_NCLASS:
+    case OP_CLASS:
+      {
+      /* The data variable is saved across frames, so the byte map needs to
+      be stored there. */
+#define BYTE_MAP ((pcre_uint8 *)data)
+      data = ecode + 1;                /* Save for matching */
+      ecode += 1 + (32 / sizeof(pcre_uchar)); /* Advance past the item */
+
+      switch (*ecode)
+        {
+        case OP_CRSTAR:
+        case OP_CRMINSTAR:
+        case OP_CRPLUS:
+        case OP_CRMINPLUS:
+        case OP_CRQUERY:
+        case OP_CRMINQUERY:
+        case OP_CRPOSSTAR:
+        case OP_CRPOSPLUS:
+        case OP_CRPOSQUERY:
+        c = *ecode++ - OP_CRSTAR;
+        if (c < OP_CRPOSSTAR - OP_CRSTAR) minimize = (c & 1) != 0;
+        else possessive = TRUE;
+        min = rep_min[c];                 /* Pick up values from tables; */
+        max = rep_max[c];                 /* zero for max => infinity */
+        if (max == 0) max = INT_MAX;
+        break;
+
+        case OP_CRRANGE:
+        case OP_CRMINRANGE:
+        case OP_CRPOSRANGE:
+        minimize = (*ecode == OP_CRMINRANGE);
+        possessive = (*ecode == OP_CRPOSRANGE);
+        min = GET2(ecode, 1);
+        max = GET2(ecode, 1 + IMM2_SIZE);
+        if (max == 0) max = INT_MAX;
+        ecode += 1 + 2 * IMM2_SIZE;
+        break;
+
+        default:               /* No repeat follows */
+        min = max = 1;
+        break;
+        }
+
+      /* First, ensure the minimum number of matches are present. */
+
+#ifdef SUPPORT_UTF
+      if (utf)
+        {
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          GETCHARINC(c, eptr);
+          if (c > 255)
+            {
+            if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
+            }
+          else
+            if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
+          }
+        }
+      else
+#endif
+      /* Not UTF mode */
+        {
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          c = *eptr++;
+#ifndef COMPILE_PCRE8
+          if (c > 255)
+            {
+            if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
+            }
+          else
+#endif
+            if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
+          }
+        }
+
+      /* If max == min we can continue with the main loop without the
+      need to recurse. */
+
+      if (min == max) continue;
+
+      /* If minimizing, keep testing the rest of the expression and advancing
+      the pointer while it matches the class. */
+
+      if (minimize)
+        {
+#ifdef SUPPORT_UTF
+        if (utf)
+          {
+          for (fi = min;; fi++)
+            {
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM16);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max) RRETURN(MATCH_NOMATCH);
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINC(c, eptr);
+            if (c > 255)
+              {
+              if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
+              }
+            else
+              if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
+            }
+          }
+        else
+#endif
+        /* Not UTF mode */
+          {
+          for (fi = min;; fi++)
+            {
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM17);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max) RRETURN(MATCH_NOMATCH);
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            c = *eptr++;
+#ifndef COMPILE_PCRE8
+            if (c > 255)
+              {
+              if (op == OP_CLASS) RRETURN(MATCH_NOMATCH);
+              }
+            else
+#endif
+              if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) RRETURN(MATCH_NOMATCH);
+            }
+          }
+        /* Control never gets here */
+        }
+
+      /* If maximizing, find the longest possible run, then work backwards. */
+
+      else
+        {
+        pp = eptr;
+
+#ifdef SUPPORT_UTF
+        if (utf)
+          {
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLEN(c, eptr, len);
+            if (c > 255)
+              {
+              if (op == OP_CLASS) break;
+              }
+            else
+              if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) break;
+            eptr += len;
+            }
+
+          if (possessive) continue;    /* No backtracking */
+
+          for (;;)
+            {
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM18);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (eptr-- <= pp) break;        /* Stop if tried at original pos */
+            BACKCHAR(eptr);
+            }
+          }
+        else
+#endif
+          /* Not UTF mode */
+          {
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            c = *eptr;
+#ifndef COMPILE_PCRE8
+            if (c > 255)
+              {
+              if (op == OP_CLASS) break;
+              }
+            else
+#endif
+              if ((BYTE_MAP[c/8] & (1 << (c&7))) == 0) break;
+            eptr++;
+            }
+
+          if (possessive) continue;    /* No backtracking */
+
+          while (eptr >= pp)
+            {
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM19);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            eptr--;
+            }
+          }
+
+        RRETURN(MATCH_NOMATCH);
+        }
+#undef BYTE_MAP
+      }
+    /* Control never gets here */
+
+
+    /* Match an extended character class. In the 8-bit library, this opcode is
+    encountered only when UTF-8 mode mode is supported. In the 16-bit and
+    32-bit libraries, codepoints greater than 255 may be encountered even when
+    UTF is not supported. */
+
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+    case OP_XCLASS:
+      {
+      data = ecode + 1 + LINK_SIZE;                /* Save for matching */
+      ecode += GET(ecode, 1);                      /* Advance past the item */
+
+      switch (*ecode)
+        {
+        case OP_CRSTAR:
+        case OP_CRMINSTAR:
+        case OP_CRPLUS:
+        case OP_CRMINPLUS:
+        case OP_CRQUERY:
+        case OP_CRMINQUERY:
+        case OP_CRPOSSTAR:
+        case OP_CRPOSPLUS:
+        case OP_CRPOSQUERY:
+        c = *ecode++ - OP_CRSTAR;
+        if (c < OP_CRPOSSTAR - OP_CRSTAR) minimize = (c & 1) != 0;
+        else possessive = TRUE;
+        min = rep_min[c];                 /* Pick up values from tables; */
+        max = rep_max[c];                 /* zero for max => infinity */
+        if (max == 0) max = INT_MAX;
+        break;
+
+        case OP_CRRANGE:
+        case OP_CRMINRANGE:
+        case OP_CRPOSRANGE:
+        minimize = (*ecode == OP_CRMINRANGE);
+        possessive = (*ecode == OP_CRPOSRANGE);
+        min = GET2(ecode, 1);
+        max = GET2(ecode, 1 + IMM2_SIZE);
+        if (max == 0) max = INT_MAX;
+        ecode += 1 + 2 * IMM2_SIZE;
+        break;
+
+        default:               /* No repeat follows */
+        min = max = 1;
+        break;
+        }
+
+      /* First, ensure the minimum number of matches are present. */
+
+      for (i = 1; i <= min; i++)
+        {
+        if (eptr >= md->end_subject)
+          {
+          SCHECK_PARTIAL();
+          RRETURN(MATCH_NOMATCH);
+          }
+        GETCHARINCTEST(c, eptr);
+        if (!PRIV(xclass)(c, data, utf)) RRETURN(MATCH_NOMATCH);
+        }
+
+      /* If max == min we can continue with the main loop without the
+      need to recurse. */
+
+      if (min == max) continue;
+
+      /* If minimizing, keep testing the rest of the expression and advancing
+      the pointer while it matches the class. */
+
+      if (minimize)
+        {
+        for (fi = min;; fi++)
+          {
+          RMATCH(eptr, ecode, offset_top, md, eptrb, RM20);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (fi >= max) RRETURN(MATCH_NOMATCH);
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          GETCHARINCTEST(c, eptr);
+          if (!PRIV(xclass)(c, data, utf)) RRETURN(MATCH_NOMATCH);
+          }
+        /* Control never gets here */
+        }
+
+      /* If maximizing, find the longest possible run, then work backwards. */
+
+      else
+        {
+        pp = eptr;
+        for (i = min; i < max; i++)
+          {
+          int len = 1;
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            break;
+            }
+#ifdef SUPPORT_UTF
+          GETCHARLENTEST(c, eptr, len);
+#else
+          c = *eptr;
+#endif
+          if (!PRIV(xclass)(c, data, utf)) break;
+          eptr += len;
+          }
+
+        if (possessive) continue;    /* No backtracking */
+
+        for(;;)
+          {
+          RMATCH(eptr, ecode, offset_top, md, eptrb, RM21);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (eptr-- <= pp) break;        /* Stop if tried at original pos */
+#ifdef SUPPORT_UTF
+          if (utf) BACKCHAR(eptr);
+#endif
+          }
+        RRETURN(MATCH_NOMATCH);
+        }
+
+      /* Control never gets here */
+      }
+#endif    /* End of XCLASS */
+
+    /* Match a single character, casefully */
+
+    case OP_CHAR:
+#ifdef SUPPORT_UTF
+    if (utf)
+      {
+      length = 1;
+      ecode++;
+      GETCHARLEN(fc, ecode, length);
+      if (length > md->end_subject - eptr)
+        {
+        CHECK_PARTIAL();             /* Not SCHECK_PARTIAL() */
+        RRETURN(MATCH_NOMATCH);
+        }
+      while (length-- > 0) if (*ecode++ != UCHAR21INC(eptr)) RRETURN(MATCH_NOMATCH);
+      }
+    else
+#endif
+    /* Not UTF mode */
+      {
+      if (md->end_subject - eptr < 1)
+        {
+        SCHECK_PARTIAL();            /* This one can use SCHECK_PARTIAL() */
+        RRETURN(MATCH_NOMATCH);
+        }
+      if (ecode[1] != *eptr++) RRETURN(MATCH_NOMATCH);
+      ecode += 2;
+      }
+    break;
+
+    /* Match a single character, caselessly. If we are at the end of the
+    subject, give up immediately. */
+
+    case OP_CHARI:
+    if (eptr >= md->end_subject)
+      {
+      SCHECK_PARTIAL();
+      RRETURN(MATCH_NOMATCH);
+      }
+
+#ifdef SUPPORT_UTF
+    if (utf)
+      {
+      length = 1;
+      ecode++;
+      GETCHARLEN(fc, ecode, length);
+
+      /* If the pattern character's value is < 128, we have only one byte, and
+      we know that its other case must also be one byte long, so we can use the
+      fast lookup table. We know that there is at least one byte left in the
+      subject. */
+
+      if (fc < 128)
+        {
+        pcre_uint32 cc = UCHAR21(eptr);
+        if (md->lcc[fc] != TABLE_GET(cc, md->lcc, cc)) RRETURN(MATCH_NOMATCH);
+        ecode++;
+        eptr++;
+        }
+
+      /* Otherwise we must pick up the subject character. Note that we cannot
+      use the value of "length" to check for sufficient bytes left, because the
+      other case of the character may have more or fewer bytes.  */
+
+      else
+        {
+        pcre_uint32 dc;
+        GETCHARINC(dc, eptr);
+        ecode += length;
+
+        /* If we have Unicode property support, we can use it to test the other
+        case of the character, if there is one. */
+
+        if (fc != dc)
+          {
+#ifdef SUPPORT_UCP
+          if (dc != UCD_OTHERCASE(fc))
+#endif
+            RRETURN(MATCH_NOMATCH);
+          }
+        }
+      }
+    else
+#endif   /* SUPPORT_UTF */
+
+    /* Not UTF mode */
+      {
+      if (TABLE_GET(ecode[1], md->lcc, ecode[1])
+          != TABLE_GET(*eptr, md->lcc, *eptr)) RRETURN(MATCH_NOMATCH);
+      eptr++;
+      ecode += 2;
+      }
+    break;
+
+    /* Match a single character repeatedly. */
+
+    case OP_EXACT:
+    case OP_EXACTI:
+    min = max = GET2(ecode, 1);
+    ecode += 1 + IMM2_SIZE;
+    goto REPEATCHAR;
+
+    case OP_POSUPTO:
+    case OP_POSUPTOI:
+    possessive = TRUE;
+    /* Fall through */
+
+    case OP_UPTO:
+    case OP_UPTOI:
+    case OP_MINUPTO:
+    case OP_MINUPTOI:
+    min = 0;
+    max = GET2(ecode, 1);
+    minimize = *ecode == OP_MINUPTO || *ecode == OP_MINUPTOI;
+    ecode += 1 + IMM2_SIZE;
+    goto REPEATCHAR;
+
+    case OP_POSSTAR:
+    case OP_POSSTARI:
+    possessive = TRUE;
+    min = 0;
+    max = INT_MAX;
+    ecode++;
+    goto REPEATCHAR;
+
+    case OP_POSPLUS:
+    case OP_POSPLUSI:
+    possessive = TRUE;
+    min = 1;
+    max = INT_MAX;
+    ecode++;
+    goto REPEATCHAR;
+
+    case OP_POSQUERY:
+    case OP_POSQUERYI:
+    possessive = TRUE;
+    min = 0;
+    max = 1;
+    ecode++;
+    goto REPEATCHAR;
+
+    case OP_STAR:
+    case OP_STARI:
+    case OP_MINSTAR:
+    case OP_MINSTARI:
+    case OP_PLUS:
+    case OP_PLUSI:
+    case OP_MINPLUS:
+    case OP_MINPLUSI:
+    case OP_QUERY:
+    case OP_QUERYI:
+    case OP_MINQUERY:
+    case OP_MINQUERYI:
+    c = *ecode++ - ((op < OP_STARI)? OP_STAR : OP_STARI);
+    minimize = (c & 1) != 0;
+    min = rep_min[c];                 /* Pick up values from tables; */
+    max = rep_max[c];                 /* zero for max => infinity */
+    if (max == 0) max = INT_MAX;
+
+    /* Common code for all repeated single-character matches. We first check
+    for the minimum number of characters. If the minimum equals the maximum, we
+    are done. Otherwise, if minimizing, check the rest of the pattern for a
+    match; if there isn't one, advance up to the maximum, one character at a
+    time.
+
+    If maximizing, advance up to the maximum number of matching characters,
+    until eptr is past the end of the maximum run. If possessive, we are
+    then done (no backing up). Otherwise, match at this position; anything
+    other than no match is immediately returned. For nomatch, back up one
+    character, unless we are matching \R and the last thing matched was
+    \r\n, in which case, back up two bytes. When we reach the first optional
+    character position, we can save stack by doing a tail recurse.
+
+    The various UTF/non-UTF and caseful/caseless cases are handled separately,
+    for speed. */
+
+    REPEATCHAR:
+#ifdef SUPPORT_UTF
+    if (utf)
+      {
+      length = 1;
+      charptr = ecode;
+      GETCHARLEN(fc, ecode, length);
+      ecode += length;
+
+      /* Handle multibyte character matching specially here. There is
+      support for caseless matching if UCP support is present. */
+
+      if (length > 1)
+        {
+#ifdef SUPPORT_UCP
+        pcre_uint32 othercase;
+        if (op >= OP_STARI &&     /* Caseless */
+            (othercase = UCD_OTHERCASE(fc)) != fc)
+          oclength = PRIV(ord2utf)(othercase, occhars);
+        else oclength = 0;
+#endif  /* SUPPORT_UCP */
+
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr <= md->end_subject - length &&
+            memcmp(eptr, charptr, IN_UCHARS(length)) == 0) eptr += length;
+#ifdef SUPPORT_UCP
+          else if (oclength > 0 &&
+                   eptr <= md->end_subject - oclength &&
+                   memcmp(eptr, occhars, IN_UCHARS(oclength)) == 0) eptr += oclength;
+#endif  /* SUPPORT_UCP */
+          else
+            {
+            CHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          }
+
+        if (min == max) continue;
+
+        if (minimize)
+          {
+          for (fi = min;; fi++)
+            {
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM22);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max) RRETURN(MATCH_NOMATCH);
+            if (eptr <= md->end_subject - length &&
+              memcmp(eptr, charptr, IN_UCHARS(length)) == 0) eptr += length;
+#ifdef SUPPORT_UCP
+            else if (oclength > 0 &&
+                     eptr <= md->end_subject - oclength &&
+                     memcmp(eptr, occhars, IN_UCHARS(oclength)) == 0) eptr += oclength;
+#endif  /* SUPPORT_UCP */
+            else
+              {
+              CHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            }
+          /* Control never gets here */
+          }
+
+        else  /* Maximize */
+          {
+          pp = eptr;
+          for (i = min; i < max; i++)
+            {
+            if (eptr <= md->end_subject - length &&
+                memcmp(eptr, charptr, IN_UCHARS(length)) == 0) eptr += length;
+#ifdef SUPPORT_UCP
+            else if (oclength > 0 &&
+                     eptr <= md->end_subject - oclength &&
+                     memcmp(eptr, occhars, IN_UCHARS(oclength)) == 0) eptr += oclength;
+#endif  /* SUPPORT_UCP */
+            else
+              {
+              CHECK_PARTIAL();
+              break;
+              }
+            }
+
+          if (possessive) continue;    /* No backtracking */
+          for(;;)
+            {
+            if (eptr <= pp) goto TAIL_RECURSE;
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM23);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+#ifdef SUPPORT_UCP
+            eptr--;
+            BACKCHAR(eptr);
+#else   /* without SUPPORT_UCP */
+            eptr -= length;
+#endif  /* SUPPORT_UCP */
+            }
+          }
+        /* Control never gets here */
+        }
+
+      /* If the length of a UTF-8 character is 1, we fall through here, and
+      obey the code as for non-UTF-8 characters below, though in this case the
+      value of fc will always be < 128. */
+      }
+    else
+#endif  /* SUPPORT_UTF */
+      /* When not in UTF-8 mode, load a single-byte character. */
+      fc = *ecode++;
+
+    /* The value of fc at this point is always one character, though we may
+    or may not be in UTF mode. The code is duplicated for the caseless and
+    caseful cases, for speed, since matching characters is likely to be quite
+    common. First, ensure the minimum number of matches are present. If min =
+    max, continue at the same level without recursing. Otherwise, if
+    minimizing, keep trying the rest of the expression and advancing one
+    matching character if failing, up to the maximum. Alternatively, if
+    maximizing, find the maximum number of characters and work backwards. */
+
+    DPRINTF(("matching %c{%d,%d} against subject %.*s\n", fc, min, max,
+      max, (char *)eptr));
+
+    if (op >= OP_STARI)  /* Caseless */
+      {
+#ifdef COMPILE_PCRE8
+      /* fc must be < 128 if UTF is enabled. */
+      foc = md->fcc[fc];
+#else
+#ifdef SUPPORT_UTF
+#ifdef SUPPORT_UCP
+      if (utf && fc > 127)
+        foc = UCD_OTHERCASE(fc);
+#else
+      if (utf && fc > 127)
+        foc = fc;
+#endif /* SUPPORT_UCP */
+      else
+#endif /* SUPPORT_UTF */
+        foc = TABLE_GET(fc, md->fcc, fc);
+#endif /* COMPILE_PCRE8 */
+
+      for (i = 1; i <= min; i++)
+        {
+        pcre_uint32 cc;                 /* Faster than pcre_uchar */
+        if (eptr >= md->end_subject)
+          {
+          SCHECK_PARTIAL();
+          RRETURN(MATCH_NOMATCH);
+          }
+        cc = UCHAR21TEST(eptr);
+        if (fc != cc && foc != cc) RRETURN(MATCH_NOMATCH);
+        eptr++;
+        }
+      if (min == max) continue;
+      if (minimize)
+        {
+        for (fi = min;; fi++)
+          {
+          pcre_uint32 cc;               /* Faster than pcre_uchar */
+          RMATCH(eptr, ecode, offset_top, md, eptrb, RM24);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (fi >= max) RRETURN(MATCH_NOMATCH);
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          cc = UCHAR21TEST(eptr);
+          if (fc != cc && foc != cc) RRETURN(MATCH_NOMATCH);
+          eptr++;
+          }
+        /* Control never gets here */
+        }
+      else  /* Maximize */
+        {
+        pp = eptr;
+        for (i = min; i < max; i++)
+          {
+          pcre_uint32 cc;               /* Faster than pcre_uchar */
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            break;
+            }
+          cc = UCHAR21TEST(eptr);
+          if (fc != cc && foc != cc) break;
+          eptr++;
+          }
+        if (possessive) continue;       /* No backtracking */
+        for (;;)
+          {
+          if (eptr == pp) goto TAIL_RECURSE;
+          RMATCH(eptr, ecode, offset_top, md, eptrb, RM25);
+          eptr--;
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          }
+        /* Control never gets here */
+        }
+      }
+
+    /* Caseful comparisons (includes all multi-byte characters) */
+
+    else
+      {
+      for (i = 1; i <= min; i++)
+        {
+        if (eptr >= md->end_subject)
+          {
+          SCHECK_PARTIAL();
+          RRETURN(MATCH_NOMATCH);
+          }
+        if (fc != UCHAR21INCTEST(eptr)) RRETURN(MATCH_NOMATCH);
+        }
+
+      if (min == max) continue;
+
+      if (minimize)
+        {
+        for (fi = min;; fi++)
+          {
+          RMATCH(eptr, ecode, offset_top, md, eptrb, RM26);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (fi >= max) RRETURN(MATCH_NOMATCH);
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          if (fc != UCHAR21INCTEST(eptr)) RRETURN(MATCH_NOMATCH);
+          }
+        /* Control never gets here */
+        }
+      else  /* Maximize */
+        {
+        pp = eptr;
+        for (i = min; i < max; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            break;
+            }
+          if (fc != UCHAR21TEST(eptr)) break;
+          eptr++;
+          }
+        if (possessive) continue;    /* No backtracking */
+        for (;;)
+          {
+          if (eptr == pp) goto TAIL_RECURSE;
+          RMATCH(eptr, ecode, offset_top, md, eptrb, RM27);
+          eptr--;
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          }
+        /* Control never gets here */
+        }
+      }
+    /* Control never gets here */
+
+    /* Match a negated single one-byte character. The character we are
+    checking can be multibyte. */
+
+    case OP_NOT:
+    case OP_NOTI:
+    if (eptr >= md->end_subject)
+      {
+      SCHECK_PARTIAL();
+      RRETURN(MATCH_NOMATCH);
+      }
+#ifdef SUPPORT_UTF
+    if (utf)
+      {
+      register pcre_uint32 ch, och;
+
+      ecode++;
+      GETCHARINC(ch, ecode);
+      GETCHARINC(c, eptr);
+
+      if (op == OP_NOT)
+        {
+        if (ch == c) RRETURN(MATCH_NOMATCH);
+        }
+      else
+        {
+#ifdef SUPPORT_UCP
+        if (ch > 127)
+          och = UCD_OTHERCASE(ch);
+#else
+        if (ch > 127)
+          och = ch;
+#endif /* SUPPORT_UCP */
+        else
+          och = TABLE_GET(ch, md->fcc, ch);
+        if (ch == c || och == c) RRETURN(MATCH_NOMATCH);
+        }
+      }
+    else
+#endif
+      {
+      register pcre_uint32 ch = ecode[1];
+      c = *eptr++;
+      if (ch == c || (op == OP_NOTI && TABLE_GET(ch, md->fcc, ch) == c))
+        RRETURN(MATCH_NOMATCH);
+      ecode += 2;
+      }
+    break;
+
+    /* Match a negated single one-byte character repeatedly. This is almost a
+    repeat of the code for a repeated single character, but I haven't found a
+    nice way of commoning these up that doesn't require a test of the
+    positive/negative option for each character match. Maybe that wouldn't add
+    very much to the time taken, but character matching *is* what this is all
+    about... */
+
+    case OP_NOTEXACT:
+    case OP_NOTEXACTI:
+    min = max = GET2(ecode, 1);
+    ecode += 1 + IMM2_SIZE;
+    goto REPEATNOTCHAR;
+
+    case OP_NOTUPTO:
+    case OP_NOTUPTOI:
+    case OP_NOTMINUPTO:
+    case OP_NOTMINUPTOI:
+    min = 0;
+    max = GET2(ecode, 1);
+    minimize = *ecode == OP_NOTMINUPTO || *ecode == OP_NOTMINUPTOI;
+    ecode += 1 + IMM2_SIZE;
+    goto REPEATNOTCHAR;
+
+    case OP_NOTPOSSTAR:
+    case OP_NOTPOSSTARI:
+    possessive = TRUE;
+    min = 0;
+    max = INT_MAX;
+    ecode++;
+    goto REPEATNOTCHAR;
+
+    case OP_NOTPOSPLUS:
+    case OP_NOTPOSPLUSI:
+    possessive = TRUE;
+    min = 1;
+    max = INT_MAX;
+    ecode++;
+    goto REPEATNOTCHAR;
+
+    case OP_NOTPOSQUERY:
+    case OP_NOTPOSQUERYI:
+    possessive = TRUE;
+    min = 0;
+    max = 1;
+    ecode++;
+    goto REPEATNOTCHAR;
+
+    case OP_NOTPOSUPTO:
+    case OP_NOTPOSUPTOI:
+    possessive = TRUE;
+    min = 0;
+    max = GET2(ecode, 1);
+    ecode += 1 + IMM2_SIZE;
+    goto REPEATNOTCHAR;
+
+    case OP_NOTSTAR:
+    case OP_NOTSTARI:
+    case OP_NOTMINSTAR:
+    case OP_NOTMINSTARI:
+    case OP_NOTPLUS:
+    case OP_NOTPLUSI:
+    case OP_NOTMINPLUS:
+    case OP_NOTMINPLUSI:
+    case OP_NOTQUERY:
+    case OP_NOTQUERYI:
+    case OP_NOTMINQUERY:
+    case OP_NOTMINQUERYI:
+    c = *ecode++ - ((op >= OP_NOTSTARI)? OP_NOTSTARI: OP_NOTSTAR);
+    minimize = (c & 1) != 0;
+    min = rep_min[c];                 /* Pick up values from tables; */
+    max = rep_max[c];                 /* zero for max => infinity */
+    if (max == 0) max = INT_MAX;
+
+    /* Common code for all repeated single-byte matches. */
+
+    REPEATNOTCHAR:
+    GETCHARINCTEST(fc, ecode);
+
+    /* The code is duplicated for the caseless and caseful cases, for speed,
+    since matching characters is likely to be quite common. First, ensure the
+    minimum number of matches are present. If min = max, continue at the same
+    level without recursing. Otherwise, if minimizing, keep trying the rest of
+    the expression and advancing one matching character if failing, up to the
+    maximum. Alternatively, if maximizing, find the maximum number of
+    characters and work backwards. */
+
+    DPRINTF(("negative matching %c{%d,%d} against subject %.*s\n", fc, min, max,
+      max, (char *)eptr));
+
+    if (op >= OP_NOTSTARI)     /* Caseless */
+      {
+#ifdef SUPPORT_UTF
+#ifdef SUPPORT_UCP
+      if (utf && fc > 127)
+        foc = UCD_OTHERCASE(fc);
+#else
+      if (utf && fc > 127)
+        foc = fc;
+#endif /* SUPPORT_UCP */
+      else
+#endif /* SUPPORT_UTF */
+        foc = TABLE_GET(fc, md->fcc, fc);
+
+#ifdef SUPPORT_UTF
+      if (utf)
+        {
+        register pcre_uint32 d;
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          GETCHARINC(d, eptr);
+          if (fc == d || (unsigned int)foc == d) RRETURN(MATCH_NOMATCH);
+          }
+        }
+      else
+#endif  /* SUPPORT_UTF */
+      /* Not UTF mode */
+        {
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          if (fc == *eptr || foc == *eptr) RRETURN(MATCH_NOMATCH);
+          eptr++;
+          }
+        }
+
+      if (min == max) continue;
+
+      if (minimize)
+        {
+#ifdef SUPPORT_UTF
+        if (utf)
+          {
+          register pcre_uint32 d;
+          for (fi = min;; fi++)
+            {
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM28);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max) RRETURN(MATCH_NOMATCH);
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINC(d, eptr);
+            if (fc == d || (unsigned int)foc == d) RRETURN(MATCH_NOMATCH);
+            }
+          }
+        else
+#endif  /*SUPPORT_UTF */
+        /* Not UTF mode */
+          {
+          for (fi = min;; fi++)
+            {
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM29);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max) RRETURN(MATCH_NOMATCH);
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            if (fc == *eptr || foc == *eptr) RRETURN(MATCH_NOMATCH);
+            eptr++;
+            }
+          }
+        /* Control never gets here */
+        }
+
+      /* Maximize case */
+
+      else
+        {
+        pp = eptr;
+
+#ifdef SUPPORT_UTF
+        if (utf)
+          {
+          register pcre_uint32 d;
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLEN(d, eptr, len);
+            if (fc == d || (unsigned int)foc == d) break;
+            eptr += len;
+            }
+          if (possessive) continue;    /* No backtracking */
+          for(;;)
+            {
+            if (eptr <= pp) goto TAIL_RECURSE;
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM30);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            eptr--;
+            BACKCHAR(eptr);
+            }
+          }
+        else
+#endif  /* SUPPORT_UTF */
+        /* Not UTF mode */
+          {
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            if (fc == *eptr || foc == *eptr) break;
+            eptr++;
+            }
+          if (possessive) continue;    /* No backtracking */
+          for (;;)
+            {
+            if (eptr == pp) goto TAIL_RECURSE;
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM31);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            eptr--;
+            }
+          }
+        /* Control never gets here */
+        }
+      }
+
+    /* Caseful comparisons */
+
+    else
+      {
+#ifdef SUPPORT_UTF
+      if (utf)
+        {
+        register pcre_uint32 d;
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          GETCHARINC(d, eptr);
+          if (fc == d) RRETURN(MATCH_NOMATCH);
+          }
+        }
+      else
+#endif
+      /* Not UTF mode */
+        {
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
+          }
+        }
+
+      if (min == max) continue;
+
+      if (minimize)
+        {
+#ifdef SUPPORT_UTF
+        if (utf)
+          {
+          register pcre_uint32 d;
+          for (fi = min;; fi++)
+            {
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM32);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max) RRETURN(MATCH_NOMATCH);
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINC(d, eptr);
+            if (fc == d) RRETURN(MATCH_NOMATCH);
+            }
+          }
+        else
+#endif
+        /* Not UTF mode */
+          {
+          for (fi = min;; fi++)
+            {
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM33);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max) RRETURN(MATCH_NOMATCH);
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            if (fc == *eptr++) RRETURN(MATCH_NOMATCH);
+            }
+          }
+        /* Control never gets here */
+        }
+
+      /* Maximize case */
+
+      else
+        {
+        pp = eptr;
+
+#ifdef SUPPORT_UTF
+        if (utf)
+          {
+          register pcre_uint32 d;
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLEN(d, eptr, len);
+            if (fc == d) break;
+            eptr += len;
+            }
+          if (possessive) continue;    /* No backtracking */
+          for(;;)
+            {
+            if (eptr <= pp) goto TAIL_RECURSE;
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM34);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            eptr--;
+            BACKCHAR(eptr);
+            }
+          }
+        else
+#endif
+        /* Not UTF mode */
+          {
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            if (fc == *eptr) break;
+            eptr++;
+            }
+          if (possessive) continue;    /* No backtracking */
+          for (;;)
+            {
+            if (eptr == pp) goto TAIL_RECURSE;
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM35);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            eptr--;
+            }
+          }
+        /* Control never gets here */
+        }
+      }
+    /* Control never gets here */
+
+    /* Match a single character type repeatedly; several different opcodes
+    share code. This is very similar to the code for single characters, but we
+    repeat it in the interests of efficiency. */
+
+    case OP_TYPEEXACT:
+    min = max = GET2(ecode, 1);
+    minimize = TRUE;
+    ecode += 1 + IMM2_SIZE;
+    goto REPEATTYPE;
+
+    case OP_TYPEUPTO:
+    case OP_TYPEMINUPTO:
+    min = 0;
+    max = GET2(ecode, 1);
+    minimize = *ecode == OP_TYPEMINUPTO;
+    ecode += 1 + IMM2_SIZE;
+    goto REPEATTYPE;
+
+    case OP_TYPEPOSSTAR:
+    possessive = TRUE;
+    min = 0;
+    max = INT_MAX;
+    ecode++;
+    goto REPEATTYPE;
+
+    case OP_TYPEPOSPLUS:
+    possessive = TRUE;
+    min = 1;
+    max = INT_MAX;
+    ecode++;
+    goto REPEATTYPE;
+
+    case OP_TYPEPOSQUERY:
+    possessive = TRUE;
+    min = 0;
+    max = 1;
+    ecode++;
+    goto REPEATTYPE;
+
+    case OP_TYPEPOSUPTO:
+    possessive = TRUE;
+    min = 0;
+    max = GET2(ecode, 1);
+    ecode += 1 + IMM2_SIZE;
+    goto REPEATTYPE;
+
+    case OP_TYPESTAR:
+    case OP_TYPEMINSTAR:
+    case OP_TYPEPLUS:
+    case OP_TYPEMINPLUS:
+    case OP_TYPEQUERY:
+    case OP_TYPEMINQUERY:
+    c = *ecode++ - OP_TYPESTAR;
+    minimize = (c & 1) != 0;
+    min = rep_min[c];                 /* Pick up values from tables; */
+    max = rep_max[c];                 /* zero for max => infinity */
+    if (max == 0) max = INT_MAX;
+
+    /* Common code for all repeated single character type matches. Note that
+    in UTF-8 mode, '.' matches a character of any length, but for the other
+    character types, the valid characters are all one-byte long. */
+
+    REPEATTYPE:
+    ctype = *ecode++;      /* Code for the character type */
+
+#ifdef SUPPORT_UCP
+    if (ctype == OP_PROP || ctype == OP_NOTPROP)
+      {
+      prop_fail_result = ctype == OP_NOTPROP;
+      prop_type = *ecode++;
+      prop_value = *ecode++;
+      }
+    else prop_type = -1;
+#endif
+
+    /* First, ensure the minimum number of matches are present. Use inline
+    code for maximizing the speed, and do the type test once at the start
+    (i.e. keep it out of the loop). Separate the UTF-8 code completely as that
+    is tidier. Also separate the UCP code, which can be the same for both UTF-8
+    and single-bytes. */
+
+    if (min > 0)
+      {
+#ifdef SUPPORT_UCP
+      if (prop_type >= 0)
+        {
+        switch(prop_type)
+          {
+          case PT_ANY:
+          if (prop_fail_result) RRETURN(MATCH_NOMATCH);
+          for (i = 1; i <= min; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            }
+          break;
+
+          case PT_LAMP:
+          for (i = 1; i <= min; i++)
+            {
+            int chartype;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            chartype = UCD_CHARTYPE(c);
+            if ((chartype == ucp_Lu ||
+                 chartype == ucp_Ll ||
+                 chartype == ucp_Lt) == prop_fail_result)
+              RRETURN(MATCH_NOMATCH);
+            }
+          break;
+
+          case PT_GC:
+          for (i = 1; i <= min; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)
+              RRETURN(MATCH_NOMATCH);
+            }
+          break;
+
+          case PT_PC:
+          for (i = 1; i <= min; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result)
+              RRETURN(MATCH_NOMATCH);
+            }
+          break;
+
+          case PT_SC:
+          for (i = 1; i <= min; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result)
+              RRETURN(MATCH_NOMATCH);
+            }
+          break;
+
+          case PT_ALNUM:
+          for (i = 1; i <= min; i++)
+            {
+            int category;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            category = UCD_CATEGORY(c);
+            if ((category == ucp_L || category == ucp_N) == prop_fail_result)
+              RRETURN(MATCH_NOMATCH);
+            }
+          break;
+
+          /* Perl space used to exclude VT, but from Perl 5.18 it is included,
+          which means that Perl space and POSIX space are now identical. PCRE
+          was changed at release 8.34. */
+
+          case PT_SPACE:    /* Perl space */
+          case PT_PXSPACE:  /* POSIX space */
+          for (i = 1; i <= min; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            switch(c)
+              {
+              HSPACE_CASES:
+              VSPACE_CASES:
+              if (prop_fail_result) RRETURN(MATCH_NOMATCH);
+              break;
+
+              default:
+              if ((UCD_CATEGORY(c) == ucp_Z) == prop_fail_result)
+                RRETURN(MATCH_NOMATCH);
+              break;
+              }
+            }
+          break;
+
+          case PT_WORD:
+          for (i = 1; i <= min; i++)
+            {
+            int category;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            category = UCD_CATEGORY(c);
+            if ((category == ucp_L || category == ucp_N || c == CHAR_UNDERSCORE)
+                   == prop_fail_result)
+              RRETURN(MATCH_NOMATCH);
+            }
+          break;
+
+          case PT_CLIST:
+          for (i = 1; i <= min; i++)
+            {
+            const pcre_uint32 *cp;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            cp = PRIV(ucd_caseless_sets) + prop_value;
+            for (;;)
+              {
+              if (c < *cp)
+                { if (prop_fail_result) break; else { RRETURN(MATCH_NOMATCH); } }
+              if (c == *cp++)
+                { if (prop_fail_result) { RRETURN(MATCH_NOMATCH); } else break; }
+              }
+            }
+          break;
+
+          case PT_UCNC:
+          for (i = 1; i <= min; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            if ((c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
+                 c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
+                 c >= 0xe000) == prop_fail_result)
+              RRETURN(MATCH_NOMATCH);
+            }
+          break;
+
+          /* This should not occur */
+
+          default:
+          RRETURN(PCRE_ERROR_INTERNAL);
+          }
+        }
+
+      /* Match extended Unicode sequences. We will get here only if the
+      support is in the binary; otherwise a compile-time error occurs. */
+
+      else if (ctype == OP_EXTUNI)
+        {
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          else
+            {
+            int lgb, rgb;
+            GETCHARINCTEST(c, eptr);
+            lgb = UCD_GRAPHBREAK(c);
+           while (eptr < md->end_subject)
+              {
+              int len = 1;
+              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
+              rgb = UCD_GRAPHBREAK(c);
+              if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
+              lgb = rgb;
+              eptr += len;
+              }
+            }
+          CHECK_PARTIAL();
+          }
+        }
+
+      else
+#endif     /* SUPPORT_UCP */
+
+/* Handle all other cases when the coding is UTF-8 */
+
+#ifdef SUPPORT_UTF
+      if (utf) switch(ctype)
+        {
+        case OP_ANY:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
+          if (md->partial != 0 &&
+              eptr + 1 >= md->end_subject &&
+              NLBLOCK->nltype == NLTYPE_FIXED &&
+              NLBLOCK->nllen == 2 &&
+              UCHAR21(eptr) == NLBLOCK->nl[0])
+            {
+            md->hitend = TRUE;
+            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
+            }
+          eptr++;
+          ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
+          }
+        break;
+
+        case OP_ALLANY:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          eptr++;
+          ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
+          }
+        break;
+
+        case OP_ANYBYTE:
+        if (eptr > md->end_subject - min) RRETURN(MATCH_NOMATCH);
+        eptr += min;
+        break;
+
+        case OP_ANYNL:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          GETCHARINC(c, eptr);
+          switch(c)
+            {
+            default: RRETURN(MATCH_NOMATCH);
+
+            case CHAR_CR:
+            if (eptr < md->end_subject && UCHAR21(eptr) == CHAR_LF) eptr++;
+            break;
+
+            case CHAR_LF:
+            break;
+
+            case CHAR_VT:
+            case CHAR_FF:
+            case CHAR_NEL:
+#ifndef EBCDIC
+            case 0x2028:
+            case 0x2029:
+#endif  /* Not EBCDIC */
+            if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+            break;
+            }
+          }
+        break;
+
+        case OP_NOT_HSPACE:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          GETCHARINC(c, eptr);
+          switch(c)
+            {
+            HSPACE_CASES: RRETURN(MATCH_NOMATCH);  /* Byte and multibyte cases */
+            default: break;
+            }
+          }
+        break;
+
+        case OP_HSPACE:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          GETCHARINC(c, eptr);
+          switch(c)
+            {
+            HSPACE_CASES: break;  /* Byte and multibyte cases */
+            default: RRETURN(MATCH_NOMATCH);
+            }
+          }
+        break;
+
+        case OP_NOT_VSPACE:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          GETCHARINC(c, eptr);
+          switch(c)
+            {
+            VSPACE_CASES: RRETURN(MATCH_NOMATCH);
+            default: break;
+            }
+          }
+        break;
+
+        case OP_VSPACE:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          GETCHARINC(c, eptr);
+          switch(c)
+            {
+            VSPACE_CASES: break;
+            default: RRETURN(MATCH_NOMATCH);
+            }
+          }
+        break;
+
+        case OP_NOT_DIGIT:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          GETCHARINC(c, eptr);
+          if (c < 128 && (md->ctypes[c] & ctype_digit) != 0)
+            RRETURN(MATCH_NOMATCH);
+          }
+        break;
+
+        case OP_DIGIT:
+        for (i = 1; i <= min; i++)
+          {
+          pcre_uint32 cc;
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          cc = UCHAR21(eptr);
+          if (cc >= 128 || (md->ctypes[cc] & ctype_digit) == 0)
+            RRETURN(MATCH_NOMATCH);
+          eptr++;
+          /* No need to skip more bytes - we know it's a 1-byte character */
+          }
+        break;
+
+        case OP_NOT_WHITESPACE:
+        for (i = 1; i <= min; i++)
+          {
+          pcre_uint32 cc;
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          cc = UCHAR21(eptr);
+          if (cc < 128 && (md->ctypes[cc] & ctype_space) != 0)
+            RRETURN(MATCH_NOMATCH);
+          eptr++;
+          ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
+          }
+        break;
+
+        case OP_WHITESPACE:
+        for (i = 1; i <= min; i++)
+          {
+          pcre_uint32 cc;
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          cc = UCHAR21(eptr);
+          if (cc >= 128 || (md->ctypes[cc] & ctype_space) == 0)
+            RRETURN(MATCH_NOMATCH);
+          eptr++;
+          /* No need to skip more bytes - we know it's a 1-byte character */
+          }
+        break;
+
+        case OP_NOT_WORDCHAR:
+        for (i = 1; i <= min; i++)
+          {
+          pcre_uint32 cc;
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          cc = UCHAR21(eptr);
+          if (cc < 128 && (md->ctypes[cc] & ctype_word) != 0)
+            RRETURN(MATCH_NOMATCH);
+          eptr++;
+          ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
+          }
+        break;
+
+        case OP_WORDCHAR:
+        for (i = 1; i <= min; i++)
+          {
+          pcre_uint32 cc;
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          cc = UCHAR21(eptr);
+          if (cc >= 128 || (md->ctypes[cc] & ctype_word) == 0)
+            RRETURN(MATCH_NOMATCH);
+          eptr++;
+          /* No need to skip more bytes - we know it's a 1-byte character */
+          }
+        break;
+
+        default:
+        RRETURN(PCRE_ERROR_INTERNAL);
+        }  /* End switch(ctype) */
+
+      else
+#endif     /* SUPPORT_UTF */
+
+      /* Code for the non-UTF-8 case for minimum matching of operators other
+      than OP_PROP and OP_NOTPROP. */
+
+      switch(ctype)
+        {
+        case OP_ANY:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          if (IS_NEWLINE(eptr)) RRETURN(MATCH_NOMATCH);
+          if (md->partial != 0 &&
+              eptr + 1 >= md->end_subject &&
+              NLBLOCK->nltype == NLTYPE_FIXED &&
+              NLBLOCK->nllen == 2 &&
+              *eptr == NLBLOCK->nl[0])
+            {
+            md->hitend = TRUE;
+            if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
+            }
+          eptr++;
+          }
+        break;
+
+        case OP_ALLANY:
+        if (eptr > md->end_subject - min)
+          {
+          SCHECK_PARTIAL();
+          RRETURN(MATCH_NOMATCH);
+          }
+        eptr += min;
+        break;
+
+        case OP_ANYBYTE:
+        if (eptr > md->end_subject - min)
+          {
+          SCHECK_PARTIAL();
+          RRETURN(MATCH_NOMATCH);
+          }
+        eptr += min;
+        break;
+
+        case OP_ANYNL:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          switch(*eptr++)
+            {
+            default: RRETURN(MATCH_NOMATCH);
+
+            case CHAR_CR:
+            if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
+            break;
+
+            case CHAR_LF:
+            break;
+
+            case CHAR_VT:
+            case CHAR_FF:
+            case CHAR_NEL:
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+            case 0x2028:
+            case 0x2029:
+#endif
+            if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+            break;
+            }
+          }
+        break;
+
+        case OP_NOT_HSPACE:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          switch(*eptr++)
+            {
+            default: break;
+            HSPACE_BYTE_CASES:
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+            HSPACE_MULTIBYTE_CASES:
+#endif
+            RRETURN(MATCH_NOMATCH);
+            }
+          }
+        break;
+
+        case OP_HSPACE:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          switch(*eptr++)
+            {
+            default: RRETURN(MATCH_NOMATCH);
+            HSPACE_BYTE_CASES:
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+            HSPACE_MULTIBYTE_CASES:
+#endif
+            break;
+            }
+          }
+        break;
+
+        case OP_NOT_VSPACE:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          switch(*eptr++)
+            {
+            VSPACE_BYTE_CASES:
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+            VSPACE_MULTIBYTE_CASES:
+#endif
+            RRETURN(MATCH_NOMATCH);
+            default: break;
+            }
+          }
+        break;
+
+        case OP_VSPACE:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          switch(*eptr++)
+            {
+            default: RRETURN(MATCH_NOMATCH);
+            VSPACE_BYTE_CASES:
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+            VSPACE_MULTIBYTE_CASES:
+#endif
+            break;
+            }
+          }
+        break;
+
+        case OP_NOT_DIGIT:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_digit) != 0)
+            RRETURN(MATCH_NOMATCH);
+          eptr++;
+          }
+        break;
+
+        case OP_DIGIT:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_digit) == 0)
+            RRETURN(MATCH_NOMATCH);
+          eptr++;
+          }
+        break;
+
+        case OP_NOT_WHITESPACE:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_space) != 0)
+            RRETURN(MATCH_NOMATCH);
+          eptr++;
+          }
+        break;
+
+        case OP_WHITESPACE:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_space) == 0)
+            RRETURN(MATCH_NOMATCH);
+          eptr++;
+          }
+        break;
+
+        case OP_NOT_WORDCHAR:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_word) != 0)
+            RRETURN(MATCH_NOMATCH);
+          eptr++;
+          }
+        break;
+
+        case OP_WORDCHAR:
+        for (i = 1; i <= min; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_word) == 0)
+            RRETURN(MATCH_NOMATCH);
+          eptr++;
+          }
+        break;
+
+        default:
+        RRETURN(PCRE_ERROR_INTERNAL);
+        }
+      }
+
+    /* If min = max, continue at the same level without recursing */
+
+    if (min == max) continue;
+
+    /* If minimizing, we have to test the rest of the pattern before each
+    subsequent match. Again, separate the UTF-8 case for speed, and also
+    separate the UCP cases. */
+
+    if (minimize)
+      {
+#ifdef SUPPORT_UCP
+      if (prop_type >= 0)
+        {
+        switch(prop_type)
+          {
+          case PT_ANY:
+          for (fi = min;; fi++)
+            {
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM36);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max) RRETURN(MATCH_NOMATCH);
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            if (prop_fail_result) RRETURN(MATCH_NOMATCH);
+            }
+          /* Control never gets here */
+
+          case PT_LAMP:
+          for (fi = min;; fi++)
+            {
+            int chartype;
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM37);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max) RRETURN(MATCH_NOMATCH);
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            chartype = UCD_CHARTYPE(c);
+            if ((chartype == ucp_Lu ||
+                 chartype == ucp_Ll ||
+                 chartype == ucp_Lt) == prop_fail_result)
+              RRETURN(MATCH_NOMATCH);
+            }
+          /* Control never gets here */
+
+          case PT_GC:
+          for (fi = min;; fi++)
+            {
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM38);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max) RRETURN(MATCH_NOMATCH);
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result)
+              RRETURN(MATCH_NOMATCH);
+            }
+          /* Control never gets here */
+
+          case PT_PC:
+          for (fi = min;; fi++)
+            {
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM39);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max) RRETURN(MATCH_NOMATCH);
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result)
+              RRETURN(MATCH_NOMATCH);
+            }
+          /* Control never gets here */
+
+          case PT_SC:
+          for (fi = min;; fi++)
+            {
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM40);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max) RRETURN(MATCH_NOMATCH);
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result)
+              RRETURN(MATCH_NOMATCH);
+            }
+          /* Control never gets here */
+
+          case PT_ALNUM:
+          for (fi = min;; fi++)
+            {
+            int category;
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM59);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max) RRETURN(MATCH_NOMATCH);
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            category = UCD_CATEGORY(c);
+            if ((category == ucp_L || category == ucp_N) == prop_fail_result)
+              RRETURN(MATCH_NOMATCH);
+            }
+          /* Control never gets here */
+
+          /* Perl space used to exclude VT, but from Perl 5.18 it is included,
+          which means that Perl space and POSIX space are now identical. PCRE
+          was changed at release 8.34. */
+
+          case PT_SPACE:    /* Perl space */
+          case PT_PXSPACE:  /* POSIX space */
+          for (fi = min;; fi++)
+            {
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM61);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max) RRETURN(MATCH_NOMATCH);
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            switch(c)
+              {
+              HSPACE_CASES:
+              VSPACE_CASES:
+              if (prop_fail_result) RRETURN(MATCH_NOMATCH);
+              break;
+
+              default:
+              if ((UCD_CATEGORY(c) == ucp_Z) == prop_fail_result)
+                RRETURN(MATCH_NOMATCH);
+              break;
+              }
+            }
+          /* Control never gets here */
+
+          case PT_WORD:
+          for (fi = min;; fi++)
+            {
+            int category;
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM62);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max) RRETURN(MATCH_NOMATCH);
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            category = UCD_CATEGORY(c);
+            if ((category == ucp_L ||
+                 category == ucp_N ||
+                 c == CHAR_UNDERSCORE)
+                   == prop_fail_result)
+              RRETURN(MATCH_NOMATCH);
+            }
+          /* Control never gets here */
+
+          case PT_CLIST:
+          for (fi = min;; fi++)
+            {
+            const pcre_uint32 *cp;
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM67);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max) RRETURN(MATCH_NOMATCH);
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            cp = PRIV(ucd_caseless_sets) + prop_value;
+            for (;;)
+              {
+              if (c < *cp)
+                { if (prop_fail_result) break; else { RRETURN(MATCH_NOMATCH); } }
+              if (c == *cp++)
+                { if (prop_fail_result) { RRETURN(MATCH_NOMATCH); } else break; }
+              }
+            }
+          /* Control never gets here */
+
+          case PT_UCNC:
+          for (fi = min;; fi++)
+            {
+            RMATCH(eptr, ecode, offset_top, md, eptrb, RM60);
+            if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+            if (fi >= max) RRETURN(MATCH_NOMATCH);
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              RRETURN(MATCH_NOMATCH);
+              }
+            GETCHARINCTEST(c, eptr);
+            if ((c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
+                 c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
+                 c >= 0xe000) == prop_fail_result)
+              RRETURN(MATCH_NOMATCH);
+            }
+          /* Control never gets here */
+
+          /* This should never occur */
+          default:
+          RRETURN(PCRE_ERROR_INTERNAL);
+          }
+        }
+
+      /* Match extended Unicode sequences. We will get here only if the
+      support is in the binary; otherwise a compile-time error occurs. */
+
+      else if (ctype == OP_EXTUNI)
+        {
+        for (fi = min;; fi++)
+          {
+          RMATCH(eptr, ecode, offset_top, md, eptrb, RM41);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (fi >= max) RRETURN(MATCH_NOMATCH);
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          else
+            {
+            int lgb, rgb;
+            GETCHARINCTEST(c, eptr);
+            lgb = UCD_GRAPHBREAK(c);
+            while (eptr < md->end_subject)
+              {
+              int len = 1;
+              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
+              rgb = UCD_GRAPHBREAK(c);
+              if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
+              lgb = rgb;
+              eptr += len;
+              }
+            }
+          CHECK_PARTIAL();
+          }
+        }
+      else
+#endif     /* SUPPORT_UCP */
+
+#ifdef SUPPORT_UTF
+      if (utf)
+        {
+        for (fi = min;; fi++)
+          {
+          RMATCH(eptr, ecode, offset_top, md, eptrb, RM42);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (fi >= max) RRETURN(MATCH_NOMATCH);
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          if (ctype == OP_ANY && IS_NEWLINE(eptr))
+            RRETURN(MATCH_NOMATCH);
+          GETCHARINC(c, eptr);
+          switch(ctype)
+            {
+            case OP_ANY:               /* This is the non-NL case */
+            if (md->partial != 0 &&    /* Take care with CRLF partial */
+                eptr >= md->end_subject &&
+                NLBLOCK->nltype == NLTYPE_FIXED &&
+                NLBLOCK->nllen == 2 &&
+                c == NLBLOCK->nl[0])
+              {
+              md->hitend = TRUE;
+              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
+              }
+            break;
+
+            case OP_ALLANY:
+            case OP_ANYBYTE:
+            break;
+
+            case OP_ANYNL:
+            switch(c)
+              {
+              default: RRETURN(MATCH_NOMATCH);
+              case CHAR_CR:
+              if (eptr < md->end_subject && UCHAR21(eptr) == CHAR_LF) eptr++;
+              break;
+
+              case CHAR_LF:
+              break;
+
+              case CHAR_VT:
+              case CHAR_FF:
+              case CHAR_NEL:
+#ifndef EBCDIC
+              case 0x2028:
+              case 0x2029:
+#endif  /* Not EBCDIC */
+              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+              break;
+              }
+            break;
+
+            case OP_NOT_HSPACE:
+            switch(c)
+              {
+              HSPACE_CASES: RRETURN(MATCH_NOMATCH);
+              default: break;
+              }
+            break;
+
+            case OP_HSPACE:
+            switch(c)
+              {
+              HSPACE_CASES: break;
+              default: RRETURN(MATCH_NOMATCH);
+              }
+            break;
+
+            case OP_NOT_VSPACE:
+            switch(c)
+              {
+              VSPACE_CASES: RRETURN(MATCH_NOMATCH);
+              default: break;
+              }
+            break;
+
+            case OP_VSPACE:
+            switch(c)
+              {
+              VSPACE_CASES: break;
+              default: RRETURN(MATCH_NOMATCH);
+              }
+            break;
+
+            case OP_NOT_DIGIT:
+            if (c < 256 && (md->ctypes[c] & ctype_digit) != 0)
+              RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_DIGIT:
+            if (c >= 256 || (md->ctypes[c] & ctype_digit) == 0)
+              RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_NOT_WHITESPACE:
+            if (c < 256 && (md->ctypes[c] & ctype_space) != 0)
+              RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_WHITESPACE:
+            if (c >= 256 || (md->ctypes[c] & ctype_space) == 0)
+              RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_NOT_WORDCHAR:
+            if (c < 256 && (md->ctypes[c] & ctype_word) != 0)
+              RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_WORDCHAR:
+            if (c >= 256 || (md->ctypes[c] & ctype_word) == 0)
+              RRETURN(MATCH_NOMATCH);
+            break;
+
+            default:
+            RRETURN(PCRE_ERROR_INTERNAL);
+            }
+          }
+        }
+      else
+#endif
+      /* Not UTF mode */
+        {
+        for (fi = min;; fi++)
+          {
+          RMATCH(eptr, ecode, offset_top, md, eptrb, RM43);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          if (fi >= max) RRETURN(MATCH_NOMATCH);
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            RRETURN(MATCH_NOMATCH);
+            }
+          if (ctype == OP_ANY && IS_NEWLINE(eptr))
+            RRETURN(MATCH_NOMATCH);
+          c = *eptr++;
+          switch(ctype)
+            {
+            case OP_ANY:               /* This is the non-NL case */
+            if (md->partial != 0 &&    /* Take care with CRLF partial */
+                eptr >= md->end_subject &&
+                NLBLOCK->nltype == NLTYPE_FIXED &&
+                NLBLOCK->nllen == 2 &&
+                c == NLBLOCK->nl[0])
+              {
+              md->hitend = TRUE;
+              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
+              }
+            break;
+
+            case OP_ALLANY:
+            case OP_ANYBYTE:
+            break;
+
+            case OP_ANYNL:
+            switch(c)
+              {
+              default: RRETURN(MATCH_NOMATCH);
+              case CHAR_CR:
+              if (eptr < md->end_subject && *eptr == CHAR_LF) eptr++;
+              break;
+
+              case CHAR_LF:
+              break;
+
+              case CHAR_VT:
+              case CHAR_FF:
+              case CHAR_NEL:
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+              case 0x2028:
+              case 0x2029:
+#endif
+              if (md->bsr_anycrlf) RRETURN(MATCH_NOMATCH);
+              break;
+              }
+            break;
+
+            case OP_NOT_HSPACE:
+            switch(c)
+              {
+              default: break;
+              HSPACE_BYTE_CASES:
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+              HSPACE_MULTIBYTE_CASES:
+#endif
+              RRETURN(MATCH_NOMATCH);
+              }
+            break;
+
+            case OP_HSPACE:
+            switch(c)
+              {
+              default: RRETURN(MATCH_NOMATCH);
+              HSPACE_BYTE_CASES:
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+              HSPACE_MULTIBYTE_CASES:
+#endif
+              break;
+              }
+            break;
+
+            case OP_NOT_VSPACE:
+            switch(c)
+              {
+              default: break;
+              VSPACE_BYTE_CASES:
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+              VSPACE_MULTIBYTE_CASES:
+#endif
+              RRETURN(MATCH_NOMATCH);
+              }
+            break;
+
+            case OP_VSPACE:
+            switch(c)
+              {
+              default: RRETURN(MATCH_NOMATCH);
+              VSPACE_BYTE_CASES:
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+              VSPACE_MULTIBYTE_CASES:
+#endif
+              break;
+              }
+            break;
+
+            case OP_NOT_DIGIT:
+            if (MAX_255(c) && (md->ctypes[c] & ctype_digit) != 0) RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_DIGIT:
+            if (!MAX_255(c) || (md->ctypes[c] & ctype_digit) == 0) RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_NOT_WHITESPACE:
+            if (MAX_255(c) && (md->ctypes[c] & ctype_space) != 0) RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_WHITESPACE:
+            if (!MAX_255(c) || (md->ctypes[c] & ctype_space) == 0) RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_NOT_WORDCHAR:
+            if (MAX_255(c) && (md->ctypes[c] & ctype_word) != 0) RRETURN(MATCH_NOMATCH);
+            break;
+
+            case OP_WORDCHAR:
+            if (!MAX_255(c) || (md->ctypes[c] & ctype_word) == 0) RRETURN(MATCH_NOMATCH);
+            break;
+
+            default:
+            RRETURN(PCRE_ERROR_INTERNAL);
+            }
+          }
+        }
+      /* Control never gets here */
+      }
+
+    /* If maximizing, it is worth using inline code for speed, doing the type
+    test once at the start (i.e. keep it out of the loop). Again, keep the
+    UTF-8 and UCP stuff separate. */
+
+    else
+      {
+      pp = eptr;  /* Remember where we started */
+
+#ifdef SUPPORT_UCP
+      if (prop_type >= 0)
+        {
+        switch(prop_type)
+          {
+          case PT_ANY:
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLENTEST(c, eptr, len);
+            if (prop_fail_result) break;
+            eptr+= len;
+            }
+          break;
+
+          case PT_LAMP:
+          for (i = min; i < max; i++)
+            {
+            int chartype;
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLENTEST(c, eptr, len);
+            chartype = UCD_CHARTYPE(c);
+            if ((chartype == ucp_Lu ||
+                 chartype == ucp_Ll ||
+                 chartype == ucp_Lt) == prop_fail_result)
+              break;
+            eptr+= len;
+            }
+          break;
+
+          case PT_GC:
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLENTEST(c, eptr, len);
+            if ((UCD_CATEGORY(c) == prop_value) == prop_fail_result) break;
+            eptr+= len;
+            }
+          break;
+
+          case PT_PC:
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLENTEST(c, eptr, len);
+            if ((UCD_CHARTYPE(c) == prop_value) == prop_fail_result) break;
+            eptr+= len;
+            }
+          break;
+
+          case PT_SC:
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLENTEST(c, eptr, len);
+            if ((UCD_SCRIPT(c) == prop_value) == prop_fail_result) break;
+            eptr+= len;
+            }
+          break;
+
+          case PT_ALNUM:
+          for (i = min; i < max; i++)
+            {
+            int category;
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLENTEST(c, eptr, len);
+            category = UCD_CATEGORY(c);
+            if ((category == ucp_L || category == ucp_N) == prop_fail_result)
+              break;
+            eptr+= len;
+            }
+          break;
+
+          /* Perl space used to exclude VT, but from Perl 5.18 it is included,
+          which means that Perl space and POSIX space are now identical. PCRE
+          was changed at release 8.34. */
+
+          case PT_SPACE:    /* Perl space */
+          case PT_PXSPACE:  /* POSIX space */
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLENTEST(c, eptr, len);
+            switch(c)
+              {
+              HSPACE_CASES:
+              VSPACE_CASES:
+              if (prop_fail_result) goto ENDLOOP99;  /* Break the loop */
+              break;
+
+              default:
+              if ((UCD_CATEGORY(c) == ucp_Z) == prop_fail_result)
+                goto ENDLOOP99;   /* Break the loop */
+              break;
+              }
+            eptr+= len;
+            }
+          ENDLOOP99:
+          break;
+
+          case PT_WORD:
+          for (i = min; i < max; i++)
+            {
+            int category;
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLENTEST(c, eptr, len);
+            category = UCD_CATEGORY(c);
+            if ((category == ucp_L || category == ucp_N ||
+                 c == CHAR_UNDERSCORE) == prop_fail_result)
+              break;
+            eptr+= len;
+            }
+          break;
+
+          case PT_CLIST:
+          for (i = min; i < max; i++)
+            {
+            const pcre_uint32 *cp;
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLENTEST(c, eptr, len);
+            cp = PRIV(ucd_caseless_sets) + prop_value;
+            for (;;)
+              {
+              if (c < *cp)
+                { if (prop_fail_result) break; else goto GOT_MAX; }
+              if (c == *cp++)
+                { if (prop_fail_result) goto GOT_MAX; else break; }
+              }
+            eptr += len;
+            }
+          GOT_MAX:
+          break;
+
+          case PT_UCNC:
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLENTEST(c, eptr, len);
+            if ((c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
+                 c == CHAR_GRAVE_ACCENT || (c >= 0xa0 && c <= 0xd7ff) ||
+                 c >= 0xe000) == prop_fail_result)
+              break;
+            eptr += len;
+            }
+          break;
+
+          default:
+          RRETURN(PCRE_ERROR_INTERNAL);
+          }
+
+        /* eptr is now past the end of the maximum run */
+
+        if (possessive) continue;    /* No backtracking */
+        for(;;)
+          {
+          if (eptr <= pp) goto TAIL_RECURSE;
+          RMATCH(eptr, ecode, offset_top, md, eptrb, RM44);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          eptr--;
+          if (utf) BACKCHAR(eptr);
+          }
+        }
+
+      /* Match extended Unicode grapheme clusters. We will get here only if the
+      support is in the binary; otherwise a compile-time error occurs. */
+
+      else if (ctype == OP_EXTUNI)
+        {
+        for (i = min; i < max; i++)
+          {
+          if (eptr >= md->end_subject)
+            {
+            SCHECK_PARTIAL();
+            break;
+            }
+          else
+            {
+            int lgb, rgb;
+            GETCHARINCTEST(c, eptr);
+            lgb = UCD_GRAPHBREAK(c);
+            while (eptr < md->end_subject)
+              {
+              int len = 1;
+              if (!utf) c = *eptr; else { GETCHARLEN(c, eptr, len); }
+              rgb = UCD_GRAPHBREAK(c);
+              if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
+              lgb = rgb;
+              eptr += len;
+              }
+            }
+          CHECK_PARTIAL();
+          }
+
+        /* eptr is now past the end of the maximum run */
+
+        if (possessive) continue;    /* No backtracking */
+
+        /* We use <= pp rather than == pp to detect the start of the run while
+        backtracking because the use of \C in UTF mode can cause BACKCHAR to
+        move back past pp. This is just palliative; the use of \C in UTF mode
+        is fraught with danger. */
+
+        for(;;)
+          {
+          int lgb, rgb;
+          PCRE_PUCHAR fptr;
+
+          if (eptr <= pp) goto TAIL_RECURSE;   /* At start of char run */
+          RMATCH(eptr, ecode, offset_top, md, eptrb, RM45);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+
+          /* Backtracking over an extended grapheme cluster involves inspecting
+          the previous two characters (if present) to see if a break is
+          permitted between them. */
+
+          eptr--;
+          if (!utf) c = *eptr; else
+            {
+            BACKCHAR(eptr);
+            GETCHAR(c, eptr);
+            }
+          rgb = UCD_GRAPHBREAK(c);
+
+          for (;;)
+            {
+            if (eptr <= pp) goto TAIL_RECURSE;   /* At start of char run */
+            fptr = eptr - 1;
+            if (!utf) c = *fptr; else
+              {
+              BACKCHAR(fptr);
+              GETCHAR(c, fptr);
+              }
+            lgb = UCD_GRAPHBREAK(c);
+            if ((PRIV(ucp_gbtable)[lgb] & (1 << rgb)) == 0) break;
+            eptr = fptr;
+            rgb = lgb;
+            }
+          }
+        }
+
+      else
+#endif   /* SUPPORT_UCP */
+
+#ifdef SUPPORT_UTF
+      if (utf)
+        {
+        switch(ctype)
+          {
+          case OP_ANY:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            if (IS_NEWLINE(eptr)) break;
+            if (md->partial != 0 &&    /* Take care with CRLF partial */
+                eptr + 1 >= md->end_subject &&
+                NLBLOCK->nltype == NLTYPE_FIXED &&
+                NLBLOCK->nllen == 2 &&
+                UCHAR21(eptr) == NLBLOCK->nl[0])
+              {
+              md->hitend = TRUE;
+              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
+              }
+            eptr++;
+            ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
+            }
+          break;
+
+          case OP_ALLANY:
+          if (max < INT_MAX)
+            {
+            for (i = min; i < max; i++)
+              {
+              if (eptr >= md->end_subject)
+                {
+                SCHECK_PARTIAL();
+                break;
+                }
+              eptr++;
+              ACROSSCHAR(eptr < md->end_subject, *eptr, eptr++);
+              }
+            }
+          else
+            {
+            eptr = md->end_subject;   /* Unlimited UTF-8 repeat */
+            SCHECK_PARTIAL();
+            }
+          break;
+
+          /* The byte case is the same as non-UTF8 */
+
+          case OP_ANYBYTE:
+          c = max - min;
+          if (c > (unsigned int)(md->end_subject - eptr))
+            {
+            eptr = md->end_subject;
+            SCHECK_PARTIAL();
+            }
+          else eptr += c;
+          break;
+
+          case OP_ANYNL:
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLEN(c, eptr, len);
+            if (c == CHAR_CR)
+              {
+              if (++eptr >= md->end_subject) break;
+              if (UCHAR21(eptr) == CHAR_LF) eptr++;
+              }
+            else
+              {
+              if (c != CHAR_LF &&
+                  (md->bsr_anycrlf ||
+                   (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
+#ifndef EBCDIC
+                    && c != 0x2028 && c != 0x2029
+#endif  /* Not EBCDIC */
+                    )))
+                break;
+              eptr += len;
+              }
+            }
+          break;
+
+          case OP_NOT_HSPACE:
+          case OP_HSPACE:
+          for (i = min; i < max; i++)
+            {
+            BOOL gotspace;
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLEN(c, eptr, len);
+            switch(c)
+              {
+              HSPACE_CASES: gotspace = TRUE; break;
+              default: gotspace = FALSE; break;
+              }
+            if (gotspace == (ctype == OP_NOT_HSPACE)) break;
+            eptr += len;
+            }
+          break;
+
+          case OP_NOT_VSPACE:
+          case OP_VSPACE:
+          for (i = min; i < max; i++)
+            {
+            BOOL gotspace;
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLEN(c, eptr, len);
+            switch(c)
+              {
+              VSPACE_CASES: gotspace = TRUE; break;
+              default: gotspace = FALSE; break;
+              }
+            if (gotspace == (ctype == OP_NOT_VSPACE)) break;
+            eptr += len;
+            }
+          break;
+
+          case OP_NOT_DIGIT:
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLEN(c, eptr, len);
+            if (c < 256 && (md->ctypes[c] & ctype_digit) != 0) break;
+            eptr+= len;
+            }
+          break;
+
+          case OP_DIGIT:
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLEN(c, eptr, len);
+            if (c >= 256 ||(md->ctypes[c] & ctype_digit) == 0) break;
+            eptr+= len;
+            }
+          break;
+
+          case OP_NOT_WHITESPACE:
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLEN(c, eptr, len);
+            if (c < 256 && (md->ctypes[c] & ctype_space) != 0) break;
+            eptr+= len;
+            }
+          break;
+
+          case OP_WHITESPACE:
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLEN(c, eptr, len);
+            if (c >= 256 ||(md->ctypes[c] & ctype_space) == 0) break;
+            eptr+= len;
+            }
+          break;
+
+          case OP_NOT_WORDCHAR:
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLEN(c, eptr, len);
+            if (c < 256 && (md->ctypes[c] & ctype_word) != 0) break;
+            eptr+= len;
+            }
+          break;
+
+          case OP_WORDCHAR:
+          for (i = min; i < max; i++)
+            {
+            int len = 1;
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            GETCHARLEN(c, eptr, len);
+            if (c >= 256 || (md->ctypes[c] & ctype_word) == 0) break;
+            eptr+= len;
+            }
+          break;
+
+          default:
+          RRETURN(PCRE_ERROR_INTERNAL);
+          }
+
+        if (possessive) continue;    /* No backtracking */
+        for(;;)
+          {
+          if (eptr <= pp) goto TAIL_RECURSE;
+          RMATCH(eptr, ecode, offset_top, md, eptrb, RM46);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          eptr--;
+          BACKCHAR(eptr);
+          if (ctype == OP_ANYNL && eptr > pp  && UCHAR21(eptr) == CHAR_NL &&
+              UCHAR21(eptr - 1) == CHAR_CR) eptr--;
+          }
+        }
+      else
+#endif  /* SUPPORT_UTF */
+      /* Not UTF mode */
+        {
+        switch(ctype)
+          {
+          case OP_ANY:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            if (IS_NEWLINE(eptr)) break;
+            if (md->partial != 0 &&    /* Take care with CRLF partial */
+                eptr + 1 >= md->end_subject &&
+                NLBLOCK->nltype == NLTYPE_FIXED &&
+                NLBLOCK->nllen == 2 &&
+                *eptr == NLBLOCK->nl[0])
+              {
+              md->hitend = TRUE;
+              if (md->partial > 1) RRETURN(PCRE_ERROR_PARTIAL);
+              }
+            eptr++;
+            }
+          break;
+
+          case OP_ALLANY:
+          case OP_ANYBYTE:
+          c = max - min;
+          if (c > (unsigned int)(md->end_subject - eptr))
+            {
+            eptr = md->end_subject;
+            SCHECK_PARTIAL();
+            }
+          else eptr += c;
+          break;
+
+          case OP_ANYNL:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            c = *eptr;
+            if (c == CHAR_CR)
+              {
+              if (++eptr >= md->end_subject) break;
+              if (*eptr == CHAR_LF) eptr++;
+              }
+            else
+              {
+              if (c != CHAR_LF && (md->bsr_anycrlf ||
+                 (c != CHAR_VT && c != CHAR_FF && c != CHAR_NEL
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+                 && c != 0x2028 && c != 0x2029
+#endif
+                 ))) break;
+              eptr++;
+              }
+            }
+          break;
+
+          case OP_NOT_HSPACE:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            switch(*eptr)
+              {
+              default: eptr++; break;
+              HSPACE_BYTE_CASES:
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+              HSPACE_MULTIBYTE_CASES:
+#endif
+              goto ENDLOOP00;
+              }
+            }
+          ENDLOOP00:
+          break;
+
+          case OP_HSPACE:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            switch(*eptr)
+              {
+              default: goto ENDLOOP01;
+              HSPACE_BYTE_CASES:
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+              HSPACE_MULTIBYTE_CASES:
+#endif
+              eptr++; break;
+              }
+            }
+          ENDLOOP01:
+          break;
+
+          case OP_NOT_VSPACE:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            switch(*eptr)
+              {
+              default: eptr++; break;
+              VSPACE_BYTE_CASES:
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+              VSPACE_MULTIBYTE_CASES:
+#endif
+              goto ENDLOOP02;
+              }
+            }
+          ENDLOOP02:
+          break;
+
+          case OP_VSPACE:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            switch(*eptr)
+              {
+              default: goto ENDLOOP03;
+              VSPACE_BYTE_CASES:
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+              VSPACE_MULTIBYTE_CASES:
+#endif
+              eptr++; break;
+              }
+            }
+          ENDLOOP03:
+          break;
+
+          case OP_NOT_DIGIT:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_digit) != 0) break;
+            eptr++;
+            }
+          break;
+
+          case OP_DIGIT:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_digit) == 0) break;
+            eptr++;
+            }
+          break;
+
+          case OP_NOT_WHITESPACE:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_space) != 0) break;
+            eptr++;
+            }
+          break;
+
+          case OP_WHITESPACE:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_space) == 0) break;
+            eptr++;
+            }
+          break;
+
+          case OP_NOT_WORDCHAR:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            if (MAX_255(*eptr) && (md->ctypes[*eptr] & ctype_word) != 0) break;
+            eptr++;
+            }
+          break;
+
+          case OP_WORDCHAR:
+          for (i = min; i < max; i++)
+            {
+            if (eptr >= md->end_subject)
+              {
+              SCHECK_PARTIAL();
+              break;
+              }
+            if (!MAX_255(*eptr) || (md->ctypes[*eptr] & ctype_word) == 0) break;
+            eptr++;
+            }
+          break;
+
+          default:
+          RRETURN(PCRE_ERROR_INTERNAL);
+          }
+
+        if (possessive) continue;    /* No backtracking */
+        for (;;)
+          {
+          if (eptr == pp) goto TAIL_RECURSE;
+          RMATCH(eptr, ecode, offset_top, md, eptrb, RM47);
+          if (rrc != MATCH_NOMATCH) RRETURN(rrc);
+          eptr--;
+          if (ctype == OP_ANYNL && eptr > pp  && *eptr == CHAR_LF &&
+              eptr[-1] == CHAR_CR) eptr--;
+          }
+        }
+
+      /* Control never gets here */
+      }
+
+    /* There's been some horrible disaster. Arrival here can only mean there is
+    something seriously wrong in the code above or the OP_xxx definitions. */
+
+    default:
+    DPRINTF(("Unknown opcode %d\n", *ecode));
+    RRETURN(PCRE_ERROR_UNKNOWN_OPCODE);
+    }
+
+  /* Do not stick any code in here without much thought; it is assumed
+  that "continue" in the code above comes out to here to repeat the main
+  loop. */
+
+  }             /* End of main loop */
+/* Control never reaches here */
+
+
+/* When compiling to use the heap rather than the stack for recursive calls to
+match(), the RRETURN() macro jumps here. The number that is saved in
+frame->Xwhere indicates which label we actually want to return to. */
+
+#ifdef NO_RECURSE
+#define LBL(val) case val: goto L_RM##val;
+HEAP_RETURN:
+switch (frame->Xwhere)
+  {
+  LBL( 1) LBL( 2) LBL( 3) LBL( 4) LBL( 5) LBL( 6) LBL( 7) LBL( 8)
+  LBL( 9) LBL(10) LBL(11) LBL(12) LBL(13) LBL(14) LBL(15) LBL(17)
+  LBL(19) LBL(24) LBL(25) LBL(26) LBL(27) LBL(29) LBL(31) LBL(33)
+  LBL(35) LBL(43) LBL(47) LBL(48) LBL(49) LBL(50) LBL(51) LBL(52)
+  LBL(53) LBL(54) LBL(55) LBL(56) LBL(57) LBL(58) LBL(63) LBL(64)
+  LBL(65) LBL(66)
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+  LBL(20) LBL(21)
+#endif
+#ifdef SUPPORT_UTF
+  LBL(16) LBL(18)
+  LBL(22) LBL(23) LBL(28) LBL(30)
+  LBL(32) LBL(34) LBL(42) LBL(46)
+#ifdef SUPPORT_UCP
+  LBL(36) LBL(37) LBL(38) LBL(39) LBL(40) LBL(41) LBL(44) LBL(45)
+  LBL(59) LBL(60) LBL(61) LBL(62) LBL(67)
+#endif  /* SUPPORT_UCP */
+#endif  /* SUPPORT_UTF */
+  default:
+  DPRINTF(("jump error in pcre match: label %d non-existent\n", frame->Xwhere));
+  return PCRE_ERROR_INTERNAL;
+  }
+#undef LBL
+#endif  /* NO_RECURSE */
+}
+
+
+/***************************************************************************
+****************************************************************************
+                   RECURSION IN THE match() FUNCTION
+
+Undefine all the macros that were defined above to handle this. */
+
+#ifdef NO_RECURSE
+#undef eptr
+#undef ecode
+#undef mstart
+#undef offset_top
+#undef eptrb
+#undef flags
+
+#undef callpat
+#undef charptr
+#undef data
+#undef next
+#undef pp
+#undef prev
+#undef saved_eptr
+
+#undef new_recursive
+
+#undef cur_is_word
+#undef condition
+#undef prev_is_word
+
+#undef ctype
+#undef length
+#undef max
+#undef min
+#undef number
+#undef offset
+#undef op
+#undef save_capture_last
+#undef save_offset1
+#undef save_offset2
+#undef save_offset3
+#undef stacksave
+
+#undef newptrb
+
+#endif
+
+/* These two are defined as macros in both cases */
+
+#undef fc
+#undef fi
+
+/***************************************************************************
+***************************************************************************/
+
+
+#ifdef NO_RECURSE
+/*************************************************
+*          Release allocated heap frames         *
+*************************************************/
+
+/* This function releases all the allocated frames. The base frame is on the
+machine stack, and so must not be freed.
+
+Argument: the address of the base frame
+Returns:  nothing
+*/
+
+static void
+release_match_heapframes (heapframe *frame_base)
+{
+heapframe *nextframe = frame_base->Xnextframe;
+while (nextframe != NULL)
+  {
+  heapframe *oldframe = nextframe;
+  nextframe = nextframe->Xnextframe;
+  (PUBL(stack_free))(oldframe);
+  }
+}
+#endif
+
+
+/*************************************************
+*         Execute a Regular Expression           *
+*************************************************/
+
+/* This function applies a compiled re to a subject string and picks out
+portions of the string if it matches. Two elements in the vector are set for
+each substring: the offsets to the start and end of the substring.
+
+Arguments:
+  argument_re     points to the compiled expression
+  extra_data      points to extra data or is NULL
+  subject         points to the subject string
+  length          length of subject string (may contain binary zeros)
+  start_offset    where to start in the subject string
+  options         option bits
+  offsets         points to a vector of ints to be filled in with offsets
+  offsetcount     the number of elements in the vector
+
+Returns:          > 0 => success; value is the number of elements filled in
+                  = 0 => success, but offsets is not big enough
+                   -1 => failed to match
+                 < -1 => some kind of unexpected problem
+*/
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre_exec(const pcre *argument_re, const pcre_extra *extra_data,
+  PCRE_SPTR subject, int length, int start_offset, int options, int *offsets,
+  int offsetcount)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre16_exec(const pcre16 *argument_re, const pcre16_extra *extra_data,
+  PCRE_SPTR16 subject, int length, int start_offset, int options, int *offsets,
+  int offsetcount)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre32_exec(const pcre32 *argument_re, const pcre32_extra *extra_data,
+  PCRE_SPTR32 subject, int length, int start_offset, int options, int *offsets,
+  int offsetcount)
+#endif
+{
+int rc, ocount, arg_offset_max;
+int newline;
+BOOL using_temporary_offsets = FALSE;
+BOOL anchored;
+BOOL startline;
+BOOL firstline;
+BOOL utf;
+BOOL has_first_char = FALSE;
+BOOL has_req_char = FALSE;
+pcre_uchar first_char = 0;
+pcre_uchar first_char2 = 0;
+pcre_uchar req_char = 0;
+pcre_uchar req_char2 = 0;
+match_data match_block;
+match_data *md = &match_block;
+const pcre_uint8 *tables;
+const pcre_uint8 *start_bits = NULL;
+PCRE_PUCHAR start_match = (PCRE_PUCHAR)subject + start_offset;
+PCRE_PUCHAR end_subject;
+PCRE_PUCHAR start_partial = NULL;
+PCRE_PUCHAR match_partial = NULL;
+PCRE_PUCHAR req_char_ptr = start_match - 1;
+
+const pcre_study_data *study;
+const REAL_PCRE *re = (const REAL_PCRE *)argument_re;
+
+#ifdef NO_RECURSE
+heapframe frame_zero;
+frame_zero.Xprevframe = NULL;            /* Marks the top level */
+frame_zero.Xnextframe = NULL;            /* None are allocated yet */
+md->match_frames_base = &frame_zero;
+#endif
+
+/* Check for the special magic call that measures the size of the stack used
+per recursive call of match(). Without the funny casting for sizeof, a Windows
+compiler gave this error: "unary minus operator applied to unsigned type,
+result still unsigned". Hopefully the cast fixes that. */
+
+if (re == NULL && extra_data == NULL && subject == NULL && length == -999 &&
+    start_offset == -999)
+#ifdef NO_RECURSE
+  return -((int)sizeof(heapframe));
+#else
+  return match(NULL, NULL, NULL, 0, NULL, NULL, 0);
+#endif
+
+/* Plausibility checks */
+
+if ((options & ~PUBLIC_EXEC_OPTIONS) != 0) return PCRE_ERROR_BADOPTION;
+if (re == NULL || subject == NULL || (offsets == NULL && offsetcount > 0))
+  return PCRE_ERROR_NULL;
+if (offsetcount < 0) return PCRE_ERROR_BADCOUNT;
+if (length < 0) return PCRE_ERROR_BADLENGTH;
+if (start_offset < 0 || start_offset > length) return PCRE_ERROR_BADOFFSET;
+
+/* Check that the first field in the block is the magic number. If it is not,
+return with PCRE_ERROR_BADMAGIC. However, if the magic number is equal to
+REVERSED_MAGIC_NUMBER we return with PCRE_ERROR_BADENDIANNESS, which
+means that the pattern is likely compiled with different endianness. */
+
+if (re->magic_number != MAGIC_NUMBER)
+  return re->magic_number == REVERSED_MAGIC_NUMBER?
+    PCRE_ERROR_BADENDIANNESS:PCRE_ERROR_BADMAGIC;
+if ((re->flags & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE;
+
+/* These two settings are used in the code for checking a UTF-8 string that
+follows immediately afterwards. Other values in the md block are used only
+during "normal" pcre_exec() processing, not when the JIT support is in use,
+so they are set up later. */
+
+/* PCRE_UTF16 has the same value as PCRE_UTF8. */
+utf = md->utf = (re->options & PCRE_UTF8) != 0;
+md->partial = ((options & PCRE_PARTIAL_HARD) != 0)? 2 :
+              ((options & PCRE_PARTIAL_SOFT) != 0)? 1 : 0;
+
+/* Check a UTF-8 string if required. Pass back the character offset and error
+code for an invalid string if a results vector is available. */
+
+#ifdef SUPPORT_UTF
+if (utf && (options & PCRE_NO_UTF8_CHECK) == 0)
+  {
+  int erroroffset;
+  int errorcode = PRIV(valid_utf)((PCRE_PUCHAR)subject, length, &erroroffset);
+  if (errorcode != 0)
+    {
+    if (offsetcount >= 2)
+      {
+      offsets[0] = erroroffset;
+      offsets[1] = errorcode;
+      }
+#if defined COMPILE_PCRE8
+    return (errorcode <= PCRE_UTF8_ERR5 && md->partial > 1)?
+      PCRE_ERROR_SHORTUTF8 : PCRE_ERROR_BADUTF8;
+#elif defined COMPILE_PCRE16
+    return (errorcode <= PCRE_UTF16_ERR1 && md->partial > 1)?
+      PCRE_ERROR_SHORTUTF16 : PCRE_ERROR_BADUTF16;
+#elif defined COMPILE_PCRE32
+    return PCRE_ERROR_BADUTF32;
+#endif
+    }
+#if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
+  /* Check that a start_offset points to the start of a UTF character. */
+  if (start_offset > 0 && start_offset < length &&
+      NOT_FIRSTCHAR(((PCRE_PUCHAR)subject)[start_offset]))
+    return PCRE_ERROR_BADUTF8_OFFSET;
+#endif
+  }
+#endif
+
+/* If the pattern was successfully studied with JIT support, run the JIT
+executable instead of the rest of this function. Most options must be set at
+compile time for the JIT code to be usable. Fallback to the normal code path if
+an unsupported flag is set. */
+
+#ifdef SUPPORT_JIT
+if (extra_data != NULL
+    && (extra_data->flags & (PCRE_EXTRA_EXECUTABLE_JIT |
+                             PCRE_EXTRA_TABLES)) == PCRE_EXTRA_EXECUTABLE_JIT
+    && extra_data->executable_jit != NULL
+    && (options & ~PUBLIC_JIT_EXEC_OPTIONS) == 0)
+  {
+  rc = PRIV(jit_exec)(extra_data, (const pcre_uchar *)subject, length,
+       start_offset, options, offsets, offsetcount);
+
+  /* PCRE_ERROR_NULL means that the selected normal or partial matching
+  mode is not compiled. In this case we simply fallback to interpreter. */
+
+  if (rc != PCRE_ERROR_JIT_BADOPTION) return rc;
+  }
+#endif
+
+/* Carry on with non-JIT matching. This information is for finding all the
+numbers associated with a given name, for condition testing. */
+
+md->name_table = (pcre_uchar *)re + re->name_table_offset;
+md->name_count = re->name_count;
+md->name_entry_size = re->name_entry_size;
+
+/* Fish out the optional data from the extra_data structure, first setting
+the default values. */
+
+study = NULL;
+md->match_limit = MATCH_LIMIT;
+md->match_limit_recursion = MATCH_LIMIT_RECURSION;
+md->callout_data = NULL;
+
+/* The table pointer is always in native byte order. */
+
+tables = re->tables;
+
+/* The two limit values override the defaults, whatever their value. */
+
+if (extra_data != NULL)
+  {
+  unsigned long int flags = extra_data->flags;
+  if ((flags & PCRE_EXTRA_STUDY_DATA) != 0)
+    study = (const pcre_study_data *)extra_data->study_data;
+  if ((flags & PCRE_EXTRA_MATCH_LIMIT) != 0)
+    md->match_limit = extra_data->match_limit;
+  if ((flags & PCRE_EXTRA_MATCH_LIMIT_RECURSION) != 0)
+    md->match_limit_recursion = extra_data->match_limit_recursion;
+  if ((flags & PCRE_EXTRA_CALLOUT_DATA) != 0)
+    md->callout_data = extra_data->callout_data;
+  if ((flags & PCRE_EXTRA_TABLES) != 0) tables = extra_data->tables;
+  }
+
+/* Limits in the regex override only if they are smaller. */
+
+if ((re->flags & PCRE_MLSET) != 0 && re->limit_match < md->match_limit)
+  md->match_limit = re->limit_match;
+
+if ((re->flags & PCRE_RLSET) != 0 &&
+    re->limit_recursion < md->match_limit_recursion)
+  md->match_limit_recursion = re->limit_recursion;
+
+/* If the exec call supplied NULL for tables, use the inbuilt ones. This
+is a feature that makes it possible to save compiled regex and re-use them
+in other programs later. */
+
+if (tables == NULL) tables = PRIV(default_tables);
+
+/* Set up other data */
+
+anchored = ((re->options | options) & PCRE_ANCHORED) != 0;
+startline = (re->flags & PCRE_STARTLINE) != 0;
+firstline = (re->options & PCRE_FIRSTLINE) != 0;
+
+/* The code starts after the real_pcre block and the capture name table. */
+
+md->start_code = (const pcre_uchar *)re + re->name_table_offset +
+  re->name_count * re->name_entry_size;
+
+md->start_subject = (PCRE_PUCHAR)subject;
+md->start_offset = start_offset;
+md->end_subject = md->start_subject + length;
+end_subject = md->end_subject;
+
+md->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
+md->use_ucp = (re->options & PCRE_UCP) != 0;
+md->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
+md->ignore_skip_arg = 0;
+
+/* Some options are unpacked into BOOL variables in the hope that testing
+them will be faster than individual option bits. */
+
+md->notbol = (options & PCRE_NOTBOL) != 0;
+md->noteol = (options & PCRE_NOTEOL) != 0;
+md->notempty = (options & PCRE_NOTEMPTY) != 0;
+md->notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;
+
+md->hitend = FALSE;
+md->mark = md->nomatch_mark = NULL;     /* In case never set */
+
+md->recursive = NULL;                   /* No recursion at top level */
+md->hasthen = (re->flags & PCRE_HASTHEN) != 0;
+
+md->lcc = tables + lcc_offset;
+md->fcc = tables + fcc_offset;
+md->ctypes = tables + ctypes_offset;
+
+/* Handle different \R options. */
+
+switch (options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE))
+  {
+  case 0:
+  if ((re->options & (PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE)) != 0)
+    md->bsr_anycrlf = (re->options & PCRE_BSR_ANYCRLF) != 0;
+  else
+#ifdef BSR_ANYCRLF
+  md->bsr_anycrlf = TRUE;
+#else
+  md->bsr_anycrlf = FALSE;
+#endif
+  break;
+
+  case PCRE_BSR_ANYCRLF:
+  md->bsr_anycrlf = TRUE;
+  break;
+
+  case PCRE_BSR_UNICODE:
+  md->bsr_anycrlf = FALSE;
+  break;
+
+  default: return PCRE_ERROR_BADNEWLINE;
+  }
+
+/* Handle different types of newline. The three bits give eight cases. If
+nothing is set at run time, whatever was used at compile time applies. */
+
+switch ((((options & PCRE_NEWLINE_BITS) == 0)? re->options :
+        (pcre_uint32)options) & PCRE_NEWLINE_BITS)
+  {
+  case 0: newline = NEWLINE; break;   /* Compile-time default */
+  case PCRE_NEWLINE_CR: newline = CHAR_CR; break;
+  case PCRE_NEWLINE_LF: newline = CHAR_NL; break;
+  case PCRE_NEWLINE_CR+
+       PCRE_NEWLINE_LF: newline = (CHAR_CR << 8) | CHAR_NL; break;
+  case PCRE_NEWLINE_ANY: newline = -1; break;
+  case PCRE_NEWLINE_ANYCRLF: newline = -2; break;
+  default: return PCRE_ERROR_BADNEWLINE;
+  }
+
+if (newline == -2)
+  {
+  md->nltype = NLTYPE_ANYCRLF;
+  }
+else if (newline < 0)
+  {
+  md->nltype = NLTYPE_ANY;
+  }
+else
+  {
+  md->nltype = NLTYPE_FIXED;
+  if (newline > 255)
+    {
+    md->nllen = 2;
+    md->nl[0] = (newline >> 8) & 255;
+    md->nl[1] = newline & 255;
+    }
+  else
+    {
+    md->nllen = 1;
+    md->nl[0] = newline;
+    }
+  }
+
+/* Partial matching was originally supported only for a restricted set of
+regexes; from release 8.00 there are no restrictions, but the bits are still
+defined (though never set). So there's no harm in leaving this code. */
+
+if (md->partial && (re->flags & PCRE_NOPARTIAL) != 0)
+  return PCRE_ERROR_BADPARTIAL;
+
+/* If the expression has got more back references than the offsets supplied can
+hold, we get a temporary chunk of working store to use during the matching.
+Otherwise, we can use the vector supplied, rounding down its size to a multiple
+of 3. */
+
+ocount = offsetcount - (offsetcount % 3);
+arg_offset_max = (2*ocount)/3;
+
+if (re->top_backref > 0 && re->top_backref >= ocount/3)
+  {
+  ocount = re->top_backref * 3 + 3;
+  md->offset_vector = (int *)(PUBL(malloc))(ocount * sizeof(int));
+  if (md->offset_vector == NULL) return PCRE_ERROR_NOMEMORY;
+  using_temporary_offsets = TRUE;
+  DPRINTF(("Got memory to hold back references\n"));
+  }
+else md->offset_vector = offsets;
+md->offset_end = ocount;
+md->offset_max = (2*ocount)/3;
+md->capture_last = 0;
+
+/* Reset the working variable associated with each extraction. These should
+never be used unless previously set, but they get saved and restored, and so we
+initialize them to avoid reading uninitialized locations. Also, unset the
+offsets for the matched string. This is really just for tidiness with callouts,
+in case they inspect these fields. */
+
+if (md->offset_vector != NULL)
+  {
+  register int *iptr = md->offset_vector + ocount;
+  register int *iend = iptr - re->top_bracket;
+  if (iend < md->offset_vector + 2) iend = md->offset_vector + 2;
+  while (--iptr >= iend) *iptr = -1;
+  if (offsetcount > 0) md->offset_vector[0] = -1;
+  if (offsetcount > 1) md->offset_vector[1] = -1;
+  }
+
+/* Set up the first character to match, if available. The first_char value is
+never set for an anchored regular expression, but the anchoring may be forced
+at run time, so we have to test for anchoring. The first char may be unset for
+an unanchored pattern, of course. If there's no first char and the pattern was
+studied, there may be a bitmap of possible first characters. */
+
+if (!anchored)
+  {
+  if ((re->flags & PCRE_FIRSTSET) != 0)
+    {
+    has_first_char = TRUE;
+    first_char = first_char2 = (pcre_uchar)(re->first_char);
+    if ((re->flags & PCRE_FCH_CASELESS) != 0)
+      {
+      first_char2 = TABLE_GET(first_char, md->fcc, first_char);
+#if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
+      if (utf && first_char > 127)
+        first_char2 = UCD_OTHERCASE(first_char);
+#endif
+      }
+    }
+  else
+    if (!startline && study != NULL &&
+      (study->flags & PCRE_STUDY_MAPPED) != 0)
+        start_bits = study->start_bits;
+  }
+
+/* For anchored or unanchored matches, there may be a "last known required
+character" set. */
+
+if ((re->flags & PCRE_REQCHSET) != 0)
+  {
+  has_req_char = TRUE;
+  req_char = req_char2 = (pcre_uchar)(re->req_char);
+  if ((re->flags & PCRE_RCH_CASELESS) != 0)
+    {
+    req_char2 = TABLE_GET(req_char, md->fcc, req_char);
+#if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
+    if (utf && req_char > 127)
+      req_char2 = UCD_OTHERCASE(req_char);
+#endif
+    }
+  }
+
+
+/* ==========================================================================*/
+
+/* Loop for handling unanchored repeated matching attempts; for anchored regexs
+the loop runs just once. */
+
+for(;;)
+  {
+  PCRE_PUCHAR save_end_subject = end_subject;
+  PCRE_PUCHAR new_start_match;
+
+  /* If firstline is TRUE, the start of the match is constrained to the first
+  line of a multiline string. That is, the match must be before or at the first
+  newline. Implement this by temporarily adjusting end_subject so that we stop
+  scanning at a newline. If the match fails at the newline, later code breaks
+  this loop. */
+
+  if (firstline)
+    {
+    PCRE_PUCHAR t = start_match;
+#ifdef SUPPORT_UTF
+    if (utf)
+      {
+      while (t < md->end_subject && !IS_NEWLINE(t))
+        {
+        t++;
+        ACROSSCHAR(t < end_subject, *t, t++);
+        }
+      }
+    else
+#endif
+    while (t < md->end_subject && !IS_NEWLINE(t)) t++;
+    end_subject = t;
+    }
+
+  /* There are some optimizations that avoid running the match if a known
+  starting point is not found, or if a known later character is not present.
+  However, there is an option that disables these, for testing and for ensuring
+  that all callouts do actually occur. The option can be set in the regex by
+  (*NO_START_OPT) or passed in match-time options. */
+
+  if (((options | re->options) & PCRE_NO_START_OPTIMIZE) == 0)
+    {
+    /* Advance to a unique first char if there is one. */
+
+    if (has_first_char)
+      {
+      pcre_uchar smc;
+
+      if (first_char != first_char2)
+        while (start_match < end_subject &&
+          (smc = UCHAR21TEST(start_match)) != first_char && smc != first_char2)
+          start_match++;
+      else
+        while (start_match < end_subject && UCHAR21TEST(start_match) != first_char)
+          start_match++;
+      }
+
+    /* Or to just after a linebreak for a multiline match */
+
+    else if (startline)
+      {
+      if (start_match > md->start_subject + start_offset)
+        {
+#ifdef SUPPORT_UTF
+        if (utf)
+          {
+          while (start_match < end_subject && !WAS_NEWLINE(start_match))
+            {
+            start_match++;
+            ACROSSCHAR(start_match < end_subject, *start_match,
+              start_match++);
+            }
+          }
+        else
+#endif
+        while (start_match < end_subject && !WAS_NEWLINE(start_match))
+          start_match++;
+
+        /* If we have just passed a CR and the newline option is ANY or ANYCRLF,
+        and we are now at a LF, advance the match position by one more character.
+        */
+
+        if (start_match[-1] == CHAR_CR &&
+             (md->nltype == NLTYPE_ANY || md->nltype == NLTYPE_ANYCRLF) &&
+             start_match < end_subject &&
+             UCHAR21TEST(start_match) == CHAR_NL)
+          start_match++;
+        }
+      }
+
+    /* Or to a non-unique first byte after study */
+
+    else if (start_bits != NULL)
+      {
+      while (start_match < end_subject)
+        {
+        register pcre_uint32 c = UCHAR21TEST(start_match);
+#ifndef COMPILE_PCRE8
+        if (c > 255) c = 255;
+#endif
+        if ((start_bits[c/8] & (1 << (c&7))) != 0) break;
+        start_match++;
+        }
+      }
+    }   /* Starting optimizations */
+
+  /* Restore fudged end_subject */
+
+  end_subject = save_end_subject;
+
+  /* The following two optimizations are disabled for partial matching or if
+  disabling is explicitly requested. */
+
+  if (((options | re->options) & PCRE_NO_START_OPTIMIZE) == 0 && !md->partial)
+    {
+    /* If the pattern was studied, a minimum subject length may be set. This is
+    a lower bound; no actual string of that length may actually match the
+    pattern. Although the value is, strictly, in characters, we treat it as
+    bytes to avoid spending too much time in this optimization. */
+
+    if (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0 &&
+        (pcre_uint32)(end_subject - start_match) < study->minlength)
+      {
+      rc = MATCH_NOMATCH;
+      break;
+      }
+
+    /* If req_char is set, we know that that character must appear in the
+    subject for the match to succeed. If the first character is set, req_char
+    must be later in the subject; otherwise the test starts at the match point.
+    This optimization can save a huge amount of backtracking in patterns with
+    nested unlimited repeats that aren't going to match. Writing separate code
+    for cased/caseless versions makes it go faster, as does using an
+    autoincrement and backing off on a match.
+
+    HOWEVER: when the subject string is very, very long, searching to its end
+    can take a long time, and give bad performance on quite ordinary patterns.
+    This showed up when somebody was matching something like /^\d+C/ on a
+    32-megabyte string... so we don't do this when the string is sufficiently
+    long. */
+
+    if (has_req_char && end_subject - start_match < REQ_BYTE_MAX)
+      {
+      register PCRE_PUCHAR p = start_match + (has_first_char? 1:0);
+
+      /* We don't need to repeat the search if we haven't yet reached the
+      place we found it at last time. */
+
+      if (p > req_char_ptr)
+        {
+        if (req_char != req_char2)
+          {
+          while (p < end_subject)
+            {
+            register pcre_uint32 pp = UCHAR21INCTEST(p);
+            if (pp == req_char || pp == req_char2) { p--; break; }
+            }
+          }
+        else
+          {
+          while (p < end_subject)
+            {
+            if (UCHAR21INCTEST(p) == req_char) { p--; break; }
+            }
+          }
+
+        /* If we can't find the required character, break the matching loop,
+        forcing a match failure. */
+
+        if (p >= end_subject)
+          {
+          rc = MATCH_NOMATCH;
+          break;
+          }
+
+        /* If we have found the required character, save the point where we
+        found it, so that we don't search again next time round the loop if
+        the start hasn't passed this character yet. */
+
+        req_char_ptr = p;
+        }
+      }
+    }
+
+#ifdef PCRE_DEBUG  /* Sigh. Some compilers never learn. */
+  printf(">>>> Match against: ");
+  pchars(start_match, end_subject - start_match, TRUE, md);
+  printf("\n");
+#endif
+
+  /* OK, we can now run the match. If "hitend" is set afterwards, remember the
+  first starting point for which a partial match was found. */
+
+  md->start_match_ptr = start_match;
+  md->start_used_ptr = start_match;
+  md->match_call_count = 0;
+  md->match_function_type = 0;
+  md->end_offset_top = 0;
+  md->skip_arg_count = 0;
+  rc = match(start_match, md->start_code, start_match, 2, md, NULL, 0);
+  if (md->hitend && start_partial == NULL)
+    {
+    start_partial = md->start_used_ptr;
+    match_partial = start_match;
+    }
+
+  switch(rc)
+    {
+    /* If MATCH_SKIP_ARG reaches this level it means that a MARK that matched
+    the SKIP's arg was not found. In this circumstance, Perl ignores the SKIP
+    entirely. The only way we can do that is to re-do the match at the same
+    point, with a flag to force SKIP with an argument to be ignored. Just
+    treating this case as NOMATCH does not work because it does not check other
+    alternatives in patterns such as A(*SKIP:A)B|AC when the subject is AC. */
+
+    case MATCH_SKIP_ARG:
+    new_start_match = start_match;
+    md->ignore_skip_arg = md->skip_arg_count;
+    break;
+
+    /* SKIP passes back the next starting point explicitly, but if it is no
+    greater than the match we have just done, treat it as NOMATCH. */
+
+    case MATCH_SKIP:
+    if (md->start_match_ptr > start_match)
+      {
+      new_start_match = md->start_match_ptr;
+      break;
+      }
+    /* Fall through */
+
+    /* NOMATCH and PRUNE advance by one character. THEN at this level acts
+    exactly like PRUNE. Unset ignore SKIP-with-argument. */
+
+    case MATCH_NOMATCH:
+    case MATCH_PRUNE:
+    case MATCH_THEN:
+    md->ignore_skip_arg = 0;
+    new_start_match = start_match + 1;
+#ifdef SUPPORT_UTF
+    if (utf)
+      ACROSSCHAR(new_start_match < end_subject, *new_start_match,
+        new_start_match++);
+#endif
+    break;
+
+    /* COMMIT disables the bumpalong, but otherwise behaves as NOMATCH. */
+
+    case MATCH_COMMIT:
+    rc = MATCH_NOMATCH;
+    goto ENDLOOP;
+
+    /* Any other return is either a match, or some kind of error. */
+
+    default:
+    goto ENDLOOP;
+    }
+
+  /* Control reaches here for the various types of "no match at this point"
+  result. Reset the code to MATCH_NOMATCH for subsequent checking. */
+
+  rc = MATCH_NOMATCH;
+
+  /* If PCRE_FIRSTLINE is set, the match must happen before or at the first
+  newline in the subject (though it may continue over the newline). Therefore,
+  if we have just failed to match, starting at a newline, do not continue. */
+
+  if (firstline && IS_NEWLINE(start_match)) break;
+
+  /* Advance to new matching position */
+
+  start_match = new_start_match;
+
+  /* Break the loop if the pattern is anchored or if we have passed the end of
+  the subject. */
+
+  if (anchored || start_match > end_subject) break;
+
+  /* If we have just passed a CR and we are now at a LF, and the pattern does
+  not contain any explicit matches for \r or \n, and the newline option is CRLF
+  or ANY or ANYCRLF, advance the match position by one more character. In
+  normal matching start_match will aways be greater than the first position at
+  this stage, but a failed *SKIP can cause a return at the same point, which is
+  why the first test exists. */
+
+  if (start_match > (PCRE_PUCHAR)subject + start_offset &&
+      start_match[-1] == CHAR_CR &&
+      start_match < end_subject &&
+      *start_match == CHAR_NL &&
+      (re->flags & PCRE_HASCRORLF) == 0 &&
+        (md->nltype == NLTYPE_ANY ||
+         md->nltype == NLTYPE_ANYCRLF ||
+         md->nllen == 2))
+    start_match++;
+
+  md->mark = NULL;   /* Reset for start of next match attempt */
+  }                  /* End of for(;;) "bumpalong" loop */
+
+/* ==========================================================================*/
+
+/* We reach here when rc is not MATCH_NOMATCH, or if one of the stopping
+conditions is true:
+
+(1) The pattern is anchored or the match was failed by (*COMMIT);
+
+(2) We are past the end of the subject;
+
+(3) PCRE_FIRSTLINE is set and we have failed to match at a newline, because
+    this option requests that a match occur at or before the first newline in
+    the subject.
+
+When we have a match and the offset vector is big enough to deal with any
+backreferences, captured substring offsets will already be set up. In the case
+where we had to get some local store to hold offsets for backreference
+processing, copy those that we can. In this case there need not be overflow if
+certain parts of the pattern were not used, even though there are more
+capturing parentheses than vector slots. */
+
+ENDLOOP:
+
+if (rc == MATCH_MATCH || rc == MATCH_ACCEPT)
+  {
+  if (using_temporary_offsets)
+    {
+    if (arg_offset_max >= 4)
+      {
+      memcpy(offsets + 2, md->offset_vector + 2,
+        (arg_offset_max - 2) * sizeof(int));
+      DPRINTF(("Copied offsets from temporary memory\n"));
+      }
+    if (md->end_offset_top > arg_offset_max) md->capture_last |= OVFLBIT;
+    DPRINTF(("Freeing temporary memory\n"));
+    (PUBL(free))(md->offset_vector);
+    }
+
+  /* Set the return code to the number of captured strings, or 0 if there were
+  too many to fit into the vector. */
+
+  rc = ((md->capture_last & OVFLBIT) != 0 &&
+         md->end_offset_top >= arg_offset_max)?
+    0 : md->end_offset_top/2;
+
+  /* If there is space in the offset vector, set any unused pairs at the end of
+  the pattern to -1 for backwards compatibility. It is documented that this
+  happens. In earlier versions, the whole set of potential capturing offsets
+  was set to -1 each time round the loop, but this is handled differently now.
+  "Gaps" are set to -1 dynamically instead (this fixes a bug). Thus, it is only
+  those at the end that need unsetting here. We can't just unset them all at
+  the start of the whole thing because they may get set in one branch that is
+  not the final matching branch. */
+
+  if (md->end_offset_top/2 <= re->top_bracket && offsets != NULL)
+    {
+    register int *iptr, *iend;
+    int resetcount = 2 + re->top_bracket * 2;
+    if (resetcount > offsetcount) resetcount = offsetcount;
+    iptr = offsets + md->end_offset_top;
+    iend = offsets + resetcount;
+    while (iptr < iend) *iptr++ = -1;
+    }
+
+  /* If there is space, set up the whole thing as substring 0. The value of
+  md->start_match_ptr might be modified if \K was encountered on the success
+  matching path. */
+
+  if (offsetcount < 2) rc = 0; else
+    {
+    offsets[0] = (int)(md->start_match_ptr - md->start_subject);
+    offsets[1] = (int)(md->end_match_ptr - md->start_subject);
+    }
+
+  /* Return MARK data if requested */
+
+  if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
+    *(extra_data->mark) = (pcre_uchar *)md->mark;
+  DPRINTF((">>>> returning %d\n", rc));
+#ifdef NO_RECURSE
+  release_match_heapframes(&frame_zero);
+#endif
+  return rc;
+  }
+
+/* Control gets here if there has been an error, or if the overall match
+attempt has failed at all permitted starting positions. */
+
+if (using_temporary_offsets)
+  {
+  DPRINTF(("Freeing temporary memory\n"));
+  (PUBL(free))(md->offset_vector);
+  }
+
+/* For anything other than nomatch or partial match, just return the code. */
+
+if (rc != MATCH_NOMATCH && rc != PCRE_ERROR_PARTIAL)
+  {
+  DPRINTF((">>>> error: returning %d\n", rc));
+#ifdef NO_RECURSE
+  release_match_heapframes(&frame_zero);
+#endif
+  return rc;
+  }
+
+/* Handle partial matches - disable any mark data */
+
+if (match_partial != NULL)
+  {
+  DPRINTF((">>>> returning PCRE_ERROR_PARTIAL\n"));
+  md->mark = NULL;
+  if (offsetcount > 1)
+    {
+    offsets[0] = (int)(start_partial - (PCRE_PUCHAR)subject);
+    offsets[1] = (int)(end_subject - (PCRE_PUCHAR)subject);
+    if (offsetcount > 2)
+      offsets[2] = (int)(match_partial - (PCRE_PUCHAR)subject);
+    }
+  rc = PCRE_ERROR_PARTIAL;
+  }
+
+/* This is the classic nomatch case */
+
+else
+  {
+  DPRINTF((">>>> returning PCRE_ERROR_NOMATCH\n"));
+  rc = PCRE_ERROR_NOMATCH;
+  }
+
+/* Return the MARK data if it has been requested. */
+
+if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_MARK) != 0)
+  *(extra_data->mark) = (pcre_uchar *)md->nomatch_mark;
+#ifdef NO_RECURSE
+  release_match_heapframes(&frame_zero);
+#endif
+return rc;
+}
+
+/* End of pcre_exec.c */
diff --git a/base/poco/Foundation/src/pcre_fullinfo.c b/base/poco/Foundation/src/pcre_fullinfo.c
new file mode 100644
index 00000000000..5ad19251d8f
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_fullinfo.c
@@ -0,0 +1,242 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2013 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+
+/* This module contains the external function pcre_fullinfo(), which returns
+information about a compiled pattern. */
+
+
+#include "pcre_config.h"
+#include "pcre_internal.h"
+
+
+/*************************************************
+*        Return info about compiled pattern      *
+*************************************************/
+
+/* This is a newer "info" function which has an extensible interface so
+that additional items can be added compatibly.
+
+Arguments:
+  argument_re      points to compiled code
+  extra_data       points extra data, or NULL
+  what             what information is required
+  where            where to put the information
+
+Returns:           0 if data returned, negative on error
+*/
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre_fullinfo(const pcre *argument_re, const pcre_extra *extra_data,
+  int what, void *where)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre16_fullinfo(const pcre16 *argument_re, const pcre16_extra *extra_data,
+  int what, void *where)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre32_fullinfo(const pcre32 *argument_re, const pcre32_extra *extra_data,
+  int what, void *where)
+#endif
+{
+const REAL_PCRE *re = (const REAL_PCRE *)argument_re;
+const pcre_study_data *study = NULL;
+
+if (re == NULL || where == NULL) return PCRE_ERROR_NULL;
+
+if (extra_data != NULL && (extra_data->flags & PCRE_EXTRA_STUDY_DATA) != 0)
+  study = (const pcre_study_data *)extra_data->study_data;
+
+/* Check that the first field in the block is the magic number. If it is not,
+return with PCRE_ERROR_BADMAGIC. However, if the magic number is equal to
+REVERSED_MAGIC_NUMBER we return with PCRE_ERROR_BADENDIANNESS, which
+means that the pattern is likely compiled with different endianness. */
+
+if (re->magic_number != MAGIC_NUMBER)
+  return re->magic_number == REVERSED_MAGIC_NUMBER?
+    PCRE_ERROR_BADENDIANNESS:PCRE_ERROR_BADMAGIC;
+
+/* Check that this pattern was compiled in the correct bit mode */
+
+if ((re->flags & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE;
+
+switch (what)
+  {
+  case PCRE_INFO_OPTIONS:
+  *((unsigned long int *)where) = re->options & PUBLIC_COMPILE_OPTIONS;
+  break;
+
+  case PCRE_INFO_SIZE:
+  *((size_t *)where) = re->size;
+  break;
+
+  case PCRE_INFO_STUDYSIZE:
+  *((size_t *)where) = (study == NULL)? 0 : study->size;
+  break;
+
+  case PCRE_INFO_JITSIZE:
+#ifdef SUPPORT_JIT
+  *((size_t *)where) =
+      (extra_data != NULL &&
+      (extra_data->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 &&
+      extra_data->executable_jit != NULL)?
+    PRIV(jit_get_size)(extra_data->executable_jit) : 0;
+#else
+  *((size_t *)where) = 0;
+#endif
+  break;
+
+  case PCRE_INFO_CAPTURECOUNT:
+  *((int *)where) = re->top_bracket;
+  break;
+
+  case PCRE_INFO_BACKREFMAX:
+  *((int *)where) = re->top_backref;
+  break;
+
+  case PCRE_INFO_FIRSTBYTE:
+  *((int *)where) =
+    ((re->flags & PCRE_FIRSTSET) != 0)? (int)re->first_char :
+    ((re->flags & PCRE_STARTLINE) != 0)? -1 : -2;
+  break;
+
+  case PCRE_INFO_FIRSTCHARACTER:
+    *((pcre_uint32 *)where) =
+      (re->flags & PCRE_FIRSTSET) != 0 ? re->first_char : 0;
+    break;
+
+  case PCRE_INFO_FIRSTCHARACTERFLAGS:
+    *((int *)where) =
+      ((re->flags & PCRE_FIRSTSET) != 0) ? 1 :
+      ((re->flags & PCRE_STARTLINE) != 0) ? 2 : 0;
+    break;
+
+  /* Make sure we pass back the pointer to the bit vector in the external
+  block, not the internal copy (with flipped integer fields). */
+
+  case PCRE_INFO_FIRSTTABLE:
+  *((const pcre_uint8 **)where) =
+    (study != NULL && (study->flags & PCRE_STUDY_MAPPED) != 0)?
+      ((const pcre_study_data *)extra_data->study_data)->start_bits : NULL;
+  break;
+
+  case PCRE_INFO_MINLENGTH:
+  *((int *)where) =
+    (study != NULL && (study->flags & PCRE_STUDY_MINLEN) != 0)?
+      (int)(study->minlength) : -1;
+  break;
+
+  case PCRE_INFO_JIT:
+  *((int *)where) = extra_data != NULL &&
+                    (extra_data->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 &&
+                    extra_data->executable_jit != NULL;
+  break;
+
+  case PCRE_INFO_LASTLITERAL:
+  *((int *)where) =
+    ((re->flags & PCRE_REQCHSET) != 0)? (int)re->req_char : -1;
+  break;
+
+  case PCRE_INFO_REQUIREDCHAR:
+    *((pcre_uint32 *)where) =
+      ((re->flags & PCRE_REQCHSET) != 0) ? re->req_char : 0;
+    break;
+
+  case PCRE_INFO_REQUIREDCHARFLAGS:
+    *((int *)where) =
+      ((re->flags & PCRE_REQCHSET) != 0);
+    break;
+
+  case PCRE_INFO_NAMEENTRYSIZE:
+  *((int *)where) = re->name_entry_size;
+  break;
+
+  case PCRE_INFO_NAMECOUNT:
+  *((int *)where) = re->name_count;
+  break;
+
+  case PCRE_INFO_NAMETABLE:
+  *((const pcre_uchar **)where) = (const pcre_uchar *)re + re->name_table_offset;
+  break;
+
+  case PCRE_INFO_DEFAULT_TABLES:
+  *((const pcre_uint8 **)where) = (const pcre_uint8 *)(PRIV(default_tables));
+  break;
+
+  /* From release 8.00 this will always return TRUE because NOPARTIAL is
+  no longer ever set (the restrictions have been removed). */
+
+  case PCRE_INFO_OKPARTIAL:
+  *((int *)where) = (re->flags & PCRE_NOPARTIAL) == 0;
+  break;
+
+  case PCRE_INFO_JCHANGED:
+  *((int *)where) = (re->flags & PCRE_JCHANGED) != 0;
+  break;
+
+  case PCRE_INFO_HASCRORLF:
+  *((int *)where) = (re->flags & PCRE_HASCRORLF) != 0;
+  break;
+
+  case PCRE_INFO_MAXLOOKBEHIND:
+  *((int *)where) = re->max_lookbehind;
+  break;
+
+  case PCRE_INFO_MATCHLIMIT:
+  if ((re->flags & PCRE_MLSET) == 0) return PCRE_ERROR_UNSET;
+  *((pcre_uint32 *)where) = re->limit_match;
+  break;
+
+  case PCRE_INFO_RECURSIONLIMIT:
+  if ((re->flags & PCRE_RLSET) == 0) return PCRE_ERROR_UNSET;
+  *((pcre_uint32 *)where) = re->limit_recursion;
+  break;
+
+  case PCRE_INFO_MATCH_EMPTY:
+  *((int *)where) = (re->flags & PCRE_MATCH_EMPTY) != 0;
+  break;
+
+  default: return PCRE_ERROR_BADOPTION;
+  }
+
+return 0;
+}
+
+/* End of pcre_fullinfo.c */
diff --git a/base/poco/Foundation/src/pcre_get.c b/base/poco/Foundation/src/pcre_get.c
new file mode 100644
index 00000000000..34fcaf19c61
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_get.c
@@ -0,0 +1,666 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2012 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+
+/* This module contains some convenience functions for extracting substrings
+from the subject string after a regex match has succeeded. The original idea
+for these functions came from Scott Wimer. */
+
+
+#include "pcre_config.h"
+#include "pcre_internal.h"
+
+
+/*************************************************
+*           Find number for named string         *
+*************************************************/
+
+/* This function is used by the get_first_set() function below, as well
+as being generally available. It assumes that names are unique.
+
+Arguments:
+  code        the compiled regex
+  stringname  the name whose number is required
+
+Returns:      the number of the named parentheses, or a negative number
+                (PCRE_ERROR_NOSUBSTRING) if not found
+*/
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre_get_stringnumber(const pcre *code, const char *stringname)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre16_get_stringnumber(const pcre16 *code, PCRE_SPTR16 stringname)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre32_get_stringnumber(const pcre32 *code, PCRE_SPTR32 stringname)
+#endif
+{
+int rc;
+int entrysize;
+int top, bot;
+pcre_uchar *nametable;
+
+#ifdef COMPILE_PCRE8
+if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
+  return rc;
+if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
+
+if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
+  return rc;
+if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
+  return rc;
+#endif
+#ifdef COMPILE_PCRE16
+if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
+  return rc;
+if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
+
+if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
+  return rc;
+if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
+  return rc;
+#endif
+#ifdef COMPILE_PCRE32
+if ((rc = pcre32_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
+  return rc;
+if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
+
+if ((rc = pcre32_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
+  return rc;
+if ((rc = pcre32_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
+  return rc;
+#endif
+
+bot = 0;
+while (top > bot)
+  {
+  int mid = (top + bot) / 2;
+  pcre_uchar *entry = nametable + entrysize*mid;
+  int c = STRCMP_UC_UC((pcre_uchar *)stringname,
+    (pcre_uchar *)(entry + IMM2_SIZE));
+  if (c == 0) return GET2(entry, 0);
+  if (c > 0) bot = mid + 1; else top = mid;
+  }
+
+return PCRE_ERROR_NOSUBSTRING;
+}
+
+
+
+/*************************************************
+*     Find (multiple) entries for named string   *
+*************************************************/
+
+/* This is used by the get_first_set() function below, as well as being
+generally available. It is used when duplicated names are permitted.
+
+Arguments:
+  code        the compiled regex
+  stringname  the name whose entries required
+  firstptr    where to put the pointer to the first entry
+  lastptr     where to put the pointer to the last entry
+
+Returns:      the length of each entry, or a negative number
+                (PCRE_ERROR_NOSUBSTRING) if not found
+*/
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre_get_stringtable_entries(const pcre *code, const char *stringname,
+  char **firstptr, char **lastptr)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre16_get_stringtable_entries(const pcre16 *code, PCRE_SPTR16 stringname,
+  PCRE_UCHAR16 **firstptr, PCRE_UCHAR16 **lastptr)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre32_get_stringtable_entries(const pcre32 *code, PCRE_SPTR32 stringname,
+  PCRE_UCHAR32 **firstptr, PCRE_UCHAR32 **lastptr)
+#endif
+{
+int rc;
+int entrysize;
+int top, bot;
+pcre_uchar *nametable, *lastentry;
+
+#ifdef COMPILE_PCRE8
+if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
+  return rc;
+if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
+
+if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
+  return rc;
+if ((rc = pcre_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
+  return rc;
+#endif
+#ifdef COMPILE_PCRE16
+if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
+  return rc;
+if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
+
+if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
+  return rc;
+if ((rc = pcre16_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
+  return rc;
+#endif
+#ifdef COMPILE_PCRE32
+if ((rc = pcre32_fullinfo(code, NULL, PCRE_INFO_NAMECOUNT, &top)) != 0)
+  return rc;
+if (top <= 0) return PCRE_ERROR_NOSUBSTRING;
+
+if ((rc = pcre32_fullinfo(code, NULL, PCRE_INFO_NAMEENTRYSIZE, &entrysize)) != 0)
+  return rc;
+if ((rc = pcre32_fullinfo(code, NULL, PCRE_INFO_NAMETABLE, &nametable)) != 0)
+  return rc;
+#endif
+
+lastentry = nametable + entrysize * (top - 1);
+bot = 0;
+while (top > bot)
+  {
+  int mid = (top + bot) / 2;
+  pcre_uchar *entry = nametable + entrysize*mid;
+  int c = STRCMP_UC_UC((pcre_uchar *)stringname,
+    (pcre_uchar *)(entry + IMM2_SIZE));
+  if (c == 0)
+    {
+    pcre_uchar *first = entry;
+    pcre_uchar *last = entry;
+    while (first > nametable)
+      {
+      if (STRCMP_UC_UC((pcre_uchar *)stringname,
+        (pcre_uchar *)(first - entrysize + IMM2_SIZE)) != 0) break;
+      first -= entrysize;
+      }
+    while (last < lastentry)
+      {
+      if (STRCMP_UC_UC((pcre_uchar *)stringname,
+        (pcre_uchar *)(last + entrysize + IMM2_SIZE)) != 0) break;
+      last += entrysize;
+      }
+#if defined COMPILE_PCRE8
+    *firstptr = (char *)first;
+    *lastptr = (char *)last;
+#elif defined COMPILE_PCRE16
+    *firstptr = (PCRE_UCHAR16 *)first;
+    *lastptr = (PCRE_UCHAR16 *)last;
+#elif defined COMPILE_PCRE32
+    *firstptr = (PCRE_UCHAR32 *)first;
+    *lastptr = (PCRE_UCHAR32 *)last;
+#endif
+    return entrysize;
+    }
+  if (c > 0) bot = mid + 1; else top = mid;
+  }
+
+return PCRE_ERROR_NOSUBSTRING;
+}
+
+
+
+/*************************************************
+*    Find first set of multiple named strings    *
+*************************************************/
+
+/* This function allows for duplicate names in the table of named substrings.
+It returns the number of the first one that was set in a pattern match.
+
+Arguments:
+  code         the compiled regex
+  stringname   the name of the capturing substring
+  ovector      the vector of matched substrings
+  stringcount  number of captured substrings
+
+Returns:       the number of the first that is set,
+               or the number of the last one if none are set,
+               or a negative number on error
+*/
+
+#if defined COMPILE_PCRE8
+static int
+get_first_set(const pcre *code, const char *stringname, int *ovector,
+  int stringcount)
+#elif defined COMPILE_PCRE16
+static int
+get_first_set(const pcre16 *code, PCRE_SPTR16 stringname, int *ovector,
+  int stringcount)
+#elif defined COMPILE_PCRE32
+static int
+get_first_set(const pcre32 *code, PCRE_SPTR32 stringname, int *ovector,
+  int stringcount)
+#endif
+{
+const REAL_PCRE *re = (const REAL_PCRE *)code;
+int entrysize;
+pcre_uchar *entry;
+#if defined COMPILE_PCRE8
+char *first, *last;
+#elif defined COMPILE_PCRE16
+PCRE_UCHAR16 *first, *last;
+#elif defined COMPILE_PCRE32
+PCRE_UCHAR32 *first, *last;
+#endif
+
+#if defined COMPILE_PCRE8
+if ((re->options & PCRE_DUPNAMES) == 0 && (re->flags & PCRE_JCHANGED) == 0)
+  return pcre_get_stringnumber(code, stringname);
+entrysize = pcre_get_stringtable_entries(code, stringname, &first, &last);
+#elif defined COMPILE_PCRE16
+if ((re->options & PCRE_DUPNAMES) == 0 && (re->flags & PCRE_JCHANGED) == 0)
+  return pcre16_get_stringnumber(code, stringname);
+entrysize = pcre16_get_stringtable_entries(code, stringname, &first, &last);
+#elif defined COMPILE_PCRE32
+if ((re->options & PCRE_DUPNAMES) == 0 && (re->flags & PCRE_JCHANGED) == 0)
+  return pcre32_get_stringnumber(code, stringname);
+entrysize = pcre32_get_stringtable_entries(code, stringname, &first, &last);
+#endif
+if (entrysize <= 0) return entrysize;
+for (entry = (pcre_uchar *)first; entry <= (pcre_uchar *)last; entry += entrysize)
+  {
+  int n = GET2(entry, 0);
+  if (n < stringcount && ovector[n*2] >= 0) return n;
+  }
+return GET2(entry, 0);
+}
+
+
+
+
+/*************************************************
+*      Copy captured string to given buffer      *
+*************************************************/
+
+/* This function copies a single captured substring into a given buffer.
+Note that we use memcpy() rather than strncpy() in case there are binary zeros
+in the string.
+
+Arguments:
+  subject        the subject string that was matched
+  ovector        pointer to the offsets table
+  stringcount    the number of substrings that were captured
+                   (i.e. the yield of the pcre_exec call, unless
+                   that was zero, in which case it should be 1/3
+                   of the offset table size)
+  stringnumber   the number of the required substring
+  buffer         where to put the substring
+  size           the size of the buffer
+
+Returns:         if successful:
+                   the length of the copied string, not including the zero
+                   that is put on the end; can be zero
+                 if not successful:
+                   PCRE_ERROR_NOMEMORY (-6) buffer too small
+                   PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
+*/
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre_copy_substring(const char *subject, int *ovector, int stringcount,
+  int stringnumber, char *buffer, int size)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre16_copy_substring(PCRE_SPTR16 subject, int *ovector, int stringcount,
+  int stringnumber, PCRE_UCHAR16 *buffer, int size)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre32_copy_substring(PCRE_SPTR32 subject, int *ovector, int stringcount,
+  int stringnumber, PCRE_UCHAR32 *buffer, int size)
+#endif
+{
+int yield;
+if (stringnumber < 0 || stringnumber >= stringcount)
+  return PCRE_ERROR_NOSUBSTRING;
+stringnumber *= 2;
+yield = ovector[stringnumber+1] - ovector[stringnumber];
+if (size < yield + 1) return PCRE_ERROR_NOMEMORY;
+memcpy(buffer, subject + ovector[stringnumber], IN_UCHARS(yield));
+buffer[yield] = 0;
+return yield;
+}
+
+
+
+/*************************************************
+*   Copy named captured string to given buffer   *
+*************************************************/
+
+/* This function copies a single captured substring into a given buffer,
+identifying it by name. If the regex permits duplicate names, the first
+substring that is set is chosen.
+
+Arguments:
+  code           the compiled regex
+  subject        the subject string that was matched
+  ovector        pointer to the offsets table
+  stringcount    the number of substrings that were captured
+                   (i.e. the yield of the pcre_exec call, unless
+                   that was zero, in which case it should be 1/3
+                   of the offset table size)
+  stringname     the name of the required substring
+  buffer         where to put the substring
+  size           the size of the buffer
+
+Returns:         if successful:
+                   the length of the copied string, not including the zero
+                   that is put on the end; can be zero
+                 if not successful:
+                   PCRE_ERROR_NOMEMORY (-6) buffer too small
+                   PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
+*/
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre_copy_named_substring(const pcre *code, const char *subject,
+  int *ovector, int stringcount, const char *stringname,
+  char *buffer, int size)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre16_copy_named_substring(const pcre16 *code, PCRE_SPTR16 subject,
+  int *ovector, int stringcount, PCRE_SPTR16 stringname,
+  PCRE_UCHAR16 *buffer, int size)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre32_copy_named_substring(const pcre32 *code, PCRE_SPTR32 subject,
+  int *ovector, int stringcount, PCRE_SPTR32 stringname,
+  PCRE_UCHAR32 *buffer, int size)
+#endif
+{
+int n = get_first_set(code, stringname, ovector, stringcount);
+if (n <= 0) return n;
+#if defined COMPILE_PCRE8
+return pcre_copy_substring(subject, ovector, stringcount, n, buffer, size);
+#elif defined COMPILE_PCRE16
+return pcre16_copy_substring(subject, ovector, stringcount, n, buffer, size);
+#elif defined COMPILE_PCRE32
+return pcre32_copy_substring(subject, ovector, stringcount, n, buffer, size);
+#endif
+}
+
+
+
+/*************************************************
+*      Copy all captured strings to new store    *
+*************************************************/
+
+/* This function gets one chunk of store and builds a list of pointers and all
+of the captured substrings in it. A NULL pointer is put on the end of the list.
+
+Arguments:
+  subject        the subject string that was matched
+  ovector        pointer to the offsets table
+  stringcount    the number of substrings that were captured
+                   (i.e. the yield of the pcre_exec call, unless
+                   that was zero, in which case it should be 1/3
+                   of the offset table size)
+  listptr        set to point to the list of pointers
+
+Returns:         if successful: 0
+                 if not successful:
+                   PCRE_ERROR_NOMEMORY (-6) failed to get store
+*/
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre_get_substring_list(const char *subject, int *ovector, int stringcount,
+  const char ***listptr)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre16_get_substring_list(PCRE_SPTR16 subject, int *ovector, int stringcount,
+  PCRE_SPTR16 **listptr)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre32_get_substring_list(PCRE_SPTR32 subject, int *ovector, int stringcount,
+  PCRE_SPTR32 **listptr)
+#endif
+{
+int i;
+int size = sizeof(pcre_uchar *);
+int double_count = stringcount * 2;
+pcre_uchar **stringlist;
+pcre_uchar *p;
+
+for (i = 0; i < double_count; i += 2)
+  {
+  size += sizeof(pcre_uchar *) + IN_UCHARS(1);
+  if (ovector[i+1] > ovector[i]) size += IN_UCHARS(ovector[i+1] - ovector[i]);
+  }
+
+stringlist = (pcre_uchar **)(PUBL(malloc))(size);
+if (stringlist == NULL) return PCRE_ERROR_NOMEMORY;
+
+#if defined COMPILE_PCRE8
+*listptr = (const char **)stringlist;
+#elif defined COMPILE_PCRE16
+*listptr = (PCRE_SPTR16 *)stringlist;
+#elif defined COMPILE_PCRE32
+*listptr = (PCRE_SPTR32 *)stringlist;
+#endif
+p = (pcre_uchar *)(stringlist + stringcount + 1);
+
+for (i = 0; i < double_count; i += 2)
+  {
+  int len = (ovector[i+1] > ovector[i])? (ovector[i+1] - ovector[i]) : 0;
+  memcpy(p, subject + ovector[i], IN_UCHARS(len));
+  *stringlist++ = p;
+  p += len;
+  *p++ = 0;
+  }
+
+*stringlist = NULL;
+return 0;
+}
+
+
+
+/*************************************************
+*   Free store obtained by get_substring_list    *
+*************************************************/
+
+/* This function exists for the benefit of people calling PCRE from non-C
+programs that can call its functions, but not free() or (PUBL(free))()
+directly.
+
+Argument:   the result of a previous pcre_get_substring_list()
+Returns:    nothing
+*/
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
+pcre_free_substring_list(const char **pointer)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
+pcre16_free_substring_list(PCRE_SPTR16 *pointer)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
+pcre32_free_substring_list(PCRE_SPTR32 *pointer)
+#endif
+{
+(PUBL(free))((void *)pointer);
+}
+
+
+
+/*************************************************
+*      Copy captured string to new store         *
+*************************************************/
+
+/* This function copies a single captured substring into a piece of new
+store
+
+Arguments:
+  subject        the subject string that was matched
+  ovector        pointer to the offsets table
+  stringcount    the number of substrings that were captured
+                   (i.e. the yield of the pcre_exec call, unless
+                   that was zero, in which case it should be 1/3
+                   of the offset table size)
+  stringnumber   the number of the required substring
+  stringptr      where to put a pointer to the substring
+
+Returns:         if successful:
+                   the length of the string, not including the zero that
+                   is put on the end; can be zero
+                 if not successful:
+                   PCRE_ERROR_NOMEMORY (-6) failed to get store
+                   PCRE_ERROR_NOSUBSTRING (-7) substring not present
+*/
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre_get_substring(const char *subject, int *ovector, int stringcount,
+  int stringnumber, const char **stringptr)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre16_get_substring(PCRE_SPTR16 subject, int *ovector, int stringcount,
+  int stringnumber, PCRE_SPTR16 *stringptr)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre32_get_substring(PCRE_SPTR32 subject, int *ovector, int stringcount,
+  int stringnumber, PCRE_SPTR32 *stringptr)
+#endif
+{
+int yield;
+pcre_uchar *substring;
+if (stringnumber < 0 || stringnumber >= stringcount)
+  return PCRE_ERROR_NOSUBSTRING;
+stringnumber *= 2;
+yield = ovector[stringnumber+1] - ovector[stringnumber];
+substring = (pcre_uchar *)(PUBL(malloc))(IN_UCHARS(yield + 1));
+if (substring == NULL) return PCRE_ERROR_NOMEMORY;
+memcpy(substring, subject + ovector[stringnumber], IN_UCHARS(yield));
+substring[yield] = 0;
+#if defined COMPILE_PCRE8
+*stringptr = (const char *)substring;
+#elif defined COMPILE_PCRE16
+*stringptr = (PCRE_SPTR16)substring;
+#elif defined COMPILE_PCRE32
+*stringptr = (PCRE_SPTR32)substring;
+#endif
+return yield;
+}
+
+
+
+/*************************************************
+*   Copy named captured string to new store      *
+*************************************************/
+
+/* This function copies a single captured substring, identified by name, into
+new store. If the regex permits duplicate names, the first substring that is
+set is chosen.
+
+Arguments:
+  code           the compiled regex
+  subject        the subject string that was matched
+  ovector        pointer to the offsets table
+  stringcount    the number of substrings that were captured
+                   (i.e. the yield of the pcre_exec call, unless
+                   that was zero, in which case it should be 1/3
+                   of the offset table size)
+  stringname     the name of the required substring
+  stringptr      where to put the pointer
+
+Returns:         if successful:
+                   the length of the copied string, not including the zero
+                   that is put on the end; can be zero
+                 if not successful:
+                   PCRE_ERROR_NOMEMORY (-6) couldn't get memory
+                   PCRE_ERROR_NOSUBSTRING (-7) no such captured substring
+*/
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre_get_named_substring(const pcre *code, const char *subject,
+  int *ovector, int stringcount, const char *stringname,
+  const char **stringptr)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre16_get_named_substring(const pcre16 *code, PCRE_SPTR16 subject,
+  int *ovector, int stringcount, PCRE_SPTR16 stringname,
+  PCRE_SPTR16 *stringptr)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre32_get_named_substring(const pcre32 *code, PCRE_SPTR32 subject,
+  int *ovector, int stringcount, PCRE_SPTR32 stringname,
+  PCRE_SPTR32 *stringptr)
+#endif
+{
+int n = get_first_set(code, stringname, ovector, stringcount);
+if (n <= 0) return n;
+#if defined COMPILE_PCRE8
+return pcre_get_substring(subject, ovector, stringcount, n, stringptr);
+#elif defined COMPILE_PCRE16
+return pcre16_get_substring(subject, ovector, stringcount, n, stringptr);
+#elif defined COMPILE_PCRE32
+return pcre32_get_substring(subject, ovector, stringcount, n, stringptr);
+#endif
+}
+
+
+
+
+/*************************************************
+*       Free store obtained by get_substring     *
+*************************************************/
+
+/* This function exists for the benefit of people calling PCRE from non-C
+programs that can call its functions, but not free() or (PUBL(free))()
+directly.
+
+Argument:   the result of a previous pcre_get_substring()
+Returns:    nothing
+*/
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
+pcre_free_substring(const char *pointer)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
+pcre16_free_substring(PCRE_SPTR16 pointer)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN void PCRE_CALL_CONVENTION
+pcre32_free_substring(PCRE_SPTR32 pointer)
+#endif
+{
+(PUBL(free))((void *)pointer);
+}
+
+/* End of pcre_get.c */
diff --git a/base/poco/Foundation/src/pcre_globals.c b/base/poco/Foundation/src/pcre_globals.c
new file mode 100644
index 00000000000..9b2329a325b
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_globals.c
@@ -0,0 +1,83 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2014 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+
+/* This module contains global variables that are exported by the PCRE library.
+PCRE is thread-clean and doesn't use any global variables in the normal sense.
+However, it calls memory allocation and freeing functions via the four
+indirections below, and it can optionally do callouts, using the fifth
+indirection. These values can be changed by the caller, but are shared between
+all threads.
+
+For MS Visual Studio and Symbian OS, there are problems in initializing these
+variables to non-local functions. In these cases, therefore, an indirection via
+a local function is used.
+
+Also, when compiling for Virtual Pascal, things are done differently, and
+global variables are not used. */
+
+#include "pcre_config.h"
+#include "pcre_internal.h"
+
+#if defined _MSC_VER || defined  __SYMBIAN32__
+static void* LocalPcreMalloc(size_t aSize)
+  {
+  return malloc(aSize);
+  }
+static void LocalPcreFree(void* aPtr)
+  {
+  free(aPtr);
+  }
+PCRE_EXP_DATA_DEFN void *(*PUBL(malloc))(size_t) = LocalPcreMalloc;
+PCRE_EXP_DATA_DEFN void  (*PUBL(free))(void *) = LocalPcreFree;
+PCRE_EXP_DATA_DEFN void *(*PUBL(stack_malloc))(size_t) = LocalPcreMalloc;
+PCRE_EXP_DATA_DEFN void  (*PUBL(stack_free))(void *) = LocalPcreFree;
+PCRE_EXP_DATA_DEFN int   (*PUBL(callout))(PUBL(callout_block) *) = NULL;
+PCRE_EXP_DATA_DEFN int   (*PUBL(stack_guard))(void) = NULL;
+
+#elif !defined VPCOMPAT
+PCRE_EXP_DATA_DEFN void *(*PUBL(malloc))(size_t) = malloc;
+PCRE_EXP_DATA_DEFN void  (*PUBL(free))(void *) = free;
+PCRE_EXP_DATA_DEFN void *(*PUBL(stack_malloc))(size_t) = malloc;
+PCRE_EXP_DATA_DEFN void  (*PUBL(stack_free))(void *) = free;
+PCRE_EXP_DATA_DEFN int   (*PUBL(callout))(PUBL(callout_block) *) = NULL;
+PCRE_EXP_DATA_DEFN int   (*PUBL(stack_guard))(void) = NULL;
+#endif
+
+/* End of pcre_globals.c */
diff --git a/base/poco/Foundation/src/pcre_internal.h b/base/poco/Foundation/src/pcre_internal.h
new file mode 100644
index 00000000000..273d4db8a98
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_internal.h
@@ -0,0 +1,2807 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2016 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+/* This header contains definitions that are shared between the different
+modules, but which are not relevant to the exported API. This includes some
+functions whose names all begin with "_pcre_", "_pcre16_" or "_pcre32_"
+depending on the PRIV macro. */
+
+#ifndef PCRE_INTERNAL_H
+#define PCRE_INTERNAL_H
+
+/* Define PCRE_DEBUG to get debugging output on stdout. */
+
+#if 0
+#define PCRE_DEBUG
+#endif
+
+/* PCRE is compiled as an 8 bit library if it is not requested otherwise. */
+
+#if !defined COMPILE_PCRE16 && !defined COMPILE_PCRE32
+#define COMPILE_PCRE8
+#endif
+
+/* If SUPPORT_UCP is defined, SUPPORT_UTF must also be defined. The
+"configure" script ensures this, but not everybody uses "configure". */
+
+#if defined SUPPORT_UCP && !(defined SUPPORT_UTF)
+#define SUPPORT_UTF 1
+#endif
+
+/* We define SUPPORT_UTF if SUPPORT_UTF8 is enabled for compatibility
+reasons with existing code. */
+
+#if defined SUPPORT_UTF8 && !(defined SUPPORT_UTF)
+#define SUPPORT_UTF 1
+#endif
+
+/* Fixme: SUPPORT_UTF8 should be eventually disappear from the code.
+Until then we define it if SUPPORT_UTF is defined. */
+
+#if defined SUPPORT_UTF && !(defined SUPPORT_UTF8)
+#define SUPPORT_UTF8 1
+#endif
+
+/* We do not support both EBCDIC and UTF-8/16/32 at the same time. The "configure"
+script prevents both being selected, but not everybody uses "configure". */
+
+#if defined EBCDIC && defined SUPPORT_UTF
+#error The use of both EBCDIC and SUPPORT_UTF is not supported.
+#endif
+
+/* Use a macro for debugging printing, 'cause that eliminates the use of #ifdef
+inline, and there are *still* stupid compilers about that don't like indented
+pre-processor statements, or at least there were when I first wrote this. After
+all, it had only been about 10 years then...
+
+It turns out that the Mac Debugging.h header also defines the macro DPRINTF, so
+be absolutely sure we get our version. */
+
+#undef DPRINTF
+#ifdef PCRE_DEBUG
+#define DPRINTF(p) printf p
+#else
+#define DPRINTF(p) /* Nothing */
+#endif
+
+
+/* Standard C headers plus the external interface definition. The only time
+setjmp and stdarg are used is when NO_RECURSE is set. */
+
+#include <ctype.h>
+#include <limits.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* Valgrind (memcheck) support */
+
+#ifdef SUPPORT_VALGRIND
+#include <valgrind/memcheck.h>
+#endif
+
+/* When compiling a DLL for Windows, the exported symbols have to be declared
+using some MS magic. I found some useful information on this web page:
+http://msdn2.microsoft.com/en-us/library/y4h7bcy6(VS.80).aspx. According to the
+information there, using __declspec(dllexport) without "extern" we have a
+definition; with "extern" we have a declaration. The settings here override the
+setting in pcre.h (which is included below); it defines only PCRE_EXP_DECL,
+which is all that is needed for applications (they just import the symbols). We
+use:
+
+  PCRE_EXP_DECL       for declarations
+  PCRE_EXP_DEFN       for definitions of exported functions
+  PCRE_EXP_DATA_DEFN  for definitions of exported variables
+
+The reason for the two DEFN macros is that in non-Windows environments, one
+does not want to have "extern" before variable definitions because it leads to
+compiler warnings. So we distinguish between functions and variables. In
+Windows, the two should always be the same.
+
+The reason for wrapping this in #ifndef PCRE_EXP_DECL is so that pcretest,
+which is an application, but needs to import this file in order to "peek" at
+internals, can #include pcre.h first to get an application's-eye view.
+
+In principle, people compiling for non-Windows, non-Unix-like (i.e. uncommon,
+special-purpose environments) might want to stick other stuff in front of
+exported symbols. That's why, in the non-Windows case, we set PCRE_EXP_DEFN and
+PCRE_EXP_DATA_DEFN only if they are not already set. */
+
+#ifndef PCRE_EXP_DECL
+#  ifdef _WIN32
+#    ifndef PCRE_STATIC
+#      define PCRE_EXP_DECL       extern __declspec(dllexport)
+#      define PCRE_EXP_DEFN       __declspec(dllexport)
+#      define PCRE_EXP_DATA_DEFN  __declspec(dllexport)
+#    else
+#      define PCRE_EXP_DECL       extern
+#      define PCRE_EXP_DEFN
+#      define PCRE_EXP_DATA_DEFN
+#    endif
+#  else
+#    ifdef __cplusplus
+#      define PCRE_EXP_DECL       extern "C"
+#    else
+#      define PCRE_EXP_DECL       extern
+#    endif
+#    ifndef PCRE_EXP_DEFN
+#      define PCRE_EXP_DEFN       PCRE_EXP_DECL
+#    endif
+#    ifndef PCRE_EXP_DATA_DEFN
+#      define PCRE_EXP_DATA_DEFN
+#    endif
+#  endif
+#endif
+
+/* When compiling with the MSVC compiler, it is sometimes necessary to include
+a "calling convention" before exported function names. (This is secondhand
+information; I know nothing about MSVC myself). For example, something like
+
+  void __cdecl function(....)
+
+might be needed. In order so make this easy, all the exported functions have
+PCRE_CALL_CONVENTION just before their names. It is rarely needed; if not
+set, we ensure here that it has no effect. */
+
+#ifndef PCRE_CALL_CONVENTION
+#define PCRE_CALL_CONVENTION
+#endif
+
+/* We need to have types that specify unsigned 8, 16 and 32-bit integers. We
+cannot determine these outside the compilation (e.g. by running a program as
+part of "configure") because PCRE is often cross-compiled for use on other
+systems. Instead we make use of the maximum sizes that are available at
+preprocessor time in standard C environments. */
+
+typedef unsigned char pcre_uint8;
+
+#if USHRT_MAX == 65535
+typedef unsigned short pcre_uint16;
+typedef short pcre_int16;
+#define PCRE_UINT16_MAX USHRT_MAX
+#define PCRE_INT16_MAX SHRT_MAX
+#elif UINT_MAX == 65535
+typedef unsigned int pcre_uint16;
+typedef int pcre_int16;
+#define PCRE_UINT16_MAX UINT_MAX
+#define PCRE_INT16_MAX INT_MAX
+#else
+#error Cannot determine a type for 16-bit integers
+#endif
+
+#if UINT_MAX == 4294967295U
+typedef unsigned int pcre_uint32;
+typedef int pcre_int32;
+#define PCRE_UINT32_MAX UINT_MAX
+#define PCRE_INT32_MAX INT_MAX
+#elif ULONG_MAX == 4294967295UL
+typedef unsigned long int pcre_uint32;
+typedef long int pcre_int32;
+#define PCRE_UINT32_MAX ULONG_MAX
+#define PCRE_INT32_MAX LONG_MAX
+#else
+#error Cannot determine a type for 32-bit integers
+#endif
+
+/* When checking for integer overflow in pcre_compile(), we need to handle
+large integers. If a 64-bit integer type is available, we can use that.
+Otherwise we have to cast to double, which of course requires floating point
+arithmetic. Handle this by defining a macro for the appropriate type. If
+stdint.h is available, include it; it may define INT64_MAX. Systems that do not
+have stdint.h (e.g. Solaris) may have inttypes.h. The macro int64_t may be set
+by "configure". */
+
+#if HAVE_STDINT_H
+#include <stdint.h>
+#elif HAVE_INTTYPES_H || defined(__SUNPRO_C)
+#include <inttypes.h>
+#endif
+
+#if defined INT64_MAX || defined int64_t
+#define INT64_OR_DOUBLE int64_t
+#else
+#define INT64_OR_DOUBLE double
+#endif
+
+/* All character handling must be done as unsigned characters. Otherwise there
+are problems with top-bit-set characters and functions such as isspace().
+However, we leave the interface to the outside world as char * or short *,
+because that should make things easier for callers. This character type is
+called pcre_uchar.
+
+The IN_UCHARS macro multiply its argument with the byte size of the current
+pcre_uchar type. Useful for memcpy and such operations, whose require the
+byte size of their input/output buffers.
+
+The MAX_255 macro checks whether its pcre_uchar input is less than 256.
+
+The TABLE_GET macro is designed for accessing elements of tables whose contain
+exactly 256 items. When the character is able to contain more than 256
+items, some check is needed before accessing these tables.
+*/
+
+#if defined COMPILE_PCRE8
+
+typedef unsigned char pcre_uchar;
+#define IN_UCHARS(x) (x)
+#define MAX_255(c) 1
+#define TABLE_GET(c, table, default) ((table)[c])
+
+#elif defined COMPILE_PCRE16
+
+#if USHRT_MAX != 65535
+/* This is a warning message. Change PCRE_UCHAR16 to a 16 bit data type in
+pcre.h(.in) and disable (comment out) this message. */
+#error Warning: PCRE_UCHAR16 is not a 16 bit data type.
+#endif
+
+typedef pcre_uint16 pcre_uchar;
+#define UCHAR_SHIFT (1)
+#define IN_UCHARS(x) ((x) * 2)
+#define MAX_255(c) ((c) <= 255u)
+#define TABLE_GET(c, table, default) (MAX_255(c)? ((table)[c]):(default))
+
+#elif defined COMPILE_PCRE32
+
+typedef pcre_uint32 pcre_uchar;
+#define UCHAR_SHIFT (2)
+#define IN_UCHARS(x) ((x) * 4)
+#define MAX_255(c) ((c) <= 255u)
+#define TABLE_GET(c, table, default) (MAX_255(c)? ((table)[c]):(default))
+
+#else
+#error Unsupported compiling mode
+#endif /* COMPILE_PCRE[8|16|32] */
+
+/* This is an unsigned int value that no character can ever have. UTF-8
+characters only go up to 0x7fffffff (though Unicode doesn't go beyond
+0x0010ffff). */
+
+#define NOTACHAR 0xffffffff
+
+/* PCRE is able to support several different kinds of newline (CR, LF, CRLF,
+"any" and "anycrlf" at present). The following macros are used to package up
+testing for newlines. NLBLOCK, PSSTART, and PSEND are defined in the various
+modules to indicate in which datablock the parameters exist, and what the
+start/end of string field names are. */
+
+#define NLTYPE_FIXED    0     /* Newline is a fixed length string */
+#define NLTYPE_ANY      1     /* Newline is any Unicode line ending */
+#define NLTYPE_ANYCRLF  2     /* Newline is CR, LF, or CRLF */
+
+/* This macro checks for a newline at the given position */
+
+#define IS_NEWLINE(p) \
+  ((NLBLOCK->nltype != NLTYPE_FIXED)? \
+    ((p) < NLBLOCK->PSEND && \
+     PRIV(is_newline)((p), NLBLOCK->nltype, NLBLOCK->PSEND, \
+       &(NLBLOCK->nllen), utf)) \
+    : \
+    ((p) <= NLBLOCK->PSEND - NLBLOCK->nllen && \
+     UCHAR21TEST(p) == NLBLOCK->nl[0] && \
+     (NLBLOCK->nllen == 1 || UCHAR21TEST(p+1) == NLBLOCK->nl[1])       \
+    ) \
+  )
+
+/* This macro checks for a newline immediately preceding the given position */
+
+#define WAS_NEWLINE(p) \
+  ((NLBLOCK->nltype != NLTYPE_FIXED)? \
+    ((p) > NLBLOCK->PSSTART && \
+     PRIV(was_newline)((p), NLBLOCK->nltype, NLBLOCK->PSSTART, \
+       &(NLBLOCK->nllen), utf)) \
+    : \
+    ((p) >= NLBLOCK->PSSTART + NLBLOCK->nllen && \
+     UCHAR21TEST(p - NLBLOCK->nllen) == NLBLOCK->nl[0] &&              \
+     (NLBLOCK->nllen == 1 || UCHAR21TEST(p - NLBLOCK->nllen + 1) == NLBLOCK->nl[1]) \
+    ) \
+  )
+
+/* When PCRE is compiled as a C++ library, the subject pointer can be replaced
+with a custom type. This makes it possible, for example, to allow pcre_exec()
+to process subject strings that are discontinuous by using a smart pointer
+class. It must always be possible to inspect all of the subject string in
+pcre_exec() because of the way it backtracks. Two macros are required in the
+normal case, for sign-unspecified and unsigned char pointers. The former is
+used for the external interface and appears in pcre.h, which is why its name
+must begin with PCRE_. */
+
+#ifdef CUSTOM_SUBJECT_PTR
+#define PCRE_PUCHAR CUSTOM_SUBJECT_PTR
+#else
+#define PCRE_PUCHAR const pcre_uchar *
+#endif
+
+/* Include the public PCRE header and the definitions of UCP character property
+values. */
+
+#include "pcre.h"
+#include "ucp.h"
+
+#ifdef COMPILE_PCRE32
+/* Assert that the public PCRE_UCHAR32 is a 32-bit type */
+typedef int __assert_pcre_uchar32_size[sizeof(PCRE_UCHAR32) == 4 ? 1 : -1];
+#endif
+
+/* When compiling for use with the Virtual Pascal compiler, these functions
+need to have their names changed. PCRE must be compiled with the -DVPCOMPAT
+option on the command line. */
+
+#ifdef VPCOMPAT
+#define strlen(s)        _strlen(s)
+#define strncmp(s1,s2,m) _strncmp(s1,s2,m)
+#define memcmp(s,c,n)    _memcmp(s,c,n)
+#define memcpy(d,s,n)    _memcpy(d,s,n)
+#define memmove(d,s,n)   _memmove(d,s,n)
+#define memset(s,c,n)    _memset(s,c,n)
+#else  /* VPCOMPAT */
+
+/* To cope with SunOS4 and other systems that lack memmove() but have bcopy(),
+define a macro for memmove() if HAVE_MEMMOVE is false, provided that HAVE_BCOPY
+is set. Otherwise, include an emulating function for those systems that have
+neither (there some non-Unix environments where this is the case). */
+
+#ifndef HAVE_MEMMOVE
+#undef  memmove        /* some systems may have a macro */
+#ifdef HAVE_BCOPY
+#define memmove(a, b, c) bcopy(b, a, c)
+#else  /* HAVE_BCOPY */
+static void *
+pcre_memmove(void *d, const void *s, size_t n)
+{
+size_t i;
+unsigned char *dest = (unsigned char *)d;
+const unsigned char *src = (const unsigned char *)s;
+if (dest > src)
+  {
+  dest += n;
+  src += n;
+  for (i = 0; i < n; ++i) *(--dest) = *(--src);
+  return (void *)dest;
+  }
+else
+  {
+  for (i = 0; i < n; ++i) *dest++ = *src++;
+  return (void *)(dest - n);
+  }
+}
+#define memmove(a, b, c) pcre_memmove(a, b, c)
+#endif   /* not HAVE_BCOPY */
+#endif   /* not HAVE_MEMMOVE */
+#endif   /* not VPCOMPAT */
+
+
+/* PCRE keeps offsets in its compiled code as 2-byte quantities (always stored
+in big-endian order) by default. These are used, for example, to link from the
+start of a subpattern to its alternatives and its end. The use of 2 bytes per
+offset limits the size of the compiled regex to around 64K, which is big enough
+for almost everybody. However, I received a request for an even bigger limit.
+For this reason, and also to make the code easier to maintain, the storing and
+loading of offsets from the byte string is now handled by the macros that are
+defined here.
+
+The macros are controlled by the value of LINK_SIZE. This defaults to 2 in
+the config.h file, but can be overridden by using -D on the command line. This
+is automated on Unix systems via the "configure" command. */
+
+#if defined COMPILE_PCRE8
+
+#if LINK_SIZE == 2
+
+#define PUT(a,n,d)   \
+  (a[n] = (d) >> 8), \
+  (a[(n)+1] = (d) & 255)
+
+#define GET(a,n) \
+  (((a)[n] << 8) | (a)[(n)+1])
+
+#define MAX_PATTERN_SIZE (1 << 16)
+
+
+#elif LINK_SIZE == 3
+
+#define PUT(a,n,d)       \
+  (a[n] = (d) >> 16),    \
+  (a[(n)+1] = (d) >> 8), \
+  (a[(n)+2] = (d) & 255)
+
+#define GET(a,n) \
+  (((a)[n] << 16) | ((a)[(n)+1] << 8) | (a)[(n)+2])
+
+#define MAX_PATTERN_SIZE (1 << 24)
+
+
+#elif LINK_SIZE == 4
+
+#define PUT(a,n,d)        \
+  (a[n] = (d) >> 24),     \
+  (a[(n)+1] = (d) >> 16), \
+  (a[(n)+2] = (d) >> 8),  \
+  (a[(n)+3] = (d) & 255)
+
+#define GET(a,n) \
+  (((a)[n] << 24) | ((a)[(n)+1] << 16) | ((a)[(n)+2] << 8) | (a)[(n)+3])
+
+/* Keep it positive */
+#define MAX_PATTERN_SIZE (1 << 30)
+
+#else
+#error LINK_SIZE must be either 2, 3, or 4
+#endif
+
+#elif defined COMPILE_PCRE16
+
+#if LINK_SIZE == 2
+
+/* Redefine LINK_SIZE as a multiple of sizeof(pcre_uchar) */
+#undef LINK_SIZE
+#define LINK_SIZE 1
+
+#define PUT(a,n,d)   \
+  (a[n] = (d))
+
+#define GET(a,n) \
+  (a[n])
+
+#define MAX_PATTERN_SIZE (1 << 16)
+
+#elif LINK_SIZE == 3 || LINK_SIZE == 4
+
+/* Redefine LINK_SIZE as a multiple of sizeof(pcre_uchar) */
+#undef LINK_SIZE
+#define LINK_SIZE 2
+
+#define PUT(a,n,d)   \
+  (a[n] = (d) >> 16), \
+  (a[(n)+1] = (d) & 65535)
+
+#define GET(a,n) \
+  (((a)[n] << 16) | (a)[(n)+1])
+
+/* Keep it positive */
+#define MAX_PATTERN_SIZE (1 << 30)
+
+#else
+#error LINK_SIZE must be either 2, 3, or 4
+#endif
+
+#elif defined COMPILE_PCRE32
+
+/* Only supported LINK_SIZE is 4 */
+/* Redefine LINK_SIZE as a multiple of sizeof(pcre_uchar) */
+#undef LINK_SIZE
+#define LINK_SIZE 1
+
+#define PUT(a,n,d)   \
+  (a[n] = (d))
+
+#define GET(a,n) \
+  (a[n])
+
+/* Keep it positive */
+#define MAX_PATTERN_SIZE (1 << 30)
+
+#else
+#error Unsupported compiling mode
+#endif /* COMPILE_PCRE[8|16|32] */
+
+/* Convenience macro defined in terms of the others */
+
+#define PUTINC(a,n,d)   PUT(a,n,d), a += LINK_SIZE
+
+
+/* PCRE uses some other 2-byte quantities that do not change when the size of
+offsets changes. There are used for repeat counts and for other things such as
+capturing parenthesis numbers in back references. */
+
+#if defined COMPILE_PCRE8
+
+#define IMM2_SIZE 2
+
+#define PUT2(a,n,d)   \
+  a[n] = (d) >> 8; \
+  a[(n)+1] = (d) & 255
+
+/* For reasons that I do not understand, the expression in this GET2 macro is
+treated by gcc as a signed expression, even when a is declared as unsigned. It
+seems that any kind of arithmetic results in a signed value. */
+
+#define GET2(a,n) \
+  (unsigned int)(((a)[n] << 8) | (a)[(n)+1])
+
+#elif defined COMPILE_PCRE16
+
+#define IMM2_SIZE 1
+
+#define PUT2(a,n,d)   \
+   a[n] = d
+
+#define GET2(a,n) \
+   a[n]
+
+#elif defined COMPILE_PCRE32
+
+#define IMM2_SIZE 1
+
+#define PUT2(a,n,d)   \
+   a[n] = d
+
+#define GET2(a,n) \
+   a[n]
+
+#else
+#error Unsupported compiling mode
+#endif /* COMPILE_PCRE[8|16|32] */
+
+#define PUT2INC(a,n,d)  PUT2(a,n,d), a += IMM2_SIZE
+
+/* The maximum length of a MARK name is currently one data unit; it may be
+changed in future to be a fixed number of bytes or to depend on LINK_SIZE. */
+
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+#define MAX_MARK ((1u << 16) - 1)
+#else
+#define MAX_MARK ((1u << 8) - 1)
+#endif
+
+/* There is a proposed future special "UTF-21" mode, in which only the lowest
+21 bits of a 32-bit character are interpreted as UTF, with the remaining 11
+high-order bits available to the application for other uses. In preparation for
+the future implementation of this mode, there are macros that load a data item
+and, if in this special mode, mask it to 21 bits. These macros all have names
+starting with UCHAR21. In all other modes, including the normal 32-bit
+library, the macros all have the same simple definitions. When the new mode is
+implemented, it is expected that these definitions will be varied appropriately
+using #ifdef when compiling the library that supports the special mode. */
+
+#define UCHAR21(eptr)        (*(eptr))
+#define UCHAR21TEST(eptr)    (*(eptr))
+#define UCHAR21INC(eptr)     (*(eptr)++)
+#define UCHAR21INCTEST(eptr) (*(eptr)++)
+
+/* When UTF encoding is being used, a character is no longer just a single
+byte in 8-bit mode or a single short in 16-bit mode. The macros for character
+handling generate simple sequences when used in the basic mode, and more
+complicated ones for UTF characters. GETCHARLENTEST and other macros are not
+used when UTF is not supported. To make sure they can never even appear when
+UTF support is omitted, we don't even define them. */
+
+#ifndef SUPPORT_UTF
+
+/* #define MAX_VALUE_FOR_SINGLE_CHAR */
+/* #define HAS_EXTRALEN(c) */
+/* #define GET_EXTRALEN(c) */
+/* #define NOT_FIRSTCHAR(c) */
+#define GETCHAR(c, eptr) c = *eptr;
+#define GETCHARTEST(c, eptr) c = *eptr;
+#define GETCHARINC(c, eptr) c = *eptr++;
+#define GETCHARINCTEST(c, eptr) c = *eptr++;
+#define GETCHARLEN(c, eptr, len) c = *eptr;
+/* #define GETCHARLENTEST(c, eptr, len) */
+/* #define BACKCHAR(eptr) */
+/* #define FORWARDCHAR(eptr) */
+/* #define ACROSSCHAR(condition, eptr, action) */
+
+#else   /* SUPPORT_UTF */
+
+/* Tests whether the code point needs extra characters to decode. */
+
+#define HASUTF8EXTRALEN(c) ((c) >= 0xc0)
+
+/* Base macro to pick up the remaining bytes of a UTF-8 character, not
+advancing the pointer. */
+
+#define GETUTF8(c, eptr) \
+    { \
+    if ((c & 0x20) == 0) \
+      c = ((c & 0x1f) << 6) | (eptr[1] & 0x3f); \
+    else if ((c & 0x10) == 0) \
+      c = ((c & 0x0f) << 12) | ((eptr[1] & 0x3f) << 6) | (eptr[2] & 0x3f); \
+    else if ((c & 0x08) == 0) \
+      c = ((c & 0x07) << 18) | ((eptr[1] & 0x3f) << 12) | \
+      ((eptr[2] & 0x3f) << 6) | (eptr[3] & 0x3f); \
+    else if ((c & 0x04) == 0) \
+      c = ((c & 0x03) << 24) | ((eptr[1] & 0x3f) << 18) | \
+          ((eptr[2] & 0x3f) << 12) | ((eptr[3] & 0x3f) << 6) | \
+          (eptr[4] & 0x3f); \
+    else \
+      c = ((c & 0x01) << 30) | ((eptr[1] & 0x3f) << 24) | \
+          ((eptr[2] & 0x3f) << 18) | ((eptr[3] & 0x3f) << 12) | \
+          ((eptr[4] & 0x3f) << 6) | (eptr[5] & 0x3f); \
+    }
+
+/* Base macro to pick up the remaining bytes of a UTF-8 character, advancing
+the pointer. */
+
+#define GETUTF8INC(c, eptr) \
+    { \
+    if ((c & 0x20) == 0) \
+      c = ((c & 0x1f) << 6) | (*eptr++ & 0x3f); \
+    else if ((c & 0x10) == 0) \
+      { \
+      c = ((c & 0x0f) << 12) | ((*eptr & 0x3f) << 6) | (eptr[1] & 0x3f); \
+      eptr += 2; \
+      } \
+    else if ((c & 0x08) == 0) \
+      { \
+      c = ((c & 0x07) << 18) | ((*eptr & 0x3f) << 12) | \
+          ((eptr[1] & 0x3f) << 6) | (eptr[2] & 0x3f); \
+      eptr += 3; \
+      } \
+    else if ((c & 0x04) == 0) \
+      { \
+      c = ((c & 0x03) << 24) | ((*eptr & 0x3f) << 18) | \
+          ((eptr[1] & 0x3f) << 12) | ((eptr[2] & 0x3f) << 6) | \
+          (eptr[3] & 0x3f); \
+      eptr += 4; \
+      } \
+    else \
+      { \
+      c = ((c & 0x01) << 30) | ((*eptr & 0x3f) << 24) | \
+          ((eptr[1] & 0x3f) << 18) | ((eptr[2] & 0x3f) << 12) | \
+          ((eptr[3] & 0x3f) << 6) | (eptr[4] & 0x3f); \
+      eptr += 5; \
+      } \
+    }
+
+#if defined COMPILE_PCRE8
+
+/* These macros were originally written in the form of loops that used data
+from the tables whose names start with PRIV(utf8_table). They were rewritten by
+a user so as not to use loops, because in some environments this gives a
+significant performance advantage, and it seems never to do any harm. */
+
+/* Tells the biggest code point which can be encoded as a single character. */
+
+#define MAX_VALUE_FOR_SINGLE_CHAR 127
+
+/* Tests whether the code point needs extra characters to decode. */
+
+#define HAS_EXTRALEN(c) ((c) >= 0xc0)
+
+/* Returns with the additional number of characters if IS_MULTICHAR(c) is TRUE.
+Otherwise it has an undefined behaviour. */
+
+#define GET_EXTRALEN(c) (PRIV(utf8_table4)[(c) & 0x3f])
+
+/* Returns TRUE, if the given character is not the first character
+of a UTF sequence. */
+
+#define NOT_FIRSTCHAR(c) (((c) & 0xc0) == 0x80)
+
+/* Get the next UTF-8 character, not advancing the pointer. This is called when
+we know we are in UTF-8 mode. */
+
+#define GETCHAR(c, eptr) \
+  c = *eptr; \
+  if (c >= 0xc0) GETUTF8(c, eptr);
+
+/* Get the next UTF-8 character, testing for UTF-8 mode, and not advancing the
+pointer. */
+
+#define GETCHARTEST(c, eptr) \
+  c = *eptr; \
+  if (utf && c >= 0xc0) GETUTF8(c, eptr);
+
+/* Get the next UTF-8 character, advancing the pointer. This is called when we
+know we are in UTF-8 mode. */
+
+#define GETCHARINC(c, eptr) \
+  c = *eptr++; \
+  if (c >= 0xc0) GETUTF8INC(c, eptr);
+
+/* Get the next character, testing for UTF-8 mode, and advancing the pointer.
+This is called when we don't know if we are in UTF-8 mode. */
+
+#define GETCHARINCTEST(c, eptr) \
+  c = *eptr++; \
+  if (utf && c >= 0xc0) GETUTF8INC(c, eptr);
+
+/* Base macro to pick up the remaining bytes of a UTF-8 character, not
+advancing the pointer, incrementing the length. */
+
+#define GETUTF8LEN(c, eptr, len) \
+    { \
+    if ((c & 0x20) == 0) \
+      { \
+      c = ((c & 0x1f) << 6) | (eptr[1] & 0x3f); \
+      len++; \
+      } \
+    else if ((c & 0x10)  == 0) \
+      { \
+      c = ((c & 0x0f) << 12) | ((eptr[1] & 0x3f) << 6) | (eptr[2] & 0x3f); \
+      len += 2; \
+      } \
+    else if ((c & 0x08)  == 0) \
+      {\
+      c = ((c & 0x07) << 18) | ((eptr[1] & 0x3f) << 12) | \
+          ((eptr[2] & 0x3f) << 6) | (eptr[3] & 0x3f); \
+      len += 3; \
+      } \
+    else if ((c & 0x04)  == 0) \
+      { \
+      c = ((c & 0x03) << 24) | ((eptr[1] & 0x3f) << 18) | \
+          ((eptr[2] & 0x3f) << 12) | ((eptr[3] & 0x3f) << 6) | \
+          (eptr[4] & 0x3f); \
+      len += 4; \
+      } \
+    else \
+      {\
+      c = ((c & 0x01) << 30) | ((eptr[1] & 0x3f) << 24) | \
+          ((eptr[2] & 0x3f) << 18) | ((eptr[3] & 0x3f) << 12) | \
+          ((eptr[4] & 0x3f) << 6) | (eptr[5] & 0x3f); \
+      len += 5; \
+      } \
+    }
+
+/* Get the next UTF-8 character, not advancing the pointer, incrementing length
+if there are extra bytes. This is called when we know we are in UTF-8 mode. */
+
+#define GETCHARLEN(c, eptr, len) \
+  c = *eptr; \
+  if (c >= 0xc0) GETUTF8LEN(c, eptr, len);
+
+/* Get the next UTF-8 character, testing for UTF-8 mode, not advancing the
+pointer, incrementing length if there are extra bytes. This is called when we
+do not know if we are in UTF-8 mode. */
+
+#define GETCHARLENTEST(c, eptr, len) \
+  c = *eptr; \
+  if (utf && c >= 0xc0) GETUTF8LEN(c, eptr, len);
+
+/* If the pointer is not at the start of a character, move it back until
+it is. This is called only in UTF-8 mode - we don't put a test within the macro
+because almost all calls are already within a block of UTF-8 only code. */
+
+#define BACKCHAR(eptr) while((*eptr & 0xc0) == 0x80) eptr--
+
+/* Same as above, just in the other direction. */
+#define FORWARDCHAR(eptr) while((*eptr & 0xc0) == 0x80) eptr++
+
+/* Same as above, but it allows a fully customizable form. */
+#define ACROSSCHAR(condition, eptr, action) \
+  while((condition) && ((eptr) & 0xc0) == 0x80) action
+
+#elif defined COMPILE_PCRE16
+
+/* Tells the biggest code point which can be encoded as a single character. */
+
+#define MAX_VALUE_FOR_SINGLE_CHAR 65535
+
+/* Tests whether the code point needs extra characters to decode. */
+
+#define HAS_EXTRALEN(c) (((c) & 0xfc00) == 0xd800)
+
+/* Returns with the additional number of characters if IS_MULTICHAR(c) is TRUE.
+Otherwise it has an undefined behaviour. */
+
+#define GET_EXTRALEN(c) 1
+
+/* Returns TRUE, if the given character is not the first character
+of a UTF sequence. */
+
+#define NOT_FIRSTCHAR(c) (((c) & 0xfc00) == 0xdc00)
+
+/* Base macro to pick up the low surrogate of a UTF-16 character, not
+advancing the pointer. */
+
+#define GETUTF16(c, eptr) \
+   { c = (((c & 0x3ff) << 10) | (eptr[1] & 0x3ff)) + 0x10000; }
+
+/* Get the next UTF-16 character, not advancing the pointer. This is called when
+we know we are in UTF-16 mode. */
+
+#define GETCHAR(c, eptr) \
+  c = *eptr; \
+  if ((c & 0xfc00) == 0xd800) GETUTF16(c, eptr);
+
+/* Get the next UTF-16 character, testing for UTF-16 mode, and not advancing the
+pointer. */
+
+#define GETCHARTEST(c, eptr) \
+  c = *eptr; \
+  if (utf && (c & 0xfc00) == 0xd800) GETUTF16(c, eptr);
+
+/* Base macro to pick up the low surrogate of a UTF-16 character, advancing
+the pointer. */
+
+#define GETUTF16INC(c, eptr) \
+   { c = (((c & 0x3ff) << 10) | (*eptr++ & 0x3ff)) + 0x10000; }
+
+/* Get the next UTF-16 character, advancing the pointer. This is called when we
+know we are in UTF-16 mode. */
+
+#define GETCHARINC(c, eptr) \
+  c = *eptr++; \
+  if ((c & 0xfc00) == 0xd800) GETUTF16INC(c, eptr);
+
+/* Get the next character, testing for UTF-16 mode, and advancing the pointer.
+This is called when we don't know if we are in UTF-16 mode. */
+
+#define GETCHARINCTEST(c, eptr) \
+  c = *eptr++; \
+  if (utf && (c & 0xfc00) == 0xd800) GETUTF16INC(c, eptr);
+
+/* Base macro to pick up the low surrogate of a UTF-16 character, not
+advancing the pointer, incrementing the length. */
+
+#define GETUTF16LEN(c, eptr, len) \
+   { c = (((c & 0x3ff) << 10) | (eptr[1] & 0x3ff)) + 0x10000; len++; }
+
+/* Get the next UTF-16 character, not advancing the pointer, incrementing
+length if there is a low surrogate. This is called when we know we are in
+UTF-16 mode. */
+
+#define GETCHARLEN(c, eptr, len) \
+  c = *eptr; \
+  if ((c & 0xfc00) == 0xd800) GETUTF16LEN(c, eptr, len);
+
+/* Get the next UTF-816character, testing for UTF-16 mode, not advancing the
+pointer, incrementing length if there is a low surrogate. This is called when
+we do not know if we are in UTF-16 mode. */
+
+#define GETCHARLENTEST(c, eptr, len) \
+  c = *eptr; \
+  if (utf && (c & 0xfc00) == 0xd800) GETUTF16LEN(c, eptr, len);
+
+/* If the pointer is not at the start of a character, move it back until
+it is. This is called only in UTF-16 mode - we don't put a test within the
+macro because almost all calls are already within a block of UTF-16 only
+code. */
+
+#define BACKCHAR(eptr) if ((*eptr & 0xfc00) == 0xdc00) eptr--
+
+/* Same as above, just in the other direction. */
+#define FORWARDCHAR(eptr) if ((*eptr & 0xfc00) == 0xdc00) eptr++
+
+/* Same as above, but it allows a fully customizable form. */
+#define ACROSSCHAR(condition, eptr, action) \
+  if ((condition) && ((eptr) & 0xfc00) == 0xdc00) action
+
+#elif defined COMPILE_PCRE32
+
+/* These are trivial for the 32-bit library, since all UTF-32 characters fit
+into one pcre_uchar unit. */
+#define MAX_VALUE_FOR_SINGLE_CHAR (0x10ffffu)
+#define HAS_EXTRALEN(c) (0)
+#define GET_EXTRALEN(c) (0)
+#define NOT_FIRSTCHAR(c) (0)
+
+/* Get the next UTF-32 character, not advancing the pointer. This is called when
+we know we are in UTF-32 mode. */
+
+#define GETCHAR(c, eptr) \
+  c = *(eptr);
+
+/* Get the next UTF-32 character, testing for UTF-32 mode, and not advancing the
+pointer. */
+
+#define GETCHARTEST(c, eptr) \
+  c = *(eptr);
+
+/* Get the next UTF-32 character, advancing the pointer. This is called when we
+know we are in UTF-32 mode. */
+
+#define GETCHARINC(c, eptr) \
+  c = *((eptr)++);
+
+/* Get the next character, testing for UTF-32 mode, and advancing the pointer.
+This is called when we don't know if we are in UTF-32 mode. */
+
+#define GETCHARINCTEST(c, eptr) \
+  c = *((eptr)++);
+
+/* Get the next UTF-32 character, not advancing the pointer, not incrementing
+length (since all UTF-32 is of length 1). This is called when we know we are in
+UTF-32 mode. */
+
+#define GETCHARLEN(c, eptr, len) \
+  GETCHAR(c, eptr)
+
+/* Get the next UTF-32character, testing for UTF-32 mode, not advancing the
+pointer, not incrementing the length (since all UTF-32 is of length 1).
+This is called when we do not know if we are in UTF-32 mode. */
+
+#define GETCHARLENTEST(c, eptr, len) \
+  GETCHARTEST(c, eptr)
+
+/* If the pointer is not at the start of a character, move it back until
+it is. This is called only in UTF-32 mode - we don't put a test within the
+macro because almost all calls are already within a block of UTF-32 only
+code.
+These are all no-ops since all UTF-32 characters fit into one pcre_uchar. */
+
+#define BACKCHAR(eptr) do { } while (0)
+
+/* Same as above, just in the other direction. */
+#define FORWARDCHAR(eptr) do { } while (0)
+
+/* Same as above, but it allows a fully customizable form. */
+#define ACROSSCHAR(condition, eptr, action) do { } while (0)
+
+#else
+#error Unsupported compiling mode
+#endif /* COMPILE_PCRE[8|16|32] */
+
+#endif  /* SUPPORT_UTF */
+
+/* Tests for Unicode horizontal and vertical whitespace characters must check a
+number of different values. Using a switch statement for this generates the
+fastest code (no loop, no memory access), and there are several places in the
+interpreter code where this happens. In order to ensure that all the case lists
+remain in step, we use macros so that there is only one place where the lists
+are defined.
+
+These values are also required as lists in pcre_compile.c when processing \h,
+\H, \v and \V in a character class. The lists are defined in pcre_tables.c, but
+macros that define the values are here so that all the definitions are
+together. The lists must be in ascending character order, terminated by
+NOTACHAR (which is 0xffffffff).
+
+Any changes should ensure that the various macros are kept in step with each
+other. NOTE: The values also appear in pcre_jit_compile.c. */
+
+/* ------ ASCII/Unicode environments ------ */
+
+#ifndef EBCDIC
+
+#define HSPACE_LIST \
+  CHAR_HT, CHAR_SPACE, CHAR_NBSP, \
+  0x1680, 0x180e, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, \
+  0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202f, 0x205f, 0x3000, \
+  NOTACHAR
+
+#define HSPACE_MULTIBYTE_CASES \
+  case 0x1680:  /* OGHAM SPACE MARK */ \
+  case 0x180e:  /* MONGOLIAN VOWEL SEPARATOR */ \
+  case 0x2000:  /* EN QUAD */ \
+  case 0x2001:  /* EM QUAD */ \
+  case 0x2002:  /* EN SPACE */ \
+  case 0x2003:  /* EM SPACE */ \
+  case 0x2004:  /* THREE-PER-EM SPACE */ \
+  case 0x2005:  /* FOUR-PER-EM SPACE */ \
+  case 0x2006:  /* SIX-PER-EM SPACE */ \
+  case 0x2007:  /* FIGURE SPACE */ \
+  case 0x2008:  /* PUNCTUATION SPACE */ \
+  case 0x2009:  /* THIN SPACE */ \
+  case 0x200A:  /* HAIR SPACE */ \
+  case 0x202f:  /* NARROW NO-BREAK SPACE */ \
+  case 0x205f:  /* MEDIUM MATHEMATICAL SPACE */ \
+  case 0x3000   /* IDEOGRAPHIC SPACE */
+
+#define HSPACE_BYTE_CASES \
+  case CHAR_HT: \
+  case CHAR_SPACE: \
+  case CHAR_NBSP
+
+#define HSPACE_CASES \
+  HSPACE_BYTE_CASES: \
+  HSPACE_MULTIBYTE_CASES
+
+#define VSPACE_LIST \
+  CHAR_LF, CHAR_VT, CHAR_FF, CHAR_CR, CHAR_NEL, 0x2028, 0x2029, NOTACHAR
+
+#define VSPACE_MULTIBYTE_CASES \
+  case 0x2028:    /* LINE SEPARATOR */ \
+  case 0x2029     /* PARAGRAPH SEPARATOR */
+
+#define VSPACE_BYTE_CASES \
+  case CHAR_LF: \
+  case CHAR_VT: \
+  case CHAR_FF: \
+  case CHAR_CR: \
+  case CHAR_NEL
+
+#define VSPACE_CASES \
+  VSPACE_BYTE_CASES: \
+  VSPACE_MULTIBYTE_CASES
+
+/* ------ EBCDIC environments ------ */
+
+#else
+#define HSPACE_LIST CHAR_HT, CHAR_SPACE, CHAR_NBSP, NOTACHAR
+
+#define HSPACE_BYTE_CASES \
+  case CHAR_HT: \
+  case CHAR_SPACE: \
+  case CHAR_NBSP
+
+#define HSPACE_CASES HSPACE_BYTE_CASES
+
+#ifdef EBCDIC_NL25
+#define VSPACE_LIST \
+  CHAR_VT, CHAR_FF, CHAR_CR, CHAR_NEL, CHAR_LF, NOTACHAR
+#else
+#define VSPACE_LIST \
+  CHAR_VT, CHAR_FF, CHAR_CR, CHAR_LF, CHAR_NEL, NOTACHAR
+#endif
+
+#define VSPACE_BYTE_CASES \
+  case CHAR_LF: \
+  case CHAR_VT: \
+  case CHAR_FF: \
+  case CHAR_CR: \
+  case CHAR_NEL
+
+#define VSPACE_CASES VSPACE_BYTE_CASES
+#endif  /* EBCDIC */
+
+/* ------ End of whitespace macros ------ */
+
+
+
+/* Private flags containing information about the compiled regex. They used to
+live at the top end of the options word, but that got almost full, so they were
+moved to a 16-bit flags word - which got almost full, so now they are in a
+32-bit flags word. From release 8.00, PCRE_NOPARTIAL is unused, as the
+restrictions on partial matching have been lifted. It remains for backwards
+compatibility. */
+
+#define PCRE_MODE8         0x00000001  /* compiled in 8 bit mode */
+#define PCRE_MODE16        0x00000002  /* compiled in 16 bit mode */
+#define PCRE_MODE32        0x00000004  /* compiled in 32 bit mode */
+#define PCRE_FIRSTSET      0x00000010  /* first_char is set */
+#define PCRE_FCH_CASELESS  0x00000020  /* caseless first char */
+#define PCRE_REQCHSET      0x00000040  /* req_byte is set */
+#define PCRE_RCH_CASELESS  0x00000080  /* caseless requested char */
+#define PCRE_STARTLINE     0x00000100  /* start after \n for multiline */
+#define PCRE_NOPARTIAL     0x00000200  /* can't use partial with this regex */
+#define PCRE_JCHANGED      0x00000400  /* j option used in regex */
+#define PCRE_HASCRORLF     0x00000800  /* explicit \r or \n in pattern */
+#define PCRE_HASTHEN       0x00001000  /* pattern contains (*THEN) */
+#define PCRE_MLSET         0x00002000  /* match limit set by regex */
+#define PCRE_RLSET         0x00004000  /* recursion limit set by regex */
+#define PCRE_MATCH_EMPTY   0x00008000  /* pattern can match empty string */
+
+#if defined COMPILE_PCRE8
+#define PCRE_MODE          PCRE_MODE8
+#elif defined COMPILE_PCRE16
+#define PCRE_MODE          PCRE_MODE16
+#elif defined COMPILE_PCRE32
+#define PCRE_MODE          PCRE_MODE32
+#endif
+#define PCRE_MODE_MASK     (PCRE_MODE8 | PCRE_MODE16 | PCRE_MODE32)
+
+/* Flags for the "extra" block produced by pcre_study(). */
+
+#define PCRE_STUDY_MAPPED  0x0001  /* a map of starting chars exists */
+#define PCRE_STUDY_MINLEN  0x0002  /* a minimum length field exists */
+
+/* Masks for identifying the public options that are permitted at compile
+time, run time, or study time, respectively. */
+
+#define PCRE_NEWLINE_BITS (PCRE_NEWLINE_CR|PCRE_NEWLINE_LF|PCRE_NEWLINE_ANY| \
+                           PCRE_NEWLINE_ANYCRLF)
+
+#define PUBLIC_COMPILE_OPTIONS \
+  (PCRE_CASELESS|PCRE_EXTENDED|PCRE_ANCHORED|PCRE_MULTILINE| \
+   PCRE_DOTALL|PCRE_DOLLAR_ENDONLY|PCRE_EXTRA|PCRE_UNGREEDY|PCRE_UTF8| \
+   PCRE_NO_AUTO_CAPTURE|PCRE_NO_AUTO_POSSESS| \
+   PCRE_NO_UTF8_CHECK|PCRE_AUTO_CALLOUT|PCRE_FIRSTLINE| \
+   PCRE_DUPNAMES|PCRE_NEWLINE_BITS|PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE| \
+   PCRE_JAVASCRIPT_COMPAT|PCRE_UCP|PCRE_NO_START_OPTIMIZE|PCRE_NEVER_UTF)
+
+#define PUBLIC_EXEC_OPTIONS \
+  (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|PCRE_NOTEMPTY_ATSTART| \
+   PCRE_NO_UTF8_CHECK|PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT|PCRE_NEWLINE_BITS| \
+   PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE|PCRE_NO_START_OPTIMIZE)
+
+#define PUBLIC_DFA_EXEC_OPTIONS \
+  (PCRE_ANCHORED|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|PCRE_NOTEMPTY_ATSTART| \
+   PCRE_NO_UTF8_CHECK|PCRE_PARTIAL_HARD|PCRE_PARTIAL_SOFT|PCRE_DFA_SHORTEST| \
+   PCRE_DFA_RESTART|PCRE_NEWLINE_BITS|PCRE_BSR_ANYCRLF|PCRE_BSR_UNICODE| \
+   PCRE_NO_START_OPTIMIZE)
+
+#define PUBLIC_STUDY_OPTIONS \
+   (PCRE_STUDY_JIT_COMPILE|PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE| \
+    PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE|PCRE_STUDY_EXTRA_NEEDED)
+
+#define PUBLIC_JIT_EXEC_OPTIONS \
+   (PCRE_NO_UTF8_CHECK|PCRE_NOTBOL|PCRE_NOTEOL|PCRE_NOTEMPTY|\
+    PCRE_NOTEMPTY_ATSTART|PCRE_PARTIAL_SOFT|PCRE_PARTIAL_HARD)
+
+/* Magic number to provide a small check against being handed junk. */
+
+#define MAGIC_NUMBER  0x50435245UL   /* 'PCRE' */
+
+/* This variable is used to detect a loaded regular expression
+in different endianness. */
+
+#define REVERSED_MAGIC_NUMBER  0x45524350UL   /* 'ERCP' */
+
+/* The maximum remaining length of subject we are prepared to search for a
+req_byte match. */
+
+#define REQ_BYTE_MAX 1000
+
+/* Miscellaneous definitions. The #ifndef is to pacify compiler warnings in
+environments where these macros are defined elsewhere. Unfortunately, there
+is no way to do the same for the typedef. */
+
+typedef int BOOL;
+
+#ifndef FALSE
+#define FALSE   0
+#define TRUE    1
+#endif
+
+/* If PCRE is to support UTF-8 on EBCDIC platforms, we cannot use normal
+character constants like '*' because the compiler would emit their EBCDIC code,
+which is different from their ASCII/UTF-8 code. Instead we define macros for
+the characters so that they always use the ASCII/UTF-8 code when UTF-8 support
+is enabled. When UTF-8 support is not enabled, the definitions use character
+literals. Both character and string versions of each character are needed, and
+there are some longer strings as well.
+
+This means that, on EBCDIC platforms, the PCRE library can handle either
+EBCDIC, or UTF-8, but not both. To support both in the same compiled library
+would need different lookups depending on whether PCRE_UTF8 was set or not.
+This would make it impossible to use characters in switch/case statements,
+which would reduce performance. For a theoretical use (which nobody has asked
+for) in a minority area (EBCDIC platforms), this is not sensible. Any
+application that did need both could compile two versions of the library, using
+macros to give the functions distinct names. */
+
+#ifndef SUPPORT_UTF
+
+/* UTF-8 support is not enabled; use the platform-dependent character literals
+so that PCRE works in both ASCII and EBCDIC environments, but only in non-UTF
+mode. Newline characters are problematic in EBCDIC. Though it has CR and LF
+characters, a common practice has been to use its NL (0x15) character as the
+line terminator in C-like processing environments. However, sometimes the LF
+(0x25) character is used instead, according to this Unicode document:
+
+http://unicode.org/standard/reports/tr13/tr13-5.html
+
+PCRE defaults EBCDIC NL to 0x15, but has a build-time option to select 0x25
+instead. Whichever is *not* chosen is defined as NEL.
+
+In both ASCII and EBCDIC environments, CHAR_NL and CHAR_LF are synonyms for the
+same code point. */
+
+#ifdef EBCDIC
+
+#ifndef EBCDIC_NL25
+#define CHAR_NL                     '\x15'
+#define CHAR_NEL                    '\x25'
+#define STR_NL                      "\x15"
+#define STR_NEL                     "\x25"
+#else
+#define CHAR_NL                     '\x25'
+#define CHAR_NEL                    '\x15'
+#define STR_NL                      "\x25"
+#define STR_NEL                     "\x15"
+#endif
+
+#define CHAR_LF                     CHAR_NL
+#define STR_LF                      STR_NL
+
+#define CHAR_ESC                    '\047'
+#define CHAR_DEL                    '\007'
+#define CHAR_NBSP                   '\x41'
+#define STR_ESC                     "\047"
+#define STR_DEL                     "\007"
+
+#else  /* Not EBCDIC */
+
+/* In ASCII/Unicode, linefeed is '\n' and we equate this to NL for
+compatibility. NEL is the Unicode newline character; make sure it is
+a positive value. */
+
+#define CHAR_LF                     '\n'
+#define CHAR_NL                     CHAR_LF
+#define CHAR_NEL                    ((unsigned char)'\x85')
+#define CHAR_ESC                    '\033'
+#define CHAR_DEL                    '\177'
+#define CHAR_NBSP                   ((unsigned char)'\xa0')
+
+#define STR_LF                      "\n"
+#define STR_NL                      STR_LF
+#define STR_NEL                     "\x85"
+#define STR_ESC                     "\033"
+#define STR_DEL                     "\177"
+
+#endif  /* EBCDIC */
+
+/* The remaining definitions work in both environments. */
+
+#define CHAR_NULL                   '\0'
+#define CHAR_HT                     '\t'
+#define CHAR_VT                     '\v'
+#define CHAR_FF                     '\f'
+#define CHAR_CR                     '\r'
+#define CHAR_BS                     '\b'
+#define CHAR_BEL                    '\a'
+
+#define CHAR_SPACE                  ' '
+#define CHAR_EXCLAMATION_MARK       '!'
+#define CHAR_QUOTATION_MARK         '"'
+#define CHAR_NUMBER_SIGN            '#'
+#define CHAR_DOLLAR_SIGN            '$'
+#define CHAR_PERCENT_SIGN           '%'
+#define CHAR_AMPERSAND              '&'
+#define CHAR_APOSTROPHE             '\''
+#define CHAR_LEFT_PARENTHESIS       '('
+#define CHAR_RIGHT_PARENTHESIS      ')'
+#define CHAR_ASTERISK               '*'
+#define CHAR_PLUS                   '+'
+#define CHAR_COMMA                  ','
+#define CHAR_MINUS                  '-'
+#define CHAR_DOT                    '.'
+#define CHAR_SLASH                  '/'
+#define CHAR_0                      '0'
+#define CHAR_1                      '1'
+#define CHAR_2                      '2'
+#define CHAR_3                      '3'
+#define CHAR_4                      '4'
+#define CHAR_5                      '5'
+#define CHAR_6                      '6'
+#define CHAR_7                      '7'
+#define CHAR_8                      '8'
+#define CHAR_9                      '9'
+#define CHAR_COLON                  ':'
+#define CHAR_SEMICOLON              ';'
+#define CHAR_LESS_THAN_SIGN         '<'
+#define CHAR_EQUALS_SIGN            '='
+#define CHAR_GREATER_THAN_SIGN      '>'
+#define CHAR_QUESTION_MARK          '?'
+#define CHAR_COMMERCIAL_AT          '@'
+#define CHAR_A                      'A'
+#define CHAR_B                      'B'
+#define CHAR_C                      'C'
+#define CHAR_D                      'D'
+#define CHAR_E                      'E'
+#define CHAR_F                      'F'
+#define CHAR_G                      'G'
+#define CHAR_H                      'H'
+#define CHAR_I                      'I'
+#define CHAR_J                      'J'
+#define CHAR_K                      'K'
+#define CHAR_L                      'L'
+#define CHAR_M                      'M'
+#define CHAR_N                      'N'
+#define CHAR_O                      'O'
+#define CHAR_P                      'P'
+#define CHAR_Q                      'Q'
+#define CHAR_R                      'R'
+#define CHAR_S                      'S'
+#define CHAR_T                      'T'
+#define CHAR_U                      'U'
+#define CHAR_V                      'V'
+#define CHAR_W                      'W'
+#define CHAR_X                      'X'
+#define CHAR_Y                      'Y'
+#define CHAR_Z                      'Z'
+#define CHAR_LEFT_SQUARE_BRACKET    '['
+#define CHAR_BACKSLASH              '\\'
+#define CHAR_RIGHT_SQUARE_BRACKET   ']'
+#define CHAR_CIRCUMFLEX_ACCENT      '^'
+#define CHAR_UNDERSCORE             '_'
+#define CHAR_GRAVE_ACCENT           '`'
+#define CHAR_a                      'a'
+#define CHAR_b                      'b'
+#define CHAR_c                      'c'
+#define CHAR_d                      'd'
+#define CHAR_e                      'e'
+#define CHAR_f                      'f'
+#define CHAR_g                      'g'
+#define CHAR_h                      'h'
+#define CHAR_i                      'i'
+#define CHAR_j                      'j'
+#define CHAR_k                      'k'
+#define CHAR_l                      'l'
+#define CHAR_m                      'm'
+#define CHAR_n                      'n'
+#define CHAR_o                      'o'
+#define CHAR_p                      'p'
+#define CHAR_q                      'q'
+#define CHAR_r                      'r'
+#define CHAR_s                      's'
+#define CHAR_t                      't'
+#define CHAR_u                      'u'
+#define CHAR_v                      'v'
+#define CHAR_w                      'w'
+#define CHAR_x                      'x'
+#define CHAR_y                      'y'
+#define CHAR_z                      'z'
+#define CHAR_LEFT_CURLY_BRACKET     '{'
+#define CHAR_VERTICAL_LINE          '|'
+#define CHAR_RIGHT_CURLY_BRACKET    '}'
+#define CHAR_TILDE                  '~'
+
+#define STR_HT                      "\t"
+#define STR_VT                      "\v"
+#define STR_FF                      "\f"
+#define STR_CR                      "\r"
+#define STR_BS                      "\b"
+#define STR_BEL                     "\a"
+
+#define STR_SPACE                   " "
+#define STR_EXCLAMATION_MARK        "!"
+#define STR_QUOTATION_MARK          "\""
+#define STR_NUMBER_SIGN             "#"
+#define STR_DOLLAR_SIGN             "$"
+#define STR_PERCENT_SIGN            "%"
+#define STR_AMPERSAND               "&"
+#define STR_APOSTROPHE              "'"
+#define STR_LEFT_PARENTHESIS        "("
+#define STR_RIGHT_PARENTHESIS       ")"
+#define STR_ASTERISK                "*"
+#define STR_PLUS                    "+"
+#define STR_COMMA                   ","
+#define STR_MINUS                   "-"
+#define STR_DOT                     "."
+#define STR_SLASH                   "/"
+#define STR_0                       "0"
+#define STR_1                       "1"
+#define STR_2                       "2"
+#define STR_3                       "3"
+#define STR_4                       "4"
+#define STR_5                       "5"
+#define STR_6                       "6"
+#define STR_7                       "7"
+#define STR_8                       "8"
+#define STR_9                       "9"
+#define STR_COLON                   ":"
+#define STR_SEMICOLON               ";"
+#define STR_LESS_THAN_SIGN          "<"
+#define STR_EQUALS_SIGN             "="
+#define STR_GREATER_THAN_SIGN       ">"
+#define STR_QUESTION_MARK           "?"
+#define STR_COMMERCIAL_AT           "@"
+#define STR_A                       "A"
+#define STR_B                       "B"
+#define STR_C                       "C"
+#define STR_D                       "D"
+#define STR_E                       "E"
+#define STR_F                       "F"
+#define STR_G                       "G"
+#define STR_H                       "H"
+#define STR_I                       "I"
+#define STR_J                       "J"
+#define STR_K                       "K"
+#define STR_L                       "L"
+#define STR_M                       "M"
+#define STR_N                       "N"
+#define STR_O                       "O"
+#define STR_P                       "P"
+#define STR_Q                       "Q"
+#define STR_R                       "R"
+#define STR_S                       "S"
+#define STR_T                       "T"
+#define STR_U                       "U"
+#define STR_V                       "V"
+#define STR_W                       "W"
+#define STR_X                       "X"
+#define STR_Y                       "Y"
+#define STR_Z                       "Z"
+#define STR_LEFT_SQUARE_BRACKET     "["
+#define STR_BACKSLASH               "\\"
+#define STR_RIGHT_SQUARE_BRACKET    "]"
+#define STR_CIRCUMFLEX_ACCENT       "^"
+#define STR_UNDERSCORE              "_"
+#define STR_GRAVE_ACCENT            "`"
+#define STR_a                       "a"
+#define STR_b                       "b"
+#define STR_c                       "c"
+#define STR_d                       "d"
+#define STR_e                       "e"
+#define STR_f                       "f"
+#define STR_g                       "g"
+#define STR_h                       "h"
+#define STR_i                       "i"
+#define STR_j                       "j"
+#define STR_k                       "k"
+#define STR_l                       "l"
+#define STR_m                       "m"
+#define STR_n                       "n"
+#define STR_o                       "o"
+#define STR_p                       "p"
+#define STR_q                       "q"
+#define STR_r                       "r"
+#define STR_s                       "s"
+#define STR_t                       "t"
+#define STR_u                       "u"
+#define STR_v                       "v"
+#define STR_w                       "w"
+#define STR_x                       "x"
+#define STR_y                       "y"
+#define STR_z                       "z"
+#define STR_LEFT_CURLY_BRACKET      "{"
+#define STR_VERTICAL_LINE           "|"
+#define STR_RIGHT_CURLY_BRACKET     "}"
+#define STR_TILDE                   "~"
+
+#define STRING_ACCEPT0              "ACCEPT\0"
+#define STRING_COMMIT0              "COMMIT\0"
+#define STRING_F0                   "F\0"
+#define STRING_FAIL0                "FAIL\0"
+#define STRING_MARK0                "MARK\0"
+#define STRING_PRUNE0               "PRUNE\0"
+#define STRING_SKIP0                "SKIP\0"
+#define STRING_THEN                 "THEN"
+
+#define STRING_alpha0               "alpha\0"
+#define STRING_lower0               "lower\0"
+#define STRING_upper0               "upper\0"
+#define STRING_alnum0               "alnum\0"
+#define STRING_ascii0               "ascii\0"
+#define STRING_blank0               "blank\0"
+#define STRING_cntrl0               "cntrl\0"
+#define STRING_digit0               "digit\0"
+#define STRING_graph0               "graph\0"
+#define STRING_print0               "print\0"
+#define STRING_punct0               "punct\0"
+#define STRING_space0               "space\0"
+#define STRING_word0                "word\0"
+#define STRING_xdigit               "xdigit"
+
+#define STRING_DEFINE               "DEFINE"
+#define STRING_WEIRD_STARTWORD      "[:<:]]"
+#define STRING_WEIRD_ENDWORD        "[:>:]]"
+
+#define STRING_CR_RIGHTPAR              "CR)"
+#define STRING_LF_RIGHTPAR              "LF)"
+#define STRING_CRLF_RIGHTPAR            "CRLF)"
+#define STRING_ANY_RIGHTPAR             "ANY)"
+#define STRING_ANYCRLF_RIGHTPAR         "ANYCRLF)"
+#define STRING_BSR_ANYCRLF_RIGHTPAR     "BSR_ANYCRLF)"
+#define STRING_BSR_UNICODE_RIGHTPAR     "BSR_UNICODE)"
+#define STRING_UTF8_RIGHTPAR            "UTF8)"
+#define STRING_UTF16_RIGHTPAR           "UTF16)"
+#define STRING_UTF32_RIGHTPAR           "UTF32)"
+#define STRING_UTF_RIGHTPAR             "UTF)"
+#define STRING_UCP_RIGHTPAR             "UCP)"
+#define STRING_NO_AUTO_POSSESS_RIGHTPAR "NO_AUTO_POSSESS)"
+#define STRING_NO_START_OPT_RIGHTPAR    "NO_START_OPT)"
+#define STRING_LIMIT_MATCH_EQ           "LIMIT_MATCH="
+#define STRING_LIMIT_RECURSION_EQ       "LIMIT_RECURSION="
+
+#else  /* SUPPORT_UTF */
+
+/* UTF-8 support is enabled; always use UTF-8 (=ASCII) character codes. This
+works in both modes non-EBCDIC platforms, and on EBCDIC platforms in UTF-8 mode
+only. */
+
+#define CHAR_HT                     '\011'
+#define CHAR_VT                     '\013'
+#define CHAR_FF                     '\014'
+#define CHAR_CR                     '\015'
+#define CHAR_LF                     '\012'
+#define CHAR_NL                     CHAR_LF
+#define CHAR_NEL                    ((unsigned char)'\x85')
+#define CHAR_BS                     '\010'
+#define CHAR_BEL                    '\007'
+#define CHAR_ESC                    '\033'
+#define CHAR_DEL                    '\177'
+
+#define CHAR_NULL                   '\0'
+#define CHAR_SPACE                  '\040'
+#define CHAR_EXCLAMATION_MARK       '\041'
+#define CHAR_QUOTATION_MARK         '\042'
+#define CHAR_NUMBER_SIGN            '\043'
+#define CHAR_DOLLAR_SIGN            '\044'
+#define CHAR_PERCENT_SIGN           '\045'
+#define CHAR_AMPERSAND              '\046'
+#define CHAR_APOSTROPHE             '\047'
+#define CHAR_LEFT_PARENTHESIS       '\050'
+#define CHAR_RIGHT_PARENTHESIS      '\051'
+#define CHAR_ASTERISK               '\052'
+#define CHAR_PLUS                   '\053'
+#define CHAR_COMMA                  '\054'
+#define CHAR_MINUS                  '\055'
+#define CHAR_DOT                    '\056'
+#define CHAR_SLASH                  '\057'
+#define CHAR_0                      '\060'
+#define CHAR_1                      '\061'
+#define CHAR_2                      '\062'
+#define CHAR_3                      '\063'
+#define CHAR_4                      '\064'
+#define CHAR_5                      '\065'
+#define CHAR_6                      '\066'
+#define CHAR_7                      '\067'
+#define CHAR_8                      '\070'
+#define CHAR_9                      '\071'
+#define CHAR_COLON                  '\072'
+#define CHAR_SEMICOLON              '\073'
+#define CHAR_LESS_THAN_SIGN         '\074'
+#define CHAR_EQUALS_SIGN            '\075'
+#define CHAR_GREATER_THAN_SIGN      '\076'
+#define CHAR_QUESTION_MARK          '\077'
+#define CHAR_COMMERCIAL_AT          '\100'
+#define CHAR_A                      '\101'
+#define CHAR_B                      '\102'
+#define CHAR_C                      '\103'
+#define CHAR_D                      '\104'
+#define CHAR_E                      '\105'
+#define CHAR_F                      '\106'
+#define CHAR_G                      '\107'
+#define CHAR_H                      '\110'
+#define CHAR_I                      '\111'
+#define CHAR_J                      '\112'
+#define CHAR_K                      '\113'
+#define CHAR_L                      '\114'
+#define CHAR_M                      '\115'
+#define CHAR_N                      '\116'
+#define CHAR_O                      '\117'
+#define CHAR_P                      '\120'
+#define CHAR_Q                      '\121'
+#define CHAR_R                      '\122'
+#define CHAR_S                      '\123'
+#define CHAR_T                      '\124'
+#define CHAR_U                      '\125'
+#define CHAR_V                      '\126'
+#define CHAR_W                      '\127'
+#define CHAR_X                      '\130'
+#define CHAR_Y                      '\131'
+#define CHAR_Z                      '\132'
+#define CHAR_LEFT_SQUARE_BRACKET    '\133'
+#define CHAR_BACKSLASH              '\134'
+#define CHAR_RIGHT_SQUARE_BRACKET   '\135'
+#define CHAR_CIRCUMFLEX_ACCENT      '\136'
+#define CHAR_UNDERSCORE             '\137'
+#define CHAR_GRAVE_ACCENT           '\140'
+#define CHAR_a                      '\141'
+#define CHAR_b                      '\142'
+#define CHAR_c                      '\143'
+#define CHAR_d                      '\144'
+#define CHAR_e                      '\145'
+#define CHAR_f                      '\146'
+#define CHAR_g                      '\147'
+#define CHAR_h                      '\150'
+#define CHAR_i                      '\151'
+#define CHAR_j                      '\152'
+#define CHAR_k                      '\153'
+#define CHAR_l                      '\154'
+#define CHAR_m                      '\155'
+#define CHAR_n                      '\156'
+#define CHAR_o                      '\157'
+#define CHAR_p                      '\160'
+#define CHAR_q                      '\161'
+#define CHAR_r                      '\162'
+#define CHAR_s                      '\163'
+#define CHAR_t                      '\164'
+#define CHAR_u                      '\165'
+#define CHAR_v                      '\166'
+#define CHAR_w                      '\167'
+#define CHAR_x                      '\170'
+#define CHAR_y                      '\171'
+#define CHAR_z                      '\172'
+#define CHAR_LEFT_CURLY_BRACKET     '\173'
+#define CHAR_VERTICAL_LINE          '\174'
+#define CHAR_RIGHT_CURLY_BRACKET    '\175'
+#define CHAR_TILDE                  '\176'
+#define CHAR_NBSP                   ((unsigned char)'\xa0')
+
+#define STR_HT                      "\011"
+#define STR_VT                      "\013"
+#define STR_FF                      "\014"
+#define STR_CR                      "\015"
+#define STR_NL                      "\012"
+#define STR_BS                      "\010"
+#define STR_BEL                     "\007"
+#define STR_ESC                     "\033"
+#define STR_DEL                     "\177"
+
+#define STR_SPACE                   "\040"
+#define STR_EXCLAMATION_MARK        "\041"
+#define STR_QUOTATION_MARK          "\042"
+#define STR_NUMBER_SIGN             "\043"
+#define STR_DOLLAR_SIGN             "\044"
+#define STR_PERCENT_SIGN            "\045"
+#define STR_AMPERSAND               "\046"
+#define STR_APOSTROPHE              "\047"
+#define STR_LEFT_PARENTHESIS        "\050"
+#define STR_RIGHT_PARENTHESIS       "\051"
+#define STR_ASTERISK                "\052"
+#define STR_PLUS                    "\053"
+#define STR_COMMA                   "\054"
+#define STR_MINUS                   "\055"
+#define STR_DOT                     "\056"
+#define STR_SLASH                   "\057"
+#define STR_0                       "\060"
+#define STR_1                       "\061"
+#define STR_2                       "\062"
+#define STR_3                       "\063"
+#define STR_4                       "\064"
+#define STR_5                       "\065"
+#define STR_6                       "\066"
+#define STR_7                       "\067"
+#define STR_8                       "\070"
+#define STR_9                       "\071"
+#define STR_COLON                   "\072"
+#define STR_SEMICOLON               "\073"
+#define STR_LESS_THAN_SIGN          "\074"
+#define STR_EQUALS_SIGN             "\075"
+#define STR_GREATER_THAN_SIGN       "\076"
+#define STR_QUESTION_MARK           "\077"
+#define STR_COMMERCIAL_AT           "\100"
+#define STR_A                       "\101"
+#define STR_B                       "\102"
+#define STR_C                       "\103"
+#define STR_D                       "\104"
+#define STR_E                       "\105"
+#define STR_F                       "\106"
+#define STR_G                       "\107"
+#define STR_H                       "\110"
+#define STR_I                       "\111"
+#define STR_J                       "\112"
+#define STR_K                       "\113"
+#define STR_L                       "\114"
+#define STR_M                       "\115"
+#define STR_N                       "\116"
+#define STR_O                       "\117"
+#define STR_P                       "\120"
+#define STR_Q                       "\121"
+#define STR_R                       "\122"
+#define STR_S                       "\123"
+#define STR_T                       "\124"
+#define STR_U                       "\125"
+#define STR_V                       "\126"
+#define STR_W                       "\127"
+#define STR_X                       "\130"
+#define STR_Y                       "\131"
+#define STR_Z                       "\132"
+#define STR_LEFT_SQUARE_BRACKET     "\133"
+#define STR_BACKSLASH               "\134"
+#define STR_RIGHT_SQUARE_BRACKET    "\135"
+#define STR_CIRCUMFLEX_ACCENT       "\136"
+#define STR_UNDERSCORE              "\137"
+#define STR_GRAVE_ACCENT            "\140"
+#define STR_a                       "\141"
+#define STR_b                       "\142"
+#define STR_c                       "\143"
+#define STR_d                       "\144"
+#define STR_e                       "\145"
+#define STR_f                       "\146"
+#define STR_g                       "\147"
+#define STR_h                       "\150"
+#define STR_i                       "\151"
+#define STR_j                       "\152"
+#define STR_k                       "\153"
+#define STR_l                       "\154"
+#define STR_m                       "\155"
+#define STR_n                       "\156"
+#define STR_o                       "\157"
+#define STR_p                       "\160"
+#define STR_q                       "\161"
+#define STR_r                       "\162"
+#define STR_s                       "\163"
+#define STR_t                       "\164"
+#define STR_u                       "\165"
+#define STR_v                       "\166"
+#define STR_w                       "\167"
+#define STR_x                       "\170"
+#define STR_y                       "\171"
+#define STR_z                       "\172"
+#define STR_LEFT_CURLY_BRACKET      "\173"
+#define STR_VERTICAL_LINE           "\174"
+#define STR_RIGHT_CURLY_BRACKET     "\175"
+#define STR_TILDE                   "\176"
+
+#define STRING_ACCEPT0              STR_A STR_C STR_C STR_E STR_P STR_T "\0"
+#define STRING_COMMIT0              STR_C STR_O STR_M STR_M STR_I STR_T "\0"
+#define STRING_F0                   STR_F "\0"
+#define STRING_FAIL0                STR_F STR_A STR_I STR_L "\0"
+#define STRING_MARK0                STR_M STR_A STR_R STR_K "\0"
+#define STRING_PRUNE0               STR_P STR_R STR_U STR_N STR_E "\0"
+#define STRING_SKIP0                STR_S STR_K STR_I STR_P "\0"
+#define STRING_THEN                 STR_T STR_H STR_E STR_N
+
+#define STRING_alpha0               STR_a STR_l STR_p STR_h STR_a "\0"
+#define STRING_lower0               STR_l STR_o STR_w STR_e STR_r "\0"
+#define STRING_upper0               STR_u STR_p STR_p STR_e STR_r "\0"
+#define STRING_alnum0               STR_a STR_l STR_n STR_u STR_m "\0"
+#define STRING_ascii0               STR_a STR_s STR_c STR_i STR_i "\0"
+#define STRING_blank0               STR_b STR_l STR_a STR_n STR_k "\0"
+#define STRING_cntrl0               STR_c STR_n STR_t STR_r STR_l "\0"
+#define STRING_digit0               STR_d STR_i STR_g STR_i STR_t "\0"
+#define STRING_graph0               STR_g STR_r STR_a STR_p STR_h "\0"
+#define STRING_print0               STR_p STR_r STR_i STR_n STR_t "\0"
+#define STRING_punct0               STR_p STR_u STR_n STR_c STR_t "\0"
+#define STRING_space0               STR_s STR_p STR_a STR_c STR_e "\0"
+#define STRING_word0                STR_w STR_o STR_r STR_d       "\0"
+#define STRING_xdigit               STR_x STR_d STR_i STR_g STR_i STR_t
+
+#define STRING_DEFINE               STR_D STR_E STR_F STR_I STR_N STR_E
+#define STRING_WEIRD_STARTWORD      STR_LEFT_SQUARE_BRACKET STR_COLON STR_LESS_THAN_SIGN STR_COLON STR_RIGHT_SQUARE_BRACKET STR_RIGHT_SQUARE_BRACKET
+#define STRING_WEIRD_ENDWORD        STR_LEFT_SQUARE_BRACKET STR_COLON STR_GREATER_THAN_SIGN STR_COLON STR_RIGHT_SQUARE_BRACKET STR_RIGHT_SQUARE_BRACKET
+
+#define STRING_CR_RIGHTPAR              STR_C STR_R STR_RIGHT_PARENTHESIS
+#define STRING_LF_RIGHTPAR              STR_L STR_F STR_RIGHT_PARENTHESIS
+#define STRING_CRLF_RIGHTPAR            STR_C STR_R STR_L STR_F STR_RIGHT_PARENTHESIS
+#define STRING_ANY_RIGHTPAR             STR_A STR_N STR_Y STR_RIGHT_PARENTHESIS
+#define STRING_ANYCRLF_RIGHTPAR         STR_A STR_N STR_Y STR_C STR_R STR_L STR_F STR_RIGHT_PARENTHESIS
+#define STRING_BSR_ANYCRLF_RIGHTPAR     STR_B STR_S STR_R STR_UNDERSCORE STR_A STR_N STR_Y STR_C STR_R STR_L STR_F STR_RIGHT_PARENTHESIS
+#define STRING_BSR_UNICODE_RIGHTPAR     STR_B STR_S STR_R STR_UNDERSCORE STR_U STR_N STR_I STR_C STR_O STR_D STR_E STR_RIGHT_PARENTHESIS
+#define STRING_UTF8_RIGHTPAR            STR_U STR_T STR_F STR_8 STR_RIGHT_PARENTHESIS
+#define STRING_UTF16_RIGHTPAR           STR_U STR_T STR_F STR_1 STR_6 STR_RIGHT_PARENTHESIS
+#define STRING_UTF32_RIGHTPAR           STR_U STR_T STR_F STR_3 STR_2 STR_RIGHT_PARENTHESIS
+#define STRING_UTF_RIGHTPAR             STR_U STR_T STR_F STR_RIGHT_PARENTHESIS
+#define STRING_UCP_RIGHTPAR             STR_U STR_C STR_P STR_RIGHT_PARENTHESIS
+#define STRING_NO_AUTO_POSSESS_RIGHTPAR STR_N STR_O STR_UNDERSCORE STR_A STR_U STR_T STR_O STR_UNDERSCORE STR_P STR_O STR_S STR_S STR_E STR_S STR_S STR_RIGHT_PARENTHESIS
+#define STRING_NO_START_OPT_RIGHTPAR    STR_N STR_O STR_UNDERSCORE STR_S STR_T STR_A STR_R STR_T STR_UNDERSCORE STR_O STR_P STR_T STR_RIGHT_PARENTHESIS
+#define STRING_LIMIT_MATCH_EQ           STR_L STR_I STR_M STR_I STR_T STR_UNDERSCORE STR_M STR_A STR_T STR_C STR_H STR_EQUALS_SIGN
+#define STRING_LIMIT_RECURSION_EQ       STR_L STR_I STR_M STR_I STR_T STR_UNDERSCORE STR_R STR_E STR_C STR_U STR_R STR_S STR_I STR_O STR_N STR_EQUALS_SIGN
+
+#endif  /* SUPPORT_UTF */
+
+/* Escape items that are just an encoding of a particular data value. */
+
+#ifndef ESC_a
+#define ESC_a CHAR_BEL
+#endif
+
+#ifndef ESC_e
+#define ESC_e CHAR_ESC
+#endif
+
+#ifndef ESC_f
+#define ESC_f CHAR_FF
+#endif
+
+#ifndef ESC_n
+#define ESC_n CHAR_LF
+#endif
+
+#ifndef ESC_r
+#define ESC_r CHAR_CR
+#endif
+
+/* We can't officially use ESC_t because it is a POSIX reserved identifier
+(presumably because of all the others like size_t). */
+
+#ifndef ESC_tee
+#define ESC_tee CHAR_HT
+#endif
+
+/* Codes for different types of Unicode property */
+
+#define PT_ANY        0    /* Any property - matches all chars */
+#define PT_LAMP       1    /* L& - the union of Lu, Ll, Lt */
+#define PT_GC         2    /* Specified general characteristic (e.g. L) */
+#define PT_PC         3    /* Specified particular characteristic (e.g. Lu) */
+#define PT_SC         4    /* Script (e.g. Han) */
+#define PT_ALNUM      5    /* Alphanumeric - the union of L and N */
+#define PT_SPACE      6    /* Perl space - Z plus 9,10,12,13 */
+#define PT_PXSPACE    7    /* POSIX space - Z plus 9,10,11,12,13 */
+#define PT_WORD       8    /* Word - L plus N plus underscore */
+#define PT_CLIST      9    /* Pseudo-property: match character list */
+#define PT_UCNC      10    /* Universal Character nameable character */
+#define PT_TABSIZE   11    /* Size of square table for autopossessify tests */
+
+/* The following special properties are used only in XCLASS items, when POSIX
+classes are specified and PCRE_UCP is set - in other words, for Unicode
+handling of these classes. They are not available via the \p or \P escapes like
+those in the above list, and so they do not take part in the autopossessifying
+table. */
+
+#define PT_PXGRAPH   11    /* [:graph:] - characters that mark the paper */
+#define PT_PXPRINT   12    /* [:print:] - [:graph:] plus non-control spaces */
+#define PT_PXPUNCT   13    /* [:punct:] - punctuation characters */
+
+/* Flag bits and data types for the extended class (OP_XCLASS) for classes that
+contain characters with values greater than 255. */
+
+#define XCL_NOT       0x01    /* Flag: this is a negative class */
+#define XCL_MAP       0x02    /* Flag: a 32-byte map is present */
+#define XCL_HASPROP   0x04    /* Flag: property checks are present. */
+
+#define XCL_END       0    /* Marks end of individual items */
+#define XCL_SINGLE    1    /* Single item (one multibyte char) follows */
+#define XCL_RANGE     2    /* A range (two multibyte chars) follows */
+#define XCL_PROP      3    /* Unicode property (2-byte property code follows) */
+#define XCL_NOTPROP   4    /* Unicode inverted property (ditto) */
+
+/* These are escaped items that aren't just an encoding of a particular data
+value such as \n. They must have non-zero values, as check_escape() returns 0
+for a data character.  Also, they must appear in the same order as in the
+opcode definitions below, up to ESC_z. There's a dummy for OP_ALLANY because it
+corresponds to "." in DOTALL mode rather than an escape sequence. It is also
+used for [^] in JavaScript compatibility mode, and for \C in non-utf mode. In
+non-DOTALL mode, "." behaves like \N.
+
+The special values ESC_DU, ESC_du, etc. are used instead of ESC_D, ESC_d, etc.
+when PCRE_UCP is set and replacement of \d etc by \p sequences is required.
+They must be contiguous, and remain in order so that the replacements can be
+looked up from a table.
+
+Negative numbers are used to encode a backreference (\1, \2, \3, etc.) in
+check_escape(). There are two tests in the code for an escape
+greater than ESC_b and less than ESC_Z to detect the types that may be
+repeated. These are the types that consume characters. If any new escapes are
+put in between that don't consume a character, that code will have to change.
+*/
+
+enum { ESC_A = 1, ESC_G, ESC_K, ESC_B, ESC_b, ESC_D, ESC_d, ESC_S, ESC_s,
+       ESC_W, ESC_w, ESC_N, ESC_dum, ESC_C, ESC_P, ESC_p, ESC_R, ESC_H,
+       ESC_h, ESC_V, ESC_v, ESC_X, ESC_Z, ESC_z,
+       ESC_E, ESC_Q, ESC_g, ESC_k,
+       ESC_DU, ESC_du, ESC_SU, ESC_su, ESC_WU, ESC_wu };
+
+
+/********************** Opcode definitions ******************/
+
+/****** NOTE NOTE NOTE ******
+
+Starting from 1 (i.e. after OP_END), the values up to OP_EOD must correspond in
+order to the list of escapes immediately above. Furthermore, values up to
+OP_DOLLM must not be changed without adjusting the table called autoposstab in
+pcre_compile.c
+
+Whenever this list is updated, the two macro definitions that follow must be
+updated to match. The possessification table called "opcode_possessify" in
+pcre_compile.c must also be updated, and also the tables called "coptable"
+and "poptable" in pcre_dfa_exec.c.
+
+****** NOTE NOTE NOTE ******/
+
+
+/* The values between FIRST_AUTOTAB_OP and LAST_AUTOTAB_RIGHT_OP, inclusive,
+are used in a table for deciding whether a repeated character type can be
+auto-possessified. */
+
+#define FIRST_AUTOTAB_OP       OP_NOT_DIGIT
+#define LAST_AUTOTAB_LEFT_OP   OP_EXTUNI
+#define LAST_AUTOTAB_RIGHT_OP  OP_DOLLM
+
+enum {
+  OP_END,            /* 0 End of pattern */
+
+  /* Values corresponding to backslashed metacharacters */
+
+  OP_SOD,            /* 1 Start of data: \A */
+  OP_SOM,            /* 2 Start of match (subject + offset): \G */
+  OP_SET_SOM,        /* 3 Set start of match (\K) */
+  OP_NOT_WORD_BOUNDARY,  /*  4 \B */
+  OP_WORD_BOUNDARY,      /*  5 \b */
+  OP_NOT_DIGIT,          /*  6 \D */
+  OP_DIGIT,              /*  7 \d */
+  OP_NOT_WHITESPACE,     /*  8 \S */
+  OP_WHITESPACE,         /*  9 \s */
+  OP_NOT_WORDCHAR,       /* 10 \W */
+  OP_WORDCHAR,           /* 11 \w */
+
+  OP_ANY,            /* 12 Match any character except newline (\N) */
+  OP_ALLANY,         /* 13 Match any character */
+  OP_ANYBYTE,        /* 14 Match any byte (\C); different to OP_ANY for UTF-8 */
+  OP_NOTPROP,        /* 15 \P (not Unicode property) */
+  OP_PROP,           /* 16 \p (Unicode property) */
+  OP_ANYNL,          /* 17 \R (any newline sequence) */
+  OP_NOT_HSPACE,     /* 18 \H (not horizontal whitespace) */
+  OP_HSPACE,         /* 19 \h (horizontal whitespace) */
+  OP_NOT_VSPACE,     /* 20 \V (not vertical whitespace) */
+  OP_VSPACE,         /* 21 \v (vertical whitespace) */
+  OP_EXTUNI,         /* 22 \X (extended Unicode sequence */
+  OP_EODN,           /* 23 End of data or \n at end of data (\Z) */
+  OP_EOD,            /* 24 End of data (\z) */
+
+  /* Line end assertions */
+
+  OP_DOLL,           /* 25 End of line - not multiline */
+  OP_DOLLM,          /* 26 End of line - multiline */
+  OP_CIRC,           /* 27 Start of line - not multiline */
+  OP_CIRCM,          /* 28 Start of line - multiline */
+
+  /* Single characters; caseful must precede the caseless ones */
+
+  OP_CHAR,           /* 29 Match one character, casefully */
+  OP_CHARI,          /* 30 Match one character, caselessly */
+  OP_NOT,            /* 31 Match one character, not the given one, casefully */
+  OP_NOTI,           /* 32 Match one character, not the given one, caselessly */
+
+  /* The following sets of 13 opcodes must always be kept in step because
+  the offset from the first one is used to generate the others. */
+
+  /* Repeated characters; caseful must precede the caseless ones */
+
+  OP_STAR,           /* 33 The maximizing and minimizing versions of */
+  OP_MINSTAR,        /* 34 these six opcodes must come in pairs, with */
+  OP_PLUS,           /* 35 the minimizing one second. */
+  OP_MINPLUS,        /* 36 */
+  OP_QUERY,          /* 37 */
+  OP_MINQUERY,       /* 38 */
+
+  OP_UPTO,           /* 39 From 0 to n matches of one character, caseful*/
+  OP_MINUPTO,        /* 40 */
+  OP_EXACT,          /* 41 Exactly n matches */
+
+  OP_POSSTAR,        /* 42 Possessified star, caseful */
+  OP_POSPLUS,        /* 43 Possessified plus, caseful */
+  OP_POSQUERY,       /* 44 Posesssified query, caseful */
+  OP_POSUPTO,        /* 45 Possessified upto, caseful */
+
+  /* Repeated characters; caseless must follow the caseful ones */
+
+  OP_STARI,          /* 46 */
+  OP_MINSTARI,       /* 47 */
+  OP_PLUSI,          /* 48 */
+  OP_MINPLUSI,       /* 49 */
+  OP_QUERYI,         /* 50 */
+  OP_MINQUERYI,      /* 51 */
+
+  OP_UPTOI,          /* 52 From 0 to n matches of one character, caseless */
+  OP_MINUPTOI,       /* 53 */
+  OP_EXACTI,         /* 54 */
+
+  OP_POSSTARI,       /* 55 Possessified star, caseless */
+  OP_POSPLUSI,       /* 56 Possessified plus, caseless */
+  OP_POSQUERYI,      /* 57 Posesssified query, caseless */
+  OP_POSUPTOI,       /* 58 Possessified upto, caseless */
+
+  /* The negated ones must follow the non-negated ones, and match them */
+  /* Negated repeated character, caseful; must precede the caseless ones */
+
+  OP_NOTSTAR,        /* 59 The maximizing and minimizing versions of */
+  OP_NOTMINSTAR,     /* 60 these six opcodes must come in pairs, with */
+  OP_NOTPLUS,        /* 61 the minimizing one second. They must be in */
+  OP_NOTMINPLUS,     /* 62 exactly the same order as those above. */
+  OP_NOTQUERY,       /* 63 */
+  OP_NOTMINQUERY,    /* 64 */
+
+  OP_NOTUPTO,        /* 65 From 0 to n matches, caseful */
+  OP_NOTMINUPTO,     /* 66 */
+  OP_NOTEXACT,       /* 67 Exactly n matches */
+
+  OP_NOTPOSSTAR,     /* 68 Possessified versions, caseful */
+  OP_NOTPOSPLUS,     /* 69 */
+  OP_NOTPOSQUERY,    /* 70 */
+  OP_NOTPOSUPTO,     /* 71 */
+
+  /* Negated repeated character, caseless; must follow the caseful ones */
+
+  OP_NOTSTARI,       /* 72 */
+  OP_NOTMINSTARI,    /* 73 */
+  OP_NOTPLUSI,       /* 74 */
+  OP_NOTMINPLUSI,    /* 75 */
+  OP_NOTQUERYI,      /* 76 */
+  OP_NOTMINQUERYI,   /* 77 */
+
+  OP_NOTUPTOI,       /* 78 From 0 to n matches, caseless */
+  OP_NOTMINUPTOI,    /* 79 */
+  OP_NOTEXACTI,      /* 80 Exactly n matches */
+
+  OP_NOTPOSSTARI,    /* 81 Possessified versions, caseless */
+  OP_NOTPOSPLUSI,    /* 82 */
+  OP_NOTPOSQUERYI,   /* 83 */
+  OP_NOTPOSUPTOI,    /* 84 */
+
+  /* Character types */
+
+  OP_TYPESTAR,       /* 85 The maximizing and minimizing versions of */
+  OP_TYPEMINSTAR,    /* 86 these six opcodes must come in pairs, with */
+  OP_TYPEPLUS,       /* 87 the minimizing one second. These codes must */
+  OP_TYPEMINPLUS,    /* 88 be in exactly the same order as those above. */
+  OP_TYPEQUERY,      /* 89 */
+  OP_TYPEMINQUERY,   /* 90 */
+
+  OP_TYPEUPTO,       /* 91 From 0 to n matches */
+  OP_TYPEMINUPTO,    /* 92 */
+  OP_TYPEEXACT,      /* 93 Exactly n matches */
+
+  OP_TYPEPOSSTAR,    /* 94 Possessified versions */
+  OP_TYPEPOSPLUS,    /* 95 */
+  OP_TYPEPOSQUERY,   /* 96 */
+  OP_TYPEPOSUPTO,    /* 97 */
+
+  /* These are used for character classes and back references; only the
+  first six are the same as the sets above. */
+
+  OP_CRSTAR,         /* 98 The maximizing and minimizing versions of */
+  OP_CRMINSTAR,      /* 99 all these opcodes must come in pairs, with */
+  OP_CRPLUS,         /* 100 the minimizing one second. These codes must */
+  OP_CRMINPLUS,      /* 101 be in exactly the same order as those above. */
+  OP_CRQUERY,        /* 102 */
+  OP_CRMINQUERY,     /* 103 */
+
+  OP_CRRANGE,        /* 104 These are different to the three sets above. */
+  OP_CRMINRANGE,     /* 105 */
+
+  OP_CRPOSSTAR,      /* 106 Possessified versions */
+  OP_CRPOSPLUS,      /* 107 */
+  OP_CRPOSQUERY,     /* 108 */
+  OP_CRPOSRANGE,     /* 109 */
+
+  /* End of quantifier opcodes */
+
+  OP_CLASS,          /* 110 Match a character class, chars < 256 only */
+  OP_NCLASS,         /* 111 Same, but the bitmap was created from a negative
+                              class - the difference is relevant only when a
+                              character > 255 is encountered. */
+  OP_XCLASS,         /* 112 Extended class for handling > 255 chars within the
+                              class. This does both positive and negative. */
+  OP_REF,            /* 113 Match a back reference, casefully */
+  OP_REFI,           /* 114 Match a back reference, caselessly */
+  OP_DNREF,          /* 115 Match a duplicate name backref, casefully */
+  OP_DNREFI,         /* 116 Match a duplicate name backref, caselessly */
+  OP_RECURSE,        /* 117 Match a numbered subpattern (possibly recursive) */
+  OP_CALLOUT,        /* 118 Call out to external function if provided */
+
+  OP_ALT,            /* 119 Start of alternation */
+  OP_KET,            /* 120 End of group that doesn't have an unbounded repeat */
+  OP_KETRMAX,        /* 121 These two must remain together and in this */
+  OP_KETRMIN,        /* 122 order. They are for groups the repeat for ever. */
+  OP_KETRPOS,        /* 123 Possessive unlimited repeat. */
+
+  /* The assertions must come before BRA, CBRA, ONCE, and COND, and the four
+  asserts must remain in order. */
+
+  OP_REVERSE,        /* 124 Move pointer back - used in lookbehind assertions */
+  OP_ASSERT,         /* 125 Positive lookahead */
+  OP_ASSERT_NOT,     /* 126 Negative lookahead */
+  OP_ASSERTBACK,     /* 127 Positive lookbehind */
+  OP_ASSERTBACK_NOT, /* 128 Negative lookbehind */
+
+  /* ONCE, ONCE_NC, BRA, BRAPOS, CBRA, CBRAPOS, and COND must come immediately
+  after the assertions, with ONCE first, as there's a test for >= ONCE for a
+  subpattern that isn't an assertion. The POS versions must immediately follow
+  the non-POS versions in each case. */
+
+  OP_ONCE,           /* 129 Atomic group, contains captures */
+  OP_ONCE_NC,        /* 130 Atomic group containing no captures */
+  OP_BRA,            /* 131 Start of non-capturing bracket */
+  OP_BRAPOS,         /* 132 Ditto, with unlimited, possessive repeat */
+  OP_CBRA,           /* 133 Start of capturing bracket */
+  OP_CBRAPOS,        /* 134 Ditto, with unlimited, possessive repeat */
+  OP_COND,           /* 135 Conditional group */
+
+  /* These five must follow the previous five, in the same order. There's a
+  check for >= SBRA to distinguish the two sets. */
+
+  OP_SBRA,           /* 136 Start of non-capturing bracket, check empty  */
+  OP_SBRAPOS,        /* 137 Ditto, with unlimited, possessive repeat */
+  OP_SCBRA,          /* 138 Start of capturing bracket, check empty */
+  OP_SCBRAPOS,       /* 139 Ditto, with unlimited, possessive repeat */
+  OP_SCOND,          /* 140 Conditional group, check empty */
+
+  /* The next two pairs must (respectively) be kept together. */
+
+  OP_CREF,           /* 141 Used to hold a capture number as condition */
+  OP_DNCREF,         /* 142 Used to point to duplicate names as a condition */
+  OP_RREF,           /* 143 Used to hold a recursion number as condition */
+  OP_DNRREF,         /* 144 Used to point to duplicate names as a condition */
+  OP_DEF,            /* 145 The DEFINE condition */
+
+  OP_BRAZERO,        /* 146 These two must remain together and in this */
+  OP_BRAMINZERO,     /* 147 order. */
+  OP_BRAPOSZERO,     /* 148 */
+
+  /* These are backtracking control verbs */
+
+  OP_MARK,           /* 149 always has an argument */
+  OP_PRUNE,          /* 150 */
+  OP_PRUNE_ARG,      /* 151 same, but with argument */
+  OP_SKIP,           /* 152 */
+  OP_SKIP_ARG,       /* 153 same, but with argument */
+  OP_THEN,           /* 154 */
+  OP_THEN_ARG,       /* 155 same, but with argument */
+  OP_COMMIT,         /* 156 */
+
+  /* These are forced failure and success verbs */
+
+  OP_FAIL,           /* 157 */
+  OP_ACCEPT,         /* 158 */
+  OP_ASSERT_ACCEPT,  /* 159 Used inside assertions */
+  OP_CLOSE,          /* 160 Used before OP_ACCEPT to close open captures */
+
+  /* This is used to skip a subpattern with a {0} quantifier */
+
+  OP_SKIPZERO,       /* 161 */
+
+  /* This is not an opcode, but is used to check that tables indexed by opcode
+  are the correct length, in order to catch updating errors - there have been
+  some in the past. */
+
+  OP_TABLE_LENGTH
+};
+
+/* *** NOTE NOTE NOTE *** Whenever the list above is updated, the two macro
+definitions that follow must also be updated to match. There are also tables
+called "opcode_possessify" in pcre_compile.c and "coptable" and "poptable" in
+pcre_dfa_exec.c that must be updated. */
+
+
+/* This macro defines textual names for all the opcodes. These are used only
+for debugging, and some of them are only partial names. The macro is referenced
+only in pcre_printint.c, which fills out the full names in many cases (and in
+some cases doesn't actually use these names at all). */
+
+#define OP_NAME_LIST \
+  "End", "\\A", "\\G", "\\K", "\\B", "\\b", "\\D", "\\d",         \
+  "\\S", "\\s", "\\W", "\\w", "Any", "AllAny", "Anybyte",         \
+  "notprop", "prop", "\\R", "\\H", "\\h", "\\V", "\\v",           \
+  "extuni",  "\\Z", "\\z",                                        \
+  "$", "$", "^", "^", "char", "chari", "not", "noti",             \
+  "*", "*?", "+", "+?", "?", "??",                                \
+  "{", "{", "{",                                                  \
+  "*+","++", "?+", "{",                                           \
+  "*", "*?", "+", "+?", "?", "??",                                \
+  "{", "{", "{",                                                  \
+  "*+","++", "?+", "{",                                           \
+  "*", "*?", "+", "+?", "?", "??",                                \
+  "{", "{", "{",                                                  \
+  "*+","++", "?+", "{",                                           \
+  "*", "*?", "+", "+?", "?", "??",                                \
+  "{", "{", "{",                                                  \
+  "*+","++", "?+", "{",                                           \
+  "*", "*?", "+", "+?", "?", "??", "{", "{", "{",                 \
+  "*+","++", "?+", "{",                                           \
+  "*", "*?", "+", "+?", "?", "??", "{", "{",                      \
+  "*+","++", "?+", "{",                                           \
+  "class", "nclass", "xclass", "Ref", "Refi", "DnRef", "DnRefi",  \
+  "Recurse", "Callout",                                           \
+  "Alt", "Ket", "KetRmax", "KetRmin", "KetRpos",                  \
+  "Reverse", "Assert", "Assert not", "AssertB", "AssertB not",    \
+  "Once", "Once_NC",                                              \
+  "Bra", "BraPos", "CBra", "CBraPos",                             \
+  "Cond",                                                         \
+  "SBra", "SBraPos", "SCBra", "SCBraPos",                         \
+  "SCond",                                                        \
+  "Cond ref", "Cond dnref", "Cond rec", "Cond dnrec", "Cond def", \
+  "Brazero", "Braminzero", "Braposzero",                          \
+  "*MARK", "*PRUNE", "*PRUNE", "*SKIP", "*SKIP",                  \
+  "*THEN", "*THEN", "*COMMIT", "*FAIL",                           \
+  "*ACCEPT", "*ASSERT_ACCEPT",                                    \
+  "Close", "Skip zero"
+
+
+/* This macro defines the length of fixed length operations in the compiled
+regex. The lengths are used when searching for specific things, and also in the
+debugging printing of a compiled regex. We use a macro so that it can be
+defined close to the definitions of the opcodes themselves.
+
+As things have been extended, some of these are no longer fixed lenths, but are
+minima instead. For example, the length of a single-character repeat may vary
+in UTF-8 mode. The code that uses this table must know about such things. */
+
+#define OP_LENGTHS \
+  1,                             /* End                                    */ \
+  1, 1, 1, 1, 1,                 /* \A, \G, \K, \B, \b                     */ \
+  1, 1, 1, 1, 1, 1,              /* \D, \d, \S, \s, \W, \w                 */ \
+  1, 1, 1,                       /* Any, AllAny, Anybyte                   */ \
+  3, 3,                          /* \P, \p                                 */ \
+  1, 1, 1, 1, 1,                 /* \R, \H, \h, \V, \v                     */ \
+  1,                             /* \X                                     */ \
+  1, 1, 1, 1, 1, 1,              /* \Z, \z, $, $M ^, ^M                    */ \
+  2,                             /* Char  - the minimum length             */ \
+  2,                             /* Chari  - the minimum length            */ \
+  2,                             /* not                                    */ \
+  2,                             /* noti                                   */ \
+  /* Positive single-char repeats                             ** These are */ \
+  2, 2, 2, 2, 2, 2,              /* *, *?, +, +?, ?, ??       ** minima in */ \
+  2+IMM2_SIZE, 2+IMM2_SIZE,      /* upto, minupto             ** mode      */ \
+  2+IMM2_SIZE,                   /* exact                                  */ \
+  2, 2, 2, 2+IMM2_SIZE,          /* *+, ++, ?+, upto+                      */ \
+  2, 2, 2, 2, 2, 2,              /* *I, *?I, +I, +?I, ?I, ??I ** UTF-8     */ \
+  2+IMM2_SIZE, 2+IMM2_SIZE,      /* upto I, minupto I                      */ \
+  2+IMM2_SIZE,                   /* exact I                                */ \
+  2, 2, 2, 2+IMM2_SIZE,          /* *+I, ++I, ?+I, upto+I                  */ \
+  /* Negative single-char repeats - only for chars < 256                   */ \
+  2, 2, 2, 2, 2, 2,              /* NOT *, *?, +, +?, ?, ??                */ \
+  2+IMM2_SIZE, 2+IMM2_SIZE,      /* NOT upto, minupto                      */ \
+  2+IMM2_SIZE,                   /* NOT exact                              */ \
+  2, 2, 2, 2+IMM2_SIZE,          /* Possessive NOT *, +, ?, upto           */ \
+  2, 2, 2, 2, 2, 2,              /* NOT *I, *?I, +I, +?I, ?I, ??I          */ \
+  2+IMM2_SIZE, 2+IMM2_SIZE,      /* NOT upto I, minupto I                  */ \
+  2+IMM2_SIZE,                   /* NOT exact I                            */ \
+  2, 2, 2, 2+IMM2_SIZE,          /* Possessive NOT *I, +I, ?I, upto I      */ \
+  /* Positive type repeats                                                 */ \
+  2, 2, 2, 2, 2, 2,              /* Type *, *?, +, +?, ?, ??               */ \
+  2+IMM2_SIZE, 2+IMM2_SIZE,      /* Type upto, minupto                     */ \
+  2+IMM2_SIZE,                   /* Type exact                             */ \
+  2, 2, 2, 2+IMM2_SIZE,          /* Possessive *+, ++, ?+, upto+           */ \
+  /* Character class & ref repeats                                         */ \
+  1, 1, 1, 1, 1, 1,              /* *, *?, +, +?, ?, ??                    */ \
+  1+2*IMM2_SIZE, 1+2*IMM2_SIZE,  /* CRRANGE, CRMINRANGE                    */ \
+  1, 1, 1, 1+2*IMM2_SIZE,        /* Possessive *+, ++, ?+, CRPOSRANGE      */ \
+  1+(32/sizeof(pcre_uchar)),     /* CLASS                                  */ \
+  1+(32/sizeof(pcre_uchar)),     /* NCLASS                                 */ \
+  0,                             /* XCLASS - variable length               */ \
+  1+IMM2_SIZE,                   /* REF                                    */ \
+  1+IMM2_SIZE,                   /* REFI                                   */ \
+  1+2*IMM2_SIZE,                 /* DNREF                                  */ \
+  1+2*IMM2_SIZE,                 /* DNREFI                                 */ \
+  1+LINK_SIZE,                   /* RECURSE                                */ \
+  2+2*LINK_SIZE,                 /* CALLOUT                                */ \
+  1+LINK_SIZE,                   /* Alt                                    */ \
+  1+LINK_SIZE,                   /* Ket                                    */ \
+  1+LINK_SIZE,                   /* KetRmax                                */ \
+  1+LINK_SIZE,                   /* KetRmin                                */ \
+  1+LINK_SIZE,                   /* KetRpos                                */ \
+  1+LINK_SIZE,                   /* Reverse                                */ \
+  1+LINK_SIZE,                   /* Assert                                 */ \
+  1+LINK_SIZE,                   /* Assert not                             */ \
+  1+LINK_SIZE,                   /* Assert behind                          */ \
+  1+LINK_SIZE,                   /* Assert behind not                      */ \
+  1+LINK_SIZE,                   /* ONCE                                   */ \
+  1+LINK_SIZE,                   /* ONCE_NC                                */ \
+  1+LINK_SIZE,                   /* BRA                                    */ \
+  1+LINK_SIZE,                   /* BRAPOS                                 */ \
+  1+LINK_SIZE+IMM2_SIZE,         /* CBRA                                   */ \
+  1+LINK_SIZE+IMM2_SIZE,         /* CBRAPOS                                */ \
+  1+LINK_SIZE,                   /* COND                                   */ \
+  1+LINK_SIZE,                   /* SBRA                                   */ \
+  1+LINK_SIZE,                   /* SBRAPOS                                */ \
+  1+LINK_SIZE+IMM2_SIZE,         /* SCBRA                                  */ \
+  1+LINK_SIZE+IMM2_SIZE,         /* SCBRAPOS                               */ \
+  1+LINK_SIZE,                   /* SCOND                                  */ \
+  1+IMM2_SIZE, 1+2*IMM2_SIZE,    /* CREF, DNCREF                           */ \
+  1+IMM2_SIZE, 1+2*IMM2_SIZE,    /* RREF, DNRREF                           */ \
+  1,                             /* DEF                                    */ \
+  1, 1, 1,                       /* BRAZERO, BRAMINZERO, BRAPOSZERO        */ \
+  3, 1, 3,                       /* MARK, PRUNE, PRUNE_ARG                 */ \
+  1, 3,                          /* SKIP, SKIP_ARG                         */ \
+  1, 3,                          /* THEN, THEN_ARG                         */ \
+  1, 1, 1, 1,                    /* COMMIT, FAIL, ACCEPT, ASSERT_ACCEPT    */ \
+  1+IMM2_SIZE, 1                 /* CLOSE, SKIPZERO                        */
+
+/* A magic value for OP_RREF to indicate the "any recursion" condition. */
+
+#define RREF_ANY  0xffff
+
+/* Compile time error code numbers. They are given names so that they can more
+easily be tracked. When a new number is added, the table called eint in
+pcreposix.c must be updated. */
+
+enum { ERR0,  ERR1,  ERR2,  ERR3,  ERR4,  ERR5,  ERR6,  ERR7,  ERR8,  ERR9,
+       ERR10, ERR11, ERR12, ERR13, ERR14, ERR15, ERR16, ERR17, ERR18, ERR19,
+       ERR20, ERR21, ERR22, ERR23, ERR24, ERR25, ERR26, ERR27, ERR28, ERR29,
+       ERR30, ERR31, ERR32, ERR33, ERR34, ERR35, ERR36, ERR37, ERR38, ERR39,
+       ERR40, ERR41, ERR42, ERR43, ERR44, ERR45, ERR46, ERR47, ERR48, ERR49,
+       ERR50, ERR51, ERR52, ERR53, ERR54, ERR55, ERR56, ERR57, ERR58, ERR59,
+       ERR60, ERR61, ERR62, ERR63, ERR64, ERR65, ERR66, ERR67, ERR68, ERR69,
+       ERR70, ERR71, ERR72, ERR73, ERR74, ERR75, ERR76, ERR77, ERR78, ERR79,
+       ERR80, ERR81, ERR82, ERR83, ERR84, ERR85, ERR86, ERR87, ERRCOUNT };
+
+/* JIT compiling modes. The function list is indexed by them. */
+
+enum { JIT_COMPILE, JIT_PARTIAL_SOFT_COMPILE, JIT_PARTIAL_HARD_COMPILE,
+       JIT_NUMBER_OF_COMPILE_MODES };
+
+/* The real format of the start of the pcre block; the index of names and the
+code vector run on as long as necessary after the end. We store an explicit
+offset to the name table so that if a regex is compiled on one host, saved, and
+then run on another where the size of pointers is different, all might still
+be well.
+
+The size of the structure must be a multiple of 8 bytes. For the case of
+compiled-on-4 and run-on-8, we include an extra pointer that is always NULL so
+that there are an even number of pointers which therefore are a multiple of 8
+bytes.
+
+It is necessary to fork the struct for the 32 bit library, since it needs to
+use pcre_uint32 for first_char and req_char. We can't put an ifdef inside the
+typedef because pcretest needs access to the struct of the 8-, 16- and 32-bit
+variants.
+
+*** WARNING ***
+When new fields are added to these structures, remember to adjust the code in
+pcre_byte_order.c that is concerned with swapping the byte order of the fields
+when a compiled regex is reloaded on a host with different endianness.
+*** WARNING ***
+There is also similar byte-flipping code in pcretest.c, which is used for
+testing the byte-flipping features. It must also be kept in step.
+*** WARNING ***
+*/
+
+typedef struct real_pcre8_or_16 {
+  pcre_uint32 magic_number;
+  pcre_uint32 size;               /* Total that was malloced */
+  pcre_uint32 options;            /* Public options */
+  pcre_uint32 flags;              /* Private flags */
+  pcre_uint32 limit_match;        /* Limit set from regex */
+  pcre_uint32 limit_recursion;    /* Limit set from regex */
+  pcre_uint16 first_char;         /* Starting character */
+  pcre_uint16 req_char;           /* This character must be seen */
+  pcre_uint16 max_lookbehind;     /* Longest lookbehind (characters) */
+  pcre_uint16 top_bracket;        /* Highest numbered group */
+  pcre_uint16 top_backref;        /* Highest numbered back reference */
+  pcre_uint16 name_table_offset;  /* Offset to name table that follows */
+  pcre_uint16 name_entry_size;    /* Size of any name items */
+  pcre_uint16 name_count;         /* Number of name items */
+  pcre_uint16 ref_count;          /* Reference count */
+  pcre_uint16 dummy1;             /* To ensure size is a multiple of 8 */
+  pcre_uint16 dummy2;             /* To ensure size is a multiple of 8 */
+  pcre_uint16 dummy3;             /* To ensure size is a multiple of 8 */
+  const pcre_uint8 *tables;       /* Pointer to tables or NULL for std */
+  void             *nullpad;      /* NULL padding */
+} real_pcre8_or_16;
+
+typedef struct real_pcre8_or_16 real_pcre;
+typedef struct real_pcre8_or_16 real_pcre16;
+
+typedef struct real_pcre32 {
+  pcre_uint32 magic_number;
+  pcre_uint32 size;               /* Total that was malloced */
+  pcre_uint32 options;            /* Public options */
+  pcre_uint32 flags;              /* Private flags */
+  pcre_uint32 limit_match;        /* Limit set from regex */
+  pcre_uint32 limit_recursion;    /* Limit set from regex */
+  pcre_uint32 first_char;         /* Starting character */
+  pcre_uint32 req_char;           /* This character must be seen */
+  pcre_uint16 max_lookbehind;     /* Longest lookbehind (characters) */
+  pcre_uint16 top_bracket;        /* Highest numbered group */
+  pcre_uint16 top_backref;        /* Highest numbered back reference */
+  pcre_uint16 name_table_offset;  /* Offset to name table that follows */
+  pcre_uint16 name_entry_size;    /* Size of any name items */
+  pcre_uint16 name_count;         /* Number of name items */
+  pcre_uint16 ref_count;          /* Reference count */
+  pcre_uint16 dummy;              /* To ensure size is a multiple of 8 */
+  const pcre_uint8 *tables;       /* Pointer to tables or NULL for std */
+  void             *nullpad;      /* NULL padding */
+} real_pcre32;
+
+#if defined COMPILE_PCRE8
+#define REAL_PCRE real_pcre
+#elif defined COMPILE_PCRE16
+#define REAL_PCRE real_pcre16
+#elif defined COMPILE_PCRE32
+#define REAL_PCRE real_pcre32
+#endif
+
+/* Assert that the size of REAL_PCRE is divisible by 8 */
+typedef int __assert_real_pcre_size_divisible_8[(sizeof(REAL_PCRE) % 8) == 0 ? 1 : -1];
+
+/* Needed in pcretest to access some fields in the real_pcre* structures
+ * directly. They're unified for 8/16/32 bits since the structs only differ
+ * after these fields; if that ever changes, need to fork those defines into
+ * 8/16 and 32 bit versions. */
+#define REAL_PCRE_MAGIC(re)     (((REAL_PCRE*)re)->magic_number)
+#define REAL_PCRE_SIZE(re)      (((REAL_PCRE*)re)->size)
+#define REAL_PCRE_OPTIONS(re)   (((REAL_PCRE*)re)->options)
+#define REAL_PCRE_FLAGS(re)     (((REAL_PCRE*)re)->flags)
+
+/* The format of the block used to store data from pcre_study(). The same
+remark (see NOTE above) about extending this structure applies. */
+
+typedef struct pcre_study_data {
+  pcre_uint32 size;               /* Total that was malloced */
+  pcre_uint32 flags;              /* Private flags */
+  pcre_uint8 start_bits[32];      /* Starting char bits */
+  pcre_uint32 minlength;          /* Minimum subject length */
+} pcre_study_data;
+
+/* Structure for building a chain of open capturing subpatterns during
+compiling, so that instructions to close them can be compiled when (*ACCEPT) is
+encountered. This is also used to identify subpatterns that contain recursive
+back references to themselves, so that they can be made atomic. */
+
+typedef struct open_capitem {
+  struct open_capitem *next;    /* Chain link */
+  pcre_uint16 number;           /* Capture number */
+  pcre_uint16 flag;             /* Set TRUE if recursive back ref */
+} open_capitem;
+
+/* Structure for building a list of named groups during the first pass of
+compiling. */
+
+typedef struct named_group {
+  const pcre_uchar  *name;          /* Points to the name in the pattern */
+  int                length;        /* Length of the name */
+  pcre_uint32        number;        /* Group number */
+} named_group;
+
+/* Structure for passing "static" information around between the functions
+doing the compiling, so that they are thread-safe. */
+
+typedef struct compile_data {
+  const pcre_uint8 *lcc;            /* Points to lower casing table */
+  const pcre_uint8 *fcc;            /* Points to case-flipping table */
+  const pcre_uint8 *cbits;          /* Points to character type table */
+  const pcre_uint8 *ctypes;         /* Points to table of type maps */
+  const pcre_uchar *start_workspace;/* The start of working space */
+  const pcre_uchar *start_code;     /* The start of the compiled code */
+  const pcre_uchar *start_pattern;  /* The start of the pattern */
+  const pcre_uchar *end_pattern;    /* The end of the pattern */
+  pcre_uchar *hwm;                  /* High watermark of workspace */
+  open_capitem *open_caps;          /* Chain of open capture items */
+  named_group *named_groups;        /* Points to vector in pre-compile */
+  pcre_uchar *name_table;           /* The name/number table */
+  int  names_found;                 /* Number of entries so far */
+  int  name_entry_size;             /* Size of each entry */
+  int  named_group_list_size;       /* Number of entries in the list */
+  int  workspace_size;              /* Size of workspace */
+  unsigned int bracount;            /* Count of capturing parens as we compile */
+  int  final_bracount;              /* Saved value after first pass */
+  int  max_lookbehind;              /* Maximum lookbehind (characters) */
+  int  top_backref;                 /* Maximum back reference */
+  unsigned int backref_map;         /* Bitmap of low back refs */
+  unsigned int namedrefcount;       /* Number of backreferences by name */
+  int  parens_depth;                /* Depth of nested parentheses */
+  int  assert_depth;                /* Depth of nested assertions */
+  pcre_uint32 external_options;     /* External (initial) options */
+  pcre_uint32 external_flags;       /* External flag bits to be set */
+  int  req_varyopt;                 /* "After variable item" flag for reqbyte */
+  BOOL had_accept;                  /* (*ACCEPT) encountered */
+  BOOL had_pruneorskip;             /* (*PRUNE) or (*SKIP) encountered */
+  BOOL check_lookbehind;            /* Lookbehinds need later checking */
+  BOOL dupnames;                    /* Duplicate names exist */
+  BOOL dupgroups;                   /* Duplicate groups exist: (?| found */
+  BOOL iscondassert;                /* Next assert is a condition */
+  int  nltype;                      /* Newline type */
+  int  nllen;                       /* Newline string length */
+  pcre_uchar nl[4];                 /* Newline string when fixed length */
+} compile_data;
+
+/* Structure for maintaining a chain of pointers to the currently incomplete
+branches, for testing for left recursion while compiling. */
+
+typedef struct branch_chain {
+  struct branch_chain *outer;
+  pcre_uchar *current_branch;
+} branch_chain;
+
+/* Structure for mutual recursion detection. */
+
+typedef struct recurse_check {
+  struct recurse_check *prev;
+  const pcre_uchar *group;
+} recurse_check;
+
+/* Structure for items in a linked list that represents an explicit recursive
+call within the pattern; used by pcre_exec(). */
+
+typedef struct recursion_info {
+  struct recursion_info *prevrec; /* Previous recursion record (or NULL) */
+  unsigned int group_num;         /* Number of group that was called */
+  int *offset_save;               /* Pointer to start of saved offsets */
+  int saved_max;                  /* Number of saved offsets */
+  int saved_capture_last;         /* Last capture number */
+  PCRE_PUCHAR subject_position;   /* Position at start of recursion */
+} recursion_info;
+
+/* A similar structure for pcre_dfa_exec(). */
+
+typedef struct dfa_recursion_info {
+  struct dfa_recursion_info *prevrec;
+  int group_num;
+  PCRE_PUCHAR subject_position;
+} dfa_recursion_info;
+
+/* Structure for building a chain of data for holding the values of the subject
+pointer at the start of each subpattern, so as to detect when an empty string
+has been matched by a subpattern - to break infinite loops; used by
+pcre_exec(). */
+
+typedef struct eptrblock {
+  struct eptrblock *epb_prev;
+  PCRE_PUCHAR epb_saved_eptr;
+} eptrblock;
+
+
+/* Structure for passing "static" information around between the functions
+doing traditional NFA matching, so that they are thread-safe. */
+
+typedef struct match_data {
+  unsigned long int match_call_count;      /* As it says */
+  unsigned long int match_limit;           /* As it says */
+  unsigned long int match_limit_recursion; /* As it says */
+  int   *offset_vector;           /* Offset vector */
+  int    offset_end;              /* One past the end */
+  int    offset_max;              /* The maximum usable for return data */
+  int    nltype;                  /* Newline type */
+  int    nllen;                   /* Newline string length */
+  int    name_count;              /* Number of names in name table */
+  int    name_entry_size;         /* Size of entry in names table */
+  unsigned int skip_arg_count;    /* For counting SKIP_ARGs */
+  unsigned int ignore_skip_arg;   /* For re-run when SKIP arg name not found */
+  pcre_uchar *name_table;         /* Table of names */
+  pcre_uchar nl[4];               /* Newline string when fixed */
+  const  pcre_uint8 *lcc;         /* Points to lower casing table */
+  const  pcre_uint8 *fcc;         /* Points to case-flipping table */
+  const  pcre_uint8 *ctypes;      /* Points to table of type maps */
+  BOOL   notbol;                  /* NOTBOL flag */
+  BOOL   noteol;                  /* NOTEOL flag */
+  BOOL   utf;                     /* UTF-8 / UTF-16 flag */
+  BOOL   jscript_compat;          /* JAVASCRIPT_COMPAT flag */
+  BOOL   use_ucp;                 /* PCRE_UCP flag */
+  BOOL   endonly;                 /* Dollar not before final \n */
+  BOOL   notempty;                /* Empty string match not wanted */
+  BOOL   notempty_atstart;        /* Empty string match at start not wanted */
+  BOOL   hitend;                  /* Hit the end of the subject at some point */
+  BOOL   bsr_anycrlf;             /* \R is just any CRLF, not full Unicode */
+  BOOL   hasthen;                 /* Pattern contains (*THEN) */
+  const  pcre_uchar *start_code;  /* For use when recursing */
+  PCRE_PUCHAR start_subject;      /* Start of the subject string */
+  PCRE_PUCHAR end_subject;        /* End of the subject string */
+  PCRE_PUCHAR start_match_ptr;    /* Start of matched string */
+  PCRE_PUCHAR end_match_ptr;      /* Subject position at end match */
+  PCRE_PUCHAR start_used_ptr;     /* Earliest consulted character */
+  int    partial;                 /* PARTIAL options */
+  int    end_offset_top;          /* Highwater mark at end of match */
+  pcre_int32 capture_last;        /* Most recent capture number + overflow flag */
+  int    start_offset;            /* The start offset value */
+  int    match_function_type;     /* Set for certain special calls of MATCH() */
+  eptrblock *eptrchain;           /* Chain of eptrblocks for tail recursions */
+  int    eptrn;                   /* Next free eptrblock */
+  recursion_info *recursive;      /* Linked list of recursion data */
+  void  *callout_data;            /* To pass back to callouts */
+  const  pcre_uchar *mark;        /* Mark pointer to pass back on success */
+  const  pcre_uchar *nomatch_mark;/* Mark pointer to pass back on failure */
+  const  pcre_uchar *once_target; /* Where to back up to for atomic groups */
+#ifdef NO_RECURSE
+  void  *match_frames_base;       /* For remembering malloc'd frames */
+#endif
+} match_data;
+
+/* A similar structure is used for the same purpose by the DFA matching
+functions. */
+
+typedef struct dfa_match_data {
+  const pcre_uchar *start_code;     /* Start of the compiled pattern */
+  const pcre_uchar *start_subject ; /* Start of the subject string */
+  const pcre_uchar *end_subject;    /* End of subject string */
+  const pcre_uchar *start_used_ptr; /* Earliest consulted character */
+  const pcre_uint8 *tables;         /* Character tables */
+  int   start_offset;               /* The start offset value */
+  int   moptions;                   /* Match options */
+  int   poptions;                   /* Pattern options */
+  int   nltype;                     /* Newline type */
+  int   nllen;                      /* Newline string length */
+  pcre_uchar nl[4];                 /* Newline string when fixed */
+  void *callout_data;               /* To pass back to callouts */
+  dfa_recursion_info *recursive;    /* Linked list of recursion data */
+} dfa_match_data;
+
+/* Bit definitions for entries in the pcre_ctypes table. */
+
+#define ctype_space   0x01
+#define ctype_letter  0x02
+#define ctype_digit   0x04
+#define ctype_xdigit  0x08
+#define ctype_word    0x10   /* alphanumeric or '_' */
+#define ctype_meta    0x80   /* regexp meta char or zero (end pattern) */
+
+/* Offsets for the bitmap tables in pcre_cbits. Each table contains a set
+of bits for a class map. Some classes are built by combining these tables. */
+
+#define cbit_space     0      /* [:space:] or \s */
+#define cbit_xdigit   32      /* [:xdigit:] */
+#define cbit_digit    64      /* [:digit:] or \d */
+#define cbit_upper    96      /* [:upper:] */
+#define cbit_lower   128      /* [:lower:] */
+#define cbit_word    160      /* [:word:] or \w */
+#define cbit_graph   192      /* [:graph:] */
+#define cbit_print   224      /* [:print:] */
+#define cbit_punct   256      /* [:punct:] */
+#define cbit_cntrl   288      /* [:cntrl:] */
+#define cbit_length  320      /* Length of the cbits table */
+
+/* Offsets of the various tables from the base tables pointer, and
+total length. */
+
+#define lcc_offset      0
+#define fcc_offset    256
+#define cbits_offset  512
+#define ctypes_offset (cbits_offset + cbit_length)
+#define tables_length (ctypes_offset + 256)
+
+/* Internal function and data prefixes. */
+
+#if defined COMPILE_PCRE8
+#ifndef PUBL
+#define PUBL(name) pcre_##name
+#endif
+#ifndef PRIV
+#define PRIV(name) _pcre_##name
+#endif
+#elif defined COMPILE_PCRE16
+#ifndef PUBL
+#define PUBL(name) pcre16_##name
+#endif
+#ifndef PRIV
+#define PRIV(name) _pcre16_##name
+#endif
+#elif defined COMPILE_PCRE32
+#ifndef PUBL
+#define PUBL(name) pcre32_##name
+#endif
+#ifndef PRIV
+#define PRIV(name) _pcre32_##name
+#endif
+#else
+#error Unsupported compiling mode
+#endif /* COMPILE_PCRE[8|16|32] */
+
+/* Layout of the UCP type table that translates property names into types and
+codes. Each entry used to point directly to a name, but to reduce the number of
+relocations in shared libraries, it now has an offset into a single string
+instead. */
+
+typedef struct {
+  pcre_uint16 name_offset;
+  pcre_uint16 type;
+  pcre_uint16 value;
+} ucp_type_table;
+
+
+/* Internal shared data tables. These are tables that are used by more than one
+of the exported public functions. They have to be "external" in the C sense,
+but are not part of the PCRE public API. The data for these tables is in the
+pcre_tables.c module. */
+
+#ifdef COMPILE_PCRE8
+extern const int            PRIV(utf8_table1)[];
+extern const int            PRIV(utf8_table1_size);
+extern const int            PRIV(utf8_table2)[];
+extern const int            PRIV(utf8_table3)[];
+extern const pcre_uint8     PRIV(utf8_table4)[];
+#endif /* COMPILE_PCRE8 */
+
+extern const char           PRIV(utt_names)[];
+extern const ucp_type_table PRIV(utt)[];
+extern const int            PRIV(utt_size);
+
+extern const pcre_uint8     PRIV(OP_lengths)[];
+extern const pcre_uint8     PRIV(default_tables)[];
+
+extern const pcre_uint32    PRIV(hspace_list)[];
+extern const pcre_uint32    PRIV(vspace_list)[];
+
+
+/* Internal shared functions. These are functions that are used by more than
+one of the exported public functions. They have to be "external" in the C
+sense, but are not part of the PCRE public API. */
+
+/* String comparison functions. */
+#if defined COMPILE_PCRE8
+
+#define STRCMP_UC_UC(str1, str2) \
+  strcmp((char *)(str1), (char *)(str2))
+#define STRCMP_UC_C8(str1, str2) \
+  strcmp((char *)(str1), (str2))
+#define STRNCMP_UC_UC(str1, str2, num) \
+  strncmp((char *)(str1), (char *)(str2), (num))
+#define STRNCMP_UC_C8(str1, str2, num) \
+  strncmp((char *)(str1), (str2), (num))
+#define STRLEN_UC(str) strlen((const char *)str)
+
+#elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+
+extern int               PRIV(strcmp_uc_uc)(const pcre_uchar *,
+                           const pcre_uchar *);
+extern int               PRIV(strcmp_uc_c8)(const pcre_uchar *,
+                           const char *);
+extern int               PRIV(strncmp_uc_uc)(const pcre_uchar *,
+                           const pcre_uchar *, unsigned int num);
+extern int               PRIV(strncmp_uc_c8)(const pcre_uchar *,
+                           const char *, unsigned int num);
+extern unsigned int      PRIV(strlen_uc)(const pcre_uchar *str);
+
+#define STRCMP_UC_UC(str1, str2) \
+  PRIV(strcmp_uc_uc)((str1), (str2))
+#define STRCMP_UC_C8(str1, str2) \
+  PRIV(strcmp_uc_c8)((str1), (str2))
+#define STRNCMP_UC_UC(str1, str2, num) \
+  PRIV(strncmp_uc_uc)((str1), (str2), (num))
+#define STRNCMP_UC_C8(str1, str2, num) \
+  PRIV(strncmp_uc_c8)((str1), (str2), (num))
+#define STRLEN_UC(str) PRIV(strlen_uc)(str)
+
+#endif /* COMPILE_PCRE[8|16|32] */
+
+#if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
+
+#define STRCMP_UC_UC_TEST(str1, str2) STRCMP_UC_UC(str1, str2)
+#define STRCMP_UC_C8_TEST(str1, str2) STRCMP_UC_C8(str1, str2)
+
+#elif defined COMPILE_PCRE32
+
+extern int               PRIV(strcmp_uc_uc_utf)(const pcre_uchar *,
+                           const pcre_uchar *);
+extern int               PRIV(strcmp_uc_c8_utf)(const pcre_uchar *,
+                           const char *);
+
+#define STRCMP_UC_UC_TEST(str1, str2) \
+  (utf ? PRIV(strcmp_uc_uc_utf)((str1), (str2)) : PRIV(strcmp_uc_uc)((str1), (str2)))
+#define STRCMP_UC_C8_TEST(str1, str2) \
+  (utf ? PRIV(strcmp_uc_c8_utf)((str1), (str2)) : PRIV(strcmp_uc_c8)((str1), (str2)))
+
+#endif /* COMPILE_PCRE[8|16|32] */
+
+extern const pcre_uchar *PRIV(find_bracket)(const pcre_uchar *, BOOL, int);
+extern BOOL              PRIV(is_newline)(PCRE_PUCHAR, int, PCRE_PUCHAR,
+                           int *, BOOL);
+extern unsigned int      PRIV(ord2utf)(pcre_uint32, pcre_uchar *);
+extern int               PRIV(valid_utf)(PCRE_PUCHAR, int, int *);
+extern BOOL              PRIV(was_newline)(PCRE_PUCHAR, int, PCRE_PUCHAR,
+                           int *, BOOL);
+extern BOOL              PRIV(xclass)(pcre_uint32, const pcre_uchar *, BOOL);
+
+#ifdef SUPPORT_JIT
+extern void              PRIV(jit_compile)(const REAL_PCRE *,
+                           PUBL(extra) *, int);
+extern int               PRIV(jit_exec)(const PUBL(extra) *,
+                           const pcre_uchar *, int, int, int, int *, int);
+extern void              PRIV(jit_free)(void *);
+extern int               PRIV(jit_get_size)(void *);
+extern const char*       PRIV(jit_get_target)(void);
+#endif
+
+/* Unicode character database (UCD) */
+
+typedef struct {
+  pcre_uint8 script;     /* ucp_Arabic, etc. */
+  pcre_uint8 chartype;   /* ucp_Cc, etc. (general categories) */
+  pcre_uint8 gbprop;     /* ucp_gbControl, etc. (grapheme break property) */
+  pcre_uint8 caseset;    /* offset to multichar other cases or zero */
+  pcre_int32 other_case; /* offset to other case, or zero if none */
+} ucd_record;
+
+extern const pcre_uint32 PRIV(ucd_caseless_sets)[];
+extern const ucd_record  PRIV(ucd_records)[];
+extern const pcre_uint8  PRIV(ucd_stage1)[];
+extern const pcre_uint16 PRIV(ucd_stage2)[];
+extern const pcre_uint32 PRIV(ucp_gentype)[];
+extern const pcre_uint32 PRIV(ucp_gbtable)[];
+#ifdef COMPILE_PCRE32
+extern const ucd_record  PRIV(dummy_ucd_record)[];
+#endif
+#ifdef SUPPORT_JIT
+extern const int         PRIV(ucp_typerange)[];
+#endif
+
+#ifdef SUPPORT_UCP
+/* UCD access macros */
+
+#define UCD_BLOCK_SIZE 128
+#define REAL_GET_UCD(ch) (PRIV(ucd_records) + \
+        PRIV(ucd_stage2)[PRIV(ucd_stage1)[(int)(ch) / UCD_BLOCK_SIZE] * \
+        UCD_BLOCK_SIZE + (int)(ch) % UCD_BLOCK_SIZE])
+
+#ifdef COMPILE_PCRE32
+#define GET_UCD(ch) ((ch > 0x10ffff)? PRIV(dummy_ucd_record) : REAL_GET_UCD(ch))
+#else
+#define GET_UCD(ch) REAL_GET_UCD(ch)
+#endif
+
+#define UCD_CHARTYPE(ch)    GET_UCD(ch)->chartype
+#define UCD_SCRIPT(ch)      GET_UCD(ch)->script
+#define UCD_CATEGORY(ch)    PRIV(ucp_gentype)[UCD_CHARTYPE(ch)]
+#define UCD_GRAPHBREAK(ch)  GET_UCD(ch)->gbprop
+#define UCD_CASESET(ch)     GET_UCD(ch)->caseset
+#define UCD_OTHERCASE(ch)   ((pcre_uint32)((int)ch + (int)(GET_UCD(ch)->other_case)))
+
+#endif /* SUPPORT_UCP */
+
+#endif
+
+/* End of pcre_internal.h */
diff --git a/base/poco/Foundation/src/pcre_jit_compile.c b/base/poco/Foundation/src/pcre_jit_compile.c
new file mode 100644
index 00000000000..0f1ea580ade
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_jit_compile.c
@@ -0,0 +1,11912 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2013 University of Cambridge
+
+  The machine code generator part (this module) was written by Zoltan Herczeg
+                      Copyright (c) 2010-2013
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+#include "pcre_config.h"
+
+
+#include "pcre_internal.h"
+
+#if defined SUPPORT_JIT
+
+/* All-in-one: Since we use the JIT compiler only from here,
+we just include it. This way we don't need to touch the build
+system files. */
+
+#define SLJIT_MALLOC(size, allocator_data) (PUBL(malloc))(size)
+#define SLJIT_FREE(ptr, allocator_data) (PUBL(free))(ptr)
+#define SLJIT_CONFIG_AUTO 1
+#define SLJIT_CONFIG_STATIC 1
+#define SLJIT_VERBOSE 0
+#define SLJIT_DEBUG 0
+
+#include "sljit/sljitLir.c"
+
+#if defined SLJIT_CONFIG_UNSUPPORTED && SLJIT_CONFIG_UNSUPPORTED
+#error Unsupported architecture
+#endif
+
+/* Defines for debugging purposes. */
+
+/* 1 - Use unoptimized capturing brackets.
+   2 - Enable capture_last_ptr (includes option 1). */
+/* #define DEBUG_FORCE_UNOPTIMIZED_CBRAS 2 */
+
+/* 1 - Always have a control head. */
+/* #define DEBUG_FORCE_CONTROL_HEAD 1 */
+
+/* Allocate memory for the regex stack on the real machine stack.
+Fast, but limited size. */
+#define MACHINE_STACK_SIZE 32768
+
+/* Growth rate for stack allocated by the OS. Should be the multiply
+of page size. */
+#define STACK_GROWTH_RATE 8192
+
+/* Enable to check that the allocation could destroy temporaries. */
+#if defined SLJIT_DEBUG && SLJIT_DEBUG
+#define DESTROY_REGISTERS 1
+#endif
+
+/*
+Short summary about the backtracking mechanism empolyed by the jit code generator:
+
+The code generator follows the recursive nature of the PERL compatible regular
+expressions. The basic blocks of regular expressions are condition checkers
+whose execute different commands depending on the result of the condition check.
+The relationship between the operators can be horizontal (concatenation) and
+vertical (sub-expression) (See struct backtrack_common for more details).
+
+  'ab' - 'a' and 'b' regexps are concatenated
+  'a+' - 'a' is the sub-expression of the '+' operator
+
+The condition checkers are boolean (true/false) checkers. Machine code is generated
+for the checker itself and for the actions depending on the result of the checker.
+The 'true' case is called as the matching path (expected path), and the other is called as
+the 'backtrack' path. Branch instructions are expesive for all CPUs, so we avoid taken
+branches on the matching path.
+
+ Greedy star operator (*) :
+   Matching path: match happens.
+   Backtrack path: match failed.
+ Non-greedy star operator (*?) :
+   Matching path: no need to perform a match.
+   Backtrack path: match is required.
+
+The following example shows how the code generated for a capturing bracket
+with two alternatives. Let A, B, C, D are arbirary regular expressions, and
+we have the following regular expression:
+
+   A(B|C)D
+
+The generated code will be the following:
+
+ A matching path
+ '(' matching path (pushing arguments to the stack)
+ B matching path
+ ')' matching path (pushing arguments to the stack)
+ D matching path
+ return with successful match
+
+ D backtrack path
+ ')' backtrack path (If we arrived from "C" jump to the backtrack of "C")
+ B backtrack path
+ C expected path
+ jump to D matching path
+ C backtrack path
+ A backtrack path
+
+ Notice, that the order of backtrack code paths are the opposite of the fast
+ code paths. In this way the topmost value on the stack is always belong
+ to the current backtrack code path. The backtrack path must check
+ whether there is a next alternative. If so, it needs to jump back to
+ the matching path eventually. Otherwise it needs to clear out its own stack
+ frame and continue the execution on the backtrack code paths.
+*/
+
+/*
+Saved stack frames:
+
+Atomic blocks and asserts require reloading the values of private data
+when the backtrack mechanism performed. Because of OP_RECURSE, the data
+are not necessarly known in compile time, thus we need a dynamic restore
+mechanism.
+
+The stack frames are stored in a chain list, and have the following format:
+([ capturing bracket offset ][ start value ][ end value ])+ ... [ 0 ] [ previous head ]
+
+Thus we can restore the private data to a particular point in the stack.
+*/
+
+typedef struct jit_arguments {
+  /* Pointers first. */
+  struct sljit_stack *stack;
+  const pcre_uchar *str;
+  const pcre_uchar *begin;
+  const pcre_uchar *end;
+  int *offsets;
+  pcre_uchar *mark_ptr;
+  void *callout_data;
+  /* Everything else after. */
+  sljit_u32 limit_match;
+  int real_offset_count;
+  int offset_count;
+  sljit_u8 notbol;
+  sljit_u8 noteol;
+  sljit_u8 notempty;
+  sljit_u8 notempty_atstart;
+} jit_arguments;
+
+typedef struct executable_functions {
+  void *executable_funcs[JIT_NUMBER_OF_COMPILE_MODES];
+  void *read_only_data_heads[JIT_NUMBER_OF_COMPILE_MODES];
+  sljit_uw executable_sizes[JIT_NUMBER_OF_COMPILE_MODES];
+  PUBL(jit_callback) callback;
+  void *userdata;
+  sljit_u32 top_bracket;
+  sljit_u32 limit_match;
+} executable_functions;
+
+typedef struct jump_list {
+  struct sljit_jump *jump;
+  struct jump_list *next;
+} jump_list;
+
+typedef struct stub_list {
+  struct sljit_jump *start;
+  struct sljit_label *quit;
+  struct stub_list *next;
+} stub_list;
+
+typedef struct label_addr_list {
+  struct sljit_label *label;
+  sljit_uw *update_addr;
+  struct label_addr_list *next;
+} label_addr_list;
+
+enum frame_types {
+  no_frame = -1,
+  no_stack = -2
+};
+
+enum control_types {
+  type_mark = 0,
+  type_then_trap = 1
+};
+
+typedef int (SLJIT_FUNC *jit_function)(jit_arguments *args);
+
+/* The following structure is the key data type for the recursive
+code generator. It is allocated by compile_matchingpath, and contains
+the arguments for compile_backtrackingpath. Must be the first member
+of its descendants. */
+typedef struct backtrack_common {
+  /* Concatenation stack. */
+  struct backtrack_common *prev;
+  jump_list *nextbacktracks;
+  /* Internal stack (for component operators). */
+  struct backtrack_common *top;
+  jump_list *topbacktracks;
+  /* Opcode pointer. */
+  pcre_uchar *cc;
+} backtrack_common;
+
+typedef struct assert_backtrack {
+  backtrack_common common;
+  jump_list *condfailed;
+  /* Less than 0 if a frame is not needed. */
+  int framesize;
+  /* Points to our private memory word on the stack. */
+  int private_data_ptr;
+  /* For iterators. */
+  struct sljit_label *matchingpath;
+} assert_backtrack;
+
+typedef struct bracket_backtrack {
+  backtrack_common common;
+  /* Where to coninue if an alternative is successfully matched. */
+  struct sljit_label *alternative_matchingpath;
+  /* For rmin and rmax iterators. */
+  struct sljit_label *recursive_matchingpath;
+  /* For greedy ? operator. */
+  struct sljit_label *zero_matchingpath;
+  /* Contains the branches of a failed condition. */
+  union {
+    /* Both for OP_COND, OP_SCOND. */
+    jump_list *condfailed;
+    assert_backtrack *assert;
+    /* For OP_ONCE. Less than 0 if not needed. */
+    int framesize;
+  } u;
+  /* Points to our private memory word on the stack. */
+  int private_data_ptr;
+} bracket_backtrack;
+
+typedef struct bracketpos_backtrack {
+  backtrack_common common;
+  /* Points to our private memory word on the stack. */
+  int private_data_ptr;
+  /* Reverting stack is needed. */
+  int framesize;
+  /* Allocated stack size. */
+  int stacksize;
+} bracketpos_backtrack;
+
+typedef struct braminzero_backtrack {
+  backtrack_common common;
+  struct sljit_label *matchingpath;
+} braminzero_backtrack;
+
+typedef struct char_iterator_backtrack {
+  backtrack_common common;
+  /* Next iteration. */
+  struct sljit_label *matchingpath;
+  union {
+    jump_list *backtracks;
+    struct {
+      unsigned int othercasebit;
+      pcre_uchar chr;
+      BOOL enabled;
+    } charpos;
+  } u;
+} char_iterator_backtrack;
+
+typedef struct ref_iterator_backtrack {
+  backtrack_common common;
+  /* Next iteration. */
+  struct sljit_label *matchingpath;
+} ref_iterator_backtrack;
+
+typedef struct recurse_entry {
+  struct recurse_entry *next;
+  /* Contains the function entry. */
+  struct sljit_label *entry;
+  /* Collects the calls until the function is not created. */
+  jump_list *calls;
+  /* Points to the starting opcode. */
+  sljit_sw start;
+} recurse_entry;
+
+typedef struct recurse_backtrack {
+  backtrack_common common;
+  BOOL inlined_pattern;
+} recurse_backtrack;
+
+#define OP_THEN_TRAP OP_TABLE_LENGTH
+
+typedef struct then_trap_backtrack {
+  backtrack_common common;
+  /* If then_trap is not NULL, this structure contains the real
+  then_trap for the backtracking path. */
+  struct then_trap_backtrack *then_trap;
+  /* Points to the starting opcode. */
+  sljit_sw start;
+  /* Exit point for the then opcodes of this alternative. */
+  jump_list *quit;
+  /* Frame size of the current alternative. */
+  int framesize;
+} then_trap_backtrack;
+
+#define MAX_RANGE_SIZE 4
+
+typedef struct compiler_common {
+  /* The sljit ceneric compiler. */
+  struct sljit_compiler *compiler;
+  /* First byte code. */
+  pcre_uchar *start;
+  /* Maps private data offset to each opcode. */
+  sljit_s32 *private_data_ptrs;
+  /* Chain list of read-only data ptrs. */
+  void *read_only_data_head;
+  /* Tells whether the capturing bracket is optimized. */
+  sljit_u8 *optimized_cbracket;
+  /* Tells whether the starting offset is a target of then. */
+  sljit_u8 *then_offsets;
+  /* Current position where a THEN must jump. */
+  then_trap_backtrack *then_trap;
+  /* Starting offset of private data for capturing brackets. */
+  sljit_s32 cbra_ptr;
+  /* Output vector starting point. Must be divisible by 2. */
+  sljit_s32 ovector_start;
+  /* Points to the starting character of the current match. */
+  sljit_s32 start_ptr;
+  /* Last known position of the requested byte. */
+  sljit_s32 req_char_ptr;
+  /* Head of the last recursion. */
+  sljit_s32 recursive_head_ptr;
+  /* First inspected character for partial matching.
+     (Needed for avoiding zero length partial matches.) */
+  sljit_s32 start_used_ptr;
+  /* Starting pointer for partial soft matches. */
+  sljit_s32 hit_start;
+  /* Pointer of the match end position. */
+  sljit_s32 match_end_ptr;
+  /* Points to the marked string. */
+  sljit_s32 mark_ptr;
+  /* Recursive control verb management chain. */
+  sljit_s32 control_head_ptr;
+  /* Points to the last matched capture block index. */
+  sljit_s32 capture_last_ptr;
+  /* Fast forward skipping byte code pointer. */
+  pcre_uchar *fast_forward_bc_ptr;
+  /* Locals used by fast fail optimization. */
+  sljit_s32 fast_fail_start_ptr;
+  sljit_s32 fast_fail_end_ptr;
+
+  /* Flipped and lower case tables. */
+  const sljit_u8 *fcc;
+  sljit_sw lcc;
+  /* Mode can be PCRE_STUDY_JIT_COMPILE and others. */
+  int mode;
+  /* TRUE, when minlength is greater than 0. */
+  BOOL might_be_empty;
+  /* \K is found in the pattern. */
+  BOOL has_set_som;
+  /* (*SKIP:arg) is found in the pattern. */
+  BOOL has_skip_arg;
+  /* (*THEN) is found in the pattern. */
+  BOOL has_then;
+  /* (*SKIP) or (*SKIP:arg) is found in lookbehind assertion. */
+  BOOL has_skip_in_assert_back;
+  /* Currently in recurse or negative assert. */
+  BOOL local_exit;
+  /* Currently in a positive assert. */
+  BOOL positive_assert;
+  /* Newline control. */
+  int nltype;
+  sljit_u32 nlmax;
+  sljit_u32 nlmin;
+  int newline;
+  int bsr_nltype;
+  sljit_u32 bsr_nlmax;
+  sljit_u32 bsr_nlmin;
+  /* Dollar endonly. */
+  int endonly;
+  /* Tables. */
+  sljit_sw ctypes;
+  /* Named capturing brackets. */
+  pcre_uchar *name_table;
+  sljit_sw name_count;
+  sljit_sw name_entry_size;
+
+  /* Labels and jump lists. */
+  struct sljit_label *partialmatchlabel;
+  struct sljit_label *quit_label;
+  struct sljit_label *forced_quit_label;
+  struct sljit_label *accept_label;
+  struct sljit_label *ff_newline_shortcut;
+  stub_list *stubs;
+  label_addr_list *label_addrs;
+  recurse_entry *entries;
+  recurse_entry *currententry;
+  jump_list *partialmatch;
+  jump_list *quit;
+  jump_list *positive_assert_quit;
+  jump_list *forced_quit;
+  jump_list *accept;
+  jump_list *calllimit;
+  jump_list *stackalloc;
+  jump_list *revertframes;
+  jump_list *wordboundary;
+  jump_list *anynewline;
+  jump_list *hspace;
+  jump_list *vspace;
+  jump_list *casefulcmp;
+  jump_list *caselesscmp;
+  jump_list *reset_match;
+  BOOL jscript_compat;
+#ifdef SUPPORT_UTF
+  BOOL utf;
+#ifdef SUPPORT_UCP
+  BOOL use_ucp;
+  jump_list *getucd;
+#endif
+#ifdef COMPILE_PCRE8
+  jump_list *utfreadchar;
+  jump_list *utfreadchar16;
+  jump_list *utfreadtype8;
+#endif
+#endif /* SUPPORT_UTF */
+} compiler_common;
+
+/* For byte_sequence_compare. */
+
+typedef struct compare_context {
+  int length;
+  int sourcereg;
+#if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
+  int ucharptr;
+  union {
+    sljit_s32 asint;
+    sljit_u16 asushort;
+#if defined COMPILE_PCRE8
+    sljit_u8 asbyte;
+    sljit_u8 asuchars[4];
+#elif defined COMPILE_PCRE16
+    sljit_u16 asuchars[2];
+#elif defined COMPILE_PCRE32
+    sljit_u32 asuchars[1];
+#endif
+  } c;
+  union {
+    sljit_s32 asint;
+    sljit_u16 asushort;
+#if defined COMPILE_PCRE8
+    sljit_u8 asbyte;
+    sljit_u8 asuchars[4];
+#elif defined COMPILE_PCRE16
+    sljit_u16 asuchars[2];
+#elif defined COMPILE_PCRE32
+    sljit_u32 asuchars[1];
+#endif
+  } oc;
+#endif
+} compare_context;
+
+/* Undefine sljit macros. */
+#undef CMP
+
+/* Used for accessing the elements of the stack. */
+#define STACK(i)      ((i) * (int)sizeof(sljit_sw))
+
+#ifdef SLJIT_PREF_SHIFT_REG
+#if SLJIT_PREF_SHIFT_REG == SLJIT_R2
+/* Nothing. */
+#elif SLJIT_PREF_SHIFT_REG == SLJIT_R3
+#define SHIFT_REG_IS_R3
+#else
+#error "Unsupported shift register"
+#endif
+#endif
+
+#define TMP1          SLJIT_R0
+#ifdef SHIFT_REG_IS_R3
+#define TMP2          SLJIT_R3
+#define TMP3          SLJIT_R2
+#else
+#define TMP2          SLJIT_R2
+#define TMP3          SLJIT_R3
+#endif
+#define STR_PTR       SLJIT_S0
+#define STR_END       SLJIT_S1
+#define STACK_TOP     SLJIT_R1
+#define STACK_LIMIT   SLJIT_S2
+#define COUNT_MATCH   SLJIT_S3
+#define ARGUMENTS     SLJIT_S4
+#define RETURN_ADDR   SLJIT_R4
+
+/* Local space layout. */
+/* These two locals can be used by the current opcode. */
+#define LOCALS0          (0 * sizeof(sljit_sw))
+#define LOCALS1          (1 * sizeof(sljit_sw))
+/* Two local variables for possessive quantifiers (char1 cannot use them). */
+#define POSSESSIVE0      (2 * sizeof(sljit_sw))
+#define POSSESSIVE1      (3 * sizeof(sljit_sw))
+/* Max limit of recursions. */
+#define LIMIT_MATCH      (4 * sizeof(sljit_sw))
+/* The output vector is stored on the stack, and contains pointers
+to characters. The vector data is divided into two groups: the first
+group contains the start / end character pointers, and the second is
+the start pointers when the end of the capturing group has not yet reached. */
+#define OVECTOR_START    (common->ovector_start)
+#define OVECTOR(i)       (OVECTOR_START + (i) * (sljit_sw)sizeof(sljit_sw))
+#define OVECTOR_PRIV(i)  (common->cbra_ptr + (i) * (sljit_sw)sizeof(sljit_sw))
+#define PRIVATE_DATA(cc) (common->private_data_ptrs[(cc) - common->start])
+
+#if defined COMPILE_PCRE8
+#define MOV_UCHAR  SLJIT_MOV_U8
+#elif defined COMPILE_PCRE16
+#define MOV_UCHAR  SLJIT_MOV_U16
+#elif defined COMPILE_PCRE32
+#define MOV_UCHAR  SLJIT_MOV_U32
+#else
+#error Unsupported compiling mode
+#endif
+
+/* Shortcuts. */
+#define DEFINE_COMPILER \
+  struct sljit_compiler *compiler = common->compiler
+#define OP1(op, dst, dstw, src, srcw) \
+  sljit_emit_op1(compiler, (op), (dst), (dstw), (src), (srcw))
+#define OP2(op, dst, dstw, src1, src1w, src2, src2w) \
+  sljit_emit_op2(compiler, (op), (dst), (dstw), (src1), (src1w), (src2), (src2w))
+#define LABEL() \
+  sljit_emit_label(compiler)
+#define JUMP(type) \
+  sljit_emit_jump(compiler, (type))
+#define JUMPTO(type, label) \
+  sljit_set_label(sljit_emit_jump(compiler, (type)), (label))
+#define JUMPHERE(jump) \
+  sljit_set_label((jump), sljit_emit_label(compiler))
+#define SET_LABEL(jump, label) \
+  sljit_set_label((jump), (label))
+#define CMP(type, src1, src1w, src2, src2w) \
+  sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w))
+#define CMPTO(type, src1, src1w, src2, src2w, label) \
+  sljit_set_label(sljit_emit_cmp(compiler, (type), (src1), (src1w), (src2), (src2w)), (label))
+#define OP_FLAGS(op, dst, dstw, type) \
+  sljit_emit_op_flags(compiler, (op), (dst), (dstw), (type))
+#define GET_LOCAL_BASE(dst, dstw, offset) \
+  sljit_get_local_base(compiler, (dst), (dstw), (offset))
+
+#define READ_CHAR_MAX 0x7fffffff
+
+#define INVALID_UTF_CHAR 888
+
+static pcre_uchar *bracketend(pcre_uchar *cc)
+{
+SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND));
+do cc += GET(cc, 1); while (*cc == OP_ALT);
+SLJIT_ASSERT(*cc >= OP_KET && *cc <= OP_KETRPOS);
+cc += 1 + LINK_SIZE;
+return cc;
+}
+
+static int no_alternatives(pcre_uchar *cc)
+{
+int count = 0;
+SLJIT_ASSERT((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND));
+do
+  {
+  cc += GET(cc, 1);
+  count++;
+  }
+while (*cc == OP_ALT);
+SLJIT_ASSERT(*cc >= OP_KET && *cc <= OP_KETRPOS);
+return count;
+}
+
+/* Functions whose might need modification for all new supported opcodes:
+ next_opcode
+ check_opcode_types
+ set_private_data_ptrs
+ get_framesize
+ init_frame
+ get_private_data_copy_length
+ copy_private_data
+ compile_matchingpath
+ compile_backtrackingpath
+*/
+
+static pcre_uchar *next_opcode(compiler_common *common, pcre_uchar *cc)
+{
+SLJIT_UNUSED_ARG(common);
+switch(*cc)
+  {
+  case OP_SOD:
+  case OP_SOM:
+  case OP_SET_SOM:
+  case OP_NOT_WORD_BOUNDARY:
+  case OP_WORD_BOUNDARY:
+  case OP_NOT_DIGIT:
+  case OP_DIGIT:
+  case OP_NOT_WHITESPACE:
+  case OP_WHITESPACE:
+  case OP_NOT_WORDCHAR:
+  case OP_WORDCHAR:
+  case OP_ANY:
+  case OP_ALLANY:
+  case OP_NOTPROP:
+  case OP_PROP:
+  case OP_ANYNL:
+  case OP_NOT_HSPACE:
+  case OP_HSPACE:
+  case OP_NOT_VSPACE:
+  case OP_VSPACE:
+  case OP_EXTUNI:
+  case OP_EODN:
+  case OP_EOD:
+  case OP_CIRC:
+  case OP_CIRCM:
+  case OP_DOLL:
+  case OP_DOLLM:
+  case OP_CRSTAR:
+  case OP_CRMINSTAR:
+  case OP_CRPLUS:
+  case OP_CRMINPLUS:
+  case OP_CRQUERY:
+  case OP_CRMINQUERY:
+  case OP_CRRANGE:
+  case OP_CRMINRANGE:
+  case OP_CRPOSSTAR:
+  case OP_CRPOSPLUS:
+  case OP_CRPOSQUERY:
+  case OP_CRPOSRANGE:
+  case OP_CLASS:
+  case OP_NCLASS:
+  case OP_REF:
+  case OP_REFI:
+  case OP_DNREF:
+  case OP_DNREFI:
+  case OP_RECURSE:
+  case OP_CALLOUT:
+  case OP_ALT:
+  case OP_KET:
+  case OP_KETRMAX:
+  case OP_KETRMIN:
+  case OP_KETRPOS:
+  case OP_REVERSE:
+  case OP_ASSERT:
+  case OP_ASSERT_NOT:
+  case OP_ASSERTBACK:
+  case OP_ASSERTBACK_NOT:
+  case OP_ONCE:
+  case OP_ONCE_NC:
+  case OP_BRA:
+  case OP_BRAPOS:
+  case OP_CBRA:
+  case OP_CBRAPOS:
+  case OP_COND:
+  case OP_SBRA:
+  case OP_SBRAPOS:
+  case OP_SCBRA:
+  case OP_SCBRAPOS:
+  case OP_SCOND:
+  case OP_CREF:
+  case OP_DNCREF:
+  case OP_RREF:
+  case OP_DNRREF:
+  case OP_DEF:
+  case OP_BRAZERO:
+  case OP_BRAMINZERO:
+  case OP_BRAPOSZERO:
+  case OP_PRUNE:
+  case OP_SKIP:
+  case OP_THEN:
+  case OP_COMMIT:
+  case OP_FAIL:
+  case OP_ACCEPT:
+  case OP_ASSERT_ACCEPT:
+  case OP_CLOSE:
+  case OP_SKIPZERO:
+  return cc + PRIV(OP_lengths)[*cc];
+
+  case OP_CHAR:
+  case OP_CHARI:
+  case OP_NOT:
+  case OP_NOTI:
+  case OP_STAR:
+  case OP_MINSTAR:
+  case OP_PLUS:
+  case OP_MINPLUS:
+  case OP_QUERY:
+  case OP_MINQUERY:
+  case OP_UPTO:
+  case OP_MINUPTO:
+  case OP_EXACT:
+  case OP_POSSTAR:
+  case OP_POSPLUS:
+  case OP_POSQUERY:
+  case OP_POSUPTO:
+  case OP_STARI:
+  case OP_MINSTARI:
+  case OP_PLUSI:
+  case OP_MINPLUSI:
+  case OP_QUERYI:
+  case OP_MINQUERYI:
+  case OP_UPTOI:
+  case OP_MINUPTOI:
+  case OP_EXACTI:
+  case OP_POSSTARI:
+  case OP_POSPLUSI:
+  case OP_POSQUERYI:
+  case OP_POSUPTOI:
+  case OP_NOTSTAR:
+  case OP_NOTMINSTAR:
+  case OP_NOTPLUS:
+  case OP_NOTMINPLUS:
+  case OP_NOTQUERY:
+  case OP_NOTMINQUERY:
+  case OP_NOTUPTO:
+  case OP_NOTMINUPTO:
+  case OP_NOTEXACT:
+  case OP_NOTPOSSTAR:
+  case OP_NOTPOSPLUS:
+  case OP_NOTPOSQUERY:
+  case OP_NOTPOSUPTO:
+  case OP_NOTSTARI:
+  case OP_NOTMINSTARI:
+  case OP_NOTPLUSI:
+  case OP_NOTMINPLUSI:
+  case OP_NOTQUERYI:
+  case OP_NOTMINQUERYI:
+  case OP_NOTUPTOI:
+  case OP_NOTMINUPTOI:
+  case OP_NOTEXACTI:
+  case OP_NOTPOSSTARI:
+  case OP_NOTPOSPLUSI:
+  case OP_NOTPOSQUERYI:
+  case OP_NOTPOSUPTOI:
+  cc += PRIV(OP_lengths)[*cc];
+#ifdef SUPPORT_UTF
+  if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+#endif
+  return cc;
+
+  /* Special cases. */
+  case OP_TYPESTAR:
+  case OP_TYPEMINSTAR:
+  case OP_TYPEPLUS:
+  case OP_TYPEMINPLUS:
+  case OP_TYPEQUERY:
+  case OP_TYPEMINQUERY:
+  case OP_TYPEUPTO:
+  case OP_TYPEMINUPTO:
+  case OP_TYPEEXACT:
+  case OP_TYPEPOSSTAR:
+  case OP_TYPEPOSPLUS:
+  case OP_TYPEPOSQUERY:
+  case OP_TYPEPOSUPTO:
+  return cc + PRIV(OP_lengths)[*cc] - 1;
+
+  case OP_ANYBYTE:
+#ifdef SUPPORT_UTF
+  if (common->utf) return NULL;
+#endif
+  return cc + 1;
+
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+  case OP_XCLASS:
+  return cc + GET(cc, 1);
+#endif
+
+  case OP_MARK:
+  case OP_PRUNE_ARG:
+  case OP_SKIP_ARG:
+  case OP_THEN_ARG:
+  return cc + 1 + 2 + cc[1];
+
+  default:
+  /* All opcodes are supported now! */
+  SLJIT_UNREACHABLE();
+  return NULL;
+  }
+}
+
+static BOOL check_opcode_types(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend)
+{
+int count;
+pcre_uchar *slot;
+pcre_uchar *assert_back_end = cc - 1;
+
+/* Calculate important variables (like stack size) and checks whether all opcodes are supported. */
+while (cc < ccend)
+  {
+  switch(*cc)
+    {
+    case OP_SET_SOM:
+    common->has_set_som = TRUE;
+    common->might_be_empty = TRUE;
+    cc += 1;
+    break;
+
+    case OP_REF:
+    case OP_REFI:
+    common->optimized_cbracket[GET2(cc, 1)] = 0;
+    cc += 1 + IMM2_SIZE;
+    break;
+
+    case OP_CBRAPOS:
+    case OP_SCBRAPOS:
+    common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] = 0;
+    cc += 1 + LINK_SIZE + IMM2_SIZE;
+    break;
+
+    case OP_COND:
+    case OP_SCOND:
+    /* Only AUTO_CALLOUT can insert this opcode. We do
+       not intend to support this case. */
+    if (cc[1 + LINK_SIZE] == OP_CALLOUT)
+      return FALSE;
+    cc += 1 + LINK_SIZE;
+    break;
+
+    case OP_CREF:
+    common->optimized_cbracket[GET2(cc, 1)] = 0;
+    cc += 1 + IMM2_SIZE;
+    break;
+
+    case OP_DNREF:
+    case OP_DNREFI:
+    case OP_DNCREF:
+    count = GET2(cc, 1 + IMM2_SIZE);
+    slot = common->name_table + GET2(cc, 1) * common->name_entry_size;
+    while (count-- > 0)
+      {
+      common->optimized_cbracket[GET2(slot, 0)] = 0;
+      slot += common->name_entry_size;
+      }
+    cc += 1 + 2 * IMM2_SIZE;
+    break;
+
+    case OP_RECURSE:
+    /* Set its value only once. */
+    if (common->recursive_head_ptr == 0)
+      {
+      common->recursive_head_ptr = common->ovector_start;
+      common->ovector_start += sizeof(sljit_sw);
+      }
+    cc += 1 + LINK_SIZE;
+    break;
+
+    case OP_CALLOUT:
+    if (common->capture_last_ptr == 0)
+      {
+      common->capture_last_ptr = common->ovector_start;
+      common->ovector_start += sizeof(sljit_sw);
+      }
+    cc += 2 + 2 * LINK_SIZE;
+    break;
+
+    case OP_ASSERTBACK:
+    slot = bracketend(cc);
+    if (slot > assert_back_end)
+      assert_back_end = slot;
+    cc += 1 + LINK_SIZE;
+    break;
+
+    case OP_THEN_ARG:
+    common->has_then = TRUE;
+    common->control_head_ptr = 1;
+    /* Fall through. */
+
+    case OP_PRUNE_ARG:
+    case OP_MARK:
+    if (common->mark_ptr == 0)
+      {
+      common->mark_ptr = common->ovector_start;
+      common->ovector_start += sizeof(sljit_sw);
+      }
+    cc += 1 + 2 + cc[1];
+    break;
+
+    case OP_THEN:
+    common->has_then = TRUE;
+    common->control_head_ptr = 1;
+    cc += 1;
+    break;
+
+    case OP_SKIP:
+    if (cc < assert_back_end)
+      common->has_skip_in_assert_back = TRUE;
+    cc += 1;
+    break;
+
+    case OP_SKIP_ARG:
+    common->control_head_ptr = 1;
+    common->has_skip_arg = TRUE;
+    if (cc < assert_back_end)
+      common->has_skip_in_assert_back = TRUE;
+    cc += 1 + 2 + cc[1];
+    break;
+
+    default:
+    cc = next_opcode(common, cc);
+    if (cc == NULL)
+      return FALSE;
+    break;
+    }
+  }
+return TRUE;
+}
+
+static BOOL is_accelerated_repeat(pcre_uchar *cc)
+{
+switch(*cc)
+  {
+  case OP_TYPESTAR:
+  case OP_TYPEMINSTAR:
+  case OP_TYPEPLUS:
+  case OP_TYPEMINPLUS:
+  case OP_TYPEPOSSTAR:
+  case OP_TYPEPOSPLUS:
+  return (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI);
+
+  case OP_STAR:
+  case OP_MINSTAR:
+  case OP_PLUS:
+  case OP_MINPLUS:
+  case OP_POSSTAR:
+  case OP_POSPLUS:
+
+  case OP_STARI:
+  case OP_MINSTARI:
+  case OP_PLUSI:
+  case OP_MINPLUSI:
+  case OP_POSSTARI:
+  case OP_POSPLUSI:
+
+  case OP_NOTSTAR:
+  case OP_NOTMINSTAR:
+  case OP_NOTPLUS:
+  case OP_NOTMINPLUS:
+  case OP_NOTPOSSTAR:
+  case OP_NOTPOSPLUS:
+
+  case OP_NOTSTARI:
+  case OP_NOTMINSTARI:
+  case OP_NOTPLUSI:
+  case OP_NOTMINPLUSI:
+  case OP_NOTPOSSTARI:
+  case OP_NOTPOSPLUSI:
+  return TRUE;
+
+  case OP_CLASS:
+  case OP_NCLASS:
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+  case OP_XCLASS:
+  cc += (*cc == OP_XCLASS) ? GET(cc, 1) : (int)(1 + (32 / sizeof(pcre_uchar)));
+#else
+  cc += (1 + (32 / sizeof(pcre_uchar)));
+#endif
+
+  switch(*cc)
+    {
+    case OP_CRSTAR:
+    case OP_CRMINSTAR:
+    case OP_CRPLUS:
+    case OP_CRMINPLUS:
+    case OP_CRPOSSTAR:
+    case OP_CRPOSPLUS:
+    return TRUE;
+    }
+  break;
+  }
+return FALSE;
+}
+
+static SLJIT_INLINE BOOL detect_fast_forward_skip(compiler_common *common, int *private_data_start)
+{
+pcre_uchar *cc = common->start;
+pcre_uchar *end;
+
+/* Skip not repeated brackets. */
+while (TRUE)
+  {
+  switch(*cc)
+    {
+    case OP_SOD:
+    case OP_SOM:
+    case OP_SET_SOM:
+    case OP_NOT_WORD_BOUNDARY:
+    case OP_WORD_BOUNDARY:
+    case OP_EODN:
+    case OP_EOD:
+    case OP_CIRC:
+    case OP_CIRCM:
+    case OP_DOLL:
+    case OP_DOLLM:
+    /* Zero width assertions. */
+    cc++;
+    continue;
+    }
+
+  if (*cc != OP_BRA && *cc != OP_CBRA)
+    break;
+
+  end = cc + GET(cc, 1);
+  if (*end != OP_KET || PRIVATE_DATA(end) != 0)
+    return FALSE;
+  if (*cc == OP_CBRA)
+    {
+    if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
+      return FALSE;
+    cc += IMM2_SIZE;
+    }
+  cc += 1 + LINK_SIZE;
+  }
+
+if (is_accelerated_repeat(cc))
+  {
+  common->fast_forward_bc_ptr = cc;
+  common->private_data_ptrs[(cc + 1) - common->start] = *private_data_start;
+  *private_data_start += sizeof(sljit_sw);
+  return TRUE;
+  }
+return FALSE;
+}
+
+static SLJIT_INLINE void detect_fast_fail(compiler_common *common, pcre_uchar *cc, int *private_data_start, sljit_s32 depth)
+{
+  pcre_uchar *next_alt;
+
+  SLJIT_ASSERT(*cc == OP_BRA || *cc == OP_CBRA);
+
+  if (*cc == OP_CBRA && common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
+    return;
+
+  next_alt = bracketend(cc) - (1 + LINK_SIZE);
+  if (*next_alt != OP_KET || PRIVATE_DATA(next_alt) != 0)
+    return;
+
+  do
+    {
+    next_alt = cc + GET(cc, 1);
+
+    cc += 1 + LINK_SIZE + ((*cc == OP_CBRA) ? IMM2_SIZE : 0);
+
+    while (TRUE)
+      {
+      switch(*cc)
+        {
+        case OP_SOD:
+        case OP_SOM:
+        case OP_SET_SOM:
+        case OP_NOT_WORD_BOUNDARY:
+        case OP_WORD_BOUNDARY:
+        case OP_EODN:
+        case OP_EOD:
+        case OP_CIRC:
+        case OP_CIRCM:
+        case OP_DOLL:
+        case OP_DOLLM:
+        /* Zero width assertions. */
+        cc++;
+        continue;
+        }
+      break;
+      }
+
+    if (depth > 0 && (*cc == OP_BRA || *cc == OP_CBRA))
+      detect_fast_fail(common, cc, private_data_start, depth - 1);
+
+    if (is_accelerated_repeat(cc))
+      {
+      common->private_data_ptrs[(cc + 1) - common->start] = *private_data_start;
+
+      if (common->fast_fail_start_ptr == 0)
+        common->fast_fail_start_ptr = *private_data_start;
+
+      *private_data_start += sizeof(sljit_sw);
+      common->fast_fail_end_ptr = *private_data_start;
+
+      if (*private_data_start > SLJIT_MAX_LOCAL_SIZE)
+        return;
+      }
+
+    cc = next_alt;
+    }
+  while (*cc == OP_ALT);
+}
+
+static int get_class_iterator_size(pcre_uchar *cc)
+{
+sljit_u32 min;
+sljit_u32 max;
+switch(*cc)
+  {
+  case OP_CRSTAR:
+  case OP_CRPLUS:
+  return 2;
+
+  case OP_CRMINSTAR:
+  case OP_CRMINPLUS:
+  case OP_CRQUERY:
+  case OP_CRMINQUERY:
+  return 1;
+
+  case OP_CRRANGE:
+  case OP_CRMINRANGE:
+  min = GET2(cc, 1);
+  max = GET2(cc, 1 + IMM2_SIZE);
+  if (max == 0)
+    return (*cc == OP_CRRANGE) ? 2 : 1;
+  max -= min;
+  if (max > 2)
+    max = 2;
+  return max;
+
+  default:
+  return 0;
+  }
+}
+
+static BOOL detect_repeat(compiler_common *common, pcre_uchar *begin)
+{
+pcre_uchar *end = bracketend(begin);
+pcre_uchar *next;
+pcre_uchar *next_end;
+pcre_uchar *max_end;
+pcre_uchar type;
+sljit_sw length = end - begin;
+int min, max, i;
+
+/* Detect fixed iterations first. */
+if (end[-(1 + LINK_SIZE)] != OP_KET)
+  return FALSE;
+
+/* Already detected repeat. */
+if (common->private_data_ptrs[end - common->start - LINK_SIZE] != 0)
+  return TRUE;
+
+next = end;
+min = 1;
+while (1)
+  {
+  if (*next != *begin)
+    break;
+  next_end = bracketend(next);
+  if (next_end - next != length || memcmp(begin, next, IN_UCHARS(length)) != 0)
+    break;
+  next = next_end;
+  min++;
+  }
+
+if (min == 2)
+  return FALSE;
+
+max = 0;
+max_end = next;
+if (*next == OP_BRAZERO || *next == OP_BRAMINZERO)
+  {
+  type = *next;
+  while (1)
+    {
+    if (next[0] != type || next[1] != OP_BRA || next[2 + LINK_SIZE] != *begin)
+      break;
+    next_end = bracketend(next + 2 + LINK_SIZE);
+    if (next_end - next != (length + 2 + LINK_SIZE) || memcmp(begin, next + 2 + LINK_SIZE, IN_UCHARS(length)) != 0)
+      break;
+    next = next_end;
+    max++;
+    }
+
+  if (next[0] == type && next[1] == *begin && max >= 1)
+    {
+    next_end = bracketend(next + 1);
+    if (next_end - next == (length + 1) && memcmp(begin, next + 1, IN_UCHARS(length)) == 0)
+      {
+      for (i = 0; i < max; i++, next_end += 1 + LINK_SIZE)
+        if (*next_end != OP_KET)
+          break;
+
+      if (i == max)
+        {
+        common->private_data_ptrs[max_end - common->start - LINK_SIZE] = next_end - max_end;
+        common->private_data_ptrs[max_end - common->start - LINK_SIZE + 1] = (type == OP_BRAZERO) ? OP_UPTO : OP_MINUPTO;
+        /* +2 the original and the last. */
+        common->private_data_ptrs[max_end - common->start - LINK_SIZE + 2] = max + 2;
+        if (min == 1)
+          return TRUE;
+        min--;
+        max_end -= (1 + LINK_SIZE) + GET(max_end, -LINK_SIZE);
+        }
+      }
+    }
+  }
+
+if (min >= 3)
+  {
+  common->private_data_ptrs[end - common->start - LINK_SIZE] = max_end - end;
+  common->private_data_ptrs[end - common->start - LINK_SIZE + 1] = OP_EXACT;
+  common->private_data_ptrs[end - common->start - LINK_SIZE + 2] = min;
+  return TRUE;
+  }
+
+return FALSE;
+}
+
+#define CASE_ITERATOR_PRIVATE_DATA_1 \
+    case OP_MINSTAR: \
+    case OP_MINPLUS: \
+    case OP_QUERY: \
+    case OP_MINQUERY: \
+    case OP_MINSTARI: \
+    case OP_MINPLUSI: \
+    case OP_QUERYI: \
+    case OP_MINQUERYI: \
+    case OP_NOTMINSTAR: \
+    case OP_NOTMINPLUS: \
+    case OP_NOTQUERY: \
+    case OP_NOTMINQUERY: \
+    case OP_NOTMINSTARI: \
+    case OP_NOTMINPLUSI: \
+    case OP_NOTQUERYI: \
+    case OP_NOTMINQUERYI:
+
+#define CASE_ITERATOR_PRIVATE_DATA_2A \
+    case OP_STAR: \
+    case OP_PLUS: \
+    case OP_STARI: \
+    case OP_PLUSI: \
+    case OP_NOTSTAR: \
+    case OP_NOTPLUS: \
+    case OP_NOTSTARI: \
+    case OP_NOTPLUSI:
+
+#define CASE_ITERATOR_PRIVATE_DATA_2B \
+    case OP_UPTO: \
+    case OP_MINUPTO: \
+    case OP_UPTOI: \
+    case OP_MINUPTOI: \
+    case OP_NOTUPTO: \
+    case OP_NOTMINUPTO: \
+    case OP_NOTUPTOI: \
+    case OP_NOTMINUPTOI:
+
+#define CASE_ITERATOR_TYPE_PRIVATE_DATA_1 \
+    case OP_TYPEMINSTAR: \
+    case OP_TYPEMINPLUS: \
+    case OP_TYPEQUERY: \
+    case OP_TYPEMINQUERY:
+
+#define CASE_ITERATOR_TYPE_PRIVATE_DATA_2A \
+    case OP_TYPESTAR: \
+    case OP_TYPEPLUS:
+
+#define CASE_ITERATOR_TYPE_PRIVATE_DATA_2B \
+    case OP_TYPEUPTO: \
+    case OP_TYPEMINUPTO:
+
+static void set_private_data_ptrs(compiler_common *common, int *private_data_start, pcre_uchar *ccend)
+{
+pcre_uchar *cc = common->start;
+pcre_uchar *alternative;
+pcre_uchar *end = NULL;
+int private_data_ptr = *private_data_start;
+int space, size, bracketlen;
+BOOL repeat_check = TRUE;
+
+while (cc < ccend)
+  {
+  space = 0;
+  size = 0;
+  bracketlen = 0;
+  if (private_data_ptr > SLJIT_MAX_LOCAL_SIZE)
+    break;
+
+  if (repeat_check && (*cc == OP_ONCE || *cc == OP_ONCE_NC || *cc == OP_BRA || *cc == OP_CBRA || *cc == OP_COND))
+    {
+    if (detect_repeat(common, cc))
+      {
+      /* These brackets are converted to repeats, so no global
+      based single character repeat is allowed. */
+      if (cc >= end)
+        end = bracketend(cc);
+      }
+    }
+  repeat_check = TRUE;
+
+  switch(*cc)
+    {
+    case OP_KET:
+    if (common->private_data_ptrs[cc + 1 - common->start] != 0)
+      {
+      common->private_data_ptrs[cc - common->start] = private_data_ptr;
+      private_data_ptr += sizeof(sljit_sw);
+      cc += common->private_data_ptrs[cc + 1 - common->start];
+      }
+    cc += 1 + LINK_SIZE;
+    break;
+
+    case OP_ASSERT:
+    case OP_ASSERT_NOT:
+    case OP_ASSERTBACK:
+    case OP_ASSERTBACK_NOT:
+    case OP_ONCE:
+    case OP_ONCE_NC:
+    case OP_BRAPOS:
+    case OP_SBRA:
+    case OP_SBRAPOS:
+    case OP_SCOND:
+    common->private_data_ptrs[cc - common->start] = private_data_ptr;
+    private_data_ptr += sizeof(sljit_sw);
+    bracketlen = 1 + LINK_SIZE;
+    break;
+
+    case OP_CBRAPOS:
+    case OP_SCBRAPOS:
+    common->private_data_ptrs[cc - common->start] = private_data_ptr;
+    private_data_ptr += sizeof(sljit_sw);
+    bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
+    break;
+
+    case OP_COND:
+    /* Might be a hidden SCOND. */
+    alternative = cc + GET(cc, 1);
+    if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
+      {
+      common->private_data_ptrs[cc - common->start] = private_data_ptr;
+      private_data_ptr += sizeof(sljit_sw);
+      }
+    bracketlen = 1 + LINK_SIZE;
+    break;
+
+    case OP_BRA:
+    bracketlen = 1 + LINK_SIZE;
+    break;
+
+    case OP_CBRA:
+    case OP_SCBRA:
+    bracketlen = 1 + LINK_SIZE + IMM2_SIZE;
+    break;
+
+    case OP_BRAZERO:
+    case OP_BRAMINZERO:
+    case OP_BRAPOSZERO:
+    repeat_check = FALSE;
+    size = 1;
+    break;
+
+    CASE_ITERATOR_PRIVATE_DATA_1
+    space = 1;
+    size = -2;
+    break;
+
+    CASE_ITERATOR_PRIVATE_DATA_2A
+    space = 2;
+    size = -2;
+    break;
+
+    CASE_ITERATOR_PRIVATE_DATA_2B
+    space = 2;
+    size = -(2 + IMM2_SIZE);
+    break;
+
+    CASE_ITERATOR_TYPE_PRIVATE_DATA_1
+    space = 1;
+    size = 1;
+    break;
+
+    CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
+    if (cc[1] != OP_ANYNL && cc[1] != OP_EXTUNI)
+      space = 2;
+    size = 1;
+    break;
+
+    case OP_TYPEUPTO:
+    if (cc[1 + IMM2_SIZE] != OP_ANYNL && cc[1 + IMM2_SIZE] != OP_EXTUNI)
+      space = 2;
+    size = 1 + IMM2_SIZE;
+    break;
+
+    case OP_TYPEMINUPTO:
+    space = 2;
+    size = 1 + IMM2_SIZE;
+    break;
+
+    case OP_CLASS:
+    case OP_NCLASS:
+    space = get_class_iterator_size(cc + size);
+    size = 1 + 32 / sizeof(pcre_uchar);
+    break;
+
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+    case OP_XCLASS:
+    space = get_class_iterator_size(cc + size);
+    size = GET(cc, 1);
+    break;
+#endif
+
+    default:
+    cc = next_opcode(common, cc);
+    SLJIT_ASSERT(cc != NULL);
+    break;
+    }
+
+  /* Character iterators, which are not inside a repeated bracket,
+     gets a private slot instead of allocating it on the stack. */
+  if (space > 0 && cc >= end)
+    {
+    common->private_data_ptrs[cc - common->start] = private_data_ptr;
+    private_data_ptr += sizeof(sljit_sw) * space;
+    }
+
+  if (size != 0)
+    {
+    if (size < 0)
+      {
+      cc += -size;
+#ifdef SUPPORT_UTF
+      if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+#endif
+      }
+    else
+      cc += size;
+    }
+
+  if (bracketlen > 0)
+    {
+    if (cc >= end)
+      {
+      end = bracketend(cc);
+      if (end[-1 - LINK_SIZE] == OP_KET)
+        end = NULL;
+      }
+    cc += bracketlen;
+    }
+  }
+*private_data_start = private_data_ptr;
+}
+
+/* Returns with a frame_types (always < 0) if no need for frame. */
+static int get_framesize(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL recursive, BOOL *needs_control_head)
+{
+int length = 0;
+int possessive = 0;
+BOOL stack_restore = FALSE;
+BOOL setsom_found = recursive;
+BOOL setmark_found = recursive;
+/* The last capture is a local variable even for recursions. */
+BOOL capture_last_found = FALSE;
+
+#if defined DEBUG_FORCE_CONTROL_HEAD && DEBUG_FORCE_CONTROL_HEAD
+SLJIT_ASSERT(common->control_head_ptr != 0);
+*needs_control_head = TRUE;
+#else
+*needs_control_head = FALSE;
+#endif
+
+if (ccend == NULL)
+  {
+  ccend = bracketend(cc) - (1 + LINK_SIZE);
+  if (!recursive && (*cc == OP_CBRAPOS || *cc == OP_SCBRAPOS))
+    {
+    possessive = length = (common->capture_last_ptr != 0) ? 5 : 3;
+    /* This is correct regardless of common->capture_last_ptr. */
+    capture_last_found = TRUE;
+    }
+  cc = next_opcode(common, cc);
+  }
+
+SLJIT_ASSERT(cc != NULL);
+while (cc < ccend)
+  switch(*cc)
+    {
+    case OP_SET_SOM:
+    SLJIT_ASSERT(common->has_set_som);
+    stack_restore = TRUE;
+    if (!setsom_found)
+      {
+      length += 2;
+      setsom_found = TRUE;
+      }
+    cc += 1;
+    break;
+
+    case OP_MARK:
+    case OP_PRUNE_ARG:
+    case OP_THEN_ARG:
+    SLJIT_ASSERT(common->mark_ptr != 0);
+    stack_restore = TRUE;
+    if (!setmark_found)
+      {
+      length += 2;
+      setmark_found = TRUE;
+      }
+    if (common->control_head_ptr != 0)
+      *needs_control_head = TRUE;
+    cc += 1 + 2 + cc[1];
+    break;
+
+    case OP_RECURSE:
+    stack_restore = TRUE;
+    if (common->has_set_som && !setsom_found)
+      {
+      length += 2;
+      setsom_found = TRUE;
+      }
+    if (common->mark_ptr != 0 && !setmark_found)
+      {
+      length += 2;
+      setmark_found = TRUE;
+      }
+    if (common->capture_last_ptr != 0 && !capture_last_found)
+      {
+      length += 2;
+      capture_last_found = TRUE;
+      }
+    cc += 1 + LINK_SIZE;
+    break;
+
+    case OP_CBRA:
+    case OP_CBRAPOS:
+    case OP_SCBRA:
+    case OP_SCBRAPOS:
+    stack_restore = TRUE;
+    if (common->capture_last_ptr != 0 && !capture_last_found)
+      {
+      length += 2;
+      capture_last_found = TRUE;
+      }
+    length += 3;
+    cc += 1 + LINK_SIZE + IMM2_SIZE;
+    break;
+
+    case OP_THEN:
+    stack_restore = TRUE;
+    if (common->control_head_ptr != 0)
+      *needs_control_head = TRUE;
+    cc ++;
+    break;
+
+    default:
+    stack_restore = TRUE;
+    /* Fall through. */
+
+    case OP_NOT_WORD_BOUNDARY:
+    case OP_WORD_BOUNDARY:
+    case OP_NOT_DIGIT:
+    case OP_DIGIT:
+    case OP_NOT_WHITESPACE:
+    case OP_WHITESPACE:
+    case OP_NOT_WORDCHAR:
+    case OP_WORDCHAR:
+    case OP_ANY:
+    case OP_ALLANY:
+    case OP_ANYBYTE:
+    case OP_NOTPROP:
+    case OP_PROP:
+    case OP_ANYNL:
+    case OP_NOT_HSPACE:
+    case OP_HSPACE:
+    case OP_NOT_VSPACE:
+    case OP_VSPACE:
+    case OP_EXTUNI:
+    case OP_EODN:
+    case OP_EOD:
+    case OP_CIRC:
+    case OP_CIRCM:
+    case OP_DOLL:
+    case OP_DOLLM:
+    case OP_CHAR:
+    case OP_CHARI:
+    case OP_NOT:
+    case OP_NOTI:
+
+    case OP_EXACT:
+    case OP_POSSTAR:
+    case OP_POSPLUS:
+    case OP_POSQUERY:
+    case OP_POSUPTO:
+
+    case OP_EXACTI:
+    case OP_POSSTARI:
+    case OP_POSPLUSI:
+    case OP_POSQUERYI:
+    case OP_POSUPTOI:
+
+    case OP_NOTEXACT:
+    case OP_NOTPOSSTAR:
+    case OP_NOTPOSPLUS:
+    case OP_NOTPOSQUERY:
+    case OP_NOTPOSUPTO:
+
+    case OP_NOTEXACTI:
+    case OP_NOTPOSSTARI:
+    case OP_NOTPOSPLUSI:
+    case OP_NOTPOSQUERYI:
+    case OP_NOTPOSUPTOI:
+
+    case OP_TYPEEXACT:
+    case OP_TYPEPOSSTAR:
+    case OP_TYPEPOSPLUS:
+    case OP_TYPEPOSQUERY:
+    case OP_TYPEPOSUPTO:
+
+    case OP_CLASS:
+    case OP_NCLASS:
+    case OP_XCLASS:
+    case OP_CALLOUT:
+
+    cc = next_opcode(common, cc);
+    SLJIT_ASSERT(cc != NULL);
+    break;
+    }
+
+/* Possessive quantifiers can use a special case. */
+if (SLJIT_UNLIKELY(possessive == length))
+  return stack_restore ? no_frame : no_stack;
+
+if (length > 0)
+  return length + 1;
+return stack_restore ? no_frame : no_stack;
+}
+
+static void init_frame(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, int stackpos, int stacktop, BOOL recursive)
+{
+DEFINE_COMPILER;
+BOOL setsom_found = recursive;
+BOOL setmark_found = recursive;
+/* The last capture is a local variable even for recursions. */
+BOOL capture_last_found = FALSE;
+int offset;
+
+/* >= 1 + shortest item size (2) */
+SLJIT_UNUSED_ARG(stacktop);
+SLJIT_ASSERT(stackpos >= stacktop + 2);
+
+stackpos = STACK(stackpos);
+if (ccend == NULL)
+  {
+  ccend = bracketend(cc) - (1 + LINK_SIZE);
+  if (recursive || (*cc != OP_CBRAPOS && *cc != OP_SCBRAPOS))
+    cc = next_opcode(common, cc);
+  }
+
+SLJIT_ASSERT(cc != NULL);
+while (cc < ccend)
+  switch(*cc)
+    {
+    case OP_SET_SOM:
+    SLJIT_ASSERT(common->has_set_som);
+    if (!setsom_found)
+      {
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0));
+      stackpos -= (int)sizeof(sljit_sw);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
+      stackpos -= (int)sizeof(sljit_sw);
+      setsom_found = TRUE;
+      }
+    cc += 1;
+    break;
+
+    case OP_MARK:
+    case OP_PRUNE_ARG:
+    case OP_THEN_ARG:
+    SLJIT_ASSERT(common->mark_ptr != 0);
+    if (!setmark_found)
+      {
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);
+      stackpos -= (int)sizeof(sljit_sw);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
+      stackpos -= (int)sizeof(sljit_sw);
+      setmark_found = TRUE;
+      }
+    cc += 1 + 2 + cc[1];
+    break;
+
+    case OP_RECURSE:
+    if (common->has_set_som && !setsom_found)
+      {
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -OVECTOR(0));
+      stackpos -= (int)sizeof(sljit_sw);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
+      stackpos -= (int)sizeof(sljit_sw);
+      setsom_found = TRUE;
+      }
+    if (common->mark_ptr != 0 && !setmark_found)
+      {
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->mark_ptr);
+      stackpos -= (int)sizeof(sljit_sw);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
+      stackpos -= (int)sizeof(sljit_sw);
+      setmark_found = TRUE;
+      }
+    if (common->capture_last_ptr != 0 && !capture_last_found)
+      {
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr);
+      stackpos -= (int)sizeof(sljit_sw);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
+      stackpos -= (int)sizeof(sljit_sw);
+      capture_last_found = TRUE;
+      }
+    cc += 1 + LINK_SIZE;
+    break;
+
+    case OP_CBRA:
+    case OP_CBRAPOS:
+    case OP_SCBRA:
+    case OP_SCBRAPOS:
+    if (common->capture_last_ptr != 0 && !capture_last_found)
+      {
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, -common->capture_last_ptr);
+      stackpos -= (int)sizeof(sljit_sw);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
+      stackpos -= (int)sizeof(sljit_sw);
+      capture_last_found = TRUE;
+      }
+    offset = (GET2(cc, 1 + LINK_SIZE)) << 1;
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, OVECTOR(offset));
+    stackpos -= (int)sizeof(sljit_sw);
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP1, 0);
+    stackpos -= (int)sizeof(sljit_sw);
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, TMP2, 0);
+    stackpos -= (int)sizeof(sljit_sw);
+
+    cc += 1 + LINK_SIZE + IMM2_SIZE;
+    break;
+
+    default:
+    cc = next_opcode(common, cc);
+    SLJIT_ASSERT(cc != NULL);
+    break;
+    }
+
+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackpos, SLJIT_IMM, 0);
+SLJIT_ASSERT(stackpos == STACK(stacktop));
+}
+
+static SLJIT_INLINE int get_private_data_copy_length(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, BOOL needs_control_head)
+{
+int private_data_length = needs_control_head ? 3 : 2;
+int size;
+pcre_uchar *alternative;
+/* Calculate the sum of the private machine words. */
+while (cc < ccend)
+  {
+  size = 0;
+  switch(*cc)
+    {
+    case OP_KET:
+    if (PRIVATE_DATA(cc) != 0)
+      {
+      private_data_length++;
+      SLJIT_ASSERT(PRIVATE_DATA(cc + 1) != 0);
+      cc += PRIVATE_DATA(cc + 1);
+      }
+    cc += 1 + LINK_SIZE;
+    break;
+
+    case OP_ASSERT:
+    case OP_ASSERT_NOT:
+    case OP_ASSERTBACK:
+    case OP_ASSERTBACK_NOT:
+    case OP_ONCE:
+    case OP_ONCE_NC:
+    case OP_BRAPOS:
+    case OP_SBRA:
+    case OP_SBRAPOS:
+    case OP_SCOND:
+    private_data_length++;
+    SLJIT_ASSERT(PRIVATE_DATA(cc) != 0);
+    cc += 1 + LINK_SIZE;
+    break;
+
+    case OP_CBRA:
+    case OP_SCBRA:
+    if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
+      private_data_length++;
+    cc += 1 + LINK_SIZE + IMM2_SIZE;
+    break;
+
+    case OP_CBRAPOS:
+    case OP_SCBRAPOS:
+    private_data_length += 2;
+    cc += 1 + LINK_SIZE + IMM2_SIZE;
+    break;
+
+    case OP_COND:
+    /* Might be a hidden SCOND. */
+    alternative = cc + GET(cc, 1);
+    if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
+      private_data_length++;
+    cc += 1 + LINK_SIZE;
+    break;
+
+    CASE_ITERATOR_PRIVATE_DATA_1
+    if (PRIVATE_DATA(cc))
+      private_data_length++;
+    cc += 2;
+#ifdef SUPPORT_UTF
+    if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+#endif
+    break;
+
+    CASE_ITERATOR_PRIVATE_DATA_2A
+    if (PRIVATE_DATA(cc))
+      private_data_length += 2;
+    cc += 2;
+#ifdef SUPPORT_UTF
+    if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+#endif
+    break;
+
+    CASE_ITERATOR_PRIVATE_DATA_2B
+    if (PRIVATE_DATA(cc))
+      private_data_length += 2;
+    cc += 2 + IMM2_SIZE;
+#ifdef SUPPORT_UTF
+    if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+#endif
+    break;
+
+    CASE_ITERATOR_TYPE_PRIVATE_DATA_1
+    if (PRIVATE_DATA(cc))
+      private_data_length++;
+    cc += 1;
+    break;
+
+    CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
+    if (PRIVATE_DATA(cc))
+      private_data_length += 2;
+    cc += 1;
+    break;
+
+    CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
+    if (PRIVATE_DATA(cc))
+      private_data_length += 2;
+    cc += 1 + IMM2_SIZE;
+    break;
+
+    case OP_CLASS:
+    case OP_NCLASS:
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+    case OP_XCLASS:
+    size = (*cc == OP_XCLASS) ? GET(cc, 1) : 1 + 32 / (int)sizeof(pcre_uchar);
+#else
+    size = 1 + 32 / (int)sizeof(pcre_uchar);
+#endif
+    if (PRIVATE_DATA(cc))
+      private_data_length += get_class_iterator_size(cc + size);
+    cc += size;
+    break;
+
+    default:
+    cc = next_opcode(common, cc);
+    SLJIT_ASSERT(cc != NULL);
+    break;
+    }
+  }
+SLJIT_ASSERT(cc == ccend);
+return private_data_length;
+}
+
+static void copy_private_data(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend,
+  BOOL save, int stackptr, int stacktop, BOOL needs_control_head)
+{
+DEFINE_COMPILER;
+int srcw[2];
+int count, size;
+BOOL tmp1next = TRUE;
+BOOL tmp1empty = TRUE;
+BOOL tmp2empty = TRUE;
+pcre_uchar *alternative;
+enum {
+  loop,
+  end
+} status;
+
+status = loop;
+stackptr = STACK(stackptr);
+stacktop = STACK(stacktop - 1);
+
+if (!save)
+  {
+  stacktop -= (needs_control_head ? 2 : 1) * sizeof(sljit_sw);
+  if (stackptr < stacktop)
+    {
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);
+    stackptr += sizeof(sljit_sw);
+    tmp1empty = FALSE;
+    }
+  if (stackptr < stacktop)
+    {
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), stackptr);
+    stackptr += sizeof(sljit_sw);
+    tmp2empty = FALSE;
+    }
+  /* The tmp1next must be TRUE in either way. */
+  }
+
+SLJIT_ASSERT(common->recursive_head_ptr != 0);
+
+do
+  {
+  count = 0;
+  if (cc >= ccend)
+    {
+    if (!save)
+      break;
+
+    count = 1;
+    srcw[0] = common->recursive_head_ptr;
+    if (needs_control_head)
+      {
+      SLJIT_ASSERT(common->control_head_ptr != 0);
+      count = 2;
+      srcw[0] = common->control_head_ptr;
+      srcw[1] = common->recursive_head_ptr;
+      }
+    status = end;
+    }
+  else switch(*cc)
+    {
+    case OP_KET:
+    if (PRIVATE_DATA(cc) != 0)
+      {
+      count = 1;
+      srcw[0] = PRIVATE_DATA(cc);
+      SLJIT_ASSERT(PRIVATE_DATA(cc + 1) != 0);
+      cc += PRIVATE_DATA(cc + 1);
+      }
+    cc += 1 + LINK_SIZE;
+    break;
+
+    case OP_ASSERT:
+    case OP_ASSERT_NOT:
+    case OP_ASSERTBACK:
+    case OP_ASSERTBACK_NOT:
+    case OP_ONCE:
+    case OP_ONCE_NC:
+    case OP_BRAPOS:
+    case OP_SBRA:
+    case OP_SBRAPOS:
+    case OP_SCOND:
+    count = 1;
+    srcw[0] = PRIVATE_DATA(cc);
+    SLJIT_ASSERT(srcw[0] != 0);
+    cc += 1 + LINK_SIZE;
+    break;
+
+    case OP_CBRA:
+    case OP_SCBRA:
+    if (common->optimized_cbracket[GET2(cc, 1 + LINK_SIZE)] == 0)
+      {
+      count = 1;
+      srcw[0] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
+      }
+    cc += 1 + LINK_SIZE + IMM2_SIZE;
+    break;
+
+    case OP_CBRAPOS:
+    case OP_SCBRAPOS:
+    count = 2;
+    srcw[0] = PRIVATE_DATA(cc);
+    srcw[1] = OVECTOR_PRIV(GET2(cc, 1 + LINK_SIZE));
+    SLJIT_ASSERT(srcw[0] != 0 && srcw[1] != 0);
+    cc += 1 + LINK_SIZE + IMM2_SIZE;
+    break;
+
+    case OP_COND:
+    /* Might be a hidden SCOND. */
+    alternative = cc + GET(cc, 1);
+    if (*alternative == OP_KETRMAX || *alternative == OP_KETRMIN)
+      {
+      count = 1;
+      srcw[0] = PRIVATE_DATA(cc);
+      SLJIT_ASSERT(srcw[0] != 0);
+      }
+    cc += 1 + LINK_SIZE;
+    break;
+
+    CASE_ITERATOR_PRIVATE_DATA_1
+    if (PRIVATE_DATA(cc))
+      {
+      count = 1;
+      srcw[0] = PRIVATE_DATA(cc);
+      }
+    cc += 2;
+#ifdef SUPPORT_UTF
+    if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+#endif
+    break;
+
+    CASE_ITERATOR_PRIVATE_DATA_2A
+    if (PRIVATE_DATA(cc))
+      {
+      count = 2;
+      srcw[0] = PRIVATE_DATA(cc);
+      srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw);
+      }
+    cc += 2;
+#ifdef SUPPORT_UTF
+    if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+#endif
+    break;
+
+    CASE_ITERATOR_PRIVATE_DATA_2B
+    if (PRIVATE_DATA(cc))
+      {
+      count = 2;
+      srcw[0] = PRIVATE_DATA(cc);
+      srcw[1] = PRIVATE_DATA(cc) + sizeof(sljit_sw);
+      }
+    cc += 2 + IMM2_SIZE;
+#ifdef SUPPORT_UTF
+    if (common->utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+#endif
+    break;
+
+    CASE_ITERATOR_TYPE_PRIVATE_DATA_1
+    if (PRIVATE_DATA(cc))
+      {
+      count = 1;
+      srcw[0] = PRIVATE_DATA(cc);
+      }
+    cc += 1;
+    break;
+
+    CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
+    if (PRIVATE_DATA(cc))
+      {
+      count = 2;
+      srcw[0] = PRIVATE_DATA(cc);
+      srcw[1] = srcw[0] + sizeof(sljit_sw);
+      }
+    cc += 1;
+    break;
+
+    CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
+    if (PRIVATE_DATA(cc))
+      {
+      count = 2;
+      srcw[0] = PRIVATE_DATA(cc);
+      srcw[1] = srcw[0] + sizeof(sljit_sw);
+      }
+    cc += 1 + IMM2_SIZE;
+    break;
+
+    case OP_CLASS:
+    case OP_NCLASS:
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+    case OP_XCLASS:
+    size = (*cc == OP_XCLASS) ? GET(cc, 1) : 1 + 32 / (int)sizeof(pcre_uchar);
+#else
+    size = 1 + 32 / (int)sizeof(pcre_uchar);
+#endif
+    if (PRIVATE_DATA(cc))
+      switch(get_class_iterator_size(cc + size))
+        {
+        case 1:
+        count = 1;
+        srcw[0] = PRIVATE_DATA(cc);
+        break;
+
+        case 2:
+        count = 2;
+        srcw[0] = PRIVATE_DATA(cc);
+        srcw[1] = srcw[0] + sizeof(sljit_sw);
+        break;
+
+        default:
+        SLJIT_UNREACHABLE();
+        break;
+        }
+    cc += size;
+    break;
+
+    default:
+    cc = next_opcode(common, cc);
+    SLJIT_ASSERT(cc != NULL);
+    break;
+    }
+
+  while (count > 0)
+    {
+    count--;
+    if (save)
+      {
+      if (tmp1next)
+        {
+        if (!tmp1empty)
+          {
+          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);
+          stackptr += sizeof(sljit_sw);
+          }
+        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), srcw[count]);
+        tmp1empty = FALSE;
+        tmp1next = FALSE;
+        }
+      else
+        {
+        if (!tmp2empty)
+          {
+          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);
+          stackptr += sizeof(sljit_sw);
+          }
+        OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), srcw[count]);
+        tmp2empty = FALSE;
+        tmp1next = TRUE;
+        }
+      }
+    else
+      {
+      if (tmp1next)
+        {
+        SLJIT_ASSERT(!tmp1empty);
+        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), srcw[count], TMP1, 0);
+        tmp1empty = stackptr >= stacktop;
+        if (!tmp1empty)
+          {
+          OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), stackptr);
+          stackptr += sizeof(sljit_sw);
+          }
+        tmp1next = FALSE;
+        }
+      else
+        {
+        SLJIT_ASSERT(!tmp2empty);
+        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), srcw[count], TMP2, 0);
+        tmp2empty = stackptr >= stacktop;
+        if (!tmp2empty)
+          {
+          OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), stackptr);
+          stackptr += sizeof(sljit_sw);
+          }
+        tmp1next = TRUE;
+        }
+      }
+    }
+  }
+while (status != end);
+
+if (save)
+  {
+  if (tmp1next)
+    {
+    if (!tmp1empty)
+      {
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);
+      stackptr += sizeof(sljit_sw);
+      }
+    if (!tmp2empty)
+      {
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);
+      stackptr += sizeof(sljit_sw);
+      }
+    }
+  else
+    {
+    if (!tmp2empty)
+      {
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP2, 0);
+      stackptr += sizeof(sljit_sw);
+      }
+    if (!tmp1empty)
+      {
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), stackptr, TMP1, 0);
+      stackptr += sizeof(sljit_sw);
+      }
+    }
+  }
+SLJIT_ASSERT(cc == ccend && stackptr == stacktop && (save || (tmp1empty && tmp2empty)));
+}
+
+static SLJIT_INLINE pcre_uchar *set_then_offsets(compiler_common *common, pcre_uchar *cc, sljit_u8 *current_offset)
+{
+pcre_uchar *end = bracketend(cc);
+BOOL has_alternatives = cc[GET(cc, 1)] == OP_ALT;
+
+/* Assert captures then. */
+if (*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT)
+  current_offset = NULL;
+/* Conditional block does not. */
+if (*cc == OP_COND || *cc == OP_SCOND)
+  has_alternatives = FALSE;
+
+cc = next_opcode(common, cc);
+if (has_alternatives)
+  current_offset = common->then_offsets + (cc - common->start);
+
+while (cc < end)
+  {
+  if ((*cc >= OP_ASSERT && *cc <= OP_ASSERTBACK_NOT) || (*cc >= OP_ONCE && *cc <= OP_SCOND))
+    cc = set_then_offsets(common, cc, current_offset);
+  else
+    {
+    if (*cc == OP_ALT && has_alternatives)
+      current_offset = common->then_offsets + (cc + 1 + LINK_SIZE - common->start);
+    if (*cc >= OP_THEN && *cc <= OP_THEN_ARG && current_offset != NULL)
+      *current_offset = 1;
+    cc = next_opcode(common, cc);
+    }
+  }
+
+return end;
+}
+
+#undef CASE_ITERATOR_PRIVATE_DATA_1
+#undef CASE_ITERATOR_PRIVATE_DATA_2A
+#undef CASE_ITERATOR_PRIVATE_DATA_2B
+#undef CASE_ITERATOR_TYPE_PRIVATE_DATA_1
+#undef CASE_ITERATOR_TYPE_PRIVATE_DATA_2A
+#undef CASE_ITERATOR_TYPE_PRIVATE_DATA_2B
+
+static SLJIT_INLINE BOOL is_powerof2(unsigned int value)
+{
+return (value & (value - 1)) == 0;
+}
+
+static SLJIT_INLINE void set_jumps(jump_list *list, struct sljit_label *label)
+{
+while (list)
+  {
+  /* sljit_set_label is clever enough to do nothing
+  if either the jump or the label is NULL. */
+  SET_LABEL(list->jump, label);
+  list = list->next;
+  }
+}
+
+static SLJIT_INLINE void add_jump(struct sljit_compiler *compiler, jump_list **list, struct sljit_jump *jump)
+{
+jump_list *list_item = sljit_alloc_memory(compiler, sizeof(jump_list));
+if (list_item)
+  {
+  list_item->next = *list;
+  list_item->jump = jump;
+  *list = list_item;
+  }
+}
+
+static void add_stub(compiler_common *common, struct sljit_jump *start)
+{
+DEFINE_COMPILER;
+stub_list *list_item = sljit_alloc_memory(compiler, sizeof(stub_list));
+
+if (list_item)
+  {
+  list_item->start = start;
+  list_item->quit = LABEL();
+  list_item->next = common->stubs;
+  common->stubs = list_item;
+  }
+}
+
+static void flush_stubs(compiler_common *common)
+{
+DEFINE_COMPILER;
+stub_list *list_item = common->stubs;
+
+while (list_item)
+  {
+  JUMPHERE(list_item->start);
+  add_jump(compiler, &common->stackalloc, JUMP(SLJIT_FAST_CALL));
+  JUMPTO(SLJIT_JUMP, list_item->quit);
+  list_item = list_item->next;
+  }
+common->stubs = NULL;
+}
+
+static void add_label_addr(compiler_common *common, sljit_uw *update_addr)
+{
+DEFINE_COMPILER;
+label_addr_list *label_addr;
+
+label_addr = sljit_alloc_memory(compiler, sizeof(label_addr_list));
+if (label_addr == NULL)
+  return;
+label_addr->label = LABEL();
+label_addr->update_addr = update_addr;
+label_addr->next = common->label_addrs;
+common->label_addrs = label_addr;
+}
+
+static SLJIT_INLINE void count_match(compiler_common *common)
+{
+DEFINE_COMPILER;
+
+OP2(SLJIT_SUB | SLJIT_SET_Z, COUNT_MATCH, 0, COUNT_MATCH, 0, SLJIT_IMM, 1);
+add_jump(compiler, &common->calllimit, JUMP(SLJIT_ZERO));
+}
+
+static SLJIT_INLINE void allocate_stack(compiler_common *common, int size)
+{
+/* May destroy all locals and registers except TMP2. */
+DEFINE_COMPILER;
+
+SLJIT_ASSERT(size > 0);
+OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_sw));
+#ifdef DESTROY_REGISTERS
+OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 12345);
+OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
+OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);
+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, TMP1, 0);
+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP1, 0);
+#endif
+add_stub(common, CMP(SLJIT_LESS, STACK_TOP, 0, STACK_LIMIT, 0));
+}
+
+static SLJIT_INLINE void free_stack(compiler_common *common, int size)
+{
+DEFINE_COMPILER;
+
+SLJIT_ASSERT(size > 0);
+OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, size * sizeof(sljit_sw));
+}
+
+static sljit_uw * allocate_read_only_data(compiler_common *common, sljit_uw size)
+{
+DEFINE_COMPILER;
+sljit_uw *result;
+
+if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
+  return NULL;
+
+result = (sljit_uw *)SLJIT_MALLOC(size + sizeof(sljit_uw), compiler->allocator_data);
+if (SLJIT_UNLIKELY(result == NULL))
+  {
+  sljit_set_compiler_memory_error(compiler);
+  return NULL;
+  }
+
+*(void**)result = common->read_only_data_head;
+common->read_only_data_head = (void *)result;
+return result + 1;
+}
+
+static void free_read_only_data(void *current, void *allocator_data)
+{
+void *next;
+
+SLJIT_UNUSED_ARG(allocator_data);
+
+while (current != NULL)
+  {
+  next = *(void**)current;
+  SLJIT_FREE(current, allocator_data);
+  current = next;
+  }
+}
+
+static SLJIT_INLINE void reset_ovector(compiler_common *common, int length)
+{
+DEFINE_COMPILER;
+struct sljit_label *loop;
+int i;
+
+/* At this point we can freely use all temporary registers. */
+SLJIT_ASSERT(length > 1);
+/* TMP1 returns with begin - 1. */
+OP2(SLJIT_SUB, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_S0), SLJIT_OFFSETOF(jit_arguments, begin), SLJIT_IMM, IN_UCHARS(1));
+if (length < 8)
+  {
+  for (i = 1; i < length; i++)
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(i), SLJIT_R0, 0);
+  }
+else
+  {
+  if (sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_SUPP | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_R0, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw)) == SLJIT_SUCCESS)
+    {
+    GET_LOCAL_BASE(SLJIT_R1, 0, OVECTOR_START);
+    OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, length - 1);
+    loop = LABEL();
+    sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_STORE | SLJIT_MEM_PRE, SLJIT_R0, SLJIT_MEM1(SLJIT_R1), sizeof(sljit_sw));
+    OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, 1);
+    JUMPTO(SLJIT_NOT_ZERO, loop);
+    }
+  else
+    {
+    GET_LOCAL_BASE(SLJIT_R1, 0, OVECTOR_START + sizeof(sljit_sw));
+    OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_IMM, length - 1);
+    loop = LABEL();
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_R0, 0);
+    OP2(SLJIT_ADD, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, sizeof(sljit_sw));
+    OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, 1);
+    JUMPTO(SLJIT_NOT_ZERO, loop);
+    }
+  }
+}
+
+static SLJIT_INLINE void reset_fast_fail(compiler_common *common)
+{
+DEFINE_COMPILER;
+sljit_s32 i;
+
+SLJIT_ASSERT(common->fast_fail_start_ptr < common->fast_fail_end_ptr);
+
+OP2(SLJIT_SUB, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+for (i = common->fast_fail_start_ptr; i < common->fast_fail_end_ptr; i += sizeof(sljit_sw))
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), i, TMP1, 0);
+}
+
+static SLJIT_INLINE void do_reset_match(compiler_common *common, int length)
+{
+DEFINE_COMPILER;
+struct sljit_label *loop;
+int i;
+
+SLJIT_ASSERT(length > 1);
+/* OVECTOR(1) contains the "string begin - 1" constant. */
+if (length > 2)
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1));
+if (length < 8)
+  {
+  for (i = 2; i < length; i++)
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(i), TMP1, 0);
+  }
+else
+  {
+  if (sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_SUPP | SLJIT_MEM_STORE | SLJIT_MEM_PRE, TMP1, SLJIT_MEM1(TMP2), sizeof(sljit_sw)) == SLJIT_SUCCESS)
+    {
+    GET_LOCAL_BASE(TMP2, 0, OVECTOR_START + sizeof(sljit_sw));
+    OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, length - 2);
+    loop = LABEL();
+    sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_STORE | SLJIT_MEM_PRE, TMP1, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
+    OP2(SLJIT_SUB | SLJIT_SET_Z, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 1);
+    JUMPTO(SLJIT_NOT_ZERO, loop);
+    }
+  else
+    {
+    GET_LOCAL_BASE(TMP2, 0, OVECTOR_START + 2 * sizeof(sljit_sw));
+    OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, length - 2);
+    loop = LABEL();
+    OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, TMP1, 0);
+    OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, sizeof(sljit_sw));
+    OP2(SLJIT_SUB | SLJIT_SET_Z, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 1);
+    JUMPTO(SLJIT_NOT_ZERO, loop);
+    }
+  }
+
+OP1(SLJIT_MOV, STACK_TOP, 0, ARGUMENTS, 0);
+if (common->mark_ptr != 0)
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, SLJIT_IMM, 0);
+if (common->control_head_ptr != 0)
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_IMM, 0);
+OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(jit_arguments, stack));
+OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->start_ptr);
+OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), SLJIT_OFFSETOF(struct sljit_stack, end));
+}
+
+static sljit_sw SLJIT_FUNC do_search_mark(sljit_sw *current, const pcre_uchar *skip_arg)
+{
+while (current != NULL)
+  {
+  switch (current[1])
+    {
+    case type_then_trap:
+    break;
+
+    case type_mark:
+    if (STRCMP_UC_UC(skip_arg, (pcre_uchar *)current[2]) == 0)
+      return current[3];
+    break;
+
+    default:
+    SLJIT_UNREACHABLE();
+    break;
+    }
+  SLJIT_ASSERT(current[0] == 0 || current < (sljit_sw*)current[0]);
+  current = (sljit_sw*)current[0];
+  }
+return 0;
+}
+
+static SLJIT_INLINE void copy_ovector(compiler_common *common, int topbracket)
+{
+DEFINE_COMPILER;
+struct sljit_label *loop;
+struct sljit_jump *early_quit;
+BOOL has_pre;
+
+/* At this point we can freely use all registers. */
+OP1(SLJIT_MOV, SLJIT_S2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1));
+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(1), STR_PTR, 0);
+
+OP1(SLJIT_MOV, SLJIT_R0, 0, ARGUMENTS, 0);
+if (common->mark_ptr != 0)
+  OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);
+OP1(SLJIT_MOV_S32, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, offset_count));
+if (common->mark_ptr != 0)
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, mark_ptr), SLJIT_R2, 0);
+OP2(SLJIT_SUB, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, offsets), SLJIT_IMM, sizeof(int));
+OP1(SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, begin));
+
+has_pre = sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, SLJIT_S1, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw)) == SLJIT_SUCCESS;
+GET_LOCAL_BASE(SLJIT_S0, 0, OVECTOR_START - (has_pre ? sizeof(sljit_sw) : 0));
+
+/* Unlikely, but possible */
+early_quit = CMP(SLJIT_EQUAL, SLJIT_R1, 0, SLJIT_IMM, 0);
+loop = LABEL();
+
+if (has_pre)
+  sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_PRE, SLJIT_S1, SLJIT_MEM1(SLJIT_S0), sizeof(sljit_sw));
+else
+  {
+  OP1(SLJIT_MOV, SLJIT_S1, 0, SLJIT_MEM1(SLJIT_S0), 0);
+  OP2(SLJIT_ADD, SLJIT_S0, 0, SLJIT_S0, 0, SLJIT_IMM, sizeof(sljit_sw));
+  }
+
+OP2(SLJIT_ADD, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, sizeof(int));
+OP2(SLJIT_SUB, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_R0, 0);
+/* Copy the integer value to the output buffer */
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+OP2(SLJIT_ASHR, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_IMM, UCHAR_SHIFT);
+#endif
+
+OP1(SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_R2), 0, SLJIT_S1, 0);
+OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 1);
+JUMPTO(SLJIT_NOT_ZERO, loop);
+JUMPHERE(early_quit);
+
+/* Calculate the return value, which is the maximum ovector value. */
+if (topbracket > 1)
+  {
+  if (sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, SLJIT_R2, SLJIT_MEM1(SLJIT_R0), -(2 * (sljit_sw)sizeof(sljit_sw))) == SLJIT_SUCCESS)
+    {
+    GET_LOCAL_BASE(SLJIT_R0, 0, OVECTOR_START + topbracket * 2 * sizeof(sljit_sw));
+    OP1(SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, topbracket + 1);
+
+    /* OVECTOR(0) is never equal to SLJIT_S2. */
+    loop = LABEL();
+    sljit_emit_mem(compiler, SLJIT_MOV | SLJIT_MEM_PRE, SLJIT_R2, SLJIT_MEM1(SLJIT_R0), -(2 * (sljit_sw)sizeof(sljit_sw)));
+    OP2(SLJIT_SUB, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 1);
+    CMPTO(SLJIT_EQUAL, SLJIT_R2, 0, SLJIT_S2, 0, loop);
+    }
+  else
+    {
+    GET_LOCAL_BASE(SLJIT_R0, 0, OVECTOR_START + (topbracket - 1) * 2 * sizeof(sljit_sw));
+    OP1(SLJIT_MOV, SLJIT_R1, 0, SLJIT_IMM, topbracket + 1);
+
+    /* OVECTOR(0) is never equal to SLJIT_S2. */
+    loop = LABEL();
+    OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R0), 0);
+    OP2(SLJIT_SUB, SLJIT_R0, 0, SLJIT_R0, 0, SLJIT_IMM, 2 * (sljit_sw)sizeof(sljit_sw));
+    OP2(SLJIT_SUB, SLJIT_R1, 0, SLJIT_R1, 0, SLJIT_IMM, 1);
+    CMPTO(SLJIT_EQUAL, SLJIT_R2, 0, SLJIT_S2, 0, loop);
+    }
+  OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_R1, 0);
+  }
+else
+  OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);
+}
+
+static SLJIT_INLINE void return_with_partial_match(compiler_common *common, struct sljit_label *quit)
+{
+DEFINE_COMPILER;
+struct sljit_jump *jump;
+
+SLJIT_COMPILE_ASSERT(STR_END == SLJIT_S1, str_end_must_be_saved_reg2);
+SLJIT_ASSERT(common->start_used_ptr != 0 && common->start_ptr != 0
+  && (common->mode == JIT_PARTIAL_SOFT_COMPILE ? common->hit_start != 0 : common->hit_start == 0));
+
+OP1(SLJIT_MOV, SLJIT_R1, 0, ARGUMENTS, 0);
+OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_PARTIAL);
+OP1(SLJIT_MOV_S32, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, real_offset_count));
+CMPTO(SLJIT_SIG_LESS, SLJIT_R2, 0, SLJIT_IMM, 2, quit);
+
+/* Store match begin and end. */
+OP1(SLJIT_MOV, SLJIT_S0, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, begin));
+OP1(SLJIT_MOV, SLJIT_R1, 0, SLJIT_MEM1(SLJIT_R1), SLJIT_OFFSETOF(jit_arguments, offsets));
+
+jump = CMP(SLJIT_SIG_LESS, SLJIT_R2, 0, SLJIT_IMM, 3);
+OP2(SLJIT_SUB, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_ptr : (common->hit_start + (int)sizeof(sljit_sw)), SLJIT_S0, 0);
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+OP2(SLJIT_ASHR, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, UCHAR_SHIFT);
+#endif
+OP1(SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_R1), 2 * sizeof(int), SLJIT_R2, 0);
+JUMPHERE(jump);
+
+OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), common->mode == JIT_PARTIAL_HARD_COMPILE ? common->start_used_ptr : common->hit_start);
+OP2(SLJIT_SUB, SLJIT_S1, 0, STR_END, 0, SLJIT_S0, 0);
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+OP2(SLJIT_ASHR, SLJIT_S1, 0, SLJIT_S1, 0, SLJIT_IMM, UCHAR_SHIFT);
+#endif
+OP1(SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_R1), sizeof(int), SLJIT_S1, 0);
+
+OP2(SLJIT_SUB, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_S0, 0);
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+OP2(SLJIT_ASHR, SLJIT_R2, 0, SLJIT_R2, 0, SLJIT_IMM, UCHAR_SHIFT);
+#endif
+OP1(SLJIT_MOV_S32, SLJIT_MEM1(SLJIT_R1), 0, SLJIT_R2, 0);
+
+JUMPTO(SLJIT_JUMP, quit);
+}
+
+static SLJIT_INLINE void check_start_used_ptr(compiler_common *common)
+{
+/* May destroy TMP1. */
+DEFINE_COMPILER;
+struct sljit_jump *jump;
+
+if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
+  {
+  /* The value of -1 must be kept for start_used_ptr! */
+  OP2(SLJIT_ADD, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, SLJIT_IMM, 1);
+  /* Jumps if start_used_ptr < STR_PTR, or start_used_ptr == -1. Although overwriting
+  is not necessary if start_used_ptr == STR_PTR, it does not hurt as well. */
+  jump = CMP(SLJIT_LESS_EQUAL, TMP1, 0, STR_PTR, 0);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
+  JUMPHERE(jump);
+  }
+else if (common->mode == JIT_PARTIAL_HARD_COMPILE)
+  {
+  jump = CMP(SLJIT_LESS_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
+  JUMPHERE(jump);
+  }
+}
+
+static SLJIT_INLINE BOOL char_has_othercase(compiler_common *common, pcre_uchar *cc)
+{
+/* Detects if the character has an othercase. */
+unsigned int c;
+
+#ifdef SUPPORT_UTF
+if (common->utf)
+  {
+  GETCHAR(c, cc);
+  if (c > 127)
+    {
+#ifdef SUPPORT_UCP
+    return c != UCD_OTHERCASE(c);
+#else
+    return FALSE;
+#endif
+    }
+#ifndef COMPILE_PCRE8
+  return common->fcc[c] != c;
+#endif
+  }
+else
+#endif
+  c = *cc;
+return MAX_255(c) ? common->fcc[c] != c : FALSE;
+}
+
+static SLJIT_INLINE unsigned int char_othercase(compiler_common *common, unsigned int c)
+{
+/* Returns with the othercase. */
+#ifdef SUPPORT_UTF
+if (common->utf && c > 127)
+  {
+#ifdef SUPPORT_UCP
+  return UCD_OTHERCASE(c);
+#else
+  return c;
+#endif
+  }
+#endif
+return TABLE_GET(c, common->fcc, c);
+}
+
+static unsigned int char_get_othercase_bit(compiler_common *common, pcre_uchar *cc)
+{
+/* Detects if the character and its othercase has only 1 bit difference. */
+unsigned int c, oc, bit;
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+int n;
+#endif
+
+#ifdef SUPPORT_UTF
+if (common->utf)
+  {
+  GETCHAR(c, cc);
+  if (c <= 127)
+    oc = common->fcc[c];
+  else
+    {
+#ifdef SUPPORT_UCP
+    oc = UCD_OTHERCASE(c);
+#else
+    oc = c;
+#endif
+    }
+  }
+else
+  {
+  c = *cc;
+  oc = TABLE_GET(c, common->fcc, c);
+  }
+#else
+c = *cc;
+oc = TABLE_GET(c, common->fcc, c);
+#endif
+
+SLJIT_ASSERT(c != oc);
+
+bit = c ^ oc;
+/* Optimized for English alphabet. */
+if (c <= 127 && bit == 0x20)
+  return (0 << 8) | 0x20;
+
+/* Since c != oc, they must have at least 1 bit difference. */
+if (!is_powerof2(bit))
+  return 0;
+
+#if defined COMPILE_PCRE8
+
+#ifdef SUPPORT_UTF
+if (common->utf && c > 127)
+  {
+  n = GET_EXTRALEN(*cc);
+  while ((bit & 0x3f) == 0)
+    {
+    n--;
+    bit >>= 6;
+    }
+  return (n << 8) | bit;
+  }
+#endif /* SUPPORT_UTF */
+return (0 << 8) | bit;
+
+#elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+
+#ifdef SUPPORT_UTF
+if (common->utf && c > 65535)
+  {
+  if (bit >= (1 << 10))
+    bit >>= 10;
+  else
+    return (bit < 256) ? ((2 << 8) | bit) : ((3 << 8) | (bit >> 8));
+  }
+#endif /* SUPPORT_UTF */
+return (bit < 256) ? ((0 << 8) | bit) : ((1 << 8) | (bit >> 8));
+
+#endif /* COMPILE_PCRE[8|16|32] */
+}
+
+static void check_partial(compiler_common *common, BOOL force)
+{
+/* Checks whether a partial matching is occurred. Does not modify registers. */
+DEFINE_COMPILER;
+struct sljit_jump *jump = NULL;
+
+SLJIT_ASSERT(!force || common->mode != JIT_COMPILE);
+
+if (common->mode == JIT_COMPILE)
+  return;
+
+if (!force)
+  jump = CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
+else if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
+  jump = CMP(SLJIT_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, SLJIT_IMM, -1);
+
+if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);
+else
+  {
+  if (common->partialmatchlabel != NULL)
+    JUMPTO(SLJIT_JUMP, common->partialmatchlabel);
+  else
+    add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));
+  }
+
+if (jump != NULL)
+  JUMPHERE(jump);
+}
+
+static void check_str_end(compiler_common *common, jump_list **end_reached)
+{
+/* Does not affect registers. Usually used in a tight spot. */
+DEFINE_COMPILER;
+struct sljit_jump *jump;
+
+if (common->mode == JIT_COMPILE)
+  {
+  add_jump(compiler, end_reached, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
+  return;
+  }
+
+jump = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);
+if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
+  {
+  add_jump(compiler, end_reached, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0));
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);
+  add_jump(compiler, end_reached, JUMP(SLJIT_JUMP));
+  }
+else
+  {
+  add_jump(compiler, end_reached, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0));
+  if (common->partialmatchlabel != NULL)
+    JUMPTO(SLJIT_JUMP, common->partialmatchlabel);
+  else
+    add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));
+  }
+JUMPHERE(jump);
+}
+
+static void detect_partial_match(compiler_common *common, jump_list **backtracks)
+{
+DEFINE_COMPILER;
+struct sljit_jump *jump;
+
+if (common->mode == JIT_COMPILE)
+  {
+  add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
+  return;
+  }
+
+/* Partial matching mode. */
+jump = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);
+add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0));
+if (common->mode == JIT_PARTIAL_SOFT_COMPILE)
+  {
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);
+  add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
+  }
+else
+  {
+  if (common->partialmatchlabel != NULL)
+    JUMPTO(SLJIT_JUMP, common->partialmatchlabel);
+  else
+    add_jump(compiler, &common->partialmatch, JUMP(SLJIT_JUMP));
+  }
+JUMPHERE(jump);
+}
+
+static void peek_char(compiler_common *common, sljit_u32 max)
+{
+/* Reads the character into TMP1, keeps STR_PTR.
+Does not check STR_END. TMP2 Destroyed. */
+DEFINE_COMPILER;
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+struct sljit_jump *jump;
+#endif
+
+SLJIT_UNUSED_ARG(max);
+
+OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+if (common->utf)
+  {
+  if (max < 128) return;
+
+  jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+  add_jump(compiler, &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
+  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+  JUMPHERE(jump);
+  }
+#endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
+
+#if defined SUPPORT_UTF && defined COMPILE_PCRE16
+if (common->utf)
+  {
+  if (max < 0xd800) return;
+
+  OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);
+  jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
+  /* TMP2 contains the high surrogate. */
+  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+  OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x40);
+  OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 10);
+  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3ff);
+  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+  JUMPHERE(jump);
+  }
+#endif
+}
+
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+
+static BOOL is_char7_bitset(const sljit_u8 *bitset, BOOL nclass)
+{
+/* Tells whether the character codes below 128 are enough
+to determine a match. */
+const sljit_u8 value = nclass ? 0xff : 0;
+const sljit_u8 *end = bitset + 32;
+
+bitset += 16;
+do
+  {
+  if (*bitset++ != value)
+    return FALSE;
+  }
+while (bitset < end);
+return TRUE;
+}
+
+static void read_char7_type(compiler_common *common, BOOL full_read)
+{
+/* Reads the precise character type of a character into TMP1, if the character
+is less than 128. Otherwise it returns with zero. Does not check STR_END. The
+full_read argument tells whether characters above max are accepted or not. */
+DEFINE_COMPILER;
+struct sljit_jump *jump;
+
+SLJIT_ASSERT(common->utf);
+
+OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+
+OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+
+if (full_read)
+  {
+  jump = CMP(SLJIT_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
+  OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+  JUMPHERE(jump);
+  }
+}
+
+#endif /* SUPPORT_UTF && COMPILE_PCRE8 */
+
+static void read_char_range(compiler_common *common, sljit_u32 min, sljit_u32 max, BOOL update_str_ptr)
+{
+/* Reads the precise value of a character into TMP1, if the character is
+between min and max (c >= min && c <= max). Otherwise it returns with a value
+outside the range. Does not check STR_END. */
+DEFINE_COMPILER;
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+struct sljit_jump *jump;
+#endif
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+struct sljit_jump *jump2;
+#endif
+
+SLJIT_UNUSED_ARG(update_str_ptr);
+SLJIT_UNUSED_ARG(min);
+SLJIT_UNUSED_ARG(max);
+SLJIT_ASSERT(min <= max);
+
+OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+if (common->utf)
+  {
+  if (max < 128 && !update_str_ptr) return;
+
+  jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
+  if (min >= 0x10000)
+    {
+    OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xf0);
+    if (update_str_ptr)
+      OP1(SLJIT_MOV_U8, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+    jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0x7);
+    OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
+    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
+    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
+    OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
+    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
+    if (!update_str_ptr)
+      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));
+    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
+    OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
+    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+    JUMPHERE(jump2);
+    if (update_str_ptr)
+      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);
+    }
+  else if (min >= 0x800 && max <= 0xffff)
+    {
+    OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xe0);
+    if (update_str_ptr)
+      OP1(SLJIT_MOV_U8, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+    jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xf);
+    OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
+    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
+    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+    if (!update_str_ptr)
+      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
+    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
+    OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
+    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+    JUMPHERE(jump2);
+    if (update_str_ptr)
+      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);
+    }
+  else if (max >= 0x800)
+    add_jump(compiler, (max < 0x10000) ? &common->utfreadchar16 : &common->utfreadchar, JUMP(SLJIT_FAST_CALL));
+  else if (max < 128)
+    {
+    OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+    }
+  else
+    {
+    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+    if (!update_str_ptr)
+      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+    else
+      OP1(SLJIT_MOV_U8, RETURN_ADDR, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
+    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
+    OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
+    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+    if (update_str_ptr)
+      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, RETURN_ADDR, 0);
+    }
+  JUMPHERE(jump);
+  }
+#endif
+
+#if defined SUPPORT_UTF && defined COMPILE_PCRE16
+if (common->utf)
+  {
+  if (max >= 0x10000)
+    {
+    OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);
+    jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
+    /* TMP2 contains the high surrogate. */
+    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+    OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x40);
+    OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 10);
+    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3ff);
+    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+    JUMPHERE(jump);
+    return;
+    }
+
+  if (max < 0xd800 && !update_str_ptr) return;
+
+  /* Skip low surrogate if necessary. */
+  OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, 0xd800);
+  jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
+  if (update_str_ptr)
+    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+  if (max >= 0xd800)
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0x10000);
+  JUMPHERE(jump);
+  }
+#endif
+}
+
+static SLJIT_INLINE void read_char(compiler_common *common)
+{
+read_char_range(common, 0, READ_CHAR_MAX, TRUE);
+}
+
+static void read_char8_type(compiler_common *common, BOOL update_str_ptr)
+{
+/* Reads the character type into TMP1, updates STR_PTR. Does not check STR_END. */
+DEFINE_COMPILER;
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+struct sljit_jump *jump;
+#endif
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+struct sljit_jump *jump2;
+#endif
+
+SLJIT_UNUSED_ARG(update_str_ptr);
+
+OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), 0);
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+if (common->utf)
+  {
+  /* This can be an extra read in some situations, but hopefully
+  it is needed in most cases. */
+  OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+  jump = CMP(SLJIT_LESS, TMP2, 0, SLJIT_IMM, 0xc0);
+  if (!update_str_ptr)
+    {
+    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+    OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
+    OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
+    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
+    OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
+    jump2 = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 255);
+    OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+    JUMPHERE(jump2);
+    }
+  else
+    add_jump(compiler, &common->utfreadtype8, JUMP(SLJIT_FAST_CALL));
+  JUMPHERE(jump);
+  return;
+  }
+#endif /* SUPPORT_UTF && COMPILE_PCRE8 */
+
+#if !defined COMPILE_PCRE8
+/* The ctypes array contains only 256 values. */
+OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
+jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 255);
+#endif
+OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+#if !defined COMPILE_PCRE8
+JUMPHERE(jump);
+#endif
+
+#if defined SUPPORT_UTF && defined COMPILE_PCRE16
+if (common->utf && update_str_ptr)
+  {
+  /* Skip low surrogate if necessary. */
+  OP2(SLJIT_SUB, TMP2, 0, TMP2, 0, SLJIT_IMM, 0xd800);
+  jump = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0xdc00 - 0xd800 - 1);
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+  JUMPHERE(jump);
+  }
+#endif /* SUPPORT_UTF && COMPILE_PCRE16 */
+}
+
+static void skip_char_back(compiler_common *common)
+{
+/* Goes one character back. Affects STR_PTR and TMP1. Does not check begin. */
+DEFINE_COMPILER;
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+#if defined COMPILE_PCRE8
+struct sljit_label *label;
+
+if (common->utf)
+  {
+  label = LABEL();
+  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -IN_UCHARS(1));
+  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0);
+  CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, label);
+  return;
+  }
+#elif defined COMPILE_PCRE16
+if (common->utf)
+  {
+  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -IN_UCHARS(1));
+  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+  /* Skip low surrogate if necessary. */
+  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
+  OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xdc00);
+  OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_EQUAL);
+  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+  return;
+  }
+#endif /* COMPILE_PCRE[8|16] */
+#endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
+OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+}
+
+static void check_newlinechar(compiler_common *common, int nltype, jump_list **backtracks, BOOL jumpifmatch)
+{
+/* Character comes in TMP1. Checks if it is a newline. TMP2 may be destroyed. */
+DEFINE_COMPILER;
+struct sljit_jump *jump;
+
+if (nltype == NLTYPE_ANY)
+  {
+  add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));
+  sljit_set_current_flags(compiler, SLJIT_SET_Z);
+  add_jump(compiler, backtracks, JUMP(jumpifmatch ? SLJIT_NOT_ZERO : SLJIT_ZERO));
+  }
+else if (nltype == NLTYPE_ANYCRLF)
+  {
+  if (jumpifmatch)
+    {
+    add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR));
+    add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
+    }
+  else
+    {
+    jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
+    add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
+    JUMPHERE(jump);
+    }
+  }
+else
+  {
+  SLJIT_ASSERT(nltype == NLTYPE_FIXED && common->newline < 256);
+  add_jump(compiler, backtracks, CMP(jumpifmatch ? SLJIT_EQUAL : SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
+  }
+}
+
+#ifdef SUPPORT_UTF
+
+#if defined COMPILE_PCRE8
+static void do_utfreadchar(compiler_common *common)
+{
+/* Fast decoding a UTF-8 character. TMP1 contains the first byte
+of the character (>= 0xc0). Return char value in TMP1, length in TMP2. */
+DEFINE_COMPILER;
+struct sljit_jump *jump;
+
+sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
+OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
+OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
+OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
+OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+
+/* Searching for the first zero. */
+OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x800);
+jump = JUMP(SLJIT_NOT_ZERO);
+/* Two byte sequence. */
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(2));
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+
+JUMPHERE(jump);
+OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x800);
+OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
+OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
+OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+
+OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x10000);
+jump = JUMP(SLJIT_NOT_ZERO);
+/* Three byte sequence. */
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
+OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(3));
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+
+/* Four byte sequence. */
+JUMPHERE(jump);
+OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(2));
+OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x10000);
+OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(3));
+OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
+OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, IN_UCHARS(4));
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+}
+
+static void do_utfreadchar16(compiler_common *common)
+{
+/* Fast decoding a UTF-8 character. TMP1 contains the first byte
+of the character (>= 0xc0). Return value in TMP1. */
+DEFINE_COMPILER;
+struct sljit_jump *jump;
+
+sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
+OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
+OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
+OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
+OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+
+/* Searching for the first zero. */
+OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x800);
+jump = JUMP(SLJIT_NOT_ZERO);
+/* Two byte sequence. */
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+
+JUMPHERE(jump);
+OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x400);
+OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_NOT_ZERO);
+/* This code runs only in 8 bit mode. No need to shift the value. */
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+OP2(SLJIT_XOR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x800);
+OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 6);
+OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x3f);
+OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+/* Three byte sequence. */
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+}
+
+static void do_utfreadtype8(compiler_common *common)
+{
+/* Fast decoding a UTF-8 character type. TMP2 contains the first byte
+of the character (>= 0xc0). Return value in TMP1. */
+DEFINE_COMPILER;
+struct sljit_jump *jump;
+struct sljit_jump *compare;
+
+sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
+
+OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, 0x20);
+jump = JUMP(SLJIT_NOT_ZERO);
+/* Two byte sequence. */
+OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 0x1f);
+/* The upper 5 bits are known at this point. */
+compare = CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, 0x3);
+OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 6);
+OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x3f);
+OP2(SLJIT_OR, TMP2, 0, TMP2, 0, TMP1, 0);
+OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP2), common->ctypes);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+
+JUMPHERE(compare);
+OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+
+/* We only have types for characters less than 256. */
+JUMPHERE(jump);
+OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 0);
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+}
+
+#endif /* COMPILE_PCRE8 */
+
+#endif /* SUPPORT_UTF */
+
+#ifdef SUPPORT_UCP
+
+/* UCD_BLOCK_SIZE must be 128 (see the assert below). */
+#define UCD_BLOCK_MASK 127
+#define UCD_BLOCK_SHIFT 7
+
+static void do_getucd(compiler_common *common)
+{
+/* Search the UCD record for the character comes in TMP1.
+Returns chartype in TMP1 and UCD offset in TMP2. */
+DEFINE_COMPILER;
+#ifdef COMPILE_PCRE32
+struct sljit_jump *jump;
+#endif
+
+#if defined SLJIT_DEBUG && SLJIT_DEBUG
+/* dummy_ucd_record */
+const ucd_record *record = GET_UCD(INVALID_UTF_CHAR);
+SLJIT_ASSERT(record->script == ucp_Common && record->chartype == ucp_Cn && record->gbprop == ucp_gbOther);
+SLJIT_ASSERT(record->caseset == 0 && record->other_case == 0);
+#endif
+
+SLJIT_ASSERT(UCD_BLOCK_SIZE == 128 && sizeof(ucd_record) == 8);
+
+sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
+
+#ifdef COMPILE_PCRE32
+if (!common->utf)
+  {
+  jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0x10ffff + 1);
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, INVALID_UTF_CHAR);
+  JUMPHERE(jump);
+  }
+#endif
+
+OP2(SLJIT_LSHR, TMP2, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);
+OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(ucd_stage1));
+OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_MASK);
+OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);
+OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0);
+OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_stage2));
+OP1(SLJIT_MOV_U16, TMP2, 0, SLJIT_MEM2(TMP2, TMP1), 1);
+OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype));
+OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+}
+#endif
+
+static SLJIT_INLINE struct sljit_label *mainloop_entry(compiler_common *common, BOOL hascrorlf)
+{
+DEFINE_COMPILER;
+struct sljit_label *mainloop;
+struct sljit_label *newlinelabel = NULL;
+struct sljit_jump *start;
+struct sljit_jump *end = NULL;
+struct sljit_jump *end2 = NULL;
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+struct sljit_jump *singlechar;
+#endif
+jump_list *newline = NULL;
+BOOL newlinecheck = FALSE;
+BOOL readuchar = FALSE;
+
+if (!(hascrorlf || (common->match_end_ptr != 0)) &&
+    (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF || common->newline > 255))
+  newlinecheck = TRUE;
+
+if (common->match_end_ptr != 0)
+  {
+  /* Search for the end of the first line. */
+  OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);
+
+  if (common->nltype == NLTYPE_FIXED && common->newline > 255)
+    {
+    mainloop = LABEL();
+    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+    end = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));
+    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+    CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, mainloop);
+    CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, mainloop);
+    JUMPHERE(end);
+    OP2(SLJIT_SUB, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+    }
+  else
+    {
+    end = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+    mainloop = LABEL();
+    /* Continual stores does not cause data dependency. */
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr, STR_PTR, 0);
+    read_char_range(common, common->nlmin, common->nlmax, TRUE);
+    check_newlinechar(common, common->nltype, &newline, TRUE);
+    CMPTO(SLJIT_LESS, STR_PTR, 0, STR_END, 0, mainloop);
+    JUMPHERE(end);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr, STR_PTR, 0);
+    set_jumps(newline, LABEL());
+    }
+
+  OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);
+  }
+
+start = JUMP(SLJIT_JUMP);
+
+if (newlinecheck)
+  {
+  newlinelabel = LABEL();
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+  end = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+  OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, common->newline & 0xff);
+  OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_EQUAL);
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);
+#endif
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+  end2 = JUMP(SLJIT_JUMP);
+  }
+
+mainloop = LABEL();
+
+/* Increasing the STR_PTR here requires one less jump in the most common case. */
+#ifdef SUPPORT_UTF
+if (common->utf) readuchar = TRUE;
+#endif
+if (newlinecheck) readuchar = TRUE;
+
+if (readuchar)
+  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+
+if (newlinecheck)
+  CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, newlinelabel);
+
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+#if defined COMPILE_PCRE8
+if (common->utf)
+  {
+  singlechar = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
+  OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+  JUMPHERE(singlechar);
+  }
+#elif defined COMPILE_PCRE16
+if (common->utf)
+  {
+  singlechar = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
+  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
+  OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
+  OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_EQUAL);
+  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+  JUMPHERE(singlechar);
+  }
+#endif /* COMPILE_PCRE[8|16] */
+#endif /* SUPPORT_UTF && !COMPILE_PCRE32 */
+JUMPHERE(start);
+
+if (newlinecheck)
+  {
+  JUMPHERE(end);
+  JUMPHERE(end2);
+  }
+
+return mainloop;
+}
+
+#define MAX_N_CHARS 16
+#define MAX_DIFF_CHARS 6
+
+static SLJIT_INLINE void add_prefix_char(pcre_uchar chr, pcre_uchar *chars)
+{
+pcre_uchar i, len;
+
+len = chars[0];
+if (len == 255)
+  return;
+
+if (len == 0)
+  {
+  chars[0] = 1;
+  chars[1] = chr;
+  return;
+  }
+
+for (i = len; i > 0; i--)
+  if (chars[i] == chr)
+    return;
+
+if (len >= MAX_DIFF_CHARS - 1)
+  {
+  chars[0] = 255;
+  return;
+  }
+
+len++;
+chars[len] = chr;
+chars[0] = len;
+}
+
+static int scan_prefix(compiler_common *common, pcre_uchar *cc, pcre_uchar *chars, int max_chars, sljit_u32 *rec_count)
+{
+/* Recursive function, which scans prefix literals. */
+BOOL last, any, class, caseless;
+int len, repeat, len_save, consumed = 0;
+sljit_u32 chr; /* Any unicode character. */
+sljit_u8 *bytes, *bytes_end, byte;
+pcre_uchar *alternative, *cc_save, *oc;
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+pcre_uchar othercase[8];
+#elif defined SUPPORT_UTF && defined COMPILE_PCRE16
+pcre_uchar othercase[2];
+#else
+pcre_uchar othercase[1];
+#endif
+
+repeat = 1;
+while (TRUE)
+  {
+  if (*rec_count == 0)
+    return 0;
+  (*rec_count)--;
+
+  last = TRUE;
+  any = FALSE;
+  class = FALSE;
+  caseless = FALSE;
+
+  switch (*cc)
+    {
+    case OP_CHARI:
+    caseless = TRUE;
+    case OP_CHAR:
+    last = FALSE;
+    cc++;
+    break;
+
+    case OP_SOD:
+    case OP_SOM:
+    case OP_SET_SOM:
+    case OP_NOT_WORD_BOUNDARY:
+    case OP_WORD_BOUNDARY:
+    case OP_EODN:
+    case OP_EOD:
+    case OP_CIRC:
+    case OP_CIRCM:
+    case OP_DOLL:
+    case OP_DOLLM:
+    /* Zero width assertions. */
+    cc++;
+    continue;
+
+    case OP_ASSERT:
+    case OP_ASSERT_NOT:
+    case OP_ASSERTBACK:
+    case OP_ASSERTBACK_NOT:
+    cc = bracketend(cc);
+    continue;
+
+    case OP_PLUSI:
+    case OP_MINPLUSI:
+    case OP_POSPLUSI:
+    caseless = TRUE;
+    case OP_PLUS:
+    case OP_MINPLUS:
+    case OP_POSPLUS:
+    cc++;
+    break;
+
+    case OP_EXACTI:
+    caseless = TRUE;
+    case OP_EXACT:
+    repeat = GET2(cc, 1);
+    last = FALSE;
+    cc += 1 + IMM2_SIZE;
+    break;
+
+    case OP_QUERYI:
+    case OP_MINQUERYI:
+    case OP_POSQUERYI:
+    caseless = TRUE;
+    case OP_QUERY:
+    case OP_MINQUERY:
+    case OP_POSQUERY:
+    len = 1;
+    cc++;
+#ifdef SUPPORT_UTF
+    if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);
+#endif
+    max_chars = scan_prefix(common, cc + len, chars, max_chars, rec_count);
+    if (max_chars == 0)
+      return consumed;
+    last = FALSE;
+    break;
+
+    case OP_KET:
+    cc += 1 + LINK_SIZE;
+    continue;
+
+    case OP_ALT:
+    cc += GET(cc, 1);
+    continue;
+
+    case OP_ONCE:
+    case OP_ONCE_NC:
+    case OP_BRA:
+    case OP_BRAPOS:
+    case OP_CBRA:
+    case OP_CBRAPOS:
+    alternative = cc + GET(cc, 1);
+    while (*alternative == OP_ALT)
+      {
+      max_chars = scan_prefix(common, alternative + 1 + LINK_SIZE, chars, max_chars, rec_count);
+      if (max_chars == 0)
+        return consumed;
+      alternative += GET(alternative, 1);
+      }
+
+    if (*cc == OP_CBRA || *cc == OP_CBRAPOS)
+      cc += IMM2_SIZE;
+    cc += 1 + LINK_SIZE;
+    continue;
+
+    case OP_CLASS:
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+    if (common->utf && !is_char7_bitset((const sljit_u8 *)(cc + 1), FALSE))
+      return consumed;
+#endif
+    class = TRUE;
+    break;
+
+    case OP_NCLASS:
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+    if (common->utf) return consumed;
+#endif
+    class = TRUE;
+    break;
+
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+    case OP_XCLASS:
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+    if (common->utf) return consumed;
+#endif
+    any = TRUE;
+    cc += GET(cc, 1);
+    break;
+#endif
+
+    case OP_DIGIT:
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+    if (common->utf && !is_char7_bitset((const sljit_u8 *)common->ctypes - cbit_length + cbit_digit, FALSE))
+      return consumed;
+#endif
+    any = TRUE;
+    cc++;
+    break;
+
+    case OP_WHITESPACE:
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+    if (common->utf && !is_char7_bitset((const sljit_u8 *)common->ctypes - cbit_length + cbit_space, FALSE))
+      return consumed;
+#endif
+    any = TRUE;
+    cc++;
+    break;
+
+    case OP_WORDCHAR:
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+    if (common->utf && !is_char7_bitset((const sljit_u8 *)common->ctypes - cbit_length + cbit_word, FALSE))
+      return consumed;
+#endif
+    any = TRUE;
+    cc++;
+    break;
+
+    case OP_NOT:
+    case OP_NOTI:
+    cc++;
+    /* Fall through. */
+    case OP_NOT_DIGIT:
+    case OP_NOT_WHITESPACE:
+    case OP_NOT_WORDCHAR:
+    case OP_ANY:
+    case OP_ALLANY:
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+    if (common->utf) return consumed;
+#endif
+    any = TRUE;
+    cc++;
+    break;
+
+#ifdef SUPPORT_UTF
+    case OP_NOTPROP:
+    case OP_PROP:
+#ifndef COMPILE_PCRE32
+    if (common->utf) return consumed;
+#endif
+    any = TRUE;
+    cc += 1 + 2;
+    break;
+#endif
+
+    case OP_TYPEEXACT:
+    repeat = GET2(cc, 1);
+    cc += 1 + IMM2_SIZE;
+    continue;
+
+    case OP_NOTEXACT:
+    case OP_NOTEXACTI:
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+    if (common->utf) return consumed;
+#endif
+    any = TRUE;
+    repeat = GET2(cc, 1);
+    cc += 1 + IMM2_SIZE + 1;
+    break;
+
+    default:
+    return consumed;
+    }
+
+  if (any)
+    {
+    do
+      {
+      chars[0] = 255;
+
+      consumed++;
+      if (--max_chars == 0)
+        return consumed;
+      chars += MAX_DIFF_CHARS;
+      }
+    while (--repeat > 0);
+
+    repeat = 1;
+    continue;
+    }
+
+  if (class)
+    {
+    bytes = (sljit_u8*) (cc + 1);
+    cc += 1 + 32 / sizeof(pcre_uchar);
+
+    switch (*cc)
+      {
+      case OP_CRSTAR:
+      case OP_CRMINSTAR:
+      case OP_CRPOSSTAR:
+      case OP_CRQUERY:
+      case OP_CRMINQUERY:
+      case OP_CRPOSQUERY:
+      max_chars = scan_prefix(common, cc + 1, chars, max_chars, rec_count);
+      if (max_chars == 0)
+        return consumed;
+      break;
+
+      default:
+      case OP_CRPLUS:
+      case OP_CRMINPLUS:
+      case OP_CRPOSPLUS:
+      break;
+
+      case OP_CRRANGE:
+      case OP_CRMINRANGE:
+      case OP_CRPOSRANGE:
+      repeat = GET2(cc, 1);
+      if (repeat <= 0)
+        return consumed;
+      break;
+      }
+
+    do
+      {
+      if (bytes[31] & 0x80)
+        chars[0] = 255;
+      else if (chars[0] != 255)
+        {
+        bytes_end = bytes + 32;
+        chr = 0;
+        do
+          {
+          byte = *bytes++;
+          SLJIT_ASSERT((chr & 0x7) == 0);
+          if (byte == 0)
+            chr += 8;
+          else
+            {
+            do
+              {
+              if ((byte & 0x1) != 0)
+                add_prefix_char(chr, chars);
+              byte >>= 1;
+              chr++;
+              }
+            while (byte != 0);
+            chr = (chr + 7) & ~7;
+            }
+          }
+        while (chars[0] != 255 && bytes < bytes_end);
+        bytes = bytes_end - 32;
+        }
+
+      consumed++;
+      if (--max_chars == 0)
+        return consumed;
+      chars += MAX_DIFF_CHARS;
+      }
+    while (--repeat > 0);
+
+    switch (*cc)
+      {
+      case OP_CRSTAR:
+      case OP_CRMINSTAR:
+      case OP_CRPOSSTAR:
+      return consumed;
+
+      case OP_CRQUERY:
+      case OP_CRMINQUERY:
+      case OP_CRPOSQUERY:
+      cc++;
+      break;
+
+      case OP_CRRANGE:
+      case OP_CRMINRANGE:
+      case OP_CRPOSRANGE:
+      if (GET2(cc, 1) != GET2(cc, 1 + IMM2_SIZE))
+        return consumed;
+      cc += 1 + 2 * IMM2_SIZE;
+      break;
+      }
+
+    repeat = 1;
+    continue;
+    }
+
+  len = 1;
+#ifdef SUPPORT_UTF
+  if (common->utf && HAS_EXTRALEN(*cc)) len += GET_EXTRALEN(*cc);
+#endif
+
+  if (caseless && char_has_othercase(common, cc))
+    {
+#ifdef SUPPORT_UTF
+    if (common->utf)
+      {
+      GETCHAR(chr, cc);
+      if ((int)PRIV(ord2utf)(char_othercase(common, chr), othercase) != len)
+        return consumed;
+      }
+    else
+#endif
+      {
+      chr = *cc;
+      othercase[0] = TABLE_GET(chr, common->fcc, chr);
+      }
+    }
+  else
+    {
+    caseless = FALSE;
+    othercase[0] = 0; /* Stops compiler warning - PH */
+    }
+
+  len_save = len;
+  cc_save = cc;
+  while (TRUE)
+    {
+    oc = othercase;
+    do
+      {
+      chr = *cc;
+      add_prefix_char(*cc, chars);
+
+      if (caseless)
+        add_prefix_char(*oc, chars);
+
+      len--;
+      consumed++;
+      if (--max_chars == 0)
+        return consumed;
+      chars += MAX_DIFF_CHARS;
+      cc++;
+      oc++;
+      }
+    while (len > 0);
+
+    if (--repeat == 0)
+      break;
+
+    len = len_save;
+    cc = cc_save;
+    }
+
+  repeat = 1;
+  if (last)
+    return consumed;
+  }
+}
+
+#if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) && !(defined SUPPORT_VALGRIND)
+
+static sljit_s32 character_to_int32(pcre_uchar chr)
+{
+sljit_s32 value = (sljit_s32)chr;
+#if defined COMPILE_PCRE8
+#define SSE2_COMPARE_TYPE_INDEX 0
+return (value << 24) | (value << 16) | (value << 8) | value;
+#elif defined COMPILE_PCRE16
+#define SSE2_COMPARE_TYPE_INDEX 1
+return (value << 16) | value;
+#elif defined COMPILE_PCRE32
+#define SSE2_COMPARE_TYPE_INDEX 2
+return value;
+#else
+#error "Unsupported unit width"
+#endif
+}
+
+static SLJIT_INLINE void fast_forward_first_char2_sse2(compiler_common *common, pcre_uchar char1, pcre_uchar char2)
+{
+DEFINE_COMPILER;
+struct sljit_label *start;
+struct sljit_jump *quit[3];
+struct sljit_jump *nomatch;
+sljit_u8 instruction[8];
+sljit_s32 tmp1_ind = sljit_get_register_index(TMP1);
+sljit_s32 tmp2_ind = sljit_get_register_index(TMP2);
+sljit_s32 str_ptr_ind = sljit_get_register_index(STR_PTR);
+BOOL load_twice = FALSE;
+pcre_uchar bit;
+
+bit = char1 ^ char2;
+if (!is_powerof2(bit))
+  bit = 0;
+
+if ((char1 != char2) && bit == 0)
+  load_twice = TRUE;
+
+quit[0] = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+
+/* First part (unaligned start) */
+
+OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, character_to_int32(char1 | bit));
+
+SLJIT_ASSERT(tmp1_ind < 8 && tmp2_ind == 1);
+
+/* MOVD xmm, r/m32 */
+instruction[0] = 0x66;
+instruction[1] = 0x0f;
+instruction[2] = 0x6e;
+instruction[3] = 0xc0 | (2 << 3) | tmp1_ind;
+sljit_emit_op_custom(compiler, instruction, 4);
+
+if (char1 != char2)
+  {
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, character_to_int32(bit != 0 ? bit : char2));
+
+  /* MOVD xmm, r/m32 */
+  instruction[3] = 0xc0 | (3 << 3) | tmp1_ind;
+  sljit_emit_op_custom(compiler, instruction, 4);
+  }
+
+/* PSHUFD xmm1, xmm2/m128, imm8 */
+instruction[2] = 0x70;
+instruction[3] = 0xc0 | (2 << 3) | 2;
+instruction[4] = 0;
+sljit_emit_op_custom(compiler, instruction, 5);
+
+if (char1 != char2)
+  {
+  /* PSHUFD xmm1, xmm2/m128, imm8 */
+  instruction[3] = 0xc0 | (3 << 3) | 3;
+  instruction[4] = 0;
+  sljit_emit_op_custom(compiler, instruction, 5);
+  }
+
+OP2(SLJIT_AND, TMP2, 0, STR_PTR, 0, SLJIT_IMM, 0xf);
+OP2(SLJIT_AND, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, ~0xf);
+
+/* MOVDQA xmm1, xmm2/m128 */
+#if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
+
+if (str_ptr_ind < 8)
+  {
+  instruction[2] = 0x6f;
+  instruction[3] = (0 << 3) | str_ptr_ind;
+  sljit_emit_op_custom(compiler, instruction, 4);
+
+  if (load_twice)
+    {
+    instruction[3] = (1 << 3) | str_ptr_ind;
+    sljit_emit_op_custom(compiler, instruction, 4);
+    }
+  }
+else
+  {
+  instruction[1] = 0x41;
+  instruction[2] = 0x0f;
+  instruction[3] = 0x6f;
+  instruction[4] = (0 << 3) | (str_ptr_ind & 0x7);
+  sljit_emit_op_custom(compiler, instruction, 5);
+
+  if (load_twice)
+    {
+    instruction[4] = (1 << 3) | str_ptr_ind;
+    sljit_emit_op_custom(compiler, instruction, 5);
+    }
+  instruction[1] = 0x0f;
+  }
+
+#else
+
+instruction[2] = 0x6f;
+instruction[3] = (0 << 3) | str_ptr_ind;
+sljit_emit_op_custom(compiler, instruction, 4);
+
+if (load_twice)
+  {
+  instruction[3] = (1 << 3) | str_ptr_ind;
+  sljit_emit_op_custom(compiler, instruction, 4);
+  }
+
+#endif
+
+if (bit != 0)
+  {
+  /* POR xmm1, xmm2/m128 */
+  instruction[2] = 0xeb;
+  instruction[3] = 0xc0 | (0 << 3) | 3;
+  sljit_emit_op_custom(compiler, instruction, 4);
+  }
+
+/* PCMPEQB/W/D xmm1, xmm2/m128 */
+instruction[2] = 0x74 + SSE2_COMPARE_TYPE_INDEX;
+instruction[3] = 0xc0 | (0 << 3) | 2;
+sljit_emit_op_custom(compiler, instruction, 4);
+
+if (load_twice)
+  {
+  instruction[3] = 0xc0 | (1 << 3) | 3;
+  sljit_emit_op_custom(compiler, instruction, 4);
+  }
+
+/* PMOVMSKB reg, xmm */
+instruction[2] = 0xd7;
+instruction[3] = 0xc0 | (tmp1_ind << 3) | 0;
+sljit_emit_op_custom(compiler, instruction, 4);
+
+if (load_twice)
+  {
+  OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP2, 0);
+  instruction[3] = 0xc0 | (tmp2_ind << 3) | 1;
+  sljit_emit_op_custom(compiler, instruction, 4);
+
+  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+  OP1(SLJIT_MOV, TMP2, 0, RETURN_ADDR, 0);
+  }
+
+OP2(SLJIT_ASHR, TMP1, 0, TMP1, 0, TMP2, 0);
+
+/* BSF r32, r/m32 */
+instruction[0] = 0x0f;
+instruction[1] = 0xbc;
+instruction[2] = 0xc0 | (tmp1_ind << 3) | tmp1_ind;
+sljit_emit_op_custom(compiler, instruction, 3);
+sljit_set_current_flags(compiler, SLJIT_SET_Z);
+
+nomatch = JUMP(SLJIT_ZERO);
+
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+quit[1] = JUMP(SLJIT_JUMP);
+
+JUMPHERE(nomatch);
+
+start = LABEL();
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, 16);
+quit[2] = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+
+/* Second part (aligned) */
+
+instruction[0] = 0x66;
+instruction[1] = 0x0f;
+
+/* MOVDQA xmm1, xmm2/m128 */
+#if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
+
+if (str_ptr_ind < 8)
+  {
+  instruction[2] = 0x6f;
+  instruction[3] = (0 << 3) | str_ptr_ind;
+  sljit_emit_op_custom(compiler, instruction, 4);
+
+  if (load_twice)
+    {
+    instruction[3] = (1 << 3) | str_ptr_ind;
+    sljit_emit_op_custom(compiler, instruction, 4);
+    }
+  }
+else
+  {
+  instruction[1] = 0x41;
+  instruction[2] = 0x0f;
+  instruction[3] = 0x6f;
+  instruction[4] = (0 << 3) | (str_ptr_ind & 0x7);
+  sljit_emit_op_custom(compiler, instruction, 5);
+
+  if (load_twice)
+    {
+    instruction[4] = (1 << 3) | str_ptr_ind;
+    sljit_emit_op_custom(compiler, instruction, 5);
+    }
+  instruction[1] = 0x0f;
+  }
+
+#else
+
+instruction[2] = 0x6f;
+instruction[3] = (0 << 3) | str_ptr_ind;
+sljit_emit_op_custom(compiler, instruction, 4);
+
+if (load_twice)
+  {
+  instruction[3] = (1 << 3) | str_ptr_ind;
+  sljit_emit_op_custom(compiler, instruction, 4);
+  }
+
+#endif
+
+if (bit != 0)
+  {
+  /* POR xmm1, xmm2/m128 */
+  instruction[2] = 0xeb;
+  instruction[3] = 0xc0 | (0 << 3) | 3;
+  sljit_emit_op_custom(compiler, instruction, 4);
+  }
+
+/* PCMPEQB/W/D xmm1, xmm2/m128 */
+instruction[2] = 0x74 + SSE2_COMPARE_TYPE_INDEX;
+instruction[3] = 0xc0 | (0 << 3) | 2;
+sljit_emit_op_custom(compiler, instruction, 4);
+
+if (load_twice)
+  {
+  instruction[3] = 0xc0 | (1 << 3) | 3;
+  sljit_emit_op_custom(compiler, instruction, 4);
+  }
+
+/* PMOVMSKB reg, xmm */
+instruction[2] = 0xd7;
+instruction[3] = 0xc0 | (tmp1_ind << 3) | 0;
+sljit_emit_op_custom(compiler, instruction, 4);
+
+if (load_twice)
+  {
+  instruction[3] = 0xc0 | (tmp2_ind << 3) | 1;
+  sljit_emit_op_custom(compiler, instruction, 4);
+
+  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, TMP2, 0);
+  }
+
+/* BSF r32, r/m32 */
+instruction[0] = 0x0f;
+instruction[1] = 0xbc;
+instruction[2] = 0xc0 | (tmp1_ind << 3) | tmp1_ind;
+sljit_emit_op_custom(compiler, instruction, 3);
+sljit_set_current_flags(compiler, SLJIT_SET_Z);
+
+JUMPTO(SLJIT_ZERO, start);
+
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+
+start = LABEL();
+SET_LABEL(quit[0], start);
+SET_LABEL(quit[1], start);
+SET_LABEL(quit[2], start);
+}
+
+#undef SSE2_COMPARE_TYPE_INDEX
+
+#endif
+
+static void fast_forward_first_char2(compiler_common *common, pcre_uchar char1, pcre_uchar char2, sljit_s32 offset)
+{
+DEFINE_COMPILER;
+struct sljit_label *start;
+struct sljit_jump *quit;
+struct sljit_jump *found;
+pcre_uchar mask;
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+struct sljit_label *utf_start = NULL;
+struct sljit_jump *utf_quit = NULL;
+#endif
+BOOL has_match_end = (common->match_end_ptr != 0);
+
+if (offset > 0)
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(offset));
+
+if (has_match_end)
+  {
+  OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
+
+  OP2(SLJIT_ADD, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr, SLJIT_IMM, IN_UCHARS(offset + 1));
+  OP2(SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_UNUSED, 0, STR_END, 0, TMP3, 0);
+  sljit_emit_cmov(compiler, SLJIT_GREATER, STR_END, TMP3, 0);
+  }
+
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+if (common->utf && offset > 0)
+  utf_start = LABEL();
+#endif
+
+#if (defined SLJIT_CONFIG_X86 && SLJIT_CONFIG_X86) && !(defined SUPPORT_VALGRIND)
+
+/* SSE2 accelerated first character search. */
+
+if (sljit_has_cpu_feature(SLJIT_HAS_SSE2))
+  {
+  fast_forward_first_char2_sse2(common, char1, char2);
+
+  SLJIT_ASSERT(common->mode == JIT_COMPILE || offset == 0);
+  if (common->mode == JIT_COMPILE)
+    {
+    /* In complete mode, we don't need to run a match when STR_PTR == STR_END. */
+    SLJIT_ASSERT(common->forced_quit_label == NULL);
+    OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);
+    add_jump(compiler, &common->forced_quit, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
+
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+    if (common->utf && offset > 0)
+      {
+      SLJIT_ASSERT(common->mode == JIT_COMPILE);
+
+      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-offset));
+      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+#if defined COMPILE_PCRE8
+      OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0);
+      CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, utf_start);
+#elif defined COMPILE_PCRE16
+      OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
+      CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0xdc00, utf_start);
+#else
+#error "Unknown code width"
+#endif
+      OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+      }
+#endif
+
+    if (offset > 0)
+      OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(offset));
+    }
+  else
+    {
+    OP2(SLJIT_SUB | SLJIT_SET_GREATER_EQUAL, SLJIT_UNUSED, 0, STR_PTR, 0, STR_END, 0);
+    if (has_match_end)
+      {
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);
+      sljit_emit_cmov(compiler, SLJIT_GREATER_EQUAL, STR_PTR, TMP1, 0);
+      }
+    else
+      sljit_emit_cmov(compiler, SLJIT_GREATER_EQUAL, STR_PTR, STR_END, 0);
+    }
+
+  if (has_match_end)
+    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
+  return;
+  }
+
+#endif
+
+quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+
+start = LABEL();
+OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+
+if (char1 == char2)
+  found = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, char1);
+else
+  {
+  mask = char1 ^ char2;
+  if (is_powerof2(mask))
+    {
+    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, mask);
+    found = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, char1 | mask);
+    }
+  else
+    {
+    OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, char1);
+    OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_EQUAL);
+    OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, char2);
+    OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_EQUAL);
+    found = JUMP(SLJIT_NOT_ZERO);
+    }
+  }
+
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+CMPTO(SLJIT_LESS, STR_PTR, 0, STR_END, 0, start);
+
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+if (common->utf && offset > 0)
+  utf_quit = JUMP(SLJIT_JUMP);
+#endif
+
+JUMPHERE(found);
+
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+if (common->utf && offset > 0)
+  {
+  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-offset));
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+#if defined COMPILE_PCRE8
+  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0);
+  CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, utf_start);
+#elif defined COMPILE_PCRE16
+  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
+  CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0xdc00, utf_start);
+#else
+#error "Unknown code width"
+#endif
+  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+  JUMPHERE(utf_quit);
+  }
+#endif
+
+JUMPHERE(quit);
+
+if (has_match_end)
+  {
+  quit = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);
+  OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);
+  if (offset > 0)
+    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(offset));
+  JUMPHERE(quit);
+  OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
+  }
+
+if (offset > 0)
+  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(offset));
+}
+
+static SLJIT_INLINE BOOL fast_forward_first_n_chars(compiler_common *common)
+{
+DEFINE_COMPILER;
+struct sljit_label *start;
+struct sljit_jump *quit;
+struct sljit_jump *match;
+/* bytes[0] represent the number of characters between 0
+and MAX_N_BYTES - 1, 255 represents any character. */
+pcre_uchar chars[MAX_N_CHARS * MAX_DIFF_CHARS];
+sljit_s32 offset;
+pcre_uchar mask;
+pcre_uchar *char_set, *char_set_end;
+int i, max, from;
+int range_right = -1, range_len;
+sljit_u8 *update_table = NULL;
+BOOL in_range;
+sljit_u32 rec_count;
+
+for (i = 0; i < MAX_N_CHARS; i++)
+  chars[i * MAX_DIFF_CHARS] = 0;
+
+rec_count = 10000;
+max = scan_prefix(common, common->start, chars, MAX_N_CHARS, &rec_count);
+
+if (max < 1)
+  return FALSE;
+
+in_range = FALSE;
+/* Prevent compiler "uninitialized" warning */
+from = 0;
+range_len = 4 /* minimum length */ - 1;
+for (i = 0; i <= max; i++)
+  {
+  if (in_range && (i - from) > range_len && (chars[(i - 1) * MAX_DIFF_CHARS] < 255))
+    {
+    range_len = i - from;
+    range_right = i - 1;
+    }
+
+  if (i < max && chars[i * MAX_DIFF_CHARS] < 255)
+    {
+    SLJIT_ASSERT(chars[i * MAX_DIFF_CHARS] > 0);
+    if (!in_range)
+      {
+      in_range = TRUE;
+      from = i;
+      }
+    }
+  else
+    in_range = FALSE;
+  }
+
+if (range_right >= 0)
+  {
+  update_table = (sljit_u8 *)allocate_read_only_data(common, 256);
+  if (update_table == NULL)
+    return TRUE;
+  memset(update_table, IN_UCHARS(range_len), 256);
+
+  for (i = 0; i < range_len; i++)
+    {
+    char_set = chars + ((range_right - i) * MAX_DIFF_CHARS);
+    SLJIT_ASSERT(char_set[0] > 0 && char_set[0] < 255);
+    char_set_end = char_set + char_set[0];
+    char_set++;
+    while (char_set <= char_set_end)
+      {
+      if (update_table[(*char_set) & 0xff] > IN_UCHARS(i))
+        update_table[(*char_set) & 0xff] = IN_UCHARS(i);
+      char_set++;
+      }
+    }
+  }
+
+offset = -1;
+/* Scan forward. */
+for (i = 0; i < max; i++)
+  {
+  if (offset == -1)
+    {
+    if (chars[i * MAX_DIFF_CHARS] <= 2)
+      offset = i;
+    }
+  else if (chars[offset * MAX_DIFF_CHARS] == 2 && chars[i * MAX_DIFF_CHARS] <= 2)
+    {
+    if (chars[i * MAX_DIFF_CHARS] == 1)
+      offset = i;
+    else
+      {
+      mask = chars[offset * MAX_DIFF_CHARS + 1] ^ chars[offset * MAX_DIFF_CHARS + 2];
+      if (!is_powerof2(mask))
+        {
+        mask = chars[i * MAX_DIFF_CHARS + 1] ^ chars[i * MAX_DIFF_CHARS + 2];
+        if (is_powerof2(mask))
+          offset = i;
+        }
+      }
+    }
+  }
+
+if (range_right < 0)
+  {
+  if (offset < 0)
+    return FALSE;
+  SLJIT_ASSERT(chars[offset * MAX_DIFF_CHARS] >= 1 && chars[offset * MAX_DIFF_CHARS] <= 2);
+  /* Works regardless the value is 1 or 2. */
+  mask = chars[offset * MAX_DIFF_CHARS + chars[offset * MAX_DIFF_CHARS]];
+  fast_forward_first_char2(common, chars[offset * MAX_DIFF_CHARS + 1], mask, offset);
+  return TRUE;
+  }
+
+if (range_right == offset)
+  offset = -1;
+
+SLJIT_ASSERT(offset == -1 || (chars[offset * MAX_DIFF_CHARS] >= 1 && chars[offset * MAX_DIFF_CHARS] <= 2));
+
+max -= 1;
+SLJIT_ASSERT(max > 0);
+if (common->match_end_ptr != 0)
+  {
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);
+  OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
+  OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max));
+  quit = CMP(SLJIT_LESS_EQUAL, STR_END, 0, TMP1, 0);
+  OP1(SLJIT_MOV, STR_END, 0, TMP1, 0);
+  JUMPHERE(quit);
+  }
+else
+  OP2(SLJIT_SUB, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max));
+
+SLJIT_ASSERT(range_right >= 0);
+
+#if !(defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
+OP1(SLJIT_MOV, RETURN_ADDR, 0, SLJIT_IMM, (sljit_sw)update_table);
+#endif
+
+start = LABEL();
+quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+
+#if defined COMPILE_PCRE8 || (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)
+OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(range_right));
+#else
+OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(range_right + 1) - 1);
+#endif
+
+#if !(defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)
+OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(RETURN_ADDR, TMP1), 0);
+#else
+OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)update_table);
+#endif
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, start);
+
+if (offset >= 0)
+  {
+  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(offset));
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+
+  if (chars[offset * MAX_DIFF_CHARS] == 1)
+    CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[offset * MAX_DIFF_CHARS + 1], start);
+  else
+    {
+    mask = chars[offset * MAX_DIFF_CHARS + 1] ^ chars[offset * MAX_DIFF_CHARS + 2];
+    if (is_powerof2(mask))
+      {
+      OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, mask);
+      CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[offset * MAX_DIFF_CHARS + 1] | mask, start);
+      }
+    else
+      {
+      match = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, chars[offset * MAX_DIFF_CHARS + 1]);
+      CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, chars[offset * MAX_DIFF_CHARS + 2], start);
+      JUMPHERE(match);
+      }
+    }
+  }
+
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+if (common->utf && offset != 0)
+  {
+  if (offset < 0)
+    {
+    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+    }
+  else
+    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));
+#if defined COMPILE_PCRE8
+  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xc0);
+  CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0x80, start);
+#elif defined COMPILE_PCRE16
+  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
+  CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0xdc00, start);
+#else
+#error "Unknown code width"
+#endif
+  if (offset < 0)
+    OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+  }
+#endif
+
+if (offset >= 0)
+  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+
+JUMPHERE(quit);
+
+if (common->match_end_ptr != 0)
+  {
+  if (range_right >= 0)
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);
+  OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
+  if (range_right >= 0)
+    {
+    quit = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP1, 0);
+    OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0);
+    JUMPHERE(quit);
+    }
+  }
+else
+  OP2(SLJIT_ADD, STR_END, 0, STR_END, 0, SLJIT_IMM, IN_UCHARS(max));
+return TRUE;
+}
+
+#undef MAX_N_CHARS
+#undef MAX_DIFF_CHARS
+
+static SLJIT_INLINE void fast_forward_first_char(compiler_common *common, pcre_uchar first_char, BOOL caseless)
+{
+pcre_uchar oc;
+
+oc = first_char;
+if (caseless)
+  {
+  oc = TABLE_GET(first_char, common->fcc, first_char);
+#if defined SUPPORT_UCP && !defined COMPILE_PCRE8
+  if (first_char > 127 && common->utf)
+    oc = UCD_OTHERCASE(first_char);
+#endif
+  }
+
+fast_forward_first_char2(common, first_char, oc, 0);
+}
+
+static SLJIT_INLINE void fast_forward_newline(compiler_common *common)
+{
+DEFINE_COMPILER;
+struct sljit_label *loop;
+struct sljit_jump *lastchar;
+struct sljit_jump *firstchar;
+struct sljit_jump *quit;
+struct sljit_jump *foundcr = NULL;
+struct sljit_jump *notfoundnl;
+jump_list *newline = NULL;
+
+if (common->match_end_ptr != 0)
+  {
+  OP1(SLJIT_MOV, TMP3, 0, STR_END, 0);
+  OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);
+  }
+
+if (common->nltype == NLTYPE_FIXED && common->newline > 255)
+  {
+  lastchar = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
+  firstchar = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP2, 0);
+
+  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(2));
+  OP2(SLJIT_SUB | SLJIT_SET_GREATER_EQUAL, SLJIT_UNUSED, 0, STR_PTR, 0, TMP1, 0);
+  OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_GREATER_EQUAL);
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+  OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCHAR_SHIFT);
+#endif
+  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+
+  loop = LABEL();
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+  quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2));
+  OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));
+  CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff, loop);
+  CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff, loop);
+
+  JUMPHERE(quit);
+  JUMPHERE(firstchar);
+  JUMPHERE(lastchar);
+
+  if (common->match_end_ptr != 0)
+    OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
+  return;
+  }
+
+OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
+OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
+firstchar = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP2, 0);
+skip_char_back(common);
+
+loop = LABEL();
+common->ff_newline_shortcut = loop;
+
+read_char_range(common, common->nlmin, common->nlmax, TRUE);
+lastchar = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)
+  foundcr = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
+check_newlinechar(common, common->nltype, &newline, FALSE);
+set_jumps(newline, loop);
+
+if (common->nltype == NLTYPE_ANY || common->nltype == NLTYPE_ANYCRLF)
+  {
+  quit = JUMP(SLJIT_JUMP);
+  JUMPHERE(foundcr);
+  notfoundnl = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+  OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, CHAR_NL);
+  OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_EQUAL);
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, UCHAR_SHIFT);
+#endif
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+  JUMPHERE(notfoundnl);
+  JUMPHERE(quit);
+  }
+JUMPHERE(lastchar);
+JUMPHERE(firstchar);
+
+if (common->match_end_ptr != 0)
+  OP1(SLJIT_MOV, STR_END, 0, TMP3, 0);
+}
+
+static BOOL check_class_ranges(compiler_common *common, const sljit_u8 *bits, BOOL nclass, BOOL invert, jump_list **backtracks);
+
+static SLJIT_INLINE void fast_forward_start_bits(compiler_common *common, const sljit_u8 *start_bits)
+{
+DEFINE_COMPILER;
+struct sljit_label *start;
+struct sljit_jump *quit;
+struct sljit_jump *found = NULL;
+jump_list *matches = NULL;
+#ifndef COMPILE_PCRE8
+struct sljit_jump *jump;
+#endif
+
+if (common->match_end_ptr != 0)
+  {
+  OP1(SLJIT_MOV, RETURN_ADDR, 0, STR_END, 0);
+  OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);
+  }
+
+start = LABEL();
+quit = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+#ifdef SUPPORT_UTF
+if (common->utf)
+  OP1(SLJIT_MOV, TMP3, 0, TMP1, 0);
+#endif
+
+if (!check_class_ranges(common, start_bits, (start_bits[31] & 0x80) != 0, TRUE, &matches))
+  {
+#ifndef COMPILE_PCRE8
+  jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 255);
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, 255);
+  JUMPHERE(jump);
+#endif
+  OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
+  OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
+  OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)start_bits);
+  OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
+  OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
+  found = JUMP(SLJIT_NOT_ZERO);
+  }
+
+#ifdef SUPPORT_UTF
+if (common->utf)
+  OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
+#endif
+OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+#ifdef SUPPORT_UTF
+#if defined COMPILE_PCRE8
+if (common->utf)
+  {
+  CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0, start);
+  OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+  }
+#elif defined COMPILE_PCRE16
+if (common->utf)
+  {
+  CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xd800, start);
+  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
+  OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
+  OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_EQUAL);
+  OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+  }
+#endif /* COMPILE_PCRE[8|16] */
+#endif /* SUPPORT_UTF */
+JUMPTO(SLJIT_JUMP, start);
+if (found != NULL)
+  JUMPHERE(found);
+if (matches != NULL)
+  set_jumps(matches, LABEL());
+JUMPHERE(quit);
+
+if (common->match_end_ptr != 0)
+  OP1(SLJIT_MOV, STR_END, 0, RETURN_ADDR, 0);
+}
+
+static SLJIT_INLINE struct sljit_jump *search_requested_char(compiler_common *common, pcre_uchar req_char, BOOL caseless, BOOL has_firstchar)
+{
+DEFINE_COMPILER;
+struct sljit_label *loop;
+struct sljit_jump *toolong;
+struct sljit_jump *alreadyfound;
+struct sljit_jump *found;
+struct sljit_jump *foundoc = NULL;
+struct sljit_jump *notfound;
+sljit_u32 oc, bit;
+
+SLJIT_ASSERT(common->req_char_ptr != 0);
+OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->req_char_ptr);
+OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, REQ_BYTE_MAX);
+toolong = CMP(SLJIT_LESS, TMP1, 0, STR_END, 0);
+alreadyfound = CMP(SLJIT_LESS, STR_PTR, 0, TMP2, 0);
+
+if (has_firstchar)
+  OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+else
+  OP1(SLJIT_MOV, TMP1, 0, STR_PTR, 0);
+
+loop = LABEL();
+notfound = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, STR_END, 0);
+
+OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(TMP1), 0);
+oc = req_char;
+if (caseless)
+  {
+  oc = TABLE_GET(req_char, common->fcc, req_char);
+#if defined SUPPORT_UCP && !(defined COMPILE_PCRE8)
+  if (req_char > 127 && common->utf)
+    oc = UCD_OTHERCASE(req_char);
+#endif
+  }
+if (req_char == oc)
+  found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char);
+else
+  {
+  bit = req_char ^ oc;
+  if (is_powerof2(bit))
+    {
+    OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, bit);
+    found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char | bit);
+    }
+  else
+    {
+    found = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, req_char);
+    foundoc = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, oc);
+    }
+  }
+OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));
+JUMPTO(SLJIT_JUMP, loop);
+
+JUMPHERE(found);
+if (foundoc)
+  JUMPHERE(foundoc);
+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->req_char_ptr, TMP1, 0);
+JUMPHERE(alreadyfound);
+JUMPHERE(toolong);
+return notfound;
+}
+
+static void do_revertframes(compiler_common *common)
+{
+DEFINE_COMPILER;
+struct sljit_jump *jump;
+struct sljit_label *mainloop;
+
+sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
+OP1(SLJIT_MOV, TMP3, 0, STACK_TOP, 0);
+GET_LOCAL_BASE(TMP1, 0, 0);
+
+/* Drop frames until we reach STACK_TOP. */
+mainloop = LABEL();
+OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), -sizeof(sljit_sw));
+jump = CMP(SLJIT_SIG_LESS_EQUAL, TMP2, 0, SLJIT_IMM, 0);
+
+OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP1, 0);
+OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(STACK_TOP), -2 * sizeof(sljit_sw));
+OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), sizeof(sljit_sw), SLJIT_MEM1(STACK_TOP), -3 * sizeof(sljit_sw));
+OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 3 * sizeof(sljit_sw));
+JUMPTO(SLJIT_JUMP, mainloop);
+
+JUMPHERE(jump);
+jump = CMP(SLJIT_NOT_ZERO /* SIG_LESS */, TMP2, 0, SLJIT_IMM, 0);
+/* End of reverting values. */
+OP1(SLJIT_MOV, STACK_TOP, 0, TMP3, 0);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+
+JUMPHERE(jump);
+OP1(SLJIT_NEG, TMP2, 0, TMP2, 0);
+OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, TMP1, 0);
+OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), 0, SLJIT_MEM1(STACK_TOP), -2 * sizeof(sljit_sw));
+OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 2 * sizeof(sljit_sw));
+JUMPTO(SLJIT_JUMP, mainloop);
+}
+
+static void check_wordboundary(compiler_common *common)
+{
+DEFINE_COMPILER;
+struct sljit_jump *skipread;
+jump_list *skipread_list = NULL;
+#if !(defined COMPILE_PCRE8) || defined SUPPORT_UTF
+struct sljit_jump *jump;
+#endif
+
+SLJIT_COMPILE_ASSERT(ctype_word == 0x10, ctype_word_must_be_16);
+
+sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0);
+/* Get type of the previous char, and put it to LOCALS1. */
+OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
+OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, SLJIT_IMM, 0);
+skipread = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP1, 0);
+skip_char_back(common);
+check_start_used_ptr(common);
+read_char(common);
+
+/* Testing char type. */
+#ifdef SUPPORT_UCP
+if (common->use_ucp)
+  {
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);
+  jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);
+  add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
+  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);
+  OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);
+  OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_LESS_EQUAL);
+  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);
+  OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);
+  OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_LESS_EQUAL);
+  JUMPHERE(jump);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP2, 0);
+  }
+else
+#endif
+  {
+#ifndef COMPILE_PCRE8
+  jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
+#elif defined SUPPORT_UTF
+  /* Here LOCALS1 has already been zeroed. */
+  jump = NULL;
+  if (common->utf)
+    jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
+#endif /* COMPILE_PCRE8 */
+  OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), common->ctypes);
+  OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 4 /* ctype_word */);
+  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, TMP1, 0);
+#ifndef COMPILE_PCRE8
+  JUMPHERE(jump);
+#elif defined SUPPORT_UTF
+  if (jump != NULL)
+    JUMPHERE(jump);
+#endif /* COMPILE_PCRE8 */
+  }
+JUMPHERE(skipread);
+
+OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
+check_str_end(common, &skipread_list);
+peek_char(common, READ_CHAR_MAX);
+
+/* Testing char type. This is a code duplication. */
+#ifdef SUPPORT_UCP
+if (common->use_ucp)
+  {
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 1);
+  jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_UNDERSCORE);
+  add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
+  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Ll);
+  OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);
+  OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_LESS_EQUAL);
+  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ucp_Nd - ucp_Ll);
+  OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ucp_No - ucp_Nd);
+  OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_LESS_EQUAL);
+  JUMPHERE(jump);
+  }
+else
+#endif
+  {
+#ifndef COMPILE_PCRE8
+  /* TMP2 may be destroyed by peek_char. */
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
+  jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
+#elif defined SUPPORT_UTF
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, 0);
+  jump = NULL;
+  if (common->utf)
+    jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
+#endif
+  OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP1), common->ctypes);
+  OP2(SLJIT_LSHR, TMP2, 0, TMP2, 0, SLJIT_IMM, 4 /* ctype_word */);
+  OP2(SLJIT_AND, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
+#ifndef COMPILE_PCRE8
+  JUMPHERE(jump);
+#elif defined SUPPORT_UTF
+  if (jump != NULL)
+    JUMPHERE(jump);
+#endif /* COMPILE_PCRE8 */
+  }
+set_jumps(skipread_list, LABEL());
+
+OP2(SLJIT_XOR | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1);
+sljit_emit_fast_return(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0);
+}
+
+static BOOL check_class_ranges(compiler_common *common, const sljit_u8 *bits, BOOL nclass, BOOL invert, jump_list **backtracks)
+{
+/* May destroy TMP1. */
+DEFINE_COMPILER;
+int ranges[MAX_RANGE_SIZE];
+sljit_u8 bit, cbit, all;
+int i, byte, length = 0;
+
+bit = bits[0] & 0x1;
+/* All bits will be zero or one (since bit is zero or one). */
+all = -bit;
+
+for (i = 0; i < 256; )
+  {
+  byte = i >> 3;
+  if ((i & 0x7) == 0 && bits[byte] == all)
+    i += 8;
+  else
+    {
+    cbit = (bits[byte] >> (i & 0x7)) & 0x1;
+    if (cbit != bit)
+      {
+      if (length >= MAX_RANGE_SIZE)
+        return FALSE;
+      ranges[length] = i;
+      length++;
+      bit = cbit;
+      all = -cbit;
+      }
+    i++;
+    }
+  }
+
+if (((bit == 0) && nclass) || ((bit == 1) && !nclass))
+  {
+  if (length >= MAX_RANGE_SIZE)
+    return FALSE;
+  ranges[length] = 256;
+  length++;
+  }
+
+if (length < 0 || length > 4)
+  return FALSE;
+
+bit = bits[0] & 0x1;
+if (invert) bit ^= 0x1;
+
+/* No character is accepted. */
+if (length == 0 && bit == 0)
+  add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
+
+switch(length)
+  {
+  case 0:
+  /* When bit != 0, all characters are accepted. */
+  return TRUE;
+
+  case 1:
+  add_jump(compiler, backtracks, CMP(bit == 0 ? SLJIT_LESS : SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
+  return TRUE;
+
+  case 2:
+  if (ranges[0] + 1 != ranges[1])
+    {
+    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
+    add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_LESS : SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
+    }
+  else
+    add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_EQUAL : SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
+  return TRUE;
+
+  case 3:
+  if (bit != 0)
+    {
+    add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));
+    if (ranges[0] + 1 != ranges[1])
+      {
+      OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
+      add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
+      }
+    else
+      add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
+    return TRUE;
+    }
+
+  add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[0]));
+  if (ranges[1] + 1 != ranges[2])
+    {
+    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[1]);
+    add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[1]));
+    }
+  else
+    add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1]));
+  return TRUE;
+
+  case 4:
+  if ((ranges[1] - ranges[0]) == (ranges[3] - ranges[2])
+      && (ranges[0] | (ranges[2] - ranges[0])) == ranges[2]
+      && (ranges[1] & (ranges[2] - ranges[0])) == 0
+      && is_powerof2(ranges[2] - ranges[0]))
+    {
+    SLJIT_ASSERT((ranges[0] & (ranges[2] - ranges[0])) == 0 && (ranges[2] & ranges[3] & (ranges[2] - ranges[0])) != 0);
+    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[0]);
+    if (ranges[2] + 1 != ranges[3])
+      {
+      OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2]);
+      add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_LESS : SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2]));
+      }
+    else
+      add_jump(compiler, backtracks, CMP(bit != 0 ? SLJIT_EQUAL : SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2]));
+    return TRUE;
+    }
+
+  if (bit != 0)
+    {
+    i = 0;
+    if (ranges[0] + 1 != ranges[1])
+      {
+      OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
+      add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
+      i = ranges[0];
+      }
+    else
+      add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[0]));
+
+    if (ranges[2] + 1 != ranges[3])
+      {
+      OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[2] - i);
+      add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[2]));
+      }
+    else
+      add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[2] - i));
+    return TRUE;
+    }
+
+  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[0]);
+  add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, ranges[3] - ranges[0]));
+  if (ranges[1] + 1 != ranges[2])
+    {
+    OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]);
+    add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, ranges[2] - ranges[1]));
+    }
+  else
+    add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, ranges[1] - ranges[0]));
+  return TRUE;
+
+  default:
+  SLJIT_UNREACHABLE();
+  return FALSE;
+  }
+}
+
+static void check_anynewline(compiler_common *common)
+{
+/* Check whether TMP1 contains a newline character. TMP2 destroyed. */
+DEFINE_COMPILER;
+
+sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
+
+OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);
+OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);
+OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_LESS_EQUAL);
+OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);
+#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+#ifdef COMPILE_PCRE8
+if (common->utf)
+  {
+#endif
+  OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);
+  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);
+  OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);
+#ifdef COMPILE_PCRE8
+  }
+#endif
+#endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */
+OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_EQUAL);
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+}
+
+static void check_hspace(compiler_common *common)
+{
+/* Check whether TMP1 contains a newline character. TMP2 destroyed. */
+DEFINE_COMPILER;
+
+sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
+
+OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x09);
+OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_EQUAL);
+OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x20);
+OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);
+OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xa0);
+#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+#ifdef COMPILE_PCRE8
+if (common->utf)
+  {
+#endif
+  OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);
+  OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x1680);
+  OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);
+  OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e);
+  OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);
+  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x2000);
+  OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x200A - 0x2000);
+  OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_LESS_EQUAL);
+  OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x202f - 0x2000);
+  OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);
+  OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x205f - 0x2000);
+  OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);
+  OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x3000 - 0x2000);
+#ifdef COMPILE_PCRE8
+  }
+#endif
+#endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */
+OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_EQUAL);
+
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+}
+
+static void check_vspace(compiler_common *common)
+{
+/* Check whether TMP1 contains a newline character. TMP2 destroyed. */
+DEFINE_COMPILER;
+
+sljit_emit_fast_enter(compiler, RETURN_ADDR, 0);
+
+OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x0a);
+OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x0d - 0x0a);
+OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_LESS_EQUAL);
+OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x0a);
+#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+#ifdef COMPILE_PCRE8
+if (common->utf)
+  {
+#endif
+  OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);
+  OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, 0x1);
+  OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2029 - 0x0a);
+#ifdef COMPILE_PCRE8
+  }
+#endif
+#endif /* SUPPORT_UTF || COMPILE_PCRE16 || COMPILE_PCRE32 */
+OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_EQUAL);
+
+sljit_emit_fast_return(compiler, RETURN_ADDR, 0);
+}
+
+static void do_casefulcmp(compiler_common *common)
+{
+DEFINE_COMPILER;
+struct sljit_jump *jump;
+struct sljit_label *label;
+int char1_reg;
+int char2_reg;
+
+if (sljit_get_register_index(TMP3) < 0)
+  {
+  char1_reg = STR_END;
+  char2_reg = STACK_TOP;
+  }
+else
+  {
+  char1_reg = TMP3;
+  char2_reg = RETURN_ADDR;
+  }
+
+sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0);
+OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+
+if (char1_reg == STR_END)
+  {
+  OP1(SLJIT_MOV, TMP3, 0, char1_reg, 0);
+  OP1(SLJIT_MOV, RETURN_ADDR, 0, char2_reg, 0);
+  }
+
+if (sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_SUPP | SLJIT_MEM_POST, char1_reg, SLJIT_MEM1(TMP1), IN_UCHARS(1)) == SLJIT_SUCCESS)
+  {
+  label = LABEL();
+  sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_POST, char1_reg, SLJIT_MEM1(TMP1), IN_UCHARS(1));
+  sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_POST, char2_reg, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+  jump = CMP(SLJIT_NOT_EQUAL, char1_reg, 0, char2_reg, 0);
+  OP2(SLJIT_SUB | SLJIT_SET_Z, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));
+  JUMPTO(SLJIT_NOT_ZERO, label);
+
+  JUMPHERE(jump);
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
+  }
+else if (sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, char1_reg, SLJIT_MEM1(TMP1), IN_UCHARS(1)) == SLJIT_SUCCESS)
+  {
+  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));
+  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+
+  label = LABEL();
+  sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_PRE, char1_reg, SLJIT_MEM1(TMP1), IN_UCHARS(1));
+  sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_PRE, char2_reg, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+  jump = CMP(SLJIT_NOT_EQUAL, char1_reg, 0, char2_reg, 0);
+  OP2(SLJIT_SUB | SLJIT_SET_Z, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));
+  JUMPTO(SLJIT_NOT_ZERO, label);
+
+  JUMPHERE(jump);
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+  }
+else
+  {
+  label = LABEL();
+  OP1(MOV_UCHAR, char1_reg, 0, SLJIT_MEM1(TMP1), 0);
+  OP1(MOV_UCHAR, char2_reg, 0, SLJIT_MEM1(STR_PTR), 0);
+  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+  jump = CMP(SLJIT_NOT_EQUAL, char1_reg, 0, char2_reg, 0);
+  OP2(SLJIT_SUB | SLJIT_SET_Z, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));
+  JUMPTO(SLJIT_NOT_ZERO, label);
+
+  JUMPHERE(jump);
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
+  }
+
+if (char1_reg == STR_END)
+  {
+  OP1(SLJIT_MOV, char1_reg, 0, TMP3, 0);
+  OP1(SLJIT_MOV, char2_reg, 0, RETURN_ADDR, 0);
+  }
+
+sljit_emit_fast_return(compiler, TMP1, 0);
+}
+
+static void do_caselesscmp(compiler_common *common)
+{
+DEFINE_COMPILER;
+struct sljit_jump *jump;
+struct sljit_label *label;
+int char1_reg = STR_END;
+int char2_reg;
+int lcc_table;
+int opt_type = 0;
+
+if (sljit_get_register_index(TMP3) < 0)
+  {
+  char2_reg = STACK_TOP;
+  lcc_table = STACK_LIMIT;
+  }
+else
+  {
+  char2_reg = RETURN_ADDR;
+  lcc_table = TMP3;
+  }
+
+if (sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_SUPP | SLJIT_MEM_POST, char1_reg, SLJIT_MEM1(TMP1), IN_UCHARS(1)) == SLJIT_SUCCESS)
+  opt_type = 1;
+else if (sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_SUPP | SLJIT_MEM_PRE, char1_reg, SLJIT_MEM1(TMP1), IN_UCHARS(1)) == SLJIT_SUCCESS)
+  opt_type = 2;
+
+sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0);
+OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+
+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, char1_reg, 0);
+
+if (char2_reg == STACK_TOP)
+  {
+  OP1(SLJIT_MOV, TMP3, 0, char2_reg, 0);
+  OP1(SLJIT_MOV, RETURN_ADDR, 0, lcc_table, 0);
+  }
+
+OP1(SLJIT_MOV, lcc_table, 0, SLJIT_IMM, common->lcc);
+
+if (opt_type == 1)
+  {
+  label = LABEL();
+  sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_POST, char1_reg, SLJIT_MEM1(TMP1), IN_UCHARS(1));
+  sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_POST, char2_reg, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+  }
+else if (opt_type == 2)
+  {
+  OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));
+  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+
+  label = LABEL();
+  sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_PRE, char1_reg, SLJIT_MEM1(TMP1), IN_UCHARS(1));
+  sljit_emit_mem(compiler, MOV_UCHAR | SLJIT_MEM_PRE, char2_reg, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+  }
+else
+  {
+  label = LABEL();
+  OP1(MOV_UCHAR, char1_reg, 0, SLJIT_MEM1(TMP1), 0);
+  OP1(MOV_UCHAR, char2_reg, 0, SLJIT_MEM1(STR_PTR), 0);
+  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, IN_UCHARS(1));
+  }
+
+#ifndef COMPILE_PCRE8
+jump = CMP(SLJIT_GREATER, char1_reg, 0, SLJIT_IMM, 255);
+#endif
+OP1(SLJIT_MOV_U8, char1_reg, 0, SLJIT_MEM2(lcc_table, char1_reg), 0);
+#ifndef COMPILE_PCRE8
+JUMPHERE(jump);
+jump = CMP(SLJIT_GREATER, char2_reg, 0, SLJIT_IMM, 255);
+#endif
+OP1(SLJIT_MOV_U8, char2_reg, 0, SLJIT_MEM2(lcc_table, char2_reg), 0);
+#ifndef COMPILE_PCRE8
+JUMPHERE(jump);
+#endif
+
+if (opt_type == 0)
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+
+jump = CMP(SLJIT_NOT_EQUAL, char1_reg, 0, char2_reg, 0);
+OP2(SLJIT_SUB | SLJIT_SET_Z, TMP2, 0, TMP2, 0, SLJIT_IMM, IN_UCHARS(1));
+JUMPTO(SLJIT_NOT_ZERO, label);
+
+JUMPHERE(jump);
+OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
+
+if (opt_type == 2)
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+
+if (char2_reg == STACK_TOP)
+  {
+  OP1(SLJIT_MOV, char2_reg, 0, TMP3, 0);
+  OP1(SLJIT_MOV, lcc_table, 0, RETURN_ADDR, 0);
+  }
+
+OP1(SLJIT_MOV, char1_reg, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1);
+sljit_emit_fast_return(compiler, TMP1, 0);
+}
+
+#if defined SUPPORT_UTF && defined SUPPORT_UCP
+
+static const pcre_uchar * SLJIT_FUNC do_utf_caselesscmp(pcre_uchar *src1, pcre_uchar *src2, pcre_uchar *end1, pcre_uchar *end2)
+{
+/* This function would be ineffective to do in JIT level. */
+sljit_u32 c1, c2;
+const ucd_record *ur;
+const sljit_u32 *pp;
+
+while (src1 < end1)
+  {
+  if (src2 >= end2)
+    return (pcre_uchar*)1;
+  GETCHARINC(c1, src1);
+  GETCHARINC(c2, src2);
+  ur = GET_UCD(c2);
+  if (c1 != c2 && c1 != c2 + ur->other_case)
+    {
+    pp = PRIV(ucd_caseless_sets) + ur->caseset;
+    for (;;)
+      {
+      if (c1 < *pp) return NULL;
+      if (c1 == *pp++) break;
+      }
+    }
+  }
+return src2;
+}
+
+#endif /* SUPPORT_UTF && SUPPORT_UCP */
+
+static pcre_uchar *byte_sequence_compare(compiler_common *common, BOOL caseless, pcre_uchar *cc,
+    compare_context *context, jump_list **backtracks)
+{
+DEFINE_COMPILER;
+unsigned int othercasebit = 0;
+pcre_uchar *othercasechar = NULL;
+#ifdef SUPPORT_UTF
+int utflength;
+#endif
+
+if (caseless && char_has_othercase(common, cc))
+  {
+  othercasebit = char_get_othercase_bit(common, cc);
+  SLJIT_ASSERT(othercasebit);
+  /* Extracting bit difference info. */
+#if defined COMPILE_PCRE8
+  othercasechar = cc + (othercasebit >> 8);
+  othercasebit &= 0xff;
+#elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+  /* Note that this code only handles characters in the BMP. If there
+  ever are characters outside the BMP whose othercase differs in only one
+  bit from itself (there currently are none), this code will need to be
+  revised for COMPILE_PCRE32. */
+  othercasechar = cc + (othercasebit >> 9);
+  if ((othercasebit & 0x100) != 0)
+    othercasebit = (othercasebit & 0xff) << 8;
+  else
+    othercasebit &= 0xff;
+#endif /* COMPILE_PCRE[8|16|32] */
+  }
+
+if (context->sourcereg == -1)
+  {
+#if defined COMPILE_PCRE8
+#if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
+  if (context->length >= 4)
+    OP1(SLJIT_MOV_S32, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
+  else if (context->length >= 2)
+    OP1(SLJIT_MOV_U16, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
+  else
+#endif
+    OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
+#elif defined COMPILE_PCRE16
+#if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
+  if (context->length >= 4)
+    OP1(SLJIT_MOV_S32, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
+  else
+#endif
+    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
+#elif defined COMPILE_PCRE32
+  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), -context->length);
+#endif /* COMPILE_PCRE[8|16|32] */
+  context->sourcereg = TMP2;
+  }
+
+#ifdef SUPPORT_UTF
+utflength = 1;
+if (common->utf && HAS_EXTRALEN(*cc))
+  utflength += GET_EXTRALEN(*cc);
+
+do
+  {
+#endif
+
+  context->length -= IN_UCHARS(1);
+#if (defined SLJIT_UNALIGNED && SLJIT_UNALIGNED) && (defined COMPILE_PCRE8 || defined COMPILE_PCRE16)
+
+  /* Unaligned read is supported. */
+  if (othercasebit != 0 && othercasechar == cc)
+    {
+    context->c.asuchars[context->ucharptr] = *cc | othercasebit;
+    context->oc.asuchars[context->ucharptr] = othercasebit;
+    }
+  else
+    {
+    context->c.asuchars[context->ucharptr] = *cc;
+    context->oc.asuchars[context->ucharptr] = 0;
+    }
+  context->ucharptr++;
+
+#if defined COMPILE_PCRE8
+  if (context->ucharptr >= 4 || context->length == 0 || (context->ucharptr == 2 && context->length == 1))
+#else
+  if (context->ucharptr >= 2 || context->length == 0)
+#endif
+    {
+    if (context->length >= 4)
+      OP1(SLJIT_MOV_S32, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
+    else if (context->length >= 2)
+      OP1(SLJIT_MOV_U16, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
+#if defined COMPILE_PCRE8
+    else if (context->length >= 1)
+      OP1(SLJIT_MOV_U8, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
+#endif /* COMPILE_PCRE8 */
+    context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;
+
+    switch(context->ucharptr)
+      {
+      case 4 / sizeof(pcre_uchar):
+      if (context->oc.asint != 0)
+        OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asint);
+      add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asint | context->oc.asint));
+      break;
+
+      case 2 / sizeof(pcre_uchar):
+      if (context->oc.asushort != 0)
+        OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asushort);
+      add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asushort | context->oc.asushort));
+      break;
+
+#ifdef COMPILE_PCRE8
+      case 1:
+      if (context->oc.asbyte != 0)
+        OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, context->oc.asbyte);
+      add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, context->c.asbyte | context->oc.asbyte));
+      break;
+#endif
+
+      default:
+      SLJIT_UNREACHABLE();
+      break;
+      }
+    context->ucharptr = 0;
+    }
+
+#else
+
+  /* Unaligned read is unsupported or in 32 bit mode. */
+  if (context->length >= 1)
+    OP1(MOV_UCHAR, context->sourcereg, 0, SLJIT_MEM1(STR_PTR), -context->length);
+
+  context->sourcereg = context->sourcereg == TMP1 ? TMP2 : TMP1;
+
+  if (othercasebit != 0 && othercasechar == cc)
+    {
+    OP2(SLJIT_OR, context->sourcereg, 0, context->sourcereg, 0, SLJIT_IMM, othercasebit);
+    add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc | othercasebit));
+    }
+  else
+    add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, context->sourcereg, 0, SLJIT_IMM, *cc));
+
+#endif
+
+  cc++;
+#ifdef SUPPORT_UTF
+  utflength--;
+  }
+while (utflength > 0);
+#endif
+
+return cc;
+}
+
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+
+#define SET_TYPE_OFFSET(value) \
+  if ((value) != typeoffset) \
+    { \
+    if ((value) < typeoffset) \
+      OP2(SLJIT_ADD, typereg, 0, typereg, 0, SLJIT_IMM, typeoffset - (value)); \
+    else \
+      OP2(SLJIT_SUB, typereg, 0, typereg, 0, SLJIT_IMM, (value) - typeoffset); \
+    } \
+  typeoffset = (value);
+
+#define SET_CHAR_OFFSET(value) \
+  if ((value) != charoffset) \
+    { \
+    if ((value) < charoffset) \
+      OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(charoffset - (value))); \
+    else \
+      OP2(SLJIT_SUB, TMP1, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)((value) - charoffset)); \
+    } \
+  charoffset = (value);
+
+static pcre_uchar *compile_char1_matchingpath(compiler_common *common, pcre_uchar type, pcre_uchar *cc, jump_list **backtracks, BOOL check_str_ptr);
+
+static void compile_xclass_matchingpath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)
+{
+DEFINE_COMPILER;
+jump_list *found = NULL;
+jump_list **list = (cc[0] & XCL_NOT) == 0 ? &found : backtracks;
+sljit_uw c, charoffset, max = 256, min = READ_CHAR_MAX;
+struct sljit_jump *jump = NULL;
+pcre_uchar *ccbegin;
+int compares, invertcmp, numberofcmps;
+#if defined SUPPORT_UTF && (defined COMPILE_PCRE8 || defined COMPILE_PCRE16)
+BOOL utf = common->utf;
+#endif
+
+#ifdef SUPPORT_UCP
+BOOL needstype = FALSE, needsscript = FALSE, needschar = FALSE;
+BOOL charsaved = FALSE;
+int typereg = TMP1;
+const sljit_u32 *other_cases;
+sljit_uw typeoffset;
+#endif
+
+/* Scanning the necessary info. */
+cc++;
+ccbegin = cc;
+compares = 0;
+if (cc[-1] & XCL_MAP)
+  {
+  min = 0;
+  cc += 32 / sizeof(pcre_uchar);
+  }
+
+while (*cc != XCL_END)
+  {
+  compares++;
+  if (*cc == XCL_SINGLE)
+    {
+    cc ++;
+    GETCHARINCTEST(c, cc);
+    if (c > max) max = c;
+    if (c < min) min = c;
+#ifdef SUPPORT_UCP
+    needschar = TRUE;
+#endif
+    }
+  else if (*cc == XCL_RANGE)
+    {
+    cc ++;
+    GETCHARINCTEST(c, cc);
+    if (c < min) min = c;
+    GETCHARINCTEST(c, cc);
+    if (c > max) max = c;
+#ifdef SUPPORT_UCP
+    needschar = TRUE;
+#endif
+    }
+#ifdef SUPPORT_UCP
+  else
+    {
+    SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP);
+    cc++;
+    if (*cc == PT_CLIST)
+      {
+      other_cases = PRIV(ucd_caseless_sets) + cc[1];
+      while (*other_cases != NOTACHAR)
+        {
+        if (*other_cases > max) max = *other_cases;
+        if (*other_cases < min) min = *other_cases;
+        other_cases++;
+        }
+      }
+    else
+      {
+      max = READ_CHAR_MAX;
+      min = 0;
+      }
+
+    switch(*cc)
+      {
+      case PT_ANY:
+      /* Any either accepts everything or ignored. */
+      if (cc[-1] == XCL_PROP)
+        {
+        compile_char1_matchingpath(common, OP_ALLANY, cc, backtracks, FALSE);
+        if (list == backtracks)
+          add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
+        return;
+        }
+      break;
+
+      case PT_LAMP:
+      case PT_GC:
+      case PT_PC:
+      case PT_ALNUM:
+      needstype = TRUE;
+      break;
+
+      case PT_SC:
+      needsscript = TRUE;
+      break;
+
+      case PT_SPACE:
+      case PT_PXSPACE:
+      case PT_WORD:
+      case PT_PXGRAPH:
+      case PT_PXPRINT:
+      case PT_PXPUNCT:
+      needstype = TRUE;
+      needschar = TRUE;
+      break;
+
+      case PT_CLIST:
+      case PT_UCNC:
+      needschar = TRUE;
+      break;
+
+      default:
+      SLJIT_UNREACHABLE();
+      break;
+      }
+    cc += 2;
+    }
+#endif
+  }
+SLJIT_ASSERT(compares > 0);
+
+/* We are not necessary in utf mode even in 8 bit mode. */
+cc = ccbegin;
+read_char_range(common, min, max, (cc[-1] & XCL_NOT) != 0);
+
+if ((cc[-1] & XCL_HASPROP) == 0)
+  {
+  if ((cc[-1] & XCL_MAP) != 0)
+    {
+    jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
+    if (!check_class_ranges(common, (const sljit_u8 *)cc, (((const sljit_u8 *)cc)[31] & 0x80) != 0, TRUE, &found))
+      {
+      OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
+      OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
+      OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);
+      OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
+      OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
+      add_jump(compiler, &found, JUMP(SLJIT_NOT_ZERO));
+      }
+
+    add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
+    JUMPHERE(jump);
+
+    cc += 32 / sizeof(pcre_uchar);
+    }
+  else
+    {
+    OP2(SLJIT_SUB, TMP2, 0, TMP1, 0, SLJIT_IMM, min);
+    add_jump(compiler, (cc[-1] & XCL_NOT) == 0 ? backtracks : &found, CMP(SLJIT_GREATER, TMP2, 0, SLJIT_IMM, max - min));
+    }
+  }
+else if ((cc[-1] & XCL_MAP) != 0)
+  {
+  OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);
+#ifdef SUPPORT_UCP
+  charsaved = TRUE;
+#endif
+  if (!check_class_ranges(common, (const sljit_u8 *)cc, FALSE, TRUE, list))
+    {
+#ifdef COMPILE_PCRE8
+    jump = NULL;
+    if (common->utf)
+#endif
+      jump = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
+
+    OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
+    OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
+    OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);
+    OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
+    OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
+    add_jump(compiler, list, JUMP(SLJIT_NOT_ZERO));
+
+#ifdef COMPILE_PCRE8
+    if (common->utf)
+#endif
+      JUMPHERE(jump);
+    }
+
+  OP1(SLJIT_MOV, TMP1, 0, RETURN_ADDR, 0);
+  cc += 32 / sizeof(pcre_uchar);
+  }
+
+#ifdef SUPPORT_UCP
+if (needstype || needsscript)
+  {
+  if (needschar && !charsaved)
+    OP1(SLJIT_MOV, RETURN_ADDR, 0, TMP1, 0);
+
+#ifdef COMPILE_PCRE32
+  if (!common->utf)
+    {
+    jump = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0x10ffff + 1);
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, INVALID_UTF_CHAR);
+    JUMPHERE(jump);
+    }
+#endif
+
+  OP2(SLJIT_LSHR, TMP2, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);
+  OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(ucd_stage1));
+  OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, UCD_BLOCK_MASK);
+  OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, UCD_BLOCK_SHIFT);
+  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, TMP2, 0);
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_stage2));
+  OP1(SLJIT_MOV_U16, TMP2, 0, SLJIT_MEM2(TMP2, TMP1), 1);
+
+  /* Before anything else, we deal with scripts. */
+  if (needsscript)
+    {
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, script));
+    OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3);
+
+    ccbegin = cc;
+
+    while (*cc != XCL_END)
+      {
+      if (*cc == XCL_SINGLE)
+        {
+        cc ++;
+        GETCHARINCTEST(c, cc);
+        }
+      else if (*cc == XCL_RANGE)
+        {
+        cc ++;
+        GETCHARINCTEST(c, cc);
+        GETCHARINCTEST(c, cc);
+        }
+      else
+        {
+        SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP);
+        cc++;
+        if (*cc == PT_SC)
+          {
+          compares--;
+          invertcmp = (compares == 0 && list != backtracks);
+          if (cc[-1] == XCL_NOTPROP)
+            invertcmp ^= 0x1;
+          jump = CMP(SLJIT_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, (int)cc[1]);
+          add_jump(compiler, compares > 0 ? list : backtracks, jump);
+          }
+        cc += 2;
+        }
+      }
+
+    cc = ccbegin;
+    }
+
+  if (needschar)
+    {
+    OP1(SLJIT_MOV, TMP1, 0, RETURN_ADDR, 0);
+    }
+
+  if (needstype)
+    {
+    if (!needschar)
+      {
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype));
+      OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM2(TMP1, TMP2), 3);
+      }
+    else
+      {
+      OP2(SLJIT_SHL, TMP2, 0, TMP2, 0, SLJIT_IMM, 3);
+      OP1(SLJIT_MOV_U8, RETURN_ADDR, 0, SLJIT_MEM1(TMP2), (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, chartype));
+      typereg = RETURN_ADDR;
+      }
+    }
+  }
+#endif
+
+/* Generating code. */
+charoffset = 0;
+numberofcmps = 0;
+#ifdef SUPPORT_UCP
+typeoffset = 0;
+#endif
+
+while (*cc != XCL_END)
+  {
+  compares--;
+  invertcmp = (compares == 0 && list != backtracks);
+  jump = NULL;
+
+  if (*cc == XCL_SINGLE)
+    {
+    cc ++;
+    GETCHARINCTEST(c, cc);
+
+    if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))
+      {
+      OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));
+      OP_FLAGS(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, SLJIT_EQUAL);
+      numberofcmps++;
+      }
+    else if (numberofcmps > 0)
+      {
+      OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));
+      OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_EQUAL);
+      jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);
+      numberofcmps = 0;
+      }
+    else
+      {
+      jump = CMP(SLJIT_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));
+      numberofcmps = 0;
+      }
+    }
+  else if (*cc == XCL_RANGE)
+    {
+    cc ++;
+    GETCHARINCTEST(c, cc);
+    SET_CHAR_OFFSET(c);
+    GETCHARINCTEST(c, cc);
+
+    if (numberofcmps < 3 && (*cc == XCL_SINGLE || *cc == XCL_RANGE))
+      {
+      OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));
+      OP_FLAGS(numberofcmps == 0 ? SLJIT_MOV : SLJIT_OR, TMP2, 0, SLJIT_LESS_EQUAL);
+      numberofcmps++;
+      }
+    else if (numberofcmps > 0)
+      {
+      OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));
+      OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_LESS_EQUAL);
+      jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);
+      numberofcmps = 0;
+      }
+    else
+      {
+      jump = CMP(SLJIT_LESS_EQUAL ^ invertcmp, TMP1, 0, SLJIT_IMM, (sljit_sw)(c - charoffset));
+      numberofcmps = 0;
+      }
+    }
+#ifdef SUPPORT_UCP
+  else
+    {
+    SLJIT_ASSERT(*cc == XCL_PROP || *cc == XCL_NOTPROP);
+    if (*cc == XCL_NOTPROP)
+      invertcmp ^= 0x1;
+    cc++;
+    switch(*cc)
+      {
+      case PT_ANY:
+      if (!invertcmp)
+        jump = JUMP(SLJIT_JUMP);
+      break;
+
+      case PT_LAMP:
+      OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lu - typeoffset);
+      OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_EQUAL);
+      OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Ll - typeoffset);
+      OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);
+      OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lt - typeoffset);
+      OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_EQUAL);
+      jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);
+      break;
+
+      case PT_GC:
+      c = PRIV(ucp_typerange)[(int)cc[1] * 2];
+      SET_TYPE_OFFSET(c);
+      jump = CMP(SLJIT_LESS_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, PRIV(ucp_typerange)[(int)cc[1] * 2 + 1] - c);
+      break;
+
+      case PT_PC:
+      jump = CMP(SLJIT_EQUAL ^ invertcmp, typereg, 0, SLJIT_IMM, (int)cc[1] - typeoffset);
+      break;
+
+      case PT_SC:
+      compares++;
+      /* Do nothing. */
+      break;
+
+      case PT_SPACE:
+      case PT_PXSPACE:
+      SET_CHAR_OFFSET(9);
+      OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd - 0x9);
+      OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_LESS_EQUAL);
+
+      OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x85 - 0x9);
+      OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);
+
+      OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e - 0x9);
+      OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);
+
+      SET_TYPE_OFFSET(ucp_Zl);
+      OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Zs - ucp_Zl);
+      OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_LESS_EQUAL);
+      jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);
+      break;
+
+      case PT_WORD:
+      OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_UNDERSCORE - charoffset));
+      OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_EQUAL);
+      /* Fall through. */
+
+      case PT_ALNUM:
+      SET_TYPE_OFFSET(ucp_Ll);
+      OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Lu - ucp_Ll);
+      OP_FLAGS((*cc == PT_ALNUM) ? SLJIT_MOV : SLJIT_OR, TMP2, 0, SLJIT_LESS_EQUAL);
+      SET_TYPE_OFFSET(ucp_Nd);
+      OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_No - ucp_Nd);
+      OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_LESS_EQUAL);
+      jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);
+      break;
+
+      case PT_CLIST:
+      other_cases = PRIV(ucd_caseless_sets) + cc[1];
+
+      /* At least three characters are required.
+         Otherwise this case would be handled by the normal code path. */
+      SLJIT_ASSERT(other_cases[0] != NOTACHAR && other_cases[1] != NOTACHAR && other_cases[2] != NOTACHAR);
+      SLJIT_ASSERT(other_cases[0] < other_cases[1] && other_cases[1] < other_cases[2]);
+
+      /* Optimizing character pairs, if their difference is power of 2. */
+      if (is_powerof2(other_cases[1] ^ other_cases[0]))
+        {
+        if (charoffset == 0)
+          OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]);
+        else
+          {
+          OP2(SLJIT_ADD, TMP2, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)charoffset);
+          OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]);
+          }
+        OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, other_cases[1]);
+        OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_EQUAL);
+        other_cases += 2;
+        }
+      else if (is_powerof2(other_cases[2] ^ other_cases[1]))
+        {
+        if (charoffset == 0)
+          OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, other_cases[2] ^ other_cases[1]);
+        else
+          {
+          OP2(SLJIT_ADD, TMP2, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)charoffset);
+          OP2(SLJIT_OR, TMP2, 0, TMP2, 0, SLJIT_IMM, other_cases[1] ^ other_cases[0]);
+          }
+        OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP2, 0, SLJIT_IMM, other_cases[2]);
+        OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_EQUAL);
+
+        OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(other_cases[0] - charoffset));
+        OP_FLAGS(SLJIT_OR | ((other_cases[3] == NOTACHAR) ? SLJIT_SET_Z : 0), TMP2, 0, SLJIT_EQUAL);
+
+        other_cases += 3;
+        }
+      else
+        {
+        OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(*other_cases++ - charoffset));
+        OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_EQUAL);
+        }
+
+      while (*other_cases != NOTACHAR)
+        {
+        OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(*other_cases++ - charoffset));
+        OP_FLAGS(SLJIT_OR | ((*other_cases == NOTACHAR) ? SLJIT_SET_Z : 0), TMP2, 0, SLJIT_EQUAL);
+        }
+      jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);
+      break;
+
+      case PT_UCNC:
+      OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_DOLLAR_SIGN - charoffset));
+      OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_EQUAL);
+      OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_COMMERCIAL_AT - charoffset));
+      OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);
+      OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(CHAR_GRAVE_ACCENT - charoffset));
+      OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);
+
+      SET_CHAR_OFFSET(0xa0);
+      OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (sljit_sw)(0xd7ff - charoffset));
+      OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_LESS_EQUAL);
+      SET_CHAR_OFFSET(0);
+      OP2(SLJIT_SUB | SLJIT_SET_GREATER_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xe000 - 0);
+      OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_GREATER_EQUAL);
+      jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);
+      break;
+
+      case PT_PXGRAPH:
+      /* C and Z groups are the farthest two groups. */
+      SET_TYPE_OFFSET(ucp_Ll);
+      OP2(SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Ll);
+      OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_GREATER);
+
+      jump = CMP(SLJIT_NOT_EQUAL, typereg, 0, SLJIT_IMM, ucp_Cf - ucp_Ll);
+
+      /* In case of ucp_Cf, we overwrite the result. */
+      SET_CHAR_OFFSET(0x2066);
+      OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2069 - 0x2066);
+      OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_LESS_EQUAL);
+
+      OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x061c - 0x2066);
+      OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);
+
+      OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x180e - 0x2066);
+      OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);
+
+      JUMPHERE(jump);
+      jump = CMP(SLJIT_ZERO ^ invertcmp, TMP2, 0, SLJIT_IMM, 0);
+      break;
+
+      case PT_PXPRINT:
+      /* C and Z groups are the farthest two groups. */
+      SET_TYPE_OFFSET(ucp_Ll);
+      OP2(SLJIT_SUB | SLJIT_SET_GREATER, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Ll);
+      OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_GREATER);
+
+      OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Zs - ucp_Ll);
+      OP_FLAGS(SLJIT_AND, TMP2, 0, SLJIT_NOT_EQUAL);
+
+      jump = CMP(SLJIT_NOT_EQUAL, typereg, 0, SLJIT_IMM, ucp_Cf - ucp_Ll);
+
+      /* In case of ucp_Cf, we overwrite the result. */
+      SET_CHAR_OFFSET(0x2066);
+      OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x2069 - 0x2066);
+      OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_LESS_EQUAL);
+
+      OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x061c - 0x2066);
+      OP_FLAGS(SLJIT_OR, TMP2, 0, SLJIT_EQUAL);
+
+      JUMPHERE(jump);
+      jump = CMP(SLJIT_ZERO ^ invertcmp, TMP2, 0, SLJIT_IMM, 0);
+      break;
+
+      case PT_PXPUNCT:
+      SET_TYPE_OFFSET(ucp_Sc);
+      OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_So - ucp_Sc);
+      OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_LESS_EQUAL);
+
+      SET_CHAR_OFFSET(0);
+      OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0x7f);
+      OP_FLAGS(SLJIT_AND, TMP2, 0, SLJIT_LESS_EQUAL);
+
+      SET_TYPE_OFFSET(ucp_Pc);
+      OP2(SLJIT_SUB | SLJIT_SET_LESS_EQUAL, SLJIT_UNUSED, 0, typereg, 0, SLJIT_IMM, ucp_Ps - ucp_Pc);
+      OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_LESS_EQUAL);
+      jump = JUMP(SLJIT_NOT_ZERO ^ invertcmp);
+      break;
+
+      default:
+      SLJIT_UNREACHABLE();
+      break;
+      }
+    cc += 2;
+    }
+#endif
+
+  if (jump != NULL)
+    add_jump(compiler, compares > 0 ? list : backtracks, jump);
+  }
+
+if (found != NULL)
+  set_jumps(found, LABEL());
+}
+
+#undef SET_TYPE_OFFSET
+#undef SET_CHAR_OFFSET
+
+#endif
+
+static pcre_uchar *compile_simple_assertion_matchingpath(compiler_common *common, pcre_uchar type, pcre_uchar *cc, jump_list **backtracks)
+{
+DEFINE_COMPILER;
+int length;
+struct sljit_jump *jump[4];
+#ifdef SUPPORT_UTF
+struct sljit_label *label;
+#endif /* SUPPORT_UTF */
+
+switch(type)
+  {
+  case OP_SOD:
+  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
+  add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, TMP1, 0));
+  return cc;
+
+  case OP_SOM:
+  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
+  add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, TMP1, 0));
+  return cc;
+
+  case OP_NOT_WORD_BOUNDARY:
+  case OP_WORD_BOUNDARY:
+  add_jump(compiler, &common->wordboundary, JUMP(SLJIT_FAST_CALL));
+  sljit_set_current_flags(compiler, SLJIT_SET_Z);
+  add_jump(compiler, backtracks, JUMP(type == OP_NOT_WORD_BOUNDARY ? SLJIT_NOT_ZERO : SLJIT_ZERO));
+  return cc;
+
+  case OP_EODN:
+  /* Requires rather complex checks. */
+  jump[0] = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+  if (common->nltype == NLTYPE_FIXED && common->newline > 255)
+    {
+    OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
+    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+    if (common->mode == JIT_COMPILE)
+      add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, STR_END, 0));
+    else
+      {
+      jump[1] = CMP(SLJIT_EQUAL, TMP2, 0, STR_END, 0);
+      OP2(SLJIT_SUB | SLJIT_SET_LESS, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0);
+      OP_FLAGS(SLJIT_MOV, TMP2, 0, SLJIT_LESS);
+      OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);
+      OP_FLAGS(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, SLJIT_NOT_EQUAL);
+      add_jump(compiler, backtracks, JUMP(SLJIT_NOT_EQUAL));
+      check_partial(common, TRUE);
+      add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
+      JUMPHERE(jump[1]);
+      }
+    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+    add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
+    add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
+    }
+  else if (common->nltype == NLTYPE_FIXED)
+    {
+    OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+    add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, STR_END, 0));
+    add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline));
+    }
+  else
+    {
+    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+    jump[1] = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
+    OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
+    OP2(SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_GREATER, SLJIT_UNUSED, 0, TMP2, 0, STR_END, 0);
+    jump[2] = JUMP(SLJIT_GREATER);
+    add_jump(compiler, backtracks, JUMP(SLJIT_NOT_EQUAL) /* LESS */);
+    /* Equal. */
+    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+    jump[3] = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);
+    add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
+
+    JUMPHERE(jump[1]);
+    if (common->nltype == NLTYPE_ANYCRLF)
+      {
+      OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+      add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP2, 0, STR_END, 0));
+      add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL));
+      }
+    else
+      {
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, STR_PTR, 0);
+      read_char_range(common, common->nlmin, common->nlmax, TRUE);
+      add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, STR_END, 0));
+      add_jump(compiler, &common->anynewline, JUMP(SLJIT_FAST_CALL));
+      sljit_set_current_flags(compiler, SLJIT_SET_Z);
+      add_jump(compiler, backtracks, JUMP(SLJIT_ZERO));
+      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1);
+      }
+    JUMPHERE(jump[2]);
+    JUMPHERE(jump[3]);
+    }
+  JUMPHERE(jump[0]);
+  check_partial(common, FALSE);
+  return cc;
+
+  case OP_EOD:
+  add_jump(compiler, backtracks, CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0));
+  check_partial(common, FALSE);
+  return cc;
+
+  case OP_DOLL:
+  OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
+  OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, noteol));
+  add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+
+  if (!common->endonly)
+    compile_simple_assertion_matchingpath(common, OP_EODN, cc, backtracks);
+  else
+    {
+    add_jump(compiler, backtracks, CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0));
+    check_partial(common, FALSE);
+    }
+  return cc;
+
+  case OP_DOLLM:
+  jump[1] = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);
+  OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
+  OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, noteol));
+  add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+  check_partial(common, FALSE);
+  jump[0] = JUMP(SLJIT_JUMP);
+  JUMPHERE(jump[1]);
+
+  if (common->nltype == NLTYPE_FIXED && common->newline > 255)
+    {
+    OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
+    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+    if (common->mode == JIT_COMPILE)
+      add_jump(compiler, backtracks, CMP(SLJIT_GREATER, TMP2, 0, STR_END, 0));
+    else
+      {
+      jump[1] = CMP(SLJIT_LESS_EQUAL, TMP2, 0, STR_END, 0);
+      /* STR_PTR = STR_END - IN_UCHARS(1) */
+      add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
+      check_partial(common, TRUE);
+      add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
+      JUMPHERE(jump[1]);
+      }
+
+    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(1));
+    add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
+    add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
+    }
+  else
+    {
+    peek_char(common, common->nlmax);
+    check_newlinechar(common, common->nltype, backtracks, FALSE);
+    }
+  JUMPHERE(jump[0]);
+  return cc;
+
+  case OP_CIRC:
+  OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin));
+  add_jump(compiler, backtracks, CMP(SLJIT_GREATER, STR_PTR, 0, TMP1, 0));
+  OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, notbol));
+  add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+  return cc;
+
+  case OP_CIRCM:
+  OP1(SLJIT_MOV, TMP2, 0, ARGUMENTS, 0);
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, begin));
+  jump[1] = CMP(SLJIT_GREATER, STR_PTR, 0, TMP1, 0);
+  OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(jit_arguments, notbol));
+  add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+  jump[0] = JUMP(SLJIT_JUMP);
+  JUMPHERE(jump[1]);
+
+  add_jump(compiler, backtracks, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
+  if (common->nltype == NLTYPE_FIXED && common->newline > 255)
+    {
+    OP2(SLJIT_SUB, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(2));
+    add_jump(compiler, backtracks, CMP(SLJIT_LESS, TMP2, 0, TMP1, 0));
+    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-2));
+    OP1(MOV_UCHAR, TMP2, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));
+    add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff));
+    add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, common->newline & 0xff));
+    }
+  else
+    {
+    skip_char_back(common);
+    read_char_range(common, common->nlmin, common->nlmax, TRUE);
+    check_newlinechar(common, common->nltype, backtracks, FALSE);
+    }
+  JUMPHERE(jump[0]);
+  return cc;
+
+  case OP_REVERSE:
+  length = GET(cc, 0);
+  if (length == 0)
+    return cc + LINK_SIZE;
+  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
+#ifdef SUPPORT_UTF
+  if (common->utf)
+    {
+    OP1(SLJIT_MOV, TMP3, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, length);
+    label = LABEL();
+    add_jump(compiler, backtracks, CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP3, 0));
+    skip_char_back(common);
+    OP2(SLJIT_SUB | SLJIT_SET_Z, TMP2, 0, TMP2, 0, SLJIT_IMM, 1);
+    JUMPTO(SLJIT_NOT_ZERO, label);
+    }
+  else
+#endif
+    {
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, begin));
+    OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(length));
+    add_jump(compiler, backtracks, CMP(SLJIT_LESS, STR_PTR, 0, TMP1, 0));
+    }
+  check_start_used_ptr(common);
+  return cc + LINK_SIZE;
+  }
+SLJIT_UNREACHABLE();
+return cc;
+}
+
+static pcre_uchar *compile_char1_matchingpath(compiler_common *common, pcre_uchar type, pcre_uchar *cc, jump_list **backtracks, BOOL check_str_ptr)
+{
+DEFINE_COMPILER;
+int length;
+unsigned int c, oc, bit;
+compare_context context;
+struct sljit_jump *jump[3];
+jump_list *end_list;
+#ifdef SUPPORT_UTF
+struct sljit_label *label;
+#ifdef SUPPORT_UCP
+pcre_uchar propdata[5];
+#endif
+#endif /* SUPPORT_UTF */
+
+switch(type)
+  {
+  case OP_NOT_DIGIT:
+  case OP_DIGIT:
+  /* Digits are usually 0-9, so it is worth to optimize them. */
+  if (check_str_ptr)
+    detect_partial_match(common, backtracks);
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+  if (common->utf && is_char7_bitset((const sljit_u8 *)common->ctypes - cbit_length + cbit_digit, FALSE))
+    read_char7_type(common, type == OP_NOT_DIGIT);
+  else
+#endif
+    read_char8_type(common, type == OP_NOT_DIGIT);
+    /* Flip the starting bit in the negative case. */
+  OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_digit);
+  add_jump(compiler, backtracks, JUMP(type == OP_DIGIT ? SLJIT_ZERO : SLJIT_NOT_ZERO));
+  return cc;
+
+  case OP_NOT_WHITESPACE:
+  case OP_WHITESPACE:
+  if (check_str_ptr)
+    detect_partial_match(common, backtracks);
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+  if (common->utf && is_char7_bitset((const sljit_u8 *)common->ctypes - cbit_length + cbit_space, FALSE))
+    read_char7_type(common, type == OP_NOT_WHITESPACE);
+  else
+#endif
+    read_char8_type(common, type == OP_NOT_WHITESPACE);
+  OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_space);
+  add_jump(compiler, backtracks, JUMP(type == OP_WHITESPACE ? SLJIT_ZERO : SLJIT_NOT_ZERO));
+  return cc;
+
+  case OP_NOT_WORDCHAR:
+  case OP_WORDCHAR:
+  if (check_str_ptr)
+    detect_partial_match(common, backtracks);
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+  if (common->utf && is_char7_bitset((const sljit_u8 *)common->ctypes - cbit_length + cbit_word, FALSE))
+    read_char7_type(common, type == OP_NOT_WORDCHAR);
+  else
+#endif
+    read_char8_type(common, type == OP_NOT_WORDCHAR);
+  OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, ctype_word);
+  add_jump(compiler, backtracks, JUMP(type == OP_WORDCHAR ? SLJIT_ZERO : SLJIT_NOT_ZERO));
+  return cc;
+
+  case OP_ANY:
+  if (check_str_ptr)
+    detect_partial_match(common, backtracks);
+  read_char_range(common, common->nlmin, common->nlmax, TRUE);
+  if (common->nltype == NLTYPE_FIXED && common->newline > 255)
+    {
+    jump[0] = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, (common->newline >> 8) & 0xff);
+    end_list = NULL;
+    if (common->mode != JIT_PARTIAL_HARD_COMPILE)
+      add_jump(compiler, &end_list, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
+    else
+      check_str_end(common, &end_list);
+
+    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+    add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, common->newline & 0xff));
+    set_jumps(end_list, LABEL());
+    JUMPHERE(jump[0]);
+    }
+  else
+    check_newlinechar(common, common->nltype, backtracks, TRUE);
+  return cc;
+
+  case OP_ALLANY:
+  if (check_str_ptr)
+    detect_partial_match(common, backtracks);
+#ifdef SUPPORT_UTF
+  if (common->utf)
+    {
+    OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+#if defined COMPILE_PCRE8 || defined COMPILE_PCRE16
+#if defined COMPILE_PCRE8
+    jump[0] = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
+    OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+#elif defined COMPILE_PCRE16
+    jump[0] = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xd800);
+    OP2(SLJIT_AND, TMP1, 0, TMP1, 0, SLJIT_IMM, 0xfc00);
+    OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, SLJIT_IMM, 0xd800);
+    OP_FLAGS(SLJIT_MOV, TMP1, 0, SLJIT_EQUAL);
+    OP2(SLJIT_SHL, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+#endif
+    JUMPHERE(jump[0]);
+#endif /* COMPILE_PCRE[8|16] */
+    return cc;
+    }
+#endif
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+  return cc;
+
+  case OP_ANYBYTE:
+  if (check_str_ptr)
+    detect_partial_match(common, backtracks);
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+  return cc;
+
+#ifdef SUPPORT_UTF
+#ifdef SUPPORT_UCP
+  case OP_NOTPROP:
+  case OP_PROP:
+  propdata[0] = XCL_HASPROP;
+  propdata[1] = type == OP_NOTPROP ? XCL_NOTPROP : XCL_PROP;
+  propdata[2] = cc[0];
+  propdata[3] = cc[1];
+  propdata[4] = XCL_END;
+  if (check_str_ptr)
+    detect_partial_match(common, backtracks);
+  compile_xclass_matchingpath(common, propdata, backtracks);
+  return cc + 2;
+#endif
+#endif
+
+  case OP_ANYNL:
+  if (check_str_ptr)
+    detect_partial_match(common, backtracks);
+  read_char_range(common, common->bsr_nlmin, common->bsr_nlmax, FALSE);
+  jump[0] = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_CR);
+  /* We don't need to handle soft partial matching case. */
+  end_list = NULL;
+  if (common->mode != JIT_PARTIAL_HARD_COMPILE)
+    add_jump(compiler, &end_list, CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0));
+  else
+    check_str_end(common, &end_list);
+  OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+  jump[1] = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, CHAR_NL);
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+  jump[2] = JUMP(SLJIT_JUMP);
+  JUMPHERE(jump[0]);
+  check_newlinechar(common, common->bsr_nltype, backtracks, FALSE);
+  set_jumps(end_list, LABEL());
+  JUMPHERE(jump[1]);
+  JUMPHERE(jump[2]);
+  return cc;
+
+  case OP_NOT_HSPACE:
+  case OP_HSPACE:
+  if (check_str_ptr)
+    detect_partial_match(common, backtracks);
+  read_char_range(common, 0x9, 0x3000, type == OP_NOT_HSPACE);
+  add_jump(compiler, &common->hspace, JUMP(SLJIT_FAST_CALL));
+  sljit_set_current_flags(compiler, SLJIT_SET_Z);
+  add_jump(compiler, backtracks, JUMP(type == OP_NOT_HSPACE ? SLJIT_NOT_ZERO : SLJIT_ZERO));
+  return cc;
+
+  case OP_NOT_VSPACE:
+  case OP_VSPACE:
+  if (check_str_ptr)
+    detect_partial_match(common, backtracks);
+  read_char_range(common, 0xa, 0x2029, type == OP_NOT_VSPACE);
+  add_jump(compiler, &common->vspace, JUMP(SLJIT_FAST_CALL));
+  sljit_set_current_flags(compiler, SLJIT_SET_Z);
+  add_jump(compiler, backtracks, JUMP(type == OP_NOT_VSPACE ? SLJIT_NOT_ZERO : SLJIT_ZERO));
+  return cc;
+
+#ifdef SUPPORT_UCP
+  case OP_EXTUNI:
+  if (check_str_ptr)
+    detect_partial_match(common, backtracks);
+  read_char(common);
+  add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, gbprop));
+  /* Optimize register allocation: use a real register. */
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, STACK_TOP, 0);
+  OP1(SLJIT_MOV_U8, STACK_TOP, 0, SLJIT_MEM2(TMP1, TMP2), 3);
+
+  label = LABEL();
+  jump[0] = CMP(SLJIT_GREATER_EQUAL, STR_PTR, 0, STR_END, 0);
+  OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);
+  read_char(common);
+  add_jump(compiler, &common->getucd, JUMP(SLJIT_FAST_CALL));
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, (sljit_sw)PRIV(ucd_records) + SLJIT_OFFSETOF(ucd_record, gbprop));
+  OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM2(TMP1, TMP2), 3);
+
+  OP2(SLJIT_SHL, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, 2);
+  OP1(SLJIT_MOV_U32, TMP1, 0, SLJIT_MEM1(STACK_TOP), (sljit_sw)PRIV(ucp_gbtable));
+  OP1(SLJIT_MOV, STACK_TOP, 0, TMP2, 0);
+  OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
+  OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
+  JUMPTO(SLJIT_NOT_ZERO, label);
+
+  OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);
+  JUMPHERE(jump[0]);
+  OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
+
+  if (common->mode == JIT_PARTIAL_HARD_COMPILE)
+    {
+    jump[0] = CMP(SLJIT_LESS, STR_PTR, 0, STR_END, 0);
+    /* Since we successfully read a char above, partial matching must occure. */
+    check_partial(common, TRUE);
+    JUMPHERE(jump[0]);
+    }
+  return cc;
+#endif
+
+  case OP_CHAR:
+  case OP_CHARI:
+  length = 1;
+#ifdef SUPPORT_UTF
+  if (common->utf && HAS_EXTRALEN(*cc)) length += GET_EXTRALEN(*cc);
+#endif
+  if (common->mode == JIT_COMPILE && check_str_ptr
+      && (type == OP_CHAR || !char_has_othercase(common, cc) || char_get_othercase_bit(common, cc) != 0))
+    {
+    OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(length));
+    add_jump(compiler, backtracks, CMP(SLJIT_GREATER, STR_PTR, 0, STR_END, 0));
+
+    context.length = IN_UCHARS(length);
+    context.sourcereg = -1;
+#if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
+    context.ucharptr = 0;
+#endif
+    return byte_sequence_compare(common, type == OP_CHARI, cc, &context, backtracks);
+    }
+
+  if (check_str_ptr)
+    detect_partial_match(common, backtracks);
+#ifdef SUPPORT_UTF
+  if (common->utf)
+    {
+    GETCHAR(c, cc);
+    }
+  else
+#endif
+    c = *cc;
+
+  if (type == OP_CHAR || !char_has_othercase(common, cc))
+    {
+    read_char_range(common, c, c, FALSE);
+    add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c));
+    return cc + length;
+    }
+  oc = char_othercase(common, c);
+  read_char_range(common, c < oc ? c : oc, c > oc ? c : oc, FALSE);
+  bit = c ^ oc;
+  if (is_powerof2(bit))
+    {
+    OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, bit);
+    add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));
+    return cc + length;
+    }
+  jump[0] = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, c);
+  add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, oc));
+  JUMPHERE(jump[0]);
+  return cc + length;
+
+  case OP_NOT:
+  case OP_NOTI:
+  if (check_str_ptr)
+    detect_partial_match(common, backtracks);
+  length = 1;
+#ifdef SUPPORT_UTF
+  if (common->utf)
+    {
+#ifdef COMPILE_PCRE8
+    c = *cc;
+    if (c < 128)
+      {
+      OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(STR_PTR), 0);
+      if (type == OP_NOT || !char_has_othercase(common, cc))
+        add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, c));
+      else
+        {
+        /* Since UTF8 code page is fixed, we know that c is in [a-z] or [A-Z] range. */
+        OP2(SLJIT_OR, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x20);
+        add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, c | 0x20));
+        }
+      /* Skip the variable-length character. */
+      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+      jump[0] = CMP(SLJIT_LESS, TMP1, 0, SLJIT_IMM, 0xc0);
+      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)PRIV(utf8_table4) - 0xc0);
+      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP1, 0);
+      JUMPHERE(jump[0]);
+      return cc + 1;
+      }
+    else
+#endif /* COMPILE_PCRE8 */
+      {
+      GETCHARLEN(c, cc, length);
+      }
+    }
+  else
+#endif /* SUPPORT_UTF */
+    c = *cc;
+
+  if (type == OP_NOT || !char_has_othercase(common, cc))
+    {
+    read_char_range(common, c, c, TRUE);
+    add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, c));
+    }
+  else
+    {
+    oc = char_othercase(common, c);
+    read_char_range(common, c < oc ? c : oc, c > oc ? c : oc, TRUE);
+    bit = c ^ oc;
+    if (is_powerof2(bit))
+      {
+      OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, bit);
+      add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, c | bit));
+      }
+    else
+      {
+      add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, c));
+      add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, oc));
+      }
+    }
+  return cc + length;
+
+  case OP_CLASS:
+  case OP_NCLASS:
+  if (check_str_ptr)
+    detect_partial_match(common, backtracks);
+
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+  bit = (common->utf && is_char7_bitset((const sljit_u8 *)cc, type == OP_NCLASS)) ? 127 : 255;
+  read_char_range(common, 0, bit, type == OP_NCLASS);
+#else
+  read_char_range(common, 0, 255, type == OP_NCLASS);
+#endif
+
+  if (check_class_ranges(common, (const sljit_u8 *)cc, type == OP_NCLASS, FALSE, backtracks))
+    return cc + 32 / sizeof(pcre_uchar);
+
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+  jump[0] = NULL;
+  if (common->utf)
+    {
+    jump[0] = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, bit);
+    if (type == OP_CLASS)
+      {
+      add_jump(compiler, backtracks, jump[0]);
+      jump[0] = NULL;
+      }
+    }
+#elif !defined COMPILE_PCRE8
+  jump[0] = CMP(SLJIT_GREATER, TMP1, 0, SLJIT_IMM, 255);
+  if (type == OP_CLASS)
+    {
+    add_jump(compiler, backtracks, jump[0]);
+    jump[0] = NULL;
+    }
+#endif /* SUPPORT_UTF && COMPILE_PCRE8 */
+
+  OP2(SLJIT_AND, TMP2, 0, TMP1, 0, SLJIT_IMM, 0x7);
+  OP2(SLJIT_LSHR, TMP1, 0, TMP1, 0, SLJIT_IMM, 3);
+  OP1(SLJIT_MOV_U8, TMP1, 0, SLJIT_MEM1(TMP1), (sljit_sw)cc);
+  OP2(SLJIT_SHL, TMP2, 0, SLJIT_IMM, 1, TMP2, 0);
+  OP2(SLJIT_AND | SLJIT_SET_Z, SLJIT_UNUSED, 0, TMP1, 0, TMP2, 0);
+  add_jump(compiler, backtracks, JUMP(SLJIT_ZERO));
+
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+  if (jump[0] != NULL)
+    JUMPHERE(jump[0]);
+#endif
+  return cc + 32 / sizeof(pcre_uchar);
+
+#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+  case OP_XCLASS:
+  if (check_str_ptr)
+    detect_partial_match(common, backtracks);
+  compile_xclass_matchingpath(common, cc + LINK_SIZE, backtracks);
+  return cc + GET(cc, 0) - 1;
+#endif
+  }
+SLJIT_UNREACHABLE();
+return cc;
+}
+
+static SLJIT_INLINE pcre_uchar *compile_charn_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, jump_list **backtracks)
+{
+/* This function consumes at least one input character. */
+/* To decrease the number of length checks, we try to concatenate the fixed length character sequences. */
+DEFINE_COMPILER;
+pcre_uchar *ccbegin = cc;
+compare_context context;
+int size;
+
+context.length = 0;
+do
+  {
+  if (cc >= ccend)
+    break;
+
+  if (*cc == OP_CHAR)
+    {
+    size = 1;
+#ifdef SUPPORT_UTF
+    if (common->utf && HAS_EXTRALEN(cc[1]))
+      size += GET_EXTRALEN(cc[1]);
+#endif
+    }
+  else if (*cc == OP_CHARI)
+    {
+    size = 1;
+#ifdef SUPPORT_UTF
+    if (common->utf)
+      {
+      if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)
+        size = 0;
+      else if (HAS_EXTRALEN(cc[1]))
+        size += GET_EXTRALEN(cc[1]);
+      }
+    else
+#endif
+    if (char_has_othercase(common, cc + 1) && char_get_othercase_bit(common, cc + 1) == 0)
+      size = 0;
+    }
+  else
+    size = 0;
+
+  cc += 1 + size;
+  context.length += IN_UCHARS(size);
+  }
+while (size > 0 && context.length <= 128);
+
+cc = ccbegin;
+if (context.length > 0)
+  {
+  /* We have a fixed-length byte sequence. */
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, context.length);
+  add_jump(compiler, backtracks, CMP(SLJIT_GREATER, STR_PTR, 0, STR_END, 0));
+
+  context.sourcereg = -1;
+#if defined SLJIT_UNALIGNED && SLJIT_UNALIGNED
+  context.ucharptr = 0;
+#endif
+  do cc = byte_sequence_compare(common, *cc == OP_CHARI, cc + 1, &context, backtracks); while (context.length > 0);
+  return cc;
+  }
+
+/* A non-fixed length character will be checked if length == 0. */
+return compile_char1_matchingpath(common, *cc, cc + 1, backtracks, TRUE);
+}
+
+/* Forward definitions. */
+static void compile_matchingpath(compiler_common *, pcre_uchar *, pcre_uchar *, backtrack_common *);
+static void compile_backtrackingpath(compiler_common *, struct backtrack_common *);
+
+#define PUSH_BACKTRACK(size, ccstart, error) \
+  do \
+    { \
+    backtrack = sljit_alloc_memory(compiler, (size)); \
+    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \
+      return error; \
+    memset(backtrack, 0, size); \
+    backtrack->prev = parent->top; \
+    backtrack->cc = (ccstart); \
+    parent->top = backtrack; \
+    } \
+  while (0)
+
+#define PUSH_BACKTRACK_NOVALUE(size, ccstart) \
+  do \
+    { \
+    backtrack = sljit_alloc_memory(compiler, (size)); \
+    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \
+      return; \
+    memset(backtrack, 0, size); \
+    backtrack->prev = parent->top; \
+    backtrack->cc = (ccstart); \
+    parent->top = backtrack; \
+    } \
+  while (0)
+
+#define BACKTRACK_AS(type) ((type *)backtrack)
+
+static void compile_dnref_search(compiler_common *common, pcre_uchar *cc, jump_list **backtracks)
+{
+/* The OVECTOR offset goes to TMP2. */
+DEFINE_COMPILER;
+int count = GET2(cc, 1 + IMM2_SIZE);
+pcre_uchar *slot = common->name_table + GET2(cc, 1) * common->name_entry_size;
+unsigned int offset;
+jump_list *found = NULL;
+
+SLJIT_ASSERT(*cc == OP_DNREF || *cc == OP_DNREFI);
+
+OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1));
+
+count--;
+while (count-- > 0)
+  {
+  offset = GET2(slot, 0) << 1;
+  GET_LOCAL_BASE(TMP2, 0, OVECTOR(offset));
+  add_jump(compiler, &found, CMP(SLJIT_NOT_EQUAL, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0));
+  slot += common->name_entry_size;
+  }
+
+offset = GET2(slot, 0) << 1;
+GET_LOCAL_BASE(TMP2, 0, OVECTOR(offset));
+if (backtracks != NULL && !common->jscript_compat)
+  add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0));
+
+set_jumps(found, LABEL());
+}
+
+static void compile_ref_matchingpath(compiler_common *common, pcre_uchar *cc, jump_list **backtracks, BOOL withchecks, BOOL emptyfail)
+{
+DEFINE_COMPILER;
+BOOL ref = (*cc == OP_REF || *cc == OP_REFI);
+int offset = 0;
+struct sljit_jump *jump = NULL;
+struct sljit_jump *partial;
+struct sljit_jump *nopartial;
+
+if (ref)
+  {
+  offset = GET2(cc, 1) << 1;
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));
+  /* OVECTOR(1) contains the "string begin - 1" constant. */
+  if (withchecks && !common->jscript_compat)
+    add_jump(compiler, backtracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1)));
+  }
+else
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
+
+#if defined SUPPORT_UTF && defined SUPPORT_UCP
+if (common->utf && *cc == OP_REFI)
+  {
+  SLJIT_ASSERT(TMP1 == SLJIT_R0 && STACK_TOP == SLJIT_R1);
+  if (ref)
+    OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));
+  else
+    OP1(SLJIT_MOV, SLJIT_R2, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
+
+  if (withchecks)
+    jump = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_R2, 0);
+
+  /* No free saved registers so save data on stack. */
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, STACK_TOP, 0);
+  OP1(SLJIT_MOV, SLJIT_R1, 0, STR_PTR, 0);
+  OP1(SLJIT_MOV, SLJIT_R3, 0, STR_END, 0);
+  sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_RET(SW) | SLJIT_ARG1(SW) | SLJIT_ARG2(SW) | SLJIT_ARG3(SW) | SLJIT_ARG4(SW), SLJIT_IMM, SLJIT_FUNC_OFFSET(do_utf_caselesscmp));
+  OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
+  OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_RETURN_REG, 0);
+
+  if (common->mode == JIT_COMPILE)
+    add_jump(compiler, backtracks, CMP(SLJIT_LESS_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1));
+  else
+    {
+    OP2(SLJIT_SUB | SLJIT_SET_Z | SLJIT_SET_LESS, SLJIT_UNUSED, 0, SLJIT_RETURN_REG, 0, SLJIT_IMM, 1);
+
+    add_jump(compiler, backtracks, JUMP(SLJIT_LESS));
+
+    nopartial = JUMP(SLJIT_NOT_EQUAL);
+    OP1(SLJIT_MOV, STR_PTR, 0, STR_END, 0);
+    check_partial(common, FALSE);
+    add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
+    JUMPHERE(nopartial);
+    }
+  }
+else
+#endif /* SUPPORT_UTF && SUPPORT_UCP */
+  {
+  if (ref)
+    OP2(SLJIT_SUB | SLJIT_SET_Z, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), TMP1, 0);
+  else
+    OP2(SLJIT_SUB | SLJIT_SET_Z, TMP2, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw), TMP1, 0);
+
+  if (withchecks)
+    jump = JUMP(SLJIT_ZERO);
+
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, TMP2, 0);
+  partial = CMP(SLJIT_GREATER, STR_PTR, 0, STR_END, 0);
+  if (common->mode == JIT_COMPILE)
+    add_jump(compiler, backtracks, partial);
+
+  add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));
+  add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+
+  if (common->mode != JIT_COMPILE)
+    {
+    nopartial = JUMP(SLJIT_JUMP);
+    JUMPHERE(partial);
+    /* TMP2 -= STR_END - STR_PTR */
+    OP2(SLJIT_SUB, TMP2, 0, TMP2, 0, STR_PTR, 0);
+    OP2(SLJIT_ADD, TMP2, 0, TMP2, 0, STR_END, 0);
+    partial = CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, 0);
+    OP1(SLJIT_MOV, STR_PTR, 0, STR_END, 0);
+    add_jump(compiler, *cc == OP_REF ? &common->casefulcmp : &common->caselesscmp, JUMP(SLJIT_FAST_CALL));
+    add_jump(compiler, backtracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+    JUMPHERE(partial);
+    check_partial(common, FALSE);
+    add_jump(compiler, backtracks, JUMP(SLJIT_JUMP));
+    JUMPHERE(nopartial);
+    }
+  }
+
+if (jump != NULL)
+  {
+  if (emptyfail)
+    add_jump(compiler, backtracks, jump);
+  else
+    JUMPHERE(jump);
+  }
+}
+
+static SLJIT_INLINE pcre_uchar *compile_ref_iterator_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
+{
+DEFINE_COMPILER;
+BOOL ref = (*cc == OP_REF || *cc == OP_REFI);
+backtrack_common *backtrack;
+pcre_uchar type;
+int offset = 0;
+struct sljit_label *label;
+struct sljit_jump *zerolength;
+struct sljit_jump *jump = NULL;
+pcre_uchar *ccbegin = cc;
+int min = 0, max = 0;
+BOOL minimize;
+
+PUSH_BACKTRACK(sizeof(ref_iterator_backtrack), cc, NULL);
+
+if (ref)
+  offset = GET2(cc, 1) << 1;
+else
+  cc += IMM2_SIZE;
+type = cc[1 + IMM2_SIZE];
+
+SLJIT_COMPILE_ASSERT((OP_CRSTAR & 0x1) == 0, crstar_opcode_must_be_even);
+minimize = (type & 0x1) != 0;
+switch(type)
+  {
+  case OP_CRSTAR:
+  case OP_CRMINSTAR:
+  min = 0;
+  max = 0;
+  cc += 1 + IMM2_SIZE + 1;
+  break;
+  case OP_CRPLUS:
+  case OP_CRMINPLUS:
+  min = 1;
+  max = 0;
+  cc += 1 + IMM2_SIZE + 1;
+  break;
+  case OP_CRQUERY:
+  case OP_CRMINQUERY:
+  min = 0;
+  max = 1;
+  cc += 1 + IMM2_SIZE + 1;
+  break;
+  case OP_CRRANGE:
+  case OP_CRMINRANGE:
+  min = GET2(cc, 1 + IMM2_SIZE + 1);
+  max = GET2(cc, 1 + IMM2_SIZE + 1 + IMM2_SIZE);
+  cc += 1 + IMM2_SIZE + 1 + 2 * IMM2_SIZE;
+  break;
+  default:
+  SLJIT_UNREACHABLE();
+  break;
+  }
+
+if (!minimize)
+  {
+  if (min == 0)
+    {
+    allocate_stack(common, 2);
+    if (ref)
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);
+    /* Temporary release of STR_PTR. */
+    OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
+    /* Handles both invalid and empty cases. Since the minimum repeat,
+    is zero the invalid case is basically the same as an empty case. */
+    if (ref)
+      zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));
+    else
+      {
+      compile_dnref_search(common, ccbegin, NULL);
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1, TMP2, 0);
+      zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
+      }
+    /* Restore if not zero length. */
+    OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
+    }
+  else
+    {
+    allocate_stack(common, 1);
+    if (ref)
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
+    if (ref)
+      {
+      add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1)));
+      zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));
+      }
+    else
+      {
+      compile_dnref_search(common, ccbegin, &backtrack->topbacktracks);
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1, TMP2, 0);
+      zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
+      }
+    }
+
+  if (min > 1 || max > 1)
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0, SLJIT_IMM, 0);
+
+  label = LABEL();
+  if (!ref)
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1);
+  compile_ref_matchingpath(common, ccbegin, &backtrack->topbacktracks, FALSE, FALSE);
+
+  if (min > 1 || max > 1)
+    {
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0);
+    OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0, TMP1, 0);
+    if (min > 1)
+      CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, min, label);
+    if (max > 1)
+      {
+      jump = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, max);
+      allocate_stack(common, 1);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+      JUMPTO(SLJIT_JUMP, label);
+      JUMPHERE(jump);
+      }
+    }
+
+  if (max == 0)
+    {
+    /* Includes min > 1 case as well. */
+    allocate_stack(common, 1);
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+    JUMPTO(SLJIT_JUMP, label);
+    }
+
+  JUMPHERE(zerolength);
+  BACKTRACK_AS(ref_iterator_backtrack)->matchingpath = LABEL();
+
+  count_match(common);
+  return cc;
+  }
+
+allocate_stack(common, ref ? 2 : 3);
+if (ref)
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));
+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
+if (type != OP_CRMINSTAR)
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);
+
+if (min == 0)
+  {
+  /* Handles both invalid and empty cases. Since the minimum repeat,
+  is zero the invalid case is basically the same as an empty case. */
+  if (ref)
+    zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));
+  else
+    {
+    compile_dnref_search(common, ccbegin, NULL);
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP2, 0);
+    zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
+    }
+  /* Length is non-zero, we can match real repeats. */
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+  jump = JUMP(SLJIT_JUMP);
+  }
+else
+  {
+  if (ref)
+    {
+    add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1)));
+    zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));
+    }
+  else
+    {
+    compile_dnref_search(common, ccbegin, &backtrack->topbacktracks);
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), 0);
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP2, 0);
+    zerolength = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_MEM1(TMP2), sizeof(sljit_sw));
+    }
+  }
+
+BACKTRACK_AS(ref_iterator_backtrack)->matchingpath = LABEL();
+if (max > 0)
+  add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_GREATER_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, max));
+
+if (!ref)
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(2));
+compile_ref_matchingpath(common, ccbegin, &backtrack->topbacktracks, TRUE, TRUE);
+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+
+if (min > 1)
+  {
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
+  OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
+  CMPTO(SLJIT_LESS, TMP1, 0, SLJIT_IMM, min, BACKTRACK_AS(ref_iterator_backtrack)->matchingpath);
+  }
+else if (max > 0)
+  OP2(SLJIT_ADD, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 1);
+
+if (jump != NULL)
+  JUMPHERE(jump);
+JUMPHERE(zerolength);
+
+count_match(common);
+return cc;
+}
+
+static SLJIT_INLINE pcre_uchar *compile_recurse_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
+{
+DEFINE_COMPILER;
+backtrack_common *backtrack;
+recurse_entry *entry = common->entries;
+recurse_entry *prev = NULL;
+sljit_sw start = GET(cc, 1);
+pcre_uchar *start_cc;
+BOOL needs_control_head;
+
+PUSH_BACKTRACK(sizeof(recurse_backtrack), cc, NULL);
+
+/* Inlining simple patterns. */
+if (get_framesize(common, common->start + start, NULL, TRUE, &needs_control_head) == no_stack)
+  {
+  start_cc = common->start + start;
+  compile_matchingpath(common, next_opcode(common, start_cc), bracketend(start_cc) - (1 + LINK_SIZE), backtrack);
+  BACKTRACK_AS(recurse_backtrack)->inlined_pattern = TRUE;
+  return cc + 1 + LINK_SIZE;
+  }
+
+while (entry != NULL)
+  {
+  if (entry->start == start)
+    break;
+  prev = entry;
+  entry = entry->next;
+  }
+
+if (entry == NULL)
+  {
+  entry = sljit_alloc_memory(compiler, sizeof(recurse_entry));
+  if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
+    return NULL;
+  entry->next = NULL;
+  entry->entry = NULL;
+  entry->calls = NULL;
+  entry->start = start;
+
+  if (prev != NULL)
+    prev->next = entry;
+  else
+    common->entries = entry;
+  }
+
+if (common->has_set_som && common->mark_ptr != 0)
+  {
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));
+  allocate_stack(common, 2);
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
+  }
+else if (common->has_set_som || common->mark_ptr != 0)
+  {
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->has_set_som ? (int)(OVECTOR(0)) : common->mark_ptr);
+  allocate_stack(common, 1);
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+  }
+
+if (entry->entry == NULL)
+  add_jump(compiler, &entry->calls, JUMP(SLJIT_FAST_CALL));
+else
+  JUMPTO(SLJIT_FAST_CALL, entry->entry);
+/* Leave if the match is failed. */
+add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0));
+return cc + 1 + LINK_SIZE;
+}
+
+static sljit_s32 SLJIT_FUNC do_callout(struct jit_arguments *arguments, PUBL(callout_block) *callout_block, pcre_uchar **jit_ovector)
+{
+const pcre_uchar *begin = arguments->begin;
+int *offset_vector = arguments->offsets;
+int offset_count = arguments->offset_count;
+int i;
+
+if (PUBL(callout) == NULL)
+  return 0;
+
+callout_block->version = 2;
+callout_block->callout_data = arguments->callout_data;
+
+/* Offsets in subject. */
+callout_block->subject_length = arguments->end - arguments->begin;
+callout_block->start_match = (pcre_uchar*)callout_block->subject - arguments->begin;
+callout_block->current_position = (pcre_uchar*)callout_block->offset_vector - arguments->begin;
+#if defined COMPILE_PCRE8
+callout_block->subject = (PCRE_SPTR)begin;
+#elif defined COMPILE_PCRE16
+callout_block->subject = (PCRE_SPTR16)begin;
+#elif defined COMPILE_PCRE32
+callout_block->subject = (PCRE_SPTR32)begin;
+#endif
+
+/* Convert and copy the JIT offset vector to the offset_vector array. */
+callout_block->capture_top = 0;
+callout_block->offset_vector = offset_vector;
+for (i = 2; i < offset_count; i += 2)
+  {
+  offset_vector[i] = jit_ovector[i] - begin;
+  offset_vector[i + 1] = jit_ovector[i + 1] - begin;
+  if (jit_ovector[i] >= begin)
+    callout_block->capture_top = i;
+  }
+
+callout_block->capture_top = (callout_block->capture_top >> 1) + 1;
+if (offset_count > 0)
+  offset_vector[0] = -1;
+if (offset_count > 1)
+  offset_vector[1] = -1;
+return (*PUBL(callout))(callout_block);
+}
+
+/* Aligning to 8 byte. */
+#define CALLOUT_ARG_SIZE \
+    (((int)sizeof(PUBL(callout_block)) + 7) & ~7)
+
+#define CALLOUT_ARG_OFFSET(arg) \
+    SLJIT_OFFSETOF(PUBL(callout_block), arg)
+
+static SLJIT_INLINE pcre_uchar *compile_callout_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
+{
+DEFINE_COMPILER;
+backtrack_common *backtrack;
+
+PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);
+
+allocate_stack(common, CALLOUT_ARG_SIZE / sizeof(sljit_sw));
+
+SLJIT_ASSERT(common->capture_last_ptr != 0);
+OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);
+OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
+OP1(SLJIT_MOV_S32, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(callout_number), SLJIT_IMM, cc[1]);
+OP1(SLJIT_MOV_S32, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(capture_last), TMP2, 0);
+
+/* These pointer sized fields temporarly stores internal variables. */
+OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));
+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(offset_vector), STR_PTR, 0);
+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(subject), TMP2, 0);
+
+if (common->mark_ptr != 0)
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr));
+OP1(SLJIT_MOV_S32, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(pattern_position), SLJIT_IMM, GET(cc, 2));
+OP1(SLJIT_MOV_S32, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(next_item_length), SLJIT_IMM, GET(cc, 2 + LINK_SIZE));
+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), CALLOUT_ARG_OFFSET(mark), (common->mark_ptr != 0) ? TMP2 : SLJIT_IMM, 0);
+
+/* Needed to save important temporary registers. */
+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, STACK_TOP, 0);
+/* SLJIT_R0 = arguments */
+OP1(SLJIT_MOV, SLJIT_R1, 0, STACK_TOP, 0);
+GET_LOCAL_BASE(SLJIT_R2, 0, OVECTOR_START);
+sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_RET(S32) | SLJIT_ARG1(SW) | SLJIT_ARG2(SW) | SLJIT_ARG3(SW), SLJIT_IMM, SLJIT_FUNC_OFFSET(do_callout));
+OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
+free_stack(common, CALLOUT_ARG_SIZE / sizeof(sljit_sw));
+
+/* Check return value. */
+OP2(SLJIT_SUB32 | SLJIT_SET_Z | SLJIT_SET_SIG_GREATER, SLJIT_UNUSED, 0, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0);
+add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_SIG_GREATER32));
+if (common->forced_quit_label == NULL)
+  add_jump(compiler, &common->forced_quit, JUMP(SLJIT_NOT_EQUAL32) /* SIG_LESS */);
+else
+  JUMPTO(SLJIT_NOT_EQUAL32 /* SIG_LESS */, common->forced_quit_label);
+return cc + 2 + 2 * LINK_SIZE;
+}
+
+#undef CALLOUT_ARG_SIZE
+#undef CALLOUT_ARG_OFFSET
+
+static SLJIT_INLINE BOOL assert_needs_str_ptr_saving(pcre_uchar *cc)
+{
+while (TRUE)
+  {
+  switch (*cc)
+    {
+    case OP_NOT_WORD_BOUNDARY:
+    case OP_WORD_BOUNDARY:
+    case OP_CIRC:
+    case OP_CIRCM:
+    case OP_DOLL:
+    case OP_DOLLM:
+    case OP_CALLOUT:
+    case OP_ALT:
+    cc += PRIV(OP_lengths)[*cc];
+    break;
+
+    case OP_KET:
+    return FALSE;
+
+    default:
+    return TRUE;
+    }
+  }
+}
+
+static pcre_uchar *compile_assert_matchingpath(compiler_common *common, pcre_uchar *cc, assert_backtrack *backtrack, BOOL conditional)
+{
+DEFINE_COMPILER;
+int framesize;
+int extrasize;
+BOOL needs_control_head;
+int private_data_ptr;
+backtrack_common altbacktrack;
+pcre_uchar *ccbegin;
+pcre_uchar opcode;
+pcre_uchar bra = OP_BRA;
+jump_list *tmp = NULL;
+jump_list **target = (conditional) ? &backtrack->condfailed : &backtrack->common.topbacktracks;
+jump_list **found;
+/* Saving previous accept variables. */
+BOOL save_local_exit = common->local_exit;
+BOOL save_positive_assert = common->positive_assert;
+then_trap_backtrack *save_then_trap = common->then_trap;
+struct sljit_label *save_quit_label = common->quit_label;
+struct sljit_label *save_accept_label = common->accept_label;
+jump_list *save_quit = common->quit;
+jump_list *save_positive_assert_quit = common->positive_assert_quit;
+jump_list *save_accept = common->accept;
+struct sljit_jump *jump;
+struct sljit_jump *brajump = NULL;
+
+/* Assert captures then. */
+common->then_trap = NULL;
+
+if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
+  {
+  SLJIT_ASSERT(!conditional);
+  bra = *cc;
+  cc++;
+  }
+private_data_ptr = PRIVATE_DATA(cc);
+SLJIT_ASSERT(private_data_ptr != 0);
+framesize = get_framesize(common, cc, NULL, FALSE, &needs_control_head);
+backtrack->framesize = framesize;
+backtrack->private_data_ptr = private_data_ptr;
+opcode = *cc;
+SLJIT_ASSERT(opcode >= OP_ASSERT && opcode <= OP_ASSERTBACK_NOT);
+found = (opcode == OP_ASSERT || opcode == OP_ASSERTBACK) ? &tmp : target;
+ccbegin = cc;
+cc += GET(cc, 1);
+
+if (bra == OP_BRAMINZERO)
+  {
+  /* This is a braminzero backtrack path. */
+  OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+  free_stack(common, 1);
+  brajump = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
+  }
+
+if (framesize < 0)
+  {
+  extrasize = 1;
+  if (bra == OP_BRA && !assert_needs_str_ptr_saving(ccbegin + 1 + LINK_SIZE))
+    extrasize = 0;
+
+  if (needs_control_head)
+    extrasize++;
+
+  if (framesize == no_frame)
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STACK_TOP, 0);
+
+  if (extrasize > 0)
+    allocate_stack(common, extrasize);
+
+  if (needs_control_head)
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
+
+  if (extrasize > 0)
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+
+  if (needs_control_head)
+    {
+    SLJIT_ASSERT(extrasize == 2);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_IMM, 0);
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
+    }
+  }
+else
+  {
+  extrasize = needs_control_head ? 3 : 2;
+  allocate_stack(common, framesize + extrasize);
+
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+  OP2(SLJIT_ADD, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + extrasize) * sizeof(sljit_sw));
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP2, 0);
+  if (needs_control_head)
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+
+  if (needs_control_head)
+    {
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP1, 0);
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_IMM, 0);
+    }
+  else
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0);
+
+  init_frame(common, ccbegin, NULL, framesize + extrasize - 1, extrasize, FALSE);
+  }
+
+memset(&altbacktrack, 0, sizeof(backtrack_common));
+if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
+  {
+  /* Negative assert is stronger than positive assert. */
+  common->local_exit = TRUE;
+  common->quit_label = NULL;
+  common->quit = NULL;
+  common->positive_assert = FALSE;
+  }
+else
+  common->positive_assert = TRUE;
+common->positive_assert_quit = NULL;
+
+while (1)
+  {
+  common->accept_label = NULL;
+  common->accept = NULL;
+  altbacktrack.top = NULL;
+  altbacktrack.topbacktracks = NULL;
+
+  if (*ccbegin == OP_ALT && extrasize > 0)
+    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+
+  altbacktrack.cc = ccbegin;
+  compile_matchingpath(common, ccbegin + 1 + LINK_SIZE, cc, &altbacktrack);
+  if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
+    {
+    if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
+      {
+      common->local_exit = save_local_exit;
+      common->quit_label = save_quit_label;
+      common->quit = save_quit;
+      }
+    common->positive_assert = save_positive_assert;
+    common->then_trap = save_then_trap;
+    common->accept_label = save_accept_label;
+    common->positive_assert_quit = save_positive_assert_quit;
+    common->accept = save_accept;
+    return NULL;
+    }
+  common->accept_label = LABEL();
+  if (common->accept != NULL)
+    set_jumps(common->accept, common->accept_label);
+
+  /* Reset stack. */
+  if (framesize < 0)
+    {
+    if (framesize == no_frame)
+      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+    else if (extrasize > 0)
+      free_stack(common, extrasize);
+
+    if (needs_control_head)
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(-1));
+    }
+  else
+    {
+    if ((opcode != OP_ASSERT_NOT && opcode != OP_ASSERTBACK_NOT) || conditional)
+      {
+      /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */
+      OP2(SLJIT_SUB, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_sw));
+      if (needs_control_head)
+        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(-1));
+      }
+    else
+      {
+      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+      if (needs_control_head)
+        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(-framesize - 2));
+      add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
+      }
+    }
+
+  if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
+    {
+    /* We know that STR_PTR was stored on the top of the stack. */
+    if (conditional)
+      {
+      if (extrasize > 0)
+        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), needs_control_head ? STACK(-2) : STACK(-1));
+      }
+    else if (bra == OP_BRAZERO)
+      {
+      if (framesize < 0)
+        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(-extrasize));
+      else
+        {
+        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(-framesize - 1));
+        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(-framesize - extrasize));
+        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP1, 0);
+        }
+      OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
+      }
+    else if (framesize >= 0)
+      {
+      /* For OP_BRA and OP_BRAMINZERO. */
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(-framesize - 1));
+      }
+    }
+  add_jump(compiler, found, JUMP(SLJIT_JUMP));
+
+  compile_backtrackingpath(common, altbacktrack.top);
+  if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
+    {
+    if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
+      {
+      common->local_exit = save_local_exit;
+      common->quit_label = save_quit_label;
+      common->quit = save_quit;
+      }
+    common->positive_assert = save_positive_assert;
+    common->then_trap = save_then_trap;
+    common->accept_label = save_accept_label;
+    common->positive_assert_quit = save_positive_assert_quit;
+    common->accept = save_accept;
+    return NULL;
+    }
+  set_jumps(altbacktrack.topbacktracks, LABEL());
+
+  if (*cc != OP_ALT)
+    break;
+
+  ccbegin = cc;
+  cc += GET(cc, 1);
+  }
+
+if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
+  {
+  SLJIT_ASSERT(common->positive_assert_quit == NULL);
+  /* Makes the check less complicated below. */
+  common->positive_assert_quit = common->quit;
+  }
+
+/* None of them matched. */
+if (common->positive_assert_quit != NULL)
+  {
+  jump = JUMP(SLJIT_JUMP);
+  set_jumps(common->positive_assert_quit, LABEL());
+  SLJIT_ASSERT(framesize != no_stack);
+  if (framesize < 0)
+    OP2(SLJIT_SUB, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_IMM, extrasize * sizeof(sljit_sw));
+  else
+    {
+    OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+    add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
+    OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + extrasize) * sizeof(sljit_sw));
+    }
+  JUMPHERE(jump);
+  }
+
+if (needs_control_head)
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(1));
+
+if (opcode == OP_ASSERT || opcode == OP_ASSERTBACK)
+  {
+  /* Assert is failed. */
+  if ((conditional && extrasize > 0) || bra == OP_BRAZERO)
+    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+
+  if (framesize < 0)
+    {
+    /* The topmost item should be 0. */
+    if (bra == OP_BRAZERO)
+      {
+      if (extrasize == 2)
+        free_stack(common, 1);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
+      }
+    else if (extrasize > 0)
+      free_stack(common, extrasize);
+    }
+  else
+    {
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(extrasize - 1));
+    /* The topmost item should be 0. */
+    if (bra == OP_BRAZERO)
+      {
+      free_stack(common, framesize + extrasize - 1);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
+      }
+    else
+      free_stack(common, framesize + extrasize);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP1, 0);
+    }
+  jump = JUMP(SLJIT_JUMP);
+  if (bra != OP_BRAZERO)
+    add_jump(compiler, target, jump);
+
+  /* Assert is successful. */
+  set_jumps(tmp, LABEL());
+  if (framesize < 0)
+    {
+    /* We know that STR_PTR was stored on the top of the stack. */
+    if (extrasize > 0)
+      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(-extrasize));
+
+    /* Keep the STR_PTR on the top of the stack. */
+    if (bra == OP_BRAZERO)
+      {
+      OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
+      if (extrasize == 2)
+        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+      }
+    else if (bra == OP_BRAMINZERO)
+      {
+      OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
+      }
+    }
+  else
+    {
+    if (bra == OP_BRA)
+      {
+      /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */
+      OP2(SLJIT_SUB, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_IMM, (framesize + 1) * sizeof(sljit_sw));
+      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(-extrasize + 1));
+      }
+    else
+      {
+      /* We don't need to keep the STR_PTR, only the previous private_data_ptr. */
+      OP2(SLJIT_SUB, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_IMM, (framesize + 2) * sizeof(sljit_sw));
+      if (extrasize == 2)
+        {
+        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+        if (bra == OP_BRAMINZERO)
+          OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
+        }
+      else
+        {
+        OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), 0);
+        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), bra == OP_BRAZERO ? STR_PTR : SLJIT_IMM, 0);
+        }
+      }
+    }
+
+  if (bra == OP_BRAZERO)
+    {
+    backtrack->matchingpath = LABEL();
+    SET_LABEL(jump, backtrack->matchingpath);
+    }
+  else if (bra == OP_BRAMINZERO)
+    {
+    JUMPTO(SLJIT_JUMP, backtrack->matchingpath);
+    JUMPHERE(brajump);
+    if (framesize >= 0)
+      {
+      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+      add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(-framesize - 1));
+      }
+    set_jumps(backtrack->common.topbacktracks, LABEL());
+    }
+  }
+else
+  {
+  /* AssertNot is successful. */
+  if (framesize < 0)
+    {
+    if (extrasize > 0)
+      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+
+    if (bra != OP_BRA)
+      {
+      if (extrasize == 2)
+        free_stack(common, 1);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
+      }
+    else if (extrasize > 0)
+      free_stack(common, extrasize);
+    }
+  else
+    {
+    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(extrasize - 1));
+    /* The topmost item should be 0. */
+    if (bra != OP_BRA)
+      {
+      free_stack(common, framesize + extrasize - 1);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
+      }
+    else
+      free_stack(common, framesize + extrasize);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP1, 0);
+    }
+
+  if (bra == OP_BRAZERO)
+    backtrack->matchingpath = LABEL();
+  else if (bra == OP_BRAMINZERO)
+    {
+    JUMPTO(SLJIT_JUMP, backtrack->matchingpath);
+    JUMPHERE(brajump);
+    }
+
+  if (bra != OP_BRA)
+    {
+    SLJIT_ASSERT(found == &backtrack->common.topbacktracks);
+    set_jumps(backtrack->common.topbacktracks, LABEL());
+    backtrack->common.topbacktracks = NULL;
+    }
+  }
+
+if (opcode == OP_ASSERT_NOT || opcode == OP_ASSERTBACK_NOT)
+  {
+  common->local_exit = save_local_exit;
+  common->quit_label = save_quit_label;
+  common->quit = save_quit;
+  }
+common->positive_assert = save_positive_assert;
+common->then_trap = save_then_trap;
+common->accept_label = save_accept_label;
+common->positive_assert_quit = save_positive_assert_quit;
+common->accept = save_accept;
+return cc + 1 + LINK_SIZE;
+}
+
+static SLJIT_INLINE void match_once_common(compiler_common *common, pcre_uchar ket, int framesize, int private_data_ptr, BOOL has_alternatives, BOOL needs_control_head)
+{
+DEFINE_COMPILER;
+int stacksize;
+
+if (framesize < 0)
+  {
+  if (framesize == no_frame)
+    OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+  else
+    {
+    stacksize = needs_control_head ? 1 : 0;
+    if (ket != OP_KET || has_alternatives)
+      stacksize++;
+
+    if (stacksize > 0)
+      free_stack(common, stacksize);
+    }
+
+  if (needs_control_head)
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), (ket != OP_KET || has_alternatives) ? STACK(-2) : STACK(-1));
+
+  /* TMP2 which is set here used by OP_KETRMAX below. */
+  if (ket == OP_KETRMAX)
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(-1));
+  else if (ket == OP_KETRMIN)
+    {
+    /* Move the STR_PTR to the private_data_ptr. */
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(-1));
+    }
+  }
+else
+  {
+  stacksize = (ket != OP_KET || has_alternatives) ? 2 : 1;
+  OP2(SLJIT_SUB, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_IMM, (framesize + stacksize) * sizeof(sljit_sw));
+  if (needs_control_head)
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(-1));
+
+  if (ket == OP_KETRMAX)
+    {
+    /* TMP2 which is set here used by OP_KETRMAX below. */
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+    }
+  }
+if (needs_control_head)
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, TMP1, 0);
+}
+
+static SLJIT_INLINE int match_capture_common(compiler_common *common, int stacksize, int offset, int private_data_ptr)
+{
+DEFINE_COMPILER;
+
+if (common->capture_last_ptr != 0)
+  {
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, SLJIT_IMM, offset >> 1);
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);
+  stacksize++;
+  }
+if (common->optimized_cbracket[offset >> 1] == 0)
+  {
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize + 1), TMP2, 0);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), STR_PTR, 0);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);
+  stacksize += 2;
+  }
+return stacksize;
+}
+
+/*
+  Handling bracketed expressions is probably the most complex part.
+
+  Stack layout naming characters:
+    S - Push the current STR_PTR
+    0 - Push a 0 (NULL)
+    A - Push the current STR_PTR. Needed for restoring the STR_PTR
+        before the next alternative. Not pushed if there are no alternatives.
+    M - Any values pushed by the current alternative. Can be empty, or anything.
+    C - Push the previous OVECTOR(i), OVECTOR(i+1) and OVECTOR_PRIV(i) to the stack.
+    L - Push the previous local (pointed by localptr) to the stack
+   () - opional values stored on the stack
+  ()* - optonal, can be stored multiple times
+
+  The following list shows the regular expression templates, their PCRE byte codes
+  and stack layout supported by pcre-sljit.
+
+  (?:)                     OP_BRA     | OP_KET                A M
+  ()                       OP_CBRA    | OP_KET                C M
+  (?:)+                    OP_BRA     | OP_KETRMAX        0   A M S   ( A M S )*
+                           OP_SBRA    | OP_KETRMAX        0   L M S   ( L M S )*
+  (?:)+?                   OP_BRA     | OP_KETRMIN        0   A M S   ( A M S )*
+                           OP_SBRA    | OP_KETRMIN        0   L M S   ( L M S )*
+  ()+                      OP_CBRA    | OP_KETRMAX        0   C M S   ( C M S )*
+                           OP_SCBRA   | OP_KETRMAX        0   C M S   ( C M S )*
+  ()+?                     OP_CBRA    | OP_KETRMIN        0   C M S   ( C M S )*
+                           OP_SCBRA   | OP_KETRMIN        0   C M S   ( C M S )*
+  (?:)?    OP_BRAZERO    | OP_BRA     | OP_KET            S ( A M 0 )
+  (?:)??   OP_BRAMINZERO | OP_BRA     | OP_KET            S ( A M 0 )
+  ()?      OP_BRAZERO    | OP_CBRA    | OP_KET            S ( C M 0 )
+  ()??     OP_BRAMINZERO | OP_CBRA    | OP_KET            S ( C M 0 )
+  (?:)*    OP_BRAZERO    | OP_BRA     | OP_KETRMAX      S 0 ( A M S )*
+           OP_BRAZERO    | OP_SBRA    | OP_KETRMAX      S 0 ( L M S )*
+  (?:)*?   OP_BRAMINZERO | OP_BRA     | OP_KETRMIN      S 0 ( A M S )*
+           OP_BRAMINZERO | OP_SBRA    | OP_KETRMIN      S 0 ( L M S )*
+  ()*      OP_BRAZERO    | OP_CBRA    | OP_KETRMAX      S 0 ( C M S )*
+           OP_BRAZERO    | OP_SCBRA   | OP_KETRMAX      S 0 ( C M S )*
+  ()*?     OP_BRAMINZERO | OP_CBRA    | OP_KETRMIN      S 0 ( C M S )*
+           OP_BRAMINZERO | OP_SCBRA   | OP_KETRMIN      S 0 ( C M S )*
+
+
+  Stack layout naming characters:
+    A - Push the alternative index (starting from 0) on the stack.
+        Not pushed if there is no alternatives.
+    M - Any values pushed by the current alternative. Can be empty, or anything.
+
+  The next list shows the possible content of a bracket:
+  (|)     OP_*BRA    | OP_ALT ...         M A
+  (?()|)  OP_*COND   | OP_ALT             M A
+  (?>|)   OP_ONCE    | OP_ALT ...         [stack trace] M A
+  (?>|)   OP_ONCE_NC | OP_ALT ...         [stack trace] M A
+                                          Or nothing, if trace is unnecessary
+*/
+
+static pcre_uchar *compile_bracket_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
+{
+DEFINE_COMPILER;
+backtrack_common *backtrack;
+pcre_uchar opcode;
+int private_data_ptr = 0;
+int offset = 0;
+int i, stacksize;
+int repeat_ptr = 0, repeat_length = 0;
+int repeat_type = 0, repeat_count = 0;
+pcre_uchar *ccbegin;
+pcre_uchar *matchingpath;
+pcre_uchar *slot;
+pcre_uchar bra = OP_BRA;
+pcre_uchar ket;
+assert_backtrack *assert;
+BOOL has_alternatives;
+BOOL needs_control_head = FALSE;
+struct sljit_jump *jump;
+struct sljit_jump *skip;
+struct sljit_label *rmax_label = NULL;
+struct sljit_jump *braminzero = NULL;
+
+PUSH_BACKTRACK(sizeof(bracket_backtrack), cc, NULL);
+
+if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
+  {
+  bra = *cc;
+  cc++;
+  opcode = *cc;
+  }
+
+opcode = *cc;
+ccbegin = cc;
+matchingpath = bracketend(cc) - 1 - LINK_SIZE;
+ket = *matchingpath;
+if (ket == OP_KET && PRIVATE_DATA(matchingpath) != 0)
+  {
+  repeat_ptr = PRIVATE_DATA(matchingpath);
+  repeat_length = PRIVATE_DATA(matchingpath + 1);
+  repeat_type = PRIVATE_DATA(matchingpath + 2);
+  repeat_count = PRIVATE_DATA(matchingpath + 3);
+  SLJIT_ASSERT(repeat_length != 0 && repeat_type != 0 && repeat_count != 0);
+  if (repeat_type == OP_UPTO)
+    ket = OP_KETRMAX;
+  if (repeat_type == OP_MINUPTO)
+    ket = OP_KETRMIN;
+  }
+
+if ((opcode == OP_COND || opcode == OP_SCOND) && cc[1 + LINK_SIZE] == OP_DEF)
+  {
+  /* Drop this bracket_backtrack. */
+  parent->top = backtrack->prev;
+  return matchingpath + 1 + LINK_SIZE + repeat_length;
+  }
+
+matchingpath = ccbegin + 1 + LINK_SIZE;
+SLJIT_ASSERT(ket == OP_KET || ket == OP_KETRMAX || ket == OP_KETRMIN);
+SLJIT_ASSERT(!((bra == OP_BRAZERO && ket == OP_KETRMIN) || (bra == OP_BRAMINZERO && ket == OP_KETRMAX)));
+cc += GET(cc, 1);
+
+has_alternatives = *cc == OP_ALT;
+if (SLJIT_UNLIKELY(opcode == OP_COND || opcode == OP_SCOND))
+  has_alternatives = (*matchingpath == OP_RREF || *matchingpath == OP_DNRREF || *matchingpath == OP_FAIL) ? FALSE : TRUE;
+
+if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))
+  opcode = OP_SCOND;
+if (SLJIT_UNLIKELY(opcode == OP_ONCE_NC))
+  opcode = OP_ONCE;
+
+if (opcode == OP_CBRA || opcode == OP_SCBRA)
+  {
+  /* Capturing brackets has a pre-allocated space. */
+  offset = GET2(ccbegin, 1 + LINK_SIZE);
+  if (common->optimized_cbracket[offset] == 0)
+    {
+    private_data_ptr = OVECTOR_PRIV(offset);
+    offset <<= 1;
+    }
+  else
+    {
+    offset <<= 1;
+    private_data_ptr = OVECTOR(offset);
+    }
+  BACKTRACK_AS(bracket_backtrack)->private_data_ptr = private_data_ptr;
+  matchingpath += IMM2_SIZE;
+  }
+else if (opcode == OP_ONCE || opcode == OP_SBRA || opcode == OP_SCOND)
+  {
+  /* Other brackets simply allocate the next entry. */
+  private_data_ptr = PRIVATE_DATA(ccbegin);
+  SLJIT_ASSERT(private_data_ptr != 0);
+  BACKTRACK_AS(bracket_backtrack)->private_data_ptr = private_data_ptr;
+  if (opcode == OP_ONCE)
+    BACKTRACK_AS(bracket_backtrack)->u.framesize = get_framesize(common, ccbegin, NULL, FALSE, &needs_control_head);
+  }
+
+/* Instructions before the first alternative. */
+stacksize = 0;
+if (ket == OP_KETRMAX || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))
+  stacksize++;
+if (bra == OP_BRAZERO)
+  stacksize++;
+
+if (stacksize > 0)
+  allocate_stack(common, stacksize);
+
+stacksize = 0;
+if (ket == OP_KETRMAX || (ket == OP_KETRMIN && bra != OP_BRAMINZERO))
+  {
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
+  stacksize++;
+  }
+
+if (bra == OP_BRAZERO)
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
+
+if (bra == OP_BRAMINZERO)
+  {
+  /* This is a backtrack path! (Since the try-path of OP_BRAMINZERO matches to the empty string) */
+  OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+  if (ket != OP_KETRMIN)
+    {
+    free_stack(common, 1);
+    braminzero = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
+    }
+  else
+    {
+    if (opcode == OP_ONCE || opcode >= OP_SBRA)
+      {
+      jump = CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
+      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
+      /* Nothing stored during the first run. */
+      skip = JUMP(SLJIT_JUMP);
+      JUMPHERE(jump);
+      /* Checking zero-length iteration. */
+      if (opcode != OP_ONCE || BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
+        {
+        /* When we come from outside, private_data_ptr contains the previous STR_PTR. */
+        braminzero = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+        }
+      else
+        {
+        /* Except when the whole stack frame must be saved. */
+        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+        braminzero = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), STACK(-BACKTRACK_AS(bracket_backtrack)->u.framesize - 2));
+        }
+      JUMPHERE(skip);
+      }
+    else
+      {
+      jump = CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
+      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
+      JUMPHERE(jump);
+      }
+    }
+  }
+
+if (repeat_type != 0)
+  {
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_IMM, repeat_count);
+  if (repeat_type == OP_EXACT)
+    rmax_label = LABEL();
+  }
+
+if (ket == OP_KETRMIN)
+  BACKTRACK_AS(bracket_backtrack)->recursive_matchingpath = LABEL();
+
+if (ket == OP_KETRMAX)
+  {
+  rmax_label = LABEL();
+  if (has_alternatives && opcode != OP_ONCE && opcode < OP_SBRA && repeat_type == 0)
+    BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = rmax_label;
+  }
+
+/* Handling capturing brackets and alternatives. */
+if (opcode == OP_ONCE)
+  {
+  stacksize = 0;
+  if (needs_control_head)
+    {
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
+    stacksize++;
+    }
+
+  if (BACKTRACK_AS(bracket_backtrack)->u.framesize < 0)
+    {
+    /* Neither capturing brackets nor recursions are found in the block. */
+    if (ket == OP_KETRMIN)
+      {
+      stacksize += 2;
+      if (!needs_control_head)
+        OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+      }
+    else
+      {
+      if (BACKTRACK_AS(bracket_backtrack)->u.framesize == no_frame)
+        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STACK_TOP, 0);
+      if (ket == OP_KETRMAX || has_alternatives)
+        stacksize++;
+      }
+
+    if (stacksize > 0)
+      allocate_stack(common, stacksize);
+
+    stacksize = 0;
+    if (needs_control_head)
+      {
+      stacksize++;
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+      }
+
+    if (ket == OP_KETRMIN)
+      {
+      if (needs_control_head)
+        OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
+      if (BACKTRACK_AS(bracket_backtrack)->u.framesize == no_frame)
+        OP2(SLJIT_ADD, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STACK_TOP, 0, SLJIT_IMM, needs_control_head ? (2 * sizeof(sljit_sw)) : sizeof(sljit_sw));
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize + 1), TMP2, 0);
+      }
+    else if (ket == OP_KETRMAX || has_alternatives)
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
+    }
+  else
+    {
+    if (ket != OP_KET || has_alternatives)
+      stacksize++;
+
+    stacksize += BACKTRACK_AS(bracket_backtrack)->u.framesize + 1;
+    allocate_stack(common, stacksize);
+
+    if (needs_control_head)
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+    OP2(SLJIT_ADD, TMP2, 0, STACK_TOP, 0, SLJIT_IMM, stacksize * sizeof(sljit_sw));
+
+    stacksize = needs_control_head ? 1 : 0;
+    if (ket != OP_KET || has_alternatives)
+      {
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP2, 0);
+      stacksize++;
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);
+      }
+    else
+      {
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP2, 0);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP1, 0);
+      }
+    init_frame(common, ccbegin, NULL, BACKTRACK_AS(bracket_backtrack)->u.framesize + stacksize, stacksize + 1, FALSE);
+    }
+  }
+else if (opcode == OP_CBRA || opcode == OP_SCBRA)
+  {
+  /* Saving the previous values. */
+  if (common->optimized_cbracket[offset >> 1] != 0)
+    {
+    SLJIT_ASSERT(private_data_ptr == OVECTOR(offset));
+    allocate_stack(common, 2);
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr + sizeof(sljit_sw));
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STR_PTR, 0);
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
+    }
+  else
+    {
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+    allocate_stack(common, 1);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STR_PTR, 0);
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+    }
+  }
+else if (opcode == OP_SBRA || opcode == OP_SCOND)
+  {
+  /* Saving the previous value. */
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+  allocate_stack(common, 1);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STR_PTR, 0);
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+  }
+else if (has_alternatives)
+  {
+  /* Pushing the starting string pointer. */
+  allocate_stack(common, 1);
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+  }
+
+/* Generating code for the first alternative. */
+if (opcode == OP_COND || opcode == OP_SCOND)
+  {
+  if (*matchingpath == OP_CREF)
+    {
+    SLJIT_ASSERT(has_alternatives);
+    add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed),
+      CMP(SLJIT_EQUAL, SLJIT_MEM1(SLJIT_SP), OVECTOR(GET2(matchingpath, 1) << 1), SLJIT_MEM1(SLJIT_SP), OVECTOR(1)));
+    matchingpath += 1 + IMM2_SIZE;
+    }
+  else if (*matchingpath == OP_DNCREF)
+    {
+    SLJIT_ASSERT(has_alternatives);
+
+    i = GET2(matchingpath, 1 + IMM2_SIZE);
+    slot = common->name_table + GET2(matchingpath, 1) * common->name_entry_size;
+    OP1(SLJIT_MOV, TMP3, 0, STR_PTR, 0);
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(1));
+    OP2(SLJIT_SUB | SLJIT_SET_Z, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(GET2(slot, 0) << 1), TMP1, 0);
+    slot += common->name_entry_size;
+    i--;
+    while (i-- > 0)
+      {
+      OP2(SLJIT_SUB, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(GET2(slot, 0) << 1), TMP1, 0);
+      OP2(SLJIT_OR | SLJIT_SET_Z, TMP2, 0, TMP2, 0, STR_PTR, 0);
+      slot += common->name_entry_size;
+      }
+    OP1(SLJIT_MOV, STR_PTR, 0, TMP3, 0);
+    add_jump(compiler, &(BACKTRACK_AS(bracket_backtrack)->u.condfailed), JUMP(SLJIT_ZERO));
+    matchingpath += 1 + 2 * IMM2_SIZE;
+    }
+  else if (*matchingpath == OP_RREF || *matchingpath == OP_DNRREF || *matchingpath == OP_FAIL)
+    {
+    /* Never has other case. */
+    BACKTRACK_AS(bracket_backtrack)->u.condfailed = NULL;
+    SLJIT_ASSERT(!has_alternatives);
+
+    if (*matchingpath == OP_FAIL)
+      stacksize = 0;
+    else if (*matchingpath == OP_RREF)
+      {
+      stacksize = GET2(matchingpath, 1);
+      if (common->currententry == NULL)
+        stacksize = 0;
+      else if (stacksize == RREF_ANY)
+        stacksize = 1;
+      else if (common->currententry->start == 0)
+        stacksize = stacksize == 0;
+      else
+        stacksize = stacksize == (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
+
+      if (stacksize != 0)
+        matchingpath += 1 + IMM2_SIZE;
+      }
+    else
+      {
+      if (common->currententry == NULL || common->currententry->start == 0)
+        stacksize = 0;
+      else
+        {
+        stacksize = GET2(matchingpath, 1 + IMM2_SIZE);
+        slot = common->name_table + GET2(matchingpath, 1) * common->name_entry_size;
+        i = (int)GET2(common->start, common->currententry->start + 1 + LINK_SIZE);
+        while (stacksize > 0)
+          {
+          if ((int)GET2(slot, 0) == i)
+            break;
+          slot += common->name_entry_size;
+          stacksize--;
+          }
+        }
+
+      if (stacksize != 0)
+        matchingpath += 1 + 2 * IMM2_SIZE;
+      }
+
+      /* The stacksize == 0 is a common "else" case. */
+      if (stacksize == 0)
+        {
+        if (*cc == OP_ALT)
+          {
+          matchingpath = cc + 1 + LINK_SIZE;
+          cc += GET(cc, 1);
+          }
+        else
+          matchingpath = cc;
+        }
+    }
+  else
+    {
+    SLJIT_ASSERT(has_alternatives && *matchingpath >= OP_ASSERT && *matchingpath <= OP_ASSERTBACK_NOT);
+    /* Similar code as PUSH_BACKTRACK macro. */
+    assert = sljit_alloc_memory(compiler, sizeof(assert_backtrack));
+    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
+      return NULL;
+    memset(assert, 0, sizeof(assert_backtrack));
+    assert->common.cc = matchingpath;
+    BACKTRACK_AS(bracket_backtrack)->u.assert = assert;
+    matchingpath = compile_assert_matchingpath(common, matchingpath, assert, TRUE);
+    }
+  }
+
+compile_matchingpath(common, matchingpath, cc, backtrack);
+if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
+  return NULL;
+
+if (opcode == OP_ONCE)
+  match_once_common(common, ket, BACKTRACK_AS(bracket_backtrack)->u.framesize, private_data_ptr, has_alternatives, needs_control_head);
+
+stacksize = 0;
+if (repeat_type == OP_MINUPTO)
+  {
+  /* We need to preserve the counter. TMP2 will be used below. */
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), repeat_ptr);
+  stacksize++;
+  }
+if (ket != OP_KET || bra != OP_BRA)
+  stacksize++;
+if (offset != 0)
+  {
+  if (common->capture_last_ptr != 0)
+    stacksize++;
+  if (common->optimized_cbracket[offset >> 1] == 0)
+    stacksize += 2;
+  }
+if (has_alternatives && opcode != OP_ONCE)
+  stacksize++;
+
+if (stacksize > 0)
+  allocate_stack(common, stacksize);
+
+stacksize = 0;
+if (repeat_type == OP_MINUPTO)
+  {
+  /* TMP2 was set above. */
+  OP2(SLJIT_SUB, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP2, 0, SLJIT_IMM, 1);
+  stacksize++;
+  }
+
+if (ket != OP_KET || bra != OP_BRA)
+  {
+  if (ket != OP_KET)
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
+  else
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
+  stacksize++;
+  }
+
+if (offset != 0)
+  stacksize = match_capture_common(common, stacksize, offset, private_data_ptr);
+
+if (has_alternatives)
+  {
+  if (opcode != OP_ONCE)
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
+  if (ket != OP_KETRMAX)
+    BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();
+  }
+
+/* Must be after the matchingpath label. */
+if (offset != 0 && common->optimized_cbracket[offset >> 1] != 0)
+  {
+  SLJIT_ASSERT(private_data_ptr == OVECTOR(offset + 0));
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), STR_PTR, 0);
+  }
+
+if (ket == OP_KETRMAX)
+  {
+  if (repeat_type != 0)
+    {
+    if (has_alternatives)
+      BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();
+    OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_IMM, 1);
+    JUMPTO(SLJIT_NOT_ZERO, rmax_label);
+    /* Drop STR_PTR for greedy plus quantifier. */
+    if (opcode != OP_ONCE)
+      free_stack(common, 1);
+    }
+  else if (opcode == OP_ONCE || opcode >= OP_SBRA)
+    {
+    if (has_alternatives)
+      BACKTRACK_AS(bracket_backtrack)->alternative_matchingpath = LABEL();
+    /* Checking zero-length iteration. */
+    if (opcode != OP_ONCE)
+      {
+      CMPTO(SLJIT_NOT_EQUAL, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STR_PTR, 0, rmax_label);
+      /* Drop STR_PTR for greedy plus quantifier. */
+      if (bra != OP_BRAZERO)
+        free_stack(common, 1);
+      }
+    else
+      /* TMP2 must contain the starting STR_PTR. */
+      CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, STR_PTR, 0, rmax_label);
+    }
+  else
+    JUMPTO(SLJIT_JUMP, rmax_label);
+  BACKTRACK_AS(bracket_backtrack)->recursive_matchingpath = LABEL();
+  }
+
+if (repeat_type == OP_EXACT)
+  {
+  count_match(common);
+  OP2(SLJIT_SUB | SLJIT_SET_Z, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_IMM, 1);
+  JUMPTO(SLJIT_NOT_ZERO, rmax_label);
+  }
+else if (repeat_type == OP_UPTO)
+  {
+  /* We need to preserve the counter. */
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), repeat_ptr);
+  allocate_stack(common, 1);
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+  }
+
+if (bra == OP_BRAZERO)
+  BACKTRACK_AS(bracket_backtrack)->zero_matchingpath = LABEL();
+
+if (bra == OP_BRAMINZERO)
+  {
+  /* This is a backtrack path! (From the viewpoint of OP_BRAMINZERO) */
+  JUMPTO(SLJIT_JUMP, ((braminzero_backtrack *)parent)->matchingpath);
+  if (braminzero != NULL)
+    {
+    JUMPHERE(braminzero);
+    /* We need to release the end pointer to perform the
+    backtrack for the zero-length iteration. When
+    framesize is < 0, OP_ONCE will do the release itself. */
+    if (opcode == OP_ONCE && BACKTRACK_AS(bracket_backtrack)->u.framesize >= 0)
+      {
+      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+      add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
+      }
+    else if (ket == OP_KETRMIN && opcode != OP_ONCE)
+      free_stack(common, 1);
+    }
+  /* Continue to the normal backtrack. */
+  }
+
+if ((ket != OP_KET && bra != OP_BRAMINZERO) || bra == OP_BRAZERO)
+  count_match(common);
+
+/* Skip the other alternatives. */
+while (*cc == OP_ALT)
+  cc += GET(cc, 1);
+cc += 1 + LINK_SIZE;
+
+if (opcode == OP_ONCE)
+  {
+  /* We temporarily encode the needs_control_head in the lowest bit.
+     Note: on the target architectures of SLJIT the ((x << 1) >> 1) returns
+     the same value for small signed numbers (including negative numbers). */
+  BACKTRACK_AS(bracket_backtrack)->u.framesize = (BACKTRACK_AS(bracket_backtrack)->u.framesize << 1) | (needs_control_head ? 1 : 0);
+  }
+return cc + repeat_length;
+}
+
+static pcre_uchar *compile_bracketpos_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
+{
+DEFINE_COMPILER;
+backtrack_common *backtrack;
+pcre_uchar opcode;
+int private_data_ptr;
+int cbraprivptr = 0;
+BOOL needs_control_head;
+int framesize;
+int stacksize;
+int offset = 0;
+BOOL zero = FALSE;
+pcre_uchar *ccbegin = NULL;
+int stack; /* Also contains the offset of control head. */
+struct sljit_label *loop = NULL;
+struct jump_list *emptymatch = NULL;
+
+PUSH_BACKTRACK(sizeof(bracketpos_backtrack), cc, NULL);
+if (*cc == OP_BRAPOSZERO)
+  {
+  zero = TRUE;
+  cc++;
+  }
+
+opcode = *cc;
+private_data_ptr = PRIVATE_DATA(cc);
+SLJIT_ASSERT(private_data_ptr != 0);
+BACKTRACK_AS(bracketpos_backtrack)->private_data_ptr = private_data_ptr;
+switch(opcode)
+  {
+  case OP_BRAPOS:
+  case OP_SBRAPOS:
+  ccbegin = cc + 1 + LINK_SIZE;
+  break;
+
+  case OP_CBRAPOS:
+  case OP_SCBRAPOS:
+  offset = GET2(cc, 1 + LINK_SIZE);
+  /* This case cannot be optimized in the same was as
+  normal capturing brackets. */
+  SLJIT_ASSERT(common->optimized_cbracket[offset] == 0);
+  cbraprivptr = OVECTOR_PRIV(offset);
+  offset <<= 1;
+  ccbegin = cc + 1 + LINK_SIZE + IMM2_SIZE;
+  break;
+
+  default:
+  SLJIT_UNREACHABLE();
+  break;
+  }
+
+framesize = get_framesize(common, cc, NULL, FALSE, &needs_control_head);
+BACKTRACK_AS(bracketpos_backtrack)->framesize = framesize;
+if (framesize < 0)
+  {
+  if (offset != 0)
+    {
+    stacksize = 2;
+    if (common->capture_last_ptr != 0)
+      stacksize++;
+    }
+  else
+    stacksize = 1;
+
+  if (needs_control_head)
+    stacksize++;
+  if (!zero)
+    stacksize++;
+
+  BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;
+  allocate_stack(common, stacksize);
+  if (framesize == no_frame)
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STACK_TOP, 0);
+
+  stack = 0;
+  if (offset != 0)
+    {
+    stack = 2;
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset));
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1));
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
+    if (common->capture_last_ptr != 0)
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr);
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), TMP2, 0);
+    if (needs_control_head)
+      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
+    if (common->capture_last_ptr != 0)
+      {
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), TMP1, 0);
+      stack = 3;
+      }
+    }
+  else
+    {
+    if (needs_control_head)
+      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+    stack = 1;
+    }
+
+  if (needs_control_head)
+    stack++;
+  if (!zero)
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), SLJIT_IMM, 1);
+  if (needs_control_head)
+    {
+    stack--;
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP2, 0);
+    }
+  }
+else
+  {
+  stacksize = framesize + 1;
+  if (!zero)
+    stacksize++;
+  if (needs_control_head)
+    stacksize++;
+  if (offset == 0)
+    stacksize++;
+  BACKTRACK_AS(bracketpos_backtrack)->stacksize = stacksize;
+
+  allocate_stack(common, stacksize);
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+  if (needs_control_head)
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
+  OP2(SLJIT_ADD, SLJIT_MEM1(SLJIT_SP), private_data_ptr, STACK_TOP, 0, SLJIT_IMM, stacksize * sizeof(sljit_sw));
+
+  stack = 0;
+  if (!zero)
+    {
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 1);
+    stack = 1;
+    }
+  if (needs_control_head)
+    {
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP2, 0);
+    stack++;
+    }
+  if (offset == 0)
+    {
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), STR_PTR, 0);
+    stack++;
+    }
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stack), TMP1, 0);
+  init_frame(common, cc, NULL, stacksize - 1, stacksize - framesize, FALSE);
+  stack -= 1 + (offset == 0);
+  }
+
+if (offset != 0)
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), cbraprivptr, STR_PTR, 0);
+
+loop = LABEL();
+while (*cc != OP_KETRPOS)
+  {
+  backtrack->top = NULL;
+  backtrack->topbacktracks = NULL;
+  cc += GET(cc, 1);
+
+  compile_matchingpath(common, ccbegin, cc, backtrack);
+  if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
+    return NULL;
+
+  if (framesize < 0)
+    {
+    if (framesize == no_frame)
+      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+
+    if (offset != 0)
+      {
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), cbraprivptr);
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), STR_PTR, 0);
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), cbraprivptr, STR_PTR, 0);
+      if (common->capture_last_ptr != 0)
+        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, SLJIT_IMM, offset >> 1);
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);
+      }
+    else
+      {
+      if (opcode == OP_SBRAPOS)
+        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+      }
+
+    /* Even if the match is empty, we need to reset the control head. */
+    if (needs_control_head)
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(stack));
+
+    if (opcode == OP_SBRAPOS || opcode == OP_SCBRAPOS)
+      add_jump(compiler, &emptymatch, CMP(SLJIT_EQUAL, TMP1, 0, STR_PTR, 0));
+
+    if (!zero)
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0);
+    }
+  else
+    {
+    if (offset != 0)
+      {
+      OP2(SLJIT_SUB, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_IMM, stacksize * sizeof(sljit_sw));
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), cbraprivptr);
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), STR_PTR, 0);
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), cbraprivptr, STR_PTR, 0);
+      if (common->capture_last_ptr != 0)
+        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, SLJIT_IMM, offset >> 1);
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);
+      }
+    else
+      {
+      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+      OP2(SLJIT_SUB, STACK_TOP, 0, TMP2, 0, SLJIT_IMM, stacksize * sizeof(sljit_sw));
+      if (opcode == OP_SBRAPOS)
+        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(TMP2), STACK(-framesize - 2));
+      OP1(SLJIT_MOV, SLJIT_MEM1(TMP2), STACK(-framesize - 2), STR_PTR, 0);
+      }
+
+    /* Even if the match is empty, we need to reset the control head. */
+    if (needs_control_head)
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_MEM1(STACK_TOP), STACK(stack));
+
+    if (opcode == OP_SBRAPOS || opcode == OP_SCBRAPOS)
+      add_jump(compiler, &emptymatch, CMP(SLJIT_EQUAL, TMP1, 0, STR_PTR, 0));
+
+    if (!zero)
+      {
+      if (framesize < 0)
+        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0);
+      else
+        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
+      }
+    }
+
+  JUMPTO(SLJIT_JUMP, loop);
+  flush_stubs(common);
+
+  compile_backtrackingpath(common, backtrack->top);
+  if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
+    return NULL;
+  set_jumps(backtrack->topbacktracks, LABEL());
+
+  if (framesize < 0)
+    {
+    if (offset != 0)
+      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), cbraprivptr);
+    else
+      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+    }
+  else
+    {
+    if (offset != 0)
+      {
+      /* Last alternative. */
+      if (*cc == OP_KETRPOS)
+        OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), cbraprivptr);
+      }
+    else
+      {
+      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+      OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(TMP2), STACK(-framesize - 2));
+      }
+    }
+
+  if (*cc == OP_KETRPOS)
+    break;
+  ccbegin = cc + 1 + LINK_SIZE;
+  }
+
+/* We don't have to restore the control head in case of a failed match. */
+
+backtrack->topbacktracks = NULL;
+if (!zero)
+  {
+  if (framesize < 0)
+    add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(stacksize - 1), SLJIT_IMM, 0));
+  else /* TMP2 is set to [private_data_ptr] above. */
+    add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_NOT_EQUAL, SLJIT_MEM1(TMP2), STACK(-stacksize), SLJIT_IMM, 0));
+  }
+
+/* None of them matched. */
+set_jumps(emptymatch, LABEL());
+count_match(common);
+return cc + 1 + LINK_SIZE;
+}
+
+static SLJIT_INLINE pcre_uchar *get_iterator_parameters(compiler_common *common, pcre_uchar *cc, pcre_uchar *opcode, pcre_uchar *type, sljit_u32 *max, sljit_u32 *exact, pcre_uchar **end)
+{
+int class_len;
+
+*opcode = *cc;
+*exact = 0;
+
+if (*opcode >= OP_STAR && *opcode <= OP_POSUPTO)
+  {
+  cc++;
+  *type = OP_CHAR;
+  }
+else if (*opcode >= OP_STARI && *opcode <= OP_POSUPTOI)
+  {
+  cc++;
+  *type = OP_CHARI;
+  *opcode -= OP_STARI - OP_STAR;
+  }
+else if (*opcode >= OP_NOTSTAR && *opcode <= OP_NOTPOSUPTO)
+  {
+  cc++;
+  *type = OP_NOT;
+  *opcode -= OP_NOTSTAR - OP_STAR;
+  }
+else if (*opcode >= OP_NOTSTARI && *opcode <= OP_NOTPOSUPTOI)
+  {
+  cc++;
+  *type = OP_NOTI;
+  *opcode -= OP_NOTSTARI - OP_STAR;
+  }
+else if (*opcode >= OP_TYPESTAR && *opcode <= OP_TYPEPOSUPTO)
+  {
+  cc++;
+  *opcode -= OP_TYPESTAR - OP_STAR;
+  *type = OP_END;
+  }
+else
+  {
+  SLJIT_ASSERT(*opcode == OP_CLASS || *opcode == OP_NCLASS || *opcode == OP_XCLASS);
+  *type = *opcode;
+  cc++;
+  class_len = (*type < OP_XCLASS) ? (int)(1 + (32 / sizeof(pcre_uchar))) : GET(cc, 0);
+  *opcode = cc[class_len - 1];
+
+  if (*opcode >= OP_CRSTAR && *opcode <= OP_CRMINQUERY)
+    {
+    *opcode -= OP_CRSTAR - OP_STAR;
+    *end = cc + class_len;
+
+    if (*opcode == OP_PLUS || *opcode == OP_MINPLUS)
+      {
+      *exact = 1;
+      *opcode -= OP_PLUS - OP_STAR;
+      }
+    }
+  else if (*opcode >= OP_CRPOSSTAR && *opcode <= OP_CRPOSQUERY)
+    {
+    *opcode -= OP_CRPOSSTAR - OP_POSSTAR;
+    *end = cc + class_len;
+
+    if (*opcode == OP_POSPLUS)
+      {
+      *exact = 1;
+      *opcode = OP_POSSTAR;
+      }
+    }
+  else
+    {
+    SLJIT_ASSERT(*opcode == OP_CRRANGE || *opcode == OP_CRMINRANGE || *opcode == OP_CRPOSRANGE);
+    *max = GET2(cc, (class_len + IMM2_SIZE));
+    *exact = GET2(cc, class_len);
+
+    if (*max == 0)
+      {
+      if (*opcode == OP_CRPOSRANGE)
+        *opcode = OP_POSSTAR;
+      else
+        *opcode -= OP_CRRANGE - OP_STAR;
+      }
+    else
+      {
+      *max -= *exact;
+      if (*max == 0)
+        *opcode = OP_EXACT;
+      else if (*max == 1)
+        {
+        if (*opcode == OP_CRPOSRANGE)
+          *opcode = OP_POSQUERY;
+        else
+          *opcode -= OP_CRRANGE - OP_QUERY;
+        }
+      else
+        {
+        if (*opcode == OP_CRPOSRANGE)
+          *opcode = OP_POSUPTO;
+        else
+          *opcode -= OP_CRRANGE - OP_UPTO;
+        }
+      }
+    *end = cc + class_len + 2 * IMM2_SIZE;
+    }
+  return cc;
+  }
+
+switch(*opcode)
+  {
+  case OP_EXACT:
+  *exact = GET2(cc, 0);
+  cc += IMM2_SIZE;
+  break;
+
+  case OP_PLUS:
+  case OP_MINPLUS:
+  *exact = 1;
+  *opcode -= OP_PLUS - OP_STAR;
+  break;
+
+  case OP_POSPLUS:
+  *exact = 1;
+  *opcode = OP_POSSTAR;
+  break;
+
+  case OP_UPTO:
+  case OP_MINUPTO:
+  case OP_POSUPTO:
+  *max = GET2(cc, 0);
+  cc += IMM2_SIZE;
+  break;
+  }
+
+if (*type == OP_END)
+  {
+  *type = *cc;
+  *end = next_opcode(common, cc);
+  cc++;
+  return cc;
+  }
+
+*end = cc + 1;
+#ifdef SUPPORT_UTF
+if (common->utf && HAS_EXTRALEN(*cc)) *end += GET_EXTRALEN(*cc);
+#endif
+return cc;
+}
+
+static pcre_uchar *compile_iterator_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
+{
+DEFINE_COMPILER;
+backtrack_common *backtrack;
+pcre_uchar opcode;
+pcre_uchar type;
+sljit_u32 max = 0, exact;
+BOOL fast_fail;
+sljit_s32 fast_str_ptr;
+BOOL charpos_enabled;
+pcre_uchar charpos_char;
+unsigned int charpos_othercasebit;
+pcre_uchar *end;
+jump_list *no_match = NULL;
+jump_list *no_char1_match = NULL;
+struct sljit_jump *jump = NULL;
+struct sljit_label *label;
+int private_data_ptr = PRIVATE_DATA(cc);
+int base = (private_data_ptr == 0) ? SLJIT_MEM1(STACK_TOP) : SLJIT_MEM1(SLJIT_SP);
+int offset0 = (private_data_ptr == 0) ? STACK(0) : private_data_ptr;
+int offset1 = (private_data_ptr == 0) ? STACK(1) : private_data_ptr + (int)sizeof(sljit_sw);
+int tmp_base, tmp_offset;
+
+PUSH_BACKTRACK(sizeof(char_iterator_backtrack), cc, NULL);
+
+fast_str_ptr = PRIVATE_DATA(cc + 1);
+fast_fail = TRUE;
+
+SLJIT_ASSERT(common->fast_forward_bc_ptr == NULL || fast_str_ptr == 0 || cc == common->fast_forward_bc_ptr);
+
+if (cc == common->fast_forward_bc_ptr)
+  fast_fail = FALSE;
+else if (common->fast_fail_start_ptr == 0)
+  fast_str_ptr = 0;
+
+SLJIT_ASSERT(common->fast_forward_bc_ptr != NULL || fast_str_ptr == 0
+  || (fast_str_ptr >= common->fast_fail_start_ptr && fast_str_ptr <= common->fast_fail_end_ptr));
+
+cc = get_iterator_parameters(common, cc, &opcode, &type, &max, &exact, &end);
+
+if (type != OP_EXTUNI)
+  {
+  tmp_base = TMP3;
+  tmp_offset = 0;
+  }
+else
+  {
+  tmp_base = SLJIT_MEM1(SLJIT_SP);
+  tmp_offset = POSSESSIVE0;
+  }
+
+if (fast_fail && fast_str_ptr != 0)
+  add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), fast_str_ptr));
+
+/* Handle fixed part first. */
+if (exact > 1)
+  {
+  SLJIT_ASSERT(fast_str_ptr == 0);
+  if (common->mode == JIT_COMPILE
+#ifdef SUPPORT_UTF
+      && !common->utf
+#endif
+      )
+    {
+    OP2(SLJIT_ADD, TMP1, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(exact));
+    add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_GREATER, TMP1, 0, STR_END, 0));
+    OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, exact);
+    label = LABEL();
+    compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks, FALSE);
+    OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);
+    JUMPTO(SLJIT_NOT_ZERO, label);
+    }
+  else
+    {
+    OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, exact);
+    label = LABEL();
+    compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks, TRUE);
+    OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);
+    JUMPTO(SLJIT_NOT_ZERO, label);
+    }
+  }
+else if (exact == 1)
+  compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks, TRUE);
+
+switch(opcode)
+  {
+  case OP_STAR:
+  case OP_UPTO:
+  SLJIT_ASSERT(fast_str_ptr == 0 || opcode == OP_STAR);
+
+  if (type == OP_ANYNL || type == OP_EXTUNI)
+    {
+    SLJIT_ASSERT(private_data_ptr == 0);
+    SLJIT_ASSERT(fast_str_ptr == 0);
+
+    allocate_stack(common, 2);
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, 0);
+
+    if (opcode == OP_UPTO)
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0, SLJIT_IMM, max);
+
+    label = LABEL();
+    compile_char1_matchingpath(common, type, cc, &BACKTRACK_AS(char_iterator_backtrack)->u.backtracks, TRUE);
+    if (opcode == OP_UPTO)
+      {
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0);
+      OP2(SLJIT_SUB | SLJIT_SET_Z, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+      jump = JUMP(SLJIT_ZERO);
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE0, TMP1, 0);
+      }
+
+    /* We cannot use TMP3 because of this allocate_stack. */
+    allocate_stack(common, 1);
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+    JUMPTO(SLJIT_JUMP, label);
+    if (jump != NULL)
+      JUMPHERE(jump);
+    }
+  else
+    {
+    charpos_enabled = FALSE;
+    charpos_char = 0;
+    charpos_othercasebit = 0;
+
+    if ((type != OP_CHAR && type != OP_CHARI) && (*end == OP_CHAR || *end == OP_CHARI))
+      {
+      charpos_enabled = TRUE;
+#ifdef SUPPORT_UTF
+      charpos_enabled = !common->utf || !HAS_EXTRALEN(end[1]);
+#endif
+      if (charpos_enabled && *end == OP_CHARI && char_has_othercase(common, end + 1))
+        {
+        charpos_othercasebit = char_get_othercase_bit(common, end + 1);
+        if (charpos_othercasebit == 0)
+          charpos_enabled = FALSE;
+        }
+
+      if (charpos_enabled)
+        {
+        charpos_char = end[1];
+        /* Consumpe the OP_CHAR opcode. */
+        end += 2;
+#if defined COMPILE_PCRE8
+        SLJIT_ASSERT((charpos_othercasebit >> 8) == 0);
+#elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+        SLJIT_ASSERT((charpos_othercasebit >> 9) == 0);
+        if ((charpos_othercasebit & 0x100) != 0)
+          charpos_othercasebit = (charpos_othercasebit & 0xff) << 8;
+#endif
+        if (charpos_othercasebit != 0)
+          charpos_char |= charpos_othercasebit;
+
+        BACKTRACK_AS(char_iterator_backtrack)->u.charpos.enabled = TRUE;
+        BACKTRACK_AS(char_iterator_backtrack)->u.charpos.chr = charpos_char;
+        BACKTRACK_AS(char_iterator_backtrack)->u.charpos.othercasebit = charpos_othercasebit;
+        }
+      }
+
+    if (charpos_enabled)
+      {
+      if (opcode == OP_UPTO)
+        OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, max + 1);
+
+      /* Search the first instance of charpos_char. */
+      jump = JUMP(SLJIT_JUMP);
+      label = LABEL();
+      if (opcode == OP_UPTO)
+        {
+        OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);
+        add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_ZERO));
+        }
+      compile_char1_matchingpath(common, type, cc, &backtrack->topbacktracks, FALSE);
+      if (fast_str_ptr != 0)
+        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);
+      JUMPHERE(jump);
+
+      detect_partial_match(common, &backtrack->topbacktracks);
+      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+      if (charpos_othercasebit != 0)
+        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, charpos_othercasebit);
+      CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, charpos_char, label);
+
+      if (private_data_ptr == 0)
+        allocate_stack(common, 2);
+      OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+      OP1(SLJIT_MOV, base, offset1, STR_PTR, 0);
+      if (opcode == OP_UPTO)
+        {
+        OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);
+        add_jump(compiler, &no_match, JUMP(SLJIT_ZERO));
+        }
+
+      /* Search the last instance of charpos_char. */
+      label = LABEL();
+      compile_char1_matchingpath(common, type, cc, &no_match, FALSE);
+      if (fast_str_ptr != 0)
+        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);
+      detect_partial_match(common, &no_match);
+      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(0));
+      if (charpos_othercasebit != 0)
+        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, charpos_othercasebit);
+      if (opcode == OP_STAR)
+        {
+        CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, charpos_char, label);
+        OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+        }
+      else
+        {
+        jump = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, charpos_char);
+        OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+        JUMPHERE(jump);
+        }
+
+      if (opcode == OP_UPTO)
+        {
+        OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);
+        JUMPTO(SLJIT_NOT_ZERO, label);
+        }
+      else
+        JUMPTO(SLJIT_JUMP, label);
+
+      set_jumps(no_match, LABEL());
+      OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
+      OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+      OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+      }
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+    else if (common->utf)
+      {
+      if (private_data_ptr == 0)
+        allocate_stack(common, 2);
+
+      OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+      OP1(SLJIT_MOV, base, offset1, STR_PTR, 0);
+
+      if (opcode == OP_UPTO)
+        OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, max);
+
+      label = LABEL();
+      compile_char1_matchingpath(common, type, cc, &no_match, TRUE);
+      OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+
+      if (opcode == OP_UPTO)
+        {
+        OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);
+        JUMPTO(SLJIT_NOT_ZERO, label);
+        }
+      else
+        JUMPTO(SLJIT_JUMP, label);
+
+      set_jumps(no_match, LABEL());
+      OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
+      if (fast_str_ptr != 0)
+        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);
+      }
+#endif
+    else
+      {
+      if (private_data_ptr == 0)
+        allocate_stack(common, 2);
+
+      OP1(SLJIT_MOV, base, offset1, STR_PTR, 0);
+      if (opcode == OP_UPTO)
+        OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, max);
+
+      label = LABEL();
+      detect_partial_match(common, &no_match);
+      compile_char1_matchingpath(common, type, cc, &no_char1_match, FALSE);
+      if (opcode == OP_UPTO)
+        {
+        OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);
+        JUMPTO(SLJIT_NOT_ZERO, label);
+        OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+        }
+      else
+        JUMPTO(SLJIT_JUMP, label);
+
+      set_jumps(no_char1_match, LABEL());
+      OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+      set_jumps(no_match, LABEL());
+      OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+      if (fast_str_ptr != 0)
+        OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);
+      }
+    }
+  BACKTRACK_AS(char_iterator_backtrack)->matchingpath = LABEL();
+  break;
+
+  case OP_MINSTAR:
+  if (private_data_ptr == 0)
+    allocate_stack(common, 1);
+  OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+  BACKTRACK_AS(char_iterator_backtrack)->matchingpath = LABEL();
+  if (fast_str_ptr != 0)
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);
+  break;
+
+  case OP_MINUPTO:
+  SLJIT_ASSERT(fast_str_ptr == 0);
+  if (private_data_ptr == 0)
+    allocate_stack(common, 2);
+  OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+  OP1(SLJIT_MOV, base, offset1, SLJIT_IMM, max + 1);
+  BACKTRACK_AS(char_iterator_backtrack)->matchingpath = LABEL();
+  break;
+
+  case OP_QUERY:
+  case OP_MINQUERY:
+  SLJIT_ASSERT(fast_str_ptr == 0);
+  if (private_data_ptr == 0)
+    allocate_stack(common, 1);
+  OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+  if (opcode == OP_QUERY)
+    compile_char1_matchingpath(common, type, cc, &BACKTRACK_AS(char_iterator_backtrack)->u.backtracks, TRUE);
+  BACKTRACK_AS(char_iterator_backtrack)->matchingpath = LABEL();
+  break;
+
+  case OP_EXACT:
+  break;
+
+  case OP_POSSTAR:
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+  if (common->utf)
+    {
+    OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
+    label = LABEL();
+    compile_char1_matchingpath(common, type, cc, &no_match, TRUE);
+    OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
+    JUMPTO(SLJIT_JUMP, label);
+    set_jumps(no_match, LABEL());
+    OP1(SLJIT_MOV, STR_PTR, 0, tmp_base, tmp_offset);
+    if (fast_str_ptr != 0)
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);
+    break;
+    }
+#endif
+  label = LABEL();
+  detect_partial_match(common, &no_match);
+  compile_char1_matchingpath(common, type, cc, &no_char1_match, FALSE);
+  JUMPTO(SLJIT_JUMP, label);
+  set_jumps(no_char1_match, LABEL());
+  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+  set_jumps(no_match, LABEL());
+  if (fast_str_ptr != 0)
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), fast_str_ptr, STR_PTR, 0);
+  break;
+
+  case OP_POSUPTO:
+  SLJIT_ASSERT(fast_str_ptr == 0);
+#if defined SUPPORT_UTF && !defined COMPILE_PCRE32
+  if (common->utf)
+    {
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1, STR_PTR, 0);
+    OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, max);
+    label = LABEL();
+    compile_char1_matchingpath(common, type, cc, &no_match, TRUE);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1, STR_PTR, 0);
+    OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);
+    JUMPTO(SLJIT_NOT_ZERO, label);
+    set_jumps(no_match, LABEL());
+    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), POSSESSIVE1);
+    break;
+    }
+#endif
+  OP1(SLJIT_MOV, tmp_base, tmp_offset, SLJIT_IMM, max);
+  label = LABEL();
+  detect_partial_match(common, &no_match);
+  compile_char1_matchingpath(common, type, cc, &no_char1_match, FALSE);
+  OP2(SLJIT_SUB | SLJIT_SET_Z, tmp_base, tmp_offset, tmp_base, tmp_offset, SLJIT_IMM, 1);
+  JUMPTO(SLJIT_NOT_ZERO, label);
+  OP2(SLJIT_ADD, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+  set_jumps(no_char1_match, LABEL());
+  OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+  set_jumps(no_match, LABEL());
+  break;
+
+  case OP_POSQUERY:
+  SLJIT_ASSERT(fast_str_ptr == 0);
+  OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
+  compile_char1_matchingpath(common, type, cc, &no_match, TRUE);
+  OP1(SLJIT_MOV, tmp_base, tmp_offset, STR_PTR, 0);
+  set_jumps(no_match, LABEL());
+  OP1(SLJIT_MOV, STR_PTR, 0, tmp_base, tmp_offset);
+  break;
+
+  default:
+  SLJIT_UNREACHABLE();
+  break;
+  }
+
+count_match(common);
+return end;
+}
+
+static SLJIT_INLINE pcre_uchar *compile_fail_accept_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
+{
+DEFINE_COMPILER;
+backtrack_common *backtrack;
+
+PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);
+
+if (*cc == OP_FAIL)
+  {
+  add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));
+  return cc + 1;
+  }
+
+if (*cc == OP_ASSERT_ACCEPT || common->currententry != NULL || !common->might_be_empty)
+  {
+  /* No need to check notempty conditions. */
+  if (common->accept_label == NULL)
+    add_jump(compiler, &common->accept, JUMP(SLJIT_JUMP));
+  else
+    JUMPTO(SLJIT_JUMP, common->accept_label);
+  return cc + 1;
+  }
+
+if (common->accept_label == NULL)
+  add_jump(compiler, &common->accept, CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0)));
+else
+  CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0), common->accept_label);
+OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
+OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty));
+add_jump(compiler, &backtrack->topbacktracks, CMP(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty_atstart));
+if (common->accept_label == NULL)
+  add_jump(compiler, &common->accept, CMP(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, 0));
+else
+  CMPTO(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, 0, common->accept_label);
+OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
+if (common->accept_label == NULL)
+  add_jump(compiler, &common->accept, CMP(SLJIT_NOT_EQUAL, TMP2, 0, STR_PTR, 0));
+else
+  CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, STR_PTR, 0, common->accept_label);
+add_jump(compiler, &backtrack->topbacktracks, JUMP(SLJIT_JUMP));
+return cc + 1;
+}
+
+static SLJIT_INLINE pcre_uchar *compile_close_matchingpath(compiler_common *common, pcre_uchar *cc)
+{
+DEFINE_COMPILER;
+int offset = GET2(cc, 1);
+BOOL optimized_cbracket = common->optimized_cbracket[offset] != 0;
+
+/* Data will be discarded anyway... */
+if (common->currententry != NULL)
+  return cc + 1 + IMM2_SIZE;
+
+if (!optimized_cbracket)
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR_PRIV(offset));
+offset <<= 1;
+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), STR_PTR, 0);
+if (!optimized_cbracket)
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);
+return cc + 1 + IMM2_SIZE;
+}
+
+static SLJIT_INLINE pcre_uchar *compile_control_verb_matchingpath(compiler_common *common, pcre_uchar *cc, backtrack_common *parent)
+{
+DEFINE_COMPILER;
+backtrack_common *backtrack;
+pcre_uchar opcode = *cc;
+pcre_uchar *ccend = cc + 1;
+
+if (opcode == OP_PRUNE_ARG || opcode == OP_SKIP_ARG || opcode == OP_THEN_ARG)
+  ccend += 2 + cc[1];
+
+PUSH_BACKTRACK(sizeof(backtrack_common), cc, NULL);
+
+if (opcode == OP_SKIP)
+  {
+  allocate_stack(common, 1);
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+  return ccend;
+  }
+
+if (opcode == OP_PRUNE_ARG || opcode == OP_THEN_ARG)
+  {
+  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)(cc + 2));
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, TMP2, 0);
+  OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), TMP2, 0);
+  }
+
+return ccend;
+}
+
+static pcre_uchar then_trap_opcode[1] = { OP_THEN_TRAP };
+
+static SLJIT_INLINE void compile_then_trap_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, backtrack_common *parent)
+{
+DEFINE_COMPILER;
+backtrack_common *backtrack;
+BOOL needs_control_head;
+int size;
+
+PUSH_BACKTRACK_NOVALUE(sizeof(then_trap_backtrack), cc);
+common->then_trap = BACKTRACK_AS(then_trap_backtrack);
+BACKTRACK_AS(then_trap_backtrack)->common.cc = then_trap_opcode;
+BACKTRACK_AS(then_trap_backtrack)->start = (sljit_sw)(cc - common->start);
+BACKTRACK_AS(then_trap_backtrack)->framesize = get_framesize(common, cc, ccend, FALSE, &needs_control_head);
+
+size = BACKTRACK_AS(then_trap_backtrack)->framesize;
+size = 3 + (size < 0 ? 0 : size);
+
+OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
+allocate_stack(common, size);
+if (size > 3)
+  OP2(SLJIT_ADD, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, STACK_TOP, 0, SLJIT_IMM, (size - 3) * sizeof(sljit_sw));
+else
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, STACK_TOP, 0);
+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 1), SLJIT_IMM, BACKTRACK_AS(then_trap_backtrack)->start);
+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 2), SLJIT_IMM, type_then_trap);
+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(size - 3), TMP2, 0);
+
+size = BACKTRACK_AS(then_trap_backtrack)->framesize;
+if (size >= 0)
+  init_frame(common, cc, ccend, size - 1, 0, FALSE);
+}
+
+static void compile_matchingpath(compiler_common *common, pcre_uchar *cc, pcre_uchar *ccend, backtrack_common *parent)
+{
+DEFINE_COMPILER;
+backtrack_common *backtrack;
+BOOL has_then_trap = FALSE;
+then_trap_backtrack *save_then_trap = NULL;
+
+SLJIT_ASSERT(*ccend == OP_END || (*ccend >= OP_ALT && *ccend <= OP_KETRPOS));
+
+if (common->has_then && common->then_offsets[cc - common->start] != 0)
+  {
+  SLJIT_ASSERT(*ccend != OP_END && common->control_head_ptr != 0);
+  has_then_trap = TRUE;
+  save_then_trap = common->then_trap;
+  /* Tail item on backtrack. */
+  compile_then_trap_matchingpath(common, cc, ccend, parent);
+  }
+
+while (cc < ccend)
+  {
+  switch(*cc)
+    {
+    case OP_SOD:
+    case OP_SOM:
+    case OP_NOT_WORD_BOUNDARY:
+    case OP_WORD_BOUNDARY:
+    case OP_EODN:
+    case OP_EOD:
+    case OP_DOLL:
+    case OP_DOLLM:
+    case OP_CIRC:
+    case OP_CIRCM:
+    case OP_REVERSE:
+    cc = compile_simple_assertion_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
+    break;
+
+    case OP_NOT_DIGIT:
+    case OP_DIGIT:
+    case OP_NOT_WHITESPACE:
+    case OP_WHITESPACE:
+    case OP_NOT_WORDCHAR:
+    case OP_WORDCHAR:
+    case OP_ANY:
+    case OP_ALLANY:
+    case OP_ANYBYTE:
+    case OP_NOTPROP:
+    case OP_PROP:
+    case OP_ANYNL:
+    case OP_NOT_HSPACE:
+    case OP_HSPACE:
+    case OP_NOT_VSPACE:
+    case OP_VSPACE:
+    case OP_EXTUNI:
+    case OP_NOT:
+    case OP_NOTI:
+    cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE);
+    break;
+
+    case OP_SET_SOM:
+    PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));
+    allocate_stack(common, 1);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(0), STR_PTR, 0);
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP2, 0);
+    cc++;
+    break;
+
+    case OP_CHAR:
+    case OP_CHARI:
+    if (common->mode == JIT_COMPILE)
+      cc = compile_charn_matchingpath(common, cc, ccend, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
+    else
+      cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE);
+    break;
+
+    case OP_STAR:
+    case OP_MINSTAR:
+    case OP_PLUS:
+    case OP_MINPLUS:
+    case OP_QUERY:
+    case OP_MINQUERY:
+    case OP_UPTO:
+    case OP_MINUPTO:
+    case OP_EXACT:
+    case OP_POSSTAR:
+    case OP_POSPLUS:
+    case OP_POSQUERY:
+    case OP_POSUPTO:
+    case OP_STARI:
+    case OP_MINSTARI:
+    case OP_PLUSI:
+    case OP_MINPLUSI:
+    case OP_QUERYI:
+    case OP_MINQUERYI:
+    case OP_UPTOI:
+    case OP_MINUPTOI:
+    case OP_EXACTI:
+    case OP_POSSTARI:
+    case OP_POSPLUSI:
+    case OP_POSQUERYI:
+    case OP_POSUPTOI:
+    case OP_NOTSTAR:
+    case OP_NOTMINSTAR:
+    case OP_NOTPLUS:
+    case OP_NOTMINPLUS:
+    case OP_NOTQUERY:
+    case OP_NOTMINQUERY:
+    case OP_NOTUPTO:
+    case OP_NOTMINUPTO:
+    case OP_NOTEXACT:
+    case OP_NOTPOSSTAR:
+    case OP_NOTPOSPLUS:
+    case OP_NOTPOSQUERY:
+    case OP_NOTPOSUPTO:
+    case OP_NOTSTARI:
+    case OP_NOTMINSTARI:
+    case OP_NOTPLUSI:
+    case OP_NOTMINPLUSI:
+    case OP_NOTQUERYI:
+    case OP_NOTMINQUERYI:
+    case OP_NOTUPTOI:
+    case OP_NOTMINUPTOI:
+    case OP_NOTEXACTI:
+    case OP_NOTPOSSTARI:
+    case OP_NOTPOSPLUSI:
+    case OP_NOTPOSQUERYI:
+    case OP_NOTPOSUPTOI:
+    case OP_TYPESTAR:
+    case OP_TYPEMINSTAR:
+    case OP_TYPEPLUS:
+    case OP_TYPEMINPLUS:
+    case OP_TYPEQUERY:
+    case OP_TYPEMINQUERY:
+    case OP_TYPEUPTO:
+    case OP_TYPEMINUPTO:
+    case OP_TYPEEXACT:
+    case OP_TYPEPOSSTAR:
+    case OP_TYPEPOSPLUS:
+    case OP_TYPEPOSQUERY:
+    case OP_TYPEPOSUPTO:
+    cc = compile_iterator_matchingpath(common, cc, parent);
+    break;
+
+    case OP_CLASS:
+    case OP_NCLASS:
+    if (cc[1 + (32 / sizeof(pcre_uchar))] >= OP_CRSTAR && cc[1 + (32 / sizeof(pcre_uchar))] <= OP_CRPOSRANGE)
+      cc = compile_iterator_matchingpath(common, cc, parent);
+    else
+      cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE);
+    break;
+
+#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+    case OP_XCLASS:
+    if (*(cc + GET(cc, 1)) >= OP_CRSTAR && *(cc + GET(cc, 1)) <= OP_CRPOSRANGE)
+      cc = compile_iterator_matchingpath(common, cc, parent);
+    else
+      cc = compile_char1_matchingpath(common, *cc, cc + 1, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE);
+    break;
+#endif
+
+    case OP_REF:
+    case OP_REFI:
+    if (cc[1 + IMM2_SIZE] >= OP_CRSTAR && cc[1 + IMM2_SIZE] <= OP_CRPOSRANGE)
+      cc = compile_ref_iterator_matchingpath(common, cc, parent);
+    else
+      {
+      compile_ref_matchingpath(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE, FALSE);
+      cc += 1 + IMM2_SIZE;
+      }
+    break;
+
+    case OP_DNREF:
+    case OP_DNREFI:
+    if (cc[1 + 2 * IMM2_SIZE] >= OP_CRSTAR && cc[1 + 2 * IMM2_SIZE] <= OP_CRPOSRANGE)
+      cc = compile_ref_iterator_matchingpath(common, cc, parent);
+    else
+      {
+      compile_dnref_search(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks);
+      compile_ref_matchingpath(common, cc, parent->top != NULL ? &parent->top->nextbacktracks : &parent->topbacktracks, TRUE, FALSE);
+      cc += 1 + 2 * IMM2_SIZE;
+      }
+    break;
+
+    case OP_RECURSE:
+    cc = compile_recurse_matchingpath(common, cc, parent);
+    break;
+
+    case OP_CALLOUT:
+    cc = compile_callout_matchingpath(common, cc, parent);
+    break;
+
+    case OP_ASSERT:
+    case OP_ASSERT_NOT:
+    case OP_ASSERTBACK:
+    case OP_ASSERTBACK_NOT:
+    PUSH_BACKTRACK_NOVALUE(sizeof(assert_backtrack), cc);
+    cc = compile_assert_matchingpath(common, cc, BACKTRACK_AS(assert_backtrack), FALSE);
+    break;
+
+    case OP_BRAMINZERO:
+    PUSH_BACKTRACK_NOVALUE(sizeof(braminzero_backtrack), cc);
+    cc = bracketend(cc + 1);
+    if (*(cc - 1 - LINK_SIZE) != OP_KETRMIN)
+      {
+      allocate_stack(common, 1);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+      }
+    else
+      {
+      allocate_stack(common, 2);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), STR_PTR, 0);
+      }
+    BACKTRACK_AS(braminzero_backtrack)->matchingpath = LABEL();
+    count_match(common);
+    break;
+
+    case OP_ONCE:
+    case OP_ONCE_NC:
+    case OP_BRA:
+    case OP_CBRA:
+    case OP_COND:
+    case OP_SBRA:
+    case OP_SCBRA:
+    case OP_SCOND:
+    cc = compile_bracket_matchingpath(common, cc, parent);
+    break;
+
+    case OP_BRAZERO:
+    if (cc[1] > OP_ASSERTBACK_NOT)
+      cc = compile_bracket_matchingpath(common, cc, parent);
+    else
+      {
+      PUSH_BACKTRACK_NOVALUE(sizeof(assert_backtrack), cc);
+      cc = compile_assert_matchingpath(common, cc, BACKTRACK_AS(assert_backtrack), FALSE);
+      }
+    break;
+
+    case OP_BRAPOS:
+    case OP_CBRAPOS:
+    case OP_SBRAPOS:
+    case OP_SCBRAPOS:
+    case OP_BRAPOSZERO:
+    cc = compile_bracketpos_matchingpath(common, cc, parent);
+    break;
+
+    case OP_MARK:
+    PUSH_BACKTRACK_NOVALUE(sizeof(backtrack_common), cc);
+    SLJIT_ASSERT(common->mark_ptr != 0);
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), common->mark_ptr);
+    allocate_stack(common, common->has_skip_arg ? 5 : 1);
+    OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(common->has_skip_arg ? 4 : 0), TMP2, 0);
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, (sljit_sw)(cc + 2));
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, TMP2, 0);
+    OP1(SLJIT_MOV, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, mark_ptr), TMP2, 0);
+    if (common->has_skip_arg)
+      {
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, STACK_TOP, 0);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(1), SLJIT_IMM, type_mark);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(2), SLJIT_IMM, (sljit_sw)(cc + 2));
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(3), STR_PTR, 0);
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), TMP1, 0);
+      }
+    cc += 1 + 2 + cc[1];
+    break;
+
+    case OP_PRUNE:
+    case OP_PRUNE_ARG:
+    case OP_SKIP:
+    case OP_SKIP_ARG:
+    case OP_THEN:
+    case OP_THEN_ARG:
+    case OP_COMMIT:
+    cc = compile_control_verb_matchingpath(common, cc, parent);
+    break;
+
+    case OP_FAIL:
+    case OP_ACCEPT:
+    case OP_ASSERT_ACCEPT:
+    cc = compile_fail_accept_matchingpath(common, cc, parent);
+    break;
+
+    case OP_CLOSE:
+    cc = compile_close_matchingpath(common, cc);
+    break;
+
+    case OP_SKIPZERO:
+    cc = bracketend(cc + 1);
+    break;
+
+    default:
+    SLJIT_UNREACHABLE();
+    return;
+    }
+  if (cc == NULL)
+    return;
+  }
+
+if (has_then_trap)
+  {
+  /* Head item on backtrack. */
+  PUSH_BACKTRACK_NOVALUE(sizeof(then_trap_backtrack), cc);
+  BACKTRACK_AS(then_trap_backtrack)->common.cc = then_trap_opcode;
+  BACKTRACK_AS(then_trap_backtrack)->then_trap = common->then_trap;
+  common->then_trap = save_then_trap;
+  }
+SLJIT_ASSERT(cc == ccend);
+}
+
+#undef PUSH_BACKTRACK
+#undef PUSH_BACKTRACK_NOVALUE
+#undef BACKTRACK_AS
+
+#define COMPILE_BACKTRACKINGPATH(current) \
+  do \
+    { \
+    compile_backtrackingpath(common, (current)); \
+    if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler))) \
+      return; \
+    } \
+  while (0)
+
+#define CURRENT_AS(type) ((type *)current)
+
+static void compile_iterator_backtrackingpath(compiler_common *common, struct backtrack_common *current)
+{
+DEFINE_COMPILER;
+pcre_uchar *cc = current->cc;
+pcre_uchar opcode;
+pcre_uchar type;
+sljit_u32 max = 0, exact;
+struct sljit_label *label = NULL;
+struct sljit_jump *jump = NULL;
+jump_list *jumplist = NULL;
+pcre_uchar *end;
+int private_data_ptr = PRIVATE_DATA(cc);
+int base = (private_data_ptr == 0) ? SLJIT_MEM1(STACK_TOP) : SLJIT_MEM1(SLJIT_SP);
+int offset0 = (private_data_ptr == 0) ? STACK(0) : private_data_ptr;
+int offset1 = (private_data_ptr == 0) ? STACK(1) : private_data_ptr + (int)sizeof(sljit_sw);
+
+cc = get_iterator_parameters(common, cc, &opcode, &type, &max, &exact, &end);
+
+switch(opcode)
+  {
+  case OP_STAR:
+  case OP_UPTO:
+  if (type == OP_ANYNL || type == OP_EXTUNI)
+    {
+    SLJIT_ASSERT(private_data_ptr == 0);
+    set_jumps(CURRENT_AS(char_iterator_backtrack)->u.backtracks, LABEL());
+    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+    free_stack(common, 1);
+    CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(char_iterator_backtrack)->matchingpath);
+    }
+  else
+    {
+    if (CURRENT_AS(char_iterator_backtrack)->u.charpos.enabled)
+      {
+      OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
+      OP1(SLJIT_MOV, TMP2, 0, base, offset1);
+      OP2(SLJIT_SUB, STR_PTR, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(1));
+
+      jump = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, TMP2, 0);
+      label = LABEL();
+      OP1(MOV_UCHAR, TMP1, 0, SLJIT_MEM1(STR_PTR), IN_UCHARS(-1));
+      OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+      if (CURRENT_AS(char_iterator_backtrack)->u.charpos.othercasebit != 0)
+        OP2(SLJIT_OR, TMP1, 0, TMP1, 0, SLJIT_IMM, CURRENT_AS(char_iterator_backtrack)->u.charpos.othercasebit);
+      CMPTO(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, CURRENT_AS(char_iterator_backtrack)->u.charpos.chr, CURRENT_AS(char_iterator_backtrack)->matchingpath);
+      skip_char_back(common);
+      CMPTO(SLJIT_GREATER, STR_PTR, 0, TMP2, 0, label);
+      }
+    else
+      {
+      OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
+      jump = CMP(SLJIT_LESS_EQUAL, STR_PTR, 0, base, offset1);
+      skip_char_back(common);
+      OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+      JUMPTO(SLJIT_JUMP, CURRENT_AS(char_iterator_backtrack)->matchingpath);
+      }
+    JUMPHERE(jump);
+    if (private_data_ptr == 0)
+      free_stack(common, 2);
+    }
+  break;
+
+  case OP_MINSTAR:
+  OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
+  compile_char1_matchingpath(common, type, cc, &jumplist, TRUE);
+  OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+  JUMPTO(SLJIT_JUMP, CURRENT_AS(char_iterator_backtrack)->matchingpath);
+  set_jumps(jumplist, LABEL());
+  if (private_data_ptr == 0)
+    free_stack(common, 1);
+  break;
+
+  case OP_MINUPTO:
+  OP1(SLJIT_MOV, TMP1, 0, base, offset1);
+  OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
+  OP2(SLJIT_SUB | SLJIT_SET_Z, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+  add_jump(compiler, &jumplist, JUMP(SLJIT_ZERO));
+
+  OP1(SLJIT_MOV, base, offset1, TMP1, 0);
+  compile_char1_matchingpath(common, type, cc, &jumplist, TRUE);
+  OP1(SLJIT_MOV, base, offset0, STR_PTR, 0);
+  JUMPTO(SLJIT_JUMP, CURRENT_AS(char_iterator_backtrack)->matchingpath);
+
+  set_jumps(jumplist, LABEL());
+  if (private_data_ptr == 0)
+    free_stack(common, 2);
+  break;
+
+  case OP_QUERY:
+  OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
+  OP1(SLJIT_MOV, base, offset0, SLJIT_IMM, 0);
+  CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(char_iterator_backtrack)->matchingpath);
+  jump = JUMP(SLJIT_JUMP);
+  set_jumps(CURRENT_AS(char_iterator_backtrack)->u.backtracks, LABEL());
+  OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
+  OP1(SLJIT_MOV, base, offset0, SLJIT_IMM, 0);
+  JUMPTO(SLJIT_JUMP, CURRENT_AS(char_iterator_backtrack)->matchingpath);
+  JUMPHERE(jump);
+  if (private_data_ptr == 0)
+    free_stack(common, 1);
+  break;
+
+  case OP_MINQUERY:
+  OP1(SLJIT_MOV, STR_PTR, 0, base, offset0);
+  OP1(SLJIT_MOV, base, offset0, SLJIT_IMM, 0);
+  jump = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
+  compile_char1_matchingpath(common, type, cc, &jumplist, TRUE);
+  JUMPTO(SLJIT_JUMP, CURRENT_AS(char_iterator_backtrack)->matchingpath);
+  set_jumps(jumplist, LABEL());
+  JUMPHERE(jump);
+  if (private_data_ptr == 0)
+    free_stack(common, 1);
+  break;
+
+  case OP_EXACT:
+  case OP_POSSTAR:
+  case OP_POSQUERY:
+  case OP_POSUPTO:
+  break;
+
+  default:
+  SLJIT_UNREACHABLE();
+  break;
+  }
+
+set_jumps(current->topbacktracks, LABEL());
+}
+
+static SLJIT_INLINE void compile_ref_iterator_backtrackingpath(compiler_common *common, struct backtrack_common *current)
+{
+DEFINE_COMPILER;
+pcre_uchar *cc = current->cc;
+BOOL ref = (*cc == OP_REF || *cc == OP_REFI);
+pcre_uchar type;
+
+type = cc[ref ? 1 + IMM2_SIZE : 1 + 2 * IMM2_SIZE];
+
+if ((type & 0x1) == 0)
+  {
+  /* Maximize case. */
+  set_jumps(current->topbacktracks, LABEL());
+  OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+  free_stack(common, 1);
+  CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(ref_iterator_backtrack)->matchingpath);
+  return;
+  }
+
+OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(ref_iterator_backtrack)->matchingpath);
+set_jumps(current->topbacktracks, LABEL());
+free_stack(common, ref ? 2 : 3);
+}
+
+static SLJIT_INLINE void compile_recurse_backtrackingpath(compiler_common *common, struct backtrack_common *current)
+{
+DEFINE_COMPILER;
+
+if (CURRENT_AS(recurse_backtrack)->inlined_pattern)
+  compile_backtrackingpath(common, current->top);
+set_jumps(current->topbacktracks, LABEL());
+if (CURRENT_AS(recurse_backtrack)->inlined_pattern)
+  return;
+
+if (common->has_set_som && common->mark_ptr != 0)
+  {
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
+  free_stack(common, 2);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(0), TMP2, 0);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, TMP1, 0);
+  }
+else if (common->has_set_som || common->mark_ptr != 0)
+  {
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+  free_stack(common, 1);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->has_set_som ? (int)(OVECTOR(0)) : common->mark_ptr, TMP2, 0);
+  }
+}
+
+static void compile_assert_backtrackingpath(compiler_common *common, struct backtrack_common *current)
+{
+DEFINE_COMPILER;
+pcre_uchar *cc = current->cc;
+pcre_uchar bra = OP_BRA;
+struct sljit_jump *brajump = NULL;
+
+SLJIT_ASSERT(*cc != OP_BRAMINZERO);
+if (*cc == OP_BRAZERO)
+  {
+  bra = *cc;
+  cc++;
+  }
+
+if (bra == OP_BRAZERO)
+  {
+  SLJIT_ASSERT(current->topbacktracks == NULL);
+  OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+  }
+
+if (CURRENT_AS(assert_backtrack)->framesize < 0)
+  {
+  set_jumps(current->topbacktracks, LABEL());
+
+  if (bra == OP_BRAZERO)
+    {
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
+    CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(assert_backtrack)->matchingpath);
+    free_stack(common, 1);
+    }
+  return;
+  }
+
+if (bra == OP_BRAZERO)
+  {
+  if (*cc == OP_ASSERT_NOT || *cc == OP_ASSERTBACK_NOT)
+    {
+    OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
+    CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(assert_backtrack)->matchingpath);
+    free_stack(common, 1);
+    return;
+    }
+  free_stack(common, 1);
+  brajump = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0);
+  }
+
+if (*cc == OP_ASSERT || *cc == OP_ASSERTBACK)
+  {
+  OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), CURRENT_AS(assert_backtrack)->private_data_ptr);
+  add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), CURRENT_AS(assert_backtrack)->private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(-CURRENT_AS(assert_backtrack)->framesize - 1));
+
+  set_jumps(current->topbacktracks, LABEL());
+  }
+else
+  set_jumps(current->topbacktracks, LABEL());
+
+if (bra == OP_BRAZERO)
+  {
+  /* We know there is enough place on the stack. */
+  OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, sizeof(sljit_sw));
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), SLJIT_IMM, 0);
+  JUMPTO(SLJIT_JUMP, CURRENT_AS(assert_backtrack)->matchingpath);
+  JUMPHERE(brajump);
+  }
+}
+
+static void compile_bracket_backtrackingpath(compiler_common *common, struct backtrack_common *current)
+{
+DEFINE_COMPILER;
+int opcode, stacksize, alt_count, alt_max;
+int offset = 0;
+int private_data_ptr = CURRENT_AS(bracket_backtrack)->private_data_ptr;
+int repeat_ptr = 0, repeat_type = 0, repeat_count = 0;
+pcre_uchar *cc = current->cc;
+pcre_uchar *ccbegin;
+pcre_uchar *ccprev;
+pcre_uchar bra = OP_BRA;
+pcre_uchar ket;
+assert_backtrack *assert;
+sljit_uw *next_update_addr = NULL;
+BOOL has_alternatives;
+BOOL needs_control_head = FALSE;
+struct sljit_jump *brazero = NULL;
+struct sljit_jump *alt1 = NULL;
+struct sljit_jump *alt2 = NULL;
+struct sljit_jump *once = NULL;
+struct sljit_jump *cond = NULL;
+struct sljit_label *rmin_label = NULL;
+struct sljit_label *exact_label = NULL;
+
+if (*cc == OP_BRAZERO || *cc == OP_BRAMINZERO)
+  {
+  bra = *cc;
+  cc++;
+  }
+
+opcode = *cc;
+ccbegin = bracketend(cc) - 1 - LINK_SIZE;
+ket = *ccbegin;
+if (ket == OP_KET && PRIVATE_DATA(ccbegin) != 0)
+  {
+  repeat_ptr = PRIVATE_DATA(ccbegin);
+  repeat_type = PRIVATE_DATA(ccbegin + 2);
+  repeat_count = PRIVATE_DATA(ccbegin + 3);
+  SLJIT_ASSERT(repeat_type != 0 && repeat_count != 0);
+  if (repeat_type == OP_UPTO)
+    ket = OP_KETRMAX;
+  if (repeat_type == OP_MINUPTO)
+    ket = OP_KETRMIN;
+  }
+ccbegin = cc;
+cc += GET(cc, 1);
+has_alternatives = *cc == OP_ALT;
+if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
+  has_alternatives = (ccbegin[1 + LINK_SIZE] >= OP_ASSERT && ccbegin[1 + LINK_SIZE] <= OP_ASSERTBACK_NOT) || CURRENT_AS(bracket_backtrack)->u.condfailed != NULL;
+if (opcode == OP_CBRA || opcode == OP_SCBRA)
+  offset = (GET2(ccbegin, 1 + LINK_SIZE)) << 1;
+if (SLJIT_UNLIKELY(opcode == OP_COND) && (*cc == OP_KETRMAX || *cc == OP_KETRMIN))
+  opcode = OP_SCOND;
+if (SLJIT_UNLIKELY(opcode == OP_ONCE_NC))
+  opcode = OP_ONCE;
+
+alt_max = has_alternatives ? no_alternatives(ccbegin) : 0;
+
+/* Decoding the needs_control_head in framesize. */
+if (opcode == OP_ONCE)
+  {
+  needs_control_head = (CURRENT_AS(bracket_backtrack)->u.framesize & 0x1) != 0;
+  CURRENT_AS(bracket_backtrack)->u.framesize >>= 1;
+  }
+
+if (ket != OP_KET && repeat_type != 0)
+  {
+  /* TMP1 is used in OP_KETRMIN below. */
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+  free_stack(common, 1);
+  if (repeat_type == OP_UPTO)
+    OP2(SLJIT_ADD, SLJIT_MEM1(SLJIT_SP), repeat_ptr, TMP1, 0, SLJIT_IMM, 1);
+  else
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), repeat_ptr, TMP1, 0);
+  }
+
+if (ket == OP_KETRMAX)
+  {
+  if (bra == OP_BRAZERO)
+    {
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+    free_stack(common, 1);
+    brazero = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, 0);
+    }
+  }
+else if (ket == OP_KETRMIN)
+  {
+  if (bra != OP_BRAMINZERO)
+    {
+    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+    if (repeat_type != 0)
+      {
+      /* TMP1 was set a few lines above. */
+      CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);
+      /* Drop STR_PTR for non-greedy plus quantifier. */
+      if (opcode != OP_ONCE)
+        free_stack(common, 1);
+      }
+    else if (opcode >= OP_SBRA || opcode == OP_ONCE)
+      {
+      /* Checking zero-length iteration. */
+      if (opcode != OP_ONCE || CURRENT_AS(bracket_backtrack)->u.framesize < 0)
+        CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);
+      else
+        {
+        OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+        CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_MEM1(TMP1), STACK(-CURRENT_AS(bracket_backtrack)->u.framesize - 2), CURRENT_AS(bracket_backtrack)->recursive_matchingpath);
+        }
+      /* Drop STR_PTR for non-greedy plus quantifier. */
+      if (opcode != OP_ONCE)
+        free_stack(common, 1);
+      }
+    else
+      JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);
+    }
+  rmin_label = LABEL();
+  if (repeat_type != 0)
+    OP2(SLJIT_ADD, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_IMM, 1);
+  }
+else if (bra == OP_BRAZERO)
+  {
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+  free_stack(common, 1);
+  brazero = CMP(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0);
+  }
+else if (repeat_type == OP_EXACT)
+  {
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_IMM, 1);
+  exact_label = LABEL();
+  }
+
+if (offset != 0)
+  {
+  if (common->capture_last_ptr != 0)
+    {
+    SLJIT_ASSERT(common->optimized_cbracket[offset >> 1] == 0);
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, TMP1, 0);
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(2));
+    free_stack(common, 3);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP2, 0);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), TMP1, 0);
+    }
+  else if (common->optimized_cbracket[offset >> 1] == 0)
+    {
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
+    free_stack(common, 2);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), TMP2, 0);
+    }
+  }
+
+if (SLJIT_UNLIKELY(opcode == OP_ONCE))
+  {
+  if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)
+    {
+    OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+    add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
+    }
+  once = JUMP(SLJIT_JUMP);
+  }
+else if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
+  {
+  if (has_alternatives)
+    {
+    /* Always exactly one alternative. */
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+    free_stack(common, 1);
+
+    alt_max = 2;
+    alt1 = CMP(SLJIT_EQUAL, TMP1, 0, SLJIT_IMM, sizeof(sljit_uw));
+    }
+  }
+else if (has_alternatives)
+  {
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+  free_stack(common, 1);
+
+  if (alt_max > 4)
+    {
+    /* Table jump if alt_max is greater than 4. */
+    next_update_addr = allocate_read_only_data(common, alt_max * sizeof(sljit_uw));
+    if (SLJIT_UNLIKELY(next_update_addr == NULL))
+      return;
+    sljit_emit_ijump(compiler, SLJIT_JUMP, SLJIT_MEM1(TMP1), (sljit_sw)next_update_addr);
+    add_label_addr(common, next_update_addr++);
+    }
+  else
+    {
+    if (alt_max == 4)
+      alt2 = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_uw));
+    alt1 = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, sizeof(sljit_uw));
+    }
+  }
+
+COMPILE_BACKTRACKINGPATH(current->top);
+if (current->topbacktracks)
+  set_jumps(current->topbacktracks, LABEL());
+
+if (SLJIT_UNLIKELY(opcode == OP_COND) || SLJIT_UNLIKELY(opcode == OP_SCOND))
+  {
+  /* Conditional block always has at most one alternative. */
+  if (ccbegin[1 + LINK_SIZE] >= OP_ASSERT && ccbegin[1 + LINK_SIZE] <= OP_ASSERTBACK_NOT)
+    {
+    SLJIT_ASSERT(has_alternatives);
+    assert = CURRENT_AS(bracket_backtrack)->u.assert;
+    if (assert->framesize >= 0 && (ccbegin[1 + LINK_SIZE] == OP_ASSERT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK))
+      {
+      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), assert->private_data_ptr);
+      add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), assert->private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(-assert->framesize - 1));
+      }
+    cond = JUMP(SLJIT_JUMP);
+    set_jumps(CURRENT_AS(bracket_backtrack)->u.assert->condfailed, LABEL());
+    }
+  else if (CURRENT_AS(bracket_backtrack)->u.condfailed != NULL)
+    {
+    SLJIT_ASSERT(has_alternatives);
+    cond = JUMP(SLJIT_JUMP);
+    set_jumps(CURRENT_AS(bracket_backtrack)->u.condfailed, LABEL());
+    }
+  else
+    SLJIT_ASSERT(!has_alternatives);
+  }
+
+if (has_alternatives)
+  {
+  alt_count = sizeof(sljit_uw);
+  do
+    {
+    current->top = NULL;
+    current->topbacktracks = NULL;
+    current->nextbacktracks = NULL;
+    /* Conditional blocks always have an additional alternative, even if it is empty. */
+    if (*cc == OP_ALT)
+      {
+      ccprev = cc + 1 + LINK_SIZE;
+      cc += GET(cc, 1);
+      if (opcode != OP_COND && opcode != OP_SCOND)
+        {
+        if (opcode != OP_ONCE)
+          {
+          if (private_data_ptr != 0)
+            OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), private_data_ptr);
+          else
+            OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+          }
+        else
+          OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(needs_control_head ? 1 : 0));
+        }
+      compile_matchingpath(common, ccprev, cc, current);
+      if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
+        return;
+      }
+
+    /* Instructions after the current alternative is successfully matched. */
+    /* There is a similar code in compile_bracket_matchingpath. */
+    if (opcode == OP_ONCE)
+      match_once_common(common, ket, CURRENT_AS(bracket_backtrack)->u.framesize, private_data_ptr, has_alternatives, needs_control_head);
+
+    stacksize = 0;
+    if (repeat_type == OP_MINUPTO)
+      {
+      /* We need to preserve the counter. TMP2 will be used below. */
+      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(SLJIT_SP), repeat_ptr);
+      stacksize++;
+      }
+    if (ket != OP_KET || bra != OP_BRA)
+      stacksize++;
+    if (offset != 0)
+      {
+      if (common->capture_last_ptr != 0)
+        stacksize++;
+      if (common->optimized_cbracket[offset >> 1] == 0)
+        stacksize += 2;
+      }
+    if (opcode != OP_ONCE)
+      stacksize++;
+
+    if (stacksize > 0)
+      allocate_stack(common, stacksize);
+
+    stacksize = 0;
+    if (repeat_type == OP_MINUPTO)
+      {
+      /* TMP2 was set above. */
+      OP2(SLJIT_SUB, SLJIT_MEM1(STACK_TOP), STACK(stacksize), TMP2, 0, SLJIT_IMM, 1);
+      stacksize++;
+      }
+
+    if (ket != OP_KET || bra != OP_BRA)
+      {
+      if (ket != OP_KET)
+        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), STR_PTR, 0);
+      else
+        OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, 0);
+      stacksize++;
+      }
+
+    if (offset != 0)
+      stacksize = match_capture_common(common, stacksize, offset, private_data_ptr);
+
+    if (opcode != OP_ONCE)
+      OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(stacksize), SLJIT_IMM, alt_count);
+
+    if (offset != 0 && ket == OP_KETRMAX && common->optimized_cbracket[offset >> 1] != 0)
+      {
+      /* If ket is not OP_KETRMAX, this code path is executed after the jump to alternative_matchingpath. */
+      SLJIT_ASSERT(private_data_ptr == OVECTOR(offset + 0));
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), STR_PTR, 0);
+      }
+
+    JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->alternative_matchingpath);
+
+    if (opcode != OP_ONCE)
+      {
+      if (alt_max > 4)
+        add_label_addr(common, next_update_addr++);
+      else
+        {
+        if (alt_count != 2 * sizeof(sljit_uw))
+          {
+          JUMPHERE(alt1);
+          if (alt_max == 3 && alt_count == sizeof(sljit_uw))
+            alt2 = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, 2 * sizeof(sljit_uw));
+          }
+        else
+          {
+          JUMPHERE(alt2);
+          if (alt_max == 4)
+            alt1 = CMP(SLJIT_GREATER_EQUAL, TMP1, 0, SLJIT_IMM, 3 * sizeof(sljit_uw));
+          }
+        }
+      alt_count += sizeof(sljit_uw);
+      }
+
+    COMPILE_BACKTRACKINGPATH(current->top);
+    if (current->topbacktracks)
+      set_jumps(current->topbacktracks, LABEL());
+    SLJIT_ASSERT(!current->nextbacktracks);
+    }
+  while (*cc == OP_ALT);
+
+  if (cond != NULL)
+    {
+    SLJIT_ASSERT(opcode == OP_COND || opcode == OP_SCOND);
+    assert = CURRENT_AS(bracket_backtrack)->u.assert;
+    if ((ccbegin[1 + LINK_SIZE] == OP_ASSERT_NOT || ccbegin[1 + LINK_SIZE] == OP_ASSERTBACK_NOT) && assert->framesize >= 0)
+      {
+      OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), assert->private_data_ptr);
+      add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), assert->private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(-assert->framesize - 1));
+      }
+    JUMPHERE(cond);
+    }
+
+  /* Free the STR_PTR. */
+  if (private_data_ptr == 0)
+    free_stack(common, 1);
+  }
+
+if (offset != 0)
+  {
+  /* Using both tmp register is better for instruction scheduling. */
+  if (common->optimized_cbracket[offset >> 1] != 0)
+    {
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
+    free_stack(common, 2);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), TMP2, 0);
+    }
+  else
+    {
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+    free_stack(common, 1);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP1, 0);
+    }
+  }
+else if (opcode == OP_SBRA || opcode == OP_SCOND)
+  {
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(0));
+  free_stack(common, 1);
+  }
+else if (opcode == OP_ONCE)
+  {
+  cc = ccbegin + GET(ccbegin, 1);
+  stacksize = needs_control_head ? 1 : 0;
+
+  if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)
+    {
+    /* Reset head and drop saved frame. */
+    stacksize += CURRENT_AS(bracket_backtrack)->u.framesize + ((ket != OP_KET || *cc == OP_ALT) ? 2 : 1);
+    }
+  else if (ket == OP_KETRMAX || (*cc == OP_ALT && ket != OP_KETRMIN))
+    {
+    /* The STR_PTR must be released. */
+    stacksize++;
+    }
+
+  if (stacksize > 0)
+    free_stack(common, stacksize);
+
+  JUMPHERE(once);
+  /* Restore previous private_data_ptr */
+  if (CURRENT_AS(bracket_backtrack)->u.framesize >= 0)
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(-CURRENT_AS(bracket_backtrack)->u.framesize - 1));
+  else if (ket == OP_KETRMIN)
+    {
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
+    /* See the comment below. */
+    free_stack(common, 2);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), private_data_ptr, TMP1, 0);
+    }
+  }
+
+if (repeat_type == OP_EXACT)
+  {
+  OP2(SLJIT_ADD, TMP1, 0, SLJIT_MEM1(SLJIT_SP), repeat_ptr, SLJIT_IMM, 1);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), repeat_ptr, TMP1, 0);
+  CMPTO(SLJIT_LESS_EQUAL, TMP1, 0, SLJIT_IMM, repeat_count, exact_label);
+  }
+else if (ket == OP_KETRMAX)
+  {
+  OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+  if (bra != OP_BRAZERO)
+    free_stack(common, 1);
+
+  CMPTO(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0, CURRENT_AS(bracket_backtrack)->recursive_matchingpath);
+  if (bra == OP_BRAZERO)
+    {
+    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
+    JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->zero_matchingpath);
+    JUMPHERE(brazero);
+    free_stack(common, 1);
+    }
+  }
+else if (ket == OP_KETRMIN)
+  {
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+
+  /* OP_ONCE removes everything in case of a backtrack, so we don't
+  need to explicitly release the STR_PTR. The extra release would
+  affect badly the free_stack(2) above. */
+  if (opcode != OP_ONCE)
+    free_stack(common, 1);
+  CMPTO(SLJIT_NOT_EQUAL, TMP1, 0, SLJIT_IMM, 0, rmin_label);
+  if (opcode == OP_ONCE)
+    free_stack(common, bra == OP_BRAMINZERO ? 2 : 1);
+  else if (bra == OP_BRAMINZERO)
+    free_stack(common, 1);
+  }
+else if (bra == OP_BRAZERO)
+  {
+  OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+  JUMPTO(SLJIT_JUMP, CURRENT_AS(bracket_backtrack)->zero_matchingpath);
+  JUMPHERE(brazero);
+  }
+}
+
+static SLJIT_INLINE void compile_bracketpos_backtrackingpath(compiler_common *common, struct backtrack_common *current)
+{
+DEFINE_COMPILER;
+int offset;
+struct sljit_jump *jump;
+
+if (CURRENT_AS(bracketpos_backtrack)->framesize < 0)
+  {
+  if (*current->cc == OP_CBRAPOS || *current->cc == OP_SCBRAPOS)
+    {
+    offset = (GET2(current->cc, 1 + LINK_SIZE)) << 1;
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(1));
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset), TMP1, 0);
+    if (common->capture_last_ptr != 0)
+      OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(2));
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(offset + 1), TMP2, 0);
+    if (common->capture_last_ptr != 0)
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, TMP1, 0);
+    }
+  set_jumps(current->topbacktracks, LABEL());
+  free_stack(common, CURRENT_AS(bracketpos_backtrack)->stacksize);
+  return;
+  }
+
+OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), CURRENT_AS(bracketpos_backtrack)->private_data_ptr);
+add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
+
+if (current->topbacktracks)
+  {
+  jump = JUMP(SLJIT_JUMP);
+  set_jumps(current->topbacktracks, LABEL());
+  /* Drop the stack frame. */
+  free_stack(common, CURRENT_AS(bracketpos_backtrack)->stacksize);
+  JUMPHERE(jump);
+  }
+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), CURRENT_AS(bracketpos_backtrack)->private_data_ptr, SLJIT_MEM1(STACK_TOP), STACK(-CURRENT_AS(bracketpos_backtrack)->framesize - 1));
+}
+
+static SLJIT_INLINE void compile_braminzero_backtrackingpath(compiler_common *common, struct backtrack_common *current)
+{
+assert_backtrack backtrack;
+
+current->top = NULL;
+current->topbacktracks = NULL;
+current->nextbacktracks = NULL;
+if (current->cc[1] > OP_ASSERTBACK_NOT)
+  {
+  /* Manual call of compile_bracket_matchingpath and compile_bracket_backtrackingpath. */
+  compile_bracket_matchingpath(common, current->cc, current);
+  compile_bracket_backtrackingpath(common, current->top);
+  }
+else
+  {
+  memset(&backtrack, 0, sizeof(backtrack));
+  backtrack.common.cc = current->cc;
+  backtrack.matchingpath = CURRENT_AS(braminzero_backtrack)->matchingpath;
+  /* Manual call of compile_assert_matchingpath. */
+  compile_assert_matchingpath(common, current->cc, &backtrack, FALSE);
+  }
+SLJIT_ASSERT(!current->nextbacktracks && !current->topbacktracks);
+}
+
+static SLJIT_INLINE void compile_control_verb_backtrackingpath(compiler_common *common, struct backtrack_common *current)
+{
+DEFINE_COMPILER;
+pcre_uchar opcode = *current->cc;
+struct sljit_label *loop;
+struct sljit_jump *jump;
+
+if (opcode == OP_THEN || opcode == OP_THEN_ARG)
+  {
+  if (common->then_trap != NULL)
+    {
+    SLJIT_ASSERT(common->control_head_ptr != 0);
+
+    OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_IMM, type_then_trap);
+    OP1(SLJIT_MOV, TMP2, 0, SLJIT_IMM, common->then_trap->start);
+    jump = JUMP(SLJIT_JUMP);
+
+    loop = LABEL();
+    OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+    JUMPHERE(jump);
+    CMPTO(SLJIT_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(1), TMP1, 0, loop);
+    CMPTO(SLJIT_NOT_EQUAL, SLJIT_MEM1(STACK_TOP), STACK(2), TMP2, 0, loop);
+    add_jump(compiler, &common->then_trap->quit, JUMP(SLJIT_JUMP));
+    return;
+    }
+  else if (common->positive_assert)
+    {
+    add_jump(compiler, &common->positive_assert_quit, JUMP(SLJIT_JUMP));
+    return;
+    }
+  }
+
+if (common->local_exit)
+  {
+  if (common->quit_label == NULL)
+    add_jump(compiler, &common->quit, JUMP(SLJIT_JUMP));
+  else
+    JUMPTO(SLJIT_JUMP, common->quit_label);
+  return;
+  }
+
+if (opcode == OP_SKIP_ARG)
+  {
+  SLJIT_ASSERT(common->control_head_ptr != 0);
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS0, STACK_TOP, 0);
+  OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_IMM, (sljit_sw)(current->cc + 2));
+  sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_RET(SW) | SLJIT_ARG1(SW) | SLJIT_ARG2(SW), SLJIT_IMM, SLJIT_FUNC_OFFSET(do_search_mark));
+  OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
+
+  OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0);
+  add_jump(compiler, &common->reset_match, CMP(SLJIT_NOT_EQUAL, STR_PTR, 0, SLJIT_IMM, 0));
+  return;
+  }
+
+if (opcode == OP_SKIP)
+  OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+else
+  OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_IMM, 0);
+add_jump(compiler, &common->reset_match, JUMP(SLJIT_JUMP));
+}
+
+static SLJIT_INLINE void compile_then_trap_backtrackingpath(compiler_common *common, struct backtrack_common *current)
+{
+DEFINE_COMPILER;
+struct sljit_jump *jump;
+int size;
+
+if (CURRENT_AS(then_trap_backtrack)->then_trap)
+  {
+  common->then_trap = CURRENT_AS(then_trap_backtrack)->then_trap;
+  return;
+  }
+
+size = CURRENT_AS(then_trap_backtrack)->framesize;
+size = 3 + (size < 0 ? 0 : size);
+
+OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(size - 3));
+free_stack(common, size);
+jump = JUMP(SLJIT_JUMP);
+
+set_jumps(CURRENT_AS(then_trap_backtrack)->quit, LABEL());
+/* STACK_TOP is set by THEN. */
+if (CURRENT_AS(then_trap_backtrack)->framesize >= 0)
+  add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
+OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+free_stack(common, 3);
+
+JUMPHERE(jump);
+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, TMP1, 0);
+}
+
+static void compile_backtrackingpath(compiler_common *common, struct backtrack_common *current)
+{
+DEFINE_COMPILER;
+then_trap_backtrack *save_then_trap = common->then_trap;
+
+while (current)
+  {
+  if (current->nextbacktracks != NULL)
+    set_jumps(current->nextbacktracks, LABEL());
+  switch(*current->cc)
+    {
+    case OP_SET_SOM:
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+    free_stack(common, 1);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(0), TMP1, 0);
+    break;
+
+    case OP_STAR:
+    case OP_MINSTAR:
+    case OP_PLUS:
+    case OP_MINPLUS:
+    case OP_QUERY:
+    case OP_MINQUERY:
+    case OP_UPTO:
+    case OP_MINUPTO:
+    case OP_EXACT:
+    case OP_POSSTAR:
+    case OP_POSPLUS:
+    case OP_POSQUERY:
+    case OP_POSUPTO:
+    case OP_STARI:
+    case OP_MINSTARI:
+    case OP_PLUSI:
+    case OP_MINPLUSI:
+    case OP_QUERYI:
+    case OP_MINQUERYI:
+    case OP_UPTOI:
+    case OP_MINUPTOI:
+    case OP_EXACTI:
+    case OP_POSSTARI:
+    case OP_POSPLUSI:
+    case OP_POSQUERYI:
+    case OP_POSUPTOI:
+    case OP_NOTSTAR:
+    case OP_NOTMINSTAR:
+    case OP_NOTPLUS:
+    case OP_NOTMINPLUS:
+    case OP_NOTQUERY:
+    case OP_NOTMINQUERY:
+    case OP_NOTUPTO:
+    case OP_NOTMINUPTO:
+    case OP_NOTEXACT:
+    case OP_NOTPOSSTAR:
+    case OP_NOTPOSPLUS:
+    case OP_NOTPOSQUERY:
+    case OP_NOTPOSUPTO:
+    case OP_NOTSTARI:
+    case OP_NOTMINSTARI:
+    case OP_NOTPLUSI:
+    case OP_NOTMINPLUSI:
+    case OP_NOTQUERYI:
+    case OP_NOTMINQUERYI:
+    case OP_NOTUPTOI:
+    case OP_NOTMINUPTOI:
+    case OP_NOTEXACTI:
+    case OP_NOTPOSSTARI:
+    case OP_NOTPOSPLUSI:
+    case OP_NOTPOSQUERYI:
+    case OP_NOTPOSUPTOI:
+    case OP_TYPESTAR:
+    case OP_TYPEMINSTAR:
+    case OP_TYPEPLUS:
+    case OP_TYPEMINPLUS:
+    case OP_TYPEQUERY:
+    case OP_TYPEMINQUERY:
+    case OP_TYPEUPTO:
+    case OP_TYPEMINUPTO:
+    case OP_TYPEEXACT:
+    case OP_TYPEPOSSTAR:
+    case OP_TYPEPOSPLUS:
+    case OP_TYPEPOSQUERY:
+    case OP_TYPEPOSUPTO:
+    case OP_CLASS:
+    case OP_NCLASS:
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+    case OP_XCLASS:
+#endif
+    compile_iterator_backtrackingpath(common, current);
+    break;
+
+    case OP_REF:
+    case OP_REFI:
+    case OP_DNREF:
+    case OP_DNREFI:
+    compile_ref_iterator_backtrackingpath(common, current);
+    break;
+
+    case OP_RECURSE:
+    compile_recurse_backtrackingpath(common, current);
+    break;
+
+    case OP_ASSERT:
+    case OP_ASSERT_NOT:
+    case OP_ASSERTBACK:
+    case OP_ASSERTBACK_NOT:
+    compile_assert_backtrackingpath(common, current);
+    break;
+
+    case OP_ONCE:
+    case OP_ONCE_NC:
+    case OP_BRA:
+    case OP_CBRA:
+    case OP_COND:
+    case OP_SBRA:
+    case OP_SCBRA:
+    case OP_SCOND:
+    compile_bracket_backtrackingpath(common, current);
+    break;
+
+    case OP_BRAZERO:
+    if (current->cc[1] > OP_ASSERTBACK_NOT)
+      compile_bracket_backtrackingpath(common, current);
+    else
+      compile_assert_backtrackingpath(common, current);
+    break;
+
+    case OP_BRAPOS:
+    case OP_CBRAPOS:
+    case OP_SBRAPOS:
+    case OP_SCBRAPOS:
+    case OP_BRAPOSZERO:
+    compile_bracketpos_backtrackingpath(common, current);
+    break;
+
+    case OP_BRAMINZERO:
+    compile_braminzero_backtrackingpath(common, current);
+    break;
+
+    case OP_MARK:
+    OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(common->has_skip_arg ? 4 : 0));
+    if (common->has_skip_arg)
+      OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+    free_stack(common, common->has_skip_arg ? 5 : 1);
+    OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, TMP1, 0);
+    if (common->has_skip_arg)
+      OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, TMP2, 0);
+    break;
+
+    case OP_THEN:
+    case OP_THEN_ARG:
+    case OP_PRUNE:
+    case OP_PRUNE_ARG:
+    case OP_SKIP:
+    case OP_SKIP_ARG:
+    compile_control_verb_backtrackingpath(common, current);
+    break;
+
+    case OP_COMMIT:
+    if (!common->local_exit)
+      OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);
+    if (common->quit_label == NULL)
+      add_jump(compiler, &common->quit, JUMP(SLJIT_JUMP));
+    else
+      JUMPTO(SLJIT_JUMP, common->quit_label);
+    break;
+
+    case OP_CALLOUT:
+    case OP_FAIL:
+    case OP_ACCEPT:
+    case OP_ASSERT_ACCEPT:
+    set_jumps(current->topbacktracks, LABEL());
+    break;
+
+    case OP_THEN_TRAP:
+    /* A virtual opcode for then traps. */
+    compile_then_trap_backtrackingpath(common, current);
+    break;
+
+    default:
+    SLJIT_UNREACHABLE();
+    break;
+    }
+  current = current->prev;
+  }
+common->then_trap = save_then_trap;
+}
+
+static SLJIT_INLINE void compile_recurse(compiler_common *common)
+{
+DEFINE_COMPILER;
+pcre_uchar *cc = common->start + common->currententry->start;
+pcre_uchar *ccbegin = cc + 1 + LINK_SIZE + (*cc == OP_BRA ? 0 : IMM2_SIZE);
+pcre_uchar *ccend = bracketend(cc) - (1 + LINK_SIZE);
+BOOL needs_control_head;
+int framesize = get_framesize(common, cc, NULL, TRUE, &needs_control_head);
+int private_data_size = get_private_data_copy_length(common, ccbegin, ccend, needs_control_head);
+int alternativesize;
+BOOL needs_frame;
+backtrack_common altbacktrack;
+struct sljit_jump *jump;
+
+/* Recurse captures then. */
+common->then_trap = NULL;
+
+SLJIT_ASSERT(*cc == OP_BRA || *cc == OP_CBRA || *cc == OP_CBRAPOS || *cc == OP_SCBRA || *cc == OP_SCBRAPOS);
+needs_frame = framesize >= 0;
+if (!needs_frame)
+  framesize = 0;
+alternativesize = *(cc + GET(cc, 1)) == OP_ALT ? 1 : 0;
+
+SLJIT_ASSERT(common->currententry->entry == NULL && common->recursive_head_ptr != 0);
+common->currententry->entry = LABEL();
+set_jumps(common->currententry->calls, common->currententry->entry);
+
+sljit_emit_fast_enter(compiler, TMP2, 0);
+count_match(common);
+allocate_stack(common, private_data_size + framesize + alternativesize);
+OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(private_data_size + framesize + alternativesize - 1), TMP2, 0);
+copy_private_data(common, ccbegin, ccend, TRUE, framesize + alternativesize, private_data_size + framesize + alternativesize, needs_control_head);
+if (needs_control_head)
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_IMM, 0);
+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->recursive_head_ptr, STACK_TOP, 0);
+if (needs_frame)
+  init_frame(common, cc, NULL, framesize + alternativesize - 1, alternativesize, TRUE);
+
+if (alternativesize > 0)
+  OP1(SLJIT_MOV, SLJIT_MEM1(STACK_TOP), STACK(0), STR_PTR, 0);
+
+memset(&altbacktrack, 0, sizeof(backtrack_common));
+common->quit_label = NULL;
+common->accept_label = NULL;
+common->quit = NULL;
+common->accept = NULL;
+altbacktrack.cc = ccbegin;
+cc += GET(cc, 1);
+while (1)
+  {
+  altbacktrack.top = NULL;
+  altbacktrack.topbacktracks = NULL;
+
+  if (altbacktrack.cc != ccbegin)
+    OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(STACK_TOP), STACK(0));
+
+  compile_matchingpath(common, altbacktrack.cc, cc, &altbacktrack);
+  if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
+    return;
+
+  add_jump(compiler, &common->accept, JUMP(SLJIT_JUMP));
+
+  compile_backtrackingpath(common, altbacktrack.top);
+  if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
+    return;
+  set_jumps(altbacktrack.topbacktracks, LABEL());
+
+  if (*cc != OP_ALT)
+    break;
+
+  altbacktrack.cc = cc + 1 + LINK_SIZE;
+  cc += GET(cc, 1);
+  }
+
+/* None of them matched. */
+OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 0);
+jump = JUMP(SLJIT_JUMP);
+
+if (common->quit != NULL)
+  {
+  set_jumps(common->quit, LABEL());
+  OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), common->recursive_head_ptr);
+  if (needs_frame)
+    {
+    OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));
+    add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
+    OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));
+    }
+  OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 0);
+  common->quit = NULL;
+  add_jump(compiler, &common->quit, JUMP(SLJIT_JUMP));
+  }
+
+set_jumps(common->accept, LABEL());
+OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), common->recursive_head_ptr);
+if (needs_frame)
+  {
+  OP2(SLJIT_ADD, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));
+  add_jump(compiler, &common->revertframes, JUMP(SLJIT_FAST_CALL));
+  OP2(SLJIT_SUB, STACK_TOP, 0, STACK_TOP, 0, SLJIT_IMM, (framesize + alternativesize) * sizeof(sljit_sw));
+  }
+OP1(SLJIT_MOV, TMP3, 0, SLJIT_IMM, 1);
+
+JUMPHERE(jump);
+if (common->quit != NULL)
+  set_jumps(common->quit, LABEL());
+copy_private_data(common, ccbegin, ccend, FALSE, framesize + alternativesize, private_data_size + framesize + alternativesize, needs_control_head);
+free_stack(common, private_data_size + framesize + alternativesize);
+if (needs_control_head)
+  {
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(STACK_TOP), STACK(-3));
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(-2));
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->recursive_head_ptr, TMP1, 0);
+  OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, TMP2, 0);
+  }
+else
+  {
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(STACK_TOP), STACK(-2));
+  OP1(SLJIT_MOV, TMP1, 0, TMP3, 0);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->recursive_head_ptr, TMP2, 0);
+  }
+sljit_emit_fast_return(compiler, SLJIT_MEM1(STACK_TOP), STACK(-1));
+}
+
+#undef COMPILE_BACKTRACKINGPATH
+#undef CURRENT_AS
+
+void
+PRIV(jit_compile)(const REAL_PCRE *re, PUBL(extra) *extra, int mode)
+{
+struct sljit_compiler *compiler;
+backtrack_common rootbacktrack;
+compiler_common common_data;
+compiler_common *common = &common_data;
+const sljit_u8 *tables = re->tables;
+pcre_study_data *study;
+int private_data_size;
+pcre_uchar *ccend;
+executable_functions *functions;
+void *executable_func;
+sljit_uw executable_size;
+sljit_uw total_length;
+label_addr_list *label_addr;
+struct sljit_label *mainloop_label = NULL;
+struct sljit_label *continue_match_label;
+struct sljit_label *empty_match_found_label = NULL;
+struct sljit_label *empty_match_backtrack_label = NULL;
+struct sljit_label *reset_match_label;
+struct sljit_label *quit_label;
+struct sljit_jump *jump;
+struct sljit_jump *minlength_check_failed = NULL;
+struct sljit_jump *reqbyte_notfound = NULL;
+struct sljit_jump *empty_match = NULL;
+
+SLJIT_ASSERT((extra->flags & PCRE_EXTRA_STUDY_DATA) != 0);
+study = extra->study_data;
+
+if (!tables)
+  tables = PRIV(default_tables);
+
+memset(&rootbacktrack, 0, sizeof(backtrack_common));
+memset(common, 0, sizeof(compiler_common));
+rootbacktrack.cc = (pcre_uchar *)re + re->name_table_offset + re->name_count * re->name_entry_size;
+
+common->start = rootbacktrack.cc;
+common->read_only_data_head = NULL;
+common->fcc = tables + fcc_offset;
+common->lcc = (sljit_sw)(tables + lcc_offset);
+common->mode = mode;
+common->might_be_empty = study->minlength == 0;
+common->nltype = NLTYPE_FIXED;
+switch(re->options & PCRE_NEWLINE_BITS)
+  {
+  case 0:
+  /* Compile-time default */
+  switch(NEWLINE)
+    {
+    case -1: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANY; break;
+    case -2: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANYCRLF; break;
+    default: common->newline = NEWLINE; break;
+    }
+  break;
+  case PCRE_NEWLINE_CR: common->newline = CHAR_CR; break;
+  case PCRE_NEWLINE_LF: common->newline = CHAR_NL; break;
+  case PCRE_NEWLINE_CR+
+       PCRE_NEWLINE_LF: common->newline = (CHAR_CR << 8) | CHAR_NL; break;
+  case PCRE_NEWLINE_ANY: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANY; break;
+  case PCRE_NEWLINE_ANYCRLF: common->newline = (CHAR_CR << 8) | CHAR_NL; common->nltype = NLTYPE_ANYCRLF; break;
+  default: return;
+  }
+common->nlmax = READ_CHAR_MAX;
+common->nlmin = 0;
+if ((re->options & PCRE_BSR_ANYCRLF) != 0)
+  common->bsr_nltype = NLTYPE_ANYCRLF;
+else if ((re->options & PCRE_BSR_UNICODE) != 0)
+  common->bsr_nltype = NLTYPE_ANY;
+else
+  {
+#ifdef BSR_ANYCRLF
+  common->bsr_nltype = NLTYPE_ANYCRLF;
+#else
+  common->bsr_nltype = NLTYPE_ANY;
+#endif
+  }
+common->bsr_nlmax = READ_CHAR_MAX;
+common->bsr_nlmin = 0;
+common->endonly = (re->options & PCRE_DOLLAR_ENDONLY) != 0;
+common->ctypes = (sljit_sw)(tables + ctypes_offset);
+common->name_table = ((pcre_uchar *)re) + re->name_table_offset;
+common->name_count = re->name_count;
+common->name_entry_size = re->name_entry_size;
+common->jscript_compat = (re->options & PCRE_JAVASCRIPT_COMPAT) != 0;
+#ifdef SUPPORT_UTF
+/* PCRE_UTF[16|32] have the same value as PCRE_UTF8. */
+common->utf = (re->options & PCRE_UTF8) != 0;
+#ifdef SUPPORT_UCP
+common->use_ucp = (re->options & PCRE_UCP) != 0;
+#endif
+if (common->utf)
+  {
+  if (common->nltype == NLTYPE_ANY)
+    common->nlmax = 0x2029;
+  else if (common->nltype == NLTYPE_ANYCRLF)
+    common->nlmax = (CHAR_CR > CHAR_NL) ? CHAR_CR : CHAR_NL;
+  else
+    {
+    /* We only care about the first newline character. */
+    common->nlmax = common->newline & 0xff;
+    }
+
+  if (common->nltype == NLTYPE_FIXED)
+    common->nlmin = common->newline & 0xff;
+  else
+    common->nlmin = (CHAR_CR < CHAR_NL) ? CHAR_CR : CHAR_NL;
+
+  if (common->bsr_nltype == NLTYPE_ANY)
+    common->bsr_nlmax = 0x2029;
+  else
+    common->bsr_nlmax = (CHAR_CR > CHAR_NL) ? CHAR_CR : CHAR_NL;
+  common->bsr_nlmin = (CHAR_CR < CHAR_NL) ? CHAR_CR : CHAR_NL;
+  }
+#endif /* SUPPORT_UTF */
+ccend = bracketend(common->start);
+
+/* Calculate the local space size on the stack. */
+common->ovector_start = LIMIT_MATCH + sizeof(sljit_sw);
+common->optimized_cbracket = (sljit_u8 *)SLJIT_MALLOC(re->top_bracket + 1, compiler->allocator_data);
+if (!common->optimized_cbracket)
+  return;
+#if defined DEBUG_FORCE_UNOPTIMIZED_CBRAS && DEBUG_FORCE_UNOPTIMIZED_CBRAS == 1
+memset(common->optimized_cbracket, 0, re->top_bracket + 1);
+#else
+memset(common->optimized_cbracket, 1, re->top_bracket + 1);
+#endif
+
+SLJIT_ASSERT(*common->start == OP_BRA && ccend[-(1 + LINK_SIZE)] == OP_KET);
+#if defined DEBUG_FORCE_UNOPTIMIZED_CBRAS && DEBUG_FORCE_UNOPTIMIZED_CBRAS == 2
+common->capture_last_ptr = common->ovector_start;
+common->ovector_start += sizeof(sljit_sw);
+#endif
+if (!check_opcode_types(common, common->start, ccend))
+  {
+  SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);
+  return;
+  }
+
+/* Checking flags and updating ovector_start. */
+if (mode == JIT_COMPILE && (re->flags & PCRE_REQCHSET) != 0 && (re->options & PCRE_NO_START_OPTIMIZE) == 0)
+  {
+  common->req_char_ptr = common->ovector_start;
+  common->ovector_start += sizeof(sljit_sw);
+  }
+if (mode != JIT_COMPILE)
+  {
+  common->start_used_ptr = common->ovector_start;
+  common->ovector_start += sizeof(sljit_sw);
+  if (mode == JIT_PARTIAL_SOFT_COMPILE)
+    {
+    common->hit_start = common->ovector_start;
+    common->ovector_start += 2 * sizeof(sljit_sw);
+    }
+  }
+if ((re->options & PCRE_FIRSTLINE) != 0)
+  {
+  common->match_end_ptr = common->ovector_start;
+  common->ovector_start += sizeof(sljit_sw);
+  }
+#if defined DEBUG_FORCE_CONTROL_HEAD && DEBUG_FORCE_CONTROL_HEAD
+common->control_head_ptr = 1;
+#endif
+if (common->control_head_ptr != 0)
+  {
+  common->control_head_ptr = common->ovector_start;
+  common->ovector_start += sizeof(sljit_sw);
+  }
+if (common->has_set_som)
+  {
+  /* Saving the real start pointer is necessary. */
+  common->start_ptr = common->ovector_start;
+  common->ovector_start += sizeof(sljit_sw);
+  }
+
+/* Aligning ovector to even number of sljit words. */
+if ((common->ovector_start & sizeof(sljit_sw)) != 0)
+  common->ovector_start += sizeof(sljit_sw);
+
+if (common->start_ptr == 0)
+  common->start_ptr = OVECTOR(0);
+
+/* Capturing brackets cannot be optimized if callouts are allowed. */
+if (common->capture_last_ptr != 0)
+  memset(common->optimized_cbracket, 0, re->top_bracket + 1);
+
+SLJIT_ASSERT(!(common->req_char_ptr != 0 && common->start_used_ptr != 0));
+common->cbra_ptr = OVECTOR_START + (re->top_bracket + 1) * 2 * sizeof(sljit_sw);
+
+total_length = ccend - common->start;
+common->private_data_ptrs = (sljit_s32 *)SLJIT_MALLOC(total_length * (sizeof(sljit_s32) + (common->has_then ? 1 : 0)), compiler->allocator_data);
+if (!common->private_data_ptrs)
+  {
+  SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);
+  return;
+  }
+memset(common->private_data_ptrs, 0, total_length * sizeof(sljit_s32));
+
+private_data_size = common->cbra_ptr + (re->top_bracket + 1) * sizeof(sljit_sw);
+set_private_data_ptrs(common, &private_data_size, ccend);
+if ((re->options & PCRE_ANCHORED) == 0 && (re->options & PCRE_NO_START_OPTIMIZE) == 0)
+  {
+  if (!detect_fast_forward_skip(common, &private_data_size) && !common->has_skip_in_assert_back)
+    detect_fast_fail(common, common->start, &private_data_size, 4);
+  }
+
+SLJIT_ASSERT(common->fast_fail_start_ptr <= common->fast_fail_end_ptr);
+
+if (private_data_size > SLJIT_MAX_LOCAL_SIZE)
+  {
+  SLJIT_FREE(common->private_data_ptrs, compiler->allocator_data);
+  SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);
+  return;
+  }
+
+if (common->has_then)
+  {
+  common->then_offsets = (sljit_u8 *)(common->private_data_ptrs + total_length);
+  memset(common->then_offsets, 0, total_length);
+  set_then_offsets(common, common->start, NULL);
+  }
+
+compiler = sljit_create_compiler(NULL);
+if (!compiler)
+  {
+  SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);
+  SLJIT_FREE(common->private_data_ptrs, compiler->allocator_data);
+  return;
+  }
+common->compiler = compiler;
+
+/* Main pcre_jit_exec entry. */
+sljit_emit_enter(compiler, 0, SLJIT_ARG1(SW), 5, 5, 0, 0, private_data_size);
+
+/* Register init. */
+reset_ovector(common, (re->top_bracket + 1) * 2);
+if (common->req_char_ptr != 0)
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->req_char_ptr, SLJIT_R0, 0);
+
+OP1(SLJIT_MOV, ARGUMENTS, 0, SLJIT_S0, 0);
+OP1(SLJIT_MOV, TMP1, 0, SLJIT_S0, 0);
+OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
+OP1(SLJIT_MOV, STR_END, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, end));
+OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, stack));
+OP1(SLJIT_MOV_U32, TMP1, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, limit_match));
+OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(struct sljit_stack, end));
+OP1(SLJIT_MOV, STACK_LIMIT, 0, SLJIT_MEM1(TMP2), SLJIT_OFFSETOF(struct sljit_stack, start));
+OP2(SLJIT_ADD, TMP1, 0, TMP1, 0, SLJIT_IMM, 1);
+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LIMIT_MATCH, TMP1, 0);
+
+if (common->fast_fail_start_ptr < common->fast_fail_end_ptr)
+  reset_fast_fail(common);
+
+if (mode == JIT_PARTIAL_SOFT_COMPILE)
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, -1);
+if (common->mark_ptr != 0)
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->mark_ptr, SLJIT_IMM, 0);
+if (common->control_head_ptr != 0)
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->control_head_ptr, SLJIT_IMM, 0);
+
+/* Main part of the matching */
+if ((re->options & PCRE_ANCHORED) == 0)
+  {
+  mainloop_label = mainloop_entry(common, (re->flags & PCRE_HASCRORLF) != 0);
+  continue_match_label = LABEL();
+  /* Forward search if possible. */
+  if ((re->options & PCRE_NO_START_OPTIMIZE) == 0)
+    {
+    if (mode == JIT_COMPILE && fast_forward_first_n_chars(common))
+      ;
+    else if ((re->flags & PCRE_FIRSTSET) != 0)
+      fast_forward_first_char(common, (pcre_uchar)re->first_char, (re->flags & PCRE_FCH_CASELESS) != 0);
+    else if ((re->flags & PCRE_STARTLINE) != 0)
+      fast_forward_newline(common);
+    else if (study != NULL && (study->flags & PCRE_STUDY_MAPPED) != 0)
+      fast_forward_start_bits(common, study->start_bits);
+    }
+  }
+else
+  continue_match_label = LABEL();
+
+if (mode == JIT_COMPILE && study->minlength > 0 && (re->options & PCRE_NO_START_OPTIMIZE) == 0)
+  {
+  OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);
+  OP2(SLJIT_ADD, TMP2, 0, STR_PTR, 0, SLJIT_IMM, IN_UCHARS(study->minlength));
+  minlength_check_failed = CMP(SLJIT_GREATER, TMP2, 0, STR_END, 0);
+  }
+if (common->req_char_ptr != 0)
+  reqbyte_notfound = search_requested_char(common, (pcre_uchar)re->req_char, (re->flags & PCRE_RCH_CASELESS) != 0, (re->flags & PCRE_FIRSTSET) != 0);
+
+/* Store the current STR_PTR in OVECTOR(0). */
+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), OVECTOR(0), STR_PTR, 0);
+/* Copy the limit of allowed recursions. */
+OP1(SLJIT_MOV, COUNT_MATCH, 0, SLJIT_MEM1(SLJIT_SP), LIMIT_MATCH);
+if (common->capture_last_ptr != 0)
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->capture_last_ptr, SLJIT_IMM, -1);
+if (common->fast_forward_bc_ptr != NULL)
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), PRIVATE_DATA(common->fast_forward_bc_ptr + 1), STR_PTR, 0);
+
+if (common->start_ptr != OVECTOR(0))
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_ptr, STR_PTR, 0);
+
+/* Copy the beginning of the string. */
+if (mode == JIT_PARTIAL_SOFT_COMPILE)
+  {
+  jump = CMP(SLJIT_NOT_EQUAL, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, -1);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start + sizeof(sljit_sw), STR_PTR, 0);
+  JUMPHERE(jump);
+  }
+else if (mode == JIT_PARTIAL_HARD_COMPILE)
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, STR_PTR, 0);
+
+compile_matchingpath(common, common->start, ccend, &rootbacktrack);
+if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
+  {
+  sljit_free_compiler(compiler);
+  SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);
+  SLJIT_FREE(common->private_data_ptrs, compiler->allocator_data);
+  free_read_only_data(common->read_only_data_head, compiler->allocator_data);
+  return;
+  }
+
+if (common->might_be_empty)
+  {
+  empty_match = CMP(SLJIT_EQUAL, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP), OVECTOR(0));
+  empty_match_found_label = LABEL();
+  }
+
+common->accept_label = LABEL();
+if (common->accept != NULL)
+  set_jumps(common->accept, common->accept_label);
+
+/* This means we have a match. Update the ovector. */
+copy_ovector(common, re->top_bracket + 1);
+common->quit_label = common->forced_quit_label = LABEL();
+if (common->quit != NULL)
+  set_jumps(common->quit, common->quit_label);
+if (common->forced_quit != NULL)
+  set_jumps(common->forced_quit, common->forced_quit_label);
+if (minlength_check_failed != NULL)
+  SET_LABEL(minlength_check_failed, common->forced_quit_label);
+sljit_emit_return(compiler, SLJIT_MOV, SLJIT_RETURN_REG, 0);
+
+if (mode != JIT_COMPILE)
+  {
+  common->partialmatchlabel = LABEL();
+  set_jumps(common->partialmatch, common->partialmatchlabel);
+  return_with_partial_match(common, common->quit_label);
+  }
+
+if (common->might_be_empty)
+  empty_match_backtrack_label = LABEL();
+compile_backtrackingpath(common, rootbacktrack.top);
+if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
+  {
+  sljit_free_compiler(compiler);
+  SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);
+  SLJIT_FREE(common->private_data_ptrs, compiler->allocator_data);
+  free_read_only_data(common->read_only_data_head, compiler->allocator_data);
+  return;
+  }
+
+SLJIT_ASSERT(rootbacktrack.prev == NULL);
+reset_match_label = LABEL();
+
+if (mode == JIT_PARTIAL_SOFT_COMPILE)
+  {
+  /* Update hit_start only in the first time. */
+  jump = CMP(SLJIT_NOT_EQUAL, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, 0);
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->start_used_ptr, SLJIT_IMM, -1);
+  OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), common->hit_start, TMP1, 0);
+  JUMPHERE(jump);
+  }
+
+/* Check we have remaining characters. */
+if ((re->options & PCRE_ANCHORED) == 0 && (re->options & PCRE_FIRSTLINE) != 0)
+  {
+  SLJIT_ASSERT(common->match_end_ptr != 0);
+  OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), common->match_end_ptr);
+  }
+
+OP1(SLJIT_MOV, STR_PTR, 0, SLJIT_MEM1(SLJIT_SP),
+    (common->fast_forward_bc_ptr != NULL) ? (PRIVATE_DATA(common->fast_forward_bc_ptr + 1)) : common->start_ptr);
+
+if ((re->options & PCRE_ANCHORED) == 0)
+  {
+  if (common->ff_newline_shortcut != NULL)
+    {
+    if ((re->options & PCRE_FIRSTLINE) == 0)
+      CMPTO(SLJIT_LESS, STR_PTR, 0, STR_END, 0, common->ff_newline_shortcut);
+    /* There cannot be more newlines here. */
+    }
+  else
+    CMPTO(SLJIT_LESS, STR_PTR, 0, ((re->options & PCRE_FIRSTLINE) == 0) ? STR_END : TMP1, 0, mainloop_label);
+  }
+
+/* No more remaining characters. */
+if (reqbyte_notfound != NULL)
+  JUMPHERE(reqbyte_notfound);
+
+if (mode == JIT_PARTIAL_SOFT_COMPILE)
+  CMPTO(SLJIT_NOT_EQUAL, SLJIT_MEM1(SLJIT_SP), common->hit_start, SLJIT_IMM, -1, common->partialmatchlabel);
+
+OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_NOMATCH);
+JUMPTO(SLJIT_JUMP, common->quit_label);
+
+flush_stubs(common);
+
+if (common->might_be_empty)
+  {
+  JUMPHERE(empty_match);
+  OP1(SLJIT_MOV, TMP1, 0, ARGUMENTS, 0);
+  OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty));
+  CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, SLJIT_IMM, 0, empty_match_backtrack_label);
+  OP1(SLJIT_MOV_U8, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, notempty_atstart));
+  CMPTO(SLJIT_EQUAL, TMP2, 0, SLJIT_IMM, 0, empty_match_found_label);
+  OP1(SLJIT_MOV, TMP2, 0, SLJIT_MEM1(TMP1), SLJIT_OFFSETOF(jit_arguments, str));
+  CMPTO(SLJIT_NOT_EQUAL, TMP2, 0, STR_PTR, 0, empty_match_found_label);
+  JUMPTO(SLJIT_JUMP, empty_match_backtrack_label);
+  }
+
+common->fast_forward_bc_ptr = NULL;
+common->fast_fail_start_ptr = 0;
+common->fast_fail_end_ptr = 0;
+common->currententry = common->entries;
+common->local_exit = TRUE;
+quit_label = common->quit_label;
+while (common->currententry != NULL)
+  {
+  /* Might add new entries. */
+  compile_recurse(common);
+  if (SLJIT_UNLIKELY(sljit_get_compiler_error(compiler)))
+    {
+    sljit_free_compiler(compiler);
+    SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);
+    SLJIT_FREE(common->private_data_ptrs, compiler->allocator_data);
+    free_read_only_data(common->read_only_data_head, compiler->allocator_data);
+    return;
+    }
+  flush_stubs(common);
+  common->currententry = common->currententry->next;
+  }
+common->local_exit = FALSE;
+common->quit_label = quit_label;
+
+/* Allocating stack, returns with PCRE_ERROR_JIT_STACKLIMIT if fails. */
+/* This is a (really) rare case. */
+set_jumps(common->stackalloc, LABEL());
+/* RETURN_ADDR is not a saved register. */
+sljit_emit_fast_enter(compiler, SLJIT_MEM1(SLJIT_SP), LOCALS0);
+
+SLJIT_ASSERT(TMP1 == SLJIT_R0 && STACK_TOP == SLJIT_R1);
+
+OP1(SLJIT_MOV, SLJIT_MEM1(SLJIT_SP), LOCALS1, STACK_TOP, 0);
+OP1(SLJIT_MOV, SLJIT_R0, 0, ARGUMENTS, 0);
+OP2(SLJIT_SUB, SLJIT_R1, 0, STACK_LIMIT, 0, SLJIT_IMM, STACK_GROWTH_RATE);
+OP1(SLJIT_MOV, SLJIT_R0, 0, SLJIT_MEM1(SLJIT_R0), SLJIT_OFFSETOF(jit_arguments, stack));
+OP1(SLJIT_MOV, STACK_LIMIT, 0, TMP2, 0);
+
+sljit_emit_icall(compiler, SLJIT_CALL, SLJIT_RET(SW) | SLJIT_ARG1(SW) | SLJIT_ARG2(SW), SLJIT_IMM, SLJIT_FUNC_OFFSET(sljit_stack_resize));
+jump = CMP(SLJIT_EQUAL, SLJIT_RETURN_REG, 0, SLJIT_IMM, 0);
+OP1(SLJIT_MOV, TMP2, 0, STACK_LIMIT, 0);
+OP1(SLJIT_MOV, STACK_LIMIT, 0, SLJIT_RETURN_REG, 0);
+OP1(SLJIT_MOV, TMP1, 0, SLJIT_MEM1(SLJIT_SP), LOCALS0);
+OP1(SLJIT_MOV, STACK_TOP, 0, SLJIT_MEM1(SLJIT_SP), LOCALS1);
+sljit_emit_fast_return(compiler, TMP1, 0);
+
+/* Allocation failed. */
+JUMPHERE(jump);
+/* We break the return address cache here, but this is a really rare case. */
+OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_JIT_STACKLIMIT);
+JUMPTO(SLJIT_JUMP, common->quit_label);
+
+/* Call limit reached. */
+set_jumps(common->calllimit, LABEL());
+OP1(SLJIT_MOV, SLJIT_RETURN_REG, 0, SLJIT_IMM, PCRE_ERROR_MATCHLIMIT);
+JUMPTO(SLJIT_JUMP, common->quit_label);
+
+if (common->revertframes != NULL)
+  {
+  set_jumps(common->revertframes, LABEL());
+  do_revertframes(common);
+  }
+if (common->wordboundary != NULL)
+  {
+  set_jumps(common->wordboundary, LABEL());
+  check_wordboundary(common);
+  }
+if (common->anynewline != NULL)
+  {
+  set_jumps(common->anynewline, LABEL());
+  check_anynewline(common);
+  }
+if (common->hspace != NULL)
+  {
+  set_jumps(common->hspace, LABEL());
+  check_hspace(common);
+  }
+if (common->vspace != NULL)
+  {
+  set_jumps(common->vspace, LABEL());
+  check_vspace(common);
+  }
+if (common->casefulcmp != NULL)
+  {
+  set_jumps(common->casefulcmp, LABEL());
+  do_casefulcmp(common);
+  }
+if (common->caselesscmp != NULL)
+  {
+  set_jumps(common->caselesscmp, LABEL());
+  do_caselesscmp(common);
+  }
+if (common->reset_match != NULL)
+  {
+  set_jumps(common->reset_match, LABEL());
+  do_reset_match(common, (re->top_bracket + 1) * 2);
+  CMPTO(SLJIT_GREATER, STR_PTR, 0, TMP1, 0, continue_match_label);
+  OP1(SLJIT_MOV, STR_PTR, 0, TMP1, 0);
+  JUMPTO(SLJIT_JUMP, reset_match_label);
+  }
+#ifdef SUPPORT_UTF
+#ifdef COMPILE_PCRE8
+if (common->utfreadchar != NULL)
+  {
+  set_jumps(common->utfreadchar, LABEL());
+  do_utfreadchar(common);
+  }
+if (common->utfreadchar16 != NULL)
+  {
+  set_jumps(common->utfreadchar16, LABEL());
+  do_utfreadchar16(common);
+  }
+if (common->utfreadtype8 != NULL)
+  {
+  set_jumps(common->utfreadtype8, LABEL());
+  do_utfreadtype8(common);
+  }
+#endif /* COMPILE_PCRE8 */
+#endif /* SUPPORT_UTF */
+#ifdef SUPPORT_UCP
+if (common->getucd != NULL)
+  {
+  set_jumps(common->getucd, LABEL());
+  do_getucd(common);
+  }
+#endif
+
+SLJIT_FREE(common->optimized_cbracket, compiler->allocator_data);
+SLJIT_FREE(common->private_data_ptrs, compiler->allocator_data);
+
+executable_func = sljit_generate_code(compiler);
+executable_size = sljit_get_generated_code_size(compiler);
+label_addr = common->label_addrs;
+while (label_addr != NULL)
+  {
+  *label_addr->update_addr = sljit_get_label_addr(label_addr->label);
+  label_addr = label_addr->next;
+  }
+sljit_free_compiler(compiler);
+if (executable_func == NULL)
+  {
+  free_read_only_data(common->read_only_data_head, compiler->allocator_data);
+  return;
+  }
+
+/* Reuse the function descriptor if possible. */
+if ((extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 && extra->executable_jit != NULL)
+  functions = (executable_functions *)extra->executable_jit;
+else
+  {
+  /* Note: If your memory-checker has flagged the allocation below as a
+   * memory leak, it is probably because you either forgot to call
+   * pcre_free_study() (or pcre16_free_study()) on the pcre_extra (or
+   * pcre16_extra) object, or you called said function after having
+   * cleared the PCRE_EXTRA_EXECUTABLE_JIT bit from the "flags" field
+   * of the object. (The function will only free the JIT data if the
+   * bit remains set, as the bit indicates that the pointer to the data
+   * is valid.)
+   */
+  functions = SLJIT_MALLOC(sizeof(executable_functions), compiler->allocator_data);
+  if (functions == NULL)
+    {
+    /* This case is highly unlikely since we just recently
+    freed a lot of memory. Not impossible though. */
+    sljit_free_code(executable_func);
+    free_read_only_data(common->read_only_data_head, compiler->allocator_data);
+    return;
+    }
+  memset(functions, 0, sizeof(executable_functions));
+  functions->top_bracket = (re->top_bracket + 1) * 2;
+  functions->limit_match = (re->flags & PCRE_MLSET) != 0 ? re->limit_match : 0;
+  extra->executable_jit = functions;
+  extra->flags |= PCRE_EXTRA_EXECUTABLE_JIT;
+  }
+
+functions->executable_funcs[mode] = executable_func;
+functions->read_only_data_heads[mode] = common->read_only_data_head;
+functions->executable_sizes[mode] = executable_size;
+}
+
+static SLJIT_NOINLINE int jit_machine_stack_exec(jit_arguments *arguments, void *executable_func)
+{
+union {
+   void *executable_func;
+   jit_function call_executable_func;
+} convert_executable_func;
+sljit_u8 local_space[MACHINE_STACK_SIZE];
+struct sljit_stack local_stack;
+
+local_stack.min_start = local_space;
+local_stack.start = local_space;
+local_stack.end = local_space + MACHINE_STACK_SIZE;
+local_stack.top = local_space + MACHINE_STACK_SIZE;
+arguments->stack = &local_stack;
+convert_executable_func.executable_func = executable_func;
+return convert_executable_func.call_executable_func(arguments);
+}
+
+int
+PRIV(jit_exec)(const PUBL(extra) *extra_data, const pcre_uchar *subject,
+  int length, int start_offset, int options, int *offsets, int offset_count)
+{
+executable_functions *functions = (executable_functions *)extra_data->executable_jit;
+union {
+   void *executable_func;
+   jit_function call_executable_func;
+} convert_executable_func;
+jit_arguments arguments;
+int max_offset_count;
+int retval;
+int mode = JIT_COMPILE;
+
+if ((options & PCRE_PARTIAL_HARD) != 0)
+  mode = JIT_PARTIAL_HARD_COMPILE;
+else if ((options & PCRE_PARTIAL_SOFT) != 0)
+  mode = JIT_PARTIAL_SOFT_COMPILE;
+
+if (functions->executable_funcs[mode] == NULL)
+  return PCRE_ERROR_JIT_BADOPTION;
+
+/* Sanity checks should be handled by pcre_exec. */
+arguments.str = subject + start_offset;
+arguments.begin = subject;
+arguments.end = subject + length;
+arguments.mark_ptr = NULL;
+/* JIT decreases this value less frequently than the interpreter. */
+arguments.limit_match = ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0) ? MATCH_LIMIT : (sljit_u32)(extra_data->match_limit);
+if (functions->limit_match != 0 && functions->limit_match < arguments.limit_match)
+  arguments.limit_match = functions->limit_match;
+arguments.notbol = (options & PCRE_NOTBOL) != 0;
+arguments.noteol = (options & PCRE_NOTEOL) != 0;
+arguments.notempty = (options & PCRE_NOTEMPTY) != 0;
+arguments.notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;
+arguments.offsets = offsets;
+arguments.callout_data = (extra_data->flags & PCRE_EXTRA_CALLOUT_DATA) != 0 ? extra_data->callout_data : NULL;
+arguments.real_offset_count = offset_count;
+
+/* pcre_exec() rounds offset_count to a multiple of 3, and then uses only 2/3 of
+the output vector for storing captured strings, with the remainder used as
+workspace. We don't need the workspace here. For compatibility, we limit the
+number of captured strings in the same way as pcre_exec(), so that the user
+gets the same result with and without JIT. */
+
+if (offset_count != 2)
+  offset_count = ((offset_count - (offset_count % 3)) * 2) / 3;
+max_offset_count = functions->top_bracket;
+if (offset_count > max_offset_count)
+  offset_count = max_offset_count;
+arguments.offset_count = offset_count;
+
+if (functions->callback)
+  arguments.stack = (struct sljit_stack *)functions->callback(functions->userdata);
+else
+  arguments.stack = (struct sljit_stack *)functions->userdata;
+
+if (arguments.stack == NULL)
+  retval = jit_machine_stack_exec(&arguments, functions->executable_funcs[mode]);
+else
+  {
+  convert_executable_func.executable_func = functions->executable_funcs[mode];
+  retval = convert_executable_func.call_executable_func(&arguments);
+  }
+
+if (retval * 2 > offset_count)
+  retval = 0;
+if ((extra_data->flags & PCRE_EXTRA_MARK) != 0)
+  *(extra_data->mark) = arguments.mark_ptr;
+
+return retval;
+}
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre_jit_exec(const pcre *argument_re, const pcre_extra *extra_data,
+  PCRE_SPTR subject, int length, int start_offset, int options,
+  int *offsets, int offset_count, pcre_jit_stack *stack)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre16_jit_exec(const pcre16 *argument_re, const pcre16_extra *extra_data,
+  PCRE_SPTR16 subject, int length, int start_offset, int options,
+  int *offsets, int offset_count, pcre16_jit_stack *stack)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre32_jit_exec(const pcre32 *argument_re, const pcre32_extra *extra_data,
+  PCRE_SPTR32 subject, int length, int start_offset, int options,
+  int *offsets, int offset_count, pcre32_jit_stack *stack)
+#endif
+{
+pcre_uchar *subject_ptr = (pcre_uchar *)subject;
+executable_functions *functions = (executable_functions *)extra_data->executable_jit;
+union {
+   void *executable_func;
+   jit_function call_executable_func;
+} convert_executable_func;
+jit_arguments arguments;
+int max_offset_count;
+int retval;
+int mode = JIT_COMPILE;
+
+SLJIT_UNUSED_ARG(argument_re);
+
+/* Plausibility checks */
+if ((options & ~PUBLIC_JIT_EXEC_OPTIONS) != 0) return PCRE_ERROR_JIT_BADOPTION;
+
+if ((options & PCRE_PARTIAL_HARD) != 0)
+  mode = JIT_PARTIAL_HARD_COMPILE;
+else if ((options & PCRE_PARTIAL_SOFT) != 0)
+  mode = JIT_PARTIAL_SOFT_COMPILE;
+
+if (functions == NULL || functions->executable_funcs[mode] == NULL)
+  return PCRE_ERROR_JIT_BADOPTION;
+
+/* Sanity checks should be handled by pcre_exec. */
+arguments.stack = (struct sljit_stack *)stack;
+arguments.str = subject_ptr + start_offset;
+arguments.begin = subject_ptr;
+arguments.end = subject_ptr + length;
+arguments.mark_ptr = NULL;
+/* JIT decreases this value less frequently than the interpreter. */
+arguments.limit_match = ((extra_data->flags & PCRE_EXTRA_MATCH_LIMIT) == 0) ? MATCH_LIMIT : (sljit_u32)(extra_data->match_limit);
+if (functions->limit_match != 0 && functions->limit_match < arguments.limit_match)
+  arguments.limit_match = functions->limit_match;
+arguments.notbol = (options & PCRE_NOTBOL) != 0;
+arguments.noteol = (options & PCRE_NOTEOL) != 0;
+arguments.notempty = (options & PCRE_NOTEMPTY) != 0;
+arguments.notempty_atstart = (options & PCRE_NOTEMPTY_ATSTART) != 0;
+arguments.offsets = offsets;
+arguments.callout_data = (extra_data->flags & PCRE_EXTRA_CALLOUT_DATA) != 0 ? extra_data->callout_data : NULL;
+arguments.real_offset_count = offset_count;
+
+/* pcre_exec() rounds offset_count to a multiple of 3, and then uses only 2/3 of
+the output vector for storing captured strings, with the remainder used as
+workspace. We don't need the workspace here. For compatibility, we limit the
+number of captured strings in the same way as pcre_exec(), so that the user
+gets the same result with and without JIT. */
+
+if (offset_count != 2)
+  offset_count = ((offset_count - (offset_count % 3)) * 2) / 3;
+max_offset_count = functions->top_bracket;
+if (offset_count > max_offset_count)
+  offset_count = max_offset_count;
+arguments.offset_count = offset_count;
+
+convert_executable_func.executable_func = functions->executable_funcs[mode];
+retval = convert_executable_func.call_executable_func(&arguments);
+
+if (retval * 2 > offset_count)
+  retval = 0;
+if ((extra_data->flags & PCRE_EXTRA_MARK) != 0)
+  *(extra_data->mark) = arguments.mark_ptr;
+
+return retval;
+}
+
+void
+PRIV(jit_free)(void *executable_funcs)
+{
+int i;
+executable_functions *functions = (executable_functions *)executable_funcs;
+for (i = 0; i < JIT_NUMBER_OF_COMPILE_MODES; i++)
+  {
+  if (functions->executable_funcs[i] != NULL)
+    sljit_free_code(functions->executable_funcs[i]);
+  free_read_only_data(functions->read_only_data_heads[i], NULL);
+  }
+SLJIT_FREE(functions, compiler->allocator_data);
+}
+
+int
+PRIV(jit_get_size)(void *executable_funcs)
+{
+int i;
+sljit_uw size = 0;
+sljit_uw *executable_sizes = ((executable_functions *)executable_funcs)->executable_sizes;
+for (i = 0; i < JIT_NUMBER_OF_COMPILE_MODES; i++)
+  size += executable_sizes[i];
+return (int)size;
+}
+
+const char*
+PRIV(jit_get_target)(void)
+{
+return sljit_get_platform_name();
+}
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DECL pcre_jit_stack *
+pcre_jit_stack_alloc(int startsize, int maxsize)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DECL pcre16_jit_stack *
+pcre16_jit_stack_alloc(int startsize, int maxsize)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DECL pcre32_jit_stack *
+pcre32_jit_stack_alloc(int startsize, int maxsize)
+#endif
+{
+if (startsize < 1 || maxsize < 1)
+  return NULL;
+if (startsize > maxsize)
+  startsize = maxsize;
+startsize = (startsize + STACK_GROWTH_RATE - 1) & ~(STACK_GROWTH_RATE - 1);
+maxsize = (maxsize + STACK_GROWTH_RATE - 1) & ~(STACK_GROWTH_RATE - 1);
+return (PUBL(jit_stack)*)sljit_allocate_stack(startsize, maxsize, NULL);
+}
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DECL void
+pcre_jit_stack_free(pcre_jit_stack *stack)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DECL void
+pcre16_jit_stack_free(pcre16_jit_stack *stack)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DECL void
+pcre32_jit_stack_free(pcre32_jit_stack *stack)
+#endif
+{
+sljit_free_stack((struct sljit_stack *)stack, NULL);
+}
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DECL void
+pcre_assign_jit_stack(pcre_extra *extra, pcre_jit_callback callback, void *userdata)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DECL void
+pcre16_assign_jit_stack(pcre16_extra *extra, pcre16_jit_callback callback, void *userdata)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DECL void
+pcre32_assign_jit_stack(pcre32_extra *extra, pcre32_jit_callback callback, void *userdata)
+#endif
+{
+executable_functions *functions;
+if (extra != NULL &&
+    (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 &&
+    extra->executable_jit != NULL)
+  {
+  functions = (executable_functions *)extra->executable_jit;
+  functions->callback = callback;
+  functions->userdata = userdata;
+  }
+}
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DECL void
+pcre_jit_free_unused_memory(void)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DECL void
+pcre16_jit_free_unused_memory(void)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DECL void
+pcre32_jit_free_unused_memory(void)
+#endif
+{
+sljit_free_unused_memory_exec();
+}
+
+#else  /* SUPPORT_JIT */
+
+/* These are dummy functions to avoid linking errors when JIT support is not
+being compiled. */
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DECL pcre_jit_stack *
+pcre_jit_stack_alloc(int startsize, int maxsize)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DECL pcre16_jit_stack *
+pcre16_jit_stack_alloc(int startsize, int maxsize)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DECL pcre32_jit_stack *
+pcre32_jit_stack_alloc(int startsize, int maxsize)
+#endif
+{
+(void)startsize;
+(void)maxsize;
+return NULL;
+}
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DECL void
+pcre_jit_stack_free(pcre_jit_stack *stack)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DECL void
+pcre16_jit_stack_free(pcre16_jit_stack *stack)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DECL void
+pcre32_jit_stack_free(pcre32_jit_stack *stack)
+#endif
+{
+(void)stack;
+}
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DECL void
+pcre_assign_jit_stack(pcre_extra *extra, pcre_jit_callback callback, void *userdata)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DECL void
+pcre16_assign_jit_stack(pcre16_extra *extra, pcre16_jit_callback callback, void *userdata)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DECL void
+pcre32_assign_jit_stack(pcre32_extra *extra, pcre32_jit_callback callback, void *userdata)
+#endif
+{
+(void)extra;
+(void)callback;
+(void)userdata;
+}
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DECL void
+pcre_jit_free_unused_memory(void)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DECL void
+pcre16_jit_free_unused_memory(void)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DECL void
+pcre32_jit_free_unused_memory(void)
+#endif
+{
+}
+
+#endif
+
+/* End of pcre_jit_compile.c */
diff --git a/base/poco/Foundation/src/pcre_maketables.c b/base/poco/Foundation/src/pcre_maketables.c
new file mode 100644
index 00000000000..d86e391dad3
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_maketables.c
@@ -0,0 +1,155 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2012 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+
+/* This module contains the external function pcre_maketables(), which builds
+character tables for PCRE in the current locale. The file is compiled on its
+own as part of the PCRE library. However, it is also included in the
+compilation of dftables.c, in which case the macro DFTABLES is defined. */
+
+#pragma warning( disable : 4244)  // conversion from 'int' to 'unsigned short', possible loss of data
+
+#ifndef DFTABLES
+#  include "pcre_config.h"
+#  include "pcre_internal.h"
+#endif
+
+
+/*************************************************
+*           Create PCRE character tables         *
+*************************************************/
+
+/* This function builds a set of character tables for use by PCRE and returns
+a pointer to them. They are build using the ctype functions, and consequently
+their contents will depend upon the current locale setting. When compiled as
+part of the library, the store is obtained via PUBL(malloc)(), but when
+compiled inside dftables, use malloc().
+
+Arguments:   none
+Returns:     pointer to the contiguous block of data
+*/
+
+#if defined COMPILE_PCRE8
+const unsigned char *
+pcre_maketables(void)
+#elif defined COMPILE_PCRE16
+const unsigned char *
+pcre16_maketables(void)
+#elif defined COMPILE_PCRE32
+const unsigned char *
+pcre32_maketables(void)
+#endif
+{
+unsigned char *yield, *p;
+int i;
+
+#ifndef DFTABLES
+yield = (unsigned char*)(PUBL(malloc))(tables_length);
+#else
+yield = (unsigned char*)malloc(tables_length);
+#endif
+
+if (yield == NULL) return NULL;
+p = yield;
+
+/* First comes the lower casing table */
+
+for (i = 0; i < 256; i++) *p++ = tolower(i);
+
+/* Next the case-flipping table */
+
+for (i = 0; i < 256; i++) *p++ = islower(i)? toupper(i) : tolower(i);
+
+/* Then the character class tables. Don't try to be clever and save effort on
+exclusive ones - in some locales things may be different.
+
+Note that the table for "space" includes everything "isspace" gives, including
+VT in the default locale. This makes it work for the POSIX class [:space:].
+From release 8.34 is is also correct for Perl space, because Perl added VT at
+release 5.18.
+
+Note also that it is possible for a character to be alnum or alpha without
+being lower or upper, such as "male and female ordinals" (\xAA and \xBA) in the
+fr_FR locale (at least under Debian Linux's locales as of 12/2005). So we must
+test for alnum specially. */
+
+memset(p, 0, cbit_length);
+for (i = 0; i < 256; i++)
+  {
+  if (isdigit(i)) p[cbit_digit  + i/8] |= 1 << (i&7);
+  if (isupper(i)) p[cbit_upper  + i/8] |= 1 << (i&7);
+  if (islower(i)) p[cbit_lower  + i/8] |= 1 << (i&7);
+  if (isalnum(i)) p[cbit_word   + i/8] |= 1 << (i&7);
+  if (i == '_')   p[cbit_word   + i/8] |= 1 << (i&7);
+  if (isspace(i)) p[cbit_space  + i/8] |= 1 << (i&7);
+  if (isxdigit(i))p[cbit_xdigit + i/8] |= 1 << (i&7);
+  if (isgraph(i)) p[cbit_graph  + i/8] |= 1 << (i&7);
+  if (isprint(i)) p[cbit_print  + i/8] |= 1 << (i&7);
+  if (ispunct(i)) p[cbit_punct  + i/8] |= 1 << (i&7);
+  if (iscntrl(i)) p[cbit_cntrl  + i/8] |= 1 << (i&7);
+  }
+p += cbit_length;
+
+/* Finally, the character type table. In this, we used to exclude VT from the
+white space chars, because Perl didn't recognize it as such for \s and for
+comments within regexes. However, Perl changed at release 5.18, so PCRE changed
+at release 8.34. */
+
+for (i = 0; i < 256; i++)
+  {
+  int x = 0;
+  if (isspace(i)) x += ctype_space;
+  if (isalpha(i)) x += ctype_letter;
+  if (isdigit(i)) x += ctype_digit;
+  if (isxdigit(i)) x += ctype_xdigit;
+  if (isalnum(i) || i == '_') x += ctype_word;
+
+  /* Note: strchr includes the terminating zero in the characters it considers.
+  In this instance, that is ok because we want binary zero to be flagged as a
+  meta-character, which in this sense is any character that terminates a run
+  of data characters. */
+
+  if (strchr("\\*+?{^.$|()[", i) != 0) x += ctype_meta;
+  *p++ = x;
+  }
+
+return yield;
+}
+
+/* End of pcre_maketables.c */
diff --git a/base/poco/Foundation/src/pcre_newline.c b/base/poco/Foundation/src/pcre_newline.c
new file mode 100644
index 00000000000..08933bfc7fe
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_newline.c
@@ -0,0 +1,207 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2012 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+
+/* This module contains internal functions for testing newlines when more than
+one kind of newline is to be recognized. When a newline is found, its length is
+returned. In principle, we could implement several newline "types", each
+referring to a different set of newline characters. At present, PCRE supports
+only NLTYPE_FIXED, which gets handled without these functions, NLTYPE_ANYCRLF,
+and NLTYPE_ANY. The full list of Unicode newline characters is taken from
+http://unicode.org/unicode/reports/tr18/. */
+
+
+#include "pcre_config.h"
+#include "pcre_internal.h"
+
+
+
+/*************************************************
+*      Check for newline at given position       *
+*************************************************/
+
+/* It is guaranteed that the initial value of ptr is less than the end of the
+string that is being processed.
+
+Arguments:
+  ptr          pointer to possible newline
+  type         the newline type
+  endptr       pointer to the end of the string
+  lenptr       where to return the length
+  utf          TRUE if in utf mode
+
+Returns:       TRUE or FALSE
+*/
+
+BOOL
+PRIV(is_newline)(PCRE_PUCHAR ptr, int type, PCRE_PUCHAR endptr, int *lenptr,
+  BOOL utf)
+{
+pcre_uint32 c;
+(void)utf;
+#ifdef SUPPORT_UTF
+if (utf)
+  {
+  GETCHAR(c, ptr);
+  }
+else
+#endif  /* SUPPORT_UTF */
+  c = *ptr;
+
+/* Note that this function is called only for ANY or ANYCRLF. */
+
+if (type == NLTYPE_ANYCRLF) switch(c)
+  {
+  case CHAR_LF: *lenptr = 1; return TRUE;
+  case CHAR_CR: *lenptr = (ptr < endptr - 1 && ptr[1] == CHAR_LF)? 2 : 1;
+               return TRUE;
+  default: return FALSE;
+  }
+
+/* NLTYPE_ANY */
+
+else switch(c)
+  {
+#ifdef EBCDIC
+  case CHAR_NEL:
+#endif
+  case CHAR_LF:
+  case CHAR_VT:
+  case CHAR_FF: *lenptr = 1; return TRUE;
+
+  case CHAR_CR:
+  *lenptr = (ptr < endptr - 1 && ptr[1] == CHAR_LF)? 2 : 1;
+  return TRUE;
+
+#ifndef EBCDIC
+#ifdef COMPILE_PCRE8
+  case CHAR_NEL: *lenptr = utf? 2 : 1; return TRUE;
+  case 0x2028:                                       /* LS */
+  case 0x2029: *lenptr = 3; return TRUE;             /* PS */
+#else /* COMPILE_PCRE16 || COMPILE_PCRE32 */
+  case CHAR_NEL:
+  case 0x2028:                                       /* LS */
+  case 0x2029: *lenptr = 1; return TRUE;             /* PS */
+#endif  /* COMPILE_PCRE8 */
+#endif  /* Not EBCDIC */
+
+  default: return FALSE;
+  }
+}
+
+
+
+/*************************************************
+*     Check for newline at previous position     *
+*************************************************/
+
+/* It is guaranteed that the initial value of ptr is greater than the start of
+the string that is being processed.
+
+Arguments:
+  ptr          pointer to possible newline
+  type         the newline type
+  startptr     pointer to the start of the string
+  lenptr       where to return the length
+  utf          TRUE if in utf mode
+
+Returns:       TRUE or FALSE
+*/
+
+BOOL
+PRIV(was_newline)(PCRE_PUCHAR ptr, int type, PCRE_PUCHAR startptr, int *lenptr,
+  BOOL utf)
+{
+pcre_uint32 c;
+(void)utf;
+ptr--;
+#ifdef SUPPORT_UTF
+if (utf)
+  {
+  BACKCHAR(ptr);
+  GETCHAR(c, ptr);
+  }
+else
+#endif  /* SUPPORT_UTF */
+  c = *ptr;
+
+/* Note that this function is called only for ANY or ANYCRLF. */
+
+if (type == NLTYPE_ANYCRLF) switch(c)
+  {
+  case CHAR_LF:
+  *lenptr = (ptr > startptr && ptr[-1] == CHAR_CR)? 2 : 1;
+  return TRUE;
+
+  case CHAR_CR: *lenptr = 1; return TRUE;
+  default: return FALSE;
+  }
+
+/* NLTYPE_ANY */
+
+else switch(c)
+  {
+  case CHAR_LF:
+  *lenptr = (ptr > startptr && ptr[-1] == CHAR_CR)? 2 : 1;
+  return TRUE;
+
+#ifdef EBCDIC
+  case CHAR_NEL:
+#endif
+  case CHAR_VT:
+  case CHAR_FF:
+  case CHAR_CR: *lenptr = 1; return TRUE;
+
+#ifndef EBCDIC
+#ifdef COMPILE_PCRE8
+  case CHAR_NEL: *lenptr = utf? 2 : 1; return TRUE;
+  case 0x2028:                                       /* LS */
+  case 0x2029: *lenptr = 3; return TRUE;             /* PS */
+#else /* COMPILE_PCRE16 || COMPILE_PCRE32 */
+  case CHAR_NEL:
+  case 0x2028:                                       /* LS */
+  case 0x2029: *lenptr = 1; return TRUE;             /* PS */
+#endif  /* COMPILE_PCRE8 */
+#endif  /* NotEBCDIC */
+
+  default: return FALSE;
+  }
+}
+
+/* End of pcre_newline.c */
diff --git a/base/poco/Foundation/src/pcre_ord2utf8.c b/base/poco/Foundation/src/pcre_ord2utf8.c
new file mode 100644
index 00000000000..e69e7f8351c
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_ord2utf8.c
@@ -0,0 +1,92 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2012 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+#pragma warning( disable : 4244)  // conversion from 'int' to 'unsigned short', possible loss of data
+
+/* This file contains a private PCRE function that converts an ordinal
+character value into a UTF8 string. */
+
+#include "pcre_config.h"
+#define COMPILE_PCRE8
+
+#include "pcre_internal.h"
+
+/*************************************************
+*       Convert character value to UTF-8         *
+*************************************************/
+
+/* This function takes an integer value in the range 0 - 0x10ffff
+and encodes it as a UTF-8 character in 1 to 4 pcre_uchars.
+
+Arguments:
+  cvalue     the character value
+  buffer     pointer to buffer for result - at least 6 pcre_uchars long
+
+Returns:     number of characters placed in the buffer
+*/
+
+unsigned
+int
+PRIV(ord2utf)(pcre_uint32 cvalue, pcre_uchar *buffer)
+{
+#ifdef SUPPORT_UTF
+
+register int i, j;
+
+for (i = 0; i < PRIV(utf8_table1_size); i++)
+  if ((int)cvalue <= PRIV(utf8_table1)[i]) break;
+buffer += i;
+for (j = i; j > 0; j--)
+ {
+ *buffer-- = 0x80 | (cvalue & 0x3f);
+ cvalue >>= 6;
+ }
+*buffer = PRIV(utf8_table2)[i] | cvalue;
+return i + 1;
+
+#else
+
+(void)(cvalue);  /* Keep compiler happy; this function won't ever be */
+(void)(buffer);  /* called when SUPPORT_UTF is not defined. */
+return 0;
+
+#endif
+}
+
+/* End of pcre_ord2utf8.c */
diff --git a/base/poco/Foundation/src/pcre_refcount.c b/base/poco/Foundation/src/pcre_refcount.c
new file mode 100644
index 00000000000..e22afe6aa65
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_refcount.c
@@ -0,0 +1,90 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2012 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+#pragma warning( disable : 4244)  // conversion from 'int' to 'unsigned short', possible loss of data
+
+/* This module contains the external function pcre_refcount(), which is an
+auxiliary function that can be used to maintain a reference count in a compiled
+pattern data block. This might be helpful in applications where the block is
+shared by different users. */
+
+
+#include "pcre_config.h"
+#include "pcre_internal.h"
+
+
+/*************************************************
+*           Maintain reference count             *
+*************************************************/
+
+/* The reference count is a 16-bit field, initialized to zero. It is not
+possible to transfer a non-zero count from one host to a different host that
+has a different byte order - though I can't see why anyone in their right mind
+would ever want to do that!
+
+Arguments:
+  argument_re   points to compiled code
+  adjust        value to add to the count
+
+Returns:        the (possibly updated) count value (a non-negative number), or
+                a negative error number
+*/
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre_refcount(pcre *argument_re, int adjust)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre16_refcount(pcre16 *argument_re, int adjust)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN int PCRE_CALL_CONVENTION
+pcre32_refcount(pcre32 *argument_re, int adjust)
+#endif
+{
+REAL_PCRE *re = (REAL_PCRE *)argument_re;
+if (re == NULL) return PCRE_ERROR_NULL;
+if (re->magic_number != MAGIC_NUMBER) return PCRE_ERROR_BADMAGIC;
+if ((re->flags & PCRE_MODE) == 0) return PCRE_ERROR_BADMODE;
+re->ref_count = (-adjust > re->ref_count)? 0 :
+                (adjust + re->ref_count > 65535)? 65535 :
+                re->ref_count + adjust;
+return re->ref_count;
+}
+
+/* End of pcre_refcount.c */
diff --git a/base/poco/Foundation/src/pcre_string_utils.c b/base/poco/Foundation/src/pcre_string_utils.c
new file mode 100644
index 00000000000..089aa6222d4
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_string_utils.c
@@ -0,0 +1,207 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2014 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+
+/* This module contains internal functions for comparing and finding the length
+of strings for different data item sizes. */
+
+#include "pcre_config.h"
+#include "pcre_internal.h"
+
+#ifndef COMPILE_PCRE8
+
+/*************************************************
+*           Compare string utilities             *
+*************************************************/
+
+/* The following two functions compares two strings. Basically a strcmp
+for non 8 bit characters.
+
+Arguments:
+  str1        first string
+  str2        second string
+
+Returns:      0 if both string are equal (like strcmp), 1 otherwise
+*/
+
+int
+PRIV(strcmp_uc_uc)(const pcre_uchar *str1, const pcre_uchar *str2)
+{
+pcre_uchar c1;
+pcre_uchar c2;
+
+while (*str1 != '\0' || *str2 != '\0')
+  {
+  c1 = *str1++;
+  c2 = *str2++;
+  if (c1 != c2)
+    return ((c1 > c2) << 1) - 1;
+  }
+/* Both length and characters must be equal. */
+return 0;
+}
+
+#ifdef COMPILE_PCRE32
+
+int
+PRIV(strcmp_uc_uc_utf)(const pcre_uchar *str1, const pcre_uchar *str2)
+{
+pcre_uchar c1;
+pcre_uchar c2;
+
+while (*str1 != '\0' || *str2 != '\0')
+  {
+  c1 = UCHAR21INC(str1);
+  c2 = UCHAR21INC(str2);
+  if (c1 != c2)
+    return ((c1 > c2) << 1) - 1;
+  }
+/* Both length and characters must be equal. */
+return 0;
+}
+
+#endif /* COMPILE_PCRE32 */
+
+int
+PRIV(strcmp_uc_c8)(const pcre_uchar *str1, const char *str2)
+{
+const pcre_uint8 *ustr2 = (pcre_uint8 *)str2;
+pcre_uchar c1;
+pcre_uchar c2;
+
+while (*str1 != '\0' || *ustr2 != '\0')
+  {
+  c1 = *str1++;
+  c2 = (pcre_uchar)*ustr2++;
+  if (c1 != c2)
+    return ((c1 > c2) << 1) - 1;
+  }
+/* Both length and characters must be equal. */
+return 0;
+}
+
+#ifdef COMPILE_PCRE32
+
+int
+PRIV(strcmp_uc_c8_utf)(const pcre_uchar *str1, const char *str2)
+{
+const pcre_uint8 *ustr2 = (pcre_uint8 *)str2;
+pcre_uchar c1;
+pcre_uchar c2;
+
+while (*str1 != '\0' || *ustr2 != '\0')
+  {
+  c1 = UCHAR21INC(str1);
+  c2 = (pcre_uchar)*ustr2++;
+  if (c1 != c2)
+    return ((c1 > c2) << 1) - 1;
+  }
+/* Both length and characters must be equal. */
+return 0;
+}
+
+#endif /* COMPILE_PCRE32 */
+
+/* The following two functions compares two, fixed length
+strings. Basically an strncmp for non 8 bit characters.
+
+Arguments:
+  str1        first string
+  str2        second string
+  num         size of the string
+
+Returns:      0 if both string are equal (like strcmp), 1 otherwise
+*/
+
+int
+PRIV(strncmp_uc_uc)(const pcre_uchar *str1, const pcre_uchar *str2, unsigned int num)
+{
+pcre_uchar c1;
+pcre_uchar c2;
+
+while (num-- > 0)
+  {
+  c1 = *str1++;
+  c2 = *str2++;
+  if (c1 != c2)
+    return ((c1 > c2) << 1) - 1;
+  }
+/* Both length and characters must be equal. */
+return 0;
+}
+
+int
+PRIV(strncmp_uc_c8)(const pcre_uchar *str1, const char *str2, unsigned int num)
+{
+const pcre_uint8 *ustr2 = (pcre_uint8 *)str2;
+pcre_uchar c1;
+pcre_uchar c2;
+
+while (num-- > 0)
+  {
+  c1 = *str1++;
+  c2 = (pcre_uchar)*ustr2++;
+  if (c1 != c2)
+    return ((c1 > c2) << 1) - 1;
+  }
+/* Both length and characters must be equal. */
+return 0;
+}
+
+/* The following function returns with the length of
+a zero terminated string. Basically an strlen for non 8 bit characters.
+
+Arguments:
+  str         string
+
+Returns:      length of the string
+*/
+
+unsigned int
+PRIV(strlen_uc)(const pcre_uchar *str)
+{
+unsigned int len = 0;
+while (*str++ != 0)
+  len++;
+return len;
+}
+
+#endif /* !COMPILE_PCRE8 */
+
+/* End of pcre_string_utils.c */
diff --git a/base/poco/Foundation/src/pcre_study.c b/base/poco/Foundation/src/pcre_study.c
new file mode 100644
index 00000000000..3facd6fb83c
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_study.c
@@ -0,0 +1,1683 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2012 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+#pragma warning( disable : 4244)  // conversion from 'int' to 'unsigned short', possible loss of data
+
+/* This module contains the external function pcre_study(), along with local
+supporting functions. */
+
+#include "pcre_config.h"
+#include "pcre_internal.h"
+
+#define SET_BIT(c) start_bits[c/8] |= (1 << (c&7))
+
+/* Returns from set_start_bits() */
+
+enum { SSB_FAIL, SSB_DONE, SSB_CONTINUE, SSB_UNKNOWN };
+
+
+
+/*************************************************
+*   Find the minimum subject length for a group  *
+*************************************************/
+
+/* Scan a parenthesized group and compute the minimum length of subject that
+is needed to match it. This is a lower bound; it does not mean there is a
+string of that length that matches. In UTF8 mode, the result is in characters
+rather than bytes.
+
+Arguments:
+  re              compiled pattern block
+  code            pointer to start of group (the bracket)
+  startcode       pointer to start of the whole pattern's code
+  options         the compiling options
+  recurses        chain of recurse_check to catch mutual recursion
+  countptr        pointer to call count (to catch over complexity)
+
+Returns:   the minimum length
+           -1 if \C in UTF-8 mode or (*ACCEPT) was encountered
+           -2 internal error (missing capturing bracket)
+           -3 internal error (opcode not listed)
+*/
+
+static int
+find_minlength(const REAL_PCRE *re, const pcre_uchar *code,
+  const pcre_uchar *startcode, int options, recurse_check *recurses,
+  int *countptr)
+{
+int length = -1;
+/* PCRE_UTF16 has the same value as PCRE_UTF8. */
+BOOL utf = (options & PCRE_UTF8) != 0;
+BOOL had_recurse = FALSE;
+recurse_check this_recurse;
+register int branchlength = 0;
+register pcre_uchar *cc = (pcre_uchar *)code + 1 + LINK_SIZE;
+
+if ((*countptr)++ > 1000) return -1;   /* too complex */
+
+if (*code == OP_CBRA || *code == OP_SCBRA ||
+    *code == OP_CBRAPOS || *code == OP_SCBRAPOS) cc += IMM2_SIZE;
+
+/* Scan along the opcodes for this branch. If we get to the end of the
+branch, check the length against that of the other branches. */
+
+for (;;)
+  {
+  int d, min;
+  pcre_uchar *cs, *ce;
+  register pcre_uchar op = *cc;
+
+  switch (op)
+    {
+    case OP_COND:
+    case OP_SCOND:
+
+    /* If there is only one branch in a condition, the implied branch has zero
+    length, so we don't add anything. This covers the DEFINE "condition"
+    automatically. */
+
+    cs = cc + GET(cc, 1);
+    if (*cs != OP_ALT)
+      {
+      cc = cs + 1 + LINK_SIZE;
+      break;
+      }
+
+    /* Otherwise we can fall through and treat it the same as any other
+    subpattern. */
+
+    case OP_CBRA:
+    case OP_SCBRA:
+    case OP_BRA:
+    case OP_SBRA:
+    case OP_CBRAPOS:
+    case OP_SCBRAPOS:
+    case OP_BRAPOS:
+    case OP_SBRAPOS:
+    case OP_ONCE:
+    case OP_ONCE_NC:
+    d = find_minlength(re, cc, startcode, options, recurses, countptr);
+    if (d < 0) return d;
+    branchlength += d;
+    do cc += GET(cc, 1); while (*cc == OP_ALT);
+    cc += 1 + LINK_SIZE;
+    break;
+
+    /* ACCEPT makes things far too complicated; we have to give up. */
+
+    case OP_ACCEPT:
+    case OP_ASSERT_ACCEPT:
+    return -1;
+
+    /* Reached end of a branch; if it's a ket it is the end of a nested
+    call. If it's ALT it is an alternation in a nested call. If it is END it's
+    the end of the outer call. All can be handled by the same code. If an
+    ACCEPT was previously encountered, use the length that was in force at that
+    time, and pass back the shortest ACCEPT length. */
+
+    case OP_ALT:
+    case OP_KET:
+    case OP_KETRMAX:
+    case OP_KETRMIN:
+    case OP_KETRPOS:
+    case OP_END:
+    if (length < 0 || (!had_recurse && branchlength < length))
+      length = branchlength;
+    if (op != OP_ALT) return length;
+    cc += 1 + LINK_SIZE;
+    branchlength = 0;
+    had_recurse = FALSE;
+    break;
+
+    /* Skip over assertive subpatterns */
+
+    case OP_ASSERT:
+    case OP_ASSERT_NOT:
+    case OP_ASSERTBACK:
+    case OP_ASSERTBACK_NOT:
+    do cc += GET(cc, 1); while (*cc == OP_ALT);
+    /* Fall through */
+
+    /* Skip over things that don't match chars */
+
+    case OP_REVERSE:
+    case OP_CREF:
+    case OP_DNCREF:
+    case OP_RREF:
+    case OP_DNRREF:
+    case OP_DEF:
+    case OP_CALLOUT:
+    case OP_SOD:
+    case OP_SOM:
+    case OP_EOD:
+    case OP_EODN:
+    case OP_CIRC:
+    case OP_CIRCM:
+    case OP_DOLL:
+    case OP_DOLLM:
+    case OP_NOT_WORD_BOUNDARY:
+    case OP_WORD_BOUNDARY:
+    cc += PRIV(OP_lengths)[*cc];
+    break;
+
+    /* Skip over a subpattern that has a {0} or {0,x} quantifier */
+
+    case OP_BRAZERO:
+    case OP_BRAMINZERO:
+    case OP_BRAPOSZERO:
+    case OP_SKIPZERO:
+    cc += PRIV(OP_lengths)[*cc];
+    do cc += GET(cc, 1); while (*cc == OP_ALT);
+    cc += 1 + LINK_SIZE;
+    break;
+
+    /* Handle literal characters and + repetitions */
+
+    case OP_CHAR:
+    case OP_CHARI:
+    case OP_NOT:
+    case OP_NOTI:
+    case OP_PLUS:
+    case OP_PLUSI:
+    case OP_MINPLUS:
+    case OP_MINPLUSI:
+    case OP_POSPLUS:
+    case OP_POSPLUSI:
+    case OP_NOTPLUS:
+    case OP_NOTPLUSI:
+    case OP_NOTMINPLUS:
+    case OP_NOTMINPLUSI:
+    case OP_NOTPOSPLUS:
+    case OP_NOTPOSPLUSI:
+    branchlength++;
+    cc += 2;
+#ifdef SUPPORT_UTF
+    if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+#endif
+    break;
+
+    case OP_TYPEPLUS:
+    case OP_TYPEMINPLUS:
+    case OP_TYPEPOSPLUS:
+    branchlength++;
+    cc += (cc[1] == OP_PROP || cc[1] == OP_NOTPROP)? 4 : 2;
+    break;
+
+    /* Handle exact repetitions. The count is already in characters, but we
+    need to skip over a multibyte character in UTF8 mode.  */
+
+    case OP_EXACT:
+    case OP_EXACTI:
+    case OP_NOTEXACT:
+    case OP_NOTEXACTI:
+    branchlength += GET2(cc,1);
+    cc += 2 + IMM2_SIZE;
+#ifdef SUPPORT_UTF
+    if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+#endif
+    break;
+
+    case OP_TYPEEXACT:
+    branchlength += GET2(cc,1);
+    cc += 2 + IMM2_SIZE + ((cc[1 + IMM2_SIZE] == OP_PROP
+      || cc[1 + IMM2_SIZE] == OP_NOTPROP)? 2 : 0);
+    break;
+
+    /* Handle single-char non-literal matchers */
+
+    case OP_PROP:
+    case OP_NOTPROP:
+    cc += 2;
+    /* Fall through */
+
+    case OP_NOT_DIGIT:
+    case OP_DIGIT:
+    case OP_NOT_WHITESPACE:
+    case OP_WHITESPACE:
+    case OP_NOT_WORDCHAR:
+    case OP_WORDCHAR:
+    case OP_ANY:
+    case OP_ALLANY:
+    case OP_EXTUNI:
+    case OP_HSPACE:
+    case OP_NOT_HSPACE:
+    case OP_VSPACE:
+    case OP_NOT_VSPACE:
+    branchlength++;
+    cc++;
+    break;
+
+    /* "Any newline" might match two characters, but it also might match just
+    one. */
+
+    case OP_ANYNL:
+    branchlength += 1;
+    cc++;
+    break;
+
+    /* The single-byte matcher means we can't proceed in UTF-8 mode. (In
+    non-UTF-8 mode \C will actually be turned into OP_ALLANY, so won't ever
+    appear, but leave the code, just in case.) */
+
+    case OP_ANYBYTE:
+#ifdef SUPPORT_UTF
+    if (utf) return -1;
+#endif
+    branchlength++;
+    cc++;
+    break;
+
+    /* For repeated character types, we have to test for \p and \P, which have
+    an extra two bytes of parameters. */
+
+    case OP_TYPESTAR:
+    case OP_TYPEMINSTAR:
+    case OP_TYPEQUERY:
+    case OP_TYPEMINQUERY:
+    case OP_TYPEPOSSTAR:
+    case OP_TYPEPOSQUERY:
+    if (cc[1] == OP_PROP || cc[1] == OP_NOTPROP) cc += 2;
+    cc += PRIV(OP_lengths)[op];
+    break;
+
+    case OP_TYPEUPTO:
+    case OP_TYPEMINUPTO:
+    case OP_TYPEPOSUPTO:
+    if (cc[1 + IMM2_SIZE] == OP_PROP
+      || cc[1 + IMM2_SIZE] == OP_NOTPROP) cc += 2;
+    cc += PRIV(OP_lengths)[op];
+    break;
+
+    /* Check a class for variable quantification */
+
+    case OP_CLASS:
+    case OP_NCLASS:
+#if defined SUPPORT_UTF || defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+    case OP_XCLASS:
+    /* The original code caused an unsigned overflow in 64 bit systems,
+    so now we use a conditional statement. */
+    if (op == OP_XCLASS)
+      cc += GET(cc, 1);
+    else
+      cc += PRIV(OP_lengths)[OP_CLASS];
+#else
+    cc += PRIV(OP_lengths)[OP_CLASS];
+#endif
+
+    switch (*cc)
+      {
+      case OP_CRPLUS:
+      case OP_CRMINPLUS:
+      case OP_CRPOSPLUS:
+      branchlength++;
+      /* Fall through */
+
+      case OP_CRSTAR:
+      case OP_CRMINSTAR:
+      case OP_CRQUERY:
+      case OP_CRMINQUERY:
+      case OP_CRPOSSTAR:
+      case OP_CRPOSQUERY:
+      cc++;
+      break;
+
+      case OP_CRRANGE:
+      case OP_CRMINRANGE:
+      case OP_CRPOSRANGE:
+      branchlength += GET2(cc,1);
+      cc += 1 + 2 * IMM2_SIZE;
+      break;
+
+      default:
+      branchlength++;
+      break;
+      }
+    break;
+
+    /* Backreferences and subroutine calls are treated in the same way: we find
+    the minimum length for the subpattern. A recursion, however, causes an
+    a flag to be set that causes the length of this branch to be ignored. The
+    logic is that a recursion can only make sense if there is another
+    alternation that stops the recursing. That will provide the minimum length
+    (when no recursion happens). A backreference within the group that it is
+    referencing behaves in the same way.
+
+    If PCRE_JAVASCRIPT_COMPAT is set, a backreference to an unset bracket
+    matches an empty string (by default it causes a matching failure), so in
+    that case we must set the minimum length to zero. */
+
+    case OP_DNREF:     /* Duplicate named pattern back reference */
+    case OP_DNREFI:
+    if ((options & PCRE_JAVASCRIPT_COMPAT) == 0)
+      {
+      int count = GET2(cc, 1+IMM2_SIZE);
+      pcre_uchar *slot = (pcre_uchar *)re +
+        re->name_table_offset + GET2(cc, 1) * re->name_entry_size;
+      d = INT_MAX;
+      while (count-- > 0)
+        {
+        ce = cs = (pcre_uchar *)PRIV(find_bracket)(startcode, utf, GET2(slot, 0));
+        if (cs == NULL) return -2;
+        do ce += GET(ce, 1); while (*ce == OP_ALT);
+        if (cc > cs && cc < ce)     /* Simple recursion */
+          {
+          d = 0;
+          had_recurse = TRUE;
+          break;
+          }
+        else
+          {
+          recurse_check *r = recurses;
+          for (r = recurses; r != NULL; r = r->prev) if (r->group == cs) break;
+          if (r != NULL)           /* Mutual recursion */
+            {
+            d = 0;
+            had_recurse = TRUE;
+            break;
+            }
+          else
+            {
+            int dd;
+            this_recurse.prev = recurses;
+            this_recurse.group = cs;
+            dd = find_minlength(re, cs, startcode, options, &this_recurse,
+              countptr);
+            if (dd < d) d = dd;
+            }
+          }
+        slot += re->name_entry_size;
+        }
+      }
+    else d = 0;
+    cc += 1 + 2*IMM2_SIZE;
+    goto REPEAT_BACK_REFERENCE;
+
+    case OP_REF:      /* Single back reference */
+    case OP_REFI:
+    if ((options & PCRE_JAVASCRIPT_COMPAT) == 0)
+      {
+      ce = cs = (pcre_uchar *)PRIV(find_bracket)(startcode, utf, GET2(cc, 1));
+      if (cs == NULL) return -2;
+      do ce += GET(ce, 1); while (*ce == OP_ALT);
+      if (cc > cs && cc < ce)    /* Simple recursion */
+        {
+        d = 0;
+        had_recurse = TRUE;
+        }
+      else
+        {
+        recurse_check *r = recurses;
+        for (r = recurses; r != NULL; r = r->prev) if (r->group == cs) break;
+        if (r != NULL)           /* Mutual recursion */
+          {
+          d = 0;
+          had_recurse = TRUE;
+          }
+        else
+          {
+          this_recurse.prev = recurses;
+          this_recurse.group = cs;
+          d = find_minlength(re, cs, startcode, options, &this_recurse,
+            countptr);
+          }
+        }
+      }
+    else d = 0;
+    cc += 1 + IMM2_SIZE;
+
+    /* Handle repeated back references */
+
+    REPEAT_BACK_REFERENCE:
+    switch (*cc)
+      {
+      case OP_CRSTAR:
+      case OP_CRMINSTAR:
+      case OP_CRQUERY:
+      case OP_CRMINQUERY:
+      case OP_CRPOSSTAR:
+      case OP_CRPOSQUERY:
+      min = 0;
+      cc++;
+      break;
+
+      case OP_CRPLUS:
+      case OP_CRMINPLUS:
+      case OP_CRPOSPLUS:
+      min = 1;
+      cc++;
+      break;
+
+      case OP_CRRANGE:
+      case OP_CRMINRANGE:
+      case OP_CRPOSRANGE:
+      min = GET2(cc, 1);
+      cc += 1 + 2 * IMM2_SIZE;
+      break;
+
+      default:
+      min = 1;
+      break;
+      }
+
+    branchlength += min * d;
+    break;
+
+    /* We can easily detect direct recursion, but not mutual recursion. This is
+    caught by a recursion depth count. */
+
+    case OP_RECURSE:
+    cs = ce = (pcre_uchar *)startcode + GET(cc, 1);
+    do ce += GET(ce, 1); while (*ce == OP_ALT);
+    if (cc > cs && cc < ce)    /* Simple recursion */
+      had_recurse = TRUE;
+    else
+      {
+      recurse_check *r = recurses;
+      for (r = recurses; r != NULL; r = r->prev) if (r->group == cs) break;
+      if (r != NULL)           /* Mutual recursion */
+        had_recurse = TRUE;
+      else
+        {
+        this_recurse.prev = recurses;
+        this_recurse.group = cs;
+        branchlength += find_minlength(re, cs, startcode, options,
+          &this_recurse, countptr);
+        }
+      }
+    cc += 1 + LINK_SIZE;
+    break;
+
+    /* Anything else does not or need not match a character. We can get the
+    item's length from the table, but for those that can match zero occurrences
+    of a character, we must take special action for UTF-8 characters. As it
+    happens, the "NOT" versions of these opcodes are used at present only for
+    ASCII characters, so they could be omitted from this list. However, in
+    future that may change, so we include them here so as not to leave a
+    gotcha for a future maintainer. */
+
+    case OP_UPTO:
+    case OP_UPTOI:
+    case OP_NOTUPTO:
+    case OP_NOTUPTOI:
+    case OP_MINUPTO:
+    case OP_MINUPTOI:
+    case OP_NOTMINUPTO:
+    case OP_NOTMINUPTOI:
+    case OP_POSUPTO:
+    case OP_POSUPTOI:
+    case OP_NOTPOSUPTO:
+    case OP_NOTPOSUPTOI:
+
+    case OP_STAR:
+    case OP_STARI:
+    case OP_NOTSTAR:
+    case OP_NOTSTARI:
+    case OP_MINSTAR:
+    case OP_MINSTARI:
+    case OP_NOTMINSTAR:
+    case OP_NOTMINSTARI:
+    case OP_POSSTAR:
+    case OP_POSSTARI:
+    case OP_NOTPOSSTAR:
+    case OP_NOTPOSSTARI:
+
+    case OP_QUERY:
+    case OP_QUERYI:
+    case OP_NOTQUERY:
+    case OP_NOTQUERYI:
+    case OP_MINQUERY:
+    case OP_MINQUERYI:
+    case OP_NOTMINQUERY:
+    case OP_NOTMINQUERYI:
+    case OP_POSQUERY:
+    case OP_POSQUERYI:
+    case OP_NOTPOSQUERY:
+    case OP_NOTPOSQUERYI:
+
+    cc += PRIV(OP_lengths)[op];
+#ifdef SUPPORT_UTF
+    if (utf && HAS_EXTRALEN(cc[-1])) cc += GET_EXTRALEN(cc[-1]);
+#endif
+    break;
+
+    /* Skip these, but we need to add in the name length. */
+
+    case OP_MARK:
+    case OP_PRUNE_ARG:
+    case OP_SKIP_ARG:
+    case OP_THEN_ARG:
+    cc += PRIV(OP_lengths)[op] + cc[1];
+    break;
+
+    /* The remaining opcodes are just skipped over. */
+
+    case OP_CLOSE:
+    case OP_COMMIT:
+    case OP_FAIL:
+    case OP_PRUNE:
+    case OP_SET_SOM:
+    case OP_SKIP:
+    case OP_THEN:
+    cc += PRIV(OP_lengths)[op];
+    break;
+
+    /* This should not occur: we list all opcodes explicitly so that when
+    new ones get added they are properly considered. */
+
+    default:
+    return -3;
+    }
+  }
+/* Control never gets here */
+}
+
+
+
+/*************************************************
+*      Set a bit and maybe its alternate case    *
+*************************************************/
+
+/* Given a character, set its first byte's bit in the table, and also the
+corresponding bit for the other version of a letter if we are caseless. In
+UTF-8 mode, for characters greater than 127, we can only do the caseless thing
+when Unicode property support is available.
+
+Arguments:
+  start_bits    points to the bit map
+  p             points to the character
+  caseless      the caseless flag
+  cd            the block with char table pointers
+  utf           TRUE for UTF-8 / UTF-16 / UTF-32 mode
+
+Returns:        pointer after the character
+*/
+
+static const pcre_uchar *
+set_table_bit(pcre_uint8 *start_bits, const pcre_uchar *p, BOOL caseless,
+  compile_data *cd, BOOL utf)
+{
+pcre_uint32 c = *p;
+
+#ifdef COMPILE_PCRE8
+SET_BIT(c);
+
+#ifdef SUPPORT_UTF
+if (utf && c > 127)
+  {
+  GETCHARINC(c, p);
+#ifdef SUPPORT_UCP
+  if (caseless)
+    {
+    pcre_uchar buff[6];
+    c = UCD_OTHERCASE(c);
+    (void)PRIV(ord2utf)(c, buff);
+    SET_BIT(buff[0]);
+    }
+#endif  /* Not SUPPORT_UCP */
+  return p;
+  }
+#else   /* Not SUPPORT_UTF */
+(void)(utf);   /* Stops warning for unused parameter */
+#endif  /* SUPPORT_UTF */
+
+/* Not UTF-8 mode, or character is less than 127. */
+
+if (caseless && (cd->ctypes[c] & ctype_letter) != 0) SET_BIT(cd->fcc[c]);
+return p + 1;
+#endif  /* COMPILE_PCRE8 */
+
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+if (c > 0xff)
+  {
+  c = 0xff;
+  caseless = FALSE;
+  }
+SET_BIT(c);
+
+#ifdef SUPPORT_UTF
+if (utf && c > 127)
+  {
+  GETCHARINC(c, p);
+#ifdef SUPPORT_UCP
+  if (caseless)
+    {
+    c = UCD_OTHERCASE(c);
+    if (c > 0xff)
+      c = 0xff;
+    SET_BIT(c);
+    }
+#endif  /* SUPPORT_UCP */
+  return p;
+  }
+#else   /* Not SUPPORT_UTF */
+(void)(utf);   /* Stops warning for unused parameter */
+#endif  /* SUPPORT_UTF */
+
+if (caseless && (cd->ctypes[c] & ctype_letter) != 0) SET_BIT(cd->fcc[c]);
+return p + 1;
+#endif
+}
+
+
+
+/*************************************************
+*     Set bits for a positive character type     *
+*************************************************/
+
+/* This function sets starting bits for a character type. In UTF-8 mode, we can
+only do a direct setting for bytes less than 128, as otherwise there can be
+confusion with bytes in the middle of UTF-8 characters. In a "traditional"
+environment, the tables will only recognize ASCII characters anyway, but in at
+least one Windows environment, some higher bytes bits were set in the tables.
+So we deal with that case by considering the UTF-8 encoding.
+
+Arguments:
+  start_bits     the starting bitmap
+  cbit type      the type of character wanted
+  table_limit    32 for non-UTF-8; 16 for UTF-8
+  cd             the block with char table pointers
+
+Returns:         nothing
+*/
+
+static void
+set_type_bits(pcre_uint8 *start_bits, int cbit_type, unsigned int table_limit,
+  compile_data *cd)
+{
+register pcre_uint32 c;
+for (c = 0; c < table_limit; c++) start_bits[c] |= cd->cbits[c+cbit_type];
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+if (table_limit == 32) return;
+for (c = 128; c < 256; c++)
+  {
+  if ((cd->cbits[c/8] & (1 << (c&7))) != 0)
+    {
+    pcre_uchar buff[6];
+    (void)PRIV(ord2utf)(c, buff);
+    SET_BIT(buff[0]);
+    }
+  }
+#endif
+}
+
+
+/*************************************************
+*     Set bits for a negative character type     *
+*************************************************/
+
+/* This function sets starting bits for a negative character type such as \D.
+In UTF-8 mode, we can only do a direct setting for bytes less than 128, as
+otherwise there can be confusion with bytes in the middle of UTF-8 characters.
+Unlike in the positive case, where we can set appropriate starting bits for
+specific high-valued UTF-8 characters, in this case we have to set the bits for
+all high-valued characters. The lowest is 0xc2, but we overkill by starting at
+0xc0 (192) for simplicity.
+
+Arguments:
+  start_bits     the starting bitmap
+  cbit type      the type of character wanted
+  table_limit    32 for non-UTF-8; 16 for UTF-8
+  cd             the block with char table pointers
+
+Returns:         nothing
+*/
+
+static void
+set_nottype_bits(pcre_uint8 *start_bits, int cbit_type, unsigned int table_limit,
+  compile_data *cd)
+{
+register pcre_uint32 c;
+for (c = 0; c < table_limit; c++) start_bits[c] |= ~cd->cbits[c+cbit_type];
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+if (table_limit != 32) for (c = 24; c < 32; c++) start_bits[c] = 0xff;
+#endif
+}
+
+
+
+/*************************************************
+*          Create bitmap of starting bytes       *
+*************************************************/
+
+/* This function scans a compiled unanchored expression recursively and
+attempts to build a bitmap of the set of possible starting bytes. As time goes
+by, we may be able to get more clever at doing this. The SSB_CONTINUE return is
+useful for parenthesized groups in patterns such as (a*)b where the group
+provides some optional starting bytes but scanning must continue at the outer
+level to find at least one mandatory byte. At the outermost level, this
+function fails unless the result is SSB_DONE.
+
+Arguments:
+  code         points to an expression
+  start_bits   points to a 32-byte table, initialized to 0
+  utf          TRUE if in UTF-8 / UTF-16 / UTF-32 mode
+  cd           the block with char table pointers
+
+Returns:       SSB_FAIL     => Failed to find any starting bytes
+               SSB_DONE     => Found mandatory starting bytes
+               SSB_CONTINUE => Found optional starting bytes
+               SSB_UNKNOWN  => Hit an unrecognized opcode
+*/
+
+static int
+set_start_bits(const pcre_uchar *code, pcre_uint8 *start_bits, BOOL utf,
+  compile_data *cd)
+{
+register pcre_uint32 c;
+int yield = SSB_DONE;
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+int table_limit = utf? 16:32;
+#else
+int table_limit = 32;
+#endif
+
+#if 0
+/* ========================================================================= */
+/* The following comment and code was inserted in January 1999. In May 2006,
+when it was observed to cause compiler warnings about unused values, I took it
+out again. If anybody is still using OS/2, they will have to put it back
+manually. */
+
+/* This next statement and the later reference to dummy are here in order to
+trick the optimizer of the IBM C compiler for OS/2 into generating correct
+code. Apparently IBM isn't going to fix the problem, and we would rather not
+disable optimization (in this module it actually makes a big difference, and
+the pcre module can use all the optimization it can get). */
+
+volatile int dummy;
+/* ========================================================================= */
+#endif
+
+do
+  {
+  BOOL try_next = TRUE;
+  const pcre_uchar *tcode = code + 1 + LINK_SIZE;
+
+  if (*code == OP_CBRA || *code == OP_SCBRA ||
+      *code == OP_CBRAPOS || *code == OP_SCBRAPOS) tcode += IMM2_SIZE;
+
+  while (try_next)    /* Loop for items in this branch */
+    {
+    int rc;
+
+    switch(*tcode)
+      {
+      /* If we reach something we don't understand, it means a new opcode has
+      been created that hasn't been added to this code. Hopefully this problem
+      will be discovered during testing. */
+
+      default:
+      return SSB_UNKNOWN;
+
+      /* Fail for a valid opcode that implies no starting bits. */
+
+      case OP_ACCEPT:
+      case OP_ASSERT_ACCEPT:
+      case OP_ALLANY:
+      case OP_ANY:
+      case OP_ANYBYTE:
+      case OP_CIRC:
+      case OP_CIRCM:
+      case OP_CLOSE:
+      case OP_COMMIT:
+      case OP_COND:
+      case OP_CREF:
+      case OP_DEF:
+      case OP_DNCREF:
+      case OP_DNREF:
+      case OP_DNREFI:
+      case OP_DNRREF:
+      case OP_DOLL:
+      case OP_DOLLM:
+      case OP_END:
+      case OP_EOD:
+      case OP_EODN:
+      case OP_EXTUNI:
+      case OP_FAIL:
+      case OP_MARK:
+      case OP_NOT:
+      case OP_NOTEXACT:
+      case OP_NOTEXACTI:
+      case OP_NOTI:
+      case OP_NOTMINPLUS:
+      case OP_NOTMINPLUSI:
+      case OP_NOTMINQUERY:
+      case OP_NOTMINQUERYI:
+      case OP_NOTMINSTAR:
+      case OP_NOTMINSTARI:
+      case OP_NOTMINUPTO:
+      case OP_NOTMINUPTOI:
+      case OP_NOTPLUS:
+      case OP_NOTPLUSI:
+      case OP_NOTPOSPLUS:
+      case OP_NOTPOSPLUSI:
+      case OP_NOTPOSQUERY:
+      case OP_NOTPOSQUERYI:
+      case OP_NOTPOSSTAR:
+      case OP_NOTPOSSTARI:
+      case OP_NOTPOSUPTO:
+      case OP_NOTPOSUPTOI:
+      case OP_NOTPROP:
+      case OP_NOTQUERY:
+      case OP_NOTQUERYI:
+      case OP_NOTSTAR:
+      case OP_NOTSTARI:
+      case OP_NOTUPTO:
+      case OP_NOTUPTOI:
+      case OP_NOT_HSPACE:
+      case OP_NOT_VSPACE:
+      case OP_PRUNE:
+      case OP_PRUNE_ARG:
+      case OP_RECURSE:
+      case OP_REF:
+      case OP_REFI:
+      case OP_REVERSE:
+      case OP_RREF:
+      case OP_SCOND:
+      case OP_SET_SOM:
+      case OP_SKIP:
+      case OP_SKIP_ARG:
+      case OP_SOD:
+      case OP_SOM:
+      case OP_THEN:
+      case OP_THEN_ARG:
+      return SSB_FAIL;
+
+      /* A "real" property test implies no starting bits, but the fake property
+      PT_CLIST identifies a list of characters. These lists are short, as they
+      are used for characters with more than one "other case", so there is no
+      point in recognizing them for OP_NOTPROP. */
+
+      case OP_PROP:
+      if (tcode[1] != PT_CLIST) return SSB_FAIL;
+        {
+        const pcre_uint32 *p = PRIV(ucd_caseless_sets) + tcode[2];
+        while ((c = *p++) < NOTACHAR)
+          {
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+          if (utf)
+            {
+            pcre_uchar buff[6];
+            (void)PRIV(ord2utf)(c, buff);
+            c = buff[0];
+            }
+#endif
+          if (c > 0xff) SET_BIT(0xff); else SET_BIT(c);
+          }
+        }
+      try_next = FALSE;
+      break;
+
+      /* We can ignore word boundary tests. */
+
+      case OP_WORD_BOUNDARY:
+      case OP_NOT_WORD_BOUNDARY:
+      tcode++;
+      break;
+
+      /* If we hit a bracket or a positive lookahead assertion, recurse to set
+      bits from within the subpattern. If it can't find anything, we have to
+      give up. If it finds some mandatory character(s), we are done for this
+      branch. Otherwise, carry on scanning after the subpattern. */
+
+      case OP_BRA:
+      case OP_SBRA:
+      case OP_CBRA:
+      case OP_SCBRA:
+      case OP_BRAPOS:
+      case OP_SBRAPOS:
+      case OP_CBRAPOS:
+      case OP_SCBRAPOS:
+      case OP_ONCE:
+      case OP_ONCE_NC:
+      case OP_ASSERT:
+      rc = set_start_bits(tcode, start_bits, utf, cd);
+      if (rc == SSB_FAIL || rc == SSB_UNKNOWN) return rc;
+      if (rc == SSB_DONE) try_next = FALSE; else
+        {
+        do tcode += GET(tcode, 1); while (*tcode == OP_ALT);
+        tcode += 1 + LINK_SIZE;
+        }
+      break;
+
+      /* If we hit ALT or KET, it means we haven't found anything mandatory in
+      this branch, though we might have found something optional. For ALT, we
+      continue with the next alternative, but we have to arrange that the final
+      result from subpattern is SSB_CONTINUE rather than SSB_DONE. For KET,
+      return SSB_CONTINUE: if this is the top level, that indicates failure,
+      but after a nested subpattern, it causes scanning to continue. */
+
+      case OP_ALT:
+      yield = SSB_CONTINUE;
+      try_next = FALSE;
+      break;
+
+      case OP_KET:
+      case OP_KETRMAX:
+      case OP_KETRMIN:
+      case OP_KETRPOS:
+      return SSB_CONTINUE;
+
+      /* Skip over callout */
+
+      case OP_CALLOUT:
+      tcode += 2 + 2*LINK_SIZE;
+      break;
+
+      /* Skip over lookbehind and negative lookahead assertions */
+
+      case OP_ASSERT_NOT:
+      case OP_ASSERTBACK:
+      case OP_ASSERTBACK_NOT:
+      do tcode += GET(tcode, 1); while (*tcode == OP_ALT);
+      tcode += 1 + LINK_SIZE;
+      break;
+
+      /* BRAZERO does the bracket, but carries on. */
+
+      case OP_BRAZERO:
+      case OP_BRAMINZERO:
+      case OP_BRAPOSZERO:
+      rc = set_start_bits(++tcode, start_bits, utf, cd);
+      if (rc == SSB_FAIL || rc == SSB_UNKNOWN) return rc;
+/* =========================================================================
+      See the comment at the head of this function concerning the next line,
+      which was an old fudge for the benefit of OS/2.
+      dummy = 1;
+  ========================================================================= */
+      do tcode += GET(tcode,1); while (*tcode == OP_ALT);
+      tcode += 1 + LINK_SIZE;
+      break;
+
+      /* SKIPZERO skips the bracket. */
+
+      case OP_SKIPZERO:
+      tcode++;
+      do tcode += GET(tcode,1); while (*tcode == OP_ALT);
+      tcode += 1 + LINK_SIZE;
+      break;
+
+      /* Single-char * or ? sets the bit and tries the next item */
+
+      case OP_STAR:
+      case OP_MINSTAR:
+      case OP_POSSTAR:
+      case OP_QUERY:
+      case OP_MINQUERY:
+      case OP_POSQUERY:
+      tcode = set_table_bit(start_bits, tcode + 1, FALSE, cd, utf);
+      break;
+
+      case OP_STARI:
+      case OP_MINSTARI:
+      case OP_POSSTARI:
+      case OP_QUERYI:
+      case OP_MINQUERYI:
+      case OP_POSQUERYI:
+      tcode = set_table_bit(start_bits, tcode + 1, TRUE, cd, utf);
+      break;
+
+      /* Single-char upto sets the bit and tries the next */
+
+      case OP_UPTO:
+      case OP_MINUPTO:
+      case OP_POSUPTO:
+      tcode = set_table_bit(start_bits, tcode + 1 + IMM2_SIZE, FALSE, cd, utf);
+      break;
+
+      case OP_UPTOI:
+      case OP_MINUPTOI:
+      case OP_POSUPTOI:
+      tcode = set_table_bit(start_bits, tcode + 1 + IMM2_SIZE, TRUE, cd, utf);
+      break;
+
+      /* At least one single char sets the bit and stops */
+
+      case OP_EXACT:
+      tcode += IMM2_SIZE;
+      /* Fall through */
+      case OP_CHAR:
+      case OP_PLUS:
+      case OP_MINPLUS:
+      case OP_POSPLUS:
+      (void)set_table_bit(start_bits, tcode + 1, FALSE, cd, utf);
+      try_next = FALSE;
+      break;
+
+      case OP_EXACTI:
+      tcode += IMM2_SIZE;
+      /* Fall through */
+      case OP_CHARI:
+      case OP_PLUSI:
+      case OP_MINPLUSI:
+      case OP_POSPLUSI:
+      (void)set_table_bit(start_bits, tcode + 1, TRUE, cd, utf);
+      try_next = FALSE;
+      break;
+
+      /* Special spacing and line-terminating items. These recognize specific
+      lists of characters. The difference between VSPACE and ANYNL is that the
+      latter can match the two-character CRLF sequence, but that is not
+      relevant for finding the first character, so their code here is
+      identical. */
+
+      case OP_HSPACE:
+      SET_BIT(CHAR_HT);
+      SET_BIT(CHAR_SPACE);
+#ifdef SUPPORT_UTF
+      if (utf)
+        {
+#ifdef COMPILE_PCRE8
+        SET_BIT(0xC2);  /* For U+00A0 */
+        SET_BIT(0xE1);  /* For U+1680, U+180E */
+        SET_BIT(0xE2);  /* For U+2000 - U+200A, U+202F, U+205F */
+        SET_BIT(0xE3);  /* For U+3000 */
+#elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+        SET_BIT(0xA0);
+        SET_BIT(0xFF);  /* For characters > 255 */
+#endif  /* COMPILE_PCRE[8|16|32] */
+        }
+      else
+#endif /* SUPPORT_UTF */
+        {
+#ifndef EBCDIC
+        SET_BIT(0xA0);
+#endif  /* Not EBCDIC */
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+        SET_BIT(0xFF);  /* For characters > 255 */
+#endif  /* COMPILE_PCRE[16|32] */
+        }
+      try_next = FALSE;
+      break;
+
+      case OP_ANYNL:
+      case OP_VSPACE:
+      SET_BIT(CHAR_LF);
+      SET_BIT(CHAR_VT);
+      SET_BIT(CHAR_FF);
+      SET_BIT(CHAR_CR);
+#ifdef SUPPORT_UTF
+      if (utf)
+        {
+#ifdef COMPILE_PCRE8
+        SET_BIT(0xC2);  /* For U+0085 */
+        SET_BIT(0xE2);  /* For U+2028, U+2029 */
+#elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+        SET_BIT(CHAR_NEL);
+        SET_BIT(0xFF);  /* For characters > 255 */
+#endif  /* COMPILE_PCRE[8|16|32] */
+        }
+      else
+#endif /* SUPPORT_UTF */
+        {
+        SET_BIT(CHAR_NEL);
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+        SET_BIT(0xFF);  /* For characters > 255 */
+#endif
+        }
+      try_next = FALSE;
+      break;
+
+      /* Single character types set the bits and stop. Note that if PCRE_UCP
+      is set, we do not see these op codes because \d etc are converted to
+      properties. Therefore, these apply in the case when only characters less
+      than 256 are recognized to match the types. */
+
+      case OP_NOT_DIGIT:
+      set_nottype_bits(start_bits, cbit_digit, table_limit, cd);
+      try_next = FALSE;
+      break;
+
+      case OP_DIGIT:
+      set_type_bits(start_bits, cbit_digit, table_limit, cd);
+      try_next = FALSE;
+      break;
+
+      /* The cbit_space table has vertical tab as whitespace; we no longer
+      have to play fancy tricks because Perl added VT to its whitespace at
+      release 5.18. PCRE added it at release 8.34. */
+
+      case OP_NOT_WHITESPACE:
+      set_nottype_bits(start_bits, cbit_space, table_limit, cd);
+      try_next = FALSE;
+      break;
+
+      case OP_WHITESPACE:
+      set_type_bits(start_bits, cbit_space, table_limit, cd);
+      try_next = FALSE;
+      break;
+
+      case OP_NOT_WORDCHAR:
+      set_nottype_bits(start_bits, cbit_word, table_limit, cd);
+      try_next = FALSE;
+      break;
+
+      case OP_WORDCHAR:
+      set_type_bits(start_bits, cbit_word, table_limit, cd);
+      try_next = FALSE;
+      break;
+
+      /* One or more character type fudges the pointer and restarts, knowing
+      it will hit a single character type and stop there. */
+
+      case OP_TYPEPLUS:
+      case OP_TYPEMINPLUS:
+      case OP_TYPEPOSPLUS:
+      tcode++;
+      break;
+
+      case OP_TYPEEXACT:
+      tcode += 1 + IMM2_SIZE;
+      break;
+
+      /* Zero or more repeats of character types set the bits and then
+      try again. */
+
+      case OP_TYPEUPTO:
+      case OP_TYPEMINUPTO:
+      case OP_TYPEPOSUPTO:
+      tcode += IMM2_SIZE;  /* Fall through */
+
+      case OP_TYPESTAR:
+      case OP_TYPEMINSTAR:
+      case OP_TYPEPOSSTAR:
+      case OP_TYPEQUERY:
+      case OP_TYPEMINQUERY:
+      case OP_TYPEPOSQUERY:
+      switch(tcode[1])
+        {
+        default:
+        case OP_ANY:
+        case OP_ALLANY:
+        return SSB_FAIL;
+
+        case OP_HSPACE:
+        SET_BIT(CHAR_HT);
+        SET_BIT(CHAR_SPACE);
+#ifdef SUPPORT_UTF
+        if (utf)
+          {
+#ifdef COMPILE_PCRE8
+          SET_BIT(0xC2);  /* For U+00A0 */
+          SET_BIT(0xE1);  /* For U+1680, U+180E */
+          SET_BIT(0xE2);  /* For U+2000 - U+200A, U+202F, U+205F */
+          SET_BIT(0xE3);  /* For U+3000 */
+#elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+          SET_BIT(0xA0);
+          SET_BIT(0xFF);  /* For characters > 255 */
+#endif  /* COMPILE_PCRE[8|16|32] */
+          }
+        else
+#endif /* SUPPORT_UTF */
+#ifndef EBCDIC
+          SET_BIT(0xA0);
+#endif  /* Not EBCDIC */
+        break;
+
+        case OP_ANYNL:
+        case OP_VSPACE:
+        SET_BIT(CHAR_LF);
+        SET_BIT(CHAR_VT);
+        SET_BIT(CHAR_FF);
+        SET_BIT(CHAR_CR);
+#ifdef SUPPORT_UTF
+        if (utf)
+          {
+#ifdef COMPILE_PCRE8
+          SET_BIT(0xC2);  /* For U+0085 */
+          SET_BIT(0xE2);  /* For U+2028, U+2029 */
+#elif defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+          SET_BIT(CHAR_NEL);
+          SET_BIT(0xFF);  /* For characters > 255 */
+#endif  /* COMPILE_PCRE16 */
+          }
+        else
+#endif /* SUPPORT_UTF */
+          SET_BIT(CHAR_NEL);
+        break;
+
+        case OP_NOT_DIGIT:
+        set_nottype_bits(start_bits, cbit_digit, table_limit, cd);
+        break;
+
+        case OP_DIGIT:
+        set_type_bits(start_bits, cbit_digit, table_limit, cd);
+        break;
+
+        /* The cbit_space table has vertical tab as whitespace; we no longer
+        have to play fancy tricks because Perl added VT to its whitespace at
+        release 5.18. PCRE added it at release 8.34. */
+
+        case OP_NOT_WHITESPACE:
+        set_nottype_bits(start_bits, cbit_space, table_limit, cd);
+        break;
+
+        case OP_WHITESPACE:
+        set_type_bits(start_bits, cbit_space, table_limit, cd);
+        break;
+
+        case OP_NOT_WORDCHAR:
+        set_nottype_bits(start_bits, cbit_word, table_limit, cd);
+        break;
+
+        case OP_WORDCHAR:
+        set_type_bits(start_bits, cbit_word, table_limit, cd);
+        break;
+        }
+
+      tcode += 2;
+      break;
+
+      /* Character class where all the information is in a bit map: set the
+      bits and either carry on or not, according to the repeat count. If it was
+      a negative class, and we are operating with UTF-8 characters, any byte
+      with a value >= 0xc4 is a potentially valid starter because it starts a
+      character with a value > 255. */
+
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+      case OP_XCLASS:
+      if ((tcode[1 + LINK_SIZE] & XCL_HASPROP) != 0)
+        return SSB_FAIL;
+      /* All bits are set. */
+      if ((tcode[1 + LINK_SIZE] & XCL_MAP) == 0 && (tcode[1 + LINK_SIZE] & XCL_NOT) != 0)
+        return SSB_FAIL;
+#endif
+      /* Fall through */
+
+      case OP_NCLASS:
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+      if (utf)
+        {
+        start_bits[24] |= 0xf0;              /* Bits for 0xc4 - 0xc8 */
+        memset(start_bits+25, 0xff, 7);      /* Bits for 0xc9 - 0xff */
+        }
+#endif
+#if defined COMPILE_PCRE16 || defined COMPILE_PCRE32
+      SET_BIT(0xFF);                         /* For characters > 255 */
+#endif
+      /* Fall through */
+
+      case OP_CLASS:
+        {
+        pcre_uint8 *map;
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+        map = NULL;
+        if (*tcode == OP_XCLASS)
+          {
+          if ((tcode[1 + LINK_SIZE] & XCL_MAP) != 0)
+            map = (pcre_uint8 *)(tcode + 1 + LINK_SIZE + 1);
+          tcode += GET(tcode, 1);
+          }
+        else
+#endif
+          {
+          tcode++;
+          map = (pcre_uint8 *)tcode;
+          tcode += 32 / sizeof(pcre_uchar);
+          }
+
+        /* In UTF-8 mode, the bits in a bit map correspond to character
+        values, not to byte values. However, the bit map we are constructing is
+        for byte values. So we have to do a conversion for characters whose
+        value is > 127. In fact, there are only two possible starting bytes for
+        characters in the range 128 - 255. */
+
+#if defined SUPPORT_UTF || !defined COMPILE_PCRE8
+        if (map != NULL)
+#endif
+          {
+#if defined SUPPORT_UTF && defined COMPILE_PCRE8
+          if (utf)
+            {
+            for (c = 0; c < 16; c++) start_bits[c] |= map[c];
+            for (c = 128; c < 256; c++)
+              {
+              if ((map[c/8] & (1 << (c&7))) != 0)
+                {
+                int d = (c >> 6) | 0xc0;            /* Set bit for this starter */
+                start_bits[d/8] |= (1 << (d&7));    /* and then skip on to the */
+                c = (c & 0xc0) + 0x40 - 1;          /* next relevant character. */
+                }
+              }
+            }
+          else
+#endif
+            {
+            /* In non-UTF-8 mode, the two bit maps are completely compatible. */
+            for (c = 0; c < 32; c++) start_bits[c] |= map[c];
+            }
+          }
+
+        /* Advance past the bit map, and act on what follows. For a zero
+        minimum repeat, continue; otherwise stop processing. */
+
+        switch (*tcode)
+          {
+          case OP_CRSTAR:
+          case OP_CRMINSTAR:
+          case OP_CRQUERY:
+          case OP_CRMINQUERY:
+          case OP_CRPOSSTAR:
+          case OP_CRPOSQUERY:
+          tcode++;
+          break;
+
+          case OP_CRRANGE:
+          case OP_CRMINRANGE:
+          case OP_CRPOSRANGE:
+          if (GET2(tcode, 1) == 0) tcode += 1 + 2 * IMM2_SIZE;
+            else try_next = FALSE;
+          break;
+
+          default:
+          try_next = FALSE;
+          break;
+          }
+        }
+      break; /* End of bitmap class handling */
+
+      }      /* End of switch */
+    }        /* End of try_next loop */
+
+  code += GET(code, 1);   /* Advance to next branch */
+  }
+while (*code == OP_ALT);
+return yield;
+}
+
+
+
+
+
+/*************************************************
+*          Study a compiled expression           *
+*************************************************/
+
+/* This function is handed a compiled expression that it must study to produce
+information that will speed up the matching. It returns a pcre[16]_extra block
+which then gets handed back to pcre_exec().
+
+Arguments:
+  re        points to the compiled expression
+  options   contains option bits
+  errorptr  points to where to place error messages;
+            set NULL unless error
+
+Returns:    pointer to a pcre[16]_extra block, with study_data filled in and
+              the appropriate flags set;
+            NULL on error or if no optimization possible
+*/
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN pcre_extra * PCRE_CALL_CONVENTION
+pcre_study(const pcre *external_re, int options, const char **errorptr)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN pcre16_extra * PCRE_CALL_CONVENTION
+pcre16_study(const pcre16 *external_re, int options, const char **errorptr)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN pcre32_extra * PCRE_CALL_CONVENTION
+pcre32_study(const pcre32 *external_re, int options, const char **errorptr)
+#endif
+{
+int min;
+int count = 0;
+BOOL bits_set = FALSE;
+pcre_uint8 start_bits[32];
+PUBL(extra) *extra = NULL;
+pcre_study_data *study;
+const pcre_uint8 *tables;
+pcre_uchar *code;
+compile_data compile_block;
+const REAL_PCRE *re = (const REAL_PCRE *)external_re;
+
+
+*errorptr = NULL;
+
+if (re == NULL || re->magic_number != MAGIC_NUMBER)
+  {
+  *errorptr = "argument is not a compiled regular expression";
+  return NULL;
+  }
+
+if ((re->flags & PCRE_MODE) == 0)
+  {
+#if defined COMPILE_PCRE8
+  *errorptr = "argument not compiled in 8 bit mode";
+#elif defined COMPILE_PCRE16
+  *errorptr = "argument not compiled in 16 bit mode";
+#elif defined COMPILE_PCRE32
+  *errorptr = "argument not compiled in 32 bit mode";
+#endif
+  return NULL;
+  }
+
+if ((options & ~PUBLIC_STUDY_OPTIONS) != 0)
+  {
+  *errorptr = "unknown or incorrect option bit(s) set";
+  return NULL;
+  }
+
+code = (pcre_uchar *)re + re->name_table_offset +
+  (re->name_count * re->name_entry_size);
+
+/* For an anchored pattern, or an unanchored pattern that has a first char, or
+a multiline pattern that matches only at "line starts", there is no point in
+seeking a list of starting bytes. */
+
+if ((re->options & PCRE_ANCHORED) == 0 &&
+    (re->flags & (PCRE_FIRSTSET|PCRE_STARTLINE)) == 0)
+  {
+  int rc;
+
+  /* Set the character tables in the block that is passed around */
+
+  tables = re->tables;
+
+#if defined COMPILE_PCRE8
+  if (tables == NULL)
+    (void)pcre_fullinfo(external_re, NULL, PCRE_INFO_DEFAULT_TABLES,
+    (void *)(&tables));
+#elif defined COMPILE_PCRE16
+  if (tables == NULL)
+    (void)pcre16_fullinfo(external_re, NULL, PCRE_INFO_DEFAULT_TABLES,
+    (void *)(&tables));
+#elif defined COMPILE_PCRE32
+  if (tables == NULL)
+    (void)pcre32_fullinfo(external_re, NULL, PCRE_INFO_DEFAULT_TABLES,
+    (void *)(&tables));
+#endif
+
+  compile_block.lcc = tables + lcc_offset;
+  compile_block.fcc = tables + fcc_offset;
+  compile_block.cbits = tables + cbits_offset;
+  compile_block.ctypes = tables + ctypes_offset;
+
+  /* See if we can find a fixed set of initial characters for the pattern. */
+
+  memset(start_bits, 0, 32 * sizeof(pcre_uint8));
+  rc = set_start_bits(code, start_bits, (re->options & PCRE_UTF8) != 0,
+    &compile_block);
+  bits_set = rc == SSB_DONE;
+  if (rc == SSB_UNKNOWN)
+    {
+    *errorptr = "internal error: opcode not recognized";
+    return NULL;
+    }
+  }
+
+/* Find the minimum length of subject string. */
+
+switch(min = find_minlength(re, code, code, re->options, NULL, &count))
+  {
+  case -2: *errorptr = "internal error: missing capturing bracket"; return NULL;
+  case -3: *errorptr = "internal error: opcode not recognized"; return NULL;
+  default: break;
+  }
+
+/* If a set of starting bytes has been identified, or if the minimum length is
+greater than zero, or if JIT optimization has been requested, or if
+PCRE_STUDY_EXTRA_NEEDED is set, get a pcre[16]_extra block and a
+pcre_study_data block. The study data is put in the latter, which is pointed to
+by the former, which may also get additional data set later by the calling
+program. At the moment, the size of pcre_study_data is fixed. We nevertheless
+save it in a field for returning via the pcre_fullinfo() function so that if it
+becomes variable in the future, we don't have to change that code. */
+
+if (bits_set || min > 0 || (options & (
+#ifdef SUPPORT_JIT
+    PCRE_STUDY_JIT_COMPILE | PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE |
+    PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE |
+#endif
+    PCRE_STUDY_EXTRA_NEEDED)) != 0)
+  {
+  extra = (PUBL(extra) *)(PUBL(malloc))
+    (sizeof(PUBL(extra)) + sizeof(pcre_study_data));
+  if (extra == NULL)
+    {
+    *errorptr = "failed to get memory";
+    return NULL;
+    }
+
+  study = (pcre_study_data *)((char *)extra + sizeof(PUBL(extra)));
+  extra->flags = PCRE_EXTRA_STUDY_DATA;
+  extra->study_data = study;
+
+  study->size = sizeof(pcre_study_data);
+  study->flags = 0;
+
+  /* Set the start bits always, to avoid unset memory errors if the
+  study data is written to a file, but set the flag only if any of the bits
+  are set, to save time looking when none are. */
+
+  if (bits_set)
+    {
+    study->flags |= PCRE_STUDY_MAPPED;
+    memcpy(study->start_bits, start_bits, sizeof(start_bits));
+    }
+  else memset(study->start_bits, 0, 32 * sizeof(pcre_uint8));
+
+#ifdef PCRE_DEBUG
+  if (bits_set)
+    {
+    pcre_uint8 *ptr = start_bits;
+    int i;
+
+    printf("Start bits:\n");
+    for (i = 0; i < 32; i++)
+      printf("%3d: %02x%s", i * 8, *ptr++, ((i + 1) & 0x7) != 0? " " : "\n");
+    }
+#endif
+
+  /* Always set the minlength value in the block, because the JIT compiler
+  makes use of it. However, don't set the bit unless the length is greater than
+  zero - the interpretive pcre_exec() and pcre_dfa_exec() needn't waste time
+  checking the zero case. */
+
+  if (min > 0)
+    {
+    study->flags |= PCRE_STUDY_MINLEN;
+    study->minlength = min;
+    }
+  else study->minlength = 0;
+
+  /* If JIT support was compiled and requested, attempt the JIT compilation.
+  If no starting bytes were found, and the minimum length is zero, and JIT
+  compilation fails, abandon the extra block and return NULL, unless
+  PCRE_STUDY_EXTRA_NEEDED is set. */
+
+#ifdef SUPPORT_JIT
+  extra->executable_jit = NULL;
+  if ((options & PCRE_STUDY_JIT_COMPILE) != 0)
+    PRIV(jit_compile)(re, extra, JIT_COMPILE);
+  if ((options & PCRE_STUDY_JIT_PARTIAL_SOFT_COMPILE) != 0)
+    PRIV(jit_compile)(re, extra, JIT_PARTIAL_SOFT_COMPILE);
+  if ((options & PCRE_STUDY_JIT_PARTIAL_HARD_COMPILE) != 0)
+    PRIV(jit_compile)(re, extra, JIT_PARTIAL_HARD_COMPILE);
+
+  if (study->flags == 0 && (extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) == 0 &&
+      (options & PCRE_STUDY_EXTRA_NEEDED) == 0)
+    {
+#if defined COMPILE_PCRE8
+    pcre_free_study(extra);
+#elif defined COMPILE_PCRE16
+    pcre16_free_study(extra);
+#elif defined COMPILE_PCRE32
+    pcre32_free_study(extra);
+#endif
+    extra = NULL;
+    }
+#endif
+  }
+
+return extra;
+}
+
+
+/*************************************************
+*          Free the study data                   *
+*************************************************/
+
+/* This function frees the memory that was obtained by pcre_study().
+
+Argument:   a pointer to the pcre[16]_extra block
+Returns:    nothing
+*/
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN void
+pcre_free_study(pcre_extra *extra)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN void
+pcre16_free_study(pcre16_extra *extra)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN void
+pcre32_free_study(pcre32_extra *extra)
+#endif
+{
+if (extra == NULL)
+  return;
+#ifdef SUPPORT_JIT
+if ((extra->flags & PCRE_EXTRA_EXECUTABLE_JIT) != 0 &&
+     extra->executable_jit != NULL)
+  PRIV(jit_free)(extra->executable_jit);
+#endif
+PUBL(free)(extra);
+}
+
+/* End of pcre_study.c */
diff --git a/base/poco/Foundation/src/pcre_tables.c b/base/poco/Foundation/src/pcre_tables.c
new file mode 100644
index 00000000000..43663a68991
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_tables.c
@@ -0,0 +1,723 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2017 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+#ifndef PCRE_INCLUDED
+
+/* This module contains some fixed tables that are used by more than one of the
+PCRE code modules. The tables are also #included by the pcretest program, which
+uses macros to change their names from _pcre_xxx to xxxx, thereby avoiding name
+clashes with the library. */
+
+#include "pcre_config.h"
+#include "pcre_internal.h"
+
+#endif /* PCRE_INCLUDED */
+
+/* Table of sizes for the fixed-length opcodes. It's defined in a macro so that
+the definition is next to the definition of the opcodes in pcre_internal.h. */
+
+const pcre_uint8 PRIV(OP_lengths)[] = { OP_LENGTHS };
+
+/* Tables of horizontal and vertical whitespace characters, suitable for
+adding to classes. */
+
+const pcre_uint32 PRIV(hspace_list)[] = { HSPACE_LIST };
+const pcre_uint32 PRIV(vspace_list)[] = { VSPACE_LIST };
+
+
+
+/*************************************************
+*           Tables for UTF-8 support             *
+*************************************************/
+
+/* These are the breakpoints for different numbers of bytes in a UTF-8
+character. */
+
+#if (defined SUPPORT_UTF && defined COMPILE_PCRE8) \
+  || (defined PCRE_INCLUDED && (defined SUPPORT_PCRE16 || defined SUPPORT_PCRE32))
+
+/* These tables are also required by pcretest in 16- or 32-bit mode. */
+
+const int PRIV(utf8_table1)[] =
+  { 0x7f, 0x7ff, 0xffff, 0x1fffff, 0x3ffffff, 0x7fffffff};
+
+const int PRIV(utf8_table1_size) = sizeof(PRIV(utf8_table1)) / sizeof(int);
+
+/* These are the indicator bits and the mask for the data bits to set in the
+first byte of a character, indexed by the number of additional bytes. */
+
+const int PRIV(utf8_table2)[] = { 0,    0xc0, 0xe0, 0xf0, 0xf8, 0xfc};
+const int PRIV(utf8_table3)[] = { 0xff, 0x1f, 0x0f, 0x07, 0x03, 0x01};
+
+/* Table of the number of extra bytes, indexed by the first byte masked with
+0x3f. The highest number for a valid UTF-8 first byte is in fact 0x3d. */
+
+const pcre_uint8 PRIV(utf8_table4)[] = {
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+  3,3,3,3,3,3,3,3,4,4,4,4,5,5,5,5 };
+
+#endif /* (SUPPORT_UTF && COMPILE_PCRE8) || (PCRE_INCLUDED && SUPPORT_PCRE[16|32])*/
+
+#ifdef SUPPORT_UTF
+
+/* Table to translate from particular type value to the general value. */
+
+const pcre_uint32 PRIV(ucp_gentype)[] = {
+  ucp_C, ucp_C, ucp_C, ucp_C, ucp_C,  /* Cc, Cf, Cn, Co, Cs */
+  ucp_L, ucp_L, ucp_L, ucp_L, ucp_L,  /* Ll, Lu, Lm, Lo, Lt */
+  ucp_M, ucp_M, ucp_M,                /* Mc, Me, Mn */
+  ucp_N, ucp_N, ucp_N,                /* Nd, Nl, No */
+  ucp_P, ucp_P, ucp_P, ucp_P, ucp_P,  /* Pc, Pd, Pe, Pf, Pi */
+  ucp_P, ucp_P,                       /* Ps, Po */
+  ucp_S, ucp_S, ucp_S, ucp_S,         /* Sc, Sk, Sm, So */
+  ucp_Z, ucp_Z, ucp_Z                 /* Zl, Zp, Zs */
+};
+
+/* This table encodes the rules for finding the end of an extended grapheme
+cluster. Every code point has a grapheme break property which is one of the
+ucp_gbXX values defined in ucp.h. The 2-dimensional table is indexed by the
+properties of two adjacent code points. The left property selects a word from
+the table, and the right property selects a bit from that word like this:
+
+  ucp_gbtable[left-property] & (1 << right-property)
+
+The value is non-zero if a grapheme break is NOT permitted between the relevant
+two code points. The breaking rules are as follows:
+
+1. Break at the start and end of text (pretty obviously).
+
+2. Do not break between a CR and LF; otherwise, break before and   after
+   controls.
+
+3. Do not break Hangul syllable sequences, the rules for which are:
+
+    L may be followed by L, V, LV or LVT
+    LV or V may be followed by V or T
+    LVT or T may be followed by T
+
+4. Do not break before extending characters.
+
+The next two rules are only for extended grapheme clusters (but that's what we
+are implementing).
+
+5. Do not break before SpacingMarks.
+
+6. Do not break after Prepend characters.
+
+7. Otherwise, break everywhere.
+*/
+
+const pcre_uint32 PRIV(ucp_gbtable[]) = {
+   (1<<ucp_gbLF),                                           /*  0 CR */
+   0,                                                       /*  1 LF */
+   0,                                                       /*  2 Control */
+   (1<<ucp_gbExtend)|(1<<ucp_gbSpacingMark),                /*  3 Extend */
+   (1<<ucp_gbExtend)|(1<<ucp_gbPrepend)|                    /*  4 Prepend */
+     (1<<ucp_gbSpacingMark)|(1<<ucp_gbL)|
+     (1<<ucp_gbV)|(1<<ucp_gbT)|(1<<ucp_gbLV)|
+     (1<<ucp_gbLVT)|(1<<ucp_gbOther),
+
+   (1<<ucp_gbExtend)|(1<<ucp_gbSpacingMark),                /*  5 SpacingMark */
+   (1<<ucp_gbExtend)|(1<<ucp_gbSpacingMark)|(1<<ucp_gbL)|   /*  6 L */
+     (1<<ucp_gbV)|(1<<ucp_gbLV)|(1<<ucp_gbLVT),
+
+   (1<<ucp_gbExtend)|(1<<ucp_gbSpacingMark)|(1<<ucp_gbV)|   /*  7 V */
+     (1<<ucp_gbT),
+
+   (1<<ucp_gbExtend)|(1<<ucp_gbSpacingMark)|(1<<ucp_gbT),   /*  8 T */
+   (1<<ucp_gbExtend)|(1<<ucp_gbSpacingMark)|(1<<ucp_gbV)|   /*  9 LV */
+     (1<<ucp_gbT),
+
+   (1<<ucp_gbExtend)|(1<<ucp_gbSpacingMark)|(1<<ucp_gbT),   /* 10 LVT */
+   (1<<ucp_gbRegionalIndicator),                            /* 11 RegionalIndicator */
+   (1<<ucp_gbExtend)|(1<<ucp_gbSpacingMark)                 /* 12 Other */
+};
+
+#ifdef SUPPORT_JIT
+/* This table reverses PRIV(ucp_gentype). We can save the cost
+of a memory load. */
+
+const int PRIV(ucp_typerange)[] = {
+  ucp_Cc, ucp_Cs,
+  ucp_Ll, ucp_Lu,
+  ucp_Mc, ucp_Mn,
+  ucp_Nd, ucp_No,
+  ucp_Pc, ucp_Ps,
+  ucp_Sc, ucp_So,
+  ucp_Zl, ucp_Zs,
+};
+#endif /* SUPPORT_JIT */
+
+/* The pcre_utt[] table below translates Unicode property names into type and
+code values. It is searched by binary chop, so must be in collating sequence of
+name. Originally, the table contained pointers to the name strings in the first
+field of each entry. However, that leads to a large number of relocations when
+a shared library is dynamically loaded. A significant reduction is made by
+putting all the names into a single, large string and then using offsets in the
+table itself. Maintenance is more error-prone, but frequent changes to this
+data are unlikely.
+
+July 2008: There is now a script called maint/GenerateUtt.py that can be used
+to generate this data automatically instead of maintaining it by hand.
+
+The script was updated in March 2009 to generate a new EBCDIC-compliant
+version. Like all other character and string literals that are compared against
+the regular expression pattern, we must use STR_ macros instead of literal
+strings to make sure that UTF-8 support works on EBCDIC platforms. */
+
+#define STRING_Any0 STR_A STR_n STR_y "\0"
+#define STRING_Arabic0 STR_A STR_r STR_a STR_b STR_i STR_c "\0"
+#define STRING_Armenian0 STR_A STR_r STR_m STR_e STR_n STR_i STR_a STR_n "\0"
+#define STRING_Avestan0 STR_A STR_v STR_e STR_s STR_t STR_a STR_n "\0"
+#define STRING_Balinese0 STR_B STR_a STR_l STR_i STR_n STR_e STR_s STR_e "\0"
+#define STRING_Bamum0 STR_B STR_a STR_m STR_u STR_m "\0"
+#define STRING_Bassa_Vah0 STR_B STR_a STR_s STR_s STR_a STR_UNDERSCORE STR_V STR_a STR_h "\0"
+#define STRING_Batak0 STR_B STR_a STR_t STR_a STR_k "\0"
+#define STRING_Bengali0 STR_B STR_e STR_n STR_g STR_a STR_l STR_i "\0"
+#define STRING_Bopomofo0 STR_B STR_o STR_p STR_o STR_m STR_o STR_f STR_o "\0"
+#define STRING_Brahmi0 STR_B STR_r STR_a STR_h STR_m STR_i "\0"
+#define STRING_Braille0 STR_B STR_r STR_a STR_i STR_l STR_l STR_e "\0"
+#define STRING_Buginese0 STR_B STR_u STR_g STR_i STR_n STR_e STR_s STR_e "\0"
+#define STRING_Buhid0 STR_B STR_u STR_h STR_i STR_d "\0"
+#define STRING_C0 STR_C "\0"
+#define STRING_Canadian_Aboriginal0 STR_C STR_a STR_n STR_a STR_d STR_i STR_a STR_n STR_UNDERSCORE STR_A STR_b STR_o STR_r STR_i STR_g STR_i STR_n STR_a STR_l "\0"
+#define STRING_Carian0 STR_C STR_a STR_r STR_i STR_a STR_n "\0"
+#define STRING_Caucasian_Albanian0 STR_C STR_a STR_u STR_c STR_a STR_s STR_i STR_a STR_n STR_UNDERSCORE STR_A STR_l STR_b STR_a STR_n STR_i STR_a STR_n "\0"
+#define STRING_Cc0 STR_C STR_c "\0"
+#define STRING_Cf0 STR_C STR_f "\0"
+#define STRING_Chakma0 STR_C STR_h STR_a STR_k STR_m STR_a "\0"
+#define STRING_Cham0 STR_C STR_h STR_a STR_m "\0"
+#define STRING_Cherokee0 STR_C STR_h STR_e STR_r STR_o STR_k STR_e STR_e "\0"
+#define STRING_Cn0 STR_C STR_n "\0"
+#define STRING_Co0 STR_C STR_o "\0"
+#define STRING_Common0 STR_C STR_o STR_m STR_m STR_o STR_n "\0"
+#define STRING_Coptic0 STR_C STR_o STR_p STR_t STR_i STR_c "\0"
+#define STRING_Cs0 STR_C STR_s "\0"
+#define STRING_Cuneiform0 STR_C STR_u STR_n STR_e STR_i STR_f STR_o STR_r STR_m "\0"
+#define STRING_Cypriot0 STR_C STR_y STR_p STR_r STR_i STR_o STR_t "\0"
+#define STRING_Cyrillic0 STR_C STR_y STR_r STR_i STR_l STR_l STR_i STR_c "\0"
+#define STRING_Deseret0 STR_D STR_e STR_s STR_e STR_r STR_e STR_t "\0"
+#define STRING_Devanagari0 STR_D STR_e STR_v STR_a STR_n STR_a STR_g STR_a STR_r STR_i "\0"
+#define STRING_Duployan0 STR_D STR_u STR_p STR_l STR_o STR_y STR_a STR_n "\0"
+#define STRING_Egyptian_Hieroglyphs0 STR_E STR_g STR_y STR_p STR_t STR_i STR_a STR_n STR_UNDERSCORE STR_H STR_i STR_e STR_r STR_o STR_g STR_l STR_y STR_p STR_h STR_s "\0"
+#define STRING_Elbasan0 STR_E STR_l STR_b STR_a STR_s STR_a STR_n "\0"
+#define STRING_Ethiopic0 STR_E STR_t STR_h STR_i STR_o STR_p STR_i STR_c "\0"
+#define STRING_Georgian0 STR_G STR_e STR_o STR_r STR_g STR_i STR_a STR_n "\0"
+#define STRING_Glagolitic0 STR_G STR_l STR_a STR_g STR_o STR_l STR_i STR_t STR_i STR_c "\0"
+#define STRING_Gothic0 STR_G STR_o STR_t STR_h STR_i STR_c "\0"
+#define STRING_Grantha0 STR_G STR_r STR_a STR_n STR_t STR_h STR_a "\0"
+#define STRING_Greek0 STR_G STR_r STR_e STR_e STR_k "\0"
+#define STRING_Gujarati0 STR_G STR_u STR_j STR_a STR_r STR_a STR_t STR_i "\0"
+#define STRING_Gurmukhi0 STR_G STR_u STR_r STR_m STR_u STR_k STR_h STR_i "\0"
+#define STRING_Han0 STR_H STR_a STR_n "\0"
+#define STRING_Hangul0 STR_H STR_a STR_n STR_g STR_u STR_l "\0"
+#define STRING_Hanunoo0 STR_H STR_a STR_n STR_u STR_n STR_o STR_o "\0"
+#define STRING_Hebrew0 STR_H STR_e STR_b STR_r STR_e STR_w "\0"
+#define STRING_Hiragana0 STR_H STR_i STR_r STR_a STR_g STR_a STR_n STR_a "\0"
+#define STRING_Imperial_Aramaic0 STR_I STR_m STR_p STR_e STR_r STR_i STR_a STR_l STR_UNDERSCORE STR_A STR_r STR_a STR_m STR_a STR_i STR_c "\0"
+#define STRING_Inherited0 STR_I STR_n STR_h STR_e STR_r STR_i STR_t STR_e STR_d "\0"
+#define STRING_Inscriptional_Pahlavi0 STR_I STR_n STR_s STR_c STR_r STR_i STR_p STR_t STR_i STR_o STR_n STR_a STR_l STR_UNDERSCORE STR_P STR_a STR_h STR_l STR_a STR_v STR_i "\0"
+#define STRING_Inscriptional_Parthian0 STR_I STR_n STR_s STR_c STR_r STR_i STR_p STR_t STR_i STR_o STR_n STR_a STR_l STR_UNDERSCORE STR_P STR_a STR_r STR_t STR_h STR_i STR_a STR_n "\0"
+#define STRING_Javanese0 STR_J STR_a STR_v STR_a STR_n STR_e STR_s STR_e "\0"
+#define STRING_Kaithi0 STR_K STR_a STR_i STR_t STR_h STR_i "\0"
+#define STRING_Kannada0 STR_K STR_a STR_n STR_n STR_a STR_d STR_a "\0"
+#define STRING_Katakana0 STR_K STR_a STR_t STR_a STR_k STR_a STR_n STR_a "\0"
+#define STRING_Kayah_Li0 STR_K STR_a STR_y STR_a STR_h STR_UNDERSCORE STR_L STR_i "\0"
+#define STRING_Kharoshthi0 STR_K STR_h STR_a STR_r STR_o STR_s STR_h STR_t STR_h STR_i "\0"
+#define STRING_Khmer0 STR_K STR_h STR_m STR_e STR_r "\0"
+#define STRING_Khojki0 STR_K STR_h STR_o STR_j STR_k STR_i "\0"
+#define STRING_Khudawadi0 STR_K STR_h STR_u STR_d STR_a STR_w STR_a STR_d STR_i "\0"
+#define STRING_L0 STR_L "\0"
+#define STRING_L_AMPERSAND0 STR_L STR_AMPERSAND "\0"
+#define STRING_Lao0 STR_L STR_a STR_o "\0"
+#define STRING_Latin0 STR_L STR_a STR_t STR_i STR_n "\0"
+#define STRING_Lepcha0 STR_L STR_e STR_p STR_c STR_h STR_a "\0"
+#define STRING_Limbu0 STR_L STR_i STR_m STR_b STR_u "\0"
+#define STRING_Linear_A0 STR_L STR_i STR_n STR_e STR_a STR_r STR_UNDERSCORE STR_A "\0"
+#define STRING_Linear_B0 STR_L STR_i STR_n STR_e STR_a STR_r STR_UNDERSCORE STR_B "\0"
+#define STRING_Lisu0 STR_L STR_i STR_s STR_u "\0"
+#define STRING_Ll0 STR_L STR_l "\0"
+#define STRING_Lm0 STR_L STR_m "\0"
+#define STRING_Lo0 STR_L STR_o "\0"
+#define STRING_Lt0 STR_L STR_t "\0"
+#define STRING_Lu0 STR_L STR_u "\0"
+#define STRING_Lycian0 STR_L STR_y STR_c STR_i STR_a STR_n "\0"
+#define STRING_Lydian0 STR_L STR_y STR_d STR_i STR_a STR_n "\0"
+#define STRING_M0 STR_M "\0"
+#define STRING_Mahajani0 STR_M STR_a STR_h STR_a STR_j STR_a STR_n STR_i "\0"
+#define STRING_Malayalam0 STR_M STR_a STR_l STR_a STR_y STR_a STR_l STR_a STR_m "\0"
+#define STRING_Mandaic0 STR_M STR_a STR_n STR_d STR_a STR_i STR_c "\0"
+#define STRING_Manichaean0 STR_M STR_a STR_n STR_i STR_c STR_h STR_a STR_e STR_a STR_n "\0"
+#define STRING_Mc0 STR_M STR_c "\0"
+#define STRING_Me0 STR_M STR_e "\0"
+#define STRING_Meetei_Mayek0 STR_M STR_e STR_e STR_t STR_e STR_i STR_UNDERSCORE STR_M STR_a STR_y STR_e STR_k "\0"
+#define STRING_Mende_Kikakui0 STR_M STR_e STR_n STR_d STR_e STR_UNDERSCORE STR_K STR_i STR_k STR_a STR_k STR_u STR_i "\0"
+#define STRING_Meroitic_Cursive0 STR_M STR_e STR_r STR_o STR_i STR_t STR_i STR_c STR_UNDERSCORE STR_C STR_u STR_r STR_s STR_i STR_v STR_e "\0"
+#define STRING_Meroitic_Hieroglyphs0 STR_M STR_e STR_r STR_o STR_i STR_t STR_i STR_c STR_UNDERSCORE STR_H STR_i STR_e STR_r STR_o STR_g STR_l STR_y STR_p STR_h STR_s "\0"
+#define STRING_Miao0 STR_M STR_i STR_a STR_o "\0"
+#define STRING_Mn0 STR_M STR_n "\0"
+#define STRING_Modi0 STR_M STR_o STR_d STR_i "\0"
+#define STRING_Mongolian0 STR_M STR_o STR_n STR_g STR_o STR_l STR_i STR_a STR_n "\0"
+#define STRING_Mro0 STR_M STR_r STR_o "\0"
+#define STRING_Myanmar0 STR_M STR_y STR_a STR_n STR_m STR_a STR_r "\0"
+#define STRING_N0 STR_N "\0"
+#define STRING_Nabataean0 STR_N STR_a STR_b STR_a STR_t STR_a STR_e STR_a STR_n "\0"
+#define STRING_Nd0 STR_N STR_d "\0"
+#define STRING_New_Tai_Lue0 STR_N STR_e STR_w STR_UNDERSCORE STR_T STR_a STR_i STR_UNDERSCORE STR_L STR_u STR_e "\0"
+#define STRING_Nko0 STR_N STR_k STR_o "\0"
+#define STRING_Nl0 STR_N STR_l "\0"
+#define STRING_No0 STR_N STR_o "\0"
+#define STRING_Ogham0 STR_O STR_g STR_h STR_a STR_m "\0"
+#define STRING_Ol_Chiki0 STR_O STR_l STR_UNDERSCORE STR_C STR_h STR_i STR_k STR_i "\0"
+#define STRING_Old_Italic0 STR_O STR_l STR_d STR_UNDERSCORE STR_I STR_t STR_a STR_l STR_i STR_c "\0"
+#define STRING_Old_North_Arabian0 STR_O STR_l STR_d STR_UNDERSCORE STR_N STR_o STR_r STR_t STR_h STR_UNDERSCORE STR_A STR_r STR_a STR_b STR_i STR_a STR_n "\0"
+#define STRING_Old_Permic0 STR_O STR_l STR_d STR_UNDERSCORE STR_P STR_e STR_r STR_m STR_i STR_c "\0"
+#define STRING_Old_Persian0 STR_O STR_l STR_d STR_UNDERSCORE STR_P STR_e STR_r STR_s STR_i STR_a STR_n "\0"
+#define STRING_Old_South_Arabian0 STR_O STR_l STR_d STR_UNDERSCORE STR_S STR_o STR_u STR_t STR_h STR_UNDERSCORE STR_A STR_r STR_a STR_b STR_i STR_a STR_n "\0"
+#define STRING_Old_Turkic0 STR_O STR_l STR_d STR_UNDERSCORE STR_T STR_u STR_r STR_k STR_i STR_c "\0"
+#define STRING_Oriya0 STR_O STR_r STR_i STR_y STR_a "\0"
+#define STRING_Osmanya0 STR_O STR_s STR_m STR_a STR_n STR_y STR_a "\0"
+#define STRING_P0 STR_P "\0"
+#define STRING_Pahawh_Hmong0 STR_P STR_a STR_h STR_a STR_w STR_h STR_UNDERSCORE STR_H STR_m STR_o STR_n STR_g "\0"
+#define STRING_Palmyrene0 STR_P STR_a STR_l STR_m STR_y STR_r STR_e STR_n STR_e "\0"
+#define STRING_Pau_Cin_Hau0 STR_P STR_a STR_u STR_UNDERSCORE STR_C STR_i STR_n STR_UNDERSCORE STR_H STR_a STR_u "\0"
+#define STRING_Pc0 STR_P STR_c "\0"
+#define STRING_Pd0 STR_P STR_d "\0"
+#define STRING_Pe0 STR_P STR_e "\0"
+#define STRING_Pf0 STR_P STR_f "\0"
+#define STRING_Phags_Pa0 STR_P STR_h STR_a STR_g STR_s STR_UNDERSCORE STR_P STR_a "\0"
+#define STRING_Phoenician0 STR_P STR_h STR_o STR_e STR_n STR_i STR_c STR_i STR_a STR_n "\0"
+#define STRING_Pi0 STR_P STR_i "\0"
+#define STRING_Po0 STR_P STR_o "\0"
+#define STRING_Ps0 STR_P STR_s "\0"
+#define STRING_Psalter_Pahlavi0 STR_P STR_s STR_a STR_l STR_t STR_e STR_r STR_UNDERSCORE STR_P STR_a STR_h STR_l STR_a STR_v STR_i "\0"
+#define STRING_Rejang0 STR_R STR_e STR_j STR_a STR_n STR_g "\0"
+#define STRING_Runic0 STR_R STR_u STR_n STR_i STR_c "\0"
+#define STRING_S0 STR_S "\0"
+#define STRING_Samaritan0 STR_S STR_a STR_m STR_a STR_r STR_i STR_t STR_a STR_n "\0"
+#define STRING_Saurashtra0 STR_S STR_a STR_u STR_r STR_a STR_s STR_h STR_t STR_r STR_a "\0"
+#define STRING_Sc0 STR_S STR_c "\0"
+#define STRING_Sharada0 STR_S STR_h STR_a STR_r STR_a STR_d STR_a "\0"
+#define STRING_Shavian0 STR_S STR_h STR_a STR_v STR_i STR_a STR_n "\0"
+#define STRING_Siddham0 STR_S STR_i STR_d STR_d STR_h STR_a STR_m "\0"
+#define STRING_Sinhala0 STR_S STR_i STR_n STR_h STR_a STR_l STR_a "\0"
+#define STRING_Sk0 STR_S STR_k "\0"
+#define STRING_Sm0 STR_S STR_m "\0"
+#define STRING_So0 STR_S STR_o "\0"
+#define STRING_Sora_Sompeng0 STR_S STR_o STR_r STR_a STR_UNDERSCORE STR_S STR_o STR_m STR_p STR_e STR_n STR_g "\0"
+#define STRING_Sundanese0 STR_S STR_u STR_n STR_d STR_a STR_n STR_e STR_s STR_e "\0"
+#define STRING_Syloti_Nagri0 STR_S STR_y STR_l STR_o STR_t STR_i STR_UNDERSCORE STR_N STR_a STR_g STR_r STR_i "\0"
+#define STRING_Syriac0 STR_S STR_y STR_r STR_i STR_a STR_c "\0"
+#define STRING_Tagalog0 STR_T STR_a STR_g STR_a STR_l STR_o STR_g "\0"
+#define STRING_Tagbanwa0 STR_T STR_a STR_g STR_b STR_a STR_n STR_w STR_a "\0"
+#define STRING_Tai_Le0 STR_T STR_a STR_i STR_UNDERSCORE STR_L STR_e "\0"
+#define STRING_Tai_Tham0 STR_T STR_a STR_i STR_UNDERSCORE STR_T STR_h STR_a STR_m "\0"
+#define STRING_Tai_Viet0 STR_T STR_a STR_i STR_UNDERSCORE STR_V STR_i STR_e STR_t "\0"
+#define STRING_Takri0 STR_T STR_a STR_k STR_r STR_i "\0"
+#define STRING_Tamil0 STR_T STR_a STR_m STR_i STR_l "\0"
+#define STRING_Telugu0 STR_T STR_e STR_l STR_u STR_g STR_u "\0"
+#define STRING_Thaana0 STR_T STR_h STR_a STR_a STR_n STR_a "\0"
+#define STRING_Thai0 STR_T STR_h STR_a STR_i "\0"
+#define STRING_Tibetan0 STR_T STR_i STR_b STR_e STR_t STR_a STR_n "\0"
+#define STRING_Tifinagh0 STR_T STR_i STR_f STR_i STR_n STR_a STR_g STR_h "\0"
+#define STRING_Tirhuta0 STR_T STR_i STR_r STR_h STR_u STR_t STR_a "\0"
+#define STRING_Ugaritic0 STR_U STR_g STR_a STR_r STR_i STR_t STR_i STR_c "\0"
+#define STRING_Vai0 STR_V STR_a STR_i "\0"
+#define STRING_Warang_Citi0 STR_W STR_a STR_r STR_a STR_n STR_g STR_UNDERSCORE STR_C STR_i STR_t STR_i "\0"
+#define STRING_Xan0 STR_X STR_a STR_n "\0"
+#define STRING_Xps0 STR_X STR_p STR_s "\0"
+#define STRING_Xsp0 STR_X STR_s STR_p "\0"
+#define STRING_Xuc0 STR_X STR_u STR_c "\0"
+#define STRING_Xwd0 STR_X STR_w STR_d "\0"
+#define STRING_Yi0 STR_Y STR_i "\0"
+#define STRING_Z0 STR_Z "\0"
+#define STRING_Zl0 STR_Z STR_l "\0"
+#define STRING_Zp0 STR_Z STR_p "\0"
+#define STRING_Zs0 STR_Z STR_s "\0"
+
+const char PRIV(utt_names)[] =
+  STRING_Any0
+  STRING_Arabic0
+  STRING_Armenian0
+  STRING_Avestan0
+  STRING_Balinese0
+  STRING_Bamum0
+  STRING_Bassa_Vah0
+  STRING_Batak0
+  STRING_Bengali0
+  STRING_Bopomofo0
+  STRING_Brahmi0
+  STRING_Braille0
+  STRING_Buginese0
+  STRING_Buhid0
+  STRING_C0
+  STRING_Canadian_Aboriginal0
+  STRING_Carian0
+  STRING_Caucasian_Albanian0
+  STRING_Cc0
+  STRING_Cf0
+  STRING_Chakma0
+  STRING_Cham0
+  STRING_Cherokee0
+  STRING_Cn0
+  STRING_Co0
+  STRING_Common0
+  STRING_Coptic0
+  STRING_Cs0
+  STRING_Cuneiform0
+  STRING_Cypriot0
+  STRING_Cyrillic0
+  STRING_Deseret0
+  STRING_Devanagari0
+  STRING_Duployan0
+  STRING_Egyptian_Hieroglyphs0
+  STRING_Elbasan0
+  STRING_Ethiopic0
+  STRING_Georgian0
+  STRING_Glagolitic0
+  STRING_Gothic0
+  STRING_Grantha0
+  STRING_Greek0
+  STRING_Gujarati0
+  STRING_Gurmukhi0
+  STRING_Han0
+  STRING_Hangul0
+  STRING_Hanunoo0
+  STRING_Hebrew0
+  STRING_Hiragana0
+  STRING_Imperial_Aramaic0
+  STRING_Inherited0
+  STRING_Inscriptional_Pahlavi0
+  STRING_Inscriptional_Parthian0
+  STRING_Javanese0
+  STRING_Kaithi0
+  STRING_Kannada0
+  STRING_Katakana0
+  STRING_Kayah_Li0
+  STRING_Kharoshthi0
+  STRING_Khmer0
+  STRING_Khojki0
+  STRING_Khudawadi0
+  STRING_L0
+  STRING_L_AMPERSAND0
+  STRING_Lao0
+  STRING_Latin0
+  STRING_Lepcha0
+  STRING_Limbu0
+  STRING_Linear_A0
+  STRING_Linear_B0
+  STRING_Lisu0
+  STRING_Ll0
+  STRING_Lm0
+  STRING_Lo0
+  STRING_Lt0
+  STRING_Lu0
+  STRING_Lycian0
+  STRING_Lydian0
+  STRING_M0
+  STRING_Mahajani0
+  STRING_Malayalam0
+  STRING_Mandaic0
+  STRING_Manichaean0
+  STRING_Mc0
+  STRING_Me0
+  STRING_Meetei_Mayek0
+  STRING_Mende_Kikakui0
+  STRING_Meroitic_Cursive0
+  STRING_Meroitic_Hieroglyphs0
+  STRING_Miao0
+  STRING_Mn0
+  STRING_Modi0
+  STRING_Mongolian0
+  STRING_Mro0
+  STRING_Myanmar0
+  STRING_N0
+  STRING_Nabataean0
+  STRING_Nd0
+  STRING_New_Tai_Lue0
+  STRING_Nko0
+  STRING_Nl0
+  STRING_No0
+  STRING_Ogham0
+  STRING_Ol_Chiki0
+  STRING_Old_Italic0
+  STRING_Old_North_Arabian0
+  STRING_Old_Permic0
+  STRING_Old_Persian0
+  STRING_Old_South_Arabian0
+  STRING_Old_Turkic0
+  STRING_Oriya0
+  STRING_Osmanya0
+  STRING_P0
+  STRING_Pahawh_Hmong0
+  STRING_Palmyrene0
+  STRING_Pau_Cin_Hau0
+  STRING_Pc0
+  STRING_Pd0
+  STRING_Pe0
+  STRING_Pf0
+  STRING_Phags_Pa0
+  STRING_Phoenician0
+  STRING_Pi0
+  STRING_Po0
+  STRING_Ps0
+  STRING_Psalter_Pahlavi0
+  STRING_Rejang0
+  STRING_Runic0
+  STRING_S0
+  STRING_Samaritan0
+  STRING_Saurashtra0
+  STRING_Sc0
+  STRING_Sharada0
+  STRING_Shavian0
+  STRING_Siddham0
+  STRING_Sinhala0
+  STRING_Sk0
+  STRING_Sm0
+  STRING_So0
+  STRING_Sora_Sompeng0
+  STRING_Sundanese0
+  STRING_Syloti_Nagri0
+  STRING_Syriac0
+  STRING_Tagalog0
+  STRING_Tagbanwa0
+  STRING_Tai_Le0
+  STRING_Tai_Tham0
+  STRING_Tai_Viet0
+  STRING_Takri0
+  STRING_Tamil0
+  STRING_Telugu0
+  STRING_Thaana0
+  STRING_Thai0
+  STRING_Tibetan0
+  STRING_Tifinagh0
+  STRING_Tirhuta0
+  STRING_Ugaritic0
+  STRING_Vai0
+  STRING_Warang_Citi0
+  STRING_Xan0
+  STRING_Xps0
+  STRING_Xsp0
+  STRING_Xuc0
+  STRING_Xwd0
+  STRING_Yi0
+  STRING_Z0
+  STRING_Zl0
+  STRING_Zp0
+  STRING_Zs0;
+
+const ucp_type_table PRIV(utt)[] = {
+  {   0, PT_ANY, 0 },
+  {   4, PT_SC, ucp_Arabic },
+  {  11, PT_SC, ucp_Armenian },
+  {  20, PT_SC, ucp_Avestan },
+  {  28, PT_SC, ucp_Balinese },
+  {  37, PT_SC, ucp_Bamum },
+  {  43, PT_SC, ucp_Bassa_Vah },
+  {  53, PT_SC, ucp_Batak },
+  {  59, PT_SC, ucp_Bengali },
+  {  67, PT_SC, ucp_Bopomofo },
+  {  76, PT_SC, ucp_Brahmi },
+  {  83, PT_SC, ucp_Braille },
+  {  91, PT_SC, ucp_Buginese },
+  { 100, PT_SC, ucp_Buhid },
+  { 106, PT_GC, ucp_C },
+  { 108, PT_SC, ucp_Canadian_Aboriginal },
+  { 128, PT_SC, ucp_Carian },
+  { 135, PT_SC, ucp_Caucasian_Albanian },
+  { 154, PT_PC, ucp_Cc },
+  { 157, PT_PC, ucp_Cf },
+  { 160, PT_SC, ucp_Chakma },
+  { 167, PT_SC, ucp_Cham },
+  { 172, PT_SC, ucp_Cherokee },
+  { 181, PT_PC, ucp_Cn },
+  { 184, PT_PC, ucp_Co },
+  { 187, PT_SC, ucp_Common },
+  { 194, PT_SC, ucp_Coptic },
+  { 201, PT_PC, ucp_Cs },
+  { 204, PT_SC, ucp_Cuneiform },
+  { 214, PT_SC, ucp_Cypriot },
+  { 222, PT_SC, ucp_Cyrillic },
+  { 231, PT_SC, ucp_Deseret },
+  { 239, PT_SC, ucp_Devanagari },
+  { 250, PT_SC, ucp_Duployan },
+  { 259, PT_SC, ucp_Egyptian_Hieroglyphs },
+  { 280, PT_SC, ucp_Elbasan },
+  { 288, PT_SC, ucp_Ethiopic },
+  { 297, PT_SC, ucp_Georgian },
+  { 306, PT_SC, ucp_Glagolitic },
+  { 317, PT_SC, ucp_Gothic },
+  { 324, PT_SC, ucp_Grantha },
+  { 332, PT_SC, ucp_Greek },
+  { 338, PT_SC, ucp_Gujarati },
+  { 347, PT_SC, ucp_Gurmukhi },
+  { 356, PT_SC, ucp_Han },
+  { 360, PT_SC, ucp_Hangul },
+  { 367, PT_SC, ucp_Hanunoo },
+  { 375, PT_SC, ucp_Hebrew },
+  { 382, PT_SC, ucp_Hiragana },
+  { 391, PT_SC, ucp_Imperial_Aramaic },
+  { 408, PT_SC, ucp_Inherited },
+  { 418, PT_SC, ucp_Inscriptional_Pahlavi },
+  { 440, PT_SC, ucp_Inscriptional_Parthian },
+  { 463, PT_SC, ucp_Javanese },
+  { 472, PT_SC, ucp_Kaithi },
+  { 479, PT_SC, ucp_Kannada },
+  { 487, PT_SC, ucp_Katakana },
+  { 496, PT_SC, ucp_Kayah_Li },
+  { 505, PT_SC, ucp_Kharoshthi },
+  { 516, PT_SC, ucp_Khmer },
+  { 522, PT_SC, ucp_Khojki },
+  { 529, PT_SC, ucp_Khudawadi },
+  { 539, PT_GC, ucp_L },
+  { 541, PT_LAMP, 0 },
+  { 544, PT_SC, ucp_Lao },
+  { 548, PT_SC, ucp_Latin },
+  { 554, PT_SC, ucp_Lepcha },
+  { 561, PT_SC, ucp_Limbu },
+  { 567, PT_SC, ucp_Linear_A },
+  { 576, PT_SC, ucp_Linear_B },
+  { 585, PT_SC, ucp_Lisu },
+  { 590, PT_PC, ucp_Ll },
+  { 593, PT_PC, ucp_Lm },
+  { 596, PT_PC, ucp_Lo },
+  { 599, PT_PC, ucp_Lt },
+  { 602, PT_PC, ucp_Lu },
+  { 605, PT_SC, ucp_Lycian },
+  { 612, PT_SC, ucp_Lydian },
+  { 619, PT_GC, ucp_M },
+  { 621, PT_SC, ucp_Mahajani },
+  { 630, PT_SC, ucp_Malayalam },
+  { 640, PT_SC, ucp_Mandaic },
+  { 648, PT_SC, ucp_Manichaean },
+  { 659, PT_PC, ucp_Mc },
+  { 662, PT_PC, ucp_Me },
+  { 665, PT_SC, ucp_Meetei_Mayek },
+  { 678, PT_SC, ucp_Mende_Kikakui },
+  { 692, PT_SC, ucp_Meroitic_Cursive },
+  { 709, PT_SC, ucp_Meroitic_Hieroglyphs },
+  { 730, PT_SC, ucp_Miao },
+  { 735, PT_PC, ucp_Mn },
+  { 738, PT_SC, ucp_Modi },
+  { 743, PT_SC, ucp_Mongolian },
+  { 753, PT_SC, ucp_Mro },
+  { 757, PT_SC, ucp_Myanmar },
+  { 765, PT_GC, ucp_N },
+  { 767, PT_SC, ucp_Nabataean },
+  { 777, PT_PC, ucp_Nd },
+  { 780, PT_SC, ucp_New_Tai_Lue },
+  { 792, PT_SC, ucp_Nko },
+  { 796, PT_PC, ucp_Nl },
+  { 799, PT_PC, ucp_No },
+  { 802, PT_SC, ucp_Ogham },
+  { 808, PT_SC, ucp_Ol_Chiki },
+  { 817, PT_SC, ucp_Old_Italic },
+  { 828, PT_SC, ucp_Old_North_Arabian },
+  { 846, PT_SC, ucp_Old_Permic },
+  { 857, PT_SC, ucp_Old_Persian },
+  { 869, PT_SC, ucp_Old_South_Arabian },
+  { 887, PT_SC, ucp_Old_Turkic },
+  { 898, PT_SC, ucp_Oriya },
+  { 904, PT_SC, ucp_Osmanya },
+  { 912, PT_GC, ucp_P },
+  { 914, PT_SC, ucp_Pahawh_Hmong },
+  { 927, PT_SC, ucp_Palmyrene },
+  { 937, PT_SC, ucp_Pau_Cin_Hau },
+  { 949, PT_PC, ucp_Pc },
+  { 952, PT_PC, ucp_Pd },
+  { 955, PT_PC, ucp_Pe },
+  { 958, PT_PC, ucp_Pf },
+  { 961, PT_SC, ucp_Phags_Pa },
+  { 970, PT_SC, ucp_Phoenician },
+  { 981, PT_PC, ucp_Pi },
+  { 984, PT_PC, ucp_Po },
+  { 987, PT_PC, ucp_Ps },
+  { 990, PT_SC, ucp_Psalter_Pahlavi },
+  { 1006, PT_SC, ucp_Rejang },
+  { 1013, PT_SC, ucp_Runic },
+  { 1019, PT_GC, ucp_S },
+  { 1021, PT_SC, ucp_Samaritan },
+  { 1031, PT_SC, ucp_Saurashtra },
+  { 1042, PT_PC, ucp_Sc },
+  { 1045, PT_SC, ucp_Sharada },
+  { 1053, PT_SC, ucp_Shavian },
+  { 1061, PT_SC, ucp_Siddham },
+  { 1069, PT_SC, ucp_Sinhala },
+  { 1077, PT_PC, ucp_Sk },
+  { 1080, PT_PC, ucp_Sm },
+  { 1083, PT_PC, ucp_So },
+  { 1086, PT_SC, ucp_Sora_Sompeng },
+  { 1099, PT_SC, ucp_Sundanese },
+  { 1109, PT_SC, ucp_Syloti_Nagri },
+  { 1122, PT_SC, ucp_Syriac },
+  { 1129, PT_SC, ucp_Tagalog },
+  { 1137, PT_SC, ucp_Tagbanwa },
+  { 1146, PT_SC, ucp_Tai_Le },
+  { 1153, PT_SC, ucp_Tai_Tham },
+  { 1162, PT_SC, ucp_Tai_Viet },
+  { 1171, PT_SC, ucp_Takri },
+  { 1177, PT_SC, ucp_Tamil },
+  { 1183, PT_SC, ucp_Telugu },
+  { 1190, PT_SC, ucp_Thaana },
+  { 1197, PT_SC, ucp_Thai },
+  { 1202, PT_SC, ucp_Tibetan },
+  { 1210, PT_SC, ucp_Tifinagh },
+  { 1219, PT_SC, ucp_Tirhuta },
+  { 1227, PT_SC, ucp_Ugaritic },
+  { 1236, PT_SC, ucp_Vai },
+  { 1240, PT_SC, ucp_Warang_Citi },
+  { 1252, PT_ALNUM, 0 },
+  { 1256, PT_PXSPACE, 0 },
+  { 1260, PT_SPACE, 0 },
+  { 1264, PT_UCNC, 0 },
+  { 1268, PT_WORD, 0 },
+  { 1272, PT_SC, ucp_Yi },
+  { 1275, PT_GC, ucp_Z },
+  { 1277, PT_PC, ucp_Zl },
+  { 1280, PT_PC, ucp_Zp },
+  { 1283, PT_PC, ucp_Zs }
+};
+
+const int PRIV(utt_size) = sizeof(PRIV(utt)) / sizeof(ucp_type_table);
+
+#endif /* SUPPORT_UTF */
+
+/* End of pcre_tables.c */
diff --git a/base/poco/Foundation/src/pcre_ucd.c b/base/poco/Foundation/src/pcre_ucd.c
new file mode 100644
index 00000000000..c7e8aab4805
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_ucd.c
@@ -0,0 +1,3641 @@
+/* This module is generated by the maint/MultiStage2.py script.
+Do not modify it by hand. Instead modify the script and run it
+to regenerate this code.
+
+As well as being part of the PCRE library, this module is #included
+by the pcretest program, which redefines the PRIV macro to change
+table names from _pcre_xxx to xxxx, thereby avoiding name clashes
+with the library. At present, just one of these tables is actually
+needed. */
+
+#ifndef PCRE_INCLUDED
+
+#include "pcre_config.h"
+#include "pcre_internal.h"
+
+#endif /* PCRE_INCLUDED */
+
+/* Unicode character database. */
+/* This file was autogenerated by the MultiStage2.py script. */
+/* Total size: 72576 bytes, block size: 128. */
+
+/* The tables herein are needed only when UCP support is built
+into PCRE. This module should not be referenced otherwise, so
+it should not matter whether it is compiled or not. However
+a comment was received about space saving - maybe the guy linked
+all the modules rather than using a library - so we include a
+condition to cut out the tables when not needed. But don't leave
+a totally empty module because some compilers barf at that.
+Instead, just supply small dummy tables. */
+
+#ifndef SUPPORT_UCP
+const ucd_record PRIV(ucd_records)[] = {{0,0,0,0,0 }};
+const pcre_uint8 PRIV(ucd_stage1)[] = {0};
+const pcre_uint16 PRIV(ucd_stage2)[] = {0};
+const pcre_uint32 PRIV(ucd_caseless_sets)[] = {0};
+#else
+
+/* If the 32-bit library is run in non-32-bit mode, character values
+greater than 0x10ffff may be encountered. For these we set up a
+special record. */
+
+#ifdef COMPILE_PCRE32
+const ucd_record PRIV(dummy_ucd_record)[] = {{
+  ucp_Common,    /* script */
+  ucp_Cn,        /* type unassigned */
+  ucp_gbOther,   /* grapheme break property */
+  0,             /* case set */
+  0,             /* other case */
+  }};
+#endif
+
+/* When recompiling tables with a new Unicode version, please check the
+types in this structure definition from pcre_internal.h (the actual
+field names will be different):
+
+typedef struct {
+pcre_uint8 property_0;
+pcre_uint8 property_1;
+pcre_uint8 property_2;
+pcre_uint8 property_3;
+pcre_int32 property_4;
+} ucd_record;
+*/
+
+
+const pcre_uint32 PRIV(ucd_caseless_sets)[] = {
+  NOTACHAR,
+  0x0053,   0x0073,   0x017f,   NOTACHAR,
+  0x01c4,   0x01c5,   0x01c6,   NOTACHAR,
+  0x01c7,   0x01c8,   0x01c9,   NOTACHAR,
+  0x01ca,   0x01cb,   0x01cc,   NOTACHAR,
+  0x01f1,   0x01f2,   0x01f3,   NOTACHAR,
+  0x0345,   0x0399,   0x03b9,   0x1fbe,   NOTACHAR,
+  0x00b5,   0x039c,   0x03bc,   NOTACHAR,
+  0x03a3,   0x03c2,   0x03c3,   NOTACHAR,
+  0x0392,   0x03b2,   0x03d0,   NOTACHAR,
+  0x0398,   0x03b8,   0x03d1,   0x03f4,   NOTACHAR,
+  0x03a6,   0x03c6,   0x03d5,   NOTACHAR,
+  0x03a0,   0x03c0,   0x03d6,   NOTACHAR,
+  0x039a,   0x03ba,   0x03f0,   NOTACHAR,
+  0x03a1,   0x03c1,   0x03f1,   NOTACHAR,
+  0x0395,   0x03b5,   0x03f5,   NOTACHAR,
+  0x1e60,   0x1e61,   0x1e9b,   NOTACHAR,
+  0x03a9,   0x03c9,   0x2126,   NOTACHAR,
+  0x004b,   0x006b,   0x212a,   NOTACHAR,
+  0x00c5,   0x00e5,   0x212b,   NOTACHAR,
+};
+
+/* When #included in pcretest, we don't need this large table. */
+
+#ifndef PCRE_INCLUDED
+
+const ucd_record PRIV(ucd_records)[] = { /* 5760 bytes, record size 8 */
+  {     9,      0,      2,      0,      0, }, /*   0 */
+  {     9,      0,      1,      0,      0, }, /*   1 */
+  {     9,      0,      0,      0,      0, }, /*   2 */
+  {     9,     29,     12,      0,      0, }, /*   3 */
+  {     9,     21,     12,      0,      0, }, /*   4 */
+  {     9,     23,     12,      0,      0, }, /*   5 */
+  {     9,     22,     12,      0,      0, }, /*   6 */
+  {     9,     18,     12,      0,      0, }, /*   7 */
+  {     9,     25,     12,      0,      0, }, /*   8 */
+  {     9,     17,     12,      0,      0, }, /*   9 */
+  {     9,     13,     12,      0,      0, }, /*  10 */
+  {    33,      9,     12,      0,     32, }, /*  11 */
+  {    33,      9,     12,     71,     32, }, /*  12 */
+  {    33,      9,     12,      1,     32, }, /*  13 */
+  {     9,     24,     12,      0,      0, }, /*  14 */
+  {     9,     16,     12,      0,      0, }, /*  15 */
+  {    33,      5,     12,      0,    -32, }, /*  16 */
+  {    33,      5,     12,     71,    -32, }, /*  17 */
+  {    33,      5,     12,      1,    -32, }, /*  18 */
+  {     9,     26,     12,      0,      0, }, /*  19 */
+  {    33,      7,     12,      0,      0, }, /*  20 */
+  {     9,     20,     12,      0,      0, }, /*  21 */
+  {     9,      1,      2,      0,      0, }, /*  22 */
+  {     9,     15,     12,      0,      0, }, /*  23 */
+  {     9,      5,     12,     26,    775, }, /*  24 */
+  {     9,     19,     12,      0,      0, }, /*  25 */
+  {    33,      9,     12,     75,     32, }, /*  26 */
+  {    33,      5,     12,      0,   7615, }, /*  27 */
+  {    33,      5,     12,     75,    -32, }, /*  28 */
+  {    33,      5,     12,      0,    121, }, /*  29 */
+  {    33,      9,     12,      0,      1, }, /*  30 */
+  {    33,      5,     12,      0,     -1, }, /*  31 */
+  {    33,      9,     12,      0,      0, }, /*  32 */
+  {    33,      5,     12,      0,      0, }, /*  33 */
+  {    33,      9,     12,      0,   -121, }, /*  34 */
+  {    33,      5,     12,      1,   -268, }, /*  35 */
+  {    33,      5,     12,      0,    195, }, /*  36 */
+  {    33,      9,     12,      0,    210, }, /*  37 */
+  {    33,      9,     12,      0,    206, }, /*  38 */
+  {    33,      9,     12,      0,    205, }, /*  39 */
+  {    33,      9,     12,      0,     79, }, /*  40 */
+  {    33,      9,     12,      0,    202, }, /*  41 */
+  {    33,      9,     12,      0,    203, }, /*  42 */
+  {    33,      9,     12,      0,    207, }, /*  43 */
+  {    33,      5,     12,      0,     97, }, /*  44 */
+  {    33,      9,     12,      0,    211, }, /*  45 */
+  {    33,      9,     12,      0,    209, }, /*  46 */
+  {    33,      5,     12,      0,    163, }, /*  47 */
+  {    33,      9,     12,      0,    213, }, /*  48 */
+  {    33,      5,     12,      0,    130, }, /*  49 */
+  {    33,      9,     12,      0,    214, }, /*  50 */
+  {    33,      9,     12,      0,    218, }, /*  51 */
+  {    33,      9,     12,      0,    217, }, /*  52 */
+  {    33,      9,     12,      0,    219, }, /*  53 */
+  {    33,      5,     12,      0,     56, }, /*  54 */
+  {    33,      9,     12,      5,      2, }, /*  55 */
+  {    33,      8,     12,      5,      1, }, /*  56 */
+  {    33,      5,     12,      5,     -2, }, /*  57 */
+  {    33,      9,     12,      9,      2, }, /*  58 */
+  {    33,      8,     12,      9,      1, }, /*  59 */
+  {    33,      5,     12,      9,     -2, }, /*  60 */
+  {    33,      9,     12,     13,      2, }, /*  61 */
+  {    33,      8,     12,     13,      1, }, /*  62 */
+  {    33,      5,     12,     13,     -2, }, /*  63 */
+  {    33,      5,     12,      0,    -79, }, /*  64 */
+  {    33,      9,     12,     17,      2, }, /*  65 */
+  {    33,      8,     12,     17,      1, }, /*  66 */
+  {    33,      5,     12,     17,     -2, }, /*  67 */
+  {    33,      9,     12,      0,    -97, }, /*  68 */
+  {    33,      9,     12,      0,    -56, }, /*  69 */
+  {    33,      9,     12,      0,   -130, }, /*  70 */
+  {    33,      9,     12,      0,  10795, }, /*  71 */
+  {    33,      9,     12,      0,   -163, }, /*  72 */
+  {    33,      9,     12,      0,  10792, }, /*  73 */
+  {    33,      5,     12,      0,  10815, }, /*  74 */
+  {    33,      9,     12,      0,   -195, }, /*  75 */
+  {    33,      9,     12,      0,     69, }, /*  76 */
+  {    33,      9,     12,      0,     71, }, /*  77 */
+  {    33,      5,     12,      0,  10783, }, /*  78 */
+  {    33,      5,     12,      0,  10780, }, /*  79 */
+  {    33,      5,     12,      0,  10782, }, /*  80 */
+  {    33,      5,     12,      0,   -210, }, /*  81 */
+  {    33,      5,     12,      0,   -206, }, /*  82 */
+  {    33,      5,     12,      0,   -205, }, /*  83 */
+  {    33,      5,     12,      0,   -202, }, /*  84 */
+  {    33,      5,     12,      0,   -203, }, /*  85 */
+  {    33,      5,     12,      0,  42319, }, /*  86 */
+  {    33,      5,     12,      0,  42315, }, /*  87 */
+  {    33,      5,     12,      0,   -207, }, /*  88 */
+  {    33,      5,     12,      0,  42280, }, /*  89 */
+  {    33,      5,     12,      0,  42308, }, /*  90 */
+  {    33,      5,     12,      0,   -209, }, /*  91 */
+  {    33,      5,     12,      0,   -211, }, /*  92 */
+  {    33,      5,     12,      0,  10743, }, /*  93 */
+  {    33,      5,     12,      0,  42305, }, /*  94 */
+  {    33,      5,     12,      0,  10749, }, /*  95 */
+  {    33,      5,     12,      0,   -213, }, /*  96 */
+  {    33,      5,     12,      0,   -214, }, /*  97 */
+  {    33,      5,     12,      0,  10727, }, /*  98 */
+  {    33,      5,     12,      0,   -218, }, /*  99 */
+  {    33,      5,     12,      0,  42282, }, /* 100 */
+  {    33,      5,     12,      0,    -69, }, /* 101 */
+  {    33,      5,     12,      0,   -217, }, /* 102 */
+  {    33,      5,     12,      0,    -71, }, /* 103 */
+  {    33,      5,     12,      0,   -219, }, /* 104 */
+  {    33,      5,     12,      0,  42258, }, /* 105 */
+  {    33,      6,     12,      0,      0, }, /* 106 */
+  {     9,      6,     12,      0,      0, }, /* 107 */
+  {     3,     24,     12,      0,      0, }, /* 108 */
+  {    27,     12,      3,      0,      0, }, /* 109 */
+  {    27,     12,      3,     21,    116, }, /* 110 */
+  {    19,      9,     12,      0,      1, }, /* 111 */
+  {    19,      5,     12,      0,     -1, }, /* 112 */
+  {    19,     24,     12,      0,      0, }, /* 113 */
+  {     9,      2,     12,      0,      0, }, /* 114 */
+  {    19,      6,     12,      0,      0, }, /* 115 */
+  {    19,      5,     12,      0,    130, }, /* 116 */
+  {    19,      9,     12,      0,    116, }, /* 117 */
+  {    19,      9,     12,      0,     38, }, /* 118 */
+  {    19,      9,     12,      0,     37, }, /* 119 */
+  {    19,      9,     12,      0,     64, }, /* 120 */
+  {    19,      9,     12,      0,     63, }, /* 121 */
+  {    19,      5,     12,      0,      0, }, /* 122 */
+  {    19,      9,     12,      0,     32, }, /* 123 */
+  {    19,      9,     12,     34,     32, }, /* 124 */
+  {    19,      9,     12,     59,     32, }, /* 125 */
+  {    19,      9,     12,     38,     32, }, /* 126 */
+  {    19,      9,     12,     21,     32, }, /* 127 */
+  {    19,      9,     12,     51,     32, }, /* 128 */
+  {    19,      9,     12,     26,     32, }, /* 129 */
+  {    19,      9,     12,     47,     32, }, /* 130 */
+  {    19,      9,     12,     55,     32, }, /* 131 */
+  {    19,      9,     12,     30,     32, }, /* 132 */
+  {    19,      9,     12,     43,     32, }, /* 133 */
+  {    19,      9,     12,     67,     32, }, /* 134 */
+  {    19,      5,     12,      0,    -38, }, /* 135 */
+  {    19,      5,     12,      0,    -37, }, /* 136 */
+  {    19,      5,     12,      0,    -32, }, /* 137 */
+  {    19,      5,     12,     34,    -32, }, /* 138 */
+  {    19,      5,     12,     59,    -32, }, /* 139 */
+  {    19,      5,     12,     38,    -32, }, /* 140 */
+  {    19,      5,     12,     21,   -116, }, /* 141 */
+  {    19,      5,     12,     51,    -32, }, /* 142 */
+  {    19,      5,     12,     26,   -775, }, /* 143 */
+  {    19,      5,     12,     47,    -32, }, /* 144 */
+  {    19,      5,     12,     55,    -32, }, /* 145 */
+  {    19,      5,     12,     30,      1, }, /* 146 */
+  {    19,      5,     12,     30,    -32, }, /* 147 */
+  {    19,      5,     12,     43,    -32, }, /* 148 */
+  {    19,      5,     12,     67,    -32, }, /* 149 */
+  {    19,      5,     12,      0,    -64, }, /* 150 */
+  {    19,      5,     12,      0,    -63, }, /* 151 */
+  {    19,      9,     12,      0,      8, }, /* 152 */
+  {    19,      5,     12,     34,    -30, }, /* 153 */
+  {    19,      5,     12,     38,    -25, }, /* 154 */
+  {    19,      9,     12,      0,      0, }, /* 155 */
+  {    19,      5,     12,     43,    -15, }, /* 156 */
+  {    19,      5,     12,     47,    -22, }, /* 157 */
+  {    19,      5,     12,      0,     -8, }, /* 158 */
+  {    10,      9,     12,      0,      1, }, /* 159 */
+  {    10,      5,     12,      0,     -1, }, /* 160 */
+  {    19,      5,     12,     51,    -54, }, /* 161 */
+  {    19,      5,     12,     55,    -48, }, /* 162 */
+  {    19,      5,     12,      0,      7, }, /* 163 */
+  {    19,      5,     12,      0,   -116, }, /* 164 */
+  {    19,      9,     12,     38,    -60, }, /* 165 */
+  {    19,      5,     12,     59,    -64, }, /* 166 */
+  {    19,     25,     12,      0,      0, }, /* 167 */
+  {    19,      9,     12,      0,     -7, }, /* 168 */
+  {    19,      9,     12,      0,   -130, }, /* 169 */
+  {    12,      9,     12,      0,     80, }, /* 170 */
+  {    12,      9,     12,      0,     32, }, /* 171 */
+  {    12,      5,     12,      0,    -32, }, /* 172 */
+  {    12,      5,     12,      0,    -80, }, /* 173 */
+  {    12,      9,     12,      0,      1, }, /* 174 */
+  {    12,      5,     12,      0,     -1, }, /* 175 */
+  {    12,     26,     12,      0,      0, }, /* 176 */
+  {    12,     12,      3,      0,      0, }, /* 177 */
+  {    12,     11,      3,      0,      0, }, /* 178 */
+  {    12,      9,     12,      0,     15, }, /* 179 */
+  {    12,      5,     12,      0,    -15, }, /* 180 */
+  {     1,      9,     12,      0,     48, }, /* 181 */
+  {     1,      6,     12,      0,      0, }, /* 182 */
+  {     1,     21,     12,      0,      0, }, /* 183 */
+  {     1,      5,     12,      0,    -48, }, /* 184 */
+  {     1,      5,     12,      0,      0, }, /* 185 */
+  {     1,     17,     12,      0,      0, }, /* 186 */
+  {     1,     26,     12,      0,      0, }, /* 187 */
+  {     1,     23,     12,      0,      0, }, /* 188 */
+  {    25,     12,      3,      0,      0, }, /* 189 */
+  {    25,     17,     12,      0,      0, }, /* 190 */
+  {    25,     21,     12,      0,      0, }, /* 191 */
+  {    25,      7,     12,      0,      0, }, /* 192 */
+  {     0,      1,      2,      0,      0, }, /* 193 */
+  {     0,     25,     12,      0,      0, }, /* 194 */
+  {     0,     21,     12,      0,      0, }, /* 195 */
+  {     0,     23,     12,      0,      0, }, /* 196 */
+  {     0,     26,     12,      0,      0, }, /* 197 */
+  {     0,     12,      3,      0,      0, }, /* 198 */
+  {     0,      7,     12,      0,      0, }, /* 199 */
+  {     0,      6,     12,      0,      0, }, /* 200 */
+  {     0,     13,     12,      0,      0, }, /* 201 */
+  {    49,     21,     12,      0,      0, }, /* 202 */
+  {    49,      1,      2,      0,      0, }, /* 203 */
+  {    49,      7,     12,      0,      0, }, /* 204 */
+  {    49,     12,      3,      0,      0, }, /* 205 */
+  {    55,      7,     12,      0,      0, }, /* 206 */
+  {    55,     12,      3,      0,      0, }, /* 207 */
+  {    63,     13,     12,      0,      0, }, /* 208 */
+  {    63,      7,     12,      0,      0, }, /* 209 */
+  {    63,     12,      3,      0,      0, }, /* 210 */
+  {    63,      6,     12,      0,      0, }, /* 211 */
+  {    63,     26,     12,      0,      0, }, /* 212 */
+  {    63,     21,     12,      0,      0, }, /* 213 */
+  {    89,      7,     12,      0,      0, }, /* 214 */
+  {    89,     12,      3,      0,      0, }, /* 215 */
+  {    89,      6,     12,      0,      0, }, /* 216 */
+  {    89,     21,     12,      0,      0, }, /* 217 */
+  {    94,      7,     12,      0,      0, }, /* 218 */
+  {    94,     12,      3,      0,      0, }, /* 219 */
+  {    94,     21,     12,      0,      0, }, /* 220 */
+  {    14,     12,      3,      0,      0, }, /* 221 */
+  {    14,     10,      5,      0,      0, }, /* 222 */
+  {    14,      7,     12,      0,      0, }, /* 223 */
+  {    14,     13,     12,      0,      0, }, /* 224 */
+  {    14,     21,     12,      0,      0, }, /* 225 */
+  {    14,      6,     12,      0,      0, }, /* 226 */
+  {     2,      7,     12,      0,      0, }, /* 227 */
+  {     2,     12,      3,      0,      0, }, /* 228 */
+  {     2,     10,      5,      0,      0, }, /* 229 */
+  {     2,     10,      3,      0,      0, }, /* 230 */
+  {     2,     13,     12,      0,      0, }, /* 231 */
+  {     2,     23,     12,      0,      0, }, /* 232 */
+  {     2,     15,     12,      0,      0, }, /* 233 */
+  {     2,     26,     12,      0,      0, }, /* 234 */
+  {    21,     12,      3,      0,      0, }, /* 235 */
+  {    21,     10,      5,      0,      0, }, /* 236 */
+  {    21,      7,     12,      0,      0, }, /* 237 */
+  {    21,     13,     12,      0,      0, }, /* 238 */
+  {    20,     12,      3,      0,      0, }, /* 239 */
+  {    20,     10,      5,      0,      0, }, /* 240 */
+  {    20,      7,     12,      0,      0, }, /* 241 */
+  {    20,     13,     12,      0,      0, }, /* 242 */
+  {    20,     21,     12,      0,      0, }, /* 243 */
+  {    20,     23,     12,      0,      0, }, /* 244 */
+  {    43,     12,      3,      0,      0, }, /* 245 */
+  {    43,     10,      5,      0,      0, }, /* 246 */
+  {    43,      7,     12,      0,      0, }, /* 247 */
+  {    43,     10,      3,      0,      0, }, /* 248 */
+  {    43,     13,     12,      0,      0, }, /* 249 */
+  {    43,     26,     12,      0,      0, }, /* 250 */
+  {    43,     15,     12,      0,      0, }, /* 251 */
+  {    53,     12,      3,      0,      0, }, /* 252 */
+  {    53,      7,     12,      0,      0, }, /* 253 */
+  {    53,     10,      3,      0,      0, }, /* 254 */
+  {    53,     10,      5,      0,      0, }, /* 255 */
+  {    53,     13,     12,      0,      0, }, /* 256 */
+  {    53,     15,     12,      0,      0, }, /* 257 */
+  {    53,     26,     12,      0,      0, }, /* 258 */
+  {    53,     23,     12,      0,      0, }, /* 259 */
+  {    54,     12,      3,      0,      0, }, /* 260 */
+  {    54,     10,      5,      0,      0, }, /* 261 */
+  {    54,      7,     12,      0,      0, }, /* 262 */
+  {    54,     13,     12,      0,      0, }, /* 263 */
+  {    54,     15,     12,      0,      0, }, /* 264 */
+  {    54,     26,     12,      0,      0, }, /* 265 */
+  {    28,     12,      3,      0,      0, }, /* 266 */
+  {    28,     10,      5,      0,      0, }, /* 267 */
+  {    28,      7,     12,      0,      0, }, /* 268 */
+  {    28,     10,      3,      0,      0, }, /* 269 */
+  {    28,     13,     12,      0,      0, }, /* 270 */
+  {    36,     12,      3,      0,      0, }, /* 271 */
+  {    36,     10,      5,      0,      0, }, /* 272 */
+  {    36,      7,     12,      0,      0, }, /* 273 */
+  {    36,     10,      3,      0,      0, }, /* 274 */
+  {    36,     13,     12,      0,      0, }, /* 275 */
+  {    36,     15,     12,      0,      0, }, /* 276 */
+  {    36,     26,     12,      0,      0, }, /* 277 */
+  {    47,     10,      5,      0,      0, }, /* 278 */
+  {    47,      7,     12,      0,      0, }, /* 279 */
+  {    47,     12,      3,      0,      0, }, /* 280 */
+  {    47,     10,      3,      0,      0, }, /* 281 */
+  {    47,     13,     12,      0,      0, }, /* 282 */
+  {    47,     21,     12,      0,      0, }, /* 283 */
+  {    56,      7,     12,      0,      0, }, /* 284 */
+  {    56,     12,      3,      0,      0, }, /* 285 */
+  {    56,      7,      5,      0,      0, }, /* 286 */
+  {    56,      6,     12,      0,      0, }, /* 287 */
+  {    56,     21,     12,      0,      0, }, /* 288 */
+  {    56,     13,     12,      0,      0, }, /* 289 */
+  {    32,      7,     12,      0,      0, }, /* 290 */
+  {    32,     12,      3,      0,      0, }, /* 291 */
+  {    32,      7,      5,      0,      0, }, /* 292 */
+  {    32,      6,     12,      0,      0, }, /* 293 */
+  {    32,     13,     12,      0,      0, }, /* 294 */
+  {    57,      7,     12,      0,      0, }, /* 295 */
+  {    57,     26,     12,      0,      0, }, /* 296 */
+  {    57,     21,     12,      0,      0, }, /* 297 */
+  {    57,     12,      3,      0,      0, }, /* 298 */
+  {    57,     13,     12,      0,      0, }, /* 299 */
+  {    57,     15,     12,      0,      0, }, /* 300 */
+  {    57,     22,     12,      0,      0, }, /* 301 */
+  {    57,     18,     12,      0,      0, }, /* 302 */
+  {    57,     10,      5,      0,      0, }, /* 303 */
+  {    38,      7,     12,      0,      0, }, /* 304 */
+  {    38,     10,     12,      0,      0, }, /* 305 */
+  {    38,     12,      3,      0,      0, }, /* 306 */
+  {    38,     10,      5,      0,      0, }, /* 307 */
+  {    38,     13,     12,      0,      0, }, /* 308 */
+  {    38,     21,     12,      0,      0, }, /* 309 */
+  {    38,     26,     12,      0,      0, }, /* 310 */
+  {    16,      9,     12,      0,   7264, }, /* 311 */
+  {    16,      7,     12,      0,      0, }, /* 312 */
+  {    16,      6,     12,      0,      0, }, /* 313 */
+  {    23,      7,      6,      0,      0, }, /* 314 */
+  {    23,      7,      7,      0,      0, }, /* 315 */
+  {    23,      7,      8,      0,      0, }, /* 316 */
+  {    15,      7,     12,      0,      0, }, /* 317 */
+  {    15,     12,      3,      0,      0, }, /* 318 */
+  {    15,     21,     12,      0,      0, }, /* 319 */
+  {    15,     15,     12,      0,      0, }, /* 320 */
+  {    15,     26,     12,      0,      0, }, /* 321 */
+  {     8,      7,     12,      0,      0, }, /* 322 */
+  {     7,     17,     12,      0,      0, }, /* 323 */
+  {     7,      7,     12,      0,      0, }, /* 324 */
+  {     7,     21,     12,      0,      0, }, /* 325 */
+  {    40,     29,     12,      0,      0, }, /* 326 */
+  {    40,      7,     12,      0,      0, }, /* 327 */
+  {    40,     22,     12,      0,      0, }, /* 328 */
+  {    40,     18,     12,      0,      0, }, /* 329 */
+  {    45,      7,     12,      0,      0, }, /* 330 */
+  {    45,     14,     12,      0,      0, }, /* 331 */
+  {    50,      7,     12,      0,      0, }, /* 332 */
+  {    50,     12,      3,      0,      0, }, /* 333 */
+  {    24,      7,     12,      0,      0, }, /* 334 */
+  {    24,     12,      3,      0,      0, }, /* 335 */
+  {     6,      7,     12,      0,      0, }, /* 336 */
+  {     6,     12,      3,      0,      0, }, /* 337 */
+  {    51,      7,     12,      0,      0, }, /* 338 */
+  {    51,     12,      3,      0,      0, }, /* 339 */
+  {    31,      7,     12,      0,      0, }, /* 340 */
+  {    31,     12,      3,      0,      0, }, /* 341 */
+  {    31,     10,      5,      0,      0, }, /* 342 */
+  {    31,     21,     12,      0,      0, }, /* 343 */
+  {    31,      6,     12,      0,      0, }, /* 344 */
+  {    31,     23,     12,      0,      0, }, /* 345 */
+  {    31,     13,     12,      0,      0, }, /* 346 */
+  {    31,     15,     12,      0,      0, }, /* 347 */
+  {    37,     21,     12,      0,      0, }, /* 348 */
+  {    37,     17,     12,      0,      0, }, /* 349 */
+  {    37,     12,      3,      0,      0, }, /* 350 */
+  {    37,      1,      2,      0,      0, }, /* 351 */
+  {    37,     13,     12,      0,      0, }, /* 352 */
+  {    37,      7,     12,      0,      0, }, /* 353 */
+  {    37,      6,     12,      0,      0, }, /* 354 */
+  {    34,      7,     12,      0,      0, }, /* 355 */
+  {    34,     12,      3,      0,      0, }, /* 356 */
+  {    34,     10,      5,      0,      0, }, /* 357 */
+  {    34,     26,     12,      0,      0, }, /* 358 */
+  {    34,     21,     12,      0,      0, }, /* 359 */
+  {    34,     13,     12,      0,      0, }, /* 360 */
+  {    52,      7,     12,      0,      0, }, /* 361 */
+  {    39,      7,     12,      0,      0, }, /* 362 */
+  {    39,     10,     12,      0,      0, }, /* 363 */
+  {    39,     10,      5,      0,      0, }, /* 364 */
+  {    39,     13,     12,      0,      0, }, /* 365 */
+  {    39,     15,     12,      0,      0, }, /* 366 */
+  {    39,     26,     12,      0,      0, }, /* 367 */
+  {    31,     26,     12,      0,      0, }, /* 368 */
+  {     5,      7,     12,      0,      0, }, /* 369 */
+  {     5,     12,      3,      0,      0, }, /* 370 */
+  {     5,     10,      5,      0,      0, }, /* 371 */
+  {     5,     21,     12,      0,      0, }, /* 372 */
+  {    90,      7,     12,      0,      0, }, /* 373 */
+  {    90,     10,      5,      0,      0, }, /* 374 */
+  {    90,     12,      3,      0,      0, }, /* 375 */
+  {    90,     10,     12,      0,      0, }, /* 376 */
+  {    90,     13,     12,      0,      0, }, /* 377 */
+  {    90,     21,     12,      0,      0, }, /* 378 */
+  {    90,      6,     12,      0,      0, }, /* 379 */
+  {    27,     11,      3,      0,      0, }, /* 380 */
+  {    61,     12,      3,      0,      0, }, /* 381 */
+  {    61,     10,      5,      0,      0, }, /* 382 */
+  {    61,      7,     12,      0,      0, }, /* 383 */
+  {    61,     13,     12,      0,      0, }, /* 384 */
+  {    61,     21,     12,      0,      0, }, /* 385 */
+  {    61,     26,     12,      0,      0, }, /* 386 */
+  {    75,     12,      3,      0,      0, }, /* 387 */
+  {    75,     10,      5,      0,      0, }, /* 388 */
+  {    75,      7,     12,      0,      0, }, /* 389 */
+  {    75,     13,     12,      0,      0, }, /* 390 */
+  {    92,      7,     12,      0,      0, }, /* 391 */
+  {    92,     12,      3,      0,      0, }, /* 392 */
+  {    92,     10,      5,      0,      0, }, /* 393 */
+  {    92,     21,     12,      0,      0, }, /* 394 */
+  {    69,      7,     12,      0,      0, }, /* 395 */
+  {    69,     10,      5,      0,      0, }, /* 396 */
+  {    69,     12,      3,      0,      0, }, /* 397 */
+  {    69,     21,     12,      0,      0, }, /* 398 */
+  {    69,     13,     12,      0,      0, }, /* 399 */
+  {    72,     13,     12,      0,      0, }, /* 400 */
+  {    72,      7,     12,      0,      0, }, /* 401 */
+  {    72,      6,     12,      0,      0, }, /* 402 */
+  {    72,     21,     12,      0,      0, }, /* 403 */
+  {    75,     21,     12,      0,      0, }, /* 404 */
+  {     9,     10,      5,      0,      0, }, /* 405 */
+  {     9,      7,     12,      0,      0, }, /* 406 */
+  {    12,      5,     12,      0,      0, }, /* 407 */
+  {    12,      6,     12,      0,      0, }, /* 408 */
+  {    33,      5,     12,      0,  35332, }, /* 409 */
+  {    33,      5,     12,      0,   3814, }, /* 410 */
+  {    33,      9,     12,     63,      1, }, /* 411 */
+  {    33,      5,     12,     63,     -1, }, /* 412 */
+  {    33,      5,     12,     63,    -58, }, /* 413 */
+  {    33,      9,     12,      0,  -7615, }, /* 414 */
+  {    19,      5,     12,      0,      8, }, /* 415 */
+  {    19,      9,     12,      0,     -8, }, /* 416 */
+  {    19,      5,     12,      0,     74, }, /* 417 */
+  {    19,      5,     12,      0,     86, }, /* 418 */
+  {    19,      5,     12,      0,    100, }, /* 419 */
+  {    19,      5,     12,      0,    128, }, /* 420 */
+  {    19,      5,     12,      0,    112, }, /* 421 */
+  {    19,      5,     12,      0,    126, }, /* 422 */
+  {    19,      8,     12,      0,     -8, }, /* 423 */
+  {    19,      5,     12,      0,      9, }, /* 424 */
+  {    19,      9,     12,      0,    -74, }, /* 425 */
+  {    19,      8,     12,      0,     -9, }, /* 426 */
+  {    19,      5,     12,     21,  -7173, }, /* 427 */
+  {    19,      9,     12,      0,    -86, }, /* 428 */
+  {    19,      9,     12,      0,   -100, }, /* 429 */
+  {    19,      9,     12,      0,   -112, }, /* 430 */
+  {    19,      9,     12,      0,   -128, }, /* 431 */
+  {    19,      9,     12,      0,   -126, }, /* 432 */
+  {    27,      1,      3,      0,      0, }, /* 433 */
+  {     9,     27,      2,      0,      0, }, /* 434 */
+  {     9,     28,      2,      0,      0, }, /* 435 */
+  {     9,      2,      2,      0,      0, }, /* 436 */
+  {     9,      9,     12,      0,      0, }, /* 437 */
+  {     9,      5,     12,      0,      0, }, /* 438 */
+  {    19,      9,     12,     67,  -7517, }, /* 439 */
+  {    33,      9,     12,     71,  -8383, }, /* 440 */
+  {    33,      9,     12,     75,  -8262, }, /* 441 */
+  {    33,      9,     12,      0,     28, }, /* 442 */
+  {    33,      5,     12,      0,    -28, }, /* 443 */
+  {    33,     14,     12,      0,     16, }, /* 444 */
+  {    33,     14,     12,      0,    -16, }, /* 445 */
+  {    33,     14,     12,      0,      0, }, /* 446 */
+  {     9,     26,     12,      0,     26, }, /* 447 */
+  {     9,     26,     12,      0,    -26, }, /* 448 */
+  {     4,     26,     12,      0,      0, }, /* 449 */
+  {    17,      9,     12,      0,     48, }, /* 450 */
+  {    17,      5,     12,      0,    -48, }, /* 451 */
+  {    33,      9,     12,      0, -10743, }, /* 452 */
+  {    33,      9,     12,      0,  -3814, }, /* 453 */
+  {    33,      9,     12,      0, -10727, }, /* 454 */
+  {    33,      5,     12,      0, -10795, }, /* 455 */
+  {    33,      5,     12,      0, -10792, }, /* 456 */
+  {    33,      9,     12,      0, -10780, }, /* 457 */
+  {    33,      9,     12,      0, -10749, }, /* 458 */
+  {    33,      9,     12,      0, -10783, }, /* 459 */
+  {    33,      9,     12,      0, -10782, }, /* 460 */
+  {    33,      9,     12,      0, -10815, }, /* 461 */
+  {    10,      5,     12,      0,      0, }, /* 462 */
+  {    10,     26,     12,      0,      0, }, /* 463 */
+  {    10,     12,      3,      0,      0, }, /* 464 */
+  {    10,     21,     12,      0,      0, }, /* 465 */
+  {    10,     15,     12,      0,      0, }, /* 466 */
+  {    16,      5,     12,      0,  -7264, }, /* 467 */
+  {    58,      7,     12,      0,      0, }, /* 468 */
+  {    58,      6,     12,      0,      0, }, /* 469 */
+  {    58,     21,     12,      0,      0, }, /* 470 */
+  {    58,     12,      3,      0,      0, }, /* 471 */
+  {    22,     26,     12,      0,      0, }, /* 472 */
+  {    22,      6,     12,      0,      0, }, /* 473 */
+  {    22,     14,     12,      0,      0, }, /* 474 */
+  {    23,     10,      3,      0,      0, }, /* 475 */
+  {    26,      7,     12,      0,      0, }, /* 476 */
+  {    26,      6,     12,      0,      0, }, /* 477 */
+  {    29,      7,     12,      0,      0, }, /* 478 */
+  {    29,      6,     12,      0,      0, }, /* 479 */
+  {     3,      7,     12,      0,      0, }, /* 480 */
+  {    23,      7,     12,      0,      0, }, /* 481 */
+  {    23,     26,     12,      0,      0, }, /* 482 */
+  {    29,     26,     12,      0,      0, }, /* 483 */
+  {    22,      7,     12,      0,      0, }, /* 484 */
+  {    60,      7,     12,      0,      0, }, /* 485 */
+  {    60,      6,     12,      0,      0, }, /* 486 */
+  {    60,     26,     12,      0,      0, }, /* 487 */
+  {    85,      7,     12,      0,      0, }, /* 488 */
+  {    85,      6,     12,      0,      0, }, /* 489 */
+  {    85,     21,     12,      0,      0, }, /* 490 */
+  {    76,      7,     12,      0,      0, }, /* 491 */
+  {    76,      6,     12,      0,      0, }, /* 492 */
+  {    76,     21,     12,      0,      0, }, /* 493 */
+  {    76,     13,     12,      0,      0, }, /* 494 */
+  {    12,      7,     12,      0,      0, }, /* 495 */
+  {    12,     21,     12,      0,      0, }, /* 496 */
+  {    78,      7,     12,      0,      0, }, /* 497 */
+  {    78,     14,     12,      0,      0, }, /* 498 */
+  {    78,     12,      3,      0,      0, }, /* 499 */
+  {    78,     21,     12,      0,      0, }, /* 500 */
+  {    33,      9,     12,      0, -35332, }, /* 501 */
+  {    33,      9,     12,      0, -42280, }, /* 502 */
+  {    33,      9,     12,      0, -42308, }, /* 503 */
+  {    33,      9,     12,      0, -42319, }, /* 504 */
+  {    33,      9,     12,      0, -42315, }, /* 505 */
+  {    33,      9,     12,      0, -42305, }, /* 506 */
+  {    33,      9,     12,      0, -42258, }, /* 507 */
+  {    33,      9,     12,      0, -42282, }, /* 508 */
+  {    48,      7,     12,      0,      0, }, /* 509 */
+  {    48,     12,      3,      0,      0, }, /* 510 */
+  {    48,     10,      5,      0,      0, }, /* 511 */
+  {    48,     26,     12,      0,      0, }, /* 512 */
+  {    64,      7,     12,      0,      0, }, /* 513 */
+  {    64,     21,     12,      0,      0, }, /* 514 */
+  {    74,     10,      5,      0,      0, }, /* 515 */
+  {    74,      7,     12,      0,      0, }, /* 516 */
+  {    74,     12,      3,      0,      0, }, /* 517 */
+  {    74,     21,     12,      0,      0, }, /* 518 */
+  {    74,     13,     12,      0,      0, }, /* 519 */
+  {    68,     13,     12,      0,      0, }, /* 520 */
+  {    68,      7,     12,      0,      0, }, /* 521 */
+  {    68,     12,      3,      0,      0, }, /* 522 */
+  {    68,     21,     12,      0,      0, }, /* 523 */
+  {    73,      7,     12,      0,      0, }, /* 524 */
+  {    73,     12,      3,      0,      0, }, /* 525 */
+  {    73,     10,      5,      0,      0, }, /* 526 */
+  {    73,     21,     12,      0,      0, }, /* 527 */
+  {    83,     12,      3,      0,      0, }, /* 528 */
+  {    83,     10,      5,      0,      0, }, /* 529 */
+  {    83,      7,     12,      0,      0, }, /* 530 */
+  {    83,     21,     12,      0,      0, }, /* 531 */
+  {    83,     13,     12,      0,      0, }, /* 532 */
+  {    38,      6,     12,      0,      0, }, /* 533 */
+  {    67,      7,     12,      0,      0, }, /* 534 */
+  {    67,     12,      3,      0,      0, }, /* 535 */
+  {    67,     10,      5,      0,      0, }, /* 536 */
+  {    67,     13,     12,      0,      0, }, /* 537 */
+  {    67,     21,     12,      0,      0, }, /* 538 */
+  {    91,      7,     12,      0,      0, }, /* 539 */
+  {    91,     12,      3,      0,      0, }, /* 540 */
+  {    91,      6,     12,      0,      0, }, /* 541 */
+  {    91,     21,     12,      0,      0, }, /* 542 */
+  {    86,      7,     12,      0,      0, }, /* 543 */
+  {    86,     10,      5,      0,      0, }, /* 544 */
+  {    86,     12,      3,      0,      0, }, /* 545 */
+  {    86,     21,     12,      0,      0, }, /* 546 */
+  {    86,      6,     12,      0,      0, }, /* 547 */
+  {    86,     13,     12,      0,      0, }, /* 548 */
+  {    23,      7,      9,      0,      0, }, /* 549 */
+  {    23,      7,     10,      0,      0, }, /* 550 */
+  {     9,      4,      2,      0,      0, }, /* 551 */
+  {     9,      3,     12,      0,      0, }, /* 552 */
+  {    25,     25,     12,      0,      0, }, /* 553 */
+  {     0,     24,     12,      0,      0, }, /* 554 */
+  {     9,      6,      3,      0,      0, }, /* 555 */
+  {    35,      7,     12,      0,      0, }, /* 556 */
+  {    19,     14,     12,      0,      0, }, /* 557 */
+  {    19,     15,     12,      0,      0, }, /* 558 */
+  {    19,     26,     12,      0,      0, }, /* 559 */
+  {    70,      7,     12,      0,      0, }, /* 560 */
+  {    66,      7,     12,      0,      0, }, /* 561 */
+  {    41,      7,     12,      0,      0, }, /* 562 */
+  {    41,     15,     12,      0,      0, }, /* 563 */
+  {    18,      7,     12,      0,      0, }, /* 564 */
+  {    18,     14,     12,      0,      0, }, /* 565 */
+  {   117,      7,     12,      0,      0, }, /* 566 */
+  {   117,     12,      3,      0,      0, }, /* 567 */
+  {    59,      7,     12,      0,      0, }, /* 568 */
+  {    59,     21,     12,      0,      0, }, /* 569 */
+  {    42,      7,     12,      0,      0, }, /* 570 */
+  {    42,     21,     12,      0,      0, }, /* 571 */
+  {    42,     14,     12,      0,      0, }, /* 572 */
+  {    13,      9,     12,      0,     40, }, /* 573 */
+  {    13,      5,     12,      0,    -40, }, /* 574 */
+  {    46,      7,     12,      0,      0, }, /* 575 */
+  {    44,      7,     12,      0,      0, }, /* 576 */
+  {    44,     13,     12,      0,      0, }, /* 577 */
+  {   105,      7,     12,      0,      0, }, /* 578 */
+  {   103,      7,     12,      0,      0, }, /* 579 */
+  {   103,     21,     12,      0,      0, }, /* 580 */
+  {   109,      7,     12,      0,      0, }, /* 581 */
+  {    11,      7,     12,      0,      0, }, /* 582 */
+  {    80,      7,     12,      0,      0, }, /* 583 */
+  {    80,     21,     12,      0,      0, }, /* 584 */
+  {    80,     15,     12,      0,      0, }, /* 585 */
+  {   119,      7,     12,      0,      0, }, /* 586 */
+  {   119,     26,     12,      0,      0, }, /* 587 */
+  {   119,     15,     12,      0,      0, }, /* 588 */
+  {   115,      7,     12,      0,      0, }, /* 589 */
+  {   115,     15,     12,      0,      0, }, /* 590 */
+  {    65,      7,     12,      0,      0, }, /* 591 */
+  {    65,     15,     12,      0,      0, }, /* 592 */
+  {    65,     21,     12,      0,      0, }, /* 593 */
+  {    71,      7,     12,      0,      0, }, /* 594 */
+  {    71,     21,     12,      0,      0, }, /* 595 */
+  {    97,      7,     12,      0,      0, }, /* 596 */
+  {    96,      7,     12,      0,      0, }, /* 597 */
+  {    30,      7,     12,      0,      0, }, /* 598 */
+  {    30,     12,      3,      0,      0, }, /* 599 */
+  {    30,     15,     12,      0,      0, }, /* 600 */
+  {    30,     21,     12,      0,      0, }, /* 601 */
+  {    87,      7,     12,      0,      0, }, /* 602 */
+  {    87,     15,     12,      0,      0, }, /* 603 */
+  {    87,     21,     12,      0,      0, }, /* 604 */
+  {   116,      7,     12,      0,      0, }, /* 605 */
+  {   116,     15,     12,      0,      0, }, /* 606 */
+  {   111,      7,     12,      0,      0, }, /* 607 */
+  {   111,     26,     12,      0,      0, }, /* 608 */
+  {   111,     12,      3,      0,      0, }, /* 609 */
+  {   111,     15,     12,      0,      0, }, /* 610 */
+  {   111,     21,     12,      0,      0, }, /* 611 */
+  {    77,      7,     12,      0,      0, }, /* 612 */
+  {    77,     21,     12,      0,      0, }, /* 613 */
+  {    82,      7,     12,      0,      0, }, /* 614 */
+  {    82,     15,     12,      0,      0, }, /* 615 */
+  {    81,      7,     12,      0,      0, }, /* 616 */
+  {    81,     15,     12,      0,      0, }, /* 617 */
+  {   120,      7,     12,      0,      0, }, /* 618 */
+  {   120,     21,     12,      0,      0, }, /* 619 */
+  {   120,     15,     12,      0,      0, }, /* 620 */
+  {    88,      7,     12,      0,      0, }, /* 621 */
+  {     0,     15,     12,      0,      0, }, /* 622 */
+  {    93,     10,      5,      0,      0, }, /* 623 */
+  {    93,     12,      3,      0,      0, }, /* 624 */
+  {    93,      7,     12,      0,      0, }, /* 625 */
+  {    93,     21,     12,      0,      0, }, /* 626 */
+  {    93,     15,     12,      0,      0, }, /* 627 */
+  {    93,     13,     12,      0,      0, }, /* 628 */
+  {    84,     12,      3,      0,      0, }, /* 629 */
+  {    84,     10,      5,      0,      0, }, /* 630 */
+  {    84,      7,     12,      0,      0, }, /* 631 */
+  {    84,     21,     12,      0,      0, }, /* 632 */
+  {    84,      1,      2,      0,      0, }, /* 633 */
+  {   100,      7,     12,      0,      0, }, /* 634 */
+  {   100,     13,     12,      0,      0, }, /* 635 */
+  {    95,     12,      3,      0,      0, }, /* 636 */
+  {    95,      7,     12,      0,      0, }, /* 637 */
+  {    95,     10,      5,      0,      0, }, /* 638 */
+  {    95,     13,     12,      0,      0, }, /* 639 */
+  {    95,     21,     12,      0,      0, }, /* 640 */
+  {   110,      7,     12,      0,      0, }, /* 641 */
+  {   110,     12,      3,      0,      0, }, /* 642 */
+  {   110,     21,     12,      0,      0, }, /* 643 */
+  {    99,     12,      3,      0,      0, }, /* 644 */
+  {    99,     10,      5,      0,      0, }, /* 645 */
+  {    99,      7,     12,      0,      0, }, /* 646 */
+  {    99,     21,     12,      0,      0, }, /* 647 */
+  {    99,     13,     12,      0,      0, }, /* 648 */
+  {    47,     15,     12,      0,      0, }, /* 649 */
+  {   107,      7,     12,      0,      0, }, /* 650 */
+  {   107,     10,      5,      0,      0, }, /* 651 */
+  {   107,     12,      3,      0,      0, }, /* 652 */
+  {   107,     21,     12,      0,      0, }, /* 653 */
+  {   108,      7,     12,      0,      0, }, /* 654 */
+  {   108,     12,      3,      0,      0, }, /* 655 */
+  {   108,     10,      5,      0,      0, }, /* 656 */
+  {   108,     13,     12,      0,      0, }, /* 657 */
+  {   106,     12,      3,      0,      0, }, /* 658 */
+  {   106,     10,      5,      0,      0, }, /* 659 */
+  {   106,      7,     12,      0,      0, }, /* 660 */
+  {   106,     10,      3,      0,      0, }, /* 661 */
+  {   123,      7,     12,      0,      0, }, /* 662 */
+  {   123,     10,      3,      0,      0, }, /* 663 */
+  {   123,     10,      5,      0,      0, }, /* 664 */
+  {   123,     12,      3,      0,      0, }, /* 665 */
+  {   123,     21,     12,      0,      0, }, /* 666 */
+  {   123,     13,     12,      0,      0, }, /* 667 */
+  {   122,      7,     12,      0,      0, }, /* 668 */
+  {   122,     10,      3,      0,      0, }, /* 669 */
+  {   122,     10,      5,      0,      0, }, /* 670 */
+  {   122,     12,      3,      0,      0, }, /* 671 */
+  {   122,     21,     12,      0,      0, }, /* 672 */
+  {   113,      7,     12,      0,      0, }, /* 673 */
+  {   113,     10,      5,      0,      0, }, /* 674 */
+  {   113,     12,      3,      0,      0, }, /* 675 */
+  {   113,     21,     12,      0,      0, }, /* 676 */
+  {   113,     13,     12,      0,      0, }, /* 677 */
+  {   101,      7,     12,      0,      0, }, /* 678 */
+  {   101,     12,      3,      0,      0, }, /* 679 */
+  {   101,     10,      5,      0,      0, }, /* 680 */
+  {   101,     13,     12,      0,      0, }, /* 681 */
+  {   124,      9,     12,      0,     32, }, /* 682 */
+  {   124,      5,     12,      0,    -32, }, /* 683 */
+  {   124,     13,     12,      0,      0, }, /* 684 */
+  {   124,     15,     12,      0,      0, }, /* 685 */
+  {   124,      7,     12,      0,      0, }, /* 686 */
+  {   121,      7,     12,      0,      0, }, /* 687 */
+  {    62,      7,     12,      0,      0, }, /* 688 */
+  {    62,     14,     12,      0,      0, }, /* 689 */
+  {    62,     21,     12,      0,      0, }, /* 690 */
+  {    79,      7,     12,      0,      0, }, /* 691 */
+  {   114,      7,     12,      0,      0, }, /* 692 */
+  {   114,     13,     12,      0,      0, }, /* 693 */
+  {   114,     21,     12,      0,      0, }, /* 694 */
+  {   102,      7,     12,      0,      0, }, /* 695 */
+  {   102,     12,      3,      0,      0, }, /* 696 */
+  {   102,     21,     12,      0,      0, }, /* 697 */
+  {   118,      7,     12,      0,      0, }, /* 698 */
+  {   118,     12,      3,      0,      0, }, /* 699 */
+  {   118,     21,     12,      0,      0, }, /* 700 */
+  {   118,     26,     12,      0,      0, }, /* 701 */
+  {   118,      6,     12,      0,      0, }, /* 702 */
+  {   118,     13,     12,      0,      0, }, /* 703 */
+  {   118,     15,     12,      0,      0, }, /* 704 */
+  {    98,      7,     12,      0,      0, }, /* 705 */
+  {    98,     10,      5,      0,      0, }, /* 706 */
+  {    98,     12,      3,      0,      0, }, /* 707 */
+  {    98,      6,     12,      0,      0, }, /* 708 */
+  {   104,      7,     12,      0,      0, }, /* 709 */
+  {   104,     26,     12,      0,      0, }, /* 710 */
+  {   104,     12,      3,      0,      0, }, /* 711 */
+  {   104,     21,     12,      0,      0, }, /* 712 */
+  {     9,     10,      3,      0,      0, }, /* 713 */
+  {    19,     12,      3,      0,      0, }, /* 714 */
+  {   112,      7,     12,      0,      0, }, /* 715 */
+  {   112,     15,     12,      0,      0, }, /* 716 */
+  {   112,     12,      3,      0,      0, }, /* 717 */
+  {     9,     26,     11,      0,      0, }, /* 718 */
+  {    26,     26,     12,      0,      0, }, /* 719 */
+};
+
+const pcre_uint8 PRIV(ucd_stage1)[] = { /* 8704 bytes */
+  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, /* U+0000 */
+ 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, /* U+0800 */
+ 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 41, 41, 42, 43, 44, 45, /* U+1000 */
+ 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, /* U+1800 */
+ 62, 63, 64, 65, 66, 66, 67, 68, 69, 70, 71, 72, 73, 71, 74, 75, /* U+2000 */
+ 76, 76, 66, 77, 66, 66, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, /* U+2800 */
+ 88, 89, 90, 91, 92, 93, 94, 71, 95, 95, 95, 95, 95, 95, 95, 95, /* U+3000 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+3800 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+4000 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 96, 95, 95, 95, 95, /* U+4800 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+5000 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+5800 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+6000 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+6800 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+7000 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+7800 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+8000 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+8800 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+9000 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 97, /* U+9800 */
+ 98, 99, 99, 99, 99, 99, 99, 99, 99,100,101,101,102,103,104,105, /* U+A000 */
+106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,114, /* U+A800 */
+115,116,117,118,119,120,114,115,116,117,118,119,120,114,115,116, /* U+B000 */
+117,118,119,120,114,115,116,117,118,119,120,114,115,116,117,118, /* U+B800 */
+119,120,114,115,116,117,118,119,120,114,115,116,117,118,119,120, /* U+C000 */
+114,115,116,117,118,119,120,114,115,116,117,118,119,120,114,115, /* U+C800 */
+116,117,118,119,120,114,115,116,117,118,119,120,114,115,116,121, /* U+D000 */
+122,122,122,122,122,122,122,122,122,122,122,122,122,122,122,122, /* U+D800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+E000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+E800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F000 */
+123,123, 95, 95,124,125,126,127,128,128,129,130,131,132,133,134, /* U+F800 */
+135,136,137,138,139,140,141,142,143,144,145,139,146,146,147,139, /* U+10000 */
+148,149,150,151,152,153,154,155,156,139,139,139,157,139,139,139, /* U+10800 */
+158,159,160,161,162,163,164,139,139,165,139,166,167,168,139,139, /* U+11000 */
+139,169,139,139,139,170,139,139,139,139,139,139,139,139,139,139, /* U+11800 */
+171,171,171,171,171,171,171,172,173,139,139,139,139,139,139,139, /* U+12000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+12800 */
+174,174,174,174,174,174,174,174,175,139,139,139,139,139,139,139, /* U+13000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+13800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+14000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+14800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+15000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+15800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+16000 */
+176,176,176,176,177,178,179,180,139,139,139,139,139,139,181,182, /* U+16800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+17000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+17800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+18000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+18800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+19000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+19800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+1A000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+1A800 */
+183,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+1B000 */
+139,139,139,139,139,139,139,139,184,185,139,139,139,139,139,139, /* U+1B800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+1C000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+1C800 */
+ 71,186,187,188,189,139,190,139,191,192,193,194,195,196,197,198, /* U+1D000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+1D800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+1E000 */
+199,200,139,139,139,139,139,139,139,139,139,139,201,202,139,139, /* U+1E800 */
+203,204,205,206,207,139,208,209, 71,210,211,212,213,214,215,216, /* U+1F000 */
+217,218,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+1F800 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+20000 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+20800 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+21000 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+21800 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+22000 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+22800 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+23000 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+23800 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+24000 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+24800 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+25000 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+25800 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+26000 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+26800 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+27000 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+27800 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+28000 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+28800 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+29000 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+29800 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95,219, 95, 95, /* U+2A000 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, /* U+2A800 */
+ 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95, 95,220, 95, /* U+2B000 */
+221,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+2B800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+2C000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+2C800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+2D000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+2D800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+2E000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+2E800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+2F000 */
+ 95, 95, 95, 95,221,139,139,139,139,139,139,139,139,139,139,139, /* U+2F800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+30000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+30800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+31000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+31800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+32000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+32800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+33000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+33800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+34000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+34800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+35000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+35800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+36000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+36800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+37000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+37800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+38000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+38800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+39000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+39800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3A000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3A800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3B000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3B800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3C000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3C800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3D000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3D800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3E000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3E800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3F000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+3F800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+40000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+40800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+41000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+41800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+42000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+42800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+43000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+43800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+44000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+44800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+45000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+45800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+46000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+46800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+47000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+47800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+48000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+48800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+49000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+49800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4A000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4A800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4B000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4B800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4C000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4C800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4D000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4D800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4E000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4E800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4F000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+4F800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+50000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+50800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+51000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+51800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+52000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+52800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+53000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+53800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+54000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+54800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+55000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+55800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+56000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+56800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+57000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+57800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+58000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+58800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+59000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+59800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5A000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5A800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5B000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5B800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5C000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5C800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5D000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5D800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5E000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5E800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5F000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+5F800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+60000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+60800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+61000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+61800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+62000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+62800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+63000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+63800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+64000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+64800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+65000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+65800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+66000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+66800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+67000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+67800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+68000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+68800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+69000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+69800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6A000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6A800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6B000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6B800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6C000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6C800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6D000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6D800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6E000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6E800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6F000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+6F800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+70000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+70800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+71000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+71800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+72000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+72800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+73000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+73800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+74000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+74800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+75000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+75800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+76000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+76800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+77000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+77800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+78000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+78800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+79000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+79800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7A000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7A800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7B000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7B800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7C000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7C800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7D000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7D800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7E000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7E800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7F000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+7F800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+80000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+80800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+81000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+81800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+82000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+82800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+83000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+83800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+84000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+84800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+85000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+85800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+86000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+86800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+87000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+87800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+88000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+88800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+89000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+89800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8A000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8A800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8B000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8B800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8C000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8C800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8D000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8D800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8E000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8E800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8F000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+8F800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+90000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+90800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+91000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+91800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+92000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+92800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+93000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+93800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+94000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+94800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+95000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+95800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+96000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+96800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+97000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+97800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+98000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+98800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+99000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+99800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9A000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9A800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9B000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9B800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9C000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9C800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9D000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9D800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9E000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9E800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9F000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+9F800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A0000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A0800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A1000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A1800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A2000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A2800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A3000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A3800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A4000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A4800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A5000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A5800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A6000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A6800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A7000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A7800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A8000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A8800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A9000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+A9800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AA000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AA800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AB000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AB800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AC000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AC800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AD000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AD800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AE000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AE800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AF000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+AF800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B0000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B0800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B1000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B1800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B2000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B2800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B3000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B3800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B4000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B4800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B5000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B5800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B6000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B6800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B7000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B7800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B8000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B8800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B9000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+B9800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BA000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BA800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BB000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BB800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BC000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BC800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BD000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BD800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BE000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BE800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BF000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+BF800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C0000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C0800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C1000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C1800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C2000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C2800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C3000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C3800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C4000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C4800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C5000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C5800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C6000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C6800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C7000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C7800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C8000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C8800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C9000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+C9800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CA000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CA800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CB000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CB800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CC000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CC800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CD000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CD800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CE000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CE800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CF000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+CF800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D0000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D0800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D1000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D1800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D2000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D2800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D3000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D3800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D4000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D4800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D5000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D5800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D6000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D6800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D7000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D7800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D8000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D8800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D9000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+D9800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DA000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DA800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DB000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DB800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DC000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DC800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DD000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DD800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DE000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DE800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DF000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+DF800 */
+222,223,224,225,223,223,223,223,223,223,223,223,223,223,223,223, /* U+E0000 */
+223,223,223,223,223,223,223,223,223,223,223,223,223,223,223,223, /* U+E0800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E1000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E1800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E2000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E2800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E3000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E3800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E4000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E4800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E5000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E5800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E6000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E6800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E7000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E7800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E8000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E8800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E9000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+E9800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EA000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EA800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EB000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EB800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EC000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EC800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+ED000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+ED800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EE000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EE800 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EF000 */
+139,139,139,139,139,139,139,139,139,139,139,139,139,139,139,139, /* U+EF800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F0000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F0800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F1000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F1800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F2000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F2800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F3000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F3800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F4000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F4800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F5000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F5800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F6000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F6800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F7000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F7800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F8000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F8800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F9000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+F9800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FA000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FA800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FB000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FB800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FC000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FC800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FD000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FD800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FE000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FE800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+FF000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,226, /* U+FF800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+100000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+100800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+101000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+101800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+102000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+102800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+103000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+103800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+104000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+104800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+105000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+105800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+106000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+106800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+107000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+107800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+108000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+108800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+109000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+109800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10A000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10A800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10B000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10B800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10C000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10C800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10D000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10D800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10E000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10E800 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123, /* U+10F000 */
+123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,226, /* U+10F800 */
+};
+
+const pcre_uint16 PRIV(ucd_stage2)[] = { /* 58112 bytes, block = 128 */
+/* block 0 */
+  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  1,  0,  0,  2,  0,  0,
+  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+  3,  4,  4,  4,  5,  4,  4,  4,  6,  7,  4,  8,  4,  9,  4,  4,
+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,  4,  4,  8,  8,  8,  4,
+  4, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 11, 11, 11, 11,
+ 11, 11, 11, 13, 11, 11, 11, 11, 11, 11, 11,  6,  4,  7, 14, 15,
+ 14, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 17, 16, 16, 16, 16,
+ 16, 16, 16, 18, 16, 16, 16, 16, 16, 16, 16,  6,  8,  7,  8,  0,
+
+/* block 1 */
+  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+  3,  4,  5,  5,  5,  5, 19,  4, 14, 19, 20, 21,  8, 22, 19, 14,
+ 19,  8, 23, 23, 14, 24,  4,  4, 14, 23, 20, 25, 23, 23, 23,  4,
+ 11, 11, 11, 11, 11, 26, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+ 11, 11, 11, 11, 11, 11, 11,  8, 11, 11, 11, 11, 11, 11, 11, 27,
+ 16, 16, 16, 16, 16, 28, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16,  8, 16, 16, 16, 16, 16, 16, 16, 29,
+
+/* block 2 */
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 32, 33, 30, 31, 30, 31, 30, 31, 33, 30, 31, 30, 31, 30, 31, 30,
+ 31, 30, 31, 30, 31, 30, 31, 30, 31, 33, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 34, 30, 31, 30, 31, 30, 31, 35,
+
+/* block 3 */
+ 36, 37, 30, 31, 30, 31, 38, 30, 31, 39, 39, 30, 31, 33, 40, 41,
+ 42, 30, 31, 39, 43, 44, 45, 46, 30, 31, 47, 33, 45, 48, 49, 50,
+ 30, 31, 30, 31, 30, 31, 51, 30, 31, 51, 33, 33, 30, 31, 51, 30,
+ 31, 52, 52, 30, 31, 30, 31, 53, 30, 31, 33, 20, 30, 31, 33, 54,
+ 20, 20, 20, 20, 55, 56, 57, 58, 59, 60, 61, 62, 63, 30, 31, 30,
+ 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 64, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 33, 65, 66, 67, 30, 31, 68, 69, 30, 31, 30, 31, 30, 31, 30, 31,
+
+/* block 4 */
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 70, 33, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 33, 33, 33, 33, 33, 33, 71, 30, 31, 72, 73, 74,
+ 74, 30, 31, 75, 76, 77, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 78, 79, 80, 81, 82, 33, 83, 83, 33, 84, 33, 85, 86, 33, 33, 33,
+ 83, 87, 33, 88, 33, 89, 90, 33, 91, 92, 33, 93, 94, 33, 33, 92,
+ 33, 95, 96, 33, 33, 97, 33, 33, 33, 33, 33, 33, 33, 98, 33, 33,
+
+/* block 5 */
+ 99, 33, 33, 99, 33, 33, 33,100, 99,101,102,102,103, 33, 33, 33,
+ 33, 33,104, 33, 20, 33, 33, 33, 33, 33, 33, 33, 33, 33,105, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+106,106,106,106,106,106,106,106,106,107,107,107,107,107,107,107,
+107,107, 14, 14, 14, 14,107,107,107,107,107,107,107,107,107,107,
+107,107, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+106,106,106,106,106, 14, 14, 14, 14, 14,108,108,107, 14,107, 14,
+ 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+
+/* block 6 */
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,110,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+111,112,111,112,107,113,111,112,114,114,115,116,116,116,  4,117,
+
+/* block 7 */
+114,114,114,114,113, 14,118,  4,119,119,119,114,120,114,121,121,
+122,123,124,123,123,125,123,123,126,127,128,123,129,123,123,123,
+130,131,114,132,123,123,133,123,123,134,123,123,135,136,136,136,
+122,137,138,137,137,139,137,137,140,141,142,137,143,137,137,137,
+144,145,146,147,137,137,148,137,137,149,137,137,150,151,151,152,
+153,154,155,155,155,156,157,158,111,112,111,112,111,112,111,112,
+111,112,159,160,159,160,159,160,159,160,159,160,159,160,159,160,
+161,162,163,164,165,166,167,111,112,168,111,112,122,169,169,169,
+
+/* block 8 */
+170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,170,
+171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,
+171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,171,
+172,172,172,172,172,172,172,172,172,172,172,172,172,172,172,172,
+172,172,172,172,172,172,172,172,172,172,172,172,172,172,172,172,
+173,173,173,173,173,173,173,173,173,173,173,173,173,173,173,173,
+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,
+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,
+
+/* block 9 */
+174,175,176,177,177,109,109,177,178,178,174,175,174,175,174,175,
+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,
+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,
+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,
+179,174,175,174,175,174,175,174,175,174,175,174,175,174,175,180,
+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,
+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,
+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,
+
+/* block 10 */
+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,
+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,
+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,
+114,181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,
+181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,181,
+181,181,181,181,181,181,181,114,114,182,183,183,183,183,183,183,
+114,184,184,184,184,184,184,184,184,184,184,184,184,184,184,184,
+184,184,184,184,184,184,184,184,184,184,184,184,184,184,184,184,
+
+/* block 11 */
+184,184,184,184,184,184,184,185,114,  4,186,114,114,187,187,188,
+114,189,189,189,189,189,189,189,189,189,189,189,189,189,189,189,
+189,189,189,189,189,189,189,189,189,189,189,189,189,189,189,189,
+189,189,189,189,189,189,189,189,189,189,189,189,189,189,190,189,
+191,189,189,191,189,189,191,189,114,114,114,114,114,114,114,114,
+192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,192,
+192,192,192,192,192,192,192,192,192,192,192,114,114,114,114,114,
+192,192,192,191,191,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 12 */
+193,193,193,193,193, 22,194,194,194,195,195,196,  4,195,197,197,
+198,198,198,198,198,198,198,198,198,198,198,  4, 22,114,195,  4,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+107,199,199,199,199,199,199,199,199,199,199,109,109,109,109,109,
+109,109,109,109,109,109,198,198,198,198,198,198,198,198,198,198,
+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,195,195,195,195,199,199,
+109,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+
+/* block 13 */
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,195,199,198,198,198,198,198,198,198, 22,197,198,
+198,198,198,198,198,200,200,198,198,197,198,198,198,198,199,199,
+201,201,201,201,201,201,201,201,201,201,199,199,199,197,197,199,
+
+/* block 14 */
+202,202,202,202,202,202,202,202,202,202,202,202,202,202,114,203,
+204,205,204,204,204,204,204,204,204,204,204,204,204,204,204,204,
+204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,204,
+205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,205,
+205,205,205,205,205,205,205,205,205,205,205,114,114,204,204,204,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+
+/* block 15 */
+206,206,206,206,206,206,206,206,206,206,206,206,206,206,206,206,
+206,206,206,206,206,206,206,206,206,206,206,206,206,206,206,206,
+206,206,206,206,206,206,207,207,207,207,207,207,207,207,207,207,
+207,206,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+208,208,208,208,208,208,208,208,208,208,209,209,209,209,209,209,
+209,209,209,209,209,209,209,209,209,209,209,209,209,209,209,209,
+209,209,209,209,209,209,209,209,209,209,209,210,210,210,210,210,
+210,210,210,210,211,211,212,213,213,213,211,114,114,114,114,114,
+
+/* block 16 */
+214,214,214,214,214,214,214,214,214,214,214,214,214,214,214,214,
+214,214,214,214,214,214,215,215,215,215,216,215,215,215,215,215,
+215,215,215,215,216,215,215,215,216,215,215,215,215,215,114,114,
+217,217,217,217,217,217,217,217,217,217,217,217,217,217,217,114,
+218,218,218,218,218,218,218,218,218,218,218,218,218,218,218,218,
+218,218,218,218,218,218,218,218,218,219,219,219,114,114,220,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 17 */
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,198,198,198,198,198,198,198,198,198,198,198,198,
+198,198,198,198,198,198,198,198,198,198,198,198,198,198,198,198,
+
+/* block 18 */
+221,221,221,222,223,223,223,223,223,223,223,223,223,223,223,223,
+223,223,223,223,223,223,223,223,223,223,223,223,223,223,223,223,
+223,223,223,223,223,223,223,223,223,223,223,223,223,223,223,223,
+223,223,223,223,223,223,223,223,223,223,221,222,221,223,222,222,
+222,221,221,221,221,221,221,221,221,222,222,222,222,221,222,222,
+223,109,109,221,221,221,221,221,223,223,223,223,223,223,223,223,
+223,223,221,221,  4,  4,224,224,224,224,224,224,224,224,224,224,
+225,226,223,223,223,223,223,223,223,223,223,223,223,223,223,223,
+
+/* block 19 */
+227,228,229,229,114,227,227,227,227,227,227,227,227,114,114,227,
+227,114,114,227,227,227,227,227,227,227,227,227,227,227,227,227,
+227,227,227,227,227,227,227,227,227,114,227,227,227,227,227,227,
+227,114,227,114,114,114,227,227,227,227,114,114,228,227,230,229,
+229,228,228,228,228,114,114,229,229,114,114,229,229,228,227,114,
+114,114,114,114,114,114,114,230,114,114,114,114,227,227,114,227,
+227,227,228,228,114,114,231,231,231,231,231,231,231,231,231,231,
+227,227,232,232,233,233,233,233,233,233,234,232,114,114,114,114,
+
+/* block 20 */
+114,235,235,236,114,237,237,237,237,237,237,114,114,114,114,237,
+237,114,114,237,237,237,237,237,237,237,237,237,237,237,237,237,
+237,237,237,237,237,237,237,237,237,114,237,237,237,237,237,237,
+237,114,237,237,114,237,237,114,237,237,114,114,235,114,236,236,
+236,235,235,114,114,114,114,235,235,114,114,235,235,235,114,114,
+114,235,114,114,114,114,114,114,114,237,237,237,237,114,237,114,
+114,114,114,114,114,114,238,238,238,238,238,238,238,238,238,238,
+235,235,237,237,237,235,114,114,114,114,114,114,114,114,114,114,
+
+/* block 21 */
+114,239,239,240,114,241,241,241,241,241,241,241,241,241,114,241,
+241,241,114,241,241,241,241,241,241,241,241,241,241,241,241,241,
+241,241,241,241,241,241,241,241,241,114,241,241,241,241,241,241,
+241,114,241,241,114,241,241,241,241,241,114,114,239,241,240,240,
+240,239,239,239,239,239,114,239,239,240,114,240,240,239,114,114,
+241,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+241,241,239,239,114,114,242,242,242,242,242,242,242,242,242,242,
+243,244,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 22 */
+114,245,246,246,114,247,247,247,247,247,247,247,247,114,114,247,
+247,114,114,247,247,247,247,247,247,247,247,247,247,247,247,247,
+247,247,247,247,247,247,247,247,247,114,247,247,247,247,247,247,
+247,114,247,247,114,247,247,247,247,247,114,114,245,247,248,245,
+246,245,245,245,245,114,114,246,246,114,114,246,246,245,114,114,
+114,114,114,114,114,114,245,248,114,114,114,114,247,247,114,247,
+247,247,245,245,114,114,249,249,249,249,249,249,249,249,249,249,
+250,247,251,251,251,251,251,251,114,114,114,114,114,114,114,114,
+
+/* block 23 */
+114,114,252,253,114,253,253,253,253,253,253,114,114,114,253,253,
+253,114,253,253,253,253,114,114,114,253,253,114,253,114,253,253,
+114,114,114,253,253,114,114,114,253,253,253,114,114,114,253,253,
+253,253,253,253,253,253,253,253,253,253,114,114,114,114,254,255,
+252,255,255,114,114,114,255,255,255,114,255,255,255,252,114,114,
+253,114,114,114,114,114,114,254,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,256,256,256,256,256,256,256,256,256,256,
+257,257,257,258,258,258,258,258,258,259,258,114,114,114,114,114,
+
+/* block 24 */
+260,261,261,261,114,262,262,262,262,262,262,262,262,114,262,262,
+262,114,262,262,262,262,262,262,262,262,262,262,262,262,262,262,
+262,262,262,262,262,262,262,262,262,114,262,262,262,262,262,262,
+262,262,262,262,262,262,262,262,262,262,114,114,114,262,260,260,
+260,261,261,261,261,114,260,260,260,114,260,260,260,260,114,114,
+114,114,114,114,114,260,260,114,262,262,114,114,114,114,114,114,
+262,262,260,260,114,114,263,263,263,263,263,263,263,263,263,263,
+114,114,114,114,114,114,114,114,264,264,264,264,264,264,264,265,
+
+/* block 25 */
+114,266,267,267,114,268,268,268,268,268,268,268,268,114,268,268,
+268,114,268,268,268,268,268,268,268,268,268,268,268,268,268,268,
+268,268,268,268,268,268,268,268,268,114,268,268,268,268,268,268,
+268,268,268,268,114,268,268,268,268,268,114,114,266,268,267,266,
+267,267,269,267,267,114,266,267,267,114,267,267,266,266,114,114,
+114,114,114,114,114,269,269,114,114,114,114,114,114,114,268,114,
+268,268,266,266,114,114,270,270,270,270,270,270,270,270,270,270,
+114,268,268,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 26 */
+114,271,272,272,114,273,273,273,273,273,273,273,273,114,273,273,
+273,114,273,273,273,273,273,273,273,273,273,273,273,273,273,273,
+273,273,273,273,273,273,273,273,273,273,273,273,273,273,273,273,
+273,273,273,273,273,273,273,273,273,273,273,114,114,273,274,272,
+272,271,271,271,271,114,272,272,272,114,272,272,272,271,273,114,
+114,114,114,114,114,114,114,274,114,114,114,114,114,114,114,114,
+273,273,271,271,114,114,275,275,275,275,275,275,275,275,275,275,
+276,276,276,276,276,276,114,114,114,277,273,273,273,273,273,273,
+
+/* block 27 */
+114,114,278,278,114,279,279,279,279,279,279,279,279,279,279,279,
+279,279,279,279,279,279,279,114,114,114,279,279,279,279,279,279,
+279,279,279,279,279,279,279,279,279,279,279,279,279,279,279,279,
+279,279,114,279,279,279,279,279,279,279,279,279,114,279,114,114,
+279,279,279,279,279,279,279,114,114,114,280,114,114,114,114,281,
+278,278,280,280,280,114,280,114,278,278,278,278,278,278,278,281,
+114,114,114,114,114,114,282,282,282,282,282,282,282,282,282,282,
+114,114,278,278,283,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 28 */
+114,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,
+284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,
+284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,284,
+284,285,284,286,285,285,285,285,285,285,285,114,114,114,114,  5,
+284,284,284,284,284,284,287,285,285,285,285,285,285,285,285,288,
+289,289,289,289,289,289,289,289,289,289,288,288,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 29 */
+114,290,290,114,290,114,114,290,290,114,290,114,114,290,114,114,
+114,114,114,114,290,290,290,290,114,290,290,290,290,290,290,290,
+114,290,290,290,114,290,114,290,114,114,290,290,114,290,290,290,
+290,291,290,292,291,291,291,291,291,291,114,291,291,290,114,114,
+290,290,290,290,290,114,293,114,291,291,291,291,291,291,114,114,
+294,294,294,294,294,294,294,294,294,294,114,114,290,290,290,290,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 30 */
+295,296,296,296,297,297,297,297,297,297,297,297,297,297,297,297,
+297,297,297,296,297,296,296,296,298,298,296,296,296,296,296,296,
+299,299,299,299,299,299,299,299,299,299,300,300,300,300,300,300,
+300,300,300,300,296,298,296,298,296,298,301,302,301,302,303,303,
+295,295,295,295,295,295,295,295,114,295,295,295,295,295,295,295,
+295,295,295,295,295,295,295,295,295,295,295,295,295,295,295,295,
+295,295,295,295,295,295,295,295,295,295,295,295,295,114,114,114,
+114,298,298,298,298,298,298,298,298,298,298,298,298,298,298,303,
+
+/* block 31 */
+298,298,298,298,298,297,298,298,295,295,295,295,295,298,298,298,
+298,298,298,298,298,298,298,298,114,298,298,298,298,298,298,298,
+298,298,298,298,298,298,298,298,298,298,298,298,298,298,298,298,
+298,298,298,298,298,298,298,298,298,298,298,298,298,114,296,296,
+296,296,296,296,296,296,298,296,296,296,296,296,296,114,296,296,
+297,297,297,297,297, 19, 19, 19, 19,297,297,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 32 */
+304,304,304,304,304,304,304,304,304,304,304,304,304,304,304,304,
+304,304,304,304,304,304,304,304,304,304,304,304,304,304,304,304,
+304,304,304,304,304,304,304,304,304,304,304,305,305,306,306,306,
+306,307,306,306,306,306,306,306,305,306,306,307,307,306,306,304,
+308,308,308,308,308,308,308,308,308,308,309,309,309,309,309,309,
+304,304,304,304,304,304,307,307,306,306,304,304,304,304,306,306,
+306,304,305,305,305,304,304,305,305,305,305,305,305,305,304,304,
+304,306,306,306,306,304,304,304,304,304,304,304,304,304,304,304,
+
+/* block 33 */
+304,304,306,305,307,306,306,305,305,305,305,305,305,306,304,305,
+308,308,308,308,308,308,308,308,308,308,305,305,305,306,310,310,
+311,311,311,311,311,311,311,311,311,311,311,311,311,311,311,311,
+311,311,311,311,311,311,311,311,311,311,311,311,311,311,311,311,
+311,311,311,311,311,311,114,311,114,114,114,114,114,311,114,114,
+312,312,312,312,312,312,312,312,312,312,312,312,312,312,312,312,
+312,312,312,312,312,312,312,312,312,312,312,312,312,312,312,312,
+312,312,312,312,312,312,312,312,312,312,312,  4,313,312,312,312,
+
+/* block 34 */
+314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,
+314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,
+314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,
+314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,
+314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,
+314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,
+315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,
+315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,
+
+/* block 35 */
+315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,
+315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,
+315,315,315,315,315,315,315,315,316,316,316,316,316,316,316,316,
+316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,
+316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,
+316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,
+316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,
+316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,
+
+/* block 36 */
+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,
+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,
+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,
+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,
+317,317,317,317,317,317,317,317,317,114,317,317,317,317,114,114,
+317,317,317,317,317,317,317,114,317,114,317,317,317,317,114,114,
+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,
+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,
+
+/* block 37 */
+317,317,317,317,317,317,317,317,317,114,317,317,317,317,114,114,
+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,
+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,
+317,114,317,317,317,317,114,114,317,317,317,317,317,317,317,114,
+317,114,317,317,317,317,114,114,317,317,317,317,317,317,317,317,
+317,317,317,317,317,317,317,114,317,317,317,317,317,317,317,317,
+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,
+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,
+
+/* block 38 */
+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,
+317,114,317,317,317,317,114,114,317,317,317,317,317,317,317,317,
+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,
+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,
+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,
+317,317,317,317,317,317,317,317,317,317,317,114,114,318,318,318,
+319,319,319,319,319,319,319,319,319,320,320,320,320,320,320,320,
+320,320,320,320,320,320,320,320,320,320,320,320,320,114,114,114,
+
+/* block 39 */
+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,
+321,321,321,321,321,321,321,321,321,321,114,114,114,114,114,114,
+322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,
+322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,
+322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,
+322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,
+322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,322,
+322,322,322,322,322,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 40 */
+323,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+
+/* block 41 */
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+
+/* block 42 */
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,325,325,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+
+/* block 43 */
+326,327,327,327,327,327,327,327,327,327,327,327,327,327,327,327,
+327,327,327,327,327,327,327,327,327,327,327,328,329,114,114,114,
+330,330,330,330,330,330,330,330,330,330,330,330,330,330,330,330,
+330,330,330,330,330,330,330,330,330,330,330,330,330,330,330,330,
+330,330,330,330,330,330,330,330,330,330,330,330,330,330,330,330,
+330,330,330,330,330,330,330,330,330,330,330,330,330,330,330,330,
+330,330,330,330,330,330,330,330,330,330,330,  4,  4,  4,331,331,
+331,330,330,330,330,330,330,330,330,114,114,114,114,114,114,114,
+
+/* block 44 */
+332,332,332,332,332,332,332,332,332,332,332,332,332,114,332,332,
+332,332,333,333,333,114,114,114,114,114,114,114,114,114,114,114,
+334,334,334,334,334,334,334,334,334,334,334,334,334,334,334,334,
+334,334,335,335,335,  4,  4,114,114,114,114,114,114,114,114,114,
+336,336,336,336,336,336,336,336,336,336,336,336,336,336,336,336,
+336,336,337,337,114,114,114,114,114,114,114,114,114,114,114,114,
+338,338,338,338,338,338,338,338,338,338,338,338,338,114,338,338,
+338,114,339,339,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 45 */
+340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,
+340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,
+340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,340,
+340,340,340,340,341,341,342,341,341,341,341,341,341,341,342,342,
+342,342,342,342,342,342,341,342,342,341,341,341,341,341,341,341,
+341,341,341,341,343,343,343,344,343,343,343,345,340,341,114,114,
+346,346,346,346,346,346,346,346,346,346,114,114,114,114,114,114,
+347,347,347,347,347,347,347,347,347,347,114,114,114,114,114,114,
+
+/* block 46 */
+348,348,  4,  4,348,  4,349,348,348,348,348,350,350,350,351,114,
+352,352,352,352,352,352,352,352,352,352,114,114,114,114,114,114,
+353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,
+353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,
+353,353,353,354,353,353,353,353,353,353,353,353,353,353,353,353,
+353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,
+353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,
+353,353,353,353,353,353,353,353,114,114,114,114,114,114,114,114,
+
+/* block 47 */
+353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,
+353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,353,
+353,353,353,353,353,353,353,353,353,350,353,114,114,114,114,114,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,324,
+324,324,324,324,324,324,114,114,114,114,114,114,114,114,114,114,
+
+/* block 48 */
+355,355,355,355,355,355,355,355,355,355,355,355,355,355,355,355,
+355,355,355,355,355,355,355,355,355,355,355,355,355,355,355,114,
+356,356,356,357,357,357,357,356,356,357,357,357,114,114,114,114,
+357,357,356,357,357,357,357,357,357,356,356,356,114,114,114,114,
+358,114,114,114,359,359,360,360,360,360,360,360,360,360,360,360,
+361,361,361,361,361,361,361,361,361,361,361,361,361,361,361,361,
+361,361,361,361,361,361,361,361,361,361,361,361,361,361,114,114,
+361,361,361,361,361,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 49 */
+362,362,362,362,362,362,362,362,362,362,362,362,362,362,362,362,
+362,362,362,362,362,362,362,362,362,362,362,362,362,362,362,362,
+362,362,362,362,362,362,362,362,362,362,362,362,114,114,114,114,
+363,363,363,363,363,364,364,364,363,363,364,363,363,363,363,363,
+363,362,362,362,362,362,362,362,363,363,114,114,114,114,114,114,
+365,365,365,365,365,365,365,365,365,365,366,114,114,114,367,367,
+368,368,368,368,368,368,368,368,368,368,368,368,368,368,368,368,
+368,368,368,368,368,368,368,368,368,368,368,368,368,368,368,368,
+
+/* block 50 */
+369,369,369,369,369,369,369,369,369,369,369,369,369,369,369,369,
+369,369,369,369,369,369,369,370,370,371,371,370,114,114,372,372,
+373,373,373,373,373,373,373,373,373,373,373,373,373,373,373,373,
+373,373,373,373,373,373,373,373,373,373,373,373,373,373,373,373,
+373,373,373,373,373,373,373,373,373,373,373,373,373,373,373,373,
+373,373,373,373,373,374,375,374,375,375,375,375,375,375,375,114,
+375,376,375,376,376,375,375,375,375,375,375,375,375,374,374,374,
+374,374,374,375,375,375,375,375,375,375,375,375,375,114,114,375,
+
+/* block 51 */
+377,377,377,377,377,377,377,377,377,377,114,114,114,114,114,114,
+377,377,377,377,377,377,377,377,377,377,114,114,114,114,114,114,
+378,378,378,378,378,378,378,379,378,378,378,378,378,378,114,114,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,380,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 52 */
+381,381,381,381,382,383,383,383,383,383,383,383,383,383,383,383,
+383,383,383,383,383,383,383,383,383,383,383,383,383,383,383,383,
+383,383,383,383,383,383,383,383,383,383,383,383,383,383,383,383,
+383,383,383,383,381,382,381,381,381,381,381,382,381,382,382,382,
+382,382,381,382,382,383,383,383,383,383,383,383,114,114,114,114,
+384,384,384,384,384,384,384,384,384,384,385,385,385,385,385,385,
+385,386,386,386,386,386,386,386,386,386,386,381,381,381,381,381,
+381,381,381,381,386,386,386,386,386,386,386,386,386,114,114,114,
+
+/* block 53 */
+387,387,388,389,389,389,389,389,389,389,389,389,389,389,389,389,
+389,389,389,389,389,389,389,389,389,389,389,389,389,389,389,389,
+389,388,387,387,387,387,388,388,387,387,388,387,387,387,389,389,
+390,390,390,390,390,390,390,390,390,390,389,389,389,389,389,389,
+391,391,391,391,391,391,391,391,391,391,391,391,391,391,391,391,
+391,391,391,391,391,391,391,391,391,391,391,391,391,391,391,391,
+391,391,391,391,391,391,392,393,392,392,393,393,393,392,393,392,
+392,392,393,393,114,114,114,114,114,114,114,114,394,394,394,394,
+
+/* block 54 */
+395,395,395,395,395,395,395,395,395,395,395,395,395,395,395,395,
+395,395,395,395,395,395,395,395,395,395,395,395,395,395,395,395,
+395,395,395,395,396,396,396,396,396,396,396,396,397,397,397,397,
+397,397,397,397,396,396,397,397,114,114,114,398,398,398,398,398,
+399,399,399,399,399,399,399,399,399,399,114,114,114,395,395,395,
+400,400,400,400,400,400,400,400,400,400,401,401,401,401,401,401,
+401,401,401,401,401,401,401,401,401,401,401,401,401,401,401,401,
+401,401,401,401,401,401,401,401,402,402,402,402,402,402,403,403,
+
+/* block 55 */
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+404,404,404,404,404,404,404,404,114,114,114,114,114,114,114,114,
+109,109,109,  4,109,109,109,109,109,109,109,109,109,109,109,109,
+109,405,109,109,109,109,109,109,109,406,406,406,406,109,406,406,
+406,406,405,405,109,406,406,114,109,109,114,114,114,114,114,114,
+
+/* block 56 */
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33,122,122,122,122,122,407,106,106,106,106,
+106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,
+106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,
+106,106,106,106,106,106,106,106,106,106,106,106,106,115,115,115,
+115,115,106,106,106,106,115,115,115,115,115, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33,408,409, 33, 33, 33,410, 33, 33,
+
+/* block 57 */
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,106,106,106,106,106,
+106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,
+106,106,106,106,106,106,106,106,106,106,106,106,106,106,106,115,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,114,114,114,114,114,114,109,109,109,109,
+
+/* block 58 */
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+411,412, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+
+/* block 59 */
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 33, 33, 33, 33, 33,413, 33, 33,414, 33,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+
+/* block 60 */
+415,415,415,415,415,415,415,415,416,416,416,416,416,416,416,416,
+415,415,415,415,415,415,114,114,416,416,416,416,416,416,114,114,
+415,415,415,415,415,415,415,415,416,416,416,416,416,416,416,416,
+415,415,415,415,415,415,415,415,416,416,416,416,416,416,416,416,
+415,415,415,415,415,415,114,114,416,416,416,416,416,416,114,114,
+122,415,122,415,122,415,122,415,114,416,114,416,114,416,114,416,
+415,415,415,415,415,415,415,415,416,416,416,416,416,416,416,416,
+417,417,418,418,418,418,419,419,420,420,421,421,422,422,114,114,
+
+/* block 61 */
+415,415,415,415,415,415,415,415,423,423,423,423,423,423,423,423,
+415,415,415,415,415,415,415,415,423,423,423,423,423,423,423,423,
+415,415,415,415,415,415,415,415,423,423,423,423,423,423,423,423,
+415,415,122,424,122,114,122,122,416,416,425,425,426,113,427,113,
+113,113,122,424,122,114,122,122,428,428,428,428,426,113,113,113,
+415,415,122,122,114,114,122,122,416,416,429,429,114,113,113,113,
+415,415,122,122,122,163,122,122,416,416,430,430,168,113,113,113,
+114,114,122,424,122,114,122,122,431,431,432,432,426,113,113,114,
+
+/* block 62 */
+  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 22,433,433, 22, 22,
+  9,  9,  9,  9,  9,  9,  4,  4, 21, 25,  6, 21, 21, 25,  6, 21,
+  4,  4,  4,  4,  4,  4,  4,  4,434,435, 22, 22, 22, 22, 22,  3,
+  4,  4,  4,  4,  4,  4,  4,  4,  4, 21, 25,  4,  4,  4,  4, 15,
+ 15,  4,  4,  4,  8,  6,  7,  4,  4,  4,  4,  4,  4,  4,  4,  4,
+  4,  4,  8,  4, 15,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  3,
+ 22, 22, 22, 22, 22,436, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+ 23,106,114,114, 23, 23, 23, 23, 23, 23,  8,  8,  8,  6,  7,106,
+
+/* block 63 */
+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,  8,  8,  8,  6,  7,114,
+106,106,106,106,106,106,106,106,106,106,106,106,106,114,114,114,
+  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
+  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+109,109,109,109,109,109,109,109,109,109,109,109,109,380,380,380,
+380,109,380,380,380,109,109,109,109,109,109,109,109,109,109,109,
+109,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 64 */
+ 19, 19,437, 19, 19, 19, 19,437, 19, 19,438,437,437,437,438,438,
+437,437,437,438, 19,437, 19, 19,  8,437,437,437,437,437, 19, 19,
+ 19, 19, 19, 19,437, 19,439, 19,437, 19,440,441,437,437, 19,438,
+437,437,442,437,438,406,406,406,406,438, 19, 19,438,438,437,437,
+  8,  8,  8,  8,  8,437,438,438,438,438, 19,  8, 19, 19,443, 19,
+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+444,444,444,444,444,444,444,444,444,444,444,444,444,444,444,444,
+445,445,445,445,445,445,445,445,445,445,445,445,445,445,445,445,
+
+/* block 65 */
+446,446,446, 30, 31,446,446,446,446, 23,114,114,114,114,114,114,
+  8,  8,  8,  8,  8, 19, 19, 19, 19, 19,  8,  8, 19, 19, 19, 19,
+  8, 19, 19,  8, 19, 19,  8, 19, 19, 19, 19, 19, 19, 19,  8, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,  8,  8,
+ 19, 19,  8, 19,  8, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+
+/* block 66 */
+  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+
+/* block 67 */
+ 19, 19, 19, 19, 19, 19, 19, 19,  6,  7,  6,  7, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+  8,  8, 19, 19, 19, 19, 19, 19, 19,  6,  7, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,  8, 19, 19, 19,
+
+/* block 68 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,  8,  8,  8,  8,  8,
+  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+  8,  8,  8,  8, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,  8,  8,  8,  8,
+  8,  8, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,
+
+/* block 69 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+
+/* block 70 */
+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19,447,447,447,447,447,447,447,447,447,447,
+447,447,447,447,447,447,447,447,447,447,447,447,447,447,447,447,
+448,448,448,448,448,448,448,448,448,448,448,448,448,448,448,448,
+448,448,448,448,448,448,448,448,448,448, 23, 23, 23, 23, 23, 23,
+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+
+/* block 71 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+
+/* block 72 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19,  8, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19,  8, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19,  8,  8,  8,  8,  8,  8,  8,  8,
+
+/* block 73 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,  8,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+
+/* block 74 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19,  6,  7,  6,  7,  6,  7,  6,  7,
+  6,  7,  6,  7,  6,  7, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+
+/* block 75 */
+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+ 23, 23, 23, 23, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+  8,  8,  8,  8,  8,  6,  7,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+  8,  8,  8,  8,  8,  8,  6,  7,  6,  7,  6,  7,  6,  7,  6,  7,
+  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+
+/* block 76 */
+449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,
+449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,
+449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,
+449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,
+449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,
+449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,
+449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,
+449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,449,
+
+/* block 77 */
+  8,  8,  8,  6,  7,  6,  7,  6,  7,  6,  7,  6,  7,  6,  7,  6,
+  7,  6,  7,  6,  7,  6,  7,  6,  7,  8,  8,  8,  8,  8,  8,  8,
+  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+  8,  8,  8,  8,  8,  8,  8,  8,  6,  7,  6,  7,  8,  8,  8,  8,
+  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  6,  7,  8,  8,
+
+/* block 78 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+  8,  8,  8,  8,  8, 19, 19,  8,  8,  8,  8,  8,  8, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19,114,114, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+
+/* block 79 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19,114,114, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19,114, 19, 19, 19, 19, 19, 19,
+ 19, 19,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 80 */
+450,450,450,450,450,450,450,450,450,450,450,450,450,450,450,450,
+450,450,450,450,450,450,450,450,450,450,450,450,450,450,450,450,
+450,450,450,450,450,450,450,450,450,450,450,450,450,450,450,114,
+451,451,451,451,451,451,451,451,451,451,451,451,451,451,451,451,
+451,451,451,451,451,451,451,451,451,451,451,451,451,451,451,451,
+451,451,451,451,451,451,451,451,451,451,451,451,451,451,451,114,
+ 30, 31,452,453,454,455,456, 30, 31, 30, 31, 30, 31,457,458,459,
+460, 33, 30, 31, 33, 30, 31, 33, 33, 33, 33, 33,106,106,461,461,
+
+/* block 81 */
+159,160,159,160,159,160,159,160,159,160,159,160,159,160,159,160,
+159,160,159,160,159,160,159,160,159,160,159,160,159,160,159,160,
+159,160,159,160,159,160,159,160,159,160,159,160,159,160,159,160,
+159,160,159,160,159,160,159,160,159,160,159,160,159,160,159,160,
+159,160,159,160,159,160,159,160,159,160,159,160,159,160,159,160,
+159,160,159,160,159,160,159,160,159,160,159,160,159,160,159,160,
+159,160,159,160,462,463,463,463,463,463,463,159,160,159,160,464,
+464,464,159,160,114,114,114,114,114,465,465,465,465,466,465,465,
+
+/* block 82 */
+467,467,467,467,467,467,467,467,467,467,467,467,467,467,467,467,
+467,467,467,467,467,467,467,467,467,467,467,467,467,467,467,467,
+467,467,467,467,467,467,114,467,114,114,114,114,114,467,114,114,
+468,468,468,468,468,468,468,468,468,468,468,468,468,468,468,468,
+468,468,468,468,468,468,468,468,468,468,468,468,468,468,468,468,
+468,468,468,468,468,468,468,468,468,468,468,468,468,468,468,468,
+468,468,468,468,468,468,468,468,114,114,114,114,114,114,114,469,
+470,114,114,114,114,114,114,114,114,114,114,114,114,114,114,471,
+
+/* block 83 */
+317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,317,
+317,317,317,317,317,317,317,114,114,114,114,114,114,114,114,114,
+317,317,317,317,317,317,317,114,317,317,317,317,317,317,317,114,
+317,317,317,317,317,317,317,114,317,317,317,317,317,317,317,114,
+317,317,317,317,317,317,317,114,317,317,317,317,317,317,317,114,
+317,317,317,317,317,317,317,114,317,317,317,317,317,317,317,114,
+177,177,177,177,177,177,177,177,177,177,177,177,177,177,177,177,
+177,177,177,177,177,177,177,177,177,177,177,177,177,177,177,177,
+
+/* block 84 */
+  4,  4, 21, 25, 21, 25,  4,  4,  4, 21, 25,  4, 21, 25,  4,  4,
+  4,  4,  4,  4,  4,  4,  4,  9,  4,  4,  9,  4, 21, 25,  4,  4,
+ 21, 25,  6,  7,  6,  7,  6,  7,  6,  7,  4,  4,  4,  4,  4,107,
+  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  9,  9,  4,  4,  4,  4,
+  9,  4,  6,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 85 */
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+472,472,472,472,472,472,472,472,472,472,114,472,472,472,472,472,
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+472,472,472,472,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 86 */
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+
+/* block 87 */
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,472,
+472,472,472,472,472,472,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,
+
+/* block 88 */
+  3,  4,  4,  4, 19,473,406,474,  6,  7,  6,  7,  6,  7,  6,  7,
+  6,  7, 19, 19,  6,  7,  6,  7,  6,  7,  6,  7,  9,  6,  7,  7,
+ 19,474,474,474,474,474,474,474,474,474,109,109,109,109,475,475,
+  9,107,107,107,107,107, 19, 19,474,474,474,473,406,  4, 19, 19,
+114,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,
+476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,
+476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,
+476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,
+
+/* block 89 */
+476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,476,
+476,476,476,476,476,476,476,114,114,109,109, 14, 14,477,477,476,
+  9,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,
+478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,
+478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,
+478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,
+478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,
+478,478,478,478,478,478,478,478,478,478,478,  4,107,479,479,478,
+
+/* block 90 */
+114,114,114,114,114,480,480,480,480,480,480,480,480,480,480,480,
+480,480,480,480,480,480,480,480,480,480,480,480,480,480,480,480,
+480,480,480,480,480,480,480,480,480,480,480,480,480,480,114,114,
+114,481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,
+481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,
+481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,
+481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,
+481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,
+
+/* block 91 */
+481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,114,
+ 19, 19, 23, 23, 23, 23, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+480,480,480,480,480,480,480,480,480,480,480,480,480,480,480,480,
+480,480,480,480,480,480,480,480,480,480,480,114,114,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19,114,114,114,114,114,114,114,114,114,114,114,114,
+478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,
+
+/* block 92 */
+482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,
+482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,114,
+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 23, 23, 23, 23, 23, 23, 23, 23,
+ 19, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,482,
+482,482,482,482,482,482,482,482,482,482,482,482,482,482,482, 19,
+
+/* block 93 */
+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,
+483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,
+483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,114,
+
+/* block 94 */
+483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,
+483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,
+483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,
+483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,
+483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,483,
+483,483,483,483,483,483,483,483, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+
+/* block 95 */
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+
+/* block 96 */
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,114,114,114,114,114,114,114,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+
+/* block 97 */
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 98 */
+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,
+485,485,485,485,485,486,485,485,485,485,485,485,485,485,485,485,
+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,
+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,
+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,
+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,
+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,
+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,
+
+/* block 99 */
+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,
+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,
+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,
+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,
+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,
+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,
+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,
+485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,485,
+
+/* block 100 */
+485,485,485,485,485,485,485,485,485,485,485,485,485,114,114,114,
+487,487,487,487,487,487,487,487,487,487,487,487,487,487,487,487,
+487,487,487,487,487,487,487,487,487,487,487,487,487,487,487,487,
+487,487,487,487,487,487,487,487,487,487,487,487,487,487,487,487,
+487,487,487,487,487,487,487,114,114,114,114,114,114,114,114,114,
+488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,
+488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,488,
+488,488,488,488,488,488,488,488,489,489,489,489,489,489,490,490,
+
+/* block 101 */
+491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,
+491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,
+491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,
+491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,
+491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,
+491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,
+491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,
+491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,
+
+/* block 102 */
+491,491,491,491,491,491,491,491,491,491,491,491,492,493,493,493,
+491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,491,
+494,494,494,494,494,494,494,494,494,494,491,491,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,
+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,
+174,175,174,175,174,175,174,175,174,175,174,175,174,175,495,177,
+178,178,178,496,177,177,177,177,177,177,177,177,177,177,496,408,
+
+/* block 103 */
+174,175,174,175,174,175,174,175,174,175,174,175,174,175,174,175,
+174,175,174,175,174,175,174,175,174,175,174,175,408,408,114,177,
+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,
+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,
+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,
+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,
+497,497,497,497,497,497,498,498,498,498,498,498,498,498,498,498,
+499,499,500,500,500,500,500,500,114,114,114,114,114,114,114,114,
+
+/* block 104 */
+ 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+ 14, 14, 14, 14, 14, 14, 14,107,107,107,107,107,107,107,107,107,
+ 14, 14, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 33, 33, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+106, 33, 33, 33, 33, 33, 33, 33, 33, 30, 31, 30, 31,501, 30, 31,
+
+/* block 105 */
+ 30, 31, 30, 31, 30, 31, 30, 31,107, 14, 14, 30, 31,502, 33,114,
+ 30, 31, 30, 31, 33, 33, 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,
+ 30, 31, 30, 31, 30, 31, 30, 31, 30, 31,503,504,505,506,114,114,
+507,508,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114, 20,106,106, 33, 20, 20, 20, 20, 20,
+
+/* block 106 */
+509,509,510,509,509,509,510,509,509,509,509,510,509,509,509,509,
+509,509,509,509,509,509,509,509,509,509,509,509,509,509,509,509,
+509,509,509,511,511,510,510,511,512,512,512,512,114,114,114,114,
+ 23, 23, 23, 23, 23, 23, 19, 19,  5, 19,114,114,114,114,114,114,
+513,513,513,513,513,513,513,513,513,513,513,513,513,513,513,513,
+513,513,513,513,513,513,513,513,513,513,513,513,513,513,513,513,
+513,513,513,513,513,513,513,513,513,513,513,513,513,513,513,513,
+513,513,513,513,514,514,514,514,114,114,114,114,114,114,114,114,
+
+/* block 107 */
+515,515,516,516,516,516,516,516,516,516,516,516,516,516,516,516,
+516,516,516,516,516,516,516,516,516,516,516,516,516,516,516,516,
+516,516,516,516,516,516,516,516,516,516,516,516,516,516,516,516,
+516,516,516,516,515,515,515,515,515,515,515,515,515,515,515,515,
+515,515,515,515,517,114,114,114,114,114,114,114,114,114,518,518,
+519,519,519,519,519,519,519,519,519,519,114,114,114,114,114,114,
+221,221,221,221,221,221,221,221,221,221,221,221,221,221,221,221,
+221,221,223,223,223,223,223,223,225,225,225,223,114,114,114,114,
+
+/* block 108 */
+520,520,520,520,520,520,520,520,520,520,521,521,521,521,521,521,
+521,521,521,521,521,521,521,521,521,521,521,521,521,521,521,521,
+521,521,521,521,521,521,522,522,522,522,522,522,522,522,  4,523,
+524,524,524,524,524,524,524,524,524,524,524,524,524,524,524,524,
+524,524,524,524,524,524,524,525,525,525,525,525,525,525,525,525,
+525,525,526,526,114,114,114,114,114,114,114,114,114,114,114,527,
+314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,314,
+314,314,314,314,314,314,314,314,314,314,314,314,314,114,114,114,
+
+/* block 109 */
+528,528,528,529,530,530,530,530,530,530,530,530,530,530,530,530,
+530,530,530,530,530,530,530,530,530,530,530,530,530,530,530,530,
+530,530,530,530,530,530,530,530,530,530,530,530,530,530,530,530,
+530,530,530,528,529,529,528,528,528,528,529,529,528,529,529,529,
+529,531,531,531,531,531,531,531,531,531,531,531,531,531,114,107,
+532,532,532,532,532,532,532,532,532,532,114,114,114,114,531,531,
+304,304,304,304,304,306,533,304,304,304,304,304,304,304,304,304,
+308,308,308,308,308,308,308,308,308,308,304,304,304,304,304,114,
+
+/* block 110 */
+534,534,534,534,534,534,534,534,534,534,534,534,534,534,534,534,
+534,534,534,534,534,534,534,534,534,534,534,534,534,534,534,534,
+534,534,534,534,534,534,534,534,534,535,535,535,535,535,535,536,
+536,535,535,536,536,535,535,114,114,114,114,114,114,114,114,114,
+534,534,534,535,534,534,534,534,534,534,534,534,535,536,114,114,
+537,537,537,537,537,537,537,537,537,537,114,114,538,538,538,538,
+304,304,304,304,304,304,304,304,304,304,304,304,304,304,304,304,
+533,304,304,304,304,304,304,310,310,310,304,305,306,305,304,304,
+
+/* block 111 */
+539,539,539,539,539,539,539,539,539,539,539,539,539,539,539,539,
+539,539,539,539,539,539,539,539,539,539,539,539,539,539,539,539,
+539,539,539,539,539,539,539,539,539,539,539,539,539,539,539,539,
+540,539,540,540,540,539,539,540,540,539,539,539,539,539,540,540,
+539,540,539,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,539,539,541,542,542,
+543,543,543,543,543,543,543,543,543,543,543,544,545,545,544,544,
+546,546,543,547,547,544,545,114,114,114,114,114,114,114,114,114,
+
+/* block 112 */
+114,317,317,317,317,317,317,114,114,317,317,317,317,317,317,114,
+114,317,317,317,317,317,317,114,114,114,114,114,114,114,114,114,
+317,317,317,317,317,317,317,114,317,317,317,317,317,317,317,114,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
+ 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 14,106,106,106,106,
+114,114,114,114, 33,122,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 113 */
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+543,543,543,543,543,543,543,543,543,543,543,543,543,543,543,543,
+543,543,543,543,543,543,543,543,543,543,543,543,543,543,543,543,
+543,543,543,544,544,545,544,544,545,544,544,546,544,545,114,114,
+548,548,548,548,548,548,548,548,548,548,114,114,114,114,114,114,
+
+/* block 114 */
+549,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,549,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,549,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,549,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+549,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+
+/* block 115 */
+550,550,550,550,550,550,550,550,550,550,550,550,549,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,549,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,549,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+549,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,549,550,550,550,
+
+/* block 116 */
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,549,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,549,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+549,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,549,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+
+/* block 117 */
+550,550,550,550,550,550,550,550,549,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,549,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+549,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,549,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,549,550,550,550,550,550,550,550,
+
+/* block 118 */
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,549,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+549,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,549,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,549,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+
+/* block 119 */
+550,550,550,550,549,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+549,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,549,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,549,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,549,550,550,550,550,550,550,550,550,550,550,550,
+
+/* block 120 */
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+549,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,549,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,549,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,549,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+
+/* block 121 */
+550,550,550,550,550,550,550,550,549,550,550,550,550,550,550,550,
+550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,550,
+550,550,550,550,114,114,114,114,114,114,114,114,114,114,114,114,
+315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,315,
+315,315,315,315,315,315,315,114,114,114,114,316,316,316,316,316,
+316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,
+316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,316,
+316,316,316,316,316,316,316,316,316,316,316,316,114,114,114,114,
+
+/* block 122 */
+551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,
+551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,
+551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,
+551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,
+551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,
+551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,
+551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,
+551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,551,
+
+/* block 123 */
+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
+
+/* block 124 */
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,114,114,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+
+/* block 125 */
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 126 */
+ 33, 33, 33, 33, 33, 33, 33,114,114,114,114,114,114,114,114,114,
+114,114,114,185,185,185,185,185,114,114,114,114,114,192,189,192,
+192,192,192,192,192,192,192,192,192,553,192,192,192,192,192,192,
+192,192,192,192,192,192,192,114,192,192,192,192,192,114,192,114,
+192,192,114,192,192,114,192,192,192,192,192,192,192,192,192,192,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+
+/* block 127 */
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,554,554,554,554,554,554,554,554,554,554,554,554,554,554,
+554,554,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+
+/* block 128 */
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+
+/* block 129 */
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,  7,  6,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+
+/* block 130 */
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+114,114,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+199,199,199,199,199,199,199,199,199,199,199,199,196,197,114,114,
+
+/* block 131 */
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+  4,  4,  4,  4,  4,  4,  4,  6,  7,  4,114,114,114,114,114,114,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,114,114,
+  4,  9,  9, 15, 15,  6,  7,  6,  7,  6,  7,  6,  7,  6,  7,  6,
+  7,  6,  7,  6,  7,  4,  4,  6,  7,  4,  4,  4,  4, 15, 15, 15,
+  4,  4,  4,114,  4,  4,  4,  4,  9,  6,  7,  6,  7,  6,  7,  4,
+  4,  4,  8,  9,  8,  8,  8,114,  4,  5,  4,  4,114,114,114,114,
+199,199,199,199,199,114,199,199,199,199,199,199,199,199,199,199,
+
+/* block 132 */
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,114,114, 22,
+
+/* block 133 */
+114,  4,  4,  4,  5,  4,  4,  4,  6,  7,  4,  8,  4,  9,  4,  4,
+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,  4,  4,  8,  8,  8,  4,
+  4, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+ 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,  6,  4,  7, 14, 15,
+ 14, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,  6,  8,  7,  8,  6,
+  7,  4,  6,  7,  4,  4,478,478,478,478,478,478,478,478,478,478,
+107,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,
+
+/* block 134 */
+478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,478,
+478,478,478,478,478,478,478,478,478,478,478,478,478,478,555,555,
+481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,
+481,481,481,481,481,481,481,481,481,481,481,481,481,481,481,114,
+114,114,481,481,481,481,481,481,114,114,481,481,481,481,481,481,
+114,114,481,481,481,481,481,481,114,114,481,481,481,114,114,114,
+  5,  5,  8, 14, 19,  5,  5,114, 19,  8,  8,  8,  8, 19, 19,114,
+436,436,436,436,436,436,436,436,436, 22, 22, 22, 19, 19,114,114,
+
+/* block 135 */
+556,556,556,556,556,556,556,556,556,556,556,556,114,556,556,556,
+556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,
+556,556,556,556,556,556,556,114,556,556,556,556,556,556,556,556,
+556,556,556,556,556,556,556,556,556,556,556,114,556,556,114,556,
+556,556,556,556,556,556,556,556,556,556,556,556,556,556,114,114,
+556,556,556,556,556,556,556,556,556,556,556,556,556,556,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 136 */
+556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,
+556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,
+556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,
+556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,
+556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,
+556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,
+556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,556,
+556,556,556,556,556,556,556,556,556,556,556,114,114,114,114,114,
+
+/* block 137 */
+  4,  4,  4,114,114,114,114, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+ 23, 23, 23, 23,114,114,114, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+557,557,557,557,557,557,557,557,557,557,557,557,557,557,557,557,
+557,557,557,557,557,557,557,557,557,557,557,557,557,557,557,557,
+557,557,557,557,557,557,557,557,557,557,557,557,557,557,557,557,
+557,557,557,557,557,558,558,558,558,559,559,559,559,559,559,559,
+
+/* block 138 */
+559,559,559,559,559,559,559,559,559,559,558,558,559,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,
+559,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,114,114,
+
+/* block 139 */
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 140 */
+560,560,560,560,560,560,560,560,560,560,560,560,560,560,560,560,
+560,560,560,560,560,560,560,560,560,560,560,560,560,114,114,114,
+561,561,561,561,561,561,561,561,561,561,561,561,561,561,561,561,
+561,561,561,561,561,561,561,561,561,561,561,561,561,561,561,561,
+561,561,561,561,561,561,561,561,561,561,561,561,561,561,561,561,
+561,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+109, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,114,114,114,114,
+
+/* block 141 */
+562,562,562,562,562,562,562,562,562,562,562,562,562,562,562,562,
+562,562,562,562,562,562,562,562,562,562,562,562,562,562,562,562,
+563,563,563,563,114,114,114,114,114,114,114,114,114,114,114,114,
+564,564,564,564,564,564,564,564,564,564,564,564,564,564,564,564,
+564,565,564,564,564,564,564,564,564,564,565,114,114,114,114,114,
+566,566,566,566,566,566,566,566,566,566,566,566,566,566,566,566,
+566,566,566,566,566,566,566,566,566,566,566,566,566,566,566,566,
+566,566,566,566,566,566,567,567,567,567,567,114,114,114,114,114,
+
+/* block 142 */
+568,568,568,568,568,568,568,568,568,568,568,568,568,568,568,568,
+568,568,568,568,568,568,568,568,568,568,568,568,568,568,114,569,
+570,570,570,570,570,570,570,570,570,570,570,570,570,570,570,570,
+570,570,570,570,570,570,570,570,570,570,570,570,570,570,570,570,
+570,570,570,570,114,114,114,114,570,570,570,570,570,570,570,570,
+571,572,572,572,572,572,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 143 */
+573,573,573,573,573,573,573,573,573,573,573,573,573,573,573,573,
+573,573,573,573,573,573,573,573,573,573,573,573,573,573,573,573,
+573,573,573,573,573,573,573,573,574,574,574,574,574,574,574,574,
+574,574,574,574,574,574,574,574,574,574,574,574,574,574,574,574,
+574,574,574,574,574,574,574,574,574,574,574,574,574,574,574,574,
+575,575,575,575,575,575,575,575,575,575,575,575,575,575,575,575,
+575,575,575,575,575,575,575,575,575,575,575,575,575,575,575,575,
+575,575,575,575,575,575,575,575,575,575,575,575,575,575,575,575,
+
+/* block 144 */
+576,576,576,576,576,576,576,576,576,576,576,576,576,576,576,576,
+576,576,576,576,576,576,576,576,576,576,576,576,576,576,114,114,
+577,577,577,577,577,577,577,577,577,577,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 145 */
+578,578,578,578,578,578,578,578,578,578,578,578,578,578,578,578,
+578,578,578,578,578,578,578,578,578,578,578,578,578,578,578,578,
+578,578,578,578,578,578,578,578,114,114,114,114,114,114,114,114,
+579,579,579,579,579,579,579,579,579,579,579,579,579,579,579,579,
+579,579,579,579,579,579,579,579,579,579,579,579,579,579,579,579,
+579,579,579,579,579,579,579,579,579,579,579,579,579,579,579,579,
+579,579,579,579,114,114,114,114,114,114,114,114,114,114,114,580,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 146 */
+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,
+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,
+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,
+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,
+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,
+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,
+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,
+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,
+
+/* block 147 */
+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,
+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,
+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,
+581,581,581,581,581,581,581,114,114,114,114,114,114,114,114,114,
+581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,581,
+581,581,581,581,581,581,114,114,114,114,114,114,114,114,114,114,
+581,581,581,581,581,581,581,581,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 148 */
+582,582,582,582,582,582,114,114,582,114,582,582,582,582,582,582,
+582,582,582,582,582,582,582,582,582,582,582,582,582,582,582,582,
+582,582,582,582,582,582,582,582,582,582,582,582,582,582,582,582,
+582,582,582,582,582,582,114,582,582,114,114,114,582,114,114,582,
+583,583,583,583,583,583,583,583,583,583,583,583,583,583,583,583,
+583,583,583,583,583,583,114,584,585,585,585,585,585,585,585,585,
+586,586,586,586,586,586,586,586,586,586,586,586,586,586,586,586,
+586,586,586,586,586,586,586,587,587,588,588,588,588,588,588,588,
+
+/* block 149 */
+589,589,589,589,589,589,589,589,589,589,589,589,589,589,589,589,
+589,589,589,589,589,589,589,589,589,589,589,589,589,589,589,114,
+114,114,114,114,114,114,114,590,590,590,590,590,590,590,590,590,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 150 */
+591,591,591,591,591,591,591,591,591,591,591,591,591,591,591,591,
+591,591,591,591,591,591,592,592,592,592,592,592,114,114,114,593,
+594,594,594,594,594,594,594,594,594,594,594,594,594,594,594,594,
+594,594,594,594,594,594,594,594,594,594,114,114,114,114,114,595,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 151 */
+596,596,596,596,596,596,596,596,596,596,596,596,596,596,596,596,
+596,596,596,596,596,596,596,596,596,596,596,596,596,596,596,596,
+597,597,597,597,597,597,597,597,597,597,597,597,597,597,597,597,
+597,597,597,597,597,597,597,597,114,114,114,114,114,114,597,597,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 152 */
+598,599,599,599,114,599,599,114,114,114,114,114,599,599,599,599,
+598,598,598,598,114,598,598,598,114,598,598,598,598,598,598,598,
+598,598,598,598,598,598,598,598,598,598,598,598,598,598,598,598,
+598,598,598,598,114,114,114,114,599,599,599,114,114,114,114,599,
+600,600,600,600,600,600,600,600,114,114,114,114,114,114,114,114,
+601,601,601,601,601,601,601,601,601,114,114,114,114,114,114,114,
+602,602,602,602,602,602,602,602,602,602,602,602,602,602,602,602,
+602,602,602,602,602,602,602,602,602,602,602,602,602,603,603,604,
+
+/* block 153 */
+605,605,605,605,605,605,605,605,605,605,605,605,605,605,605,605,
+605,605,605,605,605,605,605,605,605,605,605,605,605,606,606,606,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+607,607,607,607,607,607,607,607,608,607,607,607,607,607,607,607,
+607,607,607,607,607,607,607,607,607,607,607,607,607,607,607,607,
+607,607,607,607,607,609,609,114,114,114,114,610,610,610,610,610,
+611,611,611,611,611,611,611,114,114,114,114,114,114,114,114,114,
+
+/* block 154 */
+612,612,612,612,612,612,612,612,612,612,612,612,612,612,612,612,
+612,612,612,612,612,612,612,612,612,612,612,612,612,612,612,612,
+612,612,612,612,612,612,612,612,612,612,612,612,612,612,612,612,
+612,612,612,612,612,612,114,114,114,613,613,613,613,613,613,613,
+614,614,614,614,614,614,614,614,614,614,614,614,614,614,614,614,
+614,614,614,614,614,614,114,114,615,615,615,615,615,615,615,615,
+616,616,616,616,616,616,616,616,616,616,616,616,616,616,616,616,
+616,616,616,114,114,114,114,114,617,617,617,617,617,617,617,617,
+
+/* block 155 */
+618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,618,
+618,618,114,114,114,114,114,114,114,619,619,619,619,114,114,114,
+114,114,114,114,114,114,114,114,114,620,620,620,620,620,620,620,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 156 */
+621,621,621,621,621,621,621,621,621,621,621,621,621,621,621,621,
+621,621,621,621,621,621,621,621,621,621,621,621,621,621,621,621,
+621,621,621,621,621,621,621,621,621,621,621,621,621,621,621,621,
+621,621,621,621,621,621,621,621,621,621,621,621,621,621,621,621,
+621,621,621,621,621,621,621,621,621,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 157 */
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+622,622,622,622,622,622,622,622,622,622,622,622,622,622,622,622,
+622,622,622,622,622,622,622,622,622,622,622,622,622,622,622,114,
+
+/* block 158 */
+623,624,623,625,625,625,625,625,625,625,625,625,625,625,625,625,
+625,625,625,625,625,625,625,625,625,625,625,625,625,625,625,625,
+625,625,625,625,625,625,625,625,625,625,625,625,625,625,625,625,
+625,625,625,625,625,625,625,625,624,624,624,624,624,624,624,624,
+624,624,624,624,624,624,624,626,626,626,626,626,626,626,114,114,
+114,114,627,627,627,627,627,627,627,627,627,627,627,627,627,627,
+627,627,627,627,627,627,628,628,628,628,628,628,628,628,628,628,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,624,
+
+/* block 159 */
+629,629,630,631,631,631,631,631,631,631,631,631,631,631,631,631,
+631,631,631,631,631,631,631,631,631,631,631,631,631,631,631,631,
+631,631,631,631,631,631,631,631,631,631,631,631,631,631,631,631,
+630,630,630,629,629,629,629,630,630,629,629,632,632,633,632,632,
+632,632,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+634,634,634,634,634,634,634,634,634,634,634,634,634,634,634,634,
+634,634,634,634,634,634,634,634,634,114,114,114,114,114,114,114,
+635,635,635,635,635,635,635,635,635,635,114,114,114,114,114,114,
+
+/* block 160 */
+636,636,636,637,637,637,637,637,637,637,637,637,637,637,637,637,
+637,637,637,637,637,637,637,637,637,637,637,637,637,637,637,637,
+637,637,637,637,637,637,637,636,636,636,636,636,638,636,636,636,
+636,636,636,636,636,114,639,639,639,639,639,639,639,639,639,639,
+640,640,640,640,114,114,114,114,114,114,114,114,114,114,114,114,
+641,641,641,641,641,641,641,641,641,641,641,641,641,641,641,641,
+641,641,641,641,641,641,641,641,641,641,641,641,641,641,641,641,
+641,641,641,642,643,643,641,114,114,114,114,114,114,114,114,114,
+
+/* block 161 */
+644,644,645,646,646,646,646,646,646,646,646,646,646,646,646,646,
+646,646,646,646,646,646,646,646,646,646,646,646,646,646,646,646,
+646,646,646,646,646,646,646,646,646,646,646,646,646,646,646,646,
+646,646,646,645,645,645,644,644,644,644,644,644,644,644,644,645,
+645,646,646,646,646,647,647,647,647,114,114,114,114,647,114,114,
+648,648,648,648,648,648,648,648,648,648,646,114,114,114,114,114,
+114,649,649,649,649,649,649,649,649,649,649,649,649,649,649,649,
+649,649,649,649,649,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 162 */
+650,650,650,650,650,650,650,650,650,650,650,650,650,650,650,650,
+650,650,114,650,650,650,650,650,650,650,650,650,650,650,650,650,
+650,650,650,650,650,650,650,650,650,650,650,650,651,651,651,652,
+652,652,651,651,652,651,652,652,653,653,653,653,653,653,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 163 */
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+654,654,654,654,654,654,654,654,654,654,654,654,654,654,654,654,
+654,654,654,654,654,654,654,654,654,654,654,654,654,654,654,654,
+654,654,654,654,654,654,654,654,654,654,654,654,654,654,654,655,
+656,656,656,655,655,655,655,655,655,655,655,114,114,114,114,114,
+657,657,657,657,657,657,657,657,657,657,114,114,114,114,114,114,
+
+/* block 164 */
+114,658,659,659,114,660,660,660,660,660,660,660,660,114,114,660,
+660,114,114,660,660,660,660,660,660,660,660,660,660,660,660,660,
+660,660,660,660,660,660,660,660,660,114,660,660,660,660,660,660,
+660,114,660,660,114,660,660,660,660,660,114,114,658,660,661,659,
+658,659,659,659,659,114,114,659,659,114,114,659,659,659,114,114,
+114,114,114,114,114,114,114,661,114,114,114,114,114,660,660,660,
+660,660,659,659,114,114,658,658,658,658,658,658,658,114,114,114,
+658,658,658,658,658,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 165 */
+662,662,662,662,662,662,662,662,662,662,662,662,662,662,662,662,
+662,662,662,662,662,662,662,662,662,662,662,662,662,662,662,662,
+662,662,662,662,662,662,662,662,662,662,662,662,662,662,662,662,
+663,664,664,665,665,665,665,665,665,664,665,664,664,663,664,665,
+665,664,665,665,662,662,666,662,114,114,114,114,114,114,114,114,
+667,667,667,667,667,667,667,667,667,667,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 166 */
+668,668,668,668,668,668,668,668,668,668,668,668,668,668,668,668,
+668,668,668,668,668,668,668,668,668,668,668,668,668,668,668,668,
+668,668,668,668,668,668,668,668,668,668,668,668,668,668,668,669,
+670,670,671,671,671,671,114,114,670,670,670,670,671,671,670,671,
+671,672,672,672,672,672,672,672,672,672,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 167 */
+673,673,673,673,673,673,673,673,673,673,673,673,673,673,673,673,
+673,673,673,673,673,673,673,673,673,673,673,673,673,673,673,673,
+673,673,673,673,673,673,673,673,673,673,673,673,673,673,673,673,
+674,674,674,675,675,675,675,675,675,675,675,674,674,675,674,675,
+675,676,676,676,673,114,114,114,114,114,114,114,114,114,114,114,
+677,677,677,677,677,677,677,677,677,677,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 168 */
+678,678,678,678,678,678,678,678,678,678,678,678,678,678,678,678,
+678,678,678,678,678,678,678,678,678,678,678,678,678,678,678,678,
+678,678,678,678,678,678,678,678,678,678,678,679,680,679,680,680,
+679,679,679,679,679,679,680,679,114,114,114,114,114,114,114,114,
+681,681,681,681,681,681,681,681,681,681,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 169 */
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+682,682,682,682,682,682,682,682,682,682,682,682,682,682,682,682,
+682,682,682,682,682,682,682,682,682,682,682,682,682,682,682,682,
+683,683,683,683,683,683,683,683,683,683,683,683,683,683,683,683,
+683,683,683,683,683,683,683,683,683,683,683,683,683,683,683,683,
+684,684,684,684,684,684,684,684,684,684,685,685,685,685,685,685,
+685,685,685,114,114,114,114,114,114,114,114,114,114,114,114,686,
+
+/* block 170 */
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+687,687,687,687,687,687,687,687,687,687,687,687,687,687,687,687,
+687,687,687,687,687,687,687,687,687,687,687,687,687,687,687,687,
+687,687,687,687,687,687,687,687,687,687,687,687,687,687,687,687,
+687,687,687,687,687,687,687,687,687,114,114,114,114,114,114,114,
+
+/* block 171 */
+688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,
+688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,
+688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,
+688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,
+688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,
+688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,
+688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,
+688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,
+
+/* block 172 */
+688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,688,
+688,688,688,688,688,688,688,688,688,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 173 */
+689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,
+689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,
+689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,
+689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,
+689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,
+689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,
+689,689,689,689,689,689,689,689,689,689,689,689,689,689,689,114,
+690,690,690,690,690,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 174 */
+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,
+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,
+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,
+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,
+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,
+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,
+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,
+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,
+
+/* block 175 */
+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,
+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,
+691,691,691,691,691,691,691,691,691,691,691,691,691,691,691,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 176 */
+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,
+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,
+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,
+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,
+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,
+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,
+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,
+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,
+
+/* block 177 */
+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,
+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,
+497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,497,
+497,497,497,497,497,497,497,497,497,114,114,114,114,114,114,114,
+692,692,692,692,692,692,692,692,692,692,692,692,692,692,692,692,
+692,692,692,692,692,692,692,692,692,692,692,692,692,692,692,114,
+693,693,693,693,693,693,693,693,693,693,114,114,114,114,694,694,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 178 */
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+695,695,695,695,695,695,695,695,695,695,695,695,695,695,695,695,
+695,695,695,695,695,695,695,695,695,695,695,695,695,695,114,114,
+696,696,696,696,696,697,114,114,114,114,114,114,114,114,114,114,
+
+/* block 179 */
+698,698,698,698,698,698,698,698,698,698,698,698,698,698,698,698,
+698,698,698,698,698,698,698,698,698,698,698,698,698,698,698,698,
+698,698,698,698,698,698,698,698,698,698,698,698,698,698,698,698,
+699,699,699,699,699,699,699,700,700,700,700,700,701,701,701,701,
+702,702,702,702,700,701,114,114,114,114,114,114,114,114,114,114,
+703,703,703,703,703,703,703,703,703,703,114,704,704,704,704,704,
+704,704,114,698,698,698,698,698,698,698,698,698,698,698,698,698,
+698,698,698,698,698,698,698,698,114,114,114,114,114,698,698,698,
+
+/* block 180 */
+698,698,698,698,698,698,698,698,698,698,698,698,698,698,698,698,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 181 */
+705,705,705,705,705,705,705,705,705,705,705,705,705,705,705,705,
+705,705,705,705,705,705,705,705,705,705,705,705,705,705,705,705,
+705,705,705,705,705,705,705,705,705,705,705,705,705,705,705,705,
+705,705,705,705,705,705,705,705,705,705,705,705,705,705,705,705,
+705,705,705,705,705,114,114,114,114,114,114,114,114,114,114,114,
+705,706,706,706,706,706,706,706,706,706,706,706,706,706,706,706,
+706,706,706,706,706,706,706,706,706,706,706,706,706,706,706,706,
+706,706,706,706,706,706,706,706,706,706,706,706,706,706,706,114,
+
+/* block 182 */
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,707,
+707,707,707,708,708,708,708,708,708,708,708,708,708,708,708,708,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 183 */
+478,476,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 184 */
+709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,
+709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,
+709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,
+709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,
+709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,
+709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,709,
+709,709,709,709,709,709,709,709,709,709,709,114,114,114,114,114,
+709,709,709,709,709,709,709,709,709,709,709,709,709,114,114,114,
+
+/* block 185 */
+709,709,709,709,709,709,709,709,709,114,114,114,114,114,114,114,
+709,709,709,709,709,709,709,709,709,709,114,114,710,711,711,712,
+ 22, 22, 22, 22,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 186 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19,114,114,114,114,114,114,114,114,114,114,
+
+/* block 187 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19,114,114, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19,713,405,109,109,109, 19, 19, 19,405,713,713,
+713,713,713, 22, 22, 22, 22, 22, 22, 22, 22,109,109,109,109,109,
+
+/* block 188 */
+109,109,109, 19, 19,109,109,109,109,109,109,109, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,109,109,109,109, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 189 */
+559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,
+559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,
+559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,
+559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,559,
+559,559,714,714,714,559,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 190 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,114,114,114,114,
+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+ 23, 23,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 191 */
+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,
+437,437,437,437,437,437,437,437,437,437,438,438,438,438,438,438,
+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,
+438,438,438,438,437,437,437,437,437,437,437,437,437,437,437,437,
+437,437,437,437,437,437,437,437,437,437,437,437,437,437,438,438,
+438,438,438,438,438,114,438,438,438,438,438,438,438,438,438,438,
+438,438,438,438,438,438,438,438,437,437,437,437,437,437,437,437,
+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,
+
+/* block 192 */
+437,437,438,438,438,438,438,438,438,438,438,438,438,438,438,438,
+438,438,438,438,438,438,438,438,438,438,438,438,437,114,437,437,
+114,114,437,114,114,437,437,114,114,437,437,437,437,114,437,437,
+437,437,437,437,437,437,438,438,438,438,114,438,114,438,438,438,
+438,438,438,438,114,438,438,438,438,438,438,438,438,438,438,438,
+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,
+437,437,437,437,437,437,437,437,437,437,438,438,438,438,438,438,
+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,
+
+/* block 193 */
+438,438,438,438,437,437,114,437,437,437,437,114,114,437,437,437,
+437,437,437,437,437,114,437,437,437,437,437,437,437,114,438,438,
+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,
+438,438,438,438,438,438,438,438,437,437,114,437,437,437,437,114,
+437,437,437,437,437,114,437,114,114,114,437,437,437,437,437,437,
+437,114,438,438,438,438,438,438,438,438,438,438,438,438,438,438,
+438,438,438,438,438,438,438,438,438,438,438,438,437,437,437,437,
+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,
+
+/* block 194 */
+437,437,437,437,437,437,438,438,438,438,438,438,438,438,438,438,
+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,
+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,
+437,437,437,437,437,437,437,437,437,437,438,438,438,438,438,438,
+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,
+438,438,438,438,437,437,437,437,437,437,437,437,437,437,437,437,
+437,437,437,437,437,437,437,437,437,437,437,437,437,437,438,438,
+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,
+
+/* block 195 */
+438,438,438,438,438,438,438,438,437,437,437,437,437,437,437,437,
+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,
+437,437,438,438,438,438,438,438,438,438,438,438,438,438,438,438,
+438,438,438,438,438,438,438,438,438,438,438,438,437,437,437,437,
+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,
+437,437,437,437,437,437,438,438,438,438,438,438,438,438,438,438,
+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,
+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,
+
+/* block 196 */
+437,437,437,437,437,437,437,437,437,437,438,438,438,438,438,438,
+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,
+438,438,438,438,438,438,114,114,437,437,437,437,437,437,437,437,
+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,
+437,  8,438,438,438,438,438,438,438,438,438,438,438,438,438,438,
+438,438,438,438,438,438,438,438,438,438,438,  8,438,438,438,438,
+438,438,437,437,437,437,437,437,437,437,437,437,437,437,437,437,
+437,437,437,437,437,437,437,437,437,437,437,  8,438,438,438,438,
+
+/* block 197 */
+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,
+438,438,438,438,438,  8,438,438,438,438,438,438,437,437,437,437,
+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,
+437,437,437,437,437,  8,438,438,438,438,438,438,438,438,438,438,
+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,  8,
+438,438,438,438,438,438,437,437,437,437,437,437,437,437,437,437,
+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,  8,
+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,
+
+/* block 198 */
+438,438,438,438,438,438,438,438,438,  8,438,438,438,438,438,438,
+437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,437,
+437,437,437,437,437,437,437,437,437,  8,438,438,438,438,438,438,
+438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,438,
+438,438,438,  8,438,438,438,438,438,438,437,438,114,114, 10, 10,
+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+ 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+
+/* block 199 */
+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,
+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,
+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,
+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,
+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,
+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,
+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,
+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,
+
+/* block 200 */
+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,
+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,
+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,
+715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,715,
+715,715,715,715,715,114,114,716,716,716,716,716,716,716,716,716,
+717,717,717,717,717,717,717,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 201 */
+199,199,199,199,114,199,199,199,199,199,199,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,199,
+114,199,199,114,199,114,114,199,114,199,199,199,199,199,199,199,
+199,199,199,114,199,199,199,199,114,199,114,199,114,114,114,114,
+114,114,199,114,114,114,114,199,114,199,114,199,114,199,199,199,
+114,199,199,114,199,114,114,199,114,199,114,199,114,199,114,199,
+114,199,199,114,199,114,114,199,199,199,199,114,199,199,199,199,
+199,199,199,114,199,199,199,199,114,199,199,199,199,114,199,114,
+
+/* block 202 */
+199,199,199,199,199,199,199,199,199,199,114,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,114,114,114,114,
+114,199,199,199,114,199,199,199,199,199,114,199,199,199,199,199,
+199,199,199,199,199,199,199,199,199,199,199,199,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+194,194,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 203 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+
+/* block 204 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19,114,114,114,114,114,114,114,114,114,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,
+114, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+114, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+114, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19,114,114,114,114,114,114,114,114,114,114,
+
+/* block 205 */
+ 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+
+/* block 206 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,718,718,718,718,718,718,718,718,718,718,
+718,718,718,718,718,718,718,718,718,718,718,718,718,718,718,718,
+
+/* block 207 */
+719, 19, 19,114,114,114,114,114,114,114,114,114,114,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,114,114,
+ 19, 19,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 208 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,
+
+/* block 209 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,
+114,114,114,114, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,114,114,114,
+
+/* block 210 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,
+
+/* block 211 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114, 19, 19, 19, 19, 19,
+
+/* block 212 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19,114, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+
+/* block 213 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19,114,114, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+
+/* block 214 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,
+ 19, 19, 19, 19,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 215 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 216 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 217 */
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+
+/* block 218 */
+ 19, 19, 19, 19, 19, 19, 19, 19,114,114,114,114,114,114,114,114,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+ 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 219 */
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 220 */
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,114,114,114,114,114,114,114,114,114,114,114,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+
+/* block 221 */
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,484,
+484,484,484,484,484,484,484,484,484,484,484,484,484,484,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,114,
+
+/* block 222 */
+436, 22,436,436,436,436,436,436,436,436,436,436,436,436,436,436,
+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,
+ 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+ 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+ 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+ 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+ 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+ 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+
+/* block 223 */
+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,
+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,
+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,
+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,
+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,
+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,
+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,
+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,
+
+/* block 224 */
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+
+/* block 225 */
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,109,
+436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,436,
+
+/* block 226 */
+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
+552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,552,
+552,552,552,552,552,552,552,552,552,552,552,552,552,552,114,114,
+
+};
+
+#if UCD_BLOCK_SIZE != 128
+#error Please correct UCD_BLOCK_SIZE in pcre_internal.h
+#endif
+#endif  /* SUPPORT_UCP */
+
+#endif  /* PCRE_INCLUDED */
diff --git a/base/poco/Foundation/src/pcre_valid_utf8.c b/base/poco/Foundation/src/pcre_valid_utf8.c
new file mode 100644
index 00000000000..68bc50e1446
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_valid_utf8.c
@@ -0,0 +1,298 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2013 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+
+/* This module contains an internal function for validating UTF-8 character
+strings. */
+
+
+#include "pcre_config.h"
+#include "pcre_internal.h"
+
+
+/*************************************************
+*         Validate a UTF-8 string                *
+*************************************************/
+
+/* This function is called (optionally) at the start of compile or match, to
+check that a supposed UTF-8 string is actually valid. The early check means
+that subsequent code can assume it is dealing with a valid string. The check
+can be turned off for maximum performance, but the consequences of supplying an
+invalid string are then undefined.
+
+Originally, this function checked according to RFC 2279, allowing for values in
+the range 0 to 0x7fffffff, up to 6 bytes long, but ensuring that they were in
+the canonical format. Once somebody had pointed out RFC 3629 to me (it
+obsoletes 2279), additional restrictions were applied. The values are now
+limited to be between 0 and 0x0010ffff, no more than 4 bytes long, and the
+subrange 0xd000 to 0xdfff is excluded. However, the format of 5-byte and 6-byte
+characters is still checked.
+
+From release 8.13 more information about the details of the error are passed
+back in the returned value:
+
+PCRE_UTF8_ERR0   No error
+PCRE_UTF8_ERR1   Missing 1 byte at the end of the string
+PCRE_UTF8_ERR2   Missing 2 bytes at the end of the string
+PCRE_UTF8_ERR3   Missing 3 bytes at the end of the string
+PCRE_UTF8_ERR4   Missing 4 bytes at the end of the string
+PCRE_UTF8_ERR5   Missing 5 bytes at the end of the string
+PCRE_UTF8_ERR6   2nd-byte's two top bits are not 0x80
+PCRE_UTF8_ERR7   3rd-byte's two top bits are not 0x80
+PCRE_UTF8_ERR8   4th-byte's two top bits are not 0x80
+PCRE_UTF8_ERR9   5th-byte's two top bits are not 0x80
+PCRE_UTF8_ERR10  6th-byte's two top bits are not 0x80
+PCRE_UTF8_ERR11  5-byte character is not permitted by RFC 3629
+PCRE_UTF8_ERR12  6-byte character is not permitted by RFC 3629
+PCRE_UTF8_ERR13  4-byte character with value > 0x10ffff is not permitted
+PCRE_UTF8_ERR14  3-byte character with value 0xd000-0xdfff is not permitted
+PCRE_UTF8_ERR15  Overlong 2-byte sequence
+PCRE_UTF8_ERR16  Overlong 3-byte sequence
+PCRE_UTF8_ERR17  Overlong 4-byte sequence
+PCRE_UTF8_ERR18  Overlong 5-byte sequence (won't ever occur)
+PCRE_UTF8_ERR19  Overlong 6-byte sequence (won't ever occur)
+PCRE_UTF8_ERR20  Isolated 0x80 byte (not within UTF-8 character)
+PCRE_UTF8_ERR21  Byte with the illegal value 0xfe or 0xff
+PCRE_UTF8_ERR22  Unused (was non-character)
+
+Arguments:
+  string       points to the string
+  length       length of string, or -1 if the string is zero-terminated
+  errp         pointer to an error position offset variable
+
+Returns:       = 0    if the string is a valid UTF-8 string
+               > 0    otherwise, setting the offset of the bad character
+*/
+
+int
+PRIV(valid_utf)(PCRE_PUCHAR string, int length, int *erroroffset)
+{
+#ifdef SUPPORT_UTF
+register PCRE_PUCHAR p;
+
+if (length < 0)
+  {
+  for (p = string; *p != 0; p++);
+  length = (int)(p - string);
+  }
+
+for (p = string; length-- > 0; p++)
+  {
+  register pcre_uchar ab, c, d;
+
+  c = *p;
+  if (c < 128) continue;                /* ASCII character */
+
+  if (c < 0xc0)                         /* Isolated 10xx xxxx byte */
+    {
+    *erroroffset = (int)(p - string);
+    return PCRE_UTF8_ERR20;
+    }
+
+  if (c >= 0xfe)                        /* Invalid 0xfe or 0xff bytes */
+    {
+    *erroroffset = (int)(p - string);
+    return PCRE_UTF8_ERR21;
+    }
+
+  ab = PRIV(utf8_table4)[c & 0x3f];     /* Number of additional bytes */
+  if (length < ab)
+    {
+    *erroroffset = (int)(p - string);          /* Missing bytes */
+    return ab - length;                 /* Codes ERR1 to ERR5 */
+    }
+  length -= ab;                         /* Length remaining */
+
+  /* Check top bits in the second byte */
+
+  if (((d = *(++p)) & 0xc0) != 0x80)
+    {
+    *erroroffset = (int)(p - string) - 1;
+    return PCRE_UTF8_ERR6;
+    }
+
+  /* For each length, check that the remaining bytes start with the 0x80 bit
+  set and not the 0x40 bit. Then check for an overlong sequence, and for the
+  excluded range 0xd800 to 0xdfff. */
+
+  switch (ab)
+    {
+    /* 2-byte character. No further bytes to check for 0x80. Check first byte
+    for for xx00 000x (overlong sequence). */
+
+    case 1: if ((c & 0x3e) == 0)
+      {
+      *erroroffset = (int)(p - string) - 1;
+      return PCRE_UTF8_ERR15;
+      }
+    break;
+
+    /* 3-byte character. Check third byte for 0x80. Then check first 2 bytes
+      for 1110 0000, xx0x xxxx (overlong sequence) or
+          1110 1101, 1010 xxxx (0xd800 - 0xdfff) */
+
+    case 2:
+    if ((*(++p) & 0xc0) != 0x80)     /* Third byte */
+      {
+      *erroroffset = (int)(p - string) - 2;
+      return PCRE_UTF8_ERR7;
+      }
+    if (c == 0xe0 && (d & 0x20) == 0)
+      {
+      *erroroffset = (int)(p - string) - 2;
+      return PCRE_UTF8_ERR16;
+      }
+    if (c == 0xed && d >= 0xa0)
+      {
+      *erroroffset = (int)(p - string) - 2;
+      return PCRE_UTF8_ERR14;
+      }
+    break;
+
+    /* 4-byte character. Check 3rd and 4th bytes for 0x80. Then check first 2
+       bytes for for 1111 0000, xx00 xxxx (overlong sequence), then check for a
+       character greater than 0x0010ffff (f4 8f bf bf) */
+
+    case 3:
+    if ((*(++p) & 0xc0) != 0x80)     /* Third byte */
+      {
+      *erroroffset = (int)(p - string) - 2;
+      return PCRE_UTF8_ERR7;
+      }
+    if ((*(++p) & 0xc0) != 0x80)     /* Fourth byte */
+      {
+      *erroroffset = (int)(p - string) - 3;
+      return PCRE_UTF8_ERR8;
+      }
+    if (c == 0xf0 && (d & 0x30) == 0)
+      {
+      *erroroffset = (int)(p - string) - 3;
+      return PCRE_UTF8_ERR17;
+      }
+    if (c > 0xf4 || (c == 0xf4 && d > 0x8f))
+      {
+      *erroroffset = (int)(p - string) - 3;
+      return PCRE_UTF8_ERR13;
+      }
+    break;
+
+    /* 5-byte and 6-byte characters are not allowed by RFC 3629, and will be
+    rejected by the length test below. However, we do the appropriate tests
+    here so that overlong sequences get diagnosed, and also in case there is
+    ever an option for handling these larger code points. */
+
+    /* 5-byte character. Check 3rd, 4th, and 5th bytes for 0x80. Then check for
+    1111 1000, xx00 0xxx */
+
+    case 4:
+    if ((*(++p) & 0xc0) != 0x80)     /* Third byte */
+      {
+      *erroroffset = (int)(p - string) - 2;
+      return PCRE_UTF8_ERR7;
+      }
+    if ((*(++p) & 0xc0) != 0x80)     /* Fourth byte */
+      {
+      *erroroffset = (int)(p - string) - 3;
+      return PCRE_UTF8_ERR8;
+      }
+    if ((*(++p) & 0xc0) != 0x80)     /* Fifth byte */
+      {
+      *erroroffset = (int)(p - string) - 4;
+      return PCRE_UTF8_ERR9;
+      }
+    if (c == 0xf8 && (d & 0x38) == 0)
+      {
+      *erroroffset = (int)(p - string) - 4;
+      return PCRE_UTF8_ERR18;
+      }
+    break;
+
+    /* 6-byte character. Check 3rd-6th bytes for 0x80. Then check for
+    1111 1100, xx00 00xx. */
+
+    case 5:
+    if ((*(++p) & 0xc0) != 0x80)     /* Third byte */
+      {
+      *erroroffset = (int)(p - string) - 2;
+      return PCRE_UTF8_ERR7;
+      }
+    if ((*(++p) & 0xc0) != 0x80)     /* Fourth byte */
+      {
+      *erroroffset = (int)(p - string) - 3;
+      return PCRE_UTF8_ERR8;
+      }
+    if ((*(++p) & 0xc0) != 0x80)     /* Fifth byte */
+      {
+      *erroroffset = (int)(p - string) - 4;
+      return PCRE_UTF8_ERR9;
+      }
+    if ((*(++p) & 0xc0) != 0x80)     /* Sixth byte */
+      {
+      *erroroffset = (int)(p - string) - 5;
+      return PCRE_UTF8_ERR10;
+      }
+    if (c == 0xfc && (d & 0x3c) == 0)
+      {
+      *erroroffset = (int)(p - string) - 5;
+      return PCRE_UTF8_ERR19;
+      }
+    break;
+    }
+
+  /* Character is valid under RFC 2279, but 4-byte and 5-byte characters are
+  excluded by RFC 3629. The pointer p is currently at the last byte of the
+  character. */
+
+  if (ab > 3)
+    {
+    *erroroffset = (int)(p - string) - ab;
+    return (ab == 4)? PCRE_UTF8_ERR11 : PCRE_UTF8_ERR12;
+    }
+  }
+
+#else  /* Not SUPPORT_UTF */
+(void)(string);  /* Keep picky compilers happy */
+(void)(length);
+(void)(erroroffset);
+#endif
+
+return PCRE_UTF8_ERR0;   /* This indicates success */
+}
+
+/* End of pcre_valid_utf8.c */
diff --git a/base/poco/Foundation/src/pcre_version.c b/base/poco/Foundation/src/pcre_version.c
new file mode 100644
index 00000000000..b48b2ee20fb
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_version.c
@@ -0,0 +1,94 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2012 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+
+/* This module contains the external function pcre_version(), which returns a
+string that identifies the PCRE version that is in use. */
+
+#include "pcre_config.h"
+#include "pcre_internal.h"
+
+
+/*************************************************
+*          Return version string                 *
+*************************************************/
+
+/* These macros are the standard way of turning unquoted text into C strings.
+They allow macros like PCRE_MAJOR to be defined without quotes, which is
+convenient for user programs that want to test its value. */
+
+#define STRING(a)  # a
+#define XSTRING(s) STRING(s)
+
+/* A problem turned up with PCRE_PRERELEASE, which is defined empty for
+production releases. Originally, it was used naively in this code:
+
+  return XSTRING(PCRE_MAJOR)
+         "." XSTRING(PCRE_MINOR)
+             XSTRING(PCRE_PRERELEASE)
+         " " XSTRING(PCRE_DATE);
+
+However, when PCRE_PRERELEASE is empty, this leads to an attempted expansion of
+STRING(). The C standard states: "If (before argument substitution) any
+argument consists of no preprocessing tokens, the behavior is undefined." It
+turns out the gcc treats this case as a single empty string - which is what we
+really want - but Visual C grumbles about the lack of an argument for the
+macro. Unfortunately, both are within their rights. To cope with both ways of
+handling this, I had resort to some messy hackery that does a test at run time.
+I could find no way of detecting that a macro is defined as an empty string at
+pre-processor time. This hack uses a standard trick for avoiding calling
+the STRING macro with an empty argument when doing the test. */
+
+#if defined COMPILE_PCRE8
+PCRE_EXP_DEFN const char * PCRE_CALL_CONVENTION
+pcre_version(void)
+#elif defined COMPILE_PCRE16
+PCRE_EXP_DEFN const char * PCRE_CALL_CONVENTION
+pcre16_version(void)
+#elif defined COMPILE_PCRE32
+PCRE_EXP_DEFN const char * PCRE_CALL_CONVENTION
+pcre32_version(void)
+#endif
+{
+return (XSTRING(Z PCRE_PRERELEASE)[1] == 0)?
+  XSTRING(PCRE_MAJOR.PCRE_MINOR PCRE_DATE) :
+  XSTRING(PCRE_MAJOR.PCRE_MINOR) XSTRING(PCRE_PRERELEASE PCRE_DATE);
+}
+
+/* End of pcre_version.c */
diff --git a/base/poco/Foundation/src/pcre_xclass.c b/base/poco/Foundation/src/pcre_xclass.c
new file mode 100644
index 00000000000..22fc782895a
--- /dev/null
+++ b/base/poco/Foundation/src/pcre_xclass.c
@@ -0,0 +1,264 @@
+/*************************************************
+*      Perl-Compatible Regular Expressions       *
+*************************************************/
+
+/* PCRE is a library of functions to support regular expressions whose syntax
+and semantics are as close as possible to those of the Perl 5 language.
+
+                       Written by Philip Hazel
+           Copyright (c) 1997-2013 University of Cambridge
+
+-----------------------------------------------------------------------------
+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 Cambridge 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 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 OWNER 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.
+-----------------------------------------------------------------------------
+*/
+
+
+/* This module contains an internal function that is used to match an extended
+class. It is used by both pcre_exec() and pcre_def_exec(). */
+
+#include "pcre_config.h"
+#include "pcre_internal.h"
+
+
+/*************************************************
+*       Match character against an XCLASS        *
+*************************************************/
+
+/* This function is called to match a character against an extended class that
+might contain values > 255 and/or Unicode properties.
+
+Arguments:
+  c           the character
+  data        points to the flag byte of the XCLASS data
+
+Returns:      TRUE if character matches, else FALSE
+*/
+
+BOOL
+PRIV(xclass)(pcre_uint32 c, const pcre_uchar *data, BOOL utf)
+{
+pcre_uchar t;
+BOOL negated = (*data & XCL_NOT) != 0;
+
+(void)utf;
+#ifdef COMPILE_PCRE8
+/* In 8 bit mode, this must always be TRUE. Help the compiler to know that. */
+utf = TRUE;
+#endif
+
+/* Character values < 256 are matched against a bitmap, if one is present. If
+not, we still carry on, because there may be ranges that start below 256 in the
+additional data. */
+
+if (c < 256)
+  {
+  if ((*data & XCL_HASPROP) == 0)
+    {
+    if ((*data & XCL_MAP) == 0) return negated;
+    return (((pcre_uint8 *)(data + 1))[c/8] & (1 << (c&7))) != 0;
+    }
+  if ((*data & XCL_MAP) != 0 &&
+    (((pcre_uint8 *)(data + 1))[c/8] & (1 << (c&7))) != 0)
+    return !negated; /* char found */
+  }
+
+/* First skip the bit map if present. Then match against the list of Unicode
+properties or large chars or ranges that end with a large char. We won't ever
+encounter XCL_PROP or XCL_NOTPROP when UCP support is not compiled. */
+
+if ((*data++ & XCL_MAP) != 0) data += 32 / sizeof(pcre_uchar);
+
+while ((t = *data++) != XCL_END)
+  {
+  pcre_uint32 x, y;
+  if (t == XCL_SINGLE)
+    {
+#ifdef SUPPORT_UTF
+    if (utf)
+      {
+      GETCHARINC(x, data); /* macro generates multiple statements */
+      }
+    else
+#endif
+      x = *data++;
+    if (c == x) return !negated;
+    }
+  else if (t == XCL_RANGE)
+    {
+#ifdef SUPPORT_UTF
+    if (utf)
+      {
+      GETCHARINC(x, data); /* macro generates multiple statements */
+      GETCHARINC(y, data); /* macro generates multiple statements */
+      }
+    else
+#endif
+      {
+      x = *data++;
+      y = *data++;
+      }
+    if (c >= x && c <= y) return !negated;
+    }
+
+#ifdef SUPPORT_UCP
+  else  /* XCL_PROP & XCL_NOTPROP */
+    {
+    const ucd_record *prop = GET_UCD(c);
+    BOOL isprop = t == XCL_PROP;
+
+    switch(*data)
+      {
+      case PT_ANY:
+      if (isprop) return !negated;
+      break;
+
+      case PT_LAMP:
+      if ((prop->chartype == ucp_Lu || prop->chartype == ucp_Ll ||
+           prop->chartype == ucp_Lt) == isprop) return !negated;
+      break;
+
+      case PT_GC:
+      if ((data[1] == PRIV(ucp_gentype)[prop->chartype]) == isprop)
+        return !negated;
+      break;
+
+      case PT_PC:
+      if ((data[1] == prop->chartype) == isprop) return !negated;
+      break;
+
+      case PT_SC:
+      if ((data[1] == prop->script) == isprop) return !negated;
+      break;
+
+      case PT_ALNUM:
+      if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
+           PRIV(ucp_gentype)[prop->chartype] == ucp_N) == isprop)
+        return !negated;
+      break;
+
+      /* Perl space used to exclude VT, but from Perl 5.18 it is included,
+      which means that Perl space and POSIX space are now identical. PCRE
+      was changed at release 8.34. */
+
+      case PT_SPACE:    /* Perl space */
+      case PT_PXSPACE:  /* POSIX space */
+      switch(c)
+        {
+        HSPACE_CASES:
+        VSPACE_CASES:
+        if (isprop) return !negated;
+        break;
+
+        default:
+        if ((PRIV(ucp_gentype)[prop->chartype] == ucp_Z) == isprop)
+          return !negated;
+        break;
+        }
+      break;
+
+      case PT_WORD:
+      if ((PRIV(ucp_gentype)[prop->chartype] == ucp_L ||
+           PRIV(ucp_gentype)[prop->chartype] == ucp_N || c == CHAR_UNDERSCORE)
+             == isprop)
+        return !negated;
+      break;
+
+      case PT_UCNC:
+      if (c < 0xa0)
+        {
+        if ((c == CHAR_DOLLAR_SIGN || c == CHAR_COMMERCIAL_AT ||
+             c == CHAR_GRAVE_ACCENT) == isprop)
+          return !negated;
+        }
+      else
+        {
+        if ((c < 0xd800 || c > 0xdfff) == isprop)
+          return !negated;
+        }
+      break;
+
+      /* The following three properties can occur only in an XCLASS, as there
+      is no \p or \P coding for them. */
+
+      /* Graphic character. Implement this as not Z (space or separator) and
+      not C (other), except for Cf (format) with a few exceptions. This seems
+      to be what Perl does. The exceptional characters are:
+
+      U+061C           Arabic Letter Mark
+      U+180E           Mongolian Vowel Separator
+      U+2066 - U+2069  Various "isolate"s
+      */
+
+      case PT_PXGRAPH:
+      if ((PRIV(ucp_gentype)[prop->chartype] != ucp_Z &&
+            (PRIV(ucp_gentype)[prop->chartype] != ucp_C ||
+              (prop->chartype == ucp_Cf &&
+                c != 0x061c && c != 0x180e && (c < 0x2066 || c > 0x2069))
+         )) == isprop)
+        return !negated;
+      break;
+
+      /* Printable character: same as graphic, with the addition of Zs, i.e.
+      not Zl and not Zp, and U+180E. */
+
+      case PT_PXPRINT:
+      if ((prop->chartype != ucp_Zl &&
+           prop->chartype != ucp_Zp &&
+            (PRIV(ucp_gentype)[prop->chartype] != ucp_C ||
+              (prop->chartype == ucp_Cf &&
+                c != 0x061c && (c < 0x2066 || c > 0x2069))
+         )) == isprop)
+        return !negated;
+      break;
+
+      /* Punctuation: all Unicode punctuation, plus ASCII characters that
+      Unicode treats as symbols rather than punctuation, for Perl
+      compatibility (these are $+<=>^`|~). */
+
+      case PT_PXPUNCT:
+      if ((PRIV(ucp_gentype)[prop->chartype] == ucp_P ||
+            (c < 128 && PRIV(ucp_gentype)[prop->chartype] == ucp_S)) == isprop)
+        return !negated;
+      break;
+
+      /* This should never occur, but compilers may mutter if there is no
+      default. */
+
+      default:
+      return FALSE;
+      }
+
+    data += 2;
+    }
+#endif  /* SUPPORT_UCP */
+  }
+
+return negated;   /* char did not match */
+}
+
+/* End of pcre_xclass.c */
diff --git a/base/poco/Foundation/src/pocomsg.mc b/base/poco/Foundation/src/pocomsg.mc
new file mode 100644
index 00000000000..d1f6d6e7a8e
--- /dev/null
+++ b/base/poco/Foundation/src/pocomsg.mc
@@ -0,0 +1,87 @@
+;//
+;// pocomsg.mc[.h]
+;//
+;// The Poco message source/header file.
+;//
+;// NOTE: pocomsg.h is automatically generated from pocomsg.mc.
+;//       Never edit pocomsg.h directly!
+;//
+;// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+;// and Contributors.
+;//
+;// Permission is hereby granted, free of charge, to any person or organization
+;// obtaining a copy of the software and accompanying documentation covered by
+;// this license (the "Software") to use, reproduce, display, distribute,
+;// execute, and transmit the Software, and to prepare derivative works of the
+;// Software, and to permit third-parties to whom the Software is furnished to
+;// do so, all subject to the following:
+;//
+;// The copyright notices in the Software and this entire statement, including
+;// the above license grant, this restriction and the following disclaimer,
+;// must be included in all copies of the Software, in whole or in part, and
+;// all derivative works of the Software, unless such copies or derivative
+;// works are solely in the form of machine-executable object code generated by
+;// a source language processor.
+;//
+;// 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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+;// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+;// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+;// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+;// DEALINGS IN THE SOFTWARE.
+;//
+
+
+;//
+;// Categories
+;//
+MessageId=0x1
+SymbolicName=POCO_CTG_FATAL
+Language=English
+Fatal
+.
+MessageId=0x2
+SymbolicName=POCO_CTG_CRITICAL
+Language=English
+Critical
+.
+MessageId=0x3
+SymbolicName=POCO_CTG_ERROR
+Language=English
+Error
+.
+MessageId=0x4
+SymbolicName=POCO_CTG_WARNING
+Language=English
+Warning
+.
+MessageId=0x5
+SymbolicName=POCO_CTG_NOTICE
+Language=English
+Notice
+.
+MessageId=0x6
+SymbolicName=POCO_CTG_INFORMATION
+Language=English
+Information
+.
+MessageId=0x7
+SymbolicName=POCO_CTG_DEBUG
+Language=English
+Debug
+.
+MessageId=0x8
+SymbolicName=POCO_CTG_TRACE
+Language=English
+Trace
+.
+
+;//
+;// Event Identifiers
+;//
+MessageId=0x1000
+SymbolicName=POCO_MSG_LOG
+Language=English
+%1
+.
diff --git a/base/poco/Foundation/src/strtod.cc b/base/poco/Foundation/src/strtod.cc
new file mode 100644
index 00000000000..68d02171911
--- /dev/null
+++ b/base/poco/Foundation/src/strtod.cc
@@ -0,0 +1,556 @@
+// Copyright 2010 the V8 project authors. 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 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 Google Inc. 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 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
+// OWNER 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.
+
+#include <stdarg.h>
+#include <limits.h>
+
+#include "strtod.h"
+#include "bignum.h"
+#include "cached-powers.h"
+#include "ieee.h"
+
+namespace double_conversion {
+
+// 2^53 = 9007199254740992.
+// Any integer with at most 15 decimal digits will hence fit into a double
+// (which has a 53bit significand) without loss of precision.
+static const int kMaxExactDoubleIntegerDecimalDigits = 15;
+// 2^64 = 18446744073709551616 > 10^19
+static const int kMaxUint64DecimalDigits = 19;
+
+// Max double: 1.7976931348623157 x 10^308
+// Min non-zero double: 4.9406564584124654 x 10^-324
+// Any x >= 10^309 is interpreted as +infinity.
+// Any x <= 10^-324 is interpreted as 0.
+// Note that 2.5e-324 (despite being smaller than the min double) will be read
+// as non-zero (equal to the min non-zero double).
+static const int kMaxDecimalPower = 309;
+static const int kMinDecimalPower = -324;
+
+// 2^64 = 18446744073709551616
+static const uint64_t kMaxUint64 = UINT64_2PART_C(0xFFFFFFFF, FFFFFFFF);
+
+
+static const double exact_powers_of_ten[] = {
+  1.0,  // 10^0
+  10.0,
+  100.0,
+  1000.0,
+  10000.0,
+  100000.0,
+  1000000.0,
+  10000000.0,
+  100000000.0,
+  1000000000.0,
+  10000000000.0,  // 10^10
+  100000000000.0,
+  1000000000000.0,
+  10000000000000.0,
+  100000000000000.0,
+  1000000000000000.0,
+  10000000000000000.0,
+  100000000000000000.0,
+  1000000000000000000.0,
+  10000000000000000000.0,
+  100000000000000000000.0,  // 10^20
+  1000000000000000000000.0,
+  // 10^22 = 0x21e19e0c9bab2400000 = 0x878678326eac9 * 2^22
+  10000000000000000000000.0
+};
+static const int kExactPowersOfTenSize = ARRAY_SIZE(exact_powers_of_ten);
+
+// Maximum number of significant digits in the decimal representation.
+// In fact the value is 772 (see conversions.cc), but to give us some margin
+// we round up to 780.
+static const int kMaxSignificantDecimalDigits = 780;
+
+static Vector<const char> TrimLeadingZeros(Vector<const char> buffer) {
+  for (int i = 0; i < buffer.length(); i++) {
+    if (buffer[i] != '0') {
+      return buffer.SubVector(i, buffer.length());
+    }
+  }
+  return Vector<const char>(buffer.start(), 0);
+}
+
+
+static Vector<const char> TrimTrailingZeros(Vector<const char> buffer) {
+  for (int i = buffer.length() - 1; i >= 0; --i) {
+    if (buffer[i] != '0') {
+      return buffer.SubVector(0, i + 1);
+    }
+  }
+  return Vector<const char>(buffer.start(), 0);
+}
+
+
+static void CutToMaxSignificantDigits(Vector<const char> buffer,
+                                       int exponent,
+                                       char* significant_buffer,
+                                       int* significant_exponent) {
+  for (int i = 0; i < kMaxSignificantDecimalDigits - 1; ++i) {
+    significant_buffer[i] = buffer[i];
+  }
+  // The input buffer has been trimmed. Therefore the last digit must be
+  // different from '0'.
+  ASSERT(buffer[buffer.length() - 1] != '0');
+  // Set the last digit to be non-zero. This is sufficient to guarantee
+  // correct rounding.
+  significant_buffer[kMaxSignificantDecimalDigits - 1] = '1';
+  *significant_exponent =
+      exponent + (buffer.length() - kMaxSignificantDecimalDigits);
+}
+
+
+// Trims the buffer and cuts it to at most kMaxSignificantDecimalDigits.
+// If possible the input-buffer is reused, but if the buffer needs to be
+// modified (due to cutting), then the input needs to be copied into the
+// buffer_copy_space.
+static void TrimAndCut(Vector<const char> buffer, int exponent,
+                       char* buffer_copy_space, int space_size,
+                       Vector<const char>* trimmed, int* updated_exponent) {
+  Vector<const char> left_trimmed = TrimLeadingZeros(buffer);
+  Vector<const char> right_trimmed = TrimTrailingZeros(left_trimmed);
+  exponent += left_trimmed.length() - right_trimmed.length();
+  if (right_trimmed.length() > kMaxSignificantDecimalDigits) {
+    (void) space_size;  // Mark variable as used.
+    ASSERT(space_size >= kMaxSignificantDecimalDigits);
+    CutToMaxSignificantDigits(right_trimmed, exponent,
+                              buffer_copy_space, updated_exponent);
+    *trimmed = Vector<const char>(buffer_copy_space,
+                                 kMaxSignificantDecimalDigits);
+  } else {
+    *trimmed = right_trimmed;
+    *updated_exponent = exponent;
+  }
+}
+
+
+// Reads digits from the buffer and converts them to a uint64.
+// Reads in as many digits as fit into a uint64.
+// When the string starts with "1844674407370955161" no further digit is read.
+// Since 2^64 = 18446744073709551616 it would still be possible read another
+// digit if it was less or equal than 6, but this would complicate the code.
+static uint64_t ReadUint64(Vector<const char> buffer,
+                           int* number_of_read_digits) {
+  uint64_t result = 0;
+  int i = 0;
+  while (i < buffer.length() && result <= (kMaxUint64 / 10 - 1)) {
+    int digit = buffer[i++] - '0';
+    ASSERT(0 <= digit && digit <= 9);
+    result = 10 * result + digit;
+  }
+  *number_of_read_digits = i;
+  return result;
+}
+
+
+// Reads a DiyFp from the buffer.
+// The returned DiyFp is not necessarily normalized.
+// If remaining_decimals is zero then the returned DiyFp is accurate.
+// Otherwise it has been rounded and has error of at most 1/2 ulp.
+static void ReadDiyFp(Vector<const char> buffer,
+                      DiyFp* result,
+                      int* remaining_decimals) {
+  int read_digits;
+  uint64_t significand = ReadUint64(buffer, &read_digits);
+  if (buffer.length() == read_digits) {
+    *result = DiyFp(significand, 0);
+    *remaining_decimals = 0;
+  } else {
+    // Round the significand.
+    if (buffer[read_digits] >= '5') {
+      significand++;
+    }
+    // Compute the binary exponent.
+    int exponent = 0;
+    *result = DiyFp(significand, exponent);
+    *remaining_decimals = buffer.length() - read_digits;
+  }
+}
+
+
+static bool DoubleStrtod(Vector<const char> trimmed,
+                         int exponent,
+                         double* result) {
+#if !defined(DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS)
+  // On x86 the floating-point stack can be 64 or 80 bits wide. If it is
+  // 80 bits wide (as is the case on Linux) then double-rounding occurs and the
+  // result is not accurate.
+  // We know that Windows32 uses 64 bits and is therefore accurate.
+  // Note that the ARM simulator is compiled for 32bits. It therefore exhibits
+  // the same problem.
+  return false;
+#endif
+  if (trimmed.length() <= kMaxExactDoubleIntegerDecimalDigits) {
+    int read_digits;
+    // The trimmed input fits into a double.
+    // If the 10^exponent (resp. 10^-exponent) fits into a double too then we
+    // can compute the result-double simply by multiplying (resp. dividing) the
+    // two numbers.
+    // This is possible because IEEE guarantees that floating-point operations
+    // return the best possible approximation.
+    if (exponent < 0 && -exponent < kExactPowersOfTenSize) {
+      // 10^-exponent fits into a double.
+      *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
+      ASSERT(read_digits == trimmed.length());
+      *result /= exact_powers_of_ten[-exponent];
+      return true;
+    }
+    if (0 <= exponent && exponent < kExactPowersOfTenSize) {
+      // 10^exponent fits into a double.
+      *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
+      ASSERT(read_digits == trimmed.length());
+      *result *= exact_powers_of_ten[exponent];
+      return true;
+    }
+    int remaining_digits =
+        kMaxExactDoubleIntegerDecimalDigits - trimmed.length();
+    if ((0 <= exponent) &&
+        (exponent - remaining_digits < kExactPowersOfTenSize)) {
+      // The trimmed string was short and we can multiply it with
+      // 10^remaining_digits. As a result the remaining exponent now fits
+      // into a double too.
+      *result = static_cast<double>(ReadUint64(trimmed, &read_digits));
+      ASSERT(read_digits == trimmed.length());
+      *result *= exact_powers_of_ten[remaining_digits];
+      *result *= exact_powers_of_ten[exponent - remaining_digits];
+      return true;
+    }
+  }
+  return false;
+}
+
+
+// Returns 10^exponent as an exact DiyFp.
+// The given exponent must be in the range [1; kDecimalExponentDistance[.
+static DiyFp AdjustmentPowerOfTen(int exponent) {
+  ASSERT(0 < exponent);
+  ASSERT(exponent < PowersOfTenCache::kDecimalExponentDistance);
+  // Simply hardcode the remaining powers for the given decimal exponent
+  // distance.
+  ASSERT(PowersOfTenCache::kDecimalExponentDistance == 8);
+  switch (exponent) {
+    case 1: return DiyFp(UINT64_2PART_C(0xa0000000, 00000000), -60);
+    case 2: return DiyFp(UINT64_2PART_C(0xc8000000, 00000000), -57);
+    case 3: return DiyFp(UINT64_2PART_C(0xfa000000, 00000000), -54);
+    case 4: return DiyFp(UINT64_2PART_C(0x9c400000, 00000000), -50);
+    case 5: return DiyFp(UINT64_2PART_C(0xc3500000, 00000000), -47);
+    case 6: return DiyFp(UINT64_2PART_C(0xf4240000, 00000000), -44);
+    case 7: return DiyFp(UINT64_2PART_C(0x98968000, 00000000), -40);
+    default:
+      UNREACHABLE();
+      return DiyFp(0, 0);
+  }
+}
+
+
+// If the function returns true then the result is the correct double.
+// Otherwise it is either the correct double or the double that is just below
+// the correct double.
+static bool DiyFpStrtod(Vector<const char> buffer,
+                        int exponent,
+                        double* result) {
+  DiyFp input;
+  int remaining_decimals;
+  ReadDiyFp(buffer, &input, &remaining_decimals);
+  // Since we may have dropped some digits the input is not accurate.
+  // If remaining_decimals is different than 0 than the error is at most
+  // .5 ulp (unit in the last place).
+  // We don't want to deal with fractions and therefore keep a common
+  // denominator.
+  const int kDenominatorLog = 3;
+  const int kDenominator = 1 << kDenominatorLog;
+  // Move the remaining decimals into the exponent.
+  exponent += remaining_decimals;
+  int error = (remaining_decimals == 0 ? 0 : kDenominator / 2);
+
+  int old_e = input.e();
+  input.Normalize();
+  error <<= old_e - input.e();
+
+  ASSERT(exponent <= PowersOfTenCache::kMaxDecimalExponent);
+  if (exponent < PowersOfTenCache::kMinDecimalExponent) {
+    *result = 0.0;
+    return true;
+  }
+  DiyFp cached_power;
+  int cached_decimal_exponent;
+  PowersOfTenCache::GetCachedPowerForDecimalExponent(exponent,
+                                                     &cached_power,
+                                                     &cached_decimal_exponent);
+
+  if (cached_decimal_exponent != exponent) {
+    int adjustment_exponent = exponent - cached_decimal_exponent;
+    DiyFp adjustment_power = AdjustmentPowerOfTen(adjustment_exponent);
+    input.Multiply(adjustment_power);
+    if (kMaxUint64DecimalDigits - buffer.length() >= adjustment_exponent) {
+      // The product of input with the adjustment power fits into a 64 bit
+      // integer.
+      ASSERT(DiyFp::kSignificandSize == 64);
+    } else {
+      // The adjustment power is exact. There is hence only an error of 0.5.
+      error += kDenominator / 2;
+    }
+  }
+
+  input.Multiply(cached_power);
+  // The error introduced by a multiplication of a*b equals
+  //   error_a + error_b + error_a*error_b/2^64 + 0.5
+  // Substituting a with 'input' and b with 'cached_power' we have
+  //   error_b = 0.5  (all cached powers have an error of less than 0.5 ulp),
+  //   error_ab = 0 or 1 / kDenominator > error_a*error_b/ 2^64
+  int error_b = kDenominator / 2;
+  int error_ab = (error == 0 ? 0 : 1);  // We round up to 1.
+  int fixed_error = kDenominator / 2;
+  error += error_b + error_ab + fixed_error;
+
+  old_e = input.e();
+  input.Normalize();
+  error <<= old_e - input.e();
+
+  // See if the double's significand changes if we add/subtract the error.
+  int order_of_magnitude = DiyFp::kSignificandSize + input.e();
+  int effective_significand_size =
+      Double::SignificandSizeForOrderOfMagnitude(order_of_magnitude);
+  int precision_digits_count =
+      DiyFp::kSignificandSize - effective_significand_size;
+  if (precision_digits_count + kDenominatorLog >= DiyFp::kSignificandSize) {
+    // This can only happen for very small denormals. In this case the
+    // half-way multiplied by the denominator exceeds the range of an uint64.
+    // Simply shift everything to the right.
+    int shift_amount = (precision_digits_count + kDenominatorLog) -
+        DiyFp::kSignificandSize + 1;
+    input.set_f(input.f() >> shift_amount);
+    input.set_e(input.e() + shift_amount);
+    // We add 1 for the lost precision of error, and kDenominator for
+    // the lost precision of input.f().
+    error = (error >> shift_amount) + 1 + kDenominator;
+    precision_digits_count -= shift_amount;
+  }
+  // We use uint64_ts now. This only works if the DiyFp uses uint64_ts too.
+  ASSERT(DiyFp::kSignificandSize == 64);
+  ASSERT(precision_digits_count < 64);
+  uint64_t one64 = 1;
+  uint64_t precision_bits_mask = (one64 << precision_digits_count) - 1;
+  uint64_t precision_bits = input.f() & precision_bits_mask;
+  uint64_t half_way = one64 << (precision_digits_count - 1);
+  precision_bits *= kDenominator;
+  half_way *= kDenominator;
+  DiyFp rounded_input(input.f() >> precision_digits_count,
+                      input.e() + precision_digits_count);
+  if (precision_bits >= half_way + error) {
+    rounded_input.set_f(rounded_input.f() + 1);
+  }
+  // If the last_bits are too close to the half-way case than we are too
+  // inaccurate and round down. In this case we return false so that we can
+  // fall back to a more precise algorithm.
+
+  *result = Double(rounded_input).value();
+  if (half_way - error < precision_bits && precision_bits < half_way + error) {
+    // Too imprecise. The caller will have to fall back to a slower version.
+    // However the returned number is guaranteed to be either the correct
+    // double, or the next-lower double.
+    return false;
+  } else {
+    return true;
+  }
+}
+
+
+// Returns
+//   - -1 if buffer*10^exponent < diy_fp.
+//   -  0 if buffer*10^exponent == diy_fp.
+//   - +1 if buffer*10^exponent > diy_fp.
+// Preconditions:
+//   buffer.length() + exponent <= kMaxDecimalPower + 1
+//   buffer.length() + exponent > kMinDecimalPower
+//   buffer.length() <= kMaxDecimalSignificantDigits
+static int CompareBufferWithDiyFp(Vector<const char> buffer,
+                                  int exponent,
+                                  DiyFp diy_fp) {
+  ASSERT(buffer.length() + exponent <= kMaxDecimalPower + 1);
+  ASSERT(buffer.length() + exponent > kMinDecimalPower);
+  ASSERT(buffer.length() <= kMaxSignificantDecimalDigits);
+  // Make sure that the Bignum will be able to hold all our numbers.
+  // Our Bignum implementation has a separate field for exponents. Shifts will
+  // consume at most one bigit (< 64 bits).
+  // ln(10) == 3.3219...
+  ASSERT(((kMaxDecimalPower + 1) * 333 / 100) < Bignum::kMaxSignificantBits);
+  Bignum buffer_bignum;
+  Bignum diy_fp_bignum;
+  buffer_bignum.AssignDecimalString(buffer);
+  diy_fp_bignum.AssignUInt64(diy_fp.f());
+  if (exponent >= 0) {
+    buffer_bignum.MultiplyByPowerOfTen(exponent);
+  } else {
+    diy_fp_bignum.MultiplyByPowerOfTen(-exponent);
+  }
+  if (diy_fp.e() > 0) {
+    diy_fp_bignum.ShiftLeft(diy_fp.e());
+  } else {
+    buffer_bignum.ShiftLeft(-diy_fp.e());
+  }
+  return Bignum::Compare(buffer_bignum, diy_fp_bignum);
+}
+
+
+// Returns true if the guess is the correct double.
+// Returns false, when guess is either correct or the next-lower double.
+static bool ComputeGuess(Vector<const char> trimmed, int exponent,
+                         double* guess) {
+  if (trimmed.length() == 0) {
+    *guess = 0.0;
+    return true;
+  }
+  if (exponent + trimmed.length() - 1 >= kMaxDecimalPower) {
+    *guess = Double::Infinity();
+    return true;
+  }
+  if (exponent + trimmed.length() <= kMinDecimalPower) {
+    *guess = 0.0;
+    return true;
+  }
+
+  if (DoubleStrtod(trimmed, exponent, guess) ||
+      DiyFpStrtod(trimmed, exponent, guess)) {
+    return true;
+  }
+  if (*guess == Double::Infinity()) {
+    return true;
+  }
+  return false;
+}
+
+double Strtod(Vector<const char> buffer, int exponent) {
+  char copy_buffer[kMaxSignificantDecimalDigits];
+  Vector<const char> trimmed;
+  int updated_exponent;
+  TrimAndCut(buffer, exponent, copy_buffer, kMaxSignificantDecimalDigits,
+             &trimmed, &updated_exponent);
+  exponent = updated_exponent;
+
+  double guess;
+  bool is_correct = ComputeGuess(trimmed, exponent, &guess);
+  if (is_correct) return guess;
+
+  DiyFp upper_boundary = Double(guess).UpperBoundary();
+  int comparison = CompareBufferWithDiyFp(trimmed, exponent, upper_boundary);
+  if (comparison < 0) {
+    return guess;
+  } else if (comparison > 0) {
+    return Double(guess).NextDouble();
+  } else if ((Double(guess).Significand() & 1) == 0) {
+    // Round towards even.
+    return guess;
+  } else {
+    return Double(guess).NextDouble();
+  }
+}
+
+float Strtof(Vector<const char> buffer, int exponent) {
+  char copy_buffer[kMaxSignificantDecimalDigits];
+  Vector<const char> trimmed;
+  int updated_exponent;
+  TrimAndCut(buffer, exponent, copy_buffer, kMaxSignificantDecimalDigits,
+             &trimmed, &updated_exponent);
+  exponent = updated_exponent;
+
+  double double_guess;
+  bool is_correct = ComputeGuess(trimmed, exponent, &double_guess);
+
+  float float_guess = static_cast<float>(double_guess);
+  if (float_guess == double_guess) {
+    // This shortcut triggers for integer values.
+    return float_guess;
+  }
+
+  // We must catch double-rounding. Say the double has been rounded up, and is
+  // now a boundary of a float, and rounds up again. This is why we have to
+  // look at previous too.
+  // Example (in decimal numbers):
+  //    input: 12349
+  //    high-precision (4 digits): 1235
+  //    low-precision (3 digits):
+  //       when read from input: 123
+  //       when rounded from high precision: 124.
+  // To do this we simply look at the neigbors of the correct result and see
+  // if they would round to the same float. If the guess is not correct we have
+  // to look at four values (since two different doubles could be the correct
+  // double).
+
+  double double_next = Double(double_guess).NextDouble();
+  double double_previous = Double(double_guess).PreviousDouble();
+
+  float f1 = static_cast<float>(double_previous);
+  float f2 = float_guess;
+  float f3 = static_cast<float>(double_next);
+  float f4;
+  if (is_correct) {
+    f4 = f3;
+  } else {
+    double double_next2 = Double(double_next).NextDouble();
+    f4 = static_cast<float>(double_next2);
+  }
+  (void) f2;  // Mark variable as used.
+  ASSERT(f1 <= f2 && f2 <= f3 && f3 <= f4);
+
+  // If the guess doesn't lie near a single-precision boundary we can simply
+  // return its float-value.
+  if (f1 == f4) {
+    return float_guess;
+  }
+
+  ASSERT((f1 != f2 && f2 == f3 && f3 == f4) ||
+         (f1 == f2 && f2 != f3 && f3 == f4) ||
+         (f1 == f2 && f2 == f3 && f3 != f4));
+
+  // guess and next are the two possible canditates (in the same way that
+  // double_guess was the lower candidate for a double-precision guess).
+  float guess = f1;
+  float next = f4;
+  DiyFp upper_boundary;
+  if (guess == 0.0f) {
+    float min_float = 1e-45f;
+    upper_boundary = Double(static_cast<double>(min_float) / 2).AsDiyFp();
+  } else {
+    upper_boundary = Single(guess).UpperBoundary();
+  }
+  int comparison = CompareBufferWithDiyFp(trimmed, exponent, upper_boundary);
+  if (comparison < 0) {
+    return guess;
+  } else if (comparison > 0) {
+    return next;
+  } else if ((Single(guess).Significand() & 1) == 0) {
+    // Round towards even.
+    return guess;
+  } else {
+    return next;
+  }
+}
+
+}  // namespace double_conversion
diff --git a/base/poco/Foundation/src/strtod.h b/base/poco/Foundation/src/strtod.h
new file mode 100644
index 00000000000..ed0293b8f54
--- /dev/null
+++ b/base/poco/Foundation/src/strtod.h
@@ -0,0 +1,45 @@
+// Copyright 2010 the V8 project authors. 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 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 Google Inc. 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 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
+// OWNER 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.
+
+#ifndef DOUBLE_CONVERSION_STRTOD_H_
+#define DOUBLE_CONVERSION_STRTOD_H_
+
+#include "utils.h"
+
+namespace double_conversion {
+
+// The buffer must only contain digits in the range [0-9]. It must not
+// contain a dot or a sign. It must not start with '0', and must not be empty.
+double Strtod(Vector<const char> buffer, int exponent);
+
+// The buffer must only contain digits in the range [0-9]. It must not
+// contain a dot or a sign. It must not start with '0', and must not be empty.
+float Strtof(Vector<const char> buffer, int exponent);
+
+}  // namespace double_conversion
+
+#endif  // DOUBLE_CONVERSION_STRTOD_H_
diff --git a/base/poco/Foundation/src/trees.c b/base/poco/Foundation/src/trees.c
new file mode 100644
index 00000000000..50cf4b4571c
--- /dev/null
+++ b/base/poco/Foundation/src/trees.c
@@ -0,0 +1,1203 @@
+/* trees.c -- output deflated data using Huffman coding
+ * Copyright (C) 1995-2017 Jean-loup Gailly
+ * detect_data_type() function provided freely by Cosmin Truta, 2006
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ *  ALGORITHM
+ *
+ *      The "deflation" process uses several Huffman trees. The more
+ *      common source values are represented by shorter bit sequences.
+ *
+ *      Each code tree is stored in a compressed form which is itself
+ * a Huffman encoding of the lengths of all the code strings (in
+ * ascending order by source values).  The actual code strings are
+ * reconstructed from the lengths in the inflate process, as described
+ * in the deflate specification.
+ *
+ *  REFERENCES
+ *
+ *      Deutsch, L.P.,"'Deflate' Compressed Data Format Specification".
+ *      Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc
+ *
+ *      Storer, James A.
+ *          Data Compression:  Methods and Theory, pp. 49-50.
+ *          Computer Science Press, 1988.  ISBN 0-7167-8156-5.
+ *
+ *      Sedgewick, R.
+ *          Algorithms, p290.
+ *          Addison-Wesley, 1983. ISBN 0-201-06672-6.
+ */
+
+/* @(#) $Id$ */
+
+/* #define GEN_TREES_H */
+
+#include "deflate.h"
+
+#ifdef ZLIB_DEBUG
+#  include <ctype.h>
+#endif
+
+/* ===========================================================================
+ * Constants
+ */
+
+#define MAX_BL_BITS 7
+/* Bit length codes must not exceed MAX_BL_BITS bits */
+
+#define END_BLOCK 256
+/* end of block literal code */
+
+#define REP_3_6      16
+/* repeat previous bit length 3-6 times (2 bits of repeat count) */
+
+#define REPZ_3_10    17
+/* repeat a zero length 3-10 times  (3 bits of repeat count) */
+
+#define REPZ_11_138  18
+/* repeat a zero length 11-138 times  (7 bits of repeat count) */
+
+local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */
+   = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0};
+
+local const int extra_dbits[D_CODES] /* extra bits for each distance code */
+   = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13};
+
+local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */
+   = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7};
+
+local const uch bl_order[BL_CODES]
+   = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15};
+/* The lengths of the bit length codes are sent in order of decreasing
+ * probability, to avoid transmitting the lengths for unused bit length codes.
+ */
+
+/* ===========================================================================
+ * Local data. These are initialized only once.
+ */
+
+#define DIST_CODE_LEN  512 /* see definition of array dist_code below */
+
+#if defined(GEN_TREES_H) || !defined(STDC)
+/* non ANSI compilers may not accept trees.h */
+
+local ct_data static_ltree[L_CODES+2];
+/* The static literal tree. Since the bit lengths are imposed, there is no
+ * need for the L_CODES extra codes used during heap construction. However
+ * The codes 286 and 287 are needed to build a canonical tree (see _tr_init
+ * below).
+ */
+
+local ct_data static_dtree[D_CODES];
+/* The static distance tree. (Actually a trivial tree since all codes use
+ * 5 bits.)
+ */
+
+uch _dist_code[DIST_CODE_LEN];
+/* Distance codes. The first 256 values correspond to the distances
+ * 3 .. 258, the last 256 values correspond to the top 8 bits of
+ * the 15 bit distances.
+ */
+
+uch _length_code[MAX_MATCH-MIN_MATCH+1];
+/* length code for each normalized match length (0 == MIN_MATCH) */
+
+local int base_length[LENGTH_CODES];
+/* First normalized length for each code (0 = MIN_MATCH) */
+
+local int base_dist[D_CODES];
+/* First normalized distance for each code (0 = distance of 1) */
+
+#else
+#  include "trees.h"
+#endif /* GEN_TREES_H */
+
+struct static_tree_desc_s {
+    const ct_data *static_tree;  /* static tree or NULL */
+    const intf *extra_bits;      /* extra bits for each code or NULL */
+    int     extra_base;          /* base index for extra_bits */
+    int     elems;               /* max number of elements in the tree */
+    int     max_length;          /* max bit length for the codes */
+};
+
+local const static_tree_desc  static_l_desc =
+{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
+
+local const static_tree_desc  static_d_desc =
+{static_dtree, extra_dbits, 0,          D_CODES, MAX_BITS};
+
+local const static_tree_desc  static_bl_desc =
+{(const ct_data *)0, extra_blbits, 0,   BL_CODES, MAX_BL_BITS};
+
+/* ===========================================================================
+ * Local (static) routines in this file.
+ */
+
+local void tr_static_init OF((void));
+local void init_block     OF((deflate_state *s));
+local void pqdownheap     OF((deflate_state *s, ct_data *tree, int k));
+local void gen_bitlen     OF((deflate_state *s, tree_desc *desc));
+local void gen_codes      OF((ct_data *tree, int max_code, ushf *bl_count));
+local void build_tree     OF((deflate_state *s, tree_desc *desc));
+local void scan_tree      OF((deflate_state *s, ct_data *tree, int max_code));
+local void send_tree      OF((deflate_state *s, ct_data *tree, int max_code));
+local int  build_bl_tree  OF((deflate_state *s));
+local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes,
+                              int blcodes));
+local void compress_block OF((deflate_state *s, const ct_data *ltree,
+                              const ct_data *dtree));
+local int  detect_data_type OF((deflate_state *s));
+local unsigned bi_reverse OF((unsigned value, int length));
+local void bi_windup      OF((deflate_state *s));
+local void bi_flush       OF((deflate_state *s));
+
+#ifdef GEN_TREES_H
+local void gen_trees_header OF((void));
+#endif
+
+#ifndef ZLIB_DEBUG
+#  define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len)
+   /* Send a code of the given tree. c and tree must not have side effects */
+
+#else /* !ZLIB_DEBUG */
+#  define send_code(s, c, tree) \
+     { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \
+       send_bits(s, tree[c].Code, tree[c].Len); }
+#endif
+
+/* ===========================================================================
+ * Output a short LSB first on the stream.
+ * IN assertion: there is enough room in pendingBuf.
+ */
+#define put_short(s, w) { \
+    put_byte(s, (uch)((w) & 0xff)); \
+    put_byte(s, (uch)((ush)(w) >> 8)); \
+}
+
+/* ===========================================================================
+ * Send a value on a given number of bits.
+ * IN assertion: length <= 16 and value fits in length bits.
+ */
+#ifdef ZLIB_DEBUG
+local void send_bits      OF((deflate_state *s, int value, int length));
+
+local void send_bits(s, value, length)
+    deflate_state *s;
+    int value;  /* value to send */
+    int length; /* number of bits */
+{
+    Tracevv((stderr," l %2d v %4x ", length, value));
+    Assert(length > 0 && length <= 15, "invalid length");
+    s->bits_sent += (ulg)length;
+
+    /* If not enough room in bi_buf, use (valid) bits from bi_buf and
+     * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
+     * unused bits in value.
+     */
+    if (s->bi_valid > (int)Buf_size - length) {
+        s->bi_buf |= (ush)value << s->bi_valid;
+        put_short(s, s->bi_buf);
+        s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
+        s->bi_valid += length - Buf_size;
+    } else {
+        s->bi_buf |= (ush)value << s->bi_valid;
+        s->bi_valid += length;
+    }
+}
+#else /* !ZLIB_DEBUG */
+
+#define send_bits(s, value, length) \
+{ int len = length;\
+  if (s->bi_valid > (int)Buf_size - len) {\
+    int val = (int)value;\
+    s->bi_buf |= (ush)val << s->bi_valid;\
+    put_short(s, s->bi_buf);\
+    s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\
+    s->bi_valid += len - Buf_size;\
+  } else {\
+    s->bi_buf |= (ush)(value) << s->bi_valid;\
+    s->bi_valid += len;\
+  }\
+}
+#endif /* ZLIB_DEBUG */
+
+
+/* the arguments must not have side effects */
+
+/* ===========================================================================
+ * Initialize the various 'constant' tables.
+ */
+local void tr_static_init()
+{
+#if defined(GEN_TREES_H) || !defined(STDC)
+    static int static_init_done = 0;
+    int n;        /* iterates over tree elements */
+    int bits;     /* bit counter */
+    int length;   /* length value */
+    int code;     /* code value */
+    int dist;     /* distance index */
+    ush bl_count[MAX_BITS+1];
+    /* number of codes at each bit length for an optimal tree */
+
+    if (static_init_done) return;
+
+    /* For some embedded targets, global variables are not initialized: */
+#ifdef NO_INIT_GLOBAL_POINTERS
+    static_l_desc.static_tree = static_ltree;
+    static_l_desc.extra_bits = extra_lbits;
+    static_d_desc.static_tree = static_dtree;
+    static_d_desc.extra_bits = extra_dbits;
+    static_bl_desc.extra_bits = extra_blbits;
+#endif
+
+    /* Initialize the mapping length (0..255) -> length code (0..28) */
+    length = 0;
+    for (code = 0; code < LENGTH_CODES-1; code++) {
+        base_length[code] = length;
+        for (n = 0; n < (1<<extra_lbits[code]); n++) {
+            _length_code[length++] = (uch)code;
+        }
+    }
+    Assert (length == 256, "tr_static_init: length != 256");
+    /* Note that the length 255 (match length 258) can be represented
+     * in two different ways: code 284 + 5 bits or code 285, so we
+     * overwrite length_code[255] to use the best encoding:
+     */
+    _length_code[length-1] = (uch)code;
+
+    /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
+    dist = 0;
+    for (code = 0 ; code < 16; code++) {
+        base_dist[code] = dist;
+        for (n = 0; n < (1<<extra_dbits[code]); n++) {
+            _dist_code[dist++] = (uch)code;
+        }
+    }
+    Assert (dist == 256, "tr_static_init: dist != 256");
+    dist >>= 7; /* from now on, all distances are divided by 128 */
+    for ( ; code < D_CODES; code++) {
+        base_dist[code] = dist << 7;
+        for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) {
+            _dist_code[256 + dist++] = (uch)code;
+        }
+    }
+    Assert (dist == 256, "tr_static_init: 256+dist != 512");
+
+    /* Construct the codes of the static literal tree */
+    for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0;
+    n = 0;
+    while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++;
+    while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++;
+    while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++;
+    while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++;
+    /* Codes 286 and 287 do not exist, but we must include them in the
+     * tree construction to get a canonical Huffman tree (longest code
+     * all ones)
+     */
+    gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count);
+
+    /* The static distance tree is trivial: */
+    for (n = 0; n < D_CODES; n++) {
+        static_dtree[n].Len = 5;
+        static_dtree[n].Code = bi_reverse((unsigned)n, 5);
+    }
+    static_init_done = 1;
+
+#  ifdef GEN_TREES_H
+    gen_trees_header();
+#  endif
+#endif /* defined(GEN_TREES_H) || !defined(STDC) */
+}
+
+/* ===========================================================================
+ * Genererate the file trees.h describing the static trees.
+ */
+#ifdef GEN_TREES_H
+#  ifndef ZLIB_DEBUG
+#    include <stdio.h>
+#  endif
+
+#  define SEPARATOR(i, last, width) \
+      ((i) == (last)? "\n};\n\n" :    \
+       ((i) % (width) == (width)-1 ? ",\n" : ", "))
+
+void gen_trees_header()
+{
+    FILE *header = fopen("trees.h", "w");
+    int i;
+
+    Assert (header != NULL, "Can't open trees.h");
+    fprintf(header,
+            "/* header created automatically with -DGEN_TREES_H */\n\n");
+
+    fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n");
+    for (i = 0; i < L_CODES+2; i++) {
+        fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code,
+                static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5));
+    }
+
+    fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n");
+    for (i = 0; i < D_CODES; i++) {
+        fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code,
+                static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5));
+    }
+
+    fprintf(header, "const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {\n");
+    for (i = 0; i < DIST_CODE_LEN; i++) {
+        fprintf(header, "%2u%s", _dist_code[i],
+                SEPARATOR(i, DIST_CODE_LEN-1, 20));
+    }
+
+    fprintf(header,
+        "const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {\n");
+    for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) {
+        fprintf(header, "%2u%s", _length_code[i],
+                SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20));
+    }
+
+    fprintf(header, "local const int base_length[LENGTH_CODES] = {\n");
+    for (i = 0; i < LENGTH_CODES; i++) {
+        fprintf(header, "%1u%s", base_length[i],
+                SEPARATOR(i, LENGTH_CODES-1, 20));
+    }
+
+    fprintf(header, "local const int base_dist[D_CODES] = {\n");
+    for (i = 0; i < D_CODES; i++) {
+        fprintf(header, "%5u%s", base_dist[i],
+                SEPARATOR(i, D_CODES-1, 10));
+    }
+
+    fclose(header);
+}
+#endif /* GEN_TREES_H */
+
+/* ===========================================================================
+ * Initialize the tree data structures for a new zlib stream.
+ */
+void ZLIB_INTERNAL _tr_init(s)
+    deflate_state *s;
+{
+    tr_static_init();
+
+    s->l_desc.dyn_tree = s->dyn_ltree;
+    s->l_desc.stat_desc = &static_l_desc;
+
+    s->d_desc.dyn_tree = s->dyn_dtree;
+    s->d_desc.stat_desc = &static_d_desc;
+
+    s->bl_desc.dyn_tree = s->bl_tree;
+    s->bl_desc.stat_desc = &static_bl_desc;
+
+    s->bi_buf = 0;
+    s->bi_valid = 0;
+#ifdef ZLIB_DEBUG
+    s->compressed_len = 0L;
+    s->bits_sent = 0L;
+#endif
+
+    /* Initialize the first block of the first file: */
+    init_block(s);
+}
+
+/* ===========================================================================
+ * Initialize a new block.
+ */
+local void init_block(s)
+    deflate_state *s;
+{
+    int n; /* iterates over tree elements */
+
+    /* Initialize the trees. */
+    for (n = 0; n < L_CODES;  n++) s->dyn_ltree[n].Freq = 0;
+    for (n = 0; n < D_CODES;  n++) s->dyn_dtree[n].Freq = 0;
+    for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;
+
+    s->dyn_ltree[END_BLOCK].Freq = 1;
+    s->opt_len = s->static_len = 0L;
+    s->last_lit = s->matches = 0;
+}
+
+#define SMALLEST 1
+/* Index within the heap array of least frequent node in the Huffman tree */
+
+
+/* ===========================================================================
+ * Remove the smallest element from the heap and recreate the heap with
+ * one less element. Updates heap and heap_len.
+ */
+#define pqremove(s, tree, top) \
+{\
+    top = s->heap[SMALLEST]; \
+    s->heap[SMALLEST] = s->heap[s->heap_len--]; \
+    pqdownheap(s, tree, SMALLEST); \
+}
+
+/* ===========================================================================
+ * Compares to subtrees, using the tree depth as tie breaker when
+ * the subtrees have equal frequency. This minimizes the worst case length.
+ */
+#define smaller(tree, n, m, depth) \
+   (tree[n].Freq < tree[m].Freq || \
+   (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m]))
+
+/* ===========================================================================
+ * Restore the heap property by moving down the tree starting at node k,
+ * exchanging a node with the smallest of its two sons if necessary, stopping
+ * when the heap property is re-established (each father smaller than its
+ * two sons).
+ */
+local void pqdownheap(s, tree, k)
+    deflate_state *s;
+    ct_data *tree;  /* the tree to restore */
+    int k;               /* node to move down */
+{
+    int v = s->heap[k];
+    int j = k << 1;  /* left son of k */
+    while (j <= s->heap_len) {
+        /* Set j to the smallest of the two sons: */
+        if (j < s->heap_len &&
+            smaller(tree, s->heap[j+1], s->heap[j], s->depth)) {
+            j++;
+        }
+        /* Exit if v is smaller than both sons */
+        if (smaller(tree, v, s->heap[j], s->depth)) break;
+
+        /* Exchange v with the smallest son */
+        s->heap[k] = s->heap[j];  k = j;
+
+        /* And continue down the tree, setting j to the left son of k */
+        j <<= 1;
+    }
+    s->heap[k] = v;
+}
+
+/* ===========================================================================
+ * Compute the optimal bit lengths for a tree and update the total bit length
+ * for the current block.
+ * IN assertion: the fields freq and dad are set, heap[heap_max] and
+ *    above are the tree nodes sorted by increasing frequency.
+ * OUT assertions: the field len is set to the optimal bit length, the
+ *     array bl_count contains the frequencies for each bit length.
+ *     The length opt_len is updated; static_len is also updated if stree is
+ *     not null.
+ */
+local void gen_bitlen(s, desc)
+    deflate_state *s;
+    tree_desc *desc;    /* the tree descriptor */
+{
+    ct_data *tree        = desc->dyn_tree;
+    int max_code         = desc->max_code;
+    const ct_data *stree = desc->stat_desc->static_tree;
+    const intf *extra    = desc->stat_desc->extra_bits;
+    int base             = desc->stat_desc->extra_base;
+    int max_length       = desc->stat_desc->max_length;
+    int h;              /* heap index */
+    int n, m;           /* iterate over the tree elements */
+    int bits;           /* bit length */
+    int xbits;          /* extra bits */
+    ush f;              /* frequency */
+    int overflow = 0;   /* number of elements with bit length too large */
+
+    for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0;
+
+    /* In a first pass, compute the optimal bit lengths (which may
+     * overflow in the case of the bit length tree).
+     */
+    tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */
+
+    for (h = s->heap_max+1; h < HEAP_SIZE; h++) {
+        n = s->heap[h];
+        bits = tree[tree[n].Dad].Len + 1;
+        if (bits > max_length) bits = max_length, overflow++;
+        tree[n].Len = (ush)bits;
+        /* We overwrite tree[n].Dad which is no longer needed */
+
+        if (n > max_code) continue; /* not a leaf node */
+
+        s->bl_count[bits]++;
+        xbits = 0;
+        if (n >= base) xbits = extra[n-base];
+        f = tree[n].Freq;
+        s->opt_len += (ulg)f * (unsigned)(bits + xbits);
+        if (stree) s->static_len += (ulg)f * (unsigned)(stree[n].Len + xbits);
+    }
+    if (overflow == 0) return;
+
+    Tracev((stderr,"\nbit length overflow\n"));
+    /* This happens for example on obj2 and pic of the Calgary corpus */
+
+    /* Find the first bit length which could increase: */
+    do {
+        bits = max_length-1;
+        while (s->bl_count[bits] == 0) bits--;
+        s->bl_count[bits]--;      /* move one leaf down the tree */
+        s->bl_count[bits+1] += 2; /* move one overflow item as its brother */
+        s->bl_count[max_length]--;
+        /* The brother of the overflow item also moves one step up,
+         * but this does not affect bl_count[max_length]
+         */
+        overflow -= 2;
+    } while (overflow > 0);
+
+    /* Now recompute all bit lengths, scanning in increasing frequency.
+     * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all
+     * lengths instead of fixing only the wrong ones. This idea is taken
+     * from 'ar' written by Haruhiko Okumura.)
+     */
+    for (bits = max_length; bits != 0; bits--) {
+        n = s->bl_count[bits];
+        while (n != 0) {
+            m = s->heap[--h];
+            if (m > max_code) continue;
+            if ((unsigned) tree[m].Len != (unsigned) bits) {
+                Tracev((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
+                s->opt_len += ((ulg)bits - tree[m].Len) * tree[m].Freq;
+                tree[m].Len = (ush)bits;
+            }
+            n--;
+        }
+    }
+}
+
+/* ===========================================================================
+ * Generate the codes for a given tree and bit counts (which need not be
+ * optimal).
+ * IN assertion: the array bl_count contains the bit length statistics for
+ * the given tree and the field len is set for all tree elements.
+ * OUT assertion: the field code is set for all tree elements of non
+ *     zero code length.
+ */
+local void gen_codes (tree, max_code, bl_count)
+    ct_data *tree;             /* the tree to decorate */
+    int max_code;              /* largest code with non zero frequency */
+    ushf *bl_count;            /* number of codes at each bit length */
+{
+    ush next_code[MAX_BITS+1]; /* next code value for each bit length */
+    unsigned code = 0;         /* running code value */
+    int bits;                  /* bit index */
+    int n;                     /* code index */
+
+    /* The distribution counts are first used to generate the code values
+     * without bit reversal.
+     */
+    for (bits = 1; bits <= MAX_BITS; bits++) {
+        code = (code + bl_count[bits-1]) << 1;
+        next_code[bits] = (ush)code;
+    }
+    /* Check that the bit counts in bl_count are consistent. The last code
+     * must be all ones.
+     */
+    Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,
+            "inconsistent bit counts");
+    Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
+
+    for (n = 0;  n <= max_code; n++) {
+        int len = tree[n].Len;
+        if (len == 0) continue;
+        /* Now reverse the bits */
+        tree[n].Code = (ush)bi_reverse(next_code[len]++, len);
+
+        Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
+             n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
+    }
+}
+
+/* ===========================================================================
+ * Construct one Huffman tree and assigns the code bit strings and lengths.
+ * Update the total bit length for the current block.
+ * IN assertion: the field freq is set for all tree elements.
+ * OUT assertions: the fields len and code are set to the optimal bit length
+ *     and corresponding code. The length opt_len is updated; static_len is
+ *     also updated if stree is not null. The field max_code is set.
+ */
+local void build_tree(s, desc)
+    deflate_state *s;
+    tree_desc *desc; /* the tree descriptor */
+{
+    ct_data *tree         = desc->dyn_tree;
+    const ct_data *stree  = desc->stat_desc->static_tree;
+    int elems             = desc->stat_desc->elems;
+    int n, m;          /* iterate over heap elements */
+    int max_code = -1; /* largest code with non zero frequency */
+    int node;          /* new node being created */
+
+    /* Construct the initial heap, with least frequent element in
+     * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].
+     * heap[0] is not used.
+     */
+    s->heap_len = 0, s->heap_max = HEAP_SIZE;
+
+    for (n = 0; n < elems; n++) {
+        if (tree[n].Freq != 0) {
+            s->heap[++(s->heap_len)] = max_code = n;
+            s->depth[n] = 0;
+        } else {
+            tree[n].Len = 0;
+        }
+    }
+
+    /* The pkzip format requires that at least one distance code exists,
+     * and that at least one bit should be sent even if there is only one
+     * possible code. So to avoid special checks later on we force at least
+     * two codes of non zero frequency.
+     */
+    while (s->heap_len < 2) {
+        node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0);
+        tree[node].Freq = 1;
+        s->depth[node] = 0;
+        s->opt_len--; if (stree) s->static_len -= stree[node].Len;
+        /* node is 0 or 1 so it does not have extra bits */
+    }
+    desc->max_code = max_code;
+
+    /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,
+     * establish sub-heaps of increasing lengths:
+     */
+    for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n);
+
+    /* Construct the Huffman tree by repeatedly combining the least two
+     * frequent nodes.
+     */
+    node = elems;              /* next internal node of the tree */
+    do {
+        pqremove(s, tree, n);  /* n = node of least frequency */
+        m = s->heap[SMALLEST]; /* m = node of next least frequency */
+
+        s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */
+        s->heap[--(s->heap_max)] = m;
+
+        /* Create a new node father of n and m */
+        tree[node].Freq = tree[n].Freq + tree[m].Freq;
+        s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ?
+                                s->depth[n] : s->depth[m]) + 1);
+        tree[n].Dad = tree[m].Dad = (ush)node;
+#ifdef DUMP_BL_TREE
+        if (tree == s->bl_tree) {
+            fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)",
+                    node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq);
+        }
+#endif
+        /* and insert the new node in the heap */
+        s->heap[SMALLEST] = node++;
+        pqdownheap(s, tree, SMALLEST);
+
+    } while (s->heap_len >= 2);
+
+    s->heap[--(s->heap_max)] = s->heap[SMALLEST];
+
+    /* At this point, the fields freq and dad are set. We can now
+     * generate the bit lengths.
+     */
+    gen_bitlen(s, (tree_desc *)desc);
+
+    /* The field len is now set, we can generate the bit codes */
+    gen_codes ((ct_data *)tree, max_code, s->bl_count);
+}
+
+/* ===========================================================================
+ * Scan a literal or distance tree to determine the frequencies of the codes
+ * in the bit length tree.
+ */
+local void scan_tree (s, tree, max_code)
+    deflate_state *s;
+    ct_data *tree;   /* the tree to be scanned */
+    int max_code;    /* and its largest code of non zero frequency */
+{
+    int n;                     /* iterates over all tree elements */
+    int prevlen = -1;          /* last emitted length */
+    int curlen;                /* length of current code */
+    int nextlen = tree[0].Len; /* length of next code */
+    int count = 0;             /* repeat count of the current code */
+    int max_count = 7;         /* max repeat count */
+    int min_count = 4;         /* min repeat count */
+
+    if (nextlen == 0) max_count = 138, min_count = 3;
+    tree[max_code+1].Len = (ush)0xffff; /* guard */
+
+    for (n = 0; n <= max_code; n++) {
+        curlen = nextlen; nextlen = tree[n+1].Len;
+        if (++count < max_count && curlen == nextlen) {
+            continue;
+        } else if (count < min_count) {
+            s->bl_tree[curlen].Freq += count;
+        } else if (curlen != 0) {
+            if (curlen != prevlen) s->bl_tree[curlen].Freq++;
+            s->bl_tree[REP_3_6].Freq++;
+        } else if (count <= 10) {
+            s->bl_tree[REPZ_3_10].Freq++;
+        } else {
+            s->bl_tree[REPZ_11_138].Freq++;
+        }
+        count = 0; prevlen = curlen;
+        if (nextlen == 0) {
+            max_count = 138, min_count = 3;
+        } else if (curlen == nextlen) {
+            max_count = 6, min_count = 3;
+        } else {
+            max_count = 7, min_count = 4;
+        }
+    }
+}
+
+/* ===========================================================================
+ * Send a literal or distance tree in compressed form, using the codes in
+ * bl_tree.
+ */
+local void send_tree (s, tree, max_code)
+    deflate_state *s;
+    ct_data *tree; /* the tree to be scanned */
+    int max_code;       /* and its largest code of non zero frequency */
+{
+    int n;                     /* iterates over all tree elements */
+    int prevlen = -1;          /* last emitted length */
+    int curlen;                /* length of current code */
+    int nextlen = tree[0].Len; /* length of next code */
+    int count = 0;             /* repeat count of the current code */
+    int max_count = 7;         /* max repeat count */
+    int min_count = 4;         /* min repeat count */
+
+    /* tree[max_code+1].Len = -1; */  /* guard already set */
+    if (nextlen == 0) max_count = 138, min_count = 3;
+
+    for (n = 0; n <= max_code; n++) {
+        curlen = nextlen; nextlen = tree[n+1].Len;
+        if (++count < max_count && curlen == nextlen) {
+            continue;
+        } else if (count < min_count) {
+            do { send_code(s, curlen, s->bl_tree); } while (--count != 0);
+
+        } else if (curlen != 0) {
+            if (curlen != prevlen) {
+                send_code(s, curlen, s->bl_tree); count--;
+            }
+            Assert(count >= 3 && count <= 6, " 3_6?");
+            send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2);
+
+        } else if (count <= 10) {
+            send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);
+
+        } else {
+            send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7);
+        }
+        count = 0; prevlen = curlen;
+        if (nextlen == 0) {
+            max_count = 138, min_count = 3;
+        } else if (curlen == nextlen) {
+            max_count = 6, min_count = 3;
+        } else {
+            max_count = 7, min_count = 4;
+        }
+    }
+}
+
+/* ===========================================================================
+ * Construct the Huffman tree for the bit lengths and return the index in
+ * bl_order of the last bit length code to send.
+ */
+local int build_bl_tree(s)
+    deflate_state *s;
+{
+    int max_blindex;  /* index of last bit length code of non zero freq */
+
+    /* Determine the bit length frequencies for literal and distance trees */
+    scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
+    scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);
+
+    /* Build the bit length tree: */
+    build_tree(s, (tree_desc *)(&(s->bl_desc)));
+    /* opt_len now includes the length of the tree representations, except
+     * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
+     */
+
+    /* Determine the number of bit length codes to send. The pkzip format
+     * requires that at least 4 bit length codes be sent. (appnote.txt says
+     * 3 but the actual value used is 4.)
+     */
+    for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
+        if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
+    }
+    /* Update opt_len to include the bit length tree and counts */
+    s->opt_len += 3*((ulg)max_blindex+1) + 5+5+4;
+    Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
+            s->opt_len, s->static_len));
+
+    return max_blindex;
+}
+
+/* ===========================================================================
+ * Send the header for a block using dynamic Huffman trees: the counts, the
+ * lengths of the bit length codes, the literal tree and the distance tree.
+ * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
+ */
+local void send_all_trees(s, lcodes, dcodes, blcodes)
+    deflate_state *s;
+    int lcodes, dcodes, blcodes; /* number of codes for each tree */
+{
+    int rank;                    /* index in bl_order */
+
+    Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
+    Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
+            "too many codes");
+    Tracev((stderr, "\nbl counts: "));
+    send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */
+    send_bits(s, dcodes-1,   5);
+    send_bits(s, blcodes-4,  4); /* not -3 as stated in appnote.txt */
+    for (rank = 0; rank < blcodes; rank++) {
+        Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
+        send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);
+    }
+    Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
+
+    send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */
+    Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
+
+    send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */
+    Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
+}
+
+/* ===========================================================================
+ * Send a stored block
+ */
+void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last)
+    deflate_state *s;
+    charf *buf;       /* input block */
+    ulg stored_len;   /* length of input block */
+    int last;         /* one if this is the last block for a file */
+{
+    send_bits(s, (STORED_BLOCK<<1)+last, 3);    /* send block type */
+    bi_windup(s);        /* align on byte boundary */
+    put_short(s, (ush)stored_len);
+    put_short(s, (ush)~stored_len);
+    zmemcpy(s->pending_buf + s->pending, (Bytef *)buf, stored_len);
+    s->pending += stored_len;
+#ifdef ZLIB_DEBUG
+    s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
+    s->compressed_len += (stored_len + 4) << 3;
+    s->bits_sent += 2*16;
+    s->bits_sent += stored_len<<3;
+#endif
+}
+
+/* ===========================================================================
+ * Flush the bits in the bit buffer to pending output (leaves at most 7 bits)
+ */
+void ZLIB_INTERNAL _tr_flush_bits(s)
+    deflate_state *s;
+{
+    bi_flush(s);
+}
+
+/* ===========================================================================
+ * Send one empty static block to give enough lookahead for inflate.
+ * This takes 10 bits, of which 7 may remain in the bit buffer.
+ */
+void ZLIB_INTERNAL _tr_align(s)
+    deflate_state *s;
+{
+    send_bits(s, STATIC_TREES<<1, 3);
+    send_code(s, END_BLOCK, static_ltree);
+#ifdef ZLIB_DEBUG
+    s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
+#endif
+    bi_flush(s);
+}
+
+/* ===========================================================================
+ * Determine the best encoding for the current block: dynamic trees, static
+ * trees or store, and write out the encoded block.
+ */
+void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
+    deflate_state *s;
+    charf *buf;       /* input block, or NULL if too old */
+    ulg stored_len;   /* length of input block */
+    int last;         /* one if this is the last block for a file */
+{
+    ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
+    int max_blindex = 0;  /* index of last bit length code of non zero freq */
+
+    /* Build the Huffman trees unless a stored block is forced */
+    if (s->level > 0) {
+
+        /* Check if the file is binary or text */
+        if (s->strm->data_type == Z_UNKNOWN)
+            s->strm->data_type = detect_data_type(s);
+
+        /* Construct the literal and distance trees */
+        build_tree(s, (tree_desc *)(&(s->l_desc)));
+        Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
+                s->static_len));
+
+        build_tree(s, (tree_desc *)(&(s->d_desc)));
+        Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
+                s->static_len));
+        /* At this point, opt_len and static_len are the total bit lengths of
+         * the compressed block data, excluding the tree representations.
+         */
+
+        /* Build the bit length tree for the above two trees, and get the index
+         * in bl_order of the last bit length code to send.
+         */
+        max_blindex = build_bl_tree(s);
+
+        /* Determine the best encoding. Compute the block lengths in bytes. */
+        opt_lenb = (s->opt_len+3+7)>>3;
+        static_lenb = (s->static_len+3+7)>>3;
+
+        Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
+                opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
+                s->last_lit));
+
+        if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
+
+    } else {
+        Assert(buf != (char*)0, "lost buf");
+        opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
+    }
+
+#ifdef FORCE_STORED
+    if (buf != (char*)0) { /* force stored block */
+#else
+    if (stored_len+4 <= opt_lenb && buf != (char*)0) {
+                       /* 4: two words for the lengths */
+#endif
+        /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
+         * Otherwise we can't have processed more than WSIZE input bytes since
+         * the last block flush, because compression would have been
+         * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
+         * transform a block into a stored block.
+         */
+        _tr_stored_block(s, buf, stored_len, last);
+
+#ifdef FORCE_STATIC
+    } else if (static_lenb >= 0) { /* force static trees */
+#else
+    } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) {
+#endif
+        send_bits(s, (STATIC_TREES<<1)+last, 3);
+        compress_block(s, (const ct_data *)static_ltree,
+                       (const ct_data *)static_dtree);
+#ifdef ZLIB_DEBUG
+        s->compressed_len += 3 + s->static_len;
+#endif
+    } else {
+        send_bits(s, (DYN_TREES<<1)+last, 3);
+        send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
+                       max_blindex+1);
+        compress_block(s, (const ct_data *)s->dyn_ltree,
+                       (const ct_data *)s->dyn_dtree);
+#ifdef ZLIB_DEBUG
+        s->compressed_len += 3 + s->opt_len;
+#endif
+    }
+    Assert (s->compressed_len == s->bits_sent, "bad compressed size");
+    /* The above check is made mod 2^32, for files larger than 512 MB
+     * and uLong implemented on 32 bits.
+     */
+    init_block(s);
+
+    if (last) {
+        bi_windup(s);
+#ifdef ZLIB_DEBUG
+        s->compressed_len += 7;  /* align on byte boundary */
+#endif
+    }
+    Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
+           s->compressed_len-7*last));
+}
+
+/* ===========================================================================
+ * Save the match info and tally the frequency counts. Return true if
+ * the current block must be flushed.
+ */
+int ZLIB_INTERNAL _tr_tally (s, dist, lc)
+    deflate_state *s;
+    unsigned dist;  /* distance of matched string */
+    unsigned lc;    /* match length-MIN_MATCH or unmatched char (if dist==0) */
+{
+    s->d_buf[s->last_lit] = (ush)dist;
+    s->l_buf[s->last_lit++] = (uch)lc;
+    if (dist == 0) {
+        /* lc is the unmatched char */
+        s->dyn_ltree[lc].Freq++;
+    } else {
+        s->matches++;
+        /* Here, lc is the match length - MIN_MATCH */
+        dist--;             /* dist = match distance - 1 */
+        Assert((ush)dist < (ush)MAX_DIST(s) &&
+               (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
+               (ush)d_code(dist) < (ush)D_CODES,  "_tr_tally: bad match");
+
+        s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++;
+        s->dyn_dtree[d_code(dist)].Freq++;
+    }
+
+#ifdef TRUNCATE_BLOCK
+    /* Try to guess if it is profitable to stop the current block here */
+    if ((s->last_lit & 0x1fff) == 0 && s->level > 2) {
+        /* Compute an upper bound for the compressed length */
+        ulg out_length = (ulg)s->last_lit*8L;
+        ulg in_length = (ulg)((long)s->strstart - s->block_start);
+        int dcode;
+        for (dcode = 0; dcode < D_CODES; dcode++) {
+            out_length += (ulg)s->dyn_dtree[dcode].Freq *
+                (5L+extra_dbits[dcode]);
+        }
+        out_length >>= 3;
+        Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
+               s->last_lit, in_length, out_length,
+               100L - out_length*100L/in_length));
+        if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1;
+    }
+#endif
+    return (s->last_lit == s->lit_bufsize-1);
+    /* We avoid equality with lit_bufsize because of wraparound at 64K
+     * on 16 bit machines and because stored blocks are restricted to
+     * 64K-1 bytes.
+     */
+}
+
+/* ===========================================================================
+ * Send the block data compressed using the given Huffman trees
+ */
+local void compress_block(s, ltree, dtree)
+    deflate_state *s;
+    const ct_data *ltree; /* literal tree */
+    const ct_data *dtree; /* distance tree */
+{
+    unsigned dist;      /* distance of matched string */
+    int lc;             /* match length or unmatched char (if dist == 0) */
+    unsigned lx = 0;    /* running index in l_buf */
+    unsigned code;      /* the code to send */
+    int extra;          /* number of extra bits to send */
+
+    if (s->last_lit != 0) do {
+        dist = s->d_buf[lx];
+        lc = s->l_buf[lx++];
+        if (dist == 0) {
+            send_code(s, lc, ltree); /* send a literal byte */
+            Tracecv(isgraph(lc), (stderr," '%c' ", lc));
+        } else {
+            /* Here, lc is the match length - MIN_MATCH */
+            code = _length_code[lc];
+            send_code(s, code+LITERALS+1, ltree); /* send the length code */
+            extra = extra_lbits[code];
+            if (extra != 0) {
+                lc -= base_length[code];
+                send_bits(s, lc, extra);       /* send the extra length bits */
+            }
+            dist--; /* dist is now the match distance - 1 */
+            code = d_code(dist);
+            Assert (code < D_CODES, "bad d_code");
+
+            send_code(s, code, dtree);       /* send the distance code */
+            extra = extra_dbits[code];
+            if (extra != 0) {
+                dist -= (unsigned)base_dist[code];
+                send_bits(s, dist, extra);   /* send the extra distance bits */
+            }
+        } /* literal or match pair ? */
+
+        /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
+        Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
+               "pendingBuf overflow");
+
+    } while (lx < s->last_lit);
+
+    send_code(s, END_BLOCK, ltree);
+}
+
+/* ===========================================================================
+ * Check if the data type is TEXT or BINARY, using the following algorithm:
+ * - TEXT if the two conditions below are satisfied:
+ *    a) There are no non-portable control characters belonging to the
+ *       "black list" (0..6, 14..25, 28..31).
+ *    b) There is at least one printable character belonging to the
+ *       "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).
+ * - BINARY otherwise.
+ * - The following partially-portable control characters form a
+ *   "gray list" that is ignored in this detection algorithm:
+ *   (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).
+ * IN assertion: the fields Freq of dyn_ltree are set.
+ */
+local int detect_data_type(s)
+    deflate_state *s;
+{
+    /* black_mask is the bit mask of black-listed bytes
+     * set bits 0..6, 14..25, and 28..31
+     * 0xf3ffc07f = binary 11110011111111111100000001111111
+     */
+    unsigned long black_mask = 0xf3ffc07fUL;
+    int n;
+
+    /* Check for non-textual ("black-listed") bytes. */
+    for (n = 0; n <= 31; n++, black_mask >>= 1)
+        if ((black_mask & 1) && (s->dyn_ltree[n].Freq != 0))
+            return Z_BINARY;
+
+    /* Check for textual ("white-listed") bytes. */
+    if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0
+            || s->dyn_ltree[13].Freq != 0)
+        return Z_TEXT;
+    for (n = 32; n < LITERALS; n++)
+        if (s->dyn_ltree[n].Freq != 0)
+            return Z_TEXT;
+
+    /* There are no "black-listed" or "white-listed" bytes:
+     * this stream either is empty or has tolerated ("gray-listed") bytes only.
+     */
+    return Z_BINARY;
+}
+
+/* ===========================================================================
+ * Reverse the first len bits of a code, using straightforward code (a faster
+ * method would use a table)
+ * IN assertion: 1 <= len <= 15
+ */
+local unsigned bi_reverse(code, len)
+    unsigned code; /* the value to invert */
+    int len;       /* its bit length */
+{
+    register unsigned res = 0;
+    do {
+        res |= code & 1;
+        code >>= 1, res <<= 1;
+    } while (--len > 0);
+    return res >> 1;
+}
+
+/* ===========================================================================
+ * Flush the bit buffer, keeping at most 7 bits in it.
+ */
+local void bi_flush(s)
+    deflate_state *s;
+{
+    if (s->bi_valid == 16) {
+        put_short(s, s->bi_buf);
+        s->bi_buf = 0;
+        s->bi_valid = 0;
+    } else if (s->bi_valid >= 8) {
+        put_byte(s, (Byte)s->bi_buf);
+        s->bi_buf >>= 8;
+        s->bi_valid -= 8;
+    }
+}
+
+/* ===========================================================================
+ * Flush the bit buffer and align the output on a byte boundary
+ */
+local void bi_windup(s)
+    deflate_state *s;
+{
+    if (s->bi_valid > 8) {
+        put_short(s, s->bi_buf);
+    } else if (s->bi_valid > 0) {
+        put_byte(s, (Byte)s->bi_buf);
+    }
+    s->bi_buf = 0;
+    s->bi_valid = 0;
+#ifdef ZLIB_DEBUG
+    s->bits_sent = (s->bits_sent+7) & ~7;
+#endif
+}
diff --git a/base/poco/Foundation/src/trees.h b/base/poco/Foundation/src/trees.h
new file mode 100644
index 00000000000..d35639d82a2
--- /dev/null
+++ b/base/poco/Foundation/src/trees.h
@@ -0,0 +1,128 @@
+/* header created automatically with -DGEN_TREES_H */
+
+local const ct_data static_ltree[L_CODES+2] = {
+{{ 12},{  8}}, {{140},{  8}}, {{ 76},{  8}}, {{204},{  8}}, {{ 44},{  8}},
+{{172},{  8}}, {{108},{  8}}, {{236},{  8}}, {{ 28},{  8}}, {{156},{  8}},
+{{ 92},{  8}}, {{220},{  8}}, {{ 60},{  8}}, {{188},{  8}}, {{124},{  8}},
+{{252},{  8}}, {{  2},{  8}}, {{130},{  8}}, {{ 66},{  8}}, {{194},{  8}},
+{{ 34},{  8}}, {{162},{  8}}, {{ 98},{  8}}, {{226},{  8}}, {{ 18},{  8}},
+{{146},{  8}}, {{ 82},{  8}}, {{210},{  8}}, {{ 50},{  8}}, {{178},{  8}},
+{{114},{  8}}, {{242},{  8}}, {{ 10},{  8}}, {{138},{  8}}, {{ 74},{  8}},
+{{202},{  8}}, {{ 42},{  8}}, {{170},{  8}}, {{106},{  8}}, {{234},{  8}},
+{{ 26},{  8}}, {{154},{  8}}, {{ 90},{  8}}, {{218},{  8}}, {{ 58},{  8}},
+{{186},{  8}}, {{122},{  8}}, {{250},{  8}}, {{  6},{  8}}, {{134},{  8}},
+{{ 70},{  8}}, {{198},{  8}}, {{ 38},{  8}}, {{166},{  8}}, {{102},{  8}},
+{{230},{  8}}, {{ 22},{  8}}, {{150},{  8}}, {{ 86},{  8}}, {{214},{  8}},
+{{ 54},{  8}}, {{182},{  8}}, {{118},{  8}}, {{246},{  8}}, {{ 14},{  8}},
+{{142},{  8}}, {{ 78},{  8}}, {{206},{  8}}, {{ 46},{  8}}, {{174},{  8}},
+{{110},{  8}}, {{238},{  8}}, {{ 30},{  8}}, {{158},{  8}}, {{ 94},{  8}},
+{{222},{  8}}, {{ 62},{  8}}, {{190},{  8}}, {{126},{  8}}, {{254},{  8}},
+{{  1},{  8}}, {{129},{  8}}, {{ 65},{  8}}, {{193},{  8}}, {{ 33},{  8}},
+{{161},{  8}}, {{ 97},{  8}}, {{225},{  8}}, {{ 17},{  8}}, {{145},{  8}},
+{{ 81},{  8}}, {{209},{  8}}, {{ 49},{  8}}, {{177},{  8}}, {{113},{  8}},
+{{241},{  8}}, {{  9},{  8}}, {{137},{  8}}, {{ 73},{  8}}, {{201},{  8}},
+{{ 41},{  8}}, {{169},{  8}}, {{105},{  8}}, {{233},{  8}}, {{ 25},{  8}},
+{{153},{  8}}, {{ 89},{  8}}, {{217},{  8}}, {{ 57},{  8}}, {{185},{  8}},
+{{121},{  8}}, {{249},{  8}}, {{  5},{  8}}, {{133},{  8}}, {{ 69},{  8}},
+{{197},{  8}}, {{ 37},{  8}}, {{165},{  8}}, {{101},{  8}}, {{229},{  8}},
+{{ 21},{  8}}, {{149},{  8}}, {{ 85},{  8}}, {{213},{  8}}, {{ 53},{  8}},
+{{181},{  8}}, {{117},{  8}}, {{245},{  8}}, {{ 13},{  8}}, {{141},{  8}},
+{{ 77},{  8}}, {{205},{  8}}, {{ 45},{  8}}, {{173},{  8}}, {{109},{  8}},
+{{237},{  8}}, {{ 29},{  8}}, {{157},{  8}}, {{ 93},{  8}}, {{221},{  8}},
+{{ 61},{  8}}, {{189},{  8}}, {{125},{  8}}, {{253},{  8}}, {{ 19},{  9}},
+{{275},{  9}}, {{147},{  9}}, {{403},{  9}}, {{ 83},{  9}}, {{339},{  9}},
+{{211},{  9}}, {{467},{  9}}, {{ 51},{  9}}, {{307},{  9}}, {{179},{  9}},
+{{435},{  9}}, {{115},{  9}}, {{371},{  9}}, {{243},{  9}}, {{499},{  9}},
+{{ 11},{  9}}, {{267},{  9}}, {{139},{  9}}, {{395},{  9}}, {{ 75},{  9}},
+{{331},{  9}}, {{203},{  9}}, {{459},{  9}}, {{ 43},{  9}}, {{299},{  9}},
+{{171},{  9}}, {{427},{  9}}, {{107},{  9}}, {{363},{  9}}, {{235},{  9}},
+{{491},{  9}}, {{ 27},{  9}}, {{283},{  9}}, {{155},{  9}}, {{411},{  9}},
+{{ 91},{  9}}, {{347},{  9}}, {{219},{  9}}, {{475},{  9}}, {{ 59},{  9}},
+{{315},{  9}}, {{187},{  9}}, {{443},{  9}}, {{123},{  9}}, {{379},{  9}},
+{{251},{  9}}, {{507},{  9}}, {{  7},{  9}}, {{263},{  9}}, {{135},{  9}},
+{{391},{  9}}, {{ 71},{  9}}, {{327},{  9}}, {{199},{  9}}, {{455},{  9}},
+{{ 39},{  9}}, {{295},{  9}}, {{167},{  9}}, {{423},{  9}}, {{103},{  9}},
+{{359},{  9}}, {{231},{  9}}, {{487},{  9}}, {{ 23},{  9}}, {{279},{  9}},
+{{151},{  9}}, {{407},{  9}}, {{ 87},{  9}}, {{343},{  9}}, {{215},{  9}},
+{{471},{  9}}, {{ 55},{  9}}, {{311},{  9}}, {{183},{  9}}, {{439},{  9}},
+{{119},{  9}}, {{375},{  9}}, {{247},{  9}}, {{503},{  9}}, {{ 15},{  9}},
+{{271},{  9}}, {{143},{  9}}, {{399},{  9}}, {{ 79},{  9}}, {{335},{  9}},
+{{207},{  9}}, {{463},{  9}}, {{ 47},{  9}}, {{303},{  9}}, {{175},{  9}},
+{{431},{  9}}, {{111},{  9}}, {{367},{  9}}, {{239},{  9}}, {{495},{  9}},
+{{ 31},{  9}}, {{287},{  9}}, {{159},{  9}}, {{415},{  9}}, {{ 95},{  9}},
+{{351},{  9}}, {{223},{  9}}, {{479},{  9}}, {{ 63},{  9}}, {{319},{  9}},
+{{191},{  9}}, {{447},{  9}}, {{127},{  9}}, {{383},{  9}}, {{255},{  9}},
+{{511},{  9}}, {{  0},{  7}}, {{ 64},{  7}}, {{ 32},{  7}}, {{ 96},{  7}},
+{{ 16},{  7}}, {{ 80},{  7}}, {{ 48},{  7}}, {{112},{  7}}, {{  8},{  7}},
+{{ 72},{  7}}, {{ 40},{  7}}, {{104},{  7}}, {{ 24},{  7}}, {{ 88},{  7}},
+{{ 56},{  7}}, {{120},{  7}}, {{  4},{  7}}, {{ 68},{  7}}, {{ 36},{  7}},
+{{100},{  7}}, {{ 20},{  7}}, {{ 84},{  7}}, {{ 52},{  7}}, {{116},{  7}},
+{{  3},{  8}}, {{131},{  8}}, {{ 67},{  8}}, {{195},{  8}}, {{ 35},{  8}},
+{{163},{  8}}, {{ 99},{  8}}, {{227},{  8}}
+};
+
+local const ct_data static_dtree[D_CODES] = {
+{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}},
+{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}},
+{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}},
+{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}},
+{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}},
+{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}}
+};
+
+const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {
+ 0,  1,  2,  3,  4,  4,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  8,
+ 8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9, 10, 10, 10, 10, 10, 10, 10, 10,
+10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
+13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,  0,  0, 16, 17,
+18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
+23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
+};
+
+const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {
+ 0,  1,  2,  3,  4,  5,  6,  7,  8,  8,  9,  9, 10, 10, 11, 11, 12, 12, 12, 12,
+13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
+17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
+19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
+22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
+23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
+};
+
+local const int base_length[LENGTH_CODES] = {
+0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
+64, 80, 96, 112, 128, 160, 192, 224, 0
+};
+
+local const int base_dist[D_CODES] = {
+    0,     1,     2,     3,     4,     6,     8,    12,    16,    24,
+   32,    48,    64,    96,   128,   192,   256,   384,   512,   768,
+ 1024,  1536,  2048,  3072,  4096,  6144,  8192, 12288, 16384, 24576
+};
+
diff --git a/base/poco/Foundation/src/ucp.h b/base/poco/Foundation/src/ucp.h
new file mode 100644
index 00000000000..2fa00296e42
--- /dev/null
+++ b/base/poco/Foundation/src/ucp.h
@@ -0,0 +1,224 @@
+/*************************************************
+*          Unicode Property Table handler        *
+*************************************************/
+
+#ifndef _UCP_H
+#define _UCP_H
+
+/* This file contains definitions of the property values that are returned by
+the UCD access macros. New values that are added for new releases of Unicode
+should always be at the end of each enum, for backwards compatibility.
+
+IMPORTANT: Note also that the specific numeric values of the enums have to be
+the same as the values that are generated by the maint/MultiStage2.py script,
+where the equivalent property descriptive names are listed in vectors.
+
+ALSO: The specific values of the first two enums are assumed for the table
+called catposstab in pcre_compile.c. */
+
+/* These are the general character categories. */
+
+enum {
+  ucp_C,     /* Other */
+  ucp_L,     /* Letter */
+  ucp_M,     /* Mark */
+  ucp_N,     /* Number */
+  ucp_P,     /* Punctuation */
+  ucp_S,     /* Symbol */
+  ucp_Z      /* Separator */
+};
+
+/* These are the particular character categories. */
+
+enum {
+  ucp_Cc,    /* Control */
+  ucp_Cf,    /* Format */
+  ucp_Cn,    /* Unassigned */
+  ucp_Co,    /* Private use */
+  ucp_Cs,    /* Surrogate */
+  ucp_Ll,    /* Lower case letter */
+  ucp_Lm,    /* Modifier letter */
+  ucp_Lo,    /* Other letter */
+  ucp_Lt,    /* Title case letter */
+  ucp_Lu,    /* Upper case letter */
+  ucp_Mc,    /* Spacing mark */
+  ucp_Me,    /* Enclosing mark */
+  ucp_Mn,    /* Non-spacing mark */
+  ucp_Nd,    /* Decimal number */
+  ucp_Nl,    /* Letter number */
+  ucp_No,    /* Other number */
+  ucp_Pc,    /* Connector punctuation */
+  ucp_Pd,    /* Dash punctuation */
+  ucp_Pe,    /* Close punctuation */
+  ucp_Pf,    /* Final punctuation */
+  ucp_Pi,    /* Initial punctuation */
+  ucp_Po,    /* Other punctuation */
+  ucp_Ps,    /* Open punctuation */
+  ucp_Sc,    /* Currency symbol */
+  ucp_Sk,    /* Modifier symbol */
+  ucp_Sm,    /* Mathematical symbol */
+  ucp_So,    /* Other symbol */
+  ucp_Zl,    /* Line separator */
+  ucp_Zp,    /* Paragraph separator */
+  ucp_Zs     /* Space separator */
+};
+
+/* These are grapheme break properties. Note that the code for processing them
+assumes that the values are less than 16. If more values are added that take
+the number to 16 or more, the code will have to be rewritten. */
+
+enum {
+  ucp_gbCR,                /*  0 */
+  ucp_gbLF,                /*  1 */
+  ucp_gbControl,           /*  2 */
+  ucp_gbExtend,            /*  3 */
+  ucp_gbPrepend,           /*  4 */
+  ucp_gbSpacingMark,       /*  5 */
+  ucp_gbL,                 /*  6 Hangul syllable type L */
+  ucp_gbV,                 /*  7 Hangul syllable type V */
+  ucp_gbT,                 /*  8 Hangul syllable type T */
+  ucp_gbLV,                /*  9 Hangul syllable type LV */
+  ucp_gbLVT,               /* 10 Hangul syllable type LVT */
+  ucp_gbRegionalIndicator, /* 11 */
+  ucp_gbOther              /* 12 */
+};
+
+/* These are the script identifications. */
+
+enum {
+  ucp_Arabic,
+  ucp_Armenian,
+  ucp_Bengali,
+  ucp_Bopomofo,
+  ucp_Braille,
+  ucp_Buginese,
+  ucp_Buhid,
+  ucp_Canadian_Aboriginal,
+  ucp_Cherokee,
+  ucp_Common,
+  ucp_Coptic,
+  ucp_Cypriot,
+  ucp_Cyrillic,
+  ucp_Deseret,
+  ucp_Devanagari,
+  ucp_Ethiopic,
+  ucp_Georgian,
+  ucp_Glagolitic,
+  ucp_Gothic,
+  ucp_Greek,
+  ucp_Gujarati,
+  ucp_Gurmukhi,
+  ucp_Han,
+  ucp_Hangul,
+  ucp_Hanunoo,
+  ucp_Hebrew,
+  ucp_Hiragana,
+  ucp_Inherited,
+  ucp_Kannada,
+  ucp_Katakana,
+  ucp_Kharoshthi,
+  ucp_Khmer,
+  ucp_Lao,
+  ucp_Latin,
+  ucp_Limbu,
+  ucp_Linear_B,
+  ucp_Malayalam,
+  ucp_Mongolian,
+  ucp_Myanmar,
+  ucp_New_Tai_Lue,
+  ucp_Ogham,
+  ucp_Old_Italic,
+  ucp_Old_Persian,
+  ucp_Oriya,
+  ucp_Osmanya,
+  ucp_Runic,
+  ucp_Shavian,
+  ucp_Sinhala,
+  ucp_Syloti_Nagri,
+  ucp_Syriac,
+  ucp_Tagalog,
+  ucp_Tagbanwa,
+  ucp_Tai_Le,
+  ucp_Tamil,
+  ucp_Telugu,
+  ucp_Thaana,
+  ucp_Thai,
+  ucp_Tibetan,
+  ucp_Tifinagh,
+  ucp_Ugaritic,
+  ucp_Yi,
+  /* New for Unicode 5.0: */
+  ucp_Balinese,
+  ucp_Cuneiform,
+  ucp_Nko,
+  ucp_Phags_Pa,
+  ucp_Phoenician,
+  /* New for Unicode 5.1: */
+  ucp_Carian,
+  ucp_Cham,
+  ucp_Kayah_Li,
+  ucp_Lepcha,
+  ucp_Lycian,
+  ucp_Lydian,
+  ucp_Ol_Chiki,
+  ucp_Rejang,
+  ucp_Saurashtra,
+  ucp_Sundanese,
+  ucp_Vai,
+  /* New for Unicode 5.2: */
+  ucp_Avestan,
+  ucp_Bamum,
+  ucp_Egyptian_Hieroglyphs,
+  ucp_Imperial_Aramaic,
+  ucp_Inscriptional_Pahlavi,
+  ucp_Inscriptional_Parthian,
+  ucp_Javanese,
+  ucp_Kaithi,
+  ucp_Lisu,
+  ucp_Meetei_Mayek,
+  ucp_Old_South_Arabian,
+  ucp_Old_Turkic,
+  ucp_Samaritan,
+  ucp_Tai_Tham,
+  ucp_Tai_Viet,
+  /* New for Unicode 6.0.0: */
+  ucp_Batak,
+  ucp_Brahmi,
+  ucp_Mandaic,
+  /* New for Unicode 6.1.0: */
+  ucp_Chakma,
+  ucp_Meroitic_Cursive,
+  ucp_Meroitic_Hieroglyphs,
+  ucp_Miao,
+  ucp_Sharada,
+  ucp_Sora_Sompeng,
+  ucp_Takri,
+  /* New for Unicode 7.0.0: */
+  ucp_Bassa_Vah,
+  ucp_Caucasian_Albanian,
+  ucp_Duployan,
+  ucp_Elbasan,
+  ucp_Grantha,
+  ucp_Khojki,
+  ucp_Khudawadi,
+  ucp_Linear_A,
+  ucp_Mahajani,
+  ucp_Manichaean,
+  ucp_Mende_Kikakui,
+  ucp_Modi,
+  ucp_Mro,
+  ucp_Nabataean,
+  ucp_Old_North_Arabian,
+  ucp_Old_Permic,
+  ucp_Pahawh_Hmong,
+  ucp_Palmyrene,
+  ucp_Psalter_Pahlavi,
+  ucp_Pau_Cin_Hau,
+  ucp_Siddham,
+  ucp_Tirhuta,
+  ucp_Warang_Citi
+};
+
+#endif
+
+/* End of ucp.h */
diff --git a/base/poco/Foundation/src/utils.h b/base/poco/Foundation/src/utils.h
new file mode 100644
index 00000000000..c87cee13cff
--- /dev/null
+++ b/base/poco/Foundation/src/utils.h
@@ -0,0 +1,325 @@
+// Copyright 2010 the V8 project authors. 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 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 Google Inc. 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 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
+// OWNER 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.
+
+#ifndef DOUBLE_CONVERSION_UTILS_H_
+#define DOUBLE_CONVERSION_UTILS_H_
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <assert.h>
+#ifndef ASSERT
+#define ASSERT(condition)         \
+    assert(condition);
+#endif
+#ifndef UNIMPLEMENTED
+#define UNIMPLEMENTED() (abort())
+#endif
+#ifndef UNREACHABLE
+#define UNREACHABLE()   (abort())
+#endif
+
+// Double operations detection based on target architecture.
+// Linux uses a 80bit wide floating point stack on x86. This induces double
+// rounding, which in turn leads to wrong results.
+// An easy way to test if the floating-point operations are correct is to
+// evaluate: 89255.0/1e22. If the floating-point stack is 64 bits wide then
+// the result is equal to 89255e-22.
+// The best way to test this, is to create a division-function and to compare
+// the output of the division with the expected result. (Inlining must be
+// disabled.)
+// On Linux,x86 89255e-22 != Div_double(89255.0/1e22)
+#if defined(_M_X64) || defined(__x86_64__) || \
+    defined(__ARMEL__) || defined(_M_ARM) || defined(__arm__) || defined(__arm64__) || \
+    defined(__avr32__) || \
+    defined(__hppa__) || defined(__ia64__) || \
+    defined(__mips__) || \
+    defined(__powerpc__) || defined(__ppc__) || defined(__ppc64__) || \
+    defined(__sparc__) || defined(__sparc) || defined(__s390__) || \
+    defined(__SH4__) || defined(__alpha__) || \
+    defined(_MIPS_ARCH_MIPS32R2) || \
+    defined(__riscv) || \
+	defined(__AARCH64EL__) || \
+    defined(nios2) || defined(__nios2) || defined(__nios2__)
+#define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
+#elif defined(_M_IX86) || defined(__i386__) || defined(__i386)
+#if defined(_WIN32)
+// Windows uses a 64bit wide floating point stack.
+#define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
+#else
+#undef DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS
+#endif  // _WIN32
+#else
+#error Target architecture was not detected as supported by Double-Conversion.
+#endif
+
+#if defined(__GNUC__)
+#define DOUBLE_CONVERSION_UNUSED __attribute__((unused))
+#else
+#define DOUBLE_CONVERSION_UNUSED
+#endif
+
+#if defined(_WIN32) && !defined(__MINGW32__)
+
+typedef signed char int8_t;
+typedef unsigned char uint8_t;
+typedef short int16_t;  // NOLINT
+typedef unsigned short uint16_t;  // NOLINT
+typedef int int32_t;
+typedef unsigned int uint32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+// intptr_t and friends are defined in crtdefs.h through stdio.h.
+
+#else
+
+#include <stdint.h>
+
+#endif
+
+// The following macro works on both 32 and 64-bit platforms.
+// Usage: instead of writing 0x1234567890123456
+//      write UINT64_2PART_C(0x12345678,90123456);
+#define UINT64_2PART_C(a, b) (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
+
+
+// The expression ARRAY_SIZE(a) is a compile-time constant of type
+// size_t which represents the number of elements of the given
+// array. You should only use ARRAY_SIZE on statically allocated
+// arrays.
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(a)                                   \
+  ((sizeof(a) / sizeof(*(a))) /                         \
+  static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))
+#endif
+
+// A macro to disallow the evil copy constructor and operator= functions
+// This should be used in the private: declarations for a class
+#ifndef DISALLOW_COPY_AND_ASSIGN
+#define DISALLOW_COPY_AND_ASSIGN(TypeName)      \
+  TypeName(const TypeName&);                    \
+  void operator=(const TypeName&)
+#endif
+
+// A macro to disallow all the implicit constructors, namely the
+// default constructor, copy constructor and operator= functions.
+//
+// This should be used in the private: declarations for a class
+// that wants to prevent anyone from instantiating it. This is
+// especially useful for classes containing only static methods.
+#ifndef DISALLOW_IMPLICIT_CONSTRUCTORS
+#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
+  TypeName();                                    \
+  DISALLOW_COPY_AND_ASSIGN(TypeName)
+#endif
+
+namespace double_conversion {
+
+static const int kCharSize = sizeof(char);
+
+// Returns the maximum of the two parameters.
+template <typename T>
+static T Max(T a, T b) {
+  return a < b ? b : a;
+}
+
+
+// Returns the minimum of the two parameters.
+template <typename T>
+static T Min(T a, T b) {
+  return a < b ? a : b;
+}
+
+
+inline int StrLength(const char* string) {
+  size_t length = strlen(string);
+  ASSERT(length == static_cast<size_t>(static_cast<int>(length)));
+  return static_cast<int>(length);
+}
+
+// This is a simplified version of V8's Vector class.
+template <typename T>
+class Vector {
+ public:
+  Vector() : start_(NULL), length_(0) {}
+  Vector(T* data, int length) : start_(data), length_(length) {
+    ASSERT(length == 0 || (length > 0 && data != NULL));
+  }
+
+  // Returns a vector using the same backing storage as this one,
+  // spanning from and including 'from', to but not including 'to'.
+  Vector<T> SubVector(int from, int to) {
+    ASSERT(to <= length_);
+    ASSERT(from < to);
+    ASSERT(0 <= from);
+    return Vector<T>(start() + from, to - from);
+  }
+
+  // Returns the length of the vector.
+  int length() const { return length_; }
+
+  // Returns whether or not the vector is empty.
+  bool is_empty() const { return length_ == 0; }
+
+  // Returns the pointer to the start of the data in the vector.
+  T* start() const { return start_; }
+
+  // Access individual vector elements - checks bounds in debug mode.
+  T& operator[](int index) const {
+    ASSERT(0 <= index && index < length_);
+    return start_[index];
+  }
+
+  T& first() { return start_[0]; }
+
+  T& last() { return start_[length_ - 1]; }
+
+ private:
+  T* start_;
+  int length_;
+};
+
+
+// Helper class for building result strings in a character buffer. The
+// purpose of the class is to use safe operations that checks the
+// buffer bounds on all operations in debug mode.
+class StringBuilder {
+ public:
+  StringBuilder(char* buffer, int size)
+      : buffer_(buffer, size), position_(0) { }
+
+  ~StringBuilder() { if (!is_finalized()) Finalize(); }
+
+  int size() const { return buffer_.length(); }
+
+  // Get the current position in the builder.
+  int position() const {
+    ASSERT(!is_finalized());
+    return position_;
+  }
+
+  // Reset the position.
+  void Reset() { position_ = 0; }
+
+  // Add a single character to the builder. It is not allowed to add
+  // 0-characters; use the Finalize() method to terminate the string
+  // instead.
+  void AddCharacter(char c) {
+    ASSERT(c != '\0');
+    ASSERT(!is_finalized() && position_ < buffer_.length());
+    buffer_[position_++] = c;
+  }
+
+  // Add an entire string to the builder. Uses strlen() internally to
+  // compute the length of the input string.
+  void AddString(const char* s) {
+    AddSubstring(s, StrLength(s));
+  }
+
+  // Add the first 'n' characters of the given string 's' to the
+  // builder. The input string must have enough characters.
+  void AddSubstring(const char* s, int n) {
+    ASSERT(!is_finalized() && position_ + n < buffer_.length());
+    ASSERT(static_cast<size_t>(n) <= strlen(s));
+    memmove(&buffer_[position_], s, n * kCharSize);
+    position_ += n;
+  }
+
+
+  // Add character padding to the builder. If count is non-positive,
+  // nothing is added to the builder.
+  void AddPadding(char c, int count) {
+    for (int i = 0; i < count; i++) {
+      AddCharacter(c);
+    }
+  }
+
+  // Finalize the string by 0-terminating it and returning the buffer.
+  char* Finalize() {
+    ASSERT(!is_finalized() && position_ < buffer_.length());
+    buffer_[position_] = '\0';
+    // Make sure nobody managed to add a 0-character to the
+    // buffer while building the string.
+    ASSERT(strlen(buffer_.start()) == static_cast<size_t>(position_));
+    position_ = -1;
+    ASSERT(is_finalized());
+    return buffer_.start();
+  }
+
+ private:
+  Vector<char> buffer_;
+  int position_;
+
+  bool is_finalized() const { return position_ < 0; }
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(StringBuilder);
+};
+
+// The type-based aliasing rule allows the compiler to assume that pointers of
+// different types (for some definition of different) never alias each other.
+// Thus the following code does not work:
+//
+// float f = foo();
+// int fbits = *(int*)(&f);
+//
+// The compiler 'knows' that the int pointer can't refer to f since the types
+// don't match, so the compiler may cache f in a register, leaving random data
+// in fbits.  Using C++ style casts makes no difference, however a pointer to
+// char data is assumed to alias any other pointer.  This is the 'memcpy
+// exception'.
+//
+// Bit_cast uses the memcpy exception to move the bits from a variable of one
+// type of a variable of another type.  Of course the end result is likely to
+// be implementation dependent.  Most compilers (gcc-4.2 and MSVC 2005)
+// will completely optimize BitCast away.
+//
+// There is an additional use for BitCast.
+// Recent gccs will warn when they see casts that may result in breakage due to
+// the type-based aliasing rule.  If you have checked that there is no breakage
+// you can use BitCast to cast one pointer type to another.  This confuses gcc
+// enough that it can no longer see that you have cast one pointer type to
+// another thus avoiding the warning.
+template <class Dest, class Source>
+inline Dest BitCast(const Source& source) {
+  // Compile time assertion: sizeof(Dest) == sizeof(Source)
+  // A compile error here means your Dest and Source have different sizes.
+  DOUBLE_CONVERSION_UNUSED
+      typedef char VerifySizesAreEqual[sizeof(Dest) == sizeof(Source) ? 1 : -1];
+
+  Dest dest;
+  memmove(&dest, &source, sizeof(dest));
+  return dest;
+}
+
+template <class Dest, class Source>
+inline Dest BitCast(Source* source) {
+  return BitCast<Dest>(reinterpret_cast<uintptr_t>(source));
+}
+
+}  // namespace double_conversion
+
+#endif  // DOUBLE_CONVERSION_UTILS_H_
diff --git a/base/poco/Foundation/src/zutil.c b/base/poco/Foundation/src/zutil.c
new file mode 100644
index 00000000000..083c9f58c7b
--- /dev/null
+++ b/base/poco/Foundation/src/zutil.c
@@ -0,0 +1,324 @@
+/* zutil.c -- target dependent utility functions for the compression library
+ * Copyright (C) 1995-2005, 2010, 2011, 2012 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id: //poco/1.4/Foundation/src/zutil.c#3 $ */
+
+#include "zutil.h"
+#ifndef Z_SOLO
+#  include "gzguts.h"
+#endif
+
+#ifndef NO_DUMMY_DECL
+struct internal_state      {int dummy;}; /* for buggy compilers */
+#endif
+
+z_const char * const z_errmsg[10] = {
+"need dictionary",     /* Z_NEED_DICT       2  */
+"stream end",          /* Z_STREAM_END      1  */
+"",                    /* Z_OK              0  */
+"file error",          /* Z_ERRNO         (-1) */
+"stream error",        /* Z_STREAM_ERROR  (-2) */
+"data error",          /* Z_DATA_ERROR    (-3) */
+"insufficient memory", /* Z_MEM_ERROR     (-4) */
+"buffer error",        /* Z_BUF_ERROR     (-5) */
+"incompatible version",/* Z_VERSION_ERROR (-6) */
+""};
+
+
+const char * ZEXPORT zlibVersion()
+{
+    return ZLIB_VERSION;
+}
+
+uLong ZEXPORT zlibCompileFlags()
+{
+    uLong flags;
+
+    flags = 0;
+    switch ((int)(sizeof(uInt))) {
+    case 2:     break;
+    case 4:     flags += 1;     break;
+    case 8:     flags += 2;     break;
+    default:    flags += 3;
+    }
+    switch ((int)(sizeof(uLong))) {
+    case 2:     break;
+    case 4:     flags += 1 << 2;        break;
+    case 8:     flags += 2 << 2;        break;
+    default:    flags += 3 << 2;
+    }
+    switch ((int)(sizeof(voidpf))) {
+    case 2:     break;
+    case 4:     flags += 1 << 4;        break;
+    case 8:     flags += 2 << 4;        break;
+    default:    flags += 3 << 4;
+    }
+    switch ((int)(sizeof(z_off_t))) {
+    case 2:     break;
+    case 4:     flags += 1 << 6;        break;
+    case 8:     flags += 2 << 6;        break;
+    default:    flags += 3 << 6;
+    }
+#ifdef ZLIB_DEBUG
+    flags += 1 << 8;
+#endif
+#if defined(ASMV) || defined(ASMINF)
+    flags += 1 << 9;
+#endif
+#ifdef ZLIB_WINAPI
+    flags += 1 << 10;
+#endif
+#ifdef BUILDFIXED
+    flags += 1 << 12;
+#endif
+#ifdef DYNAMIC_CRC_TABLE
+    flags += 1 << 13;
+#endif
+#ifdef NO_GZCOMPRESS
+    flags += 1L << 16;
+#endif
+#ifdef NO_GZIP
+    flags += 1L << 17;
+#endif
+#ifdef PKZIP_BUG_WORKAROUND
+    flags += 1L << 20;
+#endif
+#ifdef FASTEST
+    flags += 1L << 21;
+#endif
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#  ifdef NO_vsnprintf
+    flags += 1L << 25;
+#    ifdef HAS_vsprintf_void
+    flags += 1L << 26;
+#    endif
+#  else
+#    ifdef HAS_vsnprintf_void
+    flags += 1L << 26;
+#    endif
+#  endif
+#else
+    flags += 1L << 24;
+#  ifdef NO_snprintf
+    flags += 1L << 25;
+#    ifdef HAS_sprintf_void
+    flags += 1L << 26;
+#    endif
+#  else
+#    ifdef HAS_snprintf_void
+    flags += 1L << 26;
+#    endif
+#  endif
+#endif
+    return flags;
+}
+
+#ifdef ZLIB_DEBUG
+
+#  ifndef verbose
+#    define verbose 0
+#  endif
+int ZLIB_INTERNAL z_verbose = verbose;
+
+void ZLIB_INTERNAL z_error (m)
+    char *m;
+{
+    fprintf(stderr, "%s\n", m);
+    exit(1);
+}
+#endif
+
+/* exported to allow conversion of error code to string for compress() and
+ * uncompress()
+ */
+const char * ZEXPORT zError(err)
+    int err;
+{
+    return ERR_MSG(err);
+}
+
+#if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
+    /* The Microsoft C Run-Time Library for Windows CE doesn't have
+     * errno.  We define it as a global variable to simplify porting.
+     * Its value is always 0 and should not be used.
+     */
+    int errno = 0;
+#endif
+
+#ifndef HAVE_MEMCPY
+
+void ZLIB_INTERNAL zmemcpy(dest, source, len)
+    Bytef* dest;
+    const Bytef* source;
+    uInt  len;
+{
+    if (len == 0) return;
+    do {
+        *dest++ = *source++; /* ??? to be unrolled */
+    } while (--len != 0);
+}
+
+int ZLIB_INTERNAL zmemcmp(s1, s2, len)
+    const Bytef* s1;
+    const Bytef* s2;
+    uInt  len;
+{
+    uInt j;
+
+    for (j = 0; j < len; j++) {
+        if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
+    }
+    return 0;
+}
+
+void ZLIB_INTERNAL zmemzero(dest, len)
+    Bytef* dest;
+    uInt  len;
+{
+    if (len == 0) return;
+    do {
+        *dest++ = 0;  /* ??? to be unrolled */
+    } while (--len != 0);
+}
+#endif
+
+#ifndef Z_SOLO
+
+#ifdef SYS16BIT
+
+#ifdef __TURBOC__
+/* Turbo C in 16-bit mode */
+
+#  define MY_ZCALLOC
+
+/* Turbo C malloc() does not allow dynamic allocation of 64K bytes
+ * and farmalloc(64K) returns a pointer with an offset of 8, so we
+ * must fix the pointer. Warning: the pointer must be put back to its
+ * original form in order to free it, use zcfree().
+ */
+
+#define MAX_PTR 10
+/* 10*64K = 640K */
+
+local int next_ptr = 0;
+
+typedef struct ptr_table_s {
+    voidpf org_ptr;
+    voidpf new_ptr;
+} ptr_table;
+
+local ptr_table table[MAX_PTR];
+/* This table is used to remember the original form of pointers
+ * to large buffers (64K). Such pointers are normalized with a zero offset.
+ * Since MSDOS is not a preemptive multitasking OS, this table is not
+ * protected from concurrent access. This hack doesn't work anyway on
+ * a protected system like OS/2. Use Microsoft C instead.
+ */
+
+voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
+{
+    voidpf buf = opaque; /* just to make some compilers happy */
+    ulg bsize = (ulg)items*size;
+
+    /* If we allocate less than 65520 bytes, we assume that farmalloc
+     * will return a usable pointer which doesn't have to be normalized.
+     */
+    if (bsize < 65520L) {
+        buf = farmalloc(bsize);
+        if (*(ush*)&buf != 0) return buf;
+    } else {
+        buf = farmalloc(bsize + 16L);
+    }
+    if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
+    table[next_ptr].org_ptr = buf;
+
+    /* Normalize the pointer to seg:0 */
+    *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
+    *(ush*)&buf = 0;
+    table[next_ptr++].new_ptr = buf;
+    return buf;
+}
+
+void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
+{
+    int n;
+    if (*(ush*)&ptr != 0) { /* object < 64K */
+        farfree(ptr);
+        return;
+    }
+    /* Find the original pointer */
+    for (n = 0; n < next_ptr; n++) {
+        if (ptr != table[n].new_ptr) continue;
+
+        farfree(table[n].org_ptr);
+        while (++n < next_ptr) {
+            table[n-1] = table[n];
+        }
+        next_ptr--;
+        return;
+    }
+    ptr = opaque; /* just to make some compilers happy */
+    Assert(0, "zcfree: ptr not found");
+}
+
+#endif /* __TURBOC__ */
+
+
+#ifdef M_I86
+/* Microsoft C in 16-bit mode */
+
+#  define MY_ZCALLOC
+
+#if (!defined(_MSC_VER) || (_MSC_VER <= 600))
+#  define _halloc  halloc
+#  define _hfree   hfree
+#endif
+
+voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
+{
+    if (opaque) opaque = 0; /* to make compiler happy */
+    return _halloc((long)items, size);
+}
+
+void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
+{
+    if (opaque) opaque = 0; /* to make compiler happy */
+    _hfree(ptr);
+}
+
+#endif /* M_I86 */
+
+#endif /* SYS16BIT */
+
+
+#ifndef MY_ZCALLOC /* Any system without a special alloc function */
+
+#ifndef STDC
+extern voidp  malloc OF((uInt size));
+extern voidp  calloc OF((uInt items, uInt size));
+extern void   free   OF((voidpf ptr));
+#endif
+
+voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
+    voidpf opaque;
+    unsigned items;
+    unsigned size;
+{
+    if (opaque) items += size - size; /* make compiler happy */
+    return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
+                              (voidpf)calloc(items, size);
+}
+
+void ZLIB_INTERNAL zcfree (opaque, ptr)
+    voidpf opaque;
+    voidpf ptr;
+{
+    free(ptr);
+    if (opaque) return; /* make compiler happy */
+}
+
+#endif /* MY_ZCALLOC */
+
+#endif /* !Z_SOLO */
diff --git a/base/poco/Foundation/src/zutil.h b/base/poco/Foundation/src/zutil.h
new file mode 100644
index 00000000000..dd28aa3377b
--- /dev/null
+++ b/base/poco/Foundation/src/zutil.h
@@ -0,0 +1,253 @@
+/* zutil.h -- internal interface and configuration of the compression library
+ * Copyright (C) 1995-2013 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id: //poco/1.4/Foundation/src/zutil.h#3 $ */
+
+#ifndef ZUTIL_H
+#define ZUTIL_H
+
+#ifdef HAVE_HIDDEN
+#  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
+#else
+#  define ZLIB_INTERNAL
+#endif
+
+#include "zlib.h"
+
+#if defined(STDC) && !defined(Z_SOLO)
+#  if !(defined(_WIN32_WCE) && defined(_MSC_VER))
+#    include <stddef.h>
+#  endif
+#  include <string.h>
+#  include <stdlib.h>
+#endif
+
+#ifdef Z_SOLO
+   typedef long ptrdiff_t;  /* guess -- will be caught if guess is wrong */
+#endif
+
+#ifndef local
+#  define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+typedef unsigned char  uch;
+typedef uch FAR uchf;
+typedef unsigned short ush;
+typedef ush FAR ushf;
+typedef unsigned long  ulg;
+
+extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
+/* (size given to avoid silly warnings with Visual C++) */
+
+#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
+
+#define ERR_RETURN(strm,err) \
+  return (strm->msg = ERR_MSG(err), (err))
+/* To be used only when the state is known to be valid */
+
+        /* common constants */
+
+#ifndef DEF_WBITS
+#  define DEF_WBITS MAX_WBITS
+#endif
+/* default windowBits for decompression. MAX_WBITS is for compression only */
+
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+/* default memLevel */
+
+#define STORED_BLOCK 0
+#define STATIC_TREES 1
+#define DYN_TREES    2
+/* The three kinds of block type */
+
+#define MIN_MATCH  3
+#define MAX_MATCH  258
+/* The minimum and maximum match lengths */
+
+#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
+
+        /* target dependencies */
+
+#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))
+#  define OS_CODE  0x00
+#  ifndef Z_SOLO
+#    if defined(__TURBOC__) || defined(__BORLANDC__)
+#      if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
+         /* Allow compilation with ANSI keywords only enabled */
+         void _Cdecl farfree( void *block );
+         void *_Cdecl farmalloc( unsigned long nbytes );
+#      else
+#        include <alloc.h>
+#      endif
+#    else /* MSC or DJGPP */
+#      include <malloc.h>
+#    endif
+#  endif
+#endif
+
+#ifdef AMIGA
+#  define OS_CODE  0x01
+#endif
+
+#if defined(VAXC) || defined(VMS)
+#  define OS_CODE  0x02
+#  define F_OPEN(name, mode) \
+     fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
+#endif
+
+#if defined(ATARI) || defined(atarist)
+#  define OS_CODE  0x05
+#endif
+
+#ifdef OS2
+#  define OS_CODE  0x06
+#  if defined(M_I86) && !defined(Z_SOLO)
+#    include <malloc.h>
+#  endif
+#endif
+
+#if defined(MACOS) || defined(TARGET_OS_MAC)
+#  define OS_CODE  0x07
+#  ifndef Z_SOLO
+#    if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
+#      include <unix.h> /* for fdopen */
+#    else
+#      ifndef fdopen
+#        define fdopen(fd,mode) NULL /* No fdopen() */
+#      endif
+#    endif
+#  endif
+#endif
+
+#ifdef TOPS20
+#  define OS_CODE  0x0a
+#endif
+
+#ifdef WIN32
+#  ifndef __CYGWIN__  /* Cygwin is Unix, not Win32 */
+#    define OS_CODE  0x0b
+#  endif
+#endif
+
+#ifdef __50SERIES /* Prime/PRIMOS */
+#  define OS_CODE  0x0f
+#endif
+
+#if defined(_BEOS_) || defined(RISCOS)
+#  define fdopen(fd,mode) NULL /* No fdopen() */
+#endif
+
+#if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX
+#  if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
+#    define fdopen(fd,mode) NULL /* No fdopen() */
+#    ifndef _PTRDIFF_T_DEFINED
+       typedef int ptrdiff_t;
+#      define _PTRDIFF_T_DEFINED
+#    endif
+#  else
+#    define fdopen(fd,type)  _fdopen(fd,type)
+#  endif
+#endif
+
+#if defined(__BORLANDC__) && !defined(MSDOS)
+  #pragma warn -8004
+  #pragma warn -8008
+  #pragma warn -8066
+#endif
+
+/* provide prototypes for these when building zlib without LFS */
+#if !defined(_WIN32) && \
+    (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0)
+    ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
+    ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
+#endif
+
+        /* common defaults */
+
+#ifndef OS_CODE
+#  define OS_CODE  0x03  /* assume Unix */
+#endif
+
+#ifndef F_OPEN
+#  define F_OPEN(name, mode) fopen((name), (mode))
+#endif
+
+         /* functions */
+
+#if defined(pyr) || defined(Z_SOLO)
+#  define NO_MEMCPY
+#endif
+#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
+ /* Use our own functions for small and medium model with MSC <= 5.0.
+  * You may have to use the same strategy for Borland C (untested).
+  * The __SC__ check is for Symantec.
+  */
+#  define NO_MEMCPY
+#endif
+#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
+#  define HAVE_MEMCPY
+#endif
+#ifdef HAVE_MEMCPY
+#  ifdef SMALL_MEDIUM /* MSDOS small or medium model */
+#    define zmemcpy _fmemcpy
+#    define zmemcmp _fmemcmp
+#    define zmemzero(dest, len) _fmemset(dest, 0, len)
+#  else
+#    define zmemcpy memcpy
+#    define zmemcmp memcmp
+#    define zmemzero(dest, len) memset(dest, 0, len)
+#  endif
+#else
+   void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len));
+   int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len));
+   void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len));
+#endif
+
+/* Diagnostic functions */
+#ifdef ZLIB_DEBUG
+#  include <stdio.h>
+   extern int ZLIB_INTERNAL z_verbose;
+   extern void ZLIB_INTERNAL z_error OF((char *m));
+#  define Assert(cond,msg) {if(!(cond)) z_error(msg);}
+#  define Trace(x) {if (z_verbose>=0) fprintf x ;}
+#  define Tracev(x) {if (z_verbose>0) fprintf x ;}
+#  define Tracevv(x) {if (z_verbose>1) fprintf x ;}
+#  define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}
+#  define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}
+#else
+#  define Assert(cond,msg)
+#  define Trace(x)
+#  define Tracev(x)
+#  define Tracevv(x)
+#  define Tracec(c,x)
+#  define Tracecv(c,x)
+#endif
+
+#ifndef Z_SOLO
+   voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items,
+                                    unsigned size));
+   void ZLIB_INTERNAL zcfree  OF((voidpf opaque, voidpf ptr));
+#endif
+
+#define ZALLOC(strm, items, size) \
+           (*((strm)->zalloc))((strm)->opaque, (items), (size))
+#define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
+#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
+
+/* Reverse the bytes in a 32-bit value */
+#define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
+                    (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
+
+#endif /* ZUTIL_H */
diff --git a/base/poco/JSON/CMakeLists.txt b/base/poco/JSON/CMakeLists.txt
new file mode 100644
index 00000000000..96fa00d098d
--- /dev/null
+++ b/base/poco/JSON/CMakeLists.txt
@@ -0,0 +1,18 @@
+# Poco::JSON (pdjson)
+
+set (SRCS_PDJSON
+    src/pdjson.c
+)
+
+add_library (_poco_json_pdjson ${SRCS_PDJSON})
+add_library (Poco::JSON::Pdjson ALIAS _poco_json_pdjson)
+
+# Poco::JSON
+
+file (GLOB SRCS src/*.cpp)
+
+add_library (_poco_json ${SRCS})
+add_library (Poco::JSON ALIAS _poco_json)
+
+target_include_directories (_poco_json SYSTEM PUBLIC "include")
+target_link_libraries (_poco_json PUBLIC Poco::Foundation Poco::JSON::Pdjson)
diff --git a/base/poco/JSON/include/Poco/JSON/Array.h b/base/poco/JSON/include/Poco/JSON/Array.h
new file mode 100644
index 00000000000..6a61ad39c6c
--- /dev/null
+++ b/base/poco/JSON/include/Poco/JSON/Array.h
@@ -0,0 +1,566 @@
+//
+// Array.h
+//
+// Library: JSON
+// Package: JSON
+// Module:  Array
+//
+// Definition of the Array class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef JSON_Array_INCLUDED
+#define JSON_Array_INCLUDED
+
+
+#include "Poco/JSON/JSON.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Dynamic/Var.h"
+#include <vector>
+#include <sstream>
+
+
+namespace Poco {
+namespace JSON {
+
+
+class Object;
+
+
+class JSON_API Array
+	/// Represents a JSON array. Array provides a representation
+	/// based on shared pointers and optimized for performance. It is possible to
+	/// convert Array to Poco::Dynamic::Array. Conversion requires copying and therefore
+	/// has performance penalty; the benefit is in improved syntax, eg:
+	///
+	///    // use pointers to avoid copying
+	///    using namespace Poco::JSON;
+	///    std::string json = "[ {\"test\" : 0}, { \"test1\" : [1, 2, 3], \"test2\" : 4 } ]";
+	///    Parser parser;
+	///    Var result = parser.parse(json);
+	///    Array::Ptr arr = result.extract<Array::Ptr>();
+	///    Object::Ptr object = arr->getObject(0); // object == {\"test\" : 0}
+	///    int i = object->getElement<int>("test"); // i == 0;
+	///    Object::Ptr subObject = *arr->getObject(1); // subObject == {\"test\" : 0}
+	///    Array subArr::Ptr = subObject->getArray("test1"); // subArr == [1, 2, 3]
+	///    i = result = subArr->get(0); // i == 1;
+	///
+	///    // copy/convert to Poco::Dynamic::Array
+	///    Poco::Dynamic::Array da = *arr;
+	///    i = da[0]["test"];     // i == 0
+	///    i = da[1]["test1"][1]; // i == 2
+	///    i = da[1]["test2"];    // i == 4
+	/// ----
+{
+public:
+	typedef std::vector<Dynamic::Var>                 ValueVec;
+	typedef std::vector<Dynamic::Var>::iterator       Iterator;
+	typedef std::vector<Dynamic::Var>::const_iterator ConstIterator;
+	typedef SharedPtr<Array> Ptr;
+
+	Array(int options = 0);
+		/// Creates an empty Array.
+		///
+		/// If JSON_ESCAPE_UNICODE is specified, when the object is
+		/// stringified, all unicode characters will be escaped in the
+		/// resulting string.
+
+	Array(const Array& copy);
+		/// Creates an Array by copying another one.
+
+#ifdef POCO_ENABLE_CPP11
+
+	Array(Array&& other);
+		/// Move constructor
+
+	Array& operator=(Array&& other);
+		/// Move assignment operator.
+
+#endif // POCO_ENABLE_CPP11
+
+	Array& operator=(const Array& other);
+		/// Assignment operator.
+
+	virtual ~Array();
+		/// Destroys the Array.
+
+	void setEscapeUnicode(bool escape = true);
+		/// Sets the flag for escaping unicode.
+
+	bool getEscapeUnicode() const;
+		/// Returns the flag for escaping unicode.
+
+	ValueVec::const_iterator begin() const;
+		/// Returns the begin iterator for values.
+
+	ValueVec::const_iterator end() const;
+		/// Returns the end iterator for values.
+
+	Dynamic::Var get(unsigned int index) const;
+		/// Retrieves the element at the given index.
+		/// Will return an empty value when the element doesn't exist.
+
+	Array::Ptr getArray(unsigned int index) const;
+		/// Retrieves an array. When the element is not
+		/// an Array or doesn't exist, an empty SharedPtr is returned.
+
+	template<typename T>
+	T getElement(unsigned int index) const
+		/// Retrieves an element and tries to convert it to the
+		/// template type. The convert<T> method of
+		/// Dynamic is called which can also throw
+		/// exceptions for invalid values.
+		/// Note: This will not work for an array or an object.
+	{
+		Dynamic::Var value = get(index);
+		return value.convert<T>();
+	}
+
+	SharedPtr<Object> getObject(unsigned int index) const;
+		/// Retrieves an object. When the element is not
+		/// an object or doesn't exist, an empty SharedPtr is returned.
+
+	std::size_t size() const;
+		/// Returns the size of the array.
+
+	bool isArray(unsigned int index) const;
+		/// Returns true when the element is an array.
+
+	bool isArray(const Dynamic::Var& value) const;
+		/// Returns true when the element is an array.
+
+	bool isArray(ConstIterator& value) const;
+		/// Returns true when the element is an array.
+
+	bool isNull(unsigned int index) const;
+		/// Returns true when the element is null or
+		/// when the element doesn't exist.
+
+	bool isObject(unsigned int index) const;
+		/// Returns true when the element is an object.
+
+	bool isObject(const Dynamic::Var& value) const;
+		/// Returns true when the element is an object.
+
+	bool isObject(ConstIterator& value) const;
+		/// Returns true when the element is an object.
+
+	template<typename T>
+	T optElement(unsigned int index, const T& def) const
+		/// Returns the element at the given index. When
+		/// the element is null, doesn't exist or can't
+		/// be converted to the given type, the default
+		/// value will be returned
+	{
+		T value = def;
+		if (index < _values.size())
+		{
+			try
+			{
+				value = _values[index].convert<T>();
+			}
+			catch (...)
+			{
+				// Default value is returned.
+			}
+		}
+		return value;
+	}
+
+	void add(const Dynamic::Var& value);
+		/// Add the given value to the array
+
+	void set(unsigned int index, const Dynamic::Var& value);
+		/// Update the element on the given index to specified value
+
+	void stringify(std::ostream& out, unsigned int indent = 0, int step = -1) const;
+		/// Prints the array to out. When indent has zero value,
+		/// the array will be printed without newline breaks and spaces between elements.
+
+	void remove(unsigned int index);
+		/// Removes the element on the given index.
+
+	operator const Poco::Dynamic::Array& () const;
+		/// Conversion operator to Dynamic::Array.
+
+	static Poco::Dynamic::Array makeArray(const JSON::Array::Ptr& arr);
+		/// Utility function for creation of array.
+
+	void clear();
+		/// Clears the contents of the array.
+
+private:
+	void resetDynArray() const;
+
+	typedef SharedPtr<Poco::Dynamic::Array> ArrayPtr;
+
+	ValueVec         _values;
+	mutable ArrayPtr _pArray;
+	mutable bool     _modified;
+	// Note:
+	//  The reason we have this flag here (rather than as argument to stringify())
+	//  is because Array can be returned stringified from a Dynamic::Var:toString(),
+	//  so it must know whether to escape unicode or not.
+	bool             _escapeUnicode;
+};
+
+
+//
+// inlines
+//
+
+inline void Array::setEscapeUnicode(bool escape)
+{
+	_escapeUnicode = escape;
+}
+
+
+inline bool Array::getEscapeUnicode() const
+{
+	return _escapeUnicode;
+}
+
+
+inline Array::ValueVec::const_iterator Array::begin() const
+{
+	return _values.begin();
+}
+
+
+inline Array::ValueVec::const_iterator Array::end() const
+
+{
+	return _values.end();
+}
+
+
+inline std::size_t Array::size() const
+{
+	return static_cast<std::size_t>(_values.size());
+}
+
+
+inline bool Array::isArray(unsigned int index) const
+{
+	Dynamic::Var value = get(index);
+	return isArray(value);
+}
+
+
+inline bool Array::isArray(const Dynamic::Var& value) const
+{
+	return value.type() == typeid(Array::Ptr);
+}
+
+
+inline bool Array::isArray(ConstIterator& it) const
+{
+	return it!= end() && isArray(*it);
+}
+
+
+inline void Array::add(const Dynamic::Var& value)
+{
+	_values.push_back(value);
+	_modified = true;
+}
+
+
+inline void Array::set(unsigned int index, const Dynamic::Var& value)
+{
+	if (index >= _values.size()) _values.resize(index + 1);
+	_values[index] = value;
+	_modified = true;
+}
+
+
+inline void Array::remove(unsigned int index)
+{
+	_values.erase(_values.begin() + index);
+}
+
+
+} } // namespace Poco::JSON
+
+
+namespace Poco {
+namespace Dynamic {
+
+
+template <>
+class VarHolderImpl<JSON::Array::Ptr>: public VarHolder
+{
+public:
+	VarHolderImpl(const JSON::Array::Ptr& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(JSON::Array::Ptr);
+	}
+
+	void convert(Int8&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(Int16&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(Int32&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(Int64&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(UInt8&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(UInt16&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(UInt32&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(UInt64&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(bool& value) const
+	{
+		value = !_val.isNull() && _val->size() > 0;
+	}
+
+	void convert(float&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(double&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(char&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(std::string& s) const
+	{
+		std::ostringstream oss;
+		_val->stringify(oss, 2);
+		s = oss.str();
+	}
+
+	void convert(DateTime& /*val*/) const
+	{
+		throw BadCastException("Cannot convert Array to DateTime");
+	}
+
+	void convert(LocalDateTime& /*ldt*/) const
+	{
+		throw BadCastException("Cannot convert Array to LocalDateTime");
+	}
+
+	void convert(Timestamp& /*ts*/) const
+	{
+		throw BadCastException("Cannot convert Array to Timestamp");
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const JSON::Array::Ptr& value() const
+	{
+		return _val;
+	}
+
+	bool isInteger() const
+	{
+		return false;
+	}
+
+	bool isSigned() const
+	{
+		return false;
+	}
+
+	bool isNumeric() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	JSON::Array::Ptr _val;
+};
+
+
+template <>
+class VarHolderImpl<JSON::Array>: public VarHolder
+{
+public:
+	VarHolderImpl(const JSON::Array& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(JSON::Array);
+	}
+
+	void convert(Int8&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(Int16&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(Int32&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(Int64&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(UInt8&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(UInt16&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(UInt32&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(UInt64&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(bool& value) const
+	{
+		value = _val.size() > 0;
+	}
+
+	void convert(float&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(double&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(char&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(std::string& s) const
+	{
+		std::ostringstream oss;
+		_val.stringify(oss, 2);
+		s = oss.str();
+	}
+
+	void convert(DateTime& /*val*/) const
+	{
+		throw BadCastException("Cannot convert Array to DateTime");
+	}
+
+	void convert(LocalDateTime& /*ldt*/) const
+	{
+		throw BadCastException("Cannot convert Array to LocalDateTime");
+	}
+
+	void convert(Timestamp& /*ts*/) const
+	{
+		throw BadCastException("Cannot convert Array to Timestamp");
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const JSON::Array& value() const
+	{
+		return _val;
+	}
+
+	bool isInteger() const
+	{
+		return false;
+	}
+
+	bool isSigned() const
+	{
+		return false;
+	}
+
+	bool isNumeric() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	JSON::Array _val;
+};
+
+
+} } // namespace Poco::Dynamic
+
+
+#endif // JSON_Array_INCLUDED
diff --git a/base/poco/JSON/include/Poco/JSON/Handler.h b/base/poco/JSON/include/Poco/JSON/Handler.h
new file mode 100644
index 00000000000..8c64f34ff01
--- /dev/null
+++ b/base/poco/JSON/include/Poco/JSON/Handler.h
@@ -0,0 +1,106 @@
+//
+// Handler.h
+//
+// Library: JSON
+// Package: JSON
+// Module:  Handler
+//
+// Definition of the Handler class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef JSON_Handler_INCLUDED
+#define JSON_Handler_INCLUDED
+
+
+#include "Poco/JSON/JSON.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Dynamic/Var.h"
+#include "Poco/Dynamic/Struct.h"
+
+
+namespace Poco {
+namespace JSON {
+
+
+class JSON_API Handler
+	/// Interface for handling parsing events generated by the JSON Parser.
+	///
+	/// An application can implement a subclass of Handler to implement
+	/// callback-based parsing of a JSON document, similar to how a SAX
+	/// parser would handle XML.
+{
+public:
+	typedef SharedPtr<Handler> Ptr;
+
+	Handler();
+		/// Creates an empty Handler.
+	
+	virtual ~Handler();
+		/// Destroys the Handler.
+
+	virtual void reset() = 0;
+		/// Resets the handler state.
+
+	virtual void startObject() = 0;
+		/// The parser has read a {, meaning a new object will be read.
+
+	virtual void endObject() = 0;
+		/// The parser has read a }, meaning the object is read.
+
+	virtual void startArray() = 0;
+		/// The parser has read a [, meaning a new array will be read.
+
+	virtual void endArray() = 0;
+		/// The parser has read a ], meaning the array is read.
+
+	virtual void key(const std::string& k) = 0;
+		/// A key of an object is read.
+
+	virtual void null() = 0;
+		/// A null value is read.
+
+	virtual void value(int v) = 0;
+		/// An integer value is read.
+
+	virtual void value(unsigned v) = 0;
+		/// An unsigned value is read. This will only be triggered if the
+		/// value cannot fit into a signed int.
+
+#if defined(POCO_HAVE_INT64)
+	virtual void value(Int64 v) = 0;
+		/// A 64-bit integer value is read.
+
+	virtual void value(UInt64 v) = 0;
+		/// An unsigned 64-bit integer value is read. This will only be
+		/// triggered if the value cannot fit into a signed 64-bit integer.
+#endif
+
+	virtual void value(const std::string& value) = 0;
+		/// A string value is read.
+
+	virtual void value(double d) = 0;
+		/// A double value is read.
+
+	virtual void value(bool b) = 0;
+		/// A boolean value is read.
+
+	virtual Poco::Dynamic::Var asVar() const;
+		/// Returns the result of the parser (an object, array or string),
+		/// empty Var if there is no result.
+
+	virtual Poco::DynamicStruct asStruct() const;
+		/// Returns the result of the parser (an object, array or string),
+		/// empty Var if there is no result.
+};
+
+
+} } // namespace Poco::JSON
+
+
+#endif // JSON_Handler_INCLUDED
diff --git a/base/poco/JSON/include/Poco/JSON/JSON.h b/base/poco/JSON/include/Poco/JSON/JSON.h
new file mode 100644
index 00000000000..36d7623756b
--- /dev/null
+++ b/base/poco/JSON/include/Poco/JSON/JSON.h
@@ -0,0 +1,62 @@
+//
+// JSON.h
+//
+// Library: JSON
+// Package: JSON
+// Module:  JSON
+//
+// Basic definitions for the Poco JSON library.
+// This file must be the first file included by every other JSON
+// header file.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef JSON_JSON_INCLUDED
+#define JSON_JSON_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+//
+// The following block is the standard way of creating macros which make exporting
+// from a DLL simpler. All files within this DLL are compiled with the JSON_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any project
+// that uses this DLL. This way any other project whose source files include this file see
+// JSON_API functions as being imported from a DLL, whereas this DLL sees symbols
+// defined with this macro as being exported.
+//
+#if defined(_WIN32) && defined(POCO_DLL)
+	#if defined(JSON_EXPORTS)
+		#define JSON_API __declspec(dllexport)
+	#else
+		#define JSON_API __declspec(dllimport)
+	#endif
+#endif
+
+
+#if !defined(JSON_API)
+	#if !defined(POCO_NO_GCC_API_ATTRIBUTE) && defined (__GNUC__) && (__GNUC__ >= 4)
+		#define JSON_API __attribute__ ((visibility ("default")))
+	#else
+		#define JSON_API
+	#endif
+#endif
+
+
+//
+// Automatically link JSON library.
+//
+#if defined(_MSC_VER)
+	#if !defined(POCO_NO_AUTOMATIC_LIBS) && !defined(JSON_EXPORTS)
+		#pragma comment(lib, "PocoJSON" POCO_LIB_SUFFIX)
+	#endif
+#endif
+
+
+#endif // JSON_JSON_INCLUDED
diff --git a/base/poco/JSON/include/Poco/JSON/JSONException.h b/base/poco/JSON/include/Poco/JSON/JSONException.h
new file mode 100644
index 00000000000..058d36f0aea
--- /dev/null
+++ b/base/poco/JSON/include/Poco/JSON/JSONException.h
@@ -0,0 +1,35 @@
+//
+// JSONException.h
+//
+// Library: JSON
+// Package: JSON
+// Module:  JSONException
+//
+// Definition of the JSONException class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef JSON_JSONException_INCLUDED
+#define JSON_JSONException_INCLUDED
+
+
+#include "Poco/JSON/JSON.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+namespace JSON {
+
+
+POCO_DECLARE_EXCEPTION(JSON_API, JSONException, Poco::Exception)
+
+
+} } // namespace Poco::JSON
+
+
+#endif // JSON_JSONException_INCLUDED
diff --git a/base/poco/JSON/include/Poco/JSON/Object.h b/base/poco/JSON/include/Poco/JSON/Object.h
new file mode 100644
index 00000000000..8812561a53a
--- /dev/null
+++ b/base/poco/JSON/include/Poco/JSON/Object.h
@@ -0,0 +1,715 @@
+//
+// Object.h
+//
+// Library: JSON
+// Package: JSON
+// Module:  Object
+//
+// Definition of the Object class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef JSON_Object_INCLUDED
+#define JSON_Object_INCLUDED
+
+
+#include "Poco/JSON/JSON.h"
+#include "Poco/JSON/Array.h"
+#include "Poco/JSON/Stringifier.h"
+#include "Poco/JSONString.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Dynamic/Var.h"
+#include "Poco/Dynamic/Struct.h"
+#include "Poco/Nullable.h"
+#include <map>
+#include <vector>
+#include <deque>
+#include <iostream>
+#include <sstream>
+
+
+namespace Poco {
+namespace JSON {
+
+
+class JSON_API Object
+	/// Represents a JSON object. Object provides a representation based on
+	/// shared pointers and optimized for performance. It is possible to
+	/// convert Object to DynamicStruct. Conversion requires copying and therefore
+	/// has performance penalty; the benefit is in improved syntax, eg:
+	///
+	///    std::string json = "{ \"test\" : { \"property\" : \"value\" } }";
+	///    Parser parser;
+	///    Var result = parser.parse(json);
+	///
+	///    // use pointers to avoid copying
+	///    Object::Ptr object = result.extract<Object::Ptr>();
+	///    Var test = object->get("test"); // holds { "property" : "value" }
+	///    Object::Ptr subObject = test.extract<Object::Ptr>();
+	///    test = subObject->get("property");
+	///    std::string val = test.toString(); // val holds "value"
+	///
+	///    // copy/convert to Poco::DynamicStruct
+	///    Poco::DynamicStruct ds = *object;
+	///    val = ds["test"]["property"]; // val holds "value"
+	///
+{
+public:
+	typedef SharedPtr<Object>                   Ptr;
+	typedef std::map<std::string, Dynamic::Var> ValueMap;
+	typedef ValueMap::value_type                ValueType;
+	typedef ValueMap::iterator                  Iterator;
+	typedef ValueMap::const_iterator            ConstIterator;
+	typedef std::vector<std::string>            NameList;
+
+	explicit Object(int options = 0);
+		/// Creates an empty Object.
+		///
+		/// If JSON_PRESERVE_KEY_ORDER is specified, the object will
+		/// preserve the items insertion order. Otherwise, items will be
+		/// sorted by keys.
+		///
+		/// If JSON_ESCAPE_UNICODE is specified, when the object is
+		/// stringified, all unicode characters will be escaped in the
+		/// resulting string.
+
+	Object(const Object& copy);
+		/// Creates an Object by copying another one.
+		///
+		/// Struct is not copied to keep the operation as
+		/// efficient as possible (when needed, it will be generated upon request).
+
+#ifdef POCO_ENABLE_CPP11
+
+	Object(Object&& other);
+		/// Move constructor
+
+	Object &operator =(Object &&other);
+		// Move asignment operator
+
+#endif // POCO_ENABLE_CPP11
+
+	virtual ~Object();
+		/// Destroys the Object.
+
+	Object &operator =(const Object &other);
+		// Assignment operator
+
+	void setEscapeUnicode(bool escape = true);
+		/// Sets the flag for escaping unicode.
+
+	bool getEscapeUnicode() const;
+		/// Returns the flag for escaping unicode.
+
+	Iterator begin();
+		/// Returns begin iterator for values.
+
+	ConstIterator begin() const;
+		/// Returns const begin iterator for values.
+
+	Iterator end();
+		/// Returns end iterator for values.
+
+	ConstIterator end() const;
+		/// Returns const end iterator for values.
+
+	Dynamic::Var get(const std::string& key) const;
+		/// Retrieves a property. An empty value is
+		/// returned when the property doesn't exist.
+
+	Array::Ptr getArray(const std::string& key) const;
+		/// Returns a SharedPtr to an array when the property
+		/// is an array. An empty SharedPtr is returned when
+		/// the element doesn't exist or is not an array.
+
+	Object::Ptr getObject(const std::string& key) const;
+		/// Returns a SharedPtr to an object when the property
+		/// is an object. An empty SharedPtr is returned when
+		/// the property doesn't exist or is not an object
+
+	template<typename T>
+	T getValue(const std::string& key) const
+		/// Retrieves the property with the given name and will
+		/// try to convert the value to the given template type.
+		/// The convert<T>() method of Var is called
+		/// which can also throw exceptions for invalid values.
+		/// Note: This will not work for an array or an object.
+	{
+		Dynamic::Var value = get(key);
+		return value.convert<T>();
+	}
+
+	template<typename T>
+	Poco::Nullable<T> getNullableValue(const std::string& key) const
+		/// Retrieves the property with the given name and will
+		/// try to convert the value to the given template type.
+		///
+		/// The convert<T> method of Var is called
+		/// which can also throw exceptions for invalid values.
+		/// Note: This will not work for an array or an object.
+	{
+		if (isNull(key))
+			return Poco::Nullable<T>();
+
+		Dynamic::Var value = get(key);
+		return value.convert<T>();
+	}
+
+	void getNames(NameList& names) const;
+		/// Fills the supplied vector with all property names.
+
+	NameList getNames() const;
+		/// Returns all property names.
+
+	bool has(const std::string& key) const;
+		/// Returns true when the given property exists.
+
+	bool isArray(const std::string& key) const;
+		/// Returns true when the given property contains an array.
+
+	bool isArray(ConstIterator& it) const;
+		/// Returns true when the given property contains an array.
+
+	bool isNull(const std::string& key) const;
+		/// Returns true when the given property contains a null value.
+
+	bool isObject(const std::string& key) const;
+		/// Returns true when the given property contains an object.
+
+	bool isObject(ConstIterator& it) const;
+		/// Returns true when the given property contains an object.
+
+	template<typename T>
+	T optValue(const std::string& key, const T& def) const
+		/// Returns the value of a property when the property exists
+		/// and can be converted to the given type. Otherwise
+		/// def will be returned.
+	{
+		T value = def;
+		ValueMap::const_iterator it = _values.find(key);
+		if (it != _values.end() && ! it->second.isEmpty())
+		{
+			try
+			{
+				value = it->second.convert<T>();
+			}
+			catch (...)
+			{
+				// The default value will be returned
+			}
+		}
+		return value;
+	}
+
+	std::size_t size() const;
+		/// Returns the number of properties.
+
+	void set(const std::string& key, const Dynamic::Var& value);
+		/// Sets a new value.
+
+	void stringify(std::ostream& out, unsigned int indent = 0, int step = -1) const;
+		/// Prints the object to out stream.
+		///
+		/// When indent is 0, the object will be printed on a single
+		/// line without indentation.
+
+	void remove(const std::string& key);
+		/// Removes the property with the given key.
+
+	static Poco::DynamicStruct makeStruct(const Object::Ptr& obj);
+		/// Utility function for creation of struct.
+
+	operator const Poco::DynamicStruct& () const;
+		/// Cast operator to Poco::DynamiStruct.
+
+	void clear();
+		/// Clears the contents of the object.
+		///
+		/// Insertion order preservation property is left intact.
+
+private:
+	typedef std::deque<ValueMap::const_iterator>  KeyList;
+	typedef Poco::DynamicStruct::Ptr              StructPtr;
+
+	void resetDynStruct() const;
+	void syncKeys(const KeyList& keys);
+
+	template <typename C>
+	void doStringify(const C& container, std::ostream& out, unsigned int indent, unsigned int step) const
+	{
+		int options = Poco::JSON_WRAP_STRINGS;
+		options |= _escapeUnicode ? Poco::JSON_ESCAPE_UNICODE : 0;
+
+		out << '{';
+
+		if (indent > 0) out << std::endl;
+
+		typename C::const_iterator it = container.begin();
+		typename C::const_iterator end = container.end();
+		for (; it != end;)
+		{
+			for (unsigned int i = 0; i < indent; i++) out << ' ';
+
+			Stringifier::stringify(getKey(it), out, indent, step, options);
+			out << ((indent > 0) ? " : " : ":");
+
+			Stringifier::stringify(getValue(it), out, indent + step, step, options);
+
+			if (++it != container.end()) out << ',';
+
+			if (step > 0) out << std::endl;
+		}
+
+		if (indent >= step) indent -= step;
+
+		for (unsigned int i = 0; i < indent; i++) out << ' ';
+
+		out << '}';
+	}
+
+	const std::string& getKey(ValueMap::const_iterator& it) const;
+	const Dynamic::Var& getValue(ValueMap::const_iterator& it) const;
+	const std::string& getKey(KeyList::const_iterator& it) const;
+	const Dynamic::Var& getValue(KeyList::const_iterator& it) const;
+
+	ValueMap          _values;
+	KeyList           _keys;
+	bool              _preserveInsOrder;
+	// Note:
+	//  The reason for this flag (rather than as argument to stringify()) is
+	//  because Object can be returned stringified from Dynamic::Var::toString(),
+	//  so it must know whether to escape unicode or not.
+	bool              _escapeUnicode;
+	mutable StructPtr _pStruct;
+	mutable bool      _modified;
+};
+
+
+//
+// inlines
+//
+
+inline void Object::setEscapeUnicode(bool escape)
+{
+	_escapeUnicode = escape;
+}
+
+
+inline bool Object::getEscapeUnicode() const
+{
+	return _escapeUnicode;
+}
+
+
+inline Object::Iterator Object::begin()
+{
+	return _values.begin();
+}
+
+
+inline Object::ConstIterator Object::begin() const
+{
+	return _values.begin();
+}
+
+
+inline Object::Iterator Object::end()
+{
+	return _values.end();
+}
+
+
+inline Object::ConstIterator Object::end() const
+{
+	return _values.end();
+}
+
+
+inline bool Object::has(const std::string& key) const
+{
+	ValueMap::const_iterator it = _values.find(key);
+	return it != _values.end();
+}
+
+
+inline bool Object::isArray(const std::string& key) const
+{
+	ValueMap::const_iterator it = _values.find(key);
+	return isArray(it);
+}
+
+
+inline bool Object::isArray(ConstIterator& it) const
+{
+	return it != _values.end() && (it->second.type() == typeid(Array::Ptr) || it->second.type() == typeid(Array));
+}
+
+
+inline bool Object::isNull(const std::string& key) const
+{
+	ValueMap::const_iterator it = _values.find(key);
+	return it == _values.end() || it->second.isEmpty();
+}
+
+
+inline bool Object::isObject(const std::string& key) const
+{
+	ValueMap::const_iterator it = _values.find(key);
+	return isObject(it);
+}
+
+
+inline bool Object::isObject(ConstIterator& it) const
+{
+	return it != _values.end() && (it->second.type() == typeid(Object::Ptr) || it->second.type() == typeid(Object));
+}
+
+
+inline std::size_t Object::size() const
+{
+	return static_cast<std::size_t>(_values.size());
+}
+
+
+inline void Object::remove(const std::string& key)
+{
+	_values.erase(key);
+	if (_preserveInsOrder)
+	{
+		KeyList::iterator it = _keys.begin();
+		KeyList::iterator end = _keys.end();
+		for (; it != end; ++it)
+		{
+			if (key == (*it)->first)
+			{
+				_keys.erase(it);
+				break;
+			}
+		}
+	}
+	_modified = true;
+}
+
+
+inline const std::string& Object::getKey(ValueMap::const_iterator& it) const
+{
+	return it->first;
+}
+
+
+inline const Dynamic::Var& Object::getValue(ValueMap::const_iterator& it) const
+{
+	return it->second;
+}
+
+
+inline const Dynamic::Var& Object::getValue(KeyList::const_iterator& it) const
+{
+	ValueMap::const_iterator itv = _values.find((*it)->first);
+	if (itv != _values.end())
+		return itv->second;
+	else
+		throw Poco::NotFoundException();
+}
+
+
+} } // namespace Poco::JSON
+
+
+namespace Poco {
+namespace Dynamic {
+
+
+template <>
+class VarHolderImpl<JSON::Object::Ptr>: public VarHolder
+{
+public:
+	VarHolderImpl(const JSON::Object::Ptr& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(JSON::Object::Ptr);
+	}
+
+	void convert(Int8&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(Int16&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(Int32&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(Int64&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(UInt8&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(UInt16&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(UInt32&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(UInt64&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(bool& value) const
+	{
+		value = !_val.isNull() && _val->size() > 0;
+	}
+
+	void convert(float&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(double&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(char&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(std::string& s) const
+	{
+		std::ostringstream oss;
+		_val->stringify(oss, 2);
+		s = oss.str();
+	}
+
+	void convert(DateTime& /*val*/) const
+	{
+		//TODO: val = _val;
+		throw NotImplementedException("Conversion not implemented: JSON:Object => DateTime");
+	}
+
+	void convert(LocalDateTime& /*ldt*/) const
+	{
+		//TODO: ldt = _val.timestamp();
+		throw NotImplementedException("Conversion not implemented: JSON:Object => LocalDateTime");
+	}
+
+	void convert(Timestamp& /*ts*/) const
+	{
+		//TODO: ts = _val.timestamp();
+		throw NotImplementedException("Conversion not implemented: JSON:Object => Timestamp");
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const JSON::Object::Ptr& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return false;
+	}
+
+	bool isSigned() const
+	{
+		return false;
+	}
+
+	bool isNumeric() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	JSON::Object::Ptr _val;
+};
+
+
+template <>
+class VarHolderImpl<JSON::Object>: public VarHolder
+{
+public:
+	VarHolderImpl(const JSON::Object& val): _val(val)
+	{
+	}
+
+	~VarHolderImpl()
+	{
+	}
+
+	const std::type_info& type() const
+	{
+		return typeid(JSON::Object);
+	}
+
+	void convert(Int8&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(Int16&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(Int32&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(Int64&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(UInt8&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(UInt16&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(UInt32&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(UInt64&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(bool& value) const
+	{
+		value = _val.size() > 0;
+	}
+
+	void convert(float&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(double&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(char&) const
+	{
+		throw BadCastException();
+	}
+
+	void convert(std::string& s) const
+	{
+		std::ostringstream oss;
+		_val.stringify(oss, 2);
+		s = oss.str();
+	}
+
+	void convert(DateTime& /*val*/) const
+	{
+		//TODO: val = _val;
+		throw NotImplementedException("Conversion not implemented: JSON:Object => DateTime");
+	}
+
+	void convert(LocalDateTime& /*ldt*/) const
+	{
+		//TODO: ldt = _val.timestamp();
+		throw NotImplementedException("Conversion not implemented: JSON:Object => LocalDateTime");
+	}
+
+	void convert(Timestamp& /*ts*/) const
+	{
+		//TODO: ts = _val.timestamp();
+		throw NotImplementedException("Conversion not implemented: JSON:Object => Timestamp");
+	}
+
+	VarHolder* clone(Placeholder<VarHolder>* pVarHolder = 0) const
+	{
+		return cloneHolder(pVarHolder, _val);
+	}
+
+	const JSON::Object& value() const
+	{
+		return _val;
+	}
+
+	bool isArray() const
+	{
+		return false;
+	}
+
+	bool isInteger() const
+	{
+		return false;
+	}
+
+	bool isSigned() const
+	{
+		return false;
+	}
+
+	bool isNumeric() const
+	{
+		return false;
+	}
+
+	bool isString() const
+	{
+		return false;
+	}
+
+private:
+	JSON::Object _val;
+};
+
+
+} } // namespace Poco::Dynamic
+
+
+#endif // JSON_Object_INCLUDED
diff --git a/base/poco/JSON/include/Poco/JSON/ParseHandler.h b/base/poco/JSON/include/Poco/JSON/ParseHandler.h
new file mode 100644
index 00000000000..98cd69ed89d
--- /dev/null
+++ b/base/poco/JSON/include/Poco/JSON/ParseHandler.h
@@ -0,0 +1,169 @@
+//
+// ParseHandler.h
+//
+// Library: JSON
+// Package: JSON
+// Module:  ParseHandler
+//
+// Definition of the ParseHandler class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef JSON_ParseHandler_INCLUDED
+#define JSON_ParseHandler_INCLUDED
+
+
+#include "Poco/JSON/Handler.h"
+#include <stack>
+
+
+namespace Poco {
+namespace JSON {
+
+
+class JSON_API ParseHandler: public Handler
+	/// ParseHandler is the default handler for the JSON Parser.
+	///
+	/// This handler will construct an Object or Array based
+	/// on the handlers called by the Parser.
+{
+public:
+	ParseHandler(bool preserveObjectOrder = false);
+		/// Creates the ParseHandler.
+		///
+		/// If preserveObjectOrder is true, the order of properties
+		/// inside objects is preserved. Otherwise, items
+		/// will be sorted by keys.
+
+	virtual ~ParseHandler();
+		/// Destroys the ParseHandler.
+
+	virtual void reset();
+		/// Resets the handler state.
+		
+	void startObject();
+		/// Handles a '{'; a new object is started.
+
+	void endObject();
+		/// Handles a '}'; the object is closed.
+
+	void startArray();
+		/// Handles a '['; a new array is started.
+
+	void endArray();
+		/// Handles a ']'; the array is closed.
+
+	void key(const std::string& k);
+		/// A key is read
+
+	Dynamic::Var asVar() const;
+		/// Returns the result of the parser (an object or an array).
+
+	virtual void value(int v);
+		/// An integer value is read
+
+	virtual void value(unsigned v);
+		/// An unsigned value is read. This will only be triggered if the
+		/// value cannot fit into a signed int.
+
+#if defined(POCO_HAVE_INT64)
+	virtual void value(Int64 v);
+		/// A 64-bit integer value is read
+
+	virtual void value(UInt64 v);
+		/// An unsigned 64-bit integer value is read. This will only be
+		/// triggered if the value cannot fit into a signed 64-bit integer.
+#endif
+
+	virtual void value(const std::string& s);
+		/// A string value is read.
+
+	virtual void value(double d);
+		/// A double value is read.
+
+	virtual void value(bool b);
+		/// A boolean value is read.
+
+	virtual void null();
+		/// A null value is read.
+
+private:
+	void setValue(const Poco::Dynamic::Var& value);
+	typedef std::stack<Dynamic::Var> Stack;
+
+	Stack        _stack;
+	std::string  _key;
+	Dynamic::Var _result;
+	bool         _preserveObjectOrder;
+};
+
+
+//
+// inlines
+//
+inline Dynamic::Var ParseHandler::asVar() const
+{
+	return _result;
+}
+
+
+inline void ParseHandler::value(int v)
+{
+	setValue(v);
+}
+
+
+inline void ParseHandler::value(unsigned v)
+{
+	setValue(v);
+}
+
+
+#if defined(POCO_HAVE_INT64)
+inline void ParseHandler::value(Int64 v)
+{
+	setValue(v);
+}
+
+
+inline void ParseHandler::value(UInt64 v)
+{
+	setValue(v);
+}
+#endif
+
+
+inline void ParseHandler::value(const std::string& s)
+{
+	setValue(s);
+}
+
+
+inline void ParseHandler::value(double d)
+{
+	setValue(d);
+}
+
+
+inline void ParseHandler::value(bool b)
+{
+	setValue(b);
+}
+
+
+inline void ParseHandler::null()
+{
+	Poco::Dynamic::Var empty;
+	setValue(empty);
+}
+
+
+} } // namespace Poco::JSON
+
+
+#endif // JSON_ParseHandler_INCLUDED
diff --git a/base/poco/JSON/include/Poco/JSON/Parser.h b/base/poco/JSON/include/Poco/JSON/Parser.h
new file mode 100644
index 00000000000..592ddabc320
--- /dev/null
+++ b/base/poco/JSON/include/Poco/JSON/Parser.h
@@ -0,0 +1,203 @@
+//
+// Parser.h
+//
+// Library: JSON
+// Package: JSON
+// Module:  Parser
+//
+// Definition of the Parser class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef JSON_JSONParser_INCLUDED
+#define JSON_JSONParser_INCLUDED
+
+
+#include "Poco/JSON/JSON.h"
+#include "Poco/JSON/ParserImpl.h"
+#include "Poco/JSON/Object.h"
+#include "Poco/JSON/Array.h"
+#include "Poco/JSON/ParseHandler.h"
+#include "Poco/JSON/JSONException.h"
+#include "Poco/UTF8Encoding.h"
+#include "Poco/Dynamic/Var.h"
+#include <string>
+
+
+namespace Poco {
+namespace JSON {
+
+
+class JSON_API Parser: private ParserImpl
+	/// A parser for reading RFC 4627 compliant JSON from strings or streams.
+	/// 
+	/// Simple usage example:
+	/// 
+	///    std::string json = "{ \"name\" : \"Franky\", \"children\" : [ \"Jonas\", \"Ellen\" ] }";
+	///    Parser parser;
+	///    Var result = parser.parse(json);
+	///    // ... use result (see next example)
+	///    parser.reset();
+	///    std::ostringstream ostr;
+	///    PrintHandler::Ptr pHandler = new PrintHandler(ostr);
+	///    parser.setHandler(pHandler);
+	///    parser.parse(json); // ostr.str() == json
+	/// ----
+	///
+	/// The result of parsing a valid JSON document will be either an Object
+	/// or an Array. Therefore the result of parse() is a Poco::Dynamic::Var
+	/// containing a Poco::SharedPtr to an Object or Array instance.
+	///
+	/// Example:
+	/// 
+	///    std::string json = "{ \"name\" : \"Franky\", \"children\" : [ \"Jonas\", \"Ellen\" ] }";
+	///    Parser parser;
+	///    Var result = parser.parse(json);
+	///    Object::Ptr object = result.extract<Object::Ptr>();
+	///    std::string name = object.getValue<std::string>("name");
+	///    Array::Ptr children = object.getArray("children");
+	/// ----
+{
+public:
+
+	Parser(const Handler::Ptr& pHandler = new ParseHandler, std::size_t bufSize = JSON_PARSE_BUFFER_SIZE);
+		/// Creates JSON Parser, using the given Handler and buffer size.
+
+	virtual ~Parser();
+		/// Destroys JSON Parser.
+
+	void reset();
+		/// Resets the parser.
+
+	void setAllowComments(bool comments);
+		/// Allow or disallow comments. By default, comments are not allowed.
+
+	bool getAllowComments() const;
+		/// Returns true if comments are allowed, false otherwise.
+		///
+		/// By default, comments are not allowed.
+		
+	void setAllowNullByte(bool nullByte);
+		/// Allow or disallow null byte in strings. 
+		///
+		/// By default, null byte is allowed.
+
+	bool getAllowNullByte() const;
+		/// Returns true if null byte is allowed, false otherwise.
+		///
+		/// By default, null bytes are allowed.
+
+	void setDepth(std::size_t depth);
+		/// Sets the allowed JSON depth.
+
+	std::size_t getDepth() const;
+		/// Returns the allowed JSON depth.
+
+	Dynamic::Var parse(const std::string& json);
+		/// Parses JSON from a string.
+
+	Dynamic::Var parse(std::istream& in);
+		/// Parses JSON from an input stream.
+
+	void setHandler(const Handler::Ptr& pHandler);
+		/// Set the Handler.
+
+	const Handler::Ptr& getHandler();
+		/// Returns the Handler.
+
+	Dynamic::Var asVar() const;
+		/// Returns the result of parsing;
+
+	Dynamic::Var result() const;
+		/// Returns the result of parsing as Dynamic::Var;
+
+private:
+	Parser(const Parser&);
+	Parser& operator = (const Parser&);
+};
+
+
+//
+// inlines
+//
+inline void Parser::setAllowComments(bool comments)
+{
+	setAllowCommentsImpl(comments);
+}
+
+
+inline bool Parser::getAllowComments() const
+{
+	return getAllowCommentsImpl();
+}
+
+
+inline void Parser::setAllowNullByte(bool nullByte)
+{
+	setAllowNullByteImpl(nullByte);
+}
+
+
+inline bool Parser::getAllowNullByte() const
+{
+	return getAllowNullByteImpl();
+}
+
+
+inline void Parser::setDepth(std::size_t depth)
+{
+	setDepthImpl(depth);
+}
+
+
+inline std::size_t Parser::getDepth() const
+{
+	return getDepthImpl();
+}
+
+
+inline const Handler::Ptr& Parser::getHandler()
+{
+	return getHandlerImpl();
+}
+
+
+inline Dynamic::Var Parser::result() const
+{
+	return resultImpl();
+}
+
+
+inline Dynamic::Var Parser::asVar() const
+{
+	return asVarImpl();
+}
+
+
+inline void Parser::reset()
+{
+	resetImpl();
+}
+
+
+inline Dynamic::Var Parser::parse(const std::string& json)
+{
+	return parseImpl(json);
+}
+
+
+inline Dynamic::Var Parser::parse(std::istream& in)
+{
+	return parseImpl(in);
+}
+
+
+} } // namespace Poco::JSON
+
+
+#endif // JSON_JSONParser_INCLUDED
diff --git a/base/poco/JSON/include/Poco/JSON/ParserImpl.h b/base/poco/JSON/include/Poco/JSON/ParserImpl.h
new file mode 100644
index 00000000000..dd92fe84e67
--- /dev/null
+++ b/base/poco/JSON/include/Poco/JSON/ParserImpl.h
@@ -0,0 +1,194 @@
+//
+// Parser.h
+//
+// Library: JSON
+// Package: JSON
+// Module:  ParserImpl
+//
+// Definition of the ParserImpl class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef JSON_JSONParserImpl_INCLUDED
+#define JSON_JSONParserImpl_INCLUDED
+
+
+#include "Poco/JSON/JSON.h"
+#include "Poco/JSON/Object.h"
+#include "Poco/JSON/Array.h"
+#include "Poco/JSON/ParseHandler.h"
+#include "Poco/JSON/JSONException.h"
+#include "Poco/UTF8Encoding.h"
+#include "Poco/Dynamic/Var.h"
+#include <string>
+
+
+struct json_stream;
+
+
+namespace Poco {
+namespace JSON {
+
+
+class JSON_API ParserImpl
+{
+protected:
+	static const std::size_t JSON_PARSE_BUFFER_SIZE = 4096;
+	static const std::size_t JSON_PARSER_STACK_SIZE = 128;
+	static const int         JSON_UNLIMITED_DEPTH = -1;
+
+	ParserImpl(const Handler::Ptr& pHandler = new ParseHandler, std::size_t bufSize = JSON_PARSE_BUFFER_SIZE);
+		/// Creates JSON ParserImpl, using the given Handler and buffer size.
+
+	virtual ~ParserImpl();
+		/// Destroys JSON ParserImpl.
+
+	void resetImpl();
+		/// Resets the parser.
+
+	void setAllowCommentsImpl(bool comments);
+		/// Allow or disallow comments. By default, comments are not allowed.
+
+	bool getAllowCommentsImpl() const;
+		/// Returns true if comments are allowed, false otherwise.
+		///
+		/// By default, comments are not allowed.
+
+	void setAllowNullByteImpl(bool nullByte);
+		/// Allow or disallow null byte in strings.
+		///
+		/// By default, null byte is allowed.
+
+	bool getAllowNullByteImpl() const;
+		/// Returns true if null byte is allowed, false otherwise.
+		///
+		/// By default, null bytes are allowed.
+
+	void setDepthImpl(std::size_t depth);
+		/// Sets the allowed JSON depth.
+
+	std::size_t getDepthImpl() const;
+		/// Returns the allowed JSON depth.
+
+	Dynamic::Var parseImpl(const std::string& json);
+		/// Parses JSON from a string.
+
+	Dynamic::Var parseImpl(std::istream& in);
+		/// Parses JSON from an input stream.
+
+	void setHandlerImpl(const Handler::Ptr& pHandler);
+		/// Set the Handler.
+
+	const Handler::Ptr& getHandlerImpl();
+		/// Returns the Handler.
+
+	Dynamic::Var asVarImpl() const;
+		/// Returns the result of parsing;
+
+	Dynamic::Var resultImpl() const;
+		/// Returns the result of parsing as Dynamic::Var;
+
+private:
+	ParserImpl(const ParserImpl&);
+	ParserImpl& operator =(const ParserImpl&);
+
+	void handleArray();
+	void handleObject();
+	void handle();
+	void handle(const std::string& json);
+	void stripComments(std::string& json);
+	bool checkError();
+
+	struct json_stream* _pJSON;
+	Handler::Ptr _pHandler;
+	int          _depth;
+	char         _decimalPoint;
+	bool         _allowNullByte;
+	bool         _allowComments;
+};
+
+
+//
+// inlines
+//
+
+inline void ParserImpl::resetImpl()
+{
+	// currently, json stream is opened and closed on every parse request
+	// (perhaps there is some optimization room?)
+	//json_reset(&_json);
+	if (_pHandler) _pHandler->reset();
+}
+
+
+inline void ParserImpl::setAllowCommentsImpl(bool comments)
+{
+	_allowComments = comments;
+}
+
+
+inline bool ParserImpl::getAllowCommentsImpl() const
+{
+	return _allowComments;
+}
+
+
+inline void ParserImpl::setAllowNullByteImpl(bool nullByte)
+{
+	_allowNullByte = nullByte;
+}
+
+
+inline bool ParserImpl::getAllowNullByteImpl() const
+{
+	return _allowNullByte;
+}
+
+
+inline void ParserImpl::setDepthImpl(std::size_t depth)
+{
+	_depth = static_cast<int>(depth);
+}
+
+
+inline std::size_t ParserImpl::getDepthImpl() const
+{
+	return static_cast<int>(_depth);
+}
+
+
+inline void ParserImpl::setHandlerImpl(const Handler::Ptr& pHandler)
+{
+	_pHandler = pHandler;
+}
+
+
+inline const Handler::Ptr& ParserImpl::getHandlerImpl()
+{
+	return _pHandler;
+}
+
+
+inline Dynamic::Var ParserImpl::resultImpl() const
+{
+	return asVarImpl();
+}
+
+
+inline Dynamic::Var ParserImpl::asVarImpl() const
+{
+	if (_pHandler) return _pHandler->asVar();
+
+	return Dynamic::Var();
+}
+
+
+} } // namespace Poco::JSON
+
+
+#endif // JSON_JSONParserImpl_INCLUDED
diff --git a/base/poco/JSON/include/Poco/JSON/PrintHandler.h b/base/poco/JSON/include/Poco/JSON/PrintHandler.h
new file mode 100644
index 00000000000..620dc52a9a1
--- /dev/null
+++ b/base/poco/JSON/include/Poco/JSON/PrintHandler.h
@@ -0,0 +1,139 @@
+//
+// PrintHandler.h
+//
+// Library: JSON
+// Package: JSON
+// Module:  PrintHandler
+//
+// Definition of the PrintHandler class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef JSON_PrintHandler_INCLUDED
+#define JSON_PrintHandler_INCLUDED
+
+
+#include "Poco/JSON/JSON.h"
+#include "Poco/JSON/Handler.h"
+#include "Poco/JSONString.h"
+
+
+namespace Poco {
+namespace JSON {
+
+
+class JSON_API PrintHandler: public Handler
+	/// PrintHandler formats and prints the JSON object
+	/// to either user-provided std::ostream or standard output.
+	/// If indent is zero, the output is a condensed JSON string,
+	/// otherwise, the proper indentation is applied to elements.
+{
+public:
+	typedef SharedPtr<PrintHandler> Ptr;
+
+	static const unsigned JSON_PRINT_FLAT = 0;
+
+	PrintHandler(unsigned indent = 0, int options = Poco::JSON_WRAP_STRINGS);
+		/// Creates the PrintHandler.
+
+	PrintHandler(std::ostream& out, unsigned indent = 0, int options = Poco::JSON_WRAP_STRINGS);
+		/// Creates the PrintHandler.
+
+	~PrintHandler();
+		/// Destroys the PrintHandler.
+
+	void reset();
+		/// Resets the handler state.
+
+	void startObject();
+		/// The parser has read a '{'; a new object is started.
+		/// If indent is greater than zero, a newline will be appended.
+
+	void endObject();
+		/// The parser has read a '}'; the object is closed.
+
+	void startArray();
+		/// The parser has read a [; a new array will be started.
+		/// If indent is greater than zero, a newline will be appended.
+
+	void endArray();
+		/// The parser has read a ]; the array is closed.
+
+	void key(const std::string& k);
+		/// A key of an object is read; it will be written to the output,
+		/// followed by a ':'. If indent is greater than zero, the colon
+		/// is padded by a space before and after.
+
+	void null();
+		/// A null value is read; "null" will be written to the output.
+
+	void value(int v);
+		/// An integer value is read.
+
+	void value(unsigned v);
+		/// An unsigned value is read. This will only be triggered if the
+		/// value cannot fit into a signed int.
+		
+#if defined(POCO_HAVE_INT64)
+	void value(Int64 v);
+		/// A 64-bit integer value is read; it will be written to the output.
+
+	void value(UInt64 v);
+		/// An unsigned 64-bit integer value is read; it will be written to the output.
+#endif
+
+	void value(const std::string& value);
+		/// A string value is read; it will be formatted and written to the output.
+
+	void value(double d);
+		/// A double value is read; it will be written to the output.
+
+	void value(bool b);
+		/// A boolean value is read; it will be written to the output.
+
+	void comma();
+		/// A comma is read; it will be written to the output as "true" or "false".
+
+	void setIndent(unsigned indent);
+		/// Sets indentation.
+
+private:
+	const char* endLine() const;
+	unsigned indent();
+	bool printFlat() const;
+	void arrayValue();
+	bool array() const;
+
+	std::ostream& _out;
+	unsigned      _indent;
+	std::string   _tab;
+	int           _array;
+	bool          _objStart;
+	int           _options;
+};
+
+
+//
+// inlines
+//
+inline void PrintHandler::setIndent(unsigned indent)
+{
+	_indent = indent;
+}
+
+
+inline bool PrintHandler::array() const
+{
+	return _array > 0;
+}
+
+
+} } // namespace Poco::JSON
+
+
+#endif // JSON_PrintHandler_INCLUDED
diff --git a/base/poco/JSON/include/Poco/JSON/Query.h b/base/poco/JSON/include/Poco/JSON/Query.h
new file mode 100644
index 00000000000..c639a3d7dd9
--- /dev/null
+++ b/base/poco/JSON/include/Poco/JSON/Query.h
@@ -0,0 +1,125 @@
+//
+// Query.h
+//
+// Library: JSON
+// Package: JSON
+// Module:  Query
+//
+// Definition of the Query class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef JSON_JSONQuery_INCLUDED
+#define JSON_JSONQuery_INCLUDED
+
+
+#include "Poco/JSON/JSON.h"
+#include "Poco/JSON/Object.h"
+#include "Poco/JSON/Array.h"
+
+
+namespace Poco {
+namespace JSON {
+
+
+class JSON_API Query
+	/// Class that can be used to search for a value in a JSON object or array.
+{
+public:
+	Query(const Dynamic::Var& source);
+		/// Creates a Query/
+		///
+		/// Source must be JSON Object, Array, Object::Ptr,
+		/// Array::Ptr or empty Var. Any other type will trigger throwing of 
+		/// InvalidArgumentException.
+		///
+		/// Creating Query holding Ptr will typically result in faster
+		/// performance.
+
+	virtual ~Query();
+		/// Destroys the Query.
+
+	Object::Ptr findObject(const std::string& path) const;
+		/// Search for an object. 
+		///
+		/// When the object can't be found, a zero Ptr is returned; 
+		/// otherwise, a shared pointer to internally held object
+		/// is returned.
+		/// If object (as opposed to a pointer to object) is held
+		/// internally, a shared pointer to new (heap-allocated) Object is
+		/// returned; this may be expensive operation.
+
+	Object& findObject(const std::string& path, Object& obj) const;
+		/// Search for an object. 
+		///
+		/// If object is found, it is assigned to the
+		/// Object through the reference passed in. When the object can't be 
+		/// found, the provided Object is emptied and returned.
+
+	Array::Ptr findArray(const std::string& path) const;
+		/// Search for an array. 
+		///
+		/// When the array can't be found, a zero Ptr is returned; 
+		/// otherwise, a shared pointer to internally held array
+		/// is returned.
+		/// If array (as opposed to a pointer to array) is held
+		/// internally, a shared pointer to new (heap-allocated) Object is
+		/// returned; this may be expensive operation.
+
+	Array& findArray(const std::string& path, Array& obj) const;
+		/// Search for an array. 
+		///
+		/// If array is found, it is assigned to the
+		/// Object through the reference passed in. When the array can't be 
+		/// found, the provided Object is emptied and returned.
+
+	Dynamic::Var find(const std::string& path) const;
+		/// Searches a value.
+		///
+		/// Example: "person.children[0].name" will return the
+		/// the name of the first child. When the value can't be found
+		/// an empty value is returned.
+
+	template<typename T>
+	T findValue(const std::string& path, const T& def) const
+		/// Searches for a value will convert it to the given type.
+		/// When the value can't be found or has an invalid type
+		/// the default value will be returned.
+	{
+		T result = def;
+		Dynamic::Var value = find(path);
+		if (!value.isEmpty())
+		{
+			try
+			{
+				result = value.convert<T>();
+			}
+			catch (...) 
+			{ 
+			}
+		}
+		return result;
+	}
+
+	std::string findValue(const char* path, const char* def) const
+		/// Searches for a value will convert it to the given type.
+		/// When the value can't be found or has an invalid type
+		/// the default value will be returned.
+	{
+		return findValue<std::string>(path, def);
+	}
+
+private:
+	Dynamic::Var _source;
+};
+
+
+} } // namespace Poco::JSON
+
+
+#endif // JSON_JSONQuery_INCLUDED
diff --git a/base/poco/JSON/include/Poco/JSON/Stringifier.h b/base/poco/JSON/include/Poco/JSON/Stringifier.h
new file mode 100644
index 00000000000..8e3303becff
--- /dev/null
+++ b/base/poco/JSON/include/Poco/JSON/Stringifier.h
@@ -0,0 +1,73 @@
+//
+// Stringifier.h
+//
+// Library: JSON
+// Package: JSON
+// Module:  Stringifier
+//
+// Definition of the Stringifier class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef JSON_JSONStringifier_INCLUDED
+#define JSON_JSONStringifier_INCLUDED
+
+
+#include "Poco/JSON/JSON.h"
+#include "Poco/JSONString.h"
+#include "Poco/Dynamic/Var.h"
+#include <ostream>
+
+
+namespace Poco {
+namespace JSON {
+
+
+class JSON_API Stringifier
+	/// Helper class for creating a string from a JSON object or array.
+{
+public:
+	static void condense(const Dynamic::Var& any, std::ostream& out, int options = Poco::JSON_WRAP_STRINGS);
+		/// Writes a condensed string representation of the value to the output stream while preserving
+		/// the insertion order.
+		///
+		/// If JSON_ESCAPE_UNICODE is in options, all unicode characters will be escaped, otherwise
+		/// only the compulsory ones.
+		///
+		/// This is just a "shortcut" to stringify(any, out) with name indicating the function effect.
+
+	static void stringify(const Dynamic::Var& any, std::ostream& out,
+			unsigned int indent = 0, int step = -1, int options = Poco::JSON_WRAP_STRINGS);
+		/// Writes a string representation of the value to the output stream.
+		///
+		/// When indent is 0, the string will be created as small as possible.
+		/// Indentation is increased/decreased using number of spaces defined in step.
+		/// The default value -1 for step indicates that step will be equal to the
+		/// indent size.
+		///
+		/// If JSON_ESCAPE_UNICODE is in options, all unicode characters will be escaped, otherwise
+		/// only the compulsory ones.
+
+	static void formatString(const std::string& value, std::ostream& out, int options = Poco::JSON_WRAP_STRINGS);
+		/// Formats the JSON string and streams it into ostream.
+		///
+		/// If JSON_ESCAPE_UNICODE is in options, all unicode characters will be escaped, otherwise
+		/// only the compulsory ones.
+};
+
+
+inline void Stringifier::condense(const Dynamic::Var& any, std::ostream& out, int options)
+{
+	stringify(any, out, 0, -1, options);
+}
+
+
+} } // namespace Poco::JSON
+
+
+#endif // JSON_JSONStringifier_INCLUDED
diff --git a/base/poco/JSON/include/Poco/JSON/Template.h b/base/poco/JSON/include/Poco/JSON/Template.h
new file mode 100644
index 00000000000..7e8ac51e034
--- /dev/null
+++ b/base/poco/JSON/include/Poco/JSON/Template.h
@@ -0,0 +1,151 @@
+//
+// Template.h
+//
+// Library: JSON
+// Package: JSON
+// Module:  Template
+//
+// Definition of the Template class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef JSON_JSONTemplate_INCLUDED
+#define JSON_JSONTemplate_INCLUDED
+
+
+#include "Poco/JSON/JSON.h"
+#include "Poco/Dynamic/Var.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Path.h"
+#include "Poco/Timestamp.h"
+#include <sstream>
+#include <stack>
+
+
+namespace Poco {
+namespace JSON {
+
+
+class MultiPart;
+
+
+POCO_DECLARE_EXCEPTION(JSON_API, JSONTemplateException, Poco::Exception)
+
+
+class JSON_API Template
+	/// Template is a template engine which uses JSON as input
+	/// for generating output. There are commands for
+	/// looping over JSON arrays, include other templates,
+	/// conditional output, etc.
+	///
+	/// All text is send to the outputstream. A command is placed
+	/// between 
+	///     <?
+	/// and 
+	///     ?>
+	/// ----
+	///
+	/// These are the available commands:
+	/// 
+	///     <? echo query ?>
+	/// ----
+	/// The result of the query is send to the output stream
+	/// This command can also be written as <?= query ?>
+	/// 
+	///     <? if query ?> <? else ?> <? endif ?>
+	/// ----
+	/// When the result of query is true, all the text between
+	/// if and else (or endif when there is no else) is send to the
+	/// output stream. When the result of query is false, all the text
+	/// between else and endif is send to the output stream. An empty
+	/// object, an empty array or a null value is considered as a false value.
+	/// For numbers a zero is false. An empty String is also false.
+	///
+	///     <? ifexist query ?> <? else ?> <? endif ?>
+	/// ----
+	/// This can be used to check the existence of the value.
+	/// Use this for example when a zero value is ok (which returns false for <? if ?>.
+	/// 
+	///     <? for variable query ?> <? endfor ?>
+	/// ----
+	/// The result of the query must be an array. For each element
+	/// in the array the text between for and endfor is send to the
+	/// output stream. The active element is stored in the variable.
+	///
+	///     <? include "filename" ?>
+	/// ----
+	/// Includes a template. When the filename is relative it will try
+	/// to resolve the filename against the active template. When this
+	/// file doesn't exist, it can still be found when the JSONTemplateCache
+	/// is used.
+	///
+	///  A query is passed to Poco::JSON::Query to get the value.
+{
+public:
+	typedef SharedPtr<Template> Ptr;
+
+	Template();
+		/// Creates a Template.
+
+	Template(const Path& templatePath);
+		/// Creates a Template from the file with the given templatePath.
+
+	virtual ~Template();
+		/// Destroys the Template.
+
+	void parse();
+		/// Parse a template from a file.
+
+	void parse(const std::string& source);
+		/// Parse a template from a string.
+
+	void parse(std::istream& in);
+		/// Parse a template from an input stream.
+
+	Timestamp parseTime() const;
+		/// Returns the time when the template was parsed.
+
+	void render(const Dynamic::Var& data, std::ostream& out) const;
+		/// Renders the template and send the output to the stream.
+
+private:
+	std::string readText(std::istream& in);
+	std::string readWord(std::istream& in);
+	std::string readQuery(std::istream& in);
+	std::string readTemplateCommand(std::istream& in);
+	std::string readString(std::istream& in);
+	void readWhiteSpace(std::istream& in);
+
+	MultiPart* _parts;
+	std::stack<MultiPart*> _partStack;
+	MultiPart* _currentPart;
+	Path _templatePath;
+	Timestamp _parseTime;
+};
+
+
+//
+// inlines
+//
+inline void Template::parse(const std::string& source)
+{
+	std::istringstream is(source);
+	parse(is);
+}
+
+
+inline Timestamp Template::parseTime() const
+{
+	return _parseTime;
+}
+
+
+} } // namespace Poco::JSON
+
+
+#endif // JSON_JSONTemplate_INCLUDED
diff --git a/base/poco/JSON/include/Poco/JSON/TemplateCache.h b/base/poco/JSON/include/Poco/JSON/TemplateCache.h
new file mode 100644
index 00000000000..0f5fcf095b6
--- /dev/null
+++ b/base/poco/JSON/include/Poco/JSON/TemplateCache.h
@@ -0,0 +1,105 @@
+//
+// TemplateCache.h
+//
+// Library: JSON
+// Package: JSON
+// Module:  TemplateCache
+//
+// Definition of the TemplateCache class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef JSON_JSONTemplateCache_INCLUDED
+#define JSON_JSONTemplateCache_INCLUDED
+
+
+#include "Poco/JSON/JSON.h"
+#include "Poco/JSON/Template.h"
+#include "Poco/Path.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Logger.h"
+#include <vector>
+#include <map>
+
+
+namespace Poco {
+namespace JSON {
+
+
+class JSON_API TemplateCache
+	/// Use to cache parsed templates. Templates are
+	/// stored in a map with the full path as key.
+	/// When a template file has changed, the cache
+	/// will remove the old template from the cache
+	/// and load a new one.
+{
+public:
+	TemplateCache();
+		/// Creates an empty TemplateCache.
+		///
+		/// The cache must be created and not destroyed 
+		/// as long as it is used.
+
+	virtual ~TemplateCache();
+		/// Destroys the TemplateCache.
+
+	void addPath(const Path& path);
+		/// Add a path for resolving template paths.
+		/// The order of check is FIFO.
+
+	Template::Ptr getTemplate(const Path& path);
+		/// Returns a template from the cache.
+		/// When the template file is not yet loaded
+		/// or when the file has changed, the template
+		/// will be (re)loaded and parsed. A shared pointer
+		/// is returned, so it is safe to use this template
+		/// even when the template isn't stored anymore in
+		/// the cache.
+
+	static TemplateCache* instance();
+		/// Returns the only instance of this cache.
+
+	void setLogger(Logger& logger);
+		/// Sets the logger for the cache.
+
+private:
+	void setup();
+	Path resolvePath(const Path& path) const;
+
+	static TemplateCache*                _pInstance;
+	std::vector<Path>                    _includePaths;
+	std::map<std::string, Template::Ptr> _cache;
+	Logger*                              _pLogger;
+};
+
+
+//
+// inlines
+//
+inline void TemplateCache::addPath(const Path& path)
+{
+	_includePaths.push_back(path);
+}
+
+
+inline TemplateCache* TemplateCache::instance()
+{
+	return _pInstance;
+}
+
+
+inline void TemplateCache::setLogger(Logger& logger)
+{
+	_pLogger = &logger;
+}
+
+
+} } // namespace Poco::JSON
+
+
+#endif // JSON_JSONTemplateCache_INCLUDED
diff --git a/base/poco/JSON/src/Array.cpp b/base/poco/JSON/src/Array.cpp
new file mode 100644
index 00000000000..710d0259c63
--- /dev/null
+++ b/base/poco/JSON/src/Array.cpp
@@ -0,0 +1,268 @@
+//
+// Array.cpp
+//
+// Library: JSON
+// Package: JSON
+// Module:  Array
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/JSON/Array.h"
+#include "Poco/JSON/Object.h"
+#include "Poco/JSON/Stringifier.h"
+#include "Poco/JSONString.h"
+
+
+using Poco::Dynamic::Var;
+
+
+namespace Poco {
+namespace JSON {
+
+
+Array::Array(int options): _modified(false),
+	_escapeUnicode((options & Poco::JSON_ESCAPE_UNICODE) != 0)
+{
+}
+
+
+Array::Array(const Array& other) : _values(other._values),
+	_pArray(other._pArray),
+	_modified(other._modified)
+{
+}
+
+
+Array &Array::operator=(const Array& other)
+{
+	if (&other != this)
+	{
+		_values = other._values;
+		_pArray = other._pArray;
+		_modified = other._modified;
+	}
+	return *this;
+}
+
+#ifdef POCO_ENABLE_CPP11
+
+
+Array::Array(Array&& other) :
+	_values(std::move(other._values)),
+	_pArray(!other._modified ? other._pArray : 0),
+	_modified(other._modified)
+{
+	_pArray = 0;
+}
+
+Array &Array::operator= (Array&& other)
+{
+	if (&other != this)
+	{
+		_values = std::move(other._values);
+		_pArray = other._pArray;
+		other._pArray = 0;
+		_modified = other._modified;
+	}
+	return *this;
+}
+
+
+#endif // POCO_ENABLE_CPP11
+
+
+Array::~Array()
+{
+}
+
+
+Var Array::get(unsigned int index) const
+{
+	Var value;
+	try
+	{
+		value = _values.at(index);
+	}
+	catch (std::out_of_range&)
+	{
+		//Ignore, we return an empty value
+	}
+	return value;
+}
+
+
+Array::Ptr Array::getArray(unsigned int index) const
+{
+	Array::Ptr result;
+
+	Var value = get(index);
+	if (value.type() == typeid(Array::Ptr))
+	{
+		result = value.extract<Array::Ptr>();
+	}
+	return result;
+}
+
+
+Object::Ptr Array::getObject(unsigned int index) const
+{
+	Object::Ptr result;
+
+	Var value = get(index);
+	if (value.type() == typeid(Object::Ptr))
+	{
+		result = value.extract<Object::Ptr>();
+	}
+	return result;
+}
+
+
+bool Array::isNull(unsigned int index) const
+{
+	if (index < _values.size())
+	{
+		Dynamic::Var value = _values[index];
+		return value.isEmpty();
+	}
+	return true;
+}
+
+
+bool Array::isObject(unsigned int index) const
+{
+	Var value = get(index);
+	return isObject(value);
+}
+
+
+bool Array::isObject(const Dynamic::Var& value) const
+{
+	return value.type() == typeid(Object::Ptr);
+}
+
+
+bool Array::isObject(ConstIterator& it) const
+{
+	return it!= end() && isObject(*it);
+}
+
+
+void Array::stringify(std::ostream& out, unsigned int indent, int step) const
+{
+	int options = Poco::JSON_WRAP_STRINGS;
+	options |= _escapeUnicode ? Poco::JSON_ESCAPE_UNICODE : 0;
+
+	if (step == -1) step = indent;
+
+	out << "[";
+
+	if (indent > 0) out << std::endl;
+
+	for (ValueVec::const_iterator it = _values.begin(); it != _values.end();)
+	{
+		for (int i = 0; i < indent; i++) out << ' ';
+
+		Stringifier::stringify(*it, out, indent + step, step, options);
+
+		if (++it != _values.end())
+		{
+			out << ",";
+			if (step > 0) out << '\n';
+		}
+	}
+
+	if (step > 0) out << '\n';
+
+	if (indent >= step) indent -= step;
+
+	for (int i = 0; i < indent; i++) out << ' ';
+
+	out << "]";
+}
+
+
+void Array::resetDynArray() const
+{
+	if (!_pArray)
+		_pArray = new Poco::Dynamic::Array;
+	else
+		_pArray->clear();
+}
+
+
+Array::operator const Poco::Dynamic::Array& () const
+{
+	if (!_values.size())
+	{
+		resetDynArray();
+	}
+	else if (_modified)
+	{
+		ValueVec::const_iterator it = _values.begin();
+		ValueVec::const_iterator end = _values.end();
+		resetDynArray();
+		int index = 0;
+		for (; it != end; ++it, ++index)
+		{
+			if (isObject(it))
+			{
+				_pArray->insert(_pArray->end(), Poco::JSON::Object::makeStruct(getObject(index)));
+			}
+			else if (isArray(it))
+			{
+				_pArray->insert(_pArray->end(), makeArray(getArray(index)));
+			}
+			else
+			{
+				_pArray->insert(_pArray->end(), *it);
+			}
+		}
+		_modified = false;
+	}
+
+	return *_pArray;
+}
+
+
+Poco::Dynamic::Array Array::makeArray(const JSON::Array::Ptr& arr)
+{
+	Poco::Dynamic::Array vec;
+
+	JSON::Array::ConstIterator it  = arr->begin();
+	JSON::Array::ConstIterator end = arr->end();
+	int index = 0;
+	for (; it != end; ++it, ++index)
+	{
+		if (arr->isObject(it))
+		{
+			Object::Ptr pObj = arr->getObject(index);
+			DynamicStruct str = Poco::JSON::Object::makeStruct(pObj);
+			vec.insert(vec.end(), str);
+		}
+		else if (arr->isArray(it))
+		{
+			Array::Ptr pArr = arr->getArray(index);
+			std::vector<Poco::Dynamic::Var> v = makeArray(pArr);
+			vec.insert(vec.end(), v);
+		}
+		else
+			vec.insert(vec.end(), *it);
+	}
+
+	return vec;
+}
+
+
+void Array::clear()
+{
+	_values.clear();
+	_pArray = 0;
+}
+
+
+} } // namespace Poco::JSON
diff --git a/base/poco/JSON/src/Handler.cpp b/base/poco/JSON/src/Handler.cpp
new file mode 100644
index 00000000000..e207329ad38
--- /dev/null
+++ b/base/poco/JSON/src/Handler.cpp
@@ -0,0 +1,45 @@
+//
+// Handler.cpp
+//
+// Library: JSON
+// Package: JSON
+// Module:  Handler
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/JSON/Handler.h"
+#include "Poco/JSON/Object.h"
+
+
+namespace Poco {
+namespace JSON {
+
+
+Handler::Handler()
+{
+}
+
+
+Handler::~Handler()
+{
+}
+
+
+Dynamic::Var Handler::asVar() const
+{
+	return Dynamic::Var();
+}
+
+
+Poco::DynamicStruct Handler::asStruct() const
+{
+	return Poco::DynamicStruct();
+}
+
+
+} } // namespace Poco::JSON
diff --git a/base/poco/JSON/src/JSONException.cpp b/base/poco/JSON/src/JSONException.cpp
new file mode 100644
index 00000000000..0ab2a131202
--- /dev/null
+++ b/base/poco/JSON/src/JSONException.cpp
@@ -0,0 +1,26 @@
+//
+// JSONException.cpp
+//
+// Library: JSON
+// Package: JSON
+// Module:  JSONException
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/JSON/JSONException.h"
+#include <typeinfo>
+
+
+namespace Poco {
+namespace JSON {
+
+
+POCO_IMPLEMENT_EXCEPTION(JSONException, Exception, "JSON Exception")
+
+
+} } // namespace Poco::JSON
diff --git a/base/poco/JSON/src/Object.cpp b/base/poco/JSON/src/Object.cpp
new file mode 100644
index 00000000000..7fca65c5b01
--- /dev/null
+++ b/base/poco/JSON/src/Object.cpp
@@ -0,0 +1,298 @@
+//
+// Object.cpp
+//
+// Library: JSON
+// Package: JSON
+// Module:  Object
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/JSON/Object.h"
+#include <iostream>
+#include <sstream>
+
+
+using Poco::Dynamic::Var;
+
+
+namespace Poco {
+namespace JSON {
+
+
+Object::Object(int options):
+	_preserveInsOrder((options & Poco::JSON_PRESERVE_KEY_ORDER) != 0),
+	_escapeUnicode((options & Poco::JSON_ESCAPE_UNICODE) != 0),
+	_modified(false)
+{
+}
+
+
+Object::Object(const Object& other) : _values(other._values),
+	_preserveInsOrder(other._preserveInsOrder),
+	_escapeUnicode(other._escapeUnicode),
+	_pStruct(!other._modified ? other._pStruct : 0),
+	_modified(other._modified)
+{
+	syncKeys(other._keys);
+}
+
+
+#ifdef POCO_ENABLE_CPP11
+
+
+Object::Object(Object&& other) :
+	_values(std::move(other._values)),
+	_keys(std::move(other._keys)),
+	_preserveInsOrder(other._preserveInsOrder),
+	_escapeUnicode(other._escapeUnicode),
+	_pStruct(!other._modified ? other._pStruct : 0),
+	_modified(other._modified)
+{
+	other.clear();
+}
+
+
+Object &Object::operator= (Object &&other)
+{
+	if (&other != this)
+	{
+		_values = other._values;
+		_preserveInsOrder = other._preserveInsOrder;
+		syncKeys(other._keys);
+		_escapeUnicode = other._escapeUnicode;
+		_pStruct = !other._modified ? other._pStruct : 0;
+		_modified = other._modified;
+		other.clear();
+	}
+	return *this;
+}
+
+
+#endif // POCO_ENABLE_CPP11
+
+
+Object::~Object()
+{
+}
+
+
+Object &Object::operator= (const Object &other)
+{
+	if (&other != this)
+	{
+		_values = other._values;
+		_keys = other._keys;
+		_preserveInsOrder = other._preserveInsOrder;
+		_escapeUnicode = other._escapeUnicode;
+		_pStruct = !other._modified ? other._pStruct : 0;
+		_modified = other._modified;
+	}
+	return *this;
+}
+
+
+void Object::syncKeys(const KeyList& keys)
+{
+	if(_preserveInsOrder)
+	{
+		// update iterators in _keys to point to copied _values
+		for(KeyList::const_iterator it = keys.begin(); it != keys.end(); ++it)
+		{
+			ValueMap::const_iterator itv = _values.find((*it)->first);
+			poco_assert (itv != _values.end());
+			_keys.push_back(itv);
+		}
+	}
+}
+
+
+Var Object::get(const std::string& key) const
+{
+	ValueMap::const_iterator it = _values.find(key);
+	if (it != _values.end())
+	{
+		return it->second;
+	}
+
+	return Var();
+}
+
+
+Array::Ptr Object::getArray(const std::string& key) const
+{
+	ValueMap::const_iterator it = _values.find(key);
+	if ((it != _values.end()) && (it->second.type() == typeid(Array::Ptr)))
+	{
+		return it->second.extract<Array::Ptr>();
+	}
+
+	return 0;
+}
+
+
+Object::Ptr Object::getObject(const std::string& key) const
+{
+	ValueMap::const_iterator it = _values.find(key);
+	if ((it != _values.end()) && (it->second.type() == typeid(Object::Ptr)))
+	{
+		return it->second.extract<Object::Ptr>();
+	}
+
+	return 0;
+}
+
+
+void Object::getNames(NameList& names) const
+{
+	names.clear();
+	if (_preserveInsOrder)
+	{
+		for(KeyList::const_iterator it = _keys.begin(); it != _keys.end(); ++it)
+		{
+			names.push_back((*it)->first);
+		}
+	}
+	else
+	{
+		for(ValueMap::const_iterator it = _values.begin(); it != _values.end(); ++it)
+		{
+			names.push_back(it->first);
+		}
+	}
+}
+
+
+Object::NameList Object::getNames() const
+{
+	NameList names;
+	getNames(names);
+	return names;
+}
+
+
+void Object::stringify(std::ostream& out, unsigned int indent, int step) const
+{
+	if (step < 0) step = indent;
+
+	if (!_preserveInsOrder)
+		doStringify(_values, out, indent, step);
+	else
+		doStringify(_keys, out, indent, step);
+}
+
+
+const std::string& Object::getKey(KeyList::const_iterator& iter) const
+{
+	ValueMap::const_iterator it = _values.begin();
+	ValueMap::const_iterator end = _values.end();
+	for (; it != end; ++it)
+	{
+		if (it == *iter) return it->first;
+	}
+
+	throw NotFoundException((*iter)->first);
+}
+
+
+void Object::set(const std::string& key, const Dynamic::Var& value)
+{
+	std::pair<ValueMap::iterator, bool> ret = _values.insert(ValueMap::value_type(key, value));
+	if (!ret.second) ret.first->second = value;
+	if (_preserveInsOrder)
+	{
+		KeyList::iterator it = _keys.begin();
+		KeyList::iterator end = _keys.end();
+		for (; it != end; ++it)
+		{
+			if (key == (*it)->first) return;
+		}
+		_keys.push_back(ret.first);
+	}
+	_modified = true;
+}
+
+
+Poco::DynamicStruct Object::makeStruct(const Object::Ptr& obj)
+{
+	Poco::DynamicStruct ds;
+
+	ConstIterator it  = obj->begin();
+	ConstIterator end = obj->end();
+	for (; it != end; ++it)
+	{
+		if (obj->isObject(it))
+		{
+			Object::Ptr pObj = obj->getObject(it->first);
+			DynamicStruct str = makeStruct(pObj);
+			ds.insert(it->first, str);
+		}
+		else if (obj->isArray(it))
+		{
+			Array::Ptr pArr = obj->getArray(it->first);
+			std::vector<Poco::Dynamic::Var> v = Poco::JSON::Array::makeArray(pArr);
+			ds.insert(it->first, v);
+		}
+		else
+			ds.insert(it->first, it->second);
+	}
+
+	return ds;
+}
+
+
+void Object::resetDynStruct() const
+{
+	if (!_pStruct)
+		_pStruct = new Poco::DynamicStruct;
+	else
+		_pStruct->clear();
+}
+
+
+Object::operator const Poco::DynamicStruct& () const
+{
+	if (!_values.size())
+	{
+		resetDynStruct();
+	}
+	else if (_modified)
+	{
+		ValueMap::const_iterator it = _values.begin();
+		ValueMap::const_iterator end = _values.end();
+		resetDynStruct();
+		for (; it != end; ++it)
+		{
+			if (isObject(it))
+			{
+				_pStruct->insert(it->first, makeStruct(getObject(it->first)));
+			}
+			else if (isArray(it))
+			{
+				_pStruct->insert(it->first, Poco::JSON::Array::makeArray(getArray(it->first)));
+			}
+			else
+			{
+				_pStruct->insert(it->first, it->second);
+			}
+		}
+	}
+
+	return *_pStruct;
+}
+
+
+void Object::clear()
+{
+	_values.clear();
+	_keys.clear();
+	_pStruct = 0;
+	_modified = true;
+}
+
+
+} } // namespace Poco::JSON
diff --git a/base/poco/JSON/src/ParseHandler.cpp b/base/poco/JSON/src/ParseHandler.cpp
new file mode 100644
index 00000000000..1b271ff4fac
--- /dev/null
+++ b/base/poco/JSON/src/ParseHandler.cpp
@@ -0,0 +1,148 @@
+//
+// ParseHandler.cpp
+//
+// Library: JSON
+// Package: JSON
+// Module:  ParseHandler
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/JSON/ParseHandler.h"
+#include "Poco/JSON/Object.h"
+#include "Poco/JSON/JSONException.h"
+
+
+using Poco::Dynamic::Var;
+
+
+namespace Poco {
+namespace JSON {
+
+
+ParseHandler::ParseHandler(bool preserveObjectOrder) : Handler(),
+	_preserveObjectOrder(preserveObjectOrder)
+{
+}
+
+
+ParseHandler::~ParseHandler()
+{
+}
+
+
+void ParseHandler::reset()
+{
+	while (!_stack.empty()) _stack.pop();
+	_key = "";
+	_result.empty();
+}
+
+
+void ParseHandler::startObject()
+{
+	Object::Ptr newObj = new Object(_preserveObjectOrder);
+	if (_stack.empty()) // The first object
+	{
+		_result = newObj;
+	}
+	else
+	{
+		Var parent = _stack.top();
+
+		if (parent.type() == typeid(Array::Ptr))
+		{
+			Array::Ptr arr = parent.extract<Array::Ptr>();
+			arr->add(newObj);
+		}
+		else if (parent.type() == typeid(Object::Ptr))
+		{
+			poco_assert_dbg(!_key.empty());
+			Object::Ptr obj = parent.extract<Object::Ptr>();
+			obj->set(_key, newObj);
+			_key.clear();
+		}
+	}
+
+	_stack.push(newObj);
+}
+
+
+void ParseHandler::endObject()
+{
+	if (!_stack.empty()) _stack.pop();
+}
+
+
+void ParseHandler::startArray()
+{
+	Array::Ptr newArr = new Array();
+
+	if (_stack.empty()) // The first array
+	{
+		_result = newArr;
+	}
+	else
+	{
+		Var parent = _stack.top();
+
+		if (parent.type() == typeid(Array::Ptr))
+		{
+			Array::Ptr arr = parent.extract<Array::Ptr>();
+			arr->add(newArr);
+		}
+		else if (parent.type() == typeid(Object::Ptr))
+		{
+			poco_assert_dbg(!_key.empty());
+			Object::Ptr obj = parent.extract<Object::Ptr>();
+			obj->set(_key, newArr);
+			_key.clear();
+		}
+	}
+
+	_stack.push(newArr);
+}
+
+
+void ParseHandler::endArray()
+{
+	if (!_stack.empty()) _stack.pop();
+}
+
+
+void ParseHandler::key(const std::string& k)
+{
+	_key = k;
+}
+
+
+void ParseHandler::setValue(const Var& value)
+{
+	if (_stack.size())
+	{
+		Var parent = _stack.top();
+
+		if (parent.type() == typeid(Array::Ptr))
+		{
+			Array::Ptr arr = parent.extract<Array::Ptr>();
+			arr->add(value);
+		}
+		else if (parent.type() == typeid(Object::Ptr))
+		{
+			Object::Ptr obj = parent.extract<Object::Ptr>();
+			obj->set(_key, value);
+			_key.clear();
+		}
+	}
+	else
+	{
+		throw JSONException("Attempt to set value on an empty stack");
+	}
+}
+
+
+} } // namespace Poco::JSON
diff --git a/base/poco/JSON/src/Parser.cpp b/base/poco/JSON/src/Parser.cpp
new file mode 100644
index 00000000000..368a3a5d696
--- /dev/null
+++ b/base/poco/JSON/src/Parser.cpp
@@ -0,0 +1,49 @@
+//
+// Parser.cpp
+//
+// Library: JSON
+// Package: JSON
+// Module:  Parser
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/JSON/Parser.h"
+#include "Poco/JSON/JSONException.h"
+#include "Poco/Ascii.h"
+#include "Poco/Token.h"
+#include "Poco/UTF8Encoding.h"
+#include "Poco/String.h"
+#undef min
+#undef max
+#include <limits>
+#include <clocale>
+#include <istream>
+
+
+namespace Poco {
+namespace JSON {
+
+
+Parser::Parser(const Handler::Ptr& pHandler, std::size_t bufSize):
+	ParserImpl(pHandler, bufSize)
+{
+}
+
+
+Parser::~Parser()
+{
+}
+
+
+void Parser::setHandler(const Handler::Ptr& pHandler)
+{
+	setHandlerImpl(pHandler);
+}
+
+
+} } // namespace Poco::JSON
diff --git a/base/poco/JSON/src/ParserImpl.cpp b/base/poco/JSON/src/ParserImpl.cpp
new file mode 100644
index 00000000000..a13c4359af3
--- /dev/null
+++ b/base/poco/JSON/src/ParserImpl.cpp
@@ -0,0 +1,241 @@
+//
+// Parser.cpp
+//
+// Library: JSON
+// Package: JSON
+// Module:  Parser
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/JSON/Parser.h"
+#include "Poco/JSON/JSONException.h"
+#include "Poco/Ascii.h"
+#include "Poco/Token.h"
+#include "Poco/UTF8Encoding.h"
+#include "Poco/String.h"
+#include "Poco/StreamCopier.h"
+#undef min
+#undef max
+#include <limits>
+#include <clocale>
+#include <istream>
+#include "pdjson.h"
+
+
+typedef struct json_stream json_stream;
+
+
+namespace Poco {
+namespace JSON {
+
+
+ParserImpl::ParserImpl(const Handler::Ptr& pHandler, std::size_t bufSize):
+	_pJSON(new json_stream),
+	_pHandler(pHandler),
+	_depth(JSON_UNLIMITED_DEPTH),
+	_decimalPoint('.'),
+	_allowNullByte(true),
+	_allowComments(false)
+{
+}
+
+
+ParserImpl::~ParserImpl()
+{
+	delete _pJSON;
+}
+
+
+void ParserImpl::handle(const std::string& json)
+{
+	if (!_allowNullByte && json.find("\\u0000") != json.npos)
+		throw JSONException("Null bytes in strings not allowed.");
+
+	try
+	{
+		json_open_buffer(_pJSON, json.data(), json.size());
+		checkError();
+		//////////////////////////////////
+		// Underlying parser is capable of parsing multiple consecutive JSONs;
+		// we do not currently support this feature; to force error on
+		// excessive characters past valid JSON end, this MUST be called
+		// AFTER opening the buffer - otherwise it is overwritten by
+		// json_open*() call, which calls internal init()
+		json_set_streaming(_pJSON, false);
+		/////////////////////////////////
+		handle(); checkError();
+		if (JSON_DONE != json_next(_pJSON))
+			throw JSONException("Excess characters found after JSON end.");
+		json_close(_pJSON);
+	}
+	catch (std::exception&)
+	{
+		json_close(_pJSON);
+		throw;
+	}
+}
+
+
+Dynamic::Var ParserImpl::parseImpl(const std::string& json)
+{
+	if (_allowComments)
+	{
+		std::string str = json;
+		stripComments(str);
+		handle(str);
+	}
+	else handle(json);
+
+	return asVarImpl();
+}
+
+
+Dynamic::Var ParserImpl::parseImpl(std::istream& in)
+{
+	std::ostringstream os;
+	StreamCopier::copyStream(in, os);
+	return parseImpl(os.str());
+}
+
+
+void ParserImpl::stripComments(std::string& json)
+{
+	if (_allowComments)
+	{
+		bool inString = false;
+		bool inComment = false;
+		char prevChar = 0;
+		std::string::iterator it = json.begin();
+		for (; it != json.end();)
+		{
+			if (*it == '"' && !inString) inString = true;
+			else inString = false;
+			if (!inString)
+			{
+				if (*it == '/' && it + 1 != json.end() && *(it + 1) == '*')
+					inComment = true;
+			}
+			if (inComment)
+			{
+				char c = *it;
+				it = json.erase(it);
+				if (prevChar == '*' && c == '/')
+				{
+					inComment = false;
+					prevChar = 0;
+				}
+				else prevChar = c;
+			}
+			else ++it;
+		}
+	}
+}
+
+
+void ParserImpl::handleArray()
+{
+	json_type tok = json_peek(_pJSON);
+	while (tok != JSON_ARRAY_END && checkError())
+	{
+		handle();
+		tok = json_peek(_pJSON);
+	}
+
+	if (tok == JSON_ARRAY_END) handle();
+	else throw JSONException("JSON array end not found");
+}
+
+
+void ParserImpl::handleObject()
+{
+	json_type tok = json_peek(_pJSON);
+	while (tok != JSON_OBJECT_END && checkError())
+	{
+		json_next(_pJSON);
+		if (_pHandler) _pHandler->key(std::string(json_get_string(_pJSON, NULL)));
+		handle();
+		tok = json_peek(_pJSON);
+	}
+
+	if (tok == JSON_OBJECT_END) handle();
+	else throw JSONException("JSON object end not found");
+}
+
+
+void ParserImpl::handle()
+{
+	enum json_type type = json_next(_pJSON);
+	switch (type)
+	{
+		case JSON_DONE:
+			return;
+		case JSON_NULL:
+			_pHandler->null();
+			break;
+		case JSON_TRUE:
+			if (_pHandler) _pHandler->value(true);
+			break;
+		case JSON_FALSE:
+			if (_pHandler) _pHandler->value(false);
+			break;
+		case JSON_NUMBER:
+		{
+			if (_pHandler)
+			{
+				std::string str(json_get_string(_pJSON, NULL));
+				if (str.find(_decimalPoint) != str.npos || str.find('e') != str.npos || str.find('E') != str.npos)
+				{
+					_pHandler->value(NumberParser::parseFloat(str));
+				}
+				else
+				{
+					Poco::Int64 val;
+					if (NumberParser::tryParse64(str, val))
+						_pHandler->value(val);
+					else
+						_pHandler->value(NumberParser::parseUnsigned64(str));
+				}
+			}
+			break;
+		}
+		case JSON_STRING:
+			if (_pHandler) _pHandler->value(std::string(json_get_string(_pJSON, NULL)));
+			break;
+		case JSON_OBJECT:
+			if (_pHandler) _pHandler->startObject();
+			handleObject();
+			break;
+		case JSON_OBJECT_END:
+			if (_pHandler) _pHandler->endObject();
+			return;
+		case JSON_ARRAY:
+			if (_pHandler) _pHandler->startArray();
+			handleArray();
+			break;
+		case JSON_ARRAY_END:
+			if (_pHandler) _pHandler->endArray();
+			return;
+		case JSON_ERROR:
+		{
+			const char* pErr = json_get_error(_pJSON);
+			std::string err(pErr ? pErr : "JSON parser error.");
+			throw JSONException(err);
+		}
+	}
+}
+
+
+bool ParserImpl::checkError()
+{
+	const char* err = json_get_error(_pJSON);
+	if (err) throw Poco::JSON::JSONException(err);
+	return true;
+}
+
+
+} } // namespace Poco::JSON
diff --git a/base/poco/JSON/src/PrintHandler.cpp b/base/poco/JSON/src/PrintHandler.cpp
new file mode 100644
index 00000000000..bf735d0869c
--- /dev/null
+++ b/base/poco/JSON/src/PrintHandler.cpp
@@ -0,0 +1,215 @@
+//
+// PrintHandler.cpp
+//
+// Library: JSON
+// Package: JSON
+// Module:  PrintHandler
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/JSON/PrintHandler.h"
+#include "Poco/JSON/Stringifier.h"
+#include <iostream>
+
+
+namespace Poco {
+namespace JSON {
+
+
+PrintHandler::PrintHandler(unsigned indent, int options):
+	_out(std::cout),
+	_indent(indent),
+	_array(0),
+	_objStart(true),
+	_options(options)
+{
+}
+
+
+PrintHandler::PrintHandler(std::ostream& out, unsigned indent, int options):
+	_out(out),
+	_indent(indent),
+	_array(0),
+	_objStart(true),
+	_options(options)
+{
+}
+
+
+PrintHandler::~PrintHandler()
+{
+}
+
+
+void PrintHandler::reset()
+{
+	_out.flush();
+	_tab = "";
+	_array = 0;
+	_objStart = true;
+}
+
+
+const char* PrintHandler::endLine() const
+{
+	if (!printFlat()) return "\n";
+	else return "";
+}
+
+
+bool PrintHandler::printFlat() const
+{
+	return _indent == JSON_PRINT_FLAT;
+}
+
+
+unsigned PrintHandler::indent()
+{
+	if (!printFlat()) return _indent;
+	
+	return 0;
+}
+
+
+void PrintHandler::startObject()
+{
+	arrayValue();
+	_out << '{';
+	_out << endLine();
+	_tab.append(indent(), ' ');
+	_objStart = true;
+}
+
+
+void PrintHandler::endObject()
+{
+	if (_tab.length() >= indent())
+		_tab.erase(_tab.length() - indent());
+
+	_out << endLine() << _tab << '}';
+	_objStart = false;
+}
+
+
+void PrintHandler::startArray()
+{
+	arrayValue();
+	_out << '[' << endLine();
+	_tab.append(indent(), ' ');
+	++_array;
+	_objStart = true;
+}
+
+
+void PrintHandler::endArray()
+{
+	_tab.erase(_tab.length() - indent());
+	_out << endLine() << _tab << ']';
+	--_array;
+	poco_assert (_array >= 0);
+	_objStart = false;
+}
+
+
+void PrintHandler::key(const std::string& k)
+{
+	if (!_objStart) comma();
+	
+	_objStart = true;
+		
+	_out << _tab;
+	Stringifier::formatString(k, _out, _options);
+	if (!printFlat()) _out << ' ';
+	_out << ':';
+	if (!printFlat()) _out << ' ';
+}
+
+
+void PrintHandler::null()
+{
+	arrayValue();
+	_out << "null";
+	_objStart = false;
+}
+
+
+void PrintHandler::value(int v)
+{
+	arrayValue();
+	_out << v;
+	_objStart = false;
+}
+
+
+void PrintHandler::value(unsigned v)
+{
+	arrayValue();
+	_out << v;
+	_objStart = false;
+}
+
+
+#if defined(POCO_HAVE_INT64)
+void PrintHandler::value(Int64 v)
+{
+	arrayValue();
+	_out << v;
+	_objStart = false;
+}
+
+
+void PrintHandler::value(UInt64 v)
+{
+	arrayValue();
+	_out << v;
+	_objStart = false;
+}
+#endif
+
+
+void PrintHandler::value(const std::string& value)
+{
+	arrayValue();
+	Stringifier::formatString(value, _out, _options);
+	_objStart = false;
+}
+
+
+void PrintHandler::value(double d)
+{
+	arrayValue();
+	_out << d;
+	_objStart = false;
+}
+
+
+void PrintHandler::value(bool b)
+{
+	arrayValue();
+	_out << b;
+	_objStart = false;
+}
+
+
+void PrintHandler::comma()
+{
+	_out << ',' << endLine();
+}
+
+
+void PrintHandler::arrayValue()
+{
+	if (!_objStart) comma();
+	if (array()) 
+	{
+		_out << _tab;
+	}
+}
+
+
+} } // namespace Poco::JSON
diff --git a/base/poco/JSON/src/Query.cpp b/base/poco/JSON/src/Query.cpp
new file mode 100644
index 00000000000..45047a6a050
--- /dev/null
+++ b/base/poco/JSON/src/Query.cpp
@@ -0,0 +1,172 @@
+//
+// Query.cpp
+//
+// Library: JSON
+// Package: JSON
+// Module:  Query
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/JSON/Query.h"
+#include "Poco/StringTokenizer.h"
+#include "Poco/RegularExpression.h"
+#include "Poco/NumberParser.h"
+#include <sstream>
+
+
+using Poco::Dynamic::Var;
+
+
+namespace Poco {
+namespace JSON {
+
+
+Query::Query(const Var& source): _source(source)
+{
+	if (!source.isEmpty() &&
+		source.type() != typeid(Object) &&
+		source.type() != typeid(Object::Ptr) &&
+		source.type() != typeid(Array) &&
+		source.type() != typeid(Array::Ptr))
+		throw InvalidArgumentException("Only JSON Object, Array or pointers thereof allowed.");
+}
+
+
+Query::~Query()
+{
+}
+
+
+Object::Ptr Query::findObject(const std::string& path) const
+{
+	Var result = find(path);
+
+	if (result.type() == typeid(Object::Ptr))
+		return result.extract<Object::Ptr>();
+	else if (result.type() == typeid(Object))
+		return new Object(result.extract<Object>());
+
+	return 0;
+}
+
+
+Object& Query::findObject(const std::string& path, Object& obj) const
+{
+	obj.clear();
+
+	Var result = find(path);
+
+	if (result.type() == typeid(Object::Ptr))
+		obj = *result.extract<Object::Ptr>();
+	else if (result.type() == typeid(Object))
+		obj = result.extract<Object>();
+	
+	return obj;
+}
+
+
+Array::Ptr Query::findArray(const std::string& path) const
+{
+	Var result = find(path);
+
+	if (result.type() == typeid(Array::Ptr))
+		return result.extract<Array::Ptr>();
+	else if (result.type() == typeid(Array))
+		return new Array(result.extract<Array>());
+
+	return 0;
+}
+
+
+Array& Query::findArray(const std::string& path, Array& arr) const
+{
+	arr.clear();
+
+	Var result = find(path);
+
+	if (result.type() == typeid(Array::Ptr))
+		arr = *result.extract<Array::Ptr>();
+	else if (result.type() == typeid(Array))
+		arr = result.extract<Array>();
+	
+	return arr;
+}
+
+
+Var Query::find(const std::string& path) const
+{
+	Var result = _source;
+	StringTokenizer tokenizer(path, ".");
+	for (StringTokenizer::Iterator token = tokenizer.begin(); token != tokenizer.end(); token++)
+	{
+		if (!result.isEmpty())
+		{
+			std::vector<int> indexes;
+			RegularExpression::MatchVec matches;
+			int firstOffset = -1;
+			int offset = 0;
+			RegularExpression regex("\\[([0-9]+)\\]");
+			while (regex.match(*token, offset, matches) > 0)
+			{
+				if (firstOffset == -1)
+				{
+					firstOffset = static_cast<int>(matches[0].offset);
+				}
+				std::string num = token->substr(matches[1].offset, matches[1].length);
+				indexes.push_back(NumberParser::parse(num));
+				offset = static_cast<int>(matches[0].offset + matches[0].length);
+			}
+
+			std::string name(*token);
+			if (firstOffset != -1)
+			{
+				name = name.substr(0, firstOffset);
+			}
+
+			if (name.length() > 0)
+			{
+				if (result.type() == typeid(Object::Ptr))
+				{
+					Object::Ptr o = result.extract<Object::Ptr>();
+					result = o->get(name);
+				}
+				else if (result.type() == typeid(Object))
+				{
+					Object o = result.extract<Object>();
+					result = o.get(name);
+				}
+				else
+					result.empty();
+
+			}
+
+			if (!result.isEmpty() && !indexes.empty())
+			{
+				for (std::vector<int>::iterator it = indexes.begin(); it != indexes.end(); ++it)
+				{
+					if (result.type() == typeid(Array::Ptr))
+					{
+						Array::Ptr array = result.extract<Array::Ptr>();
+						result = array->get(*it);
+						if (result.isEmpty()) break;
+					}
+					else if (result.type() == typeid(Array))
+					{
+						Array array = result.extract<Array>();
+						result = array.get(*it);
+						if (result.isEmpty()) break;
+					}
+				}
+			}
+		}
+	}
+	return result;
+}
+
+
+} } // namespace Poco::JSON
diff --git a/base/poco/JSON/src/Stringifier.cpp b/base/poco/JSON/src/Stringifier.cpp
new file mode 100644
index 00000000000..633ddf67533
--- /dev/null
+++ b/base/poco/JSON/src/Stringifier.cpp
@@ -0,0 +1,86 @@
+//
+// Stringifier.cpp
+//
+// Library: JSON
+// Package: JSON
+// Module:  Stringifier
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/JSON/Stringifier.h"
+#include "Poco/JSON/Array.h"
+#include "Poco/JSON/Object.h"
+#include <iomanip>
+
+
+using Poco::Dynamic::Var;
+
+
+namespace Poco {
+namespace JSON {
+
+
+void Stringifier::stringify(const Var& any, std::ostream& out, unsigned int indent, int step, int options)
+{
+	bool escapeUnicode = ((options & Poco::JSON_ESCAPE_UNICODE) != 0);
+
+	if (step == -1) step = indent;
+
+	if (any.type() == typeid(Object))
+	{
+		Object& o = const_cast<Object&>(any.extract<Object>());
+		o.setEscapeUnicode(escapeUnicode);
+		o.stringify(out, indent == 0 ? 0 : indent, step);
+	}
+	else if (any.type() == typeid(Array))
+	{
+		Array& a = const_cast<Array&>(any.extract<Array>());
+		a.setEscapeUnicode(escapeUnicode);
+		a.stringify(out, indent == 0 ? 0 : indent, step);
+	}
+	else if (any.type() == typeid(Object::Ptr))
+	{
+		Object::Ptr& o = const_cast<Object::Ptr&>(any.extract<Object::Ptr>());
+		o->setEscapeUnicode(escapeUnicode);
+		o->stringify(out, indent == 0 ? 0 : indent, step);
+	}
+	else if (any.type() == typeid(Array::Ptr))
+	{
+		Array::Ptr& a = const_cast<Array::Ptr&>(any.extract<Array::Ptr>());
+		a->setEscapeUnicode(escapeUnicode);
+		a->stringify(out, indent == 0 ? 0 : indent, step);
+	}
+	else if (any.isEmpty())
+	{
+		out << "null";
+	}
+	else if (any.isNumeric() || any.isBoolean())
+	{
+		std::string value = any.convert<std::string>();
+		if (any.type() == typeid(char)) formatString(value, out, options);
+		else out << value;
+	}
+	else if (any.isString() || any.isDateTime() || any.isDate() || any.isTime())
+	{
+		std::string value = any.convert<std::string>();
+		formatString(value, out, options);
+	}
+	else
+	{
+		out << any.convert<std::string>();
+	}
+}
+
+
+void Stringifier::formatString(const std::string& value, std::ostream& out, int options)
+{
+	Poco::toJSON(value, out, options);
+}
+
+
+} }  // namespace Poco::JSON
diff --git a/base/poco/JSON/src/Template.cpp b/base/poco/JSON/src/Template.cpp
new file mode 100644
index 00000000000..c546302e8ba
--- /dev/null
+++ b/base/poco/JSON/src/Template.cpp
@@ -0,0 +1,701 @@
+//
+// Template.cpp
+//
+// Library: JSON
+// Package: JSON
+// Module:  Template
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/JSON/Template.h"
+#include "Poco/JSON/TemplateCache.h"
+#include "Poco/JSON/Query.h"
+#include "Poco/File.h"
+#include "Poco/FileStream.h"
+
+
+using Poco::Dynamic::Var;
+
+
+namespace Poco {
+namespace JSON {
+
+
+POCO_IMPLEMENT_EXCEPTION(JSONTemplateException, Exception, "Template Exception")
+
+
+class Part
+{
+public:
+	Part()
+	{
+	}
+
+	virtual ~Part()
+	{
+	}
+
+	virtual void render(const Var& data, std::ostream& out) const = 0;
+
+	typedef std::vector<SharedPtr<Part> > VectorParts;
+};
+
+
+class StringPart: public Part
+{
+public:
+	StringPart(): Part()
+	{
+	}
+
+	StringPart(const std::string& content): Part(), _content(content)
+	{
+	}
+
+	virtual ~StringPart()
+	{
+	}
+
+	void render(const Var& data, std::ostream& out) const
+	{
+		out << _content;
+	}
+
+	void setContent(const std::string& content)
+	{
+		_content = content;
+	}
+
+	inline std::string getContent() const
+	{
+		return _content;
+	}
+
+private:
+	std::string _content;
+};
+
+
+class MultiPart: public Part
+{
+public:
+	MultiPart()
+	{
+	}
+
+	virtual ~MultiPart()
+	{
+	}
+
+	virtual void addPart(Part* part)
+	{
+		_parts.push_back(part);
+	}
+
+	void render(const Var& data, std::ostream& out) const
+	{
+		for (VectorParts::const_iterator it = _parts.begin(); it != _parts.end(); ++it)
+		{
+			(*it)->render(data, out);
+		}
+	}
+
+protected:
+	VectorParts _parts;
+};
+
+
+class EchoPart: public Part
+{
+public:
+	EchoPart(const std::string& query): Part(), _query(query)
+	{
+	}
+
+	virtual ~EchoPart()
+	{
+	}
+
+	void render(const Var& data, std::ostream& out) const
+	{
+		Query query(data);
+		Var value = query.find(_query);
+
+		if (!value.isEmpty())
+		{
+			out << value.convert<std::string>();
+		}
+	}
+
+private:
+	std::string _query;
+};
+
+
+class LogicQuery
+{
+public:
+	LogicQuery(const std::string& query): _queryString(query)
+	{
+	}
+
+	virtual ~LogicQuery()
+	{
+	}
+
+	virtual bool apply(const Var& data) const
+	{
+		bool logic = false;
+
+		Query query(data);
+		Var value = query.find(_queryString);
+
+		if (!value.isEmpty()) // When empty, logic will be false
+		{
+			if (value.isString())
+				// An empty string must result in false, otherwise true
+				// Which is not the case when we convert to bool with Var
+			{
+				std::string s = value.convert<std::string>();
+				logic = !s.empty();
+			}
+			else
+			{
+				// All other values, try to convert to bool
+				// An empty object or array will turn into false
+				// all other values depend on the convert<> in Var
+				logic = value.convert<bool>();
+			}
+		}
+
+		return logic;
+	}
+
+protected:
+	std::string _queryString;
+};
+
+
+class LogicExistQuery: public LogicQuery
+{
+public:
+	LogicExistQuery(const std::string& query): LogicQuery(query)
+	{
+	}
+
+	virtual ~LogicExistQuery()
+	{
+	}
+
+	virtual bool apply(const Var& data) const
+	{
+		Query query(data);
+		Var value = query.find(_queryString);
+
+		return !value.isEmpty();
+	}
+};
+
+
+class LogicElseQuery: public LogicQuery
+{
+public:
+	LogicElseQuery(): LogicQuery("")
+	{
+	}
+
+	virtual ~LogicElseQuery()
+	{
+	}
+
+	virtual bool apply(const Var& data) const
+	{
+		return true;
+	}
+};
+
+
+class LogicPart: public MultiPart
+{
+public:
+	LogicPart(): MultiPart()
+	{
+	}
+
+	virtual ~LogicPart()
+	{
+	}
+
+	void addPart(LogicQuery* query, Part* part)
+	{
+		MultiPart::addPart(part);
+		_queries.push_back(query);
+	}
+
+	void addPart(Part* part)
+	{
+		MultiPart::addPart(part);
+		_queries.push_back(new LogicElseQuery());
+	}
+
+	void render(const Var& data, std::ostream& out) const
+	{
+		int count = 0;
+		for (std::vector<SharedPtr<LogicQuery> >::const_iterator it = _queries.begin(); it != _queries.end(); ++it, ++count)
+		{
+			if ((*it)->apply(data) && _parts.size() > count)
+			{
+				_parts[count]->render(data, out);
+				break;
+			}
+		}
+	}
+
+private:
+	std::vector<SharedPtr<LogicQuery> > _queries;
+};
+
+
+class LoopPart: public MultiPart
+{
+public:
+	LoopPart(const std::string& name, const std::string& query): MultiPart(), _name(name), _query(query)
+	{
+	}
+
+	virtual ~LoopPart()
+	{
+	}
+
+	void render(const Var& data, std::ostream& out) const
+	{
+		Query query(data);
+
+		if (data.type() == typeid(Object::Ptr))
+		{
+			Object::Ptr dataObject = data.extract<Object::Ptr>();
+			Array::Ptr array = query.findArray(_query);
+			if (!array.isNull())
+			{
+				for (int i = 0; i < array->size(); i++)
+				{
+					Var value = array->get(i);
+					dataObject->set(_name, value);
+					MultiPart::render(data, out);
+				}
+				dataObject->remove(_name);
+			}
+		}
+	}
+
+private:
+	std::string _name;
+	std::string _query;
+};
+
+
+class IncludePart: public Part
+{
+public:
+
+	IncludePart(const Path& parentPath, const Path& path): 
+		Part(), 
+		_path(path)
+	{
+		// When the path is relative, try to make it absolute based
+		// on the path of the parent template. When the file doesn't
+		// exist, we keep it relative and hope that the cache can
+		// resolve it.
+		if (_path.isRelative())
+		{
+			Path templatePath(parentPath, _path);
+			File templateFile(templatePath);
+			if (templateFile.exists())
+			{
+				_path = templatePath;
+			}
+		}
+	}
+
+	virtual ~IncludePart()
+	{
+	}
+
+	void render(const Var& data, std::ostream& out) const
+	{
+		TemplateCache* cache = TemplateCache::instance();
+		if (cache == 0)
+		{
+			Template tpl(_path);
+			tpl.parse();
+			tpl.render(data, out);
+		}
+		else
+		{
+			Template::Ptr tpl = cache->getTemplate(_path);
+			tpl->render(data, out);
+		}
+	}
+
+private:
+	Path _path;
+};
+
+
+Template::Template(const Path& templatePath): 
+	_parts(0), 
+	_currentPart(0), 
+	_templatePath(templatePath)
+{
+}
+
+
+Template::Template():
+	_parts(0), 
+	_currentPart(0)
+{
+}
+
+
+Template::~Template()
+{
+	delete _parts;
+}
+
+
+void Template::parse()
+{
+	File file(_templatePath);
+	if (file.exists())
+	{
+		FileInputStream fis(_templatePath.toString());
+		parse(fis);
+	}
+}
+
+
+void Template::parse(std::istream& in)
+{
+	_parseTime.update();
+
+	_parts = new MultiPart;
+	_currentPart = _parts;
+
+	while (in.good())
+	{
+		std::string text = readText(in); // Try to read text first
+		if (text.length() > 0)
+		{
+			_currentPart->addPart(new StringPart(text));
+		}
+
+		if (in.bad())
+			break; // Nothing to do anymore
+
+		std::string command = readTemplateCommand(in);  // Try to read a template command
+		if (command.empty())
+		{
+			break;
+		}
+
+		readWhiteSpace(in);
+
+		if (command.compare("echo") == 0)
+		{
+			std::string query = readQuery(in);
+			if (query.empty())
+			{
+				throw JSONTemplateException("Missing query in <? echo ?>");
+			}
+			_currentPart->addPart(new EchoPart(query));
+		}
+		else if (command.compare("for") == 0)
+		{
+			std::string loopVariable = readWord(in);
+			if (loopVariable.empty())
+			{
+				throw JSONTemplateException("Missing variable in <? for ?> command");
+			}
+			readWhiteSpace(in);
+
+			std::string query = readQuery(in);
+			if (query.empty())
+			{
+				throw JSONTemplateException("Missing query in <? for ?> command");
+			}
+
+			_partStack.push(_currentPart);
+			LoopPart* part = new LoopPart(loopVariable, query);
+			_partStack.push(part);
+			_currentPart->addPart(part);
+			_currentPart = part;
+		}
+		else if (command.compare("else") == 0)
+		{
+			if (_partStack.size() == 0)
+			{
+				throw JSONTemplateException("Unexpected <? else ?> found");
+			}
+			_currentPart = _partStack.top();
+			LogicPart* lp = dynamic_cast<LogicPart*>(_currentPart);
+			if (lp == 0)
+			{
+				throw JSONTemplateException("Missing <? if ?> or <? ifexist ?> for <? else ?>");
+			}
+			MultiPart* part = new MultiPart();
+			lp->addPart(part);
+			_currentPart = part;
+		}
+		else if (command.compare("elsif") == 0 || command.compare("elif") == 0)
+		{
+			std::string query = readQuery(in);
+			if (query.empty())
+			{
+				throw JSONTemplateException("Missing query in <? " + command + " ?>");
+			}
+
+			if (_partStack.size() == 0)
+			{
+				throw JSONTemplateException("Unexpected <? elsif / elif ?> found");
+			}
+
+			_currentPart = _partStack.top();
+			LogicPart* lp = dynamic_cast<LogicPart*>(_currentPart);
+			if (lp == 0)
+			{
+				throw JSONTemplateException("Missing <? if ?> or <? ifexist ?> for <? elsif / elif ?>");
+			}
+			MultiPart* part = new MultiPart();
+			lp->addPart(new LogicQuery(query), part);
+			_currentPart = part;
+		}
+		else if (command.compare("endfor") == 0)
+		{
+			if (_partStack.size() < 2)
+			{
+				throw JSONTemplateException("Unexpected <? endfor ?> found");
+			}
+			MultiPart* loopPart = _partStack.top();
+			LoopPart* lp = dynamic_cast<LoopPart*>(loopPart);
+			if (lp == 0)
+			{
+				throw JSONTemplateException("Missing <? for ?> command");
+			}
+			_partStack.pop();
+			_currentPart = _partStack.top();
+			_partStack.pop();
+		}
+		else if (command.compare("endif") == 0)
+		{
+			if (_partStack.size() < 2)
+			{
+				throw JSONTemplateException("Unexpected <? endif ?> found");
+			}
+
+			_currentPart = _partStack.top();
+			LogicPart* lp = dynamic_cast<LogicPart*>(_currentPart);
+			if (lp == 0)
+			{
+				throw JSONTemplateException("Missing <? if ?> or <? ifexist ?> for <? endif ?>");
+			}
+
+			_partStack.pop();
+			_currentPart = _partStack.top();
+			_partStack.pop();
+		}
+		else if (command.compare("if") == 0 || command.compare("ifexist") == 0)
+		{
+			std::string query = readQuery(in);
+			if (query.empty())
+			{
+				throw JSONTemplateException("Missing query in <? " + command + " ?>");
+			}
+			_partStack.push(_currentPart);
+			LogicPart* lp = new LogicPart();
+			_partStack.push(lp);
+			_currentPart->addPart(lp);
+			_currentPart = new MultiPart();
+			if (command.compare("ifexist") == 0)
+			{
+				lp->addPart(new LogicExistQuery(query), _currentPart);
+			}
+			else
+			{
+				lp->addPart(new LogicQuery(query), _currentPart);
+			}
+		}
+		else if (command.compare("include") == 0)
+		{
+			readWhiteSpace(in);
+			std::string filename = readString(in);
+			if (filename.empty())
+			{
+				throw JSONTemplateException("Missing filename in <? include ?>");
+			}
+			else
+			{
+				Path resolvePath(_templatePath);
+				resolvePath.makeParent();
+				_currentPart->addPart(new IncludePart(resolvePath, filename));
+			}
+		}
+		else
+		{
+			throw JSONTemplateException("Unknown command " + command);
+		}
+
+		readWhiteSpace(in);
+
+		int c = in.get();
+		if (c == '?' && in.peek() == '>')
+		{
+			in.get(); // forget '>'
+
+			if (command.compare("echo") != 0)
+			{
+				if (in.peek() == '\r')
+				{
+					in.get();
+				}
+				if (in.peek() == '\n')
+				{
+					in.get();
+				}
+			}
+		}
+		else
+		{
+			throw JSONTemplateException("Missing ?>");
+		}
+	}
+}
+
+
+std::string Template::readText(std::istream& in)
+{
+	std::string text;
+	int c = in.get();
+	while (c != -1)
+	{
+		if (c == '<')
+		{
+			if (in.peek() == '?')
+			{
+				in.get(); // forget '?'
+				break;
+			}
+		}
+		text += c;
+
+		c = in.get();
+	}
+	return text;
+}
+
+
+std::string Template::readTemplateCommand(std::istream& in)
+{
+	std::string command;
+
+	readWhiteSpace(in);
+
+	int c = in.get();
+	while (c != -1)
+	{
+		if (Ascii::isSpace(c))
+			break;
+
+		if (c == '?' && in.peek() == '>')
+		{
+			in.putback(c);
+			break;
+		}
+
+		if (c == '=' && command.length() == 0)
+		{
+			command = "echo";
+			break;
+		}
+
+		command += c;
+
+		c = in.get();
+	}
+
+	return command;
+}
+
+
+std::string Template::readWord(std::istream& in)
+{
+	std::string word;
+	int c;
+	while ((c = in.peek()) != -1 && !Ascii::isSpace(c))
+	{
+		in.get();
+		word += c;
+	}
+	return word;
+}
+
+
+std::string Template::readQuery(std::istream& in)
+{
+	std::string word;
+	int c;
+	while ((c = in.get()) != -1)
+	{
+		if (c == '?' && in.peek() == '>')
+		{
+			in.putback(c);
+			break;
+		}
+
+		if (Ascii::isSpace(c))
+		{
+			break;
+		}
+		word += c;
+	}
+	return word;
+}
+
+
+void Template::readWhiteSpace(std::istream& in)
+{
+	int c;
+	while ((c = in.peek()) != -1 && Ascii::isSpace(c))
+	{
+		in.get();
+	}
+}
+
+
+std::string Template::readString(std::istream& in)
+{
+	std::string str;
+
+	int c = in.get();
+	if (c == '"')
+	{
+		while ((c = in.get()) != -1 && c != '"')
+		{
+			str += c;
+		}
+	}
+	return str;
+}
+
+
+void Template::render(const Var& data, std::ostream& out) const
+{
+	_parts->render(data, out);
+}
+
+
+} } // namespace Poco::JSON
diff --git a/base/poco/JSON/src/TemplateCache.cpp b/base/poco/JSON/src/TemplateCache.cpp
new file mode 100644
index 00000000000..d8df071d454
--- /dev/null
+++ b/base/poco/JSON/src/TemplateCache.cpp
@@ -0,0 +1,157 @@
+//
+// TemplateCache.cpp
+//
+// Library: JSON
+// Package: JSON
+// Module:  TemplateCache
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/File.h"
+#include "Poco/JSON/TemplateCache.h"
+
+
+namespace Poco {
+namespace JSON {
+
+
+TemplateCache* TemplateCache::_pInstance = 0;
+
+
+TemplateCache::TemplateCache(): _pLogger(0)
+{
+	setup();
+}
+
+
+TemplateCache::~TemplateCache()
+{
+	_pInstance = 0;
+}
+
+
+void TemplateCache::setup()
+{
+	poco_assert (_pInstance == 0);
+	_pInstance = this;
+}
+
+
+Template::Ptr TemplateCache::getTemplate(const Path& path)
+{
+	if (_pLogger)
+	{
+		poco_trace_f1(*_pLogger, "Trying to load %s", path.toString());
+	}
+
+	Path templatePath = resolvePath(path);
+	std::string templatePathname = templatePath.toString();
+	
+	if (_pLogger)
+	{
+		poco_trace_f1(*_pLogger, "Path resolved to %s", templatePathname);
+	}
+	
+	File templateFile(templatePathname);
+
+	Template::Ptr tpl;
+
+	std::map<std::string, Template::Ptr>::iterator it = _cache.find(templatePathname);
+	if (it == _cache.end())
+	{
+		if (templateFile.exists())
+		{
+			if (_pLogger)
+			{
+				poco_information_f1(*_pLogger, "Loading template %s", templatePath.toString());
+			}
+
+			tpl = new Template(templatePath);
+
+			try
+			{
+				tpl->parse();
+				_cache[templatePathname] = tpl;
+			}
+			catch (JSONTemplateException& jte)
+			{
+				if (_pLogger)
+				{
+					poco_error_f2(*_pLogger, "Template %s contains an error: %s", templatePath.toString(), jte.message());
+				}
+			}
+		}
+		else
+		{
+			if (_pLogger)
+			{
+				poco_error_f1(*_pLogger, "Template file %s doesn't exist", templatePath.toString());
+			}
+			throw FileNotFoundException(templatePathname);
+		}
+	}
+	else
+	{
+		tpl = it->second;
+		if (tpl->parseTime() < templateFile.getLastModified())
+		{
+			if (_pLogger)
+			{
+				poco_information_f1(*_pLogger, "Reloading template %s", templatePath.toString());
+			}
+
+			tpl = new Template(templatePath);
+
+			try
+			{
+				tpl->parse();
+				_cache[templatePathname] = tpl;
+			}
+			catch (JSONTemplateException& jte)
+			{
+				if (_pLogger)
+				{
+					poco_error_f2(*_pLogger, "Template %s contains an error: %s", templatePath.toString(), jte.message());
+				}
+			}
+		}
+	}
+
+	return tpl;
+}
+
+
+Path TemplateCache::resolvePath(const Path& path) const
+{
+	if (path.isAbsolute())
+		return path;
+
+	for (std::vector<Path>::const_iterator it = _includePaths.begin(); it != _includePaths.end(); ++it)
+	{
+		Path templatePath(*it, path);
+
+		File templateFile(templatePath);
+		if (templateFile.exists())
+		{
+			if (_pLogger)
+			{
+				poco_trace_f2(*_pLogger, "%s template file resolved to %s", path.toString(), templatePath.toString());
+			}
+			return templatePath;
+		}
+		if (_pLogger)
+		{
+			poco_trace_f1(*_pLogger, "%s doesn't exist", templatePath.toString());
+		}
+	}
+
+	throw FileNotFoundException(path.toString());
+}
+
+
+} } // Poco::JSON
diff --git a/base/poco/JSON/src/pdjson.c b/base/poco/JSON/src/pdjson.c
new file mode 100644
index 00000000000..18768ac96d3
--- /dev/null
+++ b/base/poco/JSON/src/pdjson.c
@@ -0,0 +1,870 @@
+#define _POSIX_C_SOURCE 200112L
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include "pdjson.h"
+
+#define JSON_FLAG_ERROR      (1u << 0)
+#define JSON_FLAG_STREAMING  (1u << 1)
+
+
+// patched for poco 1.8.x (VS 2008)
+#if defined(_MSC_VER) && (_MSC_VER < 1900)
+
+#define json_error(json, format, ...)                             \
+    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
+        json->flags |= JSON_FLAG_ERROR;                           \
+        _snprintf_s(json->errmsg, sizeof(json->errmsg), _TRUNCATE,\
+                 "error: %lu: " format,                           \
+                 (unsigned long) json->lineno,                    \
+                 __VA_ARGS__);                                    \
+    }                                                             \
+
+#else
+
+#define json_error(json, format, ...)                             \
+    if (!(json->flags & JSON_FLAG_ERROR)) {                       \
+        json->flags |= JSON_FLAG_ERROR;                           \
+        snprintf(json->errmsg, sizeof(json->errmsg),              \
+                 "error: %lu: " format,                           \
+                 (unsigned long) json->lineno,                    \
+                 __VA_ARGS__);                                    \
+    }                                                             \
+
+#endif // _MSC_VER
+
+#define STACK_INC 4
+
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#define strerror_r(err, buf, len) strerror_s(buf, len, err)
+#endif
+/*
+const char *json_typename[] = {
+    [JSON_ERROR]      = "ERROR",
+    [JSON_DONE]       = "DONE",
+    [JSON_OBJECT]     = "OBJECT",
+    [JSON_OBJECT_END] = "OBJECT_END",
+    [JSON_ARRAY]      = "ARRAY",
+    [JSON_ARRAY_END]  = "ARRAY_END",
+    [JSON_STRING]     = "STRING",
+    [JSON_NUMBER]     = "NUMBER",
+    [JSON_TRUE]       = "TRUE",
+    [JSON_FALSE]      = "FALSE",
+    [JSON_NULL]       = "NULL",
+};
+*/
+struct json_stack {
+    enum json_type type;
+    long count;
+};
+
+static void json_error_s(json_stream *json, int err)
+{
+    char errbuf[1024] = {0};
+    strerror_r(err, errbuf, sizeof(errbuf));
+    json_error(json, "%s", errbuf);
+}
+
+static enum json_type
+push(json_stream *json, enum json_type type)
+{
+    json->stack_top++;
+
+    if (json->stack_top >= json->stack_size) {
+        struct json_stack *stack;
+        stack = (struct json_stack *) json->alloc.realloc(json->stack,
+                (json->stack_size + STACK_INC) * sizeof(*json->stack));
+        if (stack == NULL) {
+            json_error_s(json, errno);
+            return JSON_ERROR;
+        }
+
+        json->stack_size += STACK_INC;
+        json->stack = stack;
+    }
+
+    json->stack[json->stack_top].type = type;
+    json->stack[json->stack_top].count = 0;
+
+    return type;
+}
+
+static enum json_type
+pop(json_stream *json, int c, enum json_type expected)
+{
+    if (json->stack == NULL || json->stack[json->stack_top].type != expected) {
+        json_error(json, "unexpected byte, '%c'", c);
+        return JSON_ERROR;
+    }
+    json->stack_top--;
+    return expected == JSON_ARRAY ? JSON_ARRAY_END : JSON_OBJECT_END;
+}
+
+static int buffer_peek(struct json_source *source)
+{
+    if (source->position < source->source.buffer.length)
+        return source->source.buffer.buffer[source->position];
+    else
+        return EOF;
+}
+
+static int buffer_get(struct json_source *source)
+{
+    int c = source->peek(source);
+    source->position++;
+    return c;
+}
+
+static int stream_get(struct json_source *source)
+{
+    source->position++;
+    return fgetc(source->source.stream.stream);
+}
+
+static int stream_peek(struct json_source *source)
+{
+    int c = fgetc(source->source.stream.stream);
+    ungetc(c, source->source.stream.stream);
+    return c;
+}
+
+static void init(json_stream *json)
+{
+    json->lineno = 1;
+    json->flags = JSON_FLAG_STREAMING;
+    json->errmsg[0] = '\0';
+    json->ntokens = 0;
+    json->next = (enum json_type) 0;
+
+    json->stack = NULL;
+    json->stack_top = -1;
+    json->stack_size = 0;
+
+    json->data.string = NULL;
+    json->data.string_size = 0;
+    json->data.string_fill = 0;
+    json->source.position = 0;
+
+    json->alloc.malloc = malloc;
+    json->alloc.realloc = realloc;
+    json->alloc.free = free;
+}
+
+static enum json_type
+is_match(json_stream *json, const char *pattern, enum json_type type)
+{
+    for (const char *p = pattern; *p; p++)
+        if (*p != json->source.get(&json->source))
+            return JSON_ERROR;
+    return type;
+}
+
+static int pushchar(json_stream *json, int c)
+{
+    if (json->data.string_fill == json->data.string_size) {
+        size_t size = json->data.string_size * 2;
+        char *buffer = (char*) json->alloc.realloc(json->data.string, size);
+        if (buffer == NULL) {
+            json_error_s(json, errno);
+            return -1;
+        } else {
+            json->data.string_size = size;
+            json->data.string = buffer;
+        }
+    }
+    json->data.string[json->data.string_fill++] = c;
+    return 0;
+}
+
+static int init_string(json_stream *json)
+{
+    json->data.string_fill = 0;
+    if (json->data.string == NULL) {
+        json->data.string_size = 1024;
+        json->data.string = (char*) json->alloc.malloc(json->data.string_size);
+        if (json->data.string == NULL) {
+            json_error_s(json, errno);
+            return -1;
+        }
+    }
+    json->data.string[0] = '\0';
+    return 0;
+}
+
+static int encode_utf8(json_stream *json, unsigned long c)
+{
+    if (c < 0x80UL) {
+        return pushchar(json, c);
+    } else if (c < 0x0800UL) {
+        return !((pushchar(json, (c >> 6 & 0x1F) | 0xC0) == 0) &&
+                 (pushchar(json, (c >> 0 & 0x3F) | 0x80) == 0));
+    } else if (c < 0x010000UL) {
+        if (c >= 0xd800 && c <= 0xdfff) {
+            json_error(json, "invalid codepoint %06lx", c);
+            return -1;
+        }
+        return !((pushchar(json, (c >> 12 & 0x0F) | 0xE0) == 0) &&
+                 (pushchar(json, (c >>  6 & 0x3F) | 0x80) == 0) &&
+                 (pushchar(json, (c >>  0 & 0x3F) | 0x80) == 0));
+    } else if (c < 0x110000UL) {
+        return !((pushchar(json, (c >> 18 & 0x07) | 0xF0) == 0) &&
+                (pushchar(json, (c >> 12 & 0x3F) | 0x80) == 0) &&
+                (pushchar(json, (c >> 6  & 0x3F) | 0x80) == 0) &&
+                (pushchar(json, (c >> 0  & 0x3F) | 0x80) == 0));
+    } else {
+        json_error(json, "can't encode UTF-8 for %06lx", c);
+        return -1;
+    }
+}
+
+static int hexchar(int c)
+{
+    switch (c) {
+    case '0': return 0;
+    case '1': return 1;
+    case '2': return 2;
+    case '3': return 3;
+    case '4': return 4;
+    case '5': return 5;
+    case '6': return 6;
+    case '7': return 7;
+    case '8': return 8;
+    case '9': return 9;
+    case 'a':
+    case 'A': return 10;
+    case 'b':
+    case 'B': return 11;
+    case 'c':
+    case 'C': return 12;
+    case 'd':
+    case 'D': return 13;
+    case 'e':
+    case 'E': return 14;
+    case 'f':
+    case 'F': return 15;
+    default:
+        return -1;
+    }
+}
+
+static long
+read_unicode_cp(json_stream *json)
+{
+    long cp = 0;
+    int shift = 12;
+
+    for (size_t i = 0; i < 4; i++) {
+        int c = json->source.get(&json->source);
+        int hc;
+
+        if (c == EOF) {
+            json_error(json, "%s", "unterminated string literal in unicode");
+            return -1;
+        } else if ((hc = hexchar(c)) == -1) {
+            json_error(json, "bad escape unicode byte, '%c'", c);
+            return -1;
+        }
+
+        cp += hc * (1 << shift);
+        shift -= 4;
+    }
+
+
+    return cp;
+}
+
+static int read_unicode(json_stream *json)
+{
+    long cp, h, l;
+
+    if ((cp = read_unicode_cp(json)) == -1) {
+        return -1;
+    }
+
+    if (cp >= 0xd800 && cp <= 0xdbff) {
+        /* This is the high portion of a surrogate pair; we need to read the
+         * lower portion to get the codepoint
+         */
+        h = cp;
+
+        int c = json->source.get(&json->source);
+        if (c == EOF) {
+            json_error(json, "%s", "unterminated string literal in unicode");
+            return -1;
+        } else if (c != '\\') {
+            json_error(json, "invalid continuation for surrogate pair: '%c', "
+                             "expected '\\'", c);
+            return -1;
+        }
+
+        c = json->source.get(&json->source);
+        if (c == EOF) {
+            json_error(json, "%s", "unterminated string literal in unicode");
+            return -1;
+        } else if (c != 'u') {
+            json_error(json, "invalid continuation for surrogate pair: '%c', "
+                             "expected 'u'", c);
+            return -1;
+        }
+
+        if ((l = read_unicode_cp(json)) == -1) {
+            return -1;
+        }
+
+        if (l < 0xdc00 || l > 0xdfff) {
+            json_error(json, "invalid surrogate pair continuation \\u%04lx out "
+                             "of range (dc00-dfff)", l);
+            return -1;
+        }
+
+        cp = ((h - 0xd800) * 0x400) + ((l - 0xdc00) + 0x10000);
+    } else if (cp >= 0xdc00 && cp <= 0xdfff) {
+            json_error(json, "dangling surrogate \\u%04lx", cp);
+            return -1;
+    }
+
+    return encode_utf8(json, cp);
+}
+
+int read_escaped(json_stream *json)
+{
+    int c = json->source.get(&json->source);
+    if (c == EOF) {
+        json_error(json, "%s", "unterminated string literal in escape");
+        return -1;
+    } else if (c == 'u') {
+        if (read_unicode(json) != 0)
+            return -1;
+    } else {
+        switch (c) {
+        case '\\':
+        case 'b':
+        case 'f':
+        case 'n':
+        case 'r':
+        case 't':
+        case '/':
+        case '"':
+            {
+                const char *codes = "\\bfnrt/\"";
+                char *p = (char*) strchr(codes, c);
+                if (pushchar(json, "\\\b\f\n\r\t/\""[p - codes]) != 0)
+                    return -1;
+            }
+            break;
+        default:
+            json_error(json, "bad escaped byte, '%c'", c);
+            return -1;
+        }
+    }
+    return 0;
+}
+
+static int
+char_needs_escaping(int c)
+{
+    if ((c >= 0) && (c < 0x20 || c == 0x22 || c == 0x5c)) {
+        return 1;
+    }
+
+    return 0;
+}
+
+static int
+utf8_seq_length(char byte)
+{
+    unsigned char u = (unsigned char) byte;
+    if (u < 0x80) return 1;
+
+    if (0x80 <= u && u <= 0xBF)
+    {
+        // second, third or fourth byte of a multi-byte
+        // sequence, i.e. a "continuation byte"
+        return 0;
+    }
+    else if (u == 0xC0 || u == 0xC1)
+    {
+        // overlong encoding of an ASCII byte
+        return 0;
+    }
+    else if (0xC2 <= u && u <= 0xDF)
+    {
+        // 2-byte sequence
+        return 2;
+    }
+    else if (0xE0 <= u && u <= 0xEF)
+    {
+        // 3-byte sequence
+        return 3;
+    }
+    else if (0xF0 <= u && u <= 0xF4)
+    {
+        // 4-byte sequence
+        return 4;
+    }
+    else
+    {
+        // u >= 0xF5
+        // Restricted (start of 4-, 5- or 6-byte sequence) or invalid UTF-8
+        return 0;
+    }
+}
+
+static int
+is_legal_utf8(const unsigned char *bytes, int length)
+{
+    if (0 == bytes || 0 == length) return 0;
+
+    unsigned char a;
+    const unsigned char* srcptr = bytes + length;
+    switch (length)
+    {
+    default:
+        return 0;
+        // Everything else falls through when true.
+    case 4:
+        if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return 0;
+    case 3:
+        if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return 0;
+    case 2:
+        a = (*--srcptr);
+        switch (*bytes)
+        {
+        case 0xE0:
+            if (a < 0xA0 || a > 0xBF) return 0;
+            break;
+        case 0xED:
+            if (a < 0x80 || a > 0x9F) return 0;
+            break;
+        case 0xF0:
+            if (a < 0x90 || a > 0xBF) return 0;
+            break;
+        case 0xF4:
+            if (a < 0x80 || a > 0x8F) return 0;
+            break;
+        default:
+            if (a < 0x80 || a > 0xBF) return 0;
+        }
+    case 1:
+        if (*bytes >= 0x80 && *bytes < 0xC2) return 0;
+    }
+    return *bytes <= 0xF4;
+}
+
+static int
+read_utf8(json_stream* json, int next_char)
+{
+    int count = utf8_seq_length(next_char);
+    if (!count)
+    {
+        json_error(json, "%s", "Bad character.");
+        return -1;
+    }
+
+    char buffer[4];
+    buffer[0] = next_char;
+    for (int i = 1; i < count; ++i)
+    {
+        buffer[i] = json->source.get(&json->source);;
+    }
+
+    if (!is_legal_utf8((unsigned char*) buffer, count))
+    {
+        json_error(json, "%s", "No legal UTF8 found");
+        return -1;
+    }
+
+    for (int i = 0; i < count; ++i)
+    {
+        if (pushchar(json, buffer[i]) != 0)
+            return -1;
+    }
+    return 0;
+}
+
+static enum json_type
+read_string(json_stream *json)
+{
+    if (init_string(json) != 0)
+        return JSON_ERROR;
+    while (1) {
+        int c = json->source.get(&json->source);
+        if (c == EOF) {
+            json_error(json, "%s", "unterminated string literal");
+            return JSON_ERROR;
+        } else if (c == '"') {
+            if (pushchar(json, '\0') == 0)
+                return JSON_STRING;
+            else
+                return JSON_ERROR;
+        } else if (c == '\\') {
+            if (read_escaped(json) != 0)
+                return JSON_ERROR;
+        } else if ((unsigned) c >= 0x80) {
+            if (read_utf8(json, c) != 0)
+                return JSON_ERROR;
+        } else {
+            if (char_needs_escaping(c)) {
+                json_error(json, "%s", "unescaped control character in string");
+                return JSON_ERROR;
+            }
+
+            if (pushchar(json, c) != 0)
+                return JSON_ERROR;
+        }
+    }
+    return JSON_ERROR;
+}
+
+static int
+is_digit(int c)
+{
+    return c >= 48 /*0*/ && c <= 57 /*9*/;
+}
+
+static int
+read_digits(json_stream *json)
+{
+    unsigned nread = 0;
+    while (is_digit(json->source.peek(&json->source))) {
+        if (pushchar(json, json->source.get(&json->source)) != 0)
+            return -1;
+
+        nread++;
+    }
+
+    if (nread == 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+static enum json_type
+read_number(json_stream *json, int c)
+{
+    if (pushchar(json, c) != 0)
+        return JSON_ERROR;
+    if (c == '-') {
+        c = json->source.get(&json->source);
+        if (is_digit(c)) {
+            return read_number(json, c);
+        } else {
+            json_error(json, "unexpected byte, '%c'", c);
+        }
+    } else if (strchr("123456789", c) != NULL) {
+        c = json->source.peek(&json->source);
+        if (is_digit(c)) {
+            if (read_digits(json) != 0)
+                return JSON_ERROR;
+        }
+    }
+    /* Up to decimal or exponent has been read. */
+    c = json->source.peek(&json->source);
+    if (strchr(".eE", c) == NULL) {
+        if (pushchar(json, '\0') != 0)
+            return JSON_ERROR;
+        else
+            return JSON_NUMBER;
+    }
+    if (c == '.') {
+        json->source.get(&json->source); // consume .
+        if (pushchar(json, c) != 0)
+            return JSON_ERROR;
+        if (read_digits(json) != 0)
+            return JSON_ERROR;
+    }
+    /* Check for exponent. */
+    c = json->source.peek(&json->source);
+    if (c == 'e' || c == 'E') {
+        json->source.get(&json->source); // consume e/E
+        if (pushchar(json, c) != 0)
+            return JSON_ERROR;
+        c = json->source.peek(&json->source);
+        if (c == '+' || c == '-') {
+            json->source.get(&json->source); // consume
+            if (pushchar(json, c) != 0)
+                return JSON_ERROR;
+            if (read_digits(json) != 0)
+                return JSON_ERROR;
+        } else if (is_digit(c)) {
+            if (read_digits(json) != 0)
+                return JSON_ERROR;
+        } else {
+            json_error(json, "unexpected byte in number, '%c'", c);
+            return JSON_ERROR;
+        }
+    }
+    if (pushchar(json, '\0') != 0)
+        return JSON_ERROR;
+    else
+        return JSON_NUMBER;
+}
+
+static int
+json_isspace(int c)
+{
+    switch (c) {
+    case 0x09:
+    case 0x0a:
+    case 0x0d:
+    case 0x20:
+        return 1;
+    }
+
+    return 0;
+}
+
+/* Returns the next non-whitespace character in the stream. */
+static int next(json_stream *json)
+{
+   int c;
+   while (json_isspace(c = json->source.get(&json->source)))
+       if (c == '\n')
+           json->lineno++;
+   return c;
+}
+
+static enum json_type
+read_value(json_stream *json, int c)
+{
+    json->ntokens++;
+    switch (c) {
+    case EOF:
+        json_error(json, "%s", "unexpected end of data");
+        return JSON_ERROR;
+    case '{':
+        return push(json, JSON_OBJECT);
+    case '[':
+        return push(json, JSON_ARRAY);
+    case '"':
+        return read_string(json);
+    case 'n':
+        return is_match(json, "ull", JSON_NULL);
+    case 'f':
+        return is_match(json, "alse", JSON_FALSE);
+    case 't':
+        return is_match(json, "rue", JSON_TRUE);
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+    case '-':
+        if (init_string(json) != 0)
+            return JSON_ERROR;
+        return read_number(json, c);
+    default:
+        json_error(json, "unexpected byte, '%c'", c);
+        return JSON_ERROR;
+    }
+}
+
+enum json_type json_peek(json_stream *json)
+{
+    enum json_type next = json_next(json);
+    json->next = next;
+    return next;
+}
+
+enum json_type json_next(json_stream *json)
+{
+    if (json->flags & JSON_FLAG_ERROR)
+        return JSON_ERROR;
+    if (json->next != 0) {
+        enum json_type next = json->next;
+        json->next = (enum json_type) 0;
+        return next;
+    }
+    if (json->ntokens > 0 && json->stack_top == (size_t)-1) {
+        int c;
+
+        do {
+            c = json->source.peek(&json->source);
+            if (json_isspace(c)) {
+                c = json->source.get(&json->source);
+            }
+        } while (json_isspace(c));
+
+        if (!(json->flags & JSON_FLAG_STREAMING) && c != EOF) {
+            return JSON_ERROR;
+        }
+
+        return JSON_DONE;
+    }
+    int c = next(json);
+    if (json->stack_top == (size_t)-1)
+        return read_value(json, c);
+    if (json->stack[json->stack_top].type == JSON_ARRAY) {
+        if (json->stack[json->stack_top].count == 0) {
+            if (c == ']') {
+                return pop(json, c, JSON_ARRAY);
+            }
+            json->stack[json->stack_top].count++;
+            return read_value(json, c);
+        } else if (c == ',') {
+            json->stack[json->stack_top].count++;
+            return read_value(json, next(json));
+        } else if (c == ']') {
+            return pop(json, c, JSON_ARRAY);
+        } else {
+            json_error(json, "unexpected byte, '%c'", c);
+            return JSON_ERROR;
+        }
+    } else if (json->stack[json->stack_top].type == JSON_OBJECT) {
+        if (json->stack[json->stack_top].count == 0) {
+            if (c == '}') {
+                return pop(json, c, JSON_OBJECT);
+            }
+
+            /* No property value pairs yet. */
+            enum json_type value = read_value(json, c);
+            if (value != JSON_STRING) {
+                json_error(json, "%s", "expected property name or '}'");
+                return JSON_ERROR;
+            } else {
+                json->stack[json->stack_top].count++;
+                return value;
+            }
+        } else if ((json->stack[json->stack_top].count % 2) == 0) {
+            /* Expecting comma followed by property name. */
+            if (c != ',' && c != '}') {
+                json_error(json, "%s", "expected ',' or '}'");
+                return JSON_ERROR;
+            } else if (c == '}') {
+                return pop(json, c, JSON_OBJECT);
+            } else {
+                enum json_type value = read_value(json, next(json));
+                if (value != JSON_STRING) {
+                    json_error(json, "%s", "expected property name");
+                    return JSON_ERROR;
+                } else {
+                    json->stack[json->stack_top].count++;
+                    return value;
+                }
+            }
+        } else if ((json->stack[json->stack_top].count % 2) == 1) {
+            /* Expecting colon followed by value. */
+            if (c != ':') {
+                json_error(json, "%s", "expected ':' after property name");
+                return JSON_ERROR;
+            } else {
+                json->stack[json->stack_top].count++;
+                return read_value(json, next(json));
+            }
+        }
+    }
+    json_error(json, "%s", "invalid parser state");
+    return JSON_ERROR;
+}
+
+void json_reset(json_stream *json)
+{
+    json->stack_top = -1;
+    json->ntokens = 0;
+    json->flags &= ~JSON_FLAG_ERROR;
+    json->errmsg[0] = '\0';
+}
+
+const char *json_get_string(json_stream *json, size_t *length)
+{
+    if (length != NULL)
+        *length = json->data.string_fill;
+    if (json->data.string == NULL)
+        return "";
+    else
+        return json->data.string;
+}
+
+double json_get_number(json_stream *json)
+{
+    char *p = json->data.string;
+    return p == NULL ? 0 : strtod(p, NULL);
+}
+
+const char *json_get_error(json_stream *json)
+{
+    return json->flags & JSON_FLAG_ERROR ? json->errmsg : NULL;
+}
+
+size_t json_get_lineno(json_stream *json)
+{
+    return json->lineno;
+}
+
+size_t json_get_position(json_stream *json)
+{
+    return json->source.position;
+}
+
+size_t json_get_depth(json_stream *json)
+{
+    return json->stack_top + 1;
+}
+
+void json_open_buffer(json_stream *json, const void *buffer, size_t size)
+{
+    init(json);
+    json->source.get = buffer_get;
+    json->source.peek = buffer_peek;
+    json->source.source.buffer.buffer = (char*) buffer;
+    json->source.source.buffer.length = size;
+}
+
+void json_open_string(json_stream *json, const char *string)
+{
+    json_open_buffer(json, string, strlen(string));
+}
+
+void json_open_stream(json_stream *json, FILE * stream)
+{
+    init(json);
+    json->source.get = stream_get;
+    json->source.peek = stream_peek;
+    json->source.source.stream.stream = stream;
+}
+
+static int user_get(struct json_source *json)
+{
+    return json->source.user.get(json->source.user.ptr);
+}
+
+static int user_peek(struct json_source *json)
+{
+    return json->source.user.peek(json->source.user.ptr);
+}
+
+void json_open_user(json_stream *json, json_user_io get, json_user_io peek, void *user)
+{
+    init(json);
+    json->source.get = user_get;
+    json->source.peek = user_peek;
+    json->source.source.user.ptr = user;
+    json->source.source.user.get = get;
+    json->source.source.user.peek = peek;
+}
+
+void json_set_allocator(json_stream *json, json_allocator *a)
+{
+    json->alloc = *a;
+}
+
+void json_set_streaming(json_stream *json, bool streaming)
+{
+    if (streaming)
+        json->flags |= JSON_FLAG_STREAMING;
+    else
+        json->flags &= ~JSON_FLAG_STREAMING;
+}
+
+void json_close(json_stream *json)
+{
+    json->alloc.free(json->stack);
+    json->alloc.free(json->data.string);
+}
diff --git a/base/poco/JSON/src/pdjson.h b/base/poco/JSON/src/pdjson.h
new file mode 100644
index 00000000000..beb7629647a
--- /dev/null
+++ b/base/poco/JSON/src/pdjson.h
@@ -0,0 +1,113 @@
+#ifndef PDJSON_H
+#define PDJSON_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif // __cplusplus
+
+#include <stdio.h>
+
+#if !defined(__cplusplus) && !defined(_MSC_VER) // for poco 1.8.x we must compile as C++
+	#if defined(__STDC_VERSION__) || (__STDC_VERSION__ >= 199901L)
+		#include <stdbool.h>
+	#else
+	#ifndef bool
+		#define bool int
+	#endif
+	#ifndef true
+		#define true 1
+	#endif
+	#ifndef false
+		#define false 0
+	#endif
+	#endif // __STDC_VERSION__
+#endif
+
+enum json_type {
+    JSON_ERROR = 1, JSON_DONE,
+    JSON_OBJECT, JSON_OBJECT_END, JSON_ARRAY, JSON_ARRAY_END,
+    JSON_STRING, JSON_NUMBER, JSON_TRUE, JSON_FALSE, JSON_NULL
+};
+
+struct json_allocator {
+    void *(*malloc)(size_t);
+    void *(*realloc)(void *, size_t);
+    void (*free)(void *);
+};
+
+typedef int (*json_user_io) (void *user);
+
+typedef struct json_stream json_stream;
+typedef struct json_allocator json_allocator;
+
+//extern const char *json_typename[];
+
+void json_open_buffer(json_stream *json, const void *buffer, size_t size);
+void json_open_string(json_stream *json, const char *string);
+void json_open_stream(json_stream *json, FILE *stream);
+void json_open_user(json_stream *json, json_user_io get, json_user_io peek, void *user);
+void json_close(json_stream *json);
+
+void json_set_allocator(json_stream *json, json_allocator *a);
+void json_set_streaming(json_stream *json, bool strict);
+
+enum json_type json_next(json_stream *json);
+enum json_type json_peek(json_stream *json);
+void json_reset(json_stream *json);
+const char *json_get_string(json_stream *json, size_t *length);
+double json_get_number(json_stream *json);
+
+size_t json_get_lineno(json_stream *json);
+size_t json_get_position(json_stream *json);
+size_t json_get_depth(json_stream *json);
+const char *json_get_error(json_stream *json);
+
+/* internal */
+
+struct json_source {
+    int (*get) (struct json_source *);
+    int (*peek) (struct json_source *);
+    size_t position;
+    union {
+        struct {
+            FILE *stream;
+        } stream;
+        struct {
+            const char *buffer;
+            size_t length;
+        } buffer;
+        struct {
+            void *ptr;
+            json_user_io get;
+            json_user_io peek;
+        } user;
+    } source;
+};
+
+struct json_stream {
+    size_t lineno;
+
+    struct json_stack *stack;
+    size_t stack_top;
+    size_t stack_size;
+    enum json_type next;
+    unsigned flags;
+
+    struct {
+        char *string;
+        size_t string_fill;
+        size_t string_size;
+    } data;
+
+    size_t ntokens;
+
+    struct json_source source;
+    struct json_allocator alloc;
+    char errmsg[128];
+};
+
+#if defined(__cplusplus)
+} // extern "C"
+#endif // __cplusplus
+
+#endif
diff --git a/base/poco/LICENSE b/base/poco/LICENSE
new file mode 100644
index 00000000000..2f2f957ce4f
--- /dev/null
+++ b/base/poco/LICENSE
@@ -0,0 +1,32 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+---------------------------------------------------------------------------
+Note:
+Individual files contain the following tag instead of the full license text.
+
+	SPDX-License-Identifier:	BSL-1.0
+
+This enables machine processing of license information based on the SPDX
+License Identifiers that are here available: http://spdx.org/licenses/
diff --git a/base/poco/MongoDB/CMakeLists.txt b/base/poco/MongoDB/CMakeLists.txt
new file mode 100644
index 00000000000..92589fe438f
--- /dev/null
+++ b/base/poco/MongoDB/CMakeLists.txt
@@ -0,0 +1,7 @@
+file (GLOB SRCS src/*.cpp)
+
+add_library (_poco_mongodb ${SRCS})
+add_library (Poco::MongoDB ALIAS _poco_mongodb)
+
+target_include_directories (_poco_mongodb SYSTEM PUBLIC "include")
+target_link_libraries (_poco_mongodb PUBLIC Poco::Net)
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/Array.h b/base/poco/MongoDB/include/Poco/MongoDB/Array.h
new file mode 100644
index 00000000000..ee306bb01f9
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/Array.h
@@ -0,0 +1,110 @@
+//
+// Array.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  Array
+//
+// Definition of the Array class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_Array_INCLUDED
+#define MongoDB_Array_INCLUDED
+
+
+#include "Poco/NumberFormatter.h"
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/Document.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API Array: public Document
+	/// This class represents a BSON Array.
+{
+public:
+	typedef SharedPtr<Array> Ptr;
+
+	Array();
+		/// Creates an empty Array.
+
+	virtual ~Array();
+		/// Destroys the Array.
+
+	template<typename T>
+	T get(int pos) const
+		/// Returns the element at the given index and tries to convert
+		/// it to the template type. If the element is not found, a
+		/// Poco::NotFoundException will be thrown. If the element cannot be
+		/// converted a BadCastException will be thrown.
+	{
+		return Document::get<T>(Poco::NumberFormatter::format(pos));
+	}
+
+	template<typename T>
+	T get(int pos, const T& deflt) const
+		/// Returns the element at the given index and tries to convert
+		/// it to the template type. If the element is not found, or
+		/// has the wrong type, the deflt argument will be returned.
+	{
+		return Document::get<T>(Poco::NumberFormatter::format(pos), deflt);
+	}
+
+	Element::Ptr get(int pos) const;
+		/// Returns the element at the given index.
+		/// An empty element will be returned if the element is not found.
+
+	template<typename T>
+	bool isType(int pos) const
+		/// Returns true if the type of the element equals the TypeId of ElementTrait,
+		/// otherwise false.
+	{
+		return Document::isType<T>(Poco::NumberFormatter::format(pos));
+	}
+
+	std::string toString(int indent = 0) const;
+		/// Returns a string representation of the Array.
+};
+
+
+// BSON Embedded Array
+// spec: document
+template<>
+struct ElementTraits<Array::Ptr>
+{
+	enum { TypeId = 0x04 };
+
+	static std::string toString(const Array::Ptr& value, int indent = 0)
+	{
+		//TODO:
+		return value.isNull() ? "null" : value->toString(indent);
+	}
+};
+
+
+template<>
+inline void BSONReader::read<Array::Ptr>(Array::Ptr& to)
+{
+	to->read(_reader);
+}
+
+
+template<>
+inline void BSONWriter::write<Array::Ptr>(Array::Ptr& from)
+{
+	from->write(_writer);
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_Array_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/BSONReader.h b/base/poco/MongoDB/include/Poco/MongoDB/BSONReader.h
new file mode 100644
index 00000000000..3c5d9ba3e59
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/BSONReader.h
@@ -0,0 +1,84 @@
+//
+// BSONReader.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  BSONReader
+//
+// Definition of the BSONReader class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_BSONReader_INCLUDED
+#define MongoDB_BSONReader_INCLUDED
+
+
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/BinaryReader.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API BSONReader
+	/// Class for reading BSON using a Poco::BinaryReader
+{
+public:
+	BSONReader(const Poco::BinaryReader& reader):
+		_reader(reader)
+		/// Creates the BSONReader using the given BinaryWriter.
+	{
+	}
+
+	virtual ~BSONReader()
+		/// Destroys the BSONReader.
+	{
+	}
+
+	template<typename T>
+	void read(T& t)
+		/// Reads the value from the reader. The default implementation uses the >> operator to
+		/// the given argument. Special types can write their own version.
+	{
+		_reader >> t;
+	}
+
+	std::string readCString();
+		/// Reads a cstring from the reader.
+		/// A cstring is a string terminated with a 0x00.
+
+private:
+	Poco::BinaryReader _reader;
+};
+
+
+//
+// inlines
+//
+inline std::string BSONReader::readCString()
+{
+	std::string val;
+	while(_reader.good())
+	{
+		char c;
+		_reader >> c;
+		if ( _reader.good() )
+		{
+			if (c == 0x00) return val;
+			else val += c;
+		}
+	}
+	return val;
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_BSONReader_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/BSONWriter.h b/base/poco/MongoDB/include/Poco/MongoDB/BSONWriter.h
new file mode 100644
index 00000000000..01c9491e7ca
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/BSONWriter.h
@@ -0,0 +1,74 @@
+//
+// BSONWriter.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  BSONWriter
+//
+// Definition of the BSONWriter class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_BSONWriter_INCLUDED
+#define MongoDB_BSONWriter_INCLUDED
+
+
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/BinaryWriter.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API BSONWriter
+	/// Class for writing BSON using a Poco::BinaryWriter.
+{
+public:
+	BSONWriter(const Poco::BinaryWriter& writer): 
+		_writer(writer)
+		/// Creates the BSONWriter.
+	{
+	}
+
+	virtual ~BSONWriter()
+		/// Destroys the BSONWriter.
+	{
+	}
+
+	template<typename T>
+	void write(T& t)
+		/// Writes the value to the writer. The default implementation uses
+		/// the << operator. Special types can write their own version.
+	{
+		_writer << t;
+	}
+
+	void writeCString(const std::string& value);
+		/// Writes a cstring to the writer. A cstring is a string
+		/// terminated a null character.
+
+private:
+	Poco::BinaryWriter _writer;
+};
+
+
+//
+// inlines
+//
+inline void BSONWriter::writeCString(const std::string& value)
+{
+	_writer.writeRaw(value);
+	_writer << (unsigned char) 0x00;
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_BSONWriter_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/Binary.h b/base/poco/MongoDB/include/Poco/MongoDB/Binary.h
new file mode 100644
index 00000000000..02b6baf1b38
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/Binary.h
@@ -0,0 +1,155 @@
+//
+// Binary.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  Binary
+//
+// Definition of the Binary class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_Binary_INCLUDED
+#define MongoDB_Binary_INCLUDED
+
+
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/Element.h"
+#include "Poco/Base64Encoder.h"
+#include "Poco/Buffer.h"
+#include "Poco/StreamCopier.h"
+#include "Poco/MemoryStream.h"
+#include "Poco/UUID.h"
+#include <sstream>
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API Binary
+	/// Implements BSON Binary.
+	///
+	/// A Binary stores its data in a Poco::Buffer<unsigned char>.
+{
+public:
+	typedef SharedPtr<Binary> Ptr;
+
+	Binary();
+		/// Creates an empty Binary with subtype 0.
+
+	Binary(Poco::Int32 size, unsigned char subtype);
+		/// Creates a Binary with a buffer of the given size and the given subtype.
+
+	Binary(const UUID& uuid);
+		/// Creates a Binary containing an UUID.
+		
+	Binary(const std::string& data, unsigned char subtype = 0);
+		/// Creates a Binary with the contents of the given string and the given subtype.
+		
+	Binary(const void* data, Poco::Int32 size, unsigned char subtype = 0);
+		/// Creates a Binary with the contents of the given buffer and the given subtype.		
+
+	virtual ~Binary();
+		/// Destroys the Binary.
+
+	Buffer<unsigned char>& buffer();
+		/// Returns a reference to the internal buffer
+
+	unsigned char subtype() const;
+		/// Returns the subtype.
+
+	void subtype(unsigned char type);
+		/// Sets the subtype.
+
+	std::string toString(int indent = 0) const;
+		/// Returns the contents of the Binary as Base64-encoded string.
+		
+	std::string toRawString() const;
+		/// Returns the raw content of the Binary as a string.
+
+	UUID uuid() const;
+		/// Returns the UUID when the binary subtype is 0x04.
+		/// Otherwise, throws a Poco::BadCastException.
+
+private:
+	Buffer<unsigned char> _buffer;
+	unsigned char _subtype;
+};
+
+
+//
+// inlines
+//
+inline unsigned char Binary::subtype() const
+{
+	return _subtype;
+}
+
+
+inline void Binary::subtype(unsigned char type)
+{
+	_subtype = type;
+}
+
+
+inline Buffer<unsigned char>& Binary::buffer()
+{
+	return _buffer;
+}
+
+
+inline std::string Binary::toRawString() const
+{
+	return std::string(reinterpret_cast<const char*>(_buffer.begin()), _buffer.size());
+}
+
+
+// BSON Embedded Document
+// spec: binary
+template<>
+struct ElementTraits<Binary::Ptr>
+{
+	enum { TypeId = 0x05 };
+
+	static std::string toString(const Binary::Ptr& value, int indent = 0)
+	{
+		return value.isNull() ? "" : value->toString();
+	}
+};
+
+
+template<>
+inline void BSONReader::read<Binary::Ptr>(Binary::Ptr& to)
+{
+	Poco::Int32 size;
+	_reader >> size;
+
+	to->buffer().resize(size);
+
+	unsigned char subtype;
+	_reader >> subtype;
+	to->subtype(subtype);
+	
+	_reader.readRaw((char*) to->buffer().begin(), size);
+}
+
+
+template<>
+inline void BSONWriter::write<Binary::Ptr>(Binary::Ptr& from)
+{
+	_writer << (Poco::Int32) from->buffer().size();
+	_writer << from->subtype();
+	_writer.writeRaw((char*) from->buffer().begin(), from->buffer().size());
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_Binary_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/Connection.h b/base/poco/MongoDB/include/Poco/MongoDB/Connection.h
new file mode 100644
index 00000000000..202ae90713d
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/Connection.h
@@ -0,0 +1,164 @@
+//
+// Connection.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  Connection
+//
+// Definition of the Connection class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_Connection_INCLUDED
+#define MongoDB_Connection_INCLUDED
+
+
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/Net/StreamSocket.h"
+#include "Poco/Mutex.h"
+#include "Poco/MongoDB/RequestMessage.h"
+#include "Poco/MongoDB/ResponseMessage.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API Connection
+	/// Represents a connection to a MongoDB server
+	/// using the MongoDB wire protocol.
+	///
+	/// See https://docs.mongodb.com/manual/reference/mongodb-wire-protocol/
+	/// for more information on the wire protocol.
+{
+public:
+	typedef Poco::SharedPtr<Connection> Ptr;
+
+	class MongoDB_API SocketFactory
+	{
+	public:
+		SocketFactory();
+			/// Creates the SocketFactory.
+
+		virtual ~SocketFactory();
+			/// Destroys the SocketFactory.
+
+		virtual Poco::Net::StreamSocket createSocket(const std::string& host, int port, Poco::Timespan connectTimeout, bool secure);
+			/// Creates a Poco::Net::StreamSocket (if secure is false), or a
+			/// Poco::Net::SecureStreamSocket (if secure is true) connected to the
+			/// given host and port number.
+			///
+			/// The default implementation will throw a Poco::NotImplementedException
+			/// if secure is true.
+	};
+
+	Connection();
+		/// Creates an unconnected Connection.
+		///
+		/// Use this when you want to connect later on.
+
+	Connection(const std::string& hostAndPort);
+		/// Creates a Connection connected to the given MongoDB instance at host:port.
+		///
+		/// The host and port must be separated with a colon.
+
+	Connection(const std::string& uri, SocketFactory& socketFactory);
+		/// Creates a Connection connected to the given MongoDB instance at the
+		/// given URI.
+		///
+		/// See the corresponding connect() method for more information.
+
+	Connection(const std::string& host, int port);
+		/// Creates a Connection connected to the given MongoDB instance at host and port.
+
+	Connection(const Poco::Net::SocketAddress& addrs);
+		/// Creates a Connection connected to the given MongoDB instance at the given address.
+
+	Connection(const Poco::Net::StreamSocket& socket);
+		/// Creates a Connection connected to the given MongoDB instance using the given socket,
+		/// which must already be connected.
+
+	virtual ~Connection();
+		/// Destroys the Connection.
+
+	Poco::Net::SocketAddress address() const;
+		/// Returns the address of the MongoDB server.
+
+	void connect(const std::string& hostAndPort);
+		/// Connects to the given MongoDB server.
+		///
+		/// The host and port must be separated with a colon.
+
+	void connect(const std::string& uri, SocketFactory& socketFactory);
+		/// Connects to the given MongoDB instance at the given URI.
+		///
+		/// The URI must be in standard MongoDB connection string URI format:
+		///
+		///     mongodb://<user>:<password>@hostname.com:<port>/database-name?options
+		///
+		/// The following options are supported:
+		///
+		///   - ssl: If ssl=true is specified, a custom SocketFactory subclass creating
+		///     a SecureStreamSocket must be supplied.
+		///   - connectTimeoutMS: Socket connection timeout in milliseconds.
+		///   - socketTimeoutMS: Socket send/receive timeout in milliseconds.
+		///   - authMechanism: Authentication mechanism. Only "SCRAM-SHA-1" (default)
+		///     and "MONGODB-CR" are supported.
+		///
+		/// Unknown options are silently ignored.
+		///
+		/// Will also attempt to authenticate using the specified credentials,
+		/// using Database::authenticate().
+		///
+		/// Throws a Poco::NoPermissionException if authentication fails.
+
+	void connect(const std::string& host, int port);
+		/// Connects to the given MongoDB server.
+
+	void connect(const Poco::Net::SocketAddress& addrs);
+		/// Connects to the given MongoDB server.
+
+	void connect(const Poco::Net::StreamSocket& socket);
+		/// Connects using an already connected socket.
+
+	void disconnect();
+		/// Disconnects from the MongoDB server.
+
+	void sendRequest(RequestMessage& request);
+		/// Sends a request to the MongoDB server.
+		///
+		/// Used for one-way requests without a response.
+
+	void sendRequest(RequestMessage& request, ResponseMessage& response);
+		/// Sends a request to the MongoDB server and receives the response.
+		///
+		/// Use this when a response is expected: only a "query" or "getmore"
+		/// request will return a response.
+
+protected:
+	void connect();
+
+private:
+	Poco::Net::SocketAddress _address;
+	Poco::Net::StreamSocket _socket;
+};
+
+
+//
+// inlines
+//
+inline Net::SocketAddress Connection::address() const
+{
+	return _address;
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_Connection_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/Cursor.h b/base/poco/MongoDB/include/Poco/MongoDB/Cursor.h
new file mode 100644
index 00000000000..b9816b0db1e
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/Cursor.h
@@ -0,0 +1,74 @@
+//
+// Cursor.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  Cursor
+//
+// Definition of the Cursor class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_Cursor_INCLUDED
+#define MongoDB_Cursor_INCLUDED
+
+
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/Connection.h"
+#include "Poco/MongoDB/QueryRequest.h"
+#include "Poco/MongoDB/ResponseMessage.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API Cursor: public Document
+	/// Cursor is an helper class for querying multiple documents.
+{
+public:
+	Cursor(const std::string& dbname, const std::string& collectionName, QueryRequest::Flags flags = QueryRequest::QUERY_DEFAULT);
+		/// Creates a Cursor for the given database and collection, using the specified flags.
+
+	Cursor(const std::string& fullCollectionName, QueryRequest::Flags flags = QueryRequest::QUERY_DEFAULT);
+		/// Creates a Cursor for the given database and collection ("database.collection"), using the specified flags.
+
+	virtual ~Cursor();
+		/// Destroys the Cursor.
+
+	ResponseMessage& next(Connection& connection);
+		/// Tries to get the next documents. As long as ResponseMessage has a
+		/// cursor ID next can be called to retrieve the next bunch of documents.
+		///
+		/// The cursor must be killed (see kill()) when not all documents are needed.
+
+	QueryRequest& query();
+		/// Returns the associated query.
+
+	void kill(Connection& connection);
+		/// Kills the cursor and reset it so that it can be reused.
+
+private:
+	QueryRequest    _query;
+	ResponseMessage _response;
+};
+
+
+//
+// inlines
+//
+inline QueryRequest& Cursor::query()
+{
+	return _query;
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_Cursor_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/Database.h b/base/poco/MongoDB/include/Poco/MongoDB/Database.h
new file mode 100644
index 00000000000..ab276eecb39
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/Database.h
@@ -0,0 +1,162 @@
+//
+// Database.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  Database
+//
+// Definition of the Database class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_Database_INCLUDED
+#define MongoDB_Database_INCLUDED
+
+
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/Connection.h"
+#include "Poco/MongoDB/Document.h"
+#include "Poco/MongoDB/QueryRequest.h"
+#include "Poco/MongoDB/InsertRequest.h"
+#include "Poco/MongoDB/UpdateRequest.h"
+#include "Poco/MongoDB/DeleteRequest.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API Database
+	/// Database is a helper class for creating requests. MongoDB works with
+	/// collection names and uses the part before the first dot as the name of
+	/// the database.
+{
+public:
+	explicit Database(const std::string& name);
+		/// Creates a Database for the database with the given name.
+
+	virtual ~Database();
+		/// Destroys the Database.
+		
+	bool authenticate(Connection& connection, const std::string& username, const std::string& password, const std::string& method = AUTH_SCRAM_SHA1);
+		/// Authenticates against the database using the given connection,
+		/// username and password, as well as authentication method.
+		///
+		/// "MONGODB-CR" (default prior to MongoDB 3.0) and 
+		/// "SCRAM-SHA-1" (default starting in 3.0) are the only supported 
+		/// authentication methods.
+		///
+		/// Returns true if authentication was successful, otherwise false.
+		///
+		/// May throw a Poco::ProtocolException if authentication fails for a reason other than
+		/// invalid credentials.
+
+	Int64 count(Connection& connection, const std::string& collectionName) const;
+		/// Sends a count request for the given collection to MongoDB. 
+		///
+		/// If the command fails, -1 is returned.
+
+	Poco::SharedPtr<Poco::MongoDB::QueryRequest> createCommand() const;
+		/// Creates a QueryRequest for a command.
+
+	Poco::SharedPtr<Poco::MongoDB::QueryRequest> createCountRequest(const std::string& collectionName) const;
+		/// Creates a QueryRequest to count the given collection. 
+		/// The collectionname must not contain the database name.
+
+	Poco::SharedPtr<Poco::MongoDB::DeleteRequest> createDeleteRequest(const std::string& collectionName) const;
+		/// Creates a DeleteRequest to delete documents in the given collection.
+		/// The collectionname must not contain the database name.
+
+	Poco::SharedPtr<Poco::MongoDB::InsertRequest> createInsertRequest(const std::string& collectionName) const;
+		/// Creates an InsertRequest to insert new documents in the given collection.
+		/// The collectionname must not contain the database name.
+
+	Poco::SharedPtr<Poco::MongoDB::QueryRequest> createQueryRequest(const std::string& collectionName) const;
+		/// Creates a QueryRequest. 
+		/// The collectionname must not contain the database name.
+
+	Poco::SharedPtr<Poco::MongoDB::UpdateRequest> createUpdateRequest(const std::string& collectionName) const;
+		/// Creates an UpdateRequest. 
+		/// The collectionname must not contain the database name.
+
+	Poco::MongoDB::Document::Ptr ensureIndex(Connection& connection,
+		const std::string& collection,
+		const std::string& indexName,
+		Poco::MongoDB::Document::Ptr keys,
+		bool unique = false,
+		bool background = false,
+		int version = 0,
+		int ttl = 0);
+		/// Creates an index. The document returned is the result of a getLastError call.
+		/// For more info look at the ensureIndex information on the MongoDB website.
+
+	Document::Ptr getLastErrorDoc(Connection& connection) const;
+		/// Sends the getLastError command to the database and returns the error document.
+
+	std::string getLastError(Connection& connection) const;
+		/// Sends the getLastError command to the database and returns the err element
+		/// from the error document. When err is null, an empty string is returned.
+
+	static const std::string AUTH_MONGODB_CR;
+		/// Default authentication mechanism prior to MongoDB 3.0.
+		
+	static const std::string AUTH_SCRAM_SHA1;
+		/// Default authentication mechanism for MongoDB 3.0.
+
+protected:
+	bool authCR(Connection& connection, const std::string& username, const std::string& password);
+	bool authSCRAM(Connection& connection, const std::string& username, const std::string& password);
+
+private:
+	std::string _dbname;
+};
+
+
+//
+// inlines
+//
+inline Poco::SharedPtr<Poco::MongoDB::QueryRequest> Database::createCommand() const
+{
+	Poco::SharedPtr<Poco::MongoDB::QueryRequest> cmd = createQueryRequest("$cmd");
+	cmd->setNumberToReturn(1);
+	return cmd;
+}
+
+
+inline Poco::SharedPtr<Poco::MongoDB::DeleteRequest>
+Database::createDeleteRequest(const std::string& collectionName) const
+{
+	return new Poco::MongoDB::DeleteRequest(_dbname + '.' + collectionName);
+}
+
+
+inline Poco::SharedPtr<Poco::MongoDB::InsertRequest>
+Database::createInsertRequest(const std::string& collectionName) const
+{
+	return new Poco::MongoDB::InsertRequest(_dbname + '.' + collectionName);
+}
+
+
+inline Poco::SharedPtr<Poco::MongoDB::QueryRequest>
+Database::createQueryRequest(const std::string& collectionName) const
+{
+	return new Poco::MongoDB::QueryRequest(_dbname + '.' + collectionName);
+}
+
+
+inline Poco::SharedPtr<Poco::MongoDB::UpdateRequest>
+Database::createUpdateRequest(const std::string& collectionName) const
+{
+	return new Poco::MongoDB::UpdateRequest(_dbname + '.' + collectionName);
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_Database_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/DeleteRequest.h b/base/poco/MongoDB/include/Poco/MongoDB/DeleteRequest.h
new file mode 100644
index 00000000000..8f3486d07fe
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/DeleteRequest.h
@@ -0,0 +1,113 @@
+//
+// DeleteRequest.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  DeleteRequest
+//
+// Definition of the DeleteRequest class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_DeleteRequest_INCLUDED
+#define MongoDB_DeleteRequest_INCLUDED
+
+
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/RequestMessage.h"
+#include "Poco/MongoDB/Document.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API DeleteRequest: public RequestMessage
+	/// A DeleteRequest is used to delete one ore more documents from a database.
+	///
+	/// Specific flags for this request
+	///   - DELETE_DEFAULT: default delete operation
+	///   - DELETE_SINGLE_REMOVE: delete only the first document
+{
+public:
+	enum Flags
+	{
+		DELETE_DEFAULT = 0,
+			/// Default
+
+		DELETE_SINGLE_REMOVE = 1
+			/// Delete only the first document.
+	};
+
+	DeleteRequest(const std::string& collectionName, Flags flags = DELETE_DEFAULT);
+		/// Creates a DeleteRequest for the given collection using the given flags. 
+		///
+		/// The full collection name is the concatenation of the database 
+		/// name with the collection name, using a "." for the concatenation. For example, 
+		/// for the database "foo" and the collection "bar", the full collection name is 
+		/// "foo.bar".
+
+	DeleteRequest(const std::string& collectionName, bool justOne);
+		/// Creates a DeleteRequest for the given collection.
+		/// 
+		/// The full collection name is the concatenation of the database
+		/// name with the collection name, using a "." for the concatenation. For example,
+		/// for the database "foo" and the collection "bar", the full collection name is
+		/// "foo.bar". 
+		///
+		/// If justOne is true, only the first matching document will
+		/// be removed (the same as using flag DELETE_SINGLE_REMOVE).
+
+	virtual ~DeleteRequest();
+		/// Destructor
+
+	Flags flags() const;
+		/// Returns the flags.
+
+	void flags(Flags flag);
+		/// Sets the flags.
+
+	Document& selector();
+		/// Returns the selector document.
+
+protected:
+	void buildRequest(BinaryWriter& writer);
+		/// Writes the OP_DELETE request to the writer.
+
+private:
+	Flags       _flags;
+	std::string _fullCollectionName;
+	Document    _selector;
+};
+
+
+///
+/// inlines
+///
+inline DeleteRequest::Flags DeleteRequest::flags() const
+{
+	return _flags;
+}
+
+
+inline void DeleteRequest::flags(DeleteRequest::Flags flags)
+{
+	_flags = flags;
+}
+
+
+inline Document& DeleteRequest::selector()
+{
+	return _selector;
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_DeleteRequest_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/Document.h b/base/poco/MongoDB/include/Poco/MongoDB/Document.h
new file mode 100644
index 00000000000..674a1f789f5
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/Document.h
@@ -0,0 +1,277 @@
+//
+// Document.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  Document
+//
+// Definition of the Document class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_Document_INCLUDED
+#define MongoDB_Document_INCLUDED
+
+
+#include "Poco/BinaryReader.h"
+#include "Poco/BinaryWriter.h"
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/Element.h"
+#include <algorithm>
+#include <cstdlib>
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class ElementFindByName
+{
+public:
+	ElementFindByName(const std::string& name): 
+		_name(name)
+	{
+	}
+
+	bool operator()(const Element::Ptr& element)
+	{
+		return !element.isNull() && element->name() == _name;
+	}
+
+private:
+	std::string _name;
+};
+
+
+class MongoDB_API Document
+	/// Represents a MongoDB (BSON) document.
+{
+public:
+	typedef SharedPtr<Document> Ptr;
+	typedef std::vector<Document::Ptr> Vector;
+
+	Document();
+		/// Creates an empty Document.
+
+	virtual ~Document();
+		/// Destroys the Document.
+
+	Document& addElement(Element::Ptr element);
+		/// Add an element to the document.
+		///
+		/// The active document is returned to allow chaining of the add methods.
+
+	template<typename T>
+	Document& add(const std::string& name, T value)
+		/// Creates an element with the given name and value and
+		/// adds it to the document.
+		///
+		/// The active document is returned to allow chaining of the add methods.
+	{
+		return addElement(new ConcreteElement<T>(name, value));
+	}
+
+	Document& add(const std::string& name, const char* value)
+		/// Creates an element with the given name and value and
+		/// adds it to the document.
+		///
+		/// The active document is returned to allow chaining of the add methods.
+	{
+		return addElement(new ConcreteElement<std::string>(name, std::string(value)));
+	}
+
+	Document& addNewDocument(const std::string& name);
+		/// Create a new document and add it to this document.
+		/// Unlike the other add methods, this method returns
+		/// a reference to the new document.
+
+	void clear();
+		/// Removes all elements from the document.
+
+	void elementNames(std::vector<std::string>& keys) const;
+		/// Puts all element names into std::vector.
+
+	bool empty() const;
+		/// Returns true if the document doesn't contain any documents.
+
+	bool exists(const std::string& name);
+		/// Returns true if the document has an element with the given name.
+
+	template<typename T>
+	T get(const std::string& name) const
+		/// Returns the element with the given name and tries to convert
+		/// it to the template type. When the element is not found, a
+		/// NotFoundException will be thrown. When the element can't be
+		/// converted a BadCastException will be thrown.
+	{
+		Element::Ptr element = get(name);
+		if (element.isNull())
+		{
+			throw NotFoundException(name);
+		}
+		else
+		{
+			if (ElementTraits<T>::TypeId == element->type())
+			{
+				ConcreteElement<T>* concrete = dynamic_cast<ConcreteElement<T>* >(element.get());
+				if (concrete != 0)
+				{
+					return concrete->value();
+				}
+			}
+			throw BadCastException("Invalid type mismatch!");
+		}
+	}
+
+	template<typename T>
+	T get(const std::string& name, const T& def) const
+		/// Returns the element with the given name and tries to convert
+		/// it to the template type. When the element is not found, or
+		/// has the wrong type, the def argument will be returned.
+	{
+		Element::Ptr element = get(name);
+		if (element.isNull())
+		{
+			return def;
+		}
+
+		if (ElementTraits<T>::TypeId == element->type())
+		{
+			ConcreteElement<T>* concrete = dynamic_cast<ConcreteElement<T>* >(element.get());
+			if (concrete != 0)
+			{
+				return concrete->value();
+			}
+		}
+
+		return def;
+	}
+
+	Element::Ptr get(const std::string& name) const;
+		/// Returns the element with the given name.
+		/// An empty element will be returned when the element is not found.
+
+	Int64 getInteger(const std::string& name) const;
+		/// Returns an integer. Useful when MongoDB returns Int32, Int64
+		/// or double for a number (count for example). This method will always
+		/// return an Int64. When the element is not found, a
+		/// Poco::NotFoundException will be thrown.
+
+	template<typename T>
+	bool isType(const std::string& name) const
+		/// Returns true when the type of the element equals the TypeId of ElementTrait.
+	{
+		Element::Ptr element = get(name);
+		if (element.isNull())
+		{
+			return false;
+		}
+
+		return ElementTraits<T>::TypeId == element->type();
+	}
+
+	void read(BinaryReader& reader);
+		/// Reads a document from the reader
+
+	std::size_t size() const;
+		/// Returns the number of elements in the document.
+
+	virtual std::string toString(int indent = 0) const;
+		/// Returns a String representation of the document.
+
+	void write(BinaryWriter& writer);
+		/// Writes a document to the reader
+
+protected:
+	ElementSet _elements;
+};
+
+
+//
+// inlines
+//
+inline Document& Document::addElement(Element::Ptr element)
+{
+	_elements.push_back(element);
+	return *this;
+}
+
+
+inline Document& Document::addNewDocument(const std::string& name)
+{
+	Document::Ptr newDoc = new Document();
+	add(name, newDoc);
+	return *newDoc;
+}
+
+
+inline void Document::clear()
+{
+	_elements.clear();
+}
+
+
+inline bool Document::empty() const
+{
+	return _elements.empty();
+}
+
+
+inline void Document::elementNames(std::vector<std::string>& keys) const
+{
+	for (ElementSet::const_iterator it = _elements.begin(); it != _elements.end(); ++it)
+	{
+		keys.push_back((*it)->name());
+	}
+}
+
+
+inline bool Document::exists(const std::string& name)
+{
+	return std::find_if(_elements.begin(), _elements.end(), ElementFindByName(name)) != _elements.end();
+}
+
+
+inline std::size_t Document::size() const
+{
+	return _elements.size();
+}
+
+
+// BSON Embedded Document
+// spec: document
+template<>
+struct ElementTraits<Document::Ptr>
+{
+	enum { TypeId = 0x03 };
+
+	static std::string toString(const Document::Ptr& value, int indent = 0)
+	{
+		return value.isNull() ? "null" : value->toString(indent);
+	}
+};
+
+
+template<>
+inline void BSONReader::read<Document::Ptr>(Document::Ptr& to)
+{
+	to->read(_reader);
+}
+
+
+template<>
+inline void BSONWriter::write<Document::Ptr>(Document::Ptr& from)
+{
+	from->write(_writer);
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_Document_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/Element.h b/base/poco/MongoDB/include/Poco/MongoDB/Element.h
new file mode 100644
index 00000000000..e6a41c4016b
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/Element.h
@@ -0,0 +1,403 @@
+//
+// Element.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  Element
+//
+// Definition of the Element class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_Element_INCLUDED
+#define MongoDB_Element_INCLUDED
+
+
+#include "Poco/BinaryReader.h"
+#include "Poco/BinaryWriter.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Timestamp.h"
+#include "Poco/Nullable.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/DateTimeFormatter.h"
+#include "Poco/UTF8String.h"
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/BSONReader.h"
+#include "Poco/MongoDB/BSONWriter.h"
+#include <string>
+#include <sstream>
+#include <iomanip>
+#include <list>
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API Element
+	/// Represents an Element of a Document or an Array.
+{
+public:
+	typedef Poco::SharedPtr<Element> Ptr;
+
+	explicit Element(const std::string& name);
+		/// Creates the Element with the given name.
+
+	virtual ~Element();
+		/// Destructor
+
+	const std::string& name() const;
+		/// Returns the name of the element.
+
+	virtual std::string toString(int indent = 0) const = 0;
+		/// Returns a string representation of the element.
+
+	virtual int type() const = 0;
+		/// Returns the MongoDB type of the element.
+
+private:
+	virtual void read(BinaryReader& reader) = 0;
+	virtual void write(BinaryWriter& writer) = 0;
+
+	friend class Document;
+	std::string _name;
+};
+
+
+//
+// inlines
+//
+inline const std::string& Element::name() const
+{
+	return _name;
+}
+
+
+typedef std::list<Element::Ptr> ElementSet;
+
+
+template<typename T> 
+struct ElementTraits
+{
+};
+
+
+// BSON Floating point
+// spec: double
+template<>
+struct ElementTraits<double>
+{
+	enum { TypeId = 0x01 };
+
+	static std::string toString(const double& value, int indent = 0)
+	{
+		return Poco::NumberFormatter::format(value);
+	}
+};
+
+
+// BSON UTF-8 string
+// spec: int32 (byte*) "\x00"
+// int32 is the number bytes in byte* + 1 (for trailing "\x00")
+template<>
+struct ElementTraits<std::string>
+{
+	enum { TypeId = 0x02 };
+
+	static std::string toString(const std::string& value, int indent = 0)
+	{
+		std::ostringstream oss;
+
+		oss << '"';
+
+		for (std::string::const_iterator it = value.begin(); it != value.end(); ++it)
+		{
+			switch (*it)
+			{
+			case '"':
+				oss << "\\\"";
+				break;
+			case '\\':
+				oss << "\\\\";
+				break;
+			case '\b':
+				oss << "\\b";
+				break;
+			case '\f':
+				oss << "\\f";
+				break;
+			case '\n':
+				oss << "\\n";
+				break;
+			case '\r':
+				oss << "\\r";
+				break;
+			case '\t':
+				oss << "\\t";
+				break;
+			default:
+				{
+					if ( *it > 0 && *it <= 0x1F )
+					{
+						oss << "\\u" << std::hex << std::uppercase << std::setfill('0') << std::setw(4) << static_cast<int>(*it);
+					}
+					else
+					{
+						oss << *it;
+					}
+					break;
+				}
+			}
+		}
+		oss << '"';
+		return oss.str();
+	}
+};
+
+
+template<>
+inline void BSONReader::read<std::string>(std::string& to)
+{
+	Poco::Int32 size;
+	_reader >> size;
+	_reader.readRaw(size, to);
+	to.erase(to.end() - 1); // remove terminating 0
+}
+
+
+template<>
+inline void BSONWriter::write<std::string>(std::string& from)
+{
+	_writer << (Poco::Int32) (from.length() + 1);
+	writeCString(from);
+}
+
+
+// BSON bool
+// spec: "\x00" "\x01"
+template<>
+struct ElementTraits<bool>
+{
+	enum { TypeId = 0x08 };
+
+	static std::string toString(const bool& value, int indent = 0)
+	{
+		return value ? "true" : "false";
+	}
+};
+
+
+template<>
+inline void BSONReader::read<bool>(bool& to)
+{
+	unsigned char b;
+	_reader >> b;
+	to = b != 0;
+}
+
+
+template<>
+inline void BSONWriter::write<bool>(bool& from)
+{
+	unsigned char b = from ? 0x01 : 0x00;
+	_writer << b;
+}
+
+
+// BSON 32-bit integer
+// spec: int32
+template<>
+struct ElementTraits<Int32>
+{
+	enum { TypeId = 0x10 };
+
+
+	static std::string toString(const Int32& value, int indent = 0)
+	{
+		return Poco::NumberFormatter::format(value);
+	}
+};
+
+
+// BSON UTC datetime
+// spec: int64
+template<>
+struct ElementTraits<Timestamp>
+{
+	enum { TypeId = 0x09 };
+
+	static std::string toString(const Timestamp& value, int indent = 0)
+	{
+		std::string result;
+		result.append(1, '"');
+		result.append(DateTimeFormatter::format(value, "%Y-%m-%dT%H:%M:%s%z"));
+		result.append(1, '"');
+		return result;
+	}
+};
+
+
+template<>
+inline void BSONReader::read<Timestamp>(Timestamp& to)
+{
+	Poco::Int64 value;
+	_reader >> value;
+	to = Timestamp::fromEpochTime(static_cast<std::time_t>(value / 1000));
+	to += (value % 1000 * 1000);
+}
+
+
+template<>
+inline void BSONWriter::write<Timestamp>(Timestamp& from)
+{
+	_writer << (from.epochMicroseconds() / 1000);
+}
+
+
+typedef Nullable<unsigned char> NullValue;
+
+
+// BSON Null Value
+// spec:
+template<>
+struct ElementTraits<NullValue>
+{
+	enum { TypeId = 0x0A };
+
+	static std::string toString(const NullValue& value, int indent = 0)
+	{
+		return "null";
+	}
+};
+
+
+template<>
+inline void BSONReader::read<NullValue>(NullValue& to)
+{
+}
+
+
+template<>
+inline void BSONWriter::write<NullValue>(NullValue& from)
+{
+}
+
+
+struct BSONTimestamp 
+{
+	Poco::Timestamp ts;
+	Poco::Int32 inc;
+};
+
+
+// BSON Timestamp
+// spec: int64
+template<>
+struct ElementTraits<BSONTimestamp>
+{
+	enum { TypeId = 0x11 };
+
+	static std::string toString(const BSONTimestamp& value, int indent = 0)
+	{
+		std::string result;
+		result.append(1, '"');
+		result.append(DateTimeFormatter::format(value.ts, "%Y-%m-%dT%H:%M:%s%z"));
+		result.append(1, ' ');
+		result.append(NumberFormatter::format(value.inc));
+		result.append(1, '"');
+		return result;
+	}
+};
+
+
+template<>
+inline void BSONReader::read<BSONTimestamp>(BSONTimestamp& to)
+{
+	Poco::Int64 value;
+	_reader >> value;
+	to.inc = value & 0xffffffff;
+	value >>= 32;
+	to.ts = Timestamp::fromEpochTime(static_cast<std::time_t>(value));
+}
+
+
+template<>
+inline void BSONWriter::write<BSONTimestamp>(BSONTimestamp& from)
+{
+	Poco::Int64 value = from.ts.epochMicroseconds() / 1000;
+	value <<= 32;
+	value += from.inc;
+	_writer << value;
+}
+
+
+// BSON 64-bit integer
+// spec: int64
+template<>
+struct ElementTraits<Int64>
+{
+	enum { TypeId = 0x12 };
+
+	static std::string toString(const Int64& value, int indent = 0)
+	{
+		return NumberFormatter::format(value);
+	}
+};
+
+
+template<typename T>
+class ConcreteElement: public Element
+{
+public:
+	ConcreteElement(const std::string& name, const T& init):
+		Element(name), 
+		_value(init)
+	{
+	}
+
+	virtual ~ConcreteElement()
+	{
+	}
+
+	
+	T value() const
+	{
+		return _value;
+	}
+
+
+	std::string toString(int indent = 0) const
+	{
+		return ElementTraits<T>::toString(_value, indent);
+	}
+
+	
+	int type() const
+	{
+		return ElementTraits<T>::TypeId;
+	}
+
+	void read(BinaryReader& reader)
+	{
+		BSONReader(reader).read(_value);
+	}
+
+	void write(BinaryWriter& writer)
+	{
+		BSONWriter(writer).write(_value);
+	}
+
+private:
+	T _value;
+};
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_Element_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/GetMoreRequest.h b/base/poco/MongoDB/include/Poco/MongoDB/GetMoreRequest.h
new file mode 100644
index 00000000000..f6c3f65ab08
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/GetMoreRequest.h
@@ -0,0 +1,89 @@
+//
+// GetMoreRequest.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  GetMoreRequest
+//
+// Definition of the GetMoreRequest class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_GetMoreRequest_INCLUDED
+#define MongoDB_GetMoreRequest_INCLUDED
+
+
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/RequestMessage.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API GetMoreRequest: public RequestMessage
+	/// A GetMoreRequest is used to query the database for more documents in a collection 
+	/// after a query request is send (OP_GETMORE).
+{
+public:
+	GetMoreRequest(const std::string& collectionName, Int64 cursorID);
+		/// Creates a GetMoreRequest for the give collection and cursor. 
+		///
+		/// The full collection name is the concatenation of the database 
+		/// name with the collection name, using a "." for the concatenation. For example, 
+		/// for the database "foo" and the collection "bar", the full collection name is 
+		/// "foo.bar". The cursorID has been returned by the response on the query request.
+		/// By default the numberToReturn is set to 100.
+
+	virtual ~GetMoreRequest();
+		/// Destroys the GetMoreRequest.
+
+	Int32 getNumberToReturn() const;
+		/// Returns the limit of returned documents.
+
+	void setNumberToReturn(Int32 n);
+		/// Sets the limit of returned documents.
+
+	Int64 cursorID() const;
+		/// Returns the cursor ID.
+
+protected:
+	void buildRequest(BinaryWriter& writer);
+
+private:
+	std::string _fullCollectionName;
+	Int32 _numberToReturn;
+	Int64 _cursorID;
+};
+
+
+//
+// inlines
+//
+inline Int32 GetMoreRequest::getNumberToReturn() const
+{
+	return _numberToReturn;
+}
+
+
+inline void GetMoreRequest::setNumberToReturn(Int32 n)
+{
+	_numberToReturn = n;
+}
+
+
+inline Int64 GetMoreRequest::cursorID() const
+{
+	return _cursorID;
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_GetMoreRequest_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/InsertRequest.h b/base/poco/MongoDB/include/Poco/MongoDB/InsertRequest.h
new file mode 100644
index 00000000000..f9ed8a20b57
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/InsertRequest.h
@@ -0,0 +1,97 @@
+//
+// InsertRequest.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  InsertRequest
+//
+// Definition of the InsertRequest class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_InsertRequest_INCLUDED
+#define MongoDB_InsertRequest_INCLUDED
+
+
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/RequestMessage.h"
+#include "Poco/MongoDB/Document.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API InsertRequest: public RequestMessage
+	/// A request for inserting one or more documents to the database
+	/// (OP_INSERT).
+{
+public:
+	enum Flags
+	{
+		INSERT_DEFAULT = 0,
+			/// If specified, perform a normal insert operation.
+		
+		INSERT_CONTINUE_ON_ERROR = 1
+			/// If set, the database will not stop processing a bulk insert if one 
+			/// fails (e.g. due to duplicate IDs). This makes bulk insert behave similarly 
+			/// to a series of single inserts, except lastError will be set if any insert 
+			/// fails, not just the last one. If multiple errors occur, only the most 
+			/// recent will be reported.
+	};
+
+	InsertRequest(const std::string& collectionName, Flags flags = INSERT_DEFAULT);
+		/// Creates an InsertRequest.
+		///
+		/// The full collection name is the concatenation of the database 
+		/// name with the collection name, using a "." for the concatenation. For example, 
+		/// for the database "foo" and the collection "bar", the full collection name is 
+		/// "foo.bar".
+
+	virtual ~InsertRequest();
+		/// Destroys the InsertRequest.
+
+	Document& addNewDocument();
+		/// Adds a new document for insertion. A reference to the empty document is
+		/// returned. InsertRequest is the owner of the Document and will free it
+		/// on destruction.
+
+	Document::Vector& documents();
+		/// Returns the documents to insert into the database.
+
+protected:
+	void buildRequest(BinaryWriter& writer);
+
+private:
+	Int32 _flags;
+	std::string _fullCollectionName;
+	Document::Vector _documents;
+};
+
+
+//
+// inlines
+//
+inline Document& InsertRequest::addNewDocument()
+{
+	Document::Ptr doc = new Document();
+	_documents.push_back(doc);
+	return *doc;
+}
+
+
+inline Document::Vector& InsertRequest::documents()
+{
+	return _documents;
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_InsertRequest_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/JavaScriptCode.h b/base/poco/MongoDB/include/Poco/MongoDB/JavaScriptCode.h
new file mode 100644
index 00000000000..6401743b88a
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/JavaScriptCode.h
@@ -0,0 +1,105 @@
+//
+// JavaScriptCode.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  JavaScriptCode
+//
+// Definition of the JavaScriptCode class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_JavaScriptCode_INCLUDED
+#define MongoDB_JavaScriptCode_INCLUDED
+
+
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/BSONReader.h"
+#include "Poco/MongoDB/BSONWriter.h"
+#include "Poco/MongoDB/Element.h"
+#include "Poco/SharedPtr.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API JavaScriptCode
+	/// Represents JavaScript type in BSON.
+{
+public:
+	typedef SharedPtr<JavaScriptCode> Ptr;
+
+	JavaScriptCode();
+		/// Creates an empty JavaScriptCode object.
+
+	virtual ~JavaScriptCode();
+		/// Destroys the JavaScriptCode.
+
+	void setCode(const std::string& code);
+		/// Sets the JavaScript code.
+
+	std::string getCode() const;
+		/// Returns the JavaScript code.
+
+private:
+	std::string _code;
+};
+
+
+//
+// inlines
+//
+inline void JavaScriptCode::setCode(const std::string& code)
+{
+	_code = code;
+}
+
+
+inline std::string JavaScriptCode::getCode() const
+{
+	return _code;
+}
+
+
+// BSON JavaScript code
+// spec: string
+template<>
+struct ElementTraits<JavaScriptCode::Ptr>
+{
+	enum { TypeId = 0x0D };
+
+	static std::string toString(const JavaScriptCode::Ptr& value, int indent = 0)
+	{
+		return value.isNull() ? "" : value->getCode();
+	}
+};
+
+
+template<>
+inline void BSONReader::read<JavaScriptCode::Ptr>(JavaScriptCode::Ptr& to)
+{
+	std::string code;
+	BSONReader(_reader).read(code);
+	to = new JavaScriptCode();
+	to->setCode(code);
+}
+
+
+template<>
+inline void BSONWriter::write<JavaScriptCode::Ptr>(JavaScriptCode::Ptr& from)
+{
+	std::string code = from->getCode();
+	BSONWriter(_writer).write(code);
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_JavaScriptCode_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/KillCursorsRequest.h b/base/poco/MongoDB/include/Poco/MongoDB/KillCursorsRequest.h
new file mode 100644
index 00000000000..83a808535ba
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/KillCursorsRequest.h
@@ -0,0 +1,62 @@
+//
+// KillCursorsRequest.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  KillCursorsRequest
+//
+// Definition of the KillCursorsRequest class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_KillCursorsRequest_INCLUDED
+#define MongoDB_KillCursorsRequest_INCLUDED
+
+
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/RequestMessage.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API KillCursorsRequest: public RequestMessage
+	/// Class for creating an OP_KILL_CURSORS client request. This
+	/// request is used to kill cursors, which are still open, 
+	/// returned by query requests.
+{
+public:
+	KillCursorsRequest();
+		/// Creates a KillCursorsRequest.
+
+	virtual ~KillCursorsRequest();
+		/// Destroys the KillCursorsRequest.
+		
+	std::vector<Int64>& cursors();
+		/// The internal list of cursors.
+		
+protected:
+	void buildRequest(BinaryWriter& writer);
+	std::vector<Int64> _cursors;
+};
+
+
+//
+// inlines
+//
+inline std::vector<Int64>& KillCursorsRequest::cursors()
+{
+	return _cursors;
+} 
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_KillCursorsRequest_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/Message.h b/base/poco/MongoDB/include/Poco/MongoDB/Message.h
new file mode 100644
index 00000000000..f3f1edb439d
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/Message.h
@@ -0,0 +1,73 @@
+//
+// Message.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  Message
+//
+// Definition of the Message class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_Message_INCLUDED
+#define MongoDB_Message_INCLUDED
+
+
+#include "Poco/Net/Socket.h"
+#include "Poco/BinaryReader.h"
+#include "Poco/BinaryWriter.h"
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/MessageHeader.h"
+#include <sstream>
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API Message
+	/// Base class for all messages send or retrieved from MongoDB server.
+{
+public:
+	explicit Message(MessageHeader::OpCode opcode);
+		/// Creates a Message using the given OpCode.
+	
+	virtual ~Message();
+		/// Destructor
+
+	MessageHeader& header();
+		/// Returns the message header
+
+protected:
+	MessageHeader _header;
+
+	void messageLength(Poco::Int32 length);
+		/// Sets the message length in the message header
+};
+
+
+//
+// inlines
+//
+inline MessageHeader& Message::header()
+{
+	return _header;
+}
+
+
+inline void Message::messageLength(Poco::Int32 length)
+{
+	poco_assert(length > 0);
+	_header.setMessageLength(length);
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_Message_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/MessageHeader.h b/base/poco/MongoDB/include/Poco/MongoDB/MessageHeader.h
new file mode 100644
index 00000000000..1f86612aa0e
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/MessageHeader.h
@@ -0,0 +1,130 @@
+//
+// MessageHeader.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  MessageHeader
+//
+// Definition of the MessageHeader class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_MessageHeader_INCLUDED
+#define MongoDB_MessageHeader_INCLUDED
+
+
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/MessageHeader.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API MessageHeader
+	/// Represents the message header which is always prepended to a 
+	/// MongoDB request or response message.
+{
+public:
+	static const unsigned int MSG_HEADER_SIZE = 16;
+
+	enum OpCode
+	{
+		OP_REPLY = 1,
+		OP_MSG = 1000,
+		OP_UPDATE = 2001,
+		OP_INSERT = 2002,
+		OP_QUERY = 2004,
+		OP_GET_MORE = 2005,
+		OP_DELETE = 2006,
+		OP_KILL_CURSORS = 2007
+	};
+
+	explicit MessageHeader(OpCode);
+		/// Creates the MessageHeader using the given OpCode.
+
+	virtual ~MessageHeader();
+		/// Destroys the MessageHeader.
+
+	void read(BinaryReader& reader);
+		/// Reads the header using the given BinaryReader.
+
+	void write(BinaryWriter& writer);
+		/// Writes the header using the given BinaryWriter.
+
+	Int32 getMessageLength() const;
+		/// Returns the message length.
+
+	OpCode opCode() const;
+		/// Returns the OpCode.
+
+	Int32 getRequestID() const;
+		/// Returns the request ID of the current message.
+
+	void setRequestID(Int32 id);
+		/// Sets the request ID of the current message.
+
+	Int32 responseTo() const;
+		/// Returns the request id from the original request. 
+
+private:
+	void setMessageLength(Int32 length);
+		/// Sets the message length.
+
+	Int32 _messageLength;
+	Int32 _requestID;
+	Int32 _responseTo;
+	OpCode _opCode;
+
+	friend class Message;
+};
+
+
+//
+// inlines
+//
+inline MessageHeader::OpCode MessageHeader::opCode() const
+{
+	return _opCode;
+}
+
+
+inline Int32 MessageHeader::getMessageLength() const
+{
+	return _messageLength;
+}
+
+
+inline void MessageHeader::setMessageLength(Int32 length)
+{
+	poco_assert (_messageLength >= 0);
+	_messageLength = MSG_HEADER_SIZE + length;
+}
+
+
+inline void MessageHeader::setRequestID(Int32 id)
+{
+	_requestID = id;
+}
+
+
+inline Int32 MessageHeader::getRequestID() const
+{
+	return _requestID;
+}
+
+inline Int32 MessageHeader::responseTo() const
+{
+	return _responseTo;
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_MessageHeader_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/MongoDB.h b/base/poco/MongoDB/include/Poco/MongoDB/MongoDB.h
new file mode 100644
index 00000000000..8e2126f1293
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/MongoDB.h
@@ -0,0 +1,64 @@
+//
+// MongoDB.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  MongoDB
+//
+// Basic definitions for the Poco MongoDB library.
+// This file must be the first file included by every other MongoDB
+// header file.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDBMongoDB_INCLUDED
+#define MongoDBMongoDB_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+//
+// The following block is the standard way of creating macros which make exporting
+// from a DLL simpler. All files within this DLL are compiled with the MongoDB_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any project
+// that uses this DLL. This way any other project whose source files include this file see
+// MongoDB_API functions as being imported from a DLL, whereas this DLL sees symbols
+// defined with this macro as being exported.
+//
+
+
+#if defined(_WIN32) && defined(POCO_DLL)
+	#if defined(MongoDB_EXPORTS)
+		#define MongoDB_API __declspec(dllexport)
+	#else
+		#define MongoDB_API __declspec(dllimport)
+	#endif
+#endif
+
+
+#if !defined(MongoDB_API)
+	#if !defined(POCO_NO_GCC_API_ATTRIBUTE) && defined (__GNUC__) && (__GNUC__ >= 4)
+		#define MongoDB_API __attribute__ ((visibility ("default")))
+	#else
+		#define MongoDB_API
+	#endif
+#endif
+
+
+//
+// Automatically link MongoDB library.
+//
+#if defined(_MSC_VER)
+	#if !defined(POCO_NO_AUTOMATIC_LIBS) && !defined(MongoDB_EXPORTS)
+		#pragma comment(lib, "PocoMongoDB" POCO_LIB_SUFFIX)
+	#endif
+#endif
+
+
+#endif // MongoDBMongoDB_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/ObjectId.h b/base/poco/MongoDB/include/Poco/MongoDB/ObjectId.h
new file mode 100644
index 00000000000..659047c95f0
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/ObjectId.h
@@ -0,0 +1,147 @@
+//
+// Array.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  ObjectId
+//
+// Definition of the ObjectId class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_ObjectId_INCLUDED
+#define MongoDB_ObjectId_INCLUDED
+
+
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/Element.h"
+#include "Poco/Timestamp.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API ObjectId
+	/// ObjectId is a 12-byte BSON type, constructed using:
+	///
+	///   - a 4-byte timestamp,
+	///   - a 3-byte machine identifier,
+	///   - a 2-byte process id, and
+	///   - a 3-byte counter, starting with a random value.
+	///
+	/// In MongoDB, documents stored in a collection require a unique _id field that acts
+	/// as a primary key. Because ObjectIds are small, most likely unique, and fast to generate,
+	/// MongoDB uses ObjectIds as the default value for the _id field if the _id field is not
+	/// specified; i.e., the mongod adds the _id field and generates a unique ObjectId to assign
+	/// as its value.
+{
+public:
+	typedef SharedPtr<ObjectId> Ptr;
+
+	explicit ObjectId(const std::string& id);
+		/// Creates an ObjectId from a string. 
+		///
+		/// The string must contain a hexadecimal representation
+		/// of an object ID. This means a string of 24 characters.
+
+	ObjectId(const ObjectId& copy);
+		/// Creates an ObjectId by copying another one.
+
+	virtual ~ObjectId();
+		/// Destroys the ObjectId.
+
+	Timestamp timestamp() const;
+		/// Returns the timestamp which is stored in the first four bytes of the id
+
+	std::string toString(const std::string& fmt = "%02x") const;
+		/// Returns the id in string format. The fmt parameter
+		/// specifies the formatting used for individual members 
+		/// of the ID char array.
+
+private:
+	ObjectId();
+
+	static int fromHex(char c);	
+	static char fromHex(const char* c);
+	
+	unsigned char _id[12];
+
+	friend class BSONWriter;
+	friend class BSONReader;
+	friend class Document;
+};
+
+
+//
+// inlines
+//
+inline Timestamp ObjectId::timestamp() const
+{
+	int time;
+	char* T = (char *) &time;
+	T[0] = _id[3];
+	T[1] = _id[2];
+	T[2] = _id[1];
+	T[3] = _id[0];
+	return Timestamp::fromEpochTime((time_t) time);
+}
+
+
+inline int ObjectId::fromHex(char c)
+{
+	if ( '0' <= c && c <= '9' )
+		return c - '0';
+	if ( 'a' <= c && c <= 'f' )
+		return c - 'a' + 10;
+	if ( 'A' <= c && c <= 'F' )
+		return c - 'A' + 10;
+	return 0xff;
+}
+
+
+inline char ObjectId::fromHex(const char* c)
+{
+	return (char)((fromHex(c[0]) << 4 ) | fromHex(c[1]));
+}
+
+
+// BSON Embedded Document
+// spec: ObjectId
+template<>
+struct ElementTraits<ObjectId::Ptr>
+{
+	enum { TypeId = 0x07 };
+
+	static std::string toString(const ObjectId::Ptr& id,
+		int indent = 0,
+		const std::string& fmt = "%02x")
+	{
+		return id->toString(fmt);
+	}
+};
+
+
+template<>
+inline void BSONReader::read<ObjectId::Ptr>(ObjectId::Ptr& to)
+{
+	_reader.readRaw((char*) to->_id, 12);
+}
+
+
+template<>
+inline void BSONWriter::write<ObjectId::Ptr>(ObjectId::Ptr& from)
+{
+	_writer.writeRaw((char*) from->_id, 12);
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_ObjectId_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/PoolableConnectionFactory.h b/base/poco/MongoDB/include/Poco/MongoDB/PoolableConnectionFactory.h
new file mode 100644
index 00000000000..a723eb13b77
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/PoolableConnectionFactory.h
@@ -0,0 +1,128 @@
+//
+// PoolableConnectionFactory.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  PoolableConnectionFactory
+//
+// Definition of the PoolableConnectionFactory class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_PoolableConnectionFactory_INCLUDED
+#define MongoDB_PoolableConnectionFactory_INCLUDED
+
+
+#include "Poco/MongoDB/Connection.h"
+#include "Poco/ObjectPool.h"
+
+
+namespace Poco {
+
+
+template<>
+class PoolableObjectFactory<MongoDB::Connection, MongoDB::Connection::Ptr>
+	/// PoolableObjectFactory specialisation for Connection. New connections
+	/// are created with the given address or URI.
+	///
+	/// If a Connection::SocketFactory is given, it must live for the entire
+	/// lifetime of the PoolableObjectFactory.
+{
+public:
+	PoolableObjectFactory(Net::SocketAddress& address):
+		_address(address),
+		_pSocketFactory(0)
+	{
+	}
+
+	PoolableObjectFactory(const std::string& address):
+		_address(address),
+		_pSocketFactory(0)
+	{
+	}
+
+	PoolableObjectFactory(const std::string& uri, MongoDB::Connection::SocketFactory& socketFactory):
+		_uri(uri),
+		_pSocketFactory(&socketFactory)
+	{
+	}
+
+	MongoDB::Connection::Ptr createObject()
+	{
+		if (_pSocketFactory)
+			return new MongoDB::Connection(_uri, *_pSocketFactory);
+		else
+			return new MongoDB::Connection(_address);
+	}
+
+	bool validateObject(MongoDB::Connection::Ptr pObject)
+	{
+		return true;
+	}
+
+	void activateObject(MongoDB::Connection::Ptr pObject)
+	{
+	}
+
+	void deactivateObject(MongoDB::Connection::Ptr pObject)
+	{
+	}
+
+	void destroyObject(MongoDB::Connection::Ptr pObject)
+	{
+	}
+
+private:
+	Net::SocketAddress _address;
+	std::string _uri;
+	MongoDB::Connection::SocketFactory* _pSocketFactory;
+};
+
+
+namespace MongoDB {
+
+
+class PooledConnection
+	/// Helper class for borrowing and returning a connection automatically from a pool.
+{
+public:
+	PooledConnection(Poco::ObjectPool<Connection, Connection::Ptr>& pool) : _pool(pool)
+	{
+		_connection = _pool.borrowObject();
+	}
+
+	virtual ~PooledConnection()
+	{
+		try
+		{
+			if (_connection)
+			{
+				_pool.returnObject(_connection);
+			}
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	}
+
+	operator Connection::Ptr ()
+	{
+		return _connection;
+	}
+
+private:
+	Poco::ObjectPool<Connection, Connection::Ptr>& _pool;
+	Connection::Ptr _connection;
+};
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_PoolableConnectionFactory_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/QueryRequest.h b/base/poco/MongoDB/include/Poco/MongoDB/QueryRequest.h
new file mode 100644
index 00000000000..410828749b6
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/QueryRequest.h
@@ -0,0 +1,187 @@
+//
+// QueryRequest.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  QueryRequest
+//
+// Definition of the QueryRequest class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_QueryRequest_INCLUDED
+#define MongoDB_QueryRequest_INCLUDED
+
+
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/RequestMessage.h"
+#include "Poco/MongoDB/Document.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API QueryRequest: public RequestMessage
+	/// A request to query documents in a MongoDB database
+	/// using an OP_QUERY request.
+{
+public:
+	enum Flags
+	{
+		QUERY_DEFAULT = 0, 
+			/// Do not set any flags.
+	
+		QUERY_TAILABLE_CURSOR = 2, 
+			/// Tailable means cursor is not closed when the last data is retrieved. 
+			/// Rather, the cursor marks the final object’s position. 
+			/// You can resume using the cursor later, from where it was located, 
+			/// if more data were received. Like any "latent cursor", the cursor may 
+			/// become invalid at some point (CursorNotFound) – for example if the final 
+			/// object it references were deleted.
+	
+		QUERY_SLAVE_OK = 4, 
+			/// Allow query of replica slave. Normally these return an error except 
+			/// for namespace "local".
+			
+		// QUERY_OPLOG_REPLAY = 8 (internal replication use only - drivers should not implement)
+		
+		QUERY_NO_CURSOR_TIMEOUT = 16,
+			/// The server normally times out idle cursors after an inactivity period 
+			/// (10 minutes) to prevent excess memory use. Set this option to prevent that.
+	
+		QUERY_AWAIT_DATA = 32,
+			/// Use with QUERY_TAILABLECURSOR. If we are at the end of the data, block for 
+			/// a while rather than returning no data. After a timeout period, we do 
+			/// return as normal.
+
+		QUERY_EXHAUST = 64,
+			/// Stream the data down full blast in multiple "more" packages, on the 
+			/// assumption that the client will fully read all data queried. 
+			/// Faster when you are pulling a lot of data and know you want to pull 
+			/// it all down. 
+			/// Note: the client is not allowed to not read all the data unless it 
+			/// closes the connection.
+
+		QUERY_PARTIAL = 128
+			/// Get partial results from a mongos if some shards are down 
+			/// (instead of throwing an error).
+	};
+
+	QueryRequest(const std::string& collectionName, Flags flags = QUERY_DEFAULT);
+		/// Creates a QueryRequest.
+		///
+		/// The full collection name is the concatenation of the database 
+		/// name with the collection name, using a "." for the concatenation. For example, 
+		/// for the database "foo" and the collection "bar", the full collection name is 
+		/// "foo.bar".
+
+	virtual ~QueryRequest();
+		/// Destroys the QueryRequest.
+
+	Flags getFlags() const;
+		/// Returns the flags.
+
+	void setFlags(Flags flag);
+		/// Set the flags.
+
+	std::string fullCollectionName() const;
+		/// Returns the <db>.<collection> used for this query.
+
+	Int32 getNumberToSkip() const;
+		/// Returns the number of documents to skip.
+
+	void setNumberToSkip(Int32 n);
+		/// Sets the number of documents to skip.
+
+	Int32 getNumberToReturn() const;
+		/// Returns the number of documents to return.
+
+	void setNumberToReturn(Int32 n);
+		/// Sets the number of documents to return (limit).
+
+	Document& selector();
+		/// Returns the selector document.
+
+	Document& returnFieldSelector();
+		/// Returns the field selector document.
+
+protected:
+	void buildRequest(BinaryWriter& writer);
+
+private:
+	Flags       _flags;
+	std::string _fullCollectionName;
+	Int32       _numberToSkip;
+	Int32       _numberToReturn;
+	Document    _selector;
+	Document    _returnFieldSelector;
+};
+
+
+//
+// inlines
+//
+inline QueryRequest::Flags QueryRequest::getFlags() const
+{
+	return _flags;
+}
+
+
+inline void QueryRequest::setFlags(QueryRequest::Flags flags)
+{
+	_flags = flags;
+}
+
+
+inline std::string QueryRequest::fullCollectionName() const
+{
+	return _fullCollectionName;
+}
+
+
+inline Document& QueryRequest::selector()
+{
+	return _selector;
+}
+
+
+inline Document& QueryRequest::returnFieldSelector()
+{
+	return _returnFieldSelector;
+}
+
+
+inline Int32 QueryRequest::getNumberToSkip() const
+{
+	return _numberToSkip;
+}
+
+
+inline void QueryRequest::setNumberToSkip(Int32 n)
+{
+	_numberToSkip = n;
+}
+
+
+inline Int32 QueryRequest::getNumberToReturn() const
+{
+	return _numberToReturn;
+}
+
+
+inline void QueryRequest::setNumberToReturn(Int32 n)
+{
+	_numberToReturn = n;
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_QueryRequest_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/RegularExpression.h b/base/poco/MongoDB/include/Poco/MongoDB/RegularExpression.h
new file mode 100644
index 00000000000..49ef3b00b0c
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/RegularExpression.h
@@ -0,0 +1,129 @@
+//
+// RegularExpression.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  RegularExpression
+//
+// Definition of the RegularExpression class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_RegularExpression_INCLUDED
+#define MongoDB_RegularExpression_INCLUDED
+
+
+#include "Poco/RegularExpression.h"
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/Element.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API RegularExpression
+	/// Represents a regular expression in BSON format.
+{
+public:
+	typedef SharedPtr<RegularExpression> Ptr;
+
+	RegularExpression();
+		/// Creates an empty RegularExpression.
+
+	RegularExpression(const std::string& pattern, const std::string& options);
+		/// Creates a RegularExpression using the given pattern and options.
+
+	virtual ~RegularExpression();
+		/// Destroys the RegularExpression.
+
+	SharedPtr<Poco::RegularExpression> createRE() const;
+		/// Tries to create a Poco::RegularExpression from the MongoDB regular expression.
+
+	std::string getOptions() const;
+		/// Returns the options string.
+
+	void setOptions(const std::string& options);
+		/// Sets the options string.
+
+	std::string getPattern() const;
+		/// Returns the pattern.
+
+	void setPattern(const std::string& pattern);
+		/// Sets the pattern.
+
+private:
+	std::string _pattern;
+	std::string _options;
+};
+
+
+///
+/// inlines
+///
+inline std::string RegularExpression::getPattern() const
+{
+	return _pattern;
+}
+
+
+inline void RegularExpression::setPattern(const std::string& pattern)
+{
+	_pattern = pattern;
+}
+
+
+inline std::string RegularExpression::getOptions() const
+{
+	return _options;
+}
+
+
+inline void RegularExpression::setOptions(const std::string& options)
+{
+	_options = options;
+}
+
+
+// BSON Regex
+// spec: cstring cstring
+template<>
+struct ElementTraits<RegularExpression::Ptr>
+{
+	enum { TypeId = 0x0B };
+
+	static std::string toString(const RegularExpression::Ptr& value, int indent = 0)
+	{
+		//TODO
+		return "RE: not implemented yet";
+	}
+};
+
+
+template<>
+inline void BSONReader::read<RegularExpression::Ptr>(RegularExpression::Ptr& to)
+{
+	std::string pattern = readCString();
+	std::string options = readCString();
+
+	to = new RegularExpression(pattern, options);
+}
+
+
+template<>
+inline void BSONWriter::write<RegularExpression::Ptr>(RegularExpression::Ptr& from)
+{
+	writeCString(from->getPattern());
+	writeCString(from->getOptions());
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_RegularExpression_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/ReplicaSet.h b/base/poco/MongoDB/include/Poco/MongoDB/ReplicaSet.h
new file mode 100644
index 00000000000..1f7cd93d646
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/ReplicaSet.h
@@ -0,0 +1,58 @@
+//
+// ReplicaSet.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  ReplicaSet
+//
+// Definition of the ReplicaSet class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_ReplicaSet_INCLUDED
+#define MongoDB_ReplicaSet_INCLUDED
+
+
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/MongoDB/Connection.h"
+#include <vector>
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API ReplicaSet
+	/// Class for working with a MongoDB replica set.
+{
+public:
+	explicit ReplicaSet(const std::vector<Net::SocketAddress>& addresses);
+		/// Creates the ReplicaSet using the given server addresses.
+
+	virtual ~ReplicaSet();
+		/// Destroys the ReplicaSet.
+
+	Connection::Ptr findMaster();
+		/// Tries to find the master MongoDB instance from the addresses
+		/// passed to the constructor.
+		///
+		/// Returns the Connection to the master, or null if no master
+		/// instance was found.
+
+protected:
+	Connection::Ptr isMaster(const Net::SocketAddress& host);
+
+private:
+	std::vector<Net::SocketAddress> _addresses;
+};
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_ReplicaSet_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/RequestMessage.h b/base/poco/MongoDB/include/Poco/MongoDB/RequestMessage.h
new file mode 100644
index 00000000000..9ebb4a56932
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/RequestMessage.h
@@ -0,0 +1,51 @@
+//
+// RequestMessage.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  RequestMessage
+//
+// Definition of the RequestMessage class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_RequestMessage_INCLUDED
+#define MongoDB_RequestMessage_INCLUDED
+
+
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/Message.h"
+#include <ostream>
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API RequestMessage: public Message
+	/// Base class for a request sent to the MongoDB server.
+{
+public:
+	explicit RequestMessage(MessageHeader::OpCode opcode);
+		/// Creates a RequestMessage using the given opcode.
+
+	virtual ~RequestMessage();
+		/// Destroys the RequestMessage.
+
+	void send(std::ostream& ostr);
+		/// Writes the request to stream.
+
+protected:
+	virtual void buildRequest(BinaryWriter& ss) = 0;
+};
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_RequestMessage_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/ResponseMessage.h b/base/poco/MongoDB/include/Poco/MongoDB/ResponseMessage.h
new file mode 100644
index 00000000000..dd9ecd23ee3
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/ResponseMessage.h
@@ -0,0 +1,108 @@
+//
+// ResponseMessage.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  ResponseMessage
+//
+// Definition of the ResponseMessage class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_ResponseMessage_INCLUDED
+#define MongoDB_ResponseMessage_INCLUDED
+
+
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/Message.h"
+#include "Poco/MongoDB/Document.h"
+#include <istream>
+#include <cstdlib>
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class MongoDB_API ResponseMessage: public Message
+	/// This class represents a response (OP_REPLY) from MongoDB.
+{
+public:
+	ResponseMessage();
+		/// Creates an empty ResponseMessage.
+
+	virtual ~ResponseMessage();
+		/// Destroys the ResponseMessage.
+
+	Int64 cursorID() const;
+		/// Returns the cursor ID.
+
+	void clear();
+		/// Clears the response.
+
+	std::size_t count() const;
+		/// Returns the number of documents in the response.
+
+	Document::Vector& documents();
+		/// Returns a vector containing the received documents.
+
+	bool empty() const;
+		/// Returns true if the response does not contain any documents.
+
+	bool hasDocuments() const;
+		/// Returns true if there is at least one document in the response.
+
+	void read(std::istream& istr);
+		/// Reads the response from the stream.
+
+private:
+	Int32 _responseFlags;
+	Int64 _cursorID;
+	Int32 _startingFrom;
+	Int32 _numberReturned;
+	Document::Vector _documents;
+};
+
+
+//
+// inlines
+//
+inline std::size_t ResponseMessage::count() const
+{
+	return _documents.size();
+}
+
+
+inline bool ResponseMessage::empty() const
+{
+	return _documents.size() == 0;
+}
+
+
+inline Int64 ResponseMessage::cursorID() const
+{
+	return _cursorID;
+}
+
+
+inline Document::Vector& ResponseMessage::documents()
+{
+	return _documents;
+}
+
+
+inline bool ResponseMessage::hasDocuments() const
+{
+	return _documents.size() > 0;
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_ResponseMessage_INCLUDED
diff --git a/base/poco/MongoDB/include/Poco/MongoDB/UpdateRequest.h b/base/poco/MongoDB/include/Poco/MongoDB/UpdateRequest.h
new file mode 100644
index 00000000000..0aa14bcd715
--- /dev/null
+++ b/base/poco/MongoDB/include/Poco/MongoDB/UpdateRequest.h
@@ -0,0 +1,114 @@
+//
+// UpdateRequest.h
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  UpdateRequest
+//
+// Definition of the UpdateRequest class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef MongoDB_UpdateRequest_INCLUDED
+#define MongoDB_UpdateRequest_INCLUDED
+
+
+#include "Poco/MongoDB/MongoDB.h"
+#include "Poco/MongoDB/RequestMessage.h"
+#include "Poco/MongoDB/Document.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+class UpdateRequest: public RequestMessage
+	/// This request is used to update a document in a database
+	/// using the OP_UPDATE client request. 
+{
+public:
+	enum Flags
+	{
+		UPDATE_DEFAULT = 0,
+			/// If set, the database will insert the supplied object into the
+			/// collection if no matching document is found.
+			
+		UPDATE_UPSERT = 1,
+			/// If set, the database will update all matching objects in the collection.
+			/// Otherwise only updates first matching doc.
+
+		UPDATE_MULTIUPDATE = 2
+			/// If set to, updates multiple documents that meet the query criteria.
+			/// Otherwise only updates one document.
+	};
+
+	UpdateRequest(const std::string& collectionName, Flags flags = UPDATE_DEFAULT);
+		/// Creates the UpdateRequest.
+		///
+		/// The full collection name is the concatenation of the database 
+		/// name with the collection name, using a "." for the concatenation. For example, 
+		/// for the database "foo" and the collection "bar", the full collection name is 
+		/// "foo.bar".
+
+	virtual ~UpdateRequest();
+		/// Destroys the UpdateRequest.
+
+	Document& selector();
+		/// Returns the selector document.
+
+	Document& update();
+		/// Returns the document to update.
+
+	Flags flags() const;
+		/// Returns the flags
+
+	void flags(Flags flags);
+		/// Sets the flags
+
+protected:
+	void buildRequest(BinaryWriter& writer);
+
+private:
+	Flags       _flags;
+	std::string _fullCollectionName;
+	Document    _selector;
+	Document    _update;
+};
+
+
+//
+// inlines
+//
+inline UpdateRequest::Flags UpdateRequest::flags() const
+{
+	return _flags;
+}
+
+
+inline void UpdateRequest::flags(UpdateRequest::Flags flags)
+{
+	_flags = flags;
+}
+
+
+inline Document& UpdateRequest::selector()
+{
+	return _selector;
+}
+
+
+inline Document& UpdateRequest::update()
+{
+	return _update;
+}
+
+
+} } // namespace Poco::MongoDB
+
+
+#endif // MongoDB_UpdateRequest_INCLUDED
diff --git a/base/poco/MongoDB/src/Array.cpp b/base/poco/MongoDB/src/Array.cpp
new file mode 100644
index 00000000000..c6d96d1371d
--- /dev/null
+++ b/base/poco/MongoDB/src/Array.cpp
@@ -0,0 +1,75 @@
+//
+// Array.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  Array
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/Array.h"
+#include <sstream>
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+Array::Array(): 
+	Document()
+{
+}
+
+
+Array::~Array()
+{
+}
+
+
+Element::Ptr Array::get(int pos) const
+{
+	std::string name = Poco::NumberFormatter::format(pos);
+	return Document::get(name);
+}
+
+
+std::string Array::toString(int indent) const
+{
+	std::ostringstream oss;
+
+	oss << "[";
+
+	if (indent > 0) oss << std::endl;
+
+	for (ElementSet::const_iterator it = _elements.begin(); it != _elements.end(); ++it)
+	{
+		if (it != _elements.begin())
+		{
+			oss << ",";
+			if (indent > 0) oss << std::endl;
+		}
+
+		for (int i = 0; i < indent; ++i) oss << ' ';
+
+		oss << (*it)->toString(indent > 0 ? indent + 2 : 0);
+	}
+
+	if (indent > 0)
+	{
+		oss << std::endl;
+		if (indent >= 2) indent -= 2;
+		for (int i = 0; i < indent; ++i) oss << ' ';
+	}
+
+	oss << "]";
+
+	return oss.str();
+}
+
+
+} } // Namespace Poco::Mongo
diff --git a/base/poco/MongoDB/src/Binary.cpp b/base/poco/MongoDB/src/Binary.cpp
new file mode 100644
index 00000000000..ea814d6969f
--- /dev/null
+++ b/base/poco/MongoDB/src/Binary.cpp
@@ -0,0 +1,89 @@
+//
+// Binary.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  Binary
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/Binary.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+Binary::Binary():
+	_buffer(0),
+	_subtype(0)
+{
+}
+
+
+Binary::Binary(Poco::Int32 size, unsigned char subtype):
+	_buffer(size),
+	_subtype(subtype)
+{
+}
+
+
+Binary::Binary(const UUID& uuid):
+	_buffer(128 / 8),
+	_subtype(0x04)
+{
+    unsigned char szUUID[16];
+    uuid.copyTo((char*) szUUID);
+    _buffer.assign(szUUID, 16);
+}
+
+
+
+Binary::Binary(const std::string& data, unsigned char subtype):
+	_buffer(reinterpret_cast<const unsigned char*>(data.data()), data.size()),
+	_subtype(subtype)
+{
+}
+
+
+Binary::Binary(const void* data, Poco::Int32 size, unsigned char subtype):
+	_buffer(reinterpret_cast<const unsigned char*>(data), size),
+	_subtype(subtype)
+{
+}
+
+
+Binary::~Binary()
+{
+}
+
+
+std::string Binary::toString(int indent) const
+{
+	std::ostringstream oss;
+	Base64Encoder encoder(oss);
+	MemoryInputStream mis((const char*) _buffer.begin(), _buffer.size());
+	StreamCopier::copyStream(mis, encoder);
+	encoder.close();
+	return oss.str();
+}
+
+
+UUID Binary::uuid() const
+{
+	if (_subtype == 0x04 && _buffer.size() == 16)
+	{
+		UUID uuid;
+		uuid.copyFrom((const char*) _buffer.begin());
+		return uuid;
+	}
+	throw BadCastException("Invalid subtype");
+}
+
+
+} } // namespace Poco::MongoDB
diff --git a/base/poco/MongoDB/src/Connection.cpp b/base/poco/MongoDB/src/Connection.cpp
new file mode 100644
index 00000000000..56bb192cec2
--- /dev/null
+++ b/base/poco/MongoDB/src/Connection.cpp
@@ -0,0 +1,235 @@
+//
+// Connection.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  Connection
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SocketStream.h"
+#include "Poco/MongoDB/Connection.h"
+#include "Poco/MongoDB/Database.h"
+#include "Poco/URI.h"
+#include "Poco/Format.h"
+#include "Poco/NumberParser.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+Connection::SocketFactory::SocketFactory()
+{
+}
+
+
+Connection::SocketFactory::~SocketFactory()
+{
+}
+
+
+Poco::Net::StreamSocket Connection::SocketFactory::createSocket(const std::string& host, int port, Poco::Timespan connectTimeout, bool secure)
+{
+	if (!secure)
+	{
+		Poco::Net::SocketAddress addr(host, port);
+		Poco::Net::StreamSocket socket;
+		if (connectTimeout > 0)
+			socket.connect(addr, connectTimeout);
+		else
+			socket.connect(addr);
+		return socket;
+	}
+	else throw Poco::NotImplementedException("Default SocketFactory implementation does not support SecureStreamSocket");
+}
+
+
+Connection::Connection():
+	_address(),
+	_socket()
+{
+}
+
+
+Connection::Connection(const std::string& hostAndPort):
+	_address(hostAndPort),
+	_socket()
+{
+	connect();
+}
+
+
+Connection::Connection(const std::string& uri, SocketFactory& socketFactory):
+	_address(),
+	_socket()
+{
+	connect(uri, socketFactory);
+}
+
+
+Connection::Connection(const std::string& host, int port):
+	_address(host, port),
+	_socket()
+{
+	connect();
+}
+
+
+Connection::Connection(const Poco::Net::SocketAddress& addrs):
+	_address(addrs),
+	_socket()
+{
+	connect();
+}
+
+
+Connection::Connection(const Poco::Net::StreamSocket& socket):
+	_address(socket.peerAddress()),
+	_socket(socket)
+{
+}
+
+
+Connection::~Connection()
+{
+	try
+	{
+		disconnect();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+void Connection::connect()
+{
+	_socket.connect(_address);
+}
+
+
+void Connection::connect(const std::string& hostAndPort)
+{
+	_address = Poco::Net::SocketAddress(hostAndPort);
+	connect();
+}
+
+
+void Connection::connect(const std::string& host, int port)
+{
+	_address = Poco::Net::SocketAddress(host, port);
+	connect();
+}
+
+
+void Connection::connect(const Poco::Net::SocketAddress& addrs)
+{
+	_address = addrs;
+	connect();
+}
+
+
+void Connection::connect(const Poco::Net::StreamSocket& socket)
+{
+	_address = socket.peerAddress();
+	_socket = socket;
+}
+
+
+void Connection::connect(const std::string& uri, SocketFactory& socketFactory)
+{
+	Poco::URI theURI(uri);
+	if (theURI.getScheme() != "mongodb") throw Poco::UnknownURISchemeException(uri);
+
+	std::string userInfo = theURI.getUserInfo();
+	std::string host = theURI.getHost();
+	Poco::UInt16 port = theURI.getPort();
+	if (port == 0) port = 27017;
+
+	std::string databaseName = theURI.getPath();
+	if (!databaseName.empty() && databaseName[0] == '/') databaseName.erase(0, 1);
+	if (databaseName.empty()) databaseName = "admin";
+
+	bool ssl = false;
+	Poco::Timespan connectTimeout;
+	Poco::Timespan socketTimeout;
+	std::string authMechanism = Database::AUTH_SCRAM_SHA1;
+
+	Poco::URI::QueryParameters params = theURI.getQueryParameters();
+	for (Poco::URI::QueryParameters::const_iterator it = params.begin(); it != params.end(); ++it)
+	{
+		if (it->first == "ssl")
+		{
+			ssl = (it->second == "true");
+		}
+		else if (it->first == "connectTimeoutMS")
+		{
+			connectTimeout = static_cast<Poco::Timespan::TimeDiff>(1000)*Poco::NumberParser::parse(it->second);
+		}
+		else if (it->first == "socketTimeoutMS")
+		{
+			socketTimeout = static_cast<Poco::Timespan::TimeDiff>(1000)*Poco::NumberParser::parse(it->second);
+		}
+		else if (it->first == "authMechanism")
+		{
+			authMechanism = it->second;
+		}
+	}
+
+	connect(socketFactory.createSocket(host, port, connectTimeout, ssl));
+
+	if (socketTimeout > 0)
+	{
+		_socket.setSendTimeout(socketTimeout);
+		_socket.setReceiveTimeout(socketTimeout);
+	}
+
+	if (!userInfo.empty())
+	{
+		std::string username;
+		std::string password;
+		std::string::size_type pos = userInfo.find(':');
+		if (pos != std::string::npos)
+		{
+			username.assign(userInfo, 0, pos++);
+			password.assign(userInfo, pos, userInfo.size() - pos);
+		}
+		else username = userInfo;
+
+		Database database(databaseName);
+		if (!database.authenticate(*this, username, password, authMechanism))
+			throw Poco::NoPermissionException(Poco::format("Access to MongoDB database %s denied for user %s", databaseName, username));
+	}
+}
+
+
+void Connection::disconnect()
+{
+	_socket.close();
+}
+
+
+void Connection::sendRequest(RequestMessage& request)
+{
+	Poco::Net::SocketOutputStream sos(_socket);
+	request.send(sos);
+}
+
+
+void Connection::sendRequest(RequestMessage& request, ResponseMessage& response)
+{
+	sendRequest(request);
+
+	Poco::Net::SocketInputStream sis(_socket);
+	response.read(sis);
+}
+
+
+} } // Poco::MongoDB
diff --git a/base/poco/MongoDB/src/Cursor.cpp b/base/poco/MongoDB/src/Cursor.cpp
new file mode 100644
index 00000000000..69031e0ab65
--- /dev/null
+++ b/base/poco/MongoDB/src/Cursor.cpp
@@ -0,0 +1,77 @@
+//
+// Cursor.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  Cursor
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/Cursor.h"
+#include "Poco/MongoDB/GetMoreRequest.h"
+#include "Poco/MongoDB/KillCursorsRequest.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+Cursor::Cursor(const std::string& db, const std::string& collection, QueryRequest::Flags flags):
+	_query(db + '.' + collection, flags)
+{
+}
+
+
+Cursor::Cursor(const std::string& fullCollectionName, QueryRequest::Flags flags):
+	_query(fullCollectionName, flags)
+{
+}
+
+
+Cursor::~Cursor()
+{
+	try
+	{
+		poco_assert_dbg(!_response.cursorID());
+	}
+	catch (...)
+	{
+	}
+}
+
+
+ResponseMessage& Cursor::next(Connection& connection)
+{
+	if (_response.cursorID() == 0)
+	{
+		connection.sendRequest(_query, _response);
+	}
+	else
+	{
+		Poco::MongoDB::GetMoreRequest getMore(_query.fullCollectionName(), _response.cursorID());
+		getMore.setNumberToReturn(_query.getNumberToReturn());
+		_response.clear();
+		connection.sendRequest(getMore, _response);
+	}
+	return _response;
+}
+
+
+void Cursor::kill(Connection& connection)
+{
+	if (_response.cursorID() != 0)
+	{
+		KillCursorsRequest killRequest;
+		killRequest.cursors().push_back(_response.cursorID());
+		connection.sendRequest(killRequest);
+	}
+	_response.clear();
+}
+
+
+} } // Namespace Poco::MongoDB
diff --git a/base/poco/MongoDB/src/Database.cpp b/base/poco/MongoDB/src/Database.cpp
new file mode 100644
index 00000000000..2b31523bdc4
--- /dev/null
+++ b/base/poco/MongoDB/src/Database.cpp
@@ -0,0 +1,430 @@
+//
+// Database.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  Database
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/Database.h"
+#include "Poco/MongoDB/Binary.h"
+#include "Poco/MD5Engine.h"
+#include "Poco/SHA1Engine.h"
+#include "Poco/PBKDF2Engine.h"
+#include "Poco/HMACEngine.h"
+#include "Poco/Base64Decoder.h"
+#include "Poco/MemoryStream.h"
+#include "Poco/StreamCopier.h"
+#include "Poco/Exception.h"
+#include "Poco/RandomStream.h"
+#include "Poco/Random.h"
+#include "Poco/Format.h"
+#include "Poco/NumberParser.h"
+#include <sstream>
+#include <map>
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+const std::string Database::AUTH_MONGODB_CR("MONGODB-CR");
+const std::string Database::AUTH_SCRAM_SHA1("SCRAM-SHA-1");
+
+
+namespace
+{
+	std::map<std::string, std::string> parseKeyValueList(const std::string& str)
+	{
+		std::map<std::string, std::string> kvm;
+		std::string::const_iterator it = str.begin();
+		std::string::const_iterator end = str.end();
+		while (it != end)
+		{
+			std::string k;
+			std::string v;
+			while (it != end && *it != '=') k += *it++;
+			if (it != end) ++it;
+			while (it != end && *it != ',') v += *it++;
+			if (it != end) ++it;
+			kvm[k] = v;
+		}
+		return kvm;
+	}
+
+	std::string decodeBase64(const std::string& base64)
+	{
+		Poco::MemoryInputStream istr(base64.data(), base64.size());
+		Poco::Base64Decoder decoder(istr);
+		std::string result;
+		Poco::StreamCopier::copyToString(decoder, result);
+		return result;
+	}
+
+	std::string encodeBase64(const std::string& data)
+	{
+		std::ostringstream ostr;
+		Poco::Base64Encoder encoder(ostr);
+		encoder.rdbuf()->setLineLength(0);
+		encoder << data;
+		encoder.close();
+		return ostr.str();
+	}
+
+	std::string digestToBinaryString(Poco::DigestEngine& engine)
+	{
+		Poco::DigestEngine::Digest d = engine.digest();
+		return std::string(reinterpret_cast<const char*>(&d[0]), d.size());
+	}
+
+	std::string digestToHexString(Poco::DigestEngine& engine)
+	{
+		Poco::DigestEngine::Digest d = engine.digest();
+		return Poco::DigestEngine::digestToHex(d);
+	}
+
+	std::string digestToBase64(Poco::DigestEngine& engine)
+	{
+		return encodeBase64(digestToBinaryString(engine));
+	}
+
+	std::string hashCredentials(const std::string& username, const std::string& password)
+	{
+		Poco::MD5Engine md5;
+		md5.update(username);
+		md5.update(std::string(":mongo:"));
+		md5.update(password);
+		return digestToHexString(md5);
+	}
+
+	std::string createNonce()
+	{
+		Poco::MD5Engine md5;
+		Poco::RandomInputStream randomStream;
+		Poco::Random random;
+		for (int i = 0; i < 4; i++)
+		{
+			md5.update(randomStream.get());
+			md5.update(random.nextChar());
+		}
+		return digestToHexString(md5);
+	}
+}
+
+
+Database::Database(const std::string& db):
+	_dbname(db)
+{
+}
+
+
+Database::~Database()
+{
+}
+
+
+bool Database::authenticate(Connection& connection, const std::string& username, const std::string& password, const std::string& method)
+{
+	if (username.empty()) throw Poco::InvalidArgumentException("empty username");
+	if (password.empty()) throw Poco::InvalidArgumentException("empty password");
+
+	if (method == AUTH_MONGODB_CR)
+		return authCR(connection, username, password);
+	else if (method == AUTH_SCRAM_SHA1)
+		return authSCRAM(connection, username, password);
+	else
+		throw Poco::InvalidArgumentException("authentication method", method);
+}
+
+
+bool Database::authCR(Connection& connection, const std::string& username, const std::string& password)
+{
+	std::string nonce;
+	Poco::SharedPtr<QueryRequest> pCommand = createCommand();
+	pCommand->selector().add<Poco::Int32>("getnonce", 1);
+
+	ResponseMessage response;
+	connection.sendRequest(*pCommand, response);
+	if (response.documents().size() > 0)
+	{
+		Document::Ptr pDoc = response.documents()[0];
+		if (pDoc->getInteger("ok") != 1) return false;
+		nonce = pDoc->get<std::string>("nonce", "");
+		if (nonce.empty()) throw Poco::ProtocolException("no nonce received");
+	}
+	else throw Poco::ProtocolException("empty response for getnonce");
+
+	std::string credsDigest = hashCredentials(username, password);
+
+	Poco::MD5Engine md5;
+	md5.update(nonce);
+	md5.update(username);
+	md5.update(credsDigest);
+	std::string key = digestToHexString(md5);
+
+	pCommand = createCommand();
+	pCommand->selector()
+		.add<Poco::Int32>("authenticate", 1)
+		.add<std::string>("user", username)
+		.add<std::string>("nonce", nonce)
+		.add<std::string>("key", key);
+
+	connection.sendRequest(*pCommand, response);
+	if (response.documents().size() > 0)
+	{
+		Document::Ptr pDoc = response.documents()[0];
+		return pDoc->getInteger("ok") == 1;
+	}
+	else throw Poco::ProtocolException("empty response for authenticate");
+}
+
+
+bool Database::authSCRAM(Connection& connection, const std::string& username, const std::string& password)
+{
+	std::string clientNonce(createNonce());
+	std::string clientFirstMsg = Poco::format("n=%s,r=%s", username, clientNonce);
+
+	Poco::SharedPtr<QueryRequest> pCommand = createCommand();
+	pCommand->selector()
+		.add<Poco::Int32>("saslStart", 1)
+		.add<std::string>("mechanism", AUTH_SCRAM_SHA1)
+		.add<Binary::Ptr>("payload", new Binary(Poco::format("n,,%s", clientFirstMsg)));
+
+	ResponseMessage response;
+	connection.sendRequest(*pCommand, response);
+
+	Int32 conversationId = 0;
+	std::string serverFirstMsg;
+
+	if (response.documents().size() > 0)
+	{
+		Document::Ptr pDoc = response.documents()[0];
+		if (pDoc->getInteger("ok") == 1)
+		{
+			Binary::Ptr pPayload = pDoc->get<Binary::Ptr>("payload");
+			serverFirstMsg = pPayload->toRawString();
+			conversationId = pDoc->get<Int32>("conversationId");
+		}
+		else
+		{
+			if (pDoc->exists("errmsg"))
+			{
+				const Poco::MongoDB::Element::Ptr value = pDoc->get("errmsg");
+				auto message = static_cast<const Poco::MongoDB::ConcreteElement<std::string> &>(*value).value();
+				throw Poco::RuntimeException(message);
+			}
+			else
+				return false;
+		}
+	}
+	else throw Poco::ProtocolException("empty response for saslStart");
+
+	std::map<std::string, std::string> kvm = parseKeyValueList(serverFirstMsg);
+	const std::string serverNonce = kvm["r"];
+	const std::string salt = decodeBase64(kvm["s"]);
+	const unsigned iterations = Poco::NumberParser::parseUnsigned(kvm["i"]);
+	const Poco::UInt32 dkLen = 20;
+
+	std::string hashedPassword = hashCredentials(username, password);
+
+	Poco::PBKDF2Engine<Poco::HMACEngine<Poco::SHA1Engine> > pbkdf2(salt, iterations, dkLen);
+	pbkdf2.update(hashedPassword);
+	std::string saltedPassword = digestToBinaryString(pbkdf2);
+
+	std::string clientFinalNoProof = Poco::format("c=biws,r=%s", serverNonce);
+	std::string authMessage = Poco::format("%s,%s,%s", clientFirstMsg, serverFirstMsg, clientFinalNoProof);
+
+	Poco::HMACEngine<Poco::SHA1Engine> hmacKey(saltedPassword);
+	hmacKey.update(std::string("Client Key"));
+	std::string clientKey = digestToBinaryString(hmacKey);
+
+	Poco::SHA1Engine sha1;
+	sha1.update(clientKey);
+	std::string storedKey = digestToBinaryString(sha1);
+
+	Poco::HMACEngine<Poco::SHA1Engine> hmacSig(storedKey);
+	hmacSig.update(authMessage);
+	std::string clientSignature = digestToBinaryString(hmacSig);
+
+	std::string clientProof(clientKey);
+	for (std::size_t i = 0; i < clientProof.size(); i++)
+	{
+		clientProof[i] ^= clientSignature[i];
+	}
+
+	std::string clientFinal = Poco::format("%s,p=%s", clientFinalNoProof, encodeBase64(clientProof));
+
+	pCommand = createCommand();
+	pCommand->selector()
+		.add<Poco::Int32>("saslContinue", 1)
+		.add<Poco::Int32>("conversationId", conversationId)
+		.add<Binary::Ptr>("payload", new Binary(clientFinal));
+
+	std::string serverSecondMsg;
+	connection.sendRequest(*pCommand, response);
+	if (response.documents().size() > 0)
+	{
+		Document::Ptr pDoc = response.documents()[0];
+		if (pDoc->getInteger("ok") == 1)
+		{
+			Binary::Ptr pPayload = pDoc->get<Binary::Ptr>("payload");
+			serverSecondMsg = pPayload->toRawString();
+		}
+		else
+		{
+			if (pDoc->exists("errmsg"))
+			{
+				const Poco::MongoDB::Element::Ptr value = pDoc->get("errmsg");
+				auto message = static_cast<const Poco::MongoDB::ConcreteElement<std::string> &>(*value).value();
+				throw Poco::RuntimeException(message);
+			}
+			else
+				return false;
+		}
+	}
+	else throw Poco::ProtocolException("empty response for saslContinue");
+
+	Poco::HMACEngine<Poco::SHA1Engine> hmacSKey(saltedPassword);
+	hmacSKey.update(std::string("Server Key"));
+	std::string serverKey = digestToBinaryString(hmacSKey);
+
+	Poco::HMACEngine<Poco::SHA1Engine> hmacSSig(serverKey);
+	hmacSSig.update(authMessage);
+	std::string serverSignature = digestToBase64(hmacSSig);
+
+	kvm = parseKeyValueList(serverSecondMsg);
+	std::string serverSignatureReceived = kvm["v"];
+
+	if (serverSignature != serverSignatureReceived)
+		throw Poco::ProtocolException("server signature verification failed");
+
+	pCommand = createCommand();
+	pCommand->selector()
+		.add<Poco::Int32>("saslContinue", 1)
+		.add<Poco::Int32>("conversationId", conversationId)
+		.add<Binary::Ptr>("payload", new Binary);
+
+	connection.sendRequest(*pCommand, response);
+	if (response.documents().size() > 0)
+	{
+		Document::Ptr pDoc = response.documents()[0];
+		if (pDoc->getInteger("ok") == 1)
+		{
+			return true;
+		}
+		else
+		{
+			if (pDoc->exists("errmsg"))
+			{
+				const Poco::MongoDB::Element::Ptr value = pDoc->get("errmsg");
+				auto message = static_cast<const Poco::MongoDB::ConcreteElement<std::string> &>(*value).value();
+				throw Poco::RuntimeException(message);
+			}
+			else
+				return false;
+		}
+	}
+	else throw Poco::ProtocolException("empty response for saslContinue");
+}
+
+
+Int64 Database::count(Connection& connection, const std::string& collectionName) const
+{
+	Poco::SharedPtr<Poco::MongoDB::QueryRequest> countRequest = createCountRequest(collectionName);
+
+	Poco::MongoDB::ResponseMessage response;
+	connection.sendRequest(*countRequest, response);
+
+	if (response.documents().size() > 0)
+	{
+		Poco::MongoDB::Document::Ptr doc = response.documents()[0];
+		return doc->getInteger("n");
+	}
+
+	return -1;
+}
+
+
+Poco::MongoDB::Document::Ptr Database::ensureIndex(Connection& connection, const std::string& collection, const std::string& indexName, Poco::MongoDB::Document::Ptr keys, bool unique, bool background, int version, int ttl)
+{
+	Poco::MongoDB::Document::Ptr index = new Poco::MongoDB::Document();
+	index->add("ns", _dbname + "." + collection);
+	index->add("name", indexName);
+	index->add("key", keys);
+
+	if (version > 0)
+	{
+		index->add("version", version);
+	}
+
+	if (unique)
+	{
+		index->add("unique", true);
+	}
+
+	if (background)
+	{
+		index->add("background", true);
+	}
+
+	if (ttl > 0)
+	{
+		index->add("expireAfterSeconds", ttl);
+	}
+
+	Poco::SharedPtr<Poco::MongoDB::InsertRequest> insertRequest = createInsertRequest("system.indexes");
+	insertRequest->documents().push_back(index);
+	connection.sendRequest(*insertRequest);
+
+	return getLastErrorDoc(connection);
+}
+
+
+Document::Ptr Database::getLastErrorDoc(Connection& connection) const
+{
+	Document::Ptr errorDoc;
+
+	Poco::SharedPtr<Poco::MongoDB::QueryRequest> request = createQueryRequest("$cmd");
+	request->setNumberToReturn(1);
+	request->selector().add("getLastError", 1);
+
+	Poco::MongoDB::ResponseMessage response;
+	connection.sendRequest(*request, response);
+
+	if (response.documents().size() > 0)
+	{
+		errorDoc = response.documents()[0];
+	}
+
+	return errorDoc;
+}
+
+
+std::string Database::getLastError(Connection& connection) const
+{
+	Document::Ptr errorDoc = getLastErrorDoc(connection);
+	if (!errorDoc.isNull() && errorDoc->isType<std::string>("err"))
+	{
+		return errorDoc->get<std::string>("err");
+	}
+
+	return "";
+}
+
+
+Poco::SharedPtr<Poco::MongoDB::QueryRequest> Database::createCountRequest(const std::string& collectionName) const
+{
+	Poco::SharedPtr<Poco::MongoDB::QueryRequest> request = createQueryRequest("$cmd");
+	request->setNumberToReturn(1);
+	request->selector().add("count", collectionName);
+	return request;
+}
+
+
+} } // namespace Poco::MongoDB
diff --git a/base/poco/MongoDB/src/DeleteRequest.cpp b/base/poco/MongoDB/src/DeleteRequest.cpp
new file mode 100644
index 00000000000..67a88c33302
--- /dev/null
+++ b/base/poco/MongoDB/src/DeleteRequest.cpp
@@ -0,0 +1,54 @@
+//
+// DeleteRequest.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  DeleteRequest
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/DeleteRequest.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+DeleteRequest::DeleteRequest(const std::string& collectionName, DeleteRequest::Flags flags):
+	RequestMessage(MessageHeader::OP_DELETE), 
+	_flags(flags), 
+	_fullCollectionName(collectionName),
+	_selector()
+{
+}
+
+
+DeleteRequest::DeleteRequest(const std::string& collectionName, bool justOne):
+	RequestMessage(MessageHeader::OP_DELETE),
+	_flags(justOne ? DELETE_SINGLE_REMOVE : DELETE_DEFAULT),
+	_fullCollectionName(collectionName),
+	_selector()
+{
+}
+
+
+DeleteRequest::~DeleteRequest()
+{
+}
+
+
+void DeleteRequest::buildRequest(BinaryWriter& writer)
+{
+	writer << 0; // 0 - reserved for future use
+	BSONWriter(writer).writeCString(_fullCollectionName);
+	writer << _flags;
+	_selector.write(writer);
+}
+
+
+} } // namespace Poco::MongoDB
diff --git a/base/poco/MongoDB/src/Document.cpp b/base/poco/MongoDB/src/Document.cpp
new file mode 100644
index 00000000000..114fc993891
--- /dev/null
+++ b/base/poco/MongoDB/src/Document.cpp
@@ -0,0 +1,219 @@
+//
+// Document.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  Document
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/Document.h"
+#include "Poco/MongoDB/Binary.h"
+#include "Poco/MongoDB/ObjectId.h"
+#include "Poco/MongoDB/Array.h"
+#include "Poco/MongoDB/RegularExpression.h"
+#include "Poco/MongoDB/JavaScriptCode.h"
+#include <sstream>
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+Document::Document()
+{
+}
+
+
+Document::~Document()
+{
+}
+
+
+Element::Ptr Document::get(const std::string& name) const
+{
+	Element::Ptr element;
+
+	ElementSet::const_iterator it = std::find_if(_elements.begin(), _elements.end(), ElementFindByName(name));
+	if (it != _elements.end())
+	{
+		return *it;
+	}
+
+	return element;
+}
+
+
+Int64 Document::getInteger(const std::string& name) const
+{
+	Element::Ptr element = get(name);
+	if (element.isNull()) throw Poco::NotFoundException(name);
+
+	if (ElementTraits<double>::TypeId == element->type())
+	{
+		ConcreteElement<double>* concrete = dynamic_cast<ConcreteElement<double>*>(element.get());
+		if (concrete) return static_cast<Int64>(concrete->value());
+	}
+	else if (ElementTraits<Int32>::TypeId == element->type())
+	{
+		ConcreteElement<Int32>* concrete = dynamic_cast<ConcreteElement<Int32>*>(element.get());
+		if (concrete) return concrete->value();
+	}
+	else if (ElementTraits<Int64>::TypeId == element->type())
+	{
+		ConcreteElement<Int64>* concrete = dynamic_cast<ConcreteElement<Int64>*>(element.get());
+		if (concrete) return concrete->value();
+	}
+	throw Poco::BadCastException("Invalid type mismatch!");
+}
+
+
+void Document::read(BinaryReader& reader)
+{
+	int size;
+	reader >> size;
+
+	unsigned char type;
+	reader >> type;
+
+	while (type != '\0')
+	{
+		Element::Ptr element;
+		
+		std::string name = BSONReader(reader).readCString();
+
+		switch (type)
+		{
+		case ElementTraits<double>::TypeId:
+			element = new ConcreteElement<double>(name, 0);
+			break;
+		case ElementTraits<Int32>::TypeId:
+			element = new ConcreteElement<Int32>(name, 0);
+			break;
+		case ElementTraits<std::string>::TypeId:
+			element = new ConcreteElement<std::string>(name, "");
+			break;
+		case ElementTraits<Document::Ptr>::TypeId:
+			element = new ConcreteElement<Document::Ptr>(name, new Document);
+			break;
+		case ElementTraits<Array::Ptr>::TypeId:
+			element = new ConcreteElement<Array::Ptr>(name, new Array);
+			break;
+		case ElementTraits<Binary::Ptr>::TypeId:
+			element = new ConcreteElement<Binary::Ptr>(name, new Binary);
+			break;
+		case ElementTraits<ObjectId::Ptr>::TypeId:
+			element = new ConcreteElement<ObjectId::Ptr>(name, new ObjectId);
+			break;
+		case ElementTraits<bool>::TypeId:
+			element = new ConcreteElement<bool>(name, false);
+			break;
+		case ElementTraits<Poco::Timestamp>::TypeId:
+			element = new ConcreteElement<Poco::Timestamp>(name, Poco::Timestamp());
+			break;
+		case ElementTraits<BSONTimestamp>::TypeId:
+			element = new ConcreteElement<BSONTimestamp>(name, BSONTimestamp());
+			break;
+		case ElementTraits<NullValue>::TypeId:
+			element = new ConcreteElement<NullValue>(name, NullValue(0));
+			break;
+		case ElementTraits<RegularExpression::Ptr>::TypeId:
+			element = new ConcreteElement<RegularExpression::Ptr>(name, new RegularExpression());
+			break;
+		case ElementTraits<JavaScriptCode::Ptr>::TypeId:
+			element = new ConcreteElement<JavaScriptCode::Ptr>(name, new JavaScriptCode());
+			break;
+		case ElementTraits<Int64>::TypeId:
+			element = new ConcreteElement<Int64>(name, 0);
+			break;
+		default:
+			{
+				std::stringstream ss;
+				ss << "Element " << name << " contains an unsupported type 0x" << std::hex << (int) type;
+				throw Poco::NotImplementedException(ss.str());
+			}
+		//TODO: x0F -> JavaScript code with scope
+		//		xFF -> Min Key
+		//		x7F -> Max Key
+		}
+
+		element->read(reader);
+		_elements.push_back(element);
+
+		reader >> type;
+	}
+}
+
+
+std::string Document::toString(int indent) const
+{
+	std::ostringstream oss;
+
+	oss << '{';
+
+	if (indent > 0) oss << std::endl;
+
+
+	for (ElementSet::const_iterator it = _elements.begin(); it != _elements.end(); ++it)
+	{
+		if (it != _elements.begin())
+		{
+			oss << ',';
+			if (indent > 0) oss << std::endl;
+		}
+
+		for (int i = 0; i < indent; ++i) oss << ' ';
+
+		oss << '"' << (*it)->name() << '"';
+		oss << (indent > 0  ? " : " : ":");
+
+		oss << (*it)->toString(indent > 0 ? indent + 2 : 0);
+	}
+
+	if (indent > 0)
+	{
+		oss << std::endl;
+		if (indent >= 2) indent -= 2;
+
+		for (int i = 0; i < indent; ++i) oss << ' ';
+	}
+
+	oss << '}';
+
+	return oss.str();
+}
+
+
+void Document::write(BinaryWriter& writer)
+{
+	if (_elements.empty())
+	{
+		writer << 5;
+	}
+	else
+	{
+		std::stringstream sstream;
+		Poco::BinaryWriter tempWriter(sstream);
+		for (ElementSet::iterator it = _elements.begin(); it != _elements.end(); ++it)
+		{
+			tempWriter << static_cast<unsigned char>((*it)->type());
+			BSONWriter(tempWriter).writeCString((*it)->name());
+			Element::Ptr element = *it;
+			element->write(tempWriter);
+		}
+		tempWriter.flush();
+		
+		Poco::Int32 len = static_cast<Poco::Int32>(5 + sstream.tellp()); /* 5 = sizeof(len) + 0-byte */
+		writer << len;
+		writer.writeRaw(sstream.str());
+	}
+	writer << '\0';
+}
+
+
+} } // namespace Poco::MongoDB
diff --git a/base/poco/MongoDB/src/Element.cpp b/base/poco/MongoDB/src/Element.cpp
new file mode 100644
index 00000000000..89629e0503e
--- /dev/null
+++ b/base/poco/MongoDB/src/Element.cpp
@@ -0,0 +1,32 @@
+//
+// Element.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  Element
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/Element.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+Element::Element(const std::string& name) : _name(name)
+{
+}
+
+
+Element::~Element() 
+{
+}
+
+
+} } // namespace Poco::MongoDB
diff --git a/base/poco/MongoDB/src/GetMoreRequest.cpp b/base/poco/MongoDB/src/GetMoreRequest.cpp
new file mode 100644
index 00000000000..f8a6b73c6ad
--- /dev/null
+++ b/base/poco/MongoDB/src/GetMoreRequest.cpp
@@ -0,0 +1,46 @@
+//
+// GetMoreRequest.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  GetMoreRequest
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/GetMoreRequest.h"
+#include "Poco/MongoDB/Element.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+GetMoreRequest::GetMoreRequest(const std::string& collectionName, Int64 cursorID):
+	RequestMessage(MessageHeader::OP_GET_MORE), 
+	_fullCollectionName(collectionName),
+	_numberToReturn(100),
+	_cursorID(cursorID)
+{
+}
+
+
+GetMoreRequest::~GetMoreRequest()
+{
+}
+
+
+void GetMoreRequest::buildRequest(BinaryWriter& writer)
+{
+	writer << 0; // 0 - reserved for future use
+	BSONWriter(writer).writeCString(_fullCollectionName);
+	writer << _numberToReturn;
+	writer << _cursorID;
+}
+
+
+} } // namespace Poco::MongoDB
diff --git a/base/poco/MongoDB/src/InsertRequest.cpp b/base/poco/MongoDB/src/InsertRequest.cpp
new file mode 100644
index 00000000000..ec8dc9cf94a
--- /dev/null
+++ b/base/poco/MongoDB/src/InsertRequest.cpp
@@ -0,0 +1,49 @@
+//
+// InsertRequest.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  InsertRequest
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/InsertRequest.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+InsertRequest::InsertRequest(const std::string& collectionName, Flags flags):
+	RequestMessage(MessageHeader::OP_INSERT), 
+	_flags(flags),
+	_fullCollectionName(collectionName)
+{
+}
+
+
+InsertRequest::~InsertRequest()
+{
+}
+
+
+void InsertRequest::buildRequest(BinaryWriter& writer)
+{
+	poco_assert (!_documents.empty());
+
+	writer << _flags;
+	BSONWriter bsonWriter(writer);
+	bsonWriter.writeCString(_fullCollectionName);
+	for (Document::Vector::iterator it = _documents.begin(); it != _documents.end(); ++it)
+	{
+		bsonWriter.write(*it);
+	}
+}
+
+
+} } // namespace Poco::MongoDB
diff --git a/base/poco/MongoDB/src/JavaScriptCode.cpp b/base/poco/MongoDB/src/JavaScriptCode.cpp
new file mode 100644
index 00000000000..41f5fcabe6b
--- /dev/null
+++ b/base/poco/MongoDB/src/JavaScriptCode.cpp
@@ -0,0 +1,33 @@
+//
+// JavaScriptCode.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  JavaScriptCode
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/JavaScriptCode.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+JavaScriptCode::JavaScriptCode()
+{
+
+}
+
+
+JavaScriptCode::~JavaScriptCode()
+{
+}
+
+
+} } // namespace Poco::MongoDB
diff --git a/base/poco/MongoDB/src/KillCursorsRequest.cpp b/base/poco/MongoDB/src/KillCursorsRequest.cpp
new file mode 100644
index 00000000000..6baa0e0be8f
--- /dev/null
+++ b/base/poco/MongoDB/src/KillCursorsRequest.cpp
@@ -0,0 +1,44 @@
+//
+// KillCursorsRequest.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  KillCursorsRequest
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/KillCursorsRequest.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+KillCursorsRequest::KillCursorsRequest():
+	RequestMessage(MessageHeader::OP_KILL_CURSORS)
+{
+}
+
+
+KillCursorsRequest::~KillCursorsRequest()
+{
+}
+
+
+void KillCursorsRequest::buildRequest(BinaryWriter& writer)
+{
+	writer << 0; // 0 - reserved for future use
+	writer << static_cast<Poco::UInt64>(_cursors.size());
+	for (std::vector<Int64>::iterator it = _cursors.begin(); it != _cursors.end(); ++it)
+	{
+		writer << *it;
+	}		
+}
+
+
+} } // namespace Poco::MongoDB
diff --git a/base/poco/MongoDB/src/Message.cpp b/base/poco/MongoDB/src/Message.cpp
new file mode 100644
index 00000000000..c29d282d15a
--- /dev/null
+++ b/base/poco/MongoDB/src/Message.cpp
@@ -0,0 +1,33 @@
+//
+// Message.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  Message
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/Message.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+Message::Message(MessageHeader::OpCode opcode): 
+	_header(opcode)
+{
+}
+
+
+Message::~Message()
+{
+}
+
+
+} } // namespace Poco::MongoDB
diff --git a/base/poco/MongoDB/src/MessageHeader.cpp b/base/poco/MongoDB/src/MessageHeader.cpp
new file mode 100644
index 00000000000..222121243db
--- /dev/null
+++ b/base/poco/MongoDB/src/MessageHeader.cpp
@@ -0,0 +1,63 @@
+//
+// MessageHeader.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  MessageHeader
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/Message.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+MessageHeader::MessageHeader(OpCode opCode): 
+	_messageLength(0), 
+	_requestID(0), 
+	_responseTo(0), 
+	_opCode(opCode)
+{
+}
+
+
+MessageHeader::~MessageHeader()
+{
+}
+
+
+void MessageHeader::read(BinaryReader& reader)
+{
+	reader >> _messageLength;
+	reader >> _requestID;
+	reader >> _responseTo;
+
+	Int32 opCode;
+	reader >> opCode;
+	_opCode = (OpCode) opCode;
+
+	if (!reader.good())
+	{
+		throw IOException("Failed to read from socket");
+	}
+}
+
+
+void MessageHeader::write(BinaryWriter& writer)
+{
+	writer << _messageLength;
+	writer << _requestID;
+	writer << _responseTo;
+	writer << (Int32) _opCode;
+}
+
+
+} } // namespace Poco::MongoDB
diff --git a/base/poco/MongoDB/src/ObjectId.cpp b/base/poco/MongoDB/src/ObjectId.cpp
new file mode 100644
index 00000000000..3065a2ffc30
--- /dev/null
+++ b/base/poco/MongoDB/src/ObjectId.cpp
@@ -0,0 +1,66 @@
+//
+// ObjectId.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  ObjectId
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/ObjectId.h"
+#include "Poco/Format.h"
+#include <cstring>
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+ObjectId::ObjectId()
+{
+	std::memset(_id, 0, sizeof(_id));
+}
+
+
+ObjectId::ObjectId(const std::string& id)
+{
+	poco_assert_dbg(id.size() == 24);
+
+    const char* p = id.c_str();
+    for (std::size_t i = 0; i < 12; ++i) 
+    {
+		_id[i] = fromHex(p);
+		p += 2;
+	}
+}
+
+
+ObjectId::ObjectId(const ObjectId& copy)
+{
+	std::memcpy(_id, copy._id, sizeof(_id));
+}
+
+
+ObjectId::~ObjectId()
+{
+}
+
+
+std::string ObjectId::toString(const std::string& fmt) const
+{
+	std::string s;
+
+	for (int i = 0; i < 12; ++i)
+	{
+		s += format(fmt, (unsigned int) _id[i]);
+	}
+	return s;
+}
+
+
+} } // namespace Poco::MongoDB
diff --git a/base/poco/MongoDB/src/QueryRequest.cpp b/base/poco/MongoDB/src/QueryRequest.cpp
new file mode 100644
index 00000000000..7044335ba30
--- /dev/null
+++ b/base/poco/MongoDB/src/QueryRequest.cpp
@@ -0,0 +1,54 @@
+//
+// QueryRequest.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  QueryRequest
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/QueryRequest.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+QueryRequest::QueryRequest(const std::string& collectionName, QueryRequest::Flags flags):
+	RequestMessage(MessageHeader::OP_QUERY), 
+	_flags(flags), 
+	_fullCollectionName(collectionName),
+	_numberToSkip(0), 
+	_numberToReturn(100),
+	_selector(),
+	_returnFieldSelector()
+{
+}
+
+
+QueryRequest::~QueryRequest()
+{
+}
+
+
+void QueryRequest::buildRequest(BinaryWriter& writer)
+{
+	writer << _flags;
+	BSONWriter(writer).writeCString(_fullCollectionName);
+	writer << _numberToSkip;
+	writer << _numberToReturn;
+	_selector.write(writer);
+
+	if (!_returnFieldSelector.empty())
+	{
+		_returnFieldSelector.write(writer);
+	}
+}
+
+
+} } // namespace Poco::MongoDB
diff --git a/base/poco/MongoDB/src/RegularExpression.cpp b/base/poco/MongoDB/src/RegularExpression.cpp
new file mode 100644
index 00000000000..e95e7da82e1
--- /dev/null
+++ b/base/poco/MongoDB/src/RegularExpression.cpp
@@ -0,0 +1,71 @@
+//
+// RegularExpression.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  RegularExpression
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/RegularExpression.h"
+#include <sstream>
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+RegularExpression::RegularExpression()
+{
+}
+
+
+RegularExpression::RegularExpression(const std::string& pattern, const std::string& options): 
+	_pattern(pattern), 
+	_options(options)
+{
+}
+
+
+RegularExpression::~RegularExpression()
+{
+}
+
+
+SharedPtr<Poco::RegularExpression> RegularExpression::createRE() const
+{
+	int options = 0;
+	for (std::string::const_iterator optIt = _options.begin(); optIt != _options.end(); ++optIt)
+	{
+		switch (*optIt)
+		{
+		case 'i': // Case Insensitive
+			options |= Poco::RegularExpression::RE_CASELESS;
+			break;
+		case 'm': // Multiline matching
+			options |= Poco::RegularExpression::RE_MULTILINE;
+			break;
+		case 'x': // Verbose mode
+			//No equivalent in Poco
+			break;
+		case 'l': // \w \W Locale dependent
+			//No equivalent in Poco
+			break;
+		case 's': // Dotall mode
+			options |= Poco::RegularExpression::RE_DOTALL;
+			break;
+		case 'u': // \w \W Unicode
+			//No equivalent in Poco
+			break;
+		}
+	}
+	return new Poco::RegularExpression(_pattern, options);
+}
+
+
+} } // namespace Poco::MongoDB
diff --git a/base/poco/MongoDB/src/ReplicaSet.cpp b/base/poco/MongoDB/src/ReplicaSet.cpp
new file mode 100644
index 00000000000..b56fea49311
--- /dev/null
+++ b/base/poco/MongoDB/src/ReplicaSet.cpp
@@ -0,0 +1,89 @@
+//
+// ReplicaSet.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  ReplicaSet
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/ReplicaSet.h"
+#include "Poco/MongoDB/QueryRequest.h"
+#include "Poco/MongoDB/ResponseMessage.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+ReplicaSet::ReplicaSet(const std::vector<Net::SocketAddress> &addresses): 
+	_addresses(addresses)
+{
+}
+
+
+ReplicaSet::~ReplicaSet()
+{
+}
+
+
+Connection::Ptr ReplicaSet::findMaster()
+{
+	Connection::Ptr master;
+
+	for (std::vector<Net::SocketAddress>::iterator it = _addresses.begin(); it != _addresses.end(); ++it)
+	{
+		master = isMaster(*it);
+		if (!master.isNull())
+		{
+			break;
+		}
+	}
+
+	return master;
+}
+
+
+Connection::Ptr ReplicaSet::isMaster(const Net::SocketAddress& address)
+{
+	Connection::Ptr conn = new Connection();
+
+	try
+	{
+		conn->connect(address);
+
+		QueryRequest request("admin.$cmd");
+		request.setNumberToReturn(1);
+		request.selector().add("isMaster", 1);
+
+		ResponseMessage response;
+		conn->sendRequest(request, response);
+
+		if (response.documents().size() > 0)
+		{
+			Document::Ptr doc = response.documents()[0];
+			if (doc->get<bool>("ismaster"))
+			{
+				return conn;
+			}
+			else if (doc->exists("primary"))
+			{
+				return isMaster(Net::SocketAddress(doc->get<std::string>("primary")));
+			}
+		}
+	}
+	catch (...)
+	{
+		conn = 0;
+	}
+	
+	return 0; 
+}
+
+
+} } // namespace Poco::MongoDB
diff --git a/base/poco/MongoDB/src/RequestMessage.cpp b/base/poco/MongoDB/src/RequestMessage.cpp
new file mode 100644
index 00000000000..6391d966198
--- /dev/null
+++ b/base/poco/MongoDB/src/RequestMessage.cpp
@@ -0,0 +1,51 @@
+//
+// RequestMessage.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  RequestMessage
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/RequestMessage.h"
+#include "Poco/Net/SocketStream.h"
+#include "Poco/StreamCopier.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+RequestMessage::RequestMessage(MessageHeader::OpCode opcode): 
+	Message(opcode)
+{
+}
+
+
+RequestMessage::~RequestMessage()
+{
+}
+
+
+void RequestMessage::send(std::ostream& ostr)
+{
+	std::stringstream ss;
+	BinaryWriter requestWriter(ss);
+	buildRequest(requestWriter);
+	requestWriter.flush();
+
+	messageLength(static_cast<Poco::Int32>(ss.tellp()));
+
+	BinaryWriter socketWriter(ostr, BinaryWriter::LITTLE_ENDIAN_BYTE_ORDER);
+	_header.write(socketWriter);
+	StreamCopier::copyStream(ss, ostr);
+	ostr.flush();
+}
+
+
+} } // namespace Poco::MongoDB
diff --git a/base/poco/MongoDB/src/ResponseMessage.cpp b/base/poco/MongoDB/src/ResponseMessage.cpp
new file mode 100644
index 00000000000..3254ace63e6
--- /dev/null
+++ b/base/poco/MongoDB/src/ResponseMessage.cpp
@@ -0,0 +1,70 @@
+//
+// ResponseMessage.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  ResponseMessage
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/ResponseMessage.h"
+#include "Poco/Net/SocketStream.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+ResponseMessage::ResponseMessage():
+	Message(MessageHeader::OP_REPLY), 
+	_responseFlags(0), 
+	_cursorID(0), 
+	_startingFrom(0), 
+	_numberReturned(0)
+{
+}
+
+
+ResponseMessage::~ResponseMessage()
+{
+}
+
+
+void ResponseMessage::clear()
+{
+	_responseFlags = 0;
+	_startingFrom = 0;
+	_cursorID = 0;
+	_numberReturned = 0;
+	_documents.clear();
+}
+
+
+void ResponseMessage::read(std::istream& istr)
+{
+	clear();
+
+	BinaryReader reader(istr, BinaryReader::LITTLE_ENDIAN_BYTE_ORDER);
+	
+	_header.read(reader);
+
+	reader >> _responseFlags;
+	reader >> _cursorID;
+	reader >> _startingFrom;
+	reader >> _numberReturned;
+
+	for (int i = 0; i < _numberReturned; ++i)
+	{
+		Document::Ptr doc = new Document();
+		doc->read(reader);
+		_documents.push_back(doc);
+	}
+}
+
+
+} } // namespace Poco::MongoDB
diff --git a/base/poco/MongoDB/src/UpdateRequest.cpp b/base/poco/MongoDB/src/UpdateRequest.cpp
new file mode 100644
index 00000000000..2af4621ff64
--- /dev/null
+++ b/base/poco/MongoDB/src/UpdateRequest.cpp
@@ -0,0 +1,47 @@
+//
+// UpdateRequest.cpp
+//
+// Library: MongoDB
+// Package: MongoDB
+// Module:  UpdateRequest
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/MongoDB/UpdateRequest.h"
+
+
+namespace Poco {
+namespace MongoDB {
+
+
+UpdateRequest::UpdateRequest(const std::string& collectionName, UpdateRequest::Flags flags):
+	RequestMessage(MessageHeader::OP_UPDATE), 
+	_flags(flags),
+	_fullCollectionName(collectionName),
+	_selector(),
+	_update()
+{
+}
+
+
+UpdateRequest::~UpdateRequest()
+{
+}
+
+
+void UpdateRequest::buildRequest(BinaryWriter& writer)
+{
+	writer << 0; // 0 - reserved for future use
+	BSONWriter(writer).writeCString(_fullCollectionName);
+	writer << _flags;
+	_selector.write(writer);
+	_update.write(writer);
+}
+
+
+} } // namespace Poco::MongoDB
diff --git a/base/poco/Net/CMakeLists.txt b/base/poco/Net/CMakeLists.txt
new file mode 100644
index 00000000000..da58f20e07b
--- /dev/null
+++ b/base/poco/Net/CMakeLists.txt
@@ -0,0 +1,25 @@
+file (GLOB SRCS src/*.cpp)
+
+add_library (_poco_net ${SRCS})
+add_library (Poco::Net ALIAS _poco_net)
+
+if (OS_LINUX)
+    target_compile_definitions (_poco_net PUBLIC POCO_HAVE_FD_EPOLL)
+elseif (OS_DARWIN OR OS_FREEBSD)
+    target_compile_definitions (_poco_net PUBLIC POCO_HAVE_FD_POLL)
+endif ()
+
+target_compile_options (_poco_net
+    PRIVATE
+        -Wno-atomic-implicit-seq-cst
+        -Wno-extra-semi-stmt
+        -Wno-extra-semi
+)
+
+target_compile_options (_poco_net
+    PRIVATE
+        -Wno-deprecated
+        -Wno-extra-semi
+)
+target_include_directories (_poco_net SYSTEM PUBLIC "include")
+target_link_libraries (_poco_net PUBLIC Poco::Foundation)
diff --git a/base/poco/Net/include/Poco/Net/AbstractHTTPRequestHandler.h b/base/poco/Net/include/Poco/Net/AbstractHTTPRequestHandler.h
new file mode 100644
index 00000000000..7bbc174c811
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/AbstractHTTPRequestHandler.h
@@ -0,0 +1,136 @@
+//
+// AbstractHTTPRequestHandler.h
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  AbstractHTTPRequestHandler
+//
+// Definition of the AbstractHTTPRequestHandler class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_AbstractHTTPRequestHandler_INCLUDED
+#define Net_AbstractHTTPRequestHandler_INCLUDED
+
+
+#include "Poco/Net/HTTPRequestHandler.h"
+#include "Poco/Net/HTTPResponse.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTMLForm;
+
+
+class Net_API AbstractHTTPRequestHandler: public HTTPRequestHandler
+	/// The abstract base class for AbstractHTTPRequestHandlers 
+	/// created by HTTPServer.
+	///
+	/// Derived classes must override the run() method.
+
+	/// Contrary to a HTTPRequestHandler, an AbstractHTTPRequestHandler
+	/// stores request and response as member variables to avoid having
+	/// to pass them around as method parameters. Additionally, a
+	/// HTMLForm object is created for use by subclasses.
+	///
+	/// The run() method must perform the complete handling
+	/// of the HTTP request connection. As soon as the run() 
+	/// method returns, the request handler object is destroyed.
+	///
+	/// A new AbstractHTTPRequestHandler object will be created for
+	/// each new HTTP request that is received by the HTTPServer.
+{
+public:
+	AbstractHTTPRequestHandler();
+		/// Creates the AbstractHTTPRequestHandler.
+
+	virtual ~AbstractHTTPRequestHandler();
+		/// Destroys the AbstractHTTPRequestHandler.
+
+	void handleRequest(HTTPServerRequest& request, HTTPServerResponse& response);
+		/// This class implements some common behavior,
+		/// before calling run() to actually handle the request:
+		///   - save request and response objects;
+		///   - call authorize();
+		///   - if authorize() returns true call run(),
+		///     else send 401 (Unauthorized) response.
+		///
+		/// If run() throws an exception and the response has not been
+		/// sent yet, sends a 500 (Internal Server Error) response with
+		/// the exception's display text.
+
+	HTTPServerRequest& request();
+		/// Returns the request.
+
+	HTTPServerResponse& response();
+		/// Returns the response.
+
+	HTMLForm& form();
+		/// Returns a HTMLForm for the given request.
+		/// The HTMLForm object is created when this
+		/// member function is executed the first time.
+
+	void sendErrorResponse(HTTPResponse::HTTPStatus status, const std::string& message);
+		/// Sends a HTML error page for the given status code.
+		/// The given message is added to the page:
+		///     <HTML>
+		///         <HEAD>
+		///             <TITLE>status - reason</TITLE>
+		///         </HEAD>
+		///         <BODY>
+		///            <H1>status - reason</H1>
+		///            <P>message</P>
+		///         </BODY>
+		///     </HTML>
+	
+protected:
+	virtual void run() = 0;
+		/// Must be overridden by subclasses.
+		///
+		/// Handles the given request.
+
+	virtual bool authenticate();
+		/// Check authentication; returns true if okay, false if failed to authenticate.
+		/// The default implementation always returns true.
+		///
+		/// Subclasses can override this member function to perform
+		/// some form of client or request authentication before
+		/// the request is actually handled.
+
+private:
+	HTTPServerRequest*  _pRequest;
+	HTTPServerResponse* _pResponse;
+	HTMLForm*           _pForm;
+};
+
+
+//
+// inlines
+//
+inline HTTPServerRequest& AbstractHTTPRequestHandler::request()
+{
+	poco_check_ptr (_pRequest);
+	
+	return *_pRequest;
+}
+
+
+inline HTTPServerResponse& AbstractHTTPRequestHandler::response()
+{
+	poco_check_ptr (_pResponse);
+
+	return *_pResponse;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_AbstractHTTPRequestHandler_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/DNS.h b/base/poco/Net/include/Poco/Net/DNS.h
new file mode 100644
index 00000000000..2de47b3e26a
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/DNS.h
@@ -0,0 +1,199 @@
+//
+// DNS.h
+//
+// Library: Net
+// Package: NetCore
+// Module:  DNS
+//
+// Definition of the DNS class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_DNS_INCLUDED
+#define Net_DNS_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/SocketDefs.h"
+#include "Poco/Net/IPAddress.h"
+#include "Poco/Net/HostEntry.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API DNS
+	/// This class provides an interface to the
+	/// domain name service.
+	///
+	/// Starting with POCO C++ Libraries release 1.9.0,
+	/// this class also supports Internationalized Domain Names (IDNs).
+	///
+	/// Regarding IDNs, the following rules apply:
+	///
+	///   * An IDN passed to hostByName() must be encoded manually, by calling
+	///     encodeIDN() (after testing with isIDN() first).
+	///   * An UTF-8 IDN passed to resolve() or resolveOne() is automatically encoded.
+	///   * IDNs returned in HostEntry objects are never decoded. They can be
+	///     decoded by calling decodeIDN() (after testing for an encoded IDN by
+	///     calling isEncodedIDN()).
+{
+public:
+	enum HintFlag
+	{
+		DNS_HINT_NONE           = 0,
+#ifdef POCO_HAVE_ADDRINFO
+		DNS_HINT_AI_PASSIVE     = AI_PASSIVE,     /// Socket address will be used in bind() call
+		DNS_HINT_AI_CANONNAME   = AI_CANONNAME,   /// Return canonical name in first ai_canonname
+		DNS_HINT_AI_NUMERICHOST = AI_NUMERICHOST, /// Nodename must be a numeric address string
+		DNS_HINT_AI_NUMERICSERV = AI_NUMERICSERV, /// Servicename must be a numeric port number
+		DNS_HINT_AI_ALL         = AI_ALL,         /// Query both IP6 and IP4 with AI_V4MAPPED
+		DNS_HINT_AI_ADDRCONFIG  = AI_ADDRCONFIG,  /// Resolution only if global address configured
+		DNS_HINT_AI_V4MAPPED    = AI_V4MAPPED     /// On v6 failure, query v4 and convert to V4MAPPED format
+#endif
+	};
+
+	static HostEntry hostByName(const std::string& hostname, unsigned hintFlags =
+#ifdef POCO_HAVE_ADDRINFO
+		DNS_HINT_AI_CANONNAME | DNS_HINT_AI_ADDRCONFIG
+#else
+		DNS_HINT_NONE
+#endif
+		);
+		/// Returns a HostEntry object containing the DNS information
+		/// for the host with the given name. HintFlag argument is only
+		/// used on platforms that have getaddrinfo().
+		///
+		/// Note that Internationalized Domain Names must be encoded
+		/// using Punycode (see encodeIDN()) before calling this method.
+		///
+		/// Throws a HostNotFoundException if a host with the given
+		/// name cannot be found.
+		///
+		/// Throws a NoAddressFoundException if no address can be
+		/// found for the hostname.
+		///
+		/// Throws a DNSException in case of a general DNS error.
+		///
+		/// Throws an IOException in case of any other error.
+
+	static HostEntry hostByAddress(const IPAddress& address, unsigned hintFlags =
+#ifdef POCO_HAVE_ADDRINFO
+		DNS_HINT_AI_CANONNAME | DNS_HINT_AI_ADDRCONFIG
+#else
+		DNS_HINT_NONE
+#endif
+		);
+		/// Returns a HostEntry object containing the DNS information
+		/// for the host with the given IP address. HintFlag argument is only
+		/// used on platforms that have getaddrinfo().
+		///
+		/// Throws a HostNotFoundException if a host with the given
+		/// name cannot be found.
+		///
+		/// Throws a DNSException in case of a general DNS error.
+		///
+		/// Throws an IOException in case of any other error.
+
+	static HostEntry resolve(const std::string& address);
+		/// Returns a HostEntry object containing the DNS information
+		/// for the host with the given IP address or host name.
+		///
+		/// If address contains a UTF-8 encoded IDN (internationalized
+		/// domain name), the domain name will be encoded first using
+		/// Punycode.
+		///
+		/// Throws a HostNotFoundException if a host with the given
+		/// name cannot be found.
+		///
+		/// Throws a NoAddressFoundException if no address can be
+		/// found for the hostname.
+		///
+		/// Throws a DNSException in case of a general DNS error.
+		///
+		/// Throws an IOException in case of any other error.
+
+	static IPAddress resolveOne(const std::string& address);
+		/// Convenience method that calls resolve(address) and returns
+		/// the first address from the HostInfo.
+
+	static HostEntry thisHost();
+		/// Returns a HostEntry object containing the DNS information
+		/// for this host.
+		///
+		/// Throws a HostNotFoundException if DNS information
+		/// for this host cannot be found.
+		///
+		/// Throws a NoAddressFoundException if no address can be
+		/// found for this host.
+		///
+		/// Throws a DNSException in case of a general DNS error.
+		///
+		/// Throws an IOException in case of any other error.
+
+	static void reload();
+		/// Reloads the resolver configuration.
+		///
+		/// This method will call res_init() if the Net library
+		/// has been compiled with -DPOCO_HAVE_LIBRESOLV. Otherwise
+		/// it will do nothing.
+
+	static std::string hostName();
+		/// Returns the host name of this host.
+
+	static bool isIDN(const std::string& hostname);
+		/// Returns true if the given hostname is an internationalized
+		/// domain name (IDN) containing non-ASCII characters, otherwise false.
+		///
+		/// The IDN must be UTF-8 encoded.
+
+	static bool isEncodedIDN(const std::string& hostname);
+		/// Returns true if the given hostname is an Punycode-encoded
+		/// internationalized domain name (IDN), otherwise false.
+		///
+		/// An encoded IDN starts with the character sequence "xn--".
+
+	static std::string encodeIDN(const std::string& idn);
+		/// Encodes the given IDN (internationalized domain name), which must
+		/// be in UTF-8 encoding.
+		///
+		/// The resulting string will be encoded according to Punycode.
+
+	static std::string decodeIDN(const std::string& encodedIDN);
+		/// Decodes the given Punycode-encoded IDN (internationalized domain name).
+		///
+		/// The resulting string will be UTF-8 encoded.
+
+protected:
+	static int lastError();
+		/// Returns the code of the last error.
+
+	static void error(int code, const std::string& arg);
+		/// Throws an exception according to the error code.
+
+	static void aierror(int code, const std::string& arg);
+		/// Throws an exception according to the getaddrinfo() error code.
+
+	static std::string encodeIDNLabel(const std::string& idn);
+		/// Encodes the given IDN (internationalized domain name) label, which must
+		/// be in UTF-8 encoding.
+		///
+		/// The resulting string will be encoded according to Punycode.
+
+	static std::string decodeIDNLabel(const std::string& encodedIDN);
+		/// Decodes the given Punycode-encoded IDN (internationalized domain name) label.
+		///
+		/// The resulting string will be UTF-8 encoded.
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_DNS_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/DatagramSocket.h b/base/poco/Net/include/Poco/Net/DatagramSocket.h
new file mode 100644
index 00000000000..17d02531557
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/DatagramSocket.h
@@ -0,0 +1,168 @@
+//
+// DatagramSocket.h
+//
+// Library: Net
+// Package: Sockets
+// Module:  DatagramSocket
+//
+// Definition of the DatagramSocket class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_DatagramSocket_INCLUDED
+#define Net_DatagramSocket_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/Socket.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API DatagramSocket: public Socket
+	/// This class provides an interface to an
+	/// UDP stream socket.
+{
+public:
+	DatagramSocket();
+		/// Creates an unconnected, unbound datagram socket.
+		///
+		/// Before the datagram socket can be used, bind(),
+		/// bind6() or connect() must be called.
+		///
+		/// Notice: The behavior of this constructor has changed
+		/// in release 2.0. Previously, the constructor created
+		/// an unbound IPv4 datagram socket.
+
+	explicit DatagramSocket(SocketAddress::Family family);
+		/// Creates an unconnected datagram socket.
+		///
+		/// The socket will be created for the
+		/// given address family.
+
+	DatagramSocket(const SocketAddress& address, bool reuseAddress = false);
+		/// Creates a datagram socket and binds it
+		/// to the given address.
+		///
+		/// Depending on the address family, the socket
+		/// will be either an IPv4 or an IPv6 socket.
+
+	DatagramSocket(const Socket& socket);
+		/// Creates the DatagramSocket with the SocketImpl
+		/// from another socket. The SocketImpl must be
+		/// a DatagramSocketImpl, otherwise an InvalidArgumentException
+		/// will be thrown.
+
+	~DatagramSocket();
+		/// Destroys the DatagramSocket.
+
+	DatagramSocket& operator = (const Socket& socket);
+		/// Assignment operator.
+		///
+		/// Releases the socket's SocketImpl and
+		/// attaches the SocketImpl from the other socket and
+		/// increments the reference count of the SocketImpl.	
+
+	void connect(const SocketAddress& address);
+		/// Restricts incoming and outgoing
+		/// packets to the specified address.
+		///
+		/// Calls to connect() cannot come before calls to bind().
+
+	void bind(const SocketAddress& address, bool reuseAddress = false);
+		/// Bind a local address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. 
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// Calls to connect cannot() come before calls to bind().
+
+	void bind(const SocketAddress& address, bool reuseAddress, bool reusePort);
+		/// Bind a local address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. 
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// If reusePort is true, sets the SO_REUSEPORT
+		/// socket option.
+		///
+		/// Calls to connect cannot() come before calls to bind().
+
+	int sendBytes(const void* buffer, int length, int flags = 0);
+		/// Sends the contents of the given buffer through
+		/// the socket.
+		///
+		/// Returns the number of bytes sent, which may be
+		/// less than the number of bytes specified.
+
+	int receiveBytes(void* buffer, int length, int flags = 0);
+		/// Receives data from the socket and stores it
+		/// in buffer. Up to length bytes are received.
+		///
+		/// Returns the number of bytes received.
+
+	int sendTo(const void* buffer, int length, const SocketAddress& address, int flags = 0);
+		/// Sends the contents of the given buffer through
+		/// the socket to the given address.
+		///
+		/// Returns the number of bytes sent, which may be
+		/// less than the number of bytes specified.
+
+	int receiveFrom(void* buffer, int length, SocketAddress& address, int flags = 0);
+		/// Receives data from the socket and stores it
+		/// in buffer. Up to length bytes are received.
+		/// Stores the address of the sender in address.
+		///
+		/// Returns the number of bytes received.
+
+	void setBroadcast(bool flag);
+		/// Sets the value of the SO_BROADCAST socket option.
+		///
+		/// Setting this flag allows sending datagrams to
+		/// the broadcast address.
+	
+	bool getBroadcast() const;
+		/// Returns the value of the SO_BROADCAST socket option.
+
+protected:
+	DatagramSocket(SocketImpl* pImpl);
+		/// Creates the Socket and attaches the given SocketImpl.
+		/// The socket takes ownership of the SocketImpl.
+		///
+		/// The SocketImpl must be a StreamSocketImpl, otherwise
+		/// an InvalidArgumentException will be thrown.
+};
+
+
+//
+// inlines
+//
+inline void DatagramSocket::setBroadcast(bool flag)
+{
+	impl()->setBroadcast(flag);
+}
+
+
+inline bool DatagramSocket::getBroadcast() const
+{
+	return impl()->getBroadcast();
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_DatagramSocket_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/DatagramSocketImpl.h b/base/poco/Net/include/Poco/Net/DatagramSocketImpl.h
new file mode 100644
index 00000000000..f9d280aa1be
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/DatagramSocketImpl.h
@@ -0,0 +1,55 @@
+//
+// DatagramSocketImpl.h
+//
+// Library: Net
+// Package: Sockets
+// Module:  DatagramSocketImpl
+//
+// Definition of the DatagramSocketImpl class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_DatagramSocketImpl_INCLUDED
+#define Net_DatagramSocketImpl_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/SocketImpl.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API DatagramSocketImpl: public SocketImpl
+	/// This class implements an UDP socket.
+{
+public:
+	DatagramSocketImpl();
+		/// Creates an unconnected, unbound datagram socket.
+
+	explicit DatagramSocketImpl(SocketAddress::Family family);
+		/// Creates an unconnected datagram socket.
+		///
+		/// The socket will be created for the
+		/// given address family.
+
+	DatagramSocketImpl(poco_socket_t sockfd);
+		/// Creates a StreamSocketImpl using the given native socket.
+		
+protected:
+	void init(int af);
+	
+	~DatagramSocketImpl();
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_DatagramSocketImpl_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/DialogSocket.h b/base/poco/Net/include/Poco/Net/DialogSocket.h
new file mode 100644
index 00000000000..ca47b73ba66
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/DialogSocket.h
@@ -0,0 +1,211 @@
+//
+// DialogSocket.h
+//
+// Library: Net
+// Package: Sockets
+// Module:  DialogSocket
+//
+// Definition of the DialogSocket class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_DialogSocket_INCLUDED
+#define Net_DialogSocket_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/StreamSocket.h"
+#include <cstdlib>
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API DialogSocket: public StreamSocket
+	/// DialogSocket is a subclass of StreamSocket that
+	/// can be used for implementing request-response
+	/// based client server connections.
+	///
+	/// A request is always a single-line command terminated
+	/// by CR-LF.
+	///
+	/// A response can either be a single line of text terminated
+	/// by CR-LF, or multiple lines of text in the format used
+	/// by the FTP and SMTP protocols.
+	///
+	/// Limited support for the TELNET protocol (RFC 854) is
+	/// available.
+	///
+	/// Warning: Do not call receiveBytes() on a DialogSocket.
+	/// Due to internal buffering in DialogSocket, receiveBytes()
+	/// may return an unexpected result and interfere with
+	/// DialogSocket's buffering. Use receiveRawBytes() instead.
+{
+public:
+	DialogSocket();
+		/// Creates an unconnected stream socket.
+		///
+		/// Before sending or receiving data, the socket
+		/// must be connected with a call to connect().
+
+	explicit DialogSocket(const SocketAddress& address);
+		/// Creates a stream socket and connects it to
+		/// the socket specified by address.
+
+	DialogSocket(const Socket& socket);
+		/// Creates the DialogSocket with the SocketImpl
+		/// from another socket. The SocketImpl must be
+		/// a StreamSocketImpl, otherwise an InvalidArgumentException
+		/// will be thrown.
+
+	DialogSocket(const DialogSocket& socket);
+		/// Creates the DialogSocket as copy of another dialog socket.
+
+	~DialogSocket();
+		/// Destroys the DialogSocket.
+
+	DialogSocket& operator = (const Socket& socket);
+		/// Assignment operator.
+		///
+		/// Releases the socket's SocketImpl and
+		/// attaches the SocketImpl from the other socket and
+		/// increments the reference count of the SocketImpl.	
+
+	DialogSocket& operator = (const DialogSocket& socket);
+		/// Assignment operator.
+		
+	void sendByte(unsigned char ch);
+		/// Sends a single byte over the socket connection.
+
+	void sendString(const char* str);
+		/// Sends the given null-terminated string over
+		/// the socket connection.
+
+	void sendString(const std::string& str);
+		/// Sends the given string over the socket connection.
+
+	void sendMessage(const std::string& message);
+		/// Appends a CR-LF sequence to the message and sends it
+		/// over the socket connection.
+
+	void sendMessage(const std::string& message, const std::string& arg);
+		/// Concatenates message and arg, separated by a space, appends a
+		/// CR-LF sequence, and sends the result over the socket connection.
+
+	void sendMessage(const std::string& message, const std::string& arg1, const std::string& arg2);
+		/// Concatenates message and args, separated by a space, appends a
+		/// CR-LF sequence, and sends the result over the socket connection.
+		
+	bool receiveMessage(std::string& message);
+		/// Receives a single-line message, terminated by CR-LF,
+		/// from the socket connection and appends it to response.
+		/// 
+		/// Returns true if a message has been read or false if
+		/// the connection has been closed by the peer.
+	
+	int receiveStatusMessage(std::string& message);
+		/// Receives a single-line or multi-line response from
+		/// the socket connection. The format must be according to
+		/// one of the response formats specified in the FTP (RFC 959) 
+		/// or SMTP (RFC 2821) specifications.
+		///
+		/// The first line starts with a 3-digit status code.
+		/// Following the status code is either a space character (' ' ) 
+		/// (in case of a single-line response) or a minus character ('-')
+		/// in case of a multi-line response. The following lines can have
+		/// a three-digit status code followed by a minus-sign and some
+		/// text, or some arbitrary text only. The last line again begins
+		/// with a three-digit status code (which must be the same as the
+		/// one in the first line), followed by a space and some arbitrary 
+		/// text. All lines must be terminated by a CR-LF sequence.
+		///
+		/// The response contains all response lines, separated by a newline
+		/// character, including the status code. The status code is returned.
+		/// If the response line does not contain a status code, 0 is returned.
+	
+	int get();
+		/// Reads one character from the connection.
+		///
+		/// Returns -1 (EOF_CHAR) if no more characters are available.
+
+	int peek();
+		/// Returns the character that would be returned by the next call
+		/// to get(), without actually extracting the character from the
+		/// buffer.
+		///
+		/// Returns -1 (EOF_CHAR) if no more characters are available.
+
+	int receiveRawBytes(void* buffer, int length);
+		/// Read up to length bytes from the connection and place
+		/// them into buffer. If there are data bytes in the internal
+		/// buffer, these bytes are returned first.
+		///
+		/// Use this member function instead of receiveBytes().
+		///
+		/// Returns the number of bytes read, which may be
+		/// less than requested.
+
+	void synch();
+		/// Sends a TELNET SYNCH signal over the connection.
+		///
+		/// According to RFC 854, a TELNET_DM char is sent
+		/// via sendUrgent().
+		
+	void sendTelnetCommand(unsigned char command);
+		/// Sends a TELNET command sequence (TELNET_IAC followed
+		/// by the given command) over the connection.
+
+	void sendTelnetCommand(unsigned char command, unsigned char arg);
+		/// Sends a TELNET command sequence (TELNET_IAC followed
+		/// by the given command, followed by arg) over the connection.
+
+	enum TelnetCodes
+	{
+		TELNET_SE   = 240,
+		TELNET_NOP  = 241,
+		TELNET_DM   = 242,
+		TELNET_BRK  = 243,
+		TELNET_IP   = 244,
+		TELNET_AO   = 245,
+		TELNET_AYT  = 246,
+		TELNET_EC   = 247,
+		TELNET_EL   = 248,
+		TELNET_GA   = 249,
+		TELNET_SB   = 250,
+		TELNET_WILL = 251,
+		TELNET_WONT = 252,
+		TELNET_DO   = 253,
+		TELNET_DONT = 254,
+		TELNET_IAC  = 255
+	};
+
+protected:
+	void allocBuffer();
+	void refill();
+	bool receiveLine(std::string& line, std::size_t lineLengthLimit = 0);
+	int receiveStatusLine(std::string& line, std::size_t lineLengthLimit = 0);
+
+private:
+	enum
+	{
+		RECEIVE_BUFFER_SIZE = 1024,
+		MAX_LINE_LENGTH     = 4096,
+		EOF_CHAR            = -1
+	};
+	
+	char* _pBuffer;
+	char* _pNext;
+	char* _pEnd;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_DialogSocket_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/FTPClientSession.h b/base/poco/Net/include/Poco/Net/FTPClientSession.h
new file mode 100644
index 00000000000..1750cfc028c
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/FTPClientSession.h
@@ -0,0 +1,403 @@
+//
+// FTPClientSession.h
+//
+// Library: Net
+// Package: FTP
+// Module:  FTPClientSession
+//
+// Definition of the FTPClientSession class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_FTPClientSession_INCLUDED
+#define Net_FTPClientSession_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/DialogSocket.h"
+#include "Poco/Timespan.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class SocketStream;
+
+
+class Net_API FTPClientSession
+	/// This class implements an File Transfer Protocol
+	/// (FTP, RFC 959) client.
+	///
+	/// Most of the features of the FTP protocol, as specified
+	/// in RFC 959, are supported. Not supported are EBCDIC and
+	/// LOCAL data types and format control and structured files.
+	///
+	/// Also supported are the EPRT and EPSV commands from
+	/// RFC 1738 (FTP Extensions for IPv6 and NAT).
+	/// The client will first attempt to use the EPRT and EPSV
+	/// commands. If the server does not supports these commands,
+	/// the client will fall back to PORT and PASV.
+{
+public:
+	enum
+	{
+		FTP_PORT = 21
+	};
+	
+	enum FileType
+	{
+		TYPE_TEXT,   // TYPE A (ASCII)
+		TYPE_BINARY  // TYPE I (Image)
+	};
+	
+	FTPClientSession();
+		/// Creates an FTPClientSession.
+		///
+		/// Passive mode will be used for data transfers.
+
+	explicit FTPClientSession(const StreamSocket& socket);
+		/// Creates an FTPClientSession using the given
+		/// connected socket for the control connection.
+		///
+		/// Passive mode will be used for data transfers.
+		
+	FTPClientSession(const std::string& host,
+		Poco::UInt16 port = FTP_PORT,
+		const std::string& username = "",
+		const std::string& password = "");
+		/// Creates an FTPClientSession using a socket connected
+		/// to the given host and port. If username is supplied,
+		/// login is attempted.
+		///
+		/// Passive mode will be used for data transfers.
+		
+	virtual ~FTPClientSession();
+		/// Destroys the FTPClientSession.
+	
+	void setTimeout(const Poco::Timespan& timeout);
+		/// Sets the timeout for socket operations.
+		
+	Poco::Timespan getTimeout() const;
+		/// Returns the timeout for socket operations.
+
+	void setPassive(bool flag, bool useRFC1738 = true);
+		/// Enables (default) or disables FTP passive mode for this session.
+		///
+		/// If useRFC1738 is true (the default), the RFC 1738
+		/// EPSV command is used (with a fallback to PASV if EPSV fails)
+		/// for switching to passive mode. The same applies to
+		/// EPRT and PORT for active connections.
+		
+	bool getPassive() const;
+		/// Returns true iff passive mode is enabled for this connection.
+		
+	void open(const std::string& host,
+		Poco::UInt16 port,
+		const std::string& username = "",
+		const std::string& password = "");
+		/// Opens the FTP connection to the given host and port.
+		/// If username is supplied, login is attempted.
+
+	void login(const std::string& username, const std::string& password);
+		/// Authenticates the user against the FTP server. Must be
+		/// called before any other commands (except QUIT) can be sent.
+		///
+		/// Sends a USER command followed by a PASS command with the
+		/// respective arguments to the server.
+		///
+		/// Throws a FTPException in case of a FTP-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	void logout();
+
+	void close();
+		/// Sends a QUIT command and closes the connection to the server.
+		///
+		/// Throws a FTPException in case of a FTP-specific error, or a
+		/// NetException in case of a general network communication failure.
+	
+	std::string systemType();
+		/// Returns the system type of the FTP server.
+		///
+		/// Sends a SYST command to the server and returns the result.
+	
+	void setFileType(FileType type);
+		/// Sets the file type for transferring files.
+		///
+		/// Sends a TYPE command with a corresponding argument to the
+		/// server.
+		///
+		/// Throws a FTPException in case of a FTP-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	FileType getFileType() const;
+		/// Returns the file type for transferring files.
+
+	void setWorkingDirectory(const std::string& path);
+		/// Changes the current working directory on the server.
+		///
+		/// Sends a CWD command with the given path as argument to the 
+		/// server.
+		///
+		/// Throws a FTPException in case of a FTP-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	std::string getWorkingDirectory();
+		/// Returns the current working directory on the server.
+		///
+		/// Throws a FTPException in case of a FTP-specific error, or a
+		/// NetException in case of a general network communication failure.
+		
+	void cdup();
+		/// Moves one directory up from the current working directory
+		/// on the server.
+		///
+		/// Sends a CDUP command to the server.
+		///
+		/// Throws a FTPException in case of a FTP-specific error, or a
+		/// NetException in case of a general network communication failure.
+		
+	void rename(const std::string& oldName, const std::string& newName);
+		/// Renames the file on the server given by oldName to newName.
+		///
+		/// Sends a RNFR command, followed by a RNTO command to the server.
+		///
+		/// Throws a FTPException in case of a FTP-specific error, or a
+		/// NetException in case of a general network communication failure.
+		
+	void remove(const std::string& path);
+		/// Deletes the file specified by path on the server.
+		///
+		/// Sends a DELE command with path as argument to the server.
+		///
+		/// Throws a FTPException in case of a FTP-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	void createDirectory(const std::string& path);
+		/// Creates a new directory with the given path on the server.
+		///
+		/// Sends a MKD command with path as argument to the server.
+		///
+		/// Throws a FTPException in case of a FTP-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	void removeDirectory(const std::string& path);
+		/// Removes the directory specified by path from the server.
+		///
+		/// Sends a RMD command with path as argument to the server.
+		///
+		/// Throws a FTPException in case of a FTP-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	std::istream& beginDownload(const std::string& path);
+		/// Starts downloading the file with the given name.
+		/// After all data has been read from the returned stream,
+		/// endDownload() must be called to finish the download.
+		///
+		/// A stream for reading the file's content is returned.
+		/// The stream is valid until endDownload() is called.
+		///
+		/// Creates a data connection between the client and the
+		/// server. If passive mode is on, then the server waits for
+		/// a connection request from the client. Otherwise, the
+		/// client waits for a connection request from the server.
+		/// After establishing the data connection, a SocketStream
+		/// for transferring the data is created.
+		///
+		/// If ASCII transfer mode is selected, the caller is
+		/// responsible for converting the received data to
+		/// the native text file format.
+		/// The InputLineEndingConverter class from the Foundation
+		/// library can be used for that purpose.
+		
+	void endDownload();
+		/// Must be called to complete a download initiated with
+		/// beginDownload().
+		
+	std::ostream& beginUpload(const std::string& path);
+		/// Starts uploading the file with the given name.
+		/// After all data has been written to the returned stream,
+		/// endUpload() must be called to finish the upload.
+		///
+		/// A stream for reading the file's content is returned.
+		/// The stream is valid until endUpload() is called.
+		///
+		/// Creates a data connection between the client and the
+		/// server. If passive mode is on, then the server waits for
+		/// a connection request from the client. Otherwise, the
+		/// client waits for a connection request from the server.
+		/// After establishing the data connection, a SocketStream
+		/// for transferring the data is created.
+		///
+		/// If ASCII transfer mode is selected, the caller is
+		/// responsible for converting the data to be sent
+		/// into network (CR-LF line endings) format.
+		/// The OutputLineEndingConverter class from the Foundation
+		/// library can be used for that purpose.
+
+	void endUpload();
+		/// Must be called to complete an upload initiated with
+		/// beginUpload().
+
+	std::istream& beginList(const std::string& path = "", bool extended = false);
+		/// Starts downloading a directory listing.
+		/// After all data has been read from the returned stream,
+		/// endList() must be called to finish the download.
+		///
+		/// A stream for reading the directory data is returned.
+		/// The stream is valid until endList() is called.
+		///
+		/// Optionally, a path to a directory or file can be specified.
+		/// According to the FTP protocol, if a path to a filename is
+		/// given, only information for the specific file is returned.
+		/// If a path to a directory is given, a listing of that directory
+		/// is returned. If no path is given, a listing of the current
+		/// working directory is returned.
+		///
+		/// If extended is false, only a filenames (one per line) are
+		/// returned. Otherwise, a full directory listing including
+		/// file attributes is returned. The format of this listing
+		/// depends on the FTP server. No attempt is made to interpret
+		/// this data.
+		///
+		/// Creates a data connection between the client and the
+		/// server. If passive mode is on, then the server waits for
+		/// a connection request from the client. Otherwise, the
+		/// client waits for a connection request from the server.
+		/// After establishing the data connection, a SocketStream
+		/// for transferring the data is created.
+		
+	void endList();
+		/// Must be called to complete a directory listing download 
+		/// initiated with beginList().
+
+	void abort();
+		/// Aborts the download or upload currently in progress.
+		///
+		/// Sends a TELNET IP/SYNCH sequence, followed by an ABOR
+		/// command to the server.
+		///
+		/// A separate call to endDownload() or endUpload() is
+		/// not necessary.
+		
+	int sendCommand(const std::string& command, std::string& response);
+		/// Sends the given command verbatim to the server
+		/// and waits for a response.
+
+	int sendCommand(const std::string& command, const std::string& arg, std::string& response);
+		/// Sends the given command verbatim to the server
+		/// and waits for a response.
+
+	bool isOpen() const;
+		/// Returns true if the connection with FTP server is opened.
+
+	bool isLoggedIn() const;
+		/// Returns true if the session is logged in.
+
+protected:
+	enum StatusClass
+	{
+		FTP_POSITIVE_PRELIMINARY  = 1,
+		FTP_POSITIVE_COMPLETION   = 2,
+		FTP_POSITIVE_INTERMEDIATE = 3,
+		FTP_TRANSIENT_NEGATIVE    = 4,
+		FTP_PERMANENT_NEGATIVE    = 5
+	};
+	enum
+	{
+		DEFAULT_TIMEOUT = 30000000 // 30 seconds default timeout for socket operations	
+	};
+
+	static bool isPositivePreliminary(int status);
+	static bool isPositiveCompletion(int status);
+	static bool isPositiveIntermediate(int status);
+	static bool isTransientNegative(int status);
+	static bool isPermanentNegative(int status);
+	std::string extractPath(const std::string& response);
+	StreamSocket establishDataConnection(const std::string& command, const std::string& arg);
+	StreamSocket activeDataConnection(const std::string& command, const std::string& arg);
+	StreamSocket passiveDataConnection(const std::string& command, const std::string& arg);
+	void sendPortCommand(const SocketAddress& addr);
+	SocketAddress sendPassiveCommand();
+	bool sendEPRT(const SocketAddress& addr);
+	void sendPORT(const SocketAddress& addr);
+	bool sendEPSV(SocketAddress& addr);
+	void sendPASV(SocketAddress& addr);
+	void parseAddress(const std::string& str, SocketAddress& addr);
+	void parseExtAddress(const std::string& str, SocketAddress& addr);
+	void endTransfer();
+	
+private:
+	FTPClientSession(const FTPClientSession&);
+	FTPClientSession& operator = (const FTPClientSession&);
+		
+	std::string    _host;
+	Poco::UInt16   _port;
+	DialogSocket*  _pControlSocket;
+	SocketStream*  _pDataStream;
+	bool	   _passiveMode;
+	FileType       _fileType;
+	bool	   _supports1738;
+	bool	   _serverReady;
+	bool	   _isLoggedIn;
+	Poco::Timespan _timeout;
+};
+
+
+//
+// inlines
+//
+inline bool FTPClientSession::isPositivePreliminary(int status)
+{
+	return status/100 == FTP_POSITIVE_PRELIMINARY;
+}
+
+
+inline bool FTPClientSession::isPositiveCompletion(int status)
+{
+	return status/100 == FTP_POSITIVE_COMPLETION;
+}
+
+
+inline bool FTPClientSession::isPositiveIntermediate(int status)
+{
+	return status/100 == FTP_POSITIVE_INTERMEDIATE;
+}
+
+
+inline bool FTPClientSession::isTransientNegative(int status)
+{
+	return status/100 == FTP_TRANSIENT_NEGATIVE;
+}
+
+
+inline bool FTPClientSession::isPermanentNegative(int status)
+{
+	return status/100 == FTP_PERMANENT_NEGATIVE;
+}
+
+
+inline bool FTPClientSession::isOpen() const
+{
+	return _pControlSocket != 0;
+}
+
+
+inline bool FTPClientSession::isLoggedIn() const
+{
+	return _isLoggedIn;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_FTPClientSession_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/FTPStreamFactory.h b/base/poco/Net/include/Poco/Net/FTPStreamFactory.h
new file mode 100644
index 00000000000..4f33f19c19b
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/FTPStreamFactory.h
@@ -0,0 +1,120 @@
+//
+// FTPStreamFactory.h
+//
+// Library: Net
+// Package: FTP
+// Module:  FTPStreamFactory
+//
+// Definition of the FTPStreamFactory class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_FTPStreamFactory_INCLUDED
+#define Net_FTPStreamFactory_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/HTTPSession.h"
+#include "Poco/URIStreamFactory.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API FTPPasswordProvider
+	/// The base class for all password providers.
+	/// An instance of a subclass of this class can be
+	/// registered with the FTPStreamFactory to 
+	/// provide a password
+{
+public:
+	virtual std::string password(const std::string& username, const std::string& host) = 0;
+		/// Provide the password for the given user on the given host.
+
+protected:
+	FTPPasswordProvider();
+	virtual ~FTPPasswordProvider();
+};
+
+
+class Net_API FTPStreamFactory: public Poco::URIStreamFactory
+	/// An implementation of the URIStreamFactory interface
+	/// that handles File Transfer Protocol (ftp) URIs.
+	///
+	/// The URI's path may end with an optional type specification
+	/// in the form (;type=<typecode>), where <typecode> is
+	/// one of a, i or d. If type=a, the file identified by the path
+	/// is transferred in ASCII (text) mode. If type=i, the file
+	/// is transferred in Image (binary) mode. If type=d, a directory
+	/// listing (in NLST format) is returned. This corresponds with
+	/// the FTP URL format specified in RFC 1738.
+	///
+	/// If the URI does not contain a username and password, the
+	/// username "anonymous" and the password "
+{
+public:
+	FTPStreamFactory();
+		/// Creates the FTPStreamFactory.
+
+	~FTPStreamFactory();
+		/// Destroys the FTPStreamFactory.
+		
+	std::istream* open(const Poco::URI& uri);
+		/// Creates and opens a HTTP stream for the given URI.
+		/// The URI must be a ftp://... URI.
+		///
+		/// Throws a NetException if anything goes wrong.
+		
+	static void setAnonymousPassword(const std::string& password);
+		/// Sets the password used for anonymous FTP.
+		///
+		/// WARNING: Setting the anonymous password is not
+		/// thread-safe, so it's best to call this method
+		/// during application initialization, before the
+		/// FTPStreamFactory is used for the first time.
+		
+	static const std::string& getAnonymousPassword();
+		/// Returns the password used for anonymous FTP.
+		
+	static void setPasswordProvider(FTPPasswordProvider* pProvider);
+		/// Sets the FTPPasswordProvider. If NULL is given,
+		/// no password provider is used.
+		///
+		/// WARNING: Setting the password provider is not
+		/// thread-safe, so it's best to call this method
+		/// during application initialization, before the
+		/// FTPStreamFactory is used for the first time.
+		
+	static FTPPasswordProvider* getPasswordProvider();
+		/// Returns the FTPPasswordProvider currently in use,
+		/// or NULL if no one has been set.
+
+	static void registerFactory();
+		/// Registers the FTPStreamFactory with the
+		/// default URIStreamOpener instance.
+
+	static void unregisterFactory();
+		/// Unregisters the FTPStreamFactory with the
+		/// default URIStreamOpener instance.
+
+protected:
+	static void splitUserInfo(const std::string& userInfo, std::string& username, std::string& password);
+	static void getUserInfo(const Poco::URI& uri, std::string& username, std::string& password);
+	static void getPathAndType(const Poco::URI& uri, std::string& path, char& type);
+	
+private:
+	static std::string          _anonymousPassword;
+	static FTPPasswordProvider* _pPasswordProvider;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_FTPStreamFactory_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/FilePartSource.h b/base/poco/Net/include/Poco/Net/FilePartSource.h
new file mode 100644
index 00000000000..056718541d7
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/FilePartSource.h
@@ -0,0 +1,77 @@
+//
+// FilePartSource.h
+//
+// Library: Net
+// Package: Messages
+// Module:  FilePartSource
+//
+// Definition of the FilePartSource class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_FilePartSource_INCLUDED
+#define Net_FilePartSource_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/PartSource.h"
+#include "Poco/FileStream.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API FilePartSource: public PartSource
+	/// An implementation of PartSource for
+	/// plain files.
+{
+public:
+	FilePartSource(const std::string& path);
+		/// Creates the FilePartSource for the given path.
+		///
+		/// The MIME type is set to application/octet-stream.
+		///
+		/// Throws an OpenFileException if the file cannot be opened.
+	
+	FilePartSource(const std::string& path, const std::string& mediaType);
+		/// Creates the FilePartSource for the given
+		/// path and MIME type.
+		///
+		/// Throws an OpenFileException if the file cannot be opened.
+
+	FilePartSource(const std::string& path, const std::string& filename, const std::string& mediaType);
+		/// Creates the FilePartSource for the given
+		/// path and MIME type. The given filename is 
+		/// used as part filename (see filename()) only.
+		///
+		/// Throws an OpenFileException if the file cannot be opened.
+
+	~FilePartSource();
+		/// Destroys the FilePartSource.
+
+	std::istream& stream();
+		/// Returns a file input stream for the given file.
+		
+	const std::string& filename() const;
+		/// Returns the filename portion of the path.
+
+	std::streamsize getContentLength() const;
+		/// Returns the file size.
+
+private:
+	std::string _path;
+	std::string _filename;
+	Poco::FileInputStream _istr;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_FilePartSource_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTMLForm.h b/base/poco/Net/include/Poco/Net/HTMLForm.h
new file mode 100644
index 00000000000..a4649dd2c20
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTMLForm.h
@@ -0,0 +1,272 @@
+//
+// HTMLForm.h
+//
+// Library: Net
+// Package: HTML
+// Module:  HTMLForm
+//
+// Definition of the HTMLForm class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTMLForm_INCLUDED
+#define Net_HTMLForm_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/NameValueCollection.h"
+#include <ostream>
+#include <istream>
+#include <vector>
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPRequest;
+class PartHandler;
+class PartSource;
+
+
+class Net_API HTMLForm: public NameValueCollection
+	/// HTMLForm is a helper class for working with HTML forms,
+	/// both on the client and on the server side.
+	///
+	/// The maximum number of form fields can be restricted
+	/// by calling setFieldLimit(). This is useful to
+	/// defend against certain kinds of denial-of-service
+	/// attacks. The limit is only enforced when parsing
+	/// form data from a stream or string, not when adding
+	/// form fields programmatically. The default limit is 100.
+{
+public:
+	enum Options
+	{
+		OPT_USE_CONTENT_LENGTH = 0x01
+			/// Don't use Chunked Transfer-Encoding for multipart requests.
+	};
+
+	HTMLForm();
+		/// Creates an empty HTMLForm and sets the
+		/// encoding to "application/x-www-form-urlencoded".
+
+	explicit HTMLForm(const std::string& encoding);
+		/// Creates an empty HTMLForm that uses
+		/// the given encoding.
+		///
+		/// Encoding must be either "application/x-www-form-urlencoded"
+		/// (which is the default) or "multipart/form-data".
+
+	HTMLForm(const HTTPRequest& request, std::istream& requestBody, PartHandler& handler);
+		/// Creates a HTMLForm from the given HTTP request.
+		///
+		/// Uploaded files are passed to the given PartHandler.
+
+	HTMLForm(const HTTPRequest& request, std::istream& requestBody);
+		/// Creates a HTMLForm from the given HTTP request.
+		///
+		/// Uploaded files are silently discarded.
+
+	explicit HTMLForm(const HTTPRequest& request);
+		/// Creates a HTMLForm from the given HTTP request.
+		///
+		/// The request must be a GET request and the form data
+		/// must be in the query string (URL encoded).
+		///
+		/// For POST requests, you must use one of the constructors
+		/// taking an additional input stream for the request body.
+
+	~HTMLForm();
+		/// Destroys the HTMLForm.
+
+	void setEncoding(const std::string& encoding);
+		/// Sets the encoding used for posting the form.
+		///
+		/// Encoding must be either "application/x-www-form-urlencoded"
+		/// (which is the default) or "multipart/form-data".
+
+	const std::string& getEncoding() const;
+		/// Returns the encoding used for posting the form.
+
+	void addPart(const std::string& name, PartSource* pSource);
+		/// Adds an part/attachment (file upload) to the form.
+		///
+		/// The form takes ownership of the PartSource and deletes it
+		/// when it is no longer needed.
+		///
+		/// The part will only be sent if the encoding
+		/// set for the form is "multipart/form-data"
+
+	void load(const HTTPRequest& request, std::istream& requestBody, PartHandler& handler);
+		/// Reads the form data from the given HTTP request.
+		///
+		/// Uploaded files are passed to the given PartHandler.
+
+	void load(const HTTPRequest& request, std::istream& requestBody);
+		/// Reads the form data from the given HTTP request.
+		///
+		/// Uploaded files are silently discarded.
+
+	void load(const HTTPRequest& request);
+		/// Reads the form data from the given HTTP request.
+		///
+		/// The request must be a GET request and the form data
+		/// must be in the query string (URL encoded).
+		///
+		/// For POST requests, you must use one of the overloads
+		/// taking an additional input stream for the request body.
+
+	void read(std::istream& istr, PartHandler& handler);
+		/// Reads the form data from the given input stream.
+		///
+		/// The form data read from the stream must be
+		/// in the encoding specified for the form.
+		///
+		/// Note that read() does not clear the form before
+		/// reading the new values.
+
+	void read(std::istream& istr);
+		/// Reads the URL-encoded form data from the given input stream.
+		///
+		/// Note that read() does not clear the form before
+		/// reading the new values.
+
+	void read(const std::string& queryString);
+		/// Reads the form data from the given HTTP query string.
+		///
+		/// Note that read() does not clear the form before
+		/// reading the new values.
+
+	void prepareSubmit(HTTPRequest& request, int options = 0);
+		/// Fills out the request object for submitting the form.
+		///
+		/// If the request method is GET, the encoded form is appended to the
+		/// request URI as query string. Otherwise (the method is
+		/// POST), the form's content type is set to the form's encoding.
+		/// The form's parameters must be written to the
+		/// request body separately, with a call to write.
+		/// If the request's HTTP version is HTTP/1.0:
+		///    - persistent connections are disabled
+		///    - the content transfer encoding is set to identity encoding
+		/// Otherwise, if the request's HTTP version is HTTP/1.1:
+		///    - the request's persistent connection state is left unchanged
+		///    - the content transfer encoding is set to chunked, unless
+		///      the OPT_USE_CONTENT_LENGTH is given in options
+		///
+		/// Note: Not using chunked transfer encoding for multipart forms
+		/// degrades performance, as the request content must be generated
+		/// twice, first to determine its size, then to actually send it.
+
+	std::streamsize calculateContentLength();
+		/// Calculate the content length for the form.
+		/// May be UNKNOWN_CONTENT_LENGTH if not possible
+		/// to calculate
+
+	void write(std::ostream& ostr, const std::string& boundary);
+		/// Writes the form data to the given output stream,
+		/// using the specified encoding.
+
+	void write(std::ostream& ostr);
+		/// Writes the form data to the given output stream,
+		/// using the specified encoding.
+
+	const std::string& boundary() const;
+		/// Returns the MIME boundary used for writing
+		/// multipart form data.
+
+	int getFieldLimit() const;
+		/// Returns the maximum number of header fields
+		/// allowed.
+		///
+		/// See setFieldLimit() for more information.
+
+	void setFieldLimit(int limit);
+		/// Sets the maximum number of header fields
+		/// allowed. This limit is used to defend certain
+		/// kinds of denial-of-service attacks.
+		/// Specify 0 for unlimited (not recommended).
+		///
+		/// The default limit is 100.
+
+	void setValueLengthLimit(int limit);
+		/// Sets the maximum size for form field values
+		/// stored as strings.
+
+	int getValueLengthLimit() const;
+		/// Returns the maximum size for form field values
+		/// stored as strings.
+
+	static const std::string ENCODING_URL;       /// "application/x-www-form-urlencoded"
+	static const std::string ENCODING_MULTIPART; /// "multipart/form-data"
+	static const int         UNKNOWN_CONTENT_LENGTH;
+
+protected:
+	void readUrl(std::istream& istr);
+	void readMultipart(std::istream& istr, PartHandler& handler);
+	void writeUrl(std::ostream& ostr);
+	void writeMultipart(std::ostream& ostr);
+
+private:
+	HTMLForm(const HTMLForm&);
+	HTMLForm& operator = (const HTMLForm&);
+
+	enum Limits
+	{
+		DFL_FIELD_LIMIT = 100,
+		MAX_NAME_LENGTH  = 1024,
+		DFL_MAX_VALUE_LENGTH = 256*1024
+	};
+
+	struct Part
+	{
+		std::string name;
+		PartSource* pSource;
+	};
+
+	typedef std::vector<Part> PartVec;
+
+	int         _fieldLimit;
+	int         _valueLengthLimit;
+	std::string _encoding;
+	std::string _boundary;
+	PartVec     _parts;
+};
+
+
+//
+// inlines
+//
+inline const std::string& HTMLForm::getEncoding() const
+{
+	return _encoding;
+}
+
+
+inline const std::string& HTMLForm::boundary() const
+{
+	return _boundary;
+}
+
+
+inline int HTMLForm::getFieldLimit() const
+{
+	return _fieldLimit;
+}
+
+
+inline int HTMLForm::getValueLengthLimit() const
+{
+	return _valueLengthLimit;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTMLForm_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPAuthenticationParams.h b/base/poco/Net/include/Poco/Net/HTTPAuthenticationParams.h
new file mode 100644
index 00000000000..492e2c45d42
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPAuthenticationParams.h
@@ -0,0 +1,103 @@
+//
+// HTTPAuthenticationParams.h
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPAuthenticationParams
+//
+// Definition of the HTTPAuthenticationParams class.
+//
+// Copyright (c) 2011, Anton V. Yabchinskiy (arn at bestmx dot ru).
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPAuthenticationParams_INCLUDED
+#define Net_HTTPAuthenticationParams_INCLUDED
+
+
+#include "Poco/Net/NameValueCollection.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPRequest;
+class HTTPResponse;
+
+
+class Net_API HTTPAuthenticationParams: public NameValueCollection
+	/// Collection of name-value pairs of HTTP authentication header (i.e.
+	/// "realm", "qop", "nonce" in case of digest authentication header).
+{
+public:
+	HTTPAuthenticationParams();
+		/// Creates an empty authentication parameters collection.
+
+	explicit HTTPAuthenticationParams(const std::string& authInfo);
+		/// See fromAuthInfo() documentation.
+
+	explicit HTTPAuthenticationParams(const HTTPRequest& request);
+		/// See fromRequest() documentation.
+
+	HTTPAuthenticationParams(const HTTPResponse& response, const std::string& header = WWW_AUTHENTICATE);
+		/// See fromResponse() documentation.
+
+	virtual ~HTTPAuthenticationParams();
+		/// Destroys the HTTPAuthenticationParams.
+
+	HTTPAuthenticationParams& operator = (const HTTPAuthenticationParams& authParams);
+		/// Assigns the content of another HTTPAuthenticationParams.
+
+	void fromAuthInfo(const std::string& authInfo);
+		/// Creates an HTTPAuthenticationParams by parsing authentication
+		/// information.
+
+	void fromRequest(const HTTPRequest& request);
+		/// Extracts authentication information from the request and creates
+		/// HTTPAuthenticationParams by parsing it.
+		///
+		/// Throws a NotAuthenticatedException if no authentication
+		/// information is contained in request.
+		/// Throws a InvalidArgumentException if authentication scheme is
+		/// unknown or invalid.
+
+	void fromResponse(const HTTPResponse& response, const std::string& header = WWW_AUTHENTICATE);
+		/// Extracts authentication information from the response and creates
+		/// HTTPAuthenticationParams by parsing it.
+		///
+		/// Throws a NotAuthenticatedException if no authentication
+		/// information is contained in response.
+		/// Throws a InvalidArgumentException if authentication scheme is
+		/// unknown or invalid.
+
+	void setRealm(const std::string& realm);
+		/// Sets the "realm" parameter to the provided string.
+
+	const std::string& getRealm() const;
+		/// Returns value of the "realm" parameter.
+		///
+		/// Throws NotFoundException is there is no "realm" set in the
+		/// HTTPAuthenticationParams.
+
+	std::string toString() const;
+		/// Formats the HTTPAuthenticationParams for inclusion in HTTP
+		/// request or response authentication header.
+
+	static const std::string REALM;
+	static const std::string WWW_AUTHENTICATE;
+	static const std::string PROXY_AUTHENTICATE;
+
+private:
+	void parse(std::string::const_iterator first, std::string::const_iterator last);
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPAuthenticationParams_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPBasicCredentials.h b/base/poco/Net/include/Poco/Net/HTTPBasicCredentials.h
new file mode 100644
index 00000000000..56894db8ca2
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPBasicCredentials.h
@@ -0,0 +1,123 @@
+//
+// HTTPBasicCredentials.h
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPBasicCredentials
+//
+// Definition of the HTTPBasicCredentials class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPBasicCredentials_INCLUDED
+#define Net_HTTPBasicCredentials_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPRequest;
+
+
+class Net_API HTTPBasicCredentials
+	/// This is a utility class for working with
+	/// HTTP Basic Authentication in HTTPRequest
+	/// objects.
+{
+public:
+	HTTPBasicCredentials();
+		/// Creates an empty HTTPBasicCredentials object.
+
+	HTTPBasicCredentials(const std::string& username, const std::string& password);
+		/// Creates a HTTPBasicCredentials object with the given username and password.
+
+	explicit HTTPBasicCredentials(const HTTPRequest& request);
+		/// Creates a HTTPBasicCredentials object with the authentication information
+		/// from the given request.
+		///
+		/// Throws a NotAuthenticatedException if the request does
+		/// not contain basic authentication information.
+
+	explicit HTTPBasicCredentials(const std::string& authInfo);
+		/// Creates a HTTPBasicCredentials object with the authentication information
+		/// in the given string. The authentication information can be extracted
+		/// from a HTTPRequest object by calling HTTPRequest::getCredentials().
+
+	~HTTPBasicCredentials();
+		/// Destroys the HTTPBasicCredentials.
+
+	void clear();
+		/// Clears both username and password.
+
+	void setUsername(const std::string& username);
+		/// Sets the username.
+
+	const std::string& getUsername() const;
+		/// Returns the username.
+
+	void setPassword(const std::string& password);
+		/// Sets the password.
+
+	const std::string& getPassword() const;
+		/// Returns the password.
+
+	bool empty() const;
+		/// Returns true if both username and password are empty, otherwise false.
+
+	void authenticate(HTTPRequest& request) const;
+		/// Adds authentication information to the given HTTPRequest.
+
+	void proxyAuthenticate(HTTPRequest& request) const;
+		/// Adds proxy authentication information to the given HTTPRequest.
+
+	static const std::string SCHEME;
+
+protected:
+	void parseAuthInfo(const std::string& authInfo);
+		/// Extracts username and password from Basic authentication info
+		/// by base64-decoding authInfo and splitting the resulting
+		/// string at the ':' delimiter.
+
+private:
+	HTTPBasicCredentials(const HTTPBasicCredentials&);
+	HTTPBasicCredentials& operator = (const HTTPBasicCredentials&);
+
+	std::string _username;
+	std::string _password;
+};
+
+
+//
+// inlines
+//
+inline const std::string& HTTPBasicCredentials::getUsername() const
+{
+	return _username;
+}
+
+
+inline const std::string& HTTPBasicCredentials::getPassword() const
+{
+	return _password;
+}
+
+
+inline bool HTTPBasicCredentials::empty() const
+{
+	return _username.empty() && _password.empty();
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPBasicCredentials_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPBasicStreamBuf.h b/base/poco/Net/include/Poco/Net/HTTPBasicStreamBuf.h
new file mode 100644
index 00000000000..0edbec3298c
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPBasicStreamBuf.h
@@ -0,0 +1,36 @@
+//
+// HTTPBasicStreamBuf.h
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPBasicStreamBuf
+//
+// Definition of the HTTPBasicStreamBuf class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPBasicStreamBuf_INCLUDED
+#define Net_HTTPBasicStreamBuf_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/BufferedStreamBuf.h"
+#include "Poco/Net/HTTPBufferAllocator.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+typedef Poco::BasicBufferedStreamBuf<char, std::char_traits<char>, HTTPBufferAllocator> HTTPBasicStreamBuf;
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPBasicStreamBuf_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPBufferAllocator.h b/base/poco/Net/include/Poco/Net/HTTPBufferAllocator.h
new file mode 100644
index 00000000000..512dd65e839
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPBufferAllocator.h
@@ -0,0 +1,50 @@
+//
+// HTTPBufferAllocator.h
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPBufferAllocator
+//
+// Definition of the HTTPBufferAllocator class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPBufferAllocator_INCLUDED
+#define Net_HTTPBufferAllocator_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/MemoryPool.h"
+#include <ios>
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API HTTPBufferAllocator
+	/// A BufferAllocator for HTTP streams.
+{
+public:
+	static char* allocate(std::streamsize size);
+	static void deallocate(char* ptr, std::streamsize size);
+
+	enum
+	{
+		BUFFER_SIZE = 128 * 1024 
+	};
+
+private:
+	static Poco::MemoryPool _pool;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPBufferAllocator_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPChunkedStream.h b/base/poco/Net/include/Poco/Net/HTTPChunkedStream.h
new file mode 100644
index 00000000000..c5988af944a
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPChunkedStream.h
@@ -0,0 +1,108 @@
+//
+// HTTPChunkedStream.h
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPChunkedStream
+//
+// Definition of the HTTPChunkedStream class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPChunkedStream_INCLUDED
+#define Net_HTTPChunkedStream_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/HTTPBasicStreamBuf.h"
+#include "Poco/MemoryPool.h"
+#include <cstddef>
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPSession;
+
+
+class Net_API HTTPChunkedStreamBuf: public HTTPBasicStreamBuf
+	/// This is the streambuf class used for reading and writing
+	/// HTTP message bodies in chunked transfer coding.
+{
+public:
+	typedef HTTPBasicStreamBuf::openmode openmode;
+
+	HTTPChunkedStreamBuf(HTTPSession& session, openmode mode);
+	~HTTPChunkedStreamBuf();
+	void close();
+
+protected:
+	int readFromDevice(char* buffer, std::streamsize length);
+	int writeToDevice(const char* buffer, std::streamsize length);
+
+	unsigned int parseChunkLen();
+	void skipCRLF();
+
+private:
+	HTTPSession&    _session;
+	openmode        _mode;
+	std::streamsize _chunk;
+	std::string     _chunkBuffer;
+};
+
+
+class Net_API HTTPChunkedIOS: public virtual std::ios
+	/// The base class for HTTPInputStream.
+{
+public:
+	HTTPChunkedIOS(HTTPSession& session, HTTPChunkedStreamBuf::openmode mode);
+	~HTTPChunkedIOS();
+	HTTPChunkedStreamBuf* rdbuf();
+
+protected:
+	HTTPChunkedStreamBuf _buf;
+};
+
+
+class Net_API HTTPChunkedInputStream: public HTTPChunkedIOS, public std::istream
+	/// This class is for internal use by HTTPSession only.
+{
+public:
+	HTTPChunkedInputStream(HTTPSession& session);
+	~HTTPChunkedInputStream();
+	
+	void* operator new(std::size_t size);
+	void operator delete(void* ptr);
+	
+private:
+	static Poco::MemoryPool _pool;
+};
+
+
+class Net_API HTTPChunkedOutputStream: public HTTPChunkedIOS, public std::ostream
+	/// This class is for internal use by HTTPSession only.
+{
+public:
+	HTTPChunkedOutputStream(HTTPSession& session);
+	~HTTPChunkedOutputStream();
+
+	void* operator new(std::size_t size);
+	void operator delete(void* ptr);
+	
+private:
+	static Poco::MemoryPool _pool;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPChunkedStream_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPClientSession.h b/base/poco/Net/include/Poco/Net/HTTPClientSession.h
new file mode 100644
index 00000000000..d3bdcf620f3
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPClientSession.h
@@ -0,0 +1,436 @@
+//
+// HTTPClientSession.h
+//
+// Library: Net
+// Package: HTTPClient
+// Module:  HTTPClientSession
+//
+// Definition of the HTTPClientSession class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPClientSession_INCLUDED
+#define Net_HTTPClientSession_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/HTTPSession.h"
+#include "Poco/Net/HTTPSessionFactory.h"
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/SharedPtr.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPRequest;
+class HTTPResponse;
+
+
+class Net_API HTTPClientSession: public HTTPSession
+	/// This class implements the client-side of
+	/// a HTTP session.
+	///
+	/// To send a HTTP request to a HTTP server, first
+	/// instantiate a HTTPClientSession object and
+	/// specify the server's host name and port number.
+	///
+	/// Then create a HTTPRequest object, fill it accordingly,
+	/// and pass it as argument to the sendRequest() method.
+	///
+	/// sendRequest() will return an output stream that can
+	/// be used to send the request body, if there is any.
+	///
+	/// After you are done sending the request body, create
+	/// a HTTPResponse object and pass it to receiveResponse().
+	///
+	/// This will return an input stream that can be used to
+	/// read the response body.
+	///
+	/// See RFC 2616 <http://www.faqs.org/rfcs/rfc2616.html> for more
+	/// information about the HTTP protocol.
+	///
+	/// Proxies and proxy authorization (only HTTP Basic Authorization)
+	/// is supported. Use setProxy() and setProxyCredentials() to
+	/// set up a session through a proxy.
+{
+public:
+	struct ProxyConfig
+		/// HTTP proxy server configuration.
+	{
+		ProxyConfig():
+			port(HTTP_PORT), protocol("http"), tunnel(true)
+		{
+		}
+
+		std::string  host;
+			/// Proxy server host name or IP address.
+		Poco::UInt16 port;
+			/// Proxy server TCP port.
+		std::string  protocol;
+			/// Protocol to use (http or https).
+		bool tunnel;
+			/// Use proxy as tunnel (establish 2-way communication through CONNECT request).
+			/// If tunnel option is 'false' request will be send directly to proxy without CONNECT request.
+		std::string  username;
+			/// Proxy server username.
+		std::string  password;
+			/// Proxy server password.
+		std::string  nonProxyHosts;
+			/// A regular expression defining hosts for which the proxy should be bypassed,
+			/// e.g. "localhost|127\.0\.0\.1|192\.168\.0\.\d+". Can also be an empty
+			/// string to disable proxy bypassing.
+	};
+
+	HTTPClientSession();
+		/// Creates an unconnected HTTPClientSession.
+
+	explicit HTTPClientSession(const StreamSocket& socket);
+		/// Creates a HTTPClientSession using the given socket.
+		/// The socket must not be connected. The session
+		/// takes ownership of the socket.
+
+	explicit HTTPClientSession(const SocketAddress& address);
+		/// Creates a HTTPClientSession using the given address.
+
+	HTTPClientSession(const std::string& host, Poco::UInt16 port = HTTPSession::HTTP_PORT);
+		/// Creates a HTTPClientSession using the given host and port.
+
+	HTTPClientSession(const std::string& host, Poco::UInt16 port, const ProxyConfig& proxyConfig);
+		/// Creates a HTTPClientSession using the given host, port and proxy configuration.
+
+	virtual ~HTTPClientSession();
+		/// Destroys the HTTPClientSession and closes
+		/// the underlying socket.
+
+	void setHost(const std::string& host);
+		/// Sets the host name of the target HTTP server.
+		///
+		/// The host must not be changed once there is an
+		/// open connection to the server.
+
+	const std::string& getHost() const;
+		/// Returns the host name of the target HTTP server.
+
+	void setPort(Poco::UInt16 port);
+		/// Sets the port number of the target HTTP server.
+		///
+		/// The port number must not be changed once there is an
+		/// open connection to the server.
+
+	void setResolvedHost(std::string resolved_host) { _resolved_host.swap(resolved_host); }
+
+	Poco::UInt16 getPort() const;
+		/// Returns the port number of the target HTTP server.
+
+	std::string getResolvedAddress() const;
+		/// Returns the resolved host name and port of the target HTTP server.
+
+	void setProxy(const std::string& host, Poco::UInt16 port = HTTPSession::HTTP_PORT, const std::string& protocol = "http", bool tunnel = true);
+		/// Sets the proxy host name, port number, protocol (http or https) and tunnel behaviour.
+
+	void setProxyHost(const std::string& host);
+		/// Sets the host name of the proxy server.
+
+	void setProxyPort(Poco::UInt16 port);
+		/// Sets the port number of the proxy server.
+
+	void setProxyProtocol(const std::string& protocol);
+		/// Sets the proxy protocol (http or https).
+
+	void setProxyTunnel(bool tunnel);
+		/// If 'true' proxy will be used as tunnel.
+
+	const std::string& getProxyHost() const;
+		/// Returns the proxy host name.
+
+	Poco::UInt16 getProxyPort() const;
+		/// Returns the proxy port number.
+
+	const std::string& getProxyProtocol() const;
+		/// Returns the proxy protocol.
+
+	bool isProxyTunnel() const;
+		/// Returns 'true' if proxy is configured as tunnel.
+
+	void setProxyCredentials(const std::string& username, const std::string& password);
+		/// Sets the username and password for proxy authentication.
+		/// Only Basic authentication is supported.
+
+	void setProxyUsername(const std::string& username);
+		/// Sets the username for proxy authentication.
+		/// Only Basic authentication is supported.
+
+	const std::string& getProxyUsername() const;
+		/// Returns the username for proxy authentication.
+
+	void setProxyPassword(const std::string& password);
+		/// Sets the password for proxy authentication.
+		/// Only Basic authentication is supported.
+
+	const std::string& getProxyPassword() const;
+		/// Returns the password for proxy authentication.
+
+	void setProxyConfig(const ProxyConfig& config);
+		/// Sets the proxy configuration.
+
+	const ProxyConfig& getProxyConfig() const;
+		/// Returns the proxy configuration.
+
+	static void setGlobalProxyConfig(const ProxyConfig& config);
+		/// Sets the global proxy configuration.
+		///
+		/// The global proxy configuration is used by all HTTPClientSession
+		/// instances, unless a different proxy configuration is explicitly set.
+		///
+		/// Warning: Setting the global proxy configuration is not thread safe.
+		/// The global proxy configuration should be set at start up, before
+		/// the first HTTPClientSession instance is created.
+
+	static const ProxyConfig& getGlobalProxyConfig();
+		/// Returns the global proxy configuration.
+
+	void setKeepAliveTimeout(const Poco::Timespan& timeout);
+		/// Sets the connection timeout for HTTP connections.
+
+	const Poco::Timespan& getKeepAliveTimeout() const;
+		/// Returns the connection timeout for HTTP connections.
+
+	virtual std::ostream& sendRequest(HTTPRequest& request);
+		/// Sends the header for the given HTTP request to
+		/// the server.
+		///
+		/// The HTTPClientSession will set the request's
+		/// Host and Keep-Alive headers accordingly.
+		///
+		/// The returned output stream can be used to write
+		/// the request body. The stream is valid until
+		/// receiveResponse() is called or the session
+		/// is destroyed.
+		///
+		/// In case a network or server failure happens
+		/// while writing the request body to the returned stream,
+		/// the stream state will change to bad or fail. In this
+		/// case, reset() should be called if the session will
+		/// be reused and persistent connections are enabled
+		/// to ensure a new connection will be set up
+		/// for the next request.
+
+	virtual std::istream& receiveResponse(HTTPResponse& response);
+		/// Receives the header for the response to the previous
+		/// HTTP request.
+		///
+		/// The returned input stream can be used to read
+		/// the response body. The stream is valid until
+		/// sendRequest() is called or the session is
+		/// destroyed.
+		///
+		/// It must be ensured that the response stream
+		/// is fully consumed before sending a new request
+		/// and persistent connections are enabled. Otherwise,
+		/// the unread part of the response body may be treated as
+		/// part of the next request's response header, resulting
+		/// in a Poco::Net::MessageException being thrown.
+		///
+		/// In case a network or server failure happens
+		/// while reading the response body from the returned stream,
+		/// the stream state will change to bad or fail. In this
+		/// case, reset() should be called if the session will
+		/// be reused and persistent connections are enabled
+		/// to ensure a new connection will be set up
+		/// for the next request.
+
+	virtual bool peekResponse(HTTPResponse& response);
+		/// If the request contains a "Expect: 100-continue" header,
+		/// (see HTTPRequest::setExpectContinue()) this method can be
+		/// used to check whether the server has sent a 100 Continue response
+		/// before continuing with the request, i.e. sending the request body,
+		/// after calling sendRequest().
+		///
+		/// Returns true if the server has responded with 100 Continue,
+		/// otherwise false. The HTTPResponse object contains the
+		/// response sent by the server.
+		///
+		/// In any case, receiveResponse() must be called afterwards as well in
+		/// order to complete the request. The same HTTPResponse object
+		/// passed to peekResponse() must also be passed to receiveResponse().
+		///
+		/// This method should only be called if the request contains
+		/// a "Expect: 100-continue" header.
+
+	void flushRequest();
+		/// Flushes the request stream.
+		///
+		/// Normally this method does not need to be called.
+		/// It can be used to ensure the request has been
+		/// fully sent if receiveResponse() is not called, e.g.,
+		/// because the underlying socket will be detached.
+
+	void reset();
+		/// Resets the session and closes the socket.
+		///
+		/// The next request will initiate a new connection,
+		/// even if persistent connections are enabled.
+		///
+		/// This should be called whenever something went
+		/// wrong when sending a request (e.g., sendRequest()
+		/// or receiveResponse() throws an exception, or
+		/// the request or response stream changes into
+		/// fail or bad state, but not eof state).
+
+	virtual bool secure() const;
+		/// Return true iff the session uses SSL or TLS,
+		/// or false otherwise.
+
+	bool bypassProxy() const;
+		/// Returns true if the proxy should be bypassed
+		/// for the current host.
+
+protected:
+	enum
+	{
+		DEFAULT_KEEP_ALIVE_TIMEOUT = 8
+	};
+
+	void reconnect();
+		/// Connects the underlying socket to the HTTP server.
+
+	int write(const char* buffer, std::streamsize length);
+		/// Tries to re-connect if keep-alive is on.
+
+	virtual std::string proxyRequestPrefix() const;
+		/// Returns the prefix prepended to the URI for proxy requests
+		/// (e.g., "http://myhost.com").
+
+	virtual bool mustReconnect() const;
+		/// Checks if we can reuse a persistent connection.
+
+	virtual void proxyAuthenticate(HTTPRequest& request);
+		/// Sets the proxy credentials (Proxy-Authorization header), if
+		/// proxy username and password have been set.
+
+	void proxyAuthenticateImpl(HTTPRequest& request);
+		/// Sets the proxy credentials (Proxy-Authorization header), if
+		/// proxy username and password have been set.
+
+	StreamSocket proxyConnect();
+		/// Sends a CONNECT request to the proxy server and returns
+		/// a StreamSocket for the resulting connection.
+
+	void proxyTunnel();
+		/// Calls proxyConnect() and attaches the resulting StreamSocket
+		/// to the HTTPClientSession.
+
+	HTTPSessionFactory _proxySessionFactory;
+		/// Factory to create HTTPClientSession to proxy.
+private:
+	std::string     _host;
+	std::string _resolved_host;
+	Poco::UInt16    _port;
+	ProxyConfig     _proxyConfig;
+	Poco::Timespan  _keepAliveTimeout;
+	Poco::Timestamp _lastRequest;
+	bool            _reconnect;
+	bool            _mustReconnect;
+	bool            _expectResponseBody;
+	bool            _responseReceived;
+	Poco::SharedPtr<std::ostream> _pRequestStream;
+	Poco::SharedPtr<std::istream> _pResponseStream;
+
+	static ProxyConfig _globalProxyConfig;
+
+	HTTPClientSession(const HTTPClientSession&);
+	HTTPClientSession& operator = (const HTTPClientSession&);
+
+	friend class WebSocket;
+};
+
+
+//
+// inlines
+//
+
+inline std::string HTTPClientSession::getResolvedAddress() const
+{
+	return (_resolved_host.empty() ? _host : _resolved_host) + ':' + std::to_string(_port);
+}
+
+
+inline const std::string& HTTPClientSession::getHost() const
+{
+	return _host;
+}
+
+
+inline Poco::UInt16 HTTPClientSession::getPort() const
+{
+	return _port;
+}
+
+
+inline const std::string& HTTPClientSession::getProxyHost() const
+{
+	return _proxyConfig.host;
+}
+
+
+inline Poco::UInt16 HTTPClientSession::getProxyPort() const
+{
+	return _proxyConfig.port;
+}
+
+
+inline const std::string& HTTPClientSession::getProxyProtocol() const
+{
+	return _proxyConfig.protocol;
+}
+
+
+inline bool HTTPClientSession::isProxyTunnel() const
+{
+	return _proxyConfig.tunnel;
+}
+
+
+inline const std::string& HTTPClientSession::getProxyUsername() const
+{
+	return _proxyConfig.username;
+}
+
+
+inline const std::string& HTTPClientSession::getProxyPassword() const
+{
+	return _proxyConfig.password;
+}
+
+
+inline const HTTPClientSession::ProxyConfig& HTTPClientSession::getProxyConfig() const
+{
+	return _proxyConfig;
+}
+
+
+inline const HTTPClientSession::ProxyConfig& HTTPClientSession::getGlobalProxyConfig()
+{
+	return _globalProxyConfig;
+}
+
+
+inline const Poco::Timespan& HTTPClientSession::getKeepAliveTimeout() const
+{
+	return _keepAliveTimeout;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPClientSession_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPCookie.h b/base/poco/Net/include/Poco/Net/HTTPCookie.h
new file mode 100644
index 00000000000..c7c47b2e0af
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPCookie.h
@@ -0,0 +1,272 @@
+//
+// HTTPCookie.h
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPCookie
+//
+// Definition of the HTTPCookie class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPCookie_INCLUDED
+#define Net_HTTPCookie_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class NameValueCollection;
+
+
+class Net_API HTTPCookie
+	/// This class represents a HTTP Cookie.
+	///
+	/// A cookie is a small amount of information sent by a Web 
+	/// server to a Web browser, saved by the browser, and later sent back 
+	/// to the server. A cookie's value can uniquely identify a client, so 
+	/// cookies are commonly used for session management.
+	///
+	/// A cookie has a name, a single value, and optional attributes such 
+	/// as a comment, path and domain qualifiers, a maximum age, and a 
+	/// version number.
+	///
+	/// This class supports both the Version 0 (by Netscape) and Version 1 
+	/// (by RFC 2109) cookie specifications. By default, cookies are created 
+	/// using Version 0 to ensure the best interoperability.
+{
+public:
+	HTTPCookie();
+		/// Creates an empty HTTPCookie.
+		
+	explicit HTTPCookie(const std::string& name);
+		/// Creates a cookie with the given name.	
+		/// The cookie never expires.
+		
+	explicit HTTPCookie(const NameValueCollection& nvc);
+		/// Creates a cookie from the given NameValueCollection.
+		
+	HTTPCookie(const std::string& name, const std::string& value);
+		/// Creates a cookie with the given name and value.
+		/// The cookie never expires.
+		///
+		/// Note: If value contains whitespace or non-alphanumeric
+		/// characters, the value should be escaped by calling escape()
+		/// before passing it to the constructor.
+		
+	HTTPCookie(const HTTPCookie& cookie);
+		/// Creates the HTTPCookie by copying another one.
+
+	~HTTPCookie();
+		/// Destroys the HTTPCookie.
+		
+	HTTPCookie& operator = (const HTTPCookie& cookie);
+		/// Assigns a cookie.
+		
+	void setVersion(int version);
+		/// Sets the version of the cookie.
+		///
+		/// Version must be either 0 (denoting a Netscape cookie)
+		/// or 1 (denoting a RFC 2109 cookie).
+		
+	int getVersion() const;
+		/// Returns the version of the cookie, which is
+		/// either 0 or 1.	
+		
+	void setName(const std::string& name);
+		/// Sets the name of the cookie.
+		
+	const std::string& getName() const;
+		/// Returns the name of the cookie.
+		
+	void setValue(const std::string& value);
+		/// Sets the value of the cookie.
+		///
+		/// According to the cookie specification, the
+		/// size of the value should not exceed 4 Kbytes.
+		///
+		/// Note: If value contains whitespace or non-alphanumeric
+		/// characters, the value should be escaped by calling escape()
+		/// prior to passing it to setName().
+		
+	const std::string& getValue() const;
+		/// Returns the value of the cookie.
+		
+	void setComment(const std::string& comment);
+		/// Sets the comment for the cookie.
+		///
+		/// Comments are only supported for version 1 cookies.
+
+	const std::string& getComment() const;
+		/// Returns the comment for the cookie.
+
+	void setDomain(const std::string& domain);
+		/// Sets the domain for the cookie.
+		
+	const std::string& getDomain() const;
+		/// Returns the domain for the cookie.
+
+	void setPath(const std::string& path);
+		/// Sets the path for the cookie.
+
+	void setPriority(const std::string& priority);
+		/// Sets the priority for the cookie.
+		
+	const std::string& getPath() const;
+		/// Returns the path for the cookie.
+
+	const std::string& getPriority() const;
+		/// Returns the priority for the cookie.
+
+	void setSecure(bool secure);
+		/// Sets the value of the secure flag for
+		/// the cookie.
+		
+	bool getSecure() const;
+		/// Returns the value of the secure flag
+		/// for the cookie.
+
+	void setMaxAge(int maxAge);
+		/// Sets the maximum age in seconds for
+		/// the cookie.
+		///
+		/// A value of -1 (default) causes the cookie 
+		/// to become a session cookie, which will
+		/// be deleted when the browser window
+		/// is closed.
+		///
+		/// A value of 0 deletes the cookie on
+		/// the client.
+
+	int getMaxAge() const;
+		/// Returns the maximum age in seconds for
+		/// the cookie.
+		
+	void setHttpOnly(bool flag = true);
+		/// Sets the HttpOnly flag for the cookie.
+		
+	bool getHttpOnly() const;
+		/// Returns true iff the cookie's HttpOnly flag is set.
+		
+	std::string toString() const;
+		/// Returns a string representation of the cookie,
+		/// suitable for use in a Set-Cookie header.
+		
+	static std::string escape(const std::string& str);
+		/// Escapes the given string by replacing all 
+		/// non-alphanumeric characters with escape
+		/// sequences in the form %xx, where xx is the
+		/// hexadecimal character code.
+		///
+		/// The following characters will be replaced
+		/// with escape sequences:
+		///   - percent sign %
+		///   - less-than and greater-than < and >
+		///   - curly brackets { and }
+		///   - square brackets [ and ]
+		///   - parenthesis ( and )
+		///   - solidus /
+		///   - vertical line |
+		///   - reverse solidus (backslash /)
+		///   - quotation mark "
+		///   - apostrophe '
+		///   - circumflex accent ^
+		///   - grave accent `
+		///   - comma and semicolon , and ;
+		///   - whitespace and control characters
+		
+	static std::string unescape(const std::string& str);
+		/// Unescapes the given string by replacing all
+		/// escape sequences in the form %xx with the
+		/// respective characters.
+
+private:
+	int         _version;
+	std::string _name;
+	std::string _value;
+	std::string _comment;
+	std::string _domain;
+	std::string _path;
+	std::string _priority;
+	bool        _secure;
+	int         _maxAge;
+	bool        _httpOnly;
+};
+
+
+//
+// inlines
+//
+inline int HTTPCookie::getVersion() const
+{
+	return _version;
+}
+
+
+inline const std::string& HTTPCookie::getName() const
+{
+	return _name;
+}
+
+
+inline const std::string& HTTPCookie::getValue() const
+{
+	return _value;
+}
+
+
+inline const std::string& HTTPCookie::getComment() const
+{
+	return _comment;
+}
+
+
+inline const std::string& HTTPCookie::getDomain() const
+{
+	return _domain;
+}
+
+
+inline const std::string& HTTPCookie::getPath() const
+{
+	return _path;
+}
+
+
+inline const std::string& HTTPCookie::getPriority() const
+{
+	return _priority;
+}
+
+
+inline bool HTTPCookie::getSecure() const
+{
+	return _secure;
+}
+
+
+inline int HTTPCookie::getMaxAge() const
+{
+	return _maxAge;
+}
+
+
+inline bool HTTPCookie::getHttpOnly() const
+{
+	return _httpOnly;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPCookie_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPCredentials.h b/base/poco/Net/include/Poco/Net/HTTPCredentials.h
new file mode 100644
index 00000000000..e62b8c24679
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPCredentials.h
@@ -0,0 +1,206 @@
+//
+// HTTPCredentials.h
+//
+// Library: Net
+// Package: HTTP
+// Module:	HTTPCredentials
+//
+// Definition of the HTTPCredentials class.
+//
+// Copyright (c) 2011, Anton V. Yabchinskiy (arn at bestmx dot ru).
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPCredentials_INCLUDED
+#define Net_HTTPCredentials_INCLUDED
+
+
+#include "Poco/Net/HTTPDigestCredentials.h"
+
+
+namespace Poco {
+
+
+class URI;
+
+
+namespace Net {
+
+
+class HTTPRequest;
+class HTTPResponse;
+
+
+class Net_API HTTPCredentials
+	/// This is a utility class for working with HTTP
+	/// authentication (Basic or Digest) in HTTPRequest objects.
+	///
+	/// Usage is as follows:
+	/// First, create a HTTPCredentials object containing
+	/// the username and password.
+	///     Poco::Net::HTTPCredentials creds("user", "s3cr3t");
+	///
+	/// Second, send the HTTP request with Poco::Net::HTTPClientSession.
+	///     Poco::Net::HTTPClientSession session("pocoproject.org");
+	///     Poco::Net::HTTPRequest request(HTTPRequest::HTTP_GET, "/index.html", HTTPMessage::HTTP_1_1);
+	///     session.sendRequest(request);
+	///     Poco::Net::HTTPResponse;
+	///     std::istream& istr = session.receiveResponse(response);
+	///
+	/// If the server responds with a 401 status, authenticate the
+	/// request and resend it:
+	///     if (response.getStatus() == Poco::Net::HTTPResponse::HTTP_UNAUTHORIZED)
+	///     {
+	///         creds.authenticate(request, response);
+	///         session.sendRequest(request);
+	///         ...
+	///     }
+	///
+	/// To perform multiple authenticated requests, call updateAuthInfo()
+	/// instead of authenticate() on subsequent requests.
+	///     creds.updateAuthInfo(request);
+	///     session.sendRequest(request);
+	///     ...
+	///
+	/// Note: Do not forget to read the entire response stream from the 401 response
+	/// before sending the authenticated request, otherwise there may be
+	/// problems if a persistent connection is used.
+{
+public:
+	HTTPCredentials();
+		/// Creates an empty HTTPCredentials object.
+
+	HTTPCredentials(const std::string& username, const std::string& password);
+		/// Creates an HTTPCredentials object with the given username and password.
+
+	~HTTPCredentials();
+		/// Destroys the HTTPCredentials.
+
+	void fromUserInfo(const std::string& userInfo);
+		/// Parses username:password string and sets username and password of
+		/// the credentials object.
+		/// Throws SyntaxException on invalid user information.
+
+	void fromURI(const URI& uri);
+		/// Extracts username and password from the given URI and sets username
+		/// and password of the credentials object.
+		/// Does nothing if URI has no user info part.
+
+	void clear();
+		/// Clears username, password and host.
+
+	void setUsername(const std::string& username);
+		/// Sets the username.
+
+	const std::string& getUsername() const;
+		/// Returns the username.
+
+	void setPassword(const std::string& password);
+		/// Sets the password.
+
+	const std::string& getPassword() const;
+		/// Returns the password.
+
+	bool empty() const;
+		/// Returns true if both username and password are empty, otherwise false.
+
+	void authenticate(HTTPRequest& request, const HTTPResponse& response);
+		/// Inspects WWW-Authenticate header of the response, initializes
+		/// the internal state (in case of digest authentication) and
+		/// adds required information to the given HTTPRequest.
+		///
+		/// Does nothing if there is no WWW-Authenticate header in the
+		/// HTTPResponse.
+
+	void updateAuthInfo(HTTPRequest& request);
+		/// Updates internal state (in case of digest authentication) and
+		/// replaces authentication information in the request accordingly.
+
+	void proxyAuthenticate(HTTPRequest& request, const HTTPResponse& response);
+		/// Inspects Proxy-Authenticate header of the response, initializes
+		/// the internal state (in case of digest authentication) and
+		/// adds required information to the given HTTPRequest.
+		///
+		/// Does nothing if there is no Proxy-Authenticate header in the
+		/// HTTPResponse.
+
+	void updateProxyAuthInfo(HTTPRequest& request);
+		/// Updates internal state (in case of digest authentication) and
+		/// replaces proxy authentication information in the request accordingly.
+
+	static bool isBasicCredentials(const std::string& header);
+		/// Returns true if authentication header is for Basic authentication.
+
+	static bool isDigestCredentials(const std::string& header);
+		/// Returns true if authentication header is for Digest authentication.
+
+	static bool hasBasicCredentials(const HTTPRequest& request);
+		/// Returns true if an Authorization header with Basic credentials is present in the request.
+
+	static bool hasDigestCredentials(const HTTPRequest& request);
+		/// Returns true if an Authorization header with Digest credentials is present in the request.
+
+	static bool hasNTLMCredentials(const HTTPRequest& request);
+		/// Returns true if an Authorization header with NTLM credentials is present in the request.
+
+	static bool hasProxyBasicCredentials(const HTTPRequest& request);
+		/// Returns true if a Proxy-Authorization header with Basic credentials is present in the request.
+
+	static bool hasProxyDigestCredentials(const HTTPRequest& request);
+		/// Returns true if a Proxy-Authorization header with Digest credentials is present in the request.
+
+	static void extractCredentials(const std::string& userInfo, std::string& username, std::string& password);
+		/// Extracts username and password from user:password information string.
+
+	static void extractCredentials(const Poco::URI& uri, std::string& username, std::string& password);
+		/// Extracts username and password from the given URI (e.g.: "http://user:pass@sample.com/secret").
+
+private:
+	HTTPCredentials(const HTTPCredentials&);
+	HTTPCredentials& operator = (const HTTPCredentials&);
+
+	HTTPDigestCredentials _digest;
+};
+
+
+//
+// inlines
+//
+inline void HTTPCredentials::setUsername(const std::string& username)
+{
+	_digest.setUsername(username);
+}
+
+
+inline const std::string& HTTPCredentials::getUsername() const
+{
+	return _digest.getUsername();
+}
+
+
+inline void HTTPCredentials::setPassword(const std::string& password)
+{
+	_digest.setPassword(password);
+}
+
+
+inline const std::string& HTTPCredentials::getPassword() const
+{
+	return _digest.getPassword();
+}
+
+
+inline bool HTTPCredentials::empty() const
+{
+	return _digest.empty();
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPCredentials_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPDigestCredentials.h b/base/poco/Net/include/Poco/Net/HTTPDigestCredentials.h
new file mode 100644
index 00000000000..c321c9fc87d
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPDigestCredentials.h
@@ -0,0 +1,186 @@
+//
+// HTTPDigestCredentials.h
+//
+// Library: Net
+// Package: HTTP
+// Module:	HTTPDigestCredentials
+//
+// Definition of the HTTPDigestCredentials class.
+//
+// Copyright (c) 2011, Anton V. Yabchinskiy (arn at bestmx dot ru).
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPDigestCredentials_INCLUDED
+#define Net_HTTPDigestCredentials_INCLUDED
+
+
+#include "Poco/Net/HTTPAuthenticationParams.h"
+#include "Poco/Mutex.h"
+#include <map>
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPRequest;
+class HTTPResponse;
+
+
+class Net_API HTTPDigestCredentials
+	/// This is a utility class for working with
+	/// HTTP Digest Authentication in HTTPRequest
+	/// objects.
+	///
+	/// Note: currently, no qop or qop=auth is
+	/// supported only.
+{
+public:
+	HTTPDigestCredentials();
+		/// Creates an empty HTTPDigestCredentials object.
+
+	HTTPDigestCredentials(const std::string& username, const std::string& password);
+		/// Creates a HTTPDigestCredentials object with the given username and password.
+
+	~HTTPDigestCredentials();
+		/// Destroys the HTTPDigestCredentials.
+
+	void reset();
+		/// Resets the HTTPDigestCredentials object to a clean state.
+		/// Does not clear username and password.
+
+	void clear();
+		/// Clears both username and password.
+
+	void setUsername(const std::string& username);
+		/// Sets the username.
+
+	const std::string& getUsername() const;
+		/// Returns the username.
+
+	void setPassword(const std::string& password);
+		/// Sets the password.
+
+	const std::string& getPassword() const;
+		/// Returns the password.
+
+	bool empty() const;
+		/// Returns true if both username and password are empty, otherwise false.
+
+	void authenticate(HTTPRequest& request, const HTTPResponse& response);
+		/// Parses WWW-Authenticate header of the HTTPResponse, initializes
+		/// internal state, and adds authentication information to the given HTTPRequest.
+
+	void authenticate(HTTPRequest& request, const HTTPAuthenticationParams& responseAuthParams);
+		/// Initializes internal state according to information from the
+		/// HTTPAuthenticationParams of the response, and adds authentication
+		/// information to the given HTTPRequest.
+		///
+		/// Throws InvalidArgumentException if HTTPAuthenticationParams is
+		/// invalid or some required parameter is missing.
+		/// Throws NotImplementedException in case of unsupported digest
+		/// algorithm or quality of protection method.
+
+	void updateAuthInfo(HTTPRequest& request);
+		/// Updates internal state and adds authentication information to
+		/// the given HTTPRequest.
+
+	void proxyAuthenticate(HTTPRequest& request, const HTTPResponse& response);
+		/// Parses Proxy-Authenticate header of the HTTPResponse, initializes
+		/// internal state, and adds proxy authentication information to the given HTTPRequest.
+
+	void proxyAuthenticate(HTTPRequest& request, const HTTPAuthenticationParams& responseAuthParams);
+		/// Initializes internal state according to information from the
+		/// HTTPAuthenticationParams of the response, and adds proxy authentication
+		/// information to the given HTTPRequest.
+		///
+		/// Throws InvalidArgumentException if HTTPAuthenticationParams is
+		/// invalid or some required parameter is missing.
+		/// Throws NotImplementedException in case of unsupported digest
+		/// algorithm or quality of protection method.
+
+	void updateProxyAuthInfo(HTTPRequest& request);
+		/// Updates internal state and adds proxy authentication information to
+		/// the given HTTPRequest.
+
+	bool verifyAuthInfo(const HTTPRequest& request) const;
+		/// Verifies the digest authentication information in the given HTTPRequest
+		/// by recomputing the response and comparing it with what's in the request.
+		///
+		/// Note: This method creates a HTTPAuthenticationParams object from the request
+		/// and calls verifyAuthParams() with request and params.
+
+	bool verifyAuthParams(const HTTPRequest& request, const HTTPAuthenticationParams& params) const;
+		/// Verifies the digest authentication information in the given HTTPRequest
+		/// and HTTPAuthenticationParams by recomputing the response and comparing
+		/// it with what's in the request.
+
+	static std::string createNonce();
+		/// Creates a random nonce string.
+
+	static const std::string SCHEME;
+
+private:
+	HTTPDigestCredentials(const HTTPDigestCredentials&);
+	HTTPDigestCredentials& operator = (const HTTPDigestCredentials&);
+
+	void createAuthParams(const HTTPRequest& request, const HTTPAuthenticationParams& responseAuthParams);
+	void updateAuthParams(const HTTPRequest& request);
+	int updateNonceCounter(const std::string& nonce);
+
+	static const std::string DEFAULT_ALGORITHM;
+	static const std::string DEFAULT_QOP;
+	static const std::string NONCE_PARAM;
+	static const std::string REALM_PARAM;
+	static const std::string QOP_PARAM;
+	static const std::string ALGORITHM_PARAM;
+	static const std::string USERNAME_PARAM;
+	static const std::string OPAQUE_PARAM;
+	static const std::string URI_PARAM;
+	static const std::string RESPONSE_PARAM;
+	static const std::string AUTH_PARAM;
+	static const std::string CNONCE_PARAM;
+	static const std::string NC_PARAM;
+
+	typedef std::map<std::string, int> NonceCounterMap;
+
+	std::string _username;
+	std::string _password;
+	HTTPAuthenticationParams _requestAuthParams;
+	NonceCounterMap _nc;
+
+	static int _nonceCounter;
+	static Poco::FastMutex _nonceMutex;
+};
+
+
+//
+// inlines
+//
+inline const std::string& HTTPDigestCredentials::getUsername() const
+{
+	return _username;
+}
+
+
+inline const std::string& HTTPDigestCredentials::getPassword() const
+{
+	return _password;
+}
+
+
+inline bool HTTPDigestCredentials::empty() const
+{
+	return _username.empty() && _password.empty();
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPDigestCredentials_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPFixedLengthStream.h b/base/poco/Net/include/Poco/Net/HTTPFixedLengthStream.h
new file mode 100644
index 00000000000..ad781e4e005
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPFixedLengthStream.h
@@ -0,0 +1,110 @@
+//
+// HTTPFixedLengthStream.h
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPFixedLengthStream
+//
+// Definition of the HTTPFixedLengthStream class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPFixedLengthStream_INCLUDED
+#define Net_HTTPFixedLengthStream_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/HTTPBasicStreamBuf.h"
+#include <cstddef>
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPSession;
+
+
+class Net_API HTTPFixedLengthStreamBuf: public HTTPBasicStreamBuf
+	/// This is the streambuf class used for reading and writing fixed-size
+	/// HTTP message bodies.
+	///
+	/// At most a given number of bytes are read or written.
+{
+public:
+	typedef HTTPBasicStreamBuf::openmode openmode;
+
+#if defined(POCO_HAVE_INT64)
+	typedef Poco::Int64 ContentLength;
+#else
+	typedef std::streamsize ContentLength;
+#endif
+
+	HTTPFixedLengthStreamBuf(HTTPSession& session, ContentLength length, openmode mode);
+	~HTTPFixedLengthStreamBuf();
+	
+protected:
+	int readFromDevice(char* buffer, std::streamsize length);
+	int writeToDevice(const char* buffer, std::streamsize length);
+
+private:
+	HTTPSession&    _session;
+	ContentLength _length;
+	ContentLength _count;
+};
+
+
+class Net_API HTTPFixedLengthIOS: public virtual std::ios
+	/// The base class for HTTPFixedLengthInputStream.
+{
+public:
+	HTTPFixedLengthIOS(HTTPSession& session, HTTPFixedLengthStreamBuf::ContentLength length, HTTPFixedLengthStreamBuf::openmode mode);
+	~HTTPFixedLengthIOS();
+	HTTPFixedLengthStreamBuf* rdbuf();
+
+protected:
+	HTTPFixedLengthStreamBuf _buf;
+};
+
+
+class Net_API HTTPFixedLengthInputStream: public HTTPFixedLengthIOS, public std::istream
+	/// This class is for internal use by HTTPSession only.
+{
+public:
+	HTTPFixedLengthInputStream(HTTPSession& session, HTTPFixedLengthStreamBuf::ContentLength length);
+	~HTTPFixedLengthInputStream();
+	
+	void* operator new(std::size_t size);
+	void operator delete(void* ptr);
+	
+private:
+	static Poco::MemoryPool _pool;
+};
+
+
+class Net_API HTTPFixedLengthOutputStream: public HTTPFixedLengthIOS, public std::ostream
+	/// This class is for internal use by HTTPSession only.
+{
+public:
+	HTTPFixedLengthOutputStream(HTTPSession& session, HTTPFixedLengthStreamBuf::ContentLength length);
+	~HTTPFixedLengthOutputStream();
+
+	void* operator new(std::size_t size);
+	void operator delete(void* ptr);
+	
+private:
+	static Poco::MemoryPool _pool;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPFixedLengthStream_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPHeaderStream.h b/base/poco/Net/include/Poco/Net/HTTPHeaderStream.h
new file mode 100644
index 00000000000..1d67003e0b9
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPHeaderStream.h
@@ -0,0 +1,102 @@
+//
+// HTTPHeaderStream.h
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPHeaderStream
+//
+// Definition of the HTTPHeaderStream class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPHeaderStream_INCLUDED
+#define Net_HTTPHeaderStream_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/HTTPBasicStreamBuf.h"
+#include "Poco/MemoryPool.h"
+#include <cstddef>
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPSession;
+
+
+class Net_API HTTPHeaderStreamBuf: public HTTPBasicStreamBuf
+	/// This is the streambuf class used for reading from a HTTP header
+	/// in a HTTPSession.
+{
+public:
+	typedef HTTPBasicStreamBuf::openmode openmode;
+
+	HTTPHeaderStreamBuf(HTTPSession& session, openmode mode);
+	~HTTPHeaderStreamBuf();
+	
+protected:
+	int readFromDevice(char* buffer, std::streamsize length);
+	int writeToDevice(const char* buffer, std::streamsize length);
+
+private:
+	HTTPSession& _session;
+	bool         _end;
+};
+
+
+class Net_API HTTPHeaderIOS: public virtual std::ios
+	/// The base class for HTTPHeaderInputStream.
+{
+public:
+	HTTPHeaderIOS(HTTPSession& session, HTTPHeaderStreamBuf::openmode mode);
+	~HTTPHeaderIOS();
+	HTTPHeaderStreamBuf* rdbuf();
+
+protected:
+	HTTPHeaderStreamBuf _buf;
+};
+
+
+class Net_API HTTPHeaderInputStream: public HTTPHeaderIOS, public std::istream
+	/// This class is for internal use by HTTPSession only.
+{
+public:
+	HTTPHeaderInputStream(HTTPSession& session);
+	~HTTPHeaderInputStream();
+
+	void* operator new(std::size_t size);
+	void operator delete(void* ptr);
+	
+private:
+	static Poco::MemoryPool _pool;
+};
+
+
+class Net_API HTTPHeaderOutputStream: public HTTPHeaderIOS, public std::ostream
+	/// This class is for internal use by HTTPSession only.
+{
+public:
+	HTTPHeaderOutputStream(HTTPSession& session);
+	~HTTPHeaderOutputStream();
+
+	void* operator new(std::size_t size);
+	void operator delete(void* ptr);
+	
+private:
+	static Poco::MemoryPool _pool;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPHeaderStream_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPIOStream.h b/base/poco/Net/include/Poco/Net/HTTPIOStream.h
new file mode 100644
index 00000000000..2c45812ae1e
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPIOStream.h
@@ -0,0 +1,88 @@
+//
+// HTTPIOStream.h
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPIOStream
+//
+// Definition of the HTTPIOStream class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPIOStream_INCLUDED
+#define Net_HTTPIOStream_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/HTTPResponse.h"
+#include "Poco/UnbufferedStreamBuf.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPClientSession;
+
+
+class Net_API HTTPResponseStreamBuf: public Poco::UnbufferedStreamBuf
+{
+public:
+	HTTPResponseStreamBuf(std::istream& istr);
+	
+	~HTTPResponseStreamBuf();
+		
+private:
+	int readFromDevice();
+	
+	std::istream& _istr;
+};
+
+
+inline int HTTPResponseStreamBuf::readFromDevice()
+{
+	return _istr.get();
+}
+
+
+class Net_API HTTPResponseIOS: public virtual std::ios
+{
+public:
+	HTTPResponseIOS(std::istream& istr);
+	
+	~HTTPResponseIOS();
+	
+	HTTPResponseStreamBuf* rdbuf();
+
+protected:
+	HTTPResponseStreamBuf _buf;
+};
+
+
+inline HTTPResponseStreamBuf* HTTPResponseIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+class Net_API HTTPResponseStream: public HTTPResponseIOS, public std::istream
+{
+public:
+	HTTPResponseStream(std::istream& istr, HTTPClientSession* pSession);
+		
+	~HTTPResponseStream();
+	
+private:
+	HTTPClientSession* _pSession;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPIOStream_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPMessage.h b/base/poco/Net/include/Poco/Net/HTTPMessage.h
new file mode 100644
index 00000000000..345543d5a16
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPMessage.h
@@ -0,0 +1,185 @@
+//
+// HTTPMessage.h
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPMessage
+//
+// Definition of the HTTPMessage class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPMessage_INCLUDED
+#define Net_HTTPMessage_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/MessageHeader.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class MediaType;
+
+
+class Net_API HTTPMessage: public MessageHeader
+	/// The base class for HTTPRequest and HTTPResponse.
+	///
+	/// Defines the common properties of all HTTP messages.
+	/// These are version, content length, content type
+	/// and transfer encoding.
+{
+public:
+	void setVersion(const std::string& version);
+		/// Sets the HTTP version for this message.
+		
+	const std::string& getVersion() const;
+		/// Returns the HTTP version for this message.
+		
+	void setContentLength(std::streamsize length);
+		/// Sets the Content-Length header.
+		///
+		/// If length is UNKNOWN_CONTENT_LENGTH, removes
+		/// the Content-Length header.
+		
+	std::streamsize getContentLength() const;
+		/// Returns the content length for this message,
+		/// which may be UNKNOWN_CONTENT_LENGTH if
+		/// no Content-Length header is present.
+
+#if defined(POCO_HAVE_INT64)	
+	void setContentLength64(Poco::Int64 length);
+		/// Sets the Content-Length header.
+		///
+		/// If length is UNKNOWN_CONTENT_LENGTH, removes
+		/// the Content-Length header.
+		///
+		/// In contrast to setContentLength(), this method takes
+		/// a 64-bit integer as content length.
+
+	Poco::Int64 getContentLength64() const;
+		/// Returns the content length for this message,
+		/// which may be UNKNOWN_CONTENT_LENGTH if
+		/// no Content-Length header is present.
+		///
+		/// In contrast to getContentLength(), this method
+		/// always returns a 64-bit integer for content length.
+#endif // defined(POCO_HAVE_INT64)
+
+	bool hasContentLength() const;
+		/// Returns true iff a Content-Length header is present.
+
+	void setTransferEncoding(const std::string& transferEncoding);
+		/// Sets the transfer encoding for this message.
+		///
+		/// The value should be either IDENTITY_TRANSFER_CODING
+		/// or CHUNKED_TRANSFER_CODING.
+
+	const std::string& getTransferEncoding() const;
+		/// Returns the transfer encoding used for this
+		/// message.
+		///
+		/// Normally, this is the value of the Transfer-Encoding
+		/// header field. If no such field is present,
+		/// returns IDENTITY_TRANSFER_CODING.
+		
+	void setChunkedTransferEncoding(bool flag);
+		/// If flag is true, sets the Transfer-Encoding header to
+		/// chunked. Otherwise, removes the Transfer-Encoding
+		/// header.
+		
+	bool getChunkedTransferEncoding() const;
+		/// Returns true if the Transfer-Encoding header is set
+		/// and its value is chunked.
+		
+	void setContentType(const std::string& mediaType);
+		/// Sets the content type for this message.
+		///
+		/// Specify NO_CONTENT_TYPE to remove the
+		/// Content-Type header.
+		
+	void setContentType(const MediaType& mediaType);	
+		/// Sets the content type for this message.
+		
+	const std::string& getContentType() const;
+		/// Returns the content type for this message.
+		///
+		/// If no Content-Type header is present, 
+		/// returns UNKNOWN_CONTENT_TYPE.	
+
+	void setKeepAlive(bool keepAlive);
+		/// Sets the value of the Connection header field.
+		///
+		/// The value is set to "Keep-Alive" if keepAlive is
+		/// true, or to "Close" otherwise.
+
+	bool getKeepAlive() const;
+		/// Returns true if
+		///   * the message has a Connection header field and its value is "Keep-Alive"
+		///   * the message is a HTTP/1.1 message and not Connection header is set
+		/// Returns false otherwise.
+
+	static const std::string HTTP_1_0;
+	static const std::string HTTP_1_1;
+
+	static const std::string IDENTITY_TRANSFER_ENCODING;
+	static const std::string CHUNKED_TRANSFER_ENCODING;
+
+	static const int         UNKNOWN_CONTENT_LENGTH;
+	static const std::string UNKNOWN_CONTENT_TYPE;
+	
+	static const std::string CONTENT_LENGTH;
+	static const std::string CONTENT_TYPE;
+	static const std::string TRANSFER_ENCODING;
+	static const std::string CONNECTION;
+	
+	static const std::string CONNECTION_KEEP_ALIVE;
+	static const std::string CONNECTION_CLOSE;
+
+	static const std::string EMPTY;
+
+protected:
+	HTTPMessage();
+		/// Creates the HTTPMessage with version HTTP/1.0.
+
+	HTTPMessage(const std::string& version);
+		/// Creates the HTTPMessage and sets
+		/// the version.
+
+	virtual ~HTTPMessage();
+		/// Destroys the HTTPMessage.
+	
+private:
+	HTTPMessage(const HTTPMessage&);
+	HTTPMessage& operator = (const HTTPMessage&);
+	
+	std::string _version;
+};
+
+
+//
+// inlines
+//
+inline const std::string& HTTPMessage::getVersion() const
+{
+	return _version;
+}
+
+
+inline bool HTTPMessage::hasContentLength() const
+{
+	return has(CONTENT_LENGTH);
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPMessage_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPRequest.h b/base/poco/Net/include/Poco/Net/HTTPRequest.h
new file mode 100644
index 00000000000..3f4dcb972f9
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPRequest.h
@@ -0,0 +1,208 @@
+//
+// HTTPRequest.h
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPRequest
+//
+// Definition of the HTTPRequest class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPRequest_INCLUDED
+#define Net_HTTPRequest_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/HTTPMessage.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API HTTPRequest: public HTTPMessage
+	/// This class encapsulates an HTTP request
+	/// message.
+	///
+	/// In addition to the properties common to
+	/// all HTTP messages, a HTTP request has
+	/// a method (e.g. GET, HEAD, POST, etc.) and
+	/// a request URI.
+{
+public:
+	HTTPRequest();
+		/// Creates a GET / HTTP/1.0 HTTP request.
+		
+	HTTPRequest(const std::string& version);
+		/// Creates a GET / HTTP/1.x request with
+		/// the given version (HTTP/1.0 or HTTP/1.1).
+		
+	HTTPRequest(const std::string& method, const std::string& uri);
+		/// Creates a HTTP/1.0 request with the given method and URI.
+
+	HTTPRequest(const std::string& method, const std::string& uri, const std::string& version);
+		/// Creates a HTTP request with the given method, URI and version.
+
+	virtual ~HTTPRequest();
+		/// Destroys the HTTPRequest.
+
+	void setMethod(const std::string& method);
+		/// Sets the method.
+
+	const std::string& getMethod() const;
+		/// Returns the method.
+
+	void setURI(const std::string& uri);
+		/// Sets the request URI.
+		
+	const std::string& getURI() const;
+		/// Returns the request URI.
+		
+	void setHost(const std::string& host);
+		/// Sets the value of the Host header field.
+		
+	void setHost(const std::string& host, Poco::UInt16 port);
+		/// Sets the value of the Host header field.
+		///
+		/// If the given port number is a non-standard
+		/// port number (other than 80 or 443), it is
+		/// included in the Host header field.
+		
+	const std::string& getHost() const;
+		/// Returns the value of the Host header field.
+		///
+		/// Throws a NotFoundException if the request
+		/// does not have a Host header field.
+
+	void setCookies(const NameValueCollection& cookies);
+		/// Adds a Cookie header with the names and
+		/// values from cookies.
+		
+	void getCookies(NameValueCollection& cookies) const;
+		/// Fills cookies with the cookies extracted
+		/// from the Cookie headers in the request.
+
+	bool hasCredentials() const;
+		/// Returns true iff the request contains authentication
+		/// information in the form of an Authorization header.
+		
+	void getCredentials(std::string& scheme, std::string& authInfo) const;
+		/// Returns the authentication scheme and additional authentication
+		/// information contained in this request.
+		///
+		/// Throws a NotAuthenticatedException if no authentication information
+		/// is contained in the request.
+		
+	void setCredentials(const std::string& scheme, const std::string& authInfo);
+		/// Sets the authentication scheme and information for
+		/// this request.
+		
+	bool getExpectContinue() const;
+		/// Returns true if the request contains an
+		/// "Expect: 100-continue" header.
+
+	void setExpectContinue(bool expectContinue);
+		/// Adds a "Expect: 100-continue" header to the request if
+		/// expectContinue is true, otherwise removes the Expect header.
+		
+	bool hasProxyCredentials() const;
+		/// Returns true iff the request contains proxy authentication
+		/// information in the form of an Proxy-Authorization header.
+		
+	void getProxyCredentials(std::string& scheme, std::string& authInfo) const;
+		/// Returns the proxy authentication scheme and additional proxy authentication
+		/// information contained in this request.
+		///
+		/// Throws a NotAuthenticatedException if no proxy authentication information
+		/// is contained in the request.
+		
+	void setProxyCredentials(const std::string& scheme, const std::string& authInfo);
+		/// Sets the proxy authentication scheme and information for
+		/// this request.
+
+	void write(std::ostream& ostr) const;
+		/// Writes the HTTP request to the given
+		/// output stream.
+
+#if __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Woverloaded-virtual"
+#endif
+	void read(std::istream& istr);
+#if __clang__
+#pragma clang diagnostic pop
+#endif
+
+		/// Reads the HTTP request from the
+		/// given input stream.
+		
+	static const std::string HTTP_GET;
+	static const std::string HTTP_HEAD;
+	static const std::string HTTP_PUT;
+	static const std::string HTTP_POST;
+	static const std::string HTTP_OPTIONS;
+	static const std::string HTTP_DELETE;
+	static const std::string HTTP_TRACE;
+	static const std::string HTTP_CONNECT;
+	static const std::string HTTP_PATCH;
+	
+	static const std::string HOST;
+	static const std::string COOKIE;
+	static const std::string AUTHORIZATION;
+	static const std::string PROXY_AUTHORIZATION;
+	static const std::string UPGRADE;
+	static const std::string EXPECT;
+
+protected:
+	void getCredentials(const std::string& header, std::string& scheme, std::string& authInfo) const;
+		/// Returns the authentication scheme and additional authentication
+		/// information contained in the given header of request.
+		///
+		/// Throws a NotAuthenticatedException if no authentication information
+		/// is contained in the request.
+		
+	void setCredentials(const std::string& header, const std::string& scheme, const std::string& authInfo);
+		/// Writes the authentication scheme and information for
+		/// this request to the given header.
+
+private:
+	enum Limits
+	{
+		MAX_METHOD_LENGTH  = 32,
+		MAX_URI_LENGTH     = 16384,
+		MAX_VERSION_LENGTH = 8
+	};
+	
+	std::string _method;
+	std::string _uri;
+	
+	HTTPRequest(const HTTPRequest&);
+	HTTPRequest& operator = (const HTTPRequest&);
+};
+
+
+//
+// inlines
+//
+inline const std::string& HTTPRequest::getMethod() const
+{
+	return _method;
+}
+
+
+inline const std::string& HTTPRequest::getURI() const
+{
+	return _uri;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPRequest_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPRequestHandler.h b/base/poco/Net/include/Poco/Net/HTTPRequestHandler.h
new file mode 100644
index 00000000000..8a6271204c1
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPRequestHandler.h
@@ -0,0 +1,67 @@
+//
+// HTTPRequestHandler.h
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPRequestHandler
+//
+// Definition of the HTTPRequestHandler class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPRequestHandler_INCLUDED
+#define Net_HTTPRequestHandler_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPServerRequest;
+class HTTPServerResponse;
+
+
+class Net_API HTTPRequestHandler
+	/// The abstract base class for HTTPRequestHandlers 
+	/// created by HTTPServer.
+	///
+	/// Derived classes must override the handleRequest() method.
+	/// Furthermore, a HTTPRequestHandlerFactory must be provided.
+	///
+	/// The handleRequest() method must perform the complete handling
+	/// of the HTTP request connection. As soon as the handleRequest() 
+	/// method returns, the request handler object is destroyed.
+	///
+	/// A new HTTPRequestHandler object will be created for
+	/// each new HTTP request that is received by the HTTPServer.
+{
+public:
+	HTTPRequestHandler();
+		/// Creates the HTTPRequestHandler.
+
+	virtual ~HTTPRequestHandler();
+		/// Destroys the HTTPRequestHandler.
+
+	virtual void handleRequest(HTTPServerRequest& request, HTTPServerResponse& response) = 0;
+		/// Must be overridden by subclasses.
+		///
+		/// Handles the given request.
+
+private:
+	HTTPRequestHandler(const HTTPRequestHandler&);
+	HTTPRequestHandler& operator = (const HTTPRequestHandler&);
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPRequestHandler_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPRequestHandlerFactory.h b/base/poco/Net/include/Poco/Net/HTTPRequestHandlerFactory.h
new file mode 100644
index 00000000000..421c4650183
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPRequestHandlerFactory.h
@@ -0,0 +1,78 @@
+//
+// HTTPRequestHandlerFactory.h
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPRequestHandlerFactory
+//
+// Definition of the HTTPRequestHandlerFactory class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPRequestHandlerFactory_INCLUDED
+#define Net_HTTPRequestHandlerFactory_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/BasicEvent.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPServerRequest;
+class HTTPServerResponse;
+class HTTPRequestHandler;
+
+
+class Net_API HTTPRequestHandlerFactory
+	/// A factory for HTTPRequestHandler objects.
+	/// Subclasses must override the createRequestHandler()
+	/// method.
+{
+public:
+	typedef Poco::SharedPtr<HTTPRequestHandlerFactory> Ptr;
+	
+	HTTPRequestHandlerFactory();
+		/// Creates the HTTPRequestHandlerFactory.
+
+	virtual ~HTTPRequestHandlerFactory();
+		/// Destroys the HTTPRequestHandlerFactory.
+
+	virtual HTTPRequestHandler* createRequestHandler(const HTTPServerRequest& request) = 0;
+		/// Must be overridden by subclasses.
+		///
+		/// Creates a new request handler for the given HTTP request.
+		///
+		/// The method should inspect the given HTTPServerRequest object (e.g., method
+		/// and URI) and create an appropriate HTTPRequestHandler object to handle the
+		/// request.
+		///
+		/// If the request contains a "Expect: 100-continue" header, it's possible
+		/// to prevent the server from sending the default 100 Continue response 
+		/// by setting the status of the response object that can be obtained through 
+		/// the request object (request.response()) to something other than 200 OK.
+
+protected:
+	Poco::BasicEvent<const bool> serverStopped;
+
+private:
+	HTTPRequestHandlerFactory(const HTTPRequestHandlerFactory&);
+	HTTPRequestHandlerFactory& operator = (const HTTPRequestHandlerFactory&);
+	
+	friend class HTTPServer;
+	friend class HTTPServerConnection;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPRequestHandlerFactory_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPResponse.h b/base/poco/Net/include/Poco/Net/HTTPResponse.h
new file mode 100644
index 00000000000..430653de669
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPResponse.h
@@ -0,0 +1,306 @@
+//
+// HTTPResponse.h
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPResponse
+//
+// Definition of the HTTPResponse class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPResponse_INCLUDED
+#define Net_HTTPResponse_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/HTTPMessage.h"
+#include "Poco/Net/HTTPCookie.h"
+#include "Poco/Timestamp.h"
+#include <vector>
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPCookie;
+
+
+class Net_API HTTPResponse: public HTTPMessage
+	/// This class encapsulates an HTTP response
+	/// message.
+	///
+	/// In addition to the properties common to
+	/// all HTTP messages, a HTTP response has
+	/// status code and a reason phrase.
+{
+public:
+	enum HTTPStatus
+	{
+		HTTP_CONTINUE                        = 100,
+		HTTP_SWITCHING_PROTOCOLS             = 101,
+		HTTP_PROCESSING                      = 102,
+		HTTP_OK                              = 200,
+		HTTP_CREATED                         = 201,
+		HTTP_ACCEPTED                        = 202,
+		HTTP_NONAUTHORITATIVE                = 203,
+		HTTP_NO_CONTENT                      = 204,
+		HTTP_RESET_CONTENT                   = 205,
+		HTTP_PARTIAL_CONTENT                 = 206,
+		HTTP_MULTI_STATUS                    = 207,
+		HTTP_ALREADY_REPORTED                = 208,
+		HTTP_IM_USED                         = 226,
+		HTTP_MULTIPLE_CHOICES                = 300,
+		HTTP_MOVED_PERMANENTLY               = 301,
+		HTTP_FOUND                           = 302,
+		HTTP_SEE_OTHER                       = 303,
+		HTTP_NOT_MODIFIED                    = 304,
+		HTTP_USE_PROXY                       = 305,
+		HTTP_USEPROXY                        = 305, /// @deprecated
+		// UNUSED: 306
+		HTTP_TEMPORARY_REDIRECT              = 307,
+		HTTP_PERMANENT_REDIRECT              = 308,
+		HTTP_BAD_REQUEST                     = 400,
+		HTTP_UNAUTHORIZED                    = 401,
+		HTTP_PAYMENT_REQUIRED                = 402,
+		HTTP_FORBIDDEN                       = 403,
+		HTTP_NOT_FOUND                       = 404,
+		HTTP_METHOD_NOT_ALLOWED              = 405,
+		HTTP_NOT_ACCEPTABLE                  = 406,
+		HTTP_PROXY_AUTHENTICATION_REQUIRED   = 407,
+		HTTP_REQUEST_TIMEOUT                 = 408,
+		HTTP_CONFLICT                        = 409,
+		HTTP_GONE                            = 410,
+		HTTP_LENGTH_REQUIRED                 = 411,
+		HTTP_PRECONDITION_FAILED             = 412,
+		HTTP_REQUEST_ENTITY_TOO_LARGE        = 413,
+		HTTP_REQUESTENTITYTOOLARGE           = 413, /// @deprecated
+		HTTP_REQUEST_URI_TOO_LONG            = 414,
+		HTTP_REQUESTURITOOLONG               = 414, /// @deprecated
+		HTTP_UNSUPPORTED_MEDIA_TYPE          = 415,
+		HTTP_UNSUPPORTEDMEDIATYPE            = 415, /// @deprecated
+		HTTP_REQUESTED_RANGE_NOT_SATISFIABLE = 416,
+		HTTP_EXPECTATION_FAILED              = 417,
+		HTTP_IM_A_TEAPOT                     = 418,
+		HTTP_ENCHANCE_YOUR_CALM              = 420,
+		HTTP_MISDIRECTED_REQUEST             = 421,
+		HTTP_UNPROCESSABLE_ENTITY            = 422,
+		HTTP_LOCKED                          = 423,
+		HTTP_FAILED_DEPENDENCY               = 424,
+		HTTP_UPGRADE_REQUIRED                = 426,
+		HTTP_PRECONDITION_REQUIRED           = 428,
+		HTTP_TOO_MANY_REQUESTS               = 429,
+		HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+		HTTP_UNAVAILABLE_FOR_LEGAL_REASONS   = 451,
+		HTTP_INTERNAL_SERVER_ERROR           = 500,
+		HTTP_NOT_IMPLEMENTED                 = 501,
+		HTTP_BAD_GATEWAY                     = 502,
+		HTTP_SERVICE_UNAVAILABLE             = 503,
+		HTTP_GATEWAY_TIMEOUT                 = 504,
+		HTTP_VERSION_NOT_SUPPORTED           = 505,
+		HTTP_VARIANT_ALSO_NEGOTIATES         = 506,
+		HTTP_INSUFFICIENT_STORAGE            = 507,
+		HTTP_LOOP_DETECTED                   = 508,
+		HTTP_NOT_EXTENDED                    = 510,
+		HTTP_NETWORK_AUTHENTICATION_REQUIRED = 511
+	};
+
+	HTTPResponse();
+		/// Creates the HTTPResponse with OK status.
+		
+	HTTPResponse(HTTPStatus status, const std::string& reason);
+		/// Creates the HTTPResponse with the given status
+		/// and reason phrase.
+
+	HTTPResponse(const std::string& version, HTTPStatus status, const std::string& reason);
+		/// Creates the HTTPResponse with the given version, status
+		/// and reason phrase.
+		
+	HTTPResponse(HTTPStatus status);
+		/// Creates the HTTPResponse with the given status
+		/// an an appropriate reason phrase.
+
+	HTTPResponse(const std::string& version, HTTPStatus status);
+		/// Creates the HTTPResponse with the given version, status
+		/// an an appropriate reason phrase.
+
+	virtual ~HTTPResponse();
+		/// Destroys the HTTPResponse.
+
+	void setStatus(HTTPStatus status);
+		/// Sets the HTTP status code.
+		///
+		/// Does not change the reason phrase.
+		
+	HTTPStatus getStatus() const;
+		/// Returns the HTTP status code.
+		
+	void setStatus(const std::string& status);
+		/// Sets the HTTP status code.
+		///
+		/// The string must contain a valid
+		/// HTTP numerical status code.
+		
+	void setReason(const std::string& reason);
+		/// Sets the HTTP reason phrase.
+		
+	const std::string& getReason() const;
+		/// Returns the HTTP reason phrase.
+
+	void setStatusAndReason(HTTPStatus status, const std::string& reason);
+		/// Sets the HTTP status code and reason phrase.
+		
+	void setStatusAndReason(HTTPStatus status);
+		/// Sets the HTTP status code and reason phrase.
+		///
+		/// The reason phrase is set according to the status code.
+
+	void setDate(const Poco::Timestamp& dateTime);
+		/// Sets the Date header to the given date/time value.
+		
+	Poco::Timestamp getDate() const;
+		/// Returns the value of the Date header.
+
+	void addCookie(const HTTPCookie& cookie);
+		/// Adds the cookie to the response by
+		/// adding a Set-Cookie header.
+
+	void getCookies(std::vector<HTTPCookie>& cookies) const;
+		/// Returns a vector with all the cookies
+		/// set in the response header.
+		///
+		/// May throw an exception in case of a malformed
+		/// Set-Cookie header.
+
+	void write(std::ostream& ostr) const;
+		/// Writes the HTTP response to the given
+		/// output stream.
+
+	void beginWrite(std::ostream& ostr) const;
+		/// Writes the HTTP response to the given
+		/// output stream, but do not finish with \r\n delimiter.
+
+#if __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Woverloaded-virtual"
+#endif
+	void read(std::istream& istr);
+#if __clang__
+#pragma clang diagnostic pop
+#endif
+		/// Reads the HTTP response from the
+		/// given input stream.
+		///
+		/// 100 Continue responses are ignored.
+	
+	static const std::string& getReasonForStatus(HTTPStatus status);
+		/// Returns an appropriate reason phrase
+		/// for the given status code.
+
+	static const std::string HTTP_REASON_CONTINUE;
+	static const std::string HTTP_REASON_SWITCHING_PROTOCOLS;
+	static const std::string HTTP_REASON_PROCESSING;
+	static const std::string HTTP_REASON_OK;
+	static const std::string HTTP_REASON_CREATED;
+	static const std::string HTTP_REASON_ACCEPTED;
+	static const std::string HTTP_REASON_NONAUTHORITATIVE;
+	static const std::string HTTP_REASON_NO_CONTENT;
+	static const std::string HTTP_REASON_RESET_CONTENT;
+	static const std::string HTTP_REASON_PARTIAL_CONTENT;
+	static const std::string HTTP_REASON_MULTI_STATUS;
+	static const std::string HTTP_REASON_ALREADY_REPORTED;
+	static const std::string HTTP_REASON_IM_USED;
+	static const std::string HTTP_REASON_MULTIPLE_CHOICES;
+	static const std::string HTTP_REASON_MOVED_PERMANENTLY;
+	static const std::string HTTP_REASON_FOUND;
+	static const std::string HTTP_REASON_SEE_OTHER;
+	static const std::string HTTP_REASON_NOT_MODIFIED;
+	static const std::string HTTP_REASON_USE_PROXY;
+	static const std::string HTTP_REASON_TEMPORARY_REDIRECT;
+	static const std::string HTTP_REASON_PERMANENT_REDIRECT;
+	static const std::string HTTP_REASON_BAD_REQUEST;
+	static const std::string HTTP_REASON_UNAUTHORIZED;
+	static const std::string HTTP_REASON_PAYMENT_REQUIRED;
+	static const std::string HTTP_REASON_FORBIDDEN;
+	static const std::string HTTP_REASON_NOT_FOUND;
+	static const std::string HTTP_REASON_METHOD_NOT_ALLOWED;
+	static const std::string HTTP_REASON_NOT_ACCEPTABLE;
+	static const std::string HTTP_REASON_PROXY_AUTHENTICATION_REQUIRED;
+	static const std::string HTTP_REASON_REQUEST_TIMEOUT;
+	static const std::string HTTP_REASON_CONFLICT;
+	static const std::string HTTP_REASON_GONE;
+	static const std::string HTTP_REASON_LENGTH_REQUIRED;
+	static const std::string HTTP_REASON_PRECONDITION_FAILED;
+	static const std::string HTTP_REASON_REQUEST_ENTITY_TOO_LARGE;
+	static const std::string HTTP_REASON_REQUEST_URI_TOO_LONG;
+	static const std::string HTTP_REASON_UNSUPPORTED_MEDIA_TYPE;
+	static const std::string HTTP_REASON_REQUESTED_RANGE_NOT_SATISFIABLE;
+	static const std::string HTTP_REASON_EXPECTATION_FAILED;
+	static const std::string HTTP_REASON_IM_A_TEAPOT;
+	static const std::string HTTP_REASON_ENCHANCE_YOUR_CALM;
+	static const std::string HTTP_REASON_MISDIRECTED_REQUEST;
+	static const std::string HTTP_REASON_UNPROCESSABLE_ENTITY;
+	static const std::string HTTP_REASON_LOCKED;
+	static const std::string HTTP_REASON_FAILED_DEPENDENCY;
+	static const std::string HTTP_REASON_UPGRADE_REQUIRED;
+	static const std::string HTTP_REASON_PRECONDITION_REQUIRED;
+	static const std::string HTTP_REASON_TOO_MANY_REQUESTS;
+	static const std::string HTTP_REASON_REQUEST_HEADER_FIELDS_TOO_LARGE;
+	static const std::string HTTP_REASON_UNAVAILABLE_FOR_LEGAL_REASONS;
+	static const std::string HTTP_REASON_INTERNAL_SERVER_ERROR;
+	static const std::string HTTP_REASON_NOT_IMPLEMENTED;
+	static const std::string HTTP_REASON_BAD_GATEWAY;
+	static const std::string HTTP_REASON_SERVICE_UNAVAILABLE;
+	static const std::string HTTP_REASON_GATEWAY_TIMEOUT;
+	static const std::string HTTP_REASON_VERSION_NOT_SUPPORTED;
+	static const std::string HTTP_REASON_VARIANT_ALSO_NEGOTIATES;
+	static const std::string HTTP_REASON_INSUFFICIENT_STORAGE;
+	static const std::string HTTP_REASON_LOOP_DETECTED;
+	static const std::string HTTP_REASON_NOT_EXTENDED;
+	static const std::string HTTP_REASON_NETWORK_AUTHENTICATION_REQUIRED;
+	static const std::string HTTP_REASON_UNKNOWN;
+	
+	static const std::string DATE;
+	static const std::string SET_COOKIE;
+
+private:
+	enum Limits
+	{
+		MAX_VERSION_LENGTH = 8,
+		MAX_STATUS_LENGTH  = 3,
+		MAX_REASON_LENGTH  = 512
+	};
+	
+	HTTPStatus  _status;
+	std::string _reason;
+	
+	HTTPResponse(const HTTPResponse&);
+	HTTPResponse& operator = (const HTTPResponse&);
+};
+
+
+//
+// inlines
+//
+inline HTTPResponse::HTTPStatus HTTPResponse::getStatus() const
+{
+	return _status;
+}
+
+
+inline const std::string& HTTPResponse::getReason() const
+{
+	return _reason;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPResponse_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPServer.h b/base/poco/Net/include/Poco/Net/HTTPServer.h
new file mode 100644
index 00000000000..69f092a6738
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPServer.h
@@ -0,0 +1,103 @@
+//
+// HTTPServer.h
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPServer
+//
+// Definition of the HTTPServer class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPServer_INCLUDED
+#define Net_HTTPServer_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/TCPServer.h"
+#include "Poco/Net/HTTPRequestHandlerFactory.h"
+#include "Poco/Net/HTTPServerParams.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API HTTPServer: public TCPServer
+	/// A subclass of TCPServer that implements a
+	/// full-featured multithreaded HTTP server.
+	///
+	/// A HTTPRequestHandlerFactory must be supplied.
+	/// The ServerSocket must be bound and in listening state.
+	///
+	/// To configure various aspects of the server, a HTTPServerParams
+	/// object can be passed to the constructor.
+	///
+	/// The server supports:
+	///   - HTTP/1.0 and HTTP/1.1
+	///   - automatic handling of persistent connections.
+	///   - automatic decoding/encoding of request/response message bodies
+	///     using chunked transfer encoding.
+	///
+	/// Please see the TCPServer class for information about
+	/// connection and thread handling.
+	///
+	/// See RFC 2616 <http://www.faqs.org/rfcs/rfc2616.html> for more
+	/// information about the HTTP protocol.
+{
+public:
+	HTTPServer(HTTPRequestHandlerFactory::Ptr pFactory, Poco::UInt16 portNumber = 80, HTTPServerParams::Ptr pParams = new HTTPServerParams);
+		/// Creates HTTPServer listening on the given port (default 80).
+		///
+		/// The server takes ownership of the HTTPRequstHandlerFactory
+		/// and deletes it when it's no longer needed.
+		///
+		/// New threads are taken from the default thread pool.
+
+	HTTPServer(HTTPRequestHandlerFactory::Ptr pFactory, const ServerSocket& socket, HTTPServerParams::Ptr pParams);
+		/// Creates the HTTPServer, using the given ServerSocket.
+		///
+		/// The server takes ownership of the HTTPRequstHandlerFactory
+		/// and deletes it when it's no longer needed.
+		///
+		/// The server also takes ownership of the HTTPServerParams object.
+		///
+		/// New threads are taken from the default thread pool.
+
+	HTTPServer(HTTPRequestHandlerFactory::Ptr pFactory, Poco::ThreadPool& threadPool, const ServerSocket& socket, HTTPServerParams::Ptr pParams);
+		/// Creates the HTTPServer, using the given ServerSocket.
+		///
+		/// The server takes ownership of the HTTPRequstHandlerFactory
+		/// and deletes it when it's no longer needed.
+		///
+		/// The server also takes ownership of the HTTPServerParams object.
+		///
+		/// New threads are taken from the given thread pool.
+
+	~HTTPServer();
+		/// Destroys the HTTPServer and its HTTPRequestHandlerFactory.
+
+	void stopAll(bool abortCurrent = false);
+		/// Stops the server. In contrast to TCPServer::stop(), which also
+		/// stops the server, but allows all client connections to finish at
+		/// their pace, this allows finer control over client connections.
+		///
+		/// If abortCurrent is false, all current requests are allowed to
+		/// complete. If abortCurrent is true, the underlying sockets of
+		/// all client connections are shut down, causing all requests
+		/// to abort.
+
+private:
+	HTTPRequestHandlerFactory::Ptr _pFactory;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPServer_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPServerConnection.h b/base/poco/Net/include/Poco/Net/HTTPServerConnection.h
new file mode 100644
index 00000000000..536889c04a8
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPServerConnection.h
@@ -0,0 +1,65 @@
+//
+// HTTPServerConnection.h
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPServerConnection
+//
+// Definition of the HTTPServerConnection class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPServerConnection_INCLUDED
+#define Net_HTTPServerConnection_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/TCPServerConnection.h"
+#include "Poco/Net/HTTPResponse.h"
+#include "Poco/Net/HTTPRequestHandlerFactory.h"
+#include "Poco/Net/HTTPServerParams.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPServerSession;
+
+
+class Net_API HTTPServerConnection: public TCPServerConnection
+	/// This subclass of TCPServerConnection handles HTTP
+	/// connections.
+{
+public:
+	HTTPServerConnection(const StreamSocket& socket, HTTPServerParams::Ptr pParams, HTTPRequestHandlerFactory::Ptr pFactory);
+		/// Creates the HTTPServerConnection.
+
+	virtual ~HTTPServerConnection();
+		/// Destroys the HTTPServerConnection.
+		
+	void run();
+		/// Handles all HTTP requests coming in.
+
+protected:
+	void sendErrorResponse(HTTPServerSession& session, HTTPResponse::HTTPStatus status);
+	void onServerStopped(const bool& abortCurrent);
+
+private:
+	HTTPServerParams::Ptr          _pParams;
+	HTTPRequestHandlerFactory::Ptr _pFactory;
+	bool _stopped;
+	Poco::FastMutex _mutex;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPServerConnection_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPServerConnectionFactory.h b/base/poco/Net/include/Poco/Net/HTTPServerConnectionFactory.h
new file mode 100644
index 00000000000..fc44f912c52
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPServerConnectionFactory.h
@@ -0,0 +1,55 @@
+//
+// HTTPServerConnectionFactory.h
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPServerConnectionFactory
+//
+// Definition of the HTTPServerConnectionFactory class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPServerConnectionFactory_INCLUDED
+#define Net_HTTPServerConnectionFactory_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/TCPServerConnectionFactory.h"
+#include "Poco/Net/HTTPRequestHandlerFactory.h"
+#include "Poco/Net/HTTPServerParams.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API HTTPServerConnectionFactory: public TCPServerConnectionFactory
+	/// This implementation of a TCPServerConnectionFactory
+	/// is used by HTTPServer to create HTTPServerConnection objects.
+{
+public:
+	HTTPServerConnectionFactory(HTTPServerParams::Ptr pParams, HTTPRequestHandlerFactory::Ptr pFactory);
+		/// Creates the HTTPServerConnectionFactory.
+
+	~HTTPServerConnectionFactory();
+		/// Destroys the HTTPServerConnectionFactory.
+
+	TCPServerConnection* createConnection(const StreamSocket& socket);
+		/// Creates an instance of HTTPServerConnection
+		/// using the given StreamSocket.
+	
+private:
+	HTTPServerParams::Ptr          _pParams;
+	HTTPRequestHandlerFactory::Ptr _pFactory;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPServerConnectionFactory_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPServerParams.h b/base/poco/Net/include/Poco/Net/HTTPServerParams.h
new file mode 100644
index 00000000000..0fb86aaca14
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPServerParams.h
@@ -0,0 +1,154 @@
+//
+// HTTPServerParams.h
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPServerParams
+//
+// Definition of the HTTPServerParams class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPServerParams_INCLUDED
+#define Net_HTTPServerParams_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/TCPServerParams.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API HTTPServerParams: public TCPServerParams
+	/// This class is used to specify parameters to both the
+	/// HTTPServer, as well as to HTTPRequestHandler objects.
+	///
+	/// Subclasses may add new parameters to the class.
+{
+public:
+	typedef Poco::AutoPtr<HTTPServerParams> Ptr;
+	
+	HTTPServerParams();
+		/// Creates the HTTPServerParams.
+		///
+		/// Sets the following default values:
+		///   - timeout:              60 seconds
+		///   - keepAlive:            true
+		///   - maxKeepAliveRequests: 0
+		///   - keepAliveTimeout:     10 seconds
+		
+	void setServerName(const std::string& serverName);
+		/// Sets the name and port (name:port) that the server uses to identify itself.
+		///
+		/// If this is not set to valid DNS name for your host, server-generated
+		/// redirections will not work.
+		
+	const std::string& getServerName() const;
+		/// Returns the name and port (name:port) that the server uses to identify itself.
+
+	void setSoftwareVersion(const std::string& softwareVersion);
+		/// Sets the server software name and version that the server uses to identify
+		/// itself. If this is set to a non-empty string, the server will
+		/// automatically include a Server header field with the value given
+		/// here in every response it sends.
+		///
+		/// The format of the softwareVersion string should be name/version
+		/// (e.g. MyHTTPServer/1.0).
+
+	const std::string& getSoftwareVersion() const;
+		/// Returns the server software name and version that the server uses to
+		/// identify itself.
+
+	void setTimeout(const Poco::Timespan& timeout);
+		/// Sets the connection timeout for HTTP connections.
+		
+	const Poco::Timespan& getTimeout() const;
+		/// Returns the connection timeout for HTTP connections.
+		
+	void setKeepAlive(bool keepAlive);
+		/// Enables (keepAlive == true) or disables (keepAlive == false)
+		/// persistent connections.
+		
+	bool getKeepAlive() const;
+		/// Returns true iff persistent connections are enabled.
+		
+	void setKeepAliveTimeout(const Poco::Timespan& timeout);
+		/// Sets the connection timeout for HTTP connections.
+		
+	const Poco::Timespan& getKeepAliveTimeout() const;
+		/// Returns the connection timeout for HTTP connections.
+	
+	void setMaxKeepAliveRequests(int maxKeepAliveRequests);
+		/// Specifies the maximum number of requests allowed
+		/// during a persistent connection. 0 means unlimited
+		/// connections.
+		
+	int getMaxKeepAliveRequests() const;
+		/// Returns the maximum number of requests allowed
+		/// during a persistent connection, or 0 if
+		/// unlimited connections are allowed.
+
+protected:
+	virtual ~HTTPServerParams();
+		/// Destroys the HTTPServerParams.
+
+private:
+	std::string    _serverName;
+	std::string    _softwareVersion;
+	Poco::Timespan _timeout;
+	bool           _keepAlive;
+	int            _maxKeepAliveRequests;
+	Poco::Timespan _keepAliveTimeout;
+};
+
+
+//
+// inlines
+//
+inline const std::string& HTTPServerParams::getServerName() const
+{
+	return _serverName;
+}
+
+
+inline const std::string& HTTPServerParams::getSoftwareVersion() const
+{
+	return _softwareVersion;
+}
+
+
+inline const Poco::Timespan& HTTPServerParams::getTimeout() const
+{
+	return _timeout;
+}
+
+
+inline bool HTTPServerParams::getKeepAlive() const
+{
+	return _keepAlive;
+}
+
+
+inline int HTTPServerParams::getMaxKeepAliveRequests() const
+{
+	return _maxKeepAliveRequests;
+}
+
+
+inline const Poco::Timespan& HTTPServerParams::getKeepAliveTimeout() const
+{
+	return _keepAliveTimeout;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPServerParams_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPServerRequest.h b/base/poco/Net/include/Poco/Net/HTTPServerRequest.h
new file mode 100644
index 00000000000..69ffeaec084
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPServerRequest.h
@@ -0,0 +1,80 @@
+//
+// HTTPServerRequest.h
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPServerRequest
+//
+// Definition of the HTTPServerRequest class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPServerRequest_INCLUDED
+#define Net_HTTPServerRequest_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/HTTPRequest.h"
+#include "Poco/Net/SocketAddress.h"
+#include <istream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPServerSession;
+class HTTPServerResponse;
+class HTTPServerParams;
+
+
+class Net_API HTTPServerRequest: public HTTPRequest
+	/// This abstract subclass of HTTPRequest is used for
+	/// representing server-side HTTP requests.
+	///
+	/// A HTTPServerRequest is passed to the
+	/// handleRequest() method of HTTPRequestHandler.
+{
+public:
+	HTTPServerRequest();
+		/// Creates the HTTPServerRequest
+
+	~HTTPServerRequest();
+		/// Destroys the HTTPServerRequest.
+		
+	virtual std::istream& stream() = 0;
+		/// Returns the input stream for reading
+		/// the request body.
+		///
+		/// The stream must be valid until the HTTPServerRequest
+		/// object is destroyed.
+		
+	virtual const SocketAddress& clientAddress() const = 0;
+		/// Returns the client's address.
+
+	virtual const SocketAddress& serverAddress() const = 0;
+		/// Returns the server's address.
+		
+	virtual const HTTPServerParams& serverParams() const = 0;
+		/// Returns a reference to the server parameters.
+
+	virtual HTTPServerResponse& response() const = 0;
+		/// Returns a reference to the associated response.
+		
+	virtual bool secure() const = 0;
+		/// Returns true if the request is using a secure
+		/// connection. Returns false if no secure connection
+		/// is used, or if it is not known whether a secure
+		/// connection is used.
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPServerRequest_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPServerRequestImpl.h b/base/poco/Net/include/Poco/Net/HTTPServerRequestImpl.h
new file mode 100644
index 00000000000..419adbb5e42
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPServerRequestImpl.h
@@ -0,0 +1,142 @@
+//
+// HTTPServerRequestImpl.h
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPServerRequestImpl
+//
+// Definition of the HTTPServerRequestImpl class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPServerRequestImpl_INCLUDED
+#define Net_HTTPServerRequestImpl_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/HTTPServerRequest.h"
+#include "Poco/Net/HTTPServerResponseImpl.h"
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/AutoPtr.h"
+#include <istream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPServerSession;
+class HTTPServerParams;
+class StreamSocket;
+
+
+class Net_API HTTPServerRequestImpl: public HTTPServerRequest
+	/// This subclass of HTTPServerRequest is used for
+	/// representing server-side HTTP requests.
+	///
+	/// A HTTPServerRequest is passed to the
+	/// handleRequest() method of HTTPRequestHandler.
+{
+public:
+	HTTPServerRequestImpl(HTTPServerResponseImpl& response, HTTPServerSession& session, HTTPServerParams* pParams);
+		/// Creates the HTTPServerRequestImpl, using the
+		/// given HTTPServerSession.
+
+	~HTTPServerRequestImpl();
+		/// Destroys the HTTPServerRequestImpl.
+		
+	std::istream& stream();
+		/// Returns the input stream for reading
+		/// the request body.
+		///
+		/// The stream is valid until the HTTPServerRequestImpl
+		/// object is destroyed.
+		
+	const SocketAddress& clientAddress() const;
+		/// Returns the client's address.
+
+	const SocketAddress& serverAddress() const;
+		/// Returns the server's address.
+		
+	const HTTPServerParams& serverParams() const;
+		/// Returns a reference to the server parameters.
+
+	HTTPServerResponse& response() const;
+		/// Returns a reference to the associated response.
+		
+	bool secure() const;
+		/// Returns true if the request is using a secure
+		/// connection. Returns false if no secure connection
+		/// is used, or if it is not known whether a secure
+		/// connection is used.		
+		
+	StreamSocket& socket();
+		/// Returns a reference to the underlying socket.
+		
+	StreamSocket detachSocket();
+		/// Returns the underlying socket after detaching
+		/// it from the server session.
+		
+	HTTPServerSession& session();
+		/// Returns the underlying HTTPServerSession.
+
+private:
+	HTTPServerResponseImpl&         _response;
+	HTTPServerSession&              _session;
+	std::istream*                   _pStream;
+	Poco::AutoPtr<HTTPServerParams> _pParams;
+	SocketAddress                   _clientAddress;
+	SocketAddress                   _serverAddress;
+};
+
+
+//
+// inlines
+//
+inline std::istream& HTTPServerRequestImpl::stream()
+{
+	poco_check_ptr (_pStream);
+	
+	return *_pStream;
+}
+
+
+inline const SocketAddress& HTTPServerRequestImpl::clientAddress() const
+{
+	return _clientAddress;
+}
+
+
+inline const SocketAddress& HTTPServerRequestImpl::serverAddress() const
+{
+	return _serverAddress;
+}
+
+
+inline const HTTPServerParams& HTTPServerRequestImpl::serverParams() const
+{
+	return *_pParams;
+}
+
+
+inline HTTPServerResponse& HTTPServerRequestImpl::response() const
+{
+	return _response;
+}
+
+
+inline HTTPServerSession& HTTPServerRequestImpl::session()
+{
+	return _session;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPServerRequestImpl_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPServerResponse.h b/base/poco/Net/include/Poco/Net/HTTPServerResponse.h
new file mode 100644
index 00000000000..5735f479e25
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPServerResponse.h
@@ -0,0 +1,127 @@
+//
+// HTTPServerResponse.h
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPServerResponse
+//
+// Definition of the HTTPServerResponse class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPServerResponse_INCLUDED
+#define Net_HTTPServerResponse_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/HTTPResponse.h"
+#include <cstddef>
+#include <ostream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPServerSession;
+class HTTPCookie;
+
+
+class Net_API HTTPServerResponse: public HTTPResponse
+	/// This subclass of HTTPResponse is used for
+	/// representing server-side HTTP responses.
+	///
+	/// A HTTPServerResponse is passed to the
+	/// handleRequest() method of HTTPRequestHandler.
+	///
+	/// handleRequest() must set a status code
+	/// and optional reason phrase, set headers
+	/// as necessary, and provide a message body.
+{
+public:
+	HTTPServerResponse();
+		/// Creates the HTTPServerResponse.
+
+	~HTTPServerResponse();
+		/// Destroys the HTTPServerResponse.
+
+	virtual void sendContinue() = 0;
+		/// Sends a 100 Continue response to the
+		/// client.
+		
+	virtual std::ostream& send() = 0;
+		/// Sends the response header to the client and
+		/// returns an output stream for sending the
+		/// response body.
+		///
+		/// The returned stream is valid until the response
+		/// object is destroyed.
+		///
+		/// Must not be called after beginSend(), sendFile(), sendBuffer()
+		/// or redirect() has been called.
+
+	virtual std::pair<std::ostream *, std::ostream *> beginSend() = 0;
+		/// Sends the response headers to the client
+		/// but do not finish headers with \r\n,
+		/// allowing to continue sending additional header fields.
+		///
+		/// Returns an output streams for sending the remaining headers
+		/// and response body.
+		///
+		/// Must not be called after send(), sendFile(), sendBuffer()
+		/// or redirect() has been called.
+		
+	virtual void sendFile(const std::string& path, const std::string& mediaType) = 0;
+		/// Sends the response header to the client, followed
+		/// by the content of the given file.
+		///
+		/// Must not be called after send(), sendBuffer()
+		/// or redirect() has been called.
+		///
+		/// Throws a FileNotFoundException if the file
+		/// cannot be found, or an OpenFileException if
+		/// the file cannot be opened.
+		
+	virtual void sendBuffer(const void* pBuffer, std::size_t length) = 0;
+		/// Sends the response header to the client, followed
+		/// by the contents of the given buffer.
+		///
+		/// The Content-Length header of the response is set
+		/// to length and chunked transfer encoding is disabled.
+		///
+		/// If both the HTTP message header and body (from the
+		/// given buffer) fit into one single network packet, the
+		/// complete response can be sent in one network packet.
+		///
+		/// Must not be called after send(), sendFile()
+		/// or redirect() has been called.
+		
+	virtual void redirect(const std::string& uri, HTTPStatus status = HTTP_FOUND) = 0;
+		/// Sets the status code, which must be one of
+		/// HTTP_MOVED_PERMANENTLY (301), HTTP_FOUND (302),
+		/// or HTTP_SEE_OTHER (303),
+		/// and sets the "Location" header field
+		/// to the given URI, which according to
+		/// the HTTP specification, must be absolute.
+		///
+		/// Must not be called after send() has been called.
+		
+	virtual void requireAuthentication(const std::string& realm) = 0;
+		/// Sets the status code to 401 (Unauthorized)
+		/// and sets the "WWW-Authenticate" header field
+		/// according to the given realm.
+		
+	virtual bool sent() const = 0;
+		/// Returns true if the response (header) has been sent.
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPServerResponse_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPServerResponseImpl.h b/base/poco/Net/include/Poco/Net/HTTPServerResponseImpl.h
new file mode 100644
index 00000000000..b002eaf0aab
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPServerResponseImpl.h
@@ -0,0 +1,151 @@
+//
+// HTTPServerResponseImpl.h
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPServerResponseImpl
+//
+// Definition of the HTTPServerResponseImpl class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPServerResponseImpl_INCLUDED
+#define Net_HTTPServerResponseImpl_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/HTTPServerResponse.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPServerSession;
+class HTTPServerRequestImpl;
+
+
+class Net_API HTTPServerResponseImpl: public HTTPServerResponse
+	/// This subclass of HTTPServerResponse is used for
+	/// representing server-side HTTP responses.
+	///
+	/// A HTTPServerResponse is passed to the
+	/// handleRequest() method of HTTPRequestHandler.
+	///
+	/// handleRequest() must set a status code
+	/// and optional reason phrase, set headers
+	/// as necessary, and provide a message body.
+{
+public:
+	HTTPServerResponseImpl(HTTPServerSession& session);
+		/// Creates the HTTPServerResponseImpl.
+
+	~HTTPServerResponseImpl();
+		/// Destroys the HTTPServerResponseImpl.
+
+	void sendContinue();
+		/// Sends a 100 Continue response to the
+		/// client.
+		
+	std::ostream& send();
+		/// Sends the response header to the client and
+		/// returns an output stream for sending the
+		/// response body.
+		///
+		/// The returned stream is valid until the response
+		/// object is destroyed.
+		///
+		/// Must not be called after beginSend(), sendFile(), sendBuffer()
+		/// or redirect() has been called.
+
+	std::pair<std::ostream *, std::ostream *> beginSend();
+		/// Sends the response headers to the client
+		/// but do not finish headers with \r\n,
+		/// allowing to continue sending additional header fields.
+		///
+		/// Returns an output streams for sending the remaining headers
+		/// and response body.
+		///
+		/// Must not be called after send(), sendFile(), sendBuffer()
+		/// or redirect() has been called.
+		
+	void sendFile(const std::string& path, const std::string& mediaType);
+		/// Sends the response header to the client, followed
+		/// by the content of the given file.
+		///
+		/// Must not be called after send(), sendBuffer()
+		/// or redirect() has been called.
+		///
+		/// Throws a FileNotFoundException if the file
+		/// cannot be found, or an OpenFileException if
+		/// the file cannot be opened.
+		
+	void sendBuffer(const void* pBuffer, std::size_t length);
+		/// Sends the response header to the client, followed
+		/// by the contents of the given buffer.
+		///
+		/// The Content-Length header of the response is set
+		/// to length and chunked transfer encoding is disabled.
+		///
+		/// If both the HTTP message header and body (from the
+		/// given buffer) fit into one single network packet, the
+		/// complete response can be sent in one network packet.
+		///
+		/// Must not be called after send(), sendFile()
+		/// or redirect() has been called.
+		
+	void redirect(const std::string& uri, HTTPStatus status = HTTP_FOUND);
+		/// Sets the status code, which must be one of
+		/// HTTP_MOVED_PERMANENTLY (301), HTTP_FOUND (302),
+		/// or HTTP_SEE_OTHER (303),
+		/// and sets the "Location" header field
+		/// to the given URI, which according to
+		/// the HTTP specification, must be absolute.
+		///
+		/// Must not be called after send() has been called.
+		
+	void requireAuthentication(const std::string& realm);
+		/// Sets the status code to 401 (Unauthorized)
+		/// and sets the "WWW-Authenticate" header field
+		/// according to the given realm.
+		
+	bool sent() const;
+		/// Returns true if the response (header) has been sent.
+
+protected:
+	void attachRequest(HTTPServerRequestImpl* pRequest);
+	
+private:
+	HTTPServerSession& _session;
+	HTTPServerRequestImpl* _pRequest;
+	std::ostream*      _pStream;
+	std::ostream*      _pHeaderStream;
+	
+	friend class HTTPServerRequestImpl;
+};
+
+
+//
+// inlines
+//
+inline bool HTTPServerResponseImpl::sent() const
+{
+	return _pStream != 0;
+}
+
+
+inline void HTTPServerResponseImpl::attachRequest(HTTPServerRequestImpl* pRequest)
+{
+	_pRequest = pRequest;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPServerResponseImpl_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPServerSession.h b/base/poco/Net/include/Poco/Net/HTTPServerSession.h
new file mode 100644
index 00000000000..8b169bf556d
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPServerSession.h
@@ -0,0 +1,76 @@
+//
+// HTTPServerSession.h
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPServerSession
+//
+// Definition of the HTTPServerSession class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPServerSession_INCLUDED
+#define Net_HTTPServerSession_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/HTTPSession.h"
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/Net/HTTPServerSession.h"
+#include "Poco/Net/HTTPServerParams.h"
+#include "Poco/Timespan.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API HTTPServerSession: public HTTPSession
+	/// This class handles the server side of a
+	/// HTTP session. It is used internally by
+	/// HTTPServer.
+{
+public:
+	HTTPServerSession(const StreamSocket& socket, HTTPServerParams::Ptr pParams);
+		/// Creates the HTTPServerSession.
+
+	virtual ~HTTPServerSession();
+		/// Destroys the HTTPServerSession.
+				
+	bool hasMoreRequests();
+		/// Returns true if there are requests available.
+	
+	bool canKeepAlive() const;
+		/// Returns true if the session can be kept alive.
+	
+	SocketAddress clientAddress();
+		/// Returns the client's address.
+		
+	SocketAddress serverAddress();
+		/// Returns the server's address.
+		
+private:
+	bool           _firstRequest;
+	Poco::Timespan _keepAliveTimeout;
+	int            _maxKeepAliveRequests;
+};
+
+
+//
+// inlines
+//
+inline bool HTTPServerSession::canKeepAlive() const
+{
+	return _maxKeepAliveRequests != 0;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPServerSession_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPSession.h b/base/poco/Net/include/Poco/Net/HTTPSession.h
new file mode 100644
index 00000000000..666f6f62677
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPSession.h
@@ -0,0 +1,251 @@
+//
+// HTTPSession.h
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPSession
+//
+// Definition of the HTTPSession class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPSession_INCLUDED
+#define Net_HTTPSession_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/StreamSocket.h"
+#include "Poco/Timespan.h"
+#include "Poco/Exception.h"
+#include "Poco/Any.h"
+#include "Poco/Buffer.h"
+#include <ios>
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API HTTPSession
+	/// HTTPSession implements basic HTTP session management
+	/// for both HTTP clients and HTTP servers.
+	///
+	/// HTTPSession implements buffering for HTTP connections, as well
+	/// as specific support for the various HTTP stream classes.
+	///
+	/// This class can not be instantiated. HTTPClientSession or
+	/// HTTPServerSession must be used instead.
+{
+public:
+	void setKeepAlive(bool keepAlive);
+		/// Sets the keep-alive flag for this session.
+		///
+		/// If the keep-alive flag is enabled, persistent
+		/// HTTP/1.1 connections are supported.
+		
+	bool getKeepAlive() const;
+		/// Returns the value of the keep-alive flag for
+		/// this session.
+
+	void setTimeout(const Poco::Timespan& timeout);
+		/// Sets the timeout for the HTTP session.
+		
+	void setTimeout(const Poco::Timespan& connectionTimeout, const Poco::Timespan& sendTimeout, const Poco::Timespan& receiveTimeout);
+		/// Sets different timeouts for the HTTP session.
+
+	Poco::Timespan getTimeout() const;
+		/// Returns the timeout for the HTTP session.
+
+	bool connected() const;
+		/// Returns true if the underlying socket is connected.
+
+	virtual void abort();
+		/// Aborts a session in progress by shutting down
+		/// and closing the underlying socket.
+		
+	const Poco::Exception* networkException() const;
+		/// If sending or receiving data over the underlying
+		/// socket connection resulted in an exception, a
+		/// pointer to this exception is returned.
+		/// 
+		/// Otherwise, NULL is returned.
+
+	void attachSessionData(const Poco::Any& data);
+		/// Allows to attach an application-specific data 
+		/// item to the session.
+		///
+		/// On the server side, this can be used to manage
+		/// data that must be maintained over the entire
+		/// lifetime of a persistent connection (that is,
+		/// multiple requests sent over the same connection).
+	
+	const Poco::Any& sessionData() const;
+		/// Returns the data attached with attachSessionData(),
+		/// or an empty Poco::Any if no user data has been
+		/// attached.
+
+	enum
+	{
+		HTTP_PORT = 80
+	};
+	
+	StreamSocket detachSocket();
+		/// Detaches the socket from the session.
+		///
+		/// The socket is returned, and a new, uninitialized socket is
+		/// attached to the session.
+
+	StreamSocket& socket();
+		/// Returns a reference to the underlying socket.
+		
+	void drainBuffer(Poco::Buffer<char>& buffer);
+		/// Copies all bytes remaining in the internal buffer to the
+		/// given Poco::Buffer, resizing it as necessary.
+		///
+		/// This is usually used together with detachSocket() to
+		/// obtain any data already read from the socket, but not
+		/// yet processed.
+
+protected:
+	HTTPSession();
+		/// Creates a HTTP session using an
+		/// unconnected stream socket.
+
+	HTTPSession(const StreamSocket& socket);
+		/// Creates a HTTP session using the
+		/// given socket. The session takes ownership
+		/// of the socket and closes it when it's no
+		/// longer used.
+
+	HTTPSession(const StreamSocket& socket, bool keepAlive);
+		/// Creates a HTTP session using the
+		/// given socket. The session takes ownership
+		/// of the socket and closes it when it's no
+		/// longer used.
+
+	virtual ~HTTPSession();
+		/// Destroys the HTTPSession and closes the
+		/// underlying socket.
+
+	int get();
+		/// Returns the next byte in the buffer.
+		/// Reads more data from the socket if there are
+		/// no bytes left in the buffer.
+		
+	int peek();
+		/// Peeks at the next character in the buffer.
+		/// Reads more data from the socket if there are
+		/// no bytes left in the buffer.
+		
+	virtual int read(char* buffer, std::streamsize length);
+		/// Reads up to length bytes.
+		///
+		/// If there is data in the buffer, this data
+		/// is returned. Otherwise, data is read from
+		/// the socket to avoid unnecessary buffering.
+	
+	virtual int write(const char* buffer, std::streamsize length);
+		/// Writes data to the socket.
+
+	int receive(char* buffer, int length);
+		/// Reads up to length bytes.
+		
+	int buffered() const;
+		/// Returns the number of bytes in the buffer.
+
+	void refill();
+		/// Refills the internal buffer.
+		
+	virtual void connect(const SocketAddress& address);
+		/// Connects the underlying socket to the given address
+		/// and sets the socket's receive timeout.	
+		
+	void attachSocket(const StreamSocket& socket);
+		/// Attaches a socket to the session, replacing the
+		/// previously attached socket.
+
+	void close();
+		/// Closes the underlying socket.
+		
+	void setException(const Poco::Exception& exc);
+		/// Stores a clone of the exception.
+
+	void clearException();
+		/// Clears the stored exception.
+
+private:
+	enum
+	{
+		HTTP_DEFAULT_TIMEOUT = 60000000,
+		HTTP_DEFAULT_CONNECTION_TIMEOUT = 30000000
+	};
+	
+	HTTPSession(const HTTPSession&);
+	HTTPSession& operator = (const HTTPSession&);
+	
+	StreamSocket     _socket;
+	char*            _pBuffer;
+	char*            _pCurrent;
+	char*            _pEnd;
+	bool             _keepAlive;
+	Poco::Timespan   _connectionTimeout;
+	Poco::Timespan   _receiveTimeout;
+	Poco::Timespan   _sendTimeout;
+	Poco::Exception* _pException;
+	Poco::Any        _data;
+	
+	friend class HTTPStreamBuf;
+	friend class HTTPHeaderStreamBuf;
+	friend class HTTPFixedLengthStreamBuf;
+	friend class HTTPChunkedStreamBuf;
+};
+
+
+//
+// inlines
+//
+inline bool HTTPSession::getKeepAlive() const
+{
+	return _keepAlive;
+}
+
+
+inline Poco::Timespan HTTPSession::getTimeout() const
+{
+	return _receiveTimeout;
+}
+
+
+inline StreamSocket& HTTPSession::socket()
+{
+	return _socket;
+}
+
+
+inline const Poco::Exception* HTTPSession::networkException() const
+{
+	return _pException;
+}
+
+
+inline int HTTPSession::buffered() const
+{
+	return static_cast<int>(_pEnd - _pCurrent);
+}
+
+
+inline const Poco::Any& HTTPSession::sessionData() const
+{
+	return _data;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPSession_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPSessionFactory.h b/base/poco/Net/include/Poco/Net/HTTPSessionFactory.h
new file mode 100644
index 00000000000..3bc7d15d2cf
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPSessionFactory.h
@@ -0,0 +1,155 @@
+//
+// HTTPSessionFactory.h
+//
+// Library: Net
+// Package: HTTPClient
+// Module:  HTTPSessionFactory
+//
+// Definition of the HTTPSessionFactory class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPSessionFactoryMgr_INCLUDED
+#define Net_HTTPSessionFactoryMgr_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Mutex.h"
+#include "Poco/URI.h"
+#include "Poco/SingletonHolder.h"
+#include "Poco/SharedPtr.h"
+#include <map>
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPSessionInstantiator;
+class HTTPClientSession;
+
+
+class Net_API HTTPSessionFactory
+	/// A factory for HTTPClientSession objects.
+	///
+	/// Given a URI, this class creates a HTTPClientSession
+	/// (for http) or a HTTPSClientSession (for https) for
+	/// accessing the URI.
+	///
+	/// The actual work of creating the session is done by
+	/// HTTPSessionInstantiator objects that must be registered
+	/// with a HTTPSessionFactory.
+{
+public:
+	HTTPSessionFactory();
+		/// Creates the HTTPSessionFactory.
+
+	HTTPSessionFactory(const std::string& proxyHost, Poco::UInt16 proxyPort);
+		/// Creates the HTTPSessionFactory and sets the proxy host and port.
+
+	~HTTPSessionFactory();
+		/// Destroys the HTTPSessionFactory.
+
+	void registerProtocol(const std::string& protocol, HTTPSessionInstantiator* pSessionInstantiator);
+		/// Registers the session instantiator for the given protocol.
+		/// The factory takes ownership of the SessionInstantiator.
+		///
+		/// A protocol can be registered more than once. However, only the instantiator
+		/// that has been registered first is used. Also, for each call to
+		/// registerProtocol(), a corresponding call to unregisterProtocol() must
+		/// be made.
+
+	void unregisterProtocol(const std::string& protocol);
+		/// Removes the registration of a protocol.
+		///
+		/// Throws a NotFoundException if no instantiator has been registered
+		/// for the given protocol.
+
+	bool supportsProtocol(const std::string& protocol);
+		/// Returns true if a session instantiator for the given protocol has been registered.
+
+	HTTPClientSession* createClientSession(const Poco::URI& uri);
+		/// Creates a client session for the given uri scheme. Throws exception if no factory is registered for the given scheme
+
+	const std::string& proxyHost() const;
+		/// Returns the proxy host, if one has been set, or an empty string otherwise.
+		
+	Poco::UInt16 proxyPort() const;
+		/// Returns the proxy port number, if one has been set, or zero otherwise.
+
+	void setProxy(const std::string& proxyHost, Poco::UInt16 proxyPort);
+		/// Sets the proxy host and port number.
+		
+	void setProxyCredentials(const std::string& username, const std::string& password);
+		/// Sets the username and password for proxy authorization (Basic auth only).
+
+	const std::string& proxyUsername() const;
+		/// Returns the username for proxy authorization.
+		
+	const std::string& proxyPassword() const;
+		/// Returns the password for proxy authorization.
+
+	static HTTPSessionFactory& defaultFactory();
+		/// Returns the default HTTPSessionFactory.
+
+private:
+	struct InstantiatorInfo
+	{
+		HTTPSessionInstantiator* pIn;
+		int cnt;
+		InstantiatorInfo(HTTPSessionInstantiator* pInst);
+			// no destructor!!! this is by purpose, don't add one!
+	};
+
+
+	HTTPSessionFactory(const HTTPSessionFactory&);
+	HTTPSessionFactory& operator = (const HTTPSessionFactory&);
+	
+	typedef std::map<std::string, InstantiatorInfo> Instantiators;
+
+	Instantiators _instantiators;
+	std::string   _proxyHost;
+	Poco::UInt16  _proxyPort;
+	std::string   _proxyUsername;
+	std::string   _proxyPassword;
+
+	mutable Poco::FastMutex _mutex;
+};
+
+
+//
+// inlines
+//
+inline const std::string& HTTPSessionFactory::proxyHost() const
+{
+	return _proxyHost;
+}
+
+
+inline Poco::UInt16 HTTPSessionFactory::proxyPort() const
+{
+	return _proxyPort;
+}
+
+
+inline const std::string& HTTPSessionFactory::proxyUsername() const
+{
+	return _proxyUsername;
+}
+
+
+inline const std::string& HTTPSessionFactory::proxyPassword() const
+{
+	return _proxyPassword;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPSessionFactoryMgr_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPSessionInstantiator.h b/base/poco/Net/include/Poco/Net/HTTPSessionInstantiator.h
new file mode 100644
index 00000000000..cbb6ee82f2c
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPSessionInstantiator.h
@@ -0,0 +1,117 @@
+//
+// HTTPSessionInstantiator.h
+//
+// Library: Net
+// Package: HTTPClient
+// Module:  HTTPSessionInstantiator
+//
+// Definition of the HTTPSessionInstantiator class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPSessionInstantiator_INCLUDED
+#define Net_HTTPSessionInstantiator_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/HTTPSession.h"
+#include "Poco/URI.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPClientSession;
+
+
+class Net_API HTTPSessionInstantiator
+	/// A factory for HTTPClientSession objects.
+	///
+	/// Creates a HTTP session for a given URI.
+	/// A HTTPSessionInstantiator is not used directly.
+	/// Instances are registered with a HTTPSessionFactory,
+	/// and used through it.
+{
+public:
+	HTTPSessionInstantiator();
+		/// Creates the HTTPSessionInstantiator.
+
+	virtual ~HTTPSessionInstantiator();
+		/// Destroys the HTTPSessionInstantiator.
+
+	virtual HTTPClientSession* createClientSession(const Poco::URI& uri);
+		/// Creates a HTTPClientSession for the given URI.
+
+	static void registerInstantiator();
+		/// Registers the instantiator with the global HTTPSessionFactory.
+
+	static void unregisterInstantiator();
+		/// Unregisters the factory with the global HTTPSessionFactory.
+
+protected:
+	void setProxy(const std::string& host, Poco::UInt16 port);
+		/// Sets the proxy host and port.
+		/// Called by HTTPSessionFactory.
+			
+	const std::string& proxyHost() const;
+		/// Returns the proxy post.
+
+	Poco::UInt16 proxyPort() const;
+		/// Returns the proxy port.
+
+	void setProxyCredentials(const std::string& username, const std::string& password);
+		/// Sets the username and password for proxy authorization (Basic auth only).
+
+	const std::string& proxyUsername() const;
+		/// Returns the username for proxy authorization.
+		
+	const std::string& proxyPassword() const;
+		/// Returns the password for proxy authorization.
+
+private:
+	std::string  _proxyHost;
+	Poco::UInt16 _proxyPort;
+	std::string  _proxyUsername;
+	std::string  _proxyPassword;
+	
+	friend class HTTPSessionFactory;
+};
+
+
+//
+// inlines
+//
+inline const std::string& HTTPSessionInstantiator::proxyHost() const
+{
+	return _proxyHost;
+}
+
+
+inline Poco::UInt16 HTTPSessionInstantiator::proxyPort() const
+{
+	return _proxyPort;
+}
+
+
+inline const std::string& HTTPSessionInstantiator::proxyUsername() const
+{
+	return _proxyUsername;
+}
+
+
+inline const std::string& HTTPSessionInstantiator::proxyPassword() const
+{
+	return _proxyPassword;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPSessionInstantiator_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPStream.h b/base/poco/Net/include/Poco/Net/HTTPStream.h
new file mode 100644
index 00000000000..94d52095c5e
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPStream.h
@@ -0,0 +1,103 @@
+//
+// HTTPStream.h
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPStream
+//
+// Definition of the HTTPStream class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPStream_INCLUDED
+#define Net_HTTPStream_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/HTTPBasicStreamBuf.h"
+#include "Poco/MemoryPool.h"
+#include <cstddef>
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPSession;
+
+
+class Net_API HTTPStreamBuf: public HTTPBasicStreamBuf
+	/// This is the streambuf class used for reading and writing
+	/// HTTP message bodies.
+{
+public:
+	typedef HTTPBasicStreamBuf::openmode openmode;
+
+	HTTPStreamBuf(HTTPSession& session, openmode mode);
+	~HTTPStreamBuf();
+	void close();
+	
+protected:
+	int readFromDevice(char* buffer, std::streamsize length);
+	int writeToDevice(const char* buffer, std::streamsize length);
+
+private:
+	HTTPSession& _session;
+	openmode     _mode;
+};
+
+
+class Net_API HTTPIOS: public virtual std::ios
+	/// The base class for HTTPInputStream.
+{
+public:
+	HTTPIOS(HTTPSession& session, HTTPStreamBuf::openmode mode);
+	~HTTPIOS();
+	HTTPStreamBuf* rdbuf();
+
+protected:
+	HTTPStreamBuf _buf;
+};
+
+
+class Net_API HTTPInputStream: public HTTPIOS, public std::istream
+	/// This class is for internal use by HTTPSession only.
+{
+public:
+	HTTPInputStream(HTTPSession& session);
+	~HTTPInputStream();
+
+	void* operator new(std::size_t size);
+	void operator delete(void* ptr);
+	
+private:
+	static Poco::MemoryPool _pool;
+};
+
+
+class Net_API HTTPOutputStream: public HTTPIOS, public std::ostream
+	/// This class is for internal use by HTTPSession only.
+{
+public:
+	HTTPOutputStream(HTTPSession& session);
+	~HTTPOutputStream();
+
+	void* operator new(std::size_t size);
+	void operator delete(void* ptr);
+	
+private:
+	static Poco::MemoryPool _pool;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPStream_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HTTPStreamFactory.h b/base/poco/Net/include/Poco/Net/HTTPStreamFactory.h
new file mode 100644
index 00000000000..df4a5f33366
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HTTPStreamFactory.h
@@ -0,0 +1,92 @@
+//
+// HTTPStreamFactory.h
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPStreamFactory
+//
+// Definition of the HTTPStreamFactory class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPStreamFactory_INCLUDED
+#define Net_HTTPStreamFactory_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/HTTPSession.h"
+#include "Poco/URIStreamFactory.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API HTTPStreamFactory: public Poco::URIStreamFactory
+	/// An implementation of the URIStreamFactory interface
+	/// that handles Hyper-Text Transfer Protocol (http) URIs.
+{
+public:
+	HTTPStreamFactory();
+		/// Creates the HTTPStreamFactory.
+
+	HTTPStreamFactory(const std::string& proxyHost, Poco::UInt16 proxyPort = HTTPSession::HTTP_PORT);
+		/// Creates the HTTPStreamFactory.
+		///
+		/// HTTP connections will use the given proxy.
+
+	HTTPStreamFactory(const std::string& proxyHost, Poco::UInt16 proxyPort, const std::string& proxyUsername, const std::string& proxyPassword);
+		/// Creates the HTTPStreamFactory.
+		///
+		/// HTTP connections will use the given proxy and
+		/// will be authorized against the proxy using Basic authentication
+		/// with the given proxyUsername and proxyPassword.
+
+	virtual ~HTTPStreamFactory();
+		/// Destroys the HTTPStreamFactory.
+		
+	virtual std::istream* open(const Poco::URI& uri);
+		/// Creates and opens a HTTP stream for the given URI.
+		/// The URI must be a http://... URI.
+		///
+		/// Throws a NetException if anything goes wrong.
+		///
+		/// Redirect responses are handled and the redirect
+		/// location is automatically resolved, as long
+		/// as the redirect location is still accessible
+		/// via the HTTP protocol. If a redirection to
+		/// a non http://... URI is received, a 
+		/// UnsupportedRedirectException exception is thrown.
+		/// The offending URI can then be obtained via the message()
+		/// method of UnsupportedRedirectException.
+		
+	static void registerFactory();
+		/// Registers the HTTPStreamFactory with the
+		/// default URIStreamOpener instance.	
+
+	static void unregisterFactory();
+		/// Unregisters the HTTPStreamFactory with the
+		/// default URIStreamOpener instance.	
+		
+private:
+	enum
+	{
+		MAX_REDIRECTS = 10
+	};
+	
+	std::string  _proxyHost;
+	Poco::UInt16 _proxyPort;
+	std::string  _proxyUsername;
+	std::string  _proxyPassword;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPStreamFactory_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/HostEntry.h b/base/poco/Net/include/Poco/Net/HostEntry.h
new file mode 100644
index 00000000000..23cccdffb52
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/HostEntry.h
@@ -0,0 +1,115 @@
+//
+// HostEntry.h
+//
+// Library: Net
+// Package: NetCore
+// Module:  HostEntry
+//
+// Definition of the HostEntry class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HostEntry_INCLUDED
+#define Net_HostEntry_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/SocketDefs.h"
+#include "Poco/Net/IPAddress.h"
+#include <vector>
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API HostEntry
+	/// This class stores information about a host
+	/// such as host name, alias names and a list
+	/// of IP addresses.
+{
+public:
+	typedef std::vector<std::string> AliasList;
+	typedef std::vector<IPAddress>   AddressList;
+	
+	HostEntry();
+		/// Creates an empty HostEntry.
+		
+	HostEntry(struct hostent* entry);
+		/// Creates the HostEntry from the data in a hostent structure.
+
+#if defined(POCO_HAVE_IPv6) || defined(POCO_HAVE_ADDRINFO)
+	HostEntry(struct addrinfo* info);
+		/// Creates the HostEntry from the data in an addrinfo structure.
+#endif
+
+#if defined(POCO_VXWORKS)
+	HostEntry(const std::string& name, const IPAddress& addr);
+#endif
+
+	HostEntry(const HostEntry& entry);
+		/// Creates the HostEntry by copying another one.
+
+	HostEntry& operator = (const HostEntry& entry);
+		/// Assigns another HostEntry.
+
+	void swap(HostEntry& hostEntry);
+		/// Swaps the HostEntry with another one.	
+
+	~HostEntry();
+		/// Destroys the HostEntry.
+
+	const std::string& name() const;
+		/// Returns the canonical host name.
+
+	const AliasList& aliases() const;
+		/// Returns a vector containing alias names for
+		/// the host name.
+
+	const AddressList& addresses() const;
+		/// Returns a vector containing the IPAddresses
+		/// for the host.
+
+private:
+	std::string _name;
+	AliasList   _aliases;
+	AddressList _addresses;
+};
+
+
+//
+// inlines
+//
+inline const std::string& HostEntry::name() const
+{
+	return _name;
+}
+
+
+inline const HostEntry::AliasList& HostEntry::aliases() const
+{
+	return _aliases;
+}
+
+
+inline const HostEntry::AddressList& HostEntry::addresses() const
+{
+	return _addresses;
+}
+
+
+inline void swap(HostEntry& h1, HostEntry& h2)
+{
+	h1.swap(h2);
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HostEntry_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/ICMPClient.h b/base/poco/Net/include/Poco/Net/ICMPClient.h
new file mode 100644
index 00000000000..31fb5202af0
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/ICMPClient.h
@@ -0,0 +1,97 @@
+//
+// ICMPClient.h
+//
+// Library: Net
+// Package: ICMP
+// Module:  ICMPClient
+//
+// Definition of the ICMPClient class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_ICMPClient_INCLUDED
+#define Net_ICMPClient_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/ICMPSocket.h"
+#include "Poco/Net/ICMPEventArgs.h"
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/BasicEvent.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API ICMPClient
+	/// This class provides ICMP Ping functionality.
+	///
+	/// The events are available when class is instantiated
+	///	and non-static member functions are called.
+	/// 
+	///	A "lightweight" alternative is direct (without instantiation)
+	///	use of static member functions.
+{
+public:
+	mutable Poco::BasicEvent<ICMPEventArgs> pingBegin;
+	mutable Poco::BasicEvent<ICMPEventArgs> pingReply;
+	mutable Poco::BasicEvent<ICMPEventArgs> pingError;
+	mutable Poco::BasicEvent<ICMPEventArgs> pingEnd;
+
+	explicit ICMPClient(SocketAddress::Family family, int dataSize = 48, int ttl = 128, int timeout = 50000);
+		/// Creates an ICMP client.
+
+	~ICMPClient();
+		/// Destroys the ICMP client.
+
+	int ping(SocketAddress& address, int repeat = 1) const;
+		/// Pings the specified address [repeat] times.
+		/// Notifications are posted for events.
+		/// 
+		/// Returns the number of valid replies.
+
+	int ping(const std::string& address, int repeat = 1) const;
+		/// Calls ICMPClient::ping(SocketAddress&, int) and
+		/// returns the result.
+		/// 
+		/// Returns the number of valid replies.
+
+	static int ping(SocketAddress& address,
+		SocketAddress::Family family,
+		int repeat = 1,
+		int dataSize = 48,
+		int ttl = 128,
+		int timeout = 50000);
+		/// Pings the specified address [repeat] times.
+		/// Notifications are not posted for events.
+		/// 
+		/// Returns the number of valid replies.
+
+	static int pingIPv4(const std::string& address,
+		int repeat = 1,
+		int dataSize = 48,
+		int ttl = 128,
+		int timeout = 50000);
+		/// Calls ICMPClient::ping(SocketAddress&, int) and
+		/// returns the result.
+		/// 
+		/// Returns the number of valid replies.
+
+private:
+	mutable SocketAddress::Family _family;
+	int _dataSize;
+	int _ttl;
+	int _timeout;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_ICMPClient_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/ICMPEventArgs.h b/base/poco/Net/include/Poco/Net/ICMPEventArgs.h
new file mode 100644
index 00000000000..2a663eb32f8
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/ICMPEventArgs.h
@@ -0,0 +1,163 @@
+//
+// ICMPEventArgs.h
+//
+// Library: Net
+// Package: ICMP
+// Module:  ICMPEventArgs
+//
+// Definition of ICMPEventArgs.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_ICMPEventArgs_INCLUDED
+#define Net_ICMPEventArgs_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/SocketAddress.h"
+#include <vector>
+#include <algorithm>
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API ICMPEventArgs
+	/// The purpose of the ICMPEventArgs class is to be used as template parameter
+	/// to instantiate event members in ICMPClient class.
+	/// When clients register for an event notification, the reference to the class is 
+	///	passed to the handler function to provide information about the event.
+{
+public:
+	ICMPEventArgs(const SocketAddress& address, int repetitions, int dataSize, int ttl);
+		/// Creates ICMPEventArgs.
+
+	virtual ~ICMPEventArgs();
+		/// Destroys ICMPEventArgs.
+
+	std::string hostName() const;
+		/// Tries to resolve the target IP address into host name.
+		/// If unsuccessful, all exceptions are silently ignored and 
+		///	the IP address is returned.
+
+	std::string hostAddress() const;
+		/// Returns the target IP address.
+
+	int repetitions() const;
+		/// Returns the number of repetitions for the ping operation.
+
+	int dataSize() const;
+		/// Returns the packet data size in bytes.
+
+	int ttl() const;
+		/// Returns time to live.
+
+	int sent() const;
+		/// Returns the number of packets sent.
+
+	int received() const;
+		/// Returns the number of packets received.
+
+	int replyTime(int index = -1) const;
+		/// Returns the reply time for the request specified with index.
+		/// If index == -1 (default), returns the most recent reply time.
+
+	const std::string& error(int index = -1) const;
+		/// Returns the error string for the request specified with index.
+		/// If index == -1 (default), returns the most recent error string.
+
+	int minRTT() const;
+		/// Returns the minimum round trip time for a sequence of requests.
+
+	int maxRTT() const;
+		/// Returns the maximum round trip time for a sequence of requests.
+
+	int avgRTT() const;
+		/// Returns the average round trip time for a sequence of requests.
+
+	float percent() const;
+		/// Returns the success percentage for a sequence of requests.
+
+private:
+	ICMPEventArgs();
+
+	void setRepetitions(int repetitions);
+	void setDataSize(int sz);
+	void setTTL(int timeToLive);
+	void setReplyTime(int index, int time);
+	void setError(int index, const std::string& text);
+	ICMPEventArgs& operator ++ ();
+	ICMPEventArgs operator ++ (int);
+
+	SocketAddress _address;
+	int _sent;
+	int _dataSize;
+	int _ttl;
+	std::vector<int> _rtt;
+	std::vector<std::string> _errors;
+
+	friend class ICMPClient;
+};
+
+
+//
+// inlines
+//
+inline int ICMPEventArgs::repetitions() const
+{
+	return (int) _rtt.size();
+}
+
+
+inline void ICMPEventArgs::setDataSize(int sz)
+{
+	_dataSize = sz;
+}
+
+
+inline int ICMPEventArgs::dataSize() const
+{
+	return _dataSize;
+}
+
+
+inline void ICMPEventArgs::setTTL(int timeToLive)
+{
+	_ttl = timeToLive;
+}
+
+
+inline int ICMPEventArgs::ttl() const
+{
+	return _ttl;
+}
+
+
+inline int ICMPEventArgs::sent() const
+{
+	return _sent;
+}
+
+
+inline int ICMPEventArgs::minRTT() const
+{
+	return *std::min_element(_rtt.begin(), _rtt.end());
+}
+
+
+inline int ICMPEventArgs::maxRTT() const
+{
+	return *std::max_element(_rtt.begin(), _rtt.end());
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif
diff --git a/base/poco/Net/include/Poco/Net/ICMPPacket.h b/base/poco/Net/include/Poco/Net/ICMPPacket.h
new file mode 100644
index 00000000000..52d0e87f878
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/ICMPPacket.h
@@ -0,0 +1,89 @@
+//
+// ICMPPacket.h
+//
+// Library: Net
+// Package: ICMP
+// Module:  ICMPPacket
+//
+// Definition of the ICMPPacket class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_ICMPPacket_INCLUDED
+#define Net_ICMPPacket_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Net/Socket.h"
+#include "Poco/Net/ICMPPacketImpl.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API ICMPPacket
+	/// This class is the ICMP packet abstraction. 
+{
+public:
+	ICMPPacket(SocketAddress::Family family, int dataSize = 48);
+		/// Creates an ICMPPacket of specified family.
+
+	~ICMPPacket();
+		/// Destroys the ICMPPacket.
+
+	const Poco::UInt8* packet();
+		/// Returns raw ICMP packet. ICMP header and data are included in the returned packet.
+
+	int packetSize() const;
+		/// Returns the total length of packet (header + data);
+
+	Poco::UInt16 sequence() const;
+		/// Returns the most recent sequence number generated.
+
+	void setDataSize(int dataSize);
+		/// Sets data size.
+
+	int getDataSize() const;
+		/// Returns data size.
+
+	int maxPacketSize() const;
+		/// Returns the total length of packet (header + data);
+
+	struct timeval time(Poco::UInt8* buffer = 0, int length = 0) const;
+		/// Returns current epoch time if either buffer or length are equal to zero.
+		/// Otherwise, it extracts the time value from the supplied buffer and 
+		/// returns the extracted value.
+		/// 
+		/// Supplied buffer includes IP header, ICMP header and data.
+
+	bool validReplyID(Poco::UInt8* buffer, int length) const;
+		/// Returns true if the extracted id is recognized 
+		/// (equals the process id).
+		///	
+		/// Supplied buffer includes IP header, ICMP header and data.
+
+	std::string errorDescription(Poco::UInt8* buffer, int length);
+		/// Returns error description string.
+		/// If supplied buffer contains an ICMP echo reply packet, an
+		/// empty string is returned indicating the absence of error.
+		///	
+		/// Supplied buffer includes IP header, ICMP header and data.
+
+	std::string typeDescription(int typeId);
+		/// Returns the description of the packet type.
+
+private:
+	ICMPPacketImpl* _pImpl;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_ICMPPacket_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/ICMPPacketImpl.h b/base/poco/Net/include/Poco/Net/ICMPPacketImpl.h
new file mode 100644
index 00000000000..da6bf464841
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/ICMPPacketImpl.h
@@ -0,0 +1,141 @@
+//
+// ICMPPacketImpl.h
+//
+// Library: Net
+// Package: ICMP
+// Module:  ICMPPacketImpl
+//
+// Definition of the ICMPPacketImpl class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_ICMPPacketImpl_INCLUDED
+#define Net_ICMPPacketImpl_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Net/Socket.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API ICMPPacketImpl
+	/// This is the abstract class for ICMP packet implementations.
+{
+public:
+	ICMPPacketImpl(int dataSize = 48);
+		/// Constructor. Creates an ICMPPacketImpl.
+
+	virtual ~ICMPPacketImpl();
+		/// Destructor.
+
+	const Poco::UInt8* packet(bool init = true);
+		/// Returns raw ICMP packet.
+		/// ICMP header and data are included in the packet.
+		/// If init is true, initPacket() is called.
+
+	virtual int packetSize() const = 0;
+		/// Returns the total size of packet (ICMP header + data) in number of octets.
+		/// Must be overriden.
+
+	virtual int maxPacketSize() const;
+		/// Returns the maximum permitted size of packet in number of octets.
+
+	Poco::UInt16 sequence() const;
+		/// Returns the most recent sequence number generated.
+
+	void setDataSize(int dataSize);
+		/// Sets data size.
+
+	int getDataSize() const;
+		/// Returns data size.
+
+	virtual struct timeval time(Poco::UInt8* buffer = 0, int length = 0) const = 0;
+		/// Returns current epoch time if either argument is equal to zero.
+		/// Otherwise, it extracts the time value from the supplied buffer.
+		/// 
+		/// Supplied buffer includes IP header, ICMP header and data.
+		/// Must be overriden.
+
+	virtual bool validReplyID(unsigned char* buffer, int length) const = 0;
+		/// Returns true if the extracted id is recognized 
+		/// (i.e. equals the process id).
+		///	
+		/// Supplied buffer includes IP header, ICMP header and data.
+		/// Must be overriden.
+
+	virtual std::string errorDescription(Poco::UInt8* buffer, int length) = 0;
+		/// Returns error description string.
+		/// If supplied buffer contains an ICMP echo reply packet, an
+		/// empty string is returned indicating the absence of error.
+		///	
+		/// Supplied buffer includes IP header, ICMP header and data.
+		/// Must be overriden.
+
+	virtual std::string typeDescription(int typeId) = 0;
+		/// Returns the description of the packet type.
+		/// Must be overriden.
+
+	static const Poco::UInt16 MAX_PACKET_SIZE;
+	static const Poco::UInt16 MAX_SEQ_VALUE;
+
+protected:
+	Poco::UInt16 nextSequence();
+		/// Increments sequence number and returns the new value.
+
+	void resetSequence();
+		/// Resets the sequence to zero.
+
+	virtual void initPacket() = 0;
+		/// (Re)assembles the packet.
+		/// Must be overriden.
+
+	Poco::UInt16 checksum(Poco::UInt16 *addr, Poco::Int32 len);
+		/// Calculates the checksum for supplied buffer.
+
+private:
+	Poco::UInt16 _seq;
+	Poco::UInt8* _pPacket;
+	int _dataSize;
+	
+};
+
+
+//
+// inlines
+//
+inline Poco::UInt16 ICMPPacketImpl::sequence() const
+{
+	return _seq;
+}
+
+
+inline Poco::UInt16 ICMPPacketImpl::nextSequence()
+{
+	return ++_seq;
+}
+
+
+inline void ICMPPacketImpl::resetSequence()
+{
+	_seq = 0;
+}
+
+
+inline int ICMPPacketImpl::maxPacketSize() const
+{
+	return MAX_PACKET_SIZE;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_ICMPPacketImpl_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/ICMPSocket.h b/base/poco/Net/include/Poco/Net/ICMPSocket.h
new file mode 100644
index 00000000000..75e049b3829
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/ICMPSocket.h
@@ -0,0 +1,91 @@
+//
+// ICMPSocket.h
+//
+// Library: Net
+// Package: ICMP
+// Module:  ICMPSocket
+//
+// Definition of the ICMPSocket class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_ICMPSocket_INCLUDED
+#define Net_ICMPSocket_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/Socket.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API ICMPSocket: public Socket
+	/// This class provides an interface to an
+	/// ICMP client socket.
+{
+public:
+	ICMPSocket(SocketAddress::Family family, int dataSize = 48, int ttl = 128, int timeout = 5000000);
+		/// Creates an unconnected ICMP socket.
+		///
+		/// The socket will be created for the
+		/// given address family.
+
+	ICMPSocket(const Socket& socket);
+		/// Creates the ICMPSocket with the SocketImpl
+		/// from another socket. The SocketImpl must be
+		/// a ICMPSocketImpl, otherwise an InvalidArgumentException
+		/// will be thrown.
+
+	~ICMPSocket();
+		/// Destroys the ICMPSocket.
+
+	ICMPSocket& operator = (const Socket& socket);
+		/// Assignment operator.
+		///
+		/// Releases the socket's SocketImpl and
+		/// attaches the SocketImpl from the other socket and
+		/// increments the reference count of the SocketImpl.	
+
+	int sendTo(const SocketAddress& address, int flags = 0);
+		/// Sends an ICMP request through
+		/// the socket to the given address.
+		///
+		/// Returns the number of bytes sent.
+
+	int receiveFrom(SocketAddress& address, int flags = 0);
+		/// Receives data from the socket.
+		/// Stores the address of the sender in address.
+		///
+		/// Returns the time elapsed since the originating 
+		/// request was sent.
+
+	int dataSize() const;
+		/// Returns the data size in bytes.
+
+	int ttl() const;
+		/// Returns the Time-To-Live value.
+
+	int timeout() const;
+		/// Returns the socket timeout value.
+
+protected:
+	ICMPSocket(SocketImpl* pImpl);
+		/// Creates the Socket and attaches the given SocketImpl.
+		/// The socket takes ownership of the SocketImpl.
+		///
+		/// The SocketImpl must be a ICMPSocketImpl, otherwise
+		/// an InvalidArgumentException will be thrown.
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_ICMPSocket_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/ICMPSocketImpl.h b/base/poco/Net/include/Poco/Net/ICMPSocketImpl.h
new file mode 100644
index 00000000000..98ba9a22592
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/ICMPSocketImpl.h
@@ -0,0 +1,94 @@
+//
+// ICMPSocketImpl.h
+//
+// Library: Net
+// Package: ICMP
+// Module:  ICMPSocketImpl
+//
+// Definition of the ICMPSocketImpl class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_ICMPSocketImpl_INCLUDED
+#define Net_ICMPSocketImpl_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/RawSocketImpl.h"
+#include "Poco/Net/ICMPPacket.h"
+#include "Poco/Timestamp.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API ICMPSocketImpl: public RawSocketImpl
+	/// This class implements an ICMP socket.
+{
+public:
+	ICMPSocketImpl(SocketAddress::Family family, int dataSize, int ttl, int timeout);
+		/// Creates an unconnected ICMP socket.
+		///
+		/// The socket will be created for the given address family.
+
+	int sendTo(const void*, int, const SocketAddress& address, int flags = 0);
+		/// Sends an ICMP request through the socket to the given address.
+		///
+		/// Returns the number of bytes sent.
+	
+	int receiveFrom(void*, int, SocketAddress& address, int flags = 0);
+		/// Receives data from the socket.
+		/// Stores the address of the sender in address.
+		///
+		/// Returns the time elapsed since the originating request was sent.
+
+	int dataSize() const;
+		/// Returns the data size in bytes.
+
+	int ttl() const;
+		/// Returns the Time-To-Live value.
+
+	int timeout() const;
+		/// Returns the socket timeout value.
+
+protected:
+	~ICMPSocketImpl();
+
+private:
+	ICMPPacket _icmpPacket;
+	int _ttl;
+	int _timeout;
+};
+
+
+//
+// inlines
+//
+inline int ICMPSocketImpl::dataSize() const
+{
+	return _icmpPacket.getDataSize();
+}
+
+
+inline int ICMPSocketImpl::ttl() const
+{
+	return _ttl;
+}
+
+
+inline int ICMPSocketImpl::timeout() const
+{
+	return _timeout;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_ICMPSocketImpl_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/ICMPv4PacketImpl.h b/base/poco/Net/include/Poco/Net/ICMPv4PacketImpl.h
new file mode 100644
index 00000000000..116f8c76174
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/ICMPv4PacketImpl.h
@@ -0,0 +1,173 @@
+//
+// ICMPv4PacketImpl.h
+//
+// Library: Net
+// Package: ICMP
+// Module:  ICMPv4PacketImpl
+//
+// Definition of the ICMPv4PacketImpl class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_ICMPv4PacketImpl_INCLUDED
+#define Net_ICMPv4PacketImpl_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Net/Socket.h"
+#include "Poco/Net/ICMPPacketImpl.h"
+#include <cstddef>
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API ICMPv4PacketImpl : public ICMPPacketImpl
+	/// This class implements the ICMPv4 packet.
+	/// Parts are based on original ICMP code by
+	/// Mike Muuss
+	/// U. S. Army Ballistic Research Laboratory
+ 	/// December, 1983
+{
+public:
+	// ICMPv4 header
+	struct Header
+	{
+		Poco::UInt8 type;          // ICMP packet type
+		Poco::UInt8 code;          // Type sub code
+		Poco::UInt16 checksum;
+		Poco::UInt16 id;
+		Poco::UInt16 seq;
+	};
+
+	// compile-time shield against misalignment
+#if POCO_OS != POCO_OS_ANDROID
+	poco_static_assert (offsetof(Header, code) == 0x01);
+	poco_static_assert (offsetof(Header, checksum) == 0x02);
+	poco_static_assert (offsetof(Header, id) == 0x04);
+	poco_static_assert (offsetof(Header, seq) == 0x06);
+#endif
+
+	enum MessageType
+	{
+		ECHO_REPLY,
+		ICMP_1,
+		ICMP_2,
+		DESTINATION_UNREACHABLE,
+		SOURCE_QUENCH,
+		REDIRECT,
+		ICMP_6,
+		ICMP_7,
+		ECHO_REQUEST,
+		ICMP_9,
+		ICMP_10,
+		TIME_EXCEEDED,
+		PARAMETER_PROBLEM,
+		TIMESTAMP_REQUEST,
+		TIMESTAMP_REPLY,
+		INFORMATION_REQUEST,
+		INFORMATION_REPLY,
+		MESSAGE_TYPE_UNKNOWN,  // non-standard default, must remain last but one
+		MESSAGE_TYPE_LENGTH    // length indicator, must remain last
+	};
+
+	enum DestinationUnreachableCode
+	{
+		NET_UNREACHABLE,
+		HOST_UNREACHABLE,
+		PROTOCOL_UNREACHABLE,
+		PORT_UNREACHABLE,
+		FRAGMENTATION_NEEDED_AND_DF_SET,
+		SOURCE_ROUTE_FAILED,
+		DESTINATION_UNREACHABLE_UNKNOWN, // non-standard default, must remain last but one
+		DESTINATION_UNREACHABLE_LENGTH   // length indicator, must remain last
+	};
+
+	enum RedirectMessageCode
+	{
+		REDIRECT_NETWORK,
+		REDIRECT_HOST,
+		REDIRECT_SERVICE_NETWORK,
+		REDIRECT_SERVICE_HOST,
+		REDIRECT_MESSAGE_UNKNOWN, // non-standard default, must remain last but one
+		REDIRECT_MESSAGE_LENGTH   // length indicator, must remain last
+	};
+
+	enum TimeExceededCode
+	{
+		TIME_TO_LIVE,
+		FRAGMENT_REASSEMBLY,
+		TIME_EXCEEDED_UNKNOWN, // non-standard default, must remain last but one
+		TIME_EXCEEDED_LENGTH   // length indicator, must remain last
+	};
+
+	enum ParameterProblemCode
+	{
+		POINTER_INDICATES_THE_ERROR,
+		PARAMETER_PROBLEM_UNKNOWN, // non-standard default, must remain last but one
+		PARAMETER_PROBLEM_LENGTH   // length indicator, must remain last
+	};
+
+	ICMPv4PacketImpl(int dataSize = 48);
+		/// Constructor. Creates an ICMPv4PacketImpl.
+
+	~ICMPv4PacketImpl();
+		/// Destructor.
+
+	int packetSize() const;
+		/// Returns the total length of packet (header + data);
+
+	struct timeval time(Poco::UInt8* buffer = 0, int length = 0) const;
+		/// Returns current epoch time if either buffer or length are equal to zero.
+		/// Otherwise, it extracts the time value from the supplied buffer.
+		///
+		/// Buffer includes IP header, ICMP header and data.
+
+	bool validReplyID(Poco::UInt8* buffer, int length) const;
+		/// Returns true if the extracted id is recognized
+		/// (i.e. equals the process id).
+		///
+		/// Buffer includes IP header, ICMP header and data.
+
+	virtual std::string errorDescription(Poco::UInt8* buffer, int length);
+		/// Returns error description string.
+		/// If supplied buffer contains ICMPv4 echo reply packet, an
+		/// empty string is returned indicating the absence of error.
+		///
+		/// Buffer includes IP header, ICMP header and data.
+
+	virtual std::string typeDescription(int typeId);
+		/// Returns the description of the packet type.
+
+	static const Poco::UInt16 MAX_PACKET_SIZE;
+	static const std::string MESSAGE_TYPE[MESSAGE_TYPE_LENGTH];
+	static const Poco::UInt8 DESTINATION_UNREACHABLE_TYPE; // 3
+	static const Poco::UInt8 SOURCE_QUENCH_TYPE;           // 4
+	static const Poco::UInt8 REDIRECT_MESSAGE_TYPE;        // 5
+	static const Poco::UInt8 TIME_EXCEEDED_TYPE;           // 11
+	static const Poco::UInt8 PARAMETER_PROBLEM_TYPE;       // 12
+
+private:
+	void initPacket();
+	Header* header(Poco::UInt8* buffer, int length) const;
+	Poco::UInt8* data(Poco::UInt8* buffer, int length) const;
+
+	static const std::string DESTINATION_UNREACHABLE_CODE[DESTINATION_UNREACHABLE_LENGTH];
+	static const std::string REDIRECT_MESSAGE_CODE[REDIRECT_MESSAGE_LENGTH];
+	static const std::string TIME_EXCEEDED_CODE[TIME_EXCEEDED_LENGTH];
+	static const std::string PARAMETER_PROBLEM_CODE[PARAMETER_PROBLEM_LENGTH];
+
+	Poco::UInt16 _seq;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_ICMPv4PacketImpl_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/IPAddress.h b/base/poco/Net/include/Poco/Net/IPAddress.h
new file mode 100644
index 00000000000..7d9cb6fa836
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/IPAddress.h
@@ -0,0 +1,450 @@
+//
+// IPAddress.h
+//
+// Library: Net
+// Package: NetCore
+// Module:  IPAddress
+//
+// Definition of the IPAddress class.
+//
+// Copyright (c) 2005-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_IPAddress_INCLUDED
+#define Net_IPAddress_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/SocketDefs.h"
+#include "Poco/Net/IPAddressImpl.h"
+#include "Poco/AutoPtr.h"
+#include "Poco/Exception.h"
+#include <vector>
+#include <ostream>
+
+
+namespace Poco {
+
+class BinaryReader;
+class BinaryWriter;
+
+namespace Net {
+
+
+class Net_API IPAddress
+	/// This class represents an internet (IP) host
+	/// address. The address can belong either to the
+	/// IPv4 or the IPv6 address family.
+	///
+	/// Relational operators (==, !=, <, <=, >, >=) are
+	/// supported. However, you must not interpret any
+	/// special meaning into the result of these 
+	/// operations, other than that the results are
+	/// consistent.
+	///
+	/// Especially, an IPv4 address is never equal to
+	/// an IPv6 address, even if the IPv6 address is
+	/// IPv4 compatible and the addresses are the same.
+	///
+	/// IPv6 addresses are supported only if the target platform
+	/// supports IPv6.
+{
+public:
+	typedef std::vector<IPAddress> List;
+
+	// The following declarations keep the Family type
+	// backwards compatible with the previously used
+	// enum declaration.
+	typedef AddressFamily::Family Family;
+	static const Family IPv4 = AddressFamily::IPv4;
+#if defined(POCO_HAVE_IPv6)
+	static const Family IPv6 = AddressFamily::IPv6;
+#endif
+	
+	IPAddress();
+		/// Creates a wildcard (zero) IPv4 IPAddress.
+
+	IPAddress(const IPAddress& addr);
+		/// Creates an IPAddress by copying another one.
+
+	explicit IPAddress(Family family);
+		/// Creates a wildcard (zero) IPAddress for the
+		/// given address family.
+
+	explicit IPAddress(const std::string& addr);
+		/// Creates an IPAddress from the string containing
+		/// an IP address in presentation format (dotted decimal
+		/// for IPv4, hex string for IPv6).
+		/// 
+		/// Depending on the format of addr, either an IPv4 or
+		/// an IPv6 address is created.
+		///
+		/// See toString() for details on the supported formats.
+		///
+		/// Throws an InvalidAddressException if the address cannot be parsed.
+
+	IPAddress(const std::string& addr, Family family);
+		/// Creates an IPAddress from the string containing
+		/// an IP address in presentation format (dotted decimal
+		/// for IPv4, hex string for IPv6).
+
+	IPAddress(const void* addr, poco_socklen_t length);
+		/// Creates an IPAddress from a native internet address.
+		/// A pointer to a in_addr or a in6_addr structure may be 
+		/// passed.
+
+	IPAddress(const void* addr, poco_socklen_t length, Poco::UInt32 scope);
+		/// Creates an IPAddress from a native internet address.
+		/// A pointer to a in_addr or a in6_addr structure may be 
+		/// passed. Additionally, for an IPv6 address, a scope ID
+		/// may be specified. The scope ID will be ignored if an IPv4
+		/// address is specified.
+
+	IPAddress(unsigned prefix, Family family);
+			/// Creates an IPAddress mask with the given length of prefix.
+
+#if defined(_WIN32)
+	IPAddress(const SOCKET_ADDRESS& socket_address);
+			/// Creates an IPAddress from Windows SOCKET_ADDRESS structure.
+#endif
+
+	IPAddress(const struct sockaddr& sockaddr);
+		/// Same for struct sock_addr on POSIX.
+
+
+	~IPAddress();
+		/// Destroys the IPAddress.
+
+	IPAddress& operator = (const IPAddress& addr);
+		/// Assigns an IPAddress.
+		
+	Family family() const;
+		/// Returns the address family (IPv4 or IPv6) of the address.
+
+	Poco::UInt32 scope() const;
+		/// Returns the IPv6 scope identifier of the address. Returns 0 if
+		/// the address is an IPv4 address, or the address is an
+		/// IPv6 address but does not have a scope identifier.
+
+	std::string toString() const;
+		/// Returns a string containing a representation of the address
+		/// in presentation format.
+		///
+		/// For IPv4 addresses the result will be in dotted-decimal
+		/// (d.d.d.d) notation.
+		///
+		/// Textual representation of IPv6 address is one of the following forms:
+		///
+		/// The preferred form is x:x:x:x:x:x:x:x, where the 'x's are the hexadecimal 
+		/// values of the eight 16-bit pieces of the address. This is the full form.
+		/// Example: 1080:0:0:0:8:600:200A:425C
+		///
+		/// It is not necessary to write the leading zeros in an individual field. 
+		/// However, there must be at least one numeral in every field, except as described below.
+		/// 
+		/// It is common for IPv6 addresses to contain long strings of zero bits. 
+		/// In order to make writing addresses containing zero bits easier, a special syntax is 
+		/// available to compress the zeros. The use of "::" indicates multiple groups of 16-bits of zeros. 
+		/// The "::" can only appear once in an address. The "::" can also be used to compress the leading 
+		/// and/or trailing zeros in an address. Example: 1080::8:600:200A:425C
+		///
+		/// For dealing with IPv4 compatible addresses in a mixed environment,
+		/// a special syntax is available: x:x:x:x:x:x:d.d.d.d, where the 'x's are the 
+		/// hexadecimal values of the six high-order 16-bit pieces of the address, 
+		/// and the 'd's are the decimal values of the four low-order 8-bit pieces of the 
+		/// standard IPv4 representation address. Example: ::FFFF:192.168.1.120
+		///
+		/// If an IPv6 address contains a non-zero scope identifier, it is added
+		/// to the string, delimited by a percent character. On Windows platforms,
+		/// the numeric value (which specifies an interface index) is directly
+		/// appended. On Unix platforms, the name of the interface corresponding
+		/// to the index (interpretation of the scope identifier) is added.
+	
+	bool isWildcard() const;
+		/// Returns true iff the address is a wildcard (all zero)
+		/// address.
+		
+	bool isBroadcast() const;
+		/// Returns true iff the address is a broadcast address.
+		///
+		/// Only IPv4 addresses can be broadcast addresses. In a broadcast
+		/// address, all bits are one.
+		///
+		/// For an IPv6 address, returns always false.
+	
+	bool isLoopback() const;
+		/// Returns true iff the address is a loopback address.
+		///
+		/// For IPv4, the loopback address is 127.0.0.1.
+		///
+		/// For IPv6, the loopback address is ::1.
+	
+	bool isMulticast() const;
+		/// Returns true iff the address is a multicast address.
+		///
+		/// IPv4 multicast addresses are in the
+		/// 224.0.0.0 to 239.255.255.255 range
+		/// (the first four bits have the value 1110).
+		///
+		/// IPv6 multicast addresses are in the
+		/// FFxx:x:x:x:x:x:x:x range.
+		
+	bool isUnicast() const;
+		/// Returns true iff the address is a unicast address.
+		///
+		/// An address is unicast if it is neither a wildcard,
+		/// broadcast or multicast address.
+		
+	bool isLinkLocal() const;
+		/// Returns true iff the address is a link local unicast address.
+		///
+		/// IPv4 link local addresses are in the 169.254.0.0/16 range,
+		/// according to RFC 3927.
+		///
+		/// IPv6 link local addresses have 1111 1110 10 as the first
+		/// 10 bits, followed by 54 zeros.
+		
+	bool isSiteLocal() const;
+		/// Returns true iff the address is a site local unicast address.
+		///
+		/// IPv4 site local addresses are in on of the 10.0.0.0/24,
+		/// 192.168.0.0/16 or 172.16.0.0 to 172.31.255.255 ranges.
+		///
+		/// Originally, IPv6 site-local addresses had FEC0/10 (1111 1110 11) 
+		/// prefix (RFC 4291), followed by 38 zeros. Interfaces using  
+		/// this mask are supported, but obsolete; RFC 4193 prescribes
+		/// fc00::/7 (1111 110) as local unicast prefix.
+		
+	bool isIPv4Compatible() const;
+		/// Returns true iff the address is IPv4 compatible.
+		///
+		/// For IPv4 addresses, this is always true.
+		///
+		/// For IPv6, the address must be in the ::x:x range (the
+		/// first 96 bits are zero).
+
+	bool isIPv4Mapped() const;
+		/// Returns true iff the address is an IPv4 mapped IPv6 address.
+		///
+		/// For IPv4 addresses, this is always true.
+		///
+		/// For IPv6, the address must be in the ::FFFF:x:x range.
+	
+	bool isWellKnownMC() const;
+		/// Returns true iff the address is a well-known multicast address.
+		///
+		/// For IPv4, well-known multicast addresses are in the 
+		/// 224.0.0.0/8 range.
+		///
+		/// For IPv6, well-known multicast addresses are in the 
+		/// FF0x:x:x:x:x:x:x:x range.
+	
+	bool isNodeLocalMC() const;
+		/// Returns true iff the address is a node-local multicast address.
+		///
+		/// IPv4 does not support node-local addresses, thus the result is
+		/// always false for an IPv4 address.
+		///
+		/// For IPv6, node-local multicast addresses are in the
+		/// FFx1:x:x:x:x:x:x:x range.
+	
+	bool isLinkLocalMC() const;
+		/// Returns true iff the address is a link-local multicast address.
+		///
+		/// For IPv4, link-local multicast addresses are in the
+		/// 224.0.0.0/24 range. Note that this overlaps with the range for well-known
+		/// multicast addresses.
+		///
+		/// For IPv6, link-local multicast addresses are in the
+		/// FFx2:x:x:x:x:x:x:x range.
+
+	bool isSiteLocalMC() const;
+		/// Returns true iff the address is a site-local multicast address.
+		///
+		/// For IPv4, site local multicast addresses are in the
+		/// 239.255.0.0/16 range.
+		///
+		/// For IPv6, site-local multicast addresses are in the
+		/// FFx5:x:x:x:x:x:x:x range.
+
+	bool isOrgLocalMC() const;
+		/// Returns true iff the address is a organization-local multicast address.
+		///
+		/// For IPv4, organization-local multicast addresses are in the
+		/// 239.192.0.0/16 range.
+		///
+		/// For IPv6, organization-local multicast addresses are in the
+		/// FFx8:x:x:x:x:x:x:x range.
+
+	bool isGlobalMC() const;
+		/// Returns true iff the address is a global multicast address.
+		///
+		/// For IPv4, global multicast addresses are in the 
+		/// 224.0.1.0 to 238.255.255.255 range.
+		///
+		/// For IPv6, global multicast addresses are in the
+		/// FFxF:x:x:x:x:x:x:x range.
+	
+	bool operator == (const IPAddress& addr) const;	
+	bool operator != (const IPAddress& addr) const;
+	bool operator <  (const IPAddress& addr) const;
+	bool operator <= (const IPAddress& addr) const;
+	bool operator >  (const IPAddress& addr) const;
+	bool operator >= (const IPAddress& addr) const;
+	IPAddress operator & (const IPAddress& addr) const;
+	IPAddress operator | (const IPAddress& addr) const;
+	IPAddress operator ^ (const IPAddress& addr) const;
+	IPAddress operator ~ () const;
+		
+	poco_socklen_t length() const;
+		/// Returns the length in bytes of the internal socket address structure.	
+		
+	const void* addr() const;
+		/// Returns the internal address structure.
+		
+	int af() const;
+		/// Returns the address family (AF_INET or AF_INET6) of the address.
+
+	unsigned prefixLength() const;
+		/// Returns the prefix length.
+		
+	void mask(const IPAddress& mask);
+		/// Masks the IP address using the given netmask, which is usually
+		/// a IPv4 subnet mask. Only supported for IPv4 addresses.
+		///
+		/// The new address is (address & mask).
+		
+	void mask(const IPAddress& mask, const IPAddress& set);
+		/// Masks the IP address using the given netmask, which is usually
+		/// a IPv4 subnet mask. Only supported for IPv4 addresses.
+		///
+		/// The new address is (address & mask) | (set & ~mask).
+		
+	static IPAddress parse(const std::string& addr);
+		/// Creates an IPAddress from the string containing
+		/// an IP address in presentation format (dotted decimal
+		/// for IPv4, hex string for IPv6).
+		/// 
+		/// Depending on the format of addr, either an IPv4 or
+		/// an IPv6 address is created.
+		///
+		/// See toString() for details on the supported formats.
+		///
+		/// Throws an InvalidAddressException if the address cannot be parsed.
+
+	static bool tryParse(const std::string& addr, IPAddress& result);
+		/// Tries to interpret the given address string as an
+		/// IP address in presentation format (dotted decimal
+		/// for IPv4, hex string for IPv6).
+		///
+		/// Returns true and stores the IPAddress in result if the
+		/// string contains a valid address.
+		///
+		/// Returns false and leaves result unchanged otherwise.
+
+	static IPAddress wildcard(Family family = IPv4);
+		/// Returns a wildcard IPv4 or IPv6 address (0.0.0.0).
+		
+	static IPAddress broadcast();
+		/// Returns a broadcast IPv4 address (255.255.255.255).
+
+	enum
+	{
+		MAX_ADDRESS_LENGTH = 
+#if defined(POCO_HAVE_IPv6)
+			sizeof(struct in6_addr)
+#else
+			sizeof(struct in_addr)
+#endif
+			/// Maximum length in bytes of a socket address.
+	};
+
+private:
+	typedef Poco::Net::Impl::IPAddressImpl Impl;
+	typedef Poco::AutoPtr<Impl> Ptr;
+
+	Ptr pImpl() const;
+	void newIPv4();
+	void newIPv4(const void* hostAddr);
+	void newIPv4(unsigned prefix);
+#if defined(POCO_HAVE_IPv6)
+	void newIPv6();
+	void newIPv6(const void* hostAddr);
+	void newIPv6(const void* hostAddr, Poco::UInt32 scope);
+	void newIPv6(unsigned prefix);
+#endif
+	Ptr _pImpl;
+};
+
+
+//
+// inlines
+//
+inline IPAddress::Ptr IPAddress::pImpl() const
+{
+	if (_pImpl) return _pImpl;
+	throw NullPointerException("IPaddress implementation pointer is NULL.");
+}
+
+
+inline void IPAddress::newIPv4()
+{
+	_pImpl = new Poco::Net::Impl::IPv4AddressImpl;
+}
+
+
+inline void IPAddress::newIPv4(const void* hostAddr)
+{
+	_pImpl = new Poco::Net::Impl::IPv4AddressImpl(hostAddr);
+}
+
+
+inline void IPAddress::newIPv4(unsigned prefix)
+{
+	_pImpl = new Poco::Net::Impl::IPv4AddressImpl(prefix);
+}
+
+
+#if defined(POCO_HAVE_IPv6)
+
+
+inline void IPAddress::newIPv6()
+{
+	_pImpl = new Poco::Net::Impl::IPv6AddressImpl;
+}
+
+
+inline void IPAddress::newIPv6(const void* hostAddr)
+{
+	_pImpl = new Poco::Net::Impl::IPv6AddressImpl(hostAddr);
+}
+
+
+inline void IPAddress::newIPv6(const void* hostAddr, Poco::UInt32 scope)
+{
+	_pImpl = new Poco::Net::Impl::IPv6AddressImpl(hostAddr, scope);
+}
+
+
+inline void IPAddress::newIPv6(unsigned prefix)
+{
+	_pImpl = new Poco::Net::Impl::IPv6AddressImpl(prefix);
+}
+
+
+#endif // POCO_HAVE_IPv6
+
+
+} } // namespace Poco::Net
+
+
+Net_API Poco::BinaryWriter& operator << (Poco::BinaryWriter& writer, const Poco::Net::IPAddress& value);
+Net_API Poco::BinaryReader& operator >> (Poco::BinaryReader& reader, Poco::Net::IPAddress& value);
+Net_API std::ostream& operator << (std::ostream& ostr, const Poco::Net::IPAddress& addr);
+
+
+#endif // Net_IPAddress_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/IPAddressImpl.h b/base/poco/Net/include/Poco/Net/IPAddressImpl.h
new file mode 100644
index 00000000000..e43d685509f
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/IPAddressImpl.h
@@ -0,0 +1,179 @@
+//
+// IPAddressImpl.h
+//
+// Library: Net
+// Package: NetCore
+// Module:  IPAddressImpl
+//
+// Definition of the IPAddressImpl class.
+//
+// Copyright (c) 2005-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_IPAddressImpl_INCLUDED
+#define Net_IPAddressImpl_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/SocketDefs.h"
+#include "Poco/RefCountedObject.h"
+#include <vector>
+
+
+namespace Poco {
+namespace Net {
+namespace Impl {
+
+
+class IPAddressImpl : public Poco::RefCountedObject
+{
+public:
+	typedef AddressFamily::Family Family;
+	
+	virtual ~IPAddressImpl();
+
+	virtual IPAddressImpl* clone() const = 0;
+	virtual std::string toString() const = 0;
+	virtual poco_socklen_t length() const = 0;
+	virtual const void* addr() const = 0;
+	virtual Family family() const = 0;
+	virtual int af() const = 0;
+	virtual Poco::UInt32 scope() const = 0;
+	virtual bool isWildcard() const	= 0;
+	virtual bool isBroadcast() const = 0;
+	virtual bool isLoopback() const = 0;
+	virtual bool isMulticast() const = 0;
+	virtual bool isLinkLocal() const = 0;
+	virtual bool isSiteLocal() const = 0;
+	virtual bool isIPv4Mapped() const = 0;
+	virtual bool isIPv4Compatible() const = 0;
+	virtual bool isWellKnownMC() const = 0;
+	virtual bool isNodeLocalMC() const = 0;
+	virtual bool isLinkLocalMC() const = 0;
+	virtual bool isSiteLocalMC() const = 0;
+	virtual bool isOrgLocalMC() const = 0;
+	virtual bool isGlobalMC() const = 0;
+	virtual void mask(const IPAddressImpl* pMask, const IPAddressImpl* pSet) = 0;
+	virtual unsigned prefixLength() const = 0;
+
+protected:
+	IPAddressImpl();
+
+private:
+	IPAddressImpl(const IPAddressImpl&);
+	IPAddressImpl& operator = (const IPAddressImpl&);
+};
+
+
+//
+// IPv4AddressImpl
+//
+
+class IPv4AddressImpl: public IPAddressImpl
+{
+public:
+	IPv4AddressImpl();
+	IPv4AddressImpl(const void* addr);
+	IPv4AddressImpl(unsigned prefix);
+	IPv4AddressImpl(const IPv4AddressImpl& addr);
+	IPv4AddressImpl& operator = (const IPv4AddressImpl&);
+	std::string toString() const;
+	poco_socklen_t length() const;
+	const void* addr() const;
+	Family family() const;
+	int af() const;
+	unsigned prefixLength() const;
+	Poco::UInt32 scope() const;
+	bool isWildcard() const;
+	bool isBroadcast() const;
+	bool isLoopback() const;
+	bool isMulticast() const;
+	bool isLinkLocal() const;
+	bool isSiteLocal() const;
+	bool isIPv4Compatible() const;
+	bool isIPv4Mapped() const;
+	bool isWellKnownMC() const;
+	bool isNodeLocalMC() const;
+	bool isLinkLocalMC() const;
+	bool isSiteLocalMC() const;
+	bool isOrgLocalMC() const;
+	bool isGlobalMC() const;
+	static IPv4AddressImpl parse(const std::string& addr);
+	void mask(const IPAddressImpl* pMask, const IPAddressImpl* pSet);
+	IPAddressImpl* clone() const;
+	IPv4AddressImpl operator & (const IPv4AddressImpl& addr) const;
+	IPv4AddressImpl operator | (const IPv4AddressImpl& addr) const;
+	IPv4AddressImpl operator ^ (const IPv4AddressImpl& addr) const;
+	IPv4AddressImpl operator ~ () const;
+	bool operator == (const IPv4AddressImpl& addr) const;
+	bool operator != (const IPv4AddressImpl& addr) const;
+
+private:	
+	struct in_addr _addr;
+};
+
+
+#if defined(POCO_HAVE_IPv6)
+
+
+//
+// IPv6AddressImpl
+//
+
+class IPv6AddressImpl: public IPAddressImpl
+{
+public:
+	IPv6AddressImpl();
+	IPv6AddressImpl(const void* addr);
+	IPv6AddressImpl(const void* addr, Poco::UInt32 scope);
+	IPv6AddressImpl(unsigned prefix);
+	std::string toString() const;
+	poco_socklen_t length() const;
+	const void* addr() const;
+	Family family() const;
+	int af() const;
+	unsigned prefixLength() const;
+	Poco::UInt32 scope() const;
+	bool isWildcard() const;
+	bool isBroadcast() const;
+	bool isLoopback() const;
+	bool isMulticast() const;
+	bool isLinkLocal() const;
+	bool isSiteLocal() const;
+	bool isIPv4Compatible() const;
+	bool isIPv4Mapped() const;
+	bool isWellKnownMC() const;
+	bool isNodeLocalMC() const;
+	bool isLinkLocalMC() const;
+	bool isSiteLocalMC() const;
+	bool isOrgLocalMC() const;
+	bool isGlobalMC() const;
+	static IPv6AddressImpl parse(const std::string& addr);
+	void mask(const IPAddressImpl* pMask, const IPAddressImpl* pSet);
+	IPAddressImpl* clone() const;
+	IPv6AddressImpl operator & (const IPv6AddressImpl& addr) const;
+	IPv6AddressImpl operator | (const IPv6AddressImpl& addr) const;
+	IPv6AddressImpl operator ^ (const IPv6AddressImpl& addr) const;
+	IPv6AddressImpl operator ~ () const;
+	bool operator == (const IPv6AddressImpl& addr) const;
+	bool operator != (const IPv6AddressImpl& addr) const;
+	IPv6AddressImpl(const IPv6AddressImpl& addr);
+	IPv6AddressImpl& operator = (const IPv6AddressImpl&);
+
+private:
+	struct in6_addr _addr;
+	unsigned int    _scope;
+};
+
+
+#endif // POCO_HAVE_IPv6
+
+
+} } } // namespace Poco::Net::Impl
+
+
+#endif // Net_IPAddressImpl_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/MailMessage.h b/base/poco/Net/include/Poco/Net/MailMessage.h
new file mode 100644
index 00000000000..474186036ea
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/MailMessage.h
@@ -0,0 +1,314 @@
+//
+// MailMessage.h
+//
+// Library: Net
+// Package: Mail
+// Module:  MailMessage
+//
+// Definition of the MailMessage class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_MailMessage_INCLUDED
+#define Net_MailMessage_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/MessageHeader.h"
+#include "Poco/Net/MailRecipient.h"
+#include "Poco/Net/PartStore.h"
+#include "Poco/Timestamp.h"
+#include <vector>
+
+
+namespace Poco {
+namespace Net {
+
+
+class MediaType;
+class PartSource;
+class PartHandler;
+class MultipartWriter;
+
+
+class Net_API MailMessage: public MessageHeader
+	/// This class represents an e-mail message for
+	/// use with the SMTPClientSession and POPClientSession
+	/// classes.
+	///
+	/// MailMessage supports both old-style plain text messages,
+	/// as well as MIME multipart mail messages with attachments.
+	///
+	/// For multi-part messages, the following content transfer
+	/// encodings are supported: 7bit, 8bit, quoted-printable
+	/// and base64.
+{
+public:
+	typedef std::vector<MailRecipient> Recipients;
+
+	enum ContentDisposition
+	{
+		CONTENT_INLINE,
+		CONTENT_ATTACHMENT
+	};
+
+	enum ContentTransferEncoding
+	{
+		ENCODING_7BIT,
+		ENCODING_8BIT,
+		ENCODING_QUOTED_PRINTABLE,
+		ENCODING_BASE64
+	};
+
+	struct Part
+	{
+		std::string             name;
+		PartSource*             pSource;
+		ContentDisposition      disposition;
+		ContentTransferEncoding encoding;
+	};
+
+	typedef std::vector<Part> PartVec;
+
+	MailMessage(PartStoreFactory* pStoreFactory = 0);
+		/// Creates an empty MailMessage.
+		///
+		/// If pStoreFactory is not null, message attachments will be
+		/// handled by the object created by the factory. Most
+		/// common reason is to temporarily save attachments to
+		/// the file system in order to avoid potential memory
+		/// exhaustion when attachment files are very large.
+
+	virtual ~MailMessage();
+		/// Destroys the MailMessage.
+
+	void addRecipient(const MailRecipient& recipient);
+		/// Adds a recipient for the message.
+
+	void setRecipients(const Recipients& recipient);
+		/// Clears existing and sets new recipient list for the message.
+
+	const Recipients& recipients() const;
+		/// Returns the recipients of the message.
+
+	void setSubject(const std::string& subject);
+		/// Sets the subject of the message.
+		///
+		/// The subject must not contain any non-ASCII
+		/// characters. To include non-ASCII characters
+		/// in the subject, use RFC 2047 word encoding
+		/// (see encodeWord()).
+
+	const std::string& getSubject() const;
+		/// Returns the subject of the message.
+
+	void setSender(const std::string& sender);
+		/// Sets the sender of the message (which
+		/// ends up in the From header field).
+		///
+		/// The sender must either be a valid email
+		/// address, or a real name followed by
+		/// an email address enclosed in < and >.
+		///
+		/// The sender must not contain any non-ASCII
+		/// characters. To include non-ASCII characters
+		/// in the sender, use RFC 2047 word encoding
+		/// (see encodeWord()).
+
+	const std::string& getSender() const;
+		/// Returns the sender of the message (taken
+		/// from the From header field).
+
+	void setContent(const std::string& content, ContentTransferEncoding encoding = ENCODING_QUOTED_PRINTABLE);
+		/// Sets the content of the mail message.
+		///
+		/// If the content transfer encoding is ENCODING_7BIT or
+		/// ENCODING_8BIT, the content string must be formatted
+		/// according to the rules of an internet email message.
+		///
+		/// The message will be sent as a single-part
+		/// message.
+		///
+		/// Note that single CR or LF characters as line delimiters must
+		/// not be used. Content lines always should be terminated with a
+		/// proper CRLF sequence.
+
+	const std::string& getContent() const;
+		/// Returns the content of the mail message.
+		///
+		/// A content will only be returned for single-part
+		/// messages. The content of multi-part mail messages
+		/// will be reported through the registered PartHandler.
+
+	void setContentType(const std::string& mediaType);
+		/// Sets the content type for the message.
+
+	void setContentType(const MediaType& mediaType);
+		/// Sets the content type for the message.
+
+	const std::string& getContentType() const;
+		/// Returns the content type for the message.
+
+	void setDate(const Poco::Timestamp& dateTime);
+		/// Sets the Date header to the given date/time value.
+
+	Poco::Timestamp getDate() const;
+		/// Returns the value of the Date header.
+
+	bool isMultipart() const;
+		/// Returns true iff the message is a multipart message.
+
+	void addPart(const std::string& name,
+		PartSource* pSource,
+		ContentDisposition disposition,
+		ContentTransferEncoding encoding);
+		/// Adds a part/attachment to the mail message.
+		///
+		/// The MailMessage takes ownership of the PartSource and deletes it
+		/// when it is no longer needed.
+		///
+		/// The MailMessage will be converted to a multipart message
+		/// if it is not already one.
+		///
+		/// The part name, and the filename specified in the part source
+		/// must not contain any non-ASCII characters.
+		/// To include non-ASCII characters in the part name or filename,
+		/// use RFC 2047 word encoding (see encodeWord()).
+
+	void addContent(PartSource* pSource,
+		ContentTransferEncoding encoding = ENCODING_QUOTED_PRINTABLE);
+		/// Adds a part to the mail message by calling
+		/// addPart("", pSource, CONTENT_INLINE, encoding);
+		///
+		/// The part name, and the filename specified in the part source
+		/// must not contain any non-ASCII characters.
+		/// To include non-ASCII characters in the part name or filename,
+		/// use RFC 2047 word encoding (see encodeWord()).
+
+	void addAttachment(const std::string& name,
+		PartSource* pSource,
+		ContentTransferEncoding encoding = ENCODING_BASE64);
+		/// Adds an attachment to the mail message by calling
+		/// addPart(name, pSource, CONTENT_ATTACHMENT, encoding);
+		///
+		/// The part name, and the filename specified in the part source
+		/// must not contain any non-ASCII characters.
+		/// To include non-ASCII characters in the part name or filename,
+		/// use RFC 2047 word encoding (see encodeWord()).
+
+	PartSource* createPartStore(const std::string& content,
+		const std::string& mediaType,
+		const std::string& filename = "");
+		/// Returns either default StringPartSource part store or,
+		/// if the part store factory was provided during construction,
+		/// the one created by PartStoreFactory.
+		/// Returned part store is allocated on the heap; it is caller's
+		/// responsibility to delete it after use. Typical use is handler
+		/// passing it back to MailMessage, which takes care of the cleanup.
+
+	const PartVec& parts() const;
+		/// Returns const reference to the vector containing part stores.
+
+	void read(std::istream& istr, PartHandler& handler);
+		/// Reads the MailMessage from the given input stream.
+		///
+		/// If the message has multiple parts, the parts
+		/// are reported to the PartHandler. If the message
+		/// is not a multi-part message, the content is stored
+		/// in a string available by calling getContent().
+
+	void read(std::istream& istr);
+		/// Reads the MailMessage from the given input stream.
+		///
+		/// The raw message (including all MIME parts) is stored
+		/// in a string and available by calling getContent().
+
+	void write(std::ostream& ostr) const;
+		/// Writes the mail message to the given output stream.
+
+	static std::string encodeWord(const std::string& text, const std::string& charset = "UTF-8");
+		/// If the given string contains non-ASCII characters,
+		/// encodes the given string using RFC 2047 "Q" word encoding.
+		///
+		/// The given text must already be encoded in the character set
+		/// given in charset (default is UTF-8).
+		///
+		/// Returns the encoded string, or the original string if it
+		/// consists only of ASCII characters.
+
+	static const std::string HEADER_SUBJECT;
+	static const std::string HEADER_FROM;
+	static const std::string HEADER_TO;
+	static const std::string HEADER_CC;
+	static const std::string HEADER_BCC;
+	static const std::string HEADER_DATE;
+	static const std::string HEADER_CONTENT_TYPE;
+	static const std::string HEADER_CONTENT_TRANSFER_ENCODING;
+	static const std::string HEADER_CONTENT_DISPOSITION;
+	static const std::string HEADER_CONTENT_ID;
+	static const std::string HEADER_MIME_VERSION;
+	static const std::string EMPTY_HEADER;
+	static const std::string TEXT_PLAIN;
+	static const std::string CTE_7BIT;
+	static const std::string CTE_8BIT;
+	static const std::string CTE_QUOTED_PRINTABLE;
+	static const std::string CTE_BASE64;
+
+protected:
+	void makeMultipart();
+	void writeHeader(const MessageHeader& header, std::ostream& ostr) const;
+	void writeMultipart(MessageHeader& header, std::ostream& ostr) const;
+	void writePart(MultipartWriter& writer, const Part& part) const;
+	void writeEncoded(std::istream& istr, std::ostream& ostr, ContentTransferEncoding encoding) const;
+	void setRecipientHeaders(MessageHeader& headers) const;
+	void readHeader(std::istream& istr);
+	void readMultipart(std::istream& istr, PartHandler& handler);
+	void readPart(std::istream& istr, const MessageHeader& header, PartHandler& handler);
+	void handlePart(std::istream& istr, const MessageHeader& header, PartHandler& handler);
+	static const std::string& contentTransferEncodingToString(ContentTransferEncoding encoding);
+	static int lineLength(const std::string& str);
+	static void appendRecipient(const MailRecipient& recipient, std::string& str);
+
+private:
+	MailMessage(const MailMessage&);
+	MailMessage& operator = (const MailMessage&);
+
+	Recipients              _recipients;
+	PartVec                 _parts;
+	std::string             _content;
+	ContentTransferEncoding _encoding;
+	mutable std::string     _boundary;
+	PartStoreFactory*       _pStoreFactory;
+};
+
+
+//
+// inlines
+//
+inline const MailMessage::Recipients& MailMessage::recipients() const
+{
+	return _recipients;
+}
+
+
+inline const std::string& MailMessage::getContent() const
+{
+	return _content;
+}
+
+
+inline const MailMessage::PartVec& MailMessage::parts() const
+{
+	return _parts;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_MailMessage_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/MailRecipient.h b/base/poco/Net/include/Poco/Net/MailRecipient.h
new file mode 100644
index 00000000000..7b146141af9
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/MailRecipient.h
@@ -0,0 +1,120 @@
+//
+// MailRecipient.h
+//
+// Library: Net
+// Package: Mail
+// Module:  MailRecipient
+//
+// Definition of the MailRecipient class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_MailRecipient_INCLUDED
+#define Net_MailRecipient_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API MailRecipient
+	/// The recipient of an e-mail message.
+	///
+	/// A recipient has a type (primary recipient,
+	/// carbon-copy recipient, blind-carbon-copy
+	/// recipient), an e-mail address and an optional
+	/// real name.
+{
+public:
+	enum RecipientType
+	{
+		PRIMARY_RECIPIENT,
+		CC_RECIPIENT,
+		BCC_RECIPIENT
+	};
+
+	MailRecipient();
+		/// Creates an empty MailRecipient.
+		
+	MailRecipient(const MailRecipient& recipient);
+		/// Creates a MailRecipient by copying another one.
+		
+	MailRecipient(RecipientType type, const std::string& address);
+		/// Creates a MailRecipient of the given type.
+
+	MailRecipient(RecipientType type, const std::string& address, const std::string& realName);
+		/// Creates a MailRecipient of the given type.
+
+	~MailRecipient();
+		/// Destroys the MailRecipient.
+		
+	MailRecipient& operator = (const MailRecipient& recipient);
+		/// Assigns another recipient.
+		
+	void swap(MailRecipient& recipient);
+		/// Exchanges the content of two recipients.
+
+	RecipientType getType() const;
+		/// Returns the type of the recipient.
+		
+	void setType(RecipientType type);
+		/// Sets the type of the recipient.
+		
+	const std::string& getAddress() const;
+		/// Returns the address of the recipient.
+		
+	void setAddress(const std::string& address);
+		/// Sets the address of the recipient.
+		
+	const std::string& getRealName() const;
+		/// Returns the real name of the recipient.
+		
+	void setRealName(const std::string& realName);
+		/// Sets the real name of the recipient.
+
+private:
+	std::string   _address;
+	std::string   _realName;
+	RecipientType _type;
+};
+
+
+//
+// inlines
+//
+inline MailRecipient::RecipientType MailRecipient::getType() const
+{
+	return _type;
+}
+
+
+inline const std::string& MailRecipient::getAddress() const
+{
+	return _address;
+}
+
+
+inline const std::string& MailRecipient::getRealName() const
+{
+	return _realName;
+}
+
+
+inline void swap(MailRecipient& r1, MailRecipient& r2)
+{
+	r1.swap(r2);
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_MailRecipient_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/MailStream.h b/base/poco/Net/include/Poco/Net/MailStream.h
new file mode 100644
index 00000000000..bc674b014d2
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/MailStream.h
@@ -0,0 +1,146 @@
+//
+// MailStream.h
+//
+// Library: Net
+// Package: Mail
+// Module:  MailStream
+//
+// Definition of the MailStream class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_MailStream_INCLUDED
+#define Net_MailStream_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API MailStreamBuf: public Poco::UnbufferedStreamBuf
+	/// The sole purpose of this stream buffer is to replace 
+	/// a "\r\n.\r\n" character sequence with a "\r\n..\r\n" sequence for
+	/// output streams and vice-versa for input streams.
+	///
+	/// This is used when sending mail messages to SMTP servers, or
+	/// receiving mail messages from POP servers.
+	///
+	/// See RFC 2181 (Simple Mail Transfer Protocol) and RFC 1939
+	/// (Post Office Protocol - Version 3) for more information.
+{
+public:
+	MailStreamBuf(std::istream& istr);
+		/// Creates the MailStreamBuf and connects it
+		/// to the given input stream.
+
+	MailStreamBuf(std::ostream& ostr);
+		/// Creates the MailStreamBuf and connects it
+		/// to the given output stream.
+
+	~MailStreamBuf();
+		/// Destroys the MailStreamBuf.
+		
+	void close();
+		/// Writes the terminating period, followed by
+		/// CR-LF.
+		
+protected:
+	int readFromDevice();
+	int writeToDevice(char c);
+	int readOne();
+
+private:
+	enum State
+	{
+		ST_DATA,
+		ST_CR,
+		ST_CR_LF,
+		ST_CR_LF_DOT,
+		ST_CR_LF_DOT_DOT,
+		ST_CR_LF_DOT_CR,
+		ST_CR_LF_DOT_CR_LF
+	};
+	
+	std::istream* _pIstr;
+	std::ostream* _pOstr;
+	std::string   _buffer;
+	State         _state;
+};
+
+
+class Net_API MailIOS: public virtual std::ios
+	/// The base class for MailInputStream and MailOutputStream.
+	///
+	/// This class provides common methods and is also needed to ensure 
+	/// the correct initialization order of the stream buffer and base classes.
+{
+public:
+	MailIOS(std::istream& istr);
+		/// Creates the MailIOS and connects it
+		/// to the given input stream.
+
+	MailIOS(std::ostream& ostr);
+		/// Creates the MailIOS and connects it
+		/// to the given output stream.
+
+	~MailIOS();
+		/// Destroys the stream.
+
+	void close();
+		/// Writes the terminating period, followed by
+		/// CR-LF.
+
+	MailStreamBuf* rdbuf();
+		/// Returns a pointer to the underlying streambuf.
+
+protected:
+	MailStreamBuf _buf;
+};
+
+
+class Net_API MailInputStream: public MailIOS, public std::istream
+	/// This class is used for reading E-Mail messages from a
+	/// POP3 server. All occurrences of "\r\n..\r\n" are replaced with
+	/// "\r\n.\r\n". The first occurrence of "\r\n.\r\n" denotes the end
+	/// of the stream.
+{
+public:
+	MailInputStream(std::istream& istr);
+		/// Creates the MailInputStream and connects it
+		/// to the given input stream.
+
+	~MailInputStream();
+		/// Destroys the MailInputStream.
+};
+
+
+class Net_API MailOutputStream: public MailIOS, public std::ostream
+	/// This class is used for writing E-Mail messages to a
+	/// SMTP server. All occurrences of "\r\n.\r\n" are replaced with
+	/// "\r\n..\r\n".
+{
+public:
+	MailOutputStream(std::ostream& ostr);
+		/// Creates the MailOutputStream and connects it
+		/// to the given input stream.
+
+	~MailOutputStream();
+		/// Destroys the MailOutputStream.
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_MailStream_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/MediaType.h b/base/poco/Net/include/Poco/Net/MediaType.h
new file mode 100644
index 00000000000..8440cb62454
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/MediaType.h
@@ -0,0 +1,169 @@
+//
+// MediaType.h
+//
+// Library: Net
+// Package: Messages
+// Module:  MediaType
+//
+// Definition of the MediaType class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_MediaType_INCLUDED
+#define Net_MediaType_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/NameValueCollection.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API MediaType
+	/// This class represents a MIME media type, consisting of
+	/// a top-level type, a subtype and an optional set of
+	/// parameters.
+	///
+	/// The implementation conforms with RFC 2045 and RFC 2046.
+{
+public:
+	MediaType(const std::string& mediaType);
+		/// Creates the MediaType from the given string, which
+		/// must have the format <type>/<subtype>{;<parameter>=<value>}.
+		
+	MediaType(const std::string& type, const std::string& subType);
+		/// Creates the MediaType, using the given type and subtype.
+
+	MediaType(const MediaType& mediaType);
+		/// Creates a MediaType from another one.
+
+	~MediaType();
+		/// Destroys the MediaType.
+
+	MediaType& operator = (const MediaType& mediaType);
+		/// Assigns another media type.
+		
+	MediaType& operator = (const std::string& mediaType);
+		/// Assigns another media type.
+		
+	void swap(MediaType& mediaType);
+		/// Swaps the MediaType with another one.
+		
+	void setType(const std::string& type);
+		/// Sets the top-level type.
+		
+	const std::string& getType() const;
+		/// Returns the top-level type.
+		
+	void setSubType(const std::string& subType);
+		/// Sets the sub type.
+		
+	const std::string& getSubType() const;
+		/// Returns the sub type.
+		
+	void setParameter(const std::string& name, const std::string& value);
+		/// Sets the parameter with the given name.
+		
+	const std::string& getParameter(const std::string& name) const;
+		/// Returns the parameter with the given name.
+		///
+		/// Throws a NotFoundException if the parameter does not exist.
+		
+	bool hasParameter(const std::string& name) const;
+		/// Returns true iff a parameter with the given name exists.
+		
+	void removeParameter(const std::string& name);
+		/// Removes the parameter with the given name.	
+		
+	const NameValueCollection& parameters() const;
+		/// Returns the parameters.
+		
+	std::string toString() const;
+		/// Returns the string representation of the media type
+		/// which is <type>/<subtype>{;<parameter>=<value>}
+		
+	bool matches(const MediaType& mediaType) const;
+		/// Returns true iff the type and subtype match
+		/// the type and subtype of the given media type.
+		/// Matching is case insensitive.
+		
+	bool matches(const std::string& type, const std::string& subType) const;
+		/// Returns true iff the type and subtype match
+		/// the given type and subtype.
+		/// Matching is case insensitive.
+
+	bool matches(const std::string& type) const;
+		/// Returns true iff the type matches the given type.
+		/// Matching is case insensitive.
+
+	bool matchesRange(const MediaType& mediaType) const;
+		/// Returns true if the type and subtype match
+		/// the type and subtype of the given media type.
+		/// If the MIME type is a range of types it matches
+		/// any media type within the range (e.g. "image/*" matches
+		/// any image media type, "*/*" matches anything).
+		/// Matching is case insensitive.
+
+	bool matchesRange(const std::string& type, const std::string& subType) const;
+		/// Returns true if the type and subtype match
+		/// the given type and subtype.
+		/// If the MIME type is a range of types it matches
+		/// any media type within the range (e.g. "image/*" matches
+		/// any image media type, "*/*" matches anything).
+		/// Matching is case insensitive.
+
+	bool matchesRange(const std::string& type) const;
+		/// Returns true if the type matches the given type or
+		/// the type is a range of types denoted by "*".
+		/// Matching is case insensitive.
+
+protected:
+	void parse(const std::string& mediaType);
+		
+private:
+	MediaType();
+	
+	std::string         _type;
+	std::string         _subType;
+	NameValueCollection _parameters;
+};
+
+
+//
+// inlines
+//
+inline const std::string& MediaType::getType() const
+{
+	return _type;
+}
+
+
+inline const std::string& MediaType::getSubType() const
+{
+	return _subType;
+}
+
+
+inline const NameValueCollection& MediaType::parameters() const
+{
+	return _parameters;
+}
+
+
+inline void swap(MediaType& m1, MediaType& m2)
+{
+	m1.swap(m2);
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_MediaType_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/MessageHeader.h b/base/poco/Net/include/Poco/Net/MessageHeader.h
new file mode 100644
index 00000000000..f36ad51e66b
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/MessageHeader.h
@@ -0,0 +1,169 @@
+//
+// MessageHeader.h
+//
+// Library: Net
+// Package: Messages
+// Module:  MessageHeader
+//
+// Definition of the MessageHeader class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_MessageHeader_INCLUDED
+#define Net_MessageHeader_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/NameValueCollection.h"
+#include <ostream>
+#include <istream>
+#include <vector>
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API MessageHeader: public NameValueCollection
+	/// A collection of name-value pairs that are used in
+	/// various internet protocols like HTTP and SMTP.
+	///
+	/// The name is case-insensitive.
+	///
+	/// There can be more than one name-value pair with the 
+	/// same name.
+	///
+	/// MessageHeader supports writing and reading the
+	/// header data in RFC 2822 format.
+	///
+	/// The maximum number of fields can be restricted
+	/// by calling setFieldLimit(). This is useful to
+	/// defend against certain kinds of denial-of-service
+	/// attacks. The limit is only enforced when parsing
+	/// header fields from a stream, not when programmatically
+	/// adding them. The default limit is 100.
+{
+public:
+	MessageHeader();
+		/// Creates the MessageHeader.
+
+	MessageHeader(const MessageHeader& messageHeader);
+		/// Creates the MessageHeader by copying
+		/// another one.
+
+	virtual ~MessageHeader();
+		/// Destroys the MessageHeader.
+
+	MessageHeader& operator = (const MessageHeader& messageHeader);
+		/// Assigns the content of another MessageHeader.
+
+	virtual void write(std::ostream& ostr) const;
+		/// Writes the message header to the given output stream.
+		///
+		/// The format is one name-value pair per line, with
+		/// name and value separated by a colon and lines
+		/// delimited by a carriage return and a linefeed 
+		/// character. See RFC 2822 for details.
+		
+	virtual void read(std::istream& istr);
+		/// Reads the message header from the given input stream.
+		///
+		/// See write() for the expected format.
+		/// Also supported is folding of field content, according
+		/// to section 2.2.3 of RFC 2822.
+		///
+		/// Reading stops at the first empty line (a line only
+		/// containing \r\n or \n), as well as at the end of
+		/// the stream.
+		///
+		/// Some basic sanity checking of the input stream is
+		/// performed.
+		///
+		/// Throws a MessageException if the input stream is
+		/// malformed.
+		
+	int getFieldLimit() const;
+		/// Returns the maximum number of header fields
+		/// allowed.
+		///
+		/// See setFieldLimit() for more information.
+		
+	void setFieldLimit(int limit);
+		/// Sets the maximum number of header fields
+		/// allowed. This limit is used to defend certain
+		/// kinds of denial-of-service attacks.
+		/// Specify 0 for unlimited (not recommended).
+		///
+		/// The default limit is 100.
+	
+	bool hasToken(const std::string& fieldName, const std::string& token) const;
+		/// Returns true iff the field with the given fieldName contains
+		/// the given token. Tokens in a header field are expected to be
+		/// comma-separated and are case insensitive.
+
+	static void splitElements(const std::string& s, std::vector<std::string>& elements, bool ignoreEmpty = true);
+		/// Splits the given string into separate elements. Elements are expected
+		/// to be separated by commas.
+		///
+		/// For example, the string 
+		///   text/plain; q=0.5, text/html, text/x-dvi; q=0.8
+		/// is split into the elements
+		///   text/plain; q=0.5
+		///   text/html
+		///   text/x-dvi; q=0.8
+		///
+		/// Commas enclosed in double quotes do not split elements.
+		///
+		/// If ignoreEmpty is true, empty elements are not returned.
+		
+	static void splitParameters(const std::string& s, std::string& value, NameValueCollection& parameters);
+		/// Splits the given string into a value and a collection of parameters.
+		/// Parameters are expected to be separated by semicolons.
+		///
+		/// Enclosing quotes of parameter values are removed.
+		///
+		/// For example, the string
+		///   multipart/mixed; boundary="MIME_boundary_01234567"
+		/// is split into the value
+		///   multipart/mixed
+		/// and the parameter
+		///   boundary -> MIME_boundary_01234567
+
+	static void splitParameters(const std::string::const_iterator& begin, const std::string::const_iterator& end, NameValueCollection& parameters);
+		/// Splits the given string into a collection of parameters.
+		/// Parameters are expected to be separated by semicolons.
+		///
+		/// Enclosing quotes of parameter values are removed.
+
+	static void quote(const std::string& value, std::string& result, bool allowSpace = false);
+		/// Checks if the value must be quoted. If so, the value is
+		/// appended to result, enclosed in double-quotes.
+		/// Otherwise, the value is appended to result as-is.
+		
+	static void decodeRFC2047(const std::string& ins, std::string& outs, const std::string& charset = "UTF-8");
+	static std::string decodeWord(const std::string& text, const std::string& charset = "UTF-8");
+	        /// Decode RFC2047 string.
+
+		
+private:
+	enum Limits
+		/// Limits for basic sanity checks when reading a header
+	{
+		MAX_NAME_LENGTH  = 256,
+		MAX_VALUE_LENGTH = 8192,
+		DFL_FIELD_LIMIT  = 100
+	};
+	
+	int _fieldLimit;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_MessageHeader_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/MulticastSocket.h b/base/poco/Net/include/Poco/Net/MulticastSocket.h
new file mode 100644
index 00000000000..6ae465775f3
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/MulticastSocket.h
@@ -0,0 +1,135 @@
+//
+// MulticastSocket.h
+//
+// Library: Net
+// Package: Sockets
+// Module:  MulticastSocket
+//
+// Definition of the MulticastSocket class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_MulticastSocket_INCLUDED
+#define Net_MulticastSocket_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+
+
+#ifdef POCO_NET_HAS_INTERFACE
+
+
+#include "Poco/Net/DatagramSocket.h"
+#include "Poco/Net/NetworkInterface.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API MulticastSocket: public DatagramSocket
+	/// A MulticastSocket is a special DatagramSocket
+	/// that can be used to send packets to and receive
+	/// packets from multicast groups.
+{
+public:
+	MulticastSocket();
+		/// Creates an unconnected, unbound multicast socket.
+		///
+		/// Before the multicast socket can be used, bind(),
+		/// bind6() or connect() must be called.
+		///
+		/// Notice: The behavior of this constructor has changed
+		/// in release 2.0. Previously, the constructor created
+		/// an unbound IPv4 multicast socket.
+		
+	explicit MulticastSocket(SocketAddress::Family family);
+		/// Creates an unconnected datagram socket.
+		///
+		/// The socket will be created for the
+		/// given address family.
+
+	MulticastSocket(const SocketAddress& address, bool reuseAddress = false);
+		/// Creates a datagram socket and binds it
+		/// to the given address.
+		///
+		/// Depending on the address family, the socket
+		/// will be either an IPv4 or an IPv6 socket.
+
+	MulticastSocket(const Socket& socket);
+		/// Creates the DatagramSocket with the SocketImpl
+		/// from another socket. The SocketImpl must be
+		/// a DatagramSocketImpl, otherwise an InvalidArgumentException
+		/// will be thrown.
+
+	~MulticastSocket();
+		/// Destroys the DatagramSocket.
+
+	MulticastSocket& operator = (const Socket& socket);
+		/// Assignment operator.
+		///
+		/// Releases the socket's SocketImpl and
+		/// attaches the SocketImpl from the other socket and
+		/// increments the reference count of the SocketImpl.
+
+	void setInterface(const NetworkInterface& interfc);
+		/// Sets the interface used for sending multicast packets.
+		///
+		/// To select the default interface, specify an empty
+		/// interface.
+		///
+		/// This is done by setting the IP_MULTICAST_IF/IPV6_MULTICAST_IF
+		/// socket option.
+
+	NetworkInterface getInterface() const;
+		/// Returns the interface used for sending multicast packets.
+
+	void setLoopback(bool flag);
+		/// Enable or disable loopback for multicast packets.
+		///
+		/// Sets the value of the IP_MULTICAST_LOOP/IPV6_MULTICAST_LOOP
+		/// socket option.
+
+	bool getLoopback() const;
+		/// Returns true iff loopback for multicast packets is enabled,
+		/// false otherwise.
+
+	void setTimeToLive(unsigned value);
+		/// Specifies the TTL/hop limit for outgoing packets.
+		///
+		/// Sets the value of the IP_MULTICAST_TTL/IPV6_MULTICAST_HOPS
+		/// socket option.
+
+	unsigned getTimeToLive() const;
+		/// Returns the TTL/hop limit for outgoing packets.
+		
+	void joinGroup(const IPAddress& groupAddress);
+		/// Joins the specified multicast group at the default interface.
+
+	void joinGroup(const IPAddress& groupAddress, const NetworkInterface& interfc);
+		/// Joins the specified multicast group at the given interface.
+
+	void leaveGroup(const IPAddress& groupAddress);
+		/// Leaves the specified multicast group at the default interface.
+
+	void leaveGroup(const IPAddress& groupAddress, const NetworkInterface& interfc);
+		/// Leaves the specified multicast group at the given interface.
+
+private:
+	static NetworkInterface findFirstInterface(const IPAddress& groupAddress);
+		/// Returns first multicast-eligible network interface.
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // POCO_NET_HAS_INTERFACE
+
+
+#endif // Net_MulticastSocket_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/MultipartReader.h b/base/poco/Net/include/Poco/Net/MultipartReader.h
new file mode 100644
index 00000000000..5f972dcba29
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/MultipartReader.h
@@ -0,0 +1,160 @@
+//
+// MultipartReader.h
+//
+// Library: Net
+// Package: Messages
+// Module:  MultipartReader
+//
+// Definition of the MultipartReader class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_MultipartReader_INCLUDED
+#define Net_MultipartReader_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/BufferedStreamBuf.h"
+#include <istream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class MessageHeader;
+
+
+class Net_API MultipartStreamBuf: public Poco::BufferedStreamBuf
+	/// This is the streambuf class used for reading from a multipart message stream.
+{
+public:
+	MultipartStreamBuf(std::istream& istr, const std::string& boundary);
+	~MultipartStreamBuf();
+	bool lastPart() const;
+	
+protected:
+	int readFromDevice(char* buffer, std::streamsize length);
+
+private:
+	enum 
+	{
+		STREAM_BUFFER_SIZE = 1024
+	};
+
+	std::istream& _istr;
+	std::string   _boundary;
+	bool          _lastPart;
+};
+
+
+class Net_API MultipartIOS: public virtual std::ios
+	/// The base class for MultipartInputStream.
+{
+public:
+	MultipartIOS(std::istream& istr, const std::string& boundary);
+	~MultipartIOS();
+	MultipartStreamBuf* rdbuf();
+	bool lastPart() const;
+
+protected:
+	MultipartStreamBuf _buf;
+};
+
+
+class Net_API MultipartInputStream: public MultipartIOS, public std::istream
+	/// This class is for internal use by MultipartReader only.
+{
+public:
+	MultipartInputStream(std::istream& istr, const std::string& boundary);
+	~MultipartInputStream();
+};
+
+
+
+class Net_API MultipartReader
+	/// This class is used to split a MIME multipart
+	/// message into its single parts.
+	///
+	/// The format of multipart messages is described
+	/// in section 5.1 of RFC 2046.
+	///
+	/// To split a multipart message into its parts,
+	/// do the following:
+	///   - Create a MultipartReader object, passing it
+	///     an input stream and optionally a boundary string.
+	///   - while hasNextPart() returns true, call nextPart()
+	///     and read the part from stream().
+	///
+	/// Always ensure that you read all data from the part
+	/// stream, otherwise the MultipartReader will fail to
+	/// find the next part.
+{
+public:
+	explicit MultipartReader(std::istream& istr);
+		/// Creates the MultipartReader and attaches it to the
+		/// given input stream. 
+		///
+		/// The boundary string is determined from the input
+		/// stream. The message must not contain a preamble
+		/// preceding the first encapsulation boundary.
+
+	MultipartReader(std::istream& istr, const std::string& boundary);
+		/// Creates the MultipartReader and attaches it to the
+		/// given input stream. The given boundary string is
+		/// used to find message boundaries.
+
+	~MultipartReader();
+		/// Destroys the MultipartReader.
+
+	void nextPart(MessageHeader& messageHeader);
+		/// Moves to the next part in the message and stores the
+		/// part's header fields in messageHeader.
+		///
+		/// Throws an MultipartException if there are no more parts
+		/// available, or if no boundary line can be found in
+		/// the input stream.
+		
+	bool hasNextPart();
+		/// Returns true iff more parts are available.
+		///
+		/// Before the first call to nextPart(), returns
+		/// always true.
+		
+	std::istream& stream() const;
+		/// Returns a reference to the reader's stream that
+		/// can be used to read the current part.
+		///
+		/// The returned reference will be valid until
+		/// nextPart() is called or the MultipartReader
+		/// object is destroyed.
+
+	const std::string& boundary() const;
+		/// Returns the multipart boundary used by this reader.
+
+protected:
+	void findFirstBoundary();
+	void guessBoundary();
+	void parseHeader(MessageHeader& messageHeader);
+	bool readLine(std::string& line, std::string::size_type n);
+	
+private:
+	MultipartReader();
+	MultipartReader(const MultipartReader&);
+	MultipartReader& operator = (const MultipartReader&);
+
+	std::istream&         _istr;
+	std::string           _boundary;
+	MultipartInputStream* _pMPI;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_MultipartReader_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/MultipartWriter.h b/base/poco/Net/include/Poco/Net/MultipartWriter.h
new file mode 100644
index 00000000000..97b3fd2356a
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/MultipartWriter.h
@@ -0,0 +1,109 @@
+//
+// MultipartWriter.h
+//
+// Library: Net
+// Package: Messages
+// Module:  MultipartWriter
+//
+// Definition of the MultipartWriter class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_MultipartWriter_INCLUDED
+#define Net_MultipartWriter_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include <ostream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class MessageHeader;
+
+
+class Net_API MultipartWriter
+	/// This class is used to write MIME multipart
+	/// messages to an output stream.
+	///
+	/// The format of multipart messages is described
+	/// in section 5.1 of RFC 2046.
+	///
+	/// To create a multipart message, first create
+	/// a MultipartWriter object.
+	/// Then, for each part, call nextPart() and
+	/// write the content to the output stream.
+	/// Repeat for all parts. 
+	/// After the last part has been written,
+	/// call close() to finish the multipart message.
+{
+public:
+	explicit MultipartWriter(std::ostream& ostr);
+		/// Creates the MultipartWriter, using the
+		/// given output stream.
+		///
+		/// Creates a random boundary string.
+
+	MultipartWriter(std::ostream& ostr, const std::string& boundary);
+		/// Creates the MultipartWriter, using the
+		/// given output stream and boundary string.
+
+	~MultipartWriter();
+		/// Destroys the MultipartWriter.
+		
+	void nextPart(const MessageHeader& header);
+		/// Opens a new message part and writes
+		/// the message boundary string, followed
+		/// by the message header to the stream.
+		
+	void close();
+		/// Closes the multipart message and writes
+		/// the terminating boundary string.
+		///
+		/// Does not close the underlying stream.
+
+	std::ostream& stream();
+		/// Returns the writer's stream.
+
+	const std::string& boundary() const;
+		/// Returns the multipart boundary used by this writer.
+
+	static std::string createBoundary();
+		/// Creates a random boundary string.
+		///
+		/// The string always has the form
+		/// MIME_boundary_XXXXXXXXXXXX, where
+		/// XXXXXXXXXXXX is a random hexadecimal
+		/// number.
+		
+private:
+	MultipartWriter();
+	MultipartWriter(const MultipartWriter&);
+	MultipartWriter& operator = (const MultipartWriter&);
+
+	std::ostream& _ostr;
+	std::string   _boundary;
+	bool          _firstPart;
+};
+
+
+//
+// inlines
+//
+inline std::ostream& MultipartWriter::stream()
+{
+	return _ostr;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_MultipartWriter_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/NTPClient.h b/base/poco/Net/include/Poco/Net/NTPClient.h
new file mode 100644
index 00000000000..044a486a733
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/NTPClient.h
@@ -0,0 +1,64 @@
+//
+// NTPClient.h
+//
+// Library: Net
+// Package: NTP
+// Module:  NTPClient
+//
+// Definition of the NTPClient class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_NTPClient_INCLUDED
+#define Net_NTPClient_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/NTPEventArgs.h"
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/BasicEvent.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API NTPClient
+	/// This class provides NTP (Network Time Protocol) client functionality.
+{
+public:
+	mutable Poco::BasicEvent<NTPEventArgs> response;
+
+	explicit NTPClient(SocketAddress::Family family, int timeout = 3000000);
+		/// Creates an NTP client.
+
+	~NTPClient();
+		/// Destroys the NTP client.
+
+	int request(SocketAddress& address) const;
+		/// Request the time from the server at address.
+		/// Notifications are posted for events.
+		/// 
+		/// Returns the number of valid replies.
+
+	int request(const std::string& address) const;
+		/// Request the time from the server at address.
+		/// Notifications are posted for events.
+		/// 
+		/// Returns the number of valid replies.
+
+private:
+	mutable SocketAddress::Family _family;
+	int _timeout;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_NTPClient_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/NTPEventArgs.h b/base/poco/Net/include/Poco/Net/NTPEventArgs.h
new file mode 100644
index 00000000000..89c12751c36
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/NTPEventArgs.h
@@ -0,0 +1,84 @@
+//
+// NTPEventArgs.h
+//
+// Library: Net
+// Package: NTP
+// Module:  NTPEventArgs
+//
+// Definition of NTPEventArgs.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_NTPEventArgs_INCLUDED
+#define Net_NTPEventArgs_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/Net/NTPPacket.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API NTPEventArgs
+	/// The purpose of the NTPEventArgs class is to be used as template parameter
+	/// to instantiate event members in NTPClient class.
+	/// When clients register for an event notification, the reference to the class is 
+	///	passed to the handler function to provide information about the event.
+{
+public:
+	NTPEventArgs(const SocketAddress& address);
+		/// Creates NTPEventArgs.
+
+	virtual ~NTPEventArgs();
+		/// Destroys NTPEventArgs.
+
+	std::string hostName() const;
+		/// Tries to resolve the target IP address into host name.
+		/// If unsuccessful, all exceptions are silently ignored and 
+		///	the IP address is returned.
+
+	std::string hostAddress() const;
+		/// Returns the target IP address.
+
+	const NTPPacket &packet();
+		/// Returns the NTP packet.
+
+private:
+	NTPEventArgs();
+
+	void setPacket(NTPPacket &packet);
+
+	SocketAddress _address;
+	NTPPacket _packet;
+
+	friend class NTPClient;
+};
+
+
+//
+// inlines
+//
+inline const NTPPacket &NTPEventArgs::packet()
+{
+	return _packet;
+}
+
+
+inline void NTPEventArgs::setPacket(NTPPacket &packet)
+{
+	_packet = packet;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif
diff --git a/base/poco/Net/include/Poco/Net/NTPPacket.h b/base/poco/Net/include/Poco/Net/NTPPacket.h
new file mode 100644
index 00000000000..4dae3478882
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/NTPPacket.h
@@ -0,0 +1,207 @@
+//
+// NTPPacket.h
+//
+// Library: Net
+// Package: NTP
+// Module:  NTPPacket
+//
+// Definition of the NTPPacket class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_NTPPacket_INCLUDED
+#define Net_NTPPacket_INCLUDED
+
+
+#include "Poco/Foundation.h"
+#include "Poco/Net/Net.h"
+#include "Poco/Timestamp.h"
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API NTPPacket
+	/// This class is the NTP packet abstraction. 
+{
+public:
+	NTPPacket();
+		/// Creates an NTPPacket.
+
+	NTPPacket(Poco::UInt8 *packet);
+		/// Creates an NTPPacket.
+		///
+		/// Assumed to have at least 48 bytes.
+
+	~NTPPacket();
+		/// Destroys the NTPPacket.
+
+	void packet(Poco::UInt8 *packet) const;
+		/// Returns the NTP packet.
+		///
+		/// Assumed to have at least 48 bytes.
+
+	void setPacket(Poco::UInt8 *packet);
+		/// Returns the NTP packet.
+		///
+		/// Assumed to have exactly 48 bytes.
+
+	Poco::Int8 leapIndicator() const;
+		/// Returns the leap indicator.
+
+	Poco::Int8 version() const;
+		/// Returns the version.
+
+	Poco::Int8 mode() const;
+		/// Returns the mode.
+
+	Poco::Int8 stratum() const;
+		/// Returns the stratum.
+
+	Poco::Int8 pool() const;
+		/// Returns the pool.
+
+	Poco::Int8 precision() const;
+		/// Returns the precision
+
+	Poco::Int32 rootDelay() const;
+		/// Returns the root delay
+
+	Poco::Int32 rootDispersion() const;
+		/// Returns the root dispersion
+
+	Poco::Int32 referenceId() const;
+		/// Returns the reference id
+
+	Poco::Int64 referenceTimestamp() const;
+		/// Returns the reference timestamp
+
+	Poco::Int64 originateTimestamp() const;
+		/// Returns the originate timestamp
+
+	Poco::Int64 receiveTimestamp() const;
+		/// Returns the receive timestamp
+
+	Poco::Int64 transmitTimestamp() const;
+		/// Returns the transmit timestamp
+
+	Poco::Timestamp referenceTime() const;
+		/// Returns the reference time
+
+	Poco::Timestamp originateTime() const;
+		/// Returns the originate time
+
+	Poco::Timestamp receiveTime() const;
+		/// Returns the receive time
+
+	Poco::Timestamp transmitTime() const;
+		/// Returns the transmit time
+private:
+	Poco::Timestamp convertTime(Poco::Int64 tm) const;
+
+	Poco::Int8 _leapIndicator;
+	Poco::Int8 _version;
+	Poco::Int8 _mode;
+	Poco::Int8 _stratum;
+	Poco::Int8 _pool;
+	Poco::Int8 _precision;
+	Poco::Int32 _rootDelay;
+	Poco::Int32 _rootDispersion;
+	Poco::Int32 _referenceId;
+	Poco::Int64 _referenceTimestamp;
+	Poco::Int64 _originateTimestamp;
+	Poco::Int64 _receiveTimestamp;
+	Poco::Int64 _transmitTimestamp;
+};
+
+
+//
+// inlines
+//
+inline Poco::Int8 NTPPacket::leapIndicator() const
+{
+	return _leapIndicator;
+}
+
+
+inline Poco::Int8 NTPPacket::version() const
+{
+	return _version;
+}
+
+
+inline Poco::Int8 NTPPacket::mode() const
+{
+	return _mode;
+}
+
+
+inline Poco::Int8 NTPPacket::stratum() const
+{
+	return _stratum;
+}
+
+
+inline Poco::Int8 NTPPacket::pool() const
+{
+	return _pool;
+}
+
+
+inline Poco::Int8 NTPPacket::precision() const
+{
+	return _precision;
+}
+
+
+inline Poco::Int32 NTPPacket::rootDelay() const
+{
+	return _rootDelay;
+}
+
+
+inline Poco::Int32 NTPPacket::rootDispersion() const
+{
+	return _rootDispersion;
+}
+
+
+inline Poco::Int32 NTPPacket::referenceId() const
+{
+	return _referenceId;
+}
+
+
+inline Poco::Int64 NTPPacket::referenceTimestamp() const
+{
+	return _referenceTimestamp;
+}
+
+
+inline Poco::Int64 NTPPacket::originateTimestamp() const
+{
+	return _originateTimestamp;
+}
+
+
+inline Poco::Int64 NTPPacket::receiveTimestamp() const
+{
+	return _receiveTimestamp;
+}
+
+
+inline Poco::Int64 NTPPacket::transmitTimestamp() const
+{
+	return _transmitTimestamp;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_NTPPacket_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/NameValueCollection.h b/base/poco/Net/include/Poco/Net/NameValueCollection.h
new file mode 100644
index 00000000000..e2edce34086
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/NameValueCollection.h
@@ -0,0 +1,126 @@
+//
+// NameValueCollection.h
+//
+// Library: Net
+// Package: Messages
+// Module:  NameValueCollection
+//
+// Definition of the NameValueCollection class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_NameValueCollection_INCLUDED
+#define Net_NameValueCollection_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/String.h"
+#include "Poco/ListMap.h"
+#include <cstddef>
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API NameValueCollection
+	/// A collection of name-value pairs that are used in
+	/// various internet protocols like HTTP and SMTP.
+	///
+	/// The name is case-insensitive.
+	///
+	/// There can be more than one name-value pair with the 
+	/// same name.
+{
+public:
+	typedef Poco::ListMap<std::string, std::string> HeaderMap;
+	typedef HeaderMap::Iterator Iterator;
+	typedef HeaderMap::ConstIterator ConstIterator;
+	
+	NameValueCollection();
+		/// Creates an empty NameValueCollection.
+
+	NameValueCollection(const NameValueCollection& nvc);
+		/// Creates a NameValueCollection by copying another one.
+
+	virtual ~NameValueCollection();
+		/// Destroys the NameValueCollection.
+
+	NameValueCollection& operator = (const NameValueCollection& nvc);
+		/// Assigns the name-value pairs of another NameValueCollection to this one.
+		
+	void swap(NameValueCollection& nvc);
+		/// Swaps the NameValueCollection with another one.
+		
+	const std::string& operator [] (const std::string& name) const;
+		/// Returns the value of the (first) name-value pair with the given name.
+		///
+		/// Throws a NotFoundException if the name-value pair does not exist.
+		
+	void set(const std::string& name, const std::string& value);	
+		/// Sets the value of the (first) name-value pair with the given name.
+		
+	void add(const std::string& name, const std::string& value);
+		/// Adds a new name-value pair with the given name and value.
+		
+	const std::string& get(const std::string& name) const;
+		/// Returns the value of the first name-value pair with the given name.
+		///
+		/// Throws a NotFoundException if the name-value pair does not exist.
+
+	const std::string& get(const std::string& name, const std::string& defaultValue) const;
+		/// Returns the value of the first name-value pair with the given name.
+		/// If no value with the given name has been found, the defaultValue is returned.
+
+	bool has(const std::string& name) const;
+		/// Returns true if there is at least one name-value pair
+		/// with the given name.
+
+	ConstIterator find(const std::string& name) const;
+		/// Returns an iterator pointing to the first name-value pair
+		/// with the given name.
+		
+	ConstIterator begin() const;
+		/// Returns an iterator pointing to the begin of
+		/// the name-value pair collection.
+		
+	ConstIterator end() const;
+		/// Returns an iterator pointing to the end of 
+		/// the name-value pair collection.
+		
+	bool empty() const;
+		/// Returns true iff the header does not have any content.
+
+	std::size_t size() const;
+		/// Returns the number of name-value pairs in the
+		/// collection.
+
+	void erase(const std::string& name);
+		/// Removes all name-value pairs with the given name.
+
+	void clear();
+		/// Removes all name-value pairs and their values.
+
+private:
+	HeaderMap _map;
+};
+
+
+//
+// inlines
+//
+inline void swap(NameValueCollection& nvc1, NameValueCollection& nvc2)
+{
+	nvc1.swap(nvc2);
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_NameValueCollection_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/Net.h b/base/poco/Net/include/Poco/Net/Net.h
new file mode 100644
index 00000000000..4ec02035154
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/Net.h
@@ -0,0 +1,122 @@
+//
+// Net.h
+//
+// Library: Net
+// Package: NetCore
+// Module:  Net
+//
+// Basic definitions for the Poco Net library.
+// This file must be the first file included by every other Net
+// header file.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_Net_INCLUDED
+#define Net_Net_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+//
+// The following block is the standard way of creating macros which make exporting
+// from a DLL simpler. All files within this DLL are compiled with the Net_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any project
+// that uses this DLL. This way any other project whose source files include this file see
+// Net_API functions as being imported from a DLL, wheras this DLL sees symbols
+// defined with this macro as being exported.
+//
+#if defined(_WIN32) && defined(POCO_DLL)
+	#if defined(Net_EXPORTS)
+		#define Net_API __declspec(dllexport)
+	#else
+		#define Net_API __declspec(dllimport)
+	#endif
+#endif
+
+
+#if !defined(Net_API)
+	#if !defined(POCO_NO_GCC_API_ATTRIBUTE) && defined (__GNUC__) && (__GNUC__ >= 4)
+		#define Net_API __attribute__ ((visibility ("default")))
+	#else
+		#define Net_API
+	#endif
+#endif
+
+
+//
+// Automatically link Net library.
+//
+#if defined(_MSC_VER)
+	#if !defined(POCO_NO_AUTOMATIC_LIBS) && !defined(Net_EXPORTS)
+		#pragma comment(lib, "PocoNet" POCO_LIB_SUFFIX)
+	#endif
+#endif
+
+
+// Default to enabled IPv6 support if not explicitly disabled
+#if !defined(POCO_NET_NO_IPv6) && !defined (POCO_HAVE_IPv6)
+	#define POCO_HAVE_IPv6
+#elif defined(POCO_NET_NO_IPv6) && defined (POCO_HAVE_IPv6)
+	#undef POCO_HAVE_IPv6
+#endif // POCO_NET_NO_IPv6, POCO_HAVE_IPv6
+
+
+namespace Poco {
+namespace Net {
+
+
+void Net_API initializeNetwork();
+	/// Initialize the network subsystem.
+	/// (Windows only, no-op elsewhere)
+
+
+void Net_API uninitializeNetwork();
+	/// Uninitialize the network subsystem.
+	/// (Windows only, no-op elsewhere)
+
+
+}} // namespace Poco::Net
+
+
+//
+// Automate network initialization (only relevant on Windows).
+//
+
+#if defined(POCO_OS_FAMILY_WINDOWS) && !defined(POCO_NO_AUTOMATIC_LIB_INIT) && !defined(__GNUC__)
+
+extern "C" const struct Net_API NetworkInitializer pocoNetworkInitializer;
+
+#if defined(Net_EXPORTS)
+	#if defined(_WIN64) || defined(_WIN32_WCE)
+		#define POCO_NET_FORCE_SYMBOL(s) __pragma(comment (linker, "/export:"#s))
+	#elif defined(_WIN32)
+		#define POCO_NET_FORCE_SYMBOL(s) __pragma(comment (linker, "/export:_"#s))
+	#endif
+#else  // !Net_EXPORTS
+	#if defined(_WIN64) || defined(_WIN32_WCE)
+		#define POCO_NET_FORCE_SYMBOL(s) __pragma(comment (linker, "/include:"#s))
+	#elif defined(_WIN32)
+		#define POCO_NET_FORCE_SYMBOL(s) __pragma(comment (linker, "/include:_"#s))
+	#endif
+#endif // Net_EXPORTS
+
+POCO_NET_FORCE_SYMBOL(pocoNetworkInitializer)
+
+#endif // POCO_OS_FAMILY_WINDOWS
+
+
+//
+// Define POCO_NET_HAS_INTERFACE for platforms that have network interface detection implemented.
+//
+#if defined(POCO_OS_FAMILY_WINDOWS) || (POCO_OS == POCO_OS_LINUX) || (POCO_OS == POCO_OS_ANDROID) || defined(POCO_OS_FAMILY_BSD) || (POCO_OS == POCO_OS_SOLARIS) || (POCO_OS == POCO_OS_QNX)
+	#define POCO_NET_HAS_INTERFACE
+#endif
+
+
+#endif // Net_Net_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/NetException.h b/base/poco/Net/include/Poco/Net/NetException.h
new file mode 100644
index 00000000000..92bb3ed9120
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/NetException.h
@@ -0,0 +1,60 @@
+//
+// NetException.h
+//
+// Library: Net
+// Package: NetCore
+// Module:  NetException
+//
+// Definition of the NetException class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_NetException_INCLUDED
+#define Net_NetException_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+POCO_DECLARE_EXCEPTION(Net_API, NetException, Poco::IOException)
+POCO_DECLARE_EXCEPTION(Net_API, InvalidAddressException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, InvalidSocketException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, ServiceNotFoundException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, ConnectionAbortedException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, ConnectionResetException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, ConnectionRefusedException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, DNSException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, HostNotFoundException, DNSException)
+POCO_DECLARE_EXCEPTION(Net_API, NoAddressFoundException, DNSException)
+POCO_DECLARE_EXCEPTION(Net_API, InterfaceNotFoundException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, NoMessageException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, MessageException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, MultipartException, MessageException)
+POCO_DECLARE_EXCEPTION(Net_API, HTTPException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, NotAuthenticatedException, HTTPException)
+POCO_DECLARE_EXCEPTION(Net_API, UnsupportedRedirectException, HTTPException)
+POCO_DECLARE_EXCEPTION(Net_API, FTPException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, SMTPException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, POP3Exception, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, ICMPException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, NTPException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, HTMLFormException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, WebSocketException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, UnsupportedFamilyException, NetException)
+POCO_DECLARE_EXCEPTION(Net_API, AddressFamilyMismatchException, NetException)
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_NetException_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/NetworkInterface.h b/base/poco/Net/include/Poco/Net/NetworkInterface.h
new file mode 100644
index 00000000000..17e10fdf6c7
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/NetworkInterface.h
@@ -0,0 +1,352 @@
+//
+// NetworkInterface.h
+//
+// Library: Net
+// Package: Sockets
+// Module:  NetworkInterface
+//
+// Definition of the NetworkInterface class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_NetworkInterface_INCLUDED
+#define Net_NetworkInterface_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+
+
+#ifdef POCO_NET_HAS_INTERFACE
+
+
+#include "Poco/Net/IPAddress.h"
+#include "Poco/Mutex.h"
+#include "Poco/Tuple.h"
+#include <map>
+#include <ostream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetworkInterfaceImpl;
+
+
+class Net_API NetworkInterface
+	/// This class represents a network interface.
+	/// 
+	/// NetworkInterface is used with MulticastSocket to specify
+	/// multicast interfaces for sending and receiving multicast
+	/// messages.
+	/// 
+	/// The class also provides static member functions for
+	/// enumerating or searching network interfaces and their
+	/// respective configuration values.
+	///
+	/// On Windows, detection capabilities vary depending on the
+	/// OS version/service pack. Although the best effort is made
+	/// not to attempt access to non-existent features through a 
+	/// combination of compile/runtime checks, when running binaries
+	/// compiled on a newer version of the OS on an older one
+	/// problems may occur; if possible, it is best to run
+	/// binaries on the OS version where they were compiled.
+	/// This particularly applies to OS versions older than Vista
+	/// and XP.
+{
+public:
+	typedef std::vector<NetworkInterface>                List;
+	typedef List                                         NetworkInterfaceList;//@deprecated
+	typedef std::map<unsigned, NetworkInterface>         Map;
+	typedef Poco::Tuple<IPAddress, IPAddress, IPAddress> AddressTuple;
+	typedef std::vector<AddressTuple>                    AddressList;
+	typedef AddressList::iterator                        AddressIterator;
+	typedef AddressList::const_iterator                  ConstAddressIterator;
+	typedef std::vector<unsigned char>                   MACAddress;
+
+	enum AddressType
+	{
+		IP_ADDRESS,
+		SUBNET_MASK,
+		BROADCAST_ADDRESS
+	};
+
+	enum Type
+	{
+		NI_TYPE_ETHERNET_CSMACD,
+		NI_TYPE_ISO88025_TOKENRING,
+		NI_TYPE_FRAMERELAY,
+		NI_TYPE_PPP,
+		NI_TYPE_SOFTWARE_LOOPBACK,
+		NI_TYPE_ATM,
+		NI_TYPE_IEEE80211,
+		NI_TYPE_TUNNEL,
+		NI_TYPE_IEEE1394,
+		NI_TYPE_OTHER
+	};
+
+	enum IPVersion
+	{
+		IPv4_ONLY,    /// Return interfaces with IPv4 address only
+		IPv6_ONLY,    /// Return interfaces with IPv6 address only
+		IPv4_OR_IPv6  /// Return interfaces with IPv4 or IPv6 address
+	};
+
+	static const unsigned NO_INDEX = ~0;
+#if defined(POCO_OS_FAMILY_WINDOWS)
+	static const char MAC_SEPARATOR = '-';
+#else
+	static const char MAC_SEPARATOR = ':';
+#endif
+
+	NetworkInterface(unsigned index = NO_INDEX);
+		/// Creates a NetworkInterface representing the
+		/// default interface.
+		///
+		/// The name is empty, the IP address is the wildcard
+		/// address and the index is max value of unsigned integer.
+	
+	NetworkInterface(const NetworkInterface& interfc);
+		/// Creates the NetworkInterface by copying another one.
+
+	~NetworkInterface();
+		/// Destroys the NetworkInterface.
+
+	NetworkInterface& operator = (const NetworkInterface& interfc);
+		/// Assigns another NetworkInterface.
+	
+	bool operator < (const NetworkInterface& other) const;
+		/// Operator less-than.
+	
+	bool operator == (const NetworkInterface& other) const;
+		/// Operator equal. Compares interface indices.
+
+	void swap(NetworkInterface& other);
+		/// Swaps the NetworkInterface with another one.	
+		
+	unsigned index() const;
+		/// Returns the interface OS index.
+		
+	const std::string& name() const;
+		/// Returns the interface name.
+		
+	const std::string& displayName() const;
+		/// Returns the interface display name.
+		///
+		/// On Windows platforms, this is currently the network adapter
+		/// name. This may change to the "friendly name" of the network
+		/// connection in a future version, however. 
+		///
+		/// On other platforms this is the same as name().
+
+	const std::string& adapterName() const;
+		/// Returns the interface adapter name.
+		///
+		/// On Windows platforms, this is the network adapter LUID.
+		/// The adapter name is used by some Windows Net APIs like DHCP. 
+		///
+		/// On other platforms this is the same as name().
+
+	const IPAddress& firstAddress(IPAddress::Family family) const;
+		/// Returns the first IP address bound to the interface.
+		/// Throws NotFoundException if the address family is not
+		/// configured on the interface.
+
+	void firstAddress(IPAddress& addr, IPAddress::Family family = IPAddress::IPv4) const;
+		/// Returns the first IP address bound to the interface.
+		/// If the address family is not configured on the interface,
+		/// the address returned in addr will be unspecified (wildcard).
+
+	const IPAddress& address(unsigned index = 0) const;
+		/// Returns the IP address bound to the interface at index position.
+
+	void addAddress(const IPAddress& address);
+		/// Adds address to the interface.
+
+	void addAddress(const IPAddress& address, const IPAddress& subnetMask, const IPAddress& broadcastAddress);
+		/// Adds address to the interface.
+
+	const AddressList& addressList() const;
+		/// Returns the list of IP addresses bound to the interface.
+
+	const IPAddress& subnetMask(unsigned index = 0) const;
+		/// Returns the subnet mask for this network interface.
+
+	const IPAddress& broadcastAddress(unsigned index = 0) const;
+		/// Returns the broadcast address for this network interface.
+
+	const IPAddress& destAddress(unsigned index = 0) const;
+		/// Returns the IPv4 point-to-point destination address for this network interface.
+
+	const MACAddress& macAddress() const;
+		/// Returns MAC (Media Access Control) address for the interface.
+
+	unsigned mtu() const;
+		/// Returns the MTU for this interface.
+
+	NetworkInterface::Type type() const;
+		/// returns the MIB IfType of the interface.
+
+	bool supportsIP() const;
+		/// Returns true if the interface supports IP.
+
+	bool supportsIPv4() const;
+		/// Returns true if the interface supports IPv4.
+
+	bool supportsIPv6() const;
+		/// Returns true if the interface supports IPv6.	
+
+	bool supportsBroadcast() const;
+		/// Returns true if the interface supports broadcast.
+
+	bool supportsMulticast() const;
+		/// Returns true if the interface supports multicast.
+
+	bool isLoopback() const;
+		/// Returns true if the interface is loopback.
+
+	bool isPointToPoint() const;
+		/// Returns true if the interface is point-to-point.
+
+	bool isRunning() const;
+		/// Returns true if the interface is running.
+
+	bool isUp() const;
+		/// Returns true if the interface is up.
+
+	static NetworkInterface forName(const std::string& name, bool requireIPv6 = false);
+		/// Returns the NetworkInterface for the given name.
+		/// 
+		/// If requireIPv6 is false, an IPv4 interface is returned.
+		/// Otherwise, an IPv6 interface is returned.
+		///
+		/// Throws an InterfaceNotFoundException if an interface
+		/// with the give name does not exist.
+
+	static NetworkInterface forName(const std::string& name, IPVersion ipVersion);
+		/// Returns the NetworkInterface for the given name.
+		/// 
+		/// The ipVersion argument can be used to specify whether
+		/// an IPv4 (IPv4_ONLY) or IPv6 (IPv6_ONLY) interface is required, 
+		/// or whether the caller does not care (IPv4_OR_IPv6).
+		///
+		/// Throws an InterfaceNotFoundException if an interface
+		/// with the give name does not exist.
+		
+	static NetworkInterface forAddress(const IPAddress& address);
+		/// Returns the NetworkInterface for the given IP address.
+		///
+		/// Throws an InterfaceNotFoundException if an interface
+		/// with the give address does not exist.
+
+	static NetworkInterface forIndex(unsigned index);
+		/// Returns the NetworkInterface for the given interface index.
+		///
+		/// Throws an InterfaceNotFoundException if an interface
+		/// with the given index does not exist.
+
+	static List list(bool ipOnly = true, bool upOnly = true);
+		/// Returns a list with all network interfaces
+		/// on the system.
+		///
+		/// If ipOnly is true, only interfaces supporting IP
+		/// are returned. Otherwise, all system network interfaces
+		/// are returned.
+		///
+		/// If upOnly is true, only interfaces being up are returned.
+		/// Otherwise, both interfaces being up and down are returned.
+		///
+		/// If there are multiple addresses bound to one interface,
+		/// multiple NetworkInterface entries are listed for
+		/// the same interface.
+
+	static Map map(bool ipOnly = true, bool upOnly = true);
+		/// Returns a map containing system network interfaces
+		/// Map is keyed by interface system indices.
+		///
+		/// If ipOnly is true, only interfaces supporting IP
+		/// are returned. Otherwise, all system network interfaces
+		/// are returned.
+		///
+		/// If upOnly is true, only interfaces being up are returned.
+		/// Otherwise, both interfaces being up and down are returned.
+		///
+		/// If there are multiple addresses bound to one interface,
+		/// they are contained within the NetworkInterface (second) 
+		/// member of the pair.
+
+protected:
+	NetworkInterface(const std::string& name, const std::string& displayName, const std::string& adapterName, const IPAddress& address, unsigned index, MACAddress* pMACAddress = 0);
+		/// Creates the NetworkInterface.
+
+	NetworkInterface(const std::string& name, const std::string& displayName, const std::string& adapterName, unsigned index, MACAddress* pMACAddress = 0);
+		/// Creates the NetworkInterface.
+
+	NetworkInterface(const std::string& name, const IPAddress& address, unsigned index, MACAddress* pMACAddress = 0);
+		/// Creates the NetworkInterface.
+
+	NetworkInterface(const std::string& name,
+		const std::string& displayName,
+		const std::string& adapterName,
+		const IPAddress& address,
+		const IPAddress& subnetMask,
+		const IPAddress& broadcastAddress,
+		unsigned index,
+		MACAddress* pMACAddress = 0);
+		/// Creates the NetworkInterface.
+
+	NetworkInterface(const std::string& name,
+		const IPAddress& address,
+		const IPAddress& subnetMask,
+		const IPAddress& broadcastAddress,
+		unsigned index,
+		MACAddress* pMACAddress = 0);
+		/// Creates the NetworkInterface.
+
+	IPAddress interfaceNameToAddress(const std::string& interfaceName) const;
+		/// Determines the IPAddress bound to the interface with the given name.
+
+	unsigned interfaceNameToIndex(const std::string& interfaceName) const;
+		/// Determines the interface index of the interface with the given name.
+
+	NetworkInterfaceImpl& impl() { return *_pImpl; };
+
+private:
+	NetworkInterfaceImpl* _pImpl;
+
+	static Poco::FastMutex _mutex;
+};
+
+
+///
+/// inlines
+///
+
+
+inline bool NetworkInterface::operator < (const NetworkInterface& other) const
+{
+	return this->index() < other.index();
+}
+
+
+inline bool NetworkInterface::operator == (const NetworkInterface& other) const
+{
+	return this->index() == other.index();
+}
+
+
+} } // namespace Poco::Net
+
+
+Net_API std::ostream& operator << (std::ostream& ostr, const Poco::Net::NetworkInterface::MACAddress& addr);
+
+
+#endif // POCO_NET_HAS_INTERFACE
+
+
+#endif // Net_NetworkInterface_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/NullPartHandler.h b/base/poco/Net/include/Poco/Net/NullPartHandler.h
new file mode 100644
index 00000000000..21c45c68055
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/NullPartHandler.h
@@ -0,0 +1,47 @@
+//
+// NullPartHandler.h
+//
+// Library: Net
+// Package: Messages
+// Module:  NullPartHandler
+//
+// Definition of the NullPartHandler class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_NullPartHandler_INCLUDED
+#define Net_NullPartHandler_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/PartHandler.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API NullPartHandler: public PartHandler
+	/// A very special PartHandler that simply discards all data.
+{
+public:
+	NullPartHandler();
+		/// Creates the NullPartHandler.
+	
+	~NullPartHandler();
+		/// Destroys the NullPartHandler.
+	
+	void handlePart(const MessageHeader& header, std::istream& stream);
+		/// Reads and discards all data from the stream.
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_NullPartHandler_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/OAuth10Credentials.h b/base/poco/Net/include/Poco/Net/OAuth10Credentials.h
new file mode 100644
index 00000000000..1402d40d5b1
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/OAuth10Credentials.h
@@ -0,0 +1,274 @@
+//
+// OAuth10Credentials.h
+//
+// Library: Net
+// Package: OAuth
+// Module:	OAuth10Credentials
+//
+// Definition of the OAuth10Credentials class.
+//
+// Copyright (c) 2014, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_OAuth10Credentials_INCLUDED
+#define Net_OAuth10Credentials_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/URI.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPRequest;
+class HTMLForm;
+
+
+class Net_API OAuth10Credentials
+	/// This class implements OAuth 1.0A authentication for HTTP requests,
+	/// according to RFC 5849.
+	/// 
+	/// Only PLAINTEXT and HMAC-SHA1 signature methods are
+	/// supported. The RSA-SHA1 signature method is not supported.
+	///
+	/// The OAuth10Credentials can be used to sign a client request, as
+	/// well as to verify the signature of a request on the server.
+	///
+	/// To sign a client request, using a known consumer (client) key, consumer (client) secret,
+	/// OAuth token and token secret:
+	///
+	///   1. Create an OAuth10Credentials object using all four credentials, either using
+	///      the four argument constructor, or by using the default constructor and setting
+	///      the credentials using the setter methods.
+	///   2. Create a URI containing the full request URI.
+	///   3. Create an appropriate HTTPRequest object.
+	///   4. Optionally, create a HTMLForm object containing additional parameters to sign.
+	///   5. Sign the request by calling authenticate(). This will add an OAuth
+	///      Authorization header to the request.
+	///   6. Send the request using a HTTPClientSession.
+	///
+	/// To request the OAuth request token from a server, using only the consumer (client) key
+	/// and consumer (client) secret:
+	///
+	///   1. Create an OAuth10Credentials object using the two consumer credentials, either using
+	///      the two argument constructor, or by using the default constructor and setting
+	///      the credentials using the setter methods.
+	///   2. Specify the callback URI using setCallback().
+	///   3. Create a URI containing the full request URI to obtain the token.
+	///   4. Create an appropriate HTTPRequest object.
+	///   5. Sign the request by calling authenticate(). This will add an OAuth
+	///      Authorization header to the request.
+	///   6. Send the request using a HTTPClientSession.
+	///   7. The response will contain the request token and request token secret.
+	///      These can be extracted from the response body using a HTMLForm object.
+	///
+	/// Requesting the access token and secret (temporary credentials) from the server 
+	/// is analogous to signing a client request using consumer key, consumer secret, 
+	/// request token and request token secret. 
+	/// The server response will contain the access token and access token secret,
+	/// which can again be extracted from the response body using a HTMLForm object.
+	///
+	/// To verify a request on the server:
+	///
+	///   1. Create an OAuth10Credentials object using the constructor taking a
+	///      HTTPRequest object. This will extract the consumer key and token (if
+	///      provided).
+	///   2. Provide the consumer secret and token secret (if required) matching the
+	///      consumer key and token to the OAuth10Credentials object using the 
+	///      setter methods.
+	///   3. Create an URI object containing the full request URI.
+	///   4. Call verify() to verify the signature.
+	///   5. If verification was successful, and the request was a request for
+	///      a request (temporary) token, call getCallback() to
+	///      obtain the callback URI provided by the client.
+{
+public:
+	enum SignatureMethod
+		/// OAuth 1.0A Signature Method.
+	{
+		SIGN_PLAINTEXT, /// OAuth 1.0A PLAINTEXT signature method
+		SIGN_HMAC_SHA1  /// OAuth 1.0A HMAC-SHA1 signature method
+	};
+	
+	OAuth10Credentials();
+		/// Creates an empty OAuth10Credentials object.
+
+	OAuth10Credentials(const std::string& consumerKey, const std::string& consumerSecret);
+		/// Creates an OAuth10Credentials object with the given consumer key and consumer secret.
+		///
+		/// The token and tokenSecret will be left empty.
+
+	OAuth10Credentials(const std::string& consumerKey, const std::string& consumerSecret, const std::string& token, const std::string& tokenSecret);
+		/// Creates an OAuth10Credentials object with the given consumer key and 
+		/// consumer secret, as well as token and token secret.
+
+	explicit OAuth10Credentials(const HTTPRequest& request);
+		/// Creates an OAuth10Credentials object from a HTTPRequest object.
+		///
+		/// Extracts consumer key and token (if available) from the Authorization header.
+		///
+		/// Throws a NotAuthenticatedException if the request does
+		/// not contain OAuth 1.0 credentials.
+
+	~OAuth10Credentials();
+		/// Destroys the OAuth10Credentials.
+
+	void setConsumerKey(const std::string& consumerKey);
+		/// Sets the consumer key.
+		
+	const std::string& getConsumerKey() const;
+		/// Returns the consumer key.
+
+	void setConsumerSecret(const std::string& consumerSecret);
+		/// Sets the consumer secret.
+		
+	const std::string& getConsumerSecret() const;
+		/// Returns the consumer secret.
+		
+	void setToken(const std::string& token);
+		/// Sets the token.
+		
+	const std::string& getToken() const;
+		/// Returns the token.
+
+	void setTokenSecret(const std::string& tokenSecret);
+		/// Sets the token.
+		
+	const std::string& getTokenSecret() const;
+		/// Returns the token secret.
+		
+	void setRealm(const std::string& realm);
+		/// Sets the optional realm to be included in the Authorization header.
+		
+	const std::string& getRealm() const;
+		/// Returns the optional realm to be included in the Authorization header.
+		
+	void setCallback(const std::string& uri);
+		/// Sets the callback URI.
+		
+	const std::string& getCallback() const;
+		/// Returns the callback URI.
+				
+	void authenticate(HTTPRequest& request, const Poco::URI& uri, SignatureMethod method = SIGN_HMAC_SHA1);
+		/// Adds an OAuth 1.0A Authentication header to the given request, using
+		/// the given signature method.
+		
+	void authenticate(HTTPRequest& request, const Poco::URI& uri, const Poco::Net::HTMLForm& params, SignatureMethod method = SIGN_HMAC_SHA1);
+		/// Adds an OAuth 1.0A Authentication header to the given request, using
+		/// the given signature method.
+
+	bool verify(const HTTPRequest& request, const Poco::URI& uri);
+		/// Verifies the signature of the given request. 
+		///
+		/// The consumer key, consumer secret, token and token secret must have been set.
+		///
+		/// Returns true if the signature is valid, otherwise false.
+		///
+		/// Throws a NotAuthenticatedException if the request does not contain OAuth
+		/// credentials, or in case of an unsupported OAuth version or signature method.
+		
+	bool verify(const HTTPRequest& request, const Poco::URI& uri, const Poco::Net::HTMLForm& params);
+		/// Verifies the signature of the given request. 
+		///
+		/// The consumer key, consumer secret, token and token secret must have been set.
+		///
+		/// Returns true if the signature is valid, otherwise false.
+		///
+		/// Throws a NotAuthenticatedException if the request does not contain OAuth
+		/// credentials, or in case of an unsupported OAuth version or signature method.
+
+	void nonceAndTimestampForTesting(const std::string& nonce, const std::string& timestamp);
+		/// Sets the nonce and timestamp to a wellknown value.
+		///
+		/// For use by testsuite only, to test the signature
+		/// algorithm with wellknown inputs.
+		///
+		/// In normal operation, the nonce is a random value
+		/// computed by createNonce() and the timestamp is taken
+		/// from the system time.
+
+	static const std::string SCHEME;
+
+protected:
+	void signPlaintext(Poco::Net::HTTPRequest& request) const;
+		/// Signs the given HTTP request according to OAuth 1.0A PLAINTEXT signature method.
+
+	void signHMACSHA1(Poco::Net::HTTPRequest& request, const std::string& uri, const Poco::Net::HTMLForm& params) const;
+		/// Signs the given HTTP request according to OAuth 1.0A HMAC-SHA1 signature method.
+
+	std::string createNonce() const;
+		/// Creates a nonce, which is basically a Base64-encoded 32 character random
+		/// string, with non-alphanumeric characters removed.
+
+	std::string createSignature(const Poco::Net::HTTPRequest& request, const std::string& uri, const Poco::Net::HTMLForm& params, const std::string& nonce, const std::string& timestamp) const;
+		/// Creates a OAuth signature for the given request and its parameters, according
+		/// to <https://dev.twitter.com/docs/auth/creating-signature>.
+		
+	static std::string percentEncode(const std::string& str);
+		/// Percent-encodes the given string according to Twitter API's rules,
+		/// given in <https://dev.twitter.com/docs/auth/percent-encoding-parameters>.
+
+private:
+	OAuth10Credentials(const OAuth10Credentials&);
+	OAuth10Credentials& operator = (const OAuth10Credentials&);
+	
+	std::string _consumerKey;
+	std::string _consumerSecret;
+	std::string _token;
+	std::string _tokenSecret;
+	std::string _callback;
+	std::string _realm;
+	std::string _nonce;
+	std::string _timestamp;
+};
+
+
+//
+// inlines
+//
+inline const std::string& OAuth10Credentials::getConsumerKey() const
+{
+	return _consumerKey;
+}
+
+
+inline const std::string& OAuth10Credentials::getConsumerSecret() const
+{
+	return _consumerSecret;
+}
+
+
+inline const std::string& OAuth10Credentials::getToken() const
+{
+	return _token;
+}
+
+
+inline const std::string& OAuth10Credentials::getTokenSecret() const
+{
+	return _tokenSecret;
+}
+
+
+inline const std::string& OAuth10Credentials::getRealm() const
+{
+	return _realm;
+}
+
+
+inline const std::string& OAuth10Credentials::getCallback() const
+{
+	return _callback;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_OAuth10Credentials_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/OAuth20Credentials.h b/base/poco/Net/include/Poco/Net/OAuth20Credentials.h
new file mode 100644
index 00000000000..6935f2dfa65
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/OAuth20Credentials.h
@@ -0,0 +1,132 @@
+//
+// OAuth20Credentials.h
+//
+// Library: Net
+// Package: OAuth
+// Module:	OAuth20Credentials
+//
+// Definition of the OAuth20Credentials class.
+//
+// Copyright (c) 2014, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_OAuth20Credentials_INCLUDED
+#define Net_OAuth20Credentials_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPRequest;
+
+
+class Net_API OAuth20Credentials
+	/// This class implements OAuth 2.0 authentication for HTTP requests,
+	/// via Bearer tokens in the Authorization header, 
+	/// according to RFC 6749 and RFC 6750.
+	///
+	/// To add an Authorization header containing a bearer token
+	/// to a HTTPRequest object, create an OAuth20Credentials object
+	/// with the bearer token and call authenticate().
+	///
+	/// The bearer token can also be extracted from a HTTPRequest
+	/// by creating the OAuth20Credentials object with a HTTPRequest
+	/// object containing a "Bearer" Authorization header and
+	/// calling getBearerToken().
+	///
+	/// The authorization header scheme can be changed from 
+	/// "Bearer" to a custom value. For example, GitHub uses
+	/// the "token" scheme.
+{
+public:
+	OAuth20Credentials();
+		/// Creates an empty OAuth20Credentials object.
+
+	explicit OAuth20Credentials(const std::string& bearerToken);
+		/// Creates an OAuth20Credentials object with the given bearer token.
+
+	OAuth20Credentials(const std::string& bearerToken, const std::string& scheme);
+		/// Creates an OAuth20Credentials object with the given bearer token
+		/// and authorization scheme, which overrides the default scheme ("Bearer").
+		///
+		/// This is useful for services like GitHub, which use "token" as scheme.
+
+	explicit OAuth20Credentials(const HTTPRequest& request);
+		/// Creates an OAuth20Credentials object from a HTTPRequest object.
+		///
+		/// Extracts bearer token from the Authorization header, which
+		/// must use the "Bearer" authorization scheme.
+		///
+		/// Throws a NotAuthenticatedException if the request does
+		/// not contain a bearer token in the Authorization header.
+
+	OAuth20Credentials(const HTTPRequest& request, const std::string& scheme);
+		/// Creates an OAuth20Credentials object from a HTTPRequest object.
+		///
+		/// Extracts bearer token from the Authorization header, which must
+		/// use the given authorization scheme.
+		///
+		/// Throws a NotAuthenticatedException if the request does
+		/// not contain a bearer token in the Authorization header.
+
+	~OAuth20Credentials();
+		/// Destroys the HTTPCredentials.
+
+	void setBearerToken(const std::string& bearerToken);
+		/// Sets the bearer token.
+		
+	const std::string& getBearerToken() const;
+		/// Returns the bearer token.
+
+	void setScheme(const std::string& scheme);
+		/// Sets the Authorization header scheme.
+		
+	const std::string& getScheme() const;
+		/// Returns the Authorization header scheme.
+		
+	void authenticate(HTTPRequest& request);
+		/// Adds an Authorization header containing the bearer token to
+		/// the HTTPRequest.
+
+	static const std::string SCHEME;
+
+protected:
+	void extractBearerToken(const HTTPRequest& request);
+		/// Extracts the bearer token from the HTTPRequest.
+		
+private:
+	OAuth20Credentials(const OAuth20Credentials&);
+	OAuth20Credentials& operator = (const OAuth20Credentials&);
+	
+	std::string _bearerToken;
+	std::string _scheme;
+};
+
+
+//
+// inlines
+//
+inline const std::string& OAuth20Credentials::getBearerToken() const
+{
+	return _bearerToken;
+}
+
+
+inline const std::string& OAuth20Credentials::getScheme() const
+{
+	return _scheme;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_OAuth20Credentials_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/POP3ClientSession.h b/base/poco/Net/include/Poco/Net/POP3ClientSession.h
new file mode 100644
index 00000000000..a4b12ce1ed6
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/POP3ClientSession.h
@@ -0,0 +1,185 @@
+//
+// POP3ClientSession.h
+//
+// Library: Net
+// Package: Mail
+// Module:  POP3ClientSession
+//
+// Definition of the POP3ClientSession class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_POP3ClientSession_INCLUDED
+#define Net_POP3ClientSession_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/DialogSocket.h"
+#include "Poco/Timespan.h"
+#include <ostream>
+#include <vector>
+
+
+namespace Poco {
+namespace Net {
+
+
+class MessageHeader;
+class MailMessage;
+class PartHandler;
+
+
+class Net_API POP3ClientSession
+	/// This class implements an Post Office Protocol
+	/// Version 3 (POP3, RFC 1939)
+	/// client for receiving e-mail messages.
+{
+public:
+	enum
+	{
+		POP3_PORT = 110
+	};
+	
+	struct MessageInfo
+		/// Information returned by listMessages().
+	{
+		int id;
+		int size;
+	};
+	
+	typedef std::vector<MessageInfo> MessageInfoVec;
+
+	explicit POP3ClientSession(const StreamSocket& socket);
+		/// Creates the POP3ClientSession using
+		/// the given socket, which must be connected
+		/// to a POP3 server.
+
+	POP3ClientSession(const std::string& host, Poco::UInt16 port = POP3_PORT);
+		/// Creates the POP3ClientSession using a socket connected
+		/// to the given host and port.
+
+	virtual ~POP3ClientSession();
+		/// Destroys the SMTPClientSession.
+
+	void setTimeout(const Poco::Timespan& timeout);
+		/// Sets the timeout for socket read operations.
+		
+	Poco::Timespan getTimeout() const;
+		/// Returns the timeout for socket read operations.
+
+	void login(const std::string& username, const std::string& password);
+		/// Logs in to the POP3 server by sending a USER command
+		/// followed by a PASS command.
+		///
+		/// Throws a POP3Exception in case of a POP3-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	void close();
+		/// Sends a QUIT command and closes the connection to the server.	
+		///
+		/// Throws a POP3Exception in case of a POP3-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	int messageCount();
+		/// Sends a STAT command to determine the number of messages
+		/// available on the server and returns that number.
+		///
+		/// Throws a POP3Exception in case of a POP3-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	void listMessages(MessageInfoVec& messages);
+		/// Fills the given vector with the ids and sizes of all
+		/// messages available on the server.
+		///
+		/// Throws a POP3Exception in case of a POP3-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	void retrieveMessage(int id, MailMessage& message);
+		/// Retrieves the message with the given id from the server and
+		/// stores the raw message content in the message's
+		/// content string, available with message.getContent().
+		///
+		/// Throws a POP3Exception in case of a POP3-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	void retrieveMessage(int id, MailMessage& message, PartHandler& handler);
+		/// Retrieves the message with the given id from the server and
+		/// stores it in message.
+		///
+		/// If the message has multiple parts, the parts
+		/// are reported to the PartHandler. If the message
+		/// is not a multi-part message, the content is stored
+		/// in a string available by calling message.getContent().
+		///
+		/// Throws a POP3Exception in case of a POP3-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	void retrieveMessage(int id, std::ostream& ostr);
+		/// Retrieves the raw message with the given id from the
+		/// server and copies it to the given output stream.
+		///
+		/// Throws a POP3Exception in case of a POP3-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	void retrieveHeader(int id, MessageHeader& header);
+		/// Retrieves the message header of the message with the
+		/// given id and stores it in header.
+		///
+		/// For this to work, the server must support the TOP command.
+		///
+		/// Throws a POP3Exception in case of a POP3-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	void deleteMessage(int id);
+		/// Marks the message with the given ID for deletion. The message
+		/// will be deleted when the connection to the server is
+		/// closed by calling close().
+		///
+		/// Throws a POP3Exception in case of a POP3-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	bool sendCommand(const std::string& command, std::string& response);
+		/// Sends the given command verbatim to the server
+		/// and waits for a response.
+		///
+		/// Returns true if the response is positive, false otherwise.
+		///
+		/// Throws a POP3Exception in case of a POP3-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	bool sendCommand(const std::string& command, const std::string& arg, std::string& response);
+		/// Sends the given command verbatim to the server
+		/// and waits for a response.
+		///
+		/// Returns true if the response is positive, false otherwise.
+		///
+		/// Throws a POP3Exception in case of a POP3-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	bool sendCommand(const std::string& command, const std::string& arg1, const std::string& arg2, std::string& response);
+		/// Sends the given command verbatim to the server
+		/// and waits for a response.
+		///
+		/// Returns true if the response is positive, false otherwise.
+		///
+		/// Throws a POP3Exception in case of a POP3-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+protected:
+	static bool isPositive(const std::string& response);
+	
+private:
+	DialogSocket _socket;
+	bool         _isOpen;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_POP3ClientSession_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/ParallelSocketAcceptor.h b/base/poco/Net/include/Poco/Net/ParallelSocketAcceptor.h
new file mode 100644
index 00000000000..514bcfbfa1a
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/ParallelSocketAcceptor.h
@@ -0,0 +1,233 @@
+//
+// ParallelSocketAcceptor.h
+//
+// Library: Net
+// Package: Reactor
+// Module:  ParallelSocketAcceptor
+//
+// Definition of the ParallelSocketAcceptor class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_ParallelSocketAcceptor_INCLUDED
+#define Net_ParallelSocketAcceptor_INCLUDED
+
+
+#include "Poco/Net/ParallelSocketReactor.h"
+#include "Poco/Net/StreamSocket.h"
+#include "Poco/Net/ServerSocket.h"
+#include "Poco/Environment.h"
+#include "Poco/NObserver.h"
+#include "Poco/SharedPtr.h"
+#include <vector>
+
+
+using Poco::Net::Socket;
+using Poco::Net::SocketReactor;
+using Poco::Net::ServerSocket;
+using Poco::Net::StreamSocket;
+using Poco::NObserver;
+using Poco::AutoPtr;
+
+
+namespace Poco {
+namespace Net {
+
+
+template <class ServiceHandler, class SR>
+class ParallelSocketAcceptor
+	/// This class implements the Acceptor part of the Acceptor-Connector design pattern.
+	/// Only the difference from single-threaded version is documented here, For full 
+	/// description see Poco::Net::SocketAcceptor documentation.
+	/// 
+	/// This is a multi-threaded version of SocketAcceptor, it differs from the
+	/// single-threaded version in number of reactors (defaulting to number of processors)
+	/// that can be specified at construction time and is rotated in a round-robin fashion
+	/// by event handler. See ParallelSocketAcceptor::onAccept and 
+	/// ParallelSocketAcceptor::createServiceHandler documentation and implementation for 
+	/// details.
+{
+public:
+	typedef Poco::Net::ParallelSocketReactor<SR> ParallelReactor;
+
+	explicit ParallelSocketAcceptor(ServerSocket& socket,
+		unsigned threads = Poco::Environment::processorCount()):
+		_socket(socket),
+		_pReactor(0),
+		_threads(threads),
+		_next(0)
+		/// Creates a ParallelSocketAcceptor using the given ServerSocket, 
+		/// sets number of threads and populates the reactors vector.
+	{
+		init();
+	}
+
+	ParallelSocketAcceptor(ServerSocket& socket,
+		SocketReactor& reactor,
+		unsigned threads = Poco::Environment::processorCount()):
+		_socket(socket),
+		_pReactor(&reactor),
+		_threads(threads),
+		_next(0)
+		/// Creates a ParallelSocketAcceptor using the given ServerSocket, sets the 
+		/// number of threads, populates the reactors vector and registers itself 
+		/// with the given SocketReactor.
+	{
+		init();
+		_pReactor->addEventHandler(_socket,
+			Poco::Observer<ParallelSocketAcceptor,
+			ReadableNotification>(*this, &ParallelSocketAcceptor::onAccept));
+	}
+
+	virtual ~ParallelSocketAcceptor()
+		/// Destroys the ParallelSocketAcceptor.
+	{
+		try
+		{
+			if (_pReactor)
+			{
+				_pReactor->removeEventHandler(_socket,
+					Poco::Observer<ParallelSocketAcceptor,
+					ReadableNotification>(*this, &ParallelSocketAcceptor::onAccept));
+			}
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	}
+
+	void setReactor(SocketReactor& reactor)
+		/// Sets the reactor for this acceptor.
+	{
+		_pReactor = &reactor;
+		if (!_pReactor->hasEventHandler(_socket, 
+			Poco::Observer<ParallelSocketAcceptor,
+			ReadableNotification>(*this, &ParallelSocketAcceptor::onAccept)))
+		{
+			registerAcceptor(reactor);
+		}
+	}
+	
+	virtual void registerAcceptor(SocketReactor& reactor)
+		/// Registers the ParallelSocketAcceptor with a SocketReactor.
+		///
+		/// A subclass can override this function to e.g.
+		/// register an event handler for timeout event.
+		/// 
+		/// The overriding method must either call the base class
+		/// implementation or register the accept handler on its own.
+	{
+		if (_pReactor)
+			throw Poco::InvalidAccessException("Acceptor already registered.");
+
+		_pReactor = &reactor;
+		_pReactor->addEventHandler(_socket,
+			Poco::Observer<ParallelSocketAcceptor,
+			ReadableNotification>(*this, &ParallelSocketAcceptor::onAccept));
+	}
+	
+	virtual void unregisterAcceptor()
+		/// Unregisters the ParallelSocketAcceptor.
+		///
+		/// A subclass can override this function to e.g.
+		/// unregister its event handler for a timeout event.
+		/// 
+		/// The overriding method must either call the base class
+		/// implementation or unregister the accept handler on its own.
+	{
+		if (_pReactor)
+		{
+			_pReactor->removeEventHandler(_socket,
+				Poco::Observer<ParallelSocketAcceptor,
+				ReadableNotification>(*this, &ParallelSocketAcceptor::onAccept));
+		}
+	}
+	
+	void onAccept(ReadableNotification* pNotification)
+		/// Accepts connection and creates event handler.
+	{
+		pNotification->release();
+		StreamSocket sock = _socket.acceptConnection();
+		_pReactor->wakeUp();
+		createServiceHandler(sock);
+	}
+
+protected:
+	virtual ServiceHandler* createServiceHandler(StreamSocket& socket)
+		/// Create and initialize a new ServiceHandler instance.
+		///
+		/// Subclasses can override this method.
+	{
+		std::size_t next = _next++;
+		if (_next == _reactors.size()) _next = 0;
+		_reactors[next]->wakeUp();
+		return new ServiceHandler(socket, *_reactors[next]);
+	}
+
+	SocketReactor* reactor()
+		/// Returns a pointer to the SocketReactor where
+		/// this SocketAcceptor is registered.
+		///
+		/// The pointer may be null.
+	{
+		return _pReactor;
+	}
+
+	Socket& socket()
+		/// Returns a reference to the SocketAcceptor's socket.
+	{
+		return _socket;
+	}
+
+	void init()
+		/// Populates the reactors vector.
+	{
+		poco_assert (_threads > 0);
+
+		for (unsigned i = 0; i < _threads; ++i)
+			_reactors.push_back(new ParallelReactor);
+	}
+
+	typedef std::vector<typename ParallelReactor::Ptr> ReactorVec;
+
+	ReactorVec& reactors()
+		/// Returns reference to vector of reactors.
+	{
+		return _reactors;
+	}
+
+	SocketReactor* reactor(std::size_t idx)
+		/// Returns reference to the reactor at position idx.
+	{
+		return _reactors.at(idx).get();
+	}
+
+	std::size_t& next()
+		/// Returns reference to the next reactor index.
+	{
+		return _next;
+	}
+
+private:
+	ParallelSocketAcceptor();
+	ParallelSocketAcceptor(const ParallelSocketAcceptor&);
+	ParallelSocketAcceptor& operator = (const ParallelSocketAcceptor&);
+
+	ServerSocket   _socket;
+	SocketReactor* _pReactor;
+	unsigned       _threads;
+	ReactorVec     _reactors;
+	std::size_t    _next;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_ParallelSocketAcceptor_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/ParallelSocketReactor.h b/base/poco/Net/include/Poco/Net/ParallelSocketReactor.h
new file mode 100644
index 00000000000..a7631ce1d94
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/ParallelSocketReactor.h
@@ -0,0 +1,90 @@
+//
+// ParallelSocketReactor.h
+//
+// Library: Net
+// Package: Reactor
+// Module:  ParallelSocketReactor
+//
+// Definition of the ParallelSocketReactor class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_ParallelSocketReactor_INCLUDED
+#define Net_ParallelSocketReactor_INCLUDED
+
+
+#include "Poco/Net/SocketReactor.h"
+#include "Poco/Net/SocketNotification.h"
+#include "Poco/Net/StreamSocket.h"
+#include "Poco/Net/ServerSocket.h"
+#include "Poco/NObserver.h"
+#include "Poco/Thread.h"
+#include "Poco/SharedPtr.h"
+
+
+using Poco::Net::Socket;
+using Poco::Net::SocketReactor;
+using Poco::Net::ReadableNotification;
+using Poco::Net::ShutdownNotification;
+using Poco::Net::ServerSocket;
+using Poco::Net::StreamSocket;
+using Poco::NObserver;
+using Poco::AutoPtr;
+using Poco::Thread;
+
+
+namespace Poco {
+namespace Net {
+
+
+template <class SR>
+class ParallelSocketReactor: public SR
+{
+public:
+	typedef Poco::SharedPtr<ParallelSocketReactor> Ptr;
+
+	ParallelSocketReactor()
+	{
+		_thread.start(*this);
+	}
+	
+	ParallelSocketReactor(const Poco::Timespan& timeout):
+		SR(timeout)
+	{
+		_thread.start(*this);
+	}
+	
+	~ParallelSocketReactor()
+	{
+		try
+		{
+			this->stop();
+			_thread.join();
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	}
+	
+protected:
+	void onIdle()
+	{
+		SR::onIdle();
+		Poco::Thread::yield();
+	}
+	
+private:
+	Poco::Thread _thread;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_ParallelSocketReactor_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/PartHandler.h b/base/poco/Net/include/Poco/Net/PartHandler.h
new file mode 100644
index 00000000000..941dd0305c2
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/PartHandler.h
@@ -0,0 +1,68 @@
+//
+// PartHandler.h
+//
+// Library: Net
+// Package: Messages
+// Module:  PartHandler
+//
+// Definition of the PartHandler class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_PartHandler_INCLUDED
+#define Net_PartHandler_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include <istream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class MessageHeader;
+
+
+class Net_API PartHandler
+	/// The base class for all part or attachment handlers.
+	///
+	/// Part handlers are used for handling email parts and 
+	/// attachments in MIME multipart messages, as well as file 
+	/// uploads via HTML forms.
+	///
+	/// Subclasses must override handlePart().
+{
+public:
+	virtual void handlePart(const MessageHeader& header, std::istream& stream) = 0;
+		/// Called for every part encountered during the processing
+		/// of an email message or an uploaded HTML form.
+		///
+		/// Information about the part can be extracted from
+		/// the given message header. What information can be obtained
+		/// from header depends on the kind of part.
+		///
+		/// The content of the part can be read from stream.
+		
+protected:
+	PartHandler();
+		/// Creates the PartHandler.
+
+	virtual ~PartHandler();
+		/// Destroys the PartHandler.
+
+private:
+	PartHandler(const PartHandler&);
+	PartHandler& operator = (const PartHandler&);
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_PartHandler_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/PartSource.h b/base/poco/Net/include/Poco/Net/PartSource.h
new file mode 100644
index 00000000000..06978d74cdf
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/PartSource.h
@@ -0,0 +1,110 @@
+//
+// PartSource.h
+//
+// Library: Net
+// Package: Messages
+// Module:  PartSource
+//
+// Definition of the PartSource class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_PartSource_INCLUDED
+#define Net_PartSource_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/MessageHeader.h"
+#include <istream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API PartSource
+	/// This abstract class is used for adding parts or attachments
+	/// to mail messages, as well as for uploading files as part of a HTML form.
+{
+public:
+	virtual std::istream& stream() = 0;
+		/// Returns an input stream for reading the
+		/// part data.
+		///
+		/// Subclasses must override this method.
+
+	virtual const std::string& filename() const;
+		/// Returns the filename for the part or attachment.
+		///
+		/// May be overridded by subclasses. The default
+		/// implementation returns an empty string.
+
+	const std::string& mediaType() const;
+		/// Returns the MIME media type for this part or attachment.
+
+	MessageHeader& headers();
+		/// Returns a MessageHeader containing additional header
+		/// fields for the part.
+
+	const MessageHeader& headers() const;
+		/// Returns a MessageHeader containing additional header
+		/// fields for the part.
+
+	virtual std::streamsize getContentLength() const;
+		/// Returns the content length for this part
+		/// which may be UNKNOWN_CONTENT_LENGTH if
+		/// not available.
+
+	virtual ~PartSource();
+		/// Destroys the PartSource.
+
+	static const int UNKNOWN_CONTENT_LENGTH;
+
+protected:
+	PartSource();
+		/// Creates the PartSource, using
+		/// the application/octet-stream MIME type.
+
+	PartSource(const std::string& mediaType);
+		/// Creates the PartSource, using the
+		/// given MIME type.
+
+private:
+	PartSource(const PartSource&);
+	PartSource& operator = (const PartSource&);
+
+	std::string _mediaType;
+	MessageHeader _headers;
+};
+
+
+//
+// inlines
+//
+inline const std::string& PartSource::mediaType() const
+{
+	return _mediaType;
+}
+
+
+inline MessageHeader& PartSource::headers()
+{
+	return _headers;
+}
+
+
+inline const MessageHeader& PartSource::headers() const
+{
+	return _headers;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_PartSource_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/PartStore.h b/base/poco/Net/include/Poco/Net/PartStore.h
new file mode 100644
index 00000000000..a7be187c804
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/PartStore.h
@@ -0,0 +1,106 @@
+//
+// PartStore.h
+//
+// Library: Net
+// Package: Messages
+// Module:  PartStore
+//
+// Definition of the PartStore class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_PartStore_INCLUDED
+#define Net_PartStore_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/PartSource.h"
+#include "Poco/FileStream.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API PartStore: public PartSource
+	/// A parent class for part stores storing message parts.
+{
+public:
+	PartStore(const std::string& mediaType);
+		/// Creates the PartStore for the given MIME type.
+
+	~PartStore();
+		/// Destroys the PartFileStore.
+
+private:
+	PartStore();
+};
+
+
+class Net_API FilePartStore: public PartStore
+	/// An implementation of PartSource for persisting
+	/// parts (usually email attachment files) to the file system.
+{
+public:
+	FilePartStore(const std::string& content, const std::string& mediaType, const std::string& filename = "");
+		/// Creates the FilePartStore for the given MIME type.
+		/// For security purposes, attachment filename is NOT used to save file to the file system.
+		/// A unique temporary file name is used to persist the file.
+		/// The given filename parameter is the message part (attachment) filename (see filename()) only.
+		///
+		/// Throws an exception if the file cannot be opened.
+
+	~FilePartStore();
+		/// Destroys the FilePartStore.
+
+	std::istream& stream();
+		/// Returns a file input stream for the given file.
+
+	const std::string& filename() const;
+		/// Returns the filename portion of the path.
+		/// This is the name under which the file is known
+		/// to the user of this class (typically, MailMessage
+		/// class). The real name of the file as saved
+		/// to the filesystem can be obtained by calling
+		/// path() member function.
+
+	const std::string& path() const;
+		/// Returns the full path to the file as saved
+		/// to the file system. For security reasons,
+		/// file is not saved under the real file name
+		/// (as specified by the user).
+
+private:
+	std::string      _filename;
+	std::string      _path;
+	Poco::FileStream _fstr;
+};
+
+
+class PartStoreFactory
+	/// Parent factory class for part stores creation.
+{
+public:
+	virtual PartSource* createPartStore(const std::string& content, const std::string& mediaType, const std::string& filename = "") = 0;
+};
+
+
+class FilePartStoreFactory: public PartStoreFactory
+{
+public:
+	PartSource* createPartStore(const std::string& content, const std::string& mediaType, const std::string& filename = "")
+	{
+		return new FilePartStore(content, mediaType, filename);
+	}
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_PartStore_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/PollSet.h b/base/poco/Net/include/Poco/Net/PollSet.h
new file mode 100644
index 00000000000..9b24e135915
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/PollSet.h
@@ -0,0 +1,86 @@
+//
+// PollSet.h
+//
+// Library: Net
+// Package: Sockets
+// Module:  PollSet
+//
+// Definition of the PollSet class.
+//
+// Copyright (c) 2016, Applied Informatics Software Engineering GmbH.
+// All rights reserved.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_PollSet_INCLUDED
+#define Net_PollSet_INCLUDED
+
+
+#include "Poco/Net/Socket.h"
+#include <map>
+
+
+namespace Poco {
+namespace Net {
+
+
+class PollSetImpl;
+
+
+class Net_API PollSet
+	/// A set of sockets that can be efficiently polled as a whole.
+	///
+	/// If supported, PollSet is implemented using epoll (Linux) or
+	/// poll (BSD) APIs. A fallback implementation using select()
+	/// is also provided.
+{
+public:
+	enum Mode
+	{
+		POLL_READ  = 0x01,
+		POLL_WRITE = 0x02,
+		POLL_ERROR = 0x04
+	};
+
+	typedef std::map<Poco::Net::Socket, int> SocketModeMap;
+
+	PollSet();
+		/// Creates an empty PollSet.
+
+	~PollSet();
+		/// Destroys the PollSet.
+
+	void add(const Poco::Net::Socket& socket, int mode);
+		/// Adds the given socket to the set, for polling with
+		/// the given mode, which can be an OR'd combination of
+		/// POLL_READ, POLL_WRITE and POLL_ERROR.
+
+	void remove(const Poco::Net::Socket& socket);
+		/// Removes the given socket from the set.
+
+	void update(const Poco::Net::Socket& socket, int mode);
+		/// Updates the mode of the given socket.
+
+	void clear();
+		/// Removes all sockets from the PollSet.
+
+	SocketModeMap poll(const Poco::Timespan& timeout);
+		/// Waits until the state of at least one of the PollSet's sockets
+		/// changes accordingly to its mode, or the timeout expires.
+		/// Returns a PollMap containing the sockets that have had
+		/// their state changed.
+
+private:
+	PollSetImpl* _pImpl;
+
+	PollSet(const PollSet&);
+	PollSet& operator = (const PollSet&);
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_PollSet_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/QuotedPrintableDecoder.h b/base/poco/Net/include/Poco/Net/QuotedPrintableDecoder.h
new file mode 100644
index 00000000000..b456660f6e1
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/QuotedPrintableDecoder.h
@@ -0,0 +1,86 @@
+//
+// QuotedPrintableDecoder.h
+//
+// Library: Net
+// Package: Messages
+// Module:  QuotedPrintableDecoder
+//
+// Definition of the QuotedPrintableDecoder class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_QuotedPrintableDecoder_INCLUDED
+#define Net_QuotedPrintableDecoder_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include <istream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API QuotedPrintableDecoderBuf: public Poco::UnbufferedStreamBuf
+	/// This streambuf decodes all quoted-printable (see RFC 2045) 
+	/// encoded data read from the istream connected to it.
+	///
+	/// Note: For performance reasons, the characters 
+	/// are read directly from the given istream's 
+	/// underlying streambuf, so the state
+	/// of the istream will not reflect that of
+	/// its streambuf.
+{
+public:
+	QuotedPrintableDecoderBuf(std::istream& istr);
+	~QuotedPrintableDecoderBuf();
+	
+private:
+	int readFromDevice();
+
+	std::streambuf& _buf;
+};
+
+
+class Net_API QuotedPrintableDecoderIOS: public virtual std::ios
+	/// The base class for QuotedPrintableDecoder.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	QuotedPrintableDecoderIOS(std::istream& istr);
+	~QuotedPrintableDecoderIOS();
+	QuotedPrintableDecoderBuf* rdbuf();
+
+protected:
+	QuotedPrintableDecoderBuf _buf;
+};
+
+
+class Net_API QuotedPrintableDecoder: public QuotedPrintableDecoderIOS, public std::istream
+	/// This istream decodes all quoted-printable (see RFC 2045)
+	/// encoded data read from the istream connected to it.
+	///
+	/// Note: For performance reasons, the characters 
+	/// are read directly from the given istream's 
+	/// underlying streambuf, so the state
+	/// of the istream will not reflect that of
+	/// its streambuf.
+{
+public:
+	QuotedPrintableDecoder(std::istream& istr);
+	~QuotedPrintableDecoder();
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_QuotedPrintableDecoder_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/QuotedPrintableEncoder.h b/base/poco/Net/include/Poco/Net/QuotedPrintableEncoder.h
new file mode 100644
index 00000000000..d0e7d74549b
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/QuotedPrintableEncoder.h
@@ -0,0 +1,85 @@
+//
+// QuotedPrintableEncoder.h
+//
+// Library: Net
+// Package: Messages
+// Module:  QuotedPrintableEncoder
+//
+// Definition of the QuotedPrintableEncoder class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_QuotedPrintableEncoder_INCLUDED
+#define Net_QuotedPrintableEncoder_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include <ostream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API QuotedPrintableEncoderBuf: public Poco::UnbufferedStreamBuf
+	/// This streambuf encodes all data written
+	/// to it in quoted-printable encoding (see RFC 2045)
+	/// and forwards it to a connected ostream.
+{
+public:
+	QuotedPrintableEncoderBuf(std::ostream& ostr);
+	~QuotedPrintableEncoderBuf();
+	int close();
+	
+private:
+	int writeToDevice(char c);
+	void writeEncoded(char c);
+	void writeRaw(char c);
+
+	int           _pending;
+	int           _lineLength;
+	std::ostream& _ostr;
+};
+
+
+class Net_API QuotedPrintableEncoderIOS: public virtual std::ios
+	/// The base class for QuotedPrintableEncoder.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	QuotedPrintableEncoderIOS(std::ostream& ostr);
+	~QuotedPrintableEncoderIOS();
+	int close();
+	QuotedPrintableEncoderBuf* rdbuf();
+
+protected:
+	QuotedPrintableEncoderBuf _buf;
+};
+
+
+class Net_API QuotedPrintableEncoder: public QuotedPrintableEncoderIOS, public std::ostream
+	/// This ostream encodes all data
+	/// written to it in quoted-printable encoding
+	/// (see RFC 2045) and forwards it to a connected ostream.
+	/// Always call close() when done
+	/// writing data, to ensure proper
+	/// completion of the encoding operation.
+{
+public:
+	QuotedPrintableEncoder(std::ostream& ostr);
+	~QuotedPrintableEncoder();
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_QuotedPrintableEncoder_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/RawSocket.h b/base/poco/Net/include/Poco/Net/RawSocket.h
new file mode 100644
index 00000000000..3638b20e452
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/RawSocket.h
@@ -0,0 +1,161 @@
+//
+// RawSocket.h
+//
+// Library: Net
+// Package: Sockets
+// Module:  RawSocket
+//
+// Definition of the RawSocket class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_RawSocket_INCLUDED
+#define Net_RawSocket_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/Socket.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API RawSocket: public Socket
+	/// This class provides an interface to a
+	/// raw IP socket.
+{
+public:
+	RawSocket();
+		/// Creates an unconnected IPv4 raw socket.
+
+	RawSocket(SocketAddress::Family family, int proto = IPPROTO_RAW);
+		/// Creates an unconnected raw socket.
+		///
+		/// The socket will be created for the
+		/// given address family.
+
+	RawSocket(const SocketAddress& address, bool reuseAddress = false);
+		/// Creates a raw socket and binds it
+		/// to the given address.
+		///
+		/// Depending on the address family, the socket
+		/// will be either an IPv4 or an IPv6 socket.
+
+	RawSocket(const Socket& socket);
+		/// Creates the RawSocket with the SocketImpl
+		/// from another socket. The SocketImpl must be
+		/// a RawSocketImpl, otherwise an InvalidArgumentException
+		/// will be thrown.
+
+	~RawSocket();
+		/// Destroys the RawSocket.
+
+	RawSocket& operator = (const Socket& socket);
+		/// Assignment operator.
+		///
+		/// Releases the socket's SocketImpl and
+		/// attaches the SocketImpl from the other socket and
+		/// increments the reference count of the SocketImpl.	
+
+	void connect(const SocketAddress& address);
+		/// Restricts incoming and outgoing
+		/// packets to the specified address.
+		///
+		/// Calls to connect() cannot come before calls to bind().
+
+	void bind(const SocketAddress& address, bool reuseAddress = false);
+		/// Bind a local address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. 
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// Calls to connect() cannot come before calls to bind().
+
+	void bind(const SocketAddress& address, bool reuseAddress, bool reusePort);
+		/// Bind a local address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. 
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// If reusePort is true, sets the SO_REUSEPORT
+		/// socket option.
+		///
+		/// Calls to connect() cannot come before calls to bind().
+
+	int sendBytes(const void* buffer, int length, int flags = 0);
+		/// Sends the contents of the given buffer through
+		/// the socket.
+		///
+		/// Returns the number of bytes sent, which may be
+		/// less than the number of bytes specified.
+
+	int receiveBytes(void* buffer, int length, int flags = 0);
+		/// Receives data from the socket and stores it
+		/// in buffer. Up to length bytes are received.
+		///
+		/// Returns the number of bytes received.
+
+	int sendTo(const void* buffer, int length, const SocketAddress& address, int flags = 0);
+		/// Sends the contents of the given buffer through
+		/// the socket to the given address.
+		///
+		/// Returns the number of bytes sent, which may be
+		/// less than the number of bytes specified.
+
+	int receiveFrom(void* buffer, int length, SocketAddress& address, int flags = 0);
+		/// Receives data from the socket and stores it
+		/// in buffer. Up to length bytes are received.
+		/// Stores the address of the sender in address.
+		///
+		/// Returns the number of bytes received.
+
+	void setBroadcast(bool flag);
+		/// Sets the value of the SO_BROADCAST socket option.
+		///
+		/// Setting this flag allows sending datagrams to
+		/// the broadcast address.
+	
+	bool getBroadcast() const;
+		/// Returns the value of the SO_BROADCAST socket option.
+
+protected:
+	RawSocket(SocketImpl* pImpl);
+		/// Creates the Socket and attaches the given SocketImpl.
+		/// The socket takes ownership of the SocketImpl.
+		///
+		/// The SocketImpl must be a StreamSocketImpl, otherwise
+		/// an InvalidArgumentException will be thrown.
+};
+
+
+//
+// inlines
+//
+inline void RawSocket::setBroadcast(bool flag)
+{
+	impl()->setBroadcast(flag);
+}
+
+
+inline bool RawSocket::getBroadcast() const
+{
+	return impl()->getBroadcast();
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_RawSocket_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/RawSocketImpl.h b/base/poco/Net/include/Poco/Net/RawSocketImpl.h
new file mode 100644
index 00000000000..df10b645874
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/RawSocketImpl.h
@@ -0,0 +1,56 @@
+//
+// RawSocketImpl.h
+//
+// Library: Net
+// Package: Sockets
+// Module:  RawSocketImpl
+//
+// Definition of the RawSocketImpl class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_RawSocketImpl_INCLUDED
+#define Net_RawSocketImpl_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/SocketImpl.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API RawSocketImpl: public SocketImpl
+	/// This class implements a raw socket.
+{
+public:
+	RawSocketImpl();
+		/// Creates an unconnected IPv4 raw socket with IPPROTO_RAW.
+		
+	RawSocketImpl(SocketAddress::Family family, int proto = IPPROTO_RAW);
+		/// Creates an unconnected raw socket.
+		///
+		/// The socket will be created for the
+		/// given address family.
+
+	RawSocketImpl(poco_socket_t sockfd);
+		/// Creates a RawSocketImpl using the given native socket.
+				
+protected:
+	void init(int af);
+	void init2(int af, int proto);
+	
+	~RawSocketImpl();
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_RawSocketImpl_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/RemoteSyslogChannel.h b/base/poco/Net/include/Poco/Net/RemoteSyslogChannel.h
new file mode 100644
index 00000000000..848b1634fb3
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/RemoteSyslogChannel.h
@@ -0,0 +1,158 @@
+//
+// RemoteSyslogChannel.h
+//
+// Library: Net
+// Package: Logging
+// Module:  RemoteSyslogChannel
+//
+// Definition of the RemoteSyslogChannel class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_RemoteSyslogChannel_INCLUDED
+#define Net_RemoteSyslogChannel_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Channel.h"
+#include "Poco/Mutex.h"
+#include "Poco/Net/DatagramSocket.h"
+#include "Poco/Net/SocketAddress.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API RemoteSyslogChannel: public Poco::Channel
+	/// This Channel implements remote syslog logging over UDP according
+	/// to RFC 5424 "The Syslog Protocol"
+	/// and RFC 5426 "Transmission of syslog messages over UDP".
+	///
+	/// In addition, RemoteSyslogListener also supports the "old" BSD syslog
+	/// protocol, as described in RFC 3164.
+	///
+	/// RFC 5425 structured data can be passed via the "structured-data"
+	/// property of the log Message. The content of the "structured-data"
+	/// property must be correct according to RFC 5425.
+	///
+	/// Example:
+	///     msg.set("structured-data", "[exampleSDID@32473 iut=\"3\" eventSource=\"Application\" eventID=\"1011\"]");
+{
+public:
+	static const std::string BSD_TIMEFORMAT;
+	static const std::string SYSLOG_TIMEFORMAT;
+
+	enum Severity
+	{
+		SYSLOG_EMERGENCY     = 0, /// Emergency: system is unusable
+		SYSLOG_ALERT         = 1, /// Alert: action must be taken immediately
+		SYSLOG_CRITICAL      = 2, /// Critical: critical conditions
+		SYSLOG_ERROR         = 3, /// Error: error conditions
+		SYSLOG_WARNING       = 4, /// Warning: warning conditions
+		SYSLOG_NOTICE        = 5, /// Notice: normal but significant condition
+		SYSLOG_INFORMATIONAL = 6, /// Informational: informational messages
+		SYSLOG_DEBUG         = 7  /// Debug: debug-level messages
+	};
+
+	enum Facility
+	{
+		SYSLOG_KERN     = ( 0<<3), /// kernel messages
+		SYSLOG_USER     = ( 1<<3), /// random user-level messages
+		SYSLOG_MAIL     = ( 2<<3), /// mail system
+		SYSLOG_DAEMON   = ( 3<<3), /// system daemons
+		SYSLOG_AUTH     = ( 4<<3), /// security/authorization messages
+		SYSLOG_SYSLOG   = ( 5<<3), /// messages generated internally by syslogd
+		SYSLOG_LPR      = ( 6<<3), /// line printer subsystem
+		SYSLOG_NEWS     = ( 7<<3), /// network news subsystem
+		SYSLOG_UUCP     = ( 8<<3), /// UUCP subsystem
+		SYSLOG_CRON     = ( 9<<3), /// clock daemon
+		SYSLOG_AUTHPRIV = (10<<3), /// security/authorization messages (private)
+		SYSLOG_FTP      = (11<<3), /// ftp daemon
+		SYSLOG_NTP      = (12<<3), /// ntp subsystem
+		SYSLOG_LOGAUDIT = (13<<3), /// log audit
+		SYSLOG_LOGALERT = (14<<3), /// log alert
+		SYSLOG_CLOCK    = (15<<3), /// clock daemon
+		SYSLOG_LOCAL0   = (16<<3), /// reserved for local use
+		SYSLOG_LOCAL1   = (17<<3), /// reserved for local use
+		SYSLOG_LOCAL2   = (18<<3), /// reserved for local use
+		SYSLOG_LOCAL3   = (19<<3), /// reserved for local use
+		SYSLOG_LOCAL4   = (20<<3), /// reserved for local use
+		SYSLOG_LOCAL5   = (21<<3), /// reserved for local use
+		SYSLOG_LOCAL6   = (22<<3), /// reserved for local use
+		SYSLOG_LOCAL7   = (23<<3)  /// reserved for local use
+	};
+
+	enum
+	{
+		SYSLOG_PORT = 514
+	};
+
+	RemoteSyslogChannel();
+		/// Creates a RemoteSyslogChannel.
+
+	RemoteSyslogChannel(const std::string& address, const std::string& name, int facility = SYSLOG_USER, bool bsdFormat = false);
+		/// Creates a RemoteSyslogChannel with the given target address, name, and facility.
+		/// If bsdFormat is true, messages are formatted according to RFC 3164.
+
+	void open();
+		/// Opens the RemoteSyslogChannel.
+
+	void close();
+		/// Closes the RemoteSyslogChannel.
+
+	void log(const Message& msg);
+		/// Sends the message's text to the syslog service.
+
+	void setProperty(const std::string& name, const std::string& value);
+		/// Sets the property with the given value.
+		///
+		/// The following properties are supported:
+		///     * name:      The name used to identify the source of log messages.
+		///     * facility:  The facility added to each log message. See the Facility enumeration for a list of supported values.
+		///                  The LOG_ prefix can be omitted and values are case insensitive (e.g. a facility value "mail" is recognized as SYSLOG_MAIL)
+		///     * format:    "bsd"/"rfc3164" (RFC 3164 format) or "new"/"rfc5424" (default)
+		///     * loghost:   The target IP address or host name where log messages are sent. Optionally, a port number (separated
+		///                  by a colon) can also be specified.
+		///     * host:      (optional) Host name included in syslog messages. If not specified, the host's real domain name or
+		///                  IP address will be used.
+
+	std::string getProperty(const std::string& name) const;
+		/// Returns the value of the property with the given name.
+
+	static void registerChannel();
+		/// Registers the channel with the global LoggingFactory.
+
+	static const std::string PROP_NAME;
+	static const std::string PROP_FACILITY;
+	static const std::string PROP_FORMAT;
+	static const std::string PROP_LOGHOST;
+	static const std::string PROP_HOST;
+	static const std::string STRUCTURED_DATA;
+
+protected:
+	~RemoteSyslogChannel();
+	static int getPrio(const Message& msg);
+
+private:
+	std::string _logHost;
+	std::string _name;
+	std::string _host;
+	int  _facility;
+	bool _bsdFormat;
+	DatagramSocket _socket;
+	SocketAddress _socketAddress;
+	bool _open;
+	mutable Poco::FastMutex _mutex;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_RemoteSyslogChannel_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/RemoteSyslogListener.h b/base/poco/Net/include/Poco/Net/RemoteSyslogListener.h
new file mode 100644
index 00000000000..93895244c2c
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/RemoteSyslogListener.h
@@ -0,0 +1,121 @@
+//
+// RemoteSyslogListener.h
+//
+// Library: Net
+// Package: Logging
+// Module:  RemoteSyslogListener
+//
+// Definition of the RemoteSyslogListener class.
+//
+// Copyright (c) 2007-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_RemoteSyslogListener_INCLUDED
+#define Net_RemoteSyslogListener_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/ThreadPool.h"
+#include "Poco/SplitterChannel.h"
+#include "Poco/NotificationQueue.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class RemoteUDPListener;
+class SyslogParser;
+
+
+class Net_API RemoteSyslogListener: public Poco::SplitterChannel
+	/// RemoteSyslogListener implements listening for syslog messages
+	/// sent over UDP, according to RFC 5424 "The Syslog Protocol"
+	/// and RFC 5426 "Transmission of syslog messages over UDP".
+	///
+	/// In addition, RemoteSyslogListener also supports the "old" BSD syslog
+	/// protocol, as described in RFC 3164.
+	///
+	/// The RemoteSyslogListener is a subclass of Poco::SplitterChannel.
+	/// Every received log message is sent to the channels registered
+	/// with addChannel() or the "channel" property.
+	///
+	/// Poco::Message objects created by RemoteSyslogListener will have
+	/// the following named parameters:
+	///   - addr: IP address of the host/interface sending the message.
+	///   - host: host name; only for "new" syslog messages.
+	///   - app:  application name; only for "new" syslog messages.
+	///   - structured-data: RFC 5424 structured data, or empty if not present.
+{
+public:
+	RemoteSyslogListener();
+		/// Creates the RemoteSyslogListener.
+
+	RemoteSyslogListener(Poco::UInt16 port);
+		/// Creates the RemoteSyslogListener, listening on the given port number.
+
+	RemoteSyslogListener(Poco::UInt16 port, int threads);
+		/// Creates the RemoteSyslogListener, listening on the given port number
+		/// and using the number of threads for message processing.
+
+	void setProperty(const std::string& name, const std::string& value);
+		/// Sets the property with the given value.
+		///
+		/// The following properties are supported:
+		///     * port: The UDP port number where to listen for UDP packets
+		///       containing syslog messages. If 0 is specified, does not
+		///       listen for UDP messages.
+		///     * threads: The number of parser threads processing
+		///       received syslog messages. Defaults to 1. A maximum
+		///       of 16 threads is supported.
+
+	std::string getProperty(const std::string& name) const;
+		/// Returns the value of the property with the given name.
+
+	void open();
+		/// Starts the listener.
+
+	void close();
+		/// Stops the listener.
+
+	void processMessage(const std::string& messageText);
+		/// Parses a single line of text containing a syslog message
+		/// and sends it down the filter chain.
+
+	void enqueueMessage(const std::string& messageText, const Poco::Net::SocketAddress& senderAddress);
+		/// Enqueues a single line of text containing a syslog message
+		/// for asynchronous processing by a parser thread.
+
+	static void registerChannel();
+		/// Registers the channel with the global LoggingFactory.
+
+	static const std::string PROP_PORT;
+	static const std::string PROP_THREADS;
+
+    static const std::string LOG_PROP_APP;
+    static const std::string LOG_PROP_HOST;
+	static const std::string LOG_PROP_STRUCTURED_DATA;
+
+protected:
+	~RemoteSyslogListener();
+		/// Destroys the RemoteSyslogListener.
+
+private:
+	RemoteUDPListener*      _pListener;
+	SyslogParser*           _pParser;
+	Poco::ThreadPool        _threadPool;
+	Poco::NotificationQueue _queue;
+	Poco::UInt16            _port;
+	int                     _threads;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_RemoteSyslogListener_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/SMTPChannel.h b/base/poco/Net/include/Poco/Net/SMTPChannel.h
new file mode 100644
index 00000000000..373d93ded40
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/SMTPChannel.h
@@ -0,0 +1,108 @@
+//
+// SMTPChannel.h
+//
+// Library: Net
+// Package: Logging
+// Module:  SMTPChannel
+//
+// Definition of the SMTPChannel class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_SMTPChannel_INCLUDED
+#define Net_SMTPChannel_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Channel.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API SMTPChannel: public Poco::Channel
+	/// This Channel implements SMTP (email) logging.
+{
+public:
+	SMTPChannel();
+		/// Creates a SMTPChannel.
+		
+	SMTPChannel(const std::string& mailhost, const std::string& sender, const std::string& recipient);
+		/// Creates a SMTPChannel with the given target mailhost, sender, and recipient.
+	
+	void open();
+		/// Opens the SMTPChannel.
+		
+	void close();
+		/// Closes the SMTPChannel.
+		
+	void log(const Message& msg);
+		/// Sends the message's text to the recipient.
+		
+	void setProperty(const std::string& name, const std::string& value);
+		/// Sets the property with the given value.
+		///
+		/// The following properties are supported:
+		///     * mailhost:   The SMTP server. Default is "localhost".
+		///     * sender:     The sender address.
+		///     * recipient:  The recipient address.
+		///     * local:      If true, local time is used. Default is true.
+		///     * attachment: Filename of the file to attach.
+		///     * type:       Content type of the file to attach.
+		///     * delete:     Boolean value indicating whether to delete 
+		///                   the attachment file after sending.
+		///     * throw:      Boolean value indicating whether to throw 
+		///                   exception upon failure.
+		
+	std::string getProperty(const std::string& name) const;
+		/// Returns the value of the property with the given name.
+
+	static void registerChannel();
+		/// Registers the channel with the global LoggingFactory.
+
+	static const std::string PROP_MAILHOST;
+	static const std::string PROP_SENDER;
+	static const std::string PROP_RECIPIENT;
+	static const std::string PROP_LOCAL;
+	static const std::string PROP_ATTACHMENT;
+	static const std::string PROP_TYPE;
+	static const std::string PROP_DELETE;
+	static const std::string PROP_THROW;
+
+protected:
+	~SMTPChannel();
+
+private:
+	bool isTrue(const std::string& value) const;
+
+	std::string _mailHost;
+	std::string _sender;
+	std::string _recipient;
+	bool        _local;
+	std::string _attachment;
+	std::string _type;
+	bool        _delete;
+	bool        _throw;
+};
+
+
+inline bool SMTPChannel::isTrue(const std::string& value) const
+{
+	return ((0 == icompare(value, "true")) ||
+			(0 == icompare(value, "t")) ||
+			(0 == icompare(value, "yes")) ||
+			(0 == icompare(value, "y")));
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_SMTPChannel_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/SMTPClientSession.h b/base/poco/Net/include/Poco/Net/SMTPClientSession.h
new file mode 100644
index 00000000000..5edf999598b
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/SMTPClientSession.h
@@ -0,0 +1,234 @@
+//
+// SMTPClientSession.h
+//
+// Library: Net
+// Package: Mail
+// Module:  SMTPClientSession
+//
+// Definition of the SMTPClientSession class.
+//
+// Copyright (c) 2005-2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_SMTPClientSession_INCLUDED
+#define Net_SMTPClientSession_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/DialogSocket.h"
+#include "Poco/DigestEngine.h"
+#include "Poco/Timespan.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class MailMessage;
+
+
+class Net_API SMTPClientSession
+	/// This class implements an Simple Mail
+	/// Transfer Protocol (SMTP, RFC 2821)
+	/// client for sending e-mail messages.
+{
+public:
+	typedef std::vector<std::string> Recipients;
+
+	enum
+	{
+		SMTP_PORT = 25
+	};
+
+	enum LoginMethod
+	{
+		AUTH_NONE,
+		AUTH_CRAM_MD5,
+		AUTH_CRAM_SHA1,
+		AUTH_LOGIN,
+		AUTH_PLAIN,
+		AUTH_XOAUTH2 
+	};
+
+	explicit SMTPClientSession(const StreamSocket& socket);
+		/// Creates the SMTPClientSession using
+		/// the given socket, which must be connected
+		/// to a SMTP server.
+
+	SMTPClientSession(const std::string& host, Poco::UInt16 port = SMTP_PORT);
+		/// Creates the SMTPClientSession using a socket connected
+		/// to the given host and port.
+
+	virtual ~SMTPClientSession();
+		/// Destroys the SMTPClientSession.
+
+	void setTimeout(const Poco::Timespan& timeout);
+		/// Sets the timeout for socket read operations.
+		
+	Poco::Timespan getTimeout() const;
+		/// Returns the timeout for socket read operations.
+
+	void login(const std::string& hostname);
+		/// Greets the SMTP server by sending a EHLO command
+		/// with the given hostname as argument.
+		///
+		/// If the server does not understand the EHLO command,
+		/// a HELO command is sent instead.
+		///
+		/// Throws a SMTPException in case of a SMTP-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	void login();
+		/// Calls login(hostname) with the current host name.
+
+	void login(const std::string& hostname, LoginMethod loginMethod, const std::string& username, const std::string& password);
+		/// Logs in to the SMTP server using the given authentication method and the given
+		/// credentials.
+
+	void login(LoginMethod loginMethod, const std::string& username, const std::string& password);
+		/// Logs in to the SMTP server using the given authentication method and the given
+		/// credentials.
+		
+	void open();
+		/// Reads the initial response from the SMTP server.
+		///
+		/// Usually called implicitly through login(), but can
+		/// also be called explicitly to implement different forms
+		/// of SMTP authentication.
+		///
+		/// Does nothing if called more than once.
+
+	void close();
+		/// Sends a QUIT command and closes the connection to the server.	
+		///
+		/// Throws a SMTPException in case of a SMTP-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	void sendMessage(const MailMessage& message);
+		/// Sends the given mail message by sending a MAIL FROM command,
+		/// a RCPT TO command for every recipient, and a DATA command with
+		/// the message headers and content. Using this function results in
+		/// RCPT TO commands list generated from the recipient list supplied
+		/// with the message itself.
+		///
+		/// Throws a SMTPException in case of a SMTP-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	void sendMessage(const MailMessage& message, const Recipients& recipients);
+		/// Sends the given mail message by sending a MAIL FROM command,
+		/// a RCPT TO command for every recipient, and a DATA command with
+		/// the message headers and content. Using this function results in
+		/// message header being generated from the supplied recipients list.
+		///
+		/// Throws a SMTPException in case of a SMTP-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	void sendMessage(std::istream& istr);
+		/// Sends the mail message from the supplied stream. Content of the stream
+		/// is copied without any checking. Only the completion status is checked and,
+		/// if not valid, SMTPExcpetion is thrown.
+
+	int sendCommand(const std::string& command, std::string& response);
+		/// Sends the given command verbatim to the server
+		/// and waits for a response.
+		///
+		/// Throws a SMTPException in case of a SMTP-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	int sendCommand(const std::string& command, const std::string& arg, std::string& response);
+		/// Sends the given command verbatim to the server
+		/// and waits for a response.
+		///
+		/// Throws a SMTPException in case of a SMTP-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	void sendAddresses(const std::string& from, const Recipients& recipients);
+		/// Sends the message preamble by sending a MAIL FROM command,
+		/// and a RCPT TO command for every recipient.
+		///
+		/// Throws a SMTPException in case of a SMTP-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+	void sendData();
+		/// Sends the message preamble by sending a DATA command.
+		///
+		/// Throws a SMTPException in case of a SMTP-specific error, or a
+		/// NetException in case of a general network communication failure.
+
+protected:
+	enum StatusClass
+	{
+		SMTP_POSITIVE_COMPLETION   = 2,
+		SMTP_POSITIVE_INTERMEDIATE = 3,
+		SMTP_TRANSIENT_NEGATIVE    = 4,
+		SMTP_PERMANENT_NEGATIVE    = 5
+	};
+	enum
+	{
+		DEFAULT_TIMEOUT = 30000000 // 30 seconds default timeout for socket operations	
+	};
+
+	static bool isPositiveCompletion(int status);
+	static bool isPositiveIntermediate(int status);
+	static bool isTransientNegative(int status);
+	static bool isPermanentNegative(int status);
+
+	void login(const std::string& hostname, std::string& response);
+	void loginUsingCRAMMD5(const std::string& username, const std::string& password);
+	void loginUsingCRAMSHA1(const std::string& username, const std::string& password);
+	void loginUsingCRAM(const std::string& username, const std::string& method, Poco::DigestEngine& hmac);
+	void loginUsingLogin(const std::string& username, const std::string& password);
+	void loginUsingPlain(const std::string& username, const std::string& password);
+	void loginUsingXOAUTH2(const std::string& username, const std::string& password);
+	DialogSocket& socket();
+
+private:
+	void sendCommands(const MailMessage& message, const Recipients* pRecipients = 0);
+	void transportMessage(const MailMessage& message);
+
+	DialogSocket _socket;
+	bool         _isOpen;
+};
+
+
+//
+// inlines
+//
+inline bool SMTPClientSession::isPositiveCompletion(int status)
+{
+	return status/100 == SMTP_POSITIVE_COMPLETION;
+}
+
+
+inline bool SMTPClientSession::isPositiveIntermediate(int status)
+{
+	return status/100 == SMTP_POSITIVE_INTERMEDIATE;
+}
+
+
+inline bool SMTPClientSession::isTransientNegative(int status)
+{
+	return status/100 == SMTP_TRANSIENT_NEGATIVE;
+}
+
+
+inline bool SMTPClientSession::isPermanentNegative(int status)
+{
+	return status/100 == SMTP_PERMANENT_NEGATIVE;
+}
+
+
+inline DialogSocket& SMTPClientSession::socket()
+{
+	return _socket;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_SMTPClientSession_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/ServerSocket.h b/base/poco/Net/include/Poco/Net/ServerSocket.h
new file mode 100644
index 00000000000..d8aca6790ae
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/ServerSocket.h
@@ -0,0 +1,230 @@
+//
+// ServerSocket.h
+//
+// Library: Net
+// Package: Sockets
+// Module:  ServerSocket
+//
+// Definition of the ServerSocket class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_ServerSocket_INCLUDED
+#define Net_ServerSocket_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/Socket.h"
+#include "Poco/Net/StreamSocket.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API ServerSocket: public Socket
+	/// This class provides an interface to a
+	/// TCP server socket.
+{
+public:
+	ServerSocket();
+		/// Creates a server socket.
+		///
+		/// The server socket must be bound to
+		/// an address and put into listening state.
+
+	ServerSocket(const Socket& socket);
+		/// Creates the ServerSocket with the SocketImpl
+		/// from another socket. The SocketImpl must be
+		/// a ServerSocketImpl, otherwise an InvalidArgumentException
+		/// will be thrown.
+
+	ServerSocket(const SocketAddress& address, int backlog = 64);
+		/// Creates a server socket, binds it
+		/// to the given address and puts it in listening
+		/// state.
+		///
+		/// After successful construction, the server socket
+		/// is ready to accept connections.
+
+	ServerSocket(Poco::UInt16 port, int backlog = 64);
+		/// Creates a server socket, binds it
+		/// to the given port and puts it in listening
+		/// state.
+		///
+		/// After successful construction, the server socket
+		/// is ready to accept connections.
+
+	virtual ~ServerSocket();
+		/// Destroys the StreamSocket.
+
+	ServerSocket& operator = (const Socket& socket);
+		/// Assignment operator.
+		///
+		/// Releases the socket's SocketImpl and
+		/// attaches the SocketImpl from the other socket and
+		/// increments the reference count of the SocketImpl.	
+
+	virtual void bind(const SocketAddress& address, bool reuseAddress = false);
+		/// Binds a local address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. TCP clients should not bind a socket to a
+		/// specific address.
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+
+	virtual void bind(const SocketAddress& address, bool reuseAddress, bool reusePort);
+		/// Binds a local address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. TCP clients should not bind a socket to a
+		/// specific address.
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// If reuseAddress is true, sets the SO_REUSEPORT
+		/// socket option.
+
+	virtual void bind(Poco::UInt16 port, bool reuseAddress = false);
+		/// Binds a local port to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. 
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+
+	virtual void bind(Poco::UInt16 port, bool reuseAddress, bool reusePort);
+		/// Binds a local port to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. 
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+        	///
+		/// If reusePort is true, sets the SO_REUSEPORT
+		/// socket option.
+
+	virtual void bind6(const SocketAddress& address, bool reuseAddress = false, bool ipV6Only = false);
+		/// Binds a local IPv6 address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. TCP clients should not bind a socket to a
+		/// specific address.
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// The given address must be an IPv6 address. The
+		/// IPPROTO_IPV6/IPV6_V6ONLY option is set on the socket
+		/// according to the ipV6Only parameter.
+		///
+		/// If the library has not been built with IPv6 support,
+		/// a Poco::NotImplementedException will be thrown.
+
+	virtual void bind6(const SocketAddress& address, bool reuseAddress, bool reusePort,  bool ipV6Only);
+		/// Binds a local IPv6 address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. TCP clients should not bind a socket to a
+		/// specific address.
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// If reusePort is true, sets the SO_REUSEPORT
+		/// socket option.
+		///
+		/// The given address must be an IPv6 address. The
+		/// IPPROTO_IPV6/IPV6_V6ONLY option is set on the socket
+		/// according to the ipV6Only parameter.
+		///
+		/// If the library has not been built with IPv6 support,
+		/// a Poco::NotImplementedException will be thrown.
+
+	virtual void bind6(Poco::UInt16 port, bool reuseAddress = false, bool ipV6Only = false);
+		/// Binds a local IPv6 port to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. 
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// The given address must be an IPv6 address. The
+		/// IPPROTO_IPV6/IPV6_V6ONLY option is set on the socket
+		/// according to the ipV6Only parameter.
+		///
+		/// If the library has not been built with IPv6 support,
+		/// a Poco::NotImplementedException will be thrown.
+		
+	virtual void bind6(Poco::UInt16 port, bool reuseAddress, bool reusePort, bool ipV6Only);
+		/// Binds a local IPv6 port to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. 
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// If reusePort is true, sets the SO_REUSEPORT
+		/// socket option.
+		/// The given address must be an IPv6 address. The
+		/// IPPROTO_IPV6/IPV6_V6ONLY option is set on the socket
+		/// according to the ipV6Only parameter.
+		///
+		/// If the library has not been built with IPv6 support,
+		/// a Poco::NotImplementedException will be thrown.
+
+	virtual void listen(int backlog = 64);
+		/// Puts the socket into listening state.
+		///
+		/// The socket becomes a passive socket that
+		/// can accept incoming connection requests.
+		///
+		/// The backlog argument specifies the maximum
+		/// number of connections that can be queued
+		/// for this socket.
+
+	virtual StreamSocket acceptConnection(SocketAddress& clientAddr);
+		/// Gets the next completed connection from the
+		/// socket's completed connection queue.
+		///
+		/// If the queue is empty, waits until a connection
+		/// request completes.
+		///
+		/// Returns a new TCP socket for the connection
+		/// with the client.
+		///
+		/// The client socket's address is returned in clientAddr.
+
+	virtual StreamSocket acceptConnection();
+		/// Gets the next completed connection from the
+		/// socket's completed connection queue.
+		///
+		/// If the queue is empty, waits until a connection
+		/// request completes.
+		///
+		/// Returns a new TCP socket for the connection
+		/// with the client.
+
+protected:
+	ServerSocket(SocketImpl* pImpl, bool);
+		/// The bool argument is to resolve an ambiguity with
+		/// another constructor (Microsoft Visual C++ 2005)
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_ServerSocket_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/ServerSocketImpl.h b/base/poco/Net/include/Poco/Net/ServerSocketImpl.h
new file mode 100644
index 00000000000..aaa5c7cc209
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/ServerSocketImpl.h
@@ -0,0 +1,45 @@
+//
+// ServerSocketImpl.h
+//
+// Library: Net
+// Package: Sockets
+// Module:  ServerSocketImpl
+//
+// Definition of the ServerSocketImpl class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_ServerSocketImpl_INCLUDED
+#define Net_ServerSocketImpl_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/SocketImpl.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API ServerSocketImpl: public SocketImpl
+	/// This class implements a TCP server socket.
+{
+public:
+	ServerSocketImpl();
+		/// Creates the ServerSocketImpl.
+
+protected:
+	virtual ~ServerSocketImpl();
+		/// Destroys the ServerSocketImpl.
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_ServerSocketImpl_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/Socket.h b/base/poco/Net/include/Poco/Net/Socket.h
new file mode 100644
index 00000000000..18a1b5a05c2
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/Socket.h
@@ -0,0 +1,631 @@
+//
+// Socket.h
+//
+// Library: Net
+// Package: Sockets
+// Module:  Socket
+//
+// Definition of the Socket class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_Socket_INCLUDED
+#define Net_Socket_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/SocketImpl.h"
+#include <vector>
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API Socket
+	/// Socket is the common base class for
+	/// StreamSocket, ServerSocket, DatagramSocket and other
+	/// socket classes.
+	///
+	/// It provides operations common to all socket types.
+{
+public:
+	enum SelectMode
+		/// The mode argument to poll() and select().
+	{
+		SELECT_READ  = 1,
+		SELECT_WRITE = 2,
+		SELECT_ERROR = 4
+	};
+	
+	typedef std::vector<Socket> SocketList;
+
+	Socket();
+		/// Creates an uninitialized socket.
+
+	Socket(const Socket& socket);
+		/// Copy constructor.
+		///
+		/// Attaches the SocketImpl from the other socket and
+		/// increments the reference count of the SocketImpl.
+		
+	Socket& operator = (const Socket& socket);
+		/// Assignment operator.
+		///
+		/// Releases the socket's SocketImpl and
+		/// attaches the SocketImpl from the other socket and
+		/// increments the reference count of the SocketImpl.
+		
+	virtual ~Socket();
+		/// Destroys the Socket and releases the
+		/// SocketImpl.
+		
+	bool operator == (const Socket& socket) const;
+		/// Returns true if both sockets share the same
+		/// SocketImpl, false otherwise.
+
+	bool operator != (const Socket& socket) const;
+		/// Returns false if both sockets share the same
+		/// SocketImpl, true otherwise.
+
+	bool operator <  (const Socket& socket) const;
+		/// Compares the SocketImpl pointers.
+	
+	bool operator <= (const Socket& socket) const;
+		/// Compares the SocketImpl pointers.
+
+	bool operator >  (const Socket& socket) const;
+		/// Compares the SocketImpl pointers.
+
+	bool operator >= (const Socket& socket) const;
+		/// Compares the SocketImpl pointers.
+		
+	void close();
+		/// Closes the socket.
+
+	static int select(SocketList& readList, SocketList& writeList, SocketList& exceptList, const Poco::Timespan& timeout);
+		/// Determines the status of one or more sockets, 
+		/// using a call to select().
+		///
+		/// ReadList contains the list of sockets which should be
+		/// checked for readability.
+		///
+		/// WriteList contains the list of sockets which should be
+		/// checked for writeability.
+		///
+		/// ExceptList contains a list of sockets which should be
+		/// checked for a pending error.
+		///
+		/// Returns the number of sockets ready.
+		///
+		/// After return, 
+		///   * readList contains those sockets ready for reading,
+		///   * writeList contains those sockets ready for writing,
+		///   * exceptList contains those sockets with a pending error.
+		///
+		/// If the total number of sockets passed in readList, writeList and
+		/// exceptList is zero, select() will return immediately and the
+		/// return value will be 0.
+		///
+		/// If one of the sockets passed to select() is closed while
+		/// select() runs, select will return immediately. However,
+		/// the closed socket will not be included in any list.
+		/// In this case, the return value may be greater than the sum
+		/// of all sockets in all list.
+
+	bool poll(const Poco::Timespan& timeout, int mode) const;
+		/// Determines the status of the socket, using a 
+		/// call to poll() or select().
+		/// 
+		/// The mode argument is constructed by combining the values
+		/// of the SelectMode enumeration.
+		///
+		/// Returns true if the next operation corresponding to
+		/// mode will not block, false otherwise.
+
+	int available() const;
+		/// Returns the number of bytes available that can be read
+		/// without causing the socket to block.
+
+	void setSendBufferSize(int size);
+		/// Sets the size of the send buffer.
+		
+	int getSendBufferSize() const;
+		/// Returns the size of the send buffer.
+		///
+		/// The returned value may be different than the
+		/// value previously set with setSendBufferSize(),
+		/// as the system is free to adjust the value.
+
+	void setReceiveBufferSize(int size);
+		/// Sets the size of the receive buffer.
+		
+	int getReceiveBufferSize() const;
+		/// Returns the size of the receive buffer.
+		///
+		/// The returned value may be different than the
+		/// value previously set with setReceiveBufferSize(),
+		/// as the system is free to adjust the value.
+
+	void setSendTimeout(const Poco::Timespan& timeout);
+		/// Sets the send timeout for the socket.
+	
+	Poco::Timespan getSendTimeout() const;
+		/// Returns the send timeout for the socket.
+		///
+		/// The returned timeout may be different than the
+		/// timeout previously set with setSendTimeout(),
+		/// as the system is free to adjust the value.
+
+	void setReceiveTimeout(const Poco::Timespan& timeout);
+		/// Sets the send timeout for the socket.
+		///
+		/// On systems that do not support SO_RCVTIMEO, a
+		/// workaround using poll() is provided.
+	
+	Poco::Timespan getReceiveTimeout() const;
+		/// Returns the receive timeout for the socket.
+		///
+		/// The returned timeout may be different than the
+		/// timeout previously set with getReceiveTimeout(),
+		/// as the system is free to adjust the value.
+
+	void setOption(int level, int option, int value);
+		/// Sets the socket option specified by level and option
+		/// to the given integer value.
+
+	void setOption(int level, int option, unsigned value);
+		/// Sets the socket option specified by level and option
+		/// to the given integer value.
+
+	void setOption(int level, int option, unsigned char value);
+		/// Sets the socket option specified by level and option
+		/// to the given integer value.
+		
+	void setOption(int level, int option, const Poco::Timespan& value);
+		/// Sets the socket option specified by level and option
+		/// to the given time value.
+		
+	void setOption(int level, int option, const IPAddress& value);
+		/// Sets the socket option specified by level and option
+		/// to the given time value.
+
+	void getOption(int level, int option, int& value) const;
+		/// Returns the value of the socket option 
+		/// specified by level and option.
+
+	void getOption(int level, int option, unsigned& value) const;
+		/// Returns the value of the socket option 
+		/// specified by level and option.
+
+	void getOption(int level, int option, unsigned char& value) const;
+		/// Returns the value of the socket option 
+		/// specified by level and option.
+
+	void getOption(int level, int option, Poco::Timespan& value) const;
+		/// Returns the value of the socket option 
+		/// specified by level and option.
+	
+	void getOption(int level, int option, IPAddress& value) const;
+		/// Returns the value of the socket option 
+		/// specified by level and option.
+
+	void setLinger(bool on, int seconds);
+		/// Sets the value of the SO_LINGER socket option.
+		
+	void getLinger(bool& on, int& seconds) const;
+		/// Returns the value of the SO_LINGER socket option.
+	
+	void setNoDelay(bool flag);
+		/// Sets the value of the TCP_NODELAY socket option.
+		
+	bool getNoDelay() const;
+		/// Returns the value of the TCP_NODELAY socket option.
+	
+	void setKeepAlive(bool flag);
+		/// Sets the value of the SO_KEEPALIVE socket option.
+		
+	bool getKeepAlive() const;
+		/// Returns the value of the SO_KEEPALIVE socket option.
+	
+	void setReuseAddress(bool flag);
+		/// Sets the value of the SO_REUSEADDR socket option.
+	
+	bool getReuseAddress() const;
+		/// Returns the value of the SO_REUSEADDR socket option.
+
+	void setReusePort(bool flag);
+		/// Sets the value of the SO_REUSEPORT socket option.
+		/// Does nothing if the socket implementation does not
+		/// support SO_REUSEPORT.
+	
+	bool getReusePort() const;
+		/// Returns the value of the SO_REUSEPORT socket option.
+		///
+		/// Returns false if the socket implementation does not
+		/// support SO_REUSEPORT.
+		
+	void setOOBInline(bool flag);
+		/// Sets the value of the SO_OOBINLINE socket option.
+	
+	bool getOOBInline() const;
+		/// Returns the value of the SO_OOBINLINE socket option.
+
+	void setBlocking(bool flag);
+		/// Sets the socket in blocking mode if flag is true,
+		/// disables blocking mode if flag is false.
+
+	bool getBlocking() const;
+		/// Returns the blocking mode of the socket.
+		/// This method will only work if the blocking modes of 
+		/// the socket are changed via the setBlocking method!
+
+	SocketAddress address() const;
+		/// Returns the IP address and port number of the socket.
+		
+	SocketAddress peerAddress() const;
+		/// Returns the IP address and port number of the peer socket.
+
+	SocketImpl* impl() const;
+		/// Returns the SocketImpl for this socket.
+		
+	bool secure() const;
+		/// Returns true iff the socket's connection is secure
+		/// (using SSL or TLS).
+		
+	static bool supportsIPv4();
+		/// Returns true if the system supports IPv4.
+		
+	static bool supportsIPv6();
+		/// Returns true if the system supports IPv6.
+
+	void init(int af);
+		/// Creates the underlying system socket for the given
+		/// address family.
+		///
+		/// Normally, this method should not be called directly, as
+		/// socket creation will be handled automatically. There are
+		/// a few situations where calling this method after creation
+		/// of the Socket object makes sense. One example is setting
+		/// a socket option before calling bind() on a ServerSocket.
+
+    poco_socket_t sockfd() const;
+        /// Returns the socket descriptor for this socket.
+
+protected:
+	Socket(SocketImpl* pImpl);
+		/// Creates the Socket and attaches the given SocketImpl.
+		/// The socket takes ownership of the SocketImpl.
+
+private:
+
+#if defined(POCO_HAVE_FD_POLL)
+class FDCompare
+	/// Utility functor used to compare socket file descriptors.
+	/// Used in poll() member function.
+{
+public:
+	FDCompare(int fd): _fd(fd) { }
+	inline bool operator()(const Socket& socket) const
+	{ return socket.sockfd() == _fd; }
+
+private:
+	FDCompare();
+	int _fd;
+};
+#endif
+
+	SocketImpl* _pImpl;
+};
+
+
+//
+// inlines
+//
+inline bool Socket::operator == (const Socket& socket) const
+{
+	return _pImpl == socket._pImpl;
+}
+
+
+inline bool Socket::operator != (const Socket& socket) const
+{
+	return _pImpl != socket._pImpl;
+}
+
+
+inline bool Socket::operator <  (const Socket& socket) const
+{
+	return _pImpl < socket._pImpl;
+}
+
+
+inline bool Socket::operator <= (const Socket& socket) const
+{
+	return _pImpl <= socket._pImpl;
+}
+
+
+inline bool Socket::operator >  (const Socket& socket) const
+{
+	return _pImpl > socket._pImpl;
+}
+
+
+inline bool Socket::operator >= (const Socket& socket) const
+{
+	return _pImpl >= socket._pImpl;
+}
+
+
+inline void Socket::close()
+{
+	_pImpl->close();
+}
+
+
+inline bool Socket::poll(const Poco::Timespan& timeout, int mode) const
+{
+	return _pImpl->poll(timeout, mode);
+}
+
+
+inline int Socket::available() const
+{
+	return _pImpl->available();
+}
+
+
+inline void Socket::setSendBufferSize(int size)
+{
+	_pImpl->setSendBufferSize(size);
+}
+
+	
+inline int Socket::getSendBufferSize() const
+{
+	return _pImpl->getSendBufferSize();
+}
+
+
+inline void Socket::setReceiveBufferSize(int size)
+{
+	_pImpl->setReceiveBufferSize(size);
+}
+
+	
+inline int Socket::getReceiveBufferSize() const
+{
+	return _pImpl->getReceiveBufferSize();
+}
+
+
+inline void Socket::setSendTimeout(const Poco::Timespan& timeout)
+{
+	_pImpl->setSendTimeout(timeout);
+}
+
+
+inline Poco::Timespan Socket::getSendTimeout() const
+{
+	return _pImpl->getSendTimeout();
+}
+
+
+inline void Socket::setReceiveTimeout(const Poco::Timespan& timeout)
+{
+	_pImpl->setReceiveTimeout(timeout);
+}
+
+
+inline Poco::Timespan Socket::getReceiveTimeout() const
+{
+	return _pImpl->getReceiveTimeout();
+}
+
+
+inline void Socket::setOption(int level, int option, int value)
+{
+	_pImpl->setOption(level, option, value);
+}
+
+
+inline void Socket::setOption(int level, int option, unsigned value)
+{
+	_pImpl->setOption(level, option, value);
+}
+
+
+inline void Socket::setOption(int level, int option, unsigned char value)
+{
+	_pImpl->setOption(level, option, value);
+}
+
+
+inline void Socket::setOption(int level, int option, const Poco::Timespan& value)
+{
+	_pImpl->setOption(level, option, value);
+}
+
+	
+inline void Socket::setOption(int level, int option, const IPAddress& value)
+{
+	_pImpl->setOption(level, option, value);
+}
+
+
+inline void Socket::getOption(int level, int option, int& value) const
+{
+	_pImpl->getOption(level, option, value);
+}
+
+
+inline void Socket::getOption(int level, int option, unsigned& value) const
+{
+	_pImpl->getOption(level, option, value);
+}
+
+
+inline void Socket::getOption(int level, int option, unsigned char& value) const
+{
+	_pImpl->getOption(level, option, value);
+}
+
+
+inline void Socket::getOption(int level, int option, Poco::Timespan& value) const
+{
+	_pImpl->getOption(level, option, value);
+}
+
+
+inline void Socket::getOption(int level, int option, IPAddress& value) const
+{
+	_pImpl->getOption(level, option, value);
+}
+
+
+inline void Socket::setLinger(bool on, int seconds)
+{
+	_pImpl->setLinger(on, seconds);
+}
+
+	
+inline void Socket::getLinger(bool& on, int& seconds) const
+{
+	_pImpl->getLinger(on, seconds);
+}
+
+
+inline void Socket::setNoDelay(bool flag)
+{
+	_pImpl->setNoDelay(flag);
+}
+
+	
+inline bool Socket::getNoDelay() const
+{
+	return _pImpl->getNoDelay();
+}
+
+
+inline void Socket::setKeepAlive(bool flag)
+{
+	_pImpl->setKeepAlive(flag);
+}
+
+	
+inline bool Socket::getKeepAlive() const
+{
+	return _pImpl->getKeepAlive();
+}
+
+
+inline void Socket::setReuseAddress(bool flag)
+{
+	_pImpl->setReuseAddress(flag);
+}
+
+
+inline bool Socket::getReuseAddress() const
+{
+	return _pImpl->getReuseAddress();
+}
+
+
+inline void Socket::setReusePort(bool flag)
+{
+	_pImpl->setReusePort(flag);
+}
+
+
+inline bool Socket::getReusePort() const
+{
+	return _pImpl->getReusePort();
+}
+
+	
+inline void Socket::setOOBInline(bool flag)
+{
+	_pImpl->setOOBInline(flag);
+}
+
+
+inline bool Socket::getOOBInline() const
+{
+	return _pImpl->getOOBInline();
+}
+
+
+inline void Socket::setBlocking(bool flag)
+{
+	_pImpl->setBlocking(flag);
+}
+
+
+inline bool Socket::getBlocking() const
+{
+	return _pImpl->getBlocking();
+}
+
+
+inline SocketImpl* Socket::impl() const
+{
+	return _pImpl;
+}
+
+
+inline poco_socket_t Socket::sockfd() const
+{
+	return _pImpl->sockfd();
+}
+
+
+inline SocketAddress Socket::address() const
+{
+	return _pImpl->address();
+}
+
+	
+inline SocketAddress Socket::peerAddress() const
+{
+	return _pImpl->peerAddress();
+}
+
+
+inline bool Socket::secure() const
+{
+	return _pImpl->secure();
+}
+
+
+inline bool Socket::supportsIPv4()
+{
+	return true;
+}
+
+
+inline bool Socket::supportsIPv6()
+{
+#if defined(POCO_HAVE_IPv6)
+	return true;
+#else
+	return false;
+#endif
+}
+
+
+inline void Socket::init(int af)
+{
+	_pImpl->init(af);
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_Socket_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/SocketAcceptor.h b/base/poco/Net/include/Poco/Net/SocketAcceptor.h
new file mode 100644
index 00000000000..c9021ecd0be
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/SocketAcceptor.h
@@ -0,0 +1,196 @@
+//
+// SocketAcceptor.h
+//
+// Library: Net
+// Package: Reactor
+// Module:  SocketAcceptor
+//
+// Definition of the SocketAcceptor class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_SocketAcceptor_INCLUDED
+#define Net_SocketAcceptor_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/SocketNotification.h"
+#include "Poco/Net/SocketReactor.h"
+#include "Poco/Net/ServerSocket.h"
+#include "Poco/Net/StreamSocket.h"
+#include "Poco/Observer.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+template <class ServiceHandler>
+class SocketAcceptor
+	/// This class implements the Acceptor part of the
+	/// Acceptor-Connector design pattern.
+	///
+	/// The Acceptor-Connector pattern has been described in the book
+	/// "Pattern Languages of Program Design 3", edited by Robert Martin,
+	/// Frank Buschmann and Dirk Riehle (Addison Wesley, 1997).
+	///
+	/// The Acceptor-Connector design pattern decouples connection
+	/// establishment and service initialization in a distributed system
+	/// from the processing performed once a service is initialized.
+	/// This decoupling is achieved with three components: Acceptors, 
+	/// Connectors and Service Handlers.
+	/// The SocketAcceptor passively waits for connection requests (usually
+	/// from a remote Connector) and establishes a connection upon
+	/// arrival of a connection requests. Also, a Service Handler is
+	/// initialized to process the data arriving via the connection in
+	/// an application-specific way.
+	///
+	/// The SocketAcceptor sets up a ServerSocket and registers itself
+	/// for a ReadableNotification, denoting an incoming connection request.
+	///
+	/// When the ServerSocket becomes readable the SocketAcceptor accepts
+	/// the connection request and creates a ServiceHandler to
+	/// service the connection.
+	///
+	/// The ServiceHandler class must provide a constructor that
+	/// takes a StreamSocket and a SocketReactor as arguments,
+	/// e.g.:
+	///     MyServiceHandler(const StreamSocket& socket, ServiceReactor& reactor)
+	///
+	/// When the ServiceHandler is done, it must destroy itself.
+	///
+	/// Subclasses can override the createServiceHandler() factory method
+	/// if special steps are necessary to create a ServiceHandler object.
+{
+public:
+	explicit SocketAcceptor(ServerSocket& socket):
+		_socket(socket),
+		_pReactor(0)
+		/// Creates a SocketAcceptor, using the given ServerSocket.
+	{
+	}
+
+	SocketAcceptor(ServerSocket& socket, SocketReactor& reactor):
+		_socket(socket),
+		_pReactor(&reactor)
+		/// Creates a SocketAcceptor, using the given ServerSocket.
+		/// The SocketAcceptor registers itself with the given SocketReactor.
+	{
+		_pReactor->addEventHandler(_socket, Poco::Observer<SocketAcceptor,
+			ReadableNotification>(*this, &SocketAcceptor::onAccept));
+	}
+
+	virtual ~SocketAcceptor()
+		/// Destroys the SocketAcceptor.
+	{
+		try
+		{
+			if (_pReactor)
+			{
+				_pReactor->removeEventHandler(_socket, Poco::Observer<SocketAcceptor,
+					ReadableNotification>(*this, &SocketAcceptor::onAccept));
+			}
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	}
+
+	void setReactor(SocketReactor& reactor)
+		/// Sets the reactor for this acceptor.
+	{
+		_pReactor = &reactor;
+		if (!_pReactor->hasEventHandler(_socket, Poco::Observer<SocketAcceptor,
+			ReadableNotification>(*this, &SocketAcceptor::onAccept)))
+		{
+			registerAcceptor(reactor);
+		}
+	}
+
+	virtual void registerAcceptor(SocketReactor& reactor)
+		/// Registers the SocketAcceptor with a SocketReactor.
+		///
+		/// A subclass can override this function to e.g.
+		/// register an event handler for timeout event.
+		/// 
+		/// If acceptor was constructed without providing reactor to it,
+		/// the override of this method must either call the base class
+		/// implementation or directly register the accept handler with
+		/// the reactor.
+	{
+		if (_pReactor)
+			throw Poco::InvalidAccessException("Acceptor already registered.");
+
+		_pReactor = &reactor;
+		_pReactor->addEventHandler(_socket, Poco::Observer<SocketAcceptor, ReadableNotification>(*this, &SocketAcceptor::onAccept));
+	}
+	
+	virtual void unregisterAcceptor()
+		/// Unregisters the SocketAcceptor.
+		///
+		/// A subclass can override this function to e.g.
+		/// unregister its event handler for a timeout event.
+		/// 
+		/// If the accept handler was registered with the reactor,
+		/// the overriding method must either call the base class
+		/// implementation or directly unregister the accept handler.
+	{
+		if (_pReactor)
+		{
+			_pReactor->removeEventHandler(_socket, Poco::Observer<SocketAcceptor, ReadableNotification>(*this, &SocketAcceptor::onAccept));
+		}
+	}
+	
+	void onAccept(ReadableNotification* pNotification)
+		/// Accepts connection and creates event handler.
+	{
+		pNotification->release();
+		StreamSocket sock = _socket.acceptConnection();
+		_pReactor->wakeUp();
+		createServiceHandler(sock);
+	}
+	
+protected:
+	virtual ServiceHandler* createServiceHandler(StreamSocket& socket)
+		/// Create and initialize a new ServiceHandler instance.
+		///
+		/// Subclasses can override this method.
+	{
+		return new ServiceHandler(socket, *_pReactor);
+	}
+
+	SocketReactor* reactor()
+		/// Returns a pointer to the SocketReactor where
+		/// this SocketAcceptor is registered.
+		///
+		/// The pointer may be null.
+	{
+		return _pReactor;
+	}
+
+	Socket& socket()
+		/// Returns a reference to the SocketAcceptor's socket.
+	{
+		return _socket;
+	}
+
+private:
+	SocketAcceptor();
+	SocketAcceptor(const SocketAcceptor&);
+	SocketAcceptor& operator = (const SocketAcceptor&);
+	
+	ServerSocket   _socket;
+	SocketReactor* _pReactor;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_SocketAcceptor_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/SocketAddress.h b/base/poco/Net/include/Poco/Net/SocketAddress.h
new file mode 100644
index 00000000000..61c55817897
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/SocketAddress.h
@@ -0,0 +1,301 @@
+//
+// SocketAddress.h
+//
+// Library: Net
+// Package: NetCore
+// Module:  SocketAddress
+//
+// Definition of the SocketAddress class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_SocketAddress_INCLUDED
+#define Net_SocketAddress_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/SocketAddressImpl.h"
+#include <ostream>
+
+
+namespace Poco {
+
+class BinaryReader;
+class BinaryWriter;
+
+namespace Net {
+
+
+class IPAddress;
+
+
+class Net_API SocketAddress
+	/// This class represents an internet (IP) endpoint/socket
+	/// address. The address can belong either to the
+	/// IPv4 or the IPv6 address family and consists of a
+	/// host address and a port number.
+{
+public:
+	// The following declarations keep the Family type
+	// backwards compatible with the previously used
+	// enum declaration.
+	typedef AddressFamily::Family Family;
+	static const Family IPv4 = AddressFamily::IPv4;
+#if defined(POCO_HAVE_IPv6)
+	static const Family IPv6 = AddressFamily::IPv6;
+#endif
+#if defined(POCO_OS_FAMILY_UNIX)
+	static const Family UNIX_LOCAL = AddressFamily::UNIX_LOCAL;
+#endif
+
+	SocketAddress();
+		/// Creates a wildcard (all zero) IPv4 SocketAddress.
+
+	explicit SocketAddress(Family family);
+		/// Creates a SocketAddress with unspecified (wildcard) IP address
+		/// of the given family.
+
+	SocketAddress(const IPAddress& hostAddress, Poco::UInt16 portNumber);
+		/// Creates a SocketAddress from an IP address and given port number.
+
+	explicit SocketAddress(Poco::UInt16 port);
+		/// Creates a SocketAddress with unspecified (wildcard) IP address
+		/// and given port number.
+
+	SocketAddress(Family family, Poco::UInt16 port);
+		/// Creates a SocketAddress with unspecified (wildcard) IP address
+		/// of the given family, and given port number.
+
+	SocketAddress(const std::string& hostAddress, Poco::UInt16 portNumber);
+		/// Creates a SocketAddress from an IP address and given port number.
+		///
+		/// The IP address must either be a domain name, or it must
+		/// be in dotted decimal (IPv4) or hex string (IPv6) format.
+
+	SocketAddress(Family family, const std::string& hostAddress, Poco::UInt16 portNumber);
+		/// Creates a SocketAddress from an IP address and given port number.
+		///
+		/// The IP address must either be a domain name, or it must
+		/// be in dotted decimal (IPv4) or hex string (IPv6) format.
+		///
+		/// If a domain name is given in hostAddress, it is resolved and the address
+		/// matching the given family is used. If no address matching the given family
+		/// is found, or the IP address given in hostAddress does not match the given
+		/// family, an AddressFamilyMismatchException is thrown.
+
+	SocketAddress(const std::string& hostAddress, const std::string& portNumber);
+		/// Creates a SocketAddress from an IP address and the
+		/// service name or port number.
+		///
+		/// The IP address must either be a domain name, or it must
+		/// be in dotted decimal (IPv4) or hex string (IPv6) format.
+		///
+		/// The given port must either be a decimal port number, or
+		/// a service name.
+
+	SocketAddress(Family family, const std::string& hostAddress, const std::string& portNumber);
+		/// Creates a SocketAddress from an IP address and the
+		/// service name or port number.
+		///
+		/// The IP address must either be a domain name, or it must
+		/// be in dotted decimal (IPv4) or hex string (IPv6) format.
+		///
+		/// The given port must either be a decimal port number, or
+		/// a service name.
+		///
+		/// If a domain name is given in hostAddress, it is resolved and the address
+		/// matching the given family is used. If no address matching the given family
+		/// is found, or the IP address given in hostAddress does not match the given
+		/// family, an AddressFamilyMismatchException is thrown.
+
+	explicit SocketAddress(const std::string& hostAndPort);
+		/// Creates a SocketAddress from an IP address or host name and the
+		/// port number/service name. Host name/address and port number must
+		/// be separated by a colon. In case of an IPv6 address,
+		/// the address part must be enclosed in brackets.
+		///
+		/// Examples:
+		///     192.168.1.10:80
+		///     [::ffff:192.168.1.120]:2040
+		///     www.appinf.com:8080
+		///
+		/// On POSIX platforms supporting UNIX_LOCAL sockets, hostAndPort
+		/// can also be the absolute path of a local socket, starting with a
+		/// slash, e.g. "/tmp/local.socket".
+
+	SocketAddress(Family family, const std::string& addr);
+		/// Creates a SocketAddress of the given family from a
+		/// string representation of the address, which is
+		/// either an IP address and port number, separated by
+		/// a colon for IPv4 or IPv6 addresses, or a path for
+		/// UNIX_LOCAL sockets.
+
+	SocketAddress(const SocketAddress& addr);
+		/// Creates a SocketAddress by copying another one.
+
+	SocketAddress(const struct sockaddr* addr, poco_socklen_t length);
+		/// Creates a SocketAddress from a native socket address.
+
+	~SocketAddress();
+		/// Destroys the SocketAddress.
+
+	SocketAddress& operator = (const SocketAddress& socketAddress);
+		/// Assigns another SocketAddress.
+
+	IPAddress host() const;
+		/// Returns the host IP address.
+
+	Poco::UInt16 port() const;
+		/// Returns the port number.
+
+	poco_socklen_t length() const;
+		/// Returns the length of the internal native socket address.
+
+	const struct sockaddr* addr() const;
+		/// Returns a pointer to the internal native socket address.
+
+	int af() const;
+		/// Returns the address family (AF_INET or AF_INET6) of the address.
+
+	std::string toString() const;
+		/// Returns a string representation of the address.
+
+	Family family() const;
+		/// Returns the address family of the host's address.
+
+	bool operator < (const SocketAddress& socketAddress) const;
+	bool operator == (const SocketAddress& socketAddress) const;
+	bool operator != (const SocketAddress& socketAddress) const;
+
+	enum
+	{
+		MAX_ADDRESS_LENGTH =
+#if defined(POCO_OS_FAMILY_UNIX)
+			sizeof(struct sockaddr_un)
+#elif defined(POCO_HAVE_IPv6)
+			sizeof(struct sockaddr_in6)
+#else
+			sizeof(struct sockaddr_in)
+#endif
+			/// Maximum length in bytes of a socket address.
+	};
+
+protected:
+	void init(const IPAddress& hostAddress, Poco::UInt16 portNumber);
+	void init(const std::string& hostAddress, Poco::UInt16 portNumber);
+	void init(Family family, const std::string& hostAddress, Poco::UInt16 portNumber);
+	void init(Family family, const std::string& address);
+	void init(const std::string& hostAndPort);
+	Poco::UInt16 resolveService(const std::string& service);
+
+private:
+	typedef Poco::Net::Impl::SocketAddressImpl Impl;
+	typedef Poco::AutoPtr<Impl> Ptr;
+
+	Ptr pImpl() const;
+
+	void newIPv4();
+	void newIPv4(const sockaddr_in*);
+	void newIPv4(const IPAddress& hostAddress, Poco::UInt16 portNumber);
+
+#if defined(POCO_HAVE_IPv6)
+	void newIPv6(const sockaddr_in6*);
+	void newIPv6(const IPAddress& hostAddress, Poco::UInt16 portNumber);
+#endif
+
+#if defined(POCO_OS_FAMILY_UNIX)
+	void newLocal(const sockaddr_un* sockAddr);
+	void newLocal(const std::string& path);
+#endif
+
+	Ptr _pImpl;
+};
+
+
+//
+// inlines
+//
+inline SocketAddress::Ptr SocketAddress::pImpl() const
+{
+	if (_pImpl) return _pImpl;
+	throw Poco::NullPointerException("Pointer to SocketAddress implementation is NULL.");
+}
+
+
+inline void SocketAddress::newIPv4()
+{
+	_pImpl = new Poco::Net::Impl::IPv4SocketAddressImpl;
+}
+
+
+inline void SocketAddress::newIPv4(const sockaddr_in* sockAddr)
+{
+	_pImpl = new Poco::Net::Impl::IPv4SocketAddressImpl(sockAddr);
+}
+
+
+inline void SocketAddress::newIPv4(const IPAddress& hostAddress, Poco::UInt16 portNumber)
+{
+	_pImpl = new Poco::Net::Impl::IPv4SocketAddressImpl(hostAddress.addr(), htons(portNumber));
+}
+
+
+#if defined(POCO_HAVE_IPv6)
+inline void SocketAddress::newIPv6(const sockaddr_in6* sockAddr)
+{
+	_pImpl = new Poco::Net::Impl::IPv6SocketAddressImpl(sockAddr);
+}
+
+
+inline void SocketAddress::newIPv6(const IPAddress& hostAddress, Poco::UInt16 portNumber)
+{
+	_pImpl = new Poco::Net::Impl::IPv6SocketAddressImpl(hostAddress.addr(), htons(portNumber), hostAddress.scope());
+}
+#endif // POCO_HAVE_IPv6
+
+
+#if defined(POCO_OS_FAMILY_UNIX)
+inline void SocketAddress::newLocal(const sockaddr_un* sockAddr)
+{
+	_pImpl = new Poco::Net::Impl::LocalSocketAddressImpl(sockAddr);
+}
+
+
+inline void SocketAddress::newLocal(const std::string& path)
+{
+	_pImpl = new Poco::Net::Impl::LocalSocketAddressImpl(path.c_str(), path.size());
+}
+#endif // POCO_OS_FAMILY_UNIX
+
+
+inline 	bool SocketAddress::operator == (const SocketAddress& socketAddress) const
+{
+#if defined(POCO_OS_FAMILY_UNIX)
+	if (family() == UNIX_LOCAL)
+		return toString() == socketAddress.toString();
+	else
+#endif
+		return host() == socketAddress.host() && port() == socketAddress.port();
+}
+
+
+inline bool SocketAddress::operator != (const SocketAddress& socketAddress) const
+{
+	return !(operator == (socketAddress));
+}
+
+
+} } // namespace Poco::Net
+
+
+Net_API Poco::BinaryWriter& operator << (Poco::BinaryWriter& writer, const Poco::Net::SocketAddress& value);
+Net_API Poco::BinaryReader& operator >> (Poco::BinaryReader& reader, Poco::Net::SocketAddress& value);
+Net_API std::ostream& operator << (std::ostream& ostr, const Poco::Net::SocketAddress& address);
+
+
+#endif // Net_SocketAddress_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/SocketAddressImpl.h b/base/poco/Net/include/Poco/Net/SocketAddressImpl.h
new file mode 100644
index 00000000000..079bece510d
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/SocketAddressImpl.h
@@ -0,0 +1,258 @@
+//
+// SocketAddressImpl.h
+//
+// Library: Net
+// Package: NetCore
+// Module:  SocketAddressImpl
+//
+// Definition of the SocketAddressImpl class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_SocketAddressImpl_INCLUDED
+#define Net_SocketAddressImpl_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/SocketDefs.h"
+#include "Poco/Net/IPAddress.h"
+#include "Poco/RefCountedObject.h"
+
+
+namespace Poco {
+namespace Net {
+namespace Impl {
+
+
+class Net_API SocketAddressImpl : public Poco::RefCountedObject
+{
+public:
+	typedef AddressFamily::Family Family;
+
+	virtual ~SocketAddressImpl();
+
+	virtual IPAddress host() const = 0;
+	virtual UInt16 port() const = 0;
+	virtual poco_socklen_t length() const = 0;
+	virtual const struct sockaddr* addr() const = 0;
+	virtual int af() const = 0;
+	virtual Family family() const = 0;
+	virtual std::string toString() const = 0;
+
+protected:
+	SocketAddressImpl();
+
+private:
+	SocketAddressImpl(const SocketAddressImpl&);
+	SocketAddressImpl& operator = (const SocketAddressImpl&);
+};
+
+
+class Net_API IPv4SocketAddressImpl: public SocketAddressImpl
+{
+public:
+	IPv4SocketAddressImpl();
+	IPv4SocketAddressImpl(const struct sockaddr_in* addr);
+	IPv4SocketAddressImpl(const void* addr, UInt16 port);
+	IPAddress host() const;
+	UInt16 port() const;
+	poco_socklen_t length() const;
+	const struct sockaddr* addr() const;
+	int af() const;
+	Family family() const;
+	std::string toString() const;
+
+private:
+	struct sockaddr_in _addr;
+};
+
+
+//
+// inlines
+//
+
+inline IPAddress IPv4SocketAddressImpl::host() const
+{
+	return IPAddress(&_addr.sin_addr, sizeof(_addr.sin_addr));
+}
+
+
+inline UInt16 IPv4SocketAddressImpl::port() const
+{
+	return _addr.sin_port;
+}
+
+
+inline poco_socklen_t IPv4SocketAddressImpl::length() const
+{
+	return sizeof(_addr);
+}
+
+
+inline const struct sockaddr* IPv4SocketAddressImpl::addr() const
+{
+	return reinterpret_cast<const struct sockaddr*>(&_addr);
+}
+
+
+inline int IPv4SocketAddressImpl::af() const
+{
+	return _addr.sin_family;
+}
+
+
+inline SocketAddressImpl::Family IPv4SocketAddressImpl::family() const
+{
+	return AddressFamily::IPv4;
+}
+
+
+#if defined(POCO_HAVE_IPv6)
+
+
+class Net_API IPv6SocketAddressImpl: public SocketAddressImpl
+{
+public:
+	IPv6SocketAddressImpl(const struct sockaddr_in6* addr);
+	IPv6SocketAddressImpl(const void* addr, UInt16 port);
+	IPv6SocketAddressImpl(const void* addr, UInt16 port, UInt32 scope);
+	IPAddress host() const;
+	UInt16 port() const;
+	poco_socklen_t length() const;
+	const struct sockaddr* addr() const;
+	int af() const;
+	Family family() const;
+	std::string toString() const;
+
+private:
+	struct sockaddr_in6 _addr;
+};
+
+
+//
+// inlines
+//
+
+inline IPAddress IPv6SocketAddressImpl::host() const
+{
+	return IPAddress(&_addr.sin6_addr, sizeof(_addr.sin6_addr), _addr.sin6_scope_id);
+}
+
+
+inline UInt16 IPv6SocketAddressImpl::port() const
+{
+	return _addr.sin6_port;
+}
+
+
+inline poco_socklen_t IPv6SocketAddressImpl::length() const
+{
+	return sizeof(_addr);
+}
+
+
+inline const struct sockaddr* IPv6SocketAddressImpl::addr() const
+{
+	return reinterpret_cast<const struct sockaddr*>(&_addr);
+}
+
+
+inline int IPv6SocketAddressImpl::af() const
+{
+	return _addr.sin6_family;
+}
+
+
+inline SocketAddressImpl::Family IPv6SocketAddressImpl::family() const
+{
+	return AddressFamily::IPv6;
+}
+
+
+#endif // POCO_HAVE_IPv6
+
+
+#if defined(POCO_OS_FAMILY_UNIX)
+
+
+class Net_API LocalSocketAddressImpl: public SocketAddressImpl
+{
+public:
+	LocalSocketAddressImpl(const struct sockaddr_un* addr);
+	LocalSocketAddressImpl(const char* path);
+	LocalSocketAddressImpl(const char* path, std::size_t length);
+	~LocalSocketAddressImpl();
+	IPAddress host() const;
+	UInt16 port() const;
+	poco_socklen_t length() const;
+	const struct sockaddr* addr() const;
+	int af() const;
+	Family family() const;
+	const char* path() const;
+	std::string toString() const;
+
+private:
+	struct sockaddr_un* _pAddr;
+		// Note: We allocate struct sockaddr_un on the heap, otherwise we would
+		// waste a lot of memory due to small object optimization in SocketAddress.
+};
+
+
+//
+// inlines
+//
+
+inline IPAddress LocalSocketAddressImpl::host() const
+{
+	throw Poco::InvalidAccessException("local socket address does not have host IP address");
+}
+
+
+inline UInt16 LocalSocketAddressImpl::port() const
+{
+	throw Poco::InvalidAccessException("local socket address does not have port number");
+}
+
+
+inline poco_socklen_t LocalSocketAddressImpl::length() const
+{
+	return sizeof(struct sockaddr_un);
+}
+
+
+inline const struct sockaddr* LocalSocketAddressImpl::addr() const
+{
+	return reinterpret_cast<const struct sockaddr*>(_pAddr);
+}
+
+
+inline int LocalSocketAddressImpl::af() const
+{
+	return _pAddr->sun_family;
+}
+
+
+inline SocketAddressImpl::Family LocalSocketAddressImpl::family() const
+{
+	return AddressFamily::UNIX_LOCAL;
+}
+
+
+inline const char* LocalSocketAddressImpl::path() const
+{
+	return _pAddr->sun_path;
+}
+
+
+#endif // POCO_OS_FAMILY_UNIX
+
+
+} } } // namespace Poco::Net::Impl
+
+
+#endif // Net_SocketAddressImpl_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/SocketConnector.h b/base/poco/Net/include/Poco/Net/SocketConnector.h
new file mode 100644
index 00000000000..d3196c9f624
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/SocketConnector.h
@@ -0,0 +1,212 @@
+//
+// SocketConnector.h
+//
+// Library: Net
+// Package: Reactor
+// Module:  SocketConnector
+//
+// Definition of the SocketConnector class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_SocketConnector_INCLUDED
+#define Net_SocketConnector_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/SocketNotification.h"
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/Net/StreamSocket.h"
+#include "Poco/Observer.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+template <class ServiceHandler>
+class SocketConnector
+	/// This class implements the Connector part of the
+	/// Acceptor-Connector design pattern.
+	///
+	/// The Acceptor-Connector pattern has been described in the book
+	/// "Pattern Languages of Program Design 3", edited by Robert Martin,
+	/// Frank Buschmann and Dirk Riehle (Addison Wesley, 1997).
+	///
+	/// The Acceptor-Connector design pattern decouples connection
+	/// establishment and service initialization in a distributed system
+	/// from the processing performed once a service is initialized.
+	/// This decoupling is achieved with three components: Acceptors, 
+	/// Connectors and Service Handlers.
+	/// The Connector actively establishes a connection with a remote
+	/// server socket (usually managed by an Acceptor) and initializes
+	/// a Service Handler to manage the connection.
+	///
+	/// The SocketConnector sets up a StreamSocket, initiates a non-blocking
+	/// connect operation and registers itself for ReadableNotification, WritableNotification
+	/// and ErrorNotification. ReadableNotification or WritableNotification denote the successful 
+	/// establishment of the connection.
+	///
+	/// When the StreamSocket becomes readable or writeable, the SocketConnector 
+	/// creates a ServiceHandler to service the connection and unregisters
+	/// itself.
+	///
+	/// In case of an error (ErrorNotification), the SocketConnector unregisters itself
+	/// and calls the onError() method, which can be overridden by subclasses
+	/// to perform custom error handling.
+	///
+	/// The ServiceHandler class must provide a constructor that
+	/// takes a StreamSocket and a SocketReactor as arguments,
+	/// e.g.:
+	///     MyServiceHandler(const StreamSocket& socket, ServiceReactor& reactor)
+	///
+	/// When the ServiceHandler is done, it must destroy itself.
+	///
+	/// Subclasses can override the createServiceHandler() factory method
+	/// if special steps are necessary to create a ServiceHandler object.
+{
+public:		
+	explicit SocketConnector(SocketAddress& address):
+		_pReactor(0)
+		/// Creates a SocketConnector, using the given Socket.
+	{
+		_socket.connectNB(address);
+	}
+
+	SocketConnector(SocketAddress& address, SocketReactor& reactor):
+		_pReactor(0)
+		/// Creates an acceptor, using the given ServerSocket.
+		/// The SocketConnector registers itself with the given SocketReactor.
+	{
+		_socket.connectNB(address);
+		registerConnector(reactor);
+	}
+
+	virtual ~SocketConnector()
+		/// Destroys the SocketConnector.
+	{
+		try
+		{
+			unregisterConnector();
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	}
+	
+	virtual void registerConnector(SocketReactor& reactor)
+		/// Registers the SocketConnector with a SocketReactor.
+		///
+		/// A subclass can override this and, for example, also register
+		/// an event handler for a timeout event.
+		///
+		/// The overriding method must call the baseclass implementation first.
+	{
+		_pReactor = &reactor;
+		_pReactor->addEventHandler(_socket, Poco::Observer<SocketConnector, ReadableNotification>(*this, &SocketConnector::onReadable));
+		_pReactor->addEventHandler(_socket, Poco::Observer<SocketConnector, WritableNotification>(*this, &SocketConnector::onWritable));
+		_pReactor->addEventHandler(_socket, Poco::Observer<SocketConnector, ErrorNotification>(*this, &SocketConnector::onError));
+	}
+	
+	virtual void unregisterConnector()
+		/// Unregisters the SocketConnector.
+		///
+		/// A subclass can override this and, for example, also unregister
+		/// its event handler for a timeout event.
+		///
+		/// The overriding method must call the baseclass implementation first.
+	{
+		if (_pReactor)
+		{
+			_pReactor->removeEventHandler(_socket, Poco::Observer<SocketConnector, ReadableNotification>(*this, &SocketConnector::onReadable));
+			_pReactor->removeEventHandler(_socket, Poco::Observer<SocketConnector, WritableNotification>(*this, &SocketConnector::onWritable));
+			_pReactor->removeEventHandler(_socket, Poco::Observer<SocketConnector, ErrorNotification>(*this, &SocketConnector::onError));
+		}
+	}
+	
+	void onReadable(ReadableNotification* pNotification)
+	{
+		pNotification->release();
+		int err = _socket.impl()->socketError(); 
+		if (err)
+		{
+			onError(err);
+			unregisterConnector();
+		}
+		else
+		{
+			onConnect();
+		}
+	}
+	
+	void onWritable(WritableNotification* pNotification)
+	{
+		pNotification->release();
+		onConnect();
+	}
+	
+	void onConnect()
+	{
+		_socket.setBlocking(true);
+		createServiceHandler();
+		unregisterConnector();
+	}
+	
+	void onError(ErrorNotification* pNotification)
+	{
+		pNotification->release();
+		onError(_socket.impl()->socketError());
+		unregisterConnector();
+	}
+	
+protected:
+	virtual ServiceHandler* createServiceHandler()
+		/// Create and initialize a new ServiceHandler instance.
+		///
+		/// Subclasses can override this method.
+	{
+		return new ServiceHandler(_socket, *_pReactor);
+	}
+
+	virtual void onError(int errorCode)
+		/// Called when the socket cannot be connected.
+		///
+		/// Subclasses can override this method.
+	{
+	}
+	
+	SocketReactor* reactor()
+		/// Returns a pointer to the SocketReactor where
+		/// this SocketConnector is registered.
+		///
+		/// The pointer may be null.
+	{
+		return _pReactor;
+	}
+	
+	StreamSocket& socket()
+		/// Returns a reference to the SocketConnector's socket.
+	{
+		return _socket;
+	}
+
+private:
+	SocketConnector();
+	SocketConnector(const SocketConnector&);
+	SocketConnector& operator = (const SocketConnector&);
+	
+	StreamSocket   _socket;
+	SocketReactor* _pReactor;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_SocketConnector_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/SocketDefs.h b/base/poco/Net/include/Poco/Net/SocketDefs.h
new file mode 100644
index 00000000000..1ba80534d5e
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/SocketDefs.h
@@ -0,0 +1,379 @@
+//
+// SocketDefs.h
+//
+// Library: Net
+// Package: NetCore
+// Module:  SocketDefs
+//
+// Include platform-specific header files for sockets.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_SocketDefs_INCLUDED
+#define Net_SocketDefs_INCLUDED
+
+
+#define POCO_ENOERR 0
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+	#include "Poco/UnWindows.h"
+	#include <winsock2.h>
+	#include <ws2tcpip.h>
+	#define POCO_INVALID_SOCKET  INVALID_SOCKET
+	#define poco_socket_t        SOCKET
+	#define poco_socklen_t       int
+	#define poco_ioctl_request_t int
+	#define poco_closesocket(s)  closesocket(s)
+	#define POCO_EINTR           WSAEINTR
+	#define POCO_EACCES          WSAEACCES
+	#define POCO_EFAULT          WSAEFAULT
+	#define POCO_EINVAL          WSAEINVAL
+	#define POCO_EMFILE          WSAEMFILE
+	#define POCO_EAGAIN          WSAEWOULDBLOCK
+	#define POCO_EWOULDBLOCK     WSAEWOULDBLOCK
+	#define POCO_EINPROGRESS     WSAEINPROGRESS
+	#define POCO_EALREADY        WSAEALREADY
+	#define POCO_ENOTSOCK        WSAENOTSOCK
+	#define POCO_EDESTADDRREQ    WSAEDESTADDRREQ
+	#define POCO_EMSGSIZE        WSAEMSGSIZE
+	#define POCO_EPROTOTYPE      WSAEPROTOTYPE
+	#define POCO_ENOPROTOOPT     WSAENOPROTOOPT
+	#define POCO_EPROTONOSUPPORT WSAEPROTONOSUPPORT
+	#define POCO_ESOCKTNOSUPPORT WSAESOCKTNOSUPPORT
+	#define POCO_ENOTSUP         WSAEOPNOTSUPP
+	#define POCO_EPFNOSUPPORT    WSAEPFNOSUPPORT
+	#define POCO_EAFNOSUPPORT    WSAEAFNOSUPPORT
+	#define POCO_EADDRINUSE      WSAEADDRINUSE
+	#define POCO_EADDRNOTAVAIL   WSAEADDRNOTAVAIL
+	#define POCO_ENETDOWN        WSAENETDOWN
+	#define POCO_ENETUNREACH     WSAENETUNREACH
+	#define POCO_ENETRESET       WSAENETRESET
+	#define POCO_ECONNABORTED    WSAECONNABORTED
+	#define POCO_ECONNRESET      WSAECONNRESET
+	#define POCO_ENOBUFS         WSAENOBUFS
+	#define POCO_EISCONN         WSAEISCONN
+	#define POCO_ENOTCONN        WSAENOTCONN
+	#define POCO_ESHUTDOWN       WSAESHUTDOWN
+	#define POCO_ETIMEDOUT       WSAETIMEDOUT
+	#define POCO_ECONNREFUSED    WSAECONNREFUSED
+	#define POCO_EHOSTDOWN       WSAEHOSTDOWN
+	#define POCO_EHOSTUNREACH    WSAEHOSTUNREACH
+	#define POCO_ESYSNOTREADY    WSASYSNOTREADY
+	#define POCO_ENOTINIT        WSANOTINITIALISED
+	#define POCO_HOST_NOT_FOUND  WSAHOST_NOT_FOUND
+	#define POCO_TRY_AGAIN       WSATRY_AGAIN
+	#define POCO_NO_RECOVERY     WSANO_RECOVERY
+	#define POCO_NO_DATA         WSANO_DATA
+	#ifndef ADDRESS_FAMILY
+		#define ADDRESS_FAMILY USHORT
+	#endif
+#elif defined(POCO_VXWORKS)
+	#include <hostLib.h>
+	#include <ifLib.h>
+	#include <inetLib.h>
+	#include <ioLib.h>
+	#include <resolvLib.h>
+	#include <types.h>
+	#include <socket.h>
+	#include <netinet/tcp.h>
+	#define POCO_INVALID_SOCKET  -1
+	#define poco_socket_t        int
+	#define poco_socklen_t       int
+	#define poco_ioctl_request_t int
+	#define poco_closesocket(s)  ::close(s)
+	#define POCO_EINTR           EINTR
+	#define POCO_EACCES          EACCES
+	#define POCO_EFAULT          EFAULT
+	#define POCO_EINVAL          EINVAL
+	#define POCO_EMFILE          EMFILE
+	#define POCO_EAGAIN          EAGAIN
+	#define POCO_EWOULDBLOCK     EWOULDBLOCK
+	#define POCO_EINPROGRESS     EINPROGRESS
+	#define POCO_EALREADY        EALREADY
+	#define POCO_ENOTSOCK        ENOTSOCK
+	#define POCO_EDESTADDRREQ    EDESTADDRREQ
+	#define POCO_EMSGSIZE        EMSGSIZE
+	#define POCO_EPROTOTYPE      EPROTOTYPE
+	#define POCO_ENOPROTOOPT     ENOPROTOOPT
+	#define POCO_EPROTONOSUPPORT EPROTONOSUPPORT
+	#define POCO_ESOCKTNOSUPPORT ESOCKTNOSUPPORT
+	#define POCO_ENOTSUP         ENOTSUP
+	#define POCO_EPFNOSUPPORT    EPFNOSUPPORT
+	#define POCO_EAFNOSUPPORT    EAFNOSUPPORT
+	#define POCO_EADDRINUSE      EADDRINUSE
+	#define POCO_EADDRNOTAVAIL   EADDRNOTAVAIL
+	#define POCO_ENETDOWN        ENETDOWN
+	#define POCO_ENETUNREACH     ENETUNREACH
+	#define POCO_ENETRESET       ENETRESET
+	#define POCO_ECONNABORTED    ECONNABORTED
+	#define POCO_ECONNRESET      ECONNRESET
+	#define POCO_ENOBUFS         ENOBUFS
+	#define POCO_EISCONN         EISCONN
+	#define POCO_ENOTCONN        ENOTCONN
+	#define POCO_ESHUTDOWN       ESHUTDOWN
+	#define POCO_ETIMEDOUT       ETIMEDOUT
+	#define POCO_ECONNREFUSED    ECONNREFUSED
+	#define POCO_EHOSTDOWN       EHOSTDOWN
+	#define POCO_EHOSTUNREACH    EHOSTUNREACH
+	#define POCO_ESYSNOTREADY    -4
+	#define POCO_ENOTINIT        -5
+	#define POCO_HOST_NOT_FOUND  HOST_NOT_FOUND
+	#define POCO_TRY_AGAIN       TRY_AGAIN
+	#define POCO_NO_RECOVERY     NO_RECOVERY
+	#define POCO_NO_DATA         NO_DATA
+#elif defined(POCO_OS_FAMILY_UNIX)
+	#include <unistd.h>
+	#include <errno.h>
+	#include <sys/types.h>
+	#include <sys/socket.h>
+	#include <sys/un.h>
+	#include <fcntl.h>
+	#if POCO_OS != POCO_OS_HPUX
+		#include <sys/select.h>
+	#endif
+	#include <sys/ioctl.h>
+	#include <arpa/inet.h>
+	#include <netinet/in.h>
+	#include <netinet/tcp.h>
+	#include <netdb.h>
+	#if defined(POCO_OS_FAMILY_UNIX)
+		#if (POCO_OS == POCO_OS_LINUX) || (POCO_OS == POCO_OS_ANDROID)
+			// Net/src/NetworkInterface.cpp changed #include <linux/if.h> to #include <net/if.h>
+			// no more conflict, can use #include <net/if.h> here
+			#include <net/if.h>
+		#elif (POCO_OS == POCO_OS_HPUX)
+			extern "C"
+			{
+				#include <net/if.h>
+			}
+		#else
+			#include <net/if.h>
+		#endif
+	#endif
+	#if (POCO_OS == POCO_OS_SOLARIS) || (POCO_OS == POCO_OS_MAC_OS_X)
+		#include <sys/sockio.h>
+		#include <sys/filio.h>
+	#endif
+	#define POCO_INVALID_SOCKET  -1
+	#define poco_socket_t        int
+	#define poco_socklen_t       socklen_t
+	#define poco_fcntl_request_t int
+	#if defined(POCO_OS_FAMILY_BSD)
+		#define poco_ioctl_request_t unsigned long
+	#else
+		#define poco_ioctl_request_t int
+	#endif
+	#define poco_closesocket(s)  ::close(s)
+	#define POCO_EINTR           EINTR
+	#define POCO_EACCES          EACCES
+	#define POCO_EFAULT          EFAULT
+	#define POCO_EINVAL          EINVAL
+	#define POCO_EMFILE          EMFILE
+	#define POCO_EAGAIN          EAGAIN
+	#define POCO_EWOULDBLOCK     EWOULDBLOCK
+	#define POCO_EINPROGRESS     EINPROGRESS
+	#define POCO_EALREADY        EALREADY
+	#define POCO_ENOTSOCK        ENOTSOCK
+	#define POCO_EDESTADDRREQ    EDESTADDRREQ
+	#define POCO_EMSGSIZE        EMSGSIZE
+	#define POCO_EPROTOTYPE      EPROTOTYPE
+	#define POCO_ENOPROTOOPT     ENOPROTOOPT
+	#define POCO_EPROTONOSUPPORT EPROTONOSUPPORT
+	#if defined(ESOCKTNOSUPPORT)
+		#define POCO_ESOCKTNOSUPPORT ESOCKTNOSUPPORT
+	#else
+		#define POCO_ESOCKTNOSUPPORT -1
+	#endif
+	#define POCO_ENOTSUP         ENOTSUP
+	#define POCO_EPFNOSUPPORT    EPFNOSUPPORT
+	#define POCO_EAFNOSUPPORT    EAFNOSUPPORT
+	#define POCO_EADDRINUSE      EADDRINUSE
+	#define POCO_EADDRNOTAVAIL   EADDRNOTAVAIL
+	#define POCO_ENETDOWN        ENETDOWN
+	#define POCO_ENETUNREACH     ENETUNREACH
+	#define POCO_ENETRESET       ENETRESET
+	#define POCO_ECONNABORTED    ECONNABORTED
+	#define POCO_ECONNRESET      ECONNRESET
+	#define POCO_ENOBUFS         ENOBUFS
+	#define POCO_EISCONN         EISCONN
+	#define POCO_ENOTCONN        ENOTCONN
+	#if defined(ESHUTDOWN)
+		#define POCO_ESHUTDOWN   ESHUTDOWN
+	#else
+		#define POCO_ESHUTDOWN   -2
+	#endif
+	#define POCO_ETIMEDOUT       ETIMEDOUT
+	#define POCO_ECONNREFUSED    ECONNREFUSED
+	#if defined(EHOSTDOWN)
+		#define POCO_EHOSTDOWN   EHOSTDOWN
+	#else
+		#define POCO_EHOSTDOWN   -3
+	#endif
+	#define POCO_EHOSTUNREACH    EHOSTUNREACH
+	#define POCO_ESYSNOTREADY    -4
+	#define POCO_ENOTINIT        -5
+	#define POCO_HOST_NOT_FOUND  HOST_NOT_FOUND
+	#define POCO_TRY_AGAIN       TRY_AGAIN
+	#define POCO_NO_RECOVERY     NO_RECOVERY
+	#define POCO_NO_DATA         NO_DATA
+#endif
+
+
+#if defined(POCO_OS_FAMILY_BSD) || (POCO_OS == POCO_OS_TRU64) || (POCO_OS == POCO_OS_AIX) || (POCO_OS == POCO_OS_IRIX) || (POCO_OS == POCO_OS_QNX) || (POCO_OS == POCO_OS_VXWORKS)
+	#define POCO_HAVE_SALEN 1
+#endif
+
+
+#if POCO_OS != POCO_OS_VXWORKS && !defined(POCO_NET_NO_ADDRINFO)
+	#define POCO_HAVE_ADDRINFO 1
+#endif
+
+/// Without this option, Poco library will restart recv after EINTR,
+/// but it doesn't update socket receive timeout that leads to infinite wait
+/// when query profiler is activated. The issue persisted in delayed_replica_failover
+/// integration test after we enabled query profiler by default.
+#define POCO_BROKEN_TIMEOUTS 1
+
+
+#if defined(POCO_HAVE_ADDRINFO)
+	#ifndef AI_PASSIVE
+		#define AI_PASSIVE 0
+	#endif
+	#ifndef AI_CANONNAME
+		#define AI_CANONNAME 0
+	#endif
+	#ifndef AI_NUMERICHOST
+		#define AI_NUMERICHOST 0
+	#endif
+	#ifndef AI_NUMERICSERV
+		#define AI_NUMERICSERV 0
+	#endif
+	#ifndef AI_ALL
+		#define AI_ALL 0
+	#endif
+	#ifndef AI_ADDRCONFIG
+		#define AI_ADDRCONFIG 0
+	#endif
+	#ifndef AI_V4MAPPED
+		#define AI_V4MAPPED 0
+	#endif
+#endif
+
+
+#if defined(POCO_HAVE_SALEN)
+	#define poco_set_sa_len(pSA, len) (pSA)->sa_len = (len)
+	#define poco_set_sin_len(pSA) (pSA)->sin_len = sizeof(struct sockaddr_in)
+	#if defined(POCO_HAVE_IPv6)
+		#define poco_set_sin6_len(pSA) (pSA)->sin6_len = sizeof(struct sockaddr_in6)
+	#endif
+	#if defined(POCO_OS_FAMILY_UNIX)
+		#define poco_set_sun_len(pSA, len) (pSA)->sun_len = (len)
+	#endif
+#else
+	#define poco_set_sa_len(pSA, len)  (void) 0
+	#define poco_set_sin_len(pSA)      (void) 0
+	#define poco_set_sin6_len(pSA)     (void) 0
+	#define poco_set_sun_len(pSA, len) (void) 0
+#endif
+
+
+#ifndef INADDR_NONE
+	#define INADDR_NONE 0xffffffff
+#endif
+
+#ifndef INADDR_ANY
+	#define INADDR_ANY 0x00000000
+#endif
+
+#ifndef INADDR_BROADCAST
+	#define INADDR_BROADCAST 0xffffffff
+#endif
+
+#ifndef INADDR_LOOPBACK
+	#define INADDR_LOOPBACK 0x7f000001
+#endif
+
+#ifndef INADDR_UNSPEC_GROUP
+	#define INADDR_UNSPEC_GROUP 0xe0000000
+#endif
+
+#ifndef INADDR_ALLHOSTS_GROUP
+	#define INADDR_ALLHOSTS_GROUP 0xe0000001
+#endif
+
+#ifndef INADDR_ALLRTRS_GROUP
+	#define INADDR_ALLRTRS_GROUP 0xe0000002
+#endif
+
+#ifndef INADDR_MAX_LOCAL_GROUP
+	#define INADDR_MAX_LOCAL_GROUP 0xe00000ff
+#endif
+
+#if defined(POCO_ARCH_BIG_ENDIAN)
+	#define poco_ntoh_16(x) (x)
+	#define poco_ntoh_32(x) (x)
+#else
+	#define poco_ntoh_16(x) \
+		((((x) >> 8) & 0x00ff) | (((x) << 8) & 0xff00))
+	#define poco_ntoh_32(x) \
+		((((x) >> 24) & 0x000000ff) | (((x) >> 8) & 0x0000ff00) | (((x) << 8) & 0x00ff0000) | (((x) << 24) & 0xff000000))
+#endif
+#define poco_hton_16(x) poco_ntoh_16(x)
+#define poco_hton_32(x) poco_ntoh_32(x)
+
+
+#if !defined(s6_addr16)
+	#if defined(POCO_OS_FAMILY_WINDOWS)
+		#define s6_addr16 u.Word
+	#else
+		#define s6_addr16 __u6_addr.__u6_addr16
+	#endif
+#endif
+
+
+#if !defined(s6_addr32)
+	#if defined(POCO_OS_FAMILY_UNIX)
+		#if (POCO_OS == POCO_OS_SOLARIS)
+			#define s6_addr32 _S6_un._S6_u32
+		#else
+			#define s6_addr32 __u6_addr.__u6_addr32
+		#endif
+	#endif
+#endif
+
+
+namespace Poco {
+namespace Net {
+
+
+struct AddressFamily
+	/// AddressFamily::Family replaces the previously used IPAddress::Family
+	/// enumeration and is now used for IPAddress::Family and SocketAddress::Family.
+{
+	enum Family
+		/// Possible address families for socket addresses.
+	{
+		IPv4,
+			/// IPv4 address family.
+	#if defined(POCO_HAVE_IPv6)
+		IPv6,
+			/// IPv6 address family.
+	#endif
+	#if defined(POCO_OS_FAMILY_UNIX)
+		UNIX_LOCAL
+			/// UNIX domain socket address family. Available on UNIX/POSIX platforms only.
+	#endif
+	};
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_SocketDefs_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/SocketImpl.h b/base/poco/Net/include/Poco/Net/SocketImpl.h
new file mode 100644
index 00000000000..d1fec1de7d6
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/SocketImpl.h
@@ -0,0 +1,503 @@
+//
+// SocketImpl.h
+//
+// Library: Net
+// Package: Sockets
+// Module:  SocketImpl
+//
+// Definition of the SocketImpl class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_SocketImpl_INCLUDED
+#define Net_SocketImpl_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/SocketDefs.h"
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/Timespan.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API SocketImpl: public Poco::RefCountedObject
+	/// This class encapsulates the Berkeley sockets API.
+	///
+	/// Subclasses implement specific socket types like
+	/// stream or datagram sockets.
+	///
+	/// You should not create any instances of this class.
+{
+public:
+	enum SelectMode
+	{
+		SELECT_READ  = 1,
+		SELECT_WRITE = 2,
+		SELECT_ERROR = 4
+	};
+
+	virtual SocketImpl* acceptConnection(SocketAddress& clientAddr);
+		/// Get the next completed connection from the
+		/// socket's completed connection queue.
+		///
+		/// If the queue is empty, waits until a connection
+		/// request completes.
+		///
+		/// Returns a new TCP socket for the connection
+		/// with the client.
+		///
+		/// The client socket's address is returned in clientAddr.
+
+	virtual void connect(const SocketAddress& address);
+		/// Initializes the socket and establishes a connection to
+		/// the TCP server at the given address.
+		///
+		/// Can also be used for UDP sockets. In this case, no
+		/// connection is established. Instead, incoming and outgoing
+		/// packets are restricted to the specified address.
+
+	virtual void connect(const SocketAddress& address, const Poco::Timespan& timeout);
+		/// Initializes the socket, sets the socket timeout and
+		/// establishes a connection to the TCP server at the given address.
+
+	virtual void connectNB(const SocketAddress& address);
+		/// Initializes the socket and establishes a connection to
+		/// the TCP server at the given address. Prior to opening the
+		/// connection the socket is set to nonblocking mode.
+
+	virtual void bind(const SocketAddress& address, bool reuseAddress = false);
+		/// Bind a local address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. TCP clients should not bind a socket to a
+		/// specific address.
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+
+	virtual void bind(const SocketAddress& address, bool reuseAddress, bool reusePort );
+		/// Bind a local address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. TCP clients should not bind a socket to a
+		/// specific address.
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// If reusePort is true, sets the SO_REUSEPORT
+		/// socket option.
+
+	virtual void bind6(const SocketAddress& address, bool reuseAddress = false, bool ipV6Only = false);
+		/// Bind a local IPv6 address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. TCP clients should not bind a socket to a
+		/// specific address.
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// The given address must be an IPv6 address. The
+		/// IPPROTO_IPV6/IPV6_V6ONLY option is set on the socket
+		/// according to the ipV6Only parameter.
+		///
+		/// If the library has not been built with IPv6 support,
+		/// a Poco::NotImplementedException will be thrown.
+
+	virtual void bind6(const SocketAddress& address, bool reuseAddress, bool reusePort,  bool ipV6Only);
+		/// Bind a local IPv6 address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. TCP clients should not bind a socket to a
+		/// specific address.
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		///
+		/// If reusePort is true, sets the SO_REUSEPORT
+		/// socket option.
+		///
+		/// The given address must be an IPv6 address. The
+		/// IPPROTO_IPV6/IPV6_V6ONLY option is set on the socket
+		/// according to the ipV6Only parameter.
+		///
+		/// If the library has not been built with IPv6 support,
+		/// a Poco::NotImplementedException will be thrown.
+
+	virtual void listen(int backlog = 64);
+		/// Puts the socket into listening state.
+		///
+		/// The socket becomes a passive socket that
+		/// can accept incoming connection requests.
+		///
+		/// The backlog argument specifies the maximum
+		/// number of connections that can be queued
+		/// for this socket.
+
+	virtual void close();
+		/// Close the socket.
+
+	virtual void shutdownReceive();
+		/// Shuts down the receiving part of the socket connection.
+
+	virtual void shutdownSend();
+		/// Shuts down the sending part of the socket connection.
+
+	virtual void shutdown();
+		/// Shuts down both the receiving and the sending part
+		/// of the socket connection.
+
+	virtual int sendBytes(const void* buffer, int length, int flags = 0);
+		/// Sends the contents of the given buffer through
+		/// the socket.
+		///
+		/// Returns the number of bytes sent, which may be
+		/// less than the number of bytes specified.
+		///
+		/// Certain socket implementations may also return a negative
+		/// value denoting a certain condition.
+
+	virtual int receiveBytes(void* buffer, int length, int flags = 0);
+		/// Receives data from the socket and stores it
+		/// in buffer. Up to length bytes are received.
+		///
+		/// Returns the number of bytes received.
+		///
+		/// Certain socket implementations may also return a negative
+		/// value denoting a certain condition.
+
+	virtual int sendTo(const void* buffer, int length, const SocketAddress& address, int flags = 0);
+		/// Sends the contents of the given buffer through
+		/// the socket to the given address.
+		///
+		/// Returns the number of bytes sent, which may be
+		/// less than the number of bytes specified.
+
+	virtual int receiveFrom(void* buffer, int length, SocketAddress& address, int flags = 0);
+		/// Receives data from the socket and stores it
+		/// in buffer. Up to length bytes are received.
+		/// Stores the address of the sender in address.
+		///
+		/// Returns the number of bytes received.
+
+	virtual void sendUrgent(unsigned char data);
+		/// Sends one byte of urgent data through
+		/// the socket.
+		///
+		/// The data is sent with the MSG_OOB flag.
+		///
+		/// The preferred way for a socket to receive urgent data
+		/// is by enabling the SO_OOBINLINE option.
+
+	virtual int available();
+		/// Returns the number of bytes available that can be read
+		/// without causing the socket to block.
+
+	virtual bool poll(const Poco::Timespan& timeout, int mode);
+		/// Determines the status of the socket, using a
+		/// call to select().
+		///
+		/// The mode argument is constructed by combining the values
+		/// of the SelectMode enumeration.
+		///
+		/// Returns true if the next operation corresponding to
+		/// mode will not block, false otherwise.
+
+	bool pollImpl(Poco::Timespan& timeout, int mode);
+		/// Modifies `timeout`
+
+	virtual void setSendBufferSize(int size);
+		/// Sets the size of the send buffer.
+
+	virtual int getSendBufferSize();
+		/// Returns the size of the send buffer.
+		///
+		/// The returned value may be different than the
+		/// value previously set with setSendBufferSize(),
+		/// as the system is free to adjust the value.
+
+	virtual void setReceiveBufferSize(int size);
+		/// Sets the size of the receive buffer.
+
+	virtual int getReceiveBufferSize();
+		/// Returns the size of the receive buffer.
+		///
+		/// The returned value may be different than the
+		/// value previously set with setReceiveBufferSize(),
+		/// as the system is free to adjust the value.
+
+	virtual void setSendTimeout(const Poco::Timespan& timeout);
+		/// Sets the send timeout for the socket.
+
+	virtual Poco::Timespan getSendTimeout();
+		/// Returns the send timeout for the socket.
+		///
+		/// The returned timeout may be different than the
+		/// timeout previously set with setSendTimeout(),
+		/// as the system is free to adjust the value.
+
+	virtual void setReceiveTimeout(const Poco::Timespan& timeout);
+		/// Sets the send timeout for the socket.
+		///
+		/// On systems that do not support SO_RCVTIMEO, a
+		/// workaround using poll() is provided.
+
+	virtual Poco::Timespan getReceiveTimeout();
+		/// Returns the receive timeout for the socket.
+		///
+		/// The returned timeout may be different than the
+		/// timeout previously set with setReceiveTimeout(),
+		/// as the system is free to adjust the value.
+
+	virtual SocketAddress address();
+		/// Returns the IP address and port number of the socket.
+
+	virtual SocketAddress peerAddress();
+		/// Returns the IP address and port number of the peer socket.
+
+	void setOption(int level, int option, int value);
+		/// Sets the socket option specified by level and option
+		/// to the given integer value.
+
+	void setOption(int level, int option, unsigned value);
+		/// Sets the socket option specified by level and option
+		/// to the given integer value.
+
+	void setOption(int level, int option, unsigned char value);
+		/// Sets the socket option specified by level and option
+		/// to the given integer value.
+
+	void setOption(int level, int option, const Poco::Timespan& value);
+		/// Sets the socket option specified by level and option
+		/// to the given time value.
+
+	void setOption(int level, int option, const IPAddress& value);
+		/// Sets the socket option specified by level and option
+		/// to the given time value.
+
+	virtual void setRawOption(int level, int option, const void* value, poco_socklen_t length);
+		/// Sets the socket option specified by level and option
+		/// to the given time value.
+
+	void getOption(int level, int option, int& value);
+		/// Returns the value of the socket option
+		/// specified by level and option.
+
+	void getOption(int level, int option, unsigned& value);
+		/// Returns the value of the socket option
+		/// specified by level and option.
+
+	void getOption(int level, int option, unsigned char& value);
+		/// Returns the value of the socket option
+		/// specified by level and option.
+
+	void getOption(int level, int option, Poco::Timespan& value);
+		/// Returns the value of the socket option
+		/// specified by level and option.
+
+	void getOption(int level, int option, IPAddress& value);
+		/// Returns the value of the socket option
+		/// specified by level and option.
+
+	virtual void getRawOption(int level, int option, void* value, poco_socklen_t& length);
+		/// Returns the value of the socket option
+		/// specified by level and option.
+
+	void setLinger(bool on, int seconds);
+		/// Sets the value of the SO_LINGER socket option.
+
+	void getLinger(bool& on, int& seconds);
+		/// Returns the value of the SO_LINGER socket option.
+
+	void setNoDelay(bool flag);
+		/// Sets the value of the TCP_NODELAY socket option.
+
+	bool getNoDelay();
+		/// Returns the value of the TCP_NODELAY socket option.
+
+	void setKeepAlive(bool flag);
+		/// Sets the value of the SO_KEEPALIVE socket option.
+
+	bool getKeepAlive();
+		/// Returns the value of the SO_KEEPALIVE socket option.
+
+	void setReuseAddress(bool flag);
+		/// Sets the value of the SO_REUSEADDR socket option.
+
+	bool getReuseAddress();
+		/// Returns the value of the SO_REUSEADDR socket option.
+
+	void setReusePort(bool flag);
+		/// Sets the value of the SO_REUSEPORT socket option.
+		/// Does nothing if the socket implementation does not
+		/// support SO_REUSEPORT.
+
+	bool getReusePort();
+		/// Returns the value of the SO_REUSEPORT socket option.
+		///
+		/// Returns false if the socket implementation does not
+		/// support SO_REUSEPORT.
+
+	void setOOBInline(bool flag);
+		/// Sets the value of the SO_OOBINLINE socket option.
+
+	bool getOOBInline();
+		/// Returns the value of the SO_OOBINLINE socket option.
+
+	void setBroadcast(bool flag);
+		/// Sets the value of the SO_BROADCAST socket option.
+
+	bool getBroadcast();
+		/// Returns the value of the SO_BROADCAST socket option.
+
+	virtual void setBlocking(bool flag);
+		/// Sets the socket in blocking mode if flag is true,
+		/// disables blocking mode if flag is false.
+
+	virtual bool getBlocking() const;
+		/// Returns the blocking mode of the socket.
+		/// This method will only work if the blocking modes of
+		/// the socket are changed via the setBlocking method!
+
+	virtual bool secure() const;
+		/// Returns true iff the socket's connection is secure
+		/// (using SSL or TLS).
+
+	int socketError();
+		/// Returns the value of the SO_ERROR socket option.
+
+	poco_socket_t sockfd() const;
+		/// Returns the socket descriptor for the
+		/// underlying native socket.
+
+	void ioctl(poco_ioctl_request_t request, int& arg);
+		/// A wrapper for the ioctl system call.
+
+	void ioctl(poco_ioctl_request_t request, void* arg);
+		/// A wrapper for the ioctl system call.
+
+#if defined(POCO_OS_FAMILY_UNIX)
+	int fcntl(poco_fcntl_request_t request);
+		/// A wrapper for the fcntl system call.
+
+	int fcntl(poco_fcntl_request_t request, long arg);
+		/// A wrapper for the fcntl system call.
+#endif
+
+	bool initialized() const;
+		/// Returns true iff the underlying socket is initialized.
+
+protected:
+	SocketImpl();
+		/// Creates a SocketImpl.
+
+	SocketImpl(poco_socket_t sockfd);
+		/// Creates a SocketImpl using the given native socket.
+
+	virtual ~SocketImpl();
+		/// Destroys the SocketImpl.
+		/// Closes the socket if it is still open.
+
+	virtual void init(int af);
+		/// Creates the underlying native socket.
+		///
+		/// Subclasses must implement this method so
+		/// that it calls initSocket() with the
+		/// appropriate arguments.
+		///
+		/// The default implementation creates a
+		/// stream socket.
+
+	void initSocket(int af, int type, int proto = 0);
+		/// Creates the underlying native socket.
+		///
+		/// The first argument, af, specifies the address family
+		/// used by the socket, which should be either AF_INET or
+		/// AF_INET6.
+		///
+		/// The second argument, type, specifies the type of the
+		/// socket, which can be one of SOCK_STREAM, SOCK_DGRAM
+		/// or SOCK_RAW.
+		///
+		/// The third argument, proto, is normally set to 0,
+		/// except for raw sockets.
+
+	void reset(poco_socket_t fd = POCO_INVALID_SOCKET);
+		/// Allows subclasses to set the socket manually, iff no valid socket is set yet.
+
+	static int lastError();
+		/// Returns the last error code.
+
+	static void error();
+		/// Throws an appropriate exception for the last error.
+
+	static void error(const std::string& arg);
+		/// Throws an appropriate exception for the last error.
+
+	static void error(int code);
+		/// Throws an appropriate exception for the given error code.
+
+	static void error(int code, const std::string& arg);
+		/// Throws an appropriate exception for the given error code.
+
+protected:
+	SocketImpl(const SocketImpl&);
+	SocketImpl& operator = (const SocketImpl&);
+
+	poco_socket_t _sockfd;
+	Poco::Timespan _recvTimeout;
+	Poco::Timespan _sndTimeout;
+	bool          _blocking;
+	bool          _isBrokenTimeout;
+
+	friend class Socket;
+	friend class SecureSocketImpl;
+	friend class PollSetImpl;
+};
+
+
+//
+// inlines
+//
+inline poco_socket_t SocketImpl::sockfd() const
+{
+	return _sockfd;
+}
+
+
+inline bool SocketImpl::initialized() const
+{
+	return _sockfd != POCO_INVALID_SOCKET;
+}
+
+
+inline int SocketImpl::lastError()
+{
+#if defined(_WIN32)
+	return WSAGetLastError();
+#else
+	return errno;
+#endif
+}
+
+
+inline bool SocketImpl::getBlocking() const
+{
+	return _blocking;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_SocketImpl_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/SocketNotification.h b/base/poco/Net/include/Poco/Net/SocketNotification.h
new file mode 100644
index 00000000000..7b857ecfe8c
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/SocketNotification.h
@@ -0,0 +1,153 @@
+//
+// SocketNotification.h
+//
+// Library: Net
+// Package: Reactor
+// Module:  SocketNotification
+//
+// Definition of the SocketNotification class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_SocketNotification_INCLUDED
+#define Net_SocketNotification_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/Socket.h"
+#include "Poco/Notification.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class SocketReactor;
+
+
+class Net_API SocketNotification: public Poco::Notification
+	/// The base class for all notifications generated by
+	/// the SocketReactor.
+{
+public:
+	explicit SocketNotification(SocketReactor* pReactor);
+		/// Creates the SocketNotification for the given SocketReactor.
+
+	virtual ~SocketNotification();
+		/// Destroys the SocketNotification.
+		
+	SocketReactor& source() const;
+		/// Returns the SocketReactor that generated the notification.	
+		
+	Socket socket() const;
+		/// Returns the socket that caused the notification.
+
+private:
+	void setSocket(const Socket& socket);
+	
+	SocketReactor* _pReactor;
+	Socket         _socket;
+	
+	friend class SocketNotifier;
+};
+
+
+class Net_API ReadableNotification: public SocketNotification
+	/// This notification is sent if a socket has become readable.
+{
+public:
+	ReadableNotification(SocketReactor* pReactor);
+		/// Creates the ReadableNotification for the given SocketReactor.
+
+	~ReadableNotification();
+		/// Destroys the ReadableNotification.
+};
+
+
+class Net_API WritableNotification: public SocketNotification
+	/// This notification is sent if a socket has become writable.
+{
+public:
+	WritableNotification(SocketReactor* pReactor);
+		/// Creates the WritableNotification for the given SocketReactor.
+
+	~WritableNotification();
+		/// Destroys the WritableNotification.
+};
+
+
+class Net_API ErrorNotification: public SocketNotification
+	/// This notification is sent if a socket has signalled an error.
+{
+public:
+	ErrorNotification(SocketReactor* pReactor);
+		/// Creates the ErrorNotification for the given SocketReactor.
+
+	~ErrorNotification();
+		/// Destroys the ErrorNotification.
+};
+
+
+class Net_API TimeoutNotification: public SocketNotification
+	/// This notification is sent if no other event has occurred
+	/// for a specified time.
+{
+public:
+	TimeoutNotification(SocketReactor* pReactor);
+		/// Creates the TimeoutNotification for the given SocketReactor.
+
+	~TimeoutNotification();
+		/// Destroys the TimeoutNotification.
+};
+
+
+class Net_API IdleNotification: public SocketNotification
+	/// This notification is sent when the SocketReactor does
+	/// not have any sockets to react to.
+{
+public:
+	IdleNotification(SocketReactor* pReactor);
+		/// Creates the IdleNotification for the given SocketReactor.
+
+	~IdleNotification();
+		/// Destroys the IdleNotification.
+};
+
+
+class Net_API ShutdownNotification: public SocketNotification
+	/// This notification is sent when the SocketReactor is
+	/// about to shut down.
+{
+public:
+	ShutdownNotification(SocketReactor* pReactor);
+		/// Creates the ShutdownNotification for the given SocketReactor.
+
+	~ShutdownNotification();
+		/// Destroys the ShutdownNotification.
+};
+
+
+//
+// inlines
+//
+inline SocketReactor& SocketNotification::source() const
+{
+	return *_pReactor;
+}
+
+	
+inline Socket SocketNotification::socket() const
+{
+	return _socket;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_SocketNotification_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/SocketNotifier.h b/base/poco/Net/include/Poco/Net/SocketNotifier.h
new file mode 100644
index 00000000000..a98e407a3dd
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/SocketNotifier.h
@@ -0,0 +1,110 @@
+//
+// SocketNotifier.h
+//
+// Library: Net
+// Package: Reactor
+// Module:  SocketNotifier
+//
+// Definition of the SocketNotifier class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_SocketNotifier_INCLUDED
+#define Net_SocketNotifier_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/Socket.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/NotificationCenter.h"
+#include "Poco/Observer.h"
+#include <set>
+
+
+namespace Poco {
+namespace Net {
+
+
+class Socket;
+class SocketReactor;
+class SocketNotification;
+
+
+class Net_API SocketNotifier: public Poco::RefCountedObject
+	/// This class is used internally by SocketReactor
+	/// to notify registered event handlers of socket events.
+{
+public:
+	explicit SocketNotifier(const Socket& socket);
+		/// Creates the SocketNotifier for the given socket.
+		
+	void addObserver(SocketReactor* pReactor, const Poco::AbstractObserver& observer);
+		/// Adds the given observer. 
+		
+	void removeObserver(SocketReactor* pReactor, const Poco::AbstractObserver& observer);
+		/// Removes the given observer. 
+		
+	bool hasObserver(const Poco::AbstractObserver& observer) const;
+		/// Returns true if the given observer is registered.
+		
+	bool accepts(SocketNotification* pNotification);
+		/// Returns true if there is at least one observer for the given notification.
+		
+	void dispatch(SocketNotification* pNotification);
+		/// Dispatches the notification to all observers.
+		
+	bool hasObservers() const;
+		/// Returns true if there are subscribers.
+		
+	std::size_t countObservers() const;
+		/// Returns the number of subscribers;
+
+protected:
+	~SocketNotifier();
+		/// Destroys the SocketNotifier.
+
+private:
+	typedef std::multiset<SocketNotification*> EventSet;
+
+	EventSet                 _events;
+	Poco::NotificationCenter _nc;
+	Socket                   _socket;
+};
+
+
+//
+// inlines
+//
+inline bool SocketNotifier::accepts(SocketNotification* pNotification)
+{
+	return _events.find(pNotification) != _events.end();
+}
+
+
+inline bool SocketNotifier::hasObserver(const Poco::AbstractObserver& observer) const
+{
+	return _nc.hasObserver(observer);
+}
+
+
+inline bool SocketNotifier::hasObservers() const
+{
+	return _nc.hasObservers();
+}
+
+
+inline std::size_t SocketNotifier::countObservers() const
+{
+	return _nc.countObservers();
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_SocketNotifier_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/SocketReactor.h b/base/poco/Net/include/Poco/Net/SocketReactor.h
new file mode 100644
index 00000000000..06c40bbd6ab
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/SocketReactor.h
@@ -0,0 +1,235 @@
+//
+// SocketReactor.h
+//
+// Library: Net
+// Package: Reactor
+// Module:  SocketReactor
+//
+// Definition of the SocketReactor class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_SocketReactor_INCLUDED
+#define Net_SocketReactor_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/Socket.h"
+#include "Poco/Runnable.h"
+#include "Poco/Timespan.h"
+#include "Poco/Observer.h"
+#include "Poco/AutoPtr.h"
+#include <map>
+
+
+namespace Poco {
+
+
+class Thread;
+
+
+namespace Net {
+
+
+class Socket;
+class SocketNotification;
+class SocketNotifier;
+
+
+class Net_API SocketReactor: public Poco::Runnable
+	/// This class, which is part of the Reactor pattern,
+	/// implements the "Initiation Dispatcher".
+	///
+	/// The Reactor pattern has been described in the book
+	/// "Pattern Languages of Program Design" by Jim Coplien
+	/// and Douglas C. Schmidt (Addison Wesley, 1995).
+	///
+	/// The Reactor design pattern handles service requests that
+	/// are delivered concurrently to an application by one or more
+	/// clients. Each service in an application may consist of several
+	/// methods and is represented by a separate event handler. The event
+	/// handler is responsible for servicing service-specific requests.
+	/// The SocketReactor dispatches the event handlers.
+	///
+	/// Event handlers (any class can be an event handler - there
+	/// is no base class for event handlers) can be registered
+	/// with the addEventHandler() method and deregistered with
+	/// the removeEventHandler() method.
+	/// 
+	/// An event handler is always registered for a certain socket,
+	/// which is given in the call to addEventHandler(). Any method
+	/// of the event handler class can be registered to handle the
+	/// event - the only requirement is that the method takes
+	/// a pointer to an instance of SocketNotification (or a subclass of it)
+	/// as argument.
+	///
+	/// Once started, the SocketReactor waits for events
+	/// on the registered sockets, using Socket::select().
+	/// If an event is detected, the corresponding event handler
+	/// is invoked. There are five event types (and corresponding
+	/// notification classes) defined: ReadableNotification, WritableNotification,
+	/// ErrorNotification, TimeoutNotification, IdleNotification and 
+	/// ShutdownNotification.
+	/// 
+	/// The ReadableNotification will be dispatched if a socket becomes
+	/// readable. The WritableNotification will be dispatched if a socket
+	/// becomes writable. The ErrorNotification will be dispatched if
+	/// there is an error condition on a socket.
+	///
+	/// If the timeout expires and no event has occurred, a
+	/// TimeoutNotification will be dispatched to all event handlers
+	/// registered for it. This is done in the onTimeout() method
+	/// which can be overridden by subclasses to perform custom
+	/// timeout processing.
+	///
+	/// If there are no sockets for the SocketReactor to pass to
+	/// Socket::select(), an IdleNotification will be dispatched to
+	/// all event handlers registered for it. This is done in the
+	/// onIdle() method which can be overridden by subclasses
+	/// to perform custom idle processing. Since onIdle() will be
+	/// called repeatedly in a loop, it is recommended to do a
+	/// short sleep or yield in the event handler.
+	///
+	/// Finally, when the SocketReactor is about to shut down (as a result 
+	/// of stop() being called), it dispatches a ShutdownNotification
+	/// to all event handlers. This is done in the onShutdown() method
+	/// which can be overridded by subclasses to perform custom
+	/// shutdown processing.
+	///
+	/// The SocketReactor is implemented so that it can 
+	/// run in its own thread. It is also possible to run
+	/// multiple SocketReactors in parallel, as long as
+	/// they work on different sockets.
+	///
+	/// It is safe to call addEventHandler() and removeEventHandler()
+	/// from another thread while the SocketReactor is running. Also,
+	/// it is safe to call addEventHandler() and removeEventHandler()
+	/// from event handlers.
+{
+public:
+	SocketReactor();
+		/// Creates the SocketReactor.
+
+	explicit SocketReactor(const Poco::Timespan& timeout);
+		/// Creates the SocketReactor, using the given timeout.
+
+	virtual ~SocketReactor();
+		/// Destroys the SocketReactor.
+
+	void run();
+		/// Runs the SocketReactor. The reactor will run
+		/// until stop() is called (in a separate thread).
+		
+	void stop();
+		/// Stops the SocketReactor.
+		///
+		/// The reactor will be stopped when the next event
+		/// (including a timeout event) occurs.
+
+	void wakeUp();
+		/// Wakes up idle reactor.
+
+	void setTimeout(const Poco::Timespan& timeout);
+		/// Sets the timeout. 
+		///
+		/// If no other event occurs for the given timeout 
+		/// interval, a timeout event is sent to all event listeners.
+		///
+		/// The default timeout is 250 milliseconds;
+		///
+		/// The timeout is passed to the Socket::select()
+		/// method.
+		
+	const Poco::Timespan& getTimeout() const;
+		/// Returns the timeout.
+
+	void addEventHandler(const Socket& socket, const Poco::AbstractObserver& observer);
+		/// Registers an event handler with the SocketReactor.
+		///
+		/// Usage:
+		///     Poco::Observer<MyEventHandler, SocketNotification> obs(*this, &MyEventHandler::handleMyEvent);
+		///     reactor.addEventHandler(obs);
+
+	bool hasEventHandler(const Socket& socket, const Poco::AbstractObserver& observer);
+		/// Returns true if the observer is registered with SocketReactor for the given socket.
+
+	void removeEventHandler(const Socket& socket, const Poco::AbstractObserver& observer);
+		/// Unregisters an event handler with the SocketReactor.
+		///
+		/// Usage:
+		///     Poco::Observer<MyEventHandler, SocketNotification> obs(*this, &MyEventHandler::handleMyEvent);
+		///     reactor.removeEventHandler(obs);
+
+protected:
+	virtual void onTimeout();
+		/// Called if the timeout expires and no other events are available.
+		///
+		/// Can be overridden by subclasses. The default implementation
+		/// dispatches the TimeoutNotification and thus should be called by overriding
+		/// implementations.
+
+	virtual void onIdle();
+		/// Called if no sockets are available to call select() on.
+		///
+		/// Can be overridden by subclasses. The default implementation
+		/// dispatches the IdleNotification and thus should be called by overriding
+		/// implementations.
+
+	virtual void onShutdown();
+		/// Called when the SocketReactor is about to terminate.
+		///
+		/// Can be overridden by subclasses. The default implementation
+		/// dispatches the ShutdownNotification and thus should be called by overriding
+		/// implementations.
+
+	virtual void onBusy();
+		/// Called when the SocketReactor is busy and at least one notification
+		/// has been dispatched.
+		///
+		/// Can be overridden by subclasses to perform additional
+		/// periodic tasks. The default implementation does nothing.
+
+	void dispatch(const Socket& socket, SocketNotification* pNotification);
+		/// Dispatches the given notification to all observers
+		/// registered for the given socket.
+		
+	void dispatch(SocketNotification* pNotification);
+		/// Dispatches the given notification to all observers.
+
+private:
+	typedef Poco::AutoPtr<SocketNotifier>     NotifierPtr;
+	typedef Poco::AutoPtr<SocketNotification> NotificationPtr;
+	typedef std::map<Socket, NotifierPtr>     EventHandlerMap;
+
+	void dispatch(NotifierPtr& pNotifier, SocketNotification* pNotification);
+
+	enum
+	{
+		DEFAULT_TIMEOUT = 250000
+	};
+
+	bool            _stop;
+	Poco::Timespan  _timeout;
+	EventHandlerMap _handlers;
+	NotificationPtr _pReadableNotification;
+	NotificationPtr _pWritableNotification;
+	NotificationPtr _pErrorNotification;
+	NotificationPtr _pTimeoutNotification;
+	NotificationPtr _pIdleNotification;
+	NotificationPtr _pShutdownNotification;
+	Poco::FastMutex _mutex;
+	Poco::Thread*   _pThread;
+	
+	friend class SocketNotifier;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_SocketReactor_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/SocketStream.h b/base/poco/Net/include/Poco/Net/SocketStream.h
new file mode 100644
index 00000000000..5a9a62c0eff
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/SocketStream.h
@@ -0,0 +1,177 @@
+//
+// SocketStream.h
+//
+// Library: Net
+// Package: Sockets
+// Module:  SocketStream
+//
+// Definition of the SocketStream class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_SocketStream_INCLUDED
+#define Net_SocketStream_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/StreamSocket.h"
+#include "Poco/BufferedBidirectionalStreamBuf.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class StreamSocketImpl;
+
+
+class Net_API SocketStreamBuf: public Poco::BufferedBidirectionalStreamBuf
+	/// This is the streambuf class used for reading from and writing to a socket.
+{
+public:
+	SocketStreamBuf(const Socket& socket);
+		/// Creates a SocketStreamBuf with the given socket.
+		///
+		/// The socket's SocketImpl must be a StreamSocketImpl,
+		/// otherwise an InvalidArgumentException is thrown.
+
+	~SocketStreamBuf();
+		/// Destroys the SocketStreamBuf.
+		
+	StreamSocketImpl* socketImpl() const;
+		/// Returns the internal SocketImpl.
+	
+protected:
+	int readFromDevice(char* buffer, std::streamsize length);
+	int writeToDevice(const char* buffer, std::streamsize length);
+
+private:
+	enum 
+	{
+		STREAM_BUFFER_SIZE = 1024
+	};
+
+	StreamSocketImpl* _pImpl;
+};
+
+
+class Net_API SocketIOS: public virtual std::ios
+	/// The base class for SocketStream, SocketInputStream and
+	/// SocketOutputStream.
+	///
+	/// This class is needed to ensure the correct initialization
+	/// order of the stream buffer and base classes.
+{
+public:
+	SocketIOS(const Socket& socket);
+		/// Creates the SocketIOS with the given socket.
+		///
+		/// The socket's SocketImpl must be a StreamSocketImpl,
+		/// otherwise an InvalidArgumentException is thrown.
+		
+	~SocketIOS();
+		/// Destroys the SocketIOS.
+		///
+		/// Flushes the buffer, but does not close the socket.
+		
+	SocketStreamBuf* rdbuf();
+		/// Returns a pointer to the internal SocketStreamBuf.
+		
+	void close();
+		/// Flushes the stream and closes the socket.
+		
+	StreamSocket socket() const;
+		/// Returns the underlying socket.
+
+protected:
+	SocketStreamBuf _buf;
+};
+
+
+class Net_API SocketOutputStream: public SocketIOS, public std::ostream
+	/// An output stream for writing to a socket.
+{
+public:
+	explicit SocketOutputStream(const Socket& socket);
+		/// Creates the SocketOutputStream with the given socket.
+		///
+		/// The socket's SocketImpl must be a StreamSocketImpl,
+		/// otherwise an InvalidArgumentException is thrown.
+
+	~SocketOutputStream();
+		/// Destroys the SocketOutputStream.
+		///
+		/// Flushes the buffer, but does not close the socket.
+};
+
+
+class Net_API SocketInputStream: public SocketIOS, public std::istream
+	/// An input stream for reading from a socket.
+	///
+	/// When using formatted input from a SocketInputStream,
+	/// always ensure that a receive timeout is set for the
+	/// socket. Otherwise your program might unexpectedly
+	/// hang.
+	///
+	/// However, using formatted input from a SocketInputStream
+	/// is not recommended, due to the read-ahead behavior of
+	/// istream with formatted reads.
+{
+public:
+	explicit SocketInputStream(const Socket& socket);
+		/// Creates the SocketInputStream with the given socket.
+		///
+		/// The socket's SocketImpl must be a StreamSocketImpl,
+		/// otherwise an InvalidArgumentException is thrown.
+
+	~SocketInputStream();
+		/// Destroys the SocketInputStream.
+};
+
+
+class Net_API SocketStream: public SocketIOS, public std::iostream
+	/// An bidirectional stream for reading from and writing to a socket.
+	///
+	/// When using formatted input from a SocketStream,
+	/// always ensure that a receive timeout is set for the
+	/// socket. Otherwise your program might unexpectedly
+	/// hang.
+	///
+	/// However, using formatted input from a SocketStream
+	/// is not recommended, due to the read-ahead behavior of
+	/// istream with formatted reads.
+{
+public:
+	explicit SocketStream(const Socket& socket);
+		/// Creates the SocketStream with the given socket.
+		///
+		/// The socket's SocketImpl must be a StreamSocketImpl,
+		/// otherwise an InvalidArgumentException is thrown.
+
+	~SocketStream();
+		/// Destroys the SocketStream.
+		///
+		/// Flushes the buffer, but does not close the socket.
+};
+
+
+//
+// inlines
+//
+inline StreamSocketImpl* SocketStreamBuf::socketImpl() const
+{
+	return _pImpl;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_SocketStream_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/StreamSocket.h b/base/poco/Net/include/Poco/Net/StreamSocket.h
new file mode 100644
index 00000000000..46374d85dca
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/StreamSocket.h
@@ -0,0 +1,180 @@
+//
+// StreamSocket.h
+//
+// Library: Net
+// Package: Sockets
+// Module:  StreamSocket
+//
+// Definition of the StreamSocket class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_StreamSocket_INCLUDED
+#define Net_StreamSocket_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/Socket.h"
+#include "Poco/FIFOBuffer.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class StreamSocketImpl;
+
+
+class Net_API StreamSocket: public Socket
+	/// This class provides an interface to a
+	/// TCP stream socket.
+{
+public:
+	StreamSocket();
+		/// Creates an unconnected stream socket.
+		///
+		/// Before sending or receiving data, the socket
+		/// must be connected with a call to connect().
+
+	explicit StreamSocket(const SocketAddress& address);
+		/// Creates a stream socket and connects it to
+		/// the socket specified by address.
+
+	explicit StreamSocket(SocketAddress::Family family);
+		/// Creates an unconnected stream socket
+		/// for the given address family.
+		///
+		/// This is useful if certain socket options
+		/// (like send and receive buffer) sizes, that must 
+		/// be set before connecting the socket, will be
+		/// set later on.
+
+	StreamSocket(const Socket& socket);
+		/// Creates the StreamSocket with the SocketImpl
+		/// from another socket. The SocketImpl must be
+		/// a StreamSocketImpl, otherwise an InvalidArgumentException
+		/// will be thrown.
+
+	virtual ~StreamSocket();
+		/// Destroys the StreamSocket.
+
+	StreamSocket& operator = (const Socket& socket);
+		/// Assignment operator.
+		///
+		/// Releases the socket's SocketImpl and
+		/// attaches the SocketImpl from the other socket and
+		/// increments the reference count of the SocketImpl.	
+
+	void connect(const SocketAddress& address);
+		/// Initializes the socket and establishes a connection to 
+		/// the TCP server at the given address.
+		///
+		/// Can also be used for UDP sockets. In this case, no
+		/// connection is established. Instead, incoming and outgoing
+		/// packets are restricted to the specified address.
+
+	void connect(const SocketAddress& address, const Poco::Timespan& timeout);
+		/// Initializes the socket, sets the socket timeout and 
+		/// establishes a connection to the TCP server at the given address.
+
+	void connectNB(const SocketAddress& address);
+		/// Initializes the socket and establishes a connection to 
+		/// the TCP server at the given address. Prior to opening the
+		/// connection the socket is set to nonblocking mode.
+
+	void shutdownReceive();
+		/// Shuts down the receiving part of the socket connection.
+		
+	void shutdownSend();
+		/// Shuts down the sending part of the socket connection.
+		
+	void shutdown();
+		/// Shuts down both the receiving and the sending part
+		/// of the socket connection.
+	
+	int sendBytes(const void* buffer, int length, int flags = 0);
+		/// Sends the contents of the given buffer through
+		/// the socket.
+		///
+		/// Returns the number of bytes sent, which may be
+		/// less than the number of bytes specified.
+		///
+		/// Certain socket implementations may also return a negative
+		/// value denoting a certain condition.
+
+	int sendBytes(Poco::FIFOBuffer& buffer);
+		/// Sends the contents of the given buffer through
+		/// the socket. FIFOBuffer has writable/readable transition
+		/// notifications which may be enabled to notify the caller when
+		/// the buffer transitions between empty, partially full and
+		/// full states.
+		///
+		/// Returns the number of bytes sent, which may be
+		/// less than the number of bytes specified.
+		///
+		/// Certain socket implementations may also return a negative
+		/// value denoting a certain condition.
+
+	int receiveBytes(void* buffer, int length, int flags = 0);
+		/// Receives data from the socket and stores it
+		/// in buffer. Up to length bytes are received.
+		///
+		/// Returns the number of bytes received. 
+		/// A return value of 0 means a graceful shutdown 
+		/// of the connection from the peer.
+		///
+		/// Throws a TimeoutException if a receive timeout has
+		/// been set and nothing is received within that interval.
+		/// Throws a NetException (or a subclass) in case of other errors.
+
+	int receiveBytes(Poco::FIFOBuffer& buffer);
+		/// Receives data from the socket and stores it
+		/// in buffer. Up to length bytes are received. FIFOBuffer has 
+		/// writable/readable transition notifications which may be enabled 
+		/// to notify the caller when the buffer transitions between empty, 
+		/// partially full and full states.
+		///
+		/// Returns the number of bytes received. 
+		/// A return value of 0 means a graceful shutdown 
+		/// of the connection from the peer.
+		///
+		/// Throws a TimeoutException if a receive timeout has
+		/// been set and nothing is received within that interval.
+		/// Throws a NetException (or a subclass) in case of other errors.
+
+	void sendUrgent(unsigned char data);
+		/// Sends one byte of urgent data through
+		/// the socket.
+		///
+		/// The data is sent with the MSG_OOB flag.
+		///
+		/// The preferred way for a socket to receive urgent data
+		/// is by enabling the SO_OOBINLINE option.
+
+	StreamSocket(SocketImpl* pImpl);
+		/// Creates the Socket and attaches the given SocketImpl.
+		/// The socket takes ownership of the SocketImpl.
+		///
+		/// The SocketImpl must be a StreamSocketImpl, otherwise
+		/// an InvalidArgumentException will be thrown.
+
+private:
+	enum
+	{
+		BUFFER_SIZE = 1024
+	};
+
+	friend class ServerSocket;
+	friend class SocketIOS;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_StreamSocket_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/StreamSocketImpl.h b/base/poco/Net/include/Poco/Net/StreamSocketImpl.h
new file mode 100644
index 00000000000..eb4196983ca
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/StreamSocketImpl.h
@@ -0,0 +1,59 @@
+//
+// StreamSocketImpl.h
+//
+// Library: Net
+// Package: Sockets
+// Module:  StreamSocketImpl
+//
+// Definition of the StreamSocketImpl class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_StreamSocketImpl_INCLUDED
+#define Net_StreamSocketImpl_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/SocketImpl.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API StreamSocketImpl: public SocketImpl
+	/// This class implements a TCP socket.
+{
+public:
+	StreamSocketImpl();
+		/// Creates a StreamSocketImpl.
+
+	explicit StreamSocketImpl(SocketAddress::Family addressFamily);
+		/// Creates a SocketImpl, with the underlying
+		/// socket initialized for the given address family.
+		
+	StreamSocketImpl(poco_socket_t sockfd);
+		/// Creates a StreamSocketImpl using the given native socket.
+		
+	virtual int sendBytes(const void* buffer, int length, int flags = 0);
+		/// Ensures that all data in buffer is sent if the socket
+		/// is blocking. In case of a non-blocking socket, sends as
+		/// many bytes as possible.
+		///
+		/// Returns the number of bytes sent. The return value may also be
+		/// negative to denote some special condition.
+
+protected:
+	virtual ~StreamSocketImpl();
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_StreamSocketImpl_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/StringPartSource.h b/base/poco/Net/include/Poco/Net/StringPartSource.h
new file mode 100644
index 00000000000..8f2b478dc2d
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/StringPartSource.h
@@ -0,0 +1,71 @@
+//
+// StringPartSource.h
+//
+// Library: Net
+// Package: Messages
+// Module:  StringPartSource
+//
+// Definition of the StringPartSource class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_StringPartSource_INCLUDED
+#define Net_StringPartSource_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/PartSource.h"
+#include <sstream>
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API StringPartSource: public PartSource
+	/// An implementation of PartSource for strings.
+{
+public:
+	StringPartSource(const std::string& str);
+		/// Creates the StringPartSource for the given string.
+		///
+		/// The MIME type is set to text/plain.
+	
+	StringPartSource(const std::string& str, const std::string& mediaType);
+		/// Creates the StringPartSource for the given
+		/// string and MIME type.
+
+	StringPartSource(const std::string& str, const std::string& mediaType, const std::string& filename);
+		/// Creates the StringPartSource for the given
+		/// string, MIME type and filename.
+
+	~StringPartSource();
+		/// Destroys the StringPartSource.
+
+	std::istream& stream();
+		/// Returns a string input stream for the string.
+		
+	const std::string& filename() const;
+		/// Returns the filename portion of the path.
+
+	std::streamsize getContentLength() const;
+		/// Returns the string size.
+
+private:
+	std::istringstream _istr;
+	std::string        _filename;
+	
+	StringPartSource(const StringPartSource&);
+	StringPartSource& operator = (const StringPartSource&);
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_StringPartSource_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/TCPServer.h b/base/poco/Net/include/Poco/Net/TCPServer.h
new file mode 100644
index 00000000000..7744c01ea7e
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/TCPServer.h
@@ -0,0 +1,260 @@
+//
+// TCPServer.h
+//
+// Library: Net
+// Package: TCPServer
+// Module:  TCPServer
+//
+// Definition of the TCPServer class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_TCPServer_INCLUDED
+#define Net_TCPServer_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/ServerSocket.h"
+#include "Poco/Net/TCPServerConnectionFactory.h"
+#include "Poco/Net/TCPServerParams.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include "Poco/Runnable.h"
+#include "Poco/Thread.h"
+#include "Poco/ThreadPool.h"
+
+#include <atomic>
+
+
+namespace Poco {
+namespace Net {
+
+
+class TCPServerDispatcher;
+class StreamSocket;
+
+
+class Net_API TCPServerConnectionFilter: public Poco::RefCountedObject
+	/// A TCPServerConnectionFilter can be used to reject incoming connections
+	/// before passing them on to the TCPServerDispatcher and
+	/// starting a thread to handle them.
+	///
+	/// An example use case is white-list or black-list IP address filtering.
+	///
+	/// Subclasses must override the accept() method.
+{
+public:
+	typedef Poco::AutoPtr<TCPServerConnectionFilter> Ptr;
+	
+	virtual bool accept(const StreamSocket& socket) = 0;
+		/// Returns true if the given StreamSocket connection should
+		/// be handled, and passed on to the TCPServerDispatcher.
+		///
+		/// Returns false if the socket should be closed immediately.
+		///
+		/// The socket can be prevented from being closed immediately
+		/// if false is returned by creating a copy of the socket.
+		/// This can be used to handle certain socket connections in
+		/// a special way, outside the TCPServer framework.
+
+protected:
+	virtual ~TCPServerConnectionFilter();
+};
+
+
+class Net_API TCPServer: public Poco::Runnable
+	/// This class implements a multithreaded TCP server.
+	///
+	/// The server uses a ServerSocket to listen for incoming
+	/// connections. The ServerSocket must have been bound to
+	/// an address before it is passed to the TCPServer constructor.
+	/// Additionally, the ServerSocket must be put into listening
+	/// state before the TCPServer is started by calling the start()
+	/// method.
+	///
+	/// The server uses a thread pool to assign threads to incoming
+	/// connections. Before incoming connections are assigned to
+	/// a connection thread, they are put into a queue.
+	/// Connection threads fetch new connections from the queue as soon
+	/// as they become free. Thus, a connection thread may serve more
+	/// than one connection.
+	///
+	/// As soon as a connection thread fetches the next connection from
+	/// the queue, it creates a TCPServerConnection object for it
+	/// (using the TCPServerConnectionFactory passed to the constructor)
+	/// and calls the TCPServerConnection's start() method. When the
+	/// start() method returns, the connection object is deleted.
+	///
+	/// The number of connection threads is adjusted dynamically, depending
+	/// on the number of connections waiting to be served.
+	///
+	/// It is possible to specify a maximum number of queued connections.
+	/// This prevents the connection queue from overflowing in the
+	/// case of an extreme server load. In such a case, connections that
+	/// cannot be queued are silently and immediately closed.
+	///
+	/// TCPServer uses a separate thread to accept incoming connections.
+	/// Thus, the call to start() returns immediately, and the server
+	/// continues to run in the background.
+	///
+	/// To stop the server from accepting new connections, call stop().
+	///
+	/// After calling stop(), no new connections will be accepted and
+	/// all queued connections will be discarded.
+	/// Already served connections, however, will continue being served.
+{
+public:
+	TCPServer(TCPServerConnectionFactory::Ptr pFactory, Poco::UInt16 portNumber = 0, TCPServerParams::Ptr pParams = 0);
+		/// Creates the TCPServer, with ServerSocket listening on the given port.
+		/// Default port is zero, allowing any available port. The port number
+		/// can be queried through TCPServer::port() member.
+		///
+		/// The server takes ownership of the TCPServerConnectionFactory
+		/// and deletes it when it's no longer needed.
+		///
+		/// The server also takes ownership of the TCPServerParams object.
+		/// If no TCPServerParams object is given, the server's TCPServerDispatcher
+		/// creates its own one.
+		///
+		/// New threads are taken from the default thread pool.
+
+	TCPServer(TCPServerConnectionFactory::Ptr pFactory, const ServerSocket& socket, TCPServerParams::Ptr pParams = 0);
+		/// Creates the TCPServer, using the given ServerSocket.
+		///
+		/// The server takes ownership of the TCPServerConnectionFactory
+		/// and deletes it when it's no longer needed.
+		///
+		/// The server also takes ownership of the TCPServerParams object.
+		/// If no TCPServerParams object is given, the server's TCPServerDispatcher
+		/// creates its own one.
+		///
+		/// New threads are taken from the default thread pool.
+
+	TCPServer(TCPServerConnectionFactory::Ptr pFactory, Poco::ThreadPool& threadPool, const ServerSocket& socket, TCPServerParams::Ptr pParams = 0);
+		/// Creates the TCPServer, using the given ServerSocket.
+		///
+		/// The server takes ownership of the TCPServerConnectionFactory
+		/// and deletes it when it's no longer needed.
+		///
+		/// The server also takes ownership of the TCPServerParams object.
+		/// If no TCPServerParams object is given, the server's TCPServerDispatcher
+		/// creates its own one.
+		///
+		/// New threads are taken from the given thread pool.
+
+	virtual ~TCPServer();
+		/// Destroys the TCPServer and its TCPServerConnectionFactory.
+
+	const TCPServerParams& params() const;
+		/// Returns a const reference to the TCPServerParam object
+		/// used by the server's TCPServerDispatcher.	
+
+	void start();
+		/// Starts the server. A new thread will be
+		/// created that waits for and accepts incoming
+		/// connections.
+		///
+		/// Before start() is called, the ServerSocket passed to
+		/// TCPServer must have been bound and put into listening state.
+
+	void stop();
+		/// Stops the server.
+		///
+		/// No new connections will be accepted.
+		/// Already handled connections will continue to be served.
+		///
+		/// Once the server has been stopped, it cannot be restarted.
+		
+	int currentThreads() const;
+		/// Returns the number of currently used connection threads.
+
+	int maxThreads() const;
+		/// Returns the maximum number of threads available.
+
+	int totalConnections() const;
+		/// Returns the total number of handled connections.
+		
+	int currentConnections() const;
+		/// Returns the number of currently handled connections.
+
+	int maxConcurrentConnections() const;
+		/// Returns the maximum number of concurrently handled connections.	
+		
+	int queuedConnections() const;
+		/// Returns the number of queued connections.
+
+	int refusedConnections() const;
+		/// Returns the number of refused connections.
+
+	const ServerSocket& socket() const;
+		/// Returns the underlying server socket.
+
+	Poco::UInt16 port() const;
+		/// Returns the port the server socket listens on.
+		
+	void setConnectionFilter(const TCPServerConnectionFilter::Ptr& pFilter);
+		/// Sets a TCPServerConnectionFilter. Can also be used to remove
+		/// a filter by passing a null pointer.
+		///
+		/// To avoid a potential race condition, the filter must
+		/// be set before the TCPServer is started. Trying to set
+		/// the filter after start() has been called will trigger
+		/// an assertion.
+		
+	TCPServerConnectionFilter::Ptr getConnectionFilter() const;
+		/// Returns the TCPServerConnectionFilter set with setConnectionFilter(),
+		/// or null pointer if no filter has been set.
+
+protected:
+	void run();
+		/// Runs the server. The server will run until
+		/// the stop() method is called, or the server
+		/// object is destroyed, which implicitly calls
+		/// the stop() method.
+
+	static std::string threadName(const ServerSocket& socket);
+		/// Returns a thread name for the server thread.
+
+private:
+	TCPServer();
+	TCPServer(const TCPServer&);
+	TCPServer& operator = (const TCPServer&);
+	
+	ServerSocket _socket;
+	TCPServerDispatcher* _pDispatcher;
+	TCPServerConnectionFilter::Ptr _pConnectionFilter;
+	Poco::Thread _thread;
+	std::atomic<bool> _stopped;
+};
+
+
+//
+// inlines
+//
+inline const ServerSocket& TCPServer::socket() const
+{
+	return _socket;
+}
+
+
+inline Poco::UInt16 TCPServer::port() const
+{
+	return _socket.address().port();
+}
+
+
+inline TCPServerConnectionFilter::Ptr TCPServer::getConnectionFilter() const
+{
+	return _pConnectionFilter;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_TCPServer_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/TCPServerConnection.h b/base/poco/Net/include/Poco/Net/TCPServerConnection.h
new file mode 100644
index 00000000000..380edcc1690
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/TCPServerConnection.h
@@ -0,0 +1,86 @@
+//
+// TCPServerConnection.h
+//
+// Library: Net
+// Package: TCPServer
+// Module:  TCPServerConnection
+//
+// Definition of the TCPServerConnection class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_TCPServerConnection_INCLUDED
+#define Net_TCPServerConnection_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/StreamSocket.h"
+#include "Poco/Runnable.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API TCPServerConnection: public Poco::Runnable
+	/// The abstract base class for TCP server connections
+	/// created by TCPServer.
+	///
+	/// Derived classes must override the run() method
+	/// (inherited from Runnable). Furthermore, a
+	/// TCPServerConnectionFactory must be provided for the subclass.
+	///
+	/// The run() method must perform the complete handling
+	/// of the client connection. As soon as the run() method
+	/// returns, the server connection object is destroyed and
+	/// the connection is automatically closed.
+	///
+	/// A new TCPServerConnection object will be created for
+	/// each new client connection that is accepted by
+	/// TCPServer.
+{
+public:
+	TCPServerConnection(const StreamSocket& socket);
+		/// Creates the TCPServerConnection using the given
+		/// stream socket.
+
+	virtual ~TCPServerConnection();
+		/// Destroys the TCPServerConnection.
+
+protected:
+	StreamSocket& socket();
+		/// Returns a reference to the underlying socket.
+
+	void start();
+		/// Calls run() and catches any exceptions that
+		/// might be thrown by run().
+
+private:
+	TCPServerConnection();
+	TCPServerConnection(const TCPServerConnection&);
+	TCPServerConnection& operator = (const TCPServerConnection&);
+	
+	StreamSocket _socket;
+	
+	friend class TCPServerDispatcher;
+};
+
+
+//
+// inlines
+//
+inline StreamSocket& TCPServerConnection::socket()
+{
+	return _socket;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_TCPServerConnection_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/TCPServerConnectionFactory.h b/base/poco/Net/include/Poco/Net/TCPServerConnectionFactory.h
new file mode 100644
index 00000000000..8fc4d6b4d00
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/TCPServerConnectionFactory.h
@@ -0,0 +1,89 @@
+//
+// TCPServerConnectionFactory.h
+//
+// Library: Net
+// Package: TCPServer
+// Module:  TCPServerConnectionFactory
+//
+// Definition of the TCPServerConnectionFactory class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_TCPServerConnectionFactory_INCLUDED
+#define Net_TCPServerConnectionFactory_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/TCPServerConnection.h"
+#include "Poco/SharedPtr.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API TCPServerConnectionFactory
+	/// A factory for TCPServerConnection objects.
+	///
+	/// The TCPServer class uses a TCPServerConnectionFactory
+	/// to create a connection object for each new connection
+	/// it accepts.
+	///
+	/// Subclasses must override the createConnection()
+	/// method.
+	///
+	/// The TCPServerConnectionFactoryImpl template class
+	/// can be used to automatically instantiate a
+	/// TCPServerConnectionFactory for a given subclass
+	/// of TCPServerConnection.
+{
+public:
+	typedef Poco::SharedPtr<TCPServerConnectionFactory> Ptr;
+	
+	virtual ~TCPServerConnectionFactory();
+		/// Destroys the TCPServerConnectionFactory.
+
+	virtual TCPServerConnection* createConnection(const StreamSocket& socket) = 0;
+		/// Creates an instance of a subclass of TCPServerConnection,
+		/// using the given StreamSocket.
+
+protected:
+	TCPServerConnectionFactory();
+		/// Creates the TCPServerConnectionFactory.
+
+private:
+	TCPServerConnectionFactory(const TCPServerConnectionFactory&);
+	TCPServerConnectionFactory& operator = (const TCPServerConnectionFactory&);
+};
+
+
+template <class S>
+class TCPServerConnectionFactoryImpl: public TCPServerConnectionFactory
+	/// This template provides a basic implementation of
+	/// TCPServerConnectionFactory.
+{
+public:
+	TCPServerConnectionFactoryImpl()
+	{
+	}
+	
+	~TCPServerConnectionFactoryImpl()
+	{
+	}
+	
+	TCPServerConnection* createConnection(const StreamSocket& socket)
+	{
+		return new S(socket);
+	}
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_TCPServerConnectionFactory_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/TCPServerDispatcher.h b/base/poco/Net/include/Poco/Net/TCPServerDispatcher.h
new file mode 100644
index 00000000000..715af3fef4c
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/TCPServerDispatcher.h
@@ -0,0 +1,131 @@
+//
+// TCPServerDispatcher.h
+//
+// Library: Net
+// Package: TCPServer
+// Module:  TCPServerDispatcher
+//
+// Definition of the TCPServerDispatcher class.
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_TCPServerDispatcher_INCLUDED
+#define Net_TCPServerDispatcher_INCLUDED
+
+#include <atomic>
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/StreamSocket.h"
+#include "Poco/Net/TCPServerConnectionFactory.h"
+#include "Poco/Net/TCPServerParams.h"
+#include "Poco/Runnable.h"
+#include "Poco/NotificationQueue.h"
+#include "Poco/ThreadPool.h"
+#include "Poco/Mutex.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API TCPServerDispatcher: public Poco::Runnable
+	/// A helper class for TCPServer that dispatches
+	/// connections to server connection threads.
+{
+public:
+	TCPServerDispatcher(TCPServerConnectionFactory::Ptr pFactory, Poco::ThreadPool& threadPool, TCPServerParams::Ptr pParams);
+		/// Creates the TCPServerDispatcher.
+		///
+		/// The dispatcher takes ownership of the TCPServerParams object.
+		/// If no TCPServerParams object is supplied, the TCPServerDispatcher
+		/// creates one.
+
+	void duplicate();
+		/// Increments the object's reference count.
+
+	void release();
+		/// Decrements the object's reference count
+		/// and deletes the object if the count
+		/// reaches zero.	
+
+	void run();
+		/// Runs the dispatcher.
+		
+	void enqueue(const StreamSocket& socket);
+		/// Queues the given socket connection.
+
+	void stop();
+		/// Stops the dispatcher.
+			
+	int currentThreads() const;
+		/// Returns the number of currently used threads.
+
+	int maxThreads() const;
+		/// Returns the maximum number of threads available.
+		
+	int totalConnections() const;
+		/// Returns the total number of handled connections.
+		
+	int currentConnections() const;
+		/// Returns the number of currently handled connections.	
+
+	int maxConcurrentConnections() const;
+		/// Returns the maximum number of concurrently handled connections.	
+		
+	int queuedConnections() const;
+		/// Returns the number of queued connections.	
+	
+	int refusedConnections() const;
+		/// Returns the number of refused connections.
+
+	const TCPServerParams& params() const;
+		/// Returns a const reference to the TCPServerParam object.
+
+protected:
+	~TCPServerDispatcher();
+		/// Destroys the TCPServerDispatcher.
+
+	void beginConnection();
+		/// Updates the performance counters.
+		
+	void endConnection();
+		/// Updates the performance counters.
+
+private:
+	TCPServerDispatcher();
+	TCPServerDispatcher(const TCPServerDispatcher&);
+	TCPServerDispatcher& operator = (const TCPServerDispatcher&);
+
+	std::atomic<int> _rc;
+	TCPServerParams::Ptr _pParams;
+	std::atomic<int>  _currentThreads;
+	std::atomic<int>  _totalConnections;
+	std::atomic<int>  _currentConnections;
+	std::atomic<int>  _maxConcurrentConnections;
+	std::atomic<int>  _refusedConnections;
+	std::atomic<bool> _stopped;
+	Poco::NotificationQueue         _queue;
+	TCPServerConnectionFactory::Ptr _pConnectionFactory;
+	Poco::ThreadPool&               _threadPool;
+	mutable Poco::FastMutex         _mutex;
+};
+
+
+//
+// inlines
+//
+inline const TCPServerParams& TCPServerDispatcher::params() const
+{
+	return *_pParams;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_TCPServerDispatcher_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/TCPServerParams.h b/base/poco/Net/include/Poco/Net/TCPServerParams.h
new file mode 100644
index 00000000000..1c2057e5ec1
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/TCPServerParams.h
@@ -0,0 +1,137 @@
+//
+// TCPServerParams.h
+//
+// Library: Net
+// Package: TCPServer
+// Module:  TCPServerParams
+//
+// Definition of the TCPServerParams class.
+//
+// Copyright (c) 2005-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_TCPServerParams_INCLUDED
+#define Net_TCPServerParams_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/Timespan.h"
+#include "Poco/Thread.h"
+#include "Poco/AutoPtr.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class Net_API TCPServerParams: public Poco::RefCountedObject
+	/// This class is used to specify parameters to both the
+	/// TCPServer, as well as to TCPServerDispatcher objects.
+	///
+	/// Subclasses may add new parameters to the class.
+{
+public:
+	typedef Poco::AutoPtr<TCPServerParams> Ptr;
+	
+	TCPServerParams();
+		/// Creates the TCPServerParams.
+		///
+		/// Sets the following default values:
+		///   - threadIdleTime:       10 seconds
+		///   - maxThreads:           0
+		///   - maxQueued:            64
+
+	void setThreadIdleTime(const Poco::Timespan& idleTime);
+		/// Sets the maximum idle time for a thread before
+		/// it is terminated.
+		///
+		/// The default idle time is 10 seconds;
+		
+	const Poco::Timespan& getThreadIdleTime() const;
+		/// Returns the maximum thread idle time.
+
+	void setMaxQueued(int count);
+		/// Sets the maximum number of queued connections.
+		/// Must be greater than 0.
+		///
+		/// If there are already the maximum number of connections
+		/// in the queue, new connections will be silently discarded.
+		///
+		/// The default number is 64.
+		
+	int getMaxQueued() const;
+		/// Returns the maximum number of queued connections.
+
+	void setMaxThreads(int count);
+		/// Sets the maximum number of simultaneous threads
+		/// available for this TCPServerDispatcher.
+		///
+		/// Must be greater than or equal to 0.
+		/// If 0 is specified, the TCPServerDispatcher will
+		/// set this parameter to the number of available threads
+		/// in its thread pool.
+		///
+		/// The thread pool used by the TCPServerDispatcher
+		/// must at least have the capacity for the given
+		/// number of threads.
+		
+	int getMaxThreads() const;
+		/// Returns the maximum number of simultaneous threads
+		/// available for this TCPServerDispatcher.	
+		
+	void setThreadPriority(Poco::Thread::Priority prio);
+		/// Sets the priority of TCP server threads 
+		/// created by TCPServer.
+		
+	Poco::Thread::Priority getThreadPriority() const;
+		/// Returns the priority of TCP server threads
+		/// created by TCPServer. 
+
+protected:
+	virtual ~TCPServerParams();
+		/// Destroys the TCPServerParams.
+
+private:
+	Poco::Timespan _threadIdleTime;
+	int _maxThreads;
+	int _maxQueued;
+	Poco::Thread::Priority _threadPriority;
+};
+
+
+//
+// inlines
+//
+inline const Poco::Timespan& TCPServerParams::getThreadIdleTime() const
+{
+	return _threadIdleTime;
+}
+
+
+inline int TCPServerParams::getMaxThreads() const
+{
+	return _maxThreads;
+}
+
+
+inline int TCPServerParams::getMaxQueued() const
+{
+	return _maxQueued;
+}
+
+
+inline Poco::Thread::Priority TCPServerParams::getThreadPriority() const
+{
+	return _threadPriority;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_TCPServerParams_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/WebSocket.h b/base/poco/Net/include/Poco/Net/WebSocket.h
new file mode 100644
index 00000000000..5d3f05d12d6
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/WebSocket.h
@@ -0,0 +1,297 @@
+//
+// WebSocket.h
+//
+// Library: Net
+// Package: WebSocket
+// Module:  WebSocket
+//
+// Definition of the WebSocket class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_WebSocket_INCLUDED
+#define Net_WebSocket_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Net/StreamSocket.h"
+#include "Poco/Net/HTTPCredentials.h"
+#include "Poco/Buffer.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class WebSocketImpl;
+class HTTPServerRequest;
+class HTTPServerResponse;
+class HTTPClientSession;
+
+
+class Net_API WebSocket: public StreamSocket
+	/// This class implements a WebSocket according
+	/// to the WebSocket protocol specification in RFC 6455.
+	///
+	/// Both client-side and server-side WebSockets
+	/// are supported.
+	///
+	/// Server-side WebSockets are usually created from within
+	/// a HTTPRequestHandler.
+	///
+	/// Client-side WebSockets are created using a HTTPClientSession.
+	///
+	/// Note that special frames like PING must be handled at
+	/// application level. In the case of a PING, a PONG message
+	/// must be returned.
+{
+public:
+	enum Mode
+	{
+		WS_SERVER, /// Server-side WebSocket.
+		WS_CLIENT  /// Client-side WebSocket.
+	};
+
+	enum FrameFlags
+		/// Frame header flags.
+	{
+		FRAME_FLAG_FIN  = 0x80, /// FIN bit: final fragment of a multi-fragment message.
+		FRAME_FLAG_RSV1 = 0x40, /// Reserved for future use. Must be zero.
+		FRAME_FLAG_RSV2 = 0x20, /// Reserved for future use. Must be zero.
+		FRAME_FLAG_RSV3 = 0x10  /// Reserved for future use. Must be zero.
+	};
+
+	enum FrameOpcodes
+		/// Frame header opcodes.
+	{
+		FRAME_OP_CONT    = 0x00, /// Continuation frame.
+		FRAME_OP_TEXT    = 0x01, /// Text frame.
+		FRAME_OP_BINARY  = 0x02, /// Binary frame.
+		FRAME_OP_CLOSE   = 0x08, /// Close connection.
+		FRAME_OP_PING    = 0x09, /// Ping frame.
+		FRAME_OP_PONG    = 0x0a, /// Pong frame.
+		FRAME_OP_BITMASK = 0x0f, /// Bit mask for opcodes.
+		FRAME_OP_SETRAW  = 0x100 /// Set raw flags (for use with sendBytes() and FRAME_OP_CONT).
+	};
+
+	enum SendFlags
+		/// Combined header flags and opcodes for use with sendFrame().
+	{
+		FRAME_TEXT   = FRAME_FLAG_FIN | FRAME_OP_TEXT,
+			/// Use this for sending a single text (UTF-8) payload frame.
+		FRAME_BINARY = FRAME_FLAG_FIN | FRAME_OP_BINARY
+			/// Use this for sending a single binary payload frame.
+	};
+
+	enum StatusCodes
+		/// StatusCodes for CLOSE frames sent with shutdown().
+	{
+		WS_NORMAL_CLOSE            = 1000,
+		WS_ENDPOINT_GOING_AWAY     = 1001,
+		WS_PROTOCOL_ERROR          = 1002,
+		WS_PAYLOAD_NOT_ACCEPTABLE  = 1003,
+		WS_RESERVED                = 1004,
+		WS_RESERVED_NO_STATUS_CODE = 1005,
+		WS_RESERVED_ABNORMAL_CLOSE = 1006,
+		WS_MALFORMED_PAYLOAD       = 1007,
+		WS_POLICY_VIOLATION        = 1008,
+		WS_PAYLOAD_TOO_BIG         = 1009,
+		WS_EXTENSION_REQUIRED      = 1010,
+		WS_UNEXPECTED_CONDITION    = 1011,
+		WS_RESERVED_TLS_FAILURE    = 1015
+	};
+
+	enum ErrorCodes
+		/// These error codes can be obtained from a WebSocketException
+		/// to determine the exact cause of the error.
+	{
+		WS_ERR_NO_HANDSHAKE                   = 1,
+			/// No Connection: Upgrade or Upgrade: websocket header in handshake request.
+		WS_ERR_HANDSHAKE_NO_VERSION           = 2,
+			/// No Sec-WebSocket-Version header in handshake request.
+		WS_ERR_HANDSHAKE_UNSUPPORTED_VERSION  = 3,
+			/// Unsupported WebSocket version requested by client.
+		WS_ERR_HANDSHAKE_NO_KEY               = 4,
+			/// No Sec-WebSocket-Key header in handshake request.
+		WS_ERR_HANDSHAKE_ACCEPT               = 5,
+			/// No Sec-WebSocket-Accept header or wrong value.
+		WS_ERR_UNAUTHORIZED                   = 6,
+			/// The server rejected the username or password for authentication.
+		WS_ERR_PAYLOAD_TOO_BIG                = 10,
+			/// Payload too big for supplied buffer.
+		WS_ERR_INCOMPLETE_FRAME               = 11
+			/// Incomplete frame received.
+	};
+
+	WebSocket(HTTPServerRequest& request, HTTPServerResponse& response);
+		/// Creates a server-side WebSocket from within a
+		/// HTTPRequestHandler.
+		///
+		/// First verifies that the request is a valid WebSocket upgrade
+		/// request. If so, completes the handshake by sending
+		/// a proper 101 response.
+		///
+		/// Throws an exception if the request is not a proper WebSocket
+		/// upgrade request.
+
+	WebSocket(HTTPClientSession& cs, HTTPRequest& request, HTTPResponse& response);
+		/// Creates a client-side WebSocket, using the given
+		/// HTTPClientSession and HTTPRequest for the initial handshake
+		/// (HTTP Upgrade request).
+		///
+		/// Additional HTTP headers for the initial handshake request
+		/// (such as Origin or Sec-WebSocket-Protocol) can be given
+		/// in the request object.
+		///
+		/// The result of the handshake can be obtained from the response
+		/// object.
+
+	WebSocket(HTTPClientSession& cs, HTTPRequest& request, HTTPResponse& response, HTTPCredentials& credentials);
+		/// Creates a client-side WebSocket, using the given
+		/// HTTPClientSession and HTTPRequest for the initial handshake
+		/// (HTTP Upgrade request).
+		///
+		/// The given credentials are used for authentication
+		/// if requested by the server.
+		///
+		/// Additional HTTP headers for the initial handshake request
+		/// (such as Origin or Sec-WebSocket-Protocol) can be given
+		/// in the request object.
+		///
+		/// The result of the handshake can be obtained from the response
+		/// object.
+
+	WebSocket(const Socket& socket);
+		/// Creates a WebSocket from another Socket, which must be a WebSocket,
+		/// otherwise a Poco::InvalidArgumentException will be thrown.
+
+	virtual ~WebSocket();
+		/// Destroys the StreamSocket.
+
+	WebSocket& operator = (const Socket& socket);
+		/// Assignment operator.
+		///
+		/// The other socket must be a WebSocket, otherwise a Poco::InvalidArgumentException
+		/// will be thrown.
+
+	void shutdown();
+		/// Sends a Close control frame to the server end of
+		/// the connection to initiate an orderly shutdown
+		/// of the connection.
+
+	void shutdown(Poco::UInt16 statusCode, const std::string& statusMessage = "");
+		/// Sends a Close control frame to the server end of
+		/// the connection to initiate an orderly shutdown
+		/// of the connection.
+
+	int sendFrame(const void* buffer, int length, int flags = FRAME_TEXT);
+		/// Sends the contents of the given buffer through
+		/// the socket as a single frame.
+		///
+		/// Values from the FrameFlags, FrameOpcodes and SendFlags enumerations
+		/// can be specified in flags.
+		///
+		/// Returns the number of bytes sent, which may be
+		/// less than the number of bytes specified.
+		///
+		/// Certain socket implementations may also return a negative
+		/// value denoting a certain condition.
+
+	int receiveFrame(void* buffer, int length, int& flags);
+		/// Receives a frame from the socket and stores it
+		/// in buffer. Up to length bytes are received. If
+		/// the frame's payload is larger, a WebSocketException
+		/// is thrown and the WebSocket connection must be
+		/// terminated.
+		///
+		/// The frame's payload size must not exceed the
+		/// maximum payload size set with setMaxPayloadSize().
+		/// If it does, a WebSocketException (WS_ERR_PAYLOAD_TOO_BIG)
+		/// is thrown and the WebSocket connection must be
+		/// terminated.
+		///
+		/// A WebSocketException will also be thrown if a malformed
+		/// or incomplete frame is received.
+		///
+		/// Returns the number of bytes received.
+		/// A return value of 0 means that the peer has
+		/// shut down or closed the connection.
+		///
+		/// Throws a TimeoutException if a receive timeout has
+		/// been set and nothing is received within that interval.
+		/// Throws a NetException (or a subclass) in case of other errors.
+		///
+		/// The frame flags and opcode (FrameFlags and FrameOpcodes)
+		/// is stored in flags.
+
+	int receiveFrame(Poco::Buffer<char>& buffer, int& flags);
+		/// Receives a frame from the socket and stores it
+		/// after any previous content in buffer.
+		/// The buffer will be grown as necessary.
+		///
+		/// The frame's payload size must not exceed the
+		/// maximum payload size set with setMaxPayloadSize().
+		/// If it does, a WebSocketException (WS_ERR_PAYLOAD_TOO_BIG)
+		/// is thrown and the WebSocket connection must be
+		/// terminated.
+		///
+		/// A WebSocketException will also be thrown if a malformed
+		/// or incomplete frame is received.
+		///
+		/// If this method is used, a reasonable maximum payload size should
+		/// be set with setMaxPayloadSize() to prevent a potential
+		/// DoS attack (memory exhaustion) by sending a WebSocket frame
+		/// header with a huge payload size.
+		///
+		/// Returns the number of bytes received.
+		/// A return value of 0 means that the peer has
+		/// shut down or closed the connection.
+		///
+		/// Throws a TimeoutException if a receive timeout has
+		/// been set and nothing is received within that interval.
+		/// Throws a NetException (or a subclass) in case of other errors.
+		///
+		/// The frame flags and opcode (FrameFlags and FrameOpcodes)
+		/// is stored in flags.
+
+	Mode mode() const;
+		/// Returns WS_SERVER if the WebSocket is a server-side
+		/// WebSocket, or WS_CLIENT otherwise.
+
+	void setMaxPayloadSize(int maxPayloadSize);
+		/// Sets the maximum payload size for receiveFrame().
+		///
+		/// The default is std::numeric_limits<int>::max().
+
+	int getMaxPayloadSize() const;
+		/// Returns the maximum payload size for receiveFrame().
+		///
+		/// The default is std::numeric_limits<int>::max().
+
+	static const std::string WEBSOCKET_VERSION;
+		/// The WebSocket protocol version supported (13).
+
+protected:
+	static WebSocketImpl* accept(HTTPServerRequest& request, HTTPServerResponse& response);
+	static WebSocketImpl* connect(HTTPClientSession& cs, HTTPRequest& request, HTTPResponse& response, HTTPCredentials& credentials);
+	static WebSocketImpl* completeHandshake(HTTPClientSession& cs, HTTPResponse& response, const std::string& key);
+	static std::string computeAccept(const std::string& key);
+	static std::string createKey();
+
+private:
+	WebSocket();
+
+	static const std::string WEBSOCKET_GUID;
+	static HTTPCredentials _defaultCreds;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_WebSocket_INCLUDED
diff --git a/base/poco/Net/include/Poco/Net/WebSocketImpl.h b/base/poco/Net/include/Poco/Net/WebSocketImpl.h
new file mode 100644
index 00000000000..a2471c3694b
--- /dev/null
+++ b/base/poco/Net/include/Poco/Net/WebSocketImpl.h
@@ -0,0 +1,142 @@
+//
+// WebSocketImpl.h
+//
+// Library: Net
+// Package: WebSocket
+// Module:  WebSocketImpl
+//
+// Definition of the StreamSocketImpl class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_WebSocketImpl_INCLUDED
+#define Net_WebSocketImpl_INCLUDED
+
+
+#include "Poco/Net/StreamSocketImpl.h"
+#include "Poco/Buffer.h"
+#include "Poco/Random.h"
+#include "Poco/Buffer.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class HTTPSession;
+
+
+class Net_API WebSocketImpl: public StreamSocketImpl
+	/// This class implements a WebSocket, according
+	/// to the WebSocket protocol described in RFC 6455.
+{
+public:
+	WebSocketImpl(StreamSocketImpl* pStreamSocketImpl, HTTPSession& session, bool mustMaskPayload);
+		/// Creates a WebSocketImpl.
+
+	// StreamSocketImpl
+	virtual int sendBytes(const void* buffer, int length, int flags);
+		/// Sends a WebSocket protocol frame.
+
+	virtual int receiveBytes(void* buffer, int length, int flags);
+		/// Receives a WebSocket protocol frame.
+
+	virtual int receiveBytes(Poco::Buffer<char>& buffer, int flags);
+		/// Receives a WebSocket protocol frame.
+
+	virtual SocketImpl* acceptConnection(SocketAddress& clientAddr);
+	virtual void connect(const SocketAddress& address);
+	virtual void connect(const SocketAddress& address, const Poco::Timespan& timeout);
+	virtual void connectNB(const SocketAddress& address);
+	virtual void bind(const SocketAddress& address, bool reuseAddress = false);
+	virtual void bind(const SocketAddress& address, bool reuseAddress, bool reusePort);
+	virtual void bind6(const SocketAddress& address, bool reuseAddress = false, bool ipV6Only = false);
+	virtual void bind6(const SocketAddress& address, bool reuseAddress, bool reusePort, bool ipV6Only);
+	virtual void listen(int backlog = 64);
+	virtual void close();
+	virtual void shutdownReceive();
+	virtual void shutdownSend();
+	virtual void shutdown();
+	virtual int sendTo(const void* buffer, int length, const SocketAddress& address, int flags = 0);
+	virtual int receiveFrom(void* buffer, int length, SocketAddress& address, int flags = 0);
+	virtual void sendUrgent(unsigned char data);
+	virtual int available();
+	virtual bool secure() const;
+	virtual void setSendTimeout(const Poco::Timespan& timeout);
+	virtual Poco::Timespan getSendTimeout();
+	virtual void setReceiveTimeout(const Poco::Timespan& timeout);
+	virtual Poco::Timespan getReceiveTimeout();
+
+	// Internal
+	int frameFlags() const;
+		/// Returns the frame flags of the most recently received frame.
+
+	bool mustMaskPayload() const;
+		/// Returns true if the payload must be masked.
+
+	void setMaxPayloadSize(int maxPayloadSize);
+		/// Sets the maximum payload size for receiveFrame().
+		///
+		/// The default is std::numeric_limits<int>::max().
+
+	int getMaxPayloadSize() const;
+		/// Returns the maximum payload size for receiveFrame().
+		///
+		/// The default is std::numeric_limits<int>::max().
+
+protected:
+	enum
+	{
+		FRAME_FLAG_MASK   = 0x80,
+		MAX_HEADER_LENGTH = 14
+	};
+
+	int receiveHeader(char mask[4], bool& useMask);
+	int receivePayload(char *buffer, int payloadLength, char mask[4], bool useMask);
+	int receiveNBytes(void* buffer, int bytes);
+	int receiveSomeBytes(char* buffer, int bytes);
+	virtual ~WebSocketImpl();
+
+private:
+	WebSocketImpl();
+
+	StreamSocketImpl* _pStreamSocketImpl;
+	int _maxPayloadSize;
+	Poco::Buffer<char> _buffer;
+	int _bufferOffset;
+	int _frameFlags;
+	bool _mustMaskPayload;
+	Poco::Random _rnd;
+};
+
+
+//
+// inlines
+//
+inline int WebSocketImpl::frameFlags() const
+{
+	return _frameFlags;
+}
+
+
+inline bool WebSocketImpl::mustMaskPayload() const
+{
+	return _mustMaskPayload;
+}
+
+
+inline int WebSocketImpl::getMaxPayloadSize() const
+{
+	return _maxPayloadSize;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_WebSocketImpl_INCLUDED
diff --git a/base/poco/Net/src/AbstractHTTPRequestHandler.cpp b/base/poco/Net/src/AbstractHTTPRequestHandler.cpp
new file mode 100644
index 00000000000..ed39617e2b8
--- /dev/null
+++ b/base/poco/Net/src/AbstractHTTPRequestHandler.cpp
@@ -0,0 +1,109 @@
+//
+// AbstractHTTPRequestHandler.cpp
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  AbstractHTTPRequestHandler
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/AbstractHTTPRequestHandler.h"
+#include "Poco/Net/HTTPServerRequest.h"
+#include "Poco/Net/HTTPServerResponse.h"
+#include "Poco/Net/HTMLForm.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/Exception.h"
+
+
+using Poco::NumberFormatter;
+
+
+namespace Poco {
+namespace Net {
+
+
+AbstractHTTPRequestHandler::AbstractHTTPRequestHandler():
+	_pRequest(0),
+	_pResponse(0),
+	_pForm(0)
+{
+}
+
+
+AbstractHTTPRequestHandler::~AbstractHTTPRequestHandler()
+{
+	delete _pForm;
+}
+
+
+void AbstractHTTPRequestHandler::handleRequest(HTTPServerRequest& request, HTTPServerResponse& response)
+{
+	_pRequest  = &request;
+	_pResponse = &response;
+	if (authenticate())
+	{
+		try
+		{
+			run();
+		}
+		catch (Poco::Exception& exc)
+		{
+			if (!response.sent())
+			{
+				sendErrorResponse(HTTPResponse::HTTP_INTERNAL_SERVER_ERROR, exc.displayText());
+			}
+		}
+		catch (std::exception& exc)
+		{
+			if (!response.sent())
+			{
+				sendErrorResponse(HTTPResponse::HTTP_INTERNAL_SERVER_ERROR, exc.what());
+			}
+		}
+	}
+	else
+	{
+		sendErrorResponse(HTTPResponse::HTTP_UNAUTHORIZED, "");
+	}
+}
+
+
+bool AbstractHTTPRequestHandler::authenticate()
+{
+	return true;
+}
+
+
+HTMLForm& AbstractHTTPRequestHandler::form()
+{
+	if (!_pForm)
+		_pForm = new HTMLForm(request(), request().stream());
+
+	return *_pForm;
+}
+
+
+void AbstractHTTPRequestHandler::sendErrorResponse(HTTPResponse::HTTPStatus status, const std::string& message)
+{
+	response().setStatusAndReason(status);
+	std::string statusAndReason(NumberFormatter::format(static_cast<int>(response().getStatus())));
+	statusAndReason += " - ";
+	statusAndReason += response().getReason();
+	std::string page("<HTML><HEAD><TITLE>");
+	page += statusAndReason;
+	page += "</TITLE></HEAD><BODY><H1>";
+	page += statusAndReason;
+	page += "</H1>";
+	page += "<P>";
+	page += message;
+	page += "</P></BODY></HTML>";
+	response().sendBuffer(page.data(), page.size());
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/DNS.cpp b/base/poco/Net/src/DNS.cpp
new file mode 100644
index 00000000000..9ed5a49cef2
--- /dev/null
+++ b/base/poco/Net/src/DNS.cpp
@@ -0,0 +1,687 @@
+//
+// DNS.cpp
+//
+// Library: Net
+// Package: NetCore
+// Module:  DNS
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/DNS.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/Environment.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/RWLock.h"
+#include "Poco/TextIterator.h"
+#include "Poco/TextConverter.h"
+#include "Poco/UTF8Encoding.h"
+#include "Poco/UTF32Encoding.h"
+#include "Poco/Unicode.h"
+#include <cstring>
+
+
+#if defined(POCO_HAVE_LIBRESOLV)
+#include <resolv.h>
+#endif
+
+
+using Poco::Environment;
+using Poco::NumberFormatter;
+using Poco::IOException;
+
+
+namespace Poco {
+namespace Net {
+
+
+typedef Poco::UInt32 punycode_uint;
+
+
+enum
+{
+	punycode_success = 0,
+	punycode_overflow = -1,
+	punycode_big_output = -2,
+	punycode_bad_input = -3
+};
+
+
+static int punycode_encode(size_t input_length, const punycode_uint input[], size_t* output_length, char output[]);
+static int punycode_decode(size_t input_length, const char input[], size_t* output_length, punycode_uint output[]);
+
+
+#if defined(POCO_HAVE_LIBRESOLV)
+static Poco::RWLock resolverLock;
+#endif
+
+
+HostEntry DNS::hostByName(const std::string& hostname, unsigned
+#ifdef POCO_HAVE_ADDRINFO
+						  hintFlags
+#endif
+						 )
+{
+#if defined(POCO_HAVE_LIBRESOLV)
+	Poco::ScopedReadRWLock readLock(resolverLock);
+#endif
+
+#if defined(POCO_HAVE_ADDRINFO)
+	struct addrinfo* pAI;
+	struct addrinfo hints;
+	std::memset(&hints, 0, sizeof(hints));
+	hints.ai_flags = hintFlags;
+	int rc = getaddrinfo(hostname.c_str(), NULL, &hints, &pAI);
+	if (rc == 0)
+	{
+		HostEntry result(pAI);
+		freeaddrinfo(pAI);
+		return result;
+	}
+	else
+	{
+		aierror(rc, hostname);
+	}
+#elif defined(POCO_VXWORKS)
+	int addr = hostGetByName(const_cast<char*>(hostname.c_str()));
+	if (addr != ERROR)
+	{
+		return HostEntry(hostname, IPAddress(&addr, sizeof(addr)));
+	}
+#else
+	struct hostent* he = gethostbyname(hostname.c_str());
+	if (he)
+	{
+		return HostEntry(he);
+	}
+#endif
+	error(lastError(), hostname); // will throw an appropriate exception
+	throw NetException(); // to silence compiler
+}
+
+
+HostEntry DNS::hostByAddress(const IPAddress& address, unsigned
+#ifdef POCO_HAVE_ADDRINFO
+							 hintFlags
+#endif
+							)
+{
+#if defined(POCO_HAVE_LIBRESOLV)
+	Poco::ScopedReadRWLock readLock(resolverLock);
+#endif
+
+#if defined(POCO_HAVE_ADDRINFO)
+	SocketAddress sa(address, 0);
+	static char fqname[1024];
+	int rc = getnameinfo(sa.addr(), sa.length(), fqname, sizeof(fqname), NULL, 0, NI_NAMEREQD);
+	if (rc == 0)
+	{
+		struct addrinfo* pAI;
+		struct addrinfo hints;
+		std::memset(&hints, 0, sizeof(hints));
+		hints.ai_flags = hintFlags;
+		rc = getaddrinfo(fqname, NULL, &hints, &pAI);
+		if (rc == 0)
+		{
+			HostEntry result(pAI);
+			freeaddrinfo(pAI);
+			return result;
+		}
+		else
+		{
+			aierror(rc, address.toString());
+		}
+	}
+	else
+	{
+		aierror(rc, address.toString());
+	}
+#elif defined(POCO_VXWORKS)
+	char name[MAXHOSTNAMELEN + 1];
+	if (hostGetByAddr(*reinterpret_cast<const int*>(address.addr()), name) == OK)
+	{
+		return HostEntry(std::string(name), address);
+	}
+#else
+	struct hostent* he = gethostbyaddr(reinterpret_cast<const char*>(address.addr()), address.length(), address.af());
+	if (he)
+	{
+		return HostEntry(he);
+	}
+#endif
+	int err = lastError();
+	error(err, address.toString()); // will throw an appropriate exception
+	throw NetException(); // to silence compiler
+}
+
+
+HostEntry DNS::resolve(const std::string& address)
+{
+	IPAddress ip;
+	if (IPAddress::tryParse(address, ip))
+	{
+		return hostByAddress(ip);
+	}
+	else if (isIDN(address))
+	{
+		std::string encoded = encodeIDN(address);
+		return hostByName(encoded);
+	}
+	else
+	{
+		return hostByName(address);
+	}
+}
+
+
+IPAddress DNS::resolveOne(const std::string& address)
+{
+	const HostEntry& entry = resolve(address);
+	if (!entry.addresses().empty())
+		return entry.addresses()[0];
+	else
+		throw NoAddressFoundException(address);
+}
+
+
+HostEntry DNS::thisHost()
+{
+	return hostByName(hostName());
+}
+
+
+void DNS::reload()
+{
+#if defined(POCO_HAVE_LIBRESOLV)
+	Poco::ScopedWriteRWLock writeLock(resolverLock);
+	res_init();
+#endif
+}
+
+
+std::string DNS::hostName()
+{
+	char buffer[256];
+	int rc = gethostname(buffer, sizeof(buffer));
+	if (rc == 0)
+		return std::string(buffer);
+	else
+		throw NetException("Cannot get host name");
+}
+
+
+bool DNS::isIDN(const std::string& hostname)
+{
+	for (std::string::const_iterator it = hostname.begin(); it != hostname.end(); ++it)
+	{
+		if (static_cast<unsigned char>(*it) >= 0x80) return true;
+	}
+	return false;
+}
+
+
+bool DNS::isEncodedIDN(const std::string& hostname)
+{
+	return hostname.compare(0, 4, "xn--") == 0 || hostname.find(".xn--") != std::string::npos;
+}
+
+
+std::string DNS::encodeIDN(const std::string& idn)
+{
+	std::string encoded;
+	std::string::const_iterator it = idn.begin();
+	std::string::const_iterator end = idn.end();
+	while (it != end)
+	{
+		std::string label;
+		bool mustEncode = false;
+		while (it != end && *it != '.')
+		{
+			if (static_cast<unsigned char>(*it) >= 0x80) mustEncode = true;
+			label += *it++;
+		}
+		if (mustEncode)
+			encoded += encodeIDNLabel(label);
+		else
+			encoded += label;
+		if (it != end) encoded += *it++;
+	}
+	return encoded;
+}
+
+
+std::string DNS::decodeIDN(const std::string& encodedIDN)
+{
+	std::string decoded;
+	std::string::const_iterator it = encodedIDN.begin();
+	std::string::const_iterator end = encodedIDN.end();
+	while (it != end)
+	{
+		std::string label;
+		while (it != end && *it != '.')
+		{
+			label += *it++;
+		}
+		decoded += decodeIDNLabel(label);
+		if (it != end) decoded += *it++;
+	}
+	return decoded;
+}
+
+
+std::string DNS::encodeIDNLabel(const std::string& label)
+{
+	std::string encoded = "xn--";
+	std::vector<Poco::UInt32> uniLabel;
+	Poco::UTF8Encoding utf8;
+	Poco::TextIterator it(label, utf8);
+	Poco::TextIterator end(label);
+	while (it != end)
+	{
+		int ch = *it;
+		if (ch < 0) throw DNSException("Invalid UTF-8 character in IDN label", label);
+		if (Poco::Unicode::isUpper(ch))
+		{
+			ch = Poco::Unicode::toLower(ch);
+		}
+		uniLabel.push_back(static_cast<Poco::UInt32>(ch));
+		++it;
+	}
+	char buffer[64];
+	std::size_t size = 64;
+	int rc = punycode_encode(uniLabel.size(), &uniLabel[0], &size, buffer);
+	if (rc == punycode_success)
+		encoded.append(buffer, size);
+	else
+		throw DNSException("Failed to encode IDN label", label);
+	return encoded;
+}
+
+
+std::string DNS::decodeIDNLabel(const std::string& encodedIDN)
+{
+	std::string decoded;
+	if (encodedIDN.compare(0, 4, "xn--") == 0)
+	{
+		std::size_t size = 64;
+		punycode_uint buffer[64];
+		int rc = punycode_decode(encodedIDN.size() - 4, encodedIDN.data() + 4, &size, buffer);
+		if (rc == punycode_success)
+		{
+			Poco::UTF32Encoding utf32;
+			Poco::UTF8Encoding utf8;
+			Poco::TextConverter converter(utf32, utf8);
+			converter.convert(buffer, size*sizeof(punycode_uint), decoded);
+		}
+		else throw DNSException("Failed to decode IDN label: ", encodedIDN);
+	}
+	else
+	{
+		decoded = encodedIDN;
+	}
+	return decoded;
+}
+
+
+int DNS::lastError()
+{
+#if defined(_WIN32)
+	return GetLastError();
+#elif defined(POCO_VXWORKS)
+	return errno;
+#else
+	return h_errno;
+#endif
+}
+
+
+void DNS::error(int code, const std::string& arg)
+{
+	switch (code)
+	{
+	case POCO_ESYSNOTREADY:
+		throw NetException("Net subsystem not ready");
+	case POCO_ENOTINIT:
+		throw NetException("Net subsystem not initialized");
+	case POCO_HOST_NOT_FOUND:
+		throw HostNotFoundException(arg);
+	case POCO_TRY_AGAIN:
+		throw DNSException("Temporary DNS error while resolving", arg);
+	case POCO_NO_RECOVERY:
+		throw DNSException("Non recoverable DNS error while resolving", arg);
+	case POCO_NO_DATA:
+		throw NoAddressFoundException(arg);
+	default:
+		throw IOException(NumberFormatter::format(code));
+	}
+}
+
+
+void DNS::aierror(int code, const std::string& arg)
+{
+#if defined(POCO_HAVE_IPv6) || defined(POCO_HAVE_ADDRINFO)
+	switch (code)
+	{
+	case EAI_AGAIN:
+		throw DNSException("Temporary DNS error while resolving", arg);
+	case EAI_FAIL:
+		throw DNSException("Non recoverable DNS error while resolving", arg);
+#if !defined(_WIN32) // EAI_NODATA and EAI_NONAME have the same value
+#if defined(EAI_NODATA) // deprecated in favor of EAI_NONAME on FreeBSD
+	case EAI_NODATA:
+		throw NoAddressFoundException(arg);
+#endif
+#endif
+	case EAI_NONAME:
+		throw HostNotFoundException(arg);
+#if defined(EAI_SYSTEM)
+	case EAI_SYSTEM:
+		error(lastError(), arg);
+		break;
+#endif
+#if defined(_WIN32)
+	case WSANO_DATA: // may happen on XP
+		throw HostNotFoundException(arg);
+#endif
+	default:
+		throw DNSException("EAI", gai_strerror(code));
+	}
+#endif // POCO_HAVE_IPv6 || defined(POCO_HAVE_ADDRINFO)
+}
+
+
+/*
+  Code copied from http://www.nicemice.net/idn/punycode-spec.gz on
+  2018-02-17 with SHA-1 a966a8017f6be579d74a50a226accc7607c40133
+  labeled punycode-spec 1.0.3 (2006-Mar-23-Thu).
+
+  Modified for POCO C++ Libraries by Guenter Obiltschnig.
+
+  License on the original code:
+
+  punycode-spec 1.0.3 (2006-Mar-23-Thu)
+  http://www.nicemice.net/idn/
+  Adam M. Costello
+  http://www.nicemice.net/amc/
+
+  B. Disclaimer and license
+
+    Regarding this entire document or any portion of it (including
+    the pseudocode and C code), the author makes no guarantees and
+    is not responsible for any damage resulting from its use.  The
+    author grants irrevocable permission to anyone to use, modify,
+    and distribute it in any way that does not diminish the rights
+    of anyone else to use, modify, and distribute it, provided that
+    redistributed derivative works do not contain misleading author or
+    version information.  Derivative works need not be licensed under
+    similar terms.
+
+  C. Punycode sample implementation
+
+  punycode-sample.c 2.0.0 (2004-Mar-21-Sun)
+  http://www.nicemice.net/idn/
+  Adam M. Costello
+  http://www.nicemice.net/amc/
+
+  This is ANSI C code (C89) implementing Punycode 1.0.x.
+*/
+
+
+/*** Bootstring parameters for Punycode ***/
+
+enum
+{
+	base = 36,
+	tmin = 1,
+	tmax = 26,
+	skew = 38,
+	damp = 700,
+	initial_bias = 72,
+	initial_n = 0x80,
+	delimiter = 0x2D
+};
+
+/* basic(cp) tests whether cp is a basic code point: */
+#define basic(cp) ((punycode_uint)(cp) < 0x80)
+
+/* delim(cp) tests whether cp is a delimiter: */
+#define delim(cp) ((cp) == delimiter)
+
+/* encode_digit(d,flag) returns the basic code point whose value      */
+/* (when used for representing integers) is d, which needs to be in   */
+/* the range 0 to base-1.  The lowercase form is used unless flag is  */
+/* nonzero, in which case the uppercase form is used.  The behavior   */
+/* is undefined if flag is nonzero and digit d has no uppercase form. */
+
+static char encode_digit(punycode_uint d, int flag)
+{
+	return d + 22 + 75 * (d < 26) - ((flag != 0) << 5);
+	/*  0..25 map to ASCII a..z or A..Z */
+	/* 26..35 map to ASCII 0..9         */
+}
+
+/* decode_digit(cp) returns the numeric value of a basic code */
+/* point (for use in representing integers) in the range 0 to */
+/* base-1, or base if cp does not represent a value.          */
+
+static unsigned decode_digit(int cp)
+{
+	return (unsigned) (cp - 48 < 10 ? cp - 22 :  cp - 65 < 26 ? cp - 65 :
+		cp - 97 < 26 ? cp - 97 :  base);
+}
+
+/*** Platform-specific constants ***/
+
+/* maxint is the maximum value of a punycode_uint variable: */
+static const punycode_uint maxint = -1;
+/* Because maxint is unsigned, -1 becomes the maximum value. */
+
+/*** Bias adaptation function ***/
+
+static punycode_uint adapt(punycode_uint delta, punycode_uint numpoints, int firsttime);
+
+static punycode_uint adapt(punycode_uint delta, punycode_uint numpoints, int firsttime)
+{
+	punycode_uint k;
+
+	delta = firsttime ? delta / damp : delta >> 1;
+	/* delta >> 1 is a faster way of doing delta / 2 */
+	delta += delta / numpoints;
+
+	for (k = 0;  delta > ((base - tmin) * tmax) / 2;  k += base)
+	{
+		delta /= base - tmin;
+	}
+
+	return k + (base - tmin + 1) * delta / (delta + skew);
+}
+
+/*** Main encode function ***/
+
+int punycode_encode(size_t input_length_orig, const punycode_uint input[], size_t *output_length, char output[])
+{
+	punycode_uint input_length, n, delta, h, b, bias, j, m, q, k, t;
+	size_t out, max_out;
+
+	/* The Punycode spec assumes that the input length is the same type */
+	/* of integer as a code point, so we need to convert the size_t to  */
+	/* a punycode_uint, which could overflow.                           */
+
+	if (input_length_orig > maxint) return punycode_overflow;
+	input_length = (punycode_uint) input_length_orig;
+
+	/* Initialize the state: */
+
+	n = initial_n;
+	delta = 0;
+	out = 0;
+	max_out = *output_length;
+	bias = initial_bias;
+
+	/* Handle the basic code points: */
+
+	for (j = 0;  j < input_length;  ++j)
+	{
+		if (basic(input[j]))
+		{
+			if (max_out - out < 2) return punycode_big_output;
+			output[out++] = (char) input[j];
+		}
+		/* else if (input[j] < n) return punycode_bad_input; */
+		/* (not needed for Punycode with unsigned code points) */
+	}
+
+	h = b = (punycode_uint) out;
+	/* cannot overflow because out <= input_length <= maxint */
+
+	/* h is the number of code points that have been handled, b is the  */
+	/* number of basic code points, and out is the number of ASCII code */
+	/* points that have been output.                                    */
+
+	if (b > 0) output[out++] = delimiter;
+
+	/* Main encoding loop: */
+
+	while (h < input_length)
+	{
+		/* All non-basic code points < n have been     */
+		/* handled already.  Find the next larger one: */
+
+		for (m = maxint, j = 0;  j < input_length;  ++j)
+		{
+			/* if (basic(input[j])) continue; */
+			/* (not needed for Punycode) */
+			if (input[j] >= n && input[j] < m) m = input[j];
+		}
+
+		/* Increase delta enough to advance the decoder's    */
+		/* <n,i> state to <m,0>, but guard against overflow: */
+
+		if (m - n > (maxint - delta) / (h + 1)) return punycode_overflow;
+		delta += (m - n) * (h + 1);
+		n = m;
+
+		for (j = 0;  j < input_length;  ++j)
+		{
+			/* Punycode does not need to check whether input[j] is basic: */
+			if (input[j] < n /* || basic(input[j]) */ )
+			{
+				if (++delta == 0) return punycode_overflow;
+			}
+
+			if (input[j] == n)
+			{
+				/* Represent delta as a generalized variable-length integer: */
+
+				for (q = delta, k = base;  ;  k += base)
+				{
+					if (out >= max_out) return punycode_big_output;
+					t = k <= bias /* + tmin */ ? tmin :     /* +tmin not needed */
+						k >= bias + tmax ? tmax : k - bias;
+					if (q < t) break;
+					output[out++] = encode_digit(t + (q - t) % (base - t), 0);
+					q = (q - t) / (base - t);
+				}
+
+				output[out++] = encode_digit(q, 0);
+				bias = adapt(delta, h + 1, h == b);
+				delta = 0;
+				++h;
+			}
+		}
+
+		++delta, ++n;
+	}
+
+	*output_length = out;
+	return punycode_success;
+}
+
+/*** Main decode function ***/
+
+int punycode_decode(size_t input_length, const char input[], size_t *output_length, punycode_uint output[])
+{
+	punycode_uint n, out, i, max_out, bias, oldi, w, k, digit, t;
+	size_t b, j, in;
+
+	/* Initialize the state: */
+
+	n = initial_n;
+	out = i = 0;
+	max_out = *output_length > maxint ? maxint : (punycode_uint) *output_length;
+	bias = initial_bias;
+
+	/* Handle the basic code points:  Let b be the number of input code */
+	/* points before the last delimiter, or 0 if there is none, then    */
+	/* copy the first b code points to the output.                      */
+
+	for (b = j = 0;  j < input_length;  ++j)
+	{
+		if (delim(input[j])) b = j;
+	}
+	if (b > max_out) return punycode_big_output;
+
+	for (j = 0;  j < b;  ++j)
+	{
+		if (!basic(input[j])) return punycode_bad_input;
+		output[out++] = input[j];
+	}
+
+	/* Main decoding loop:  Start just after the last delimiter if any  */
+	/* basic code points were copied; start at the beginning otherwise. */
+
+	for (in = b > 0 ? b + 1 : 0;  in < input_length;  ++out)
+	{
+		/* in is the index of the next ASCII code point to be consumed, */
+		/* and out is the number of code points in the output array.    */
+
+		/* Decode a generalized variable-length integer into delta,  */
+		/* which gets added to i.  The overflow checking is easier   */
+		/* if we increase i as we go, then subtract off its starting */
+		/* value at the end to obtain delta.                         */
+
+		for (oldi = i, w = 1, k = base;  ;  k += base)
+		{
+			if (in >= input_length) return punycode_bad_input;
+			digit = decode_digit(input[in++]);
+			if (digit >= base) return punycode_bad_input;
+			if (digit > (maxint - i) / w) return punycode_overflow;
+			i += digit * w;
+			t = k <= bias /* + tmin */ ? tmin :     /* +tmin not needed */
+				k >= bias + tmax ? tmax : k - bias;
+			if (digit < t) break;
+			if (w > maxint / (base - t)) return punycode_overflow;
+			w *= (base - t);
+		}
+
+		bias = adapt(i - oldi, out + 1, oldi == 0);
+
+		/* i was supposed to wrap around from out+1 to 0,   */
+		/* incrementing n each time, so we'll fix that now: */
+
+		if (i / (out + 1) > maxint - n) return punycode_overflow;
+		n += i / (out + 1);
+		i %= (out + 1);
+
+		/* Insert n at position i of the output: */
+
+		/* not needed for Punycode: */
+		/* if (basic(n)) return punycode_bad_input; */
+		if (out >= max_out) return punycode_big_output;
+
+		std::memmove(output + i + 1, output + i, (out - i) * sizeof *output);
+		output[i++] = n;
+	}
+
+	*output_length = (size_t) out;
+	/* cannot overflow because out <= old value of *output_length */
+	return punycode_success;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/DatagramSocket.cpp b/base/poco/Net/src/DatagramSocket.cpp
new file mode 100644
index 00000000000..8d7cc92e3e2
--- /dev/null
+++ b/base/poco/Net/src/DatagramSocket.cpp
@@ -0,0 +1,114 @@
+//
+// DatagramSocket.cpp
+//
+// Library: Net
+// Package: Sockets
+// Module:  DatagramSocket
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/DatagramSocket.h"
+#include "Poco/Net/DatagramSocketImpl.h"
+#include "Poco/Exception.h"
+
+
+using Poco::InvalidArgumentException;
+
+
+namespace Poco {
+namespace Net {
+
+
+DatagramSocket::DatagramSocket(): Socket(new DatagramSocketImpl)
+{
+}
+
+
+DatagramSocket::DatagramSocket(SocketAddress::Family family): Socket(new DatagramSocketImpl(family))
+{
+}
+
+
+DatagramSocket::DatagramSocket(const SocketAddress& address, bool reuseAddress): Socket(new DatagramSocketImpl(address.family()))
+{
+	bind(address, reuseAddress);
+}
+
+
+DatagramSocket::DatagramSocket(const Socket& socket): Socket(socket)
+{
+	if (!dynamic_cast<DatagramSocketImpl*>(impl()))
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+}
+
+
+DatagramSocket::DatagramSocket(SocketImpl* pImpl): Socket(pImpl)
+{
+	if (!dynamic_cast<DatagramSocketImpl*>(impl()))
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+}
+
+
+DatagramSocket::~DatagramSocket()
+{
+}
+
+
+DatagramSocket& DatagramSocket::operator = (const Socket& socket)
+{
+	if (dynamic_cast<DatagramSocketImpl*>(socket.impl()))
+		Socket::operator = (socket);
+	else
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+	return *this;
+}
+
+
+void DatagramSocket::connect(const SocketAddress& address)
+{
+	impl()->connect(address);
+}
+
+
+void DatagramSocket::bind(const SocketAddress& address, bool reuseAddress)
+{
+	impl()->bind(address, reuseAddress);
+}
+
+
+void DatagramSocket::bind(const SocketAddress& address, bool reuseAddress, bool reusePort)
+{
+	impl()->bind(address, reuseAddress, reusePort);
+}
+
+
+int DatagramSocket::sendBytes(const void* buffer, int length, int flags)
+{
+	return impl()->sendBytes(buffer, length, flags);
+}
+
+
+int DatagramSocket::receiveBytes(void* buffer, int length, int flags)
+{
+	return impl()->receiveBytes(buffer, length, flags);
+}
+
+
+int DatagramSocket::sendTo(const void* buffer, int length, const SocketAddress& address, int flags)
+{
+	return impl()->sendTo(buffer, length, address, flags);
+}
+
+
+int DatagramSocket::receiveFrom(void* buffer, int length, SocketAddress& address, int flags)
+{
+	return impl()->receiveFrom(buffer, length, address, flags);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/DatagramSocketImpl.cpp b/base/poco/Net/src/DatagramSocketImpl.cpp
new file mode 100644
index 00000000000..9b86ebe6119
--- /dev/null
+++ b/base/poco/Net/src/DatagramSocketImpl.cpp
@@ -0,0 +1,63 @@
+//
+// DatagramSocketImpl.cpp
+//
+// Library: Net
+// Package: Sockets
+// Module:  DatagramSocketImpl
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/DatagramSocketImpl.h"
+#include "Poco/Net/NetException.h"
+
+
+using Poco::InvalidArgumentException;
+
+
+namespace Poco {
+namespace Net {
+
+
+DatagramSocketImpl::DatagramSocketImpl()
+{
+}
+
+
+DatagramSocketImpl::DatagramSocketImpl(SocketAddress::Family family)
+{
+	if (family == SocketAddress::IPv4)
+		init(AF_INET);
+#if defined(POCO_HAVE_IPv6)
+	else if (family == SocketAddress::IPv6)
+		init(AF_INET6);
+#endif
+#if defined(POCO_OS_FAMILY_UNIX)
+	else if (family == SocketAddress::UNIX_LOCAL)
+		init(AF_UNIX);
+#endif
+	else throw InvalidArgumentException("Invalid or unsupported address family passed to DatagramSocketImpl");
+}
+
+	
+DatagramSocketImpl::DatagramSocketImpl(poco_socket_t sockfd): SocketImpl(sockfd)
+{
+}
+
+
+DatagramSocketImpl::~DatagramSocketImpl()
+{
+}
+
+
+void DatagramSocketImpl::init(int af)
+{
+	initSocket(af, SOCK_DGRAM);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/DialogSocket.cpp b/base/poco/Net/src/DialogSocket.cpp
new file mode 100644
index 00000000000..030280c6c3f
--- /dev/null
+++ b/base/poco/Net/src/DialogSocket.cpp
@@ -0,0 +1,295 @@
+//
+// DialogSocket.cpp
+//
+// Library: Net
+// Package: Sockets
+// Module:  DialogSocket
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/DialogSocket.h"
+#include "Poco/Exception.h"
+#include "Poco/Ascii.h"
+#include <cstring>
+
+
+namespace Poco {
+namespace Net {
+
+
+DialogSocket::DialogSocket():
+	_pBuffer(0),
+	_pNext(0),
+	_pEnd(0)
+{
+	allocBuffer();
+}
+
+
+DialogSocket::DialogSocket(const SocketAddress& address):
+	StreamSocket(address),
+	_pBuffer(0),
+	_pNext(0),
+	_pEnd(0)
+{
+	allocBuffer();
+}
+
+
+DialogSocket::DialogSocket(const Socket& socket):
+	StreamSocket(socket),
+	_pBuffer(0),
+	_pNext(0),
+	_pEnd(0)
+{
+	allocBuffer();
+}
+
+
+DialogSocket::DialogSocket(const DialogSocket& socket):
+	StreamSocket(socket),
+	_pBuffer(0),
+	_pNext(0),
+	_pEnd(0)
+{
+	allocBuffer();
+}
+
+
+DialogSocket::~DialogSocket()
+{
+	delete [] _pBuffer;
+}
+
+
+DialogSocket& DialogSocket::operator = (const Socket& socket)
+{
+	StreamSocket::operator = (socket);
+	_pNext   = _pBuffer;
+	_pEnd    = _pBuffer;
+	return *this;
+}
+
+
+DialogSocket& DialogSocket::operator = (const DialogSocket& socket)
+{
+	StreamSocket::operator = (socket);
+	_pNext   = _pBuffer;
+	_pEnd    = _pBuffer;
+	return *this;
+}
+
+
+void DialogSocket::sendByte(unsigned char ch)
+{
+	sendBytes(&ch, 1);
+}
+
+
+void DialogSocket::sendString(const char* str)
+{
+	sendBytes(str, (int) std::strlen(str));
+}
+
+
+void DialogSocket::sendString(const std::string& str)
+{
+	sendBytes(str.data(), (int) str.length());
+}
+
+
+void DialogSocket::sendMessage(const std::string& message)
+{
+	std::string line;
+	line.reserve(message.length() + 2);
+	line.append(message);
+	line.append("\r\n");
+	sendString(line);
+}
+
+
+void DialogSocket::sendMessage(const std::string& message, const std::string& arg)
+{
+	std::string line;
+	line.reserve(message.length() + arg.length() + 3);
+	line.append(message);
+	if (!arg.empty())
+	{
+		line.append(" ");
+		line.append(arg);
+	}
+	line.append("\r\n");
+	sendString(line);
+}
+
+
+void DialogSocket::sendMessage(const std::string& message, const std::string& arg1, const std::string& arg2)
+{
+	std::string line;
+	line.reserve(message.length() + arg1.length() +arg2.length() + 4);
+	line.append(message);
+	line.append(" ");
+	line.append(arg1);
+	if (!arg2.empty())
+	{
+		line.append(" ");
+		line.append(arg2);
+	}
+	line.append("\r\n");
+	sendString(line);
+}
+
+
+bool DialogSocket::receiveMessage(std::string& message)
+{
+	message.clear();
+	return receiveLine(message, MAX_LINE_LENGTH);
+}
+
+
+int DialogSocket::receiveStatusMessage(std::string& message)
+{
+	message.clear();
+	int status = receiveStatusLine(message, MAX_LINE_LENGTH);
+	if (status < 0)
+	{
+		while (status <= 0)
+		{
+			message += '\n';
+			status = receiveStatusLine(message, message.length() + MAX_LINE_LENGTH);
+		}
+	}
+	return status;
+}
+
+
+int DialogSocket::get()
+{
+	refill();
+	if (_pNext != _pEnd)
+		return std::char_traits<char>::to_int_type(*_pNext++);
+	else
+		return EOF_CHAR;
+}
+
+
+int DialogSocket::peek()
+{
+	refill();
+	if (_pNext != _pEnd)
+		return std::char_traits<char>::to_int_type(*_pNext);
+	else
+		return EOF_CHAR;
+}
+
+
+void DialogSocket::synch()
+{
+	sendUrgent(TELNET_DM);
+}
+
+
+void DialogSocket::sendTelnetCommand(unsigned char command)
+{
+	unsigned char buffer[2];
+	buffer[0] = TELNET_IAC;
+	buffer[1] = command;
+	sendBytes(buffer, 2);
+}
+
+
+void DialogSocket::sendTelnetCommand(unsigned char command, unsigned char arg)
+{
+	unsigned char buffer[3];
+	buffer[0] = TELNET_IAC;
+	buffer[1] = command;
+	buffer[2] = arg;
+	sendBytes(buffer, 3);
+}
+
+
+void DialogSocket::refill()
+{
+	if (_pNext == _pEnd)
+	{
+		int n = receiveBytes(_pBuffer, RECEIVE_BUFFER_SIZE);
+		if (n > 0)
+		{
+			_pNext = _pBuffer;
+			_pEnd  = _pBuffer + n;
+		}
+	}
+}
+
+
+void DialogSocket::allocBuffer()
+{
+	_pBuffer = new char [RECEIVE_BUFFER_SIZE];
+	_pNext   = _pBuffer;
+	_pEnd    = _pBuffer;
+}
+
+
+bool DialogSocket::receiveLine(std::string& line, std::size_t lineLengthLimit)
+{
+	// An old wisdom goes: be strict in what you emit
+	// and generous in what you accept.
+	int ch = get();
+	while (ch != EOF_CHAR && ch != '\r' && ch != '\n')
+	{
+		if (lineLengthLimit == 0 || line.size() < lineLengthLimit)
+			line += (char) ch;
+		else
+			throw Poco::IOException("Line too long");
+		ch = get();
+	}
+	if (ch == '\r' && peek() == '\n')
+		get();
+	else if (ch == EOF_CHAR)
+		return false;
+	return true;
+}
+
+
+int DialogSocket::receiveStatusLine(std::string& line, std::size_t lineLengthLimit)
+{
+	int status = 0;
+	int ch = get();
+	if (ch != EOF_CHAR) line += (char) ch;
+	int n = 0;
+	while (Poco::Ascii::isDigit(ch) && n < 3)
+	{
+		status *= 10;
+		status += ch - '0';
+		++n;
+		ch = get();
+		if (ch != EOF_CHAR) line += (char) ch;
+	}
+	if (n == 3)
+	{
+		if (ch == '-')
+			status = -status;
+	}
+	else status = 0;
+	if (ch != EOF_CHAR) receiveLine(line, lineLengthLimit);
+	return status;
+}
+
+
+int DialogSocket::receiveRawBytes(void* buffer, int length)
+{
+	refill();
+	int n = static_cast<int>(_pEnd - _pNext);
+	if (n > length) n = length;
+	std::memcpy(buffer, _pNext, n);
+	_pNext += n;
+	return n;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/FTPClientSession.cpp b/base/poco/Net/src/FTPClientSession.cpp
new file mode 100644
index 00000000000..e0bf4489832
--- /dev/null
+++ b/base/poco/Net/src/FTPClientSession.cpp
@@ -0,0 +1,599 @@
+//
+// FTPClientSession.cpp
+//
+// Library: Net
+// Package: FTP
+// Module:  FTPClientSession
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/FTPClientSession.h"
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/Net/SocketStream.h"
+#include "Poco/Net/ServerSocket.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/Ascii.h"
+
+
+using Poco::NumberFormatter;
+
+
+namespace Poco {
+namespace Net {
+
+
+FTPClientSession::FTPClientSession():
+	_port(0),
+	_pControlSocket(0),
+	_pDataStream(0),
+	_passiveMode(true),
+	_fileType(TYPE_BINARY),
+	_supports1738(true),
+	_serverReady(false),
+	_isLoggedIn(false),
+	_timeout(DEFAULT_TIMEOUT)
+{
+}
+
+	
+FTPClientSession::FTPClientSession(const StreamSocket& socket):
+	_host(socket.address().host().toString()),
+	_port(socket.address().port()),
+	_pControlSocket(new DialogSocket(socket)),
+	_pDataStream(0),
+	_passiveMode(true),
+	_fileType(TYPE_BINARY),
+	_supports1738(true),
+	_serverReady(false),
+	_isLoggedIn(false),
+	_timeout(DEFAULT_TIMEOUT)
+{
+	_pControlSocket->setReceiveTimeout(_timeout);
+}
+
+
+FTPClientSession::FTPClientSession(const std::string& host,
+	Poco::UInt16 port,
+	const std::string& username,
+	const std::string& password):
+	_host(host),
+	_port(port),
+	_pControlSocket(new DialogSocket(SocketAddress(host, port))),
+	_pDataStream(0),
+	_passiveMode(true),
+	_fileType(TYPE_BINARY),
+	_supports1738(true),
+	_serverReady(false),
+	_isLoggedIn(false),
+	_timeout(DEFAULT_TIMEOUT)
+{
+	if (!username.empty())
+		login(username, password);
+	else
+		_pControlSocket->setReceiveTimeout(_timeout);
+}
+
+
+FTPClientSession::~FTPClientSession()
+{
+	try
+	{
+		close();
+	}
+	catch (...) 
+	{
+	}
+}
+
+
+void FTPClientSession::setTimeout(const Poco::Timespan& timeout)
+{
+	if (!isOpen())
+		throw FTPException("Connection is closed.");
+
+	_timeout = timeout;
+	_pControlSocket->setReceiveTimeout(timeout);
+}
+
+	
+Poco::Timespan FTPClientSession::getTimeout() const
+{
+	return _timeout;
+}
+
+
+void FTPClientSession::setPassive(bool flag, bool useRFC1738)
+{
+	_passiveMode  = flag;
+	_supports1738 = useRFC1738;
+}
+
+	
+bool FTPClientSession::getPassive() const
+{
+	return _passiveMode;
+}
+
+
+void FTPClientSession::open(const std::string& host,
+	Poco::UInt16 port,
+	const std::string& username,
+	const std::string& password)
+{
+	_host = host;
+	_port = port;
+	if (!username.empty())
+	{
+		login(username, password);
+	}
+	else
+	{
+		_pControlSocket = new DialogSocket(SocketAddress(_host, _port));
+		_pControlSocket->setReceiveTimeout(_timeout);
+	}
+}
+
+
+void FTPClientSession::login(const std::string& username, const std::string& password)
+{
+	if (_isLoggedIn) logout();
+
+	int status = FTP_POSITIVE_COMPLETION * 100;
+	std::string response;
+	if (!_pControlSocket)
+	{
+		_pControlSocket = new DialogSocket(SocketAddress(_host, _port));
+		_pControlSocket->setReceiveTimeout(_timeout);
+	}
+
+	if (!_serverReady)
+	{
+		status = _pControlSocket->receiveStatusMessage(response);
+		if (!isPositiveCompletion(status))
+			throw FTPException("Cannot login to server", response, status);
+
+		_serverReady = true;
+	}
+
+	status = sendCommand("USER", username, response);
+	if (isPositiveIntermediate(status))
+		status = sendCommand("PASS", password, response);
+	if (!isPositiveCompletion(status)) 
+		throw FTPException("Login denied", response, status);
+
+	setFileType(_fileType);
+	_isLoggedIn = true;
+}
+
+
+void FTPClientSession::logout()
+{
+	if (!isOpen())
+		throw FTPException("Connection is closed.");
+
+	if (_isLoggedIn)
+	{
+		try { endTransfer(); }
+		catch (...) { }
+		_isLoggedIn = false;
+		std::string response;
+		sendCommand("QUIT", response);
+	}
+}
+
+
+void FTPClientSession::close()
+{
+	try { logout(); }
+	catch (...) {}
+	_serverReady = false;
+	if (_pControlSocket)
+	{
+		_pControlSocket->close();
+		delete _pControlSocket;
+		_pControlSocket = 0;
+	}
+}
+
+
+void FTPClientSession::setFileType(FTPClientSession::FileType type)
+{
+	std::string response;
+	int status = sendCommand("TYPE", (type == TYPE_TEXT ? "A" : "I"), response);
+	if (!isPositiveCompletion(status)) throw FTPException("Cannot set file type", response, status);
+	_fileType = type;
+}
+
+
+FTPClientSession::FileType FTPClientSession::getFileType() const
+{
+	return _fileType;
+}
+
+
+std::string FTPClientSession::systemType()
+{
+	std::string response;
+	int status = sendCommand("SYST", response);
+	if (isPositiveCompletion(status))
+		return response.substr(4);
+	else
+		throw FTPException("Cannot get remote system type", response, status);
+}
+
+
+void FTPClientSession::setWorkingDirectory(const std::string& path)
+{
+	std::string response;
+	int status = sendCommand("CWD", path, response);
+	if (!isPositiveCompletion(status))
+		throw FTPException("Cannot change directory", response, status);
+}
+
+
+std::string FTPClientSession::getWorkingDirectory()
+{
+	std::string response;
+	int status = sendCommand("PWD", response);
+	if (isPositiveCompletion(status))
+		return extractPath(response);
+	else
+		throw FTPException("Cannot get current working directory", response, status);
+}
+
+
+void FTPClientSession::cdup()
+{
+	std::string response;
+	int status = sendCommand("CDUP", response);
+	if (!isPositiveCompletion(status))
+		throw FTPException("Cannot change directory", response, status);
+}
+
+	
+void FTPClientSession::rename(const std::string& oldName, const std::string& newName)
+{
+	std::string response;
+	int status = sendCommand("RNFR", oldName, response);
+	if (!isPositiveIntermediate(status)) 
+		throw FTPException(std::string("Cannot rename ") + oldName, response, status);
+	status = sendCommand("RNTO", newName, response);
+	if (!isPositiveCompletion(status)) 
+		throw FTPException(std::string("Cannot rename to ") + newName, response, status);
+}
+
+	
+void FTPClientSession::remove(const std::string& path)
+{
+	std::string response;
+	int status = sendCommand("DELE", path, response);
+	if (!isPositiveCompletion(status)) 
+		throw FTPException(std::string("Cannot remove " + path), response, status);
+}
+
+
+void FTPClientSession::createDirectory(const std::string& path)
+{
+	std::string response;
+	int status = sendCommand("MKD", path, response);
+	if (!isPositiveCompletion(status)) 
+		throw FTPException(std::string("Cannot create directory ") + path, response, status);
+}
+
+
+void FTPClientSession::removeDirectory(const std::string& path)
+{
+	std::string response;
+	int status = sendCommand("RMD", path, response);
+	if (!isPositiveCompletion(status)) 
+		throw FTPException(std::string("Cannot remove directory ") + path, response, status);
+}
+
+
+std::istream& FTPClientSession::beginDownload(const std::string& path)
+{
+	if (!isOpen())
+		throw FTPException("Connection is closed.");
+
+	delete _pDataStream;
+	_pDataStream = 0;
+	_pDataStream = new SocketStream(establishDataConnection("RETR", path));
+	return *_pDataStream;
+}
+
+	
+void FTPClientSession::endDownload()
+{
+	endTransfer();
+}
+
+	
+std::ostream& FTPClientSession::beginUpload(const std::string& path)
+{
+	if (!isOpen())
+		throw FTPException("Connection is closed.");
+
+	delete _pDataStream;
+	_pDataStream = 0;
+	_pDataStream = new SocketStream(establishDataConnection("STOR", path));
+	return *_pDataStream;
+}
+
+
+void FTPClientSession::endUpload()
+{
+	endTransfer();
+}
+
+
+std::istream& FTPClientSession::beginList(const std::string& path, bool extended)
+{
+	if (!isOpen())
+		throw FTPException("Connection is closed.");
+
+	delete _pDataStream;
+	_pDataStream = 0;
+	_pDataStream = new SocketStream(establishDataConnection(extended ? "LIST" : "NLST", path));
+	return *_pDataStream;
+}
+
+
+void FTPClientSession::endList()
+{
+	endTransfer();
+}
+
+	
+void FTPClientSession::abort()
+{
+	if (!isOpen())
+		throw FTPException("Connection is closed.");
+
+	_pControlSocket->sendByte(DialogSocket::TELNET_IP);
+	_pControlSocket->synch();
+	std::string response;
+	int status = sendCommand("ABOR", response);
+	if (status == 426)
+		status = _pControlSocket->receiveStatusMessage(response);
+	if (status != 226) 
+		throw FTPException("Cannot abort transfer", response, status);
+}
+
+
+int FTPClientSession::sendCommand(const std::string& command, std::string& response)
+{
+	if (!isOpen())
+		throw FTPException("Connection is closed.");
+
+	_pControlSocket->sendMessage(command);
+	return _pControlSocket->receiveStatusMessage(response);
+}
+
+
+int FTPClientSession::sendCommand(const std::string& command, const std::string& arg, std::string& response)
+{
+	if (!isOpen())
+		throw FTPException("Connection is closed.");
+
+	_pControlSocket->sendMessage(command, arg);
+	return _pControlSocket->receiveStatusMessage(response);
+}
+
+
+std::string FTPClientSession::extractPath(const std::string& response)
+{
+	std::string path;
+	std::string::const_iterator it  = response.begin();
+	std::string::const_iterator end = response.end();
+	while (it != end && *it != '"') ++it;
+	if (it != end)
+	{
+		++it;
+		while (it != end)
+		{
+			if (*it == '"')
+			{
+				++it;
+				if (it == end || (it != end && *it != '"')) break;
+			}
+			path += *it++;
+		}
+	}
+	return path;
+}
+
+
+StreamSocket FTPClientSession::establishDataConnection(const std::string& command, const std::string& arg)
+{
+	if (_passiveMode)
+		return passiveDataConnection(command, arg);
+	else
+		return activeDataConnection(command, arg);
+}
+
+
+StreamSocket FTPClientSession::activeDataConnection(const std::string& command, const std::string& arg)
+{
+	if (!isOpen())
+		throw FTPException("Connection is closed.");
+
+	ServerSocket server(SocketAddress(_pControlSocket->address().host(), 0));
+	sendPortCommand(server.address());
+	std::string response;
+	int status = sendCommand(command, arg, response);
+	if (!isPositivePreliminary(status)) 
+		throw FTPException(command + " command failed", response, status);
+	if (server.poll(_timeout, Socket::SELECT_READ))
+		return server.acceptConnection();
+	else
+		throw FTPException("The server has not initiated a data connection");
+}
+
+
+StreamSocket FTPClientSession::passiveDataConnection(const std::string& command, const std::string& arg)
+{
+	SocketAddress sa(sendPassiveCommand());
+	StreamSocket sock(sa);
+	std::string response;
+	int status = sendCommand(command, arg, response);
+	if (!isPositivePreliminary(status)) 
+		throw FTPException(command + " command failed", response, status);
+	return sock;
+}
+
+
+void FTPClientSession::sendPortCommand(const SocketAddress& addr)
+{
+	if (_supports1738)
+	{
+		if (sendEPRT(addr))
+			return;
+		else
+			_supports1738 = false;
+	}
+	sendPORT(addr);
+}
+
+
+SocketAddress FTPClientSession::sendPassiveCommand()
+{
+	SocketAddress addr;
+	if (_supports1738)
+	{
+		if (sendEPSV(addr))
+			return addr;
+		else
+			_supports1738 = false;
+	}
+	sendPASV(addr);
+	return addr;
+}
+
+
+bool FTPClientSession::sendEPRT(const SocketAddress& addr)
+{
+	std::string arg("|");
+	arg += addr.af() == AF_INET ? '1' : '2';
+	arg += '|';
+	arg += addr.host().toString();
+	arg += '|';
+	arg += NumberFormatter::format(addr.port());
+	arg += '|';
+	std::string response;
+	int status = sendCommand("EPRT", arg, response);
+	if (isPositiveCompletion(status))
+		return true;
+	else if (isPermanentNegative(status))
+		return false;
+	else
+		throw FTPException("EPRT command failed", response, status);
+}
+
+
+void FTPClientSession::sendPORT(const SocketAddress& addr)
+{
+	std::string arg(addr.host().toString());
+	for (std::string::iterator it = arg.begin(); it != arg.end(); ++it)
+	{
+		if (*it == '.') *it = ',';
+	}
+	arg += ',';
+	Poco::UInt16 port = addr.port();
+	arg += NumberFormatter::format(port/256);
+	arg += ',';
+	arg += NumberFormatter::format(port % 256);
+	std::string response;
+	int status = sendCommand("PORT", arg, response);
+	if (!isPositiveCompletion(status)) 
+		throw FTPException("PORT command failed", response, status);
+}
+
+
+bool FTPClientSession::sendEPSV(SocketAddress& addr)
+{
+	std::string response;
+	int status = sendCommand("EPSV", response);
+	if (isPositiveCompletion(status))
+	{
+		parseExtAddress(response, addr);
+		return true;
+	}
+	else if (isPermanentNegative(status))
+	{
+		return false;
+	}
+	else throw FTPException("EPSV command failed", response, status);
+}
+
+
+void FTPClientSession::sendPASV(SocketAddress& addr)
+{
+	std::string response;
+	int status = sendCommand("PASV", response);
+	if (!isPositiveCompletion(status)) 
+		throw FTPException("PASV command failed", response, status);
+	parseAddress(response, addr);
+}
+
+
+void FTPClientSession::parseAddress(const std::string& str, SocketAddress& addr)
+{
+	std::string::const_iterator it  = str.begin();
+	std::string::const_iterator end = str.end();
+	while (it != end && *it != '(') ++it;
+	if (it != end) ++it;
+	std::string host;
+	while (it != end && Poco::Ascii::isDigit(*it)) host += *it++;
+	if (it != end && *it == ',') { host += '.'; ++it; }
+	while (it != end && Poco::Ascii::isDigit(*it)) host += *it++;
+	if (it != end && *it == ',') { host += '.'; ++it; }
+	while (it != end && Poco::Ascii::isDigit(*it)) host += *it++;
+	if (it != end && *it == ',') { host += '.'; ++it; }
+	while (it != end && Poco::Ascii::isDigit(*it)) host += *it++;
+	if (it != end && *it == ',') ++it;
+	Poco::UInt16 portHi = 0;
+	while (it != end && Poco::Ascii::isDigit(*it)) { portHi *= 10; portHi += *it++ - '0'; }
+	if (it != end && *it == ',') ++it;
+	Poco::UInt16 portLo = 0;
+	while (it != end && Poco::Ascii::isDigit(*it)) { portLo *= 10; portLo += *it++ - '0'; }
+	addr = SocketAddress(host, portHi*256 + portLo);
+}
+
+
+void FTPClientSession::parseExtAddress(const std::string& str, SocketAddress& addr)
+{
+	std::string::const_iterator it  = str.begin();
+	std::string::const_iterator end = str.end();
+	while (it != end && *it != '(') ++it;
+	if (it != end) ++it;
+	char delim = '|';
+	if (it != end) delim = *it++;
+	if (it != end && *it == delim) ++it;
+	if (it != end && *it == delim) ++it;
+	Poco::UInt16 port = 0;
+	while (it != end && Poco::Ascii::isDigit(*it)) { port *= 10; port += *it++ - '0'; }	
+	addr = SocketAddress(_pControlSocket->peerAddress().host(), port);	
+}
+
+
+void FTPClientSession::endTransfer()
+{
+	if (_pDataStream)
+	{
+		delete _pDataStream;
+		_pDataStream = 0;
+		std::string response;
+		int status = _pControlSocket->receiveStatusMessage(response);
+		if (!isPositiveCompletion(status)) 
+			throw FTPException("Data transfer failed", response, status);
+	}
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/FTPStreamFactory.cpp b/base/poco/Net/src/FTPStreamFactory.cpp
new file mode 100644
index 00000000000..b557e2f7512
--- /dev/null
+++ b/base/poco/Net/src/FTPStreamFactory.cpp
@@ -0,0 +1,243 @@
+//
+// FTPStreamFactory.cpp
+//
+// Library: Net
+// Package: FTP
+// Module:  FTPStreamFactory
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/FTPStreamFactory.h"
+#include "Poco/Net/FTPClientSession.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/URI.h"
+#include "Poco/URIStreamOpener.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include "Poco/Path.h"
+
+
+using Poco::URIStreamFactory;
+using Poco::URI;
+using Poco::URIStreamOpener;
+using Poco::UnbufferedStreamBuf;
+using Poco::Path;
+
+
+namespace Poco {
+namespace Net {
+
+
+class FTPStreamBuf: public UnbufferedStreamBuf
+{
+public:
+	FTPStreamBuf(std::istream& istr):
+		_istr(istr)
+	{
+		// make sure exceptions from underlying string propagate
+		_istr.exceptions(std::ios::badbit);
+	}
+	
+	~FTPStreamBuf()
+	{
+	}
+		
+private:
+	int readFromDevice()
+	{
+		return _istr.get();
+	}
+	
+	std::istream& _istr;
+};
+
+
+class FTPIOS: public virtual std::ios
+{
+public:
+	FTPIOS(std::istream& istr):
+		_buf(istr)
+	{
+		poco_ios_init(&_buf);
+	}
+	
+	~FTPIOS()
+	{
+	}
+	
+	FTPStreamBuf* rdbuf()
+	{
+		return &_buf;
+	}
+
+protected:
+	FTPStreamBuf _buf;
+};
+
+
+class FTPStream: public FTPIOS, public std::istream
+{
+public:
+	FTPStream(std::istream& istr, FTPClientSession* pSession):
+		FTPIOS(istr),
+		std::istream(&_buf),
+		_pSession(pSession)
+	{
+	}
+		
+	~FTPStream()
+	{
+		delete _pSession;
+	}
+	
+private:
+	FTPClientSession* _pSession;
+};
+
+
+FTPPasswordProvider::FTPPasswordProvider()
+{
+}
+
+
+FTPPasswordProvider::~FTPPasswordProvider()
+{
+}
+
+
+std::string          FTPStreamFactory::_anonymousPassword("poco@localhost");
+FTPPasswordProvider* FTPStreamFactory::_pPasswordProvider(0);
+
+
+FTPStreamFactory::FTPStreamFactory()
+{
+}
+
+
+FTPStreamFactory::~FTPStreamFactory()
+{
+}
+
+
+std::istream* FTPStreamFactory::open(const URI& uri)
+{
+	poco_assert (uri.getScheme() == "ftp");
+
+	FTPClientSession* pSession = new FTPClientSession(uri.getHost(), uri.getPort());
+	try
+	{
+		std::string username;
+		std::string password;
+		getUserInfo(uri, username, password);
+		
+		std::string path;
+		char        type;
+		getPathAndType(uri, path, type);
+			
+		pSession->login(username, password);
+		if (type == 'a')
+			pSession->setFileType(FTPClientSession::TYPE_TEXT);
+			
+		Path p(path, Path::PATH_UNIX);
+		p.makeFile();
+		for (int i = 0; i < p.depth(); ++i)
+			pSession->setWorkingDirectory(p[i]);
+		std::string file(p.getFileName());
+		std::istream& istr = (type == 'd' ? pSession->beginList(file) : pSession->beginDownload(file));
+		return new FTPStream(istr, pSession);
+	}
+	catch (...)
+	{
+		delete pSession;
+		throw;
+	}
+}
+
+
+void FTPStreamFactory::setAnonymousPassword(const std::string& password)
+{
+	_anonymousPassword = password;
+}
+
+	
+const std::string& FTPStreamFactory::getAnonymousPassword()
+{
+	return _anonymousPassword;
+}
+
+	
+void FTPStreamFactory::setPasswordProvider(FTPPasswordProvider* pProvider)
+{
+	_pPasswordProvider = pProvider;
+}
+
+	
+FTPPasswordProvider* FTPStreamFactory::getPasswordProvider()
+{
+	return _pPasswordProvider;
+}
+
+
+void FTPStreamFactory::splitUserInfo(const std::string& userInfo, std::string& username, std::string& password)
+{
+	std::string::size_type pos = userInfo.find(':');
+	if (pos != std::string::npos)
+	{
+		username.assign(userInfo, 0, pos++);
+		password.assign(userInfo, pos, userInfo.size() - pos);
+	}
+	else username = userInfo;
+}
+
+
+void FTPStreamFactory::getUserInfo(const URI& uri, std::string& username, std::string& password)
+{
+	splitUserInfo(uri.getUserInfo(), username, password);
+	if (username.empty())
+	{
+		username = "anonymous";
+		password = _anonymousPassword;
+	}
+	else if (password.empty())
+	{
+		if (_pPasswordProvider)
+			password = _pPasswordProvider->password(username, uri.getHost());
+		else
+			throw FTPException(std::string("Password required for ") + username + "@" + uri.getHost());
+	}
+}
+
+
+void FTPStreamFactory::getPathAndType(const Poco::URI& uri, std::string& path, char& type)
+{
+	path = uri.getPath();
+	type = 'i';
+	std::string::size_type pos = path.rfind(';');
+	if (pos != std::string::npos)
+	{
+		if (path.length() == pos + 7 && path.compare(pos + 1, 5, "type=") == 0)
+		{
+			type = path[pos + 6];
+			path.resize(pos);
+		}
+	}
+}
+
+
+void FTPStreamFactory::registerFactory()
+{
+	URIStreamOpener::defaultOpener().registerStreamFactory("ftp", new FTPStreamFactory);
+}
+
+
+void FTPStreamFactory::unregisterFactory()
+{
+	URIStreamOpener::defaultOpener().unregisterStreamFactory("ftp");
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/FilePartSource.cpp b/base/poco/Net/src/FilePartSource.cpp
new file mode 100644
index 00000000000..afd3a01db70
--- /dev/null
+++ b/base/poco/Net/src/FilePartSource.cpp
@@ -0,0 +1,87 @@
+//
+// FilePartSource.cpp
+//
+// Library: Net
+// Package: Messages
+// Module:  FilePartSource
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/FilePartSource.h"
+#include "Poco/Path.h"
+#include "Poco/File.h"
+#include "Poco/Exception.h"
+
+
+using Poco::Path;
+using Poco::OpenFileException;
+
+
+namespace Poco {
+namespace Net {
+
+
+FilePartSource::FilePartSource(const std::string& path):
+	_path(path), _istr(path)
+{
+	Path p(path);
+	_filename = p.getFileName();
+	if (!_istr.good())
+		throw OpenFileException(path);
+}
+
+
+FilePartSource::FilePartSource(const std::string& path, const std::string& mediaType):
+	PartSource(mediaType),
+	_path(path),
+	_istr(path)
+{
+	Path p(path);
+	_filename = p.getFileName();
+	if (!_istr.good())
+		throw OpenFileException(path);
+}
+
+
+FilePartSource::FilePartSource(const std::string& path, const std::string& filename, const std::string& mediaType):
+	PartSource(mediaType),
+	_path(path),
+	_filename(filename),
+	_istr(path)
+{
+	Path p(path);
+	if (!_istr.good())
+		throw OpenFileException(path);
+}
+
+
+FilePartSource::~FilePartSource()
+{
+}
+
+
+std::istream& FilePartSource::stream()
+{
+	return _istr;
+}
+
+
+const std::string& FilePartSource::filename() const
+{
+	return _filename;
+}
+
+
+std::streamsize FilePartSource::getContentLength() const
+{
+	Poco::File p(_path);
+	return static_cast<std::streamsize>(p.getSize());
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTMLForm.cpp b/base/poco/Net/src/HTMLForm.cpp
new file mode 100644
index 00000000000..3de03e6c6b7
--- /dev/null
+++ b/base/poco/Net/src/HTMLForm.cpp
@@ -0,0 +1,468 @@
+//
+// HTMLForm.cpp
+//
+// Library: Net
+// Package: HTML
+// Module:  HTMLForm
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTMLForm.h"
+#include "Poco/Net/HTTPRequest.h"
+#include "Poco/Net/PartSource.h"
+#include "Poco/Net/PartHandler.h"
+#include "Poco/Net/MultipartWriter.h"
+#include "Poco/Net/MultipartReader.h"
+#include "Poco/Net/NullPartHandler.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/NullStream.h"
+#include "Poco/CountingStream.h"
+#include "Poco/StreamCopier.h"
+#include "Poco/URI.h"
+#include "Poco/String.h"
+#include "Poco/CountingStream.h"
+#include "Poco/UTF8String.h"
+#include <sstream>
+
+
+using Poco::NullInputStream;
+using Poco::StreamCopier;
+using Poco::SyntaxException;
+using Poco::URI;
+using Poco::icompare;
+
+
+namespace Poco {
+namespace Net {
+
+
+const std::string HTMLForm::ENCODING_URL           = "application/x-www-form-urlencoded";
+const std::string HTMLForm::ENCODING_MULTIPART     = "multipart/form-data";
+const int         HTMLForm::UNKNOWN_CONTENT_LENGTH = -1;
+
+
+class HTMLFormCountingOutputStream: public CountingOutputStream
+{
+public:
+	HTMLFormCountingOutputStream():
+		_valid(true)
+	{
+	}
+
+	bool isValid() const
+	{
+		return _valid;
+	}
+
+	void setValid(bool v)
+	{
+		_valid = v;
+	}
+
+private:
+	bool _valid;
+};
+
+
+HTMLForm::HTMLForm():
+	_fieldLimit(DFL_FIELD_LIMIT),
+	_valueLengthLimit(DFL_MAX_VALUE_LENGTH),
+	_encoding(ENCODING_URL)
+{
+}
+
+
+HTMLForm::HTMLForm(const std::string& encoding):
+	_fieldLimit(DFL_FIELD_LIMIT),
+	_valueLengthLimit(DFL_MAX_VALUE_LENGTH),
+	_encoding(encoding)
+{
+}
+
+
+HTMLForm::HTMLForm(const HTTPRequest& request, std::istream& requestBody, PartHandler& handler):
+	_fieldLimit(DFL_FIELD_LIMIT),
+	_valueLengthLimit(DFL_MAX_VALUE_LENGTH)
+{
+	load(request, requestBody, handler);
+}
+
+
+HTMLForm::HTMLForm(const HTTPRequest& request, std::istream& requestBody):
+	_fieldLimit(DFL_FIELD_LIMIT),
+	_valueLengthLimit(DFL_MAX_VALUE_LENGTH)
+{
+	load(request, requestBody);
+}
+
+
+HTMLForm::HTMLForm(const HTTPRequest& request):
+	_fieldLimit(DFL_FIELD_LIMIT),
+	_valueLengthLimit(DFL_MAX_VALUE_LENGTH)
+{
+	load(request);
+}
+
+
+HTMLForm::~HTMLForm()
+{
+	for (PartVec::iterator it = _parts.begin(); it != _parts.end(); ++it)
+	{
+		delete it->pSource;
+	}
+}
+
+
+void HTMLForm::setEncoding(const std::string& encoding)
+{
+	_encoding = encoding;
+}
+
+
+void HTMLForm::addPart(const std::string& name, PartSource* pSource)
+{
+	poco_check_ptr (pSource);
+
+	Part part;
+	part.name    = name;
+	part.pSource = pSource;
+	_parts.push_back(part);
+}
+
+
+void HTMLForm::load(const HTTPRequest& request, std::istream& requestBody, PartHandler& handler)
+{
+	clear();
+
+	URI uri(request.getURI());
+	const std::string& query = uri.getRawQuery();
+	if (!query.empty())
+	{
+		std::istringstream istr(query);
+		readUrl(istr);
+	}
+
+	if (request.getMethod() == HTTPRequest::HTTP_POST || request.getMethod() == HTTPRequest::HTTP_PUT)
+	{
+		std::string mediaType;
+		NameValueCollection params;
+		MessageHeader::splitParameters(request.getContentType(), mediaType, params);
+		_encoding = mediaType;
+		if (_encoding == ENCODING_MULTIPART)
+		{
+			_boundary = params["boundary"];
+			readMultipart(requestBody, handler);
+		}
+		else
+		{
+			readUrl(requestBody);
+		}
+	}
+}
+
+
+void HTMLForm::load(const HTTPRequest& request, std::istream& requestBody)
+{
+	NullPartHandler nah;
+	load(request, requestBody, nah);
+}
+
+
+void HTMLForm::load(const HTTPRequest& request)
+{
+	NullPartHandler nah;
+	NullInputStream nis;
+	load(request, nis, nah);
+}
+
+
+void HTMLForm::read(std::istream& istr, PartHandler& handler)
+{
+	if (_encoding == ENCODING_URL)
+		readUrl(istr);
+	else
+		readMultipart(istr, handler);
+}
+
+
+void HTMLForm::read(std::istream& istr)
+{
+	readUrl(istr);
+}
+
+
+void HTMLForm::read(const std::string& queryString)
+{
+	std::istringstream istr(queryString);
+	readUrl(istr);
+}
+
+
+void HTMLForm::prepareSubmit(HTTPRequest& request, int options)
+{
+	if (request.getMethod() == HTTPRequest::HTTP_POST || request.getMethod() == HTTPRequest::HTTP_PUT)
+	{
+		if (_encoding == ENCODING_URL)
+		{
+			request.setContentType(_encoding);
+			request.setChunkedTransferEncoding(false);
+			Poco::CountingOutputStream ostr;
+			writeUrl(ostr);
+			request.setContentLength(ostr.chars());
+		}
+		else
+		{
+			_boundary = MultipartWriter::createBoundary();
+			std::string ct(_encoding);
+			ct.append("; boundary=\"");
+			ct.append(_boundary);
+			ct.append("\"");
+			request.setContentType(ct);
+		}
+		if (request.getVersion() == HTTPMessage::HTTP_1_0)
+		{
+			request.setKeepAlive(false);
+			request.setChunkedTransferEncoding(false);
+		}
+		else if (_encoding != ENCODING_URL && (options & OPT_USE_CONTENT_LENGTH) == 0)
+		{
+			request.setChunkedTransferEncoding(true);
+		}
+		if (!request.getChunkedTransferEncoding() && !request.hasContentLength())
+ 		{
+ 			request.setContentLength(calculateContentLength());
+ 		}
+	}
+	else
+	{
+		std::string uri = request.getURI();
+		std::ostringstream ostr;
+		writeUrl(ostr);
+		uri.append("?");
+		uri.append(ostr.str());
+		request.setURI(uri);
+	}
+}
+
+
+std::streamsize HTMLForm::calculateContentLength()
+{
+	if (_encoding == ENCODING_MULTIPART && _boundary.empty())
+		throw HTMLFormException("Form must be prepared");
+
+	HTMLFormCountingOutputStream c;
+	write(c);
+	if (c.isValid())
+		return c.chars();
+	else
+		return UNKNOWN_CONTENT_LENGTH;
+}
+
+
+void HTMLForm::write(std::ostream& ostr, const std::string& boundary)
+{
+	if (_encoding == ENCODING_URL)
+	{
+		writeUrl(ostr);
+	}
+	else
+	{
+		_boundary = boundary;
+		writeMultipart(ostr);
+	}
+}
+
+
+void HTMLForm::write(std::ostream& ostr)
+{
+	if (_encoding == ENCODING_URL)
+		writeUrl(ostr);
+	else
+		writeMultipart(ostr);
+}
+
+
+void HTMLForm::readUrl(std::istream& istr)
+{
+	static const int eof = std::char_traits<char>::eof();
+
+	int fields = 0;
+	int ch = istr.get();
+	bool isFirst = true;
+	while (ch != eof)
+	{
+		if (_fieldLimit > 0 && fields == _fieldLimit)
+			throw HTMLFormException("Too many form fields");
+		std::string name;
+		std::string value;
+		while (ch != eof && ch != '=' && ch != '&')
+		{
+			if (ch == '+') ch = ' ';
+			if (name.size() < MAX_NAME_LENGTH)
+				name += (char) ch;
+			else
+				throw HTMLFormException("Field name too long");
+			ch = istr.get();
+		}
+		if (ch == '=')
+		{
+			ch = istr.get();
+			while (ch != eof && ch != '&')
+			{
+				if (ch == '+') ch = ' ';
+				if (value.size() < _valueLengthLimit)
+					value += (char) ch;
+				else
+					throw HTMLFormException("Field value too long");
+				ch = istr.get();
+			}
+		}
+		// remove UTF-8 byte order mark from first name, if present
+		if (isFirst)
+		{
+			UTF8::removeBOM(name);
+		}
+		std::string decodedName;
+		std::string decodedValue;
+		URI::decode(name, decodedName);
+		URI::decode(value, decodedValue);
+		add(decodedName, decodedValue);
+		++fields;
+		if (ch == '&') ch = istr.get();
+		isFirst = false;
+	}
+}
+
+
+void HTMLForm::readMultipart(std::istream& istr, PartHandler& handler)
+{
+	static const int eof = std::char_traits<char>::eof();
+
+	int fields = 0;
+	MultipartReader reader(istr, _boundary);
+	while (reader.hasNextPart())
+	{
+		if (_fieldLimit > 0 && fields == _fieldLimit)
+			throw HTMLFormException("Too many form fields");
+		MessageHeader header;
+		reader.nextPart(header);
+		std::string disp;
+		NameValueCollection params;
+		if (header.has("Content-Disposition"))
+		{
+			std::string cd = header.get("Content-Disposition");
+			MessageHeader::splitParameters(cd, disp, params);
+		}
+		if (params.has("filename"))
+		{
+			handler.handlePart(header, reader.stream());
+			// Ensure that the complete part has been read.
+			while (reader.stream().good()) reader.stream().get();
+		}
+		else
+		{
+			std::string name = params["name"];
+			std::string value;
+			std::istream& istr = reader.stream();
+			int ch = istr.get();
+			while (ch != eof)
+			{
+				if (value.size() < _valueLengthLimit)
+					value += (char) ch;
+				else
+					throw HTMLFormException("Field value too long");
+				ch = istr.get();
+			}
+			add(name, value);
+		}
+		++fields;
+	}
+}
+
+
+void HTMLForm::writeUrl(std::ostream& ostr)
+{
+	for (NameValueCollection::ConstIterator it = begin(); it != end(); ++it)
+	{
+		if (it != begin()) ostr << "&";
+		std::string name;
+		URI::encode(it->first, "!?#/'\",;:$&()[]*+=@", name);
+		std::string value;
+		URI::encode(it->second, "!?#/'\",;:$&()[]*+=@", value);
+		ostr << name << "=" << value;
+	}
+}
+
+
+void HTMLForm::writeMultipart(std::ostream& ostr)
+{
+	HTMLFormCountingOutputStream* pCountingOutputStream(dynamic_cast<HTMLFormCountingOutputStream*>(&ostr));
+
+	MultipartWriter writer(ostr, _boundary);
+	for (NameValueCollection::ConstIterator it = begin(); it != end(); ++it)
+	{
+		MessageHeader header;
+		std::string disp("form-data; name=\"");
+		disp.append(it->first);
+		disp.append("\"");
+		header.set("Content-Disposition", disp);
+		writer.nextPart(header);
+		ostr << it->second;
+	}
+	for (PartVec::iterator ita = _parts.begin(); ita != _parts.end(); ++ita)
+	{
+		MessageHeader header(ita->pSource->headers());
+		std::string disp("form-data; name=\"");
+		disp.append(ita->name);
+		disp.append("\"");
+		std::string filename = ita->pSource->filename();
+		if (!filename.empty())
+		{
+			disp.append("; filename=\"");
+			disp.append(filename);
+			disp.append("\"");
+		}
+		header.set("Content-Disposition", disp);
+		header.set("Content-Type", ita->pSource->mediaType());
+		writer.nextPart(header);
+		if (pCountingOutputStream)
+		{
+			// count only, don't move stream position
+			std::streamsize partlen = ita->pSource->getContentLength();
+			if (partlen != PartSource::UNKNOWN_CONTENT_LENGTH)
+				pCountingOutputStream->addChars(static_cast<int>(partlen));
+			else
+				pCountingOutputStream->setValid(false);
+		}
+		else
+		{
+			StreamCopier::copyStream(ita->pSource->stream(), ostr);
+		}
+	}
+	writer.close();
+	_boundary = writer.boundary();
+}
+
+
+void HTMLForm::setFieldLimit(int limit)
+{
+	poco_assert (limit >= 0);
+
+	_fieldLimit = limit;
+}
+
+
+void HTMLForm::setValueLengthLimit(int limit)
+{
+	poco_assert (limit >= 0);
+
+	_valueLengthLimit = limit;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPAuthenticationParams.cpp b/base/poco/Net/src/HTTPAuthenticationParams.cpp
new file mode 100644
index 00000000000..26adedf19e5
--- /dev/null
+++ b/base/poco/Net/src/HTTPAuthenticationParams.cpp
@@ -0,0 +1,316 @@
+//
+// HTTPAuthenticationParams.cpp
+//
+// Library: Net
+// Package: HTTP
+// Module:	HTTPAuthenticationParams
+//
+// Copyright (c) 2011, Anton V. Yabchinskiy (arn at bestmx dot ru).
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Exception.h"
+#include "Poco/Net/HTTPAuthenticationParams.h"
+#include "Poco/Net/HTTPRequest.h"
+#include "Poco/Net/HTTPResponse.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/String.h"
+#include "Poco/Ascii.h"
+
+
+using Poco::icompare;
+using Poco::Ascii;
+
+
+namespace
+{
+	bool mustBeQuoted(const std::string& name)
+	{
+		return
+			icompare(name, "cnonce") == 0 ||
+			icompare(name, "domain") == 0 ||
+			icompare(name, "nonce") == 0 ||
+			icompare(name, "opaque") == 0 ||
+			icompare(name, "qop") == 0 ||
+			icompare(name, "realm") == 0 ||
+			icompare(name, "response") == 0 ||
+			icompare(name, "uri") == 0 ||
+			icompare(name, "username") == 0;
+	}
+
+
+	void formatParameter(std::string& result, const std::string& name, const std::string& value)
+	{
+		result += name;
+		result += '=';
+		if (mustBeQuoted(name))
+		{
+			result += '"';
+			result += value;
+			result += '"';
+		}
+		else
+		{
+			result += value;
+		}
+	}
+}
+
+
+namespace Poco {
+namespace Net {
+
+
+const std::string HTTPAuthenticationParams::REALM("realm");
+const std::string HTTPAuthenticationParams::WWW_AUTHENTICATE("WWW-Authenticate");
+const std::string HTTPAuthenticationParams::PROXY_AUTHENTICATE("Proxy-Authenticate");
+
+
+HTTPAuthenticationParams::HTTPAuthenticationParams()
+{
+}
+
+
+HTTPAuthenticationParams::HTTPAuthenticationParams(const std::string& authInfo)
+{
+	fromAuthInfo(authInfo);
+}
+
+
+HTTPAuthenticationParams::HTTPAuthenticationParams(const HTTPRequest& request)
+{
+	fromRequest(request);
+}
+
+
+HTTPAuthenticationParams::HTTPAuthenticationParams(const HTTPResponse& response, const std::string& header)
+{
+	fromResponse(response, header);
+}
+
+
+HTTPAuthenticationParams::~HTTPAuthenticationParams()
+{
+}
+
+
+HTTPAuthenticationParams& HTTPAuthenticationParams::operator = (const HTTPAuthenticationParams& authParams)
+{
+	NameValueCollection::operator = (authParams);
+
+	return *this;
+}
+
+
+void HTTPAuthenticationParams::fromAuthInfo(const std::string& authInfo)
+{
+	parse(authInfo.begin(), authInfo.end());
+}
+
+
+void HTTPAuthenticationParams::fromRequest(const HTTPRequest& request)
+{
+	std::string scheme;
+	std::string authInfo;
+
+	request.getCredentials(scheme, authInfo);
+
+	if (icompare(scheme, "Digest") != 0)
+		throw InvalidArgumentException("Could not parse non-Digest authentication information", scheme);
+
+	fromAuthInfo(authInfo);
+}
+
+
+void HTTPAuthenticationParams::fromResponse(const HTTPResponse& response, const std::string& header)
+{
+	NameValueCollection::ConstIterator it = response.find(header);
+	if (it == response.end())
+		throw NotAuthenticatedException("HTTP response has no authentication header");
+
+	bool found = false;
+	while (!found && it != response.end() && icompare(it->first, header) == 0)
+	{
+		const std::string& header = it->second;
+		if (icompare(header, 0, 6, "Basic ") == 0)
+		{
+			parse(header.begin() + 6, header.end());
+			found = true;
+		}
+		else if (icompare(header, 0, 7, "Digest ") == 0)
+		{
+			parse(header.begin() + 7, header.end());
+			found = true;
+		}
+		++it;
+	}
+	if (!found) throw NotAuthenticatedException("No Basic or Digest authentication header found");
+}
+
+
+const std::string& HTTPAuthenticationParams::getRealm() const
+{
+	return get(REALM);
+}
+
+
+void HTTPAuthenticationParams::setRealm(const std::string& realm)
+{
+	set(REALM, realm);
+}
+
+
+std::string HTTPAuthenticationParams::toString() const
+{
+	ConstIterator iter = begin();
+	std::string result;
+
+	if (iter != end())
+	{
+		formatParameter(result, iter->first, iter->second);
+		++iter;
+	}
+
+	for (; iter != end(); ++iter)
+	{
+		result.append(", ");
+		formatParameter(result, iter->first, iter->second);
+	}
+
+	return result;
+}
+
+
+void HTTPAuthenticationParams::parse(std::string::const_iterator first, std::string::const_iterator last)
+{
+	enum State
+	{
+		STATE_INITIAL = 0x0100,
+		STATE_FINAL = 0x0200,
+
+		STATE_SPACE = STATE_INITIAL | 0,
+		STATE_TOKEN = 1,
+		STATE_EQUALS = 2,
+		STATE_VALUE = STATE_FINAL | 3,
+		STATE_VALUE_QUOTED = 4,
+		STATE_VALUE_ESCAPE = 5,
+		STATE_COMMA = STATE_FINAL | 6
+	};
+
+	int state = STATE_SPACE;
+	std::string token;
+	std::string value;
+
+	for (std::string::const_iterator it = first; it != last; ++it)
+	{
+		switch (state)
+		{
+		case STATE_SPACE:
+			if (Ascii::isAlphaNumeric(*it) || *it == '_' || *it == '-')
+			{
+				token += *it;
+				state = STATE_TOKEN;
+			}
+			else if (Ascii::isSpace(*it))
+			{
+				// Skip
+			}
+			else throw SyntaxException("Invalid authentication information");
+			break;
+
+		case STATE_TOKEN:
+			if (*it == '=')
+			{
+				state = STATE_EQUALS;
+			}
+			else if (Ascii::isAlphaNumeric(*it) || *it == '_' || *it == '-')
+			{
+				token += *it;
+			}
+			else throw SyntaxException("Invalid authentication information");
+			break;
+
+		case STATE_EQUALS:
+			if (Ascii::isAlphaNumeric(*it) || *it == '_')
+			{
+				value += *it;
+				state = STATE_VALUE;
+			}
+			else if (*it == '"')
+			{
+				state = STATE_VALUE_QUOTED;
+			}
+			else throw SyntaxException("Invalid authentication information");
+			break;
+
+		case STATE_VALUE_QUOTED:
+			if (*it == '\\')
+			{
+				state = STATE_VALUE_ESCAPE;
+			}
+			else if (*it == '"')
+			{
+				add(token, value);
+				token.clear();
+				value.clear();
+				state = STATE_COMMA;
+			}
+			else
+			{
+				value += *it;
+			}
+			break;
+
+		case STATE_VALUE_ESCAPE:
+			value += *it;
+			state = STATE_VALUE_QUOTED;
+			break;
+
+		case STATE_VALUE:
+			if (Ascii::isSpace(*it))
+			{
+				add(token, value);
+				token.clear();
+				value.clear();
+				state = STATE_COMMA;
+			}
+			else if (*it == ',')
+			{
+				add(token, value);
+				token.clear();
+				value.clear();
+				state = STATE_SPACE;
+			}
+			else
+			{
+				value += *it;
+			}
+			break;
+
+		case STATE_COMMA:
+			if (*it == ',')
+			{
+				state = STATE_SPACE;
+			}
+			else if (Ascii::isSpace(*it))
+			{
+				// Skip
+			}
+			else throw SyntaxException("Invalid authentication information");
+			break;
+		}
+	}
+
+	if (state == STATE_VALUE)
+		add(token, value);
+
+	if (!(state & STATE_FINAL))
+		throw SyntaxException("Invalid authentication information");
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPBasicCredentials.cpp b/base/poco/Net/src/HTTPBasicCredentials.cpp
new file mode 100644
index 00000000000..5b5e89897e7
--- /dev/null
+++ b/base/poco/Net/src/HTTPBasicCredentials.cpp
@@ -0,0 +1,134 @@
+//
+// HTTPBasicCredentials.cpp
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPBasicCredentials
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPBasicCredentials.h"
+#include "Poco/Net/HTTPRequest.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Base64Encoder.h"
+#include "Poco/Base64Decoder.h"
+#include "Poco/String.h"
+#include <sstream>
+
+
+using Poco::Base64Decoder;
+using Poco::Base64Encoder;
+using Poco::icompare;
+
+
+namespace Poco {
+namespace Net {
+
+
+const std::string HTTPBasicCredentials::SCHEME = "Basic";
+
+
+HTTPBasicCredentials::HTTPBasicCredentials()
+{
+}
+
+
+HTTPBasicCredentials::HTTPBasicCredentials(const std::string& username, const std::string& password):
+	_username(username),
+	_password(password)
+{
+}
+
+
+HTTPBasicCredentials::HTTPBasicCredentials(const HTTPRequest& request)
+{
+	std::string scheme;
+	std::string authInfo;
+	request.getCredentials(scheme, authInfo);
+	if (icompare(scheme, SCHEME) == 0)
+	{
+		parseAuthInfo(authInfo);
+	}
+	else throw NotAuthenticatedException("Basic authentication expected");
+}
+
+
+HTTPBasicCredentials::HTTPBasicCredentials(const std::string& authInfo)
+{
+	parseAuthInfo(authInfo);
+}
+
+
+HTTPBasicCredentials::~HTTPBasicCredentials()
+{
+}
+
+
+void HTTPBasicCredentials::clear()
+{
+	_username.clear();
+	_password.clear();
+}
+
+
+void HTTPBasicCredentials::setUsername(const std::string& username)
+{
+	_username = username;
+}
+
+
+void HTTPBasicCredentials::setPassword(const std::string& password)
+{
+	_password = password;
+}
+
+
+void HTTPBasicCredentials::authenticate(HTTPRequest& request) const
+{
+	std::ostringstream ostr;
+	Base64Encoder encoder(ostr);
+	encoder.rdbuf()->setLineLength(0);
+	encoder << _username << ":" << _password;
+	encoder.close();
+	request.setCredentials(SCHEME, ostr.str());
+}
+
+
+void HTTPBasicCredentials::proxyAuthenticate(HTTPRequest& request) const
+{
+	std::ostringstream ostr;
+	Base64Encoder encoder(ostr);
+	encoder.rdbuf()->setLineLength(0);
+	encoder << _username << ":" << _password;
+	encoder.close();
+	request.setProxyCredentials(SCHEME, ostr.str());
+}
+
+
+void HTTPBasicCredentials::parseAuthInfo(const std::string& authInfo)
+{
+	static const int eof = std::char_traits<char>::eof();
+
+	std::istringstream istr(authInfo);
+	Base64Decoder decoder(istr);
+	int ch = decoder.get();
+	while (ch != eof && ch != ':')
+	{
+		_username += (char) ch;
+		ch = decoder.get();
+	}
+	if (ch == ':') ch = decoder.get();
+	while (ch != eof)
+	{
+		_password += (char) ch;
+		ch = decoder.get();
+	}
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPBufferAllocator.cpp b/base/poco/Net/src/HTTPBufferAllocator.cpp
new file mode 100644
index 00000000000..2944e2a6121
--- /dev/null
+++ b/base/poco/Net/src/HTTPBufferAllocator.cpp
@@ -0,0 +1,44 @@
+//
+// HTTPBufferAllocator.cpp
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPBufferAllocator
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPBufferAllocator.h"
+
+
+using Poco::MemoryPool;
+
+
+namespace Poco {
+namespace Net {
+
+
+MemoryPool HTTPBufferAllocator::_pool(HTTPBufferAllocator::BUFFER_SIZE, 16);
+
+
+char* HTTPBufferAllocator::allocate(std::streamsize size)
+{
+	poco_assert_dbg (size == BUFFER_SIZE);
+
+	return reinterpret_cast<char*>(_pool.get());
+}
+
+
+void HTTPBufferAllocator::deallocate(char* ptr, std::streamsize size)
+{
+	poco_assert_dbg (size == BUFFER_SIZE);
+
+	_pool.release(ptr);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPChunkedStream.cpp b/base/poco/Net/src/HTTPChunkedStream.cpp
new file mode 100644
index 00000000000..f2f79da590b
--- /dev/null
+++ b/base/poco/Net/src/HTTPChunkedStream.cpp
@@ -0,0 +1,258 @@
+//
+// HTTPChunkedStream.cpp
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPChunkedStream
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPChunkedStream.h"
+#include "Poco/Net/HTTPSession.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/NumberParser.h"
+#include "Poco/Ascii.h"
+
+
+using Poco::NumberFormatter;
+using Poco::NumberParser;
+
+
+namespace Poco {
+namespace Net {
+
+
+//
+// HTTPChunkedStreamBuf
+//
+
+
+HTTPChunkedStreamBuf::HTTPChunkedStreamBuf(HTTPSession& session, openmode mode):
+	HTTPBasicStreamBuf(HTTPBufferAllocator::BUFFER_SIZE, mode),
+	_session(session),
+	_mode(mode),
+	_chunk(0)
+{
+}
+
+
+HTTPChunkedStreamBuf::~HTTPChunkedStreamBuf()
+{
+}
+
+
+void HTTPChunkedStreamBuf::close()
+{
+	if (_mode & std::ios::out)
+	{
+		sync();
+		_session.write("0\r\n\r\n", 5);
+	}
+}
+
+static inline int assertNonEOF(int c)
+{
+	if (c == std::char_traits<char>::eof())
+		throw MessageException("Unexpected EOF");
+    return c;
+}
+
+static inline bool isCRLF(char c1, char c2)
+{
+	return c1 == '\r' && c2 == '\n';
+}
+
+unsigned int HTTPChunkedStreamBuf::parseChunkLen()
+{
+	const size_t maxLineLength = 4096;
+	std::string line;
+	while (line.size() < maxLineLength)
+	{
+		int c = assertNonEOF(_session.get());
+		line += static_cast<char>(c);
+		if (c == '\n') break;
+	}
+
+	const size_t n = line.size();
+	if (n >= 2 && isCRLF(line[n-2], line[n-1]))
+		line.resize(n-2);
+	else
+		throw MessageException("Malformed chunked encoding");
+
+	if (size_t pos = line.find(';'); pos != std::string::npos)
+		line.resize(pos);
+
+	unsigned chunkLen;
+	if (NumberParser::tryParseHex(line, chunkLen))
+		return chunkLen;
+	else
+		throw MessageException("Invalid chunk length");
+}
+
+void HTTPChunkedStreamBuf::skipCRLF()
+{
+	int c1 = assertNonEOF(_session.get());
+	int c2 = assertNonEOF(_session.get());
+	if (!isCRLF(c1, c2))
+		throw MessageException("Malformed chunked encoding");
+}
+
+int HTTPChunkedStreamBuf::readFromDevice(char* buffer, std::streamsize length)
+{
+	static const int eof = std::char_traits<char>::eof();
+	if (_chunk == eof)
+		return 0;
+
+	if (_chunk == 0)
+	{
+		_chunk = parseChunkLen();
+	}
+
+	if (_chunk > 0)
+	{
+		if (length > _chunk) length = _chunk;
+		int n = _session.read(buffer, length);
+		if (n > 0)
+			_chunk -= n;
+		else
+			throw MessageException("Unexpected EOF");
+
+		if (_chunk == 0) skipCRLF();
+		return n;
+	}
+	else 
+	{
+		skipCRLF();
+		_chunk = eof;
+		return 0;
+	}
+}
+
+
+int HTTPChunkedStreamBuf::writeToDevice(const char* buffer, std::streamsize length)
+{
+	_chunkBuffer.clear();
+	NumberFormatter::appendHex(_chunkBuffer, length);
+	_chunkBuffer.append("\r\n", 2);
+	_chunkBuffer.append(buffer, static_cast<std::string::size_type>(length));
+	_chunkBuffer.append("\r\n", 2);
+	_session.write(_chunkBuffer.data(), static_cast<std::streamsize>(_chunkBuffer.size()));
+	return static_cast<int>(length);
+}
+
+
+//
+// HTTPChunkedIOS
+//
+
+
+HTTPChunkedIOS::HTTPChunkedIOS(HTTPSession& session, HTTPChunkedStreamBuf::openmode mode):
+	_buf(session, mode)
+{
+	poco_ios_init(&_buf);
+}
+
+
+HTTPChunkedIOS::~HTTPChunkedIOS()
+{
+	try
+	{
+		_buf.close();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+HTTPChunkedStreamBuf* HTTPChunkedIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+//
+// HTTPChunkedInputStream
+//
+
+
+Poco::MemoryPool HTTPChunkedInputStream::_pool(sizeof(HTTPChunkedInputStream));
+
+
+HTTPChunkedInputStream::HTTPChunkedInputStream(HTTPSession& session):
+	HTTPChunkedIOS(session, std::ios::in),
+	std::istream(&_buf)
+{
+}
+
+
+HTTPChunkedInputStream::~HTTPChunkedInputStream()
+{
+}
+
+
+void* HTTPChunkedInputStream::operator new(std::size_t size)
+{
+	return _pool.get();
+}
+
+
+void HTTPChunkedInputStream::operator delete(void* ptr)
+{
+	try
+	{
+		_pool.release(ptr);
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+//
+// HTTPChunkedOutputStream
+//
+
+
+Poco::MemoryPool HTTPChunkedOutputStream::_pool(sizeof(HTTPChunkedOutputStream));
+
+
+HTTPChunkedOutputStream::HTTPChunkedOutputStream(HTTPSession& session):
+	HTTPChunkedIOS(session, std::ios::out),
+	std::ostream(&_buf)
+{
+}
+
+
+HTTPChunkedOutputStream::~HTTPChunkedOutputStream()
+{
+}
+
+
+void* HTTPChunkedOutputStream::operator new(std::size_t size)
+{
+	return _pool.get();
+}
+
+
+void HTTPChunkedOutputStream::operator delete(void* ptr)
+{
+	try
+	{
+		_pool.release(ptr);
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPClientSession.cpp b/base/poco/Net/src/HTTPClientSession.cpp
new file mode 100644
index 00000000000..323e9526df5
--- /dev/null
+++ b/base/poco/Net/src/HTTPClientSession.cpp
@@ -0,0 +1,514 @@
+//
+// HTTPClientSession.cpp
+//
+// Library: Net
+// Package: HTTPClient
+// Module:  HTTPClientSession
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPClientSession.h"
+#include "Poco/Net/HTTPSessionInstantiator.h"
+#include "Poco/Net/HTTPRequest.h"
+#include "Poco/Net/HTTPResponse.h"
+#include "Poco/Net/HTTPHeaderStream.h"
+#include "Poco/Net/HTTPStream.h"
+#include "Poco/Net/HTTPFixedLengthStream.h"
+#include "Poco/Net/HTTPChunkedStream.h"
+#include "Poco/Net/HTTPBasicCredentials.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/CountingStream.h"
+#include "Poco/RegularExpression.h"
+#include <sstream>
+#include <iostream>
+
+
+using Poco::NumberFormatter;
+using Poco::IllegalStateException;
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPClientSession::ProxyConfig HTTPClientSession::_globalProxyConfig;
+
+
+HTTPClientSession::HTTPClientSession():
+	_port(HTTPSession::HTTP_PORT),
+	_proxyConfig(_globalProxyConfig),
+	_keepAliveTimeout(DEFAULT_KEEP_ALIVE_TIMEOUT, 0),
+	_reconnect(false),
+	_mustReconnect(false),
+	_expectResponseBody(false),
+	_responseReceived(false)
+{
+	_proxySessionFactory.registerProtocol("http", new HTTPSessionInstantiator);
+}
+
+
+HTTPClientSession::HTTPClientSession(const StreamSocket& socket):
+	HTTPSession(socket),
+	_port(HTTPSession::HTTP_PORT),
+	_proxyConfig(_globalProxyConfig),
+	_keepAliveTimeout(DEFAULT_KEEP_ALIVE_TIMEOUT, 0),
+	_reconnect(false),
+	_mustReconnect(false),
+	_expectResponseBody(false),
+	_responseReceived(false)
+{
+	_proxySessionFactory.registerProtocol("http", new HTTPSessionInstantiator);
+}
+
+
+HTTPClientSession::HTTPClientSession(const SocketAddress& address):
+	_host(address.host().toString()),
+	_port(address.port()),
+	_proxyConfig(_globalProxyConfig),
+	_keepAliveTimeout(DEFAULT_KEEP_ALIVE_TIMEOUT, 0),
+	_reconnect(false),
+	_mustReconnect(false),
+	_expectResponseBody(false),
+	_responseReceived(false)
+{
+	_proxySessionFactory.registerProtocol("http", new HTTPSessionInstantiator);
+}
+
+
+HTTPClientSession::HTTPClientSession(const std::string& host, Poco::UInt16 port):
+	_host(host),
+	_port(port),
+	_proxyConfig(_globalProxyConfig),
+	_keepAliveTimeout(DEFAULT_KEEP_ALIVE_TIMEOUT, 0),
+	_reconnect(false),
+	_mustReconnect(false),
+	_expectResponseBody(false),
+	_responseReceived(false)
+{
+	_proxySessionFactory.registerProtocol("http", new HTTPSessionInstantiator);
+}
+
+
+HTTPClientSession::HTTPClientSession(const std::string& host, Poco::UInt16 port, const ProxyConfig& proxyConfig):
+	_host(host),
+	_port(port),
+	_proxyConfig(proxyConfig),
+	_keepAliveTimeout(DEFAULT_KEEP_ALIVE_TIMEOUT, 0),
+	_reconnect(false),
+	_mustReconnect(false),
+	_expectResponseBody(false),
+	_responseReceived(false)
+{
+	_proxySessionFactory.registerProtocol("http", new HTTPSessionInstantiator);
+}
+
+
+HTTPClientSession::~HTTPClientSession()
+{
+	_proxySessionFactory.unregisterProtocol("http");
+}
+
+
+void HTTPClientSession::setHost(const std::string& host)
+{
+	if (!connected())
+		_host = host;
+	else
+		throw IllegalStateException("Cannot set the host for an already connected session");
+}
+
+
+void HTTPClientSession::setPort(Poco::UInt16 port)
+{
+	if (!connected())
+		_port = port;
+	else
+		throw IllegalStateException("Cannot set the port number for an already connected session");
+}
+
+
+void HTTPClientSession::setProxy(const std::string& host, Poco::UInt16 port, const std::string& protocol, bool tunnel)
+{
+	if (protocol != "http" && protocol != "https")
+		throw IllegalStateException("Protocol must be either http or https");
+
+	if (!connected())
+	{
+		_proxyConfig.host = host;
+		_proxyConfig.port = port;
+		_proxyConfig.protocol = protocol;
+		_proxyConfig.tunnel = tunnel;
+	}
+	else throw IllegalStateException("Cannot set the proxy host, port and protocol for an already connected session");
+}
+
+
+void HTTPClientSession::setProxyHost(const std::string& host)
+{
+	if (!connected())
+		_proxyConfig.host = host;
+	else
+		throw IllegalStateException("Cannot set the proxy host for an already connected session");
+}
+
+
+void HTTPClientSession::setProxyPort(Poco::UInt16 port)
+{
+	if (!connected())
+		_proxyConfig.port = port;
+	else
+		throw IllegalStateException("Cannot set the proxy port number for an already connected session");
+}
+
+
+void HTTPClientSession::setProxyProtocol(const std::string& protocol)
+{
+	if (protocol != "http" && protocol != "https")
+		throw IllegalStateException("Protocol must be either http or https");
+
+	if (!connected())
+		_proxyConfig.protocol = protocol;
+	else
+		throw IllegalStateException("Cannot set the proxy port number for an already connected session");
+}
+
+
+void HTTPClientSession::setProxyTunnel(bool tunnel)
+{
+	if (!connected())
+		_proxyConfig.tunnel = tunnel;
+	else
+		throw IllegalStateException("Cannot set the proxy tunnel for an already connected session");
+}
+
+
+void HTTPClientSession::setProxyCredentials(const std::string& username, const std::string& password)
+{
+	_proxyConfig.username = username;
+	_proxyConfig.password = password;
+}
+
+
+void HTTPClientSession::setProxyUsername(const std::string& username)
+{
+	_proxyConfig.username = username;
+}
+
+
+void HTTPClientSession::setProxyPassword(const std::string& password)
+{
+	_proxyConfig.password = password;
+}
+
+
+void HTTPClientSession::setProxyConfig(const ProxyConfig& config)
+{
+	_proxyConfig = config;
+}
+
+
+void HTTPClientSession::setGlobalProxyConfig(const ProxyConfig& config)
+{
+	_globalProxyConfig = config;
+}
+
+
+void HTTPClientSession::setKeepAliveTimeout(const Poco::Timespan& timeout)
+{
+	_keepAliveTimeout = timeout;
+}
+
+
+std::ostream& HTTPClientSession::sendRequest(HTTPRequest& request)
+{
+	_pRequestStream = 0;
+	_pResponseStream = 0;
+	clearException();
+	_responseReceived = false;
+
+	bool keepAlive = getKeepAlive();
+	if (((connected() && !keepAlive) || mustReconnect()) && !_host.empty())
+	{
+		close();
+		_mustReconnect = false;
+	}
+	try
+	{
+		if (!connected())
+			reconnect();
+		if (!keepAlive)
+			request.setKeepAlive(false);
+		if (!request.has(HTTPRequest::HOST) && !_host.empty())
+			request.setHost(_host, _port);
+		if (!_proxyConfig.host.empty() && !bypassProxy())
+		{
+			request.setURI(proxyRequestPrefix() + request.getURI());
+			proxyAuthenticate(request);
+		}
+		_reconnect = keepAlive;
+		_expectResponseBody = request.getMethod() != HTTPRequest::HTTP_HEAD;
+		const std::string& method = request.getMethod();
+		if (request.getChunkedTransferEncoding())
+		{
+			HTTPHeaderOutputStream hos(*this);
+			request.write(hos);
+			_pRequestStream = new HTTPChunkedOutputStream(*this);
+		}
+		else if (request.hasContentLength())
+		{
+			Poco::CountingOutputStream cs;
+			request.write(cs);
+#if POCO_HAVE_INT64
+			_pRequestStream = new HTTPFixedLengthOutputStream(*this, request.getContentLength64() + cs.chars());
+#else
+			_pRequestStream = new HTTPFixedLengthOutputStream(*this, request.getContentLength() + cs.chars());
+#endif
+			request.write(*_pRequestStream);
+		}
+		else if ((method != HTTPRequest::HTTP_PUT && method != HTTPRequest::HTTP_POST && method != HTTPRequest::HTTP_PATCH) || request.has(HTTPRequest::UPGRADE))
+		{
+			Poco::CountingOutputStream cs;
+			request.write(cs);
+			_pRequestStream = new HTTPFixedLengthOutputStream(*this, cs.chars());
+			request.write(*_pRequestStream);
+		}
+		else
+		{
+			_pRequestStream = new HTTPOutputStream(*this);
+			request.write(*_pRequestStream);
+		}
+		_lastRequest.update();
+		return *_pRequestStream;
+	}
+	catch (Exception&)
+	{
+		close();
+		throw;
+	}
+}
+
+
+void HTTPClientSession::flushRequest()
+{
+	_pRequestStream = 0;
+	if (networkException()) networkException()->rethrow();
+}
+
+
+std::istream& HTTPClientSession::receiveResponse(HTTPResponse& response)
+{
+	flushRequest();
+	if (!_responseReceived)
+	{
+		do
+		{
+			response.clear();
+			HTTPHeaderInputStream his(*this);
+			try
+			{
+				response.read(his);
+			}
+			catch (Exception&)
+			{
+				close();
+				if (networkException())
+					networkException()->rethrow();
+				else
+					throw;
+				throw;
+			}
+		}
+		while (response.getStatus() == HTTPResponse::HTTP_CONTINUE);
+	}
+
+	_mustReconnect = getKeepAlive() && !response.getKeepAlive();
+
+	if (!_expectResponseBody || response.getStatus() < 200 || response.getStatus() == HTTPResponse::HTTP_NO_CONTENT || response.getStatus() == HTTPResponse::HTTP_NOT_MODIFIED)
+		_pResponseStream = new HTTPFixedLengthInputStream(*this, 0);
+	else if (response.getChunkedTransferEncoding())
+		_pResponseStream = new HTTPChunkedInputStream(*this);
+	else if (response.hasContentLength())
+#if defined(POCO_HAVE_INT64)
+		_pResponseStream = new HTTPFixedLengthInputStream(*this, response.getContentLength64());
+#else
+		_pResponseStream = new HTTPFixedLengthInputStream(*this, response.getContentLength());
+#endif
+	else
+		_pResponseStream = new HTTPInputStream(*this);
+
+	return *_pResponseStream;
+}
+
+
+bool HTTPClientSession::peekResponse(HTTPResponse& response)
+{
+	poco_assert (!_responseReceived);
+
+	_pRequestStream->flush();
+
+	if (networkException()) networkException()->rethrow();
+
+	response.clear();
+	HTTPHeaderInputStream his(*this);
+	try
+	{
+		response.read(his);
+	}
+	catch (Exception&)
+	{
+		close();
+		if (networkException())
+			networkException()->rethrow();
+		else
+			throw;
+		throw;
+	}
+	_responseReceived = response.getStatus() != HTTPResponse::HTTP_CONTINUE;
+	return !_responseReceived;
+}
+
+
+void HTTPClientSession::reset()
+{
+	close();
+}
+
+
+bool HTTPClientSession::secure() const
+{
+	return false;
+}
+
+
+int HTTPClientSession::write(const char* buffer, std::streamsize length)
+{
+	try
+	{
+		int rc = HTTPSession::write(buffer, length);
+		_reconnect = false;
+		return rc;
+	}
+	catch (Poco::Exception&)
+	{
+		if (_reconnect)
+		{
+			close();
+			reconnect();
+			int rc = HTTPSession::write(buffer, length);
+			clearException();
+			_reconnect = false;
+			return rc;
+		}
+		else throw;
+	}
+}
+
+
+void HTTPClientSession::reconnect()
+{
+	if (_proxyConfig.host.empty() || bypassProxy())
+	{
+		SocketAddress addr(_resolved_host.empty() ? _host : _resolved_host, _port);
+		connect(addr);
+	}
+	else
+	{
+		SocketAddress addr(_proxyConfig.host, _proxyConfig.port);
+		connect(addr);
+	}
+}
+
+
+std::string HTTPClientSession::proxyRequestPrefix() const
+{
+	std::string result("http://");
+	result.append(_host);
+	/// Do not append default by default, since this may break some servers.
+	/// One example of such server is GCS (Google Cloud Storage).
+	if (_port != HTTPSession::HTTP_PORT)
+	{
+		result.append(":");
+		NumberFormatter::append(result, _port);
+	}
+	return result;
+}
+
+
+bool HTTPClientSession::mustReconnect() const
+{
+	if (!_mustReconnect)
+	{
+		Poco::Timestamp now;
+		return _keepAliveTimeout <= now - _lastRequest;
+	}
+	else return true;
+}
+
+
+void HTTPClientSession::proxyAuthenticate(HTTPRequest& request)
+{
+	proxyAuthenticateImpl(request);
+}
+
+
+void HTTPClientSession::proxyAuthenticateImpl(HTTPRequest& request)
+{
+	if (!_proxyConfig.username.empty())
+	{
+		HTTPBasicCredentials creds(_proxyConfig.username, _proxyConfig.password);
+		creds.proxyAuthenticate(request);
+	}
+}
+
+
+StreamSocket HTTPClientSession::proxyConnect()
+{
+	URI proxyUri;
+	proxyUri.setScheme(getProxyProtocol());
+	proxyUri.setHost(getProxyHost());
+	proxyUri.setPort(getProxyPort());
+
+	SharedPtr<HTTPClientSession> proxySession (_proxySessionFactory.createClientSession(proxyUri));
+
+	proxySession->setTimeout(getTimeout());
+	std::string targetAddress(_host);
+	targetAddress.append(":");
+	NumberFormatter::append(targetAddress, _port);
+	HTTPRequest proxyRequest(HTTPRequest::HTTP_CONNECT, targetAddress, HTTPMessage::HTTP_1_1);
+	HTTPResponse proxyResponse;
+	proxyRequest.set("Proxy-Connection", "keep-alive");
+	proxyRequest.set("Host", targetAddress);
+	proxyAuthenticateImpl(proxyRequest);
+	proxySession->setKeepAlive(true);
+	proxySession->sendRequest(proxyRequest);
+	proxySession->receiveResponse(proxyResponse);
+	if (proxyResponse.getStatus() != HTTPResponse::HTTP_OK)
+		throw HTTPException("Cannot establish proxy connection", proxyResponse.getReason());
+	return proxySession->detachSocket();
+}
+
+
+void HTTPClientSession::proxyTunnel()
+{
+	StreamSocket ss = proxyConnect();
+	attachSocket(ss);
+}
+
+
+bool HTTPClientSession::bypassProxy() const
+{
+	if (!_proxyConfig.nonProxyHosts.empty())
+	{
+		return RegularExpression::match(_host, _proxyConfig.nonProxyHosts, RegularExpression::RE_CASELESS | RegularExpression::RE_ANCHORED);
+	}
+	else return false;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPCookie.cpp b/base/poco/Net/src/HTTPCookie.cpp
new file mode 100644
index 00000000000..9cbae4ad8a0
--- /dev/null
+++ b/base/poco/Net/src/HTTPCookie.cpp
@@ -0,0 +1,343 @@
+//
+// HTTPCookie.cpp
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPCookie
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPCookie.h"
+#include "Poco/Net/NameValueCollection.h"
+#include "Poco/Timestamp.h"
+#include "Poco/DateTime.h"
+#include "Poco/DateTimeFormatter.h"
+#include "Poco/DateTimeFormat.h"
+#include "Poco/DateTimeParser.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/NumberParser.h"
+#include "Poco/String.h"
+#include "Poco/URI.h"
+
+
+using Poco::Timestamp;
+using Poco::DateTime;
+using Poco::DateTimeFormatter;
+using Poco::DateTimeFormat;
+using Poco::DateTimeParser;
+using Poco::NumberFormatter;
+using Poco::NumberParser;
+using Poco::icompare;
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPCookie::HTTPCookie():
+	_version(0),
+	_secure(false),
+	_maxAge(-1),
+	_httpOnly(false)
+{
+}
+
+	
+HTTPCookie::HTTPCookie(const std::string& name):
+	_version(0),
+	_name(name),
+	_secure(false),
+	_maxAge(-1),
+	_httpOnly(false)
+{
+}
+
+
+HTTPCookie::HTTPCookie(const NameValueCollection& nvc):
+	_version(0),
+	_secure(false),
+	_maxAge(-1),
+	_httpOnly(false)
+{
+	for (NameValueCollection::ConstIterator it = nvc.begin(); it != nvc.end(); ++it)
+	{
+		const std::string& name  = it->first;
+		const std::string& value = it->second;
+		if (icompare(name, "comment") == 0)
+		{
+			setComment(value);
+		}
+		else if (icompare(name, "domain") == 0)
+		{
+			setDomain(value);
+		}
+		else if (icompare(name, "path") == 0)
+		{
+			setPath(value);
+		}
+		else if (icompare(name, "priority") == 0)
+		{
+			setPriority(value);
+		}
+		else if (icompare(name, "max-age") == 0)
+		{
+			setMaxAge(NumberParser::parse(value));
+		}
+		else if (icompare(name, "secure") == 0)
+		{
+			setSecure(true);
+		}
+		else if (icompare(name, "expires") == 0)
+		{
+			int tzd;
+			DateTime exp = DateTimeParser::parse(value, tzd);
+			Timestamp now;
+			setMaxAge((int) ((exp.timestamp() - now) / Timestamp::resolution()));
+		}
+		else if (icompare(name, "version") == 0)
+		{
+			setVersion(NumberParser::parse(value));
+		}
+		else if (icompare(name, "HttpOnly") == 0)
+		{
+			setHttpOnly(true);
+		}
+		else
+		{
+			setName(name);
+			setValue(value);
+		}
+	}
+}
+
+	
+HTTPCookie::HTTPCookie(const std::string& name, const std::string& value):
+	_version(0),
+	_name(name),
+	_value(value),
+	_secure(false),
+	_maxAge(-1),
+	_httpOnly(false)
+{
+}
+
+	
+HTTPCookie::HTTPCookie(const HTTPCookie& cookie):
+	_version(cookie._version),
+	_name(cookie._name),
+	_value(cookie._value),
+	_comment(cookie._comment),
+	_domain(cookie._domain),
+	_path(cookie._path),
+	_priority(cookie._priority),
+	_secure(cookie._secure),
+	_maxAge(cookie._maxAge),
+	_httpOnly(cookie._httpOnly)
+{
+}
+
+
+HTTPCookie::~HTTPCookie()
+{
+}
+
+	
+HTTPCookie& HTTPCookie::operator = (const HTTPCookie& cookie)
+{
+	if (&cookie != this)
+	{
+		_version  = cookie._version;
+		_name     = cookie._name;
+		_value    = cookie._value;
+		_comment  = cookie._comment;
+		_domain   = cookie._domain;
+		_path     = cookie._path;
+		_priority = cookie._priority;
+		_secure   = cookie._secure;
+		_maxAge   = cookie._maxAge;
+		_httpOnly = cookie._httpOnly;
+	}
+	return *this;
+}
+
+	
+void HTTPCookie::setVersion(int version)
+{
+	_version = version;
+}
+
+	
+void HTTPCookie::setName(const std::string& name)
+{
+	_name = name;
+}
+
+	
+void HTTPCookie::setValue(const std::string& value)
+{
+	_value = value;
+}
+
+	
+void HTTPCookie::setComment(const std::string& comment)
+{
+	_comment = comment;
+}
+
+
+void HTTPCookie::setDomain(const std::string& domain)
+{
+	_domain = domain;
+}
+
+
+void HTTPCookie::setPath(const std::string& path)
+{
+	_path = path;
+}
+
+
+void HTTPCookie::setPriority(const std::string& priority)
+{
+	_priority = priority;
+}
+
+
+void HTTPCookie::setSecure(bool secure)
+{
+	_secure = secure;
+}
+
+
+void HTTPCookie::setMaxAge(int maxAge) 
+{
+	_maxAge = maxAge;
+}
+
+
+void HTTPCookie::setHttpOnly(bool flag)
+{
+	_httpOnly = flag;
+}
+
+
+std::string HTTPCookie::toString() const
+{
+	std::string result;
+	result.reserve(256);
+	result.append(_name);
+	result.append("=");
+	if (_version == 0)
+	{
+		// Netscape cookie
+		result.append(_value);
+		if (!_domain.empty())
+		{
+			result.append("; domain=");
+			result.append(_domain);
+		}
+		if (!_path.empty())
+		{
+			result.append("; path=");
+			result.append(_path);
+		}
+		if (!_priority.empty())
+		{
+			result.append("; Priority=");
+			result.append(_priority);
+		}
+		if (_maxAge != -1)
+		{
+			Timestamp ts;
+			ts += _maxAge * Timestamp::resolution();
+			result.append("; expires=");
+			DateTimeFormatter::append(result, ts, DateTimeFormat::HTTP_FORMAT);
+		}
+		if (_secure)
+		{
+			result.append("; secure");
+		}
+		if (_httpOnly)
+		{
+			result.append("; HttpOnly");
+		}
+	}
+	else
+	{
+		// RFC 2109 cookie
+		result.append("\"");
+		result.append(_value);
+		result.append("\"");
+		if (!_comment.empty())
+		{
+			result.append("; Comment=\"");
+			result.append(_comment);
+			result.append("\"");
+		}
+		if (!_domain.empty())
+		{
+			result.append("; Domain=\"");
+			result.append(_domain);
+			result.append("\"");
+		}
+		if (!_path.empty())
+		{
+			result.append("; Path=\"");
+			result.append(_path);
+			result.append("\"");
+		}
+		if (!_priority.empty())
+		{
+			result.append("; Priority=\"");
+			result.append(_priority);
+			result.append("\"");
+		}
+
+		if (_maxAge != -1)
+		{
+			result.append("; Max-Age=\"");
+			NumberFormatter::append(result, _maxAge);
+			result.append("\"");
+		}
+		if (_secure)
+		{
+			result.append("; secure");
+		}
+		if (_httpOnly)
+		{
+			result.append("; HttpOnly");
+		}
+		result.append("; Version=\"1\"");
+	}
+	return result;
+}
+
+
+namespace
+{
+	static const std::string ILLEGAL_CHARS("()[]/|\\',;");
+}
+
+
+std::string HTTPCookie::escape(const std::string& str)
+{
+	std::string result;
+	Poco::URI::encode(str, ILLEGAL_CHARS, result);
+	return result;
+}
+
+
+std::string HTTPCookie::unescape(const std::string& str)
+{
+	std::string result;
+	Poco::URI::decode(str, result);
+	return result;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPCredentials.cpp b/base/poco/Net/src/HTTPCredentials.cpp
new file mode 100644
index 00000000000..ae1d6ea0b62
--- /dev/null
+++ b/base/poco/Net/src/HTTPCredentials.cpp
@@ -0,0 +1,208 @@
+//
+// HTTPCredentials.cpp
+//
+// Library: Net
+// Package: HTTP
+// Module:	HTTPCredentials
+//
+// Copyright (c) 2011, Anton V. Yabchinskiy (arn at bestmx dot ru).
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPAuthenticationParams.h"
+#include "Poco/Net/HTTPBasicCredentials.h"
+#include "Poco/Net/HTTPCredentials.h"
+#include "Poco/Net/HTTPRequest.h"
+#include "Poco/Net/HTTPResponse.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/String.h"
+#include "Poco/Ascii.h"
+#include "Poco/URI.h"
+
+
+using Poco::icompare;
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPCredentials::HTTPCredentials()
+{
+}
+
+
+HTTPCredentials::HTTPCredentials(const std::string& username, const std::string& password):
+	_digest(username, password)
+{
+}
+
+
+HTTPCredentials::~HTTPCredentials()
+{
+}
+
+
+void HTTPCredentials::fromUserInfo(const std::string& userInfo)
+{
+	std::string username;
+	std::string password;
+
+	extractCredentials(userInfo, username, password);
+	setUsername(username);
+	setPassword(password);
+	_digest.reset();
+}
+
+
+void HTTPCredentials::fromURI(const URI& uri)
+{
+	std::string username;
+	std::string password;
+
+	extractCredentials(uri, username, password);
+	setUsername(username);
+	setPassword(password);
+	_digest.reset();
+}
+
+
+void HTTPCredentials::authenticate(HTTPRequest& request, const HTTPResponse& response)
+{
+	for (HTTPResponse::ConstIterator iter = response.find(HTTPAuthenticationParams::WWW_AUTHENTICATE); iter != response.end(); ++iter)
+	{
+		if (isBasicCredentials(iter->second)) 
+		{
+			HTTPBasicCredentials(_digest.getUsername(), _digest.getPassword()).authenticate(request);
+			return;
+		} 
+		else if (isDigestCredentials(iter->second)) 
+		{
+			_digest.authenticate(request, HTTPAuthenticationParams(iter->second.substr(7)));
+			return;
+		}
+	}
+}
+
+
+void HTTPCredentials::updateAuthInfo(HTTPRequest& request)
+{
+	if (request.has(HTTPRequest::AUTHORIZATION)) 
+	{
+		const std::string& authorization = request.get(HTTPRequest::AUTHORIZATION);
+
+		if (isBasicCredentials(authorization)) 
+		{
+			HTTPBasicCredentials(_digest.getUsername(), _digest.getPassword()).authenticate(request);
+		} 
+		else if (isDigestCredentials(authorization)) 
+		{
+			_digest.updateAuthInfo(request);
+		}
+	}
+}
+
+
+void HTTPCredentials::proxyAuthenticate(HTTPRequest& request, const HTTPResponse& response)
+{
+	for (HTTPResponse::ConstIterator iter = response.find(HTTPAuthenticationParams::PROXY_AUTHENTICATE); iter != response.end(); ++iter)
+	{
+		if (isBasicCredentials(iter->second)) 
+		{
+			HTTPBasicCredentials(_digest.getUsername(), _digest.getPassword()).proxyAuthenticate(request);
+			return;
+		} 
+		else if (isDigestCredentials(iter->second)) 
+		{
+			_digest.proxyAuthenticate(request, HTTPAuthenticationParams(iter->second.substr(7)));
+			return;
+		}
+	}
+}
+
+
+void HTTPCredentials::updateProxyAuthInfo(HTTPRequest& request)
+{
+	if (request.has(HTTPRequest::PROXY_AUTHORIZATION)) 
+	{
+		const std::string& authorization = request.get(HTTPRequest::PROXY_AUTHORIZATION);
+
+		if (isBasicCredentials(authorization)) 
+		{
+			HTTPBasicCredentials(_digest.getUsername(), _digest.getPassword()).proxyAuthenticate(request);
+		} 
+		else if (isDigestCredentials(authorization)) 
+		{
+			_digest.updateProxyAuthInfo(request);
+		}
+	}
+}
+
+
+bool HTTPCredentials::isBasicCredentials(const std::string& header)
+{
+	return icompare(header, 0, 5, "Basic") == 0 && (header.size() > 5 ? Poco::Ascii::isSpace(header[5]) : true);
+}
+
+
+bool HTTPCredentials::isDigestCredentials(const std::string& header)
+{
+	return icompare(header, 0, 6, "Digest") == 0 && (header.size() > 6 ? Poco::Ascii::isSpace(header[6]) : true);
+}
+
+
+bool HTTPCredentials::hasBasicCredentials(const HTTPRequest& request)
+{
+	return request.has(HTTPRequest::AUTHORIZATION) && isBasicCredentials(request.get(HTTPRequest::AUTHORIZATION));
+}
+
+
+bool HTTPCredentials::hasDigestCredentials(const HTTPRequest& request)
+{
+	return request.has(HTTPRequest::AUTHORIZATION) && isDigestCredentials(request.get(HTTPRequest::AUTHORIZATION));
+}
+
+
+bool HTTPCredentials::hasProxyBasicCredentials(const HTTPRequest& request)
+{
+	return request.has(HTTPRequest::PROXY_AUTHORIZATION) && isBasicCredentials(request.get(HTTPRequest::PROXY_AUTHORIZATION));
+}
+
+
+bool HTTPCredentials::hasProxyDigestCredentials(const HTTPRequest& request)
+{
+	return request.has(HTTPRequest::PROXY_AUTHORIZATION) && isDigestCredentials(request.get(HTTPRequest::PROXY_AUTHORIZATION));
+}
+
+
+void HTTPCredentials::extractCredentials(const std::string& userInfo, std::string& username, std::string& password)
+{
+	const std::string::size_type p = userInfo.find(':');
+
+	if (p != std::string::npos) 
+	{
+		username.assign(userInfo, 0, p);
+		password.assign(userInfo, p + 1, std::string::npos);
+	} 
+	else 
+	{
+		username.assign(userInfo);
+		password.clear();
+	}
+}
+
+
+void HTTPCredentials::extractCredentials(const Poco::URI& uri, std::string& username, std::string& password)
+{
+	if (!uri.getUserInfo().empty()) 
+	{
+		extractCredentials(uri.getUserInfo(), username, password);
+	}
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPDigestCredentials.cpp b/base/poco/Net/src/HTTPDigestCredentials.cpp
new file mode 100644
index 00000000000..0d3deb51465
--- /dev/null
+++ b/base/poco/Net/src/HTTPDigestCredentials.cpp
@@ -0,0 +1,313 @@
+//
+// HTTPDigestCredentials.cpp
+//
+// Library: Net
+// Package: HTTP
+// Module:	HTTPDigestCredentials
+//
+// Copyright (c) 2011, Anton V. Yabchinskiy (arn at bestmx dot ru).
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DateTime.h"
+#include "Poco/DateTimeFormat.h"
+#include "Poco/DateTimeFormatter.h"
+#include "Poco/Exception.h"
+#include "Poco/MD5Engine.h"
+#include "Poco/Net/HTTPDigestCredentials.h"
+#include "Poco/Net/HTTPRequest.h"
+#include "Poco/Net/HTTPResponse.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/StringTokenizer.h"
+
+
+namespace
+{
+	std::string digest(Poco::DigestEngine& engine,
+					   const std::string& a,
+					   const std::string& b,
+					   const std::string& c = std::string(),
+					   const std::string& d = std::string(),
+					   const std::string& e = std::string(),
+					   const std::string& f = std::string())
+	{
+		engine.reset();
+		engine.update(a);
+		engine.update(':');
+		engine.update(b);
+		if (!c.empty())
+		{
+			engine.update(':');
+			engine.update(c);
+			if (!d.empty())
+			{
+				engine.update(':');
+				engine.update(d);
+				engine.update(':');
+				engine.update(e);
+				engine.update(':');
+				engine.update(f);
+			}
+		}
+		return Poco::DigestEngine::digestToHex(engine.digest());
+	}
+
+	std::string formatNonceCounter(int counter)
+	{
+		return Poco::NumberFormatter::formatHex(counter, 8);
+	}
+}
+
+
+namespace Poco {
+namespace Net {
+
+
+const std::string HTTPDigestCredentials::SCHEME = "Digest";
+const std::string HTTPDigestCredentials::DEFAULT_ALGORITHM("MD5");
+const std::string HTTPDigestCredentials::DEFAULT_QOP("");
+const std::string HTTPDigestCredentials::NONCE_PARAM("nonce");
+const std::string HTTPDigestCredentials::REALM_PARAM("realm");
+const std::string HTTPDigestCredentials::QOP_PARAM("qop");
+const std::string HTTPDigestCredentials::ALGORITHM_PARAM("algorithm");
+const std::string HTTPDigestCredentials::USERNAME_PARAM("username");
+const std::string HTTPDigestCredentials::OPAQUE_PARAM("opaque");
+const std::string HTTPDigestCredentials::URI_PARAM("uri");
+const std::string HTTPDigestCredentials::RESPONSE_PARAM("response");
+const std::string HTTPDigestCredentials::AUTH_PARAM("auth");
+const std::string HTTPDigestCredentials::CNONCE_PARAM("cnonce");
+const std::string HTTPDigestCredentials::NC_PARAM("nc");
+int HTTPDigestCredentials::_nonceCounter(0);
+Poco::FastMutex HTTPDigestCredentials::_nonceMutex;
+
+
+HTTPDigestCredentials::HTTPDigestCredentials()
+{
+}
+
+
+HTTPDigestCredentials::HTTPDigestCredentials(const std::string& username, const std::string& password):
+	_username(username),
+	_password(password)
+{
+}
+
+
+HTTPDigestCredentials::~HTTPDigestCredentials()
+{
+}
+
+
+void HTTPDigestCredentials::reset()
+{
+	_requestAuthParams.clear();
+	_nc.clear();
+}
+
+
+void HTTPDigestCredentials::setUsername(const std::string& username)
+{
+	_username = username;
+}
+
+
+void HTTPDigestCredentials::setPassword(const std::string& password)
+{
+	_password = password;
+}
+
+
+void HTTPDigestCredentials::clear()
+{
+	_username.clear();
+	_password.clear();
+}
+
+
+void HTTPDigestCredentials::authenticate(HTTPRequest& request, const HTTPResponse& response)
+{
+	authenticate(request, HTTPAuthenticationParams(response));
+}
+
+
+void HTTPDigestCredentials::authenticate(HTTPRequest& request, const HTTPAuthenticationParams& responseAuthParams)
+{
+	createAuthParams(request, responseAuthParams);
+	request.setCredentials(SCHEME, _requestAuthParams.toString());
+}
+
+
+void HTTPDigestCredentials::updateAuthInfo(HTTPRequest& request)
+{
+	updateAuthParams(request);
+	request.setCredentials(SCHEME, _requestAuthParams.toString());
+}
+
+
+void HTTPDigestCredentials::proxyAuthenticate(HTTPRequest& request, const HTTPResponse& response)
+{
+	proxyAuthenticate(request, HTTPAuthenticationParams(response, HTTPAuthenticationParams::PROXY_AUTHENTICATE));
+}
+
+
+void HTTPDigestCredentials::proxyAuthenticate(HTTPRequest& request, const HTTPAuthenticationParams& responseAuthParams)
+{
+	createAuthParams(request, responseAuthParams);
+	request.setProxyCredentials(SCHEME, _requestAuthParams.toString());
+}
+
+
+void HTTPDigestCredentials::updateProxyAuthInfo(HTTPRequest& request)
+{
+	updateAuthParams(request);
+	request.setProxyCredentials(SCHEME, _requestAuthParams.toString());
+}
+
+
+std::string HTTPDigestCredentials::createNonce()
+{
+	Poco::FastMutex::ScopedLock lock(_nonceMutex);
+
+	MD5Engine md5;
+	Timestamp::TimeVal now = Timestamp().epochMicroseconds();
+
+	md5.update(&_nonceCounter, sizeof(_nonceCounter));
+	md5.update(&now, sizeof(now));
+
+	++_nonceCounter;
+
+	return DigestEngine::digestToHex(md5.digest());
+}
+
+
+void HTTPDigestCredentials::createAuthParams(const HTTPRequest& request, const HTTPAuthenticationParams& responseAuthParams)
+{
+	// Not implemented: "domain" auth parameter and integrity protection.
+
+	if (!responseAuthParams.has(NONCE_PARAM) || !responseAuthParams.has(REALM_PARAM))
+		throw InvalidArgumentException("Invalid HTTP authentication parameters");
+
+	const std::string& algorithm = responseAuthParams.get(ALGORITHM_PARAM, DEFAULT_ALGORITHM);
+
+	if (icompare(algorithm, DEFAULT_ALGORITHM) != 0)
+		throw NotImplementedException("Unsupported digest algorithm", algorithm);
+
+	const std::string& nonce = responseAuthParams.get(NONCE_PARAM);
+	const std::string& qop = responseAuthParams.get(QOP_PARAM, DEFAULT_QOP);
+	const std::string& realm = responseAuthParams.getRealm();
+
+	_requestAuthParams.clear();
+	_requestAuthParams.set(USERNAME_PARAM, _username);
+	_requestAuthParams.set(NONCE_PARAM, nonce);
+	_requestAuthParams.setRealm(realm);
+	if (responseAuthParams.has(OPAQUE_PARAM))
+	{
+		_requestAuthParams.set(OPAQUE_PARAM, responseAuthParams.get(OPAQUE_PARAM));
+	}
+
+	if (qop.empty())
+	{
+		updateAuthParams(request);
+	}
+	else
+	{
+		Poco::StringTokenizer tok(qop, ",", Poco::StringTokenizer::TOK_TRIM);
+		bool qopSupported = false;
+		for (Poco::StringTokenizer::Iterator it = tok.begin(); it != tok.end(); ++it)
+		{
+			if (icompare(*it, AUTH_PARAM) == 0)
+			{
+				qopSupported = true;
+				_requestAuthParams.set(CNONCE_PARAM, createNonce());
+				_requestAuthParams.set(QOP_PARAM, *it);
+				updateAuthParams(request);
+				break;
+			}
+		}
+		if (!qopSupported)
+			throw NotImplementedException("Unsupported QoP requested", qop);
+	}
+}
+
+
+void HTTPDigestCredentials::updateAuthParams(const HTTPRequest& request)
+{
+	MD5Engine engine;
+	const std::string& qop = _requestAuthParams.get(QOP_PARAM, DEFAULT_QOP);
+	const std::string& realm = _requestAuthParams.getRealm();
+	const std::string& nonce = _requestAuthParams.get(NONCE_PARAM);
+
+	_requestAuthParams.set(URI_PARAM, request.getURI());
+
+	if (qop.empty())
+	{
+		const std::string ha1 = digest(engine, _username, realm, _password);
+		const std::string ha2 = digest(engine, request.getMethod(), request.getURI());
+
+		_requestAuthParams.set(RESPONSE_PARAM, digest(engine, ha1, nonce, ha2));
+	}
+	else if (icompare(qop, AUTH_PARAM) == 0)
+	{
+		const std::string& cnonce = _requestAuthParams.get(CNONCE_PARAM);
+
+		const std::string ha1 = digest(engine, _username, realm, _password);
+		const std::string ha2 = digest(engine, request.getMethod(), request.getURI());
+		const std::string nc = formatNonceCounter(updateNonceCounter(nonce));
+
+		_requestAuthParams.set(NC_PARAM, nc);
+		_requestAuthParams.set(RESPONSE_PARAM, digest(engine, ha1, nonce, nc, cnonce, qop, ha2));
+	}
+}
+
+
+bool HTTPDigestCredentials::verifyAuthInfo(const HTTPRequest& request) const
+{
+	HTTPAuthenticationParams params(request);
+	return verifyAuthParams(request, params);
+}
+
+
+bool HTTPDigestCredentials::verifyAuthParams(const HTTPRequest& request, const HTTPAuthenticationParams& params) const
+{
+	const std::string& nonce = params.get(NONCE_PARAM);
+	const std::string& realm = params.getRealm();
+	const std::string& qop   = params.get(QOP_PARAM, DEFAULT_QOP);
+	std::string response;
+	MD5Engine engine;
+	if (qop.empty())
+	{
+		const std::string ha1 = digest(engine, _username, realm, _password);
+		const std::string ha2 = digest(engine, request.getMethod(), request.getURI());
+		response = digest(engine, ha1, nonce, ha2);
+	}
+	else if (icompare(qop, AUTH_PARAM) == 0)
+	{
+		const std::string& cnonce = params.get(CNONCE_PARAM);
+		const std::string& nc = params.get(NC_PARAM);
+		const std::string ha1 = digest(engine, _username, realm, _password);
+		const std::string ha2 = digest(engine, request.getMethod(), request.getURI());
+		response = digest(engine, ha1, nonce, nc, cnonce, qop, ha2);
+	}
+	return response == params.get(RESPONSE_PARAM);
+}
+
+
+int HTTPDigestCredentials::updateNonceCounter(const std::string& nonce)
+{
+	NonceCounterMap::iterator iter = _nc.find(nonce);
+
+	if (iter == _nc.end())
+	{
+		iter = _nc.insert(NonceCounterMap::value_type(nonce, 0)).first;
+	}
+	iter->second++;
+
+	return iter->second;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPFixedLengthStream.cpp b/base/poco/Net/src/HTTPFixedLengthStream.cpp
new file mode 100644
index 00000000000..d19f6122ee1
--- /dev/null
+++ b/base/poco/Net/src/HTTPFixedLengthStream.cpp
@@ -0,0 +1,185 @@
+//
+// HTTPFixedLengthStream.cpp
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPFixedLengthStream
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPFixedLengthStream.h"
+#include "Poco/Net/HTTPSession.h"
+#include "Poco/Net/NetException.h"
+
+
+using Poco::BufferedStreamBuf;
+
+
+namespace Poco {
+namespace Net {
+
+
+//
+// HTTPFixedLengthStreamBuf
+//
+
+
+HTTPFixedLengthStreamBuf::HTTPFixedLengthStreamBuf(HTTPSession& session, ContentLength length, openmode mode):
+	HTTPBasicStreamBuf(HTTPBufferAllocator::BUFFER_SIZE, mode),
+	_session(session),
+	_length(length),
+	_count(0)
+{
+}
+
+
+HTTPFixedLengthStreamBuf::~HTTPFixedLengthStreamBuf()
+{
+}
+
+
+int HTTPFixedLengthStreamBuf::readFromDevice(char* buffer, std::streamsize length)
+{
+	int n = 0;
+	if (_count < _length)
+	{
+		if (_count + length > _length)
+			length = static_cast<std::streamsize>(_length - _count);
+		n = _session.read(buffer, length);
+		if (n > 0)
+			_count += n;
+		else
+			throw MessageException("Unexpected EOF");
+	}
+	return n;
+}
+
+
+int HTTPFixedLengthStreamBuf::writeToDevice(const char* buffer, std::streamsize length)
+{
+	int n = 0;
+	if (_count < _length)
+	{
+		if (_count + length > _length)
+			length = static_cast<std::streamsize>(_length - _count);
+		n = _session.write(buffer, length);
+		if (n > 0) _count += n;
+	}
+	return n;
+}
+
+
+//
+// HTTPFixedLengthIOS
+//
+
+
+HTTPFixedLengthIOS::HTTPFixedLengthIOS(HTTPSession& session, HTTPFixedLengthStreamBuf::ContentLength length, HTTPFixedLengthStreamBuf::openmode mode):
+	_buf(session, length, mode)
+{
+	poco_ios_init(&_buf);
+}
+
+
+HTTPFixedLengthIOS::~HTTPFixedLengthIOS()
+{
+	try
+	{
+		_buf.sync();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+HTTPFixedLengthStreamBuf* HTTPFixedLengthIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+//
+// HTTPFixedLengthInputStream
+//
+
+
+Poco::MemoryPool HTTPFixedLengthInputStream::_pool(sizeof(HTTPFixedLengthInputStream));
+
+
+HTTPFixedLengthInputStream::HTTPFixedLengthInputStream(HTTPSession& session, HTTPFixedLengthStreamBuf::ContentLength length):
+	HTTPFixedLengthIOS(session, length, std::ios::in),
+	std::istream(&_buf)
+{
+}
+
+
+HTTPFixedLengthInputStream::~HTTPFixedLengthInputStream()
+{
+}
+
+
+void* HTTPFixedLengthInputStream::operator new(std::size_t size)
+{
+	return _pool.get();
+}
+
+
+void HTTPFixedLengthInputStream::operator delete(void* ptr)
+{
+	try
+	{
+		_pool.release(ptr);
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+//
+// HTTPFixedLengthOutputStream
+//
+
+
+Poco::MemoryPool HTTPFixedLengthOutputStream::_pool(sizeof(HTTPFixedLengthOutputStream));
+
+
+HTTPFixedLengthOutputStream::HTTPFixedLengthOutputStream(HTTPSession& session, HTTPFixedLengthStreamBuf::ContentLength length):
+	HTTPFixedLengthIOS(session, length, std::ios::out),
+	std::ostream(&_buf)
+{
+}
+
+
+HTTPFixedLengthOutputStream::~HTTPFixedLengthOutputStream()
+{
+}
+
+
+void* HTTPFixedLengthOutputStream::operator new(std::size_t size)
+{
+	return _pool.get();
+}
+
+
+void HTTPFixedLengthOutputStream::operator delete(void* ptr)
+{
+	try
+	{
+		_pool.release(ptr);
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPHeaderStream.cpp b/base/poco/Net/src/HTTPHeaderStream.cpp
new file mode 100644
index 00000000000..8e0091fcbe3
--- /dev/null
+++ b/base/poco/Net/src/HTTPHeaderStream.cpp
@@ -0,0 +1,178 @@
+//
+// HTTPHeaderStream.cpp
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPHeaderStream
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPHeaderStream.h"
+#include "Poco/Net/HTTPSession.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+//
+// HTTPHeaderStreamBuf
+//
+
+
+HTTPHeaderStreamBuf::HTTPHeaderStreamBuf(HTTPSession& session, openmode mode):
+	HTTPBasicStreamBuf(HTTPBufferAllocator::BUFFER_SIZE, mode),
+	_session(session),
+	_end(false)
+{
+}
+
+
+HTTPHeaderStreamBuf::~HTTPHeaderStreamBuf()
+{
+}
+
+
+int HTTPHeaderStreamBuf::readFromDevice(char* buffer, std::streamsize length)
+{
+	// read line-by-line; an empty line denotes the end of the headers.
+	static const int eof = std::char_traits<char>::eof();
+
+	if (_end) return 0;
+
+	int n = 0;
+	int ch = _session.get();
+	while (ch != eof && ch != '\n' && n < length - 1)
+	{
+		*buffer++ = (char) ch; ++n;
+		ch = _session.get();
+	}
+	if (ch != eof)
+	{
+		*buffer++ = (char) ch; ++n;
+		if (n == 2) _end = true;
+	}
+	return n;
+}
+
+
+int HTTPHeaderStreamBuf::writeToDevice(const char* buffer, std::streamsize length)
+{
+	return _session.write(buffer, length);
+}
+
+
+//
+// HTTPHeaderIOS
+//
+
+
+HTTPHeaderIOS::HTTPHeaderIOS(HTTPSession& session, HTTPHeaderStreamBuf::openmode mode):
+	_buf(session, mode)
+{
+	poco_ios_init(&_buf);
+}
+
+
+HTTPHeaderIOS::~HTTPHeaderIOS()
+{
+	try
+	{
+		_buf.sync();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+HTTPHeaderStreamBuf* HTTPHeaderIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+//
+// HTTPHeaderInputStream
+//
+
+
+Poco::MemoryPool HTTPHeaderInputStream::_pool(sizeof(HTTPHeaderInputStream));
+
+
+HTTPHeaderInputStream::HTTPHeaderInputStream(HTTPSession& session):
+	HTTPHeaderIOS(session, std::ios::in),
+	std::istream(&_buf)
+{
+}
+
+
+HTTPHeaderInputStream::~HTTPHeaderInputStream()
+{
+}
+
+
+void* HTTPHeaderInputStream::operator new(std::size_t size)
+{
+	return _pool.get();
+}
+
+
+void HTTPHeaderInputStream::operator delete(void* ptr)
+{
+	try
+	{
+		_pool.release(ptr);
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+//
+// HTTPHeaderOutputStream
+//
+
+
+Poco::MemoryPool HTTPHeaderOutputStream::_pool(sizeof(HTTPHeaderOutputStream));
+
+
+HTTPHeaderOutputStream::HTTPHeaderOutputStream(HTTPSession& session):
+	HTTPHeaderIOS(session, std::ios::out),
+	std::ostream(&_buf)
+{
+}
+
+
+HTTPHeaderOutputStream::~HTTPHeaderOutputStream()
+{
+}
+
+
+void* HTTPHeaderOutputStream::operator new(std::size_t size)
+{
+	return _pool.get();
+}
+
+
+void HTTPHeaderOutputStream::operator delete(void* ptr)
+{
+	try
+	{
+		_pool.release(ptr);
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPIOStream.cpp b/base/poco/Net/src/HTTPIOStream.cpp
new file mode 100644
index 00000000000..c6492aed8f2
--- /dev/null
+++ b/base/poco/Net/src/HTTPIOStream.cpp
@@ -0,0 +1,65 @@
+//
+// HTTPIOStream.cpp
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPIOStream
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPIOStream.h"
+#include "Poco/Net/HTTPClientSession.h"
+
+
+using Poco::UnbufferedStreamBuf;
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPResponseStreamBuf::HTTPResponseStreamBuf(std::istream& istr):
+	_istr(istr)
+{
+	// make sure exceptions from underlying string propagate
+	_istr.exceptions(std::ios::badbit);
+}
+
+
+HTTPResponseStreamBuf::~HTTPResponseStreamBuf()
+{
+}
+
+
+HTTPResponseIOS::HTTPResponseIOS(std::istream& istr):
+	_buf(istr)
+{
+	poco_ios_init(&_buf);
+}
+
+
+HTTPResponseIOS::~HTTPResponseIOS()
+{
+}
+
+
+HTTPResponseStream::HTTPResponseStream(std::istream& istr, HTTPClientSession* pSession):
+	HTTPResponseIOS(istr),
+	std::istream(&_buf),
+	_pSession(pSession)
+{
+}
+
+
+HTTPResponseStream::~HTTPResponseStream()
+{
+	delete _pSession;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPMessage.cpp b/base/poco/Net/src/HTTPMessage.cpp
new file mode 100644
index 00000000000..debda04c3b3
--- /dev/null
+++ b/base/poco/Net/src/HTTPMessage.cpp
@@ -0,0 +1,184 @@
+//
+// HTTPMessage.cpp
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPMessage
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPMessage.h"
+#include "Poco/Net/MediaType.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/NumberParser.h"
+#include "Poco/String.h"
+
+
+using Poco::NumberFormatter;
+using Poco::NumberParser;
+using Poco::icompare;
+
+
+namespace Poco {
+namespace Net {
+
+
+const std::string HTTPMessage::HTTP_1_0                   = "HTTP/1.0";
+const std::string HTTPMessage::HTTP_1_1                   = "HTTP/1.1";
+const std::string HTTPMessage::IDENTITY_TRANSFER_ENCODING = "identity";
+const std::string HTTPMessage::CHUNKED_TRANSFER_ENCODING  = "chunked";
+const int         HTTPMessage::UNKNOWN_CONTENT_LENGTH     = -1;
+const std::string HTTPMessage::UNKNOWN_CONTENT_TYPE;
+const std::string HTTPMessage::CONTENT_LENGTH             = "Content-Length";
+const std::string HTTPMessage::CONTENT_TYPE               = "Content-Type";
+const std::string HTTPMessage::TRANSFER_ENCODING          = "Transfer-Encoding";
+const std::string HTTPMessage::CONNECTION                 = "Connection";
+const std::string HTTPMessage::CONNECTION_KEEP_ALIVE      = "Keep-Alive";
+const std::string HTTPMessage::CONNECTION_CLOSE           = "Close";
+const std::string HTTPMessage::EMPTY;
+
+
+HTTPMessage::HTTPMessage():
+	_version(HTTP_1_0)
+{
+}
+
+
+HTTPMessage::HTTPMessage(const std::string& version):
+	_version(version)
+{
+}
+
+
+HTTPMessage::~HTTPMessage()
+{
+}
+
+
+void HTTPMessage::setVersion(const std::string& version)
+{
+	_version = version;
+}
+
+
+void HTTPMessage::setContentLength(std::streamsize length)
+{
+	if (length != UNKNOWN_CONTENT_LENGTH)
+		set(CONTENT_LENGTH, NumberFormatter::format(length));
+	else
+		erase(CONTENT_LENGTH);
+}
+
+	
+std::streamsize HTTPMessage::getContentLength() const
+{
+	const std::string& contentLength = get(CONTENT_LENGTH, EMPTY);
+	if (!contentLength.empty())
+	{
+		if (sizeof(std::streamsize) == sizeof(Poco::Int64))
+			return static_cast<std::streamsize>(NumberParser::parse64(contentLength));
+		else
+			return static_cast<std::streamsize>(NumberParser::parse(contentLength));
+	}
+	else return UNKNOWN_CONTENT_LENGTH;
+}
+
+
+#if defined(POCO_HAVE_INT64)	
+void HTTPMessage::setContentLength64(Poco::Int64 length)
+{
+	if (length != UNKNOWN_CONTENT_LENGTH)
+		set(CONTENT_LENGTH, NumberFormatter::format(length));
+	else
+		erase(CONTENT_LENGTH);
+}
+
+	
+Poco::Int64 HTTPMessage::getContentLength64() const
+{
+	const std::string& contentLength = get(CONTENT_LENGTH, EMPTY);
+	if (!contentLength.empty())
+	{
+		return NumberParser::parse64(contentLength);
+	}
+	else return UNKNOWN_CONTENT_LENGTH;
+}
+#endif // defined(POCO_HAVE_INT64)	
+
+
+void HTTPMessage::setTransferEncoding(const std::string& transferEncoding)
+{
+	if (icompare(transferEncoding, IDENTITY_TRANSFER_ENCODING) == 0)
+		erase(TRANSFER_ENCODING);
+	else
+		set(TRANSFER_ENCODING, transferEncoding);
+}
+
+
+const std::string& HTTPMessage::getTransferEncoding() const
+{
+	return get(TRANSFER_ENCODING, IDENTITY_TRANSFER_ENCODING);
+}
+
+
+void HTTPMessage::setChunkedTransferEncoding(bool flag)
+{
+	if (flag)
+		setTransferEncoding(CHUNKED_TRANSFER_ENCODING);
+	else
+		setTransferEncoding(IDENTITY_TRANSFER_ENCODING);
+}
+
+	
+bool HTTPMessage::getChunkedTransferEncoding() const
+{
+	return icompare(getTransferEncoding(), CHUNKED_TRANSFER_ENCODING) == 0;
+}
+
+	
+void HTTPMessage::setContentType(const std::string& mediaType)
+{
+	if (mediaType.empty())
+		erase(CONTENT_TYPE);
+	else
+		set(CONTENT_TYPE, mediaType);
+}
+
+
+void HTTPMessage::setContentType(const MediaType& mediaType)
+{
+	setContentType(mediaType.toString());
+}
+
+	
+const std::string& HTTPMessage::getContentType() const
+{
+	return get(CONTENT_TYPE, UNKNOWN_CONTENT_TYPE);
+}
+
+
+void HTTPMessage::setKeepAlive(bool keepAlive)
+{
+	if (keepAlive)
+		set(CONNECTION, CONNECTION_KEEP_ALIVE);
+	else
+		set(CONNECTION, CONNECTION_CLOSE);
+}
+
+
+bool HTTPMessage::getKeepAlive() const
+{
+	const std::string& connection = get(CONNECTION, EMPTY);
+	if (!connection.empty())
+		return icompare(connection, CONNECTION_CLOSE) != 0;
+	else
+		return getVersion() == HTTP_1_1;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPRequest.cpp b/base/poco/Net/src/HTTPRequest.cpp
new file mode 100644
index 00000000000..52b3cf2f714
--- /dev/null
+++ b/base/poco/Net/src/HTTPRequest.cpp
@@ -0,0 +1,277 @@
+//
+// HTTPRequest.cpp
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPRequest
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPRequest.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Net/NameValueCollection.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/Ascii.h"
+#include "Poco/String.h"
+
+
+using Poco::NumberFormatter;
+
+
+namespace Poco {
+namespace Net {
+
+
+const std::string HTTPRequest::HTTP_GET            = "GET";
+const std::string HTTPRequest::HTTP_HEAD           = "HEAD";
+const std::string HTTPRequest::HTTP_PUT            = "PUT";
+const std::string HTTPRequest::HTTP_POST           = "POST";
+const std::string HTTPRequest::HTTP_OPTIONS        = "OPTIONS";
+const std::string HTTPRequest::HTTP_DELETE         = "DELETE";
+const std::string HTTPRequest::HTTP_TRACE          = "TRACE";
+const std::string HTTPRequest::HTTP_CONNECT        = "CONNECT";
+const std::string HTTPRequest::HTTP_PATCH          = "PATCH";
+const std::string HTTPRequest::HOST                = "Host";
+const std::string HTTPRequest::COOKIE              = "Cookie";
+const std::string HTTPRequest::AUTHORIZATION       = "Authorization";
+const std::string HTTPRequest::PROXY_AUTHORIZATION = "Proxy-Authorization";
+const std::string HTTPRequest::UPGRADE             = "Upgrade";
+const std::string HTTPRequest::EXPECT              = "Expect";
+
+
+HTTPRequest::HTTPRequest():
+	_method(HTTP_GET),
+	_uri("/")
+{
+}
+
+	
+HTTPRequest::HTTPRequest(const std::string& version):
+	HTTPMessage(version),
+	_method(HTTP_GET),
+	_uri("/")
+{
+}
+
+	
+HTTPRequest::HTTPRequest(const std::string& method, const std::string& uri):
+	_method(method),
+	_uri(uri)
+{
+}
+
+
+HTTPRequest::HTTPRequest(const std::string& method, const std::string& uri, const std::string& version):
+	HTTPMessage(version),
+	_method(method),
+	_uri(uri)
+{
+}
+
+
+HTTPRequest::~HTTPRequest()
+{
+}
+
+
+void HTTPRequest::setMethod(const std::string& method)
+{
+	_method = method;
+}
+
+
+void HTTPRequest::setURI(const std::string& uri)
+{
+	_uri = uri;
+}
+
+
+void HTTPRequest::setHost(const std::string& host)
+{
+	set(HOST, host);
+}
+
+	
+void HTTPRequest::setHost(const std::string& host, Poco::UInt16 port)
+{
+	std::string value;
+	if (host.find(':') != std::string::npos)
+	{
+		// IPv6 address
+		value.append("[");
+		value.append(host);
+		value.append("]");
+	}
+	else
+	{
+		value.append(host);
+	}    
+
+	if (port != 80 && port != 443)
+	{
+		value.append(":");
+		NumberFormatter::append(value, port);
+	}
+	setHost(value);
+}
+
+	
+const std::string& HTTPRequest::getHost() const
+{
+	return get(HOST);
+}
+
+
+void HTTPRequest::setCookies(const NameValueCollection& cookies)
+{
+	std::string cookie;
+	cookie.reserve(64);
+	for (NameValueCollection::ConstIterator it = cookies.begin(); it != cookies.end(); ++it)
+	{
+		if (it != cookies.begin())
+			cookie.append("; ");
+		cookie.append(it->first);
+		cookie.append("=");
+		cookie.append(it->second);
+	}
+	add(COOKIE, cookie);
+}
+
+	
+void HTTPRequest::getCookies(NameValueCollection& cookies) const
+{
+	NameValueCollection::ConstIterator it = find(COOKIE);
+	while (it != end() && Poco::icompare(it->first, COOKIE) == 0)
+	{
+		splitParameters(it->second.begin(), it->second.end(), cookies);
+		++it;
+	}
+}
+
+
+bool HTTPRequest::hasCredentials() const
+{
+	return has(AUTHORIZATION);
+}
+
+	
+void HTTPRequest::getCredentials(std::string& scheme, std::string& authInfo) const
+{
+	getCredentials(AUTHORIZATION, scheme, authInfo);
+}
+
+	
+void HTTPRequest::setCredentials(const std::string& scheme, const std::string& authInfo)
+{
+	setCredentials(AUTHORIZATION, scheme, authInfo);
+}
+
+
+bool HTTPRequest::hasProxyCredentials() const
+{
+	return has(PROXY_AUTHORIZATION);
+}
+
+	
+void HTTPRequest::getProxyCredentials(std::string& scheme, std::string& authInfo) const
+{
+	getCredentials(PROXY_AUTHORIZATION, scheme, authInfo);
+}
+
+	
+void HTTPRequest::setProxyCredentials(const std::string& scheme, const std::string& authInfo)
+{
+	setCredentials(PROXY_AUTHORIZATION, scheme, authInfo);
+}
+
+
+void HTTPRequest::write(std::ostream& ostr) const
+{
+	ostr << _method << " " << _uri << " " << getVersion() << "\r\n";
+	HTTPMessage::write(ostr);
+	ostr << "\r\n";
+}
+
+
+void HTTPRequest::read(std::istream& istr)
+{
+	static const int eof = std::char_traits<char>::eof();
+
+	std::string method;
+	std::string uri;
+	std::string version;
+	method.reserve(16);
+	uri.reserve(64);
+	version.reserve(16);
+	int ch = istr.get();
+	if (istr.bad()) throw NetException("Error reading HTTP request header");
+	if (ch == eof) throw NoMessageException();
+	while (Poco::Ascii::isSpace(ch)) ch = istr.get();
+	if (ch == eof) throw MessageException("No HTTP request header");
+	while (!Poco::Ascii::isSpace(ch) && ch != eof && method.length() < MAX_METHOD_LENGTH) { method += (char) ch; ch = istr.get(); }
+	if (!Poco::Ascii::isSpace(ch)) throw MessageException("HTTP request method invalid or too long");
+	while (Poco::Ascii::isSpace(ch)) ch = istr.get();
+	while (!Poco::Ascii::isSpace(ch) && ch != eof && uri.length() < MAX_URI_LENGTH) { uri += (char) ch; ch = istr.get(); }
+	if (!Poco::Ascii::isSpace(ch)) throw MessageException("HTTP request URI invalid or too long");
+	while (Poco::Ascii::isSpace(ch)) ch = istr.get();
+	while (!Poco::Ascii::isSpace(ch) && ch != eof && version.length() < MAX_VERSION_LENGTH) { version += (char) ch; ch = istr.get(); }
+	if (!Poco::Ascii::isSpace(ch)) throw MessageException("Invalid HTTP version string");
+	while (ch != '\n' && ch != eof) { ch = istr.get(); }
+	HTTPMessage::read(istr);
+	ch = istr.get();
+	while (ch != '\n' && ch != eof) { ch = istr.get(); }
+	setMethod(method);
+	setURI(uri);
+	setVersion(version);
+}
+
+
+void HTTPRequest::getCredentials(const std::string& header, std::string& scheme, std::string& authInfo) const
+{
+	scheme.clear();
+	authInfo.clear();
+	if (has(header))
+	{
+		const std::string& auth = get(header);
+		std::string::const_iterator it  = auth.begin();
+		std::string::const_iterator end = auth.end();
+		while (it != end && Poco::Ascii::isSpace(*it)) ++it;
+		while (it != end && !Poco::Ascii::isSpace(*it)) scheme += *it++;
+		while (it != end && Poco::Ascii::isSpace(*it)) ++it;
+		while (it != end) authInfo += *it++;
+	}
+	else throw NotAuthenticatedException();
+}
+
+	
+void HTTPRequest::setCredentials(const std::string& header, const std::string& scheme, const std::string& authInfo)
+{
+	std::string auth(scheme);
+	auth.append(" ");
+	auth.append(authInfo);
+	set(header, auth);
+}
+
+
+bool HTTPRequest::getExpectContinue() const
+{
+	const std::string& expect = get(EXPECT, EMPTY);
+	return !expect.empty() && icompare(expect, "100-continue") == 0;
+}
+
+
+void HTTPRequest::setExpectContinue(bool expectContinue)
+{
+	if (expectContinue)
+		set(EXPECT, "100-continue");
+	else
+		erase(EXPECT);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPRequestHandler.cpp b/base/poco/Net/src/HTTPRequestHandler.cpp
new file mode 100644
index 00000000000..1d73ff82274
--- /dev/null
+++ b/base/poco/Net/src/HTTPRequestHandler.cpp
@@ -0,0 +1,32 @@
+//
+// HTTPRequestHandler.cpp
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPRequestHandler
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPRequestHandler.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPRequestHandler::HTTPRequestHandler()
+{
+}
+
+
+HTTPRequestHandler::~HTTPRequestHandler()
+{
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPRequestHandlerFactory.cpp b/base/poco/Net/src/HTTPRequestHandlerFactory.cpp
new file mode 100644
index 00000000000..d6f44f070b7
--- /dev/null
+++ b/base/poco/Net/src/HTTPRequestHandlerFactory.cpp
@@ -0,0 +1,32 @@
+//
+// HTTPRequestHandlerFactory.cpp
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPRequestHandlerFactory
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPRequestHandlerFactory.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPRequestHandlerFactory::HTTPRequestHandlerFactory()
+{
+}
+
+
+HTTPRequestHandlerFactory::~HTTPRequestHandlerFactory()
+{
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPResponse.cpp b/base/poco/Net/src/HTTPResponse.cpp
new file mode 100644
index 00000000000..e0017321595
--- /dev/null
+++ b/base/poco/Net/src/HTTPResponse.cpp
@@ -0,0 +1,390 @@
+//
+// HTTPResponse.cpp
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPResponse
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPResponse.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/NumberParser.h"
+#include "Poco/DateTime.h"
+#include "Poco/DateTimeFormatter.h"
+#include "Poco/DateTimeFormat.h"
+#include "Poco/DateTimeParser.h"
+#include "Poco/Ascii.h"
+#include "Poco/String.h"
+
+
+using Poco::DateTime;
+using Poco::NumberFormatter;
+using Poco::NumberParser;
+using Poco::DateTimeFormatter;
+using Poco::DateTimeFormat;
+using Poco::DateTimeParser;
+
+
+namespace Poco {
+namespace Net {
+
+
+const std::string HTTPResponse::HTTP_REASON_CONTINUE                        = "Continue";
+const std::string HTTPResponse::HTTP_REASON_SWITCHING_PROTOCOLS             = "Switching Protocols";
+const std::string HTTPResponse::HTTP_REASON_PROCESSING                      = "Processing";
+const std::string HTTPResponse::HTTP_REASON_OK                              = "OK";
+const std::string HTTPResponse::HTTP_REASON_CREATED                         = "Created";
+const std::string HTTPResponse::HTTP_REASON_ACCEPTED                        = "Accepted";
+const std::string HTTPResponse::HTTP_REASON_NONAUTHORITATIVE                = "Non-Authoritative Information";
+const std::string HTTPResponse::HTTP_REASON_NO_CONTENT                      = "No Content";
+const std::string HTTPResponse::HTTP_REASON_RESET_CONTENT                   = "Reset Content";
+const std::string HTTPResponse::HTTP_REASON_PARTIAL_CONTENT                 = "Partial Content";
+const std::string HTTPResponse::HTTP_REASON_MULTI_STATUS                    = "Multi Status";
+const std::string HTTPResponse::HTTP_REASON_ALREADY_REPORTED                = "Already Reported";
+const std::string HTTPResponse::HTTP_REASON_IM_USED                         = "IM Used";
+const std::string HTTPResponse::HTTP_REASON_MULTIPLE_CHOICES                = "Multiple Choices";
+const std::string HTTPResponse::HTTP_REASON_MOVED_PERMANENTLY               = "Moved Permanently";
+const std::string HTTPResponse::HTTP_REASON_FOUND                           = "Found";
+const std::string HTTPResponse::HTTP_REASON_SEE_OTHER                       = "See Other";
+const std::string HTTPResponse::HTTP_REASON_NOT_MODIFIED                    = "Not Modified";
+const std::string HTTPResponse::HTTP_REASON_USE_PROXY                       = "Use Proxy";
+const std::string HTTPResponse::HTTP_REASON_TEMPORARY_REDIRECT              = "Temporary Redirect";
+const std::string HTTPResponse::HTTP_REASON_PERMANENT_REDIRECT              = "Permanent Redirect";
+const std::string HTTPResponse::HTTP_REASON_BAD_REQUEST                     = "Bad Request";
+const std::string HTTPResponse::HTTP_REASON_UNAUTHORIZED                    = "Unauthorized";
+const std::string HTTPResponse::HTTP_REASON_PAYMENT_REQUIRED                = "Payment Required";
+const std::string HTTPResponse::HTTP_REASON_FORBIDDEN                       = "Forbidden";
+const std::string HTTPResponse::HTTP_REASON_NOT_FOUND                       = "Not Found";
+const std::string HTTPResponse::HTTP_REASON_METHOD_NOT_ALLOWED              = "Method Not Allowed";
+const std::string HTTPResponse::HTTP_REASON_NOT_ACCEPTABLE                  = "Not Acceptable";
+const std::string HTTPResponse::HTTP_REASON_PROXY_AUTHENTICATION_REQUIRED   = "Proxy Authentication Required";
+const std::string HTTPResponse::HTTP_REASON_REQUEST_TIMEOUT                 = "Request Time-out";
+const std::string HTTPResponse::HTTP_REASON_CONFLICT                        = "Conflict";
+const std::string HTTPResponse::HTTP_REASON_GONE                            = "Gone";
+const std::string HTTPResponse::HTTP_REASON_LENGTH_REQUIRED                 = "Length Required";
+const std::string HTTPResponse::HTTP_REASON_PRECONDITION_FAILED             = "Precondition Failed";
+const std::string HTTPResponse::HTTP_REASON_REQUEST_ENTITY_TOO_LARGE        = "Request Entity Too Large";
+const std::string HTTPResponse::HTTP_REASON_REQUEST_URI_TOO_LONG            = "Request-URI Too Large";
+const std::string HTTPResponse::HTTP_REASON_UNSUPPORTED_MEDIA_TYPE          = "Unsupported Media Type";
+const std::string HTTPResponse::HTTP_REASON_REQUESTED_RANGE_NOT_SATISFIABLE = "Requested Range Not Satisfiable";
+const std::string HTTPResponse::HTTP_REASON_EXPECTATION_FAILED              = "Expectation Failed";
+const std::string HTTPResponse::HTTP_REASON_IM_A_TEAPOT                     = "I'm a Teapot";
+const std::string HTTPResponse::HTTP_REASON_ENCHANCE_YOUR_CALM              = "Enchance Your Calm";
+const std::string HTTPResponse::HTTP_REASON_MISDIRECTED_REQUEST             = "Misdirected Request";
+const std::string HTTPResponse::HTTP_REASON_UNPROCESSABLE_ENTITY            = "Unprocessable Entity";
+const std::string HTTPResponse::HTTP_REASON_LOCKED                          = "Locked";
+const std::string HTTPResponse::HTTP_REASON_FAILED_DEPENDENCY               = "Failed Dependency";
+const std::string HTTPResponse::HTTP_REASON_UPGRADE_REQUIRED                = "Upgrade Required";
+const std::string HTTPResponse::HTTP_REASON_PRECONDITION_REQUIRED           = "Precondition Required";
+const std::string HTTPResponse::HTTP_REASON_TOO_MANY_REQUESTS               = "Too Many Requests";
+const std::string HTTPResponse::HTTP_REASON_REQUEST_HEADER_FIELDS_TOO_LARGE = "Request Header Fields Too Large";
+const std::string HTTPResponse::HTTP_REASON_UNAVAILABLE_FOR_LEGAL_REASONS   = "Unavailable For Legal Reasons";
+const std::string HTTPResponse::HTTP_REASON_INTERNAL_SERVER_ERROR           = "Internal Server Error";
+const std::string HTTPResponse::HTTP_REASON_NOT_IMPLEMENTED                 = "Not Implemented";
+const std::string HTTPResponse::HTTP_REASON_BAD_GATEWAY                     = "Bad Gateway";
+const std::string HTTPResponse::HTTP_REASON_SERVICE_UNAVAILABLE             = "Service Unavailable";
+const std::string HTTPResponse::HTTP_REASON_GATEWAY_TIMEOUT                 = "Gateway Time-Out";
+const std::string HTTPResponse::HTTP_REASON_VERSION_NOT_SUPPORTED           = "HTTP Version Not Supported";
+const std::string HTTPResponse::HTTP_REASON_VARIANT_ALSO_NEGOTIATES         = "Variant Also Negotiates";
+const std::string HTTPResponse::HTTP_REASON_INSUFFICIENT_STORAGE            = "Insufficient Storage";
+const std::string HTTPResponse::HTTP_REASON_LOOP_DETECTED                   = "Loop Detected";
+const std::string HTTPResponse::HTTP_REASON_NOT_EXTENDED                    = "Not Extended";
+const std::string HTTPResponse::HTTP_REASON_NETWORK_AUTHENTICATION_REQUIRED = "Network Authentication Required";
+const std::string HTTPResponse::HTTP_REASON_UNKNOWN                         = "???";
+const std::string HTTPResponse::DATE       = "Date";
+const std::string HTTPResponse::SET_COOKIE = "Set-Cookie";
+
+
+HTTPResponse::HTTPResponse():
+	_status(HTTP_OK),
+	_reason(getReasonForStatus(HTTP_OK))
+{
+}
+
+	
+HTTPResponse::HTTPResponse(HTTPStatus status, const std::string& reason):
+	_status(status),
+	_reason(reason)
+{
+}
+
+
+	
+HTTPResponse::HTTPResponse(const std::string& version, HTTPStatus status, const std::string& reason):
+	HTTPMessage(version),
+	_status(status),
+	_reason(reason)
+{
+}
+
+	
+HTTPResponse::HTTPResponse(HTTPStatus status):
+	_status(status),
+	_reason(getReasonForStatus(status))
+{
+}
+
+
+HTTPResponse::HTTPResponse(const std::string& version, HTTPStatus status):
+	HTTPMessage(version),
+	_status(status),
+	_reason(getReasonForStatus(status))
+{
+}
+
+
+HTTPResponse::~HTTPResponse()
+{
+}
+
+
+void HTTPResponse::setStatus(HTTPStatus status)
+{
+	_status = status;
+}
+
+
+void HTTPResponse::setStatus(const std::string& status)
+{
+	setStatus((HTTPStatus) NumberParser::parse(status));
+}
+	
+	
+void HTTPResponse::setReason(const std::string& reason)
+{
+	_reason = reason;
+}
+
+
+void HTTPResponse::setStatusAndReason(HTTPStatus status, const std::string& reason)
+{
+	_status = status;
+	_reason = reason;
+}
+
+	
+void HTTPResponse::setStatusAndReason(HTTPStatus status)
+{
+	setStatusAndReason(status, getReasonForStatus(status));
+}
+
+
+void HTTPResponse::setDate(const Poco::Timestamp& dateTime)
+{
+	set(DATE, DateTimeFormatter::format(dateTime, DateTimeFormat::HTTP_FORMAT));
+}
+
+	
+Poco::Timestamp HTTPResponse::getDate() const
+{
+	const std::string& dateTime = get(DATE);
+	int tzd;
+	return DateTimeParser::parse(dateTime, tzd).timestamp();
+}
+
+
+void HTTPResponse::addCookie(const HTTPCookie& cookie)
+{
+	add(SET_COOKIE, cookie.toString());
+}
+
+
+void HTTPResponse::getCookies(std::vector<HTTPCookie>& cookies) const
+{
+	cookies.clear();
+	NameValueCollection::ConstIterator it = find(SET_COOKIE);
+	while (it != end() && Poco::icompare(it->first, SET_COOKIE) == 0)
+	{
+		NameValueCollection nvc;
+		splitParameters(it->second.begin(), it->second.end(), nvc);
+		cookies.push_back(HTTPCookie(nvc));
+		++it;
+	}
+}
+
+
+void HTTPResponse::write(std::ostream& ostr) const
+{
+	beginWrite(ostr);
+	ostr << "\r\n";
+}
+
+
+void HTTPResponse::beginWrite(std::ostream& ostr) const
+{
+	ostr << getVersion() << " " << static_cast<int>(_status) << " " << _reason << "\r\n";
+	HTTPMessage::write(ostr);
+}
+
+
+void HTTPResponse::read(std::istream& istr)
+{
+	static const int eof = std::char_traits<char>::eof();
+
+	std::string version;
+	std::string status;
+	std::string reason;
+	
+	int ch =  istr.get();
+	if (istr.bad()) throw NetException("Error reading HTTP response header");
+	if (ch == eof) throw NoMessageException();
+	while (Poco::Ascii::isSpace(ch)) ch = istr.get();
+	if (ch == eof) throw MessageException("No HTTP response header");
+	while (!Poco::Ascii::isSpace(ch) && ch != eof && version.length() < MAX_VERSION_LENGTH) { version += (char) ch; ch = istr.get(); }
+	if (!Poco::Ascii::isSpace(ch)) throw MessageException("Invalid HTTP version string");
+	while (Poco::Ascii::isSpace(ch)) ch = istr.get();
+	while (!Poco::Ascii::isSpace(ch) && ch != eof && status.length() < MAX_STATUS_LENGTH) { status += (char) ch; ch = istr.get(); }
+	if (!Poco::Ascii::isSpace(ch)) throw MessageException("Invalid HTTP status code");
+	while (Poco::Ascii::isSpace(ch) && ch != '\r' && ch != '\n' && ch != eof) ch = istr.get();
+	while (ch != '\r' && ch != '\n' && ch != eof && reason.length() < MAX_REASON_LENGTH) { reason += (char) ch; ch = istr.get(); }
+	if (!Poco::Ascii::isSpace(ch)) throw MessageException("HTTP reason string too long");
+	if (ch == '\r') ch = istr.get();
+	if (ch != '\n') throw MessageException("Unterminated HTTP response line");
+
+	HTTPMessage::read(istr);
+	ch = istr.get();
+	while (ch != '\n' && ch != eof) { ch = istr.get(); }
+	setVersion(version);
+	setStatus(status);
+	setReason(reason);
+}
+
+
+const std::string& HTTPResponse::getReasonForStatus(HTTPStatus status)
+{
+	switch (status)
+	{
+	case HTTP_CONTINUE:
+		return HTTP_REASON_CONTINUE;
+	case HTTP_SWITCHING_PROTOCOLS:
+		return HTTP_REASON_SWITCHING_PROTOCOLS;
+	case HTTP_PROCESSING:
+		return HTTP_REASON_PROCESSING;
+	case HTTP_OK:
+		return HTTP_REASON_OK;
+	case HTTP_CREATED:
+		return HTTP_REASON_CREATED;
+	case HTTP_ACCEPTED:
+		return HTTP_REASON_ACCEPTED;
+	case HTTP_NONAUTHORITATIVE:	
+		return HTTP_REASON_NONAUTHORITATIVE;
+	case HTTP_NO_CONTENT:
+		return HTTP_REASON_NO_CONTENT;
+	case HTTP_RESET_CONTENT:
+		return HTTP_REASON_RESET_CONTENT;
+	case HTTP_PARTIAL_CONTENT:
+		return HTTP_REASON_PARTIAL_CONTENT;
+	case HTTP_MULTI_STATUS:
+		return HTTP_REASON_MULTI_STATUS;
+	case HTTP_ALREADY_REPORTED:
+		return HTTP_REASON_ALREADY_REPORTED;
+	case HTTP_IM_USED:
+		return HTTP_REASON_IM_USED;
+	case HTTP_MULTIPLE_CHOICES:
+		return HTTP_REASON_MULTIPLE_CHOICES;
+	case HTTP_MOVED_PERMANENTLY:
+		return HTTP_REASON_MOVED_PERMANENTLY;
+	case HTTP_FOUND:
+		return HTTP_REASON_FOUND;
+	case HTTP_SEE_OTHER:
+		return HTTP_REASON_SEE_OTHER;
+	case HTTP_NOT_MODIFIED:
+		return HTTP_REASON_NOT_MODIFIED;
+	case HTTP_USE_PROXY:
+		return HTTP_REASON_USE_PROXY;
+	case HTTP_TEMPORARY_REDIRECT:
+		return HTTP_REASON_TEMPORARY_REDIRECT;
+	case HTTP_BAD_REQUEST:
+		return HTTP_REASON_BAD_REQUEST;
+	case HTTP_UNAUTHORIZED:
+		return HTTP_REASON_UNAUTHORIZED;
+	case HTTP_PAYMENT_REQUIRED:
+		return HTTP_REASON_PAYMENT_REQUIRED;
+	case HTTP_FORBIDDEN:
+		return HTTP_REASON_FORBIDDEN;
+	case HTTP_NOT_FOUND:
+		return HTTP_REASON_NOT_FOUND;
+	case HTTP_METHOD_NOT_ALLOWED:
+		return HTTP_REASON_METHOD_NOT_ALLOWED;
+	case HTTP_NOT_ACCEPTABLE:
+		return HTTP_REASON_NOT_ACCEPTABLE;
+	case HTTP_PROXY_AUTHENTICATION_REQUIRED:
+		return HTTP_REASON_PROXY_AUTHENTICATION_REQUIRED;
+	case HTTP_REQUEST_TIMEOUT:
+		return HTTP_REASON_REQUEST_TIMEOUT;
+	case HTTP_CONFLICT:
+		return HTTP_REASON_CONFLICT;
+	case HTTP_GONE:
+		return HTTP_REASON_GONE;
+	case HTTP_LENGTH_REQUIRED:
+		return HTTP_REASON_LENGTH_REQUIRED;
+	case HTTP_PRECONDITION_FAILED:
+		return HTTP_REASON_PRECONDITION_FAILED;
+	case HTTP_REQUEST_ENTITY_TOO_LARGE:
+		return HTTP_REASON_REQUEST_ENTITY_TOO_LARGE;
+	case HTTP_REQUEST_URI_TOO_LONG:
+		return HTTP_REASON_REQUEST_URI_TOO_LONG;
+	case HTTP_UNSUPPORTED_MEDIA_TYPE:
+		return HTTP_REASON_UNSUPPORTED_MEDIA_TYPE;
+	case HTTP_REQUESTED_RANGE_NOT_SATISFIABLE:
+		return HTTP_REASON_REQUESTED_RANGE_NOT_SATISFIABLE;
+	case HTTP_EXPECTATION_FAILED:
+		return HTTP_REASON_EXPECTATION_FAILED;
+	case HTTP_IM_A_TEAPOT:
+		return HTTP_REASON_IM_A_TEAPOT;
+	case HTTP_ENCHANCE_YOUR_CALM:
+		return HTTP_REASON_ENCHANCE_YOUR_CALM;
+	case HTTP_MISDIRECTED_REQUEST:
+		return HTTP_REASON_MISDIRECTED_REQUEST;
+	case HTTP_UNPROCESSABLE_ENTITY:
+		return HTTP_REASON_UNPROCESSABLE_ENTITY;
+	case HTTP_LOCKED:
+		return HTTP_REASON_LOCKED;
+	case HTTP_FAILED_DEPENDENCY:
+		return HTTP_REASON_FAILED_DEPENDENCY;
+	case HTTP_UPGRADE_REQUIRED:
+		return HTTP_REASON_UPGRADE_REQUIRED;
+	case HTTP_PRECONDITION_REQUIRED:
+		return HTTP_REASON_PRECONDITION_REQUIRED;
+	case HTTP_TOO_MANY_REQUESTS:
+		return HTTP_REASON_TOO_MANY_REQUESTS;
+	case HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE:
+		return HTTP_REASON_REQUEST_HEADER_FIELDS_TOO_LARGE;
+	case HTTP_UNAVAILABLE_FOR_LEGAL_REASONS:
+		return HTTP_REASON_UNAVAILABLE_FOR_LEGAL_REASONS;
+	case HTTP_INTERNAL_SERVER_ERROR:
+		return HTTP_REASON_INTERNAL_SERVER_ERROR;
+	case HTTP_NOT_IMPLEMENTED:
+		return HTTP_REASON_NOT_IMPLEMENTED;
+	case HTTP_BAD_GATEWAY:
+		return HTTP_REASON_BAD_GATEWAY;
+	case HTTP_SERVICE_UNAVAILABLE:
+		return HTTP_REASON_SERVICE_UNAVAILABLE;
+	case HTTP_GATEWAY_TIMEOUT:
+		return HTTP_REASON_GATEWAY_TIMEOUT;
+	case HTTP_VERSION_NOT_SUPPORTED:
+		return HTTP_REASON_VERSION_NOT_SUPPORTED;
+	case HTTP_VARIANT_ALSO_NEGOTIATES:
+		return HTTP_REASON_VARIANT_ALSO_NEGOTIATES;
+	case HTTP_INSUFFICIENT_STORAGE:
+		return HTTP_REASON_INSUFFICIENT_STORAGE;
+	case HTTP_LOOP_DETECTED:
+		return HTTP_REASON_LOOP_DETECTED;
+	case HTTP_NOT_EXTENDED:
+		return HTTP_REASON_NOT_EXTENDED;
+	case HTTP_NETWORK_AUTHENTICATION_REQUIRED:
+		return HTTP_REASON_NETWORK_AUTHENTICATION_REQUIRED;
+	default:
+		return HTTP_REASON_UNKNOWN;
+	}
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPServer.cpp b/base/poco/Net/src/HTTPServer.cpp
new file mode 100644
index 00000000000..079dd800962
--- /dev/null
+++ b/base/poco/Net/src/HTTPServer.cpp
@@ -0,0 +1,59 @@
+//
+// HTTPServer.cpp
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPServer
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPServer.h"
+#include "Poco/Net/HTTPServerConnectionFactory.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPServer::HTTPServer(HTTPRequestHandlerFactory::Ptr pFactory, Poco::UInt16 portNumber, HTTPServerParams::Ptr pParams):
+	TCPServer(new HTTPServerConnectionFactory(pParams, pFactory), portNumber, pParams),
+	_pFactory(pFactory)
+{
+}
+
+
+HTTPServer::HTTPServer(HTTPRequestHandlerFactory::Ptr pFactory, const ServerSocket& socket, HTTPServerParams::Ptr pParams):
+	TCPServer(new HTTPServerConnectionFactory(pParams, pFactory), socket, pParams),
+	_pFactory(pFactory)
+{
+}
+
+
+HTTPServer::HTTPServer(HTTPRequestHandlerFactory::Ptr pFactory, Poco::ThreadPool& threadPool, const ServerSocket& socket, HTTPServerParams::Ptr pParams):
+	TCPServer(new HTTPServerConnectionFactory(pParams, pFactory), threadPool, socket, pParams),
+	_pFactory(pFactory)
+{
+}
+
+
+HTTPServer::~HTTPServer()
+{
+	/// We should call stop and join thread here instead of destructor of parent TCPHandler,
+	/// because there's possible race on 'vptr' between this virtual destructor and 'run' method.
+	stop();
+}
+
+
+void HTTPServer::stopAll(bool abortCurrent)
+{
+	stop();
+	_pFactory->serverStopped(this, abortCurrent);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPServerConnection.cpp b/base/poco/Net/src/HTTPServerConnection.cpp
new file mode 100644
index 00000000000..a6c27ce8c9e
--- /dev/null
+++ b/base/poco/Net/src/HTTPServerConnection.cpp
@@ -0,0 +1,180 @@
+//
+// HTTPServerConnection.cpp
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPServerConnection
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPServerConnection.h"
+#include "Poco/Net/HTTPServerSession.h"
+#include "Poco/Net/HTTPServerRequestImpl.h"
+#include "Poco/Net/HTTPServerResponseImpl.h"
+#include "Poco/Net/HTTPRequestHandler.h"
+#include "Poco/Net/HTTPRequestHandlerFactory.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/Timestamp.h"
+#include "Poco/Delegate.h"
+#include <memory>
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPServerConnection::HTTPServerConnection(const StreamSocket& socket, HTTPServerParams::Ptr pParams, HTTPRequestHandlerFactory::Ptr pFactory):
+	TCPServerConnection(socket),
+	_pParams(pParams),
+	_pFactory(pFactory),
+	_stopped(false)
+{
+	poco_check_ptr (pFactory);
+	
+	_pFactory->serverStopped += Poco::delegate(this, &HTTPServerConnection::onServerStopped);
+}
+
+
+HTTPServerConnection::~HTTPServerConnection()
+{
+	try
+	{
+		_pFactory->serverStopped -= Poco::delegate(this, &HTTPServerConnection::onServerStopped);
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void HTTPServerConnection::run()
+{
+	std::string server = _pParams->getSoftwareVersion();
+	HTTPServerSession session(socket(), _pParams);
+	while (!_stopped && session.hasMoreRequests())
+	{
+		try
+		{
+			Poco::FastMutex::ScopedLock lock(_mutex);
+			if (!_stopped)
+			{
+				HTTPServerResponseImpl response(session);
+				HTTPServerRequestImpl request(response, session, _pParams);
+			
+				Poco::Timestamp now;
+				response.setDate(now);
+				response.setVersion(request.getVersion());
+				response.setKeepAlive(_pParams->getKeepAlive() && request.getKeepAlive() && session.canKeepAlive());
+				if (!server.empty())
+					response.set("Server", server);
+				try
+				{
+#ifndef POCO_ENABLE_CPP11
+					std::auto_ptr<HTTPRequestHandler> pHandler(_pFactory->createRequestHandler(request));
+#else
+					std::unique_ptr<HTTPRequestHandler> pHandler(_pFactory->createRequestHandler(request));
+#endif
+					if (pHandler.get())
+					{
+						if (request.getExpectContinue() && response.getStatus() == HTTPResponse::HTTP_OK)
+							response.sendContinue();
+					
+						pHandler->handleRequest(request, response);
+						session.setKeepAlive(_pParams->getKeepAlive() && response.getKeepAlive() && session.canKeepAlive());
+					}
+					else sendErrorResponse(session, HTTPResponse::HTTP_NOT_IMPLEMENTED);
+				}
+				catch (Poco::Exception&)
+				{
+					if (!response.sent())
+					{
+						try
+						{
+							sendErrorResponse(session, HTTPResponse::HTTP_INTERNAL_SERVER_ERROR);
+						}
+						catch (...)
+						{
+						}
+					}
+					throw;
+				}
+			}
+		}
+		catch (NoMessageException&)
+		{
+			break;
+		}
+		catch (MessageException&)
+		{
+			sendErrorResponse(session, HTTPResponse::HTTP_BAD_REQUEST);
+		}
+		catch (Poco::Exception&)
+		{
+			if (session.networkException())
+			{
+				session.networkException()->rethrow();
+			}
+			else throw;
+		}
+	}
+}
+
+
+void HTTPServerConnection::sendErrorResponse(HTTPServerSession& session, HTTPResponse::HTTPStatus status)
+{
+	HTTPServerResponseImpl response(session);
+	response.setVersion(HTTPMessage::HTTP_1_1);
+	response.setStatusAndReason(status);
+	response.setKeepAlive(false);
+	response.send();
+	session.setKeepAlive(false);
+}
+
+
+void HTTPServerConnection::onServerStopped(const bool& abortCurrent)
+{
+	_stopped = true;
+	if (abortCurrent)
+	{
+		try
+		{
+			// Note: On Windows, select() will not return if one of its socket is being
+			// shut down. Therefore we have to call close(), which works better.
+			// On other platforms, we do the more graceful thing.
+#if defined(_WIN32)
+			socket().close();
+#else
+			socket().shutdown();
+#endif
+		}
+		catch (...)
+		{
+		}
+	}
+	else
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+
+		try
+		{
+#if defined(_WIN32)
+			socket().close();
+#else
+			socket().shutdown();
+#endif
+		}
+		catch (...)
+		{
+		}
+	}
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPServerConnectionFactory.cpp b/base/poco/Net/src/HTTPServerConnectionFactory.cpp
new file mode 100644
index 00000000000..8e17288f3b5
--- /dev/null
+++ b/base/poco/Net/src/HTTPServerConnectionFactory.cpp
@@ -0,0 +1,43 @@
+//
+// HTTPServerConnectionFactory.cpp
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPServerConnectionFactory
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPServerConnectionFactory.h"
+#include "Poco/Net/HTTPServerConnection.h"
+#include "Poco/Net/HTTPRequestHandlerFactory.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPServerConnectionFactory::HTTPServerConnectionFactory(HTTPServerParams::Ptr pParams, HTTPRequestHandlerFactory::Ptr pFactory):
+	_pParams(pParams),
+	_pFactory(pFactory)
+{
+	poco_check_ptr (pFactory);
+}
+
+
+HTTPServerConnectionFactory::~HTTPServerConnectionFactory()
+{
+}
+
+
+TCPServerConnection* HTTPServerConnectionFactory::createConnection(const StreamSocket& socket)
+{
+	return new HTTPServerConnection(socket, _pParams, _pFactory);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPServerParams.cpp b/base/poco/Net/src/HTTPServerParams.cpp
new file mode 100644
index 00000000000..cc871611111
--- /dev/null
+++ b/base/poco/Net/src/HTTPServerParams.cpp
@@ -0,0 +1,73 @@
+//
+// HTTPServerParams.cpp
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPServerParams
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPServerParams.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPServerParams::HTTPServerParams():
+	_timeout(60000000),
+	_keepAlive(true),
+	_maxKeepAliveRequests(0),
+	_keepAliveTimeout(15000000)
+{
+}
+
+
+HTTPServerParams::~HTTPServerParams()
+{
+}
+
+	
+void HTTPServerParams::setServerName(const std::string& serverName)
+{
+	_serverName = serverName;
+}
+	
+
+void HTTPServerParams::setSoftwareVersion(const std::string& softwareVersion)
+{
+	_softwareVersion = softwareVersion;
+}
+
+
+void HTTPServerParams::setTimeout(const Poco::Timespan& timeout)
+{
+	_timeout = timeout;
+}
+
+	
+void HTTPServerParams::setKeepAlive(bool keepAlive)
+{
+	_keepAlive = keepAlive;
+}
+
+	
+void HTTPServerParams::setKeepAliveTimeout(const Poco::Timespan& timeout)
+{
+	_keepAliveTimeout = timeout;
+}
+
+	
+void HTTPServerParams::setMaxKeepAliveRequests(int maxKeepAliveRequests)
+{
+	poco_assert (maxKeepAliveRequests >= 0);
+	_maxKeepAliveRequests = maxKeepAliveRequests;
+}
+	
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPServerRequest.cpp b/base/poco/Net/src/HTTPServerRequest.cpp
new file mode 100644
index 00000000000..de3d46481ac
--- /dev/null
+++ b/base/poco/Net/src/HTTPServerRequest.cpp
@@ -0,0 +1,32 @@
+//
+// HTTPServerRequest.cpp
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPServerRequest
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPServerRequest.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPServerRequest::HTTPServerRequest()
+{
+}
+
+
+HTTPServerRequest::~HTTPServerRequest()
+{
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPServerRequestImpl.cpp b/base/poco/Net/src/HTTPServerRequestImpl.cpp
new file mode 100644
index 00000000000..d8ea7398c9b
--- /dev/null
+++ b/base/poco/Net/src/HTTPServerRequestImpl.cpp
@@ -0,0 +1,88 @@
+//
+// HTTPServerRequestImpl.cpp
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPServerRequestImpl
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPServerRequestImpl.h"
+#include "Poco/Net/HTTPServerResponseImpl.h"
+#include "Poco/Net/HTTPServerSession.h"
+#include "Poco/Net/HTTPHeaderStream.h"
+#include "Poco/Net/HTTPStream.h"
+#include "Poco/Net/HTTPFixedLengthStream.h"
+#include "Poco/Net/HTTPChunkedStream.h"
+#include "Poco/Net/HTTPServerParams.h"
+#include "Poco/Net/StreamSocket.h"
+#include "Poco/String.h"
+
+
+using Poco::icompare;
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPServerRequestImpl::HTTPServerRequestImpl(HTTPServerResponseImpl& response, HTTPServerSession& session, HTTPServerParams* pParams):
+	_response(response),
+	_session(session),
+	_pStream(0),
+	_pParams(pParams, true)
+{
+	response.attachRequest(this);
+
+	HTTPHeaderInputStream hs(session);
+	read(hs);
+	
+	// Now that we know socket is still connected, obtain addresses
+	_clientAddress = session.clientAddress();
+	_serverAddress = session.serverAddress();
+	
+	if (getChunkedTransferEncoding())
+		_pStream = new HTTPChunkedInputStream(session);
+	else if (hasContentLength())
+#if defined(POCO_HAVE_INT64)
+		_pStream = new HTTPFixedLengthInputStream(session, getContentLength64());
+#else
+		_pStream = new HTTPFixedLengthInputStream(session, getContentLength());
+#endif
+	else if (getMethod() == HTTPRequest::HTTP_GET || getMethod() == HTTPRequest::HTTP_HEAD || getMethod() == HTTPRequest::HTTP_DELETE)
+		_pStream = new HTTPFixedLengthInputStream(session, 0);
+	else
+		_pStream = new HTTPInputStream(session);
+}
+
+
+HTTPServerRequestImpl::~HTTPServerRequestImpl()
+{
+	delete _pStream;
+}
+
+
+bool HTTPServerRequestImpl::secure() const
+{
+	return _session.socket().secure();
+}
+
+
+StreamSocket& HTTPServerRequestImpl::socket()
+{
+	return _session.socket();
+}
+
+
+StreamSocket HTTPServerRequestImpl::detachSocket()
+{
+	return _session.detachSocket();
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPServerResponse.cpp b/base/poco/Net/src/HTTPServerResponse.cpp
new file mode 100644
index 00000000000..e5550a3222f
--- /dev/null
+++ b/base/poco/Net/src/HTTPServerResponse.cpp
@@ -0,0 +1,32 @@
+//
+// HTTPServerResponse.cpp
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPServerResponse
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPServerResponse.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPServerResponse::HTTPServerResponse()
+{
+}
+
+
+HTTPServerResponse::~HTTPServerResponse()
+{
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPServerResponseImpl.cpp b/base/poco/Net/src/HTTPServerResponseImpl.cpp
new file mode 100644
index 00000000000..fb6783c633e
--- /dev/null
+++ b/base/poco/Net/src/HTTPServerResponseImpl.cpp
@@ -0,0 +1,221 @@
+//
+// HTTPServerResponseImpl.cpp
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPServerResponseImpl
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPServerResponseImpl.h"
+#include "Poco/Net/HTTPServerRequestImpl.h"
+#include "Poco/Net/HTTPServerSession.h"
+#include "Poco/Net/HTTPHeaderStream.h"
+#include "Poco/Net/HTTPStream.h"
+#include "Poco/Net/HTTPFixedLengthStream.h"
+#include "Poco/Net/HTTPChunkedStream.h"
+#include "Poco/File.h"
+#include "Poco/Timestamp.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/StreamCopier.h"
+#include "Poco/CountingStream.h"
+#include "Poco/Exception.h"
+#include "Poco/FileStream.h"
+#include "Poco/DateTimeFormatter.h"
+#include "Poco/DateTimeFormat.h"
+
+
+using Poco::File;
+using Poco::Timestamp;
+using Poco::NumberFormatter;
+using Poco::StreamCopier;
+using Poco::OpenFileException;
+using Poco::DateTimeFormatter;
+using Poco::DateTimeFormat;
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPServerResponseImpl::HTTPServerResponseImpl(HTTPServerSession& session):
+	_session(session),
+	_pRequest(0),
+	_pStream(0),
+	_pHeaderStream(0)
+{
+}
+
+
+HTTPServerResponseImpl::~HTTPServerResponseImpl()
+{
+	if (_pHeaderStream && _pHeaderStream != _pStream)
+		delete _pHeaderStream;
+	if (_pStream)
+		delete _pStream;
+}
+
+
+void HTTPServerResponseImpl::sendContinue()
+{
+	HTTPHeaderOutputStream hs(_session);
+	hs << getVersion() << " 100 Continue\r\n\r\n";
+}
+
+
+std::ostream& HTTPServerResponseImpl::send()
+{
+	poco_assert (!_pStream);
+
+	if ((_pRequest && _pRequest->getMethod() == HTTPRequest::HTTP_HEAD) ||
+		getStatus() < 200 ||
+		getStatus() == HTTPResponse::HTTP_NO_CONTENT ||
+		getStatus() == HTTPResponse::HTTP_NOT_MODIFIED)
+	{
+		Poco::CountingOutputStream cs;
+		write(cs);
+		_pStream = new HTTPFixedLengthOutputStream(_session, cs.chars());
+		write(*_pStream);
+	}
+	else if (getChunkedTransferEncoding())
+	{
+		HTTPHeaderOutputStream hs(_session);
+		write(hs);
+		_pStream = new HTTPChunkedOutputStream(_session);
+	}
+	else if (hasContentLength())
+	{
+		Poco::CountingOutputStream cs;
+		write(cs);
+#if defined(POCO_HAVE_INT64)	
+		_pStream = new HTTPFixedLengthOutputStream(_session, getContentLength64() + cs.chars());
+#else
+		_pStream = new HTTPFixedLengthOutputStream(_session, getContentLength() + cs.chars());
+#endif
+		write(*_pStream);
+	}
+	else
+	{
+		_pStream = new HTTPOutputStream(_session);
+		setKeepAlive(false);
+		write(*_pStream);
+	}
+	return *_pStream;
+}
+
+
+std::pair<std::ostream *, std::ostream *> HTTPServerResponseImpl::beginSend()
+{
+	poco_assert (!_pStream);
+	poco_assert (!_pHeaderStream);
+
+	// NOTE Code is not exception safe.
+
+	if ((_pRequest && _pRequest->getMethod() == HTTPRequest::HTTP_HEAD) ||
+		getStatus() < 200 ||
+		getStatus() == HTTPResponse::HTTP_NO_CONTENT ||
+		getStatus() == HTTPResponse::HTTP_NOT_MODIFIED)
+	{
+		throw Exception("HTTPServerResponse::beginSend is invalid for HEAD request");
+	}
+	else if (getChunkedTransferEncoding())
+	{
+		_pHeaderStream = new HTTPHeaderOutputStream(_session);
+		beginWrite(*_pHeaderStream);
+		_pStream = new HTTPChunkedOutputStream(_session);
+	}
+	else if (hasContentLength())
+	{
+		throw Exception("HTTPServerResponse::beginSend is invalid for response with Content-Length header");
+	}
+	else
+	{
+		_pStream = new HTTPOutputStream(_session);
+		_pHeaderStream = _pStream;
+		setKeepAlive(false);
+		beginWrite(*_pStream);
+	}
+
+	return std::make_pair(_pHeaderStream, _pStream);
+}
+
+
+void HTTPServerResponseImpl::sendFile(const std::string& path, const std::string& mediaType)
+{
+	poco_assert (!_pStream);
+
+	File f(path);
+	Timestamp dateTime    = f.getLastModified();
+	File::FileSize length = f.getSize();
+	set("Last-Modified", DateTimeFormatter::format(dateTime, DateTimeFormat::HTTP_FORMAT));
+#if defined(POCO_HAVE_INT64)	
+	setContentLength64(length);
+#else
+	setContentLength(static_cast<int>(length));
+#endif
+	setContentType(mediaType);
+	setChunkedTransferEncoding(false);
+
+	Poco::FileInputStream istr(path);
+	if (istr.good())
+	{
+		_pStream = new HTTPHeaderOutputStream(_session);
+		write(*_pStream);
+		if (_pRequest && _pRequest->getMethod() != HTTPRequest::HTTP_HEAD)
+		{
+			StreamCopier::copyStream(istr, *_pStream);
+		}
+	}
+	else throw OpenFileException(path);
+}
+
+
+void HTTPServerResponseImpl::sendBuffer(const void* pBuffer, std::size_t length)
+{
+	poco_assert (!_pStream);
+
+	setContentLength(static_cast<int>(length));
+	setChunkedTransferEncoding(false);
+	
+	_pStream = new HTTPHeaderOutputStream(_session);
+	write(*_pStream);
+	if (_pRequest && _pRequest->getMethod() != HTTPRequest::HTTP_HEAD)
+	{
+		_pStream->write(static_cast<const char*>(pBuffer), static_cast<std::streamsize>(length));
+	}
+}
+
+
+void HTTPServerResponseImpl::redirect(const std::string& uri, HTTPStatus status)
+{
+	poco_assert (!_pStream);
+
+	setContentLength(0);
+	setChunkedTransferEncoding(false);
+
+	setStatusAndReason(status);
+	set("Location", uri);
+
+	_pStream = new HTTPHeaderOutputStream(_session);
+	write(*_pStream);
+}
+
+
+void HTTPServerResponseImpl::requireAuthentication(const std::string& realm)
+{
+	poco_assert (!_pStream);
+	
+	setStatusAndReason(HTTPResponse::HTTP_UNAUTHORIZED);
+	std::string auth("Basic realm=\"");
+	auth.append(realm);
+	auth.append("\"");
+	set("WWW-Authenticate", auth);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPServerSession.cpp b/base/poco/Net/src/HTTPServerSession.cpp
new file mode 100644
index 00000000000..f6d3c4e5b92
--- /dev/null
+++ b/base/poco/Net/src/HTTPServerSession.cpp
@@ -0,0 +1,70 @@
+//
+// HTTPServerSession.cpp
+//
+// Library: Net
+// Package: HTTPServer
+// Module:  HTTPServerSession
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPServerSession.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPServerSession::HTTPServerSession(const StreamSocket& socket, HTTPServerParams::Ptr pParams):
+	HTTPSession(socket, pParams->getKeepAlive()),
+	_firstRequest(true),
+	_keepAliveTimeout(pParams->getKeepAliveTimeout()),
+	_maxKeepAliveRequests(pParams->getMaxKeepAliveRequests())
+{
+	setTimeout(pParams->getTimeout());
+	this->socket().setReceiveTimeout(pParams->getTimeout());
+}
+
+
+HTTPServerSession::~HTTPServerSession()
+{
+}
+
+
+bool HTTPServerSession::hasMoreRequests()
+{
+	if (!socket().impl()->initialized()) return false;
+
+	if (_firstRequest)
+	{
+		_firstRequest = false;
+		--_maxKeepAliveRequests;
+		return socket().poll(getTimeout(), Socket::SELECT_READ);
+	}
+	else if (_maxKeepAliveRequests != 0 && getKeepAlive())
+	{
+		if (_maxKeepAliveRequests > 0) 
+			--_maxKeepAliveRequests;
+		return buffered() > 0 || socket().poll(_keepAliveTimeout, Socket::SELECT_READ);
+	}
+	else return false;
+}
+
+
+SocketAddress HTTPServerSession::clientAddress()
+{
+	return socket().peerAddress();
+}
+
+
+SocketAddress HTTPServerSession::serverAddress()
+{
+	return socket().address();
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPSession.cpp b/base/poco/Net/src/HTTPSession.cpp
new file mode 100644
index 00000000000..cb6fdc25e9a
--- /dev/null
+++ b/base/poco/Net/src/HTTPSession.cpp
@@ -0,0 +1,261 @@
+//
+// HTTPSession.cpp
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPSession
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPSession.h"
+#include "Poco/Net/HTTPBufferAllocator.h"
+#include "Poco/Net/NetException.h"
+#include <cstring>
+
+
+using Poco::TimeoutException;
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPSession::HTTPSession():
+	_pBuffer(0),
+	_pCurrent(0),
+	_pEnd(0),
+	_keepAlive(false),
+	_connectionTimeout(HTTP_DEFAULT_CONNECTION_TIMEOUT),
+	_receiveTimeout(HTTP_DEFAULT_TIMEOUT),
+	_sendTimeout(HTTP_DEFAULT_TIMEOUT),
+	_pException(0)
+{
+}
+
+
+HTTPSession::HTTPSession(const StreamSocket& socket):
+	_socket(socket),
+	_pBuffer(0),
+	_pCurrent(0),
+	_pEnd(0),
+	_keepAlive(false),
+	_connectionTimeout(HTTP_DEFAULT_CONNECTION_TIMEOUT),
+	_receiveTimeout(HTTP_DEFAULT_TIMEOUT),
+	_sendTimeout(HTTP_DEFAULT_TIMEOUT),
+	_pException(0)
+{
+}
+
+
+HTTPSession::HTTPSession(const StreamSocket& socket, bool keepAlive):
+	_socket(socket),
+	_pBuffer(0),
+	_pCurrent(0),
+	_pEnd(0),
+	_keepAlive(keepAlive),
+	_connectionTimeout(HTTP_DEFAULT_CONNECTION_TIMEOUT),
+	_receiveTimeout(HTTP_DEFAULT_TIMEOUT),
+	_sendTimeout(HTTP_DEFAULT_TIMEOUT),
+	_pException(0)
+{
+}
+
+
+HTTPSession::~HTTPSession()
+{
+	try
+	{
+		if (_pBuffer) HTTPBufferAllocator::deallocate(_pBuffer, HTTPBufferAllocator::BUFFER_SIZE);
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+	try
+	{
+		close();
+	}
+	catch (...)
+	{
+	}
+	delete _pException;
+}
+
+
+void HTTPSession::setKeepAlive(bool keepAlive)
+{
+	_keepAlive = keepAlive;
+}
+
+
+void HTTPSession::setTimeout(const Poco::Timespan& timeout)
+{
+	setTimeout(timeout, timeout, timeout);
+}
+
+
+void HTTPSession::setTimeout(const Poco::Timespan& connectionTimeout, const Poco::Timespan& sendTimeout, const Poco::Timespan& receiveTimeout)
+{
+	 _connectionTimeout = connectionTimeout;
+	 _sendTimeout = sendTimeout;
+	 _receiveTimeout = receiveTimeout;
+}
+
+
+int HTTPSession::get()
+{
+	if (_pCurrent == _pEnd)
+		refill();
+	
+	if (_pCurrent < _pEnd)
+		return *_pCurrent++;
+	else
+		return std::char_traits<char>::eof();
+}
+
+	
+int HTTPSession::peek()
+{
+	if (_pCurrent == _pEnd)
+		refill();
+
+	if (_pCurrent < _pEnd)
+		return *_pCurrent;
+	else
+		return std::char_traits<char>::eof();
+}
+
+	
+int HTTPSession::read(char* buffer, std::streamsize length)
+{
+	if (_pCurrent < _pEnd)
+	{
+		int n = (int) (_pEnd - _pCurrent);
+		if (n > length) n = (int) length;
+		std::memcpy(buffer, _pCurrent, n);
+		_pCurrent += n;
+		return n;
+	}
+	else return receive(buffer, (int) length);
+}
+
+
+int HTTPSession::write(const char* buffer, std::streamsize length)
+{
+	try
+	{
+		return _socket.sendBytes(buffer, (int) length);
+	}
+	catch (Poco::Exception& exc)
+	{
+		setException(exc);
+		throw;
+	}
+}
+
+
+int HTTPSession::receive(char* buffer, int length)
+{
+	try
+	{
+		return _socket.receiveBytes(buffer, length);
+	}
+	catch (Poco::Exception& exc)
+	{
+		setException(exc);
+		throw;
+	}
+}
+
+
+void HTTPSession::refill()
+{
+	if (!_pBuffer)
+	{
+		_pBuffer = HTTPBufferAllocator::allocate(HTTPBufferAllocator::BUFFER_SIZE);
+	}
+	_pCurrent = _pEnd = _pBuffer;
+	int n = receive(_pBuffer, HTTPBufferAllocator::BUFFER_SIZE);
+	_pEnd += n;
+}
+
+
+bool HTTPSession::connected() const
+{
+	return _socket.impl()->initialized();
+}
+
+
+void HTTPSession::connect(const SocketAddress& address)
+{
+	_socket.connect(address, _connectionTimeout);
+	_socket.setReceiveTimeout(_receiveTimeout);
+	_socket.setSendTimeout(_sendTimeout);
+	_socket.setNoDelay(true);
+	// There may be leftover data from a previous (failed) request in the buffer,
+	// so we clear it.
+	_pCurrent = _pEnd = _pBuffer;
+}
+
+
+void HTTPSession::abort()
+{
+	_socket.shutdown();
+	close();
+}
+
+
+void HTTPSession::close()
+{
+	_socket.close();
+}
+
+
+void HTTPSession::setException(const Poco::Exception& exc)
+{
+	delete _pException;
+	_pException = exc.clone();
+}
+
+
+void HTTPSession::clearException()
+{
+	delete _pException;
+	_pException = 0;
+}
+
+
+StreamSocket HTTPSession::detachSocket()
+{
+	StreamSocket oldSocket(_socket);
+	StreamSocket newSocket;
+	_socket = newSocket;
+	return oldSocket;
+}
+
+
+void HTTPSession::attachSocket(const StreamSocket& socket)
+{
+	_socket = socket;
+}
+
+
+void HTTPSession::attachSessionData(const Poco::Any& data)
+{
+	_data = data;
+}
+
+
+void HTTPSession::drainBuffer(Poco::Buffer<char>& buffer)
+{
+	buffer.assign(_pCurrent, static_cast<std::size_t>(_pEnd - _pCurrent));
+	_pCurrent = _pEnd;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPSessionFactory.cpp b/base/poco/Net/src/HTTPSessionFactory.cpp
new file mode 100644
index 00000000000..e4a62da68b0
--- /dev/null
+++ b/base/poco/Net/src/HTTPSessionFactory.cpp
@@ -0,0 +1,146 @@
+//
+// HTTPSessionFactory.cpp
+//
+// Library: Net
+// Package: HTTPClient
+// Module:  HTTPSessionFactory
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPSessionFactory.h"
+#include "Poco/Net/HTTPSessionInstantiator.h"
+#include "Poco/Exception.h"
+
+
+using Poco::SingletonHolder;
+using Poco::FastMutex;
+using Poco::NotFoundException;
+using Poco::ExistsException;
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPSessionFactory::HTTPSessionFactory():
+	_proxyPort(0)
+{
+}
+
+
+HTTPSessionFactory::HTTPSessionFactory(const std::string& proxyHost, Poco::UInt16 proxyPort):
+	_proxyHost(proxyHost),
+	_proxyPort(proxyPort)
+{
+}
+
+
+HTTPSessionFactory::~HTTPSessionFactory()
+{
+	for (Instantiators::iterator it = _instantiators.begin(); it != _instantiators.end(); ++it)
+	{
+		delete it->second.pIn;
+	}
+}
+
+
+void HTTPSessionFactory::registerProtocol(const std::string& protocol, HTTPSessionInstantiator* pSessionInstantiator)
+{
+	poco_assert_dbg(pSessionInstantiator);
+
+	FastMutex::ScopedLock lock(_mutex);
+	std::pair<Instantiators::iterator, bool> tmp = _instantiators.insert(make_pair(protocol, InstantiatorInfo(pSessionInstantiator)));
+	if (!tmp.second) 
+	{
+		++tmp.first->second.cnt;
+		delete pSessionInstantiator;
+	}
+}
+
+
+void HTTPSessionFactory::unregisterProtocol(const std::string& protocol)
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	Instantiators::iterator it = _instantiators.find(protocol);
+	if (it != _instantiators.end())
+	{
+		if (it->second.cnt == 1)
+		{
+			delete it->second.pIn;
+			_instantiators.erase(it);
+		}
+		else --it->second.cnt;
+	}
+	else throw NotFoundException("No HTTPSessionInstantiator registered for", protocol);
+}
+
+
+bool HTTPSessionFactory::supportsProtocol(const std::string& protocol)
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	Instantiators::iterator it = _instantiators.find(protocol);
+	return it != _instantiators.end();
+}
+
+
+HTTPClientSession* HTTPSessionFactory::createClientSession(const Poco::URI& uri)
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	if (uri.isRelative()) throw Poco::UnknownURISchemeException("Relative URIs are not supported by HTTPSessionFactory.");
+
+	Instantiators::iterator it = _instantiators.find(uri.getScheme());
+	if (it != _instantiators.end())
+	{
+		it->second.pIn->setProxy(_proxyHost, _proxyPort);
+		it->second.pIn->setProxyCredentials(_proxyUsername, _proxyPassword);
+		return it->second.pIn->createClientSession(uri);
+	}
+	else throw Poco::UnknownURISchemeException(uri.getScheme());
+}
+
+
+void HTTPSessionFactory::setProxy(const std::string& host, Poco::UInt16 port)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	_proxyHost = host;
+	_proxyPort = port;
+}
+
+
+void HTTPSessionFactory::setProxyCredentials(const std::string& username, const std::string& password)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	_proxyUsername = username;
+	_proxyPassword = password;
+}
+
+
+namespace
+{
+	static SingletonHolder<HTTPSessionFactory> singleton;
+}
+
+
+HTTPSessionFactory& HTTPSessionFactory::defaultFactory()
+{
+	return *singleton.get();
+}
+
+
+HTTPSessionFactory::InstantiatorInfo::InstantiatorInfo(HTTPSessionInstantiator* pInst): pIn(pInst), cnt(1)
+{
+	poco_check_ptr (pIn);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPSessionInstantiator.cpp b/base/poco/Net/src/HTTPSessionInstantiator.cpp
new file mode 100644
index 00000000000..d2f291f6b52
--- /dev/null
+++ b/base/poco/Net/src/HTTPSessionInstantiator.cpp
@@ -0,0 +1,77 @@
+//
+// HTTPSessionInstantiator.cpp
+//
+// Library: Net
+// Package: HTTPClient
+// Module:  HTTPSessionInstantiator
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPSessionInstantiator.h"
+#include "Poco/Net/HTTPSessionFactory.h"
+#include "Poco/Net/HTTPClientSession.h"
+
+
+using Poco::URI;
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPSessionInstantiator::HTTPSessionInstantiator():
+	_proxyPort(0)
+{
+}
+
+
+HTTPSessionInstantiator::~HTTPSessionInstantiator()
+{
+}
+
+
+HTTPClientSession* HTTPSessionInstantiator::createClientSession(const Poco::URI& uri)
+{
+	poco_assert (uri.getScheme() == "http");
+	HTTPClientSession* pSession = new HTTPClientSession(uri.getHost(), uri.getPort());
+	if (!proxyHost().empty())
+	{
+		pSession->setProxy(proxyHost(), proxyPort());
+		pSession->setProxyCredentials(proxyUsername(), proxyPassword());
+	}
+	return pSession;
+}
+
+
+void HTTPSessionInstantiator::registerInstantiator()
+{
+	HTTPSessionFactory::defaultFactory().registerProtocol("http", new HTTPSessionInstantiator);
+}
+
+
+void HTTPSessionInstantiator::unregisterInstantiator()
+{
+	HTTPSessionFactory::defaultFactory().unregisterProtocol("http");
+}
+
+
+void HTTPSessionInstantiator::setProxy(const std::string& host, Poco::UInt16 port)
+{
+	_proxyHost = host;
+	_proxyPort = port;
+}
+
+
+void HTTPSessionInstantiator::setProxyCredentials(const std::string& username, const std::string& password)
+{
+	_proxyUsername = username;
+	_proxyPassword = password;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPStream.cpp b/base/poco/Net/src/HTTPStream.cpp
new file mode 100644
index 00000000000..4acb881c4f3
--- /dev/null
+++ b/base/poco/Net/src/HTTPStream.cpp
@@ -0,0 +1,173 @@
+//
+// HTTPStream.cpp
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPStream
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPStream.h"
+#include "Poco/Net/HTTPSession.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+//
+// HTTPStreamBuf
+//
+
+
+HTTPStreamBuf::HTTPStreamBuf(HTTPSession& session, openmode mode):
+	HTTPBasicStreamBuf(HTTPBufferAllocator::BUFFER_SIZE, mode),
+	_session(session),
+	_mode(mode)
+{
+}
+
+
+HTTPStreamBuf::~HTTPStreamBuf()
+{
+}
+
+
+void HTTPStreamBuf::close()
+{
+	if (_mode & std::ios::out)
+	{
+		sync();
+		if (!_session.getKeepAlive())
+		    _session.socket().shutdownSend();
+	}
+}
+
+
+int HTTPStreamBuf::readFromDevice(char* buffer, std::streamsize length)
+{
+	return _session.read(buffer, length);
+}
+
+
+int HTTPStreamBuf::writeToDevice(const char* buffer, std::streamsize length)
+{
+
+	return _session.write(buffer, length);
+}
+
+
+//
+// HTTPIOS
+//
+
+
+HTTPIOS::HTTPIOS(HTTPSession& session, HTTPStreamBuf::openmode mode):
+	_buf(session, mode)
+{
+	poco_ios_init(&_buf);
+}
+
+
+HTTPIOS::~HTTPIOS()
+{
+	try
+	{
+		_buf.close();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+HTTPStreamBuf* HTTPIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+//
+// HTTPInputStream
+//
+
+
+Poco::MemoryPool HTTPInputStream::_pool(sizeof(HTTPInputStream));
+
+
+HTTPInputStream::HTTPInputStream(HTTPSession& session):
+	HTTPIOS(session, std::ios::in),
+	std::istream(&_buf)
+{
+}
+
+
+HTTPInputStream::~HTTPInputStream()
+{
+}
+
+
+void* HTTPInputStream::operator new(std::size_t size)
+{
+	return _pool.get();
+}
+
+
+void HTTPInputStream::operator delete(void* ptr)
+{
+	try
+	{
+		_pool.release(ptr);
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+//
+// HTTPOutputStream
+//
+
+
+Poco::MemoryPool HTTPOutputStream::_pool(sizeof(HTTPOutputStream));
+
+
+HTTPOutputStream::HTTPOutputStream(HTTPSession& session):
+	HTTPIOS(session, std::ios::out),
+	std::ostream(&_buf)
+{
+}
+
+
+HTTPOutputStream::~HTTPOutputStream()
+{
+}
+
+
+void* HTTPOutputStream::operator new(std::size_t size)
+{
+	return _pool.get();
+}
+
+
+void HTTPOutputStream::operator delete(void* ptr)
+{
+	try
+	{
+		_pool.release(ptr);
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HTTPStreamFactory.cpp b/base/poco/Net/src/HTTPStreamFactory.cpp
new file mode 100644
index 00000000000..ee77d98ec4d
--- /dev/null
+++ b/base/poco/Net/src/HTTPStreamFactory.cpp
@@ -0,0 +1,187 @@
+//
+// HTTPStreamFactory.cpp
+//
+// Library: Net
+// Package: HTTP
+// Module:  HTTPStreamFactory
+//
+// Copyright (c) 2005-2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPStreamFactory.h"
+#include "Poco/Net/HTTPClientSession.h"
+#include "Poco/Net/HTTPIOStream.h"
+#include "Poco/Net/HTTPRequest.h"
+#include "Poco/Net/HTTPResponse.h"
+#include "Poco/Net/HTTPCredentials.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/URI.h"
+#include "Poco/URIStreamOpener.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include "Poco/NullStream.h"
+#include "Poco/StreamCopier.h"
+#include "Poco/Format.h"
+#include "Poco/Version.h"
+
+
+using Poco::URIStreamFactory;
+using Poco::URI;
+using Poco::URIStreamOpener;
+using Poco::UnbufferedStreamBuf;
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPStreamFactory::HTTPStreamFactory():
+	_proxyPort(HTTPSession::HTTP_PORT)
+{
+}
+
+
+HTTPStreamFactory::HTTPStreamFactory(const std::string& proxyHost, Poco::UInt16 proxyPort):
+	_proxyHost(proxyHost),
+	_proxyPort(proxyPort)
+{
+}
+
+
+HTTPStreamFactory::HTTPStreamFactory(const std::string& proxyHost, Poco::UInt16 proxyPort, const std::string& proxyUsername, const std::string& proxyPassword):
+	_proxyHost(proxyHost),
+	_proxyPort(proxyPort),
+	_proxyUsername(proxyUsername),
+	_proxyPassword(proxyPassword)
+{
+}
+
+
+HTTPStreamFactory::~HTTPStreamFactory()
+{
+}
+
+
+std::istream* HTTPStreamFactory::open(const URI& uri)
+{
+	poco_assert (uri.getScheme() == "http");
+
+	URI resolvedURI(uri);
+	URI proxyUri;
+	HTTPClientSession* pSession = 0;
+	HTTPResponse res;
+	bool retry = false;
+	bool authorize = false;
+	std::string username;
+	std::string password;
+
+	try
+	{
+		do
+		{
+			if (!pSession)
+			{
+				pSession = new HTTPClientSession(resolvedURI.getHost(), resolvedURI.getPort());
+			
+				if (proxyUri.empty())
+				{
+					if (!_proxyHost.empty())
+					{
+						pSession->setProxy(_proxyHost, _proxyPort);
+						pSession->setProxyCredentials(_proxyUsername, _proxyPassword);
+					}
+				}
+				else
+				{
+					pSession->setProxy(proxyUri.getHost(), proxyUri.getPort());
+					if (!_proxyUsername.empty())
+					{
+						pSession->setProxyCredentials(_proxyUsername, _proxyPassword);
+					}
+				}
+			}
+						
+			std::string path = resolvedURI.getPathAndQuery();
+			if (path.empty()) path = "/";
+			HTTPRequest req(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1);
+			
+			if (authorize)
+			{
+				HTTPCredentials::extractCredentials(uri, username, password);
+				HTTPCredentials cred(username, password);
+				cred.authenticate(req, res);
+			}
+			
+			req.set("User-Agent", Poco::format("poco/%d.%d.%d", 
+				(POCO_VERSION >> 24) & 0xFF,
+				(POCO_VERSION >> 16) & 0xFF,
+				(POCO_VERSION >> 8) & 0xFF));
+			req.set("Accept", "*/*");
+			
+			pSession->sendRequest(req);
+			std::istream& rs = pSession->receiveResponse(res);
+			bool moved = (res.getStatus() == HTTPResponse::HTTP_MOVED_PERMANENTLY || 
+						  res.getStatus() == HTTPResponse::HTTP_FOUND || 
+						  res.getStatus() == HTTPResponse::HTTP_SEE_OTHER ||
+						  res.getStatus() == HTTPResponse::HTTP_TEMPORARY_REDIRECT);
+			if (moved)
+			{
+				resolvedURI.resolve(res.get("Location"));
+				if (!username.empty())
+				{
+					resolvedURI.setUserInfo(username + ":" + password);
+				}
+				throw URIRedirection(resolvedURI.toString());
+			}
+			else if (res.getStatus() == HTTPResponse::HTTP_OK)
+			{
+				return new HTTPResponseStream(rs, pSession);
+			}
+			else if (res.getStatus() == HTTPResponse::HTTP_USE_PROXY && !retry)
+			{
+				// The requested resource MUST be accessed through the proxy 
+				// given by the Location field. The Location field gives the 
+				// URI of the proxy. The recipient is expected to repeat this 
+				// single request via the proxy. 305 responses MUST only be generated by origin servers.
+				// only use for one single request!
+				proxyUri.resolve(res.get("Location"));
+				delete pSession; 
+				pSession = 0;
+				retry = true; // only allow useproxy once
+			}
+			else if (res.getStatus() == HTTPResponse::HTTP_UNAUTHORIZED && !authorize)
+			{
+				authorize = true;
+				retry = true;
+				Poco::NullOutputStream null;
+				Poco::StreamCopier::copyStream(rs, null);
+			}
+			else throw HTTPException(res.getReason(), uri.toString());
+		}
+		while (retry);
+		throw HTTPException("Too many redirects", uri.toString());
+	}
+	catch (...)
+	{
+		delete pSession;
+		throw;
+	}
+}
+
+
+void HTTPStreamFactory::registerFactory()
+{
+	URIStreamOpener::defaultOpener().registerStreamFactory("http", new HTTPStreamFactory);
+}
+
+
+void HTTPStreamFactory::unregisterFactory()
+{
+	URIStreamOpener::defaultOpener().unregisterStreamFactory("http");
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/HostEntry.cpp b/base/poco/Net/src/HostEntry.cpp
new file mode 100644
index 00000000000..3257c703113
--- /dev/null
+++ b/base/poco/Net/src/HostEntry.cpp
@@ -0,0 +1,135 @@
+//
+// HostEntry.cpp
+//
+// Library: Net
+// Package: NetCore
+// Module:  HostEntry
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HostEntry.h"
+#include "Poco/Exception.h"
+#include <algorithm>
+
+
+namespace Poco {
+namespace Net {
+
+
+HostEntry::HostEntry()
+{
+}
+
+	
+HostEntry::HostEntry(struct hostent* entry)
+{
+	poco_check_ptr (entry);
+	
+	_name = entry->h_name;	
+	char** alias = entry->h_aliases;
+	if (alias)
+	{
+		while (*alias)
+		{
+			_aliases.push_back(std::string(*alias));
+			++alias;
+		}
+	}
+	char** address = entry->h_addr_list;
+	if (address)
+	{
+		while (*address)
+		{
+			_addresses.push_back(IPAddress(*address, entry->h_length));
+			++address;
+		}
+	}
+}
+
+
+#if defined(POCO_HAVE_IPv6) || defined(POCO_HAVE_ADDRINFO)
+
+
+HostEntry::HostEntry(struct addrinfo* ainfo)
+{
+	poco_check_ptr (ainfo);
+	
+	for (struct addrinfo* ai = ainfo; ai; ai = ai->ai_next)
+	{
+		if (ai->ai_canonname)
+		{
+			_name.assign(ai->ai_canonname);
+		}
+		if (ai->ai_addrlen && ai->ai_addr)
+		{
+			switch (ai->ai_addr->sa_family)
+			{
+			case AF_INET:
+				_addresses.push_back(IPAddress(&reinterpret_cast<struct sockaddr_in*>(ai->ai_addr)->sin_addr, sizeof(in_addr)));
+				break;
+#if defined(POCO_HAVE_IPv6)
+			case AF_INET6:
+				_addresses.push_back(IPAddress(&reinterpret_cast<struct sockaddr_in6*>(ai->ai_addr)->sin6_addr, sizeof(in6_addr), reinterpret_cast<struct sockaddr_in6*>(ai->ai_addr)->sin6_scope_id));
+				break;
+#endif
+			}
+		}
+	}
+}
+
+
+#endif // POCO_HAVE_IPv6
+
+
+#if defined(POCO_VXWORKS)
+
+
+HostEntry::HostEntry(const std::string& name, const IPAddress& addr):
+	_name(name)
+{
+	_addresses.push_back(addr);
+}
+
+
+#endif // POCO_VXWORKS
+
+
+HostEntry::HostEntry(const HostEntry& entry):
+	_name(entry._name),
+	_aliases(entry._aliases),
+	_addresses(entry._addresses)
+{
+}
+
+
+HostEntry& HostEntry::operator = (const HostEntry& entry)
+{
+	if (&entry != this)
+	{
+		_name      = entry._name;
+		_aliases   = entry._aliases;
+		_addresses = entry._addresses;
+	}
+	return *this;
+}
+
+
+void HostEntry::swap(HostEntry& hostEntry)
+{
+	std::swap(_name, hostEntry._name);
+	std::swap(_aliases, hostEntry._aliases);
+	std::swap(_addresses, hostEntry._addresses);
+}
+
+
+HostEntry::~HostEntry()
+{
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/ICMPClient.cpp b/base/poco/Net/src/ICMPClient.cpp
new file mode 100644
index 00000000000..4639d6a5fa4
--- /dev/null
+++ b/base/poco/Net/src/ICMPClient.cpp
@@ -0,0 +1,150 @@
+//
+// ICMPClient.cpp
+//
+// Library: Net
+// Package: ICMP
+// Module:  ICMPClient
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/Net/ICMPClient.h"
+#include "Poco/Net/ICMPSocket.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Channel.h"
+#include "Poco/Message.h"
+#include "Poco/Exception.h"
+#include <sstream>
+
+
+using Poco::Channel;
+using Poco::Message;
+using Poco::InvalidArgumentException;
+using Poco::NotImplementedException;
+using Poco::TimeoutException;
+using Poco::Exception;
+
+
+namespace Poco {
+namespace Net {
+
+
+ICMPClient::ICMPClient(SocketAddress::Family family, int dataSize, int ttl, int timeout):
+	_family(family),
+	_dataSize(dataSize),
+	_ttl(ttl),
+	_timeout(timeout)
+{
+}
+
+
+ICMPClient::~ICMPClient()
+{
+}
+
+
+int ICMPClient::ping(const std::string& address, int repeat) const
+{
+	if (repeat <= 0) return 0;
+
+	SocketAddress addr(address, 0);
+	return ping(addr, repeat);
+}
+
+
+int ICMPClient::ping(SocketAddress& address, int repeat) const
+{
+	if (repeat <= 0) return 0;
+
+	ICMPSocket icmpSocket(_family, _dataSize, _ttl, _timeout);
+	SocketAddress returnAddress;
+
+	ICMPEventArgs eventArgs(address, repeat, icmpSocket.dataSize(), icmpSocket.ttl());
+	pingBegin.notify(this, eventArgs);
+
+	for (int i = 0; i < repeat; ++i)
+	{
+		icmpSocket.sendTo(address);
+		++eventArgs;
+
+		try
+		{
+			int t = icmpSocket.receiveFrom(returnAddress);
+			eventArgs.setReplyTime(i, t);
+			pingReply.notify(this, eventArgs);
+		}
+		catch (TimeoutException&)
+		{
+			std::ostringstream os;
+			os << address.host().toString() << ": Request timed out.";
+			eventArgs.setError(i, os.str());
+			pingError.notify(this, eventArgs);
+			continue;
+		}
+		catch (ICMPException& ex)
+		{
+			std::ostringstream os;
+			os << address.host().toString() << ": " << ex.what();
+			eventArgs.setError(i, os.str());
+			pingError.notify(this, eventArgs);
+			continue;
+		}
+		catch (Exception& ex)
+		{
+			std::ostringstream os;
+			os << ex.displayText();
+			eventArgs.setError(i, os.str());
+			pingError.notify(this, eventArgs);
+			continue;
+		}
+	}
+	pingEnd.notify(this, eventArgs);
+	return eventArgs.received();
+}
+
+
+int ICMPClient::pingIPv4(const std::string& address, int repeat,
+	int dataSize, int ttl, int timeout)
+{
+	if (repeat <= 0) return 0;
+
+	SocketAddress a(address, 0);
+	return ping(a, IPAddress::IPv4, repeat, dataSize, ttl, timeout);
+}
+
+
+int ICMPClient::ping(SocketAddress& address,
+	IPAddress::Family family, int repeat,
+	int dataSize, int ttl, int timeout)
+{
+	if (repeat <= 0) return 0;
+
+	ICMPSocket icmpSocket(family, dataSize, ttl, timeout);
+	SocketAddress returnAddress;
+	int received = 0;
+
+	for (int i = 0; i < repeat; ++i)
+	{
+		icmpSocket.sendTo(address);
+		try
+		{
+			icmpSocket.receiveFrom(returnAddress);
+			++received;
+		}
+		catch (TimeoutException&)
+		{
+		}
+		catch (ICMPException&)
+		{
+		}
+	}
+	return received;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/ICMPEventArgs.cpp b/base/poco/Net/src/ICMPEventArgs.cpp
new file mode 100644
index 00000000000..3a219f9d741
--- /dev/null
+++ b/base/poco/Net/src/ICMPEventArgs.cpp
@@ -0,0 +1,168 @@
+//
+// ICMPEventArgs.cpp
+//
+// Library: Net
+// Package: ICMP
+// Module:  ICMPEventArgs
+//
+// Implementation of ICMPEventArgs
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/ICMPEventArgs.h"
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/Net/DNS.h"
+#include "Poco/Exception.h"
+#include "Poco/Net/NetException.h"
+#include <numeric>
+
+
+using Poco::IOException;
+using Poco::InvalidArgumentException;
+
+
+namespace Poco {
+namespace Net {
+
+
+ICMPEventArgs::ICMPEventArgs(const SocketAddress& address, int repetitions, int dataSize, int ttl):
+	_address(address), 
+	_sent(0),
+	_dataSize(dataSize), 
+	_ttl(ttl), 
+	_rtt(repetitions, 0), 
+	_errors(repetitions)
+{
+}
+
+
+ICMPEventArgs::~ICMPEventArgs()
+{
+}
+
+
+std::string ICMPEventArgs::hostName() const
+{
+	try
+	{
+		return DNS::resolve(_address.host().toString()).name();
+	}
+	catch (HostNotFoundException&) 
+	{
+	}
+	catch (NoAddressFoundException&) 
+	{
+	}
+	catch (DNSException&)
+	{
+	}
+	catch (IOException&)
+	{
+	}
+	return _address.host().toString();
+}
+
+
+std::string ICMPEventArgs::hostAddress() const
+{
+	return _address.host().toString();
+}
+
+
+void ICMPEventArgs::setRepetitions(int repetitions)
+{
+	_rtt.clear();
+	_rtt.resize(repetitions, 0);
+	_errors.assign(repetitions, "");
+}
+
+
+ICMPEventArgs& ICMPEventArgs::operator ++ ()
+{
+	++_sent;
+	return *this;
+}
+
+
+ICMPEventArgs ICMPEventArgs::operator ++ (int)
+{
+	ICMPEventArgs prev(*this);
+	operator ++ ();
+	return prev;
+}
+
+
+int ICMPEventArgs::received() const
+{
+	int received = 0;
+
+	for (int i = 0; i < _rtt.size(); ++i) 
+	{
+		if (_rtt[i]) ++received;
+	}
+	return received;
+}
+
+
+void ICMPEventArgs::setError(int index, const std::string& text)
+{
+	if (index >= _errors.size()) 
+		throw InvalidArgumentException("Supplied index exceeds vector capacity.");
+
+	_errors[index] = text;
+}
+
+
+const std::string& ICMPEventArgs::error(int index) const
+{
+	if (0 == _errors.size()) 
+		throw InvalidArgumentException("Supplied index exceeds vector capacity.");
+
+	if (-1 == index) index = _sent - 1;
+
+	return _errors[index];
+}
+
+
+void ICMPEventArgs::setReplyTime(int index, int time)
+{
+	if (index >= _rtt.size()) 
+		throw InvalidArgumentException("Supplied index exceeds array capacity.");
+	if (0 == time) time = 1;
+	_rtt[index] = time;
+}
+
+
+int ICMPEventArgs::replyTime(int index) const
+{
+	if (0 == _rtt.size()) 
+		throw InvalidArgumentException("Supplied index exceeds array capacity.");
+
+	if (-1 == index) index = _sent - 1;
+
+	return _rtt[index];
+}
+
+
+int ICMPEventArgs::avgRTT() const
+{
+	if (0 == _rtt.size()) return 0;
+	
+	return (int) (std::accumulate(_rtt.begin(), _rtt.end(), 0) / _rtt.size());
+}
+
+
+float ICMPEventArgs::percent() const
+{
+	if (0 == _rtt.size()) return 0;
+
+	return ((float) received() / (float) _rtt.size()) * (float) 100.0;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/ICMPPacket.cpp b/base/poco/Net/src/ICMPPacket.cpp
new file mode 100644
index 00000000000..a05f7260f4c
--- /dev/null
+++ b/base/poco/Net/src/ICMPPacket.cpp
@@ -0,0 +1,110 @@
+//
+// ICMPPacket.cpp
+//
+// Library: Net
+// Package: ICMP
+// Module:  ICMPPacket
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/ICMPPacket.h"
+#include "Poco/Net/ICMPv4PacketImpl.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Timestamp.h"
+#include "Poco/Timespan.h"
+#include "Poco/NumberFormatter.h"
+#include <sstream>
+
+
+using Poco::InvalidArgumentException;
+using Poco::NotImplementedException;
+using Poco::Timestamp;
+using Poco::Timespan;
+using Poco::NumberFormatter;
+using Poco::UInt8;
+using Poco::UInt16;
+using Poco::Int32;
+
+
+namespace Poco {
+namespace Net {
+
+
+ICMPPacket::ICMPPacket(IPAddress::Family family, int dataSize):_pImpl(0)
+{
+	if (family == IPAddress::IPv4)
+		_pImpl = new ICMPv4PacketImpl(dataSize);
+#if defined(POCO_HAVE_IPv6)
+	else if (family == IPAddress::IPv6)
+		throw NotImplementedException("ICMPv6 packets not implemented.");
+#endif
+	else throw InvalidArgumentException("Invalid or unsupported address family passed to ICMPPacket");
+}
+
+
+ICMPPacket::~ICMPPacket()
+{
+	delete _pImpl;
+}
+
+
+void ICMPPacket::setDataSize(int dataSize)
+{
+	_pImpl->setDataSize(dataSize);
+}
+
+
+int ICMPPacket::getDataSize() const
+{
+	return _pImpl->getDataSize();
+}
+
+
+int ICMPPacket::packetSize() const
+{
+	return _pImpl->packetSize();
+}
+
+
+int ICMPPacket::maxPacketSize() const
+{
+	return _pImpl->maxPacketSize();
+}
+
+
+const Poco::UInt8* ICMPPacket::packet()
+{
+	return _pImpl->packet();
+}
+
+
+struct timeval ICMPPacket::time(Poco::UInt8* buffer, int length) const
+{
+	return _pImpl->time(buffer, length);
+}
+
+
+bool ICMPPacket::validReplyID(Poco::UInt8* buffer, int length) const
+{
+	return _pImpl->validReplyID(buffer, length);
+}
+
+
+std::string ICMPPacket::errorDescription(Poco::UInt8* buffer, int length)
+{
+	return _pImpl->errorDescription(buffer, length);
+}
+
+
+std::string ICMPPacket::typeDescription(int typeId)
+{
+	return _pImpl->typeDescription(typeId);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/ICMPPacketImpl.cpp b/base/poco/Net/src/ICMPPacketImpl.cpp
new file mode 100644
index 00000000000..e354c40484a
--- /dev/null
+++ b/base/poco/Net/src/ICMPPacketImpl.cpp
@@ -0,0 +1,103 @@
+//
+// ICMPPacketImpl.cpp
+//
+// Library: Net
+// Package: ICMP
+// Module:  ICMPPacketImpl
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/ICMPPacketImpl.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Timestamp.h"
+#include "Poco/Timespan.h"
+#include "Poco/NumberFormatter.h"
+#include <sstream>
+
+
+using Poco::InvalidArgumentException;
+using Poco::Timestamp;
+using Poco::Timespan;
+using Poco::NumberFormatter;
+using Poco::UInt8;
+using Poco::UInt16;
+using Poco::Int32;
+
+
+namespace Poco {
+namespace Net {
+
+
+const UInt16 ICMPPacketImpl::MAX_PACKET_SIZE = 4096;
+const UInt16 ICMPPacketImpl::MAX_SEQ_VALUE   = 65535;
+
+
+ICMPPacketImpl::ICMPPacketImpl(int dataSize):
+	_seq(0),
+	_pPacket(new UInt8[MAX_PACKET_SIZE]),
+	_dataSize(dataSize)
+{
+	if (_dataSize > MAX_PACKET_SIZE)
+		throw InvalidArgumentException("Packet size must be <= " + NumberFormatter::format(MAX_PACKET_SIZE));
+}
+
+
+ICMPPacketImpl::~ICMPPacketImpl()
+{
+	delete [] _pPacket;
+}
+
+
+void ICMPPacketImpl::setDataSize(int dataSize)
+{
+	_dataSize = dataSize;
+	initPacket();
+}
+
+
+int ICMPPacketImpl::getDataSize() const
+{
+	return _dataSize;
+}
+
+
+const Poco::UInt8* ICMPPacketImpl::packet(bool init)
+{
+	if (init) initPacket();
+	return _pPacket;
+}
+
+
+unsigned short ICMPPacketImpl::checksum(UInt16 *addr, Int32 len)
+{
+	Int32 nleft = len;
+	UInt16* w   = addr;
+	UInt16 answer;
+	Int32 sum = 0;
+
+	while (nleft > 1)  
+	{
+		sum   += *w++;
+		nleft -= sizeof(UInt16);
+	}
+
+	if (nleft == 1) 
+	{
+		UInt16 u = 0;
+		*(UInt8*) (&u) = *(UInt8*) w;
+		sum += u;
+	}
+
+	sum = (sum >> 16) + (sum & 0xffff);
+	sum += (sum >> 16);
+	answer = ~sum;
+	return answer;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/ICMPSocket.cpp b/base/poco/Net/src/ICMPSocket.cpp
new file mode 100644
index 00000000000..4e66c237ae2
--- /dev/null
+++ b/base/poco/Net/src/ICMPSocket.cpp
@@ -0,0 +1,94 @@
+//
+// ICMPSocket.cpp
+//
+// Library: Net
+// Package: ICMP
+// Module:  ICMPSocket
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/ICMPSocket.h"
+#include "Poco/Net/ICMPSocketImpl.h"
+#include "Poco/Exception.h"
+
+
+using Poco::InvalidArgumentException;
+
+
+namespace Poco {
+namespace Net {
+
+
+ICMPSocket::ICMPSocket(IPAddress::Family family, int dataSize, int ttl, int timeout): 
+	Socket(new ICMPSocketImpl(family, dataSize, ttl, timeout))
+{
+}
+
+
+ICMPSocket::ICMPSocket(const Socket& socket): 
+	Socket(socket)
+{
+	if (!dynamic_cast<ICMPSocketImpl*>(impl()))
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+}
+
+
+ICMPSocket::ICMPSocket(SocketImpl* pImpl): 
+	Socket(pImpl)
+{
+	if (!dynamic_cast<ICMPSocketImpl*>(impl()))
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+}
+
+
+ICMPSocket::~ICMPSocket()
+{
+}
+
+
+ICMPSocket& ICMPSocket::operator = (const Socket& socket)
+{
+	if (dynamic_cast<ICMPSocketImpl*>(socket.impl()))
+		Socket::operator = (socket);
+	else
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+	return *this;
+}
+
+
+int ICMPSocket::sendTo(const SocketAddress& address, int flags)
+{
+	return impl()->sendTo(0, 0, address, flags);
+}
+
+
+int ICMPSocket::receiveFrom(SocketAddress& address, int flags)
+{
+	return impl()->receiveFrom(0, 0, address, flags);
+}
+
+
+int ICMPSocket::dataSize() const
+{
+	return static_cast<ICMPSocketImpl*>(impl())->dataSize();
+}
+
+
+int ICMPSocket::ttl() const
+{
+	return static_cast<ICMPSocketImpl*>(impl())->ttl();
+}
+
+
+int ICMPSocket::timeout() const
+{
+	return static_cast<ICMPSocketImpl*>(impl())->timeout();
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/ICMPSocketImpl.cpp b/base/poco/Net/src/ICMPSocketImpl.cpp
new file mode 100644
index 00000000000..8c68d53030c
--- /dev/null
+++ b/base/poco/Net/src/ICMPSocketImpl.cpp
@@ -0,0 +1,97 @@
+//
+// ICMPSocketImpl.cpp
+//
+// Library: Net
+// Package: ICMP
+// Module:  ICMPSocketImpl
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/ICMPSocketImpl.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Timespan.h"
+#include "Poco/Timestamp.h"
+#include "Poco/Exception.h"
+#include "Poco/Buffer.h"
+
+
+using Poco::TimeoutException;
+using Poco::Timespan;
+using Poco::Exception;
+
+
+namespace Poco {
+namespace Net {
+
+
+ICMPSocketImpl::ICMPSocketImpl(IPAddress::Family family, int dataSize, int ttl, int timeout):
+	RawSocketImpl(family, IPPROTO_ICMP),
+	_icmpPacket(family, dataSize),
+	_ttl(ttl),
+	_timeout(timeout)
+{
+	setOption(IPPROTO_IP, IP_TTL, ttl);
+	setReceiveTimeout(Timespan(timeout));
+}
+
+
+ICMPSocketImpl::~ICMPSocketImpl()
+{
+}
+
+
+int ICMPSocketImpl::sendTo(const void*, int, const SocketAddress& address, int flags)
+{
+	int n = SocketImpl::sendTo(_icmpPacket.packet(), _icmpPacket.packetSize(), address, flags);
+	return n;
+}
+
+
+int ICMPSocketImpl::receiveFrom(void*, int, SocketAddress& address, int flags)
+{
+	int maxPacketSize = _icmpPacket.maxPacketSize();
+	Poco::Buffer<unsigned char> buffer(maxPacketSize);
+
+	try
+	{
+		Poco::Timestamp ts;
+		do
+		{
+			if (ts.isElapsed(_timeout))
+			{
+				// This guards against a possible DoS attack, where sending
+				// fake ping responses will cause an endless loop.
+				throw TimeoutException();
+			}
+			SocketImpl::receiveFrom(buffer.begin(), maxPacketSize, address, flags);
+		}
+		while (!_icmpPacket.validReplyID(buffer.begin(), maxPacketSize));
+	}
+	catch (TimeoutException&)
+	{
+		throw;
+	}
+	catch (Exception&)
+	{
+		std::string err = _icmpPacket.errorDescription(buffer.begin(), maxPacketSize);
+		if (!err.empty())
+			throw ICMPException(err);
+		else
+			throw;
+	}
+
+	struct timeval then = _icmpPacket.time(buffer.begin(), maxPacketSize);
+	struct timeval now  = _icmpPacket.time();
+
+	int elapsed	= (((now.tv_sec * 1000000) + now.tv_usec) - ((then.tv_sec * 1000000) + then.tv_usec))/1000;
+
+	return elapsed;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/ICMPv4PacketImpl.cpp b/base/poco/Net/src/ICMPv4PacketImpl.cpp
new file mode 100644
index 00000000000..7df987a6fdd
--- /dev/null
+++ b/base/poco/Net/src/ICMPv4PacketImpl.cpp
@@ -0,0 +1,263 @@
+//
+// ICMPv4PacketImpl.cpp
+//
+// Library: Net
+// Package: ICMP
+// Module:  ICMPv4PacketImpl
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/ICMPv4PacketImpl.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Timestamp.h"
+#include "Poco/Timespan.h"
+#include "Poco/NumberFormatter.h"
+#if !defined(POCO_VXWORKS)
+#include "Poco/Process.h"
+#endif
+#include <sstream>
+
+
+using Poco::InvalidArgumentException;
+using Poco::Timestamp;
+using Poco::Timespan;
+using Poco::NumberFormatter;
+using Poco::UInt8;
+using Poco::UInt16;
+using Poco::Int32;
+
+
+namespace Poco {
+namespace Net {
+
+
+const UInt8 ICMPv4PacketImpl::DESTINATION_UNREACHABLE_TYPE       = 3;
+const Poco::UInt8 ICMPv4PacketImpl::SOURCE_QUENCH_TYPE     = 4;
+const Poco::UInt8 ICMPv4PacketImpl::REDIRECT_MESSAGE_TYPE  = 5;
+const UInt8 ICMPv4PacketImpl::TIME_EXCEEDED_TYPE                 = 11;
+const Poco::UInt8 ICMPv4PacketImpl::PARAMETER_PROBLEM_TYPE = 12;
+
+
+const std::string ICMPv4PacketImpl::MESSAGE_TYPE[] = 
+{
+	"Echo Reply",
+	"ICMP 1",
+	"ICMP 2",
+	"Dest Unreachable",
+	"Source Quench",
+	"Redirect",
+	"ICMP 6",
+	"ICMP 7",
+	"Echo",
+	"ICMP 9",
+	"ICMP 10",
+	"Time Exceeded",
+	"Parameter Problem",
+	"Timestamp",
+	"Timestamp Reply",
+	"Info Request",
+	"Info Reply",
+	"Unknown type"
+};
+
+
+const std::string ICMPv4PacketImpl::DESTINATION_UNREACHABLE_CODE[] = 
+{
+	"Net unreachable",
+	"Host unreachable",
+	"Protocol unreachable",
+	"Port unreachable",
+	"Fragmentation needed and DF set",
+	"Source route failed",
+	"Unknown code"
+};
+
+
+const std::string ICMPv4PacketImpl::REDIRECT_MESSAGE_CODE[] = 
+{
+	"Redirect datagrams for the network",
+	"Redirect datagrams for the host",
+	"Redirect datagrams for the type of service and network",
+	"Redirect datagrams for the type of service and host",
+	"Unknown code"
+};
+
+
+const std::string ICMPv4PacketImpl::TIME_EXCEEDED_CODE[] = 
+{
+	"Time to live exceeded in transit",
+	"Fragment reassembly time exceeded",
+	"Unknown code"
+};
+
+
+const std::string ICMPv4PacketImpl::PARAMETER_PROBLEM_CODE[] = 
+{
+	"Pointer indicates the error",
+	"Unknown code"
+};
+
+
+ICMPv4PacketImpl::ICMPv4PacketImpl(int dataSize)
+	: ICMPPacketImpl(dataSize),
+	_seq(0)
+{
+	initPacket();
+}
+
+
+ICMPv4PacketImpl::~ICMPv4PacketImpl()
+{
+}
+
+
+int ICMPv4PacketImpl::packetSize() const
+{
+	return getDataSize() + sizeof(Header);
+}
+
+
+void ICMPv4PacketImpl::initPacket()
+{
+	if (_seq >= MAX_SEQ_VALUE) resetSequence();
+
+	Header* icp = (Header*) packet(false);
+	icp->type     = ECHO_REQUEST;
+	icp->code     = 0;
+	icp->checksum = 0;
+	icp->seq      = ++_seq;
+#if defined(POCO_VXWORKS)
+	icp->id       = 0;
+#else
+	icp->id       = static_cast<UInt16>(Poco::Process::id());
+#endif
+
+	struct timeval* ptp = (struct timeval *) (icp + 1);
+	*ptp = time();
+
+	icp->checksum = checksum((UInt16*) icp, getDataSize() + sizeof(Header));
+}
+
+
+struct timeval ICMPv4PacketImpl::time(Poco::UInt8* buffer, int length) const
+{
+	struct timeval tv;
+
+	if (0 == buffer || 0 == length)
+	{
+		Timespan value(Timestamp().epochMicroseconds());
+		tv.tv_sec  = (long) value.totalSeconds();
+		tv.tv_usec = (long) value.useconds();
+	}
+	else
+	{
+		struct timeval* ptv = (struct timeval*) data(buffer, length);
+		if (ptv) tv = *ptv;
+		else throw InvalidArgumentException("Invalid packet.");
+	}
+	return tv;
+}
+
+
+ICMPv4PacketImpl::Header* ICMPv4PacketImpl::header(Poco::UInt8* buffer, int length) const
+{
+	poco_check_ptr (buffer);
+
+	int offset = (buffer[0] & 0x0F) * 4;
+	if ((offset + sizeof(Header)) > length) return 0;
+
+	buffer += offset;
+	return (Header *) buffer;
+}
+
+
+Poco::UInt8* ICMPv4PacketImpl::data(Poco::UInt8* buffer, int length) const
+{
+	return ((Poco::UInt8*) header(buffer, length)) + sizeof(Header);
+}
+
+
+bool ICMPv4PacketImpl::validReplyID(Poco::UInt8* buffer, int length) const
+{
+	Header *icp = header(buffer, length);
+#if defined(POCO_VXWORKS)
+	return icp && icp->id == 0;
+#else
+	return icp && (static_cast<Poco::UInt16>(Process::id()) == icp->id);
+#endif
+}
+
+
+std::string ICMPv4PacketImpl::errorDescription(unsigned char* buffer, int length)
+{
+	Header *icp = header(buffer, length);
+
+	if (!icp) return "Invalid header.";
+	if (ECHO_REPLY == icp->type) return std::string(); // not an error
+
+	UInt8 pointer = 0;
+	if (PARAMETER_PROBLEM == icp->type)
+	{
+		UInt8 mask = 0x00FF;
+		pointer = icp->id & mask;
+	}
+
+	MessageType type = static_cast<MessageType>(icp->type);
+	int code = icp->code;
+	std::ostringstream err;
+
+	switch (type)
+	{
+	case DESTINATION_UNREACHABLE_TYPE:
+		if (code >= NET_UNREACHABLE && code < DESTINATION_UNREACHABLE_UNKNOWN)
+			err << DESTINATION_UNREACHABLE_CODE[code];
+		else
+			err << DESTINATION_UNREACHABLE_CODE[DESTINATION_UNREACHABLE_UNKNOWN];
+		break;
+	
+	case SOURCE_QUENCH_TYPE:		
+		err << "Source quench";
+		break;
+	
+	case REDIRECT_MESSAGE_TYPE:
+		if (code >= REDIRECT_NETWORK && code < REDIRECT_MESSAGE_UNKNOWN) 
+			err << REDIRECT_MESSAGE_CODE[code];
+		else
+			err << REDIRECT_MESSAGE_CODE[REDIRECT_MESSAGE_UNKNOWN];
+		break;
+
+	case TIME_EXCEEDED_TYPE:
+		if (code >= TIME_TO_LIVE || code < TIME_EXCEEDED_UNKNOWN)
+			err << TIME_EXCEEDED_CODE[code];
+		else
+			err << TIME_EXCEEDED_CODE[TIME_EXCEEDED_UNKNOWN];
+		break;
+	
+	case PARAMETER_PROBLEM_TYPE:
+		if (POINTER_INDICATES_THE_ERROR != code)
+			code = PARAMETER_PROBLEM_UNKNOWN;
+		err << PARAMETER_PROBLEM_CODE[code] << ": error in octet #" << pointer;
+		break;
+	
+	default:
+		err << "Unknown type.";
+		break;
+	}
+
+	return err.str();
+}
+
+std::string ICMPv4PacketImpl::typeDescription(int typeId)
+{
+	poco_assert (typeId >= ECHO_REPLY && typeId < MESSAGE_TYPE_LENGTH);
+
+	return MESSAGE_TYPE[typeId];
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/IPAddress.cpp b/base/poco/Net/src/IPAddress.cpp
new file mode 100644
index 00000000000..e34a02181b2
--- /dev/null
+++ b/base/poco/Net/src/IPAddress.cpp
@@ -0,0 +1,601 @@
+//
+// IPAddress.cpp
+//
+// Library: Net
+// Package: NetCore
+// Module:  IPAddress
+//
+// Copyright (c) 2005-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/IPAddress.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/BinaryReader.h"
+#include "Poco/BinaryWriter.h"
+#include "Poco/String.h"
+#include "Poco/Types.h"
+
+
+using Poco::RefCountedObject;
+using Poco::NumberFormatter;
+using Poco::BinaryReader;
+using Poco::BinaryWriter;
+using Poco::toLower;
+using Poco::trim;
+using Poco::UInt8;
+using Poco::UInt16;
+using Poco::UInt32;
+using Poco::Net::Impl::IPAddressImpl;
+using Poco::Net::Impl::IPv4AddressImpl;
+#if defined(POCO_HAVE_IPv6)
+using Poco::Net::Impl::IPv6AddressImpl;
+#endif
+
+
+namespace Poco {
+namespace Net {
+
+
+#if !defined(_MSC_VER) || defined(__STDC__)
+// Go home MSVC, you're drunk...
+// See http://stackoverflow.com/questions/5899857/multiple-definition-error-for-static-const-class-members
+const IPAddress::Family IPAddress::IPv4;
+#if defined(POCO_HAVE_IPv6)
+const IPAddress::Family IPAddress::IPv6;
+#endif
+#endif
+
+
+IPAddress::IPAddress()
+{
+	newIPv4();
+}
+
+
+IPAddress::IPAddress(const IPAddress& addr)
+{
+	if (addr.family() == IPv4)
+		newIPv4(addr.addr());
+#if defined(POCO_HAVE_IPv6)
+	else
+		newIPv6(addr.addr(), addr.scope());
+#endif
+}
+
+
+IPAddress::IPAddress(Family family)
+{
+	if (family == IPv4)
+		newIPv4();
+#if defined(POCO_HAVE_IPv6)
+	else if (family == IPv6)
+		newIPv6();
+#endif
+	else throw Poco::InvalidArgumentException("Invalid or unsupported address family passed to IPAddress()");
+}
+
+
+IPAddress::IPAddress(const std::string& addr)
+{
+	IPv4AddressImpl empty4 = IPv4AddressImpl();
+	if (addr.empty() || trim(addr) == "0.0.0.0")
+	{
+		newIPv4(empty4.addr());
+		return;
+	}
+
+	IPv4AddressImpl addr4(IPv4AddressImpl::parse(addr));
+	if (addr4 != empty4)
+	{
+		newIPv4(addr4.addr());
+		return;
+	}
+
+#if defined(POCO_HAVE_IPv6)
+	IPv6AddressImpl empty6 = IPv6AddressImpl();
+	if (addr.empty() || trim(addr) == "::")
+	{
+		newIPv6(empty6.addr());
+		return;
+	}
+
+	IPv6AddressImpl addr6(IPv6AddressImpl::parse(addr));
+	if (addr6 != IPv6AddressImpl())
+	{
+		newIPv6(addr6.addr(), addr6.scope());
+		return;
+	}
+#endif
+
+	throw InvalidAddressException(addr);
+}
+
+
+IPAddress::IPAddress(const std::string& addr, Family family)
+{
+	if (family == IPv4)
+	{
+		IPv4AddressImpl addr4(IPv4AddressImpl::parse(addr));
+		newIPv4(addr4.addr());
+		return;
+	}
+#if defined(POCO_HAVE_IPv6)
+	else if (family == IPv6)
+	{
+		IPv6AddressImpl addr6(IPv6AddressImpl::parse(addr));
+		newIPv6(addr6.addr(), addr6.scope());
+		return;
+	}
+#endif
+	else throw Poco::InvalidArgumentException("Invalid or unsupported address family passed to IPAddress()");
+}
+
+
+IPAddress::IPAddress(const void* addr, poco_socklen_t length)
+	: _pImpl(0)
+{
+	if (length == sizeof(struct in_addr))
+		newIPv4(addr);
+#if defined(POCO_HAVE_IPv6)
+	else if (length == sizeof(struct in6_addr))
+		newIPv6(addr);
+#endif
+	else throw Poco::InvalidArgumentException("Invalid address length passed to IPAddress()");
+}
+
+
+IPAddress::IPAddress(const void* addr, poco_socklen_t length, Poco::UInt32 scope)
+{
+	if (length == sizeof(struct in_addr))
+		newIPv4(addr);
+#if defined(POCO_HAVE_IPv6)
+	else if (length == sizeof(struct in6_addr))
+		newIPv6(addr, scope);
+#endif
+	else throw Poco::InvalidArgumentException("Invalid address length passed to IPAddress()");
+}
+
+
+IPAddress::IPAddress(unsigned prefix, Family family)
+{
+	if (family == IPv4)
+	{
+		if (prefix <= 32)
+			newIPv4(prefix);
+		else
+			throw Poco::InvalidArgumentException("Invalid prefix length passed to IPAddress()");
+	}
+#if defined(POCO_HAVE_IPv6)
+	else if (family == IPv6)
+	{
+		if (prefix <= 128)
+			newIPv6(prefix);
+		else
+			throw Poco::InvalidArgumentException("Invalid prefix length passed to IPAddress()");
+	}
+#endif
+	else throw Poco::InvalidArgumentException("Invalid or unsupported address family passed to IPAddress()");
+}
+
+
+#if defined(_WIN32)
+IPAddress::IPAddress(const SOCKET_ADDRESS& socket_address)
+	: _pImpl(0)
+{
+	ADDRESS_FAMILY family = socket_address.lpSockaddr->sa_family;
+	if (family == AF_INET)
+		newIPv4(&reinterpret_cast<const struct sockaddr_in*>(socket_address.lpSockaddr)->sin_addr);
+#if defined(POCO_HAVE_IPv6)
+	else if (family == AF_INET6)
+		newIPv6(&reinterpret_cast<const struct sockaddr_in6*>(socket_address.lpSockaddr)->sin6_addr,
+			reinterpret_cast<const struct sockaddr_in6*>(socket_address.lpSockaddr)->sin6_scope_id);
+#endif
+	else throw Poco::InvalidArgumentException("Invalid or unsupported address family passed to IPAddress()");
+}
+#endif
+
+
+IPAddress::IPAddress(const struct sockaddr& sockaddr)
+{
+	unsigned short family = sockaddr.sa_family;
+	if (family == AF_INET)
+		newIPv4(&reinterpret_cast<const struct sockaddr_in*>(&sockaddr)->sin_addr);
+#if defined(POCO_HAVE_IPv6)
+	else if (family == AF_INET6)
+		newIPv6(&reinterpret_cast<const struct sockaddr_in6*>(&sockaddr)->sin6_addr,
+			reinterpret_cast<const struct sockaddr_in6*>(&sockaddr)->sin6_scope_id);
+#endif
+	else throw Poco::InvalidArgumentException("Invalid or unsupported address family passed to IPAddress()");
+}
+
+
+IPAddress::~IPAddress()
+{
+}
+
+
+IPAddress& IPAddress::operator = (const IPAddress& addr)
+{
+	if (&addr != this)
+	{
+		if (addr.family() == IPAddress::IPv4)
+			newIPv4(addr.addr());
+#if defined(POCO_HAVE_IPv6)
+		else if (addr.family() == IPAddress::IPv6)
+			newIPv6(addr.addr(), addr.scope());
+#endif
+		else 
+			throw Poco::InvalidArgumentException("Invalid or unsupported address family");
+	}
+	return *this;
+}
+
+
+IPAddress::Family IPAddress::family() const
+{
+	return pImpl()->family();
+}
+
+
+Poco::UInt32 IPAddress::scope() const
+{
+	return pImpl()->scope();
+}
+
+	
+std::string IPAddress::toString() const
+{
+	return pImpl()->toString();
+}
+
+
+bool IPAddress::isWildcard() const
+{
+	return pImpl()->isWildcard();
+}
+
+
+bool IPAddress::isBroadcast() const
+{
+	return pImpl()->isBroadcast();
+}
+
+
+bool IPAddress::isLoopback() const
+{
+	return pImpl()->isLoopback();
+}
+
+
+bool IPAddress::isMulticast() const
+{
+	return pImpl()->isMulticast();
+}
+
+	
+bool IPAddress::isUnicast() const
+{
+	return !isWildcard() && !isBroadcast() && !isMulticast();
+}
+
+	
+bool IPAddress::isLinkLocal() const
+{
+	return pImpl()->isLinkLocal();
+}
+
+
+bool IPAddress::isSiteLocal() const
+{
+	return pImpl()->isSiteLocal();
+}
+
+
+bool IPAddress::isIPv4Compatible() const
+{
+	return pImpl()->isIPv4Compatible();
+}
+
+
+bool IPAddress::isIPv4Mapped() const
+{
+	return pImpl()->isIPv4Mapped();
+}
+
+
+bool IPAddress::isWellKnownMC() const
+{
+	return pImpl()->isWellKnownMC();
+}
+
+
+bool IPAddress::isNodeLocalMC() const
+{
+	return pImpl()->isNodeLocalMC();
+}
+
+
+bool IPAddress::isLinkLocalMC() const
+{
+	return pImpl()->isLinkLocalMC();
+}
+
+
+bool IPAddress::isSiteLocalMC() const
+{
+	return pImpl()->isSiteLocalMC();
+}
+
+
+bool IPAddress::isOrgLocalMC() const
+{
+	return pImpl()->isOrgLocalMC();
+}
+
+
+bool IPAddress::isGlobalMC() const
+{
+	return pImpl()->isGlobalMC();
+}
+
+
+bool IPAddress::operator == (const IPAddress& a) const
+{
+	poco_socklen_t l1 = length();
+	poco_socklen_t l2 = a.length();
+	if (l1 == l2)
+    {
+#if defined(POCO_HAVE_IPv6)
+        if ( scope() != a.scope() )
+            return false;
+#endif
+		return std::memcmp(addr(), a.addr(), l1) == 0;
+    }
+	else return false;
+}
+
+
+bool IPAddress::operator != (const IPAddress& a) const
+{
+    return !(*this == a);
+}
+
+
+bool IPAddress::operator < (const IPAddress& a) const
+{
+	poco_socklen_t l1 = length();
+	poco_socklen_t l2 = a.length();
+	if (l1 == l2)
+    {
+#if defined(POCO_HAVE_IPv6)
+        if ( scope() != a.scope() )
+            return scope() < a.scope();
+#endif
+		return std::memcmp(addr(), a.addr(), l1) < 0;
+    }
+	else return l1 < l2;
+}
+
+
+bool IPAddress::operator <= (const IPAddress& a) const
+{
+    return !(a < *this);
+}
+
+
+bool IPAddress::operator > (const IPAddress& a) const
+{
+    return a < *this;
+}
+
+
+bool IPAddress::operator >= (const IPAddress& a) const
+{
+    return !(*this < a);
+}
+
+
+IPAddress IPAddress::operator & (const IPAddress& other) const
+{
+	if (family() == other.family())
+	{
+		if (family() == IPv4)
+		{
+			IPv4AddressImpl t(pImpl()->addr());
+			IPv4AddressImpl o(other.pImpl()->addr());
+			return IPAddress((t & o).addr(), sizeof(struct in_addr));
+		}
+#if defined(POCO_HAVE_IPv6)
+		else if (family() == IPv6)
+		{
+			const IPv6AddressImpl t(pImpl()->addr(), pImpl()->scope());
+			const IPv6AddressImpl o(other.pImpl()->addr(), other.pImpl()->scope());
+			const IPv6AddressImpl r = t & o;
+			return IPAddress(r.addr(), sizeof(struct in6_addr), r.scope());
+		}
+#endif
+		else throw Poco::InvalidArgumentException("Invalid or unsupported address family passed to IPAddress()");
+	}
+	else throw Poco::InvalidArgumentException("Invalid or unsupported address family passed to IPAddress()");
+}
+
+
+IPAddress IPAddress::operator | (const IPAddress& other) const
+{
+	if (family() == other.family())
+	{
+		if (family() == IPv4)
+		{
+			IPv4AddressImpl t(pImpl()->addr());
+			IPv4AddressImpl o(other.pImpl()->addr());
+			return IPAddress((t | o).addr(), sizeof(struct in_addr));
+		}
+#if defined(POCO_HAVE_IPv6)
+		else if (family() == IPv6)
+		{
+			const IPv6AddressImpl t(pImpl()->addr(), pImpl()->scope());
+			const IPv6AddressImpl o(other.pImpl()->addr(), other.pImpl()->scope());
+			const IPv6AddressImpl r = t | o;
+			return IPAddress(r.addr(), sizeof(struct in6_addr), r.scope());
+		}
+#endif
+		else throw Poco::InvalidArgumentException("Invalid or unsupported address family passed to IPAddress()");
+	}
+	else throw Poco::InvalidArgumentException("Invalid or unsupported address family passed to IPAddress()");
+}
+
+
+IPAddress IPAddress::operator ^ (const IPAddress& other) const
+{
+	if (family() == other.family())
+	{
+		if (family() == IPv4)
+		{
+			IPv4AddressImpl t(pImpl()->addr());
+			IPv4AddressImpl o(other.pImpl()->addr());
+			return IPAddress((t ^ o).addr(), sizeof(struct in_addr));
+		}
+#if defined(POCO_HAVE_IPv6)
+		else if (family() == IPv6)
+		{
+			const IPv6AddressImpl t(pImpl()->addr(), pImpl()->scope());
+			const IPv6AddressImpl o(other.pImpl()->addr(), other.pImpl()->scope());
+			const IPv6AddressImpl r = t ^ o;
+			return IPAddress(r.addr(), sizeof(struct in6_addr), r.scope());
+		}
+#endif
+		else throw Poco::InvalidArgumentException("Invalid or unsupported address family passed to IPAddress()");
+	}
+	else throw Poco::InvalidArgumentException("Invalid or unsupported address family passed to IPAddress()");
+}
+
+
+IPAddress IPAddress::operator ~ () const
+{
+	if (family() == IPv4)
+	{
+		IPv4AddressImpl self(this->pImpl()->addr());
+		return IPAddress((~self).addr(), sizeof(struct in_addr));
+	}
+#if defined(POCO_HAVE_IPv6)
+	else if (family() == IPv6)
+	{
+		const IPv6AddressImpl self(pImpl()->addr(), pImpl()->scope());
+		const IPv6AddressImpl r = ~self;
+		return IPAddress(r.addr(), sizeof(struct in6_addr), r.scope());
+	}
+#endif
+	else throw Poco::InvalidArgumentException("Invalid or unsupported address family passed to IPAddress()");
+}
+
+
+poco_socklen_t IPAddress::length() const
+{
+	return pImpl()->length();
+}
+
+	
+const void* IPAddress::addr() const
+{
+	return pImpl()->addr();
+}
+
+
+int IPAddress::af() const
+{
+	return pImpl()->af();
+}
+
+
+unsigned IPAddress::prefixLength() const
+{
+	return pImpl()->prefixLength();
+}
+
+
+IPAddress IPAddress::parse(const std::string& addr)
+{
+	return IPAddress(addr);
+}
+
+
+bool IPAddress::tryParse(const std::string& addr, IPAddress& result)
+{
+	IPv4AddressImpl impl4(IPv4AddressImpl::parse(addr));
+	if (impl4 != IPv4AddressImpl() || trim(addr) == "0.0.0.0")
+	{
+		result.newIPv4(impl4.addr());
+		return true;
+	}
+#if defined(POCO_HAVE_IPv6)
+	IPv6AddressImpl impl6(IPv6AddressImpl::parse(addr));
+	if (impl6 != IPv6AddressImpl())
+	{
+		result.newIPv6(impl6.addr(), impl6.scope());
+		return true;
+	}
+#endif
+	return false;
+}
+
+
+void IPAddress::mask(const IPAddress& mask)
+{
+	IPAddress null;
+	pImpl()->mask(mask.pImpl(), null.pImpl());
+}
+
+
+void IPAddress::mask(const IPAddress& mask, const IPAddress& set)
+{
+	pImpl()->mask(mask.pImpl(), set.pImpl());
+}
+
+
+IPAddress IPAddress::wildcard(Family family)
+{
+	return IPAddress(family);
+}
+
+
+IPAddress IPAddress::broadcast()
+{
+	struct in_addr ia;
+	ia.s_addr = INADDR_NONE;
+	return IPAddress(&ia, sizeof(ia));
+}
+
+
+} } // namespace Poco::Net
+
+
+Poco::BinaryWriter& operator << (Poco::BinaryWriter& writer, const Poco::Net::IPAddress& value)
+{
+	writer << static_cast<Poco::UInt8>(value.length());
+	writer.writeRaw(reinterpret_cast<const char*>(value.addr()), value.length());
+	return writer;
+}
+
+
+Poco::BinaryReader& operator >> (Poco::BinaryReader& reader, Poco::Net::IPAddress& value)
+{
+	char buf[Poco::Net::IPAddress::MAX_ADDRESS_LENGTH];
+	Poco::UInt8 length;
+	reader >> length;
+	reader.readRaw(buf, length);
+	value = Poco::Net::IPAddress(buf, length);
+	return reader;
+}
+
+
+std::ostream& operator << (std::ostream& ostr, const Poco::Net::IPAddress& addr)
+{
+	ostr << addr.toString();
+	return ostr;
+}
diff --git a/base/poco/Net/src/IPAddressImpl.cpp b/base/poco/Net/src/IPAddressImpl.cpp
new file mode 100644
index 00000000000..dcc63e6862f
--- /dev/null
+++ b/base/poco/Net/src/IPAddressImpl.cpp
@@ -0,0 +1,813 @@
+//
+// IPAddress.cpp
+//
+// Library: Net
+// Package: NetCore
+// Module:  IPAddress
+//
+// Copyright (c) 2005-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/IPAddressImpl.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/ByteOrder.h"
+#include "Poco/String.h"
+#include "Poco/Types.h"
+
+
+using Poco::RefCountedObject;
+using Poco::NumberFormatter;
+using Poco::toLower;
+using Poco::UInt8;
+using Poco::UInt16;
+using Poco::UInt32;
+
+
+namespace {
+
+
+template <typename T>
+unsigned maskBits(T val, unsigned size)
+	/// Returns the length of the mask (number of bits set in val).
+	/// The val should be either all zeros or two contiguos areas of 1s and 0s. 
+	/// The algorithm ignores invalid non-contiguous series of 1s and treats val 
+	/// as if all bits between MSb and last non-zero bit are set to 1.
+{
+	unsigned count = 0;
+	if (val)
+	{
+		val = (val ^ (val - 1)) >> 1;
+		for (count = 0; val; ++count) val >>= 1;
+	}
+	else count = size;
+	return size - count;
+}
+
+
+} // namespace
+
+
+namespace Poco {
+namespace Net {
+namespace Impl {
+
+
+//
+// IPAddressImpl
+//
+
+
+IPAddressImpl::IPAddressImpl()
+{
+}
+
+
+IPAddressImpl::~IPAddressImpl()
+{
+}
+
+
+//
+// IPv4AddressImpl
+//
+
+
+IPv4AddressImpl::IPv4AddressImpl()
+{
+	std::memset(&_addr, 0, sizeof(_addr));
+}
+
+
+IPv4AddressImpl::IPv4AddressImpl(const void* addr)
+{
+	std::memcpy(&_addr, addr, sizeof(_addr));
+}
+
+
+IPv4AddressImpl::IPv4AddressImpl(unsigned prefix)
+{
+	UInt32 addr = (prefix == 32) ? 0xffffffff : ~(0xffffffff >> prefix);
+	_addr.s_addr = ByteOrder::toNetwork(addr);
+}
+
+
+IPv4AddressImpl::IPv4AddressImpl(const IPv4AddressImpl& addr)
+{
+	std::memcpy(&_addr, &addr._addr, sizeof(_addr));
+}
+
+
+IPv4AddressImpl& IPv4AddressImpl::operator = (const IPv4AddressImpl& addr)
+{
+	if (this == &addr)
+		return *this;
+
+	std::memcpy(&_addr, &addr._addr, sizeof(_addr));
+	return *this;
+}
+
+
+std::string IPv4AddressImpl::toString() const
+{
+	const UInt8* bytes = reinterpret_cast<const UInt8*>(&_addr);
+	std::string result;
+	result.reserve(16);
+	NumberFormatter::append(result, bytes[0]);
+	result.append(".");
+	NumberFormatter::append(result, bytes[1]);
+	result.append(".");
+	NumberFormatter::append(result, bytes[2]);
+	result.append(".");
+	NumberFormatter::append(result, bytes[3]);
+	return result;
+}
+
+
+poco_socklen_t IPv4AddressImpl::length() const
+{
+	return sizeof(_addr);
+}
+
+
+const void* IPv4AddressImpl::addr() const
+{
+	return &_addr;
+}
+
+
+IPAddressImpl::Family IPv4AddressImpl::family() const
+{
+	return AddressFamily::IPv4;
+}
+
+
+int IPv4AddressImpl::af() const
+{
+	return AF_INET;
+}
+
+
+unsigned IPv4AddressImpl::prefixLength() const
+{
+	return maskBits(ntohl(_addr.s_addr), 32);
+}
+
+
+Poco::UInt32 IPv4AddressImpl::scope() const
+{
+	return 0;
+}
+
+
+bool IPv4AddressImpl::isWildcard() const
+{
+	return _addr.s_addr == INADDR_ANY;
+}
+
+
+bool IPv4AddressImpl::isBroadcast() const
+{
+	return _addr.s_addr == INADDR_NONE;
+}
+
+
+bool IPv4AddressImpl::isLoopback() const
+{
+	return (ntohl(_addr.s_addr) & 0xFF000000) == 0x7F000000; // 127.0.0.1 to 127.255.255.255
+}
+
+
+bool IPv4AddressImpl::isMulticast() const
+{
+	return (ntohl(_addr.s_addr) & 0xF0000000) == 0xE0000000; // 224.0.0.0/24 to 239.0.0.0/24
+}
+
+
+bool IPv4AddressImpl::isLinkLocal() const
+{
+	return (ntohl(_addr.s_addr) & 0xFFFF0000) == 0xA9FE0000; // 169.254.0.0/16
+}
+
+
+bool IPv4AddressImpl::isSiteLocal() const
+{
+	UInt32 addr = ntohl(_addr.s_addr);
+	return (addr & 0xFF000000) == 0x0A000000 ||     // 10.0.0.0/24
+		(addr & 0xFFFF0000) == 0xC0A80000 ||        // 192.68.0.0/16
+		(addr >= 0xAC100000 && addr <= 0xAC1FFFFF); // 172.16.0.0 to 172.31.255.255
+}
+
+
+bool IPv4AddressImpl::isIPv4Compatible() const
+{
+	return true;
+}
+
+
+bool IPv4AddressImpl::isIPv4Mapped() const
+{
+	return true;
+}
+
+
+bool IPv4AddressImpl::isWellKnownMC() const
+{
+	return (ntohl(_addr.s_addr) & 0xFFFFFF00) == 0xE0000000; // 224.0.0.0/8
+}
+
+
+bool IPv4AddressImpl::isNodeLocalMC() const
+{
+	return false;
+}
+
+
+bool IPv4AddressImpl::isLinkLocalMC() const
+{
+	return (ntohl(_addr.s_addr) & 0xFF000000) == 0xE0000000; // 244.0.0.0/24
+}
+
+
+bool IPv4AddressImpl::isSiteLocalMC() const
+{
+	return (ntohl(_addr.s_addr) & 0xFFFF0000) == 0xEFFF0000; // 239.255.0.0/16
+}
+
+
+bool IPv4AddressImpl::isOrgLocalMC() const
+{
+	return (ntohl(_addr.s_addr) & 0xFFFF0000) == 0xEFC00000; // 239.192.0.0/16
+}
+
+
+bool IPv4AddressImpl::isGlobalMC() const
+{
+	UInt32 addr = ntohl(_addr.s_addr);
+	return addr >= 0xE0000100 && addr <= 0xEE000000; // 224.0.1.0 to 238.255.255.255
+}
+
+
+IPv4AddressImpl IPv4AddressImpl::parse(const std::string& addr)
+{
+	if (addr.empty()) return IPv4AddressImpl();
+#if defined(_WIN32) 
+	struct in_addr ia;
+	ia.s_addr = inet_addr(addr.c_str());
+	if (ia.s_addr == INADDR_NONE && addr != "255.255.255.255")
+		return IPv4AddressImpl();
+	else
+		return IPv4AddressImpl(&ia);
+#else
+#if __GNUC__ < 3 || defined(POCO_VXWORKS)
+	struct in_addr ia;
+	ia.s_addr = inet_addr(const_cast<char*>(addr.c_str()));
+	if (ia.s_addr == INADDR_NONE && addr != "255.255.255.255")
+		return IPv4AddressImpl();
+	else
+		return IPv4AddressImpl(&ia);
+#else
+	struct in_addr ia;
+	if (inet_aton(addr.c_str(), &ia))
+		return IPv4AddressImpl(&ia);
+	else
+		return IPv4AddressImpl();
+#endif
+#endif
+}
+
+
+void IPv4AddressImpl::mask(const IPAddressImpl* pMask, const IPAddressImpl* pSet)
+{
+	poco_assert (pMask->af() == AF_INET && pSet->af() == AF_INET);
+	
+	_addr.s_addr &= static_cast<const IPv4AddressImpl*>(pMask)->_addr.s_addr;
+	_addr.s_addr |= static_cast<const IPv4AddressImpl*>(pSet)->_addr.s_addr & ~static_cast<const IPv4AddressImpl*>(pMask)->_addr.s_addr;
+}
+
+
+IPAddressImpl* IPv4AddressImpl::clone() const
+{
+	return new IPv4AddressImpl(&_addr);
+}
+
+
+IPv4AddressImpl IPv4AddressImpl::operator & (const IPv4AddressImpl& addr) const
+{
+	IPv4AddressImpl result(&_addr);
+	result._addr.s_addr &= addr._addr.s_addr;
+	return result;
+}
+
+
+IPv4AddressImpl IPv4AddressImpl::operator | (const IPv4AddressImpl& addr) const
+{
+	IPv4AddressImpl result(&_addr);
+	result._addr.s_addr |= addr._addr.s_addr;
+	return result;
+}
+
+
+IPv4AddressImpl IPv4AddressImpl::operator ^ (const IPv4AddressImpl& addr) const
+{
+	IPv4AddressImpl result(&_addr);
+	result._addr.s_addr ^= addr._addr.s_addr;
+	return result;
+}
+
+
+IPv4AddressImpl IPv4AddressImpl::operator ~ () const
+{
+IPv4AddressImpl result(&_addr);
+	result._addr.s_addr ^= 0xffffffff;
+	return result;
+}
+
+
+bool IPv4AddressImpl::operator == (const IPv4AddressImpl& addr) const
+{
+	return 0 == std::memcmp(&addr._addr, &_addr, sizeof(_addr));
+}
+
+
+bool IPv4AddressImpl::operator != (const IPv4AddressImpl& addr) const
+{
+	return !(*this == addr);
+}
+
+
+#if defined(POCO_HAVE_IPv6)
+
+
+//
+// IPv6AddressImpl
+//
+
+
+IPv6AddressImpl::IPv6AddressImpl(): _scope(0)
+{
+	std::memset(&_addr, 0, sizeof(_addr));
+}
+
+
+IPv6AddressImpl::IPv6AddressImpl(const void* addr): _scope(0)
+{
+	std::memcpy(&_addr, addr, sizeof(_addr));
+}
+
+
+IPv6AddressImpl::IPv6AddressImpl(const void* addr, Poco::UInt32 scope): _scope(scope)
+{
+	std::memcpy(&_addr, addr, sizeof(_addr));
+}
+
+
+IPv6AddressImpl::IPv6AddressImpl(const IPv6AddressImpl& addr): _scope(addr._scope)
+{
+	std::memcpy((void*) &_addr, (void*) &addr._addr, sizeof(_addr));
+}
+
+
+IPv6AddressImpl& IPv6AddressImpl::operator = (const IPv6AddressImpl& addr)
+{
+	if (this == &addr)
+		return *this;
+
+	_scope = addr._scope;
+	std::memcpy(&_addr, &addr._addr, sizeof(_addr));
+	return *this;
+}
+
+
+IPv6AddressImpl::IPv6AddressImpl(unsigned prefix):
+	_scope(0)
+{
+	unsigned i = 0;
+#ifdef POCO_OS_FAMILY_WINDOWS
+	for (; prefix >= 16; ++i, prefix -= 16) 
+	{
+		_addr.s6_addr16[i] = 0xffff;
+	}
+	if (prefix > 0)
+	{
+		_addr.s6_addr16[i++] = ByteOrder::toNetwork(static_cast<Poco::UInt16>(~(0xffff >> prefix)));
+	}
+	while (i < 8)
+	{
+		_addr.s6_addr16[i++] = 0;
+	}
+#else
+	for (; prefix >= 32; ++i, prefix -= 32) 
+	{
+		_addr.s6_addr32[i] = 0xffffffff;
+	}
+	if (prefix > 0)
+	{
+		_addr.s6_addr32[i++] = ByteOrder::toNetwork(~(0xffffffffU >> prefix));
+	}
+	while (i < 4)
+	{
+		_addr.s6_addr32[i++] = 0;
+	}
+#endif
+}
+
+
+std::string IPv6AddressImpl::toString() const
+{
+	const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
+	if ((isIPv4Compatible() && !isLoopback()) || isIPv4Mapped())
+	{
+		std::string result;
+		result.reserve(24);
+		if (words[5] == 0)
+			result.append("::");
+		else
+			result.append("::ffff:");
+		const UInt8* bytes = reinterpret_cast<const UInt8*>(&_addr);
+		if (bytes[12] != 0) // only 0.0.0.0 can start with zero
+		{
+			NumberFormatter::append(result, bytes[12]);
+			result.append(".");
+			NumberFormatter::append(result, bytes[13]);
+			result.append(".");
+			NumberFormatter::append(result, bytes[14]);
+			result.append(".");
+			NumberFormatter::append(result, bytes[15]);
+		}
+		return result;
+	}
+	else
+	{
+		std::string result;
+		result.reserve(64);
+		bool zeroSequence = false;
+		int i = 0;
+		while (i < 8)
+		{
+			if (!zeroSequence && words[i] == 0)
+			{
+				int zi = i;
+				while (zi < 8 && words[zi] == 0) ++zi;
+				if (zi > i + 1)
+				{
+					i = zi;
+					result.append(":");
+					zeroSequence = true;
+				}
+			}
+			if (i > 0) result.append(":");
+			if (i < 8) NumberFormatter::appendHex(result, ByteOrder::fromNetwork(words[i++]));
+		}
+		if (_scope > 0)
+		{
+			result.append("%");
+#if defined(_WIN32)
+			NumberFormatter::append(result, _scope);
+#else
+			char buffer[IFNAMSIZ];
+			if (if_indextoname(_scope, buffer))
+			{
+				result.append(buffer);
+			}
+			else
+			{
+				NumberFormatter::append(result, _scope);
+			}
+#endif
+		}
+		return toLower(result);
+	}
+}
+
+
+poco_socklen_t IPv6AddressImpl::length() const
+{
+	return sizeof(_addr);
+}
+
+
+const void* IPv6AddressImpl::addr() const
+{
+	return &_addr;
+}
+
+
+IPAddressImpl::Family IPv6AddressImpl::family() const
+{
+	return AddressFamily::IPv6;
+}
+
+
+int IPv6AddressImpl::af() const
+{
+	return AF_INET6;
+}
+
+
+unsigned IPv6AddressImpl::prefixLength() const
+{
+	unsigned bits = 0;
+	unsigned bitPos = 128;
+#if defined(POCO_OS_FAMILY_UNIX)
+	for (int i = 3; i >= 0; --i)
+	{
+		unsigned addr = ntohl(_addr.s6_addr32[i]);
+		if ((bits = maskBits(addr, 32))) return (bitPos - (32 - bits));
+		bitPos -= 32;
+	}
+	return 0;
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+	for (int i = 7; i >= 0; --i)
+	{
+		unsigned short addr = ByteOrder::fromNetwork(_addr.s6_addr16[i]);
+		if ((bits = maskBits(addr, 16))) return (bitPos - (16 - bits));
+		bitPos -= 16;
+	}
+	return 0;
+#else
+#warning prefixLength() not implemented
+	throw NotImplementedException("prefixLength() not implemented");
+#endif
+}
+
+
+Poco::UInt32 IPv6AddressImpl::scope() const
+{
+	return _scope;
+}
+
+
+bool IPv6AddressImpl::isWildcard() const
+{
+	const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
+	return words[0] == 0 && words[1] == 0 && words[2] == 0 && words[3] == 0 && 
+		words[4] == 0 && words[5] == 0 && words[6] == 0 && words[7] == 0;
+}
+
+
+bool IPv6AddressImpl::isBroadcast() const
+{
+	return false;
+}
+
+
+bool IPv6AddressImpl::isLoopback() const
+{
+	const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
+	return words[0] == 0 && words[1] == 0 && words[2] == 0 && words[3] == 0 && 
+		words[4] == 0 && words[5] == 0 && words[6] == 0 && ByteOrder::fromNetwork(words[7]) == 0x0001;
+}
+
+
+bool IPv6AddressImpl::isMulticast() const
+{
+	const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
+	return (ByteOrder::fromNetwork(words[0]) & 0xFFE0) == 0xFF00;
+}
+
+
+bool IPv6AddressImpl::isLinkLocal() const
+{
+	const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
+	return (ByteOrder::fromNetwork(words[0]) & 0xFFE0) == 0xFE80;
+}
+
+
+bool IPv6AddressImpl::isSiteLocal() const
+{
+	const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
+	return ((ByteOrder::fromNetwork(words[0]) & 0xFFE0) == 0xFEC0) || ((ByteOrder::fromNetwork(words[0]) & 0xFF00) == 0xFC00);
+}
+
+
+bool IPv6AddressImpl::isIPv4Compatible() const
+{
+	const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
+	return words[0] == 0 && words[1] == 0 && words[2] == 0 && words[3] == 0 && words[4] == 0 && words[5] == 0;
+}
+
+
+bool IPv6AddressImpl::isIPv4Mapped() const
+{
+	const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
+	return words[0] == 0 && words[1] == 0 && words[2] == 0 && words[3] == 0 && words[4] == 0 && ByteOrder::fromNetwork(words[5]) == 0xFFFF;
+}
+
+
+bool IPv6AddressImpl::isWellKnownMC() const
+{
+	const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
+	return (ByteOrder::fromNetwork(words[0]) & 0xFFF0) == 0xFF00;
+}
+
+
+bool IPv6AddressImpl::isNodeLocalMC() const
+{
+	const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
+	return (ByteOrder::fromNetwork(words[0]) & 0xFFEF) == 0xFF01;
+}
+
+
+bool IPv6AddressImpl::isLinkLocalMC() const
+{
+	const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
+	return (ByteOrder::fromNetwork(words[0]) & 0xFFEF) == 0xFF02;
+}
+
+
+bool IPv6AddressImpl::isSiteLocalMC() const
+{
+	const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
+	return (ByteOrder::fromNetwork(words[0]) & 0xFFEF) == 0xFF05;
+}
+
+
+bool IPv6AddressImpl::isOrgLocalMC() const
+{
+	const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
+	return (ByteOrder::fromNetwork(words[0]) & 0xFFEF) == 0xFF08;
+}
+
+
+bool IPv6AddressImpl::isGlobalMC() const
+{
+	const UInt16* words = reinterpret_cast<const UInt16*>(&_addr);
+	return (ByteOrder::fromNetwork(words[0]) & 0xFFEF) == 0xFF0F;
+}
+
+
+IPv6AddressImpl IPv6AddressImpl::parse(const std::string& addr)
+{
+	if (addr.empty()) return IPv6AddressImpl();
+#if defined(_WIN32)
+	struct addrinfo* pAI;
+	struct addrinfo hints;
+	std::memset(&hints, 0, sizeof(hints));
+	hints.ai_flags = AI_NUMERICHOST;
+	int rc = getaddrinfo(addr.c_str(), NULL, &hints, &pAI);
+	if (rc == 0)
+	{
+		IPv6AddressImpl result = IPv6AddressImpl(&reinterpret_cast<struct sockaddr_in6*>(pAI->ai_addr)->sin6_addr, static_cast<int>(reinterpret_cast<struct sockaddr_in6*>(pAI->ai_addr)->sin6_scope_id));
+		freeaddrinfo(pAI);
+		return result;
+	}
+	else return IPv6AddressImpl();
+#else
+	struct in6_addr ia;
+	std::string::size_type pos = addr.find('%');
+	if (std::string::npos != pos)
+	{
+		std::string::size_type start = ('[' == addr[0]) ? 1 : 0;
+		std::string unscopedAddr(addr, start, pos - start);
+		std::string scope(addr, pos + 1, addr.size() - start - pos);
+		Poco::UInt32 scopeId(0);
+		if (!(scopeId = if_nametoindex(scope.c_str())))
+			return IPv6AddressImpl();
+		if (inet_pton(AF_INET6, unscopedAddr.c_str(), &ia) == 1)
+			return IPv6AddressImpl(&ia, scopeId);
+		else
+			return IPv6AddressImpl();
+	}
+	else
+	{
+		if (inet_pton(AF_INET6, addr.c_str(), &ia) == 1)
+			return IPv6AddressImpl(&ia);
+		else
+			return IPv6AddressImpl();
+	}
+#endif
+}
+
+
+void IPv6AddressImpl::mask(const IPAddressImpl* pMask, const IPAddressImpl* pSet)
+{
+	throw Poco::NotImplementedException("mask() is only supported for IPv4 addresses");
+}
+
+
+IPAddressImpl* IPv6AddressImpl::clone() const
+{
+	return new IPv6AddressImpl(*this);
+}
+
+
+IPv6AddressImpl IPv6AddressImpl::operator & (const IPv6AddressImpl& addr) const
+{
+	if (_scope != addr._scope)
+		throw Poco::InvalidArgumentException("Scope ID of passed IPv6 address does not match with the source one.");
+
+	IPv6AddressImpl result(*this);
+#ifdef POCO_OS_FAMILY_WINDOWS
+	result._addr.s6_addr16[0] &= addr._addr.s6_addr16[0];
+	result._addr.s6_addr16[1] &= addr._addr.s6_addr16[1];
+	result._addr.s6_addr16[2] &= addr._addr.s6_addr16[2];
+	result._addr.s6_addr16[3] &= addr._addr.s6_addr16[3];
+	result._addr.s6_addr16[4] &= addr._addr.s6_addr16[4];
+	result._addr.s6_addr16[5] &= addr._addr.s6_addr16[5];
+	result._addr.s6_addr16[6] &= addr._addr.s6_addr16[6];
+	result._addr.s6_addr16[7] &= addr._addr.s6_addr16[7];
+#else
+	result._addr.s6_addr32[0] &= addr._addr.s6_addr32[0];
+	result._addr.s6_addr32[1] &= addr._addr.s6_addr32[1];
+	result._addr.s6_addr32[2] &= addr._addr.s6_addr32[2];
+	result._addr.s6_addr32[3] &= addr._addr.s6_addr32[3];
+#endif
+	return result;
+}
+
+
+IPv6AddressImpl IPv6AddressImpl::operator | (const IPv6AddressImpl& addr) const
+{
+	if (_scope != addr._scope) 
+		throw Poco::InvalidArgumentException("Scope ID of passed IPv6 address does not match with the source one.");
+    
+	IPv6AddressImpl result(*this);
+#ifdef POCO_OS_FAMILY_WINDOWS
+	result._addr.s6_addr16[0] |= addr._addr.s6_addr16[0];
+	result._addr.s6_addr16[1] |= addr._addr.s6_addr16[1];
+	result._addr.s6_addr16[2] |= addr._addr.s6_addr16[2];
+	result._addr.s6_addr16[3] |= addr._addr.s6_addr16[3];
+	result._addr.s6_addr16[4] |= addr._addr.s6_addr16[4];
+	result._addr.s6_addr16[5] |= addr._addr.s6_addr16[5];
+	result._addr.s6_addr16[6] |= addr._addr.s6_addr16[6];
+	result._addr.s6_addr16[7] |= addr._addr.s6_addr16[7];
+#else
+	result._addr.s6_addr32[0] |= addr._addr.s6_addr32[0];
+	result._addr.s6_addr32[1] |= addr._addr.s6_addr32[1];
+	result._addr.s6_addr32[2] |= addr._addr.s6_addr32[2];
+	result._addr.s6_addr32[3] |= addr._addr.s6_addr32[3];
+#endif
+	return result;
+}
+
+
+IPv6AddressImpl IPv6AddressImpl::operator ^ (const IPv6AddressImpl& addr) const
+{
+	if (_scope != addr._scope)
+		throw Poco::InvalidArgumentException("Scope ID of passed IPv6 address does not match  with the source one.");
+    
+	IPv6AddressImpl result(*this);
+
+#ifdef POCO_OS_FAMILY_WINDOWS
+	result._addr.s6_addr16[0] ^= addr._addr.s6_addr16[0];
+	result._addr.s6_addr16[1] ^= addr._addr.s6_addr16[1];
+	result._addr.s6_addr16[2] ^= addr._addr.s6_addr16[2];
+	result._addr.s6_addr16[3] ^= addr._addr.s6_addr16[3];
+	result._addr.s6_addr16[4] ^= addr._addr.s6_addr16[4];
+	result._addr.s6_addr16[5] ^= addr._addr.s6_addr16[5];
+	result._addr.s6_addr16[6] ^= addr._addr.s6_addr16[6];
+	result._addr.s6_addr16[7] ^= addr._addr.s6_addr16[7];
+#else
+	result._addr.s6_addr32[0] ^= addr._addr.s6_addr32[0];
+	result._addr.s6_addr32[1] ^= addr._addr.s6_addr32[1];
+	result._addr.s6_addr32[2] ^= addr._addr.s6_addr32[2];
+	result._addr.s6_addr32[3] ^= addr._addr.s6_addr32[3];
+#endif
+	return result;
+}
+
+
+IPv6AddressImpl IPv6AddressImpl::operator ~ () const
+{
+	IPv6AddressImpl result(*this);
+#ifdef POCO_OS_FAMILY_WINDOWS
+	result._addr.s6_addr16[0] ^= 0xffff;
+	result._addr.s6_addr16[1] ^= 0xffff;
+	result._addr.s6_addr16[2] ^= 0xffff;
+	result._addr.s6_addr16[3] ^= 0xffff;
+	result._addr.s6_addr16[4] ^= 0xffff;
+	result._addr.s6_addr16[5] ^= 0xffff;
+	result._addr.s6_addr16[6] ^= 0xffff;
+	result._addr.s6_addr16[7] ^= 0xffff;
+#else
+	result._addr.s6_addr32[0] ^= 0xffffffff;
+	result._addr.s6_addr32[1] ^= 0xffffffff;
+	result._addr.s6_addr32[2] ^= 0xffffffff;
+	result._addr.s6_addr32[3] ^= 0xffffffff;
+#endif
+	return result;
+}
+
+
+bool IPv6AddressImpl::operator == (const IPv6AddressImpl& addr) const
+{
+	return _scope == addr._scope && 0 == std::memcmp(&addr._addr, &_addr, sizeof(_addr));
+}
+
+
+bool IPv6AddressImpl::operator != (const IPv6AddressImpl& addr) const
+{
+	return !(*this == addr);
+}
+
+
+#endif // POCO_HAVE_IPv6
+
+
+} } } // namespace Poco::Net::Impl
diff --git a/base/poco/Net/src/MailMessage.cpp b/base/poco/Net/src/MailMessage.cpp
new file mode 100644
index 00000000000..3fab8fa4688
--- /dev/null
+++ b/base/poco/Net/src/MailMessage.cpp
@@ -0,0 +1,695 @@
+//
+// MailMessage.cpp
+//
+// Library: Net
+// Package: Mail
+// Module:  MailMessage
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/MailMessage.h"
+#include "Poco/Net/MediaType.h"
+#include "Poco/Net/MultipartReader.h"
+#include "Poco/Net/MultipartWriter.h"
+#include "Poco/Net/PartSource.h"
+#include "Poco/Net/PartHandler.h"
+#include "Poco/Net/StringPartSource.h"
+#include "Poco/Net/QuotedPrintableEncoder.h"
+#include "Poco/Net/QuotedPrintableDecoder.h"
+#include "Poco/Net/NameValueCollection.h"
+#include "Poco/Base64Encoder.h"
+#include "Poco/Base64Decoder.h"
+#include "Poco/StreamCopier.h"
+#include "Poco/DateTimeFormat.h"
+#include "Poco/DateTimeFormatter.h"
+#include "Poco/DateTimeParser.h"
+#include "Poco/String.h"
+#include "Poco/StringTokenizer.h"
+#include "Poco/StreamCopier.h"
+#include "Poco/NumberFormatter.h"
+#include <sstream>
+
+
+using Poco::Base64Encoder;
+using Poco::Base64Decoder;
+using Poco::StreamCopier;
+using Poco::DateTimeFormat;
+using Poco::DateTimeFormatter;
+using Poco::DateTimeParser;
+using Poco::StringTokenizer;
+using Poco::icompare;
+
+
+namespace Poco {
+namespace Net {
+
+
+namespace
+{
+	class MultiPartHandler: public PartHandler
+		/// This is a default part handler for multipart messages, used when there 
+		/// is no external handler provided to he MailMessage. This handler
+		/// will handle all types of message parts, including attachments.
+	{
+	public:
+		MultiPartHandler(MailMessage* pMsg): _pMsg(pMsg)
+			/// Creates multi part handler.
+			/// The pMsg pointer points to the calling MailMessage
+			/// and will be used to properly populate it, so the
+			/// message content could be written out unmodified
+			/// in its entirety, including attachments.
+		{
+		}
+		
+		~MultiPartHandler()
+			/// Destroys string part handler.
+		{
+		}
+		
+		void handlePart(const MessageHeader& header, std::istream& stream)
+			/// Handles a part. If message pointer was provided at construction time, 
+			/// the message pointed to will be properly populated so it could be written
+			/// back out at a later point in time.
+		{
+			std::string tmp;
+			Poco::StreamCopier::copyToString(stream, tmp);
+			if (_pMsg)
+			{
+				MailMessage::ContentTransferEncoding cte = MailMessage::ENCODING_7BIT;
+				if (header.has(MailMessage::HEADER_CONTENT_TRANSFER_ENCODING))
+				{
+					std::string enc = header[MailMessage::HEADER_CONTENT_TRANSFER_ENCODING];
+					if (enc == MailMessage::CTE_8BIT)
+						cte = MailMessage::ENCODING_8BIT;
+					else if (enc == MailMessage::CTE_QUOTED_PRINTABLE)
+						cte = MailMessage::ENCODING_QUOTED_PRINTABLE;
+					else if (enc == MailMessage::CTE_BASE64)
+						cte = MailMessage::ENCODING_BASE64;
+				}
+
+				std::string contentType = header.get(MailMessage::HEADER_CONTENT_TYPE, "");
+				std::string contentDisp = header.get(MailMessage::HEADER_CONTENT_DISPOSITION, "");
+				std::string filename;
+				if (!contentDisp.empty())
+					filename = getParamFromHeader(contentDisp, "filename");
+				if (filename.empty()) 
+					filename = getParamFromHeader(contentType, "name");
+				PartSource* pPS = _pMsg->createPartStore(tmp, contentType, filename);
+				poco_check_ptr (pPS);
+				NameValueCollection::ConstIterator it = header.begin();
+				NameValueCollection::ConstIterator end = header.end();
+				bool added = false;
+				for (; it != end; ++it)
+				{
+					if (!added && MailMessage::HEADER_CONTENT_DISPOSITION == it->first)
+					{
+						if (it->second == "inline") 
+							_pMsg->addContent(pPS, cte);
+						else 
+							_pMsg->addAttachment("", pPS, cte);
+						added = true;
+					}
+					
+					pPS->headers().set(it->first, it->second);
+				}
+
+				if (contentDisp.empty())
+				{
+					_pMsg->addContent(pPS, cte);
+					added = true;
+				}
+
+				if (!added) delete pPS;
+			}
+		}
+		
+	private:
+		std::string getParamFromHeader(const std::string& header, const std::string& param)
+		{
+			StringTokenizer st(header, ";=", StringTokenizer::TOK_IGNORE_EMPTY | StringTokenizer::TOK_TRIM);
+			StringTokenizer::Iterator it = st.begin();
+			StringTokenizer::Iterator end = st.end();
+			for (; it != end; ++it) { if (*it == param) break; }
+			if (it != end)
+			{
+				++it;
+				if (it == end) return "";
+				return *it;
+			}
+			return "";
+		}
+
+		MailMessage* _pMsg;
+	};
+
+
+	class StringPartHandler: public PartHandler
+		/// This is a default part handler, used when there is no
+		/// external handler provided to the MailMessage. This handler
+		/// handles only single-part messages.
+	{
+	public:
+		StringPartHandler(std::string& content): _str(content)
+			/// Creates string part handler.
+			/// The content parameter represents the part content.
+		{
+		}
+		
+		~StringPartHandler()
+			/// Destroys string part handler.
+		{
+		}
+		
+		void handlePart(const MessageHeader& header, std::istream& stream)
+			/// Handles a part.
+		{
+			std::string tmp;
+			Poco::StreamCopier::copyToString(stream, tmp);
+			_str.append(tmp);
+		}
+		
+	private:
+		std::string& _str;
+	};
+}
+
+
+const std::string MailMessage::HEADER_SUBJECT("Subject");
+const std::string MailMessage::HEADER_FROM("From");
+const std::string MailMessage::HEADER_TO("To");
+const std::string MailMessage::HEADER_CC("CC");
+const std::string MailMessage::HEADER_BCC("BCC");
+const std::string MailMessage::HEADER_DATE("Date");
+const std::string MailMessage::HEADER_CONTENT_TYPE("Content-Type");
+const std::string MailMessage::HEADER_CONTENT_TRANSFER_ENCODING("Content-Transfer-Encoding");
+const std::string MailMessage::HEADER_CONTENT_DISPOSITION("Content-Disposition");
+const std::string MailMessage::HEADER_CONTENT_ID("Content-ID");
+const std::string MailMessage::HEADER_MIME_VERSION("Mime-Version");
+const std::string MailMessage::EMPTY_HEADER;
+const std::string MailMessage::TEXT_PLAIN("text/plain");
+const std::string MailMessage::CTE_7BIT("7bit");
+const std::string MailMessage::CTE_8BIT("8bit");
+const std::string MailMessage::CTE_QUOTED_PRINTABLE("quoted-printable");
+const std::string MailMessage::CTE_BASE64("base64");
+
+
+MailMessage::MailMessage(PartStoreFactory* pStoreFactory): 
+	_encoding(),
+	_pStoreFactory(pStoreFactory)
+{
+	Poco::Timestamp now;
+	setDate(now);
+	setContentType("text/plain");
+}
+
+
+MailMessage::~MailMessage()
+{
+	for (PartVec::iterator it = _parts.begin(); it != _parts.end(); ++it)
+	{
+		delete it->pSource;
+	}
+}
+
+	
+void MailMessage::addRecipient(const MailRecipient& recipient)
+{
+	_recipients.push_back(recipient);
+}
+
+
+void MailMessage::setRecipients(const Recipients& recipients)
+{
+	_recipients.assign(recipients.begin(), recipients.end());
+}
+
+
+void MailMessage::setSender(const std::string& sender)
+{
+	set(HEADER_FROM, sender);
+}
+
+	
+const std::string& MailMessage::getSender() const
+{
+	if (has(HEADER_FROM))
+		return get(HEADER_FROM);
+	else
+		return EMPTY_HEADER;
+}
+
+	
+void MailMessage::setSubject(const std::string& subject)
+{
+	set(HEADER_SUBJECT, subject);
+}
+
+	
+const std::string& MailMessage::getSubject() const
+{
+	if (has(HEADER_SUBJECT))
+		return get(HEADER_SUBJECT);
+	else
+		return EMPTY_HEADER;
+}
+
+
+void MailMessage::setContent(const std::string& content, ContentTransferEncoding encoding)
+{
+	_content  = content;
+	_encoding = encoding;
+	set(HEADER_CONTENT_TRANSFER_ENCODING, contentTransferEncodingToString(encoding));
+}
+
+
+void MailMessage::setContentType(const std::string& mediaType)
+{
+	set(HEADER_CONTENT_TYPE, mediaType);
+}
+
+	
+void MailMessage::setContentType(const MediaType& mediaType)
+{
+	setContentType(mediaType.toString());
+}
+
+	
+const std::string& MailMessage::getContentType() const
+{
+	if (has(HEADER_CONTENT_TYPE))
+		return get(HEADER_CONTENT_TYPE);
+	else
+		return TEXT_PLAIN;
+}
+
+
+void MailMessage::setDate(const Poco::Timestamp& dateTime)
+{
+	set(HEADER_DATE, DateTimeFormatter::format(dateTime, DateTimeFormat::RFC1123_FORMAT));
+}
+
+	
+Poco::Timestamp MailMessage::getDate() const
+{
+	const std::string& dateTime = get(HEADER_DATE);
+	int tzd;
+	return DateTimeParser::parse(dateTime, tzd).timestamp();
+}
+
+	
+bool MailMessage::isMultipart() const
+{
+	MediaType mediaType = getContentType();
+	return mediaType.matches("multipart");
+}
+
+
+void MailMessage::addPart(const std::string& name, PartSource* pSource, ContentDisposition disposition, ContentTransferEncoding encoding)
+{
+	poco_check_ptr (pSource);
+
+	makeMultipart();
+	Part part;
+	part.name        = name;
+	part.pSource     = pSource;
+	part.disposition = disposition;
+	part.encoding    = encoding;
+	_parts.push_back(part);
+}
+
+
+void MailMessage::addContent(PartSource* pSource, ContentTransferEncoding encoding)
+{
+	addPart("", pSource, CONTENT_INLINE, encoding);
+}
+
+	
+void MailMessage::addAttachment(const std::string& name, PartSource* pSource, ContentTransferEncoding encoding)
+{
+	addPart(name, pSource, CONTENT_ATTACHMENT, encoding);
+}
+
+
+void MailMessage::read(std::istream& istr, PartHandler& handler)
+{
+	readHeader(istr);
+	if (isMultipart())
+	{
+		readMultipart(istr, handler);
+	}
+	else
+	{
+		StringPartHandler handler(_content);
+		readPart(istr, *this, handler);
+	}
+}
+
+
+void MailMessage::read(std::istream& istr)
+{
+	readHeader(istr);
+	if (isMultipart())
+	{
+		MultiPartHandler handler(this);
+		readMultipart(istr, handler);
+	}
+	else
+	{
+		StringPartHandler handler(_content);
+		readPart(istr, *this, handler);
+	}
+}
+
+
+void MailMessage::write(std::ostream& ostr) const
+{
+	MessageHeader header(*this);
+	setRecipientHeaders(header);
+	if (isMultipart())
+	{
+		writeMultipart(header, ostr);
+	}
+	else
+	{
+		writeHeader(header, ostr);
+		std::istringstream istr(_content);
+		writeEncoded(istr, ostr, _encoding);
+	}
+}
+
+
+void MailMessage::makeMultipart()
+{
+	if (!isMultipart())
+	{
+		MediaType mediaType("multipart", "mixed");
+		setContentType(mediaType);	
+	}
+}
+
+
+void MailMessage::writeHeader(const MessageHeader& header, std::ostream& ostr) const
+{
+	header.write(ostr);
+	ostr << "\r\n";
+}
+
+
+void MailMessage::writeMultipart(MessageHeader& header, std::ostream& ostr) const
+{
+	if (_boundary.empty()) _boundary = MultipartWriter::createBoundary();
+	MediaType mediaType(getContentType());
+	mediaType.setParameter("boundary", _boundary);
+	header.set(HEADER_CONTENT_TYPE, mediaType.toString());
+	header.set(HEADER_MIME_VERSION, "1.0");
+	writeHeader(header, ostr);
+	
+	MultipartWriter writer(ostr, _boundary);
+	for (PartVec::const_iterator it = _parts.begin(); it != _parts.end(); ++it)
+	{
+		writePart(writer, *it);
+	}
+	writer.close();
+}
+
+
+void MailMessage::writePart(MultipartWriter& writer, const Part& part) const
+{
+	MessageHeader partHeader(part.pSource->headers());
+	MediaType mediaType(part.pSource->mediaType());
+	if (!part.name.empty())
+		mediaType.setParameter("name", part.name);
+	partHeader.set(HEADER_CONTENT_TYPE, mediaType.toString());
+	partHeader.set(HEADER_CONTENT_TRANSFER_ENCODING, contentTransferEncodingToString(part.encoding));
+	std::string disposition;
+	if (part.disposition == CONTENT_ATTACHMENT)
+	{
+		disposition = "attachment";
+		const std::string& filename = part.pSource->filename();
+		if (!filename.empty())
+		{
+			disposition.append("; filename=");
+			quote(filename, disposition);
+		}
+	}
+	else disposition = "inline";
+	partHeader.set(HEADER_CONTENT_DISPOSITION, disposition);
+	writer.nextPart(partHeader);
+	writeEncoded(part.pSource->stream(), writer.stream(), part.encoding);
+}
+
+
+void MailMessage::writeEncoded(std::istream& istr, std::ostream& ostr, ContentTransferEncoding encoding) const
+{
+	switch (encoding)
+	{
+	case ENCODING_7BIT:
+	case ENCODING_8BIT:
+		StreamCopier::copyStream(istr, ostr);
+		break;
+	case ENCODING_QUOTED_PRINTABLE:
+		{
+			QuotedPrintableEncoder encoder(ostr);
+			StreamCopier::copyStream(istr, encoder);
+			encoder.close();
+		}
+		break;
+	case ENCODING_BASE64:
+		{
+			Base64Encoder encoder(ostr);
+			StreamCopier::copyStream(istr, encoder);
+			encoder.close();
+		}
+		break;
+	}
+}
+
+
+void MailMessage::readHeader(std::istream& istr)
+{
+	clear();
+	MessageHeader::read(istr);
+	istr.get(); // \r
+	if ('\n' == istr.peek()) istr.get(); // \n
+}
+
+
+void MailMessage::readMultipart(std::istream& istr, PartHandler& handler)
+{
+	MediaType contentType(getContentType());
+	_boundary = contentType.getParameter("boundary");
+	MultipartReader reader(istr, _boundary);
+	while (reader.hasNextPart())
+	{
+		MessageHeader partHeader;
+		reader.nextPart(partHeader);
+		readPart(reader.stream(), partHeader, handler);
+	}
+}
+
+
+void MailMessage::readPart(std::istream& istr, const MessageHeader& header, PartHandler& handler)
+{
+    std::string encoding;
+    if (header.has(HEADER_CONTENT_TRANSFER_ENCODING))
+    {
+        encoding = header.get(HEADER_CONTENT_TRANSFER_ENCODING);
+        // get rid of a parameter if one is set
+        std::string::size_type pos = encoding.find(';');
+        if (pos != std::string::npos)
+            encoding.resize(pos);
+    }
+    if (icompare(encoding, CTE_QUOTED_PRINTABLE) == 0)
+    {
+        QuotedPrintableDecoder decoder(istr);
+        handlePart(decoder, header, handler);
+        _encoding = ENCODING_QUOTED_PRINTABLE;
+    }
+    else if (icompare(encoding, CTE_BASE64) == 0)
+    {
+        Base64Decoder decoder(istr);
+        handlePart(decoder, header, handler);
+        _encoding = ENCODING_BASE64;
+    }
+    else
+    {
+        if (icompare(encoding, CTE_7BIT) == 0)
+            _encoding = ENCODING_7BIT;
+        else if (icompare(encoding, CTE_8BIT) == 0)
+            _encoding = ENCODING_8BIT;
+
+        handlePart(istr, header, handler);
+    }
+}
+
+
+void MailMessage::handlePart(std::istream& istr, const MessageHeader& header, PartHandler& handler)
+{
+	handler.handlePart(header, istr);
+	// Read remaining characters from stream in case
+	// the handler failed to read the complete stream.
+	while (istr.good()) istr.get();
+}
+
+
+void MailMessage::setRecipientHeaders(MessageHeader& headers) const
+{
+	std::string to;
+	std::string cc;
+	std::string bcc;
+	
+	for (Recipients::const_iterator it = _recipients.begin(); it != _recipients.end(); ++it)
+	{
+		switch (it->getType())
+		{
+		case MailRecipient::PRIMARY_RECIPIENT:
+			appendRecipient(*it, to);
+			break;
+		case MailRecipient::CC_RECIPIENT:
+			appendRecipient(*it, cc);
+			break;
+		case MailRecipient::BCC_RECIPIENT:
+			break;
+		}
+	}
+	if (!to.empty()) headers.set(HEADER_TO, to);
+	if (!cc.empty()) headers.set(HEADER_CC, cc);
+}
+
+
+const std::string& MailMessage::contentTransferEncodingToString(ContentTransferEncoding encoding)
+{
+	switch (encoding)
+	{
+	case ENCODING_7BIT:
+		return CTE_7BIT;
+	case ENCODING_8BIT:
+		return CTE_8BIT;
+	case ENCODING_QUOTED_PRINTABLE:
+		return CTE_QUOTED_PRINTABLE;
+	case ENCODING_BASE64:
+		return CTE_BASE64;
+	default:
+		poco_bugcheck();
+	}
+	return CTE_7BIT;
+}
+
+
+int MailMessage::lineLength(const std::string& str)
+{
+	int n = 0;
+	std::string::const_reverse_iterator it  = str.rbegin();
+	std::string::const_reverse_iterator end = str.rend();
+	while (it != end && *it != '\n') { ++n; ++it; }
+	return n;
+}
+
+
+void MailMessage::appendRecipient(const MailRecipient& recipient, std::string& str)
+{
+	if (!str.empty()) str.append(", ");
+	const std::string& realName = recipient.getRealName();
+	const std::string& address  = recipient.getAddress();
+	std::string rec;
+	if (!realName.empty())
+	{
+		quote(realName, rec, true);
+		rec.append(" ");
+	}
+	rec.append("<");
+	rec.append(address);
+	rec.append(">");
+	if (lineLength(str) + rec.length() > 70) str.append("\r\n\t");
+	str.append(rec);
+}
+
+
+std::string MailMessage::encodeWord(const std::string& text, const std::string& charset)
+{
+	bool containsNonASCII = false;
+	for (std::string::const_iterator it = text.begin(); it != text.end(); ++it)
+	{
+		if (static_cast<unsigned char>(*it) > 127)
+		{
+			containsNonASCII = true;
+			break;
+		}
+	}
+	if (!containsNonASCII) return text;
+	
+	std::string encodedText;
+	std::string::size_type lineLength = 0;
+	for (std::string::const_iterator it = text.begin(); it != text.end(); ++it)
+	{
+		if (lineLength == 0)
+		{
+			encodedText += "=?";
+			encodedText += charset;
+			encodedText += "?q?";
+			lineLength += charset.length() + 5;
+		}
+		switch (*it)
+		{
+		case ' ':
+			encodedText += '_';
+			lineLength++;
+			break;
+		case '=':
+		case '?':
+		case '_':
+		case '(':
+		case ')':
+		case '[':
+		case ']':
+		case '<':
+		case '>':
+		case ',':
+		case ';':
+		case ':':
+		case '.':
+		case '@':
+			encodedText += '=';
+			NumberFormatter::appendHex(encodedText, static_cast<unsigned>(static_cast<unsigned char>(*it)), 2);
+			lineLength += 3;
+			break;
+		default:
+			if (*it > 32 && *it < 127)
+			{
+				encodedText += *it;
+				lineLength++;
+			}
+			else
+			{
+				encodedText += '=';
+				NumberFormatter::appendHex(encodedText, static_cast<unsigned>(static_cast<unsigned char>(*it)), 2);
+				lineLength += 3;
+			}
+		}
+		if ((lineLength >= 64 && (*it == ' ' || *it == '\t' || *it == '\r' || *it == '\n')) || lineLength >= 72)
+		{
+			encodedText += "?=\r\n ";
+			lineLength = 0;
+		}
+	}
+	if (lineLength > 0)
+	{
+		encodedText += "?=";
+	}	
+	return encodedText;
+}
+
+
+PartSource* MailMessage::createPartStore(const std::string& content, const std::string& mediaType, const std::string& filename)
+{
+	if (!_pStoreFactory) return new StringPartSource(content, mediaType, filename);
+	else return _pStoreFactory->createPartStore(content, mediaType, filename);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/MailRecipient.cpp b/base/poco/Net/src/MailRecipient.cpp
new file mode 100644
index 00000000000..1f6672810ba
--- /dev/null
+++ b/base/poco/Net/src/MailRecipient.cpp
@@ -0,0 +1,94 @@
+//
+// MailRecipient.cpp
+//
+// Library: Net
+// Package: Mail
+// Module:  MailRecipient
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/MailRecipient.h"
+#include <algorithm>
+
+
+namespace Poco {
+namespace Net {
+
+
+MailRecipient::MailRecipient():
+	_type(PRIMARY_RECIPIENT)
+{
+}
+
+	
+MailRecipient::MailRecipient(const MailRecipient& recipient):
+	_address(recipient._address),
+	_realName(recipient._realName),
+	_type(recipient._type)
+{
+}
+
+	
+MailRecipient::MailRecipient(RecipientType type, const std::string& address):
+	_address(address),
+	_type(type)
+{
+}
+
+
+MailRecipient::MailRecipient(RecipientType type, const std::string& address, const std::string& realName):
+	_address(address),
+	_realName(realName),
+	_type(type)
+{
+}
+
+
+MailRecipient::~MailRecipient()
+{
+}
+
+	
+MailRecipient& MailRecipient::operator = (const MailRecipient& recipient)
+{
+	if (this != &recipient)
+	{
+		MailRecipient tmp(recipient);
+		swap(tmp);
+	}
+	return *this;
+}
+
+
+void MailRecipient::swap(MailRecipient& recipient)
+{
+	std::swap(_type, recipient._type);
+	std::swap(_address, recipient._address);
+	std::swap(_realName, recipient._realName);
+}
+
+	
+void MailRecipient::setType(RecipientType type)
+{
+	_type = type;
+}
+
+	
+void MailRecipient::setAddress(const std::string& address)
+{
+	_address = address;
+}
+
+	
+void MailRecipient::setRealName(const std::string& realName)
+{
+	_realName = realName;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/MailStream.cpp b/base/poco/Net/src/MailStream.cpp
new file mode 100644
index 00000000000..8cd8fa44d86
--- /dev/null
+++ b/base/poco/Net/src/MailStream.cpp
@@ -0,0 +1,221 @@
+//
+// MailStream.cpp
+//
+// Library: Net
+// Package: Mail
+// Module:  MailStream
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/MailStream.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+MailStreamBuf::MailStreamBuf(std::istream& istr):
+	_pIstr(&istr), 
+	_pOstr(0),
+	_state(ST_CR_LF)
+{
+}
+
+
+MailStreamBuf::MailStreamBuf(std::ostream& ostr):
+	_pIstr(0), 
+	_pOstr(&ostr),
+	_state(ST_CR_LF)
+{
+}
+
+
+MailStreamBuf::~MailStreamBuf()
+{
+}
+
+
+void MailStreamBuf::close()
+{
+	if (_pOstr && _state != ST_CR_LF_DOT_CR_LF)
+	{
+		if (!_buffer.empty())
+			_pOstr->write(_buffer.data(), (std::streamsize) _buffer.length());
+		if (_state != ST_CR_LF)
+			_pOstr->write("\r\n", 2);
+		_pOstr->write(".\r\n", 3);
+		_state = ST_CR_LF_DOT_CR_LF;
+	}
+}
+
+		
+int MailStreamBuf::readFromDevice()
+{
+	int c = std::char_traits<char>::eof();
+	if (!_buffer.empty())
+	{
+		c = _buffer[0];
+		_buffer.erase(0, 1);
+	}
+	else
+	{
+		c = readOne();
+		while (c != std::char_traits<char>::eof() && _state != ST_DATA && _state != ST_CR_LF_DOT_CR_LF)
+			c = readOne();
+		if (!_buffer.empty())
+		{
+			c = _buffer[0];
+			_buffer.erase(0, 1);
+		}
+	}
+	return c;
+}
+
+
+int MailStreamBuf::readOne()
+{
+	int c = std::char_traits<char>::eof();
+	if (_state != ST_CR_LF_DOT_CR_LF)
+	{
+		c = _pIstr->get();
+		switch (c)
+		{
+		case '\r':
+			if (_state == ST_CR_LF_DOT)
+				_state = ST_CR_LF_DOT_CR;
+			else
+				_state = ST_CR;
+			break;
+		case '\n':
+			if (_state == ST_CR)
+				_state = ST_CR_LF;
+			else if (_state == ST_CR_LF_DOT_CR)
+				_state = ST_CR_LF_DOT_CR_LF;
+			else
+				_state = ST_DATA;
+			break;
+		case '.':
+			if (_state == ST_CR_LF)
+				_state = ST_CR_LF_DOT;
+			else if (_state == ST_CR_LF_DOT)
+				_state = ST_CR_LF_DOT_DOT;
+			else
+				_state = ST_DATA;
+			break;
+		default:
+			_state = ST_DATA;
+		}
+		if (_state == ST_CR_LF_DOT_DOT)
+			_state = ST_DATA;
+		else if (_state == ST_CR_LF_DOT_CR_LF)
+			_buffer.resize(_buffer.size() - 2);
+		else if (c != std::char_traits<char>::eof())
+			_buffer += (char) c;
+	}
+	return c;
+}
+
+
+int MailStreamBuf::writeToDevice(char c)
+{
+	switch (c)
+	{
+	case '\r':
+		_state = ST_CR;
+		break;
+	case '\n':
+		if (_state == ST_CR)
+			_state = ST_CR_LF;
+		else
+			_state = ST_DATA;
+		break;
+	case '.':
+		if (_state == ST_CR_LF)
+			_state = ST_CR_LF_DOT;
+		else
+			_state = ST_DATA;
+		break;
+	default:
+		_state = ST_DATA;
+	}
+	if (_state == ST_DATA)
+	{
+		if (!_buffer.empty())
+		{
+			_pOstr->write(_buffer.data(), (std::streamsize) _buffer.length());
+			_buffer.clear();
+		}
+		_pOstr->put(c);
+	}
+	else if (_state == ST_CR_LF_DOT)
+	{
+		// buffer contains one or more CR-LF pairs
+		_pOstr->write(_buffer.data(), (std::streamsize) _buffer.length());
+		_pOstr->write("..", 2);
+		_state = ST_DATA;
+		_buffer.clear();
+	}
+	else _buffer += c;
+	return charToInt(c);
+}
+
+
+MailIOS::MailIOS(std::istream& istr): _buf(istr)
+{
+	poco_ios_init(&_buf);
+}
+
+
+MailIOS::MailIOS(std::ostream& ostr): _buf(ostr)
+{
+	poco_ios_init(&_buf);
+}
+
+
+MailIOS::~MailIOS()
+{
+}
+
+
+void MailIOS::close()
+{
+	_buf.close();
+}
+
+
+MailStreamBuf* MailIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+MailInputStream::MailInputStream(std::istream& istr): 
+	MailIOS(istr), 
+	std::istream(&_buf)
+{
+}
+
+
+MailInputStream::~MailInputStream()
+{
+}
+
+
+MailOutputStream::MailOutputStream(std::ostream& ostr): 
+	MailIOS(ostr), 
+	std::ostream(&_buf)
+{
+}
+
+
+MailOutputStream::~MailOutputStream()
+{
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/MediaType.cpp b/base/poco/Net/src/MediaType.cpp
new file mode 100644
index 00000000000..d8a23c9ef25
--- /dev/null
+++ b/base/poco/Net/src/MediaType.cpp
@@ -0,0 +1,191 @@
+//
+// MediaType.cpp
+//
+// Library: Net
+// Package: Messages
+// Module:  MediaType
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/MediaType.h"
+#include "Poco/Net/MessageHeader.h"
+#include "Poco/String.h"
+#include "Poco/Ascii.h"
+#include <algorithm>
+
+
+using Poco::icompare;
+
+
+namespace Poco {
+namespace Net {
+
+
+MediaType::MediaType(const std::string& mediaType)
+{
+	parse(mediaType);
+}
+
+	
+MediaType::MediaType(const std::string& type, const std::string& subType):
+	_type(type),
+	_subType(subType)
+{
+}
+
+
+MediaType::MediaType(const MediaType& mediaType):
+	_type(mediaType._type),
+	_subType(mediaType._subType),
+	_parameters(mediaType._parameters)
+{
+}
+
+
+MediaType::~MediaType()
+{
+}
+
+
+MediaType& MediaType::operator = (const MediaType& mediaType)
+{
+	if (&mediaType != this)
+	{
+		_type       = mediaType._type;
+		_subType    = mediaType._subType;
+		_parameters = mediaType._parameters;
+	}
+	return *this;
+}
+
+	
+MediaType& MediaType::operator = (const std::string& mediaType)
+{
+	parse(mediaType);
+	return *this;
+}
+
+
+void MediaType::swap(MediaType& mediaType)
+{
+	std::swap(_type, mediaType._type);
+	std::swap(_subType, mediaType._subType);
+	_parameters.swap(mediaType._parameters);
+}
+
+	
+void MediaType::setType(const std::string& type)
+{
+	_type = type;
+}
+
+	
+void MediaType::setSubType(const std::string& subType)
+{
+	_subType = subType;
+}
+
+	
+void MediaType::setParameter(const std::string& name, const std::string& value)
+{
+	_parameters.set(name, value);
+}
+
+	
+const std::string& MediaType::getParameter(const std::string& name) const
+{
+	return _parameters.get(name);
+}
+
+	
+bool MediaType::hasParameter(const std::string& name) const
+{
+	return _parameters.has(name);
+}
+
+	
+void MediaType::removeParameter(const std::string& name)
+{
+	_parameters.erase(name);
+}
+
+	
+std::string MediaType::toString() const
+{
+	std::string result;
+	result.append(_type);
+	result.append("/");
+	result.append(_subType);
+	for (NameValueCollection::ConstIterator it = _parameters.begin(); it != _parameters.end(); ++it)
+	{
+		result.append("; ");
+		result.append(it->first);
+		result.append("=");
+		MessageHeader::quote(it->second, result);
+	}
+	return result;
+}
+
+
+bool MediaType::matches(const MediaType& mediaType) const
+{
+	return matches(mediaType._type, mediaType._subType);
+}
+
+	
+bool MediaType::matches(const std::string& type, const std::string& subType) const
+{
+	return icompare(_type, type) == 0 && icompare(_subType, subType) == 0;
+}
+
+
+bool MediaType::matches(const std::string& type) const
+{
+	return icompare(_type, type) == 0;
+}
+
+
+bool MediaType::matchesRange(const MediaType& mediaType) const
+{
+	return matchesRange(mediaType._type, mediaType._subType);
+}
+
+
+bool MediaType::matchesRange(const std::string& type, const std::string& subType) const
+{
+	if (_type == "*" || type == "*" || icompare(_type, type) == 0) 
+	{
+		return _subType == "*" || subType == "*" || icompare(_subType, subType) == 0;
+	}
+	else return false;
+}
+
+
+bool MediaType::matchesRange(const std::string& type) const
+{
+	return _type == "*" || type == "*" || matches(type);
+}
+
+
+void MediaType::parse(const std::string& mediaType)
+{
+	_type.clear();
+	_subType.clear();
+	_parameters.clear();
+	std::string::const_iterator it  = mediaType.begin();
+	std::string::const_iterator end = mediaType.end();
+	while (it != end && Poco::Ascii::isSpace(*it)) ++it;
+	while (it != end && *it != '/') _type += *it++;
+	if (it != end) ++it;
+	while (it != end && *it != ';' && !Poco::Ascii::isSpace(*it)) _subType += *it++;
+	while (it != end && *it != ';') ++it;
+	MessageHeader::splitParameters(it, end, _parameters);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/MessageHeader.cpp b/base/poco/Net/src/MessageHeader.cpp
new file mode 100644
index 00000000000..f1537daf908
--- /dev/null
+++ b/base/poco/Net/src/MessageHeader.cpp
@@ -0,0 +1,394 @@
+//
+// MessageHeader.cpp
+//
+// Library: Net
+// Package: Messages
+// Module:  MessageHeader
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/MessageHeader.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/String.h"
+#include "Poco/Ascii.h"
+#include "Poco/TextConverter.h"
+#include "Poco/StringTokenizer.h"
+#include "Poco/Base64Decoder.h"
+#include "Poco/UTF8Encoding.h"
+#include <sstream>
+
+
+namespace Poco {
+namespace Net {
+
+
+MessageHeader::MessageHeader():
+	_fieldLimit(DFL_FIELD_LIMIT)
+{
+}
+
+
+MessageHeader::MessageHeader(const MessageHeader& messageHeader):
+	NameValueCollection(messageHeader),
+	_fieldLimit(DFL_FIELD_LIMIT)
+{
+}
+
+
+MessageHeader::~MessageHeader()
+{
+}
+
+
+MessageHeader& MessageHeader::operator = (const MessageHeader& messageHeader)
+{
+	NameValueCollection::operator = (messageHeader);
+	return *this;
+}
+
+
+void MessageHeader::write(std::ostream& ostr) const
+{
+	NameValueCollection::ConstIterator it = begin();
+	while (it != end())
+	{
+		ostr << it->first << ": " << it->second << "\r\n";
+		++it;
+	}
+}
+
+
+void MessageHeader::read(std::istream& istr)
+{
+	static const int eof = std::char_traits<char>::eof();
+	std::streambuf& buf = *istr.rdbuf();
+
+	std::string name;
+	std::string value;
+	name.reserve(32);
+	value.reserve(64);
+	int ch = buf.sbumpc();
+	int fields = 0;
+	while (ch != eof && ch != '\r' && ch != '\n')
+	{
+		if (_fieldLimit > 0 && fields == _fieldLimit)
+			throw MessageException("Too many header fields");
+		name.clear();
+		value.clear();
+		while (ch != eof && ch != ':' && ch != '\n' && name.length() < MAX_NAME_LENGTH) { name += ch; ch = buf.sbumpc(); }
+		if (ch == '\n') { ch = buf.sbumpc(); continue; } // ignore invalid header lines
+		if (ch != ':') throw MessageException("Field name too long/no colon found");
+		if (ch != eof) ch = buf.sbumpc(); // ':'
+		while (ch != eof && Poco::Ascii::isSpace(ch) && ch != '\r' && ch != '\n') ch = buf.sbumpc();
+		while (ch != eof && ch != '\r' && ch != '\n' && value.length() < MAX_VALUE_LENGTH) { value += ch; ch = buf.sbumpc(); }
+		if (ch == '\r') ch = buf.sbumpc();
+		if (ch == '\n')
+			ch = buf.sbumpc();
+		else if (ch != eof)
+			throw MessageException("Field value too long/no CRLF found");
+		while (ch == ' ' || ch == '\t') // folding
+		{
+			while (ch != eof && ch != '\r' && ch != '\n' && value.length() < MAX_VALUE_LENGTH) { value += ch; ch = buf.sbumpc(); }
+			if (ch == '\r') ch = buf.sbumpc();
+			if (ch == '\n')
+				ch = buf.sbumpc();
+			else if (ch != eof)
+				throw MessageException("Folded field value too long/no CRLF found");
+		}
+		Poco::trimRightInPlace(value);
+		add(name, decodeWord(value));
+		++fields;
+	}
+	istr.putback(ch);
+}
+
+
+int MessageHeader::getFieldLimit() const
+{
+	return _fieldLimit;
+}
+
+	
+void MessageHeader::setFieldLimit(int limit)
+{
+	poco_assert (limit >= 0);
+	
+	_fieldLimit = limit;
+}
+
+
+bool MessageHeader::hasToken(const std::string& fieldName, const std::string& token) const
+{
+	std::string field = get(fieldName, "");
+	std::vector<std::string> tokens;
+	splitElements(field, tokens, true);
+	for (std::vector<std::string>::const_iterator it = tokens.begin(); it != tokens.end(); ++it)
+	{
+		if (Poco::icompare(*it, token) == 0)
+			return true;
+	}
+	return false;
+}
+
+
+void MessageHeader::splitElements(const std::string& s, std::vector<std::string>& elements, bool ignoreEmpty)
+{
+	elements.clear();
+	std::string::const_iterator it  = s.begin();
+	std::string::const_iterator end = s.end();
+	std::string elem;
+	elem.reserve(64);
+	while (it != end)
+	{
+		if (*it == '"')
+		{
+			elem += *it++;
+			while (it != end && *it != '"')
+			{
+				if (*it == '\\')
+				{
+					++it;
+					if (it != end) elem += *it++;
+				}
+				else elem += *it++;
+			}
+			if (it != end) elem += *it++;
+		}
+		else if (*it == '\\')
+		{
+			++it;
+			if (it != end) elem += *it++;
+		}
+		else if (*it == ',')
+		{
+			Poco::trimInPlace(elem);
+			if (!ignoreEmpty || !elem.empty())
+				elements.push_back(elem);
+			elem.clear();
+			++it;
+		}
+		else elem += *it++;
+	}
+	if (!elem.empty())
+	{
+		Poco::trimInPlace(elem);
+		if (!ignoreEmpty || !elem.empty())
+			elements.push_back(elem);
+	}
+}
+
+
+void MessageHeader::splitParameters(const std::string& s, std::string& value, NameValueCollection& parameters)
+{
+	value.clear();
+	parameters.clear();
+	std::string::const_iterator it  = s.begin();
+	std::string::const_iterator end = s.end();
+	while (it != end && Poco::Ascii::isSpace(*it)) ++it;
+	while (it != end && *it != ';') value += *it++;
+	Poco::trimRightInPlace(value);
+	if (it != end) ++it;
+	splitParameters(it, end, parameters);
+}
+
+
+void MessageHeader::splitParameters(const std::string::const_iterator& begin, const std::string::const_iterator& end, NameValueCollection& parameters)
+{
+	std::string pname;
+	std::string pvalue;
+	pname.reserve(32);
+	pvalue.reserve(64);
+	std::string::const_iterator it = begin;
+	while (it != end)
+	{
+		pname.clear();
+		pvalue.clear();
+		while (it != end && Poco::Ascii::isSpace(*it)) ++it;
+		while (it != end && *it != '=' && *it != ';') pname += *it++;
+		Poco::trimRightInPlace(pname);
+		if (it != end && *it != ';') ++it;
+		while (it != end && Poco::Ascii::isSpace(*it)) ++it;
+		while (it != end && *it != ';')
+		{
+			if (*it == '"')
+			{
+				++it;
+				while (it != end && *it != '"')
+				{
+					if (*it == '\\')
+					{
+						++it;
+						if (it != end) pvalue += *it++;
+					}
+					else pvalue += *it++;
+				}
+				if (it != end) ++it;
+			}
+			else if (*it == '\\')
+			{
+				++it;
+				if (it != end) pvalue += *it++;
+			}
+			else pvalue += *it++;
+		}
+		Poco::trimRightInPlace(pvalue);
+		if (!pname.empty()) parameters.add(pname, pvalue);
+		if (it != end) ++it;
+	}
+}
+
+
+void MessageHeader::quote(const std::string& value, std::string& result, bool allowSpace)
+{
+	bool mustQuote = false;
+	for (std::string::const_iterator it = value.begin(); !mustQuote && it != value.end(); ++it)
+	{
+		if (!Poco::Ascii::isAlphaNumeric(*it) && *it != '.' && *it != '_' && *it != '-' && !(Poco::Ascii::isSpace(*it) && allowSpace))
+			mustQuote = true;
+	}
+	if (mustQuote) result += '"';
+	result.append(value);
+	if (mustQuote) result += '"';
+}
+
+
+void MessageHeader::decodeRFC2047(const std::string& ins, std::string& outs, const std::string& charset_to) 
+{
+	std::string tempout;
+	StringTokenizer tokens(ins, "?");
+
+	std::string charset = toUpper(tokens[0]);
+	std::string encoding = toUpper(tokens[1]);
+	std::string text = tokens[2];
+
+	std::istringstream istr(text);
+
+	if (encoding == "B") 
+	{
+		// Base64 encoding.
+		Base64Decoder decoder(istr);
+		for (char c; decoder.get(c); tempout += c) {}
+	}
+	else if (encoding == "Q") 
+	{
+		// Quoted encoding.				
+		for (char c; istr.get(c);) 
+		{
+			if (c == '_') 
+			{
+				//RFC 2047  _ is a space.
+				tempout += " ";
+				continue;
+			}
+
+			// FIXME: check that we have enought chars-
+			if (c == '=') 
+			{
+				// The next two chars are hex representation of the complete byte.
+				std::string hex;
+				for (int i = 0; i < 2; i++) 
+				{
+					istr.get(c);
+					hex += c;
+				}
+				hex = toUpper(hex);
+				tempout += (char)(int)strtol(hex.c_str(), 0, 16);
+				continue;
+			}
+			tempout += c;
+		}
+	}
+	else 
+	{
+		// Wrong encoding
+		outs = ins;
+		return;
+	}
+
+	// convert to the right charset.
+	if (charset != charset_to) 
+	{
+		try 
+		{
+			TextEncoding& enc = TextEncoding::byName(charset);
+			TextEncoding& dec = TextEncoding::byName(charset_to);
+			TextConverter converter(enc, dec);
+			converter.convert(tempout, outs);
+		}
+		catch (...) 
+		{
+			// FIXME: Unsuported encoding...
+			outs = tempout;
+		}
+	}
+	else 
+	{
+		// Not conversion necesary.
+		outs = tempout;
+	}
+}
+
+
+std::string MessageHeader::decodeWord(const std::string& text, const std::string& charset)
+{
+	std::string outs, tmp = text;
+	do {
+		std::string tmp2;
+		// find the begining of the next rfc2047 chunk 
+		size_t pos = tmp.find("=?");
+		if (pos == std::string::npos) {
+			// No more found, return
+			outs += tmp;
+			break;
+		}
+
+		// check if there are standar text before the rfc2047 chunk, and if so, copy it.
+		if (pos > 0) {
+			outs += tmp.substr(0, pos);
+		}
+
+		// remove text already copied.
+		tmp = tmp.substr(pos + 2);
+
+		// find the first separator
+		size_t pos1 = tmp.find("?");
+		if (pos1 == std::string::npos) {
+			// not found.
+			outs += tmp;
+			break;
+		}
+
+		// find the second separator
+		size_t pos2 = tmp.find("?", pos1 + 1);
+		if (pos2 == std::string::npos) {
+			// not found
+			outs += tmp;
+			break;
+		}
+
+		// find the end of the actual rfc2047 chunk
+		size_t pos3 = tmp.find("?=", pos2 + 1);
+		if (pos3 == std::string::npos) {
+			// not found.
+			outs += tmp;
+			break;
+
+		}
+		// At this place, there are a valid rfc2047 chunk, so decode and copy the result.
+		decodeRFC2047(tmp.substr(0, pos3), tmp2, charset);
+		outs += tmp2;
+
+		// Jump at the rest of the string and repeat the whole process.
+		tmp = tmp.substr(pos3 + 2);
+	} while (true);
+
+	return outs;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/MulticastSocket.cpp b/base/poco/Net/src/MulticastSocket.cpp
new file mode 100644
index 00000000000..e302f6a818a
--- /dev/null
+++ b/base/poco/Net/src/MulticastSocket.cpp
@@ -0,0 +1,289 @@
+//
+// MulticastSocket.cpp
+//
+// Library: Net
+// Package: Sockets
+// Module:  MulticastSocket
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/MulticastSocket.h"
+
+
+#ifdef POCO_NET_HAS_INTERFACE
+
+
+#include "Poco/Net/NetException.h"
+#include <cstring>
+
+
+#if defined(hpux) && defined(_XOPEN_SOURCE_EXTENDED) && defined(POCO_HPUX_IP_MREQ_HACK)
+// netinet/in.h does not define struct ip_mreq if
+// _XOPEN_SOURCE_EXTENDED is #define'd in HP-UX 11.x 
+// versions prior to 11.30. Compile with -DPOCO_HPUX_IP_MREQ_HACK
+// if you experience problems.
+struct ip_mreq 
+{
+	struct in_addr imr_multiaddr;
+	struct in_addr imr_interface;
+};
+#endif
+
+
+// some Unix variants don't have IPV6_ADD_MEMBERSHIP/IPV6_DROP_MEMBERSHIP
+#if defined(IPV6_JOIN_GROUP) && !defined(IPV6_ADD_MEMBERSHIP)
+#define IPV6_ADD_MEMBERSHIP  IPV6_JOIN_GROUP
+#define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP
+#endif
+
+
+namespace Poco {
+namespace Net {
+
+
+MulticastSocket::MulticastSocket()
+{
+}
+
+
+MulticastSocket::MulticastSocket(SocketAddress::Family family): DatagramSocket(family)
+{
+#if defined(POCO_OS_FAMILY_UNIX)
+	if (family == SocketAddress::UNIX_LOCAL)
+		throw Poco::InvalidArgumentException("Cannot create a MulticastSocket with UNIX_LOCAL socket");
+#endif
+}
+
+
+MulticastSocket::MulticastSocket(const SocketAddress& address, bool reuseAddress): DatagramSocket(address, reuseAddress)
+{
+}
+
+
+MulticastSocket::MulticastSocket(const Socket& socket): DatagramSocket(socket)
+{
+}
+
+
+MulticastSocket::~MulticastSocket()
+{
+}
+
+
+MulticastSocket& MulticastSocket::operator = (const Socket& socket)
+{
+	DatagramSocket::operator = (socket);
+	return *this;
+}
+
+
+void MulticastSocket::setInterface(const NetworkInterface& interfc)
+{
+	if (address().family() == SocketAddress::IPv4)
+	{
+		impl()->setOption(IPPROTO_IP, IP_MULTICAST_IF, interfc.firstAddress(IPAddress::IPv4));
+	}
+#if defined(POCO_HAVE_IPv6)
+	else if (address().family() == SocketAddress::IPv6)
+	{
+		impl()->setOption(IPPROTO_IPV6, IPV6_MULTICAST_IF, interfc.index());
+	}
+#endif
+	else throw UnsupportedFamilyException("Unknown or unsupported socket family.");
+}
+
+	
+NetworkInterface MulticastSocket::getInterface() const
+{
+	try
+	{
+		IPAddress addr;
+		impl()->getOption(IPPROTO_IP, IP_MULTICAST_IF, addr);
+		return NetworkInterface::forAddress(addr);
+	}
+	catch (Poco::Exception&)
+	{
+#if defined(POCO_HAVE_IPv6)
+		int ix;
+		impl()->getOption(IPPROTO_IPV6, IPV6_MULTICAST_IF, ix);
+		return NetworkInterface::forIndex(ix);
+#else
+		throw;
+#endif
+	}
+}
+
+	
+void MulticastSocket::setLoopback(bool flag)
+{
+	if (address().af() == AF_INET)
+	{
+		unsigned char uflag = flag ? 1 : 0;
+		impl()->setOption(IPPROTO_IP, IP_MULTICAST_LOOP, uflag);
+	}
+	else
+	{
+#if defined(POCO_HAVE_IPv6)
+		unsigned uflag = flag ? 1 : 0;
+		impl()->setOption(IPPROTO_IPV6, IPV6_MULTICAST_LOOP, uflag);
+#endif
+	}
+}
+
+	
+bool MulticastSocket::getLoopback() const
+{
+	bool flag = false;
+	if (address().af() == AF_INET)
+	{
+		unsigned char uflag;
+		impl()->getOption(IPPROTO_IP, IP_MULTICAST_LOOP, uflag);
+		flag = uflag != 0;
+	}
+	else
+	{
+#if defined(POCO_HAVE_IPv6)
+		unsigned uflag;
+		impl()->getOption(IPPROTO_IPV6, IPV6_MULTICAST_LOOP, uflag);
+		flag = uflag != 0;
+#endif
+	}
+	return flag;
+}
+
+	
+void MulticastSocket::setTimeToLive(unsigned value)
+{
+	if (address().af() == AF_INET)
+	{
+		unsigned char ttl = (unsigned char) value;
+		impl()->setOption(IPPROTO_IP, IP_MULTICAST_TTL, ttl);
+	}
+	else
+	{
+#if defined(POCO_HAVE_IPv6)
+		impl()->setOption(IPPROTO_IPV6, IPV6_MULTICAST_HOPS, value);
+#endif
+	}
+}
+
+	
+unsigned MulticastSocket::getTimeToLive() const
+{
+	unsigned ttl(0);
+	if (address().af() == AF_INET)
+	{
+		unsigned char cttl;
+		impl()->getOption(IPPROTO_IP, IP_MULTICAST_TTL, cttl);
+		ttl = cttl;
+	}
+	else
+	{
+#if defined(POCO_HAVE_IPv6)
+		impl()->getOption(IPPROTO_IPV6, IPV6_MULTICAST_HOPS, ttl);
+#endif
+	}
+	return ttl;
+}
+
+	
+void MulticastSocket::joinGroup(const IPAddress& groupAddress)
+{
+	joinGroup(groupAddress, findFirstInterface(groupAddress));
+}
+
+	
+void MulticastSocket::joinGroup(const IPAddress& groupAddress, const NetworkInterface& interfc)
+{
+	if (groupAddress.af() == AF_INET)
+	{
+		struct ip_mreq mr;
+		std::memcpy(&mr.imr_multiaddr, groupAddress.addr(), groupAddress.length());
+		std::memcpy(&mr.imr_interface, interfc.firstAddress(IPAddress::IPv4).addr(), interfc.firstAddress(IPAddress::IPv4).length());
+		impl()->setRawOption(IPPROTO_IP, IP_ADD_MEMBERSHIP, &mr, sizeof(mr));
+	}
+	else
+	{
+#if defined(POCO_HAVE_IPv6)
+		struct ipv6_mreq mr;
+		std::memcpy(&mr.ipv6mr_multiaddr, groupAddress.addr(), groupAddress.length());
+		mr.ipv6mr_interface = interfc.index();
+		impl()->setRawOption(IPPROTO_IPV6, IPV6_ADD_MEMBERSHIP, &mr, sizeof(mr));
+#endif
+	}
+}
+
+
+NetworkInterface MulticastSocket::findFirstInterface(const IPAddress& groupAddress)
+{
+	NetworkInterface::Map m = NetworkInterface::map();
+	if (groupAddress.family() == IPAddress::IPv4)
+	{
+		for (NetworkInterface::Map::const_iterator it = m.begin(); it != m.end(); ++it)
+		{
+			if (it->second.supportsIPv4() &&
+				it->second.firstAddress(IPAddress::IPv4).isUnicast() &&
+				!it->second.isLoopback() &&
+				!it->second.isPointToPoint())
+			{
+				return it->second;
+			}
+		}
+	}
+#ifdef POCO_HAVE_IPv6
+	else if (groupAddress.family() == IPAddress::IPv6)
+	{
+		for (NetworkInterface::Map::const_iterator it = m.begin(); it != m.end(); ++it)
+		{
+			if (it->second.supportsIPv6() &&
+				it->second.firstAddress(IPAddress::IPv6).isUnicast() &&
+				!it->second.isLoopback() &&
+				!it->second.isPointToPoint())
+			{
+				return it->second;
+			}
+		}
+	}
+#endif // POCO_HAVE_IPv6
+
+	throw NotFoundException("No multicast-eligible network interface found.");
+}
+
+	
+void MulticastSocket::leaveGroup(const IPAddress& groupAddress)
+{
+	NetworkInterface intf;
+	leaveGroup(groupAddress, intf);
+}
+
+	
+void MulticastSocket::leaveGroup(const IPAddress& groupAddress, const NetworkInterface& interfc)
+{
+	if (groupAddress.af() == AF_INET)
+	{
+		struct ip_mreq mr;
+		std::memcpy(&mr.imr_multiaddr, groupAddress.addr(), groupAddress.length());
+		std::memcpy(&mr.imr_interface, interfc.firstAddress(IPAddress::IPv4).addr(), interfc.firstAddress(IPAddress::IPv4).length());
+		impl()->setRawOption(IPPROTO_IP, IP_DROP_MEMBERSHIP, &mr, sizeof(mr));
+	}
+	else
+	{
+#if defined(POCO_HAVE_IPv6)
+		struct ipv6_mreq mr;
+		std::memcpy(&mr.ipv6mr_multiaddr, groupAddress.addr(), groupAddress.length());
+		mr.ipv6mr_interface = interfc.index();
+		impl()->setRawOption(IPPROTO_IPV6, IPV6_DROP_MEMBERSHIP, &mr, sizeof(mr));
+#endif
+	}
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // POCO_NET_HAS_INTERFACE
diff --git a/base/poco/Net/src/MultipartReader.cpp b/base/poco/Net/src/MultipartReader.cpp
new file mode 100644
index 00000000000..29408cd0854
--- /dev/null
+++ b/base/poco/Net/src/MultipartReader.cpp
@@ -0,0 +1,309 @@
+//
+// MultipartReader.cpp
+//
+// Library: Net
+// Package: Messages
+// Module:  MultipartReader
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/MultipartReader.h"
+#include "Poco/Net/MessageHeader.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Ascii.h"
+
+
+using Poco::BufferedStreamBuf;
+
+
+namespace Poco {
+namespace Net {
+
+
+//
+// MultipartStreamBuf
+//
+
+
+MultipartStreamBuf::MultipartStreamBuf(std::istream& istr, const std::string& boundary):
+	BufferedStreamBuf(STREAM_BUFFER_SIZE, std::ios::in),
+	_istr(istr),
+	_boundary(boundary),
+	_lastPart(false)
+{
+	poco_assert (!boundary.empty() && boundary.length() < STREAM_BUFFER_SIZE - 6);
+}
+
+
+MultipartStreamBuf::~MultipartStreamBuf()
+{
+}
+
+
+int MultipartStreamBuf::readFromDevice(char* buffer, std::streamsize length)
+{
+	poco_assert_dbg (length >= _boundary.length() + 6);
+
+	static const int eof = std::char_traits<char>::eof();
+	std::streambuf& buf = *_istr.rdbuf();
+
+	int n  = 0;
+	int ch = buf.sbumpc();
+	if (ch == eof) return -1;
+	*buffer++ = (char) ch; ++n;
+	if (ch == '\n' || (ch == '\r' && buf.sgetc() == '\n'))
+	{
+		if (ch == '\r')
+		{
+			ch = buf.sbumpc(); // '\n'
+			*buffer++ = (char) ch; ++n;
+		}
+		ch = buf.sgetc();
+		if (ch == '\r' || ch == '\n') return n;
+		*buffer++ = (char) buf.sbumpc(); ++n;
+		if (ch == '-' && buf.sgetc() == '-')
+		{
+			ch = buf.sbumpc(); // '-'
+			*buffer++ = (char) ch; ++n;
+			std::string::const_iterator it  = _boundary.begin();
+			std::string::const_iterator end = _boundary.end();
+			ch = buf.sbumpc();
+			*buffer++ = (char) ch; ++n;
+			while (it != end && ch == *it)
+			{
+				++it;
+				ch = buf.sbumpc();
+				*buffer++ = (char) ch; ++n;
+			}
+			if (it == end)
+			{
+				if (ch == '\n' || (ch == '\r' && buf.sgetc() == '\n'))
+				{
+					if (ch == '\r')
+					{
+						buf.sbumpc(); // '\n'
+					}
+					return 0;					
+				}
+				else if (ch == '-' && buf.sgetc() == '-')
+				{
+					buf.sbumpc(); // '-'
+					_lastPart = true;
+					return 0;
+				}
+			}
+		}
+	}
+	ch = buf.sgetc();
+	while (ch != eof && ch != '\r' && ch != '\n' && n < length)
+	{
+		*buffer++ = (char) buf.sbumpc(); ++n;
+		ch = buf.sgetc();
+	}
+	return n;
+}
+
+
+bool MultipartStreamBuf::lastPart() const
+{
+	return _lastPart;
+}
+
+
+//
+// MultipartIOS
+//
+
+
+MultipartIOS::MultipartIOS(std::istream& istr, const std::string& boundary):
+	_buf(istr, boundary)
+{
+	poco_ios_init(&_buf);
+}
+
+
+MultipartIOS::~MultipartIOS()
+{
+	try
+	{
+		_buf.sync();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+MultipartStreamBuf* MultipartIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+bool MultipartIOS::lastPart() const
+{
+	return _buf.lastPart();
+}
+
+
+//
+// MultipartInputStream
+//
+
+
+MultipartInputStream::MultipartInputStream(std::istream& istr, const std::string& boundary):
+	MultipartIOS(istr, boundary),
+	std::istream(&_buf)
+{
+}
+
+
+MultipartInputStream::~MultipartInputStream()
+{
+}
+
+
+//
+// MultipartReader
+//
+
+
+MultipartReader::MultipartReader(std::istream& istr):
+	_istr(istr),
+	_pMPI(0)
+{
+}
+
+
+MultipartReader::MultipartReader(std::istream& istr, const std::string& boundary):
+	_istr(istr),
+	_boundary(boundary),
+	_pMPI(0)
+{
+}
+
+
+MultipartReader::~MultipartReader()
+{
+	delete _pMPI;
+}
+
+
+void MultipartReader::nextPart(MessageHeader& messageHeader)
+{
+	if (!_pMPI)
+	{
+		if (_boundary.empty())
+			guessBoundary();
+		else
+			findFirstBoundary();
+	}
+	else if (_pMPI->lastPart())
+	{
+		throw MultipartException("No more parts available");
+	}
+	parseHeader(messageHeader);
+	delete _pMPI;
+	_pMPI = new MultipartInputStream(_istr, _boundary);
+}
+
+
+bool MultipartReader::hasNextPart()
+{
+	return (!_pMPI || !_pMPI->lastPart()) && _istr.good();
+}
+
+	
+std::istream& MultipartReader::stream() const
+{
+	poco_check_ptr (_pMPI);
+	
+	return *_pMPI;
+}
+
+
+const std::string& MultipartReader::boundary() const
+{
+	return _boundary;
+}
+
+
+void MultipartReader::findFirstBoundary()
+{
+	std::string expect("--");
+	expect.append(_boundary);
+	std::string line;
+	line.reserve(expect.length());
+	bool ok = true;
+	do
+	{
+		ok = readLine(line, expect.length());
+	}
+	while (ok && line != expect);
+
+	if (!ok) throw MultipartException("No boundary line found");
+}
+
+
+void MultipartReader::guessBoundary()
+{
+	static const int eof = std::char_traits<char>::eof();
+	int ch = _istr.get();
+	while (Poco::Ascii::isSpace(ch))
+		ch = _istr.get();
+	if (ch == '-' && _istr.peek() == '-')
+	{
+		_istr.get();
+		ch = _istr.peek();
+		while (ch != eof && ch != '\r' && ch != '\n' && _boundary.size() < 128) // Note: should be no longer than 70 chars acc. to RFC 2046
+		{
+			_boundary += (char) _istr.get();
+			ch = _istr.peek();
+		}
+		if (ch != '\r' && ch != '\n')
+			throw MultipartException("Invalid boundary line found");
+		if (ch == '\r' || ch == '\n')
+			_istr.get();
+		if (_istr.peek() == '\n')
+			_istr.get();
+	}
+	else throw MultipartException("No boundary line found");
+}
+
+
+void MultipartReader::parseHeader(MessageHeader& messageHeader)
+{
+	messageHeader.clear();
+	messageHeader.read(_istr);
+	int ch = _istr.get();
+	if (ch == '\r' && _istr.peek() == '\n') _istr.get();
+}
+
+
+bool MultipartReader::readLine(std::string& line, std::string::size_type n)
+{
+	static const int eof = std::char_traits<char>::eof();
+	static const int maxLength = 1024;
+
+	line.clear();
+	int ch = _istr.peek();
+	int length = 0;
+	while (ch != eof && ch != '\r' && ch != '\n' && length < maxLength)
+	{
+		ch = (char) _istr.get();
+		if (line.length() < n) line += ch;
+		ch = _istr.peek();
+		length++;
+	}
+	if (ch != eof) _istr.get();
+	if (ch == '\r' && _istr.peek() == '\n') _istr.get();
+	return ch != eof && length < maxLength;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/MultipartWriter.cpp b/base/poco/Net/src/MultipartWriter.cpp
new file mode 100644
index 00000000000..831fae10712
--- /dev/null
+++ b/base/poco/Net/src/MultipartWriter.cpp
@@ -0,0 +1,87 @@
+//
+// MultipartWriter.cpp
+//
+// Library: Net
+// Package: Messages
+// Module:  MultipartWriter
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/MultipartWriter.h"
+#include "Poco/Net/MessageHeader.h"
+#include "Poco/Random.h"
+#include "Poco/NumberFormatter.h"
+
+
+using Poco::Random;
+using Poco::NumberFormatter;
+
+
+namespace Poco {
+namespace Net {
+
+
+MultipartWriter::MultipartWriter(std::ostream& ostr):
+	_ostr(ostr),
+	_boundary(createBoundary()),
+	_firstPart(true)
+{
+}
+
+
+MultipartWriter::MultipartWriter(std::ostream& ostr, const std::string& boundary):
+	_ostr(ostr),
+	_boundary(boundary),
+	_firstPart(true)
+{
+	if (_boundary.empty())
+		_boundary = createBoundary();
+}
+
+
+MultipartWriter::~MultipartWriter()
+{
+}
+
+
+void MultipartWriter::nextPart(const MessageHeader& header)
+{
+	if (_firstPart)
+		_firstPart = false;
+	else
+		_ostr << "\r\n";
+	_ostr << "--" << _boundary << "\r\n";
+	header.write(_ostr);
+	_ostr << "\r\n";
+}
+
+
+void MultipartWriter::close()
+{
+	_ostr << "\r\n--" << _boundary << "--\r\n";
+}
+
+
+const std::string& MultipartWriter::boundary() const
+{
+	return _boundary;
+}
+
+
+std::string MultipartWriter::createBoundary()
+{
+	std::string boundary("MIME_boundary_");
+	Random rnd;
+	rnd.seed();
+	NumberFormatter::appendHex(boundary, rnd.next(), 8);
+	NumberFormatter::appendHex(boundary, rnd.next(), 8);
+	return boundary;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/NTPClient.cpp b/base/poco/Net/src/NTPClient.cpp
new file mode 100644
index 00000000000..b370388767b
--- /dev/null
+++ b/base/poco/Net/src/NTPClient.cpp
@@ -0,0 +1,87 @@
+//
+// NTPClient.cpp
+//
+// Library: Net
+// Package: NTP
+// Module:  NTPClient
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/Net/NTPClient.h"
+#include "Poco/Net/NTPPacket.h"
+#include "Poco/Net/DatagramSocket.h"
+#include "Poco/Net/NetException.h"
+
+
+using Poco::TimeoutException;
+
+
+namespace Poco {
+namespace Net {
+
+
+NTPClient::NTPClient(IPAddress::Family family, int timeout): 
+	_family(family), _timeout(timeout)
+{
+}
+
+
+NTPClient::~NTPClient()
+{
+}
+
+
+int NTPClient::request(const std::string& address) const
+{
+	SocketAddress addr(address, 123);
+	return request(addr);
+}
+
+
+int NTPClient::request(SocketAddress& address) const
+{
+	Poco::Net::SocketAddress sa;
+	DatagramSocket ntpSocket(_family);
+	ntpSocket.setReceiveTimeout(_timeout);
+	ntpSocket.bind(sa);
+
+	SocketAddress returnAddress;
+
+	NTPEventArgs eventArgs(address);
+
+	NTPPacket packet;
+	Poco::UInt8 p[1024];
+	packet.packet(&p[0]);
+
+	ntpSocket.sendTo(p, 48, address);
+
+	int received = 0;
+	try
+	{
+		Poco::Net::SocketAddress sender;
+		int n = ntpSocket.receiveFrom(p, sizeof(p)-1, sender);
+
+		if (n < 48) // NTP packet must have at least 48 bytes
+			throw Poco::Net::NTPException("Invalid response received");
+
+		packet.setPacket(p);
+		eventArgs.setPacket(packet);
+		++received;
+		response.notify(this, eventArgs);
+	}
+	catch (Poco::TimeoutException &)
+	{
+		// ignore
+	}
+
+	return received;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/NTPEventArgs.cpp b/base/poco/Net/src/NTPEventArgs.cpp
new file mode 100644
index 00000000000..21c57b87796
--- /dev/null
+++ b/base/poco/Net/src/NTPEventArgs.cpp
@@ -0,0 +1,71 @@
+//
+// NTPEventArgs.cpp
+//
+// Library: Net
+// Package: NTP
+// Module:  NTPEventArgs
+//
+// Implementation of NTPEventArgs
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/NTPEventArgs.h"
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/Net/DNS.h"
+#include "Poco/Exception.h"
+#include "Poco/Net/NetException.h"
+
+
+using Poco::IOException;
+using Poco::InvalidArgumentException;
+
+
+namespace Poco {
+namespace Net {
+
+
+NTPEventArgs::NTPEventArgs(const SocketAddress& address):
+	_address(address), _packet()
+{
+}
+
+
+NTPEventArgs::~NTPEventArgs()
+{
+}
+
+
+std::string NTPEventArgs::hostName() const
+{
+	try
+	{
+		return DNS::resolve(_address.host().toString()).name();
+	}
+	catch (HostNotFoundException&) 
+	{
+	}
+	catch (NoAddressFoundException&) 
+	{
+	}
+	catch (DNSException&)
+	{
+	}
+	catch (IOException&)
+	{
+	}
+	return _address.host().toString();
+}
+
+
+std::string NTPEventArgs::hostAddress() const
+{
+	return _address.host().toString();
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/NTPPacket.cpp b/base/poco/Net/src/NTPPacket.cpp
new file mode 100644
index 00000000000..2f7aec830c3
--- /dev/null
+++ b/base/poco/Net/src/NTPPacket.cpp
@@ -0,0 +1,158 @@
+//
+// NTPPacket.cpp
+//
+// Library: Net
+// Package: NTP
+// Module:  NTPPacket
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/NTPPacket.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Timestamp.h"
+#include "Poco/ByteOrder.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+#if !defined(POCO_COMPILER_SUN)
+#pragma pack(push, 1)
+#else
+#pragma pack(1)
+#endif
+struct NTPPacketData 
+{
+	Poco::Int8 mode:3;
+	Poco::Int8 vn:3;
+	Poco::Int8 li:2;
+	Poco::Int8 stratum;
+	Poco::Int8 pool;
+	Poco::Int8 prec;
+	Poco::Int32 rootdelay;
+	Poco::Int32 rootdisp;
+	Poco::Int32 refid;
+	Poco::Int64 rts;
+	Poco::Int64 ots;
+	Poco::Int64 vts;
+	Poco::Int64 tts;
+};
+#if !defined(POCO_COMPILER_SUN)
+#pragma pack(pop)
+#else
+#pragma pack()
+#endif
+
+
+NTPPacket::NTPPacket() :
+	// the next 3 fields must be in reverse order from spec
+	_leapIndicator(3),
+	_version(4),
+	_mode(3),
+
+	_stratum(0),
+	_pool(6),
+	_precision(-18),
+	_rootDelay(0),
+	_rootDispersion(0),
+	_referenceId(0),
+	_referenceTimestamp(0),
+	_receiveTimestamp(0),
+	_transmitTimestamp(0)
+{
+	Poco::Timestamp ts;
+	_originateTimestamp = ts.utcTime() - 2874597888;
+}
+
+
+NTPPacket::NTPPacket(Poco::UInt8 *packet)
+{
+	setPacket(packet);
+}
+
+
+NTPPacket::~NTPPacket()
+{
+}
+
+
+void NTPPacket::packet(Poco::UInt8 *packet) const
+{
+	NTPPacketData *p = (NTPPacketData*)packet;
+
+	p->li = _leapIndicator;
+	p->vn = _version;
+	p->mode = _mode;
+	p->stratum = _stratum;
+	p->pool = _pool;
+	p->prec = _precision;
+	p->rootdelay = Poco::ByteOrder::toNetwork(_rootDelay);
+	p->rootdisp = Poco::ByteOrder::toNetwork(_rootDispersion);
+	p->refid = Poco::ByteOrder::toNetwork(_referenceId);
+	p->rts = Poco::ByteOrder::toNetwork(_referenceTimestamp);
+	p->ots = Poco::ByteOrder::toNetwork(_originateTimestamp);
+	p->vts = Poco::ByteOrder::toNetwork(_receiveTimestamp);
+	p->tts = Poco::ByteOrder::toNetwork(_transmitTimestamp);
+}
+
+
+void NTPPacket::setPacket(Poco::UInt8 *packet)
+{
+	NTPPacketData *p = (NTPPacketData*)packet;
+
+	_leapIndicator = p->li;
+	_version = p->vn;
+	_mode = p->mode;
+	_stratum = p->stratum;
+	_pool = p->pool;
+	_precision = p->prec;
+	_rootDelay = Poco::ByteOrder::fromNetwork(p->rootdelay);
+	_rootDispersion = Poco::ByteOrder::fromNetwork(p->rootdisp);
+	_referenceId = Poco::ByteOrder::fromNetwork(p->refid);
+	_referenceTimestamp = Poco::ByteOrder::fromNetwork(p->rts);
+	_originateTimestamp = Poco::ByteOrder::fromNetwork(p->ots);
+	_receiveTimestamp = Poco::ByteOrder::fromNetwork(p->vts);
+	_transmitTimestamp = Poco::ByteOrder::fromNetwork(p->tts);
+}
+
+
+Poco::Timestamp NTPPacket::referenceTime() const
+{
+	return convertTime(_referenceTimestamp);
+}
+
+
+Poco::Timestamp NTPPacket::originateTime() const
+{
+	return convertTime(_originateTimestamp);
+}
+
+
+Poco::Timestamp NTPPacket::receiveTime() const
+{
+	return convertTime(_receiveTimestamp);
+}
+
+
+Poco::Timestamp NTPPacket::transmitTime() const
+{
+	return convertTime(_transmitTimestamp);
+}
+
+
+Poco::Timestamp NTPPacket::convertTime(Poco::Int64 tm) const
+{
+	const unsigned long seventyYears = 2208988800UL;
+	Poco::UInt32 secsSince1900 = UInt32(Poco::ByteOrder::toLittleEndian(tm) >> 32);
+	unsigned long epoch = secsSince1900 - seventyYears;
+	return Poco::Timestamp::fromEpochTime(epoch);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/NameValueCollection.cpp b/base/poco/Net/src/NameValueCollection.cpp
new file mode 100644
index 00000000000..def4814a166
--- /dev/null
+++ b/base/poco/Net/src/NameValueCollection.cpp
@@ -0,0 +1,153 @@
+//
+// NameValueCollection.cpp
+//
+// Library: Net
+// Package: Messages
+// Module:  NameValueCollection
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/NameValueCollection.h"
+#include "Poco/Exception.h"
+#include <algorithm>
+
+
+using Poco::NotFoundException;
+
+
+namespace Poco {
+namespace Net {
+
+
+NameValueCollection::NameValueCollection()
+{
+}
+
+
+NameValueCollection::NameValueCollection(const NameValueCollection& nvc):
+	_map(nvc._map)
+{
+}
+
+
+NameValueCollection::~NameValueCollection()
+{
+}
+
+
+NameValueCollection& NameValueCollection::operator = (const NameValueCollection& nvc)
+{
+	if (&nvc != this)
+	{
+		_map = nvc._map;
+	}
+	return *this;
+}
+
+
+void NameValueCollection::swap(NameValueCollection& nvc)
+{
+	std::swap(_map, nvc._map);
+}
+
+	
+const std::string& NameValueCollection::operator [] (const std::string& name) const
+{
+	ConstIterator it = _map.find(name);
+	if (it != _map.end())
+		return it->second;
+	else
+		throw NotFoundException(name);
+}
+
+	
+void NameValueCollection::set(const std::string& name, const std::string& value)	
+{
+	Iterator it = _map.find(name);
+	if (it != _map.end())
+		it->second = value;
+	else
+		_map.insert(HeaderMap::ValueType(name, value));
+}
+
+	
+void NameValueCollection::add(const std::string& name, const std::string& value)
+{
+	_map.insert(HeaderMap::ValueType(name, value));
+}
+
+	
+const std::string& NameValueCollection::get(const std::string& name) const
+{
+	ConstIterator it = _map.find(name);
+	if (it != _map.end())
+		return it->second;
+	else
+		throw NotFoundException(name);
+}
+
+
+const std::string& NameValueCollection::get(const std::string& name, const std::string& defaultValue) const
+{
+	ConstIterator it = _map.find(name);
+	if (it != _map.end())
+		return it->second;
+	else
+		return defaultValue;
+}
+
+
+bool NameValueCollection::has(const std::string& name) const
+{
+	return _map.find(name) != _map.end();
+}
+
+
+NameValueCollection::ConstIterator NameValueCollection::find(const std::string& name) const
+{
+	return _map.find(name);
+}
+
+	
+NameValueCollection::ConstIterator NameValueCollection::begin() const
+{
+	return _map.begin();
+}
+
+	
+NameValueCollection::ConstIterator NameValueCollection::end() const
+{
+	return _map.end();
+}
+
+	
+bool NameValueCollection::empty() const
+{
+	return _map.empty();
+}
+
+
+std::size_t NameValueCollection::size() const
+{
+	return _map.size();
+}
+
+
+void NameValueCollection::erase(const std::string& name)
+{
+	_map.erase(name);
+}
+
+
+void NameValueCollection::clear()
+{
+	_map.clear();
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/Net.cpp b/base/poco/Net/src/Net.cpp
new file mode 100644
index 00000000000..e81b4b54590
--- /dev/null
+++ b/base/poco/Net/src/Net.cpp
@@ -0,0 +1,76 @@
+//
+// Net.cpp
+//
+// Library: Net
+// Package: NetCore
+// Module:  NetCore
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/Net.h"
+
+
+#include "Poco/Net/SocketDefs.h"
+#include "Poco/Net/NetException.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+void Net_API initializeNetwork()
+{
+#if defined(POCO_OS_FAMILY_WINDOWS)
+	WORD    version = MAKEWORD(2, 2);
+	WSADATA data;
+	if (WSAStartup(version, &data) != 0)
+		throw NetException("Failed to initialize network subsystem");
+#endif
+}
+
+
+void Net_API uninitializeNetwork()
+{
+#if defined(POCO_OS_FAMILY_WINDOWS)
+	WSACleanup();
+#endif
+}
+
+
+} } // namespace Poco::Net
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS) && !defined(POCO_NO_AUTOMATIC_LIB_INIT)
+
+	struct NetworkInitializer
+		/// Network initializer for windows statically
+		/// linked library.
+	{
+		NetworkInitializer()
+			/// Calls Poco::Net::initializeNetwork();
+		{
+			Poco::Net::initializeNetwork();
+		}
+
+		~NetworkInitializer()
+			/// Calls Poco::Net::uninitializeNetwork();
+		{
+			try
+			{
+				Poco::Net::uninitializeNetwork();
+			}
+			catch (...)
+			{
+				poco_unexpected();
+			}
+		}
+	};
+
+	const NetworkInitializer pocoNetworkInitializer;
+
+#endif
diff --git a/base/poco/Net/src/NetException.cpp b/base/poco/Net/src/NetException.cpp
new file mode 100644
index 00000000000..a167642b2a3
--- /dev/null
+++ b/base/poco/Net/src/NetException.cpp
@@ -0,0 +1,54 @@
+//
+// NetException.cpp
+//
+// Library: Net
+// Package: NetCore
+// Module:  NetException
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/NetException.h"
+#include <typeinfo>
+
+
+using Poco::IOException;
+
+
+namespace Poco {
+namespace Net {
+
+
+POCO_IMPLEMENT_EXCEPTION(NetException, IOException, "Net Exception")
+POCO_IMPLEMENT_EXCEPTION(InvalidAddressException, NetException, "Invalid address")
+POCO_IMPLEMENT_EXCEPTION(InvalidSocketException, NetException, "Invalid socket")
+POCO_IMPLEMENT_EXCEPTION(ServiceNotFoundException, NetException, "Service not found")
+POCO_IMPLEMENT_EXCEPTION(ConnectionAbortedException, NetException, "Software caused connection abort")
+POCO_IMPLEMENT_EXCEPTION(ConnectionResetException, NetException, "Connection reset by peer")
+POCO_IMPLEMENT_EXCEPTION(ConnectionRefusedException, NetException, "Connection refused")
+POCO_IMPLEMENT_EXCEPTION(DNSException, NetException, "DNS error")
+POCO_IMPLEMENT_EXCEPTION(HostNotFoundException, DNSException, "Host not found")
+POCO_IMPLEMENT_EXCEPTION(NoAddressFoundException, DNSException, "No address found")
+POCO_IMPLEMENT_EXCEPTION(InterfaceNotFoundException, NetException, "Interface not found")
+POCO_IMPLEMENT_EXCEPTION(NoMessageException, NetException, "No message received")
+POCO_IMPLEMENT_EXCEPTION(MessageException, NetException, "Malformed message")
+POCO_IMPLEMENT_EXCEPTION(MultipartException, MessageException, "Malformed multipart message")
+POCO_IMPLEMENT_EXCEPTION(HTTPException, NetException, "HTTP Exception")
+POCO_IMPLEMENT_EXCEPTION(NotAuthenticatedException, HTTPException, "No authentication information found")
+POCO_IMPLEMENT_EXCEPTION(UnsupportedRedirectException, HTTPException, "Unsupported HTTP redirect (protocol change)")
+POCO_IMPLEMENT_EXCEPTION(FTPException, NetException, "FTP Exception")
+POCO_IMPLEMENT_EXCEPTION(SMTPException, NetException, "SMTP Exception")
+POCO_IMPLEMENT_EXCEPTION(POP3Exception, NetException, "POP3 Exception")
+POCO_IMPLEMENT_EXCEPTION(ICMPException, NetException, "ICMP Exception")
+POCO_IMPLEMENT_EXCEPTION(NTPException, NetException, "NTP Exception")
+POCO_IMPLEMENT_EXCEPTION(HTMLFormException, NetException, "HTML Form Exception")
+POCO_IMPLEMENT_EXCEPTION(WebSocketException, NetException, "WebSocket Exception")
+POCO_IMPLEMENT_EXCEPTION(UnsupportedFamilyException, NetException, "Unknown or unsupported socket family")
+POCO_IMPLEMENT_EXCEPTION(AddressFamilyMismatchException, NetException, "Address family mismatch")
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/NetworkInterface.cpp b/base/poco/Net/src/NetworkInterface.cpp
new file mode 100644
index 00000000000..ed520c32b60
--- /dev/null
+++ b/base/poco/Net/src/NetworkInterface.cpp
@@ -0,0 +1,1827 @@
+//
+// NetworkInterface.cpp
+//
+// Library: Net
+// Package: NetCore
+// Module:  NetworkInterface
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/NetworkInterface.h"
+
+
+#ifdef POCO_NET_HAS_INTERFACE
+
+
+#include "Poco/Net/DatagramSocket.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/NumberParser.h"
+#include "Poco/StringTokenizer.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/Format.h"
+#if defined(POCO_OS_FAMILY_WINDOWS)
+	#if defined(POCO_WIN32_UTF8)
+		#include "Poco/UnicodeConverter.h"
+	#endif
+	#include "Poco/Error.h"
+	#include <wincrypt.h>
+	#include <iphlpapi.h>
+	#include <ipifcons.h>
+#endif
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <iomanip>
+
+
+using Poco::NumberFormatter;
+using Poco::FastMutex;
+using Poco::format;
+
+
+std::ostream& operator << (std::ostream& os, const Poco::Net::NetworkInterface::MACAddress& mac)
+{
+	std::ios state(0);
+	state.copyfmt(os);
+	for (unsigned i = 0; i < mac.size(); ++i)
+	{
+		if (i > 0) os << Poco::Net::NetworkInterface::MAC_SEPARATOR;
+		os << std::hex << std::setw(2) << std::setfill('0') << (unsigned) mac[i];
+	}
+	os.copyfmt(state);
+	return os;
+}
+
+
+namespace Poco {
+namespace Net {
+
+
+//
+// NetworkInterfaceImpl
+//
+
+class NetworkInterfaceImpl: public Poco::RefCountedObject
+{
+public:
+	typedef NetworkInterface::AddressTuple AddressTuple;
+	typedef NetworkInterface::AddressList  AddressList;
+	typedef NetworkInterface::Type         Type;
+
+	NetworkInterfaceImpl(unsigned index);
+	NetworkInterfaceImpl(const std::string& name, const std::string& displayName, const std::string& adapterName, const IPAddress& address, unsigned index, NetworkInterface::MACAddress* pMACAddress = 0);
+	NetworkInterfaceImpl(const std::string& name, const std::string& displayName, const std::string& adapterName, unsigned index = 0, NetworkInterface::MACAddress* pMACAddress = 0);
+	NetworkInterfaceImpl(const std::string& name,
+		const std::string& displayName,
+		const std::string& adapterName,
+		const IPAddress& address,
+		const IPAddress& subnetMask,
+		const IPAddress& broadcastAddress,
+		unsigned index,
+		NetworkInterface::MACAddress* pMACAddress = 0);
+
+	unsigned index() const;
+	const std::string& name() const;
+	const std::string& displayName() const;
+	const std::string& adapterName() const;
+	const IPAddress& firstAddress(IPAddress::Family family) const;
+	void addAddress(const AddressTuple& address);
+	const IPAddress& address(unsigned index) const;
+	const NetworkInterface::AddressList& addressList() const;
+	bool hasAddress(const IPAddress& address) const;
+	const IPAddress& subnetMask(unsigned index) const;
+	const IPAddress& broadcastAddress(unsigned index) const;
+	const IPAddress& destAddress(unsigned index) const;
+	const NetworkInterface::MACAddress& macAddress() const;
+	bool supportsIPv4() const;
+	bool supportsIPv6() const;
+
+	void setName(const std::string& name);
+	void setDisplayName(const std::string& name);
+	void setAdapterName(const std::string& name);
+	void addAddress(const IPAddress& addr);
+	void setMACAddress(const NetworkInterface::MACAddress& addr);
+	void setMACAddress(const void *addr, std::size_t len);
+
+	unsigned mtu() const;
+	unsigned ifindex() const;
+	Type type() const;
+
+	bool broadcast() const;
+	bool loopback() const;
+	bool multicast() const;
+	bool pointToPoint() const;
+	bool running() const;
+	bool up() const;
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+	void setFlags(DWORD flags, DWORD iftype);
+	void setRunning(bool running);
+#else
+	void setFlags(short flags);
+#endif
+
+	void setUp(bool up);
+	void setMTU(unsigned mtu);
+	void setType(Type type);
+	void setIndex(unsigned index);
+	void setPhyParams();
+
+protected:
+	~NetworkInterfaceImpl();
+
+private:
+	std::string _name;
+	std::string _displayName;
+	std::string _adapterName;
+	AddressList _addressList;
+	unsigned    _index;
+	bool        _broadcast;
+	bool        _loopback;
+	bool        _multicast;
+	bool        _pointToPoint;
+	bool        _up;
+	bool        _running;
+	unsigned    _mtu;
+	Type        _type;
+
+	NetworkInterface::MACAddress _macAddress;
+
+	friend class NetworkInterface;
+};
+
+
+NetworkInterfaceImpl::NetworkInterfaceImpl(unsigned index):
+	_index(index),
+	_broadcast(false),
+	_loopback(false),
+	_multicast(false),
+	_pointToPoint(false),
+	_up(false),
+	_running(false),
+	_mtu(0),
+	_type(NetworkInterface::NI_TYPE_OTHER)
+{
+}
+
+
+NetworkInterfaceImpl::NetworkInterfaceImpl(const std::string& name, const std::string& displayName, const std::string& adapterName, const IPAddress& address, unsigned index, NetworkInterface::MACAddress* pMACAddress):
+	_name(name),
+	_displayName(displayName),
+	_adapterName(adapterName),
+	_index(index),
+	_broadcast(false),
+	_loopback(false),
+	_multicast(false),
+	_pointToPoint(false),
+	_up(false),
+	_running(false),
+	_mtu(0),
+	_type(NetworkInterface::NI_TYPE_OTHER)
+{
+	_addressList.push_back(AddressTuple(address, IPAddress(), IPAddress()));
+	setPhyParams();
+	if (pMACAddress) setMACAddress(*pMACAddress);
+}
+
+
+NetworkInterfaceImpl::NetworkInterfaceImpl(const std::string& name, const std::string& displayName, const std::string& adapterName, unsigned index, NetworkInterface::MACAddress* pMACAddress):
+	_name(name),
+	_displayName(displayName),
+	_adapterName(adapterName),
+	_index(index),
+	_broadcast(false),
+	_loopback(false),
+	_multicast(false),
+	_pointToPoint(false),
+	_up(false),
+	_running(false),
+	_mtu(0),
+	_type(NetworkInterface::NI_TYPE_OTHER)
+{
+	setPhyParams();
+	if (pMACAddress) setMACAddress(*pMACAddress);
+}
+
+
+NetworkInterfaceImpl::NetworkInterfaceImpl(const std::string& name,
+	const std::string& displayName,
+	const std::string& adapterName,
+	const IPAddress& address,
+	const IPAddress& subnetMask,
+	const IPAddress& broadcastAddress,
+	unsigned index,
+	NetworkInterface::MACAddress* pMACAddress):
+	_name(name),
+	_displayName(displayName),
+	_adapterName(adapterName),
+	_index(index),
+	_broadcast(false),
+	_loopback(false),
+	_multicast(false),
+	_pointToPoint(false),
+	_up(false),
+	_running(false),
+	_mtu(0),
+	_type(NetworkInterface::NI_TYPE_OTHER)
+{
+	_addressList.push_back(AddressTuple(address, subnetMask, broadcastAddress));
+	setPhyParams();
+	if (pMACAddress) setMACAddress(*pMACAddress);
+}
+
+
+void NetworkInterfaceImpl::setPhyParams()
+{
+#if !defined(POCO_OS_FAMILY_WINDOWS) && !defined(POCO_VXWORKS)
+	struct ifreq ifr;
+	std::strncpy(ifr.ifr_name, _name.c_str(), IFNAMSIZ);
+	DatagramSocket ds(SocketAddress::IPv4);
+
+	ds.impl()->ioctl(SIOCGIFFLAGS, &ifr);
+	setFlags(ifr.ifr_flags);
+
+	ds.impl()->ioctl(SIOCGIFMTU, &ifr);
+	setMTU(ifr.ifr_mtu);
+#endif
+}
+
+
+NetworkInterfaceImpl::~NetworkInterfaceImpl()
+{
+}
+
+
+bool NetworkInterfaceImpl::supportsIPv4() const
+{
+	AddressList::const_iterator it = _addressList.begin();
+	AddressList::const_iterator end = _addressList.end();
+	for (; it != end; ++it)
+	{
+		if (IPAddress::IPv4 == it->get<NetworkInterface::IP_ADDRESS>().family())
+			return true;
+	}
+
+	return false;
+}
+
+
+bool NetworkInterfaceImpl::supportsIPv6() const
+{
+#ifdef POCO_HAVE_IPv6
+	AddressList::const_iterator it = _addressList.begin();
+	AddressList::const_iterator end = _addressList.end();
+	for (; it != end; ++it)
+	{
+		if (IPAddress::IPv6 == it->get<NetworkInterface::IP_ADDRESS>().family())
+			return true;
+	}
+#endif
+	return false;
+}
+
+
+inline unsigned NetworkInterfaceImpl::index() const
+{
+	return _index;
+}
+
+
+inline const std::string& NetworkInterfaceImpl::name() const
+{
+	return _name;
+}
+
+
+inline const std::string& NetworkInterfaceImpl::displayName() const
+{
+	return _displayName;
+}
+
+
+inline const std::string& NetworkInterfaceImpl::adapterName() const
+{
+	return _adapterName;
+}
+
+
+const IPAddress& NetworkInterfaceImpl::firstAddress(IPAddress::Family family) const
+{
+	AddressList::const_iterator it = _addressList.begin();
+	AddressList::const_iterator end = _addressList.end();
+	for (;it != end; ++it)
+	{
+		const IPAddress& addr = it->get<NetworkInterface::IP_ADDRESS>();
+		if (addr.family() == family) return addr;
+	}
+
+	throw NotFoundException(format("%s family address not found.", (family == IPAddress::IPv4) ? std::string("IPv4") : std::string("IPv6")));
+}
+
+
+inline void NetworkInterfaceImpl::addAddress(const AddressTuple& address)
+{
+	_addressList.push_back(address);
+}
+
+
+bool NetworkInterfaceImpl::hasAddress(const IPAddress& address) const
+{
+	NetworkInterface::ConstAddressIterator it = _addressList.begin();
+	NetworkInterface::ConstAddressIterator end = _addressList.end();
+	for (; it != end; ++it)
+	{
+		if (it->get<NetworkInterface::IP_ADDRESS>() == address)
+			return true;
+	}
+	return false;
+}
+
+
+inline const IPAddress& NetworkInterfaceImpl::address(unsigned index) const
+{
+	if (index < _addressList.size()) return _addressList[index].get<NetworkInterface::IP_ADDRESS>();
+	else throw NotFoundException(Poco::format("No address with index %u.", index));
+}
+
+
+inline const NetworkInterface::AddressList& NetworkInterfaceImpl::addressList() const
+{
+	return _addressList;
+}
+
+
+const IPAddress& NetworkInterfaceImpl::subnetMask(unsigned index) const
+{
+	if (index < _addressList.size())
+		return _addressList[index].get<NetworkInterface::SUBNET_MASK>();
+
+	throw NotFoundException(Poco::format("No subnet mask with index %u.", index));
+}
+
+
+const IPAddress& NetworkInterfaceImpl::broadcastAddress(unsigned index) const
+{
+	if (index < _addressList.size())
+		return _addressList[index].get<NetworkInterface::BROADCAST_ADDRESS>();
+
+	throw NotFoundException(Poco::format("No subnet mask with index %u.", index));
+}
+
+
+const IPAddress& NetworkInterfaceImpl::destAddress(unsigned index) const
+{
+	if (!pointToPoint())
+		throw InvalidAccessException("Only PPP addresses have destination address.");
+	else if (index < _addressList.size())
+		return _addressList[index].get<NetworkInterface::BROADCAST_ADDRESS>();
+
+	throw NotFoundException(Poco::format("No address with index %u.", index));
+}
+
+
+const NetworkInterface::MACAddress& NetworkInterfaceImpl::macAddress() const
+{
+	return _macAddress;
+}
+
+
+inline unsigned NetworkInterfaceImpl::mtu() const
+{
+	return _mtu;
+}
+
+
+inline NetworkInterface::Type NetworkInterfaceImpl::type() const
+{
+	return _type;
+}
+
+
+inline bool NetworkInterfaceImpl::broadcast() const
+{
+	return _broadcast;
+}
+
+
+inline bool NetworkInterfaceImpl::loopback() const
+{
+	return _loopback;
+}
+
+
+inline bool NetworkInterfaceImpl::multicast() const
+{
+	return _multicast;
+}
+
+
+inline bool NetworkInterfaceImpl::pointToPoint() const
+{
+	return _pointToPoint;
+}
+
+
+inline bool NetworkInterfaceImpl::running() const
+{
+	return _running;
+}
+
+
+inline bool NetworkInterfaceImpl::up() const
+{
+	return _up;
+}
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+
+
+void NetworkInterfaceImpl::setFlags(DWORD flags, DWORD iftype)
+{
+	_running = _up = false;
+	switch (iftype) {
+	case IF_TYPE_ETHERNET_CSMACD:
+	case IF_TYPE_ISO88025_TOKENRING:
+	case IF_TYPE_IEEE80211:
+		_multicast = _broadcast = true;
+		break;
+	case IF_TYPE_SOFTWARE_LOOPBACK:
+		_loopback =  true;
+		break;
+	case IF_TYPE_PPP:
+	case IF_TYPE_ATM:
+	case IF_TYPE_TUNNEL:
+	case IF_TYPE_IEEE1394:
+		_pointToPoint = true;
+		break;
+	}
+	if (!(flags & IP_ADAPTER_NO_MULTICAST))
+		_multicast = true;
+}
+
+
+void NetworkInterfaceImpl::setRunning(bool running)
+{
+	_running = running;
+}
+
+
+#else
+
+
+void NetworkInterfaceImpl::setFlags(short flags)
+{
+#ifdef POCO_OS_FAMILY_UNIX
+	_broadcast = ((flags & IFF_BROADCAST) != 0);
+	_loopback = ((flags & IFF_LOOPBACK) != 0);
+	_multicast = ((flags & IFF_MULTICAST) != 0);
+	_pointToPoint = ((flags & IFF_POINTOPOINT) != 0);
+	_running = ((flags & IFF_RUNNING) != 0);
+	_up = ((flags & IFF_UP) != 0);
+#endif
+}
+
+
+#endif
+
+
+inline void NetworkInterfaceImpl::setUp(bool up)
+{
+	_up = up;
+}
+
+
+inline void NetworkInterfaceImpl::setMTU(unsigned mtu)
+{
+	_mtu = mtu;
+}
+
+
+inline void NetworkInterfaceImpl::setType(Type type)
+{
+	_type = type;
+}
+
+
+inline void NetworkInterfaceImpl::setIndex(unsigned index)
+{
+	_index = index;
+}
+
+
+inline void NetworkInterfaceImpl::setName(const std::string& name)
+{
+	_name = name;
+}
+
+
+inline void NetworkInterfaceImpl::setDisplayName(const std::string& name)
+{
+	_displayName = name;
+}
+
+
+inline void NetworkInterfaceImpl::setAdapterName(const std::string& name)
+{
+	_adapterName = name;
+}
+
+
+inline void NetworkInterfaceImpl::addAddress(const IPAddress& addr)
+{
+	_addressList.push_back(addr);
+}
+
+
+inline void NetworkInterfaceImpl::setMACAddress(const NetworkInterface::MACAddress& addr)
+{
+	_macAddress = addr;
+}
+
+
+inline void NetworkInterfaceImpl::setMACAddress(const void *addr, std::size_t len)
+{
+	_macAddress.clear();
+	_macAddress.insert(_macAddress.end(), static_cast<const unsigned char*>(addr), static_cast<const unsigned char*>(addr) + len);
+}
+
+
+//
+// NetworkInterface
+//
+
+
+FastMutex NetworkInterface::_mutex;
+
+
+NetworkInterface::NetworkInterface(unsigned index):
+	_pImpl(new NetworkInterfaceImpl(index))
+{
+}
+
+
+NetworkInterface::NetworkInterface(const NetworkInterface& interfc):
+	_pImpl(interfc._pImpl)
+{
+	_pImpl->duplicate();
+}
+
+
+NetworkInterface::NetworkInterface(const std::string& name, const std::string& displayName, const std::string& adapterName, const IPAddress& address, unsigned index, MACAddress* pMACAddress):
+	_pImpl(new NetworkInterfaceImpl(name, displayName, adapterName, address, index, pMACAddress))
+{
+}
+
+
+NetworkInterface::NetworkInterface(const std::string& name, const std::string& displayName, const std::string& adapterName, unsigned index, MACAddress* pMACAddress):
+	_pImpl(new NetworkInterfaceImpl(name, displayName, adapterName, index, pMACAddress))
+{
+}
+
+
+NetworkInterface::NetworkInterface(const std::string& name, const IPAddress& address, unsigned index, MACAddress* pMACAddress):
+	_pImpl(new NetworkInterfaceImpl(name, name, name, address, index, pMACAddress))
+{
+}
+
+
+NetworkInterface::NetworkInterface(const std::string& name,
+	const std::string& displayName,
+	const std::string& adapterName,
+	const IPAddress& address,
+	const IPAddress& subnetMask,
+	const IPAddress& broadcastAddress,
+	unsigned index,
+	MACAddress* pMACAddress):
+	_pImpl(new NetworkInterfaceImpl(name, displayName, adapterName, address, subnetMask, broadcastAddress, index, pMACAddress))
+{
+}
+
+
+NetworkInterface::NetworkInterface(const std::string& name,
+	const IPAddress& address,
+	const IPAddress& subnetMask,
+	const IPAddress& broadcastAddress,
+	unsigned index,
+	MACAddress* pMACAddress):
+	_pImpl(new NetworkInterfaceImpl(name, name, name, address, subnetMask, broadcastAddress, index, pMACAddress))
+{
+}
+
+
+NetworkInterface::~NetworkInterface()
+{
+	_pImpl->release();
+}
+
+
+NetworkInterface& NetworkInterface::operator = (const NetworkInterface& interfc)
+{
+	NetworkInterface tmp(interfc);
+	swap(tmp);
+	return *this;
+}
+
+
+void NetworkInterface::swap(NetworkInterface& other)
+{
+	using std::swap;
+	swap(_pImpl, other._pImpl);
+}
+
+
+unsigned NetworkInterface::index() const
+{
+	return _pImpl->index();
+}
+
+
+const std::string& NetworkInterface::name() const
+{
+	return _pImpl->name();
+}
+
+
+const std::string& NetworkInterface::displayName() const
+{
+	return _pImpl->displayName();
+}
+
+
+const std::string& NetworkInterface::adapterName() const
+{
+	return _pImpl->adapterName();
+}
+
+
+const IPAddress& NetworkInterface::firstAddress(IPAddress::Family family) const
+{
+	return _pImpl->firstAddress(family);
+}
+
+
+void NetworkInterface::firstAddress(IPAddress& addr, IPAddress::Family family) const
+{
+	try
+	{
+		addr = firstAddress(family);
+	}
+	catch (NotFoundException&)
+	{
+		addr = IPAddress(family);
+	}
+}
+
+
+void NetworkInterface::addAddress(const IPAddress& address)
+{
+	_pImpl->addAddress(AddressTuple(address, IPAddress(), IPAddress()));
+}
+
+
+void NetworkInterface::addAddress(const IPAddress& address, const IPAddress& subnetMask, const IPAddress& broadcastAddress)
+{
+	_pImpl->addAddress(AddressTuple(address, subnetMask, broadcastAddress));
+}
+
+
+const IPAddress& NetworkInterface::address(unsigned index) const
+{
+	return _pImpl->address(index);
+}
+
+
+const NetworkInterface::AddressList& NetworkInterface::addressList() const
+{
+	return _pImpl->addressList();
+}
+
+
+const IPAddress& NetworkInterface::subnetMask(unsigned index) const
+{
+	return _pImpl->subnetMask(index);
+}
+
+
+const IPAddress& NetworkInterface::broadcastAddress(unsigned index) const
+{
+	return _pImpl->broadcastAddress(index);
+}
+
+
+const NetworkInterface::MACAddress& NetworkInterface::macAddress() const
+{
+	return _pImpl->macAddress();
+}
+
+
+const IPAddress& NetworkInterface::destAddress(unsigned index) const
+{
+	return _pImpl->destAddress(index);
+}
+
+
+unsigned NetworkInterface::mtu() const
+{
+	return _pImpl->mtu();
+}
+
+
+NetworkInterface::Type NetworkInterface::type() const
+{
+	return _pImpl->type();
+}
+
+
+bool NetworkInterface::supportsIP() const
+{
+	return _pImpl->supportsIPv4() || _pImpl->supportsIPv6();
+}
+
+
+bool NetworkInterface::supportsIPv4() const
+{
+	return _pImpl->supportsIPv4();
+}
+
+
+bool NetworkInterface::supportsIPv6() const
+{
+	return _pImpl->supportsIPv6();
+}
+
+
+bool NetworkInterface::supportsBroadcast() const
+{
+	return _pImpl->broadcast();
+}
+
+
+bool NetworkInterface::supportsMulticast() const
+{
+	return _pImpl->multicast();
+}
+
+
+bool NetworkInterface::isLoopback() const
+{
+	return _pImpl->loopback();
+}
+
+
+bool NetworkInterface::isPointToPoint() const
+{
+	return _pImpl->pointToPoint();
+}
+
+
+bool NetworkInterface::isRunning() const
+{
+	return _pImpl->running();
+}
+
+
+bool NetworkInterface::isUp() const
+{
+	return _pImpl->up();
+}
+
+
+NetworkInterface NetworkInterface::forName(const std::string& name, bool requireIPv6)
+{
+	if (requireIPv6) 
+		return forName(name, IPv6_ONLY);
+	else 
+		return forName(name, IPv4_OR_IPv6);
+}
+
+
+NetworkInterface NetworkInterface::forName(const std::string& name, IPVersion ipVersion)
+{
+	Map map = NetworkInterface::map(false, false);
+	Map::const_iterator it = map.begin();
+	Map::const_iterator end = map.end();
+
+	for (; it != end; ++it)
+	{
+		if (it->second.name() == name)
+		{
+			if (ipVersion == IPv4_ONLY && it->second.supportsIPv4())
+				return it->second;
+			else if (ipVersion == IPv6_ONLY && it->second.supportsIPv6())
+				return it->second;
+			else if (ipVersion == IPv4_OR_IPv6)
+				return it->second;
+		}
+	}
+	throw InterfaceNotFoundException(name);
+}
+
+
+NetworkInterface NetworkInterface::forAddress(const IPAddress& addr)
+{
+	Map map = NetworkInterface::map(true, false);
+	Map::const_iterator it = map.begin();
+	Map::const_iterator end = map.end();
+
+	for (; it != end; ++it)
+	{
+		const std::size_t count = it->second.addressList().size();
+		for (int i = 0; i < count; ++i)
+		{
+			if (it->second.address(i) == addr)
+				return it->second;
+		}
+	}
+	throw InterfaceNotFoundException(addr.toString());
+}
+
+
+NetworkInterface NetworkInterface::forIndex(unsigned i)
+{
+	if (i != NetworkInterface::NO_INDEX)
+	{
+		Map map = NetworkInterface::map(false, false);
+		Map::const_iterator it = map.find(i);
+		if (it != map.end())
+			return it->second;
+		else
+			throw InterfaceNotFoundException("#" + NumberFormatter::format(i));
+	}
+	throw InterfaceNotFoundException("#" + NumberFormatter::format(i));
+}
+
+
+NetworkInterface::List NetworkInterface::list(bool ipOnly, bool upOnly)
+{
+	List list;
+	Map m = map(ipOnly, upOnly);
+	NetworkInterface::Map::const_iterator it = m.begin();
+	NetworkInterface::Map::const_iterator end = m.end();
+	for (; it != end; ++it)
+	{
+		int index = it->second.index();
+		std::string name = it->second.name();
+		std::string displayName = it->second.displayName();
+		std::string adapterName = it->second.adapterName();
+		NetworkInterface::MACAddress mac = it->second.macAddress();
+
+		typedef NetworkInterface::AddressList List;
+		const List& ipList = it->second.addressList();
+		if (ipList.size() > 0)
+		{
+			List::const_iterator ipIt = ipList.begin();
+			List::const_iterator ipEnd = ipList.end();
+			for(; ipIt != ipEnd; ++ipIt)
+			{
+				IPAddress addr = ipIt->get<NetworkInterface::IP_ADDRESS>();
+				IPAddress mask = ipIt->get<NetworkInterface::SUBNET_MASK>();
+				NetworkInterface ni;
+				if(mask.isWildcard())
+				{
+					ni = NetworkInterface(name, displayName, adapterName, addr, index, &mac);
+				}
+				else
+				{
+					IPAddress broadcast = ipIt->get<NetworkInterface::BROADCAST_ADDRESS>();
+					ni = NetworkInterface(name, displayName, adapterName, addr, mask, broadcast, index, &mac);
+				}
+
+				ni._pImpl->_broadcast = it->second._pImpl->_broadcast;
+				ni._pImpl->_loopback = it->second._pImpl->_loopback;
+				ni._pImpl->_multicast = it->second._pImpl->_multicast;
+				ni._pImpl->_pointToPoint = it->second._pImpl->_pointToPoint;
+				ni._pImpl->_up = it->second._pImpl->_up;
+				ni._pImpl->_running = it->second._pImpl->_running;
+				ni._pImpl->_mtu = it->second._pImpl->_mtu;
+				ni._pImpl->_type = it->second._pImpl->_type;
+
+				list.push_back(ni);
+			}
+		}
+		else
+		{
+			list.push_back(NetworkInterface(name, displayName, adapterName, index, &mac));
+		}
+	}
+
+	return list;
+}
+
+
+} } // namespace Poco::Net
+
+
+//
+// platform-specific code below
+//
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+//
+// Windows
+//
+
+
+#include "Poco/Buffer.h"
+#include <iterator>
+
+
+namespace Poco {
+namespace Net {
+
+
+namespace {
+
+
+IPAddress getBroadcastAddress(PIP_ADAPTER_PREFIX pPrefix, const IPAddress& addr, ULONG* pprefix = 0)
+	/// This function relies on (1) subnet prefix being at the position
+	/// immediately preceding and (2) broadcast address being at the position
+	/// immediately succeeding the IPv4 unicast address.
+	///
+	/// Since there is no explicit guarantee on order, to ensure correctness,
+	/// the above constraints are checked prior to returning the result.
+	/// Additionally, on pre-Vista versions on Windows, the main structure does
+	/// not contain prefix length; for those platforms, this function
+	/// returns prefix through pprefix argument.
+{
+	PIP_ADAPTER_PREFIX pPrev = 0;
+	for (int i = 0; pPrefix; pPrefix = pPrefix->Next, ++i)
+	{
+		ADDRESS_FAMILY family = pPrefix->Address.lpSockaddr->sa_family;
+		if ((family == AF_INET) && (addr == IPAddress(pPrefix->Address)))
+			break;
+		pPrev = pPrefix;
+	}
+
+	if (pPrefix && pPrefix->Next && pPrev)
+	{
+		IPAddress ipPrefix(pPrev->PrefixLength, IPAddress::IPv4);
+		IPAddress mask(pPrefix->Next->Address);
+		if ((ipPrefix & mask) == (ipPrefix & addr))
+		{
+			if (pprefix) *pprefix = pPrefix->PrefixLength;
+			return IPAddress(pPrefix->Next->Address);
+		}
+	}
+
+	return IPAddress(IPAddress::IPv4);
+}
+
+
+NetworkInterface::Type fromNative(DWORD type)
+{
+	switch (type)
+	{
+	case IF_TYPE_ETHERNET_CSMACD:    return NetworkInterface::NI_TYPE_ETHERNET_CSMACD;
+	case IF_TYPE_ISO88025_TOKENRING: return NetworkInterface::NI_TYPE_ISO88025_TOKENRING;
+	case IF_TYPE_FRAMERELAY:         return NetworkInterface::NI_TYPE_FRAMERELAY;
+	case IF_TYPE_PPP:                return NetworkInterface::NI_TYPE_PPP;
+	case IF_TYPE_SOFTWARE_LOOPBACK:  return NetworkInterface::NI_TYPE_SOFTWARE_LOOPBACK;
+	case IF_TYPE_ATM:                return NetworkInterface::NI_TYPE_ATM;
+	case IF_TYPE_IEEE80211:          return NetworkInterface::NI_TYPE_IEEE80211;
+	case IF_TYPE_TUNNEL:             return NetworkInterface::NI_TYPE_TUNNEL;
+	case IF_TYPE_IEEE1394:           return NetworkInterface::NI_TYPE_IEEE1394;
+	default:                         return NetworkInterface::NI_TYPE_OTHER;
+	}
+}
+
+
+IPAddress subnetMaskForInterface(const std::string& name, bool isLoopback)
+{
+	if (isLoopback)
+	{
+		return IPAddress::parse("255.0.0.0");
+	}
+	else
+	{
+#if !defined(_WIN32_WCE)
+		std::string subKey("SYSTEM\\CurrentControlSet\\services\\Tcpip\\Parameters\\Interfaces\\");
+		subKey += name;
+		std::string netmask;
+		HKEY hKey;
+#if defined(POCO_WIN32_UTF8) && !defined(POCO_NO_WSTRING)
+		std::wstring usubKey;
+		Poco::UnicodeConverter::toUTF16(subKey, usubKey);
+		if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, usubKey.c_str(), 0, KEY_READ, &hKey) != ERROR_SUCCESS)
+			return IPAddress();
+		wchar_t unetmask[16];
+		DWORD size = sizeof(unetmask);
+		if (RegQueryValueExW(hKey, L"DhcpSubnetMask", NULL, NULL, (LPBYTE)&unetmask, &size) != ERROR_SUCCESS)
+		{
+			if (RegQueryValueExW(hKey, L"SubnetMask", NULL, NULL, (LPBYTE)&unetmask, &size) != ERROR_SUCCESS)
+			{
+				RegCloseKey(hKey);
+				return IPAddress();
+			}
+		}
+		Poco::UnicodeConverter::toUTF8(unetmask, netmask);
+#else
+		if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, subKey.c_str(), 0, KEY_READ, &hKey) != ERROR_SUCCESS)
+			return IPAddress();
+		char unetmask[16];
+		DWORD size = sizeof(unetmask);
+		if (RegQueryValueExA(hKey, "DhcpSubnetMask", NULL, NULL, (LPBYTE)&unetmask, &size) != ERROR_SUCCESS)
+		{
+			if (RegQueryValueExA(hKey, "SubnetMask", NULL, NULL, (LPBYTE)&unetmask, &size) != ERROR_SUCCESS)
+			{
+				RegCloseKey(hKey);
+				return IPAddress();
+			}
+		}
+		netmask = unetmask;
+#endif
+		RegCloseKey(hKey);
+		return IPAddress::parse(netmask);
+#else
+		return IPAddress();
+#endif // !defined(_WIN32_WCE)
+	}
+}
+
+
+} /// namespace
+
+
+NetworkInterface::Map NetworkInterface::map(bool ipOnly, bool upOnly)
+{
+	OSVERSIONINFO osvi;
+	ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
+	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+	GetVersionEx(&osvi);
+
+	FastMutex::ScopedLock lock(_mutex);
+	Map result;
+	ULONG outBufLen = 16384;
+	Poco::Buffer<UCHAR> memory(outBufLen);
+	ULONG flags = (GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_INCLUDE_PREFIX);
+#ifdef GAA_FLAG_INCLUDE_ALL_INTERFACES
+	flags |= GAA_FLAG_INCLUDE_ALL_INTERFACES;
+#endif
+#if defined(POCO_HAVE_IPv6)
+	const unsigned family = AF_UNSPEC; //IPv4 and IPv6
+#else
+	const unsigned family = AF_INET; //IPv4 only
+#endif
+	DWORD dwRetVal = 0;
+	ULONG iterations = 0;
+	PIP_ADAPTER_ADDRESSES pAddress = 0;
+	do
+	{
+		pAddress = reinterpret_cast<IP_ADAPTER_ADDRESSES*>(memory.begin()); // leave in the loop, begin may change after resize
+		poco_assert (memory.capacity() >= outBufLen);
+		if (ERROR_BUFFER_OVERFLOW == (dwRetVal = GetAdaptersAddresses(family, flags, 0, pAddress, &outBufLen)))
+			memory.resize(outBufLen, false); // adjust size and try again
+		else if (ERROR_NO_DATA == dwRetVal) // no network interfaces found
+			return result;
+		else if (NO_ERROR != dwRetVal) // error occurred
+			throw SystemException(format("An error occurred while trying to obtain list of network interfaces: [%s]", Error::getMessage(dwRetVal)));
+		else
+			break;
+	} 
+	while ((ERROR_BUFFER_OVERFLOW == dwRetVal) && (++iterations <= 2));
+
+	poco_assert (NO_ERROR == dwRetVal);
+	for (; pAddress; pAddress = pAddress->Next)
+	{
+		IPAddress address;
+		IPAddress subnetMask;
+		IPAddress broadcastAddress;
+		unsigned ifIndex = 0;
+
+#if defined(POCO_HAVE_IPv6)
+	#if defined(_WIN32_WCE)
+		ifIndex = pAddress->Ipv6IfIndex;
+	#elif (_WIN32_WINNT >= 0x0501) && (NTDDI_VERSION >= 0x05010100) // Win XP SP1
+		#if defined (IP_ADAPTER_IPV6_ENABLED) // Vista
+			if(osvi.dwMajorVersion>=6)//vista
+			{
+				if ((pAddress->Flags & IP_ADAPTER_IPV6_ENABLED) &&
+					(osvi.dwMajorVersion >= 5) &&
+					(osvi.dwMinorVersion >= 1) &&
+					(osvi.dwBuildNumber >=1))
+				{
+					ifIndex = pAddress->Ipv6IfIndex;
+				}
+			}
+			else
+			{
+				if ((osvi.dwMajorVersion >= 5) &&
+					(osvi.dwMinorVersion >= 1) &&
+					(osvi.dwBuildNumber >= 1))
+				{
+					ifIndex = pAddress->Ipv6IfIndex;
+				}
+			}
+		#else // !defined(IP_ADAPTER_IPV6_ENABLED)
+			if ((osvi.dwMajorVersion >= 5) &&
+				(osvi.dwMinorVersion >= 1) &&
+				(osvi.dwBuildNumber >= 1))
+			{
+				ifIndex = pAddress->Ipv6IfIndex;
+			}
+		#endif // defined(IP_ADAPTER_IPV6_ENABLED)
+	#endif // (_WIN32_WINNT >= 0x0501) && (NTDDI_VERSION >= 0x05010100)
+#endif // POCO_HAVE_IPv6
+
+#if defined (IP_ADAPTER_IPV4_ENABLED)
+		if(osvi.dwMajorVersion>=6)
+		{//vista
+			if (pAddress->Flags & IP_ADAPTER_IPV4_ENABLED)
+			{
+				ifIndex = pAddress->IfIndex;
+			}
+		}
+		else
+		{
+			ifIndex = pAddress->IfIndex;
+		}
+#else // !IP_ADAPTER_IPV4_ENABLED
+		ifIndex = pAddress->IfIndex;
+#endif
+		if (ifIndex == 0) continue;
+
+		std::string name;
+		std::string displayName;
+		std::string adapterName(pAddress->AdapterName);
+#ifdef POCO_WIN32_UTF8
+		Poco::UnicodeConverter::toUTF8(pAddress->FriendlyName, name);
+		Poco::UnicodeConverter::toUTF8(pAddress->Description, displayName);
+#else
+		char nameBuffer[1024];
+		int rc = WideCharToMultiByte(CP_ACP, 0, pAddress->FriendlyName, -1, nameBuffer, sizeof(nameBuffer), NULL, NULL);
+		if (rc) name = nameBuffer;
+		char displayNameBuffer[1024];
+		rc = WideCharToMultiByte(CP_ACP, 0, pAddress->Description, -1, displayNameBuffer, sizeof(displayNameBuffer), NULL, NULL);
+		if (rc) displayName = displayNameBuffer;
+#endif
+
+		bool isUp = (pAddress->OperStatus == IfOperStatusUp);
+		bool isIP = (0 != pAddress->FirstUnicastAddress);
+		if (((ipOnly && isIP) || !ipOnly) && ((upOnly && isUp) || !upOnly))
+		{
+			NetworkInterface ni(name, displayName, adapterName, ifIndex);
+			// Create interface even if it has an empty list of addresses; also, set
+			// physical attributes which are protocol independent (name, media type,
+			// MAC address, MTU, operational status, etc).
+			Map::iterator ifIt = result.find(ifIndex);
+			if (ifIt == result.end())
+				ifIt = result.insert(Map::value_type(ifIndex, ni)).first;
+
+			ifIt->second.impl().setFlags(pAddress->Flags, pAddress->IfType);
+			ifIt->second.impl().setMTU(pAddress->Mtu);
+			ifIt->second.impl().setUp(pAddress->OperStatus == IfOperStatusUp);
+#if (_WIN32_WINNT >= 0x0600) // Vista and newer only
+			if ((osvi.dwMajorVersion >= 6) &&
+				(osvi.dwMinorVersion >= 0) &&
+				(osvi.dwBuildNumber >= 0))
+			{
+				ifIt->second.impl().setRunning(pAddress->ReceiveLinkSpeed > 0 || pAddress->TransmitLinkSpeed > 0);
+			}
+#endif
+			ifIt->second.impl().setType(fromNative(pAddress->IfType));
+			if (pAddress->PhysicalAddressLength)
+				ifIt->second.impl().setMACAddress(pAddress->PhysicalAddress, pAddress->PhysicalAddressLength);
+
+			for (PIP_ADAPTER_UNICAST_ADDRESS pUniAddr = pAddress->FirstUnicastAddress;
+				pUniAddr;
+				pUniAddr = pUniAddr->Next)
+			{
+				address = IPAddress(pUniAddr->Address);
+				ADDRESS_FAMILY family = pUniAddr->Address.lpSockaddr->sa_family;
+				switch (family)
+				{
+				case AF_INET:
+				{
+					// Windows lists broadcast address on localhost
+					bool hasBroadcast = (pAddress->IfType == IF_TYPE_ETHERNET_CSMACD) || (pAddress->IfType == IF_TYPE_SOFTWARE_LOOPBACK) || (pAddress->IfType == IF_TYPE_IEEE80211);
+					if (hasBroadcast)
+					{
+						// On Windows, a valid broadcast address will be all 1's (== address | ~subnetMask); additionaly, on pre-Vista versions of
+						// OS, master address structure does not contain member for prefix length; we go an extra mile here in order to make sure
+						// we reflect the actual values held by system and protect against misconfiguration (e.g. bad DHCP config entry)
+						ULONG prefixLength = 0;
+#if defined(_WIN32_WCE)
+	#if _WIN32_WCE >= 0x0800
+						prefixLength = pUniAddr->OnLinkPrefixLength;
+						broadcastAddress = getBroadcastAddress(pAddress->FirstPrefix, address);
+	#else
+						broadcastAddress = getBroadcastAddress(pAddress->FirstPrefix, address, &prefixLength);
+	#endif
+						// if previous call did not do it, make last-ditch attempt for prefix and broadcast
+						if (prefixLength == 0 && pAddress->FirstPrefix)
+							prefixLength = pAddress->FirstPrefix->PrefixLength;
+						poco_assert (prefixLength <= 32);
+						if (broadcastAddress.isWildcard())
+						{
+							IPAddress mask(static_cast<unsigned>(prefixLength), IPAddress::IPv4);
+							IPAddress host(mask & address);
+							broadcastAddress = host | ~mask;
+						}
+#elif (_WIN32_WINNT >= 0x0501) && (NTDDI_VERSION >= 0x05010100) // Win XP SP1
+	#if (_WIN32_WINNT >= 0x0600) // Vista and newer
+						if (osvi.dwMajorVersion >= 6)
+						{
+							prefixLength = pUniAddr->OnLinkPrefixLength;
+							broadcastAddress = getBroadcastAddress(pAddress->FirstPrefix, address);
+						}
+						else
+						{
+							broadcastAddress = getBroadcastAddress(pAddress->FirstPrefix, address, &prefixLength);
+						}
+	#else
+						broadcastAddress = getBroadcastAddress(pAddress->FirstPrefix, address, &prefixLength);
+	#endif
+						poco_assert (prefixLength <= 32);
+						if (broadcastAddress.isWildcard())
+						{
+							IPAddress mask(static_cast<unsigned>(prefixLength), IPAddress::IPv4);
+							IPAddress host(mask & address);
+							broadcastAddress = host | ~mask;
+						}
+#endif // (_WIN32_WINNT >= 0x0501) && (NTDDI_VERSION >= 0x05010100)
+						if (prefixLength)
+						{
+							subnetMask = IPAddress(static_cast<unsigned>(prefixLength), IPAddress::IPv4);
+						}
+						else // if all of the above fails, look up the subnet mask in the registry
+						{
+							address = IPAddress(&reinterpret_cast<struct sockaddr_in*>(pUniAddr->Address.lpSockaddr)->sin_addr, sizeof(in_addr));
+							subnetMask = subnetMaskForInterface(name, address.isLoopback());
+							if (!address.isLoopback())
+							{
+								broadcastAddress = address;
+								broadcastAddress.mask(subnetMask, IPAddress::broadcast());
+							}
+						}
+						ifIt->second.addAddress(address, subnetMask, broadcastAddress);
+					}
+					else
+					{
+						ifIt->second.addAddress(address);
+					}
+				} 
+				break;
+#if defined(POCO_HAVE_IPv6)
+				case AF_INET6:
+					ifIt->second.addAddress(address);
+					break;
+#endif
+				} // switch family
+			} // for addresses
+		} // if ipOnly/upOnly
+	} // for adapters
+	return result;
+}
+
+
+} } // namespace Poco::Net
+
+
+#elif defined(POCO_VXWORKS)
+//
+// VxWorks
+//
+
+#error TODO
+
+/*
+namespace Poco {
+namespace Net {
+
+
+NetworkInterface::NetworkInterfaceList NetworkInterface::list()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	NetworkInterfaceList result;
+
+	int ifIndex = 1;
+	char ifName[32];
+	char ifAddr[INET_ADDR_LEN];
+
+	for (;;)
+	{
+		if (ifIndexToIfName(ifIndex, ifName) == OK)
+		{
+			std::string name(ifName);
+			IPAddress addr;
+			IPAddress mask;
+			IPAddress bcst;
+			if (ifAddrGet(ifName, ifAddr) == OK)
+			{
+				addr = IPAddress(std::string(ifAddr));
+			}
+			int ifMask;
+			if (ifMaskGet(ifName, &ifMask) == OK)
+			{
+				mask = IPAddress(&ifMask, sizeof(ifMask));
+			}
+			if (ifBroadcastGet(ifName, ifAddr) == OK)
+			{
+				bcst = IPAddress(std::string(ifAddr));
+			}
+			result.push_back(NetworkInterface(name, name, name, addr, mask, bcst));
+			ifIndex++;
+		}
+		else break;
+	}
+
+	return result;
+}
+
+
+} } // namespace Poco::Net
+*/
+
+#elif defined(POCO_OS_FAMILY_BSD) || (POCO_OS == POCO_OS_QNX) || (POCO_OS == POCO_OS_SOLARIS)
+//
+// BSD variants, QNX(?) and Solaris
+//
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <ifaddrs.h>
+#include <net/if.h>
+#include <net/if_dl.h>
+#ifndef POCO_NO_NET_IFTYPES
+#include <net/if_types.h>
+#endif
+
+
+namespace Poco {
+namespace Net {
+
+
+namespace {
+
+
+NetworkInterface::Type fromNative(u_char nativeType)
+{
+	switch (nativeType)
+	{
+#ifndef POCO_NO_NET_IFTYPES
+		case IFT_ETHER:		return NetworkInterface::NI_TYPE_ETHERNET_CSMACD;
+		case IFT_ISO88025:	return NetworkInterface::NI_TYPE_ISO88025_TOKENRING;
+		case IFT_FRELAY:	return NetworkInterface::NI_TYPE_FRAMERELAY;
+		case IFT_PPP:		return NetworkInterface::NI_TYPE_PPP;
+		case IFT_LOOP:		return NetworkInterface::NI_TYPE_SOFTWARE_LOOPBACK;
+		case IFT_ATM:		return NetworkInterface::NI_TYPE_ATM;
+#if (POCO_OS != POCO_OS_SOLARIS)
+		case IFT_IEEE1394:	return NetworkInterface::NI_TYPE_IEEE1394;
+#endif
+#endif
+		default:			return NetworkInterface::NI_TYPE_OTHER;
+
+	}
+}
+
+
+void setInterfaceParams(struct ifaddrs* iface, NetworkInterfaceImpl& impl)
+{
+	struct sockaddr_dl* sdl = (struct sockaddr_dl*) iface->ifa_addr;
+	impl.setName(iface->ifa_name);
+	impl.setDisplayName(iface->ifa_name);
+	impl.setAdapterName(iface->ifa_name);
+	impl.setPhyParams();
+
+	impl.setMACAddress(LLADDR(sdl), sdl->sdl_alen);
+	impl.setType(fromNative(sdl->sdl_type));
+}
+
+
+} // namespace
+
+
+NetworkInterface::Map NetworkInterface::map(bool ipOnly, bool upOnly)
+{
+	FastMutex::ScopedLock lock(_mutex);
+	Map result;
+	unsigned ifIndex = 0;
+	NetworkInterface intf;
+	Map::iterator ifIt;
+
+	struct ifaddrs* ifaces = 0;
+	struct ifaddrs* currIface = 0;
+
+	if (getifaddrs(&ifaces) < 0)
+		throw NetException("cannot get network adapter list");
+
+	try
+	{
+		for (currIface = ifaces; currIface != 0; currIface = currIface->ifa_next)
+		{
+			if (!currIface->ifa_addr) continue;
+
+			IPAddress address, subnetMask, broadcastAddress;
+			unsigned family = currIface->ifa_addr->sa_family;
+			switch (family)
+			{
+#if defined(POCO_OS_FAMILY_BSD)
+			case AF_LINK:
+			{
+				struct sockaddr_dl* sdl = (struct sockaddr_dl*) currIface->ifa_addr;
+				ifIndex = sdl->sdl_index;
+				intf = NetworkInterface(ifIndex);
+				setInterfaceParams(currIface, intf.impl());
+				if ((result.find(ifIndex) == result.end()) && ((upOnly && intf.isUp()) || !upOnly))
+					ifIt = result.insert(Map::value_type(ifIndex, intf)).first;
+				break;
+			}
+#endif
+			case AF_INET:
+				ifIndex = if_nametoindex(currIface->ifa_name);
+				ifIt = result.find(ifIndex);
+				intf = NetworkInterface(ifIndex);
+				setInterfaceParams(currIface, intf.impl());
+				if ((ifIt == result.end()) && ((upOnly && intf.isUp()) || !upOnly))
+					ifIt = result.insert(Map::value_type(ifIndex, intf)).first;
+
+				address = IPAddress(*(currIface->ifa_addr));
+
+				if (( currIface->ifa_flags & IFF_LOOPBACK ) == 0 && currIface->ifa_netmask)
+					subnetMask = IPAddress(*(currIface->ifa_netmask));
+
+				if (currIface->ifa_flags & IFF_BROADCAST && currIface->ifa_broadaddr)
+					broadcastAddress = IPAddress(*(currIface->ifa_broadaddr));
+				else if (currIface->ifa_flags & IFF_POINTOPOINT && currIface->ifa_dstaddr)
+					broadcastAddress = IPAddress(*(currIface->ifa_dstaddr));
+				else
+					broadcastAddress = IPAddress();
+				break;
+#if defined(POCO_HAVE_IPv6)
+			case AF_INET6:
+				ifIndex = if_nametoindex(currIface->ifa_name);
+				ifIt = result.find(ifIndex);
+				intf = NetworkInterface(ifIndex);
+				setInterfaceParams(currIface, intf.impl());
+				if ((ifIt == result.end()) && ((upOnly && intf.isUp()) || !upOnly))
+					ifIt = result.insert(Map::value_type(ifIndex, intf)).first;
+
+				address = IPAddress(&reinterpret_cast<const struct sockaddr_in6*>(currIface->ifa_addr)->sin6_addr,
+					sizeof(struct in6_addr), ifIndex);
+				subnetMask = IPAddress(*(currIface->ifa_netmask));
+				broadcastAddress = IPAddress();
+				break;
+#endif
+			default:
+				continue;
+			}
+
+			if (family == AF_INET
+#ifdef POCO_HAVE_IPv6
+			|| family == AF_INET6
+#endif
+			)
+			{
+				if ((upOnly && intf.isUp()) || !upOnly)
+				{
+					if ((ifIt = result.find(ifIndex)) != result.end())
+						ifIt->second.addAddress(address, subnetMask, broadcastAddress);
+				}
+			}
+		}
+	}
+	catch (...)
+	{
+	}
+	if (ifaces) freeifaddrs(ifaces);
+
+	if (ipOnly)
+	{
+		Map::iterator it = result.begin();
+		Map::iterator end = result.end();
+		for (; it != end;)
+		{
+			if (!it->second.supportsIPv4() && !it->second.supportsIPv6())
+				result.erase(it++);
+			else ++it;
+		}
+	}
+
+	return result;
+}
+
+
+} } // namespace Poco::Net
+
+
+#elif POCO_OS == POCO_OS_LINUX || POCO_OS == POCO_OS_ANDROID
+//
+// Linux
+//
+
+
+#include <sys/types.h>
+#if POCO_OS != POCO_OS_ANDROID // Android doesn't have <ifaddrs.h>
+#include <ifaddrs.h>
+#endif
+#include <net/if.h>
+#ifndef POCO_NO_LINUX_IF_PACKET_H
+#include <linux/if_packet.h>
+#endif
+#include <net/if_arp.h>
+#include <iostream>
+
+namespace Poco {
+namespace Net {
+
+
+namespace {
+
+
+static NetworkInterface::Type fromNative(unsigned arphrd)
+{
+	switch (arphrd)
+	{
+	case ARPHRD_ETHER:     return NetworkInterface::NI_TYPE_ETHERNET_CSMACD;
+	case ARPHRD_IEEE802:   return NetworkInterface::NI_TYPE_ISO88025_TOKENRING;
+	case ARPHRD_DLCI:      return NetworkInterface::NI_TYPE_FRAMERELAY;
+	case ARPHRD_PPP:       return NetworkInterface::NI_TYPE_PPP;
+	case ARPHRD_LOOPBACK:  return NetworkInterface::NI_TYPE_SOFTWARE_LOOPBACK;
+	case ARPHRD_ATM:       return NetworkInterface::NI_TYPE_ATM;
+	case ARPHRD_IEEE80211: return NetworkInterface::NI_TYPE_IEEE80211;
+	case ARPHRD_TUNNEL:
+	case ARPHRD_TUNNEL6:   return NetworkInterface::NI_TYPE_TUNNEL;
+	case ARPHRD_IEEE1394:  return NetworkInterface::NI_TYPE_IEEE1394;
+	default:               return NetworkInterface::NI_TYPE_OTHER;
+	}
+}
+
+#if POCO_OS != POCO_OS_ANDROID
+
+void setInterfaceParams(struct ifaddrs* iface, NetworkInterfaceImpl& impl)
+{
+	impl.setName(iface->ifa_name);
+	impl.setDisplayName(iface->ifa_name);
+	impl.setAdapterName(iface->ifa_name);
+	impl.setPhyParams();
+
+#ifndef POCO_NO_LINUX_IF_PACKET_H
+	struct sockaddr_ll* sdl = (struct sockaddr_ll*) iface->ifa_addr;
+	impl.setMACAddress(sdl->sll_addr, sdl->sll_halen);
+	impl.setType(fromNative(sdl->sll_hatype));
+#else
+	std::string ifPath("/sys/class/net/");
+	ifPath += iface->ifa_name;
+
+	std::string addrPath(ifPath);
+	addrPath += "/address";
+	
+	std::ifstream addrStream(addrPath.c_str());
+	if (addrStream.good())
+	{
+		std::string addr;
+		std::getline(addrStream, addr);
+		Poco::StringTokenizer tok(addr, ":");
+		std::vector<unsigned char> mac;
+		for (Poco::StringTokenizer::Iterator it = tok.begin(); it != tok.end(); ++it)
+		{
+			mac.push_back(static_cast<unsigned char>(Poco::NumberParser::parseHex(*it)));
+		}
+		impl.setMACAddress(&mac[0], mac.size());
+		addrStream.close();
+	}
+	
+	std::string typePath(ifPath);
+	typePath += "/type";
+	std::ifstream typeStream(typePath.c_str());
+	if (typeStream.good())
+	{
+		int type;
+		typeStream >> type;
+		impl.setType(fromNative(type));
+		typeStream.close();
+	}
+#endif // POCO_NO_LINUX_IF_PACKET_H
+}
+
+#endif
+
+
+}
+
+
+NetworkInterface::Map NetworkInterface::map(bool ipOnly, bool upOnly)
+{
+#if POCO_OS != POCO_OS_ANDROID
+	FastMutex::ScopedLock lock(_mutex);
+	Map result;
+	unsigned ifIndex = 0;
+	NetworkInterface intf;
+	Map::iterator ifIt;
+
+	struct ifaddrs* ifaces = 0;
+	struct ifaddrs* iface = 0;
+
+	if (getifaddrs(&ifaces) < 0)
+		throw NetException("cannot get network adapter list");
+
+	try
+	{
+		for (iface = ifaces; iface; iface = iface->ifa_next)
+		{
+			if (!iface->ifa_addr) continue;
+
+			IPAddress address, subnetMask, broadcastAddress;
+			unsigned family = iface->ifa_addr->sa_family;
+			switch (family)
+			{
+#ifndef POCO_NO_LINUX_IF_PACKET_H
+			case AF_PACKET:
+			{
+				struct sockaddr_ll* sll = (struct sockaddr_ll*)iface->ifa_addr;
+				ifIndex = sll->sll_ifindex;
+				intf = NetworkInterface(ifIndex);
+				setInterfaceParams(iface, intf.impl());
+
+				if ((result.find(ifIndex) == result.end()) && ((upOnly && intf.isUp()) || !upOnly))
+					ifIt = result.insert(Map::value_type(ifIndex, intf)).first;
+
+				break;
+			}
+#endif // POCO_NO_LINUX_IF_PACKET_H
+			case AF_INET:
+				ifIndex = if_nametoindex(iface->ifa_name);
+				ifIt = result.find(ifIndex);
+				intf = NetworkInterface(ifIndex);
+				setInterfaceParams(iface, intf.impl());
+
+				if ((ifIt == result.end()) && ((upOnly && intf.isUp()) || !upOnly))
+					ifIt = result.insert(Map::value_type(ifIndex, intf)).first;
+
+				address = IPAddress(*(iface->ifa_addr));
+				subnetMask = IPAddress(*(iface->ifa_netmask));
+
+				if (iface->ifa_flags & IFF_BROADCAST && iface->ifa_broadaddr)
+					broadcastAddress = IPAddress(*(iface->ifa_broadaddr));
+				else if (iface->ifa_flags & IFF_POINTOPOINT && iface->ifa_dstaddr)
+					broadcastAddress = IPAddress(*(iface->ifa_dstaddr));
+				else
+					broadcastAddress = IPAddress();
+
+				break;
+#if defined(POCO_HAVE_IPv6)
+			case AF_INET6:
+				ifIndex = if_nametoindex(iface->ifa_name);
+				ifIt = result.find(ifIndex);
+				intf = NetworkInterface(ifIndex);
+				setInterfaceParams(iface, intf.impl());
+
+				if ((ifIt == result.end()) && ((upOnly && intf.isUp()) || !upOnly))
+					result.insert(Map::value_type(ifIndex, intf));
+
+				address = IPAddress(&reinterpret_cast<const struct sockaddr_in6*>(iface->ifa_addr)->sin6_addr, sizeof(struct in6_addr), ifIndex);
+				subnetMask = IPAddress(*(iface->ifa_netmask));
+				broadcastAddress = IPAddress();
+
+				break;
+#endif
+			default:
+				continue;
+			}
+
+			if (family == AF_INET
+#ifdef POCO_HAVE_IPv6
+			|| family == AF_INET6
+#endif
+			)
+			{
+				intf = NetworkInterface(std::string(iface->ifa_name), address, subnetMask, broadcastAddress, ifIndex);
+				if ((upOnly && intf.isUp()) || !upOnly)
+				{
+					if ((ifIt = result.find(ifIndex)) != result.end())
+						ifIt->second.addAddress(address, subnetMask, broadcastAddress);
+				}
+			}
+		} // for interface
+	}
+	catch (...)
+	{
+		if (ifaces) freeifaddrs(ifaces);
+		throw;
+	}
+
+	if (ifaces) freeifaddrs(ifaces);
+
+	if (ipOnly)
+	{
+		Map::iterator it = result.begin();
+		Map::iterator end = result.end();
+		for (; it != end;)
+		{
+			if (!it->second.supportsIPv4() && !it->second.supportsIPv6())
+				result.erase(it++);
+			else ++it;
+		}
+	}
+
+	return result;
+#else
+	throw Poco::NotImplementedException("Not implemented in Android");
+#endif
+}
+
+
+} } // namespace Poco::Net
+
+
+#else
+//
+// Non-BSD Unix variants
+//
+#error TODO
+/*
+NetworkInterface::NetworkInterfaceList NetworkInterface::list()
+{
+	FastMutex::ScopedLock lock(_mutex);
+	NetworkInterfaceList result;
+	DatagramSocket socket;
+	// the following code is loosely based
+	// on W. Richard Stevens, UNIX Network Programming, pp 434ff.
+	int lastlen = 0;
+	int len = 100*sizeof(struct ifreq);
+	char* buf = 0;
+	try
+	{
+		struct ifconf ifc;
+		for (;;)
+		{
+			buf = new char[len];
+			ifc.ifc_len = len;
+			ifc.ifc_buf = buf;
+			if (::ioctl(socket.impl()->sockfd(), SIOCGIFCONF, &ifc) < 0)
+			{
+				if (errno != EINVAL || lastlen != 0)
+					throw NetException("cannot get network adapter list");
+			}
+			else
+			{
+				if (ifc.ifc_len == lastlen)
+					break;
+				lastlen = ifc.ifc_len;
+			}
+			len += 10*sizeof(struct ifreq);
+			delete [] buf;
+		}
+		for (const char* ptr = buf; ptr < buf + ifc.ifc_len;)
+		{
+			const struct ifreq* ifr = reinterpret_cast<const struct ifreq*>(ptr);
+#if defined(POCO_HAVE_SALEN)
+			len = ifr->ifr_addr.sa_len;
+			if (sizeof(struct sockaddr) > len) len = sizeof(struct sockaddr);
+#else
+			len = sizeof(struct sockaddr);
+#endif
+			IPAddress addr;
+			bool haveAddr = false;
+			int ifIndex(-1);
+			switch (ifr->ifr_addr.sa_family)
+			{
+#if defined(POCO_HAVE_IPv6)
+			case AF_INET6:
+				ifIndex = if_nametoindex(ifr->ifr_name);
+				if (len < sizeof(struct sockaddr_in6)) len = sizeof(struct sockaddr_in6);
+				addr = IPAddress(&reinterpret_cast<const struct sockaddr_in6*>(&ifr->ifr_addr)->sin6_addr, sizeof(struct in6_addr), ifIndex);
+				haveAddr = true;
+				break;
+#endif
+			case AF_INET:
+				if (len < sizeof(struct sockaddr_in)) len = sizeof(struct sockaddr_in);
+				addr = IPAddress(ifr->ifr_addr);
+				haveAddr = true;
+				break;
+			default:
+				break;
+			}
+			if (haveAddr)
+			{
+				std::string name(ifr->ifr_name);
+				result.push_back(NetworkInterface(name, name, name, addr, ifIndex));
+			}
+			len += sizeof(ifr->ifr_name);
+			ptr += len;
+		}
+	}
+	catch (...)
+	{
+		delete [] buf;
+		throw;
+	}
+	delete [] buf;
+	return result;
+}
+*/
+
+} } // namespace Poco::Net
+
+
+#endif
+
+
+#endif // POCO_NET_HAS_INTERFACE
diff --git a/base/poco/Net/src/NullPartHandler.cpp b/base/poco/Net/src/NullPartHandler.cpp
new file mode 100644
index 00000000000..49703a4050a
--- /dev/null
+++ b/base/poco/Net/src/NullPartHandler.cpp
@@ -0,0 +1,46 @@
+//
+// NullPartHandler.cpp
+//
+// Library: Net
+// Package: Messages
+// Module:  NullPartHandler
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/NullPartHandler.h"
+#include "Poco/Net/MessageHeader.h"
+#include "Poco/NullStream.h"
+#include "Poco/StreamCopier.h"
+
+
+using Poco::NullOutputStream;
+using Poco::StreamCopier;
+
+
+namespace Poco {
+namespace Net {
+
+
+NullPartHandler::NullPartHandler()
+{
+}
+
+
+NullPartHandler::~NullPartHandler()
+{
+}
+
+
+void NullPartHandler::handlePart(const MessageHeader& header, std::istream& stream)
+{
+	NullOutputStream ostr;
+	StreamCopier::copyStream(stream, ostr);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/OAuth10Credentials.cpp b/base/poco/Net/src/OAuth10Credentials.cpp
new file mode 100644
index 00000000000..ad769704d8f
--- /dev/null
+++ b/base/poco/Net/src/OAuth10Credentials.cpp
@@ -0,0 +1,365 @@
+//
+// OAuth10Credentials.cpp
+//
+// Library: Net
+// Package: OAuth
+// Module:	OAuth10Credentials
+//
+// Copyright (c) 2014, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/OAuth10Credentials.h"
+#include "Poco/Net/HTTPRequest.h"
+#include "Poco/Net/HTMLForm.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Net/HTTPAuthenticationParams.h"
+#include "Poco/SHA1Engine.h"
+#include "Poco/HMACEngine.h"
+#include "Poco/Base64Encoder.h"
+#include "Poco/RandomStream.h"
+#include "Poco/Timestamp.h"
+#include "Poco/NumberParser.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/Format.h"
+#include "Poco/String.h"
+#include <map>
+#include <sstream>
+
+
+namespace Poco {
+namespace Net {
+
+
+const std::string OAuth10Credentials::SCHEME = "OAuth";
+
+
+OAuth10Credentials::OAuth10Credentials()
+{
+}
+
+
+OAuth10Credentials::OAuth10Credentials(const std::string& consumerKey, const std::string& consumerSecret):
+	_consumerKey(consumerKey),
+	_consumerSecret(consumerSecret)
+{
+}
+
+
+OAuth10Credentials::OAuth10Credentials(const std::string& consumerKey, const std::string& consumerSecret, const std::string& token, const std::string& tokenSecret):
+	_consumerKey(consumerKey),
+	_consumerSecret(consumerSecret),
+	_token(token),
+	_tokenSecret(tokenSecret)
+{
+}
+
+
+OAuth10Credentials::OAuth10Credentials(const Poco::Net::HTTPRequest& request)
+{
+	if (request.hasCredentials())
+	{
+		std::string authScheme;
+		std::string authParams;
+		request.getCredentials(authScheme, authParams);
+		if (icompare(authScheme, SCHEME) == 0)
+		{
+			HTTPAuthenticationParams params(authParams);
+			std::string consumerKey = params.get("oauth_consumer_key", "");
+			URI::decode(consumerKey, _consumerKey);
+			std::string token = params.get("oauth_token", "");
+			URI::decode(token, _token);
+			std::string callback = params.get("oauth_callback", "");
+			URI::decode(callback, _callback);
+		}
+		else throw NotAuthenticatedException("No OAuth credentials in Authorization header", authScheme);
+	}
+	else throw NotAuthenticatedException("No Authorization header found");
+}
+
+
+OAuth10Credentials::~OAuth10Credentials()
+{
+}
+
+
+void OAuth10Credentials::setConsumerKey(const std::string& consumerKey)
+{
+	_consumerKey = consumerKey;
+}
+
+
+void OAuth10Credentials::setConsumerSecret(const std::string& consumerSecret)
+{
+	_consumerSecret = consumerSecret;
+}
+
+
+void OAuth10Credentials::setToken(const std::string& token)
+{
+	_token = token;
+}
+
+
+void OAuth10Credentials::setTokenSecret(const std::string& tokenSecret)
+{
+	_tokenSecret = tokenSecret;
+}
+
+
+void OAuth10Credentials::setRealm(const std::string& realm)
+{
+	_realm = realm;
+}
+
+
+void OAuth10Credentials::setCallback(const std::string& callback)
+{
+	_callback = callback;
+}
+
+
+void OAuth10Credentials::authenticate(HTTPRequest& request, const Poco::URI& uri, SignatureMethod method)
+{
+	HTMLForm emptyParams;
+	authenticate(request, uri, emptyParams, method);
+}
+
+	
+void OAuth10Credentials::authenticate(HTTPRequest& request, const Poco::URI& uri, const Poco::Net::HTMLForm& params, SignatureMethod method)
+{
+	if (method == SIGN_PLAINTEXT)
+	{
+		signPlaintext(request);
+	}
+	else
+	{
+		URI uriWithoutQuery(uri);
+		uriWithoutQuery.setQuery("");
+		uriWithoutQuery.setFragment("");
+		signHMACSHA1(request, uriWithoutQuery.toString(), params);
+	}
+}
+
+
+bool OAuth10Credentials::verify(const HTTPRequest& request, const Poco::URI& uri)
+{
+	HTMLForm params;
+	return verify(request, uri, params);
+}
+
+
+bool OAuth10Credentials::verify(const HTTPRequest& request, const Poco::URI& uri, const Poco::Net::HTMLForm& params)
+{
+	if (request.hasCredentials())
+	{
+		std::string authScheme;
+		std::string authParams;
+		request.getCredentials(authScheme, authParams);
+		if (icompare(authScheme, SCHEME) == 0)
+		{
+			HTTPAuthenticationParams oauthParams(authParams);
+
+			std::string version = oauthParams.get("oauth_version", "1.0");
+			if (version != "1.0") throw NotAuthenticatedException("Unsupported OAuth version", version);
+			
+			_consumerKey.clear();
+			std::string consumerKey = oauthParams.get("oauth_consumer_key", "");
+			URI::decode(consumerKey, _consumerKey);
+			
+			_token.clear();
+			std::string token = oauthParams.get("oauth_token", "");
+			URI::decode(token, _token);
+			
+			_callback.clear();
+			std::string callback = oauthParams.get("oauth_callback", "");
+			URI::decode(callback, _callback);
+			
+			std::string nonceEnc = oauthParams.get("oauth_nonce", "");
+			std::string nonce;
+			URI::decode(nonceEnc, nonce);
+			
+			std::string timestamp = oauthParams.get("oauth_timestamp", "");
+			
+			std::string method = oauthParams.get("oauth_signature_method", "");
+			
+			std::string signatureEnc = oauthParams.get("oauth_signature", "");
+			std::string signature;
+			URI::decode(signatureEnc, signature);
+
+			std::string refSignature;
+			if (icompare(method, "PLAINTEXT") == 0)
+			{
+				refSignature = percentEncode(_consumerSecret);
+				refSignature += '&';
+				refSignature += percentEncode(_tokenSecret);
+			}
+			else if (icompare(method, "HMAC-SHA1") == 0)
+			{
+				URI uriWithoutQuery(uri);
+				uriWithoutQuery.setQuery("");
+				uriWithoutQuery.setFragment("");
+				refSignature = createSignature(request, uriWithoutQuery.toString(), params, nonce, timestamp);
+			}
+			else throw NotAuthenticatedException("Unsupported OAuth signature method", method);
+			
+			return refSignature == signature;			
+		}
+		else throw NotAuthenticatedException("No OAuth credentials found in Authorization header");
+	}
+	else throw NotAuthenticatedException("No Authorization header found");
+}
+
+
+void OAuth10Credentials::nonceAndTimestampForTesting(const std::string& nonce, const std::string& timestamp)
+{
+	_nonce = nonce;
+	_timestamp = timestamp;
+}
+
+
+void OAuth10Credentials::signPlaintext(Poco::Net::HTTPRequest& request) const
+{
+	std::string signature(percentEncode(_consumerSecret));
+	signature += '&';
+	signature += percentEncode(_tokenSecret);
+	
+	std::string authorization(SCHEME);
+	if (!_realm.empty())
+	{
+		Poco::format(authorization, " realm=\"%s\",", _realm);
+	}
+	Poco::format(authorization, " oauth_consumer_key=\"%s\"", percentEncode(_consumerKey));
+	Poco::format(authorization, ", oauth_signature=\"%s\"", percentEncode(signature));
+	authorization += ", oauth_signature_method=\"PLAINTEXT\"";
+	if (!_token.empty())
+	{
+		Poco::format(authorization, ", oauth_token=\"%s\"", percentEncode(_token));
+	}
+	if (!_callback.empty())
+	{
+		Poco::format(authorization, ", oauth_callback=\"%s\"", percentEncode(_callback));
+	}
+	authorization += ", oauth_version=\"1.0\"";
+
+	request.set(HTTPRequest::AUTHORIZATION, authorization);
+}
+
+
+void OAuth10Credentials::signHMACSHA1(Poco::Net::HTTPRequest& request, const std::string& uri, const Poco::Net::HTMLForm& params) const
+{
+	std::string nonce(_nonce);
+	if (nonce.empty())
+	{
+		nonce = createNonce();
+	}
+	std::string timestamp(_timestamp);
+	if (timestamp.empty())
+	{
+		timestamp = Poco::NumberFormatter::format(Poco::Timestamp().epochTime());
+	}
+	std::string signature(createSignature(request, uri, params, nonce, timestamp));
+
+	std::string authorization(SCHEME);
+	if (!_realm.empty())
+	{
+		Poco::format(authorization, " realm=\"%s\",", _realm);
+	}
+	Poco::format(authorization, " oauth_consumer_key=\"%s\"", percentEncode(_consumerKey));
+	Poco::format(authorization, ", oauth_nonce=\"%s\"", percentEncode(nonce));
+	Poco::format(authorization, ", oauth_signature=\"%s\"", percentEncode(signature));
+	authorization += ", oauth_signature_method=\"HMAC-SHA1\"";
+	Poco::format(authorization, ", oauth_timestamp=\"%s\"", timestamp);
+	if (!_token.empty())
+	{
+		Poco::format(authorization, ", oauth_token=\"%s\"", percentEncode(_token));
+	}
+	if (!_callback.empty())
+	{
+		Poco::format(authorization, ", oauth_callback=\"%s\"", percentEncode(_callback));
+	}
+	authorization += ", oauth_version=\"1.0\"";
+
+	request.set(HTTPRequest::AUTHORIZATION, authorization);
+}
+
+
+std::string OAuth10Credentials::createNonce() const
+{
+	std::ostringstream base64Nonce;
+	Poco::Base64Encoder base64Encoder(base64Nonce);
+	Poco::RandomInputStream randomStream;
+	for (int i = 0; i < 32; i++)
+	{
+		base64Encoder.put(randomStream.get());
+	}
+	base64Encoder.close();
+	std::string nonce = base64Nonce.str();
+	return Poco::translate(nonce, "+/=", "");
+}
+
+
+std::string OAuth10Credentials::createSignature(const Poco::Net::HTTPRequest& request, const std::string& uri, const Poco::Net::HTMLForm& params, const std::string& nonce, const std::string& timestamp) const
+{
+	std::map<std::string, std::string> paramsMap;
+	paramsMap["oauth_version"]          = "1.0";
+	paramsMap["oauth_consumer_key"]     = percentEncode(_consumerKey);
+	paramsMap["oauth_nonce"]            = percentEncode(nonce);
+	paramsMap["oauth_signature_method"] = "HMAC-SHA1";
+	paramsMap["oauth_timestamp"]        = timestamp;
+	if (!_token.empty())
+	{
+		paramsMap["oauth_token"] = percentEncode(_token);
+	}
+	if (!_callback.empty())
+	{
+		paramsMap["oauth_callback"] = percentEncode(_callback);
+	}
+	for (Poco::Net::HTMLForm::ConstIterator it = params.begin(); it != params.end(); ++it)
+	{
+		paramsMap[percentEncode(it->first)] = percentEncode(it->second);
+	}
+	
+	std::string paramsString;
+	for (std::map<std::string, std::string>::const_iterator it = paramsMap.begin(); it != paramsMap.end(); ++it)
+	{
+		if (it != paramsMap.begin()) paramsString += '&';
+		paramsString += it->first;
+		paramsString += "=";
+		paramsString += it->second;
+	}
+	
+	std::string signatureBase = request.getMethod();
+	signatureBase += '&';
+	signatureBase += percentEncode(uri);
+	signatureBase += '&';
+	signatureBase += percentEncode(paramsString);
+	
+	std::string signingKey;
+	signingKey += percentEncode(_consumerSecret);
+	signingKey += '&';
+	signingKey += percentEncode(_tokenSecret);
+	
+	Poco::HMACEngine<Poco::SHA1Engine> hmacEngine(signingKey);
+	hmacEngine.update(signatureBase);
+	Poco::DigestEngine::Digest digest = hmacEngine.digest();
+	std::ostringstream digestBase64;
+	Poco::Base64Encoder base64Encoder(digestBase64);
+	base64Encoder.write(reinterpret_cast<char*>(&digest[0]), digest.size());
+	base64Encoder.close();
+	return digestBase64.str();
+}
+
+
+std::string OAuth10Credentials::percentEncode(const std::string& str)
+{
+	std::string encoded;
+	Poco::URI::encode(str, "!?#/'\",;:$&()[]*+=@", encoded);
+	return encoded;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/OAuth20Credentials.cpp b/base/poco/Net/src/OAuth20Credentials.cpp
new file mode 100644
index 00000000000..392115ad5f7
--- /dev/null
+++ b/base/poco/Net/src/OAuth20Credentials.cpp
@@ -0,0 +1,105 @@
+//
+// OAuth20Credentials.cpp
+//
+// Library: Net
+// Package: OAuth
+// Module:	OAuth20Credentials
+//
+// Copyright (c) 2014, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/OAuth20Credentials.h"
+#include "Poco/Net/HTTPRequest.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+const std::string OAuth20Credentials::SCHEME = "Bearer";
+
+
+OAuth20Credentials::OAuth20Credentials():
+	_scheme(SCHEME)
+{
+}
+
+
+OAuth20Credentials::OAuth20Credentials(const std::string& bearerToken):
+	_bearerToken(bearerToken),
+	_scheme(SCHEME)
+{
+}
+
+
+OAuth20Credentials::OAuth20Credentials(const std::string& bearerToken, const std::string& scheme):
+	_bearerToken(bearerToken),
+	_scheme(scheme)
+{
+}
+
+
+OAuth20Credentials::OAuth20Credentials(const HTTPRequest& request):
+	_scheme(SCHEME)
+{
+	extractBearerToken(request);
+}
+
+
+OAuth20Credentials::OAuth20Credentials(const HTTPRequest& request, const std::string& scheme):
+	_scheme(scheme)
+{
+	extractBearerToken(request);
+}
+
+
+OAuth20Credentials::~OAuth20Credentials()
+{
+}
+
+
+void OAuth20Credentials::setBearerToken(const std::string& bearerToken)
+{
+	_bearerToken = bearerToken;
+}
+
+
+void OAuth20Credentials::setScheme(const std::string& scheme)
+{
+	_scheme = scheme;
+}
+
+	
+void OAuth20Credentials::authenticate(HTTPRequest& request)
+{
+	std::string auth(_scheme);
+	auth += ' ';
+	auth += _bearerToken;
+	request.set(HTTPRequest::AUTHORIZATION, auth);
+}
+
+
+void OAuth20Credentials::extractBearerToken(const HTTPRequest& request)
+{
+	if (request.hasCredentials())
+	{
+		std::string authScheme;
+		std::string authInfo;
+		request.getCredentials(authScheme, authInfo);
+		if (icompare(authScheme, _scheme) == 0)
+		{
+			_bearerToken = authInfo;
+		}
+		else throw NotAuthenticatedException("No bearer token in Authorization header", authScheme);
+	}
+	else throw NotAuthenticatedException("No Authorization header found");
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/POP3ClientSession.cpp b/base/poco/Net/src/POP3ClientSession.cpp
new file mode 100644
index 00000000000..159f2108c53
--- /dev/null
+++ b/base/poco/Net/src/POP3ClientSession.cpp
@@ -0,0 +1,280 @@
+//
+// POP3ClientSession.cpp
+//
+// Library: Net
+// Package: Mail
+// Module:  POP3ClientSession
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/POP3ClientSession.h"
+#include "Poco/Net/MailMessage.h"
+#include "Poco/Net/MailStream.h"
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/StreamCopier.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include "Poco/Ascii.h"
+#include <istream>
+
+
+using Poco::NumberFormatter;
+using Poco::StreamCopier;
+
+
+namespace Poco {
+namespace Net {
+
+
+class DialogStreamBuf: public Poco::UnbufferedStreamBuf
+{
+public:
+	DialogStreamBuf(DialogSocket& socket):
+		_socket(socket)
+	{
+	}
+	
+	~DialogStreamBuf()
+	{
+	}
+		
+private:
+	int readFromDevice()
+	{
+		return _socket.get();
+	}
+	
+	DialogSocket& _socket;
+};
+
+
+class DialogIOS: public virtual std::ios
+{
+public:
+	DialogIOS(DialogSocket& socket):
+		_buf(socket)
+	{
+		poco_ios_init(&_buf);
+	}
+	
+	~DialogIOS()
+	{
+	}
+	
+	DialogStreamBuf* rdbuf()
+	{
+		return &_buf;
+	}
+
+protected:
+	DialogStreamBuf _buf;
+};
+
+
+class DialogInputStream: public DialogIOS, public std::istream
+{
+public:
+	DialogInputStream(DialogSocket& socket):
+		DialogIOS(socket),
+		std::istream(&_buf)
+	{
+	}
+		
+	~DialogInputStream()
+	{
+	}
+};
+
+
+POP3ClientSession::POP3ClientSession(const StreamSocket& socket):
+	_socket(socket),
+	_isOpen(true)
+{
+}
+
+
+POP3ClientSession::POP3ClientSession(const std::string& host, Poco::UInt16 port):	
+	_socket(SocketAddress(host, port)),
+	_isOpen(true)
+{
+}
+
+
+POP3ClientSession::~POP3ClientSession()
+{
+	try
+	{
+		close();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+void POP3ClientSession::setTimeout(const Poco::Timespan& timeout)
+{
+	_socket.setReceiveTimeout(timeout);
+}
+
+	
+Poco::Timespan POP3ClientSession::getTimeout() const
+{
+	return _socket.getReceiveTimeout();
+}
+
+
+void POP3ClientSession::login(const std::string& username, const std::string& password)
+{
+	std::string response;
+	_socket.receiveMessage(response);
+	if (!isPositive(response)) throw POP3Exception("The POP3 service is unavailable", response);
+	sendCommand("USER", username, response);
+	if (!isPositive(response)) throw POP3Exception("Login rejected for user", response);
+	sendCommand("PASS", password, response);
+	if (!isPositive(response)) throw POP3Exception("Password rejected for user", response);
+}
+
+
+void POP3ClientSession::close()
+{
+	if (_isOpen)
+	{
+		std::string response;
+		sendCommand("QUIT", response);
+		_socket.close();
+		_isOpen = false;
+	}
+}
+
+
+int POP3ClientSession::messageCount()
+{
+	std::string response;
+	sendCommand("STAT", response);
+	if (!isPositive(response)) throw POP3Exception("Cannot determine message count", response);
+	std::string::const_iterator it  = response.begin();
+	std::string::const_iterator end = response.end();
+	int count = 0;
+	while (it != end && !Poco::Ascii::isSpace(*it)) ++it;
+	while (it != end && Poco::Ascii::isSpace(*it)) ++it;
+	while (it != end && Poco::Ascii::isDigit(*it)) count = count*10 + *it++ - '0';
+	return count;
+}
+
+
+void POP3ClientSession::listMessages(MessageInfoVec& messages)
+{
+	messages.clear();
+	std::string response;
+	sendCommand("LIST", response);
+	if (!isPositive(response)) throw POP3Exception("Cannot get message list", response);
+	_socket.receiveMessage(response);
+	while (response != ".")
+	{
+		MessageInfo info = {0, 0};
+		std::string::const_iterator it  = response.begin();
+		std::string::const_iterator end = response.end();
+		while (it != end && Poco::Ascii::isDigit(*it)) info.id = info.id*10 + *it++ - '0';
+		while (it != end && Poco::Ascii::isSpace(*it)) ++it;
+		while (it != end && Poco::Ascii::isDigit(*it)) info.size = info.size*10 + *it++ - '0';
+		messages.push_back(info);
+		_socket.receiveMessage(response);
+	}
+}
+
+
+void POP3ClientSession::retrieveMessage(int id, MailMessage& message)
+{
+	std::string response;
+	sendCommand("RETR", NumberFormatter::format(id), response);
+	if (!isPositive(response)) throw POP3Exception("Cannot retrieve message", response);
+	DialogInputStream sis(_socket);
+	MailInputStream mis(sis);
+	message.read(mis);
+	while (mis.good()) mis.get(); // read any remaining junk
+}
+
+
+void POP3ClientSession::retrieveMessage(int id, MailMessage& message, PartHandler& handler)
+{
+	std::string response;
+	sendCommand("RETR", NumberFormatter::format(id), response);
+	if (!isPositive(response)) throw POP3Exception("Cannot retrieve message", response);
+	DialogInputStream sis(_socket);
+	MailInputStream mis(sis);
+	message.read(mis, handler);
+	while (mis.good()) mis.get(); // read any remaining junk
+}
+
+
+void POP3ClientSession::retrieveMessage(int id, std::ostream& ostr)
+{
+	std::string response;
+	sendCommand("RETR", NumberFormatter::format(id), response);
+	if (!isPositive(response)) throw POP3Exception("Cannot retrieve message", response);
+	DialogInputStream sis(_socket);
+	MailInputStream mis(sis);
+	StreamCopier::copyStream(mis, ostr);
+}
+
+
+void POP3ClientSession::retrieveHeader(int id, MessageHeader& header)
+{
+	std::string response;
+	sendCommand("TOP", NumberFormatter::format(id), "0", response);
+	if (!isPositive(response)) throw POP3Exception("Cannot retrieve header", response);
+	DialogInputStream sis(_socket);
+	MailInputStream mis(sis);
+	header.read(mis);
+	// skip stuff following header
+	mis.get(); // \r
+	mis.get(); // \n
+}
+
+
+void POP3ClientSession::deleteMessage(int id)
+{
+	std::string response;
+	sendCommand("DELE", NumberFormatter::format(id), response);
+	if (!isPositive(response)) throw POP3Exception("Cannot mark message for deletion", response);
+}
+
+
+bool POP3ClientSession::sendCommand(const std::string& command, std::string& response)
+{
+	_socket.sendMessage(command);
+	_socket.receiveMessage(response);
+	return isPositive(response);
+}
+
+
+bool POP3ClientSession::sendCommand(const std::string& command, const std::string& arg, std::string& response)
+{
+	_socket.sendMessage(command, arg);
+	_socket.receiveMessage(response);
+	return isPositive(response);
+}
+
+
+bool POP3ClientSession::sendCommand(const std::string& command, const std::string& arg1, const std::string& arg2, std::string& response)
+{
+	_socket.sendMessage(command, arg1, arg2);
+	_socket.receiveMessage(response);
+	return isPositive(response);
+}
+
+
+bool POP3ClientSession::isPositive(const std::string& response)
+{
+	return response.length() > 0 && response[0] == '+';
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/PartHandler.cpp b/base/poco/Net/src/PartHandler.cpp
new file mode 100644
index 00000000000..945cf318b5d
--- /dev/null
+++ b/base/poco/Net/src/PartHandler.cpp
@@ -0,0 +1,32 @@
+//
+// PartHandler.cpp
+//
+// Library: Net
+// Package: Messages
+// Module:  PartHandler
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/PartHandler.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+PartHandler::PartHandler()
+{
+}
+
+
+PartHandler::~PartHandler()
+{
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/PartSource.cpp b/base/poco/Net/src/PartSource.cpp
new file mode 100644
index 00000000000..22f6c66828b
--- /dev/null
+++ b/base/poco/Net/src/PartSource.cpp
@@ -0,0 +1,58 @@
+//
+// PartSource.cpp
+//
+// Library: Net
+// Package: Messages
+// Module:  PartSource
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/PartSource.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+const int         PartSource::UNKNOWN_CONTENT_LENGTH     = -1;
+
+
+PartSource::PartSource():
+	_mediaType("application/octet-stream")
+{
+}
+
+	
+PartSource::PartSource(const std::string& mediaType):
+	_mediaType(mediaType)
+{
+}
+
+
+PartSource::~PartSource()
+{
+}
+
+
+namespace
+{
+	static const std::string EMPTY;
+}
+
+
+const std::string& PartSource::filename() const
+{
+	return EMPTY;
+}
+
+std::streamsize PartSource::getContentLength() const
+{
+	return UNKNOWN_CONTENT_LENGTH;
+}
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/PartStore.cpp b/base/poco/Net/src/PartStore.cpp
new file mode 100644
index 00000000000..3b0b0251d0e
--- /dev/null
+++ b/base/poco/Net/src/PartStore.cpp
@@ -0,0 +1,87 @@
+//
+// PartStore.cpp
+//
+// Library: Net
+// Package: Messages
+// Module:  PartStore
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/PartStore.h"
+#include "Poco/TemporaryFile.h"
+#include "Poco/File.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+//
+// PartStore
+//
+
+
+PartStore::PartStore(const std::string& mediaType): PartSource(mediaType)
+{
+}
+
+
+PartStore::~PartStore()
+{
+}
+
+
+//
+// FilePartStore
+//
+
+
+FilePartStore::FilePartStore(const std::string& content, const std::string& mediaType, const std::string& filename):
+	PartStore(mediaType),
+	_filename(filename),
+	_path(TemporaryFile::tempName()),
+	_fstr(_path)
+{
+	_fstr << content << std::flush;
+	_fstr.seekg(0, std::ios::beg);
+}
+
+
+FilePartStore::~FilePartStore()
+{
+	try
+	{
+		_fstr.close();
+		File(_path).remove();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+std::istream& FilePartStore::stream()
+{
+	return _fstr;
+}
+
+
+const std::string& FilePartStore::filename() const
+{
+	return _filename;
+}
+
+
+const std::string& FilePartStore::path() const
+{
+	return _path;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/PollSet.cpp b/base/poco/Net/src/PollSet.cpp
new file mode 100644
index 00000000000..ff580fc39cb
--- /dev/null
+++ b/base/poco/Net/src/PollSet.cpp
@@ -0,0 +1,532 @@
+//
+// PollSet.cpp
+//
+// Library: Net
+// Package: Sockets
+// Module:  PollSet
+//
+// Copyright (c) 2016, Applied Informatics Software Engineering GmbH.
+// All rights reserved.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/PollSet.h"
+#include "Poco/Net/SocketImpl.h"
+#include "Poco/Mutex.h"
+#include <set>
+
+#ifdef __sun
+#include <cstring>
+#endif
+
+#if defined(_WIN32) && _WIN32_WINNT >= 0x0600
+#ifndef POCO_HAVE_FD_POLL
+#define POCO_HAVE_FD_POLL 1
+#endif
+#elif defined(POCO_OS_FAMILY_BSD)
+#ifndef POCO_HAVE_FD_POLL
+#define POCO_HAVE_FD_POLL 1
+#endif
+#endif
+
+
+#if defined(POCO_HAVE_FD_EPOLL)
+#include <sys/epoll.h>
+#elif defined(POCO_HAVE_FD_POLL)
+#ifndef _WIN32
+#include <poll.h>
+#endif
+#endif
+
+
+namespace Poco {
+namespace Net {
+
+
+#if defined(POCO_HAVE_FD_EPOLL)
+
+
+//
+// Linux implementation using epoll
+//
+class PollSetImpl
+{
+public:
+	PollSetImpl():
+		_epollfd(-1),
+		_events(1024)
+	{
+		_epollfd = epoll_create(1);
+		if (_epollfd < 0)
+		{
+			SocketImpl::error();
+		}
+	}
+
+	~PollSetImpl()
+	{
+		if (_epollfd >= 0)
+			::close(_epollfd);
+	}
+
+	void add(const Socket& socket, int mode)
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+
+		SocketImpl* sockImpl = socket.impl();
+		poco_socket_t fd = sockImpl->sockfd();
+		struct epoll_event ev;
+		ev.events = 0;
+		if (mode & PollSet::POLL_READ)
+			ev.events |= EPOLLIN;
+		if (mode & PollSet::POLL_WRITE)
+			ev.events |= EPOLLOUT;
+		if (mode & PollSet::POLL_ERROR)
+			ev.events |= EPOLLERR;
+		ev.data.ptr = socket.impl();
+		int err = epoll_ctl(_epollfd, EPOLL_CTL_ADD, fd, &ev);
+
+		if (err)
+		{
+			if (errno == EEXIST) update(socket, mode);
+			else SocketImpl::error();
+		}
+
+		if (_socketMap.find(sockImpl) == _socketMap.end())
+			_socketMap[sockImpl] = socket;
+	}
+
+	void remove(const Socket& socket)
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+
+		poco_socket_t fd = socket.impl()->sockfd();
+		struct epoll_event ev;
+		ev.events = 0;
+		ev.data.ptr = 0;
+		int err = epoll_ctl(_epollfd, EPOLL_CTL_DEL, fd, &ev);
+		if (err) SocketImpl::error();
+
+		_socketMap.erase(socket.impl());
+	}
+
+	void update(const Socket& socket, int mode)
+	{
+		poco_socket_t fd = socket.impl()->sockfd();
+		struct epoll_event ev;
+		ev.events = 0;
+		if (mode & PollSet::POLL_READ)
+			ev.events |= EPOLLIN;
+		if (mode & PollSet::POLL_WRITE)
+			ev.events |= EPOLLOUT;
+		if (mode & PollSet::POLL_ERROR)
+			ev.events |= EPOLLERR;
+		ev.data.ptr = socket.impl();
+		int err = epoll_ctl(_epollfd, EPOLL_CTL_MOD, fd, &ev);
+		if (err)
+		{
+			SocketImpl::error();
+		}
+	}
+
+	void clear()
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+
+		::close(_epollfd);
+		_socketMap.clear();
+		_epollfd = epoll_create(1);
+		if (_epollfd < 0)
+		{
+			SocketImpl::error();
+		}
+	}
+
+	PollSet::SocketModeMap poll(const Poco::Timespan& timeout)
+	{
+		PollSet::SocketModeMap result;
+
+		if (_socketMap.empty()) return result;
+
+		Poco::Timespan remainingTime(timeout);
+		int rc;
+		do
+		{
+			Poco::Timestamp start;
+			rc = epoll_wait(_epollfd, &_events[0], _events.size(), remainingTime.totalMilliseconds());
+			if (rc < 0 && SocketImpl::lastError() == POCO_EINTR)
+			{
+				Poco::Timestamp end;
+				Poco::Timespan waited = end - start;
+				if (waited < remainingTime)
+					remainingTime -= waited;
+				else
+					remainingTime = 0;
+			}
+		}
+		while (rc < 0 && SocketImpl::lastError() == POCO_EINTR);
+		if (rc < 0) SocketImpl::error();
+
+		Poco::FastMutex::ScopedLock lock(_mutex);
+
+		for (int i = 0; i < rc; i++)
+		{
+			std::map<void*, Socket>::iterator it = _socketMap.find(_events[i].data.ptr);
+			if (it != _socketMap.end())
+			{
+				if (_events[i].events & EPOLLIN)
+					result[it->second] |= PollSet::POLL_READ;
+				if (_events[i].events & EPOLLOUT)
+					result[it->second] |= PollSet::POLL_WRITE;
+				if (_events[i].events & EPOLLERR)
+					result[it->second] |= PollSet::POLL_ERROR;
+			}
+		}
+
+		return result;
+	}
+
+private:
+	Poco::FastMutex _mutex;
+	int _epollfd;
+	std::map<void*, Socket> _socketMap;
+	std::vector<struct epoll_event> _events;
+};
+
+
+#elif defined(POCO_HAVE_FD_POLL)
+
+
+//
+// BSD implementation using poll
+//
+class PollSetImpl
+{
+public:
+	void add(const Socket& socket, int mode)
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+
+		poco_socket_t fd = socket.impl()->sockfd();
+		_addMap[fd] = mode;
+		_removeSet.erase(fd);
+		_socketMap[fd] = socket;
+	}
+
+	void remove(const Socket& socket)
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+
+		poco_socket_t fd = socket.impl()->sockfd();
+		_removeSet.insert(fd);
+		_addMap.erase(fd);
+		_socketMap.erase(fd);
+	}
+
+	void update(const Socket& socket, int mode)
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+
+		poco_socket_t fd = socket.impl()->sockfd();
+		for (std::vector<pollfd>::iterator it = _pollfds.begin(); it != _pollfds.end(); ++it)
+		{
+			if (it->fd == fd)
+			{
+				it->events = 0;
+				if (mode & PollSet::POLL_READ)
+					it->events |= POLLIN;
+				if (mode & PollSet::POLL_WRITE)
+					it->events |= POLLOUT;
+			}
+		}
+	}
+
+	void clear()
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+
+		_socketMap.clear();
+		_addMap.clear();
+		_removeSet.clear();
+		_pollfds.clear();
+	}
+
+	PollSet::SocketModeMap poll(const Poco::Timespan& timeout)
+	{
+		PollSet::SocketModeMap result;
+		{
+			Poco::FastMutex::ScopedLock lock(_mutex);
+
+			if (!_removeSet.empty())
+			{
+				for (std::vector<pollfd>::iterator it = _pollfds.begin(); it != _pollfds.end();)
+				{
+					if (_removeSet.find(it->fd) != _removeSet.end())
+					{
+						it = _pollfds.erase(it);
+					}
+					else ++it;
+				}
+				_removeSet.clear();
+			}
+
+			_pollfds.reserve(_pollfds.size() + _addMap.size());
+			for (std::map<poco_socket_t, int>::iterator it = _addMap.begin(); it != _addMap.end(); ++it)
+			{
+				pollfd pfd;
+				pfd.fd = it->first;
+				pfd.events = 0;
+				pfd.revents = 0;
+				if (it->second & PollSet::POLL_READ)
+					pfd.events |= POLLIN;
+				if (it->second & PollSet::POLL_WRITE)
+					pfd.events |= POLLOUT;
+
+				_pollfds.push_back(pfd);
+			}
+			_addMap.clear();
+		}
+
+		if (_pollfds.empty()) return result;
+
+		Poco::Timespan remainingTime(timeout);
+		int rc;
+		do
+		{
+			Poco::Timestamp start;
+#ifdef _WIN32
+			rc = WSAPoll(&_pollfds[0], _pollfds.size(), static_cast<INT>(timeout.totalMilliseconds()));
+#else
+			rc = ::poll(&_pollfds[0], _pollfds.size(), timeout.totalMilliseconds());
+#endif
+			if (rc < 0 && SocketImpl::lastError() == POCO_EINTR)
+			{
+				Poco::Timestamp end;
+				Poco::Timespan waited = end - start;
+				if (waited < remainingTime)
+					remainingTime -= waited;
+				else
+					remainingTime = 0;
+			}
+		}
+		while (rc < 0 && SocketImpl::lastError() == POCO_EINTR);
+		if (rc < 0) SocketImpl::error();
+
+		{
+			Poco::FastMutex::ScopedLock lock(_mutex);
+
+			if (!_socketMap.empty())
+			{
+				for (std::vector<pollfd>::iterator it = _pollfds.begin(); it != _pollfds.end(); ++it)
+				{
+					std::map<poco_socket_t, Socket>::const_iterator its = _socketMap.find(it->fd);
+					if (its != _socketMap.end())
+					{
+						if (it->revents & POLLIN)
+							result[its->second] |= PollSet::POLL_READ;
+						if (it->revents & POLLOUT)
+							result[its->second] |= PollSet::POLL_WRITE;
+						if (it->revents & POLLERR)
+							result[its->second] |= PollSet::POLL_ERROR;
+#ifdef _WIN32
+						if (it->revents & POLLHUP)
+							result[its->second] |= PollSet::POLL_READ;
+#endif
+					}
+					it->revents = 0;
+				}
+			}
+		}
+
+		return result;
+	}
+
+private:
+	Poco::FastMutex _mutex;
+	std::map<poco_socket_t, Socket> _socketMap;
+	std::map<poco_socket_t, int> _addMap;
+	std::set<poco_socket_t> _removeSet;
+	std::vector<pollfd> _pollfds;
+};
+
+
+#else
+
+
+//
+// Fallback implementation using select()
+//
+class PollSetImpl
+{
+public:
+	void add(const Socket& socket, int mode)
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+
+		_map[socket] = mode;
+	}
+
+	void remove(const Socket& socket)
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+
+		_map.erase(socket);
+	}
+
+	void update(const Socket& socket, int mode)
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+
+		_map[socket] = mode;
+	}
+
+	void clear()
+	{
+		Poco::FastMutex::ScopedLock lock(_mutex);
+
+		_map.clear();
+	}
+
+	PollSet::SocketModeMap poll(const Poco::Timespan& timeout)
+	{
+		fd_set fdRead;
+		fd_set fdWrite;
+		fd_set fdExcept;
+		int nfd = 0;
+
+		FD_ZERO(&fdRead);
+		FD_ZERO(&fdWrite);
+		FD_ZERO(&fdExcept);
+
+		{
+			Poco::FastMutex::ScopedLock lock(_mutex);
+
+			for (PollSet::SocketModeMap::const_iterator it = _map.begin(); it != _map.end(); ++it)
+			{
+				poco_socket_t fd = it->first.impl()->sockfd();
+				if (fd != POCO_INVALID_SOCKET && it->second)
+				{
+					if (int(fd) > nfd) nfd = int(fd);
+
+					if (it->second & PollSet::POLL_READ)
+					{
+						FD_SET(fd, &fdRead);
+					}
+					if (it->second & PollSet::POLL_WRITE)
+					{
+						FD_SET(fd, &fdWrite);
+					}
+					if (it->second & PollSet::POLL_ERROR)
+					{
+						FD_SET(fd, &fdExcept);
+					}
+				}
+			}
+		}
+
+		PollSet::SocketModeMap result;
+		if (nfd == 0) return result;
+
+		Poco::Timespan remainingTime(timeout);
+		int rc;
+		do
+		{
+			struct timeval tv;
+			tv.tv_sec  = (long) remainingTime.totalSeconds();
+			tv.tv_usec = (long) remainingTime.useconds();
+			Poco::Timestamp start;
+			rc = ::select(nfd + 1, &fdRead, &fdWrite, &fdExcept, &tv);
+			if (rc < 0 && SocketImpl::lastError() == POCO_EINTR)
+			{
+				Poco::Timestamp end;
+				Poco::Timespan waited = end - start;
+				if (waited < remainingTime)
+					remainingTime -= waited;
+				else
+					remainingTime = 0;
+			}
+		}
+		while (rc < 0 && SocketImpl::lastError() == POCO_EINTR);
+		if (rc < 0) SocketImpl::error();
+
+		{
+			Poco::FastMutex::ScopedLock lock(_mutex);
+
+			for (PollSet::SocketModeMap::const_iterator it = _map.begin(); it != _map.end(); ++it)
+			{
+				poco_socket_t fd = it->first.impl()->sockfd();
+				if (fd != POCO_INVALID_SOCKET)
+				{
+					if (FD_ISSET(fd, &fdRead))
+					{
+						result[it->first] |= PollSet::POLL_READ;
+					}
+					if (FD_ISSET(fd, &fdWrite))
+					{
+						result[it->first] |= PollSet::POLL_WRITE;
+					}
+					if (FD_ISSET(fd, &fdExcept))
+					{
+						result[it->first] |= PollSet::POLL_ERROR;
+					}
+				}
+			}
+		}
+
+		return result;
+	}
+
+private:
+	Poco::FastMutex _mutex;
+	PollSet::SocketModeMap _map;
+};
+
+
+#endif
+
+
+PollSet::PollSet():
+	_pImpl(new PollSetImpl)
+{
+}
+
+
+PollSet::~PollSet()
+{
+	delete _pImpl;
+}
+
+
+void PollSet::add(const Socket& socket, int mode)
+{
+	_pImpl->add(socket, mode);
+}
+
+
+void PollSet::remove(const Socket& socket)
+{
+	_pImpl->remove(socket);
+}
+
+
+void PollSet::update(const Socket& socket, int mode)
+{
+	_pImpl->update(socket, mode);
+}
+
+
+void PollSet::clear()
+{
+	_pImpl->clear();
+}
+
+
+PollSet::SocketModeMap PollSet::poll(const Poco::Timespan& timeout)
+{
+	return _pImpl->poll(timeout);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/QuotedPrintableDecoder.cpp b/base/poco/Net/src/QuotedPrintableDecoder.cpp
new file mode 100644
index 00000000000..4f8b3c6726b
--- /dev/null
+++ b/base/poco/Net/src/QuotedPrintableDecoder.cpp
@@ -0,0 +1,102 @@
+//
+// QuotedPrintableDecoder.cpp
+//
+// Library: Net
+// Package: Messages
+// Module:  QuotedPrintableDecoder
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/QuotedPrintableDecoder.h"
+#include "Poco/NumberParser.h"
+#include "Poco/Exception.h"
+#include "Poco/Ascii.h"
+
+
+using Poco::UnbufferedStreamBuf;
+using Poco::NumberParser;
+using Poco::DataFormatException;
+
+
+namespace Poco {
+namespace Net {
+
+
+QuotedPrintableDecoderBuf::QuotedPrintableDecoderBuf(std::istream& istr): 
+	_buf(*istr.rdbuf())
+{
+}
+
+
+QuotedPrintableDecoderBuf::~QuotedPrintableDecoderBuf()
+{
+}
+
+
+int QuotedPrintableDecoderBuf::readFromDevice()
+{
+	int ch = _buf.sbumpc();
+	while (ch == '=')
+	{
+		ch = _buf.sbumpc();
+		if (ch == '\r')
+		{
+			_buf.sbumpc(); // read \n
+		}
+		else if (Poco::Ascii::isHexDigit(ch))
+		{
+			std::string hex = "0x";
+			hex += (char) ch;
+			ch = _buf.sbumpc();
+			if (Poco::Ascii::isHexDigit(ch))
+			{
+				hex += (char) ch;
+				return NumberParser::parseHex(hex);
+			}
+			throw DataFormatException("Incomplete hex number in quoted-printable encoded stream");
+		}
+		else if (ch != '\n')
+		{
+			throw DataFormatException("Invalid occurrence of '=' in quoted-printable encoded stream");
+		}
+		ch = _buf.sbumpc();
+	}
+	return ch;
+}
+
+
+QuotedPrintableDecoderIOS::QuotedPrintableDecoderIOS(std::istream& istr): _buf(istr)
+{
+	poco_ios_init(&_buf);
+}
+
+
+QuotedPrintableDecoderIOS::~QuotedPrintableDecoderIOS()
+{
+}
+
+
+QuotedPrintableDecoderBuf* QuotedPrintableDecoderIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+QuotedPrintableDecoder::QuotedPrintableDecoder(std::istream& istr): 
+	QuotedPrintableDecoderIOS(istr), 
+	std::istream(&_buf)
+{
+}
+
+
+QuotedPrintableDecoder::~QuotedPrintableDecoder()
+{
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/QuotedPrintableEncoder.cpp b/base/poco/Net/src/QuotedPrintableEncoder.cpp
new file mode 100644
index 00000000000..a71eb154f53
--- /dev/null
+++ b/base/poco/Net/src/QuotedPrintableEncoder.cpp
@@ -0,0 +1,150 @@
+//
+// QuotedPrintableEncoder.cpp
+//
+// Library: Net
+// Package: Messages
+// Module:  QuotedPrintableEncoder
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/QuotedPrintableEncoder.h"
+#include "Poco/NumberFormatter.h"
+
+
+using Poco::UnbufferedStreamBuf;
+using Poco::NumberFormatter;
+
+
+namespace Poco {
+namespace Net {
+
+
+QuotedPrintableEncoderBuf::QuotedPrintableEncoderBuf(std::ostream& ostr): 
+	_pending(-1),
+	_lineLength(0),
+	_ostr(ostr)
+{
+}
+
+
+QuotedPrintableEncoderBuf::~QuotedPrintableEncoderBuf()
+{
+	try
+	{
+		close();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+int QuotedPrintableEncoderBuf::writeToDevice(char c)
+{
+	if (_pending != -1)
+	{
+		if (_pending == '\r' && c == '\n')
+			writeRaw((char) _pending);
+		else if (c == '\r' || c == '\n')
+			writeEncoded((char) _pending);
+		else
+			writeRaw((char) _pending);
+		_pending = -1;
+	}
+	if (c == '\t' || c == ' ')
+	{
+		_pending = charToInt(c);
+		return _pending;
+	}
+	else if (c == '\r' || c == '\n' || (c > 32 && c < 127 && c != '='))
+	{
+		writeRaw(c);
+	}
+	else
+	{
+		writeEncoded(c);
+	}
+	return charToInt(c);
+}
+
+
+void QuotedPrintableEncoderBuf::writeEncoded(char c)
+{
+	if (_lineLength >= 73)
+	{
+		_ostr << "=\r\n";
+		_lineLength = 3;
+	}
+	else _lineLength += 3;
+	_ostr << '=' << NumberFormatter::formatHex((unsigned) charToInt(c), 2);
+}
+
+
+void QuotedPrintableEncoderBuf::writeRaw(char c)
+{
+	if (c == '\r' || c == '\n')
+	{
+		_ostr.put(c);
+		_lineLength = 0;
+	}
+	else if (_lineLength < 75)
+	{
+		_ostr.put(c);
+		++_lineLength;
+	}
+	else
+	{
+		_ostr << "=\r\n" << c;
+		_lineLength = 1;
+	}
+}
+
+
+int QuotedPrintableEncoderBuf::close()
+{
+	sync();
+	return _ostr ? 0 : -1;
+}
+
+
+QuotedPrintableEncoderIOS::QuotedPrintableEncoderIOS(std::ostream& ostr): _buf(ostr)
+{
+	poco_ios_init(&_buf);
+}
+
+
+QuotedPrintableEncoderIOS::~QuotedPrintableEncoderIOS()
+{
+}
+
+
+int QuotedPrintableEncoderIOS::close()
+{
+	return _buf.close();
+}
+
+
+QuotedPrintableEncoderBuf* QuotedPrintableEncoderIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+QuotedPrintableEncoder::QuotedPrintableEncoder(std::ostream& ostr): 
+	QuotedPrintableEncoderIOS(ostr), 
+	std::ostream(&_buf)
+{
+}
+
+
+QuotedPrintableEncoder::~QuotedPrintableEncoder()
+{
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/RawSocket.cpp b/base/poco/Net/src/RawSocket.cpp
new file mode 100644
index 00000000000..7605dcac390
--- /dev/null
+++ b/base/poco/Net/src/RawSocket.cpp
@@ -0,0 +1,117 @@
+//
+// RawSocket.cpp
+//
+// Library: Net
+// Package: Sockets
+// Module:  RawSocket
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/RawSocket.h"
+#include "Poco/Net/RawSocketImpl.h"
+#include "Poco/Exception.h"
+
+
+using Poco::InvalidArgumentException;
+
+
+namespace Poco {
+namespace Net {
+
+
+RawSocket::RawSocket(): 
+	Socket(new RawSocketImpl)
+{
+}
+
+
+RawSocket::RawSocket(SocketAddress::Family family, int proto): 
+	Socket(new RawSocketImpl(family, proto))
+{
+}
+
+
+RawSocket::RawSocket(const SocketAddress& address, bool reuseAddress): 
+	Socket(new RawSocketImpl(address.family()))
+{
+	bind(address, reuseAddress);
+}
+
+
+RawSocket::RawSocket(const Socket& socket): Socket(socket)
+{
+	if (!dynamic_cast<RawSocketImpl*>(impl()))
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+}
+
+
+RawSocket::RawSocket(SocketImpl* pImpl): Socket(pImpl)
+{
+	if (!dynamic_cast<RawSocketImpl*>(impl()))
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+}
+
+
+RawSocket::~RawSocket()
+{
+}
+
+
+RawSocket& RawSocket::operator = (const Socket& socket)
+{
+	if (dynamic_cast<RawSocketImpl*>(socket.impl()))
+		Socket::operator = (socket);
+	else
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+	return *this;
+}
+
+
+void RawSocket::connect(const SocketAddress& address)
+{
+	impl()->connect(address);
+}
+
+
+void RawSocket::bind(const SocketAddress& address, bool reuseAddress)
+{
+	impl()->bind(address, reuseAddress);
+}
+
+
+void RawSocket::bind(const SocketAddress& address, bool reuseAddress, bool reusePort)
+{
+	impl()->bind(address, reuseAddress, reusePort);
+}
+
+
+int RawSocket::sendBytes(const void* buffer, int length, int flags)
+{
+	return impl()->sendBytes(buffer, length, flags);
+}
+
+
+int RawSocket::receiveBytes(void* buffer, int length, int flags)
+{
+	return impl()->receiveBytes(buffer, length, flags);
+}
+
+
+int RawSocket::sendTo(const void* buffer, int length, const SocketAddress& address, int flags)
+{
+	return impl()->sendTo(buffer, length, address, flags);
+}
+
+
+int RawSocket::receiveFrom(void* buffer, int length, SocketAddress& address, int flags)
+{
+	return impl()->receiveFrom(buffer, length, address, flags);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/RawSocketImpl.cpp b/base/poco/Net/src/RawSocketImpl.cpp
new file mode 100644
index 00000000000..c7fb248ef7d
--- /dev/null
+++ b/base/poco/Net/src/RawSocketImpl.cpp
@@ -0,0 +1,69 @@
+//
+// RawSocketImpl.cpp
+//
+// Library: Net
+// Package: Sockets
+// Module:  RawSocketImpl
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/RawSocketImpl.h"
+#include "Poco/Net/NetException.h"
+
+
+using Poco::InvalidArgumentException;
+
+
+namespace Poco {
+namespace Net {
+
+
+RawSocketImpl::RawSocketImpl()
+{
+	init(AF_INET);
+}
+
+
+RawSocketImpl::RawSocketImpl(SocketAddress::Family family, int proto)
+{
+	if (family == SocketAddress::IPv4)
+		init2(AF_INET, proto);
+#if defined(POCO_HAVE_IPv6)
+	else if (family == SocketAddress::IPv6)
+		init2(AF_INET6, proto);
+#endif
+	else throw InvalidArgumentException("Invalid or unsupported address family passed to RawSocketImpl");
+
+}
+
+	
+RawSocketImpl::RawSocketImpl(poco_socket_t sockfd): 
+	SocketImpl(sockfd)
+{
+}
+
+
+RawSocketImpl::~RawSocketImpl()
+{
+}
+
+
+void RawSocketImpl::init(int af)
+{
+	init2(af, IPPROTO_RAW);
+}
+
+
+void RawSocketImpl::init2(int af, int proto)
+{
+	initSocket(af, SOCK_RAW, proto);
+	setOption(IPPROTO_IP, IP_HDRINCL, 0);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/RemoteSyslogChannel.cpp b/base/poco/Net/src/RemoteSyslogChannel.cpp
new file mode 100644
index 00000000000..8ad6d5b2d0d
--- /dev/null
+++ b/base/poco/Net/src/RemoteSyslogChannel.cpp
@@ -0,0 +1,356 @@
+//
+// RemoteSyslogChannel.cpp
+//
+// Library: Net
+// Package: Logging
+// Module:  RemoteSyslogChannel
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/RemoteSyslogChannel.h"
+#include "Poco/Message.h"
+#include "Poco/DateTimeFormatter.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/Net/DNS.h"
+#include "Poco/LoggingFactory.h"
+#include "Poco/Instantiator.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+const std::string RemoteSyslogChannel::BSD_TIMEFORMAT("%b %f %H:%M:%S");
+const std::string RemoteSyslogChannel::SYSLOG_TIMEFORMAT("%Y-%m-%dT%H:%M:%S.%i%z");
+const std::string RemoteSyslogChannel::PROP_NAME("name");
+const std::string RemoteSyslogChannel::PROP_FACILITY("facility");
+const std::string RemoteSyslogChannel::PROP_FORMAT("format");
+const std::string RemoteSyslogChannel::PROP_LOGHOST("loghost");
+const std::string RemoteSyslogChannel::PROP_HOST("host");
+const std::string RemoteSyslogChannel::STRUCTURED_DATA("structured-data");
+
+
+RemoteSyslogChannel::RemoteSyslogChannel():
+	_logHost("localhost"),
+	_name("-"),
+	_facility(SYSLOG_USER),
+	_bsdFormat(false),
+	_open(false)
+{
+}
+
+		
+RemoteSyslogChannel::RemoteSyslogChannel(const std::string& address, const std::string& name, int facility, bool bsdFormat):
+	_logHost(address),
+	_name(name),
+	_facility(facility),
+	_bsdFormat(bsdFormat),
+	_open(false)
+{
+	if (_name.empty()) _name = "-";
+}
+
+
+RemoteSyslogChannel::~RemoteSyslogChannel()
+{
+	try
+	{
+		close();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void RemoteSyslogChannel::open()
+{
+	if (_open) return;
+
+	if (_logHost.find(':') != std::string::npos)
+		_socketAddress = SocketAddress(_logHost);
+	else
+		_socketAddress = SocketAddress(_logHost, SYSLOG_PORT);
+
+	// reset socket for the case that it has been previously closed
+	_socket = DatagramSocket(_socketAddress.family());
+
+	if (_host.empty())
+	{
+		try
+		{
+			_host = DNS::thisHost().name();
+		}
+		catch (Poco::Exception&)
+		{
+			_host = _socket.address().host().toString();
+		}
+	}
+
+	_open = true;
+}
+
+	
+void RemoteSyslogChannel::close()
+{
+	if (_open)
+	{
+		_socket.close();
+		_open = false;
+	}
+}
+
+	
+void RemoteSyslogChannel::log(const Message& msg)
+{
+	Poco::FastMutex::ScopedLock lock(_mutex);
+
+	if (!_open) open();
+
+	std::string m;
+	m.reserve(1024);
+	m += '<';
+	Poco::NumberFormatter::append(m, getPrio(msg) + _facility);
+	m += '>';
+	if (_bsdFormat)
+	{
+		Poco::DateTimeFormatter::append(m, msg.getTime(), BSD_TIMEFORMAT);
+		m += ' ';
+		m += _host;
+	}
+	else
+	{
+		m += "1 "; // version
+		Poco::DateTimeFormatter::append(m, msg.getTime(), SYSLOG_TIMEFORMAT);
+		m += ' ';
+		m += _host;
+		m += ' ';
+		m += _name;
+		m += ' ';
+		Poco::NumberFormatter::append(m, msg.getPid());
+		m += ' ';
+		m += msg.getSource();
+		m += ' ';
+		if (msg.has(STRUCTURED_DATA))
+		{
+			m += msg.get(STRUCTURED_DATA);
+		}
+		else
+		{
+			m += "-";
+		}
+	}
+	m += ' ';
+	m += msg.getText();
+
+	_socket.sendTo(m.data(), static_cast<int>(m.size()), _socketAddress);
+}
+
+	
+void RemoteSyslogChannel::setProperty(const std::string& name, const std::string& value)
+{
+	if (name == PROP_NAME)
+	{
+		_name = value;
+		if (_name.empty()) _name = "-";
+	}
+	else if (name == PROP_FACILITY)
+	{
+		std::string facility;
+		if (Poco::icompare(value, 4, "LOG_") == 0)
+			facility = Poco::toUpper(value.substr(4));
+		else if (Poco::icompare(value, 4, "SYSLOG_") == 0)
+			facility = Poco::toUpper(value.substr(7));
+		else
+			facility = Poco::toUpper(value);
+		
+		if (facility == "KERN")
+			_facility = SYSLOG_KERN;
+		else if (facility == "USER")
+			_facility = SYSLOG_USER;
+		else if (facility == "MAIL")
+			_facility = SYSLOG_MAIL;
+		else if (facility == "DAEMON")
+			_facility = SYSLOG_DAEMON;
+		else if (facility == "AUTH")
+			_facility = SYSLOG_AUTH;
+		else if (facility == "AUTHPRIV")
+			_facility = SYSLOG_AUTHPRIV;
+		else if (facility == "SYSLOG")
+			_facility = SYSLOG_SYSLOG;
+		else if (facility == "LPR")
+			_facility = SYSLOG_LPR;
+		else if (facility == "NEWS")
+			_facility = SYSLOG_NEWS;
+		else if (facility == "UUCP")
+			_facility = SYSLOG_UUCP;
+		else if (facility == "CRON")
+			_facility = SYSLOG_CRON;
+		else if (facility == "FTP")
+			_facility = SYSLOG_FTP;
+		else if (facility == "NTP")
+			_facility = SYSLOG_NTP;
+		else if (facility == "LOGAUDIT")
+			_facility = SYSLOG_LOGAUDIT;
+		else if (facility == "LOGALERT")
+			_facility = SYSLOG_LOGALERT;
+		else if (facility == "CLOCK")
+			_facility = SYSLOG_CLOCK;
+		else if (facility == "LOCAL0")
+			_facility = SYSLOG_LOCAL0;
+		else if (facility == "LOCAL1")
+			_facility = SYSLOG_LOCAL1;
+		else if (facility == "LOCAL2")
+			_facility = SYSLOG_LOCAL2;
+		else if (facility == "LOCAL3")
+			_facility = SYSLOG_LOCAL3;
+		else if (facility == "LOCAL4")
+			_facility = SYSLOG_LOCAL4;
+		else if (facility == "LOCAL5")
+			_facility = SYSLOG_LOCAL5;
+		else if (facility == "LOCAL6")
+			_facility = SYSLOG_LOCAL6;
+		else if (facility == "LOCAL7")
+			_facility = SYSLOG_LOCAL7;
+	}
+	else if (name == PROP_LOGHOST)
+	{
+		_logHost = value;
+	}
+	else if (name == PROP_HOST)
+	{
+		_host = value;
+	}
+	else if (name == PROP_FORMAT)
+	{
+		_bsdFormat = (value == "bsd" || value == "rfc3164");
+	}
+	else
+	{
+		Channel::setProperty(name, value);
+	}
+}
+
+	
+std::string RemoteSyslogChannel::getProperty(const std::string& name) const
+{
+	if (name == PROP_NAME)
+	{
+		if (_name != "-")
+			return _name;
+		else
+			return "";
+	}
+	else if (name == PROP_FACILITY)
+	{
+		if (_facility == SYSLOG_KERN)
+			return "KERN";
+		else if (_facility == SYSLOG_USER)
+			return "USER";
+		else if (_facility == SYSLOG_MAIL)
+			return "MAIL";
+		else if (_facility == SYSLOG_DAEMON)
+			return "DAEMON";
+		else if (_facility == SYSLOG_AUTH)
+			return "AUTH";
+		else if (_facility == SYSLOG_AUTHPRIV)
+			return "AUTHPRIV";
+		else if (_facility == SYSLOG_SYSLOG)
+			return "SYSLOG";
+		else if (_facility == SYSLOG_LPR)
+			return "LPR";
+		else if (_facility == SYSLOG_NEWS)
+			return "NEWS";
+		else if (_facility == SYSLOG_UUCP)
+			return "UUCP";
+		else if (_facility == SYSLOG_CRON)
+			return "CRON";
+		else if (_facility == SYSLOG_FTP)
+			return "FTP";
+		else if (_facility == SYSLOG_NTP)
+			return "NTP";
+		else if (_facility == SYSLOG_LOGAUDIT)
+			return "LOGAUDIT";
+		else if (_facility == SYSLOG_LOGALERT)
+			return "LOGALERT";
+		else if (_facility == SYSLOG_CLOCK)
+			return "CLOCK";
+		else if (_facility == SYSLOG_LOCAL0)
+			return "LOCAL0";
+		else if (_facility == SYSLOG_LOCAL1)
+			return "LOCAL1";
+		else if (_facility == SYSLOG_LOCAL2)
+			return "LOCAL2";
+		else if (_facility == SYSLOG_LOCAL3)
+			return "LOCAL3";
+		else if (_facility == SYSLOG_LOCAL4)
+			return "LOCAL4";
+		else if (_facility == SYSLOG_LOCAL5)
+			return "LOCAL5";
+		else if (_facility == SYSLOG_LOCAL6)
+			return "LOCAL6";
+		else if (_facility == SYSLOG_LOCAL7)
+			return "LOCAL7";
+		else
+			return "";
+	}
+	else if (name == PROP_LOGHOST)
+	{
+		return _logHost;
+	}
+	else if (name == PROP_HOST)
+	{
+		return _host;
+	}
+	else if (name == PROP_FORMAT)
+	{
+		return _bsdFormat ? "rfc3164" : "rfc5424";
+	}
+	else
+	{
+		return Channel::getProperty(name);
+	}
+}
+
+
+int RemoteSyslogChannel::getPrio(const Message& msg)
+{
+	switch (msg.getPriority())
+	{
+	case Message::PRIO_TEST:
+	case Message::PRIO_TRACE:
+	case Message::PRIO_DEBUG:
+		return SYSLOG_DEBUG;
+	case Message::PRIO_INFORMATION:
+		return SYSLOG_INFORMATIONAL;
+	case Message::PRIO_NOTICE:
+		return SYSLOG_NOTICE;
+	case Message::PRIO_WARNING:
+		return SYSLOG_WARNING;
+	case Message::PRIO_ERROR:
+		return SYSLOG_ERROR;
+	case Message::PRIO_CRITICAL:
+		return SYSLOG_CRITICAL;
+	case Message::PRIO_FATAL:
+		return SYSLOG_ALERT;
+	default:
+		return 0;
+	}
+}
+
+
+void RemoteSyslogChannel::registerChannel()
+{
+	Poco::LoggingFactory::defaultFactory().registerChannelClass("RemoteSyslogChannel", new Poco::Instantiator<RemoteSyslogChannel, Poco::Channel>);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/RemoteSyslogListener.cpp b/base/poco/Net/src/RemoteSyslogListener.cpp
new file mode 100644
index 00000000000..5a319ea7eaa
--- /dev/null
+++ b/base/poco/Net/src/RemoteSyslogListener.cpp
@@ -0,0 +1,630 @@
+//
+// RemoteSyslogListener.cpp
+//
+// Library: Net
+// Package: Logging
+// Module:  RemoteSyslogListener
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/RemoteSyslogListener.h"
+#include "Poco/Net/RemoteSyslogChannel.h"
+#include "Poco/Net/DatagramSocket.h"
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/Runnable.h"
+#include "Poco/Notification.h"
+#include "Poco/AutoPtr.h"
+#include "Poco/NumberParser.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/DateTimeParser.h"
+#include "Poco/Message.h"
+#include "Poco/LoggingFactory.h"
+#include "Poco/Buffer.h"
+#include "Poco/Ascii.h"
+#include <cstddef>
+
+
+namespace Poco {
+namespace Net {
+
+
+//
+// MessageNotification
+//
+
+
+class MessageNotification: public Poco::Notification
+{
+public:
+	MessageNotification(const char* buffer, std::size_t length, const Poco::Net::SocketAddress& sourceAddress):
+		_message(buffer, length),
+		_sourceAddress(sourceAddress)
+	{
+	}
+
+	MessageNotification(const std::string& message, const Poco::Net::SocketAddress& sourceAddress):
+		_message(message),
+		_sourceAddress(sourceAddress)
+	{
+	}
+		
+	~MessageNotification()
+	{
+	}
+	
+	const std::string& message() const
+	{
+		return _message;
+	}
+	
+	const Poco::Net::SocketAddress& sourceAddress() const
+	{
+		return _sourceAddress;
+	}
+	
+private:
+	std::string _message;
+	Poco::Net::SocketAddress _sourceAddress;
+};
+
+
+//
+// RemoteUDPListener
+//
+
+
+class RemoteUDPListener: public Poco::Runnable
+{
+public:
+	enum
+	{
+		WAITTIME_MILLISEC = 1000,
+		BUFFER_SIZE = 65536
+	};
+	
+	RemoteUDPListener(Poco::NotificationQueue& queue, Poco::UInt16 port);
+	~RemoteUDPListener();
+
+	void run();
+	void safeStop();
+
+private:
+	Poco::NotificationQueue& _queue;
+	DatagramSocket           _socket;
+	bool                     _stopped;
+};
+
+
+RemoteUDPListener::RemoteUDPListener(Poco::NotificationQueue& queue, Poco::UInt16 port):
+	_queue(queue),
+	_socket(Poco::Net::SocketAddress(Poco::Net::IPAddress(), port)),
+	_stopped(false)
+{
+}
+
+
+RemoteUDPListener::~RemoteUDPListener()
+{
+}
+
+
+void RemoteUDPListener::run()
+{
+	Poco::Buffer<char> buffer(BUFFER_SIZE);
+	Poco::Timespan waitTime(WAITTIME_MILLISEC* 1000);
+	while (!_stopped)
+	{
+		try
+		{
+			if (_socket.poll(waitTime, Socket::SELECT_READ))
+			{
+				Poco::Net::SocketAddress sourceAddress;
+				int n = _socket.receiveFrom(buffer.begin(), BUFFER_SIZE, sourceAddress);
+				if (n > 0)
+				{
+					_queue.enqueueNotification(new MessageNotification(buffer.begin(), n, sourceAddress));
+				}
+			}
+		}
+		catch (...)
+		{
+			// lazy exception catching
+		}
+	}
+}
+
+
+void RemoteUDPListener::safeStop()
+{
+	_stopped = true;
+}
+
+
+//
+// SyslogParser
+//
+
+
+class SyslogParser: public Poco::Runnable
+{
+public:
+	static const std::string NILVALUE;
+
+	enum
+	{
+		WAITTIME_MILLISEC = 1000
+	};
+
+	SyslogParser(Poco::NotificationQueue& queue, RemoteSyslogListener* pListener);
+	~SyslogParser();
+
+	void parse(const std::string& line, Poco::Message& message);
+	void run();
+	void safeStop();
+
+	static Poco::Message::Priority convert(RemoteSyslogChannel::Severity severity);
+
+private:
+	void parsePrio(const std::string& line, std::size_t& pos, RemoteSyslogChannel::Severity& severity, RemoteSyslogChannel::Facility& fac);
+	void parseNew(const std::string& line, RemoteSyslogChannel::Severity severity, RemoteSyslogChannel::Facility fac, std::size_t& pos, Poco::Message& message);
+	void parseBSD(const std::string& line, RemoteSyslogChannel::Severity severity, RemoteSyslogChannel::Facility fac, std::size_t& pos, Poco::Message& message);
+
+	static std::string parseUntilSpace(const std::string& line, std::size_t& pos);
+		/// Parses until it encounters the next space char, returns the string from pos, excluding space
+		/// pos will point past the space char
+
+	static std::string parseStructuredData(const std::string& line, std::size_t& pos);
+		/// Parses the structured data field.
+
+	static std::string parseStructuredDataToken(const std::string& line, std::size_t& pos);
+	/// Parses a token from the structured data field.
+
+private:
+	Poco::NotificationQueue& _queue;
+	bool                     _stopped;
+	RemoteSyslogListener*    _pListener;
+};
+
+
+const std::string SyslogParser::NILVALUE("-");
+
+
+SyslogParser::SyslogParser(Poco::NotificationQueue& queue, RemoteSyslogListener* pListener):
+	_queue(queue),
+	_stopped(false),
+	_pListener(pListener)
+{
+	poco_check_ptr (_pListener);
+}
+
+
+SyslogParser::~SyslogParser()
+{
+}
+
+
+void SyslogParser::run()
+{
+	while (!_stopped)
+	{
+		try
+		{
+			Poco::AutoPtr<Poco::Notification> pNf(_queue.waitDequeueNotification(WAITTIME_MILLISEC));
+			if (pNf)
+			{
+				Poco::AutoPtr<MessageNotification> pMsgNf = pNf.cast<MessageNotification>();
+				Poco::Message message;
+				parse(pMsgNf->message(), message);
+				message["addr"] =pMsgNf->sourceAddress().host().toString();
+				_pListener->log(message);
+			}
+		}
+		catch (Poco::Exception&)
+		{
+			// parsing exception, what should we do?
+		}
+		catch (...)
+		{
+		}
+	}
+}
+
+
+void SyslogParser::safeStop()
+{
+	_stopped = true;
+}
+
+
+void SyslogParser::parse(const std::string& line, Poco::Message& message)
+{
+	// <int> -> int: lower 3 bits severity, upper bits: facility
+	std::size_t pos = 0;
+	RemoteSyslogChannel::Severity severity;
+	RemoteSyslogChannel::Facility fac;
+	parsePrio(line, pos, severity, fac);
+
+	// the next field decide if we parse an old BSD message or a new syslog message
+	// BSD: expects a month value in string form: Jan, Feb...
+	// SYSLOG expects a version number: 1
+	
+	if (Poco::Ascii::isDigit(line[pos]))
+	{
+		parseNew(line, severity, fac, pos, message);
+	}
+	else
+	{
+		parseBSD(line, severity, fac, pos, message);
+	}
+	poco_assert (pos == line.size());
+}
+
+
+void SyslogParser::parsePrio(const std::string& line, std::size_t& pos, RemoteSyslogChannel::Severity& severity, RemoteSyslogChannel::Facility& fac)
+{
+	poco_assert (pos < line.size());
+	poco_assert (line[pos] == '<');
+	++pos;
+	std::size_t start = pos;
+	
+	while (pos < line.size() && Poco::Ascii::isDigit(line[pos]))
+		++pos;
+	
+	poco_assert (line[pos] == '>');
+	poco_assert (pos - start > 0);
+	std::string valStr = line.substr(start, pos - start);
+	++pos; // skip the >
+
+	int val = Poco::NumberParser::parse(valStr);
+	poco_assert (val >= 0 && val <= (RemoteSyslogChannel::SYSLOG_LOCAL7 + RemoteSyslogChannel::SYSLOG_DEBUG));
+	
+	Poco::UInt16 pri = static_cast<Poco::UInt16>(val);
+	// now get the lowest 3 bits
+	severity = static_cast<RemoteSyslogChannel::Severity>(pri & 0x0007u);
+	fac = static_cast<RemoteSyslogChannel::Facility>(pri & 0xfff8u);
+}
+
+
+void SyslogParser::parseNew(const std::string& line, RemoteSyslogChannel::Severity severity, RemoteSyslogChannel::Facility fac, std::size_t& pos, Poco::Message& message)
+{
+	Poco::Message::Priority prio = convert(severity);
+	// rest of the unparsed header is:
+	// VERSION SP TIMESTAMP SP HOSTNAME SP APP-NAME SP PROCID SP MSGID
+	std::string versionStr(parseUntilSpace(line, pos));
+	std::string timeStr(parseUntilSpace(line, pos)); // can be the nilvalue!
+	std::string hostName(parseUntilSpace(line, pos));
+	std::string appName(parseUntilSpace(line, pos));
+	std::string procId(parseUntilSpace(line, pos));
+	std::string msgId(parseUntilSpace(line, pos));
+	std::string sd(parseStructuredData(line, pos));
+	std::string messageText(line.substr(pos));
+	pos = line.size();
+	Poco::DateTime date;
+	int tzd = 0;
+	bool hasDate = Poco::DateTimeParser::tryParse(RemoteSyslogChannel::SYSLOG_TIMEFORMAT, timeStr, date, tzd);
+	Poco::Message logEntry(msgId, messageText, prio);
+	logEntry[RemoteSyslogListener::LOG_PROP_HOST] = hostName;
+	logEntry[RemoteSyslogListener::LOG_PROP_APP] = appName;
+	logEntry[RemoteSyslogListener::LOG_PROP_STRUCTURED_DATA] = sd;
+	
+	if (hasDate)
+		logEntry.setTime(date.timestamp());
+	int lval(0);
+	Poco::NumberParser::tryParse(procId, lval);
+	logEntry.setPid(lval);
+	message.swap(logEntry);
+}
+
+
+void SyslogParser::parseBSD(const std::string& line, RemoteSyslogChannel::Severity severity, RemoteSyslogChannel::Facility fac, std::size_t& pos, Poco::Message& message)
+{
+	Poco::Message::Priority prio = convert(severity);
+	// rest of the unparsed header is:
+	// "%b %f %H:%M:%S" SP hostname|ipaddress
+	// detect three spaces
+	int spaceCnt = 0;
+	std::size_t start = pos;
+	while (spaceCnt < 3 && pos < line.size())
+	{
+		if (line[pos] == ' ')
+		{
+			spaceCnt++;
+			if (spaceCnt == 1)
+			{
+				// size must be 3 chars for month
+				if (pos - start != 3)
+				{
+					// probably a shortened time value, or the hostname
+					// assume hostName
+					Poco::Message logEntry(line.substr(start, pos-start), line.substr(pos+1), prio);
+					message.swap(logEntry);
+					return;
+				}
+			}
+			else if (spaceCnt == 2)
+			{
+				// a day value!
+				if (!(Poco::Ascii::isDigit(line[pos-1]) && (Poco::Ascii::isDigit(line[pos-2]) || Poco::Ascii::isSpace(line[pos-2]))))
+				{
+					// assume the next field is a hostname
+					spaceCnt = 3;
+				}
+			}
+			if (pos + 1 < line.size() && line[pos+1] == ' ')
+			{
+				// we have two spaces when the day value is smaller than 10!
+				++pos; // skip one
+			}
+		}
+		++pos;
+	}
+	std::string timeStr(line.substr(start, pos-start-1));
+	int tzd(0);
+	Poco::DateTime date;
+	int year = date.year(); // year is not included, use the current one
+	bool hasDate = Poco::DateTimeParser::tryParse(RemoteSyslogChannel::BSD_TIMEFORMAT, timeStr, date, tzd);
+	if (hasDate)
+	{
+		int m = date.month();
+		int d = date.day();
+		int h = date.hour();
+		int min = date.minute();
+		int sec = date.second();
+		date = Poco::DateTime(year, m, d, h, min, sec);
+	}
+	// next entry is host SP
+	std::string hostName(parseUntilSpace(line, pos));
+
+	// TAG: at most 32 alphanumeric chars, ANY non alphannumeric indicates start of message content
+	// ignore: treat everything as content
+	std::string messageText(line.substr(pos));
+	pos = line.size();
+	Poco::Message logEntry(hostName, messageText, prio);
+	logEntry.setTime(date.timestamp());
+	message.swap(logEntry);
+}
+
+
+std::string SyslogParser::parseUntilSpace(const std::string& line, std::size_t& pos)
+{
+	std::size_t start = pos;
+	while (pos < line.size() && !Poco::Ascii::isSpace(line[pos]))
+		++pos;
+	// skip space
+	++pos;
+	return line.substr(start, pos-start-1);
+}
+
+
+std::string SyslogParser::parseStructuredData(const std::string& line, std::size_t& pos)
+{
+	std::string sd;
+	if (pos < line.size())
+	{
+		if (line[pos] == '-') 
+		{
+			++pos;
+		}
+		else if (line[pos] == '[')
+		{
+			std::string tok = parseStructuredDataToken(line, pos);
+			while (tok == "[")
+			{
+				sd += tok;
+				tok = parseStructuredDataToken(line, pos);
+				while (tok != "]" && !tok.empty())
+				{
+					sd += tok;
+					tok = parseStructuredDataToken(line, pos);
+				}
+				sd += tok;
+				if (pos < line.size() && line[pos] == '[') tok = parseStructuredDataToken(line, pos);
+			}
+		}
+		if (pos < line.size() && Poco::Ascii::isSpace(line[pos])) ++pos;
+	}
+	return sd;
+}
+
+
+std::string SyslogParser::parseStructuredDataToken(const std::string& line, std::size_t& pos)
+{
+	std::string tok;
+	if (pos < line.size())
+	{
+		if (Poco::Ascii::isSpace(line[pos]) || line[pos] == '=' || line[pos] == '[' || line[pos] == ']')
+		{
+			tok += line[pos++];
+		}
+		else if (line[pos] == '"')
+		{
+			tok += line[pos++];
+			while (pos < line.size() && line[pos] != '"')
+			{
+				tok += line[pos++];
+			}
+			tok += '"';
+			if (pos < line.size()) pos++;
+		}
+		else
+		{
+			while (pos < line.size() && !Poco::Ascii::isSpace(line[pos]) && line[pos] != '=')
+			{
+				tok += line[pos++];
+			}
+		}
+	}
+	return tok;
+}
+
+Poco::Message::Priority SyslogParser::convert(RemoteSyslogChannel::Severity severity)
+{
+	switch (severity)
+	{
+	case RemoteSyslogChannel::SYSLOG_EMERGENCY:
+		return Poco::Message::PRIO_FATAL;
+	case RemoteSyslogChannel::SYSLOG_ALERT:
+		return Poco::Message::PRIO_FATAL;
+	case RemoteSyslogChannel::SYSLOG_CRITICAL:
+		return Poco::Message::PRIO_CRITICAL;
+	case RemoteSyslogChannel::SYSLOG_ERROR:
+		return Poco::Message::PRIO_ERROR;
+	case RemoteSyslogChannel::SYSLOG_WARNING:
+		return Poco::Message::PRIO_WARNING;
+	case RemoteSyslogChannel::SYSLOG_NOTICE:
+		return Poco::Message::PRIO_NOTICE;
+	case RemoteSyslogChannel::SYSLOG_INFORMATIONAL:
+		return Poco::Message::PRIO_INFORMATION;
+	case RemoteSyslogChannel::SYSLOG_DEBUG:
+		return Poco::Message::PRIO_DEBUG;
+	}
+	throw Poco::LogicException("Illegal severity value in message");
+}
+
+
+//
+// RemoteSyslogListener
+//
+
+
+const std::string RemoteSyslogListener::PROP_PORT("port");
+const std::string RemoteSyslogListener::PROP_THREADS("threads");
+
+const std::string RemoteSyslogListener::LOG_PROP_APP("app");
+const std::string RemoteSyslogListener::LOG_PROP_HOST("host");
+const std::string RemoteSyslogListener::LOG_PROP_STRUCTURED_DATA("structured-data");
+
+
+RemoteSyslogListener::RemoteSyslogListener():
+	_pListener(0),
+	_pParser(0),
+	_port(RemoteSyslogChannel::SYSLOG_PORT),
+	_threads(1)
+{
+}
+
+
+RemoteSyslogListener::RemoteSyslogListener(Poco::UInt16 port):
+	_pListener(0),
+	_pParser(0),
+	_port(port),
+	_threads(1)
+{
+}
+
+
+RemoteSyslogListener::RemoteSyslogListener(Poco::UInt16 port, int threads):
+	_pListener(0),
+	_pParser(0),
+	_port(port),
+	_threads(threads)
+{
+}
+
+
+RemoteSyslogListener::~RemoteSyslogListener()
+{
+}
+
+
+void RemoteSyslogListener::processMessage(const std::string& messageText)
+{
+	Poco::Message message;
+	_pParser->parse(messageText, message);
+	log(message);
+}
+
+
+void RemoteSyslogListener::enqueueMessage(const std::string& messageText, const Poco::Net::SocketAddress& senderAddress)
+{
+	_queue.enqueueNotification(new MessageNotification(messageText, senderAddress));
+}
+
+
+void RemoteSyslogListener::setProperty(const std::string& name, const std::string& value)
+{
+	if (name == PROP_PORT)
+	{
+		int val = Poco::NumberParser::parse(value);
+		if (val >= 0 && val < 65536)
+			_port = static_cast<Poco::UInt16>(val);
+		else
+			throw Poco::InvalidArgumentException("Not a valid port number", value);
+	}
+	else if (name == PROP_THREADS)
+	{
+		int val = Poco::NumberParser::parse(value);
+		if (val > 0 && val < 16)
+			_threads = val;
+		else
+			throw Poco::InvalidArgumentException("Invalid number of threads", value);
+	}
+	else 
+	{
+		SplitterChannel::setProperty(name, value);
+	}
+}
+
+
+std::string RemoteSyslogListener::getProperty(const std::string& name) const
+{
+	if (name == PROP_PORT)
+		return Poco::NumberFormatter::format(_port);
+	else if (name == PROP_THREADS)
+		return Poco::NumberFormatter::format(_threads);
+	else	
+		return SplitterChannel::getProperty(name);
+}
+
+
+void RemoteSyslogListener::open()
+{
+	SplitterChannel::open();
+	_pParser = new SyslogParser(_queue, this);
+	if (_port > 0)
+	{
+		_pListener = new RemoteUDPListener(_queue, _port);
+	}
+	for (int i = 0; i < _threads; i++)
+	{
+		_threadPool.start(*_pParser);
+	}
+	if (_pListener)
+	{
+		_threadPool.start(*_pListener);
+	}
+}
+
+
+void RemoteSyslogListener::close()
+{
+	if (_pListener)
+	{
+		_pListener->safeStop();
+	}
+	if (_pParser)
+	{
+		_pParser->safeStop();
+	}
+	_queue.clear();
+	_threadPool.joinAll();
+	delete _pListener;
+	delete _pParser;
+	_pListener = 0;
+	_pParser = 0;
+	SplitterChannel::close();
+}
+
+
+void RemoteSyslogListener::registerChannel()
+{
+	Poco::LoggingFactory::defaultFactory().registerChannelClass("RemoteSyslogListener", new Poco::Instantiator<RemoteSyslogListener, Poco::Channel>);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/SMTPChannel.cpp b/base/poco/Net/src/SMTPChannel.cpp
new file mode 100644
index 00000000000..a498179a44e
--- /dev/null
+++ b/base/poco/Net/src/SMTPChannel.cpp
@@ -0,0 +1,210 @@
+//
+// SMTPChannel.cpp
+//
+// Library: Net
+// Package: Logging
+// Module:  SMTPChannel
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SMTPChannel.h"
+#include "Poco/Net/MailMessage.h"
+#include "Poco/Net/MailRecipient.h"
+#include "Poco/Net/SMTPClientSession.h"
+#include "Poco/Net/StringPartSource.h"
+#include "Poco/Message.h"
+#include "Poco/DateTimeFormatter.h"
+#include "Poco/DateTimeFormat.h"
+#include "Poco/LocalDateTime.h"
+#include "Poco/LoggingFactory.h"
+#include "Poco/Instantiator.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/FileStream.h"
+#include "Poco/File.h"
+#include "Poco/Environment.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+const std::string SMTPChannel::PROP_MAILHOST("mailhost");
+const std::string SMTPChannel::PROP_SENDER("sender");
+const std::string SMTPChannel::PROP_RECIPIENT("recipient");
+const std::string SMTPChannel::PROP_LOCAL("local");
+const std::string SMTPChannel::PROP_ATTACHMENT("attachment");
+const std::string SMTPChannel::PROP_TYPE("type");
+const std::string SMTPChannel::PROP_DELETE("delete");
+const std::string SMTPChannel::PROP_THROW("throw");
+
+
+SMTPChannel::SMTPChannel():
+	_mailHost("localhost"),
+	_local(true),
+	_type("text/plain"),
+	_delete(false),
+	_throw(false)
+{
+}
+
+		
+SMTPChannel::SMTPChannel(const std::string& mailhost, const std::string& sender, const std::string& recipient):
+	_mailHost(mailhost),
+	_sender(sender),
+	_recipient(recipient),
+	_local(true),
+	_type("text/plain"),
+	_delete(false),
+	_throw(false)
+{
+}
+
+
+SMTPChannel::~SMTPChannel()
+{
+	try
+	{
+		close();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void SMTPChannel::open()
+{
+}
+
+	
+void SMTPChannel::close()
+{
+}
+
+	
+void SMTPChannel::log(const Message& msg)
+{
+	try
+	{
+		MailMessage message;
+		message.setSender(_sender);
+		message.addRecipient(MailRecipient(MailRecipient::PRIMARY_RECIPIENT, _recipient));
+		message.setSubject("Log Message from " + _sender);
+		std::stringstream content;
+		content << "Log Message\r\n"
+			<< "===========\r\n\r\n"
+			<< "Host: " << Environment::nodeName() << "\r\n"
+			<< "Logger: " << msg.getSource() << "\r\n";
+
+		if (_local)
+		{
+			DateTime dt(msg.getTime());
+			content	<< "Timestamp: " << DateTimeFormatter::format(LocalDateTime(dt), DateTimeFormat::RFC822_FORMAT) << "\r\n";
+		}
+		else
+			content	<< "Timestamp: " << DateTimeFormatter::format(msg.getTime(), DateTimeFormat::RFC822_FORMAT) << "\r\n";
+
+		content	<< "Priority: " << NumberFormatter::format(msg.getPriority()) << "\r\n"
+			<< "Process ID: " << NumberFormatter::format(msg.getPid()) << "\r\n"
+			<< "Thread: " << msg.getThread() << " (ID: " << msg.getTid() << ")\r\n"
+			<< "Message text: " << msg.getText() << "\r\n\r\n";
+
+		message.addContent(new StringPartSource(content.str()));
+	
+		if (!_attachment.empty())
+		{
+			{
+				Poco::FileInputStream fis(_attachment, std::ios::in | std::ios::binary | std::ios::ate);
+				if (fis.good())
+				{
+					typedef std::allocator<std::string::value_type>::size_type SST;
+
+					std::streamoff size = fis.tellg();
+					poco_assert (std::numeric_limits<unsigned int>::max() >= size);
+					poco_assert (std::numeric_limits<SST>::max() >= size);
+					char* pMem = new char [static_cast<unsigned int>(size)];
+					fis.seekg(std::ios::beg);
+					fis.read(pMem, size);
+					message.addAttachment(_attachment,
+						new StringPartSource(std::string(pMem, static_cast<SST>(size)), 
+							_type,
+							_attachment));
+
+					delete [] pMem;
+				}
+			}
+			if (_delete) File(_attachment).remove();
+		}
+
+		SMTPClientSession session(_mailHost);
+		session.login();
+		session.sendMessage(message);
+		session.close();
+	} 
+	catch (Exception&) 
+	{ 
+		if (_throw) throw; 
+	}
+}
+
+	
+void SMTPChannel::setProperty(const std::string& name, const std::string& value)
+{
+	if (name == PROP_MAILHOST) 
+		_mailHost = value;
+	else if (name == PROP_SENDER) 
+		_sender = value;
+	else if (name == PROP_RECIPIENT) 
+		_recipient = value;
+	else if (name == PROP_LOCAL) 
+		_local = isTrue(value);
+	else if (name == PROP_ATTACHMENT) 
+		_attachment = value;
+	else if (name == PROP_TYPE) 
+		_type = value;
+	else if (name == PROP_DELETE) 
+		_delete = isTrue(value);
+	else if (name == PROP_THROW) 
+		_throw = isTrue(value);
+	else 
+		Channel::setProperty(name, value);
+}
+
+	
+std::string SMTPChannel::getProperty(const std::string& name) const
+{
+	if (name == PROP_MAILHOST) 
+		return _mailHost;
+	else if (name == PROP_SENDER) 
+		return _sender;
+	else if (name == PROP_RECIPIENT) 
+		return _recipient;
+	else if (name == PROP_LOCAL) 
+		return _local ? "true" : "false";
+	else if (name == PROP_ATTACHMENT) 
+		return _attachment;
+	else if (name == PROP_TYPE) 
+		return _type;
+	else if (name == PROP_DELETE) 
+		return _delete ? "true" : "false";
+	else if (name == PROP_THROW) 
+		return _throw ? "true" : "false";
+	else
+		return Channel::getProperty(name);
+}
+
+
+void SMTPChannel::registerChannel()
+{
+	Poco::LoggingFactory::defaultFactory().registerChannelClass("SMTPChannel", 
+		new Poco::Instantiator<SMTPChannel, Poco::Channel>);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/SMTPClientSession.cpp b/base/poco/Net/src/SMTPClientSession.cpp
new file mode 100644
index 00000000000..20e330a8d91
--- /dev/null
+++ b/base/poco/Net/src/SMTPClientSession.cpp
@@ -0,0 +1,466 @@
+//
+// SMTPClientSession.cpp
+//
+// Library: Net
+// Package: Mail
+// Module:  SMTPClientSession
+//
+// Copyright (c) 2005-2008, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SMTPClientSession.h"
+#include "Poco/Net/MailMessage.h"
+#include "Poco/Net/MailRecipient.h"
+#include "Poco/Net/MailStream.h"
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/Net/SocketStream.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Environment.h"
+#include "Poco/Net/NetworkInterface.h"
+#include "Poco/HMACEngine.h"
+#include "Poco/MD5Engine.h"
+#include "Poco/SHA1Engine.h"
+#include "Poco/DigestStream.h"
+#include "Poco/StreamCopier.h"
+#include "Poco/Base64Encoder.h"
+#include "Poco/Base64Decoder.h"
+#include "Poco/String.h"
+#include <sstream>
+#include <fstream>
+#include <iostream>
+
+
+using Poco::DigestEngine;
+using Poco::HMACEngine;
+using Poco::MD5Engine;
+using Poco::SHA1Engine;
+using Poco::DigestOutputStream;
+using Poco::StreamCopier;
+using Poco::Base64Encoder;
+using Poco::Base64Decoder;
+using Poco::Environment;
+
+
+namespace Poco {
+namespace Net {
+
+
+SMTPClientSession::SMTPClientSession(const StreamSocket& socket):
+	_socket(socket),
+	_isOpen(false)
+{
+}
+
+
+SMTPClientSession::SMTPClientSession(const std::string& host, Poco::UInt16 port):
+	_socket(SocketAddress(host, port)),
+	_isOpen(false)
+{
+}
+
+
+SMTPClientSession::~SMTPClientSession()
+{
+	try
+	{
+		close();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+void SMTPClientSession::setTimeout(const Poco::Timespan& timeout)
+{
+	_socket.setReceiveTimeout(timeout);
+}
+
+	
+Poco::Timespan SMTPClientSession::getTimeout() const
+{
+	return _socket.getReceiveTimeout();
+}
+
+
+void SMTPClientSession::login(const std::string& hostname, std::string& response)
+{
+	open();
+	int status = sendCommand("EHLO", hostname, response);
+	if (isPermanentNegative(status))
+		status = sendCommand("HELO", hostname, response);
+	if (!isPositiveCompletion(status)) throw SMTPException("Login failed", response, status);
+}
+
+
+void SMTPClientSession::login(const std::string& hostname)
+{
+	std::string response;
+	login(hostname, response);
+}
+
+
+void SMTPClientSession::login()
+{
+	login(Environment::nodeName());
+}
+
+
+void SMTPClientSession::loginUsingCRAMMD5(const std::string& username, const std::string& password)
+{
+	HMACEngine<MD5Engine> hmac(password);
+	loginUsingCRAM(username, "CRAM-MD5", hmac);
+}
+
+
+void SMTPClientSession::loginUsingCRAMSHA1(const std::string& username, const std::string& password)
+{
+	HMACEngine<SHA1Engine> hmac(password);
+	loginUsingCRAM(username, "CRAM-SHA1", hmac);
+}
+
+
+void SMTPClientSession::loginUsingCRAM(const std::string& username, const std::string& method, Poco::DigestEngine& hmac)
+{
+	std::string response;
+	int status = sendCommand(std::string("AUTH ") + method, response);
+
+	if (!isPositiveIntermediate(status)) throw SMTPException(std::string("Cannot authenticate using ") + method, response, status);
+	std::string challengeBase64 = response.substr(4);
+	
+	std::istringstream istr(challengeBase64);
+	Base64Decoder decoder(istr);
+	std::string challenge;
+	StreamCopier::copyToString(decoder, challenge);
+	
+	hmac.update(challenge);
+	
+	const DigestEngine::Digest& digest = hmac.digest();
+	std::string digestString(DigestEngine::digestToHex(digest));
+	
+	std::string challengeResponse = username + " " + digestString;
+	
+	std::ostringstream challengeResponseBase64;
+	Base64Encoder encoder(challengeResponseBase64);
+	encoder.rdbuf()->setLineLength(0);
+	encoder << challengeResponse;
+	encoder.close();
+	
+	status = sendCommand(challengeResponseBase64.str(), response);
+  	if (!isPositiveCompletion(status)) throw SMTPException(std::string("Login using ") + method + " failed", response, status);  
+}
+
+
+void SMTPClientSession::loginUsingLogin(const std::string& username, const std::string& password)
+{
+	std::string response;
+	int status = sendCommand("AUTH LOGIN", response);
+	if (!isPositiveIntermediate(status)) throw SMTPException("Cannot authenticate using LOGIN", response, status);
+	
+	std::ostringstream usernameBase64;
+	Base64Encoder usernameEncoder(usernameBase64);
+	usernameEncoder.rdbuf()->setLineLength(0);
+	usernameEncoder << username;
+	usernameEncoder.close();
+	
+	std::ostringstream passwordBase64;
+	Base64Encoder passwordEncoder(passwordBase64);
+	passwordEncoder.rdbuf()->setLineLength(0);
+	passwordEncoder << password;
+	passwordEncoder.close();
+	
+	//Server request for username/password not defined could be either
+	//S: login:
+	//C: user_login
+	//S: password:
+	//C: user_password
+	//or
+	//S: password:
+	//C: user_password
+	//S: login:
+	//C: user_login
+	
+	std::string decodedResponse;
+	std::istringstream responseStream(response.substr(4));
+	Base64Decoder responseDecoder(responseStream);
+	StreamCopier::copyToString(responseDecoder, decodedResponse);
+	
+	if (Poco::icompare(decodedResponse, 0, 8, "username") == 0) // username first (md5("Username:"))
+	{
+		status = sendCommand(usernameBase64.str(), response);
+		if (!isPositiveIntermediate(status)) throw SMTPException("Login using LOGIN username failed", response, status);
+		
+		status = sendCommand(passwordBase64.str(), response);
+		if (!isPositiveCompletion(status)) throw SMTPException("Login using LOGIN password failed", response, status);  
+	}
+	else if  (Poco::icompare(decodedResponse, 0, 8, "password") == 0) // password first (md5("Password:"))
+	{
+		status = sendCommand(passwordBase64.str(), response);
+		if (!isPositiveIntermediate(status)) throw SMTPException("Login using LOGIN password failed", response, status);  
+		
+		status = sendCommand(usernameBase64.str(), response);
+		if (!isPositiveCompletion(status)) throw SMTPException("Login using LOGIN username failed", response, status);
+	}
+}
+
+
+void SMTPClientSession::loginUsingPlain(const std::string& username, const std::string& password)
+{
+	std::ostringstream credentialsBase64;
+	Base64Encoder credentialsEncoder(credentialsBase64);
+	credentialsEncoder.rdbuf()->setLineLength(0);
+	credentialsEncoder << '\0' << username << '\0' << password;
+	credentialsEncoder.close();
+
+	std::string response;
+	int status = sendCommand("AUTH PLAIN", credentialsBase64.str(), response);
+	if (!isPositiveCompletion(status)) throw SMTPException("Login using PLAIN failed", response, status);
+}
+
+
+void SMTPClientSession::loginUsingXOAUTH2(const std::string& username, const std::string& password)
+{
+	std::ostringstream credentialsBase64;
+	Base64Encoder credentialsEncoder(credentialsBase64);
+	credentialsEncoder.rdbuf()->setLineLength(0);
+	credentialsEncoder << "user=" << username << "\001auth=Bearer " << password << "\001\001";
+	credentialsEncoder.close();
+
+	std::string response;
+	int status = sendCommand("AUTH XOAUTH2", credentialsBase64.str(), response);
+	if (!isPositiveCompletion(status)) throw SMTPException("Login using XOAUTH2 failed", response, status);
+}
+
+
+void SMTPClientSession::login(LoginMethod loginMethod, const std::string& username, const std::string& password)
+{
+	login(Environment::nodeName(), loginMethod, username, password);
+}
+
+
+void SMTPClientSession::login(const std::string& hostname, LoginMethod loginMethod, const std::string& username, const std::string& password)
+{
+	std::string response;
+	login(hostname, response);
+	
+	if (loginMethod == AUTH_CRAM_MD5)
+	{
+		if (response.find("CRAM-MD5", 0) != std::string::npos)
+		{
+			loginUsingCRAMMD5(username, password);
+		}
+		else throw SMTPException("The mail service does not support CRAM-MD5 authentication", response);
+	}
+	else if (loginMethod == AUTH_CRAM_SHA1)
+	{
+		if (response.find("CRAM-SHA1", 0) != std::string::npos)
+		{
+			loginUsingCRAMSHA1(username, password);
+		}
+		else throw SMTPException("The mail service does not support CRAM-SHA1 authentication", response);
+	}
+	else if (loginMethod == AUTH_LOGIN)
+	{
+		if (response.find("LOGIN", 0) != std::string::npos)
+		{
+			loginUsingLogin(username, password);
+		}
+		else throw SMTPException("The mail service does not support LOGIN authentication", response);
+	}
+	else if (loginMethod == AUTH_PLAIN)
+	{
+		if (response.find("PLAIN", 0) != std::string::npos)
+		{
+			loginUsingPlain(username, password);
+		}
+		else throw SMTPException("The mail service does not support PLAIN authentication", response);
+	}
+	else if (loginMethod == AUTH_XOAUTH2)
+	{
+		if (response.find("XOAUTH2", 0) != std::string::npos)
+		{
+			loginUsingXOAUTH2(username, password);
+		}
+		else throw SMTPException("The mail service does not support XOAUTH2 authentication", response);
+	}
+	else if (loginMethod != AUTH_NONE)
+	{
+		throw SMTPException("The autentication method is not supported");
+	}
+}
+
+
+void SMTPClientSession::open()
+{
+	if (!_isOpen)
+	{
+		std::string response;
+		int status = _socket.receiveStatusMessage(response);
+		if (!isPositiveCompletion(status)) throw SMTPException("The mail service is unavailable", response, status);
+		_isOpen = true;
+	}
+}
+
+
+void SMTPClientSession::close()
+{
+	if (_isOpen)
+	{
+		std::string response;
+		sendCommand("QUIT", response);
+		_socket.close();
+		_isOpen = false;
+	}
+}
+
+
+void SMTPClientSession::sendCommands(const MailMessage& message, const Recipients* pRecipients)
+{
+	std::string response;
+	int status = 0;
+	const std::string& fromField = message.getSender();
+	std::string::size_type emailPos = fromField.find('<');
+	if (emailPos == std::string::npos)
+	{
+		std::string sender("<");
+		sender.append(fromField);
+		sender.append(">");
+		status = sendCommand("MAIL FROM:", sender, response);
+	}
+	else
+	{
+		status = sendCommand("MAIL FROM:", fromField.substr(emailPos, fromField.size() - emailPos), response);
+	}
+
+	if (!isPositiveCompletion(status)) throw SMTPException("Cannot send message", response, status);
+	
+	std::ostringstream recipient;
+	if (pRecipients)
+	{
+		for (Recipients::const_iterator it = pRecipients->begin(); it != pRecipients->end(); ++it)
+		{
+			recipient << '<' << *it << '>';
+			int status = sendCommand("RCPT TO:", recipient.str(), response);
+			if (!isPositiveCompletion(status)) throw SMTPException(std::string("Recipient rejected: ") + recipient.str(), response, status);
+			recipient.str("");
+		}
+	}
+	else
+	{
+		for (MailMessage::Recipients::const_iterator it = message.recipients().begin(); it != message.recipients().end(); ++it)
+		{
+			recipient << '<' << it->getAddress() << '>';
+			int status = sendCommand("RCPT TO:", recipient.str(), response);
+			if (!isPositiveCompletion(status)) throw SMTPException(std::string("Recipient rejected: ") + recipient.str(), response, status);
+			recipient.str("");
+		}
+	}
+
+	status = sendCommand("DATA", response);
+	if (!isPositiveIntermediate(status)) throw SMTPException("Cannot send message data", response, status);
+}
+
+
+void SMTPClientSession::sendAddresses(const std::string& from, const Recipients& recipients)
+{
+	std::string response;
+	int status = 0;
+
+	std::string::size_type emailPos = from.find('<');
+	if (emailPos == std::string::npos)
+	{
+		std::string sender("<");
+		sender.append(from);
+		sender.append(">");
+		status = sendCommand("MAIL FROM:", sender, response);
+	}
+	else
+	{
+		status = sendCommand("MAIL FROM:", from.substr(emailPos, from.size() - emailPos), response);
+	}
+
+	if (!isPositiveCompletion(status)) throw SMTPException("Cannot send message", response, status);
+	
+	std::ostringstream recipient;
+
+	for (Recipients::const_iterator it = recipients.begin(); it != recipients.end(); ++it)
+	{
+
+		recipient << '<' << *it << '>';
+		int status = sendCommand("RCPT TO:", recipient.str(), response);
+		if (!isPositiveCompletion(status)) throw SMTPException(std::string("Recipient rejected: ") + recipient.str(), response, status);
+		recipient.str("");
+	}
+}
+
+
+void SMTPClientSession::sendData()
+{
+	std::string response;
+	int status = sendCommand("DATA", response);
+	if (!isPositiveIntermediate(status)) throw SMTPException("Cannot send message data", response, status);
+}
+
+
+void SMTPClientSession::sendMessage(const MailMessage& message)
+{
+	sendCommands(message);
+	transportMessage(message);
+}
+
+
+void SMTPClientSession::sendMessage(const MailMessage& message, const Recipients& recipients)
+{
+	sendCommands(message, &recipients);
+	transportMessage(message);
+}
+
+
+void SMTPClientSession::transportMessage(const MailMessage& message)
+{
+	SocketOutputStream socketStream(_socket);
+	MailOutputStream mailStream(socketStream);
+	message.write(mailStream);
+	mailStream.close();
+	socketStream.flush();
+	
+	std::string response;
+	int status = _socket.receiveStatusMessage(response);
+	if (!isPositiveCompletion(status)) throw SMTPException("The server rejected the message", response, status);
+}
+
+
+int SMTPClientSession::sendCommand(const std::string& command, std::string& response)
+{
+	_socket.sendMessage(command);
+	return _socket.receiveStatusMessage(response);
+}
+
+
+int SMTPClientSession::sendCommand(const std::string& command, const std::string& arg, std::string& response)
+{
+	_socket.sendMessage(command, arg);
+	return _socket.receiveStatusMessage(response);
+}
+
+
+void SMTPClientSession::sendMessage(std::istream& istr)
+{
+	std::string response;
+	int status = 0;
+	
+	SocketOutputStream socketStream(_socket);
+	MailOutputStream mailStream(socketStream);
+	StreamCopier::copyStream(istr, mailStream);
+	mailStream.close();
+	socketStream.flush();
+	status = _socket.receiveStatusMessage(response);
+	if (!isPositiveCompletion(status)) throw SMTPException("The server rejected the message", response, status);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/ServerSocket.cpp b/base/poco/Net/src/ServerSocket.cpp
new file mode 100644
index 00000000000..349cad3d468
--- /dev/null
+++ b/base/poco/Net/src/ServerSocket.cpp
@@ -0,0 +1,158 @@
+//
+// ServerSocket.cpp
+//
+// Library: Net
+// Package: Sockets
+// Module:  ServerSocket
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/ServerSocket.h"
+#include "Poco/Net/ServerSocketImpl.h"
+#include "Poco/Exception.h"
+
+
+using Poco::InvalidArgumentException;
+
+
+namespace Poco {
+namespace Net {
+
+
+ServerSocket::ServerSocket(): Socket(new ServerSocketImpl)
+{
+}
+
+
+ServerSocket::ServerSocket(const Socket& socket): Socket(socket)
+{
+	if (!dynamic_cast<ServerSocketImpl*>(impl()))
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+}
+
+
+ServerSocket::ServerSocket(const SocketAddress& address, int backlog): Socket(new ServerSocketImpl)
+{
+	impl()->bind(address, true);
+	impl()->listen(backlog);
+}
+
+
+ServerSocket::ServerSocket(Poco::UInt16 port, int backlog): Socket(new ServerSocketImpl)
+{
+	IPAddress wildcardAddr;
+	SocketAddress address(wildcardAddr, port);
+	impl()->bind(address, true);
+	impl()->listen(backlog);
+}
+
+
+ServerSocket::ServerSocket(SocketImpl* pImpl, bool ignore): Socket(pImpl)
+{
+}
+
+
+ServerSocket::~ServerSocket()
+{
+}
+
+
+ServerSocket& ServerSocket::operator = (const Socket& socket)
+{
+	if (dynamic_cast<ServerSocketImpl*>(socket.impl()))
+		Socket::operator = (socket);
+	else
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+	return *this;
+}
+
+
+void ServerSocket::bind(const SocketAddress& address, bool reuseAddress)
+{
+	impl()->bind(address, reuseAddress);
+}
+
+
+void ServerSocket::bind(const SocketAddress& address, bool reuseAddress, bool reusePort)
+{
+	impl()->bind(address, reuseAddress, reusePort);
+}
+
+
+void ServerSocket::bind(Poco::UInt16 port, bool reuseAddress)
+{
+	IPAddress wildcardAddr;
+	SocketAddress address(wildcardAddr, port);
+	impl()->bind(address, reuseAddress);
+}
+
+
+void ServerSocket::bind(Poco::UInt16 port, bool reuseAddress, bool reusePort)
+{
+	IPAddress wildcardAddr;
+	SocketAddress address(wildcardAddr, port);
+	impl()->bind(address, reuseAddress, reusePort);
+}
+
+
+void ServerSocket::bind6(const SocketAddress& address, bool reuseAddress, bool ipV6Only)
+{
+	impl()->bind6(address, reuseAddress, ipV6Only);
+}
+
+
+void ServerSocket::bind6(const SocketAddress& address, bool reuseAddress, bool reusePort, bool ipV6Only)
+{
+	impl()->bind6(address, reuseAddress, reusePort, ipV6Only);
+}
+
+
+void ServerSocket::bind6(Poco::UInt16 port, bool reuseAddress, bool ipV6Only)
+{
+#if defined(POCO_HAVE_IPv6)
+	IPAddress wildcardAddr(IPAddress::IPv6);
+	SocketAddress address(wildcardAddr, port);
+	impl()->bind6(address, reuseAddress, ipV6Only);
+#else
+	throw Poco::NotImplementedException("No IPv6 support available");
+#endif // POCO_HAVE_IPv6
+}
+
+	
+void ServerSocket::bind6(Poco::UInt16 port, bool reuseAddress, bool reusePort, bool ipV6Only)
+{
+#if defined(POCO_HAVE_IPv6)
+	IPAddress wildcardAddr(IPAddress::IPv6);
+	SocketAddress address(wildcardAddr, port);
+	impl()->bind6(address, reuseAddress, reusePort, ipV6Only);
+#else
+	throw Poco::NotImplementedException("No IPv6 support available");
+#endif // POCO_HAVE_IPv6
+}
+
+	
+void ServerSocket::listen(int backlog)
+{
+	impl()->listen(backlog);
+}
+
+
+StreamSocket ServerSocket::acceptConnection(SocketAddress& clientAddr)
+{
+	return StreamSocket(impl()->acceptConnection(clientAddr));
+}
+
+
+StreamSocket ServerSocket::acceptConnection()
+{
+	SocketAddress clientAddr;
+	return StreamSocket(impl()->acceptConnection(clientAddr));
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/ServerSocketImpl.cpp b/base/poco/Net/src/ServerSocketImpl.cpp
new file mode 100644
index 00000000000..7f6cd41bbfa
--- /dev/null
+++ b/base/poco/Net/src/ServerSocketImpl.cpp
@@ -0,0 +1,32 @@
+//
+// ServerSocketImpl.cpp
+//
+// Library: Net
+// Package: Sockets
+// Module:  ServerSocketImpl
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/ServerSocketImpl.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+ServerSocketImpl::ServerSocketImpl()
+{
+}
+
+
+ServerSocketImpl::~ServerSocketImpl()
+{
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/Socket.cpp b/base/poco/Net/src/Socket.cpp
new file mode 100644
index 00000000000..72a8bd9e2fa
--- /dev/null
+++ b/base/poco/Net/src/Socket.cpp
@@ -0,0 +1,392 @@
+//
+// Socket.cpp
+//
+// Library: Net
+// Package: Sockets
+// Module:  Socket
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/Socket.h"
+#include "Poco/Net/StreamSocketImpl.h"
+#include "Poco/Timestamp.h"
+#include <algorithm>
+#include <string.h> // FD_SET needs memset on some platforms, so we can't use <cstring>
+#if defined(POCO_HAVE_FD_EPOLL)
+#include <sys/epoll.h>
+#elif defined(POCO_HAVE_FD_POLL)
+#include "Poco/SharedPtr.h"
+#include <poll.h>
+#endif
+
+
+namespace Poco {
+namespace Net {
+
+
+Socket::Socket():
+	_pImpl(new StreamSocketImpl)
+{
+}
+
+
+Socket::Socket(SocketImpl* pImpl):
+	_pImpl(pImpl)
+{
+	poco_check_ptr (_pImpl);
+}
+
+
+Socket::Socket(const Socket& socket):
+	_pImpl(socket._pImpl)
+{
+	poco_check_ptr (_pImpl);
+
+	_pImpl->duplicate();
+}
+
+
+Socket& Socket::operator = (const Socket& socket)
+{
+	if (&socket != this)
+	{
+		if (_pImpl) _pImpl->release();
+		_pImpl = socket._pImpl;
+		if (_pImpl) _pImpl->duplicate();
+	}
+	return *this;
+}
+
+
+Socket::~Socket()
+{
+	_pImpl->release();
+}
+
+
+int Socket::select(SocketList& readList, SocketList& writeList, SocketList& exceptList, const Poco::Timespan& timeout)
+{
+#if defined(POCO_HAVE_FD_EPOLL)
+
+	int epollSize = readList.size() + writeList.size() + exceptList.size();
+	if (epollSize == 0) return 0;
+
+	int epollfd = -1;
+	{
+		struct epoll_event eventsIn[epollSize];
+		memset(eventsIn, 0, sizeof(eventsIn));
+		struct epoll_event* eventLast = eventsIn;
+		for (SocketList::iterator it = readList.begin(); it != readList.end(); ++it)
+		{
+			poco_socket_t sockfd = it->sockfd();
+			if (sockfd != POCO_INVALID_SOCKET)
+			{
+				struct epoll_event* e = eventsIn;
+				for (; e != eventLast; ++e)
+				{
+					if (reinterpret_cast<Socket*>(e->data.ptr)->sockfd() == sockfd)
+						break;
+				}
+				if (e == eventLast)
+				{
+					e->data.ptr = &(*it);
+					++eventLast;
+				}
+				e->events |= EPOLLIN;
+			}
+		}
+
+		for (SocketList::iterator it = writeList.begin(); it != writeList.end(); ++it)
+		{
+			poco_socket_t sockfd = it->sockfd();
+			if (sockfd != POCO_INVALID_SOCKET)
+			{
+				struct epoll_event* e = eventsIn;
+				for (; e != eventLast; ++e)
+				{
+					if (reinterpret_cast<Socket*>(e->data.ptr)->sockfd() == sockfd)
+						break;
+				}
+				if (e == eventLast)
+				{
+					e->data.ptr = &(*it);
+					++eventLast;
+				}
+				e->events |= EPOLLOUT;
+			}
+		}
+
+		for (SocketList::iterator it = exceptList.begin(); it != exceptList.end(); ++it)
+		{
+			poco_socket_t sockfd = it->sockfd();
+			if (sockfd != POCO_INVALID_SOCKET)
+			{
+				struct epoll_event* e = eventsIn;
+				for (; e != eventLast; ++e)
+				{
+					if (reinterpret_cast<Socket*>(e->data.ptr)->sockfd() == sockfd)
+						break;
+				}
+				if (e == eventLast)
+				{
+					e->data.ptr = &(*it);
+					++eventLast;
+				}
+				e->events |= EPOLLERR;
+			}
+		}
+
+		epollSize = eventLast - eventsIn;
+		if (epollSize == 0) return 0;
+
+		epollfd = epoll_create(1);
+		if (epollfd < 0)
+		{
+			SocketImpl::error("Can't create epoll queue");
+		}
+
+		for (struct epoll_event* e = eventsIn; e != eventLast; ++e)
+		{
+			poco_socket_t sockfd = reinterpret_cast<Socket*>(e->data.ptr)->sockfd();
+			if (sockfd != POCO_INVALID_SOCKET)
+			{
+				if (epoll_ctl(epollfd, EPOLL_CTL_ADD, sockfd, e) < 0)
+				{
+					::close(epollfd);
+					SocketImpl::error("Can't insert socket to epoll queue");
+				}
+			}
+		}
+	}
+
+	struct epoll_event eventsOut[epollSize];
+	memset(eventsOut, 0, sizeof(eventsOut));
+
+	Poco::Timespan remainingTime(timeout);
+	int rc;
+	do
+	{
+		Poco::Timestamp start;
+		rc = epoll_wait(epollfd, eventsOut, epollSize, remainingTime.totalMilliseconds());
+		if (rc < 0 && SocketImpl::lastError() == POCO_EINTR)
+		{
+ 			Poco::Timestamp end;
+			Poco::Timespan waited = end - start;
+			if (waited < remainingTime)
+				remainingTime -= waited;
+			else
+				remainingTime = 0;
+		}
+	}
+	while (rc < 0 && SocketImpl::lastError() == POCO_EINTR);
+
+	::close(epollfd);
+	if (rc < 0) SocketImpl::error();
+
+ 	SocketList readyReadList;
+	SocketList readyWriteList;
+	SocketList readyExceptList;
+	for (int n = 0; n < rc; ++n)
+	{
+		if (eventsOut[n].events & EPOLLERR)
+			readyExceptList.push_back(*reinterpret_cast<Socket*>(eventsOut[n].data.ptr));
+		if (eventsOut[n].events & EPOLLIN)
+			readyReadList.push_back(*reinterpret_cast<Socket*>(eventsOut[n].data.ptr));
+		if (eventsOut[n].events & EPOLLOUT)
+			readyWriteList.push_back(*reinterpret_cast<Socket*>(eventsOut[n].data.ptr));
+	}
+	std::swap(readList, readyReadList);
+	std::swap(writeList, readyWriteList);
+	std::swap(exceptList, readyExceptList);
+	return readList.size() + writeList.size() + exceptList.size();
+
+#elif defined(POCO_HAVE_FD_POLL)
+	typedef Poco::SharedPtr<pollfd, Poco::ReferenceCounter, Poco::ReleaseArrayPolicy<pollfd> > SharedPollArray;
+
+	nfds_t nfd = readList.size() + writeList.size() + exceptList.size();
+	if (0 == nfd) return 0;
+
+	SharedPollArray pPollArr = new pollfd[nfd]();
+
+	int idx = 0;
+	for (SocketList::iterator it = readList.begin(); it != readList.end(); ++it)
+	{
+		pPollArr[idx].fd = int(it->sockfd());
+		pPollArr[idx++].events |= POLLIN;
+	}
+
+	SocketList::iterator begR = readList.begin();
+	SocketList::iterator endR = readList.end();
+	for (SocketList::iterator it = writeList.begin(); it != writeList.end(); ++it)
+	{
+		SocketList::iterator pos = std::find(begR, endR, *it);
+		if (pos != endR)
+		{
+			pPollArr[pos-begR].events |= POLLOUT;
+			--nfd;
+		}
+		else
+		{
+			pPollArr[idx].fd = int(it->sockfd());
+			pPollArr[idx++].events |= POLLOUT;
+		}
+	}
+
+	SocketList::iterator begW = writeList.begin();
+	SocketList::iterator endW = writeList.end();
+	for (SocketList::iterator it = exceptList.begin(); it != exceptList.end(); ++it)
+	{
+		SocketList::iterator pos = std::find(begR, endR, *it);
+		if (pos != endR) --nfd;
+		else
+		{
+			SocketList::iterator pos = std::find(begW, endW, *it);
+			if (pos != endW) --nfd;
+			else pPollArr[idx++].fd = int(it->sockfd());
+		}
+	}
+
+	Poco::Timespan remainingTime(timeout);
+	int rc;
+	do
+	{
+		Poco::Timestamp start;
+		rc = ::poll(pPollArr, nfd, remainingTime.totalMilliseconds());
+		if (rc < 0 && SocketImpl::lastError() == POCO_EINTR)
+		{
+			Poco::Timestamp end;
+			Poco::Timespan waited = end - start;
+			if (waited < remainingTime) remainingTime -= waited;
+			else remainingTime = 0;
+		}
+	}
+	while (rc < 0 && SocketImpl::lastError() == POCO_EINTR);
+	if (rc < 0) SocketImpl::error();
+
+	SocketList readyReadList;
+	SocketList readyWriteList;
+	SocketList readyExceptList;
+
+	SocketList::iterator begE = exceptList.begin();
+	SocketList::iterator endE = exceptList.end();
+	for (int idx = 0; idx < nfd; ++idx)
+	{
+		SocketList::iterator slIt = std::find_if(begR, endR, Socket::FDCompare(pPollArr[idx].fd));
+		if (POLLIN & pPollArr[idx].revents && slIt != endR) readyReadList.push_back(*slIt);
+		slIt = std::find_if(begW, endW, Socket::FDCompare(pPollArr[idx].fd));
+		if (POLLOUT & pPollArr[idx].revents && slIt != endW) readyWriteList.push_back(*slIt);
+		slIt = std::find_if(begE, endE, Socket::FDCompare(pPollArr[idx].fd));
+		if (POLLERR & pPollArr[idx].revents && slIt != endE) readyExceptList.push_back(*slIt);
+	}
+	std::swap(readList, readyReadList);
+	std::swap(writeList, readyWriteList);
+	std::swap(exceptList, readyExceptList);
+	return readList.size() + writeList.size() + exceptList.size();
+
+#else
+
+	fd_set fdRead;
+	fd_set fdWrite;
+	fd_set fdExcept;
+	int nfd = 0;
+	FD_ZERO(&fdRead);
+	for (SocketList::const_iterator it = readList.begin(); it != readList.end(); ++it)
+	{
+		poco_socket_t fd = it->sockfd();
+		if (fd != POCO_INVALID_SOCKET)
+		{
+			if (int(fd) > nfd)
+				nfd = int(fd);
+			FD_SET(fd, &fdRead);
+		}
+	}
+	FD_ZERO(&fdWrite);
+	for (SocketList::const_iterator it = writeList.begin(); it != writeList.end(); ++it)
+	{
+		poco_socket_t fd = it->sockfd();
+		if (fd != POCO_INVALID_SOCKET)
+		{
+			if (int(fd) > nfd)
+				nfd = int(fd);
+			FD_SET(fd, &fdWrite);
+		}
+	}
+	FD_ZERO(&fdExcept);
+	for (SocketList::const_iterator it = exceptList.begin(); it != exceptList.end(); ++it)
+	{
+		poco_socket_t fd = it->sockfd();
+		if (fd != POCO_INVALID_SOCKET)
+		{
+			if (int(fd) > nfd)
+				nfd = int(fd);
+			FD_SET(fd, &fdExcept);
+		}
+	}
+	if (nfd == 0) return 0;
+	Poco::Timespan remainingTime(timeout);
+	int rc;
+	do
+	{
+		struct timeval tv;
+		tv.tv_sec  = (long) remainingTime.totalSeconds();
+		tv.tv_usec = (long) remainingTime.useconds();
+		Poco::Timestamp start;
+		rc = ::select(nfd + 1, &fdRead, &fdWrite, &fdExcept, &tv);
+		if (rc < 0 && SocketImpl::lastError() == POCO_EINTR)
+		{
+			Poco::Timestamp end;
+			Poco::Timespan waited = end - start;
+			if (waited < remainingTime)
+				remainingTime -= waited;
+			else
+				remainingTime = 0;
+		}
+	}
+	while (rc < 0 && SocketImpl::lastError() == POCO_EINTR);
+	if (rc < 0) SocketImpl::error();
+
+	SocketList readyReadList;
+	for (SocketList::const_iterator it = readList.begin(); it != readList.end(); ++it)
+	{
+		poco_socket_t fd = it->sockfd();
+		if (fd != POCO_INVALID_SOCKET)
+		{
+			if (FD_ISSET(fd, &fdRead))
+				readyReadList.push_back(*it);
+		}
+	}
+	std::swap(readList, readyReadList);
+	SocketList readyWriteList;
+	for (SocketList::const_iterator it = writeList.begin(); it != writeList.end(); ++it)
+	{
+		poco_socket_t fd = it->sockfd();
+		if (fd != POCO_INVALID_SOCKET)
+		{
+			if (FD_ISSET(fd, &fdWrite))
+				readyWriteList.push_back(*it);
+		}
+	}
+	std::swap(writeList, readyWriteList);
+	SocketList readyExceptList;
+	for (SocketList::const_iterator it = exceptList.begin(); it != exceptList.end(); ++it)
+	{
+		poco_socket_t fd = it->sockfd();
+		if (fd != POCO_INVALID_SOCKET)
+		{
+			if (FD_ISSET(fd, &fdExcept))
+				readyExceptList.push_back(*it);
+		}
+	}
+	std::swap(exceptList, readyExceptList);
+	return rc;
+
+#endif // POCO_HAVE_FD_EPOLL
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/SocketAddress.cpp b/base/poco/Net/src/SocketAddress.cpp
new file mode 100644
index 00000000000..0782ca3eea3
--- /dev/null
+++ b/base/poco/Net/src/SocketAddress.cpp
@@ -0,0 +1,435 @@
+//
+// SocketAddress.cpp
+//
+// Library: Net
+// Package: NetCore
+// Module:  SocketAddress
+//
+// Copyright (c) 2005-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/Net/IPAddress.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Net/DNS.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/NumberParser.h"
+#include "Poco/BinaryReader.h"
+#include "Poco/BinaryWriter.h"
+#include <algorithm>
+#include <cstring>
+
+
+using Poco::RefCountedObject;
+using Poco::NumberParser;
+using Poco::UInt16;
+using Poco::InvalidArgumentException;
+using Poco::Net::Impl::SocketAddressImpl;
+using Poco::Net::Impl::IPv4SocketAddressImpl;
+#ifdef POCO_HAVE_IPv6
+using Poco::Net::Impl::IPv6SocketAddressImpl;
+#endif
+#ifdef POCO_OS_FAMILY_UNIX
+using Poco::Net::Impl::LocalSocketAddressImpl;
+#endif
+
+
+namespace Poco {
+namespace Net {
+
+
+struct AFLT
+{
+	bool operator () (const IPAddress& a1, const IPAddress& a2)
+	{
+		return a1.af() < a2.af();
+	}
+};
+
+
+//
+// SocketAddress
+//
+
+
+#if !defined(_MSC_VER) || defined(__STDC__)
+// Go home MSVC, you're drunk...
+// See http://stackoverflow.com/questions/5899857/multiple-definition-error-for-static-const-class-members
+const SocketAddress::Family SocketAddress::IPv4;
+#if defined(POCO_HAVE_IPv6)
+const SocketAddress::Family SocketAddress::IPv6;
+#endif
+#if defined(POCO_OS_FAMILY_UNIX)
+const SocketAddress::Family SocketAddress::UNIX_LOCAL;
+#endif
+#endif
+
+
+SocketAddress::SocketAddress()
+{
+	newIPv4();
+}
+
+
+SocketAddress::SocketAddress(Family fam)
+{
+		init(IPAddress(fam), 0);
+}
+
+
+SocketAddress::SocketAddress(const IPAddress& hostAddress, Poco::UInt16 portNumber)
+{
+	init(hostAddress, portNumber);
+}
+
+
+SocketAddress::SocketAddress(Poco::UInt16 portNumber)
+{
+	init(IPAddress(), portNumber);
+}
+
+
+SocketAddress::SocketAddress(Family fam, Poco::UInt16 portNumber)
+{
+	init(IPAddress(fam), portNumber);
+}
+
+
+SocketAddress::SocketAddress(const std::string& hostAddress, Poco::UInt16 portNumber)
+{
+	init(hostAddress, portNumber);
+}
+
+
+SocketAddress::SocketAddress(Family fam, const std::string& hostAddress, Poco::UInt16 portNumber)
+{
+	init(fam, hostAddress, portNumber);
+}
+
+
+SocketAddress::SocketAddress(const std::string& hostAddress, const std::string& portNumber)
+{
+	init(hostAddress, resolveService(portNumber));
+}
+
+
+SocketAddress::SocketAddress(Family fam, const std::string& hostAddress, const std::string& portNumber)
+{
+	init(fam, hostAddress, resolveService(portNumber));
+}
+
+
+SocketAddress::SocketAddress(Family fam, const std::string& addr)
+{
+	init(fam, addr);
+}
+
+
+SocketAddress::SocketAddress(const std::string& hostAndPort)
+{
+	init(hostAndPort);
+}
+
+
+SocketAddress::SocketAddress(const SocketAddress& socketAddress)
+{
+	if (socketAddress.family() == IPv4)
+		newIPv4(reinterpret_cast<const sockaddr_in*>(socketAddress.addr()));
+#if defined(POCO_HAVE_IPv6)
+	else if (socketAddress.family() == IPv6)
+		newIPv6(reinterpret_cast<const sockaddr_in6*>(socketAddress.addr()));
+#endif
+#if defined(POCO_OS_FAMILY_UNIX)
+	else if (socketAddress.family() == UNIX_LOCAL)
+		newLocal(reinterpret_cast<const sockaddr_un*>(socketAddress.addr()));
+#endif
+}
+
+
+SocketAddress::SocketAddress(const struct sockaddr* sockAddr, poco_socklen_t length)
+{
+	if (length == sizeof(struct sockaddr_in) && sockAddr->sa_family == AF_INET)
+		newIPv4(reinterpret_cast<const struct sockaddr_in*>(sockAddr));
+#if defined(POCO_HAVE_IPv6)
+	else if (length == sizeof(struct sockaddr_in6) && sockAddr->sa_family == AF_INET6)
+		newIPv6(reinterpret_cast<const struct sockaddr_in6*>(sockAddr));
+#endif
+#if defined(POCO_OS_FAMILY_UNIX)
+	else if (length > 0 && length <= sizeof(struct sockaddr_un) && sockAddr->sa_family == AF_UNIX)
+		newLocal(reinterpret_cast<const sockaddr_un*>(sockAddr));
+#endif
+	else throw Poco::InvalidArgumentException("Invalid address length or family passed to SocketAddress()");
+}
+
+
+SocketAddress::~SocketAddress()
+{
+}
+
+
+bool SocketAddress::operator < (const SocketAddress& socketAddress) const
+{
+	if (family() < socketAddress.family()) return true;
+	if (family() > socketAddress.family()) return false;
+#if defined(POCO_OS_FAMILY_UNIX)
+	if (family() == UNIX_LOCAL) return toString() < socketAddress.toString();
+#endif
+	if (host() < socketAddress.host()) return true;
+	if (host() > socketAddress.host()) return false;
+	return (port() < socketAddress.port());
+}
+
+
+SocketAddress& SocketAddress::operator = (const SocketAddress& socketAddress)
+{
+	if (&socketAddress != this)
+	{
+		if (socketAddress.family() == IPv4)
+			newIPv4(reinterpret_cast<const sockaddr_in*>(socketAddress.addr()));
+#if defined(POCO_HAVE_IPv6)
+		else if (socketAddress.family() == IPv6)
+			newIPv6(reinterpret_cast<const sockaddr_in6*>(socketAddress.addr()));
+#endif
+#if defined(POCO_OS_FAMILY_UNIX)
+		else if (socketAddress.family() == UNIX_LOCAL)
+			newLocal(reinterpret_cast<const sockaddr_un*>(socketAddress.addr()));
+#endif
+	}
+	return *this;
+}
+
+
+IPAddress SocketAddress::host() const
+{
+	return pImpl()->host();
+}
+
+
+Poco::UInt16 SocketAddress::port() const
+{
+	return ntohs(pImpl()->port());
+}
+
+
+poco_socklen_t SocketAddress::length() const
+{
+	return pImpl()->length();
+}
+
+
+const struct sockaddr* SocketAddress::addr() const
+{
+	return pImpl()->addr();
+}
+
+
+int SocketAddress::af() const
+{
+	return pImpl()->af();
+}
+
+
+SocketAddress::Family SocketAddress::family() const
+{
+	return static_cast<Family>(pImpl()->family());
+}
+
+
+std::string SocketAddress::toString() const
+{
+	return pImpl()->toString();
+}
+
+
+void SocketAddress::init(const IPAddress& hostAddress, Poco::UInt16 portNumber)
+{
+	if (hostAddress.family() == IPAddress::IPv4)
+		newIPv4(hostAddress, portNumber);
+#if defined(POCO_HAVE_IPv6)
+	else if (hostAddress.family() == IPAddress::IPv6)
+		newIPv6(hostAddress, portNumber);
+#endif
+	else throw Poco::NotImplementedException("unsupported IP address family");
+}
+
+
+void SocketAddress::init(const std::string& hostAddress, Poco::UInt16 portNumber)
+{
+	IPAddress ip;
+	if (IPAddress::tryParse(hostAddress, ip))
+	{
+		init(ip, portNumber);
+	}
+	else
+	{
+		HostEntry he = DNS::hostByName(hostAddress);
+		HostEntry::AddressList addresses = he.addresses();
+		if (addresses.size() > 0)
+		{
+#if defined(POCO_HAVE_IPv6) && defined(POCO_SOCKETADDRESS_PREFER_IPv4)
+			// if we get both IPv4 and IPv6 addresses, prefer IPv4
+			std::stable_sort(addresses.begin(), addresses.end(), AFLT());
+#endif
+			init(addresses[0], portNumber);
+		}
+		else throw HostNotFoundException("No address found for host", hostAddress);
+	}
+}
+
+
+void SocketAddress::init(Family fam, const std::string& hostAddress, Poco::UInt16 portNumber)
+{
+	IPAddress ip;
+	if (IPAddress::tryParse(hostAddress, ip))
+	{
+		if (ip.family() != fam) throw AddressFamilyMismatchException(hostAddress);
+		init(ip, portNumber);
+	}
+	else
+	{
+		HostEntry he = DNS::hostByName(hostAddress);
+		HostEntry::AddressList addresses = he.addresses();
+		if (addresses.size() > 0)
+		{
+			for (HostEntry::AddressList::const_iterator it = addresses.begin(); it != addresses.end(); ++it)
+			{
+				if (it->family() == fam)
+				{
+					init(*it, portNumber);
+					return;
+				}
+			}
+			throw AddressFamilyMismatchException(hostAddress);
+		}
+		else throw HostNotFoundException("No address found for host", hostAddress);
+	}
+}
+
+
+void SocketAddress::init(Family fam, const std::string& address)
+{
+#if defined(POCO_OS_FAMILY_UNIX)
+	if (fam == UNIX_LOCAL)
+	{
+		newLocal(address);
+	}
+	else
+#endif
+	{
+		std::string host;
+		std::string port;
+		std::string::const_iterator it  = address.begin();
+		std::string::const_iterator end = address.end();
+
+		if (*it == '[')
+		{
+			++it;
+			while (it != end && *it != ']') host += *it++;
+			if (it == end) throw InvalidArgumentException("Malformed IPv6 address");
+			++it;
+		}
+		else
+		{
+			while (it != end && *it != ':') host += *it++;
+		}
+		if (it != end && *it == ':')
+		{
+			++it;
+			while (it != end) port += *it++;
+		}
+		else throw InvalidArgumentException("Missing port number");
+		init(fam, host, resolveService(port));
+	}
+}
+
+
+void SocketAddress::init(const std::string& hostAndPort)
+{
+	poco_assert (!hostAndPort.empty());
+
+	std::string host;
+	std::string port;
+	std::string::const_iterator it  = hostAndPort.begin();
+	std::string::const_iterator end = hostAndPort.end();
+
+#if defined(POCO_OS_FAMILY_UNIX)
+	if (*it == '/')
+	{
+		newLocal(hostAndPort);
+		return;
+	}
+#endif
+	if (*it == '[')
+	{
+		++it;
+		while (it != end && *it != ']') host += *it++;
+		if (it == end) throw InvalidArgumentException("Malformed IPv6 address");
+		++it;
+	}
+	else
+	{
+		while (it != end && *it != ':') host += *it++;
+	}
+	if (it != end && *it == ':')
+	{
+		++it;
+		while (it != end) port += *it++;
+	}
+	else throw InvalidArgumentException("Missing port number");
+	init(host, resolveService(port));
+}
+
+
+Poco::UInt16 SocketAddress::resolveService(const std::string& service)
+{
+	unsigned port;
+	if (NumberParser::tryParseUnsigned(service, port) && port <= 0xFFFF)
+	{
+		return (UInt16) port;
+	}
+	else
+	{
+#if defined(POCO_VXWORKS)
+		throw ServiceNotFoundException(service);
+#else
+		struct servent* se = getservbyname(service.c_str(), NULL);
+		if (se)
+			return ntohs(se->s_port);
+		else
+			throw ServiceNotFoundException(service);
+#endif
+	}
+}
+
+
+} } // namespace Poco::Net
+
+
+Poco::BinaryWriter& operator << (Poco::BinaryWriter& writer, const Poco::Net::SocketAddress& value)
+{
+	writer << value.host();
+	writer << value.port();
+	return writer;
+}
+
+
+Poco::BinaryReader& operator >> (Poco::BinaryReader& reader, Poco::Net::SocketAddress& value)
+{
+	Poco::Net::IPAddress host;
+	reader >> host;
+	Poco::UInt16 port;
+	reader >> port;
+	value = Poco::Net::SocketAddress(host, port);
+	return reader;
+}
+
+
+std::ostream& operator << (std::ostream& ostr, const Poco::Net::SocketAddress& address)
+{
+	ostr << address.toString();
+	return ostr;
+}
diff --git a/base/poco/Net/src/SocketAddressImpl.cpp b/base/poco/Net/src/SocketAddressImpl.cpp
new file mode 100644
index 00000000000..57690170f20
--- /dev/null
+++ b/base/poco/Net/src/SocketAddressImpl.cpp
@@ -0,0 +1,184 @@
+//
+// SocketAddressImpl.cpp
+//
+// Library: Net
+// Package: NetCore
+// Module:  SocketAddressImpl
+//
+// Copyright (c) 2005-2011, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SocketAddressImpl.h"
+#include "Poco/Net/SocketDefs.h"
+#include "Poco/NumberFormatter.h"
+#include <cstring>
+
+
+namespace Poco {
+namespace Net {
+namespace Impl {
+
+
+//
+// SocketAddressImpl
+//
+
+
+SocketAddressImpl::SocketAddressImpl()
+{
+}
+
+
+SocketAddressImpl::~SocketAddressImpl()
+{
+}
+
+
+//
+// IPv4SocketAddressImpl
+//
+
+
+IPv4SocketAddressImpl::IPv4SocketAddressImpl()
+{
+	std::memset(&_addr, 0, sizeof(_addr));
+	_addr.sin_family = AF_INET;
+	poco_set_sin_len(&_addr);
+}
+
+
+IPv4SocketAddressImpl::IPv4SocketAddressImpl(const struct sockaddr_in* addr)
+{
+	std::memcpy(&_addr, addr, sizeof(_addr));
+}
+
+
+IPv4SocketAddressImpl::IPv4SocketAddressImpl(const void* addr, UInt16 port)
+{
+	std::memset(&_addr, 0, sizeof(_addr));
+	_addr.sin_family = AF_INET;
+	poco_set_sin_len(&_addr);
+	std::memcpy(&_addr.sin_addr, addr, sizeof(_addr.sin_addr));
+	_addr.sin_port = port;
+}
+
+
+std::string IPv4SocketAddressImpl::toString() const
+{
+	std::string result;
+	result.append(host().toString());
+	result.append(":");
+	NumberFormatter::append(result, ntohs(port()));
+	return result;
+}
+
+
+#if defined(POCO_HAVE_IPv6)
+
+
+//
+// IPv6SocketAddressImpl
+//
+
+
+IPv6SocketAddressImpl::IPv6SocketAddressImpl(const struct sockaddr_in6* addr)
+{
+	std::memcpy(&_addr, addr, sizeof(_addr));
+}
+
+
+IPv6SocketAddressImpl::IPv6SocketAddressImpl(const void* addr, UInt16 port)
+{
+	std::memset(&_addr, 0, sizeof(_addr));
+	_addr.sin6_family = AF_INET6;
+	poco_set_sin6_len(&_addr);
+	std::memcpy(&_addr.sin6_addr, addr, sizeof(_addr.sin6_addr));
+	_addr.sin6_port = port;
+}
+
+
+IPv6SocketAddressImpl::IPv6SocketAddressImpl(const void* addr, UInt16 port, UInt32 scope)
+{
+	std::memset(&_addr, 0, sizeof(_addr));
+	_addr.sin6_family = AF_INET6;
+	poco_set_sin6_len(&_addr);
+	std::memcpy(&_addr.sin6_addr, addr, sizeof(_addr.sin6_addr));
+	_addr.sin6_port = port;
+	_addr.sin6_scope_id = scope;
+}
+
+
+std::string IPv6SocketAddressImpl::toString() const
+{
+	std::string result;
+	result.append("[");
+	result.append(host().toString());
+	result.append("]");
+	result.append(":");
+	NumberFormatter::append(result, ntohs(port()));
+	return result;
+}
+
+
+#endif // POCO_HAVE_IPv6
+
+
+#if defined(POCO_OS_FAMILY_UNIX)
+
+
+//
+// LocalSocketAddressImpl
+//
+
+
+LocalSocketAddressImpl::LocalSocketAddressImpl(const struct sockaddr_un* addr)
+{
+	_pAddr = new sockaddr_un;
+	std::memcpy(_pAddr, addr, sizeof(struct sockaddr_un));
+}
+
+
+LocalSocketAddressImpl::LocalSocketAddressImpl(const char* path)
+{
+	poco_assert (std::strlen(path) < sizeof(_pAddr->sun_path));
+
+	_pAddr = new sockaddr_un;
+	poco_set_sun_len(_pAddr, std::strlen(path) + sizeof(struct sockaddr_un) - sizeof(_pAddr->sun_path) + 1);
+	_pAddr->sun_family = AF_UNIX;
+	std::strcpy(_pAddr->sun_path, path);
+}
+
+
+LocalSocketAddressImpl::LocalSocketAddressImpl(const char* path, std::size_t length)
+{
+	poco_assert (length < sizeof(_pAddr->sun_path));
+
+	_pAddr = new sockaddr_un;
+	poco_set_sun_len(_pAddr, length + sizeof(struct sockaddr_un) - sizeof(_pAddr->sun_path) + 1);
+	_pAddr->sun_family = AF_UNIX;
+	std::memcpy(_pAddr->sun_path, path, length);
+	_pAddr->sun_path[length] = 0;
+}
+
+
+LocalSocketAddressImpl::~LocalSocketAddressImpl()
+{
+	delete _pAddr;
+}
+
+
+std::string LocalSocketAddressImpl::toString() const
+{
+	std::string result(path());
+	return result;
+}
+
+
+#endif // POCO_OS_FAMILY_UNIX
+
+
+} } } // namespace Poco::Net::Impl
diff --git a/base/poco/Net/src/SocketImpl.cpp b/base/poco/Net/src/SocketImpl.cpp
new file mode 100644
index 00000000000..160ff6bd62b
--- /dev/null
+++ b/base/poco/Net/src/SocketImpl.cpp
@@ -0,0 +1,1090 @@
+//
+// SocketImpl.cpp
+//
+// Library: Net
+// Package: Sockets
+// Module:  SocketImpl
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SocketImpl.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Net/StreamSocketImpl.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/Timestamp.h"
+#include <string.h> // FD_SET needs memset on some platforms, so we can't use <cstring>
+
+
+#if defined(_WIN32) && _WIN32_WINNT >= 0x0600
+#ifndef POCO_HAVE_FD_POLL
+#define POCO_HAVE_FD_POLL 1
+#endif
+#elif defined(POCO_OS_FAMILY_UNIX)
+#ifndef POCO_HAVE_FD_POLL
+#define POCO_HAVE_FD_POLL 1
+#endif
+#endif
+
+
+#if defined(POCO_HAVE_FD_POLL)
+#ifndef _WIN32
+#include <poll.h>
+#endif
+#endif
+
+
+#if defined(sun) || defined(__sun) || defined(__sun__)
+#include <unistd.h>
+#include <stropts.h>
+#endif
+
+
+#ifdef POCO_OS_FAMILY_WINDOWS
+#include <windows.h>
+#endif
+
+
+using Poco::IOException;
+using Poco::TimeoutException;
+using Poco::InvalidArgumentException;
+using Poco::NumberFormatter;
+using Poco::Timespan;
+
+
+namespace Poco {
+namespace Net {
+
+
+bool checkIsBrokenTimeout()
+{
+#if defined(POCO_BROKEN_TIMEOUTS)
+	return true;
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+	// on Windows 7 and lower, socket timeouts have a minimum of 500ms, use poll for timeouts on this case
+	// https://social.msdn.microsoft.com/Forums/en-US/76620f6d-22b1-4872-aaf0-833204f3f867/minimum-timeout-value-for-sorcvtimeo
+	OSVERSIONINFO vi;
+	vi.dwOSVersionInfoSize = sizeof(vi);
+	if (GetVersionEx(&vi) == 0) return true; //throw SystemException("Cannot get OS version information");
+	return vi.dwMajorVersion < 6 || (vi.dwMajorVersion == 6 && vi.dwMinorVersion < 2);
+#endif
+	return false;
+}
+
+
+SocketImpl::SocketImpl():
+	_sockfd(POCO_INVALID_SOCKET),
+	_blocking(true), 
+	_isBrokenTimeout(checkIsBrokenTimeout())
+{
+}
+
+
+SocketImpl::SocketImpl(poco_socket_t sockfd):
+	_sockfd(sockfd),
+	_blocking(true),
+	_isBrokenTimeout(checkIsBrokenTimeout())
+{
+}
+
+
+SocketImpl::~SocketImpl()
+{
+	close();
+}
+
+	
+SocketImpl* SocketImpl::acceptConnection(SocketAddress& clientAddr)
+{
+	if (_sockfd == POCO_INVALID_SOCKET) throw InvalidSocketException();
+
+	sockaddr_storage buffer;
+	struct sockaddr* pSA = reinterpret_cast<struct sockaddr*>(&buffer);
+	poco_socklen_t saLen = sizeof(buffer);
+	poco_socket_t sd;
+	do
+	{
+		sd = ::accept(_sockfd, pSA, &saLen);
+	}
+	while (sd == POCO_INVALID_SOCKET && lastError() == POCO_EINTR);
+	if (sd != POCO_INVALID_SOCKET)
+	{
+		clientAddr = SocketAddress(pSA, saLen);
+		return new StreamSocketImpl(sd);
+	}
+	error(); // will throw
+	return 0;
+}
+
+
+void SocketImpl::connect(const SocketAddress& address)
+{
+	if (_sockfd == POCO_INVALID_SOCKET)
+	{
+		init(address.af());
+	}
+	int rc;
+	do
+	{
+#if defined(POCO_VXWORKS)
+		rc = ::connect(_sockfd, (sockaddr*) address.addr(), address.length());
+#else
+		rc = ::connect(_sockfd, address.addr(), address.length());
+#endif
+	}
+	while (rc != 0 && lastError() == POCO_EINTR);
+	if (rc != 0) 
+	{
+		int err = lastError();
+		error(err, address.toString());
+	}
+}
+
+
+void SocketImpl::connect(const SocketAddress& address, const Poco::Timespan& timeout)
+{
+	if (_sockfd == POCO_INVALID_SOCKET)
+	{
+		init(address.af());
+	}
+	setBlocking(false);
+	try
+	{
+#if defined(POCO_VXWORKS)
+		int rc = ::connect(_sockfd, (sockaddr*) address.addr(), address.length());
+#else
+		int rc = ::connect(_sockfd, address.addr(), address.length());
+#endif
+		if (rc != 0)
+		{
+			int err = lastError();
+			if (err != POCO_EINPROGRESS && err != POCO_EWOULDBLOCK)
+				error(err, address.toString());
+			if (!poll(timeout, SELECT_READ | SELECT_WRITE | SELECT_ERROR))
+				throw Poco::TimeoutException("connect timed out", address.toString());
+			err = socketError();
+			if (err != 0) error(err);
+		}
+	}
+	catch (Poco::Exception&)
+	{
+		setBlocking(true);
+		throw;
+	}
+	setBlocking(true);
+}
+
+
+void SocketImpl::connectNB(const SocketAddress& address)
+{
+	if (_sockfd == POCO_INVALID_SOCKET)
+	{
+		init(address.af());
+	}
+	setBlocking(false);
+#if defined(POCO_VXWORKS)
+	int rc = ::connect(_sockfd, (sockaddr*) address.addr(), address.length());
+#else
+	int rc = ::connect(_sockfd, address.addr(), address.length());
+#endif
+	if (rc != 0)
+	{
+		int err = lastError();
+		if (err != POCO_EINPROGRESS && err != POCO_EWOULDBLOCK)
+			error(err, address.toString());
+	}
+}
+
+
+void SocketImpl::bind(const SocketAddress& address, bool reuseAddress)
+{
+	bind(address, reuseAddress, reuseAddress);
+}
+
+
+void SocketImpl::bind(const SocketAddress& address, bool reuseAddress, bool reusePort)
+{
+	if (_sockfd == POCO_INVALID_SOCKET)
+	{
+		init(address.af());
+	}
+	if (reuseAddress)
+		setReuseAddress(true);
+    if (reusePort)
+		setReusePort(true);
+#if defined(POCO_VXWORKS)
+	int rc = ::bind(_sockfd, (sockaddr*) address.addr(), address.length());
+#else
+	int rc = ::bind(_sockfd, address.addr(), address.length());
+#endif
+	if (rc != 0) error(address.toString());
+}
+
+
+void SocketImpl::bind6(const SocketAddress& address, bool reuseAddress, bool ipV6Only)
+{
+    bind6(address, reuseAddress, true, ipV6Only);
+}
+
+
+void SocketImpl::bind6(const SocketAddress& address, bool reuseAddress, bool reusePort, bool ipV6Only)
+{
+#if defined(POCO_HAVE_IPv6)
+	if (address.family() != SocketAddress::IPv6)
+		throw Poco::InvalidArgumentException("SocketAddress must be an IPv6 address");
+		
+	if (_sockfd == POCO_INVALID_SOCKET)
+	{
+		init(address.af());
+	}
+#ifdef IPV6_V6ONLY
+	setOption(IPPROTO_IPV6, IPV6_V6ONLY, ipV6Only ? 1 : 0);
+#else
+	if (ipV6Only) throw Poco::NotImplementedException("IPV6_V6ONLY not defined.");
+#endif
+	if (reuseAddress)
+		setReuseAddress(true);
+    if (reusePort)
+		setReusePort(true);
+	int rc = ::bind(_sockfd, address.addr(), address.length());
+	if (rc != 0) error(address.toString());
+#else
+	throw Poco::NotImplementedException("No IPv6 support available");
+#endif
+}
+
+	
+void SocketImpl::listen(int backlog)
+{
+	if (_sockfd == POCO_INVALID_SOCKET) throw InvalidSocketException();
+	
+	int rc = ::listen(_sockfd, backlog);
+	if (rc != 0) error();
+}
+
+
+void SocketImpl::close()
+{
+	if (_sockfd != POCO_INVALID_SOCKET)
+	{
+		poco_closesocket(_sockfd);
+		_sockfd = POCO_INVALID_SOCKET;
+	}
+}
+
+
+void SocketImpl::shutdownReceive()
+{
+	if (_sockfd == POCO_INVALID_SOCKET) throw InvalidSocketException();
+
+	int rc = ::shutdown(_sockfd, 0);
+	if (rc != 0) error();
+}
+
+	
+void SocketImpl::shutdownSend()
+{
+	if (_sockfd == POCO_INVALID_SOCKET) throw InvalidSocketException();
+
+	int rc = ::shutdown(_sockfd, 1);
+	if (rc != 0) error();
+}
+
+	
+void SocketImpl::shutdown()
+{
+	if (_sockfd == POCO_INVALID_SOCKET) throw InvalidSocketException();
+
+	int rc = ::shutdown(_sockfd, 2);
+	if (rc != 0) error();
+}
+
+
+int SocketImpl::sendBytes(const void* buffer, int length, int flags)
+{
+	if (_isBrokenTimeout)
+	{
+		if (_sndTimeout.totalMicroseconds() != 0)
+		{
+			if (!poll(_sndTimeout, SELECT_WRITE))
+				throw TimeoutException();
+		}
+	}
+
+	int rc;
+	do
+	{
+		if (_sockfd == POCO_INVALID_SOCKET) throw InvalidSocketException();
+		rc = ::send(_sockfd, reinterpret_cast<const char*>(buffer), length, flags);
+	}
+	while (_blocking && rc < 0 && lastError() == POCO_EINTR);
+	if (rc < 0)
+	{
+		int err = lastError();
+		if (err == POCO_EAGAIN || err == POCO_ETIMEDOUT)
+			throw TimeoutException();
+		else
+			error(err);
+	}
+	return rc;
+}
+
+
+int SocketImpl::receiveBytes(void* buffer, int length, int flags)
+{
+	bool blocking = _blocking && (flags & MSG_DONTWAIT) == 0;
+	if (_isBrokenTimeout && blocking)
+	{
+		if (_recvTimeout.totalMicroseconds() != 0)
+		{
+			if (!poll(_recvTimeout, SELECT_READ))
+				throw TimeoutException();
+		}
+	}
+	
+	int rc;
+	do
+	{
+		if (_sockfd == POCO_INVALID_SOCKET) throw InvalidSocketException();
+		rc = ::recv(_sockfd, reinterpret_cast<char*>(buffer), length, flags);
+	}
+	while (blocking && rc < 0 && lastError() == POCO_EINTR);
+	if (rc < 0) 
+	{
+		int err = lastError();
+		if ((err == POCO_EAGAIN || err == POCO_EWOULDBLOCK) && !blocking)
+			;
+		else if (err == POCO_EAGAIN || err == POCO_ETIMEDOUT)
+			throw TimeoutException(err);
+		else
+			error(err);
+	}
+	return rc;
+}
+
+
+int SocketImpl::sendTo(const void* buffer, int length, const SocketAddress& address, int flags)
+{
+	int rc;
+	do
+	{
+		if (_sockfd == POCO_INVALID_SOCKET) throw InvalidSocketException();
+#if defined(POCO_VXWORKS)
+		rc = ::sendto(_sockfd, (char*) buffer, length, flags, (sockaddr*) address.addr(), address.length());
+#else
+		rc = ::sendto(_sockfd, reinterpret_cast<const char*>(buffer), length, flags, address.addr(), address.length());
+#endif
+	}
+	while (_blocking && rc < 0 && lastError() == POCO_EINTR);
+	if (rc < 0) error();
+	return rc;
+}
+
+
+int SocketImpl::receiveFrom(void* buffer, int length, SocketAddress& address, int flags)
+{
+	if (_isBrokenTimeout)
+	{
+		if (_recvTimeout.totalMicroseconds() != 0)
+		{
+			if (!poll(_recvTimeout, SELECT_READ))
+				throw TimeoutException();
+		}
+	}
+	
+	sockaddr_storage abuffer;
+	struct sockaddr* pSA = reinterpret_cast<struct sockaddr*>(&abuffer);
+	poco_socklen_t saLen = sizeof(abuffer);
+	int rc;
+	do
+	{
+		if (_sockfd == POCO_INVALID_SOCKET) throw InvalidSocketException();
+		rc = ::recvfrom(_sockfd, reinterpret_cast<char*>(buffer), length, flags, pSA, &saLen);
+	}
+	while (_blocking && rc < 0 && lastError() == POCO_EINTR);
+	if (rc >= 0)
+	{
+		address = SocketAddress(pSA, saLen);
+	}
+	else
+	{
+		int err = lastError();
+		if (err == POCO_EAGAIN && !_blocking)
+			;
+		else if (err == POCO_EAGAIN || err == POCO_ETIMEDOUT)
+			throw TimeoutException(err);
+		else
+			error(err);
+	}
+	return rc;
+}
+
+
+void SocketImpl::sendUrgent(unsigned char data)
+{
+	if (_sockfd == POCO_INVALID_SOCKET) throw InvalidSocketException();
+
+	int rc = ::send(_sockfd, reinterpret_cast<const char*>(&data), sizeof(data), MSG_OOB);
+	if (rc < 0) error();
+}
+
+
+int SocketImpl::available()
+{
+	int result = 0;
+	ioctl(FIONREAD, result);
+	return result;
+}
+
+
+bool SocketImpl::secure() const
+{
+	return false;
+}
+
+
+bool SocketImpl::pollImpl(Poco::Timespan& remainingTime, int mode)
+{
+	poco_socket_t sockfd = _sockfd;
+	if (sockfd == POCO_INVALID_SOCKET) throw InvalidSocketException();
+
+#if defined(POCO_HAVE_FD_POLL)
+
+	pollfd pollBuf;
+
+	memset(&pollBuf, 0, sizeof(pollfd));
+	pollBuf.fd = _sockfd;
+	if (mode & SELECT_READ) pollBuf.events |= POLLIN;
+	if (mode & SELECT_WRITE) pollBuf.events |= POLLOUT;
+
+	int rc;
+	do
+	{
+		Poco::Timestamp start;
+#ifdef _WIN32
+		rc = WSAPoll(&pollBuf, 1, static_cast<INT>(remainingTime.totalMilliseconds()));
+#else
+		rc = ::poll(&pollBuf, 1, remainingTime.totalMilliseconds());
+#endif
+		/// Decrease timeout in case of retriable error.
+		///
+		/// But do this only if the timeout is positive,
+		/// since negative timeout means an infinite timeout.
+		if (rc < 0 && lastError() == POCO_EINTR && remainingTime > 0)
+		{
+			Poco::Timestamp end;
+			Poco::Timespan waited = end - start;
+			if (waited < remainingTime)
+				remainingTime -= waited;
+			else
+				remainingTime = 0;
+		}
+	}
+	while (rc < 0 && lastError() == POCO_EINTR);
+	if (rc < 0) error();
+	return rc > 0; 
+
+#else
+
+	fd_set fdRead;
+	fd_set fdWrite;
+	fd_set fdExcept;
+	FD_ZERO(&fdRead);
+	FD_ZERO(&fdWrite);
+	FD_ZERO(&fdExcept);
+	if (mode & SELECT_READ)
+	{
+		FD_SET(sockfd, &fdRead);
+	}
+	if (mode & SELECT_WRITE)
+	{
+		FD_SET(sockfd, &fdWrite);
+	}
+	if (mode & SELECT_ERROR)
+	{
+		FD_SET(sockfd, &fdExcept);
+	}
+	int errorCode = POCO_ENOERR;
+	int rc;
+	do
+	{
+		struct timeval tv;
+		tv.tv_sec  = (long) remainingTime.totalSeconds();
+		tv.tv_usec = (long) remainingTime.useconds();
+		Poco::Timestamp start;
+		rc = ::select(int(sockfd) + 1, &fdRead, &fdWrite, &fdExcept, &tv);
+		if (rc < 0 && (errorCode = lastError()) == POCO_EINTR)
+		{
+			Poco::Timestamp end;
+			Poco::Timespan waited = end - start;
+			if (waited < remainingTime)
+				remainingTime -= waited;
+			else
+				remainingTime = 0;
+		}
+	}
+	while (rc < 0 && errorCode == POCO_EINTR);
+	if (rc < 0) error(errorCode);
+	return rc > 0; 
+
+#endif // POCO_HAVE_FD_POLL
+}
+
+bool SocketImpl::poll(const Poco::Timespan& timeout, int mode)
+{
+	Poco::Timespan remainingTime(timeout);
+	return pollImpl(remainingTime, mode);
+}
+	
+void SocketImpl::setSendBufferSize(int size)
+{
+	setOption(SOL_SOCKET, SO_SNDBUF, size);
+}
+
+	
+int SocketImpl::getSendBufferSize()
+{
+	int result;
+	getOption(SOL_SOCKET, SO_SNDBUF, result);
+	return result;
+}
+
+
+void SocketImpl::setReceiveBufferSize(int size)
+{
+	setOption(SOL_SOCKET, SO_RCVBUF, size);
+}
+
+	
+int SocketImpl::getReceiveBufferSize()
+{
+	int result;
+	getOption(SOL_SOCKET, SO_RCVBUF, result);
+	return result;
+}
+
+
+void SocketImpl::setSendTimeout(const Poco::Timespan& timeout)
+{
+#if defined(_WIN32)
+	int value = (int) timeout.totalMilliseconds();
+	setOption(SOL_SOCKET, SO_SNDTIMEO, value);
+#else
+	setOption(SOL_SOCKET, SO_SNDTIMEO, timeout);
+#endif
+	_sndTimeout = timeout;
+}
+
+
+Poco::Timespan SocketImpl::getSendTimeout()
+{
+	Timespan result;
+#if defined(_WIN32) && !defined(POCO_BROKEN_TIMEOUTS)
+	int value;
+	getOption(SOL_SOCKET, SO_SNDTIMEO, value);
+	result = Timespan::TimeDiff(value)*1000;
+#elif !defined(POCO_BROKEN_TIMEOUTS)
+	getOption(SOL_SOCKET, SO_SNDTIMEO, result);
+#endif
+	if (_isBrokenTimeout)
+		result = _sndTimeout;
+	return result;
+}
+
+
+void SocketImpl::setReceiveTimeout(const Poco::Timespan& timeout)
+{
+#if defined(_WIN32)
+	int value = (int) timeout.totalMilliseconds();
+	setOption(SOL_SOCKET, SO_RCVTIMEO, value);
+#else
+	setOption(SOL_SOCKET, SO_RCVTIMEO, timeout);
+#endif
+	_recvTimeout = timeout;
+}
+
+
+Poco::Timespan SocketImpl::getReceiveTimeout()
+{
+	Timespan result;
+#if defined(_WIN32) && !defined(POCO_BROKEN_TIMEOUTS)
+	int value;
+	getOption(SOL_SOCKET, SO_RCVTIMEO, value);
+	result = Timespan::TimeDiff(value)*1000;
+#elif !defined(POCO_BROKEN_TIMEOUTS)
+	getOption(SOL_SOCKET, SO_RCVTIMEO, result);
+#endif
+	if (_isBrokenTimeout)
+		result = _recvTimeout;
+	return result;
+}
+
+	
+SocketAddress SocketImpl::address()
+{
+	if (_sockfd == POCO_INVALID_SOCKET) throw InvalidSocketException();
+
+	sockaddr_storage buffer;
+	struct sockaddr* pSA = reinterpret_cast<struct sockaddr*>(&buffer);
+	poco_socklen_t saLen = sizeof(buffer);
+	int rc = ::getsockname(_sockfd, pSA, &saLen);
+	if (rc == 0)
+		return SocketAddress(pSA, saLen);
+	else 
+		error();
+	return SocketAddress();
+}
+
+
+SocketAddress SocketImpl::peerAddress()
+{
+	if (_sockfd == POCO_INVALID_SOCKET) throw InvalidSocketException();
+
+	sockaddr_storage buffer;
+	struct sockaddr* pSA = reinterpret_cast<struct sockaddr*>(&buffer);
+	poco_socklen_t saLen = sizeof(buffer);
+	int rc = ::getpeername(_sockfd, pSA, &saLen);
+	if (rc == 0)
+		return SocketAddress(pSA, saLen);
+	else
+		error();
+	return SocketAddress();
+}
+
+
+void SocketImpl::setOption(int level, int option, int value)
+{
+	setRawOption(level, option, &value, sizeof(value));
+}
+
+
+void SocketImpl::setOption(int level, int option, unsigned value)
+{
+	setRawOption(level, option, &value, sizeof(value));
+}
+
+
+void SocketImpl::setOption(int level, int option, unsigned char value)
+{
+	setRawOption(level, option, &value, sizeof(value));
+}
+
+
+void SocketImpl::setOption(int level, int option, const IPAddress& value)
+{
+	setRawOption(level, option, value.addr(), value.length());
+}
+
+
+void SocketImpl::setOption(int level, int option, const Poco::Timespan& value)
+{
+	struct timeval tv;
+	tv.tv_sec  = (long) value.totalSeconds();
+	tv.tv_usec = (long) value.useconds();
+
+	setRawOption(level, option, &tv, sizeof(tv));
+}
+
+
+void SocketImpl::setRawOption(int level, int option, const void* value, poco_socklen_t length)
+{
+	if (_sockfd == POCO_INVALID_SOCKET) throw InvalidSocketException();
+
+#if defined(POCO_VXWORKS)
+	int rc = ::setsockopt(_sockfd, level, option, (char*) value, length);
+#else
+	int rc = ::setsockopt(_sockfd, level, option, reinterpret_cast<const char*>(value), length);
+#endif
+	if (rc == -1) error();
+}
+
+
+void SocketImpl::getOption(int level, int option, int& value)
+{
+	poco_socklen_t len = sizeof(value);
+	getRawOption(level, option, &value, len);
+}
+
+
+void SocketImpl::getOption(int level, int option, unsigned& value)
+{
+	poco_socklen_t len = sizeof(value);
+	getRawOption(level, option, &value, len);
+}
+
+
+void SocketImpl::getOption(int level, int option, unsigned char& value)
+{
+	poco_socklen_t len = sizeof(value);
+	getRawOption(level, option, &value, len);
+}
+
+
+void SocketImpl::getOption(int level, int option, Poco::Timespan& value)
+{
+	struct timeval tv;
+	poco_socklen_t len = sizeof(tv);
+	getRawOption(level, option, &tv, len);
+	value.assign(tv.tv_sec, tv.tv_usec);
+}
+
+
+void SocketImpl::getOption(int level, int option, IPAddress& value)
+{
+	char buffer[IPAddress::MAX_ADDRESS_LENGTH];
+	poco_socklen_t len = sizeof(buffer);
+	getRawOption(level, option, buffer, len);
+	value = IPAddress(buffer, len);
+}
+
+
+void SocketImpl::getRawOption(int level, int option, void* value, poco_socklen_t& length)
+{
+	if (_sockfd == POCO_INVALID_SOCKET) throw InvalidSocketException();
+
+	int rc = ::getsockopt(_sockfd, level, option, reinterpret_cast<char*>(value), &length);
+	if (rc == -1) error();
+}
+
+
+void SocketImpl::setLinger(bool on, int seconds)
+{
+	struct linger l;
+	l.l_onoff  = on ? 1 : 0;
+	l.l_linger = seconds;
+	setRawOption(SOL_SOCKET, SO_LINGER, &l, sizeof(l));
+}
+
+
+void SocketImpl::getLinger(bool& on, int& seconds)
+{
+	struct linger l;
+	poco_socklen_t len = sizeof(l);
+	getRawOption(SOL_SOCKET, SO_LINGER, &l, len);
+	on      = l.l_onoff != 0;
+	seconds = l.l_linger;
+}
+
+
+void SocketImpl::setNoDelay(bool flag)
+{
+	int value = flag ? 1 : 0;
+	setOption(IPPROTO_TCP, TCP_NODELAY, value);
+}
+
+
+bool SocketImpl::getNoDelay()
+{
+	int value(0);
+	getOption(IPPROTO_TCP, TCP_NODELAY, value);
+	return value != 0;
+}
+
+
+void SocketImpl::setKeepAlive(bool flag)
+{
+	int value = flag ? 1 : 0;
+	setOption(SOL_SOCKET, SO_KEEPALIVE, value);
+}
+
+
+bool SocketImpl::getKeepAlive()
+{
+	int value(0);
+	getOption(SOL_SOCKET, SO_KEEPALIVE, value);
+	return value != 0;
+}
+
+
+void SocketImpl::setReuseAddress(bool flag)
+{
+	int value = flag ? 1 : 0;
+	setOption(SOL_SOCKET, SO_REUSEADDR, value);
+}
+
+
+bool SocketImpl::getReuseAddress()
+{
+	int value(0);
+	getOption(SOL_SOCKET, SO_REUSEADDR, value);
+	return value != 0;
+}
+
+
+void SocketImpl::setReusePort(bool flag)
+{
+#ifdef SO_REUSEPORT
+	try
+	{
+		int value = flag ? 1 : 0;
+		setOption(SOL_SOCKET, SO_REUSEPORT, value);
+	}
+	catch (IOException&)
+	{
+		// ignore error, since not all implementations
+		// support SO_REUSEPORT, even if the macro
+		// is defined.
+	}
+#endif
+}
+
+
+bool SocketImpl::getReusePort()
+{
+#ifdef SO_REUSEPORT
+	int value(0);
+	getOption(SOL_SOCKET, SO_REUSEPORT, value);
+	return value != 0;
+#else
+	return false;
+#endif
+}
+
+
+void SocketImpl::setOOBInline(bool flag)
+{
+	int value = flag ? 1 : 0;
+	setOption(SOL_SOCKET, SO_OOBINLINE, value);
+}
+
+
+bool SocketImpl::getOOBInline()
+{
+	int value(0);
+	getOption(SOL_SOCKET, SO_OOBINLINE, value);
+	return value != 0;
+}
+
+
+void SocketImpl::setBroadcast(bool flag)
+{
+	int value = flag ? 1 : 0;
+	setOption(SOL_SOCKET, SO_BROADCAST, value);
+}
+
+
+bool SocketImpl::getBroadcast()
+{
+	int value(0);
+	getOption(SOL_SOCKET, SO_BROADCAST, value);
+	return value != 0;
+}
+
+
+void SocketImpl::setBlocking(bool flag)
+{
+#if !defined(POCO_OS_FAMILY_UNIX)
+	int arg = flag ? 0 : 1;
+	ioctl(FIONBIO, arg);
+#else
+	int arg = fcntl(F_GETFL);
+	long flags = arg & ~O_NONBLOCK;
+	if (!flag) flags |= O_NONBLOCK;
+	(void) fcntl(F_SETFL, flags);
+#endif
+	_blocking = flag;
+}
+
+
+int SocketImpl::socketError()
+{
+	int result(0);
+	getOption(SOL_SOCKET, SO_ERROR, result);
+	return result;
+}
+
+
+void SocketImpl::init(int af)
+{
+#ifdef SOCK_CLOEXEC
+	initSocket(af, SOCK_STREAM|SOCK_CLOEXEC);
+#else
+	initSocket(af, SOCK_STREAM);
+#endif
+}
+
+
+void SocketImpl::initSocket(int af, int type, int proto)
+{
+	poco_assert (_sockfd == POCO_INVALID_SOCKET);
+
+	_sockfd = ::socket(af, type, proto);
+	if (_sockfd == POCO_INVALID_SOCKET)
+		error();
+
+#if defined(__MACH__) && defined(__APPLE__) || defined(__FreeBSD__)
+	// SIGPIPE sends a signal that if unhandled (which is the default)
+	// will crash the process. This only happens on UNIX, and not Linux.
+	//
+	// In order to have POCO sockets behave the same across platforms, it is
+	// best to just ignore SIGPIPE altogether.
+	setOption(SOL_SOCKET, SO_NOSIGPIPE, 1);
+#endif
+}
+
+
+void SocketImpl::ioctl(poco_ioctl_request_t request, int& arg)
+{
+#if defined(_WIN32)
+	int rc = ioctlsocket(_sockfd, request, reinterpret_cast<u_long*>(&arg));
+#elif defined(POCO_VXWORKS)
+	int rc = ::ioctl(_sockfd, request, (int) &arg);
+#else
+	int rc = ::ioctl(_sockfd, request, &arg);
+#endif
+	if (rc != 0) error();
+}
+
+
+void SocketImpl::ioctl(poco_ioctl_request_t request, void* arg)
+{
+#if defined(_WIN32)
+	int rc = ioctlsocket(_sockfd, request, reinterpret_cast<u_long*>(arg));
+#elif defined(POCO_VXWORKS)
+	int rc = ::ioctl(_sockfd, request, (int) arg);
+#else
+	int rc = ::ioctl(_sockfd, request, arg);
+#endif
+	if (rc != 0) error();
+}
+
+
+#if defined(POCO_OS_FAMILY_UNIX)
+int SocketImpl::fcntl(poco_fcntl_request_t request)
+{
+	int rc = ::fcntl(_sockfd, request);
+	if (rc == -1) error();
+	return rc;
+}
+
+
+int SocketImpl::fcntl(poco_fcntl_request_t request, long arg)
+{
+	int rc = ::fcntl(_sockfd, request, arg);
+	if (rc == -1) error();
+	return rc;
+}
+#endif
+
+
+void SocketImpl::reset(poco_socket_t aSocket)
+{
+	_sockfd = aSocket;
+}
+
+
+void SocketImpl::error()
+{
+	int err = lastError();
+	std::string empty;
+	error(err, empty);
+}
+
+
+void SocketImpl::error(const std::string& arg)
+{
+	error(lastError(), arg);
+}
+
+
+void SocketImpl::error(int code)
+{
+	std::string arg;
+	error(code, arg);
+}
+
+
+void SocketImpl::error(int code, const std::string& arg)
+{
+	switch (code)
+	{
+	case POCO_ENOERR: return;
+	case POCO_ESYSNOTREADY:
+		throw NetException("Net subsystem not ready", code);
+	case POCO_ENOTINIT:
+		throw NetException("Net subsystem not initialized", code);
+	case POCO_EINTR:
+		throw IOException("Interrupted", code);
+	case POCO_EACCES:
+		throw IOException("Permission denied", code);
+	case POCO_EFAULT:
+		throw IOException("Bad address", code);
+	case POCO_EINVAL:
+		throw InvalidArgumentException(code);
+	case POCO_EMFILE:
+		throw IOException("Too many open files", code);
+	case POCO_EWOULDBLOCK:
+		throw IOException("Operation would block", code);
+	case POCO_EINPROGRESS:
+		throw IOException("Operation now in progress", code);
+	case POCO_EALREADY:
+		throw IOException("Operation already in progress", code);
+	case POCO_ENOTSOCK:
+		throw IOException("Socket operation attempted on non-socket", code);
+	case POCO_EDESTADDRREQ:
+		throw NetException("Destination address required", code);
+	case POCO_EMSGSIZE:
+		throw NetException("Message too long", code);
+	case POCO_EPROTOTYPE:
+		throw NetException("Wrong protocol type", code);
+	case POCO_ENOPROTOOPT:
+		throw NetException("Protocol not available", code);
+	case POCO_EPROTONOSUPPORT:
+		throw NetException("Protocol not supported", code);
+	case POCO_ESOCKTNOSUPPORT:
+		throw NetException("Socket type not supported", code);
+	case POCO_ENOTSUP:
+		throw NetException("Operation not supported", code);
+	case POCO_EPFNOSUPPORT:
+		throw NetException("Protocol family not supported", code);
+	case POCO_EAFNOSUPPORT:
+		throw NetException("Address family not supported", code);
+	case POCO_EADDRINUSE:
+		throw NetException("Address already in use", arg, code);
+	case POCO_EADDRNOTAVAIL:
+		throw NetException("Cannot assign requested address", arg, code);
+	case POCO_ENETDOWN:
+		throw NetException("Network is down", code);
+	case POCO_ENETUNREACH:
+		throw NetException("Network is unreachable", code);
+	case POCO_ENETRESET:
+		throw NetException("Network dropped connection on reset", code);
+	case POCO_ECONNABORTED:
+		throw ConnectionAbortedException(code);
+	case POCO_ECONNRESET:
+		throw ConnectionResetException(code);
+	case POCO_ENOBUFS:
+		throw IOException("No buffer space available", code);
+	case POCO_EISCONN:
+		throw NetException("Socket is already connected", code);
+	case POCO_ENOTCONN:
+		throw NetException("Socket is not connected", code);
+	case POCO_ESHUTDOWN:
+		throw NetException("Cannot send after socket shutdown", code);
+	case POCO_ETIMEDOUT:
+		throw TimeoutException(code);
+	case POCO_ECONNREFUSED:
+		throw ConnectionRefusedException(arg, code);
+	case POCO_EHOSTDOWN:
+		throw NetException("Host is down", arg, code);
+	case POCO_EHOSTUNREACH:
+		throw NetException("No route to host", arg, code);
+#if defined(POCO_OS_FAMILY_UNIX)
+	case EPIPE:
+		throw IOException("Broken pipe", code);
+	case EBADF:
+		throw IOException("Bad socket descriptor", code);
+	case ENOENT:
+		throw IOException("Not found", arg, code);
+#endif
+	default:
+		throw IOException(NumberFormatter::format(code), arg, code);
+	}
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/SocketNotification.cpp b/base/poco/Net/src/SocketNotification.cpp
new file mode 100644
index 00000000000..da3c922da5a
--- /dev/null
+++ b/base/poco/Net/src/SocketNotification.cpp
@@ -0,0 +1,105 @@
+//
+// SocketNotification.cpp
+//
+// Library: Net
+// Package: Reactor
+// Module:  SocketNotification
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SocketNotification.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+SocketNotification::SocketNotification(SocketReactor* pReactor):
+	_pReactor(pReactor)
+{
+}
+
+
+SocketNotification::~SocketNotification()
+{
+}
+
+	
+void SocketNotification::setSocket(const Socket& socket)
+{
+	_socket = socket;
+}
+
+
+ReadableNotification::ReadableNotification(SocketReactor* pReactor): 
+	SocketNotification(pReactor)
+{
+}
+
+
+ReadableNotification::~ReadableNotification()
+{
+}
+
+
+WritableNotification::WritableNotification(SocketReactor* pReactor): 
+	SocketNotification(pReactor)
+{
+}
+
+
+WritableNotification::~WritableNotification()
+{
+}
+
+
+ErrorNotification::ErrorNotification(SocketReactor* pReactor): 
+	SocketNotification(pReactor)
+{
+}
+
+
+ErrorNotification::~ErrorNotification()
+{
+}
+
+
+TimeoutNotification::TimeoutNotification(SocketReactor* pReactor): 
+	SocketNotification(pReactor)
+{
+}
+
+
+TimeoutNotification::~TimeoutNotification()
+{
+}
+
+
+IdleNotification::IdleNotification(SocketReactor* pReactor): 
+	SocketNotification(pReactor)
+{
+}
+
+
+IdleNotification::~IdleNotification()
+{
+}
+
+
+ShutdownNotification::ShutdownNotification(SocketReactor* pReactor): 
+	SocketNotification(pReactor)
+{
+}
+
+
+ShutdownNotification::~ShutdownNotification()
+{
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/SocketNotifier.cpp b/base/poco/Net/src/SocketNotifier.cpp
new file mode 100644
index 00000000000..9bbf6ca8269
--- /dev/null
+++ b/base/poco/Net/src/SocketNotifier.cpp
@@ -0,0 +1,89 @@
+//
+// SocketNotifier.cpp
+//
+// Library: Net
+// Package: Reactor
+// Module:  SocketNotifier
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SocketNotifier.h"
+#include "Poco/Net/SocketReactor.h"
+#include "Poco/Net/SocketNotification.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+SocketNotifier::SocketNotifier(const Socket& socket):
+	_socket(socket)
+{
+}
+
+	
+SocketNotifier::~SocketNotifier()
+{
+}
+
+	
+void SocketNotifier::addObserver(SocketReactor* pReactor, const Poco::AbstractObserver& observer)
+{
+	_nc.addObserver(observer);
+	if (observer.accepts(pReactor->_pReadableNotification))
+		_events.insert(pReactor->_pReadableNotification.get());
+	else if (observer.accepts(pReactor->_pWritableNotification))
+		_events.insert(pReactor->_pWritableNotification.get());
+	else if (observer.accepts(pReactor->_pErrorNotification))
+		_events.insert(pReactor->_pErrorNotification.get());
+	else if (observer.accepts(pReactor->_pTimeoutNotification))
+		_events.insert(pReactor->_pTimeoutNotification.get());
+}
+
+	
+void SocketNotifier::removeObserver(SocketReactor* pReactor, const Poco::AbstractObserver& observer)
+{
+	_nc.removeObserver(observer);
+	EventSet::iterator it = _events.end();
+	if (observer.accepts(pReactor->_pReadableNotification))
+		it = _events.find(pReactor->_pReadableNotification.get());
+	else if (observer.accepts(pReactor->_pWritableNotification))
+		it = _events.find(pReactor->_pWritableNotification.get());
+	else if (observer.accepts(pReactor->_pErrorNotification))
+		it = _events.find(pReactor->_pErrorNotification.get());
+	else if (observer.accepts(pReactor->_pTimeoutNotification))
+		it = _events.find(pReactor->_pTimeoutNotification.get());
+	if (it != _events.end())
+		_events.erase(it);
+}
+
+
+namespace
+{
+	static Socket nullSocket;
+}
+
+
+void SocketNotifier::dispatch(SocketNotification* pNotification)
+{
+	pNotification->setSocket(_socket);
+	pNotification->duplicate();
+	try
+	{
+		_nc.postNotification(pNotification);
+	}
+	catch (...)
+	{
+		pNotification->setSocket(nullSocket);
+		throw;
+	}
+	pNotification->setSocket(nullSocket);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/SocketReactor.cpp b/base/poco/Net/src/SocketReactor.cpp
new file mode 100644
index 00000000000..79150e28422
--- /dev/null
+++ b/base/poco/Net/src/SocketReactor.cpp
@@ -0,0 +1,297 @@
+//
+// SocketReactor.cpp
+//
+// Library: Net
+// Package: Reactor
+// Module:  SocketReactor
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SocketReactor.h"
+#include "Poco/Net/SocketNotification.h"
+#include "Poco/Net/SocketNotifier.h"
+#include "Poco/ErrorHandler.h"
+#include "Poco/Thread.h"
+#include "Poco/Exception.h"
+
+
+using Poco::FastMutex;
+using Poco::Exception;
+using Poco::ErrorHandler;
+
+
+namespace Poco {
+namespace Net {
+
+
+SocketReactor::SocketReactor():
+	_stop(false),
+	_timeout(DEFAULT_TIMEOUT),
+	_pReadableNotification(new ReadableNotification(this)),
+	_pWritableNotification(new WritableNotification(this)),
+	_pErrorNotification(new ErrorNotification(this)),
+	_pTimeoutNotification(new TimeoutNotification(this)),
+	_pIdleNotification(new IdleNotification(this)),
+	_pShutdownNotification(new ShutdownNotification(this)),
+	_pThread(0)
+{
+}
+
+
+SocketReactor::SocketReactor(const Poco::Timespan& timeout):
+	_stop(false),
+	_timeout(timeout),
+	_pReadableNotification(new ReadableNotification(this)),
+	_pWritableNotification(new WritableNotification(this)),
+	_pErrorNotification(new ErrorNotification(this)),
+	_pTimeoutNotification(new TimeoutNotification(this)),
+	_pIdleNotification(new IdleNotification(this)),
+	_pShutdownNotification(new ShutdownNotification(this)),
+	_pThread(0)
+{
+}
+
+
+SocketReactor::~SocketReactor()
+{
+}
+
+
+void SocketReactor::run()
+{
+	_pThread = Thread::current();
+
+	Socket::SocketList readable;
+	Socket::SocketList writable;
+	Socket::SocketList except;
+	
+	while (!_stop)
+	{
+		try
+		{
+			readable.clear();
+			writable.clear();
+			except.clear();
+			int nSockets = 0;
+			{
+				FastMutex::ScopedLock lock(_mutex);
+				for (EventHandlerMap::iterator it = _handlers.begin(); it != _handlers.end(); ++it)
+				{
+					if (it->second->accepts(_pReadableNotification))
+					{
+						readable.push_back(it->first);
+						nSockets++;
+					}
+					if (it->second->accepts(_pWritableNotification))
+					{
+						writable.push_back(it->first);
+						nSockets++;
+					}
+					if (it->second->accepts(_pErrorNotification))
+					{
+						except.push_back(it->first);
+						nSockets++;
+					}
+				}
+			}
+			if (nSockets == 0)
+			{
+				onIdle();
+				Thread::trySleep(static_cast<long>(_timeout.totalMilliseconds()));
+			}
+			else if (Socket::select(readable, writable, except, _timeout))
+			{
+				onBusy();
+
+				for (Socket::SocketList::iterator it = readable.begin(); it != readable.end(); ++it)
+					dispatch(*it, _pReadableNotification);
+				for (Socket::SocketList::iterator it = writable.begin(); it != writable.end(); ++it)
+					dispatch(*it, _pWritableNotification);
+				for (Socket::SocketList::iterator it = except.begin(); it != except.end(); ++it)
+					dispatch(*it, _pErrorNotification);
+			}
+			else onTimeout();
+		}
+		catch (Exception& exc)
+		{
+			ErrorHandler::handle(exc);
+		}
+		catch (std::exception& exc)
+		{
+			ErrorHandler::handle(exc);
+		}
+		catch (...)
+		{
+			ErrorHandler::handle();
+		}
+	}
+	onShutdown();
+}
+
+
+void SocketReactor::stop()
+{
+	_stop = true;
+}
+
+
+void SocketReactor::wakeUp()
+{
+	if (_pThread) _pThread->wakeUp();
+}
+
+
+void SocketReactor::setTimeout(const Poco::Timespan& timeout)
+{
+	_timeout = timeout;
+}
+
+
+const Poco::Timespan& SocketReactor::getTimeout() const
+{
+	return _timeout;
+}
+
+
+void SocketReactor::addEventHandler(const Socket& socket, const Poco::AbstractObserver& observer)
+{
+	NotifierPtr pNotifier;
+	{
+		FastMutex::ScopedLock lock(_mutex);
+		
+		EventHandlerMap::iterator it = _handlers.find(socket);
+		if (it == _handlers.end())
+		{
+			pNotifier = new SocketNotifier(socket);
+			_handlers[socket] = pNotifier;
+		}
+		else pNotifier = it->second;
+	}
+	if (!pNotifier->hasObserver(observer))
+		pNotifier->addObserver(this, observer);
+}
+
+
+bool SocketReactor::hasEventHandler(const Socket& socket, const Poco::AbstractObserver& observer)
+{
+	NotifierPtr pNotifier;
+	{
+		FastMutex::ScopedLock lock(_mutex);
+	
+		EventHandlerMap::iterator it = _handlers.find(socket);
+		if (it != _handlers.end())
+		{
+			if (it->second->hasObserver(observer))
+				return true;
+		}
+	}
+
+	return false;
+}
+
+
+void SocketReactor::removeEventHandler(const Socket& socket, const Poco::AbstractObserver& observer)
+{
+	NotifierPtr pNotifier;
+	{
+		FastMutex::ScopedLock lock(_mutex);
+	
+		EventHandlerMap::iterator it = _handlers.find(socket);
+		if (it != _handlers.end())
+		{
+			pNotifier = it->second;
+			if (pNotifier->hasObserver(observer) && pNotifier->countObservers() == 1)
+			{
+				_handlers.erase(it);
+			}
+		}
+	}
+	if (pNotifier && pNotifier->hasObserver(observer))
+	{
+		pNotifier->removeObserver(this, observer);
+	}
+
+}
+
+
+void SocketReactor::onTimeout()
+{
+	dispatch(_pTimeoutNotification);
+}
+
+
+void SocketReactor::onIdle()
+{
+	dispatch(_pIdleNotification);
+}
+
+
+void SocketReactor::onShutdown()
+{
+	dispatch(_pShutdownNotification);
+}
+
+
+void SocketReactor::onBusy()
+{
+}
+
+
+void SocketReactor::dispatch(const Socket& socket, SocketNotification* pNotification)
+{
+	NotifierPtr pNotifier;
+	{
+		FastMutex::ScopedLock lock(_mutex);
+		EventHandlerMap::iterator it = _handlers.find(socket);
+		if (it != _handlers.end())
+			pNotifier = it->second;
+		else
+			return;
+	}
+	dispatch(pNotifier, pNotification);
+}
+
+
+void SocketReactor::dispatch(SocketNotification* pNotification)
+{
+	std::vector<NotifierPtr> delegates;
+	delegates.reserve(_handlers.size());
+	{
+		FastMutex::ScopedLock lock(_mutex);
+		for (EventHandlerMap::iterator it = _handlers.begin(); it != _handlers.end(); ++it)
+			delegates.push_back(it->second);
+	}
+	for (std::vector<NotifierPtr>::iterator it = delegates.begin(); it != delegates.end(); ++it)
+	{
+		dispatch(*it, pNotification);
+	}
+}
+
+
+void SocketReactor::dispatch(NotifierPtr& pNotifier, SocketNotification* pNotification)
+{
+	try
+	{
+		pNotifier->dispatch(pNotification);
+	}
+	catch (Exception& exc)
+	{
+		ErrorHandler::handle(exc);
+	}
+	catch (std::exception& exc)
+	{
+		ErrorHandler::handle(exc);
+	}
+	catch (...)
+	{
+		ErrorHandler::handle();
+	}
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/SocketStream.cpp b/base/poco/Net/src/SocketStream.cpp
new file mode 100644
index 00000000000..77ae8c2442a
--- /dev/null
+++ b/base/poco/Net/src/SocketStream.cpp
@@ -0,0 +1,156 @@
+//
+// SocketStream.cpp
+//
+// Library: Net
+// Package: Sockets
+// Module:  SocketStream
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SocketStream.h"
+#include "Poco/Net/StreamSocketImpl.h"
+#include "Poco/Exception.h"
+
+
+using Poco::BufferedBidirectionalStreamBuf;
+using Poco::InvalidArgumentException;
+
+
+namespace Poco {
+namespace Net {
+
+
+//
+// SocketStreamBuf
+//
+
+
+SocketStreamBuf::SocketStreamBuf(const Socket& socket): 
+	BufferedBidirectionalStreamBuf(STREAM_BUFFER_SIZE, std::ios::in | std::ios::out),
+	_pImpl(dynamic_cast<StreamSocketImpl*>(socket.impl()))
+{
+	if (_pImpl)
+		_pImpl->duplicate(); 
+	else
+		throw InvalidArgumentException("Invalid or null SocketImpl passed to SocketStreamBuf");
+}
+
+
+SocketStreamBuf::~SocketStreamBuf()
+{
+	_pImpl->release();
+}
+
+
+int SocketStreamBuf::readFromDevice(char* buffer, std::streamsize length)
+{
+	return _pImpl->receiveBytes(buffer, (int) length);
+}
+
+
+int SocketStreamBuf::writeToDevice(const char* buffer, std::streamsize length)
+{
+	return _pImpl->sendBytes(buffer, (int) length);
+}
+
+
+//
+// SocketIOS
+//
+
+
+SocketIOS::SocketIOS(const Socket& socket):
+	_buf(socket)
+{
+	poco_ios_init(&_buf);
+}
+
+
+SocketIOS::~SocketIOS()
+{
+	try
+	{
+		_buf.sync();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+SocketStreamBuf* SocketIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+void SocketIOS::close()
+{
+	_buf.sync();
+	_buf.socketImpl()->close();
+}
+
+
+StreamSocket SocketIOS::socket() const
+{
+	return StreamSocket(_buf.socketImpl());
+}
+
+
+//
+// SocketOutputStream
+//
+
+
+SocketOutputStream::SocketOutputStream(const Socket& socket):
+	SocketIOS(socket),
+	std::ostream(&_buf)
+{
+}
+
+
+SocketOutputStream::~SocketOutputStream()
+{
+}
+
+
+//
+// SocketInputStream
+//
+
+
+SocketInputStream::SocketInputStream(const Socket& socket):
+	SocketIOS(socket),
+	std::istream(&_buf)
+{
+}
+
+
+SocketInputStream::~SocketInputStream()
+{
+}
+
+
+//
+// SocketStream
+//
+
+
+SocketStream::SocketStream(const Socket& socket):
+	SocketIOS(socket),
+	std::iostream(&_buf)
+{
+}
+
+
+SocketStream::~SocketStream()
+{
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/StreamSocket.cpp b/base/poco/Net/src/StreamSocket.cpp
new file mode 100644
index 00000000000..598d2991c69
--- /dev/null
+++ b/base/poco/Net/src/StreamSocket.cpp
@@ -0,0 +1,150 @@
+//
+// StreamSocket.cpp
+//
+// Library: Net
+// Package: Sockets
+// Module:  StreamSocket
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/StreamSocket.h"
+#include "Poco/Net/StreamSocketImpl.h"
+#include "Poco/FIFOBuffer.h"
+#include "Poco/Mutex.h"
+#include "Poco/Exception.h"
+
+
+using Poco::InvalidArgumentException;
+using Poco::Mutex;
+using Poco::ScopedLock;
+
+
+namespace Poco {
+namespace Net {
+
+
+StreamSocket::StreamSocket(): Socket(new StreamSocketImpl)
+{
+}
+
+
+StreamSocket::StreamSocket(const SocketAddress& address): Socket(new StreamSocketImpl(address.family()))
+{
+	connect(address);
+}
+
+
+StreamSocket::StreamSocket(SocketAddress::Family family): Socket(new StreamSocketImpl(family))
+{
+}
+
+
+StreamSocket::StreamSocket(const Socket& socket): Socket(socket)
+{
+	if (!dynamic_cast<StreamSocketImpl*>(impl()))
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+}
+
+
+StreamSocket::StreamSocket(SocketImpl* pImpl): Socket(pImpl)
+{
+	if (!dynamic_cast<StreamSocketImpl*>(impl()))
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+}
+
+
+StreamSocket::~StreamSocket()
+{
+}
+
+
+StreamSocket& StreamSocket::operator = (const Socket& socket)
+{
+	if (dynamic_cast<StreamSocketImpl*>(socket.impl()))
+		Socket::operator = (socket);
+	else
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+	return *this;
+}
+
+
+void StreamSocket::connect(const SocketAddress& address)
+{
+	impl()->connect(address);
+}
+
+
+void StreamSocket::connect(const SocketAddress& address, const Poco::Timespan& timeout)
+{
+	impl()->connect(address, timeout);
+}
+
+
+void StreamSocket::connectNB(const SocketAddress& address)
+{
+	impl()->connectNB(address);
+}
+
+
+void StreamSocket::shutdownReceive()
+{
+	impl()->shutdownReceive();
+}
+
+	
+void StreamSocket::shutdownSend()
+{
+	impl()->shutdownSend();
+}
+
+	
+void StreamSocket::shutdown()
+{
+	impl()->shutdown();
+}
+
+
+int StreamSocket::sendBytes(const void* buffer, int length, int flags)
+{
+	return impl()->sendBytes(buffer, length, flags);
+}
+
+
+int StreamSocket::sendBytes(FIFOBuffer& fifoBuf)
+{
+	ScopedLock<Mutex> l(fifoBuf.mutex());
+
+	int ret = impl()->sendBytes(fifoBuf.begin(), (int) fifoBuf.used());
+	if (ret > 0) fifoBuf.drain(ret);
+	return ret;
+}
+
+
+int StreamSocket::receiveBytes(void* buffer, int length, int flags)
+{
+	return impl()->receiveBytes(buffer, length, flags);
+}
+
+
+int StreamSocket::receiveBytes(FIFOBuffer& fifoBuf)
+{
+	ScopedLock<Mutex> l(fifoBuf.mutex());
+
+	int ret = impl()->receiveBytes(fifoBuf.next(), (int)fifoBuf.available());
+	if (ret > 0) fifoBuf.advance(ret);
+	return ret;
+}
+
+
+void StreamSocket::sendUrgent(unsigned char data)
+{
+	impl()->sendUrgent(data);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/StreamSocketImpl.cpp b/base/poco/Net/src/StreamSocketImpl.cpp
new file mode 100644
index 00000000000..8116942db59
--- /dev/null
+++ b/base/poco/Net/src/StreamSocketImpl.cpp
@@ -0,0 +1,77 @@
+//
+// StreamSocketImpl.cpp
+//
+// Library: Net
+// Package: Sockets
+// Module:  StreamSocketImpl
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/StreamSocketImpl.h"
+#include "Poco/Exception.h"
+#include "Poco/Thread.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+StreamSocketImpl::StreamSocketImpl()
+{
+}
+
+
+StreamSocketImpl::StreamSocketImpl(SocketAddress::Family family)
+{
+	if (family == SocketAddress::IPv4)
+		init(AF_INET);
+#if defined(POCO_HAVE_IPv6)
+	else if (family == SocketAddress::IPv6)
+		init(AF_INET6);
+#endif
+#if defined(POCO_OS_FAMILY_UNIX)
+	else if (family == SocketAddress::UNIX_LOCAL)
+		init(AF_UNIX);
+#endif
+	else throw Poco::InvalidArgumentException("Invalid or unsupported address family passed to StreamSocketImpl");
+}
+
+
+StreamSocketImpl::StreamSocketImpl(poco_socket_t sockfd): SocketImpl(sockfd)
+{
+}
+
+
+StreamSocketImpl::~StreamSocketImpl()
+{
+}
+
+
+int StreamSocketImpl::sendBytes(const void* buffer, int length, int flags)
+{
+	const char* p = reinterpret_cast<const char*>(buffer);
+	int remaining = length;
+	int sent = 0;
+	bool blocking = getBlocking();
+	while (remaining > 0)
+	{
+		int n = SocketImpl::sendBytes(p, remaining, flags);
+		poco_assert_dbg (n >= 0);
+		p += n; 
+		sent += n;
+		remaining -= n;
+		if (blocking && remaining > 0)
+			Poco::Thread::yield();
+		else
+			break;
+	}
+	return sent;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/StringPartSource.cpp b/base/poco/Net/src/StringPartSource.cpp
new file mode 100644
index 00000000000..a512449f69f
--- /dev/null
+++ b/base/poco/Net/src/StringPartSource.cpp
@@ -0,0 +1,67 @@
+//
+// StringPartSource.cpp
+//
+// Library: Net
+// Package: Messages
+// Module:  StringPartSource
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/StringPartSource.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+StringPartSource::StringPartSource(const std::string& str):
+	PartSource("text/plain"),
+	_istr(str)
+{
+}
+
+
+StringPartSource::StringPartSource(const std::string& str, const std::string& mediaType):
+	PartSource(mediaType),
+	_istr(str)
+{
+}
+
+
+StringPartSource::StringPartSource(const std::string& str, const std::string& mediaType, const std::string& filename):
+	PartSource(mediaType),
+	_istr(str),
+	_filename(filename)
+{
+}
+
+
+StringPartSource::~StringPartSource()
+{
+}
+
+
+std::istream& StringPartSource::stream()
+{
+	return _istr;
+}
+
+	
+const std::string& StringPartSource::filename() const
+{
+	return _filename;
+}
+
+
+std::streamsize StringPartSource::getContentLength() const
+{
+	return _istr.str().length();
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/TCPServer.cpp b/base/poco/Net/src/TCPServer.cpp
new file mode 100644
index 00000000000..7a7282f785c
--- /dev/null
+++ b/base/poco/Net/src/TCPServer.cpp
@@ -0,0 +1,243 @@
+//
+// TCPServer.cpp
+//
+// Library: Net
+// Package: TCPServer
+// Module:  TCPServer
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/TCPServer.h"
+#include "Poco/Net/TCPServerDispatcher.h"
+#include "Poco/Net/TCPServerConnection.h"
+#include "Poco/Net/TCPServerConnectionFactory.h"
+#include "Poco/Timespan.h"
+#include "Poco/Exception.h"
+#include "Poco/ErrorHandler.h"
+
+
+using Poco::ErrorHandler;
+
+
+namespace Poco {
+namespace Net {
+
+
+//
+// TCPServerConnectionFilter
+//
+
+
+TCPServerConnectionFilter::~TCPServerConnectionFilter()
+{
+}
+
+
+//
+// TCPServer
+//
+
+
+TCPServer::TCPServer(TCPServerConnectionFactory::Ptr pFactory, Poco::UInt16 portNumber, TCPServerParams::Ptr pParams):
+	_socket(ServerSocket(portNumber)),
+	_thread(threadName(_socket)),
+	_stopped(true)
+{	
+	Poco::ThreadPool& pool = Poco::ThreadPool::defaultPool();
+	if (pParams)
+	{
+		int toAdd = pParams->getMaxThreads() - pool.capacity();
+		if (toAdd > 0) pool.addCapacity(toAdd);
+	}
+	_pDispatcher = new TCPServerDispatcher(pFactory, pool, pParams);
+	
+}
+
+
+TCPServer::TCPServer(TCPServerConnectionFactory::Ptr pFactory, const ServerSocket& socket, TCPServerParams::Ptr pParams):
+	_socket(socket),
+	_thread(threadName(socket)),
+	_stopped(true)
+{
+	Poco::ThreadPool& pool = Poco::ThreadPool::defaultPool();
+	if (pParams)
+	{
+		int toAdd = pParams->getMaxThreads() - pool.capacity();
+		if (toAdd > 0) pool.addCapacity(toAdd);
+	}
+	_pDispatcher = new TCPServerDispatcher(pFactory, pool, pParams);
+}
+
+
+TCPServer::TCPServer(TCPServerConnectionFactory::Ptr pFactory, Poco::ThreadPool& threadPool, const ServerSocket& socket, TCPServerParams::Ptr pParams):
+	_socket(socket),
+	_pDispatcher(new TCPServerDispatcher(pFactory, threadPool, pParams)),
+	_thread(threadName(socket)),
+	_stopped(true)
+{
+}
+
+
+TCPServer::~TCPServer()
+{
+	try
+	{
+		stop();
+		_pDispatcher->release();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+const TCPServerParams& TCPServer::params() const
+{
+	return _pDispatcher->params();
+}
+
+
+void TCPServer::start()
+{
+	poco_assert (_stopped);
+
+	_stopped = false;
+	_thread.start(*this);
+}
+
+	
+void TCPServer::stop()
+{
+	if (!_stopped)
+	{
+		_stopped = true;
+		_thread.join();
+		_pDispatcher->stop();
+	}
+}
+
+
+void TCPServer::run()
+{
+	while (!_stopped)
+	{
+		Poco::Timespan timeout(250000);
+		try
+		{
+			if (_socket.poll(timeout, Socket::SELECT_READ))
+			{
+				try
+				{
+					StreamSocket ss = _socket.acceptConnection();
+					
+					if (!_pConnectionFilter || _pConnectionFilter->accept(ss))
+					{
+						// enable nodelay per default: OSX really needs that
+#if defined(POCO_OS_FAMILY_UNIX)
+						if (ss.address().family() != AddressFamily::UNIX_LOCAL)
+#endif
+						{
+							ss.setNoDelay(true);
+						}
+						_pDispatcher->enqueue(ss);
+					}
+				}
+				catch (Poco::Exception& exc)
+				{
+					ErrorHandler::handle(exc);
+				}
+				catch (std::exception& exc)
+				{
+					ErrorHandler::handle(exc);
+				}
+				catch (...)
+				{
+					ErrorHandler::handle();
+				}
+			}
+		}
+		catch (Poco::Exception& exc)
+		{
+			ErrorHandler::handle(exc);
+			// possibly a resource issue since poll() failed;
+			// give some time to recover before trying again
+			Poco::Thread::sleep(50); 
+		}
+	}
+}
+
+
+int TCPServer::currentThreads() const
+{
+	return _pDispatcher->currentThreads();
+}
+
+
+int TCPServer::maxThreads() const
+{
+	return _pDispatcher->maxThreads();
+}
+
+	
+int TCPServer::totalConnections() const
+{
+	return _pDispatcher->totalConnections();
+}
+
+
+int TCPServer::currentConnections() const
+{
+	return _pDispatcher->currentConnections();
+}
+
+
+int TCPServer::maxConcurrentConnections() const
+{
+	return _pDispatcher->maxConcurrentConnections();
+}
+
+	
+int TCPServer::queuedConnections() const
+{
+	return _pDispatcher->queuedConnections();
+}
+
+
+int TCPServer::refusedConnections() const
+{
+	return _pDispatcher->refusedConnections();
+}
+
+
+void TCPServer::setConnectionFilter(const TCPServerConnectionFilter::Ptr& pConnectionFilter)
+{
+	poco_assert (_stopped);
+
+	_pConnectionFilter = pConnectionFilter;
+}
+
+
+std::string TCPServer::threadName(const ServerSocket& socket)
+{
+#if _WIN32_WCE == 0x0800
+	// Workaround for WEC2013: only the first call to getsockname()
+	// succeeds. To mitigate the impact of this bug, do not call
+	// socket.address(), which calls getsockname(), here.
+	std::string name("TCPServer");
+	#pragma message("Using WEC2013 getsockname() workaround in TCPServer::threadName(). Remove when no longer needed.")
+#else
+	std::string name("TCPServer: ");
+	name.append(socket.address().toString());
+#endif
+	return name;
+
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/TCPServerConnection.cpp b/base/poco/Net/src/TCPServerConnection.cpp
new file mode 100644
index 00000000000..1072b182c23
--- /dev/null
+++ b/base/poco/Net/src/TCPServerConnection.cpp
@@ -0,0 +1,60 @@
+//
+// TCPServerConnection.cpp
+//
+// Library: Net
+// Package: TCPServer
+// Module:  TCPServerConnection
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/TCPServerConnection.h"
+#include "Poco/Exception.h"
+#include "Poco/ErrorHandler.h"
+
+
+using Poco::Exception;
+using Poco::ErrorHandler;
+
+
+namespace Poco {
+namespace Net {
+
+
+TCPServerConnection::TCPServerConnection(const StreamSocket& socket):
+	_socket(socket)
+{
+}
+
+
+TCPServerConnection::~TCPServerConnection()
+{
+}
+
+
+void TCPServerConnection::start()
+{
+	try
+	{
+		run();
+	}
+	catch (Exception& exc)
+	{
+		ErrorHandler::handle(exc);
+	}
+	catch (std::exception& exc)
+	{
+		ErrorHandler::handle(exc);
+	}
+	catch (...)
+	{
+		ErrorHandler::handle();
+	}
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/TCPServerConnectionFactory.cpp b/base/poco/Net/src/TCPServerConnectionFactory.cpp
new file mode 100644
index 00000000000..a861e433d97
--- /dev/null
+++ b/base/poco/Net/src/TCPServerConnectionFactory.cpp
@@ -0,0 +1,32 @@
+//
+// TCPServerConnectionFactory.cpp
+//
+// Library: Net
+// Package: TCPServer
+// Module:  TCPServerConnectionFactory
+//
+// Copyright (c) 2005-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/TCPServerConnectionFactory.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+TCPServerConnectionFactory::TCPServerConnectionFactory()
+{
+}
+
+
+TCPServerConnectionFactory::~TCPServerConnectionFactory()
+{
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/TCPServerDispatcher.cpp b/base/poco/Net/src/TCPServerDispatcher.cpp
new file mode 100644
index 00000000000..20a1ffe1b4f
--- /dev/null
+++ b/base/poco/Net/src/TCPServerDispatcher.cpp
@@ -0,0 +1,240 @@
+//
+// TCPServerDispatcher.cpp
+//
+// Library: Net
+// Package: TCPServer
+// Module:  TCPServerDispatcher
+//
+// Copyright (c) 2005-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/TCPServerDispatcher.h"
+#include "Poco/Net/TCPServerConnectionFactory.h"
+#include "Poco/Notification.h"
+#include "Poco/AutoPtr.h"
+#include "Poco/ErrorHandler.h"
+#include <memory>
+#include <iostream>
+
+
+using Poco::Notification;
+using Poco::FastMutex;
+using Poco::AutoPtr;
+
+
+namespace Poco {
+namespace Net {
+
+
+class TCPConnectionNotification: public Notification
+{
+public:
+	TCPConnectionNotification(const StreamSocket& socket):
+		_socket(socket)
+	{
+	}
+	
+	~TCPConnectionNotification()
+	{
+	}
+	
+	const StreamSocket& socket() const
+	{
+		return _socket;
+	}
+
+private:
+	StreamSocket _socket;
+};
+
+
+TCPServerDispatcher::TCPServerDispatcher(TCPServerConnectionFactory::Ptr pFactory, Poco::ThreadPool& threadPool, TCPServerParams::Ptr pParams):
+	_rc(1),
+	_pParams(pParams),
+	_currentThreads(0),
+	_totalConnections(0),
+	_currentConnections(0),
+	_maxConcurrentConnections(0),
+	_refusedConnections(0),
+	_stopped(false),
+	_pConnectionFactory(pFactory),
+	_threadPool(threadPool)
+{
+	poco_check_ptr (pFactory);
+
+	if (!_pParams)
+		_pParams = new TCPServerParams;
+	
+	if (_pParams->getMaxThreads() == 0)
+		_pParams->setMaxThreads(threadPool.capacity());
+}
+
+
+TCPServerDispatcher::~TCPServerDispatcher()
+{
+}
+
+
+void TCPServerDispatcher::duplicate()
+{
+	++_rc;
+}
+
+
+void TCPServerDispatcher::release()
+{
+	if (--_rc == 0) delete this;
+}
+
+
+void TCPServerDispatcher::run()
+{
+	AutoPtr<TCPServerDispatcher> guard(this, true); // ensure object stays alive
+
+	int idleTime = (int) _pParams->getThreadIdleTime().totalMilliseconds();
+
+	for (;;)
+	{
+		try
+		{
+			AutoPtr<Notification> pNf = _queue.waitDequeueNotification(idleTime);
+			if (pNf && !_stopped)
+			{
+				TCPConnectionNotification* pCNf = dynamic_cast<TCPConnectionNotification*>(pNf.get());
+				if (pCNf)
+				{
+					beginConnection();
+					if (!_stopped)
+					{
+						std::unique_ptr<TCPServerConnection> pConnection(_pConnectionFactory->createConnection(pCNf->socket()));
+						poco_check_ptr(pConnection.get());
+						pConnection->start();
+					}
+					/// endConnection() should be called after destroying TCPServerConnection,
+					/// otherwise currentConnections() could become zero while some connections are yet still alive.
+					endConnection();
+				}
+			}
+		}
+		catch (Poco::Exception &exc) { ErrorHandler::handle(exc); }
+		catch (std::exception &exc)  { ErrorHandler::handle(exc); }
+		catch (...)                  { ErrorHandler::handle();    }
+		FastMutex::ScopedLock lock(_mutex);
+		if (_stopped || (_currentThreads > 1 && _queue.empty()))
+		{
+			--_currentThreads;
+			break;
+		}
+	}
+}
+
+
+namespace
+{
+	static const std::string threadName("TCPServerConnection");
+}
+
+	
+void TCPServerDispatcher::enqueue(const StreamSocket& socket)
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	if (_queue.size() < _pParams->getMaxQueued())
+	{
+		if (!_queue.hasIdleThreads() && _currentThreads < _pParams->getMaxThreads())
+		{
+			try
+			{
+				_threadPool.startWithPriority(_pParams->getThreadPriority(), *this, threadName);
+				++_currentThreads;
+			}
+			catch (Poco::Exception& exc)
+			{
+				++_refusedConnections;
+				std::cerr << "Got exception while starting thread for connection. Error code: "
+						  << exc.code() << ", message: '" << exc.displayText() << "'" << std::endl;
+				return;
+			}
+		}
+		_queue.enqueueNotification(new TCPConnectionNotification(socket));
+	}
+	else
+	{
+		++_refusedConnections;
+	}
+}
+
+
+void TCPServerDispatcher::stop()
+{
+	_stopped = true;
+	_queue.clear();
+	_queue.wakeUpAll();
+}
+
+
+int TCPServerDispatcher::currentThreads() const
+{
+	return _currentThreads;
+}
+
+int TCPServerDispatcher::maxThreads() const
+{
+	FastMutex::ScopedLock lock(_mutex);
+	
+	return _threadPool.capacity();
+}
+
+
+int TCPServerDispatcher::totalConnections() const
+{
+	return _totalConnections;
+}
+
+
+int TCPServerDispatcher::currentConnections() const
+{
+	return _currentConnections;
+}
+
+
+int TCPServerDispatcher::maxConcurrentConnections() const
+{
+	return _maxConcurrentConnections;
+}
+
+
+int TCPServerDispatcher::queuedConnections() const
+{
+	return _queue.size();
+}
+
+
+int TCPServerDispatcher::refusedConnections() const
+{
+	return _refusedConnections;
+}
+
+
+void TCPServerDispatcher::beginConnection()
+{
+	FastMutex::ScopedLock lock(_mutex);
+
+	++_totalConnections;
+	++_currentConnections;
+	if (_currentConnections > _maxConcurrentConnections)
+		_maxConcurrentConnections.store(_currentConnections);
+}
+
+
+void TCPServerDispatcher::endConnection()
+{
+	--_currentConnections;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/TCPServerParams.cpp b/base/poco/Net/src/TCPServerParams.cpp
new file mode 100644
index 00000000000..6a90374abc5
--- /dev/null
+++ b/base/poco/Net/src/TCPServerParams.cpp
@@ -0,0 +1,64 @@
+//
+// TCPServerParams.cpp
+//
+// Library: Net
+// Package: TCPServer
+// Module:  TCPServerParams
+//
+// Copyright (c) 2005-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/TCPServerParams.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+TCPServerParams::TCPServerParams():
+	_threadIdleTime(10000000),
+	_maxThreads(0),
+	_maxQueued(64),
+	_threadPriority(Poco::Thread::PRIO_NORMAL)
+{
+}
+
+
+TCPServerParams::~TCPServerParams()
+{
+}
+
+
+void TCPServerParams::setThreadIdleTime(const Poco::Timespan& milliseconds)
+{
+	_threadIdleTime = milliseconds;
+}
+
+
+void TCPServerParams::setMaxThreads(int count)
+{
+	poco_assert (count > 0);
+
+	_maxThreads = count;
+}
+
+
+void TCPServerParams::setMaxQueued(int count)
+{
+	poco_assert (count >= 0);
+
+	_maxQueued = count;
+}
+
+
+void TCPServerParams::setThreadPriority(Poco::Thread::Priority prio)
+{
+	_threadPriority = prio;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/WebSocket.cpp b/base/poco/Net/src/WebSocket.cpp
new file mode 100644
index 00000000000..17816ad00af
--- /dev/null
+++ b/base/poco/Net/src/WebSocket.cpp
@@ -0,0 +1,263 @@
+//
+// WebSocket.cpp
+//
+// Library: Net
+// Package: WebSocket
+// Module:  WebSocket
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/WebSocket.h"
+#include "Poco/Net/WebSocketImpl.h"
+#include "Poco/Net/HTTPServerRequestImpl.h"
+#include "Poco/Net/HTTPServerResponse.h"
+#include "Poco/Net/HTTPClientSession.h"
+#include "Poco/Net/HTTPServerSession.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/MemoryStream.h"
+#include "Poco/NullStream.h"
+#include "Poco/BinaryWriter.h"
+#include "Poco/SHA1Engine.h"
+#include "Poco/Base64Encoder.h"
+#include "Poco/String.h"
+#include "Poco/Random.h"
+#include "Poco/StreamCopier.h"
+#include <sstream>
+
+
+namespace Poco {
+namespace Net {
+
+
+const std::string WebSocket::WEBSOCKET_GUID("258EAFA5-E914-47DA-95CA-C5AB0DC85B11");
+const std::string WebSocket::WEBSOCKET_VERSION("13");
+HTTPCredentials WebSocket::_defaultCreds;
+
+
+WebSocket::WebSocket(HTTPServerRequest& request, HTTPServerResponse& response):
+	StreamSocket(accept(request, response))
+{
+}
+
+
+WebSocket::WebSocket(HTTPClientSession& cs, HTTPRequest& request, HTTPResponse& response):
+	StreamSocket(connect(cs, request, response, _defaultCreds))
+{
+}
+
+
+WebSocket::WebSocket(HTTPClientSession& cs, HTTPRequest& request, HTTPResponse& response, HTTPCredentials& credentials):
+	StreamSocket(connect(cs, request, response, credentials))
+{
+}
+
+
+WebSocket::WebSocket(const Socket& socket):
+	StreamSocket(socket)
+{
+	if (!dynamic_cast<WebSocketImpl*>(impl()))
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+}
+
+
+WebSocket::~WebSocket()
+{
+}
+
+
+WebSocket& WebSocket::operator = (const Socket& socket)
+{
+	if (dynamic_cast<WebSocketImpl*>(socket.impl()))
+		Socket::operator = (socket);
+	else
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+	return *this;
+}
+
+
+void WebSocket::shutdown()
+{
+	shutdown(WS_NORMAL_CLOSE);
+}
+
+
+void WebSocket::shutdown(Poco::UInt16 statusCode, const std::string& statusMessage)
+{
+	Poco::Buffer<char> buffer(statusMessage.size() + 2);
+	Poco::MemoryOutputStream ostr(buffer.begin(), buffer.size());
+	Poco::BinaryWriter writer(ostr, Poco::BinaryWriter::NETWORK_BYTE_ORDER);
+	writer << statusCode;
+	writer.writeRaw(statusMessage);
+	sendFrame(buffer.begin(), static_cast<int>(ostr.charsWritten()), FRAME_FLAG_FIN | FRAME_OP_CLOSE);
+}
+
+
+int WebSocket::sendFrame(const void* buffer, int length, int flags)
+{
+	flags |= FRAME_OP_SETRAW;
+	return static_cast<WebSocketImpl*>(impl())->sendBytes(buffer, length, flags);
+}
+
+
+int WebSocket::receiveFrame(void* buffer, int length, int& flags)
+{
+	int n = static_cast<WebSocketImpl*>(impl())->receiveBytes(buffer, length, 0);
+	flags = static_cast<WebSocketImpl*>(impl())->frameFlags();
+	return n;
+}
+
+
+int WebSocket::receiveFrame(Poco::Buffer<char>& buffer, int& flags)
+{
+	int n = static_cast<WebSocketImpl*>(impl())->receiveBytes(buffer, 0);
+	flags = static_cast<WebSocketImpl*>(impl())->frameFlags();
+	return n;
+}
+
+
+WebSocket::Mode WebSocket::mode() const
+{
+	return static_cast<WebSocketImpl*>(impl())->mustMaskPayload() ? WS_CLIENT : WS_SERVER;
+}
+
+
+void WebSocket::setMaxPayloadSize(int maxPayloadSize)
+{
+	static_cast<WebSocketImpl*>(impl())->setMaxPayloadSize(maxPayloadSize);
+}
+
+
+int WebSocket::getMaxPayloadSize() const
+{
+	return static_cast<WebSocketImpl*>(impl())->getMaxPayloadSize();
+}
+
+
+WebSocketImpl* WebSocket::accept(HTTPServerRequest& request, HTTPServerResponse& response)
+{
+	if (request.hasToken("Connection", "upgrade") && icompare(request.get("Upgrade", ""), "websocket") == 0)
+	{
+		std::string version = request.get("Sec-WebSocket-Version", "");
+		if (version.empty()) throw WebSocketException("Missing Sec-WebSocket-Version in handshake request", WS_ERR_HANDSHAKE_NO_VERSION);
+		if (version != WEBSOCKET_VERSION) throw WebSocketException("Unsupported WebSocket version requested", version, WS_ERR_HANDSHAKE_UNSUPPORTED_VERSION);
+		std::string key = request.get("Sec-WebSocket-Key", "");
+		Poco::trimInPlace(key);
+		if (key.empty()) throw WebSocketException("Missing Sec-WebSocket-Key in handshake request", WS_ERR_HANDSHAKE_NO_KEY);
+
+		response.setStatusAndReason(HTTPResponse::HTTP_SWITCHING_PROTOCOLS);
+		response.set("Upgrade", "websocket");
+		response.set("Connection", "Upgrade");
+		response.set("Sec-WebSocket-Accept", computeAccept(key));
+		response.setContentLength(HTTPResponse::UNKNOWN_CONTENT_LENGTH);
+		response.send().flush();
+
+		HTTPServerRequestImpl& requestImpl = static_cast<HTTPServerRequestImpl&>(request);
+		return new WebSocketImpl(static_cast<StreamSocketImpl*>(requestImpl.detachSocket().impl()), requestImpl.session(), false);
+	}
+	else throw WebSocketException("No WebSocket handshake", WS_ERR_NO_HANDSHAKE);
+}
+
+
+WebSocketImpl* WebSocket::connect(HTTPClientSession& cs, HTTPRequest& request, HTTPResponse& response, HTTPCredentials& credentials)
+{
+	if (!cs.getProxyHost().empty() && !cs.secure())
+	{
+		cs.proxyTunnel();
+	}
+	std::string key = createKey();
+	request.set("Connection", "Upgrade");
+	request.set("Upgrade", "websocket");
+	request.set("Sec-WebSocket-Version", WEBSOCKET_VERSION);
+	request.set("Sec-WebSocket-Key", key);
+	request.setChunkedTransferEncoding(false);
+	cs.setKeepAlive(true);
+	cs.sendRequest(request);
+	std::istream& istr = cs.receiveResponse(response);
+	if (response.getStatus() == HTTPResponse::HTTP_SWITCHING_PROTOCOLS)
+	{
+		return completeHandshake(cs, response, key);
+	}
+	else if (response.getStatus() == HTTPResponse::HTTP_UNAUTHORIZED)
+	{
+		if (!credentials.empty())
+		{
+			Poco::NullOutputStream null;
+			Poco::StreamCopier::copyStream(istr, null);
+			credentials.authenticate(request, response);
+			if (!cs.getProxyHost().empty() && !cs.secure())
+			{
+				cs.reset();
+				cs.proxyTunnel();
+			}
+			cs.sendRequest(request);
+			cs.receiveResponse(response);
+			if (response.getStatus() == HTTPResponse::HTTP_SWITCHING_PROTOCOLS)
+			{
+				return completeHandshake(cs, response, key);
+			}
+			else if (response.getStatus() == HTTPResponse::HTTP_UNAUTHORIZED)
+			{
+				throw WebSocketException("Not authorized", WS_ERR_UNAUTHORIZED);
+			}
+		}
+		else throw WebSocketException("Not authorized", WS_ERR_UNAUTHORIZED);
+	}
+	if (response.getStatus() == HTTPResponse::HTTP_OK)
+	{
+		throw WebSocketException("The server does not understand the WebSocket protocol", WS_ERR_NO_HANDSHAKE);
+	}
+	else
+	{
+		throw WebSocketException("Cannot upgrade to WebSocket connection", response.getReason(), WS_ERR_NO_HANDSHAKE);
+	}
+}
+
+
+WebSocketImpl* WebSocket::completeHandshake(HTTPClientSession& cs, HTTPResponse& response, const std::string& key)
+{
+	std::string connection = response.get("Connection", "");
+	if (Poco::icompare(connection, "Upgrade") != 0)
+		throw WebSocketException("No Connection: Upgrade header in handshake response", WS_ERR_NO_HANDSHAKE);
+	std::string upgrade = response.get("Upgrade", "");
+	if (Poco::icompare(upgrade, "websocket") != 0)
+		throw WebSocketException("No Upgrade: websocket header in handshake response", WS_ERR_NO_HANDSHAKE);
+	std::string accept = response.get("Sec-WebSocket-Accept", "");
+	if (accept != computeAccept(key))
+		throw WebSocketException("Invalid or missing Sec-WebSocket-Accept header in handshake response", WS_ERR_HANDSHAKE_ACCEPT);
+	return new WebSocketImpl(static_cast<StreamSocketImpl*>(cs.detachSocket().impl()), cs, true);
+}
+
+
+std::string WebSocket::createKey()
+{
+	Poco::Random rnd;
+	std::ostringstream ostr;
+	Poco::Base64Encoder base64(ostr);
+	Poco::BinaryWriter writer(base64);
+	writer << rnd.next() << rnd.next() << rnd.next() << rnd.next();
+	base64.close();
+	return ostr.str();
+}
+
+
+std::string WebSocket::computeAccept(const std::string& key)
+{
+	std::string accept(key);
+	accept += WEBSOCKET_GUID;
+	Poco::SHA1Engine sha1;
+	sha1.update(accept);
+	Poco::DigestEngine::Digest d = sha1.digest();
+	std::ostringstream ostr;
+	Poco::Base64Encoder base64(ostr);
+	base64.write(reinterpret_cast<const char*>(&d[0]), d.size());
+	base64.close();
+	return ostr.str();
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/Net/src/WebSocketImpl.cpp b/base/poco/Net/src/WebSocketImpl.cpp
new file mode 100644
index 00000000000..7c97fa7b00b
--- /dev/null
+++ b/base/poco/Net/src/WebSocketImpl.cpp
@@ -0,0 +1,400 @@
+//
+// WebSocketImpl.cpp
+//
+// Library: Net
+// Package: WebSocket
+// Module:  WebSocketImpl
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#define NOMINMAX
+#include "Poco/Net/WebSocketImpl.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Net/WebSocket.h"
+#include "Poco/Net/HTTPSession.h"
+#include "Poco/Buffer.h"
+#include "Poco/BinaryWriter.h"
+#include "Poco/BinaryReader.h"
+#include "Poco/MemoryStream.h"
+#include "Poco/Format.h"
+#include <limits>
+#include <cstring>
+
+
+namespace Poco {
+namespace Net {
+
+
+WebSocketImpl::WebSocketImpl(StreamSocketImpl* pStreamSocketImpl, HTTPSession& session, bool mustMaskPayload):
+	StreamSocketImpl(pStreamSocketImpl->sockfd()),
+	_pStreamSocketImpl(pStreamSocketImpl),
+	_maxPayloadSize(std::numeric_limits<int>::max()),
+	_buffer(0),
+	_bufferOffset(0),
+	_frameFlags(0),
+	_mustMaskPayload(mustMaskPayload)
+{
+	poco_check_ptr(pStreamSocketImpl);
+	_pStreamSocketImpl->duplicate();
+	session.drainBuffer(_buffer);
+}
+
+
+WebSocketImpl::~WebSocketImpl()
+{
+	try
+	{
+		_pStreamSocketImpl->release();
+		reset();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+int WebSocketImpl::sendBytes(const void* buffer, int length, int flags)
+{
+	Poco::Buffer<char> frame(length + MAX_HEADER_LENGTH);
+	Poco::MemoryOutputStream ostr(frame.begin(), frame.size());
+	Poco::BinaryWriter writer(ostr, Poco::BinaryWriter::NETWORK_BYTE_ORDER);
+
+	if (flags == 0) flags = WebSocket::FRAME_BINARY;
+	flags &= 0xff;
+	writer << static_cast<Poco::UInt8>(flags);
+	Poco::UInt8 lengthByte(0);
+	if (_mustMaskPayload)
+	{
+		lengthByte |= FRAME_FLAG_MASK;
+	}
+	if (length < 126)
+	{
+		lengthByte |= static_cast<Poco::UInt8>(length);
+		writer << lengthByte;
+	}
+	else if (length < 65536)
+	{
+		lengthByte |= 126;
+		writer << lengthByte << static_cast<Poco::UInt16>(length);
+	}
+	else
+	{
+		lengthByte |= 127;
+		writer << lengthByte << static_cast<Poco::UInt64>(length);
+	}
+	if (_mustMaskPayload)
+	{
+		const Poco::UInt32 mask = _rnd.next();
+		const char* m = reinterpret_cast<const char*>(&mask);
+		const char* b = reinterpret_cast<const char*>(buffer);
+		writer.writeRaw(m, 4);
+		char* p = frame.begin() + ostr.charsWritten();
+		for (int i = 0; i < length; i++)
+		{
+			p[i] = b[i] ^ m[i % 4];
+		}
+	}
+	else
+	{
+		std::memcpy(frame.begin() + ostr.charsWritten(), buffer, length);
+	}
+	_pStreamSocketImpl->sendBytes(frame.begin(), length + static_cast<int>(ostr.charsWritten()));
+	return length;
+}
+
+
+int WebSocketImpl::receiveHeader(char mask[4], bool& useMask)
+{
+	char header[MAX_HEADER_LENGTH];
+	int n = receiveNBytes(header, 2);
+	if (n <= 0)
+	{
+		_frameFlags = 0;
+		return n;
+	}
+	poco_assert (n == 2);
+	Poco::UInt8 flags = static_cast<Poco::UInt8>(header[0]);
+	_frameFlags = flags;
+	Poco::UInt8 lengthByte = static_cast<Poco::UInt8>(header[1]);
+	useMask = ((lengthByte & FRAME_FLAG_MASK) != 0);
+	int payloadLength;
+	lengthByte &= 0x7f;
+	if (lengthByte == 127)
+	{
+		n = receiveNBytes(header + 2, 8);
+		if (n <= 0)
+		{
+			_frameFlags = 0;
+			return n;
+		}
+		Poco::MemoryInputStream istr(header + 2, 8);
+		Poco::BinaryReader reader(istr, Poco::BinaryReader::NETWORK_BYTE_ORDER);
+		Poco::UInt64 l;
+		reader >> l;
+		if (l > _maxPayloadSize) throw WebSocketException("Payload too big", WebSocket::WS_ERR_PAYLOAD_TOO_BIG);
+		payloadLength = static_cast<int>(l);
+	}
+	else if (lengthByte == 126)
+	{
+		n = receiveNBytes(header + 2, 2);
+		if (n <= 0)
+		{
+			_frameFlags = 0;
+			return n;
+		}
+		Poco::MemoryInputStream istr(header + 2, 2);
+		Poco::BinaryReader reader(istr, Poco::BinaryReader::NETWORK_BYTE_ORDER);
+		Poco::UInt16 l;
+		reader >> l;
+		if (l > _maxPayloadSize) throw WebSocketException("Payload too big", WebSocket::WS_ERR_PAYLOAD_TOO_BIG);
+		payloadLength = static_cast<int>(l);
+	}
+	else
+	{
+		if (lengthByte > _maxPayloadSize) throw WebSocketException("Payload too big", WebSocket::WS_ERR_PAYLOAD_TOO_BIG);
+		payloadLength = lengthByte;
+	}
+
+	if (useMask)
+	{
+		n = receiveNBytes(mask, 4);
+		if (n <= 0)
+		{
+			_frameFlags = 0;
+			return n;
+		}
+	}
+
+	return payloadLength;
+}
+
+
+void WebSocketImpl::setMaxPayloadSize(int maxPayloadSize)
+{
+	poco_assert (maxPayloadSize > 0);
+
+	_maxPayloadSize = maxPayloadSize;
+}
+
+
+int WebSocketImpl::receivePayload(char *buffer, int payloadLength, char mask[4], bool useMask)
+{
+	int received = receiveNBytes(reinterpret_cast<char*>(buffer), payloadLength);
+	if (received <= 0) throw WebSocketException("Incomplete frame received", WebSocket::WS_ERR_INCOMPLETE_FRAME);
+
+	if (useMask)
+	{
+		for (int i = 0; i < received; i++)
+		{
+			buffer[i] ^= mask[i % 4];
+		}
+	}
+	return received;
+}
+
+
+int WebSocketImpl::receiveBytes(void* buffer, int length, int)
+{
+	char mask[4];
+	bool useMask;
+	int payloadLength = receiveHeader(mask, useMask);
+	if (payloadLength <= 0)
+		return payloadLength;
+	if (payloadLength > length)
+		throw WebSocketException(Poco::format("Insufficient buffer for payload size %d", payloadLength), WebSocket::WS_ERR_PAYLOAD_TOO_BIG);
+	return receivePayload(reinterpret_cast<char*>(buffer), payloadLength, mask, useMask);
+}
+
+
+int WebSocketImpl::receiveBytes(Poco::Buffer<char>& buffer, int)
+{
+	char mask[4];
+	bool useMask;
+	int payloadLength = receiveHeader(mask, useMask);
+	if (payloadLength <= 0)
+		return payloadLength;
+	std::size_t oldSize = buffer.size();
+	buffer.resize(oldSize + payloadLength);
+	return receivePayload(buffer.begin() + oldSize, payloadLength, mask, useMask);
+}
+
+
+int WebSocketImpl::receiveNBytes(void* buffer, int bytes)
+{
+	int received = receiveSomeBytes(reinterpret_cast<char*>(buffer), bytes);
+	if (received > 0)
+	{
+		while (received < bytes)
+		{
+			int n = receiveSomeBytes(reinterpret_cast<char*>(buffer) + received, bytes - received);
+			if (n > 0)
+				received += n;
+			else
+				throw WebSocketException("Incomplete frame received", WebSocket::WS_ERR_INCOMPLETE_FRAME);
+		}
+	}
+	return received;
+}
+
+
+int WebSocketImpl::receiveSomeBytes(char* buffer, int bytes)
+{
+	int n = static_cast<int>(_buffer.size()) - _bufferOffset;
+	if (n > 0)
+	{
+		if (bytes < n) n = bytes;
+		std::memcpy(buffer, _buffer.begin() + _bufferOffset, n);
+		_bufferOffset += n;
+		return n;
+	}
+	else
+	{
+		return _pStreamSocketImpl->receiveBytes(buffer, bytes);
+	}
+}
+
+
+SocketImpl* WebSocketImpl::acceptConnection(SocketAddress& clientAddr)
+{
+	throw Poco::InvalidAccessException("Cannot acceptConnection() on a WebSocketImpl");
+}
+
+
+void WebSocketImpl::connect(const SocketAddress& address)
+{
+	throw Poco::InvalidAccessException("Cannot connect() a WebSocketImpl");
+}
+
+
+void WebSocketImpl::connect(const SocketAddress& address, const Poco::Timespan& timeout)
+{
+	throw Poco::InvalidAccessException("Cannot connect() a WebSocketImpl");
+}
+
+
+void WebSocketImpl::connectNB(const SocketAddress& address)
+{
+	throw Poco::InvalidAccessException("Cannot connectNB() a WebSocketImpl");
+}
+
+
+void WebSocketImpl::bind(const SocketAddress& address, bool reuseAddress)
+{
+	throw Poco::InvalidAccessException("Cannot bind() a WebSocketImpl");
+}
+
+
+void WebSocketImpl::bind(const SocketAddress& address, bool reuseAddress, bool reusePort)
+{
+	throw Poco::InvalidAccessException("Cannot bind() a WebSocketImpl");
+}
+
+
+void WebSocketImpl::bind6(const SocketAddress& address, bool reuseAddress, bool ipV6Only)
+{
+	throw Poco::InvalidAccessException("Cannot bind6() a WebSocketImpl");
+}
+
+
+void WebSocketImpl::bind6(const SocketAddress& address, bool reuseAddress, bool reusePort, bool ipV6Only)
+{
+	throw Poco::InvalidAccessException("Cannot bind6() a WebSocketImpl");
+}
+
+
+void WebSocketImpl::listen(int backlog)
+{
+	throw Poco::InvalidAccessException("Cannot listen() on a WebSocketImpl");
+}
+
+
+void WebSocketImpl::close()
+{
+	_pStreamSocketImpl->close();
+	reset();
+}
+
+
+void WebSocketImpl::shutdownReceive()
+{
+	_pStreamSocketImpl->shutdownReceive();
+}
+
+
+void WebSocketImpl::shutdownSend()
+{
+	_pStreamSocketImpl->shutdownSend();
+}
+
+
+void WebSocketImpl::shutdown()
+{
+	_pStreamSocketImpl->shutdown();
+}
+
+
+int WebSocketImpl::sendTo(const void* buffer, int length, const SocketAddress& address, int flags)
+{
+	throw Poco::InvalidAccessException("Cannot sendTo() on a WebSocketImpl");
+}
+
+
+int WebSocketImpl::receiveFrom(void* buffer, int length, SocketAddress& address, int flags)
+{
+	throw Poco::InvalidAccessException("Cannot receiveFrom() on a WebSocketImpl");
+}
+
+
+void WebSocketImpl::sendUrgent(unsigned char data)
+{
+	throw Poco::InvalidAccessException("Cannot sendUrgent() on a WebSocketImpl");
+}
+
+
+bool WebSocketImpl::secure() const
+{
+	return _pStreamSocketImpl->secure();
+}
+
+
+void WebSocketImpl::setSendTimeout(const Poco::Timespan& timeout)
+{
+	_pStreamSocketImpl->setSendTimeout(timeout);
+}
+
+
+Poco::Timespan WebSocketImpl::getSendTimeout()
+{
+	return _pStreamSocketImpl->getSendTimeout();
+}
+
+
+void WebSocketImpl::setReceiveTimeout(const Poco::Timespan& timeout)
+{
+	_pStreamSocketImpl->setReceiveTimeout(timeout);
+}
+
+
+Poco::Timespan WebSocketImpl::getReceiveTimeout()
+{
+	return _pStreamSocketImpl->getReceiveTimeout();
+}
+
+
+int WebSocketImpl::available()
+{
+	int n = static_cast<int>(_buffer.size()) - _bufferOffset;
+	if (n > 0)
+		return n + _pStreamSocketImpl->available();
+	else
+		return _pStreamSocketImpl->available();
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/CMakeLists.txt b/base/poco/NetSSL_OpenSSL/CMakeLists.txt
new file mode 100644
index 00000000000..9ec5acaab02
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/CMakeLists.txt
@@ -0,0 +1,14 @@
+if (ENABLE_SSL)
+    file (GLOB SRCS src/*.cpp)
+
+    add_library (_poco_net_ssl ${SRCS})
+    add_library (Poco::Net::SSL ALIAS _poco_net_ssl)
+
+    target_include_directories (_poco_net_ssl SYSTEM PUBLIC "include")
+    target_link_libraries (_poco_net_ssl PUBLIC Poco::Crypto Poco::Net Poco::Util)
+else ()
+    add_library (_poco_net_ssl INTERFACE)
+    add_library (Poco::Net::SSL ALIAS _poco_net_ssl)
+
+    message (STATUS "Not using Poco::Net::SSL")
+endif ()
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/AcceptCertificateHandler.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/AcceptCertificateHandler.h
new file mode 100644
index 00000000000..2d92c629aa7
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/AcceptCertificateHandler.h
@@ -0,0 +1,52 @@
+//
+// AcceptCertificateHandler.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  AcceptCertificateHandler
+//
+// Definition of the AcceptCertificateHandler class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_AcceptCertificateHandler_INCLUDED
+#define NetSSL_AcceptCertificateHandler_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/InvalidCertificateHandler.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API AcceptCertificateHandler: public InvalidCertificateHandler
+	/// A AcceptCertificateHandler is invoked whenever an error 
+	/// occurs verifying the certificate. It always accepts
+	/// the certificate.
+	///
+	/// Should be using for testing purposes only.
+{
+public:
+	AcceptCertificateHandler(bool handleErrorsOnServerSide);
+		/// Creates the AcceptCertificateHandler
+
+	virtual ~AcceptCertificateHandler();
+		/// Destroys the AcceptCertificateHandler.
+
+	void onInvalidCertificate(const void* pSender, VerificationErrorArgs& errorCert);
+		/// Receives the questionable certificate in parameter errorCert. If one wants to accept the
+		/// certificate, call errorCert.setIgnoreError(true).
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_AcceptCertificateHandler_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/CertificateHandlerFactory.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/CertificateHandlerFactory.h
new file mode 100644
index 00000000000..5e3699c3cab
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/CertificateHandlerFactory.h
@@ -0,0 +1,93 @@
+//
+// CertificateHandlerFactory.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  CertificateHandlerFactory
+//
+// Definition of the CertificateHandlerFactory class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_CertificateHandlerFactory_INCLUDED
+#define NetSSL_CertificateHandlerFactory_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class InvalidCertificateHandler;
+
+
+class NetSSL_API CertificateHandlerFactory
+	/// A CertificateHandlerFactory is responsible for creating InvalidCertificateHandlers.
+	///
+	/// You don't need to access this class directly. Use the macro
+	///     POCO_REGISTER_CHFACTORY(namespace, InvalidCertificateHandlerName) 
+	/// instead (see the documentation of InvalidCertificateHandler for an example).
+{
+public:
+	CertificateHandlerFactory();
+		/// Creates the CertificateHandlerFactory.
+
+	virtual ~CertificateHandlerFactory();
+		/// Destroys the CertificateHandlerFactory.
+
+	virtual InvalidCertificateHandler* create(bool server) const = 0;
+		/// Creates a new InvalidCertificateHandler. Set server to true if the certificate handler is used on the server side.
+};
+
+
+class NetSSL_API CertificateHandlerFactoryRegistrar
+	/// Registrar class which automatically registers CertificateHandlerFactory at the CertificateHandlerFactoryMgr.
+	/// You don't need to access this class directly. Use the macro
+	///     POCO_REGISTER_CHFACTORY(namespace, InvalidCertificateHandlerName) 
+	/// instead (see the documentation of InvalidCertificateHandler for an example).
+{
+public:
+	CertificateHandlerFactoryRegistrar(const std::string& name, CertificateHandlerFactory* pFactory);
+		/// Registers the CertificateHandlerFactory with the given name at the factory manager.
+
+	virtual ~CertificateHandlerFactoryRegistrar();
+		/// Destroys the CertificateHandlerFactoryRegistrar.
+};
+
+
+template <typename T>
+class CertificateHandlerFactoryImpl: public Poco::Net::CertificateHandlerFactory
+{
+public:
+	CertificateHandlerFactoryImpl()
+	{
+	}
+
+	~CertificateHandlerFactoryImpl()
+	{
+	}
+
+	InvalidCertificateHandler* create(bool server) const
+	{
+		return new T(server);
+	}
+};
+
+
+} } // namespace Poco::Net
+
+
+// DEPRECATED: register the factory directly at the FactoryMgr:
+// Poco::Net::SSLManager::instance().certificateHandlerFactoryMgr().setFactory(name, new Poco::Net::CertificateHandlerFactoryImpl<MyConsoleHandler>());
+#define POCO_REGISTER_CHFACTORY(API, PKCLS)		\
+	static Poco::Net::CertificateHandlerFactoryRegistrar aRegistrar(std::string(#PKCLS), new Poco::Net::CertificateHandlerFactoryImpl<PKCLS>());
+
+
+#endif // NetSSL_CertificateHandlerFactory_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/CertificateHandlerFactoryMgr.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/CertificateHandlerFactoryMgr.h
new file mode 100644
index 00000000000..e70c9060b6f
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/CertificateHandlerFactoryMgr.h
@@ -0,0 +1,64 @@
+//
+// CertificateHandlerFactoryMgr.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  CertificateHandlerFactoryMgr
+//
+// Definition of the CertificateHandlerFactoryMgr class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_CertificateHandlerFactoryMgr_INCLUDED
+#define NetSSL_CertificateHandlerFactoryMgr_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/CertificateHandlerFactory.h"
+#include "Poco/SharedPtr.h"
+#include <map>
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API CertificateHandlerFactoryMgr
+	/// A CertificateHandlerFactoryMgr manages all existing CertificateHandlerFactories.
+{
+public:
+	typedef std::map<std::string, Poco::SharedPtr<CertificateHandlerFactory> > FactoriesMap;
+	
+	CertificateHandlerFactoryMgr();
+		/// Creates the CertificateHandlerFactoryMgr.
+
+	~CertificateHandlerFactoryMgr();
+		/// Destroys the CertificateHandlerFactoryMgr.
+
+	void setFactory(const std::string& name, CertificateHandlerFactory* pFactory);
+		/// Registers the factory. Class takes ownership of the pointer.
+		/// If a factory with the same name already exists, an exception is thrown.
+
+	bool hasFactory(const std::string& name) const;
+		/// Returns true if for the given name a factory is already registered
+	
+	const CertificateHandlerFactory* getFactory(const std::string& name) const;
+		/// Returns NULL if for the given name a factory does not exist, otherwise the factory is returned
+
+	void removeFactory(const std::string& name);
+		/// Removes the factory from the manager. 
+
+private:
+	FactoriesMap _factories;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_CertificateHandlerFactoryMgr_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/ConsoleCertificateHandler.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/ConsoleCertificateHandler.h
new file mode 100644
index 00000000000..c58962c4764
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/ConsoleCertificateHandler.h
@@ -0,0 +1,50 @@
+//
+// ConsoleCertificateHandler.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  ConsoleCertificateHandler
+//
+// Definition of the ConsoleCertificateHandler class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_ConsoleCertificateHandler_INCLUDED
+#define NetSSL_ConsoleCertificateHandler_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/InvalidCertificateHandler.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API ConsoleCertificateHandler: public InvalidCertificateHandler
+	/// A ConsoleCertificateHandler is invoked whenever an error occurs verifying the certificate.
+	/// 
+	/// The certificate is printed to stdout and the user is asked via console if he wants to accept it.
+{
+public:
+	ConsoleCertificateHandler(bool handleErrorsOnServerSide);
+		/// Creates the ConsoleCertificateHandler.
+
+	virtual ~ConsoleCertificateHandler();
+		/// Destroys the ConsoleCertificateHandler.
+
+	void onInvalidCertificate(const void* pSender, VerificationErrorArgs& errorCert);
+		/// Prints the certificate to stdout and waits for user input on the console
+		/// to decide if a certificate should be accepted/rejected.
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_ConsoleCertificateHandler_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/Context.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/Context.h
new file mode 100644
index 00000000000..a7a0c716318
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/Context.h
@@ -0,0 +1,415 @@
+//
+// Context.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  Context
+//
+// Definition of the Context class.
+//
+// Copyright (c) 2006-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_Context_INCLUDED
+#define NetSSL_Context_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/SocketDefs.h"
+#include "Poco/Crypto/X509Certificate.h"
+#include "Poco/Crypto/RSAKey.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include <openssl/ssl.h>
+#include <cstdlib>
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API Context: public Poco::RefCountedObject
+	/// This class encapsulates context information for
+	/// an SSL server or client, such as the certificate
+	/// verification mode and the location of certificates
+	/// and private key files, as well as the list of
+	/// supported ciphers.
+	///
+	/// The Context class is also used to control
+	/// SSL session caching on the server and client side.
+{
+public:
+	typedef Poco::AutoPtr<Context> Ptr;
+
+	enum Usage
+	{
+		CLIENT_USE, 	    /// Context is used by a client.
+		SERVER_USE,         /// Context is used by a server.
+		TLSV1_CLIENT_USE,   /// Context is used by a client requiring TLSv1.
+		TLSV1_SERVER_USE,   /// Context is used by a server requiring TLSv1.
+		TLSV1_1_CLIENT_USE, /// Context is used by a client requiring TLSv1.1 (OpenSSL 1.0.0 or newer).
+		TLSV1_1_SERVER_USE, /// Context is used by a server requiring TLSv1.1 (OpenSSL 1.0.0 or newer).
+		TLSV1_2_CLIENT_USE, /// Context is used by a client requiring TLSv1.2 (OpenSSL 1.0.1 or newer).
+		TLSV1_2_SERVER_USE  /// Context is used by a server requiring TLSv1.2 (OpenSSL 1.0.1 or newer).
+	};
+
+	enum VerificationMode
+	{
+		VERIFY_NONE    = SSL_VERIFY_NONE,
+			/// Server: The server will not send a client certificate
+			/// request to the client, so the client will not send a certificate.
+			///
+			/// Client: If not using an anonymous cipher (by default disabled),
+			/// the server will send a certificate which will be checked, but
+			/// the result of the check will be ignored.
+
+		VERIFY_RELAXED = SSL_VERIFY_PEER,
+			/// Server: The server sends a client certificate request to the
+			/// client. The certificate returned (if any) is checked.
+			/// If the verification process fails, the TLS/SSL handshake is
+			/// immediately terminated with an alert message containing the
+			/// reason for the verification failure.
+			///
+			/// Client: The server certificate is verified, if one is provided.
+			/// If the verification process fails, the TLS/SSL handshake is
+			/// immediately terminated with an alert message containing the
+			/// reason for the verification failure.
+
+		VERIFY_STRICT  = SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
+			/// Server: If the client did not return a certificate, the TLS/SSL
+			/// handshake is immediately terminated with a handshake failure
+			/// alert.
+			///
+			/// Client: Same as VERIFY_RELAXED.
+
+		VERIFY_ONCE    = SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE
+			/// Server: Only request a client certificate on the initial
+			/// TLS/SSL handshake. Do not ask for a client certificate
+			/// again in case of a renegotiation.
+			///
+			/// Client: Same as VERIFY_RELAXED.
+	};
+
+	enum Protocols
+	{
+		PROTO_SSLV2   = 0x01,
+		PROTO_SSLV3   = 0x02,
+		PROTO_TLSV1   = 0x04,
+		PROTO_TLSV1_1 = 0x08,
+		PROTO_TLSV1_2 = 0x10
+	};
+
+	struct NetSSL_API CAPaths
+	{
+		std::string caDefaultDir;
+		std::string caDefaultFile;
+		std::string caLocation;
+	};
+
+	struct NetSSL_API Params
+	{
+		Params();
+			/// Initializes the struct with default values.
+
+		std::string privateKeyFile;
+			/// Path to the private key file used for encryption.
+			/// Can be empty if no private key file is used.
+
+		std::string certificateFile;
+			/// Path to the certificate file (in PEM format).
+			/// If the private key and the certificate are stored in the same file, this
+			/// can be empty if privateKeyFile is given.
+
+		std::string caLocation;
+			/// Path to the file or directory containing the CA/root certificates.
+			/// Can be empty if the OpenSSL builtin CA certificates
+			/// are used (see loadDefaultCAs).
+
+		VerificationMode verificationMode;
+			/// Specifies whether and how peer certificates are validated.
+			/// Defaults to VERIFY_RELAXED.
+
+		int verificationDepth;
+			/// Sets the upper limit for verification chain sizes. Verification
+			/// will fail if a certificate chain larger than this is encountered.
+			/// Defaults to 9.
+
+		bool loadDefaultCAs;
+			/// Specifies whether the builtin CA certificates from OpenSSL are used.
+			/// Defaults to false.
+
+		std::string cipherList;
+			/// Specifies the supported ciphers in OpenSSL notation.
+			/// Defaults to "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH".
+
+		std::string dhParamsFile;
+			/// Specifies a file containing Diffie-Hellman parameters.
+			/// If empty, the default parameters are used.
+
+		std::string ecdhCurve;
+			/// Specifies the name of the curve to use for ECDH, based
+			/// on the curve names specified in RFC 4492.
+			/// Defaults to "prime256v1".
+	};
+
+	Context(Usage usage, const Params& params);
+		/// Creates a Context using the given parameters.
+		///
+		///   * usage specifies whether the context is used by a client or server.
+		///   * params specifies the context parameters.
+
+	Context(
+		Usage usage,
+		const std::string& privateKeyFile,
+		const std::string& certificateFile,
+		const std::string& caLocation,
+		VerificationMode verificationMode = VERIFY_RELAXED,
+		int verificationDepth = 9,
+		bool loadDefaultCAs = false,
+		const std::string& cipherList = "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
+		/// Creates a Context.
+		///
+		///   * usage specifies whether the context is used by a client or server.
+		///   * privateKeyFile contains the path to the private key file used for encryption.
+		///     Can be empty if no private key file is used.
+		///   * certificateFile contains the path to the certificate file (in PEM format).
+		///     If the private key and the certificate are stored in the same file, this
+		///     can be empty if privateKeyFile is given.
+		///   * caLocation contains the path to the file or directory containing the
+		///     CA/root certificates. Can be empty if the OpenSSL builtin CA certificates
+		///     are used (see loadDefaultCAs).
+		///   * verificationMode specifies whether and how peer certificates are validated.
+		///   * verificationDepth sets the upper limit for verification chain sizes. Verification
+		///     will fail if a certificate chain larger than this is encountered.
+		///   * loadDefaultCAs specifies whether the builtin CA certificates from OpenSSL are used.
+		///   * cipherList specifies the supported ciphers in OpenSSL notation.
+		///
+		/// Note: If the private key is protected by a passphrase, a PrivateKeyPassphraseHandler
+		/// must have been setup with the SSLManager, or the SSLManager's PrivateKeyPassphraseRequired
+		/// event must be handled.
+
+	Context(
+		Usage usage,
+		const std::string& caLocation,
+		VerificationMode verificationMode = VERIFY_RELAXED,
+		int verificationDepth = 9,
+		bool loadDefaultCAs = false,
+		const std::string& cipherList = "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
+		/// Creates a Context.
+		///
+		///   * usage specifies whether the context is used by a client or server.
+		///   * caLocation contains the path to the file or directory containing the
+		///     CA/root certificates. Can be empty if the OpenSSL builtin CA certificates
+		///     are used (see loadDefaultCAs).
+		///   * verificationMode specifies whether and how peer certificates are validated.
+		///   * verificationDepth sets the upper limit for verification chain sizes. Verification
+		///     will fail if a certificate chain larger than this is encountered.
+		///   * loadDefaultCAs specifies whether the builtin CA certificates from OpenSSL are used.
+		///   * cipherList specifies the supported ciphers in OpenSSL notation.
+		///
+		/// Note that a private key and/or certificate must be specified with
+		/// usePrivateKey()/useCertificate() before the Context can be used.
+
+	~Context();
+		/// Destroys the Context.
+
+	void useCertificate(const Poco::Crypto::X509Certificate& certificate);
+		/// Sets the certificate to be used by the Context.
+		///
+		/// To set-up a complete certificate chain, it might be
+		/// necessary to call addChainCertificate() to specify
+		/// additional certificates.
+		///
+		/// Note that useCertificate() must always be called before
+		/// usePrivateKey().
+
+	void addChainCertificate(const Poco::Crypto::X509Certificate& certificate);
+		/// Adds a certificate for certificate chain validation.
+
+	void addCertificateAuthority(const Poco::Crypto::X509Certificate& certificate);
+		/// Add one trusted certification authority to be used by the Context.
+
+	void usePrivateKey(const Poco::Crypto::RSAKey& key);
+		/// Sets the private key to be used by the Context.
+		///
+		/// Note that useCertificate() must always be called before
+		/// usePrivateKey().
+		///
+		/// Note: If the private key is protected by a passphrase, a PrivateKeyPassphraseHandler
+		/// must have been setup with the SSLManager, or the SSLManager's PrivateKeyPassphraseRequired
+		/// event must be handled.
+
+	SSL_CTX* sslContext() const;
+		/// Returns the underlying OpenSSL SSL Context object.
+
+	Usage usage() const;
+		/// Returns whether the context is for use by a client or by a server
+		/// and whether TLSv1 is required.
+
+	bool isForServerUse() const;
+		/// Returns true iff the context is for use by a server.
+
+	Context::VerificationMode verificationMode() const;
+		/// Returns the verification mode.
+
+	void enableSessionCache(bool flag = true);
+		/// Enable or disable SSL/TLS session caching.
+		/// For session caching to work, it must be enabled
+		/// on the server, as well as on the client side.
+		///
+		/// The default is disabled session caching.
+		///
+		/// To enable session caching on the server side, use the
+		/// two-argument version of this method to specify
+		/// a session ID context.
+
+	void enableSessionCache(bool flag, const std::string& sessionIdContext);
+		/// Enables or disables SSL/TLS session caching on the server.
+		/// For session caching to work, it must be enabled
+		/// on the server, as well as on the client side.
+		///
+		/// SessionIdContext contains the application's unique
+		/// session ID context, which becomes part of each
+		/// session identifier generated by the server within this
+		/// context. SessionIdContext can be an arbitrary sequence
+		/// of bytes with a maximum length of SSL_MAX_SSL_SESSION_ID_LENGTH.
+		///
+		/// A non-empty sessionIdContext should be specified even if
+		/// session caching is disabled to avoid problems with clients
+		/// requesting to reuse a session (e.g. Firefox 3.6).
+		///
+		/// This method may only be called on SERVER_USE Context objects.
+
+	bool sessionCacheEnabled() const;
+		/// Returns true iff the session cache is enabled.
+
+	void setSessionCacheSize(std::size_t size);
+		/// Sets the maximum size of the server session cache, in number of
+		/// sessions. The default size (according to OpenSSL documentation)
+		/// is 1024*20, which may be too large for many applications,
+		/// especially on embedded platforms with limited memory.
+		///
+		/// Specifying a size of 0 will set an unlimited cache size.
+		///
+		/// This method may only be called on SERVER_USE Context objects.
+
+	std::size_t getSessionCacheSize() const;
+		/// Returns the current maximum size of the server session cache.
+		///
+		/// This method may only be called on SERVER_USE Context objects.
+
+	void setSessionTimeout(long seconds);
+		/// Sets the timeout (in seconds) of cached sessions on the server.
+		/// A cached session will be removed from the cache if it has
+		/// not been used for the given number of seconds.
+		///
+		/// This method may only be called on SERVER_USE Context objects.
+
+	long getSessionTimeout() const;
+		/// Returns the timeout (in seconds) of cached sessions on the server.
+		///
+		/// This method may only be called on SERVER_USE Context objects.
+
+	void flushSessionCache();
+		/// Flushes the SSL session cache on the server.
+		///
+		/// This method may only be called on SERVER_USE Context objects.
+
+	void enableExtendedCertificateVerification(bool flag = true);
+		/// Enable or disable the automatic post-connection
+		/// extended certificate verification.
+		///
+		/// See X509Certificate::verify() for more information.
+
+	bool extendedCertificateVerificationEnabled() const;
+		/// Returns true iff automatic extended certificate
+		/// verification is enabled.
+
+	void disableStatelessSessionResumption();
+		/// Newer versions of OpenSSL support RFC 4507 tickets for stateless
+		/// session resumption.
+		///
+		/// The feature can be disabled by calling this method.
+
+	void disableProtocols(int protocols);
+		/// Disables the given protocols.
+		///
+		/// The protocols to be disabled are specified by OR-ing
+		/// values from the Protocols enumeration, e.g.:
+		///
+		///   context.disableProtocols(PROTO_SSLV2 | PROTO_SSLV3);
+
+	void preferServerCiphers();
+		/// When choosing a cipher, use the server's preferences instead of the client
+		/// preferences. When not called, the SSL server will always follow the clients
+		/// preferences. When called, the SSL/TLS server will choose following its own
+		/// preferences.
+
+	const CAPaths &getCAPaths();
+
+private:
+	void init(const Params& params);
+		/// Initializes the Context with the given parameters.
+
+	void initDH(const std::string& dhFile);
+		/// Initializes the Context with Diffie-Hellman parameters.
+
+	void initECDH(const std::string& curve);
+		/// Initializes the Context with Elliptic-Curve Diffie-Hellman key
+		/// exchange curve parameters.
+
+	void createSSLContext();
+		/// Create a SSL_CTX object according to Context configuration.
+
+	Usage _usage;
+	VerificationMode _mode;
+	SSL_CTX* _pSSLContext;
+	CAPaths _caPaths;
+	bool _extendedCertificateVerification;
+};
+
+
+//
+// inlines
+//
+inline Context::Usage Context::usage() const
+{
+	return _usage;
+}
+
+
+inline bool Context::isForServerUse() const
+{
+	return _usage == SERVER_USE
+		|| _usage == TLSV1_SERVER_USE
+		|| _usage == TLSV1_1_SERVER_USE
+		|| _usage == TLSV1_2_SERVER_USE;
+}
+
+
+inline Context::VerificationMode Context::verificationMode() const
+{
+	return _mode;
+}
+
+
+inline SSL_CTX* Context::sslContext() const
+{
+	return _pSSLContext;
+}
+
+
+inline bool Context::extendedCertificateVerificationEnabled() const
+{
+	return _extendedCertificateVerification;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_Context_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/HTTPSClientSession.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/HTTPSClientSession.h
new file mode 100644
index 00000000000..81344b1e5d5
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/HTTPSClientSession.h
@@ -0,0 +1,165 @@
+//
+// HTTPSClientSession.h
+//
+// Library: NetSSL_OpenSSL
+// Package: HTTPSClient
+// Module:  HTTPSClientSession
+//
+// Definition of the HTTPSClientSession class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_HTTPSClientSession_INCLUDED
+#define NetSSL_HTTPSClientSession_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/Utility.h"
+#include "Poco/Net/HTTPClientSession.h"
+#include "Poco/Net/Context.h"
+#include "Poco/Net/Session.h"
+#include "Poco/Net/X509Certificate.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class SecureStreamSocket;
+class HTTPRequest;
+class HTTPResponse;
+
+
+class NetSSL_API HTTPSClientSession: public HTTPClientSession
+	/// This class implements the client-side of
+	/// a HTTPS session.
+	///
+	/// To send a HTTPS request to a HTTPS server, first
+	/// instantiate a HTTPSClientSession object and
+	/// specify the server's host name and port number.
+	///
+	/// Then create a HTTPRequest object, fill it accordingly,
+	/// and pass it as argument to the sendRequest() method.
+	///
+	/// sendRequest() will return an output stream that can
+	/// be used to send the request body, if there is any.
+	///
+	/// After you are done sending the request body, create
+	/// a HTTPResponse object and pass it to receiveResponse().
+	///
+	/// This will return an input stream that can be used to
+	/// read the response body.
+	///
+	/// See RFC 2616 <http://www.faqs.org/rfcs/rfc2616.html> for more
+	/// information about the HTTP protocol.
+	///
+	/// Note that sending requests that neither contain a content length
+	/// field in the header nor are using chunked transfer encoding will
+	/// result in a SSL protocol violation, as the framework shuts down
+	/// the socket after sending the message body. No orderly SSL shutdown
+	/// will be performed in this case.
+	///
+	/// If session caching has been enabled for the Context object passed
+	/// to the HTTPSClientSession, the HTTPSClientSession class will
+	/// attempt to reuse a previously obtained Session object in
+	/// case of a reconnect.
+{
+public:
+	enum
+	{
+		HTTPS_PORT = 443
+	};
+
+	HTTPSClientSession();
+		/// Creates an unconnected HTTPSClientSession.
+
+	explicit HTTPSClientSession(const SecureStreamSocket& socket);
+		/// Creates a HTTPSClientSession using the given socket.
+		/// The socket must not be connected. The session
+		/// takes ownership of the socket.
+
+	HTTPSClientSession(const SecureStreamSocket& socket, Session::Ptr pSession);
+		/// Creates a HTTPSClientSession using the given socket.
+		/// The socket must not be connected. The session
+		/// takes ownership of the socket.
+		///
+		/// The given Session is reused, if possible (client session
+		/// caching is enabled for the given Context, and the server
+		/// agrees to reuse the session).
+
+	HTTPSClientSession(const std::string& host, Poco::UInt16 port = HTTPS_PORT);
+		/// Creates a HTTPSClientSession using the given host and port.
+
+	explicit HTTPSClientSession(Context::Ptr pContext);
+		/// Creates an unconnected HTTPSClientSession, using the
+		/// give SSL context.
+
+	HTTPSClientSession(Context::Ptr pContext, Session::Ptr pSession);
+		/// Creates an unconnected HTTPSClientSession, using the
+		/// give SSL context.
+		///
+		/// The given Session is reused, if possible (client session
+		/// caching is enabled for the given Context, and the server
+		/// agrees to reuse the session).
+
+	HTTPSClientSession(const std::string& host, Poco::UInt16 port, Context::Ptr pContext);
+		/// Creates a HTTPSClientSession using the given host and port,
+		/// using the given SSL context.
+
+	HTTPSClientSession(const std::string& host, Poco::UInt16 port, Context::Ptr pContext, Session::Ptr pSession);
+		/// Creates a HTTPSClientSession using the given host and port,
+		/// using the given SSL context.
+		///
+		/// The given Session is reused, if possible (client session
+		/// caching is enabled for the given Context, and the server
+		/// agrees to reuse the session).
+
+	~HTTPSClientSession();
+		/// Destroys the HTTPSClientSession and closes
+		/// the underlying socket.
+
+	bool secure() const;
+		/// Return true iff the session uses SSL or TLS,
+		/// or false otherwise.
+
+	X509Certificate serverCertificate();
+		/// Returns the server's certificate.
+		///
+		/// The certificate is available after the first request has been sent.
+
+	Session::Ptr sslSession();
+		/// Returns the SSL Session object for the current
+		/// connection, if session caching has been enabled for
+		/// the HTTPSClientSession's Context. A null pointer is
+		/// returned otherwise.
+		///
+		/// The Session object can be obtained after the first request has
+		/// been sent.
+
+	// HTTPSession
+	void abort();
+
+protected:
+	void connect(const SocketAddress& address);
+	std::string proxyRequestPrefix() const;
+	void proxyAuthenticate(HTTPRequest& request);
+	int read(char* buffer, std::streamsize length);
+
+private:
+	HTTPSClientSession(const HTTPSClientSession&);
+	HTTPSClientSession& operator = (const HTTPSClientSession&);
+
+	Context::Ptr _pContext;
+	Session::Ptr _pSession;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPSClientSession_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/HTTPSSessionInstantiator.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/HTTPSSessionInstantiator.h
new file mode 100644
index 00000000000..214e2819b64
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/HTTPSSessionInstantiator.h
@@ -0,0 +1,65 @@
+//
+// HTTPSSessionInstantiator.h
+//
+// Library: NetSSL_OpenSSL
+// Package: HTTPSClient
+// Module:  HTTPSSessionInstantiator
+//
+// Definition of the HTTPSSessionInstantiator class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_HTTPSSessionInstantiator_INCLUDED
+#define Net_HTTPSSessionInstantiator_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/Context.h"
+#include "Poco/Net/Utility.h"
+#include "Poco/Net/HTTPSessionInstantiator.h"
+#include "Poco/URI.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API HTTPSSessionInstantiator: public HTTPSessionInstantiator
+	/// The HTTPSessionInstantiator for HTTPSClientSession.
+{
+public:
+	HTTPSSessionInstantiator();
+		/// Creates the HTTPSSessionInstantiator.
+
+	HTTPSSessionInstantiator(Context::Ptr pContext);
+		/// Creates the HTTPSSessionInstantiator using the given SSL context.
+
+	~HTTPSSessionInstantiator();
+		/// Destroys the HTTPSSessionInstantiator.
+
+	HTTPClientSession* createClientSession(const Poco::URI& uri);
+		/// Creates a HTTPSClientSession for the given URI.
+
+	static void registerInstantiator();
+		/// Registers the instantiator with the global HTTPSessionFactory.
+
+	static void registerInstantiator(Context::Ptr pContext);
+		/// Registers the instantiator with the global HTTPSessionFactory using the given SSL context.
+
+	static void unregisterInstantiator();
+		/// Unregisters the factory with the global HTTPSessionFactory.
+
+private:
+	Context::Ptr _pContext;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPSSessionInstantiator_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/HTTPSStreamFactory.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/HTTPSStreamFactory.h
new file mode 100644
index 00000000000..2fd3515c88f
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/HTTPSStreamFactory.h
@@ -0,0 +1,83 @@
+//
+// HTTPSStreamFactory.h
+//
+// Library: NetSSL_OpenSSL
+// Package: HTTPSClient
+// Module:  HTTPSStreamFactory
+//
+// Definition of the HTTPSStreamFactory class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_HTTPSStreamFactory_INCLUDED
+#define NetSSL_HTTPSStreamFactory_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/HTTPSession.h"
+#include "Poco/URIStreamFactory.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API HTTPSStreamFactory: public Poco::URIStreamFactory
+	/// An implementation of the URIStreamFactory interface
+	/// that handles secure Hyper-Text Transfer Protocol (https) URIs.
+{
+public:
+	HTTPSStreamFactory();
+		/// Creates the HTTPSStreamFactory.
+
+	HTTPSStreamFactory(const std::string& proxyHost, Poco::UInt16 proxyPort = HTTPSession::HTTP_PORT);
+		/// Creates the HTTPSStreamFactory.
+		///
+		/// HTTPS connections will use the given proxy.
+
+	HTTPSStreamFactory(const std::string& proxyHost, Poco::UInt16 proxyPort, const std::string& proxyUsername, const std::string& proxyPassword);
+		/// Creates the HTTPSStreamFactory.
+		///
+		/// HTTPS connections will use the given proxy and
+		/// will be authorized against the proxy using Basic authentication
+		/// with the given proxyUsername and proxyPassword.
+
+	~HTTPSStreamFactory();
+		/// Destroys the HTTPSStreamFactory.
+		
+	std::istream* open(const Poco::URI& uri);
+		/// Creates and opens a HTTPS stream for the given URI.
+		/// The URI must be a https://... URI.
+		///
+		/// Throws a NetException if anything goes wrong.
+		
+	static void registerFactory();
+		/// Registers the HTTPSStreamFactory with the
+		/// default URIStreamOpener instance.	
+
+	static void unregisterFactory();
+		/// Unregisters the HTTPSStreamFactory with the
+		/// default URIStreamOpener instance.	
+		
+private:
+	enum
+	{
+		MAX_REDIRECTS = 10
+	};
+	
+	std::string  _proxyHost;
+	Poco::UInt16 _proxyPort;
+	std::string  _proxyUsername;
+	std::string  _proxyPassword;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_HTTPSStreamFactory_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/InvalidCertificateHandler.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/InvalidCertificateHandler.h
new file mode 100644
index 00000000000..e10faf3cdb2
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/InvalidCertificateHandler.h
@@ -0,0 +1,80 @@
+//
+// InvalidCertificateHandler.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  InvalidCertificateHandler
+//
+// Definition of the InvalidCertificateHandler class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_InvalidCertificateHandler_INCLUDED
+#define NetSSL_InvalidCertificateHandler_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/VerificationErrorArgs.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API InvalidCertificateHandler
+	/// A InvalidCertificateHandler is invoked whenever an error occurs verifying the certificate. It allows the user
+	/// to inspect and accept/reject the certificate.
+	/// One can install one's own InvalidCertificateHandler by implementing this interface. Note that
+	/// in the implementation file of the subclass the following code must be present (assuming you use the namespace My_API 
+	/// and the name of your handler class is MyGuiHandler):
+	///    
+	///    #include "Poco/Net/CertificateHandlerFactory.h"
+	///    ...
+	///    POCO_REGISTER_CHFACTORY(My_API, MyGuiHandler)
+	///
+	/// One can either set the handler directly in the startup code of the main method of ones application by calling
+	///
+	///    SSLManager::instance().initialize(mypassphraseHandler, myguiHandler, mySSLContext)
+	///
+	/// or in case one uses Poco::Util::Application one can rely on an XML configuration and put the following entry
+	/// under the path openSSL.invalidCertificateHandler:
+	///    
+	///    <invalidCertificateHandler>
+	///        <name>MyGuiHandler<name>
+	///        <options>
+	///            [...] // Put optional config params for the handler here
+	///        </options>
+	///    </invalidCertificateHandler>
+	///
+	/// Note that the name of the InvalidCertificateHandler must be same as the one provided to the POCO_REGISTER_CHFACTORY macro.
+{
+public:
+	InvalidCertificateHandler(bool handleErrorsOnServerSide);
+		/// Creates the InvalidCertificateHandler.
+		/// 
+		/// Set handleErrorsOnServerSide to true if the certificate handler is used on the server side.
+		/// Automatically registers at one of the SSLManager::VerificationError events.
+
+	virtual ~InvalidCertificateHandler();
+		/// Destroys the InvalidCertificateHandler.
+
+	virtual void onInvalidCertificate(const void* pSender, VerificationErrorArgs& errorCert) = 0;
+		/// Receives the questionable certificate in parameter errorCert. If one wants to accept the
+		/// certificate, call errorCert.setIgnoreError(true).
+
+protected:
+	bool _handleErrorsOnServerSide;
+		/// Stores if the certificate handler gets invoked by the server (i.e. a client certificate is wrong)
+		/// or the client (a server certificate is wrong)
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_InvalidCertificateHandler_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/KeyConsoleHandler.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/KeyConsoleHandler.h
new file mode 100644
index 00000000000..d9483d78e03
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/KeyConsoleHandler.h
@@ -0,0 +1,47 @@
+//
+// KeyConsoleHandler.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  KeyConsoleHandler
+//
+// Definition of the KeyConsoleHandler class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_KeyConsoleHandler_INCLUDED
+#define NetSSL_KeyConsoleHandler_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/PrivateKeyPassphraseHandler.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API KeyConsoleHandler: public PrivateKeyPassphraseHandler
+	/// An implementation of PrivateKeyPassphraseHandler that
+	/// reads the key for a certificate from the console.
+{
+public:
+	KeyConsoleHandler(bool server);
+		/// Creates the KeyConsoleHandler.
+
+	~KeyConsoleHandler();
+		/// Destroys the KeyConsoleHandler.
+
+	void onPrivateKeyRequested(const void* pSender, std::string& privateKey);
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_KeyConsoleHandler_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/KeyFileHandler.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/KeyFileHandler.h
new file mode 100644
index 00000000000..274cdbff592
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/KeyFileHandler.h
@@ -0,0 +1,51 @@
+//
+// KeyFileHandler.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  KeyFileHandler
+//
+// Definition of the KeyFileHandler class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_KeyFileHandler_INCLUDED
+#define NetSSL_KeyFileHandler_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/PrivateKeyPassphraseHandler.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API KeyFileHandler: public PrivateKeyPassphraseHandler
+	/// An implementation of PrivateKeyPassphraseHandler that 
+	/// reads the key for a certificate from a configuration file
+	/// under the path "openSSL.privateKeyPassphraseHandler.options.password".
+{
+public:
+	KeyFileHandler(bool server);
+		/// Creates the KeyFileHandler.
+
+	virtual ~KeyFileHandler();
+		/// Destroys the KeyFileHandler.
+
+	void onPrivateKeyRequested(const void* pSender, std::string& privateKey);
+
+private:
+	static const std::string CFG_PRIV_KEY_FILE;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_KeyFileHandler_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/NetSSL.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/NetSSL.h
new file mode 100644
index 00000000000..ae793fde934
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/NetSSL.h
@@ -0,0 +1,94 @@
+//
+// NetSSL.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  OpenSSL
+//
+// Basic definitions for the Poco OpenSSL library.
+// This file must be the first file included by every other OpenSSL
+// header file.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_NetSSL_INCLUDED
+#define NetSSL_NetSSL_INCLUDED
+
+
+#include "Poco/Net/Net.h"
+#include "Poco/Crypto/Crypto.h"
+
+
+//
+// The following block is the standard way of creating macros which make exporting
+// from a DLL simpler. All files within this DLL are compiled with the NetSSL_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any project
+// that uses this DLL. This way any other project whose source files include this file see
+// NetSSL_API functions as being imported from a DLL, wheras this DLL sees symbols
+// defined with this macro as being exported.
+//
+#if (defined(_WIN32) || defined(__CYGWIN__)) && defined(POCO_DLL)
+	#if defined(NetSSL_EXPORTS)
+		#define NetSSL_API __declspec(dllexport)
+	#else
+		#define NetSSL_API __declspec(dllimport)
+	#endif
+#endif
+
+
+#if !defined(NetSSL_API)
+	#if !defined(POCO_NO_GCC_API_ATTRIBUTE) && defined (__GNUC__) && (__GNUC__ >= 4)
+		#define NetSSL_API __attribute__ ((visibility ("default")))
+	#else
+		#define NetSSL_API
+	#endif
+#endif
+
+
+//
+// Automatically link NetSSL and OpenSSL libraries.
+//
+#if defined(_MSC_VER)
+	#if !defined(POCO_NO_AUTOMATIC_LIBS)
+		#if !defined(NetSSL_EXPORTS)
+			#pragma comment(lib, "PocoNetSSL" POCO_LIB_SUFFIX)
+		#endif
+	#endif // POCO_NO_AUTOMATIC_LIBS
+#endif
+
+
+namespace Poco {
+namespace Net {
+
+
+void NetSSL_API initializeSSL();
+	/// Initialize the NetSSL library, as well as the underlying OpenSSL
+	/// libraries, by calling Poco::Crypto::OpenSSLInitializer::initialize().
+	///
+	/// Should be called before using any class from the NetSSL library.
+	/// The NetSSL will be initialized automatically, through 
+	/// Poco::Crypto::OpenSSLInitializer instances or similar mechanisms
+	/// when creating Context or SSLManager instances.
+	/// However, it is recommended to call initializeSSL()
+	/// in any case at application startup.
+	///
+	/// Can be called multiple times; however, for every call to
+	/// initializeSSL(), a matching call to uninitializeSSL()
+	/// must be performed.
+	
+
+void NetSSL_API uninitializeSSL();
+	/// Uninitializes the NetSSL library by calling 
+	/// Poco::Crypto::OpenSSLInitializer::uninitialize() and
+	/// shutting down the SSLManager.
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_NetSSL_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/PrivateKeyFactory.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/PrivateKeyFactory.h
new file mode 100644
index 00000000000..9c0fa37faa2
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/PrivateKeyFactory.h
@@ -0,0 +1,95 @@
+//
+// PrivateKeyFactory.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  PrivateKeyFactory
+//
+// Definition of the PrivateKeyFactory class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_PrivateKeyFactory_INCLUDED
+#define NetSSL_PrivateKeyFactory_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class PrivateKeyPassphraseHandler;
+
+
+class NetSSL_API PrivateKeyFactory
+	/// A PrivateKeyFactory is responsible for creating PrivateKeyPassphraseHandlers.
+	///
+	/// You don't need to access this class directly. Use the macro
+	///     POCO_REGISTER_KEYFACTORY(namespace, PrivateKeyPassphraseHandlerName) 
+	/// instead (see the documentation of PrivateKeyPassphraseHandler for an example).
+{
+public:
+	PrivateKeyFactory();
+		/// Creates the PrivateKeyFactory.
+
+	virtual ~PrivateKeyFactory();
+		/// Destroys the PrivateKeyFactory.
+
+	virtual PrivateKeyPassphraseHandler* create(bool onServer) const = 0;
+		/// Creates a new PrivateKeyPassphraseHandler
+};
+
+
+class NetSSL_API PrivateKeyFactoryRegistrar
+	/// Registrar class which automatically registers PrivateKeyFactories at the PrivateKeyFactoryMgr.
+	///
+	/// You don't need to access this class directly. Use the macro
+	///     POCO_REGISTER_KEYFACTORY(namespace, PrivateKeyPassphraseHandlerName) 
+	/// instead (see the documentation of PrivateKeyPassphraseHandler for an example).
+
+{
+public:
+	PrivateKeyFactoryRegistrar(const std::string& name, PrivateKeyFactory* pFactory);
+		/// Registers the PrivateKeyFactory with the given name at the factory manager.
+
+	virtual ~PrivateKeyFactoryRegistrar();
+		/// Destroys the PrivateKeyFactoryRegistrar.
+};
+
+
+template<typename T>
+class PrivateKeyFactoryImpl: public Poco::Net::PrivateKeyFactory
+{
+public:
+	PrivateKeyFactoryImpl()
+	{
+	}
+
+	~PrivateKeyFactoryImpl()
+	{
+	}
+
+	PrivateKeyPassphraseHandler* create(bool server) const
+	{
+		return new T(server);
+	}
+};
+
+
+} } // namespace Poco::Net
+
+
+// DEPRECATED: register the factory directly at the FactoryMgr:
+// Poco::Net::SSLManager::instance().privateKeyFactoryMgr().setFactory(name, new Poco::Net::PrivateKeyFactoryImpl<MyKeyHandler>());
+#define POCO_REGISTER_KEYFACTORY(API, PKCLS)	\
+	static Poco::Net::PrivateKeyFactoryRegistrar aRegistrar(std::string(#PKCLS), new Poco::Net::PrivateKeyFactoryImpl<PKCLS>());
+
+
+#endif // NetSSL_PrivateKeyFactory_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/PrivateKeyFactoryMgr.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/PrivateKeyFactoryMgr.h
new file mode 100644
index 00000000000..b29b37f46a7
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/PrivateKeyFactoryMgr.h
@@ -0,0 +1,64 @@
+//
+// PrivateKeyFactoryMgr.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  PrivateKeyFactoryMgr
+//
+// Definition of the PrivateKeyFactoryMgr class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_PrivateKeyFactoryMgr_INCLUDED
+#define NetSSL_PrivateKeyFactoryMgr_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/PrivateKeyFactory.h"
+#include "Poco/SharedPtr.h"
+#include <map>
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API PrivateKeyFactoryMgr
+	/// A PrivateKeyFactoryMgr manages all existing PrivateKeyFactories.
+{
+public:
+	typedef std::map<std::string, Poco::SharedPtr<PrivateKeyFactory> > FactoriesMap;
+	
+	PrivateKeyFactoryMgr();
+		/// Creates the PrivateKeyFactoryMgr.
+
+	~PrivateKeyFactoryMgr();
+		/// Destroys the PrivateKeyFactoryMgr.
+
+	void setFactory(const std::string& name, PrivateKeyFactory* pFactory);
+		/// Registers the factory. Class takes ownership of the pointer.
+		/// If a factory with the same name already exists, an exception is thrown.
+
+	bool hasFactory(const std::string& name) const;
+		/// Returns true if for the given name a factory is already registered
+	
+	const PrivateKeyFactory* getFactory(const std::string& name) const;
+		/// Returns NULL if for the given name a factory does not exist, otherwise the factory is returned
+
+	void removeFactory(const std::string& name);
+		/// Removes the factory from the manager. 
+
+private:
+	FactoriesMap _factories;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_PrivateKeyFactoryMgr_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/PrivateKeyPassphraseHandler.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/PrivateKeyPassphraseHandler.h
new file mode 100644
index 00000000000..726703f78f7
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/PrivateKeyPassphraseHandler.h
@@ -0,0 +1,84 @@
+//
+// PrivateKeyPassphraseHandler.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  PrivateKeyPassphraseHandler
+//
+// Definition of the PrivateKeyPassphraseHandler class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_PrivateKeyPassphraseHandler_INCLUDED
+#define NetSSL_PrivateKeyPassphraseHandler_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API PrivateKeyPassphraseHandler
+	/// A passphrase handler is needed whenever the private key of a certificate is loaded and the certificate is protected
+	/// by a passphrase. The PrivateKeyPassphraseHandler's task is to provide that passphrase.
+	/// One can install one's own PrivateKeyPassphraseHandler by implementing this interface. Note that
+	/// in the implementation file of the subclass the following code must be present (assuming you use the namespace My_API 
+	/// and the name of your handler class is MyGuiHandler):
+	///    
+	///    #include "Poco/Net/PrivateKeyFactory.h"
+	///    ...
+	///    POCO_REGISTER_KEYFACTORY(My_API, MyGuiHandler)
+	///
+	/// One can either set the handler directly in the startup code of the main method of ones application by calling
+	///
+	///    SSLManager::instance().initialize(myguiHandler, myInvalidCertificateHandler, mySSLContext)
+	///
+	/// or in case one's application extends Poco::Util::Application one can use an XML configuration and put the following entry
+	/// under the path openSSL.privateKeyPassphraseHandler:
+	///    
+	///    <privateKeyPassphraseHandler>
+	///        <name>MyGuiHandler</name>
+	///        <options>
+	///            [...] // Put optional config params for the handler here
+	///        </options>
+	///    </privateKeyPassphraseHandler>
+	///
+	/// Note that the name of the passphrase handler must be same as the one provided to the POCO_REGISTER_KEYFACTORY macro.
+{
+public:
+	PrivateKeyPassphraseHandler(bool onServerSide);
+		/// Creates the PrivateKeyPassphraseHandler. Automatically registers at the SSLManager::PrivateKeyPassword event.
+
+	virtual ~PrivateKeyPassphraseHandler();
+		/// Destroys the PrivateKeyPassphraseHandler.
+
+	virtual void onPrivateKeyRequested(const void* pSender, std::string& privateKey) = 0;
+		/// Returns the requested private key in the parameter privateKey.
+
+	bool serverSide() const;
+
+private:
+	bool _serverSide;
+};
+
+
+//
+// inlines
+//
+inline bool PrivateKeyPassphraseHandler::serverSide() const
+{
+	return _serverSide;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_PrivateKeyPassphraseHandler_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/RejectCertificateHandler.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/RejectCertificateHandler.h
new file mode 100644
index 00000000000..b170ad50b5c
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/RejectCertificateHandler.h
@@ -0,0 +1,48 @@
+//
+// RejectCertificateHandler.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  RejectCertificateHandler
+//
+// Definition of the RejectCertificateHandler class.
+//
+// Copyright (c) 2006-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_RejectCertificateHandler_INCLUDED
+#define NetSSL_RejectCertificateHandler_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/InvalidCertificateHandler.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API RejectCertificateHandler: public InvalidCertificateHandler
+	/// A RejectCertificateHandler is invoked whenever an error 
+	/// occurs verifying the certificate. It always rejects
+	/// the certificate.
+{
+public:
+	RejectCertificateHandler(bool handleErrorsOnServerSide);
+		/// Creates the RejectCertificateHandler
+
+	virtual ~RejectCertificateHandler();
+		/// Destroys the RejectCertificateHandler.
+
+	void onInvalidCertificate(const void* pSender, VerificationErrorArgs& errorCert);
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_RejectCertificateHandler_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/SSLException.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/SSLException.h
new file mode 100644
index 00000000000..7b8dfe79d36
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/SSLException.h
@@ -0,0 +1,39 @@
+//
+// SSLException.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  SSLException
+//
+// Definition of the SSLException class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_SSLException_INCLUDED
+#define NetSSL_SSLException_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/NetException.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+POCO_DECLARE_EXCEPTION(NetSSL_API, SSLException, NetException)
+POCO_DECLARE_EXCEPTION(NetSSL_API, SSLContextException, SSLException)
+POCO_DECLARE_EXCEPTION(NetSSL_API, InvalidCertificateException, SSLException)
+POCO_DECLARE_EXCEPTION(NetSSL_API, CertificateValidationException, SSLException)
+POCO_DECLARE_EXCEPTION(NetSSL_API, SSLConnectionUnexpectedlyClosedException, SSLException)
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_SSLException_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/SSLManager.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/SSLManager.h
new file mode 100644
index 00000000000..6d0f469295b
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/SSLManager.h
@@ -0,0 +1,390 @@
+//
+// SSLManager.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  SSLManager
+//
+// Definition of the SSLManager class.
+//
+// Copyright (c) 2006-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_SSLManager_INCLUDED
+#define NetSSL_SSLManager_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/VerificationErrorArgs.h"
+#include "Poco/Net/Context.h"
+#include "Poco/Net/PrivateKeyFactoryMgr.h"
+#include "Poco/Net/CertificateHandlerFactoryMgr.h"
+#include "Poco/Net/InvalidCertificateHandler.h"
+#include "Poco/Util/AbstractConfiguration.h"
+#include "Poco/BasicEvent.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Mutex.h"
+#include <openssl/ssl.h>
+#if defined(OPENSSL_FIPS) && OPENSSL_VERSION_NUMBER < 0x010001000L
+#include <openssl/fips.h>
+#endif
+
+
+namespace Poco {
+namespace Net {
+
+
+class Context;
+
+
+class NetSSL_API SSLManager
+	/// SSLManager is a singleton for holding the default server/client
+	/// Context and handling callbacks for certificate verification errors
+	/// and private key passphrases.
+	///
+	/// Proper initialization of SSLManager is critical.
+	///
+	/// SSLManager can be initialized manually, by calling initializeServer()
+	/// and/or initializeClient(), or initialization can be automatic. In the latter
+	/// case, a Poco::Util::Application instance must be available and the required
+	/// configuration properties must be set (see below).
+	///
+	/// Note that manual initialization must happen very early in the application,
+	/// before defaultClientContext() or defaultServerContext() are called.
+	///
+	/// If defaultClientContext() and defaultServerContext() are never called
+	/// in an application, initialization of SSLManager can be omitted.
+	/// However, in this case, delegates for the ServerVerificationError,
+	/// ClientVerificationError and PrivateKeyPassphraseRequired events
+	/// must be registered.
+	///
+	/// An exemplary documentation which sets either the server or client default context and creates
+	/// a PrivateKeyPassphraseHandler that reads the password from the XML file looks like this:
+	///
+	///    <AppConfig>
+	///       <openSSL>
+	///          <server|client>
+	///            <privateKeyFile>mycert.key</privateKeyFile>
+	///            <certificateFile>mycert.crt</certificateFile>
+	///            <caConfig>rootcert.pem</caConfig>
+	///            <verificationMode>none|relaxed|strict|once</verificationMode>
+	///            <verificationDepth>1..9</verificationDepth>
+	///            <loadDefaultCAFile>true|false</loadDefaultCAFile>
+	///            <cipherList>ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH</cipherList>
+	///            <preferServerCiphers>true|false</preferServerCiphers>
+	///            <privateKeyPassphraseHandler>
+	///                <name>KeyFileHandler</name>
+	///                <options>
+	///                    <password>test</password>
+	///                </options>
+	///            </privateKeyPassphraseHandler>
+	///            <invalidCertificateHandler>
+	///                 <name>ConsoleCertificateHandler</name>
+	///            </invalidCertificateHandler>
+	///            <cacheSessions>true|false</cacheSessions>
+	///            <sessionIdContext>someString</sessionIdContext> <!-- server only -->
+	///            <sessionCacheSize>0..n</sessionCacheSize>       <!-- server only -->
+	///            <sessionTimeout>0..n</sessionTimeout>           <!-- server only -->
+	///            <extendedVerification>true|false</extendedVerification>
+	///            <requireTLSv1>true|false</requireTLSv1>
+	///            <requireTLSv1_1>true|false</requireTLSv1_1>
+	///            <requireTLSv1_2>true|false</requireTLSv1_2>
+	///            <disableProtocols>sslv2,sslv3,tlsv1,tlsv1_1,tlsv1_2</disableProtocols>
+	///            <dhParamsFile>dh.pem</dhParamsFile>
+	///            <ecdhCurve>prime256v1</ecdhCurve>
+	///          </server|client>
+	///          <fips>false</fips>
+	///       </openSSL>
+	///    </AppConfig>
+	///
+	/// Following is a list of supported configuration properties. Property names must always
+	/// be prefixed with openSSL.server or openSSL.client. Some properties are only supported
+	/// for servers.
+	///
+	///    - privateKeyFile (string): The path to the file containing the private key for the certificate
+	///      in PEM format (or containing both the private key and the certificate).
+	///    - certificateFile (string): The Path to the file containing the server's or client's certificate
+	///      in PEM format. Can be omitted if the the file given in privateKeyFile contains the certificate as well.
+	///    - caConfig (string): The path to the file or directory containing the trusted root certificates.
+	///    - verificationMode (string): Specifies whether and how peer certificates are validated (see
+	///      the Context class for details). Valid values are none, relaxed, strict, once.
+	///    - verificationDepth (integer, 1-9): Sets the upper limit for verification chain sizes. Verification
+	///      will fail if a certificate chain larger than this is encountered.
+	///    - loadDefaultCAFile (boolean): Specifies whether the builtin CA certificates from OpenSSL are used.
+	///    - cipherList (string): Specifies the supported ciphers in OpenSSL notation
+	///      (e.g. "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH").
+	///    - preferServerCiphers (bool): When choosing a cipher, use the server's preferences instead of the
+	///      client preferences. When not called, the SSL server will always follow the clients
+	///      preferences. When called, the SSL/TLS server will choose following its own
+	///      preferences.
+	///    - privateKeyPassphraseHandler.name (string): The name of the class (subclass of PrivateKeyPassphraseHandler)
+	///      used for obtaining the passphrase for accessing the private key.
+	///    - privateKeyPassphraseHandler.options.password (string): The password to be used by KeyFileHandler.
+	///    - invalidCertificateHandler.name: The name of the class (subclass of CertificateHandler)
+	///      used for confirming invalid certificates.
+	///    - cacheSessions (boolean): Enables or disables session caching.
+	///    - sessionIdContext (string): contains the application's unique session ID context, which becomes
+	///      part of each session identifier generated by the server. Can be an arbitrary sequence
+	///      of bytes with a maximum length of SSL_MAX_SSL_SESSION_ID_LENGTH. Should be specified
+	///      for a server to enable session caching. Should be specified even if session caching
+	///      is disabled to avoid problems with clients that request session caching (e.g. Firefox 3.6).
+	///      If not specified, defaults to ${application.name}.
+	///    - sessionCacheSize (integer): Sets the maximum size of the server session cache, in number of
+	///      sessions. The default size (according to OpenSSL documentation) is 1024*20, which may be too
+	///      large for many applications, especially on embedded platforms with limited memory.
+	///      Specifying a size of 0 will set an unlimited cache size.
+	///    - sessionTimeout (integer):  Sets the timeout (in seconds) of cached sessions on the server.
+	///    - extendedVerification (boolean): Enable or disable the automatic post-connection
+	///      extended certificate verification.
+	///    - requireTLSv1 (boolean): Require a TLSv1 connection.
+	///    - requireTLSv1_1 (boolean): Require a TLSv1.1 connection.
+	///    - requireTLSv1_2 (boolean): Require a TLSv1.2 connection.
+	///    - disableProtocols (string): A comma-separated list of protocols that should be
+	///      disabled. Valid protocol names are sslv2, sslv3, tlsv1, tlsv1_1, tlsv1_2.
+	///    - dhParamsFile (string): Specifies a file containing Diffie-Hellman parameters.
+	///      If not specified or empty, the default parameters are used.
+	///    - ecdhCurve (string): Specifies the name of the curve to use for ECDH, based
+	///      on the curve names specified in RFC 4492. Defaults to "prime256v1".
+	///    - fips: Enable or disable OpenSSL FIPS mode. Only supported if the OpenSSL version
+	///      that this library is built against supports FIPS mode.
+{
+public:
+	typedef Poco::SharedPtr<PrivateKeyPassphraseHandler> PrivateKeyPassphraseHandlerPtr;
+	typedef Poco::SharedPtr<InvalidCertificateHandler> InvalidCertificateHandlerPtr;
+
+	Poco::BasicEvent<VerificationErrorArgs> ServerVerificationError;
+		/// Fired whenever a certificate verification error is detected by the server during a handshake.
+
+	Poco::BasicEvent<VerificationErrorArgs> ClientVerificationError;
+		/// Fired whenever a certificate verification error is detected by the client during a handshake.
+
+	Poco::BasicEvent<std::string> PrivateKeyPassphraseRequired;
+		/// Fired when a encrypted certificate is loaded. Not setting the password
+		/// in the event parameter will result in a failure to load the certificate.
+
+	static SSLManager& instance();
+		/// Returns the instance of the SSLManager singleton.
+
+	void initializeServer(PrivateKeyPassphraseHandlerPtr ptrPassphraseHandler, InvalidCertificateHandlerPtr ptrCertificateHandler, Context::Ptr ptrContext);
+		/// Initializes the server side of the SSLManager with a default passphrase handler, a default invalid certificate handler and a default context. If this method
+		/// is never called the SSLmanager will try to initialize its members from an application configuration.
+		///
+		/// PtrPassphraseHandler and ptrCertificateHandler can be 0. However, in this case, event delegates
+		/// must be registered with the ServerVerificationError and PrivateKeyPassphraseRequired events.
+		///
+		/// Note: Always create the handlers (or register the corresponding event delegates) before creating
+		/// the Context, as during creation of the Context the passphrase for the private key might be needed.
+		///
+		/// Valid initialization code would be:
+		///     SharedPtr<PrivateKeyPassphraseHandler> pConsoleHandler = new KeyConsoleHandler;
+		///     SharedPtr<InvalidCertificateHandler> pInvalidCertHandler = new ConsoleCertificateHandler;
+		///     Context::Ptr pContext = new Context(Context::SERVER_USE, "any.pem", "any.pem", "rootcert.pem", Context::VERIFY_RELAXED, 9, false, "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
+		///     SSLManager::instance().initializeServer(pConsoleHandler, pInvalidCertHandler, pContext);
+
+	void initializeClient(PrivateKeyPassphraseHandlerPtr ptrPassphraseHandler, InvalidCertificateHandlerPtr ptrHandler, Context::Ptr ptrContext);
+		/// Initializes the client side of the SSLManager with a default passphrase handler, a default invalid certificate handler and a default context. If this method
+		/// is never called the SSLmanager will try to initialize its members from an application configuration.
+		///
+		/// PtrPassphraseHandler and ptrCertificateHandler can be 0. However, in this case, event delegates
+		/// must be registered with the ClientVerificationError and PrivateKeyPassphraseRequired events.
+		///
+		/// Note: Always create the handlers (or register the corresponding event delegates) before creating
+		/// the Context, as during creation of the Context the passphrase for the private key might be needed.
+		///
+		/// Valid initialization code would be:
+		///     SharedPtr<PrivateKeyPassphraseHandler> pConsoleHandler = new KeyConsoleHandler;
+		///     SharedPtr<InvalidCertificateHandler> pInvalidCertHandler = new ConsoleCertificateHandler;
+		///     Context::Ptr pContext = new Context(Context::CLIENT_USE, "", "", "rootcert.pem", Context::VERIFY_RELAXED, 9, false, "ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
+		///     SSLManager::instance().initializeClient(pConsoleHandler, pInvalidCertHandler, pContext);
+
+	Context::Ptr defaultServerContext();
+		/// Returns the default Context used by the server.
+		///
+		/// Unless initializeServer() has been called, the first call to this method initializes the default Context
+		/// from the application configuration.
+
+	Context::Ptr defaultClientContext();
+		/// Returns the default Context used by the client.
+		///
+		/// Unless initializeClient() has been called, the first call to this method initializes the default Context
+		/// from the application configuration.
+
+	PrivateKeyPassphraseHandlerPtr serverPassphraseHandler();
+		/// Returns the configured passphrase handler of the server. If none is set, the method will create a default one
+		/// from an application configuration.
+
+	InvalidCertificateHandlerPtr serverCertificateHandler();
+		/// Returns an initialized certificate handler (used by the server to verify client cert) which determines how invalid certificates are treated.
+		/// If none is set, it will try to auto-initialize one from an application configuration.
+
+	PrivateKeyPassphraseHandlerPtr clientPassphraseHandler();
+		/// Returns the configured passphrase handler of the client. If none is set, the method will create a default one
+		/// from an application configuration.
+
+	InvalidCertificateHandlerPtr clientCertificateHandler();
+		/// Returns an initialized certificate handler (used by the client to verify server cert) which determines how invalid certificates are treated.
+		/// If none is set, it will try to auto-initialize one from an application configuration.
+
+	PrivateKeyFactoryMgr& privateKeyFactoryMgr();
+		/// Returns the private key factory manager which stores the
+		/// factories for the different registered passphrase handlers for private keys.
+
+	CertificateHandlerFactoryMgr& certificateHandlerFactoryMgr();
+		/// Returns the CertificateHandlerFactoryMgr which stores the
+		/// factories for the different registered certificate handlers.
+
+	static bool isFIPSEnabled();
+		// Returns true if FIPS mode is enabled, false otherwise.
+
+	void shutdown();
+		/// Shuts down the SSLManager and releases the default Context
+		/// objects. After a call to shutdown(), the SSLManager can no
+		/// longer be used.
+		///
+		/// Normally, it's not necessary to call this method directly, as this
+		/// will be called either by uninitializeSSL(), or when
+		/// the SSLManager instance is destroyed.
+
+	static const std::string CFG_SERVER_PREFIX;
+	static const std::string CFG_CLIENT_PREFIX;
+
+protected:
+	static int verifyClientCallback(int ok, X509_STORE_CTX* pStore);
+		/// The return value of this method defines how errors in
+		/// verification are handled. Return 0 to terminate the handshake,
+		/// or 1 to continue despite the error.
+
+	static int verifyServerCallback(int ok, X509_STORE_CTX* pStore);
+		/// The return value of this method defines how errors in
+		/// verification are handled. Return 0 to terminate the handshake,
+		/// or 1 to continue despite the error.
+
+	static int privateKeyPassphraseCallback(char* pBuf, int size, int flag, void* userData);
+		/// Method is invoked by OpenSSL to retrieve a passwd for an encrypted certificate.
+		/// The request is delegated to the PrivatekeyPassword event. This method returns the
+		/// length of the password.
+
+	static Poco::Util::AbstractConfiguration& appConfig();
+		/// Returns the application configuration.
+		///
+		/// Throws a InvalidStateException if not application instance
+		/// is available.
+
+private:
+	SSLManager();
+		/// Creates the SSLManager.
+
+	~SSLManager();
+		/// Destroys the SSLManager.
+
+	void initDefaultContext(bool server);
+		/// Inits the default context, the first time it is accessed.
+
+	void initEvents(bool server);
+		/// Registers delegates at the events according to the configuration.
+
+	void initPassphraseHandler(bool server);
+		/// Inits the passphrase handler.
+
+	void initCertificateHandler(bool server);
+		/// Inits the certificate handler.
+
+	static int verifyCallback(bool server, int ok, X509_STORE_CTX* pStore);
+		/// The return value of this method defines how errors in
+		/// verification are handled. Return 0 to terminate the handshake,
+		/// or 1 to continue despite the error.
+
+	PrivateKeyFactoryMgr             _factoryMgr;
+	CertificateHandlerFactoryMgr     _certHandlerFactoryMgr;
+	Context::Ptr                     _ptrDefaultServerContext;
+	PrivateKeyPassphraseHandlerPtr   _ptrServerPassphraseHandler;
+	InvalidCertificateHandlerPtr     _ptrServerCertificateHandler;
+	Context::Ptr                     _ptrDefaultClientContext;
+	PrivateKeyPassphraseHandlerPtr   _ptrClientPassphraseHandler;
+	InvalidCertificateHandlerPtr     _ptrClientCertificateHandler;
+	Poco::FastMutex                  _mutex;
+
+	static const std::string CFG_PRIV_KEY_FILE;
+	static const std::string CFG_CERTIFICATE_FILE;
+	static const std::string CFG_CA_LOCATION;
+	static const std::string CFG_VER_MODE;
+	static const Context::VerificationMode VAL_VER_MODE;
+	static const std::string CFG_VER_DEPTH;
+	static const int         VAL_VER_DEPTH;
+	static const std::string CFG_ENABLE_DEFAULT_CA;
+	static const bool        VAL_ENABLE_DEFAULT_CA;
+	static const std::string CFG_CIPHER_LIST;
+	static const std::string CFG_CYPHER_LIST; // for backwards compatibility
+	static const std::string VAL_CIPHER_LIST;
+	static const std::string CFG_PREFER_SERVER_CIPHERS;
+	static const std::string CFG_DELEGATE_HANDLER;
+	static const std::string VAL_DELEGATE_HANDLER;
+	static const std::string CFG_CERTIFICATE_HANDLER;
+	static const std::string VAL_CERTIFICATE_HANDLER;
+	static const std::string CFG_CACHE_SESSIONS;
+	static const std::string CFG_SESSION_ID_CONTEXT;
+	static const std::string CFG_SESSION_CACHE_SIZE;
+	static const std::string CFG_SESSION_TIMEOUT;
+	static const std::string CFG_EXTENDED_VERIFICATION;
+	static const std::string CFG_REQUIRE_TLSV1;
+	static const std::string CFG_REQUIRE_TLSV1_1;
+	static const std::string CFG_REQUIRE_TLSV1_2;
+	static const std::string CFG_DISABLE_PROTOCOLS;
+	static const std::string CFG_DH_PARAMS_FILE;
+	static const std::string CFG_ECDH_CURVE;
+
+#ifdef OPENSSL_FIPS
+	static const std::string CFG_FIPS_MODE;
+	static const bool        VAL_FIPS_MODE;
+#endif
+
+	friend class Poco::SingletonHolder<SSLManager>;
+	friend class Context;
+};
+
+
+//
+// inlines
+//
+inline PrivateKeyFactoryMgr& SSLManager::privateKeyFactoryMgr()
+{
+	return _factoryMgr;
+}
+
+
+inline CertificateHandlerFactoryMgr& SSLManager::certificateHandlerFactoryMgr()
+{
+	return _certHandlerFactoryMgr;
+}
+
+
+inline bool SSLManager::isFIPSEnabled()
+{
+#ifdef OPENSSL_FIPS
+	return FIPS_mode() ? true : false;
+#else
+	return false;
+#endif
+}
+
+
+inline int SSLManager::verifyServerCallback(int ok, X509_STORE_CTX* pStore)
+{
+	return SSLManager::verifyCallback(true, ok, pStore);
+}
+
+
+inline int SSLManager::verifyClientCallback(int ok, X509_STORE_CTX* pStore)
+{
+	return SSLManager::verifyCallback(false, ok, pStore);
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_SSLManager_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureSMTPClientSession.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureSMTPClientSession.h
new file mode 100644
index 00000000000..146be2aeb57
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureSMTPClientSession.h
@@ -0,0 +1,96 @@
+//
+// SecureSMTPClientSession.h
+//
+// Library: NetSSL_OpenSSL
+// Package: Mail
+// Module:  SecureSMTPClientSession
+//
+// Definition of the SecureSMTPClientSession class.
+//
+// Copyright (c) 2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Net_SecureSMTPClientSession_INCLUDED
+#define Net_SecureSMTPClientSession_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/SMTPClientSession.h"
+#include "Poco/Net/Context.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API SecureSMTPClientSession: public SMTPClientSession
+	/// This class implements an Simple Mail
+	/// Transfer Protocol (SMTP, RFC 2821)
+	/// client for sending e-mail messages that
+	/// supports the STARTTLS command for secure
+	/// connections.
+	///
+	/// Usage is as follows:
+	///   1. Create a SecureSMTPClientSession object.
+	///   2. Call login() or login(hostname).
+	///   3. Call startTLS() to switch to a secure connection.
+	///      Check the return value to see if a secure connection
+	///      has actually been established (not all servers may
+	///      support STARTTLS).
+	///   4. Call any of the login() methods to securely authenticate
+	///      with a username and password.
+	///   5. Send the message(s).
+{
+public:
+	explicit SecureSMTPClientSession(const StreamSocket& socket);
+		/// Creates the SecureSMTPClientSession using
+		/// the given socket, which must be connected
+		/// to a SMTP server.
+
+	SecureSMTPClientSession(const std::string& host, Poco::UInt16 port = SMTP_PORT);
+		/// Creates the SecureSMTPClientSession using a socket connected
+		/// to the given host and port.
+
+	virtual ~SecureSMTPClientSession();
+		/// Destroys the SMTPClientSession.
+
+	bool startTLS();
+		/// Sends a STARTTLS command and, if successful, 
+		/// creates a secure SSL/TLS connection over the
+		/// existing socket connection.
+		///
+		/// Must be called after login() or login(hostname).
+		/// If successful, login() can be called again
+		/// to authenticate the user.
+		///
+		/// Returns true if the STARTTLS command was successful,
+		/// false otherwise.
+
+	bool startTLS(Context::Ptr pContext);
+		/// Sends a STARTTLS command and, if successful, 
+		/// creates a secure SSL/TLS connection over the
+		/// existing socket connection.
+		///
+		/// Uses the given Context object for creating
+		/// the SSL/TLS connection.
+		///
+		/// Must be called after login() or login(hostname).
+		/// If successful, login() can be called again
+		/// to authenticate the user.
+		///
+		/// Returns true if the STARTTLS command was successful,
+		/// false otherwise.
+		
+private:
+	std::string _host;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // Net_SecureSMTPClientSession_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureServerSocket.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureServerSocket.h
new file mode 100644
index 00000000000..2b89c45cb9e
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureServerSocket.h
@@ -0,0 +1,136 @@
+//
+// SecureServerSocket.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLSockets
+// Module:  SecureServerSocket
+//
+// Definition of the SecureServerSocket class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_SecureServerSocket_INCLUDED
+#define NetSSL_SecureServerSocket_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/ServerSocket.h"
+#include "Poco/Net/Context.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API SecureServerSocket: public ServerSocket
+	/// A server socket for secure SSL connections.
+{
+public:
+	SecureServerSocket();
+		/// Creates a SSL server socket using the
+		/// default SSL server context.
+		///
+		/// The server socket must be bound to
+		/// an address and put into listening state.
+
+	explicit SecureServerSocket(Context::Ptr pContext);
+		/// Creates a SSL server socket, using the
+		/// given SSL context object.
+		///
+		/// The server socket must be bound to
+		/// an address and put into listening state.
+
+	SecureServerSocket(const Socket& socket);
+		/// Creates the SecureServerSocket with the SocketImpl
+		/// from another socket. The SocketImpl must be
+		/// a SecureServerSocketImpl, otherwise an InvalidArgumentException
+		/// will be thrown.
+
+	SecureServerSocket(const SocketAddress& address, int backlog = 64);
+		/// Creates a server socket using the default server SSL context,
+		/// binds it to the given address and puts it in listening
+		/// state.
+		///
+		/// After successful construction, the server socket
+		/// is ready to accept connections.
+
+	SecureServerSocket(const SocketAddress& address, int backlog, Context::Ptr pContext);
+		/// Creates a server socket using the given SSL context, binds it
+		/// to the given address and puts it in listening
+		/// state.
+		///
+		/// After successful construction, the server socket
+		/// is ready to accept connections.
+
+	SecureServerSocket(Poco::UInt16 port, int backlog = 64);
+		/// Creates a server socket using the default server SSL context,
+		/// binds it to the given port and puts it in listening
+		/// state.
+		///
+		/// After successful construction, the server socket
+		/// is ready to accept connections.
+
+	SecureServerSocket(Poco::UInt16 port, int backlog, Context::Ptr pContext);
+		/// Creates a server socket using the given SSL context, binds it
+		/// to the given port and puts it in listening
+		/// state.
+		///
+		/// After successful construction, the server socket
+		/// is ready to accept connections.
+
+	virtual ~SecureServerSocket();
+		/// Destroys the StreamSocket.
+
+	SecureServerSocket& operator = (const Socket& socket);
+		/// Assignment operator.
+		///
+		/// Releases the socket's SocketImpl and
+		/// attaches the SocketImpl from the other socket and
+		/// increments the reference count of the SocketImpl.	
+
+	StreamSocket acceptConnection(SocketAddress& clientAddr);
+		/// Get the next completed connection from the
+		/// socket's completed connection queue.
+		///
+		/// If the queue is empty, waits until a connection
+		/// request completes.
+		///
+		/// Returns a new SSL socket for the connection
+		/// with the client.
+		///
+		/// The client socket's address is returned in clientAddr.
+		///
+		/// No SSL handshake is performed on the new connection.
+		/// The SSL handshake will be performed the first time
+		/// sendBytes(), receiveBytes() or completeHandshake()
+		/// is called on the returned SecureStreamSocket.
+
+	StreamSocket acceptConnection();
+		/// Get the next completed connection from the
+		/// socket's completed connection queue.
+		///
+		/// If the queue is empty, waits until a connection
+		/// request completes.
+		///
+		/// Returns a new SSL socket for the connection
+		/// with the client.
+		///
+		/// No SSL handshake is performed on the new connection.
+		/// The SSL handshake will be performed the first time
+		/// sendBytes(), receiveBytes() or completeHandshake()
+		/// is called on the returned SecureStreamSocket.
+
+	Context::Ptr context() const;
+		/// Returns the SSL context used by this socket.
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_SecureServerSocket_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureServerSocketImpl.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureServerSocketImpl.h
new file mode 100644
index 00000000000..2cf969d099f
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureServerSocketImpl.h
@@ -0,0 +1,146 @@
+//
+// SecureServerSocketImpl.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLSockets
+// Module:  SecureServerSocketImpl
+//
+// Definition of the SecureServerSocketImpl class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_SecureServerSocketImpl_INCLUDED
+#define NetSSL_SecureServerSocketImpl_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/SecureSocketImpl.h"
+#include "Poco/Net/ServerSocketImpl.h"
+#include "Poco/Net/Context.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API SecureServerSocketImpl: public ServerSocketImpl
+	/// The SocketImpl class for SecureServerSocket.
+{
+public:
+	SecureServerSocketImpl(Context::Ptr pContext);
+		/// Creates the SecureServerSocketImpl using the
+		/// given SSL context object.
+
+	SocketImpl* acceptConnection(SocketAddress& clientAddr);
+		/// Get the next completed connection from the
+		/// socket's completed connection queue.
+		///
+		/// If the queue is empty, waits until a connection
+		/// request completes.
+		///
+		/// Returns a new TCP socket for the connection
+		/// with the client.
+		///
+		/// The client socket's address is returned in clientAddr.
+	
+	void connect(const SocketAddress& address);
+		/// Not supported by this kind of socket.
+		///
+		/// Throws a Poco::InvalidAccessException.
+
+	void connect(const SocketAddress& address, const Poco::Timespan& timeout);
+		/// Not supported by this kind of socket.
+		///
+		/// Throws a Poco::InvalidAccessException.
+
+	void connectNB(const SocketAddress& address);
+		/// Not supported by this kind of socket.
+		///
+		/// Throws a Poco::InvalidAccessException.
+	
+	void bind(const SocketAddress& address, bool reuseAddress = false, bool reusePort = false);
+		/// Bind a local address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. TCP clients should not bind a socket to a
+		/// specific address.
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		
+	void listen(int backlog = 64);
+		/// Puts the socket into listening state.
+		///
+		/// The socket becomes a passive socket that
+		/// can accept incoming connection requests.
+		///
+		/// The backlog argument specifies the maximum
+		/// number of connections that can be queued
+		/// for this socket.
+
+	void close();
+		/// Close the socket.
+	
+	int sendBytes(const void* buffer, int length, int flags = 0);
+		/// Not supported by this kind of socket.
+		///
+		/// Throws a Poco::InvalidAccessException.
+	
+	int receiveBytes(void* buffer, int length, int flags = 0);
+		/// Not supported by this kind of socket.
+		///
+		/// Throws a Poco::InvalidAccessException.
+	
+	int sendTo(const void* buffer, int length, const SocketAddress& address, int flags = 0);
+		/// Not supported by this kind of socket.
+		///
+		/// Throws a Poco::InvalidAccessException.
+	
+	int receiveFrom(void* buffer, int length, SocketAddress& address, int flags = 0);
+		/// Not supported by this kind of socket.
+		///
+		/// Throws a Poco::InvalidAccessException.
+	
+	void sendUrgent(unsigned char data);
+		/// Not supported by this kind of socket.
+		///
+		/// Throws a Poco::InvalidAccessException.
+
+	bool secure() const;
+		/// Returns true iff the socket's connection is secure
+		/// (using SSL or TLS).
+		
+	Context::Ptr context() const;
+		/// Returns the SSL context used by this socket.
+
+protected:
+	~SecureServerSocketImpl();
+		/// Destroys the SecureServerSocketImpl.
+
+private:
+	SecureServerSocketImpl(const SecureServerSocketImpl&);
+	SecureServerSocketImpl& operator = (const SecureServerSocketImpl&);
+
+private:
+	SecureSocketImpl _impl;
+};
+
+
+//
+// inlines
+//
+inline Context::Ptr SecureServerSocketImpl::context() const
+{
+	return _impl.context();
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_SecureServerSocketImpl_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureSocketImpl.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureSocketImpl.h
new file mode 100644
index 00000000000..f804e00cb83
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureSocketImpl.h
@@ -0,0 +1,268 @@
+//
+// SecureSocketImpl.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLSockets
+// Module:  SecureSocketImpl
+//
+// Definition of the SecureSocketImpl class.
+//
+// Copyright (c) 2006-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_SecureSocketImpl_INCLUDED
+#define NetSSL_SecureSocketImpl_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/SocketImpl.h"
+#include "Poco/Net/Context.h"
+#include "Poco/Net/X509Certificate.h"
+#include "Poco/Net/Session.h"
+#include <openssl/bio.h>
+#include <openssl/ssl.h>
+
+#include <mutex>
+
+namespace Poco {
+namespace Net {
+
+
+class HostEntry;
+
+
+class NetSSL_API SecureSocketImpl
+	/// The SocketImpl for SecureStreamSocket.
+{
+public:
+	SecureSocketImpl(Poco::AutoPtr<SocketImpl> pSocketImpl, Context::Ptr pContext);
+		/// Creates the SecureSocketImpl using an already
+		/// connected stream socket.
+
+	virtual ~SecureSocketImpl();
+		/// Destroys the SecureSocketImpl.
+
+	SocketImpl* acceptConnection(SocketAddress& clientAddr);
+		/// Get the next completed connection from the
+		/// socket's completed connection queue.
+		///
+		/// If the queue is empty, waits until a connection
+		/// request completes.
+		///
+		/// Returns a new SSL socket for the connection
+		/// with the client.
+		///
+		/// The client socket's address is returned in clientAddr.
+	
+	void connect(const SocketAddress& address, bool performHandshake);
+		/// Initializes the socket and establishes a secure connection to
+		/// the TCP server at the given address.
+		///
+		/// If performHandshake is true, the SSL handshake is performed immediately
+		/// after establishing the connection. Otherwise, the handshake is performed
+		/// the first time sendBytes(), receiveBytes() or completeHandshake() is called.
+
+	void connect(const SocketAddress& address, const Poco::Timespan& timeout, bool performHandshake);
+		/// Initializes the socket, sets the socket timeout and
+		/// establishes a secure connection to the TCP server at the given address.
+		///
+		/// If performHandshake is true, the SSL handshake is performed immediately
+		/// after establishing the connection. Otherwise, the handshake is performed
+		/// the first time sendBytes(), receiveBytes() or completeHandshake() is called.
+
+	void connectNB(const SocketAddress& address);
+		/// Initializes the socket and establishes a secure connection to
+		/// the TCP server at the given address. Prior to opening the
+		/// connection the socket is set to nonblocking mode.
+
+	void bind(const SocketAddress& address, bool reuseAddress = false, bool reusePort = false);
+		/// Bind a local address to the socket.
+		///
+		/// This is usually only done when establishing a server
+		/// socket. SSL clients should not bind a socket to a
+		/// specific address.
+		///
+		/// If reuseAddress is true, sets the SO_REUSEADDR
+		/// socket option.
+		
+	void listen(int backlog = 64);
+		/// Puts the socket into listening state.
+		///
+		/// The socket becomes a passive socket that
+		/// can accept incoming connection requests.
+		///
+		/// The backlog argument specifies the maximum
+		/// number of connections that can be queued
+		/// for this socket.
+
+	void shutdown();
+		/// Shuts down the connection by attempting
+		/// an orderly SSL shutdown, then actually
+		/// shutting down the TCP connection.
+
+	void close();
+		/// Close the socket.
+		
+	void abort();
+		/// Aborts the connection by closing the
+		/// underlying TCP connection. No orderly SSL shutdown
+		/// is performed.
+	
+	int sendBytes(const void* buffer, int length, int flags = 0);
+		/// Sends the contents of the given buffer through
+		/// the socket. Any specified flags are ignored.
+		///
+		/// Returns the number of bytes sent, which may be
+		/// less than the number of bytes specified.
+	
+	int receiveBytes(void* buffer, int length, int flags = 0);
+		/// Receives data from the socket and stores it
+		/// in buffer. Up to length bytes are received.
+		///
+		/// Returns the number of bytes received.
+		
+	int available() const;
+		/// Returns the number of bytes available from the
+		/// SSL buffer for immediate reading.
+	
+	int completeHandshake();
+		/// Completes the SSL handshake.
+		///
+		/// If the SSL connection was the result of an accept(),
+		/// the server-side handshake is completed, otherwise
+		/// a client-side handshake is performed.
+		
+	poco_socket_t sockfd();
+		/// Returns the underlying socket descriptor.
+
+	X509* peerCertificate() const;
+		/// Returns the peer's certificate.
+		
+	Context::Ptr context() const;
+		/// Returns the SSL context used for this socket.
+
+	void verifyPeerCertificate();
+		/// Performs post-connect (or post-accept) peer certificate validation,
+		/// using the peer host name set with setPeerHostName(), or the peer's
+		/// IP address string if no peer host name has been set.
+
+	void verifyPeerCertificate(const std::string& hostName);
+		/// Performs post-connect (or post-accept) peer certificate validation
+		/// using the given peer host name.
+
+	void setPeerHostName(const std::string& hostName);
+		/// Sets the peer host name for certificate validation purposes.
+		
+	const std::string& getPeerHostName() const;
+		/// Returns the peer host name.
+		
+	Session::Ptr currentSession();
+		/// Returns the SSL session of the current connection,
+		/// for reuse in a future connection (if session caching
+		/// is enabled).
+		///
+		/// If no connection is established, returns null.
+		
+	void useSession(Session::Ptr pSession);
+		/// Sets the SSL session to use for the next
+		/// connection. Setting a previously saved Session
+		/// object is necessary to enable session caching.
+		///
+		/// To remove the currently set session, a null pointer
+		/// can be given.
+		///
+		/// Must be called before connect() to be effective.
+		
+	bool sessionWasReused();
+		/// Returns true iff a reused session was negotiated during
+		/// the handshake.
+		
+protected:
+	void acceptSSL();
+		/// Assume per-object mutex is locked.
+		/// Performs a server-side SSL handshake and certificate verification.
+
+	void connectSSL(bool performHandshake);
+		/// Performs a client-side SSL handshake and establishes a secure
+		/// connection over an already existing TCP connection.
+	
+	long verifyPeerCertificateImpl(const std::string& hostName);
+		/// Performs post-connect (or post-accept) peer certificate validation.
+		
+	static bool isLocalHost(const std::string& hostName);
+		/// Returns true iff the given host name is the local host
+		/// (either "localhost" or "127.0.0.1").
+
+	bool mustRetry(int rc, Poco::Timespan& remaining_time);
+		/// Returns true if the last operation should be retried,
+		/// otherwise false.
+		///
+		/// In case of an SSL_ERROR_WANT_READ error, and if the socket is
+		/// blocking, waits for the underlying socket to become readable.
+		///
+		/// In case of an SSL_ERROR_WANT_WRITE error, and if the socket is
+		/// blocking, waits for the underlying socket to become writable.
+		///
+		/// Can also throw a Poco::TimeoutException if the socket does
+		/// not become readable or writable within the sockets
+		/// receive or send timeout.
+
+	int handleError(int rc);
+		/// Handles an SSL error by throwing an appropriate exception.
+
+	void reset();
+		/// Prepares the socket for re-use.
+		///
+		/// After closing and resetting a socket, the socket can
+		/// be used for a new connection.
+		///
+		/// Note that simply closing a socket is not sufficient
+		/// to be able to re-use it again.
+
+	Poco::Timespan getMaxTimeout();
+
+private:	
+	SecureSocketImpl(const SecureSocketImpl&);
+	SecureSocketImpl& operator = (const SecureSocketImpl&);
+
+	mutable std::recursive_mutex _mutex;
+	SSL* _pSSL; // GUARDED_BY _mutex
+	Poco::AutoPtr<SocketImpl> _pSocket;
+	Context::Ptr _pContext;
+	bool _needHandshake;
+	std::string _peerHostName;
+	Session::Ptr _pSession;
+	
+	friend class SecureStreamSocketImpl;
+};
+
+
+//
+// inlines
+//
+inline poco_socket_t SecureSocketImpl::sockfd()
+{
+	return _pSocket->sockfd();
+}
+
+
+inline Context::Ptr SecureSocketImpl::context() const
+{
+	return _pContext;
+}
+
+
+inline const std::string& SecureSocketImpl::getPeerHostName() const
+{
+	return _peerHostName;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_SecureSocketImpl_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureStreamSocket.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureStreamSocket.h
new file mode 100644
index 00000000000..059be1bbee5
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureStreamSocket.h
@@ -0,0 +1,272 @@
+//
+// SecureStreamSocket.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLSockets
+// Module:  SecureStreamSocket
+//
+// Definition of the SecureStreamSocket class.
+//
+// Copyright (c) 2006-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_SecureStreamSocket_INCLUDED
+#define NetSSL_SecureStreamSocket_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/StreamSocket.h"
+#include "Poco/Net/Context.h"
+#include "Poco/Net/Session.h"
+#include "Poco/Net/X509Certificate.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API SecureStreamSocket: public StreamSocket
+	/// A subclass of StreamSocket for secure SSL sockets.
+	///
+	/// A few notes about nonblocking IO:
+	/// sendBytes() and receiveBytes() can return a
+	/// negative value when using a nonblocking socket, which means 
+	/// a SSL handshake is currently in progress and more data
+	/// needs to be read or written for the handshake to continue.
+	/// If sendBytes() or receiveBytes() return ERR_SSL_WANT_WRITE,
+	/// sendBytes() must be called as soon as possible (usually, after
+	/// select() indicates that data can be written). Likewise, if
+	/// ERR_SSL_WANT_READ is returned, receiveBytes() must be called
+	/// as soon as data is available for reading (indicated by select()).
+	///
+	/// The SSL handshake is delayed until the first sendBytes() or 
+	/// receiveBytes() operation is performed on the socket. No automatic
+	/// post connection check (checking the peer certificate for a valid
+	/// hostname) is performed when using nonblocking I/O. To manually
+	/// perform peer certificate validation, call verifyPeerCertificate()
+	/// after the SSL handshake has been completed.
+{
+public:
+	enum
+	{
+		ERR_SSL_WANT_READ  = -1,
+		ERR_SSL_WANT_WRITE = -2
+	};
+	
+	SecureStreamSocket();
+		/// Creates an unconnected secure stream socket
+		/// using the default client SSL context.
+		///
+		/// Before sending or receiving data, the socket
+		/// must be connected with a call to connect().
+
+	explicit SecureStreamSocket(Context::Ptr pContext);
+		/// Creates an unconnected secure stream socket
+		/// using the given SSL context.
+		///
+		/// Before sending or receiving data, the socket
+		/// must be connected with a call to connect().
+
+	SecureStreamSocket(Context::Ptr pContext, Session::Ptr pSession);
+		/// Creates an unconnected secure stream socket
+		/// using the given SSL context.
+		///
+		/// Before sending or receiving data, the socket
+		/// must be connected with a call to connect().
+		///
+		/// The given Session is reused, if possible (client session
+		/// caching is enabled for the given Context, and the server
+		/// agrees to reuse the session).
+
+	explicit SecureStreamSocket(const SocketAddress& address);
+		/// Creates a secure stream socket using the default 
+		/// client SSL context and connects it to
+		/// the socket specified by address.
+
+	SecureStreamSocket(const SocketAddress& address, Context::Ptr pContext);
+		/// Creates a secure stream socket using the given 
+		/// client SSL context and connects it to
+		/// the socket specified by address.
+
+	SecureStreamSocket(const SocketAddress& address, Context::Ptr pContext, Session::Ptr pSession);
+		/// Creates a secure stream socket using the given 
+		/// client SSL context and connects it to
+		/// the socket specified by address.
+		///
+		/// The given Session is reused, if possible (client session
+		/// caching is enabled for the given Context, and the server
+		/// agrees to reuse the session).
+
+	SecureStreamSocket(const SocketAddress& address, const std::string& hostName);
+		/// Creates a secure stream socket using the default 
+		/// client SSL context and connects it to
+		/// the socket specified by address.
+		///
+		/// The given host name is used for certificate verification.
+
+	SecureStreamSocket(const SocketAddress& address, const std::string& hostName, Context::Ptr pContext);
+		/// Creates a secure stream socket using the given 
+		/// client SSL context and connects it to
+		/// the socket specified by address.
+		///
+		/// The given host name is used for certificate verification.
+
+	SecureStreamSocket(const SocketAddress& address, const std::string& hostName, Context::Ptr pContext, Session::Ptr pSession);
+		/// Creates a secure stream socket using the given 
+		/// client SSL context and connects it to
+		/// the socket specified by address.
+		///
+		/// The given host name is used for certificate verification.
+		///
+		/// The given Session is reused, if possible (client session
+		/// caching is enabled for the given Context, and the server
+		/// agrees to reuse the session).
+
+	SecureStreamSocket(const Socket& socket);
+		/// Creates the SecureStreamSocket with the SocketImpl
+		/// from another socket. The SocketImpl must be
+		/// a SecureStreamSocketImpl, otherwise an InvalidArgumentException
+		/// will be thrown.
+
+	virtual ~SecureStreamSocket();
+		/// Destroys the StreamSocket.
+
+	SecureStreamSocket& operator = (const Socket& socket);
+		/// Assignment operator.
+		///
+		/// Releases the socket's SocketImpl and
+		/// attaches the SocketImpl from the other socket and
+		/// increments the reference count of the SocketImpl.	
+	
+	bool havePeerCertificate() const;
+		/// Returns true iff the peer has presented a
+		/// certificate.
+
+	X509Certificate peerCertificate() const;
+		/// Returns the peer's X509 certificate.
+		///
+		/// Throws a SSLException if the peer did not
+		/// present a certificate.
+		
+	void setPeerHostName(const std::string& hostName);
+		/// Sets the peer's host name used for certificate validation.
+		
+	const std::string& getPeerHostName() const;
+		/// Returns the peer's host name used for certificate validation.
+
+	static SecureStreamSocket attach(const StreamSocket& streamSocket);
+		/// Creates a SecureStreamSocket over an existing socket
+		/// connection. The given StreamSocket must be connected.
+		/// A SSL handshake will be performed.
+
+	static SecureStreamSocket attach(const StreamSocket& streamSocket, Context::Ptr pContext);
+		/// Creates a SecureStreamSocket over an existing socket
+		/// connection. The given StreamSocket must be connected.
+		/// A SSL handshake will be performed.
+
+	static SecureStreamSocket attach(const StreamSocket& streamSocket, Context::Ptr pContext, Session::Ptr pSession);
+		/// Creates a SecureStreamSocket over an existing socket
+		/// connection. The given StreamSocket must be connected.
+		/// A SSL handshake will be performed.
+		///
+		/// The given Session is reused, if possible (client session
+		/// caching is enabled for the given Context, and the server
+		/// agrees to reuse the session).
+
+	static SecureStreamSocket attach(const StreamSocket& streamSocket, const std::string& peerHostName);
+		/// Creates a SecureStreamSocket over an existing socket
+		/// connection. The given StreamSocket must be connected.
+		/// A SSL handshake will be performed.
+
+	static SecureStreamSocket attach(const StreamSocket& streamSocket, const std::string& peerHostName, Context::Ptr pContext);
+		/// Creates a SecureStreamSocket over an existing socket
+		/// connection. The given StreamSocket must be connected.
+		/// A SSL handshake will be performed.
+
+	static SecureStreamSocket attach(const StreamSocket& streamSocket, const std::string& peerHostName, Context::Ptr pContext, Session::Ptr pSession);
+		/// Creates a SecureStreamSocket over an existing socket
+		/// connection. The given StreamSocket must be connected.
+		/// A SSL handshake will be performed.
+		///
+		/// The given Session is reused, if possible (client session
+		/// caching is enabled for the given Context, and the server
+		/// agrees to reuse the session).
+
+	Context::Ptr context() const;
+		/// Returns the SSL context used by this socket.
+		
+	void setLazyHandshake(bool flag = true);
+		/// Enable lazy SSL handshake. If enabled, the SSL handshake
+		/// will be performed the first time date is sent or
+		/// received over the connection.
+		
+	bool getLazyHandshake() const;
+		/// Returns true if setLazyHandshake(true) has been called.
+		
+	void verifyPeerCertificate();
+		/// Performs post-connect (or post-accept) peer certificate validation,
+		/// using the peer host name set with setPeerHostName(), or the peer's
+		/// IP address string if no peer host name has been set.
+		///
+		/// Should only be used for non-blocking connections, after the
+		/// initial SSL handshake has been performed (see completeHandshake()).
+
+	void verifyPeerCertificate(const std::string& hostName);
+		/// Performs post-connect (or post-accept) peer certificate validation
+		/// using the given host name.
+		///
+		/// Should only be used for non-blocking connections, after the
+		/// initial SSL handshake has been performed (see completeHandshake()).
+		
+	int completeHandshake();
+		/// Completes the SSL handshake.
+		///
+		/// If the SSL connection was the result of an accept(),
+		/// the server-side handshake is completed, otherwise
+		/// a client-side handshake is performed.
+		///
+		/// Returns 1 if the handshake was successful, ERR_SSL_WANT_READ or
+		/// ERR_SSL_WANT_WRITE if more data is required to complete the
+		/// handshake. In this case, completeHandshake() should be called
+		/// again, after the necessary condition has been met.
+
+	Session::Ptr currentSession();
+		/// Returns the SSL session of the current connection,
+		/// for reuse in a future connection (if session caching
+		/// is enabled).
+		///
+		/// If no connection is established, returns null.
+		
+	void useSession(Session::Ptr pSession);
+		/// Sets the SSL session to use for the next
+		/// connection. Setting a previously saved Session
+		/// object is necessary to enable session caching.
+		///
+		/// To remove the currently set session, a null pointer
+		/// can be given.
+		///
+		/// Must be called before connect() to be effective.
+		
+	bool sessionWasReused();
+		/// Returns true iff a reused session was negotiated during
+		/// the handshake.
+		
+	void abort();
+		/// Aborts the SSL connection by closing the underlying
+		/// TCP connection. No orderly SSL shutdown is performed.
+		
+protected:
+	SecureStreamSocket(SocketImpl* pImpl);
+
+	friend class SecureServerSocket;
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_SecureStreamSocket_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureStreamSocketImpl.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureStreamSocketImpl.h
new file mode 100644
index 00000000000..6de70da1663
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/SecureStreamSocketImpl.h
@@ -0,0 +1,303 @@
+//
+// SecureStreamSocketImpl.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLSockets
+// Module:  SecureStreamSocketImpl
+//
+// Definition of the SecureStreamSocketImpl class.
+//
+// Copyright (c) 2006-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_SecureStreamSocketImpl_INCLUDED
+#define NetSSL_SecureStreamSocketImpl_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/SecureSocketImpl.h"
+#include "Poco/Net/StreamSocketImpl.h"
+#include "Poco/Net/Context.h"
+#include "Poco/Net/X509Certificate.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API SecureStreamSocketImpl: public StreamSocketImpl
+	/// This class implements a SSL stream socket.
+{
+public:
+	SecureStreamSocketImpl(Context::Ptr pContext);
+		/// Creates the SecureStreamSocketImpl.
+
+	SecureStreamSocketImpl(StreamSocketImpl* pStreamSocket, Context::Ptr pContext);
+		/// Creates the SecureStreamSocketImpl.
+
+    void setSendTimeout(const Poco::Timespan& timeout);
+    void setReceiveTimeout(const Poco::Timespan& timeout);
+
+	SocketImpl* acceptConnection(SocketAddress& clientAddr);
+		/// Not supported by a SecureStreamSocket.
+		///
+		/// Throws a Poco::InvalidAccessException.
+
+	void connect(const SocketAddress& address);
+		/// Initializes the socket and establishes a connection to
+		/// the TCP server at the given address.
+		///
+		/// Can also be used for UDP sockets. In this case, no
+		/// connection is established. Instead, incoming and outgoing
+		/// packets are restricted to the specified address.
+
+	void connect(const SocketAddress& address, const Poco::Timespan& timeout);
+		/// Initializes the socket, sets the socket timeout and
+		/// establishes a connection to the TCP server at the given address.
+
+	void connectNB(const SocketAddress& address);
+		/// Initializes the socket and establishes a connection to
+		/// the TCP server at the given address. Prior to opening the
+		/// connection the socket is set to nonblocking mode.
+		
+	void bind(const SocketAddress& address, bool reuseAddress = false, bool reusePort = false);
+		/// Not supported by a SecureStreamSocket.
+		///
+		/// Throws a Poco::InvalidAccessException.
+		
+	void listen(int backlog = 64);
+		/// Not supported by a SecureStreamSocket.
+		///
+		/// Throws a Poco::InvalidAccessException.
+
+	void close();
+		/// Close the socket.
+	
+	int sendBytes(const void* buffer, int length, int flags = 0);
+		/// Sends the contents of the given buffer through
+		/// the socket. Any specified flags are ignored.
+		///
+		/// Returns the number of bytes sent, which may be
+		/// less than the number of bytes specified.
+	
+	int receiveBytes(void* buffer, int length, int flags = 0);
+		/// Receives data from the socket and stores it
+		/// in buffer. Up to length bytes are received.
+		///
+		/// Returns the number of bytes received.
+	
+	int sendTo(const void* buffer, int length, const SocketAddress& address, int flags = 0);
+		/// Not supported by a SecureStreamSocket.
+		///
+		/// Throws a Poco::InvalidAccessException.
+	
+	int receiveFrom(void* buffer, int length, SocketAddress& address, int flags = 0);
+		/// Not supported by a SecureStreamSocket.
+		///
+		/// Throws a Poco::InvalidAccessException.
+	
+	void sendUrgent(unsigned char data);
+		/// Not supported by a SecureStreamSocket.
+		///
+		/// Throws a Poco::InvalidAccessException.
+
+	int available();
+		/// Returns the number of bytes available that can be read
+		/// without causing the socket to block.
+		///
+		/// For an SSL connection, returns the number of bytes that
+		/// can be read from the currently buffered SSL record,
+		/// before a new record is read from the underlying socket.
+
+	void shutdownReceive();
+		/// Shuts down the receiving part of the socket connection.
+		///
+		/// Since SSL does not support a half shutdown, this does
+		/// nothing.
+		
+	void shutdownSend();
+		/// Shuts down the receiving part of the socket connection.
+		///
+		/// Since SSL does not support a half shutdown, this does
+		/// nothing.
+		
+	void shutdown();
+		/// Shuts down the SSL connection.
+		
+	void abort();
+		/// Aborts the connection by closing the underlying
+		/// TCP connection. No orderly SSL shutdown is performed.
+		
+	bool secure() const;
+		/// Returns true iff the socket's connection is secure
+		/// (using SSL or TLS).
+
+	void setPeerHostName(const std::string& hostName);
+		/// Sets the peer host name for certificate validation purposes.
+		
+	const std::string& getPeerHostName() const;
+		/// Returns the peer host name.
+
+	bool havePeerCertificate() const;
+		/// Returns true iff the peer has presented a
+		/// certificate.
+
+	X509Certificate peerCertificate() const;
+		/// Returns the peer's X509 certificate.
+		///
+		/// Throws a SSLException if the peer did not
+		/// present a certificate.
+		
+	Context::Ptr context() const;
+		/// Returns the SSL context used by this socket.
+
+	void setLazyHandshake(bool flag = true);
+		/// Enable lazy SSL handshake. If enabled, the SSL handshake
+		/// will be performed the first time date is sent or
+		/// received over the connection.
+		
+	bool getLazyHandshake() const;
+		/// Returns true if setLazyHandshake(true) has been called.
+
+	void verifyPeerCertificate();
+		/// Performs post-connect (or post-accept) peer certificate validation,
+		/// using the peer's IP address as host name.
+
+	void verifyPeerCertificate(const std::string& hostName);
+		/// Performs post-connect (or post-accept) peer certificate validation
+		/// using the given host name.
+
+	int completeHandshake();
+		/// Completes the SSL handshake.
+		///
+		/// If the SSL connection was the result of an accept(),
+		/// the server-side handshake is completed, otherwise
+		/// a client-side handshake is performed.
+
+	Session::Ptr currentSession();
+		/// Returns the SSL session of the current connection,
+		/// for reuse in a future connection (if session caching
+		/// is enabled).
+		///
+		/// If no connection is established, returns null.
+		
+	void useSession(Session::Ptr pSession);
+		/// Sets the SSL session to use for the next
+		/// connection. Setting a previously saved Session
+		/// object is necessary to enable session caching.
+		///
+		/// To remove the currently set session, a null pointer
+		/// can be given.
+		///
+		/// Must be called before connect() to be effective.
+		
+	bool sessionWasReused();
+		/// Returns true iff a reused session was negotiated during
+		/// the handshake.
+		
+protected:
+	void acceptSSL();
+		/// Performs a SSL server-side handshake.
+	
+	void connectSSL();
+		/// Performs a SSL client-side handshake on an already connected TCP socket.
+	
+	~SecureStreamSocketImpl();
+		/// Destroys the SecureStreamSocketImpl.
+
+	static int lastError();
+	static void error();
+	static void error(const std::string& arg);
+	static void error(int code);
+	static void error(int code, const std::string& arg);
+
+private:
+	SecureStreamSocketImpl(const SecureStreamSocketImpl&);
+	SecureStreamSocketImpl& operator = (const SecureStreamSocketImpl&);
+
+    StreamSocketImpl * underlying_socket;
+	SecureSocketImpl _impl;
+	bool             _lazyHandshake;
+
+	friend class SecureSocketImpl;
+	friend class SecureStreamSocket;
+};
+
+
+//
+// inlines
+//
+inline const std::string& SecureStreamSocketImpl::getPeerHostName() const
+{
+	return _impl.getPeerHostName();
+}
+
+
+inline void SecureStreamSocketImpl::setPeerHostName(const std::string& peerHostName)
+{
+	_impl.setPeerHostName(peerHostName);
+}
+
+
+inline Context::Ptr SecureStreamSocketImpl::context() const
+{
+	return _impl.context();
+}
+
+
+inline Session::Ptr SecureStreamSocketImpl::currentSession()
+{
+	return _impl.currentSession();
+}
+
+	
+inline void SecureStreamSocketImpl::useSession(Session::Ptr pSession)
+{
+	_impl.useSession(pSession);
+}
+
+	
+inline bool SecureStreamSocketImpl::sessionWasReused()
+{
+	return _impl.sessionWasReused();
+}
+
+
+inline int SecureStreamSocketImpl::lastError()
+{
+	return SocketImpl::lastError();
+}
+
+
+inline void SecureStreamSocketImpl::error()
+{
+	return SocketImpl::error();
+}
+
+
+inline void SecureStreamSocketImpl::error(const std::string& arg)
+{
+	return SocketImpl::error(arg);
+}
+
+
+inline void SecureStreamSocketImpl::error(int code)
+{
+	return SocketImpl::error(code);
+}
+
+
+inline void SecureStreamSocketImpl::error(int code, const std::string& arg)
+{
+	return SocketImpl::error(code, arg);
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_SecureStreamSocketImpl_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/Session.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/Session.h
new file mode 100644
index 00000000000..cc9b2db7463
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/Session.h
@@ -0,0 +1,79 @@
+//
+// Session.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  Session
+//
+// Definition of the Session class.
+//
+// Copyright (c) 2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_Session_INCLUDED
+#define NetSSL_Session_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include <openssl/ssl.h>
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API Session: public Poco::RefCountedObject
+	/// This class encapsulates a SSL session object
+	/// used with session caching on the client side.
+	///
+	/// For session caching to work, a client must
+	/// save the session object from an existing connection,
+	/// if it wants to reuse it with a future connection.
+{
+public:
+	typedef Poco::AutoPtr<Session> Ptr;
+
+	SSL_SESSION* sslSession() const;
+		/// Returns the stored OpenSSL SSL_SESSION object.
+
+protected:	
+	Session(SSL_SESSION* pSession);
+		/// Creates a new Session object, using the given
+		/// SSL_SESSION object. 
+		/// 
+		/// The SSL_SESSION's reference count is not changed.
+
+	~Session();
+		/// Destroys the Session.
+		///
+		/// Calls SSL_SESSION_free() on the stored
+		/// SSL_SESSION object.
+
+private:
+	Session();
+
+	SSL_SESSION* _pSession;
+	
+	friend class SecureSocketImpl;
+};
+
+
+//
+// inlines
+//
+inline SSL_SESSION* Session::sslSession() const
+{
+	return _pSession;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_Session_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/Utility.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/Utility.h
new file mode 100644
index 00000000000..b1d0073cfa6
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/Utility.h
@@ -0,0 +1,52 @@
+//
+// Utility.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  Utility
+//
+// Definition of the Utility class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_Utility_INCLUDED
+#define NetSSL_Utility_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/Context.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API Utility
+	/// This class provides various helper functions for working
+	/// with the OpenSSL library.
+{
+public:
+	static Context::VerificationMode convertVerificationMode(const std::string& verMode);
+		/// Non-case sensitive conversion of a string to a VerificationMode enum.
+		/// If verMode is illegal an InvalidArgumentException is thrown.
+
+	static std::string convertCertificateError(long errCode);
+		/// Converts an SSL certificate handling error code into an error message.
+
+	static std::string getLastError();
+		/// Returns the last error from the error stack
+
+	static void clearErrorStack();
+		/// Clears the error stack
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_Utility_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/VerificationErrorArgs.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/VerificationErrorArgs.h
new file mode 100644
index 00000000000..55ef897bb7a
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/VerificationErrorArgs.h
@@ -0,0 +1,108 @@
+//
+// VerificationErrorArgs.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  VerificationErrorArgs
+//
+// Definition of the VerificationErrorArgs class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_VerificationErrorArgs_INCLUDED
+#define NetSSL_VerificationErrorArgs_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/X509Certificate.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+class NetSSL_API VerificationErrorArgs
+	/// A utility class for certificate error handling.
+{
+public:
+	VerificationErrorArgs(const X509Certificate& cert, int errDepth, int errNum, const std::string& errMsg);
+		/// Creates the VerificationErrorArgs. _ignoreError is per default set to false.
+
+	~VerificationErrorArgs();
+		/// Destroys the VerificationErrorArgs.
+
+	const X509Certificate& certificate() const;
+		/// Returns the certificate that caused the error.
+
+	int errorDepth() const;
+		/// Returns the position of the certificate in the certificate chain.
+
+	int errorNumber() const;
+		/// Returns the id of the error
+
+	const std::string& errorMessage() const;
+		/// Returns the textual presentation of the errorNumber.
+
+	void setIgnoreError(bool ignoreError);
+		/// setIgnoreError to true, if a verification error is judged non-fatal by the user.
+
+	bool getIgnoreError() const;
+		/// returns the value of _ignoreError
+
+private:
+	X509Certificate	_cert;
+	int             _errorDepth;
+	int             _errorNumber;
+	std::string     _errorMessage; /// Textual representation of the _errorNumber
+	bool            _ignoreError;
+};
+
+
+//
+// inlines
+//
+inline const X509Certificate& VerificationErrorArgs::certificate() const
+{
+	return _cert;
+}
+
+
+inline int VerificationErrorArgs::errorDepth() const
+{
+	return _errorDepth;
+}
+
+
+inline int VerificationErrorArgs::errorNumber() const
+{
+	return _errorNumber;
+}
+
+
+inline const std::string& VerificationErrorArgs::errorMessage() const
+{
+	return _errorMessage;
+}
+
+
+inline void VerificationErrorArgs::setIgnoreError(bool ignoreError)
+{
+	_ignoreError = ignoreError;
+}
+
+
+inline bool VerificationErrorArgs::getIgnoreError() const
+{
+	return _ignoreError;
+}
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_VerificationErrorArgs_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/include/Poco/Net/X509Certificate.h b/base/poco/NetSSL_OpenSSL/include/Poco/Net/X509Certificate.h
new file mode 100644
index 00000000000..a810b29457e
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/include/Poco/Net/X509Certificate.h
@@ -0,0 +1,102 @@
+//
+// X509Certificate.h
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  X509Certificate
+//
+// Definition of the X509Certificate class.
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef NetSSL_X509Certificate_INCLUDED
+#define NetSSL_X509Certificate_INCLUDED
+
+
+#include "Poco/Net/NetSSL.h"
+#include "Poco/Net/SocketDefs.h"
+#include "Poco/Crypto/X509Certificate.h"
+#include "Poco/DateTime.h"
+#include "Poco/SharedPtr.h"
+#include <set>
+
+
+namespace Poco {
+namespace Net {
+
+
+class HostEntry;
+
+
+class NetSSL_API X509Certificate: public Poco::Crypto::X509Certificate
+	/// This class extends Poco::Crypto::X509Certificate with the
+	/// feature to validate a certificate.
+{
+public:
+	explicit X509Certificate(std::istream& istr);
+		/// Creates the X509Certificate object by reading
+		/// a certificate in PEM format from a stream.
+
+	explicit X509Certificate(const std::string& path);
+		/// Creates the X509Certificate object by reading
+		/// a certificate in PEM format from a file.
+
+	explicit X509Certificate(X509* pCert);
+		/// Creates the X509Certificate from an existing
+		/// OpenSSL certificate. Ownership is taken of 
+		/// the certificate.
+
+	X509Certificate(X509* pCert, bool shared);
+		/// Creates the X509Certificate from an existing
+		/// OpenSSL certificate. Ownership is taken of 
+		/// the certificate. If shared is true, the 
+		/// certificate's reference count is incremented.
+
+	X509Certificate(const Poco::Crypto::X509Certificate& cert);
+		/// Creates the certificate by copying another one.
+
+	X509Certificate& operator = (const Poco::Crypto::X509Certificate& cert);
+		/// Assigns a certificate.
+
+	~X509Certificate();
+		/// Destroys the X509Certificate.
+
+	bool verify(const std::string& hostName) const;
+		/// Verifies the validity of the certificate against the host name.
+		///
+		/// For this check to be successful, the certificate must contain
+		/// a domain name that matches the domain name
+		/// of the host.
+		/// 
+		/// Returns true if verification succeeded, or false otherwise.
+		
+	static bool verify(const Poco::Crypto::X509Certificate& cert, const std::string& hostName);
+		/// Verifies the validity of the certificate against the host name.
+		///
+		/// For this check to be successful, the certificate must contain
+		/// a domain name that matches the domain name
+		/// of the host.
+		///
+		/// Returns true if verification succeeded, or false otherwise.
+		
+protected:
+	static bool containsWildcards(const std::string& commonName);
+	static bool matchWildcard(const std::string& alias, const std::string& hostName);
+	
+private:
+	enum
+	{
+		NAME_BUFFER_SIZE = 256
+	};
+};
+
+
+} } // namespace Poco::Net
+
+
+#endif // NetSSL_X509Certificate_INCLUDED
diff --git a/base/poco/NetSSL_OpenSSL/src/AcceptCertificateHandler.cpp b/base/poco/NetSSL_OpenSSL/src/AcceptCertificateHandler.cpp
new file mode 100644
index 00000000000..84017f7c343
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/AcceptCertificateHandler.cpp
@@ -0,0 +1,38 @@
+//
+// AcceptCertificateHandler.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  AcceptCertificateHandler
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/AcceptCertificateHandler.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+AcceptCertificateHandler::AcceptCertificateHandler(bool server): InvalidCertificateHandler(server)
+{
+}
+
+
+AcceptCertificateHandler::~AcceptCertificateHandler()
+{
+}
+
+
+void AcceptCertificateHandler::onInvalidCertificate(const void*, VerificationErrorArgs& errorCert)
+{
+	errorCert.setIgnoreError(true);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/CertificateHandlerFactory.cpp b/base/poco/NetSSL_OpenSSL/src/CertificateHandlerFactory.cpp
new file mode 100644
index 00000000000..8c517748be7
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/CertificateHandlerFactory.cpp
@@ -0,0 +1,44 @@
+//
+// CertificateHandlerFactory.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  CertificateHandlerFactory
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/CertificateHandlerFactory.h"
+#include "Poco/Net/SSLManager.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+CertificateHandlerFactory::CertificateHandlerFactory()
+{
+}
+
+
+CertificateHandlerFactory::~CertificateHandlerFactory()
+{
+}
+
+
+CertificateHandlerFactoryRegistrar::CertificateHandlerFactoryRegistrar(const std::string& name, CertificateHandlerFactory* pFactory)
+{
+	SSLManager::instance().certificateHandlerFactoryMgr().setFactory(name, pFactory);
+}
+
+
+CertificateHandlerFactoryRegistrar::~CertificateHandlerFactoryRegistrar()
+{
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/CertificateHandlerFactoryMgr.cpp b/base/poco/NetSSL_OpenSSL/src/CertificateHandlerFactoryMgr.cpp
new file mode 100644
index 00000000000..a89bbea11f2
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/CertificateHandlerFactoryMgr.cpp
@@ -0,0 +1,69 @@
+//
+// CertificateHandlerFactoryMgr.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  CertificateHandlerFactoryMgr
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/CertificateHandlerFactoryMgr.h"
+#include "Poco/Net/ConsoleCertificateHandler.h"
+#include "Poco/Net/AcceptCertificateHandler.h"
+#include "Poco/Net/RejectCertificateHandler.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+CertificateHandlerFactoryMgr::CertificateHandlerFactoryMgr()
+{
+	setFactory("ConsoleCertificateHandler", new CertificateHandlerFactoryImpl<ConsoleCertificateHandler>());
+	setFactory("AcceptCertificateHandler", new CertificateHandlerFactoryImpl<AcceptCertificateHandler>());
+	setFactory("RejectCertificateHandler", new CertificateHandlerFactoryImpl<RejectCertificateHandler>());
+}
+
+
+CertificateHandlerFactoryMgr::~CertificateHandlerFactoryMgr()
+{
+}
+
+
+void CertificateHandlerFactoryMgr::setFactory(const std::string& name, CertificateHandlerFactory* pFactory)
+{
+	bool success = _factories.insert(make_pair(name, Poco::SharedPtr<CertificateHandlerFactory>(pFactory))).second;
+	if (!success)
+		delete pFactory;
+	poco_assert(success);
+}
+		
+
+bool CertificateHandlerFactoryMgr::hasFactory(const std::string& name) const
+{
+	return _factories.find(name) != _factories.end();
+}
+		
+	
+const CertificateHandlerFactory* CertificateHandlerFactoryMgr::getFactory(const std::string& name) const
+{
+	FactoriesMap::const_iterator it = _factories.find(name);
+	if (it != _factories.end())
+		return it->second;
+	else
+		return 0;
+}
+
+
+void CertificateHandlerFactoryMgr::removeFactory(const std::string& name)
+{
+	_factories.erase(name);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/ConsoleCertificateHandler.cpp b/base/poco/NetSSL_OpenSSL/src/ConsoleCertificateHandler.cpp
new file mode 100644
index 00000000000..db64752e70c
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/ConsoleCertificateHandler.cpp
@@ -0,0 +1,53 @@
+//
+// ConsoleCertificateHandler.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  ConsoleCertificateHandler
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/ConsoleCertificateHandler.h"
+#include <iostream>
+
+
+namespace Poco {
+namespace Net {
+
+
+ConsoleCertificateHandler::ConsoleCertificateHandler(bool server): InvalidCertificateHandler(server)
+{
+}
+
+
+ConsoleCertificateHandler::~ConsoleCertificateHandler()
+{
+}
+
+
+void ConsoleCertificateHandler::onInvalidCertificate(const void*, VerificationErrorArgs& errorCert)
+{
+	const X509Certificate& aCert = errorCert.certificate();
+	std::cout << "\n";
+	std::cout << "WARNING: Certificate verification failed\n";
+	std::cout << "----------------------------------------\n";
+	std::cout << "Issuer Name:  " << aCert.issuerName() << "\n";
+	std::cout << "Subject Name: " << aCert.subjectName() << "\n\n";
+	std::cout << "The certificate yielded the error: " << errorCert.errorMessage() << "\n\n";
+	std::cout << "The error occurred in the certificate chain at position " << errorCert.errorDepth() << "\n";
+	std::cout << "Accept the certificate (y,n)? ";
+	char c = 0;
+	std::cin >> c;
+	if (c == 'y' || c == 'Y')
+		errorCert.setIgnoreError(true);
+	else
+		errorCert.setIgnoreError(false);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/Context.cpp b/base/poco/NetSSL_OpenSSL/src/Context.cpp
new file mode 100644
index 00000000000..ca220c40a33
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/Context.cpp
@@ -0,0 +1,733 @@
+//
+// Context.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  Context
+//
+// Copyright (c) 2006-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/Context.h"
+#include "Poco/Net/SSLManager.h"
+#include "Poco/Net/SSLException.h"
+#include "Poco/Net/Utility.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include "Poco/File.h"
+#include "Poco/Path.h"
+#include "Poco/DirectoryIterator.h"
+#include "Poco/RegularExpression.h"
+#include "Poco/Timestamp.h"
+#include <openssl/bio.h>
+#include <openssl/err.h>
+#include <openssl/ssl.h>
+#include <openssl/x509v3.h>
+
+#if defined(BORINGSSL_API_VERSION)
+#if BORINGSSL_API_VERSION <= 9
+#define BORINGSSL_DEPRECATED 1
+#endif
+#endif
+
+namespace Poco {
+namespace Net {
+
+
+Context::Params::Params():
+	verificationMode(VERIFY_RELAXED),
+	verificationDepth(9),
+	loadDefaultCAs(false),
+	cipherList("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH")
+{
+}
+
+
+Context::Context(Usage usage, const Params& params):
+	_usage(usage),
+	_mode(params.verificationMode),
+	_pSSLContext(0),
+	_extendedCertificateVerification(true)
+{
+	init(params);
+}
+
+
+Context::Context(
+	Usage usage,
+	const std::string& privateKeyFile,
+	const std::string& certificateFile,
+	const std::string& caLocation,
+	VerificationMode verificationMode,
+	int verificationDepth,
+	bool loadDefaultCAs,
+	const std::string& cipherList):
+	_usage(usage),
+	_mode(verificationMode),
+	_pSSLContext(0),
+	_extendedCertificateVerification(true)
+{
+	Params params;
+	params.privateKeyFile = privateKeyFile;
+	params.certificateFile = certificateFile;
+	params.caLocation = caLocation;
+	params.verificationMode = verificationMode;
+	params.verificationDepth = verificationDepth;
+	params.loadDefaultCAs = loadDefaultCAs;
+	params.cipherList = cipherList;
+	init(params);
+}
+
+
+Context::Context(
+	Usage usage,
+	const std::string& caLocation,
+	VerificationMode verificationMode,
+	int verificationDepth,
+	bool loadDefaultCAs,
+	const std::string& cipherList):
+	_usage(usage),
+	_mode(verificationMode),
+	_pSSLContext(0),
+	_extendedCertificateVerification(true)
+{
+	Params params;
+	params.caLocation = caLocation;
+	params.verificationMode = verificationMode;
+	params.verificationDepth = verificationDepth;
+	params.loadDefaultCAs = loadDefaultCAs;
+	params.cipherList = cipherList;
+	init(params);
+}
+
+
+Context::~Context()
+{
+	try
+	{
+		SSL_CTX_free(_pSSLContext);
+		Poco::Crypto::OpenSSLInitializer::uninitialize();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+static bool poco_dir_cert(const std::string & dir)
+{
+	if (dir.empty())
+		return false;
+
+	File f(dir);
+	return f.exists() && f.isDirectory();
+}
+
+static bool poco_dir_contains_certs(const std::string & dir)
+{
+	RegularExpression re("^[a-fA-F0-9]{8}\\.\\d$");
+	try
+	{
+		for (DirectoryIterator it(dir), end; it != end; ++it)
+			if (re.match(Path(it->path()).getFileName()))
+				return true;
+	}
+	catch (Poco::Exception& exc) {}
+
+	return false;
+}
+
+static bool poco_file_cert(const std::string & file)
+{
+	if (file.empty())
+		return false;
+
+	File f(file);
+	return f.exists() && f.isFile();
+}
+
+static int poco_ssl_probe_and_set_default_ca_location(SSL_CTX *ctx, Context::CAPaths &caPaths)
+{
+	/* The probe paths are based on:
+		* https://www.happyassassin.net/posts/2015/01/12/a-note-about-ssltls-trusted-certificate-stores-and-platforms/
+		* Golang's crypto probing paths:
+		*   https://golang.org/search?q=certFiles   and certDirectories
+		*/
+	static const char *paths[] = {
+		"/etc/pki/tls/certs/ca-bundle.crt",
+		"/etc/ssl/certs/ca-bundle.crt",
+		"/etc/pki/tls/certs/ca-bundle.trust.crt",
+		"/etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem",
+
+		"/etc/ssl/ca-bundle.pem",
+		"/etc/pki/tls/cacert.pem",
+		"/etc/ssl/cert.pem",
+		"/etc/ssl/cacert.pem",
+
+		"/etc/certs/ca-certificates.crt",
+		"/etc/ssl/certs/ca-certificates.crt",
+
+		"/etc/ssl/certs",
+
+		"/usr/local/etc/ssl/cert.pem",
+		"/usr/local/etc/ssl/cacert.pem",
+
+		"/usr/local/etc/ssl/certs/cert.pem",
+		"/usr/local/etc/ssl/certs/cacert.pem",
+
+		/* BSD */
+		"/usr/local/share/certs/ca-root-nss.crt",
+		"/etc/openssl/certs/ca-certificates.crt",
+#ifdef __APPLE__
+		"/private/etc/ssl/cert.pem",
+		"/private/etc/ssl/certs",
+		"/usr/local/etc/openssl@1.1/cert.pem",
+		"/usr/local/etc/openssl@1.0/cert.pem",
+		"/usr/local/etc/openssl/certs",
+		"/System/Library/OpenSSL",
+#endif
+#ifdef _AIX
+		"/var/ssl/certs/ca-bundle.crt",
+#endif
+	};
+
+	const char * dir = nullptr;
+	for (const char * path : paths)
+	{
+		if (poco_dir_cert(path))
+		{
+			if (dir == nullptr)
+				dir = path;
+
+			if (poco_dir_contains_certs(path) && SSL_CTX_load_verify_locations(ctx, NULL, path))
+			{
+				caPaths.caDefaultDir = path;
+				return 1;
+			}
+		}
+
+		if (SSL_CTX_load_verify_locations(ctx, path, NULL))
+		{
+			caPaths.caDefaultFile = path;
+			return 1;
+		}
+	}
+
+	if (dir != nullptr)
+	{
+		caPaths.caDefaultDir = dir;
+		return SSL_CTX_load_verify_locations(ctx, NULL, dir);
+	}
+
+	return 0;
+}
+
+
+void Context::init(const Params& params)
+{
+	Poco::Crypto::OpenSSLInitializer::initialize();
+
+	createSSLContext();
+
+	try
+	{
+		int errCode = 0;
+		if (!params.caLocation.empty())
+		{
+			Poco::File aFile(params.caLocation);
+			if (aFile.isDirectory())
+				errCode = SSL_CTX_load_verify_locations(_pSSLContext, 0, Poco::Path::transcode(params.caLocation).c_str());
+			else
+				errCode = SSL_CTX_load_verify_locations(_pSSLContext, Poco::Path::transcode(params.caLocation).c_str(), 0);
+			if (errCode != 1)
+			{
+				std::string msg = Utility::getLastError();
+				throw SSLContextException(std::string("Cannot load CA file/directory at ") + params.caLocation, msg);
+			}
+			_caPaths.caLocation = params.caLocation;
+		}
+
+		if (params.loadDefaultCAs)
+		{
+			const char * dir = getenv(X509_get_default_cert_dir_env());
+			if (!dir)
+				dir = X509_get_default_cert_dir();
+
+			const char * file = getenv(X509_get_default_cert_file_env());
+			if (!file)
+				file = X509_get_default_cert_file();
+
+			if (poco_file_cert(file))
+			{
+				_caPaths.caDefaultFile = file;
+				errCode = SSL_CTX_set_default_verify_paths(_pSSLContext);
+			}
+			else
+			{
+				if (poco_dir_cert(dir))
+				{
+					errCode = 0;
+					if (!poco_dir_contains_certs(dir))
+						errCode = poco_ssl_probe_and_set_default_ca_location(_pSSLContext, _caPaths);
+
+					if (errCode == 0)
+					{
+						errCode = SSL_CTX_set_default_verify_paths(_pSSLContext);
+						_caPaths.caDefaultDir = dir;
+					}
+				}
+				else
+					errCode = poco_ssl_probe_and_set_default_ca_location(_pSSLContext, _caPaths);
+			}
+
+			if (errCode != 1)
+			{
+				std::string msg = Utility::getLastError();
+				throw SSLContextException("Cannot load default CA certificates", msg);
+			}
+		}
+
+		if (!params.privateKeyFile.empty())
+		{
+			errCode = SSL_CTX_use_PrivateKey_file(_pSSLContext, Poco::Path::transcode(params.privateKeyFile).c_str(), SSL_FILETYPE_PEM);
+			if (errCode != 1)
+			{
+				std::string msg = Utility::getLastError();
+				throw SSLContextException(std::string("Error loading private key from file ") + params.privateKeyFile, msg);
+			}
+		}
+
+		if (!params.certificateFile.empty())
+		{
+			errCode = SSL_CTX_use_certificate_chain_file(_pSSLContext, Poco::Path::transcode(params.certificateFile).c_str());
+			if (errCode != 1)
+			{
+				std::string errMsg = Utility::getLastError();
+				throw SSLContextException(std::string("Error loading certificate from file ") + params.certificateFile, errMsg);
+			}
+		}
+
+		if (isForServerUse())
+			SSL_CTX_set_verify(_pSSLContext, params.verificationMode, &SSLManager::verifyServerCallback);
+		else
+			SSL_CTX_set_verify(_pSSLContext, params.verificationMode, &SSLManager::verifyClientCallback);
+
+		SSL_CTX_set_cipher_list(_pSSLContext, params.cipherList.c_str());
+		SSL_CTX_set_verify_depth(_pSSLContext, params.verificationDepth);
+		SSL_CTX_set_mode(_pSSLContext, SSL_MODE_AUTO_RETRY);
+		SSL_CTX_set_session_cache_mode(_pSSLContext, SSL_SESS_CACHE_OFF);
+
+		initDH(params.dhParamsFile);
+		initECDH(params.ecdhCurve);
+	}
+	catch (...)
+	{
+		SSL_CTX_free(_pSSLContext);
+		throw;
+	}
+}
+
+
+void Context::useCertificate(const Poco::Crypto::X509Certificate& certificate)
+{
+	int errCode = SSL_CTX_use_certificate(_pSSLContext, const_cast<X509*>(certificate.certificate()));
+	if (errCode != 1)
+	{
+		std::string msg = Utility::getLastError();
+		throw SSLContextException("Cannot set certificate for Context", msg);
+	}
+}
+
+
+void Context::addChainCertificate(const Poco::Crypto::X509Certificate& certificate)
+{
+	X509* pCert = certificate.dup();
+	int errCode = SSL_CTX_add_extra_chain_cert(_pSSLContext, pCert);
+	if (errCode != 1)
+	{
+		X509_free(pCert);
+		std::string msg = Utility::getLastError();
+		throw SSLContextException("Cannot add chain certificate to Context", msg);
+	}
+}
+
+
+void Context::addCertificateAuthority(const Crypto::X509Certificate &certificate)
+{
+	if (X509_STORE* store = SSL_CTX_get_cert_store(_pSSLContext))
+	{
+		int errCode = X509_STORE_add_cert(store, const_cast<X509*>(certificate.certificate()));
+		if (errCode != 1)
+		{
+			std::string msg = Utility::getLastError();
+			throw SSLContextException("Cannot add certificate authority to Context", msg);
+		}
+	}
+	else
+	{
+		std::string msg = Utility::getLastError();
+		throw SSLContextException("Cannot add certificate authority to Context", msg);
+	}
+}
+
+
+void Context::usePrivateKey(const Poco::Crypto::RSAKey& key)
+{
+	int errCode = SSL_CTX_use_RSAPrivateKey(_pSSLContext, key.impl()->getRSA());
+	if (errCode != 1)
+	{
+		std::string msg = Utility::getLastError();
+		throw SSLContextException("Cannot set private key for Context", msg);
+	}
+}
+
+
+void Context::enableSessionCache(bool flag)
+{
+	if (flag)
+	{
+		SSL_CTX_set_session_cache_mode(_pSSLContext, isForServerUse() ? SSL_SESS_CACHE_SERVER : SSL_SESS_CACHE_CLIENT);
+	}
+	else
+	{
+		SSL_CTX_set_session_cache_mode(_pSSLContext, SSL_SESS_CACHE_OFF);
+	}
+}
+
+
+void Context::enableSessionCache(bool flag, const std::string& sessionIdContext)
+{
+	poco_assert (isForServerUse());
+
+	if (flag)
+	{
+		SSL_CTX_set_session_cache_mode(_pSSLContext, SSL_SESS_CACHE_SERVER);
+	}
+	else
+	{
+		SSL_CTX_set_session_cache_mode(_pSSLContext, SSL_SESS_CACHE_OFF);
+	}
+
+	unsigned length = static_cast<unsigned>(sessionIdContext.length());
+	if (length > SSL_MAX_SSL_SESSION_ID_LENGTH) length = SSL_MAX_SSL_SESSION_ID_LENGTH;
+	int rc = SSL_CTX_set_session_id_context(_pSSLContext, reinterpret_cast<const unsigned char*>(sessionIdContext.data()), length);
+	if (rc != 1) throw SSLContextException("cannot set session ID context");
+}
+
+
+bool Context::sessionCacheEnabled() const
+{
+	return SSL_CTX_get_session_cache_mode(_pSSLContext) != SSL_SESS_CACHE_OFF;
+}
+
+
+void Context::setSessionCacheSize(std::size_t size)
+{
+	poco_assert (isForServerUse());
+
+	SSL_CTX_sess_set_cache_size(_pSSLContext, static_cast<long>(size));
+}
+
+
+std::size_t Context::getSessionCacheSize() const
+{
+	poco_assert (isForServerUse());
+
+	return static_cast<std::size_t>(SSL_CTX_sess_get_cache_size(_pSSLContext));
+}
+
+
+void Context::setSessionTimeout(long seconds)
+{
+	poco_assert (isForServerUse());
+
+	SSL_CTX_set_timeout(_pSSLContext, seconds);
+}
+
+
+long Context::getSessionTimeout() const
+{
+	poco_assert (isForServerUse());
+
+	return SSL_CTX_get_timeout(_pSSLContext);
+}
+
+
+void Context::flushSessionCache()
+{
+	poco_assert (isForServerUse());
+
+	Poco::Timestamp now;
+	SSL_CTX_flush_sessions(_pSSLContext, static_cast<long>(now.epochTime()));
+}
+
+
+void Context::enableExtendedCertificateVerification(bool flag)
+{
+	_extendedCertificateVerification = flag;
+}
+
+
+void Context::disableStatelessSessionResumption()
+{
+#if defined(SSL_OP_NO_TICKET)
+	SSL_CTX_set_options(_pSSLContext, SSL_OP_NO_TICKET);
+#endif
+}
+
+
+void Context::disableProtocols(int protocols)
+{
+	if (protocols & PROTO_SSLV2)
+	{
+#if defined(SSL_OP_NO_SSLv2)
+		SSL_CTX_set_options(_pSSLContext, SSL_OP_NO_SSLv2);
+#endif
+	}
+	if (protocols & PROTO_SSLV3)
+	{
+#if defined(SSL_OP_NO_SSLv3)
+		SSL_CTX_set_options(_pSSLContext, SSL_OP_NO_SSLv3);
+#endif
+	}
+	if (protocols & PROTO_TLSV1)
+	{
+#if defined(SSL_OP_NO_TLSv1)
+		SSL_CTX_set_options(_pSSLContext, SSL_OP_NO_TLSv1);
+#endif
+	}
+	if (protocols & PROTO_TLSV1_1)
+	{
+#if defined(SSL_OP_NO_TLSv1_1)
+		SSL_CTX_set_options(_pSSLContext, SSL_OP_NO_TLSv1_1);
+#endif
+	}
+	if (protocols & PROTO_TLSV1_2)
+	{
+#if defined(SSL_OP_NO_TLSv1_2)
+		SSL_CTX_set_options(_pSSLContext, SSL_OP_NO_TLSv1_2);
+#endif
+	}
+}
+
+
+void Context::preferServerCiphers()
+{
+#if defined(SSL_OP_CIPHER_SERVER_PREFERENCE)
+	SSL_CTX_set_options(_pSSLContext, SSL_OP_CIPHER_SERVER_PREFERENCE);
+#endif
+}
+
+const Context::CAPaths &Context::getCAPaths()
+{
+	return _caPaths;
+}
+
+
+void Context::createSSLContext()
+{
+	if (SSLManager::isFIPSEnabled())
+	{
+		_pSSLContext = SSL_CTX_new(TLSv1_method());
+	}
+	else
+	{
+		switch (_usage)
+		{
+		case CLIENT_USE:
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+			_pSSLContext = SSL_CTX_new(TLS_client_method());
+#else
+			_pSSLContext = SSL_CTX_new(SSLv23_client_method());
+#endif
+			break;
+		case SERVER_USE:
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+			_pSSLContext = SSL_CTX_new(TLS_server_method());
+#else
+			_pSSLContext = SSL_CTX_new(SSLv23_server_method());
+#endif
+			break;
+#if defined(SSL_OP_NO_TLSv1) && !defined(OPENSSL_NO_TLS1)
+		case TLSV1_CLIENT_USE:
+			_pSSLContext = SSL_CTX_new(TLSv1_client_method());
+			break;
+		case TLSV1_SERVER_USE:
+			_pSSLContext = SSL_CTX_new(TLSv1_server_method());
+			break;
+#endif
+#if defined(SSL_OP_NO_TLSv1_1) && !defined(OPENSSL_NO_TLS1)
+/* SSL_OP_NO_TLSv1_1 is defined in ssl.h if the library version supports TLSv1.1.
+ * OPENSSL_NO_TLS1 is defined in opensslconf.h or on the compiler command line
+ * if TLS1.x was removed at OpenSSL library build time via Configure options.
+ */
+        case TLSV1_1_CLIENT_USE:
+            _pSSLContext = SSL_CTX_new(TLSv1_1_client_method());
+            break;
+        case TLSV1_1_SERVER_USE:
+            _pSSLContext = SSL_CTX_new(TLSv1_1_server_method());
+            break;
+#endif
+#if defined(SSL_OP_NO_TLSv1_2) && !defined(OPENSSL_NO_TLS1)
+        case TLSV1_2_CLIENT_USE:
+            _pSSLContext = SSL_CTX_new(TLSv1_2_client_method());
+            break;
+        case TLSV1_2_SERVER_USE:
+            _pSSLContext = SSL_CTX_new(TLSv1_2_server_method());
+            break;
+#endif
+		default:
+			throw Poco::InvalidArgumentException("Invalid or unsupported usage");
+		}
+	}
+	if (!_pSSLContext)
+	{
+		unsigned long err = ERR_get_error();
+		throw SSLException("Cannot create SSL_CTX object", ERR_error_string(err, 0));
+	}
+
+	SSL_CTX_set_default_passwd_cb(_pSSLContext, &SSLManager::privateKeyPassphraseCallback);
+	Utility::clearErrorStack();
+	SSL_CTX_set_options(_pSSLContext, SSL_OP_ALL);
+}
+
+
+void Context::initDH(const std::string& dhParamsFile)
+{
+#ifndef OPENSSL_NO_DH
+    // 1024-bit MODP Group with 160-bit prime order subgroup (RFC5114)
+	// -----BEGIN DH PARAMETERS-----
+	// MIIBDAKBgQCxC4+WoIDgHd6S3l6uXVTsUsmfvPsGo8aaap3KUtI7YWBz4oZ1oj0Y
+	// mDjvHi7mUsAT7LSuqQYRIySXXDzUm4O/rMvdfZDEvXCYSI6cIZpzck7/1vrlZEc4
+	// +qMaT/VbzMChUa9fDci0vUW/N982XBpl5oz9p21NpwjfH7K8LkpDcQKBgQCk0cvV
+	// w/00EmdlpELvuZkF+BBN0lisUH/WQGz/FCZtMSZv6h5cQVZLd35pD1UE8hMWAhe0
+	// sBuIal6RVH+eJ0n01/vX07mpLuGQnQ0iY/gKdqaiTAh6CR9THb8KAWm2oorWYqTR
+	// jnOvoy13nVkY0IvIhY9Nzvl8KiSFXm7rIrOy5QICAKA=
+	// -----END DH PARAMETERS-----
+	//
+
+	static const unsigned char dh1024_p[] =
+	{
+		0xB1,0x0B,0x8F,0x96,0xA0,0x80,0xE0,0x1D,0xDE,0x92,0xDE,0x5E,
+		0xAE,0x5D,0x54,0xEC,0x52,0xC9,0x9F,0xBC,0xFB,0x06,0xA3,0xC6,
+		0x9A,0x6A,0x9D,0xCA,0x52,0xD2,0x3B,0x61,0x60,0x73,0xE2,0x86,
+		0x75,0xA2,0x3D,0x18,0x98,0x38,0xEF,0x1E,0x2E,0xE6,0x52,0xC0,
+		0x13,0xEC,0xB4,0xAE,0xA9,0x06,0x11,0x23,0x24,0x97,0x5C,0x3C,
+		0xD4,0x9B,0x83,0xBF,0xAC,0xCB,0xDD,0x7D,0x90,0xC4,0xBD,0x70,
+		0x98,0x48,0x8E,0x9C,0x21,0x9A,0x73,0x72,0x4E,0xFF,0xD6,0xFA,
+		0xE5,0x64,0x47,0x38,0xFA,0xA3,0x1A,0x4F,0xF5,0x5B,0xCC,0xC0,
+		0xA1,0x51,0xAF,0x5F,0x0D,0xC8,0xB4,0xBD,0x45,0xBF,0x37,0xDF,
+		0x36,0x5C,0x1A,0x65,0xE6,0x8C,0xFD,0xA7,0x6D,0x4D,0xA7,0x08,
+		0xDF,0x1F,0xB2,0xBC,0x2E,0x4A,0x43,0x71,
+	};
+
+	static const unsigned char dh1024_g[] =
+	{
+		0xA4,0xD1,0xCB,0xD5,0xC3,0xFD,0x34,0x12,0x67,0x65,0xA4,0x42,
+		0xEF,0xB9,0x99,0x05,0xF8,0x10,0x4D,0xD2,0x58,0xAC,0x50,0x7F,
+		0xD6,0x40,0x6C,0xFF,0x14,0x26,0x6D,0x31,0x26,0x6F,0xEA,0x1E,
+		0x5C,0x41,0x56,0x4B,0x77,0x7E,0x69,0x0F,0x55,0x04,0xF2,0x13,
+		0x16,0x02,0x17,0xB4,0xB0,0x1B,0x88,0x6A,0x5E,0x91,0x54,0x7F,
+		0x9E,0x27,0x49,0xF4,0xD7,0xFB,0xD7,0xD3,0xB9,0xA9,0x2E,0xE1,
+		0x90,0x9D,0x0D,0x22,0x63,0xF8,0x0A,0x76,0xA6,0xA2,0x4C,0x08,
+		0x7A,0x09,0x1F,0x53,0x1D,0xBF,0x0A,0x01,0x69,0xB6,0xA2,0x8A,
+		0xD6,0x62,0xA4,0xD1,0x8E,0x73,0xAF,0xA3,0x2D,0x77,0x9D,0x59,
+		0x18,0xD0,0x8B,0xC8,0x85,0x8F,0x4D,0xCE,0xF9,0x7C,0x2A,0x24,
+		0x85,0x5E,0x6E,0xEB,0x22,0xB3,0xB2,0xE5,
+	};
+
+	DH* dh = 0;
+	if (!dhParamsFile.empty())
+	{
+		BIO* bio = BIO_new_file(dhParamsFile.c_str(), "r");
+		if (!bio)
+		{
+			std::string msg = Utility::getLastError();
+			throw SSLContextException(std::string("Error opening Diffie-Hellman parameters file ") + dhParamsFile, msg);
+		}
+		dh = PEM_read_bio_DHparams(bio, 0, 0, 0);
+		BIO_free(bio);
+		if (!dh)
+		{
+			std::string msg = Utility::getLastError();
+			throw SSLContextException(std::string("Error reading Diffie-Hellman parameters from file ") + dhParamsFile, msg);
+		}
+	}
+	else
+	{
+		dh = DH_new();
+		if (!dh)
+		{
+			std::string msg = Utility::getLastError();
+			throw SSLContextException("Error creating Diffie-Hellman parameters", msg);
+		}
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L && !defined(LIBRESSL_VERSION_NUMBER) && !defined(BORINGSSL_DEPRECATED)
+		BIGNUM* p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), 0);
+		BIGNUM* g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), 0);
+		DH_set0_pqg(dh, p, 0, g);
+		DH_set_length(dh, 160);
+		if (!p || !g)
+		{
+			DH_free(dh);
+			throw SSLContextException("Error creating Diffie-Hellman parameters");
+		}
+#else
+		dh->p = BN_bin2bn(dh1024_p, sizeof(dh1024_p), 0);
+		dh->g = BN_bin2bn(dh1024_g, sizeof(dh1024_g), 0);
+#ifdef BORINGSSL_DEPRECATED
+		dh->priv_length = 160;
+#else
+		dh->length = 160;
+#endif
+		if ((!dh->p) || (!dh->g))
+		{
+			DH_free(dh);
+			throw SSLContextException("Error creating Diffie-Hellman parameters");
+		}
+#endif
+	}
+	SSL_CTX_set_tmp_dh(_pSSLContext, dh);
+	SSL_CTX_set_options(_pSSLContext, SSL_OP_SINGLE_DH_USE);
+	DH_free(dh);
+#else
+	if (!dhParamsFile.empty())
+		throw SSLContextException("OpenSSL does not support DH");
+#endif
+}
+
+
+void Context::initECDH(const std::string& curve)
+{
+#if OPENSSL_VERSION_NUMBER >= 0x0090800fL
+#ifndef OPENSSL_NO_ECDH
+	int nid = 0;
+	if (!curve.empty())
+	{
+		nid = OBJ_sn2nid(curve.c_str());
+	}
+	else
+	{
+		nid = OBJ_sn2nid("prime256v1");
+	}
+	if (nid == 0)
+	{
+		throw SSLContextException("Unknown ECDH curve name", curve);
+	}
+
+	EC_KEY* ecdh = EC_KEY_new_by_curve_name(nid);
+	if (!ecdh)
+	{
+		throw SSLContextException("Cannot create ECDH curve");
+	}
+	SSL_CTX_set_tmp_ecdh(_pSSLContext, ecdh);
+	SSL_CTX_set_options(_pSSLContext, SSL_OP_SINGLE_ECDH_USE);
+	EC_KEY_free(ecdh);
+#endif
+#endif
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/HTTPSClientSession.cpp b/base/poco/NetSSL_OpenSSL/src/HTTPSClientSession.cpp
new file mode 100644
index 00000000000..91c87bd70b6
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/HTTPSClientSession.cpp
@@ -0,0 +1,210 @@
+//
+// HTTPSClientSession.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: HTTPSClient
+// Module:  HTTPSClientSession
+//
+// Copyright (c) 2006-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPSClientSession.h"
+#include "Poco/Net/HTTPSSessionInstantiator.h"
+#include "Poco/Net/SecureStreamSocket.h"
+#include "Poco/Net/SecureStreamSocketImpl.h"
+#include "Poco/Net/SSLManager.h"
+#include "Poco/Net/SSLException.h"
+#include "Poco/Net/HTTPRequest.h"
+#include "Poco/Net/HTTPResponse.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/NumberFormatter.h"
+
+
+using Poco::NumberFormatter;
+using Poco::IllegalStateException;
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPSClientSession::HTTPSClientSession():
+	HTTPClientSession(SecureStreamSocket()),
+	_pContext(SSLManager::instance().defaultClientContext())
+{
+	setPort(HTTPS_PORT);
+	_proxySessionFactory.registerProtocol("https", new HTTPSSessionInstantiator);
+}
+
+
+HTTPSClientSession::HTTPSClientSession(const SecureStreamSocket& socket):
+	HTTPClientSession(socket),
+	_pContext(socket.context())
+{
+	setPort(HTTPS_PORT);
+	_proxySessionFactory.registerProtocol("https", new HTTPSSessionInstantiator);
+}
+
+
+HTTPSClientSession::HTTPSClientSession(const SecureStreamSocket& socket, Session::Ptr pSession):
+	HTTPClientSession(socket),
+	_pContext(socket.context()),
+	_pSession(pSession)
+{
+	setPort(HTTPS_PORT);
+	_proxySessionFactory.registerProtocol("https", new HTTPSSessionInstantiator);
+}
+
+
+HTTPSClientSession::HTTPSClientSession(const std::string& host, Poco::UInt16 port):
+	HTTPClientSession(SecureStreamSocket()),
+	_pContext(SSLManager::instance().defaultClientContext())
+{
+	setHost(host);
+	setPort(port);
+	_proxySessionFactory.registerProtocol("https", new HTTPSSessionInstantiator);
+}
+
+
+HTTPSClientSession::HTTPSClientSession(Context::Ptr pContext):
+	HTTPClientSession(SecureStreamSocket(pContext)),
+	_pContext(pContext)
+{
+	_proxySessionFactory.registerProtocol("https", new HTTPSSessionInstantiator(pContext));
+}
+
+
+HTTPSClientSession::HTTPSClientSession(Context::Ptr pContext, Session::Ptr pSession):
+	HTTPClientSession(SecureStreamSocket(pContext, pSession)),
+	_pContext(pContext),
+	_pSession(pSession)
+{
+	_proxySessionFactory.registerProtocol("https", new HTTPSSessionInstantiator(pContext));
+}
+
+
+HTTPSClientSession::HTTPSClientSession(const std::string& host, Poco::UInt16 port, Context::Ptr pContext):
+	HTTPClientSession(SecureStreamSocket(pContext)),
+	_pContext(pContext)
+{
+	setHost(host);
+	setPort(port);
+	_proxySessionFactory.registerProtocol("https", new HTTPSSessionInstantiator(pContext));
+}
+
+
+HTTPSClientSession::HTTPSClientSession(const std::string& host, Poco::UInt16 port, Context::Ptr pContext, Session::Ptr pSession):
+	HTTPClientSession(SecureStreamSocket(pContext, pSession)),
+	_pContext(pContext),
+	_pSession(pSession)
+{
+	setHost(host);
+	setPort(port);
+	_proxySessionFactory.registerProtocol("https", new HTTPSSessionInstantiator(pContext));
+}
+
+
+HTTPSClientSession::~HTTPSClientSession()
+{
+	_proxySessionFactory.unregisterProtocol("https");
+}
+
+
+bool HTTPSClientSession::secure() const
+{
+	return true;
+}
+
+
+void HTTPSClientSession::abort()
+{
+	SecureStreamSocket sss(socket());
+	sss.abort();
+}
+
+
+X509Certificate HTTPSClientSession::serverCertificate()
+{
+	SecureStreamSocket sss(socket());
+	return sss.peerCertificate();
+}
+
+
+std::string HTTPSClientSession::proxyRequestPrefix() const
+{
+	std::string result("https://");
+	result.append(getHost());
+	/// Do not append default by default, since this may break some servers.
+	/// One example of such server is GCS (Google Cloud Storage).
+	if (getPort() != HTTPS_PORT)
+	{
+		result.append(":");
+		NumberFormatter::append(result, getPort());
+	}
+	return result;
+}
+
+
+void HTTPSClientSession::proxyAuthenticate(HTTPRequest& request)
+{
+}
+
+
+void HTTPSClientSession::connect(const SocketAddress& address)
+{
+	bool useProxy = !getProxyHost().empty() && !bypassProxy();
+	
+	if (useProxy && isProxyTunnel())
+	{
+		StreamSocket proxySocket(proxyConnect());
+		SecureStreamSocket secureSocket = SecureStreamSocket::attach(proxySocket, getHost(), _pContext, _pSession);
+		attachSocket(secureSocket);
+		if (_pContext->sessionCacheEnabled())
+		{
+			_pSession = secureSocket.currentSession();
+		}
+	}
+	else
+	{
+		SecureStreamSocket sss(socket());
+		if (sss.getPeerHostName().empty())
+		{
+			sss.setPeerHostName(useProxy ? getProxyHost() : getHost());
+		}
+		if (_pContext->sessionCacheEnabled())
+		{
+			sss.useSession(_pSession);
+		}
+		HTTPSession::connect(address);
+		if (_pContext->sessionCacheEnabled())
+		{
+			_pSession = sss.currentSession();
+		}
+	}
+}
+
+
+int HTTPSClientSession::read(char* buffer, std::streamsize length)
+{
+	try
+	{
+		return HTTPSession::read(buffer, length);
+	}
+	catch(SSLConnectionUnexpectedlyClosedException&)
+	{
+		return 0;
+	}
+}
+
+
+Session::Ptr HTTPSClientSession::sslSession()
+{
+	return _pSession;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/HTTPSSessionInstantiator.cpp b/base/poco/NetSSL_OpenSSL/src/HTTPSSessionInstantiator.cpp
new file mode 100644
index 00000000000..fb8774d6549
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/HTTPSSessionInstantiator.cpp
@@ -0,0 +1,71 @@
+//
+// HTTPSSessionInstantiator.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: HTTPSClient
+// Module:  HTTPSSessionInstantiator
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPSSessionInstantiator.h"
+#include "Poco/Net/HTTPSessionFactory.h"
+#include "Poco/Net/HTTPSClientSession.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPSSessionInstantiator::HTTPSSessionInstantiator()
+{
+}
+
+
+HTTPSSessionInstantiator::HTTPSSessionInstantiator(Context::Ptr pContext) :
+	_pContext(pContext)
+{
+}
+
+
+HTTPSSessionInstantiator::~HTTPSSessionInstantiator()
+{
+}
+
+
+HTTPClientSession* HTTPSSessionInstantiator::createClientSession(const Poco::URI& uri)
+{
+	poco_assert (uri.getScheme() == "https");
+	HTTPSClientSession* pSession = _pContext.isNull() ? new HTTPSClientSession(uri.getHost(), uri.getPort()) : new HTTPSClientSession(uri.getHost(), uri.getPort(), _pContext);
+	if (!proxyHost().empty())
+	{
+		pSession->setProxy(proxyHost(), proxyPort());
+		pSession->setProxyCredentials(proxyUsername(), proxyPassword());
+	}
+	return pSession;
+}
+
+
+void HTTPSSessionInstantiator::registerInstantiator()
+{
+	HTTPSessionFactory::defaultFactory().registerProtocol("https", new HTTPSSessionInstantiator);
+}
+
+
+void HTTPSSessionInstantiator::registerInstantiator(Context::Ptr context)
+{
+	HTTPSessionFactory::defaultFactory().registerProtocol("https", new HTTPSSessionInstantiator(context));
+}
+
+
+void HTTPSSessionInstantiator::unregisterInstantiator()
+{
+	HTTPSessionFactory::defaultFactory().unregisterProtocol("https");
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/HTTPSStreamFactory.cpp b/base/poco/NetSSL_OpenSSL/src/HTTPSStreamFactory.cpp
new file mode 100644
index 00000000000..6ef20e63ffd
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/HTTPSStreamFactory.cpp
@@ -0,0 +1,194 @@
+//
+// HTTPSStreamFactory.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: HTTPSClient
+// Module:  HTTPSStreamFactory
+//
+// Copyright (c) 2006-2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/HTTPSStreamFactory.h"
+#include "Poco/Net/HTTPSClientSession.h"
+#include "Poco/Net/HTTPIOStream.h"
+#include "Poco/Net/HTTPRequest.h"
+#include "Poco/Net/HTTPResponse.h"
+#include "Poco/Net/HTTPCredentials.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/URI.h"
+#include "Poco/URIStreamOpener.h"
+#include "Poco/UnbufferedStreamBuf.h"
+#include "Poco/NullStream.h"
+#include "Poco/StreamCopier.h"
+#include "Poco/Format.h"
+#include "Poco/Version.h"
+
+
+using Poco::URIStreamFactory;
+using Poco::URI;
+using Poco::URIStreamOpener;
+using Poco::UnbufferedStreamBuf;
+
+
+namespace Poco {
+namespace Net {
+
+
+HTTPSStreamFactory::HTTPSStreamFactory():
+	_proxyPort(HTTPSession::HTTP_PORT)
+{
+}
+
+
+HTTPSStreamFactory::HTTPSStreamFactory(const std::string& proxyHost, Poco::UInt16 proxyPort):
+	_proxyHost(proxyHost),
+	_proxyPort(proxyPort)
+{
+}
+
+
+HTTPSStreamFactory::HTTPSStreamFactory(const std::string& proxyHost, Poco::UInt16 proxyPort, const std::string& proxyUsername, const std::string& proxyPassword):
+	_proxyHost(proxyHost),
+	_proxyPort(proxyPort),
+	_proxyUsername(proxyUsername),
+	_proxyPassword(proxyPassword)
+{
+}
+
+
+HTTPSStreamFactory::~HTTPSStreamFactory()
+{
+}
+
+
+std::istream* HTTPSStreamFactory::open(const URI& uri)
+{
+	poco_assert (uri.getScheme() == "https" || uri.getScheme() == "http");
+
+	URI resolvedURI(uri);
+	URI proxyUri;
+	HTTPClientSession* pSession = 0;
+	HTTPResponse res;
+	try
+	{
+		bool retry = false;
+		bool authorize = false;
+		int redirects = 0;
+		std::string username;
+		std::string password;
+		
+		do
+		{
+			if (!pSession)
+			{
+				if (resolvedURI.getScheme() != "http")
+					pSession = new HTTPSClientSession(resolvedURI.getHost(), resolvedURI.getPort());
+				else
+					pSession = new HTTPClientSession(resolvedURI.getHost(), resolvedURI.getPort());
+
+				if (proxyUri.empty())
+				{
+					if (!_proxyHost.empty())
+					{
+						pSession->setProxy(_proxyHost, _proxyPort);
+						pSession->setProxyCredentials(_proxyUsername, _proxyPassword);
+					}
+				}
+				else
+				{
+					pSession->setProxy(proxyUri.getHost(), proxyUri.getPort());
+					if (!_proxyUsername.empty())
+					{
+						pSession->setProxyCredentials(_proxyUsername, _proxyPassword);
+					}
+				}
+			}
+			std::string path = resolvedURI.getPathAndQuery();
+			if (path.empty()) path = "/";
+			HTTPRequest req(HTTPRequest::HTTP_GET, path, HTTPMessage::HTTP_1_1);
+			
+			if (authorize)
+			{
+				HTTPCredentials::extractCredentials(uri, username, password);
+				HTTPCredentials cred(username, password);
+				cred.authenticate(req, res);
+			}
+
+			req.set("User-Agent", Poco::format("poco/%d.%d.%d", 
+				(POCO_VERSION >> 24) & 0xFF,
+				(POCO_VERSION >> 16) & 0xFF,
+				(POCO_VERSION >> 8) & 0xFF));
+			req.set("Accept", "*/*");
+
+			pSession->sendRequest(req);
+			std::istream& rs = pSession->receiveResponse(res);
+			bool moved = (res.getStatus() == HTTPResponse::HTTP_MOVED_PERMANENTLY || 
+			              res.getStatus() == HTTPResponse::HTTP_FOUND || 
+			              res.getStatus() == HTTPResponse::HTTP_SEE_OTHER ||
+						  res.getStatus() == HTTPResponse::HTTP_TEMPORARY_REDIRECT);
+			if (moved)
+			{
+				resolvedURI.resolve(res.get("Location"));
+				if (!username.empty())
+				{
+					resolvedURI.setUserInfo(username + ":" + password);
+					authorize = false;
+				}
+				delete pSession; 
+				pSession = 0;
+				++redirects;
+				retry = true;
+			}
+			else if (res.getStatus() == HTTPResponse::HTTP_OK)
+			{
+				return new HTTPResponseStream(rs, pSession);
+			}
+			else if (res.getStatus() == HTTPResponse::HTTP_USEPROXY && !retry)
+			{
+				// The requested resource MUST be accessed through the proxy 
+				// given by the Location field. The Location field gives the 
+				// URI of the proxy. The recipient is expected to repeat this 
+				// single request via the proxy. 305 responses MUST only be generated by origin servers.
+				// only use for one single request!
+				proxyUri.resolve(res.get("Location"));
+				delete pSession; 
+				pSession = 0;
+				retry = true; // only allow useproxy once
+			}
+			else if (res.getStatus() == HTTPResponse::HTTP_UNAUTHORIZED && !authorize)
+			{
+				authorize = true;
+				retry = true;
+				Poco::NullOutputStream null;
+				Poco::StreamCopier::copyStream(rs, null);
+			}
+			else throw HTTPException(res.getReason(), uri.toString());
+		}
+		while (retry && redirects < MAX_REDIRECTS);
+		throw HTTPException("Too many redirects", uri.toString());
+	}
+	catch (...)
+	{
+		delete pSession;
+		throw;
+	}
+}
+
+
+void HTTPSStreamFactory::registerFactory()
+{
+	URIStreamOpener::defaultOpener().registerStreamFactory("https", new HTTPSStreamFactory);
+}
+
+
+void HTTPSStreamFactory::unregisterFactory()
+{
+	URIStreamOpener::defaultOpener().unregisterStreamFactory("https");
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/InvalidCertificateHandler.cpp b/base/poco/NetSSL_OpenSSL/src/InvalidCertificateHandler.cpp
new file mode 100644
index 00000000000..7cf68613c47
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/InvalidCertificateHandler.cpp
@@ -0,0 +1,52 @@
+//
+// InvalidCertificateHandler.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  InvalidCertificateHandler
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/InvalidCertificateHandler.h"
+#include "Poco/Net/SSLManager.h"
+#include "Poco/Delegate.h"
+
+
+using Poco::Delegate;
+
+
+namespace Poco {
+namespace Net {
+
+
+InvalidCertificateHandler::InvalidCertificateHandler(bool handleErrorsOnServerSide): _handleErrorsOnServerSide(handleErrorsOnServerSide)
+{
+	if (_handleErrorsOnServerSide)
+		SSLManager::instance().ServerVerificationError += Delegate<InvalidCertificateHandler, VerificationErrorArgs>(this, &InvalidCertificateHandler::onInvalidCertificate);
+	else
+		SSLManager::instance().ClientVerificationError += Delegate<InvalidCertificateHandler, VerificationErrorArgs>(this, &InvalidCertificateHandler::onInvalidCertificate);
+}
+
+
+InvalidCertificateHandler::~InvalidCertificateHandler()
+{
+	try
+	{
+		if (_handleErrorsOnServerSide)
+			SSLManager::instance().ServerVerificationError -= Delegate<InvalidCertificateHandler, VerificationErrorArgs>(this, &InvalidCertificateHandler::onInvalidCertificate);
+		else
+			SSLManager::instance().ClientVerificationError -= Delegate<InvalidCertificateHandler, VerificationErrorArgs>(this, &InvalidCertificateHandler::onInvalidCertificate);
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/KeyConsoleHandler.cpp b/base/poco/NetSSL_OpenSSL/src/KeyConsoleHandler.cpp
new file mode 100644
index 00000000000..66de05db500
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/KeyConsoleHandler.cpp
@@ -0,0 +1,40 @@
+//
+// KeyConsoleHandler.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  KeyConsoleHandler
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/KeyConsoleHandler.h"
+#include <iostream>
+
+
+namespace Poco {
+namespace Net {
+
+
+KeyConsoleHandler::KeyConsoleHandler(bool server):PrivateKeyPassphraseHandler(server)
+{
+}
+
+
+KeyConsoleHandler::~KeyConsoleHandler()
+{
+}
+
+
+void KeyConsoleHandler::onPrivateKeyRequested(const void* pSender, std::string& privateKey)
+{
+	std::cout << "Please enter the passphrase for the private key: ";
+	std::cin >> privateKey;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/KeyFileHandler.cpp b/base/poco/NetSSL_OpenSSL/src/KeyFileHandler.cpp
new file mode 100644
index 00000000000..c06485aefde
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/KeyFileHandler.cpp
@@ -0,0 +1,61 @@
+//
+// KeyFileHandler.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  KeyFileHandler
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/KeyFileHandler.h"
+#include "Poco/Net/SSLManager.h"
+#include "Poco/File.h"
+#include "Poco/Util/AbstractConfiguration.h"
+#include "Poco/Util/Application.h"
+#include "Poco/Util/OptionException.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+const std::string KeyFileHandler::CFG_PRIV_KEY_FILE("privateKeyPassphraseHandler.options.password");
+
+
+KeyFileHandler::KeyFileHandler(bool server):PrivateKeyPassphraseHandler(server)
+{
+}
+
+
+KeyFileHandler::~KeyFileHandler()
+{
+}
+
+
+void KeyFileHandler::onPrivateKeyRequested(const void* pSender, std::string& privateKey)
+{
+	try
+	{
+		Poco::Util::AbstractConfiguration& config = Poco::Util::Application::instance().config();
+		std::string prefix = serverSide() ? SSLManager::CFG_SERVER_PREFIX : SSLManager::CFG_CLIENT_PREFIX;
+		if (!config.hasProperty(prefix + CFG_PRIV_KEY_FILE))
+			throw Poco::Util::EmptyOptionException(std::string("Missing Configuration Entry: ") + prefix + CFG_PRIV_KEY_FILE);
+		
+		privateKey = config.getString(prefix + CFG_PRIV_KEY_FILE);
+	}
+	catch (Poco::NullPointerException&)
+	{
+		throw Poco::IllegalStateException(
+			"An application configuration is required to obtain the private key passphrase, "
+			"but no Poco::Util::Application instance is available."
+			);
+	}
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/PrivateKeyFactory.cpp b/base/poco/NetSSL_OpenSSL/src/PrivateKeyFactory.cpp
new file mode 100644
index 00000000000..90297c351e5
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/PrivateKeyFactory.cpp
@@ -0,0 +1,44 @@
+//
+// PrivateKeyFactory.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  PrivateKeyFactory
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/PrivateKeyFactory.h"
+#include "Poco/Net/SSLManager.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+PrivateKeyFactory::PrivateKeyFactory()
+{
+}
+
+
+PrivateKeyFactory::~PrivateKeyFactory()
+{
+}
+
+
+PrivateKeyFactoryRegistrar::PrivateKeyFactoryRegistrar(const std::string& name, PrivateKeyFactory* pFactory)
+{
+	SSLManager::instance().privateKeyFactoryMgr().setFactory(name, pFactory);
+}
+
+
+PrivateKeyFactoryRegistrar::~PrivateKeyFactoryRegistrar()
+{
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/PrivateKeyFactoryMgr.cpp b/base/poco/NetSSL_OpenSSL/src/PrivateKeyFactoryMgr.cpp
new file mode 100644
index 00000000000..94b4ad34ba9
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/PrivateKeyFactoryMgr.cpp
@@ -0,0 +1,67 @@
+//
+// PrivateKeyFactoryMgr.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  PrivateKeyFactoryMgr
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/PrivateKeyFactoryMgr.h"
+#include "Poco/Net/KeyFileHandler.h"
+#include "Poco/Net/KeyConsoleHandler.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+PrivateKeyFactoryMgr::PrivateKeyFactoryMgr()
+{
+	setFactory("KeyFileHandler", new PrivateKeyFactoryImpl<KeyFileHandler>());
+	setFactory("KeyConsoleHandler", new PrivateKeyFactoryImpl<KeyConsoleHandler>());
+}
+
+
+PrivateKeyFactoryMgr::~PrivateKeyFactoryMgr()
+{
+}
+
+
+void PrivateKeyFactoryMgr::setFactory(const std::string& name, PrivateKeyFactory* pFactory)
+{
+	bool success = _factories.insert(make_pair(name, Poco::SharedPtr<PrivateKeyFactory>(pFactory))).second;
+	if (!success)
+		delete pFactory;
+	poco_assert(success);
+}
+		
+
+bool PrivateKeyFactoryMgr::hasFactory(const std::string& name) const
+{
+	return _factories.find(name) != _factories.end();
+}
+		
+	
+const PrivateKeyFactory* PrivateKeyFactoryMgr::getFactory(const std::string& name) const
+{
+	FactoriesMap::const_iterator it = _factories.find(name);
+	if (it != _factories.end())
+		return it->second;
+	else
+		return 0;
+}
+
+
+void PrivateKeyFactoryMgr::removeFactory(const std::string& name)
+{
+	_factories.erase(name);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/PrivateKeyPassphraseHandler.cpp b/base/poco/NetSSL_OpenSSL/src/PrivateKeyPassphraseHandler.cpp
new file mode 100644
index 00000000000..9c1386c74c0
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/PrivateKeyPassphraseHandler.cpp
@@ -0,0 +1,46 @@
+//
+// PrivateKeyPassphraseHandler.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  PrivateKeyPassphraseHandler
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/PrivateKeyPassphraseHandler.h"
+#include "Poco/Net/SSLManager.h"
+#include "Poco/Delegate.h"
+
+
+using Poco::Delegate;
+
+
+namespace Poco {
+namespace Net {
+
+
+PrivateKeyPassphraseHandler::PrivateKeyPassphraseHandler(bool onServerSide): _serverSide(onServerSide)
+{
+	SSLManager::instance().PrivateKeyPassphraseRequired += Delegate<PrivateKeyPassphraseHandler, std::string>(this, &PrivateKeyPassphraseHandler::onPrivateKeyRequested);
+}
+
+
+PrivateKeyPassphraseHandler::~PrivateKeyPassphraseHandler()
+{
+	try
+	{
+		SSLManager::instance().PrivateKeyPassphraseRequired -= Delegate<PrivateKeyPassphraseHandler, std::string>(this, &PrivateKeyPassphraseHandler::onPrivateKeyRequested);
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/RejectCertificateHandler.cpp b/base/poco/NetSSL_OpenSSL/src/RejectCertificateHandler.cpp
new file mode 100644
index 00000000000..1502a13e86d
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/RejectCertificateHandler.cpp
@@ -0,0 +1,38 @@
+//
+// RejectCertificateHandler.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  RejectCertificateHandler
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/RejectCertificateHandler.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+RejectCertificateHandler::RejectCertificateHandler(bool server): InvalidCertificateHandler(server)
+{
+}
+
+
+RejectCertificateHandler::~RejectCertificateHandler()
+{
+}
+
+
+void RejectCertificateHandler::onInvalidCertificate(const void*, VerificationErrorArgs& errorCert)
+{
+	errorCert.setIgnoreError(false);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/SSLException.cpp b/base/poco/NetSSL_OpenSSL/src/SSLException.cpp
new file mode 100644
index 00000000000..2b64d2a4d63
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/SSLException.cpp
@@ -0,0 +1,30 @@
+//
+// SSLException.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  SSLException
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SSLException.h"
+#include <typeinfo>
+
+
+namespace Poco {
+namespace Net {
+
+
+POCO_IMPLEMENT_EXCEPTION(SSLException, NetException, "SSL Exception")
+POCO_IMPLEMENT_EXCEPTION(SSLContextException, SSLException, "SSL context exception")
+POCO_IMPLEMENT_EXCEPTION(InvalidCertificateException, SSLException, "Invalid certficate")
+POCO_IMPLEMENT_EXCEPTION(CertificateValidationException, SSLException, "Certificate validation error")
+POCO_IMPLEMENT_EXCEPTION(SSLConnectionUnexpectedlyClosedException, SSLException, "SSL connection unexpectedly closed")
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/SSLManager.cpp b/base/poco/NetSSL_OpenSSL/src/SSLManager.cpp
new file mode 100644
index 00000000000..82eed1a29eb
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/SSLManager.cpp
@@ -0,0 +1,460 @@
+//
+// SSLManager.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  SSLManager
+//
+// Copyright (c) 2006-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SSLManager.h"
+#include "Poco/Net/Context.h"
+#include "Poco/Net/Utility.h"
+#include "Poco/Net/PrivateKeyPassphraseHandler.h"
+#include "Poco/Net/RejectCertificateHandler.h"
+#include "Poco/Crypto/OpenSSLInitializer.h"
+#include "Poco/Net/SSLException.h"
+#include "Poco/SingletonHolder.h"
+#include "Poco/Delegate.h"
+#include "Poco/StringTokenizer.h"
+#include "Poco/Util/Application.h"
+#include "Poco/Util/OptionException.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+const std::string SSLManager::CFG_PRIV_KEY_FILE("privateKeyFile");
+const std::string SSLManager::CFG_CERTIFICATE_FILE("certificateFile");
+const std::string SSLManager::CFG_CA_LOCATION("caConfig");
+const std::string SSLManager::CFG_VER_MODE("verificationMode");
+const Context::VerificationMode SSLManager::VAL_VER_MODE(Context::VERIFY_RELAXED);
+const std::string SSLManager::CFG_VER_DEPTH("verificationDepth");
+const int         SSLManager::VAL_VER_DEPTH(9);
+const std::string SSLManager::CFG_ENABLE_DEFAULT_CA("loadDefaultCAFile");
+const bool        SSLManager::VAL_ENABLE_DEFAULT_CA(true);
+const std::string SSLManager::CFG_CIPHER_LIST("cipherList");
+const std::string SSLManager::CFG_CYPHER_LIST("cypherList");
+const std::string SSLManager::VAL_CIPHER_LIST("ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH");
+const std::string SSLManager::CFG_PREFER_SERVER_CIPHERS("preferServerCiphers");
+const std::string SSLManager::CFG_DELEGATE_HANDLER("privateKeyPassphraseHandler.name");
+const std::string SSLManager::VAL_DELEGATE_HANDLER("KeyConsoleHandler");
+const std::string SSLManager::CFG_CERTIFICATE_HANDLER("invalidCertificateHandler.name");
+const std::string SSLManager::VAL_CERTIFICATE_HANDLER("ConsoleCertificateHandler");
+const std::string SSLManager::CFG_SERVER_PREFIX("openSSL.server.");
+const std::string SSLManager::CFG_CLIENT_PREFIX("openSSL.client.");
+const std::string SSLManager::CFG_CACHE_SESSIONS("cacheSessions");
+const std::string SSLManager::CFG_SESSION_ID_CONTEXT("sessionIdContext");
+const std::string SSLManager::CFG_SESSION_CACHE_SIZE("sessionCacheSize");
+const std::string SSLManager::CFG_SESSION_TIMEOUT("sessionTimeout");
+const std::string SSLManager::CFG_EXTENDED_VERIFICATION("extendedVerification");
+const std::string SSLManager::CFG_REQUIRE_TLSV1("requireTLSv1");
+const std::string SSLManager::CFG_REQUIRE_TLSV1_1("requireTLSv1_1");
+const std::string SSLManager::CFG_REQUIRE_TLSV1_2("requireTLSv1_2");
+const std::string SSLManager::CFG_DISABLE_PROTOCOLS("disableProtocols");
+const std::string SSLManager::CFG_DH_PARAMS_FILE("dhParamsFile");
+const std::string SSLManager::CFG_ECDH_CURVE("ecdhCurve");
+#ifdef OPENSSL_FIPS
+const std::string SSLManager::CFG_FIPS_MODE("openSSL.fips");
+const bool        SSLManager::VAL_FIPS_MODE(false);
+#endif
+
+
+SSLManager::SSLManager()
+{
+}
+
+
+SSLManager::~SSLManager()
+{
+	try
+	{
+		shutdown();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void SSLManager::shutdown()
+{
+	PrivateKeyPassphraseRequired.clear();
+	ClientVerificationError.clear();
+	ServerVerificationError.clear();
+	_ptrDefaultServerContext = 0;
+	_ptrDefaultClientContext = 0;
+}
+
+
+namespace
+{
+	static Poco::SingletonHolder<SSLManager> singleton;
+}
+
+
+SSLManager& SSLManager::instance()
+{
+	return *singleton.get();
+}
+
+
+void SSLManager::initializeServer(PrivateKeyPassphraseHandlerPtr ptrPassphraseHandler, InvalidCertificateHandlerPtr ptrHandler, Context::Ptr ptrContext)
+{
+	_ptrServerPassphraseHandler  = ptrPassphraseHandler;
+	_ptrServerCertificateHandler = ptrHandler;
+	_ptrDefaultServerContext     = ptrContext;
+}
+
+
+void SSLManager::initializeClient(PrivateKeyPassphraseHandlerPtr ptrPassphraseHandler, InvalidCertificateHandlerPtr ptrHandler, Context::Ptr ptrContext)
+{
+	_ptrClientPassphraseHandler  = ptrPassphraseHandler;
+	_ptrClientCertificateHandler = ptrHandler;
+	_ptrDefaultClientContext     = ptrContext;
+}
+
+
+Context::Ptr SSLManager::defaultServerContext()
+{
+	Poco::FastMutex::ScopedLock lock(_mutex);
+	
+	if (!_ptrDefaultServerContext)
+		initDefaultContext(true);
+
+	return _ptrDefaultServerContext;
+}
+
+
+Context::Ptr SSLManager::defaultClientContext()
+{
+	Poco::FastMutex::ScopedLock lock(_mutex);
+
+	if (!_ptrDefaultClientContext)
+	{
+		try
+		{
+			initDefaultContext(false);
+		}
+		catch (Poco::IllegalStateException&)
+		{
+			_ptrClientCertificateHandler = new RejectCertificateHandler(false);
+			_ptrDefaultClientContext = new Context(Context::CLIENT_USE, "", Context::VERIFY_RELAXED, 9, true);
+			_ptrDefaultClientContext->disableProtocols(Context::PROTO_SSLV2 | Context::PROTO_SSLV3);
+		}
+	}
+		
+	return _ptrDefaultClientContext;
+}
+
+
+SSLManager::PrivateKeyPassphraseHandlerPtr SSLManager::serverPassphraseHandler()
+{
+	Poco::FastMutex::ScopedLock lock(_mutex);
+
+	if (!_ptrServerPassphraseHandler)
+		initPassphraseHandler(true);
+
+	return _ptrServerPassphraseHandler;
+}
+
+
+SSLManager::PrivateKeyPassphraseHandlerPtr SSLManager::clientPassphraseHandler()
+{
+	Poco::FastMutex::ScopedLock lock(_mutex);
+
+	if (!_ptrClientPassphraseHandler)
+		initPassphraseHandler(false);
+
+	return _ptrClientPassphraseHandler;
+}
+
+
+SSLManager::InvalidCertificateHandlerPtr SSLManager::serverCertificateHandler()
+{
+	Poco::FastMutex::ScopedLock lock(_mutex);
+
+	if (!_ptrServerCertificateHandler)
+		initCertificateHandler(true);
+
+	return _ptrServerCertificateHandler;
+}
+
+
+SSLManager::InvalidCertificateHandlerPtr SSLManager::clientCertificateHandler()
+{
+	Poco::FastMutex::ScopedLock lock(_mutex);
+
+	if (!_ptrClientCertificateHandler)
+		initCertificateHandler(false);
+
+	return _ptrClientCertificateHandler;
+}
+
+
+int SSLManager::verifyCallback(bool server, int ok, X509_STORE_CTX* pStore)
+{
+	if (!ok)
+	{
+		X509* pCert = X509_STORE_CTX_get_current_cert(pStore);
+		X509Certificate x509(pCert, true);
+		int depth = X509_STORE_CTX_get_error_depth(pStore);
+		int err = X509_STORE_CTX_get_error(pStore);
+		std::string error(X509_verify_cert_error_string(err));
+		VerificationErrorArgs args(x509, depth, err, error);
+		if (server)
+			SSLManager::instance().ServerVerificationError.notify(&SSLManager::instance(), args);
+		else
+			SSLManager::instance().ClientVerificationError.notify(&SSLManager::instance(), args);
+		ok = args.getIgnoreError() ? 1 : 0;
+	}
+
+	return ok;
+}
+
+
+int SSLManager::privateKeyPassphraseCallback(char* pBuf, int size, int flag, void* userData)
+{
+	std::string pwd;
+	SSLManager::instance().PrivateKeyPassphraseRequired.notify(&SSLManager::instance(), pwd);
+
+	strncpy(pBuf, (char *)(pwd.c_str()), size);
+	pBuf[size - 1] = '\0';
+	if (size > pwd.length())
+		size = (int) pwd.length();
+
+	return size;
+}
+
+
+void SSLManager::initDefaultContext(bool server)
+{
+	if (server && _ptrDefaultServerContext) return;
+	if (!server && _ptrDefaultClientContext) return;
+
+	Poco::Crypto::OpenSSLInitializer openSSLInitializer;
+	initEvents(server);
+	Poco::Util::AbstractConfiguration& config = appConfig();
+
+#ifdef OPENSSL_FIPS
+	bool fipsEnabled = config.getBool(CFG_FIPS_MODE, VAL_FIPS_MODE);
+	if (fipsEnabled && !Poco::Crypto::OpenSSLInitializer::isFIPSEnabled())
+	{
+		Poco::Crypto::OpenSSLInitializer::enableFIPSMode(true);
+	}
+#endif
+
+	std::string prefix = server ? CFG_SERVER_PREFIX : CFG_CLIENT_PREFIX;
+
+	Context::Params params;
+	// mandatory options
+	params.privateKeyFile = config.getString(prefix + CFG_PRIV_KEY_FILE, "");
+	params.certificateFile = config.getString(prefix + CFG_CERTIFICATE_FILE, params.privateKeyFile);	
+	params.caLocation = config.getString(prefix + CFG_CA_LOCATION, "");
+
+	if (server && params.certificateFile.empty() && params.privateKeyFile.empty())
+		throw SSLException("Configuration error: no certificate file has been specified");
+
+	// optional options for which we have defaults defined
+	params.verificationMode = VAL_VER_MODE;
+	if (config.hasProperty(prefix + CFG_VER_MODE))
+	{
+		// either: none, relaxed, strict, once
+		std::string mode = config.getString(prefix + CFG_VER_MODE);
+		params.verificationMode = Utility::convertVerificationMode(mode);
+	}
+
+	params.verificationDepth = config.getInt(prefix + CFG_VER_DEPTH, VAL_VER_DEPTH);
+	params.loadDefaultCAs = config.getBool(prefix + CFG_ENABLE_DEFAULT_CA, VAL_ENABLE_DEFAULT_CA);
+	params.cipherList = config.getString(prefix + CFG_CIPHER_LIST, VAL_CIPHER_LIST);
+	params.cipherList = config.getString(prefix + CFG_CYPHER_LIST, params.cipherList); // for backwards compatibility
+	bool requireTLSv1 = config.getBool(prefix + CFG_REQUIRE_TLSV1, false);
+	bool requireTLSv1_1 = config.getBool(prefix + CFG_REQUIRE_TLSV1_1, false);
+	bool requireTLSv1_2 = config.getBool(prefix + CFG_REQUIRE_TLSV1_2, false);
+
+	params.dhParamsFile = config.getString(prefix + CFG_DH_PARAMS_FILE, "");
+	params.ecdhCurve    = config.getString(prefix + CFG_ECDH_CURVE, "");
+
+	Context::Usage usage;
+	
+	if (server)
+	{
+		if (requireTLSv1_2)
+			usage = Context::TLSV1_2_SERVER_USE;
+		else if (requireTLSv1_1)
+			usage = Context::TLSV1_1_SERVER_USE;
+		else if (requireTLSv1)
+			usage = Context::TLSV1_SERVER_USE;
+		else
+			usage = Context::SERVER_USE;
+		_ptrDefaultServerContext = new Context(usage, params);
+	}
+	else
+	{
+		if (requireTLSv1_2)
+			usage = Context::TLSV1_2_CLIENT_USE;
+		else if (requireTLSv1_1)
+			usage = Context::TLSV1_1_CLIENT_USE;
+		else if (requireTLSv1)
+			usage = Context::TLSV1_CLIENT_USE;
+		else
+			usage = Context::CLIENT_USE;
+		_ptrDefaultClientContext = new Context(usage, params);
+	}
+	
+	std::string disabledProtocolsList = config.getString(prefix + CFG_DISABLE_PROTOCOLS, "");
+	Poco::StringTokenizer dpTok(disabledProtocolsList, ";,", Poco::StringTokenizer::TOK_TRIM | Poco::StringTokenizer::TOK_IGNORE_EMPTY);
+	int disabledProtocols = 0;
+	for (Poco::StringTokenizer::Iterator it = dpTok.begin(); it != dpTok.end(); ++it)
+	{
+		if (*it == "sslv2")
+			disabledProtocols |= Context::PROTO_SSLV2;
+		else if (*it == "sslv3")
+			disabledProtocols |= Context::PROTO_SSLV3;
+		else if (*it == "tlsv1")
+			disabledProtocols |= Context::PROTO_TLSV1;
+		else if (*it == "tlsv1_1")
+			disabledProtocols |= Context::PROTO_TLSV1_1;
+		else if (*it == "tlsv1_2")
+			disabledProtocols |= Context::PROTO_TLSV1_2;
+	}
+	if (server)
+		_ptrDefaultServerContext->disableProtocols(disabledProtocols);
+	else
+		_ptrDefaultClientContext->disableProtocols(disabledProtocols);
+		
+	bool cacheSessions = config.getBool(prefix + CFG_CACHE_SESSIONS, false);
+	if (server)
+	{
+		std::string sessionIdContext = config.getString(prefix + CFG_SESSION_ID_CONTEXT, config.getString("application.name", ""));
+		_ptrDefaultServerContext->enableSessionCache(cacheSessions, sessionIdContext);
+		if (config.hasProperty(prefix + CFG_SESSION_CACHE_SIZE))
+		{
+			int cacheSize = config.getInt(prefix + CFG_SESSION_CACHE_SIZE);
+			_ptrDefaultServerContext->setSessionCacheSize(cacheSize);
+		}
+		if (config.hasProperty(prefix + CFG_SESSION_TIMEOUT))
+		{
+			int timeout = config.getInt(prefix + CFG_SESSION_TIMEOUT);
+			_ptrDefaultServerContext->setSessionTimeout(timeout);
+		}
+	}
+	else
+	{
+		_ptrDefaultClientContext->enableSessionCache(cacheSessions);
+	}
+	bool extendedVerification = config.getBool(prefix + CFG_EXTENDED_VERIFICATION, false);
+	if (server)
+		_ptrDefaultServerContext->enableExtendedCertificateVerification(extendedVerification);
+	else
+		_ptrDefaultClientContext->enableExtendedCertificateVerification(extendedVerification);
+
+	bool preferServerCiphers = config.getBool(prefix + CFG_PREFER_SERVER_CIPHERS, false);
+	if (preferServerCiphers)
+	{
+		if (server)
+			_ptrDefaultServerContext->preferServerCiphers();
+		else
+			_ptrDefaultClientContext->preferServerCiphers();
+	}
+}
+
+
+void SSLManager::initEvents(bool server)
+{
+	initPassphraseHandler(server);
+	initCertificateHandler(server);
+}
+
+
+void SSLManager::initPassphraseHandler(bool server)
+{
+	if (server && _ptrServerPassphraseHandler) return;
+	if (!server && _ptrClientPassphraseHandler) return;
+	
+	std::string prefix = server ? CFG_SERVER_PREFIX : CFG_CLIENT_PREFIX;
+	Poco::Util::AbstractConfiguration& config = appConfig();
+
+	std::string className(config.getString(prefix + CFG_DELEGATE_HANDLER, VAL_DELEGATE_HANDLER));
+
+	const PrivateKeyFactory* pFactory = 0;
+	if (privateKeyFactoryMgr().hasFactory(className))
+	{
+		pFactory = privateKeyFactoryMgr().getFactory(className);
+	}
+
+	if (pFactory)
+	{
+		if (server)
+			_ptrServerPassphraseHandler = pFactory->create(server);
+		else
+			_ptrClientPassphraseHandler = pFactory->create(server);
+	}
+	else throw Poco::Util::UnknownOptionException(std::string("No passphrase handler known with the name ") + className);
+}
+	
+
+void SSLManager::initCertificateHandler(bool server)
+{
+	if (server && _ptrServerCertificateHandler) return;
+	if (!server && _ptrClientCertificateHandler) return;
+
+	std::string prefix = server ? CFG_SERVER_PREFIX : CFG_CLIENT_PREFIX;
+	Poco::Util::AbstractConfiguration& config = appConfig();
+
+	std::string className(config.getString(prefix+CFG_CERTIFICATE_HANDLER, VAL_CERTIFICATE_HANDLER));
+
+	const CertificateHandlerFactory* pFactory = 0;
+	if (certificateHandlerFactoryMgr().hasFactory(className))
+	{
+		pFactory = certificateHandlerFactoryMgr().getFactory(className);
+	}
+
+	if (pFactory)
+	{
+		if (server)
+			_ptrServerCertificateHandler = pFactory->create(true);
+		else
+			_ptrClientCertificateHandler = pFactory->create(false);
+	}
+	else throw Poco::Util::UnknownOptionException(std::string("No InvalidCertificate handler known with the name ") + className);
+}
+
+
+Poco::Util::AbstractConfiguration& SSLManager::appConfig()
+{
+	try
+	{
+		return Poco::Util::Application::instance().config();
+	}
+	catch (Poco::NullPointerException&)
+	{
+		throw Poco::IllegalStateException(
+			"An application configuration is required to initialize the Poco::Net::SSLManager, "
+			"but no Poco::Util::Application instance is available."
+		);
+	}
+}
+
+
+void initializeSSL()
+{
+	Poco::Crypto::initializeCrypto();
+}
+
+
+void uninitializeSSL()
+{
+	SSLManager::instance().shutdown();
+	Poco::Crypto::uninitializeCrypto();
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/SecureSMTPClientSession.cpp b/base/poco/NetSSL_OpenSSL/src/SecureSMTPClientSession.cpp
new file mode 100644
index 00000000000..c1a9569bc76
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/SecureSMTPClientSession.cpp
@@ -0,0 +1,64 @@
+//
+// SecureSMTPClientSession.h
+//
+// Library: NetSSL_OpenSSL
+// Package: Mail
+// Module:  SecureSMTPClientSession
+//
+// Copyright (c) 2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SecureSMTPClientSession.h"
+#include "Poco/Net/SecureStreamSocket.h"
+#include "Poco/Net/SSLManager.h"
+#include "Poco/Net/DialogSocket.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+SecureSMTPClientSession::SecureSMTPClientSession(const StreamSocket& socket):
+	SMTPClientSession(socket)
+{
+}
+
+
+SecureSMTPClientSession::SecureSMTPClientSession(const std::string& host, Poco::UInt16 port):
+	SMTPClientSession(host, port),
+	_host(host)
+{
+}
+
+
+SecureSMTPClientSession::~SecureSMTPClientSession()
+{
+}
+
+
+bool SecureSMTPClientSession::startTLS()
+{
+	return startTLS(SSLManager::instance().defaultClientContext());
+}
+
+
+bool SecureSMTPClientSession::startTLS(Context::Ptr pContext)
+{
+	int status = 0;
+	std::string response;
+	
+	status = sendCommand("STARTTLS", response);
+	if (!isPositiveCompletion(status)) return false;
+
+	SecureStreamSocket sss(SecureStreamSocket::attach(socket(), _host, pContext));
+	socket() = sss;
+	
+	return true;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/SecureServerSocket.cpp b/base/poco/NetSSL_OpenSSL/src/SecureServerSocket.cpp
new file mode 100644
index 00000000000..a394304ace4
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/SecureServerSocket.cpp
@@ -0,0 +1,121 @@
+//
+// SecureServerSocket.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLSockets
+// Module:  SecureServerSocket
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SecureServerSocket.h"
+#include "Poco/Net/SecureServerSocketImpl.h"
+#include "Poco/Net/SecureStreamSocket.h"
+#include "Poco/Net/SSLManager.h"
+#include "Poco/Exception.h"
+
+
+using Poco::InvalidArgumentException;
+
+
+namespace Poco {
+namespace Net {
+
+
+SecureServerSocket::SecureServerSocket(): 
+	ServerSocket(new SecureServerSocketImpl(SSLManager::instance().defaultServerContext()), true)
+{
+}
+
+
+SecureServerSocket::SecureServerSocket(Context::Ptr pContext):
+	ServerSocket(new SecureServerSocketImpl(pContext), true)
+{
+}
+
+
+SecureServerSocket::SecureServerSocket(const Socket& socket): 
+	ServerSocket(socket)
+{
+	if (!dynamic_cast<SecureServerSocketImpl*>(impl()))
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+}
+
+
+SecureServerSocket::SecureServerSocket(const SocketAddress& address, int backlog): 
+	ServerSocket(new SecureServerSocketImpl(SSLManager::instance().defaultServerContext()), true)
+{
+	impl()->bind(address, true);
+	impl()->listen(backlog);
+}
+
+
+SecureServerSocket::SecureServerSocket(const SocketAddress& address, int backlog, Context::Ptr pContext): 
+	ServerSocket(new SecureServerSocketImpl(pContext), true)
+{
+	impl()->bind(address, true);
+	impl()->listen(backlog);
+}
+
+
+SecureServerSocket::SecureServerSocket(Poco::UInt16 port, int backlog): 
+	ServerSocket(new SecureServerSocketImpl(SSLManager::instance().defaultServerContext()), true)
+{
+	IPAddress wildcardAddr;
+	SocketAddress address(wildcardAddr, port);
+	impl()->bind(address, true);
+	impl()->listen(backlog);
+}
+
+SecureServerSocket::SecureServerSocket(Poco::UInt16 port, int backlog, Context::Ptr pContext): 
+	ServerSocket(new SecureServerSocketImpl(pContext), true)
+{
+	IPAddress wildcardAddr;
+	SocketAddress address(wildcardAddr, port);
+	impl()->bind(address, true);
+	impl()->listen(backlog);
+}
+
+
+SecureServerSocket::~SecureServerSocket()
+{
+}
+
+
+SecureServerSocket& SecureServerSocket::operator = (const Socket& socket)
+{
+	if (&socket != this)
+	{
+		if (dynamic_cast<SecureServerSocketImpl*>(socket.impl()))
+			ServerSocket::operator = (socket);
+		else
+			throw InvalidArgumentException("Cannot assign incompatible socket");
+	}
+	return *this;
+}
+
+
+StreamSocket SecureServerSocket::acceptConnection(SocketAddress& clientAddr)
+{
+	return SecureStreamSocket(impl()->acceptConnection(clientAddr));
+}
+
+
+StreamSocket SecureServerSocket::acceptConnection()
+{
+	SocketAddress clientAddr;
+	return SecureStreamSocket(impl()->acceptConnection(clientAddr));
+}
+
+
+Context::Ptr SecureServerSocket::context() const
+{
+	return static_cast<SecureServerSocketImpl*>(impl())->context();
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/SecureServerSocketImpl.cpp b/base/poco/NetSSL_OpenSSL/src/SecureServerSocketImpl.cpp
new file mode 100644
index 00000000000..1e7d4bf2325
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/SecureServerSocketImpl.cpp
@@ -0,0 +1,122 @@
+//
+// SecureServerSocketImpl.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLSockets
+// Module:  SecureServerSocketImpl
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SecureServerSocketImpl.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+SecureServerSocketImpl::SecureServerSocketImpl(Context::Ptr pContext):
+	_impl(new ServerSocketImpl, pContext)
+{
+}
+
+
+SecureServerSocketImpl::~SecureServerSocketImpl()
+{
+	try
+	{
+		reset();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+SocketImpl* SecureServerSocketImpl::acceptConnection(SocketAddress& clientAddr)
+{
+	return _impl.acceptConnection(clientAddr);
+}
+
+
+void SecureServerSocketImpl::connect(const SocketAddress& address)
+{
+	throw Poco::InvalidAccessException("Cannot connect() a SecureServerSocket");
+}
+
+
+void SecureServerSocketImpl::connect(const SocketAddress& address, const Poco::Timespan& timeout)
+{
+	throw Poco::InvalidAccessException("Cannot connect() a SecureServerSocket");
+}
+	
+
+void SecureServerSocketImpl::connectNB(const SocketAddress& address)
+{
+	throw Poco::InvalidAccessException("Cannot connect() a SecureServerSocket");
+}
+	
+
+void SecureServerSocketImpl::bind(const SocketAddress& address, bool reuseAddress, bool reusePort)
+{
+	_impl.bind(address, reuseAddress, reusePort);
+	reset(_impl.sockfd());
+}
+
+	
+void SecureServerSocketImpl::listen(int backlog)
+{
+	_impl.listen(backlog);
+	reset(_impl.sockfd());
+}
+	
+
+void SecureServerSocketImpl::close()
+{
+	reset();
+	_impl.close();
+}
+	
+
+int SecureServerSocketImpl::sendBytes(const void* buffer, int length, int flags)
+{
+	throw Poco::InvalidAccessException("Cannot sendBytes() on a SecureServerSocket");
+}
+
+
+int SecureServerSocketImpl::receiveBytes(void* buffer, int length, int flags)
+{
+	throw Poco::InvalidAccessException("Cannot receiveBytes() on a SecureServerSocket");
+}
+
+
+int SecureServerSocketImpl::sendTo(const void* buffer, int length, const SocketAddress& address, int flags)
+{
+	throw Poco::InvalidAccessException("Cannot sendTo() on a SecureServerSocket");
+}
+
+
+int SecureServerSocketImpl::receiveFrom(void* buffer, int length, SocketAddress& address, int flags)
+{
+	throw Poco::InvalidAccessException("Cannot receiveFrom() on a SecureServerSocket");
+}
+
+
+void SecureServerSocketImpl::sendUrgent(unsigned char data)
+{
+	throw Poco::InvalidAccessException("Cannot sendUrgent() on a SecureServerSocket");
+}
+
+
+bool SecureServerSocketImpl::secure() const
+{
+	return true;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/SecureSocketImpl.cpp b/base/poco/NetSSL_OpenSSL/src/SecureSocketImpl.cpp
new file mode 100644
index 00000000000..9631c7a401a
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/SecureSocketImpl.cpp
@@ -0,0 +1,633 @@
+//
+// SecureSocketImpl.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLSockets
+// Module:  SecureSocketImpl
+//
+// Copyright (c) 2006-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SecureSocketImpl.h"
+#include "Poco/Net/SSLException.h"
+#include "Poco/Net/Context.h"
+#include "Poco/Net/X509Certificate.h"
+#include "Poco/Net/Utility.h"
+#include "Poco/Net/SecureStreamSocket.h"
+#include "Poco/Net/SecureStreamSocketImpl.h"
+#include "Poco/Net/StreamSocketImpl.h"
+#include "Poco/Net/StreamSocket.h"
+#include "Poco/Net/NetException.h"
+#include "Poco/Net/DNS.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/NumberParser.h"
+#include "Poco/Format.h"
+#include <openssl/x509v3.h>
+#include <openssl/err.h>
+
+
+using Poco::IOException;
+using Poco::TimeoutException;
+using Poco::InvalidArgumentException;
+using Poco::NumberFormatter;
+using Poco::Timespan;
+
+
+// workaround for C++-incompatible macro
+#define POCO_BIO_set_nbio_accept(b,n) BIO_ctrl(b,BIO_C_SET_ACCEPT,1,(void*)((n)?"a":NULL))
+
+
+namespace Poco {
+namespace Net {
+
+struct RemainingTimeCounter
+{
+	explicit RemainingTimeCounter(Poco::Timespan& remainingTime_) : remainingTime(remainingTime_) {};
+	~RemainingTimeCounter()
+	{
+		Poco::Timestamp end;
+		Poco::Timespan waited = end - start;
+		if (waited < remainingTime)
+			remainingTime -= waited;
+		else
+			remainingTime = 0;
+	}
+private:
+	Poco::Timespan& remainingTime;
+	Poco::Timestamp start;
+};
+
+SecureSocketImpl::SecureSocketImpl(Poco::AutoPtr<SocketImpl> pSocketImpl, Context::Ptr pContext):
+	_pSSL(nullptr),
+	_pSocket(pSocketImpl),
+	_pContext(pContext),
+	_needHandshake(false)
+{
+	poco_check_ptr (_pSocket);
+	poco_check_ptr (_pContext);
+}
+
+
+SecureSocketImpl::~SecureSocketImpl()
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	try
+	{
+		reset();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+SocketImpl* SecureSocketImpl::acceptConnection(SocketAddress& clientAddr)
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	poco_assert (!_pSSL);
+
+	StreamSocket ss = _pSocket->acceptConnection(clientAddr);
+	Poco::AutoPtr<SecureStreamSocketImpl> pSecureStreamSocketImpl = new SecureStreamSocketImpl(static_cast<StreamSocketImpl*>(ss.impl()), _pContext);
+	pSecureStreamSocketImpl->acceptSSL();
+	pSecureStreamSocketImpl->duplicate();
+	return pSecureStreamSocketImpl;
+}
+
+
+void SecureSocketImpl::acceptSSL()
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	poco_assert (!_pSSL);
+
+	BIO* pBIO = BIO_new(BIO_s_socket());
+	if (!pBIO) throw SSLException("Cannot create BIO object");
+	BIO_set_fd(pBIO, static_cast<int>(_pSocket->sockfd()), BIO_NOCLOSE);
+
+	_pSSL = SSL_new(_pContext->sslContext());
+	if (!_pSSL)
+	{
+		BIO_free(pBIO);
+		throw SSLException("Cannot create SSL object");
+	}
+	SSL_set_bio(_pSSL, pBIO, pBIO);
+	SSL_set_accept_state(_pSSL);
+	_needHandshake = true;
+}
+
+
+void SecureSocketImpl::connect(const SocketAddress& address, bool performHandshake)
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	if (_pSSL) reset();
+
+	poco_assert (!_pSSL);
+
+	_pSocket->connect(address);
+	connectSSL(performHandshake);
+}
+
+
+void SecureSocketImpl::connect(const SocketAddress& address, const Poco::Timespan& timeout, bool performHandshake)
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	if (_pSSL) reset();
+
+	poco_assert (!_pSSL);
+
+	_pSocket->connect(address, timeout);
+	//FIXME it updates timeouts of SecureStreamSocketImpl::underlying_socket it does not update timeouts of SecureStreamSocketImpl
+	//However, timeouts of SecureStreamSocketImpl are not used in connectSSL() and previous settings are restored after
+	Poco::Timespan receiveTimeout = _pSocket->getReceiveTimeout();
+	Poco::Timespan sendTimeout = _pSocket->getSendTimeout();
+	_pSocket->setReceiveTimeout(timeout);
+	_pSocket->setSendTimeout(timeout);
+	connectSSL(performHandshake);
+	_pSocket->setReceiveTimeout(receiveTimeout);
+	_pSocket->setSendTimeout(sendTimeout);
+}
+
+
+void SecureSocketImpl::connectNB(const SocketAddress& address)
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	if (_pSSL) reset();
+
+	poco_assert (!_pSSL);
+
+	_pSocket->connectNB(address);
+	connectSSL(false);
+}
+
+
+void SecureSocketImpl::connectSSL(bool performHandshake)
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	poco_assert (!_pSSL);
+	poco_assert (_pSocket->initialized());
+
+	BIO* pBIO = BIO_new(BIO_s_socket());
+	if (!pBIO) throw SSLException("Cannot create SSL BIO object");
+	BIO_set_fd(pBIO, static_cast<int>(_pSocket->sockfd()), BIO_NOCLOSE);
+
+	_pSSL = SSL_new(_pContext->sslContext());
+	if (!_pSSL)
+	{
+		BIO_free(pBIO);
+		throw SSLException("Cannot create SSL object");
+	}
+	SSL_set_bio(_pSSL, pBIO, pBIO);
+
+#if OPENSSL_VERSION_NUMBER >= 0x0908060L && !defined(OPENSSL_NO_TLSEXT)
+	if (!_peerHostName.empty())
+	{
+		SSL_set_tlsext_host_name(_pSSL, _peerHostName.c_str());
+	}
+#endif
+
+	if (_pSession)
+	{
+		SSL_set_session(_pSSL, _pSession->sslSession());
+	}
+
+	try
+	{
+		if (performHandshake && _pSocket->getBlocking())
+		{
+			int ret;
+			Poco::Timespan remaining_time = getMaxTimeout();
+			do
+			{
+				RemainingTimeCounter counter(remaining_time);
+				ret = SSL_connect(_pSSL);
+			}
+			while (mustRetry(ret, remaining_time));
+			handleError(ret);
+			verifyPeerCertificate();
+		}
+		else
+		{
+			SSL_set_connect_state(_pSSL);
+			_needHandshake = true;
+		}
+	}
+	catch (...)
+	{
+		SSL_free(_pSSL);
+		_pSSL = 0;
+		throw;
+	}
+}
+
+
+void SecureSocketImpl::bind(const SocketAddress& address, bool reuseAddress, bool reusePort)
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	poco_check_ptr (_pSocket);
+
+	_pSocket->bind(address, reuseAddress, reusePort);
+}
+
+
+void SecureSocketImpl::listen(int backlog)
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	poco_check_ptr (_pSocket);
+
+	_pSocket->listen(backlog);
+}
+
+
+void SecureSocketImpl::shutdown()
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	if (_pSSL)
+	{
+        // Don't shut down the socket more than once.
+        int shutdownState = SSL_get_shutdown(_pSSL);
+        bool shutdownSent = (shutdownState & SSL_SENT_SHUTDOWN) == SSL_SENT_SHUTDOWN;
+        if (!shutdownSent)
+        {
+			// A proper clean shutdown would require us to
+			// retry the shutdown if we get a zero return
+			// value, until SSL_shutdown() returns 1.
+			// However, this will lead to problems with
+			// most web browsers, so we just set the shutdown
+			// flag by calling SSL_shutdown() once and be
+			// done with it.
+			int rc = SSL_shutdown(_pSSL);
+			if (rc < 0) handleError(rc);
+			if (_pSocket->getBlocking())
+			{
+				_pSocket->shutdown();
+			}
+		}
+	}
+}
+
+
+void SecureSocketImpl::close()
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	try
+	{
+		shutdown();
+	}
+	catch (...)
+	{
+	}
+	_pSocket->close();
+}
+
+
+int SecureSocketImpl::sendBytes(const void* buffer, int length, int flags)
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	poco_assert (_pSocket->initialized());
+	poco_check_ptr (_pSSL);
+
+	int rc;
+	if (_needHandshake)
+	{
+		rc = completeHandshake();
+		if (rc == 1)
+			verifyPeerCertificate();
+		else if (rc == 0)
+			throw SSLConnectionUnexpectedlyClosedException();
+		else
+			return rc;
+	}
+
+	Poco::Timespan remaining_time = getMaxTimeout();
+	do
+	{
+		RemainingTimeCounter counter(remaining_time);
+		rc = SSL_write(_pSSL, buffer, length);
+	}
+	while (mustRetry(rc, remaining_time));
+	if (rc <= 0)
+	{
+		rc = handleError(rc);
+		if (rc == 0) throw SSLConnectionUnexpectedlyClosedException();
+	}
+	return rc;
+}
+
+
+int SecureSocketImpl::receiveBytes(void* buffer, int length, int flags)
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	poco_assert (_pSocket->initialized());
+	poco_check_ptr (_pSSL);
+
+	/// Special case: just check that we can read from socket
+	if ((flags & MSG_DONTWAIT) && (flags & MSG_PEEK))
+		return _pSocket->receiveBytes(buffer, length, flags);
+
+	int rc;
+	if (_needHandshake)
+	{
+		rc = completeHandshake();
+		if (rc == 1)
+			verifyPeerCertificate();
+		else
+			return rc;
+	}
+
+	Poco::Timespan remaining_time = getMaxTimeout();
+	do
+	{
+		/// SSL record may consist of several TCP packets,
+		/// so thread can be blocked on recv/send and epoll_wait several times
+		/// until SSL_read will return rc > 0. Let's use our own time counter.
+		RemainingTimeCounter counter(remaining_time);
+		rc = SSL_read(_pSSL, buffer, length);
+	}
+	while (mustRetry(rc, remaining_time));
+	if (rc <= 0)
+	{
+		return handleError(rc);
+	}
+	return rc;
+}
+
+
+int SecureSocketImpl::available() const
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	poco_check_ptr (_pSSL);
+
+	return SSL_pending(_pSSL);
+}
+
+
+int SecureSocketImpl::completeHandshake()
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	poco_assert (_pSocket->initialized());
+	poco_check_ptr (_pSSL);
+
+	int rc;
+	Poco::Timespan remaining_time = getMaxTimeout();
+	do
+	{
+		RemainingTimeCounter counter(remaining_time);
+		rc = SSL_do_handshake(_pSSL);
+	}
+	while (mustRetry(rc, remaining_time));
+	if (rc <= 0)
+	{
+		return handleError(rc);
+	}
+	_needHandshake = false;
+	return rc;
+}
+
+
+void SecureSocketImpl::verifyPeerCertificate()
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	if (_peerHostName.empty())
+		verifyPeerCertificate(_pSocket->peerAddress().host().toString());
+	else
+		verifyPeerCertificate(_peerHostName);
+}
+
+
+void SecureSocketImpl::verifyPeerCertificate(const std::string& hostName)
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	long certErr = verifyPeerCertificateImpl(hostName);
+	if (certErr != X509_V_OK)
+	{
+		std::string msg = Utility::convertCertificateError(certErr);
+		throw CertificateValidationException("Unacceptable certificate from " + hostName, msg);
+	}
+}
+
+
+long SecureSocketImpl::verifyPeerCertificateImpl(const std::string& hostName)
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	Context::VerificationMode mode = _pContext->verificationMode();
+	if (mode == Context::VERIFY_NONE || !_pContext->extendedCertificateVerificationEnabled() ||
+	    (mode != Context::VERIFY_STRICT && isLocalHost(hostName)))
+	{
+		return X509_V_OK;
+	}
+
+	X509* pCert = SSL_get_peer_certificate(_pSSL);
+	if (pCert)
+	{
+		X509Certificate cert(pCert);
+		return cert.verify(hostName) ? X509_V_OK : X509_V_ERR_APPLICATION_VERIFICATION;
+	}
+	else return X509_V_OK;
+}
+
+/// This is static method, that's why no lock
+bool SecureSocketImpl::isLocalHost(const std::string& hostName)
+{
+	try
+	{
+		SocketAddress addr(hostName, 0);
+		return addr.host().isLoopback();
+	}
+	catch (Poco::Exception&)
+	{
+		return false;
+	}
+}
+
+
+X509* SecureSocketImpl::peerCertificate() const
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	if (_pSSL)
+		return SSL_get_peer_certificate(_pSSL);
+	else
+		return 0;
+}
+
+Poco::Timespan SecureSocketImpl::getMaxTimeout()
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	Poco::Timespan remaining_time = _pSocket->getReceiveTimeout();
+	Poco::Timespan send_timeout = _pSocket->getSendTimeout();
+	if (remaining_time < send_timeout)
+		remaining_time = send_timeout;
+	return remaining_time;
+}
+
+bool SecureSocketImpl::mustRetry(int rc, Poco::Timespan& remaining_time)
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	if (rc <= 0)
+	{
+		int sslError = SSL_get_error(_pSSL, rc);
+		int socketError = _pSocket->lastError();
+		switch (sslError)
+		{
+		case SSL_ERROR_WANT_READ:
+			if (_pSocket->getBlocking())
+			{
+				/// Level-triggered mode of epoll_wait is used, so if SSL_read don't read all available data from socket,
+				/// epoll_wait returns true without waiting for new data even if remaining_time == 0
+				if (_pSocket->pollImpl(remaining_time, Poco::Net::Socket::SELECT_READ) && remaining_time != 0)
+					return true;
+				else
+					throw Poco::TimeoutException();
+			}
+			break;
+		case SSL_ERROR_WANT_WRITE:
+			if (_pSocket->getBlocking())
+			{
+				/// The same as for SSL_ERROR_WANT_READ
+				if (_pSocket->pollImpl(remaining_time, Poco::Net::Socket::SELECT_WRITE) && remaining_time != 0)
+					return true;
+				else
+					throw Poco::TimeoutException();
+			}
+			break;
+		case SSL_ERROR_SYSCALL:
+			return socketError == POCO_EAGAIN || socketError == POCO_EINTR;
+		default:
+			return socketError == POCO_EINTR;
+		}
+	}
+	return false;
+}
+
+
+int SecureSocketImpl::handleError(int rc)
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	if (rc > 0) return rc;
+
+	int sslError = SSL_get_error(_pSSL, rc);
+	int error = SocketImpl::lastError();
+
+	switch (sslError)
+	{
+	case SSL_ERROR_ZERO_RETURN:
+		return 0;
+	case SSL_ERROR_WANT_READ:
+		return SecureStreamSocket::ERR_SSL_WANT_READ;
+	case SSL_ERROR_WANT_WRITE:
+		return SecureStreamSocket::ERR_SSL_WANT_WRITE;
+	case SSL_ERROR_WANT_CONNECT:
+	case SSL_ERROR_WANT_ACCEPT:
+	case SSL_ERROR_WANT_X509_LOOKUP:
+		// these should not occur
+		poco_bugcheck();
+		return rc;
+	case SSL_ERROR_SYSCALL:
+		if (error != 0)
+		{
+			SocketImpl::error(error);
+		}
+		// fallthrough
+	default:
+		{
+			long lastError = ERR_get_error();
+			if (lastError == 0)
+			{
+				if (rc == 0)
+				{
+					// Most web browsers do this, don't report an error
+					if (_pContext->isForServerUse())
+						return 0;
+					else
+						throw SSLConnectionUnexpectedlyClosedException();
+				}
+				else if (rc == -1)
+				{
+					throw SSLConnectionUnexpectedlyClosedException();
+				}
+				else
+				{
+					SecureStreamSocketImpl::error(Poco::format("The BIO reported an error: %d", rc));
+				}
+			}
+			else
+			{
+				char buffer[256];
+				ERR_error_string_n(lastError, buffer, sizeof(buffer));
+				std::string msg(buffer);
+				throw SSLException(msg);
+			}
+		}
+ 		break;
+	}
+	return rc;
+}
+
+
+void SecureSocketImpl::setPeerHostName(const std::string& peerHostName)
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	_peerHostName = peerHostName;
+}
+
+
+void SecureSocketImpl::reset()
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	close();
+	if (_pSSL)
+	{
+		SSL_free(_pSSL);
+		_pSSL = nullptr;
+	}
+}
+
+
+void SecureSocketImpl::abort()
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	_pSocket->shutdown();
+}
+
+
+Session::Ptr SecureSocketImpl::currentSession()
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	if (_pSSL)
+	{
+		SSL_SESSION* pSession = SSL_get1_session(_pSSL);
+		if (pSession)
+		{
+			if (_pSession && pSession == _pSession->sslSession())
+			{
+				SSL_SESSION_free(pSession);
+				return _pSession;
+			}
+			else return new Session(pSession);
+		}
+	}
+	return 0;
+}
+
+
+void SecureSocketImpl::useSession(Session::Ptr pSession)
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	_pSession = pSession;
+}
+
+
+bool SecureSocketImpl::sessionWasReused()
+{
+	std::lock_guard<std::recursive_mutex> lock(_mutex);
+	if (_pSSL)
+		return SSL_session_reused(_pSSL) != 0;
+	else
+		return false;
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/SecureStreamSocket.cpp b/base/poco/NetSSL_OpenSSL/src/SecureStreamSocket.cpp
new file mode 100644
index 00000000000..f4766ca6f97
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/SecureStreamSocket.cpp
@@ -0,0 +1,287 @@
+//
+// SecureStreamSocket.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLSockets
+// Module:  SecureStreamSocket
+//
+// Copyright (c) 2006-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SecureStreamSocket.h"
+#include "Poco/Net/SecureStreamSocketImpl.h"
+#include "Poco/Net/SocketImpl.h"
+#include "Poco/Net/SSLManager.h"
+#include "Poco/Exception.h"
+
+
+using Poco::InvalidArgumentException;
+
+
+namespace Poco {
+namespace Net {
+
+
+SecureStreamSocket::SecureStreamSocket(): 
+	StreamSocket(new SecureStreamSocketImpl(SSLManager::instance().defaultClientContext()))
+{
+}
+
+
+SecureStreamSocket::SecureStreamSocket(Context::Ptr pContext): 
+	StreamSocket(new SecureStreamSocketImpl(pContext))
+{
+}
+
+
+SecureStreamSocket::SecureStreamSocket(Context::Ptr pContext, Session::Ptr pSession): 
+	StreamSocket(new SecureStreamSocketImpl(pContext))
+{
+	useSession(pSession);
+}
+
+
+SecureStreamSocket::SecureStreamSocket(const SocketAddress& address): 
+	StreamSocket(new SecureStreamSocketImpl(SSLManager::instance().defaultClientContext()))
+{
+	connect(address);
+}
+
+
+SecureStreamSocket::SecureStreamSocket(const SocketAddress& address, const std::string& hostName): 
+	StreamSocket(new SecureStreamSocketImpl(SSLManager::instance().defaultClientContext()))
+{
+	static_cast<SecureStreamSocketImpl*>(impl())->setPeerHostName(hostName);
+	connect(address);
+}
+
+
+SecureStreamSocket::SecureStreamSocket(const SocketAddress& address, Context::Ptr pContext): 
+	StreamSocket(new SecureStreamSocketImpl(pContext))
+{
+	connect(address);
+}
+
+
+SecureStreamSocket::SecureStreamSocket(const SocketAddress& address, Context::Ptr pContext, Session::Ptr pSession): 
+	StreamSocket(new SecureStreamSocketImpl(pContext))
+{
+	useSession(pSession);
+	connect(address);
+}
+
+
+SecureStreamSocket::SecureStreamSocket(const SocketAddress& address, const std::string& hostName, Context::Ptr pContext): 
+	StreamSocket(new SecureStreamSocketImpl(pContext))
+{
+	static_cast<SecureStreamSocketImpl*>(impl())->setPeerHostName(hostName);
+	connect(address);
+}
+
+
+SecureStreamSocket::SecureStreamSocket(const SocketAddress& address, const std::string& hostName, Context::Ptr pContext, Session::Ptr pSession): 
+	StreamSocket(new SecureStreamSocketImpl(pContext))
+{
+	static_cast<SecureStreamSocketImpl*>(impl())->setPeerHostName(hostName);
+	useSession(pSession);
+	connect(address);
+}
+
+
+SecureStreamSocket::SecureStreamSocket(const Socket& socket): 
+	StreamSocket(socket)
+{
+	if (!dynamic_cast<SecureStreamSocketImpl*>(impl()))
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+}
+
+
+SecureStreamSocket::SecureStreamSocket(SocketImpl* pImpl): 
+	StreamSocket(pImpl)
+{
+	if (!dynamic_cast<SecureStreamSocketImpl*>(impl()))
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+}
+
+
+SecureStreamSocket::~SecureStreamSocket()
+{
+}
+
+
+SecureStreamSocket& SecureStreamSocket::operator = (const Socket& socket)
+{
+	if (dynamic_cast<SecureStreamSocketImpl*>(socket.impl()))
+		StreamSocket::operator = (socket);
+	else
+		throw InvalidArgumentException("Cannot assign incompatible socket");
+	return *this;
+}
+
+
+bool SecureStreamSocket::havePeerCertificate() const
+{
+	return static_cast<SecureStreamSocketImpl*>(impl())->havePeerCertificate();
+}
+
+
+X509Certificate SecureStreamSocket::peerCertificate() const
+{
+	return static_cast<SecureStreamSocketImpl*>(impl())->peerCertificate();
+}
+
+
+void SecureStreamSocket::setPeerHostName(const std::string& hostName)
+{
+	static_cast<SecureStreamSocketImpl*>(impl())->setPeerHostName(hostName);
+}
+
+	
+const std::string& SecureStreamSocket::getPeerHostName() const
+{
+	return static_cast<SecureStreamSocketImpl*>(impl())->getPeerHostName();
+}
+
+
+SecureStreamSocket SecureStreamSocket::attach(const StreamSocket& streamSocket)
+{
+	SecureStreamSocketImpl* pImpl = new SecureStreamSocketImpl(static_cast<StreamSocketImpl*>(streamSocket.impl()), SSLManager::instance().defaultClientContext());
+	SecureStreamSocket result(pImpl);
+	if (pImpl->context()->isForServerUse())
+		pImpl->acceptSSL();
+	else
+		pImpl->connectSSL();
+	return result;
+}
+
+
+SecureStreamSocket SecureStreamSocket::attach(const StreamSocket& streamSocket, Context::Ptr pContext)
+{
+	SecureStreamSocketImpl* pImpl = new SecureStreamSocketImpl(static_cast<StreamSocketImpl*>(streamSocket.impl()), pContext);
+	SecureStreamSocket result(pImpl);
+	if (pImpl->context()->isForServerUse())
+		pImpl->acceptSSL();
+	else
+		pImpl->connectSSL();
+	return result;
+}
+
+
+SecureStreamSocket SecureStreamSocket::attach(const StreamSocket& streamSocket, Context::Ptr pContext, Session::Ptr pSession)
+{
+	SecureStreamSocketImpl* pImpl = new SecureStreamSocketImpl(static_cast<StreamSocketImpl*>(streamSocket.impl()), pContext);
+	SecureStreamSocket result(pImpl);
+	result.useSession(pSession);
+	if (pImpl->context()->isForServerUse())
+		pImpl->acceptSSL();
+	else
+		pImpl->connectSSL();
+	return result;
+}
+
+
+SecureStreamSocket SecureStreamSocket::attach(const StreamSocket& streamSocket, const std::string& peerHostName)
+{
+	SecureStreamSocketImpl* pImpl = new SecureStreamSocketImpl(static_cast<StreamSocketImpl*>(streamSocket.impl()), SSLManager::instance().defaultClientContext());
+	SecureStreamSocket result(pImpl);
+	result.setPeerHostName(peerHostName);
+	if (pImpl->context()->isForServerUse())
+		pImpl->acceptSSL();
+	else
+		pImpl->connectSSL();
+	return result;
+}
+
+
+SecureStreamSocket SecureStreamSocket::attach(const StreamSocket& streamSocket, const std::string& peerHostName, Context::Ptr pContext)
+{
+	SecureStreamSocketImpl* pImpl = new SecureStreamSocketImpl(static_cast<StreamSocketImpl*>(streamSocket.impl()), pContext);
+	SecureStreamSocket result(pImpl);
+	result.setPeerHostName(peerHostName);
+	if (pImpl->context()->isForServerUse())
+		pImpl->acceptSSL();
+	else
+		pImpl->connectSSL();
+	return result;
+}
+
+
+SecureStreamSocket SecureStreamSocket::attach(const StreamSocket& streamSocket, const std::string& peerHostName, Context::Ptr pContext, Session::Ptr pSession)
+{
+	SecureStreamSocketImpl* pImpl = new SecureStreamSocketImpl(static_cast<StreamSocketImpl*>(streamSocket.impl()), pContext);
+	SecureStreamSocket result(pImpl);
+	result.setPeerHostName(peerHostName);
+	result.useSession(pSession);
+	if (pImpl->context()->isForServerUse())
+		pImpl->acceptSSL();
+	else
+		pImpl->connectSSL();
+	return result;
+}
+
+
+Context::Ptr SecureStreamSocket::context() const
+{
+	return static_cast<SecureStreamSocketImpl*>(impl())->context();
+}
+
+
+void SecureStreamSocket::setLazyHandshake(bool flag)
+{
+	static_cast<SecureStreamSocketImpl*>(impl())->setLazyHandshake(flag);
+}
+
+	
+bool SecureStreamSocket::getLazyHandshake() const
+{
+	return static_cast<SecureStreamSocketImpl*>(impl())->getLazyHandshake();
+}
+
+
+void SecureStreamSocket::verifyPeerCertificate()
+{
+	static_cast<SecureStreamSocketImpl*>(impl())->verifyPeerCertificate();
+}
+
+
+void SecureStreamSocket::verifyPeerCertificate(const std::string& hostName)
+{
+	static_cast<SecureStreamSocketImpl*>(impl())->verifyPeerCertificate(hostName);
+}
+
+
+int SecureStreamSocket::completeHandshake()
+{
+	return static_cast<SecureStreamSocketImpl*>(impl())->completeHandshake();
+}
+
+
+Session::Ptr SecureStreamSocket::currentSession()
+{
+	return static_cast<SecureStreamSocketImpl*>(impl())->currentSession();
+}
+
+	
+void SecureStreamSocket::useSession(Session::Ptr pSession)
+{
+	static_cast<SecureStreamSocketImpl*>(impl())->useSession(pSession);
+}
+
+	
+bool SecureStreamSocket::sessionWasReused()
+{
+	return static_cast<SecureStreamSocketImpl*>(impl())->sessionWasReused();
+}
+
+
+void SecureStreamSocket::abort()
+{
+	static_cast<SecureStreamSocketImpl*>(impl())->abort();
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/SecureStreamSocketImpl.cpp b/base/poco/NetSSL_OpenSSL/src/SecureStreamSocketImpl.cpp
new file mode 100644
index 00000000000..aa1a96e1585
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/SecureStreamSocketImpl.cpp
@@ -0,0 +1,241 @@
+//
+// SecureStreamSocketImpl.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLSockets
+// Module:  SecureStreamSocketImpl
+//
+// Copyright (c) 2006-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/SecureStreamSocketImpl.h"
+#include "Poco/Net/SSLException.h"
+#include "Poco/Thread.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+SecureStreamSocketImpl::SecureStreamSocketImpl(Context::Ptr pContext):
+    underlying_socket(new StreamSocketImpl),
+	_impl(underlying_socket, pContext),
+	_lazyHandshake(false)
+{
+}
+
+
+SecureStreamSocketImpl::SecureStreamSocketImpl(StreamSocketImpl* pStreamSocket, Context::Ptr pContext):
+    underlying_socket(pStreamSocket),
+	_impl(underlying_socket, pContext),
+	_lazyHandshake(false)
+{
+	pStreamSocket->duplicate();
+	reset(_impl.sockfd());
+}
+
+
+SecureStreamSocketImpl::~SecureStreamSocketImpl()
+{
+	try
+	{
+		reset();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+void SecureStreamSocketImpl::setSendTimeout(const Poco::Timespan& timeout)
+{
+    underlying_socket->setSendTimeout(timeout);
+    _sndTimeout = underlying_socket->getSendTimeout();
+}
+
+void SecureStreamSocketImpl::setReceiveTimeout(const Poco::Timespan& timeout)
+{
+    underlying_socket->setReceiveTimeout(timeout);
+    _recvTimeout = underlying_socket->getReceiveTimeout();
+}
+
+SocketImpl* SecureStreamSocketImpl::acceptConnection(SocketAddress& clientAddr)
+{
+	throw Poco::InvalidAccessException("Cannot acceptConnection() on a SecureStreamSocketImpl");
+}
+
+
+void SecureStreamSocketImpl::acceptSSL()
+{
+	_impl.acceptSSL();
+}
+
+
+void SecureStreamSocketImpl::connect(const SocketAddress& address)
+{
+	_impl.connect(address, !_lazyHandshake);
+	reset(_impl.sockfd());
+}
+
+
+void SecureStreamSocketImpl::connect(const SocketAddress& address, const Poco::Timespan& timeout)
+{
+	_impl.connect(address, timeout, !_lazyHandshake);
+	reset(_impl.sockfd());
+}
+	
+
+void SecureStreamSocketImpl::connectNB(const SocketAddress& address)
+{
+	_impl.connectNB(address);
+	reset(_impl.sockfd());
+}
+
+
+void SecureStreamSocketImpl::connectSSL()
+{
+	_impl.connectSSL(!_lazyHandshake);
+}
+	
+
+void SecureStreamSocketImpl::bind(const SocketAddress& address, bool reuseAddress, bool reusePort)
+{
+	throw Poco::InvalidAccessException("Cannot bind() a SecureStreamSocketImpl");
+}
+
+	
+void SecureStreamSocketImpl::listen(int backlog)
+{
+	throw Poco::InvalidAccessException("Cannot listen() on a SecureStreamSocketImpl");
+}
+	
+
+void SecureStreamSocketImpl::close()
+{
+	reset();
+	_impl.close();
+}
+
+
+void SecureStreamSocketImpl::abort()
+{
+	reset();
+	_impl.abort();
+}
+
+
+int SecureStreamSocketImpl::sendBytes(const void* buffer, int length, int flags)
+{
+	return _impl.sendBytes(buffer, length, flags);
+}
+
+
+int SecureStreamSocketImpl::receiveBytes(void* buffer, int length, int flags)
+{
+	return _impl.receiveBytes(buffer, length, flags);
+}
+
+
+int SecureStreamSocketImpl::sendTo(const void* buffer, int length, const SocketAddress& address, int flags)
+{
+	throw Poco::InvalidAccessException("Cannot sendTo() on a SecureStreamSocketImpl");
+}
+
+
+int SecureStreamSocketImpl::receiveFrom(void* buffer, int length, SocketAddress& address, int flags)
+{
+	throw Poco::InvalidAccessException("Cannot receiveFrom() on a SecureStreamSocketImpl");
+}
+
+
+void SecureStreamSocketImpl::sendUrgent(unsigned char data)
+{
+	throw Poco::InvalidAccessException("Cannot sendUrgent() on a SecureStreamSocketImpl");
+}
+
+
+int SecureStreamSocketImpl::available()
+{
+	return _impl.available();
+}
+
+
+void SecureStreamSocketImpl::shutdownReceive()
+{
+}
+
+	
+void SecureStreamSocketImpl::shutdownSend()
+{
+}
+
+	
+void SecureStreamSocketImpl::shutdown()
+{
+	_impl.shutdown();
+}
+
+
+bool SecureStreamSocketImpl::secure() const
+{
+	return true;
+}
+
+
+bool SecureStreamSocketImpl::havePeerCertificate() const
+{
+	X509* pCert = _impl.peerCertificate();
+	if (pCert)
+	{
+		X509_free(pCert);
+		return true;
+	}
+	else return false;
+}
+
+
+X509Certificate SecureStreamSocketImpl::peerCertificate() const
+{
+	X509* pCert = _impl.peerCertificate();
+	if (pCert)
+		return X509Certificate(pCert);
+	else
+		throw SSLException("No certificate available");
+}
+
+
+void SecureStreamSocketImpl::setLazyHandshake(bool flag)
+{
+	_lazyHandshake = flag;
+}
+
+	
+bool SecureStreamSocketImpl::getLazyHandshake() const
+{
+	return _lazyHandshake;
+}
+
+
+void SecureStreamSocketImpl::verifyPeerCertificate()
+{
+	_impl.verifyPeerCertificate();
+}
+
+
+void SecureStreamSocketImpl::verifyPeerCertificate(const std::string& hostName)
+{
+	_impl.verifyPeerCertificate(hostName);
+}
+
+
+int SecureStreamSocketImpl::completeHandshake()
+{
+	return _impl.completeHandshake();
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/Session.cpp b/base/poco/NetSSL_OpenSSL/src/Session.cpp
new file mode 100644
index 00000000000..96a507d9469
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/Session.cpp
@@ -0,0 +1,40 @@
+//
+// Session.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  Session
+//
+// Copyright (c) 2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#if defined(__APPLE__)
+// Some OpenSSL functions are deprecated in OS X 10.7
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations" 
+#endif
+
+
+#include "Poco/Net/Session.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+Session::Session(SSL_SESSION* pSession):
+	_pSession(pSession)
+{
+}
+
+
+Session::~Session()
+{
+	SSL_SESSION_free(_pSession);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/Utility.cpp b/base/poco/NetSSL_OpenSSL/src/Utility.cpp
new file mode 100644
index 00000000000..5428b769968
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/Utility.cpp
@@ -0,0 +1,71 @@
+//
+// Utility.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  Utility
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/Utility.h"
+#include "Poco/String.h"
+#include "Poco/Util/OptionException.h"
+#include <openssl/err.h>
+
+
+namespace Poco {
+namespace Net {
+
+
+Context::VerificationMode Utility::convertVerificationMode(const std::string& vMode)
+{
+	std::string mode = Poco::toLower(vMode);
+	Context::VerificationMode verMode = Context::VERIFY_STRICT;
+
+	if (mode == "none")
+		verMode = Context::VERIFY_NONE;
+	else if (mode == "relaxed")
+		verMode = Context::VERIFY_RELAXED;
+	else if (mode == "strict")
+		verMode = Context::VERIFY_STRICT;
+	else if (mode == "once")
+		verMode = Context::VERIFY_ONCE;
+	else
+		throw Poco::InvalidArgumentException("Invalid verification mode. Should be relaxed, strict or once but got", vMode);
+
+	return verMode;
+}
+
+
+std::string Utility::convertCertificateError(long errCode)
+{
+	std::string errMsg(X509_verify_cert_error_string(errCode));
+	return errMsg;
+}
+
+
+std::string Utility::getLastError()
+{
+	unsigned long errCode = ERR_get_error();
+	if (errCode != 0)
+	{
+		char buffer[256];
+		ERR_error_string_n(errCode, buffer, sizeof(buffer));
+		return std::string(buffer);
+	}
+	else return "No error";
+}
+
+
+void Utility::clearErrorStack()
+{
+	ERR_clear_error();
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/VerificationErrorArgs.cpp b/base/poco/NetSSL_OpenSSL/src/VerificationErrorArgs.cpp
new file mode 100644
index 00000000000..f7f6451b1cb
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/VerificationErrorArgs.cpp
@@ -0,0 +1,37 @@
+//
+// VerificationErrorArgs.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  VerificationErrorArgs
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/VerificationErrorArgs.h"
+
+
+namespace Poco {
+namespace Net {
+
+
+VerificationErrorArgs::VerificationErrorArgs(const X509Certificate& cert, int errDepth, int errNum, const std::string& errMsg):
+	_cert(cert),
+	_errorDepth(errDepth),
+	_errorNumber(errNum),
+	_errorMessage(errMsg),
+	_ignoreError(false)
+{
+}
+
+
+VerificationErrorArgs::~VerificationErrorArgs()
+{
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/NetSSL_OpenSSL/src/X509Certificate.cpp b/base/poco/NetSSL_OpenSSL/src/X509Certificate.cpp
new file mode 100644
index 00000000000..54651c3ac87
--- /dev/null
+++ b/base/poco/NetSSL_OpenSSL/src/X509Certificate.cpp
@@ -0,0 +1,175 @@
+//
+// X509Certificate.cpp
+//
+// Library: NetSSL_OpenSSL
+// Package: SSLCore
+// Module:  X509Certificate
+//
+// Copyright (c) 2006-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Net/X509Certificate.h"
+#include "Poco/Net/SSLException.h"
+#include "Poco/Net/SSLManager.h"
+#include "Poco/Net/DNS.h"
+#include "Poco/TemporaryFile.h"
+#include "Poco/FileStream.h"
+#include "Poco/StreamCopier.h"
+#include "Poco/String.h"
+#include "Poco/RegularExpression.h"
+#include "Poco/DateTimeParser.h"
+#include <openssl/pem.h>
+#include <openssl/x509v3.h>
+#include <openssl/err.h>
+
+
+namespace Poco {
+namespace Net {
+
+
+X509Certificate::X509Certificate(std::istream& istr):
+	Poco::Crypto::X509Certificate(istr)
+{	
+}
+
+
+X509Certificate::X509Certificate(const std::string& path):
+	Poco::Crypto::X509Certificate(path)
+{
+}
+
+
+X509Certificate::X509Certificate(X509* pCert):
+	Poco::Crypto::X509Certificate(pCert)
+{
+}
+
+
+X509Certificate::X509Certificate(X509* pCert, bool shared):
+	Poco::Crypto::X509Certificate(pCert, shared)
+{
+}
+
+
+X509Certificate::X509Certificate(const Poco::Crypto::X509Certificate& cert):
+	Poco::Crypto::X509Certificate(cert)
+{
+}
+
+
+X509Certificate& X509Certificate::operator = (const Poco::Crypto::X509Certificate& cert)
+{
+	X509Certificate tmp(cert);
+	swap(tmp);
+	return *this;
+}
+
+
+X509Certificate::~X509Certificate()
+{
+}
+
+
+bool X509Certificate::verify(const std::string& hostName) const
+{
+	return verify(*this, hostName);
+}
+
+
+bool X509Certificate::verify(const Poco::Crypto::X509Certificate& certificate, const std::string& hostName)
+{		
+#if OPENSSL_VERSION_NUMBER < 0x10002000L
+	std::string commonName;
+	std::set<std::string> dnsNames;
+	certificate.extractNames(commonName, dnsNames);
+	if (!commonName.empty()) dnsNames.insert(commonName);
+	bool ok = (dnsNames.find(hostName) != dnsNames.end());
+	if (!ok)
+	{
+		for (std::set<std::string>::const_iterator it = dnsNames.begin(); !ok && it != dnsNames.end(); ++it)
+		{
+			try
+			{
+				// two cases: name contains wildcards or not
+				if (containsWildcards(*it))
+				{
+					// a compare by IPAddress is not possible with wildcards
+					// only allow compare by name
+					ok = matchWildcard(*it, hostName);
+				}
+				else
+				{
+					// it depends on hostName whether we compare by IP or by alias
+					IPAddress ip;
+					if (IPAddress::tryParse(hostName, ip))
+					{
+						// compare by IP
+						const HostEntry& heData = DNS::resolve(*it);
+						const HostEntry::AddressList& addr = heData.addresses();
+						HostEntry::AddressList::const_iterator it = addr.begin();
+						HostEntry::AddressList::const_iterator itEnd = addr.end();
+						for (; it != itEnd && !ok; ++it)
+						{
+							ok = (*it == ip);
+						}
+					}
+					else
+					{
+						ok = Poco::icompare(*it, hostName) == 0;
+					}
+				}
+			}
+			catch (NoAddressFoundException&)
+			{
+			}
+			catch (HostNotFoundException&)
+			{
+			}
+		}
+	}
+	return ok;
+#else
+	if (X509_check_host(const_cast<X509*>(certificate.certificate()), hostName.c_str(), hostName.length(), 0, NULL) == 1)
+	{
+		return true;
+	}
+	else
+	{
+		IPAddress ip;
+		if (IPAddress::tryParse(hostName, ip))
+		{
+		    return (X509_check_ip_asc(const_cast<X509*>(certificate.certificate()), hostName.c_str(), 0) == 1);
+		}
+	}
+	return false;
+#endif
+}
+
+
+bool X509Certificate::containsWildcards(const std::string& commonName)
+{
+	return (commonName.find('*') != std::string::npos || commonName.find('?') != std::string::npos);
+}
+
+
+bool X509Certificate::matchWildcard(const std::string& wildcard, const std::string& hostName)
+{
+	// fix wildcards
+	std::string wildcardExpr("^");
+	wildcardExpr += Poco::replace(wildcard, ".", "\\.");
+	Poco::replaceInPlace(wildcardExpr, "*", ".*");
+	Poco::replaceInPlace(wildcardExpr, "..*", ".*");
+	Poco::replaceInPlace(wildcardExpr, "?", ".?");
+	Poco::replaceInPlace(wildcardExpr, "..?", ".?");
+	wildcardExpr += "$";
+
+	Poco::RegularExpression expr(wildcardExpr, Poco::RegularExpression::RE_CASELESS);
+	return expr.match(hostName);
+}
+
+
+} } // namespace Poco::Net
diff --git a/base/poco/README.md b/base/poco/README.md
new file mode 100644
index 00000000000..3710a75ef5a
--- /dev/null
+++ b/base/poco/README.md
@@ -0,0 +1,38 @@
+![alt text][logo]
+
+
+[![Travis Build Status](https://travis-ci.org/pocoproject/poco.png?branch=master)](https://travis-ci.org/pocoproject/poco)
+[![Build status](https://ci.appveyor.com/api/projects/status/7iyrx3f233s3akae/branch/master?svg=true)](https://ci.appveyor.com/project/obiltschnig/poco/branch/master)
+[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/370/badge)](https://bestpractices.coreinfrastructure.org/projects/370)
+
+
+POCO (Portable Components) C++ Libraries are:
+---------------------------------------------
+
+- A collection of C++ class libraries, conceptually similar to the Java Class Library, the .NET Framework or Apple’s Cocoa.
+- Focused on solutions to frequently-encountered practical problems.
+- Focused on ‘internet-age’ network-centric applications.
+- Written in efficient, modern, 100% ANSI/ISO Standard C++.
+- Based on and complementing the C++ Standard Library/STL.
+- Highly portable and available on many different platforms, from embedded to server.
+- Open Source, licensed under the [Boost Software License](https://spdx.org/licenses/BSL-1.0).
+
+![alt text][overview]
+
+----
+To start using POCO, see the [Guided Tour](https://pocoproject.org/docs/00100-GuidedTour.html)
+and [Getting Started](https://pocoproject.org/docs/00200-GettingStarted.html) documents.
+
+----
+POCO has an active user and contributing community, please visit our [web site](https://pocoproject.org) and [blog](https://pocoproject.org/blog).
+Answers to POCO-related questions can also be found on [Stack Overflow](https://stackoverflow.com/questions/tagged/poco-libraries).
+
+Please see [CONTRIBUTING](CONTRIBUTING.md) for submitting contributions, bugs reports, feature requests or security issues.
+
+----
+In regards to Boost, in spite of some functional overlapping,
+POCO is best thought of as a Boost complement (rather than replacement).
+Side-by-side use of Boost and POCO is a very common occurrence.
+
+[overview]: doc/images/overview.png "Poco Overview"
+[logo]: doc/images/logo.png "Poco Logo"
diff --git a/base/poco/Redis/CMakeLists.txt b/base/poco/Redis/CMakeLists.txt
new file mode 100644
index 00000000000..562957140ba
--- /dev/null
+++ b/base/poco/Redis/CMakeLists.txt
@@ -0,0 +1,8 @@
+file (GLOB SRCS src/*.cpp)
+
+add_library (_poco_redis ${SRCS})
+add_library (Poco::Redis ALIAS _poco_redis)
+
+target_compile_options (_poco_redis PRIVATE -Wno-shadow)
+target_include_directories (_poco_redis SYSTEM PUBLIC "include")
+target_link_libraries (_poco_redis PUBLIC Poco::Net)
diff --git a/base/poco/Redis/include/Poco/Redis/Array.h b/base/poco/Redis/include/Poco/Redis/Array.h
new file mode 100644
index 00000000000..262abc9a441
--- /dev/null
+++ b/base/poco/Redis/include/Poco/Redis/Array.h
@@ -0,0 +1,322 @@
+//
+// Array.h
+//
+// Library: Redis
+// Package: Redis
+// Module:  Array
+//
+// Definition of the Array class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Redis_Array_INCLUDED
+#define Redis_Array_INCLUDED
+
+
+#include "Poco/Redis/Redis.h"
+#include "Poco/Redis/Type.h"
+#include "Poco/Redis/Exception.h"
+#include <vector>
+#include <sstream>
+
+
+namespace Poco {
+namespace Redis {
+
+
+class Redis_API Array
+	/// Represents a Redis Array. An Array can contain Integers, Strings,
+	/// Bulk Strings, Errors and other Arrays. It can also contain a Null
+	/// value.
+{
+public:
+	typedef std::vector<RedisType::Ptr>::const_iterator const_iterator;
+
+	Array();
+		/// Creates an Array. As long as there are no elements added,
+		/// the array will contain a Null value.
+
+	Array(const Array& copy);
+		/// Creates an Array by copying another one.
+
+	virtual ~Array();
+		/// Destroys the Array.
+
+	template<typename T>
+	Array& operator<<(const T& arg)
+		/// Adds the argument to the array.
+		///
+		/// Note: a std::string will be added as a BulkString because this
+		/// is commonly used for representing strings in Redis. If you
+		/// really need a simple string, use addSimpleString().
+	{
+		return add(arg);
+	}
+
+	Array& operator<<(const char* s);
+		/// Special implementation for const char*.
+		///
+		/// Note: the specialization creates a BulkString. If you need
+		/// a simple string, call addSimpleString().
+
+	Array& operator<<(const std::vector<std::string>& strings);
+		/// Special implementation for a vector with strings.
+		/// All strings will be added as a BulkString.
+
+	Array& add();
+		/// Adds an Null BulkString.
+
+	template<typename T>
+	Array& add(const T& arg)
+		/// Adds an element to the array.
+		///
+		/// Note: the specialization for std::string will add a BulkString!
+		/// If you really need a simple string, call addSimpleString.
+	{
+		addRedisType(new Type<T>(arg));
+		return *this;
+	}
+
+	Array& add(const char* s);
+		/// Special implementation for const char*.
+		///
+		/// Note: the specialization creates a BulkString. If you need
+		/// a simple string, call addSimpleString.
+
+	Array& add(const std::vector<std::string>& strings);
+		/// Special implementation for a vector with strings.
+		/// All strings will be added as a BulkString.
+
+	Array& addRedisType(RedisType::Ptr value);
+		/// Adds a Redis element.
+
+	Array& addSimpleString(const std::string& value);
+		/// Adds a simple string (can't contain newline characters!).
+
+	const_iterator begin() const;
+		/// Returns an iterator to the start of the array. 
+		///
+		/// Note: this can throw a NullValueException when this is a Null array.
+
+	void clear();
+		/// Removes all elements from the array.
+
+	const_iterator end() const;
+		/// Returns an iterator to the end of the array. 
+		///
+		/// Note: this can throw a NullValueException when this is a Null array.
+
+	template<typename T>
+	T get(size_t pos) const
+		/// Returns the element on the given position and tries to convert
+		/// to the template type. A Poco::BadCastException will be thrown when the
+		/// the conversion fails. An Poco::InvalidArgumentException will be thrown
+		/// when the index is out of range. When the array is a Null array
+		/// a Poco::NullValueException is thrown.
+	{
+		if ( _elements.isNull() ) throw NullValueException();
+
+		if ( pos >= _elements.value().size() ) throw InvalidArgumentException();
+
+		RedisType::Ptr element = _elements.value().at(pos);
+		if ( RedisTypeTraits<T>::TypeId == element->type() )
+		{
+			Type<T>* concrete = dynamic_cast<Type<T>* >(element.get());
+			if ( concrete != NULL ) return concrete->value();
+		}
+		throw BadCastException();
+	}
+
+	int getType(size_t pos) const;
+		/// Returns the type of the element. This can throw a Poco::NullValueException
+		/// when this array is a Null array. An Poco::InvalidArgumentException will
+		/// be thrown when the index is out of range.
+
+	bool isNull() const;
+		/// Returns true when this is a Null array.
+
+	void makeNull();
+		/// Turns the array into a Null array. When the array already has some
+		/// elements, the array will be cleared.
+
+	std::string toString() const;
+		/// Returns the String representation as specified in the
+		/// Redis Protocol specification.
+
+	size_t size() const;
+		/// Returns the size of the array. 
+		///
+		/// Note: this can throw a NullValueException when this is a Null array.
+
+private:
+	void checkNull();
+		/// Checks for null array and sets a new vector if true.
+
+	Nullable<std::vector<RedisType::Ptr> > _elements;
+};
+
+
+//
+// inlines
+//
+
+
+inline Array& Array::operator<<(const char* s)
+{
+	BulkString value(s);
+	return add(value);
+}
+
+
+inline Array& Array::operator<<(const std::vector<std::string>& strings)
+{
+	return add(strings);
+}
+
+
+inline Array& Array::add()
+{
+	BulkString value;
+	return add(value);
+}
+
+
+template<>
+inline Array& Array::add(const std::string& arg)
+{
+	BulkString value(arg);
+	return add(value);
+}
+
+
+inline Array& Array::add(const char* s)
+{
+	BulkString value(s);
+	return add(value);
+}
+
+
+inline Array& Array::add(const std::vector<std::string>& strings)
+{
+	for(std::vector<std::string>::const_iterator it = strings.begin(); it != strings.end(); ++it)
+	{
+		add(*it);
+	}
+	return *this;
+}
+
+
+inline Array& Array::addSimpleString(const std::string& value)
+{
+	return addRedisType(new Type<std::string>(value));
+}
+
+
+inline Array::const_iterator Array::begin() const
+{
+	return _elements.value().begin();
+}
+
+
+inline void Array::checkNull()
+{
+	std::vector<RedisType::Ptr> v;
+	if ( _elements.isNull() ) _elements.assign(v);
+}
+
+
+inline void Array::clear()
+{
+	if ( !_elements.isNull() )
+	{
+		_elements.value().clear();
+	}
+}
+
+
+inline Array::const_iterator Array::end() const
+{
+	return _elements.value().end();
+}
+
+
+inline bool Array::isNull() const
+{
+	return _elements.isNull();
+}
+
+
+inline void Array::makeNull()
+{
+	if ( !_elements.isNull() ) _elements.value().clear();
+
+	_elements.clear();
+}
+
+
+inline size_t Array::size() const
+{
+	return _elements.value().size();
+}
+
+
+template<>
+struct RedisTypeTraits<Array>
+{
+	enum { TypeId = RedisType::REDIS_ARRAY };
+
+	static const char marker = '*';
+
+	static std::string toString(const Array& value)
+	{
+		std::stringstream result;
+		result <<  marker;
+		if ( value.isNull() )
+		{
+			result << "-1" << LineEnding::NEWLINE_CRLF;
+		}
+		else
+		{
+			result << value.size() << LineEnding::NEWLINE_CRLF;
+			for(std::vector<RedisType::Ptr>::const_iterator it = value.begin();
+				it != value.end(); ++it)
+			{
+				result << (*it)->toString();
+			}
+		}
+		return result.str();
+	}
+
+	static void read(RedisInputStream& input, Array& value)
+	{
+		value.clear();
+
+		Int64 length = NumberParser::parse64(input.getline());
+
+		if ( length != -1 )
+		{
+			for(int i = 0; i < length; ++i)
+			{
+				char marker = input.get();
+				RedisType::Ptr element = RedisType::createRedisType(marker);
+
+				if ( element.isNull() )
+					throw RedisException("Wrong answer received from Redis server");
+
+				element->read(input);
+				value.addRedisType(element);
+			}
+		}
+	}
+};
+
+
+} } // namespace Poco::Redis
+
+
+#endif // Redis_Array_INCLUDED
diff --git a/base/poco/Redis/include/Poco/Redis/AsyncReader.h b/base/poco/Redis/include/Poco/Redis/AsyncReader.h
new file mode 100644
index 00000000000..040ce3292ac
--- /dev/null
+++ b/base/poco/Redis/include/Poco/Redis/AsyncReader.h
@@ -0,0 +1,98 @@
+//
+// AsyncReader.h
+//
+// Library: Redis
+// Package: Redis
+// Module:  AsyncReader
+//
+// Definition of the AsyncReader class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Redis_AsyncReader_INCLUDED
+#define Redis_AsyncReader_INCLUDED
+
+
+#include "Poco/Redis/Redis.h"
+#include "Poco/Redis/Client.h"
+#include "Poco/Redis/RedisEventArgs.h"
+#include "Poco/Activity.h"
+
+
+namespace Poco {
+namespace Redis {
+
+
+class Redis_API AsyncReader
+	/// Wrapper around a Redis client to read messages asynchronously. Use this
+	/// for publish/subscribe. The redisResponse event is used to notify that
+	/// a message is received. When a reader is started for a Redis server,
+	/// you should use execute<void>, because this class is responsible for
+	/// reading all replies.
+{
+public:
+	BasicEvent<RedisEventArgs> redisResponse;
+		/// Event that is fired when a message is received.
+
+	BasicEvent<RedisEventArgs> redisException;
+		/// Event that is fired when an error occurred.
+
+	AsyncReader(Client& client);
+		/// Creates the AsyncReader using the given Client.
+
+	virtual ~AsyncReader();
+		/// Destroys the AsyncReader.
+
+	bool isStopped();
+		/// Returns true if the activity is not running, false when it is.
+
+	void start();
+		/// Starts the activity to read replies from the Redis server.
+
+	void stop();
+		/// Stops the read activity.
+
+protected:
+	void runActivity();
+
+private:
+	AsyncReader(const AsyncReader&);
+	AsyncReader& operator = (const AsyncReader&);
+
+	Client& _client;
+	Activity<AsyncReader> _activity;
+};
+
+
+//
+// inlines
+//
+
+
+inline bool AsyncReader::isStopped()
+{
+	return _activity.isStopped();
+}
+
+
+inline void AsyncReader::start()
+{
+	_activity.start();
+}
+
+
+inline void AsyncReader::stop()
+{
+	_activity.stop();
+}
+
+
+} } // namespace Poco::Redis
+
+
+#endif //Redis_AsyncReader_INCLUDED
diff --git a/base/poco/Redis/include/Poco/Redis/Client.h b/base/poco/Redis/include/Poco/Redis/Client.h
new file mode 100644
index 00000000000..6b204ae6c69
--- /dev/null
+++ b/base/poco/Redis/include/Poco/Redis/Client.h
@@ -0,0 +1,239 @@
+//
+// Client.h
+//
+// Library: Redis
+// Package: Redis
+// Module:  Client
+//
+// Definition of the Client class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Redis_Client_INCLUDED
+#define Redis_Client_INCLUDED
+
+
+#include "Poco/Redis/Redis.h"
+#include "Poco/Redis/Array.h"
+#include "Poco/Redis/Error.h"
+#include "Poco/Redis/RedisStream.h"
+#include "Poco/Net/SocketAddress.h"
+#include "Poco/Timespan.h"
+
+
+namespace Poco {
+namespace Redis {
+
+
+class Redis_API Client
+	/// Represents a connection to a Redis server.
+	///
+	/// A command is always made from an Array and a reply can be a signed 64
+	/// bit integer, a simple string, a bulk string, an array or an error. The
+	/// first element of the command array is the Redis command. A simple string
+	/// is a string that cannot contain a CR or LF character. A bulk string is
+	/// implemented as a typedef for Poco::Nullable<std::string>. This is
+	/// because a bulk string can represent a Null value.
+	///
+	///     BulkString bs = client.execute<BulkString>(...);
+	///     if ( bs.isNull() )
+	///     {
+	///        // We have a Null value
+	///     }
+	///     else
+	///     {
+	///        // We have a string value
+	///     }
+	///
+	/// To create Redis commands, the factory methods of the Command class can
+	/// be used or the Array class can be used directly.
+	///
+	///     Command llen = Command::llen("list");
+	///
+	/// is the same as:
+	///
+	///     Array command;
+	///     command.add("LLEN").add("list");
+	///
+	/// or:
+	///
+	///     Array command;
+	///     command << "LLEN" << "list";
+	///
+	///	or even:
+	///
+	///     Command command("LLEN");
+	///     command << "list";
+{
+public:
+	typedef SharedPtr<Client> Ptr;
+
+	Client();
+		/// Creates an unconnected Client.
+		/// Use this when you want to connect later on.
+
+	Client(const std::string& hostAndPort);
+		/// Constructor which connects to the given Redis host/port.
+		/// The host and port must be separated with a colon.
+
+	Client(const std::string& host, int port);
+		/// Constructor which connects to the given Redis host/port.
+
+	Client(const Net::SocketAddress& addrs);
+		/// Constructor which connects to the given Redis host/port.
+
+	virtual ~Client();
+		/// Destroys the Client.
+
+	Net::SocketAddress address() const;
+		/// Returns the address of the Redis connection.
+
+	void connect(const std::string& hostAndPort);
+		/// Connects to the given Redis server. The host and port must be
+		/// separated with a colon.
+
+	void connect(const std::string& host, int port);
+		/// Connects to the given Redis server.
+
+	void connect(const Net::SocketAddress& addrs);
+		/// Connects to the given Redis server.
+
+	void connect(const std::string& hostAndPort, const Timespan& timeout);
+		/// Connects to the given Redis server. The host and port must be
+		/// separated with a colon.
+
+	void connect(const std::string& host, int port, const Timespan& timeout);
+		/// Connects to the given Redis server.
+
+	void connect(const Net::SocketAddress& addrs, const Timespan& timeout);
+		/// Connects to the given Redis server.
+
+	void disconnect();
+		/// Disconnects from the Redis server.
+
+	bool isConnected() const;
+		/// Returns true iff the Client is connected to a Redis server.
+
+	template<typename T>
+	T execute(const Array& command)
+		/// Sends the Redis Command to the server. It gets the reply
+		/// and tries to convert it to the given template type.
+		///
+		/// A specialization exists for type void, which doesn't read
+		/// the reply. If the server sends a reply, it is your
+		/// responsibility to read it. Use this for pipelining.
+		///
+		/// A Poco::BadCastException will be thrown when the reply couldn't be
+		/// converted. Supported types are Int64, std::string, BulkString,
+		/// Array and void. When the reply is an Error, it will throw
+		/// a RedisException.
+	{
+		T result = T();
+		writeCommand(command, true);
+		readReply(result);
+		return result;
+	}
+
+	void flush();
+		/// Flush the output buffer to Redis. Use this when commands
+		/// are stored in the buffer to send them all at once to Redis.
+
+	RedisType::Ptr sendCommand(const Array& command);
+		/// Sends a Redis command to the server and returns the reply.
+		/// Use this when the type of the reply isn't known.
+
+	RedisType::Ptr readReply();
+		/// Read a reply from the Redis server.
+
+	template<typename T>
+	void readReply(T& result)
+		/// Read a reply from the Redis server and tries to convert that reply
+		/// to the template type. When the reply is a Redis error, it will
+		/// throw a RedisException. A BadCastException will be thrown, when
+		/// the reply is not of the given type.
+	{
+		RedisType::Ptr redisResult = readReply();
+		if (redisResult->type() == RedisTypeTraits<Error>::TypeId)
+		{
+			Type<Error>* error = dynamic_cast<Type<Error>*>(redisResult.get());
+			throw RedisException(error->value().getMessage());
+		}
+
+		if (redisResult->type() == RedisTypeTraits<T>::TypeId)
+		{
+			Type<T>* type = dynamic_cast<Type<T>*>(redisResult.get());
+			if (type != NULL) result = type->value();
+		}
+		else throw BadCastException();
+	}
+
+	Array sendCommands(const std::vector<Array>& commands);
+		/// Sends all commands (pipelining) to the Redis server before
+		/// getting all replies.
+
+	void setReceiveTimeout(const Timespan& timeout);
+		/// Sets a receive timeout.
+
+private:
+	Client(const Client&);
+	Client& operator = (const Client&);
+
+	void connect();
+		/// Connects to the Redis server
+
+	void connect(const Timespan& timeout);
+		/// Connects to the Redis server and sets a timeout.
+
+	void writeCommand(const Array& command, bool flush);
+		/// Sends a request to the Redis server. Use readReply to get the
+		/// answer. Can also be used for pipelining commands. Make sure you
+		/// call readReply as many times as you called writeCommand, even when
+		/// an error occurred on a command.
+
+	Net::SocketAddress _address;
+	Net::StreamSocket _socket;
+	RedisInputStream* _input;
+	RedisOutputStream* _output;
+};
+
+
+//
+// inlines
+//
+
+
+inline Net::SocketAddress Client::address() const
+{
+	return _address;
+}
+
+
+template<> inline
+void Client::execute<void>(const Array& command)
+{
+	writeCommand(command, false);
+}
+
+
+inline void Client::flush()
+{
+	poco_assert(_output);
+	_output->flush();
+}
+
+
+inline void Client::setReceiveTimeout(const Timespan& timeout)
+{
+	_socket.setReceiveTimeout(timeout);
+}
+
+
+} } // namespace Poco::Redis
+
+
+#endif // Redis_Client_INCLUDED
diff --git a/base/poco/Redis/include/Poco/Redis/Command.h b/base/poco/Redis/include/Poco/Redis/Command.h
new file mode 100644
index 00000000000..627441c6546
--- /dev/null
+++ b/base/poco/Redis/include/Poco/Redis/Command.h
@@ -0,0 +1,279 @@
+//
+// Command.h
+//
+// Library: Redis
+// Package: Redis
+// Module:  Command
+//
+// Definition of the Command class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Redis_Command_INCLUDED
+#define Redis_Command_INCLUDED
+
+
+#include "Poco/Redis/Redis.h"
+#include "Poco/Redis/Array.h"
+#include <vector>
+#include <map>
+
+
+namespace Poco {
+namespace Redis {
+
+
+class Redis_API Command: public Array
+	/// Helper class for creating commands. This class contains
+	/// factory methods for commonly used Redis commands.
+	///
+	/// There are two ways of building commands:
+	///
+	///     1. Use this class and the factory methods
+	///     2. Use the Array or Command class and build the command using the add
+	///        method or << operator.
+	///
+	/// For example:
+	///
+	///     Command cmd = Command::set("mykey", "Hello");
+	///
+	/// is the same as:
+	///
+	///     Array cmd;
+	///     cmd << "SET" << "mykey" << "Hello";
+	///
+{
+public:
+	typedef std::vector<std::string> StringVec;
+
+	Command(const std::string& command);
+		/// Creates a command.
+
+	Command(const Command& copy);
+		/// Creates a command by copying another one.
+
+	virtual ~Command();
+		/// Destroys the command.
+
+	static Command append(const std::string& key, const std::string& value);
+		/// Creates and returns an APPEND command.
+
+	static Command blpop(const StringVec& lists, Int64 timeout = 0);
+		/// Creates and returns a BLPOP command.
+
+	static Command brpop(const StringVec& lists, Int64 timeout = 0);
+		/// Creates and returns a BRPOP command.
+
+	static Command brpoplpush(const std::string& sourceList, const std::string& destinationList, Int64 timeout = 0);
+		/// Creates and returns a BRPOPLPUSH command.
+
+	static Command decr(const std::string& key, Int64 by = 0);
+		/// Creates and returns an DECR or DECRBY command. Calls DECR when by is omitted or zero.
+
+	static Command del(const std::string& key);
+		/// Creates and returns an DEL command.
+
+	static Command del(const StringVec& keys);
+		/// Creates and returns an DEL command.
+
+	static Command get(const std::string& key);
+		/// Creates and returns an GET command.
+
+	static Command exists(const std::string& key);
+		/// Creates and returns an EXISTS command.
+
+	static Command hdel(const std::string& hash, const std::string& field);
+		/// Creates and returns an HDEL command.
+
+	static Command hdel(const std::string& hash, const StringVec& fields);
+		/// Creates and returns an HDEL command.
+
+	static Command hexists(const std::string& hash, const std::string& field);
+		/// Creates and returns an HEXISTS command.
+
+	static Command hget(const std::string& hash, const std::string& field);
+		/// Creates and returns an HGET command.
+
+	static Command hgetall(const std::string& hash);
+		/// Creates and returns an HGETALL command.
+
+	static Command hincrby(const std::string& hash, const std::string& field, Int64 by = 1);
+		/// Creates and returns an HINCRBY command.
+
+	static Command hkeys(const std::string& hash);
+		/// Creates and returns an HKEYS command.
+
+	static Command hlen(const std::string& hash);
+		/// Creates and returns an HLEN command.
+
+	static Command hmget(const std::string& hash, const StringVec& fields);
+		/// Creates and returns an HMGET command.
+
+	static Command hmset(const std::string& hash, std::map<std::string, std::string>& fields);
+		/// Creates and returns a HMSET command.
+
+	static Command hset(const std::string& hash, const std::string& field, const std::string& value, bool create = true);
+		/// Creates and returns an HSET or HSETNX (when create is false) command.
+
+	static Command hset(const std::string& hash, const std::string& field, Int64 value, bool create = true);
+		/// Creates and returns an HSET or HSETNX (when create is false) command.
+
+	static Command hstrlen(const std::string& hash, const std::string& field);
+		/// Creates and returns an HSTRLEN command (Available for Redis 3.2).
+
+	static Command hvals(const std::string& hash);
+		/// Creates and returns an HVALS command.
+
+	static Command incr(const std::string& key, Int64 by = 0);
+		/// Creates and returns an INCR or INCRBY command. Calls INCR when by is omitted or zero.
+
+	static Command lindex(const std::string& list, Int64 index = 0);
+		/// Creates and returns a LINDEX command.
+
+	static Command linsert(const std::string& list, bool before, const std::string& reference, const std::string& value);
+		/// Creates and returns a LINSERT command.
+
+	static Command llen(const std::string& list);
+		/// Creates and returns a LLEN command.
+
+	static Command lpop(const std::string& list);
+		/// Creates and returns a LPOP command.
+
+	static Command lpush(const std::string& list, const std::string& value, bool create = true);
+		/// Creates and returns a LPUSH or LPUSHX (when create is false) command.
+
+	static Command lpush(const std::string& list, const StringVec& value, bool create = true);
+		/// Creates and returns a LPUSH or LPUSHX (when create is false) command.
+
+	static Command lrange(const std::string& list, Int64 start = 0, Int64 stop = -1);
+		/// Creates and returns a LRANGE command. When start and stop is omitted an LRANGE
+		/// command will returned that returns all items of the list.
+
+	static Command lrem(const std::string& list, Int64 count, const std::string& value);
+		/// Creates and returns a LREM command.
+
+	static Command lset(const std::string& list, Int64 index, const std::string& value);
+		/// Creates and returns a LSET command.
+
+	static Command ltrim(const std::string& list, Int64 start = 0, Int64 stop = -1);
+		/// Creates and returns a LTRIM command.
+
+	static Command mget(const StringVec& keys);
+		/// Creates and returns a MGET command.
+
+	static Command mset(const std::map<std::string, std::string>& keyvalues, bool create = true);
+		/// Creates and returns a MSET or MSETNX (when create is false) command.
+
+	static Command sadd(const std::string& set, const std::string& value);
+		/// Creates and returns a SADD command.
+
+	static Command sadd(const std::string& set, const StringVec& values);
+		/// Creates and returns a SADD command.
+
+	static Command scard(const std::string& set);
+		/// Creates and returns a SCARD command.
+
+	static Command sdiff(const std::string& set1, const std::string& set2);
+		/// Creates and returns a SDIFF command.Creates and returns
+
+	static Command sdiff(const std::string& set, const StringVec& sets);
+		/// Creates and returns a SDIFF command.
+
+	static Command sdiffstore(const std::string& set, const std::string& set1, const std::string& set2);
+		/// Creates and returns a SDIFFSTORE command.
+
+	static Command sdiffstore(const std::string& set, const StringVec& sets);
+		/// Creates and returns a SDIFFSTORE command.
+
+	static Command set(const std::string& key, const std::string& value, bool overwrite = true, const Poco::Timespan& expireTime = 0, bool create = true);
+		/// Creates and returns a SET command to set the key with a value.
+
+	static Command set(const std::string& key, Int64 value, bool overwrite = true, const Poco::Timespan& expireTime = 0, bool create = true);
+		/// Creates and returns a SET command to set the key with a value.
+
+	static Command sinter(const std::string& set1, const std::string& set2);
+		/// Creates and returns a SINTER command.
+
+	static Command sinter(const std::string& set, const StringVec& sets);
+		/// Creates and returns a SINTER command.
+
+	static Command sinterstore(const std::string& set, const std::string& set1, const std::string& set2);
+		/// Creates and returns a SINTERSTORE command.
+
+	static Command sinterstore(const std::string& set, const StringVec& sets);
+		/// Creates and returns a SINTERSTORE command.
+
+	static Command sismember(const std::string& set, const std::string& member);
+		/// Creates and returns a SISMEMBER command.
+
+	static Command smembers(const std::string& set);
+		/// Creates and returns a SMEMBERS command.
+
+	static Command smove(const std::string& source, const std::string& destination, const std::string& member);
+		/// Creates and returns a SMOVE command.
+
+	static Command spop(const std::string& set, Int64 count = 0);
+		/// Creates and returns a SPOP command.
+
+	static Command srandmember(const std::string& set, Int64 count = 0);
+		/// Creates and returns a SRANDMEMBER command.
+
+	static Command srem(const std::string& set, const std::string& member);
+		/// Creates and returns a SREM command.
+
+	static Command srem(const std::string& set, const StringVec& members);
+		/// Creates and returns a SREM command.
+
+	static Command sunion(const std::string& set1, const std::string& set2);
+		/// Creates and returns a SUNION command.
+
+	static Command sunion(const std::string& set, const StringVec& sets);
+		/// Creates and returns a SUNION command.
+
+	static Command sunionstore(const std::string& set, const std::string& set1, const std::string& set2);
+		/// Creates and returns a SUNIONSTORE command.
+
+	static Command sunionstore(const std::string& set, const StringVec& sets);
+		/// Creates and returns a SUNIONSTORE command.
+
+	static Command rename(const std::string& key, const std::string& newName, bool overwrite = true);
+		/// Creates and returns a RENAME or RENAMENX when overwrite is false.
+
+	static Command rpop(const std::string& list);
+		/// Creates and returns a RPOP command.
+
+	static Command rpoplpush(const std::string& sourceList, const std::string& destinationList);
+		/// Creates and returns a RPOPLPUSH command.
+
+	static Command rpush(const std::string& list, const std::string& value, bool create = true);
+		/// Creates and returns a RPUSH or RPUSHX (when create is false) command.
+
+	static Command rpush(const std::string& list, const StringVec& value, bool create = true);
+		/// Creates and returns a RPUSH or RPUSHX (when create is false) command.
+
+	static Command expire(const std::string& key, Int64 seconds);
+		/// Creates and returns an EXPIRE command.
+
+	static Command ping();
+		/// Creates and returns a PING command.
+
+	static Command multi();
+		/// Creates and returns a MULTI command.
+
+	static Command exec();
+		/// Creates and returns a EXEC command.
+
+	static Command discard();
+		/// Creates and returns a DISCARD command.
+};
+
+
+} } // namespace Poco::Redis
+
+
+#endif // Redis_Command_INCLUDED
diff --git a/base/poco/Redis/include/Poco/Redis/Error.h b/base/poco/Redis/include/Poco/Redis/Error.h
new file mode 100644
index 00000000000..ddc8155bd54
--- /dev/null
+++ b/base/poco/Redis/include/Poco/Redis/Error.h
@@ -0,0 +1,91 @@
+//
+// Error.h
+//
+// Library: Redis
+// Package: Redis
+// Module:  Error
+//
+// Definition of the Error class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Redis_Error_INCLUDED
+#define Redis_Error_INCLUDED
+
+
+#include "Poco/Redis/Type.h"
+
+
+namespace Poco {
+namespace Redis {
+
+
+class Redis_API Error
+	/// Represent a Redis error.
+{
+public:
+	Error();
+		/// Creates an empty Error.
+
+	Error(const std::string& message);
+		/// Creates an Error with the given message.
+
+	virtual ~Error();
+		/// Destroys the Error.
+
+	const std::string& getMessage() const;
+		/// Returns the error message.
+
+	void setMessage(const std::string& message);
+		/// Sets the error message.
+
+private:
+	std::string _message;
+};
+
+
+//
+// inlines
+//
+
+
+inline const std::string& Error::getMessage() const
+{
+	return _message;
+}
+
+
+inline void Error::setMessage(const std::string& message)
+{
+	_message = message;
+}
+
+
+template<>
+struct RedisTypeTraits<Error>
+{
+	enum { TypeId = RedisType::REDIS_ERROR };
+
+	static const char marker = '-';
+
+	static std::string toString(const Error& value)
+	{
+		return marker + value.getMessage()  + LineEnding::NEWLINE_CRLF;
+	}
+
+	static void read(RedisInputStream& input, Error& value)
+	{
+		value.setMessage(input.getline());
+	}
+};
+
+
+} } // namespace Poco::Redis
+
+
+#endif // Redis_Error_INCLUDED
diff --git a/base/poco/Redis/include/Poco/Redis/Exception.h b/base/poco/Redis/include/Poco/Redis/Exception.h
new file mode 100644
index 00000000000..445442821a6
--- /dev/null
+++ b/base/poco/Redis/include/Poco/Redis/Exception.h
@@ -0,0 +1,36 @@
+//
+// Exception.h
+//
+// Library: Redis
+// Package: Redis
+// Module:  Exception
+//
+// Definition of the Exception class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Redis_Exception_INCLUDED
+#define Redis_Exception_INCLUDED
+
+
+#include "Poco/Redis/Redis.h"
+#include "Poco/Exception.h"
+#include <typeinfo>
+
+
+namespace Poco {
+namespace Redis {
+
+
+POCO_DECLARE_EXCEPTION(Redis_API, RedisException, Exception)
+
+
+} } // namespace Poco::Redis
+
+
+#endif // Redis_Exception_INCLUDED
diff --git a/base/poco/Redis/include/Poco/Redis/PoolableConnectionFactory.h b/base/poco/Redis/include/Poco/Redis/PoolableConnectionFactory.h
new file mode 100644
index 00000000000..57dc24c2a92
--- /dev/null
+++ b/base/poco/Redis/include/Poco/Redis/PoolableConnectionFactory.h
@@ -0,0 +1,114 @@
+//
+// PoolableConnectionFactory.h
+//
+// Library: Redis
+// Package: Redis
+// Module:  PoolableConnectionFactory
+//
+// Definition of the PoolableConnectionFactory class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Redis_PoolableConnectionFactory_INCLUDED
+#define Redis_PoolableConnectionFactory_INCLUDED
+
+
+#include "Poco/Redis/Client.h"
+#include "Poco/ObjectPool.h"
+#include "Poco/Version.h"
+
+
+namespace Poco {
+
+
+template<>
+class PoolableObjectFactory<Redis::Client, Redis::Client::Ptr>
+	/// PoolableObjectFactory specialisation for Client. New connections
+	/// are created with the given address.
+{
+public:
+	PoolableObjectFactory(Net::SocketAddress& address):
+		_address(address)
+	{
+	}
+
+	PoolableObjectFactory(const std::string& address):
+		_address(address)
+	{
+	}
+
+	Redis::Client::Ptr createObject()
+	{
+		return new Redis::Client(_address);
+	}
+
+	bool validateObject(Redis::Client::Ptr pObject)
+	{
+		return true;
+	}
+
+	void activateObject(Redis::Client::Ptr pObject)
+	{
+	}
+
+	void deactivateObject(Redis::Client::Ptr pObject)
+	{
+	}
+
+	void destroyObject(Redis::Client::Ptr pObject)
+	{
+	}
+
+private:
+	Net::SocketAddress _address;
+};
+
+
+namespace Redis {
+
+
+class PooledConnection
+	/// Helper class for borrowing and returning a connection automatically from a pool.
+{
+public:
+	PooledConnection(ObjectPool<Client, Client::Ptr>& pool, long timeoutMilliseconds = 0) : _pool(pool)
+	{
+#if POCO_VERSION >= 0x01080000
+		_client = _pool.borrowObject(timeoutMilliseconds);
+#else
+		_client = _pool.borrowObject();
+#endif
+	}
+
+	virtual ~PooledConnection()
+	{
+		try
+		{
+			_pool.returnObject(_client);
+		}
+		catch (...)
+		{
+			poco_unexpected();
+		}
+	}
+
+	operator Client::Ptr()
+	{
+		return _client;
+	}
+
+private:
+	ObjectPool<Client, Client::Ptr>& _pool;
+	Client::Ptr _client;
+};
+
+
+} } // namespace Poco::Redis
+
+
+#endif // Redis_PoolableConnectionFactory_INCLUDED
diff --git a/base/poco/Redis/include/Poco/Redis/Redis.h b/base/poco/Redis/include/Poco/Redis/Redis.h
new file mode 100644
index 00000000000..bddc260b2d4
--- /dev/null
+++ b/base/poco/Redis/include/Poco/Redis/Redis.h
@@ -0,0 +1,62 @@
+//
+// Redis.h
+//
+// Library: Redis
+// Package: Redis
+// Module:  Redis
+//
+// Basic definitions for the Poco Redis library.
+// This file must be the first file included by every other Redis
+// header file.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef RedisRedis_INCLUDED
+#define RedisRedis_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+//
+// The following block is the standard way of creating macros which make exporting
+// from a DLL simpler. All files within this DLL are compiled with the Redis_EXPORTS
+// symbol defined on the command line. This symbol should not be defined on any project
+// that uses this DLL. This way any other project whose source files include this file see
+// Redis_API functions as being imported from a DLL, wheras this DLL sees symbols
+// defined with this macro as being exported.
+//
+#if defined(_WIN32) && defined(POCO_DLL)
+	#if defined(Redis_EXPORTS)
+		#define Redis_API __declspec(dllexport)
+	#else
+		#define Redis_API __declspec(dllimport)
+	#endif
+#endif
+
+
+#if !defined(Redis_API)
+	#if !defined(POCO_NO_GCC_API_ATTRIBUTE) && defined (__GNUC__) && (__GNUC__ >= 4)
+		#define Redis_API __attribute__ ((visibility ("default")))
+	#else
+		#define Redis_API
+	#endif
+#endif
+
+
+//
+// Automatically link Redis library.
+//
+#if defined(_MSC_VER)
+	#if !defined(POCO_NO_AUTOMATIC_LIBS) && !defined(Redis_EXPORTS)
+		#pragma comment(lib, "PocoRedis" POCO_LIB_SUFFIX)
+	#endif
+#endif
+
+
+#endif // RedisRedis_INCLUDED
diff --git a/base/poco/Redis/include/Poco/Redis/RedisEventArgs.h b/base/poco/Redis/include/Poco/Redis/RedisEventArgs.h
new file mode 100644
index 00000000000..6150078980b
--- /dev/null
+++ b/base/poco/Redis/include/Poco/Redis/RedisEventArgs.h
@@ -0,0 +1,99 @@
+//
+// RedisEventArgs.h
+//
+// Library: Redis
+// Package: Redis
+// Module:  RedisEventArgs
+//
+// Definition of the RedisEventArgs class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Redis_RedisEventArgs_INCLUDED
+#define Redis_RedisEventArgs_INCLUDED
+
+
+#include "Poco/Redis/Type.h"
+
+
+namespace Poco {
+namespace Redis {
+
+
+class Redis_API RedisEventArgs
+	/// Event arguments for AsyncReader events.
+{
+public:
+	RedisEventArgs(RedisType::Ptr message);
+		/// Creates the RedisEventArgs from the given message.
+
+	RedisEventArgs(Exception* e);
+		/// Creates the RedisEventArgs from the given Redis Exception.
+
+	~RedisEventArgs();
+		/// Destroys the RedisEventArgs.
+
+	RedisType::Ptr message() const;
+		/// Returns the message retrieved from the Redis server.
+		/// This can be a NULL pointer when this event is about an exception.
+
+	const Exception* exception() const;
+		/// Returns the exception if any, otherwise it returns null pointer.
+
+	void stop();
+		/// When called, the AsyncReader will stop.
+		///
+		/// Note: The AsyncReader will always stop when this is an exception
+		/// event. Use this for example for pub/sub when there are no
+		/// subcribers anymore.
+
+	bool isStopped() const;
+		/// Returns true when the AsyncReader will stop.
+
+private:
+	RedisType::Ptr _message;
+
+	Exception* _exception;
+
+	bool _stop;
+};
+
+
+//
+// inlines
+//
+
+
+inline RedisType::Ptr RedisEventArgs::message() const
+{
+	return _message;
+}
+
+
+inline const Exception* RedisEventArgs::exception() const
+{
+	return _exception;
+}
+
+
+inline bool RedisEventArgs::isStopped() const
+{
+	return _stop;
+}
+
+
+inline void RedisEventArgs::stop()
+{
+	_stop = true;
+}
+
+
+} } // namespace Poco::Redis
+
+
+#endif // Redis_RedisEventArgs_INCLUDED
diff --git a/base/poco/Redis/include/Poco/Redis/RedisStream.h b/base/poco/Redis/include/Poco/Redis/RedisStream.h
new file mode 100644
index 00000000000..c750f38a1b0
--- /dev/null
+++ b/base/poco/Redis/include/Poco/Redis/RedisStream.h
@@ -0,0 +1,114 @@
+//
+// RedisStream.h
+//
+// Library: Redis
+// Package: Redis
+// Module:  RedisStream
+//
+// Definition of the RedisStream class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Redis_RedisStream_INCLUDED
+#define Redis_RedisStream_INCLUDED
+
+
+#include "Poco/Redis/Redis.h"
+#include "Poco/BufferedStreamBuf.h"
+#include "Poco/Net/StreamSocket.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+namespace Redis {
+
+
+class RedisStreamBuf: public BufferedStreamBuf
+	/// BufferedStreamBuf for Redis.
+{
+public:
+	RedisStreamBuf(Net::StreamSocket& redis);
+		/// Constructor
+
+	~RedisStreamBuf();
+		/// Destructor
+
+	std::string readLine();
+		/// Reads a line from Redis (until \r\n is encountered).
+
+protected:
+	int readFromDevice(char* buffer, std::streamsize length);
+	int writeToDevice(const char* buffer, std::streamsize length);
+
+private:
+	enum
+	{
+		STREAM_BUFFER_SIZE = 1024
+	};
+
+	Net::StreamSocket& _redis;
+};
+
+
+class RedisIOS: public virtual std::ios
+{
+public:
+	RedisIOS(Net::StreamSocket& redis);
+		/// Creates the RedisIOS with the given socket.
+
+	~RedisIOS();
+		/// Destroys the RedisIOS.
+		///
+		/// Flushes the buffer, but does not close the socket.
+
+	RedisStreamBuf* rdbuf();
+		/// Returns a pointer to the internal RedisStreamBuf.
+
+	void close();
+		/// Flushes the stream.
+
+protected:
+	RedisStreamBuf _buf;
+};
+
+
+class Redis_API RedisOutputStream: public RedisIOS, public std::ostream
+	/// An output stream for writing to a Redis server.
+{
+public:
+	RedisOutputStream(Net::StreamSocket& redis);
+		/// Creates the RedisOutputStream with the given socket.
+
+	~RedisOutputStream();
+		/// Destroys the RedisOutputStream.
+		///
+		/// Flushes the buffer.
+};
+
+
+class Redis_API RedisInputStream: public RedisIOS, public std::istream
+	/// An input stream for reading from a Redis server.
+{
+public:
+	RedisInputStream(Net::StreamSocket& redis);
+		/// Creates the RedisInputStream with the given socket.
+
+	~RedisInputStream();
+		/// Destroys the RedisInputStream.
+
+	std::string getline();
+		/// Redis uses \r\n as delimiter. This getline version removes
+		/// the \r from the result.
+};
+
+
+} } // namespace Poco::Redis
+
+
+#endif // Redis_RedisStream_INCLUDED
diff --git a/base/poco/Redis/include/Poco/Redis/Type.h b/base/poco/Redis/include/Poco/Redis/Type.h
new file mode 100644
index 00000000000..79c534f1a88
--- /dev/null
+++ b/base/poco/Redis/include/Poco/Redis/Type.h
@@ -0,0 +1,293 @@
+//
+// Type.h
+//
+// Library: Redis
+// Package: Redis
+// Module:  Type
+//
+// Definition of the Type class.
+//
+// Copyright (c) 2016, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Redis_Type_INCLUDED
+#define Redis_Type_INCLUDED
+
+
+#include "Poco/LineEndingConverter.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/NumberParser.h"
+#include "Poco/SharedPtr.h"
+#include "Poco/Nullable.h"
+#include "Poco/Redis/Redis.h"
+#include "Poco/Redis/RedisStream.h"
+
+
+namespace Poco {
+namespace Redis {
+
+
+class Redis_API RedisType
+	/// Base class for all Redis types. This class makes it possible to store
+	/// element with different types in Array.
+{
+public:
+	enum Types 
+	{
+		REDIS_INTEGER,       /// Redis Integer
+		REDIS_SIMPLE_STRING, /// Redis Simple String
+		REDIS_BULK_STRING,   /// Redis Bulkstring
+		REDIS_ARRAY,         /// Redis Array
+		REDIS_ERROR          /// Redis Error
+	};
+
+	typedef SharedPtr<RedisType> Ptr;
+
+	RedisType();
+		/// Creates the RedisType.
+
+	virtual ~RedisType();
+		/// Destroys the RedisType.
+
+	bool isArray() const;
+		/// Returns true when the value is a Redis array.
+
+	bool isBulkString() const;
+		/// Returns true when the value is a Redis bulkstring.
+
+	bool isError() const;
+		/// Returns true when the value is a Redis error.
+
+	bool isInteger() const;
+		/// Returns true when the value is a Redis integer (64 bit integer).
+
+	bool isSimpleString() const;
+		/// Returns true when the value is a simple string.
+
+	virtual int type() const = 0;
+		/// Returns the type of the value.
+
+	virtual void read(RedisInputStream& input) = 0;
+		/// Reads the value from the stream.
+
+	virtual std::string toString() const = 0;
+		/// Converts the value to a RESP (REdis Serialization Protocol) string.
+
+	static RedisType::Ptr createRedisType(char marker);
+		/// Create a Redis type based on the marker:
+		///
+		///     - '+': a simple string (std::string)
+		///     - '-': an error (Error)
+		///     - '$': a bulk string (BulkString)
+		///     - '*': an array (Array)
+		///     - ':': a signed 64 bit integer (Int64)
+};
+
+
+//
+// inlines
+//
+
+
+inline bool RedisType::isArray() const
+{
+	return type() == REDIS_ARRAY;
+}
+
+
+inline bool RedisType::isBulkString() const
+{
+	return type() == REDIS_BULK_STRING;
+}
+
+
+inline bool RedisType::isError() const
+{
+	return type() == REDIS_ERROR;
+}
+
+
+inline bool RedisType::isInteger() const
+{
+	return type() == REDIS_INTEGER;
+}
+
+
+inline bool RedisType::isSimpleString() const
+{
+	return type() == REDIS_SIMPLE_STRING;
+}
+
+
+template<typename T>
+struct RedisTypeTraits
+{
+};
+
+
+template<>
+struct RedisTypeTraits<Int64>
+{
+	enum 
+	{
+		TypeId = RedisType::REDIS_INTEGER 
+	};
+
+	static const char marker = ':';
+
+	static std::string toString(const Int64& value)
+	{
+		return marker + NumberFormatter::format(value) + "\r\n";
+	}
+
+	static void read(RedisInputStream& input, Int64& value)
+	{
+		std::string number = input.getline();
+		value = NumberParser::parse64(number);
+	}
+};
+
+
+template<>
+struct RedisTypeTraits<std::string>
+{
+	enum 
+	{ 
+		TypeId = RedisType::REDIS_SIMPLE_STRING 
+	};
+
+	static const char marker = '+';
+
+	static std::string toString(const std::string& value)
+	{
+		return marker + value + LineEnding::NEWLINE_CRLF;
+	}
+
+	static void read(RedisInputStream& input, std::string& value)
+	{
+		value = input.getline();
+	}
+};
+
+
+typedef Nullable<std::string> BulkString;
+	/// A bulk string is a string that can contain a NULL value.
+	/// So, BulkString is a typedef for Nullable<std::string>.
+
+
+template<>
+struct RedisTypeTraits<BulkString>
+{
+	enum 
+	{ 
+		TypeId = RedisType::REDIS_BULK_STRING 
+	};
+
+	static const char marker = '$';
+
+	static std::string toString(const BulkString& value)
+	{
+		if ( value.isNull() )
+		{
+			return marker + std::string("-1") + LineEnding::NEWLINE_CRLF;
+		}
+		else
+		{
+			std::string s = value.value();
+			return marker
+				+ NumberFormatter::format(s.length())
+				+ LineEnding::NEWLINE_CRLF
+				+ s
+				+ LineEnding::NEWLINE_CRLF;
+		}
+	}
+
+	static void read(RedisInputStream& input, BulkString& value)
+	{
+		value.clear();
+
+		std::string line = input.getline();
+		int length = NumberParser::parse(line);
+
+		if ( length >= 0 )
+		{
+			std::string s;
+			s.resize(length, ' ');
+			input.read(&*s.begin(), length);
+			value.assign(s);
+
+			input.getline(); // Read and ignore /r/n
+		}
+	}
+};
+
+
+template<typename T>
+class Type: public RedisType
+	/// Template class for all Redis types. This class will use
+	/// RedisTypeTraits structure for calling the type specific code.
+{
+public:
+	Type()
+		/// Creates the Type.
+	{
+	}
+
+	Type(const T& t) : _value(t)
+		/// Creates the Type from another one.
+	{
+	}
+
+	Type(const Type& copy) : _value(copy._value)
+		/// Creates the Type by copying another one.
+	{
+	}
+
+	virtual ~Type()
+		/// Destroys the Type.
+	{
+	}
+
+	int type() const
+		/// Returns the type of the value
+	{
+		return RedisTypeTraits<T>::TypeId;
+	}
+
+	void read(RedisInputStream& socket)
+		/// Reads the value from the stream (RESP).
+	{
+		RedisTypeTraits<T>::read(socket, _value);
+	}
+
+	std::string toString() const
+		/// Converts the value to a string based on the RESP protocol.
+	{
+		return RedisTypeTraits<T>::toString(_value);
+	}
+
+	T& value()
+		/// Returns the value
+	{
+		return _value;
+	}
+
+	const T& value() const
+		/// Returns a const value
+	{
+		return _value;
+	}
+
+private:
+	T _value;
+};
+
+
+} } // namespace Poco/Redis
+
+
+#endif // Redis_Type_INCLUDED
diff --git a/base/poco/Redis/src/Array.cpp b/base/poco/Redis/src/Array.cpp
new file mode 100644
index 00000000000..47938d5b4fb
--- /dev/null
+++ b/base/poco/Redis/src/Array.cpp
@@ -0,0 +1,67 @@
+//
+// Array.h
+//
+// Library: Redis
+// Package: Redis
+// Module:  Array
+//
+// Implementation of the Array class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Redis/Array.h"
+
+
+namespace Poco {
+namespace Redis {
+
+
+Array::Array()
+{
+}
+
+
+Array::Array(const Array& copy): 
+	_elements(copy._elements)
+{
+}
+
+
+Array::~Array()
+{
+}
+
+
+Array& Array::addRedisType(RedisType::Ptr value)
+{
+	checkNull();
+
+	_elements.value().push_back(value);
+
+	return *this;
+}
+
+
+int Array::getType(size_t pos) const
+{
+	if (_elements.isNull()) throw NullValueException();
+
+	if (pos >= _elements.value().size()) throw InvalidArgumentException();
+
+	RedisType::Ptr element = _elements.value().at(pos);
+	return element->type();
+}
+
+
+std::string Array::toString() const
+{
+	return RedisTypeTraits<Array>::toString(*this);
+}
+
+
+} } // namespace Poco::Redis
diff --git a/base/poco/Redis/src/AsyncReader.cpp b/base/poco/Redis/src/AsyncReader.cpp
new file mode 100644
index 00000000000..d59d418ac79
--- /dev/null
+++ b/base/poco/Redis/src/AsyncReader.cpp
@@ -0,0 +1,61 @@
+//
+// AsyncReader.cpp
+//
+// Library: Redis
+// Package: Redis
+// Module:  AsyncReader
+//
+// Implementation of the AsyncReader class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Redis/AsyncReader.h"
+
+
+namespace Poco {
+namespace Redis {
+
+
+AsyncReader::AsyncReader(Client& client): 
+	_client(client),
+	_activity(this, &AsyncReader::runActivity)
+{
+}
+
+
+AsyncReader::~AsyncReader()
+{
+	stop();
+}
+
+
+void AsyncReader::runActivity()
+{
+	while (!_activity.isStopped())
+	{
+		try
+		{
+			RedisType::Ptr reply = _client.readReply();
+
+			RedisEventArgs args(reply);
+			redisResponse.notify(this, args);
+
+			if ( args.isStopped() ) stop();
+		}
+		catch (Exception& e)
+		{
+			RedisEventArgs args(&e);
+			redisException.notify(this, args);
+			stop();
+		}
+		if (!_activity.isStopped()) Thread::trySleep(100);
+	}
+}
+
+
+} } // namespace Poco::Redis
diff --git a/base/poco/Redis/src/Client.cpp b/base/poco/Redis/src/Client.cpp
new file mode 100644
index 00000000000..6d28f6a29d2
--- /dev/null
+++ b/base/poco/Redis/src/Client.cpp
@@ -0,0 +1,213 @@
+//
+// Client.cpp
+//
+// Library: Redis
+// Package: Redis
+// Module:  Client
+//
+// Implementation of the Client class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Redis/Client.h"
+#include "Poco/Redis/Exception.h"
+
+
+namespace Poco {
+namespace Redis {
+
+
+Client::Client():
+	_address(),
+	_socket(),
+	_input(0),
+	_output(0)
+{
+}
+
+
+Client::Client(const std::string& hostAndPort):
+	_address(hostAndPort),
+	_socket(),
+	_input(0),
+	_output(0)
+{
+	connect();
+}
+
+
+Client::Client(const std::string& host, int port):
+	_address(host, port),
+	_socket(),
+	_input(0),
+	_output(0)
+{
+	connect();
+}
+
+
+Client::Client(const Net::SocketAddress& addrs):
+	_address(addrs),
+	_socket(),
+	_input(0),
+	_output(0)
+{
+	connect();
+}
+
+
+Client::~Client()
+{
+	delete _input;
+	delete _output;
+}
+
+
+void Client::connect()
+{
+	poco_assert(! _input);
+	poco_assert(! _output);
+
+	_socket = Net::StreamSocket(_address);
+	_input = new RedisInputStream(_socket);
+	_output = new RedisOutputStream(_socket);
+}
+
+
+void Client::connect(const std::string& hostAndPort)
+{
+	_address = Net::SocketAddress(hostAndPort);
+	connect();
+}
+
+
+void Client::connect(const std::string& host, int port)
+{
+	_address = Net::SocketAddress(host, port);
+	connect();
+}
+
+
+void Client::connect(const Net::SocketAddress& addrs)
+{
+	_address = addrs;
+	connect();
+}
+
+
+void Client::connect(const Timespan& timeout)
+{
+	poco_assert(! _input);
+	poco_assert(! _output);
+
+	_socket = Net::StreamSocket();
+	_socket.connect(_address, timeout);
+	_input = new RedisInputStream(_socket);
+	_output = new RedisOutputStream(_socket);
+}
+
+
+void Client::connect(const std::string& hostAndPort, const Timespan& timeout)
+{
+	_address = Net::SocketAddress(hostAndPort);
+	connect(timeout);
+}
+
+
+void Client::connect(const std::string& host, int port, const Timespan& timeout)
+{
+	_address = Net::SocketAddress(host, port);
+	connect(timeout);
+}
+
+
+void Client::connect(const Net::SocketAddress& addrs, const Timespan& timeout)
+{
+	_address = addrs;
+	connect(timeout);
+}
+
+
+void Client::disconnect()
+{
+	delete _input;
+	_input = 0;
+
+	delete _output;
+	_output = 0;
+
+	_socket.close();
+}
+
+
+bool Client::isConnected() const
+{
+	return _input != 0;
+}
+
+
+void Client::writeCommand(const Array& command, bool doFlush)
+{
+	poco_assert(_output);
+
+	std::string commandStr = command.toString();
+
+	_output->write(commandStr.c_str(), commandStr.length());
+	if (doFlush) _output->flush();
+}
+
+
+RedisType::Ptr Client::readReply()
+{
+	poco_assert(_input);
+
+	int c = _input->get();
+	if (c == -1)
+	{
+		disconnect();
+		throw RedisException("Lost connection to Redis server");
+	}
+	RedisType::Ptr result = RedisType::createRedisType(c);
+	if (result.isNull())
+	{
+		throw RedisException("Invalid Redis type returned");
+	}
+
+	result->read(*_input);
+
+	return result;
+}
+
+
+RedisType::Ptr Client::sendCommand(const Array& command)
+{
+	writeCommand(command, true);
+	return readReply();
+}
+
+
+Array Client::sendCommands(const std::vector<Array>& commands)
+{
+	Array results;
+
+	for (std::vector<Array>::const_iterator it = commands.begin(); it != commands.end(); ++it)
+	{
+		writeCommand(*it, false);
+	}
+	_output->flush();
+
+	for (int i = 0; i < commands.size(); ++i)
+	{
+		results.addRedisType(readReply());
+	}
+
+	return results;
+}
+
+
+} } // namespace Poco::Redis
diff --git a/base/poco/Redis/src/Command.cpp b/base/poco/Redis/src/Command.cpp
new file mode 100644
index 00000000000..0c2de1e1722
--- /dev/null
+++ b/base/poco/Redis/src/Command.cpp
@@ -0,0 +1,738 @@
+//
+// Command.cpp
+//
+// Library: Redis
+// Package: Redis
+// Module:  Command
+//
+// Implementation of the Command class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Redis/Command.h"
+#include "Poco/NumberFormatter.h"
+
+
+namespace Poco {
+namespace Redis {
+
+
+Command::Command(const std::string& command): Array()
+{
+	add(command);
+}
+
+
+Command::Command(const Command& copy): Array(copy)
+{
+}
+
+
+Command::~Command()
+{
+}
+
+
+Command Command::append(const std::string& key, const std::string& value)
+{
+	Command cmd("APPEND");
+
+	cmd << key << value;
+
+	return cmd;
+}
+
+
+Command Command::blpop(const StringVec& lists, Int64 timeout)
+{
+	Command cmd("BLPOP");
+
+	cmd << lists << NumberFormatter::format(timeout);
+
+	return cmd;
+}
+
+
+Command Command::brpop(const StringVec& lists, Int64 timeout)
+{
+	Command cmd("BRPOP");
+
+	cmd << lists << NumberFormatter::format(timeout);
+
+	return cmd;
+}
+
+
+Command Command::brpoplpush(const std::string& sourceList, const std::string& destinationList, Int64 timeout)
+{
+	Command cmd("BRPOPLPUSH");
+
+	cmd << sourceList << destinationList << NumberFormatter::format(timeout);
+
+	return cmd;
+}
+
+
+Command Command::decr(const std::string& key, Int64 by)
+{
+	Command cmd(by == 0 ? "DECR" : "DECRBY");
+
+	cmd << key;
+	if ( by > 0 ) cmd << NumberFormatter::format(by);
+
+	return cmd;
+}
+
+
+Command Command::del(const std::string& key)
+{
+	Command cmd("DEL");
+
+	cmd << key;
+
+	return cmd;
+}
+
+
+Command Command::del(const StringVec& keys)
+{
+	Command cmd("DEL");
+
+	cmd << keys;
+
+	return cmd;
+}
+
+
+Command Command::get(const std::string& key)
+{
+	Command cmd("GET");
+
+	cmd << key;
+
+	return cmd;
+}
+
+
+Command Command::exists(const std::string& key)
+{
+	Command cmd("EXISTS");
+
+	cmd << key;
+
+	return cmd;
+}
+
+
+Command Command::hdel(const std::string& hash, const std::string& field)
+{
+	Command cmd("HDEL");
+
+	cmd << hash << field;
+
+	return cmd;
+}
+
+
+Command Command::hdel(const std::string& hash, const StringVec& fields)
+{
+	Command cmd("HDEL");
+
+	cmd << hash << fields;
+
+	return cmd;
+}
+
+
+Command Command::hexists(const std::string& hash, const std::string& field)
+{
+	Command cmd("HEXISTS");
+
+	cmd << hash << field;
+
+	return cmd;
+}
+
+
+Command Command::hget(const std::string& hash, const std::string& field)
+{
+	Command cmd("HGET");
+
+	cmd << hash << field;
+
+	return cmd;
+}
+
+
+Command Command::hgetall(const std::string& hash)
+{
+	Command cmd("HGETALL");
+
+	cmd << hash;
+
+	return cmd;
+}
+
+
+Command Command::hincrby(const std::string& hash, const std::string& field, Int64 by)
+{
+	Command cmd("HINCRBY");
+
+	cmd << hash << field << NumberFormatter::format(by);
+
+	return cmd;
+}
+
+
+Command Command::hkeys(const std::string& hash)
+{
+	Command cmd("HKEYS");
+
+	cmd << hash;
+
+	return cmd;
+}
+
+
+Command Command::hlen(const std::string& hash)
+{
+	Command cmd("HLEN");
+
+	cmd << hash;
+
+	return cmd;
+}
+
+
+Command Command::hmget(const std::string& hash, const StringVec& fields)
+{
+	Command cmd("HMGET");
+
+	cmd << hash << fields;
+
+	return cmd;
+}
+
+
+Command Command::hmset(const std::string& hash, std::map<std::string, std::string>& fields)
+{
+	Command cmd("HMSET");
+
+	cmd << hash;
+	for(std::map<std::string, std::string>::const_iterator it = fields.begin(); it != fields.end(); ++it)
+	{
+		cmd << it->first << it->second;
+	}
+
+	return cmd;
+}
+
+
+Command Command::hset(const std::string& hash, const std::string& field, const std::string& value, bool create)
+{
+	Command cmd(create ? "HSET" : "HSETNX");
+
+	cmd << hash << field << value;
+
+	return cmd;
+}
+
+
+Command Command::hset(const std::string& hash, const std::string& field, Int64 value, bool create)
+{
+	return hset(hash, field, NumberFormatter::format(value), create);
+}
+
+
+Command Command::hstrlen(const std::string& hash, const std::string& field)
+{
+	Command cmd("HSTRLEN");
+
+	cmd << hash << field;
+
+	return cmd;
+}
+
+
+Command Command::hvals(const std::string& hash)
+{
+	Command cmd("HVALS");
+
+	cmd << hash;
+
+	return cmd;
+}
+
+
+Command Command::incr(const std::string& key, Int64 by)
+{
+	Command cmd(by == 0 ? "INCR" : "INCRBY");
+
+	cmd << key;
+	if ( by > 0 ) cmd << NumberFormatter::format(by);
+
+	return cmd;
+}
+
+
+Command Command::lindex(const std::string& list, Int64 index)
+{
+	Command cmd("LINDEX");
+
+	cmd << list << NumberFormatter::format(index);
+
+	return cmd;
+}
+
+
+Command Command::linsert(const std::string& list, bool before, const std::string& reference, const std::string& value)
+{
+	Command cmd("LINSERT");
+
+	cmd << list << (before ? "BEFORE" : "AFTER") << reference << value;
+	return cmd;
+}
+
+
+Command Command::llen(const std::string& list)
+{
+	Command cmd("LLEN");
+
+	cmd << list;
+
+	return cmd;
+}
+
+
+Command Command::lpop(const std::string& list)
+{
+	Command cmd("LPOP");
+
+	cmd << list;
+
+	return cmd;
+}
+
+
+Command Command::lpush(const std::string& list, const std::string& value, bool create)
+{
+	Command cmd(create ? "LPUSH" : "LPUSHX");
+
+	cmd << list << value;
+
+	return cmd;
+}
+
+
+Command Command::lpush(const std::string& list, const StringVec& values, bool create)
+{
+	Command cmd(create ? "LPUSH" : "LPUSHX");
+
+	cmd << list << values;
+
+	return cmd;
+}
+
+
+Command Command::lrange(const std::string& list, Int64 start, Int64 stop)
+{
+	Command cmd("LRANGE");
+
+	cmd << list << NumberFormatter::format(start) << NumberFormatter::format(stop);
+
+	return cmd;
+}
+
+
+Command Command::lrem(const std::string& list, Int64 count, const std::string& value)
+{
+	Command cmd("LREM");
+
+	cmd << list << NumberFormatter::format(count) << value;
+
+	return cmd;
+}
+
+
+Command Command::lset(const std::string& list, Int64 index, const std::string& value)
+{
+	Command cmd("LSET");
+
+	cmd << list << NumberFormatter::format(index) << value;
+
+	return cmd;
+}
+
+
+Command Command::ltrim(const std::string& list, Int64 start, Int64 stop)
+{
+	Command cmd("LTRIM");
+
+	cmd << list << NumberFormatter::format(start) << NumberFormatter::format(stop);
+
+	return cmd;
+}
+
+
+Command Command::mget(const StringVec& keys)
+{
+	Command cmd("MGET");
+
+	cmd << keys;
+
+	return cmd;
+}
+
+
+Command Command::mset(const std::map<std::string, std::string>& keyvalues, bool create)
+{
+	Command cmd(create ? "MSET" : "MSETNX");
+
+	for(std::map<std::string, std::string>::const_iterator it = keyvalues.begin(); it != keyvalues.end(); ++it)
+	{
+		cmd << it->first << it->second;
+	}
+
+	return cmd;
+}
+
+
+Command Command::sadd(const std::string& set, const std::string& value)
+{
+	Command cmd("SADD");
+
+	cmd << set << value;
+
+	return cmd;
+}
+
+
+Command Command::sadd(const std::string& set, const StringVec& values)
+{
+	Command cmd("SADD");
+
+	cmd << set << values;
+
+	return cmd;
+}
+
+
+Command Command::scard(const std::string& set)
+{
+	Command cmd("SCARD");
+
+	cmd << set;
+
+	return cmd;
+}
+
+
+Command Command::sdiff(const std::string& set1, const std::string& set2)
+{
+	Command cmd("SDIFF");
+
+	cmd << set1 << set2;
+
+	return cmd;
+}
+
+
+Command Command::sdiff(const std::string& set, const StringVec& sets)
+{
+	Command cmd("SDIFF");
+
+	cmd << set << sets;
+
+	return cmd;
+}
+
+
+Command Command::sdiffstore(const std::string& set, const std::string& set1, const std::string& set2)
+{
+	Command cmd("SDIFFSTORE");
+
+	cmd << set << set1 << set2;
+
+	return cmd;
+}
+
+
+Command Command::sdiffstore(const std::string& set, const StringVec& sets)
+{
+	Command cmd("SDIFFSTORE");
+
+	cmd << set << sets;
+
+	return cmd;
+}
+
+
+Command Command::set(const std::string& key, const std::string& value, bool overwrite, const Poco::Timespan& expireTime, bool create)
+{
+	Command cmd("SET");
+
+	cmd << key << value;
+	if (! overwrite) cmd << "NX";
+	if (! create) cmd << "XX";
+	if (expireTime.totalMicroseconds() > 0) cmd << "PX" << expireTime.totalMilliseconds();
+
+	return cmd;
+}
+
+
+Command Command::set(const std::string& key, Int64 value, bool overwrite, const Poco::Timespan& expireTime, bool create)
+{
+	return set(key, NumberFormatter::format(value), overwrite, expireTime, create);
+}
+
+
+Command Command::sinter(const std::string& set1, const std::string& set2)
+{
+	Command cmd("SINTER");
+
+	cmd << set1 << set2;
+
+	return cmd;
+}
+
+
+Command Command::sinter(const std::string& set, const StringVec& sets)
+{
+	Command cmd("SINTER");
+
+	cmd << set << sets;
+
+	return cmd;
+}
+
+
+Command Command::sinterstore(const std::string& set, const std::string& set1, const std::string& set2)
+{
+	Command cmd("SINTERSTORE");
+
+	cmd << set << set1 << set2;
+
+	return cmd;
+}
+
+
+Command Command::sinterstore(const std::string& set, const StringVec& sets)
+{
+	Command cmd("SINTERSTORE");
+
+	cmd << set << sets;
+
+	return cmd;
+}
+
+
+Command Command::sismember(const std::string& set, const std::string& member)
+{
+	Command cmd("SISMEMBER");
+
+	cmd << set << member;
+
+	return cmd;
+}
+
+
+Command Command::smembers(const std::string& set)
+{
+	Command cmd("SMEMBERS");
+
+	cmd << set;
+
+	return cmd;
+}
+
+
+Command Command::smove(const std::string& source, const std::string& destination, const std::string& member)
+{
+	Command cmd("SMOVE");
+
+	cmd << source  << destination << member;
+
+	return cmd;
+}
+
+
+Command Command::spop(const std::string& set, Int64 count)
+{
+	Command cmd("SPOP");
+
+	cmd << set;
+	if( count != 0 ) cmd << NumberFormatter::format(count);
+
+	return cmd;
+}
+
+
+Command Command::srandmember(const std::string& set, Int64 count)
+{
+	Command cmd("SRANDMEMBER");
+
+	cmd << set;
+	if( count != 0 ) cmd << NumberFormatter::format(count);
+
+	return cmd;
+}
+
+
+Command Command::srem(const std::string& set1, const std::string& member)
+{
+	Command cmd("SREM");
+
+	cmd << set1 << member;
+
+	return cmd;
+}
+
+
+Command Command::srem(const std::string& set, const StringVec& members)
+{
+	Command cmd("SREM");
+
+	cmd << set << members;
+
+	return cmd;
+}
+
+
+Command Command::sunion(const std::string& set1, const std::string& set2)
+{
+	Command cmd("SUNION");
+
+	cmd << set1 << set2;
+
+	return cmd;
+}
+
+
+Command Command::sunion(const std::string& set, const StringVec& sets)
+{
+	Command cmd("SUNION");
+
+	cmd << set << sets;
+
+	return cmd;
+}
+
+
+Command Command::sunionstore(const std::string& set, const std::string& set1, const std::string& set2)
+{
+	Command cmd("SUNIONSTORE");
+
+	cmd << set << set1 << set2;
+
+	return cmd;
+}
+
+
+Command Command::sunionstore(const std::string& set, const StringVec& sets)
+{
+	Command cmd("SUNIONSTORE");
+
+	cmd << set << sets;
+
+	return cmd;
+}
+
+
+Command Command::rename(const std::string& key, const std::string& newName, bool overwrite)
+{
+	Command cmd(overwrite ? "RENAME" : "RENAMENX");
+
+	cmd << key << newName;
+
+	return cmd;
+}
+
+
+Command Command::rpop(const std::string& list)
+{
+	Command cmd("RPOP");
+
+	cmd << list;
+
+	return cmd;
+}
+
+
+Command Command::rpoplpush(const std::string& sourceList, const std::string& destinationList)
+{
+	Command cmd("RPOPLPUSH");
+
+	cmd << sourceList << destinationList;
+
+	return cmd;
+}
+
+
+Command Command::rpush(const std::string& list, const std::string& value, bool create)
+{
+	Command cmd(create ? "RPUSH" : "RPUSHX");
+
+	cmd << list << value;
+
+	return cmd;
+}
+
+
+Command Command::rpush(const std::string& list, const StringVec& values, bool create)
+{
+	Command cmd(create ? "RPUSH" : "RPUSHX");
+
+	cmd << list << values;
+
+	return cmd;
+}
+
+
+Command Command::expire(const std::string& key, Int64 seconds)
+{
+	Command cmd("EXPIRE");
+
+	cmd << key << NumberFormatter::format(seconds);
+
+	return cmd;
+}
+
+
+Command Command::ping()
+{
+	Command cmd("PING");
+
+	return cmd;
+}
+
+
+Command Command::multi()
+{
+	Command cmd("MULTI");
+
+	return cmd;
+}
+
+
+Command Command::exec()
+{
+	Command cmd("EXEC");
+
+	return cmd;
+}
+
+
+Command Command::discard()
+{
+	Command cmd("DISCARD");
+
+	return cmd;
+}
+
+
+} } // namespace Poco::Redis
diff --git a/base/poco/Redis/src/Error.cpp b/base/poco/Redis/src/Error.cpp
new file mode 100644
index 00000000000..47f7cb766f9
--- /dev/null
+++ b/base/poco/Redis/src/Error.cpp
@@ -0,0 +1,39 @@
+//
+// Error.cpp
+//
+// Library: Redis
+// Package: Redis
+// Module:  Error
+//
+// Implementation of the Error class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Redis/Error.h"
+
+
+namespace Poco {
+namespace Redis {
+
+
+Error::Error()
+{
+}
+
+
+Error::Error(const std::string& message): _message(message)
+{
+}
+
+
+Error::~Error()
+{
+}
+
+
+} } // namespace Poco::Redis
diff --git a/base/poco/Redis/src/Exception.cpp b/base/poco/Redis/src/Exception.cpp
new file mode 100644
index 00000000000..e2829f12a5d
--- /dev/null
+++ b/base/poco/Redis/src/Exception.cpp
@@ -0,0 +1,27 @@
+//
+// Exception.h
+//
+// Library: Redis
+// Package: Redis
+// Module:  Exception
+//
+// Implementation of the Exception class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Redis/Exception.h"
+
+
+namespace Poco {
+namespace Redis {
+
+
+POCO_IMPLEMENT_EXCEPTION(RedisException, Exception, "Redis Exception")
+
+
+} } // namespace Poco::Redis
diff --git a/base/poco/Redis/src/RedisEventArgs.cpp b/base/poco/Redis/src/RedisEventArgs.cpp
new file mode 100644
index 00000000000..014da2bb835
--- /dev/null
+++ b/base/poco/Redis/src/RedisEventArgs.cpp
@@ -0,0 +1,46 @@
+//
+// RedisEventArgs.cpp
+//
+// Library: Redis
+// Package: Redis
+// Module:  RedisEventArgs
+//
+// Implementation of the RedisEventArgs class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Redis/RedisEventArgs.h"
+
+
+namespace Poco {
+namespace Redis {
+
+
+RedisEventArgs::RedisEventArgs(RedisType::Ptr pMessage):
+	_message(pMessage),
+	_exception(0),
+	_stop(false)
+{
+}
+
+
+RedisEventArgs::RedisEventArgs(Exception* pException):
+	_message(),
+	_exception(pException ? pException->clone() : 0),
+	_stop(false)
+{
+}
+
+
+RedisEventArgs::~RedisEventArgs()
+{
+	delete _exception;
+}
+
+
+} } // namespace Poco::Redis
diff --git a/base/poco/Redis/src/RedisStream.cpp b/base/poco/Redis/src/RedisStream.cpp
new file mode 100644
index 00000000000..a81eb293967
--- /dev/null
+++ b/base/poco/Redis/src/RedisStream.cpp
@@ -0,0 +1,133 @@
+//
+// RedisStream.cpp
+//
+// Library: Redis
+// Package: Redis
+// Module:  RedisStream
+//
+// Implementation of the RedisStream class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Redis/RedisStream.h"
+#include <iostream>
+
+
+namespace Poco {
+namespace Redis {
+
+
+//
+// RedisStreamBuf
+//
+
+
+RedisStreamBuf::RedisStreamBuf(Net::StreamSocket& redis):
+	BufferedStreamBuf(STREAM_BUFFER_SIZE, std::ios::in | std::ios::out),
+	_redis(redis)
+{
+}
+
+
+RedisStreamBuf::~RedisStreamBuf()
+{
+}
+
+
+int RedisStreamBuf::readFromDevice(char* buffer, std::streamsize len)
+{
+	return _redis.receiveBytes(buffer, len);
+}
+
+
+int RedisStreamBuf::writeToDevice(const char* buffer, std::streamsize length)
+{
+	return _redis.sendBytes(buffer, length);
+}
+
+
+//
+// RedisIOS
+//
+
+
+RedisIOS::RedisIOS(Net::StreamSocket& redis):
+	_buf(redis)
+{
+	poco_ios_init(&_buf);
+}
+
+
+RedisIOS::~RedisIOS()
+{
+	try
+	{
+		_buf.sync();
+	}
+	catch (...)
+	{
+	}
+}
+
+
+RedisStreamBuf* RedisIOS::rdbuf()
+{
+	return &_buf;
+}
+
+
+void RedisIOS::close()
+{
+	_buf.sync();
+}
+
+
+//
+// RedisOutputStream
+//
+
+
+RedisOutputStream::RedisOutputStream(Net::StreamSocket& redis):
+	RedisIOS(redis),
+	std::ostream(&_buf)
+{
+}
+
+
+RedisOutputStream::~RedisOutputStream()
+{
+}
+
+
+RedisInputStream::RedisInputStream(Net::StreamSocket& redis):
+	RedisIOS(redis),
+	std::istream(&_buf)
+{
+}
+
+
+//
+// RedisInputStream
+//
+
+
+RedisInputStream::~RedisInputStream()
+{
+}
+
+
+std::string RedisInputStream::getline()
+{
+	std::string line;
+	std::getline(*this, line);
+	if ( line.size() > 0 ) line.erase(line.end() - 1);
+	return line;
+}
+
+
+} } // namespace Poco::Redis
diff --git a/base/poco/Redis/src/Type.cpp b/base/poco/Redis/src/Type.cpp
new file mode 100644
index 00000000000..83a50448881
--- /dev/null
+++ b/base/poco/Redis/src/Type.cpp
@@ -0,0 +1,62 @@
+//
+// Type.h
+//
+// Library: Redis
+// Package: Redis
+// Module:  Type
+//
+// Implementation of the Type class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Redis/Type.h"
+#include "Poco/Redis/Error.h"
+#include "Poco/Redis/Array.h"
+
+
+namespace Poco {
+namespace Redis {
+
+
+RedisType::RedisType()
+{
+}
+
+
+RedisType::~RedisType()
+{
+}
+
+
+RedisType::Ptr RedisType::createRedisType(char marker)
+{
+	RedisType::Ptr result;
+
+	switch(marker)
+	{
+	case RedisTypeTraits<Int64>::marker :
+		result = new Type<Int64>();
+		break;
+	case RedisTypeTraits<std::string>::marker :
+		result = new Type<std::string>();
+		break;
+	case RedisTypeTraits<BulkString>::marker :
+		result = new Type<BulkString>();
+		break;
+	case RedisTypeTraits<Array>::marker :
+		result = new Type<Array>();
+		break;
+	case RedisTypeTraits<Error>::marker :
+		result = new Type<Error>();
+		break;
+	}
+	return result;
+}
+
+
+} } // namespace Poco::Redis
diff --git a/base/poco/Util/CMakeLists.txt b/base/poco/Util/CMakeLists.txt
new file mode 100644
index 00000000000..f37e099e648
--- /dev/null
+++ b/base/poco/Util/CMakeLists.txt
@@ -0,0 +1,7 @@
+file (GLOB SRCS src/*.cpp)
+
+add_library (_poco_util ${SRCS})
+add_library (Poco::Util ALIAS _poco_util)
+
+target_include_directories (_poco_util SYSTEM PUBLIC "include")
+target_link_libraries (_poco_util PUBLIC Poco::JSON Poco::XML)
diff --git a/base/poco/Util/include/Poco/Util/AbstractConfiguration.h b/base/poco/Util/include/Poco/Util/AbstractConfiguration.h
new file mode 100644
index 00000000000..277c6d7296b
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/AbstractConfiguration.h
@@ -0,0 +1,381 @@
+//
+// AbstractConfiguration.h
+//
+// Library: Util
+// Package: Configuration
+// Module:  AbstractConfiguration
+//
+// Definition of the AbstractConfiguration class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_AbstractConfiguration_INCLUDED
+#define Util_AbstractConfiguration_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Mutex.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/BasicEvent.h"
+#include <vector>
+#include <utility>
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API AbstractConfiguration: public Poco::RefCountedObject
+	/// AbstractConfiguration is an abstract base class for different
+	/// kinds of configuration data, such as INI files, property files,
+	/// XML configuration files or the Windows Registry.
+	///
+	/// Configuration property keys have a hierarchical format, consisting
+	/// of names separated by periods. The exact interpretation of key names
+	/// is up to the actual subclass implementation of AbstractConfiguration.
+	/// Keys are case sensitive.
+	///
+	/// All public methods are synchronized, so the class is safe for multithreaded use.
+	/// AbstractConfiguration implements reference counting based garbage collection.
+	///
+	/// Subclasses must override the getRaw(), setRaw() and enumerate() methods.
+{
+public:
+	typedef std::vector<std::string> Keys;
+	
+	class KeyValue
+		/// A key-value pair, used as event argument.
+	{
+	public:
+		KeyValue(const std::string& key, std::string& value):
+			_key(key),
+			_value(value)
+		{
+		}
+		
+		const std::string& key() const
+		{
+			return _key;
+		}
+		
+		const std::string& value() const
+		{
+			return _value;
+		}
+		
+		std::string& value()
+		{
+			return _value;
+		}
+	
+	private:
+		const std::string& _key;
+		std::string& _value;
+	};
+	
+	Poco::BasicEvent<KeyValue> propertyChanging;
+		/// Fired before a property value is changed or
+		/// a new property is created.
+		///
+		/// Can be used to check or fix a property value,
+		/// or to cancel the change by throwing an exception.
+		///
+		/// The event delegate can use one of the get...() functions
+		/// to obtain the current property value.
+
+	Poco::BasicEvent<const KeyValue> propertyChanged;
+		/// Fired after a property value has been changed
+		/// or a property has been created.
+
+	Poco::BasicEvent<const std::string> propertyRemoving;
+		/// Fired before a property is removed by a
+		/// call to remove().
+		///
+		/// Note: This will even be fired if the key
+		/// does not exist and the remove operation will
+		/// fail with an exception.
+		
+	Poco::BasicEvent<const std::string> propertyRemoved;
+		/// Fired after a property has been removed by
+		/// a call to remove().
+
+	AbstractConfiguration();
+		/// Creates the AbstractConfiguration.
+
+	bool hasProperty(const std::string& key) const;
+		/// Returns true iff the property with the given key exists.
+
+	bool hasOption(const std::string& key) const;
+		/// Returns true iff the property with the given key exists.
+		///
+		/// Same as hasProperty().
+
+	bool has(const std::string& key) const;
+		/// Returns true iff the property with the given key exists.
+		///
+		/// Same as hasProperty().
+		
+	std::string getString(const std::string& key) const;
+		/// Returns the string value of the property with the given name.
+		/// Throws a NotFoundException if the key does not exist.
+		/// If the value contains references to other properties (${<property>}), these
+		/// are expanded.
+		
+	std::string getString(const std::string& key, const std::string& defaultValue) const;
+		/// If a property with the given key exists, returns the property's string value,
+		/// otherwise returns the given default value.
+		/// If the value contains references to other properties (${<property>}), these
+		/// are expanded.
+
+	std::string getRawString(const std::string& key) const;
+		/// Returns the raw string value of the property with the given name.
+		/// Throws a NotFoundException if the key does not exist.
+		/// References to other properties are not expanded.
+		
+	std::string getRawString(const std::string& key, const std::string& defaultValue) const;
+		/// If a property with the given key exists, returns the property's raw string value,
+		/// otherwise returns the given default value.
+		/// References to other properties are not expanded.
+		
+	int getInt(const std::string& key) const;
+		/// Returns the int value of the property with the given name.
+		/// Throws a NotFoundException if the key does not exist.
+		/// Throws a SyntaxException if the property can not be converted
+		/// to an int.
+		/// Numbers starting with 0x are treated as hexadecimal.
+		/// If the value contains references to other properties (${<property>}), these
+		/// are expanded.
+		
+	unsigned int getUInt(const std::string& key) const;
+		/// Returns the unsigned int value of the property with the given name.
+		/// Throws a NotFoundException if the key does not exist.
+		/// Throws a SyntaxException if the property can not be converted
+		/// to an unsigned int.
+		/// Numbers starting with 0x are treated as hexadecimal.
+		/// If the value contains references to other properties (${<property>}), these
+		/// are expanded.
+		
+	int getInt(const std::string& key, int defaultValue) const;
+		/// If a property with the given key exists, returns the property's int value,
+		/// otherwise returns the given default value.
+		/// Throws a SyntaxException if the property can not be converted
+		/// to an int.
+		/// Numbers starting with 0x are treated as hexadecimal.
+		/// If the value contains references to other properties (${<property>}), these
+		/// are expanded.
+		
+	unsigned int getUInt(const std::string& key, unsigned int defaultValue) const;
+		/// If a property with the given key exists, returns the property's unsigned int
+		/// value, otherwise returns the given default value.
+		/// Throws a SyntaxException if the property can not be converted
+		/// to an unsigned int.
+		/// Numbers starting with 0x are treated as hexadecimal.
+		/// If the value contains references to other properties (${<property>}), these
+		/// are expanded.
+
+#if defined(POCO_HAVE_INT64)
+
+	Int64 getInt64(const std::string& key) const;
+		/// Returns the Int64 value of the property with the given name.
+		/// Throws a NotFoundException if the key does not exist.
+		/// Throws a SyntaxException if the property can not be converted
+		/// to an Int64.
+		/// Numbers starting with 0x are treated as hexadecimal.
+		/// If the value contains references to other properties (${<property>}), these
+		/// are expanded.
+
+	UInt64 getUInt64(const std::string& key) const;
+		/// Returns the UInt64 value of the property with the given name.
+		/// Throws a NotFoundException if the key does not exist.
+		/// Throws a SyntaxException if the property can not be converted
+		/// to an UInt64.
+		/// Numbers starting with 0x are treated as hexadecimal.
+		/// If the value contains references to other properties (${<property>}), these
+		/// are expanded.
+
+	Int64 getInt64(const std::string& key, Int64 defaultValue) const;
+		/// If a property with the given key exists, returns the property's Int64 value,
+		/// otherwise returns the given default value.
+		/// Throws a SyntaxException if the property can not be converted
+		/// to an Int64.
+		/// Numbers starting with 0x are treated as hexadecimal.
+		/// If the value contains references to other properties (${<property>}), these
+		/// are expanded.
+
+	UInt64 getUInt64(const std::string& key, UInt64 defaultValue) const;
+		/// If a property with the given key exists, returns the property's UInt64
+		/// value, otherwise returns the given default value.
+		/// Throws a SyntaxException if the property can not be converted
+		/// to an UInt64.
+		/// Numbers starting with 0x are treated as hexadecimal.
+		/// If the value contains references to other properties (${<property>}), these
+		/// are expanded.
+
+#endif // defined(POCO_HAVE_INT64)
+
+	double getDouble(const std::string& key) const;
+		/// Returns the double value of the property with the given name.
+		/// Throws a NotFoundException if the key does not exist.
+		/// Throws a SyntaxException if the property can not be converted
+		/// to a double.
+		/// If the value contains references to other properties (${<property>}), these
+		/// are expanded.
+		
+	double getDouble(const std::string& key, double defaultValue) const;
+		/// If a property with the given key exists, returns the property's double value,
+		/// otherwise returns the given default value.
+		/// Throws a SyntaxException if the property can not be converted
+		/// to an double.
+		/// If the value contains references to other properties (${<property>}), these
+		/// are expanded.
+
+	bool getBool(const std::string& key) const;
+		/// Returns the boolean value of the property with the given name.
+		/// Throws a NotFoundException if the key does not exist.
+		/// Throws a SyntaxException if the property can not be converted
+		/// to a boolean.
+		/// If the value contains references to other properties (${<property>}), these
+		/// are expanded.
+		
+	bool getBool(const std::string& key, bool defaultValue) const;
+		/// If a property with the given key exists, returns the property's boolean value,
+		/// otherwise returns the given default value.
+		/// Throws a SyntaxException if the property can not be converted
+		/// to a boolean.
+		/// The following string values can be converted into a boolean:
+		///   - numerical values: non zero becomes true, zero becomes false
+		///   - strings: true, yes, on become true, false, no, off become false
+		/// Case does not matter.
+		/// If the value contains references to other properties (${<property>}), these
+		/// are expanded.
+		
+	virtual void setString(const std::string& key, const std::string& value);
+		/// Sets the property with the given key to the given value.
+		/// An already existing value for the key is overwritten.
+		
+	virtual void setInt(const std::string& key, int value);
+		/// Sets the property with the given key to the given value.
+		/// An already existing value for the key is overwritten.
+		
+	virtual void setUInt(const std::string& key, unsigned int value);
+		/// Sets the property with the given key to the given value.
+		/// An already existing value for the key is overwritten.
+
+#if defined(POCO_HAVE_INT64)
+
+	virtual void setInt64(const std::string& key, Int64 value);
+		/// Sets the property with the given key to the given value.
+		/// An already existing value for the key is overwritten.
+
+	virtual void setUInt64(const std::string& key, UInt64 value);
+		/// Sets the property with the given key to the given value.
+		/// An already existing value for the key is overwritten.
+
+#endif // defined(POCO_HAVE_INT64)
+
+	virtual void setDouble(const std::string& key, double value);
+		/// Sets the property with the given key to the given value.
+		/// An already existing value for the key is overwritten.
+
+	virtual void setBool(const std::string& key, bool value);
+		/// Sets the property with the given key to the given value.
+		/// An already existing value for the key is overwritten.
+		
+	void keys(Keys& range) const;
+		/// Returns in range the names of all keys at root level.
+
+	void keys(const std::string& key, Keys& range) const;
+		/// Returns in range the names of all subkeys under the given key.
+		/// If an empty key is passed, all root level keys are returned.
+	
+	const AbstractConfiguration* createView(const std::string& prefix) const;
+		/// Creates a non-mutable view (see ConfigurationView) into the configuration.
+
+	AbstractConfiguration* createView(const std::string& prefix);
+		/// Creates a view (see ConfigurationView) into the configuration.
+	
+	std::string expand(const std::string& value) const;
+		/// Replaces all occurrences of ${<property>} in value with the
+		/// value of the <property>. If <property> does not exist,
+		/// nothing is changed.
+		///
+		/// If a circular property reference is detected, a
+		/// CircularReferenceException will be thrown.
+
+	void remove(const std::string& key);
+		/// Removes the property with the given key.
+		///
+		/// Does nothing if the key does not exist.
+		
+	void enableEvents(bool enable = true);
+		/// Enables (or disables) events.
+		
+	bool eventsEnabled() const;
+		/// Returns true iff events are enabled.
+	
+protected:
+	virtual bool getRaw(const std::string& key, std::string& value) const = 0;
+		/// If the property with the given key exists, stores the property's value
+		/// in value and returns true. Otherwise, returns false.
+		///
+		/// Must be overridden by subclasses.
+
+	virtual void setRaw(const std::string& key, const std::string& value) = 0;
+		/// Sets the property with the given key to the given value.
+		/// An already existing value for the key is overwritten.
+		///
+		/// Must be overridden by subclasses.
+		
+	virtual void enumerate(const std::string& key, Keys& range) const = 0;
+		/// Returns in range the names of all subkeys under the given key.
+		/// If an empty key is passed, all root level keys are returned.
+		
+	virtual void removeRaw(const std::string& key);
+		/// Removes the property with the given key.
+		///
+		/// Does nothing if the key does not exist.
+		///
+		/// Should be overridden by subclasses; the default
+		/// implementation throws a Poco::NotImplementedException.
+
+	static int parseInt(const std::string& value);
+	static unsigned parseUInt(const std::string& value);
+
+#if defined(POCO_HAVE_INT64)
+
+	static Int64 parseInt64(const std::string& value);
+	static UInt64 parseUInt64(const std::string& value);
+
+#endif // defined(POCO_HAVE_INT64)
+
+	static bool parseBool(const std::string& value);
+	void setRawWithEvent(const std::string& key, std::string value);
+	
+	virtual ~AbstractConfiguration();
+
+private:
+	std::string internalExpand(const std::string& value) const;
+	std::string uncheckedExpand(const std::string& value) const;
+
+	AbstractConfiguration(const AbstractConfiguration&);
+	AbstractConfiguration& operator = (const AbstractConfiguration&);
+
+	mutable int _depth;
+	bool        _eventsEnabled;
+	mutable Poco::Mutex _mutex;
+	
+	friend class LayeredConfiguration;
+	friend class ConfigurationView;
+	friend class ConfigurationMapper;
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_AbstractConfiguration_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/Application.h b/base/poco/Util/include/Poco/Util/Application.h
new file mode 100644
index 00000000000..da63ecf1b9b
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/Application.h
@@ -0,0 +1,545 @@
+//
+// Application.h
+//
+// Library: Util
+// Package: Application
+// Module:  Application
+//
+// Definition of the Application class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_Application_INCLUDED
+#define Util_Application_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Util/Subsystem.h"
+#include "Poco/Util/LayeredConfiguration.h"
+#include "Poco/Util/OptionSet.h"
+#include "Poco/AutoPtr.h"
+#include "Poco/Logger.h"
+#include "Poco/Path.h"
+#include "Poco/Timestamp.h"
+#include "Poco/Timespan.h"
+#include "Poco/AutoPtr.h"
+#if defined(POCO_VXWORKS)
+#include <cstdarg>
+#endif
+#include <vector>
+#include <typeinfo>
+
+
+namespace Poco {
+namespace Util {
+
+
+class OptionSet;
+
+
+class Util_API Application: public Subsystem
+	/// The Application class implements the main subsystem
+	/// in a process. The application class is responsible for
+	/// initializing all its subsystems.
+	///
+	/// Subclasses can and should override the following virtual methods:
+	///   - initialize() (the one-argument, protected variant)
+	///   - uninitialize()
+	///   - reinitialize()
+	///   - defineOptions()
+	///   - handleOption()
+	///   - main()
+	///
+	/// The application's main logic should be implemented in
+	/// the main() method.
+	///
+	/// There may be at most one instance of the Application class
+	/// in a process.
+	///
+	/// The Application class maintains a LayeredConfiguration (available
+	/// via the config() member function) consisting of:
+	///   - a MapConfiguration (priority -100) storing application-specific
+	///     properties, as well as properties from bound command line arguments.
+	///   - a SystemConfiguration (priority 100)
+	///   - the configurations loaded with loadConfiguration().
+	///
+	/// The Application class sets a few default properties in
+	/// its configuration. These are:
+	///   - application.path: the absolute path to application executable
+	///   - application.name: the file name of the application executable
+	///   - application.baseName: the file name (excluding extension) of the application executable
+	///   - application.dir: the path to the directory where the application executable resides
+	///   - application.configDir: the path to the directory where user specific configuration files of the application should be stored.
+	///   - application.cacheDir: the path to the directory where user specific non-essential data files of the application should be stored.
+	///   - application.dataDir: the path to the directory where user specific data files of the application should be stored.
+	///   - application.tempDir: the path to the directory where user specific temporary files and other file objects of the application should be stored.
+	///
+	/// If loadConfiguration() has never been called, application.configDir will be equal to application.dir.
+	///
+	/// The POCO_APP_MAIN macro can be used to implement main(argc, argv).
+	/// If POCO has been built with POCO_WIN32_UTF8, POCO_APP_MAIN supports
+	/// Unicode command line arguments.
+{
+public:
+	typedef std::vector<std::string> ArgVec;
+	typedef Poco::AutoPtr<Subsystem> SubsystemPtr;
+	typedef std::vector<SubsystemPtr> SubsystemVec;
+
+	enum ExitCode
+		/// Commonly used exit status codes.
+		/// Based on the definitions in the 4.3BSD <sysexits.h> header file.
+	{
+		EXIT_OK          = 0,  /// successful termination
+		EXIT_USAGE	     = 64, /// command line usage error
+		EXIT_DATAERR     = 65, /// data format error
+		EXIT_NOINPUT     = 66, /// cannot open input
+		EXIT_NOUSER      = 67, /// addressee unknown
+		EXIT_NOHOST      = 68, /// host name unknown
+		EXIT_UNAVAILABLE = 69, /// service unavailable
+		EXIT_SOFTWARE    = 70, /// internal software error
+		EXIT_OSERR	     = 71, /// system error (e.g., can't fork)
+		EXIT_OSFILE      = 72, /// critical OS file missing
+		EXIT_CANTCREAT   = 73, /// can't create (user) output file
+		EXIT_IOERR       = 74, /// input/output error
+		EXIT_TEMPFAIL    = 75, /// temp failure; user is invited to retry
+		EXIT_PROTOCOL    = 76, /// remote error in protocol
+		EXIT_NOPERM      = 77, /// permission denied
+		EXIT_CONFIG      = 78  /// configuration error
+	};
+
+	enum ConfigPriority
+	{
+		PRIO_APPLICATION = -100,
+		PRIO_DEFAULT     = 0,
+		PRIO_SYSTEM      = 100
+	};
+
+	Application();
+		/// Creates the Application.
+
+	Application(int argc, char* argv[]);
+		/// Creates the Application and calls init(argc, argv).
+
+	void addSubsystem(Subsystem* pSubsystem);
+		/// Adds a new subsystem to the application. The
+		/// application immediately takes ownership of it, so that a
+		/// call in the form
+		///     Application::instance().addSubsystem(new MySubsystem);
+		/// is okay.
+
+	void init(int argc, char* argv[]);
+		/// Processes the application's command line arguments
+		/// and sets the application's properties (e.g.,
+		/// "application.path", "application.name", etc.).
+		///
+		/// Note that as of release 1.3.7, init() no longer
+		/// calls initialize(). This is now called from run().
+
+#if defined(POCO_WIN32_UTF8) && !defined(POCO_NO_WSTRING)
+	void init(int argc, wchar_t* argv[]);
+		/// Processes the application's command line arguments
+		/// and sets the application's properties (e.g.,
+		/// "application.path", "application.name", etc.).
+		///
+		/// Note that as of release 1.3.7, init() no longer
+		/// calls initialize(). This is now called from run().
+		///
+		/// This Windows-specific version of init is used for passing
+		/// Unicode command line arguments from wmain().
+#endif
+
+	void init(const ArgVec& args);
+		/// Processes the application's command line arguments
+		/// and sets the application's properties (e.g.,
+		/// "application.path", "application.name", etc.).
+		///
+		/// Note that as of release 1.3.7, init() no longer
+		/// calls initialize(). This is now called from run().
+
+	bool initialized() const;
+		/// Returns true iff the application is in initialized state
+		/// (that means, has been initialized but not yet uninitialized).
+
+	void setUnixOptions(bool flag);
+		/// Specify whether command line option handling is Unix-style
+		/// (flag == true; default) or Windows/OpenVMS-style (flag == false).
+		///
+		/// This member function should be called from the constructor of
+		/// a subclass to be effective.
+
+	int loadConfiguration(int priority = PRIO_DEFAULT);
+		/// Loads configuration information from a default location.
+		///
+		/// The configuration(s) will be added to the application's
+		/// LayeredConfiguration with the given priority.
+		///
+		/// The configuration file(s) must be located in the same directory
+		/// as the executable or a parent directory of it, and must have the
+		/// same base name as the executable, with one of the following extensions:
+		/// .properties, .ini or .xml.
+		///
+		/// The .properties file, if it exists, is loaded first, followed
+		/// by the .ini file and the .xml file.
+		///
+		/// If the application is built in debug mode (the _DEBUG preprocessor
+		/// macro is defined) and the base name of the appication executable
+		/// ends with a 'd', a config file without the 'd' ending its base name is
+		/// also found.
+		///
+		/// Example: Given the application "SampleAppd.exe", built in debug mode.
+		/// Then loadConfiguration() will automatically find a configuration file
+		/// named "SampleApp.properties" if it exists and if "SampleAppd.properties"
+		/// cannot be found.
+		///
+		/// Returns the number of configuration files loaded, which may be zero.
+		///
+		/// This method must not be called before init(argc, argv)
+		/// has been called.
+
+	void loadConfiguration(const std::string& path, int priority = PRIO_DEFAULT);
+		/// Loads configuration information from the file specified by
+		/// the given path. The file type is determined by the file
+		/// extension. The following extensions are supported:
+		///   - .properties - properties file (PropertyFileConfiguration)
+		///   - .ini        - initialization file (IniFileConfiguration)
+		///   - .xml        - XML file (XMLConfiguration)
+		///
+		/// Extensions are not case sensitive.
+		///
+		/// The configuration will be added to the application's
+		/// LayeredConfiguration with the given priority.
+
+	template <class C> C& getSubsystem() const;
+		/// Returns a reference to the subsystem of the class
+		/// given as template argument.
+		///
+		/// Throws a NotFoundException if such a subsystem has
+		/// not been registered.
+
+	SubsystemVec& subsystems();
+		/// Returns a reference to the subsystem list
+
+	virtual int run();
+		/// Runs the application by performing additional (un)initializations
+		/// and calling the main() method.
+		///
+		/// First calls initialize(), then calls main(), and
+		/// finally calls uninitialize(). The latter will be called
+		/// even if main() throws an exception. If initialize() throws
+		/// an exception, main() will not be called and the exception
+		/// will be propagated to the caller. If uninitialize() throws
+		/// an exception, the exception will be propagated to the caller.
+
+	std::string commandName() const;
+		/// Returns the command name used to invoke the application.
+
+	std::string commandPath() const;
+		/// Returns the full command path used to invoke the application.
+
+	LayeredConfiguration& config() const;
+		/// Returns the application's configuration.
+
+	Poco::Logger& logger() const;
+		/// Returns the application's logger.
+		///
+		/// Before the logging subsystem has been initialized, the
+		/// application's logger is "ApplicationStartup", which is
+		/// connected to a ConsoleChannel.
+		///
+		/// After the logging subsystem has been initialized, which
+		/// usually happens as the first action in Application::initialize(),
+		/// the application's logger is the one specified by the
+		/// "application.logger" configuration property. If that property
+		/// is not specified, the logger is "Application".
+
+	const ArgVec& argv() const;
+		/// Returns reference to vector of the application's arguments as
+		/// specified on the command line. If user overrides the
+		/// Application::main(const ArgVec&) function, it will receive
+		/// only the command line parameters that were not processed in
+		/// Application::processOptons(). This function returns the
+		/// full set of command line parameters as received in
+		/// main(argc, argv*).
+
+	const OptionSet& options() const;
+		/// Returns the application's option set.
+
+	static Application& instance();
+		/// Returns a reference to the Application singleton.
+		///
+		/// Throws a NullPointerException if no Application instance exists.
+
+	const Poco::Timestamp& startTime() const;
+		/// Returns the application start time (UTC).
+
+	Poco::Timespan uptime() const;
+		/// Returns the application uptime.
+
+	void stopOptionsProcessing();
+		/// If called from an option callback, stops all further
+		/// options processing.
+		///
+		/// If called, the following options on the command line
+		/// will not be processed, and required options will not
+		/// be checked.
+		///
+		/// This is useful, for example, if an option for displaying
+		/// help information has been encountered and no other things
+		/// besides displaying help shall be done.
+
+	const char* name() const;
+
+protected:
+	void initialize(Application& self);
+		/// Initializes the application and all registered subsystems.
+		/// Subsystems are always initialized in the exact same order
+		/// in which they have been registered.
+		///
+		/// Overriding implementations must call the base class implementation.
+
+	void uninitialize();
+		/// Uninitializes the application and all registered subsystems.
+		/// Subsystems are always uninitialized in reverse order in which
+		/// they have been initialized.
+		///
+		/// Overriding implementations must call the base class implementation.
+
+	void reinitialize(Application& self);
+		/// Re-nitializes the application and all registered subsystems.
+		/// Subsystems are always reinitialized in the exact same order
+		/// in which they have been registered.
+		///
+		/// Overriding implementations must call the base class implementation.
+
+	virtual void defineOptions(OptionSet& options);
+		/// Called before command line processing begins.
+		/// If a subclass wants to support command line arguments,
+		/// it must override this method.
+		/// The default implementation does not define any options itself,
+		/// but calls defineOptions() on all registered subsystems.
+		///
+		/// Overriding implementations should call the base class implementation.
+
+	virtual void handleOption(const std::string& name, const std::string& value);
+		/// Called when the option with the given name is encountered
+		/// during command line arguments processing.
+		///
+		/// The default implementation does option validation, bindings
+		/// and callback handling.
+		///
+		/// Overriding implementations must call the base class implementation.
+
+	void setLogger(Poco::Logger& logger);
+		/// Sets the logger used by the application.
+
+	virtual int main(const std::vector<std::string>& args);
+		/// The application's main logic.
+		///
+		/// Unprocessed command line arguments are passed in args.
+		/// Note that all original command line arguments are available
+		/// via the properties application.argc and application.argv[<n>].
+		///
+		/// Returns an exit code which should be one of the values
+		/// from the ExitCode enumeration.
+
+	bool findFile(Poco::Path& path) const;
+		/// Searches for the file in path in the application directory.
+		///
+		/// If path is absolute, the method immediately returns true and
+		/// leaves path unchanged.
+		///
+		/// If path is relative, searches for the file in the application
+		/// directory and in all subsequent parent directories.
+		/// Returns true and stores the absolute path to the file in
+		/// path if the file could be found. Returns false and leaves path
+		/// unchanged otherwise.
+
+	void init();
+		/// Common initialization code.
+
+	~Application();
+		/// Destroys the Application and deletes all registered subsystems.
+
+private:
+	void setup();
+	void setArgs(int argc, char* argv[]);
+	void setArgs(const ArgVec& args);
+	void getApplicationPath(Poco::Path& path) const;
+	void processOptions();
+	bool findAppConfigFile(const std::string& appName, const std::string& extension, Poco::Path& path) const;
+	bool findAppConfigFile(const Path& basePath, const std::string& appName, const std::string& extension, Poco::Path& path) const;
+
+	typedef Poco::AutoPtr<LayeredConfiguration> ConfigPtr;
+
+	ConfigPtr       _pConfig;
+	SubsystemVec    _subsystems;
+	bool            _initialized;
+	std::string     _command;
+	ArgVec          _argv;
+	ArgVec          _unprocessedArgs;
+	OptionSet       _options;
+	bool            _unixOptions;
+	Poco::Logger*   _pLogger;
+	Poco::Timestamp _startTime;
+	bool            _stopOptionsProcessing;
+
+#if defined(POCO_OS_FAMILY_UNIX) && !defined(POCO_VXWORKS)
+	std::string _workingDirAtLaunch;
+#endif
+
+	static Application* _pInstance;
+
+	friend class LoggingSubsystem;
+
+	Application(const Application&);
+	Application& operator = (const Application&);
+};
+
+
+//
+// inlines
+//
+template <class C> C& Application::getSubsystem() const
+{
+	for (SubsystemVec::const_iterator it = _subsystems.begin(); it != _subsystems.end(); ++it)
+	{
+		const Subsystem* pSS(it->get());
+		const C* pC = dynamic_cast<const C*>(pSS);
+		if (pC) return *const_cast<C*>(pC);
+	}
+	throw Poco::NotFoundException("The subsystem has not been registered", typeid(C).name());
+}
+
+inline Application::SubsystemVec& Application::subsystems()
+{
+	return _subsystems;
+}
+
+
+inline bool Application::initialized() const
+{
+	return _initialized;
+}
+
+
+inline LayeredConfiguration& Application::config() const
+{
+	return *const_cast<LayeredConfiguration*>(_pConfig.get());
+}
+
+
+inline Poco::Logger& Application::logger() const
+{
+	poco_check_ptr (_pLogger);
+	return *_pLogger;
+}
+
+
+inline const Application::ArgVec& Application::argv() const
+{
+	return _argv;
+}
+
+
+inline const OptionSet& Application::options() const
+{
+	return _options;
+}
+
+
+inline Application& Application::instance()
+{
+	poco_check_ptr (_pInstance);
+	return *_pInstance;
+}
+
+
+inline const Poco::Timestamp& Application::startTime() const
+{
+	return _startTime;
+}
+
+
+inline Poco::Timespan Application::uptime() const
+{
+	Poco::Timestamp now;
+	Poco::Timespan uptime = now - _startTime;
+
+	return uptime;
+}
+
+
+} } // namespace Poco::Util
+
+
+//
+// Macro to implement main()
+//
+#if defined(_WIN32) && defined(POCO_WIN32_UTF8) && !defined(POCO_NO_WSTRING)
+	#define POCO_APP_MAIN(App) \
+	int wmain(int argc, wchar_t** argv)		\
+	{										\
+		Poco::AutoPtr<App> pApp = new App;	\
+		try									\
+		{									\
+			pApp->init(argc, argv);			\
+		}									\
+		catch (Poco::Exception& exc)		\
+		{									\
+			pApp->logger().log(exc);		\
+			return Poco::Util::Application::EXIT_CONFIG;\
+		}									\
+		return pApp->run();					\
+	}
+#elif defined(POCO_VXWORKS)
+	#define POCO_APP_MAIN(App) \
+	int pocoAppMain(const char* appName, ...) \
+	{ \
+		std::vector<std::string> args; \
+		args.push_back(std::string(appName)); \
+		va_list vargs; \
+		va_start(vargs, appName); \
+		const char* arg = va_arg(vargs, const char*); \
+		while (arg) \
+		{ \
+			args.push_back(std::string(arg)); \
+			arg = va_arg(vargs, const char*); \
+		} \
+		va_end(vargs); \
+		Poco::AutoPtr<App> pApp = new App;	\
+		try									\
+		{									\
+			pApp->init(args);			\
+		}									\
+		catch (Poco::Exception& exc)		\
+		{									\
+			pApp->logger().log(exc);		\
+			return Poco::Util::Application::EXIT_CONFIG;\
+		}									\
+		return pApp->run();					\
+	}
+#else
+	#define POCO_APP_MAIN(App) \
+	int main(int argc, char** argv)			\
+	{										\
+		Poco::AutoPtr<App> pApp = new App;	\
+		try									\
+		{									\
+			pApp->init(argc, argv);			\
+		}									\
+		catch (Poco::Exception& exc)		\
+		{									\
+			pApp->logger().log(exc);		\
+			return Poco::Util::Application::EXIT_CONFIG;\
+		}									\
+		return pApp->run();					\
+	}
+#endif
+
+
+#endif // Util_Application_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/ConfigurationMapper.h b/base/poco/Util/include/Poco/Util/ConfigurationMapper.h
new file mode 100644
index 00000000000..ef8e960d515
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/ConfigurationMapper.h
@@ -0,0 +1,94 @@
+//
+// ConfigurationMapper.h
+//
+// Library: Util
+// Package: Configuration
+// Module:  ConfigurationMapper
+//
+// Definition of the ConfigurationMapper class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_ConfigurationMapper_INCLUDED
+#define Util_ConfigurationMapper_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Util/AbstractConfiguration.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API ConfigurationMapper: public AbstractConfiguration
+	/// This configuration maps a property hierarchy into another
+	/// hierarchy.
+	/// 
+	/// For example, given a configuration with the following properties:
+	///     config.value1
+	///     config.value2
+	///     config.sub.value1
+	///     config.sub.value2
+	/// and a ConfigurationView with fromPrefix == "config" and toPrefix == "root.conf", then
+	/// the above properties will be available via the mapper as
+	///     root.conf.value1
+	///     root.conf.value2
+	///     root.conf.sub.value1
+	///     root.conf.sub.value2
+	///
+	/// FromPrefix can be empty, in which case, and given toPrefix == "root",
+	/// the properties will be available as
+	///     root.config.value1
+	///     root.config.value2
+	///     root.config.sub.value1
+	///     root.config.sub.value2
+	///
+	/// This is equivalent to the functionality of the ConfigurationView class.
+	///
+	/// Similarly, toPrefix can also be empty. Given fromPrefix == "config" and
+	/// toPrefix == "", the properties will be available as
+	///     value1
+	///     value2
+	///     sub.value1
+	///     sub.value2
+	///
+	/// If both fromPrefix and toPrefix are empty, no mapping is performed.
+	///
+	/// A ConfigurationMapper is most useful in combination with a
+	/// LayeredConfiguration.
+{
+public:
+	ConfigurationMapper(const std::string& fromPrefix, const std::string& toPrefix, AbstractConfiguration* pConfig);
+		/// Creates the ConfigurationMapper. The ConfigurationMapper does not take
+		/// ownership of the passed configuration.
+
+protected:
+	bool getRaw(const std::string& key, std::string& value) const;
+	void setRaw(const std::string& key, const std::string& value);
+	void enumerate(const std::string& key, Keys& range) const;
+	void removeRaw(const std::string& key);
+	
+	std::string translateKey(const std::string& key) const;
+	
+	~ConfigurationMapper();
+
+private:
+	ConfigurationMapper(const ConfigurationMapper&);
+	ConfigurationMapper& operator = (const ConfigurationMapper&);
+
+	std::string _fromPrefix;
+	std::string _toPrefix;
+	AbstractConfiguration* _pConfig;
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_ConfigurationMapper_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/ConfigurationView.h b/base/poco/Util/include/Poco/Util/ConfigurationView.h
new file mode 100644
index 00000000000..10f8948747d
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/ConfigurationView.h
@@ -0,0 +1,82 @@
+//
+// ConfigurationView.h
+//
+// Library: Util
+// Package: Configuration
+// Module:  ConfigurationView
+//
+// Definition of the ConfigurationView class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_ConfigurationView_INCLUDED
+#define Util_ConfigurationView_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Util/AbstractConfiguration.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API ConfigurationView: public AbstractConfiguration
+	/// This configuration implements a "view" into a sub-hierarchy 
+	/// of another configuration.
+	/// 
+	/// For example, given a configuration with the following properties:
+	///     config.value1
+	///     config.value2
+	///     config.sub.value1
+	///     config.sub.value2
+	/// and a ConfigurationView with the prefix "config", then
+	/// the above properties will be available via the view as
+	///     value1
+	///     value2
+	///     sub.value1
+	///     sub.value2
+	///
+	/// A ConfigurationView is most useful in combination with a
+	/// LayeredConfiguration.
+	///
+	/// If a property is not found in the view, it is searched in
+	/// the original configuration. Given the above example configuration,
+	/// the property named "config.value1" will still be found in the view.
+	///
+	/// The main reason for this is that placeholder expansion (${property})
+	/// still works as expected given a ConfigurationView.
+{
+public:
+	ConfigurationView(const std::string& prefix, AbstractConfiguration* pConfig);
+		/// Creates the ConfigurationView. The ConfigurationView does not take
+		/// ownership of the passed configuration.
+
+protected:
+	bool getRaw(const std::string& key, std::string& value) const;
+	void setRaw(const std::string& key, const std::string& value);
+	void enumerate(const std::string& key, Keys& range) const;
+	void removeRaw(const std::string& key);
+	
+	std::string translateKey(const std::string& key) const;
+	
+	~ConfigurationView();
+
+private:
+	ConfigurationView(const ConfigurationView&);
+	ConfigurationView& operator = (const ConfigurationView&);
+
+	std::string _prefix;
+	AbstractConfiguration* _pConfig;
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_ConfigurationView_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/FilesystemConfiguration.h b/base/poco/Util/include/Poco/Util/FilesystemConfiguration.h
new file mode 100644
index 00000000000..d0a17189828
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/FilesystemConfiguration.h
@@ -0,0 +1,93 @@
+//
+// FilesystemConfiguration.h
+//
+// Library: Util
+// Package: Configuration
+// Module:  FilesystemConfiguration
+//
+// Definition of the FilesystemConfiguration class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_FilesystemConfiguration_INCLUDED
+#define Util_FilesystemConfiguration_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Util/AbstractConfiguration.h"
+#include "Poco/Path.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API FilesystemConfiguration: public AbstractConfiguration
+	/// An implementation of AbstractConfiguration that stores configuration data
+	/// in a directory hierarchy in the filesystem.
+	///
+	/// Every period-separated part of a property name is represented
+	/// as a directory in the filesystem, relative to the base directory.
+	/// Values are stored in files named "data".
+	///
+	/// All changes to properties are immediately persisted in the filesystem.
+	///
+	/// For example, a configuration consisting of the properties
+	/// 
+	///   logging.loggers.root.channel.class = ConsoleChannel
+	///   logging.loggers.app.name = Application
+	///   logging.loggers.app.channel = c1
+	///   logging.formatters.f1.class = PatternFormatter
+	///   logging.formatters.f1.pattern = [%p] %t
+	///
+	/// is stored in the filesystem as follows:
+	///
+	///   logging/
+	///           loggers/
+	///                   root/
+	///                        channel/
+	///                                class/
+	///                                      data ("ConsoleChannel")
+	///                   app/
+	///                       name/
+	///                            data ("Application")
+	///                       channel/
+	///                               data ("c1")
+	///           formatters/
+	///                      f1/
+	///                         class/
+	///                               data ("PatternFormatter")
+	///                         pattern/
+	///                                 data ("[%p] %t")                      
+{
+public:
+	FilesystemConfiguration(const std::string& path);
+		/// Creates a FilesystemConfiguration using the given path.
+		/// All directories are created as necessary.
+
+	void clear();
+		/// Clears the configuration by erasing the configuration
+		/// directory and all its subdirectories and files.
+
+protected:
+	bool getRaw(const std::string& key, std::string& value) const;
+	void setRaw(const std::string& key, const std::string& value);
+	void enumerate(const std::string& key, Keys& range) const;
+	void removeRaw(const std::string& key);
+	Poco::Path keyToPath(const std::string& key) const;
+	~FilesystemConfiguration();
+
+private:
+	Poco::Path _path;
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_FilesystemConfiguration_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/HelpFormatter.h b/base/poco/Util/include/Poco/Util/HelpFormatter.h
new file mode 100644
index 00000000000..3d79ec01110
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/HelpFormatter.h
@@ -0,0 +1,202 @@
+//
+// HelpFormatter.h
+//
+// Library: Util
+// Package: Options
+// Module:  HelpFormatter
+//
+// Definition of the HelpFormatter class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_HelpFormatter_INCLUDED
+#define Util_HelpFormatter_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include <ostream>
+
+
+namespace Poco {
+namespace Util {
+
+
+class OptionSet;
+class Option;
+
+
+class Util_API HelpFormatter
+	/// This class formats a help message from an OptionSet.
+{
+public:
+	HelpFormatter(const OptionSet& options);
+		/// Creates the HelpFormatter, using the given
+		/// options. 
+		///
+		/// The HelpFormatter just stores a reference
+		/// to the given OptionSet, so the OptionSet must not
+		/// be destroyed during the lifetime of the HelpFormatter.
+
+	~HelpFormatter();
+		/// Destroys the HelpFormatter.
+
+	void setCommand(const std::string& command);
+		/// Sets the command name.
+		
+	const std::string& getCommand() const;
+		/// Returns the command name.
+		
+	void setUsage(const std::string& usage);
+		/// Sets the usage string.
+		
+	const std::string& getUsage() const;
+		/// Returns the usage string.
+		
+	void setHeader(const std::string& header);
+		/// Sets the header string.
+		
+	const std::string& getHeader() const;
+		/// Returns the header string.
+		
+	void setFooter(const std::string& footer);
+		/// Sets the footer string.
+		
+	const std::string& getFooter() const;
+		/// Returns the footer string.
+
+	void format(std::ostream& ostr) const;
+		/// Writes the formatted help text to the given stream.
+	
+	void setWidth(int width);
+		/// Sets the line width for the formatted help text.
+		
+	int getWidth() const;
+		/// Returns the line width for the formatted help text.
+		///
+		/// The default width is 72.
+
+	void setIndent(int indent);
+		/// Sets the indentation for description continuation lines.
+
+	int getIndent() const;
+		/// Returns the indentation for description continuation lines.
+		
+	void setAutoIndent();
+		/// Sets the indentation for description continuation lines so that
+		/// the description text is left-aligned. 
+
+	void setUnixStyle(bool flag);
+		/// Enables Unix-style options. Both short and long option names
+		/// are printed if Unix-style is set. Otherwise, only long option
+		/// names are printed.
+		///
+		/// After calling setUnixStyle(), setAutoIndent() should be called
+		/// as well to ensure proper help text formatting.
+		
+	bool isUnixStyle() const;
+		/// Returns if Unix-style options are set.
+
+	std::string shortPrefix() const;
+		/// Returns the platform-specific prefix for short options.
+		/// "-" on Unix, "/" on Windows and OpenVMS.
+	
+	std::string longPrefix() const;
+		/// Returns the platform-specific prefix for long options.
+		/// "--" on Unix, "/" on Windows and OpenVMS.
+
+protected:
+	int calcIndent() const;
+		/// Calculates the indentation for the option descriptions
+		/// from the given options.
+
+	void formatOptions(std::ostream& ostr) const;
+		/// Formats all options.
+
+	void formatOption(std::ostream& ostr, const Option& option, int width) const;
+		/// Formats an option, using the platform-specific
+		/// prefixes.
+
+	void formatText(std::ostream& ostr, const std::string& text, int indent) const;
+		/// Formats the given text.
+
+	void formatText(std::ostream& ostr, const std::string& text, int indent, int firstIndent) const;
+		/// Formats the given text.
+
+	void formatWord(std::ostream& ostr, int& pos, const std::string& word, int indent) const;
+		/// Formats the given word.
+	
+	void clearWord(std::ostream& ostr, int& pos, std::string& word, int indent) const;
+		/// Formats and then clears the given word.
+	
+private:
+	HelpFormatter(const HelpFormatter&);
+	HelpFormatter& operator = (const HelpFormatter&);
+
+	const OptionSet& _options;
+	int _width;
+	int _indent;
+	std::string _command;
+	std::string _usage;
+	std::string _header;
+	std::string _footer;
+	bool _unixStyle;
+	
+	static const int TAB_WIDTH;
+	static const int LINE_WIDTH;
+};
+
+
+//
+// inlines
+//
+inline int HelpFormatter::getWidth() const
+{
+	return _width;
+}
+
+
+inline int HelpFormatter::getIndent() const
+{
+	return _indent;
+}
+
+
+inline const std::string& HelpFormatter::getCommand() const
+{
+	return _command;
+}
+
+
+inline const std::string& HelpFormatter::getUsage() const
+{
+	return _usage;
+}
+
+
+inline const std::string& HelpFormatter::getHeader() const
+{
+	return _header;
+}
+
+
+inline const std::string& HelpFormatter::getFooter() const
+{
+	return _footer;
+}
+
+
+inline bool HelpFormatter::isUnixStyle() const
+{
+	return _unixStyle;
+}
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_HelpFormatter_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/IniFileConfiguration.h b/base/poco/Util/include/Poco/Util/IniFileConfiguration.h
new file mode 100644
index 00000000000..94ea5da333e
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/IniFileConfiguration.h
@@ -0,0 +1,99 @@
+//
+// IniFileConfiguration.h
+//
+// Library: Util
+// Package: Configuration
+// Module:  IniFileConfiguration
+//
+// Definition of the IniFileConfiguration class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_IniFileConfiguration_INCLUDED
+#define Util_IniFileConfiguration_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+
+
+#ifndef POCO_UTIL_NO_INIFILECONFIGURATION
+
+
+#include "Poco/Util/AbstractConfiguration.h"
+#include <map>
+#include <istream>
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API IniFileConfiguration: public AbstractConfiguration
+	/// This implementation of a Configuration reads properties
+	/// from a legacy Windows initialization (.ini) file.
+	///
+	/// The file syntax is implemented as follows.
+	///   - a line starting with a semicolon is treated as a comment and ignored
+	///   - a line starting with a square bracket denotes a section key [<key>]
+	///   - every other line denotes a property assignment in the form
+	///     <value key> = <value>
+	///
+	/// The name of a property is composed of the section key and the value key,
+	/// separated by a period (<section key>.<value key>).
+	///
+	/// Property names are not case sensitive. Leading and trailing whitespace is
+	/// removed from both keys and values.
+{
+public:
+	IniFileConfiguration();
+		/// Creates an empty IniFileConfiguration.
+
+	IniFileConfiguration(std::istream& istr);
+		/// Creates an IniFileConfiguration and loads the configuration data
+		/// from the given stream, which must be in initialization file format.
+		
+	IniFileConfiguration(const std::string& path);
+		/// Creates an IniFileConfiguration and loads the configuration data
+		/// from the given file, which must be in initialization file format.
+		
+	void load(std::istream& istr);
+		/// Loads the configuration data from the given stream, which 
+		/// must be in initialization file format.
+		
+	void load(const std::string& path);
+		/// Loads the configuration data from the given file, which 
+		/// must be in initialization file format.
+
+protected:
+	bool getRaw(const std::string& key, std::string& value) const;
+	void setRaw(const std::string& key, const std::string& value);
+	void enumerate(const std::string& key, Keys& range) const;
+	void removeRaw(const std::string& key);
+	~IniFileConfiguration();
+
+private:
+	void parseLine(std::istream& istr);
+
+	struct ICompare
+	{
+		bool operator () (const std::string& s1, const std::string& s2) const;
+	};
+	typedef std::map<std::string, std::string, ICompare> IStringMap;
+	
+	IStringMap _map;
+	std::string _sectionKey;
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // POCO_UTIL_NO_INIFILECONFIGURATION
+
+
+#endif // Util_IniFileConfiguration_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/IntValidator.h b/base/poco/Util/include/Poco/Util/IntValidator.h
new file mode 100644
index 00000000000..10e15f83f3c
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/IntValidator.h
@@ -0,0 +1,56 @@
+//
+// IntValidator.h
+//
+// Library: Util
+// Package: Options
+// Module:  IntValidator
+//
+// Definition of the IntValidator class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_IntValidator_INCLUDED
+#define Util_IntValidator_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Util/Validator.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API IntValidator: public Validator
+	/// The IntValidator tests whether the option argument,
+	/// which must be an integer, lies within a given range.
+{
+public:
+	IntValidator(int min, int max);
+		/// Creates the IntValidator.
+
+	~IntValidator();
+		/// Destroys the IntValidator.
+
+	void validate(const Option& option, const std::string& value);
+		/// Validates the value for the given option by
+		/// testing whether it's an integer that lies within
+		/// a given range.
+
+private:
+	IntValidator();
+
+	int _min;
+	int _max;
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_IntValidator_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/JSONConfiguration.h b/base/poco/Util/include/Poco/Util/JSONConfiguration.h
new file mode 100644
index 00000000000..d1fa53ece9a
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/JSONConfiguration.h
@@ -0,0 +1,150 @@
+//
+// JSONConfiguration.h
+//
+// Library: Util
+// Package: Util
+// Module:  JSONConfiguration
+//
+// Definition of the JSONConfiguration class.
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_JSONConfiguration_INCLUDED
+#define Util_JSONConfiguration_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+
+
+#ifndef POCO_UTIL_NO_JSONCONFIGURATION
+
+
+#include "Poco/Util/AbstractConfiguration.h"
+#include "Poco/JSON/Object.h"
+#include <istream>
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API JSONConfiguration : public AbstractConfiguration
+	/// This configuration class extracts configuration properties
+	/// from a JSON object. An XPath-like syntax for property
+	/// names is supported to allow full access to the JSON object.
+	///
+	/// Given the following JSON object as an example:
+	/// {
+	///   "config" : {
+	///      "prop1" : "value1",
+	///      "prop2" : 10,
+	///      "prop3" : [
+	///        "element1",
+	///        "element2"
+	///      ],
+	///      "prop4" : {
+	///        "prop5" : false,
+	///        "prop6" : null
+	///      }
+	///   }
+	/// }
+	///	The following property names would be valid and would
+	/// yield the shown values:
+	///
+	/// config.prop1       --> "value1"
+	/// config.prop3[1]    --> "element2"
+	/// config.prop4.prop5 --> false
+{
+public:
+
+	JSONConfiguration();
+		/// Creates an empty configuration
+
+
+	JSONConfiguration(const std::string& path);
+		/// Creates a configuration and loads the JSON structure from the given file
+
+
+	JSONConfiguration(std::istream& istr);
+		/// Creates a configuration and loads the JSON structure from the given stream
+
+
+	JSONConfiguration(const JSON::Object::Ptr& object);
+		/// Creates a configuration from the given JSON object
+
+
+	virtual ~JSONConfiguration();
+		/// Destructor
+
+
+	void load(const std::string& path);
+		/// Loads the configuration from the given file
+
+
+	void load(std::istream& istr);
+		/// Loads the configuration from the given stream
+
+
+	void loadEmpty(const std::string& root);
+		/// Loads an empty object containing only a root object with the given name.
+
+
+	void save(std::ostream& ostr, unsigned int indent = 2) const;
+		/// Saves the configuration to the given stream
+
+
+	virtual void setInt(const std::string& key, int value);
+
+
+	virtual void setBool(const std::string& key, bool value);
+
+
+	virtual void setDouble(const std::string& key, double value);
+
+
+	virtual void setString(const std::string& key, const std::string& value);
+	
+
+	virtual void removeRaw(const std::string& key);	
+	
+
+protected:
+
+	bool getRaw(const std::string & key, std::string & value) const;
+
+
+	void setRaw(const std::string& key, const std::string& value);
+
+
+	void enumerate(const std::string& key, Keys& range) const;
+
+
+private:
+
+
+	JSON::Object::Ptr findStart(const std::string& key, std::string& lastPart);
+
+
+	void getIndexes(std::string& name, std::vector<int>& indexes);
+
+
+	void setValue(const std::string& key, const Poco::DynamicAny& value);
+
+
+ 	JSON::Object::Ptr _object;
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // POCO_UTIL_NO_JSONCONFIGURATION
+
+
+#endif // Util_JSONConfiguration_INCLUDED
+
diff --git a/base/poco/Util/include/Poco/Util/LayeredConfiguration.h b/base/poco/Util/include/Poco/Util/LayeredConfiguration.h
new file mode 100644
index 00000000000..59628b36b12
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/LayeredConfiguration.h
@@ -0,0 +1,184 @@
+//
+// LayeredConfiguration.h
+//
+// Library: Util
+// Package: Configuration
+// Module:  LayeredConfiguration
+//
+// Definition of the LayeredConfiguration class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_LayeredConfiguration_INCLUDED
+#define Util_LayeredConfiguration_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Util/AbstractConfiguration.h"
+#include "Poco/AutoPtr.h"
+#include <list>
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API LayeredConfiguration: public AbstractConfiguration
+	/// A LayeredConfiguration consists of a number of AbstractConfigurations.
+	///
+	/// When reading a configuration property in a LayeredConfiguration,
+	/// all added configurations are searched, in order of their priority.
+	/// Configurations with lower priority values have precedence.
+	///
+	/// When setting a property, the property is always written to the first writeable 
+	/// configuration (see addWriteable()). 
+	/// If no writeable configuration has been added to the LayeredConfiguration, and an
+	/// attempt is made to set a property, a RuntimeException is thrown.
+	///
+	/// Every configuration added to the LayeredConfiguration has a priority value.
+	/// The priority determines the position where the configuration is inserted,
+	/// with lower priority values coming before higher priority values.
+	///
+	/// If no priority is specified, a priority of 0 is assumed.
+{
+public:
+	typedef Poco::AutoPtr<AbstractConfiguration> ConfigPtr;
+
+	LayeredConfiguration();
+		/// Creates the LayeredConfiguration.
+		
+	void add(AbstractConfiguration* pConfig);
+		/// Adds a read-only configuration to the back of the LayeredConfiguration.
+		/// The LayeredConfiguration does not take ownership of the given
+		/// configuration. In other words, the configuration's reference
+		/// count is incremented.
+
+	void add(AbstractConfiguration* pConfig, const std::string& label);
+		/// Adds a read-only configuration with the given label to the back of the LayeredConfiguration.
+		/// The LayeredConfiguration does not take ownership of the given
+		/// configuration. In other words, the configuration's reference
+		/// count is incremented.
+
+	void add(AbstractConfiguration* pConfig, bool shared);
+		/// Adds a read-only configuration to the back of the LayeredConfiguration.
+		/// If shared is false, the LayeredConfiguration takes ownership
+		/// of the given configuration (and the configuration's reference
+		/// count remains unchanged).
+
+	void add(AbstractConfiguration* pConfig, const std::string& label, bool shared);
+		/// Adds a read-only configuration with the given label to the back of the LayeredConfiguration.
+		/// If shared is false, the LayeredConfiguration takes ownership
+		/// of the given configuration (and the configuration's reference
+		/// count remains unchanged).
+
+	void add(AbstractConfiguration* pConfig, int priority);
+		/// Adds a read-only configuration to the LayeredConfiguration.
+		/// The LayeredConfiguration does not take ownership of the given
+		/// configuration. In other words, the configuration's reference
+		/// count is incremented.
+
+	void add(AbstractConfiguration* pConfig, const std::string& label, int priority);
+		/// Adds a read-only configuration with the given label to the LayeredConfiguration.
+		/// The LayeredConfiguration does not take ownership of the given
+		/// configuration. In other words, the configuration's reference
+		/// count is incremented.
+
+	void add(AbstractConfiguration* pConfig, int priority, bool shared);
+		/// Adds a read-only configuration the LayeredConfiguration.
+		/// If shared is false, the LayeredConfiguration takes ownership
+		/// of the given configuration (and the configuration's reference
+		/// count remains unchanged).
+
+	void add(AbstractConfiguration* pConfig, const std::string& label, int priority, bool shared);
+		/// Adds a read-only configuration with the given label the LayeredConfiguration.
+		/// If shared is false, the LayeredConfiguration takes ownership
+		/// of the given configuration (and the configuration's reference
+		/// count remains unchanged).
+
+	void add(AbstractConfiguration* pConfig, int priority, bool writeable, bool shared);
+		/// Adds a configuration to the LayeredConfiguration.
+		/// If shared is false, the LayeredConfiguration takes ownership
+		/// of the given configuration (and the configuration's reference
+		/// count remains unchanged).
+
+	void add(AbstractConfiguration* pConfig, const std::string& label, int priority, bool writeable, bool shared);
+		/// Adds a configuration with the given label to the LayeredConfiguration.
+		/// If shared is false, the LayeredConfiguration takes ownership
+		/// of the given configuration (and the configuration's reference
+		/// count remains unchanged).
+
+	void addWriteable(AbstractConfiguration* pConfig, int priority);
+		/// Adds a writeable configuration to the LayeredConfiguration.
+		/// The LayeredConfiguration does not take ownership of the given
+		/// configuration. In other words, the configuration's reference
+		/// count is incremented.
+
+	void addWriteable(AbstractConfiguration* pConfig, int priority, bool shared);
+		/// Adds a writeable configuration to the LayeredConfiguration.
+		/// If shared is false, the LayeredConfiguration takes ownership
+		/// of the given configuration (and the configuration's reference
+		/// count remains unchanged).
+		
+	ConfigPtr find(const std::string& label) const;
+		/// Finds and returns the configuration with the given label.
+		///
+		/// Returns null if no such configuration can be found.
+
+	//@ deprecated
+	void addFront(AbstractConfiguration* pConfig);
+		/// Adds a read-only configuration to the front of the LayeredConfiguration.
+		/// The LayeredConfiguration does not take ownership of the given
+		/// configuration. In other words, the configuration's reference
+		/// count is incremented.
+
+	//@ deprecated
+	void addFront(AbstractConfiguration* pConfig, bool shared);
+		/// Adds a read-only configuration to the front of the LayeredConfiguration.
+		/// If shared is true, the LayeredConfiguration takes ownership
+		/// of the given configuration.
+		
+	void removeConfiguration(AbstractConfiguration* pConfig);
+		/// Removes the given configuration from the LayeredConfiguration.
+		///
+		/// Does nothing if the given configuration is not part of the
+		/// LayeredConfiguration.
+		
+protected:	
+	struct ConfigItem
+	{
+		ConfigPtr   pConfig;
+		int         priority;
+		bool        writeable;
+		std::string label;
+	};
+
+	bool getRaw(const std::string& key, std::string& value) const;
+	void setRaw(const std::string& key, const std::string& value);
+	void enumerate(const std::string& key, Keys& range) const;
+	void removeRaw(const std::string& key);
+	
+	int lowest() const;
+	int highest() const;
+	void insert(const ConfigItem& item);
+	
+	~LayeredConfiguration();
+
+private:
+	LayeredConfiguration(const LayeredConfiguration&);
+	LayeredConfiguration& operator = (const LayeredConfiguration&);
+
+	typedef std::list<ConfigItem> ConfigList;
+	
+	ConfigList _configs;
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_LayeredConfiguration_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/LoggingConfigurator.h b/base/poco/Util/include/Poco/Util/LoggingConfigurator.h
new file mode 100644
index 00000000000..e5ed99aab47
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/LoggingConfigurator.h
@@ -0,0 +1,139 @@
+//
+// LoggingConfigurator.h
+//
+// Library: Util
+// Package: Configuration
+// Module:  LoggingConfigurator
+//
+// Definition of the LoggingConfigurator class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_LoggingConfigurator_INCLUDED
+#define Util_LoggingConfigurator_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Formatter.h"
+#include "Poco/Channel.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+class AbstractConfiguration;
+
+
+class Util_API LoggingConfigurator
+	/// This utility class uses a configuration object to configure the
+	/// logging subsystem of an application.
+	///
+	/// The LoggingConfigurator sets up and connects formatters, channels 
+	/// and loggers. To accomplish its work, the LoggingConfigurator relies on the
+	/// functionality provided by the LoggingFactory and LoggingRegistry classes.
+	///
+	/// The LoggingConfigurator expects all configuration data to be under a root
+	/// property named "logging".
+	/// 
+	/// Configuring Formatters
+	///
+	/// A formatter is configured using the "logging.formatters" property. Every 
+	/// formatter has an internal name, which is only used for referring to it 
+	/// during configuration time. This name becomes part of the property name.
+	/// Every formatter has a mandatory "class" property, which specifies the actual
+	/// class implementing the formatter. Any other properties are passed on to
+	/// the formatter by calling its setProperty() method.
+	///
+	/// A typical formatter definition looks as follows:
+	///     logging.formatters.f1.class = PatternFormatter
+	///     logging.formatters.f1.pattern = %s: [%p] %t
+	///     logging.formatters.f1.times = UTC
+	///
+	/// Configuring Channels
+	///
+	/// A channel is configured using the "logging.channels" property. Like with
+	/// Formatters, every channel has an internal name, which is used during
+	/// configuration only. The name becomes part of the property name.
+	/// Every channel has a mandatory "class" property, which specifies the actual
+	/// class implementing the channel. Any other properties are passed on to
+	/// the formatter by calling its setProperty() method.
+	///
+	/// For convenience, the "formatter" property of a channel is treated
+	/// specifically. The "formatter" property can either be used to refer to
+	/// an already defined formatter, or it can be used to specify an "inline"
+	/// formatter definition. In either case, when a "formatter" property is
+	/// present, the channel is automatically "wrapped" in a FormattingChannel
+	/// object.
+	/// 
+	/// Similarly, a channel supports also a "pattern" property, which results
+	/// in the automatic instantiation of a FormattingChannel object with a
+	/// connected PatternFormatter.
+	/// 
+	/// Examples:
+	///     logging.channels.c1.class = ConsoleChannel
+	///     logging.channels.c1.formatter = f1
+	///     logging.channels.c2.class = FileChannel
+	///     logging.channels.c2.path = ${system.tempDir}/sample.log
+	///     logging.channels.c2.formatter.class = PatternFormatter
+	///     logging.channels.c2.formatter.pattern = %s: [%p] %t
+	///     logging.channels.c3.class = ConsoleChannel
+	///     logging.channels.c3.pattern = %s: [%p] %t
+	///
+	/// Configuring Loggers
+	///
+	/// A logger is configured using the "logging.loggers" property. Like with
+	/// channels and formatters, every logger has an internal name, which, however,
+	/// is only used to ensure the uniqueness of the property names. Note that this
+	/// name is different from the logger's full name, which is used to access
+	/// the logger at runtime.
+	/// Every logger except the root logger has a mandatory "name" property which
+	/// is used to specify the logger's full name.
+	/// Furthermore, a "channel" property is supported, which can either refer
+	/// to a named channel, or which can contain an inline channel definition.
+	///
+	/// Examples:
+	///     logging.loggers.root.channel = c1
+	///     logging.loggers.root.level = warning
+	///     logging.loggers.l1.name = logger1
+	///     logging.loggers.l1.channel.class = ConsoleChannel
+	///     logging.loggers.l1.channel.pattern = %s: [%p] %t
+	///     logging.loggers.l1.level = information
+{
+public:
+	LoggingConfigurator();
+		/// Creates the LoggingConfigurator.
+
+	~LoggingConfigurator();
+		/// Destroys the LoggingConfigurator.
+		
+	void configure(AbstractConfiguration* pConfig);
+		/// Configures the logging subsystem based on
+		/// the given configuration.
+		///
+		/// A ConfigurationView can be used to pass only
+		/// a part of a larger configuration.
+
+private:
+	void configureFormatters(AbstractConfiguration* pConfig);
+	void configureChannels(AbstractConfiguration* pConfig);
+	void configureLoggers(AbstractConfiguration* pConfig);
+	Poco::Formatter* createFormatter(AbstractConfiguration* pConfig);
+	Poco::Channel* createChannel(AbstractConfiguration* pConfig);
+	void configureChannel(Channel* pChannel, AbstractConfiguration* pConfig);
+	void configureLogger(AbstractConfiguration* pConfig);
+	
+	LoggingConfigurator(const LoggingConfigurator&);
+	LoggingConfigurator& operator = (const LoggingConfigurator&);
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_LoggingConfigurator_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/LoggingSubsystem.h b/base/poco/Util/include/Poco/Util/LoggingSubsystem.h
new file mode 100644
index 00000000000..53e8c9a8b06
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/LoggingSubsystem.h
@@ -0,0 +1,52 @@
+//
+// LoggingSubsystem.h
+//
+// Library: Util
+// Package: Application
+// Module:  LoggingSubsystem
+//
+// Definition of the LoggingSubsystem class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_LoggingSubsystem_INCLUDED
+#define Util_LoggingSubsystem_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Util/Subsystem.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API LoggingSubsystem: public Subsystem
+	/// The LoggingSubsystem class initializes the logging
+	/// framework using the LoggingConfigurator.
+	///
+	/// It also sets the Application's logger to
+	/// the logger specified by the "application.logger"
+	/// property, or to "Application" if the property
+	/// is not specified.
+{
+public:
+	LoggingSubsystem();
+	const char* name() const;
+	
+protected:
+	void initialize(Application& self);
+	void uninitialize();
+	~LoggingSubsystem();
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_LoggingSubsystem_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/MapConfiguration.h b/base/poco/Util/include/Poco/Util/MapConfiguration.h
new file mode 100644
index 00000000000..ac725cd152b
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/MapConfiguration.h
@@ -0,0 +1,64 @@
+//
+// MapConfiguration.h
+//
+// Library: Util
+// Package: Configuration
+// Module:  MapConfiguration
+//
+// Definition of the MapConfiguration class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_MapConfiguration_INCLUDED
+#define Util_MapConfiguration_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Util/AbstractConfiguration.h"
+#include <map>
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API MapConfiguration: public AbstractConfiguration
+	/// An implementation of AbstractConfiguration that stores configuration data in a map.
+{
+public:
+	MapConfiguration();
+		/// Creates an empty MapConfiguration.
+
+	void copyTo(AbstractConfiguration& config);
+		/// Copies all configuration properties to the given configuration.
+
+	void clear();
+		/// Clears the configuration.
+
+protected:
+	typedef std::map<std::string, std::string> StringMap;
+	typedef StringMap::const_iterator iterator;
+
+	bool getRaw(const std::string& key, std::string& value) const;
+	void setRaw(const std::string& key, const std::string& value);
+	void enumerate(const std::string& key, Keys& range) const;
+	void removeRaw(const std::string& key);
+	~MapConfiguration();
+
+	iterator begin() const;
+	iterator end() const;
+
+private:	
+	StringMap _map;
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_MapConfiguration_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/Option.h b/base/poco/Util/include/Poco/Util/Option.h
new file mode 100644
index 00000000000..051f7c0094a
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/Option.h
@@ -0,0 +1,332 @@
+//
+// Option.h
+//
+// Library: Util
+// Package: Options
+// Module:  Option
+//
+// Definition of the Option class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_Option_INCLUDED
+#define Util_Option_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Util/OptionCallback.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+class Application;
+class Validator;
+class AbstractConfiguration;
+
+
+class Util_API Option
+	/// This class represents and stores the properties
+	/// of a command line option.
+	///
+	/// An option has a full name, an optional short name,
+	/// a description (used for printing a usage statement),
+	/// and an optional argument name.
+	/// An option can be optional or required.
+	/// An option can be repeatable, which means that it can
+	/// be given more than once on the command line.
+	///
+	/// An option can be part of an option group. At most one
+	/// option of each group may be specified on the command
+	/// line.
+	///
+	/// An option can be bound to a configuration property.
+	/// In this case, a configuration property will automatically
+	/// receive the option's argument value.
+	///
+	/// A callback method can be specified for options. This method
+	/// is called whenever an option is specified on the command line.
+	///
+	/// Option argument values can be automatically validated using a
+	/// Validator.
+	///
+	/// Option instances are value objects.
+	///
+	/// Typically, after construction, an Option object is immediately
+	/// passed to an Options object.
+	///
+	/// An Option object can be created by chaining the constructor
+	/// with any of the setter methods, as in the following example:
+	///
+	///     Option versionOpt("include", "I", "specify an include directory")
+	///        .required(false)
+	///        .repeatable(true)
+	///        .argument("directory");
+{
+public:
+	Option();
+		/// Creates an empty Option.
+
+	Option(const Option& option);
+		/// Creates an option from another one.
+
+	Option(const std::string& fullName, const std::string& shortName);
+		/// Creates an option with the given properties.
+
+	Option(const std::string& fullName, const std::string& shortName, const std::string& description, bool required = false);
+		/// Creates an option with the given properties.
+
+	Option(const std::string& fullName, const std::string& shortName, const std::string& description, bool required, const std::string& argName, bool argRequired = false);
+		/// Creates an option with the given properties.
+
+	~Option();
+		/// Destroys the Option.
+
+	Option& operator = (const Option& option);
+		/// Assignment operator.
+		
+	void swap(Option& option);
+		/// Swaps the option with another one.
+
+	Option& shortName(const std::string& name);
+		/// Sets the short name of the option.
+		
+	Option& fullName(const std::string& name);
+		/// Sets the full name of the option.
+		
+	Option& description(const std::string& text);
+		/// Sets the description of the option.
+		
+	Option& required(bool flag);
+		/// Sets whether the option is required (flag == true)
+		/// or optional (flag == false).
+
+	Option& repeatable(bool flag);
+		/// Sets whether the option can be specified more than once
+		/// (flag == true) or at most once (flag == false).
+		
+	Option& argument(const std::string& name, bool required = true);
+		/// Specifies that the option takes an (optional or required)
+		/// argument.
+		
+	Option& noArgument();
+		/// Specifies that the option does not take an argument (default).
+
+	Option& group(const std::string& group);
+		/// Specifies the option group the option is part of.
+		
+	Option& binding(const std::string& propertyName);
+		/// Binds the option to the configuration property with the given name.
+		///
+		/// The configuration will automatically receive the option's argument.
+
+	Option& binding(const std::string& propertyName, AbstractConfiguration* pConfig);
+		/// Binds the option to the configuration property with the given name, 
+		/// using the given AbstractConfiguration.
+		///
+		/// The configuration will automatically receive the option's argument.
+		
+	Option& callback(const AbstractOptionCallback& cb);
+		/// Binds the option to the given method.
+		///
+		/// The callback method will be called when the option
+		/// has been specified on the command line.
+		///
+		/// Usage:
+		///     callback(OptionCallback<MyApplication>(this, &MyApplication::myCallback));
+
+	Option& validator(Validator* pValidator);
+		/// Sets the validator for the given option.
+		///
+		/// The Option takes ownership of the Validator and
+		/// deletes it when it's no longer needed.
+
+	const std::string& shortName() const;
+		/// Returns the short name of the option.
+		
+	const std::string& fullName() const;
+		/// Returns the full name of the option.
+		
+	const std::string& description() const;
+		/// Returns the description of the option.
+		
+	bool required() const;
+		/// Returns true if the option is required, false if not.
+	
+	bool repeatable() const;
+		/// Returns true if the option can be specified more than
+		/// once, or false if at most once.
+	
+	bool takesArgument() const;
+		/// Returns true if the options takes an (optional) argument.
+		
+	bool argumentRequired() const;
+		/// Returns true if the argument is required.
+
+	const std::string& argumentName() const;
+		/// Returns the argument name, if specified.
+		
+	const std::string& group() const;
+		/// Returns the option group the option is part of,
+		/// or an empty string, if the option is not part of
+		/// a group.
+		
+	const std::string& binding() const;
+		/// Returns the property name the option is bound to,
+		/// or an empty string in case it is not bound.
+		
+	AbstractOptionCallback* callback() const;
+		/// Returns a pointer to the callback method for the option,
+		/// or NULL if no callback has been specified.
+		
+	Validator* validator() const;
+		/// Returns the option's Validator, if one has been specified,
+		/// or NULL otherwise.	
+		
+	AbstractConfiguration* config() const;
+		/// Returns the configuration, if specified, or NULL otherwise.
+		
+	bool matchesShort(const std::string& option) const;
+		/// Returns true if the given option string matches the
+		/// short name.
+		///
+		/// The first characters of the option string must match
+		/// the short name of the option (case sensitive),
+		/// or the option string must partially match the full
+		/// name (case insensitive).
+
+	bool matchesFull(const std::string& option) const;
+		/// Returns true if the given option string matches the
+		/// full name.
+		///
+		/// The option string must match the full
+		/// name (case insensitive).
+
+	bool matchesPartial(const std::string& option) const;
+		/// Returns true if the given option string partially matches the
+		/// full name.
+		///
+		/// The option string must partially match the full
+		/// name (case insensitive).
+		
+	void process(const std::string& option, std::string& arg) const;
+		/// Verifies that the given option string matches the
+		/// requirements of the option, and extracts the option argument,
+		/// if present.
+		///
+		/// If the option string is okay and carries an argument,
+		/// the argument is returned in arg.
+		///
+		/// Throws a MissingArgumentException if a required argument
+		/// is missing. Throws an UnexpectedArgumentException if an
+		/// argument has been found, but none is expected. 
+
+private:
+	std::string _shortName;
+	std::string _fullName;
+	std::string _description;
+	bool        _required;
+	bool        _repeatable;
+	std::string _argName;
+	bool        _argRequired;
+	std::string _group;
+	std::string _binding;
+	Validator*  _pValidator;
+	AbstractOptionCallback* _pCallback;
+	AbstractConfiguration*  _pConfig;
+};
+
+
+//
+// inlines
+//
+
+
+inline const std::string& Option::shortName() const
+{
+	return _shortName;
+}
+
+	
+inline const std::string& Option::fullName() const
+{
+	return _fullName;
+}
+
+	
+inline const std::string& Option::description() const
+{
+	return _description;
+}
+
+	
+inline bool Option::required() const
+{
+	return _required;
+}
+
+
+inline bool Option::repeatable() const
+{
+	return _repeatable;
+}
+
+	
+inline bool Option::takesArgument() const
+{
+	return !_argName.empty();
+}
+
+	
+inline bool Option::argumentRequired() const
+{
+	return _argRequired;
+}
+
+
+inline const std::string& Option::argumentName() const
+{
+	return _argName;
+}
+
+
+inline const std::string& Option::group() const
+{
+	return _group;
+}
+
+
+inline const std::string& Option::binding() const
+{
+	return _binding;
+}
+
+
+inline AbstractOptionCallback* Option::callback() const
+{
+	return _pCallback;
+}
+
+
+inline Validator* Option::validator() const
+{
+	return _pValidator;
+}
+
+
+inline AbstractConfiguration* Option::config() const
+{
+	return _pConfig;
+}
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_Option_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/OptionCallback.h b/base/poco/Util/include/Poco/Util/OptionCallback.h
new file mode 100644
index 00000000000..63dd4a30e47
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/OptionCallback.h
@@ -0,0 +1,109 @@
+//
+// OptionCallback.h
+//
+// Library: Util
+// Package: Options
+// Module:  OptionCallback
+//
+// Definition of the OptionCallback class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_OptionCallback_INCLUDED
+#define Util_OptionCallback_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API AbstractOptionCallback
+	/// Base class for OptionCallback.
+{
+public:
+	virtual void invoke(const std::string& name, const std::string& value) const = 0;
+		/// Invokes the callback member function.
+		
+	virtual AbstractOptionCallback* clone() const = 0;
+		/// Creates and returns a copy of the object.
+
+	virtual ~AbstractOptionCallback();
+		/// Destroys the AbstractOptionCallback.
+
+protected:
+	AbstractOptionCallback();
+	AbstractOptionCallback(const AbstractOptionCallback&);
+};
+
+
+template <class C>
+class OptionCallback: public AbstractOptionCallback
+	/// This class is used as an argument to Option::callback().
+	///
+	/// It stores a pointer to an object and a pointer to a member
+	/// function of the object's class.
+{
+public:
+	typedef void (C::*Callback)(const std::string& name, const std::string& value);
+
+	OptionCallback(C* pObject, Callback method):
+		_pObject(pObject),
+		_method(method)
+		/// Creates the OptionCallback for the given object and member function.
+	{
+		poco_check_ptr (pObject);
+	}
+	
+	OptionCallback(const OptionCallback& cb):
+		AbstractOptionCallback(cb),
+		_pObject(cb._pObject),
+		_method(cb._method)
+		/// Creates an OptionCallback from another one.
+	{
+	}
+	
+	~OptionCallback()
+		/// Destroys the OptionCallback.
+	{
+	}
+	
+	OptionCallback& operator = (const OptionCallback& cb)
+	{
+		if (&cb != this)
+		{
+			this->_pObject = cb._pObject;
+			this->_method  = cb._method;
+		}
+		return *this;
+	}
+	
+	void invoke(const std::string& name, const std::string& value) const
+	{
+		(_pObject->*_method)(name, value);
+	}
+	
+	AbstractOptionCallback* clone() const
+	{
+		return new OptionCallback(_pObject, _method);
+	}
+	
+private:
+	OptionCallback();
+	
+	C* _pObject;
+	Callback _method;
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_OptionCallback_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/OptionException.h b/base/poco/Util/include/Poco/Util/OptionException.h
new file mode 100644
index 00000000000..35e7bff1d34
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/OptionException.h
@@ -0,0 +1,44 @@
+//
+// OptionException.h
+//
+// Library: Util
+// Package: Options
+// Module:  OptionException
+//
+// Definition of the OptionException class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_OptionException_INCLUDED
+#define Util_OptionException_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+POCO_DECLARE_EXCEPTION(Util_API, OptionException, Poco::DataException)
+POCO_DECLARE_EXCEPTION(Util_API, UnknownOptionException, OptionException)
+POCO_DECLARE_EXCEPTION(Util_API, AmbiguousOptionException, OptionException)
+POCO_DECLARE_EXCEPTION(Util_API, MissingOptionException, OptionException)
+POCO_DECLARE_EXCEPTION(Util_API, MissingArgumentException, OptionException)
+POCO_DECLARE_EXCEPTION(Util_API, InvalidArgumentException, OptionException)
+POCO_DECLARE_EXCEPTION(Util_API, UnexpectedArgumentException, OptionException)
+POCO_DECLARE_EXCEPTION(Util_API, IncompatibleOptionsException, OptionException)
+POCO_DECLARE_EXCEPTION(Util_API, DuplicateOptionException, OptionException)
+POCO_DECLARE_EXCEPTION(Util_API, EmptyOptionException, OptionException)
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_OptionException_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/OptionProcessor.h b/base/poco/Util/include/Poco/Util/OptionProcessor.h
new file mode 100644
index 00000000000..47e5eb873cb
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/OptionProcessor.h
@@ -0,0 +1,137 @@
+//
+// OptionProcessor.h
+//
+// Library: Util
+// Package: Options
+// Module:  OptionProcessor
+//
+// Definition of the OptionProcessor class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_OptionProcessor_INCLUDED
+#define Util_OptionProcessor_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include <set>
+
+
+namespace Poco {
+namespace Util {
+
+
+class OptionSet;
+
+
+class Util_API OptionProcessor
+	/// An OptionProcessor is used to process the command line
+	/// arguments of an application.
+	///
+	/// The process() method takes an argument from the command line.
+	/// If that argument starts with an option prefix, the argument
+	/// is further processed. Otherwise, the argument is ignored and
+	/// false is returned. The argument must match one of the options
+	/// given in the OptionSet that is passed to the OptionProcessor
+	/// with the constructor. If an option is part of a group, at most
+	/// one option of the group can be passed to the OptionProcessor.
+	/// Otherwise an IncompatibleOptionsException is thrown.
+	/// If the same option is given multiple times, but the option
+	/// is not repeatable, a DuplicateOptionException is thrown.
+	/// If the option is not recognized, a UnexpectedArgumentException
+	/// is thrown.
+	/// If the option requires an argument, but none is given, an
+	/// MissingArgumentException is thrown.
+	/// If no argument is expected, but one is present, a
+	/// UnexpectedArgumentException is thrown.
+	/// If a partial option name is ambiguous, an AmbiguousOptionException
+	/// is thrown.
+	///
+	/// The OptionProcessor supports two modes: Unix mode and default mode.
+	/// In Unix mode, the option prefix is a dash '-'. A dash must be followed
+	/// by a short option name, or another dash, followed by a (partial)
+	/// long option name.
+	/// In default mode, the option prefix is a slash '/', followed by 
+	/// a (partial) long option name.
+	/// If the special option '--' is encountered in Unix mode, all following
+	/// options are ignored.
+	///
+	/// Option arguments can be specified in three ways. If a Unix short option
+	/// ("-o") is given, the argument directly follows the option name, without
+	/// any delimiting character or space ("-ovalue"). In default option mode, or if a
+	/// Unix long option ("--option") is given, the option argument is 
+	/// delimited from the option name with either an equal sign ('=') or
+	/// a colon (':'), as in "--option=value" or "/option:value". Finally,
+	/// a required option argument can be specified on the command line after the
+	/// option, delimited with a space, as in "--option value" or "-o value".
+	/// The latter only works for required option arguments, not optional ones.
+{
+public:
+	OptionProcessor(const OptionSet& options);
+		/// Creates the OptionProcessor, using the given OptionSet.
+
+	~OptionProcessor();
+		/// Destroys the OptionProcessor.
+
+	void setUnixStyle(bool flag);
+		/// Enables (flag == true) or disables (flag == false) Unix-style
+		/// option processing.
+		///
+		/// If Unix-style processing is enabled, options are expected to
+		/// begin with a single or a double dash ('-' or '--', respectively).
+		/// A single dash must be followed by a short option name. A double
+		/// dash must be followed by a (partial) full option name.
+		///
+		/// If Unix-style processing is disabled, options are expected to
+		/// begin with a slash ('/'), followed by a (partial) full option name.
+
+	bool isUnixStyle() const;
+		/// Returns true iff Unix-style option processing is enabled.
+
+	bool process(const std::string& argument, std::string& optionName, std::string& optionArg);
+		/// Examines and processes the given command line argument.
+		///
+		/// If the argument begins with an option prefix, the option is processed
+		/// and true is returned. The full option name is stored in optionName and the 
+		/// option argument, if present, is stored in optionArg.
+		///
+		/// If the option does not begin with an option prefix, false is returned.
+
+	void checkRequired() const;
+		/// Checks if all required options have been processed.
+		///
+		/// Does nothing if all required options have been processed.
+		/// Throws a MissingOptionException otherwise.
+
+private:
+	bool processUnix(const std::string& argument, std::string& optionName, std::string& optionArg);
+	bool processDefault(const std::string& argument, std::string& optionName, std::string& optionArg);
+	bool processCommon(const std::string& option, bool isShort, std::string& optionName, std::string& optionArg);
+	
+	const OptionSet& _options;
+	bool _unixStyle;
+	bool _ignore;
+	std::set<std::string> _groups;
+	std::set<std::string> _specifiedOptions;
+	std::string _deferredOption;
+};
+
+
+//
+// inlines
+//
+inline bool OptionProcessor::isUnixStyle() const
+{
+	return _unixStyle;
+}
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_OptionProcessor_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/OptionSet.h b/base/poco/Util/include/Poco/Util/OptionSet.h
new file mode 100644
index 00000000000..31e36fe7db4
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/OptionSet.h
@@ -0,0 +1,88 @@
+//
+// OptionSet.h
+//
+// Library: Util
+// Package: Options
+// Module:  OptionSet
+//
+// Definition of the OptionSet class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_OptionSet_INCLUDED
+#define Util_OptionSet_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Util/Option.h"
+#include <vector>
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API OptionSet
+	/// A collection of Option objects.
+{
+public:
+	typedef std::vector<Option> OptionVec;
+	typedef OptionVec::const_iterator Iterator;
+
+	OptionSet();
+		/// Creates the OptionSet.
+
+	OptionSet(const OptionSet& options);
+		/// Creates an option set from another one.
+
+	~OptionSet();
+		/// Destroys the OptionSet.
+
+	OptionSet& operator = (const OptionSet& options);
+		/// Assignment operator.
+
+	void addOption(const Option& option);
+		/// Adds an option to the collection.
+	
+	bool hasOption(const std::string& name, bool matchShort = false) const;
+		/// Returns a true iff an option with the given name exists.
+		///
+		/// The given name can either be a fully specified short name,
+		/// or a partially specified full name. If a partial name
+		/// matches more than one full name, false is returned.
+		/// The name must either match the short or full name of an
+		/// option. Comparison case sensitive for the short name and
+		/// not case sensitive for the full name.
+		
+	const Option& getOption(const std::string& name, bool matchShort = false) const;
+		/// Returns a reference to the option with the given name.
+		///
+		/// The given name can either be a fully specified short name,
+		/// or a partially specified full name.
+		/// The name must either match the short or full name of an
+		/// option. Comparison case sensitive for the short name and
+		/// not case sensitive for the full name.
+		/// Throws a NotFoundException if no matching option has been found.
+		/// Throws an UnknownOptionException if a partial full name matches
+		/// more than one option.
+
+	Iterator begin() const;
+		/// Supports iterating over all options.
+		
+	Iterator end() const;
+		/// Supports iterating over all options.
+	
+private:	
+	OptionVec _options;
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_OptionSet_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/PropertyFileConfiguration.h b/base/poco/Util/include/Poco/Util/PropertyFileConfiguration.h
new file mode 100644
index 00000000000..bf478d9d216
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/PropertyFileConfiguration.h
@@ -0,0 +1,99 @@
+//
+// PropertyFileConfiguration.h
+//
+// Library: Util
+// Package: Configuration
+// Module:  PropertyFileConfiguration
+//
+// Definition of the PropertyFileConfiguration class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_PropertyFileConfiguration_INCLUDED
+#define Util_PropertyFileConfiguration_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Util/MapConfiguration.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API PropertyFileConfiguration: public MapConfiguration
+	/// This implementation of a Configuration reads properties
+	/// from a Java-style properties file.
+	///
+	/// The file syntax is implemented as follows.
+	///   - a line starting with a hash '#' or exclamation mark '!' is treated as a comment and ignored
+	///   - every other line denotes a property assignment in the form
+	///     <key> = <value> or
+	///     <key> : <value>
+	///
+	/// Keys and values may contain special characters represented by the following escape sequences:
+	///   - \t: tab (0x09)
+	///   - \n: line feed (0x0a)
+	///   - \r: carriage return (0x0d)
+	///   - \f: form feed (0x0c)
+	///
+	/// For every other sequence that starts with a backslash, the backslash is removed.
+	/// Therefore, the sequence \a would just yield an 'a'.
+	///
+	/// A value can spread across multiple lines if the last character in a line (the character
+	/// immediately before the carriage return or line feed character) is a single backslash.
+	///
+	/// Property names are case sensitive. Leading and trailing whitespace is
+	/// removed from both keys and values. A property name can neither contain
+	/// a colon ':' nor an equal sign '=' character.
+{
+public:
+	PropertyFileConfiguration();
+		/// Creates an empty PropertyFileConfiguration.
+
+	PropertyFileConfiguration(std::istream& istr);
+		/// Creates an PropertyFileConfiguration and loads the configuration data
+		/// from the given stream, which must be in properties file format.
+		
+	PropertyFileConfiguration(const std::string& path);
+		/// Creates an PropertyFileConfiguration and loads the configuration data
+		/// from the given file, which must be in properties file format.
+		
+	void load(std::istream& istr);
+		/// Loads the configuration data from the given stream, which 
+		/// must be in properties file format.
+		
+	void load(const std::string& path);
+		/// Loads the configuration data from the given file, which 
+		/// must be in properties file format.
+		
+	void save(std::ostream& ostr) const;
+		/// Writes the configuration data to the given stream.
+		///
+		/// The data is written as a sequence of statements in the form
+		/// <key>: <value>
+		/// separated by a newline character.
+
+	void save(const std::string& path) const;
+		/// Writes the configuration data to the given file.
+
+protected:
+	~PropertyFileConfiguration();
+	
+private:
+	void parseLine(std::istream& istr);
+	static int readChar(std::istream& istr);
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_PropertyFileConfiguration_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/RegExpValidator.h b/base/poco/Util/include/Poco/Util/RegExpValidator.h
new file mode 100644
index 00000000000..81e5d4ad942
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/RegExpValidator.h
@@ -0,0 +1,54 @@
+//
+// RegExpValidator.h
+//
+// Library: Util
+// Package: Options
+// Module:  RegExpValidator
+//
+// Definition of the RegExpValidator class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_RegExpValidator_INCLUDED
+#define Util_RegExpValidator_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Util/Validator.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API RegExpValidator: public Validator
+	/// This validator matches the option value against
+	/// a regular expression.
+{
+public:
+	RegExpValidator(const std::string& regexp);
+		/// Creates the RegExpValidator, using the given regular expression.
+
+	~RegExpValidator();
+		/// Destroys the RegExpValidator.
+
+	void validate(const Option& option, const std::string& value);
+		/// Validates the value for the given option by
+		/// matching it with the regular expression.
+
+private:
+	RegExpValidator();
+
+	std::string _regexp;	
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_RegExpValidator_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/ServerApplication.h b/base/poco/Util/include/Poco/Util/ServerApplication.h
new file mode 100644
index 00000000000..fdc314b758e
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/ServerApplication.h
@@ -0,0 +1,287 @@
+//
+// ServerApplication.h
+//
+// Library: Util
+// Package: Application
+// Module:  ServerApplication
+//
+// Definition of the ServerApplication class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_ServerApplication_INCLUDED
+#define Util_ServerApplication_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Util/Application.h"
+#include "Poco/Event.h"
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#include "Poco/NamedEvent.h"
+#endif
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API ServerApplication: public Application
+	/// A subclass of the Application class that is used
+	/// for implementing server applications.
+	///
+	/// A ServerApplication allows for the application
+	/// to run as a Windows service or as a Unix daemon
+	/// without the need to add extra code.
+	///
+	/// For a ServerApplication to work both from the command line
+	/// and as a daemon or service, a few rules must be met:
+	///   - Subsystems must be registered in the constructor.
+	///   - All non-trivial initializations must be made in the
+	///     initialize() method.
+	///   - At the end of the main() method, waitForTerminationRequest()
+	///     should be called.
+	///   - New threads must only be created in initialize() or main() or
+	///     methods called from there, but not in the application class'
+	///     constructor or in the constructor of instance variables.
+	///     The reason for this is that fork() will be called in order to
+	///     create the daemon process, and threads created prior to calling
+	///     fork() won't be taken over to the daemon process.
+	///   - The main(argc, argv) function must look as follows:
+	///
+	///   int main(int argc, char** argv)
+	///   {
+	///       MyServerApplication app;
+	///       return app.run(argc, argv);
+	///   }
+	///
+	/// The POCO_SERVER_MAIN macro can be used to implement main(argc, argv).
+	/// If POCO has been built with POCO_WIN32_UTF8, POCO_SERVER_MAIN supports
+	/// Unicode command line arguments.
+	///
+	/// On Windows platforms, an application built on top of the
+	/// ServerApplication class can be run both from the command line
+	/// or as a service.
+	///
+	/// To run an application as a Windows service, it must be registered
+	/// with the Windows Service Control Manager (SCM). To do this, the application
+	/// can be started from the command line, with the /registerService option
+	/// specified. This causes the application to register itself with the
+	/// SCM, and then exit. Similarly, an application registered as a service can
+	/// be unregistered, by specifying the /unregisterService option.
+	/// The file name of the application executable (excluding the .exe suffix)
+	/// is used as the service name. Additionally, a more user-friendly name can be
+	/// specified, using the /displayName option (e.g., /displayName="Demo Service")
+	/// and a service description can be added with the /description option.
+	/// The startup mode (automatic or manual) for the service can be specified
+	/// with the /startup option.
+	///
+	/// An application can determine whether it is running as a service by checking
+	/// for the "application.runAsService" configuration property.
+	/// 
+	///     if (config().getBool("application.runAsService", false))
+	///     {
+	///         // do service specific things
+	///     }
+	///
+	/// Note that the working directory for an application running as a service
+	/// is the Windows system directory (e.g., C:\Windows\system32). Take this
+	/// into account when working with relative filesystem paths. Also, services
+	/// run under a different user account, so an application that works when
+	/// started from the command line may fail to run as a service if it depends
+	/// on a certain environment (e.g., the PATH environment variable).
+	///
+	/// An application registered as a Windows service can be started
+	/// with the NET START <name> command and stopped with the NET STOP <name>
+	/// command. Alternatively, the Services MMC applet can be used.
+	///
+	/// On Unix platforms, an application built on top of the ServerApplication
+	/// class can be optionally run as a daemon by giving the --daemon
+	/// command line option. A daemon, when launched, immediately
+	/// forks off a background process that does the actual work. After launching
+	/// the background process, the foreground process exits.
+	/// 
+	/// After the initialization is complete, but before entering the main() method,
+	/// the current working directory for the daemon process is changed to the root
+	/// directory ("/"), as it is common practice for daemon processes. Therefore, be
+	/// careful when working with files, as relative paths may not point to where
+	/// you expect them point to.
+	///
+	/// An application can determine whether it is running as a daemon by checking
+	/// for the "application.runAsDaemon" configuration property.
+	///
+	///     if (config().getBool("application.runAsDaemon", false))
+	///     {
+	///         // do daemon specific things
+	///     }
+	///
+	/// When running as a daemon, specifying the --pidfile option (e.g.,
+	/// --pidfile=/var/run/sample.pid) may be useful to record the process ID of 
+	/// the daemon in a file. The PID file will be removed when the daemon process 
+	/// terminates (but not, if it crashes).
+{
+public:
+	ServerApplication();
+		/// Creates the ServerApplication.
+
+	~ServerApplication();
+		/// Destroys the ServerApplication.
+		
+	bool isInteractive() const;
+		/// Returns true if the application runs from the command line.
+		/// Returns false if the application runs as a Unix daemon
+		/// or Windows service.
+
+	int run(int argc, char** argv);
+		/// Runs the application by performing additional initializations
+		/// and calling the main() method.
+		
+	int run(const std::vector<std::string>& args);
+		/// Runs the application by performing additional initializations
+		/// and calling the main() method.
+
+#if defined(POCO_WIN32_UTF8) && !defined(POCO_NO_WSTRING)
+	int run(int argc, wchar_t** argv);
+		/// Runs the application by performing additional initializations
+		/// and calling the main() method.
+		///
+		/// This Windows-specific version of init is used for passing
+		/// Unicode command line arguments from wmain().
+#endif
+
+	static void terminate();
+		/// Sends a friendly termination request to the application.
+		/// If the application's main thread is waiting in 
+		/// waitForTerminationRequest(), this method will return
+		/// and the application can shut down.
+		
+protected:
+	int run();
+	virtual void waitForTerminationRequest();
+#if !defined(_WIN32_WCE)
+	void defineOptions(OptionSet& options);
+#endif
+
+private:
+#if defined(POCO_VXWORKS)
+	static Poco::Event _terminate;
+#elif defined(POCO_OS_FAMILY_UNIX)
+	void handleDaemon(const std::string& name, const std::string& value);
+	void handleUMask(const std::string& name, const std::string& value);
+	void handlePidFile(const std::string& name, const std::string& value);
+	bool isDaemon(int argc, char** argv);
+	void beDaemon();
+#if POCO_OS == POCO_OS_ANDROID
+	static Poco::Event _terminate;
+#endif
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#if !defined(_WIN32_WCE)
+	enum Action
+	{
+		SRV_RUN,
+		SRV_REGISTER,
+		SRV_UNREGISTER
+	};
+	static BOOL __stdcall ConsoleCtrlHandler(DWORD ctrlType);
+	static void __stdcall ServiceControlHandler(DWORD control);
+#if defined(POCO_WIN32_UTF8) && !defined(POCO_NO_WSTRING)
+	static void __stdcall ServiceMain(DWORD argc, LPWSTR* argv);
+#else
+	static void __stdcall ServiceMain(DWORD argc, LPTSTR* argv);
+#endif
+
+	bool hasConsole();
+	bool isService();
+	void beService();
+	void registerService();
+	void unregisterService();
+	void handleRegisterService(const std::string& name, const std::string& value);
+	void handleUnregisterService(const std::string& name, const std::string& value);
+	void handleDisplayName(const std::string& name, const std::string& value);
+	void handleDescription(const std::string& name, const std::string& value);
+	void handleStartup(const std::string& name, const std::string& value);	
+	
+	Action      _action;
+	std::string _displayName;
+	std::string _description;
+	std::string _startup;
+
+	static Poco::Event           _terminated;
+	static SERVICE_STATUS        _serviceStatus; 
+	static SERVICE_STATUS_HANDLE _serviceStatusHandle; 
+#endif // _WIN32_WCE
+	static Poco::NamedEvent      _terminate;
+#endif
+};
+
+
+} } // namespace Poco::Util
+
+
+//
+// Macro to implement main()
+//
+#if defined(_WIN32) && defined(POCO_WIN32_UTF8)
+	#define POCO_SERVER_MAIN(App) \
+	int wmain(int argc, wchar_t** argv)	\
+	{									\
+		try 							\
+		{								\
+			App app;					\
+			return app.run(argc, argv);	\
+		}								\
+		catch (Poco::Exception& exc)	\
+		{								\
+			std::cerr << exc.displayText() << std::endl;	\
+			return Poco::Util::Application::EXIT_SOFTWARE; 	\
+		}								\
+	}
+#elif defined(POCO_VXWORKS)
+	#define POCO_SERVER_MAIN(App) \
+	int pocoSrvMain(const char* appName, ...) 				\
+	{ 														\
+		std::vector<std::string> args; 						\
+		args.push_back(std::string(appName)); 				\
+		va_list vargs; 										\
+		va_start(vargs, appName); 							\
+		const char* arg = va_arg(vargs, const char*); 		\
+		while (arg) 										\
+		{ 													\
+			args.push_back(std::string(arg));				\
+			arg = va_arg(vargs, const char*); 				\
+		} 													\
+		va_end(vargs); 										\
+		try													\
+		{ 													\
+			App app;										\
+			return app.run(args); 							\
+		} 													\
+		catch (Poco::Exception& exc)						\
+		{													\
+			std::cerr << exc.displayText() << std::endl;	\
+			return Poco::Util::Application::EXIT_SOFTWARE; 	\
+		}													\
+	}
+#else
+	#define POCO_SERVER_MAIN(App) \
+	int main(int argc, char** argv)		\
+	{									\
+		try 							\
+		{								\
+			App app;					\
+			return app.run(argc, argv);	\
+		}								\
+		catch (Poco::Exception& exc)	\
+		{								\
+			std::cerr << exc.displayText() << std::endl;	\
+			return Poco::Util::Application::EXIT_SOFTWARE; 	\
+		}								\
+	}
+#endif
+
+
+#endif // Util_ServerApplication_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/Subsystem.h b/base/poco/Util/include/Poco/Util/Subsystem.h
new file mode 100644
index 00000000000..ce6eda24eb6
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/Subsystem.h
@@ -0,0 +1,98 @@
+//
+// Subsystem.h
+//
+// Library: Util
+// Package: Application
+// Module:  Subsystem
+//
+// Definition of the Subsystem class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_Subsystem_INCLUDED
+#define Util_Subsystem_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/RefCountedObject.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+class Application;
+class OptionSet;
+
+
+class Util_API Subsystem: public Poco::RefCountedObject
+	/// Subsystems extend an application in a modular way.
+	///
+	/// The Subsystem class provides a common interface
+	/// for subsystems so that subsystems can be automatically
+	/// initialized at startup and uninitialized at shutdown.
+	///
+	/// Subsystems should also support dynamic reconfiguration,
+	/// so that they can be reconfigured anytime during the
+	/// life of a running application.
+	///
+	/// The degree to which dynamic reconfiguration is supported
+	/// is up to the actual subsystem implementation. It can
+	/// range from ignoring the reconfiguration request (not
+	/// recommended), to changing certain settings that affect
+	/// the performance, to a complete reinitialization.
+{
+public:
+	Subsystem();
+		/// Creates the Subsystem.
+
+	virtual const char* name() const = 0;
+		/// Returns the name of the subsystem.
+		/// Must be implemented by subclasses.
+
+protected:
+	virtual void initialize(Application& app) = 0;
+		/// Initializes the subsystem.
+
+	virtual void uninitialize() = 0;
+		/// Uninitializes the subsystem.
+
+	virtual void reinitialize(Application& app);
+		/// Re-initializes the subsystem.
+		///
+		/// The default implementation just calls
+		/// uninitialize() followed by initialize().
+		/// Actual implementations might want to use a
+		/// less radical and possibly more performant
+		/// approach.
+
+	virtual void defineOptions(OptionSet& options);
+		/// Called before the Application's command line processing begins.
+		/// If a subsystem wants to support command line arguments,
+		/// it must override this method.
+		/// The default implementation does not define any options.
+		///
+		/// To effectively handle options, a subsystem should either bind
+		/// the option to a configuration property or specify a callback
+		/// to handle the option.
+
+	virtual ~Subsystem();
+		/// Destroys the Subsystem.
+
+	friend class Application;
+
+private:
+	Subsystem(const Subsystem&);
+	Subsystem& operator = (const Subsystem&);
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_Subsystem_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/SystemConfiguration.h b/base/poco/Util/include/Poco/Util/SystemConfiguration.h
new file mode 100644
index 00000000000..e80dc6ef2fc
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/SystemConfiguration.h
@@ -0,0 +1,99 @@
+//
+// SystemConfiguration.h
+//
+// Library: Util
+// Package: Configuration
+// Module:  SystemConfiguration
+//
+// Definition of the SystemConfiguration class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_SystemConfiguration_INCLUDED
+#define Util_SystemConfiguration_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Util/AbstractConfiguration.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API SystemConfiguration: public AbstractConfiguration
+	/// This class implements a Configuration interface to 
+	/// various system properties and environment variables.
+	///
+	/// The following properties are supported:
+	///   - system.osName: the operating system name
+	///   - system.osVersion: the operating system version
+	///   - system.osArchitecture: the operating system architecture
+	///   - system.nodeName: the node (or host) name
+	///   - system.nodeId: system ID, based on the Ethernet address (format "xxxxxxxxxxxx") 
+	///     of the first Ethernet adapter found on the system.
+	///   - system.currentDir: the current working directory
+	///   - system.homeDir: the user's home directory
+	///   - system.configHomeDir: the base directory relative to which user specific configuration files should be stored
+	///   - system.cacheHomeDir: the base directory relative to which user specific non-essential data files should be stored
+	///   - system.dataHomeDir: the base directory relative to which user specific data files should be stored
+	///   - system.tempHomeDir: the base directory relative to which user-specific temporary files and other file objects should be placed
+	///   - system.tempDir: the system's temporary directory
+	///   - system.configDir: the system's configuration directory
+	///   - system.dateTime: the current UTC date and time, formatted in ISO 8601 format.
+	///   - system.pid: the current process ID.
+	///   - system.env.<NAME>: the environment variable with the given <NAME>.
+	///
+	/// An attempt to set a system variable will result in an
+	/// InvalidAccessException being thrown.
+	/// 
+	/// Enumerating environment variables is not supported. 
+	/// An attempt to call keys("system.env") will return an empty range. 
+	///
+	/// Removing key is not supported. An attempt to remove a key results
+	/// in a NotImplementedException being thrown.
+{
+public:
+	SystemConfiguration();
+		/// Creates the SystemConfiguration.
+
+protected:
+	bool getRaw(const std::string& key, std::string& value) const;
+	void setRaw(const std::string& key, const std::string& value);
+	void enumerate(const std::string& key, Keys& range) const;
+	void removeRaw(const std::string& key);
+	~SystemConfiguration();
+
+private:
+	static bool getEnv(const std::string& name, std::string& value);
+
+	static const std::string OSNAME;
+	static const std::string OSVERSION;
+	static const std::string OSARCHITECTURE;
+	static const std::string NODENAME;
+	static const std::string NODEID;
+	static const std::string CURRENTDIR;
+	static const std::string HOMEDIR;
+	static const std::string CONFIGHOMEDIR;
+	static const std::string CACHEHOMEDIR;
+	static const std::string DATAHOMEDIR;
+	static const std::string TEMPHOMEDIR;
+	static const std::string TEMPDIR;
+	static const std::string CONFIGDIR;
+	static const std::string DATETIME;
+#if !defined(POCO_VXWORKS)
+	static const std::string PID;
+#endif
+	static const std::string ENV;
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_SystemConfiguration_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/Timer.h b/base/poco/Util/include/Poco/Util/Timer.h
new file mode 100644
index 00000000000..a3edd47608f
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/Timer.h
@@ -0,0 +1,169 @@
+//
+// Timer.h
+//
+// Library: Util
+// Package: Timer
+// Module:  Timer
+//
+// Definition of the Timer class.
+//
+// Copyright (c) 2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_Timer_INCLUDED
+#define Util_Timer_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Util/TimerTask.h"
+#include "Poco/TimedNotificationQueue.h"
+#include "Poco/Thread.h"
+#include "Poco/Runnable.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API Timer: protected Poco::Runnable
+	/// A Timer allows to schedule tasks (TimerTask objects) for future execution 
+	/// in a background thread. Tasks may be scheduled for one-time execution, 
+	/// or for repeated execution at regular intervals. 
+	///
+	/// The Timer object creates a thread that executes all scheduled tasks
+	/// sequentially. Therefore, tasks should complete their work as quickly
+	/// as possible, otherwise subsequent tasks may be delayed.
+	///
+	/// Timer is safe for multithreaded use - multiple threads can schedule
+	/// new tasks simultaneously.
+	///
+	/// Acknowledgement: The interface of this class has been inspired by
+	/// the java.util.Timer class from Java 1.3.
+{
+public:
+	Timer();
+		/// Creates the Timer.
+	
+	explicit Timer(Poco::Thread::Priority priority);
+		/// Creates the Timer, using a timer thread with
+		/// the given priority.
+	
+	~Timer();
+		/// Destroys the Timer, cancelling all pending tasks.
+		
+	void cancel(bool wait = false);
+		/// Cancels all pending tasks.
+		///
+		/// If a task is currently running, it is allowed to finish.
+		///
+		/// Task cancellation is done asynchronously. If wait
+		/// is false, cancel() returns immediately and the
+		/// task queue will be purged as soon as the currently
+		/// running task finishes. If wait is true, waits
+		/// until the queue has been purged.
+	
+	void schedule(TimerTask::Ptr pTask, Poco::Timestamp time);
+		/// Schedules a task for execution at the specified time.
+		///
+		/// If the time lies in the past, the task is executed
+		/// immediately.
+		///
+		/// Note: the relative time the task will be executed
+		/// won't change if the system's time changes. If the
+		/// given time is 10 seconds in the future at the point
+		/// schedule() is called, the task will be executed 10
+		/// seconds later, even if the system time changes in
+		/// between.
+
+	void schedule(TimerTask::Ptr pTask, Poco::Clock clock);
+		/// Schedules a task for execution at the specified time.
+		///
+		/// If the time lies in the past, the task is executed
+		/// immediately.
+		
+	void schedule(TimerTask::Ptr pTask, long delay, long interval);
+		/// Schedules a task for periodic execution.
+		///
+		/// The task is first executed after the given delay.
+		/// Subsequently, the task is executed periodically with
+		/// the given interval in milliseconds between invocations.
+
+	void schedule(TimerTask::Ptr pTask, Poco::Timestamp time, long interval);
+		/// Schedules a task for periodic execution.
+		///
+		/// The task is first executed at the given time.
+		/// Subsequently, the task is executed periodically with
+		/// the given interval in milliseconds between invocations.
+		///
+		/// Note: the relative time the task will be executed
+		/// won't change if the system's time changes. If the
+		/// given time is 10 seconds in the future at the point
+		/// schedule() is called, the task will be executed 10
+		/// seconds later, even if the system time changes in
+		/// between.
+
+	void schedule(TimerTask::Ptr pTask, Poco::Clock clock, long interval);
+		/// Schedules a task for periodic execution.
+		///
+		/// The task is first executed at the given time.
+		/// Subsequently, the task is executed periodically with
+		/// the given interval in milliseconds between invocations.
+		
+	void scheduleAtFixedRate(TimerTask::Ptr pTask, long delay, long interval);
+		/// Schedules a task for periodic execution at a fixed rate.
+		///
+		/// The task is first executed after the given delay.
+		/// Subsequently, the task is executed periodically 
+		/// every number of milliseconds specified by interval.
+		///
+		/// If task execution takes longer than the given interval,
+		/// further executions are delayed.
+
+	void scheduleAtFixedRate(TimerTask::Ptr pTask, Poco::Timestamp time, long interval);
+		/// Schedules a task for periodic execution at a fixed rate.
+		///
+		/// The task is first executed at the given time.
+		/// Subsequently, the task is executed periodically 
+		/// every number of milliseconds specified by interval.
+		///
+		/// If task execution takes longer than the given interval,
+		/// further executions are delayed.
+		///
+		/// Note: the relative time the task will be executed
+		/// won't change if the system's time changes. If the
+		/// given time is 10 seconds in the future at the point
+		/// scheduleAtFixedRate() is called, the task will be executed 10
+		/// seconds later, even if the system time changes in
+		/// between.
+
+	void scheduleAtFixedRate(TimerTask::Ptr pTask, Poco::Clock clock, long interval);
+		/// Schedules a task for periodic execution at a fixed rate.
+		///
+		/// The task is first executed at the given time.
+		/// Subsequently, the task is executed periodically 
+		/// every number of milliseconds specified by interval.
+		///
+		/// If task execution takes longer than the given interval,
+		/// further executions are delayed.
+
+protected:
+	void run();
+	static void validateTask(const TimerTask::Ptr& pTask);
+	
+private:
+	Timer(const Timer&);
+	Timer& operator = (const Timer&);
+	
+	Poco::TimedNotificationQueue _queue;
+	Poco::Thread _thread;
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_Timer_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/TimerTask.h b/base/poco/Util/include/Poco/Util/TimerTask.h
new file mode 100644
index 00000000000..05263f6afe4
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/TimerTask.h
@@ -0,0 +1,98 @@
+//
+// TimerTask.h
+//
+// Library: Util
+// Package: Timer
+// Module:  TimerTask
+//
+// Definition of the TimerTask class.
+//
+// Copyright (c) 2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_TimerTask_INCLUDED
+#define Util_TimerTask_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Runnable.h"
+#include "Poco/RefCountedObject.h"
+#include "Poco/AutoPtr.h"
+#include "Poco/Timestamp.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API TimerTask: public Poco::RefCountedObject, public Poco::Runnable
+	/// A task that can be scheduled for one-time or 
+	/// repeated execution by a Timer.
+	///
+	/// This is an abstract class. Subclasses must override the run() member
+	/// function to implement the actual task logic.
+{
+public:
+	typedef Poco::AutoPtr<TimerTask> Ptr;
+	
+	TimerTask();
+		/// Creates the TimerTask.
+		
+	void cancel();
+		/// Cancels the execution of the timer.
+		/// If the task has been scheduled for one-time execution and has 
+		/// not yet run, or has not yet been scheduled, it will never run. 
+		/// If the task has been scheduled for repeated execution, it will never 
+		/// run again. If the task is running when this call occurs, the task 
+		/// will run to completion, but will never run again.
+		///
+		/// Warning: A TimerTask that has been cancelled must not be scheduled again.
+		/// An attempt to do so results in a Poco::Util::IllegalStateException being thrown.
+	
+	bool isCancelled() const;
+		/// Returns true iff the TimerTask has been cancelled by a call
+		/// to cancel().
+	
+	Poco::Timestamp lastExecution() const;
+		/// Returns the time of the last execution of the timer task.
+		///
+		/// Returns 0 if the timer has never been executed.
+		
+protected:
+	~TimerTask();
+		/// Destroys the TimerTask.
+	
+private:
+	TimerTask(const TimerTask&);
+	TimerTask& operator = (const TimerTask&);
+	
+	Poco::Timestamp _lastExecution;
+	bool _isCancelled;
+	
+	friend class TaskNotification;
+};
+
+
+//
+// inlines
+//
+inline bool TimerTask::isCancelled() const
+{
+	return _isCancelled;
+}
+
+
+inline Poco::Timestamp TimerTask::lastExecution() const
+{
+	return _lastExecution;
+}
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_TimerTask_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/TimerTaskAdapter.h b/base/poco/Util/include/Poco/Util/TimerTaskAdapter.h
new file mode 100644
index 00000000000..32ff3b981ad
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/TimerTaskAdapter.h
@@ -0,0 +1,69 @@
+//
+// TimerTaskAdapter.h
+//
+// Library: Util
+// Package: Timer
+// Module:  TimerTaskAdapter
+//
+// Definition of the TimerTaskAdapter class template.
+//
+// Copyright (c) 2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_TimerTaskAdapter_INCLUDED
+#define Util_TimerTaskAdapter_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Util/TimerTask.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+template <class C>
+class TimerTaskAdapter: public TimerTask
+	/// This class template simplifies the implementation
+	/// of TimerTask objects by allowing a member function
+	/// of an object to be called as task. 
+{
+public:
+	typedef void (C::*Callback)(TimerTask&);
+	
+	TimerTaskAdapter(C& object, Callback method): _pObject(&object), _method(method)
+		/// Creates the TimerTaskAdapter, using the given 
+		/// object and its member function as task target.
+		///
+		/// The member function must accept one argument,
+		/// a reference to a TimerTask object.
+	{
+	}
+	
+	void run()
+	{
+		(_pObject->*_method)(*this);
+	}
+			
+protected:
+	~TimerTaskAdapter()
+		/// Destroys the TimerTaskAdapter.
+	{
+	}
+	
+private:
+	TimerTaskAdapter();
+
+	C*       _pObject;
+	Callback _method;
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_TimerTaskAdapter_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/Units.h b/base/poco/Util/include/Poco/Util/Units.h
new file mode 100644
index 00000000000..e7f3869dda4
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/Units.h
@@ -0,0 +1,1298 @@
+//
+// Units.h
+//
+// Library: Util
+// Package: Units
+// Module:  Units
+//
+// Definitions for the C++ Units library.
+//
+// Copyright (c) 2007-2010, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+// Adapted for POCO from the following source:
+//
+// C++ Units by Calum Grant
+//
+// Written by Calum Grant
+// Copyright (C) Calum Grant 2007
+//
+// Home page: http://calumgrant.net/units
+// File location: http://calumgrant.net/units/units.hpp
+// Manual: http://calumgrant.net/units/units.html
+//
+// Copying permitted under the terms of the Boost software license.
+//
+
+
+#ifndef Util_Units_INCLUDED
+#define Util_Units_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include <cmath>
+
+
+namespace Poco {
+namespace Util {
+namespace Units {
+
+
+namespace Internal
+{
+	template <typename T1, typename T2> struct Convert;	
+	struct None; 
+	template <int Num, int Den, int Div=Num/Den, int Mod=Num%Den>
+	struct FixedPower;
+}
+
+
+template <typename Unit1, typename Unit2>
+struct Compose;
+	/// Construct a unit equivalent to Unit1*Unit2
+
+
+template <typename U, int Num, int Den = 1>
+struct Scale;
+	/// Constructs a unit equivalent to U*Num/Den
+
+
+template <typename U, int Num, int Den = 1>
+struct Translate;
+	/// Constructs a Unit equivalent to U+Num/Den
+
+
+template <typename U, int Num, int Den = 1>
+struct Power;
+	/// Constructs a Unit equivalent to U^(Num/Den)
+
+
+typedef Power<Internal::None, 0> Unit;
+	/// A unit which is effectively no units at all.
+
+
+template <typename V, typename U>
+class Value
+	/// A Value with a unit.
+	///	  - V is the type you are storing
+	///   - U is the unit of the Value
+	///
+	/// This class is usually not used directly;
+	/// client code should use the typedef'd 
+	/// instantiations defined in the Values and
+	/// Constants namespace.
+	///
+	/// Example:
+	///
+	///   using namespace Poco::Util::Units::Values;
+	///
+	///   std::cout << "One mile is " << km(mile(1)) << std::endl;
+	///       // Output: One mile is 1.60934 km
+	///
+	///   std::cout << "Flow rate is " << m3(mile(1)*inch(80)*foot(9))/s(minute(5));
+	///       // Output: Flow rate is 29.9026 (m)^3.(s)^-1
+	///
+	///   hours h;
+	///   h = cm(3);   // Compile-time error: incompatible units
+	///   h = 4;       // Compile-time error: 4 of what?
+	///   h = days(4); // Ok: h is 96 hours
+{
+public:
+	typedef V ValueType;
+	typedef U Unit;
+
+	Value(): _rep() 
+	{ 
+	}
+
+	explicit Value(const ValueType& v): _rep(v) 
+	{ 
+	}
+	
+	template <typename OV, typename OU>
+	Value(const Value<OV, OU>& v):
+		_rep(Internal::Convert<OU, U>::fn(v.get()))
+	{
+	}
+
+	const ValueType& get() const 
+	{ 
+		return _rep; 
+	}
+	 
+	template <typename OV, typename OU>
+	Value& operator = (const Value<OV, OU>& other)
+	{
+		_rep = Value(other).get();
+		return *this;
+	}
+
+	template <typename OV, typename OU>
+	Value operator + (const Value<OV, OU>& other) const
+	{
+		return Value(get() + Value(other).get());
+	}
+
+	template <typename OV, typename OU>
+	Value& operator += (const Value<OV, OU>& other)
+	{
+		_rep += Value(other).get();
+		return *this;
+	}
+
+	template <typename OV, typename OU>
+	Value& operator -= (const Value<OV, OU>& other)
+	{
+		_rep -= Value(other).get();
+		return *this;
+	}
+
+	template <typename OV, typename OU>
+	Value operator - (const Value<OV, OU>& other) const
+	{
+		return Value(get() - Value(other).get());
+	}
+
+	Value operator - () const
+	{
+		return Value(-get());
+	}
+
+	template <typename OV, typename OU>
+	Value<V, Compose<U, OU> >
+		operator * (const Value<OV, OU>& other) const
+	{
+		return Value<V, Compose<U, OU> >(get() * other.get());
+	}
+
+	Value operator * (const ValueType& v) const
+	{
+		return Value(get() * v);
+	}
+
+	Value& operator *= (const ValueType& v)
+	{
+		_rep *= v;
+		return *this;
+	}
+
+	template <typename OV, typename OU>
+	Value<V, Compose<U, Power<OU, -1> > > operator / (const Value<OV, OU>& other) const
+	{
+		return Value<V, Compose<U, Power<OU, -1> > >(get() / other.get());
+	}
+
+	Value operator / (const ValueType& v) const
+	{
+		return Value(get() / v);
+	}
+
+	Value& operator /= (const ValueType& v)
+	{
+		_rep /= v;
+		return *this;
+	}
+
+	template <typename OV, typename OU>
+	bool operator == (const Value<OV, OU>& other) const
+	{
+		return get() == Value(other).get();
+	}
+
+	template <typename OV, typename OU>
+	bool operator != (const Value<OV, OU>& other) const
+	{
+		return get() != Value(other).get();
+	}
+
+	template <typename OV, typename OU>
+	bool operator < (const Value<OV, OU>& other) const
+	{
+		return get() < Value(other).get();
+	}
+
+	template <typename OV, typename OU>
+	bool operator <= (const Value<OV, OU>& other) const
+	{
+		return get() <= Value(other).get();
+	}
+
+	template <typename OV, typename OU>
+	bool operator > (const Value<OV, OU>& other) const
+	{
+		return get() > Value(other).get();
+	}
+
+	template <typename OV, typename OU>
+	bool operator >= (const Value<OV, OU>& other) const
+	{
+		return get() >= Value(other).get();
+	}
+
+	Value& operator ++ () 
+	{ 
+		++_rep; 
+		return *this; 
+	}
+
+	Value operator ++ (int) 
+	{ 
+		Value v = *this; 
+		++_rep; 
+		return v; 
+	}
+
+	Value& operator -- () 
+	{ 
+		--_rep; 
+		return *this; 
+	}
+
+	Value operator -- (int) 
+	{ 
+		Value v = *this; 
+		--_rep; 
+		return v; 
+	}
+
+private:
+	ValueType _rep;
+};
+
+
+template <typename V, typename U>
+Value<V, Power<U, -1> > operator / (const V& a, const Value<V, U>& b)
+{
+	return Value<V, Power<U, -1> >(a / b.get());
+}
+
+
+template <typename V, typename U>
+Value<V, U > operator * (const V& a, const Value<V, U>& b)
+{
+	return Value<V, U>(a * b.get());
+}
+
+
+template <typename V, typename U>
+Value<V, Power<U, 1, 2> > sqrt(const Value<V, U>& a)
+{
+	return Value<V, Power<U, 1, 2> >(std::sqrt(a.get()));
+}
+
+
+template <typename V, typename U>
+Value<V, Power<U, 2, 1> > square(const Value<V, U>& a)
+{
+	return Value<V, Power<U, 2, 1> >(std::pow(a.get(), 2));
+}
+
+
+template <typename V, typename U>
+Value<V, Power<U, 3, 1> > cube(const Value<V, U>& a)
+{
+	return Value<V, Power<U, 3, 1> >(std::pow(a.get(), 3));
+}
+
+
+template <int Num, int Den, typename V, typename U>
+Value<V, Power<U, Num, Den> > raise(const Value<V, U>& a)
+{
+	return Value<V, Power<U, Num, Den> >(Internal::FixedPower<Num, Den>::Power(a.get()));
+}
+
+
+namespace Internal
+{
+	template <typename T1, typename T2>
+	struct Convertible;
+
+	template <typename U>
+	struct ScalingFactor;
+
+	template <typename T1, typename T2> 
+	struct Convert3
+		/// Converts T1 to T2.
+		/// Stage 3 - performed after Stage 1 and Stage 2.
+		/// The reason we perform Convert in stages is so that the compiler
+		/// can resolve templates in the order we want it to.
+	{
+		template <typename V>
+		static V fn(const V& v)
+			/// The default implementation assumes that the two quantities are in compatible
+			/// Units up to some scaling factor.  Find the scaling factor and apply it.
+		{
+			return v * ScalingFactor<T2>::template fn<V>() / ScalingFactor<T1>::template fn<V>();
+		}
+	};
+
+	template <typename T1, typename T2> 
+	struct Convert2
+		/// Converts T1 to T2.
+		/// Template matches the first argument (T1),
+		/// this is the fall-through to Convert3.
+	{
+		template <typename V>
+		static V fn(const V& v)
+		{
+			return Convert3<T1,T2>::fn(v);
+		}
+	};
+
+	template <typename T1, typename T2> 
+	struct Convert
+		/// Converts T1 to T2.
+		/// If you really want to implement your own conversion routine,
+		/// specialize this template.
+		/// The default implementation falls through to Convert2.
+	{
+		/// If this fails, then T1 is not Convertible to T2:
+		poco_static_assert ((Convertible<T1,T2>::Value));
+
+		template <typename V>
+		static V fn(const V& v)
+		{
+			return Convert2<T1,T2>::fn(v);
+		}
+	};
+
+	template <typename T>
+	struct Convert<T, T>
+		// Trivial conversion to the same type.
+	{
+		template <typename U>
+		static const U& fn(const U& u) { return u; }
+	};
+	
+	template <typename T>
+	struct Convert3<T, T>
+		// Convert to same type.
+	{
+		template <typename U>
+		static const U& fn(const U& u) { return u; }
+	};
+
+	template <typename T, typename U, int Num, int Den>
+	struct Convert2<Scale<T, Num, Den>, U>
+		// Convert from a scaled Unit.
+	{
+		template <typename V>
+		static V fn(const V& v)
+		{
+			return Convert<T, U>::fn((v * Den)/Num);
+		}
+	};
+	
+	template <typename T, typename U, int Num, int Den>
+	struct Convert3<T, Scale<U, Num, Den> >
+		// Convert to a scaled Unit.
+	{
+		template <typename V>
+		static V fn(const V& v)
+		{
+			return (Convert<T, U>::fn(v) * Num)/ Den;
+		}
+	};
+
+	template <typename T, typename U, int Num, int Den>
+	struct Convert2<Translate<T, Num, Den>, U>
+		// Convert from a translated Unit.
+	{
+		template <typename V>
+		static V fn(const V& v)
+		{
+			return Convert<T, U>::fn(v - static_cast<V>(Num) / static_cast<V>(Den));
+		}
+	};
+
+	template <typename T, typename U, int Num, int Den>
+	struct Convert3<T, Translate<U, Num, Den> >
+		// Convert to a translated Unit.
+	{
+		template <typename V>
+		static V fn(const V& v)
+		{
+			return Convert<T, U>::fn(v) + static_cast<V>(Num) / static_cast<V>(Den);
+		}
+	};
+
+	template <typename Term, typename List>
+	struct CountTerms
+		/// Count the power to which Unit Term is raised in the Unit List.
+		/// Returns a rational num/den of the power of term Term in List.
+		/// The default assumes that Term is not found (num/den=0).
+	{
+		static const int num = 0;
+		static const int den = 1;
+	};
+
+	template <typename Term>
+	struct CountTerms<Term, Term>
+	{
+		static const int num = 1;
+		static const int den = 1;
+	}; 
+ 
+	template <typename Term, typename U, int N, int D>
+	struct CountTerms<Term, Scale<U, N, D> >
+		// CountTerms ignores scaling factors - that is taken care of by ScalingFactor.
+	{
+		typedef CountTerms<Term, U> result;
+		static const int num = result::num;
+		static const int den = result::den;
+	};
+
+	template <typename Term, typename U, int N, int D>
+	struct CountTerms<Term, Translate<U, N, D> >
+		// CountTerms ignores translation.
+	{
+		typedef CountTerms<Term, U> result;
+		static const int num = result::num;
+		static const int den = result::den;
+	};
+
+	template <typename Term, typename T1, typename T2>
+	struct CountTerms<Term, Compose<T1,T2> >
+		// Addition of fractions.
+	{
+		typedef CountTerms<Term, T1> result1;
+		typedef CountTerms<Term, T2> result2;
+		static const int num = result1::num * result2::den + result1::den * result2::num;
+		static const int den = result1::den * result2::den;
+	};
+
+	template <typename Term, typename U, int N, int D>
+	struct CountTerms<Term, Power<U, N, D> >
+		// Multiplication of fractions.
+	{
+		typedef CountTerms<Term, U> result;
+		static const int num = N * result::num;
+		static const int den = D * result::den;
+	};
+
+	template <typename Term, typename T1, typename T2>
+	struct CheckTermsEqual
+		/// Counts the power of the Unit Term in Units T1 and T2.
+		/// Reports if they are equal, using equality of fractions.
+		/// Does a depth-first search of the Unit "Term", 
+		/// or counts the terms in the default case.
+	{
+		typedef CountTerms<Term, T1> count1;
+		typedef CountTerms<Term, T2> count2;
+
+		static const bool Value =
+			count1::num * count2::den ==
+			count1::den * count2::num;
+	};
+
+	template <typename U, int N, int D, typename T1, typename T2>
+	struct CheckTermsEqual<Power<U, N, D>, T1, T2 >
+	{
+		static const bool Value = CheckTermsEqual<U, T1, T2>::Value;
+	};
+
+	template <typename U, int N, int D, typename T1, typename T2>
+	struct CheckTermsEqual<Scale<U, N, D>, T1, T2 >
+	{
+		static const bool Value = CheckTermsEqual<U, T1, T2>::Value;
+	};
+
+	template <typename U, int N, int D, typename T1, typename T2>
+	struct CheckTermsEqual<Translate<U, N, D>, T1, T2 >
+	{
+		static const bool Value = CheckTermsEqual<U, T1, T2>::Value;
+	};
+
+	template <typename T1, typename T2, typename T3, typename T4>
+	struct CheckTermsEqual<Compose<T1,T2>,T3,T4>
+	{
+		static const bool Value =
+			CheckTermsEqual<T1, T3, T4>::Value &&
+			CheckTermsEqual<T2, T3, T4>::Value;
+	};
+
+	template <typename T1, typename T2>
+	struct Convertible
+		/// Determines whether two types are Convertible.
+		/// Counts the powers in the LHS and RHS and ensures they are equal.
+	{
+		static const bool Value =
+			CheckTermsEqual<T1,T1,T2>::Value &&
+			CheckTermsEqual<T2,T1,T2>::Value;
+	};
+
+	template <int Num, int Den, int Div, int Mod>
+	struct FixedPower
+		/// A functor that raises a Value to the power Num/Den.
+		/// The template is specialised for efficiency 
+		/// so that we don't always have to call the std::power function.
+	{
+		template <typename T> static T Power(const T& t)
+		{
+			return std::pow(t, static_cast<T>(Num)/static_cast<T>(Den));
+		}
+	};
+
+	template <int N, int D>
+	struct FixedPower<N, D, 1, 0>
+	{
+		template <typename T> static const T& Power(const T& t)
+		{
+			return t;
+		}
+	};
+
+	template <int N, int D>
+	struct FixedPower<N, D, 2, 0>
+	{
+		template <typename T> static T Power(const T& t)
+		{
+			return t*t;
+		}
+	};
+
+	template <int N, int D>
+	struct FixedPower<N, D, 3, 0>
+	{
+		template <typename T> static T Power(const T& t)
+		{
+			return t*t*t;
+		}
+	};
+
+	template <int N, int D>
+	struct FixedPower<N, D, 4, 0>
+	{
+		template <typename T> static const T& Power(const T& t)
+		{
+			T u = t*t;
+			return u*u;
+		}
+	};
+
+	template <int N, int D>
+	struct FixedPower<N, D, -1, 0>
+	{
+		template <typename T> static T Power(const T& t)
+		{
+			return 1/t;
+		}
+	};
+
+	template <int N, int D>
+	struct FixedPower<N, D, -2, 0>
+	{
+		template <typename T> static T Power(const T& t)
+		{
+			return 1/(t*t);
+		}
+	};
+
+	template <int N, int D>
+	struct FixedPower<N, D, 0, 0>
+	{
+		template <typename T> static T Power(const T& t)
+		{
+			return 1;
+		}
+	};
+
+	template <typename U>
+	struct ScalingFactor
+		/// Determine the scaling factor of a Unit in relation to its "base" Units.
+		/// Default is that U is a primitive Unit and is not scaled.
+	{
+		template <typename T>
+		static T fn() { return 1; }
+	};
+
+	template <typename U1, typename U2>
+	struct ScalingFactor< Compose<U1, U2> >
+	{
+		template <typename T>
+		static T fn()
+		{
+			return
+				ScalingFactor<U1>::template fn<T>() *
+				ScalingFactor<U2>::template fn<T>();
+		}
+	};
+
+	template <typename U, int N, int D>
+	struct ScalingFactor< Scale<U, N, D> >
+	{
+		template <typename T>
+		static T fn()
+		{
+			return
+				ScalingFactor<U>::template fn<T>() *
+				static_cast<T>(N) / static_cast<T>(D);
+		}
+	};
+
+	template <typename U, int N, int D>
+	struct ScalingFactor< Power<U, N, D> >
+	{
+		template <typename T>
+		static T fn()
+		{
+			return FixedPower<N, D>::Power(ScalingFactor<U>::template fn<T>());
+		}
+	};
+
+	template <typename U, int N, int D>
+	struct ScalingFactor< Translate<U, N, D> >
+	{
+		template <typename T>
+		static T fn()
+		{
+			return ScalingFactor<U>::template fn<T>();
+		}
+	};
+} // namespace Internal
+
+
+///
+/// Display
+///
+
+
+#define UNIT_DISPLAY_NAME(Unit, string) \
+	template <> \
+	struct OutputUnit<Unit> \
+	{ \
+		template <typename Stream> \
+		static void fn(Stream& os) \
+		{ \
+			os << string; \
+		} \
+	}
+
+
+namespace Internal
+{
+	template <typename U>
+	struct OutputUnit2
+		/// The default Unit formatting mechanism.
+	{
+		template <typename Stream>
+		static void fn(Stream &os) 
+		{
+			os << "Units";
+		}
+	};
+}
+
+
+template <typename U>
+struct OutputUnit
+	/// Functor to write Unit text to stream.
+{
+	template <typename Stream>
+	static void fn(Stream &os) 
+	{
+		Internal::OutputUnit2<U>::fn(os);
+	}
+};
+
+
+UNIT_DISPLAY_NAME(Unit, "1");
+
+
+namespace Internal
+{
+	template <typename U1, typename U2>
+	struct OutputUnit2< Compose<U1,U2> >
+	{
+		template <typename Stream>
+		static void fn(Stream &os) 
+		{ 
+			OutputUnit<U1>::fn(os); 
+			os << '.';
+			OutputUnit<U2>::fn(os); 
+		}
+	};
+
+	template <typename U, int Num, int Den>
+	struct OutputUnit2< Power<U, Num, Den > >
+	{
+		template <typename Stream>
+		static void fn(Stream &os) 
+		{ 
+			if(Num!=Den) os << '(';
+			OutputUnit<U>::fn(os); 
+			if(Num!=Den)
+			{
+				os << ')';
+				os << '^' << Num;
+				if(Num%Den)
+				{
+					os << '/' << Den;
+				}
+			}
+		}
+	};
+
+	template <typename U, int Num, int Den>
+	struct OutputUnit2< Translate<U, Num, Den > >
+	{
+		template <typename Stream>
+		static void fn(Stream &os) 
+		{ 
+			os << '(';
+			OutputUnit<U>::fn(os); 
+			os << '+' << Num;
+			if(Den!=1) os << '/' << Den;
+			os << ')';
+		}
+	};
+
+	template <typename U, int Num, int Den>
+	struct OutputUnit2< Scale<U, Num, Den > >
+	{
+		template <typename Stream>
+		static void fn(Stream &os) 
+		{ 
+			os << Den;
+			if(Num != 1)
+				os << '/' << Num;
+			os << '.';
+			OutputUnit<U>::fn(os); 
+		}
+	};
+} // namespace Internal
+
+
+template <typename Str, typename V, typename U>
+Str& operator << (Str& os, const Value<V, U>& value)
+{
+	os << value.get() << ' ';
+	OutputUnit<U>::fn(os);
+	return os;
+}
+
+
+///
+/// Additional Units
+///
+
+
+namespace Units
+{
+	typedef Poco::Util::Units::Unit Unit;
+
+	// SI base Units:
+
+	struct m;	/// meter
+	struct kg;	/// kilogram
+	struct s;	/// second
+	struct K;	/// Kelvin
+	struct A;	/// Ampere
+	struct mol;	/// mole
+	struct cd;	/// candela
+}
+
+
+UNIT_DISPLAY_NAME(Units::m,   "m");
+UNIT_DISPLAY_NAME(Units::kg,  "kg");
+UNIT_DISPLAY_NAME(Units::s,   "s");
+UNIT_DISPLAY_NAME(Units::K,   "K");
+UNIT_DISPLAY_NAME(Units::A,   "A");
+UNIT_DISPLAY_NAME(Units::mol, "mol");
+UNIT_DISPLAY_NAME(Units::cd,  "cd");
+
+
+namespace Units
+{
+	// SI derived Units:
+	typedef Compose<m, Power<m, -1> > rad;
+	typedef Compose<Power<m, 2>, Power<m, -2> > sr;
+	typedef Power<s, -1> Hz;
+	typedef Compose<m, Compose<kg, Power<s, -2> > > N;
+	typedef Compose<N, Power<m, -2> > Pa;
+	typedef Compose<N, m> J;
+	typedef Compose<J, Power<s, -1> > W;
+	typedef Compose<s, A> C;
+	typedef Compose<W, Power<A, -1> > V;
+	typedef Compose<C, Power<V, -1> > F;
+	typedef Compose<V, Power<A, -1> > Ohm;
+	typedef Compose<A, Power<V, -1> > S;
+	typedef Compose<V, s> Wb;
+	typedef Compose<Wb, Power<m, -2> > T;
+	typedef Compose<Wb, Power<A, -1> > H;
+	typedef cd lm;
+	typedef Compose<lm, Power<m, -2> > lx;
+	typedef Power<s, -1> Bq;
+	typedef Compose<J, Power<kg, -1> > Gy;
+	typedef Gy Sv;
+	typedef Compose<Power<s, -1>,mol> kat;
+}
+
+
+UNIT_DISPLAY_NAME(Units::rad, "rad");
+UNIT_DISPLAY_NAME(Units::sr,  "sr");
+// UNIT_DISPLAY_NAME(Units::Hz, "Hz");	// Too problematic
+UNIT_DISPLAY_NAME(Units::N,   "N");
+UNIT_DISPLAY_NAME(Units::Pa,  "Pa");
+UNIT_DISPLAY_NAME(Units::J,   "J");
+UNIT_DISPLAY_NAME(Units::W,   "W");
+UNIT_DISPLAY_NAME(Units::C,   "C");
+UNIT_DISPLAY_NAME(Units::V,   "V");
+UNIT_DISPLAY_NAME(Units::F,   "F");
+UNIT_DISPLAY_NAME(Units::Ohm, "Ohm");
+UNIT_DISPLAY_NAME(Units::S,   "S");
+UNIT_DISPLAY_NAME(Units::Wb,  "Wb");
+UNIT_DISPLAY_NAME(Units::T,   "T");
+UNIT_DISPLAY_NAME(Units::H,   "H");
+UNIT_DISPLAY_NAME(Units::lx,  "lx");
+UNIT_DISPLAY_NAME(Units::Gy,  "Gy");
+UNIT_DISPLAY_NAME(Units::kat,  "kat");
+
+
+namespace Units
+{
+	// SI prefixes:
+	template <typename U> struct deca { typedef Scale<U, 1, 10> type; };
+	template <typename U> struct hecto { typedef Scale<U, 1, 100> type; };
+	template <typename U> struct kilo { typedef Scale<U, 1, 1000> type; };
+	template <typename U> struct mega { typedef Scale<typename kilo<U>::type, 1, 1000> type; };
+	template <typename U> struct giga { typedef Scale<typename mega<U>::type, 1, 1000> type; };
+	template <typename U> struct tera { typedef Scale<typename giga<U>::type, 1, 1000> type; };
+	template <typename U> struct peta { typedef Scale<typename tera<U>::type, 1, 1000> type; };
+	template <typename U> struct exa { typedef Scale<typename peta<U>::type, 1, 1000> type; };
+	template <typename U> struct zetta { typedef Scale<typename exa<U>::type, 1, 1000> type; };
+	template <typename U> struct yotta { typedef Scale<typename zetta<U>::type, 1, 1000> type; };
+
+	template <typename U> struct deci { typedef Scale<U, 10> type; };
+	template <typename U> struct centi { typedef Scale<U, 100> type; };
+	template <typename U> struct milli { typedef Scale<U, 1000> type; };
+	template <typename U> struct micro { typedef Scale<typename milli<U>::type, 1000> type; };
+	template <typename U> struct nano { typedef Scale<typename micro<U>::type, 1000> type; };
+	template <typename U> struct pico { typedef Scale<typename nano<U>::type, 1000> type; };
+	template <typename U> struct femto { typedef Scale<typename pico<U>::type, 1000> type; };
+	template <typename U> struct atto { typedef Scale<typename femto<U>::type, 1000> type; };
+	template <typename U> struct zepto { typedef Scale<typename atto<U>::type, 1000> type; };
+	template <typename U> struct yocto { typedef Scale<typename zepto<U>::type, 1000> type; };
+
+
+	// Some prefixed SI Units:
+	typedef centi<m>::type cm;
+	typedef milli<m>::type mm;
+	typedef kilo<m>::type km;
+	typedef milli<kg>::type g;
+	typedef milli<g>::type mg;
+	typedef milli<s>::type ms;
+
+
+	class Prefix
+		/// Parent class for unit prefixes.
+		/// Use classes inheriting from this class to scale
+		/// the values.
+	{
+	public:
+		template <typename T>
+		Prefix(const T& val, double multiplier = 1, const std::string& prefix = ""): 
+			_pHolder(new Holder<T>(val)),
+			_multiplier(multiplier),
+			_prefix(prefix)
+		{ 
+		}
+
+		double value() const
+		{ 
+			return _pHolder->get() * _multiplier;
+		}
+
+		void addPrefix(std::ostream& os) const
+		{
+			os << _prefix;
+		}
+
+		void addUnit(std::ostream& os) const
+		{
+			_pHolder->appendUnit(os);
+		}
+
+	private:
+		Prefix();
+
+		class Placeholder
+		{
+		public:
+			virtual ~Placeholder() { }
+			virtual double get() const = 0;
+			virtual void appendUnit(std::ostream& os) const = 0;
+		};
+
+		template <typename U>
+		struct Holder : public Placeholder
+		{
+			typedef Value<typename U::ValueType, typename U::Unit> ValueType;
+
+			Holder (const U& val): _val(ValueType(val)) 
+			{
+			}
+
+			double get() const
+			{
+				return _val.get();
+			}
+
+			void appendUnit(std::ostream& os) const
+			{
+				OutputUnit<typename U::Unit>::fn(os);
+			}
+
+			ValueType _val;
+		};
+
+		Placeholder* _pHolder;
+		double       _multiplier;
+		std::string  _prefix;
+	};
+}
+
+
+template <typename Str>
+Str& streamOp (Str& os, const Units::Prefix& val)
+{
+	os << val.value() << ' ';
+	val.addPrefix(os);
+	val.addUnit(os);
+	return os;
+}
+
+
+template <typename Str>
+Str& operator << (Str& os, const Units::Prefix& val)
+	/// Streaming operator for prefixed values.
+{
+	return streamOp(os, val);
+}
+
+
+UNIT_DISPLAY_NAME(Units::cm, "cm");
+UNIT_DISPLAY_NAME(Units::mm, "mm");
+UNIT_DISPLAY_NAME(Units::km, "km");
+UNIT_DISPLAY_NAME(Units::g,  "g");
+UNIT_DISPLAY_NAME(Units::mg, "mg");
+UNIT_DISPLAY_NAME(Units::ms, "ms");
+
+
+namespace Units
+{
+	// Non-SI mass
+	typedef Scale<kg, 22046223, 10000000> lb;
+	typedef Scale<lb, 16> oz;
+	typedef Scale<kg, 1, 1000> tonne;
+
+	// Non-SI temperature
+	typedef Translate<K, -27315, 100> Celsius;
+	typedef Translate<Scale<Celsius, 9, 5>, 32> Fahrenheit;
+
+	// Non-SI time
+	typedef Scale<s, 1, 60> minute;
+	typedef Scale<minute, 1, 60> hour;
+	typedef Scale<hour, 1, 24> day;
+	typedef Scale<day, 1, 7> week;
+	struct month;	// No fixed ratio with week 
+	typedef Scale<month, 1, 12> year;
+	typedef Scale<year, 1, 100> century;
+	typedef Scale<year, 1, 1000> millennium;
+
+	// Non-SI length
+	typedef Scale<cm, 100, 254> inch;
+	typedef Scale<inch, 1, 12> foot;
+	typedef Scale<inch, 1, 36> yard;
+	typedef Scale<yard, 1, 1760> mile;
+	typedef Scale<m, 1, 1852> nautical_mile;
+
+	// Non-SI area
+	typedef Power<m, 2> m2;
+	typedef Power<mm, 2> mm2;
+	typedef Scale<m2, 1, 10000> hectare;
+	typedef Scale<m2, 1, 100> are;
+	typedef Power<inch, 2> inch2;
+	typedef Scale<hectare, 24710538, 10000000> acre;
+
+	// Non-SI volume
+	typedef Power<cm, 3> cm3;
+	typedef cm3 ml;
+	typedef Scale<ml, 1, 1000> liter;
+	typedef Scale<liter, 10> dl;
+	typedef Scale<liter, 100> cl;
+	typedef Power<m, 3> m3;
+
+	// Non-SI velocity
+	typedef Compose<mile, Power<hour, -1> > mph;
+	typedef Compose<km, Power<hour, -1> > kph;
+	typedef Compose<m, Power<s, -1> > meters_per_second;
+	typedef Compose<nautical_mile, Power<hour, -1> > knot;
+	typedef Scale<meters_per_second, 100, 34029> mach;
+
+	// Angles
+	typedef Scale<rad, 180000000, 3141593> degree;
+	typedef Scale<rad, 200000000, 3141593> grad;
+	typedef Scale< degree, 60 > degree_minute;
+	typedef Scale< degree_minute, 60 > degree_second;
+
+	// Pressure
+	typedef Scale<Pa, 1, 1000> kPa;
+	typedef Scale<kPa, 1450377, 10000000> psi;
+	typedef Scale<kPa, 10> millibar;
+
+	// Other
+	typedef Scale<Hz, 60> rpm;
+	typedef Scale<Unit, 100> percent;
+	typedef Scale<Unit, 1, 12> dozen;
+	typedef Scale<Unit, 1, 13> bakers_dozen;
+}
+
+
+UNIT_DISPLAY_NAME(Units::lb,            "lb");
+UNIT_DISPLAY_NAME(Units::oz,            "oz");
+UNIT_DISPLAY_NAME(Units::tonne,         "tonnes");
+UNIT_DISPLAY_NAME(Units::Celsius,       "'C");
+UNIT_DISPLAY_NAME(Units::Fahrenheit,    "'F");
+UNIT_DISPLAY_NAME(Units::minute,        "minutes");
+UNIT_DISPLAY_NAME(Units::hour,          "hours");
+UNIT_DISPLAY_NAME(Units::day,           "days");
+UNIT_DISPLAY_NAME(Units::week,          "weeks");
+UNIT_DISPLAY_NAME(Units::month,         "months");
+UNIT_DISPLAY_NAME(Units::year,          "years");
+UNIT_DISPLAY_NAME(Units::century,       "centuries");
+UNIT_DISPLAY_NAME(Units::millennium,    "millennia");
+UNIT_DISPLAY_NAME(Units::inch,          "inches");
+UNIT_DISPLAY_NAME(Units::foot,          "foot");
+UNIT_DISPLAY_NAME(Units::yard,          "yards");
+UNIT_DISPLAY_NAME(Units::mile,          "miles");
+UNIT_DISPLAY_NAME(Units::nautical_mile, "nautical miles");
+UNIT_DISPLAY_NAME(Units::hectare,       "ha");
+UNIT_DISPLAY_NAME(Units::are,           "are");
+UNIT_DISPLAY_NAME(Units::acre,          "acres");
+UNIT_DISPLAY_NAME(Units::ml,            "ml");
+UNIT_DISPLAY_NAME(Units::liter,         "l");
+UNIT_DISPLAY_NAME(Units::dl,            "dl");
+UNIT_DISPLAY_NAME(Units::cl,            "cl");
+UNIT_DISPLAY_NAME(Units::mph,           "mph");
+UNIT_DISPLAY_NAME(Units::kph,           "km/h");
+UNIT_DISPLAY_NAME(Units::knot,          "knots");
+UNIT_DISPLAY_NAME(Units::mach,          "mach");
+UNIT_DISPLAY_NAME(Units::degree,        "deg");
+UNIT_DISPLAY_NAME(Units::grad,          "grad");
+UNIT_DISPLAY_NAME(Units::degree_minute, "'");
+UNIT_DISPLAY_NAME(Units::degree_second, "\"");
+UNIT_DISPLAY_NAME(Units::kPa,           "kPa");
+UNIT_DISPLAY_NAME(Units::psi,           "PSI");
+UNIT_DISPLAY_NAME(Units::millibar,      "millibars");
+UNIT_DISPLAY_NAME(Units::percent,       "%");
+UNIT_DISPLAY_NAME(Units::rpm,           "rpm");
+UNIT_DISPLAY_NAME(Units::dozen,         "dozen");
+UNIT_DISPLAY_NAME(Units::bakers_dozen,  "bakers dozen");
+
+
+namespace Values
+{
+	typedef Value<double, Units::Unit> Unit;
+
+	// SI Units
+	typedef Value<double, Units::m> m;
+	typedef Value<double, Units::kg> kg;
+	typedef Value<double, Units::s> s;
+	typedef Value<double, Units::K> K;
+	typedef Value<double, Units::A> A;
+	typedef Value<double, Units::mol> mol;
+	typedef Value<double, Units::cd> cd;
+
+	// SI derived
+	typedef Value<double, Units::rad> rad;
+	typedef Value<double, Units::sr> sr;
+	typedef Value<double, Units::Hz> Hz;
+	typedef Value<double, Units::N> N;
+	typedef Value<double, Units::Pa> Pa;
+	typedef Value<double, Units::J> J;
+	typedef Value<double, Units::W> W;
+	typedef Value<double, Units::C> C;
+	typedef Value<double, Units::V> V;
+	typedef Value<double, Units::F> F;
+	typedef Value<double, Units::Ohm> Ohm;
+	typedef Value<double, Units::S> S;
+	typedef Value<double, Units::Wb> Wb;
+	typedef Value<double, Units::T> T;
+	typedef Value<double, Units::H> H;
+	typedef Value<double, Units::lm> lm;
+	typedef Value<double, Units::lx> lx;
+	typedef Value<double, Units::Bq> Bq;
+	typedef Value<double, Units::Gy> Gy;
+	typedef Value<double, Units::Sv> Sv;
+	typedef Value<double, Units::kat> kat;
+
+	// Prefixed Units
+	typedef Value<double, Units::cm> cm;
+	typedef Value<double, Units::mm> mm;
+	typedef Value<double, Units::km> km;
+	typedef Value<double, Units::g> g;
+	typedef Value<double, Units::mg> mg;
+	typedef Value<double, Units::ms> ms;
+
+	// Non-SI
+	typedef Value<double, Units::lb> lb;
+	typedef Value<double, Units::oz> oz;
+	typedef Value<double, Units::tonne> tonne;
+
+	typedef Value<double, Units::Celsius> Celsius;
+	typedef Value<double, Units::Fahrenheit> Fahrenheit;
+
+	typedef Value<double, Units::minute> minute;
+	typedef Value<double, Units::hour> hour;
+	typedef Value<double, Units::day> day;
+	typedef Value<double, Units::week> week;
+	typedef Value<double, Units::month> month;
+	typedef Value<double, Units::year> year;
+	typedef Value<double, Units::century> century;
+	typedef Value<double, Units::millennium> millennium;
+
+	typedef Value<double, Units::inch> inch;
+	typedef Value<double, Units::foot> foot;
+	typedef Value<double, Units::yard> yard;
+	typedef Value<double, Units::mile> mile;
+	typedef Value<double, Units::nautical_mile> nautical_mile;
+
+	typedef Value<double, Units::m2> m2;
+	typedef Value<double, Units::mm2> mm2;
+	typedef Value<double, Units::hectare> hectare;
+	typedef Value<double, Units::are> are;
+	typedef Value<double, Units::inch2> inch2;
+	typedef Value<double, Units::acre> acre;
+
+	typedef Value<double, Units::cm3> cm3;
+	typedef Value<double, Units::ml> ml;
+	typedef Value<double, Units::cl> cl;
+	typedef Value<double, Units::liter> liter;
+	typedef Value<double, Units::dl> dl;
+	typedef Value<double, Units::m3> m3;
+
+	typedef Value<double, Units::mph> mph;
+	typedef Value<double, Units::kph> kph;
+	typedef Value<double, Units::meters_per_second> meters_per_second;
+	typedef Value<double, Units::knot> knot;
+	typedef Value<double, Units::mach> mach;
+
+	typedef Value<double, Units::degree> degree;
+	typedef Value<double, Units::grad> grad;
+	typedef Value<double, Units::degree_minute> degree_minute;
+	typedef Value<double, Units::degree_second> degree_second;
+
+	typedef Value<double, Units::kPa> kPa;
+	typedef Value<double, Units::psi> psi;
+	typedef Value<double, Units::millibar> millibar;
+
+	typedef Value<double, Units::percent> percent;
+	typedef Value<double, Units::rpm> rpm;
+	typedef Value<double, Units::dozen> dozen;
+	typedef Value<double, Units::bakers_dozen> bakers_dozen;
+
+	#define DEFINE_PREFIX_CLASS(name, scale, prefix) \
+		struct name: public Units::Prefix \
+		{ \
+			template <typename T> \
+			name(const T& val): Prefix(val, scale, prefix) \
+			{ \
+			} \
+		}; \
+		template <typename Str> \
+		Str& operator << (Str& os, const name& val) \
+		{ \
+			return streamOp<Str>(os, val); \
+		}
+
+	DEFINE_PREFIX_CLASS (deca, .1, "da")
+	DEFINE_PREFIX_CLASS (hecto, .01, "h")
+	DEFINE_PREFIX_CLASS (kilo, .001, "k")
+	DEFINE_PREFIX_CLASS (mega, 1e-6, "M")
+	DEFINE_PREFIX_CLASS (giga, 1e-9, "G")
+	DEFINE_PREFIX_CLASS (tera, 1e-12, "T") 
+	DEFINE_PREFIX_CLASS (peta, 1e-15, "P")
+	DEFINE_PREFIX_CLASS (exa, 1e-18, "E")
+	DEFINE_PREFIX_CLASS (zetta, 1e-21, "Z")
+	DEFINE_PREFIX_CLASS (yotta, 1e-24, "Y")
+
+	DEFINE_PREFIX_CLASS (deci, 10, "d")
+	DEFINE_PREFIX_CLASS (centi, 100, "c")
+	DEFINE_PREFIX_CLASS (milli, 1000, "m")
+	DEFINE_PREFIX_CLASS (micro, 1e6, "u")
+	DEFINE_PREFIX_CLASS (nano, 1e9, "n")
+	DEFINE_PREFIX_CLASS (pico, 1e12, "p")
+	DEFINE_PREFIX_CLASS (femto, 1e15, "f")
+	DEFINE_PREFIX_CLASS (atto, 1e18, "a")
+	DEFINE_PREFIX_CLASS (zepto, 1e21, "z")
+	DEFINE_PREFIX_CLASS (yocto, 1e24, "y")
+}
+
+
+namespace Constants
+{
+	// Physical constants:
+	const Value<double, Compose<Units::J, Power<Units::K, -1> > > k (1.3806504e-23);
+	const Value<double, Units::kg> mu (1.660538782e-27);
+	const Value<double, Power<Units::mol, -1> > NA (6.02214179e23);
+	const Value<double, Units::s> G0 (7.7480917004e-5);
+	const Value<double, Compose<Units::F, Power<Units::m, -1> > > e0 (8.854187817e-12);
+	const Value<double, Units::kg> me (9.10938215e-31);
+	const Value<double, Units::J> eV (1.602176487e-19);
+	const Value<double, Units::C> e (1.602176487e-19);
+	const Value<double, Units::F> F (96485.3399);
+	const Value<double, Units::Unit> alpha (7.2973525376e-3);
+	const Value<double, Units::Unit> inv_alpha (137.035999679);
+	const Value<double, Compose<Units::N, Power<Units::A, -2> > > u0 (12.566370614);
+	const Value<double, Units::Wb> phi0 (2.067833667e-15);	// ??
+	const Value<double, Compose<Units::J, Compose<Power<Units::mol, -1>, Power<Units::kg, -1> > > > R (8.314472);
+	const Value<double, Compose< Power<Units::m, 3>, Compose<Power<Units::kg, -1>, Power<Units::s, -2> > > > G (6.67428e-11);
+	const Value<double, Compose< Units::J, Units::s > > h (6.62606896e-34);
+	const Value<double, Compose< Units::J, Units::s > > h_bar (1.054571628e-34);
+	const Value<double, Units::kg> mp (1.672621637e-27);
+	const Value<double, Unit> mpme (1836.15267247);
+	const Value<double, Power<Units::m, -1> > Rinf (10973731.568527);
+	const Value<double, Compose<Units::m, Power<Units::s, -1> > > c (299792458);
+	const Value<double, Compose<Units::W, Compose< Power<Units::m, -1>, Power<Units::K, -4> > > > rho (5.6704e-8);
+
+	// Other constants:
+	const Value<double, Units::rad> pi (3.141592653589793);
+	const Value<double, Units::m> lightyear (9.4605284e15);
+	const Value<double, Units::km> AU(149597871);
+	const Value<double, Compose<Units::m, Power<Units::s, -2> > > g (9.80665);
+}
+
+
+//
+// Trigonometry
+//
+
+
+template <typename V, typename U>
+V sin(const Value<V, U>& angle)
+{
+	return std::sin(Value<V, Units::rad>(angle).get());
+}
+
+
+template <typename V, typename U>
+V cos(const Value<V, U>& angle)
+{
+	return std::cos(Value<V, Units::rad>(angle).get());
+}
+
+
+template <typename V, typename U>
+V tan(const Value<V, U>& angle)
+{
+	return std::tan(Value<V, Units::rad>(angle).get());
+}
+
+
+} } } // namespace Poco::Util::Units
+
+
+#endif // Util_Units_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/Util.h b/base/poco/Util/include/Poco/Util/Util.h
new file mode 100644
index 00000000000..f567243fb16
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/Util.h
@@ -0,0 +1,62 @@
+//
+// Util.h
+//
+// Library: Util
+// Package: Util
+// Module:  Util
+//
+// Basic definitions for the Poco Util library.
+// This file must be the first file included by every other Util
+// header file.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_Util_INCLUDED
+#define Util_Util_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+//
+// The following block is the standard way of creating macros which make exporting
+// from a DLL simpler. All files within this DLL are compiled with the Util_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any project
+// that uses this DLL. This way any other project whose source files include this file see
+// Util_API functions as being imported from a DLL, whereas this DLL sees symbols
+// defined with this macro as being exported.
+//
+#if defined(_WIN32) && defined(POCO_DLL)
+	#if defined(Util_EXPORTS)
+		#define Util_API __declspec(dllexport)
+	#else
+		#define Util_API __declspec(dllimport)
+	#endif
+#endif
+
+
+#if !defined(Util_API)
+	#if !defined(POCO_NO_GCC_API_ATTRIBUTE) && defined (__GNUC__) && (__GNUC__ >= 4)
+		#define Util_API __attribute__ ((visibility ("default")))
+	#else
+		#define Util_API
+	#endif
+#endif
+
+
+//
+// Automatically link Util library.
+//
+#if defined(_MSC_VER)
+	#if !defined(POCO_NO_AUTOMATIC_LIBS) && !defined(Util_EXPORTS)
+		#pragma comment(lib, "PocoUtil" POCO_LIB_SUFFIX)
+	#endif
+#endif
+
+
+#endif // Util_Util_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/Validator.h b/base/poco/Util/include/Poco/Util/Validator.h
new file mode 100644
index 00000000000..38cbc4c3fc3
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/Validator.h
@@ -0,0 +1,57 @@
+//
+// Validator.h
+//
+// Library: Util
+// Package: Options
+// Module:  Validator
+//
+// Definition of the Validator class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_Validator_INCLUDED
+#define Util_Validator_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/RefCountedObject.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+class Option;
+
+
+class Util_API Validator: public Poco::RefCountedObject
+	/// Validator specifies the interface for option validators.
+	///
+	/// Option validators provide a simple way for the automatic
+	/// validation of command line argument values.
+{
+public:
+	virtual void validate(const Option& option, const std::string& value) = 0;
+		/// Validates the value for the given option.
+		/// Does nothing if the value is valid.
+		///
+		/// Throws an OptionException otherwise.
+
+protected:
+	Validator();
+		/// Creates the Validator.
+
+	virtual ~Validator();
+		/// Destroys the Validator.
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_Validator_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/WinRegistryConfiguration.h b/base/poco/Util/include/Poco/Util/WinRegistryConfiguration.h
new file mode 100644
index 00000000000..e7e49fc9e99
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/WinRegistryConfiguration.h
@@ -0,0 +1,71 @@
+//
+// WinRegistryConfiguration.h
+//
+// Library: Util
+// Package: Windows
+// Module:  WinRegistryConfiguration
+//
+// Definition of the WinRegistryConfiguration class.
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_WinRegistryConfiguration_INCLUDED
+#define Util_WinRegistryConfiguration_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/Util/AbstractConfiguration.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API WinRegistryConfiguration: public AbstractConfiguration
+	/// An implementation of AbstractConfiguration that stores configuration data
+	/// in the Windows registry.
+	///
+	/// Removing key is not supported. An attempt to remove a key results
+	/// in a NotImplementedException being thrown.
+{
+public:
+	WinRegistryConfiguration(const std::string& rootPath, REGSAM extraSam = 0);
+		/// Creates the WinRegistryConfiguration. 
+		/// The rootPath must start with one of the root key names
+		/// like HKEY_CLASSES_ROOT, e.g. HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services.
+		/// All further keys are relative to the root path and can be
+		/// dot separated, e.g. the path MyService.ServiceName will be converted to
+		/// HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\MyService\ServiceName.
+        /// The extraSam parameter will be passed along to WinRegistryKey, to control
+        /// registry virtualization for example.
+
+protected:
+	~WinRegistryConfiguration();
+		/// Destroys the WinRegistryConfiguration.
+
+	bool getRaw(const std::string& key, std::string& value) const;
+	void setRaw(const std::string& key, const std::string& value);
+	void enumerate(const std::string& key, Keys& range) const;
+	void removeRaw(const std::string& key);
+
+	std::string convertToRegFormat(const std::string& key, std::string& keyName) const;
+		/// Takes a key in the format of A.B.C and converts it to
+		/// registry format A\B\C, the last entry is the keyName, the rest is returned as path
+
+	friend class WinConfigurationTest;
+private:
+	std::string _rootPath;
+    REGSAM _extraSam;
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_WinRegistryConfiguration_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/WinRegistryKey.h b/base/poco/Util/include/Poco/Util/WinRegistryKey.h
new file mode 100644
index 00000000000..ca1f9fa95cd
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/WinRegistryKey.h
@@ -0,0 +1,198 @@
+//
+// WinRegistryKey.h
+//
+// Library: Util
+// Package: Windows
+// Module:  WinRegistryKey
+//
+// Definition of the WinRegistryKey class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_WinRegistryKey_INCLUDED
+#define Util_WinRegistryKey_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/UnWindows.h"
+#include <vector>
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API WinRegistryKey
+	/// This class implements a convenient interface to the
+	/// Windows Registry.
+	///
+	/// This class is only available on Windows platforms.
+{
+public:
+	typedef std::vector<std::string> Keys;
+	typedef std::vector<std::string> Values;
+
+	enum Type
+	{
+		REGT_NONE = 0,
+		REGT_STRING = 1,
+		REGT_STRING_EXPAND = 2,
+		REGT_BINARY = 3,
+		REGT_DWORD = 4,
+		REGT_DWORD_BIG_ENDIAN = 5,
+		REGT_LINK = 6,
+		REGT_MULTI_STRING = 7,
+		REGT_RESOURCE_LIST = 8,
+		REGT_FULL_RESOURCE_DESCRIPTOR = 9,
+		REGT_RESOURCE_REQUIREMENTS_LIST = 10,
+		REGT_QWORD = 11
+	};
+
+	WinRegistryKey(const std::string& key, bool readOnly = false, REGSAM extraSam = 0);
+		/// Creates the WinRegistryKey.
+		///
+		/// The key must start with one of the root key names
+		/// like HKEY_CLASSES_ROOT, e.g. HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services.
+		///
+		/// If readOnly is true, then only read access to the registry
+		/// is available and any attempt to write to the registry will
+		/// result in an exception.
+		///
+		/// extraSam is used to pass extra flags (in addition to KEY_READ and KEY_WRITE)
+		/// to the samDesired argument of RegOpenKeyEx() or RegCreateKeyEx().
+
+	WinRegistryKey(HKEY hRootKey, const std::string& subKey, bool readOnly = false, REGSAM extraSam = 0);
+		/// Creates the WinRegistryKey.
+		///
+		/// If readOnly is true, then only read access to the registry
+		/// is available and any attempt to write to the registry will
+		/// result in an exception.
+		///
+		/// extraSam is used to pass extra flags (in addition to KEY_READ and KEY_WRITE)
+		/// to the samDesired argument of RegOpenKeyEx() or RegCreateKeyEx().
+
+	~WinRegistryKey();
+		/// Destroys the WinRegistryKey.
+
+	void setString(const std::string& name, const std::string& value);
+		/// Sets the string value (REG_SZ) with the given name.
+		/// An empty name denotes the default value.
+
+	std::string getString(const std::string& name);
+		/// Returns the string value (REG_SZ) with the given name.
+		/// An empty name denotes the default value.
+		///
+		/// Throws a NotFoundException if the value does not exist.
+
+	void setStringExpand(const std::string& name, const std::string& value);
+		/// Sets the expandable string value (REG_EXPAND_SZ) with the given name.
+		/// An empty name denotes the default value.
+
+	std::string getStringExpand(const std::string& name);
+		/// Returns the string value (REG_EXPAND_SZ) with the given name.
+		/// An empty name denotes the default value.
+		/// All references to environment variables (%VAR%) in the string
+		/// are expanded.
+		///
+		/// Throws a NotFoundException if the value does not exist.
+
+	void setBinary(const std::string& name, const std::vector<char>& value);
+		/// Sets the string value (REG_BINARY) with the given name.
+		/// An empty name denotes the default value.
+
+	std::vector<char> getBinary(const std::string& name);
+		/// Returns the string value (REG_BINARY) with the given name.
+		/// An empty name denotes the default value.
+		///
+		/// Throws a NotFoundException if the value does not exist.
+
+	void setInt(const std::string& name, int value);
+		/// Sets the numeric (REG_DWORD) value with the given name.
+		/// An empty name denotes the default value.
+
+	int getInt(const std::string& name);
+		/// Returns the numeric value (REG_DWORD) with the given name.
+		/// An empty name denotes the default value.
+		///
+		/// Throws a NotFoundException if the value does not exist.
+
+#if defined(POCO_HAVE_INT64)
+
+	void setInt64(const std::string& name, Poco::Int64 value);
+		/// Sets the numeric (REG_QWORD) value with the given name.
+		/// An empty name denotes the default value.
+
+	Poco::Int64 getInt64(const std::string& name);
+		/// Returns the numeric value (REG_QWORD) with the given name.
+		/// An empty name denotes the default value.
+		///
+		/// Throws a NotFoundException if the value does not exist.
+
+#endif // POCO_HAVE_INT64
+
+	void deleteValue(const std::string& name);
+		/// Deletes the value with the given name.
+		///
+		/// Throws a NotFoundException if the value does not exist.
+
+	void deleteKey();
+		/// Recursively deletes the key and all subkeys.
+
+	bool exists();
+		/// Returns true iff the key exists.
+
+	Type type(const std::string& name);
+		/// Returns the type of the key value.
+
+	bool exists(const std::string& name);
+		/// Returns true iff the given value exists under that key.
+
+	void subKeys(Keys& keys);
+		/// Appends all subKey names to keys.
+
+	void values(Values& vals);
+		/// Appends all value names to vals;
+
+	bool isReadOnly() const;
+		/// Returns true iff the key has been opened for read-only access only.
+
+protected:
+	void open();
+	void close();
+	std::string key() const;
+	std::string key(const std::string& valueName) const;
+	HKEY handle();
+	void handleSetError(const std::string& name);
+	static HKEY handleFor(const std::string& rootKey);
+
+private:
+	WinRegistryKey();
+	WinRegistryKey(const WinRegistryKey&);
+	WinRegistryKey& operator = (const WinRegistryKey&);
+
+	HKEY        _hRootKey;
+	std::string _subKey;
+	HKEY        _hKey;
+	bool        _readOnly;
+	REGSAM      _extraSam;
+};
+
+
+//
+// inlines
+//
+inline bool WinRegistryKey::isReadOnly() const
+{
+	return _readOnly;
+}
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_WinRegistryKey_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/WinService.h b/base/poco/Util/include/Poco/Util/WinService.h
new file mode 100644
index 00000000000..8a3c49be8d5
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/WinService.h
@@ -0,0 +1,141 @@
+//
+// WinService.h
+//
+// Library: Util
+// Package: Windows
+// Module:  WinService
+//
+// Definition of the WinService class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_WinService_INCLUDED
+#define Util_WinService_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+#include "Poco/UnWindows.h"
+
+
+#if defined(POCO_WIN32_UTF8)
+#define POCO_LPQUERY_SERVICE_CONFIG LPQUERY_SERVICE_CONFIGW
+#else
+#define POCO_LPQUERY_SERVICE_CONFIG LPQUERY_SERVICE_CONFIGA
+#endif
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API WinService
+	/// This class provides an object-oriented interface to
+	/// the Windows Service Control Manager for registering,
+	/// unregistering, configuring, starting and stopping
+	/// services.
+	///
+	/// This class is only available on Windows platforms.
+{
+public:
+	enum Startup
+	{
+		SVC_AUTO_START,
+		SVC_MANUAL_START,
+		SVC_DISABLED
+	};
+	
+	WinService(const std::string& name);
+		/// Creates the WinService, using the given service name.
+
+	~WinService();
+		/// Destroys the WinService.
+
+	const std::string& name() const;
+		/// Returns the service name.
+
+	std::string displayName() const;
+		/// Returns the service's display name.
+
+	std::string path() const;
+		/// Returns the path to the service executable. 
+		///
+		/// Throws a NotFoundException if the service has not been registered.
+
+	void registerService(const std::string& path, const std::string& displayName);
+		/// Creates a Windows service with the executable specified by path
+		/// and the given displayName.
+		///
+		/// Throws a ExistsException if the service has already been registered.
+		
+	void registerService(const std::string& path);
+		/// Creates a Windows service with the executable specified by path
+		/// and the given displayName. The service name is used as display name.
+		///
+		/// Throws a ExistsException if the service has already been registered.
+
+	void unregisterService();
+		/// Deletes the Windows service. 
+		///
+		/// Throws a NotFoundException if the service has not been registered.
+
+	bool isRegistered() const;
+		/// Returns true if the service has been registered with the Service Control Manager.
+
+	bool isRunning() const;
+		/// Returns true if the service is currently running.
+		
+	void start();
+		/// Starts the service.
+		/// Does nothing if the service is already running.
+		///
+		/// Throws a NotFoundException if the service has not been registered.
+
+	void stop();
+		/// Stops the service.
+		/// Does nothing if the service is not running.
+		///
+		/// Throws a NotFoundException if the service has not been registered.
+
+	void setStartup(Startup startup);
+		/// Sets the startup mode for the service.
+		
+	Startup getStartup() const;
+		/// Returns the startup mode for the service.
+		
+	void setDescription(const std::string& description);
+		/// Sets the service description in the registry.
+		
+	std::string getDescription() const;
+		/// Returns the service description from the registry.
+
+	static const int STARTUP_TIMEOUT;
+
+protected:
+	static const std::string REGISTRY_KEY;
+	static const std::string REGISTRY_DESCRIPTION;
+
+private:
+	void open() const;
+	bool tryOpen() const;
+	void close() const;
+	POCO_LPQUERY_SERVICE_CONFIG config() const;
+
+	WinService();
+	WinService(const WinService&);
+	WinService& operator = (const WinService&);
+
+	std::string       _name;
+	SC_HANDLE         _scmHandle;
+	mutable SC_HANDLE _svcHandle;
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // Util_WinService_INCLUDED
diff --git a/base/poco/Util/include/Poco/Util/XMLConfiguration.h b/base/poco/Util/include/Poco/Util/XMLConfiguration.h
new file mode 100644
index 00000000000..c47505e67e5
--- /dev/null
+++ b/base/poco/Util/include/Poco/Util/XMLConfiguration.h
@@ -0,0 +1,209 @@
+//
+// XMLConfiguration.h
+//
+// Library: Util
+// Package: Configuration
+// Module:  XMLConfiguration
+//
+// Definition of the XMLConfiguration class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef Util_XMLConfiguration_INCLUDED
+#define Util_XMLConfiguration_INCLUDED
+
+
+#include "Poco/Util/Util.h"
+
+
+#ifndef POCO_UTIL_NO_XMLCONFIGURATION
+
+
+#include "Poco/Util/MapConfiguration.h"
+#include "Poco/DOM/Document.h"
+#include "Poco/DOM/AutoPtr.h"
+#include "Poco/DOM/DOMWriter.h"
+#include "Poco/SAX/InputSource.h"
+#include <istream>
+
+
+namespace Poco {
+namespace Util {
+
+
+class Util_API XMLConfiguration: public AbstractConfiguration
+	/// This configuration class extracts configuration properties
+	/// from an XML document. An XPath-like syntax for property
+	/// names is supported to allow full access to the XML document.
+	/// XML namespaces are not supported. The name of the root element
+	/// of the XML document is not significant and ignored. 
+	/// Periods in tag names are not supported.
+	/// 
+	/// Given the following XML document as an example:
+	///
+	///     <config>
+	///         <prop1>value1</prop1>
+	///         <prop2>value2</prop2>
+	///         <prop3>
+	///            <prop4 attr="value3"/>
+	///            <prop4 attr="value4"/>
+	///         </prop3>
+	///         <prop5 id="first">value5</prop5>
+	///         <prop5 id="second">value6</prop5>
+	///     </config>
+	///
+	/// The following property names would be valid and would
+	/// yield the shown values:
+	///
+	///     prop1                 -> value1
+	///     prop2                 -> value2
+	///     prop3.prop4           -> (empty string)
+	///     prop3.prop4[@attr]    -> value3
+	///     prop3.prop4[1][@attr] -> value4
+	///     prop5[0]              -> value5
+	///     prop5[1]              -> value6
+	///     prop5[@id=first]      -> value5
+	///     prop5[@id='second']   -> value6
+	///
+	/// Enumerating attributes is not supported.
+	/// Calling keys("prop3.prop4") will return an empty range.
+	///
+	/// As a special feature, the delimiter character used to delimit
+	/// property names can be changed to something other than period ('.') by
+	/// passing the desired character to the constructor. This allows
+	/// working with XML documents having element names with periods
+	/// in them.
+{
+public:
+	XMLConfiguration();
+		/// Creates an empty XMLConfiguration with a "config" root element.
+
+	XMLConfiguration(char delim);
+		/// Creates an empty XMLConfiguration with a "config" root element,
+		/// using the given delimiter char instead of the default '.'.
+
+	XMLConfiguration(Poco::XML::InputSource* pInputSource);
+		/// Creates an XMLConfiguration and loads the XML document from
+		/// the given InputSource.
+
+	XMLConfiguration(Poco::XML::InputSource* pInputSource, char delim);
+		/// Creates an XMLConfiguration and loads the XML document from
+		/// the given InputSource. Uses the given delimiter char instead
+		/// of the default '.'.
+
+	XMLConfiguration(std::istream& istr);
+		/// Creates an XMLConfiguration and loads the XML document from
+		/// the given stream.
+
+	XMLConfiguration(std::istream& istr, char delim);
+		/// Creates an XMLConfiguration and loads the XML document from
+		/// the given stream. Uses the given delimiter char instead
+		/// of the default '.'.
+
+	XMLConfiguration(const std::string& path);
+		/// Creates an XMLConfiguration and loads the XML document from
+		/// the given path.
+
+	XMLConfiguration(const std::string& path, char delim);
+		/// Creates an XMLConfiguration and loads the XML document from
+		/// the given path. Uses the given delimiter char instead
+		/// of the default '.'.
+
+	XMLConfiguration(const Poco::XML::Document* pDocument);
+		/// Creates the XMLConfiguration using the given XML document.
+
+	XMLConfiguration(const Poco::XML::Document* pDocument, char delim);
+		/// Creates the XMLConfiguration using the given XML document.
+		/// Uses the given delimiter char instead of the default '.'.
+		
+	XMLConfiguration(const Poco::XML::Node* pNode);
+		/// Creates the XMLConfiguration using the given XML node.
+
+	XMLConfiguration(const Poco::XML::Node* pNode, char delim);
+		/// Creates the XMLConfiguration using the given XML node.
+		/// Uses the given delimiter char instead of the default '.'.
+
+	void load(Poco::XML::InputSource* pInputSource);
+		/// Loads the XML document containing the configuration data
+		/// from the given InputSource.
+
+	void load(Poco::XML::InputSource* pInputSource, unsigned long namePoolSize);
+		/// Loads the XML document containing the configuration data
+		/// from the given InputSource. Uses the give namePoolSize (which 
+		/// should be a suitable prime like 251, 509, 1021, 4093) for the
+		/// internal DOM Document's name pool.
+
+	void load(std::istream& istr);
+		/// Loads the XML document containing the configuration data
+		/// from the given stream.
+		
+	void load(const std::string& path);
+		/// Loads the XML document containing the configuration data
+		/// from the given file.
+		
+	void load(const Poco::XML::Document* pDocument);
+		/// Loads the XML document containing the configuration data
+		/// from the given XML document.
+
+	void load(const Poco::XML::Node* pNode);
+		/// Loads the XML document containing the configuration data
+		/// from the given XML node.
+	
+	void loadEmpty(const std::string& rootElementName);
+		/// Loads an empty XML document containing only the
+		/// root element with the given name.
+		
+	void save(const std::string& path) const;
+		/// Writes the XML document containing the configuration data
+		/// to the file given by path.
+
+	void save(std::ostream& str) const;
+		/// Writes the XML document containing the configuration data
+		/// to the given stream.
+
+	void save(Poco::XML::DOMWriter& writer, const std::string& path) const;
+		/// Writes the XML document containing the configuration data
+		/// to the file given by path, using the given DOMWriter.
+		///
+		/// This can be used to use a DOMWriter with custom options.
+
+	void save(Poco::XML::DOMWriter& writer, std::ostream& str) const;
+		/// Writes the XML document containing the configuration data
+		/// to the given stream.
+		///
+		/// This can be used to use a DOMWriter with custom options.
+
+protected:
+	bool getRaw(const std::string& key, std::string& value) const;
+	void setRaw(const std::string& key, const std::string& value);
+	void enumerate(const std::string& key, Keys& range) const;
+	void removeRaw(const std::string& key);
+	~XMLConfiguration();
+
+private:
+	const Poco::XML::Node* findNode(const std::string& key) const;
+	Poco::XML::Node* findNode(const std::string& key);
+	Poco::XML::Node* findNode(std::string::const_iterator& it, const std::string::const_iterator& end, Poco::XML::Node* pNode, bool create = false) const;
+	static Poco::XML::Node* findElement(const std::string& name, Poco::XML::Node* pNode, bool create);
+	static Poco::XML::Node* findElement(int index, Poco::XML::Node* pNode, bool create);
+	static Poco::XML::Node* findElement(const std::string& attr, const std::string& value, Poco::XML::Node* pNode);
+	static Poco::XML::Node* findAttribute(const std::string& name, Poco::XML::Node* pNode, bool create);
+
+	Poco::XML::AutoPtr<Poco::XML::Node>     _pRoot;
+	Poco::XML::AutoPtr<Poco::XML::Document> _pDocument;
+	char _delim;
+};
+
+
+} } // namespace Poco::Util
+
+
+#endif // POCO_UTIL_NO_XMLCONFIGURATION
+
+
+#endif // Util_XMLConfiguration_INCLUDED
diff --git a/base/poco/Util/src/AbstractConfiguration.cpp b/base/poco/Util/src/AbstractConfiguration.cpp
new file mode 100644
index 00000000000..95e8da68a57
--- /dev/null
+++ b/base/poco/Util/src/AbstractConfiguration.cpp
@@ -0,0 +1,536 @@
+//
+// AbstractConfiguration.cpp
+//
+// Library: Util
+// Package: Configuration
+// Module:  AbstractConfiguration
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/AbstractConfiguration.h"
+#include "Poco/Util/ConfigurationView.h"
+#include "Poco/Exception.h"
+#include "Poco/NumberParser.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/String.h"
+
+
+using Poco::Mutex;
+using Poco::NotFoundException;
+using Poco::SyntaxException;
+using Poco::CircularReferenceException;
+using Poco::NumberParser;
+using Poco::NumberFormatter;
+using Poco::icompare;
+
+
+namespace Poco {
+namespace Util {
+
+
+AbstractConfiguration::AbstractConfiguration(): 
+	_depth(0),
+	_eventsEnabled(true)
+{
+}
+
+
+AbstractConfiguration::~AbstractConfiguration()
+{
+}
+
+
+bool AbstractConfiguration::hasProperty(const std::string& key) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	std::string value;
+	return getRaw(key, value);
+}
+
+
+bool AbstractConfiguration::hasOption(const std::string& key) const
+{
+	return hasProperty(key);
+}
+
+
+bool AbstractConfiguration::has(const std::string& key) const
+{
+	return hasProperty(key);
+}
+
+	
+std::string AbstractConfiguration::getString(const std::string& key) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	std::string value;
+	if (getRaw(key, value))
+		return internalExpand(value);
+	else
+		throw NotFoundException(key);
+}
+
+	
+std::string AbstractConfiguration::getString(const std::string& key, const std::string& defaultValue) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	std::string value;
+	if (getRaw(key, value))
+		return internalExpand(value);
+	else
+		return defaultValue;
+}
+
+
+std::string AbstractConfiguration::getRawString(const std::string& key) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	std::string value;
+	if (getRaw(key, value))
+		return value;
+	else
+		throw NotFoundException(key);
+}
+
+	
+std::string AbstractConfiguration::getRawString(const std::string& key, const std::string& defaultValue) const
+{
+	
+	Mutex::ScopedLock lock(_mutex);
+
+	std::string value;
+	if (getRaw(key, value))
+		return value;
+	else
+		return defaultValue;
+}
+
+	
+int AbstractConfiguration::getInt(const std::string& key) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	std::string value;
+	if (getRaw(key, value))
+		return parseInt(internalExpand(value));
+	else
+		throw NotFoundException(key);
+}
+
+	
+int AbstractConfiguration::getInt(const std::string& key, int defaultValue) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	std::string value;
+	if (getRaw(key, value))
+		return parseInt(internalExpand(value));
+	else
+		return defaultValue;
+}
+
+
+unsigned AbstractConfiguration::getUInt(const std::string& key) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	std::string value;
+	if (getRaw(key, value))
+		return parseUInt(internalExpand(value));
+	else
+		throw NotFoundException(key);
+}
+
+
+unsigned AbstractConfiguration::getUInt(const std::string& key, unsigned defaultValue) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	std::string value;
+	if (getRaw(key, value))
+		return parseUInt(internalExpand(value));
+	else
+		return defaultValue;
+}
+
+
+#if defined(POCO_HAVE_INT64)
+
+
+Int64 AbstractConfiguration::getInt64(const std::string& key) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	std::string value;
+	if (getRaw(key, value))
+		return parseInt64(internalExpand(value));
+	else
+		throw NotFoundException(key);
+}
+
+
+Int64 AbstractConfiguration::getInt64(const std::string& key, Int64 defaultValue) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	std::string value;
+	if (getRaw(key, value))
+		return parseInt64(internalExpand(value));
+	else
+		return defaultValue;
+}
+
+
+UInt64 AbstractConfiguration::getUInt64(const std::string& key) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	std::string value;
+	if (getRaw(key, value))
+		return parseUInt64(internalExpand(value));
+	else
+		throw NotFoundException(key);
+}
+
+
+UInt64 AbstractConfiguration::getUInt64(const std::string& key, UInt64 defaultValue) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	std::string value;
+	if (getRaw(key, value))
+		return parseUInt64(internalExpand(value));
+	else
+		return defaultValue;
+}
+
+
+#endif // defined(POCO_HAVE_INT64)
+
+
+double AbstractConfiguration::getDouble(const std::string& key) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	std::string value;
+	if (getRaw(key, value))
+		return NumberParser::parseFloat(internalExpand(value));
+	else
+		throw NotFoundException(key);
+}
+
+	
+double AbstractConfiguration::getDouble(const std::string& key, double defaultValue) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	std::string value;
+	if (getRaw(key, value))
+		return NumberParser::parseFloat(internalExpand(value));
+	else
+		return defaultValue;
+}
+
+
+bool AbstractConfiguration::getBool(const std::string& key) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	std::string value;
+	if (getRaw(key, value))
+		return parseBool(internalExpand(value));
+	else
+		throw NotFoundException(key);
+}
+
+
+bool AbstractConfiguration::getBool(const std::string& key, bool defaultValue) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	std::string value;
+	if (getRaw(key, value))
+		return parseBool(internalExpand(value));
+	else
+		return defaultValue;
+}
+
+
+void AbstractConfiguration::setString(const std::string& key, const std::string& value)
+{
+	setRawWithEvent(key, value);
+}
+
+	
+void AbstractConfiguration::setInt(const std::string& key, int value)
+{
+	setRawWithEvent(key, NumberFormatter::format(value));
+}
+
+	
+void AbstractConfiguration::setUInt(const std::string& key, unsigned int value)
+{
+	setRawWithEvent(key, NumberFormatter::format(value));
+}
+
+
+#if defined(POCO_HAVE_INT64)
+
+
+void AbstractConfiguration::setInt64(const std::string& key, Int64 value)
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	setRawWithEvent(key, NumberFormatter::format(value));
+}
+
+
+void AbstractConfiguration::setUInt64(const std::string& key, UInt64 value)
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	setRawWithEvent(key, NumberFormatter::format(value));
+}
+
+
+#endif // defined(POCO_HAVE_INT64)
+
+
+void AbstractConfiguration::setDouble(const std::string& key, double value)
+{
+	setRawWithEvent(key, NumberFormatter::format(value));
+}
+
+
+void AbstractConfiguration::setBool(const std::string& key, bool value)
+{
+	setRawWithEvent(key, value ? "true" : "false");
+}
+
+
+void AbstractConfiguration::keys(Keys& range) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	std::string key;
+	range.clear();
+	enumerate(key, range);
+}
+
+
+void AbstractConfiguration::keys(const std::string& key, Keys& range) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	range.clear();
+	enumerate(key, range);
+}
+
+
+const AbstractConfiguration* AbstractConfiguration::createView(const std::string& prefix) const
+{
+	return new ConfigurationView(prefix, const_cast<AbstractConfiguration*>(this));
+}
+
+
+AbstractConfiguration* AbstractConfiguration::createView(const std::string& prefix)
+{
+	return new ConfigurationView(prefix, this);
+}
+
+
+namespace
+{
+	class AutoCounter
+	{
+	public:
+		AutoCounter(int& count): _count(count)
+		{
+			++_count;
+		}
+		
+		~AutoCounter()
+		{
+			--_count;
+		}
+		
+	private:
+		int& _count;
+	};
+}
+
+
+std::string AbstractConfiguration::expand(const std::string& value) const
+{
+	Mutex::ScopedLock lock(_mutex);
+
+	return internalExpand(value);
+}
+
+
+void AbstractConfiguration::remove(const std::string& key)
+{
+	if (_eventsEnabled)
+	{
+		propertyRemoving(this, key);
+	}
+	{
+		
+		Mutex::ScopedLock lock(_mutex);
+		removeRaw(key);
+	}
+	if (_eventsEnabled)
+	{
+		propertyRemoved(this, key);
+	}
+}
+
+
+void AbstractConfiguration::enableEvents(bool enable)
+{
+	_eventsEnabled = enable;
+}
+
+	
+bool AbstractConfiguration::eventsEnabled() const
+{
+	return _eventsEnabled;
+}
+
+
+void AbstractConfiguration::removeRaw(const std::string& key)
+{
+	throw Poco::NotImplementedException("removeRaw()");
+}
+
+
+std::string AbstractConfiguration::internalExpand(const std::string& value) const
+{
+	AutoCounter counter(_depth);
+	if (_depth > 10) throw CircularReferenceException("Too many property references encountered");
+	return uncheckedExpand(value);
+}
+
+
+std::string AbstractConfiguration::uncheckedExpand(const std::string& value) const
+{
+	std::string result;
+	std::string::const_iterator it  = value.begin();
+	std::string::const_iterator end = value.end();
+	while (it != end)
+	{
+		if (*it == '$')
+		{
+			++it;
+			if (it != end && *it == '{')
+			{
+				++it;
+				std::string prop;
+				while (it != end && *it != '}') prop += *it++;
+				if (it != end) ++it;
+				std::string value;
+				if (getRaw(prop, value))
+				{
+					result.append(internalExpand(value));
+				}
+				else
+				{
+					result.append("${");
+					result.append(prop);
+					result.append("}");
+				}
+			}
+			else result += '$';
+		}
+		else result += *it++;
+	}
+	return result;
+}
+
+
+int AbstractConfiguration::parseInt(const std::string& value)
+{
+	if ((value.compare(0, 2, "0x") == 0) || (value.compare(0, 2, "0X") == 0))
+		return static_cast<int>(NumberParser::parseHex(value));
+	else
+		return NumberParser::parse(value);
+}
+
+
+unsigned AbstractConfiguration::parseUInt(const std::string& value)
+{
+	if ((value.compare(0, 2, "0x") == 0) || (value.compare(0, 2, "0X") == 0))
+		return NumberParser::parseHex(value);
+	else
+		return NumberParser::parseUnsigned(value);
+}
+
+
+Int64 AbstractConfiguration::parseInt64(const std::string& value)
+{
+	if ((value.compare(0, 2, "0x") == 0) || (value.compare(0, 2, "0X") == 0))
+		return static_cast<Int64>(NumberParser::parseHex64(value));
+	else
+		return NumberParser::parse64(value);
+}
+
+
+UInt64 AbstractConfiguration::parseUInt64(const std::string& value)
+{
+	if ((value.compare(0, 2, "0x") == 0) || (value.compare(0, 2, "0X") == 0))
+		return NumberParser::parseHex64(value);
+	else
+		return NumberParser::parseUnsigned64(value);
+}
+
+
+bool AbstractConfiguration::parseBool(const std::string& value)
+{
+	int n;
+	if (NumberParser::tryParse(value, n))
+		return n != 0;
+	else if (icompare(value, "true") == 0)
+		return true;
+	else if (icompare(value, "yes") == 0)
+		return true;
+	else if (icompare(value, "on") == 0)
+		return true;
+	else if (icompare(value, "false") == 0)
+		return false;
+	else if (icompare(value, "no") == 0)
+		return false;
+	else if (icompare(value, "off") == 0)
+		return false;
+	else 
+		throw SyntaxException("Cannot convert to boolean", value);
+}
+
+
+void AbstractConfiguration::setRawWithEvent(const std::string& key, std::string value)
+{
+	KeyValue kv(key, value);
+	if (_eventsEnabled)
+	{
+		propertyChanging(this, kv);
+	}
+	{
+		Mutex::ScopedLock lock(_mutex);
+		setRaw(key, value);
+	}
+	if (_eventsEnabled)
+	{
+		propertyChanged(this, kv);
+	}
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/Application.cpp b/base/poco/Util/src/Application.cpp
new file mode 100644
index 00000000000..c7a64eb7dba
--- /dev/null
+++ b/base/poco/Util/src/Application.cpp
@@ -0,0 +1,568 @@
+//
+// Application.cpp
+//
+// Library: Util
+// Package: Application
+// Module:  Application
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/Application.h"
+#include "Poco/Util/SystemConfiguration.h"
+#include "Poco/Util/MapConfiguration.h"
+#include "Poco/Util/PropertyFileConfiguration.h"
+#include "Poco/Util/IniFileConfiguration.h"
+#ifndef POCO_UTIL_NO_XMLCONFIGURATION
+#include "Poco/Util/XMLConfiguration.h"
+#endif
+#ifndef POCO_UTIL_NO_JSONCONFIGURATION
+#include "Poco/Util/JSONConfiguration.h"
+#endif
+#include "Poco/Util/LoggingSubsystem.h"
+#include "Poco/Util/Option.h"
+#include "Poco/Util/OptionProcessor.h"
+#include "Poco/Util/Validator.h"
+#include "Poco/Environment.h"
+#include "Poco/Exception.h"
+#include "Poco/NumberFormatter.h"
+#include "Poco/File.h"
+#include "Poco/Path.h"
+#include "Poco/String.h"
+#include "Poco/ConsoleChannel.h"
+#include "Poco/AutoPtr.h"
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#include "Poco/UnWindows.h"
+#endif
+#if defined(POCO_OS_FAMILY_UNIX) && !defined(POCO_VXWORKS)
+#include "Poco/SignalHandler.h"
+#endif
+#if defined(POCO_WIN32_UTF8) && !defined(POCO_NO_WSTRING)
+#include "Poco/UnicodeConverter.h"
+#endif
+
+
+using Poco::Logger;
+using Poco::Path;
+using Poco::File;
+using Poco::Environment;
+using Poco::SystemException;
+using Poco::ConsoleChannel;
+using Poco::NumberFormatter;
+using Poco::AutoPtr;
+using Poco::icompare;
+
+
+namespace Poco {
+namespace Util {
+
+
+Application* Application::_pInstance = 0;
+
+
+Application::Application():
+	_pConfig(new LayeredConfiguration),
+	_initialized(false),
+	_unixOptions(true),
+	_pLogger(&Logger::get("ApplicationStartup")),
+	_stopOptionsProcessing(false)
+{
+	setup();
+}
+
+
+Application::Application(int argc, char* argv[]):
+	_pConfig(new LayeredConfiguration),
+	_initialized(false),
+	_unixOptions(true),
+	_pLogger(&Logger::get("ApplicationStartup")),
+	_stopOptionsProcessing(false)
+{
+	setup();
+	init(argc, argv);
+}
+
+
+Application::~Application()
+{
+	_pInstance = 0;
+}
+
+
+void Application::setup()
+{
+	poco_assert (_pInstance == 0);
+	
+	_pConfig->add(new SystemConfiguration, PRIO_SYSTEM, false, false);
+	_pConfig->add(new MapConfiguration, PRIO_APPLICATION, true, false);
+	
+	addSubsystem(new LoggingSubsystem);
+	
+#if defined(POCO_OS_FAMILY_UNIX) && !defined(POCO_VXWORKS)
+	_workingDirAtLaunch = Path::current();
+
+	#if !defined(_DEBUG)
+	Poco::SignalHandler::install();
+	#endif
+#else
+	setUnixOptions(false);
+#endif
+
+	_pInstance = this;
+
+	AutoPtr<ConsoleChannel> pCC = new ConsoleChannel;
+	Logger::setChannel("", pCC);
+}
+
+
+void Application::addSubsystem(Subsystem* pSubsystem)
+{
+	poco_check_ptr (pSubsystem);
+
+	_subsystems.push_back(pSubsystem);
+}
+
+
+void Application::init(int argc, char* argv[])
+{
+	setArgs(argc, argv);
+	init();
+}
+
+
+#if defined(POCO_WIN32_UTF8) && !defined(POCO_NO_WSTRING)
+void Application::init(int argc, wchar_t* argv[])
+{
+	std::vector<std::string> args;
+	for (int i = 0; i < argc; ++i)
+	{
+		std::string arg;
+		Poco::UnicodeConverter::toUTF8(argv[i], arg);
+		args.push_back(arg);
+	}
+	init(args);
+}
+#endif
+
+
+void Application::init(const ArgVec& args)
+{
+	setArgs(args);
+	init();
+}
+
+
+void Application::init()
+{
+	Path appPath;
+	getApplicationPath(appPath);
+	_pConfig->setString("application.path", appPath.toString());
+	_pConfig->setString("application.name", appPath.getFileName());
+	_pConfig->setString("application.baseName", appPath.getBaseName());
+	_pConfig->setString("application.dir", appPath.parent().toString());
+	_pConfig->setString("application.configDir", Path::configHome() + appPath.getBaseName() + Path::separator());
+	_pConfig->setString("application.cacheDir", Path::cacheHome() + appPath.getBaseName() + Path::separator());
+	_pConfig->setString("application.tempDir", Path::tempHome() + appPath.getBaseName() + Path::separator());
+	_pConfig->setString("application.dataDir", Path::dataHome() + appPath.getBaseName() + Path::separator());
+	processOptions();
+}
+
+
+const char* Application::name() const
+{
+	return "Application";
+}
+
+
+void Application::initialize(Application& self)
+{
+	for (SubsystemVec::iterator it = _subsystems.begin(); it != _subsystems.end(); ++it)
+	{
+		_pLogger->debug(std::string("Initializing subsystem: ") + (*it)->name());
+		(*it)->initialize(self);
+	}
+	_initialized = true;
+}
+
+	
+void Application::uninitialize()
+{
+	if (_initialized)
+	{
+		for (SubsystemVec::reverse_iterator it = _subsystems.rbegin(); it != _subsystems.rend(); ++it)
+		{
+			_pLogger->debug(std::string("Uninitializing subsystem: ") + (*it)->name());
+			(*it)->uninitialize();
+		}
+		_initialized = false;
+	}
+}
+
+
+void Application::reinitialize(Application& self)
+{
+	for (SubsystemVec::iterator it = _subsystems.begin(); it != _subsystems.end(); ++it)
+	{
+		_pLogger->debug(std::string("Re-initializing subsystem: ") + (*it)->name());
+		(*it)->reinitialize(self);
+	}
+}
+
+
+void Application::setUnixOptions(bool flag)
+{
+	_unixOptions = flag;
+}
+
+
+int Application::loadConfiguration(int priority)
+{
+	int n = 0;
+	Path appPath;
+	getApplicationPath(appPath);
+	Path confPath;
+	if (findAppConfigFile(appPath.getBaseName(), "properties", confPath))
+	{
+		_pConfig->add(new PropertyFileConfiguration(confPath.toString()), priority, false, false);
+		++n;
+	}
+#ifndef POCO_UTIL_NO_INIFILECONFIGURATION
+	if (findAppConfigFile(appPath.getBaseName(), "ini", confPath))
+	{
+		_pConfig->add(new IniFileConfiguration(confPath.toString()), priority, false, false);
+		++n;
+	}
+#endif
+#ifndef POCO_UTIL_NO_JSONCONFIGURATION
+	if (findAppConfigFile(appPath.getBaseName(), "json", confPath))
+	{
+		_pConfig->add(new JSONConfiguration(confPath.toString()), priority, false, false);
+		++n;
+	}
+#endif
+#ifndef POCO_UTIL_NO_XMLCONFIGURATION
+	if (findAppConfigFile(appPath.getBaseName(), "xml", confPath))
+	{
+		_pConfig->add(new XMLConfiguration(confPath.toString()), priority, false, false);
+		++n;
+	}
+#endif
+	if (n > 0)
+	{
+		if (!confPath.isAbsolute())
+			_pConfig->setString("application.configDir", confPath.absolute().parent().toString());
+		else
+			_pConfig->setString("application.configDir", confPath.parent().toString());
+	}
+	return n;
+}
+
+
+void Application::loadConfiguration(const std::string& path, int priority)
+{
+	int n = 0;
+	Path confPath(path);
+	std::string ext = confPath.getExtension();
+	if (icompare(ext, "properties") == 0)
+	{
+		_pConfig->add(new PropertyFileConfiguration(confPath.toString()), priority, false, false);
+		++n;
+	}
+#ifndef POCO_UTIL_NO_INIFILECONFIGURATION
+	else if (icompare(ext, "ini") == 0)
+	{
+		_pConfig->add(new IniFileConfiguration(confPath.toString()), priority, false, false);
+		++n;
+	}
+#endif
+#ifndef POCO_UTIL_NO_JSONCONFIGURATION
+	else if (icompare(ext, "json") == 0)
+	{
+		_pConfig->add(new JSONConfiguration(confPath.toString()), priority, false, false);
+		++n;
+	}
+#endif
+#ifndef POCO_UTIL_NO_XMLCONFIGURATION
+	else if (icompare(ext, "xml") == 0)
+	{
+		_pConfig->add(new XMLConfiguration(confPath.toString()), priority, false, false);
+		++n;
+	}
+#endif
+	else throw Poco::InvalidArgumentException("Unsupported configuration file type", ext);
+
+	if (n > 0 && !_pConfig->has("application.configDir"))
+	{
+		if (!confPath.isAbsolute())
+			_pConfig->setString("application.configDir", confPath.absolute().parent().toString());
+		else
+			_pConfig->setString("application.configDir", confPath.parent().toString());
+	}
+}
+
+
+std::string Application::commandName() const
+{
+	return _pConfig->getString("application.baseName");
+}
+
+
+std::string Application::commandPath() const
+{
+	return _pConfig->getString("application.path");
+}
+
+
+void Application::stopOptionsProcessing()
+{
+	_stopOptionsProcessing = true;
+}
+
+
+int Application::run()
+{
+	int rc = EXIT_CONFIG;
+	initialize(*this);
+
+	try
+	{
+		rc = EXIT_SOFTWARE;
+		rc = main(_unprocessedArgs);
+	}
+	catch (Poco::Exception& exc)
+	{
+		logger().log(exc);
+	}
+	catch (std::exception& exc)
+	{
+		logger().error(exc.what());
+	}
+	catch (...)
+	{
+		logger().fatal("system exception");
+	}
+
+	uninitialize();
+	return rc;
+}
+
+
+int Application::main(const ArgVec& args)
+{
+	return EXIT_OK;
+}
+
+
+void Application::setArgs(int argc, char* argv[])
+{
+	_command = argv[0];
+	_pConfig->setInt("application.argc", argc);
+	_unprocessedArgs.reserve(argc);
+	std::string argvKey = "application.argv[";
+	for (int i = 0; i < argc; ++i)
+	{
+		std::string arg(argv[i]);
+		_pConfig->setString(argvKey + NumberFormatter::format(i) + "]", arg);
+		_unprocessedArgs.push_back(arg);
+	}
+}
+
+
+void Application::setArgs(const ArgVec& args)
+{
+	poco_assert (!args.empty());
+	
+	_command = args[0];
+	_pConfig->setInt("application.argc", (int) args.size());
+	_unprocessedArgs = args;
+	std::string argvKey = "application.argv[";
+	for (int i = 0; i < args.size(); ++i)
+	{
+		_pConfig->setString(argvKey + NumberFormatter::format(i) + "]", args[i]);
+	}
+}
+
+
+void Application::processOptions()
+{
+	defineOptions(_options);
+	OptionProcessor processor(_options);
+	processor.setUnixStyle(_unixOptions);
+	_argv = _unprocessedArgs;
+	_unprocessedArgs.erase(_unprocessedArgs.begin());
+	ArgVec::iterator it = _unprocessedArgs.begin();
+	while (it != _unprocessedArgs.end() && !_stopOptionsProcessing)
+	{
+		std::string name;
+		std::string value;
+		if (processor.process(*it, name, value))
+		{
+			if (!name.empty()) // "--" option to end options processing or deferred argument
+			{
+				handleOption(name, value);
+			}
+			it = _unprocessedArgs.erase(it);
+		}
+		else ++it;
+	}
+	if (!_stopOptionsProcessing)
+		processor.checkRequired();
+}
+
+
+void Application::getApplicationPath(Poco::Path& appPath) const
+{
+#if defined(POCO_OS_FAMILY_UNIX) && !defined(POCO_VXWORKS)
+	if (_command.find('/') != std::string::npos)
+	{
+		Path path(_command);
+		if (path.isAbsolute())
+		{
+			appPath = path;
+		}
+		else
+		{
+			appPath = _workingDirAtLaunch;
+			appPath.append(path);
+		}
+	}
+	else
+	{
+		if (!Path::find(Environment::get("PATH"), _command, appPath))
+			appPath = Path(_workingDirAtLaunch, _command);
+		appPath.makeAbsolute();
+	}
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+	#if defined(POCO_WIN32_UTF8) && !defined(POCO_NO_WSTRING)
+		wchar_t path[1024];
+		int n = GetModuleFileNameW(0, path, sizeof(path)/sizeof(wchar_t));
+		if (n > 0)
+		{
+			std::string p;
+			Poco::UnicodeConverter::toUTF8(path, p);
+			appPath = p;
+		}
+		else throw SystemException("Cannot get application file name.");
+	#else
+		char path[1024];
+		int n = GetModuleFileNameA(0, path, sizeof(path));
+		if (n > 0)
+			appPath = path;
+		else
+			throw SystemException("Cannot get application file name.");
+	#endif
+#else
+	appPath = _command;
+#endif
+}
+
+
+bool Application::findFile(Poco::Path& path) const
+{
+	if (path.isAbsolute()) return true;
+	
+	Path appPath;
+	getApplicationPath(appPath);
+	Path base = appPath.parent();
+	do
+	{
+		Path p(base, path);
+		File f(p);
+		if (f.exists())
+		{
+			path = p;
+			return true;
+		}
+		if (base.depth() > 0) base.popDirectory();
+	}
+	while (base.depth() > 0);
+	return false;
+}
+
+
+bool Application::findAppConfigFile(const std::string& appName, const std::string& extension, Path& path) const
+{
+	poco_assert (!appName.empty());
+
+	Path p(appName);
+	p.setExtension(extension);
+	bool found = findFile(p);
+	if (!found)
+	{
+#if defined(_DEBUG)
+		if (appName[appName.length() - 1] == 'd')
+		{
+			p.setBaseName(appName.substr(0, appName.length() - 1));
+			found = findFile(p);
+		}
+#endif
+	}
+	if (found)
+		path = p;
+	return found;
+}
+
+
+bool Application::findAppConfigFile(const Path& basePath, const std::string& appName, const std::string& extension, Path& path) const
+{
+	poco_assert (!appName.empty());
+	
+	Path p(basePath,appName);
+	p.setExtension(extension);
+	bool found = findFile(p);
+	if (!found)
+	{
+#if defined(_DEBUG)
+		if (appName[appName.length() - 1] == 'd')
+		{
+			p.setBaseName(appName.substr(0, appName.length() - 1));
+			found = findFile(p);
+		}
+#endif
+	}
+	if (found)
+		path = p;
+	return found;
+}
+
+
+void Application::defineOptions(OptionSet& options)
+{
+	for (SubsystemVec::iterator it = _subsystems.begin(); it != _subsystems.end(); ++it)
+	{
+		(*it)->defineOptions(options);
+	}
+}
+
+
+void Application::handleOption(const std::string& name, const std::string& value)
+{
+	const Option& option = _options.getOption(name);
+	if (option.validator())
+	{
+		option.validator()->validate(option, value);
+	}
+	if (!option.binding().empty())
+	{
+		AbstractConfiguration* pConfig = option.config();
+		if (!pConfig) pConfig = &config();
+		pConfig->setString(option.binding(), value);
+	}
+	if (option.callback())
+	{
+		option.callback()->invoke(name, value);
+	}
+}
+
+
+void Application::setLogger(Logger& logger)
+{
+	_pLogger = &logger;
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/ConfigurationMapper.cpp b/base/poco/Util/src/ConfigurationMapper.cpp
new file mode 100644
index 00000000000..d76f9c0b6da
--- /dev/null
+++ b/base/poco/Util/src/ConfigurationMapper.cpp
@@ -0,0 +1,101 @@
+//
+// ConfigurationMapper.cpp
+//
+// Library: Util
+// Package: Configuration
+// Module:  ConfigurationMapper
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/ConfigurationMapper.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+ConfigurationMapper::ConfigurationMapper(const std::string& fromPrefix, const std::string& toPrefix, AbstractConfiguration* pConfig):
+	_fromPrefix(fromPrefix),
+	_toPrefix(toPrefix),
+	_pConfig(pConfig)
+{
+	poco_check_ptr (pConfig);
+
+	if (!_fromPrefix.empty()) _fromPrefix += '.';
+	if (!_toPrefix.empty()) _toPrefix += '.';
+
+	_pConfig->duplicate();
+}
+
+
+ConfigurationMapper::~ConfigurationMapper()
+{
+	_pConfig->release();
+}
+
+
+bool ConfigurationMapper::getRaw(const std::string& key, std::string& value) const
+{
+	std::string translatedKey = translateKey(key);
+	return _pConfig->getRaw(translatedKey, value);
+}
+
+
+void ConfigurationMapper::setRaw(const std::string& key, const std::string& value)
+{
+	std::string translatedKey = translateKey(key);
+	_pConfig->setRaw(translatedKey, value); 
+}
+
+
+void ConfigurationMapper::enumerate(const std::string& key, Keys& range) const
+{
+	std::string cKey(key);
+	if (!cKey.empty()) cKey += '.';
+	std::string::size_type keyLen = cKey.length();
+	if (keyLen < _toPrefix.length())
+	{
+		if (_toPrefix.compare(0, keyLen, cKey) == 0)
+		{
+			std::string::size_type pos = _toPrefix.find_first_of('.', keyLen);
+			poco_assert_dbg(pos != std::string::npos);
+			range.push_back(_toPrefix.substr(keyLen, pos - keyLen));
+		}
+	}
+	else
+	{
+		std::string translatedKey;
+		if (cKey == _toPrefix)
+		{
+			translatedKey = _fromPrefix;
+			if (!translatedKey.empty())
+				translatedKey.resize(translatedKey.length() - 1);
+		}
+		else translatedKey = translateKey(key);
+		_pConfig->enumerate(translatedKey, range);
+	}
+}
+
+
+void ConfigurationMapper::removeRaw(const std::string& key)
+{
+	std::string translatedKey = translateKey(key);
+	_pConfig->remove(translatedKey);
+}
+
+
+std::string ConfigurationMapper::translateKey(const std::string& key) const
+{
+	std::string result(key);
+	if (result.compare(0, _toPrefix.size(), _toPrefix) == 0)
+		result.replace(0, _toPrefix.size(), _fromPrefix);
+	return result;
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/ConfigurationView.cpp b/base/poco/Util/src/ConfigurationView.cpp
new file mode 100644
index 00000000000..008a24f4896
--- /dev/null
+++ b/base/poco/Util/src/ConfigurationView.cpp
@@ -0,0 +1,75 @@
+//
+// ConfigurationView.cpp
+//
+// Library: Util
+// Package: Configuration
+// Module:  ConfigurationView
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/ConfigurationView.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+ConfigurationView::ConfigurationView(const std::string& prefix, AbstractConfiguration* pConfig):
+	_prefix(prefix),
+	_pConfig(pConfig)
+{
+	poco_check_ptr (pConfig);
+
+	_pConfig->duplicate();
+}
+
+
+ConfigurationView::~ConfigurationView()
+{
+	_pConfig->release();
+}
+
+
+bool ConfigurationView::getRaw(const std::string& key, std::string& value) const
+{
+	std::string translatedKey = translateKey(key);
+	return _pConfig->getRaw(translatedKey, value) || _pConfig->getRaw(key, value);
+}
+
+
+void ConfigurationView::setRaw(const std::string& key, const std::string& value)
+{
+	std::string translatedKey = translateKey(key);
+	_pConfig->setRaw(translatedKey, value); 
+}
+
+
+void ConfigurationView::enumerate(const std::string& key, Keys& range) const
+{
+	std::string translatedKey = translateKey(key);
+	_pConfig->enumerate(translatedKey, range);
+}
+
+
+void ConfigurationView::removeRaw(const std::string& key)
+{
+	std::string translatedKey = translateKey(key);
+	_pConfig->remove(translatedKey);
+}
+
+
+std::string ConfigurationView::translateKey(const std::string& key) const
+{
+	std::string result = _prefix;
+	if (!result.empty() && !key.empty() && key[0] != '[') result += '.';
+	result += key;
+	return result;
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/FilesystemConfiguration.cpp b/base/poco/Util/src/FilesystemConfiguration.cpp
new file mode 100644
index 00000000000..1978694a371
--- /dev/null
+++ b/base/poco/Util/src/FilesystemConfiguration.cpp
@@ -0,0 +1,127 @@
+//
+// FilesystemConfiguration.cpp
+//
+// Library: Util
+// Package: Configuration
+// Module:  FilesystemConfiguration
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/FilesystemConfiguration.h"
+#include "Poco/File.h"
+#include "Poco/Path.h"
+#include "Poco/DirectoryIterator.h"
+#include "Poco/StringTokenizer.h"
+#include "Poco/FileStream.h"
+
+
+using Poco::Path;
+using Poco::File;
+using Poco::DirectoryIterator;
+using Poco::StringTokenizer;
+
+
+namespace Poco {
+namespace Util {
+
+
+FilesystemConfiguration::FilesystemConfiguration(const std::string& path):
+	_path(path)
+{
+	_path.makeDirectory();
+}
+
+
+FilesystemConfiguration::~FilesystemConfiguration()
+{
+}
+
+
+void FilesystemConfiguration::clear()
+{
+	File regDir(_path);
+	regDir.remove(true);
+}
+
+
+bool FilesystemConfiguration::getRaw(const std::string& key, std::string& value) const
+{
+	Path p(keyToPath(key));
+	p.setFileName("data");
+	File f(p);
+	if (f.exists())
+	{
+		value.reserve((std::string::size_type) f.getSize());
+		Poco::FileInputStream istr(p.toString());
+		int c = istr.get();
+		while (c != std::char_traits<char>::eof())
+		{
+			value += (char) c;
+			c = istr.get();
+		}
+		return true;
+	}
+	else return false;
+}
+
+
+void FilesystemConfiguration::setRaw(const std::string& key, const std::string& value)
+{
+	Path p(keyToPath(key));
+	File dir(p);
+	dir.createDirectories();
+	p.setFileName("data");
+	Poco::FileOutputStream ostr(p.toString());
+	ostr.write(value.data(), (std::streamsize) value.length());
+}
+
+
+void FilesystemConfiguration::enumerate(const std::string& key, Keys& range) const
+{
+	Path p(keyToPath(key));
+	File dir(p);
+	if (!dir.exists())
+	{
+		return;
+	}
+
+	DirectoryIterator it(p);
+	DirectoryIterator end;
+	while (it != end)
+	{
+		 if (it->isDirectory())
+			range.push_back(it.name());
+		++it;
+	}
+}
+
+
+void FilesystemConfiguration::removeRaw(const std::string& key)
+{
+	Path p(keyToPath(key));
+	File dir(p);
+	if (dir.exists())
+	{
+		dir.remove(true);
+	}
+}
+
+
+Path FilesystemConfiguration::keyToPath(const std::string& key) const
+{
+	Path result(_path);
+	StringTokenizer tokenizer(key, ".", StringTokenizer::TOK_IGNORE_EMPTY | StringTokenizer::TOK_TRIM);
+	for (StringTokenizer::Iterator it = tokenizer.begin(); it != tokenizer.end(); ++it)
+	{
+		result.pushDirectory(*it);
+	}	
+	return result;
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/HelpFormatter.cpp b/base/poco/Util/src/HelpFormatter.cpp
new file mode 100644
index 00000000000..41c8d28720d
--- /dev/null
+++ b/base/poco/Util/src/HelpFormatter.cpp
@@ -0,0 +1,296 @@
+//
+// HelpFormatter.cpp
+//
+// Library: Util
+// Package: Options
+// Module:  HelpFormatter
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/HelpFormatter.h"
+#include "Poco/Util/OptionSet.h"
+#include "Poco/Util/Option.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+const int HelpFormatter::TAB_WIDTH  = 4;
+const int HelpFormatter::LINE_WIDTH = 78;
+
+
+HelpFormatter::HelpFormatter(const OptionSet& options): 
+	_options(options),
+	_width(LINE_WIDTH),
+	_indent(0),
+	_unixStyle(true)
+{
+#if !defined(POCO_OS_FAMILY_UNIX)
+	_unixStyle = false;
+#endif
+	_indent = calcIndent();
+}
+
+
+HelpFormatter::~HelpFormatter()
+{
+}
+
+
+void HelpFormatter::setCommand(const std::string& command)
+{
+	_command = command;
+}
+
+
+void HelpFormatter::setUsage(const std::string& usage)
+{
+	_usage = usage;
+}
+
+
+void HelpFormatter::setHeader(const std::string& header)
+{
+	_header = header;
+}
+
+
+void HelpFormatter::setFooter(const std::string& footer)
+{
+	_footer = footer;
+}
+
+
+void HelpFormatter::format(std::ostream& ostr) const
+{
+	ostr << "usage: " << _command;
+	if (!_usage.empty())
+	{
+		ostr << ' ';
+		formatText(ostr, _usage, (int) _command.length() + 1);
+	}
+	ostr << '\n';
+	if (!_header.empty())
+	{
+		formatText(ostr, _header, 0);
+		ostr << "\n\n";
+	}
+	formatOptions(ostr);
+	if (!_footer.empty())
+	{
+		ostr << '\n';
+		formatText(ostr, _footer, 0);
+		ostr << '\n';
+	}
+}
+
+
+void HelpFormatter::setWidth(int width)
+{
+	poco_assert (width > 0);
+	
+	_width = width;
+}
+
+
+void HelpFormatter::setIndent(int indent)
+{
+	poco_assert (indent >= 0 && indent < _width);
+	
+	_indent = indent;
+}
+
+
+void HelpFormatter::setAutoIndent()
+{
+	_indent = calcIndent();
+}
+
+
+void HelpFormatter::setUnixStyle(bool flag)
+{
+	_unixStyle = flag;
+}
+
+
+int HelpFormatter::calcIndent() const
+{
+	int indent = 0;
+	for (OptionSet::Iterator it = _options.begin(); it != _options.end(); ++it)
+	{
+		int shortLen = (int) it->shortName().length();
+		int fullLen  = (int) it->fullName().length();
+		int n = 0;
+		if (_unixStyle && shortLen > 0)
+		{
+			n += shortLen + (int) shortPrefix().length();
+			if (it->takesArgument())
+				n += (int) it->argumentName().length() + (it->argumentRequired() ? 0 : 2);
+			if (fullLen > 0) n += 2;
+		}
+		if (fullLen > 0)
+		{
+			n += fullLen + (int) longPrefix().length();
+			if (it->takesArgument())
+				n += 1 + (int) it->argumentName().length() + (it->argumentRequired() ? 0 : 2);
+		}
+		n += 2;
+		if (n > indent)
+			indent = n;
+	}
+	return indent;
+}
+
+
+void HelpFormatter::formatOptions(std::ostream& ostr) const
+{
+	int optWidth = calcIndent();
+	for (OptionSet::Iterator it = _options.begin(); it != _options.end(); ++it)
+	{
+		formatOption(ostr, *it, optWidth);
+		if (_indent < optWidth)
+		{
+			ostr << '\n' << std::string(_indent, ' ');
+			formatText(ostr, it->description(), _indent, _indent);
+		}
+		else
+		{
+			formatText(ostr, it->description(), _indent, optWidth);
+		}
+		ostr << '\n';
+	}
+}
+
+
+void HelpFormatter::formatOption(std::ostream& ostr, const Option& option, int width) const
+{
+	int shortLen = (int) option.shortName().length();
+	int fullLen  = (int) option.fullName().length();
+
+	int n = 0;
+	if (_unixStyle && shortLen > 0)
+	{
+		ostr << shortPrefix() << option.shortName();
+		n += (int) shortPrefix().length() + (int) option.shortName().length();
+		if (option.takesArgument())
+		{
+			if (!option.argumentRequired()) { ostr << '['; ++n; }
+			ostr << option.argumentName();
+			n += (int) option.argumentName().length();
+			if (!option.argumentRequired()) { ostr << ']'; ++n; }
+		}
+		if (fullLen > 0) { ostr << ", "; n += 2; }
+	}
+	if (fullLen > 0)
+	{
+		ostr << longPrefix() << option.fullName();
+		n += (int) longPrefix().length() + (int) option.fullName().length();
+		if (option.takesArgument())
+		{
+			if (!option.argumentRequired()) { ostr << '['; ++n; }
+			ostr << '=';
+			++n;
+			ostr << option.argumentName();
+			n += (int) option.argumentName().length();
+			if (!option.argumentRequired()) { ostr << ']'; ++n; }
+		}
+	}
+	while (n < width) { ostr << ' '; ++n; }
+}
+
+
+void HelpFormatter::formatText(std::ostream& ostr, const std::string& text, int indent) const
+{
+	formatText(ostr, text, indent, indent);
+}
+
+
+void HelpFormatter::formatText(std::ostream& ostr, const std::string& text, int indent, int firstIndent) const
+{
+	int pos = firstIndent;
+	int maxWordLen = _width - indent;
+	std::string word;
+	for (std::string::const_iterator it = text.begin(); it != text.end(); ++it)
+	{
+		if (*it == '\n')
+		{
+			clearWord(ostr, pos, word, indent);
+			ostr << '\n';
+			pos = 0;
+			while (pos < indent) { ostr << ' '; ++pos; }
+		}
+		else if (*it == '\t')
+		{
+			clearWord(ostr, pos, word, indent);
+			if (pos < _width) ++pos;
+			while (pos < _width && pos % TAB_WIDTH != 0)
+			{
+				ostr << ' ';
+				++pos;
+			}
+		}
+		else if (*it == ' ')
+		{
+			clearWord(ostr, pos, word, indent);
+			if (pos < _width) { ostr << ' '; ++pos; }
+		}
+		else 
+		{
+			if (word.length() == maxWordLen)
+			{
+				clearWord(ostr, pos, word, indent);
+			}
+			else word += *it;
+		}
+	}
+	clearWord(ostr, pos, word, indent);
+}
+
+
+void HelpFormatter::formatWord(std::ostream& ostr, int& pos, const std::string& word, int indent) const
+{
+	if (pos + word.length() > _width)
+	{
+		ostr << '\n';
+		pos = 0;
+		while (pos < indent) { ostr << ' '; ++pos; }
+	}
+	ostr << word;
+	pos += (int) word.length();
+}
+
+
+void HelpFormatter::clearWord(std::ostream& ostr, int& pos, std::string& word, int indent) const
+{
+	formatWord(ostr, pos, word, indent);
+	word.clear();
+}
+
+
+std::string HelpFormatter::shortPrefix() const
+{
+#if defined(POCO_OS_FAMILY_UNIX)
+	return "-";
+#else
+	return _unixStyle ? "-" : "/";
+#endif
+}
+
+
+std::string HelpFormatter::longPrefix() const
+{
+#if defined(POCO_OS_FAMILY_UNIX)
+	return "--";
+#else
+	return _unixStyle ? "--" : "/";
+#endif
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/IniFileConfiguration.cpp b/base/poco/Util/src/IniFileConfiguration.cpp
new file mode 100644
index 00000000000..76447c10ab2
--- /dev/null
+++ b/base/poco/Util/src/IniFileConfiguration.cpp
@@ -0,0 +1,190 @@
+//
+// IniFileConfiguration.cpp
+//
+// Library: Util
+// Package: Configuration
+// Module:  IniFileConfiguration
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/IniFileConfiguration.h"
+
+
+#ifndef POCO_UTIL_NO_INIFILECONFIGURATION
+
+
+#include "Poco/Exception.h"
+#include "Poco/String.h"
+#include "Poco/Path.h"
+#include "Poco/FileStream.h"
+#include "Poco/Ascii.h"
+#include <set>
+
+
+using Poco::icompare;
+using Poco::trim;
+using Poco::Path;
+
+
+namespace Poco {
+namespace Util {
+
+
+IniFileConfiguration::IniFileConfiguration()
+{
+}
+
+
+IniFileConfiguration::IniFileConfiguration(std::istream& istr)
+{
+	load(istr);
+}
+
+	
+IniFileConfiguration::IniFileConfiguration(const std::string& path)
+{
+	load(path);
+}
+
+
+IniFileConfiguration::~IniFileConfiguration()
+{
+}
+
+
+void IniFileConfiguration::load(std::istream& istr)
+{
+	_map.clear();
+	_sectionKey.clear();
+	while (!istr.eof())
+	{
+		parseLine(istr);
+	}
+}
+	
+
+void IniFileConfiguration::load(const std::string& path)
+{
+	Poco::FileInputStream istr(path);
+	if (istr.good())
+		load(istr);
+	else
+		throw Poco::OpenFileException(path);
+}
+
+
+bool IniFileConfiguration::getRaw(const std::string& key, std::string& value) const
+{
+	IStringMap::const_iterator it = _map.find(key);
+	if (it != _map.end())
+	{
+		value = it->second;
+		return true;
+	}
+	else return false;
+}
+
+
+void IniFileConfiguration::setRaw(const std::string& key, const std::string& value)
+{
+	_map[key] = value;
+}
+
+
+void IniFileConfiguration::enumerate(const std::string& key, Keys& range) const
+{
+	std::set<std::string> keys;
+	std::string prefix = key;
+	if (!prefix.empty()) prefix += '.';
+	std::string::size_type psize = prefix.size();
+	for (IStringMap::const_iterator it = _map.begin(); it != _map.end(); ++it)
+	{
+		if (icompare(it->first, psize, prefix) == 0)
+		{
+			std::string subKey;
+			std::string::size_type end = it->first.find('.', psize);
+			if (end == std::string::npos)
+				subKey = it->first.substr(psize);
+			else
+				subKey = it->first.substr(psize, end - psize);
+			if (keys.find(subKey) == keys.end())
+			{
+				range.push_back(subKey);
+				keys.insert(subKey);
+			}
+		}
+	}
+}
+
+
+void IniFileConfiguration::removeRaw(const std::string& key)
+{
+	std::string prefix = key;
+	if (!prefix.empty()) prefix += '.';
+	std::string::size_type psize = prefix.size();
+	IStringMap::iterator it = _map.begin();
+	IStringMap::iterator itCur;
+	while (it != _map.end())
+	{
+		itCur = it++;
+		if ((icompare(itCur->first, key) == 0) || (icompare(itCur->first, psize, prefix) == 0))
+		{
+			_map.erase(itCur);
+		}
+	}
+}
+
+
+bool IniFileConfiguration::ICompare::operator () (const std::string& s1, const std::string& s2) const
+{
+	return icompare(s1, s2) < 0;
+}
+
+
+void IniFileConfiguration::parseLine(std::istream& istr)
+{
+	static const int eof = std::char_traits<char>::eof(); 
+
+	int c = istr.get();
+	while (c != eof && Poco::Ascii::isSpace(c)) c = istr.get();
+	if (c != eof)
+	{
+		if (c == ';')
+		{
+			while (c != eof && c != '\n') c = istr.get();
+		}
+		else if (c == '[')
+		{
+			std::string key;
+			c = istr.get();
+			while (c != eof && c != ']' && c != '\n') { key += (char) c; c = istr.get(); }
+			_sectionKey = trim(key);
+		}
+		else
+		{
+			std::string key;
+			while (c != eof && c != '=' && c != '\n') { key += (char) c; c = istr.get(); }
+			std::string value;
+			if (c == '=')
+			{
+				c = istr.get();
+				while (c != eof && c != '\n') { value += (char) c; c = istr.get(); }
+			}
+			std::string fullKey = _sectionKey;
+			if (!fullKey.empty()) fullKey += '.';
+			fullKey.append(trim(key));
+			_map[fullKey] = trim(value);
+		}
+	}
+}
+
+
+} } // namespace Poco::Util
+
+
+#endif // POCO_UTIL_NO_INIFILECONFIGURATION
\ No newline at end of file
diff --git a/base/poco/Util/src/IntValidator.cpp b/base/poco/Util/src/IntValidator.cpp
new file mode 100644
index 00000000000..e5372ee0980
--- /dev/null
+++ b/base/poco/Util/src/IntValidator.cpp
@@ -0,0 +1,54 @@
+//
+// IntValidator.cpp
+//
+// Library: Util
+// Package: Options
+// Module:  IntValidator
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/IntValidator.h"
+#include "Poco/Util/Option.h"
+#include "Poco/Util/OptionException.h"
+#include "Poco/NumberParser.h"
+#include "Poco/Format.h"
+
+
+using Poco::NumberParser;
+using Poco::format;
+
+
+namespace Poco {
+namespace Util {
+
+
+IntValidator::IntValidator(int min, int max):
+	_min(min),
+	_max(max)
+{
+}
+
+
+IntValidator::~IntValidator()
+{
+}
+
+
+void IntValidator::validate(const Option& option, const std::string& value)
+{
+	int n;
+	if (NumberParser::tryParse(value, n))
+	{
+		if (n < _min || n > _max)
+			throw InvalidArgumentException(format("argument for %s must be in range %d to %d", option.fullName(), _min, _max));
+	}
+	else throw InvalidArgumentException(format("argument for %s must be an integer", option.fullName()));
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/JSONConfiguration.cpp b/base/poco/Util/src/JSONConfiguration.cpp
new file mode 100644
index 00000000000..282ac8ce5e6
--- /dev/null
+++ b/base/poco/Util/src/JSONConfiguration.cpp
@@ -0,0 +1,386 @@
+//
+// JSONConfiguration.cpp
+//
+// Library: Util
+// Package: JSON
+// Module:  JSONConfiguration
+//
+// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+
+#include "Poco/Util/JSONConfiguration.h"
+
+
+#ifndef POCO_UTIL_NO_JSONCONFIGURATION
+
+
+#include "Poco/FileStream.h"
+#include "Poco/StringTokenizer.h"
+#include "Poco/JSON/Parser.h"
+#include "Poco/JSON/Query.h"
+#include "Poco/RegularExpression.h"
+#include "Poco/NumberParser.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+JSONConfiguration::JSONConfiguration() : _object(new JSON::Object())
+{
+}
+
+
+JSONConfiguration::JSONConfiguration(const std::string& path)
+{
+	load(path);
+}
+
+
+JSONConfiguration::JSONConfiguration(std::istream& istr)
+{
+	load(istr);
+}
+
+
+JSONConfiguration::JSONConfiguration(const JSON::Object::Ptr& object) : _object(object)
+{
+}
+
+
+JSONConfiguration::~JSONConfiguration()
+{
+}
+
+
+void JSONConfiguration::load(const std::string& path)
+{
+	Poco::FileInputStream fis(path);
+	load(fis);
+}
+
+
+void JSONConfiguration::load(std::istream& istr)
+{
+	JSON::Parser parser;
+	parser.parse(istr);
+	DynamicAny result = parser.result();
+	if ( result.type() == typeid(JSON::Object::Ptr) )
+	{
+		_object = result.extract<JSON::Object::Ptr>();
+	}
+}
+
+
+void JSONConfiguration::loadEmpty(const std::string& root)
+{
+	_object = new JSON::Object();
+	JSON::Object::Ptr rootObject = new JSON::Object();
+	_object->set(root, rootObject);
+}
+
+
+bool JSONConfiguration::getRaw(const std::string & key, std::string & value) const
+{
+	JSON::Query query(_object);
+	Poco::DynamicAny result = query.find(key);
+	if ( ! result.isEmpty() )
+	{
+		value = result.convert<std::string>();
+		return true;
+	}
+	return false;
+}
+
+
+void JSONConfiguration::getIndexes(std::string& name, std::vector<int>& indexes)
+{
+	indexes.clear();
+
+	RegularExpression::MatchVec matches;
+	int firstOffset = -1;
+	int offset = 0;
+	RegularExpression regex("\\[([0-9]+)\\]");
+	while(regex.match(name, offset, matches) > 0 )
+	{
+		if ( firstOffset == -1 )
+		{
+			firstOffset = static_cast<int>(matches[0].offset);
+		}
+		std::string num = name.substr(matches[1].offset, matches[1].length);
+		indexes.push_back(NumberParser::parse(num));
+		offset = static_cast<int>(matches[0].offset + matches[0].length);
+	}
+
+	if ( firstOffset != -1 )
+	{
+		name = name.substr(0, firstOffset);
+	}
+}
+
+
+JSON::Object::Ptr JSONConfiguration::findStart(const std::string& key, std::string& lastPart)
+{
+	JSON::Object::Ptr currentObject = _object;
+
+	StringTokenizer tokenizer(key, ".");
+	lastPart = tokenizer[tokenizer.count() - 1];
+
+	for(int i = 0; i < tokenizer.count() - 1; ++i)
+	{
+		std::vector<int> indexes;
+		std::string name = tokenizer[i];
+		getIndexes(name, indexes);
+
+		DynamicAny result = currentObject->get(name);
+
+		if ( result.isEmpty() ) // Not found
+		{
+			if ( indexes.empty() ) // We want an object, create it
+			{
+				JSON::Object::Ptr newObject = new JSON::Object();
+				currentObject->set(name, newObject);
+				currentObject = newObject;
+			}
+			else // We need an array
+			{
+				JSON::Array::Ptr newArray;
+				JSON::Array::Ptr parentArray;
+				JSON::Array::Ptr topArray;
+				for(std::vector<int>::iterator it = indexes.begin(); it != indexes.end(); ++it)
+				{
+					newArray = new JSON::Array();
+					if ( topArray.isNull() )
+					{
+						topArray = newArray;
+					}
+
+					if ( ! parentArray.isNull() )
+					{
+						parentArray->add(newArray);
+					}
+
+					for(int i = 0; i <= *it - 1; ++i)
+					{
+						Poco::DynamicAny nullValue;
+						newArray->add(nullValue);
+					}
+
+					parentArray = newArray;
+				}
+
+				currentObject->set(name, topArray);
+				currentObject = new JSON::Object();
+				newArray->add(currentObject);
+			}
+		}
+		else // We have a value
+		{
+			if ( indexes.empty() ) // We want an object
+			{
+				if ( result.type() == typeid(JSON::Object::Ptr) )
+				{
+					currentObject = result.extract<JSON::Object::Ptr>();
+				}
+				else
+				{
+					throw SyntaxException("Expected a JSON object");
+				}
+			}
+			else
+			{
+				if ( result.type() == typeid(JSON::Array::Ptr) )
+				{
+					JSON::Array::Ptr arr = result.extract<JSON::Array::Ptr>();
+
+					for(std::vector<int>::iterator it = indexes.begin(); it != indexes.end() - 1; ++it)
+					{
+						JSON::Array::Ptr currentArray = arr;
+						arr = arr->getArray(*it);
+						if ( arr.isNull() )
+						{
+							arr = new JSON::Array();
+							currentArray->add(arr);
+						}
+					}
+
+					result = arr->get(*indexes.rbegin());
+					if ( result.isEmpty() ) // Index doesn't exist
+					{
+						JSON::Object::Ptr newObject = new JSON::Object();
+						arr->add(newObject);
+						currentObject = newObject;
+					}
+					else // Index is available
+					{
+						if ( result.type() == typeid(JSON::Object::Ptr) )
+						{
+							currentObject = result.extract<JSON::Object::Ptr>();
+						}
+						else
+						{
+							throw SyntaxException("Expected a JSON object");
+						}
+					}
+				}
+				else
+				{
+					throw SyntaxException("Expected a JSON array");
+				}
+			}
+		}
+	}
+	return currentObject;
+}
+
+
+void JSONConfiguration::setValue(const std::string& key, const Poco::DynamicAny& value)
+{
+
+	std::string sValue;
+	
+	value.convert<std::string>(sValue);
+	KeyValue kv(key, sValue);
+	
+	if (eventsEnabled())
+	{
+		propertyChanging(this, kv);
+	}
+	
+	std::string lastPart;
+	JSON::Object::Ptr parentObject = findStart(key, lastPart);
+
+	std::vector<int> indexes;
+	getIndexes(lastPart, indexes);
+
+	if ( indexes.empty() ) // No Array
+	{
+		parentObject->set(lastPart, value);
+	}
+	else
+	{
+		DynamicAny result = parentObject->get(lastPart);
+		if ( result.isEmpty() )
+		{
+			result = JSON::Array::Ptr(new JSON::Array());
+			parentObject->set(lastPart, result);
+		}
+		else if ( result.type() != typeid(JSON::Array::Ptr) )
+		{
+			throw SyntaxException("Expected a JSON array");
+		}
+
+		JSON::Array::Ptr arr = result.extract<JSON::Array::Ptr>();
+		for(std::vector<int>::iterator it = indexes.begin(); it != indexes.end() - 1; ++it)
+		{
+			JSON::Array::Ptr nextArray = arr->getArray(*it);
+			if ( nextArray.isNull()  )
+			{
+				for(int i = static_cast<int>(arr->size()); i <= *it; ++i)
+				{
+					Poco::DynamicAny nullValue;
+					arr->add(nullValue);
+				}
+				nextArray = new JSON::Array();
+				arr->add(nextArray);
+			}
+			arr = nextArray;
+		}
+		arr->set(indexes.back(), value);
+	}
+
+	if (eventsEnabled())
+	{
+		propertyChanged(this, kv);
+	}
+}
+
+
+void JSONConfiguration::setString(const std::string& key, const std::string& value)
+{
+	setValue(key, value);
+}
+
+
+void JSONConfiguration::setRaw(const std::string& key, const std::string& value)
+{
+	setValue(key, value);
+}
+
+
+void JSONConfiguration::setInt(const std::string& key, int value)
+{
+	setValue(key, value);
+}
+
+
+void JSONConfiguration::setBool(const std::string& key, bool value)
+{
+	setValue(key, value);
+}
+
+
+void JSONConfiguration::setDouble(const std::string& key, double value)
+{
+	setValue(key, value);
+}
+
+
+void JSONConfiguration::enumerate(const std::string& key, Keys& range) const
+{
+	JSON::Query query(_object);
+	Poco::DynamicAny result = query.find(key);
+	if ( result.type() == typeid(JSON::Object::Ptr) )
+	{
+		JSON::Object::Ptr object = result.extract<JSON::Object::Ptr>();
+		object->getNames(range);
+	}
+}
+
+
+void JSONConfiguration::save(std::ostream& ostr, unsigned int indent) const
+{
+	_object->stringify(ostr, indent);
+}
+
+
+void JSONConfiguration::removeRaw(const std::string& key)
+
+{
+	
+	std::string lastPart;
+	JSON::Object::Ptr parentObject = findStart(key, lastPart);
+	std::vector<int> indexes;
+	getIndexes(lastPart, indexes);
+
+	if ( indexes.empty() ) // No Array
+	{
+		parentObject->remove(lastPart);
+	}
+	else
+	{
+		DynamicAny result = parentObject->get(lastPart);
+		if (!result.isEmpty() && result.type() == typeid(JSON::Array::Ptr))
+		{
+
+			JSON::Array::Ptr arr = result.extract<JSON::Array::Ptr>();
+			for(std::vector<int>::iterator it = indexes.begin(); it != indexes.end() - 1; ++it)
+			{
+				arr = arr->getArray(*it);
+			}
+			arr->remove(indexes.back());
+		}
+	}
+
+}
+
+
+} } // namespace Poco::Util
+
+
+#endif // POCO_UTIL_NO_JSONCONFIGURATION
diff --git a/base/poco/Util/src/LayeredConfiguration.cpp b/base/poco/Util/src/LayeredConfiguration.cpp
new file mode 100644
index 00000000000..1cbd5d78477
--- /dev/null
+++ b/base/poco/Util/src/LayeredConfiguration.cpp
@@ -0,0 +1,233 @@
+//
+// LayeredConfiguration.cpp
+//
+// Library: Util
+// Package: Configuration
+// Module:  LayeredConfiguration
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/LayeredConfiguration.h"
+#include "Poco/Exception.h"
+#include <set>
+
+
+using Poco::AutoPtr;
+using Poco::RuntimeException;
+
+
+namespace Poco {
+namespace Util {
+
+
+LayeredConfiguration::LayeredConfiguration()
+{
+}
+
+
+LayeredConfiguration::~LayeredConfiguration()
+{
+}
+
+
+void LayeredConfiguration::add(AbstractConfiguration* pConfig)
+{
+	add(pConfig, highest(), false, true);
+}
+
+
+void LayeredConfiguration::add(AbstractConfiguration* pConfig, const std::string& label)
+{
+	add(pConfig, label, highest(), false, true);
+}
+
+
+void LayeredConfiguration::add(AbstractConfiguration* pConfig, bool shared)
+{
+	add(pConfig, highest(), false, shared);
+}
+
+
+void LayeredConfiguration::add(AbstractConfiguration* pConfig, const std::string& label, bool shared)
+{
+	add(pConfig, label, highest(), false, shared);
+}
+
+
+void LayeredConfiguration::add(AbstractConfiguration* pConfig, int priority)
+{
+	add(pConfig, priority, false, true);
+}
+
+
+void LayeredConfiguration::add(AbstractConfiguration* pConfig, const std::string& label, int priority)
+{
+	add(pConfig, label, priority, false, true);
+}
+
+
+void LayeredConfiguration::add(AbstractConfiguration* pConfig, int priority, bool shared)
+{
+	add(pConfig, priority, false, shared);
+}
+
+
+void LayeredConfiguration::add(AbstractConfiguration* pConfig, const std::string& label, int priority, bool shared)
+{
+	add(pConfig, label, priority, false, shared);
+}
+
+
+void LayeredConfiguration::addFront(AbstractConfiguration* pConfig)
+{
+	add(pConfig, lowest(), false, true);
+}
+
+
+void LayeredConfiguration::addFront(AbstractConfiguration* pConfig, bool shared)
+{
+	add(pConfig, lowest(), false, shared);
+}
+
+
+void LayeredConfiguration::addWriteable(AbstractConfiguration* pConfig, int priority)
+{
+	add(pConfig, priority, true, true);
+}
+
+
+void LayeredConfiguration::addWriteable(AbstractConfiguration* pConfig, int priority, bool shared)
+{
+	add(pConfig, priority, true, shared);
+}
+
+
+void LayeredConfiguration::add(AbstractConfiguration* pConfig, int priority, bool writeable, bool shared)
+{
+	add(pConfig, std::string(), priority, writeable, shared);
+}
+
+
+void LayeredConfiguration::add(AbstractConfiguration* pConfig, const std::string& label, int priority, bool writeable, bool shared)
+{
+	ConfigItem item;
+	item.pConfig   = ConfigPtr(pConfig, shared);
+	item.priority  = priority;
+	item.writeable = writeable;
+	item.label     = label;
+	
+	ConfigList::iterator it = _configs.begin();
+	while (it != _configs.end() && it->priority < priority)
+		++it;
+		
+	_configs.insert(it, item);
+}
+
+
+void LayeredConfiguration::removeConfiguration(AbstractConfiguration* pConfig)
+{
+	for (ConfigList::iterator it = _configs.begin(); it != _configs.end(); ++it)
+	{
+		if (it->pConfig == pConfig)
+		{
+			_configs.erase(it);
+			break;
+		}
+	}
+}
+
+
+LayeredConfiguration::ConfigPtr LayeredConfiguration::find(const std::string& label) const
+{
+	for (ConfigList::const_iterator it = _configs.begin(); it != _configs.end(); ++it)
+	{
+		if (it->label == label)
+		{
+			return it->pConfig;
+		}
+	}
+	return 0;
+}
+
+
+bool LayeredConfiguration::getRaw(const std::string& key, std::string& value) const
+{
+	for (ConfigList::const_iterator it = _configs.begin(); it != _configs.end(); ++it)
+	{
+		if (it->pConfig->getRaw(key, value))
+			return true;
+	}
+	return false;
+}
+
+
+void LayeredConfiguration::setRaw(const std::string& key, const std::string& value)
+{
+	for (ConfigList::iterator it = _configs.begin(); it != _configs.end(); ++it)
+	{
+		if (it->writeable)
+		{
+			it->pConfig->setRaw(key, value);
+			return;
+		}
+	}
+	throw RuntimeException("No writeable configuration object to store the property", key);
+}
+
+
+void LayeredConfiguration::enumerate(const std::string& key, Keys& range) const
+{
+	std::set<std::string> keys;
+	for (ConfigList::const_iterator itc = _configs.begin(); itc != _configs.end(); ++itc)
+	{
+		Keys partRange;
+		itc->pConfig->enumerate(key, partRange);
+		for (Keys::const_iterator itr = partRange.begin(); itr != partRange.end(); ++itr)
+		{
+			if (keys.find(*itr) == keys.end())
+			{
+				range.push_back(*itr);
+				keys.insert(*itr);
+			}
+		}
+	}
+}
+
+
+void LayeredConfiguration::removeRaw(const std::string& key)
+{
+	for (ConfigList::iterator it = _configs.begin(); it != _configs.end(); ++it)
+	{
+		if (it->writeable)
+		{
+			it->pConfig->remove(key);
+			return;
+		}
+	}
+}
+
+
+int LayeredConfiguration::lowest() const
+{
+	if (_configs.empty())
+		return 0;
+	else
+		return _configs.front().priority - 1;
+}
+
+
+int LayeredConfiguration::highest() const
+{
+	if (_configs.empty())
+		return 0;
+	else
+		return _configs.back().priority + 1;
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/LoggingConfigurator.cpp b/base/poco/Util/src/LoggingConfigurator.cpp
new file mode 100644
index 00000000000..82b9d7d3319
--- /dev/null
+++ b/base/poco/Util/src/LoggingConfigurator.cpp
@@ -0,0 +1,203 @@
+//
+// LoggingConfigurator.cpp
+//
+// Library: Util
+// Package: Configuration
+// Module:  LoggingConfigurator
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/LoggingConfigurator.h"
+#include "Poco/Util/AbstractConfiguration.h"
+#include "Poco/AutoPtr.h"
+#include "Poco/Channel.h"
+#include "Poco/FormattingChannel.h"
+#include "Poco/Formatter.h"
+#include "Poco/PatternFormatter.h"
+#include "Poco/Logger.h"
+#include "Poco/LoggingRegistry.h"
+#include "Poco/LoggingFactory.h"
+#include <map>
+
+
+using Poco::AutoPtr;
+using Poco::Formatter;
+using Poco::PatternFormatter;
+using Poco::Channel;
+using Poco::FormattingChannel;
+using Poco::Logger;
+using Poco::LoggingRegistry;
+using Poco::LoggingFactory;
+
+
+namespace Poco {
+namespace Util {
+
+
+LoggingConfigurator::LoggingConfigurator()
+{
+}
+
+
+LoggingConfigurator::~LoggingConfigurator()
+{
+}
+
+
+void LoggingConfigurator::configure(AbstractConfiguration* pConfig)
+{
+	poco_check_ptr (pConfig);
+
+	AutoPtr<AbstractConfiguration> pFormattersConfig(pConfig->createView("logging.formatters"));
+	configureFormatters(pFormattersConfig);
+
+	AutoPtr<AbstractConfiguration> pChannelsConfig(pConfig->createView("logging.channels"));
+	configureChannels(pChannelsConfig);
+
+	AutoPtr<AbstractConfiguration> pLoggersConfig(pConfig->createView("logging.loggers"));
+	configureLoggers(pLoggersConfig);
+}
+
+
+void LoggingConfigurator::configureFormatters(AbstractConfiguration* pConfig)
+{
+	AbstractConfiguration::Keys formatters;
+	pConfig->keys(formatters);
+	for (AbstractConfiguration::Keys::const_iterator it = formatters.begin(); it != formatters.end(); ++it)
+	{
+		AutoPtr<AbstractConfiguration> pFormatterConfig(pConfig->createView(*it));
+		AutoPtr<Formatter> pFormatter(createFormatter(pFormatterConfig));
+		LoggingRegistry::defaultRegistry().registerFormatter(*it, pFormatter);
+	}
+}
+
+
+void LoggingConfigurator::configureChannels(AbstractConfiguration* pConfig)
+{
+	AbstractConfiguration::Keys channels;
+	pConfig->keys(channels);
+	for (AbstractConfiguration::Keys::const_iterator it = channels.begin(); it != channels.end(); ++it)
+	{
+		AutoPtr<AbstractConfiguration> pChannelConfig(pConfig->createView(*it));
+		AutoPtr<Channel> pChannel = createChannel(pChannelConfig);
+		LoggingRegistry::defaultRegistry().registerChannel(*it, pChannel);
+	}
+	for (AbstractConfiguration::Keys::const_iterator it = channels.begin(); it != channels.end(); ++it)
+	{
+		AutoPtr<AbstractConfiguration> pChannelConfig(pConfig->createView(*it));
+		Channel* pChannel = LoggingRegistry::defaultRegistry().channelForName(*it);
+		configureChannel(pChannel, pChannelConfig);
+	}
+}
+
+
+void LoggingConfigurator::configureLoggers(AbstractConfiguration* pConfig)
+{
+	typedef std::map<std::string, AutoPtr<AbstractConfiguration> > LoggerMap;
+
+	AbstractConfiguration::Keys loggers;
+	pConfig->keys(loggers);
+	// use a map to sort loggers by their name, ensuring initialization in correct order (parents before children)
+	LoggerMap loggerMap; 
+	for (AbstractConfiguration::Keys::const_iterator it = loggers.begin(); it != loggers.end(); ++it)
+	{
+		AutoPtr<AbstractConfiguration> pLoggerConfig(pConfig->createView(*it));
+		loggerMap[pLoggerConfig->getString("name", "")] = pLoggerConfig;
+	}
+	for (LoggerMap::iterator it = loggerMap.begin(); it != loggerMap.end(); ++it)
+	{
+		configureLogger(it->second);
+	}
+}
+
+
+Formatter* LoggingConfigurator::createFormatter(AbstractConfiguration* pConfig)
+{
+	AutoPtr<Formatter> pFormatter(LoggingFactory::defaultFactory().createFormatter(pConfig->getString("class")));
+	AbstractConfiguration::Keys props;
+	pConfig->keys(props);
+	for (AbstractConfiguration::Keys::const_iterator it = props.begin(); it != props.end(); ++it)
+	{
+		if (*it != "class")
+			pFormatter->setProperty(*it, pConfig->getString(*it));		
+	}
+	return pFormatter.duplicate();
+}
+
+
+Channel* LoggingConfigurator::createChannel(AbstractConfiguration* pConfig)
+{
+	AutoPtr<Channel> pChannel(LoggingFactory::defaultFactory().createChannel(pConfig->getString("class")));
+	AutoPtr<Channel> pWrapper(pChannel);
+	AbstractConfiguration::Keys props;
+	pConfig->keys(props);
+	for (AbstractConfiguration::Keys::const_iterator it = props.begin(); it != props.end(); ++it)
+	{
+		if (*it == "pattern")
+		{
+			AutoPtr<Formatter> pPatternFormatter(new PatternFormatter(pConfig->getString(*it)));
+			pWrapper = new FormattingChannel(pPatternFormatter, pChannel);
+		}
+		else if (*it == "formatter")
+		{
+			AutoPtr<FormattingChannel> pFormattingChannel(new FormattingChannel(0, pChannel));
+			if (pConfig->hasProperty("formatter.class"))
+			{
+				AutoPtr<AbstractConfiguration> pFormatterConfig(pConfig->createView(*it));	
+				AutoPtr<Formatter> pFormatter(createFormatter(pFormatterConfig));
+				pFormattingChannel->setFormatter(pFormatter);
+			}
+			else pFormattingChannel->setProperty(*it, pConfig->getString(*it));
+#if defined(__GNUC__) && __GNUC__ < 3
+			pWrapper = pFormattingChannel.duplicate();
+#else
+			pWrapper = pFormattingChannel;
+#endif
+		}
+	}
+	return pWrapper.duplicate();
+}
+
+
+void LoggingConfigurator::configureChannel(Channel* pChannel, AbstractConfiguration* pConfig)
+{
+	AbstractConfiguration::Keys props;
+	pConfig->keys(props);
+	for (AbstractConfiguration::Keys::const_iterator it = props.begin(); it != props.end(); ++it)
+	{
+		if (*it != "pattern" && *it != "formatter" && *it != "class")
+		{
+			pChannel->setProperty(*it, pConfig->getString(*it));
+		}
+	}
+}
+
+
+void LoggingConfigurator::configureLogger(AbstractConfiguration* pConfig)
+{
+	Logger& logger = Logger::get(pConfig->getString("name", ""));
+	AbstractConfiguration::Keys props;
+	pConfig->keys(props);
+	for (AbstractConfiguration::Keys::const_iterator it = props.begin(); it != props.end(); ++it)
+	{
+		if (*it == "channel" && pConfig->hasProperty("channel.class"))
+		{
+			AutoPtr<AbstractConfiguration> pChannelConfig(pConfig->createView(*it));	
+			AutoPtr<Channel> pChannel(createChannel(pChannelConfig));
+			configureChannel(pChannel, pChannelConfig);
+			Logger::setChannel(logger.name(), pChannel);
+		}
+		else if (*it != "name")
+		{
+			Logger::setProperty(logger.name(), *it, pConfig->getString(*it));
+		}
+	}
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/LoggingSubsystem.cpp b/base/poco/Util/src/LoggingSubsystem.cpp
new file mode 100644
index 00000000000..08d51a32e1d
--- /dev/null
+++ b/base/poco/Util/src/LoggingSubsystem.cpp
@@ -0,0 +1,58 @@
+//
+// LoggingSubsystem.cpp
+//
+// Library: Util
+// Package: Application
+// Module:  LoggingSubsystem
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/LoggingSubsystem.h"
+#include "Poco/Util/LoggingConfigurator.h"
+#include "Poco/Util/Application.h"
+#include "Poco/Logger.h"
+
+
+using Poco::Logger;
+
+
+namespace Poco {
+namespace Util {
+
+
+LoggingSubsystem::LoggingSubsystem()
+{
+}
+
+
+LoggingSubsystem::~LoggingSubsystem()
+{
+}
+
+
+const char* LoggingSubsystem::name() const
+{
+	return "Logging Subsystem";
+}
+
+	
+void LoggingSubsystem::initialize(Application& app)
+{
+	LoggingConfigurator configurator;
+	configurator.configure(&app.config());
+	std::string logger = app.config().getString("application.logger", "Application");
+	app.setLogger(Logger::get(logger));
+}
+
+
+void LoggingSubsystem::uninitialize()
+{
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/MapConfiguration.cpp b/base/poco/Util/src/MapConfiguration.cpp
new file mode 100644
index 00000000000..480956ba36a
--- /dev/null
+++ b/base/poco/Util/src/MapConfiguration.cpp
@@ -0,0 +1,122 @@
+//
+// MapConfiguration.cpp
+//
+// Library: Util
+// Package: Configuration
+// Module:  MapConfiguration
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/MapConfiguration.h"
+#include <set>
+
+
+namespace Poco {
+namespace Util {
+
+
+MapConfiguration::MapConfiguration()
+{
+}
+
+
+MapConfiguration::~MapConfiguration()
+{
+}
+
+
+void MapConfiguration::copyTo(AbstractConfiguration& config)
+{
+	for (iterator it = _map.begin(); it != _map.end(); ++it)
+	{
+		config.setString(it->first, it->second);
+	}
+}
+
+
+void MapConfiguration::clear()
+{
+	_map.clear();
+}
+
+
+bool MapConfiguration::getRaw(const std::string& key, std::string& value) const
+{
+	StringMap::const_iterator it = _map.find(key);
+	if (it != _map.end())
+	{
+		value = it->second;
+		return true;
+	}
+	else return false;
+}
+
+
+void MapConfiguration::setRaw(const std::string& key, const std::string& value)
+{
+	_map[key] = value;
+}
+
+
+void MapConfiguration::enumerate(const std::string& key, Keys& range) const
+{
+	std::set<std::string> keys;
+	std::string prefix = key;
+	if (!prefix.empty()) prefix += '.';
+	std::string::size_type psize = prefix.size();
+	for (StringMap::const_iterator it = _map.begin(); it != _map.end(); ++it)
+	{
+		if (it->first.compare(0, psize, prefix) == 0)
+		{
+			std::string subKey;
+			std::string::size_type end = it->first.find('.', psize);
+			if (end == std::string::npos)
+				subKey = it->first.substr(psize);
+			else
+				subKey = it->first.substr(psize, end - psize);
+			if (keys.find(subKey) == keys.end())
+			{
+				range.push_back(subKey);
+				keys.insert(subKey);
+			}
+		}
+	}
+}
+
+
+void MapConfiguration::removeRaw(const std::string& key)
+{
+	std::string prefix = key;
+	if (!prefix.empty()) prefix += '.';
+	std::string::size_type psize = prefix.size();
+	StringMap::iterator it = _map.begin();
+	StringMap::iterator itCur;
+	while (it != _map.end())
+	{
+		itCur = it++;
+		if ((itCur->first == key) || (itCur->first.compare(0, psize, prefix) == 0))
+		{
+			_map.erase(itCur);
+		}
+	}
+}
+
+
+MapConfiguration::iterator MapConfiguration::begin() const
+{
+	return _map.begin();
+}
+
+
+MapConfiguration::iterator MapConfiguration::end() const
+{
+	return _map.end();
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/Option.cpp b/base/poco/Util/src/Option.cpp
new file mode 100644
index 00000000000..cdf33ec0672
--- /dev/null
+++ b/base/poco/Util/src/Option.cpp
@@ -0,0 +1,292 @@
+//
+// Option.cpp
+//
+// Library: Util
+// Package: Options
+// Module:  Option
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/Option.h"
+#include "Poco/Util/OptionException.h"
+#include "Poco/Util/Validator.h"
+#include "Poco/Util/AbstractConfiguration.h"
+#include "Poco/String.h"
+#include <algorithm>
+
+
+using Poco::icompare;
+
+
+namespace Poco {
+namespace Util {
+
+
+Option::Option(): 
+	_required(false), 
+	_repeatable(false), 
+	_argRequired(false),
+	_pValidator(0),
+	_pCallback(0),
+	_pConfig(0)
+{
+}
+
+
+Option::Option(const Option& option):
+	_shortName(option._shortName),
+	_fullName(option._fullName),
+	_description(option._description),
+	_required(option._required),
+	_repeatable(option._repeatable),
+	_argName(option._argName),
+	_argRequired(option._argRequired),
+	_group(option._group),
+	_binding(option._binding),
+	_pValidator(option._pValidator),
+	_pCallback(option._pCallback),
+	_pConfig(option._pConfig)
+{
+	if (_pValidator) _pValidator->duplicate();
+	if (_pCallback) _pCallback = _pCallback->clone();
+	if (_pConfig) _pConfig->duplicate();
+}
+
+
+Option::Option(const std::string& fullName, const std::string& shortName):
+	_shortName(shortName),
+	_fullName(fullName),
+	_required(false),
+	_repeatable(false),
+	_argRequired(false),
+	_pValidator(0),
+	_pCallback(0),
+	_pConfig(0)
+{
+}
+
+
+Option::Option(const std::string& fullName, const std::string& shortName, const std::string& description, bool required):
+	_shortName(shortName),
+	_fullName(fullName),
+	_description(description),
+	_required(required),
+	_repeatable(false),
+	_argRequired(false),
+	_pValidator(0),
+	_pCallback(0),
+	_pConfig(0)
+{
+}
+
+
+Option::Option(const std::string& fullName, const std::string& shortName, const std::string& description, bool required, const std::string& argName, bool argRequired):
+	_shortName(shortName),
+	_fullName(fullName),
+	_description(description),
+	_required(required),
+	_repeatable(false),
+	_argName(argName),
+	_argRequired(argRequired),
+	_pValidator(0),
+	_pCallback(0),
+	_pConfig(0)
+{
+}
+
+
+Option::~Option()
+{
+	if (_pValidator) _pValidator->release();
+	if (_pConfig) _pConfig->release();
+	delete _pCallback;
+}
+
+
+Option& Option::operator = (const Option& option)
+{
+	if (&option != this)
+	{
+		Option tmp(option);
+		swap(tmp);
+	}
+	return *this;
+}
+
+
+void Option::swap(Option& option)
+{
+	std::swap(_shortName, option._shortName);
+	std::swap(_fullName, option._fullName);
+	std::swap(_description, option._description);
+	std::swap(_required, option._required);
+	std::swap(_repeatable, option._repeatable);
+	std::swap(_argName, option._argName);
+	std::swap(_argRequired, option._argRequired);
+	std::swap(_group, option._group);
+	std::swap(_binding, option._binding);
+	std::swap(_pValidator, option._pValidator);
+	std::swap(_pCallback, option._pCallback);
+	std::swap(_pConfig, option._pConfig);
+}
+
+	
+Option& Option::shortName(const std::string& name)
+{
+	_shortName = name;
+	return *this;
+}
+
+
+Option& Option::fullName(const std::string& name)
+{
+	_fullName = name;
+	return *this;
+}
+
+	
+Option& Option::description(const std::string& text)
+{
+	_description = text;
+	return *this;
+}
+
+	
+Option& Option::required(bool flag)
+{
+	_required = flag;
+	return *this;
+}
+
+
+Option& Option::repeatable(bool flag)
+{
+	_repeatable = flag;
+	return *this;
+}
+
+	
+Option& Option::argument(const std::string& name, bool required)
+{
+	_argName     = name;
+	_argRequired = required;
+	return *this;
+}
+
+	
+Option& Option::noArgument()
+{
+	_argName.clear();
+	_argRequired = false;
+	return *this;
+}
+
+
+Option& Option::group(const std::string& group)
+{
+	_group = group;
+	return *this;
+}
+
+
+Option& Option::binding(const std::string& propertyName)
+{
+	return binding(propertyName, 0);
+}
+
+
+Option& Option::binding(const std::string& propertyName, AbstractConfiguration* pConfig)
+{
+	_binding = propertyName;
+	if (_pConfig) _pConfig->release();
+	_pConfig = pConfig;
+	if (_pConfig) _pConfig->duplicate();
+	return *this;
+}
+
+
+Option& Option::callback(const AbstractOptionCallback& cb)
+{
+	_pCallback = cb.clone();
+	return *this;
+}
+
+
+Option& Option::validator(Validator* pValidator)
+{
+	if (_pValidator) _pValidator->release();
+	_pValidator = pValidator;
+	return *this;
+}
+
+
+bool Option::matchesShort(const std::string& option) const
+{
+	return option.length() > 0 
+		&& !_shortName.empty() && option.compare(0, _shortName.length(), _shortName) == 0;
+}
+
+
+bool Option::matchesFull(const std::string& option) const
+{
+	std::string::size_type pos = option.find_first_of(":=");
+	std::string::size_type len = pos == std::string::npos ? option.length() : pos;
+	return len == _fullName.length()
+		&& icompare(option, 0, len, _fullName, 0, len) == 0;
+}
+
+
+bool Option::matchesPartial(const std::string& option) const
+{
+	std::string::size_type pos = option.find_first_of(":=");
+	std::string::size_type len = pos == std::string::npos ? option.length() : pos;
+	return option.length() > 0 
+		&& icompare(option, 0, len, _fullName, 0, len) == 0;
+}
+
+
+void Option::process(const std::string& option, std::string& arg) const
+{
+	std::string::size_type pos = option.find_first_of(":=");
+	std::string::size_type len = pos == std::string::npos ? option.length() : pos;
+	if (icompare(option, 0, len, _fullName, 0, len) == 0)
+	{
+		if (takesArgument())
+		{
+			if (argumentRequired() && pos == std::string::npos)
+				throw MissingArgumentException(_fullName + " requires " + argumentName());
+			if (pos != std::string::npos)
+				arg.assign(option, pos + 1, option.length() - pos - 1);
+			else
+				arg.clear();
+		}
+		else if (pos != std::string::npos)
+		{
+			throw UnexpectedArgumentException(option);
+		}
+		else arg.clear();
+	}
+	else if (!_shortName.empty() && option.compare(0, _shortName.length(), _shortName) == 0)
+	{
+		if (takesArgument())
+		{
+			if (argumentRequired() && option.length() == _shortName.length())
+				throw MissingArgumentException(_shortName + " requires " + argumentName());
+			arg.assign(option, _shortName.length(), option.length() - _shortName.length());
+		}
+		else if (option.length() != _shortName.length())
+		{
+			throw UnexpectedArgumentException(option);
+		}
+		else arg.clear();
+	}
+	else throw UnknownOptionException(option);
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/OptionCallback.cpp b/base/poco/Util/src/OptionCallback.cpp
new file mode 100644
index 00000000000..f9fdfc33d0a
--- /dev/null
+++ b/base/poco/Util/src/OptionCallback.cpp
@@ -0,0 +1,37 @@
+//
+// OptionCallback.cpp
+//
+// Library: Util
+// Package: Options
+// Module:  OptionCallback
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/OptionCallback.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+AbstractOptionCallback::AbstractOptionCallback()
+{
+}
+
+
+AbstractOptionCallback::AbstractOptionCallback(const AbstractOptionCallback&)
+{
+}
+
+
+AbstractOptionCallback::~AbstractOptionCallback()
+{
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/OptionException.cpp b/base/poco/Util/src/OptionException.cpp
new file mode 100644
index 00000000000..cda4ed0b2d7
--- /dev/null
+++ b/base/poco/Util/src/OptionException.cpp
@@ -0,0 +1,35 @@
+//
+// OptionException.cpp
+//
+// Library: Util
+// Package: Options
+// Module:  OptionException
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/OptionException.h"
+#include <typeinfo>
+
+
+namespace Poco {
+namespace Util {
+
+
+POCO_IMPLEMENT_EXCEPTION(OptionException, Poco::DataException, "Option exception")
+POCO_IMPLEMENT_EXCEPTION(UnknownOptionException, OptionException, "Unknown option specified")
+POCO_IMPLEMENT_EXCEPTION(AmbiguousOptionException, OptionException, "Ambiguous option specified")
+POCO_IMPLEMENT_EXCEPTION(MissingOptionException, OptionException, "Required option not specified")
+POCO_IMPLEMENT_EXCEPTION(MissingArgumentException, OptionException, "Missing option argument")
+POCO_IMPLEMENT_EXCEPTION(InvalidArgumentException, OptionException, "Invalid option argument")
+POCO_IMPLEMENT_EXCEPTION(UnexpectedArgumentException, OptionException, "Unexpected option argument")
+POCO_IMPLEMENT_EXCEPTION(IncompatibleOptionsException, OptionException, "Incompatible options")
+POCO_IMPLEMENT_EXCEPTION(DuplicateOptionException, OptionException, "Option must not be given more than once")
+POCO_IMPLEMENT_EXCEPTION(EmptyOptionException, OptionException, "Empty option specified")
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/OptionProcessor.cpp b/base/poco/Util/src/OptionProcessor.cpp
new file mode 100644
index 00000000000..f9c3dc68dad
--- /dev/null
+++ b/base/poco/Util/src/OptionProcessor.cpp
@@ -0,0 +1,159 @@
+//
+// OptionProcessor.cpp
+//
+// Library: Util
+// Package: Options
+// Module:  OptionProcessor
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/OptionProcessor.h"
+#include "Poco/Util/OptionSet.h"
+#include "Poco/Util/Option.h"
+#include "Poco/Util/OptionException.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+OptionProcessor::OptionProcessor(const OptionSet& options): 
+	_options(options),
+	_unixStyle(true),
+	_ignore(false)
+{
+}
+
+
+OptionProcessor::~OptionProcessor()
+{
+}
+
+
+void OptionProcessor::setUnixStyle(bool flag)
+{
+	_unixStyle = flag;
+}
+
+
+bool OptionProcessor::process(const std::string& argument, std::string& optionName, std::string& optionArg)
+{
+	optionName.clear();
+	optionArg.clear();
+	if (!_ignore)
+	{
+		if (!_deferredOption.empty())
+			return processCommon(argument, false, optionName, optionArg);
+		else if (_unixStyle)
+			return processUnix(argument, optionName, optionArg);
+		else
+			return processDefault(argument, optionName, optionArg);
+	}
+	return false;
+}
+
+
+void OptionProcessor::checkRequired() const
+{
+	for (OptionSet::Iterator it = _options.begin(); it != _options.end(); ++it)
+	{
+		if (it->required() && _specifiedOptions.find(it->fullName()) == _specifiedOptions.end())
+			throw MissingOptionException(it->fullName());
+	}
+	if (!_deferredOption.empty())
+	{
+		std::string optionArg;
+		const Option& option = _options.getOption(_deferredOption, false);
+		option.process(_deferredOption, optionArg); // will throw MissingArgumentException
+	}
+}
+
+
+bool OptionProcessor::processUnix(const std::string& argument, std::string& optionName, std::string& optionArg)
+{
+	std::string::const_iterator it  = argument.begin();
+	std::string::const_iterator end = argument.end();
+	if (it != end)
+	{
+		if (*it == '-')
+		{
+			++it;
+			if (it != end)
+			{
+				if (*it == '-')
+				{
+					++it;
+					if (it == end)
+					{
+						_ignore = true;
+						return true;
+					}
+					else return processCommon(std::string(it, end), false, optionName, optionArg);
+				}
+				else return processCommon(std::string(it, end), true, optionName, optionArg);
+			}
+		}
+	}
+	return false;
+}
+
+
+bool OptionProcessor::processDefault(const std::string& argument, std::string& optionName, std::string& optionArg)
+{
+	std::string::const_iterator it  = argument.begin();
+	std::string::const_iterator end = argument.end();
+	if (it != end)
+	{
+		if (*it == '/')
+		{
+			++it;
+			return processCommon(std::string(it, end), false, optionName, optionArg);
+		}
+	}
+	return false;
+}
+
+
+bool OptionProcessor::processCommon(const std::string& optionStr, bool isShort, std::string& optionName, std::string& optionArg)
+{
+	if (!_deferredOption.empty())
+	{
+		const Option& option = _options.getOption(_deferredOption, false);
+		std::string optionWithArg(_deferredOption);
+		_deferredOption.clear();
+		optionWithArg += '=';
+		optionWithArg += optionStr;
+		option.process(optionWithArg, optionArg);
+		optionName = option.fullName();
+		return true;
+	}
+	if (optionStr.empty()) throw EmptyOptionException();
+	const Option& option = _options.getOption(optionStr, isShort);
+	const std::string& group = option.group();
+	if (!group.empty())
+	{
+		if (_groups.find(group) != _groups.end())
+			throw IncompatibleOptionsException(option.fullName());
+		else
+			_groups.insert(group);
+	}
+	if (_specifiedOptions.find(option.fullName()) != _specifiedOptions.end() && !option.repeatable())
+		throw DuplicateOptionException(option.fullName());
+	_specifiedOptions.insert(option.fullName());
+	if (option.argumentRequired() && ((!isShort && optionStr.find_first_of(":=") == std::string::npos) || (isShort && optionStr.length() == option.shortName().length())))
+	{
+		_deferredOption = option.fullName();
+		return true;
+	}
+	option.process(optionStr, optionArg);
+	optionName = option.fullName();
+	return true;
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/OptionSet.cpp b/base/poco/Util/src/OptionSet.cpp
new file mode 100644
index 00000000000..bfda7b76914
--- /dev/null
+++ b/base/poco/Util/src/OptionSet.cpp
@@ -0,0 +1,122 @@
+//
+// OptionSet.cpp
+//
+// Library: Util
+// Package: Options
+// Module:  OptionSet
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/OptionSet.h"
+#include "Poco/Util/OptionException.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+OptionSet::OptionSet()
+{
+}
+
+
+OptionSet::OptionSet(const OptionSet& options):
+	_options(options._options)
+{
+}
+
+
+OptionSet::~OptionSet()
+{
+}
+
+
+OptionSet& OptionSet::operator = (const OptionSet& options)
+{
+	if (&options != this)
+		_options = options._options;
+	return *this;
+}
+
+
+void OptionSet::addOption(const Option& option)
+{
+	poco_assert (!option.fullName().empty());
+	OptionVec::const_iterator it = _options.begin();
+	OptionVec::const_iterator itEnd = _options.end();
+	for (; it != itEnd; ++it)
+	{
+		if (it->fullName() == option.fullName())
+		{
+			throw DuplicateOptionException(it->fullName());
+		}
+	}
+
+	_options.push_back(option);
+}
+
+
+bool OptionSet::hasOption(const std::string& name, bool matchShort) const
+{
+	bool found = false;
+	for (Iterator it = _options.begin(); it != _options.end(); ++it)
+	{
+		if ((matchShort && it->matchesShort(name)) || (!matchShort && it->matchesFull(name)))
+		{
+			if (!found)
+				found = true;
+			else
+				return false;
+		}
+	}
+	return found;
+}
+
+	
+const Option& OptionSet::getOption(const std::string& name, bool matchShort) const
+{
+	const Option* pOption = 0;
+	for (Iterator it = _options.begin(); it != _options.end(); ++it)
+	{
+		if ((matchShort && it->matchesShort(name)) || (!matchShort && it->matchesPartial(name)))
+		{
+			if (!pOption)
+			{
+				pOption = &*it;
+				if (!matchShort && it->matchesFull(name))
+					break;
+			}
+			else if (!matchShort && it->matchesFull(name))
+			{
+				pOption = &*it;
+				break;
+			}
+			else throw AmbiguousOptionException(name);
+		}
+	}
+	if (pOption)
+		return *pOption;
+	else
+		throw UnknownOptionException(name);
+}
+
+
+OptionSet::Iterator OptionSet::begin() const
+{
+	return _options.begin();
+}
+
+
+OptionSet::Iterator OptionSet::end() const
+{
+	return _options.end();
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/PropertyFileConfiguration.cpp b/base/poco/Util/src/PropertyFileConfiguration.cpp
new file mode 100644
index 00000000000..dbdc8114039
--- /dev/null
+++ b/base/poco/Util/src/PropertyFileConfiguration.cpp
@@ -0,0 +1,190 @@
+//
+// PropertyFileConfiguration.cpp
+//
+// Library: Util
+// Package: Configuration
+// Module:  PropertyFileConfiguration
+//
+// Copyright (c) 2004-2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/PropertyFileConfiguration.h"
+#include "Poco/Exception.h"
+#include "Poco/String.h"
+#include "Poco/Path.h"
+#include "Poco/FileStream.h"
+#include "Poco/LineEndingConverter.h"
+#include "Poco/Ascii.h"
+
+
+using Poco::trim;
+using Poco::Path;
+
+
+namespace Poco {
+namespace Util {
+
+
+PropertyFileConfiguration::PropertyFileConfiguration()
+{
+}
+
+
+PropertyFileConfiguration::PropertyFileConfiguration(std::istream& istr)
+{
+	load(istr);
+}
+
+	
+PropertyFileConfiguration::PropertyFileConfiguration(const std::string& path)
+{
+	load(path);
+}
+
+
+PropertyFileConfiguration::~PropertyFileConfiguration()
+{
+}
+
+	
+void PropertyFileConfiguration::load(std::istream& istr)
+{
+	clear();
+	while (!istr.eof())
+	{
+		parseLine(istr);
+	}
+}
+
+	
+void PropertyFileConfiguration::load(const std::string& path)
+{
+	Poco::FileInputStream istr(path);
+	if (istr.good())
+		load(istr);
+	else
+		throw Poco::OpenFileException(path);
+}
+
+
+void PropertyFileConfiguration::save(std::ostream& ostr) const
+{
+	MapConfiguration::iterator it = begin();
+	MapConfiguration::iterator ed = end();
+	while (it != ed)
+	{
+		ostr << it->first << ": ";
+		for (std::string::const_iterator its = it->second.begin(); its != it->second.end(); ++its)
+		{
+			switch (*its)
+			{
+			case '\t':
+				ostr << "\\t";
+				break;
+			case '\r':
+				ostr << "\\r";
+				break;
+			case '\n':
+				ostr << "\\n";
+				break;
+			case '\f':
+				ostr << "\\f";
+				break;
+			case '\\':
+				ostr << "\\\\";
+				break;
+			default:
+				ostr << *its;
+				break;
+			}
+		}
+		ostr << "\n";
+		++it;
+	}
+}
+
+
+void PropertyFileConfiguration::save(const std::string& path) const
+{
+	Poco::FileOutputStream ostr(path);
+	if (ostr.good())
+	{
+		Poco::OutputLineEndingConverter lec(ostr);
+		save(lec);
+		lec.flush();
+		ostr.flush();
+		if (!ostr.good()) throw Poco::WriteFileException(path);
+	}
+	else throw Poco::CreateFileException(path);
+}
+
+
+void PropertyFileConfiguration::parseLine(std::istream& istr)
+{
+	static const int eof = std::char_traits<char>::eof(); 
+
+	int c = istr.get();
+	while (c != eof && Poco::Ascii::isSpace(c)) c = istr.get();
+	if (c != eof)
+	{
+		if (c == '#' || c == '!')
+		{
+			while (c != eof && c != '\n' && c != '\r') c = istr.get();
+		}
+		else
+		{
+			std::string key;
+			while (c != eof && c != '=' && c != ':' && c != '\r' && c != '\n') { key += (char) c; c = istr.get(); }
+			std::string value;
+			if (c == '=' || c == ':')
+			{
+				c = readChar(istr);
+				while (c != eof && c) { value += (char) c; c = readChar(istr); }
+			}
+			setRaw(trim(key), trim(value));
+		}
+	}
+}
+
+
+int PropertyFileConfiguration::readChar(std::istream& istr)
+{
+	for (;;)
+	{
+		int c = istr.get();
+		if (c == '\\')
+		{
+			c = istr.get();
+			switch (c)
+			{
+			case 't':
+				return '\t';
+			case 'r':
+				return '\r';
+			case 'n':
+				return '\n';
+			case 'f':
+				return '\f';
+			case '\r':
+				if (istr.peek() == '\n')
+					istr.get();
+				continue;
+			case '\n':
+				continue;
+			default:
+				return c;
+			}
+		}
+		else if (c == '\n' || c == '\r')
+			return 0;
+		else
+			return c;
+	}
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/RegExpValidator.cpp b/base/poco/Util/src/RegExpValidator.cpp
new file mode 100644
index 00000000000..15533406508
--- /dev/null
+++ b/base/poco/Util/src/RegExpValidator.cpp
@@ -0,0 +1,47 @@
+//
+// RegExpValidator.cpp
+//
+// Library: Util
+// Package: Options
+// Module:  RegExpValidator
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/RegExpValidator.h"
+#include "Poco/Util/Option.h"
+#include "Poco/Util/OptionException.h"
+#include "Poco/RegularExpression.h"
+#include "Poco/Format.h"
+
+
+using Poco::format;
+
+
+namespace Poco {
+namespace Util {
+
+
+RegExpValidator::RegExpValidator(const std::string& regexp):
+	_regexp(regexp)
+{
+}
+
+
+RegExpValidator::~RegExpValidator()
+{
+}
+
+
+void RegExpValidator::validate(const Option& option, const std::string& value)
+{
+	if (!RegularExpression::match(value, _regexp, RegularExpression::RE_ANCHORED | RegularExpression::RE_UTF8))
+		throw InvalidArgumentException(format("argument for %s does not match regular expression %s", option.fullName(), _regexp));
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/ServerApplication.cpp b/base/poco/Util/src/ServerApplication.cpp
new file mode 100644
index 00000000000..99107151e3b
--- /dev/null
+++ b/base/poco/Util/src/ServerApplication.cpp
@@ -0,0 +1,749 @@
+//
+// ServerApplication.cpp
+//
+// Library: Util
+// Package: Application
+// Module:  ServerApplication
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/ServerApplication.h"
+#include "Poco/Util/Option.h"
+#include "Poco/Util/OptionSet.h"
+#include "Poco/Util/OptionException.h"
+#include "Poco/FileStream.h"
+#include "Poco/Exception.h"
+#if !defined(POCO_VXWORKS)
+#include "Poco/Process.h"
+#include "Poco/NamedEvent.h"
+#endif
+#include "Poco/NumberFormatter.h"
+#include "Poco/Logger.h"
+#include "Poco/String.h"
+#if defined(POCO_OS_FAMILY_UNIX) && !defined(POCO_VXWORKS)
+#include "Poco/TemporaryFile.h"
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <fstream>
+#elif defined(POCO_OS_FAMILY_WINDOWS)
+#if !defined(_WIN32_WCE)
+#include "Poco/Util/WinService.h"
+#include "Poco/Util/WinRegistryKey.h"
+#endif
+#include "Poco/UnWindows.h"
+#include <cstring>
+#endif
+#if defined(POCO_WIN32_UTF8) && !defined(POCO_NO_WSTRING)
+#include "Poco/UnicodeConverter.h"
+#endif
+
+
+using Poco::NumberFormatter;
+using Poco::Exception;
+using Poco::SystemException;
+
+
+namespace Poco {
+namespace Util {
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+Poco::NamedEvent      ServerApplication::_terminate(Poco::ProcessImpl::terminationEventName(Poco::Process::id()));
+#if !defined(_WIN32_WCE)
+Poco::Event           ServerApplication::_terminated;
+SERVICE_STATUS        ServerApplication::_serviceStatus;
+SERVICE_STATUS_HANDLE ServerApplication::_serviceStatusHandle = 0;
+#endif
+#endif
+#if defined(POCO_VXWORKS) || POCO_OS == POCO_OS_ANDROID
+Poco::Event ServerApplication::_terminate;
+#endif
+
+
+ServerApplication::ServerApplication()
+{
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#if !defined(_WIN32_WCE)
+	_action = SRV_RUN;
+	std::memset(&_serviceStatus, 0, sizeof(_serviceStatus));
+#endif
+#endif
+}
+
+
+ServerApplication::~ServerApplication()
+{
+}
+
+
+bool ServerApplication::isInteractive() const
+{
+	bool runsInBackground = config().getBool("application.runAsDaemon", false) || config().getBool("application.runAsService", false);
+	return !runsInBackground;
+}
+
+
+int ServerApplication::run()
+{
+	return Application::run();
+}
+
+
+void ServerApplication::terminate()
+{
+#if defined(POCO_OS_FAMILY_WINDOWS)
+	_terminate.set();
+#elif defined(POCO_VXWORKS) || POCO_OS == POCO_OS_ANDROID
+	_terminate.set();
+#else
+	Poco::Process::requestTermination(Process::id());
+#endif
+}
+
+
+#if defined(POCO_OS_FAMILY_WINDOWS)
+#if !defined(_WIN32_WCE)
+
+
+//
+// Windows specific code
+//
+BOOL ServerApplication::ConsoleCtrlHandler(DWORD ctrlType)
+{
+	switch (ctrlType)
+	{
+	case CTRL_C_EVENT:
+	case CTRL_CLOSE_EVENT:
+	case CTRL_BREAK_EVENT:
+		terminate();
+		return _terminated.tryWait(10000) ? TRUE : FALSE;
+	default:
+		return FALSE;
+	}
+}
+
+
+void ServerApplication::ServiceControlHandler(DWORD control)
+{
+	switch (control)
+	{
+	case SERVICE_CONTROL_STOP:
+	case SERVICE_CONTROL_SHUTDOWN:
+		terminate();
+		_serviceStatus.dwCurrentState = SERVICE_STOP_PENDING;
+		break;
+	case SERVICE_CONTROL_INTERROGATE:
+		break;
+	}
+	SetServiceStatus(_serviceStatusHandle,  &_serviceStatus);
+}
+
+
+#if defined(POCO_WIN32_UTF8) && !defined(POCO_NO_WSTRING)
+void ServerApplication::ServiceMain(DWORD argc, LPWSTR* argv)
+#else
+void ServerApplication::ServiceMain(DWORD argc, LPTSTR* argv)
+#endif
+{
+	ServerApplication& app = static_cast<ServerApplication&>(Application::instance());
+
+	app.config().setBool("application.runAsService", true);
+
+#if defined(POCO_WIN32_UTF8) && !defined(POCO_NO_WSTRING)
+	_serviceStatusHandle = RegisterServiceCtrlHandlerW(L"", ServiceControlHandler);
+#else
+	_serviceStatusHandle = RegisterServiceCtrlHandlerA("", ServiceControlHandler);
+#endif
+	if (!_serviceStatusHandle)
+		throw SystemException("cannot register service control handler");
+
+	_serviceStatus.dwServiceType             = SERVICE_WIN32;
+	_serviceStatus.dwCurrentState            = SERVICE_START_PENDING;
+	_serviceStatus.dwControlsAccepted        = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
+	_serviceStatus.dwWin32ExitCode           = 0;
+	_serviceStatus.dwServiceSpecificExitCode = 0;
+	_serviceStatus.dwCheckPoint              = 0;
+	_serviceStatus.dwWaitHint                = 0;
+	SetServiceStatus(_serviceStatusHandle, &_serviceStatus);
+
+	try
+	{
+#if defined(POCO_WIN32_UTF8) && !defined(POCO_NO_WSTRING)
+		std::vector<std::string> args;
+		for (DWORD i = 0; i < argc; ++i)
+		{
+			std::string arg;
+			Poco::UnicodeConverter::toUTF8(argv[i], arg);
+			args.push_back(arg);
+		}
+		app.init(args);
+#else
+		app.init(argc, argv);
+#endif
+		_serviceStatus.dwCurrentState = SERVICE_RUNNING;
+		SetServiceStatus(_serviceStatusHandle, &_serviceStatus);
+		int rc = app.run();
+		_serviceStatus.dwWin32ExitCode           = rc ? ERROR_SERVICE_SPECIFIC_ERROR : 0;
+		_serviceStatus.dwServiceSpecificExitCode = rc;
+	}
+	catch (Exception& exc)
+	{
+		app.logger().log(exc);
+		_serviceStatus.dwWin32ExitCode           = ERROR_SERVICE_SPECIFIC_ERROR;
+		_serviceStatus.dwServiceSpecificExitCode = EXIT_CONFIG;
+	}
+	catch (...)
+	{
+		app.logger().error("fatal error - aborting");
+		_serviceStatus.dwWin32ExitCode           = ERROR_SERVICE_SPECIFIC_ERROR;
+		_serviceStatus.dwServiceSpecificExitCode = EXIT_SOFTWARE;
+	}
+	_serviceStatus.dwCurrentState = SERVICE_STOPPED;
+	SetServiceStatus(_serviceStatusHandle, &_serviceStatus);
+}
+
+
+void ServerApplication::waitForTerminationRequest()
+{
+	SetConsoleCtrlHandler(ConsoleCtrlHandler, TRUE);
+	_terminate.wait();
+	_terminated.set();
+}
+
+
+int ServerApplication::run(int argc, char** argv)
+{
+	if (!hasConsole() && isService())
+	{
+		return 0;
+	}
+	else
+	{
+		int rc = EXIT_OK;
+		try
+		{
+			init(argc, argv);
+			switch (_action)
+			{
+			case SRV_REGISTER:
+				registerService();
+				rc = EXIT_OK;
+				break;
+			case SRV_UNREGISTER:
+				unregisterService();
+				rc = EXIT_OK;
+				break;
+			default:
+				rc = run();
+			}
+		}
+		catch (Exception& exc)
+		{
+			logger().log(exc);
+			rc = EXIT_SOFTWARE;
+		}
+		return rc;
+	}
+}
+
+
+int ServerApplication::run(const std::vector<std::string>& args)
+{
+	if (!hasConsole() && isService())
+	{
+		return 0;
+	}
+	else
+	{
+		int rc = EXIT_OK;
+		try
+		{
+			init(args);
+			switch (_action)
+			{
+			case SRV_REGISTER:
+				registerService();
+				rc = EXIT_OK;
+				break;
+			case SRV_UNREGISTER:
+				unregisterService();
+				rc = EXIT_OK;
+				break;
+			default:
+				rc = run();
+			}
+		}
+		catch (Exception& exc)
+		{
+			logger().log(exc);
+			rc = EXIT_SOFTWARE;
+		}
+		return rc;
+	}
+}
+
+
+#if defined(POCO_WIN32_UTF8) && !defined(POCO_NO_WSTRING)
+int ServerApplication::run(int argc, wchar_t** argv)
+{
+	if (!hasConsole() && isService())
+	{
+		return 0;
+	}
+	else
+	{
+		int rc = EXIT_OK;
+		try
+		{
+			init(argc, argv);
+			switch (_action)
+			{
+			case SRV_REGISTER:
+				registerService();
+				rc = EXIT_OK;
+				break;
+			case SRV_UNREGISTER:
+				unregisterService();
+				rc = EXIT_OK;
+				break;
+			default:
+				rc = run();
+			}
+		}
+		catch (Exception& exc)
+		{
+			logger().log(exc);
+			rc = EXIT_SOFTWARE;
+		}
+		return rc;
+	}
+}
+#endif
+
+
+bool ServerApplication::isService()
+{
+#if defined(POCO_WIN32_UTF8) && !defined(POCO_NO_WSTRING)
+	SERVICE_TABLE_ENTRYW svcDispatchTable[2];
+	svcDispatchTable[0].lpServiceName = L"";
+	svcDispatchTable[0].lpServiceProc = ServiceMain;
+	svcDispatchTable[1].lpServiceName = NULL;
+	svcDispatchTable[1].lpServiceProc = NULL;
+	return StartServiceCtrlDispatcherW(svcDispatchTable) != 0;
+#else
+	SERVICE_TABLE_ENTRY svcDispatchTable[2];
+	svcDispatchTable[0].lpServiceName = "";
+	svcDispatchTable[0].lpServiceProc = ServiceMain;
+	svcDispatchTable[1].lpServiceName = NULL;
+	svcDispatchTable[1].lpServiceProc = NULL;
+	return StartServiceCtrlDispatcherA(svcDispatchTable) != 0;
+#endif
+}
+
+
+bool ServerApplication::hasConsole()
+{
+	HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
+	return hStdOut != INVALID_HANDLE_VALUE && hStdOut != NULL;
+}
+
+
+void ServerApplication::registerService()
+{
+	std::string name = config().getString("application.baseName");
+	std::string path = config().getString("application.path");
+
+	WinService service(name);
+	if (_displayName.empty())
+		service.registerService(path);
+	else
+		service.registerService(path, _displayName);
+	if (_startup == "auto")
+		service.setStartup(WinService::SVC_AUTO_START);
+	else if (_startup == "manual")
+		service.setStartup(WinService::SVC_MANUAL_START);
+	if (!_description.empty())
+		service.setDescription(_description);
+	logger().information("The application has been successfully registered as a service.");
+}
+
+
+void ServerApplication::unregisterService()
+{
+	std::string name = config().getString("application.baseName");
+
+	WinService service(name);
+	service.unregisterService();
+	logger().information("The service has been successfully unregistered.");
+}
+
+
+void ServerApplication::defineOptions(OptionSet& options)
+{
+	Application::defineOptions(options);
+
+	options.addOption(
+		Option("registerService", "", "Register the application as a service.")
+			.required(false)
+			.repeatable(false)
+			.callback(OptionCallback<ServerApplication>(this, &ServerApplication::handleRegisterService)));
+
+	options.addOption(
+		Option("unregisterService", "", "Unregister the application as a service.")
+			.required(false)
+			.repeatable(false)
+			.callback(OptionCallback<ServerApplication>(this, &ServerApplication::handleUnregisterService)));
+
+	options.addOption(
+		Option("displayName", "", "Specify a display name for the service (only with /registerService).")
+			.required(false)
+			.repeatable(false)
+			.argument("name")
+			.callback(OptionCallback<ServerApplication>(this, &ServerApplication::handleDisplayName)));
+
+	options.addOption(
+		Option("description", "", "Specify a description for the service (only with /registerService).")
+			.required(false)
+			.repeatable(false)
+			.argument("text")
+			.callback(OptionCallback<ServerApplication>(this, &ServerApplication::handleDescription)));
+
+	options.addOption(
+		Option("startup", "", "Specify the startup mode for the service (only with /registerService).")
+			.required(false)
+			.repeatable(false)
+			.argument("automatic|manual")
+			.callback(OptionCallback<ServerApplication>(this, &ServerApplication::handleStartup)));
+}
+
+
+void ServerApplication::handleRegisterService(const std::string& name, const std::string& value)
+{
+	_action = SRV_REGISTER;
+}
+
+
+void ServerApplication::handleUnregisterService(const std::string& name, const std::string& value)
+{
+	_action = SRV_UNREGISTER;
+}
+
+
+void ServerApplication::handleDisplayName(const std::string& name, const std::string& value)
+{
+	_displayName = value;
+}
+
+
+void ServerApplication::handleDescription(const std::string& name, const std::string& value)
+{
+	_description = value;
+}
+
+
+void ServerApplication::handleStartup(const std::string& name, const std::string& value)
+{
+	if (Poco::icompare(value, 4, std::string("auto")) == 0)
+		_startup = "auto";
+	else if (Poco::icompare(value, std::string("manual")) == 0)
+		_startup = "manual";
+	else
+		throw InvalidArgumentException("argument to startup option must be 'auto[matic]' or 'manual'");
+}
+
+
+#else // _WIN32_WCE
+void ServerApplication::waitForTerminationRequest()
+{
+	_terminate.wait();
+}
+
+
+int ServerApplication::run(int argc, char** argv)
+{
+	try
+	{
+		init(argc, argv);
+	}
+	catch (Exception& exc)
+	{
+		logger().log(exc);
+		return EXIT_CONFIG;
+	}
+	return run();
+}
+
+
+int ServerApplication::run(const std::vector<std::string>& args)
+{
+	try
+	{
+		init(args);
+	}
+	catch (Exception& exc)
+	{
+		logger().log(exc);
+		return EXIT_CONFIG;
+	}
+	return run();
+}
+
+
+#if defined(POCO_WIN32_UTF8) && !defined(POCO_NO_WSTRING)
+int ServerApplication::run(int argc, wchar_t** argv)
+{
+	try
+	{
+		init(argc, argv);
+	}
+	catch (Exception& exc)
+	{
+		logger().log(exc);
+		return EXIT_CONFIG;
+	}
+	return run();
+}
+#endif
+
+
+#endif // _WIN32_WCE
+#elif defined(POCO_VXWORKS)
+//
+// VxWorks specific code
+//
+void ServerApplication::waitForTerminationRequest()
+{
+	_terminate.wait();
+}
+
+
+int ServerApplication::run(int argc, char** argv)
+{
+	try
+	{
+		init(argc, argv);
+	}
+	catch (Exception& exc)
+	{
+		logger().log(exc);
+		return EXIT_CONFIG;
+	}
+	return run();
+}
+
+
+int ServerApplication::run(const std::vector<std::string>& args)
+{
+	try
+	{
+		init(args);
+	}
+	catch (Exception& exc)
+	{
+		logger().log(exc);
+		return EXIT_CONFIG;
+	}
+	return run();
+}
+
+
+void ServerApplication::defineOptions(OptionSet& options)
+{
+	Application::defineOptions(options);
+}
+
+
+#elif defined(POCO_OS_FAMILY_UNIX)
+
+
+//
+// Unix specific code
+//
+void ServerApplication::waitForTerminationRequest()
+{
+#if POCO_OS != POCO_OS_ANDROID
+	sigset_t sset;
+	sigemptyset(&sset);
+	if (!std::getenv("POCO_ENABLE_DEBUGGER"))
+	{
+		sigaddset(&sset, SIGINT);
+	}
+	sigaddset(&sset, SIGQUIT);
+	sigaddset(&sset, SIGTERM);
+	sigprocmask(SIG_BLOCK, &sset, NULL);
+	int sig;
+	sigwait(&sset, &sig);
+#else // POCO_OS != POCO_OS_ANDROID
+	_terminate.wait();
+#endif
+}
+
+
+int ServerApplication::run(int argc, char** argv)
+{
+	bool runAsDaemon = isDaemon(argc, argv);
+	if (runAsDaemon)
+	{
+		beDaemon();
+	}
+	try
+	{
+		init(argc, argv);
+		if (runAsDaemon)
+		{
+			int rc = chdir("/");
+			if (rc != 0) return EXIT_OSERR;
+		}
+	}
+	catch (Exception& exc)
+	{
+		logger().log(exc);
+		return EXIT_CONFIG;
+	}
+	return run();
+}
+
+
+int ServerApplication::run(const std::vector<std::string>& args)
+{
+	bool runAsDaemon = false;
+	for (std::vector<std::string>::const_iterator it = args.begin(); it != args.end(); ++it)
+	{
+		if (*it == "--daemon")
+		{
+			runAsDaemon = true;
+			break;
+		}
+	}
+	if (runAsDaemon)
+	{
+		beDaemon();
+	}
+	try
+	{
+		init(args);
+		if (runAsDaemon)
+		{
+			int rc = chdir("/");
+			if (rc != 0) return EXIT_OSERR;
+		}
+	}
+	catch (Exception& exc)
+	{
+		logger().log(exc);
+		return EXIT_CONFIG;
+	}
+	return run();
+}
+
+
+bool ServerApplication::isDaemon(int argc, char** argv)
+{
+	std::string option("--daemon");
+	for (int i = 1; i < argc; ++i)
+	{
+		if (option == argv[i])
+			return true;
+	}
+	return false;
+}
+
+
+void ServerApplication::beDaemon()
+{
+#if !defined(POCO_NO_FORK_EXEC)
+	pid_t pid;
+	if ((pid = fork()) < 0)
+		throw SystemException("cannot fork daemon process");
+	else if (pid != 0)
+		exit(0);
+
+	setsid();
+	umask(027);
+
+	// attach stdin, stdout, stderr to /dev/null
+	// instead of just closing them. This avoids
+	// issues with third party/legacy code writing
+	// stuff to stdout/stderr.
+	FILE* fin  = freopen("/dev/null", "r+", stdin);
+	if (!fin) throw Poco::OpenFileException("Cannot attach stdin to /dev/null");
+	FILE* fout = freopen("/dev/null", "r+", stdout);
+	if (!fout) throw Poco::OpenFileException("Cannot attach stdout to /dev/null");
+	FILE* ferr = freopen("/dev/null", "r+", stderr);
+	if (!ferr) throw Poco::OpenFileException("Cannot attach stderr to /dev/null");
+#else
+	throw Poco::NotImplementedException("platform does not allow fork/exec");
+#endif
+}
+
+
+void ServerApplication::defineOptions(OptionSet& options)
+{
+	Application::defineOptions(options);
+
+	options.addOption(
+		Option("daemon", "", "Run application as a daemon.")
+			.required(false)
+			.repeatable(false)
+			.callback(OptionCallback<ServerApplication>(this, &ServerApplication::handleDaemon)));
+
+	options.addOption(
+		Option("umask", "", "Set the daemon's umask (octal, e.g. 027).")
+			.required(false)
+			.repeatable(false)
+			.argument("mask")
+			.callback(OptionCallback<ServerApplication>(this, &ServerApplication::handleUMask)));
+
+	options.addOption(
+		Option("pidfile", "", "Write the process ID of the application to given file.")
+			.required(false)
+			.repeatable(false)
+			.argument("path")
+			.callback(OptionCallback<ServerApplication>(this, &ServerApplication::handlePidFile)));
+}
+
+
+void ServerApplication::handleDaemon(const std::string& name, const std::string& value)
+{
+	config().setBool("application.runAsDaemon", true);
+}
+
+
+void ServerApplication::handleUMask(const std::string& name, const std::string& value)
+{
+	int mask = 0;
+	for (std::string::const_iterator it = value.begin(); it != value.end(); ++it)
+	{
+		mask *= 8;
+		if (*it >= '0' && *it <= '7')
+			mask += *it - '0';
+		else
+			throw Poco::InvalidArgumentException("umask contains non-octal characters", value);
+	}
+	umask(mask);
+}
+
+
+void ServerApplication::handlePidFile(const std::string& name, const std::string& value)
+{
+	Poco::FileOutputStream ostr(value);
+	if (ostr.good())
+		ostr << Poco::Process::id() << std::endl;
+	else
+		throw Poco::CreateFileException("Cannot write PID to file", value);
+	Poco::TemporaryFile::registerForDeletion(value);
+}
+
+
+#endif
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/Subsystem.cpp b/base/poco/Util/src/Subsystem.cpp
new file mode 100644
index 00000000000..3b3f932e97b
--- /dev/null
+++ b/base/poco/Util/src/Subsystem.cpp
@@ -0,0 +1,44 @@
+//
+// Subsystem.cpp
+//
+// Library: Util
+// Package: Application
+// Module:  Subsystem
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/Subsystem.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+Subsystem::Subsystem()
+{
+}
+
+
+Subsystem::~Subsystem()
+{
+}
+
+
+void Subsystem::reinitialize(Application& app)
+{
+	uninitialize();
+	initialize(app);
+}
+
+
+void Subsystem::defineOptions(OptionSet& options)
+{
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/SystemConfiguration.cpp b/base/poco/Util/src/SystemConfiguration.cpp
new file mode 100644
index 00000000000..8beecacef17
--- /dev/null
+++ b/base/poco/Util/src/SystemConfiguration.cpp
@@ -0,0 +1,212 @@
+//
+// SystemConfiguration.cpp
+//
+// Library: Util
+// Package: Configuration
+// Module:  SystemConfiguration
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/SystemConfiguration.h"
+#include "Poco/Environment.h"
+#include "Poco/Path.h"
+#include "Poco/DateTime.h"
+#include "Poco/DateTimeFormatter.h"
+#include "Poco/DateTimeFormat.h"
+#include "Poco/NumberFormatter.h"
+#if !defined(POCO_VXWORKS)
+#include "Poco/Process.h"
+#endif
+#include "Poco/Exception.h"
+#include <cstdio>
+
+
+using Poco::Environment;
+using Poco::Path;
+
+
+namespace Poco {
+namespace Util {
+
+
+const std::string SystemConfiguration::OSNAME         = "system.osName";
+const std::string SystemConfiguration::OSVERSION      = "system.osVersion";
+const std::string SystemConfiguration::OSARCHITECTURE = "system.osArchitecture";
+const std::string SystemConfiguration::NODENAME       = "system.nodeName";
+const std::string SystemConfiguration::NODEID         = "system.nodeId";
+const std::string SystemConfiguration::CURRENTDIR     = "system.currentDir";
+const std::string SystemConfiguration::HOMEDIR        = "system.homeDir";
+const std::string SystemConfiguration::CONFIGHOMEDIR  = "system.configHomeDir";
+const std::string SystemConfiguration::CACHEHOMEDIR   = "system.cacheHomeDir";
+const std::string SystemConfiguration::DATAHOMEDIR    = "system.dataHomeDir";
+const std::string SystemConfiguration::TEMPHOMEDIR    = "system.tempHomeDir";
+const std::string SystemConfiguration::TEMPDIR        = "system.tempDir";
+const std::string SystemConfiguration::CONFIGDIR      = "system.configDir";
+const std::string SystemConfiguration::DATETIME       = "system.dateTime";
+#if !defined(POCO_VXWORKS)
+const std::string SystemConfiguration::PID            = "system.pid";
+#endif
+const std::string SystemConfiguration::ENV            = "system.env.";
+
+
+SystemConfiguration::SystemConfiguration()
+{
+}
+
+
+SystemConfiguration::~SystemConfiguration()
+{
+}
+
+
+bool SystemConfiguration::getRaw(const std::string& key, std::string& value) const
+{
+	if (key == OSNAME)
+	{
+		value = Environment::osName();
+	}
+	else if (key == OSVERSION)
+	{
+		value = Environment::osVersion();
+	}
+	else if (key == OSARCHITECTURE)
+	{
+		value = Environment::osArchitecture();
+	}
+	else if (key == NODENAME)
+	{
+		value = Environment::nodeName();
+	}
+	else if (key == NODEID)
+	{
+		try
+		{
+			Poco::Environment::NodeId id;
+			Poco::Environment::nodeId(id);
+			char result[13];
+			std::sprintf(result, "%02x%02x%02x%02x%02x%02x",
+				id[0],
+				id[1],
+				id[2],
+				id[3],
+				id[4],
+				id[5]);
+			value = result;
+		}
+		catch (...)
+		{
+			value = "000000000000";
+		}
+	}
+	else if (key == CURRENTDIR)
+	{
+		value = Path::current();
+	}
+	else if (key == HOMEDIR)
+	{
+		value = Path::home();
+	}
+	else if (key == CONFIGHOMEDIR)
+	{
+		value = Path::configHome();
+	}
+	else if (key == CACHEHOMEDIR)
+	{
+		value = Path::cacheHome();
+	}
+	else if (key == DATAHOMEDIR)
+	{
+		value = Path::dataHome();
+	}
+
+	else if (key == TEMPHOMEDIR)
+	{
+		value = Path::tempHome();
+	}
+	else if (key == TEMPDIR)
+	{
+		value = Path::temp();
+	}
+	else if (key == CONFIGDIR)
+	{
+		value = Path::config();
+	}
+	else if (key == DATETIME)
+	{
+		value = Poco::DateTimeFormatter::format(Poco::DateTime(), Poco::DateTimeFormat::ISO8601_FORMAT);
+	}
+#if !defined(POCO_VXWORKS)
+	else if (key == PID)
+	{
+		value = "0";
+		value = Poco::NumberFormatter::format(Poco::Process::id());
+	}
+#endif
+	else if (key.compare(0, ENV.size(), ENV) == 0)
+	{
+		return getEnv(key.substr(ENV.size()), value);
+	}
+	else return false;
+	return true;
+}
+
+
+void SystemConfiguration::setRaw(const std::string& key, const std::string& value)
+{
+	throw Poco::InvalidAccessException("Attempt to modify a system property", key);
+}
+
+
+void SystemConfiguration::enumerate(const std::string& key, Keys& range) const
+{
+	if (key.empty())
+	{
+		range.push_back("system");
+	}
+	else if (key == "system")
+	{
+		range.push_back("osName");
+		range.push_back("osVersion");
+		range.push_back("osArchitecture");
+		range.push_back("nodeName");
+		range.push_back("nodeId");
+		range.push_back("currentDir");
+		range.push_back("homeDir");
+		range.push_back("configHomeDir");
+		range.push_back("cacheHomeDir");
+		range.push_back("dataHomeDir");
+		range.push_back("tempHomeDir");
+		range.push_back("tempDir");
+		range.push_back("configDir");
+		range.push_back("dateTime");
+#if !defined(POCO_VXWORKS)
+		range.push_back("pid");
+#endif
+		range.push_back("env");
+	}
+}
+
+
+void SystemConfiguration::removeRaw(const std::string& key)
+{
+	throw Poco::NotImplementedException("Removing a key in a SystemConfiguration");
+}
+
+
+bool SystemConfiguration::getEnv(const std::string& name, std::string& value)
+{
+	if (Environment::has(name))
+	{
+		value = Environment::get(name);
+		return true;
+	}
+	return false;
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/Timer.cpp b/base/poco/Util/src/Timer.cpp
new file mode 100644
index 00000000000..3de4821c163
--- /dev/null
+++ b/base/poco/Util/src/Timer.cpp
@@ -0,0 +1,351 @@
+//
+// Timer.cpp
+//
+// Library: Util
+// Package: Timer
+// Module:  Timer
+//
+// Copyright (c) 2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/Timer.h"
+#include "Poco/Notification.h"
+#include "Poco/ErrorHandler.h"
+#include "Poco/Event.h"
+
+
+using Poco::ErrorHandler;
+
+
+namespace Poco {
+namespace Util {
+
+
+class TimerNotification: public Poco::Notification
+{
+public:
+	TimerNotification(Poco::TimedNotificationQueue& queue):
+		_queue(queue)
+	{
+	}
+
+	~TimerNotification()
+	{
+	}
+
+	virtual bool execute() = 0;
+
+	Poco::TimedNotificationQueue& queue()
+	{
+		return _queue;
+	}
+
+private:
+	Poco::TimedNotificationQueue& _queue;
+};
+
+
+class StopNotification: public TimerNotification
+{
+public:
+	StopNotification(Poco::TimedNotificationQueue& queue):
+		TimerNotification(queue)
+	{
+	}
+
+	~StopNotification()
+	{
+	}
+
+	bool execute()
+	{
+		queue().clear();
+		return false;
+	}
+};
+
+
+class CancelNotification: public TimerNotification
+{
+public:
+	CancelNotification(Poco::TimedNotificationQueue& queue):
+		TimerNotification(queue)
+	{
+	}
+
+	~CancelNotification()
+	{
+	}
+
+	bool execute()
+	{
+		// Check if there's a StopNotification pending.
+		Poco::AutoPtr<TimerNotification> pNf = static_cast<TimerNotification*>(queue().dequeueNotification());
+		while (pNf)
+		{
+			if (pNf.cast<StopNotification>())
+			{
+				queue().clear();
+				_finished.set();
+				return false;
+			}
+			pNf = static_cast<TimerNotification*>(queue().dequeueNotification());
+		}
+
+		queue().clear();
+		_finished.set();
+		return true;
+	}
+
+	void wait()
+	{
+		_finished.wait();
+	}
+
+private:
+	Poco::Event _finished;
+};
+
+
+class TaskNotification: public TimerNotification
+{
+public:
+	TaskNotification(Poco::TimedNotificationQueue& queue, TimerTask::Ptr pTask):
+		TimerNotification(queue),
+		_pTask(pTask)
+	{
+	}
+
+	~TaskNotification()
+	{
+	}
+
+	TimerTask::Ptr task()
+	{
+		return _pTask;
+	}
+
+	bool execute()
+	{
+		if (!_pTask->isCancelled())
+		{
+			try
+			{
+				_pTask->_lastExecution.update();
+				_pTask->run();
+			}
+			catch (Exception& exc)
+			{
+				ErrorHandler::handle(exc);
+			}
+			catch (std::exception& exc)
+			{
+				ErrorHandler::handle(exc);
+			}
+			catch (...)
+			{
+				ErrorHandler::handle();
+			}
+		}
+		return true;
+	}
+
+private:
+	TimerTask::Ptr _pTask;
+};
+
+
+class PeriodicTaskNotification: public TaskNotification
+{
+public:
+	PeriodicTaskNotification(Poco::TimedNotificationQueue& queue, TimerTask::Ptr pTask, long interval):
+		TaskNotification(queue, pTask),
+		_interval(interval)
+	{
+	}
+
+	~PeriodicTaskNotification()
+	{
+	}
+
+	bool execute()
+	{
+		TaskNotification::execute();
+
+		if (!task()->isCancelled())
+		{
+			Poco::Clock now;
+			Poco::Clock nextExecution;
+			nextExecution += static_cast<Poco::Clock::ClockDiff>(_interval)*1000;
+			if (nextExecution < now) nextExecution = now;
+			queue().enqueueNotification(this, nextExecution);
+			duplicate();
+		}
+		return true;
+	}
+
+private:
+	long _interval;
+};
+
+
+class FixedRateTaskNotification: public TaskNotification
+{
+public:
+	FixedRateTaskNotification(Poco::TimedNotificationQueue& queue, TimerTask::Ptr pTask, long interval, Poco::Clock clock):
+		TaskNotification(queue, pTask),
+		_interval(interval),
+		_nextExecution(clock)
+	{
+	}
+
+	~FixedRateTaskNotification()
+	{
+	}
+
+	bool execute()
+	{
+		TaskNotification::execute();
+
+		if (!task()->isCancelled())
+		{
+			Poco::Clock now;
+			_nextExecution += static_cast<Poco::Clock::ClockDiff>(_interval)*1000;
+			if (_nextExecution < now) _nextExecution = now;
+			queue().enqueueNotification(this, _nextExecution);
+			duplicate();
+		}
+		return true;
+	}
+
+private:
+	long _interval;
+	Poco::Clock _nextExecution;
+};
+
+
+Timer::Timer()
+{
+	_thread.start(*this);
+}
+
+
+Timer::Timer(Poco::Thread::Priority priority)
+{
+	_thread.setPriority(priority);
+	_thread.start(*this);
+}
+
+
+Timer::~Timer()
+{
+	try
+	{
+		_queue.enqueueNotification(new StopNotification(_queue), Poco::Clock(0));
+		_thread.join();
+	}
+	catch (...)
+	{
+		poco_unexpected();
+	}
+}
+
+
+void Timer::cancel(bool wait)
+{
+	Poco::AutoPtr<CancelNotification> pNf = new CancelNotification(_queue);
+	_queue.enqueueNotification(pNf, Poco::Clock(0));
+	if (wait)
+	{
+		pNf->wait();
+	}
+}
+
+
+void Timer::schedule(TimerTask::Ptr pTask, Poco::Timestamp time)
+{
+	validateTask(pTask);
+	_queue.enqueueNotification(new TaskNotification(_queue, pTask), time);
+}
+
+
+void Timer::schedule(TimerTask::Ptr pTask, Poco::Clock clock)
+{
+	validateTask(pTask);
+	_queue.enqueueNotification(new TaskNotification(_queue, pTask), clock);
+}
+
+
+void Timer::schedule(TimerTask::Ptr pTask, long delay, long interval)
+{
+	Poco::Clock clock;
+	clock += static_cast<Poco::Clock::ClockDiff>(delay)*1000;
+	schedule(pTask, clock, interval);
+}
+
+
+void Timer::schedule(TimerTask::Ptr pTask, Poco::Timestamp time, long interval)
+{
+	validateTask(pTask);
+	_queue.enqueueNotification(new PeriodicTaskNotification(_queue, pTask, interval), time);
+}
+
+
+void Timer::schedule(TimerTask::Ptr pTask, Poco::Clock clock, long interval)
+{
+	validateTask(pTask);
+	_queue.enqueueNotification(new PeriodicTaskNotification(_queue, pTask, interval), clock);
+}
+
+
+void Timer::scheduleAtFixedRate(TimerTask::Ptr pTask, long delay, long interval)
+{
+	Poco::Clock clock;
+	clock += static_cast<Poco::Clock::ClockDiff>(delay)*1000;
+	scheduleAtFixedRate(pTask, clock, interval);
+}
+
+
+void Timer::scheduleAtFixedRate(TimerTask::Ptr pTask, Poco::Timestamp time, long interval)
+{
+	validateTask(pTask);
+	Poco::Timestamp tsNow;
+	Poco::Clock clock;
+	Poco::Timestamp::TimeDiff diff = time - tsNow;
+	clock += diff;
+	_queue.enqueueNotification(new FixedRateTaskNotification(_queue, pTask, interval, clock), clock);
+}
+
+
+void Timer::scheduleAtFixedRate(TimerTask::Ptr pTask, Poco::Clock clock, long interval)
+{
+	validateTask(pTask);
+	_queue.enqueueNotification(new FixedRateTaskNotification(_queue, pTask, interval, clock), clock);
+}
+
+
+void Timer::run()
+{
+	bool cont = true;
+	while (cont)
+	{
+		Poco::AutoPtr<TimerNotification> pNf = static_cast<TimerNotification*>(_queue.waitDequeueNotification());
+		cont = pNf->execute();
+	}
+}
+
+
+void Timer::validateTask(const TimerTask::Ptr& pTask)
+{
+	if (pTask->isCancelled())
+	{
+		throw Poco::IllegalStateException("A cancelled task must not be rescheduled");
+	}
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/TimerTask.cpp b/base/poco/Util/src/TimerTask.cpp
new file mode 100644
index 00000000000..dac3794d1ce
--- /dev/null
+++ b/base/poco/Util/src/TimerTask.cpp
@@ -0,0 +1,40 @@
+//
+// TimerTask.cpp
+//
+// Library: Util
+// Package: Timer
+// Module:  TimerTask
+//
+// Copyright (c) 2009, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/TimerTask.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+TimerTask::TimerTask():
+	_lastExecution(0),
+	_isCancelled(false)
+{
+}
+
+
+TimerTask::~TimerTask()
+{
+}
+
+
+void TimerTask::cancel()
+{
+	_isCancelled = true;
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/Validator.cpp b/base/poco/Util/src/Validator.cpp
new file mode 100644
index 00000000000..bc596db2896
--- /dev/null
+++ b/base/poco/Util/src/Validator.cpp
@@ -0,0 +1,32 @@
+//
+// Validator.cpp
+//
+// Library: Util
+// Package: Options
+// Module:  Validator
+//
+// Copyright (c) 2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/Validator.h"
+
+
+namespace Poco {
+namespace Util {
+
+
+Validator::Validator()
+{
+}
+
+
+Validator::~Validator()
+{
+}
+
+
+} } // namespace Poco::Util
diff --git a/base/poco/Util/src/XMLConfiguration.cpp b/base/poco/Util/src/XMLConfiguration.cpp
new file mode 100644
index 00000000000..974361044d7
--- /dev/null
+++ b/base/poco/Util/src/XMLConfiguration.cpp
@@ -0,0 +1,479 @@
+//
+// XMLConfiguration.cpp
+//
+// Library: Util
+// Package: Configuration
+// Module:  XMLConfiguration
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/Util/XMLConfiguration.h"
+
+
+#ifndef POCO_UTIL_NO_XMLCONFIGURATION
+
+
+#include "Poco/SAX/InputSource.h"
+#include "Poco/DOM/DOMParser.h"
+#include "Poco/DOM/Element.h"
+#include "Poco/DOM/Attr.h"
+#include "Poco/DOM/Text.h"
+#include "Poco/XML/XMLWriter.h"
+#include "Poco/Exception.h"
+#include "Poco/NumberParser.h"
+#include "Poco/NumberFormatter.h"
+#include <set>
+
+
+namespace Poco {
+namespace Util {
+
+
+XMLConfiguration::XMLConfiguration():
+	_delim('.')
+{
+	loadEmpty("config");
+}
+
+
+XMLConfiguration::XMLConfiguration(char delim):
+	_delim(delim)
+{
+	loadEmpty("config");
+}
+
+
+XMLConfiguration::XMLConfiguration(Poco::XML::InputSource* pInputSource):
+	_delim('.')
+{
+	load(pInputSource);
+}
+
+
+XMLConfiguration::XMLConfiguration(Poco::XML::InputSource* pInputSource, char delim):
+	_delim(delim)
+{
+	load(pInputSource);
+}
+
+
+XMLConfiguration::XMLConfiguration(std::istream& istr):
+	_delim('.')
+{
+	load(istr);
+}
+
+
+XMLConfiguration::XMLConfiguration(std::istream& istr, char delim):
+	_delim(delim)
+{
+	load(istr);
+}
+
+
+XMLConfiguration::XMLConfiguration(const std::string& path):
+	_delim('.')
+{
+	load(path);
+}
+
+
+XMLConfiguration::XMLConfiguration(const std::string& path, char delim):
+	_delim(delim)
+{
+	load(path);
+}
+
+
+XMLConfiguration::XMLConfiguration(const Poco::XML::Document* pDocument):
+	_delim('.')
+{
+	load(pDocument);
+}
+
+
+XMLConfiguration::XMLConfiguration(const Poco::XML::Document* pDocument, char delim):
+	_delim(delim)
+{
+	load(pDocument);
+}
+
+	
+XMLConfiguration::XMLConfiguration(const Poco::XML::Node* pNode):
+	_delim('.')
+{
+	load(pNode);
+}
+
+
+XMLConfiguration::XMLConfiguration(const Poco::XML::Node* pNode, char delim):
+	_delim(delim)
+{
+	load(pNode);
+}
+
+
+XMLConfiguration::~XMLConfiguration()
+{
+}
+
+
+void XMLConfiguration::load(Poco::XML::InputSource* pInputSource, unsigned long namePoolSize)
+{
+	poco_check_ptr (pInputSource);
+	
+	Poco::XML::DOMParser parser(namePoolSize);
+	parser.setFeature(Poco::XML::XMLReader::FEATURE_NAMESPACES, false);
+	parser.setFeature(Poco::XML::DOMParser::FEATURE_FILTER_WHITESPACE, true);
+	Poco::XML::AutoPtr<Poco::XML::Document> pDoc = parser.parse(pInputSource);
+	load(pDoc);
+}
+
+
+void XMLConfiguration::load(Poco::XML::InputSource* pInputSource)
+{
+	load(pInputSource, POCO_XML_NAMEPOOL_DEFAULT_SIZE);
+}
+
+
+void XMLConfiguration::load(std::istream& istr)
+{
+	Poco::XML::InputSource src(istr);
+	load(&src);	
+}
+
+
+void XMLConfiguration::load(const std::string& path)
+{
+	Poco::XML::InputSource src(path);
+	load(&src);	
+}
+
+	
+void XMLConfiguration::load(const Poco::XML::Document* pDocument)
+{
+	poco_check_ptr (pDocument);
+	
+	_pDocument = Poco::XML::AutoPtr<Poco::XML::Document>(const_cast<Poco::XML::Document*>(pDocument), true);
+	_pRoot     = Poco::XML::AutoPtr<Poco::XML::Node>(pDocument->documentElement(), true);
+}
+
+
+void XMLConfiguration::load(const Poco::XML::Node* pNode)
+{
+	poco_check_ptr (pNode);
+
+	if (pNode->nodeType() == Poco::XML::Node::DOCUMENT_NODE)
+	{
+		load(static_cast<const Poco::XML::Document*>(pNode));
+	}
+	else
+	{
+		_pDocument = Poco::XML::AutoPtr<Poco::XML::Document>(pNode->ownerDocument(), true);
+		_pRoot     = Poco::XML::AutoPtr<Poco::XML::Node>(const_cast<Poco::XML::Node*>(pNode), true);
+	}
+}
+
+
+void XMLConfiguration::loadEmpty(const std::string& rootElementName)
+{
+	_pDocument = new Poco::XML::Document;
+	_pRoot     = _pDocument->createElement(rootElementName);
+	_pDocument->appendChild(_pRoot);
+}
+
+
+void XMLConfiguration::save(const std::string& path) const
+{
+	Poco::XML::DOMWriter writer;
+	writer.setNewLine("\n");
+	writer.setOptions(Poco::XML::XMLWriter::PRETTY_PRINT);
+	writer.writeNode(path, _pDocument);
+}
+
+
+void XMLConfiguration::save(std::ostream& ostr) const
+{
+	Poco::XML::DOMWriter writer;
+	writer.setNewLine("\n");
+	writer.setOptions(Poco::XML::XMLWriter::PRETTY_PRINT);
+	writer.writeNode(ostr, _pDocument);
+}
+
+
+void XMLConfiguration::save(Poco::XML::DOMWriter& writer, const std::string& path) const
+{
+	writer.writeNode(path, _pDocument);
+}
+
+
+void XMLConfiguration::save(Poco::XML::DOMWriter& writer, std::ostream& ostr) const
+{
+	writer.writeNode(ostr, _pDocument);
+}
+
+
+bool XMLConfiguration::getRaw(const std::string& key, std::string& value) const
+{
+	const Poco::XML::Node* pNode = findNode(key);
+	if (pNode)
+	{
+		value = pNode->innerText();
+		return true;
+	}
+	else return false;
+}
+
+
+void XMLConfiguration::setRaw(const std::string& key, const std::string& value)
+{
+	std::string::const_iterator it = key.begin();
+	Poco::XML::Node* pNode = findNode(it, key.end(), _pRoot, true);
+	if (pNode)
+	{
+        unsigned short nodeType = pNode->nodeType();
+        if (Poco::XML::Node::ATTRIBUTE_NODE == nodeType)
+        {
+            pNode->setNodeValue(value);
+        }
+        else if (Poco::XML::Node::ELEMENT_NODE == nodeType)
+        {
+            Poco::XML::Node* pChildNode = pNode->firstChild();
+            if (pChildNode)
+            {
+                if (Poco::XML::Node::TEXT_NODE == pChildNode->nodeType())
+                {
+                    pChildNode->setNodeValue(value);
+                }
+            }
+            else
+            {
+				Poco::AutoPtr<Poco::XML::Node> pText = _pDocument->createTextNode(value);
+				pNode->appendChild(pText);
+            }
+        }
+	}
+    else throw NotFoundException("Node not found in XMLConfiguration", key);
+}
+
+
+void XMLConfiguration::enumerate(const std::string& key, Keys& range) const
+{
+	using Poco::NumberFormatter;
+
+	std::unordered_map<std::string, size_t> keys;
+	const Poco::XML::Node* pNode = findNode(key);
+	if (pNode)
+	{
+		const Poco::XML::Node* pChild = pNode->firstChild();
+		while (pChild)
+		{
+			if (pChild->nodeType() == Poco::XML::Node::ELEMENT_NODE)
+			{
+				const std::string& nodeName = pChild->nodeName();
+				size_t& count = keys[nodeName];
+				if (count)
+					range.push_back(nodeName + "[" + NumberFormatter::format(count) + "]");
+				else
+					range.push_back(nodeName);
+				++count;
+			}
+			pChild = pChild->nextSibling();
+		}
+	}
+}
+
+
+void XMLConfiguration::removeRaw(const std::string& key)
+{
+	Poco::XML::Node* pNode = findNode(key);
+
+	if (pNode)
+	{
+		if (pNode->nodeType() == Poco::XML::Node::ELEMENT_NODE)
+		{
+			Poco::XML::Node* pParent = pNode->parentNode();
+			if (pParent)
+			{
+				pParent->removeChild(pNode);
+			}
+		}
+		else if (pNode->nodeType() == Poco::XML::Node::ATTRIBUTE_NODE)
+		{
+			Poco::XML::Attr* pAttr = dynamic_cast<Poco::XML::Attr*>(pNode);
+			Poco::XML::Element* pOwner = pAttr->ownerElement();
+			if (pOwner)
+			{
+				pOwner->removeAttributeNode(pAttr);
+			}
+		}
+	}
+}
+
+
+const Poco::XML::Node* XMLConfiguration::findNode(const std::string& key) const
+{
+	std::string::const_iterator it = key.begin();
+	Poco::XML::Node* pRoot = const_cast<Poco::XML::Node*>(_pRoot.get());
+	return findNode(it, key.end(), pRoot);
+}
+
+
+Poco::XML::Node* XMLConfiguration::findNode(const std::string& key)
+{
+	std::string::const_iterator it = key.begin();
+	Poco::XML::Node* pRoot = const_cast<Poco::XML::Node*>(_pRoot.get());
+	return findNode(it, key.end(), pRoot);
+}
+
+
+Poco::XML::Node* XMLConfiguration::findNode(std::string::const_iterator& it, const std::string::const_iterator& end, Poco::XML::Node* pNode, bool create) const
+{
+	if (pNode && it != end)
+	{
+		if (*it == '[')
+		{
+			++it;
+			if (it != end && *it == '@')
+			{
+				++it;
+				std::string attr;
+				while (it != end && *it != ']' && *it != '=') attr += *it++;
+				if (it != end && *it == '=')
+				{
+					++it;
+					std::string value;
+					if (it != end && *it == '\'')
+					{
+						++it;
+						while (it != end && *it != '\'') value += *it++;
+						if (it != end) ++it;
+					}
+					else
+					{
+						while (it != end && *it != ']') value += *it++;
+					}
+					if (it != end) ++it;
+					return findNode(it, end, findElement(attr, value, pNode), create);
+				}
+				else
+				{
+					if (it != end) ++it;
+					return findAttribute(attr, pNode, create);
+				}
+			}
+			else
+			{
+				std::string index;
+				while (it != end && *it != ']') index += *it++;
+				if (it != end) ++it;
+				return findNode(it, end, findElement(Poco::NumberParser::parse(index), pNode, create), create);
+			}
+		}
+		else
+		{
+			while (it != end && *it == _delim) ++it;
+			std::string key;
+			while (it != end && *it != _delim && *it != '[') key += *it++;
+			return findNode(it, end, findElement(key, pNode, create), create);
+		}
+	}
+	else return pNode;
+}
+
+
+Poco::XML::Node* XMLConfiguration::findElement(const std::string& name, Poco::XML::Node* pNode, bool create)
+{
+	Poco::XML::Node* pChild = pNode->firstChild();
+	while (pChild)
+	{
+		if (pChild->nodeType() == Poco::XML::Node::ELEMENT_NODE && pChild->nodeName() == name)
+			return pChild;
+		pChild = pChild->nextSibling();
+	}
+	if (create)
+	{
+		Poco::AutoPtr<Poco::XML::Element> pElem = pNode->ownerDocument()->createElement(name);
+		pNode->appendChild(pElem);
+		return pElem;
+	}
+	else return 0;
+}
+
+
+Poco::XML::Node* XMLConfiguration::findElement(int index, Poco::XML::Node* pNode, bool create)
+{
+	Poco::XML::Node* pRefNode = pNode;
+	if (index > 0)
+	{
+		pNode = pNode->nextSibling();
+		while (pNode)
+		{
+			if (pNode->nodeName() == pRefNode->nodeName())
+			{
+				if (--index == 0) break;
+			}
+			pNode = pNode->nextSibling();
+		}
+	}
+	if (!pNode && create)
+	{
+		if (index == 1)
+		{
+			Poco::AutoPtr<Poco::XML::Element> pElem = pRefNode->ownerDocument()->createElement(pRefNode->nodeName());
+			pRefNode->parentNode()->appendChild(pElem);
+			return pElem;
+		}
+		else throw Poco::InvalidArgumentException("Element index out of range.");
+	}
+	return pNode;
+}
+
+
+Poco::XML::Node* XMLConfiguration::findElement(const std::string& attr, const std::string& value, Poco::XML::Node* pNode)
+{
+	Poco::XML::Node* pRefNode = pNode;
+	Poco::XML::Element* pElem = dynamic_cast<Poco::XML::Element*>(pNode);
+	if (!(pElem && pElem->getAttribute(attr) == value))
+	{
+		pNode = pNode->nextSibling();
+		while (pNode)
+		{
+			if (pNode->nodeName() == pRefNode->nodeName())
+			{
+				pElem = dynamic_cast<Poco::XML::Element*>(pNode);
+				if (pElem && pElem->getAttribute(attr) == value) break;
+			}
+			pNode = pNode->nextSibling();
+		}
+	}
+	return pNode;
+}
+
+
+Poco::XML::Node* XMLConfiguration::findAttribute(const std::string& name, Poco::XML::Node* pNode, bool create)
+{
+	Poco::XML::Node* pResult(0);
+	Poco::XML::Element* pElem = dynamic_cast<Poco::XML::Element*>(pNode);
+	if (pElem)
+	{
+		pResult = pElem->getAttributeNode(name);
+		if (!pResult && create)
+		{
+			Poco::AutoPtr<Poco::XML::Attr> pAttr = pNode->ownerDocument()->createAttribute(name);
+			pElem->setAttributeNode(pAttr);
+			return pAttr;
+		}
+	}
+	return pResult;
+}
+
+
+} } // namespace Poco::Util
+
+#endif // POCO_UTIL_NO_XMLCONFIGURATION
diff --git a/base/poco/XML/CMakeLists.txt b/base/poco/XML/CMakeLists.txt
new file mode 100644
index 00000000000..992cfbe763c
--- /dev/null
+++ b/base/poco/XML/CMakeLists.txt
@@ -0,0 +1,19 @@
+# Poco::XML (expat)
+
+file (GLOB SRCS_EXPAT src/xml*.c)
+
+add_library (_poco_xml_expat ${SRCS_EXPAT})
+add_library (Poco::XML::Expat ALIAS _poco_xml_expat)
+
+target_include_directories (_poco_xml_expat PUBLIC "include")
+target_include_directories (_poco_xml_expat PRIVATE "../Foundation/include")
+
+# Poco::XML
+
+file (GLOB SRCS src/*.cpp)
+add_library (_poco_xml ${SRCS})
+add_library (Poco::XML ALIAS _poco_xml)
+
+target_compile_options (_poco_xml PRIVATE -Wno-old-style-cast)
+target_include_directories (_poco_xml SYSTEM PUBLIC "include")
+target_link_libraries (_poco_xml PUBLIC Poco::Foundation Poco::XML::Expat)
diff --git a/base/poco/XML/include/Poco/DOM/AbstractContainerNode.h b/base/poco/XML/include/Poco/DOM/AbstractContainerNode.h
new file mode 100644
index 00000000000..e0f7893b335
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/AbstractContainerNode.h
@@ -0,0 +1,78 @@
+//
+// AbstractContainerNode.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the AbstractContainerNode class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_AbstractContainerNode_INCLUDED
+#define DOM_AbstractContainerNode_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractNode.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API AbstractContainerNode: public AbstractNode
+	/// AbstractContainerNode is an implementation of Node
+	/// that stores and manages child nodes.
+	///
+	/// Child nodes are organized in a single linked list.
+{
+public:
+	// Node
+	Node* firstChild() const;
+	Node* lastChild() const;
+	Node* insertBefore(Node* newChild, Node* refChild);
+	Node* replaceChild(Node* newChild, Node* oldChild);
+	Node* removeChild(Node* oldChild);
+	Node* appendChild(Node* newChild);
+	bool hasChildNodes() const;
+	bool hasAttributes() const;
+	Node* getNodeByPath(const XMLString& path) const;
+	Node* getNodeByPathNS(const XMLString& path, const NSMap& nsMap) const;
+
+protected:
+	AbstractContainerNode(Document* pOwnerDocument);
+	AbstractContainerNode(Document* pOwnerDocument, const AbstractContainerNode& node);
+	~AbstractContainerNode();
+
+	void dispatchNodeRemovedFromDocument();
+	void dispatchNodeInsertedIntoDocument();
+
+	static const Node* findNode(XMLString::const_iterator& it, const XMLString::const_iterator& end, const Node* pNode, const NSMap* pNSMap, bool& indexBound);
+	static const Node* findElement(const XMLString& name, const Node* pNode, const NSMap* pNSMap);
+	static const Node* findElement(int index, const Node* pNode, const NSMap* pNSMap);
+	static const Node* findElement(const XMLString& attr, const XMLString& value, const Node* pNode, const NSMap* pNSMap);
+	static const Attr* findAttribute(const XMLString& name, const Node* pNode, const NSMap* pNSMap);
+	bool hasAttributeValue(const XMLString& name, const XMLString& value, const NSMap* pNSMap) const;
+	static bool namesAreEqual(const Node* pNode1, const Node* pNode2, const NSMap* pNSMap);
+	static bool namesAreEqual(const Node* pNode, const XMLString& name, const NSMap* pNSMap);
+
+	static const XMLString WILDCARD;
+
+private:
+	AbstractNode* _pFirstChild;
+
+	friend class AbstractNode;
+	friend class NodeAppender;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_AbstractContainerNode_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/AbstractNode.h b/base/poco/XML/include/Poco/DOM/AbstractNode.h
new file mode 100644
index 00000000000..cedcc73920b
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/AbstractNode.h
@@ -0,0 +1,125 @@
+//
+// AbstractNode.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the AbstractNode class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_AbstractNode_INCLUDED
+#define DOM_AbstractNode_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/Node.h"
+#include "Poco/DOM/MutationEvent.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class AbstractContainerNode;
+class Attr;
+class EventDispatcher;
+
+
+class XML_API AbstractNode: public Node
+	/// AbstractNode provides a basic implementation
+	/// of the Node interface for all types of nodes
+	/// that do not contain other nodes.
+{
+public:
+	// Node
+	const XMLString& nodeName() const;
+	const XMLString& getNodeValue() const;
+	void setNodeValue(const XMLString& value);
+	Node* parentNode() const;
+	NodeList* childNodes() const;
+	Node* firstChild() const;
+	Node* lastChild() const;
+	Node* previousSibling() const;
+	Node* nextSibling() const;
+	NamedNodeMap* attributes() const;
+	Document* ownerDocument() const;
+	Node* insertBefore(Node* newChild, Node* refChild);
+	Node* replaceChild(Node* newChild, Node* oldChild);
+	Node* removeChild(Node* oldChild);
+	Node* appendChild(Node* newChild);
+	bool hasChildNodes() const;
+	Node* cloneNode(bool deep) const;
+	void normalize();
+	bool isSupported(const XMLString& feature, const XMLString& version) const;
+	const XMLString& namespaceURI() const;
+	XMLString prefix() const;
+	const XMLString& localName() const;
+	bool hasAttributes() const;
+
+	// EventTarget
+	void addEventListener(const XMLString& type, EventListener* listener, bool useCapture);
+	void removeEventListener(const XMLString& type, EventListener* listener, bool useCapture);
+	bool dispatchEvent(Event* evt);
+
+	// Extensions
+	XMLString innerText() const;
+	Node* getNodeByPath(const XMLString& path) const;
+	Node* getNodeByPathNS(const XMLString& path, const NSMap& nsMap) const;
+
+	virtual void autoRelease();
+
+protected:
+	AbstractNode(Document* pOwnerDocument);
+	AbstractNode(Document* pOwnerDocument, const AbstractNode& node);
+	~AbstractNode();
+
+	virtual Node* copyNode(bool deep, Document* pOwnerDocument) const = 0;
+
+	virtual bool events() const;
+	virtual bool eventsSuspended() const;
+	void captureEvent(Event* evt);
+	void bubbleEvent(Event* evt);
+	void dispatchSubtreeModified();
+	void dispatchNodeInserted();
+	void dispatchNodeRemoved();
+	virtual void dispatchNodeRemovedFromDocument();
+	virtual void dispatchNodeInsertedIntoDocument();
+	void dispatchAttrModified(Attr* pAttr, MutationEvent::AttrChangeType changeType, const XMLString& prevValue, const XMLString& newValue);
+	void dispatchCharacterDataModified(const XMLString& prevValue, const XMLString& newValue);
+	void setOwnerDocument(Document* pOwnerDocument);
+
+	static const XMLString EMPTY_STRING;
+
+private:
+	AbstractNode();
+
+	AbstractContainerNode* _pParent;
+	AbstractNode*          _pNext;
+	Document*              _pOwner;
+	EventDispatcher*       _pEventDispatcher;
+
+	static const XMLString NODE_NAME;
+
+	friend class AbstractContainerNode;
+	friend class Document;
+	friend class DocumentFragment;
+	friend class Element;
+	friend class Attr;
+	friend class CharacterData;
+	friend class DOMBuilder;
+	friend class NodeAppender;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_AbstractNode_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/Attr.h b/base/poco/XML/include/Poco/DOM/Attr.h
new file mode 100644
index 00000000000..13ace7ecce4
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/Attr.h
@@ -0,0 +1,180 @@
+//
+// Attr.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM Attr class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_Attr_INCLUDED
+#define DOM_Attr_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractNode.h"
+#include "Poco/DOM/Element.h"
+#include "Poco/XML/Name.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API Attr: public AbstractNode
+	/// The Attr interface represents an attribute in an Element object. Typically
+	/// the allowable values for the attribute are defined in a document type definition.
+	/// 
+	/// Attr objects inherit the Node interface, but since they are not actually
+	/// child nodes of the element they describe, the DOM does not consider them
+	/// part of the document tree. Thus, the Node attributes parentNode, previousSibling,
+	/// and nextSibling have a null value for Attr objects. The DOM takes the view
+	/// that attributes are properties of elements rather than having a separate
+	/// identity from the elements they are associated with; this should make it
+	/// more efficient to implement such features as default attributes associated
+	/// with all elements of a given type. Furthermore, Attr nodes may not be immediate
+	/// children of a DocumentFragment. However, they can be associated with Element
+	/// nodes contained within a DocumentFragment. In short, users and implementors
+	/// of the DOM need to be aware that Attr nodes have some things in common with
+	/// other objects inheriting the Node interface, but they also are quite distinct.
+	/// 
+	/// The attribute's effective value is determined as follows: if this attribute
+	/// has been explicitly assigned any value, that value is the attribute's effective
+	/// value; otherwise, if there is a declaration for this attribute, and that
+	/// declaration includes a default value, then that default value is the attribute's
+	/// effective value; otherwise, the attribute does not exist on this element
+	/// in the structure model until it has been explicitly added. Note that the
+	/// nodeValue attribute on the Attr instance can also be used to retrieve the
+	/// string version of the attribute's value(s).
+	/// 
+	/// In XML, where the value of an attribute can contain entity references, the
+	/// child nodes of the Attr node provide a representation in which entity references
+	/// are not expanded. These child nodes may be either Text or EntityReference
+	/// nodes. Because the attribute type may be unknown, there are no tokenized
+	/// attribute values.
+{
+public:
+	const XMLString& name() const;
+		/// Returns the name of this attribute.
+
+	bool specified() const;
+		/// If this attribute was explicitly given a value in the original document,
+		/// this is true; otherwise, it is false. Note that the implementation is in
+		/// charge of this attribute, not the user. If the user changes the value of
+		/// the attribute (even if it ends up having the same value as the default value)
+		/// then the specified flag is automatically flipped to true. To re-specify
+		/// the attribute as the default value from the DTD, the user must delete the
+		/// attribute. The implementation will then make a new attribute available with
+		/// specified set to false and the default value (if one exists).
+		/// In summary:
+		/// 
+		///     * If the attribute has an assigned value in the document then specified
+		///       is true, and the value is the assigned value.
+		///     * If the attribute has no assigned value in the document and has a default
+		///       value in the DTD, then specified is false, and the value is the default
+		///       value in the DTD.
+		///     * If the attribute has no assigned value in the document and has a value
+		///       of #IMPLIED in the DTD, then the attribute does not appear in the structure
+		///       model of the document.
+		///     * If the attribute is not associated to any element (i.e. because it
+		///       was just created or was obtained from some removal or cloning operation)
+		///       specified is true.
+
+	const XMLString& value() const;
+		/// Returns the value of the attribute as a string. Character
+		/// and general entity references are replaced with their values. See also the
+		/// method getAttribute on the Element interface.
+
+	const XMLString& getValue() const;
+		/// Returns the value of the attribute as a string. Character
+		/// and general entity references are replaced with their values. See also the
+		/// method getAttribute on the Element interface.
+
+	void setValue(const XMLString& value);
+		/// Sets the value of the attribute as a string.
+		/// This creates a Text node with the unparsed contents of the string.
+		/// I.e. any characters that an XML processor would recognize as markup are
+		/// instead treated as literal text. See also the method setAttribute on the
+		/// Element interface.
+
+	// DOM Level 2
+	Element* ownerElement() const;
+		/// The Element node this attribute is attached to or null 
+		/// if this attribute is not in use.
+
+	// Node
+	Node* parentNode() const;
+	const XMLString& nodeName() const;
+	const XMLString& getNodeValue() const;
+	void setNodeValue(const XMLString& value);
+	unsigned short nodeType() const;
+	Node* previousSibling() const;
+	const XMLString& namespaceURI() const;
+	XMLString prefix() const;
+	const XMLString& localName() const;
+
+	// Non-standard extensions
+	XMLString innerText() const;
+
+protected:
+	Attr(Document* pOwnerDocument, Element* pOwnerElement, const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const XMLString& value, bool specified = true);
+	Attr(Document* pOwnerDocument, const Attr& attr);
+	~Attr();
+	
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+
+private:
+	const Name& _name;
+	XMLString   _value;
+	bool        _specified;
+
+	friend class Document;
+	friend class Element;
+	friend class DOMBuilder;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& Attr::name() const
+{
+	return _name.qname();
+}
+
+
+inline const XMLString& Attr::value() const
+{
+	return _value;
+}
+
+
+inline const XMLString& Attr::getValue() const
+{
+	return _value;
+}
+
+
+inline bool Attr::specified() const
+{
+	return _specified;
+}
+
+
+inline Element* Attr::ownerElement() const
+{
+	return static_cast<Element*>(_pParent);
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_Attr_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/AttrMap.h b/base/poco/XML/include/Poco/DOM/AttrMap.h
new file mode 100644
index 00000000000..41f34fd6380
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/AttrMap.h
@@ -0,0 +1,65 @@
+//
+// AttrMap.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the AttrMap class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_AttrMap_INCLUDED
+#define DOM_AttrMap_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/NamedNodeMap.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Element;
+
+
+class XML_API AttrMap: public NamedNodeMap
+	// This implementation of NamedNodeMap is
+	// returned by Element::attributes()
+{
+public:
+	Node* getNamedItem(const XMLString& name) const;
+	Node* setNamedItem(Node* arg);
+	Node* removeNamedItem(const XMLString& name);
+	Node* item(unsigned long index) const;
+	unsigned long length() const;
+
+	Node* getNamedItemNS(const XMLString& namespaceURI, const XMLString& localName) const;
+	Node* setNamedItemNS(Node* arg);
+	Node* removeNamedItemNS(const XMLString& namespaceURI, const XMLString& localName);
+
+	void autoRelease();
+
+protected:
+	AttrMap(Element* pElement);
+	~AttrMap();
+
+private:
+	AttrMap();
+
+	Element* _pElement;
+	
+	friend class Element;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_AttrMap_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/AutoPtr.h b/base/poco/XML/include/Poco/DOM/AutoPtr.h
new file mode 100644
index 00000000000..85f83d49f7d
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/AutoPtr.h
@@ -0,0 +1,35 @@
+//
+// AutoPtr.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Import Poco::AutoPtr into the XML namespace.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DOMAutoPtr_INCLUDED
+#define DOM_DOMAutoPtr_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/AutoPtr.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+using Poco::AutoPtr;
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DOMAutoPtr_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/CDATASection.h b/base/poco/XML/include/Poco/DOM/CDATASection.h
new file mode 100644
index 00000000000..7a0e82b18a1
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/CDATASection.h
@@ -0,0 +1,84 @@
+//
+// CDATASection.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM CDATASection class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_CDATASection_INCLUDED
+#define DOM_CDATASection_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/Text.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API CDATASection: public Text
+	/// CDATA sections are used to escape blocks of text containing characters that
+	/// would otherwise be regarded as markup. The only delimiter that is recognized
+	/// in a CDATA section is the "]]>" string that ends the CDATA section. CDATA
+	/// sections cannot be nested. Their primary purpose is for including material
+	/// such as XML fragments, without needing to escape all the delimiters.
+	/// 
+	/// The DOMString attribute of the Text node holds the text that is contained
+	/// by the CDATA section. Note that this may contain characters that need to
+	/// be escaped outside of CDATA sections and that, depending on the character
+	/// encoding ("charset") chosen for serialization, it may be impossible to write
+	/// out some characters as part of a CDATA section.
+	/// 
+	/// The CDATASection interface inherits from the CharacterData interface through
+	/// the Text interface. Adjacent CDATASection nodes are not merged by use of
+	/// the normalize method on the Element interface.
+	/// 
+	/// Note: Because no markup is recognized within a CDATASection, character numeric
+	/// references cannot be used as an escape mechanism when serializing. Therefore,
+	/// action needs to be taken when serializing a CDATASection with a character
+	/// encoding where some of the contained characters cannot be represented. Failure
+	/// to do so would not produce well-formed XML.
+	/// One potential solution in the serialization process is to end the CDATA
+	/// section before the character, output the character using a character reference
+	/// or entity reference, and open a new CDATA section for any further characters
+	/// in the text node. Note, however, that some code conversion libraries at
+	/// the time of writing do not return an error or exception when a character
+	/// is missing from the encoding, making the task of ensuring that data is not
+	/// corrupted on serialization more difficult.
+{
+public:
+	// Text
+	Text* splitText(unsigned long offset);
+
+	// Node
+	const XMLString& nodeName() const;
+	unsigned short nodeType() const;
+
+protected:
+	CDATASection(Document* pOwnerDocument, const XMLString& data);
+	CDATASection(Document* pOwnerDocument, const CDATASection& sec);
+	~CDATASection();
+
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+
+private:
+	static const XMLString NODE_NAME;
+	
+	friend class Document;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_CDATASection_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/CharacterData.h b/base/poco/XML/include/Poco/DOM/CharacterData.h
new file mode 100644
index 00000000000..af5697da7fd
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/CharacterData.h
@@ -0,0 +1,123 @@
+//
+// CharacterData.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM CharacterData class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_CharacterData_INCLUDED
+#define DOM_CharacterData_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractNode.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API CharacterData: public AbstractNode
+	/// The CharacterData interface extends Node with a set of attributes and methods
+	/// for accessing character data in the DOM. For clarity this set is defined
+	/// here rather than on each object that uses these attributes and methods.
+	/// No DOM objects correspond directly to CharacterData, though Text and others
+	/// do inherit the interface from it. All offsets in this interface start from 0.
+	/// 
+	/// Text strings in the DOM are represented in either UTF-8 (if XML_UNICODE_WCHAR_T is
+	/// not defined) or in UTF-16 (if XML_UNICODE_WCHAR_T is defined).
+	/// Indexing on character data is done in XMLChar units.
+{
+public:
+	const XMLString& data() const;
+		/// Returns the character data of the node that 
+		/// implements the interface.
+	
+	const XMLString& getData() const;
+		/// Returns the character data of the node that 
+		/// implements the interface.
+
+	void setData(const XMLString& data);
+		/// Sets the character data of the node that
+		/// implements the interface.
+
+	unsigned long length() const;
+		/// Returns the number of XMLChars that are available
+		/// through getData and substringData. This may have the
+		/// value zero.
+
+	XMLString substringData(unsigned long offset, unsigned long count) const;
+		/// Extracts a range of data from the node.
+		/// If offset and count exceeds the length, then all
+		/// the characters to the end of the data are returned.
+
+	void appendData(const XMLString& arg);
+		/// Append the string to the end of the character data
+		/// of the node.
+
+	void insertData(unsigned long offset, const XMLString& arg);
+		/// Insert a string at the specified character offset.
+
+	void deleteData(unsigned long offset, unsigned long count);
+		/// Remove a range of characters from the node.
+
+	void replaceData(unsigned long offset, unsigned long count, const XMLString& arg);
+		/// Replace the characters starting at the specified character
+		/// offset with the specified string.
+
+	// Non-standard extensions
+	XMLString trimmedData() const;
+		/// Returns the character data of that node with
+		/// all surrounding whitespace removed.
+		///
+		/// This method is an extension to the W3C Document Object Model.
+
+	// Node
+	const XMLString& getNodeValue() const;
+	void setNodeValue(const XMLString& value);
+
+protected:
+	CharacterData(Document* pOwnerDocument, const XMLString& data);
+	CharacterData(Document* pOwnerDocument, const CharacterData& data);
+	~CharacterData();
+
+private:
+	XMLString _data;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& CharacterData::data() const
+{
+	return _data;
+}
+
+
+inline const XMLString& CharacterData::getData() const
+{
+	return _data;
+}
+
+
+inline unsigned long CharacterData::length() const
+{
+	return (unsigned long) _data.length();
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_CharacterData_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/ChildNodesList.h b/base/poco/XML/include/Poco/DOM/ChildNodesList.h
new file mode 100644
index 00000000000..aa7ece1db81
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/ChildNodesList.h
@@ -0,0 +1,55 @@
+//
+// ChildNodesList.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the ChildNodesList class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_ChildNodesList_INCLUDED
+#define DOM_ChildNodesList_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/NodeList.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API ChildNodesList: public NodeList
+	// This implementation of NodeList is returned
+	// by Node::getChildNodes().
+{
+public:
+	Node* item(unsigned long index) const;
+	unsigned long length() const;
+
+	void autoRelease();
+
+protected:
+	ChildNodesList(const Node* pParent);
+	~ChildNodesList();
+	
+private:
+	ChildNodesList();
+
+	const Node* _pParent;
+	
+	friend class AbstractNode;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_ChildNodesList_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/Comment.h b/base/poco/XML/include/Poco/DOM/Comment.h
new file mode 100644
index 00000000000..d1de7930647
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/Comment.h
@@ -0,0 +1,58 @@
+//
+// Comment.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM Comment class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_Comment_INCLUDED
+#define DOM_Comment_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/CharacterData.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API Comment: public CharacterData
+	/// This interface inherits from CharacterData and represents the content of
+	/// a comment, i.e., all the characters between the starting '<!--' and ending
+	/// '-->'. Note that this is the definition of a comment in XML, and, in practice,
+	/// HTML, although some HTML tools may implement the full SGML comment structure.
+{
+public:
+	// Node
+	const XMLString& nodeName() const;
+	unsigned short nodeType() const;
+
+protected:
+	Comment(Document* pOwnerDocument, const XMLString& data);
+	Comment(Document* pOwnerDocument, const Comment& comment);
+	~Comment();
+
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+
+private:
+	static const XMLString NODE_NAME;
+	
+	friend class Document;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_Comment_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/DOMBuilder.h b/base/poco/XML/include/Poco/DOM/DOMBuilder.h
new file mode 100644
index 00000000000..ad91da45f4d
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/DOMBuilder.h
@@ -0,0 +1,112 @@
+//
+// DOMBuilder.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMBuilder
+//
+// Definition of the DOMBuilder class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DOMBuilder_INCLUDED
+#define DOM_DOMBuilder_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/SAX/ContentHandler.h"
+#include "Poco/SAX/LexicalHandler.h"
+#include "Poco/SAX/DTDHandler.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XMLReader;
+class Document;
+class InputSource;
+class AbstractNode;
+class AbstractContainerNode;
+class NamePool;
+
+
+class XML_API DOMBuilder: protected DTDHandler, protected ContentHandler, protected LexicalHandler
+	/// This class builds a tree representation of an
+	/// XML document, according to the W3C Document Object Model, Level 1 and 2
+	/// specifications.
+	///
+	/// The actual XML parsing is done by an XMLReader, which
+	/// must be supplied to the DOMBuilder.
+{
+public:
+	DOMBuilder(XMLReader& xmlReader, NamePool* pNamePool = 0);
+		/// Creates a DOMBuilder using the given XMLReader. 
+		/// If a NamePool is given, it becomes the Document's NamePool.
+
+	virtual ~DOMBuilder();
+		/// Destroys the DOMBuilder.
+
+	virtual Document* parse(const XMLString& uri);
+		/// Parse an XML document from a location identified by an URI.
+
+	virtual Document* parse(InputSource* pInputSource);
+		/// Parse an XML document from a location identified by an InputSource.
+
+	virtual Document* parseMemoryNP(const char* xml, std::size_t size);
+		/// Parses an XML document from memory.
+
+protected:
+	// DTDHandler
+	void notationDecl(const XMLString& name, const XMLString* publicId, const XMLString* systemId);
+	void unparsedEntityDecl(const XMLString& name, const XMLString* publicId, const XMLString& systemId, const XMLString& notationName);
+
+	// ContentHandler
+	void setDocumentLocator(const Locator* loc);
+	void startDocument();
+	void endDocument();
+	void startElement(const XMLString& uri, const XMLString& localName, const XMLString& qname, const Attributes& attributes);
+	void endElement(const XMLString& uri, const XMLString& localName, const XMLString& qname);
+	void characters(const XMLChar ch[], int start, int length);
+	void ignorableWhitespace(const XMLChar ch[], int start, int length);
+	void processingInstruction(const XMLString& target, const XMLString& data);
+	void startPrefixMapping(const XMLString& prefix, const XMLString& uri);
+	void endPrefixMapping(const XMLString& prefix);
+	void skippedEntity(const XMLString& name);
+
+	// LexicalHandler
+	void startDTD(const XMLString& name, const XMLString& publicId, const XMLString& systemId);
+	void endDTD();
+	void startEntity(const XMLString& name);
+	void endEntity(const XMLString& name);
+	void startCDATA();
+	void endCDATA();
+	void comment(const XMLChar ch[], int start, int length); 
+
+	void appendNode(AbstractNode* pNode);
+	
+	void setupParse();
+
+private:
+	static const XMLString EMPTY_STRING;
+
+	XMLReader&             _xmlReader;
+	NamePool*              _pNamePool;
+	Document*              _pDocument;
+	AbstractContainerNode* _pParent;
+	AbstractNode*          _pPrevious;
+	bool                   _inCDATA;
+	bool                   _namespaces;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DOMBuilder_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/DOMException.h b/base/poco/XML/include/Poco/DOM/DOMException.h
new file mode 100644
index 00000000000..456526f1116
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/DOMException.h
@@ -0,0 +1,112 @@
+//
+// DOMException.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM DOMException class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DOMException_INCLUDED
+#define DOM_DOMException_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLException.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API DOMException: public XMLException
+	/// DOM operations only raise exceptions in "exceptional" circumstances, i.e.,
+	/// when an operation is impossible to perform (either for logical reasons,
+	/// because data is lost, or because the implementation has become unstable).
+	/// In general, DOM methods return specific error values in ordinary processing
+	/// situations, such as out-of-bound errors when using NodeList.
+	/// 
+	/// Implementations should raise other exceptions under other circumstances.
+	/// For example, implementations should raise an implementation-dependent exception
+	/// if a null argument is passed when null was not expected.
+{
+public:
+	enum
+	{
+		INDEX_SIZE_ERR = 1,          /// index or size is negative or greater than allowed value
+		DOMSTRING_SIZE_ERR,          /// the specified range of text does not fit into a DOMString (not used)
+		HIERARCHY_REQUEST_ERR,       /// a node is inserted somewhere it doesn't belong
+		WRONG_DOCUMENT_ERR,          /// a node is used in a different document than the one that created it
+		INVALID_CHARACTER_ERR,       /// an invalid character is specified (not used)
+		NO_DATA_ALLOWED_ERR,         /// data is specified for a node which does not support data
+		NO_MODIFICATION_ALLOWED_ERR, /// an attempt is made to modify an object where modifications are not allowed
+		NOT_FOUND_ERR,               /// an attempt was made to reference a node in a context where it does not exist
+		NOT_SUPPORTED_ERR,           /// the implementation does not support the type of object requested
+		INUSE_ATTRIBUTE_ERR,         /// an attempt is made to add an attribute that is already in use elsewhere
+		INVALID_STATE_ERR,           /// a parameter or an operation is not supported by the underlying object
+		SYNTAX_ERR,                  /// an invalid or illegal string is specified
+		INVALID_MODIFICATION_ERR,    /// an attempt is made to modify the type of the underlying object
+		NAMESPACE_ERR,               /// an attempt is made to create or change an object in a way which is incorrect with regard to namespaces
+		INVALID_ACCESS_ERR,          /// an attempt is made to use an object that is not, or is no longer, usable
+		
+		_NUMBER_OF_MESSAGES
+	};
+
+	DOMException(unsigned short code);
+		/// Creates a DOMException with the given error code.
+		
+	DOMException(const DOMException& exc);
+		/// Creates a DOMException by copying another one.
+		
+	~DOMException() noexcept;
+		/// Destroys the DOMException.
+		
+	DOMException& operator = (const DOMException& exc);
+
+	const char* name() const noexcept;
+		/// Returns a static string describing the exception.
+
+	const char* className() const noexcept;
+		/// Returns the name of the exception class.
+
+	Poco::Exception* clone() const;
+		/// Creates an exact copy of the exception.
+		
+	void rethrow() const;
+		/// (Re)Throws the exception.
+
+	unsigned short code() const;
+		/// Returns the DOM exception code.
+
+protected:
+	static const std::string& message(unsigned short code);
+	
+private:
+	DOMException();
+	
+	unsigned short _code;
+	
+	static const std::string MESSAGES[_NUMBER_OF_MESSAGES];
+};
+
+
+//
+// inlines
+//
+inline unsigned short DOMException::code() const
+{
+	return _code;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DOMException_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/DOMImplementation.h b/base/poco/XML/include/Poco/DOM/DOMImplementation.h
new file mode 100644
index 00000000000..0c2d7af1878
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/DOMImplementation.h
@@ -0,0 +1,82 @@
+//
+// DOMImplementation.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM DOMImplementation class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DOMImplementation_INCLUDED
+#define DOM_DOMImplementation_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class DocumentType;
+class Document;
+class NamePool;
+
+
+class XML_API DOMImplementation
+	/// The DOMImplementation interface provides a number of methods for
+	/// performing operations that are independent of any particular instance
+	/// of the document object model.
+	/// In this implementation, DOMImplementation is implemented as a singleton.
+{
+public:
+	DOMImplementation();
+		/// Creates the DOMImplementation.
+		
+	~DOMImplementation();
+		/// Destroys the DOMImplementation.
+
+	bool hasFeature(const XMLString& feature, const XMLString& version) const;
+		/// Tests if the DOM implementation implements a specific feature.
+		///
+		/// The only supported features are "XML", version "1.0" and "Core", 
+		/// "Events", "MutationEvents" and "Traversal", version "2.0".
+	
+	// DOM Level 2
+	DocumentType* createDocumentType(const XMLString& name, const XMLString& publicId, const XMLString& systemId) const;
+		/// Creates an empty DocumentType node. Entity declarations and notations 
+		/// are not made available. Entity reference expansions and default attribute 
+		/// additions do not occur.
+
+	Document* createDocument(const XMLString& namespaceURI, const XMLString& qualifiedName, DocumentType* doctype) const;
+		/// Creates an XML Document object of the specified type with its document element.
+		///
+		/// Note: You can also create a Document directly using the new operator.
+
+	static const DOMImplementation& instance();
+		/// Returns a reference to the default DOMImplementation
+		/// object.
+		
+private:
+	static const XMLString FEATURE_XML;
+	static const XMLString FEATURE_CORE;
+	static const XMLString FEATURE_EVENTS;
+	static const XMLString FEATURE_MUTATIONEVENTS;
+	static const XMLString FEATURE_TRAVERSAL;
+	static const XMLString VERSION_1_0;
+	static const XMLString VERSION_2_0;	
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DOMImplementation_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/DOMObject.h b/base/poco/XML/include/Poco/DOM/DOMObject.h
new file mode 100644
index 00000000000..40b29fb2cf7
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/DOMObject.h
@@ -0,0 +1,103 @@
+//
+// DOMObject.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOMObject class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DOMObject_INCLUDED
+#define DOM_DOMObject_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API DOMObject
+	/// The base class for all objects in the Document Object Model.
+	///
+	/// DOMObject defines the rules for memory management
+	/// in this implementation of the DOM. Violation of these
+	/// rules, which are outlined in the following, results
+	/// in memory leaks or dangling pointers.
+	///
+	/// Every object created by new or by a factory
+	/// method (for example, Document::create*) must be released
+	/// with a call to release() or autoRelease() when it
+	/// is no longer needed.
+	///
+	/// Every object created by cloning or importing another
+	/// object must be released.
+	/// For every call to duplicate() there must be a matching
+	/// call to release().
+	/// An object obtained via any other way must not be
+	/// released, except ownership of it has been explicitly
+	/// taken with a call to duplicate().
+	///
+	/// While DOMObjects are safe for use in multithreaded programs,
+	/// a DOMObject or one of its subclasses must not be accessed
+	/// from multiple threads simultaneously.
+{
+public:
+	DOMObject();
+		/// Creates the DOMObject.
+		/// The object's reference count is initialized to one.
+
+	void duplicate() const;
+		/// Increases the object's reference count.
+
+	void release() const;
+		/// Decreases the object's reference count.
+		/// If the reference count reaches zero,
+		/// the object is deleted.
+		
+	virtual void autoRelease() = 0;
+		/// Adds the object to an appropriate
+		/// AutoReleasePool, which is usually the
+		/// AutoReleasePool managed by the Document
+		/// to which this object belongs.
+
+protected:
+	virtual ~DOMObject();
+		/// Destroys the DOMObject.
+
+private:
+	DOMObject(const DOMObject&);
+	DOMObject& operator = (const DOMObject&);
+	
+	mutable int _rc;
+};
+
+
+//
+// inlines
+//
+inline void DOMObject::duplicate() const
+{
+	++_rc;
+}
+
+
+inline void DOMObject::release() const
+{
+	if (--_rc == 0)
+		delete this;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DOMObject_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/DOMParser.h b/base/poco/XML/include/Poco/DOM/DOMParser.h
new file mode 100644
index 00000000000..69d0f5aaac7
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/DOMParser.h
@@ -0,0 +1,114 @@
+//
+// DOMParser.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMParser
+//
+// Definition of the DOMParser class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DOMParser_INCLUDED
+#define DOM_DOMParser_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/SAX/SAXParser.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class NamePool;
+class Document;
+class InputSource;
+class EntityResolver;
+
+
+class XML_API DOMParser
+	/// This is a convenience class that combines a
+	/// DOMBuilder with a SAXParser, with the optional
+	/// support of a WhitespaceFilter.
+{
+public:
+	explicit DOMParser(NamePool* pNamePool = 0);
+		/// Creates a new DOMParser. 
+		/// If a NamePool is given, it becomes the Document's NamePool.
+		
+	explicit DOMParser(unsigned long namePoolSize);
+		/// Creates a new DOMParser, using the given NamePool size.
+		///
+		/// The given namePoolSize should be a suitable prime number, 
+		/// e.g. 251, 509, 1021 or 4093, depending on the expected
+		/// size of the document.
+
+	~DOMParser();
+		/// Destroys the DOMParser.
+
+	void setEncoding(const XMLString& encoding);
+		/// Sets the encoding used by the parser if no
+		/// encoding is specified in the XML document.
+		
+	const XMLString& getEncoding() const;
+		/// Returns the name of the encoding used by
+		/// the parser if no encoding is specified in
+		/// the XML document.
+
+	void addEncoding(const XMLString& name, Poco::TextEncoding* pEncoding);
+		/// Adds an encoding to the parser.
+
+	void setFeature(const XMLString& name, bool state);
+		/// Set the state of a feature.
+		///
+		/// If a feature is not recognized by the DOMParser, it is
+		/// passed on to the underlying XMLReader.
+		///
+		/// The only currently supported feature is
+		/// http://www.appinf.com/features/no-whitespace-in-element-content
+		/// which, when activated, causes the WhitespaceFilter to
+		/// be used.
+
+	bool getFeature(const XMLString& name) const;
+		/// Look up the value of a feature.
+		///
+		/// If a feature is not recognized by the DOMParser, the
+		/// DOMParser queries the underlying SAXParser for the feature.
+
+	Document* parse(const XMLString& uri);
+		/// Parse an XML document from a location identified by an URI.
+
+	Document* parse(InputSource* pInputSource);
+		/// Parse an XML document from a location identified by an InputSource.
+
+	Document* parseString(const std::string& xml);
+		/// Parse an XML document from a string.
+
+	Document* parseMemory(const char* xml, std::size_t size);
+		/// Parse an XML document from memory.
+
+	EntityResolver* getEntityResolver() const;
+		/// Returns the entity resolver used by the underlying SAXParser.
+
+	void setEntityResolver(EntityResolver* pEntityResolver);
+		/// Sets the entity resolver on the underlying SAXParser.
+
+	static const XMLString FEATURE_FILTER_WHITESPACE;
+	
+private:
+	SAXParser _saxParser;
+	NamePool* _pNamePool;
+	bool      _filterWhitespace;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DOMParser_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/DOMSerializer.h b/base/poco/XML/include/Poco/DOM/DOMSerializer.h
new file mode 100644
index 00000000000..b535105dcad
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/DOMSerializer.h
@@ -0,0 +1,122 @@
+//
+// DOMSerializer.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMSerializer
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DOMSerializer_INCLUDED
+#define DOM_DOMSerializer_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/SAX/XMLReader.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Node;
+class Element;
+class Text;
+class Comment;
+class ProcessingInstruction;
+class Entity;
+class CDATASection;
+class Notation;
+class Document;
+class DocumentType;
+class DocumentFragment;
+class DeclHandler;
+class LexicalHandler;
+
+
+class XML_API DOMSerializer: public XMLReader
+	/// The DOMSerializer serializes a DOM document
+	/// into a sequence of SAX events which are
+	/// reported to the registered SAX event
+	/// handlers.
+	///
+	/// The DOMWriter uses a DOMSerializer with an
+	/// XMLWriter to serialize a DOM document into
+	/// textual XML.
+{
+public:
+	DOMSerializer();
+		/// Creates the DOMSerializer.
+		
+	~DOMSerializer();
+		/// Destroys the DOMSerializer.
+		
+	void serialize(const Node* pNode);
+		/// Serializes a DOM node and its children
+		/// into a sequence of SAX events, which are
+		/// reported to the registered SAX event
+		/// handlers.
+
+	// XMLReader
+	void setEntityResolver(EntityResolver* pResolver);
+	EntityResolver* getEntityResolver() const;
+	void setDTDHandler(DTDHandler* pDTDHandler);
+	DTDHandler* getDTDHandler() const;
+	void setContentHandler(ContentHandler* pContentHandler);
+	ContentHandler* getContentHandler() const;
+	void setErrorHandler(ErrorHandler* pErrorHandler);
+	ErrorHandler* getErrorHandler() const;
+
+	void setFeature(const XMLString& featureId, bool state);
+	bool getFeature(const XMLString& featureId) const;
+	void setProperty(const XMLString& propertyId, const XMLString& value);
+	void setProperty(const XMLString& propertyId, void* value);
+	void* getProperty(const XMLString& propertyId) const;
+
+protected:
+	void parse(InputSource* pSource);
+		/// The DOMSerializer cannot parse an InputSource,
+		/// so this method simply throws an XMLException when invoked.
+		
+	void parse(const XMLString& systemId);
+		/// The DOMSerializer cannot parse from a system identifier,
+		/// so this method simply throws an XMLException when invoked.
+
+	void parseMemoryNP(const char* xml, std::size_t size);
+		/// The DOMSerializer cannot parse from a system identifier,
+		/// so this method simply throws an XMLException when invoked.
+
+	void iterate(const Node* pNode) const;
+	void handleNode(const Node* pNode) const;
+	void handleElement(const Element* pElement) const;
+	void handleCharacterData(const Text* pText) const;
+	void handleComment(const Comment* pComment) const;
+	void handlePI(const ProcessingInstruction* pPI) const;
+	void handleCDATASection(const CDATASection* pCDATA) const;
+	void handleDocument(const Document* pDocument) const;
+	void handleDocumentType(const DocumentType* pDocumentType) const;
+	void handleFragment(const DocumentFragment* pFragment) const;
+	void handleNotation(const Notation* pNotation) const;
+	void handleEntity(const Entity* pEntity) const;
+
+private:
+	EntityResolver* _pEntityResolver;
+	DTDHandler*     _pDTDHandler;
+	ContentHandler* _pContentHandler;
+	ErrorHandler*   _pErrorHandler;
+	DeclHandler*    _pDeclHandler;
+	LexicalHandler* _pLexicalHandler;
+	
+	static const XMLString CDATA;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DOMSerializer_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/DOMWriter.h b/base/poco/XML/include/Poco/DOM/DOMWriter.h
new file mode 100644
index 00000000000..5a5132d5664
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/DOMWriter.h
@@ -0,0 +1,127 @@
+//
+// DOMWriter.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMWriter
+//
+// Definition of class DOMWriter.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DOMWriter_INCLUDED
+#define DOM_DOMWriter_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+#include "Poco/XML/XMLStream.h"
+#include "Poco/TextEncoding.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Node;
+class Document;
+
+
+class XML_API DOMWriter
+	/// The DOMWriter uses a DOMSerializer with an
+	/// XMLWriter to serialize a DOM document into
+	/// textual XML.
+{
+public:
+	DOMWriter();
+		/// Creates a DOMWriter.
+		
+	~DOMWriter();
+		/// Destroys a DOMWriter.
+
+	void setEncoding(const std::string& encodingName, Poco::TextEncoding& textEncoding);
+		/// Sets the encoding, which will be reflected in the written XML declaration.
+
+	const std::string& getEncoding() const;
+		/// Returns the encoding name set with setEncoding.
+
+	void setOptions(int options);
+		/// Sets options for the internal XMLWriter.
+		///
+		/// See class XMLWriter for available options.
+
+	int getOptions() const;
+		/// Returns the options for the internal XMLWriter.
+
+	void setNewLine(const std::string& newLine);
+		/// Sets the line ending characters for the internal
+		/// XMLWriter. See XMLWriter::setNewLine() for a list
+		/// of supported values. 
+
+	const std::string& getNewLine() const;
+		/// Returns the line ending characters used by the
+		/// internal XMLWriter.
+
+	void setIndent(const std::string& indent);
+		/// Sets the string used for one indentation step.
+		///
+		/// The default is a single TAB character.
+		/// The given string should only contain TAB or SPACE
+		/// characters (e.g., a single TAB character, or
+		/// two to four SPACE characters).
+		
+	const std::string& getIndent() const;
+		/// Returns the string used for one indentation step.
+
+	void writeNode(XMLByteOutputStream& ostr, const Node* pNode);
+		/// Writes the XML for the given node to the specified stream.
+
+	void writeNode(const std::string& systemId, const Node* pNode);
+		/// Writes the XML for the given node to the file specified in systemId,
+		/// using a standard file output stream (Poco::FileOutputStream).
+
+private:
+	std::string         _encodingName;
+	Poco::TextEncoding* _pTextEncoding;
+	int                 _options;
+	std::string         _newLine;
+	std::string         _indent;
+};
+
+
+//
+// inlines
+//
+inline const std::string& DOMWriter::getEncoding() const
+{
+	return _encodingName;
+}
+
+
+inline int DOMWriter::getOptions() const
+{
+	return _options;
+}
+
+
+inline const std::string& DOMWriter::getNewLine() const
+{
+	return _newLine;
+}
+
+
+inline const std::string& DOMWriter::getIndent() const
+{
+	return _indent;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DOMWriter_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/DTDMap.h b/base/poco/XML/include/Poco/DOM/DTDMap.h
new file mode 100644
index 00000000000..2a475c358ef
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/DTDMap.h
@@ -0,0 +1,67 @@
+//
+// DTDMap.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DTDMap class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DTDMap_INCLUDED
+#define DOM_DTDMap_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/NamedNodeMap.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class DocumentType;
+
+
+class XML_API DTDMap: public NamedNodeMap
+	/// This implementation of NamedNodeMap
+	/// is returned by DocumentType::entities()
+	/// and DocumentType::notations(). 
+{
+public:
+	Node* getNamedItem(const XMLString& name) const;
+	Node* setNamedItem(Node* arg);
+	Node* removeNamedItem(const XMLString& name);
+	Node* item(unsigned long index) const;
+	unsigned long length() const;
+
+	Node* getNamedItemNS(const XMLString& namespaceURI, const XMLString& localName) const;
+	Node* setNamedItemNS(Node* arg);
+	Node* removeNamedItemNS(const XMLString& namespaceURI, const XMLString& localName);
+
+	void autoRelease();
+
+protected:
+	DTDMap(const DocumentType* pDocumentType, unsigned short type);
+	~DTDMap();
+
+private:
+	DTDMap();
+	
+	const DocumentType* _pDocumentType;
+	unsigned short _type;
+	
+	friend class DocumentType;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DTDMap_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/Document.h b/base/poco/XML/include/Poco/DOM/Document.h
new file mode 100644
index 00000000000..082191c0824
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/Document.h
@@ -0,0 +1,285 @@
+//
+// Document.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM Document class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_Document_INCLUDED
+#define DOM_Document_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractContainerNode.h"
+#include "Poco/DOM/DocumentEvent.h"
+#include "Poco/DOM/Element.h"
+#include "Poco/XML/XMLString.h"
+#include "Poco/XML/NamePool.h"
+#include "Poco/AutoReleasePool.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class NamePool;
+class DocumentType;
+class DOMImplementation;
+class DocumentFragment;
+class Text;
+class Comment;
+class CDATASection;
+class ProcessingInstruction;
+class Attr;
+class EntityReference;
+class NodeList;
+class Entity;
+class Notation;
+
+
+class XML_API Document: public AbstractContainerNode, public DocumentEvent
+	/// The Document interface represents the entire HTML or XML document. Conceptually, 
+	/// it is the root of the document tree, and provides the primary access to the 
+	/// document's data.
+	///
+	/// Since elements, text nodes, comments, processing instructions, etc. cannot exist 
+	/// outside the context of a Document, the Document interface also contains the 
+	/// factory methods needed to create these objects. The Node objects created have a 
+	/// ownerDocument attribute which associates them with the Document within whose 
+	/// context they were created.
+{
+public:
+	using AutoReleasePool = Poco::AutoReleasePool<DOMObject>;
+
+	explicit Document(NamePool* pNamePool = 0);
+		/// Creates a new document. If pNamePool == 0, the document
+		/// creates its own name pool, otherwise it uses the given name pool.
+		/// Sharing a name pool makes sense for documents containing instances
+		/// of the same schema, thus reducing memory usage.
+		
+	explicit Document(unsigned long namePoolSize);
+		/// Creates a new document using a name pool with the given size, which
+		/// should be a prime number (e.g., 251, 509, 1021, 4093).
+
+	Document(DocumentType* pDocumentType, NamePool* pNamePool = 0);
+		/// Creates a new document. If pNamePool == 0, the document
+		/// creates its own name pool, otherwise it uses the given name pool.
+		/// Sharing a name pool makes sense for documents containing instances
+		/// of the same schema, thus reducing memory usage.
+
+	Document(DocumentType* pDocumentType, unsigned long namePoolSize);
+		/// Creates a new document using a name pool with the given size, which
+		/// should be a prime number (e.g., 251, 509, 1021, 4093).
+
+	NamePool& namePool();
+		/// Returns a pointer to the documents Name Pool.
+
+	AutoReleasePool& autoReleasePool();
+		/// Returns a pointer to the documents Auto Release Pool.
+
+	void collectGarbage();
+		/// Releases all objects in the Auto Release Pool.
+
+	void suspendEvents();
+		/// Suspends all events until resumeEvents() is called.
+
+	void resumeEvents();
+		/// Resumes all events suspended with suspendEvent();
+
+	bool eventsSuspended() const;
+		/// Returns true if events are suspended.
+
+	bool events() const;
+		/// Returns true if events are not suspended.
+
+	const DocumentType* doctype() const;
+		/// The Document Type Declaration (see DocumentType) associated with this document.
+		/// For HTML documents as well as XML documents without a document type declaration
+		/// this returns null. The DOM Level 1 does not support editing the Document
+		/// Type Declaration. docType cannot be altered in any way, including through
+		/// the use of methods inherited from the Node interface, such as insertNode
+		/// or removeNode.
+
+	const DOMImplementation& implementation() const;
+		/// The DOMImplementation object that handles this document. A DOM application
+		/// may use objects from multiple implementations.
+
+	Element* documentElement() const;
+		/// This is a convenience attribute that allows direct access to the child node
+		/// that is the root element of the document. For HTML documents, this is the
+		/// element with the tagName "HTML".
+
+	Element* createElement(const XMLString& tagName) const;
+		/// Creates an element of the type specified. Note that the instance returned
+		/// implements the Element interface, so attributes can be specified directly
+		/// on the returned object.
+		///
+		/// In addition, if there are known attributes with default values, Attr nodes
+		/// representing them are automatically created and attached to the element.
+
+	DocumentFragment* createDocumentFragment() const;
+		/// Creates an empty DocumentFragment object.
+
+	Text* createTextNode(const XMLString& data) const;
+		/// Creates a text node given the specified string.
+
+	Comment* createComment(const XMLString& data) const;
+		/// Creates a comment node given the specified string.
+
+	CDATASection* createCDATASection(const XMLString& data) const;
+		/// Creates a CDATASection node whose value is the specified string.
+
+	ProcessingInstruction* createProcessingInstruction(const XMLString& target, const XMLString& data) const;
+		/// Creates a ProcessingInstruction node given the specified target and data strings.
+
+	Attr* createAttribute(const XMLString& name) const;	
+		/// Creates an Attr of the given name. Note that the Attr instance can then
+		/// be set on an Element using the setAttributeNode method.	
+
+	EntityReference* createEntityReference(const XMLString& name) const;
+		/// Creates an EntityReference object. In addition, if the referenced entity
+		/// is known, the child list of the EntityReference node is made the same as
+		/// that of the corresponding Entity node.
+
+	NodeList* getElementsByTagName(const XMLString& name) const;
+		/// Returns a NodeList of all Elements with a given tag name in the order
+		/// in which they would be encountered in a preorder traversal of the
+		/// document tree.
+		///
+		/// The returned NodeList must be released with a call to release()
+		/// when no longer needed.
+
+	// DOM Level 2
+	Node* importNode(Node* importedNode, bool deep);
+		/// Imports a node from another document to this document. The returned node
+		/// has no parent; (parentNode is null). The source node is not altered or removed
+		/// from the original document; this method creates a new copy of the source
+		/// node.
+		/// For all nodes, importing a node creates a node object owned by the importing
+		/// document, with attribute values identical to the source node's nodeName
+		/// and nodeType, plus the attributes related to namespaces (prefix, localName,
+		/// and namespaceURI). As in the cloneNode operation on a Node, the source node
+		/// is not altered.
+		/// Additional information is copied as appropriate to the nodeType, attempting
+		/// to mirror the behavior expected if a fragment of XML or HTML source was
+		/// copied from one document to another, recognizing that the two documents
+		/// may have different DTDs in the XML case.
+
+	Element* createElementNS(const XMLString& namespaceURI, const XMLString& qualifiedName) const;
+		/// Creates an element of the given qualified name and namespace URI.
+
+	Attr* createAttributeNS(const XMLString& namespaceURI, const XMLString& qualifiedName) const;
+		/// Creates an attribute of the given qualified name and namespace URI.
+
+	NodeList* getElementsByTagNameNS(const XMLString& namespaceURI, const XMLString& localName) const;
+		/// Returns a NodeList of all the Elements with a given local name and 
+		/// namespace URI in the order in which they are encountered in a 
+		/// preorder traversal of the Document tree.
+
+	Element* getElementById(const XMLString& elementId) const;
+		/// Returns the Element whose ID is given by elementId. If no such 
+		/// element exists, returns null. Behavior is not defined if more
+		/// than one element has this ID. 
+		///
+		/// Note: The DOM implementation must have information that says 
+		/// which attributes are of type ID. Attributes with the name "ID"
+		/// are not of type ID unless so defined. Implementations that do 
+		/// not know whether attributes are of type ID or not are expected to
+		/// return null. This implementation therefore returns null.
+		///
+		/// See also the non-standard two argument variant of getElementById()
+		/// and getElementByIdNS().
+
+	// DocumentEvent
+	Event* createEvent(const XMLString& eventType) const;
+
+	// Node
+	const XMLString& nodeName() const;
+	unsigned short nodeType() const;
+
+	// EventTarget
+	bool dispatchEvent(Event* evt);
+	
+	// Extensions
+	Entity* createEntity(const XMLString& name, const XMLString& publicId, const XMLString& systemId, const XMLString& notationName) const;
+		/// Creates an Entity with the given name, publicId, systemId and notationName.
+		///
+		/// This method is not part of the W3C Document Object Model.
+
+	Notation* createNotation(const XMLString& name, const XMLString& publicId, const XMLString& systemId) const;
+		/// Creates a Notation with the given name, publicId and systemId.
+		///
+		/// This method is not part of the W3C Document Object Model.
+
+	Element* getElementById(const XMLString& elementId, const XMLString& idAttribute) const;
+		/// Returns the first Element whose ID attribute (given in idAttribute)
+		/// has the given elementId. If no such element exists, returns null. 
+		///
+		/// This method is an extension to the W3C Document Object Model.
+
+	Element* getElementByIdNS(const XMLString& elementId, const XMLString& idAttributeURI, const XMLString& idAttributeLocalName) const;
+		/// Returns the first Element whose ID attribute (given in idAttributeURI and idAttributeLocalName)
+		/// has the given elementId. If no such element exists, returns null. 
+		///
+		/// This method is an extension to the W3C Document Object Model.
+
+protected:
+	~Document();
+
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+	
+	DocumentType* getDoctype();
+	void setDoctype(DocumentType* pDoctype);
+
+private:
+	DocumentType*   _pDocumentType;
+	NamePool*       _pNamePool;
+	AutoReleasePool _autoReleasePool;
+	int             _eventSuspendLevel;
+
+	static const XMLString NODE_NAME;
+	
+	friend class DOMBuilder;
+};
+
+
+//
+// inlines
+//
+inline NamePool& Document::namePool()
+{
+	return *_pNamePool;
+}
+
+
+inline Document::AutoReleasePool& Document::autoReleasePool()
+{
+	return _autoReleasePool;
+}
+
+
+inline const DocumentType* Document::doctype() const
+{
+	return _pDocumentType;
+}
+
+
+inline DocumentType* Document::getDoctype()
+{
+	return _pDocumentType;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_Document_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/DocumentEvent.h b/base/poco/XML/include/Poco/DOM/DocumentEvent.h
new file mode 100644
index 00000000000..14bcf270b84
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/DocumentEvent.h
@@ -0,0 +1,65 @@
+//
+// DocumentEvent.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM DocumentEvent interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DocumentEvent_INCLUDED
+#define DOM_DocumentEvent_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Event;
+
+
+class XML_API DocumentEvent
+	/// The DocumentEvent interface provides a mechanism by which the user can create
+	/// an Event of a type supported by the implementation. It is expected that
+	/// the DocumentEvent interface will be implemented on the same object which
+	/// implements the Document interface in an implementation which supports the
+	/// Event model.
+{
+public:
+	virtual Event* createEvent(const XMLString& eventType) const = 0;
+		/// Creates an event of the specified type.
+		///
+		/// The eventType parameter specifies the type of Event interface to be created.
+		/// If the Event interface specified is supported by the implementation this
+		/// method will return a new Event of the interface type requested. If the Event
+		/// is to be dispatched via the dispatchEvent method the appropriate event init
+		/// method must be called after creation in order to initialize the Event's
+		/// values. As an example, a user wishing to synthesize some kind of UIEvent
+		/// would call createEvent with the parameter "UIEvents". The initUIEvent method
+		/// could then be called on the newly created UIEvent to set the specific type
+		/// of UIEvent to be dispatched and set its context information.
+		/// The createEvent method is used in creating Events when it is either inconvenient
+		/// or unnecessary for the user to create an Event themselves. In cases where
+		/// the implementation provided Event is insufficient, users may supply their
+		/// own Event implementations for use with the dispatchEvent method.
+
+protected:
+	virtual ~DocumentEvent();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DocumentEvent_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/DocumentFragment.h b/base/poco/XML/include/Poco/DOM/DocumentFragment.h
new file mode 100644
index 00000000000..105a2171db3
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/DocumentFragment.h
@@ -0,0 +1,84 @@
+//
+// DocumentFragment.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM DocumentFragment class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DocumentFragment_INCLUDED
+#define DOM_DocumentFragment_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractContainerNode.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API DocumentFragment: public AbstractContainerNode
+	/// DocumentFragment is a "lightweight" or "minimal" Document object. It is
+	/// very common to want to be able to extract a portion of a document's tree
+	/// or to create a new fragment of a document. Imagine implementing a user command
+	/// like cut or rearranging a document by moving fragments around. It is desirable
+	/// to have an object which can hold such fragments and it is quite natural
+	/// to use a Node for this purpose. While it is true that a Document object
+	/// could fulfill this role, a Document object can potentially be a heavyweight
+	/// object, depending on the underlying implementation. What is really needed
+	/// for this is a very lightweight object. DocumentFragment is such an object.
+	/// 
+	/// Furthermore, various operations -- such as inserting nodes as children of
+	/// another Node -- may take DocumentFragment objects as arguments; this results
+	/// in all the child nodes of the DocumentFragment being moved to the child
+	/// list of this node.
+	/// 
+	/// The children of a DocumentFragment node are zero or more nodes representing
+	/// the tops of any sub-trees defining the structure of the document. DocumentFragment
+	/// nodes do not need to be well-formed XML documents (although they do need
+	/// to follow the rules imposed upon well-formed XML parsed entities, which
+	/// can have multiple top nodes). For example, a DocumentFragment might have
+	/// only one child and that child node could be a Text node. Such a structure
+	/// model represents neither an HTML document nor a well-formed XML document.
+	/// 
+	/// When a DocumentFragment is inserted into a Document (or indeed any other
+	/// Node that may take children) the children of the DocumentFragment and not
+	/// the DocumentFragment itself are inserted into the Node. This makes the DocumentFragment
+	/// very useful when the user wishes to create nodes that are siblings; the
+	/// DocumentFragment acts as the parent of these nodes so that the user can
+	/// use the standard methods from the Node interface, such as insertBefore and
+	/// appendChild.
+{
+public:
+	// Node
+	const XMLString& nodeName() const;
+	unsigned short nodeType() const;
+
+protected:
+	DocumentFragment(Document* pOwnerDocument);
+	DocumentFragment(Document* pOwnerDocument, const DocumentFragment& fragment);
+	~DocumentFragment();
+	
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+
+private:
+	static const XMLString NODE_NAME;
+	
+	friend class Document;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DocumentFragment_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/DocumentType.h b/base/poco/XML/include/Poco/DOM/DocumentType.h
new file mode 100644
index 00000000000..3d8909798b3
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/DocumentType.h
@@ -0,0 +1,125 @@
+//
+// DocumentType.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM DocumentType class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_DocumentType_INCLUDED
+#define DOM_DocumentType_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractContainerNode.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class NamedNodeMap;
+
+
+class XML_API DocumentType: public AbstractContainerNode
+	/// Each Document has a doctype attribute whose value is either null or a DocumentType
+	/// object. The DocumentType interface in the DOM Level 1 Core provides an
+	/// interface to the list of entities that are defined for the document, and
+	/// little else because the effect of namespaces and the various XML scheme
+	/// efforts on DTD representation are not clearly understood as of this writing.
+	/// 
+	/// The DOM Level 1 doesn't support editing DocumentType nodes.
+{
+public:
+	const XMLString& name() const;
+		/// The name of the DTD; i.e., the name immediately following the 
+		/// DOCTYPE keyword.
+
+	NamedNodeMap* entities() const;
+		/// A NamedNodeMap containing the general entities,
+		/// both external and internal, declared in the DTD.
+		/// Duplicates are discarded.
+		///
+		/// Note: In this implementation, only the
+		/// external entities are reported.
+		/// Every node in this map also implements the
+		/// Entity interface.
+		/// 
+		/// The returned NamedNodeMap must be released with a call
+		/// to release() when no longer needed.
+
+	NamedNodeMap* notations() const;
+		/// A NamedNodeMap containing the notations declared in the DTD. Duplicates
+		/// are discarded. Every node in this map also implements the Notation interface.
+		/// The DOM Level 1 does not support editing notations, therefore notations
+		/// cannot be altered in any way.
+		/// 
+		/// The returned NamedNodeMap must be released with a call
+		/// to release() when no longer needed.
+
+	// DOM Level 2
+	const XMLString& publicId() const;
+		/// Returns the public identifier of the external DTD subset.
+
+	const XMLString& systemId() const;
+		/// Returns the system identifier of the external DTD subset.
+
+	const XMLString& internalSubset() const;
+		/// Returns the internal DTD subset. This implementation
+		/// returns an empty string.
+
+	// Node
+	const XMLString& nodeName() const;
+	unsigned short nodeType() const;
+
+protected:
+	DocumentType(Document* pOwner, const XMLString& name, const XMLString& publicId, const XMLString& systemId);
+	DocumentType(Document* pOwner, const DocumentType& dt);
+	~DocumentType();
+
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+
+private:
+	XMLString _name;
+	XMLString _publicId;
+	XMLString _systemId;
+	
+	friend class DOMImplementation;
+	friend class Document;
+	friend class DOMBuilder;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& DocumentType::name() const
+{
+	return _name;
+}
+
+
+inline const XMLString& DocumentType::publicId() const
+{
+	return _publicId;
+}
+
+
+inline const XMLString& DocumentType::systemId() const
+{
+	return _systemId;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_DocumentType_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/Element.h b/base/poco/XML/include/Poco/DOM/Element.h
new file mode 100644
index 00000000000..90217baab84
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/Element.h
@@ -0,0 +1,219 @@
+//
+// Element.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM Element class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_Element_INCLUDED
+#define DOM_Element_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractContainerNode.h"
+#include "Poco/XML/Name.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Attr;
+class NodeList;
+class Document;
+
+
+class XML_API Element: public AbstractContainerNode
+	/// The Element interface represents an element in an XML document.
+	/// Elements may have attributes associated with them; since the Element interface
+	/// inherits from Node, the generic Node interface attribute attributes may
+	/// be used to retrieve the set of all attributes for an element. There are
+	/// methods on the Element interface to retrieve either an Attr object by name
+	/// or an attribute value by name. In XML, where an attribute value may contain
+	/// entity references, an Attr object should be retrieved to examine the possibly
+	/// fairly complex sub-tree representing the attribute value. 
+{
+public:
+	const XMLString& tagName() const;
+		/// Returns the name of the element.
+		///
+		/// For example, in
+		/// 
+		///     <elementExample id="demo"> 
+        ///         ... 
+		///     </elementExample>
+		///
+		/// tagName has the value "elementExample". Note that this is case-preserving in XML, 
+		/// as are all of the operations of the DOM.
+
+	const XMLString& getAttribute(const XMLString& name) const;
+		/// Retrieves an attribute value by name.
+		///
+		/// Returns the attribute's value, if the attribute
+		/// exists, or an empty string otherwise.
+
+	void setAttribute(const XMLString& name, const XMLString& value);
+		/// Adds a new attribute. If an attribute with that name is already present
+		/// in the element, its value is changed to be that of the value parameter.
+		/// This value is a simple string; it is not parsed as it is being set. So any
+		/// markup (such as syntax to be recognized as an entity reference) is treated
+		/// as literal text, and needs to be appropriately escaped by the implementation
+		/// when it is written out.
+ 
+	void removeAttribute(const XMLString& name);
+		/// Removes an attribute by name.
+
+	Attr* getAttributeNode(const XMLString& name) const;
+		/// Retrieves an Attr node by name.
+
+	Attr* setAttributeNode(Attr* newAttr);
+		/// Adds a new attribute. If an attribute with that name is already
+		/// present in the element, it is replaced by the new one.
+
+	Attr* addAttributeNodeNP(Attr* oldAttr, Attr* newAttr);
+		/// For internal use only.
+		/// Adds a new attribute after oldAttr.
+		/// If oldAttr is 0, newAttr is set as first attribute.
+		/// Returns newAttr.
+		/// Does not fire any events.
+
+	Attr* removeAttributeNode(Attr* oldAttr);
+		/// Removes the specified attribute.
+
+	NodeList* getElementsByTagName(const XMLString& name) const;
+		/// Returns a NodeList of all descendant elements with a given tag
+		/// name, in the order in which they would be encountered in a
+		/// preorder traversal of the Element tree.
+		///
+		/// The special name "*" matches all tags.
+		///
+		/// The returned NodeList must be released with a call
+		/// to release() when no longer needed.
+
+	void normalize();
+		/// Puts all Text nodes in the full depth of the sub-tree underneath this Element,
+		/// including attribute nodes, into a "normal" form where only markup (e.g.,
+		/// tags, comments, processing instructions, CDATA sections, and entity references)
+		/// separates Text nodes, i.e., there are no adjacent Text nodes. This can be
+		/// used to ensure that the DOM view of a document is the same as if it were
+		/// saved and re-loaded, and is useful when operations (such as XPointer
+		/// lookups) that depend on a particular document tree structure are to be used.
+		/// 
+		/// Note: In cases where the document contains CDATASections, the normalize
+		/// operation alone may not be sufficient, since XPointers do not differentiate
+		/// between Text nodes and CDATASection nodes.
+
+	// DOM Level 2
+	const XMLString& getAttributeNS(const XMLString& namespaceURI, const XMLString& localName) const;
+		/// Retrieves an attribute value by name.
+		///
+		/// Returns the attribute's value, if the attribute
+		/// exists, or an empty string otherwise.
+
+	void setAttributeNS(const XMLString& namespaceURI, const XMLString& qualifiedName, const XMLString& value);
+		/// Adds a new attribute. If an attribute with that name
+		/// is already present in the element, its value is changed
+		/// to be that of the value parameter.
+
+	void removeAttributeNS(const XMLString& namespaceURI, const XMLString& localName);
+		/// Removes an attribute by name.
+
+	Attr* getAttributeNodeNS(const XMLString& namespaceURI, const XMLString& localName) const;
+		/// Retrieves an Attr node by name.
+
+	Attr* setAttributeNodeNS(Attr* newAttr);
+		/// Adds a new attribute. If an attribute with that name is already
+		/// present in the element, it is replaced by the new one.
+
+	bool hasAttribute(const XMLString& name) const;
+		/// Returns true if and only if the element has the specified attribute.
+
+	bool hasAttributeNS(const XMLString& namespaceURI, const XMLString& localName) const;
+		/// Returns true if and only if the element has the specified attribute.
+
+	NodeList* getElementsByTagNameNS(const XMLString& namespaceURI, const XMLString& localName) const;
+		/// Returns a NodeList of all the descendant Elements with a given local name and namespace URI 
+		/// in the order in which they are encountered in a preorder traversal of this Element tree.
+		///
+		/// The special value "*" matches all namespaces, or local names respectively.
+		///
+		/// The returned NodeList must be released with a call
+		/// to release() when no longer needed.
+
+	const XMLString& namespaceURI() const;
+	XMLString prefix() const;
+	const XMLString& localName() const;
+	bool hasAttributes() const;
+	XMLString innerText() const;
+
+	Element* getChildElement(const XMLString& name) const;
+		/// Returns the first child element with the given name, or null
+		/// if such an element does not exist.
+		///
+		/// This method is an extension to the W3C Document Object Model.
+
+	Element* getChildElementNS(const XMLString& namespaceURI, const XMLString& localName) const;
+		/// Returns the first child element with the given namespaceURI and localName,
+		/// or null if such an element does not exist.
+		///
+		/// This method is an extension to the W3C Document Object Model.
+	
+	Element* getElementById(const XMLString& elementId, const XMLString& idAttribute) const;
+		/// Returns the first Element whose ID attribute (given in idAttribute)
+		/// has the given elementId. If no such element exists, returns null. 
+		///
+		/// This method is an extension to the W3C Document Object Model.
+
+	Element* getElementByIdNS(const XMLString& elementId, const XMLString& idAttributeURI, const XMLString& idAttributeLocalName) const;
+		/// Returns the first Element whose ID attribute (given in idAttributeURI and idAttributeLocalName)
+		/// has the given elementId. If no such element exists, returns null. 
+		///
+		/// This method is an extension to the W3C Document Object Model.
+	
+	// Node
+	const XMLString& nodeName() const;
+	NamedNodeMap* attributes() const;
+	unsigned short nodeType() const;
+
+protected:
+	Element(Document* pOwnerDocument, const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname);
+	Element(Document* pOwnerDocument, const Element& elem);
+	~Element();
+
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+
+	void dispatchNodeRemovedFromDocument();
+	void dispatchNodeInsertedIntoDocument();
+
+private:
+	const Name& _name;
+	Attr*       _pFirstAttr;
+
+	friend class Attr;
+	friend class Document;
+	friend class AttrMap;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& Element::tagName() const
+{
+	return _name.qname();
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_Element_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/ElementsByTagNameList.h b/base/poco/XML/include/Poco/DOM/ElementsByTagNameList.h
new file mode 100644
index 00000000000..98af2e82075
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/ElementsByTagNameList.h
@@ -0,0 +1,86 @@
+//
+// ElementsByTagNameList.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the ElementsByTagNameList and ElementsByTagNameListNS classes.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_ElementsByTagNameList_INCLUDED
+#define DOM_ElementsByTagNameList_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/NodeList.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API ElementsByTagNameList: public NodeList
+	// This implementation of NodeList is returned
+	// by Document::getElementsByTagName() and
+	// Element::getElementsByTagName().
+{
+public:
+	Node* item(unsigned long index) const;
+	unsigned long length() const;
+	void autoRelease();
+
+protected:
+	ElementsByTagNameList(const Node* pParent, const XMLString& name);
+	~ElementsByTagNameList();
+
+	Node* find(const Node* pParent, unsigned long index) const;
+
+	const Node* _pParent;
+	XMLString   _name;
+	mutable unsigned long _count;
+	
+	friend class AbstractContainerNode;
+	friend class Element;
+	friend class Document;
+};
+
+
+class XML_API ElementsByTagNameListNS: public NodeList
+	// This implementation of NodeList is returned
+	// by Document::getElementsByTagNameNS() and
+	// Element::getElementsByTagNameNS().
+{
+public:
+	virtual Node* item(unsigned long index) const;
+	virtual unsigned long length() const;
+	virtual void autoRelease();
+
+protected:
+	ElementsByTagNameListNS(const Node* pParent, const XMLString& namespaceURI, const XMLString& localName);
+	~ElementsByTagNameListNS();
+
+	Node* find(const Node* pParent, unsigned long index) const;
+
+	const Node* _pParent;
+	XMLString   _localName;
+	XMLString   _namespaceURI;
+	mutable unsigned long _count;
+	
+	friend class AbstractContainerNode;
+	friend class Element;
+	friend class Document;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_ElementsByTagNameList_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/Entity.h b/base/poco/XML/include/Poco/DOM/Entity.h
new file mode 100644
index 00000000000..40c21f59cde
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/Entity.h
@@ -0,0 +1,126 @@
+//
+// Entity.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM Entity class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_Entity_INCLUDED
+#define DOM_Entity_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractContainerNode.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API Entity: public AbstractContainerNode
+	/// This interface represents an entity, either parsed or unparsed, in an XML
+	/// document. Note that this models the entity itself not the entity declaration.
+	/// Entity declaration modeling has been left for a later Level of the DOM
+	/// specification.
+	/// 
+	/// The nodeName attribute that is inherited from Node contains the name of
+	/// the entity.
+	/// 
+	/// An XML processor may choose to completely expand entities before the structure
+	/// model is passed to the DOM; in this case there will be no EntityReference
+	/// nodes in the document tree.
+	/// 
+	/// XML does not mandate that a non-validating XML processor read and process
+	/// entity declarations made in the external subset or declared in external
+	/// parameter entities. This means that parsed entities declared in the external
+	/// subset need not be expanded by some classes of applications, and that the
+	/// replacement value of the entity may not be available. When the replacement
+	/// value is available, the corresponding Entity node's child list represents
+	/// the structure of that replacement text. Otherwise, the child list is empty.
+	/// 
+	/// The resolution of the children of the Entity (the replacement value) may
+	/// be lazily evaluated; actions by the user (such as calling the childNodes
+	/// method on the Entity Node) are assumed to trigger the evaluation.
+	/// 
+	/// The DOM Level 1 does not support editing Entity nodes; if a user wants to
+	/// make changes to the contents of an Entity, every related EntityReference
+	/// node has to be replaced in the structure model by a clone of the Entity's
+	/// contents, and then the desired changes must be made to each of those clones
+	/// instead. Entity nodes and all their descendants are readonly.
+	/// 
+	/// An Entity node does not have any parent.
+{
+public:
+	const XMLString& publicId() const;
+		/// Returns the public identifier associated with
+		/// the entity, if specified. If the public identifier
+		/// was not specified, this is the empty string.
+
+	const XMLString& systemId() const;
+		/// Returns the system identifier associated with
+		/// the entity, if specified. If the system identifier
+		/// was not specified, this is the empty string.
+
+	const XMLString& notationName() const;
+		/// Returns, for unparsed entities, the name of the
+		/// notation for the entity. For parsed entities, this
+		/// is the empty string.
+
+	// Node
+	const XMLString& nodeName() const;
+	unsigned short nodeType() const;
+
+protected:
+	Entity(Document* pOwnerDocument, const XMLString& name, const XMLString& publicId, const XMLString& systemId, const XMLString& notationName);
+	Entity(Document* pOwnerDocument, const Entity& entity);
+	~Entity();
+	
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+
+private:
+	static const XMLString NODE_NAME;
+
+	XMLString _name;
+	XMLString _publicId;
+	XMLString _systemId;
+	XMLString _notationName;
+
+	friend class Document;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& Entity::publicId() const
+{
+	return _publicId;
+}
+
+
+inline const XMLString& Entity::systemId() const
+{
+	return _systemId;
+}
+
+
+inline const XMLString& Entity::notationName() const
+{
+	return _notationName;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_Entity_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/EntityReference.h b/base/poco/XML/include/Poco/DOM/EntityReference.h
new file mode 100644
index 00000000000..5ecd044b577
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/EntityReference.h
@@ -0,0 +1,73 @@
+//
+// EntityReference.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM EntityReference class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_EntityReference_INCLUDED
+#define DOM_EntityReference_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractNode.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API EntityReference: public AbstractNode
+	/// EntityReference objects may be inserted into the structure model when an
+	/// entity reference is in the source document, or when the user wishes to insert
+	/// an entity reference. Note that character references and references to predefined
+	/// entities are considered to be expanded by the HTML or XML processor so that
+	/// characters are represented by their Unicode equivalent rather than by an
+	/// entity reference. Moreover, the XML processor may completely expand references
+	/// to entities while building the structure model, instead of providing EntityReference
+	/// objects. If it does provide such objects, then for a given EntityReference
+	/// node, it may be that there is no Entity node representing the referenced
+	/// entity. If such an Entity exists, then the child list of the EntityReference
+	/// node is the same as that of the Entity node.
+	/// 
+	/// As for Entity nodes, EntityReference nodes and all their descendants are
+	/// readonly.
+	/// 
+	/// The resolution of the children of the EntityReference (the replacement value
+	/// of the referenced Entity) may be lazily evaluated; actions by the user (such
+	/// as calling the childNodes method on the EntityReference node) are assumed
+	/// to trigger the evaluation.
+{
+public:
+	// Node
+	const XMLString& nodeName() const;
+	unsigned short nodeType() const;
+
+protected:
+	EntityReference(Document* pOwnerDocument, const XMLString& name);
+	EntityReference(Document* pOwnerDocument, const EntityReference& ref);
+	~EntityReference();
+
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+
+private:
+	XMLString _name;
+	
+	friend class Document;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_EntityReference_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/Event.h b/base/poco/XML/include/Poco/DOM/Event.h
new file mode 100644
index 00000000000..5396aa3f5a4
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/Event.h
@@ -0,0 +1,209 @@
+//
+// Event.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMEvents
+//
+// Definition of the DOM Event class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_Event_INCLUDED
+#define DOM_Event_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+#include "Poco/DOM/DOMObject.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class EventTarget;
+class Document;
+
+
+class XML_API Event: public DOMObject
+	/// The Event interface is used to provide contextual information about an event
+	/// to the handler processing the event. An object which implements the Event
+	/// interface is generally passed as the first parameter to an event handler.
+	/// More specific context information is passed to event handlers by deriving
+	/// additional interfaces from Event which contain information directly relating
+	/// to the type of event they accompany. These derived interfaces are also implemented
+	/// by the object passed to the event listener.
+{
+public:
+	enum PhaseType
+	{
+		CAPTURING_PHASE = 1, /// The event is currently being evaluated at the target EventTarget. 
+		AT_TARGET       = 2, /// The current event phase is the bubbling phase. 
+		BUBBLING_PHASE  = 3  /// The current event phase is the capturing phase. 
+	};
+
+	const XMLString& type() const;
+		/// The name of the event (case-insensitive). The name must be an XML name.
+
+	EventTarget* target() const;
+		/// Used to indicate the EventTarget to which the event was originally dispatched.
+
+	EventTarget* currentTarget() const;
+		/// Used to indicate the EventTarget whose EventListeners are currently being 
+		/// processed. This is particularly useful during capturing and bubbling.
+
+	PhaseType eventPhase() const;
+		/// Used to indicate which phase of event flow is currently being evaluated.
+
+	bool bubbles() const;
+		/// Used to indicate whether or not an event is a bubbling event. 
+		/// If the event can bubble the value is true, else the value is false.
+
+	bool cancelable() const;
+		/// Used to indicate whether or not an event can have its default action 
+		/// prevented. If the default action can be prevented the value is
+		/// true, else the value is false.
+
+	Poco::UInt64 timeStamp() const;
+		/// Used to specify the time (in milliseconds relative to the epoch) at 
+		/// which the event was created. Due to the fact that some
+		/// systems may not provide this information the value of timeStamp may 
+		/// be not available for all events. When not available, a
+		/// value of 0 will be returned. Examples of epoch time are the time of the 
+		/// system start or 0:0:0 UTC 1st January 1970.
+		/// This implementation always returns 0.
+
+	void stopPropagation();
+		/// The stopPropagation method is used prevent further propagation of an 
+		/// event during event flow. If this method is called by
+		/// any EventListener the event will cease propagating through the tree. 
+		/// The event will complete dispatch to all listeners on the
+		/// current EventTarget before event flow stops. This method may be used 
+		/// during any stage of event flow. 
+
+	void preventDefault();
+		/// If an event is cancelable, the preventDefault method is used to signify 
+		/// that the event is to be canceled, meaning any default
+		/// action normally taken by the implementation as a result of 
+		/// the event will not occur. If, during any stage of event flow, the
+		/// preventDefault method is called the event is canceled. Any default 
+		/// action associated with the event will not occur. Calling
+		/// this method for a non-cancelable event has no effect. Once 
+		/// preventDefault has been called it will remain in effect throughout
+		/// the remainder of the event's propagation. This method may be 
+		/// used during any stage of event flow. 
+
+	void initEvent(const XMLString& eventType, bool canBubble, bool isCancelable);
+		/// The initEvent method is used to initialize the value of an 
+		/// Event created through the DocumentEvent interface. This method
+		/// may only be called before the Event has been dispatched via the 
+		/// dispatchEvent method, though it may be called multiple
+		/// times during that phase if necessary. If called multiple 
+		/// times the final invocation takes precedence. If called from 
+		/// a subclass of Event interface only the values specified in the 
+		/// initEvent method are modified, all other attributes are left unchanged. 
+
+	void autoRelease();
+
+protected:
+	Event(Document* pOwnerDocument, const XMLString& type);
+	Event(Document* pOwnerDocument, const XMLString& type, EventTarget* pTarget, bool canBubble, bool isCancelable);
+	~Event();
+
+	bool isCanceled() const;
+		/// returns true if and only if the event has been cancelled.
+
+	bool isStopped() const;
+		/// returns true if and only if propagation of the event has been stopped.
+
+	void setTarget(EventTarget* pTarget);
+		/// sets the target
+
+	void setCurrentPhase(PhaseType phase);
+		/// sets the current phase
+
+	void setCurrentTarget(EventTarget* pTarget);
+		/// sets the current target
+
+private:
+	Document*    _pOwner;
+	XMLString    _type;
+	EventTarget* _pTarget;
+	EventTarget* _pCurrentTarget;
+	PhaseType    _currentPhase;
+	bool         _bubbles;
+	bool         _cancelable;
+	bool         _canceled;
+	bool         _stopped;
+	
+	friend class AbstractNode;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& Event::type() const
+{
+	return _type;
+}
+
+
+inline EventTarget* Event::target() const
+{
+	return _pTarget;
+}
+
+
+inline EventTarget* Event::currentTarget() const
+{
+	return _pCurrentTarget;
+}
+
+
+inline Event::PhaseType Event::eventPhase() const
+{
+	return _currentPhase;
+}
+
+
+inline bool Event::bubbles() const
+{
+	return _bubbles;
+}
+
+
+inline bool Event::cancelable() const
+{
+	return _cancelable;
+}
+
+
+inline Poco::UInt64 Event::timeStamp() const
+{
+	return 0;
+}
+
+
+inline bool Event::isCanceled() const
+{
+	return _canceled;
+}
+
+
+inline bool Event::isStopped() const
+{
+	return _stopped;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_Event_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/EventDispatcher.h b/base/poco/XML/include/Poco/DOM/EventDispatcher.h
new file mode 100644
index 00000000000..4e825df9c4a
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/EventDispatcher.h
@@ -0,0 +1,97 @@
+//
+// EventDispatcher.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMEvents
+//
+// Definition of the EventDispatcher class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_EventDispatcher_INCLUDED
+#define DOM_EventDispatcher_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+#include <list>
+
+
+namespace Poco {
+namespace XML {
+
+
+class Event;
+class EventListener;
+
+
+class XML_API EventDispatcher
+	/// This helper class manages event listener subscriptions
+	/// and event dispatching for AbstractNode.
+	///
+	/// The EventListener list is managed in such a way that
+	/// event listeners can be added and removed even
+	/// from within an EventListener, while events are being
+	/// dispatched.
+{
+public:
+	EventDispatcher();
+		/// Creates the EventDispatcher.
+		
+	~EventDispatcher();
+		/// Destroys the EventDispatcher.
+		
+	void addEventListener(const XMLString& type, EventListener* listener, bool useCapture);
+		/// Adds an EventListener to the internal list.
+		
+	void removeEventListener(const XMLString& type, EventListener* listener, bool useCapture);
+		/// Removes an EventListener from the internal list.
+		///
+		/// If a dispatch is currently in progress, the list
+		/// entry is only marked for deletion.
+		/// If no dispatch is currently in progress, all EventListeners
+		/// marked for deletion are removed from the list.
+
+	void dispatchEvent(Event* evt);
+		/// Dispatches the event.
+		///
+		/// Also removes all EventListeners marked for deletion from the 
+		/// event dispatcher list.
+		
+	void captureEvent(Event* evt);
+		/// Dispatches the event in its capturing phase.
+		///
+		/// Also removes all EventListeners marked for deletion from the 
+		/// event dispatcher list.
+		
+	void bubbleEvent(Event* evt);
+		/// Dispatches the event in its bubbling phase.
+		///
+		/// Also removes all EventListeners marked for deletion from the 
+		/// event dispatcher list.
+
+private:
+	struct EventListenerItem
+	{
+		XMLString      type;
+		EventListener* pListener;
+		bool           useCapture;
+	};
+
+	typedef std::list<EventListenerItem> EventListenerList;
+	
+	int               _inDispatch;
+	EventListenerList _listeners;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_EventDispatcher_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/EventException.h b/base/poco/XML/include/Poco/DOM/EventException.h
new file mode 100644
index 00000000000..cb824410587
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/EventException.h
@@ -0,0 +1,81 @@
+//
+// EventException.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMEvents
+//
+// Definition of the DOM EventException class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_EventException_INCLUDED
+#define DOM_EventException_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLException.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API EventException: public XMLException
+	/// Event operations may throw an EventException as 
+	/// specified in their method descriptions.
+{
+public:
+	enum
+	{
+		UNSPECIFIED_EVENT_TYPE_ERR = 0  /// If the Event's type was not specified by initializing the 
+		                                /// event before the method was called. Specification of the Event's
+                                        /// type as null or an empty string will also trigger this exception. 
+	};
+
+	EventException(int code);
+		/// Creates an EventException with the given error code.
+
+	EventException(const EventException& exc);
+		/// Creates an EventException by copying another one.
+
+	~EventException() noexcept;
+		/// Destroys the EventException.
+
+	EventException& operator = (const EventException& exc);
+
+	const char* name() const noexcept;
+		/// Returns a static string describing the exception.
+
+	const char* className() const noexcept;
+		/// Returns the name of the exception class.
+
+	unsigned short code() const;
+		/// Returns the Event exception code.
+
+protected:
+	Poco::Exception* clone() const;
+	
+private:
+	EventException();
+};
+
+
+//
+// inlines
+//
+inline unsigned short EventException::code() const
+{
+	return UNSPECIFIED_EVENT_TYPE_ERR;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_EventException_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/EventListener.h b/base/poco/XML/include/Poco/DOM/EventListener.h
new file mode 100644
index 00000000000..f0951b10a2a
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/EventListener.h
@@ -0,0 +1,57 @@
+//
+// EventListener.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMEvents
+//
+// Definition of the DOM EventListener interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_EventListener_INCLUDED
+#define DOM_EventListener_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Event;
+
+
+class XML_API EventListener
+	/// The EventListener interface is the primary method for handling events. Users
+	/// implement the EventListener interface and register their listener on an
+	/// EventTarget using the AddEventListener method. The users should also remove
+	/// their EventListener from its EventTarget after they have completed using
+	/// the listener.
+	/// 
+	/// When a Node is copied using the cloneNode method the EventListeners attached
+	/// to the source Node are not attached to the copied Node. If the user wishes
+	/// the same EventListeners to be added to the newly created copy the user must
+	/// add them manually.
+{
+public:
+	virtual void handleEvent(Event* evt) = 0;
+		/// This method is called whenever an event occurs of the 
+		/// type for which the EventListener interface was registered.
+
+protected:
+	virtual ~EventListener();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_EventListener_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/EventTarget.h b/base/poco/XML/include/Poco/DOM/EventTarget.h
new file mode 100644
index 00000000000..466d2151ed7
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/EventTarget.h
@@ -0,0 +1,76 @@
+//
+// EventTarget.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMEvents
+//
+// Definition of the DOM EventTarget interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_EventTarget_INCLUDED
+#define DOM_EventTarget_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/DOMObject.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class EventListener;
+class Event;
+
+
+class XML_API EventTarget: public DOMObject
+	/// The EventTarget interface is implemented by all Nodes in an implementation
+	/// which supports the DOM Event Model. Therefore, this interface can be obtained
+	/// by using binding-specific casting methods on an instance of the Node interface.
+	/// The interface allows registration and removal of EventListeners on an EventTarget
+	/// and dispatch of events to that EventTarget.
+{
+public:
+	virtual void addEventListener(const XMLString& type, EventListener* listener, bool useCapture) = 0;
+		/// This method allows the registration of event listeners on 
+		/// the event target. If an EventListener is added to an
+		/// EventTarget while it is processing an event, it will not 
+		/// be triggered by the current actions but may be triggered
+		/// during a later stage of event flow, such as the bubbling phase.
+		/// If multiple identical EventListeners are registered on the same 
+		/// EventTarget with the same parameters the duplicate instances are 
+		/// discarded. They do not cause the EventListener to be called twice and since they are
+		/// discarded they do not need to be removed with the removeEventListener method. 	
+	
+	virtual void removeEventListener(const XMLString& type, EventListener* listener, bool useCapture) = 0;
+		/// This method allows the removal of event listeners from the event 
+		/// target. If an EventListener is removed from an EventTarget while it is 
+		/// processing an event, it will not be triggered by the current actions. 
+		/// EventListeners can never be invoked after being removed.
+		/// Calling removeEventListener with arguments which do not identify 
+		/// any currently registered EventListener on the EventTarget has no effect. 
+
+	virtual bool dispatchEvent(Event* evt) = 0;
+		/// This method allows the dispatch of events into the implementations 
+		/// event model. Events dispatched in this manner will have the same capturing and 
+		/// bubbling behavior as events dispatched directly by the
+		/// implementation. The target of the event is the EventTarget on 
+		/// which dispatchEvent is called. 
+
+protected:
+	virtual ~EventTarget();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_EventTarget_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/MutationEvent.h b/base/poco/XML/include/Poco/DOM/MutationEvent.h
new file mode 100644
index 00000000000..33a8521c501
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/MutationEvent.h
@@ -0,0 +1,143 @@
+//
+// MutationEvent.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMEvents
+//
+// Definition of the DOM MutationEvent class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_MutationEvent_INCLUDED
+#define DOM_MutationEvent_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/Event.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Node;
+
+
+class XML_API MutationEvent: public Event
+	/// The MutationEvent interface provides specific contextual 
+	/// information associated with Mutation events.
+{
+public:
+	enum AttrChangeType
+	{
+		MODIFICATION = 1, /// The Attr was modified in place.
+		ADDITION     = 2, /// The Attr was just added. 
+		REMOVAL      = 3  /// The Attr was just removed. 
+	};
+
+	Node* relatedNode() const;
+		/// relatedNode is used to identify a secondary node related to a mutation 
+		/// event. For example, if a mutation event is dispatched
+		/// to a node indicating that its parent has changed, the relatedNode is the 
+		/// changed parent. If an event is instead dispatched to a
+		/// subtree indicating a node was changed within it, the relatedNode is 
+		/// the changed node. In the case of the DOMAttrModified
+		/// event it indicates the Attr node which was modified, added, or removed.
+
+	const XMLString& prevValue() const;
+		/// prevValue indicates the previous value of the Attr node in DOMAttrModified 
+		/// events, and of the CharacterData node in DOMCharDataModified events.
+
+	const XMLString& newValue() const;
+		/// newValue indicates the new value of the Attr node in DOMAttrModified 
+		/// events, and of the CharacterData node in DOMCharDataModified events.
+
+	const XMLString& attrName() const;
+		/// attrName indicates the name of the changed Attr node in a DOMAttrModified event.
+
+	AttrChangeType attrChange() const;
+		/// attrChange indicates the type of change which triggered the 
+		/// DOMAttrModified event. The values can be MODIFICATION,
+		/// ADDITION, or REMOVAL.
+
+	void initMutationEvent(const XMLString& type, bool canBubble, bool cancelable, Node* relatedNode, 
+	                       const XMLString& prevValue, const XMLString& newValue, const XMLString& attrName, AttrChangeType change);
+		/// The initMutationEvent method is used to initialize the value of a 
+		/// MutationEvent created through the DocumentEvent
+		/// interface. This method may only be called before the MutationEvent 
+		/// has been dispatched via the dispatchEvent method,
+		/// though it may be called multiple times during that phase if 
+		/// necessary. If called multiple times, the final invocation takes
+		/// precedence.
+
+	// Event Types
+	static const XMLString DOMSubtreeModified;
+	static const XMLString DOMNodeInserted;
+	static const XMLString DOMNodeRemoved;
+	static const XMLString DOMNodeRemovedFromDocument;
+	static const XMLString DOMNodeInsertedIntoDocument;
+	static const XMLString DOMAttrModified;
+	static const XMLString DOMCharacterDataModified;
+
+protected:
+	MutationEvent(Document* pOwnerDocument, const XMLString& type);
+	MutationEvent(Document* pOwnerDocument, const XMLString& type, EventTarget* pTarget, bool canBubble, bool cancelable, Node* relatedNode);
+	MutationEvent(Document* pOwnerDocument, const XMLString& type, EventTarget* pTarget, bool canBubble, bool cancelable, Node* relatedNode, 
+				  const XMLString& prevValue, const XMLString& newValue, const XMLString& attrName, AttrChangeType change);
+	~MutationEvent();
+
+private:
+	XMLString      _prevValue;
+	XMLString      _newValue;
+	XMLString      _attrName;
+	AttrChangeType _change;
+	Node*          _pRelatedNode;
+
+	friend class AbstractNode;
+	friend class Document;
+};
+
+
+//
+// inlines
+//
+inline Node* MutationEvent::relatedNode() const
+{
+	return _pRelatedNode;
+}
+
+
+inline const XMLString& MutationEvent::prevValue() const
+{
+	return _prevValue;
+}
+
+
+inline const XMLString& MutationEvent::newValue() const
+{
+	return _newValue;
+}
+
+
+inline const XMLString& MutationEvent::attrName() const
+{
+	return _attrName;
+}
+
+
+inline MutationEvent::AttrChangeType MutationEvent::attrChange() const
+{
+	return _change;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_MutationEvent_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/NamedNodeMap.h b/base/poco/XML/include/Poco/DOM/NamedNodeMap.h
new file mode 100644
index 00000000000..7b42ca88f4f
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/NamedNodeMap.h
@@ -0,0 +1,93 @@
+//
+// NamedNodeMap.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM NamedNodeMap interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_NamedNodeMap_INCLUDED
+#define DOM_NamedNodeMap_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/DOMObject.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Node;
+
+
+class XML_API NamedNodeMap: public DOMObject
+	/// Objects implementing the NamedNodeMap interface are used to represent collections
+	/// of nodes that can be accessed by name. Note that NamedNodeMap does not inherit
+	/// from NodeList; NamedNodeMaps are not maintained in any particular order.
+	/// Objects contained in an object implementing NamedNodeMap may also be accessed
+	/// by an ordinal index, but this is simply to allow convenient enumeration
+	/// of the contents of a NamedNodeMap, and does not imply that the DOM specifies
+	/// an order to these Nodes.
+	///
+	/// NamedNodeMap objects in the DOM are live.
+	///
+	/// A NamedNodeMap returned from a method must be released with a call to 
+	/// release() when no longer needed.
+{
+public:
+	virtual Node* getNamedItem(const XMLString& name) const = 0;
+		/// Retrieves a node specified by name.
+
+	virtual Node* setNamedItem(Node* arg) = 0;
+		/// Adds a node using its nodeName attribute. If a node with that name is already
+		/// present in this map, it is replaced by the new one.
+		/// As the nodeName attribute is used to derive the name which the node must
+		/// be stored under, multiple nodes of certain types (those that have a "special"
+		/// string value) cannot be stored as the names would clash. This is seen as
+		/// preferable to allowing nodes to be aliased.
+
+	virtual Node* removeNamedItem(const XMLString& name) = 0;
+		/// Removes a node specified by name. When this map contains the attributes
+		/// attached to an element, if the removed attribute is known to have a default
+		/// value, an attribute immediately appears containing the default value.
+
+	virtual Node* item(unsigned long index) const = 0;
+		/// Returns the index'th item in the map. If index is greater
+		/// than or equal to the number of nodes in the map, this
+		/// returns null.
+
+	virtual unsigned long length() const = 0;
+		/// Returns the number of nodes in the map. The range of valid
+		/// child node indices is 0 to length - 1 inclusive.
+	
+	// DOM Level 2
+	virtual Node* getNamedItemNS(const XMLString& namespaceURI, const XMLString& localName) const = 0;
+		/// Retrieves a node specified by name.
+
+	virtual Node* setNamedItemNS(Node* arg) = 0;
+		/// Adds a node using its nodeName attribute.
+		/// If a node with that namespace URI and that local name is already 
+		/// present in this map, it is replaced by the new one.
+
+	virtual Node* removeNamedItemNS(const XMLString& namespaceURI, const XMLString& localName) = 0;
+		/// Removes a node specified by name.
+	
+protected:
+	virtual ~NamedNodeMap();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_NamedNodeMap_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/Node.h b/base/poco/XML/include/Poco/DOM/Node.h
new file mode 100644
index 00000000000..0eb934af538
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/Node.h
@@ -0,0 +1,285 @@
+//
+// Node.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM Node interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_Node_INCLUDED
+#define DOM_Node_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/EventTarget.h"
+#include "Poco/XML/XMLString.h"
+#include "Poco/SAX/NamespaceSupport.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class NamedNodeMap;
+class Document;
+class NodeList;
+
+
+class XML_API Node: public EventTarget
+	/// The Node interface is the primary datatype for the entire Document Object
+	/// Model. It represents a single node in the document tree. While all objects
+	/// implementing the Node interface expose methods for dealing with children,
+	/// not all objects implementing the Node interface may have children. For
+	/// example, Text nodes may not have children, and adding children to such
+	/// nodes results in a DOMException being raised.
+	/// 
+	/// The attributes nodeName, nodeValue and attributes are included as a mechanism
+	/// to get at node information without casting down to the specific derived
+	/// interface. In cases where there is no obvious mapping of these attributes
+	/// for a specific nodeType (e.g., nodeValue for an Element or attributes for
+	/// a Comment), this returns null. Note that the specialized interfaces may
+	/// contain additional and more convenient mechanisms to get and set the relevant
+	/// information.
+	///
+	/// This implementation differs in some ways from the W3C DOM recommendations.
+	/// For example, the DOM specifies that some methods can return null strings.
+	/// Instead of null strings, this implementation always returns empty strings.
+{
+public:
+	enum
+	{
+		ELEMENT_NODE = 1,             /// The node is an Element.
+		ATTRIBUTE_NODE,               /// The node is an Attr.
+		TEXT_NODE,                    /// The node is a Text node.
+		CDATA_SECTION_NODE,           /// The node is a CDATASection.
+		ENTITY_REFERENCE_NODE,        /// The node is an EntityReference.
+		ENTITY_NODE,                  /// The node is an Entity.
+		PROCESSING_INSTRUCTION_NODE,  /// The node is a ProcessingInstruction.
+		COMMENT_NODE,                 /// The node is a Comment.
+		DOCUMENT_NODE,                /// The node is a Document.
+		DOCUMENT_TYPE_NODE,           /// The node is a DocumentType.
+		DOCUMENT_FRAGMENT_NODE,       /// The node is a DocumentFragment.
+		NOTATION_NODE                 /// The node is a Notation.
+	};
+
+	virtual const XMLString& nodeName() const = 0;
+		/// Returns the name of this node, depending on its type.
+
+	const XMLString& nodeValue() const;
+		/// Returns the value of this node, depending on its type.
+
+	virtual const XMLString& getNodeValue() const = 0;
+		/// Returns the value of this node, depending on its type.
+
+	virtual void setNodeValue(const XMLString& value) = 0;
+		/// Sets the value of this node. Throws an exception
+		/// if the node is read-only.
+
+	virtual unsigned short nodeType() const = 0;
+		/// Returns a code representing the type of the underlying object.
+
+	virtual Node* parentNode() const = 0;
+		/// The parent of this node. All nodes, except Attr, Document, DocumentFragment,
+		/// Entity, and Notation may have a parent. However, if a node has just been
+		/// created and not yet added to the tree, or if it has been removed from the
+		/// tree, this is null.
+
+	virtual NodeList* childNodes() const = 0;
+		/// Returns a NodeList containing all children of this node.
+		///
+		/// The returned NodeList must be released with a call
+		/// to release() when no longer needed.
+
+	virtual Node* firstChild() const = 0;
+		/// Returns the first child of this node. If there is no such
+		/// node, this returns null.
+
+	virtual Node* lastChild() const = 0;
+		/// Returns the last child of this node. If there is no such
+		/// node, this returns null.
+
+	virtual Node* previousSibling() const = 0;
+		/// Returns the node immediately preceding this node. If there
+		/// is no such node, this returns null.
+
+	virtual Node* nextSibling() const = 0;
+		/// Returns the node immediately following this node. If there
+		/// is no such node, this returns null.
+
+	virtual NamedNodeMap* attributes() const = 0;
+		/// Returns a NamedNodeMap containing the attributes of this
+		/// node (if it is an Element) or null otherwise.
+		/// 
+		/// The returned NamedNodeMap must be released with a call
+		/// to release() when no longer needed.
+
+	virtual Document* ownerDocument() const = 0;
+		/// Returns the Document object associated with this node.
+		/// This is also the Document object used to create new nodes.
+		/// When this node is a Document, this is null.
+
+	virtual Node* insertBefore(Node* newChild, Node* refChild) = 0;
+		/// Inserts the node newChild before the existing child node refChild.
+		///
+		/// If refChild is null, insert newChild at the end of the list of children.
+		/// If newChild is a DocumentFragment object, all of its children are
+		/// inserted in the same order, before refChild. If the newChild is already
+		/// in the tree, it is first removed.
+
+	virtual Node* replaceChild(Node* newChild, Node* oldChild) = 0;
+		/// Replaces the child node oldChild with newChild in the list of children,
+		/// and returns the oldChild node.
+		/// If newChild is a DocumentFragment object, oldChild is replaced by all of
+		/// the DocumentFragment children, which are inserted in the same order. If
+		/// the newChild is already in the tree, it is first removed.
+
+	virtual Node* removeChild(Node* oldChild) = 0;
+		/// Removes the child node indicated by oldChild from the list of children
+		/// and returns it. 
+
+	virtual Node* appendChild(Node* newChild) = 0;
+		/// Appends the node newChild to the end of the list of children of this node.
+		/// If newChild is already in the tree, it is first removed.
+
+	virtual bool hasChildNodes() const = 0;
+		/// This is a convenience method to allow easy determination of whether a 
+		/// node has any children.
+		/// Returns true if the node has any children, false otherwise.
+
+	virtual Node* cloneNode(bool deep) const = 0;
+		/// Returns a duplicate of this node, i.e., serves as a generic copy constructor
+		/// for nodes. The duplicate node has no parent; (parentNode is null.).
+		/// Cloning an Element copies all attributes and their values, including those
+		/// generated by the XML processor to represent defaulted attributes, but this
+		/// method does not copy any text it contains unless it is a deep clone, since
+		/// the text is contained in a child Text node. Cloning an Attribute directly,
+		/// as opposed to be cloned as part of an Element cloning operation, returns
+		/// a specified attribute (specified is true). Cloning any other type of node
+		/// simply returns a copy of this node.
+		/// Note that cloning an immutable subtree results in a mutable copy, but the
+		/// children of an EntityReference clone are readonly. In addition, clones of
+		/// unspecified Attr nodes are specified. And, cloning Document, DocumentType,
+		/// Entity, and Notation nodes is implementation dependent.
+	
+	// DOM Level 2
+	virtual void normalize() = 0;
+		/// Puts all Text nodes in the full depth of the sub-tree underneath this Node,
+		/// including attribute nodes, into a "normal" form where only structure (e.g.,
+		/// elements, comments, processing instructions, CDATA sections, and entity
+		/// references) separates Text nodes, i.e., there are neither adjacent Text
+		/// nodes nor empty Text nodes. This can be used to ensure that the DOM view
+		/// of a document is the same as if it were saved and re-loaded, and is useful
+		/// when operations (such as XPointer lookups) that depend on a particular
+		/// document tree structure are to be used.
+		/// 
+		/// Note: In cases where the document contains CDATASections, the normalize
+		/// operation alone may not be sufficient, since XPointers do not differentiate
+		/// between Text nodes and CDATASection nodes.
+
+	virtual bool isSupported(const XMLString& feature, const XMLString& version) const = 0;
+		/// Tests whether the DOM implementation implements a specific 
+		/// feature and that feature is supported by this node.
+
+	virtual const XMLString& namespaceURI() const = 0;
+		/// Returns the namespace URI of the node.
+		/// This is not a computed value that is the result of a namespace lookup based on an 
+		/// examination of the namespace declarations in scope. It is merely the namespace URI 
+		/// given at creation time.
+		///
+		/// For nodes of any type other than ELEMENT_NODE and ATTRIBUTE_NODE and nodes created with a 
+		/// DOM Level 1 method, such as createElement from the Document interface, this is always the
+		/// empty string.
+
+	virtual XMLString prefix() const = 0;
+		/// Returns the namespace prefix from the qualified name of the node.
+
+	virtual const XMLString& localName() const = 0;
+		/// Returns the local name of the node.
+
+	virtual bool hasAttributes() const = 0;
+		/// Returns whether this node (if it is an element) has any attributes.
+		
+	// Extensions
+	using NSMap = Poco::XML::NamespaceSupport;
+
+	virtual XMLString innerText() const = 0;
+		/// Returns a string containing the concatenated values of the node
+		/// and all its child nodes. 
+		///
+		/// This method is not part of the W3C Document Object Model.
+		
+	virtual Node* getNodeByPath(const XMLString& path) const = 0;
+		/// Searches a node (element or attribute) based on a simplified XPath 
+		/// expression.
+		///
+		/// Only simple XPath expressions are supported. These are the slash
+		/// notation for specifying paths to elements, and the square bracket
+		/// expression for finding elements by their index, by attribute value, 
+		/// or finding attributes by names.
+		///
+		/// The slash at the beginning is optional, the evaluation always starts
+		/// at this element. A double-slash at the beginning recursively searches 
+		/// the entire subtree for the first element.
+		///
+		/// Examples:
+		///     elem1/elem2/elem3
+		///     /elem1/elem2/elem3
+		///     /elem1/elem2[1]
+		///     /elem1/elem2[@attr1]
+		///     /elem1/elem2[@attr1='value']
+		///     //elem2[@attr1='value']
+		///     //[@attr1='value']
+		///
+		/// This method is an extension to the W3C Document Object Model.
+
+	virtual Node* getNodeByPathNS(const XMLString& path, const NSMap& nsMap) const = 0;
+		/// Searches a node (element or attribute) based on a simplified XPath 
+		/// expression. The given NSMap must contain mappings from namespace
+		/// prefixes to namespace URIs for all namespace prefixes used in 
+		/// the path expression.
+		///
+		/// Only simple XPath expressions are supported. These are the slash
+		/// notation for specifying paths to elements, and the square bracket
+		/// expression for finding elements by their index, by attribute value, 
+		/// or finding attributes by names.
+		///
+		/// The slash at the beginning is optional, the evaluation always starts
+		/// at this element. A double-slash at the beginning recursively searches 
+		/// the entire subtree for the first element.
+		///
+		/// Examples:
+		///     /ns1:elem1/ns2:elem2/ns2:elem3
+		///     /ns1:elem1/ns2:elem2[1]
+		///     /ns1:elem1/ns2:elem2[@attr1]
+		///     /ns1:elem1/ns2:elem2[@attr1='value']
+		///     //ns2:elem2[@ns1:attr1='value']
+		///     //[@ns1:attr1='value']
+		///
+		/// This method is an extension to the W3C Document Object Model.
+
+protected:
+	virtual ~Node();
+};
+
+
+//
+// inlines
+//
+inline const XMLString& Node::nodeValue() const
+{
+	return getNodeValue();
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_Node_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/NodeAppender.h b/base/poco/XML/include/Poco/DOM/NodeAppender.h
new file mode 100644
index 00000000000..2d36be2e3c7
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/NodeAppender.h
@@ -0,0 +1,81 @@
+//
+// NodeAppender.h
+//
+// Library: XML
+// Package: DOM
+// Module:  NodeAppender
+//
+// Definition of the NodeAppender class.
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_NodeAppender_INCLUDED
+#define DOM_NodeAppender_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/Node.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class AbstractNode;
+class Element;
+
+
+class XML_API NodeAppender
+	/// The NodeAppender class provides a very fast way to
+	/// build larger DOM documents.
+	///
+	/// In the DOM, child nodes are usually appended to a parent
+	/// node using the appendChild() method. For nodes containing
+	/// more than a few children, this method can be quite slow,
+	/// due to the way it's implemented, and because of the 
+	/// requirements of the DOM specification.
+	///
+	/// While the NodeAppender is being used on an Element, no
+	/// children-modifying methods of that Element must be used.
+	///
+	/// This class is not part of the DOM specification.
+{
+public:
+	NodeAppender(Element* parent);
+		/// Creates the NodeAppender for the given parent node,
+		/// which must be an Element.
+
+	~NodeAppender();
+		/// Destroys the NodeAppender.
+
+	void appendChild(Node* newChild);
+		/// Appends the node newChild to the end of the list of children of
+		/// the parent node specified in the constructor.
+		/// If the newChild is already in the tree, it is first removed.
+		///
+		/// NewChild can be a DocumentFragment. In this case, all children
+		/// of the fragment become children of the parent element.
+		///
+		/// In order to speed up the function, no DOM events
+		/// are fired.
+
+private:
+	NodeAppender();
+	NodeAppender(const NodeAppender&);
+	NodeAppender& operator = (const NodeAppender&);
+	
+	Element*      _pParent;
+	AbstractNode* _pLast;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // #include "Poco/XML/XML.h"
+
diff --git a/base/poco/XML/include/Poco/DOM/NodeFilter.h b/base/poco/XML/include/Poco/DOM/NodeFilter.h
new file mode 100644
index 00000000000..ae8677bf286
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/NodeFilter.h
@@ -0,0 +1,146 @@
+//
+// NodeFilter.h
+//
+// Library: XML
+// Package: DOM
+// Module:  NodeFilter
+//
+// Definition of the DOM NodeFilter interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_NodeFilter_INCLUDED
+#define DOM_NodeFilter_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Node;
+
+
+class XML_API NodeFilter
+	/// Filters are objects that know how to "filter out" nodes. If a NodeIterator
+	/// or TreeWalker is given a NodeFilter, it applies the filter before it returns
+	/// the next node. If the filter says to accept the node, the traversal logic
+	/// returns it; otherwise, traversal looks for the next node and pretends that
+	/// the node that was rejected was not there.
+	/// 
+	/// The DOM does not provide any filters. NodeFilter is just an interface that
+	/// users can implement to provide their own filters.
+	/// 
+	/// NodeFilters do not need to know how to traverse from node to node, nor do
+	/// they need to know anything about the data structure that is being traversed.
+	/// This makes it very easy to write filters, since the only thing they have
+	/// to know how to do is evaluate a single node. One filter may be used with
+	/// a number of different kinds of traversals, encouraging code reuse.
+{
+public:
+	enum
+	{
+		FILTER_ACCEPT = 1,
+			/// Accept the node. Navigation methods defined for NodeIterator or TreeWalker will return this node.
+
+		FILTER_REJECT = 2,
+			/// Reject the node. Navigation methods defined for NodeIterator or TreeWalker
+			/// will not return this node. For TreeWalker, the children of this node will
+			/// also be rejected. NodeIterators treat this as a synonym for FILTER_SKIP.
+
+		FILTER_SKIP   = 3
+			/// Skip this single node. Navigation methods defined for NodeIterator or TreeWalker
+			/// will not return this node. For both NodeIterator and TreeWalker, the children
+			/// of this node will still be considered.
+	};
+	
+	enum WhatToShow
+		/// These are the available values for the whatToShow parameter used in TreeWalkers
+		/// and NodeIterators. They are the same as the set of possible types for Node,
+		/// and their values are derived by using a bit position corresponding to the
+		/// value of nodeType for the equivalent node type. If a bit in whatToShow is
+		/// set false, that will be taken as a request to skip over this type of node;
+		/// the behavior in that case is similar to that of FILTER_SKIP.
+		/// 
+		/// Note that if node types greater than 32 are ever introduced, they may not
+		/// be individually testable via whatToShow. If that need should arise, it can
+		/// be handled by selecting SHOW_ALL together with an appropriate NodeFilter.
+	{
+		SHOW_ALL                    = 0xFFFFFFFF,
+			/// Show all Nodes.
+	
+		SHOW_ELEMENT                = 0x00000001,
+			/// Show Element nodes.
+
+		SHOW_ATTRIBUTE              = 0x00000002, 
+			/// Show Attr nodes. This is meaningful only when creating an iterator or tree-walker
+			/// with an attribute node as its root; in this case, it means that the attribute
+			/// node will appear in the first position of the iteration or traversal. Since
+			/// attributes are never children of other nodes, they do not appear when traversing
+			/// over the document tree.
+
+		SHOW_TEXT                   = 0x00000004,
+			/// Show Text nodes.
+
+		SHOW_CDATA_SECTION          = 0x00000008,
+			/// Show CDATASection nodes.
+
+		SHOW_ENTITY_REFERENCE       = 0x00000010,
+			/// Show EntityReference nodes.
+
+		SHOW_ENTITY                 = 0x00000020,
+			/// Show Entity nodes. This is meaningful only when creating an iterator or
+			/// tree-walker with an Entity node as its root; in this case, it means that
+			/// the Entity node will appear in the first position of the traversal. Since
+			/// entities are not part of the document tree, they do not appear when traversing
+			/// over the document tree.
+
+		SHOW_PROCESSING_INSTRUCTION = 0x00000040,
+			/// Show ProcessingInstruction nodes.
+
+		SHOW_COMMENT                = 0x00000080,
+			/// Show Comment nodes.
+
+		SHOW_DOCUMENT               = 0x00000100,
+			/// Show Document nodes.
+
+		SHOW_DOCUMENT_TYPE          = 0x00000200,
+			/// Show DocumentType nodes.
+
+		SHOW_DOCUMENT_FRAGMENT      = 0x00000400,
+			/// Show DocumentFragment nodes.
+
+		SHOW_NOTATION               = 0x00000800
+			/// Show Notation nodes. This is meaningful only when creating an iterator or
+			/// tree-walker with a Notation node as its root; in this case, it means that
+			/// the Notation node will appear in the first position of the traversal. Since
+			/// notations are not part of the document tree, they do not appear when traversing
+			/// over the document tree.
+	};
+	
+	virtual short acceptNode(Node* node) = 0;
+		/// Test whether a specified node is visible in the logical view of a TreeWalker
+		/// or NodeIterator. This function will be called by the implementation of TreeWalker
+		/// and NodeIterator; it is not normally called directly from user code. (Though
+		/// you could do so if you wanted to use the same filter to guide your own application
+		/// logic.)
+		///
+		/// Returns FILTER_ACCEPT, FILTER_REJECT or FILTER_SKIP.
+		
+protected:
+	virtual ~NodeFilter();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_NodeFilter_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/NodeIterator.h b/base/poco/XML/include/Poco/DOM/NodeIterator.h
new file mode 100644
index 00000000000..1f8e9a063b2
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/NodeIterator.h
@@ -0,0 +1,167 @@
+//
+// NodeIterator.h
+//
+// Library: XML
+// Package: DOM
+// Module:  NodeIterator
+//
+// Definition of the DOM NodeIterator class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_NodeIterator_INCLUDED
+#define DOM_NodeIterator_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Node;
+class NodeFilter;
+
+
+class XML_API NodeIterator
+	/// Iterators are used to step through a set of nodes, e.g. the set of nodes
+	/// in a NodeList, the document subtree governed by a particular Node, the results
+	/// of a query, or any other set of nodes. The set of nodes to be iterated is
+	/// determined by the implementation of the NodeIterator. DOM Level 2 specifies
+	/// a single NodeIterator implementation for document-order traversal of a document
+	/// subtree.
+	///
+	/// A NodeIterator can be directly instantiated using one of its constructors -
+	/// the DocumentTraversal interface is not needed and therefore not implemented.
+	/// Unlike most other DOM classes, NodeIterator supports value semantics.
+	///
+	/// If the NodeIterator's current node is removed from the document, the
+	/// result of calling any of the movement methods is undefined. This behavior does
+	/// not conform to the DOM Level 2 Traversal specification.
+{
+public:
+	NodeIterator(Node* root, unsigned long whatToShow, NodeFilter* pFilter = 0);
+		/// Creates a NodeIterator over the subtree rooted at the specified node.
+		
+	NodeIterator(const NodeIterator& iterator);
+		/// Creates a NodeIterator by copying another NodeIterator.
+		
+	NodeIterator& operator = (const NodeIterator& iterator);
+		/// Assignment operator.
+		
+	~NodeIterator();
+		/// Destroys the NodeIterator.
+
+	Node* root() const;
+		/// The root node of the NodeIterator, as specified when it was created.
+
+	unsigned long whatToShow() const;
+		/// This attribute determines which node types are presented via the iterator. 
+		/// The available set of constants is defined in the NodeFilter interface. 
+		/// Nodes not accepted by whatToShow will be skipped, but their children may 
+		/// still be considered. Note that this skip takes precedence over the filter, 
+		/// if any.
+
+	NodeFilter* filter() const;
+		/// The NodeFilter used to screen nodes.
+
+	bool expandEntityReferences() const;
+		/// The value of this flag determines whether the children of entity reference
+		/// nodes are visible to the iterator. If false, they and their descendants
+		/// will be rejected. Note that this rejection takes precedence over whatToShow
+		/// and the filter. Also note that this is currently the only situation where
+		/// NodeIterators may reject a complete subtree rather than skipping individual
+		/// nodes.
+		/// 
+		/// To produce a view of the document that has entity references expanded and
+		/// does not expose the entity reference node itself, use the whatToShow flags
+		/// to hide the entity reference node and set expandEntityReferences to true
+		/// when creating the iterator. To produce a view of the document that has entity
+		/// reference nodes but no entity expansion, use the whatToShow flags to show
+		/// the entity reference node and set expandEntityReferences to false.
+		///
+		/// This implementation does not support entity reference expansion and
+		/// thus always returns false.
+
+	Node* nextNode();
+		/// Returns the next node in the set and advances the position of the iterator
+		/// in the set. After a NodeIterator is created, the first call to nextNode()
+		/// returns the first node in the set.
+
+	Node* previousNode();
+		/// Returns the previous node in the set and moves the position of the NodeIterator
+		/// backwards in the set.
+
+	Node* currentNodeNP() const;
+		/// Returns the current node in the set.
+		///
+		/// Leaves the NodeIterator unchanged.
+		///
+		/// Warning: This is a proprietary extension to the DOM Level 2 NodeIterator
+		/// interface.
+
+	void detach();
+		/// Detaches the NodeIterator from the set which it iterated over, releasing
+		/// any computational resources and placing the iterator in the INVALID state.
+		/// After detach has been invoked, calls to nextNode or previousNode will raise
+		/// the exception INVALID_STATE_ERR.
+
+protected:
+	bool accept(Node* pNode) const;
+	Node* next() const;
+	Node* previous() const;
+	Node* last();
+
+private:
+	NodeIterator();
+	
+	Node*         _pRoot;
+	unsigned long _whatToShow;
+	NodeFilter*   _pFilter;
+	Node*         _pCurrent;
+};
+
+
+//
+// inlines
+//
+inline Node* NodeIterator::root() const
+{
+	return _pRoot;
+}
+
+
+inline Node* NodeIterator::currentNodeNP() const
+{
+	return _pCurrent;
+}
+
+
+inline unsigned long NodeIterator::whatToShow() const
+{
+	return _whatToShow;
+}
+
+
+inline NodeFilter* NodeIterator::filter() const
+{
+	return _pFilter;
+}
+
+
+inline bool NodeIterator::expandEntityReferences() const
+{
+	return false;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_NodeIterator_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/NodeList.h b/base/poco/XML/include/Poco/DOM/NodeList.h
new file mode 100644
index 00000000000..1f8c12f4cd2
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/NodeList.h
@@ -0,0 +1,61 @@
+//
+// NodeList.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM NodeList interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_NodeList_INCLUDED
+#define DOM_NodeList_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/DOMObject.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Node;
+
+
+class XML_API NodeList: public DOMObject
+	/// The NodeList interface provides the abstraction of an ordered
+	/// collection of nodes, without defining or constraining how this
+	/// collection is implemented.
+	///
+	/// The items in the NodeList are accessible via an integral index, 
+	/// starting from 0.
+	///
+	/// A NodeList returned from a method must be released with a call to 
+	/// release() when no longer needed.
+{
+public:
+	virtual Node* item(unsigned long index) const = 0;
+		/// Returns the index'th item in the collection. If index is
+		/// greater than or equal to the number of nodes in the list,
+		/// this returns null.
+
+	virtual unsigned long length() const = 0;
+		/// Returns the number of nodes in the list. The range of valid
+		/// node indices is 0 to length - 1 inclusive.
+	
+protected:
+	virtual ~NodeList();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_NodeList_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/Notation.h b/base/poco/XML/include/Poco/DOM/Notation.h
new file mode 100644
index 00000000000..c9824b0e05d
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/Notation.h
@@ -0,0 +1,93 @@
+//
+// Notation.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM Notation class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_Notation_INCLUDED
+#define DOM_Notation_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractNode.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API Notation: public AbstractNode
+	/// This interface represents a notation declared in the DTD. A notation either
+	/// declares, by name, the format of an unparsed entity (see section 4.7 of
+	/// the XML 1.0 specification <http://www.w3.org/TR/2004/REC-xml-20040204/>), 
+	/// or is used for formal declaration of processing
+	/// instruction targets (see section 2.6 of the XML 1.0 specification).
+	/// The nodeName attribute inherited from Node is set to the declared name of
+	/// the notation.
+	/// 
+	/// The DOM Level 1 does not support editing Notation nodes; they are therefore
+	/// readonly.
+	/// 
+	/// A Notation node does not have any parent.
+{
+public:
+	const XMLString& publicId() const;
+		/// Returns the public identifier of this notation.
+		/// If not specified, this is an empty string (and not null,
+		/// as in the DOM specification).
+
+	const XMLString& systemId() const;
+		/// Returns the system identifier of this notation.
+		/// If not specified, this is an empty string (and not null,
+		/// as in the DOM specification).
+
+	// Node
+	const XMLString& nodeName() const;
+	unsigned short nodeType() const;
+
+protected:
+	Notation(Document* pOwnerDocument, const XMLString& name, const XMLString& publicId, const XMLString& systemId);
+	Notation(Document* pOwnerDocument, const Notation& notation);
+	~Notation();
+	
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+
+private:
+	XMLString _name;
+	XMLString _publicId;
+	XMLString _systemId;
+	
+	friend class Document;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& Notation::publicId() const
+{
+	return _publicId;
+}
+
+
+inline const XMLString& Notation::systemId() const
+{
+	return _systemId;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_Notation_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/ProcessingInstruction.h b/base/poco/XML/include/Poco/DOM/ProcessingInstruction.h
new file mode 100644
index 00000000000..ab600ca952b
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/ProcessingInstruction.h
@@ -0,0 +1,99 @@
+//
+// ProcessingInstruction.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM ProcessingInstruction class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_ProcessingInstruction_INCLUDED
+#define DOM_ProcessingInstruction_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/AbstractNode.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API ProcessingInstruction: public AbstractNode
+	/// The ProcessingInstruction interface represents a "processing instruction",
+	/// used in XML as a way to keep processor-specific information in the text
+	/// of the document.
+{
+public:
+	const XMLString& target() const;
+		/// Returns the target of this processing instruction.
+		/// XML defines this as being the first token following
+		/// the markup that begins the processing instruction.
+
+	const XMLString& data() const;
+		/// Returns the content of this processing instruction. This is from the first non 
+		/// white space character after the target to the character immediately preceding
+		/// the ?>.
+
+	const XMLString& getData() const;
+		/// Returns the content of this processing instruction. This is from the first non 
+		/// white space character after the target to the character immediately preceding
+		/// the ?>.
+
+	void setData(const XMLString& data);
+		/// Sets the content of this processing instruction.
+
+	// Node
+	const XMLString& nodeName() const;
+	const XMLString& getNodeValue() const;
+	void setNodeValue(const XMLString& data);
+	unsigned short nodeType() const;
+
+protected:
+	ProcessingInstruction(Document* pOwnerDocument, const XMLString& target, const XMLString& data);
+	ProcessingInstruction(Document* pOwnerDocument, const ProcessingInstruction& processingInstruction);
+	~ProcessingInstruction();
+
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+
+private:
+	XMLString _target;
+	XMLString _data;
+	
+	friend class Document;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& ProcessingInstruction::target() const
+{
+	return _target;
+}
+
+
+inline const XMLString& ProcessingInstruction::data() const
+{
+	return _data;
+}
+
+
+inline const XMLString& ProcessingInstruction::getData() const
+{
+	return _data;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_ProcessingInstruction_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/Text.h b/base/poco/XML/include/Poco/DOM/Text.h
new file mode 100644
index 00000000000..3a7931a8b24
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/Text.h
@@ -0,0 +1,79 @@
+//
+// Text.h
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Definition of the DOM Text class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_Text_INCLUDED
+#define DOM_Text_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/DOM/CharacterData.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API Text: public CharacterData
+	/// The Text interface inherits from CharacterData and represents the textual
+	/// content (termed character data in XML) of an Element or Attr. If there is
+	/// no markup inside an element's content, the text is contained in a single
+	/// object implementing the Text interface that is the only child of the element.
+	/// If there is markup, it is parsed into the information items (elements, comments,
+	/// etc.) and Text nodes that form the list of children of the element.
+	/// 
+	/// When a document is first made available via the DOM, there is only one Text
+	/// node for each block of text. Users may create adjacent Text nodes that represent
+	/// the contents of a given element without any intervening markup, but should
+	/// be aware that there is no way to represent the separations between these
+	/// nodes in XML or HTML, so they will not (in general) persist between DOM
+	/// editing sessions. The normalize() method on Element merges any such adjacent
+	/// Text objects into a single node for each block of text.
+{
+public:
+	Text* splitText(unsigned long offset);
+		/// Breaks this node into two nodes at the specified offset, keeping both in
+		/// the tree as siblings. This node then only contains all the content up to
+		/// the offset point. A new node of the same type, which is inserted as the
+		/// next sibling of this node, contains all the content at and after the offset
+		/// point. When the offset is equal to the length of this node, the new node
+		/// has no data.
+
+	// Node
+	const XMLString& nodeName() const;
+	unsigned short nodeType() const;
+
+	// Non-standard extensions
+	XMLString innerText() const;
+
+protected:
+	Text(Document* pOwnerDocument, const XMLString& data);
+	Text(Document* pOwnerDocument, const Text& text);
+	~Text();
+
+	Node* copyNode(bool deep, Document* pOwnerDocument) const;
+
+private:
+	static const XMLString NODE_NAME;
+	
+	friend class Document;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_Text_INCLUDED
diff --git a/base/poco/XML/include/Poco/DOM/TreeWalker.h b/base/poco/XML/include/Poco/DOM/TreeWalker.h
new file mode 100644
index 00000000000..884b37d3c77
--- /dev/null
+++ b/base/poco/XML/include/Poco/DOM/TreeWalker.h
@@ -0,0 +1,211 @@
+//
+// TreeWalker.h
+//
+// Library: XML
+// Package: DOM
+// Module:  TreeWalker
+//
+// Definition of the DOM TreeWalker class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef DOM_TreeWalker_INCLUDED
+#define DOM_TreeWalker_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Node;
+class NodeFilter;
+
+
+class XML_API TreeWalker
+	/// TreeWalker objects are used to navigate a document tree or subtree using
+	/// the view of the document defined by their whatToShow flags and filter (if
+	/// any). Any function which performs navigation using a TreeWalker will automatically
+	/// support any view defined by a TreeWalker.
+	/// 
+	/// Omitting nodes from the logical view of a subtree can result in a structure
+	/// that is substantially different from the same subtree in the complete, unfiltered
+	/// document. Nodes that are siblings in the TreeWalker view may be children
+	/// of different, widely separated nodes in the original view. For instance,
+	/// consider a NodeFilter that skips all nodes except for Text nodes and the
+	/// root node of a document. In the logical view that results, all text nodes
+	/// will be siblings and appear as direct children of the root node, no matter
+	/// how deeply nested the structure of the original document.
+	///
+	/// A TreeWalker can be directly instantiated using one of its constructors -
+	/// the DocumentTraversal interface is not needed and therefore not implemented.
+	/// Unlike most other DOM classes, TreeWalker supports value semantics.
+	///
+	/// If the TreeWalker's current node is removed from the document, the
+	/// result of calling any of the movement methods is undefined. This behavior 
+	/// does not conform to the DOM Level 2 Traversal specification.
+{
+public:
+	TreeWalker(Node* root, unsigned long whatToShow, NodeFilter* pFilter = 0);
+		/// Creates a TreeWalker over the subtree rooted at the specified node.
+		
+	TreeWalker(const TreeWalker& walker);
+		/// Creates a TreeWalker by copying another TreeWalker.
+		
+	TreeWalker& operator = (const TreeWalker& walker);
+		/// Assignment operator.
+	
+	~TreeWalker();
+		/// Destroys the TreeWalker.
+	
+	Node* root() const;
+		/// The root node of the TreeWalker, as specified when it was created.
+
+	unsigned long whatToShow() const;
+		/// This attribute determines which node types are presented via the TreeWalker.
+		/// The available set of constants is defined in the NodeFilter interface. Nodes
+		/// not accepted by whatToShow will be skipped, but their children may still
+		/// be considered. Note that this skip takes precedence over the filter, if
+		/// any.
+
+	NodeFilter* filter() const;
+		/// The NodeFilter used to screen nodes.
+
+	bool expandEntityReferences() const;
+		/// The value of this flag determines whether the children of entity reference
+		/// nodes are visible to the iterator. If false, they and their descendants
+		/// will be rejected. Note that this rejection takes precedence over whatToShow
+		/// and the filter. Also note that this is currently the only situation where
+		/// NodeIterators may reject a complete subtree rather than skipping individual
+		/// nodes.
+		/// 
+		/// To produce a view of the document that has entity references expanded and
+		/// does not expose the entity reference node itself, use the whatToShow flags
+		/// to hide the entity reference node and set expandEntityReferences to true
+		/// when creating the iterator. To produce a view of the document that has entity
+		/// reference nodes but no entity expansion, use the whatToShow flags to show
+		/// the entity reference node and set expandEntityReferences to false.
+		///
+		/// This implementation does not support entity reference expansion and
+		/// thus always returns false.
+
+	Node* currentNode() const;
+		/// The node at which the TreeWalker is currently positioned.
+		/// Alterations to the DOM tree may cause the current node to no longer be accepted
+		/// by the TreeWalker's associated filter. currentNode may also be explicitly
+		/// set to any node, whether or not it is within the subtree specified by the
+		/// root node or would be accepted by the filter and whatToShow flags. Further
+		/// traversal occurs relative to currentNode even if it is not part of the current
+		/// view, by applying the filters in the requested direction; if no traversal
+		/// is possible, currentNode is not changed.
+
+	Node* getCurrentNode() const;
+		/// See currentNode().
+		
+	void setCurrentNode(Node* pNode);
+		/// Sets the current node.
+
+	Node* parentNode();
+		/// Moves to and returns the closest visible ancestor node of the current node.
+		/// If the search for parentNode attempts to step upward from the TreeWalker's
+		/// root node, or if it fails to find a visible ancestor node, this method retains
+		/// the current position and returns null.
+
+	Node* firstChild();
+		/// Moves the TreeWalker to the first visible child of the current node, and
+		/// returns the new node. If the current node has no visible children, returns
+		/// null, and retains the current node.
+
+	Node* lastChild();
+		/// Moves the TreeWalker to the last visible child of the current node, and
+		/// returns the new node. If the current node has no visible children, returns
+		/// null, and retains the current node.
+
+	Node* previousSibling();
+		/// Moves the TreeWalker to the previous sibling of the current node, and returns
+		/// the new node. If the current node has no visible previous sibling, returns
+		/// null, and retains the current node.
+
+	Node* nextSibling();
+		/// Moves the TreeWalker to the next sibling of the current node, and returns
+		/// the new node. If the current node has no visible next sibling, returns null,
+		/// and retains the current node.
+
+	Node* previousNode();
+		/// Moves the TreeWalker to the previous visible node in document order relative
+		/// to the current node, and returns the new node. If the current node has no
+		/// previous node, or if the search for previousNode attempts to step upward
+		/// from the TreeWalker's root node, returns null, and retains the current node.
+
+	Node* nextNode();
+		/// Moves the TreeWalker to the next visible node in document order relative
+		/// to the current node, and returns the new node. If the current node has no
+		/// next node, or if the search for nextNode attempts to step upward from the
+		/// TreeWalker's root node, returns null, and retains the current node.
+
+protected:
+	int accept(Node* pNode) const;
+	Node* next(Node* pNode) const;
+	Node* previous(Node* pNode) const;
+
+private:
+	TreeWalker();
+	
+	Node*         _pRoot;
+	unsigned long _whatToShow;
+	NodeFilter*   _pFilter;
+	Node*         _pCurrent;
+};
+
+
+//
+// inlines
+//
+inline Node* TreeWalker::root() const
+{
+	return _pRoot;
+}
+
+
+inline unsigned long TreeWalker::whatToShow() const
+{
+	return _whatToShow;
+}
+
+
+inline NodeFilter* TreeWalker::filter() const
+{
+	return _pFilter;
+}
+
+
+inline bool TreeWalker::expandEntityReferences() const
+{
+	return false;
+}
+
+
+inline Node* TreeWalker::currentNode() const
+{
+	return _pCurrent;
+}
+
+
+inline Node* TreeWalker::getCurrentNode() const
+{
+	return _pCurrent;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // DOM_TreeWalker_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/Attributes.h b/base/poco/XML/include/Poco/SAX/Attributes.h
new file mode 100644
index 00000000000..d7ba9129ed5
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/Attributes.h
@@ -0,0 +1,120 @@
+//
+// Attributes.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// SAX2 Attributes Interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_Attributes_INCLUDED
+#define SAX_Attributes_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API Attributes
+	/// Interface for a list of XML attributes.
+	/// This interface allows access to a list of attributes in three different ways:
+	///   1.by attribute index; 
+	///   2.by Namespace-qualified name; or 
+	///   3.by qualified (prefixed) name. 
+	/// 
+	/// The list will not contain attributes that were declared #IMPLIED but not 
+	/// specified in the start tag. It will also not contain
+	/// attributes used as Namespace declarations (xmlns*) unless the 
+	/// http://xml.org/sax/features/namespace-prefixes
+	/// feature is set to true (it is false by default).
+	/// 
+	/// If the namespace-prefixes feature (see above) is false, access by 
+	/// qualified name may not be available; if the
+	/// http://xml.org/sax/features/namespaces feature is false, access by 
+	/// Namespace-qualified names may not be available.
+	/// This interface replaces the now-deprecated SAX1 AttributeList interface, 
+	/// which does not contain Namespace support. In
+	/// addition to Namespace support, it adds the getIndex methods (below).
+	/// The order of attributes in the list is unspecified, and will vary from 
+	/// implementation to implementation.
+{
+public:
+	virtual int getIndex(const XMLString& name) const = 0;
+		/// Look up the index of an attribute by a qualified name.
+
+	virtual int getIndex(const XMLString& namespaceURI, const XMLString& localName) const = 0;
+		/// Look up the index of an attribute by a namspace name.
+
+	virtual int getLength() const = 0;
+		/// Return the number of attributes in the list.
+		///
+		/// Once you know the number of attributes, you can iterate through the list.
+		
+	virtual const XMLString& getLocalName(int i) const = 0;
+		/// Look up a local attribute name by index.
+
+	virtual const XMLString& getQName(int i) const = 0;
+		/// Look up a qualified attribute name by index.
+
+	virtual const XMLString& getType(int i) const = 0;
+		/// Look up an attribute type by index.
+		///
+		/// The attribute type is one of the strings "CDATA", "ID", "IDREF", "IDREFS", "NMTOKEN", 
+		/// "NMTOKENS", "ENTITY", "ENTITIES", or "NOTATION" (always in upper case).
+		///
+		/// If the parser has not read a declaration for the attribute, or if the parser does not 
+		/// report attribute types, then it must return the value "CDATA" as stated in the XML 1.0 
+		/// Recommendation (clause 3.3.3, "Attribute-Value Normalization").
+		/// 
+		/// For an enumerated attribute that is not a notation, the parser will report the type 
+		/// as "NMTOKEN".
+
+	virtual const XMLString& getType(const XMLString& qname) const = 0;
+		/// Look up an attribute type by a qualified name.
+		///
+		/// See getType(int) for a description of the possible types.
+
+	virtual const XMLString& getType(const XMLString& namespaceURI, const XMLString& localName) const = 0;
+		/// Look up an attribute type by a namespace name.
+		///
+		/// See getType(int) for a description of the possible types.
+
+	virtual const XMLString& getValue(int i) const = 0;
+		/// Look up an attribute value by index.
+		///
+		/// If the attribute value is a list of tokens (IDREFS, ENTITIES, or NMTOKENS), the tokens 
+		/// will be concatenated into a single string with each token separated by a single space.
+
+	virtual const XMLString& getValue(const XMLString& qname) const = 0;
+		/// Look up an attribute value by a qualified name.
+		///
+		/// See getValue(int) for a description of the possible values.
+
+	virtual const XMLString& getValue(const XMLString& uri, const XMLString& localName) const = 0;
+		/// Look up an attribute value by a namespace name.
+		///
+		/// See getValue(int) for a description of the possible values.
+
+	virtual const XMLString& getURI(int i) const = 0;
+		/// Look up a namespace URI by index.
+
+protected:
+	virtual ~Attributes();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_Attributes_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/AttributesImpl.h b/base/poco/XML/include/Poco/SAX/AttributesImpl.h
new file mode 100644
index 00000000000..13dcf03dac1
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/AttributesImpl.h
@@ -0,0 +1,307 @@
+//
+// AttributesImpl.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Implementation of the SAX2 Attributes Interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_AttributesImpl_INCLUDED
+#define SAX_AttributesImpl_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/SAX/Attributes.h"
+#include <vector>
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API AttributesImpl: public Attributes
+	/// This class provides a default implementation of the SAX2 Attributes interface, 
+	/// with the addition of manipulators so that the list can be modified or reused.
+	/// 
+	/// There are two typical uses of this class:
+	///     1. to take a persistent snapshot of an Attributes object in a startElement event; or
+	///     2. to construct or modify an Attributes object in a SAX2 driver or filter.
+{
+public:
+	struct Attribute
+	{
+		XMLString localName;
+		XMLString namespaceURI;
+		XMLString qname;
+		XMLString value;
+		XMLString type;
+		bool      specified;
+	};
+	using AttributeVec = std::vector<Attribute>;
+	using iterator = AttributeVec::const_iterator;
+
+	AttributesImpl();
+		/// Creates the AttributesImpl.
+		
+	AttributesImpl(const Attributes& attributes);
+		/// Creates the AttributesImpl by copying another one.
+
+	AttributesImpl(const AttributesImpl& attributes);
+		/// Creates the AttributesImpl by copying another one.
+
+	AttributesImpl(AttributesImpl&& attributes) noexcept;
+		/// Creates the AttributesImpl by copying another one.
+
+	~AttributesImpl();
+		/// Destroys the AttributesImpl.
+
+	AttributesImpl& operator = (const AttributesImpl& attributes);
+		/// Assignment operator.
+
+	AttributesImpl& operator = (AttributesImpl&& attributes) noexcept;
+		/// Assignment operator.
+
+	int getIndex(const XMLString& name) const;
+	int getIndex(const XMLString& namespaceURI, const XMLString& localName) const;
+	int getLength() const;
+	const XMLString& getLocalName(int i) const;
+	const XMLString& getQName(int i) const;
+	const XMLString& getType(int i) const;
+	const XMLString& getType(const XMLString& qname) const;
+	const XMLString& getType(const XMLString& namespaceURI, const XMLString& localName) const;
+	const XMLString& getValue(int i) const;
+	const XMLString& getValue(const XMLString& qname) const;
+	const XMLString& getValue(const XMLString& namespaceURI, const XMLString& localName) const;
+	const XMLString& getURI(int i) const;
+
+	bool isSpecified(int i) const;
+		/// Returns true unless the attribute value was provided by DTD defaulting.
+		/// Extension from Attributes2 interface.
+
+	bool isSpecified(const XMLString& qname) const;
+		/// Returns true unless the attribute value was provided by DTD defaulting.
+		/// Extension from Attributes2 interface.
+
+	bool isSpecified(const XMLString& namespaceURI, const XMLString& localName) const;
+		/// Returns true unless the attribute value was provided by DTD defaulting.
+		/// Extension from Attributes2 interface.
+
+	void setValue(int i, const XMLString& value);
+		/// Sets the value of an attribute.
+
+	void setValue(const XMLString& qname, const XMLString& value);
+		/// Sets the value of an attribute.
+
+	void setValue(const XMLString& namespaceURI, const XMLString& localName, const XMLString& value);
+		/// Sets the value of an attribute.
+
+	void setAttributes(const Attributes& attributes);
+		/// Copies the attributes from another Attributes object.
+
+	void setAttribute(int i, const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const XMLString& type, const XMLString& value);
+		/// Sets an attribute.
+
+	void addAttribute(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const XMLString& type, const XMLString& value);
+		/// Adds an attribute to the end of the list.
+
+	void addAttribute(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const XMLString& type, const XMLString& value, bool specified);
+		/// Adds an attribute to the end of the list.
+
+	void addAttribute(const XMLChar* namespaceURI, const XMLChar* localName, const XMLChar* qname, const XMLChar* type, const XMLChar* value, bool specified);
+		/// Adds an attribute to the end of the list.
+
+	Attribute& addAttribute();
+		/// Add an (empty) attribute to the end of the list.
+		/// For internal use only.
+		/// The returned Attribute element must be filled by the caller.
+
+	void removeAttribute(int i);
+		/// Removes an attribute.
+
+	void removeAttribute(const XMLString& qname);
+		/// Removes an attribute.
+
+	void removeAttribute(const XMLString& namespaceURI, const XMLString& localName);
+		/// Removes an attribute.
+
+	void clear();
+		/// Removes all attributes.
+		
+	void reserve(std::size_t capacity);
+		/// Reserves capacity in the internal vector.
+
+	void setLocalName(int i, const XMLString& localName);
+		/// Sets the local name of an attribute.
+
+	void setQName(int i, const XMLString& qname);
+		/// Sets the qualified name of an attribute.
+
+	void setType(int i, const XMLString& type);
+		/// Sets the type of an attribute.
+
+	void setURI(int i, const XMLString& namespaceURI);
+		/// Sets the namespace URI of an attribute.
+
+	iterator begin() const;
+		/// Iterator support.
+		
+	iterator end() const;
+		/// Iterator support.
+
+protected:	
+	Attribute* find(const XMLString& qname) const;
+	Attribute* find(const XMLString& namespaceURI, const XMLString& localName) const;
+
+	struct EmptyAttribute: Attribute
+	{
+		EmptyAttribute();
+	};
+
+private:
+	AttributeVec _attributes;
+	static EmptyAttribute _empty;
+};
+
+
+//
+// inlines
+//
+inline AttributesImpl::iterator AttributesImpl::begin() const
+{
+	return _attributes.begin();
+}
+
+
+inline AttributesImpl::iterator AttributesImpl::end() const
+{
+	return _attributes.end();
+}
+
+
+inline AttributesImpl::Attribute& AttributesImpl::addAttribute()
+{
+	_attributes.push_back(_empty);
+	return _attributes.back();
+}
+
+
+inline int AttributesImpl::getLength() const
+{
+	return (int) _attributes.size();
+}
+
+
+inline const XMLString& AttributesImpl::getLocalName(int i) const
+{
+	poco_assert (0 <= i && i < static_cast<int>(_attributes.size()));
+	return _attributes[i].localName;
+}
+
+
+inline const XMLString& AttributesImpl::getQName(int i) const
+{
+	poco_assert (0 <= i && i < static_cast<int>(_attributes.size()));
+	return _attributes[i].qname;
+}
+
+
+inline const XMLString& AttributesImpl::getType(int i) const
+{
+	poco_assert (0 <= i && i < static_cast<int>(_attributes.size()));
+	return _attributes[i].type;
+}
+
+
+inline const XMLString& AttributesImpl::getType(const XMLString& qname) const
+{
+	Attribute* pAttr = find(qname);
+	if (pAttr)
+		return pAttr->type;
+	else
+		return _empty.type;
+}
+
+
+inline const XMLString& AttributesImpl::getType(const XMLString& namespaceURI, const XMLString& localName) const
+{
+	Attribute* pAttr = find(namespaceURI, localName);
+	if (pAttr)
+		return pAttr->type;
+	else
+		return _empty.type;
+}
+
+
+inline const XMLString& AttributesImpl::getValue(int i) const
+{
+	poco_assert (0 <= i && i < static_cast<int>(_attributes.size()));
+	return _attributes[i].value;
+}
+
+
+inline const XMLString& AttributesImpl::getValue(const XMLString& qname) const
+{
+	Attribute* pAttr = find(qname);
+	if (pAttr)
+		return pAttr->value;
+	else
+		return _empty.value;
+}
+
+
+inline const XMLString& AttributesImpl::getValue(const XMLString& namespaceURI, const XMLString& localName) const
+{
+	Attribute* pAttr = find(namespaceURI, localName);
+	if (pAttr)
+		return pAttr->value;
+	else
+		return _empty.value;
+}
+
+
+inline const XMLString& AttributesImpl::getURI(int i) const
+{
+	poco_assert (0 <= i && i < static_cast<int>(_attributes.size()));
+	return _attributes[i].namespaceURI;
+}
+
+
+inline bool AttributesImpl::isSpecified(int i) const
+{
+	poco_assert (0 <= i && i < static_cast<int>(_attributes.size()));
+	return _attributes[i].specified;
+}
+
+
+inline bool AttributesImpl::isSpecified(const XMLString& qname) const
+{
+	Attribute* pAttr = find(qname);
+	if (pAttr)
+		return pAttr->specified;
+	else
+		return false;
+}
+
+
+inline bool AttributesImpl::isSpecified(const XMLString& namespaceURI, const XMLString& localName) const
+{
+	Attribute* pAttr = find(namespaceURI, localName);
+	if (pAttr)
+		return pAttr->specified;
+	else
+		return false;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_AttributesImpl_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/ContentHandler.h b/base/poco/XML/include/Poco/SAX/ContentHandler.h
new file mode 100644
index 00000000000..58f2a253ad8
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/ContentHandler.h
@@ -0,0 +1,240 @@
+//
+// ContentHandler.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// SAX2 ContentHandler Interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_ContentHandler_INCLUDED
+#define SAX_ContentHandler_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class Locator;
+class Attributes;
+
+
+class XML_API ContentHandler
+	/// Receive notification of the logical content of a document. 
+	///
+	/// This is the main interface that most SAX applications implement: if the
+	/// application needs to be informed of basic parsing events, it implements
+	/// this interface and registers an instance with the SAX parser using the setContentHandler
+	/// method. The parser uses the instance to report basic document-related events
+	/// like the start and end of elements and character data.
+	/// 
+	/// The order of events in this interface is very important, and mirrors the
+	/// order of information in the document itself. For example, all of an element's
+	/// content (character data, processing instructions, and/or subelements) will
+	/// appear, in order, between the startElement event and the corresponding endElement
+	/// event.
+	/// 
+	/// This interface is similar to the now-deprecated SAX 1.0 DocumentHandler
+	/// interface, but it adds support for Namespaces and for reporting skipped
+	/// entities (in non-validating XML processors).
+	/// Receive notification of the logical content of a document.
+{
+public:
+	virtual void setDocumentLocator(const Locator* loc) = 0;
+		/// Receive an object for locating the origin of SAX document events.
+		/// 
+		/// SAX parsers are strongly encouraged (though not absolutely required) to
+		/// supply a locator: if it does so, it must supply the locator to the application
+		/// by invoking this method before invoking any of the other methods in the
+		/// ContentHandler interface.
+		/// 
+		/// The locator allows the application to determine the end position of any
+		/// document-related event, even if the parser is not reporting an error. Typically,
+		/// the application will use this information for reporting its own errors (such
+		/// as character content that does not match an application's business rules).
+		/// The information returned by the locator is probably not sufficient for use
+		/// with a search engine.
+		/// 
+		/// Note that the locator will return correct information only during the invocation
+		/// SAX event callbacks after startDocument returns and before endDocument is
+		/// called. The application should not attempt to use it at any other time.
+
+	virtual void startDocument() = 0;
+		/// Receive notification of the beginning of a document.
+		///
+		/// The SAX parser calls this function one time before calling all other 
+		/// functions of this class (except SetDocumentLocator).
+
+	virtual void endDocument() = 0;
+		/// Receive notification of the end of a document.
+		///
+		/// The SAX parser will invoke this method only once, and it will be the last
+		/// method invoked during the parse. The parser shall not invoke this method
+		/// until it has either abandoned parsing (because of an unrecoverable error)
+		/// or reached the end of input.
+
+	virtual void startElement(const XMLString& uri, const XMLString& localName, const XMLString& qname, const Attributes& attrList) = 0;
+		/// Receive notification of the beginning of an element.
+		/// 
+		/// The Parser will invoke this method at the beginning of every element in
+		/// the XML document; there will be a corresponding endElement event for every
+		/// startElement event (even when the element is empty). All of the element's
+		/// content will be reported, in order, before the corresponding endElement
+		/// event.
+		/// 
+		/// This event allows up to three name components for each element:
+		///    1. the Namespace URI;
+		///    2. the local name; and
+		///    3. the qualified (prefixed) name.
+		/// 
+		/// Any or all of these may be provided, depending on the values of the http://xml.org/sax/features/namespaces
+		/// and the http://xml.org/sax/features/namespace-prefixes properties:
+		///     * the Namespace URI and local name are required when the namespaces
+		///       property is true (the default), and are optional when the namespaces property
+		///       is false (if one is specified, both must be);
+		///     * the qualified name is required when the namespace-prefixes property
+		///       is true, and is optional when the namespace-prefixes property is false (the
+		///       default).
+		/// 
+		/// Note that the attribute list provided will contain only attributes with
+		/// explicit values (specified or defaulted): #IMPLIED attributes will be omitted.
+		/// The attribute list will contain attributes used for Namespace declarations
+		/// (xmlns* attributes) only if the http://xml.org/sax/features/namespace-prefixes
+		/// property is true (it is false by default, and support for a true value is
+		/// optional).
+		/// 
+		/// Like characters(), attribute values may have characters that need more than
+		/// one char value.
+
+	virtual void endElement(const XMLString& uri, const XMLString& localName, const XMLString& qname) = 0;
+		/// Receive notification of the end of an element.
+		/// 
+		/// The SAX parser will invoke this method at the end of every element in the
+		/// XML document; there will be a corresponding startElement event for every
+		/// endElement event (even when the element is empty).
+		/// 
+		/// For information on the names, see startElement.
+
+	virtual void characters(const XMLChar ch[], int start, int length) = 0;
+		/// Receive notification of character data.
+		/// 
+		/// The Parser will call this method to report each chunk of character data.
+		/// SAX parsers may return all contiguous character data in a single chunk,
+		/// or they may split it into several chunks; however, all of the characters
+		/// in any single event must come from the same external entity so that the
+		/// Locator provides useful information.
+		/// 
+		/// The application must not attempt to read from the array outside of the specified
+		/// range.
+		/// 
+		/// Individual characters may consist of more than one XMLChar value. There
+		/// are three important cases where this happens, because characters can't be
+		/// represented in just sixteen bits. In one case, characters are represented
+		/// in a Surrogate Pair, using two special Unicode values. Such characters are
+		/// in the so-called "Astral Planes", with a code point above U+FFFF. A second
+		/// case involves composite characters, such as a base character combining with
+		/// one or more accent characters. And most important, if XMLChar is a plain
+		/// char, characters are encoded in UTF-8.
+		/// 
+		/// Your code should not assume that algorithms using char-at-a-time idioms
+		/// will be working in character units; in some cases they will split characters.
+		/// This is relevant wherever XML permits arbitrary characters, such as attribute
+		/// values, processing instruction data, and comments as well as in data reported
+		/// from this method. It's also generally relevant whenever C++ code manipulates
+		/// internationalized text; the issue isn't unique to XML.
+		/// 
+		/// Note that some parsers will report whitespace in element content using the
+		/// ignorableWhitespace method rather than this one (validating parsers must
+		/// do so).
+
+	virtual void ignorableWhitespace(const XMLChar ch[], int start, int length) = 0;
+		/// Receive notification of ignorable whitespace in element content.
+		/// 
+		/// Validating Parsers must use this method to report each chunk of whitespace
+		/// in element content (see the W3C XML 1.0 recommendation, section 2.10): non-validating
+		/// parsers may also use this method if they are capable of parsing and using
+		/// content models.
+		/// 
+		/// SAX parsers may return all contiguous whitespace in a single chunk, or they
+		/// may split it into several chunks; however, all of the characters in any
+		/// single event must come from the same external entity, so that the Locator
+		/// provides useful information.
+		/// 
+		/// The application must not attempt to read from the array outside of the specified
+		/// range.
+
+	virtual void processingInstruction(const XMLString& target, const XMLString& data) = 0;
+		/// Receive notification of a processing instruction.
+		/// 
+		/// The Parser will invoke this method once for each processing instruction
+		/// found: note that processing instructions may occur before or after the main
+		/// document element.
+		/// 
+		/// A SAX parser must never report an XML declaration (XML 1.0, section 2.8)
+		/// or a text declaration (XML 1.0, section 4.3.1) using this method.
+		/// 
+		/// Like characters(), processing instruction data may have characters that
+		/// need more than one char value.
+
+	virtual void startPrefixMapping(const XMLString& prefix, const XMLString& uri) = 0;
+		/// Begin the scope of a prefix-URI Namespace mapping.
+		/// 
+		/// The information from this event is not necessary for normal Namespace processing:
+		/// the SAX XML reader will automatically replace prefixes for element and attribute
+		/// names when the http://xml.org/sax/features/namespaces feature is true (the
+		/// default).
+		/// 
+		/// There are cases, however, when applications need to use prefixes in character
+		/// data or in attribute values, where they cannot safely be expanded automatically;
+		/// the start/endPrefixMapping event supplies the information to the application
+		/// to expand prefixes in those contexts itself, if necessary.
+		/// 
+		/// Note that start/endPrefixMapping events are not guaranteed to be properly
+		/// nested relative to each other: all startPrefixMapping events will occur
+		/// immediately before the corresponding startElement event, and all endPrefixMapping
+		/// events will occur immediately after the corresponding endElement event,
+		/// but their order is not otherwise guaranteed.
+		/// 
+		/// There should never be start/endPrefixMapping events for the "xml" prefix,
+		/// since it is predeclared and immutable.
+
+	virtual void endPrefixMapping(const XMLString& prefix) = 0;
+		/// End the scope of a prefix-URI mapping.
+		/// 
+		/// See startPrefixMapping for details. These events will always occur immediately
+		/// after the corresponding endElement event, but the order of endPrefixMapping
+		/// events is not otherwise guaranteed.
+
+	virtual void skippedEntity(const XMLString& name) = 0;
+		/// Receive notification of a skipped entity. This is not called for entity
+		/// references within markup constructs such as element start tags or markup
+		/// declarations. (The XML recommendation requires reporting skipped external
+		/// entities. SAX also reports internal entity expansion/non-expansion, except
+		/// within markup constructs.)
+		/// 
+		/// The Parser will invoke this method each time the entity is skipped. Non-validating
+		/// processors may skip entities if they have not seen the declarations (because,
+		/// for example, the entity was declared in an external DTD subset). All processors
+		/// may skip external entities, depending on the values of the http://xml.org/sax/features/external-general-entities
+		/// and the http://xml.org/sax/features/external-parameter-entities properties.
+
+protected:
+	virtual ~ContentHandler();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_ContentHandler_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/DTDHandler.h b/base/poco/XML/include/Poco/SAX/DTDHandler.h
new file mode 100644
index 00000000000..f21a299c81e
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/DTDHandler.h
@@ -0,0 +1,86 @@
+//
+// DTDHandler.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// SAX DTDHandler Interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_DTDHandler_INCLUDED
+#define SAX_DTDHandler_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API DTDHandler
+	/// If a SAX application needs information about notations and unparsed entities, 
+	/// then the application implements this interface and registers an instance with the 
+	/// SAX parser using the parser's setDTDHandler method. The parser uses the instance 
+	/// to report notation and unparsed entity declarations to the application.
+	///
+	/// Note that this interface includes only those DTD events that the XML recommendation 
+	/// requires processors to report: notation and unparsed entity declarations.
+	///
+	/// The SAX parser may report these events in any order, regardless of the order in 
+	/// which the notations and unparsed entities were declared; however, all DTD events 
+	/// must be reported after the document handler's startDocument event, and before the first 
+	/// startElement event. (If the LexicalHandler is used, these events must also be reported before the endDTD event.)
+	/// 
+	/// It is up to the application to store the information for future use (perhaps in a hash table or 
+	/// object tree). If the application encounters attributes of type "NOTATION", "ENTITY", or "ENTITIES", 
+	/// it can use the information that it obtained through this interface to find the entity and/or notation
+	/// corresponding with the attribute value.
+{
+public:
+	virtual void notationDecl(const XMLString& name, const XMLString* publicId, const XMLString* systemId) = 0;
+		/// Receive notification of a notation declaration event.
+		/// 
+		/// It is up to the application to record the notation for later reference, 
+		/// if necessary; notations may appear as attribute values and in unparsed 
+		/// entity declarations, and are sometime used with processing instruction 
+		/// target names.
+		/// 
+		/// At least one of publicId and systemId must be non-null. If a system identifier 
+		/// is present, and it is a URL, the SAX parser must resolve it fully before passing 
+		/// it to the application through this event.
+		/// 
+		/// There is no guarantee that the notation declaration will be reported before any 
+		/// unparsed entities that use it.
+		///
+		/// Note that publicId and systemId maybe null, therefore we pass a pointer rather than a reference.
+		
+	virtual void unparsedEntityDecl(const XMLString& name, const XMLString* publicId, const XMLString& systemId, const XMLString& notationName) = 0;
+		/// Receive notification of an unparsed entity declaration event.
+		/// 
+		/// Note that the notation name corresponds to a notation reported by the 
+		/// notationDecl event. It is up to the application to record the entity for 
+		/// later reference, if necessary; unparsed entities may appear as attribute values.
+		/// 
+		/// If the system identifier is a URL, the parser must resolve it fully before 
+		/// passing it to the application.
+		/// 
+		/// Note that publicId maybe null, therefore we pass a pointer rather than a reference.
+
+protected:
+	virtual ~DTDHandler();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_DTDHandler_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/DeclHandler.h b/base/poco/XML/include/Poco/SAX/DeclHandler.h
new file mode 100644
index 00000000000..578f10275d8
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/DeclHandler.h
@@ -0,0 +1,91 @@
+//
+// DeclHandler.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// SAX2-ext DeclHandler Interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_DeclHandler_INCLUDED
+#define SAX_DeclHandler_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API DeclHandler
+	/// This is an optional extension handler for SAX2 to provide information 
+	/// about DTD declarations in an XML document. XML
+	/// readers are not required to support this handler, and this handler is 
+	/// not included in the core SAX2 distribution.
+	///
+	/// Note that data-related DTD declarations (unparsed entities and notations) 
+	/// are already reported through the DTDHandler interface.
+	/// If you are using the declaration handler together with a lexical handler, 
+	/// all of the events will occur between the startDTD and the endDTD events.
+	/// To set the DeclHandler for an XML reader, use the setProperty method 
+	/// with the propertyId "http://xml.org/sax/properties/declaration-handler". 
+	/// If the reader does not support declaration events, it will throw a
+	/// SAXNotRecognizedException or a SAXNotSupportedException when you attempt to 
+	/// register the handler.
+{
+public:
+	virtual void attributeDecl(const XMLString& eName, const XMLString& aName, const XMLString* valueDefault, const XMLString* value) = 0;
+		/// Report an attribute type declaration.
+		/// 
+		/// Only the effective (first) declaration for an attribute will be reported. 
+		/// The type will be one of the strings "CDATA", "ID", "IDREF", "IDREFS", 
+		/// "NMTOKEN", "NMTOKENS", "ENTITY", "ENTITIES", a parenthesized token group 
+		/// with the separator "|" and all whitespace removed, or the word "NOTATION" 
+		/// followed by a space followed by a parenthesized token group with all whitespace 
+		/// removed.
+		///
+		/// The value will be the value as reported to applications, appropriately normalized 
+		/// and with entity and character references expanded. 
+		
+	virtual void elementDecl(const XMLString& name, const XMLString& model) = 0;
+		/// Report an element type declaration.
+		///
+		/// The content model will consist of the string "EMPTY", the string "ANY", or a 
+		/// parenthesised group, optionally followed by an occurrence indicator. The model 
+		/// will be normalized so that all parameter entities are fully resolved and all 
+		/// whitespace is removed,and will include the enclosing parentheses. Other 
+		/// normalization (such as removing redundant parentheses or simplifying occurrence 
+		/// indicators) is at the discretion of the parser.
+		
+	virtual void externalEntityDecl(const XMLString& name, const XMLString* publicId, const XMLString& systemId) = 0;
+		/// Report an external entity declaration.
+		/// 
+		/// Only the effective (first) declaration for each entity will be reported.
+		/// 
+		/// If the system identifier is a URL, the parser must resolve it fully before 
+		/// passing it to the application.
+
+	virtual void internalEntityDecl(const XMLString& name, const XMLString& value) = 0;
+		/// Report an internal entity declaration.
+		///
+		/// Only the effective (first) declaration for each entity will be reported. All 
+		/// parameter entities in the value will be expanded, but general entities will not.
+
+protected:
+	virtual ~DeclHandler();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_DeclHandler_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/DefaultHandler.h b/base/poco/XML/include/Poco/SAX/DefaultHandler.h
new file mode 100644
index 00000000000..7df1f5479e9
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/DefaultHandler.h
@@ -0,0 +1,83 @@
+//
+// DefaultHandler.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// SAX-2 DefaultHandler class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_DefaultHandler_INCLUDED
+#define SAX_DefaultHandler_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/SAX/EntityResolver.h"
+#include "Poco/SAX/DTDHandler.h"
+#include "Poco/SAX/ContentHandler.h"
+#include "Poco/SAX/ErrorHandler.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API DefaultHandler: public EntityResolver, public DTDHandler, public ContentHandler, public ErrorHandler
+	/// Default base class for SAX2 event handlers. 
+	/// This class is available as a convenience base class for SAX2 applications: 
+	/// it provides default implementations for all of the
+	/// callbacks in the four core SAX2 handler classes:
+	///      * EntityResolver 
+	///      * DTDHandler 
+	///      * ContentHandler 
+	///      * ErrorHandler 
+	/// Application writers can extend this class when they need to implement only 
+	/// part of an interface; parser writers can instantiate this
+	/// class to provide default handlers when the application has not supplied its own.
+{
+public:
+	DefaultHandler();
+		/// Creates the DefaultHandler.
+		
+	~DefaultHandler();
+		/// Destroys the DefaultHandler.
+	
+	// EntityResolver
+	InputSource* resolveEntity(const XMLString* publicId, const XMLString& systemId);
+	void releaseInputSource(InputSource* pSource);
+	
+	// DTDHandler
+	void notationDecl(const XMLString& name, const XMLString* publicId, const XMLString* systemId);
+	void unparsedEntityDecl(const XMLString& name, const XMLString* publicId, const XMLString& systemId, const XMLString& notationName);
+
+	// ContentHandler
+	void setDocumentLocator(const Locator* loc);
+	void startDocument();
+	void endDocument();
+	void startElement(const XMLString& uri, const XMLString& localName, const XMLString& qname, const Attributes& attributes);
+	void endElement(const XMLString& uri, const XMLString& localName, const XMLString& qname);
+	void characters(const XMLChar ch[], int start, int length);
+	void ignorableWhitespace(const XMLChar ch[], int start, int length);
+	void processingInstruction(const XMLString& target, const XMLString& data);
+	void startPrefixMapping(const XMLString& prefix, const XMLString& uri);
+	void endPrefixMapping(const XMLString& prefix);
+	void skippedEntity(const XMLString& name);
+	
+	// ErrorHandler
+	void warning(const SAXException& exc);
+	void error(const SAXException& exc);
+	void fatalError(const SAXException& exc);
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_DefaultHandler_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/EntityResolver.h b/base/poco/XML/include/Poco/SAX/EntityResolver.h
new file mode 100644
index 00000000000..3387ecfca6c
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/EntityResolver.h
@@ -0,0 +1,86 @@
+//
+// EntityResolver.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// SAX EntityResolver Interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_EntityResolver_INCLUDED
+#define SAX_EntityResolver_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class InputSource;
+
+
+class XML_API EntityResolver
+	/// If a SAX application needs to implement customized handling for external entities, 
+	/// it must implement this interface and register an instance with the SAX driver using 
+	/// the setEntityResolver method.
+	/// 
+	/// The XML reader will then allow the application to intercept any external entities 
+	/// (including the external DTD subset and external parameter entities, if any) before 
+	/// including them.
+	/// 
+	/// Many SAX applications will not need to implement this interface, but it will be 
+	/// especially useful for applications that build XML documents from databases or other 
+	/// specialised input sources, or for applications that use URI types other than URLs.
+	///
+	/// The application can also use this interface to redirect system identifiers to local 
+	/// URIs or to look up replacements in a catalog (possibly by using the public identifier).
+{
+public:
+	virtual InputSource* resolveEntity(const XMLString* publicId, const XMLString& systemId) = 0;
+		/// Allow the application to resolve external entities.
+		/// 
+		/// The parser will call this method before opening any external entity except the 
+		/// top-level document entity. Such entities include the external DTD subset and 
+		/// external parameter entities referenced within the DTD (in either case, only 
+		/// if the parser reads external parameter entities), and external general entities 
+		/// referenced within the document element (if the parser reads external general entities). 
+		/// The application may request that the parser locate the entity itself, that it use an 
+		/// alternative URI, or that it use data provided by the application (as a character or 
+		/// byte input stream).
+		/// 
+		/// Application writers can use this method to redirect external system identifiers to 
+		/// secure and/or local URIs, to look up public identifiers in a catalogue, or to read an 
+		/// entity from a database or other input source (including, for example, a dialog box). 
+		/// Neither XML nor SAX specifies a preferred policy for using public or system IDs to resolve 
+		/// resources. However, SAX specifies how to interpret any InputSource returned by this method, 
+		/// and that if none is returned, then the system ID will be dereferenced as a URL.
+		/// 
+		/// If the system identifier is a URL, the SAX parser must resolve it fully before reporting it to 
+		/// the application.
+		/// 
+		/// Note that publicId maybe null, therefore we pass a pointer rather than a reference.
+
+	virtual void releaseInputSource(InputSource* pSource) = 0;
+		/// This is a non-standard extension to SAX!
+		/// Called by the parser when the input source returned by ResolveEntity is
+		/// no longer needed. Should free any resources used by the input source.
+
+protected:
+	virtual ~EntityResolver();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_EntityResolver_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/EntityResolverImpl.h b/base/poco/XML/include/Poco/SAX/EntityResolverImpl.h
new file mode 100644
index 00000000000..de088c64b68
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/EntityResolverImpl.h
@@ -0,0 +1,78 @@
+//
+// EntityResolverImpl.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// An implementation of EntityResolver.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_EntityResolverImpl_INCLUDED
+#define SAX_EntityResolverImpl_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+#include "Poco/SAX/EntityResolver.h"
+#include "Poco/URIStreamOpener.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API EntityResolverImpl: public EntityResolver
+	/// A default implementation of the EntityResolver interface.
+	///
+	/// The system ID is first interpreted as an URI and the
+	/// URIStreamOpener is used to create and open an istream
+	/// for an InputSource.
+	///
+	/// If the system ID is not a valid URI, it is
+	/// interpreted as a filesystem path and a Poco::FileInputStream
+	/// is opened for it.
+{
+public:
+	EntityResolverImpl();
+		/// Creates an EntityResolverImpl that uses the default
+		/// URIStreamOpener.
+		
+	EntityResolverImpl(const Poco::URIStreamOpener& opener);
+		/// Creates an EntityResolverImpl that uses the given
+		/// URIStreamOpener.
+		
+	~EntityResolverImpl();
+		/// Destroys the EntityResolverImpl.
+	
+	InputSource* resolveEntity(const XMLString* publicId, const XMLString& systemId);
+		/// Tries to use the URIStreamOpener to create and open an istream
+		/// for the given systemId, which is interpreted as an URI.
+		///
+		/// If the systemId is not a valid URI, it is interpreted as
+		/// a local filesystem path and a Poco::FileInputStream is opened for it.
+		
+	void releaseInputSource(InputSource* pSource);
+		/// Deletes the InputSource's stream.
+	
+protected:
+	std::istream* resolveSystemId(const XMLString& systemId);	
+	
+private:
+	EntityResolverImpl(const EntityResolverImpl&);
+	EntityResolverImpl& operator = (const EntityResolverImpl&);
+	
+	const Poco::URIStreamOpener& _opener;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_EntityResolverImpl_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/ErrorHandler.h b/base/poco/XML/include/Poco/SAX/ErrorHandler.h
new file mode 100644
index 00000000000..3097e200757
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/ErrorHandler.h
@@ -0,0 +1,92 @@
+//
+// ErrorHandler.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// SAX ErrorHandler Interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_ErrorHandler_INCLUDED
+#define SAX_ErrorHandler_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class SAXException;
+
+
+class XML_API ErrorHandler
+	/// If a SAX application needs to implement customized error handling, it must 
+	/// implement this interface and then register an instance with the XML reader 
+	/// using the setErrorHandler method. The parser will then report all errors and 
+	/// warnings through this interface.
+	/// 
+	/// WARNING: If an application does not register an ErrorHandler, XML parsing errors 
+	/// will go unreported, except that SAXParseExceptions will be thrown for fatal errors. 
+	/// In order to detect validity errors, an ErrorHandler that does something with error() 
+	/// calls must be registered.
+	/// 
+	/// For XML processing errors, a SAX driver must use this interface in preference to 
+	/// throwing an exception: it is up to the application to decide whether to throw an 
+	/// exception for different types of errors and warnings. Note, however, that there is no 
+	/// requirement that the parser continue to report additional errors after a call to 
+	/// fatalError. In other words, a SAX driver class may throw an exception after reporting 
+	/// any fatalError. Also parsers may throw appropriate exceptions for non-XML errors. For 
+	/// example, XMLReader::parse() would throw an IOException for errors accessing entities or 
+	/// the document.
+{
+public:
+	virtual void warning(const SAXException& exc) = 0;
+		/// Receive notification of a warning.
+		/// 
+		/// SAX parsers will use this method to report conditions that are not errors or fatal 
+		/// errors as defined by the XML recommendation. The default behaviour is to take no action.
+		/// 
+		/// The SAX parser must continue to provide normal parsing events after invoking this method: 
+		/// it should still be possible for the application to process the document through to the end.
+		/// 
+		/// Filters may use this method to report other, non-XML warnings as well.
+
+	virtual void error(const SAXException& exc) = 0;
+		/// Receive notification of a recoverable error.
+		/// 
+		/// This corresponds to the definition of "error" in section 1.2 of the W3C XML 1.0 
+		/// Recommendation. For example, a validating parser would use this callback to report 
+		/// the violation of a validity constraint. The default behaviour is to take no action.
+		/// 
+		/// The SAX parser must continue to provide normal parsing events after invoking this 
+		/// method: it should still be possible for the application to process the document through 
+		/// to the end. If the application cannot do so, then the parser should report a fatal error 
+		/// even if the XML recommendation does not require it to do so.
+		/// 
+		/// Filters may use this method to report other, non-XML errors as well.
+
+	virtual void fatalError(const SAXException& exc) = 0;
+		/// Receive notification of a non-recoverable error.
+		/// The application must assume that the document is unusable after the parser has 
+		/// invoked this method, and should continue (if at all) only for the sake of collecting 
+		/// additional error messages: in fact, SAX parsers are free to stop reporting any other 
+		/// events once this method has been invoked.
+
+protected:
+	virtual ~ErrorHandler();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_ErrorHandler_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/InputSource.h b/base/poco/XML/include/Poco/SAX/InputSource.h
new file mode 100644
index 00000000000..7fcecf2589b
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/InputSource.h
@@ -0,0 +1,169 @@
+//
+// InputSource.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// SAX InputSource - A single input source for an XML entity.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_InputSource_INCLUDED
+#define SAX_InputSource_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+#include "Poco/XML/XMLStream.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API InputSource
+	/// This class allows a SAX application to encapsulate information about an input 
+	/// source in a single object, which may include a public identifier, a system 
+	/// identifier, a byte stream (possibly with a specified encoding), and/or a character 
+	/// stream.
+	/// 
+	/// There are two places that the application can deliver an input source to the 
+	/// parser: as the argument to the Parser.parse method, or as the return value of the 
+	/// EntityResolver::resolveEntity() method.
+	/// 
+	/// The SAX parser will use the InputSource object to determine how to read XML input. 
+	/// If there is a character stream available, the parser will read that stream directly, 
+	/// disregarding any text encoding declaration found in that stream. If there is no character 
+	/// stream, but there is a byte stream, the parser will use that byte stream, using the 
+	/// encoding specified in the InputSource or else (if no encoding is specified) autodetecting 
+	/// the character encoding using an algorithm such as the one in the XML specification. 
+	/// If neither a character stream nor a byte stream is available, the parser will attempt 
+	/// to open a URI connection to the resource identified by the system identifier.
+	/// 
+	/// An InputSource object belongs to the application: the SAX parser shall never modify it in 
+	/// any way (it may modify a copy if necessary). However, standard processing of both byte and 
+	/// character streams is to close them on as part of end-of-parse cleanup, so applications should 
+	/// not attempt to re-use such streams after they have been handed to a parser.
+{
+public:
+	InputSource();
+		/// Zero-argument default constructor.
+		
+	InputSource(const XMLString& systemId);
+		/// Creates a new input source with a system identifier.
+		/// Applications may use setPublicId to include a public identifier as well, 
+		/// or setEncoding to specify the character encoding, if known.
+		/// 
+		/// If the system identifier is a URL, it must be fully resolved (it may not 
+		/// be a relative URL).
+		
+	InputSource(XMLByteInputStream& istr);
+		/// Creates a new input source with a byte stream.
+		/// 
+		/// Application writers should use setSystemId() to provide a base for resolving
+		/// relative URIs, may use setPublicId to include a public identifier, and may use 
+		/// setEncoding to specify the object's character encoding.
+
+	~InputSource();
+		/// Destroys the InputSource.
+
+	void setPublicId(const XMLString& publicId);
+		/// Set the public identifier for this input source.
+		///
+		/// The public identifier is always optional: if the application writer includes one, 
+		/// it will be provided as part of the location information.
+		
+	void setSystemId(const XMLString& systemId);
+		/// Set the system identifier for this input source.
+		///
+		/// The system identifier is optional if there is a byte stream or a character stream, 
+		/// but it is still useful to provide one, since the application can use it to resolve 
+		/// relative URIs and can include it in error messages and warnings (the parser will 
+		/// attempt to open a connection to the URI only if there is no byte stream or character 
+		/// stream specified).
+		/// 
+		/// If the application knows the character encoding of the object pointed to by the system 
+		/// identifier, it can register the encoding using the setEncoding method.
+		/// 
+		/// If the system identifier is a URL, it must be fully resolved (it may not be a relative URL).
+
+	const XMLString& getPublicId() const;
+		/// Get the public identifier for this input source.
+		
+	const XMLString& getSystemId() const;
+		/// Get the system identifier for this input source.
+
+	void setByteStream(XMLByteInputStream& istr);
+		/// Set the byte stream for this input source.
+		/// The SAX parser will ignore this if there is also a character stream specified, but it 
+		/// will use a byte stream in preference to opening a URI connection itself.
+		
+	XMLByteInputStream* getByteStream() const;
+		/// Get the byte stream for this input source.
+
+	void setCharacterStream(XMLCharInputStream& istr);
+		/// Set the character stream for this input source.
+
+	XMLCharInputStream* getCharacterStream() const;
+		/// Get the character stream for this input source.
+
+	void setEncoding(const XMLString& encoding);
+		/// Set the character encoding, if known.
+		/// The encoding must be a string acceptable for an XML encoding declaration 
+		/// (see section 4.3.3 of the XML 1.0 recommendation).
+		
+	const XMLString& getEncoding() const;
+		/// Get the character encoding for a byte stream or URI.
+
+private:
+	XMLString _publicId;
+	XMLString _systemId;
+	XMLString _encoding;
+	XMLByteInputStream* _bistr;
+	XMLCharInputStream* _cistr;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& InputSource::getPublicId() const
+{
+	return _publicId;
+}
+
+
+inline const XMLString& InputSource::getSystemId() const
+{
+	return _systemId;
+}
+
+
+inline const XMLString& InputSource::getEncoding() const
+{
+	return _encoding;
+}
+
+
+inline XMLByteInputStream* InputSource::getByteStream() const
+{
+	return _bistr;
+}
+
+
+inline XMLCharInputStream* InputSource::getCharacterStream() const
+{
+	return _cistr;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_InputSource_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/LexicalHandler.h b/base/poco/XML/include/Poco/SAX/LexicalHandler.h
new file mode 100644
index 00000000000..772bd5c3fb8
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/LexicalHandler.h
@@ -0,0 +1,125 @@
+//
+// LexicalHandler.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// SAX2-ext LexicalHandler Interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_LexicalHandler_INCLUDED
+#define SAX_LexicalHandler_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API LexicalHandler
+	/// This is an optional extension handler for SAX2 to provide lexical information 
+	/// about an XML document, such as comments and CDATA section boundaries. 
+	/// XML readers are not required to recognize this handler, and it is not part of 
+	/// core-only SAX2 distributions.
+	/// 
+	/// The events in the lexical handler apply to the entire document, not just to the 
+	/// document element, and all lexical handler events must appear between the content 
+	/// handler's startDocument and endDocument events.
+	/// 
+	/// To set the LexicalHandler for an XML reader, use the setProperty method with the 
+	/// property name http://xml.org/sax/properties/lexical-handler and an object implementing 
+	/// this interface (or null) as the value. If the reader does not report lexical events, 
+	/// it will throw a SAXNotRecognizedException when you attempt to register the handler.
+{
+public:
+	virtual void startDTD(const XMLString& name, const XMLString& publicId, const XMLString& systemId) = 0;
+		/// Report the start of DTD declarations, if any.
+		/// 
+		/// This method is intended to report the beginning of the DOCTYPE declaration; 
+		/// if the document has no DOCTYPE declaration, this method will not be invoked.
+		/// 
+		/// All declarations reported through DTDHandler or DeclHandler events must appear 
+		/// between the startDTD and endDTD events. Declarations are assumed to belong to 
+		/// the internal DTD subset unless they appear between startEntity and endEntity 
+		/// events. Comments and processing instructions from the DTD should also be reported 
+		/// between the startDTD and endDTD events, in their original order of (logical) occurrence; 
+		/// they are not required to appear in their correct locations relative to DTDHandler or 
+		/// DeclHandler events, however.
+		/// 
+		/// Note that the start/endDTD events will appear within the start/endDocument events from 
+		/// ContentHandler and before the first startElement event.
+
+	virtual void endDTD() = 0;
+		/// Report the end of DTD declarations.
+		/// 
+		/// This method is intended to report the end of the DOCTYPE declaration; if the document 
+		/// has no DOCTYPE declaration, this method will not be invoked.
+
+	virtual void startEntity(const XMLString& name) = 0;
+		/// Report the beginning of some internal and external XML entities.
+		/// 
+		/// The reporting of parameter entities (including the external DTD subset) is optional, 
+		/// and SAX2 drivers that report LexicalHandler events may not implement it; you can use the 
+		/// http://xml.org/sax/features/lexical-handler/parameter-entities feature to query or control 
+		/// the reporting of parameter entities.
+		/// 
+		/// General entities are reported with their regular names, parameter entities have '%' 
+		/// prepended to their names, and the external DTD subset has the pseudo-entity name "[dtd]".
+		/// 
+		/// When a SAX2 driver is providing these events, all other events must be properly nested 
+		/// within start/end entity events. There is no additional requirement that events from 
+		/// DeclHandler or DTDHandler be properly ordered.
+		/// 
+		/// Note that skipped entities will be reported through the skippedEntity event, which is part of 
+		/// the ContentHandler interface.
+		/// 
+		/// Because of the streaming event model that SAX uses, some entity boundaries cannot be reported under 
+		/// any circumstances:
+		/// 
+		///     * general entities within attribute values
+		///     * parameter entities within declarations
+		///
+		/// These will be silently expanded, with no indication of where the original entity boundaries were.
+		/// 
+		/// Note also that the boundaries of character references (which are not really entities anyway) are not reported.
+		/// 
+		/// All start/endEntity events must be properly nested. 
+
+	virtual void endEntity(const XMLString& name) = 0;
+		/// Report the end of an entity.
+		
+	virtual void startCDATA() = 0;
+		/// Report the start of a CDATA section.
+		///
+		/// The contents of the CDATA section will be reported through the regular characters event; 
+		/// this event is intended only to report the boundary.
+
+	virtual void endCDATA() = 0;
+		/// Report the end of a CDATA section.
+		
+	virtual void comment(const XMLChar ch[], int start, int length) = 0;
+		/// Report an XML comment anywhere in the document.
+		/// 
+		/// This callback will be used for comments inside or outside the document element, 
+		/// including comments in the external DTD subset (if read). Comments in the DTD must 
+		/// be properly nested inside start/endDTD and start/endEntity events (if used).
+
+protected:
+	virtual ~LexicalHandler();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_LexicalHandler_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/Locator.h b/base/poco/XML/include/Poco/SAX/Locator.h
new file mode 100644
index 00000000000..4f2b47d4812
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/Locator.h
@@ -0,0 +1,103 @@
+//
+// Locator.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// SAX Locator Interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_Locator_INCLUDED
+#define SAX_Locator_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API Locator
+	/// Interface for associating a SAX event with a document location.
+	/// 
+	/// If a SAX parser provides location information to the SAX application, it does so by 
+	/// implementing this interface and then passing an instance to the application using the 
+	/// content handler's setDocumentLocator method. The application can use the object to obtain 
+	/// the location of any other SAX event in the XML source document.
+	/// 
+	/// Note that the results returned by the object will be valid only during the scope of each 
+	/// callback method: the application will receive unpredictable results if it attempts to use 
+	/// the locator at any other time, or after parsing completes.
+	/// 
+	/// SAX parsers are not required to supply a locator, but they are very strongly encouraged to 
+	/// do so. If the parser supplies a locator, it must do so before reporting any other document 
+	/// events. If no locator has been set by the time the application receives the startDocument event, 
+	/// the application should assume that a locator is not available.
+{
+public:
+	virtual XMLString getPublicId() const = 0;
+		/// Return the public identifier for the current document event.
+		/// 
+		/// The return value is the public identifier of the document entity or of the external 
+		/// parsed entity in which the markup triggering the event appears.
+
+	virtual XMLString getSystemId() const = 0;
+		/// Return the system identifier for the current document event.
+		/// 
+		/// The return value is the system identifier of the document entity or of the external 
+		/// parsed entity in which the markup triggering the event appears.
+		/// 
+		/// If the system identifier is a URL, the parser must resolve it fully before passing 
+		/// it to the application. For example, a file name must always be provided as a 
+		/// file:... URL, and other kinds of relative URI are also resolved against their bases.
+
+	virtual int getLineNumber() const = 0;
+		/// Return the line number where the current document event ends.
+		/// Lines are delimited by line ends, which are defined in the XML specification.
+		/// 
+		/// Warning: The return value from the method is intended only as an approximation for 
+		/// the sake of diagnostics; it is not intended to provide sufficient information to 
+		/// edit the character content of the original XML document. In some cases, these "line" 
+		/// numbers match what would be displayed as columns, and in others they may not match the 
+		/// source text due to internal entity expansion.
+		/// 
+		/// The return value is an approximation of the line number in the document entity or external 
+		/// parsed entity where the markup triggering the event appears.
+		/// 
+		/// If possible, the SAX driver should provide the line position of the first character after 
+		/// the text associated with the document event. The first line is line 1.
+
+	virtual int getColumnNumber() const = 0;
+		/// Return the column number where the current document event ends. 
+		/// This is one-based number of characters since the last line end.
+		/// 
+		/// Warning: The return value from the method is intended only as an approximation 
+		/// for the sake of diagnostics; it is not intended to provide sufficient information 
+		/// to edit the character content of the original XML document. For example, when lines 
+		/// contain combining character sequences, wide characters, surrogate pairs, or bi-directional 
+		/// text, the value may not correspond to the column in a text editor's display.
+		/// 
+		/// The return value is an approximation of the column number in the document entity or external 
+		/// parsed entity where the markup triggering the event appears.
+		/// 
+		/// If possible, the SAX driver should provide the line position of the first character after 
+		/// the text associated with the document event. The first column in each line is column 1.
+
+protected:
+	virtual ~Locator();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_Locator_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/LocatorImpl.h b/base/poco/XML/include/Poco/SAX/LocatorImpl.h
new file mode 100644
index 00000000000..2c924b3f889
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/LocatorImpl.h
@@ -0,0 +1,88 @@
+//
+// LocatorImpl.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// An implementation of the SAX Locator interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_LocatorImpl_INCLUDED
+#define SAX_LocatorImpl_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/SAX/Locator.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API LocatorImpl: public Locator
+	/// Provide an optional convenience implementation of Locator.
+{
+public:
+	LocatorImpl();
+		/// Zero-argument constructor.
+		/// 
+		/// This will not normally be useful, since the main purpose of this class is 
+		/// to make a snapshot of an existing Locator.
+		
+	LocatorImpl(const Locator& loc);
+		/// Copy constructor.
+		/// 
+		/// Create a persistent copy of the current state of a locator. When the original 
+		/// locator changes, this copy will still keep the original values (and it can be 
+		/// used outside the scope of DocumentHandler methods).
+
+	~LocatorImpl();
+		/// Destroys the Locator.
+		
+	LocatorImpl& operator = (const Locator& loc);
+		/// Assignment operator.
+
+	XMLString getPublicId() const;
+		/// Return the saved public identifier.
+		
+	XMLString getSystemId() const;
+		/// Return the saved system identifier.
+
+	int getLineNumber() const;
+		/// Return the saved line number (1-based).
+		
+	int getColumnNumber() const;
+		/// Return the saved column number (1-based).
+		
+	void setPublicId(const XMLString& publicId);
+		/// Set the public identifier for this locator.
+
+	void setSystemId(const XMLString& systemId);
+		/// Set the system identifier for this locator.
+
+	void setLineNumber(int lineNumber);
+		/// Set the line number for this locator (1-based).
+
+	void setColumnNumber(int columnNumber);
+		/// Set the column number for this locator (1-based).
+
+private:
+	XMLString _publicId;
+	XMLString _systemId;
+	int _lineNumber;
+	int _columnNumber;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_LocatorImpl_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/NamespaceSupport.h b/base/poco/XML/include/Poco/SAX/NamespaceSupport.h
new file mode 100644
index 00000000000..3c4244f0ac5
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/NamespaceSupport.h
@@ -0,0 +1,195 @@
+//
+// NamespaceSupport.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Namespace support for SAX2.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_NamespaceSupport_INCLUDED
+#define SAX_NamespaceSupport_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+#include <set>
+#include <map>
+#include <vector>
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API NamespaceSupport
+	/// Encapsulate Namespace logic for use by SAX drivers. 
+	/// This class encapsulates the logic of Namespace processing: 
+	/// it tracks the declarations currently in force for each context and
+	/// automatically processes qualified XML 1.0 names into their Namespace 
+	/// parts; it can also be used in reverse for generating
+	/// XML 1.0 from Namespaces.
+	/// Namespace support objects are reusable, but the reset method 
+	/// must be invoked between each session.
+{
+public:
+	using PrefixSet = std::set<XMLString>;
+
+	NamespaceSupport();
+		/// Creates a NamespaceSupport object.
+		
+	~NamespaceSupport();
+		/// Destroys a NamespaceSupport object.
+	
+	bool declarePrefix(const XMLString& prefix, const XMLString& namespaceURI);
+		/// Declare a Namespace prefix. All prefixes must be declared before they are
+		/// referenced. For example, a SAX driver (parser) would scan an element's attributes
+		/// in two passes: first for namespace declarations, then a second pass using
+		/// processName() to interpret prefixes against (potentially redefined) prefixes.
+		/// 
+		/// This method declares a prefix in the current Namespace context; the prefix
+		/// will remain in force until this context is popped, unless it is shadowed
+		/// in a descendant context.
+		/// 
+		/// To declare the default element Namespace, use the empty string as the prefix.
+		/// 
+		/// Note that you must not declare a prefix after you've pushed and popped another
+		/// Namespace context, or treated the declarations phase as complete by processing
+		/// a prefixed name.
+		///
+		/// Returns true if the prefix was legal, false otherwise.
+	
+	bool undeclarePrefix(const XMLString& prefix);
+		/// Remove the given namespace prefix.
+	
+	void getDeclaredPrefixes(PrefixSet& prefixes) const;
+		/// Return an enumeration of all prefixes declared in this context.
+		/// 
+		/// The empty (default) prefix will be included in this enumeration; note that
+		/// this behaviour differs from that of getPrefix() and getPrefixes().
+
+	const XMLString& getPrefix(const XMLString& namespaceURI) const;
+		/// Return one of the prefixes mapped to a Namespace URI.
+		/// 
+		/// If more than one prefix is currently mapped to the same URI, this method
+		/// will make an arbitrary selection; if you want all of the prefixes, use the
+		/// getPrefixes() method instead.
+
+	bool isMapped(const XMLString& namespaceURI) const;
+		/// Returns true if the given namespaceURI has been mapped to a prefix,
+		/// false otherwise.
+
+	void getPrefixes(PrefixSet& prefixes) const;
+		/// Return an enumeration of all prefixes whose declarations are active in the
+		/// current context. This includes declarations from parent contexts that have
+		/// not been overridden.
+		/// 
+		/// Note: if there is a default prefix, it will not be returned in this enumeration;
+		/// check for the default prefix using the getURI with an argument of "".
+
+	void getPrefixes(const XMLString& namespaceURI, PrefixSet& prefixes) const;
+		/// Return an enumeration of all prefixes for a given URI whose declarations
+		/// are active in the current context. This includes declarations from parent
+		/// contexts that have not been overridden.
+		/// 
+		/// This method returns prefixes mapped to a specific Namespace URI. The xml:
+		/// prefix will be included. If you want only one prefix that's mapped to the
+		/// Namespace URI, and you don't care which one you get, use the getPrefix() method
+		/// instead.
+		/// 
+		/// Note: the empty (default) prefix is never included in this enumeration;
+		/// to check for the presence of a default Namespace, use the getURI() method
+		/// with an argument of "".
+
+	const XMLString& getURI(const XMLString& prefix) const;
+		/// Look up a prefix and get the currently-mapped Namespace URI.
+		/// 
+		/// This method looks up the prefix in the current context. Use the empty string
+		/// ("") for the default Namespace.
+
+	void pushContext();
+		/// Start a new Namespace context. The new context will automatically inherit
+		/// the declarations of its parent context, but it will also keep track of which
+		/// declarations were made within this context.
+		/// 
+		/// Event callback code should start a new context once per element. This means
+		/// being ready to call this in either of two places. For elements that don't
+		/// include namespace declarations, the ContentHandler::startElement() callback
+		/// is the right place. For elements with such a declaration, it'd done in the
+		/// first ContentHandler::startPrefixMapping() callback. A boolean flag can be
+		/// used to track whether a context has been started yet. When either of those
+		/// methods is called, it checks the flag to see if a new context needs to be
+		/// started. If so, it starts the context and sets the flag. After 
+		/// ContentHandler::startElement() does that, it always clears the flag.
+		/// 
+		/// Normally, SAX drivers would push a new context at the beginning of each
+		/// XML element. Then they perform a first pass over the attributes to process
+		/// all namespace declarations, making ContentHandler::startPrefixMapping() callbacks.
+		/// Then a second pass is made, to determine the namespace-qualified names for
+		/// all attributes and for the element name. Finally all the information for
+		/// the ContentHandler::startElement() callback is available, so it can then
+		/// be made.
+		/// 
+		/// The Namespace support object always starts with a base context already in
+		/// force: in this context, only the "xml" prefix is declared.
+
+	void popContext();
+		/// Revert to the previous Namespace context.
+		/// 
+		/// Normally, you should pop the context at the end of each XML element. After
+		/// popping the context, all Namespace prefix mappings that were previously
+		/// in force are restored.
+		/// 
+		/// You must not attempt to declare additional Namespace prefixes after popping
+		/// a context, unless you push another context first.
+
+	bool processName(const XMLString& qname, XMLString& namespaceURI, XMLString& localName, bool isAttribute) const;
+		/// Process a raw XML 1.0 name. 
+		/// This method processes a raw XML 1.0 name in the current context 
+		/// by removing the prefix and looking it up among the
+		/// prefixes currently declared. The result will be returned in
+		/// namespaceURI and localName.
+		/// If the raw name has a prefix that has not been declared, then the return
+		/// value will be false, otherwise true.
+		///
+		/// Note that attribute names are processed differently than element names: 
+		/// an unprefixed element name will receive the
+		/// default Namespace (if any), while an unprefixed attribute name will not.
+
+	void reset();
+		/// Reset this Namespace support object for reuse.
+		/// 
+		/// It is necessary to invoke this method before reusing the Namespace support
+		/// object for a new session. If namespace declaration URIs are to be supported,
+		/// that flag must also be set to a non-default value.
+		/// Reset this Namespace support object for reuse.
+
+	static const XMLString XML_NAMESPACE;
+	static const XMLString XML_NAMESPACE_PREFIX;
+	static const XMLString XMLNS_NAMESPACE;
+	static const XMLString XMLNS_NAMESPACE_PREFIX;
+
+private:
+	NamespaceSupport(const NamespaceSupport&);
+	NamespaceSupport& operator = (const NamespaceSupport&);
+
+	typedef std::map<XMLString, XMLString> Context;
+	typedef std::vector<Context> ContextVec;
+	
+	ContextVec _contexts;
+
+	static const XMLString EMPTY_STRING;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_NamespaceSupport_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/SAXException.h b/base/poco/XML/include/Poco/SAX/SAXException.h
new file mode 100644
index 00000000000..e1f9cae8e4a
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/SAXException.h
@@ -0,0 +1,176 @@
+//
+// SAXException.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// SAX exception classes.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_SAXException_INCLUDED
+#define SAX_SAXException_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLException.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+POCO_DECLARE_EXCEPTION(XML_API, SAXException, XMLException)
+	/// The base class for all SAX-related exceptions like SAXParseException,
+	/// SAXNotRecognizedException or SAXNotSupportedException.
+	/// 
+	/// This class can contain basic error or warning information from either the XML parser 
+	/// or the application: a parser writer or application writer can subclass it to provide 
+	/// additional functionality. SAX handlers may throw this exception or any exception subclassed 
+	/// from it.
+	/// 
+	/// If the application needs to pass through other types of exceptions, it must wrap those exceptions 
+	/// in a SAXException or an exception derived from a SAXException.
+	/// 
+	/// If the parser or application needs to include information about a specific location in an XML 
+	/// document, it should use the SAXParseException subclass.
+
+
+POCO_DECLARE_EXCEPTION(XML_API, SAXNotRecognizedException, SAXException)
+	/// Exception class for an unrecognized identifier.
+	/// 
+	/// An XMLReader will throw this exception when it finds an unrecognized feature or property 
+	/// identifier; SAX applications and extensions may use this class for other, similar purposes.
+
+
+POCO_DECLARE_EXCEPTION(XML_API, SAXNotSupportedException, SAXException)
+	/// Exception class for an unsupported operation.
+	/// 
+	/// An XMLReader will throw this exception when it recognizes a feature or property identifier, 
+	/// but cannot perform the requested operation (setting a state or value). Other SAX2 applications 
+	/// and extensions may use this class for similar purposes.
+
+
+class Locator;
+
+
+class XML_API SAXParseException: public SAXException
+	/// Encapsulate an XML parse error or warning.
+	///
+	/// This exception may include information for locating the error in the original XML document, 
+	/// as if it came from a Locator object. Note that although the application will receive a 
+	/// SAXParseException as the argument to the handlers in the ErrorHandler interface, the application 
+	/// is not actually required to throw the exception; instead, it can simply read the information in it 
+	/// and take a different action.
+	/// 
+	/// Since this exception is a subclass of SAXException, it inherits the ability to wrap another exception.
+{
+public:	
+	SAXParseException(const std::string& msg, const Locator& loc);
+		/// Create a new SAXParseException from a message and a Locator.
+
+	SAXParseException(const std::string& msg, const Locator& loc, const Poco::Exception& exc);
+		/// Wrap an existing exception in a SAXParseException.
+
+	SAXParseException(const std::string& msg, const XMLString& publicId, const XMLString& systemId, int lineNumber, int columnNumber);
+		/// Create a new SAXParseException with an embedded exception.
+		/// 
+		/// This constructor is most useful for parser writers.
+		/// All parameters except the message are as if they were provided by a Locator. 
+		/// For example, if the system identifier is a URL (including relative filename), 
+		/// the caller must resolve it fully before creating the exception.
+
+	SAXParseException(const std::string& msg, const XMLString& publicId, const XMLString& systemId, int lineNumber, int columnNumber, const Poco::Exception& exc);
+		/// Create a new SAXParseException.
+		/// 
+		/// This constructor is most useful for parser writers.
+		/// All parameters except the message are as if they were provided by a Locator. 
+		/// For example, if the system identifier is a URL (including relative filename), 
+		/// the caller must resolve it fully before creating the exception.
+
+	SAXParseException(const SAXParseException& exc);
+		/// Creates a new SAXParseException from another one.
+
+	~SAXParseException() noexcept;
+		/// Destroy the exception.
+
+	SAXParseException& operator = (const SAXParseException& exc);
+		/// Assignment operator.
+		
+	const char* name() const noexcept;
+		/// Returns a static string describing the exception.
+
+	const char* className() const noexcept;
+		/// Returns the name of the exception class.
+
+	Poco::Exception* clone() const;
+		/// Creates an exact copy of the exception.
+		
+	void rethrow() const;
+		/// (Re)Throws the exception.
+
+	const XMLString& getPublicId() const;
+		/// Get the public identifier of the entity where the exception occurred.
+		
+	const XMLString& getSystemId() const;
+		/// Get the system identifier of the entity where the exception occurred.
+		
+	int getLineNumber() const;
+		/// The line number of the end of the text where the exception occurred.
+		/// The first line is line 1.
+		
+	int getColumnNumber() const;
+		/// The column number of the end of the text where the exception occurred.
+		/// The first column in a line is position 1.
+
+protected:
+	static std::string buildMessage(const std::string& msg, const XMLString& publicId, const XMLString& systemId, int lineNumber, int columnNumber);
+	
+private:
+	SAXParseException();
+
+	XMLString _publicId;
+	XMLString _systemId;
+	int       _lineNumber;
+	int       _columnNumber;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& SAXParseException::getPublicId() const
+{
+	return _publicId;
+}
+
+
+inline const XMLString& SAXParseException::getSystemId() const
+{
+	return _systemId;
+}
+
+
+inline int SAXParseException::getLineNumber() const
+{
+	return _lineNumber;
+}
+
+
+inline int SAXParseException::getColumnNumber() const
+{
+	return _columnNumber;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_SAXException_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/SAXParser.h b/base/poco/XML/include/Poco/SAX/SAXParser.h
new file mode 100644
index 00000000000..2fefc67021a
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/SAXParser.h
@@ -0,0 +1,113 @@
+//
+// SAXParser.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Implementation of the XMLReader interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_SAXParser_INCLUDED
+#define SAX_SAXParser_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/SAX/XMLReader.h"
+#include "Poco/XML/ParserEngine.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API SAXParser: public XMLReader
+	/// This class provides a SAX2 (Simple API for XML) interface to expat,
+	/// the XML parser toolkit.
+	/// The following SAX2 features and properties are supported:
+	///   * http://xml.org/sax/features/external-general-entities
+	///   * http://xml.org/sax/features/external-parameter-entities
+	///   * http://xml.org/sax/features/namespaces
+	///   * http://xml.org/sax/features/namespace-prefixes
+	///   * http://xml.org/sax/properties/lexical-handler
+	///   * http://xml.org/sax/properties/declaration-handler
+	///
+	/// The following proprietary extensions are supported:
+	///   * http://www.appinf.com/features/enable-partial-reads --
+	///     see ParserEngine::setEnablePartialReads()
+	///   * http://www.appinf.com/properties/bla-maximum-amplification
+	///     see ParserEngine::setBillionLaughsAttackProtectionMaximumAmplification();
+	///     argument must be a float >= 1.0 formatted as string;
+	///     property is set-only.
+	///   * http://www.appinf.com/properties/bla-activation-threshold
+	///     see ParserEngine::setBillionLaughsAttackProtectionActivationThreshold();
+	///     argument must be a 64-bit unsigned integer formatted as string;
+	///     property is set-only.
+{
+public:
+	SAXParser();
+		/// Creates an SAXParser.
+
+	SAXParser(const XMLString& encoding);
+		/// Creates an SAXParser with the given encoding.
+
+	~SAXParser();
+		/// Destroys the SAXParser.
+
+	void setEncoding(const XMLString& encoding);
+		/// Sets the encoding used by the parser if no
+		/// encoding is specified in the XML document.
+
+	const XMLString& getEncoding() const;
+		/// Returns the name of the encoding used by
+		/// the parser if no encoding is specified in
+		/// the XML document.
+
+	void addEncoding(const XMLString& name, Poco::TextEncoding* pEncoding);
+		/// Adds an encoding to the parser. Does not take ownership of the pointer!
+
+	/// XMLReader
+	void setEntityResolver(EntityResolver* pResolver);
+	EntityResolver* getEntityResolver() const;
+	void setDTDHandler(DTDHandler* pDTDHandler);
+	DTDHandler* getDTDHandler() const;
+	void setContentHandler(ContentHandler* pContentHandler);
+	ContentHandler* getContentHandler() const;
+	void setErrorHandler(ErrorHandler* pErrorHandler);
+	ErrorHandler* getErrorHandler() const;
+	void setFeature(const XMLString& featureId, bool state);
+	bool getFeature(const XMLString& featureId) const;
+	void setProperty(const XMLString& propertyId, const XMLString& value);
+	void setProperty(const XMLString& propertyId, void* value);
+	void* getProperty(const XMLString& propertyId) const;
+	void parse(InputSource* pSource);
+	void parse(const XMLString& systemId);
+	void parseMemoryNP(const char* xml, std::size_t size);
+
+	/// Extensions
+	void parseString(const std::string& xml);
+
+	static const XMLString FEATURE_PARTIAL_READS;
+	static const XMLString PROPERTY_BLA_MAXIMUM_AMPLIFICATION;
+	static const XMLString PROPERTY_BLA_ACTIVATION_THRESHOLD;
+
+protected:
+	void setupParse();
+
+private:
+	ParserEngine _engine;
+	bool _namespaces;
+	bool _namespacePrefixes;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_SAXParser_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/WhitespaceFilter.h b/base/poco/XML/include/Poco/SAX/WhitespaceFilter.h
new file mode 100644
index 00000000000..f4f08bc0f36
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/WhitespaceFilter.h
@@ -0,0 +1,81 @@
+//
+// WhitespaceFilter.h
+//
+// Library: XML
+// Package: SAX
+// Module:  WhitespaceFilter
+//
+// Definition of the WhitespaceFilter class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_WhitespaceFilter_INCLUDED
+#define SAX_WhitespaceFilter_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/SAX/XMLFilterImpl.h"
+#include "Poco/SAX/LexicalHandler.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API WhitespaceFilter: public XMLFilterImpl, public LexicalHandler
+	/// This implementation of the SAX2 XMLFilter interface
+	/// filters all whitespace-only character data element
+	/// content.
+{
+public:
+	WhitespaceFilter();
+		/// Creates the WhitespaceFilter, with no parent.
+		
+	WhitespaceFilter(XMLReader* pReader);
+		/// Creates the WhitespaceFilter with the specified parent.
+
+	~WhitespaceFilter();
+		/// Destroys the WhitespaceFilter.
+
+	// XMLReader
+	void setProperty(const XMLString& propertyId, const XMLString& value);
+	void setProperty(const XMLString& propertyId, void* value);
+	void* getProperty(const XMLString& propertyId) const;
+
+	// ContentHandler
+	void startDocument();
+	void endDocument();
+	void startElement(const XMLString& uri, const XMLString& localName, const XMLString& qname, const Attributes& attrList);
+	void endElement(const XMLString& uri, const XMLString& localName, const XMLString& qname);
+	void characters(const XMLChar ch[], int start, int length);
+	void ignorableWhitespace(const XMLChar ch[], int start, int length);
+	void processingInstruction(const XMLString& target, const XMLString& data);
+
+	// LexicalHandler
+	void startDTD(const XMLString& name, const XMLString& publicId, const XMLString& systemId);
+	void endDTD();
+	void startEntity(const XMLString& name);
+	void endEntity(const XMLString& name);
+	void startCDATA();
+	void endCDATA();
+	void comment(const XMLChar ch[], int start, int length);
+
+protected:
+	void setupParse();
+
+private:
+	LexicalHandler* _pLexicalHandler;
+	XMLString       _data;
+	bool            _filter;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_WhitespaceFilter_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/XMLFilter.h b/base/poco/XML/include/Poco/SAX/XMLFilter.h
new file mode 100644
index 00000000000..0bc2e965e94
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/XMLFilter.h
@@ -0,0 +1,61 @@
+//
+// XMLFilter.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAXFilters
+//
+// SAX2 XMLFilter Interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_XMLFilter_INCLUDED
+#define SAX_XMLFilter_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/SAX/XMLReader.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API XMLFilter: public XMLReader
+	/// Interface for an XML filter.
+	///
+	/// An XML filter is like an XML reader, except that it obtains its events from another XML reader 
+	/// rather than a primary source like an XML document or database. Filters can modify a stream of 
+	/// events as they pass on to the final application.
+	/// 
+	/// The XMLFilterImpl helper class provides a convenient base for creating SAX2 filters, by passing on 
+	/// all EntityResolver, DTDHandler, ContentHandler and ErrorHandler events automatically.
+{
+public:
+	virtual XMLReader* getParent() const = 0;
+		/// Set the parent reader.
+		/// 
+		/// This method allows the application to link the filter to a parent reader (which may be another 
+		/// filter). The argument may not be null.
+		
+	virtual void setParent(XMLReader* pParent) = 0;
+		/// Get the parent reader.
+		/// 
+		/// This method allows the application to query the parent reader (which may be another filter). 
+		/// It is generally a bad idea to perform any operations on the parent reader directly: they should 
+		/// all pass through this filter.
+	
+protected:
+	virtual ~XMLFilter();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_XMLFilter_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/XMLFilterImpl.h b/base/poco/XML/include/Poco/SAX/XMLFilterImpl.h
new file mode 100644
index 00000000000..33c049c7b27
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/XMLFilterImpl.h
@@ -0,0 +1,132 @@
+//
+// XMLFilterImpl.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAXFilters
+//
+// SAX2 XMLFilterImpl class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_XMLFilterImpl_INCLUDED
+#define SAX_XMLFilterImpl_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/SAX/XMLFilter.h"
+#include "Poco/SAX/EntityResolver.h"
+#include "Poco/SAX/DTDHandler.h"
+#include "Poco/SAX/ContentHandler.h"
+#include "Poco/SAX/ErrorHandler.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API XMLFilterImpl: public XMLFilter, public EntityResolver, public DTDHandler, public ContentHandler, public ErrorHandler
+	/// Base class for deriving an XML filter.
+	///
+	/// This class is designed to sit between an XMLReader and the client application's event 
+	/// handlers. By default, it does nothing but pass requests up to the reader and events on to 
+	/// the handlers unmodified, but subclasses can override specific methods to modify the event 
+	/// stream or the configuration requests as they pass through.
+{
+public:
+	XMLFilterImpl();
+		/// Construct an empty XML filter, with no parent.
+		///
+		/// This filter will have no parent: you must assign a parent before you start a parse or do any 
+		/// configuration with setFeature or setProperty, unless you use this as a pure event consumer rather 
+		/// than as an XMLReader.
+		
+	XMLFilterImpl(XMLReader* pParent);
+		/// Construct an XML filter with the specified parent.
+		
+	~XMLFilterImpl();
+		/// Destroys the XMLFilterImpl.
+	
+	// XMLFilter
+	XMLReader* getParent() const;
+	void setParent(XMLReader* pParent);
+
+	// XMLReader
+	void setEntityResolver(EntityResolver* pResolver);
+	EntityResolver* getEntityResolver() const;
+	void setDTDHandler(DTDHandler* pDTDHandler);
+	DTDHandler* getDTDHandler() const;
+	void setContentHandler(ContentHandler* pContentHandler);
+	ContentHandler* getContentHandler() const;
+	void setErrorHandler(ErrorHandler* pErrorHandler);
+	ErrorHandler* getErrorHandler() const;
+	void setFeature(const XMLString& featureId, bool state);
+	bool getFeature(const XMLString& featureId) const;
+	void setProperty(const XMLString& propertyId, const XMLString& value);
+	void setProperty(const XMLString& propertyId, void* value);
+	void* getProperty(const XMLString& propertyId) const;
+	void parse(InputSource* pSource);
+	void parse(const XMLString& systemId);
+	void parseMemoryNP(const char* xml, std::size_t size);
+
+	// EntityResolver
+	InputSource* resolveEntity(const XMLString* publicId, const XMLString& systemId);
+	void releaseInputSource(InputSource* pSource);
+	
+	// DTDHandler
+	void notationDecl(const XMLString& name, const XMLString* publicId, const XMLString* systemId);
+	void unparsedEntityDecl(const XMLString& name, const XMLString* publicId, const XMLString& systemId, const XMLString& notationName);
+
+	// ContentHandler
+	void setDocumentLocator(const Locator* loc);
+	void startDocument();
+	void endDocument();
+	void startElement(const XMLString& uri, const XMLString& localName, const XMLString& qname, const Attributes& attrList);
+	void endElement(const XMLString& uri, const XMLString& localName, const XMLString& qname);
+	void characters(const XMLChar ch[], int start, int length);
+	void ignorableWhitespace(const XMLChar ch[], int start, int length);
+	void processingInstruction(const XMLString& target, const XMLString& data);
+	void startPrefixMapping(const XMLString& prefix, const XMLString& uri);
+	void endPrefixMapping(const XMLString& prefix);
+	void skippedEntity(const XMLString& prefix);
+	void warning(const SAXException& e);
+	void error(const SAXException& e);
+	void fatalError(const SAXException& e);
+
+protected:
+	XMLReader* parent() const;
+		/// Return a pointer to the parent reader.
+		/// Subclasses can use this method instead of
+		/// getParent() for better performance - this method
+		/// is non-virtual and implemented as inline.
+	
+	virtual void setupParse();
+		/// Setup the event handlers in the parent reader.
+	
+private:
+	XMLReader*      _pParent;
+	EntityResolver* _pEntityResolver;
+	DTDHandler*     _pDTDHandler;
+	ContentHandler* _pContentHandler;
+	ErrorHandler*   _pErrorHandler;
+};
+
+
+//
+// inlines
+//
+inline XMLReader* XMLFilterImpl::parent() const
+{
+	return _pParent;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_XMLFilterImpl_INCLUDED
diff --git a/base/poco/XML/include/Poco/SAX/XMLReader.h b/base/poco/XML/include/Poco/SAX/XMLReader.h
new file mode 100644
index 00000000000..0b1d3603233
--- /dev/null
+++ b/base/poco/XML/include/Poco/SAX/XMLReader.h
@@ -0,0 +1,205 @@
+//
+// XMLReader.h
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// SAX2 XMLReader Interface.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef SAX_XMLReader_INCLUDED
+#define SAX_XMLReader_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class EntityResolver;
+class DTDHandler;
+class ContentHandler;
+class ErrorHandler;
+class InputSource;
+class LexicalHandler;
+class NamespaceHandler;
+
+
+class XML_API XMLReader
+	/// Interface for reading an XML document using callbacks. 
+	/// XMLReader is the interface that an XML parser's SAX2 driver must 
+	/// implement. This interface allows an application to set and
+	/// query features and properties in the parser, to register event handlers 
+	/// for document processing, and to initiate a document parse.
+	/// All SAX interfaces are assumed to be synchronous: the parse methods must not 
+	/// return until parsing is complete, and readers
+	/// must wait for an event-handler callback to return before reporting the next event.
+{
+public:
+	virtual void setEntityResolver(EntityResolver* pResolver) = 0;
+		/// Allow an application to register an entity resolver.
+		///
+		/// If the application does not register an entity resolver, the 
+		/// XMLReader will perform its own default resolution.
+		/// 
+		/// Applications may register a new or different resolver in the middle of a 
+		/// parse, and the SAX parser must begin using the new resolver immediately.
+
+	virtual EntityResolver* getEntityResolver() const = 0;
+		/// Return the current entity resolver.
+
+	virtual void setDTDHandler(DTDHandler* pDTDHandler) = 0;
+		/// Allow an application to register a DTD event handler.
+		///
+		/// If the application does not register a DTD handler, all DTD events reported by 
+		/// the SAX parser will be silently ignored.
+		/// 
+		/// Applications may register a new or different handler in the middle of a parse, 
+		/// and the SAX parser must begin using the new handler immediately.
+
+	virtual DTDHandler* getDTDHandler() const = 0;
+		/// Return the current DTD handler.
+
+	virtual void setContentHandler(ContentHandler* pContentHandler) = 0;
+		/// Allow an application to register a content event handler.
+		/// 
+		/// If the application does not register a content handler, all content events 
+		/// reported by the SAX parser will be silently ignored.
+		/// 
+		/// Applications may register a new or different handler in the middle of a parse, 
+		/// and the SAX parser must begin using the new handler immediately.
+
+	virtual ContentHandler* getContentHandler() const = 0;
+		/// Return the current content handler.
+
+	virtual void setErrorHandler(ErrorHandler* pErrorHandler) = 0;
+		/// Allow an application to register an error event handler.
+		///
+		/// If the application does not register an error handler, all error events reported by 
+		/// the SAX parser will be silently ignored; however, normal processing may not continue. 
+		/// It is highly recommended that all SAX applications implement an error handler to avoid 
+		/// unexpected bugs.
+		/// 
+		/// Applications may register a new or different handler in the middle of a parse, and the 
+		/// SAX parser must begin using the new handler immediately.
+
+	virtual ErrorHandler* getErrorHandler() const = 0;
+		/// Return the current error handler.
+	
+	virtual void setFeature(const XMLString& featureId, bool state) = 0;
+		/// Set the state of a feature.
+		///
+		/// The feature name is any fully-qualified URI. It is possible for an XMLReader to 
+		/// expose a feature value but to be unable to change the current value. Some feature 
+		/// values may be immutable or mutable only in specific contexts, such as before, during, 
+		/// or after a parse.
+		/// 
+		/// All XMLReaders are required to support setting http://xml.org/sax/features/namespaces 
+		/// to true and http://xml.org/sax/features/namespace-prefixes to false.
+
+	virtual bool getFeature(const XMLString& featureId) const = 0;
+		/// Look up the value of a feature.
+		///
+		/// The feature name is any fully-qualified URI. It is possible for an XMLReader 
+		/// to recognize a feature name but temporarily be unable to return its value. 
+		/// Some feature values may be available only in specific contexts, such as before, 
+		/// during, or after a parse. Also, some feature values may not be programmatically 
+		/// accessible. (In the case of an adapter for SAX1 Parser, there is no 
+		/// implementation-independent way to expose whether the underlying parser is performing 
+		/// validation, expanding external entities, and so forth.)
+		/// 
+		/// All XMLReaders are required to recognize the 
+		/// http://xml.org/sax/features/namespaces and the 
+		/// http://xml.org/sax/features/namespace-prefixes feature names.
+		/// Implementors are free (and encouraged) to invent their own features, 
+		/// using names built on their own URIs.
+		
+	virtual void setProperty(const XMLString& propertyId, const XMLString& value) = 0;
+		/// Set the value of a property.
+		/// 
+		/// The property name is any fully-qualified URI. It is possible for an XMLReader 
+		/// to recognize a property name but to be unable to change the current value. 
+		/// Some property values may be immutable or mutable only in specific contexts, 
+		/// such as before, during, or after a parse.
+		/// 
+		/// XMLReaders are not required to recognize setting any specific property names, though a 
+		/// core set is defined by SAX2.
+		/// 
+		/// This method is also the standard mechanism for setting extended handlers.
+
+	virtual void setProperty(const XMLString& propertyId, void* value) = 0;
+		/// Set the value of a property.
+		/// See also setProperty(const XMLString&, const XMLString&).
+
+	virtual void* getProperty(const XMLString& propertyId) const = 0;
+		/// Look up the value of a property.
+		/// String values are returned as XMLChar*
+		/// The property name is any fully-qualified URI. It is possible for an XMLReader to 
+		/// recognize a property name but temporarily be unable to return its value. Some property 
+		/// values may be available only in specific contexts, such as before, during, or after a parse.
+		///
+		/// XMLReaders are not required to recognize any specific property names, though an initial 
+		/// core set is documented for SAX2.
+		/// 
+		/// Implementors are free (and encouraged) to invent their own properties, using names 
+		/// built on their own URIs.
+
+	virtual void parse(InputSource* pSource) = 0;
+		/// Parse an XML document.
+		/// 
+		/// The application can use this method to instruct the XML reader to begin parsing an 
+		/// XML document from any valid input source (a character stream, a byte stream, or a URI).
+		/// 
+		/// Applications may not invoke this method while a parse is in progress (they should create 
+		/// a new XMLReader instead for each nested XML document). Once a parse is complete, an 
+		/// application may reuse the same XMLReader object, possibly with a different input source. 
+		/// Configuration of the XMLReader object (such as handler bindings and values established for 
+		/// feature flags and properties) is unchanged by completion of a parse, unless the definition of that 
+		/// aspect of the configuration explicitly specifies other behavior. (For example, feature flags or 
+		/// properties exposing characteristics of the document being parsed.)
+		/// 
+		/// During the parse, the XMLReader will provide information about the XML document through the registered 
+		/// event handlers.
+		///
+		/// This method is synchronous: it will not return until parsing has ended. If a client application 
+		/// wants to terminate parsing early, it should throw an exception.
+
+	virtual void parse(const XMLString& systemId) = 0;
+		/// Parse an XML document from a system identifier.
+		/// See also parse(InputSource*).
+		
+	virtual void parseMemoryNP(const char* xml, std::size_t size) = 0;
+		/// Parse an XML document from memory.
+		/// See also parse(InputSource*).
+
+	// SAX Features
+	static const XMLString FEATURE_VALIDATION;
+	static const XMLString FEATURE_NAMESPACES;
+	static const XMLString FEATURE_NAMESPACE_PREFIXES;
+	static const XMLString FEATURE_EXTERNAL_GENERAL_ENTITIES;
+	static const XMLString FEATURE_EXTERNAL_PARAMETER_ENTITIES;
+	static const XMLString FEATURE_STRING_INTERNING;
+	
+	// SAX Properties
+	static const XMLString PROPERTY_DECLARATION_HANDLER;
+	static const XMLString PROPERTY_LEXICAL_HANDLER;
+
+protected:
+	virtual ~XMLReader();
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // SAX_XMLReader_INCLUDED
diff --git a/base/poco/XML/include/Poco/XML/Content.h b/base/poco/XML/include/Poco/XML/Content.h
new file mode 100644
index 00000000000..8b2b312344f
--- /dev/null
+++ b/base/poco/XML/include/Poco/XML/Content.h
@@ -0,0 +1,63 @@
+//
+// Content.h
+//
+// Library: XML
+// Package: XML
+// Module:  Content
+//
+// Definition of the Content enum.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Based on libstudxml (http://www.codesynthesis.com/projects/libstudxml/).
+// Copyright (c) 2009-2013 Code Synthesis Tools CC.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef XML_Content_INCLUDED
+#define XML_Content_INCLUDED
+
+
+namespace Poco {
+namespace XML {
+
+
+struct Content
+	/// XML content model. C++11 enum class emulated for C++98.
+	///
+	///               element   characters  whitespaces  notes
+	///     Empty     no          no        ignored
+	///     Simple    no          yes       preserved    content accumulated
+	///     Complex   yes         no        ignored
+	///     Mixed     yes         yes       preserved
+{
+	enum value
+	{
+		Empty,
+		Simple,
+		Complex,
+		Mixed
+	};
+
+	Content(value v)
+		: _v(v)
+	{
+	}
+
+	operator value() const
+	{
+		return _v;
+	}
+
+private:
+	value _v;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // XML_Content_INCLUDED
diff --git a/base/poco/XML/include/Poco/XML/Name.h b/base/poco/XML/include/Poco/XML/Name.h
new file mode 100644
index 00000000000..beedea2fa48
--- /dev/null
+++ b/base/poco/XML/include/Poco/XML/Name.h
@@ -0,0 +1,144 @@
+//
+// Name.h
+//
+// Library: XML
+// Package: XML
+// Module:  Name
+//
+// Definition of the Name class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef XML_Name_INCLUDED
+#define XML_Name_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API Name
+	/// An XML element or attribute name, consisting of a
+	/// qualified name, a namespace URI and a local name.
+{
+public:
+	Name();
+		/// Creates an empty Name.
+		
+	Name(const XMLString& qname);
+		/// Creates a Name from a qualified name only.
+
+	Name(const XMLString& qname, const XMLString& namespaceURI);
+		/// Creates a Name from a qualified name and a namespace URI.
+		/// The local name is extracted from the qualified name.
+		
+	Name(const XMLString& qname, const XMLString& namespaceURI, const XMLString& localName);
+		/// Creates a Name from a qualified name, a namespace URI and a local name.
+		
+	Name(const Name& name);
+		/// Copy constructor.
+
+	Name(Name&& name) noexcept;
+		/// Move constructor.
+		
+	~Name();
+		/// Destroys the name.
+		
+	Name& operator = (const Name& name);
+		/// Assignment operator.
+
+	Name& operator = (Name&& name) noexcept;
+		/// Move assignment.
+		
+	void swap(Name& name);
+		/// Swaps the name with another one.	
+		
+	void assign(const XMLString& qname);
+		/// Assigns a new value to the name.
+
+	void assign(const XMLString& qname, const XMLString& namespaceURI);
+		/// Assigns new values to the name.
+		/// The local name is extracted from the qualified name.
+
+	void assign(const XMLString& qname, const XMLString& namespaceURI, const XMLString& localName);
+		/// Assigns new values to the name.
+	
+	bool equals(const Name& name) const;
+		/// Returns true if both names are equal.
+		
+	bool equals(const XMLString& qname, const XMLString& namespaceURI, const XMLString& localName) const;
+		/// Returns true if all the name's components are equal to the given ones.
+
+	bool equalsWeakly(const XMLString& qname, const XMLString& namespaceURI, const XMLString& localName) const;
+		/// Returns true if either the qnames are identical or the namespaceURIs and the localNames are identical.
+	
+	const XMLString& qname() const;
+		/// Returns the qualified name.
+		
+	const XMLString& namespaceURI() const;
+		/// Returns the namespace URI.
+		
+	const XMLString& localName() const;
+		/// Returns the local name.
+		
+	XMLString prefix() const;
+		/// Returns the namespace prefix.
+		
+	static void split(const XMLString& qname, XMLString& prefix, XMLString& localName);
+		/// Splits the given qualified name into its prefix and localName parts.
+	
+	static XMLString localName(const XMLString& qname);
+		/// Returns the local name part of the given qualified name.
+
+	static XMLString prefix(const XMLString& qname);
+		/// Returns the prefix part of the given qualified name.
+
+	static const XMLString EMPTY_NAME;
+
+private:
+	XMLString _qname;
+	XMLString _namespaceURI;
+	XMLString _localName;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& Name::qname() const
+{
+	return _qname;
+}
+
+
+inline const XMLString& Name::namespaceURI() const
+{
+	return _namespaceURI;
+}
+
+
+inline const XMLString& Name::localName() const
+{
+	return _localName;
+}
+
+
+inline void swap(Name& n1, Name& n2)
+{
+	n1.swap(n2);
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // XML_Name_INCLUDED
diff --git a/base/poco/XML/include/Poco/XML/NamePool.h b/base/poco/XML/include/Poco/XML/NamePool.h
new file mode 100644
index 00000000000..9ffadf1af95
--- /dev/null
+++ b/base/poco/XML/include/Poco/XML/NamePool.h
@@ -0,0 +1,83 @@
+//
+// NamePool.h
+//
+// Library: XML
+// Package: XML
+// Module:  NamePool
+//
+// Definition of the NamePool class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef XML_NamePool_INCLUDED
+#define XML_NamePool_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+#include "Poco/XML/Name.h"
+
+
+#ifndef POCO_XML_NAMEPOOL_DEFAULT_SIZE
+#define POCO_XML_NAMEPOOL_DEFAULT_SIZE 509
+#endif
+
+
+namespace Poco {
+namespace XML {
+
+
+class NamePoolItem;
+
+
+class XML_API NamePool
+	/// A hashtable that stores XML names consisting of an URI, a
+	/// local name and a qualified name.
+{
+public:
+	NamePool(unsigned long size = POCO_XML_NAMEPOOL_DEFAULT_SIZE);
+		/// Creates a name pool with room for up to size strings.
+		///
+		/// The given size should be a suitable prime number, 
+		/// e.g. 251, 509, 1021 or 4093.
+	
+	const Name& insert(const XMLString& qname, const XMLString& namespaceURI, const XMLString& localName);	
+		/// Returns a const reference to an Name for the given names.
+		/// Creates the Name if it does not already exist.
+		/// Throws a PoolOverflowException if the name pool is full.
+
+	const Name& insert(const Name& name);	
+		/// Returns a const reference to an Name for the given name.
+		/// Creates the Name if it does not already exist.
+		/// Throws a PoolOverflowException if the name pool is full.
+
+	void duplicate();
+		/// Increments the reference count.
+
+	void release();
+		/// Decrements the reference count and deletes the object if the reference count reaches zero.
+
+protected:
+	unsigned long hash(const XMLString& qname, const XMLString& namespaceURI, const XMLString& localName);
+	~NamePool();
+
+private:
+	NamePool(const NamePool&);
+	NamePool& operator = (const NamePool&);
+
+	NamePoolItem* _pItems;
+	unsigned long _size;
+	unsigned long _salt;
+	int           _rc;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // XML_NamePool_INCLUDED
diff --git a/base/poco/XML/include/Poco/XML/NamespaceStrategy.h b/base/poco/XML/include/Poco/XML/NamespaceStrategy.h
new file mode 100644
index 00000000000..1f27e3c23bc
--- /dev/null
+++ b/base/poco/XML/include/Poco/XML/NamespaceStrategy.h
@@ -0,0 +1,115 @@
+//
+// NamespaceStrategy.h
+//
+// Library: XML
+// Package: XML
+// Module:  NamespaceStrategy
+//
+// Definition of the NamespaceStrategy class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef XML_NamespaceStrategy_INCLUDED
+#define XML_NamespaceStrategy_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/XML/XMLString.h"
+#include "Poco/SAX/NamespaceSupport.h"
+#include "Poco/SAX/AttributesImpl.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class ContentHandler;
+
+
+class XML_API NamespaceStrategy
+	/// This class is used by ParserEngine to handle the
+	/// startElement, endElement, startPrefixMapping and
+	/// endPrefixMapping events.
+{
+public:
+	virtual ~NamespaceStrategy();
+
+	virtual void startElement(const XMLChar* name, const XMLChar** atts, int specifiedCount, ContentHandler* pContentHandler) = 0;
+		/// Translate the arguments as delivered by Expat and
+		/// call the startElement() method of the ContentHandler.
+		
+	virtual void endElement(const XMLChar* name, ContentHandler* pContentHandler) = 0;
+		/// Translate the arguments as delivered by Expat and
+		/// call the endElement() method of the ContentHandler.
+
+protected:
+	static void splitName(const XMLChar* qname, XMLString& uri, XMLString& localName);
+	static void splitName(const XMLChar* qname, XMLString& uri, XMLString& localName, XMLString& prefix);
+
+	static const XMLString NOTHING;
+};
+
+
+class XML_API NoNamespacesStrategy: public NamespaceStrategy
+	/// The NamespaceStrategy implementation used if no namespaces
+	/// processing is requested.
+{
+public:
+	NoNamespacesStrategy();
+	~NoNamespacesStrategy();
+	
+	void startElement(const XMLChar* name, const XMLChar** atts, int specifiedCount, ContentHandler* pContentHandler);
+	void endElement(const XMLChar* name, ContentHandler* pContentHandler);
+	
+private:
+	XMLString _name;
+	AttributesImpl _attrs;
+};
+
+
+class XML_API NoNamespacePrefixesStrategy: public NamespaceStrategy
+	/// The NamespaceStrategy implementation used if namespaces
+	/// processing is requested, but prefixes are not reported.
+{
+public:
+	NoNamespacePrefixesStrategy();
+	~NoNamespacePrefixesStrategy();
+	
+	void startElement(const XMLChar* name, const XMLChar** atts, int specifiedCount, ContentHandler* pContentHandler);
+	void endElement(const XMLChar* name, ContentHandler* pContentHandler);
+
+private:
+	XMLString _uri;
+	XMLString _local;
+	AttributesImpl _attrs;
+};
+
+
+class XML_API NamespacePrefixesStrategy: public NamespaceStrategy
+	/// The NamespaceStrategy implementation used if namespaces
+	/// processing is requested and prefixes are reported.
+{
+public:
+	NamespacePrefixesStrategy();
+	~NamespacePrefixesStrategy();
+	
+	void startElement(const XMLChar* name, const XMLChar** atts, int specifiedCount, ContentHandler* pContentHandler);
+	void endElement(const XMLChar* name, ContentHandler* pContentHandler);
+	
+private:
+	XMLString _uri;
+	XMLString _local;
+	XMLString _qname;
+	AttributesImpl _attrs;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // XML_NamespaceStrategy_INCLUDED
diff --git a/base/poco/XML/include/Poco/XML/ParserEngine.h b/base/poco/XML/include/Poco/XML/ParserEngine.h
new file mode 100644
index 00000000000..da5e19db805
--- /dev/null
+++ b/base/poco/XML/include/Poco/XML/ParserEngine.h
@@ -0,0 +1,384 @@
+//
+// ParserEngine.h
+//
+// Library: XML
+// Package: XML
+// Module:  ParserEngine
+//
+// Definition of the ParseEngine class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+
+
+#ifndef XML_ParserEngine_INCLUDED
+#define XML_ParserEngine_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#if defined(POCO_UNBUNDLED_EXPAT)
+#include <expat.h>
+#else
+#include "Poco/XML/expat.h"
+#endif
+#include "Poco/XML/XMLString.h"
+#include "Poco/XML/XMLStream.h"
+#include "Poco/SAX/Locator.h"
+#include "Poco/TextEncoding.h"
+#include <map>
+#include <vector>
+
+
+namespace Poco {
+namespace XML {
+
+
+class InputSource;
+class EntityResolver;
+class DTDHandler;
+class DeclHandler;
+class ContentHandler;
+class LexicalHandler;
+class ErrorHandler;
+class NamespaceStrategy;
+class ContextLocator;
+
+
+class XML_API ParserEngine: public Locator
+	/// This class provides an object-oriented, stream-based,
+	/// low-level interface to the XML Parser Toolkit (expat).
+	/// It is strongly recommended, that you use the
+	/// SAX parser classes (which are based on this
+	/// class) instead of this class, since they provide
+	/// a standardized, higher-level interface to the parser.
+{
+public:
+	ParserEngine();
+		/// Creates the parser engine.
+
+	ParserEngine(const XMLString& encoding);
+		/// Creates the parser engine and passes the encoding
+		/// to the underlying parser.
+
+	~ParserEngine();
+		/// Destroys the parser.
+
+	void setEncoding(const XMLString& encoding);
+		/// Sets the encoding used by expat. The encoding must be
+		/// set before parsing begins, otherwise it will be ignored.
+
+	const XMLString& getEncoding() const;
+		/// Returns the encoding used by expat.
+
+	void addEncoding(const XMLString& name, Poco::TextEncoding* pEncoding);
+		/// Adds an encoding to the parser.
+
+	void setNamespaceStrategy(NamespaceStrategy* pStrategy);
+		/// Sets the NamespaceStrategy used by the parser.
+		/// The parser takes ownership of the strategy object
+		/// and deletes it when it's no longer needed.
+		/// The default is NoNamespacesStrategy.
+
+	NamespaceStrategy* getNamespaceStrategy() const;
+		/// Returns the NamespaceStrategy currently in use.
+
+	void setExpandInternalEntities(bool flag = true);
+		/// Enables/disables expansion of internal entities (enabled by
+		/// default). If entity expansion is disabled, internal entities
+		/// are reported via the default handler.
+		/// Must be set before parsing begins, otherwise it will be
+		/// ignored.
+
+	bool getExpandInternalEntities() const;
+		/// Returns true if internal entities will be expanded automatically,
+		/// which is the default.
+
+	void setExternalGeneralEntities(bool flag = true);
+		/// Enable or disable processing of external general entities.
+
+	bool getExternalGeneralEntities() const;
+		/// Returns true if external general entities will be processed; false otherwise.
+
+	void setExternalParameterEntities(bool flag = true);
+		/// Enable or disable processing of external parameter entities.
+
+	bool getExternalParameterEntities() const;
+		/// Returns true if external parameter entities will be processed; false otherwise.
+
+	void setEntityResolver(EntityResolver* pResolver);
+		/// Allow an application to register an entity resolver.
+
+	EntityResolver* getEntityResolver() const;
+		/// Return the current entity resolver.
+
+	void setDTDHandler(DTDHandler* pDTDHandler);
+		/// Allow an application to register a DTD event handler.
+
+	DTDHandler* getDTDHandler() const;
+		/// Return the current DTD handler.
+
+	void setDeclHandler(DeclHandler* pDeclHandler);
+		/// Allow an application to register a DTD declarations event handler.
+
+	DeclHandler* getDeclHandler() const;
+		/// Return the current DTD declarations handler.
+
+	void setContentHandler(ContentHandler* pContentHandler);
+		/// Allow an application to register a content event handler.
+
+	ContentHandler* getContentHandler() const;
+		/// Return the current content handler.
+
+	void setLexicalHandler(LexicalHandler* pLexicalHandler);
+		/// Allow an application to register a lexical event handler.
+
+	LexicalHandler* getLexicalHandler() const;
+		/// Return the current lexical handler.
+
+	void setErrorHandler(ErrorHandler* pErrorHandler);
+		/// Allow an application to register an error event handler.
+
+	ErrorHandler* getErrorHandler() const;
+		/// Return the current error handler.
+
+	void setEnablePartialReads(bool flag = true);
+		/// Enable or disable partial reads from the input source.
+		///
+		/// This is useful for parsing XML from a socket stream for
+		/// a protocol like XMPP, where basically single elements
+		/// are read one at a time from the input source's stream, and
+		/// following elements depend upon responses sent back to
+		/// the peer.
+		///
+		/// Normally, the parser always reads blocks of PARSE_BUFFER_SIZE
+		/// at a time, and blocks until a complete block has been read (or
+		/// the end of the stream has been reached).
+		/// This allows for efficient parsing of "complete" XML documents,
+		/// but fails in a case such as XMPP, where only XML fragments
+		/// are sent at a time.
+
+	bool getEnablePartialReads() const;
+		/// Returns true if partial reads are enabled (see
+		/// setEnablePartialReads()), false otherwise.
+
+	void setBillionLaughsAttackProtectionMaximumAmplification(float maximumAmplificationFactor);
+		/// Sets the maximum tolerated amplification factor
+    	/// for protection against Billion Laughs Attacks.
+    	///
+    	/// The amplification factor is calculated as:
+    	///     amplification := (direct + indirect) / direct
+    	/// while parsing, whereas:
+    	///   - direct is the number of bytes read from the primary document in parsing and
+    	///   - indirect is the number of bytes added by expanding entities and reading of
+    	///     external DTD files, combined.
+    	///
+    	/// maximumAmplificationFactor must be non-NaN and greater than or equal to 1.0.
+		///
+		/// Requires an underlying Expat version >= 2.4.0.
+
+	void setBillionLaughsAttackProtectionActivationThreshold(Poco::UInt64 activationThresholdBytes);
+		/// Sets number of output bytes (including amplification from entity expansion and reading DTD files)
+		/// needed to activate protection against Billion Laughs Attacks.
+		///
+		/// Defaults to 8 MiB.
+		///
+		/// Requires an underlying Expat version >= 2.4.0.
+
+	void parse(InputSource* pInputSource);
+		/// Parse an XML document from the given InputSource.
+
+	void parse(const char* pBuffer, std::size_t size);
+		/// Parses an XML document from the given buffer.
+
+	// Locator
+	XMLString getPublicId() const;
+		/// Return the public identifier for the current document event.
+
+	XMLString getSystemId() const;
+		/// Return the system identifier for the current document event.
+
+	int getLineNumber() const;
+		/// Return the line number where the current document event ends.
+
+	int getColumnNumber() const;
+		/// Return the column number where the current document event ends.
+
+protected:
+	void init();
+		/// initializes expat
+
+	void parseByteInputStream(XMLByteInputStream& istr);
+		/// Parses an entity from the given stream.
+
+	void parseCharInputStream(XMLCharInputStream& istr);
+		/// Parses an entity from the given stream.
+
+	std::streamsize readBytes(XMLByteInputStream& istr, char* pBuffer, std::streamsize bufferSize);
+		/// Reads at most bufferSize bytes from the given stream into the given buffer.
+
+	std::streamsize readChars(XMLCharInputStream& istr, XMLChar* pBuffer, std::streamsize bufferSize);
+		/// Reads at most bufferSize chars from the given stream into the given buffer.
+
+	void handleError(int errorNo);
+		/// Throws an XMLException with a message corresponding
+		/// to the given Expat error code.
+
+	void parseExternal(XML_Parser extParser, InputSource* pInputSource);
+		/// Parse an XML document from the given InputSource.
+
+	void parseExternalByteInputStream(XML_Parser extParser, XMLByteInputStream& istr);
+		/// Parses an external entity from the given stream, with a separate parser.
+
+	void parseExternalCharInputStream(XML_Parser extParser, XMLCharInputStream& istr);
+		/// Parses an external entity from the given stream, with a separate parser.
+
+	void pushContext(XML_Parser parser, InputSource* pInputSource);
+		/// Pushes a new entry to the context stack.
+
+	void popContext();
+		/// Pops the top-most entry from the context stack.
+
+	void resetContext();
+		/// Resets and clears the context stack.
+
+	const Locator& locator() const;
+		/// Returns a locator denoting the current parse location.
+
+	// expat handler procedures
+	static void handleStartElement(void* userData, const XML_Char* name, const XML_Char** atts);
+	static void handleEndElement(void* userData, const XML_Char* name);
+	static void handleCharacterData(void* userData, const XML_Char* s, int len);
+	static void handleProcessingInstruction(void* userData, const XML_Char* target, const XML_Char* data);
+	static void handleDefault(void* userData, const XML_Char* s, int len);
+	static void handleUnparsedEntityDecl(void* userData, const XML_Char* entityName, const XML_Char* base, const XML_Char* systemId, const XML_Char* publicId, const XML_Char* notationName);
+	static void handleNotationDecl(void* userData, const XML_Char* notationName, const XML_Char* base, const XML_Char* systemId, const XML_Char* publicId);
+	static int handleExternalEntityRef(XML_Parser parser, const XML_Char* openEntityNames, const XML_Char* base, const XML_Char* systemId, const XML_Char* publicId);
+	static int handleUnknownEncoding(void* encodingHandlerData, const XML_Char* name, XML_Encoding* info);
+	static void handleComment(void* userData, const XML_Char* data);
+	static void handleStartCdataSection(void* userData);
+	static void handleEndCdataSection(void* userData);
+	static void handleStartNamespaceDecl(void* userData, const XML_Char* prefix, const XML_Char* uri);
+	static void handleEndNamespaceDecl(void* userData, const XML_Char* prefix);
+	static void handleStartDoctypeDecl(void* userData, const XML_Char* doctypeName, const XML_Char *systemId, const XML_Char* publicId, int hasInternalSubset);
+	static void handleEndDoctypeDecl(void* userData);
+	static void handleEntityDecl(void *userData, const XML_Char *entityName, int isParamEntity, const XML_Char *value, int valueLength,
+	                             const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId, const XML_Char *notationName);
+	static void handleExternalParsedEntityDecl(void* userData, const XML_Char* entityName, const XML_Char* base, const XML_Char* systemId, const XML_Char* publicId);
+	static void handleInternalParsedEntityDecl(void* userData, const XML_Char* entityName, const XML_Char* replacementText, int replacementTextLength);
+	static void handleSkippedEntity(void* userData, const XML_Char* entityName, int isParameterEntity);
+
+	// encoding support
+	static int convert(void *data, const char *s);
+
+private:
+	typedef std::map<XMLString, Poco::TextEncoding*> EncodingMap;
+	typedef std::vector<ContextLocator*> ContextStack;
+
+	XML_Parser _parser;
+	char*      _pBuffer;
+	bool       _encodingSpecified;
+	XMLString  _encoding;
+	bool       _expandInternalEntities;
+	bool       _externalGeneralEntities;
+	bool       _externalParameterEntities;
+	bool       _enablePartialReads;
+	NamespaceStrategy* _pNamespaceStrategy;
+	EncodingMap        _encodings;
+	ContextStack       _context;
+
+	EntityResolver* _pEntityResolver;
+	DTDHandler*     _pDTDHandler;
+	DeclHandler*    _pDeclHandler;
+	ContentHandler* _pContentHandler;
+	LexicalHandler* _pLexicalHandler;
+	ErrorHandler*   _pErrorHandler;
+
+	float _maximumAmplificationFactor;
+	Poco::UInt64 _activationThresholdBytes;
+
+	static const int PARSE_BUFFER_SIZE;
+	static const XMLString EMPTY_STRING;
+};
+
+
+//
+// inlines
+//
+inline const XMLString& ParserEngine::getEncoding() const
+{
+	return _encoding;
+}
+
+
+inline NamespaceStrategy* ParserEngine::getNamespaceStrategy() const
+{
+	return _pNamespaceStrategy;
+}
+
+
+inline bool ParserEngine::getExpandInternalEntities() const
+{
+	return _expandInternalEntities;
+}
+
+
+inline bool ParserEngine::getExternalGeneralEntities() const
+{
+	return _externalGeneralEntities;
+}
+
+
+inline bool ParserEngine::getExternalParameterEntities() const
+{
+	return _externalParameterEntities;
+}
+
+
+inline EntityResolver* ParserEngine::getEntityResolver() const
+{
+	return _pEntityResolver;
+}
+
+
+inline DTDHandler* ParserEngine::getDTDHandler() const
+{
+	return _pDTDHandler;
+}
+
+
+inline DeclHandler* ParserEngine::getDeclHandler() const
+{
+	return _pDeclHandler;
+}
+
+
+inline ContentHandler* ParserEngine::getContentHandler() const
+{
+	return _pContentHandler;
+}
+
+
+inline LexicalHandler* ParserEngine::getLexicalHandler() const
+{
+	return _pLexicalHandler;
+}
+
+
+inline ErrorHandler* ParserEngine::getErrorHandler() const
+{
+	return _pErrorHandler;
+}
+
+
+inline bool ParserEngine::getEnablePartialReads() const
+{
+	return _enablePartialReads;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // XML_ParserEngine_INCLUDED
diff --git a/base/poco/XML/include/Poco/XML/QName.h b/base/poco/XML/include/Poco/XML/QName.h
new file mode 100644
index 00000000000..9aab3305b6d
--- /dev/null
+++ b/base/poco/XML/include/Poco/XML/QName.h
@@ -0,0 +1,148 @@
+//
+// QName.h
+//
+// Library: XML
+// Package: XML
+// Module:  QName
+//
+// Definition of the QName class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Based on libstudxml (http://www.codesynthesis.com/projects/libstudxml/).
+// Copyright (c) 2009-2013 Code Synthesis Tools CC.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef XML_QName_INCLUDED
+#define XML_QName_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include <string>
+#include <iosfwd>
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API QName
+	/// This class represents a qualified XML name in the stream parser.
+	///
+	/// Note that the optional prefix is just a "syntactic sugar". In
+	/// particular, it is ignored by the comparison operators and the
+	/// std::ostream insertion operator.
+{
+public:
+	QName();
+	QName(const std::string& name);
+	QName(const std::string& ns, const std::string& name);
+	QName(const std::string& ns, const std::string& name, const std::string& prefix);
+	QName(const QName& qname);
+	QName(QName&& qname) noexcept;
+
+	QName& operator = (const QName& qname);
+	QName& operator = (QName&& qname) noexcept;
+	void swap(QName& qname);
+
+	const std::string& namespaceURI() const;
+		/// Returns the namespace URI part of the name.
+
+	const std::string& localName() const;
+		/// Returns the local part of the name.
+
+	const std::string& prefix() const;
+		/// Returns the namespace prefix of the name.
+
+	std::string& namespaceURI();
+		/// Returns the namespace URI part of the name.
+
+	std::string& localName();
+		/// Returns the local part of the name.
+
+	std::string& prefix();
+		/// Returns the namespace prefix of the name.
+
+	std::string toString() const;
+		/// Returns a printable representation in the [<namespace>#]<name> form.
+
+public:
+	friend bool operator < (const QName& x, const QName& y);
+	friend bool operator == (const QName& x, const QName& y);
+	friend bool operator != (const QName& x, const QName& y);
+
+private:
+	std::string _ns;
+	std::string _name;
+	std::string _prefix;
+};
+
+
+//
+// inlines
+//
+inline const std::string& QName::namespaceURI() const
+{
+	return _ns;
+}
+
+
+inline const std::string& QName::localName() const
+{
+	return _name;
+}
+
+
+inline const std::string& QName::prefix() const
+{
+	return _prefix;
+}
+
+
+inline std::string& QName::namespaceURI()
+{
+	return _ns;
+}
+
+
+inline std::string& QName::localName()
+{
+	return _name;
+}
+
+
+inline std::string& QName::prefix()
+{
+	return _prefix;
+}
+
+
+XML_API std::ostream& operator << (std::ostream&, const QName&);
+
+
+inline bool operator < (const QName& x, const QName& y)
+{
+	return x._ns < y._ns || (x._ns == y._ns && x._name < y._name);
+}
+
+
+inline bool operator == (const QName& x, const QName& y)
+{
+	return x._ns == y._ns && x._name == y._name;
+}
+
+
+inline bool operator != (const QName& x, const QName& y)
+{
+	return !(x == y);
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // XML_QName_INCLUDED
diff --git a/base/poco/XML/include/Poco/XML/ValueTraits.h b/base/poco/XML/include/Poco/XML/ValueTraits.h
new file mode 100644
index 00000000000..46631c93984
--- /dev/null
+++ b/base/poco/XML/include/Poco/XML/ValueTraits.h
@@ -0,0 +1,104 @@
+//
+// ValueTraits.h
+//
+// Library: XML
+// Package: XML
+// Module:  ValueTraits
+//
+// Definition of the ValueTraits templates.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Based on libstudxml (http://www.codesynthesis.com/projects/libstudxml/).
+// Copyright (c) 2009-2013 Code Synthesis Tools CC.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef XML_ValueTraits_INCLUDED
+#define XML_ValueTraits_INCLUDED
+
+
+#include "XMLStreamParserException.h"
+#include <string>
+#include <cstddef>
+#include <iostream>
+#include <sstream>
+
+
+namespace Poco {
+namespace XML {
+
+
+class XMLStreamParser;
+class XMLStreamSerializer;
+
+
+template <typename T>
+struct DefaultValueTraits
+{
+	static T
+	parse(std::string, const XMLStreamParser&);
+
+	static std::string
+	serialize(const T&, const XMLStreamSerializer&);
+};
+
+
+template <>
+struct XML_API DefaultValueTraits<bool>
+{
+	static bool
+	parse(std::string, const XMLStreamParser&);
+
+	static std::string serialize(bool v, const XMLStreamSerializer&)
+	{
+		return v ? "true" : "false";
+	}
+};
+
+
+template <>
+struct XML_API DefaultValueTraits<std::string>
+{
+	static std::string parse(std::string s, const XMLStreamParser&)
+	{
+		return s;
+	}
+
+	static std::string serialize(const std::string& v, const XMLStreamSerializer&)
+	{
+		return v;
+	}
+};
+
+
+template <typename T>
+struct ValueTraits: DefaultValueTraits<T>
+{
+};
+
+
+template <typename T, std::size_t N>
+struct ValueTraits<T[N]> : DefaultValueTraits<const T*>
+{
+};
+
+
+template <typename T>
+T DefaultValueTraits<T>::parse(std::string s, const XMLStreamParser& p)
+{
+	T r;
+	std::istringstream is(s);
+	if (!(is >> r && is.eof()))
+		throw XMLStreamParserException(p, "invalid value '" + s + "'");
+	return r;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // XML_ValueTraits_INCLUDED
diff --git a/base/poco/XML/include/Poco/XML/XML.h b/base/poco/XML/include/Poco/XML/XML.h
new file mode 100644
index 00000000000..19a21a3b479
--- /dev/null
+++ b/base/poco/XML/include/Poco/XML/XML.h
@@ -0,0 +1,62 @@
+//
+// XML.h
+//
+// Library: XML
+// Package: XML
+// Module:  XML
+//
+// Basic definitions for the Poco XML library.
+// This file must be the first file included by every other XML
+// header file.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef XML_XML_INCLUDED
+#define XML_XML_INCLUDED
+
+
+#include "Poco/Foundation.h"
+
+
+//
+// The following block is the standard way of creating macros which make exporting 
+// from a DLL simpler. All files within this DLL are compiled with the XML_EXPORTS
+// symbol defined on the command line. this symbol should not be defined on any project
+// that uses this DLL. This way any other project whose source files include this file see 
+// XML_API functions as being imported from a DLL, whereas this DLL sees symbols
+// defined with this macro as being exported.
+//
+#if defined(_WIN32) && defined(POCO_DLL)
+	#if defined(XML_EXPORTS)
+		#define XML_API __declspec(dllexport)
+	#else
+		#define XML_API __declspec(dllimport)	
+	#endif
+#endif
+
+
+#if !defined(XML_API)
+	#if !defined(POCO_NO_GCC_API_ATTRIBUTE) && defined (__GNUC__) && (__GNUC__ >= 4)
+		#define XML_API __attribute__ ((visibility ("default")))
+	#else
+		#define XML_API
+	#endif
+#endif
+
+
+//
+// Automatically link XML library.
+//
+#if defined(_MSC_VER)
+	#if !defined(POCO_NO_AUTOMATIC_LIBS) && !defined(XML_EXPORTS)
+		#pragma comment(lib, "PocoXML" POCO_LIB_SUFFIX)
+	#endif
+#endif
+
+
+#endif // XML_XML_INCLUDED
diff --git a/base/poco/XML/include/Poco/XML/XMLException.h b/base/poco/XML/include/Poco/XML/XMLException.h
new file mode 100644
index 00000000000..9805badf063
--- /dev/null
+++ b/base/poco/XML/include/Poco/XML/XMLException.h
@@ -0,0 +1,37 @@
+//
+// XMLException.h
+//
+// Library: XML
+// Package: XML
+// Module:  XMLException
+//
+// Definition of the XMLException class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef XML_XMLException_INCLUDED
+#define XML_XMLException_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/Exception.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+POCO_DECLARE_EXCEPTION(XML_API, XMLException, Poco::RuntimeException)
+	/// The base class for all XML-related exceptions like SAXException
+	/// and DOMException.
+
+
+} } // namespace Poco::XML
+
+
+#endif // XML_XMLException_INCLUDED
diff --git a/base/poco/XML/include/Poco/XML/XMLStream.h b/base/poco/XML/include/Poco/XML/XMLStream.h
new file mode 100644
index 00000000000..23a3999af14
--- /dev/null
+++ b/base/poco/XML/include/Poco/XML/XMLStream.h
@@ -0,0 +1,71 @@
+//
+// XMLStream.h
+//
+// Library: XML
+// Package: XML
+// Module:  XMLStream
+//
+// Definition of the XMLByteInputStream and XMLCharInputStream classes.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef XML_XMLStream_INCLUDED
+#define XML_XMLStream_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include <istream>
+#include <ostream>
+
+
+namespace Poco {
+namespace XML {
+
+
+// The byte input stream is always a narrow stream.
+using XMLByteInputStream = std::istream;
+using XMLByteOutputStream = std::ostream;
+
+
+//
+// The XML parser uses the stream classes provided by the C++
+// standard library (based on the basic_stream<> template).
+// In Unicode mode, a wide stream is used.
+// To turn on Unicode mode, #define XML_UNICODE and
+// XML_UNICODE_WCHAR_T when compiling the library.
+//
+// XML_UNICODE  XML_UNICODE_WCHAR_T  XMLCharInputStream  XMLCharOutputStream
+// -------------------------------------------------------------------------
+//     N                 N           std::istream        std::ostream
+//     N                 Y           std::wistream       std::wostream
+//     Y                 Y           std::wistream       std::wostream
+//     Y                 N           <not supported>
+//
+#if defined(XML_UNICODE_WCHAR_T)
+
+	// Unicode - use wide streams
+	using XMLCharInputStream = std::wistream;
+	using XMLCharOutputStream = std::wostream;
+
+#elif defined(XML_UNICODE)
+
+	// not supported - leave XMLString undefined
+
+#else
+
+	// Characters are UTF-8 encoded
+	using XMLCharInputStream = std::istream;
+	using XMLCharOutputStream = std::ostream;
+
+#endif
+
+
+} } // namespace Poco::XML
+
+
+#endif // XML_XMLStream_INCLUDED
diff --git a/base/poco/XML/include/Poco/XML/XMLStreamParser.h b/base/poco/XML/include/Poco/XML/XMLStreamParser.h
new file mode 100644
index 00000000000..31e309d564b
--- /dev/null
+++ b/base/poco/XML/include/Poco/XML/XMLStreamParser.h
@@ -0,0 +1,634 @@
+//
+// XMLStreamParser.h
+//
+// Library: XML
+// Package: XML
+// Module:  XMLStreamParser
+//
+// Definition of the XMLStreamParser class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Based on libstudxml (http://www.codesynthesis.com/projects/libstudxml/).
+// Copyright (c) 2009-2013 Code Synthesis Tools CC.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef XML_XMLStreamParser_INCLUDED
+#define XML_XMLStreamParser_INCLUDED
+
+
+// We only support UTF-8 expat.
+#ifdef XML_UNICODE
+#error UTF-16 expat (XML_UNICODE defined) is not supported
+#endif
+
+
+#include "Poco/XML/QName.h"
+#include "Poco/XML/ValueTraits.h"
+#include "Poco/XML/Content.h"
+#if defined(POCO_UNBUNDLED_EXPAT)
+#include <expat.h>
+#else
+#include "Poco/XML/expat.h"
+#endif
+#include <map>
+#include <vector>
+#include <string>
+#include <iosfwd>
+#include <cstddef>
+
+
+namespace Poco {
+namespace XML {
+
+
+class XML_API XMLStreamParser
+	/// The streaming XML pull parser and streaming XML serializer. The parser
+	/// is a conforming, non-validating XML 1.0 implementation (see Implementation Notes
+	/// for details). The application character encoding (that is, the encoding used
+	/// in the application's memory) for both parser and serializer is UTF-8.
+	/// The output encoding of the serializer is UTF-8 as well. The parser supports
+	/// UTF-8, UTF-16, ISO-8859-1, and US-ASCII input encodings.
+	///
+	/// Attribute map:
+	///
+	/// Attribute map lookup. If attribute is not found, then the version
+	/// without the default value throws an appropriate parsing exception
+	/// while the version with the default value returns that value.
+	///
+	/// Note also that there is no attribute(ns, name) version since it
+	/// would conflict with attribute(name, dv) (qualified attributes
+	/// are not very common).
+	///
+	/// Attribute map is valid throughout at the "element level" until
+	/// end_element and not just during EV_START_ELEMENT. As a special case,
+	/// the map is still valid after peek() that returned end_element until
+	/// this end_element event is retrieved with next().
+	///
+	/// Using parser:
+	///
+	///     XMLStreamParser p(ifs, argv[1]);
+	///     for (XMLStreamParser::EventType e: p)
+	///     {
+	///         switch (e)
+	///         {
+	///         case XMLStreamParser::EV_START_ELEMENT:
+	///             cerr << p.line () << ':' << p.column () << ": start " << p.name () << endl;
+	///             break;
+	///         case XMLStreamParser::EV_END_ELEMENT:
+	///             cerr << p.line () << ':' << p.column () << ": end " << p.name () << endl;
+	///             break;
+	///         case XMLStreamParser::EV_START_ATTRIBUTE:
+	///             ...
+	///         case XMLStreamParser::EV_END_ATTRIBUTE:
+	///             ...
+	///         case XMLStreamParser::EV_CHARACTERS:
+	///             ...
+	///         }
+	///     }
+{
+public:
+	enum EventType
+		/// Parsing events.
+	{
+		EV_START_ELEMENT,
+		EV_END_ELEMENT,
+		EV_START_ATTRIBUTE,
+		EV_END_ATTRIBUTE,
+		EV_CHARACTERS,
+		EV_START_NAMESPACE_DECL,
+		EV_END_NAMESPACE_DECL,
+		EV_EOF
+	};
+
+	using FeatureType = unsigned short;
+		/// If both receive_attributes_event and RECEIVE_ATTRIBUTE_MAP are
+		/// specified, then RECEIVE_ATTRIBUTES_EVENT is assumed.
+
+	static const FeatureType RECEIVE_ELEMENTS = 0x0001;
+	static const FeatureType RECEIVE_CHARACTERS = 0x0002;
+	static const FeatureType RECEIVE_ATTRIBUTE_MAP = 0x0004;
+	static const FeatureType RECEIVE_ATTRIBUTES_EVENT = 0x0008;
+	static const FeatureType RECEIVE_NAMESPACE_DECLS = 0x0010;
+	static const FeatureType RECEIVE_DEFAULT = RECEIVE_ELEMENTS | RECEIVE_CHARACTERS | RECEIVE_ATTRIBUTE_MAP;
+
+	struct AttributeValueType
+	{
+		std::string value;
+		mutable bool handled;
+	};
+
+	using AttributeMapType = std::map<QName, AttributeValueType>;
+
+	struct XML_API Iterator
+		// C++11 range-based for support. Generally, the iterator interface
+		// doesn't make much sense for the XMLStreamParser so for now we have an
+		// implementation that is just enough to the range-based for.
+	{
+		using value_type = EventType;
+
+		Iterator(XMLStreamParser* p = 0, EventType e = EV_EOF):
+			_parser(p),
+			_e(e)
+		{
+		}
+
+		value_type operator * () const
+		{
+			return _e;
+		}
+
+		Iterator& operator ++ ()
+		{
+			_e = _parser->next();
+			return *this;
+		}
+
+		bool operator == (Iterator y) const
+			/// Comparison only makes sense when comparing to end (eof).
+		{
+			return _e == EV_EOF && y._e == EV_EOF;
+		}
+
+		bool operator != (Iterator y) const
+			/// Comparison only makes sense when comparing to end (eof).
+		{
+			return !(*this == y);
+		}
+
+	private:
+		XMLStreamParser* _parser;
+		EventType _e;
+	};
+
+	Iterator begin()
+	{
+		return Iterator(this, next());
+	}
+
+	Iterator end()
+	{
+		return Iterator(this, EV_EOF);
+	}
+
+	XMLStreamParser(std::istream&, const std::string& inputName, FeatureType = RECEIVE_DEFAULT);
+		/// The parser constructor takes three arguments: the stream to parse,
+		/// input name that is used in diagnostics to identify the document being
+		/// parsed, and the list of events we want the parser to report.
+		///
+		/// Parse std::istream. Input name is used in diagnostics to identify
+		/// the document being parsed.
+		///
+		/// If stream exceptions are enabled then std::ios_base::failure
+		/// exception is used to report io errors (badbit and failbit).
+		/// Otherwise, those are reported as the parsing exception.
+
+	XMLStreamParser(const void* data, std::size_t size, const std::string& inputName, FeatureType = RECEIVE_DEFAULT);
+		/// Parse memory buffer that contains the whole document. Input name
+		/// is used in diagnostics to identify the document being parsed.
+
+	~XMLStreamParser();
+		/// Destroys the XMLStreamParser.
+
+	EventType next();
+		/// Call the next() function when we are ready to handle the next piece of XML.
+
+	void nextExpect(EventType);
+		/// Get the next event and make sure that it's what's expected. If it
+		/// is not, then throw an appropriate parsing exception.
+
+	void nextExpect(EventType, const std::string& name);
+	void nextExpect(EventType, const QName& qname);
+	void nextExpect(EventType, const std::string& ns, const std::string& name);
+
+	EventType peek();
+	EventType event();
+		/// Return the event that was last returned by the call to next() or peek().
+
+	const std::string& inputName() const;
+	const QName& getQName() const;
+	const std::string& namespaceURI() const;
+	const std::string& localName() const;
+	const std::string& prefix() const;
+	std::string& value();
+	const std::string& value() const;
+	template <typename T> T value() const;
+	Poco::UInt64 line() const;
+	Poco::UInt64 column() const;
+	const std::string& attribute(const std::string& name) const;
+	template <typename T>
+	T attribute(const std::string& name) const;
+	std::string attribute(const std::string& name, const std::string& deflt) const;
+	template <typename T>
+	T attribute(const std::string& name, const T& deflt) const;
+	const std::string& attribute(const QName& qname) const;
+	template <typename T>
+	T attribute(const QName& qname) const;
+	std::string attribute(const QName& qname, const std::string& deflt) const;
+	template <typename T>
+	T attribute(const QName& qname, const T& deflt) const;
+	bool attributePresent(const std::string& name) const;
+	bool attributePresent(const QName& qname) const;
+	const AttributeMapType& attributeMap() const;
+
+	void content(Content);
+	Content content() const;
+
+	void nextExpect(EventType, const std::string& name, Content);
+	void nextExpect(EventType, const QName& qname, Content);
+	void nextExpect(EventType, const std::string& ns, const std::string& name, Content);
+
+	// Helpers for parsing elements with simple content. The first two
+	// functions assume that EV_START_ELEMENT has already been parsed. The
+	// rest parse the complete element, from start to end.
+	//
+	// Note also that as with attribute(), there is no (namespace,name)
+	// overload since it would conflicts with (namespace,deflt).
+	std::string element();
+
+	template <typename T>
+	T element();
+	std::string element(const std::string& name);
+	std::string element(const QName& qname);
+	template <typename T>
+	T element(const std::string& name);
+	template <typename T>
+	T element(const QName& qname);
+	std::string element(const std::string& name, const std::string& deflt);
+	std::string element(const QName& qname, const std::string& deflt);
+	template <typename T>
+	T element(const std::string& name, const T& deflt);
+	template <typename T>
+	T element(const QName& qname, const T& deflt);
+
+private:
+	XMLStreamParser(const XMLStreamParser&);
+	XMLStreamParser& operator = (const XMLStreamParser&);
+
+	static void XMLCALL handleStartElement(void*, const XML_Char*, const XML_Char**);
+	static void XMLCALL handleEndElement(void*, const XML_Char*);
+	static void XMLCALL handleCharacters(void*, const XML_Char*, int);
+	static void XMLCALL handleStartNamespaceDecl(void*, const XML_Char*, const XML_Char*);
+	static void XMLCALL handleEndNamespaceDecl(void*, const XML_Char*);
+
+	void init();
+	EventType nextImpl(bool peek);
+	EventType nextBody();
+	void handleError();
+
+	// If _size is 0, then data is std::istream. Otherwise, it is a buffer.
+	union
+	{
+		std::istream* is;
+		const void* buf;
+	}
+	_data;
+
+	std::size_t _size;
+	const std::string _inputName;
+	FeatureType _feature;
+	XML_Parser _parser;
+	std::size_t _depth;
+	bool _accumulateContent; // Whether we are accumulating character content.
+	enum { state_next, state_peek } _parserState;
+	EventType _currentEvent;
+	EventType _queue;
+	QName _qname;
+	std::string _value;
+	const QName* _qualifiedName;
+	std::string* _pvalue;
+	Poco::UInt64 _line;
+	Poco::UInt64 _column;
+
+	struct AttributeType
+	{
+		QName qname;
+		std::string value;
+	};
+
+	typedef std::vector<AttributeType> attributes;
+	attributes _attributes;
+	attributes::size_type _currentAttributeIndex; // Index of the current attribute.
+
+	typedef std::vector<QName> NamespaceDecls;
+	NamespaceDecls _startNamespace;
+	NamespaceDecls::size_type _startNamespaceIndex;// Index of the current decl.
+	NamespaceDecls _endNamespace;
+	NamespaceDecls::size_type _endNamespaceIndex;// Index of the current decl.
+
+	struct ElementEntry
+	{
+		ElementEntry(std::size_t d, Content c = Content::Mixed):
+			depth(d),
+			content(c),
+			attributesUnhandled(0)
+		{
+		}
+
+		std::size_t depth;
+		Content content;
+		AttributeMapType attributeMap;
+		mutable AttributeMapType::size_type attributesUnhandled;
+	};
+
+	typedef std::vector<ElementEntry> ElementState;
+	std::vector<ElementEntry> _elementState;
+
+	const AttributeMapType _emptyAttrMap;
+
+	const ElementEntry* getElement() const;
+	const ElementEntry* getElementImpl() const;
+	void popElement();
+};
+
+
+XML_API std::ostream& operator << (std::ostream&, XMLStreamParser::EventType);
+
+
+//
+// inlines
+//
+inline XMLStreamParser::EventType XMLStreamParser::event()
+	// Return the even that was last returned by the call to next() or peek().
+{
+	return _currentEvent;
+}
+
+
+inline const std::string& XMLStreamParser::inputName() const
+{
+	return _inputName;
+}
+
+
+inline const QName& XMLStreamParser::getQName() const
+{
+	return *_qualifiedName;
+}
+
+
+inline const std::string& XMLStreamParser::namespaceURI() const
+{
+	return _qualifiedName->namespaceURI();
+}
+
+
+inline const std::string& XMLStreamParser::localName() const
+{
+	return _qualifiedName->localName();
+}
+
+
+inline const std::string& XMLStreamParser::prefix() const
+{
+	return _qualifiedName->prefix();
+}
+
+
+inline std::string& XMLStreamParser::value()
+{
+	return *_pvalue;
+}
+
+
+inline const std::string& XMLStreamParser::value() const
+{
+	return *_pvalue;
+}
+
+
+inline Poco::UInt64 XMLStreamParser::line() const
+{
+	return _line;
+}
+
+
+inline Poco::UInt64 XMLStreamParser::column() const
+{
+	return _column;
+}
+
+
+inline XMLStreamParser::EventType XMLStreamParser::peek()
+{
+	if (_parserState == state_peek)
+		return _currentEvent;
+	else
+	{
+		EventType e(nextImpl(true));
+		_parserState = state_peek; // Set it after the call to nextImpl().
+		return e;
+	}
+}
+
+
+template <typename T>
+inline T XMLStreamParser::value() const
+{
+	return ValueTraits < T > ::parse(value(), *this);
+}
+
+
+inline const std::string& XMLStreamParser::attribute(const std::string& n) const
+{
+	return attribute(QName(n));
+}
+
+
+template <typename T>
+inline T XMLStreamParser::attribute(const std::string& n) const
+{
+	return attribute < T > (QName(n));
+}
+
+
+inline std::string XMLStreamParser::attribute(const std::string& n, const std::string& dv) const
+{
+	return attribute(QName(n), dv);
+}
+
+
+template <typename T>
+inline T XMLStreamParser::attribute(const std::string& n, const T& dv) const
+{
+	return attribute < T > (QName(n), dv);
+}
+
+
+template <typename T>
+inline T XMLStreamParser::attribute(const QName& qn) const
+{
+	return ValueTraits < T > ::parse(attribute(qn), *this);
+}
+
+
+inline bool XMLStreamParser::attributePresent(const std::string& n) const
+{
+	return attributePresent(QName(n));
+}
+
+
+inline const XMLStreamParser::AttributeMapType& XMLStreamParser::attributeMap() const
+{
+	if (const ElementEntry* e = getElement())
+	{
+		e->attributesUnhandled = 0; // Assume all handled.
+		return e->attributeMap;
+	}
+
+	return _emptyAttrMap;
+}
+
+
+inline void XMLStreamParser::nextExpect(EventType e, const QName& qn)
+{
+	nextExpect(e, qn.namespaceURI(), qn.localName());
+}
+
+
+inline void XMLStreamParser::nextExpect(EventType e, const std::string& n)
+{
+	nextExpect(e, std::string(), n);
+}
+
+
+inline void XMLStreamParser::nextExpect(EventType e, const QName& qn, Content c)
+{
+	nextExpect(e, qn);
+	poco_assert(e == EV_START_ELEMENT);
+	content(c);
+}
+
+
+inline void XMLStreamParser::nextExpect(EventType e, const std::string& n, Content c)
+{
+	nextExpect(e, std::string(), n);
+	poco_assert(e == EV_START_ELEMENT);
+	content(c);
+}
+
+
+inline void XMLStreamParser::nextExpect(EventType e, const std::string& ns, const std::string& n, Content c)
+{
+	nextExpect(e, ns, n);
+	poco_assert(e == EV_START_ELEMENT);
+	content(c);
+}
+
+
+template <typename T>
+inline T XMLStreamParser::element()
+{
+	return ValueTraits < T > ::parse(element(), *this);
+}
+
+
+inline std::string XMLStreamParser::element(const std::string& n)
+{
+	nextExpect(EV_START_ELEMENT, n);
+	return element();
+}
+
+
+inline std::string XMLStreamParser::element(const QName& qn)
+{
+	nextExpect(EV_START_ELEMENT, qn);
+	return element();
+}
+
+
+template <typename T>
+inline T XMLStreamParser::element(const std::string& n)
+{
+	return ValueTraits < T > ::parse(element(n), *this);
+}
+
+
+template <typename T>
+inline T XMLStreamParser::element(const QName& qn)
+{
+	return ValueTraits < T > ::parse(element(qn), *this);
+}
+
+
+inline std::string XMLStreamParser::element(const std::string& n, const std::string& dv)
+{
+	return element(QName(n), dv);
+}
+
+
+template <typename T>
+inline T XMLStreamParser::element(const std::string& n, const T& dv)
+{
+	return element < T > (QName(n), dv);
+}
+
+
+inline void XMLStreamParser::content(Content c)
+{
+	poco_assert(_parserState == state_next);
+
+	if (!_elementState.empty() && _elementState.back().depth == _depth)
+		_elementState.back().content = c;
+	else
+		_elementState.emplace_back(_depth, c);
+}
+
+
+inline Content XMLStreamParser::content() const
+{
+	poco_assert(_parserState == state_next);
+
+	return !_elementState.empty() && _elementState.back().depth == _depth ? _elementState.back().content : Content(Content::Mixed);
+}
+
+
+inline const XMLStreamParser::ElementEntry* XMLStreamParser::getElement() const
+{
+	return _elementState.empty() ? 0 : getElementImpl();
+}
+
+
+template <typename T>
+T XMLStreamParser::attribute(const QName& qn, const T& dv) const
+{
+	if (const ElementEntry* e = getElement())
+	{
+		AttributeMapType::const_iterator i(e->attributeMap.find(qn));
+
+		if (i != e->attributeMap.end())
+		{
+			if (!i->second.handled)
+			{
+				i->second.handled = true;
+				e->attributesUnhandled--;
+			}
+			return ValueTraits < T > ::parse(i->second.value, *this);
+		}
+	}
+
+	return dv;
+}
+
+
+template <typename T>
+T XMLStreamParser::element(const QName& qn, const T& dv)
+{
+	if (peek() == EV_START_ELEMENT && getQName() == qn)
+	{
+		next();
+		return element<T>();
+	}
+
+	return dv;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // XML_XMLStreamParser_INCLUDED
diff --git a/base/poco/XML/include/Poco/XML/XMLStreamParserException.h b/base/poco/XML/include/Poco/XML/XMLStreamParserException.h
new file mode 100644
index 00000000000..b2ccedadb9d
--- /dev/null
+++ b/base/poco/XML/include/Poco/XML/XMLStreamParserException.h
@@ -0,0 +1,58 @@
+//
+// XMLStreamParserException.h
+//
+// Library: XML
+// Package: XML
+// Module:  XMLStreamParserException
+//
+// Definition of the XMLStreamParserException class.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef XML_XMLStreamParserException_INCLUDED
+#define XML_XMLStreamParserException_INCLUDED
+
+
+#include "Poco/XML/XMLException.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class XMLStreamParser;
+
+
+class XML_API XMLStreamParserException: public Poco::XML::XMLException
+{
+public:
+	XMLStreamParserException(const std::string& name, Poco::UInt64 line, Poco::UInt64 column, const std::string& description);
+	XMLStreamParserException(const XMLStreamParser&, const std::string& description);
+	virtual ~XMLStreamParserException() throw ();
+
+	const char* name() const noexcept;
+	Poco::UInt64 line() const;
+	Poco::UInt64 column() const;
+	const std::string& description() const;
+	virtual const char* what() const throw ();
+
+private:
+	void init();
+
+	std::string _name;
+	Poco::UInt64 _line;
+	Poco::UInt64 _column;
+	std::string _description;
+	std::string _what;
+};
+
+
+} } // namespace Poco::XML
+
+
+#endif // XML_XMLStreamParserException_INCLUDED
diff --git a/base/poco/XML/include/Poco/XML/XMLString.h b/base/poco/XML/include/Poco/XML/XMLString.h
new file mode 100644
index 00000000000..719fe7b8b6f
--- /dev/null
+++ b/base/poco/XML/include/Poco/XML/XMLString.h
@@ -0,0 +1,87 @@
+//
+// XMLString.h
+//
+// Library: XML
+// Package: XML
+// Module:  XMLString
+//
+// Definition of the XMLString class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef XML_XMLString_INCLUDED
+#define XML_XMLString_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+//
+// The XML parser uses the string classes provided by the C++
+// standard library (based on the basic_string<> template).
+// In Unicode mode, a std::wstring is used, otherwise
+// a std::string is used.
+// To turn on Unicode mode, #define XML_UNICODE and
+// XML_UNICODE_WCHAR_T when compiling the library.
+//
+// XML_UNICODE  XML_UNICODE_WCHAR_T  XMLChar    XMLString
+// --------------------------------------------------------------
+//     N                 N           char       std::string
+//     N                 Y           wchar_t    std::wstring
+//     Y                 Y           wchar_t    std::wstring
+//     Y                 N           <not supported>
+//
+#if defined(XML_UNICODE_WCHAR_T)
+
+	// Unicode - use wchar_t
+	using XMLChar = wchar_t;
+	using XMLString = std::wstring;
+
+	std::string fromXMLString(const XMLString& str);
+		/// Converts an XMLString into an UTF-8 encoded
+		/// string.
+		
+	XMLString toXMLString(const std::string& str);
+		/// Converts an UTF-8 encoded string into an
+		/// XMLString
+		
+	#define XML_LIT(lit) L##lit
+
+#elif defined(XML_UNICODE)
+
+	// not supported - leave XMLString undefined
+
+#else
+
+	// Characters are UTF-8 encoded
+	using XMLChar = char;
+	using XMLString = std::string;
+
+	inline const std::string& fromXMLString(const XMLString& str)
+	{
+		return str;
+	}
+
+	inline const XMLString& toXMLString(const std::string& str)
+	{
+		return str;
+	}
+	
+	#define XML_LIT(lit) lit
+
+#endif
+
+
+} } // namespace Poco::XML
+
+
+#endif // XML_XMLString_INCLUDED
diff --git a/base/poco/XML/include/Poco/XML/XMLWriter.h b/base/poco/XML/include/Poco/XML/XMLWriter.h
new file mode 100644
index 00000000000..5f947ef1716
--- /dev/null
+++ b/base/poco/XML/include/Poco/XML/XMLWriter.h
@@ -0,0 +1,375 @@
+//
+// XMLWriter.h
+//
+// Library: XML
+// Package: XML
+// Module:  XMLWriter
+//
+// Definition of the XMLWriter class.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef XML_XMLWriter_INCLUDED
+#define XML_XMLWriter_INCLUDED
+
+
+#include "Poco/XML/XML.h"
+#include "Poco/SAX/ContentHandler.h"
+#include "Poco/SAX/LexicalHandler.h"
+#include "Poco/SAX/DTDHandler.h"
+#include "Poco/SAX/NamespaceSupport.h"
+#include "Poco/XML/XMLString.h"
+#include "Poco/XML/XMLStream.h"
+#include "Poco/XML/Name.h"
+#include "Poco/TextEncoding.h"
+#include "Poco/StreamConverter.h"
+#include <vector>
+#include <map>
+
+
+namespace Poco {
+namespace XML {
+
+
+class Locator;
+
+
+class XML_API XMLWriter: public ContentHandler, public LexicalHandler, public DTDHandler
+	/// This class serializes SAX2 ContentHandler, LexicalHandler and
+	/// DTDHandler events back into a stream.
+	/// 
+	/// Various consistency checks are performed on the written data
+	/// (i.e. there must be exactly one root element and every startElement() 
+	/// must have a matching endElement()).
+	///
+	/// The XMLWriter supports optional pretty-printing of the serialized XML.
+	/// Note, however, that pretty-printing XML data alters the
+	/// information set of the document being written, since in
+	/// XML all whitespace is potentially relevant to an application.
+	///
+	/// The writer contains extensive support for XML Namespaces, so that a client  
+	/// application does not have to keep track of prefixes and supply xmlns attributes.
+	///
+	/// If the client does not provide namespace prefixes (either by specifying them
+	/// as part of the qualified name given to startElement(), or by calling
+	/// startPrefixMapping()), the XMLWriter automatically generates namespace
+	/// prefixes in the form ns1, ns2, etc.
+{
+public:
+	enum Options
+	{
+		CANONICAL               = 0x00,
+			/// Do not write an XML declaration (default).
+
+		CANONICAL_XML           = 0x01, 
+			/// Enables basic support for Canonical XML: 
+			///   - do not write an XML declaration
+			///   - do not use special empty element syntax
+			///   - set the New Line character to NEWLINE_LF
+			///   - write namespace declarations and attributes 
+			///     in canonical order
+			///   - use default namespace as much as possible
+
+		WRITE_XML_DECLARATION   = 0x02, 
+			/// Write an XML declaration.
+
+		PRETTY_PRINT            = 0x04, 
+			/// Pretty-print XML markup.
+
+		PRETTY_PRINT_ATTRIBUTES = 0x08
+			/// Write each attribute on a separate line. 
+			/// PRETTY_PRINT must be specified as well.
+	};
+
+	XMLWriter(XMLByteOutputStream& str, int options);
+		/// Creates the XMLWriter and sets the specified options.
+		///
+		/// The resulting stream will be UTF-8 encoded.
+
+	XMLWriter(XMLByteOutputStream& str, int options, const std::string& encodingName, Poco::TextEncoding& textEncoding);
+		/// Creates the XMLWriter and sets the specified options.
+		///
+		/// The encoding is reflected in the XML declaration.
+		/// The caller is responsible for that the given encodingName matches with
+		/// the given textEncoding.
+
+	XMLWriter(XMLByteOutputStream& str, int options, const std::string& encodingName, Poco::TextEncoding* pTextEncoding);
+		/// Creates the XMLWriter and sets the specified options.
+		///
+		/// The encoding is reflected in the XML declaration.
+		/// The caller is responsible for that the given encodingName matches with
+		/// the given textEncoding.
+		/// If pTextEncoding is null, the given encodingName is ignored and the
+		/// default UTF-8 encoding is used.
+
+	~XMLWriter();
+		/// Destroys the XMLWriter.
+
+	void setNewLine(const std::string& newLineCharacters);
+		/// Sets the line ending for the resulting XML file.
+		///
+		/// Possible values are:
+		///   * NEWLINE_DEFAULT (whatever is appropriate for the current platform)
+		///   * NEWLINE_CRLF    (Windows),
+		///   * NEWLINE_LF      (Unix),
+		///   * NEWLINE_CR      (Macintosh)
+
+	const std::string& getNewLine() const;
+		/// Returns the line ending currently in use.
+
+	void setIndent(const std::string& indent);
+		/// Sets the string used for one indentation step.
+		///
+		/// The default is a single TAB character.
+		/// The given string should only contain TAB or SPACE
+		/// characters (e.g., a single TAB character, or
+		/// two to four SPACE characters).
+		
+	const std::string& getIndent() const;
+		/// Returns the string used for one indentation step.
+
+	// ContentHandler
+	void setDocumentLocator(const Locator* loc);
+		/// Currently unused.
+
+	void startDocument();
+		/// Writes a generic XML declaration to the stream.
+		/// If a document type has been set (see SetDocumentType),
+		/// a DOCTYPE declaration is also written.
+
+	void endDocument();
+		/// Checks that all elements are closed and prints a final newline.
+
+	void startFragment();
+		/// Use this instead of StartDocument() if you want to write
+		/// a fragment rather than a document (no XML declaration and
+		/// more than one "root" element allowed).
+
+	void endFragment();
+		/// Checks that all elements are closed and prints a final newline.
+
+	void startElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const Attributes& attributes);
+		/// Writes an XML start element tag.
+		///
+		/// Namespaces are handled as follows.
+		///   1. If a qname, but no namespaceURI and localName are given, the qname is taken as element name.
+		///   2. If a namespaceURI and a localName, but no qname is given, and the given namespaceURI has been
+		///      declared earlier, the namespace prefix for the given namespaceURI together with the localName
+		///      is taken as element name. If the namespace has not been declared, a prefix in the form
+		///      "ns1", "ns2", etc. is generated and the namespace is declared with the generated prefix.
+		///   3. If all three are given, and the namespace given in namespaceURI has not been declared, it is declared now.
+		///      Otherwise, see 2.
+
+	void startElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname);
+		/// Writes an XML start element tag with no attributes.
+		/// See the other startElement() method for more information.
+		
+	void endElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname);
+		/// Writes an XML end element tag.
+		///
+		/// Throws an exception if the name of doesn't match the
+		/// one of the most recent startElement().
+
+	void emptyElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname);
+		/// Writes an empty XML element tag (<elem/>).
+
+	void emptyElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const Attributes& attributes);
+		/// Writes an empty XML element tag with the given attributes (<elem attr1="value1"... />).
+
+	void characters(const XMLChar ch[], int start, int length);
+		/// Writes XML character data. Quotes, ampersand's, less-than and
+		/// greater-than signs are escaped, unless a CDATA section
+		/// has been opened by calling startCDATA().
+		///
+		/// The characters must be encoded in UTF-8 (if XMLChar is char) or 
+		/// UTF-16 (if XMLChar is wchar_t).
+
+	void characters(const XMLString& str);
+		/// Writes XML character data. Quotes, ampersand's, less-than and
+		/// greater-than signs are escaped, unless a CDATA section
+		/// has been opened by calling startCDATA().
+		///
+		/// The characters must be encoded in UTF-8 (if XMLChar is char) or 
+		/// UTF-16 (if XMLChar is wchar_t).
+
+	void rawCharacters(const XMLString& str);
+		/// Writes the characters in the given string as they are.
+		/// The caller is responsible for escaping characters as
+		/// necessary to produce valid XML.
+		///
+		/// The characters must be encoded in UTF-8 (if XMLChar is char) or 
+		/// UTF-16 (if XMLChar is wchar_t).
+
+	void ignorableWhitespace(const XMLChar ch[], int start, int length);
+		/// Writes whitespace characters by simply passing them to
+		/// characters().
+
+	void processingInstruction(const XMLString& target, const XMLString& data);
+		/// Writes a processing instruction.
+
+	void startPrefixMapping(const XMLString& prefix, const XMLString& namespaceURI);
+		/// Begin the scope of a prefix-URI Namespace mapping.
+		/// A namespace declaration is written with the next element.
+
+	void endPrefixMapping(const XMLString& prefix);
+		/// End the scope of a prefix-URI mapping.
+
+	void skippedEntity(const XMLString& name);
+		/// Does nothing.
+
+	void dataElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const XMLString& data, 
+	                         const XMLString& attr1 = XMLString(), const XMLString& value1 = XMLString(),
+							 const XMLString& attr2 = XMLString(), const XMLString& value2 = XMLString(),
+							 const XMLString& attr3 = XMLString(), const XMLString& value3 = XMLString());
+		/// Writes a data element in the form <name attr1="value1"...>data</name>.
+
+	// LexicalHandler
+	void startCDATA();
+		/// Writes the <![CDATA[ string that begins a CDATA section.
+		/// Use characters() to write the actual character data.
+
+	void endCDATA();
+		/// Writes the ]]> string that ends a CDATA section.
+
+	void comment(const XMLChar ch[], int start, int length);
+		/// Writes a comment.
+
+	void startDTD(const XMLString& name, const XMLString& publicId, const XMLString& systemId);
+		/// Writes a DTD declaration.
+
+	void endDTD();
+		/// Writes the closing characters of a DTD declaration.
+
+	void startEntity(const XMLString& name);
+		/// Does nothing.
+
+	void endEntity(const XMLString& name);
+		/// Does nothing.
+	
+	// DTDHandler
+	void notationDecl(const XMLString& name, const XMLString* publicId, const XMLString* systemId);
+	void unparsedEntityDecl(const XMLString& name, const XMLString* publicId, const XMLString& systemId, const XMLString& notationName);
+
+	static const std::string NEWLINE_DEFAULT;
+	static const std::string NEWLINE_CR;
+	static const std::string NEWLINE_CRLF;
+	static const std::string NEWLINE_LF;
+
+	// Namespace support.
+	XMLString uniquePrefix();
+		/// Creates and returns a unique namespace prefix that
+		/// can be used with startPrefixMapping().
+
+	bool isNamespaceMapped(const XMLString& namespc) const;
+		/// Returns true if the given namespace has been mapped
+		/// to a prefix in the current element or its ancestors.
+		
+	// Misc.
+	int depth() const;
+		/// Return the number of nested XML elements.
+		///
+		/// Will be -1 if no document or fragment has been started, 
+		/// 0 if the document or fragment has been started,
+		/// 1 if the document element has been written and
+		/// > 1 for every element nested within the document element.
+
+protected:
+	typedef std::map<XMLString, XMLString> AttributeMap;
+	typedef std::map<XMLString, std::pair<XMLString, XMLString>> CanonicalAttributeMap;
+
+	void writeStartElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const Attributes& attributes);
+	void writeCanonicalStartElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const Attributes& attributes);
+	void writeEndElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname);
+	void writeMarkup(const std::string& str) const;
+	void writeXML(const XMLString& str) const;
+	void writeXML(XMLChar ch) const;
+	void writeNewLine() const;
+	void writeIndent() const;
+	void writeIndent(int indent) const;
+	void writeName(const XMLString& prefix, const XMLString& localName);
+	void writeXMLDeclaration();
+	void closeStartTag();
+	void declareNamespaces(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const Attributes& attributes);
+	void declareAttributeNamespaces(const Attributes& attributes);
+	void addNamespaceAttributes(AttributeMap& attributeMap);
+	void addNamespaceAttributes(CanonicalAttributeMap& attributeMap);
+	void addAttributes(AttributeMap& attributeMap, const Attributes& attributes, const XMLString& elementNamespaceURI);
+	void addAttributes(CanonicalAttributeMap& attributeMap, const Attributes& attributes, const XMLString& elementNamespaceURI);
+	void writeAttributes(const AttributeMap& attributeMap);
+	void writeAttributes(const CanonicalAttributeMap& attributeMap);
+	void prettyPrint() const;
+	static std::string nameToString(const XMLString& localName, const XMLString& qname);
+
+private:
+	struct Namespace
+	{
+		Namespace(const XMLString& thePrefix, const XMLString& theNamespaceURI):
+			prefix(thePrefix),
+			namespaceURI(theNamespaceURI)
+		{
+		}
+
+		XMLString prefix;
+		XMLString namespaceURI;
+	};
+	typedef std::vector<Name> ElementStack;
+	
+	Poco::OutputStreamConverter* _pTextConverter;
+	Poco::TextEncoding*          _pInEncoding;
+	Poco::TextEncoding*          _pOutEncoding;
+	int              _options;
+	std::string      _encoding;
+	std::string      _newLine;
+	int              _depth;
+	int              _elementCount;
+	bool             _inFragment;
+	bool             _inCDATA;
+	bool             _inDTD;
+	bool             _inInternalDTD;
+	bool             _contentWritten;
+	bool             _unclosedStartTag;
+	ElementStack     _elementStack;
+	NamespaceSupport _namespaces;
+	int              _prefix;
+	bool             _nsContextPushed;
+	std::string      _indent;
+
+	static const std::string MARKUP_QUOTENC;
+	static const std::string MARKUP_AMPENC;
+	static const std::string MARKUP_LTENC;
+	static const std::string MARKUP_GTENC;
+	static const std::string MARKUP_TABENC;
+	static const std::string MARKUP_CRENC;
+	static const std::string MARKUP_LFENC;
+	static const std::string MARKUP_LT;
+	static const std::string MARKUP_GT;
+	static const std::string MARKUP_SLASHGT;
+	static const std::string MARKUP_LTSLASH;
+	static const std::string MARKUP_COLON;
+	static const std::string MARKUP_EQQUOT;
+	static const std::string MARKUP_QUOT;
+	static const std::string MARKUP_SPACE;
+	static const std::string MARKUP_TAB;
+	static const std::string MARKUP_BEGIN_CDATA;
+	static const std::string MARKUP_END_CDATA;
+};
+
+
+//
+// inlines
+//
+inline int XMLWriter::depth() const
+{
+	return _depth;
+}
+
+
+} } // namespace Poco::XML
+
+
+#endif // XML_XMLWriter_INCLUDED
diff --git a/base/poco/XML/include/Poco/XML/expat.h b/base/poco/XML/include/Poco/XML/expat.h
new file mode 100644
index 00000000000..c9214f64070
--- /dev/null
+++ b/base/poco/XML/include/Poco/XML/expat.h
@@ -0,0 +1,1064 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2000-2005 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2001-2002 Greg Stein <gstein@users.sourceforge.net>
+   Copyright (c) 2002-2016 Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2016-2022 Sebastian Pipping <sebastian@pipping.org>
+   Copyright (c) 2016      Cristian Rodríguez <crrodriguez@opensuse.org>
+   Copyright (c) 2016      Thomas Beutlich <tc@tbeu.de>
+   Copyright (c) 2017      Rhodri James <rhodri@wildebeest.org.uk>
+   Copyright (c) 2022      Thijs Schreijer <thijs@thijsschreijer.nl>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef Expat_INCLUDED
+#define Expat_INCLUDED 1
+
+#include <stdlib.h>
+#include "expat_external.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct XML_ParserStruct;
+typedef struct XML_ParserStruct *XML_Parser;
+
+typedef unsigned char XML_Bool;
+#define XML_TRUE ((XML_Bool)1)
+#define XML_FALSE ((XML_Bool)0)
+
+/* The XML_Status enum gives the possible return values for several
+   API functions.  The preprocessor #defines are included so this
+   stanza can be added to code that still needs to support older
+   versions of Expat 1.95.x:
+
+   #ifndef XML_STATUS_OK
+   #define XML_STATUS_OK    1
+   #define XML_STATUS_ERROR 0
+   #endif
+
+   Otherwise, the #define hackery is quite ugly and would have been
+   dropped.
+*/
+enum XML_Status {
+  XML_STATUS_ERROR = 0,
+#define XML_STATUS_ERROR XML_STATUS_ERROR
+  XML_STATUS_OK = 1,
+#define XML_STATUS_OK XML_STATUS_OK
+  XML_STATUS_SUSPENDED = 2
+#define XML_STATUS_SUSPENDED XML_STATUS_SUSPENDED
+};
+
+enum XML_Error {
+  XML_ERROR_NONE,
+  XML_ERROR_NO_MEMORY,
+  XML_ERROR_SYNTAX,
+  XML_ERROR_NO_ELEMENTS,
+  XML_ERROR_INVALID_TOKEN,
+  XML_ERROR_UNCLOSED_TOKEN,
+  XML_ERROR_PARTIAL_CHAR,
+  XML_ERROR_TAG_MISMATCH,
+  XML_ERROR_DUPLICATE_ATTRIBUTE,
+  XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
+  XML_ERROR_PARAM_ENTITY_REF,
+  XML_ERROR_UNDEFINED_ENTITY,
+  XML_ERROR_RECURSIVE_ENTITY_REF,
+  XML_ERROR_ASYNC_ENTITY,
+  XML_ERROR_BAD_CHAR_REF,
+  XML_ERROR_BINARY_ENTITY_REF,
+  XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
+  XML_ERROR_MISPLACED_XML_PI,
+  XML_ERROR_UNKNOWN_ENCODING,
+  XML_ERROR_INCORRECT_ENCODING,
+  XML_ERROR_UNCLOSED_CDATA_SECTION,
+  XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+  XML_ERROR_NOT_STANDALONE,
+  XML_ERROR_UNEXPECTED_STATE,
+  XML_ERROR_ENTITY_DECLARED_IN_PE,
+  XML_ERROR_FEATURE_REQUIRES_XML_DTD,
+  XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING,
+  /* Added in 1.95.7. */
+  XML_ERROR_UNBOUND_PREFIX,
+  /* Added in 1.95.8. */
+  XML_ERROR_UNDECLARING_PREFIX,
+  XML_ERROR_INCOMPLETE_PE,
+  XML_ERROR_XML_DECL,
+  XML_ERROR_TEXT_DECL,
+  XML_ERROR_PUBLICID,
+  XML_ERROR_SUSPENDED,
+  XML_ERROR_NOT_SUSPENDED,
+  XML_ERROR_ABORTED,
+  XML_ERROR_FINISHED,
+  XML_ERROR_SUSPEND_PE,
+  /* Added in 2.0. */
+  XML_ERROR_RESERVED_PREFIX_XML,
+  XML_ERROR_RESERVED_PREFIX_XMLNS,
+  XML_ERROR_RESERVED_NAMESPACE_URI,
+  /* Added in 2.2.1. */
+  XML_ERROR_INVALID_ARGUMENT,
+  /* Added in 2.3.0. */
+  XML_ERROR_NO_BUFFER,
+  /* Added in 2.4.0. */
+  XML_ERROR_AMPLIFICATION_LIMIT_BREACH
+};
+
+enum XML_Content_Type {
+  XML_CTYPE_EMPTY = 1,
+  XML_CTYPE_ANY,
+  XML_CTYPE_MIXED,
+  XML_CTYPE_NAME,
+  XML_CTYPE_CHOICE,
+  XML_CTYPE_SEQ
+};
+
+enum XML_Content_Quant {
+  XML_CQUANT_NONE,
+  XML_CQUANT_OPT,
+  XML_CQUANT_REP,
+  XML_CQUANT_PLUS
+};
+
+/* If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be
+   XML_CQUANT_NONE, and the other fields will be zero or NULL.
+   If type == XML_CTYPE_MIXED, then quant will be NONE or REP and
+   numchildren will contain number of elements that may be mixed in
+   and children point to an array of XML_Content cells that will be
+   all of XML_CTYPE_NAME type with no quantification.
+
+   If type == XML_CTYPE_NAME, then the name points to the name, and
+   the numchildren field will be zero and children will be NULL. The
+   quant fields indicates any quantifiers placed on the name.
+
+   CHOICE and SEQ will have name NULL, the number of children in
+   numchildren and children will point, recursively, to an array
+   of XML_Content cells.
+
+   The EMPTY, ANY, and MIXED types will only occur at top level.
+*/
+
+typedef struct XML_cp XML_Content;
+
+struct XML_cp {
+  enum XML_Content_Type type;
+  enum XML_Content_Quant quant;
+  XML_Char *name;
+  unsigned int numchildren;
+  XML_Content *children;
+};
+
+/* This is called for an element declaration. See above for
+   description of the model argument. It's the user code's responsibility
+   to free model when finished with it. See XML_FreeContentModel.
+   There is no need to free the model from the handler, it can be kept
+   around and freed at a later stage.
+*/
+typedef void(XMLCALL *XML_ElementDeclHandler)(void *userData,
+                                              const XML_Char *name,
+                                              XML_Content *model);
+
+XMLPARSEAPI(void)
+XML_SetElementDeclHandler(XML_Parser parser, XML_ElementDeclHandler eldecl);
+
+/* The Attlist declaration handler is called for *each* attribute. So
+   a single Attlist declaration with multiple attributes declared will
+   generate multiple calls to this handler. The "default" parameter
+   may be NULL in the case of the "#IMPLIED" or "#REQUIRED"
+   keyword. The "isrequired" parameter will be true and the default
+   value will be NULL in the case of "#REQUIRED". If "isrequired" is
+   true and default is non-NULL, then this is a "#FIXED" default.
+*/
+typedef void(XMLCALL *XML_AttlistDeclHandler)(
+    void *userData, const XML_Char *elname, const XML_Char *attname,
+    const XML_Char *att_type, const XML_Char *dflt, int isrequired);
+
+XMLPARSEAPI(void)
+XML_SetAttlistDeclHandler(XML_Parser parser, XML_AttlistDeclHandler attdecl);
+
+/* The XML declaration handler is called for *both* XML declarations
+   and text declarations. The way to distinguish is that the version
+   parameter will be NULL for text declarations. The encoding
+   parameter may be NULL for XML declarations. The standalone
+   parameter will be -1, 0, or 1 indicating respectively that there
+   was no standalone parameter in the declaration, that it was given
+   as no, or that it was given as yes.
+*/
+typedef void(XMLCALL *XML_XmlDeclHandler)(void *userData,
+                                          const XML_Char *version,
+                                          const XML_Char *encoding,
+                                          int standalone);
+
+XMLPARSEAPI(void)
+XML_SetXmlDeclHandler(XML_Parser parser, XML_XmlDeclHandler xmldecl);
+
+typedef struct {
+  void *(*malloc_fcn)(size_t size);
+  void *(*realloc_fcn)(void *ptr, size_t size);
+  void (*free_fcn)(void *ptr);
+} XML_Memory_Handling_Suite;
+
+/* Constructs a new parser; encoding is the encoding specified by the
+   external protocol or NULL if there is none specified.
+*/
+XMLPARSEAPI(XML_Parser)
+XML_ParserCreate(const XML_Char *encoding);
+
+/* Constructs a new parser and namespace processor.  Element type
+   names and attribute names that belong to a namespace will be
+   expanded; unprefixed attribute names are never expanded; unprefixed
+   element type names are expanded only if there is a default
+   namespace. The expanded name is the concatenation of the namespace
+   URI, the namespace separator character, and the local part of the
+   name.  If the namespace separator is '\0' then the namespace URI
+   and the local part will be concatenated without any separator.
+   It is a programming error to use the separator '\0' with namespace
+   triplets (see XML_SetReturnNSTriplet).
+   If a namespace separator is chosen that can be part of a URI or
+   part of an XML name, splitting an expanded name back into its
+   1, 2 or 3 original parts on application level in the element handler
+   may end up vulnerable, so these are advised against;  sane choices for
+   a namespace separator are e.g. '\n' (line feed) and '|' (pipe).
+
+   Note that Expat does not validate namespace URIs (beyond encoding)
+   against RFC 3986 today (and is not required to do so with regard to
+   the XML 1.0 namespaces specification) but it may start doing that
+   in future releases.  Before that, an application using Expat must
+   be ready to receive namespace URIs containing non-URI characters.
+*/
+XMLPARSEAPI(XML_Parser)
+XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
+
+/* Constructs a new parser using the memory management suite referred to
+   by memsuite. If memsuite is NULL, then use the standard library memory
+   suite. If namespaceSeparator is non-NULL it creates a parser with
+   namespace processing as described above. The character pointed at
+   will serve as the namespace separator.
+
+   All further memory operations used for the created parser will come from
+   the given suite.
+*/
+XMLPARSEAPI(XML_Parser)
+XML_ParserCreate_MM(const XML_Char *encoding,
+                    const XML_Memory_Handling_Suite *memsuite,
+                    const XML_Char *namespaceSeparator);
+
+/* Prepare a parser object to be re-used.  This is particularly
+   valuable when memory allocation overhead is disproportionately high,
+   such as when a large number of small documnents need to be parsed.
+   All handlers are cleared from the parser, except for the
+   unknownEncodingHandler. The parser's external state is re-initialized
+   except for the values of ns and ns_triplets.
+
+   Added in Expat 1.95.3.
+*/
+XMLPARSEAPI(XML_Bool)
+XML_ParserReset(XML_Parser parser, const XML_Char *encoding);
+
+/* atts is array of name/value pairs, terminated by 0;
+   names and values are 0 terminated.
+*/
+typedef void(XMLCALL *XML_StartElementHandler)(void *userData,
+                                               const XML_Char *name,
+                                               const XML_Char **atts);
+
+typedef void(XMLCALL *XML_EndElementHandler)(void *userData,
+                                             const XML_Char *name);
+
+/* s is not 0 terminated. */
+typedef void(XMLCALL *XML_CharacterDataHandler)(void *userData,
+                                                const XML_Char *s, int len);
+
+/* target and data are 0 terminated */
+typedef void(XMLCALL *XML_ProcessingInstructionHandler)(void *userData,
+                                                        const XML_Char *target,
+                                                        const XML_Char *data);
+
+/* data is 0 terminated */
+typedef void(XMLCALL *XML_CommentHandler)(void *userData, const XML_Char *data);
+
+typedef void(XMLCALL *XML_StartCdataSectionHandler)(void *userData);
+typedef void(XMLCALL *XML_EndCdataSectionHandler)(void *userData);
+
+/* This is called for any characters in the XML document for which
+   there is no applicable handler.  This includes both characters that
+   are part of markup which is of a kind that is not reported
+   (comments, markup declarations), or characters that are part of a
+   construct which could be reported but for which no handler has been
+   supplied. The characters are passed exactly as they were in the XML
+   document except that they will be encoded in UTF-8 or UTF-16.
+   Line boundaries are not normalized. Note that a byte order mark
+   character is not passed to the default handler. There are no
+   guarantees about how characters are divided between calls to the
+   default handler: for example, a comment might be split between
+   multiple calls.
+*/
+typedef void(XMLCALL *XML_DefaultHandler)(void *userData, const XML_Char *s,
+                                          int len);
+
+/* This is called for the start of the DOCTYPE declaration, before
+   any DTD or internal subset is parsed.
+*/
+typedef void(XMLCALL *XML_StartDoctypeDeclHandler)(void *userData,
+                                                   const XML_Char *doctypeName,
+                                                   const XML_Char *sysid,
+                                                   const XML_Char *pubid,
+                                                   int has_internal_subset);
+
+/* This is called for the end of the DOCTYPE declaration when the
+   closing > is encountered, but after processing any external
+   subset.
+*/
+typedef void(XMLCALL *XML_EndDoctypeDeclHandler)(void *userData);
+
+/* This is called for entity declarations. The is_parameter_entity
+   argument will be non-zero if the entity is a parameter entity, zero
+   otherwise.
+
+   For internal entities (<!ENTITY foo "bar">), value will
+   be non-NULL and systemId, publicID, and notationName will be NULL.
+   The value string is NOT null-terminated; the length is provided in
+   the value_length argument. Since it is legal to have zero-length
+   values, do not use this argument to test for internal entities.
+
+   For external entities, value will be NULL and systemId will be
+   non-NULL. The publicId argument will be NULL unless a public
+   identifier was provided. The notationName argument will have a
+   non-NULL value only for unparsed entity declarations.
+
+   Note that is_parameter_entity can't be changed to XML_Bool, since
+   that would break binary compatibility.
+*/
+typedef void(XMLCALL *XML_EntityDeclHandler)(
+    void *userData, const XML_Char *entityName, int is_parameter_entity,
+    const XML_Char *value, int value_length, const XML_Char *base,
+    const XML_Char *systemId, const XML_Char *publicId,
+    const XML_Char *notationName);
+
+XMLPARSEAPI(void)
+XML_SetEntityDeclHandler(XML_Parser parser, XML_EntityDeclHandler handler);
+
+/* OBSOLETE -- OBSOLETE -- OBSOLETE
+   This handler has been superseded by the EntityDeclHandler above.
+   It is provided here for backward compatibility.
+
+   This is called for a declaration of an unparsed (NDATA) entity.
+   The base argument is whatever was set by XML_SetBase. The
+   entityName, systemId and notationName arguments will never be
+   NULL. The other arguments may be.
+*/
+typedef void(XMLCALL *XML_UnparsedEntityDeclHandler)(
+    void *userData, const XML_Char *entityName, const XML_Char *base,
+    const XML_Char *systemId, const XML_Char *publicId,
+    const XML_Char *notationName);
+
+/* This is called for a declaration of notation.  The base argument is
+   whatever was set by XML_SetBase. The notationName will never be
+   NULL.  The other arguments can be.
+*/
+typedef void(XMLCALL *XML_NotationDeclHandler)(void *userData,
+                                               const XML_Char *notationName,
+                                               const XML_Char *base,
+                                               const XML_Char *systemId,
+                                               const XML_Char *publicId);
+
+/* When namespace processing is enabled, these are called once for
+   each namespace declaration. The call to the start and end element
+   handlers occur between the calls to the start and end namespace
+   declaration handlers. For an xmlns attribute, prefix will be
+   NULL.  For an xmlns="" attribute, uri will be NULL.
+*/
+typedef void(XMLCALL *XML_StartNamespaceDeclHandler)(void *userData,
+                                                     const XML_Char *prefix,
+                                                     const XML_Char *uri);
+
+typedef void(XMLCALL *XML_EndNamespaceDeclHandler)(void *userData,
+                                                   const XML_Char *prefix);
+
+/* This is called if the document is not standalone, that is, it has an
+   external subset or a reference to a parameter entity, but does not
+   have standalone="yes". If this handler returns XML_STATUS_ERROR,
+   then processing will not continue, and the parser will return a
+   XML_ERROR_NOT_STANDALONE error.
+   If parameter entity parsing is enabled, then in addition to the
+   conditions above this handler will only be called if the referenced
+   entity was actually read.
+*/
+typedef int(XMLCALL *XML_NotStandaloneHandler)(void *userData);
+
+/* This is called for a reference to an external parsed general
+   entity.  The referenced entity is not automatically parsed.  The
+   application can parse it immediately or later using
+   XML_ExternalEntityParserCreate.
+
+   The parser argument is the parser parsing the entity containing the
+   reference; it can be passed as the parser argument to
+   XML_ExternalEntityParserCreate.  The systemId argument is the
+   system identifier as specified in the entity declaration; it will
+   not be NULL.
+
+   The base argument is the system identifier that should be used as
+   the base for resolving systemId if systemId was relative; this is
+   set by XML_SetBase; it may be NULL.
+
+   The publicId argument is the public identifier as specified in the
+   entity declaration, or NULL if none was specified; the whitespace
+   in the public identifier will have been normalized as required by
+   the XML spec.
+
+   The context argument specifies the parsing context in the format
+   expected by the context argument to XML_ExternalEntityParserCreate;
+   context is valid only until the handler returns, so if the
+   referenced entity is to be parsed later, it must be copied.
+   context is NULL only when the entity is a parameter entity.
+
+   The handler should return XML_STATUS_ERROR if processing should not
+   continue because of a fatal error in the handling of the external
+   entity.  In this case the calling parser will return an
+   XML_ERROR_EXTERNAL_ENTITY_HANDLING error.
+
+   Note that unlike other handlers the first argument is the parser,
+   not userData.
+*/
+typedef int(XMLCALL *XML_ExternalEntityRefHandler)(XML_Parser parser,
+                                                   const XML_Char *context,
+                                                   const XML_Char *base,
+                                                   const XML_Char *systemId,
+                                                   const XML_Char *publicId);
+
+/* This is called in two situations:
+   1) An entity reference is encountered for which no declaration
+      has been read *and* this is not an error.
+   2) An internal entity reference is read, but not expanded, because
+      XML_SetDefaultHandler has been called.
+   Note: skipped parameter entities in declarations and skipped general
+         entities in attribute values cannot be reported, because
+         the event would be out of sync with the reporting of the
+         declarations or attribute values
+*/
+typedef void(XMLCALL *XML_SkippedEntityHandler)(void *userData,
+                                                const XML_Char *entityName,
+                                                int is_parameter_entity);
+
+/* This structure is filled in by the XML_UnknownEncodingHandler to
+   provide information to the parser about encodings that are unknown
+   to the parser.
+
+   The map[b] member gives information about byte sequences whose
+   first byte is b.
+
+   If map[b] is c where c is >= 0, then b by itself encodes the
+   Unicode scalar value c.
+
+   If map[b] is -1, then the byte sequence is malformed.
+
+   If map[b] is -n, where n >= 2, then b is the first byte of an
+   n-byte sequence that encodes a single Unicode scalar value.
+
+   The data member will be passed as the first argument to the convert
+   function.
+
+   The convert function is used to convert multibyte sequences; s will
+   point to a n-byte sequence where map[(unsigned char)*s] == -n.  The
+   convert function must return the Unicode scalar value represented
+   by this byte sequence or -1 if the byte sequence is malformed.
+
+   The convert function may be NULL if the encoding is a single-byte
+   encoding, that is if map[b] >= -1 for all bytes b.
+
+   When the parser is finished with the encoding, then if release is
+   not NULL, it will call release passing it the data member; once
+   release has been called, the convert function will not be called
+   again.
+
+   Expat places certain restrictions on the encodings that are supported
+   using this mechanism.
+
+   1. Every ASCII character that can appear in a well-formed XML document,
+      other than the characters
+
+      $@\^`{}~
+
+      must be represented by a single byte, and that byte must be the
+      same byte that represents that character in ASCII.
+
+   2. No character may require more than 4 bytes to encode.
+
+   3. All characters encoded must have Unicode scalar values <=
+      0xFFFF, (i.e., characters that would be encoded by surrogates in
+      UTF-16 are  not allowed).  Note that this restriction doesn't
+      apply to the built-in support for UTF-8 and UTF-16.
+
+   4. No Unicode character may be encoded by more than one distinct
+      sequence of bytes.
+*/
+typedef struct {
+  int map[256];
+  void *data;
+  int(XMLCALL *convert)(void *data, const char *s);
+  void(XMLCALL *release)(void *data);
+} XML_Encoding;
+
+/* This is called for an encoding that is unknown to the parser.
+
+   The encodingHandlerData argument is that which was passed as the
+   second argument to XML_SetUnknownEncodingHandler.
+
+   The name argument gives the name of the encoding as specified in
+   the encoding declaration.
+
+   If the callback can provide information about the encoding, it must
+   fill in the XML_Encoding structure, and return XML_STATUS_OK.
+   Otherwise it must return XML_STATUS_ERROR.
+
+   If info does not describe a suitable encoding, then the parser will
+   return an XML_ERROR_UNKNOWN_ENCODING error.
+*/
+typedef int(XMLCALL *XML_UnknownEncodingHandler)(void *encodingHandlerData,
+                                                 const XML_Char *name,
+                                                 XML_Encoding *info);
+
+XMLPARSEAPI(void)
+XML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start,
+                      XML_EndElementHandler end);
+
+XMLPARSEAPI(void)
+XML_SetStartElementHandler(XML_Parser parser, XML_StartElementHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetEndElementHandler(XML_Parser parser, XML_EndElementHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetCharacterDataHandler(XML_Parser parser,
+                            XML_CharacterDataHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetProcessingInstructionHandler(XML_Parser parser,
+                                    XML_ProcessingInstructionHandler handler);
+XMLPARSEAPI(void)
+XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetCdataSectionHandler(XML_Parser parser,
+                           XML_StartCdataSectionHandler start,
+                           XML_EndCdataSectionHandler end);
+
+XMLPARSEAPI(void)
+XML_SetStartCdataSectionHandler(XML_Parser parser,
+                                XML_StartCdataSectionHandler start);
+
+XMLPARSEAPI(void)
+XML_SetEndCdataSectionHandler(XML_Parser parser,
+                              XML_EndCdataSectionHandler end);
+
+/* This sets the default handler and also inhibits expansion of
+   internal entities. These entity references will be passed to the
+   default handler, or to the skipped entity handler, if one is set.
+*/
+XMLPARSEAPI(void)
+XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler);
+
+/* This sets the default handler but does not inhibit expansion of
+   internal entities.  The entity reference will not be passed to the
+   default handler.
+*/
+XMLPARSEAPI(void)
+XML_SetDefaultHandlerExpand(XML_Parser parser, XML_DefaultHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetDoctypeDeclHandler(XML_Parser parser, XML_StartDoctypeDeclHandler start,
+                          XML_EndDoctypeDeclHandler end);
+
+XMLPARSEAPI(void)
+XML_SetStartDoctypeDeclHandler(XML_Parser parser,
+                               XML_StartDoctypeDeclHandler start);
+
+XMLPARSEAPI(void)
+XML_SetEndDoctypeDeclHandler(XML_Parser parser, XML_EndDoctypeDeclHandler end);
+
+XMLPARSEAPI(void)
+XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
+                                 XML_UnparsedEntityDeclHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetNamespaceDeclHandler(XML_Parser parser,
+                            XML_StartNamespaceDeclHandler start,
+                            XML_EndNamespaceDeclHandler end);
+
+XMLPARSEAPI(void)
+XML_SetStartNamespaceDeclHandler(XML_Parser parser,
+                                 XML_StartNamespaceDeclHandler start);
+
+XMLPARSEAPI(void)
+XML_SetEndNamespaceDeclHandler(XML_Parser parser,
+                               XML_EndNamespaceDeclHandler end);
+
+XMLPARSEAPI(void)
+XML_SetNotStandaloneHandler(XML_Parser parser,
+                            XML_NotStandaloneHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetExternalEntityRefHandler(XML_Parser parser,
+                                XML_ExternalEntityRefHandler handler);
+
+/* If a non-NULL value for arg is specified here, then it will be
+   passed as the first argument to the external entity ref handler
+   instead of the parser object.
+*/
+XMLPARSEAPI(void)
+XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg);
+
+XMLPARSEAPI(void)
+XML_SetSkippedEntityHandler(XML_Parser parser,
+                            XML_SkippedEntityHandler handler);
+
+XMLPARSEAPI(void)
+XML_SetUnknownEncodingHandler(XML_Parser parser,
+                              XML_UnknownEncodingHandler handler,
+                              void *encodingHandlerData);
+
+/* This can be called within a handler for a start element, end
+   element, processing instruction or character data.  It causes the
+   corresponding markup to be passed to the default handler.
+*/
+XMLPARSEAPI(void)
+XML_DefaultCurrent(XML_Parser parser);
+
+/* If do_nst is non-zero, and namespace processing is in effect, and
+   a name has a prefix (i.e. an explicit namespace qualifier) then
+   that name is returned as a triplet in a single string separated by
+   the separator character specified when the parser was created: URI
+   + sep + local_name + sep + prefix.
+
+   If do_nst is zero, then namespace information is returned in the
+   default manner (URI + sep + local_name) whether or not the name
+   has a prefix.
+
+   Note: Calling XML_SetReturnNSTriplet after XML_Parse or
+     XML_ParseBuffer has no effect.
+*/
+
+XMLPARSEAPI(void)
+XML_SetReturnNSTriplet(XML_Parser parser, int do_nst);
+
+/* This value is passed as the userData argument to callbacks. */
+XMLPARSEAPI(void)
+XML_SetUserData(XML_Parser parser, void *userData);
+
+/* Returns the last value set by XML_SetUserData or NULL. */
+#define XML_GetUserData(parser) (*(void **)(parser))
+
+/* This is equivalent to supplying an encoding argument to
+   XML_ParserCreate. On success XML_SetEncoding returns non-zero,
+   zero otherwise.
+   Note: Calling XML_SetEncoding after XML_Parse or XML_ParseBuffer
+     has no effect and returns XML_STATUS_ERROR.
+*/
+XMLPARSEAPI(enum XML_Status)
+XML_SetEncoding(XML_Parser parser, const XML_Char *encoding);
+
+/* If this function is called, then the parser will be passed as the
+   first argument to callbacks instead of userData.  The userData will
+   still be accessible using XML_GetUserData.
+*/
+XMLPARSEAPI(void)
+XML_UseParserAsHandlerArg(XML_Parser parser);
+
+/* If useDTD == XML_TRUE is passed to this function, then the parser
+   will assume that there is an external subset, even if none is
+   specified in the document. In such a case the parser will call the
+   externalEntityRefHandler with a value of NULL for the systemId
+   argument (the publicId and context arguments will be NULL as well).
+   Note: For the purpose of checking WFC: Entity Declared, passing
+     useDTD == XML_TRUE will make the parser behave as if the document
+     had a DTD with an external subset.
+   Note: If this function is called, then this must be done before
+     the first call to XML_Parse or XML_ParseBuffer, since it will
+     have no effect after that.  Returns
+     XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING.
+   Note: If the document does not have a DOCTYPE declaration at all,
+     then startDoctypeDeclHandler and endDoctypeDeclHandler will not
+     be called, despite an external subset being parsed.
+   Note: If XML_DTD is not defined when Expat is compiled, returns
+     XML_ERROR_FEATURE_REQUIRES_XML_DTD.
+   Note: If parser == NULL, returns XML_ERROR_INVALID_ARGUMENT.
+*/
+XMLPARSEAPI(enum XML_Error)
+XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD);
+
+/* Sets the base to be used for resolving relative URIs in system
+   identifiers in declarations.  Resolving relative identifiers is
+   left to the application: this value will be passed through as the
+   base argument to the XML_ExternalEntityRefHandler,
+   XML_NotationDeclHandler and XML_UnparsedEntityDeclHandler. The base
+   argument will be copied.  Returns XML_STATUS_ERROR if out of memory,
+   XML_STATUS_OK otherwise.
+*/
+XMLPARSEAPI(enum XML_Status)
+XML_SetBase(XML_Parser parser, const XML_Char *base);
+
+XMLPARSEAPI(const XML_Char *)
+XML_GetBase(XML_Parser parser);
+
+/* Returns the number of the attribute/value pairs passed in last call
+   to the XML_StartElementHandler that were specified in the start-tag
+   rather than defaulted. Each attribute/value pair counts as 2; thus
+   this corresponds to an index into the atts array passed to the
+   XML_StartElementHandler.  Returns -1 if parser == NULL.
+*/
+XMLPARSEAPI(int)
+XML_GetSpecifiedAttributeCount(XML_Parser parser);
+
+/* Returns the index of the ID attribute passed in the last call to
+   XML_StartElementHandler, or -1 if there is no ID attribute or
+   parser == NULL.  Each attribute/value pair counts as 2; thus this
+   corresponds to an index into the atts array passed to the
+   XML_StartElementHandler.
+*/
+XMLPARSEAPI(int)
+XML_GetIdAttributeIndex(XML_Parser parser);
+
+#ifdef XML_ATTR_INFO
+/* Source file byte offsets for the start and end of attribute names and values.
+   The value indices are exclusive of surrounding quotes; thus in a UTF-8 source
+   file an attribute value of "blah" will yield:
+   info->valueEnd - info->valueStart = 4 bytes.
+*/
+typedef struct {
+  XML_Index nameStart;  /* Offset to beginning of the attribute name. */
+  XML_Index nameEnd;    /* Offset after the attribute name's last byte. */
+  XML_Index valueStart; /* Offset to beginning of the attribute value. */
+  XML_Index valueEnd;   /* Offset after the attribute value's last byte. */
+} XML_AttrInfo;
+
+/* Returns an array of XML_AttrInfo structures for the attribute/value pairs
+   passed in last call to the XML_StartElementHandler that were specified
+   in the start-tag rather than defaulted. Each attribute/value pair counts
+   as 1; thus the number of entries in the array is
+   XML_GetSpecifiedAttributeCount(parser) / 2.
+*/
+XMLPARSEAPI(const XML_AttrInfo *)
+XML_GetAttributeInfo(XML_Parser parser);
+#endif
+
+/* Parses some input. Returns XML_STATUS_ERROR if a fatal error is
+   detected.  The last call to XML_Parse must have isFinal true; len
+   may be zero for this call (or any other).
+
+   Though the return values for these functions has always been
+   described as a Boolean value, the implementation, at least for the
+   1.95.x series, has always returned exactly one of the XML_Status
+   values.
+*/
+XMLPARSEAPI(enum XML_Status)
+XML_Parse(XML_Parser parser, const char *s, int len, int isFinal);
+
+XMLPARSEAPI(void *)
+XML_GetBuffer(XML_Parser parser, int len);
+
+XMLPARSEAPI(enum XML_Status)
+XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
+
+/* Stops parsing, causing XML_Parse() or XML_ParseBuffer() to return.
+   Must be called from within a call-back handler, except when aborting
+   (resumable = 0) an already suspended parser. Some call-backs may
+   still follow because they would otherwise get lost. Examples:
+   - endElementHandler() for empty elements when stopped in
+     startElementHandler(),
+   - endNameSpaceDeclHandler() when stopped in endElementHandler(),
+   and possibly others.
+
+   Can be called from most handlers, including DTD related call-backs,
+   except when parsing an external parameter entity and resumable != 0.
+   Returns XML_STATUS_OK when successful, XML_STATUS_ERROR otherwise.
+   Possible error codes:
+   - XML_ERROR_SUSPENDED: when suspending an already suspended parser.
+   - XML_ERROR_FINISHED: when the parser has already finished.
+   - XML_ERROR_SUSPEND_PE: when suspending while parsing an external PE.
+
+   When resumable != 0 (true) then parsing is suspended, that is,
+   XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED.
+   Otherwise, parsing is aborted, that is, XML_Parse() and XML_ParseBuffer()
+   return XML_STATUS_ERROR with error code XML_ERROR_ABORTED.
+
+   *Note*:
+   This will be applied to the current parser instance only, that is, if
+   there is a parent parser then it will continue parsing when the
+   externalEntityRefHandler() returns. It is up to the implementation of
+   the externalEntityRefHandler() to call XML_StopParser() on the parent
+   parser (recursively), if one wants to stop parsing altogether.
+
+   When suspended, parsing can be resumed by calling XML_ResumeParser().
+*/
+XMLPARSEAPI(enum XML_Status)
+XML_StopParser(XML_Parser parser, XML_Bool resumable);
+
+/* Resumes parsing after it has been suspended with XML_StopParser().
+   Must not be called from within a handler call-back. Returns same
+   status codes as XML_Parse() or XML_ParseBuffer().
+   Additional error code XML_ERROR_NOT_SUSPENDED possible.
+
+   *Note*:
+   This must be called on the most deeply nested child parser instance
+   first, and on its parent parser only after the child parser has finished,
+   to be applied recursively until the document entity's parser is restarted.
+   That is, the parent parser will not resume by itself and it is up to the
+   application to call XML_ResumeParser() on it at the appropriate moment.
+*/
+XMLPARSEAPI(enum XML_Status)
+XML_ResumeParser(XML_Parser parser);
+
+enum XML_Parsing { XML_INITIALIZED, XML_PARSING, XML_FINISHED, XML_SUSPENDED };
+
+typedef struct {
+  enum XML_Parsing parsing;
+  XML_Bool finalBuffer;
+} XML_ParsingStatus;
+
+/* Returns status of parser with respect to being initialized, parsing,
+   finished, or suspended and processing the final buffer.
+   XXX XML_Parse() and XML_ParseBuffer() should return XML_ParsingStatus,
+   XXX with XML_FINISHED_OK or XML_FINISHED_ERROR replacing XML_FINISHED
+*/
+XMLPARSEAPI(void)
+XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status);
+
+/* Creates an XML_Parser object that can parse an external general
+   entity; context is a '\0'-terminated string specifying the parse
+   context; encoding is a '\0'-terminated string giving the name of
+   the externally specified encoding, or NULL if there is no
+   externally specified encoding.  The context string consists of a
+   sequence of tokens separated by formfeeds (\f); a token consisting
+   of a name specifies that the general entity of the name is open; a
+   token of the form prefix=uri specifies the namespace for a
+   particular prefix; a token of the form =uri specifies the default
+   namespace.  This can be called at any point after the first call to
+   an ExternalEntityRefHandler so longer as the parser has not yet
+   been freed.  The new parser is completely independent and may
+   safely be used in a separate thread.  The handlers and userData are
+   initialized from the parser argument.  Returns NULL if out of memory.
+   Otherwise returns a new XML_Parser object.
+*/
+XMLPARSEAPI(XML_Parser)
+XML_ExternalEntityParserCreate(XML_Parser parser, const XML_Char *context,
+                               const XML_Char *encoding);
+
+enum XML_ParamEntityParsing {
+  XML_PARAM_ENTITY_PARSING_NEVER,
+  XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE,
+  XML_PARAM_ENTITY_PARSING_ALWAYS
+};
+
+/* Controls parsing of parameter entities (including the external DTD
+   subset). If parsing of parameter entities is enabled, then
+   references to external parameter entities (including the external
+   DTD subset) will be passed to the handler set with
+   XML_SetExternalEntityRefHandler.  The context passed will be 0.
+
+   Unlike external general entities, external parameter entities can
+   only be parsed synchronously.  If the external parameter entity is
+   to be parsed, it must be parsed during the call to the external
+   entity ref handler: the complete sequence of
+   XML_ExternalEntityParserCreate, XML_Parse/XML_ParseBuffer and
+   XML_ParserFree calls must be made during this call.  After
+   XML_ExternalEntityParserCreate has been called to create the parser
+   for the external parameter entity (context must be 0 for this
+   call), it is illegal to make any calls on the old parser until
+   XML_ParserFree has been called on the newly created parser.
+   If the library has been compiled without support for parameter
+   entity parsing (ie without XML_DTD being defined), then
+   XML_SetParamEntityParsing will return 0 if parsing of parameter
+   entities is requested; otherwise it will return non-zero.
+   Note: If XML_SetParamEntityParsing is called after XML_Parse or
+      XML_ParseBuffer, then it has no effect and will always return 0.
+   Note: If parser == NULL, the function will do nothing and return 0.
+*/
+XMLPARSEAPI(int)
+XML_SetParamEntityParsing(XML_Parser parser,
+                          enum XML_ParamEntityParsing parsing);
+
+/* Sets the hash salt to use for internal hash calculations.
+   Helps in preventing DoS attacks based on predicting hash
+   function behavior. This must be called before parsing is started.
+   Returns 1 if successful, 0 when called after parsing has started.
+   Note: If parser == NULL, the function will do nothing and return 0.
+*/
+XMLPARSEAPI(int)
+XML_SetHashSalt(XML_Parser parser, unsigned long hash_salt);
+
+/* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then
+   XML_GetErrorCode returns information about the error.
+*/
+XMLPARSEAPI(enum XML_Error)
+XML_GetErrorCode(XML_Parser parser);
+
+/* These functions return information about the current parse
+   location.  They may be called from any callback called to report
+   some parse event; in this case the location is the location of the
+   first of the sequence of characters that generated the event.  When
+   called from callbacks generated by declarations in the document
+   prologue, the location identified isn't as neatly defined, but will
+   be within the relevant markup.  When called outside of the callback
+   functions, the position indicated will be just past the last parse
+   event (regardless of whether there was an associated callback).
+
+   They may also be called after returning from a call to XML_Parse
+   or XML_ParseBuffer.  If the return value is XML_STATUS_ERROR then
+   the location is the location of the character at which the error
+   was detected; otherwise the location is the location of the last
+   parse event, as described above.
+
+   Note: XML_GetCurrentLineNumber and XML_GetCurrentColumnNumber
+   return 0 to indicate an error.
+   Note: XML_GetCurrentByteIndex returns -1 to indicate an error.
+*/
+XMLPARSEAPI(XML_Size) XML_GetCurrentLineNumber(XML_Parser parser);
+XMLPARSEAPI(XML_Size) XML_GetCurrentColumnNumber(XML_Parser parser);
+XMLPARSEAPI(XML_Index) XML_GetCurrentByteIndex(XML_Parser parser);
+
+/* Return the number of bytes in the current event.
+   Returns 0 if the event is in an internal entity.
+*/
+XMLPARSEAPI(int)
+XML_GetCurrentByteCount(XML_Parser parser);
+
+/* If XML_CONTEXT_BYTES is defined, returns the input buffer, sets
+   the integer pointed to by offset to the offset within this buffer
+   of the current parse position, and sets the integer pointed to by size
+   to the size of this buffer (the number of input bytes). Otherwise
+   returns a NULL pointer. Also returns a NULL pointer if a parse isn't
+   active.
+
+   NOTE: The character pointer returned should not be used outside
+   the handler that makes the call.
+*/
+XMLPARSEAPI(const char *)
+XML_GetInputContext(XML_Parser parser, int *offset, int *size);
+
+/* For backwards compatibility with previous versions. */
+#define XML_GetErrorLineNumber XML_GetCurrentLineNumber
+#define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber
+#define XML_GetErrorByteIndex XML_GetCurrentByteIndex
+
+/* Frees the content model passed to the element declaration handler */
+XMLPARSEAPI(void)
+XML_FreeContentModel(XML_Parser parser, XML_Content *model);
+
+/* Exposing the memory handling functions used in Expat */
+XMLPARSEAPI(void *)
+XML_ATTR_MALLOC
+XML_ATTR_ALLOC_SIZE(2)
+XML_MemMalloc(XML_Parser parser, size_t size);
+
+XMLPARSEAPI(void *)
+XML_ATTR_ALLOC_SIZE(3)
+XML_MemRealloc(XML_Parser parser, void *ptr, size_t size);
+
+XMLPARSEAPI(void)
+XML_MemFree(XML_Parser parser, void *ptr);
+
+/* Frees memory used by the parser. */
+XMLPARSEAPI(void)
+XML_ParserFree(XML_Parser parser);
+
+/* Returns a string describing the error. */
+XMLPARSEAPI(const XML_LChar *)
+XML_ErrorString(enum XML_Error code);
+
+/* Return a string containing the version number of this expat */
+XMLPARSEAPI(const XML_LChar *)
+XML_ExpatVersion(void);
+
+typedef struct {
+  int major;
+  int minor;
+  int micro;
+} XML_Expat_Version;
+
+/* Return an XML_Expat_Version structure containing numeric version
+   number information for this version of expat.
+*/
+XMLPARSEAPI(XML_Expat_Version)
+XML_ExpatVersionInfo(void);
+
+/* Added in Expat 1.95.5. */
+enum XML_FeatureEnum {
+  XML_FEATURE_END = 0,
+  XML_FEATURE_UNICODE,
+  XML_FEATURE_UNICODE_WCHAR_T,
+  XML_FEATURE_DTD,
+  XML_FEATURE_CONTEXT_BYTES,
+  XML_FEATURE_MIN_SIZE,
+  XML_FEATURE_SIZEOF_XML_CHAR,
+  XML_FEATURE_SIZEOF_XML_LCHAR,
+  XML_FEATURE_NS,
+  XML_FEATURE_LARGE_SIZE,
+  XML_FEATURE_ATTR_INFO,
+  /* Added in Expat 2.4.0. */
+  XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT,
+  XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT
+  /* Additional features must be added to the end of this enum. */
+};
+
+typedef struct {
+  enum XML_FeatureEnum feature;
+  const XML_LChar *name;
+  long int value;
+} XML_Feature;
+
+XMLPARSEAPI(const XML_Feature *)
+XML_GetFeatureList(void);
+
+#ifdef XML_DTD
+/* Added in Expat 2.4.0. */
+XMLPARSEAPI(XML_Bool)
+XML_SetBillionLaughsAttackProtectionMaximumAmplification(
+    XML_Parser parser, float maximumAmplificationFactor);
+
+/* Added in Expat 2.4.0. */
+XMLPARSEAPI(XML_Bool)
+XML_SetBillionLaughsAttackProtectionActivationThreshold(
+    XML_Parser parser, unsigned long long activationThresholdBytes);
+#endif
+
+/* Expat follows the semantic versioning convention.
+   See http://semver.org.
+*/
+#define XML_MAJOR_VERSION 2
+#define XML_MINOR_VERSION 4
+#define XML_MICRO_VERSION 7
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not Expat_INCLUDED */
diff --git a/base/poco/XML/include/Poco/XML/expat_external.h b/base/poco/XML/include/Poco/XML/expat_external.h
new file mode 100644
index 00000000000..8829f770910
--- /dev/null
+++ b/base/poco/XML/include/Poco/XML/expat_external.h
@@ -0,0 +1,165 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2000-2004 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2001-2002 Greg Stein <gstein@users.sourceforge.net>
+   Copyright (c) 2002-2006 Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2016      Cristian Rodríguez <crrodriguez@opensuse.org>
+   Copyright (c) 2016-2019 Sebastian Pipping <sebastian@pipping.org>
+   Copyright (c) 2017      Rhodri James <rhodri@wildebeest.org.uk>
+   Copyright (c) 2018      Yury Gribov <tetra2005@gmail.com>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef Expat_External_INCLUDED
+#define Expat_External_INCLUDED 1
+
+/* External API definitions */
+
+/* Expat tries very hard to make the API boundary very specifically
+   defined.  There are two macros defined to control this boundary;
+   each of these can be defined before including this header to
+   achieve some different behavior, but doing so it not recommended or
+   tested frequently.
+
+   XMLCALL    - The calling convention to use for all calls across the
+                "library boundary."  This will default to cdecl, and
+                try really hard to tell the compiler that's what we
+                want.
+
+   XMLIMPORT  - Whatever magic is needed to note that a function is
+                to be imported from a dynamically loaded library
+                (.dll, .so, or .sl, depending on your platform).
+
+   The XMLCALL macro was added in Expat 1.95.7.  The only one which is
+   expected to be directly useful in client code is XMLCALL.
+
+   Note that on at least some Unix versions, the Expat library must be
+   compiled with the cdecl calling convention as the default since
+   system headers may assume the cdecl convention.
+*/
+#ifndef XMLCALL
+#  if defined(_MSC_VER)
+#    define XMLCALL __cdecl
+#  elif defined(__GNUC__) && defined(__i386) && ! defined(__INTEL_COMPILER)
+#    define XMLCALL __attribute__((cdecl))
+#  else
+/* For any platform which uses this definition and supports more than
+   one calling convention, we need to extend this definition to
+   declare the convention used on that platform, if it's possible to
+   do so.
+
+   If this is the case for your platform, please file a bug report
+   with information on how to identify your platform via the C
+   pre-processor and how to specify the same calling convention as the
+   platform's malloc() implementation.
+*/
+#    define XMLCALL
+#  endif
+#endif /* not defined XMLCALL */
+
+#if ! defined(XML_STATIC) && ! defined(XMLIMPORT)
+#  ifndef XML_BUILDING_EXPAT
+/* using Expat from an application */
+
+#    if defined(_MSC_EXTENSIONS) && ! defined(__BEOS__) && ! defined(__CYGWIN__)
+#      define XMLIMPORT __declspec(dllimport)
+#    endif
+
+#  endif
+#endif /* not defined XML_STATIC */
+
+#ifndef XML_ENABLE_VISIBILITY
+#  define XML_ENABLE_VISIBILITY 0
+#endif
+
+#if ! defined(XMLIMPORT) && XML_ENABLE_VISIBILITY
+#  define XMLIMPORT __attribute__((visibility("default")))
+#endif
+
+/* If we didn't define it above, define it away: */
+#ifndef XMLIMPORT
+#  define XMLIMPORT
+#endif
+
+#if defined(__GNUC__)                                                          \
+    && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96))
+#  define XML_ATTR_MALLOC __attribute__((__malloc__))
+#else
+#  define XML_ATTR_MALLOC
+#endif
+
+#if defined(__GNUC__)                                                          \
+    && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+#  define XML_ATTR_ALLOC_SIZE(x) __attribute__((__alloc_size__(x)))
+#else
+#  define XML_ATTR_ALLOC_SIZE(x)
+#endif
+
+#define XMLPARSEAPI(type) XMLIMPORT type XMLCALL
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef XML_UNICODE_WCHAR_T
+#  ifndef XML_UNICODE
+#    define XML_UNICODE
+#  endif
+#  if defined(__SIZEOF_WCHAR_T__) && (__SIZEOF_WCHAR_T__ != 2)
+#    error "sizeof(wchar_t) != 2; Need -fshort-wchar for both Expat and libc"
+#  endif
+#endif
+
+#ifdef XML_UNICODE /* Information is UTF-16 encoded. */
+#  ifdef XML_UNICODE_WCHAR_T
+typedef wchar_t XML_Char;
+typedef wchar_t XML_LChar;
+#  else
+typedef unsigned short XML_Char;
+typedef char XML_LChar;
+#  endif /* XML_UNICODE_WCHAR_T */
+#else    /* Information is UTF-8 encoded. */
+typedef char XML_Char;
+typedef char XML_LChar;
+#endif   /* XML_UNICODE */
+
+#ifdef XML_LARGE_SIZE /* Use large integers for file/stream positions. */
+typedef long long XML_Index;
+typedef unsigned long long XML_Size;
+#else
+typedef long XML_Index;
+typedef unsigned long XML_Size;
+#endif /* XML_LARGE_SIZE */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not Expat_External_INCLUDED */
diff --git a/base/poco/XML/src/AbstractContainerNode.cpp b/base/poco/XML/src/AbstractContainerNode.cpp
new file mode 100644
index 00000000000..f808331419e
--- /dev/null
+++ b/base/poco/XML/src/AbstractContainerNode.cpp
@@ -0,0 +1,580 @@
+//
+// AbstractContainerNode.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/AbstractContainerNode.h"
+#include "Poco/DOM/Document.h"
+#include "Poco/DOM/Element.h"
+#include "Poco/DOM/Attr.h"
+#include "Poco/DOM/DOMException.h"
+#include "Poco/DOM/ElementsByTagNameList.h"
+#include "Poco/DOM/AutoPtr.h"
+#include "Poco/NumberParser.h"
+#include "Poco/UnicodeConverter.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+const XMLString AbstractContainerNode::WILDCARD(toXMLString("*"));
+
+
+AbstractContainerNode::AbstractContainerNode(Document* pOwnerDocument):
+	AbstractNode(pOwnerDocument),
+	_pFirstChild(0)
+{
+}
+
+
+AbstractContainerNode::AbstractContainerNode(Document* pOwnerDocument, const AbstractContainerNode& node):
+	AbstractNode(pOwnerDocument, node),
+	_pFirstChild(0)
+{
+}
+
+
+AbstractContainerNode::~AbstractContainerNode()
+{
+	AbstractNode* pChild = static_cast<AbstractNode*>(_pFirstChild);
+	while (pChild)
+	{
+		AbstractNode* pDelNode = pChild;
+		pChild = pChild->_pNext;
+		pDelNode->_pNext   = 0;
+		pDelNode->_pParent = 0;
+		pDelNode->release();
+	}
+}
+
+
+Node* AbstractContainerNode::firstChild() const
+{
+	return _pFirstChild;
+}
+
+
+Node* AbstractContainerNode::lastChild() const
+{
+	AbstractNode* pChild = _pFirstChild;
+	if (pChild)
+	{
+		while (pChild->_pNext) pChild = pChild->_pNext;
+		return pChild;
+	}
+	return 0;
+}
+
+
+Node* AbstractContainerNode::insertBefore(Node* newChild, Node* refChild)
+{
+	poco_check_ptr (newChild);
+
+	if (static_cast<AbstractNode*>(newChild)->_pOwner != _pOwner && static_cast<AbstractNode*>(newChild)->_pOwner != this)
+		throw DOMException(DOMException::WRONG_DOCUMENT_ERR);
+	if (refChild && static_cast<AbstractNode*>(refChild)->_pParent != this)
+		throw DOMException(DOMException::NOT_FOUND_ERR);
+	if (newChild == refChild)
+		return newChild;
+	if (this == newChild)
+		throw DOMException(DOMException::HIERARCHY_REQUEST_ERR);
+
+	AbstractNode* pFirst = 0;
+	AbstractNode* pLast  = 0;
+	if (newChild->nodeType() == Node::DOCUMENT_FRAGMENT_NODE)
+	{
+		AbstractContainerNode* pFrag = static_cast<AbstractContainerNode*>(newChild);
+		pFirst = pFrag->_pFirstChild;
+		pLast  = pFirst;
+		if (pFirst)
+		{
+			while (pLast->_pNext)
+			{
+				pLast->_pParent = this;
+				pLast = pLast->_pNext;
+			}
+			pLast->_pParent = this;
+		}
+		pFrag->_pFirstChild = 0;
+	}
+	else
+	{
+		newChild->duplicate();
+		AbstractContainerNode* pParent = static_cast<AbstractNode*>(newChild)->_pParent;
+		if (pParent) pParent->removeChild(newChild);
+		pFirst = static_cast<AbstractNode*>(newChild);
+		pLast  = pFirst;
+		pFirst->_pParent = this;
+	}
+	if (_pFirstChild && pFirst)
+	{
+		AbstractNode* pCur = _pFirstChild;
+		if (pCur == refChild)
+		{
+			pLast->_pNext = _pFirstChild;
+			_pFirstChild  = pFirst;
+		}
+		else
+		{
+			while (pCur && pCur->_pNext != refChild) pCur = pCur->_pNext;
+			if (pCur)
+			{
+				pLast->_pNext = pCur->_pNext;
+				pCur->_pNext = pFirst;
+			}
+			else throw DOMException(DOMException::NOT_FOUND_ERR);
+		}
+	}
+	else _pFirstChild = pFirst;
+
+	if (events())
+	{
+		while (pFirst && pFirst != pLast->_pNext)
+		{
+			pFirst->dispatchNodeInserted();
+			pFirst->dispatchNodeInsertedIntoDocument();
+			pFirst = pFirst->_pNext;
+		}
+		dispatchSubtreeModified();
+	}
+	return newChild;
+}
+
+
+Node* AbstractContainerNode::replaceChild(Node* newChild, Node* oldChild)
+{
+	poco_check_ptr (newChild);
+	poco_check_ptr (oldChild);
+
+	if (static_cast<AbstractNode*>(newChild)->_pOwner != _pOwner && static_cast<AbstractNode*>(newChild)->_pOwner != this)
+		throw DOMException(DOMException::WRONG_DOCUMENT_ERR);
+	if (static_cast<AbstractNode*>(oldChild)->_pParent != this)
+		throw DOMException(DOMException::NOT_FOUND_ERR);
+	if (newChild == oldChild)
+		return newChild;
+	if (this == newChild)
+		throw DOMException(DOMException::HIERARCHY_REQUEST_ERR);
+
+	bool doEvents = events();
+	if (newChild->nodeType() == Node::DOCUMENT_FRAGMENT_NODE)
+	{
+		insertBefore(newChild, oldChild);
+		removeChild(oldChild);
+	}
+	else
+	{
+		AbstractContainerNode* pParent = static_cast<AbstractNode*>(newChild)->_pParent;
+		if (pParent) pParent->removeChild(newChild);
+
+		if (oldChild == _pFirstChild)
+		{
+			if (doEvents)
+			{
+				_pFirstChild->dispatchNodeRemoved();
+				_pFirstChild->dispatchNodeRemovedFromDocument();
+			}
+			static_cast<AbstractNode*>(newChild)->_pNext   = static_cast<AbstractNode*>(oldChild)->_pNext;
+			static_cast<AbstractNode*>(newChild)->_pParent = this;
+			_pFirstChild->_pNext   = 0;
+			_pFirstChild->_pParent = 0;
+			_pFirstChild = static_cast<AbstractNode*>(newChild);
+			if (doEvents)
+			{
+				static_cast<AbstractNode*>(newChild)->dispatchNodeInserted();
+				static_cast<AbstractNode*>(newChild)->dispatchNodeInsertedIntoDocument();
+			}
+		}
+		else
+		{
+			AbstractNode* pCur = _pFirstChild;
+			while (pCur && pCur->_pNext != oldChild) pCur = pCur->_pNext;
+			if (pCur)
+			{
+				poco_assert_dbg (pCur->_pNext == oldChild);
+
+				if (doEvents)
+				{
+					static_cast<AbstractNode*>(oldChild)->dispatchNodeRemoved();
+					static_cast<AbstractNode*>(oldChild)->dispatchNodeRemovedFromDocument();
+				}
+				static_cast<AbstractNode*>(newChild)->_pNext   = static_cast<AbstractNode*>(oldChild)->_pNext;
+				static_cast<AbstractNode*>(newChild)->_pParent = this;
+				static_cast<AbstractNode*>(oldChild)->_pNext   = 0;
+				static_cast<AbstractNode*>(oldChild)->_pParent = 0;
+				pCur->_pNext = static_cast<AbstractNode*>(newChild);
+				if (doEvents)
+				{
+					static_cast<AbstractNode*>(newChild)->dispatchNodeInserted();
+					static_cast<AbstractNode*>(newChild)->dispatchNodeInsertedIntoDocument();
+				}
+			}
+			else throw DOMException(DOMException::NOT_FOUND_ERR);
+		}
+		newChild->duplicate();
+		oldChild->autoRelease();
+	}
+	if (doEvents) dispatchSubtreeModified();
+	return oldChild;
+}
+
+
+Node* AbstractContainerNode::removeChild(Node* oldChild)
+{
+	poco_check_ptr (oldChild);
+
+	bool doEvents = events();
+	if (oldChild == _pFirstChild)
+	{
+		if (doEvents)
+		{
+			static_cast<AbstractNode*>(oldChild)->dispatchNodeRemoved();
+			static_cast<AbstractNode*>(oldChild)->dispatchNodeRemovedFromDocument();
+		}
+		_pFirstChild = _pFirstChild->_pNext;
+		static_cast<AbstractNode*>(oldChild)->_pNext   = 0;
+		static_cast<AbstractNode*>(oldChild)->_pParent = 0;
+	}
+	else
+	{
+		AbstractNode* pCur = _pFirstChild;
+		while (pCur && pCur->_pNext != oldChild) pCur = pCur->_pNext;
+		if (pCur)
+		{
+			if (doEvents)
+			{
+				static_cast<AbstractNode*>(oldChild)->dispatchNodeRemoved();
+				static_cast<AbstractNode*>(oldChild)->dispatchNodeRemovedFromDocument();
+			}
+			pCur->_pNext = pCur->_pNext->_pNext;
+			static_cast<AbstractNode*>(oldChild)->_pNext   = 0;
+			static_cast<AbstractNode*>(oldChild)->_pParent = 0;
+		}
+		else throw DOMException(DOMException::NOT_FOUND_ERR);
+	}
+	oldChild->autoRelease();
+	if (doEvents) dispatchSubtreeModified();
+	return oldChild;
+}
+
+
+Node* AbstractContainerNode::appendChild(Node* newChild)
+{
+	return insertBefore(newChild, 0);
+}
+
+
+void AbstractContainerNode::dispatchNodeRemovedFromDocument()
+{
+	AbstractNode::dispatchNodeRemovedFromDocument();
+	Node* pChild = firstChild();
+	while (pChild)
+	{
+		static_cast<AbstractNode*>(pChild)->dispatchNodeRemovedFromDocument();
+		pChild = pChild->nextSibling();
+	}
+}
+
+
+void AbstractContainerNode::dispatchNodeInsertedIntoDocument()
+{
+	AbstractNode::dispatchNodeInsertedIntoDocument();
+	Node* pChild = firstChild();
+	while (pChild)
+	{
+		static_cast<AbstractNode*>(pChild)->dispatchNodeInsertedIntoDocument();
+		pChild = pChild->nextSibling();
+	}
+}
+
+
+bool AbstractContainerNode::hasChildNodes() const
+{
+	return _pFirstChild != 0;
+}
+
+
+bool AbstractContainerNode::hasAttributes() const
+{
+	return false;
+}
+
+
+Node* AbstractContainerNode::getNodeByPath(const XMLString& path) const
+{
+	bool indexBound;
+	XMLString::const_iterator it = path.begin();
+	if (it != path.end() && *it == '/')
+	{
+		++it;
+		if (it != path.end() && *it == '/')
+		{
+			++it;
+			XMLString name;
+			while (it != path.end() && *it != '/' && *it != '@' && *it != '[') name += *it++;
+			if (it != path.end() && *it == '/') ++it;
+			if (name.empty()) name = WILDCARD;
+			AutoPtr<ElementsByTagNameList> pList = new ElementsByTagNameList(this, name);
+			unsigned long length = pList->length();
+			for (unsigned long i = 0; i < length; i++)
+			{
+				XMLString::const_iterator beg = it;
+				const Node* pNode = findNode(beg, path.end(), pList->item(i), 0, indexBound);
+				if (pNode) return const_cast<Node*>(pNode);
+			}
+			return 0;
+		}
+	}
+	return const_cast<Node*>(findNode(it, path.end(), this, 0, indexBound));
+}
+
+
+Node* AbstractContainerNode::getNodeByPathNS(const XMLString& path, const NSMap& nsMap) const
+{
+	bool indexBound;
+	XMLString::const_iterator it = path.begin();
+	if (it != path.end() && *it == '/')
+	{
+		++it;
+		if (it != path.end() && *it == '/')
+		{
+			++it;
+			XMLString name;
+			while (it != path.end() && *it != '/' && *it != '@' && *it != '[') name += *it++;
+			if (it != path.end() && *it == '/') ++it;
+			XMLString namespaceURI;
+			XMLString localName;
+			bool nameOK = true;
+			if (name.empty())
+			{
+				namespaceURI = WILDCARD;
+				localName = WILDCARD;
+			}
+			else
+			{
+				nameOK = nsMap.processName(name, namespaceURI, localName, false);
+			}
+			if (nameOK)
+			{
+				AutoPtr<ElementsByTagNameListNS> pList = new ElementsByTagNameListNS(this, namespaceURI, localName);
+				unsigned long length = pList->length();
+				for (unsigned long i = 0; i < length; i++)
+				{
+					XMLString::const_iterator beg = it;
+					const Node* pNode = findNode(beg, path.end(), pList->item(i), &nsMap, indexBound);
+					if (pNode) return const_cast<Node*>(pNode);
+				}
+			}
+			return 0;
+		}
+	}
+	return const_cast<Node*>(findNode(it, path.end(), this, &nsMap, indexBound));
+}
+
+
+const Node* AbstractContainerNode::findNode(XMLString::const_iterator& it, const XMLString::const_iterator& end, const Node* pNode, const NSMap* pNSMap, bool& indexBound)
+{
+	indexBound = false;
+	if (pNode && it != end)
+	{
+		if (*it == '[')
+		{
+			++it;
+			if (it != end && *it == '@')
+			{
+				++it;
+				XMLString attr;
+				while (it != end && *it != ']' && *it != '=') attr += *it++;
+				if (it != end && *it == '=')
+				{
+					++it;
+					XMLString value;
+					if (it != end && *it == '\'')
+					{
+						++it;
+						while (it != end && *it != '\'') value += *it++;
+						if (it != end) ++it;
+					}
+					else
+					{
+						while (it != end && *it != ']') value += *it++;
+					}
+					if (it != end) ++it;
+					bool ib;
+					return findNode(it, end, findElement(attr, value, pNode, pNSMap), pNSMap, ib);
+				}
+				else
+				{
+					if (it != end) ++it;
+					return findAttribute(attr, pNode, pNSMap);
+				}
+			}
+			else
+			{
+				XMLString xmlIndex;
+				while (it != end && *it != ']') xmlIndex += *it++;
+				if (it != end) ++it;
+#ifdef XML_UNICODE_WCHAR_T
+				std::string index;
+				Poco::UnicodeConverter::convert(xmlIndex, index);
+				int i = Poco::NumberParser::parse(index);
+#else
+				int i = Poco::NumberParser::parse(xmlIndex);
+#endif
+				indexBound = true;
+				bool ib;
+				return findNode(it, end, findElement(i, pNode, pNSMap), pNSMap, ib);
+			}
+		}
+		else
+		{
+			while (it != end && *it == '/') ++it;
+			XMLString key;
+			while (it != end && *it != '/' && *it != '[') key += *it++;
+
+			XMLString::const_iterator itStart(it);
+			const Node* pFound = 0;
+			const Node* pElem = findElement(key, pNode->firstChild(), pNSMap);
+			while (!pFound && pElem)
+			{
+				bool ib;
+				pFound = findNode(it, end, pElem, pNSMap, ib);
+				if (!pFound) pElem = ib ? nullptr : findElement(key, pElem->nextSibling(), pNSMap);
+				it = itStart;
+			}
+			return pFound;
+		}
+	}
+	else return pNode;
+}
+
+
+const Node* AbstractContainerNode::findElement(const XMLString& name, const Node* pNode, const NSMap* pNSMap)
+{
+	while (pNode)
+	{
+		if (pNode->nodeType() == Node::ELEMENT_NODE && namesAreEqual(pNode, name, pNSMap))
+			return pNode;
+		pNode = pNode->nextSibling();
+	}
+	return 0;
+}
+
+
+const Node* AbstractContainerNode::findElement(int index, const Node* pNode, const NSMap* pNSMap)
+{
+	const Node* pRefNode = pNode;
+	if (index > 0)
+	{
+		pNode = pNode->nextSibling();
+		while (pNode)
+		{
+			if (namesAreEqual(pNode, pRefNode, pNSMap))
+			{
+				if (--index == 0) break;
+			}
+			pNode = pNode->nextSibling();
+		}
+	}
+	return pNode;
+}
+
+
+const Node* AbstractContainerNode::findElement(const XMLString& attr, const XMLString& value, const Node* pNode, const NSMap* pNSMap)
+{
+	const Node* pRefNode = pNode;
+	const Element* pElem = dynamic_cast<const Element*>(pNode);
+	if (!(pElem && pElem->hasAttributeValue(attr, value, pNSMap)))
+	{
+		pNode = pNode->nextSibling();
+		while (pNode)
+		{
+			if (namesAreEqual(pNode, pRefNode, pNSMap))
+			{
+				pElem = dynamic_cast<const Element*>(pNode);
+				if (pElem && pElem->hasAttributeValue(attr, value, pNSMap)) break;
+			}
+			pNode = pNode->nextSibling();
+		}
+	}
+	return pNode;
+}
+
+
+const Attr* AbstractContainerNode::findAttribute(const XMLString& name, const Node* pNode, const NSMap* pNSMap)
+{
+	const Attr* pResult(0);
+	const Element* pElem = dynamic_cast<const Element*>(pNode);
+	if (pElem)
+	{
+		if (pNSMap)
+		{
+			XMLString namespaceURI;
+			XMLString localName;
+			if (pNSMap->processName(name, namespaceURI, localName, true))
+			{
+				pResult = pElem->getAttributeNodeNS(namespaceURI, localName);
+			}
+		}
+		else
+		{
+			pResult = pElem->getAttributeNode(name);
+		}
+	}
+	return pResult;
+}
+
+
+bool AbstractContainerNode::hasAttributeValue(const XMLString& name, const XMLString& value, const NSMap* pNSMap) const
+{
+	const Attr* pAttr = findAttribute(name, this, pNSMap);
+	return pAttr && pAttr->getValue() == value;
+}
+
+
+bool AbstractContainerNode::namesAreEqual(const Node* pNode1, const Node* pNode2, const NSMap* pNSMap)
+{
+	if (pNSMap)
+	{
+		return pNode1->localName() == pNode2->localName() && pNode1->namespaceURI() == pNode2->namespaceURI();
+	}
+	else
+	{
+		return pNode1->nodeName() == pNode2->nodeName();
+	}
+}
+
+
+bool AbstractContainerNode::namesAreEqual(const Node* pNode, const XMLString& name, const NSMap* pNSMap)
+{
+	if (pNSMap)
+	{
+		XMLString namespaceURI;
+		XMLString localName;
+		if (name == WILDCARD)
+		{
+			return true;
+		}
+		else if (pNSMap->processName(name, namespaceURI, localName, false))
+		{
+			return (pNode->namespaceURI() == namespaceURI || namespaceURI == WILDCARD) && (pNode->localName() == localName || localName == WILDCARD);
+		}
+		else return false;
+	}
+	else
+	{
+		return pNode->nodeName() == name || name == WILDCARD;
+	}
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/AbstractNode.cpp b/base/poco/XML/src/AbstractNode.cpp
new file mode 100644
index 00000000000..d1c4912eacf
--- /dev/null
+++ b/base/poco/XML/src/AbstractNode.cpp
@@ -0,0 +1,367 @@
+//
+// AbstractNode.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/AbstractNode.h"
+#include "Poco/DOM/Document.h"
+#include "Poco/DOM/ChildNodesList.h"
+#include "Poco/DOM/EventDispatcher.h"
+#include "Poco/DOM/DOMException.h"
+#include "Poco/DOM/EventException.h"
+#include "Poco/DOM/DOMImplementation.h"
+#include "Poco/DOM/Attr.h"
+#include "Poco/XML/Name.h"
+#include "Poco/DOM/AutoPtr.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+const XMLString AbstractNode::NODE_NAME = toXMLString("#node");
+const XMLString AbstractNode::EMPTY_STRING;
+
+
+AbstractNode::AbstractNode(Document* pOwnerDocument):
+	_pParent(0),
+	_pNext(0),
+	_pOwner(pOwnerDocument),
+	_pEventDispatcher(0)
+{
+}
+
+
+AbstractNode::AbstractNode(Document* pOwnerDocument, const AbstractNode& node):
+	_pParent(0),
+	_pNext(0),
+	_pOwner(pOwnerDocument),
+	_pEventDispatcher(0)
+{
+}
+
+
+AbstractNode::~AbstractNode()
+{
+	delete _pEventDispatcher;
+	if (_pNext) _pNext->release();
+}
+
+
+void AbstractNode::autoRelease()
+{
+	_pOwner->autoReleasePool().add(this);
+}
+
+
+const XMLString& AbstractNode::nodeName() const
+{
+	return NODE_NAME;
+}
+
+
+const XMLString& AbstractNode::getNodeValue() const
+{
+	return EMPTY_STRING;
+}
+
+
+void AbstractNode::setNodeValue(const XMLString& value)
+{
+	throw DOMException(DOMException::NO_DATA_ALLOWED_ERR);
+}
+
+
+Node* AbstractNode::parentNode() const
+{
+	return _pParent;
+}
+
+
+NodeList* AbstractNode::childNodes() const
+{
+	return new ChildNodesList(this);
+}
+
+
+Node* AbstractNode::firstChild() const
+{
+	return 0;
+}
+
+
+Node* AbstractNode::lastChild() const
+{
+	return 0;
+}
+
+
+Node* AbstractNode::previousSibling() const
+{
+	if (_pParent)
+	{
+		AbstractNode* pSibling = _pParent->_pFirstChild;
+		while (pSibling)
+		{
+		    if (pSibling->_pNext == this) return pSibling;
+		    pSibling = pSibling->_pNext;
+		}
+	}
+	return 0;
+}
+
+
+Node* AbstractNode::nextSibling() const
+{
+	return _pNext;
+}
+
+
+NamedNodeMap* AbstractNode::attributes() const
+{
+	return 0;
+}
+
+
+Document* AbstractNode::ownerDocument() const
+{
+	return _pOwner;
+}
+
+
+Node* AbstractNode::insertBefore(Node* newChild, Node* refChild)
+{
+	throw DOMException(DOMException::HIERARCHY_REQUEST_ERR);
+}
+
+
+Node* AbstractNode::replaceChild(Node* newChild, Node* oldChild)
+{
+	throw DOMException(DOMException::HIERARCHY_REQUEST_ERR);
+}
+
+
+Node* AbstractNode::removeChild(Node* oldChild)
+{
+	throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
+}
+
+
+Node* AbstractNode::appendChild(Node* newChild)
+{
+	throw DOMException(DOMException::HIERARCHY_REQUEST_ERR);
+}
+
+
+bool AbstractNode::hasChildNodes() const
+{
+	return false;
+}
+
+
+Node* AbstractNode::cloneNode(bool deep) const
+{
+	return copyNode(deep, _pOwner);
+}
+
+
+void AbstractNode::normalize()
+{
+}
+
+
+bool AbstractNode::isSupported(const XMLString& feature, const XMLString& version) const
+{
+	return DOMImplementation::instance().hasFeature(feature, version);
+}
+
+
+const XMLString& AbstractNode::namespaceURI() const
+{
+	return EMPTY_STRING;
+}
+
+
+XMLString AbstractNode::prefix() const
+{
+	return EMPTY_STRING;
+}
+
+
+const XMLString& AbstractNode::localName() const
+{
+	return EMPTY_STRING;
+}
+
+
+bool AbstractNode::hasAttributes() const
+{
+	return false;
+}
+
+
+XMLString AbstractNode::innerText() const
+{
+	return EMPTY_STRING;
+}
+
+
+Node* AbstractNode::getNodeByPath(const XMLString& path) const
+{
+	return 0;
+}
+
+
+Node* AbstractNode::getNodeByPathNS(const XMLString& path, const NSMap& nsMap) const
+{
+	return 0;
+}
+
+
+void AbstractNode::addEventListener(const XMLString& type, EventListener* listener, bool useCapture)
+{
+	if (_pEventDispatcher)
+		_pEventDispatcher->removeEventListener(type, listener, useCapture);
+	else
+		_pEventDispatcher = new EventDispatcher;
+	
+	_pEventDispatcher->addEventListener(type, listener, useCapture);
+}
+
+
+void AbstractNode::removeEventListener(const XMLString& type, EventListener* listener, bool useCapture)
+{
+	if (_pEventDispatcher)
+		_pEventDispatcher->removeEventListener(type, listener, useCapture);
+}
+
+
+bool AbstractNode::dispatchEvent(Event* evt)
+{
+	if (eventsSuspended()) return true;
+
+	if (evt->type().empty()) throw EventException(EventException::UNSPECIFIED_EVENT_TYPE_ERR);
+
+	evt->setTarget(this);
+	evt->setCurrentPhase(Event::CAPTURING_PHASE);
+
+	if (_pParent) _pParent->captureEvent(evt);
+
+	if (_pEventDispatcher && !evt->isStopped())
+	{
+		evt->setCurrentPhase(Event::AT_TARGET);
+		evt->setCurrentTarget(this);
+		_pEventDispatcher->dispatchEvent(evt);
+	}
+	if (!evt->isStopped() && evt->bubbles() && _pParent)
+	{
+		evt->setCurrentPhase(Event::BUBBLING_PHASE);
+		_pParent->bubbleEvent(evt);
+	}
+
+	return evt->isCanceled();
+}
+
+
+void AbstractNode::captureEvent(Event* evt)
+{
+	if (_pParent)
+		_pParent->captureEvent(evt);
+	
+	if (_pEventDispatcher && !evt->isStopped())
+	{
+		evt->setCurrentTarget(this);
+		_pEventDispatcher->captureEvent(evt);
+	}
+}
+
+
+void AbstractNode::bubbleEvent(Event* evt)
+{
+	evt->setCurrentTarget(this);
+	if (_pEventDispatcher)
+	{
+		_pEventDispatcher->bubbleEvent(evt);
+	}
+	if (_pParent && !evt->isStopped())
+		_pParent->bubbleEvent(evt);
+}
+
+
+void AbstractNode::dispatchSubtreeModified()
+{
+	AutoPtr<MutationEvent> pEvent = new MutationEvent(_pOwner, MutationEvent::DOMSubtreeModified, this, true, false, 0);
+	dispatchEvent(pEvent.get());
+}
+
+
+void AbstractNode::dispatchNodeInserted()
+{
+	AutoPtr<MutationEvent> pEvent = new MutationEvent(_pOwner, MutationEvent::DOMNodeInserted, this, true, false, parentNode());
+	dispatchEvent(pEvent.get());
+}
+
+
+void AbstractNode::dispatchNodeRemoved()
+{
+	AutoPtr<MutationEvent> pEvent = new MutationEvent(_pOwner, MutationEvent::DOMNodeRemoved, this, true, false, parentNode());
+	dispatchEvent(pEvent.get());
+}
+
+
+void AbstractNode::dispatchNodeRemovedFromDocument()
+{
+	AutoPtr<MutationEvent> pEvent = new MutationEvent(_pOwner, MutationEvent::DOMNodeRemovedFromDocument, this, false, false, 0);
+	dispatchEvent(pEvent.get());
+}
+
+
+void AbstractNode::dispatchNodeInsertedIntoDocument()
+{
+	AutoPtr<MutationEvent> pEvent = new MutationEvent(_pOwner, MutationEvent::DOMNodeInsertedIntoDocument, this, false, false, 0);
+	dispatchEvent(pEvent.get());
+}
+
+
+void AbstractNode::dispatchAttrModified(Attr* pAttr, MutationEvent::AttrChangeType changeType, const XMLString& prevValue, const XMLString& newValue)
+{
+	AutoPtr<MutationEvent> pEvent = new MutationEvent(_pOwner, MutationEvent::DOMAttrModified, this, true, false, pAttr, prevValue, newValue, pAttr->name(), changeType);
+	dispatchEvent(pEvent.get());
+}
+
+
+void AbstractNode::dispatchCharacterDataModified(const XMLString& prevValue, const XMLString& newValue)
+{
+	AutoPtr<MutationEvent> pEvent = new MutationEvent(_pOwner, MutationEvent::DOMCharacterDataModified, this, true, false, 0, prevValue, newValue, EMPTY_STRING, MutationEvent::MODIFICATION);
+	dispatchEvent(pEvent.get());
+}
+
+
+bool AbstractNode::events() const
+{
+	return _pOwner->events();
+}
+
+
+bool AbstractNode::eventsSuspended() const
+{
+	return _pOwner->eventsSuspended();
+}
+
+
+void AbstractNode::setOwnerDocument(Document* pOwnerDocument)
+{
+	_pOwner = pOwnerDocument;
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/Attr.cpp b/base/poco/XML/src/Attr.cpp
new file mode 100644
index 00000000000..b5e22dd824a
--- /dev/null
+++ b/base/poco/XML/src/Attr.cpp
@@ -0,0 +1,133 @@
+//
+// Attr.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/Attr.h"
+#include "Poco/DOM/Document.h"
+#include "Poco/XML/NamePool.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+Attr::Attr(Document* pOwnerDocument, Element* pOwnerElement, const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const XMLString& value, bool specified):
+	AbstractNode(pOwnerDocument),
+	_name(pOwnerDocument->namePool().insert(qname, namespaceURI, localName)),
+	_value(value),
+	_specified(specified)
+{
+}
+
+
+Attr::Attr(Document* pOwnerDocument, const Attr& attr): 
+	AbstractNode(pOwnerDocument, attr),
+	_name(pOwnerDocument->namePool().insert(attr._name)),
+	_value(attr._value),
+	_specified(attr._specified)
+{
+}
+
+
+Attr::~Attr()
+{
+}
+
+
+void Attr::setValue(const XMLString& value)
+{
+	XMLString oldValue = _value;
+	_value     = value;
+	_specified = true;
+	if (_pParent && !_pOwner->eventsSuspended())
+		_pParent->dispatchAttrModified(this, MutationEvent::MODIFICATION, oldValue, value);
+}
+
+
+Node* Attr::parentNode() const
+{
+	return 0;
+}
+
+
+Node* Attr::previousSibling() const
+{
+	if (_pParent)
+	{
+		Attr* pSibling = static_cast<Element*>(_pParent)->_pFirstAttr;
+		while (pSibling)
+		{
+		    if (pSibling->_pNext == const_cast<Attr*>(this)) return pSibling;
+		    pSibling = static_cast<Attr*>(pSibling->_pNext);
+		}
+		return pSibling;
+	}
+	return 0;
+}
+
+
+const XMLString& Attr::nodeName() const
+{
+	return _name.qname();
+}
+
+
+const XMLString& Attr::getNodeValue() const
+{
+	return _value;
+}
+
+
+void Attr::setNodeValue(const XMLString& value)
+{
+	setValue(value);
+}
+
+
+unsigned short Attr::nodeType() const
+{
+	return ATTRIBUTE_NODE;
+}
+
+
+const XMLString& Attr::namespaceURI() const
+{
+	return _name.namespaceURI();
+}
+
+
+XMLString Attr::prefix() const
+{
+	return _name.prefix();
+}
+
+
+const XMLString& Attr::localName() const
+{
+	return _name.localName();
+}
+
+
+XMLString Attr::innerText() const
+{
+	return nodeValue();
+}
+
+
+Node* Attr::copyNode(bool deep, Document* pOwnerDocument) const
+{
+	return new Attr(pOwnerDocument, *this);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/AttrMap.cpp b/base/poco/XML/src/AttrMap.cpp
new file mode 100644
index 00000000000..cb3a24133dc
--- /dev/null
+++ b/base/poco/XML/src/AttrMap.cpp
@@ -0,0 +1,123 @@
+//
+// AttrMap.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/AttrMap.h"
+#include "Poco/DOM/Attr.h"
+#include "Poco/DOM/Element.h"
+#include "Poco/DOM/Document.h"
+#include "Poco/DOM/DOMException.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+AttrMap::AttrMap(Element* pElement):
+	_pElement(pElement)
+{
+	poco_check_ptr (pElement);
+	
+	_pElement->duplicate();
+}
+
+
+AttrMap::~AttrMap()
+{
+	_pElement->release();
+}
+
+
+Node* AttrMap::getNamedItem(const XMLString& name) const
+{
+	return _pElement->getAttributeNode(name);
+}
+
+
+Node* AttrMap::setNamedItem(Node* arg)
+{
+	poco_check_ptr (arg);
+
+	if (arg->nodeType() != Node::ATTRIBUTE_NODE)
+		throw DOMException(DOMException::HIERARCHY_REQUEST_ERR);
+		
+	return _pElement->setAttributeNode(static_cast<Attr*>(arg));
+}
+
+
+Node* AttrMap::removeNamedItem(const XMLString& name)
+{
+	Attr* pAttr = _pElement->getAttributeNode(name);
+	if (pAttr)
+		return _pElement->removeAttributeNode(pAttr);
+	else
+		return 0;
+}
+
+
+Node* AttrMap::item(unsigned long index) const
+{
+	AbstractNode* pAttr = _pElement->_pFirstAttr;
+	while (index-- > 0 && pAttr) pAttr = static_cast<AbstractNode*>(pAttr->nextSibling());
+	return pAttr;
+}
+
+
+unsigned long AttrMap::length() const
+{
+	unsigned long result = 0;
+	AbstractNode* pAttr = _pElement->_pFirstAttr;
+	while (pAttr) 
+	{
+		pAttr = static_cast<AbstractNode*>(pAttr->nextSibling());
+		++result;
+	}
+	return result;
+}
+
+
+Node* AttrMap::getNamedItemNS(const XMLString& namespaceURI, const XMLString& localName) const
+{
+	return _pElement->getAttributeNodeNS(namespaceURI, localName);
+}
+
+
+Node* AttrMap::setNamedItemNS(Node* arg)
+{
+	poco_check_ptr (arg);
+
+	if (arg->nodeType() != Node::ATTRIBUTE_NODE)
+		throw DOMException(DOMException::HIERARCHY_REQUEST_ERR);
+
+	return _pElement->setAttributeNodeNS(static_cast<Attr*>(arg));
+}
+
+
+Node* AttrMap::removeNamedItemNS(const XMLString& namespaceURI, const XMLString& localName)
+{
+	Attr* pAttr = _pElement->getAttributeNodeNS(namespaceURI, localName);
+	if (pAttr)
+		return _pElement->removeAttributeNode(pAttr);
+	else
+		return 0;
+}
+
+
+void AttrMap::autoRelease()
+{
+	_pElement->ownerDocument()->autoReleasePool().add(this);
+}
+
+
+} } // namespace Poco::XML
+
diff --git a/base/poco/XML/src/Attributes.cpp b/base/poco/XML/src/Attributes.cpp
new file mode 100644
index 00000000000..f2baf9ff20e
--- /dev/null
+++ b/base/poco/XML/src/Attributes.cpp
@@ -0,0 +1,27 @@
+//
+// Attributes.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/Attributes.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+Attributes::~Attributes()
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/AttributesImpl.cpp b/base/poco/XML/src/AttributesImpl.cpp
new file mode 100644
index 00000000000..fe5b24ff2c3
--- /dev/null
+++ b/base/poco/XML/src/AttributesImpl.cpp
@@ -0,0 +1,299 @@
+//
+// AttributesImpl.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/AttributesImpl.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+AttributesImpl::EmptyAttribute::EmptyAttribute()
+{
+	specified = false;
+	type = XML_LIT("CDATA");
+}
+
+
+AttributesImpl::EmptyAttribute AttributesImpl::_empty;
+
+
+AttributesImpl::AttributesImpl()
+{
+}
+
+
+AttributesImpl::AttributesImpl(const Attributes& attributes)
+{
+	setAttributes(attributes);
+}
+
+
+AttributesImpl::AttributesImpl(const AttributesImpl& attributes):
+	_attributes(attributes._attributes)
+{
+}
+
+
+AttributesImpl::AttributesImpl(AttributesImpl&& attributes) noexcept:
+	_attributes(std::move(attributes._attributes))
+{
+}
+
+
+AttributesImpl::~AttributesImpl()
+{
+}
+
+
+AttributesImpl& AttributesImpl::operator = (const AttributesImpl& attributes)
+{
+	if (&attributes != this)
+	{
+		_attributes = attributes._attributes;
+	}
+	return *this;
+}
+
+
+AttributesImpl& AttributesImpl::operator = (AttributesImpl&& attributes) noexcept
+{
+	_attributes = std::move(attributes._attributes);
+
+	return *this;
+}
+
+
+int AttributesImpl::getIndex(const XMLString& qname) const
+{
+	int i = 0;
+	AttributeVec::const_iterator it;
+	for (it = _attributes.begin(); it != _attributes.end(); ++it)
+	{
+		if (it->qname == qname) return i;
+		++i;
+	}
+	return -1;
+}
+
+
+int AttributesImpl::getIndex(const XMLString& namespaceURI, const XMLString& localName) const
+{
+	int i = 0;
+	AttributeVec::const_iterator it;
+	for (it = _attributes.begin(); it != _attributes.end(); ++it)
+	{
+		if (it->namespaceURI == namespaceURI && it->localName == localName) return i;
+		++i;
+	}
+	return -1;
+}
+
+
+void AttributesImpl::setValue(int i, const XMLString& value)
+{
+	poco_assert (0 <= i && i < static_cast<int>(_attributes.size()));
+	_attributes[i].value     = value;
+	_attributes[i].specified = true;
+}
+
+
+void AttributesImpl::setValue(const XMLString& qname, const XMLString& value)
+{
+	Attribute* pAttr = find(qname);
+	if (pAttr)
+	{
+		pAttr->value     = value;
+		pAttr->specified = true;
+	}
+}
+
+
+void AttributesImpl::setValue(const XMLString& namespaceURI, const XMLString& localName, const XMLString& value)
+{
+	Attribute* pAttr = find(namespaceURI, localName);
+	if (pAttr)
+	{
+		pAttr->value     = value;
+		pAttr->specified = true;
+	}
+}
+
+
+void AttributesImpl::setAttributes(const Attributes& attributes)
+{
+	if (&attributes != this)
+	{
+		int count = attributes.getLength();
+		_attributes.clear();
+		_attributes.reserve(count);
+		for (int i = 0; i < count; i++)
+		{
+			addAttribute(attributes.getURI(i), attributes.getLocalName(i), attributes.getQName(i), attributes.getType(i), attributes.getValue(i));
+		}
+	}
+}
+
+
+void AttributesImpl::setAttribute(int i, const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const XMLString& type, const XMLString& value)
+{
+	poco_assert (0 <= i && i < static_cast<int>(_attributes.size()));
+	_attributes[i].namespaceURI = namespaceURI;
+	_attributes[i].localName    = localName;
+	_attributes[i].qname        = qname;
+	_attributes[i].type         = type;
+	_attributes[i].value        = value;
+	_attributes[i].specified    = true;
+}
+
+
+void AttributesImpl::addAttribute(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const XMLString& type, const XMLString& value)
+{
+	AttributeVec::iterator it = _attributes.insert(_attributes.end(), Attribute());
+	it->namespaceURI = namespaceURI;
+	it->localName    = localName;
+	it->qname        = qname;
+	it->value        = value;
+	it->type         = type;
+	it->specified    = true;
+}
+
+
+void AttributesImpl::addAttribute(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const XMLString& type, const XMLString& value, bool specified)
+{
+	AttributeVec::iterator it = _attributes.insert(_attributes.end(), Attribute());
+	it->namespaceURI = namespaceURI;
+	it->localName    = localName;
+	it->qname        = qname;
+	it->value        = value;
+	it->type         = type;
+	it->specified    = specified;
+}
+
+
+void AttributesImpl::addAttribute(const XMLChar* namespaceURI, const XMLChar* localName, const XMLChar* qname, const XMLChar* type, const XMLChar* value, bool specified)
+{
+	AttributeVec::iterator it = _attributes.insert(_attributes.end(), Attribute());
+	it->namespaceURI = namespaceURI;
+	it->localName    = localName;
+	it->qname        = qname;
+	it->value        = value;
+	it->type         = type;
+	it->specified    = specified;
+}
+
+
+void AttributesImpl::removeAttribute(int i)
+{
+	int cur = 0;
+	for (AttributeVec::iterator it = _attributes.begin(); it != _attributes.end(); ++it, ++cur)
+	{
+		if (cur == i)
+		{
+			_attributes.erase(it);
+			break;
+		}
+	}
+}
+
+
+void AttributesImpl::removeAttribute(const XMLString& qname)
+{
+	for (AttributeVec::iterator it = _attributes.begin(); it != _attributes.end(); ++it)
+	{
+		if (it->qname == qname)
+		{
+			_attributes.erase(it);
+			break;
+		}
+	}
+}
+
+
+void AttributesImpl::removeAttribute(const XMLString& namespaceURI, const XMLString& localName)
+{
+	for (AttributeVec::iterator it = _attributes.begin(); it != _attributes.end(); ++it)
+	{
+		if (it->namespaceURI == namespaceURI && it->localName == localName)
+		{
+			_attributes.erase(it);
+			break;
+		}
+	}
+}
+
+
+void AttributesImpl::clear()
+{
+	_attributes.clear();
+}
+
+
+void AttributesImpl::reserve(std::size_t capacity)
+{
+	_attributes.reserve(capacity);
+}
+
+
+void AttributesImpl::setLocalName(int i, const XMLString& localName)
+{
+	poco_assert (0 <= i && i < static_cast<int>(_attributes.size()));
+	_attributes[i].localName = localName;
+}
+
+
+void AttributesImpl::setQName(int i, const XMLString& qname)
+{
+	poco_assert (0 <= i && i < static_cast<int>(_attributes.size()));
+	_attributes[i].qname = qname;
+}
+
+
+void AttributesImpl::setType(int i, const XMLString& type)
+{
+	poco_assert (0 <= i && i < static_cast<int>(_attributes.size()));
+	_attributes[i].type = type;
+}
+
+
+void AttributesImpl::setURI(int i, const XMLString& namespaceURI)
+{
+	poco_assert (0 <= i && i < static_cast<int>(_attributes.size()));
+	_attributes[i].namespaceURI = namespaceURI;
+}
+
+
+AttributesImpl::Attribute* AttributesImpl::find(const XMLString& qname) const
+{
+	for (AttributeVec::const_iterator it = _attributes.begin(); it != _attributes.end(); ++it)
+	{
+		if (it->qname == qname) 
+			return const_cast<Attribute*>(&(*it));
+	}
+	return 0;
+}
+
+
+AttributesImpl::Attribute* AttributesImpl::find(const XMLString& namespaceURI, const XMLString& localName) const
+{
+	for (AttributeVec::const_iterator it = _attributes.begin(); it != _attributes.end(); ++it)
+	{
+		if (it->namespaceURI == namespaceURI && it->localName == localName) 
+			return const_cast<Attribute*>(&(*it));
+	}
+	return 0;
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/CDATASection.cpp b/base/poco/XML/src/CDATASection.cpp
new file mode 100644
index 00000000000..229582e14cd
--- /dev/null
+++ b/base/poco/XML/src/CDATASection.cpp
@@ -0,0 +1,74 @@
+//
+// CDATASection.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/CDATASection.h"
+#include "Poco/DOM/Document.h"
+#include "Poco/DOM/DOMException.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+const XMLString CDATASection::NODE_NAME = toXMLString("#cdata-section");
+
+
+CDATASection::CDATASection(Document* pOwnerDocument, const XMLString& data): 
+	Text(pOwnerDocument, data)
+{
+}
+
+
+CDATASection::CDATASection(Document* pOwnerDocument, const CDATASection& sec): 
+	Text(pOwnerDocument, sec)
+{
+}
+
+
+CDATASection::~CDATASection()
+{
+}
+
+
+Text* CDATASection::splitText(unsigned long offset)
+{
+	Node* pParent = parentNode();
+	if (!pParent) throw DOMException(DOMException::HIERARCHY_REQUEST_ERR);
+	int n = length() - offset;
+	Text* pNew = ownerDocument()->createCDATASection(substringData(offset, n));
+	deleteData(offset, n);
+	pParent->insertBefore(pNew, nextSibling())->release();
+	return pNew;
+}
+
+
+const XMLString& CDATASection::nodeName() const
+{
+	return NODE_NAME;
+}
+
+
+unsigned short CDATASection::nodeType() const
+{
+	return Node::CDATA_SECTION_NODE;
+}
+
+
+Node* CDATASection::copyNode(bool deep, Document* pOwnerDocument) const
+{
+	return new CDATASection(pOwnerDocument, *this);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/CharacterData.cpp b/base/poco/XML/src/CharacterData.cpp
new file mode 100644
index 00000000000..f8a3ec324d4
--- /dev/null
+++ b/base/poco/XML/src/CharacterData.cpp
@@ -0,0 +1,152 @@
+//
+// CharacterData.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/CharacterData.h"
+#include "Poco/DOM/DOMException.h"
+#include "Poco/String.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+CharacterData::CharacterData(Document* pOwnerDocument, const XMLString& data): 
+	AbstractNode(pOwnerDocument),
+	_data(data)
+{
+}
+
+
+CharacterData::CharacterData(Document* pOwnerDocument, const CharacterData& data): 
+	AbstractNode(pOwnerDocument, data),
+	_data(data._data)
+{
+}
+
+
+CharacterData::~CharacterData()
+{
+}
+
+
+void CharacterData::setData(const XMLString& data)
+{
+	if (events())
+	{
+		XMLString oldData = _data;
+		_data = data;
+		dispatchCharacterDataModified(oldData, _data);
+	}
+	else
+	{
+		_data = data;
+	}
+}
+
+
+XMLString CharacterData::substringData(unsigned long offset, unsigned long count) const
+{
+	if (offset >= _data.length())
+		throw DOMException(DOMException::INDEX_SIZE_ERR);
+
+	return _data.substr(offset, count);
+}
+
+
+void CharacterData::appendData(const XMLString& arg)
+{
+	if (events())
+	{
+		XMLString oldData = _data;
+		_data.append(arg);
+		dispatchCharacterDataModified(oldData, _data);
+	}
+	else
+	{
+		_data.append(arg);
+	}
+}
+
+
+void CharacterData::insertData(unsigned long offset, const XMLString& arg)
+{
+	if (offset > _data.length())
+		throw DOMException(DOMException::INDEX_SIZE_ERR);
+
+	if (events())
+	{
+		XMLString oldData = _data;
+		_data.insert(offset, arg);
+		dispatchCharacterDataModified(oldData, _data);
+	}
+	else
+	{
+		_data.insert(offset, arg);
+	}
+}
+
+
+void CharacterData::deleteData(unsigned long offset, unsigned long count)
+{
+	if (offset >= _data.length())
+		throw DOMException(DOMException::INDEX_SIZE_ERR);
+
+	if (events())
+	{
+		XMLString oldData = _data;
+		_data.replace(offset, count, EMPTY_STRING);
+		dispatchCharacterDataModified(oldData, _data);
+	}
+	else
+		_data.replace(offset, count, EMPTY_STRING);
+}
+
+
+void CharacterData::replaceData(unsigned long offset, unsigned long count, const XMLString& arg)
+{
+	if (offset >= _data.length())
+		throw DOMException(DOMException::INDEX_SIZE_ERR);
+
+	if (events())
+	{
+		XMLString oldData = _data;
+		_data.replace(offset, count, arg);
+		dispatchCharacterDataModified(oldData, _data);
+	}
+	else
+	{
+		_data.replace(offset, count, arg);
+	}
+}
+
+
+const XMLString& CharacterData::getNodeValue() const
+{
+	return _data;
+}
+
+
+void CharacterData::setNodeValue(const XMLString& value)
+{
+	setData(value);
+}
+
+
+XMLString CharacterData::trimmedData() const
+{
+	return Poco::trim(_data);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/ChildNodesList.cpp b/base/poco/XML/src/ChildNodesList.cpp
new file mode 100644
index 00000000000..aeacaf15adb
--- /dev/null
+++ b/base/poco/XML/src/ChildNodesList.cpp
@@ -0,0 +1,70 @@
+//
+// ChildNodesList.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/ChildNodesList.h"
+#include "Poco/DOM/Node.h"
+#include "Poco/DOM/Document.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+ChildNodesList::ChildNodesList(const Node* pParent):
+	_pParent(pParent)
+{
+	poco_check_ptr (pParent);
+
+	_pParent->duplicate();
+}
+
+
+ChildNodesList::~ChildNodesList()
+{
+	_pParent->release();
+}
+
+
+Node* ChildNodesList::item(unsigned long index) const
+{
+	unsigned long n = 0;
+	Node* pCur = _pParent->firstChild();
+	while (pCur && n++ < index)
+	{
+		pCur = pCur->nextSibling();
+	}
+	return pCur;
+}
+
+
+unsigned long ChildNodesList::length() const
+{
+	unsigned long n = 0;
+	Node* pCur = _pParent->firstChild();
+	while (pCur)
+	{
+		++n;
+		pCur = pCur->nextSibling();
+	}
+	return n;
+}
+
+
+void ChildNodesList::autoRelease()
+{
+	_pParent->ownerDocument()->autoReleasePool().add(this);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/Comment.cpp b/base/poco/XML/src/Comment.cpp
new file mode 100644
index 00000000000..090f1926ea3
--- /dev/null
+++ b/base/poco/XML/src/Comment.cpp
@@ -0,0 +1,60 @@
+//
+// Comment.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/Comment.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+const XMLString Comment::NODE_NAME = toXMLString("#comment");
+
+
+Comment::Comment(Document* pOwnerDocument, const XMLString& data): 
+	CharacterData(pOwnerDocument, data)
+{
+}
+
+
+Comment::Comment(Document* pOwnerDocument, const Comment& comment): 
+	CharacterData(pOwnerDocument, comment)
+{
+}
+
+
+Comment::~Comment()
+{
+}
+
+
+const XMLString& Comment::nodeName() const
+{
+	return NODE_NAME;
+}
+
+
+unsigned short Comment::nodeType() const
+{
+	return Node::COMMENT_NODE;
+}
+
+
+Node* Comment::copyNode(bool deep, Document* pOwnerDocument) const
+{
+	return new Comment(pOwnerDocument, *this);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/ContentHandler.cpp b/base/poco/XML/src/ContentHandler.cpp
new file mode 100644
index 00000000000..03177d11e7f
--- /dev/null
+++ b/base/poco/XML/src/ContentHandler.cpp
@@ -0,0 +1,27 @@
+//
+// ContentHandler.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/ContentHandler.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+ContentHandler::~ContentHandler()
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/DOMBuilder.cpp b/base/poco/XML/src/DOMBuilder.cpp
new file mode 100644
index 00000000000..04fc525e997
--- /dev/null
+++ b/base/poco/XML/src/DOMBuilder.cpp
@@ -0,0 +1,312 @@
+//
+// DOMBuilder.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMBuilder
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/DOMBuilder.h"
+#include "Poco/DOM/Document.h"
+#include "Poco/DOM/DocumentType.h"
+#include "Poco/DOM/CharacterData.h"
+#include "Poco/DOM/Text.h"
+#include "Poco/DOM/Comment.h"
+#include "Poco/DOM/CDATASection.h"
+#include "Poco/DOM/Element.h"
+#include "Poco/DOM/Attr.h"
+#include "Poco/DOM/Entity.h"
+#include "Poco/DOM/EntityReference.h"
+#include "Poco/DOM/Notation.h"
+#include "Poco/DOM/ProcessingInstruction.h"
+#include "Poco/DOM/AutoPtr.h"
+#include "Poco/SAX/XMLReader.h"
+#include "Poco/SAX/AttributesImpl.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+const XMLString DOMBuilder::EMPTY_STRING;
+
+
+DOMBuilder::DOMBuilder(XMLReader& xmlReader, NamePool* pNamePool):
+	_xmlReader(xmlReader),
+	_pNamePool(pNamePool),
+	_pDocument(0),
+	_pParent(0),
+	_pPrevious(0),
+	_inCDATA(false),
+	_namespaces(true)
+{
+	_xmlReader.setContentHandler(this);
+	_xmlReader.setDTDHandler(this);
+	_xmlReader.setProperty(XMLReader::PROPERTY_LEXICAL_HANDLER, static_cast<LexicalHandler*>(this));
+
+	if (_pNamePool) _pNamePool->duplicate();
+}
+
+
+DOMBuilder::~DOMBuilder()
+{
+	if (_pNamePool) _pNamePool->release();
+}
+
+
+Document* DOMBuilder::parse(const XMLString& uri)
+{
+	setupParse();
+	_pDocument->suspendEvents();
+	try
+	{
+		_xmlReader.parse(uri);
+	}
+	catch (...)
+	{
+		_pDocument->release();
+		_pDocument = 0;
+		_pParent   = 0;
+		_pPrevious = 0;
+		throw;
+	}
+	_pDocument->resumeEvents();
+	_pDocument->collectGarbage();
+	return _pDocument;
+}
+
+
+Document* DOMBuilder::parse(InputSource* pInputSource)
+{
+	setupParse();
+	_pDocument->suspendEvents();
+	try
+	{
+		_xmlReader.parse(pInputSource);
+	}
+	catch (...)
+	{
+		_pDocument->release();
+		_pDocument = 0;
+		_pParent   = 0;
+		_pPrevious = 0;
+		throw;
+	}
+	_pDocument->resumeEvents();
+	_pDocument->collectGarbage();
+	return _pDocument;
+}
+
+
+Document* DOMBuilder::parseMemoryNP(const char* xml, std::size_t size)
+{
+	setupParse();
+	_pDocument->suspendEvents();
+	try
+	{
+		_xmlReader.parseMemoryNP(xml, size);
+	}
+	catch (...)
+	{
+		_pDocument->release();
+		_pDocument = 0;
+		_pParent   = 0;
+		_pPrevious = 0;
+		throw;
+	}
+	_pDocument->resumeEvents();
+	_pDocument->collectGarbage();
+	return _pDocument;
+}
+
+
+void DOMBuilder::setupParse()
+{
+	_pDocument  = new Document(_pNamePool);
+	_pParent    = _pDocument;
+	_pPrevious  = 0;
+	_inCDATA    = false;
+	_namespaces = _xmlReader.getFeature(XMLReader::FEATURE_NAMESPACES);
+}
+
+
+inline void DOMBuilder::appendNode(AbstractNode* pNode)
+{
+	if (_pPrevious && _pPrevious != _pParent)
+	{
+		_pPrevious->_pNext = pNode;
+		pNode->_pParent = _pParent;
+		pNode->duplicate();
+	}
+	else _pParent->appendChild(pNode);
+	_pPrevious = pNode;
+}
+
+
+void DOMBuilder::notationDecl(const XMLString& name, const XMLString* publicId, const XMLString* systemId)
+{
+	DocumentType* pDoctype = _pDocument->getDoctype();
+	if (pDoctype)
+	{
+		AutoPtr<Notation> pNotation = _pDocument->createNotation(name, (publicId ? *publicId : EMPTY_STRING), (systemId ? *systemId : EMPTY_STRING));
+		pDoctype->appendChild(pNotation);
+	}
+}
+
+
+void DOMBuilder::unparsedEntityDecl(const XMLString& name, const XMLString* publicId, const XMLString& systemId, const XMLString& notationName)
+{
+	DocumentType* pDoctype = _pDocument->getDoctype();
+	if (pDoctype)
+	{
+		AutoPtr<Entity> pEntity = _pDocument->createEntity(name, publicId ? *publicId : EMPTY_STRING, systemId, notationName);
+		pDoctype->appendChild(pEntity);
+	}
+}
+
+
+void DOMBuilder::setDocumentLocator(const Locator* loc)
+{
+}
+
+
+void DOMBuilder::startDocument()
+{
+}
+
+
+void DOMBuilder::endDocument()
+{
+}
+
+
+void DOMBuilder::startElement(const XMLString& uri, const XMLString& localName, const XMLString& qname, const Attributes& attributes)
+{
+	AutoPtr<Element> pElem = _namespaces ? _pDocument->createElementNS(uri, qname.empty() ? localName : qname) : _pDocument->createElement(qname);
+
+	const AttributesImpl& attrs = dynamic_cast<const AttributesImpl&>(attributes);
+	Attr* pPrevAttr = 0;
+	for (const auto& attr: attrs)
+	{
+		AutoPtr<Attr> pAttr = new Attr(_pDocument, 0, attr.namespaceURI, attr.localName, attr.qname, attr.value, attr.specified);
+		pPrevAttr = pElem->addAttributeNodeNP(pPrevAttr, pAttr);
+	}
+	appendNode(pElem);
+	_pParent = pElem;
+}
+
+
+void DOMBuilder::endElement(const XMLString& uri, const XMLString& localName, const XMLString& qname)
+{
+	_pPrevious = _pParent;
+	_pParent   = static_cast<AbstractContainerNode*>(_pParent->parentNode());
+}
+
+
+void DOMBuilder::characters(const XMLChar ch[], int start, int length)
+{
+	if (_inCDATA)
+	{
+		if (_pPrevious && _pPrevious->nodeType() == Node::CDATA_SECTION_NODE)
+		{
+			static_cast<CDATASection*>(_pPrevious)->appendData(XMLString(ch + start, length));
+		}
+		else
+		{
+			AutoPtr<CDATASection> pCDATA = _pDocument->createCDATASection(XMLString(ch + start, length));
+			appendNode(pCDATA);
+		}
+	}
+	else
+	{
+		if (_pPrevious && _pPrevious->nodeType() == Node::TEXT_NODE)
+		{
+			static_cast<Text*>(_pPrevious)->appendData(XMLString(ch + start, length));
+		}
+		else
+		{
+			AutoPtr<Text> pText = _pDocument->createTextNode(XMLString(ch + start, length));
+			appendNode(pText);
+		}
+	}
+}
+
+
+void DOMBuilder::ignorableWhitespace(const XMLChar ch[], int start, int length)
+{
+	characters(ch, start, length);
+}
+
+
+void DOMBuilder::processingInstruction(const XMLString& target, const XMLString& data)
+{
+	AutoPtr<ProcessingInstruction> pPI = _pDocument->createProcessingInstruction(target, data);
+	appendNode(pPI);
+}
+
+
+void DOMBuilder::startPrefixMapping(const XMLString& prefix, const XMLString& uri)
+{
+}
+
+
+void DOMBuilder::endPrefixMapping(const XMLString& prefix)
+{
+}
+
+
+void DOMBuilder::skippedEntity(const XMLString& name)
+{
+	AutoPtr<EntityReference> pER = _pDocument->createEntityReference(name);
+	appendNode(pER);
+}
+
+
+void DOMBuilder::startDTD(const XMLString& name, const XMLString& publicId, const XMLString& systemId)
+{
+	AutoPtr<DocumentType> pDoctype = new DocumentType(_pDocument, name, publicId, systemId);
+	_pDocument->setDoctype(pDoctype);
+}
+
+
+void DOMBuilder::endDTD()
+{
+}
+
+
+void DOMBuilder::startEntity(const XMLString& name)
+{
+}
+
+
+void DOMBuilder::endEntity(const XMLString& name)
+{
+}
+
+
+void DOMBuilder::startCDATA()
+{
+	_inCDATA = true;
+}
+
+
+void DOMBuilder::endCDATA()
+{
+	_inCDATA = false;
+}
+
+
+void DOMBuilder::comment(const XMLChar ch[], int start, int length)
+{
+	AutoPtr<Comment> pComment = _pDocument->createComment(XMLString(ch + start, length));
+	appendNode(pComment);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/DOMException.cpp b/base/poco/XML/src/DOMException.cpp
new file mode 100644
index 00000000000..546a1e2aae6
--- /dev/null
+++ b/base/poco/XML/src/DOMException.cpp
@@ -0,0 +1,107 @@
+//
+// DOMException.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/DOMException.h"
+#include <typeinfo>
+
+
+namespace Poco {
+namespace XML {
+
+
+const std::string DOMException::MESSAGES[_NUMBER_OF_MESSAGES] =
+{
+	"Invalid DOM exception code",
+	"Index or size is negative or greater than allowed value",
+	"The specified range of text does not fit into a DOMString",
+	"A node is inserted somewhere it doesn't belong",
+	"A node is used in a different document than the one that created it",
+	"An invalid character is specified",
+	"Data is specified for a node which does not support data",
+	"An attempt is made to modify an object where modifications are not allowed",
+	"An attempt was made to reference a node in a context where it does not exist",
+	"The implementation does not support the type of object requested",
+	"An attempt is made to add an attribute that is already in use elsewhere",
+	"A parameter or an operation is not supported by the underlying object",
+	"An invalid or illegal string is specified",
+	"An attempt is made to modify the type of the underlying object",
+	"An attempt is made to create or change an object in a way which is incorrect with regard to namespaces",
+	"An attempt is made to use an object that is not, or is no longer, usable"
+};
+
+
+DOMException::DOMException(unsigned short code):
+	XMLException(message(code)),
+	_code(code)
+{
+}
+
+	
+DOMException::DOMException(const DOMException& exc):
+	XMLException(exc),
+	_code(exc._code)
+{
+}
+
+	
+DOMException::~DOMException() noexcept
+{
+}
+
+	
+DOMException& DOMException::operator = (const DOMException& exc)
+{
+	if (&exc != this)
+	{
+		XMLException::operator = (exc);
+		_code = exc._code;
+	}
+	return *this;
+}
+
+
+const char* DOMException::name() const noexcept
+{
+	return "DOMException";
+}
+
+
+const char* DOMException::className() const noexcept
+{
+	return typeid(*this).name();
+}
+
+
+Poco::Exception* DOMException::clone() const
+{
+	return new DOMException(*this);
+}
+
+
+void DOMException::rethrow() const
+{
+	throw *this;
+}
+
+
+const std::string& DOMException::message(unsigned short code)
+{
+	if (code >= 1 && code < _NUMBER_OF_MESSAGES)
+		return MESSAGES[code];
+	else
+		return MESSAGES[0];
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/DOMImplementation.cpp b/base/poco/XML/src/DOMImplementation.cpp
new file mode 100644
index 00000000000..b6a138d67e1
--- /dev/null
+++ b/base/poco/XML/src/DOMImplementation.cpp
@@ -0,0 +1,86 @@
+//
+// DOMImplementation.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/DOMImplementation.h"
+#include "Poco/DOM/DocumentType.h"
+#include "Poco/DOM/Document.h"
+#include "Poco/DOM/Element.h"
+#include "Poco/String.h"
+#include "Poco/SingletonHolder.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+const XMLString DOMImplementation::FEATURE_XML            = toXMLString("xml");
+const XMLString DOMImplementation::FEATURE_CORE           = toXMLString("core");
+const XMLString DOMImplementation::FEATURE_EVENTS         = toXMLString("events");
+const XMLString DOMImplementation::FEATURE_MUTATIONEVENTS = toXMLString("mutationevents");
+const XMLString DOMImplementation::FEATURE_TRAVERSAL      = toXMLString("traversal");
+const XMLString DOMImplementation::VERSION_1_0            = toXMLString("1.0");
+const XMLString DOMImplementation::VERSION_2_0            = toXMLString("2.0");
+
+
+DOMImplementation::DOMImplementation()
+{
+}
+
+
+DOMImplementation::~DOMImplementation()
+{
+}
+
+
+bool DOMImplementation::hasFeature(const XMLString& feature, const XMLString& version) const
+{
+	XMLString lcFeature = Poco::toLower(feature);
+	return (lcFeature == FEATURE_XML && version == VERSION_1_0) ||
+	       (lcFeature == FEATURE_CORE && version == VERSION_2_0) ||
+	       (lcFeature == FEATURE_EVENTS && version == VERSION_2_0) ||
+	       (lcFeature == FEATURE_MUTATIONEVENTS && version == VERSION_2_0) ||
+	       (lcFeature == FEATURE_TRAVERSAL && version == VERSION_2_0);
+}
+
+		
+DocumentType* DOMImplementation::createDocumentType(const XMLString& name, const XMLString& publicId, const XMLString& systemId) const
+{
+	return new DocumentType(0, name, publicId, systemId);
+}
+
+
+Document* DOMImplementation::createDocument(const XMLString& namespaceURI, const XMLString& qualifiedName, DocumentType* doctype) const
+{
+	Document* pDoc = new Document(doctype);
+	if (namespaceURI.empty())
+		pDoc->appendChild(pDoc->createElement(qualifiedName))->release();
+	else
+		pDoc->appendChild(pDoc->createElementNS(namespaceURI, qualifiedName))->release();
+	return pDoc;
+}
+
+
+namespace
+{
+	static Poco::SingletonHolder<DOMImplementation> sh;
+}
+
+
+const DOMImplementation& DOMImplementation::instance()
+{
+	return *sh.get();
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/DOMObject.cpp b/base/poco/XML/src/DOMObject.cpp
new file mode 100644
index 00000000000..a82708f0dd6
--- /dev/null
+++ b/base/poco/XML/src/DOMObject.cpp
@@ -0,0 +1,32 @@
+//
+// DOMObject.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/DOMObject.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+DOMObject::DOMObject(): _rc(1)
+{
+}
+
+	
+DOMObject::~DOMObject()
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/DOMParser.cpp b/base/poco/XML/src/DOMParser.cpp
new file mode 100644
index 00000000000..5e222c6fd7a
--- /dev/null
+++ b/base/poco/XML/src/DOMParser.cpp
@@ -0,0 +1,157 @@
+//
+// DOMParser.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMParser
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/DOMParser.h"
+#include "Poco/DOM/DOMBuilder.h"
+#include "Poco/SAX/WhitespaceFilter.h"
+#include "Poco/SAX/InputSource.h"
+#include "Poco/XML/NamePool.h"
+#include <sstream>
+
+
+namespace Poco {
+namespace XML {
+
+
+const XMLString DOMParser::FEATURE_FILTER_WHITESPACE = toXMLString("http://www.appinf.com/features/no-whitespace-in-element-content");
+
+
+DOMParser::DOMParser(NamePool* pNamePool):
+	_pNamePool(pNamePool),
+	_filterWhitespace(false)
+{
+	if (_pNamePool) _pNamePool->duplicate();
+	_saxParser.setFeature(XMLReader::FEATURE_NAMESPACES, true);
+	_saxParser.setFeature(XMLReader::FEATURE_NAMESPACE_PREFIXES, true);
+}
+
+
+DOMParser::DOMParser(unsigned long namePoolSize):
+	_pNamePool(new NamePool(namePoolSize)),
+	_filterWhitespace(false)
+{
+	_saxParser.setFeature(XMLReader::FEATURE_NAMESPACES, true);
+	_saxParser.setFeature(XMLReader::FEATURE_NAMESPACE_PREFIXES, true);
+}
+
+
+DOMParser::~DOMParser()
+{
+	if (_pNamePool) _pNamePool->release();
+}
+
+
+void DOMParser::setEncoding(const XMLString& encoding)
+{
+	_saxParser.setEncoding(encoding);
+}
+
+
+const XMLString& DOMParser::getEncoding() const
+{
+	return _saxParser.getEncoding();
+}
+
+
+void DOMParser::addEncoding(const XMLString& name, Poco::TextEncoding* pEncoding)
+{
+	_saxParser.addEncoding(name, pEncoding);
+}
+
+
+void DOMParser::setFeature(const XMLString& name, bool state)
+{
+	if (name == FEATURE_FILTER_WHITESPACE)
+		_filterWhitespace = state;
+	else
+		_saxParser.setFeature(name, state);
+}
+
+
+bool DOMParser::getFeature(const XMLString& name) const
+{
+	if (name == FEATURE_FILTER_WHITESPACE)
+		return _filterWhitespace;
+	else
+		return _saxParser.getFeature(name);
+}
+
+
+Document* DOMParser::parse(const XMLString& uri)
+{
+	if (_filterWhitespace)
+	{
+		WhitespaceFilter filter(&_saxParser);
+		DOMBuilder builder(filter, _pNamePool);
+		return builder.parse(uri);
+	}
+	else
+	{
+		DOMBuilder builder(_saxParser, _pNamePool);
+		return builder.parse(uri);
+	}
+}
+
+
+Document* DOMParser::parse(InputSource* pInputSource)
+{
+	if (_filterWhitespace)
+	{
+		WhitespaceFilter filter(&_saxParser);
+		DOMBuilder builder(filter, _pNamePool);
+		return builder.parse(pInputSource);
+	}
+	else
+	{
+		DOMBuilder builder(_saxParser, _pNamePool);
+		return builder.parse(pInputSource);
+	}
+}
+
+
+Document* DOMParser::parseString(const std::string& xml)
+{
+	return parseMemory(xml.data(), xml.size());
+}
+
+
+Document* DOMParser::parseMemory(const char* xml, std::size_t size)
+{
+	if (_filterWhitespace)
+	{
+		WhitespaceFilter filter(&_saxParser);
+		DOMBuilder builder(filter, _pNamePool);
+		return builder.parseMemoryNP(xml, size);
+	}
+	else
+	{
+		DOMBuilder builder(_saxParser, _pNamePool);
+		return builder.parseMemoryNP(xml, size);
+	}
+}
+
+
+EntityResolver* DOMParser::getEntityResolver() const
+{
+	return _saxParser.getEntityResolver();
+}
+
+
+void DOMParser::setEntityResolver(EntityResolver* pEntityResolver)
+{
+	_saxParser.setEntityResolver(pEntityResolver);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/DOMSerializer.cpp b/base/poco/XML/src/DOMSerializer.cpp
new file mode 100644
index 00000000000..35e7950bcce
--- /dev/null
+++ b/base/poco/XML/src/DOMSerializer.cpp
@@ -0,0 +1,323 @@
+//
+// DOMSerializer.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMSerializer
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/DOMSerializer.h"
+#include "Poco/DOM/Document.h"
+#include "Poco/DOM/DocumentType.h"
+#include "Poco/DOM/DocumentFragment.h"
+#include "Poco/DOM/Element.h"
+#include "Poco/DOM/Attr.h"
+#include "Poco/DOM/Text.h"
+#include "Poco/DOM/CDATASection.h"
+#include "Poco/DOM/Comment.h"
+#include "Poco/DOM/ProcessingInstruction.h"
+#include "Poco/DOM/Entity.h"
+#include "Poco/DOM/Notation.h"
+#include "Poco/DOM/NamedNodeMap.h"
+#include "Poco/DOM/AutoPtr.h"
+#include "Poco/SAX/EntityResolver.h"
+#include "Poco/SAX/DTDHandler.h"
+#include "Poco/SAX/ContentHandler.h"
+#include "Poco/SAX/LexicalHandler.h"
+#include "Poco/SAX/AttributesImpl.h"
+#include "Poco/SAX/ErrorHandler.h"
+#include "Poco/SAX/SAXException.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+const XMLString DOMSerializer::CDATA = toXMLString("CDATA");
+
+
+DOMSerializer::DOMSerializer():
+	_pEntityResolver(0),
+	_pDTDHandler(0),
+	_pContentHandler(0),
+	_pErrorHandler(0),
+	_pDeclHandler(0),
+	_pLexicalHandler(0)
+{
+}
+
+
+DOMSerializer::~DOMSerializer()
+{
+}
+
+
+void DOMSerializer::setEntityResolver(EntityResolver* pEntityResolver)
+{
+	_pEntityResolver = pEntityResolver;
+}
+
+
+EntityResolver* DOMSerializer::getEntityResolver() const
+{
+	return _pEntityResolver;
+}
+
+
+void DOMSerializer::setDTDHandler(DTDHandler* pDTDHandler)
+{
+	_pDTDHandler = pDTDHandler;
+}
+
+
+DTDHandler* DOMSerializer::getDTDHandler() const
+{
+	return _pDTDHandler;
+}
+
+
+void DOMSerializer::setContentHandler(ContentHandler* pContentHandler)
+{
+	_pContentHandler = pContentHandler;
+}
+
+
+ContentHandler* DOMSerializer::getContentHandler() const
+{
+	return _pContentHandler;
+}
+
+
+void DOMSerializer::setErrorHandler(ErrorHandler* pErrorHandler)
+{
+	_pErrorHandler = pErrorHandler;
+}
+
+
+ErrorHandler* DOMSerializer::getErrorHandler() const
+{
+	return _pErrorHandler;
+}
+
+
+void DOMSerializer::setFeature(const XMLString& featureId, bool state)
+{
+	if (featureId == XMLReader::FEATURE_NAMESPACES)
+		throw SAXNotSupportedException(fromXMLString(XMLReader::FEATURE_NAMESPACES));
+	else if (featureId == XMLReader::FEATURE_NAMESPACE_PREFIXES)
+		throw SAXNotSupportedException(fromXMLString(XMLReader::FEATURE_NAMESPACE_PREFIXES));
+	else
+		throw SAXNotRecognizedException(fromXMLString(featureId));
+}
+
+
+bool DOMSerializer::getFeature(const XMLString& featureId) const
+{
+	if (featureId == XMLReader::FEATURE_NAMESPACES)
+		throw SAXNotSupportedException(fromXMLString(XMLReader::FEATURE_NAMESPACES));
+	else if (featureId == XMLReader::FEATURE_NAMESPACE_PREFIXES)
+		throw SAXNotSupportedException(fromXMLString(XMLReader::FEATURE_NAMESPACE_PREFIXES));
+	else
+		throw SAXNotRecognizedException(fromXMLString(featureId));
+}
+
+
+void DOMSerializer::setProperty(const XMLString& propertyId, const XMLString& value)
+{
+	if (propertyId == XMLReader::PROPERTY_DECLARATION_HANDLER || propertyId == XMLReader::PROPERTY_LEXICAL_HANDLER)
+		throw SAXNotSupportedException(std::string("property does not take a string value: ") + fromXMLString(propertyId));
+	else
+		throw SAXNotRecognizedException(fromXMLString(propertyId));
+}
+
+
+void DOMSerializer::setProperty(const XMLString& propertyId, void* value)
+{
+	if (propertyId == XMLReader::PROPERTY_DECLARATION_HANDLER)
+		_pDeclHandler = reinterpret_cast<DeclHandler*>(value);
+	else if (propertyId == XMLReader::PROPERTY_LEXICAL_HANDLER)
+		_pLexicalHandler = reinterpret_cast<LexicalHandler*>(value);
+	else throw SAXNotRecognizedException(fromXMLString(propertyId));
+}
+
+
+void* DOMSerializer::getProperty(const XMLString& propertyId) const
+{
+	if (propertyId == XMLReader::PROPERTY_DECLARATION_HANDLER)
+		return _pDeclHandler;
+	else if (propertyId == XMLReader::PROPERTY_LEXICAL_HANDLER)
+		return _pLexicalHandler;
+	else throw SAXNotSupportedException(fromXMLString(propertyId));
+}
+
+
+void DOMSerializer::serialize(const Node* pNode)
+{
+	poco_check_ptr (pNode);
+
+	handleNode(pNode);
+}
+
+
+void DOMSerializer::parse(InputSource* pSource)
+{
+	throw XMLException("The DOMSerializer cannot parse an InputSource");
+}
+
+
+void DOMSerializer::parse(const XMLString& systemId)
+{
+	throw XMLException("The DOMSerializer cannot parse from a system identifier");
+}
+
+
+void DOMSerializer::parseMemoryNP(const char* xml, std::size_t size)
+{
+	throw XMLException("The DOMSerializer cannot parse from memory");
+}
+
+
+void DOMSerializer::iterate(const Node* pNode) const
+{
+	while (pNode)
+	{
+		handleNode(pNode);
+		pNode = pNode->nextSibling();
+	}
+}
+
+
+void DOMSerializer::handleNode(const Node* pNode) const
+{
+	switch (pNode->nodeType())
+	{
+	case Node::ELEMENT_NODE:
+		handleElement(static_cast<const Element*>(pNode)); 
+		break;
+	case Node::TEXT_NODE:
+		handleCharacterData(static_cast<const Text*>(pNode)); 
+		break;
+	case Node::CDATA_SECTION_NODE:
+		handleCDATASection(static_cast<const CDATASection*>(pNode)); 
+		break;
+	case Node::ENTITY_NODE:
+		handleEntity(static_cast<const Entity*>(pNode));
+		break;
+	case Node::PROCESSING_INSTRUCTION_NODE:
+		handlePI(static_cast<const ProcessingInstruction*>(pNode)); 
+		break;
+	case Node::COMMENT_NODE:
+		handleComment(static_cast<const Comment*>(pNode)); 
+		break;
+	case Node::DOCUMENT_NODE:
+		handleDocument(static_cast<const Document*>(pNode)); 
+		break;
+	case Node::DOCUMENT_TYPE_NODE:
+		handleDocumentType(static_cast<const DocumentType*>(pNode));
+		break;
+	case Node::DOCUMENT_FRAGMENT_NODE:
+		handleFragment(static_cast<const DocumentFragment*>(pNode));
+		break;
+	case Node::NOTATION_NODE:
+		handleNotation(static_cast<const Notation*>(pNode));
+		break;
+	}
+}
+
+
+void DOMSerializer::handleElement(const Element* pElement) const
+{
+	if (_pContentHandler) 
+	{
+		AutoPtr<NamedNodeMap> pAttrs = pElement->attributes();
+		AttributesImpl saxAttrs;
+		for (unsigned long i = 0; i < pAttrs->length(); ++i)
+		{
+			Attr* pAttr = static_cast<Attr*>(pAttrs->item(i));
+			saxAttrs.addAttribute(pAttr->namespaceURI(), pAttr->localName(), pAttr->nodeName(), CDATA, pAttr->value(), pAttr->specified());
+		}
+		_pContentHandler->startElement(pElement->namespaceURI(), pElement->localName(), pElement->tagName(), saxAttrs);
+	}
+	iterate(pElement->firstChild());
+	if (_pContentHandler)
+		_pContentHandler->endElement(pElement->namespaceURI(), pElement->localName(), pElement->tagName());
+}
+
+
+void DOMSerializer::handleCharacterData(const Text* pText) const
+{
+	if (_pContentHandler)
+	{
+		const XMLString& data = pText->data();
+		_pContentHandler->characters(data.c_str(), 0, (int) data.length());
+	}
+}
+
+
+void DOMSerializer::handleComment(const Comment* pComment) const
+{
+	if (_pLexicalHandler)
+	{
+		const XMLString& data = pComment->data();
+		_pLexicalHandler->comment(data.c_str(), 0, (int) data.length());
+	}
+}
+
+
+void DOMSerializer::handlePI(const ProcessingInstruction* pPI) const
+{
+	if (_pContentHandler) _pContentHandler->processingInstruction(pPI->target(), pPI->data());
+}
+
+
+void DOMSerializer::handleCDATASection(const CDATASection* pCDATA) const
+{
+	if (_pLexicalHandler) _pLexicalHandler->startCDATA();
+	handleCharacterData(pCDATA);
+	if (_pLexicalHandler) _pLexicalHandler->endCDATA();
+}
+
+
+void DOMSerializer::handleDocument(const Document* pDocument) const
+{
+	if (_pContentHandler) _pContentHandler->startDocument();
+	const DocumentType* pDoctype = pDocument->doctype();
+	if (pDoctype) handleDocumentType(pDoctype);
+	iterate(pDocument->firstChild());
+	if (_pContentHandler) _pContentHandler->endDocument();
+}
+
+
+void DOMSerializer::handleDocumentType(const DocumentType* pDocumentType) const
+{
+	if (_pLexicalHandler) _pLexicalHandler->startDTD(pDocumentType->name(), pDocumentType->publicId(), pDocumentType->systemId());
+	iterate(pDocumentType->firstChild());
+	if (_pLexicalHandler) _pLexicalHandler->endDTD();
+}
+
+
+void DOMSerializer::handleFragment(const DocumentFragment* pFragment) const
+{
+	iterate(pFragment->firstChild());
+}
+
+
+void DOMSerializer::handleNotation(const Notation* pNotation) const
+{
+	if (_pDTDHandler) _pDTDHandler->notationDecl(pNotation->nodeName(), &pNotation->publicId(), &pNotation->systemId());
+}
+
+
+void DOMSerializer::handleEntity(const Entity* pEntity) const
+{
+	if (_pDTDHandler) _pDTDHandler->unparsedEntityDecl(pEntity->nodeName(), &pEntity->publicId(), pEntity->systemId(), pEntity->notationName());
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/DOMWriter.cpp b/base/poco/XML/src/DOMWriter.cpp
new file mode 100644
index 00000000000..8a087643e88
--- /dev/null
+++ b/base/poco/XML/src/DOMWriter.cpp
@@ -0,0 +1,102 @@
+//
+// DOMWriter.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMWriter
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+
+#include "Poco/DOM/DOMWriter.h"
+#include "Poco/XML/XMLWriter.h"
+#include "Poco/DOM/Document.h"
+#include "Poco/DOM/DocumentFragment.h"
+#include "Poco/DOM/DocumentType.h"
+#include "Poco/DOM/DOMException.h"
+#include "Poco/DOM/DOMSerializer.h"
+#include "Poco/SAX/LexicalHandler.h"
+#include "Poco/XML/XMLException.h"
+#include "Poco/Path.h"
+#include "Poco/FileStream.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+DOMWriter::DOMWriter():
+	_pTextEncoding(0),
+	_options(0),
+	_indent("\t")
+{
+}
+
+
+DOMWriter::~DOMWriter()
+{
+}
+
+
+void DOMWriter::setEncoding(const std::string& encodingName, Poco::TextEncoding& textEncoding)
+{
+	_encodingName  = encodingName;
+	_pTextEncoding = &textEncoding;
+}
+
+
+void DOMWriter::setOptions(int options)
+{
+	_options = options;
+}
+
+
+void DOMWriter::setNewLine(const std::string& newLine)
+{
+	_newLine = newLine;
+}
+
+
+void DOMWriter::setIndent(const std::string& indent)
+{
+	_indent = indent;
+}
+
+
+void DOMWriter::writeNode(XMLByteOutputStream& ostr, const Node* pNode)
+{
+	poco_check_ptr (pNode);
+
+	bool isFragment = pNode->nodeType() != Node::DOCUMENT_NODE;
+
+	XMLWriter writer(ostr, _options, _encodingName, _pTextEncoding);
+	writer.setNewLine(_newLine);
+	writer.setIndent(_indent);
+	
+	DOMSerializer serializer;
+	serializer.setContentHandler(&writer);
+	serializer.setDTDHandler(&writer);
+	serializer.setProperty(XMLReader::PROPERTY_LEXICAL_HANDLER, static_cast<LexicalHandler*>(&writer));
+	if (isFragment) writer.startFragment();
+	serializer.serialize(pNode);
+	if (isFragment) writer.endFragment();
+}
+
+
+void DOMWriter::writeNode(const std::string& systemId, const Node* pNode)
+{
+	Poco::FileOutputStream ostr(systemId);
+	if (ostr.good())
+		writeNode(ostr, pNode);
+	else 
+		throw Poco::CreateFileException(systemId);
+}
+
+
+} } // namespace Poco::XML
+
diff --git a/base/poco/XML/src/DTDHandler.cpp b/base/poco/XML/src/DTDHandler.cpp
new file mode 100644
index 00000000000..5c478acc408
--- /dev/null
+++ b/base/poco/XML/src/DTDHandler.cpp
@@ -0,0 +1,27 @@
+//
+// DTDHandler.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/DTDHandler.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+DTDHandler::~DTDHandler()
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/DTDMap.cpp b/base/poco/XML/src/DTDMap.cpp
new file mode 100644
index 00000000000..1420d4a7776
--- /dev/null
+++ b/base/poco/XML/src/DTDMap.cpp
@@ -0,0 +1,117 @@
+//
+// DTDMap.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/DTDMap.h"
+#include "Poco/DOM/DocumentType.h"
+#include "Poco/DOM/Document.h"
+#include "Poco/DOM/DOMException.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+DTDMap::DTDMap(const DocumentType* pDocumentType, unsigned short type):
+	_pDocumentType(pDocumentType),
+	_type(type)
+{
+	poco_check_ptr (pDocumentType->ownerDocument());
+}
+
+
+DTDMap::~DTDMap()
+{
+}
+
+
+Node* DTDMap::getNamedItem(const XMLString& name) const
+{
+	Node* pCur = _pDocumentType->firstChild();
+	while (pCur)
+	{
+		if (pCur->nodeType() == _type && pCur->nodeName() == name)
+			return pCur;
+		pCur = pCur->nextSibling();
+	}
+	return pCur;
+}
+
+
+Node* DTDMap::setNamedItem(Node* arg)
+{
+	throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
+}
+
+
+Node* DTDMap::removeNamedItem(const XMLString& name)
+{
+	throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
+}
+
+
+Node* DTDMap::item(unsigned long index) const
+{
+	unsigned long n = 0;
+	Node* pCur = _pDocumentType->firstChild();
+	while (pCur)
+	{
+		if (pCur->nodeType() == _type)
+		{
+			if (n == index) return pCur;
+			++n;
+		}
+		pCur = pCur->nextSibling();
+	}
+	return pCur;
+}
+
+
+unsigned long DTDMap::length() const
+{
+	unsigned long n = 0;
+	Node* pCur = _pDocumentType->firstChild();
+	while (pCur)
+	{
+		if (pCur->nodeType() == _type) ++n;
+		pCur = pCur->nextSibling();
+	}
+	return n;
+}
+
+
+Node* DTDMap::getNamedItemNS(const XMLString& namespaceURI, const XMLString& localName) const
+{
+	return 0;
+}
+
+
+Node* DTDMap::setNamedItemNS(Node* arg)
+{
+	throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
+}
+
+
+Node* DTDMap::removeNamedItemNS(const XMLString& namespaceURI, const XMLString& localName)
+{
+	throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
+}
+
+
+void DTDMap::autoRelease()
+{
+	_pDocumentType->ownerDocument()->autoReleasePool().add(this);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/DeclHandler.cpp b/base/poco/XML/src/DeclHandler.cpp
new file mode 100644
index 00000000000..d2164f430f1
--- /dev/null
+++ b/base/poco/XML/src/DeclHandler.cpp
@@ -0,0 +1,27 @@
+//
+// DeclHandler.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/DeclHandler.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+DeclHandler::~DeclHandler()
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/DefaultHandler.cpp b/base/poco/XML/src/DefaultHandler.cpp
new file mode 100644
index 00000000000..bcbe9465d1c
--- /dev/null
+++ b/base/poco/XML/src/DefaultHandler.cpp
@@ -0,0 +1,123 @@
+//
+// DefaultHandler.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/DefaultHandler.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+DefaultHandler::DefaultHandler()
+{
+}
+
+
+DefaultHandler::~DefaultHandler()
+{
+}
+
+
+InputSource* DefaultHandler::resolveEntity(const XMLString* publicId, const XMLString& systemId)
+{
+	return 0;
+}
+
+
+void DefaultHandler::releaseInputSource(InputSource* pSource)
+{
+}
+
+
+void DefaultHandler::notationDecl(const XMLString& name, const XMLString* publicId, const XMLString* systemId)
+{
+}
+
+
+void DefaultHandler::unparsedEntityDecl(const XMLString& name, const XMLString* publicId, const XMLString& systemId, const XMLString& notationName)
+{
+}
+
+
+void DefaultHandler::setDocumentLocator(const Locator* loc)
+{
+}
+
+
+void DefaultHandler::startDocument()
+{
+}
+
+
+void DefaultHandler::endDocument()
+{
+}
+
+
+void DefaultHandler::startElement(const XMLString& uri, const XMLString& localName, const XMLString& qname, const Attributes& attributes)
+{
+}
+
+
+void DefaultHandler::endElement(const XMLString& uri, const XMLString& localName, const XMLString& qname)
+{
+}
+
+
+void DefaultHandler::characters(const XMLChar ch[], int start, int length)
+{
+}
+
+
+void DefaultHandler::ignorableWhitespace(const XMLChar ch[], int start, int length)
+{
+}
+
+
+void DefaultHandler::processingInstruction(const XMLString& target, const XMLString& data)
+{
+}
+
+
+void DefaultHandler::startPrefixMapping(const XMLString& prefix, const XMLString& uri)
+{
+}
+
+
+void DefaultHandler::endPrefixMapping(const XMLString& prefix)
+{
+}
+
+
+void DefaultHandler::skippedEntity(const XMLString& name)
+{
+}
+
+
+void DefaultHandler::warning(const SAXException& exc)
+{
+}
+
+
+void DefaultHandler::error(const SAXException& exc)
+{
+}
+
+
+void DefaultHandler::fatalError(const SAXException& exc)
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/Document.cpp b/base/poco/XML/src/Document.cpp
new file mode 100644
index 00000000000..cb6ff125cf7
--- /dev/null
+++ b/base/poco/XML/src/Document.cpp
@@ -0,0 +1,326 @@
+//
+// Document.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/Document.h"
+#include "Poco/DOM/DocumentType.h"
+#include "Poco/DOM/DOMImplementation.h"
+#include "Poco/DOM/Element.h"
+#include "Poco/DOM/Attr.h"
+#include "Poco/DOM/DocumentFragment.h"
+#include "Poco/DOM/Text.h"
+#include "Poco/DOM/Comment.h"
+#include "Poco/DOM/CDATASection.h"
+#include "Poco/DOM/ProcessingInstruction.h"
+#include "Poco/DOM/EntityReference.h"
+#include "Poco/DOM/DOMException.h"
+#include "Poco/DOM/ElementsByTagNameList.h"
+#include "Poco/DOM/Entity.h"
+#include "Poco/DOM/Notation.h"
+#include "Poco/XML/Name.h"
+#include "Poco/XML/NamePool.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+const XMLString Document::NODE_NAME = toXMLString("#document");
+
+
+Document::Document(NamePool* pNamePool): 
+	AbstractContainerNode(0),
+	_pDocumentType(0),
+	_eventSuspendLevel(0)
+{
+	if (pNamePool)
+	{
+		_pNamePool = pNamePool;
+		_pNamePool->duplicate();
+	}
+	else
+	{
+		_pNamePool = new NamePool;
+	}
+}
+
+
+Document::Document(unsigned long namePoolSize): 
+	AbstractContainerNode(0),
+	_pDocumentType(0),
+	_pNamePool(new NamePool(namePoolSize)),
+	_eventSuspendLevel(0)
+{
+}
+
+
+Document::Document(DocumentType* pDocumentType, NamePool* pNamePool): 
+	AbstractContainerNode(0),
+	_pDocumentType(pDocumentType),
+	_eventSuspendLevel(0)
+{
+	if (pNamePool)
+	{
+		_pNamePool = pNamePool;
+		_pNamePool->duplicate();
+	}
+	else
+	{
+		_pNamePool = new NamePool;
+	}
+	if (_pDocumentType)
+	{
+		_pDocumentType->duplicate();
+		_pDocumentType->setOwnerDocument(this);
+	}
+}
+
+
+Document::Document(DocumentType* pDocumentType, unsigned long namePoolSize): 
+	AbstractContainerNode(0),
+	_pDocumentType(pDocumentType),
+	_pNamePool(new NamePool(namePoolSize)),
+	_eventSuspendLevel(0)
+{
+	if (_pDocumentType)
+	{
+		_pDocumentType->duplicate();
+		_pDocumentType->setOwnerDocument(this);
+	}
+}
+
+
+Document::~Document()
+{
+	if (_pDocumentType) _pDocumentType->release();
+	_pNamePool->release();
+}
+
+
+bool Document::dispatchEvent(Event* evt)
+{
+	return _eventSuspendLevel > 0 || AbstractContainerNode::dispatchEvent(evt);
+}
+
+
+void Document::collectGarbage()
+{
+	_autoReleasePool.release();
+}
+
+
+void Document::suspendEvents()
+{
+	++_eventSuspendLevel;
+}
+
+
+void Document::resumeEvents()
+{
+	poco_assert_dbg (_eventSuspendLevel > 0);
+
+	--_eventSuspendLevel;
+}
+
+
+const DOMImplementation& Document::implementation() const
+{
+	return DOMImplementation::instance();
+}
+
+
+Element* Document::documentElement() const
+{
+	// Skip non-element nodes before the document element
+	Node* pCur = firstChild();
+	while (pCur)
+	{
+		if (dynamic_cast<Element*>(pCur))
+			return static_cast<Element*>(pCur);
+		pCur = pCur->nextSibling();
+	}
+	return 0;
+}
+
+
+Element* Document::createElement(const XMLString& tagName) const
+{
+	return new Element(const_cast<Document*>(this), EMPTY_STRING, EMPTY_STRING, tagName); 
+}
+
+
+DocumentFragment* Document::createDocumentFragment() const
+{
+	return new DocumentFragment(const_cast<Document*>(this));
+}
+
+
+Text* Document::createTextNode(const XMLString& data) const
+{
+	return new Text(const_cast<Document*>(this), data);
+}
+
+
+Comment* Document::createComment(const XMLString& data) const
+{
+	return new Comment(const_cast<Document*>(this), data);
+}
+
+
+CDATASection* Document::createCDATASection(const XMLString& data) const
+{
+	return new CDATASection(const_cast<Document*>(this), data);
+}
+
+
+ProcessingInstruction* Document::createProcessingInstruction(const XMLString& target, const XMLString& data) const
+{
+	return new ProcessingInstruction(const_cast<Document*>(this), target, data);
+}
+
+
+Attr* Document::createAttribute(const XMLString& name) const
+{
+	return new Attr(const_cast<Document*>(this), 0, EMPTY_STRING, EMPTY_STRING, name, EMPTY_STRING);
+}
+
+
+EntityReference* Document::createEntityReference(const XMLString& name) const
+{
+	return new EntityReference(const_cast<Document*>(this), name);
+}
+
+
+NodeList* Document::getElementsByTagName(const XMLString& name) const
+{
+	return new ElementsByTagNameList(const_cast<Document*>(this), name);	
+}
+
+
+const XMLString& Document::nodeName() const
+{
+	return NODE_NAME;
+}
+
+
+unsigned short Document::nodeType() const
+{
+	return Node::DOCUMENT_NODE;
+}
+
+
+Node* Document::importNode(Node* importedNode, bool deep)
+{
+	return static_cast<AbstractNode*>(importedNode)->copyNode(deep, this);
+}
+
+
+Element* Document::createElementNS(const XMLString& namespaceURI, const XMLString& qualifiedName) const
+{
+	return new Element(const_cast<Document*>(this), namespaceURI, Name::localName(qualifiedName), qualifiedName);
+}
+
+
+Attr* Document::createAttributeNS(const XMLString& namespaceURI, const XMLString& qualifiedName) const
+{
+	return new Attr(const_cast<Document*>(this), 0, namespaceURI, Name::localName(qualifiedName), qualifiedName, EMPTY_STRING);
+}
+
+
+NodeList* Document::getElementsByTagNameNS(const XMLString& namespaceURI, const XMLString& localName) const
+{
+	return new ElementsByTagNameListNS(const_cast<Document*>(this), namespaceURI, localName);	
+}
+
+
+Element* Document::getElementById(const XMLString& elementId) const
+{
+	return 0;
+}
+
+
+Event* Document::createEvent(const XMLString& eventType) const
+{
+	if (eventType == MutationEvent::DOMSubtreeModified          ||
+	    eventType == MutationEvent::DOMNodeInserted             ||
+		eventType == MutationEvent::DOMNodeRemoved              ||
+		eventType == MutationEvent::DOMNodeRemovedFromDocument  ||
+		eventType == MutationEvent::DOMNodeInsertedIntoDocument ||
+		eventType == MutationEvent::DOMAttrModified             ||
+		eventType == MutationEvent::DOMCharacterDataModified)
+	{
+		return new MutationEvent(const_cast<Document*>(this), eventType);
+	}
+	throw DOMException(DOMException::NOT_SUPPORTED_ERR);
+}
+
+
+Node* Document::copyNode(bool deep, Document* pOwnerDocument) const
+{
+	throw DOMException(DOMException::NOT_SUPPORTED_ERR);
+}
+
+
+void Document::setDoctype(DocumentType* pDoctype)
+{
+	if (_pDocumentType) _pDocumentType->release();
+	_pDocumentType = pDoctype;
+	if (_pDocumentType)
+	{
+		_pDocumentType->duplicate();
+		_pDocumentType->setOwnerDocument(this);
+	}
+}
+
+
+bool Document::eventsSuspended() const
+{
+	return _eventSuspendLevel > 0;
+}
+
+
+bool Document::events() const
+{
+	return _eventSuspendLevel == 0;
+}
+
+
+Entity* Document::createEntity(const XMLString& name, const XMLString& publicId, const XMLString& systemId, const XMLString& notationName) const
+{
+	return new Entity(const_cast<Document*>(this), name, publicId, systemId, notationName);
+}
+
+
+Notation* Document::createNotation(const XMLString& name, const XMLString& publicId, const XMLString& systemId) const
+{
+	return new Notation(const_cast<Document*>(this), name, publicId, systemId);
+}
+
+
+Element* Document::getElementById(const XMLString& elementId, const XMLString& idAttribute) const
+{
+	Element* pElem = documentElement();
+	if (pElem) pElem = pElem->getElementById(elementId, idAttribute);
+	return pElem;
+}
+
+
+Element* Document::getElementByIdNS(const XMLString& elementId, const XMLString& idAttributeURI, const XMLString& idAttributeLocalName) const
+{
+	Element* pElem = documentElement();
+	if (pElem) pElem = pElem->getElementByIdNS(elementId, idAttributeURI, idAttributeLocalName);
+	return pElem;
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/DocumentEvent.cpp b/base/poco/XML/src/DocumentEvent.cpp
new file mode 100644
index 00000000000..943e69f67db
--- /dev/null
+++ b/base/poco/XML/src/DocumentEvent.cpp
@@ -0,0 +1,27 @@
+//
+// DocumentEvent.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/DocumentEvent.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+DocumentEvent::~DocumentEvent()
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/DocumentFragment.cpp b/base/poco/XML/src/DocumentFragment.cpp
new file mode 100644
index 00000000000..462be5292e2
--- /dev/null
+++ b/base/poco/XML/src/DocumentFragment.cpp
@@ -0,0 +1,70 @@
+//
+// DocumentFragment.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/DocumentFragment.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+const XMLString DocumentFragment::NODE_NAME = toXMLString("#document-fragment");
+
+
+DocumentFragment::DocumentFragment(Document* pOwnerDocument): 
+	AbstractContainerNode(pOwnerDocument)
+{
+}
+
+
+DocumentFragment::DocumentFragment( Document* pOwnerDocument, const DocumentFragment& fragment): 
+	AbstractContainerNode(pOwnerDocument, fragment)
+{
+}
+
+
+DocumentFragment::~DocumentFragment()
+{
+}
+
+
+const XMLString& DocumentFragment::nodeName() const
+{
+	return NODE_NAME;
+}
+
+
+unsigned short DocumentFragment::nodeType() const
+{
+	return Node::DOCUMENT_FRAGMENT_NODE;
+}
+
+
+Node* DocumentFragment::copyNode(bool deep, Document* pOwnerDocument) const
+{
+	DocumentFragment* pClone = new DocumentFragment(pOwnerDocument, *this);
+	if (deep)
+	{
+		Node* pCur = firstChild();
+		while (pCur)
+		{
+			pClone->appendChild(static_cast<AbstractNode*>(pCur)->copyNode(deep, pOwnerDocument))->release();
+			pCur = pCur->nextSibling();
+		}
+	}
+	return pClone;
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/DocumentType.cpp b/base/poco/XML/src/DocumentType.cpp
new file mode 100644
index 00000000000..26753a76807
--- /dev/null
+++ b/base/poco/XML/src/DocumentType.cpp
@@ -0,0 +1,84 @@
+//
+// DocumentType.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/DocumentType.h"
+#include "Poco/DOM/Document.h"
+#include "Poco/DOM/DTDMap.h"
+#include "Poco/DOM/DOMException.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+DocumentType::DocumentType(Document* pOwner, const XMLString& name, const XMLString& publicId, const XMLString& systemId): 
+	AbstractContainerNode(pOwner),
+	_name(name),
+	_publicId(publicId),
+	_systemId(systemId)
+{
+}
+
+
+DocumentType::DocumentType(Document* pOwner, const DocumentType& doctype): 
+	AbstractContainerNode(pOwner, doctype),
+	_name(doctype._name),
+	_publicId(doctype._publicId),
+	_systemId(doctype._systemId)
+{
+}
+
+
+DocumentType::~DocumentType()
+{
+}
+
+
+NamedNodeMap* DocumentType::entities() const
+{
+	return new DTDMap(this, Node::ENTITY_NODE);
+}
+
+
+NamedNodeMap* DocumentType::notations() const
+{
+	return new DTDMap(this, Node::NOTATION_NODE);
+}
+
+
+const XMLString& DocumentType::nodeName() const
+{
+	return _name;
+}
+
+
+unsigned short DocumentType::nodeType() const
+{
+	return Node::DOCUMENT_TYPE_NODE;
+}
+
+
+const XMLString& DocumentType::internalSubset() const
+{
+	return EMPTY_STRING;
+}
+
+
+Node* DocumentType::copyNode(bool deep, Document* pOwnerDocument) const
+{
+	return new DocumentType(pOwnerDocument, *this);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/Element.cpp b/base/poco/XML/src/Element.cpp
new file mode 100644
index 00000000000..e66039ade37
--- /dev/null
+++ b/base/poco/XML/src/Element.cpp
@@ -0,0 +1,444 @@
+//
+// Element.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/Element.h"
+#include "Poco/DOM/Document.h"
+#include "Poco/DOM/Attr.h"
+#include "Poco/DOM/DOMException.h"
+#include "Poco/DOM/ElementsByTagNameList.h"
+#include "Poco/DOM/Text.h"
+#include "Poco/DOM/AttrMap.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+Element::Element(Document* pOwnerDocument, const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname):
+	AbstractContainerNode(pOwnerDocument),
+	_name(pOwnerDocument->namePool().insert(qname, namespaceURI, localName)),
+	_pFirstAttr(0)
+{
+}
+
+
+Element::Element(Document* pOwnerDocument, const Element& element): 
+	AbstractContainerNode(pOwnerDocument, element),
+	_name(pOwnerDocument->namePool().insert(element._name)),
+	_pFirstAttr(0)
+{
+	Attr* pAttr = element._pFirstAttr;
+	while (pAttr)
+	{
+		Attr* pClonedAttr = static_cast<Attr*>(pAttr->copyNode(false, pOwnerDocument));
+		setAttributeNode(pClonedAttr);
+		pClonedAttr->release();
+		pAttr = static_cast<Attr*>(pAttr->_pNext);
+	}
+}
+
+
+Element::~Element()
+{
+	if (_pFirstAttr) _pFirstAttr->release();
+}
+
+
+const XMLString& Element::getAttribute(const XMLString& name) const
+{
+	Attr* pAttr = getAttributeNode(name);
+	if (pAttr)
+		return pAttr->getValue();
+	else
+		return EMPTY_STRING;
+}
+
+
+void Element::setAttribute(const XMLString& name, const XMLString& value)
+{
+	Attr* pAttr = getAttributeNode(name);
+	if (pAttr)
+	{
+		pAttr->setValue(value);
+	}
+	else
+	{
+		pAttr = ownerDocument()->createAttribute(name);
+		pAttr->setValue(value);
+		setAttributeNode(pAttr);
+		pAttr->release();
+	}
+}
+
+
+void Element::removeAttribute(const XMLString& name)
+{
+	Attr* pAttr = getAttributeNode(name);
+	if (pAttr) removeAttributeNode(pAttr);
+}
+
+
+Attr* Element::getAttributeNode(const XMLString& name) const
+{
+	Attr* pAttr = _pFirstAttr;
+	while (pAttr && pAttr->_name.qname() != name) pAttr = static_cast<Attr*>(pAttr->_pNext);
+	return pAttr;
+}
+
+
+Attr* Element::setAttributeNode(Attr* newAttr)
+{
+	poco_check_ptr (newAttr);
+
+	if (newAttr->ownerDocument() != ownerDocument())
+		throw DOMException(DOMException::WRONG_DOCUMENT_ERR);
+	if (newAttr->ownerElement())
+		throw DOMException(DOMException::INUSE_ATTRIBUTE_ERR);
+
+	Attr* oldAttr = getAttributeNode(newAttr->name());
+	if (oldAttr) removeAttributeNode(oldAttr);
+
+	Attr* pCur = _pFirstAttr;
+	if (pCur)
+	{
+		while (pCur->_pNext) pCur = static_cast<Attr*>(pCur->_pNext);
+		pCur->_pNext = newAttr;
+	}
+	else _pFirstAttr = newAttr;
+	newAttr->duplicate();
+	newAttr->_pParent = this;
+	if (_pOwner->events())
+		dispatchAttrModified(newAttr, MutationEvent::ADDITION, EMPTY_STRING, newAttr->getValue());
+
+	return oldAttr;
+}
+
+
+Attr* Element::removeAttributeNode(Attr* oldAttr)
+{
+	poco_check_ptr (oldAttr);
+
+	if (_pOwner->events()) 
+		dispatchAttrModified(oldAttr, MutationEvent::REMOVAL, oldAttr->getValue(), EMPTY_STRING);
+
+	if (oldAttr != _pFirstAttr)
+	{
+		Attr* pCur = _pFirstAttr;
+		while (pCur->_pNext != oldAttr) pCur = static_cast<Attr*>(pCur->_pNext);
+		if (pCur)
+		{
+			pCur->_pNext = static_cast<Attr*>(pCur->_pNext->_pNext);
+		}
+		else throw DOMException(DOMException::NOT_FOUND_ERR);
+	}
+	else _pFirstAttr = static_cast<Attr*>(_pFirstAttr->_pNext);
+	oldAttr->_pNext   = 0;
+	oldAttr->_pParent = 0;
+	oldAttr->autoRelease();
+
+	return oldAttr;
+}
+
+
+Attr* Element::addAttributeNodeNP(Attr* oldAttr, Attr* newAttr)
+{
+	newAttr->_pParent = this;
+	if (oldAttr)
+	{
+		oldAttr->_pNext = newAttr;
+	}
+	else if (_pFirstAttr)
+	{
+		newAttr->_pNext = _pFirstAttr;
+		_pFirstAttr = newAttr;
+	}
+	else
+	{
+		_pFirstAttr = newAttr;
+	}
+	newAttr->duplicate();
+	return newAttr;
+}
+
+
+NodeList* Element::getElementsByTagName(const XMLString& name) const
+{
+	return new ElementsByTagNameList(this, name);
+}
+
+
+NodeList* Element::getElementsByTagNameNS(const XMLString& namespaceURI, const XMLString& localName) const
+{
+	return new ElementsByTagNameListNS(this, namespaceURI, localName);
+}
+
+
+void Element::normalize()
+{
+	Node* pCur = firstChild();
+	while (pCur)
+	{
+		if (pCur->nodeType() == Node::ELEMENT_NODE)
+		{
+			pCur->normalize();
+		}
+		else if (pCur->nodeType() == Node::TEXT_NODE)
+		{
+			Node* pNext = pCur->nextSibling();
+			while (pNext && pNext->nodeType() == Node::TEXT_NODE)
+			{
+				static_cast<Text*>(pCur)->appendData(pNext->nodeValue());
+				removeChild(pNext);
+				pNext = pCur->nextSibling();
+			}
+		}
+		pCur = pCur->nextSibling();
+	}
+}
+
+
+const XMLString& Element::nodeName() const
+{
+	return tagName();
+}
+
+
+NamedNodeMap* Element::attributes() const
+{
+	return new AttrMap(const_cast<Element*>(this));
+}
+
+
+unsigned short Element::nodeType() const
+{
+	return Node::ELEMENT_NODE;
+}
+
+
+const XMLString& Element::getAttributeNS(const XMLString& namespaceURI, const XMLString& localName) const
+{
+	Attr* pAttr = getAttributeNodeNS(namespaceURI, localName);
+	if (pAttr)
+		return pAttr->getValue();
+	else
+		return EMPTY_STRING;
+}
+
+
+void Element::setAttributeNS(const XMLString& namespaceURI, const XMLString& qualifiedName, const XMLString& value)
+{
+	Attr* pAttr = getAttributeNodeNS(namespaceURI, qualifiedName);
+	if (pAttr)
+	{
+		pAttr->setValue(value);
+	}
+	else
+	{
+		pAttr = _pOwner->createAttributeNS(namespaceURI, qualifiedName);
+		pAttr->setValue(value);
+		setAttributeNodeNS(pAttr);
+		pAttr->release();
+	}
+}
+
+
+void Element::removeAttributeNS(const XMLString& namespaceURI, const XMLString& localName)
+{
+	Attr* pAttr = getAttributeNodeNS(namespaceURI, localName);
+	if (pAttr) removeAttributeNode(pAttr);
+}
+
+
+Attr* Element::getAttributeNodeNS(const XMLString& namespaceURI, const XMLString& localName) const
+{
+	Attr* pAttr = _pFirstAttr;
+	while (pAttr && (pAttr->_name.namespaceURI() != namespaceURI || pAttr->_name.localName() != localName)) pAttr = static_cast<Attr*>(pAttr->_pNext);
+	return pAttr;
+}
+
+
+Attr* Element::setAttributeNodeNS(Attr* newAttr)
+{
+	poco_check_ptr (newAttr);
+
+	if (newAttr->ownerDocument() != ownerDocument())
+		throw DOMException(DOMException::WRONG_DOCUMENT_ERR);
+	if (newAttr->ownerElement())
+		throw DOMException(DOMException::INUSE_ATTRIBUTE_ERR);
+
+	Attr* oldAttr = getAttributeNodeNS(newAttr->namespaceURI(), newAttr->localName());
+	if (oldAttr) removeAttributeNode(oldAttr);
+
+	Attr* pCur = _pFirstAttr;
+	if (pCur)
+	{
+		while (pCur->_pNext) pCur = static_cast<Attr*>(pCur->_pNext);
+		pCur->_pNext = newAttr;
+	}
+	else _pFirstAttr = newAttr;
+	newAttr->_pParent = this;
+	newAttr->duplicate();
+	if (_pOwner->events())
+		dispatchAttrModified(newAttr, MutationEvent::ADDITION, EMPTY_STRING, newAttr->getValue());
+
+	return oldAttr;
+}
+
+
+bool Element::hasAttribute(const XMLString& name) const
+{
+	return getAttributeNode(name) != 0;
+}
+
+
+bool Element::hasAttributeNS(const XMLString& namespaceURI, const XMLString& localName) const
+{
+	return getAttributeNodeNS(namespaceURI, localName) != 0;
+}
+
+
+const XMLString& Element::namespaceURI() const
+{
+	return _name.namespaceURI();
+}
+
+
+XMLString Element::prefix() const
+{
+	return _name.prefix();
+}
+
+
+const XMLString& Element::localName() const
+{
+	return _name.localName();
+}
+
+
+bool Element::hasAttributes() const
+{
+	return _pFirstAttr != 0;
+}
+
+
+XMLString Element::innerText() const
+{
+	XMLString result;
+	Node* pChild = firstChild();
+	while (pChild)
+	{
+		result.append(pChild->innerText());
+		pChild = pChild->nextSibling();
+	}
+	return result;
+}
+
+
+Element* Element::getChildElement(const XMLString& name) const
+{
+	Node* pNode = firstChild();
+	while (pNode && !(pNode->nodeType() == Node::ELEMENT_NODE && pNode->nodeName() == name))
+		pNode = pNode->nextSibling();
+	return static_cast<Element*>(pNode);
+}
+
+
+Element* Element::getChildElementNS(const XMLString& namespaceURI, const XMLString& localName) const
+{
+	Node* pNode = firstChild();
+	while (pNode && !(pNode->nodeType() == Node::ELEMENT_NODE && pNode->namespaceURI() == namespaceURI && pNode->localName() == localName))
+		pNode = pNode->nextSibling();
+	return static_cast<Element*>(pNode);
+}
+
+
+void Element::dispatchNodeRemovedFromDocument()
+{
+	AbstractContainerNode::dispatchNodeRemovedFromDocument();
+	Attr* pAttr = _pFirstAttr;
+	while (pAttr)
+	{
+		pAttr->dispatchNodeRemovedFromDocument();
+		pAttr = static_cast<Attr*>(pAttr->_pNext);
+	}
+}
+
+
+void Element::dispatchNodeInsertedIntoDocument()
+{
+	AbstractContainerNode::dispatchNodeInsertedIntoDocument();
+	Attr* pAttr = _pFirstAttr;
+	while (pAttr)
+	{
+		pAttr->dispatchNodeInsertedIntoDocument();
+		pAttr = static_cast<Attr*>(pAttr->_pNext);
+	}
+}
+
+
+Node* Element::copyNode(bool deep, Document* pOwnerDocument) const
+{
+	Element* pClone = new Element(pOwnerDocument, *this);
+	if (deep)
+	{
+		Node* pNode = firstChild();
+		while (pNode)
+		{
+			pClone->appendChild(static_cast<AbstractNode*>(pNode)->copyNode(true, pOwnerDocument))->release();
+			pNode = pNode->nextSibling();
+		}
+	}
+	return pClone;
+}
+
+
+Element* Element::getElementById(const XMLString& elementId, const XMLString& idAttribute) const
+{
+	if (getAttribute(idAttribute) == elementId)
+		return const_cast<Element*>(this);
+
+	Node* pNode = firstChild();
+	while (pNode)
+	{
+		if (pNode->nodeType() == Node::ELEMENT_NODE)
+		{
+			Element* pResult = static_cast<Element*>(pNode)->getElementById(elementId, idAttribute);
+			if (pResult) return pResult;
+		}
+		pNode = pNode->nextSibling();
+	}
+	return 0;
+}
+
+
+Element* Element::getElementByIdNS(const XMLString& elementId, const XMLString& idAttributeURI, const XMLString& idAttributeLocalName) const
+{
+	if (getAttributeNS(idAttributeURI, idAttributeLocalName) == elementId)
+		return const_cast<Element*>(this);
+
+	Node* pNode = firstChild();
+	while (pNode)
+	{
+		if (pNode->nodeType() == Node::ELEMENT_NODE)
+		{
+			Element* pResult = static_cast<Element*>(pNode)->getElementByIdNS(elementId, idAttributeURI, idAttributeLocalName);
+			if (pResult) return pResult;
+		}
+		pNode = pNode->nextSibling();
+	}
+	return 0;
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/ElementsByTagNameList.cpp b/base/poco/XML/src/ElementsByTagNameList.cpp
new file mode 100644
index 00000000000..d6bc382ff68
--- /dev/null
+++ b/base/poco/XML/src/ElementsByTagNameList.cpp
@@ -0,0 +1,151 @@
+//
+// ElementsByTagNameList.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/ElementsByTagNameList.h"
+#include "Poco/DOM/Node.h"
+#include "Poco/DOM/Document.h"
+#include <climits>
+
+
+namespace Poco {
+namespace XML {
+
+
+ElementsByTagNameList::ElementsByTagNameList(const Node* pParent, const XMLString& name):
+	_pParent(pParent),
+	_name(name),
+	_count(0)
+{
+	poco_check_ptr (pParent);
+	
+	_pParent->duplicate();
+}
+
+
+ElementsByTagNameList::~ElementsByTagNameList()
+{
+	_pParent->release();
+}
+
+
+Node* ElementsByTagNameList::item(unsigned long index) const
+{
+	_count = 0;
+	return find(_pParent, index);
+}
+
+
+unsigned long ElementsByTagNameList::length() const
+{
+	_count = 0;
+	find(_pParent, ULONG_MAX);
+	return _count;
+}
+
+
+namespace
+{
+	static const XMLString asterisk = toXMLString("*");
+}
+
+
+Node* ElementsByTagNameList::find(const Node* pParent, unsigned long index) const
+{
+	if (!pParent) return 0;
+
+	// preorder search
+	Node* pCur = pParent->firstChild();
+	while (pCur)
+	{
+		if (pCur->nodeType() == Node::ELEMENT_NODE && (_name == asterisk || pCur->nodeName() == _name))
+		{
+			if (_count == index) return pCur;
+			_count++;
+		}
+		Node* pNode = find(pCur, index);
+		if (pNode) return pNode;
+		pCur = pCur->nextSibling();
+	}
+	return pCur;
+}
+
+
+void ElementsByTagNameList::autoRelease()
+{
+	_pParent->ownerDocument()->autoReleasePool().add(this);
+}
+
+
+ElementsByTagNameListNS::ElementsByTagNameListNS(const Node* pParent, const XMLString& namespaceURI, const XMLString& localName):
+	_pParent(pParent),
+	_localName(localName),
+	_namespaceURI(namespaceURI),
+	_count(0)
+{
+	poco_check_ptr (pParent);
+	
+	_pParent->duplicate();
+}
+
+
+
+ElementsByTagNameListNS::~ElementsByTagNameListNS()
+{
+	_pParent->release();
+}
+
+
+Node* ElementsByTagNameListNS::item(unsigned long index) const
+{
+	_count = 0;
+	return find(_pParent, index);
+}
+
+
+unsigned long ElementsByTagNameListNS::length() const
+{
+	_count = 0;
+	find(_pParent, ULONG_MAX);
+	return _count;
+}
+
+
+Node* ElementsByTagNameListNS::find(const Node* pParent, unsigned long index) const
+{
+	if (!pParent) return 0;
+
+	// preorder search
+	Node* pCur = pParent->firstChild();
+	while (pCur)
+	{
+		if (pCur->nodeType() == Node::ELEMENT_NODE && (_localName == asterisk || pCur->localName() == _localName) && (_namespaceURI == asterisk || pCur->namespaceURI() == _namespaceURI))
+		{
+			if (_count == index) return pCur;
+			_count++;
+		}
+		Node* pNode = find(pCur, index);
+		if (pNode) return pNode;
+		pCur = pCur->nextSibling();
+	}
+	return pCur;
+}
+
+
+void ElementsByTagNameListNS::autoRelease()
+{
+	_pParent->ownerDocument()->autoReleasePool().add(this);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/Entity.cpp b/base/poco/XML/src/Entity.cpp
new file mode 100644
index 00000000000..226b57b1935
--- /dev/null
+++ b/base/poco/XML/src/Entity.cpp
@@ -0,0 +1,68 @@
+//
+// Entity.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/Entity.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+const XMLString Entity::NODE_NAME = toXMLString("#entity");
+
+
+Entity::Entity(Document* pOwnerDocument, const XMLString& name, const XMLString& publicId, const XMLString& systemId, const XMLString& notationName): 
+	AbstractContainerNode(pOwnerDocument),
+	_name(name),
+	_publicId(publicId),
+	_systemId(systemId),
+	_notationName(notationName)
+{
+}
+
+
+Entity::Entity(Document* pOwnerDocument, const Entity& entity): 
+	AbstractContainerNode(pOwnerDocument, entity),
+	_name(entity._name),
+	_publicId(entity._publicId),
+	_systemId(entity._systemId),
+	_notationName(entity._notationName)
+{
+}
+
+
+Entity::~Entity()
+{
+}
+
+
+const XMLString& Entity::nodeName() const
+{
+	return _name;
+}
+
+
+unsigned short Entity::nodeType() const
+{
+	return Node::ENTITY_NODE;
+}
+
+
+Node* Entity::copyNode(bool deep, Document* pOwnerDocument) const
+{
+	return new Entity(pOwnerDocument, *this);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/EntityReference.cpp b/base/poco/XML/src/EntityReference.cpp
new file mode 100644
index 00000000000..c57b4e80771
--- /dev/null
+++ b/base/poco/XML/src/EntityReference.cpp
@@ -0,0 +1,59 @@
+//
+// EntityReference.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/EntityReference.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+EntityReference::EntityReference(Document* pOwnerDocument, const XMLString& name): 
+	AbstractNode(pOwnerDocument),
+	_name(name)
+{
+}
+
+
+EntityReference::EntityReference(Document* pOwnerDocument, const EntityReference& ref): 
+	AbstractNode(pOwnerDocument, ref),
+	_name(ref._name)
+{
+}
+
+
+EntityReference::~EntityReference()
+{
+}
+
+
+const XMLString& EntityReference::nodeName() const
+{
+	return _name;
+}
+
+
+unsigned short EntityReference::nodeType() const
+{
+	return Node::ENTITY_REFERENCE_NODE;
+}
+
+
+Node* EntityReference::copyNode(bool deep, Document* pOwnerDocument) const
+{
+	return new EntityReference(pOwnerDocument, *this);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/EntityResolver.cpp b/base/poco/XML/src/EntityResolver.cpp
new file mode 100644
index 00000000000..80e1bde9c24
--- /dev/null
+++ b/base/poco/XML/src/EntityResolver.cpp
@@ -0,0 +1,27 @@
+//
+// EntityResolver.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/EntityResolver.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+EntityResolver::~EntityResolver()
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/EntityResolverImpl.cpp b/base/poco/XML/src/EntityResolverImpl.cpp
new file mode 100644
index 00000000000..a072df5e529
--- /dev/null
+++ b/base/poco/XML/src/EntityResolverImpl.cpp
@@ -0,0 +1,78 @@
+//
+// EntityResolverImpl.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/EntityResolverImpl.h"
+#include "Poco/SAX/InputSource.h"
+#include "Poco/XML/XMLString.h"
+#include "Poco/URI.h"
+#include "Poco/Path.h"
+#include "Poco/Exception.h"
+
+
+using Poco::URIStreamOpener;
+using Poco::URI;
+using Poco::Path;
+using Poco::Exception;
+using Poco::IOException;
+using Poco::OpenFileException;
+
+
+namespace Poco {
+namespace XML {
+
+
+EntityResolverImpl::EntityResolverImpl():
+	_opener(URIStreamOpener::defaultOpener())
+{
+}
+
+
+EntityResolverImpl::EntityResolverImpl(const URIStreamOpener& opener):
+	_opener(opener)
+{
+}
+
+
+EntityResolverImpl::~EntityResolverImpl()
+{
+}
+
+
+InputSource* EntityResolverImpl::resolveEntity(const XMLString* publicId, const XMLString& systemId)
+{
+	std::istream* pIstr = resolveSystemId(systemId);
+	InputSource* pInputSource = new InputSource(systemId);
+	if (publicId) pInputSource->setPublicId(*publicId);
+	pInputSource->setByteStream(*pIstr);
+	return pInputSource;
+}
+
+		
+void EntityResolverImpl::releaseInputSource(InputSource* pSource)
+{
+	poco_check_ptr (pSource);
+
+	delete pSource->getByteStream();
+	delete pSource;
+}
+
+
+std::istream* EntityResolverImpl::resolveSystemId(const XMLString& systemId)
+{
+	std::string sid = fromXMLString(systemId);
+	return _opener.open(sid);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/ErrorHandler.cpp b/base/poco/XML/src/ErrorHandler.cpp
new file mode 100644
index 00000000000..6a497a38161
--- /dev/null
+++ b/base/poco/XML/src/ErrorHandler.cpp
@@ -0,0 +1,27 @@
+//
+// ErrorHandler.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/ErrorHandler.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+ErrorHandler::~ErrorHandler()
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/Event.cpp b/base/poco/XML/src/Event.cpp
new file mode 100644
index 00000000000..ffdff7385e6
--- /dev/null
+++ b/base/poco/XML/src/Event.cpp
@@ -0,0 +1,102 @@
+//
+// Event.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMEvents
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/Event.h"
+#include "Poco/DOM/Document.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+Event::Event(Document* pOwnerDocument, const XMLString& type):
+	_pOwner(pOwnerDocument),
+	_type(type),
+	_pTarget(0),
+	_pCurrentTarget(0),
+	_currentPhase(CAPTURING_PHASE),
+	_bubbles(true),
+	_cancelable(true),
+	_canceled(false),
+	_stopped(false)
+{
+}
+
+
+Event::Event(Document* pOwnerDocument, const XMLString& type, EventTarget* pTarget, bool canBubble, bool isCancelable):
+	_pOwner(pOwnerDocument),
+	_type(type),
+	_pTarget(pTarget),
+	_pCurrentTarget(0),
+	_currentPhase(CAPTURING_PHASE),
+	_bubbles(canBubble),
+	_cancelable(isCancelable),
+	_canceled(false),
+	_stopped(false)
+{
+}
+
+
+Event::~Event()
+{
+}
+
+
+void Event::stopPropagation()
+{
+	_stopped = true;
+}
+
+
+void Event::preventDefault()
+{
+	_canceled = true;
+}
+
+
+void Event::initEvent(const XMLString& eventType, bool canBubble, bool isCancelable)
+{
+	_type       = eventType;
+	_bubbles    = canBubble;
+	_cancelable = isCancelable;
+	_canceled   = false;
+	_stopped    = false;
+}
+
+
+void Event::setTarget(EventTarget* pTarget)
+{
+	_pTarget = pTarget;
+}
+
+
+void Event::setCurrentPhase(PhaseType phase)
+{
+	_currentPhase = phase;
+}
+
+
+void Event::setCurrentTarget(EventTarget* pTarget)
+{
+	_pCurrentTarget = pTarget;
+}
+
+
+void Event::autoRelease()
+{
+	_pOwner->autoReleasePool().add(this);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/EventDispatcher.cpp b/base/poco/XML/src/EventDispatcher.cpp
new file mode 100644
index 00000000000..4656f9b45fb
--- /dev/null
+++ b/base/poco/XML/src/EventDispatcher.cpp
@@ -0,0 +1,146 @@
+//
+// EventDispatcher.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMEvents
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/EventDispatcher.h"
+#include "Poco/DOM/Event.h"
+#include "Poco/DOM/EventListener.h"
+
+
+namespace 
+{
+	class DispatchGuard
+	{
+	public:
+		DispatchGuard(int& count):
+			_count(count)
+		{
+			++_count;
+		}
+		
+		~DispatchGuard()
+		{
+			--_count;
+		}
+		
+	private:
+		int& _count;
+	};
+}
+
+
+namespace Poco {
+namespace XML {
+
+
+EventDispatcher::EventDispatcher():
+	_inDispatch(0)
+{
+}
+
+	
+EventDispatcher::~EventDispatcher()
+{
+}
+
+
+void EventDispatcher::addEventListener(const XMLString& type, EventListener* listener, bool useCapture)
+{
+	EventListenerItem item;
+	item.type       = type;
+	item.pListener  = listener;
+	item.useCapture = useCapture;
+	_listeners.push_front(item);
+}
+
+
+void EventDispatcher::removeEventListener(const XMLString& type, EventListener* listener, bool useCapture)
+{
+	EventListenerList::iterator it = _listeners.begin();
+	while (it != _listeners.end())
+	{
+		if (it->type == type && it->pListener == listener && it->useCapture == useCapture)
+		{
+			it->pListener = 0;
+		}
+		if (!_inDispatch && !it->pListener)
+		{
+			EventListenerList::iterator del = it++;
+			_listeners.erase(del);
+		}
+		else ++it;
+	}
+}
+
+
+void EventDispatcher::dispatchEvent(Event* evt)
+{
+	DispatchGuard guard(_inDispatch);
+	EventListenerList::iterator it = _listeners.begin();
+	while (it != _listeners.end())
+	{
+		if (it->pListener && it->type == evt->type())
+		{
+			it->pListener->handleEvent(evt);
+		}
+		if (!it->pListener)
+		{
+			EventListenerList::iterator del = it++;
+			_listeners.erase(del);
+		}
+		else ++it;
+	}
+}
+
+
+void EventDispatcher::captureEvent(Event* evt)
+{
+	DispatchGuard guard(_inDispatch);
+	EventListenerList::iterator it = _listeners.begin();
+	while (it != _listeners.end())
+	{
+		if (it->pListener && it->useCapture && it->type == evt->type())
+		{
+			it->pListener->handleEvent(evt);
+		}
+		if (!it->pListener)
+		{
+			EventListenerList::iterator del = it++;
+			_listeners.erase(del);
+		}
+		else ++it;
+	}
+}
+
+
+void EventDispatcher::bubbleEvent(Event* evt)
+{
+	DispatchGuard guard(_inDispatch);
+	EventListenerList::iterator it = _listeners.begin();
+	while (it != _listeners.end())
+	{
+		if (it->pListener && !it->useCapture && it->type == evt->type())
+		{
+			it->pListener->handleEvent(evt);
+		}
+		if (!it->pListener)
+		{
+			EventListenerList::iterator del = it++;
+			_listeners.erase(del);
+		}
+		else ++it;
+	}
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/EventException.cpp b/base/poco/XML/src/EventException.cpp
new file mode 100644
index 00000000000..844165701f1
--- /dev/null
+++ b/base/poco/XML/src/EventException.cpp
@@ -0,0 +1,65 @@
+//
+// EventException.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMEvents
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/EventException.h"
+#include <typeinfo>
+
+
+namespace Poco {
+namespace XML {
+
+
+EventException::EventException(int code):
+	XMLException("Unspecified event type")
+{
+}
+
+
+EventException::EventException(const EventException& exc):
+	XMLException(exc)
+{
+}
+
+
+EventException::~EventException() noexcept
+{
+}
+
+
+EventException& EventException::operator = (const EventException& exc)
+{
+	XMLException::operator = (exc);
+	return *this;
+}
+
+
+const char* EventException::name() const noexcept
+{
+	return "EventException";
+}
+
+
+const char* EventException::className() const noexcept
+{
+	return typeid(*this).name();
+}
+
+
+Poco::Exception* EventException::clone() const
+{
+	return new EventException(*this);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/EventListener.cpp b/base/poco/XML/src/EventListener.cpp
new file mode 100644
index 00000000000..b6c39888185
--- /dev/null
+++ b/base/poco/XML/src/EventListener.cpp
@@ -0,0 +1,27 @@
+//
+// EventListener.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMEvents
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/EventListener.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+EventListener::~EventListener()
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/EventTarget.cpp b/base/poco/XML/src/EventTarget.cpp
new file mode 100644
index 00000000000..2aa76a0dade
--- /dev/null
+++ b/base/poco/XML/src/EventTarget.cpp
@@ -0,0 +1,27 @@
+//
+// EventTarget.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMEvents
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/EventTarget.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+EventTarget::~EventTarget()
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/InputSource.cpp b/base/poco/XML/src/InputSource.cpp
new file mode 100644
index 00000000000..1ec8cfc0be2
--- /dev/null
+++ b/base/poco/XML/src/InputSource.cpp
@@ -0,0 +1,80 @@
+//
+// InputSource.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/InputSource.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+InputSource::InputSource():
+	_bistr(0),
+	_cistr(0)
+{
+}
+
+
+InputSource::InputSource(const XMLString& systemId):
+	_systemId(systemId),
+	_bistr(0),
+	_cistr(0)
+{
+}
+
+
+InputSource::InputSource(XMLByteInputStream& bistr):
+	_bistr(&bistr),
+	_cistr(0)
+{
+}
+
+
+InputSource::~InputSource()
+{
+}
+
+
+void InputSource::setPublicId(const XMLString& publicId)
+{
+	_publicId = publicId;
+}
+
+
+void InputSource::setSystemId(const XMLString& systemId)
+{
+	_systemId = systemId;
+}
+
+
+void InputSource::setEncoding(const XMLString& encoding)
+{
+	_encoding = encoding;
+}
+
+
+void InputSource::setByteStream(XMLByteInputStream& bistr)
+{
+	_bistr = &bistr;
+}
+
+
+void InputSource::setCharacterStream(XMLCharInputStream& cistr)
+{
+	_cistr = &cistr;
+}
+
+
+} } // namespace Poco::XML
+
diff --git a/base/poco/XML/src/LexicalHandler.cpp b/base/poco/XML/src/LexicalHandler.cpp
new file mode 100644
index 00000000000..52de41d7423
--- /dev/null
+++ b/base/poco/XML/src/LexicalHandler.cpp
@@ -0,0 +1,27 @@
+//
+// LexicalHandler.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/LexicalHandler.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+LexicalHandler::~LexicalHandler()
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/Locator.cpp b/base/poco/XML/src/Locator.cpp
new file mode 100644
index 00000000000..3be93bf7956
--- /dev/null
+++ b/base/poco/XML/src/Locator.cpp
@@ -0,0 +1,27 @@
+//
+// Locator.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/Locator.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+Locator::~Locator()
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/LocatorImpl.cpp b/base/poco/XML/src/LocatorImpl.cpp
new file mode 100644
index 00000000000..a77cc43f601
--- /dev/null
+++ b/base/poco/XML/src/LocatorImpl.cpp
@@ -0,0 +1,104 @@
+//
+// LocatorImpl.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/LocatorImpl.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+LocatorImpl::LocatorImpl()
+{
+	_lineNumber   = 0;
+	_columnNumber = 0;
+}
+
+
+LocatorImpl::LocatorImpl(const Locator& loc)
+{
+	_publicId     = loc.getPublicId();
+	_systemId     = loc.getSystemId();
+	_lineNumber   = loc.getLineNumber();
+	_columnNumber = loc.getColumnNumber();
+}
+
+
+LocatorImpl::~LocatorImpl()
+{
+}
+
+
+LocatorImpl& LocatorImpl::operator = (const Locator& loc)
+{
+	if (&loc != this)
+	{
+		_publicId     = loc.getPublicId();
+		_systemId     = loc.getSystemId();
+		_lineNumber   = loc.getLineNumber();
+		_columnNumber = loc.getColumnNumber();
+	}
+	return *this;
+}
+
+
+XMLString LocatorImpl::getPublicId() const
+{
+	return _publicId;
+}
+
+
+XMLString LocatorImpl::getSystemId() const
+{
+	return _systemId;
+}
+
+
+int LocatorImpl::getLineNumber() const
+{
+	return _lineNumber;
+}
+
+
+int LocatorImpl::getColumnNumber() const
+{
+	return _columnNumber;
+}
+
+
+void LocatorImpl::setPublicId(const XMLString& publicId)
+{
+	_publicId = publicId;
+}
+
+
+void LocatorImpl::setSystemId(const XMLString& systemId)
+{
+	_systemId = systemId;
+}
+
+
+void LocatorImpl::setLineNumber(int lineNumber)
+{
+	_lineNumber = lineNumber;
+}
+
+
+void LocatorImpl::setColumnNumber(int columnNumber)
+{
+	_columnNumber = columnNumber;
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/MutationEvent.cpp b/base/poco/XML/src/MutationEvent.cpp
new file mode 100644
index 00000000000..485836e6b78
--- /dev/null
+++ b/base/poco/XML/src/MutationEvent.cpp
@@ -0,0 +1,76 @@
+//
+// MutationEvent.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOMEvents
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/MutationEvent.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+const XMLString MutationEvent::DOMSubtreeModified          = toXMLString("DOMSubtreeModified");
+const XMLString MutationEvent::DOMNodeInserted             = toXMLString("DOMNodeInserted");
+const XMLString MutationEvent::DOMNodeRemoved              = toXMLString("DOMNodeRemoved");
+const XMLString MutationEvent::DOMNodeRemovedFromDocument  = toXMLString("DOMNodeRemovedFromDocument");
+const XMLString MutationEvent::DOMNodeInsertedIntoDocument = toXMLString("DOMNodeInsertedIntoDocument");
+const XMLString MutationEvent::DOMAttrModified             = toXMLString("DOMAttrModified");
+const XMLString MutationEvent::DOMCharacterDataModified    = toXMLString("DOMCharacterDataModified");
+
+
+MutationEvent::MutationEvent(Document* pOwnerDocument, const XMLString& type): 
+	Event(pOwnerDocument, type, 0, true, false),
+	_change(MODIFICATION),
+	_pRelatedNode(0)
+{
+}
+
+
+MutationEvent::MutationEvent(Document* pOwnerDocument, const XMLString& type, EventTarget* pTarget, bool canBubble, bool cancelable, Node* relatedNode):
+	Event(pOwnerDocument, type, pTarget, canBubble, cancelable),
+	_change(MODIFICATION),
+	_pRelatedNode(relatedNode)
+{
+}
+
+
+MutationEvent::MutationEvent(Document* pOwnerDocument, const XMLString& type, EventTarget* pTarget, bool canBubble, bool cancelable, Node* relatedNode, 
+	                         const XMLString& prevValue, const XMLString& newValue, const XMLString& attrName, AttrChangeType change):
+	Event(pOwnerDocument, type, pTarget, canBubble, cancelable),
+	_prevValue(prevValue),
+	_newValue(newValue),
+	_attrName(attrName),
+	_change(change),
+	_pRelatedNode(relatedNode)
+{
+}
+
+
+MutationEvent::~MutationEvent()
+{
+}
+
+
+void MutationEvent::initMutationEvent(const XMLString& type, bool canBubble, bool cancelable, Node* relatedNode, 
+	                                  const XMLString& prevValue, const XMLString& newValue, const XMLString& attrName, AttrChangeType change)
+{
+	initEvent(type, canBubble, cancelable);
+	_pRelatedNode = relatedNode;
+	_prevValue    = prevValue;
+	_newValue     = newValue;
+	_attrName     = attrName;
+	_change       = change;
+}
+
+	 
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/Name.cpp b/base/poco/XML/src/Name.cpp
new file mode 100644
index 00000000000..b14757d10cd
--- /dev/null
+++ b/base/poco/XML/src/Name.cpp
@@ -0,0 +1,188 @@
+//
+// Name.cpp
+//
+// Library: XML
+// Package: XML
+// Module:  Name
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/XML/Name.h"
+#include <algorithm>
+
+
+namespace Poco {
+namespace XML {
+
+
+const XMLString Name::EMPTY_NAME;
+
+
+Name::Name()
+{
+}
+
+
+Name::Name(const XMLString& qname):
+	_qname(qname)
+{
+}
+
+
+Name::Name(const XMLString& qname, const XMLString& namespaceURI):
+	_qname(qname),
+	_namespaceURI(namespaceURI),
+	_localName(localName(qname))
+{
+}
+
+
+Name::Name(const XMLString& qname, const XMLString& namespaceURI, const XMLString& localName):
+	_qname(qname),
+	_namespaceURI(namespaceURI),
+	_localName(localName)
+{
+}
+
+
+Name::Name(const Name& name):
+	_qname(name._qname),
+	_namespaceURI(name._namespaceURI),
+	_localName(name._localName)
+{
+}
+
+
+Name::Name(Name&& name) noexcept:
+	_qname(std::move(name._qname)),
+	_namespaceURI(std::move(name._namespaceURI)),
+	_localName(std::move(name._localName))
+{
+}
+
+	
+Name::~Name()
+{
+}
+
+
+Name& Name::operator = (const Name& name)
+{
+	if (this != &name)
+	{
+		_qname        = name._qname;
+		_namespaceURI = name._namespaceURI;
+		_localName    = name._localName;
+	}
+	return *this;
+}
+
+
+Name& Name::operator = (Name&& name) noexcept
+{
+	_qname        = std::move(name._qname);
+	_namespaceURI = std::move(name._namespaceURI);
+	_localName    = std::move(name._localName);
+
+	return *this;
+}
+
+
+void Name::swap(Name& name)
+{
+	std::swap(_qname, name._qname);
+	std::swap(_namespaceURI, name._namespaceURI);
+	std::swap(_localName, name._localName);
+}
+
+
+void Name::assign(const XMLString& qname)
+{
+	_qname        = qname;
+	_namespaceURI.clear();
+	_localName.clear();
+}
+
+
+void Name::assign(const XMLString& qname, const XMLString& namespaceURI)
+{
+	_qname        = qname;
+	_namespaceURI = namespaceURI;
+	_localName    = localName(qname);
+}
+
+
+void Name::assign(const XMLString& qname, const XMLString& namespaceURI, const XMLString& localName)
+{
+	_qname        = qname;
+	_namespaceURI = namespaceURI;
+	_localName    = localName;
+}
+
+
+bool Name::equals(const Name& name) const
+{
+	return name._namespaceURI == _namespaceURI && name._localName == _localName && name._qname == _qname;
+}
+
+
+bool Name::equals(const XMLString& qname, const XMLString& namespaceURI, const XMLString& localName) const
+{
+	return _namespaceURI == namespaceURI && _localName == localName && _qname == qname;
+}
+
+
+bool Name::equalsWeakly(const XMLString& qname, const XMLString& namespaceURI, const XMLString& localName) const
+{
+	return (_qname == qname && !qname.empty()) || (_namespaceURI == namespaceURI && _localName == localName && !_localName.empty());
+}
+
+
+XMLString Name::prefix() const
+{
+	return prefix(_qname);
+}
+
+
+void Name::split(const XMLString& qname, XMLString& prefix, XMLString& localName)
+{
+	XMLString::size_type pos = qname.find(':');
+	if (pos != XMLString::npos)
+	{
+		prefix.assign(qname, 0, pos);
+		localName.assign(qname, pos + 1, qname.size() - pos - 1);
+	}
+	else
+	{
+		prefix.clear();
+		localName.assign(qname);
+	}
+}
+
+
+XMLString Name::localName(const XMLString& qname)
+{
+	XMLString::size_type pos = qname.find(':');
+	if (pos != XMLString::npos) 
+		return XMLString(qname, pos + 1, qname.size() - pos - 1);
+	else
+		return qname;
+}
+
+
+XMLString Name::prefix(const XMLString& qname)
+{
+	XMLString::size_type pos = qname.find(':');
+	if (pos != XMLString::npos)
+		return XMLString(qname, 0, pos);
+	else
+		return EMPTY_NAME;
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/NamePool.cpp b/base/poco/XML/src/NamePool.cpp
new file mode 100644
index 00000000000..4e234eabf9d
--- /dev/null
+++ b/base/poco/XML/src/NamePool.cpp
@@ -0,0 +1,132 @@
+//
+// NamePool.cpp
+//
+// Library: XML
+// Package: XML
+// Module:  NamePool
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/XML/NamePool.h"
+#include "Poco/Exception.h"
+#include "Poco/Random.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+class NamePoolItem
+{
+public:
+	NamePoolItem(): _used(false)
+	{
+	}
+	
+	~NamePoolItem()
+	{
+	}
+	
+	bool set(const XMLString& qname, const XMLString& namespaceURI, const XMLString& localName)
+	{
+		if (!_used)
+		{
+			_name.assign(qname, namespaceURI, localName);
+			_used = true;
+			return true;
+		}
+		else return _name.equals(qname, namespaceURI, localName);
+	}
+	
+	const Name& get() const
+	{
+		return _name;
+	}
+	
+	bool used() const
+	{
+		return _used;
+	}
+	
+private:
+	Name _name;
+	bool _used;
+};
+
+
+NamePool::NamePool(unsigned long size): 
+	_size(size),
+	_salt(0),
+	_rc(1)
+{
+	poco_assert (size > 1);
+
+	_pItems = new NamePoolItem[size];
+	
+	Poco::Random rnd;
+	rnd.seed();
+	_salt = rnd.next();
+}
+
+
+NamePool::~NamePool()
+{
+	delete [] _pItems;
+}
+
+
+void NamePool::duplicate()
+{
+	++_rc;
+}
+
+
+void NamePool::release()
+{
+	if (--_rc == 0)
+		delete this;
+}
+
+
+const Name& NamePool::insert(const XMLString& qname, const XMLString& namespaceURI, const XMLString& localName)
+{
+	unsigned long i = 0;
+	unsigned long n = (hash(qname, namespaceURI, localName) ^ _salt) % _size;
+
+	while (!_pItems[n].set(qname, namespaceURI, localName) && i++ < _size) 
+		n = (n + 1) % _size;
+		
+	if (i > _size) throw Poco::PoolOverflowException("XML name pool");
+
+	return _pItems[n].get();
+}
+
+
+const Name& NamePool::insert(const Name& name)
+{
+	return insert(name.qname(), name.namespaceURI(), name.localName());
+}
+
+
+unsigned long NamePool::hash(const XMLString& qname, const XMLString& namespaceURI, const XMLString& localName)
+{
+	unsigned long h = 0;
+	XMLString::const_iterator it  = qname.begin();
+	XMLString::const_iterator end = qname.end();
+	while (it != end) h = (h << 5) + h + (unsigned long) *it++;
+	it =  namespaceURI.begin();
+	end = namespaceURI.end();
+	while (it != end) h = (h << 5) + h + (unsigned long) *it++;
+	it  = localName.begin();
+	end = localName.end();
+	while (it != end) h = (h << 5) + h + (unsigned long) *it++;
+	return h;
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/NamedNodeMap.cpp b/base/poco/XML/src/NamedNodeMap.cpp
new file mode 100644
index 00000000000..91108bf534e
--- /dev/null
+++ b/base/poco/XML/src/NamedNodeMap.cpp
@@ -0,0 +1,27 @@
+//
+// NamedNodeMap.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/NamedNodeMap.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+NamedNodeMap::~NamedNodeMap()
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/NamespaceStrategy.cpp b/base/poco/XML/src/NamespaceStrategy.cpp
new file mode 100644
index 00000000000..cfdccd6ecab
--- /dev/null
+++ b/base/poco/XML/src/NamespaceStrategy.cpp
@@ -0,0 +1,195 @@
+//
+// NamespaceStrategy.cpp
+//
+// Library: XML
+// Package: XML
+// Module:  NamespaceStrategy
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/XML/NamespaceStrategy.h"
+#include "Poco/SAX/AttributesImpl.h"
+#include "Poco/SAX/ContentHandler.h"
+#include "Poco/XML/XMLException.h"
+#include "Poco/XML/Name.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+const XMLString NamespaceStrategy::NOTHING;
+
+
+NamespaceStrategy::~NamespaceStrategy()
+{
+}
+
+
+void NamespaceStrategy::splitName(const XMLChar* qname, XMLString& uri, XMLString& localName)
+{
+	for (const XMLChar* p = qname; *p; ++p)
+	{
+		if (*p == '\t')
+		{
+			uri.assign(qname, p - qname);
+			localName.assign(p + 1);
+			return;
+		}
+	}
+	localName = qname;
+}
+
+
+void NamespaceStrategy::splitName(const XMLChar* qname, XMLString& uri, XMLString& localName, XMLString& prefix)
+{
+	const XMLChar* p = qname;
+	while (*p && *p != '\t') ++p;
+	if (*p)
+	{
+		uri.assign(qname, p - qname);
+		++p;
+		const XMLChar* loc = p;
+		while (*p && *p != '\t') ++p;
+		localName.assign(loc, p - loc);
+		if (*p)
+			prefix.assign(++p);
+		else
+			prefix.assign(XML_LIT(""));
+	}
+	else 
+	{
+		uri.assign(XML_LIT(""));
+		localName = qname;
+		prefix.assign(XML_LIT(""));
+	}	
+}
+
+
+NoNamespacesStrategy::NoNamespacesStrategy()
+{
+	_attrs.reserve(32);
+}
+
+
+NoNamespacesStrategy::~NoNamespacesStrategy()
+{
+}
+
+
+void NoNamespacesStrategy::startElement(const XMLChar* name, const XMLChar** atts, int specifiedCount, ContentHandler* pContentHandler)
+{
+	poco_assert_dbg (name && atts && pContentHandler);
+
+	_attrs.clear();
+	for (int i = 0; *atts; ++i)
+	{
+		AttributesImpl::Attribute& attr = _attrs.addAttribute();
+		attr.qname.assign(*atts++);
+		attr.value.assign(*atts++);
+		attr.specified = i < specifiedCount;
+	}
+	_name.assign(name);
+	pContentHandler->startElement(NOTHING, NOTHING, _name, _attrs);
+}
+
+
+void NoNamespacesStrategy::endElement(const XMLChar* name, ContentHandler* pContentHandler)
+{
+	poco_assert_dbg (name && pContentHandler);
+
+	_name.assign(name);
+	pContentHandler->endElement(NOTHING, NOTHING, _name);
+}
+
+
+NoNamespacePrefixesStrategy::NoNamespacePrefixesStrategy()
+{
+	_attrs.reserve(32);
+}
+
+
+NoNamespacePrefixesStrategy::~NoNamespacePrefixesStrategy()
+{
+}
+
+
+void NoNamespacePrefixesStrategy::startElement(const XMLChar* name, const XMLChar** atts, int specifiedCount, ContentHandler* pContentHandler)
+{
+	poco_assert_dbg (name && atts && pContentHandler);
+
+	_attrs.clear();
+	for (int i = 0; *atts; ++i)
+	{
+		const XMLChar* attrName  = *atts++;
+		const XMLChar* attrValue = *atts++;
+		AttributesImpl::Attribute& attr = _attrs.addAttribute();
+		splitName(attrName, attr.namespaceURI, attr.localName);
+		attr.value.assign(attrValue);
+		attr.specified = i < specifiedCount;
+	}
+	splitName(name, _uri, _local);
+	pContentHandler->startElement(_uri, _local, NOTHING, _attrs);
+}
+
+
+void NoNamespacePrefixesStrategy::endElement(const XMLChar* name, ContentHandler* pContentHandler)
+{
+	poco_assert_dbg (name && pContentHandler);
+
+	splitName(name, _uri, _local);
+	pContentHandler->endElement(_uri, _local, NOTHING);
+}
+
+
+NamespacePrefixesStrategy::NamespacePrefixesStrategy()
+{
+	_attrs.reserve(32);
+}
+
+
+NamespacePrefixesStrategy::~NamespacePrefixesStrategy()
+{
+}
+
+
+void NamespacePrefixesStrategy::startElement(const XMLChar* name, const XMLChar** atts, int specifiedCount, ContentHandler* pContentHandler)
+{
+	poco_assert_dbg (name && atts && pContentHandler);
+
+	_attrs.clear();
+	for (int i = 0; *atts; ++i)
+	{
+		const XMLChar* attrName  = *atts++;
+		const XMLChar* attrValue = *atts++;
+		AttributesImpl::Attribute& attr = _attrs.addAttribute();
+		splitName(attrName, attr.namespaceURI, attr.localName, attr.qname);
+		if (!attr.qname.empty()) attr.qname += ':';
+		attr.qname.append(attr.localName);
+		attr.value.assign(attrValue);
+		attr.specified = i < specifiedCount;
+	}
+	splitName(name, _uri, _local, _qname);
+	if (!_qname.empty()) _qname += ':';
+	_qname.append(_local);
+	pContentHandler->startElement(_uri, _local, _qname, _attrs);
+}
+
+
+void NamespacePrefixesStrategy::endElement(const XMLChar* name, ContentHandler* pContentHandler)
+{
+	poco_assert_dbg (name && pContentHandler);
+
+	splitName(name, _uri, _local, _qname);
+	if (!_qname.empty()) _qname += ':';
+	_qname.append(_local);
+	pContentHandler->endElement(_uri, _local, _qname);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/NamespaceSupport.cpp b/base/poco/XML/src/NamespaceSupport.cpp
new file mode 100644
index 00000000000..b398b97f7ba
--- /dev/null
+++ b/base/poco/XML/src/NamespaceSupport.cpp
@@ -0,0 +1,187 @@
+//
+// NamespaceSupport.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/NamespaceSupport.h"
+#include "Poco/XML/Name.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+const XMLString NamespaceSupport::EMPTY_STRING;
+const XMLString NamespaceSupport::XML_NAMESPACE          = toXMLString("http://www.w3.org/XML/1998/namespace");
+const XMLString NamespaceSupport::XML_NAMESPACE_PREFIX   = toXMLString("xml");
+const XMLString NamespaceSupport::XMLNS_NAMESPACE        = toXMLString("http://www.w3.org/xmlns/2000/");
+const XMLString NamespaceSupport::XMLNS_NAMESPACE_PREFIX = toXMLString("xmlns");
+
+
+NamespaceSupport::NamespaceSupport()
+{
+	reset();
+}
+
+
+NamespaceSupport::~NamespaceSupport()
+{
+}
+
+
+bool NamespaceSupport::declarePrefix(const XMLString& prefix, const XMLString& namespaceURI)
+{
+	poco_assert (_contexts.size() > 0);
+
+	Context& ctx = _contexts.back();
+	if (ctx.find(prefix) == ctx.end())
+	{
+		ctx.insert(Context::value_type(prefix, namespaceURI));
+		return true;
+	}
+	else return false;
+}
+
+
+bool NamespaceSupport::undeclarePrefix(const XMLString& prefix)
+{
+	for (ContextVec::reverse_iterator rit = _contexts.rbegin(); rit != _contexts.rend(); ++rit)
+	{
+		Context::iterator it = rit->find(prefix);
+		if (it != rit->end())
+		{
+			rit->erase(it);
+			return true;
+		}
+	}
+	return false;
+}
+
+
+void NamespaceSupport::getDeclaredPrefixes(PrefixSet& prefixes) const
+{
+	prefixes.clear();
+	const Context& ctx = _contexts.back();
+	for (const auto& p: ctx)
+		prefixes.insert(p.first);
+}
+
+
+const XMLString& NamespaceSupport::getPrefix(const XMLString& namespaceURI) const
+{
+	for (ContextVec::const_reverse_iterator rit = _contexts.rbegin(); rit != _contexts.rend(); ++rit)
+	{
+		for (Context::const_iterator it = rit->begin(); it != rit->end(); ++it)
+		{
+			if (it->second == namespaceURI) 
+				return it->first;
+		}
+	}
+	return EMPTY_STRING;
+}
+
+
+bool NamespaceSupport::isMapped(const XMLString& namespaceURI) const
+{
+	for (ContextVec::const_reverse_iterator rit = _contexts.rbegin(); rit != _contexts.rend(); ++rit)
+	{
+		for (Context::const_iterator it = rit->begin(); it != rit->end(); ++it)
+		{
+			if (it->second == namespaceURI) 
+				return true;
+		}
+	}
+	return false;
+}
+
+
+void NamespaceSupport::getPrefixes(PrefixSet& prefixes) const
+{
+	prefixes.clear();
+	for (ContextVec::const_reverse_iterator rit = _contexts.rbegin(); rit != _contexts.rend(); ++rit)
+	{
+		for (Context::const_iterator it = rit->begin(); it != rit->end(); ++it)
+		{
+			const XMLString& prefix = it->first;
+			if (!prefix.empty() && prefixes.find(prefix) == prefixes.end()) 
+				prefixes.insert(it->first);
+		}
+	}
+}
+
+
+void NamespaceSupport::getPrefixes(const XMLString& namespaceURI, PrefixSet& prefixes) const
+{
+	prefixes.clear();
+	for (ContextVec::const_reverse_iterator rit = _contexts.rbegin(); rit != _contexts.rend(); ++rit)
+	{
+		for (Context::const_iterator it = rit->begin(); it != rit->end(); ++it)
+		{
+			const XMLString& prefix = it->first;
+			if (it->second == namespaceURI && !prefix.empty() && prefixes.find(prefix) == prefixes.end()) 
+				prefixes.insert(it->first);
+		}
+	}
+}
+
+
+const XMLString& NamespaceSupport::getURI(const XMLString& prefix) const
+{
+	for (ContextVec::const_reverse_iterator rit = _contexts.rbegin(); rit != _contexts.rend(); ++rit)
+	{
+		Context::const_iterator it = rit->find(prefix);
+		if (it != rit->end()) 
+			return it->second;
+	}
+	return EMPTY_STRING;
+}
+
+
+void NamespaceSupport::pushContext()
+{
+	_contexts.emplace_back();
+}
+
+
+void NamespaceSupport::popContext()
+{
+	_contexts.pop_back();
+}
+
+
+bool NamespaceSupport::processName(const XMLString& qname, XMLString& namespaceURI, XMLString& localName, bool isAttribute) const
+{
+	XMLString prefix;
+	Name::split(qname, prefix, localName);
+	if (prefix.empty() && isAttribute)
+	{
+		namespaceURI.clear();
+		return true;
+	}
+	else
+	{
+		namespaceURI = getURI(prefix);
+		return !namespaceURI.empty() || prefix.empty();
+	}
+}
+
+
+void NamespaceSupport::reset()
+{
+	_contexts.clear();
+	pushContext();
+	declarePrefix(XML_NAMESPACE_PREFIX, XML_NAMESPACE);
+	declarePrefix(XMLNS_NAMESPACE_PREFIX, XMLNS_NAMESPACE);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/Node.cpp b/base/poco/XML/src/Node.cpp
new file mode 100644
index 00000000000..4134fcfa29f
--- /dev/null
+++ b/base/poco/XML/src/Node.cpp
@@ -0,0 +1,27 @@
+//
+// Node.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/Node.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+Node::~Node()
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/NodeAppender.cpp b/base/poco/XML/src/NodeAppender.cpp
new file mode 100644
index 00000000000..e0582b89cfc
--- /dev/null
+++ b/base/poco/XML/src/NodeAppender.cpp
@@ -0,0 +1,82 @@
+//
+// NodeAppender.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  NodeAppender
+//
+// Copyright (c) 2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/NodeAppender.h"
+#include "Poco/DOM/Element.h"
+#include "Poco/DOM/DOMException.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+NodeAppender::NodeAppender(Element* parent):
+	_pParent(parent),
+	_pLast(0)
+{
+	poco_check_ptr (parent);
+
+	_pLast = static_cast<AbstractNode*>(_pParent->lastChild());
+}
+
+
+NodeAppender::~NodeAppender()
+{
+}
+
+
+void NodeAppender::appendChild(Node* newChild)
+{
+	poco_check_ptr (newChild);
+	poco_assert (_pLast == 0 || _pLast->_pNext == 0);
+
+	if (static_cast<AbstractNode*>(newChild)->_pOwner != _pParent->_pOwner)
+		throw DOMException(DOMException::WRONG_DOCUMENT_ERR);
+		
+	if (newChild->nodeType() == Node::DOCUMENT_FRAGMENT_NODE)
+	{
+		AbstractContainerNode* pFrag = static_cast<AbstractContainerNode*>(newChild);
+		AbstractNode* pChild = pFrag->_pFirstChild;
+		if (pChild)
+		{
+			if (_pLast)
+				_pLast->_pNext = pChild;
+			else
+				_pParent->_pFirstChild = pChild;
+			while (pChild)
+			{
+				_pLast = pChild;
+				pChild->_pParent = _pParent;
+				pChild = pChild->_pNext;
+			}
+			pFrag->_pFirstChild = 0;
+		}
+	}
+	else
+	{
+		AbstractNode* pAN = static_cast<AbstractNode*>(newChild);
+		pAN->duplicate();
+		if (pAN->_pParent) 
+			pAN->_pParent->removeChild(pAN);
+		pAN->_pParent = _pParent;
+		if (_pLast)
+			_pLast->_pNext = pAN;
+		else
+			_pParent->_pFirstChild = pAN;
+		_pLast = pAN;
+	}
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/NodeFilter.cpp b/base/poco/XML/src/NodeFilter.cpp
new file mode 100644
index 00000000000..7239f43407b
--- /dev/null
+++ b/base/poco/XML/src/NodeFilter.cpp
@@ -0,0 +1,27 @@
+//
+// NodeFilter.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  NodeFilter
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/NodeFilter.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+NodeFilter::~NodeFilter()
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/NodeIterator.cpp b/base/poco/XML/src/NodeIterator.cpp
new file mode 100644
index 00000000000..69685f9f4eb
--- /dev/null
+++ b/base/poco/XML/src/NodeIterator.cpp
@@ -0,0 +1,176 @@
+//
+// NodeIterator.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  NodeIterator
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/NodeIterator.h"
+#include "Poco/DOM/AbstractNode.h"
+#include "Poco/DOM/NodeFilter.h"
+#include "Poco/DOM/DOMException.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+NodeIterator::NodeIterator(Node* root, unsigned long whatToShow, NodeFilter* pFilter):
+	_pRoot(root),
+	_whatToShow(whatToShow),
+	_pFilter(pFilter),
+	_pCurrent(0)
+{
+}
+
+	
+NodeIterator::NodeIterator(const NodeIterator& iterator):
+	_pRoot(iterator._pRoot),
+	_whatToShow(iterator._whatToShow),
+	_pFilter(iterator._pFilter),
+	_pCurrent(iterator._pCurrent)
+{
+}
+
+	
+NodeIterator& NodeIterator::operator = (const NodeIterator& iterator)
+{
+	if (&iterator != this)
+	{
+		_pRoot      = iterator._pRoot;
+		_whatToShow = iterator._whatToShow;
+		_pFilter    = iterator._pFilter;
+		_pCurrent   = iterator._pCurrent;
+	}
+	return *this;
+}
+
+	
+NodeIterator::~NodeIterator()
+{
+}
+
+
+Node* NodeIterator::nextNode()
+{
+	if (!_pRoot) throw DOMException(DOMException::INVALID_STATE_ERR);
+	
+	if (_pCurrent)
+		_pCurrent = next();
+	else
+		_pCurrent = _pRoot;
+	while (_pCurrent && !accept(_pCurrent))
+		_pCurrent = next();
+	return _pCurrent;
+}
+
+
+Node* NodeIterator::previousNode()
+{
+	if (!_pRoot) throw DOMException(DOMException::INVALID_STATE_ERR);
+
+	if (_pCurrent)
+		_pCurrent = previous();
+	else
+		_pCurrent = last();
+	while (_pCurrent && !accept(_pCurrent))
+		_pCurrent = previous();
+	return _pCurrent;
+}
+
+
+void NodeIterator::detach()
+{
+	_pRoot    = 0;
+	_pCurrent = 0;
+}
+
+
+bool NodeIterator::accept(Node* pNode) const
+{
+	bool accept = false;
+	switch (pNode->nodeType())
+	{
+	case Node::ELEMENT_NODE: 
+		accept = (_whatToShow & NodeFilter::SHOW_ELEMENT) != 0; break;
+	case Node::ATTRIBUTE_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_ATTRIBUTE) != 0; break; 
+	case Node::TEXT_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_TEXT) != 0; break; 
+	case Node::CDATA_SECTION_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_CDATA_SECTION) != 0; break; 
+	case Node::ENTITY_REFERENCE_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_ENTITY_REFERENCE) != 0; break; 
+	case Node::ENTITY_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_ENTITY) != 0; break; 
+	case Node::PROCESSING_INSTRUCTION_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_PROCESSING_INSTRUCTION) != 0; break; 
+	case Node::COMMENT_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_COMMENT) != 0; break; 
+	case Node::DOCUMENT_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_DOCUMENT) != 0; break; 
+	case Node::DOCUMENT_TYPE_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_DOCUMENT_TYPE) != 0; break; 
+	case Node::DOCUMENT_FRAGMENT_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_DOCUMENT_FRAGMENT) != 0; break; 
+	case Node::NOTATION_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_NOTATION) != 0; break; 
+	}
+	if (accept && _pFilter)
+		accept = _pFilter->acceptNode(pNode) == NodeFilter::FILTER_ACCEPT;
+	return accept;
+}
+
+
+Node* NodeIterator::next() const
+{
+	Node* pNext = _pCurrent->firstChild();
+	if (pNext) return pNext;
+	pNext = _pCurrent;
+	while (pNext && pNext != _pRoot)
+	{
+		Node* pSibling = pNext->nextSibling();
+		if (pSibling) return pSibling;
+		pNext = pNext->parentNode();
+	}
+	return 0;
+}
+
+
+Node* NodeIterator::previous() const
+{
+	if (_pCurrent == _pRoot) return 0;
+	Node* pPrev = _pCurrent->previousSibling();
+	while (pPrev)
+	{
+		Node* pLastChild = pPrev->lastChild();
+		if (pLastChild)
+			pPrev = pLastChild;
+		else
+			return pPrev;
+	}
+	return _pCurrent->parentNode();
+}
+
+
+Node* NodeIterator::last()
+{
+	_pCurrent = _pRoot;
+	Node* pLast = 0;
+	while (_pCurrent)
+	{
+		pLast = _pCurrent;
+		_pCurrent = next();
+	}
+	return pLast;
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/NodeList.cpp b/base/poco/XML/src/NodeList.cpp
new file mode 100644
index 00000000000..e56b37ce197
--- /dev/null
+++ b/base/poco/XML/src/NodeList.cpp
@@ -0,0 +1,27 @@
+//
+// NodeList.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/NodeList.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+NodeList::~NodeList()
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/Notation.cpp b/base/poco/XML/src/Notation.cpp
new file mode 100644
index 00000000000..fdc0cf020b3
--- /dev/null
+++ b/base/poco/XML/src/Notation.cpp
@@ -0,0 +1,63 @@
+//
+// Notation.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/Notation.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+Notation::Notation(Document* pOwnerDocument, const XMLString& name, const XMLString& publicId, const XMLString& systemId): 
+	AbstractNode(pOwnerDocument),
+	_name(name),
+	_publicId(publicId),
+	_systemId(systemId)
+{
+}
+
+
+Notation::Notation(Document* pOwnerDocument, const Notation& notation): 
+	AbstractNode(pOwnerDocument, notation),
+	_name(notation._name),
+	_publicId(notation._publicId),
+	_systemId(notation._systemId)
+{
+}
+
+
+Notation::~Notation()
+{
+}
+
+
+const XMLString& Notation::nodeName() const
+{
+	return _name;
+}
+
+
+unsigned short Notation::nodeType() const
+{
+	return Node::NOTATION_NODE;
+}
+
+
+Node* Notation::copyNode(bool deep, Document* pOwnerDocument) const
+{
+	return new Notation(pOwnerDocument, *this);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/ParserEngine.cpp b/base/poco/XML/src/ParserEngine.cpp
new file mode 100644
index 00000000000..60cd120d365
--- /dev/null
+++ b/base/poco/XML/src/ParserEngine.cpp
@@ -0,0 +1,943 @@
+//
+// ParserEngine.cpp
+//
+// Library: XML
+// Package: XML
+// Module:  ParserEngine
+//
+// Copyright (c) 2004-2007, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/XML/ParserEngine.h"
+#include "Poco/XML/NamespaceStrategy.h"
+#include "Poco/XML/XMLException.h"
+#include "Poco/SAX/EntityResolver.h"
+#include "Poco/SAX/EntityResolverImpl.h"
+#include "Poco/SAX/DTDHandler.h"
+#include "Poco/SAX/DeclHandler.h"
+#include "Poco/SAX/ContentHandler.h"
+#include "Poco/SAX/LexicalHandler.h"
+#include "Poco/SAX/ErrorHandler.h"
+#include "Poco/SAX/InputSource.h"
+#include "Poco/SAX/Locator.h"
+#include "Poco/SAX/LocatorImpl.h"
+#include "Poco/SAX/SAXException.h"
+#include "Poco/URI.h"
+#include <cstring>
+
+
+using Poco::URI;
+using Poco::TextEncoding;
+
+
+namespace Poco {
+namespace XML {
+
+
+class ContextLocator: public Locator
+{
+public:
+	ContextLocator(XML_Parser parser, const XMLString& publicId, const XMLString& systemId):
+		_parser(parser),
+		_publicId(publicId),
+		_systemId(systemId)
+	{
+	}
+
+	~ContextLocator()
+	{
+	}
+
+	XMLString getPublicId() const
+	{
+		return _publicId;
+	}
+
+	XMLString getSystemId() const
+	{
+		return _systemId;
+	}
+
+	int getLineNumber() const
+	{
+		return XML_GetCurrentLineNumber(_parser);
+	}
+
+	int getColumnNumber() const
+	{
+		return XML_GetCurrentColumnNumber(_parser);
+	}
+
+private:
+	XML_Parser _parser;
+	XMLString  _publicId;
+	XMLString  _systemId;
+};
+
+
+const int ParserEngine::PARSE_BUFFER_SIZE = 4096;
+const XMLString ParserEngine::EMPTY_STRING;
+
+
+ParserEngine::ParserEngine():
+	_parser(0),
+	_pBuffer(0),
+	_encodingSpecified(false),
+	_expandInternalEntities(true),
+	_externalGeneralEntities(false),
+	_externalParameterEntities(false),
+	_enablePartialReads(false),
+	_pNamespaceStrategy(new NoNamespacesStrategy()),
+	_pEntityResolver(0),
+	_pDTDHandler(0),
+	_pDeclHandler(0),
+	_pContentHandler(0),
+	_pLexicalHandler(0),
+	_pErrorHandler(0),
+	_maximumAmplificationFactor(0.0),
+	_activationThresholdBytes(0)
+{
+}
+
+
+ParserEngine::ParserEngine(const XMLString& encoding):
+	_parser(0),
+	_pBuffer(0),
+	_encodingSpecified(true),
+	_encoding(encoding),
+	_expandInternalEntities(true),
+	_externalGeneralEntities(false),
+	_externalParameterEntities(false),
+	_enablePartialReads(false),
+	_pNamespaceStrategy(new NoNamespacesStrategy()),
+	_pEntityResolver(0),
+	_pDTDHandler(0),
+	_pDeclHandler(0),
+	_pContentHandler(0),
+	_pLexicalHandler(0),
+	_pErrorHandler(0),
+	_maximumAmplificationFactor(0.0),
+	_activationThresholdBytes(0)
+{
+}
+
+
+ParserEngine::~ParserEngine()
+{
+	resetContext();
+	if (_parser) XML_ParserFree(_parser);
+	delete [] _pBuffer;
+	delete _pNamespaceStrategy;
+}
+
+
+void ParserEngine::setEncoding(const XMLString& encoding)
+{
+	_encoding          = encoding;
+	_encodingSpecified = true;
+}
+
+
+void ParserEngine::addEncoding(const XMLString& name, TextEncoding* pEncoding)
+{
+	poco_check_ptr (pEncoding);
+
+	if (_encodings.find(name) == _encodings.end())
+		_encodings[name] = pEncoding;
+	else
+		throw XMLException("Encoding already defined");
+}
+
+
+void ParserEngine::setNamespaceStrategy(NamespaceStrategy* pStrategy)
+{
+	poco_check_ptr (pStrategy);
+
+	delete _pNamespaceStrategy;
+	_pNamespaceStrategy = pStrategy;
+}
+
+
+void ParserEngine::setExpandInternalEntities(bool flag)
+{
+	_expandInternalEntities = flag;
+}
+
+
+void ParserEngine::setExternalGeneralEntities(bool flag)
+{
+	_externalGeneralEntities = flag;
+}
+
+
+void ParserEngine::setExternalParameterEntities(bool flag)
+{
+	_externalParameterEntities = flag;
+}
+
+
+void ParserEngine::setEntityResolver(EntityResolver* pResolver)
+{
+	_pEntityResolver = pResolver;
+}
+
+
+void ParserEngine::setDTDHandler(DTDHandler* pDTDHandler)
+{
+	_pDTDHandler = pDTDHandler;
+}
+
+
+void ParserEngine::setDeclHandler(DeclHandler* pDeclHandler)
+{
+	_pDeclHandler = pDeclHandler;
+}
+
+
+void ParserEngine::setContentHandler(ContentHandler* pContentHandler)
+{
+	_pContentHandler = pContentHandler;
+}
+
+
+void ParserEngine::setLexicalHandler(LexicalHandler* pLexicalHandler)
+{
+	_pLexicalHandler = pLexicalHandler;
+}
+
+
+void ParserEngine::setErrorHandler(ErrorHandler* pErrorHandler)
+{
+	_pErrorHandler = pErrorHandler;
+}
+
+
+void ParserEngine::setEnablePartialReads(bool flag)
+{
+	_enablePartialReads = flag;
+}
+
+
+void ParserEngine::setBillionLaughsAttackProtectionMaximumAmplification(float maximumAmplificationFactor)
+{
+	_maximumAmplificationFactor = maximumAmplificationFactor;
+}
+
+
+void ParserEngine::setBillionLaughsAttackProtectionActivationThreshold(Poco::UInt64 activationThresholdBytes)
+{
+	_activationThresholdBytes = activationThresholdBytes;
+}
+
+
+void ParserEngine::parse(InputSource* pInputSource)
+{
+	init();
+	resetContext();
+	pushContext(_parser, pInputSource);
+	if (_pContentHandler) _pContentHandler->setDocumentLocator(this);
+	if (_pContentHandler) _pContentHandler->startDocument();
+	if (pInputSource->getCharacterStream())
+		parseCharInputStream(*pInputSource->getCharacterStream());
+	else if (pInputSource->getByteStream())
+		parseByteInputStream(*pInputSource->getByteStream());
+	else throw XMLException("Input source has no stream");
+	if (_pContentHandler) _pContentHandler->endDocument();
+	popContext();
+}
+
+
+void ParserEngine::parse(const char* pBuffer, std::size_t size)
+{
+	init();
+	resetContext();
+	InputSource src;
+	pushContext(_parser, &src);
+	if (_pContentHandler) _pContentHandler->setDocumentLocator(this);
+	if (_pContentHandler) _pContentHandler->startDocument();
+	std::size_t processed = 0;
+	while (processed < size)
+	{
+		const int bufferSize = processed + PARSE_BUFFER_SIZE < size ? PARSE_BUFFER_SIZE : static_cast<int>(size - processed);
+		if (!XML_Parse(_parser, pBuffer + processed, bufferSize, 0))
+			handleError(XML_GetErrorCode(_parser));
+		processed += bufferSize;
+	}
+	if (!XML_Parse(_parser, pBuffer+processed, 0, 1))
+		handleError(XML_GetErrorCode(_parser));
+	if (_pContentHandler) _pContentHandler->endDocument();
+	popContext();
+}
+
+
+void ParserEngine::parseByteInputStream(XMLByteInputStream& istr)
+{
+	std::streamsize n = readBytes(istr, _pBuffer, PARSE_BUFFER_SIZE);
+	while (n > 0)
+	{
+		if (!XML_Parse(_parser, _pBuffer, static_cast<int>(n), 0))
+			handleError(XML_GetErrorCode(_parser));
+		if (istr.good())
+			n = readBytes(istr, _pBuffer, PARSE_BUFFER_SIZE);
+		else
+			n = 0;
+	}
+	if (!XML_Parse(_parser, _pBuffer, 0, 1))
+		handleError(XML_GetErrorCode(_parser));
+}
+
+
+void ParserEngine::parseCharInputStream(XMLCharInputStream& istr)
+{
+	std::streamsize n = readChars(istr, reinterpret_cast<XMLChar*>(_pBuffer), PARSE_BUFFER_SIZE/sizeof(XMLChar));
+	while (n > 0)
+	{
+		if (!XML_Parse(_parser, _pBuffer, static_cast<int>(n*sizeof(XMLChar)), 0))
+			handleError(XML_GetErrorCode(_parser));
+		if (istr.good())
+			n = readChars(istr, reinterpret_cast<XMLChar*>(_pBuffer), PARSE_BUFFER_SIZE/sizeof(XMLChar));
+		else
+			n = 0;
+	}
+	if (!XML_Parse(_parser, _pBuffer, 0, 1))
+		handleError(XML_GetErrorCode(_parser));
+}
+
+
+void ParserEngine::parseExternal(XML_Parser extParser, InputSource* pInputSource)
+{
+	pushContext(extParser, pInputSource);
+	if (pInputSource->getCharacterStream())
+		parseExternalCharInputStream(extParser, *pInputSource->getCharacterStream());
+	else if (pInputSource->getByteStream())
+		parseExternalByteInputStream(extParser, *pInputSource->getByteStream());
+	else throw XMLException("Input source has no stream");
+	popContext();
+}
+
+
+void ParserEngine::parseExternalByteInputStream(XML_Parser extParser, XMLByteInputStream& istr)
+{
+	char *pBuffer = new char[PARSE_BUFFER_SIZE];
+	try
+	{
+		std::streamsize n = readBytes(istr, pBuffer, PARSE_BUFFER_SIZE);
+		while (n > 0)
+		{
+			if (!XML_Parse(extParser, pBuffer, static_cast<int>(n), 0))
+				handleError(XML_GetErrorCode(extParser));
+			if (istr.good())
+				n = readBytes(istr, pBuffer, PARSE_BUFFER_SIZE);
+			else
+				n = 0;
+		}
+		if (!XML_Parse(extParser, pBuffer, 0, 1))
+			handleError(XML_GetErrorCode(extParser));
+	}
+	catch (...)
+	{
+		delete [] pBuffer;
+		throw;
+	}
+	delete [] pBuffer;
+}
+
+
+void ParserEngine::parseExternalCharInputStream(XML_Parser extParser, XMLCharInputStream& istr)
+{
+	XMLChar *pBuffer = new XMLChar[PARSE_BUFFER_SIZE/sizeof(XMLChar)];
+	try
+	{
+		std::streamsize n = readChars(istr, pBuffer, PARSE_BUFFER_SIZE/sizeof(XMLChar));
+		while (n > 0)
+		{
+			if (!XML_Parse(extParser, reinterpret_cast<char*>(pBuffer), static_cast<int>(n*sizeof(XMLChar)), 0))
+				handleError(XML_GetErrorCode(extParser));
+			if (istr.good())
+				n = readChars(istr, pBuffer, static_cast<int>(PARSE_BUFFER_SIZE/sizeof(XMLChar)));
+			else
+				n = 0;
+		}
+		if (!XML_Parse(extParser, reinterpret_cast<char*>(pBuffer), 0, 1))
+			handleError(XML_GetErrorCode(extParser));
+	}
+	catch (...)
+	{
+		delete [] pBuffer;
+		throw;
+	}
+	delete [] pBuffer;
+}
+
+
+std::streamsize ParserEngine::readBytes(XMLByteInputStream& istr, char* pBuffer, std::streamsize bufferSize)
+{
+	if (_enablePartialReads)
+	{
+		istr.read(pBuffer, 1);
+		if (istr.gcount() == 1)
+		{
+			std::streamsize n = istr.readsome(pBuffer + 1, bufferSize - 1);
+			return n + 1;
+		}
+		else return 0;
+	}
+	else
+	{
+		istr.read(pBuffer, bufferSize);
+		return istr.gcount();
+	}
+}
+
+
+std::streamsize ParserEngine::readChars(XMLCharInputStream& istr, XMLChar* pBuffer, std::streamsize bufferSize)
+{
+	if (_enablePartialReads)
+	{
+		istr.read(pBuffer, 1);
+		if (istr.gcount() == 1)
+		{
+			std::streamsize n = istr.readsome(pBuffer + 1, bufferSize - 1);
+			return n + 1;
+		}
+		else return 0;
+	}
+	else
+	{
+		istr.read(pBuffer, bufferSize);
+		return istr.gcount();
+	}
+}
+
+
+XMLString ParserEngine::getPublicId() const
+{
+	return locator().getPublicId();
+}
+
+
+XMLString ParserEngine::getSystemId() const
+{
+	return locator().getSystemId();
+}
+
+
+int ParserEngine::getLineNumber() const
+{
+	return locator().getLineNumber();
+}
+
+
+int ParserEngine::getColumnNumber() const
+{
+	return locator().getColumnNumber();
+}
+
+
+namespace
+{
+	static LocatorImpl nullLocator;
+}
+
+
+const Locator& ParserEngine::locator() const
+{
+	if (_context.empty())
+		return nullLocator;
+	else
+		return *_context.back();
+}
+
+
+void ParserEngine::init()
+{
+	if (_parser)
+		XML_ParserFree(_parser);
+
+	if (!_pBuffer)
+		_pBuffer  = new char[PARSE_BUFFER_SIZE];
+
+	if (dynamic_cast<NoNamespacePrefixesStrategy*>(_pNamespaceStrategy))
+	{
+		_parser = XML_ParserCreateNS(_encodingSpecified ? _encoding.c_str() : 0, '\t');
+		if (_parser)
+		{
+			XML_SetNamespaceDeclHandler(_parser, handleStartNamespaceDecl, handleEndNamespaceDecl);
+		}
+	}
+	else if (dynamic_cast<NamespacePrefixesStrategy*>(_pNamespaceStrategy))
+	{
+		_parser = XML_ParserCreateNS(_encodingSpecified ? _encoding.c_str() : 0, '\t');
+		if (_parser)
+		{
+			XML_SetReturnNSTriplet(_parser, 1);
+			XML_SetNamespaceDeclHandler(_parser, handleStartNamespaceDecl, handleEndNamespaceDecl);
+		}
+	}
+	else
+	{
+		_parser = XML_ParserCreate(_encodingSpecified ? _encoding.c_str() : 0);
+	}
+
+	if (!_parser) throw XMLException("Cannot create Expat parser");
+
+	XML_SetUserData(_parser, this);
+	XML_SetElementHandler(_parser, handleStartElement, handleEndElement);
+	XML_SetCharacterDataHandler(_parser, handleCharacterData);
+	XML_SetProcessingInstructionHandler(_parser, handleProcessingInstruction);
+	if (_expandInternalEntities)
+		XML_SetDefaultHandlerExpand(_parser, handleDefault);
+	else
+		XML_SetDefaultHandler(_parser, handleDefault);
+	XML_SetUnparsedEntityDeclHandler(_parser, handleUnparsedEntityDecl);
+	XML_SetNotationDeclHandler(_parser, handleNotationDecl);
+	XML_SetExternalEntityRefHandler(_parser, handleExternalEntityRef);
+	XML_SetCommentHandler(_parser, handleComment);
+	XML_SetCdataSectionHandler(_parser, handleStartCdataSection, handleEndCdataSection);
+	XML_SetDoctypeDeclHandler(_parser, handleStartDoctypeDecl, handleEndDoctypeDecl);
+	XML_SetEntityDeclHandler(_parser, handleEntityDecl);
+	XML_SetSkippedEntityHandler(_parser, handleSkippedEntity);
+	XML_SetParamEntityParsing(_parser, _externalParameterEntities ? XML_PARAM_ENTITY_PARSING_ALWAYS : XML_PARAM_ENTITY_PARSING_NEVER);
+	XML_SetUnknownEncodingHandler(_parser, handleUnknownEncoding, this);
+
+#if defined(XML_DTD) && (XML_MAJOR_VERSION > 2 || (XML_MAJOR_VERSION == 2 && XML_MINOR_VERSION >= 4))
+	if (_maximumAmplificationFactor > 1.0)
+	{
+		XML_SetBillionLaughsAttackProtectionMaximumAmplification(_parser, _maximumAmplificationFactor);
+	}
+	if (_activationThresholdBytes > 0)
+	{
+		XML_SetBillionLaughsAttackProtectionActivationThreshold(_parser, _activationThresholdBytes);
+	}
+#endif
+}
+
+
+void ParserEngine::handleError(int errorNo)
+{
+	try
+	{
+		switch (errorNo)
+		{
+		case XML_ERROR_NO_MEMORY:
+			throw XMLException("No memory");
+		case XML_ERROR_SYNTAX:
+			throw SAXParseException("Syntax error", locator());
+		case XML_ERROR_NO_ELEMENTS:
+			throw SAXParseException("No element found", locator());
+		case XML_ERROR_INVALID_TOKEN:
+			throw SAXParseException("Invalid token", locator());
+		case XML_ERROR_UNCLOSED_TOKEN:
+			throw SAXParseException("Unclosed token", locator());
+		case XML_ERROR_PARTIAL_CHAR:
+			throw SAXParseException("Partial character", locator());
+		case XML_ERROR_TAG_MISMATCH:
+			throw SAXParseException("Tag mismatch", locator());
+		case XML_ERROR_DUPLICATE_ATTRIBUTE:
+			throw SAXParseException("Duplicate attribute", locator());
+		case XML_ERROR_JUNK_AFTER_DOC_ELEMENT:
+			throw SAXParseException("Junk after document element", locator());
+		case XML_ERROR_PARAM_ENTITY_REF:
+			throw SAXParseException("Illegal parameter entity reference", locator());
+		case XML_ERROR_UNDEFINED_ENTITY:
+			throw SAXParseException("Undefined entity", locator());
+		case XML_ERROR_RECURSIVE_ENTITY_REF:
+			throw SAXParseException("Recursive entity reference", locator());
+		case XML_ERROR_ASYNC_ENTITY:
+			throw SAXParseException("Asynchronous entity", locator());
+		case XML_ERROR_BAD_CHAR_REF:
+			throw SAXParseException("Reference to invalid character number", locator());
+		case XML_ERROR_BINARY_ENTITY_REF:
+			throw SAXParseException("Reference to binary entity", locator());
+		case XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF:
+			throw SAXParseException("Reference to external entity in attribute", locator());
+		case XML_ERROR_MISPLACED_XML_PI:
+			throw SAXParseException("XML processing instruction not at start of external entity", locator());
+		case XML_ERROR_UNKNOWN_ENCODING:
+			throw SAXParseException("Unknown encoding", locator());
+		case XML_ERROR_INCORRECT_ENCODING:
+			throw SAXParseException("Encoding specified in XML declaration is incorrect", locator());
+		case XML_ERROR_UNCLOSED_CDATA_SECTION:
+			throw SAXParseException("Unclosed CDATA section", locator());
+		case XML_ERROR_EXTERNAL_ENTITY_HANDLING:
+			throw SAXParseException("Error in processing external entity reference", locator());
+		case XML_ERROR_NOT_STANDALONE:
+			throw SAXParseException("Document is not standalone", locator());
+		case XML_ERROR_UNEXPECTED_STATE:
+			throw SAXParseException("Unexpected parser state - please send a bug report", locator());
+		case XML_ERROR_ENTITY_DECLARED_IN_PE:
+			throw SAXParseException("Entity declared in parameter entity", locator());
+		case XML_ERROR_FEATURE_REQUIRES_XML_DTD:
+			throw SAXParseException("Requested feature requires XML_DTD support in Expat", locator());
+		case XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING:
+			throw SAXParseException("Cannot change setting once parsing has begun", locator());
+		case XML_ERROR_UNBOUND_PREFIX:
+			throw SAXParseException("Unbound prefix", locator());
+		case XML_ERROR_UNDECLARING_PREFIX:
+			throw SAXParseException("Must not undeclare prefix", locator());
+		case XML_ERROR_INCOMPLETE_PE:
+			throw SAXParseException("Incomplete markup in parameter entity", locator());
+		case XML_ERROR_XML_DECL:
+			throw SAXParseException("XML declaration not well-formed", locator());
+		case XML_ERROR_TEXT_DECL:
+			throw SAXParseException("Text declaration not well-formed", locator());
+		case XML_ERROR_PUBLICID:
+			throw SAXParseException("Illegal character(s) in public identifier", locator());
+		case XML_ERROR_SUSPENDED:
+			throw SAXParseException("Parser suspended", locator());
+		case XML_ERROR_NOT_SUSPENDED:
+			throw SAXParseException("Parser not suspended", locator());
+		case XML_ERROR_ABORTED:
+			throw SAXParseException("Parsing aborted", locator());
+		case XML_ERROR_FINISHED:
+			throw SAXParseException("Parsing finished", locator());
+		case XML_ERROR_SUSPEND_PE:
+			throw SAXParseException("Cannot suspend in external parameter entity", locator());
+#if XML_MAJOR_VERSION >= 2
+		case XML_ERROR_RESERVED_PREFIX_XML:
+			throw SAXParseException("Reserved prefix 'xml' must not be undeclared or bound to another namespace name", locator());
+		case XML_ERROR_RESERVED_PREFIX_XMLNS:
+			throw SAXParseException("Reserved prefix 'xmlns' must not be declared or undeclared", locator());
+		case XML_ERROR_RESERVED_NAMESPACE_URI:
+			throw SAXParseException("Prefix must not be bound to one of the reserved namespace names", locator());
+	#if XML_MAJOR_VERSION > 2 || (XML_MINOR_VERSION >= 2 && XML_MICRO_VERSION >= 1)
+		case XML_ERROR_INVALID_ARGUMENT:
+			throw SAXParseException("Invalid argument", locator());
+	#endif
+	#if XML_MAJOR_VERSION > 2 || XML_MINOR_VERSION >= 3
+		case XML_ERROR_NO_BUFFER:
+			throw SAXParseException("Internal error: a successful prior call to function XML_GetBuffer is required", locator());
+	#endif
+	#if XML_MAJOR_VERSION > 2 || XML_MINOR_VERSION >= 4
+		case XML_ERROR_AMPLIFICATION_LIMIT_BREACH:
+			throw SAXParseException("Limit on input amplification factor (from DTD and entities) breached", locator());
+	#endif
+#endif // XML_MAJOR_VERSION
+		}
+		throw XMLException("Unknown Expat error code");
+	}
+	catch (SAXException& exc)
+	{
+		if (_pErrorHandler) _pErrorHandler->error(exc);
+		throw;
+	}
+	catch (Poco::Exception& exc)
+	{
+		if (_pErrorHandler) _pErrorHandler->fatalError(SAXParseException("Fatal error", locator(), exc));
+		throw;
+	}
+}
+
+
+void ParserEngine::pushContext(XML_Parser parser, InputSource* pInputSource)
+{
+	ContextLocator* pLocator = new ContextLocator(parser, pInputSource->getPublicId(), pInputSource->getSystemId());
+	_context.push_back(pLocator);
+}
+
+
+void ParserEngine::popContext()
+{
+	poco_assert (!_context.empty());
+	delete _context.back();
+	_context.pop_back();
+}
+
+
+void ParserEngine::resetContext()
+{
+	for (auto p: _context)
+	{
+		delete p;
+	}
+	_context.clear();
+}
+
+
+void ParserEngine::handleStartElement(void* userData, const XML_Char* name, const XML_Char** atts)
+{
+	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(userData);
+
+	if (pThis->_pContentHandler)
+	{
+		try
+		{
+			pThis->_pNamespaceStrategy->startElement(name, atts, XML_GetSpecifiedAttributeCount(pThis->_parser)/2, pThis->_pContentHandler);
+		}
+		catch (XMLException& exc)
+		{
+			throw SAXParseException(exc.message(), pThis->locator());
+		}
+	}
+}
+
+
+void ParserEngine::handleEndElement(void* userData, const XML_Char* name)
+{
+	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(userData);
+
+	if (pThis->_pContentHandler)
+	{
+		try
+		{
+			pThis->_pNamespaceStrategy->endElement(name, pThis->_pContentHandler);
+		}
+		catch (XMLException& exc)
+		{
+			throw SAXParseException(exc.message(), pThis->locator());
+		}
+	}
+}
+
+
+void ParserEngine::handleCharacterData(void* userData, const XML_Char* s, int len)
+{
+	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(userData);
+
+	if (pThis->_pContentHandler)
+		pThis->_pContentHandler->characters(s, 0, len);
+}
+
+
+void ParserEngine::handleProcessingInstruction(void* userData, const XML_Char* target, const XML_Char* data)
+{
+	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(userData);
+
+	if (pThis->_pContentHandler)
+		pThis->_pContentHandler->processingInstruction(target, data);
+}
+
+
+void ParserEngine::handleDefault(void* userData, const XML_Char* s, int len)
+{
+}
+
+
+void ParserEngine::handleUnparsedEntityDecl(void* userData, const XML_Char* entityName, const XML_Char* base, const XML_Char* systemId, const XML_Char* publicId, const XML_Char* notationName)
+{
+	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(userData);
+
+	XMLString pubId;
+	if (publicId) pubId.assign(publicId);
+	if (pThis->_pDTDHandler)
+		pThis->_pDTDHandler->unparsedEntityDecl(entityName, publicId ? &pubId : 0, systemId, notationName);
+}
+
+
+void ParserEngine::handleNotationDecl(void* userData, const XML_Char* notationName, const XML_Char* base, const XML_Char* systemId, const XML_Char* publicId)
+{
+	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(userData);
+
+	XMLString pubId;
+	if (publicId) pubId.assign(publicId);
+	XMLString sysId;
+	if (systemId) sysId.assign(systemId);
+	if (pThis->_pDTDHandler)
+		pThis->_pDTDHandler->notationDecl(notationName, publicId ? &pubId : 0, systemId ? &sysId : 0);
+}
+
+
+int ParserEngine::handleExternalEntityRef(XML_Parser parser, const XML_Char* context, const XML_Char* base, const XML_Char* systemId, const XML_Char* publicId)
+{
+	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(XML_GetUserData(parser));
+
+	if (!context && !pThis->_externalParameterEntities) return XML_STATUS_ERROR;
+	if (context && !pThis->_externalGeneralEntities) return XML_STATUS_ERROR;
+
+	InputSource* pInputSource = 0;
+	EntityResolver* pEntityResolver = 0;
+	EntityResolverImpl defaultResolver;
+
+	XMLString sysId(systemId);
+	XMLString pubId;
+	if (publicId) pubId.assign(publicId);
+
+	URI uri(fromXMLString(pThis->_context.back()->getSystemId()));
+	uri.resolve(fromXMLString(sysId));
+
+	if (pThis->_pEntityResolver)
+	{
+		pEntityResolver = pThis->_pEntityResolver;
+		pInputSource = pEntityResolver->resolveEntity(publicId ? &pubId : 0, toXMLString(uri.toString()));
+	}
+	if (!pInputSource && pThis->_externalGeneralEntities)
+	{
+		pEntityResolver = &defaultResolver;
+		pInputSource = pEntityResolver->resolveEntity(publicId ? &pubId : 0, toXMLString(uri.toString()));
+	}
+
+	if (pInputSource)
+	{
+		XML_Parser extParser = XML_ExternalEntityParserCreate(pThis->_parser, context, 0);
+		if (!extParser) throw XMLException("Cannot create external entity parser");
+
+		try
+		{
+			pThis->parseExternal(extParser, pInputSource);
+		}
+		catch (XMLException&)
+		{
+			pEntityResolver->releaseInputSource(pInputSource);
+			XML_ParserFree(extParser);
+			throw;
+		}
+		pEntityResolver->releaseInputSource(pInputSource);
+		XML_ParserFree(extParser);
+		return XML_STATUS_OK;
+	}
+	else return XML_STATUS_ERROR;
+}
+
+
+int ParserEngine::handleUnknownEncoding(void* encodingHandlerData, const XML_Char* name, XML_Encoding* info)
+{
+	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(encodingHandlerData);
+
+	XMLString encoding(name);
+	TextEncoding* knownEncoding = 0;
+
+	EncodingMap::const_iterator it = pThis->_encodings.find(encoding);
+	if (it != pThis->_encodings.end())
+		knownEncoding = it->second;
+	else
+		knownEncoding = Poco::TextEncoding::find(fromXMLString(encoding));
+
+	if (knownEncoding)
+	{
+		const TextEncoding::CharacterMap& map = knownEncoding->characterMap();
+		for (int i = 0; i < 256; ++i)
+			info->map[i] = map[i];
+
+		info->data    = knownEncoding;
+		info->convert = &ParserEngine::convert;
+		info->release = 0;
+		return XML_STATUS_OK;
+	}
+	else return XML_STATUS_ERROR;
+}
+
+
+void ParserEngine::handleComment(void* userData, const XML_Char* data)
+{
+	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(userData);
+
+#if defined(XML_UNICODE_WCHAR_T)
+	if (pThis->_pLexicalHandler)
+		pThis->_pLexicalHandler->comment(data, 0, (int) std::wcslen(data));
+#else
+	if (pThis->_pLexicalHandler)
+		pThis->_pLexicalHandler->comment(data, 0, (int) std::strlen(data));
+#endif
+}
+
+
+void ParserEngine::handleStartCdataSection(void* userData)
+{
+	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(userData);
+
+	if (pThis->_pLexicalHandler)
+		pThis->_pLexicalHandler->startCDATA();
+}
+
+
+void ParserEngine::handleEndCdataSection(void* userData)
+{
+	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(userData);
+
+	if (pThis->_pLexicalHandler)
+		pThis->_pLexicalHandler->endCDATA();
+}
+
+
+void ParserEngine::handleStartNamespaceDecl(void* userData, const XML_Char* prefix, const XML_Char* uri)
+{
+	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(userData);
+
+	if (pThis->_pContentHandler)
+		pThis->_pContentHandler->startPrefixMapping((prefix ? XMLString(prefix) : EMPTY_STRING), (uri ? XMLString(uri) : EMPTY_STRING));
+}
+
+
+void ParserEngine::handleEndNamespaceDecl(void* userData, const XML_Char* prefix)
+{
+	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(userData);
+
+	if (pThis->_pContentHandler)
+		pThis->_pContentHandler->endPrefixMapping(prefix ? XMLString(prefix) : EMPTY_STRING);
+}
+
+
+void ParserEngine::handleStartDoctypeDecl(void* userData, const XML_Char* doctypeName, const XML_Char *systemId, const XML_Char* publicId, int hasInternalSubset)
+{
+	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(userData);
+
+	if (pThis->_pLexicalHandler)
+	{
+		XMLString sysId = systemId ? XMLString(systemId) : EMPTY_STRING;
+		XMLString pubId = publicId ? XMLString(publicId) : EMPTY_STRING;
+		pThis->_pLexicalHandler->startDTD(doctypeName, pubId, sysId);
+	}
+}
+
+
+void ParserEngine::handleEndDoctypeDecl(void* userData)
+{
+	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(userData);
+
+	if (pThis->_pLexicalHandler)
+		pThis->_pLexicalHandler->endDTD();
+}
+
+
+void ParserEngine::handleEntityDecl(void *userData, const XML_Char *entityName, int isParamEntity, const XML_Char *value, int valueLength,
+	                                const XML_Char *base, const XML_Char *systemId, const XML_Char *publicId, const XML_Char *notationName)
+{
+	if (value)
+		handleInternalParsedEntityDecl(userData, entityName, value, valueLength);
+	else
+		handleExternalParsedEntityDecl(userData, entityName, base, systemId, publicId);
+}
+
+
+void ParserEngine::handleExternalParsedEntityDecl(void* userData, const XML_Char* entityName, const XML_Char* base, const XML_Char* systemId, const XML_Char* publicId)
+{
+	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(userData);
+
+	XMLString pubId;
+	if (publicId) pubId.assign(publicId);
+	if (pThis->_pDeclHandler)
+		pThis->_pDeclHandler->externalEntityDecl(entityName, publicId ? &pubId : 0, systemId);
+}
+
+
+void ParserEngine::handleInternalParsedEntityDecl(void* userData, const XML_Char* entityName, const XML_Char* replacementText, int replacementTextLength)
+{
+	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(userData);
+
+	XMLString replText(replacementText, replacementTextLength);
+	if (pThis->_pDeclHandler)
+		pThis->_pDeclHandler->internalEntityDecl(entityName, replText);
+}
+
+
+void ParserEngine::handleSkippedEntity(void* userData, const XML_Char* entityName, int isParameterEntity)
+{
+	ParserEngine* pThis = reinterpret_cast<ParserEngine*>(userData);
+
+	if (pThis->_pContentHandler)
+		pThis->_pContentHandler->skippedEntity(entityName);
+}
+
+
+int ParserEngine::convert(void* data, const char* s)
+{
+	TextEncoding* pEncoding = reinterpret_cast<TextEncoding*>(data);
+	return pEncoding->convert((const unsigned char*) s);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/ProcessingInstruction.cpp b/base/poco/XML/src/ProcessingInstruction.cpp
new file mode 100644
index 00000000000..ebfc7c158be
--- /dev/null
+++ b/base/poco/XML/src/ProcessingInstruction.cpp
@@ -0,0 +1,79 @@
+//
+// ProcessingInstruction.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/ProcessingInstruction.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+ProcessingInstruction::ProcessingInstruction(Document* pOwnerDocument, const XMLString& target, const XMLString& data): 
+	AbstractNode(pOwnerDocument),
+	_target(target),
+	_data(data)
+{
+}
+
+
+ProcessingInstruction::ProcessingInstruction(Document* pOwnerDocument, const ProcessingInstruction& processingInstruction): 
+	AbstractNode(pOwnerDocument, processingInstruction),
+	_target(processingInstruction._target),
+	_data(processingInstruction._data)
+{
+}
+
+
+ProcessingInstruction::~ProcessingInstruction()
+{
+}
+
+
+void ProcessingInstruction::setData(const XMLString& data)
+{
+	_data = data;
+}
+
+
+const XMLString& ProcessingInstruction::nodeName() const
+{
+	return _target;
+}
+
+
+const XMLString& ProcessingInstruction::getNodeValue() const
+{
+	return _data;
+}
+
+
+void ProcessingInstruction::setNodeValue(const XMLString& data)
+{
+	setData(data);
+}
+
+
+unsigned short ProcessingInstruction::nodeType() const
+{
+	return Node::PROCESSING_INSTRUCTION_NODE;
+}
+
+
+Node* ProcessingInstruction::copyNode(bool deep, Document* pOwnerDocument) const
+{
+	return new ProcessingInstruction(pOwnerDocument, *this);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/QName.cpp b/base/poco/XML/src/QName.cpp
new file mode 100644
index 00000000000..b9dad0f684f
--- /dev/null
+++ b/base/poco/XML/src/QName.cpp
@@ -0,0 +1,114 @@
+//
+// QName.cpp
+//
+// Library: XML
+// Package: XML
+// Module:  QName
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Based on libstudxml (http://www.codesynthesis.com/projects/libstudxml/).
+// Copyright (c) 2009-2013 Code Synthesis Tools CC.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/XML/QName.h"
+#include <ostream>
+
+
+namespace Poco {
+namespace XML {
+
+
+QName::QName()
+{
+}
+
+
+QName::QName(const std::string& name) :
+	_name(name)
+{
+}
+
+
+QName::QName(const std::string& ns, const std::string& name) :
+	_ns(ns),
+	_name(name)
+{
+}
+
+
+QName::QName(const std::string& ns, const std::string& name, const std::string& prefix) :
+	_ns(ns),
+	_name(name),
+	_prefix(prefix)
+{
+}
+
+
+QName::QName(const QName& qname):
+	_ns(qname._ns),
+	_name(qname._name),
+	_prefix(qname._prefix)
+{
+}
+
+
+QName::QName(QName&& qname) noexcept:
+	_ns(std::move(qname._ns)),
+	_name(std::move(qname._name)),
+	_prefix(std::move(qname._prefix))
+{
+}
+
+
+QName& QName::operator = (const QName& qname)
+{
+	QName tmp(qname);
+	swap(tmp);
+	return *this;
+}
+
+
+QName& QName::operator = (QName&& qname) noexcept
+{
+	_ns = std::move(qname._ns);
+	_name = std::move(qname._name);
+	_prefix = std::move(qname._prefix);
+	
+	return *this;
+}
+
+
+void QName::swap(QName& qname)
+{
+	std::swap(_ns, qname._ns);
+	std::swap(_name, qname._name);
+	std::swap(_prefix, qname._prefix);
+}
+
+
+std::string QName::toString() const
+{
+	std::string r;
+	if (!_ns.empty())
+	{
+		r += _ns;
+		r += '#';
+	}
+
+	r += _name;
+	return r;
+}
+
+
+std::ostream& operator << (std::ostream& os, const QName& qn)
+{
+	return os << qn.toString();
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/SAXException.cpp b/base/poco/XML/src/SAXException.cpp
new file mode 100644
index 00000000000..112747b08fc
--- /dev/null
+++ b/base/poco/XML/src/SAXException.cpp
@@ -0,0 +1,138 @@
+//
+// SAXException.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/SAXException.h"
+#include "Poco/SAX/Locator.h"
+#include <typeinfo>
+#include <sstream>
+
+
+namespace Poco {
+namespace XML {
+
+
+POCO_IMPLEMENT_EXCEPTION(SAXException, XMLException, "SAX Exception")
+POCO_IMPLEMENT_EXCEPTION(SAXNotRecognizedException, SAXException, "Unrecognized SAX feature or property identifier")
+POCO_IMPLEMENT_EXCEPTION(SAXNotSupportedException, SAXException, "Unsupported SAX feature or property identifier")
+
+
+SAXParseException::SAXParseException(const std::string& msg, const Locator& loc):
+	SAXException(buildMessage(msg, loc.getPublicId(), loc.getSystemId(), loc.getLineNumber(), loc.getColumnNumber())),
+	_publicId(loc.getPublicId()),
+	_systemId(loc.getSystemId()),
+	_lineNumber(loc.getLineNumber()),
+	_columnNumber(loc.getColumnNumber())
+{
+}
+
+
+SAXParseException::SAXParseException(const std::string& msg, const Locator& loc, const Poco::Exception& exc):
+	SAXException(buildMessage(msg, loc.getPublicId(), loc.getSystemId(), loc.getLineNumber(), loc.getColumnNumber()), exc),
+	_publicId(loc.getPublicId()),
+	_systemId(loc.getSystemId()),
+	_lineNumber(loc.getLineNumber()),
+	_columnNumber(loc.getColumnNumber())
+{
+}
+
+	
+SAXParseException::SAXParseException(const std::string& msg, const XMLString& publicId, const XMLString& systemId, int lineNumber, int columnNumber):
+	SAXException(buildMessage(msg, publicId, systemId, lineNumber, columnNumber)),
+	_publicId(publicId),
+	_systemId(systemId),
+	_lineNumber(lineNumber),
+	_columnNumber(columnNumber)
+{
+}
+
+
+SAXParseException::SAXParseException(const std::string& msg, const XMLString& publicId, const XMLString& systemId, int lineNumber, int columnNumber, const Poco::Exception& exc):
+	SAXException(buildMessage(msg, publicId, systemId, lineNumber, columnNumber), exc),
+	_publicId(publicId),
+	_systemId(systemId),
+	_lineNumber(lineNumber),
+	_columnNumber(columnNumber)
+{
+}
+
+
+SAXParseException::SAXParseException(const SAXParseException& exc):
+	SAXException(exc),
+	_publicId(exc._publicId),
+	_systemId(exc._systemId),
+	_lineNumber(exc._lineNumber),
+	_columnNumber(exc._columnNumber)
+{
+}
+
+
+SAXParseException::~SAXParseException() noexcept
+{
+}
+
+
+SAXParseException& SAXParseException::operator = (const SAXParseException& exc)
+{
+	if (&exc != this)
+	{
+		SAXException::operator = (exc);
+		_publicId     = exc._publicId;
+		_systemId     = exc._systemId;
+		_lineNumber   = exc._lineNumber;
+		_columnNumber = exc._columnNumber;
+	}
+	return *this;
+}
+
+	
+const char* SAXParseException::name() const noexcept
+{
+	return "SAXParseException";
+}
+
+
+const char* SAXParseException::className() const noexcept
+{
+	return typeid(*this).name();
+}
+
+
+Poco::Exception* SAXParseException::clone() const
+{
+	return new SAXParseException(*this);
+}
+
+
+void SAXParseException::rethrow() const
+{
+	throw *this;
+}
+
+
+std::string SAXParseException::buildMessage(const std::string& msg, const XMLString& publicId, const XMLString& systemId, int lineNumber, int columnNumber)
+{
+	std::ostringstream result;
+	if (!msg.empty()) result << msg << " ";
+	result << "in ";
+	if (!systemId.empty())
+		result << "'" << fromXMLString(systemId) << "', ";
+	else if (!publicId.empty())
+		result << "'" << fromXMLString(publicId) << "', ";
+	if (lineNumber > 0)
+		result << "line " << lineNumber << " column " << columnNumber;
+	return result.str();
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/SAXParser.cpp b/base/poco/XML/src/SAXParser.cpp
new file mode 100644
index 00000000000..54238b51b41
--- /dev/null
+++ b/base/poco/XML/src/SAXParser.cpp
@@ -0,0 +1,245 @@
+//
+// SAXParser.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/SAXParser.h"
+#include "Poco/SAX/SAXException.h"
+#include "Poco/SAX/EntityResolverImpl.h"
+#include "Poco/SAX/InputSource.h"
+#include "Poco/XML/NamespaceStrategy.h"
+#include "Poco/NumberParser.h"
+#include <sstream>
+
+
+namespace Poco {
+namespace XML {
+
+
+const XMLString SAXParser::FEATURE_PARTIAL_READS = toXMLString("http://www.appinf.com/features/enable-partial-reads");
+const XMLString SAXParser::PROPERTY_BLA_MAXIMUM_AMPLIFICATION = toXMLString("http://www.appinf.com/properties/bla-maximum-amplification");
+const XMLString SAXParser::PROPERTY_BLA_ACTIVATION_THRESHOLD = toXMLString("http://www.appinf.com/properties/bla-activation-threshold");
+
+
+SAXParser::SAXParser():
+	_namespaces(true),
+	_namespacePrefixes(false)
+{
+}
+
+
+SAXParser::SAXParser(const XMLString& encoding):
+	_engine(encoding),
+	_namespaces(true),
+	_namespacePrefixes(false)
+{
+}
+
+
+SAXParser::~SAXParser()
+{
+}
+
+
+void SAXParser::setEncoding(const XMLString& encoding)
+{
+	_engine.setEncoding(encoding);
+}
+
+
+const XMLString& SAXParser::getEncoding() const
+{
+	return _engine.getEncoding();
+}
+
+
+void SAXParser::addEncoding(const XMLString& name, Poco::TextEncoding* pEncoding)
+{
+	_engine.addEncoding(name, pEncoding);
+}
+
+
+void SAXParser::setEntityResolver(EntityResolver* pResolver)
+{
+	_engine.setEntityResolver(pResolver);
+}
+
+
+EntityResolver* SAXParser::getEntityResolver() const
+{
+	return _engine.getEntityResolver();
+}
+
+
+void SAXParser::setDTDHandler(DTDHandler* pDTDHandler)
+{
+	_engine.setDTDHandler(pDTDHandler);
+}
+
+
+DTDHandler* SAXParser::getDTDHandler() const
+{
+	return _engine.getDTDHandler();
+}
+
+
+void SAXParser::setContentHandler(ContentHandler* pContentHandler)
+{
+	_engine.setContentHandler(pContentHandler);
+}
+
+
+ContentHandler* SAXParser::getContentHandler() const
+{
+	return _engine.getContentHandler();
+}
+
+
+void SAXParser::setErrorHandler(ErrorHandler* pErrorHandler)
+{
+	_engine.setErrorHandler(pErrorHandler);
+}
+
+
+ErrorHandler* SAXParser::getErrorHandler() const
+{
+	return _engine.getErrorHandler();
+}
+
+
+void SAXParser::setFeature(const XMLString& featureId, bool state)
+{
+	if (featureId == XMLReader::FEATURE_VALIDATION || featureId == XMLReader::FEATURE_STRING_INTERNING)
+		throw SAXNotSupportedException(fromXMLString(XMLReader::FEATURE_VALIDATION));
+	else if (featureId == XMLReader::FEATURE_EXTERNAL_GENERAL_ENTITIES)
+		_engine.setExternalGeneralEntities(state);
+	else if (featureId == XMLReader::FEATURE_EXTERNAL_PARAMETER_ENTITIES)
+		_engine.setExternalParameterEntities(state);
+	else if (featureId == XMLReader::FEATURE_NAMESPACES)
+		_namespaces = state;
+	else if (featureId == XMLReader::FEATURE_NAMESPACE_PREFIXES)
+		_namespacePrefixes = state;
+	else if (featureId == FEATURE_PARTIAL_READS)
+		_engine.setEnablePartialReads(state);
+	else throw SAXNotRecognizedException(fromXMLString(featureId));
+}
+
+
+bool SAXParser::getFeature(const XMLString& featureId) const
+{
+	if (featureId == XMLReader::FEATURE_VALIDATION || featureId == XMLReader::FEATURE_STRING_INTERNING)
+		throw SAXNotSupportedException(fromXMLString(XMLReader::FEATURE_VALIDATION));
+	else if (featureId == XMLReader::FEATURE_EXTERNAL_GENERAL_ENTITIES)
+		return _engine.getExternalGeneralEntities();
+	else if (featureId == XMLReader::FEATURE_EXTERNAL_PARAMETER_ENTITIES)
+		return _engine.getExternalParameterEntities();
+	else if (featureId == XMLReader::FEATURE_NAMESPACES)
+		return _namespaces;
+	else if (featureId == XMLReader::FEATURE_NAMESPACE_PREFIXES)
+		return _namespacePrefixes;
+	else if (featureId == FEATURE_PARTIAL_READS)
+		return _engine.getEnablePartialReads();
+	else throw SAXNotRecognizedException(fromXMLString(featureId));
+}
+
+
+void SAXParser::setProperty(const XMLString& propertyId, const XMLString& value)
+{
+	if (propertyId == XMLReader::PROPERTY_DECLARATION_HANDLER || propertyId == XMLReader::PROPERTY_LEXICAL_HANDLER)
+		throw SAXNotSupportedException(std::string("property does not take a string value: ") + fromXMLString(propertyId));
+	else if (propertyId == PROPERTY_BLA_MAXIMUM_AMPLIFICATION)
+		_engine.setBillionLaughsAttackProtectionMaximumAmplification(static_cast<float>(Poco::NumberParser::parseFloat(value)));
+	else if (propertyId == PROPERTY_BLA_ACTIVATION_THRESHOLD)
+		_engine.setBillionLaughsAttackProtectionActivationThreshold(Poco::NumberParser::parseUnsigned64(value));
+	else
+		throw SAXNotRecognizedException(fromXMLString(propertyId));
+}
+
+
+void SAXParser::setProperty(const XMLString& propertyId, void* value)
+{
+	if (propertyId == XMLReader::PROPERTY_DECLARATION_HANDLER)
+		_engine.setDeclHandler(reinterpret_cast<DeclHandler*>(value));
+	else if (propertyId == XMLReader::PROPERTY_LEXICAL_HANDLER)
+		_engine.setLexicalHandler(reinterpret_cast<LexicalHandler*>(value));
+	else throw SAXNotRecognizedException(fromXMLString(propertyId));
+}
+
+
+void* SAXParser::getProperty(const XMLString& propertyId) const
+{
+	if (propertyId == XMLReader::PROPERTY_DECLARATION_HANDLER)
+		return _engine.getDeclHandler();
+	else if (propertyId == XMLReader::PROPERTY_LEXICAL_HANDLER)
+		return _engine.getLexicalHandler();
+	else throw SAXNotSupportedException(fromXMLString(propertyId));
+}
+
+
+void SAXParser::parse(InputSource* pInputSource)
+{
+	if (pInputSource->getByteStream() || pInputSource->getCharacterStream())
+	{
+		setupParse();
+		_engine.parse(pInputSource);
+	}
+	else parse(pInputSource->getSystemId());
+}
+
+
+void SAXParser::parse(const XMLString& systemId)
+{
+	setupParse();
+	EntityResolverImpl entityResolver;
+	InputSource* pInputSource = entityResolver.resolveEntity(0, systemId);
+	if (pInputSource)
+	{
+		try
+		{
+			_engine.parse(pInputSource);
+		}
+		catch (...)
+		{
+			entityResolver.releaseInputSource(pInputSource);
+			throw;
+		}
+		entityResolver.releaseInputSource(pInputSource);
+	}
+	else throw XMLException("Cannot resolve system identifier", fromXMLString(systemId));
+}
+
+
+void SAXParser::parseString(const std::string& xml)
+{
+	parseMemoryNP(xml.data(), xml.size());
+}
+
+
+void SAXParser::parseMemoryNP(const char* xml, std::size_t size)
+{
+	setupParse();
+	_engine.parse(xml, size);
+}
+
+
+void SAXParser::setupParse()
+{
+	if (_namespaces && !_namespacePrefixes)
+		_engine.setNamespaceStrategy(new NoNamespacePrefixesStrategy);
+	else if (_namespaces && _namespacePrefixes)
+		_engine.setNamespaceStrategy(new NamespacePrefixesStrategy);
+	else
+		_engine.setNamespaceStrategy(new NoNamespacesStrategy);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/Text.cpp b/base/poco/XML/src/Text.cpp
new file mode 100644
index 00000000000..991c31a1d42
--- /dev/null
+++ b/base/poco/XML/src/Text.cpp
@@ -0,0 +1,80 @@
+//
+// Text.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  DOM
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/Text.h"
+#include "Poco/DOM/Document.h"
+#include "Poco/DOM/DOMException.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+const XMLString Text::NODE_NAME = toXMLString("#text");
+
+
+Text::Text(Document* pOwnerDocument, const XMLString& data): 
+	CharacterData(pOwnerDocument, data)
+{
+}
+
+
+Text::Text(Document* pOwnerDocument, const Text& text): 
+	CharacterData(pOwnerDocument, text)
+{
+}
+
+
+Text::~Text()
+{
+}
+
+
+Text* Text::splitText(unsigned long offset)
+{
+	Node* pParent = parentNode();
+	if (!pParent) throw DOMException(DOMException::HIERARCHY_REQUEST_ERR);
+	int n = length() - offset;
+	Text* pNew = ownerDocument()->createTextNode(substringData(offset, n));
+	deleteData(offset, n);
+	pParent->insertBefore(pNew, nextSibling())->release();
+	return pNew;
+}
+
+
+const XMLString& Text::nodeName() const
+{
+	return NODE_NAME;
+}
+
+
+unsigned short Text::nodeType() const
+{
+	return Node::TEXT_NODE;
+}
+
+
+XMLString Text::innerText() const
+{
+	return nodeValue();
+}
+
+
+Node* Text::copyNode(bool deep, Document* pOwnerDocument) const
+{
+	return new Text(pOwnerDocument, *this);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/TreeWalker.cpp b/base/poco/XML/src/TreeWalker.cpp
new file mode 100644
index 00000000000..69c0556cda3
--- /dev/null
+++ b/base/poco/XML/src/TreeWalker.cpp
@@ -0,0 +1,227 @@
+//
+// TreeWalker.cpp
+//
+// Library: XML
+// Package: DOM
+// Module:  TreeWalker
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/DOM/TreeWalker.h"
+#include "Poco/DOM/Node.h"
+#include "Poco/DOM/NodeFilter.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+TreeWalker::TreeWalker(Node* root, unsigned long whatToShow, NodeFilter* pFilter):
+	_pRoot(root),
+	_whatToShow(whatToShow),
+	_pFilter(pFilter),
+	_pCurrent(root)
+{
+}
+
+	
+TreeWalker::TreeWalker(const TreeWalker& walker):
+	_pRoot(walker._pRoot),
+	_whatToShow(walker._whatToShow),
+	_pFilter(walker._pFilter),
+	_pCurrent(walker._pCurrent)
+{
+}
+
+	
+TreeWalker& TreeWalker::operator = (const TreeWalker& walker)
+{
+	if (&walker != this)
+	{
+		_pRoot      = walker._pRoot;
+		_whatToShow = walker._whatToShow;
+		_pFilter    = walker._pFilter;
+		_pCurrent   = walker._pCurrent;
+	}
+	return *this;
+}
+
+	
+TreeWalker::~TreeWalker()
+{
+}
+
+
+void TreeWalker::setCurrentNode(Node* pNode)
+{
+	_pCurrent = pNode;
+}
+
+
+Node* TreeWalker::parentNode()
+{
+	if (!_pCurrent || _pCurrent == _pRoot) return 0;
+	
+	Node* pParent = _pCurrent->parentNode();
+	while (pParent && pParent != _pRoot && accept(pParent) != NodeFilter::FILTER_ACCEPT)
+		pParent = pParent->parentNode();
+	if (pParent && accept(pParent) == NodeFilter::FILTER_ACCEPT)
+		_pCurrent = pParent;
+	else
+		pParent = 0;
+	return pParent;
+}
+
+
+Node* TreeWalker::firstChild()
+{
+	if (!_pCurrent) return 0;
+
+	Node* pNode = accept(_pCurrent) != NodeFilter::FILTER_REJECT ? _pCurrent->firstChild() : 0;
+	while (pNode && accept(pNode) != NodeFilter::FILTER_ACCEPT)
+		pNode = pNode->nextSibling();
+	if (pNode)
+		_pCurrent = pNode;
+	return pNode;
+}
+
+
+Node* TreeWalker::lastChild()
+{
+	if (!_pCurrent) return 0;
+
+	Node* pNode = accept(_pCurrent) != NodeFilter::FILTER_REJECT ? _pCurrent->lastChild() : 0;
+	while (pNode && accept(pNode) != NodeFilter::FILTER_ACCEPT)
+		pNode = pNode->previousSibling();
+	if (pNode)
+		_pCurrent = pNode;
+	return pNode;
+}
+
+
+Node* TreeWalker::previousSibling()
+{
+	if (!_pCurrent) return 0;
+
+	Node* pNode = _pCurrent->previousSibling();
+	while (pNode && accept(pNode) != NodeFilter::FILTER_ACCEPT)
+		pNode = pNode->previousSibling();
+	if (pNode)
+		_pCurrent = pNode;
+	return pNode;
+}
+
+
+Node* TreeWalker::nextSibling()
+{
+	if (!_pCurrent) return 0;
+
+	Node* pNode = _pCurrent->nextSibling();
+	while (pNode && accept(pNode) != NodeFilter::FILTER_ACCEPT)
+		pNode = pNode->nextSibling();
+	if (pNode)
+		_pCurrent = pNode;
+	return pNode;
+}
+
+
+Node* TreeWalker::previousNode()
+{
+	if (!_pCurrent) return 0;
+	
+	Node* pPrev = previous(_pCurrent);
+	while (pPrev && accept(pPrev) != NodeFilter::FILTER_ACCEPT)
+		pPrev = previous(pPrev);
+	if (pPrev)
+		_pCurrent = pPrev;
+	return pPrev;
+}
+
+
+Node* TreeWalker::nextNode()
+{
+	if (!_pCurrent) return 0;
+
+	Node* pNext = next(_pCurrent);
+	while (pNext && accept(pNext) != NodeFilter::FILTER_ACCEPT)
+		pNext = next(pNext);
+	if (pNext)
+		_pCurrent = pNext;
+	return pNext;
+}
+
+
+int TreeWalker::accept(Node* pNode) const
+{
+	bool accept = false;
+	switch (pNode->nodeType())
+	{
+	case Node::ELEMENT_NODE: 
+		accept = (_whatToShow & NodeFilter::SHOW_ELEMENT) != 0; break;
+	case Node::ATTRIBUTE_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_ATTRIBUTE) != 0; break; 
+	case Node::TEXT_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_TEXT) != 0; break; 
+	case Node::CDATA_SECTION_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_CDATA_SECTION) != 0; break; 
+	case Node::ENTITY_REFERENCE_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_ENTITY_REFERENCE) != 0; break; 
+	case Node::ENTITY_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_ENTITY) != 0; break; 
+	case Node::PROCESSING_INSTRUCTION_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_PROCESSING_INSTRUCTION) != 0; break; 
+	case Node::COMMENT_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_COMMENT) != 0; break; 
+	case Node::DOCUMENT_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_DOCUMENT) != 0; break; 
+	case Node::DOCUMENT_TYPE_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_DOCUMENT_TYPE) != 0; break; 
+	case Node::DOCUMENT_FRAGMENT_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_DOCUMENT_FRAGMENT) != 0; break; 
+	case Node::NOTATION_NODE:
+		accept = (_whatToShow & NodeFilter::SHOW_NOTATION) != 0; break; 
+	}
+	if (accept && _pFilter)
+		return _pFilter->acceptNode(pNode);
+	else
+		return accept ? NodeFilter::FILTER_ACCEPT : NodeFilter::FILTER_REJECT;
+}
+
+
+Node* TreeWalker::next(Node* pNode) const
+{
+	Node* pNext = accept(pNode) != NodeFilter::FILTER_REJECT ? pNode->firstChild() : 0;
+	if (pNext) return pNext;
+	pNext = pNode;
+	while (pNext && pNext != _pRoot)
+	{
+		Node* pSibling = pNext->nextSibling();
+		if (pSibling) return pSibling;
+		pNext = pNext->parentNode();
+	}
+	return 0;
+}
+
+
+Node* TreeWalker::previous(Node* pNode) const
+{
+	if (pNode == _pRoot) return 0;
+	Node* pPrev = pNode->previousSibling();
+	while (pPrev)
+	{
+		Node* pLastChild = accept(pPrev) != NodeFilter::FILTER_REJECT ? pPrev->lastChild() : 0;
+		if (pLastChild)
+			pPrev = pLastChild;
+		else
+			return pPrev;
+	}
+	return pNode->parentNode();
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/ValueTraits.cpp b/base/poco/XML/src/ValueTraits.cpp
new file mode 100644
index 00000000000..c9b5b3efb85
--- /dev/null
+++ b/base/poco/XML/src/ValueTraits.cpp
@@ -0,0 +1,39 @@
+//
+// ValueTraits.cpp
+//
+// Library: XML
+// Package: XML
+// Module:  ValueTraits
+//
+// Definition of the ValueTraits templates.
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Based on libstudxml (http://www.codesynthesis.com/projects/libstudxml/).
+// Copyright (c) 2009-2013 Code Synthesis Tools CC.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/XML/XMLStreamParser.h"
+#include "Poco/XML/XMLStreamParserException.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+bool DefaultValueTraits<bool>::parse(std::string s, const XMLStreamParser& p)
+{
+	if (s == "true" || s == "1" || s == "True" || s == "TRUE")
+		return true;
+	else if (s == "false" || s == "0" || s == "False" || s == "FALSE")
+		return false;
+	else
+		throw XMLStreamParserException(p, "invalid bool value '" + s + "'");
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/WhitespaceFilter.cpp b/base/poco/XML/src/WhitespaceFilter.cpp
new file mode 100644
index 00000000000..0ff4d07dc5a
--- /dev/null
+++ b/base/poco/XML/src/WhitespaceFilter.cpp
@@ -0,0 +1,212 @@
+//
+// WhitespaceFilter.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  WhitespaceFilter
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/WhitespaceFilter.h"
+#include "Poco/SAX/SAXException.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+WhitespaceFilter::WhitespaceFilter():
+	_pLexicalHandler(0),
+	_filter(true)
+{
+}
+
+	
+WhitespaceFilter::WhitespaceFilter(XMLReader* pReader): 
+	XMLFilterImpl(pReader),
+	_pLexicalHandler(0),
+	_filter(true)
+{
+}
+
+
+WhitespaceFilter::~WhitespaceFilter()
+{
+}
+
+
+void WhitespaceFilter::setProperty(const XMLString& propertyId, const XMLString& value)
+{
+	if (propertyId == XMLReader::PROPERTY_LEXICAL_HANDLER)
+		throw SAXNotSupportedException(std::string("property does not take a string value: ") + fromXMLString(propertyId));
+	else
+		XMLFilterImpl::setProperty(propertyId, value);
+
+}
+
+
+void WhitespaceFilter::setProperty(const XMLString& propertyId, void* value)
+{
+	if (propertyId == XMLReader::PROPERTY_LEXICAL_HANDLER)
+		_pLexicalHandler = reinterpret_cast<LexicalHandler*>(value);
+	else
+		XMLFilterImpl::setProperty(propertyId, value);
+}
+
+
+void* WhitespaceFilter::getProperty(const XMLString& propertyId) const
+{
+	if (propertyId == XMLReader::PROPERTY_LEXICAL_HANDLER)
+		return _pLexicalHandler;
+	else
+		return XMLFilterImpl::getProperty(propertyId);
+}
+
+
+void WhitespaceFilter::startDocument()
+{
+	XMLFilterImpl::startDocument();
+	_filter = true;
+	_data.clear();
+}
+
+
+void WhitespaceFilter::endDocument()
+{
+	XMLFilterImpl::endDocument();
+	_filter = true;
+	_data.clear();
+}
+
+
+void WhitespaceFilter::startElement(const XMLString& uri, const XMLString& localName, const XMLString& qname, const Attributes& attrList)
+{
+	XMLFilterImpl::startElement(uri, localName, qname, attrList);
+	_filter = true;
+	_data.clear();
+}
+
+
+void WhitespaceFilter::endElement(const XMLString& uri, const XMLString& localName, const XMLString& qname)
+{
+	XMLFilterImpl::endElement(uri, localName, qname);
+	_filter = true;
+	_data.clear();
+}
+
+
+void WhitespaceFilter::characters(const XMLChar ch[], int start, int length)
+{
+	if (_filter)
+	{
+		bool ws = true;
+		const XMLChar* it  = ch + start;
+		const XMLChar* end = ch + start + length;
+		_data.append(it, end);
+		while (it != end)
+		{
+			if (*it != '\r' && *it != '\n' && *it != '\t' && *it != ' ')
+			{
+				ws = false;
+				break;
+			}
+			++it;
+		}
+		if (!ws)
+		{
+			XMLFilterImpl::characters(_data.data(), 0, (int) _data.length());
+			_filter = false;
+			_data.clear();	
+		}
+	}
+	else XMLFilterImpl::characters(ch, start, length);
+}
+
+
+void WhitespaceFilter::ignorableWhitespace(const XMLChar ch[], int start, int length)
+{
+	// the handler name already says that this data can be ignored
+}
+
+
+void WhitespaceFilter::processingInstruction(const XMLString& target, const XMLString& data)
+{
+	XMLFilterImpl::processingInstruction(target, data);
+	_filter = true;
+	_data.clear();
+}
+
+
+void WhitespaceFilter::startDTD(const XMLString& name, const XMLString& publicId, const XMLString& systemId)
+{
+	if (_pLexicalHandler)
+		_pLexicalHandler->startDTD(name, publicId, systemId);
+}
+
+
+void WhitespaceFilter::endDTD()
+{
+	if (_pLexicalHandler)
+		_pLexicalHandler->endDTD();
+}
+
+
+void WhitespaceFilter::startEntity(const XMLString& name)
+{
+	if (_pLexicalHandler)
+		_pLexicalHandler->startEntity(name);
+	_filter = true;
+	_data.clear();
+}
+
+
+void WhitespaceFilter::endEntity(const XMLString& name)
+{
+	if (_pLexicalHandler)
+		_pLexicalHandler->endEntity(name);
+	_filter = true;
+	_data.clear();
+}
+
+
+void WhitespaceFilter::startCDATA()
+{
+	if (_pLexicalHandler)
+		_pLexicalHandler->startCDATA();
+	_filter = false;
+	_data.clear();
+}
+
+
+void WhitespaceFilter::endCDATA()
+{
+	if (_pLexicalHandler)
+		_pLexicalHandler->endCDATA();
+	_filter = true;
+	_data.clear();
+}
+
+
+void WhitespaceFilter::comment(const XMLChar ch[], int start, int length)
+{
+	if (_pLexicalHandler)
+		_pLexicalHandler->comment(ch, start, length);
+	_filter = true;
+	_data.clear();
+}
+
+
+void WhitespaceFilter::setupParse()
+{
+	XMLFilterImpl::setupParse();
+
+	parent()->setProperty(XMLReader::PROPERTY_LEXICAL_HANDLER, static_cast<LexicalHandler*>(this));
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/XMLException.cpp b/base/poco/XML/src/XMLException.cpp
new file mode 100644
index 00000000000..62ba990cda4
--- /dev/null
+++ b/base/poco/XML/src/XMLException.cpp
@@ -0,0 +1,29 @@
+//
+// XMLException.cpp
+//
+// Library: XML
+// Package: XML
+// Module:  XMLException
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/XML/XMLException.h"
+#include <typeinfo>
+
+
+using Poco::RuntimeException;
+
+
+namespace Poco {
+namespace XML {
+
+
+POCO_IMPLEMENT_EXCEPTION(XMLException, RuntimeException, "XML Exception")
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/XMLFilter.cpp b/base/poco/XML/src/XMLFilter.cpp
new file mode 100644
index 00000000000..a409db1e8b0
--- /dev/null
+++ b/base/poco/XML/src/XMLFilter.cpp
@@ -0,0 +1,27 @@
+//
+// XMLFilter.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAXFilters
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/XMLFilter.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+XMLFilter::~XMLFilter()
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/XMLFilterImpl.cpp b/base/poco/XML/src/XMLFilterImpl.cpp
new file mode 100644
index 00000000000..2256f24584d
--- /dev/null
+++ b/base/poco/XML/src/XMLFilterImpl.cpp
@@ -0,0 +1,313 @@
+//
+// XMLFilterImpl.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAXFilters
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/XMLFilterImpl.h"
+#include "Poco/SAX/SAXException.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+XMLFilterImpl::XMLFilterImpl():
+	_pParent(0),
+	_pEntityResolver(0),
+	_pDTDHandler(0),
+	_pContentHandler(0),
+	_pErrorHandler(0)
+{
+}
+
+	
+XMLFilterImpl::XMLFilterImpl(XMLReader* pParent):
+	_pParent(pParent),
+	_pEntityResolver(0),
+	_pDTDHandler(0),
+	_pContentHandler(0),
+	_pErrorHandler(0)
+{
+}
+
+	
+XMLFilterImpl::~XMLFilterImpl()
+{
+}
+
+
+XMLReader* XMLFilterImpl::getParent() const
+{
+	return _pParent;
+}
+
+
+void XMLFilterImpl::setParent(XMLReader* pParent)
+{
+	_pParent = pParent;
+}
+
+
+void XMLFilterImpl::setEntityResolver(EntityResolver* pResolver)
+{
+	_pEntityResolver = pResolver;
+}
+
+
+EntityResolver* XMLFilterImpl::getEntityResolver() const
+{
+	return _pEntityResolver;
+}
+
+
+void XMLFilterImpl::setDTDHandler(DTDHandler* pDTDHandler)
+{
+	_pDTDHandler = pDTDHandler;
+}
+
+
+DTDHandler* XMLFilterImpl::getDTDHandler() const
+{
+	return _pDTDHandler;
+}
+
+
+void XMLFilterImpl::setContentHandler(ContentHandler* pContentHandler)
+{
+	_pContentHandler = pContentHandler;
+}
+
+
+ContentHandler* XMLFilterImpl::getContentHandler() const
+{
+	return _pContentHandler;
+}
+
+
+void XMLFilterImpl::setErrorHandler(ErrorHandler* pErrorHandler)
+{
+	_pErrorHandler = pErrorHandler;
+}
+
+
+ErrorHandler* XMLFilterImpl::getErrorHandler() const
+{
+	return _pErrorHandler;
+}
+
+
+void XMLFilterImpl::setFeature(const XMLString& featureId, bool state)
+{
+	if (_pParent)
+		_pParent->setFeature(featureId, state);
+	else
+		throw SAXNotRecognizedException(fromXMLString(featureId));
+}
+
+
+bool XMLFilterImpl::getFeature(const XMLString& featureId) const
+{
+	if (_pParent)
+		return _pParent->getFeature(featureId);
+	else
+		throw SAXNotRecognizedException(fromXMLString(featureId));
+}
+
+
+void XMLFilterImpl::setProperty(const XMLString& propertyId, const XMLString& value)
+{
+	if (_pParent)
+		_pParent->setProperty(propertyId, value);
+	else
+		throw SAXNotRecognizedException(fromXMLString(propertyId));
+}
+
+
+void XMLFilterImpl::setProperty(const XMLString& propertyId, void* value)
+{
+	if (_pParent)
+		_pParent->setProperty(propertyId, value);
+	else
+		throw SAXNotRecognizedException(fromXMLString(propertyId));
+}
+
+
+void* XMLFilterImpl::getProperty(const XMLString& propertyId) const
+{
+	if (_pParent)
+		return _pParent->getProperty(propertyId);
+	else
+		throw SAXNotRecognizedException(fromXMLString(propertyId));
+}
+
+
+void XMLFilterImpl::parse(InputSource* pSource)
+{
+	setupParse();
+	_pParent->parse(pSource);
+}
+
+
+void XMLFilterImpl::parse(const XMLString& systemId)
+{
+	setupParse();
+	_pParent->parse(systemId);
+}
+
+
+void XMLFilterImpl::parseMemoryNP(const char* xml, std::size_t size)
+{
+	setupParse();
+	_pParent->parseMemoryNP(xml, size);
+}
+
+
+InputSource* XMLFilterImpl::resolveEntity(const XMLString* publicId, const XMLString& systemId)
+{
+	if (_pEntityResolver)
+		return _pEntityResolver->resolveEntity(publicId, systemId);
+	else
+		return 0;
+}
+
+
+void XMLFilterImpl::releaseInputSource(InputSource* pSource)
+{
+	if (_pEntityResolver)
+		_pEntityResolver->releaseInputSource(pSource);
+}
+
+
+void XMLFilterImpl::notationDecl(const XMLString& name, const XMLString* publicId, const XMLString* systemId)
+{
+	if (_pDTDHandler)
+		_pDTDHandler->notationDecl(name, publicId, systemId);
+}
+
+
+void XMLFilterImpl::unparsedEntityDecl(const XMLString& name, const XMLString* publicId, const XMLString& systemId, const XMLString& notationName)
+{
+	if (_pDTDHandler)
+		_pDTDHandler->unparsedEntityDecl(name, publicId, systemId, notationName);
+}
+
+
+void XMLFilterImpl::setDocumentLocator(const Locator* loc)
+{
+	if (_pContentHandler)
+		_pContentHandler->setDocumentLocator(loc);
+}
+
+
+void XMLFilterImpl::startDocument()
+{
+	if (_pContentHandler)
+		_pContentHandler->startDocument();
+}
+
+
+void XMLFilterImpl::endDocument()
+{
+	if (_pContentHandler)
+		_pContentHandler->endDocument();
+}
+
+
+void XMLFilterImpl::startElement(const XMLString& uri, const XMLString& localName, const XMLString& qname, const Attributes& attrList)
+{
+	if (_pContentHandler)
+		_pContentHandler->startElement(uri, localName, qname, attrList);
+}
+
+
+void XMLFilterImpl::endElement(const XMLString& uri, const XMLString& localName, const XMLString& qname)
+{
+	if (_pContentHandler)
+		_pContentHandler->endElement(uri, localName, qname);
+}
+
+
+void XMLFilterImpl::characters(const XMLChar ch[], int start, int length)
+{
+	if (_pContentHandler)
+		_pContentHandler->characters(ch, start, length);
+}
+
+
+void XMLFilterImpl::ignorableWhitespace(const XMLChar ch[], int start, int length)
+{
+	if (_pContentHandler)
+		_pContentHandler->ignorableWhitespace(ch, start, length);
+}
+
+
+void XMLFilterImpl::processingInstruction(const XMLString& target, const XMLString& data)
+{
+	if (_pContentHandler)
+		_pContentHandler->processingInstruction(target, data);
+}
+
+
+void XMLFilterImpl::startPrefixMapping(const XMLString& prefix, const XMLString& uri)
+{
+	if (_pContentHandler)
+		_pContentHandler->startPrefixMapping(prefix, uri);
+}
+
+
+void XMLFilterImpl::endPrefixMapping(const XMLString& prefix)
+{
+	if (_pContentHandler)
+		_pContentHandler->endPrefixMapping(prefix);
+}
+
+
+void XMLFilterImpl::skippedEntity(const XMLString& prefix)
+{
+	if (_pContentHandler)
+		_pContentHandler->skippedEntity(prefix);
+}
+
+
+void XMLFilterImpl::warning(const SAXException& e)
+{
+	if (_pErrorHandler)
+		_pErrorHandler->warning(e);
+}
+
+
+void XMLFilterImpl::error(const SAXException& e)
+{
+	if (_pErrorHandler)
+		_pErrorHandler->error(e);
+}
+
+
+void XMLFilterImpl::fatalError(const SAXException& e)
+{
+	if (_pErrorHandler)
+		_pErrorHandler->fatalError(e);
+}
+
+
+void XMLFilterImpl::setupParse()
+{
+	poco_check_ptr (_pParent);
+
+	_pParent->setEntityResolver(this);
+	_pParent->setDTDHandler(this);
+	_pParent->setContentHandler(this);
+	_pParent->setErrorHandler(this);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/XMLReader.cpp b/base/poco/XML/src/XMLReader.cpp
new file mode 100644
index 00000000000..d6cd767d7d3
--- /dev/null
+++ b/base/poco/XML/src/XMLReader.cpp
@@ -0,0 +1,37 @@
+//
+// XMLReader.cpp
+//
+// Library: XML
+// Package: SAX
+// Module:  SAX
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/SAX/XMLReader.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+const XMLString XMLReader::FEATURE_VALIDATION                  = toXMLString("http://xml.org/sax/features/validation");
+const XMLString XMLReader::FEATURE_NAMESPACES                  = toXMLString("http://xml.org/sax/features/namespaces");
+const XMLString XMLReader::FEATURE_NAMESPACE_PREFIXES          = toXMLString("http://xml.org/sax/features/namespace-prefixes");
+const XMLString XMLReader::FEATURE_EXTERNAL_GENERAL_ENTITIES   = toXMLString("http://xml.org/sax/features/external-general-entities");
+const XMLString XMLReader::FEATURE_EXTERNAL_PARAMETER_ENTITIES = toXMLString("http://xml.org/sax/features/external-parameter-entities");
+const XMLString XMLReader::FEATURE_STRING_INTERNING            = toXMLString("http://xml.org/sax/features/string-interning");
+const XMLString XMLReader::PROPERTY_DECLARATION_HANDLER        = toXMLString("http://xml.org/sax/properties/declaration-handler");
+const XMLString XMLReader::PROPERTY_LEXICAL_HANDLER            = toXMLString("http://xml.org/sax/properties/lexical-handler");
+
+
+XMLReader::~XMLReader()
+{
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/XMLStreamParser.cpp b/base/poco/XML/src/XMLStreamParser.cpp
new file mode 100644
index 00000000000..e3937c327cf
--- /dev/null
+++ b/base/poco/XML/src/XMLStreamParser.cpp
@@ -0,0 +1,939 @@
+//
+// XMLStreamParser.cpp
+//
+// Library: XML
+// Package: XML
+// Module:  XMLStreamParser
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// Based on libstudxml (http://www.codesynthesis.com/projects/libstudxml/).
+// Copyright (c) 2009-2013 Code Synthesis Tools CC.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/XML/XMLStreamParser.h"
+#include <new>
+#include <cstring>
+#include <istream>
+#include <ostream>
+#include <sstream>
+
+
+namespace Poco {
+namespace XML {
+
+
+struct StreamExceptionController
+{
+	StreamExceptionController(std::istream& is):
+		_istr(is),
+		_oldState(_istr.exceptions())
+	{
+		_istr.exceptions(_oldState & ~std::istream::failbit);
+	}
+
+	~StreamExceptionController()
+	{
+		std::istream::iostate s = _istr.rdstate();
+		s &= ~std::istream::failbit;
+
+		// If our error state (sans failbit) intersects with the
+		// exception state then that means we have an active
+		// exception and changing error/exception state will
+		// cause another to be thrown.
+		if (!(_oldState & s))
+		{
+			// Clear failbit if it was caused by eof.
+			//
+			if (_istr.fail() && _istr.eof())
+				_istr.clear(s);
+
+			_istr.exceptions(_oldState);
+		}
+	}
+
+private:
+	StreamExceptionController(const StreamExceptionController&);
+	StreamExceptionController& operator = (const StreamExceptionController&);
+
+private:
+	std::istream& _istr;
+	std::istream::iostate _oldState;
+};
+
+
+static const char* parserEventStrings[] =
+{
+	"start element",
+	"end element",
+	"start attribute",
+	"end attribute",
+	"characters",
+	"start namespace declaration",
+	"end namespace declaration",
+	"end of file"
+};
+
+
+std::ostream& operator << (std::ostream& os, XMLStreamParser::EventType e)
+{
+	return os << parserEventStrings[e];
+}
+
+
+XMLStreamParser::XMLStreamParser(std::istream& is, const std::string& iname, FeatureType f):
+	_size(0),
+	_inputName(iname),
+	_feature(f)
+{
+	_data.is = &is;
+	init();
+}
+
+
+XMLStreamParser::XMLStreamParser(const void* data, std::size_t size, const std::string& iname, FeatureType f):
+	_size(size),
+	_inputName(iname),
+	_feature(f)
+{
+	poco_assert(data != 0 && size != 0);
+
+	_data.buf = data;
+	init();
+}
+
+
+XMLStreamParser::~XMLStreamParser()
+{
+	if (_parser) XML_ParserFree(_parser);
+}
+
+
+void XMLStreamParser::init()
+{
+	_depth = 0;
+	_parserState = state_next;
+	_currentEvent = EV_EOF;
+	_queue = EV_EOF;
+
+	_qualifiedName = &_qname;
+	_pvalue = &_value;
+
+	_line = 0;
+	_column = 0;
+
+	_currentAttributeIndex = 0;
+	_startNamespaceIndex = 0;
+	_endNamespaceIndex = 0;
+
+	if ((_feature & RECEIVE_ATTRIBUTE_MAP) != 0 && (_feature & RECEIVE_ATTRIBUTES_EVENT) != 0)
+		_feature &= ~RECEIVE_ATTRIBUTE_MAP;
+
+	// Allocate the XMLStreamParser. Make sure nothing else can throw after
+	// this call since otherwise we will leak it.
+	//
+	_parser = XML_ParserCreateNS(0, XML_Char(' '));
+
+	if (_parser == 0)
+		throw std::bad_alloc();
+
+	// Get prefixes in addition to namespaces and local names.
+	//
+	XML_SetReturnNSTriplet(_parser, true);
+
+	// Set handlers.
+	//
+	XML_SetUserData(_parser, this);
+
+	if ((_feature & RECEIVE_ELEMENTS) != 0)
+	{
+		XML_SetStartElementHandler(_parser, &handleStartElement);
+		XML_SetEndElementHandler(_parser, &handleEndElement);
+	}
+
+	if ((_feature & RECEIVE_CHARACTERS) != 0)
+		XML_SetCharacterDataHandler(_parser, &handleCharacters);
+
+	if ((_feature & RECEIVE_NAMESPACE_DECLS) != 0)
+		XML_SetNamespaceDeclHandler(_parser, &handleStartNamespaceDecl, &handleEndNamespaceDecl);
+}
+
+
+void XMLStreamParser::handleError()
+{
+	XML_Error e(XML_GetErrorCode(_parser));
+
+	if (e == XML_ERROR_ABORTED)
+	{
+		// For now we only abort the XMLStreamParser in the handleCharacters() and
+		// handleStartElement() handlers.
+		//
+		switch (content())
+		{
+		case Content::Empty:
+			throw XMLStreamParserException(*this, "characters in empty content");
+		case Content::Simple:
+			throw XMLStreamParserException(*this, "element in simple content");
+		case Content::Complex:
+			throw XMLStreamParserException(*this, "characters in complex content");
+		default:
+			poco_assert(false);
+		}
+	}
+	else
+		throw XMLStreamParserException(_inputName, XML_GetCurrentLineNumber(_parser), XML_GetCurrentColumnNumber(_parser), XML_ErrorString(e));
+}
+
+
+XMLStreamParser::EventType XMLStreamParser::next()
+{
+	if (_parserState == state_next)
+		return nextImpl(false);
+	else
+	{
+		// If we previously peeked at start/end_element, then adjust
+		// state accordingly.
+		//
+		switch (_currentEvent)
+		{
+		case EV_END_ELEMENT:
+		{
+			if (!_elementState.empty() && _elementState.back().depth == _depth)
+				popElement();
+
+			_depth--;
+			break;
+		}
+		case EV_START_ELEMENT:
+		{
+			_depth++;
+			break;
+		}
+		default:
+			break;
+		}
+
+		_parserState = state_next;
+		return _currentEvent;
+	}
+}
+
+
+const std::string& XMLStreamParser::attribute(const QName& qn) const
+{
+	if (const ElementEntry* e = getElement())
+	{
+		AttributeMapType::const_iterator i(e->attributeMap.find(qn));
+
+		if (i != e->attributeMap.end())
+		{
+			if (!i->second.handled)
+			{
+				i->second.handled = true;
+				e->attributesUnhandled--;
+			}
+			return i->second.value;
+		}
+	}
+
+	throw XMLStreamParserException(*this, "attribute '" + qn.toString() + "' expected");
+}
+
+
+std::string XMLStreamParser::attribute(const QName& qn, const std::string& dv) const
+{
+	if (const ElementEntry* e = getElement())
+	{
+		AttributeMapType::const_iterator i(e->attributeMap.find(qn));
+
+		if (i != e->attributeMap.end())
+		{
+			if (!i->second.handled)
+			{
+				i->second.handled = true;
+				e->attributesUnhandled--;
+			}
+			return i->second.value;
+		}
+	}
+
+	return dv;
+}
+
+
+bool XMLStreamParser::attributePresent(const QName& qn) const
+{
+	if (const ElementEntry* e = getElement())
+	{
+		AttributeMapType::const_iterator i(e->attributeMap.find(qn));
+
+		if (i != e->attributeMap.end())
+		{
+			if (!i->second.handled)
+			{
+				i->second.handled = true;
+				e->attributesUnhandled--;
+			}
+			return true;
+		}
+	}
+
+	return false;
+}
+
+
+void XMLStreamParser::nextExpect(EventType e)
+{
+	if (next() != e)
+		throw XMLStreamParserException(*this, std::string(parserEventStrings[e]) + " expected");
+}
+
+
+void XMLStreamParser::nextExpect(EventType e, const std::string& ns, const std::string& n)
+{
+	if (next() != e || namespaceURI() != ns || localName() != n)
+		throw XMLStreamParserException(*this, std::string(parserEventStrings[e]) + " '" + QName(ns, n).toString() + "' expected");
+}
+
+
+std::string XMLStreamParser::element()
+{
+	content(Content::Simple);
+	std::string r;
+
+	// The content of the element can be empty in which case there
+	// will be no characters event.
+	//
+	EventType e(next());
+	if (e == EV_CHARACTERS)
+	{
+		r.swap(value());
+		e = next();
+	}
+
+	// We cannot really get anything other than end_element since
+	// the simple content validation won't allow it.
+	//
+	poco_assert(e == EV_END_ELEMENT);
+
+	return r;
+}
+
+
+std::string XMLStreamParser::element(const QName& qn, const std::string& dv)
+{
+	if (peek() == EV_START_ELEMENT && getQName() == qn)
+	{
+		next();
+		return element();
+	}
+
+	return dv;
+}
+
+
+const XMLStreamParser::ElementEntry* XMLStreamParser::getElementImpl() const
+{
+	// The handleStartElement() Expat handler may have already provisioned
+	// an entry in the element stack. In this case, we need to get the
+	// one before it, if any.
+	//
+	const ElementEntry* r(0);
+	ElementState::size_type n(_elementState.size() - 1);
+
+	if (_elementState[n].depth == _depth)
+		r = &_elementState[n];
+	else if (n != 0 && _elementState[n].depth > _depth)
+	{
+		n--;
+		if (_elementState[n].depth == _depth)
+			r = &_elementState[n];
+	}
+
+	return r;
+}
+
+
+void XMLStreamParser::popElement()
+{
+	// Make sure there are no unhandled attributes left.
+	//
+	const ElementEntry& e(_elementState.back());
+	if (e.attributesUnhandled != 0)
+	{
+		// Find the first unhandled attribute and report it.
+		//
+		for (const auto& p: e.attributeMap)
+		{
+			if (!p.second.handled)
+				throw XMLStreamParserException(*this, "unexpected attribute '" + p.first.toString() + "'");
+		}
+		poco_assert(false);
+	}
+
+	_elementState.pop_back();
+}
+
+
+XMLStreamParser::EventType XMLStreamParser::nextImpl(bool peek)
+{
+	EventType e(nextBody());
+
+	// Content-specific processing. Note that we handle characters in the
+	// handleCharacters() Expat handler for two reasons. Firstly, it is faster
+	// to ignore the whitespaces at the source. Secondly, this allows us
+	// to distinguish between element and attribute characters. We can
+	// move this processing to the handler because the characters event
+	// is never queued.
+	//
+	switch (e)
+	{
+	case EV_END_ELEMENT:
+	{
+		// If this is a peek, then avoid popping the stack just yet.
+		// This way, the attribute map will still be valid until we
+		// call next().
+		//
+		if (!peek)
+		{
+			if (!_elementState.empty() && _elementState.back().depth == _depth)
+				popElement();
+
+			_depth--;
+		}
+		break;
+	}
+	case EV_START_ELEMENT:
+	{
+		if (const ElementEntry* pEntry = getElement())
+		{
+			switch (pEntry->content)
+			{
+			case Content::Empty:
+				throw XMLStreamParserException(*this, "element in empty content");
+			case Content::Simple:
+				throw XMLStreamParserException(*this, "element in simple content");
+			default:
+				break;
+			}
+		}
+
+		// If this is a peek, then delay adjusting the depth.
+		//
+		if (!peek)
+			_depth++;
+
+		break;
+	}
+	default:
+		break;
+	}
+
+	return e;
+}
+
+
+XMLStreamParser::EventType XMLStreamParser::nextBody()
+{
+	// See if we have any start namespace declarations we need to return.
+	//
+	if (_startNamespaceIndex < _startNamespace.size())
+	{
+		// Based on the previous event determine what's the next one must be.
+		//
+		switch (_currentEvent)
+		{
+		case EV_START_NAMESPACE_DECL:
+		{
+			if (++_startNamespaceIndex == _startNamespace.size())
+			{
+				_startNamespaceIndex = 0;
+				_startNamespace.clear();
+				_qualifiedName = &_qname;
+				break; // No more declarations.
+			}
+			// Fall through.
+		}
+		case EV_START_ELEMENT:
+		{
+			_currentEvent = EV_START_NAMESPACE_DECL;
+			_qualifiedName = &_startNamespace[_startNamespaceIndex];
+			return _currentEvent;
+		}
+		default:
+		{
+			poco_assert(false);
+			return _currentEvent = EV_EOF;
+		}
+		}
+	}
+
+	// See if we have any attributes we need to return as events.
+	//
+	if (_currentAttributeIndex < _attributes.size())
+	{
+		// Based on the previous event determine what's the next one must be.
+		//
+		switch (_currentEvent)
+		{
+		case EV_START_ATTRIBUTE:
+		{
+			_currentEvent = EV_CHARACTERS;
+			_pvalue = &_attributes[_currentAttributeIndex].value;
+			return _currentEvent;
+		}
+		case EV_CHARACTERS:
+		{
+			_currentEvent = EV_END_ATTRIBUTE; // Name is already set.
+			return _currentEvent;
+		}
+		case EV_END_ATTRIBUTE:
+		{
+			if (++_currentAttributeIndex == _attributes.size())
+			{
+				_currentAttributeIndex = 0;
+				_attributes.clear();
+				_qualifiedName = &_qname;
+				_pvalue = &_value;
+				break; // No more attributes.
+			}
+			// Fall through.
+		}
+		case EV_START_ELEMENT:
+		case EV_START_NAMESPACE_DECL:
+		{
+			_currentEvent = EV_START_ATTRIBUTE;
+			_qualifiedName = &_attributes[_currentAttributeIndex].qname;
+			return _currentEvent;
+		}
+		default:
+		{
+			poco_assert(false);
+			return _currentEvent = EV_EOF;
+		}
+		}
+	}
+
+	// See if we have any end namespace declarations we need to return.
+	//
+	if (_endNamespaceIndex < _endNamespace.size())
+	{
+		// Based on the previous event determine what's the next one must be.
+		//
+		switch (_currentEvent)
+		{
+		case EV_END_NAMESPACE_DECL:
+		{
+			if (++_endNamespaceIndex == _endNamespace.size())
+			{
+				_endNamespaceIndex = 0;
+				_endNamespace.clear();
+				_qualifiedName = &_qname;
+				break; // No more declarations.
+			}
+			// Fall through.
+		}
+			// The end namespace declaration comes before the end element
+			// which means it can follow pretty much any other event.
+			//
+		default:
+		{
+			_currentEvent = EV_END_NAMESPACE_DECL;
+			_qualifiedName = &_endNamespace[_endNamespaceIndex];
+			return _currentEvent;
+		}
+		}
+	}
+
+	// Check the queue.
+	//
+	if (_queue != EV_EOF)
+	{
+		_currentEvent = _queue;
+		_queue = EV_EOF;
+
+		_line = XML_GetCurrentLineNumber(_parser);
+		_column = XML_GetCurrentColumnNumber(_parser);
+
+		return _currentEvent;
+	}
+
+	// Reset the character accumulation flag.
+	//
+	_accumulateContent = false;
+
+	XML_ParsingStatus ps;
+	XML_GetParsingStatus(_parser, &ps);
+
+	switch (ps.parsing)
+	{
+	case XML_INITIALIZED:
+	{
+		// As if we finished the previous chunk.
+		break;
+	}
+	case XML_PARSING:
+	{
+		poco_assert(false);
+		return _currentEvent = EV_EOF;
+	}
+	case XML_FINISHED:
+	{
+		return _currentEvent = EV_EOF;
+	}
+	case XML_SUSPENDED:
+	{
+		switch (XML_ResumeParser(_parser))
+		{
+		case XML_STATUS_SUSPENDED:
+		{
+			// If the XMLStreamParser is again in the suspended state, then
+			// that means we have the next event.
+			//
+			return _currentEvent;
+		}
+		case XML_STATUS_OK:
+		{
+			// Otherwise, we need to get and parse the next chunk of data
+			// unless this was the last chunk, in which case this is eof.
+			//
+			if (ps.finalBuffer)
+				return _currentEvent = EV_EOF;
+
+			break;
+		}
+		case XML_STATUS_ERROR:
+			handleError();
+		}
+		break;
+	}
+	}
+
+	// Get and parse the next chunk of data until we get the next event
+	// or reach eof.
+	//
+	if (!_accumulateContent)
+		_currentEvent = EV_EOF;
+
+	XML_Status s;
+	do
+	{
+		if (_size != 0)
+		{
+			s = XML_Parse(_parser, static_cast<const char*>(_data.buf), static_cast<int>(_size), true);
+
+			if (s == XML_STATUS_ERROR)
+				handleError();
+
+			break;
+		}
+		else
+		{
+			const size_t cap(4096);
+
+			char* b(static_cast<char*>(XML_GetBuffer(_parser, cap)));
+			if (b == 0)
+				throw std::bad_alloc();
+
+			// Temporarily unset the exception failbit. Also clear the fail bit
+			// when we reset the old state if it was caused by eof.
+			//
+			std::istream& is(*_data.is);
+			{
+				StreamExceptionController sec(is);
+				is.read(b, static_cast<std::streamsize>(cap));
+			}
+
+			// If the caller hasn't configured the stream to use exceptions,
+			// then use the parsing exception to report an error.
+			//
+			if (is.bad() || (is.fail() && !is.eof()))
+				throw XMLStreamParserException(*this, "io failure");
+
+			bool eof(is.eof());
+
+			s = XML_ParseBuffer(_parser, static_cast<int>(is.gcount()), eof);
+
+			if (s == XML_STATUS_ERROR)
+				handleError();
+
+			if (eof)
+				break;
+		}
+	} while (s != XML_STATUS_SUSPENDED);
+
+	return _currentEvent;
+}
+
+
+static void splitName(const XML_Char* s, QName& qn)
+{
+	std::string& ns(qn.namespaceURI());
+	std::string& name(qn.localName());
+	std::string& prefix(qn.prefix());
+
+	const char* p(strchr(s, ' '));
+
+	if (p == 0)
+	{
+		ns.clear();
+		name = s;
+		prefix.clear();
+	}
+	else
+	{
+		ns.assign(s, 0, p - s);
+
+		s = p + 1;
+		p = strchr(s, ' ');
+
+		if (p == 0)
+		{
+			name = s;
+			prefix.clear();
+		}
+		else
+		{
+			name.assign(s, 0, p - s);
+			prefix = p + 1;
+		}
+	}
+}
+
+
+void XMLCALL XMLStreamParser::handleStartElement(void* v, const XML_Char* name, const XML_Char** atts)
+{
+	XMLStreamParser& p(*static_cast<XMLStreamParser*>(v));
+
+	XML_ParsingStatus ps;
+	XML_GetParsingStatus(p._parser, &ps);
+
+	// Expat has a (mis)-feature of a possibily calling handlers even
+	// after the non-resumable XML_StopParser call.
+	//
+	if (ps.parsing == XML_FINISHED)
+		return;
+
+	// Cannot be a followup event.
+	//
+	poco_assert(ps.parsing == XML_PARSING);
+
+	// When accumulating characters in simple content, we expect to
+	// see more characters or end element. Seeing start element is
+	// possible but means violation of the content model.
+	//
+	if (p._accumulateContent)
+	{
+		// It would have been easier to throw the exception directly,
+		// however, the Expat code is most likely not exception safe.
+		//
+		p._line = XML_GetCurrentLineNumber(p._parser);
+		p._column = XML_GetCurrentColumnNumber(p._parser);
+		XML_StopParser(p._parser, false);
+		return;
+	}
+
+	p._currentEvent = EV_START_ELEMENT;
+	splitName(name, p._qname);
+
+	p._line = XML_GetCurrentLineNumber(p._parser);
+	p._column = XML_GetCurrentColumnNumber(p._parser);
+
+	// Handle attributes.
+	//
+	if (*atts != 0)
+	{
+		bool am((p._feature & RECEIVE_ATTRIBUTE_MAP) != 0);
+		bool ae((p._feature & RECEIVE_ATTRIBUTES_EVENT) != 0);
+
+		// Provision an entry for this element.
+		//
+		ElementEntry* pe(0);
+		if (am)
+		{
+			p._elementState.emplace_back(p._depth + 1);
+			pe = &p._elementState.back();
+		}
+
+		if (am || ae)
+		{
+			for (; *atts != 0; atts += 2)
+			{
+				if (am)
+				{
+					QName qn;
+					splitName(*atts, qn);
+					AttributeMapType::value_type v(qn, AttributeValueType());
+					v.second.value = *(atts + 1);
+					v.second.handled = false;
+					pe->attributeMap.insert(v);
+				}
+				else
+				{
+					p._attributes.emplace_back();
+					splitName(*atts, p._attributes.back().qname);
+					p._attributes.back().value = *(atts + 1);
+				}
+			}
+
+			if (am)
+				pe->attributesUnhandled = pe->attributeMap.size();
+		}
+	}
+
+	XML_StopParser(p._parser, true);
+}
+
+
+void XMLCALL XMLStreamParser::handleEndElement(void* v, const XML_Char* name)
+{
+	XMLStreamParser& p(*static_cast<XMLStreamParser*>(v));
+
+	XML_ParsingStatus ps;
+	XML_GetParsingStatus(p._parser, &ps);
+
+	// Expat has a (mis)-feature of a possibily calling handlers even
+	// after the non-resumable XML_StopParser call.
+	//
+	if (ps.parsing == XML_FINISHED)
+		return;
+
+	// This can be a followup event for empty elements (<foo/>). In this
+	// case the element name is already set.
+	//
+	if (ps.parsing != XML_PARSING)
+		p._queue = EV_END_ELEMENT;
+	else
+	{
+		splitName(name, p._qname);
+
+		// If we are accumulating characters, then queue this event.
+		//
+		if (p._accumulateContent)
+			p._queue = EV_END_ELEMENT;
+		else
+		{
+			p._currentEvent = EV_END_ELEMENT;
+
+			p._line = XML_GetCurrentLineNumber(p._parser);
+			p._column = XML_GetCurrentColumnNumber(p._parser);
+		}
+
+		XML_StopParser(p._parser, true);
+	}
+}
+
+
+void XMLCALL XMLStreamParser::handleCharacters(void* v, const XML_Char* s, int n)
+{
+	XMLStreamParser& p(*static_cast<XMLStreamParser*>(v));
+
+	XML_ParsingStatus ps;
+	XML_GetParsingStatus(p._parser, &ps);
+
+	// Expat has a (mis)-feature of a possibily calling handlers even
+	// after the non-resumable XML_StopParser call.
+	//
+	if (ps.parsing == XML_FINISHED)
+		return;
+
+	Content cont(p.content());
+
+	// If this is empty or complex content, see if these are whitespaces.
+	//
+	switch (cont)
+	{
+	case Content::Empty:
+	case Content::Complex:
+	{
+		for (int i(0); i != n; ++i)
+		{
+			char c(s[i]);
+			if (c == 0x20 || c == 0x0A || c == 0x0D || c == 0x09)
+				continue;
+
+			// It would have been easier to throw the exception directly,
+			// however, the Expat code is most likely not exception safe.
+			//
+			p._line = XML_GetCurrentLineNumber(p._parser);
+			p._column = XML_GetCurrentColumnNumber(p._parser);
+			XML_StopParser(p._parser, false);
+			break;
+		}
+		return;
+	}
+	default:
+		break;
+	}
+
+	// Append the characters if we are accumulating. This can also be a
+	// followup event for another character event. In this case also
+	// append the data.
+	//
+	if (p._accumulateContent || ps.parsing != XML_PARSING)
+	{
+		poco_assert(p._currentEvent == EV_CHARACTERS);
+		p._value.append(s, n);
+	}
+	else
+	{
+		p._currentEvent = EV_CHARACTERS;
+		p._value.assign(s, n);
+
+		p._line = XML_GetCurrentLineNumber(p._parser);
+		p._column = XML_GetCurrentColumnNumber(p._parser);
+
+		// In simple content we need to accumulate all the characters
+		// into a single event. To do this we will let the XMLStreamParser run
+		// until we reach the end of the element.
+		//
+		if (cont == Content::Simple)
+			p._accumulateContent = true;
+		else
+			XML_StopParser(p._parser, true);
+	}
+}
+
+
+void XMLCALL XMLStreamParser::handleStartNamespaceDecl(void* v, const XML_Char* prefix, const XML_Char* ns)
+{
+	XMLStreamParser& p(*static_cast<XMLStreamParser*>(v));
+
+	XML_ParsingStatus ps;
+	XML_GetParsingStatus(p._parser, &ps);
+
+	// Expat has a (mis)-feature of a possibily calling handlers even
+	// after the non-resumable XML_StopParser call.
+	//
+	if (ps.parsing == XML_FINISHED)
+		return;
+
+	p._startNamespace.emplace_back();
+	p._startNamespace.back().prefix() = (prefix != 0 ? prefix : "");
+	p._startNamespace.back().namespaceURI() = (ns != 0 ? ns : "");
+}
+
+
+void XMLCALL XMLStreamParser::handleEndNamespaceDecl(void* v, const XML_Char* prefix)
+{
+	XMLStreamParser& p(*static_cast<XMLStreamParser*>(v));
+
+	XML_ParsingStatus ps;
+	XML_GetParsingStatus(p._parser, &ps);
+
+	// Expat has a (mis)-feature of a possibily calling handlers even
+	// after the non-resumable XML_StopParser call.
+	//
+	if (ps.parsing == XML_FINISHED)
+		return;
+
+	p._endNamespace.emplace_back();
+	p._endNamespace.back().prefix() = (prefix != 0 ? prefix : "");
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/XMLStreamParserException.cpp b/base/poco/XML/src/XMLStreamParserException.cpp
new file mode 100644
index 00000000000..2b93641ad6b
--- /dev/null
+++ b/base/poco/XML/src/XMLStreamParserException.cpp
@@ -0,0 +1,88 @@
+//
+// XMLStreamParserException.cpp
+//
+// Library: XML
+// Package: XML
+// Module:  XMLStreamParserException
+//
+// Copyright (c) 2015, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/XML/XMLStreamParserException.h"
+#include "Poco/XML/XMLStreamParser.h"
+
+
+namespace Poco {
+namespace XML {
+
+
+XMLStreamParserException::~XMLStreamParserException() throw ()
+{
+}
+
+
+XMLStreamParserException::XMLStreamParserException(const std::string& n, Poco::UInt64 l, Poco::UInt64 c, const std::string& d):
+	_name(n),
+	_line(l),
+	_column(c),
+	_description(d)
+{
+	init();
+}
+
+
+XMLStreamParserException::XMLStreamParserException(const XMLStreamParser& p, const std::string& d):
+	_name(p.inputName()),
+	_line(p.line()),
+	_column(p.column()),
+	_description(d)
+{
+	init();
+}
+
+
+void XMLStreamParserException::init()
+{
+	std::ostringstream os;
+	if (!_name.empty())
+		os << _name << ':';
+	os << _line << ':' << _column << ": error: " << _description;
+	_what = os.str();
+}
+
+
+const char* XMLStreamParserException::name() const noexcept
+{
+	return _name.c_str();
+}
+
+
+Poco::UInt64 XMLStreamParserException::line() const
+{
+	return _line;
+}
+
+
+Poco::UInt64 XMLStreamParserException::column() const
+{
+	return _column;
+}
+
+
+const std::string& XMLStreamParserException::description() const
+{
+	return _description;
+}
+
+
+char const* XMLStreamParserException::what() const throw ()
+{
+	return _what.c_str();
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/XMLString.cpp b/base/poco/XML/src/XMLString.cpp
new file mode 100644
index 00000000000..e8e7a3afa31
--- /dev/null
+++ b/base/poco/XML/src/XMLString.cpp
@@ -0,0 +1,64 @@
+//
+// XMLString.cpp
+//
+// Library: XML
+// Package: XML
+// Module:  XMLString
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/XML/XMLString.h"
+
+
+#if defined(XML_UNICODE_WCHAR_T)
+#include <stdlib.h>
+#endif
+
+
+namespace Poco {
+namespace XML {
+
+
+#if defined(XML_UNICODE_WCHAR_T)
+
+
+std::string fromXMLString(const XMLString& str)
+{
+	std::string result;
+	result.reserve(str.size());
+	
+	for (auto xc: str)
+	{
+		char c;
+		wctomb(&c, xc);
+		result += c;
+	}
+	return result;
+}
+
+
+XMLString toXMLString(const std::string& str)
+{
+	XMLString result;
+	result.reserve(str.size());
+	
+	for (std::string::const_iterator it = str.begin(); it != str.end();)
+	{
+		wchar_t c;
+		int n = mbtowc(&c, &*it, MB_CUR_MAX);
+		result += c;
+		it += (n > 0 ? n : 1);
+	}
+	return result;
+}
+
+
+#endif // XML_UNICODE_WCHAR_T
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/XMLWriter.cpp b/base/poco/XML/src/XMLWriter.cpp
new file mode 100644
index 00000000000..dba21692f0d
--- /dev/null
+++ b/base/poco/XML/src/XMLWriter.cpp
@@ -0,0 +1,1068 @@
+//
+// XMLWriter.cpp
+//
+// Library: XML
+// Package: XML
+// Module:  XMLWriter
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#include "Poco/XML/XMLWriter.h"
+#include "Poco/XML/XMLString.h"
+#include "Poco/XML/XMLException.h"
+#include "Poco/SAX/AttributesImpl.h"
+#include "Poco/UTF8Encoding.h"
+#include "Poco/UTF16Encoding.h"
+#include <sstream>
+
+
+namespace Poco {
+namespace XML {
+
+
+const std::string XMLWriter::NEWLINE_DEFAULT;
+const std::string XMLWriter::NEWLINE_CR         = "\r";
+const std::string XMLWriter::NEWLINE_CRLF       = "\r\n";
+const std::string XMLWriter::NEWLINE_LF         = "\n";
+const std::string XMLWriter::MARKUP_QUOTENC     = "&quot;";
+const std::string XMLWriter::MARKUP_AMPENC      = "&amp;";
+const std::string XMLWriter::MARKUP_LTENC       = "&lt;";
+const std::string XMLWriter::MARKUP_GTENC       = "&gt;";
+const std::string XMLWriter::MARKUP_TABENC      = "&#x9;";
+const std::string XMLWriter::MARKUP_CRENC       = "&#xD;";
+const std::string XMLWriter::MARKUP_LFENC       = "&#xA;";
+const std::string XMLWriter::MARKUP_LT          = "<";
+const std::string XMLWriter::MARKUP_GT          = ">";
+const std::string XMLWriter::MARKUP_SLASHGT     = "/>";
+const std::string XMLWriter::MARKUP_LTSLASH     = "</";
+const std::string XMLWriter::MARKUP_COLON       = ":";
+const std::string XMLWriter::MARKUP_EQQUOT      = "=\"";
+const std::string XMLWriter::MARKUP_QUOT        = "\"";
+const std::string XMLWriter::MARKUP_SPACE       = " ";
+const std::string XMLWriter::MARKUP_TAB         = "\t";
+const std::string XMLWriter::MARKUP_BEGIN_CDATA = "<![CDATA[";
+const std::string XMLWriter::MARKUP_END_CDATA   = "]]>";
+
+
+#if defined(XML_UNICODE_WCHAR_T)
+	#define NATIVE_ENCODING Poco::UTF16Encoding
+#else
+	#define NATIVE_ENCODING Poco::UTF8Encoding
+#endif
+
+
+XMLWriter::XMLWriter(XMLByteOutputStream& str, int options):
+	_pTextConverter(0),
+	_pInEncoding(new NATIVE_ENCODING),
+	_pOutEncoding(new Poco::UTF8Encoding),
+	_options(options),
+	_encoding("UTF-8"),
+	_depth(-1),
+	_elementCount(0),
+	_inFragment(false),
+	_inCDATA(false),
+	_inDTD(false),
+	_inInternalDTD(false),
+	_contentWritten(false),
+	_unclosedStartTag(false),
+	_prefix(0),
+	_nsContextPushed(false),
+	_indent(MARKUP_TAB)
+{
+	_pTextConverter = new Poco::OutputStreamConverter(str, *_pInEncoding, *_pOutEncoding);
+	setNewLine((_options & CANONICAL_XML) ? NEWLINE_LF : NEWLINE_DEFAULT);
+}
+
+
+XMLWriter::XMLWriter(XMLByteOutputStream& str, int options, const std::string& encodingName, Poco::TextEncoding& textEncoding):
+	_pTextConverter(0),
+	_pInEncoding(new NATIVE_ENCODING),
+	_pOutEncoding(0),
+	_options(options),
+	_encoding(encodingName),
+	_depth(-1),
+	_elementCount(0),
+	_inFragment(false),
+	_inCDATA(false),
+	_inDTD(false),
+	_inInternalDTD(false),
+	_contentWritten(false),
+	_unclosedStartTag(false),
+	_prefix(0),
+	_nsContextPushed(false),
+	_indent(MARKUP_TAB)
+{
+	_pTextConverter = new Poco::OutputStreamConverter(str, *_pInEncoding, textEncoding);
+	setNewLine((_options & CANONICAL_XML) ? NEWLINE_LF : NEWLINE_DEFAULT);
+}
+
+
+XMLWriter::XMLWriter(XMLByteOutputStream& str, int options, const std::string& encodingName, Poco::TextEncoding* pTextEncoding):
+	_pTextConverter(0),
+	_pInEncoding(new NATIVE_ENCODING),
+	_pOutEncoding(0),
+	_options(options),
+	_encoding(encodingName),
+	_depth(-1),
+	_elementCount(0),
+	_inFragment(false),
+	_inCDATA(false),
+	_inDTD(false),
+	_inInternalDTD(false),
+	_contentWritten(false),
+	_unclosedStartTag(false),
+	_prefix(0),
+	_nsContextPushed(false),
+	_indent(MARKUP_TAB)
+{
+	if (pTextEncoding)
+	{
+		_pTextConverter = new Poco::OutputStreamConverter(str, *_pInEncoding, *pTextEncoding);
+	}
+	else
+	{
+		_encoding = "UTF-8";
+		_pOutEncoding = new Poco::UTF8Encoding;
+		_pTextConverter = new Poco::OutputStreamConverter(str, *_pInEncoding, *_pOutEncoding);
+	}
+	setNewLine((_options & CANONICAL_XML) ? NEWLINE_LF : NEWLINE_DEFAULT);
+}
+
+
+XMLWriter::~XMLWriter()
+{
+	delete _pTextConverter;
+	delete _pInEncoding;
+	delete _pOutEncoding;
+}
+
+
+void XMLWriter::setDocumentLocator(const Locator* loc)
+{
+}
+
+
+void XMLWriter::setNewLine(const std::string& newLineCharacters)
+{
+	if (newLineCharacters.empty())
+	{
+#if defined(_WIN32)
+		_newLine = NEWLINE_CRLF;
+#else
+		_newLine = NEWLINE_LF;
+#endif
+	}
+	else _newLine = newLineCharacters;
+}
+
+
+const std::string& XMLWriter::getNewLine() const
+{
+	return _newLine;
+}
+
+
+void XMLWriter::setIndent(const std::string& indent)
+{
+	_indent = indent;
+}
+
+
+const std::string& XMLWriter::getIndent() const
+{
+	return _indent;
+}
+
+
+void XMLWriter::startDocument()
+{
+	if (_depth != -1)
+		throw XMLException("Cannot start a document in another document");
+
+	_inFragment    = false;
+	_depth         = 0;
+	_elementCount  = 0;
+	_inDTD         = false;
+	_inInternalDTD = false;
+	_prefix        = 0;
+
+	if (_options & WRITE_XML_DECLARATION)
+		writeXMLDeclaration();
+	
+	_contentWritten = true;
+	_namespaces.reset();
+	_namespaces.pushContext();
+}
+
+
+void XMLWriter::endDocument()
+{
+	if (_depth > 0)
+		throw XMLException("Not well-formed (at least one tag has no matching end tag)");
+	if (_elementCount == 0)
+		throw XMLException("No document element");
+
+	poco_assert_dbg (!_unclosedStartTag);
+
+	_elementCount = 0;
+	_depth        = -1;
+}
+
+
+void XMLWriter::startFragment()
+{
+	if (_depth != -1)
+		throw XMLException("Cannot start a fragment in another fragment or document");
+
+	_inFragment   = true;
+	_depth        = 0;
+	_elementCount = 0;
+	_prefix       = 0;
+
+	_contentWritten = true;
+	_namespaces.reset();
+	_namespaces.pushContext();
+}
+
+
+void XMLWriter::endFragment()
+{
+	if (_depth > 1)
+		throw XMLException("Not well-formed (at least one tag has no matching end tag)");
+	
+	_inFragment   = false;
+	_elementCount = 0;
+	_depth        = -1;
+}
+
+
+void XMLWriter::startElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname)
+{
+	const AttributesImpl attributes;
+	startElement(namespaceURI, localName, qname, attributes);
+}
+
+
+void XMLWriter::startElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const Attributes& attributes)
+{
+	if (_depth == 0 && !_inFragment && _elementCount > 1) 
+		throw XMLException("Not well-formed. Second root element found", nameToString(localName, qname));
+	
+	if (_unclosedStartTag) closeStartTag();
+	prettyPrint();
+	if (_options & CANONICAL_XML)
+		writeCanonicalStartElement(namespaceURI, localName, qname, attributes);
+	else		
+		writeStartElement(namespaceURI, localName, qname, attributes);
+	_elementStack.emplace_back(qname, namespaceURI, localName);
+	_contentWritten = false;
+	++_depth;
+}
+
+
+void XMLWriter::endElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname)
+{
+	if (_depth < 1)
+		throw XMLException("No unclosed tag");
+
+	if (!_elementStack.back().equalsWeakly(qname, namespaceURI, localName))
+		throw XMLException("End tag does not match start tag", nameToString(localName, qname));
+
+	_elementStack.pop_back();
+	--_depth;
+	if (!_unclosedStartTag) prettyPrint();
+	writeEndElement(namespaceURI, localName, qname);
+	_contentWritten = false;
+	if (_depth == 0)
+		writeNewLine();
+}
+
+
+void XMLWriter::emptyElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname)
+{
+	const AttributesImpl attributes;
+	emptyElement(namespaceURI, localName, qname, attributes);
+}
+
+
+void XMLWriter::emptyElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const Attributes& attributes)
+{
+	if (_depth == 0 && _elementCount > 1)
+		throw XMLException("Not well-formed. Second root element found.");
+
+	if (_unclosedStartTag) closeStartTag();
+	prettyPrint();
+	if (_options & CANONICAL_XML)
+		writeCanonicalStartElement(namespaceURI, localName, qname, attributes);
+	else
+		writeStartElement(namespaceURI, localName, qname, attributes);
+	_contentWritten = false;
+	writeMarkup("/");
+	closeStartTag();
+	_namespaces.popContext();
+}
+
+
+void XMLWriter::characters(const XMLChar ch[], int start, int length)
+{
+	if (length == 0) return;
+
+	if (_unclosedStartTag) closeStartTag();
+	_contentWritten = _contentWritten || length > 0;
+	if (_inCDATA)
+	{
+		while (length-- > 0) writeXML(ch[start++]);
+	}
+	else
+	{
+		while (length-- > 0)
+		{
+			XMLChar c = ch[start++];
+			switch (c)
+			{
+			case '"':  writeMarkup(MARKUP_QUOTENC); break;
+			case '&':  writeMarkup(MARKUP_AMPENC); break;
+			case '<':  writeMarkup(MARKUP_LTENC); break;
+			case '>':  writeMarkup(MARKUP_GTENC); break;
+			default:
+				if (c >= 0 && c < 32)
+				{
+					if (c == '\t' || c == '\r' || c == '\n')
+						writeXML(c);
+					else
+						throw XMLException("Invalid character token.");
+				}
+				else writeXML(c);
+			}
+		}
+	}
+}
+
+
+void XMLWriter::characters(const XMLString& str)
+{
+	characters(str.data(), 0, (int) str.length());
+}
+
+
+void XMLWriter::rawCharacters(const XMLString& str)
+{
+	if (_unclosedStartTag) closeStartTag();
+	_contentWritten = _contentWritten || !str.empty();
+	writeXML(str);
+}
+
+
+void XMLWriter::ignorableWhitespace(const XMLChar ch[], int start, int length)
+{
+	characters(ch, start, length);
+}
+
+
+void XMLWriter::processingInstruction(const XMLString& target, const XMLString& data)
+{
+	if (_unclosedStartTag) closeStartTag();
+	prettyPrint();
+	writeMarkup("<?");
+	writeXML(target);
+	if (!data.empty())
+	{
+		writeMarkup(MARKUP_SPACE);
+		writeXML(data);
+	}
+	writeMarkup("?>");
+	if (_depth == 0)
+		writeNewLine();
+}
+
+
+namespace
+{
+	static const XMLString CDATA = toXMLString("CDATA");
+}
+
+
+void XMLWriter::dataElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname,
+                             const XMLString& data,
+	                         const XMLString& attr1, const XMLString& value1,
+							 const XMLString& attr2, const XMLString& value2,
+							 const XMLString& attr3, const XMLString& value3)
+{
+	AttributesImpl attributes;
+	if (!attr1.empty()) attributes.addAttribute(XMLString(), XMLString(), attr1, CDATA, value1);
+	if (!attr2.empty()) attributes.addAttribute(XMLString(), XMLString(), attr2, CDATA, value2);
+	if (!attr3.empty()) attributes.addAttribute(XMLString(), XMLString(), attr3, CDATA, value3);
+	if (data.empty())
+	{
+		emptyElement(namespaceURI, localName, qname, attributes);
+	}
+	else
+	{
+		startElement(namespaceURI, localName, qname, attributes);
+		characters(data);
+		endElement(namespaceURI, localName, qname);
+	}
+}
+
+
+void XMLWriter::startPrefixMapping(const XMLString& prefix, const XMLString& namespaceURI)
+{
+	if (prefix != NamespaceSupport::XML_NAMESPACE_PREFIX)
+	{
+		if (!_nsContextPushed)
+		{
+			_namespaces.pushContext();
+			_nsContextPushed = true;
+		}
+		_namespaces.declarePrefix(prefix, namespaceURI);
+	}
+}
+
+
+void XMLWriter::endPrefixMapping(const XMLString& prefix)
+{
+	// Note: prefix removed by popContext() at element closing tag
+}
+
+
+void XMLWriter::skippedEntity(const XMLString& name)
+{
+}
+
+
+void XMLWriter::startCDATA()
+{
+	if (_inCDATA) throw XMLException("Cannot nest CDATA sections");
+	if (_unclosedStartTag) closeStartTag();
+	_inCDATA = true;
+	writeMarkup(MARKUP_BEGIN_CDATA);
+}
+
+
+void XMLWriter::endCDATA()
+{
+	poco_assert (_inCDATA);
+	_inCDATA = false;
+	writeMarkup(MARKUP_END_CDATA);
+}
+
+
+void XMLWriter::comment(const XMLChar ch[], int start, int length)
+{
+	if (_unclosedStartTag) closeStartTag();
+	prettyPrint();
+	writeMarkup("<!--");
+	while (length-- > 0) writeXML(ch[start++]);
+	writeMarkup("-->");
+	_contentWritten = false;
+}
+
+
+void XMLWriter::startDTD(const XMLString& name, const XMLString& publicId, const XMLString& systemId)
+{
+	writeMarkup("<!DOCTYPE ");
+	writeXML(name);
+	if (!publicId.empty())
+	{
+		writeMarkup(" PUBLIC \"");
+		writeXML(publicId);
+		writeMarkup("\"");
+	}
+	if (!systemId.empty())
+	{
+		if (publicId.empty())
+		{
+			writeMarkup(" SYSTEM");
+		}
+		writeMarkup(" \"");
+		writeXML(systemId);
+		writeMarkup("\"");
+	}
+	_inDTD = true;
+}
+
+
+void XMLWriter::endDTD()
+{
+	poco_assert (_inDTD);
+	if (_inInternalDTD)
+	{
+		writeNewLine();
+		writeMarkup("]");
+		_inInternalDTD = false;
+	}
+	writeMarkup(">");
+	writeNewLine();
+	_inDTD = false;
+}
+
+
+void XMLWriter::startEntity(const XMLString& name)
+{
+}
+
+
+void XMLWriter::endEntity(const XMLString& name)
+{
+}
+
+
+void XMLWriter::notationDecl(const XMLString& name, const XMLString* publicId, const XMLString* systemId)
+{
+	if (!_inDTD) throw XMLException("Notation declaration not within DTD");
+	if (!_inInternalDTD)
+	{
+		writeMarkup(" [");
+		_inInternalDTD = true;
+	}
+	if (_options & PRETTY_PRINT)
+	{
+		writeNewLine();
+		writeMarkup(_indent);
+	}
+	writeMarkup("<!NOTATION ");
+	writeXML(name);
+	if (systemId && !systemId->empty())
+	{
+		writeMarkup(" SYSTEM \"");
+		writeXML(*systemId);
+		writeMarkup("\"");
+	}
+	if (publicId && !publicId->empty())
+	{
+		writeMarkup(" PUBLIC \"");
+		writeXML(*publicId);
+		writeMarkup("\"");
+	}
+	writeMarkup(">");
+}
+
+
+void XMLWriter::unparsedEntityDecl(const XMLString& name, const XMLString* publicId, const XMLString& systemId, const XMLString& notationName)
+{
+	if (!_inDTD) throw XMLException("Entity declaration not within DTD");
+	if (!_inInternalDTD)
+	{
+		writeMarkup(" [");
+		_inInternalDTD = true;
+	}
+	if (_options & PRETTY_PRINT)
+	{
+		writeNewLine();
+		writeMarkup(_indent);
+	}
+	writeMarkup("<!ENTITY ");
+	writeXML(name);
+	if (!systemId.empty())
+	{
+		writeMarkup(" SYSTEM \"");
+		writeXML(systemId);
+		writeMarkup("\"");
+	}
+	if (publicId && !publicId->empty())
+	{
+		writeMarkup(" PUBLIC \"");
+		writeXML(*publicId);
+		writeMarkup("\"");
+	}
+	if (!notationName.empty())
+	{
+		writeMarkup(" NDATA ");
+		writeXML(notationName);
+	}
+	writeMarkup(">");
+}
+
+
+void XMLWriter::prettyPrint() const
+{
+	if ((_options & PRETTY_PRINT) && !_contentWritten)
+	{
+		writeNewLine();
+		writeIndent();
+	}
+}
+
+
+void XMLWriter::writeStartElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const Attributes& attributes)
+{
+	if (!_nsContextPushed)
+		_namespaces.pushContext();
+	_nsContextPushed = false;
+	++_elementCount;
+	
+	declareAttributeNamespaces(attributes);
+
+	writeMarkup(MARKUP_LT);
+	if (!localName.empty() && (qname.empty() || localName == qname))
+	{
+		XMLString prefix;
+		if (!namespaceURI.empty() && !_namespaces.isMapped(namespaceURI))
+		{
+			prefix = uniquePrefix();
+			_namespaces.declarePrefix(prefix, namespaceURI);
+		}
+		else prefix = _namespaces.getPrefix(namespaceURI);
+		writeName(prefix, localName);
+	}
+	else if (namespaceURI.empty() && localName.empty() && !qname.empty())
+	{
+		writeXML(qname);
+	}
+	else if (!localName.empty() && !qname.empty())
+	{
+		XMLString local;
+		XMLString prefix;
+		Name::split(qname, prefix, local);
+		if (prefix.empty()) prefix = _namespaces.getPrefix(namespaceURI);
+		const XMLString& uri = _namespaces.getURI(prefix);
+		if ((uri.empty() || uri != namespaceURI) && !namespaceURI.empty())
+		{
+			_namespaces.declarePrefix(prefix, namespaceURI);
+		}
+		writeName(prefix, localName);
+	}
+	else throw XMLException("Tag mismatch", nameToString(localName, qname));
+
+	AttributeMap attributeMap;
+	addNamespaceAttributes(attributeMap);
+	addAttributes(attributeMap, attributes, namespaceURI);
+	writeAttributes(attributeMap);
+	_unclosedStartTag = true;
+}
+
+
+void XMLWriter::writeCanonicalStartElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const Attributes& attributes)
+{
+	if (!_nsContextPushed)
+		_namespaces.pushContext();
+	_nsContextPushed = false;
+	++_elementCount;
+	
+	declareNamespaces(namespaceURI, localName, qname, attributes);
+
+	writeMarkup(MARKUP_LT);
+	if (!localName.empty())
+	{
+		writeName(_namespaces.getPrefix(namespaceURI), localName);
+	}
+	else if (namespaceURI.empty() && !qname.empty())
+	{
+		writeXML(qname);
+	}
+	else throw XMLException("Tag mismatch", nameToString(localName, qname));
+
+	CanonicalAttributeMap namespaceAttributeMap;
+	addNamespaceAttributes(namespaceAttributeMap);
+	writeAttributes(namespaceAttributeMap);
+	CanonicalAttributeMap attributeMap;
+	addAttributes(attributeMap, attributes, namespaceURI);
+	writeAttributes(attributeMap);
+	_unclosedStartTag = true;
+}
+
+
+void XMLWriter::writeEndElement(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname)
+{
+	if (_unclosedStartTag && !(_options & CANONICAL_XML))
+	{
+		writeMarkup(MARKUP_SLASHGT);
+		_unclosedStartTag = false;
+	}
+	else
+	{
+		if (_unclosedStartTag)
+		{
+			writeMarkup(MARKUP_GT);
+			_unclosedStartTag = false;
+		}
+		writeMarkup(MARKUP_LTSLASH);
+		if (!localName.empty())
+		{
+			XMLString prefix = _namespaces.getPrefix(namespaceURI);
+			writeName(prefix, localName);
+		}
+		else
+		{
+			writeXML(qname);
+		}
+		writeMarkup(MARKUP_GT);
+	}
+	_namespaces.popContext();
+}
+
+
+void XMLWriter::closeStartTag()
+{
+	_unclosedStartTag = false;
+	writeMarkup(MARKUP_GT);
+}
+
+
+void XMLWriter::declareNamespaces(const XMLString& namespaceURI, const XMLString& localName, const XMLString& qname, const Attributes& attributes)
+{
+	std::map<XMLString, std::set<XMLString>> usedNamespaces;
+	bool defaultNameSpaceUsed = false;
+	XMLString defaultNamespaceURI = _namespaces.getURI(XMLString());
+	XMLString local;
+	XMLString prefix;
+	XMLString elementNamespaceURI = namespaceURI;
+	Name::split(qname, prefix, local);
+	if (elementNamespaceURI.empty())
+		elementNamespaceURI = _namespaces.getURI(prefix);
+	if (!elementNamespaceURI.empty())
+	{
+		usedNamespaces[prefix].insert(elementNamespaceURI);
+		if (!defaultNamespaceURI.empty() && elementNamespaceURI == defaultNamespaceURI)
+			defaultNameSpaceUsed = true;
+	}
+	for (int i = 0; i < attributes.getLength(); i++)
+	{
+		XMLString attributeNamespaceURI = attributes.getURI(i);
+		XMLString attributeLocalName    = attributes.getLocalName(i);
+		XMLString attributeQName        = attributes.getQName(i);
+	
+		XMLString attributePrefix;
+		XMLString attributeLocal;
+		Name::split(attributeQName, attributePrefix, attributeLocal);
+		if (attributeNamespaceURI.empty())
+			attributeNamespaceURI = _namespaces.getURI(prefix);
+		if (!attributeNamespaceURI.empty())
+		{
+			usedNamespaces[attributePrefix].insert(attributeNamespaceURI);
+			defaultNameSpaceUsed = defaultNameSpaceUsed || (!defaultNamespaceURI.empty() &&  attributeNamespaceURI == defaultNamespaceURI);
+		}
+	}
+	for (const auto& p: usedNamespaces)
+	{
+		const std::set<XMLString> namespaceURIs = p.second;
+		for (const auto& nsURI: namespaceURIs)
+		{
+			XMLString prefix = p.first;
+			if (prefix.empty()) 
+				prefix = _namespaces.getPrefix(nsURI);
+			if (prefix.empty() && !_namespaces.isMapped(nsURI))
+			{
+				if (defaultNameSpaceUsed)
+				{
+					if (nsURI != defaultNamespaceURI)
+						prefix = uniquePrefix();
+				}
+				else
+				{
+					defaultNamespaceURI = nsURI;
+					defaultNameSpaceUsed = true;
+				}
+
+			}
+			const XMLString& uri = _namespaces.getURI(prefix);
+			if ((uri.empty() || uri != nsURI) && !nsURI.empty()) 
+			{
+				_namespaces.declarePrefix(prefix, nsURI);
+			}
+		}
+	}
+}
+
+
+void XMLWriter::declareAttributeNamespaces(const Attributes& attributes)
+{
+	for (int i = 0; i < attributes.getLength(); i++)
+	{
+		XMLString namespaceURI = attributes.getURI(i);
+		XMLString localName    = attributes.getLocalName(i);
+		XMLString qname        = attributes.getQName(i);
+		if (!localName.empty())
+		{
+			XMLString prefix;
+			XMLString splitLocalName;
+			Name::split(qname, prefix, splitLocalName);
+			if (prefix.empty()) prefix = _namespaces.getPrefix(namespaceURI);
+			if (prefix.empty() && !namespaceURI.empty() && !_namespaces.isMapped(namespaceURI))
+			{
+				prefix = uniquePrefix();
+				_namespaces.declarePrefix(prefix, namespaceURI);
+			}
+
+			const XMLString& uri = _namespaces.getURI(prefix);
+			if ((uri.empty() || uri != namespaceURI) && !namespaceURI.empty())
+			{
+				_namespaces.declarePrefix(prefix, namespaceURI);
+			}
+		}
+	}
+}
+
+
+void XMLWriter::addNamespaceAttributes(AttributeMap& attributeMap)
+{
+	NamespaceSupport::PrefixSet prefixes;
+	_namespaces.getDeclaredPrefixes(prefixes);
+	for (const auto& prefix: prefixes)
+	{
+		XMLString uri   = _namespaces.getURI(prefix);
+		XMLString qname = NamespaceSupport::XMLNS_NAMESPACE_PREFIX;
+		
+		if (!prefix.empty())
+		{
+			qname.append(toXMLString(MARKUP_COLON));
+			qname.append(prefix);
+		}
+		attributeMap[qname] = uri;
+	}
+}
+
+
+void XMLWriter::addNamespaceAttributes(CanonicalAttributeMap& attributeMap)
+{
+	NamespaceSupport::PrefixSet prefixes;
+	_namespaces.getDeclaredPrefixes(prefixes);
+	for (const auto& prefix: prefixes)
+	{
+		XMLString uri   = _namespaces.getURI(prefix);
+		XMLString qname = NamespaceSupport::XMLNS_NAMESPACE_PREFIX;
+		
+		if (!prefix.empty())
+		{
+			qname.append(toXMLString(MARKUP_COLON));
+			qname.append(prefix);
+		}
+		attributeMap.insert(std::make_pair(qname, std::make_pair(qname, uri)));
+	}
+}
+
+
+void XMLWriter::addAttributes(AttributeMap& attributeMap, const Attributes& attributes, const XMLString& elementNamespaceURI)
+{
+	for (int i = 0; i < attributes.getLength(); i++)
+	{
+		XMLString namespaceURI = attributes.getURI(i);
+		XMLString localName    = attributes.getLocalName(i);
+		XMLString qname        = attributes.getQName(i);
+		if (!localName.empty())
+		{
+			XMLString prefix;
+			if (!namespaceURI.empty())
+				prefix = _namespaces.getPrefix(namespaceURI);
+			if (!prefix.empty())
+			{
+				qname = prefix;
+				qname.append(toXMLString(MARKUP_COLON));
+			}
+			else qname.clear();
+			qname.append(localName);
+		}
+		attributeMap[qname] = attributes.getValue(i);
+	}
+}
+
+
+void XMLWriter::addAttributes(CanonicalAttributeMap& attributeMap, const Attributes& attributes, const XMLString& elementNamespaceURI)
+{
+	for (int i = 0; i < attributes.getLength(); i++)
+	{
+		XMLString namespaceURI = attributes.getURI(i);
+		XMLString localName    = attributes.getLocalName(i);
+		XMLString qname        = attributes.getQName(i);
+		XMLString fullQName    = qname;
+		if (!localName.empty())
+		{
+			XMLString prefix;
+			if (!namespaceURI.empty())
+			{
+				prefix    = _namespaces.getPrefix(namespaceURI);
+				fullQName = namespaceURI;
+				fullQName.append(toXMLString(MARKUP_COLON));
+			}
+			else fullQName.clear();
+			if (!prefix.empty())
+			{
+				qname = prefix;
+				qname.append(toXMLString(MARKUP_COLON));
+			}
+			else qname.clear();
+			qname.append(localName);
+			fullQName.append(localName);
+		}
+		attributeMap.insert(std::make_pair(fullQName, std::make_pair(qname, attributes.getValue(i))));
+	}
+}
+
+
+void XMLWriter::writeAttributes(const AttributeMap& attributeMap)
+{
+	for (const auto& ap: attributeMap)
+	{
+		if ((_options & PRETTY_PRINT) && (_options & PRETTY_PRINT_ATTRIBUTES))
+		{
+			writeNewLine();
+			writeIndent(_depth + 1);
+		}
+		else
+		{
+			writeMarkup(MARKUP_SPACE);
+		}
+		writeXML(ap.first);
+		writeMarkup(MARKUP_EQQUOT);
+		for (auto c: ap.second)
+		{
+			switch (c)
+			{
+			case '"':  writeMarkup(MARKUP_QUOTENC); break;
+			case '&':  writeMarkup(MARKUP_AMPENC); break;
+			case '<':  writeMarkup(MARKUP_LTENC); break;
+			case '>':  writeMarkup(MARKUP_GTENC); break;
+			case '\t': writeMarkup(MARKUP_TABENC); break;
+			case '\r': writeMarkup(MARKUP_CRENC); break;
+			case '\n': writeMarkup(MARKUP_LFENC); break;
+			default:
+				if (c >= 0 && c < 32)
+					throw XMLException("Invalid character token.");
+				else 
+					writeXML(c);
+			}
+		}
+		writeMarkup(MARKUP_QUOT);
+	}
+}
+
+
+void XMLWriter::writeAttributes(const CanonicalAttributeMap& attributeMap)
+{
+	for (const auto& ap: attributeMap)
+	{
+		if ((_options & PRETTY_PRINT) && (_options & PRETTY_PRINT_ATTRIBUTES))
+		{
+			writeNewLine();
+			writeIndent(_depth + 1);
+		}
+		else
+		{
+			writeMarkup(MARKUP_SPACE);
+		}
+		writeXML(ap.second.first);
+		writeMarkup(MARKUP_EQQUOT);
+		for (auto c: ap.second.second)
+		{
+			switch (c)
+			{
+			case '"':  writeMarkup(MARKUP_QUOTENC); break;
+			case '&':  writeMarkup(MARKUP_AMPENC); break;
+			case '<':  writeMarkup(MARKUP_LTENC); break;
+			case '>':  writeMarkup(MARKUP_GTENC); break;
+			case '\t': writeMarkup(MARKUP_TABENC); break;
+			case '\r': writeMarkup(MARKUP_CRENC); break;
+			case '\n': writeMarkup(MARKUP_LFENC); break;
+			default:
+				if (c >= 0 && c < 32)
+					throw XMLException("Invalid character token.");
+				else 
+					writeXML(c);
+			}
+		}
+		writeMarkup(MARKUP_QUOT);
+	}
+}
+
+
+void XMLWriter::writeMarkup(const std::string& str) const
+{
+#if defined(XML_UNICODE_WCHAR_T)
+	const XMLString xmlString = toXMLString(str);
+	writeXML(xmlString);
+#else
+	_pTextConverter->write(str.data(), (int) str.size());
+#endif
+}
+
+
+void XMLWriter::writeXML(const XMLString& str) const
+{
+	_pTextConverter->write((const char*) str.data(), (int) str.size()*sizeof(XMLChar));
+}
+
+
+void XMLWriter::writeXML(XMLChar ch) const
+{
+	_pTextConverter->write((const char*) &ch, sizeof(ch));
+}
+
+
+void XMLWriter::writeName(const XMLString& prefix, const XMLString& localName)
+{
+	if (prefix.empty())
+	{
+		writeXML(localName);
+	}
+	else
+	{
+		writeXML(prefix); 
+		writeMarkup(MARKUP_COLON); 
+		writeXML(localName);
+	}
+}
+
+
+void XMLWriter::writeNewLine() const
+{
+	if (_options & PRETTY_PRINT)
+		writeMarkup(_newLine);
+}
+
+
+void XMLWriter::writeIndent() const
+{
+	writeIndent(_depth);
+}
+
+
+void XMLWriter::writeIndent(int depth) const
+{
+	for (int i = 0; i < depth; ++i)
+		writeMarkup(_indent);
+}
+
+
+void XMLWriter::writeXMLDeclaration()
+{
+	writeMarkup("<?xml version=\"1.0\"");
+	if (!_encoding.empty())
+	{
+		writeMarkup(" encoding=\"");
+		writeMarkup(_encoding);
+		writeMarkup("\"");
+	}
+	writeMarkup("?>");
+	writeNewLine();
+}
+
+
+std::string XMLWriter::nameToString(const XMLString& localName, const XMLString& qname)
+{
+	if (qname.empty())
+		return fromXMLString(localName);
+	else
+		return fromXMLString(qname);
+}
+
+
+XMLString XMLWriter::uniquePrefix()
+{
+	std::ostringstream str;
+	str << "ns" << ++_prefix;
+	return toXMLString(str.str());
+}
+
+
+bool XMLWriter::isNamespaceMapped(const XMLString& namespc) const
+{
+	return _namespaces.isMapped(namespc);
+}
+
+
+} } // namespace Poco::XML
diff --git a/base/poco/XML/src/ascii.h b/base/poco/XML/src/ascii.h
new file mode 100644
index 00000000000..1f594d2e54b
--- /dev/null
+++ b/base/poco/XML/src/ascii.h
@@ -0,0 +1,123 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1999-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2007      Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
+   Licensed under the MIT license:
+
+   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.
+*/
+
+#define ASCII_A 0x41
+#define ASCII_B 0x42
+#define ASCII_C 0x43
+#define ASCII_D 0x44
+#define ASCII_E 0x45
+#define ASCII_F 0x46
+#define ASCII_G 0x47
+#define ASCII_H 0x48
+#define ASCII_I 0x49
+#define ASCII_J 0x4A
+#define ASCII_K 0x4B
+#define ASCII_L 0x4C
+#define ASCII_M 0x4D
+#define ASCII_N 0x4E
+#define ASCII_O 0x4F
+#define ASCII_P 0x50
+#define ASCII_Q 0x51
+#define ASCII_R 0x52
+#define ASCII_S 0x53
+#define ASCII_T 0x54
+#define ASCII_U 0x55
+#define ASCII_V 0x56
+#define ASCII_W 0x57
+#define ASCII_X 0x58
+#define ASCII_Y 0x59
+#define ASCII_Z 0x5A
+
+#define ASCII_a 0x61
+#define ASCII_b 0x62
+#define ASCII_c 0x63
+#define ASCII_d 0x64
+#define ASCII_e 0x65
+#define ASCII_f 0x66
+#define ASCII_g 0x67
+#define ASCII_h 0x68
+#define ASCII_i 0x69
+#define ASCII_j 0x6A
+#define ASCII_k 0x6B
+#define ASCII_l 0x6C
+#define ASCII_m 0x6D
+#define ASCII_n 0x6E
+#define ASCII_o 0x6F
+#define ASCII_p 0x70
+#define ASCII_q 0x71
+#define ASCII_r 0x72
+#define ASCII_s 0x73
+#define ASCII_t 0x74
+#define ASCII_u 0x75
+#define ASCII_v 0x76
+#define ASCII_w 0x77
+#define ASCII_x 0x78
+#define ASCII_y 0x79
+#define ASCII_z 0x7A
+
+#define ASCII_0 0x30
+#define ASCII_1 0x31
+#define ASCII_2 0x32
+#define ASCII_3 0x33
+#define ASCII_4 0x34
+#define ASCII_5 0x35
+#define ASCII_6 0x36
+#define ASCII_7 0x37
+#define ASCII_8 0x38
+#define ASCII_9 0x39
+
+#define ASCII_TAB 0x09
+#define ASCII_SPACE 0x20
+#define ASCII_EXCL 0x21
+#define ASCII_QUOT 0x22
+#define ASCII_AMP 0x26
+#define ASCII_APOS 0x27
+#define ASCII_MINUS 0x2D
+#define ASCII_PERIOD 0x2E
+#define ASCII_COLON 0x3A
+#define ASCII_SEMI 0x3B
+#define ASCII_LT 0x3C
+#define ASCII_EQUALS 0x3D
+#define ASCII_GT 0x3E
+#define ASCII_LSQB 0x5B
+#define ASCII_RSQB 0x5D
+#define ASCII_UNDERSCORE 0x5F
+#define ASCII_LPAREN 0x28
+#define ASCII_RPAREN 0x29
+#define ASCII_FF 0x0C
+#define ASCII_SLASH 0x2F
+#define ASCII_HASH 0x23
+#define ASCII_PIPE 0x7C
+#define ASCII_COMMA 0x2C
diff --git a/base/poco/XML/src/asciitab.h b/base/poco/XML/src/asciitab.h
new file mode 100644
index 00000000000..1f6453a4d0b
--- /dev/null
+++ b/base/poco/XML/src/asciitab.h
@@ -0,0 +1,66 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
+   Licensed under the MIT license:
+
+   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.
+*/
+
+/* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
+/* 0x0C */ BT_NONXML, BT_CR, BT_NONXML, BT_NONXML,
+/* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
+/* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
+/* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
+/* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
+/* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+/* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+/* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
+/* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
+/* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+/* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+/* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
+/* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
+/* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+/* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+/* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+/* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
diff --git a/base/poco/XML/src/expat_config.h b/base/poco/XML/src/expat_config.h
new file mode 100644
index 00000000000..78904d1e122
--- /dev/null
+++ b/base/poco/XML/src/expat_config.h
@@ -0,0 +1,39 @@
+//
+// expat_config.h
+//
+// Poco XML specific configuration for expat.
+//
+// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
+// and Contributors.
+//
+// SPDX-License-Identifier:	BSL-1.0
+//
+
+
+#ifndef EXPAT_CONFIG_H
+#define EXPAT_CONFIG_H
+
+
+#include "Poco/Platform.h"
+
+
+#if !defined(POCO_VXWORKS)
+#include <memory.h>
+#endif
+#include <string.h>
+
+
+#define XML_CONTEXT_BYTES 1024
+
+
+#if defined POCO_ARCH_LITTLE_ENDIAN
+#define BYTEORDER 1234
+#else
+#define BYTEORDER 4321
+#endif
+
+
+#define HAVE_MEMMOVE
+
+
+#endif /* EXPAT_CONFIG_H */
diff --git a/base/poco/XML/src/iasciitab.h b/base/poco/XML/src/iasciitab.h
new file mode 100644
index 00000000000..29853841fc6
--- /dev/null
+++ b/base/poco/XML/src/iasciitab.h
@@ -0,0 +1,67 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
+   Licensed under the MIT license:
+
+   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.
+*/
+
+/* Like asciitab.h, except that 0xD has code BT_S rather than BT_CR */
+/* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
+/* 0x0C */ BT_NONXML, BT_S, BT_NONXML, BT_NONXML,
+/* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
+/* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
+/* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
+/* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
+/* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+/* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
+/* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
+/* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
+/* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+/* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+/* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
+/* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
+/* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
+/* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
+/* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+/* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
diff --git a/base/poco/XML/src/internal.h b/base/poco/XML/src/internal.h
new file mode 100644
index 00000000000..ea906711448
--- /dev/null
+++ b/base/poco/XML/src/internal.h
@@ -0,0 +1,163 @@
+/* internal.h
+
+   Internal definitions used by Expat.  This is not needed to compile
+   client code.
+
+   The following calling convention macros are defined for frequently
+   called functions:
+
+   FASTCALL    - Used for those internal functions that have a simple
+                 body and a low number of arguments and local variables.
+
+   PTRCALL     - Used for functions called though function pointers.
+
+   PTRFASTCALL - Like PTRCALL, but for low number of arguments.
+
+   inline      - Used for selected internal functions for which inlining
+                 may improve performance on some platforms.
+
+   Note: Use of these macros is based on judgement, not hard rules,
+         and therefore subject to change.
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 2002-2003 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2002-2006 Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2003      Greg Stein <gstein@users.sourceforge.net>
+   Copyright (c) 2016-2021 Sebastian Pipping <sebastian@pipping.org>
+   Copyright (c) 2018      Yury Gribov <tetra2005@gmail.com>
+   Copyright (c) 2019      David Loffredo <loffredo@steptools.com>
+   Licensed under the MIT license:
+
+   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.
+*/
+
+#if defined(__GNUC__) && defined(__i386__) && ! defined(__MINGW32__)
+/* We'll use this version by default only where we know it helps.
+
+   regparm() generates warnings on Solaris boxes.   See SF bug #692878.
+
+   Instability reported with egcs on a RedHat Linux 7.3.
+   Let's comment out:
+   #define FASTCALL __attribute__((stdcall, regparm(3)))
+   and let's try this:
+*/
+#  define FASTCALL __attribute__((regparm(3)))
+#  define PTRFASTCALL __attribute__((regparm(3)))
+#endif
+
+/* Using __fastcall seems to have an unexpected negative effect under
+   MS VC++, especially for function pointers, so we won't use it for
+   now on that platform. It may be reconsidered for a future release
+   if it can be made more effective.
+   Likely reason: __fastcall on Windows is like stdcall, therefore
+   the compiler cannot perform stack optimizations for call clusters.
+*/
+
+/* Make sure all of these are defined if they aren't already. */
+
+#ifndef FASTCALL
+#  define FASTCALL
+#endif
+
+#ifndef PTRCALL
+#  define PTRCALL
+#endif
+
+#ifndef PTRFASTCALL
+#  define PTRFASTCALL
+#endif
+
+#ifndef XML_MIN_SIZE
+#  if ! defined(__cplusplus) && ! defined(inline)
+#    ifdef __GNUC__
+#      define inline __inline
+#    endif /* __GNUC__ */
+#  endif
+#endif /* XML_MIN_SIZE */
+
+#ifdef __cplusplus
+#  define inline inline
+#else
+#  ifndef inline
+#    define inline
+#  endif
+#endif
+
+#include <limits.h> // ULONG_MAX
+
+#if defined(_WIN32) && ! defined(__USE_MINGW_ANSI_STDIO)
+#  define EXPAT_FMT_ULL(midpart) "%" midpart "I64u"
+#  if defined(_WIN64) // Note: modifiers "td" and "zu" do not work for MinGW
+#    define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart "I64d"
+#    define EXPAT_FMT_SIZE_T(midpart) "%" midpart "I64u"
+#  else
+#    define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart "d"
+#    define EXPAT_FMT_SIZE_T(midpart) "%" midpart "u"
+#  endif
+#else
+#  define EXPAT_FMT_ULL(midpart) "%" midpart "llu"
+#  if ! defined(ULONG_MAX)
+#    error Compiler did not define ULONG_MAX for us
+#  elif ULONG_MAX == 18446744073709551615u // 2^64-1
+#    define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart "ld"
+#    define EXPAT_FMT_SIZE_T(midpart) "%" midpart "lu"
+#  else
+#    define EXPAT_FMT_PTRDIFF_T(midpart) "%" midpart "d"
+#    define EXPAT_FMT_SIZE_T(midpart) "%" midpart "u"
+#  endif
+#endif
+
+#ifndef UNUSED_P
+#  define UNUSED_P(p) (void)p
+#endif
+
+/* NOTE BEGIN If you ever patch these defaults to greater values
+              for non-attack XML payload in your environment,
+              please file a bug report with libexpat.  Thank you!
+*/
+#define EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT   \
+  100.0f
+#define EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT    \
+  8388608 // 8 MiB, 2^23
+/* NOTE END */
+
+#include "Poco/XML/expat.h" // so we can use type XML_Parser below
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void _INTERNAL_trim_to_complete_utf8_characters(const char *from,
+                                                const char **fromLimRef);
+
+#if defined(XML_DTD)
+unsigned long long testingAccountingGetCountBytesDirect(XML_Parser parser);
+unsigned long long testingAccountingGetCountBytesIndirect(XML_Parser parser);
+const char *unsignedCharToPrintable(unsigned char c);
+#  endif
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/base/poco/XML/src/latin1tab.h b/base/poco/XML/src/latin1tab.h
new file mode 100644
index 00000000000..34ab055f703
--- /dev/null
+++ b/base/poco/XML/src/latin1tab.h
@@ -0,0 +1,66 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
+   Licensed under the MIT license:
+
+   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.
+*/
+
+/* 0x80 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x84 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x88 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x8C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x90 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x94 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x98 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0x9C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xA0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xA4 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xA8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
+/* 0xAC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xB0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xB4 */ BT_OTHER, BT_NMSTRT, BT_OTHER, BT_NAME,
+/* 0xB8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
+/* 0xBC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
+/* 0xC0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xC4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xC8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xCC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xD0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xD4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+/* 0xD8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xDC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xE0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xE4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xE8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xEC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xF0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xF4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
+/* 0xF8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
+/* 0xFC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
diff --git a/base/poco/XML/src/nametab.h b/base/poco/XML/src/nametab.h
new file mode 100644
index 00000000000..63485446b96
--- /dev/null
+++ b/base/poco/XML/src/nametab.h
@@ -0,0 +1,136 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 2000 Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2017 Sebastian Pipping <sebastian@pipping.org>
+   Licensed under the MIT license:
+
+   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.
+*/
+
+static const unsigned namingBitmap[] = {
+    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+    0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x04000000,
+    0x87FFFFFE, 0x07FFFFFE, 0x00000000, 0x00000000, 0xFF7FFFFF, 0xFF7FFFFF,
+    0xFFFFFFFF, 0x7FF3FFFF, 0xFFFFFDFE, 0x7FFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
+    0xFFFFE00F, 0xFC31FFFF, 0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
+    0xFFFFFFFF, 0xF80001FF, 0x00000003, 0x00000000, 0x00000000, 0x00000000,
+    0x00000000, 0x00000000, 0xFFFFD740, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
+    0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF, 0xFFFF0003, 0xFFFFFFFF,
+    0xFFFF199F, 0x033FCFFF, 0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
+    0x0000007F, 0x00000000, 0xFFFF0000, 0x000707FF, 0x00000000, 0x07FFFFFE,
+    0x000007FE, 0xFFFE0000, 0xFFFFFFFF, 0x7CFFFFFF, 0x002F7FFF, 0x00000060,
+    0xFFFFFFE0, 0x23FFFFFF, 0xFF000000, 0x00000003, 0xFFF99FE0, 0x03C5FDFF,
+    0xB0000000, 0x00030003, 0xFFF987E0, 0x036DFDFF, 0x5E000000, 0x001C0000,
+    0xFFFBAFE0, 0x23EDFDFF, 0x00000000, 0x00000001, 0xFFF99FE0, 0x23CDFDFF,
+    0xB0000000, 0x00000003, 0xD63DC7E0, 0x03BFC718, 0x00000000, 0x00000000,
+    0xFFFDDFE0, 0x03EFFDFF, 0x00000000, 0x00000003, 0xFFFDDFE0, 0x03EFFDFF,
+    0x40000000, 0x00000003, 0xFFFDDFE0, 0x03FFFDFF, 0x00000000, 0x00000003,
+    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFE, 0x000D7FFF,
+    0x0000003F, 0x00000000, 0xFEF02596, 0x200D6CAE, 0x0000001F, 0x00000000,
+    0x00000000, 0x00000000, 0xFFFFFEFF, 0x000003FF, 0x00000000, 0x00000000,
+    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+    0x00000000, 0xFFFFFFFF, 0xFFFF003F, 0x007FFFFF, 0x0007DAED, 0x50000000,
+    0x82315001, 0x002C62AB, 0x40000000, 0xF580C900, 0x00000007, 0x02010800,
+    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0FFFFFFF, 0xFFFFFFFF,
+    0xFFFFFFFF, 0x03FFFFFF, 0x3F3FFFFF, 0xFFFFFFFF, 0xAAFF3F3F, 0x3FFFFFFF,
+    0xFFFFFFFF, 0x5FDFFFFF, 0x0FCF1FDC, 0x1FDC1FFF, 0x00000000, 0x00004C40,
+    0x00000000, 0x00000000, 0x00000007, 0x00000000, 0x00000000, 0x00000000,
+    0x00000080, 0x000003FE, 0xFFFFFFFE, 0xFFFFFFFF, 0x001FFFFF, 0xFFFFFFFE,
+    0xFFFFFFFF, 0x07FFFFFF, 0xFFFFFFE0, 0x00001FFF, 0x00000000, 0x00000000,
+    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF,
+    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000000, 0x00000000,
+    0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000000F,
+    0x00000000, 0x00000000, 0x00000000, 0x07FF6000, 0x87FFFFFE, 0x07FFFFFE,
+    0x00000000, 0x00800000, 0xFF7FFFFF, 0xFF7FFFFF, 0x00FFFFFF, 0x00000000,
+    0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xF80001FF, 0x00030003, 0x00000000,
+    0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000003, 0xFFFFD7C0, 0xFFFFFFFB,
+    0x547F7FFF, 0x000FFFFD, 0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
+    0xFFFF007B, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF, 0x00000000, 0xFFFE0000,
+    0x027FFFFF, 0xFFFFFFFE, 0xFFFE007F, 0xBBFFFFFB, 0xFFFF0016, 0x000707FF,
+    0x00000000, 0x07FFFFFE, 0x0007FFFF, 0xFFFF03FF, 0xFFFFFFFF, 0x7CFFFFFF,
+    0xFFEF7FFF, 0x03FF3DFF, 0xFFFFFFEE, 0xF3FFFFFF, 0xFF1E3FFF, 0x0000FFCF,
+    0xFFF99FEE, 0xD3C5FDFF, 0xB080399F, 0x0003FFCF, 0xFFF987E4, 0xD36DFDFF,
+    0x5E003987, 0x001FFFC0, 0xFFFBAFEE, 0xF3EDFDFF, 0x00003BBF, 0x0000FFC1,
+    0xFFF99FEE, 0xF3CDFDFF, 0xB0C0398F, 0x0000FFC3, 0xD63DC7EC, 0xC3BFC718,
+    0x00803DC7, 0x0000FF80, 0xFFFDDFEE, 0xC3EFFDFF, 0x00603DDF, 0x0000FFC3,
+    0xFFFDDFEC, 0xC3EFFDFF, 0x40603DDF, 0x0000FFC3, 0xFFFDDFEC, 0xC3FFFDFF,
+    0x00803DCF, 0x0000FFC3, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+    0xFFFFFFFE, 0x07FF7FFF, 0x03FF7FFF, 0x00000000, 0xFEF02596, 0x3BFF6CAE,
+    0x03FF3F5F, 0x00000000, 0x03000000, 0xC2A003FF, 0xFFFFFEFF, 0xFFFE03FF,
+    0xFEBF0FDF, 0x02FE3FFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
+    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1FFF0000, 0x00000002,
+    0x000000A0, 0x003EFFFE, 0xFFFFFFFE, 0xFFFFFFFF, 0x661FFFFF, 0xFFFFFFFE,
+    0xFFFFFFFF, 0x77FFFFFF,
+};
+static const unsigned char nmstrtPages[] = {
+    0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x09, 0x0A, 0x0B,
+    0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13, 0x00, 0x14, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x15, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00,
+};
+static const unsigned char namePages[] = {
+    0x19, 0x03, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x00, 0x00, 0x1F, 0x20, 0x21,
+    0x22, 0x23, 0x24, 0x25, 0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13, 0x26, 0x14, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x27, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+    0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00,
+};
diff --git a/base/poco/XML/src/siphash.h b/base/poco/XML/src/siphash.h
new file mode 100644
index 00000000000..2199632980d
--- /dev/null
+++ b/base/poco/XML/src/siphash.h
@@ -0,0 +1,393 @@
+/* ==========================================================================
+ * siphash.h - SipHash-2-4 in a single header file
+ * --------------------------------------------------------------------------
+ * Derived by William Ahern from the reference implementation[1] published[2]
+ * by Jean-Philippe Aumasson and Daniel J. Berstein.
+ * Minimal changes by Sebastian Pipping and Victor Stinner on top, see below.
+ * Licensed under the CC0 Public Domain Dedication license.
+ *
+ * 1. https://www.131002.net/siphash/siphash24.c
+ * 2. https://www.131002.net/siphash/
+ * --------------------------------------------------------------------------
+ * HISTORY:
+ *
+ * 2020-10-03  (Sebastian Pipping)
+ *   - Drop support for Visual Studio 9.0/2008 and earlier
+ *
+ * 2019-08-03  (Sebastian Pipping)
+ *   - Mark part of sip24_valid as to be excluded from clang-format
+ *   - Re-format code using clang-format 9
+ *
+ * 2018-07-08  (Anton Maklakov)
+ *   - Add "fall through" markers for GCC's -Wimplicit-fallthrough
+ *
+ * 2017-11-03  (Sebastian Pipping)
+ *   - Hide sip_tobin and sip_binof unless SIPHASH_TOBIN macro is defined
+ *
+ * 2017-07-25  (Vadim Zeitlin)
+ *   - Fix use of SIPHASH_MAIN macro
+ *
+ * 2017-07-05  (Sebastian Pipping)
+ *   - Use _SIP_ULL macro to not require a C++11 compiler if compiled as C++
+ *   - Add const qualifiers at two places
+ *   - Ensure <=80 characters line length (assuming tab width 4)
+ *
+ * 2017-06-23  (Victor Stinner)
+ *   - Address Win64 compile warnings
+ *
+ * 2017-06-18  (Sebastian Pipping)
+ *   - Clarify license note in the header
+ *   - Address C89 issues:
+ *     - Stop using inline keyword (and let compiler decide)
+ *     - Replace _Bool by int
+ *     - Turn macro siphash24 into a function
+ *     - Address invalid conversion (void pointer) by explicit cast
+ *   - Address lack of stdint.h for Visual Studio 2003 to 2008
+ *   - Always expose sip24_valid (for self-tests)
+ *
+ * 2012-11-04 - Born.  (William Ahern)
+ * --------------------------------------------------------------------------
+ * USAGE:
+ *
+ * SipHash-2-4 takes as input two 64-bit words as the key, some number of
+ * message bytes, and outputs a 64-bit word as the message digest. This
+ * implementation employs two data structures: a struct sipkey for
+ * representing the key, and a struct siphash for representing the hash
+ * state.
+ *
+ * For converting a 16-byte unsigned char array to a key, use either the
+ * macro sip_keyof or the routine sip_tokey. The former instantiates a
+ * compound literal key, while the latter requires a key object as a
+ * parameter.
+ *
+ * 	unsigned char secret[16];
+ * 	arc4random_buf(secret, sizeof secret);
+ * 	struct sipkey *key = sip_keyof(secret);
+ *
+ * For hashing a message, use either the convenience macro siphash24 or the
+ * routines sip24_init, sip24_update, and sip24_final.
+ *
+ * 	struct siphash state;
+ * 	void *msg;
+ * 	size_t len;
+ * 	uint64_t hash;
+ *
+ * 	sip24_init(&state, key);
+ * 	sip24_update(&state, msg, len);
+ * 	hash = sip24_final(&state);
+ *
+ * or
+ *
+ * 	hash = siphash24(msg, len, key);
+ *
+ * To convert the 64-bit hash value to a canonical 8-byte little-endian
+ * binary representation, use either the macro sip_binof or the routine
+ * sip_tobin. The former instantiates and returns a compound literal array,
+ * while the latter requires an array object as a parameter.
+ * --------------------------------------------------------------------------
+ * NOTES:
+ *
+ * o Neither sip_keyof, sip_binof, nor siphash24 will work with compilers
+ *   lacking compound literal support. Instead, you must use the lower-level
+ *   interfaces which take as parameters the temporary state objects.
+ *
+ * o Uppercase macros may evaluate parameters more than once. Lowercase
+ *   macros should not exhibit any such side effects.
+ * ==========================================================================
+ */
+#ifndef SIPHASH_H
+#define SIPHASH_H
+
+#include <stddef.h> /* size_t */
+#  include <stdint.h> /* uint64_t uint32_t uint8_t */
+
+/*
+ * Workaround to not require a C++11 compiler for using ULL suffix
+ * if this code is included and compiled as C++; related GCC warning is:
+ * warning: use of C++11 long long integer constant [-Wlong-long]
+ */
+#define _SIP_ULL(high, low) (((uint64_t)high << 32) | low)
+
+#define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
+
+#define SIP_U32TO8_LE(p, v)                                                    \
+  (p)[0] = (uint8_t)((v) >> 0);                                                \
+  (p)[1] = (uint8_t)((v) >> 8);                                                \
+  (p)[2] = (uint8_t)((v) >> 16);                                               \
+  (p)[3] = (uint8_t)((v) >> 24);
+
+#define SIP_U64TO8_LE(p, v)                                                    \
+  SIP_U32TO8_LE((p) + 0, (uint32_t)((v) >> 0));                                \
+  SIP_U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
+
+#define SIP_U8TO64_LE(p)                                                       \
+  (((uint64_t)((p)[0]) << 0) | ((uint64_t)((p)[1]) << 8)                       \
+   | ((uint64_t)((p)[2]) << 16) | ((uint64_t)((p)[3]) << 24)                   \
+   | ((uint64_t)((p)[4]) << 32) | ((uint64_t)((p)[5]) << 40)                   \
+   | ((uint64_t)((p)[6]) << 48) | ((uint64_t)((p)[7]) << 56))
+
+#define SIPHASH_INITIALIZER                                                    \
+  { 0, 0, 0, 0, {0}, 0, 0 }
+
+struct siphash {
+  uint64_t v0, v1, v2, v3;
+
+  unsigned char buf[8], *p;
+  uint64_t c;
+}; /* struct siphash */
+
+#define SIP_KEYLEN 16
+
+struct sipkey {
+  uint64_t k[2];
+}; /* struct sipkey */
+
+#define sip_keyof(k) sip_tokey(&(struct sipkey){{0}}, (k))
+
+static struct sipkey *
+sip_tokey(struct sipkey *key, const void *src) {
+  key->k[0] = SIP_U8TO64_LE((const unsigned char *)src);
+  key->k[1] = SIP_U8TO64_LE((const unsigned char *)src + 8);
+  return key;
+} /* sip_tokey() */
+
+#ifdef SIPHASH_TOBIN
+
+#  define sip_binof(v) sip_tobin((unsigned char[8]){0}, (v))
+
+static void *
+sip_tobin(void *dst, uint64_t u64) {
+  SIP_U64TO8_LE((unsigned char *)dst, u64);
+  return dst;
+} /* sip_tobin() */
+
+#endif /* SIPHASH_TOBIN */
+
+static void
+sip_round(struct siphash *H, const int rounds) {
+  int i;
+
+  for (i = 0; i < rounds; i++) {
+    H->v0 += H->v1;
+    H->v1 = SIP_ROTL(H->v1, 13);
+    H->v1 ^= H->v0;
+    H->v0 = SIP_ROTL(H->v0, 32);
+
+    H->v2 += H->v3;
+    H->v3 = SIP_ROTL(H->v3, 16);
+    H->v3 ^= H->v2;
+
+    H->v0 += H->v3;
+    H->v3 = SIP_ROTL(H->v3, 21);
+    H->v3 ^= H->v0;
+
+    H->v2 += H->v1;
+    H->v1 = SIP_ROTL(H->v1, 17);
+    H->v1 ^= H->v2;
+    H->v2 = SIP_ROTL(H->v2, 32);
+  }
+} /* sip_round() */
+
+static struct siphash *
+sip24_init(struct siphash *H, const struct sipkey *key) {
+  H->v0 = _SIP_ULL(0x736f6d65U, 0x70736575U) ^ key->k[0];
+  H->v1 = _SIP_ULL(0x646f7261U, 0x6e646f6dU) ^ key->k[1];
+  H->v2 = _SIP_ULL(0x6c796765U, 0x6e657261U) ^ key->k[0];
+  H->v3 = _SIP_ULL(0x74656462U, 0x79746573U) ^ key->k[1];
+
+  H->p = H->buf;
+  H->c = 0;
+
+  return H;
+} /* sip24_init() */
+
+#define sip_endof(a) (&(a)[sizeof(a) / sizeof *(a)])
+
+static struct siphash *
+sip24_update(struct siphash *H, const void *src, size_t len) {
+  const unsigned char *p = (const unsigned char *)src, *pe = p + len;
+  uint64_t m;
+
+  do {
+    while (p < pe && H->p < sip_endof(H->buf))
+      *H->p++ = *p++;
+
+    if (H->p < sip_endof(H->buf))
+      break;
+
+    m = SIP_U8TO64_LE(H->buf);
+    H->v3 ^= m;
+    sip_round(H, 2);
+    H->v0 ^= m;
+
+    H->p = H->buf;
+    H->c += 8;
+  } while (p < pe);
+
+  return H;
+} /* sip24_update() */
+
+static uint64_t
+sip24_final(struct siphash *H) {
+  const char left = (char)(H->p - H->buf);
+  uint64_t b = (H->c + left) << 56;
+
+  switch (left) {
+  case 7:
+    b |= (uint64_t)H->buf[6] << 48;
+    /* fall through */
+  case 6:
+    b |= (uint64_t)H->buf[5] << 40;
+    /* fall through */
+  case 5:
+    b |= (uint64_t)H->buf[4] << 32;
+    /* fall through */
+  case 4:
+    b |= (uint64_t)H->buf[3] << 24;
+    /* fall through */
+  case 3:
+    b |= (uint64_t)H->buf[2] << 16;
+    /* fall through */
+  case 2:
+    b |= (uint64_t)H->buf[1] << 8;
+    /* fall through */
+  case 1:
+    b |= (uint64_t)H->buf[0] << 0;
+    /* fall through */
+  case 0:
+    break;
+  }
+
+  H->v3 ^= b;
+  sip_round(H, 2);
+  H->v0 ^= b;
+  H->v2 ^= 0xff;
+  sip_round(H, 4);
+
+  return H->v0 ^ H->v1 ^ H->v2 ^ H->v3;
+} /* sip24_final() */
+
+static uint64_t
+siphash24(const void *src, size_t len, const struct sipkey *key) {
+  struct siphash state = SIPHASH_INITIALIZER;
+  return sip24_final(sip24_update(sip24_init(&state, key), src, len));
+} /* siphash24() */
+
+/*
+ * SipHash-2-4 output with
+ * k = 00 01 02 ...
+ * and
+ * in = (empty string)
+ * in = 00 (1 byte)
+ * in = 00 01 (2 bytes)
+ * in = 00 01 02 (3 bytes)
+ * ...
+ * in = 00 01 02 ... 3e (63 bytes)
+ */
+static int
+sip24_valid(void) {
+  /* clang-format off */
+  static const unsigned char vectors[64][8] = {
+    { 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, },
+    { 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, },
+    { 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, },
+    { 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85, },
+    { 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf, },
+    { 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18, },
+    { 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb, },
+    { 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab, },
+    { 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93, },
+    { 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e, },
+    { 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a, },
+    { 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4, },
+    { 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75, },
+    { 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14, },
+    { 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7, },
+    { 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1, },
+    { 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f, },
+    { 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69, },
+    { 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b, },
+    { 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb, },
+    { 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe, },
+    { 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0, },
+    { 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93, },
+    { 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8, },
+    { 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8, },
+    { 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc, },
+    { 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17, },
+    { 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f, },
+    { 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde, },
+    { 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6, },
+    { 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad, },
+    { 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32, },
+    { 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71, },
+    { 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7, },
+    { 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12, },
+    { 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15, },
+    { 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31, },
+    { 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02, },
+    { 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca, },
+    { 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a, },
+    { 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e, },
+    { 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad, },
+    { 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18, },
+    { 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4, },
+    { 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9, },
+    { 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9, },
+    { 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb, },
+    { 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0, },
+    { 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6, },
+    { 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7, },
+    { 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee, },
+    { 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1, },
+    { 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a, },
+    { 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81, },
+    { 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f, },
+    { 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24, },
+    { 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7, },
+    { 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea, },
+    { 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60, },
+    { 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66, },
+    { 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c, },
+    { 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f, },
+    { 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, },
+    { 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, }
+  };
+  /* clang-format on */
+
+  unsigned char in[64];
+  struct sipkey k;
+  size_t i;
+
+  sip_tokey(&k, "\000\001\002\003\004\005\006\007\010\011"
+                "\012\013\014\015\016\017");
+
+  for (i = 0; i < sizeof in; ++i) {
+    in[i] = (unsigned char)i;
+
+    if (siphash24(in, i, &k) != SIP_U8TO64_LE(vectors[i]))
+      return 0;
+  }
+
+  return 1;
+} /* sip24_valid() */
+
+#ifdef SIPHASH_MAIN
+
+#  include <stdio.h>
+
+int
+main(void) {
+  const int ok = sip24_valid();
+
+  if (ok)
+    puts("OK");
+  else
+    puts("FAIL");
+
+  return ! ok;
+} /* main() */
+
+#endif /* SIPHASH_MAIN */
+
+#endif /* SIPHASH_H */
diff --git a/base/poco/XML/src/utf8tab.h b/base/poco/XML/src/utf8tab.h
new file mode 100644
index 00000000000..51387789ed6
--- /dev/null
+++ b/base/poco/XML/src/utf8tab.h
@@ -0,0 +1,66 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
+   Licensed under the MIT license:
+
+   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.
+*/
+
+/* 0x80 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x84 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x88 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x8C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x90 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x94 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x98 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0x9C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xA0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xA4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xA8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xAC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xB0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xB4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xB8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xBC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
+/* 0xC0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xC4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xC8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xCC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xD0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xD4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xD8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xDC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
+/* 0xE0 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+/* 0xE4 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+/* 0xE8 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+/* 0xEC */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
+/* 0xF0 */ BT_LEAD4, BT_LEAD4, BT_LEAD4, BT_LEAD4,
+/* 0xF4 */ BT_LEAD4, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0xF8 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
+/* 0xFC */ BT_NONXML, BT_NONXML, BT_MALFORM, BT_MALFORM,
diff --git a/base/poco/XML/src/xmlparse.cpp b/base/poco/XML/src/xmlparse.cpp
new file mode 100644
index 00000000000..99570a1fb12
--- /dev/null
+++ b/base/poco/XML/src/xmlparse.cpp
@@ -0,0 +1,8402 @@
+/* fcb1a62fefa945567301146eb98e3ad3413e823a41c4378e84e8b6b6f308d824 (2.4.7+)
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2000-2006 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2001-2002 Greg Stein <gstein@users.sourceforge.net>
+   Copyright (c) 2002-2016 Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2005-2009 Steven Solie <steven@solie.ca>
+   Copyright (c) 2016      Eric Rahm <erahm@mozilla.com>
+   Copyright (c) 2016-2022 Sebastian Pipping <sebastian@pipping.org>
+   Copyright (c) 2016      Gaurav <g.gupta@samsung.com>
+   Copyright (c) 2016      Thomas Beutlich <tc@tbeu.de>
+   Copyright (c) 2016      Gustavo Grieco <gustavo.grieco@imag.fr>
+   Copyright (c) 2016      Pascal Cuoq <cuoq@trust-in-soft.com>
+   Copyright (c) 2016      Ed Schouten <ed@nuxi.nl>
+   Copyright (c) 2017-2018 Rhodri James <rhodri@wildebeest.org.uk>
+   Copyright (c) 2017      Václav Slavík <vaclav@slavik.io>
+   Copyright (c) 2017      Viktor Szakats <commit@vsz.me>
+   Copyright (c) 2017      Chanho Park <chanho61.park@samsung.com>
+   Copyright (c) 2017      Rolf Eike Beer <eike@sf-mail.de>
+   Copyright (c) 2017      Hans Wennborg <hans@chromium.org>
+   Copyright (c) 2018      Anton Maklakov <antmak.pub@gmail.com>
+   Copyright (c) 2018      Benjamin Peterson <benjamin@python.org>
+   Copyright (c) 2018      Marco Maggi <marco.maggi-ipsu@poste.it>
+   Copyright (c) 2018      Mariusz Zaborski <oshogbo@vexillium.org>
+   Copyright (c) 2019      David Loffredo <loffredo@steptools.com>
+   Copyright (c) 2019-2020 Ben Wagner <bungeman@chromium.org>
+   Copyright (c) 2019      Vadim Zeitlin <vadim@zeitlins.org>
+   Copyright (c) 2021      Dong-hee Na <donghee.na@python.org>
+   Copyright (c) 2022      Samanta Navarro <ferivoz@riseup.net>
+   Copyright (c) 2022      Jeffrey Walton <noloader@gmail.com>
+   Licensed under the MIT license:
+
+   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.
+*/
+
+#if ! defined(_GNU_SOURCE)
+#  define _GNU_SOURCE 1 /* syscall prototype */
+#endif
+
+#ifdef _WIN32
+/* force stdlib to define rand_s() */
+#  if ! defined(_CRT_RAND_S)
+#    define _CRT_RAND_S
+#  endif
+#endif
+
+#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <stddef.h>
+#include <string.h> /* memset(), memcpy() */
+#include <assert.h>
+#include <limits.h> /* UINT_MAX */
+#include <stdio.h>  /* fprintf */
+#include <stdlib.h> /* getenv, rand_s */
+#include <stdint.h> /* uintptr_t */
+#include <math.h>   /* isnan */
+
+#define EXPAT_POCO 1
+
+#if defined(EXPAT_POCO)
+#  include "Poco/RandomStream.h"
+#  include "Poco/BinaryReader.h"
+#elif defined(_WIN32)
+#  define getpid GetCurrentProcessId
+#else
+#  include <sys/time.h>  /* gettimeofday() */
+#  include <sys/types.h> /* getpid() */
+#  include <unistd.h>    /* getpid() */
+#  include <fcntl.h>     /* O_RDONLY */
+#  include <errno.h>
+#endif
+
+#define XML_BUILDING_EXPAT 1
+
+#ifdef EXPAT_WIN32
+#  include "winconfig.h"
+#endif
+
+#include "expat_config.h"
+
+#include "ascii.h"
+#include "Poco/XML/expat.h"
+#include "siphash.h"
+
+#if defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)
+#  if defined(HAVE_GETRANDOM)
+#    include <sys/random.h> /* getrandom */
+#  else
+#    include <unistd.h>      /* syscall */
+#    include <sys/syscall.h> /* SYS_getrandom */
+#  endif
+#  if ! defined(GRND_NONBLOCK)
+#    define GRND_NONBLOCK 0x0001
+#  endif /* defined(GRND_NONBLOCK) */
+#endif   /* defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM) */
+
+#if defined(HAVE_LIBBSD)                                                       \
+    && (defined(HAVE_ARC4RANDOM_BUF) || defined(HAVE_ARC4RANDOM))
+#  include <bsd/stdlib.h>
+#endif
+
+#if defined(_WIN32) && ! defined(LOAD_LIBRARY_SEARCH_SYSTEM32)
+#  define LOAD_LIBRARY_SEARCH_SYSTEM32 0x00000800
+#endif
+
+#if ! defined(HAVE_GETRANDOM) && ! defined(HAVE_SYSCALL_GETRANDOM)             \
+    && ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM)            \
+    && ! defined(XML_DEV_URANDOM) && ! defined(_WIN32)                         \
+    && ! defined(XML_POOR_ENTROPY) && ! defined(EXPAT_POCO)
+#  error You do not have support for any sources of high quality entropy \
+    enabled.  For end user security, that is probably not what you want. \
+    \
+    Your options include: \
+      * Linux >=3.17 + glibc >=2.25 (getrandom): HAVE_GETRANDOM, \
+      * Linux >=3.17 + glibc (including <2.25) (syscall SYS_getrandom): HAVE_SYSCALL_GETRANDOM, \
+      * BSD / macOS >=10.7 (arc4random_buf): HAVE_ARC4RANDOM_BUF, \
+      * BSD / macOS (including <10.7) (arc4random): HAVE_ARC4RANDOM, \
+      * libbsd (arc4random_buf): HAVE_ARC4RANDOM_BUF + HAVE_LIBBSD, \
+      * libbsd (arc4random): HAVE_ARC4RANDOM + HAVE_LIBBSD, \
+      * Linux (including <3.17) / BSD / macOS (including <10.7) / Solaris >=8 (/dev/urandom): XML_DEV_URANDOM, \
+      * Windows >=Vista (rand_s): _WIN32. \
+    \
+    If insist on not using any of these, bypass this error by defining \
+    XML_POOR_ENTROPY; you have been warned. \
+    \
+    If you have reasons to patch this detection code away or need changes \
+    to the build system, please open a bug.  Thank you!
+#endif
+
+#ifdef XML_UNICODE
+#  define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX
+#  define XmlConvert XmlUtf16Convert
+#  define XmlGetInternalEncoding XmlGetUtf16InternalEncoding
+#  define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS
+#  define XmlEncode XmlUtf16Encode
+#  define MUST_CONVERT(enc, s) (! (enc)->isUtf16 || (((uintptr_t)(s)) & 1))
+typedef unsigned short ICHAR;
+#else
+#  define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX
+#  define XmlConvert XmlUtf8Convert
+#  define XmlGetInternalEncoding XmlGetUtf8InternalEncoding
+#  define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS
+#  define XmlEncode XmlUtf8Encode
+#  define MUST_CONVERT(enc, s) (! (enc)->isUtf8)
+typedef char ICHAR;
+#endif
+
+#ifndef XML_NS
+
+#  define XmlInitEncodingNS XmlInitEncoding
+#  define XmlInitUnknownEncodingNS XmlInitUnknownEncoding
+#  undef XmlGetInternalEncodingNS
+#  define XmlGetInternalEncodingNS XmlGetInternalEncoding
+#  define XmlParseXmlDeclNS XmlParseXmlDecl
+
+#endif
+
+#ifdef XML_UNICODE
+
+#  ifdef XML_UNICODE_WCHAR_T
+#    define XML_T(x) (const wchar_t) x
+#    define XML_L(x) L##x
+#  else
+#    define XML_T(x) (const unsigned short)x
+#    define XML_L(x) x
+#  endif
+
+#else
+
+#  define XML_T(x) x
+#  define XML_L(x) x
+
+#endif
+
+/* Round up n to be a multiple of sz, where sz is a power of 2. */
+#define ROUND_UP(n, sz) (((n) + ((sz)-1)) & ~((sz)-1))
+
+/* Do safe (NULL-aware) pointer arithmetic */
+#define EXPAT_SAFE_PTR_DIFF(p, q) (((p) && (q)) ? ((p) - (q)) : 0)
+
+#include "internal.h"
+#include "xmltok.h"
+#include "xmlrole.h"
+
+typedef const XML_Char *KEY;
+
+typedef struct {
+  KEY name;
+} NAMED;
+
+typedef struct {
+  NAMED **v;
+  unsigned char power;
+  size_t size;
+  size_t used;
+  const XML_Memory_Handling_Suite *mem;
+} HASH_TABLE;
+
+static size_t keylen(KEY s);
+
+static void copy_salt_to_sipkey(XML_Parser parser, struct sipkey *key);
+
+/* For probing (after a collision) we need a step size relative prime
+   to the hash table size, which is a power of 2. We use double-hashing,
+   since we can calculate a second hash value cheaply by taking those bits
+   of the first hash value that were discarded (masked out) when the table
+   index was calculated: index = hash & mask, where mask = table->size - 1.
+   We limit the maximum step size to table->size / 4 (mask >> 2) and make
+   it odd, since odd numbers are always relative prime to a power of 2.
+*/
+#define SECOND_HASH(hash, mask, power)                                         \
+  ((((hash) & ~(mask)) >> ((power)-1)) & ((mask) >> 2))
+#define PROBE_STEP(hash, mask, power)                                          \
+  ((unsigned char)((SECOND_HASH(hash, mask, power)) | 1))
+
+typedef struct {
+  NAMED **p;
+  NAMED **end;
+} HASH_TABLE_ITER;
+
+#define INIT_TAG_BUF_SIZE 32 /* must be a multiple of sizeof(XML_Char) */
+#define INIT_DATA_BUF_SIZE 1024
+#define INIT_ATTS_SIZE 16
+#define INIT_ATTS_VERSION 0xFFFFFFFF
+#define INIT_BLOCK_SIZE 1024
+#define INIT_BUFFER_SIZE 1024
+
+#define EXPAND_SPARE 24
+
+typedef struct binding {
+  struct prefix *prefix;
+  struct binding *nextTagBinding;
+  struct binding *prevPrefixBinding;
+  const struct attribute_id *attId;
+  XML_Char *uri;
+  int uriLen;
+  int uriAlloc;
+} BINDING;
+
+typedef struct prefix {
+  const XML_Char *name;
+  BINDING *binding;
+} PREFIX;
+
+typedef struct {
+  const XML_Char *str;
+  const XML_Char *localPart;
+  const XML_Char *prefix;
+  int strLen;
+  int uriLen;
+  int prefixLen;
+} TAG_NAME;
+
+/* TAG represents an open element.
+   The name of the element is stored in both the document and API
+   encodings.  The memory buffer 'buf' is a separately-allocated
+   memory area which stores the name.  During the XML_Parse()/
+   XMLParseBuffer() when the element is open, the memory for the 'raw'
+   version of the name (in the document encoding) is shared with the
+   document buffer.  If the element is open across calls to
+   XML_Parse()/XML_ParseBuffer(), the buffer is re-allocated to
+   contain the 'raw' name as well.
+
+   A parser re-uses these structures, maintaining a list of allocated
+   TAG objects in a free list.
+*/
+typedef struct tag {
+  struct tag *parent;  /* parent of this element */
+  const char *rawName; /* tagName in the original encoding */
+  int rawNameLength;
+  TAG_NAME name; /* tagName in the API encoding */
+  char *buf;     /* buffer for name components */
+  char *bufEnd;  /* end of the buffer */
+  BINDING *bindings;
+} TAG;
+
+typedef struct {
+  const XML_Char *name;
+  const XML_Char *textPtr;
+  int textLen;   /* length in XML_Chars */
+  int processed; /* # of processed bytes - when suspended */
+  const XML_Char *systemId;
+  const XML_Char *base;
+  const XML_Char *publicId;
+  const XML_Char *notation;
+  XML_Bool open;
+  XML_Bool is_param;
+  XML_Bool is_internal; /* true if declared in internal subset outside PE */
+} ENTITY;
+
+typedef struct {
+  enum XML_Content_Type type;
+  enum XML_Content_Quant quant;
+  const XML_Char *name;
+  int firstchild;
+  int lastchild;
+  int childcnt;
+  int nextsib;
+} CONTENT_SCAFFOLD;
+
+#define INIT_SCAFFOLD_ELEMENTS 32
+
+typedef struct block {
+  struct block *next;
+  int size;
+  XML_Char s[1];
+} BLOCK;
+
+typedef struct {
+  BLOCK *blocks;
+  BLOCK *freeBlocks;
+  const XML_Char *end;
+  XML_Char *ptr;
+  XML_Char *start;
+  const XML_Memory_Handling_Suite *mem;
+} STRING_POOL;
+
+/* The XML_Char before the name is used to determine whether
+   an attribute has been specified. */
+typedef struct attribute_id {
+  XML_Char *name;
+  PREFIX *prefix;
+  XML_Bool maybeTokenized;
+  XML_Bool xmlns;
+} ATTRIBUTE_ID;
+
+typedef struct {
+  const ATTRIBUTE_ID *id;
+  XML_Bool isCdata;
+  const XML_Char *value;
+} DEFAULT_ATTRIBUTE;
+
+typedef struct {
+  unsigned long version;
+  unsigned long hash;
+  const XML_Char *uriName;
+} NS_ATT;
+
+typedef struct {
+  const XML_Char *name;
+  PREFIX *prefix;
+  const ATTRIBUTE_ID *idAtt;
+  int nDefaultAtts;
+  int allocDefaultAtts;
+  DEFAULT_ATTRIBUTE *defaultAtts;
+} ELEMENT_TYPE;
+
+typedef struct {
+  HASH_TABLE generalEntities;
+  HASH_TABLE elementTypes;
+  HASH_TABLE attributeIds;
+  HASH_TABLE prefixes;
+  STRING_POOL pool;
+  STRING_POOL entityValuePool;
+  /* false once a parameter entity reference has been skipped */
+  XML_Bool keepProcessing;
+  /* true once an internal or external PE reference has been encountered;
+     this includes the reference to an external subset */
+  XML_Bool hasParamEntityRefs;
+  XML_Bool standalone;
+#ifdef XML_DTD
+  /* indicates if external PE has been read */
+  XML_Bool paramEntityRead;
+  HASH_TABLE paramEntities;
+#endif /* XML_DTD */
+  PREFIX defaultPrefix;
+  /* === scaffolding for building content model === */
+  XML_Bool in_eldecl;
+  CONTENT_SCAFFOLD *scaffold;
+  unsigned contentStringLen;
+  unsigned scaffSize;
+  unsigned scaffCount;
+  int scaffLevel;
+  int *scaffIndex;
+} DTD;
+
+typedef struct open_internal_entity {
+  const char *internalEventPtr;
+  const char *internalEventEndPtr;
+  struct open_internal_entity *next;
+  ENTITY *entity;
+  int startTagLevel;
+  XML_Bool betweenDecl; /* WFC: PE Between Declarations */
+} OPEN_INTERNAL_ENTITY;
+
+enum XML_Account {
+  XML_ACCOUNT_DIRECT,           /* bytes directly passed to the Expat parser */
+  XML_ACCOUNT_ENTITY_EXPANSION, /* intermediate bytes produced during entity
+                                   expansion */
+  XML_ACCOUNT_NONE              /* i.e. do not account, was accounted already */
+};
+
+#ifdef XML_DTD
+typedef unsigned long long XmlBigCount;
+typedef struct accounting {
+  XmlBigCount countBytesDirect;
+  XmlBigCount countBytesIndirect;
+  int debugLevel;
+  float maximumAmplificationFactor; // >=1.0
+  unsigned long long activationThresholdBytes;
+} ACCOUNTING;
+
+typedef struct entity_stats {
+  unsigned int countEverOpened;
+  unsigned int currentDepth;
+  unsigned int maximumDepthSeen;
+  int debugLevel;
+} ENTITY_STATS;
+#endif /* XML_DTD */
+
+typedef enum XML_Error PTRCALL Processor(XML_Parser parser, const char *start,
+                                         const char *end, const char **endPtr);
+
+static Processor prologProcessor;
+static Processor prologInitProcessor;
+static Processor contentProcessor;
+static Processor cdataSectionProcessor;
+#ifdef XML_DTD
+static Processor ignoreSectionProcessor;
+static Processor externalParEntProcessor;
+static Processor externalParEntInitProcessor;
+static Processor entityValueProcessor;
+static Processor entityValueInitProcessor;
+#endif /* XML_DTD */
+static Processor epilogProcessor;
+static Processor errorProcessor;
+static Processor externalEntityInitProcessor;
+static Processor externalEntityInitProcessor2;
+static Processor externalEntityInitProcessor3;
+static Processor externalEntityContentProcessor;
+static Processor internalEntityProcessor;
+
+static enum XML_Error handleUnknownEncoding(XML_Parser parser,
+                                            const XML_Char *encodingName);
+static enum XML_Error processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
+                                     const char *s, const char *next);
+static enum XML_Error initializeEncoding(XML_Parser parser);
+static enum XML_Error doProlog(XML_Parser parser, const ENCODING *enc,
+                               const char *s, const char *end, int tok,
+                               const char *next, const char **nextPtr,
+                               XML_Bool haveMore, XML_Bool allowClosingDoctype,
+                               enum XML_Account account);
+static enum XML_Error processInternalEntity(XML_Parser parser, ENTITY *entity,
+                                            XML_Bool betweenDecl);
+static enum XML_Error doContent(XML_Parser parser, int startTagLevel,
+                                const ENCODING *enc, const char *start,
+                                const char *end, const char **endPtr,
+                                XML_Bool haveMore, enum XML_Account account);
+static enum XML_Error doCdataSection(XML_Parser parser, const ENCODING *,
+                                     const char **startPtr, const char *end,
+                                     const char **nextPtr, XML_Bool haveMore,
+                                     enum XML_Account account);
+#ifdef XML_DTD
+static enum XML_Error doIgnoreSection(XML_Parser parser, const ENCODING *,
+                                      const char **startPtr, const char *end,
+                                      const char **nextPtr, XML_Bool haveMore);
+#endif /* XML_DTD */
+
+static void freeBindings(XML_Parser parser, BINDING *bindings);
+static enum XML_Error storeAtts(XML_Parser parser, const ENCODING *,
+                                const char *s, TAG_NAME *tagNamePtr,
+                                BINDING **bindingsPtr,
+                                enum XML_Account account);
+static enum XML_Error addBinding(XML_Parser parser, PREFIX *prefix,
+                                 const ATTRIBUTE_ID *attId, const XML_Char *uri,
+                                 BINDING **bindingsPtr);
+static int defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, XML_Bool isCdata,
+                           XML_Bool isId, const XML_Char *dfltValue,
+                           XML_Parser parser);
+static enum XML_Error storeAttributeValue(XML_Parser parser, const ENCODING *,
+                                          XML_Bool isCdata, const char *,
+                                          const char *, STRING_POOL *,
+                                          enum XML_Account account);
+static enum XML_Error appendAttributeValue(XML_Parser parser, const ENCODING *,
+                                           XML_Bool isCdata, const char *,
+                                           const char *, STRING_POOL *,
+                                           enum XML_Account account);
+static ATTRIBUTE_ID *getAttributeId(XML_Parser parser, const ENCODING *enc,
+                                    const char *start, const char *end);
+static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);
+static enum XML_Error storeEntityValue(XML_Parser parser, const ENCODING *enc,
+                                       const char *start, const char *end,
+                                       enum XML_Account account);
+static int reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
+                                       const char *start, const char *end);
+static int reportComment(XML_Parser parser, const ENCODING *enc,
+                         const char *start, const char *end);
+static void reportDefault(XML_Parser parser, const ENCODING *enc,
+                          const char *start, const char *end);
+
+static const XML_Char *getContext(XML_Parser parser);
+static XML_Bool setContext(XML_Parser parser, const XML_Char *context);
+
+static void FASTCALL normalizePublicId(XML_Char *s);
+
+static DTD *dtdCreate(const XML_Memory_Handling_Suite *ms);
+/* do not call if m_parentParser != NULL */
+static void dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms);
+static void dtdDestroy(DTD *p, XML_Bool isDocEntity,
+                       const XML_Memory_Handling_Suite *ms);
+static int dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,
+                   const XML_Memory_Handling_Suite *ms);
+static int copyEntityTable(XML_Parser oldParser, HASH_TABLE *, STRING_POOL *,
+                           const HASH_TABLE *);
+static NAMED *lookup(XML_Parser parser, HASH_TABLE *table, KEY name,
+                     size_t createSize);
+static void FASTCALL hashTableInit(HASH_TABLE *,
+                                   const XML_Memory_Handling_Suite *ms);
+static void FASTCALL hashTableClear(HASH_TABLE *);
+static void FASTCALL hashTableDestroy(HASH_TABLE *);
+static void FASTCALL hashTableIterInit(HASH_TABLE_ITER *, const HASH_TABLE *);
+static NAMED *FASTCALL hashTableIterNext(HASH_TABLE_ITER *);
+
+static void FASTCALL poolInit(STRING_POOL *,
+                              const XML_Memory_Handling_Suite *ms);
+static void FASTCALL poolClear(STRING_POOL *);
+static void FASTCALL poolDestroy(STRING_POOL *);
+static XML_Char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
+                            const char *ptr, const char *end);
+static XML_Char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
+                                 const char *ptr, const char *end);
+static XML_Bool FASTCALL poolGrow(STRING_POOL *pool);
+static const XML_Char *FASTCALL poolCopyString(STRING_POOL *pool,
+                                               const XML_Char *s);
+static const XML_Char *poolCopyStringN(STRING_POOL *pool, const XML_Char *s,
+                                       int n);
+static const XML_Char *FASTCALL poolAppendString(STRING_POOL *pool,
+                                                 const XML_Char *s);
+
+static int FASTCALL nextScaffoldPart(XML_Parser parser);
+static XML_Content *build_model(XML_Parser parser);
+static ELEMENT_TYPE *getElementType(XML_Parser parser, const ENCODING *enc,
+                                    const char *ptr, const char *end);
+
+static XML_Char *copyString(const XML_Char *s,
+                            const XML_Memory_Handling_Suite *memsuite);
+
+static unsigned long generate_hash_secret_salt(XML_Parser parser);
+static XML_Bool startParsing(XML_Parser parser);
+
+static XML_Parser parserCreate(const XML_Char *encodingName,
+                               const XML_Memory_Handling_Suite *memsuite,
+                               const XML_Char *nameSep, DTD *dtd);
+
+static void parserInit(XML_Parser parser, const XML_Char *encodingName);
+
+#ifdef XML_DTD
+static float accountingGetCurrentAmplification(XML_Parser rootParser);
+static void accountingReportStats(XML_Parser originParser, const char *epilog);
+static void accountingOnAbort(XML_Parser originParser);
+static void accountingReportDiff(XML_Parser rootParser,
+                                 unsigned int levelsAwayFromRootParser,
+                                 const char *before, const char *after,
+                                 ptrdiff_t bytesMore, int source_line,
+                                 enum XML_Account account);
+static XML_Bool accountingDiffTolerated(XML_Parser originParser, int tok,
+                                        const char *before, const char *after,
+                                        int source_line,
+                                        enum XML_Account account);
+
+static void entityTrackingReportStats(XML_Parser parser, ENTITY *entity,
+                                      const char *action, int sourceLine);
+static void entityTrackingOnOpen(XML_Parser parser, ENTITY *entity,
+                                 int sourceLine);
+static void entityTrackingOnClose(XML_Parser parser, ENTITY *entity,
+                                  int sourceLine);
+
+static XML_Parser getRootParserOf(XML_Parser parser,
+                                  unsigned int *outLevelDiff);
+#endif /* XML_DTD */
+
+static unsigned long getDebugLevel(const char *variableName,
+                                   unsigned long defaultDebugLevel);
+
+#define poolStart(pool) ((pool)->start)
+#define poolEnd(pool) ((pool)->ptr)
+#define poolLength(pool) ((pool)->ptr - (pool)->start)
+#define poolChop(pool) ((void)--(pool->ptr))
+#define poolLastChar(pool) (((pool)->ptr)[-1])
+#define poolDiscard(pool) ((pool)->ptr = (pool)->start)
+#define poolFinish(pool) ((pool)->start = (pool)->ptr)
+#define poolAppendChar(pool, c)                                                \
+  (((pool)->ptr == (pool)->end && ! poolGrow(pool))                            \
+       ? 0                                                                     \
+       : ((*((pool)->ptr)++ = c), 1))
+
+struct XML_ParserStruct {
+  /* The first member must be m_userData so that the XML_GetUserData
+     macro works. */
+  void *m_userData;
+  void *m_handlerArg;
+  char *m_buffer;
+  const XML_Memory_Handling_Suite m_mem;
+  /* first character to be parsed */
+  const char *m_bufferPtr;
+  /* past last character to be parsed */
+  char *m_bufferEnd;
+  /* allocated end of m_buffer */
+  const char *m_bufferLim;
+  XML_Index m_parseEndByteIndex;
+  const char *m_parseEndPtr;
+  XML_Char *m_dataBuf;
+  XML_Char *m_dataBufEnd;
+  XML_StartElementHandler m_startElementHandler;
+  XML_EndElementHandler m_endElementHandler;
+  XML_CharacterDataHandler m_characterDataHandler;
+  XML_ProcessingInstructionHandler m_processingInstructionHandler;
+  XML_CommentHandler m_commentHandler;
+  XML_StartCdataSectionHandler m_startCdataSectionHandler;
+  XML_EndCdataSectionHandler m_endCdataSectionHandler;
+  XML_DefaultHandler m_defaultHandler;
+  XML_StartDoctypeDeclHandler m_startDoctypeDeclHandler;
+  XML_EndDoctypeDeclHandler m_endDoctypeDeclHandler;
+  XML_UnparsedEntityDeclHandler m_unparsedEntityDeclHandler;
+  XML_NotationDeclHandler m_notationDeclHandler;
+  XML_StartNamespaceDeclHandler m_startNamespaceDeclHandler;
+  XML_EndNamespaceDeclHandler m_endNamespaceDeclHandler;
+  XML_NotStandaloneHandler m_notStandaloneHandler;
+  XML_ExternalEntityRefHandler m_externalEntityRefHandler;
+  XML_Parser m_externalEntityRefHandlerArg;
+  XML_SkippedEntityHandler m_skippedEntityHandler;
+  XML_UnknownEncodingHandler m_unknownEncodingHandler;
+  XML_ElementDeclHandler m_elementDeclHandler;
+  XML_AttlistDeclHandler m_attlistDeclHandler;
+  XML_EntityDeclHandler m_entityDeclHandler;
+  XML_XmlDeclHandler m_xmlDeclHandler;
+  const ENCODING *m_encoding;
+  INIT_ENCODING m_initEncoding;
+  const ENCODING *m_internalEncoding;
+  const XML_Char *m_protocolEncodingName;
+  XML_Bool m_ns;
+  XML_Bool m_ns_triplets;
+  void *m_unknownEncodingMem;
+  void *m_unknownEncodingData;
+  void *m_unknownEncodingHandlerData;
+  void(XMLCALL *m_unknownEncodingRelease)(void *);
+  PROLOG_STATE m_prologState;
+  Processor *m_processor;
+  enum XML_Error m_errorCode;
+  const char *m_eventPtr;
+  const char *m_eventEndPtr;
+  const char *m_positionPtr;
+  OPEN_INTERNAL_ENTITY *m_openInternalEntities;
+  OPEN_INTERNAL_ENTITY *m_freeInternalEntities;
+  XML_Bool m_defaultExpandInternalEntities;
+  int m_tagLevel;
+  ENTITY *m_declEntity;
+  const XML_Char *m_doctypeName;
+  const XML_Char *m_doctypeSysid;
+  const XML_Char *m_doctypePubid;
+  const XML_Char *m_declAttributeType;
+  const XML_Char *m_declNotationName;
+  const XML_Char *m_declNotationPublicId;
+  ELEMENT_TYPE *m_declElementType;
+  ATTRIBUTE_ID *m_declAttributeId;
+  XML_Bool m_declAttributeIsCdata;
+  XML_Bool m_declAttributeIsId;
+  DTD *m_dtd;
+  const XML_Char *m_curBase;
+  TAG *m_tagStack;
+  TAG *m_freeTagList;
+  BINDING *m_inheritedBindings;
+  BINDING *m_freeBindingList;
+  int m_attsSize;
+  int m_nSpecifiedAtts;
+  int m_idAttIndex;
+  ATTRIBUTE *m_atts;
+  NS_ATT *m_nsAtts;
+  unsigned long m_nsAttsVersion;
+  unsigned char m_nsAttsPower;
+#ifdef XML_ATTR_INFO
+  XML_AttrInfo *m_attInfo;
+#endif
+  POSITION m_position;
+  STRING_POOL m_tempPool;
+  STRING_POOL m_temp2Pool;
+  char *m_groupConnector;
+  unsigned int m_groupSize;
+  XML_Char m_namespaceSeparator;
+  XML_Parser m_parentParser;
+  XML_ParsingStatus m_parsingStatus;
+#ifdef XML_DTD
+  XML_Bool m_isParamEntity;
+  XML_Bool m_useForeignDTD;
+  enum XML_ParamEntityParsing m_paramEntityParsing;
+#endif
+  unsigned long m_hash_secret_salt;
+#ifdef XML_DTD
+  ACCOUNTING m_accounting;
+  ENTITY_STATS m_entity_stats;
+#endif
+};
+
+#define MALLOC(parser, s) (parser->m_mem.malloc_fcn((s)))
+#define REALLOC(parser, p, s) (parser->m_mem.realloc_fcn((p), (s)))
+#define FREE(parser, p) (parser->m_mem.free_fcn((p)))
+
+XML_Parser XMLCALL
+XML_ParserCreate(const XML_Char *encodingName) {
+  return XML_ParserCreate_MM(encodingName, NULL, NULL);
+}
+
+XML_Parser XMLCALL
+XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep) {
+  XML_Char tmp[2] = {nsSep, 0};
+  return XML_ParserCreate_MM(encodingName, NULL, tmp);
+}
+
+// "xml=http://www.w3.org/XML/1998/namespace"
+static const XML_Char implicitContext[]
+    = {ASCII_x,     ASCII_m,     ASCII_l,      ASCII_EQUALS, ASCII_h,
+       ASCII_t,     ASCII_t,     ASCII_p,      ASCII_COLON,  ASCII_SLASH,
+       ASCII_SLASH, ASCII_w,     ASCII_w,      ASCII_w,      ASCII_PERIOD,
+       ASCII_w,     ASCII_3,     ASCII_PERIOD, ASCII_o,      ASCII_r,
+       ASCII_g,     ASCII_SLASH, ASCII_X,      ASCII_M,      ASCII_L,
+       ASCII_SLASH, ASCII_1,     ASCII_9,      ASCII_9,      ASCII_8,
+       ASCII_SLASH, ASCII_n,     ASCII_a,      ASCII_m,      ASCII_e,
+       ASCII_s,     ASCII_p,     ASCII_a,      ASCII_c,      ASCII_e,
+       '\0'};
+
+
+#if ! defined(EXPAT_POCO)
+
+/* To avoid warnings about unused functions: */
+#if ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM)
+
+#  if defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)
+
+/* Obtain entropy on Linux 3.17+ */
+static int
+writeRandomBytes_getrandom_nonblock(void *target, size_t count) {
+  int success = 0; /* full count bytes written? */
+  size_t bytesWrittenTotal = 0;
+  const unsigned int getrandomFlags = GRND_NONBLOCK;
+
+  do {
+    void *const currentTarget = (void *)((char *)target + bytesWrittenTotal);
+    const size_t bytesToWrite = count - bytesWrittenTotal;
+
+    const int bytesWrittenMore =
+#    if defined(HAVE_GETRANDOM)
+        getrandom(currentTarget, bytesToWrite, getrandomFlags);
+#    else
+        syscall(SYS_getrandom, currentTarget, bytesToWrite, getrandomFlags);
+#    endif
+
+    if (bytesWrittenMore > 0) {
+      bytesWrittenTotal += bytesWrittenMore;
+      if (bytesWrittenTotal >= count)
+        success = 1;
+    }
+  } while (! success && (errno == EINTR));
+
+  return success;
+}
+
+#  endif /* defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM) */
+
+#  if ! defined(_WIN32) && defined(XML_DEV_URANDOM)
+
+/* Extract entropy from /dev/urandom */
+static int
+writeRandomBytes_dev_urandom(void *target, size_t count) {
+  int success = 0; /* full count bytes written? */
+  size_t bytesWrittenTotal = 0;
+
+  const int fd = open("/dev/urandom", O_RDONLY);
+  if (fd < 0) {
+    return 0;
+  }
+
+  do {
+    void *const currentTarget = (void *)((char *)target + bytesWrittenTotal);
+    const size_t bytesToWrite = count - bytesWrittenTotal;
+
+    const ssize_t bytesWrittenMore = read(fd, currentTarget, bytesToWrite);
+
+    if (bytesWrittenMore > 0) {
+      bytesWrittenTotal += bytesWrittenMore;
+      if (bytesWrittenTotal >= count)
+        success = 1;
+    }
+  } while (! success && (errno == EINTR));
+
+  close(fd);
+  return success;
+}
+
+#  endif /* ! defined(_WIN32) && defined(XML_DEV_URANDOM) */
+
+#endif /* ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM) */
+
+#if defined(HAVE_ARC4RANDOM) && ! defined(HAVE_ARC4RANDOM_BUF)
+
+static void
+writeRandomBytes_arc4random(void *target, size_t count) {
+  size_t bytesWrittenTotal = 0;
+
+  while (bytesWrittenTotal < count) {
+    const uint32_t random32 = arc4random();
+    size_t i = 0;
+
+    for (; (i < sizeof(random32)) && (bytesWrittenTotal < count);
+         i++, bytesWrittenTotal++) {
+      const uint8_t random8 = (uint8_t)(random32 >> (i * 8));
+      ((uint8_t *)target)[bytesWrittenTotal] = random8;
+    }
+  }
+}
+
+#endif /* defined(HAVE_ARC4RANDOM) && ! defined(HAVE_ARC4RANDOM_BUF) */
+
+#ifdef _WIN32
+
+/* Provide declaration of rand_s() for MinGW-32 (not 64, which has it),
+   as it didn't declare it in its header prior to version 5.3.0 of its
+   runtime package (mingwrt, containing stdlib.h).  The upstream fix
+   was introduced at https://osdn.net/projects/mingw/ticket/39658 . */
+#  if defined(__MINGW32__) && defined(__MINGW32_VERSION)                       \
+      && __MINGW32_VERSION < 5003000L && ! defined(__MINGW64_VERSION_MAJOR)
+__declspec(dllimport) int rand_s(unsigned int *);
+#  endif
+
+/* Obtain entropy on Windows using the rand_s() function which
+ * generates cryptographically secure random numbers.  Internally it
+ * uses RtlGenRandom API which is present in Windows XP and later.
+ */
+static int
+writeRandomBytes_rand_s(void *target, size_t count) {
+  size_t bytesWrittenTotal = 0;
+
+  while (bytesWrittenTotal < count) {
+    unsigned int random32 = 0;
+    size_t i = 0;
+
+    if (rand_s(&random32))
+      return 0; /* failure */
+
+    for (; (i < sizeof(random32)) && (bytesWrittenTotal < count);
+         i++, bytesWrittenTotal++) {
+      const uint8_t random8 = (uint8_t)(random32 >> (i * 8));
+      ((uint8_t *)target)[bytesWrittenTotal] = random8;
+    }
+  }
+  return 1; /* success */
+}
+
+#endif /* _WIN32 */
+
+#if ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM)
+
+static unsigned long
+gather_time_entropy(void) {
+#  ifdef _WIN32
+  FILETIME ft;
+  GetSystemTimeAsFileTime(&ft); /* never fails */
+  return ft.dwHighDateTime ^ ft.dwLowDateTime;
+#  else
+  struct timeval tv;
+  int gettimeofday_res;
+
+  gettimeofday_res = gettimeofday(&tv, NULL);
+
+#    if defined(NDEBUG)
+  (void)gettimeofday_res;
+#    else
+  assert(gettimeofday_res == 0);
+#    endif /* defined(NDEBUG) */
+
+  /* Microseconds time is <20 bits entropy */
+  return tv.tv_usec;
+#  endif
+}
+
+#endif /* ! defined(HAVE_ARC4RANDOM_BUF) && ! defined(HAVE_ARC4RANDOM) */
+
+#endif /* ! defined(EXPAT_POCO) */
+
+static unsigned long
+ENTROPY_DEBUG(const char *label, unsigned long entropy) {
+  if (getDebugLevel("EXPAT_ENTROPY_DEBUG", 0) >= 1u) {
+    fprintf(stderr, "expat: Entropy: %s --> 0x%0*lx (%lu bytes)\n", label,
+            (int)sizeof(entropy) * 2, entropy, (unsigned long)sizeof(entropy));
+  }
+  return entropy;
+}
+
+static unsigned long
+generate_hash_secret_salt(XML_Parser parser) {
+  unsigned long entropy;
+  (void)parser;
+#if defined(EXPAT_POCO)
+  Poco::RandomInputStream rstr;
+  Poco::BinaryReader rrdr(rstr);
+  rrdr >> entropy;
+  return ENTROPY_DEBUG("RandomInputStream", entropy);
+#else
+  /* "Failproof" high quality providers: */
+#if defined(HAVE_ARC4RANDOM_BUF)
+  arc4random_buf(&entropy, sizeof(entropy));
+  return ENTROPY_DEBUG("arc4random_buf", entropy);
+#elif defined(HAVE_ARC4RANDOM)
+  writeRandomBytes_arc4random((void *)&entropy, sizeof(entropy));
+  return ENTROPY_DEBUG("arc4random", entropy);
+#else
+  /* Try high quality providers first .. */
+#  ifdef _WIN32
+  if (writeRandomBytes_rand_s((void *)&entropy, sizeof(entropy))) {
+    return ENTROPY_DEBUG("rand_s", entropy);
+  }
+#  elif defined(HAVE_GETRANDOM) || defined(HAVE_SYSCALL_GETRANDOM)
+  if (writeRandomBytes_getrandom_nonblock((void *)&entropy, sizeof(entropy))) {
+    return ENTROPY_DEBUG("getrandom", entropy);
+  }
+#  endif
+#  if ! defined(_WIN32) && defined(XML_DEV_URANDOM)
+  if (writeRandomBytes_dev_urandom((void *)&entropy, sizeof(entropy))) {
+    return ENTROPY_DEBUG("/dev/urandom", entropy);
+  }
+#  endif /* ! defined(_WIN32) && defined(XML_DEV_URANDOM) */
+  /* .. and self-made low quality for backup: */
+
+  /* Process ID is 0 bits entropy if attacker has local access */
+  entropy = gather_time_entropy() ^ getpid();
+
+  /* Factors are 2^31-1 and 2^61-1 (Mersenne primes M31 and M61) */
+  if (sizeof(unsigned long) == 4) {
+    return ENTROPY_DEBUG("fallback(4)", entropy * 2147483647);
+  } else {
+    return ENTROPY_DEBUG("fallback(8)",
+                         entropy * (unsigned long)2305843009213693951ULL);
+  }
+#endif
+#endif /* defined(EXPAT_POCO) */
+}
+
+static unsigned long
+get_hash_secret_salt(XML_Parser parser) {
+  if (parser->m_parentParser != NULL)
+    return get_hash_secret_salt(parser->m_parentParser);
+  return parser->m_hash_secret_salt;
+}
+
+static XML_Bool /* only valid for root parser */
+startParsing(XML_Parser parser) {
+  /* hash functions must be initialized before setContext() is called */
+  if (parser->m_hash_secret_salt == 0)
+    parser->m_hash_secret_salt = generate_hash_secret_salt(parser);
+  if (parser->m_ns) {
+    /* implicit context only set for root parser, since child
+       parsers (i.e. external entity parsers) will inherit it
+    */
+    return setContext(parser, implicitContext);
+  }
+  return XML_TRUE;
+}
+
+XML_Parser XMLCALL
+XML_ParserCreate_MM(const XML_Char *encodingName,
+                    const XML_Memory_Handling_Suite *memsuite,
+                    const XML_Char *nameSep) {
+  return parserCreate(encodingName, memsuite, nameSep, NULL);
+}
+
+static XML_Parser
+parserCreate(const XML_Char *encodingName,
+             const XML_Memory_Handling_Suite *memsuite, const XML_Char *nameSep,
+             DTD *dtd) {
+  XML_Parser parser;
+
+  if (memsuite) {
+    XML_Memory_Handling_Suite *mtemp;
+    parser = (XML_Parser)memsuite->malloc_fcn(sizeof(struct XML_ParserStruct));
+    if (parser != NULL) {
+      mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
+      mtemp->malloc_fcn = memsuite->malloc_fcn;
+      mtemp->realloc_fcn = memsuite->realloc_fcn;
+      mtemp->free_fcn = memsuite->free_fcn;
+    }
+  } else {
+    XML_Memory_Handling_Suite *mtemp;
+    parser = (XML_Parser)malloc(sizeof(struct XML_ParserStruct));
+    if (parser != NULL) {
+      mtemp = (XML_Memory_Handling_Suite *)&(parser->m_mem);
+      mtemp->malloc_fcn = malloc;
+      mtemp->realloc_fcn = realloc;
+      mtemp->free_fcn = free;
+    }
+  }
+
+  if (! parser)
+    return parser;
+
+  parser->m_buffer = NULL;
+  parser->m_bufferLim = NULL;
+
+  parser->m_attsSize = INIT_ATTS_SIZE;
+  parser->m_atts
+      = (ATTRIBUTE *)MALLOC(parser, parser->m_attsSize * sizeof(ATTRIBUTE));
+  if (parser->m_atts == NULL) {
+    FREE(parser, parser);
+    return NULL;
+  }
+#ifdef XML_ATTR_INFO
+  parser->m_attInfo = (XML_AttrInfo *)MALLOC(
+      parser, parser->m_attsSize * sizeof(XML_AttrInfo));
+  if (parser->m_attInfo == NULL) {
+    FREE(parser, parser->m_atts);
+    FREE(parser, parser);
+    return NULL;
+  }
+#endif
+  parser->m_dataBuf
+      = (XML_Char *)MALLOC(parser, INIT_DATA_BUF_SIZE * sizeof(XML_Char));
+  if (parser->m_dataBuf == NULL) {
+    FREE(parser, parser->m_atts);
+#ifdef XML_ATTR_INFO
+    FREE(parser, parser->m_attInfo);
+#endif
+    FREE(parser, parser);
+    return NULL;
+  }
+  parser->m_dataBufEnd = parser->m_dataBuf + INIT_DATA_BUF_SIZE;
+
+  if (dtd)
+    parser->m_dtd = dtd;
+  else {
+    parser->m_dtd = dtdCreate(&parser->m_mem);
+    if (parser->m_dtd == NULL) {
+      FREE(parser, parser->m_dataBuf);
+      FREE(parser, parser->m_atts);
+#ifdef XML_ATTR_INFO
+      FREE(parser, parser->m_attInfo);
+#endif
+      FREE(parser, parser);
+      return NULL;
+    }
+  }
+
+  parser->m_freeBindingList = NULL;
+  parser->m_freeTagList = NULL;
+  parser->m_freeInternalEntities = NULL;
+
+  parser->m_groupSize = 0;
+  parser->m_groupConnector = NULL;
+
+  parser->m_unknownEncodingHandler = NULL;
+  parser->m_unknownEncodingHandlerData = NULL;
+
+  parser->m_namespaceSeparator = ASCII_EXCL;
+  parser->m_ns = XML_FALSE;
+  parser->m_ns_triplets = XML_FALSE;
+
+  parser->m_nsAtts = NULL;
+  parser->m_nsAttsVersion = 0;
+  parser->m_nsAttsPower = 0;
+
+  parser->m_protocolEncodingName = NULL;
+
+  poolInit(&parser->m_tempPool, &(parser->m_mem));
+  poolInit(&parser->m_temp2Pool, &(parser->m_mem));
+  parserInit(parser, encodingName);
+
+  if (encodingName && ! parser->m_protocolEncodingName) {
+    XML_ParserFree(parser);
+    return NULL;
+  }
+
+  if (nameSep) {
+    parser->m_ns = XML_TRUE;
+    parser->m_internalEncoding = XmlGetInternalEncodingNS();
+    parser->m_namespaceSeparator = *nameSep;
+  } else {
+    parser->m_internalEncoding = XmlGetInternalEncoding();
+  }
+
+  return parser;
+}
+
+static void
+parserInit(XML_Parser parser, const XML_Char *encodingName) {
+  parser->m_processor = prologInitProcessor;
+  XmlPrologStateInit(&parser->m_prologState);
+  if (encodingName != NULL) {
+    parser->m_protocolEncodingName = copyString(encodingName, &(parser->m_mem));
+  }
+  parser->m_curBase = NULL;
+  XmlInitEncoding(&parser->m_initEncoding, &parser->m_encoding, 0);
+  parser->m_userData = NULL;
+  parser->m_handlerArg = NULL;
+  parser->m_startElementHandler = NULL;
+  parser->m_endElementHandler = NULL;
+  parser->m_characterDataHandler = NULL;
+  parser->m_processingInstructionHandler = NULL;
+  parser->m_commentHandler = NULL;
+  parser->m_startCdataSectionHandler = NULL;
+  parser->m_endCdataSectionHandler = NULL;
+  parser->m_defaultHandler = NULL;
+  parser->m_startDoctypeDeclHandler = NULL;
+  parser->m_endDoctypeDeclHandler = NULL;
+  parser->m_unparsedEntityDeclHandler = NULL;
+  parser->m_notationDeclHandler = NULL;
+  parser->m_startNamespaceDeclHandler = NULL;
+  parser->m_endNamespaceDeclHandler = NULL;
+  parser->m_notStandaloneHandler = NULL;
+  parser->m_externalEntityRefHandler = NULL;
+  parser->m_externalEntityRefHandlerArg = parser;
+  parser->m_skippedEntityHandler = NULL;
+  parser->m_elementDeclHandler = NULL;
+  parser->m_attlistDeclHandler = NULL;
+  parser->m_entityDeclHandler = NULL;
+  parser->m_xmlDeclHandler = NULL;
+  parser->m_bufferPtr = parser->m_buffer;
+  parser->m_bufferEnd = parser->m_buffer;
+  parser->m_parseEndByteIndex = 0;
+  parser->m_parseEndPtr = NULL;
+  parser->m_declElementType = NULL;
+  parser->m_declAttributeId = NULL;
+  parser->m_declEntity = NULL;
+  parser->m_doctypeName = NULL;
+  parser->m_doctypeSysid = NULL;
+  parser->m_doctypePubid = NULL;
+  parser->m_declAttributeType = NULL;
+  parser->m_declNotationName = NULL;
+  parser->m_declNotationPublicId = NULL;
+  parser->m_declAttributeIsCdata = XML_FALSE;
+  parser->m_declAttributeIsId = XML_FALSE;
+  memset(&parser->m_position, 0, sizeof(POSITION));
+  parser->m_errorCode = XML_ERROR_NONE;
+  parser->m_eventPtr = NULL;
+  parser->m_eventEndPtr = NULL;
+  parser->m_positionPtr = NULL;
+  parser->m_openInternalEntities = NULL;
+  parser->m_defaultExpandInternalEntities = XML_TRUE;
+  parser->m_tagLevel = 0;
+  parser->m_tagStack = NULL;
+  parser->m_inheritedBindings = NULL;
+  parser->m_nSpecifiedAtts = 0;
+  parser->m_unknownEncodingMem = NULL;
+  parser->m_unknownEncodingRelease = NULL;
+  parser->m_unknownEncodingData = NULL;
+  parser->m_parentParser = NULL;
+  parser->m_parsingStatus.parsing = XML_INITIALIZED;
+#ifdef XML_DTD
+  parser->m_isParamEntity = XML_FALSE;
+  parser->m_useForeignDTD = XML_FALSE;
+  parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
+#endif
+  parser->m_hash_secret_salt = 0;
+
+#ifdef XML_DTD
+  memset(&parser->m_accounting, 0, sizeof(ACCOUNTING));
+  parser->m_accounting.debugLevel = getDebugLevel("EXPAT_ACCOUNTING_DEBUG", 0u);
+  parser->m_accounting.maximumAmplificationFactor
+      = EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT;
+  parser->m_accounting.activationThresholdBytes
+      = EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT;
+
+  memset(&parser->m_entity_stats, 0, sizeof(ENTITY_STATS));
+  parser->m_entity_stats.debugLevel = getDebugLevel("EXPAT_ENTITY_DEBUG", 0u);
+#endif
+}
+
+/* moves list of bindings to m_freeBindingList */
+static void FASTCALL
+moveToFreeBindingList(XML_Parser parser, BINDING *bindings) {
+  while (bindings) {
+    BINDING *b = bindings;
+    bindings = bindings->nextTagBinding;
+    b->nextTagBinding = parser->m_freeBindingList;
+    parser->m_freeBindingList = b;
+  }
+}
+
+XML_Bool XMLCALL
+XML_ParserReset(XML_Parser parser, const XML_Char *encodingName) {
+  TAG *tStk;
+  OPEN_INTERNAL_ENTITY *openEntityList;
+
+  if (parser == NULL)
+    return XML_FALSE;
+
+  if (parser->m_parentParser)
+    return XML_FALSE;
+  /* move m_tagStack to m_freeTagList */
+  tStk = parser->m_tagStack;
+  while (tStk) {
+    TAG *tag = tStk;
+    tStk = tStk->parent;
+    tag->parent = parser->m_freeTagList;
+    moveToFreeBindingList(parser, tag->bindings);
+    tag->bindings = NULL;
+    parser->m_freeTagList = tag;
+  }
+  /* move m_openInternalEntities to m_freeInternalEntities */
+  openEntityList = parser->m_openInternalEntities;
+  while (openEntityList) {
+    OPEN_INTERNAL_ENTITY *openEntity = openEntityList;
+    openEntityList = openEntity->next;
+    openEntity->next = parser->m_freeInternalEntities;
+    parser->m_freeInternalEntities = openEntity;
+  }
+  moveToFreeBindingList(parser, parser->m_inheritedBindings);
+  FREE(parser, parser->m_unknownEncodingMem);
+  if (parser->m_unknownEncodingRelease)
+    parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);
+  poolClear(&parser->m_tempPool);
+  poolClear(&parser->m_temp2Pool);
+  FREE(parser, (void *)parser->m_protocolEncodingName);
+  parser->m_protocolEncodingName = NULL;
+  parserInit(parser, encodingName);
+  dtdReset(parser->m_dtd, &parser->m_mem);
+  return XML_TRUE;
+}
+
+enum XML_Status XMLCALL
+XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName) {
+  if (parser == NULL)
+    return XML_STATUS_ERROR;
+  /* Block after XML_Parse()/XML_ParseBuffer() has been called.
+     XXX There's no way for the caller to determine which of the
+     XXX possible error cases caused the XML_STATUS_ERROR return.
+  */
+  if (parser->m_parsingStatus.parsing == XML_PARSING
+      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
+    return XML_STATUS_ERROR;
+
+  /* Get rid of any previous encoding name */
+  FREE(parser, (void *)parser->m_protocolEncodingName);
+
+  if (encodingName == NULL)
+    /* No new encoding name */
+    parser->m_protocolEncodingName = NULL;
+  else {
+    /* Copy the new encoding name into allocated memory */
+    parser->m_protocolEncodingName = copyString(encodingName, &(parser->m_mem));
+    if (! parser->m_protocolEncodingName)
+      return XML_STATUS_ERROR;
+  }
+  return XML_STATUS_OK;
+}
+
+XML_Parser XMLCALL
+XML_ExternalEntityParserCreate(XML_Parser oldParser, const XML_Char *context,
+                               const XML_Char *encodingName) {
+  XML_Parser parser = oldParser;
+  DTD *newDtd = NULL;
+  DTD *oldDtd;
+  XML_StartElementHandler oldStartElementHandler;
+  XML_EndElementHandler oldEndElementHandler;
+  XML_CharacterDataHandler oldCharacterDataHandler;
+  XML_ProcessingInstructionHandler oldProcessingInstructionHandler;
+  XML_CommentHandler oldCommentHandler;
+  XML_StartCdataSectionHandler oldStartCdataSectionHandler;
+  XML_EndCdataSectionHandler oldEndCdataSectionHandler;
+  XML_DefaultHandler oldDefaultHandler;
+  XML_UnparsedEntityDeclHandler oldUnparsedEntityDeclHandler;
+  XML_NotationDeclHandler oldNotationDeclHandler;
+  XML_StartNamespaceDeclHandler oldStartNamespaceDeclHandler;
+  XML_EndNamespaceDeclHandler oldEndNamespaceDeclHandler;
+  XML_NotStandaloneHandler oldNotStandaloneHandler;
+  XML_ExternalEntityRefHandler oldExternalEntityRefHandler;
+  XML_SkippedEntityHandler oldSkippedEntityHandler;
+  XML_UnknownEncodingHandler oldUnknownEncodingHandler;
+  XML_ElementDeclHandler oldElementDeclHandler;
+  XML_AttlistDeclHandler oldAttlistDeclHandler;
+  XML_EntityDeclHandler oldEntityDeclHandler;
+  XML_XmlDeclHandler oldXmlDeclHandler;
+  ELEMENT_TYPE *oldDeclElementType;
+
+  void *oldUserData;
+  void *oldHandlerArg;
+  XML_Bool oldDefaultExpandInternalEntities;
+  XML_Parser oldExternalEntityRefHandlerArg;
+#ifdef XML_DTD
+  enum XML_ParamEntityParsing oldParamEntityParsing;
+  int oldInEntityValue;
+#endif
+  XML_Bool oldns_triplets;
+  /* Note that the new parser shares the same hash secret as the old
+     parser, so that dtdCopy and copyEntityTable can lookup values
+     from hash tables associated with either parser without us having
+     to worry which hash secrets each table has.
+  */
+  unsigned long oldhash_secret_salt;
+
+  /* Validate the oldParser parameter before we pull everything out of it */
+  if (oldParser == NULL)
+    return NULL;
+
+  /* Stash the original parser contents on the stack */
+  oldDtd = parser->m_dtd;
+  oldStartElementHandler = parser->m_startElementHandler;
+  oldEndElementHandler = parser->m_endElementHandler;
+  oldCharacterDataHandler = parser->m_characterDataHandler;
+  oldProcessingInstructionHandler = parser->m_processingInstructionHandler;
+  oldCommentHandler = parser->m_commentHandler;
+  oldStartCdataSectionHandler = parser->m_startCdataSectionHandler;
+  oldEndCdataSectionHandler = parser->m_endCdataSectionHandler;
+  oldDefaultHandler = parser->m_defaultHandler;
+  oldUnparsedEntityDeclHandler = parser->m_unparsedEntityDeclHandler;
+  oldNotationDeclHandler = parser->m_notationDeclHandler;
+  oldStartNamespaceDeclHandler = parser->m_startNamespaceDeclHandler;
+  oldEndNamespaceDeclHandler = parser->m_endNamespaceDeclHandler;
+  oldNotStandaloneHandler = parser->m_notStandaloneHandler;
+  oldExternalEntityRefHandler = parser->m_externalEntityRefHandler;
+  oldSkippedEntityHandler = parser->m_skippedEntityHandler;
+  oldUnknownEncodingHandler = parser->m_unknownEncodingHandler;
+  oldElementDeclHandler = parser->m_elementDeclHandler;
+  oldAttlistDeclHandler = parser->m_attlistDeclHandler;
+  oldEntityDeclHandler = parser->m_entityDeclHandler;
+  oldXmlDeclHandler = parser->m_xmlDeclHandler;
+  oldDeclElementType = parser->m_declElementType;
+
+  oldUserData = parser->m_userData;
+  oldHandlerArg = parser->m_handlerArg;
+  oldDefaultExpandInternalEntities = parser->m_defaultExpandInternalEntities;
+  oldExternalEntityRefHandlerArg = parser->m_externalEntityRefHandlerArg;
+#ifdef XML_DTD
+  oldParamEntityParsing = parser->m_paramEntityParsing;
+  oldInEntityValue = parser->m_prologState.inEntityValue;
+#endif
+  oldns_triplets = parser->m_ns_triplets;
+  /* Note that the new parser shares the same hash secret as the old
+     parser, so that dtdCopy and copyEntityTable can lookup values
+     from hash tables associated with either parser without us having
+     to worry which hash secrets each table has.
+  */
+  oldhash_secret_salt = parser->m_hash_secret_salt;
+
+#ifdef XML_DTD
+  if (! context)
+    newDtd = oldDtd;
+#endif /* XML_DTD */
+
+  /* Note that the magical uses of the pre-processor to make field
+     access look more like C++ require that `parser' be overwritten
+     here.  This makes this function more painful to follow than it
+     would be otherwise.
+  */
+  if (parser->m_ns) {
+    XML_Char tmp[2] = {parser->m_namespaceSeparator, 0};
+    parser = parserCreate(encodingName, &parser->m_mem, tmp, newDtd);
+  } else {
+    parser = parserCreate(encodingName, &parser->m_mem, NULL, newDtd);
+  }
+
+  if (! parser)
+    return NULL;
+
+  parser->m_startElementHandler = oldStartElementHandler;
+  parser->m_endElementHandler = oldEndElementHandler;
+  parser->m_characterDataHandler = oldCharacterDataHandler;
+  parser->m_processingInstructionHandler = oldProcessingInstructionHandler;
+  parser->m_commentHandler = oldCommentHandler;
+  parser->m_startCdataSectionHandler = oldStartCdataSectionHandler;
+  parser->m_endCdataSectionHandler = oldEndCdataSectionHandler;
+  parser->m_defaultHandler = oldDefaultHandler;
+  parser->m_unparsedEntityDeclHandler = oldUnparsedEntityDeclHandler;
+  parser->m_notationDeclHandler = oldNotationDeclHandler;
+  parser->m_startNamespaceDeclHandler = oldStartNamespaceDeclHandler;
+  parser->m_endNamespaceDeclHandler = oldEndNamespaceDeclHandler;
+  parser->m_notStandaloneHandler = oldNotStandaloneHandler;
+  parser->m_externalEntityRefHandler = oldExternalEntityRefHandler;
+  parser->m_skippedEntityHandler = oldSkippedEntityHandler;
+  parser->m_unknownEncodingHandler = oldUnknownEncodingHandler;
+  parser->m_elementDeclHandler = oldElementDeclHandler;
+  parser->m_attlistDeclHandler = oldAttlistDeclHandler;
+  parser->m_entityDeclHandler = oldEntityDeclHandler;
+  parser->m_xmlDeclHandler = oldXmlDeclHandler;
+  parser->m_declElementType = oldDeclElementType;
+  parser->m_userData = oldUserData;
+  if (oldUserData == oldHandlerArg)
+    parser->m_handlerArg = parser->m_userData;
+  else
+    parser->m_handlerArg = parser;
+  if (oldExternalEntityRefHandlerArg != oldParser)
+    parser->m_externalEntityRefHandlerArg = oldExternalEntityRefHandlerArg;
+  parser->m_defaultExpandInternalEntities = oldDefaultExpandInternalEntities;
+  parser->m_ns_triplets = oldns_triplets;
+  parser->m_hash_secret_salt = oldhash_secret_salt;
+  parser->m_parentParser = oldParser;
+#ifdef XML_DTD
+  parser->m_paramEntityParsing = oldParamEntityParsing;
+  parser->m_prologState.inEntityValue = oldInEntityValue;
+  if (context) {
+#endif /* XML_DTD */
+    if (! dtdCopy(oldParser, parser->m_dtd, oldDtd, &parser->m_mem)
+        || ! setContext(parser, context)) {
+      XML_ParserFree(parser);
+      return NULL;
+    }
+    parser->m_processor = externalEntityInitProcessor;
+#ifdef XML_DTD
+  } else {
+    /* The DTD instance referenced by parser->m_dtd is shared between the
+       document's root parser and external PE parsers, therefore one does not
+       need to call setContext. In addition, one also *must* not call
+       setContext, because this would overwrite existing prefix->binding
+       pointers in parser->m_dtd with ones that get destroyed with the external
+       PE parser. This would leave those prefixes with dangling pointers.
+    */
+    parser->m_isParamEntity = XML_TRUE;
+    XmlPrologStateInitExternalEntity(&parser->m_prologState);
+    parser->m_processor = externalParEntInitProcessor;
+  }
+#endif /* XML_DTD */
+  return parser;
+}
+
+static void FASTCALL
+destroyBindings(BINDING *bindings, XML_Parser parser) {
+  for (;;) {
+    BINDING *b = bindings;
+    if (! b)
+      break;
+    bindings = b->nextTagBinding;
+    FREE(parser, b->uri);
+    FREE(parser, b);
+  }
+}
+
+void XMLCALL
+XML_ParserFree(XML_Parser parser) {
+  TAG *tagList;
+  OPEN_INTERNAL_ENTITY *entityList;
+  if (parser == NULL)
+    return;
+  /* free m_tagStack and m_freeTagList */
+  tagList = parser->m_tagStack;
+  for (;;) {
+    TAG *p;
+    if (tagList == NULL) {
+      if (parser->m_freeTagList == NULL)
+        break;
+      tagList = parser->m_freeTagList;
+      parser->m_freeTagList = NULL;
+    }
+    p = tagList;
+    tagList = tagList->parent;
+    FREE(parser, p->buf);
+    destroyBindings(p->bindings, parser);
+    FREE(parser, p);
+  }
+  /* free m_openInternalEntities and m_freeInternalEntities */
+  entityList = parser->m_openInternalEntities;
+  for (;;) {
+    OPEN_INTERNAL_ENTITY *openEntity;
+    if (entityList == NULL) {
+      if (parser->m_freeInternalEntities == NULL)
+        break;
+      entityList = parser->m_freeInternalEntities;
+      parser->m_freeInternalEntities = NULL;
+    }
+    openEntity = entityList;
+    entityList = entityList->next;
+    FREE(parser, openEntity);
+  }
+
+  destroyBindings(parser->m_freeBindingList, parser);
+  destroyBindings(parser->m_inheritedBindings, parser);
+  poolDestroy(&parser->m_tempPool);
+  poolDestroy(&parser->m_temp2Pool);
+  FREE(parser, (void *)parser->m_protocolEncodingName);
+#ifdef XML_DTD
+  /* external parameter entity parsers share the DTD structure
+     parser->m_dtd with the root parser, so we must not destroy it
+  */
+  if (! parser->m_isParamEntity && parser->m_dtd)
+#else
+  if (parser->m_dtd)
+#endif /* XML_DTD */
+    dtdDestroy(parser->m_dtd, (XML_Bool)! parser->m_parentParser,
+               &parser->m_mem);
+  FREE(parser, (void *)parser->m_atts);
+#ifdef XML_ATTR_INFO
+  FREE(parser, (void *)parser->m_attInfo);
+#endif
+  FREE(parser, parser->m_groupConnector);
+  FREE(parser, parser->m_buffer);
+  FREE(parser, parser->m_dataBuf);
+  FREE(parser, parser->m_nsAtts);
+  FREE(parser, parser->m_unknownEncodingMem);
+  if (parser->m_unknownEncodingRelease)
+    parser->m_unknownEncodingRelease(parser->m_unknownEncodingData);
+  FREE(parser, parser);
+}
+
+void XMLCALL
+XML_UseParserAsHandlerArg(XML_Parser parser) {
+  if (parser != NULL)
+    parser->m_handlerArg = parser;
+}
+
+enum XML_Error XMLCALL
+XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD) {
+  if (parser == NULL)
+    return XML_ERROR_INVALID_ARGUMENT;
+#ifdef XML_DTD
+  /* block after XML_Parse()/XML_ParseBuffer() has been called */
+  if (parser->m_parsingStatus.parsing == XML_PARSING
+      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
+    return XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING;
+  parser->m_useForeignDTD = useDTD;
+  return XML_ERROR_NONE;
+#else
+  UNUSED_P(useDTD);
+  return XML_ERROR_FEATURE_REQUIRES_XML_DTD;
+#endif
+}
+
+void XMLCALL
+XML_SetReturnNSTriplet(XML_Parser parser, int do_nst) {
+  if (parser == NULL)
+    return;
+  /* block after XML_Parse()/XML_ParseBuffer() has been called */
+  if (parser->m_parsingStatus.parsing == XML_PARSING
+      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
+    return;
+  parser->m_ns_triplets = do_nst ? XML_TRUE : XML_FALSE;
+}
+
+void XMLCALL
+XML_SetUserData(XML_Parser parser, void *p) {
+  if (parser == NULL)
+    return;
+  if (parser->m_handlerArg == parser->m_userData)
+    parser->m_handlerArg = parser->m_userData = p;
+  else
+    parser->m_userData = p;
+}
+
+enum XML_Status XMLCALL
+XML_SetBase(XML_Parser parser, const XML_Char *p) {
+  if (parser == NULL)
+    return XML_STATUS_ERROR;
+  if (p) {
+    p = poolCopyString(&parser->m_dtd->pool, p);
+    if (! p)
+      return XML_STATUS_ERROR;
+    parser->m_curBase = p;
+  } else
+    parser->m_curBase = NULL;
+  return XML_STATUS_OK;
+}
+
+const XML_Char *XMLCALL
+XML_GetBase(XML_Parser parser) {
+  if (parser == NULL)
+    return NULL;
+  return parser->m_curBase;
+}
+
+int XMLCALL
+XML_GetSpecifiedAttributeCount(XML_Parser parser) {
+  if (parser == NULL)
+    return -1;
+  return parser->m_nSpecifiedAtts;
+}
+
+int XMLCALL
+XML_GetIdAttributeIndex(XML_Parser parser) {
+  if (parser == NULL)
+    return -1;
+  return parser->m_idAttIndex;
+}
+
+#ifdef XML_ATTR_INFO
+const XML_AttrInfo *XMLCALL
+XML_GetAttributeInfo(XML_Parser parser) {
+  if (parser == NULL)
+    return NULL;
+  return parser->m_attInfo;
+}
+#endif
+
+void XMLCALL
+XML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start,
+                      XML_EndElementHandler end) {
+  if (parser == NULL)
+    return;
+  parser->m_startElementHandler = start;
+  parser->m_endElementHandler = end;
+}
+
+void XMLCALL
+XML_SetStartElementHandler(XML_Parser parser, XML_StartElementHandler start) {
+  if (parser != NULL)
+    parser->m_startElementHandler = start;
+}
+
+void XMLCALL
+XML_SetEndElementHandler(XML_Parser parser, XML_EndElementHandler end) {
+  if (parser != NULL)
+    parser->m_endElementHandler = end;
+}
+
+void XMLCALL
+XML_SetCharacterDataHandler(XML_Parser parser,
+                            XML_CharacterDataHandler handler) {
+  if (parser != NULL)
+    parser->m_characterDataHandler = handler;
+}
+
+void XMLCALL
+XML_SetProcessingInstructionHandler(XML_Parser parser,
+                                    XML_ProcessingInstructionHandler handler) {
+  if (parser != NULL)
+    parser->m_processingInstructionHandler = handler;
+}
+
+void XMLCALL
+XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler) {
+  if (parser != NULL)
+    parser->m_commentHandler = handler;
+}
+
+void XMLCALL
+XML_SetCdataSectionHandler(XML_Parser parser,
+                           XML_StartCdataSectionHandler start,
+                           XML_EndCdataSectionHandler end) {
+  if (parser == NULL)
+    return;
+  parser->m_startCdataSectionHandler = start;
+  parser->m_endCdataSectionHandler = end;
+}
+
+void XMLCALL
+XML_SetStartCdataSectionHandler(XML_Parser parser,
+                                XML_StartCdataSectionHandler start) {
+  if (parser != NULL)
+    parser->m_startCdataSectionHandler = start;
+}
+
+void XMLCALL
+XML_SetEndCdataSectionHandler(XML_Parser parser,
+                              XML_EndCdataSectionHandler end) {
+  if (parser != NULL)
+    parser->m_endCdataSectionHandler = end;
+}
+
+void XMLCALL
+XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler) {
+  if (parser == NULL)
+    return;
+  parser->m_defaultHandler = handler;
+  parser->m_defaultExpandInternalEntities = XML_FALSE;
+}
+
+void XMLCALL
+XML_SetDefaultHandlerExpand(XML_Parser parser, XML_DefaultHandler handler) {
+  if (parser == NULL)
+    return;
+  parser->m_defaultHandler = handler;
+  parser->m_defaultExpandInternalEntities = XML_TRUE;
+}
+
+void XMLCALL
+XML_SetDoctypeDeclHandler(XML_Parser parser, XML_StartDoctypeDeclHandler start,
+                          XML_EndDoctypeDeclHandler end) {
+  if (parser == NULL)
+    return;
+  parser->m_startDoctypeDeclHandler = start;
+  parser->m_endDoctypeDeclHandler = end;
+}
+
+void XMLCALL
+XML_SetStartDoctypeDeclHandler(XML_Parser parser,
+                               XML_StartDoctypeDeclHandler start) {
+  if (parser != NULL)
+    parser->m_startDoctypeDeclHandler = start;
+}
+
+void XMLCALL
+XML_SetEndDoctypeDeclHandler(XML_Parser parser, XML_EndDoctypeDeclHandler end) {
+  if (parser != NULL)
+    parser->m_endDoctypeDeclHandler = end;
+}
+
+void XMLCALL
+XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
+                                 XML_UnparsedEntityDeclHandler handler) {
+  if (parser != NULL)
+    parser->m_unparsedEntityDeclHandler = handler;
+}
+
+void XMLCALL
+XML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler handler) {
+  if (parser != NULL)
+    parser->m_notationDeclHandler = handler;
+}
+
+void XMLCALL
+XML_SetNamespaceDeclHandler(XML_Parser parser,
+                            XML_StartNamespaceDeclHandler start,
+                            XML_EndNamespaceDeclHandler end) {
+  if (parser == NULL)
+    return;
+  parser->m_startNamespaceDeclHandler = start;
+  parser->m_endNamespaceDeclHandler = end;
+}
+
+void XMLCALL
+XML_SetStartNamespaceDeclHandler(XML_Parser parser,
+                                 XML_StartNamespaceDeclHandler start) {
+  if (parser != NULL)
+    parser->m_startNamespaceDeclHandler = start;
+}
+
+void XMLCALL
+XML_SetEndNamespaceDeclHandler(XML_Parser parser,
+                               XML_EndNamespaceDeclHandler end) {
+  if (parser != NULL)
+    parser->m_endNamespaceDeclHandler = end;
+}
+
+void XMLCALL
+XML_SetNotStandaloneHandler(XML_Parser parser,
+                            XML_NotStandaloneHandler handler) {
+  if (parser != NULL)
+    parser->m_notStandaloneHandler = handler;
+}
+
+void XMLCALL
+XML_SetExternalEntityRefHandler(XML_Parser parser,
+                                XML_ExternalEntityRefHandler handler) {
+  if (parser != NULL)
+    parser->m_externalEntityRefHandler = handler;
+}
+
+void XMLCALL
+XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg) {
+  if (parser == NULL)
+    return;
+  if (arg)
+    parser->m_externalEntityRefHandlerArg = (XML_Parser)arg;
+  else
+    parser->m_externalEntityRefHandlerArg = parser;
+}
+
+void XMLCALL
+XML_SetSkippedEntityHandler(XML_Parser parser,
+                            XML_SkippedEntityHandler handler) {
+  if (parser != NULL)
+    parser->m_skippedEntityHandler = handler;
+}
+
+void XMLCALL
+XML_SetUnknownEncodingHandler(XML_Parser parser,
+                              XML_UnknownEncodingHandler handler, void *data) {
+  if (parser == NULL)
+    return;
+  parser->m_unknownEncodingHandler = handler;
+  parser->m_unknownEncodingHandlerData = data;
+}
+
+void XMLCALL
+XML_SetElementDeclHandler(XML_Parser parser, XML_ElementDeclHandler eldecl) {
+  if (parser != NULL)
+    parser->m_elementDeclHandler = eldecl;
+}
+
+void XMLCALL
+XML_SetAttlistDeclHandler(XML_Parser parser, XML_AttlistDeclHandler attdecl) {
+  if (parser != NULL)
+    parser->m_attlistDeclHandler = attdecl;
+}
+
+void XMLCALL
+XML_SetEntityDeclHandler(XML_Parser parser, XML_EntityDeclHandler handler) {
+  if (parser != NULL)
+    parser->m_entityDeclHandler = handler;
+}
+
+void XMLCALL
+XML_SetXmlDeclHandler(XML_Parser parser, XML_XmlDeclHandler handler) {
+  if (parser != NULL)
+    parser->m_xmlDeclHandler = handler;
+}
+
+int XMLCALL
+XML_SetParamEntityParsing(XML_Parser parser,
+                          enum XML_ParamEntityParsing peParsing) {
+  if (parser == NULL)
+    return 0;
+  /* block after XML_Parse()/XML_ParseBuffer() has been called */
+  if (parser->m_parsingStatus.parsing == XML_PARSING
+      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
+    return 0;
+#ifdef XML_DTD
+  parser->m_paramEntityParsing = peParsing;
+  return 1;
+#else
+  return peParsing == XML_PARAM_ENTITY_PARSING_NEVER;
+#endif
+}
+
+int XMLCALL
+XML_SetHashSalt(XML_Parser parser, unsigned long hash_salt) {
+  if (parser == NULL)
+    return 0;
+  if (parser->m_parentParser)
+    return XML_SetHashSalt(parser->m_parentParser, hash_salt);
+  /* block after XML_Parse()/XML_ParseBuffer() has been called */
+  if (parser->m_parsingStatus.parsing == XML_PARSING
+      || parser->m_parsingStatus.parsing == XML_SUSPENDED)
+    return 0;
+  parser->m_hash_secret_salt = hash_salt;
+  return 1;
+}
+
+enum XML_Status XMLCALL
+XML_Parse(XML_Parser parser, const char *s, int len, int isFinal) {
+  if ((parser == NULL) || (len < 0) || ((s == NULL) && (len != 0))) {
+    if (parser != NULL)
+      parser->m_errorCode = XML_ERROR_INVALID_ARGUMENT;
+    return XML_STATUS_ERROR;
+  }
+  switch (parser->m_parsingStatus.parsing) {
+  case XML_SUSPENDED:
+    parser->m_errorCode = XML_ERROR_SUSPENDED;
+    return XML_STATUS_ERROR;
+  case XML_FINISHED:
+    parser->m_errorCode = XML_ERROR_FINISHED;
+    return XML_STATUS_ERROR;
+  case XML_INITIALIZED:
+    if (parser->m_parentParser == NULL && ! startParsing(parser)) {
+      parser->m_errorCode = XML_ERROR_NO_MEMORY;
+      return XML_STATUS_ERROR;
+    }
+    /* fall through */
+  default:
+    parser->m_parsingStatus.parsing = XML_PARSING;
+  }
+
+  if (len == 0) {
+    parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
+    if (! isFinal)
+      return XML_STATUS_OK;
+    parser->m_positionPtr = parser->m_bufferPtr;
+    parser->m_parseEndPtr = parser->m_bufferEnd;
+
+    /* If data are left over from last buffer, and we now know that these
+       data are the final chunk of input, then we have to check them again
+       to detect errors based on that fact.
+    */
+    parser->m_errorCode
+        = parser->m_processor(parser, parser->m_bufferPtr,
+                              parser->m_parseEndPtr, &parser->m_bufferPtr);
+
+    if (parser->m_errorCode == XML_ERROR_NONE) {
+      switch (parser->m_parsingStatus.parsing) {
+      case XML_SUSPENDED:
+        /* It is hard to be certain, but it seems that this case
+         * cannot occur.  This code is cleaning up a previous parse
+         * with no new data (since len == 0).  Changing the parsing
+         * state requires getting to execute a handler function, and
+         * there doesn't seem to be an opportunity for that while in
+         * this circumstance.
+         *
+         * Given the uncertainty, we retain the code but exclude it
+         * from coverage tests.
+         *
+         * LCOV_EXCL_START
+         */
+        XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
+                          parser->m_bufferPtr, &parser->m_position);
+        parser->m_positionPtr = parser->m_bufferPtr;
+        return XML_STATUS_SUSPENDED;
+        /* LCOV_EXCL_STOP */
+      case XML_INITIALIZED:
+      case XML_PARSING:
+        parser->m_parsingStatus.parsing = XML_FINISHED;
+        /* fall through */
+      default:
+        return XML_STATUS_OK;
+      }
+    }
+    parser->m_eventEndPtr = parser->m_eventPtr;
+    parser->m_processor = errorProcessor;
+    return XML_STATUS_ERROR;
+  }
+#ifndef XML_CONTEXT_BYTES
+  else if (parser->m_bufferPtr == parser->m_bufferEnd) {
+    const char *end;
+    int nLeftOver;
+    enum XML_Status result;
+    /* Detect overflow (a+b > MAX <==> b > MAX-a) */
+    if ((XML_Size)len > ((XML_Size)-1) / 2 - parser->m_parseEndByteIndex) {
+      parser->m_errorCode = XML_ERROR_NO_MEMORY;
+      parser->m_eventPtr = parser->m_eventEndPtr = NULL;
+      parser->m_processor = errorProcessor;
+      return XML_STATUS_ERROR;
+    }
+    parser->m_parseEndByteIndex += len;
+    parser->m_positionPtr = s;
+    parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
+
+    parser->m_errorCode
+        = parser->m_processor(parser, s, parser->m_parseEndPtr = s + len, &end);
+
+    if (parser->m_errorCode != XML_ERROR_NONE) {
+      parser->m_eventEndPtr = parser->m_eventPtr;
+      parser->m_processor = errorProcessor;
+      return XML_STATUS_ERROR;
+    } else {
+      switch (parser->m_parsingStatus.parsing) {
+      case XML_SUSPENDED:
+        result = XML_STATUS_SUSPENDED;
+        break;
+      case XML_INITIALIZED:
+      case XML_PARSING:
+        if (isFinal) {
+          parser->m_parsingStatus.parsing = XML_FINISHED;
+          return XML_STATUS_OK;
+        }
+      /* fall through */
+      default:
+        result = XML_STATUS_OK;
+      }
+    }
+
+    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr, end,
+                      &parser->m_position);
+    nLeftOver = s + len - end;
+    if (nLeftOver) {
+      if (parser->m_buffer == NULL
+          || nLeftOver > parser->m_bufferLim - parser->m_buffer) {
+        /* avoid _signed_ integer overflow */
+        char *temp = NULL;
+        const int bytesToAllocate = (int)((unsigned)len * 2U);
+        if (bytesToAllocate > 0) {
+          temp = (char *)REALLOC(parser, parser->m_buffer, bytesToAllocate);
+        }
+        if (temp == NULL) {
+          parser->m_errorCode = XML_ERROR_NO_MEMORY;
+          parser->m_eventPtr = parser->m_eventEndPtr = NULL;
+          parser->m_processor = errorProcessor;
+          return XML_STATUS_ERROR;
+        }
+        parser->m_buffer = temp;
+        parser->m_bufferLim = parser->m_buffer + bytesToAllocate;
+      }
+      memcpy(parser->m_buffer, end, nLeftOver);
+    }
+    parser->m_bufferPtr = parser->m_buffer;
+    parser->m_bufferEnd = parser->m_buffer + nLeftOver;
+    parser->m_positionPtr = parser->m_bufferPtr;
+    parser->m_parseEndPtr = parser->m_bufferEnd;
+    parser->m_eventPtr = parser->m_bufferPtr;
+    parser->m_eventEndPtr = parser->m_bufferPtr;
+    return result;
+  }
+#endif /* not defined XML_CONTEXT_BYTES */
+  else {
+    void *buff = XML_GetBuffer(parser, len);
+    if (buff == NULL)
+      return XML_STATUS_ERROR;
+    else {
+      memcpy(buff, s, len);
+      return XML_ParseBuffer(parser, len, isFinal);
+    }
+  }
+}
+
+enum XML_Status XMLCALL
+XML_ParseBuffer(XML_Parser parser, int len, int isFinal) {
+  const char *start;
+  enum XML_Status result = XML_STATUS_OK;
+
+  if (parser == NULL)
+    return XML_STATUS_ERROR;
+  switch (parser->m_parsingStatus.parsing) {
+  case XML_SUSPENDED:
+    parser->m_errorCode = XML_ERROR_SUSPENDED;
+    return XML_STATUS_ERROR;
+  case XML_FINISHED:
+    parser->m_errorCode = XML_ERROR_FINISHED;
+    return XML_STATUS_ERROR;
+  case XML_INITIALIZED:
+    /* Has someone called XML_GetBuffer successfully before? */
+    if (! parser->m_bufferPtr) {
+      parser->m_errorCode = XML_ERROR_NO_BUFFER;
+      return XML_STATUS_ERROR;
+    }
+
+    if (parser->m_parentParser == NULL && ! startParsing(parser)) {
+      parser->m_errorCode = XML_ERROR_NO_MEMORY;
+      return XML_STATUS_ERROR;
+    }
+    /* fall through */
+  default:
+    parser->m_parsingStatus.parsing = XML_PARSING;
+  }
+
+  start = parser->m_bufferPtr;
+  parser->m_positionPtr = start;
+  parser->m_bufferEnd += len;
+  parser->m_parseEndPtr = parser->m_bufferEnd;
+  parser->m_parseEndByteIndex += len;
+  parser->m_parsingStatus.finalBuffer = (XML_Bool)isFinal;
+
+  parser->m_errorCode = parser->m_processor(
+      parser, start, parser->m_parseEndPtr, &parser->m_bufferPtr);
+
+  if (parser->m_errorCode != XML_ERROR_NONE) {
+    parser->m_eventEndPtr = parser->m_eventPtr;
+    parser->m_processor = errorProcessor;
+    return XML_STATUS_ERROR;
+  } else {
+    switch (parser->m_parsingStatus.parsing) {
+    case XML_SUSPENDED:
+      result = XML_STATUS_SUSPENDED;
+      break;
+    case XML_INITIALIZED:
+    case XML_PARSING:
+      if (isFinal) {
+        parser->m_parsingStatus.parsing = XML_FINISHED;
+        return result;
+      }
+    default:; /* should not happen */
+    }
+  }
+
+  XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
+                    parser->m_bufferPtr, &parser->m_position);
+  parser->m_positionPtr = parser->m_bufferPtr;
+  return result;
+}
+
+void *XMLCALL
+XML_GetBuffer(XML_Parser parser, int len) {
+  if (parser == NULL)
+    return NULL;
+  if (len < 0) {
+    parser->m_errorCode = XML_ERROR_NO_MEMORY;
+    return NULL;
+  }
+  switch (parser->m_parsingStatus.parsing) {
+  case XML_SUSPENDED:
+    parser->m_errorCode = XML_ERROR_SUSPENDED;
+    return NULL;
+  case XML_FINISHED:
+    parser->m_errorCode = XML_ERROR_FINISHED;
+    return NULL;
+  default:;
+  }
+
+  if (len > EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferEnd)) {
+#ifdef XML_CONTEXT_BYTES
+    int keep;
+#endif /* defined XML_CONTEXT_BYTES */
+    /* Do not invoke signed arithmetic overflow: */
+    int neededSize = (int)((unsigned)len
+                           + (unsigned)EXPAT_SAFE_PTR_DIFF(
+                               parser->m_bufferEnd, parser->m_bufferPtr));
+    if (neededSize < 0) {
+      parser->m_errorCode = XML_ERROR_NO_MEMORY;
+      return NULL;
+    }
+#ifdef XML_CONTEXT_BYTES
+    keep = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer);
+    if (keep > XML_CONTEXT_BYTES)
+      keep = XML_CONTEXT_BYTES;
+    /* Detect and prevent integer overflow */
+    if (keep > INT_MAX - neededSize) {
+      parser->m_errorCode = XML_ERROR_NO_MEMORY;
+      return NULL;
+    }
+    neededSize += keep;
+#endif /* defined XML_CONTEXT_BYTES */
+    if (neededSize
+        <= EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_buffer)) {
+#ifdef XML_CONTEXT_BYTES
+      if (keep < EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)) {
+        int offset
+            = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferPtr, parser->m_buffer)
+              - keep;
+        /* The buffer pointers cannot be NULL here; we have at least some bytes
+         * in the buffer */
+        memmove(parser->m_buffer, &parser->m_buffer[offset],
+                parser->m_bufferEnd - parser->m_bufferPtr + keep);
+        parser->m_bufferEnd -= offset;
+        parser->m_bufferPtr -= offset;
+      }
+#else
+      if (parser->m_buffer && parser->m_bufferPtr) {
+        memmove(parser->m_buffer, parser->m_bufferPtr,
+                EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));
+        parser->m_bufferEnd
+            = parser->m_buffer
+              + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
+        parser->m_bufferPtr = parser->m_buffer;
+      }
+#endif /* not defined XML_CONTEXT_BYTES */
+    } else {
+      char *newBuf;
+      int bufferSize
+          = (int)EXPAT_SAFE_PTR_DIFF(parser->m_bufferLim, parser->m_bufferPtr);
+      if (bufferSize == 0)
+        bufferSize = INIT_BUFFER_SIZE;
+      do {
+        /* Do not invoke signed arithmetic overflow: */
+        bufferSize = (int)(2U * (unsigned)bufferSize);
+      } while (bufferSize < neededSize && bufferSize > 0);
+      if (bufferSize <= 0) {
+        parser->m_errorCode = XML_ERROR_NO_MEMORY;
+        return NULL;
+      }
+      newBuf = (char *)MALLOC(parser, bufferSize);
+      if (newBuf == 0) {
+        parser->m_errorCode = XML_ERROR_NO_MEMORY;
+        return NULL;
+      }
+      parser->m_bufferLim = newBuf + bufferSize;
+#ifdef XML_CONTEXT_BYTES
+      if (parser->m_bufferPtr) {
+        memcpy(newBuf, &parser->m_bufferPtr[-keep],
+               EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)
+                   + keep);
+        FREE(parser, parser->m_buffer);
+        parser->m_buffer = newBuf;
+        parser->m_bufferEnd
+            = parser->m_buffer
+              + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr)
+              + keep;
+        parser->m_bufferPtr = parser->m_buffer + keep;
+      } else {
+        /* This must be a brand new buffer with no data in it yet */
+        parser->m_bufferEnd = newBuf;
+        parser->m_bufferPtr = parser->m_buffer = newBuf;
+      }
+#else
+      if (parser->m_bufferPtr) {
+        memcpy(newBuf, parser->m_bufferPtr,
+               EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr));
+        FREE(parser, parser->m_buffer);
+        parser->m_bufferEnd
+            = newBuf
+              + EXPAT_SAFE_PTR_DIFF(parser->m_bufferEnd, parser->m_bufferPtr);
+      } else {
+        /* This must be a brand new buffer with no data in it yet */
+        parser->m_bufferEnd = newBuf;
+      }
+      parser->m_bufferPtr = parser->m_buffer = newBuf;
+#endif /* not defined XML_CONTEXT_BYTES */
+    }
+    parser->m_eventPtr = parser->m_eventEndPtr = NULL;
+    parser->m_positionPtr = NULL;
+  }
+  return parser->m_bufferEnd;
+}
+
+enum XML_Status XMLCALL
+XML_StopParser(XML_Parser parser, XML_Bool resumable) {
+  if (parser == NULL)
+    return XML_STATUS_ERROR;
+  switch (parser->m_parsingStatus.parsing) {
+  case XML_SUSPENDED:
+    if (resumable) {
+      parser->m_errorCode = XML_ERROR_SUSPENDED;
+      return XML_STATUS_ERROR;
+    }
+    parser->m_parsingStatus.parsing = XML_FINISHED;
+    break;
+  case XML_FINISHED:
+    parser->m_errorCode = XML_ERROR_FINISHED;
+    return XML_STATUS_ERROR;
+  default:
+    if (resumable) {
+#ifdef XML_DTD
+      if (parser->m_isParamEntity) {
+        parser->m_errorCode = XML_ERROR_SUSPEND_PE;
+        return XML_STATUS_ERROR;
+      }
+#endif
+      parser->m_parsingStatus.parsing = XML_SUSPENDED;
+    } else
+      parser->m_parsingStatus.parsing = XML_FINISHED;
+  }
+  return XML_STATUS_OK;
+}
+
+enum XML_Status XMLCALL
+XML_ResumeParser(XML_Parser parser) {
+  enum XML_Status result = XML_STATUS_OK;
+
+  if (parser == NULL)
+    return XML_STATUS_ERROR;
+  if (parser->m_parsingStatus.parsing != XML_SUSPENDED) {
+    parser->m_errorCode = XML_ERROR_NOT_SUSPENDED;
+    return XML_STATUS_ERROR;
+  }
+  parser->m_parsingStatus.parsing = XML_PARSING;
+
+  parser->m_errorCode = parser->m_processor(
+      parser, parser->m_bufferPtr, parser->m_parseEndPtr, &parser->m_bufferPtr);
+
+  if (parser->m_errorCode != XML_ERROR_NONE) {
+    parser->m_eventEndPtr = parser->m_eventPtr;
+    parser->m_processor = errorProcessor;
+    return XML_STATUS_ERROR;
+  } else {
+    switch (parser->m_parsingStatus.parsing) {
+    case XML_SUSPENDED:
+      result = XML_STATUS_SUSPENDED;
+      break;
+    case XML_INITIALIZED:
+    case XML_PARSING:
+      if (parser->m_parsingStatus.finalBuffer) {
+        parser->m_parsingStatus.parsing = XML_FINISHED;
+        return result;
+      }
+    default:;
+    }
+  }
+
+  XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
+                    parser->m_bufferPtr, &parser->m_position);
+  parser->m_positionPtr = parser->m_bufferPtr;
+  return result;
+}
+
+void XMLCALL
+XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status) {
+  if (parser == NULL)
+    return;
+  assert(status != NULL);
+  *status = parser->m_parsingStatus;
+}
+
+enum XML_Error XMLCALL
+XML_GetErrorCode(XML_Parser parser) {
+  if (parser == NULL)
+    return XML_ERROR_INVALID_ARGUMENT;
+  return parser->m_errorCode;
+}
+
+XML_Index XMLCALL
+XML_GetCurrentByteIndex(XML_Parser parser) {
+  if (parser == NULL)
+    return -1;
+  if (parser->m_eventPtr)
+    return (XML_Index)(parser->m_parseEndByteIndex
+                       - (parser->m_parseEndPtr - parser->m_eventPtr));
+  return -1;
+}
+
+int XMLCALL
+XML_GetCurrentByteCount(XML_Parser parser) {
+  if (parser == NULL)
+    return 0;
+  if (parser->m_eventEndPtr && parser->m_eventPtr)
+    return (int)(parser->m_eventEndPtr - parser->m_eventPtr);
+  return 0;
+}
+
+const char *XMLCALL
+XML_GetInputContext(XML_Parser parser, int *offset, int *size) {
+#ifdef XML_CONTEXT_BYTES
+  if (parser == NULL)
+    return NULL;
+  if (parser->m_eventPtr && parser->m_buffer) {
+    if (offset != NULL)
+      *offset = (int)(parser->m_eventPtr - parser->m_buffer);
+    if (size != NULL)
+      *size = (int)(parser->m_bufferEnd - parser->m_buffer);
+    return parser->m_buffer;
+  }
+#else
+  (void)parser;
+  (void)offset;
+  (void)size;
+#endif /* defined XML_CONTEXT_BYTES */
+  return (const char *)0;
+}
+
+XML_Size XMLCALL
+XML_GetCurrentLineNumber(XML_Parser parser) {
+  if (parser == NULL)
+    return 0;
+  if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {
+    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
+                      parser->m_eventPtr, &parser->m_position);
+    parser->m_positionPtr = parser->m_eventPtr;
+  }
+  return parser->m_position.lineNumber + 1;
+}
+
+XML_Size XMLCALL
+XML_GetCurrentColumnNumber(XML_Parser parser) {
+  if (parser == NULL)
+    return 0;
+  if (parser->m_eventPtr && parser->m_eventPtr >= parser->m_positionPtr) {
+    XmlUpdatePosition(parser->m_encoding, parser->m_positionPtr,
+                      parser->m_eventPtr, &parser->m_position);
+    parser->m_positionPtr = parser->m_eventPtr;
+  }
+  return parser->m_position.columnNumber;
+}
+
+void XMLCALL
+XML_FreeContentModel(XML_Parser parser, XML_Content *model) {
+  if (parser != NULL)
+    FREE(parser, model);
+}
+
+void *XMLCALL
+XML_MemMalloc(XML_Parser parser, size_t size) {
+  if (parser == NULL)
+    return NULL;
+  return MALLOC(parser, size);
+}
+
+void *XMLCALL
+XML_MemRealloc(XML_Parser parser, void *ptr, size_t size) {
+  if (parser == NULL)
+    return NULL;
+  return REALLOC(parser, ptr, size);
+}
+
+void XMLCALL
+XML_MemFree(XML_Parser parser, void *ptr) {
+  if (parser != NULL)
+    FREE(parser, ptr);
+}
+
+void XMLCALL
+XML_DefaultCurrent(XML_Parser parser) {
+  if (parser == NULL)
+    return;
+  if (parser->m_defaultHandler) {
+    if (parser->m_openInternalEntities)
+      reportDefault(parser, parser->m_internalEncoding,
+                    parser->m_openInternalEntities->internalEventPtr,
+                    parser->m_openInternalEntities->internalEventEndPtr);
+    else
+      reportDefault(parser, parser->m_encoding, parser->m_eventPtr,
+                    parser->m_eventEndPtr);
+  }
+}
+
+const XML_LChar *XMLCALL
+XML_ErrorString(enum XML_Error code) {
+  switch (code) {
+  case XML_ERROR_NONE:
+    return NULL;
+  case XML_ERROR_NO_MEMORY:
+    return XML_L("out of memory");
+  case XML_ERROR_SYNTAX:
+    return XML_L("syntax error");
+  case XML_ERROR_NO_ELEMENTS:
+    return XML_L("no element found");
+  case XML_ERROR_INVALID_TOKEN:
+    return XML_L("not well-formed (invalid token)");
+  case XML_ERROR_UNCLOSED_TOKEN:
+    return XML_L("unclosed token");
+  case XML_ERROR_PARTIAL_CHAR:
+    return XML_L("partial character");
+  case XML_ERROR_TAG_MISMATCH:
+    return XML_L("mismatched tag");
+  case XML_ERROR_DUPLICATE_ATTRIBUTE:
+    return XML_L("duplicate attribute");
+  case XML_ERROR_JUNK_AFTER_DOC_ELEMENT:
+    return XML_L("junk after document element");
+  case XML_ERROR_PARAM_ENTITY_REF:
+    return XML_L("illegal parameter entity reference");
+  case XML_ERROR_UNDEFINED_ENTITY:
+    return XML_L("undefined entity");
+  case XML_ERROR_RECURSIVE_ENTITY_REF:
+    return XML_L("recursive entity reference");
+  case XML_ERROR_ASYNC_ENTITY:
+    return XML_L("asynchronous entity");
+  case XML_ERROR_BAD_CHAR_REF:
+    return XML_L("reference to invalid character number");
+  case XML_ERROR_BINARY_ENTITY_REF:
+    return XML_L("reference to binary entity");
+  case XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF:
+    return XML_L("reference to external entity in attribute");
+  case XML_ERROR_MISPLACED_XML_PI:
+    return XML_L("XML or text declaration not at start of entity");
+  case XML_ERROR_UNKNOWN_ENCODING:
+    return XML_L("unknown encoding");
+  case XML_ERROR_INCORRECT_ENCODING:
+    return XML_L("encoding specified in XML declaration is incorrect");
+  case XML_ERROR_UNCLOSED_CDATA_SECTION:
+    return XML_L("unclosed CDATA section");
+  case XML_ERROR_EXTERNAL_ENTITY_HANDLING:
+    return XML_L("error in processing external entity reference");
+  case XML_ERROR_NOT_STANDALONE:
+    return XML_L("document is not standalone");
+  case XML_ERROR_UNEXPECTED_STATE:
+    return XML_L("unexpected parser state - please send a bug report");
+  case XML_ERROR_ENTITY_DECLARED_IN_PE:
+    return XML_L("entity declared in parameter entity");
+  case XML_ERROR_FEATURE_REQUIRES_XML_DTD:
+    return XML_L("requested feature requires XML_DTD support in Expat");
+  case XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING:
+    return XML_L("cannot change setting once parsing has begun");
+  /* Added in 1.95.7. */
+  case XML_ERROR_UNBOUND_PREFIX:
+    return XML_L("unbound prefix");
+  /* Added in 1.95.8. */
+  case XML_ERROR_UNDECLARING_PREFIX:
+    return XML_L("must not undeclare prefix");
+  case XML_ERROR_INCOMPLETE_PE:
+    return XML_L("incomplete markup in parameter entity");
+  case XML_ERROR_XML_DECL:
+    return XML_L("XML declaration not well-formed");
+  case XML_ERROR_TEXT_DECL:
+    return XML_L("text declaration not well-formed");
+  case XML_ERROR_PUBLICID:
+    return XML_L("illegal character(s) in public id");
+  case XML_ERROR_SUSPENDED:
+    return XML_L("parser suspended");
+  case XML_ERROR_NOT_SUSPENDED:
+    return XML_L("parser not suspended");
+  case XML_ERROR_ABORTED:
+    return XML_L("parsing aborted");
+  case XML_ERROR_FINISHED:
+    return XML_L("parsing finished");
+  case XML_ERROR_SUSPEND_PE:
+    return XML_L("cannot suspend in external parameter entity");
+  /* Added in 2.0.0. */
+  case XML_ERROR_RESERVED_PREFIX_XML:
+    return XML_L(
+        "reserved prefix (xml) must not be undeclared or bound to another namespace name");
+  case XML_ERROR_RESERVED_PREFIX_XMLNS:
+    return XML_L("reserved prefix (xmlns) must not be declared or undeclared");
+  case XML_ERROR_RESERVED_NAMESPACE_URI:
+    return XML_L(
+        "prefix must not be bound to one of the reserved namespace names");
+  /* Added in 2.2.5. */
+  case XML_ERROR_INVALID_ARGUMENT: /* Constant added in 2.2.1, already */
+    return XML_L("invalid argument");
+    /* Added in 2.3.0. */
+  case XML_ERROR_NO_BUFFER:
+    return XML_L(
+        "a successful prior call to function XML_GetBuffer is required");
+  /* Added in 2.4.0. */
+  case XML_ERROR_AMPLIFICATION_LIMIT_BREACH:
+    return XML_L(
+        "limit on input amplification factor (from DTD and entities) breached");
+  }
+  return NULL;
+}
+
+const XML_LChar *XMLCALL
+XML_ExpatVersion(void) {
+  /* V1 is used to string-ize the version number. However, it would
+     string-ize the actual version macro *names* unless we get them
+     substituted before being passed to V1. CPP is defined to expand
+     a macro, then rescan for more expansions. Thus, we use V2 to expand
+     the version macros, then CPP will expand the resulting V1() macro
+     with the correct numerals. */
+  /* ### I'm assuming cpp is portable in this respect... */
+
+#define V1(a, b, c) XML_L(#a) XML_L(".") XML_L(#b) XML_L(".") XML_L(#c)
+#define V2(a, b, c) XML_L("expat_") V1(a, b, c)
+
+  return V2(XML_MAJOR_VERSION, XML_MINOR_VERSION, XML_MICRO_VERSION);
+
+#undef V1
+#undef V2
+}
+
+XML_Expat_Version XMLCALL
+XML_ExpatVersionInfo(void) {
+  XML_Expat_Version version;
+
+  version.major = XML_MAJOR_VERSION;
+  version.minor = XML_MINOR_VERSION;
+  version.micro = XML_MICRO_VERSION;
+
+  return version;
+}
+
+const XML_Feature *XMLCALL
+XML_GetFeatureList(void) {
+  static const XML_Feature features[] = {
+      {XML_FEATURE_SIZEOF_XML_CHAR, XML_L("sizeof(XML_Char)"),
+       sizeof(XML_Char)},
+      {XML_FEATURE_SIZEOF_XML_LCHAR, XML_L("sizeof(XML_LChar)"),
+       sizeof(XML_LChar)},
+#ifdef XML_UNICODE
+      {XML_FEATURE_UNICODE, XML_L("XML_UNICODE"), 0},
+#endif
+#ifdef XML_UNICODE_WCHAR_T
+      {XML_FEATURE_UNICODE_WCHAR_T, XML_L("XML_UNICODE_WCHAR_T"), 0},
+#endif
+#ifdef XML_DTD
+      {XML_FEATURE_DTD, XML_L("XML_DTD"), 0},
+#endif
+#ifdef XML_CONTEXT_BYTES
+      {XML_FEATURE_CONTEXT_BYTES, XML_L("XML_CONTEXT_BYTES"),
+       XML_CONTEXT_BYTES},
+#endif
+#ifdef XML_MIN_SIZE
+      {XML_FEATURE_MIN_SIZE, XML_L("XML_MIN_SIZE"), 0},
+#endif
+#ifdef XML_NS
+      {XML_FEATURE_NS, XML_L("XML_NS"), 0},
+#endif
+#ifdef XML_LARGE_SIZE
+      {XML_FEATURE_LARGE_SIZE, XML_L("XML_LARGE_SIZE"), 0},
+#endif
+#ifdef XML_ATTR_INFO
+      {XML_FEATURE_ATTR_INFO, XML_L("XML_ATTR_INFO"), 0},
+#endif
+#ifdef XML_DTD
+      /* Added in Expat 2.4.0. */
+      {XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT,
+       XML_L("XML_BLAP_MAX_AMP"),
+       (long int)
+           EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_MAXIMUM_AMPLIFICATION_DEFAULT},
+      {XML_FEATURE_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT,
+       XML_L("XML_BLAP_ACT_THRES"),
+       EXPAT_BILLION_LAUGHS_ATTACK_PROTECTION_ACTIVATION_THRESHOLD_DEFAULT},
+#endif
+      {XML_FEATURE_END, NULL, 0}};
+
+  return features;
+}
+
+#ifdef XML_DTD
+XML_Bool XMLCALL
+XML_SetBillionLaughsAttackProtectionMaximumAmplification(
+    XML_Parser parser, float maximumAmplificationFactor) {
+  if ((parser == NULL) || (parser->m_parentParser != NULL)
+      || isnan(maximumAmplificationFactor)
+      || (maximumAmplificationFactor < 1.0f)) {
+    return XML_FALSE;
+  }
+  parser->m_accounting.maximumAmplificationFactor = maximumAmplificationFactor;
+  return XML_TRUE;
+}
+
+XML_Bool XMLCALL
+XML_SetBillionLaughsAttackProtectionActivationThreshold(
+    XML_Parser parser, unsigned long long activationThresholdBytes) {
+  if ((parser == NULL) || (parser->m_parentParser != NULL)) {
+    return XML_FALSE;
+  }
+  parser->m_accounting.activationThresholdBytes = activationThresholdBytes;
+  return XML_TRUE;
+}
+#endif /* XML_DTD */
+
+/* Initially tag->rawName always points into the parse buffer;
+   for those TAG instances opened while the current parse buffer was
+   processed, and not yet closed, we need to store tag->rawName in a more
+   permanent location, since the parse buffer is about to be discarded.
+*/
+static XML_Bool
+storeRawNames(XML_Parser parser) {
+  TAG *tag = parser->m_tagStack;
+  while (tag) {
+    int bufSize;
+    int nameLen = sizeof(XML_Char) * (tag->name.strLen + 1);
+    size_t rawNameLen;
+    char *rawNameBuf = tag->buf + nameLen;
+    /* Stop if already stored.  Since m_tagStack is a stack, we can stop
+       at the first entry that has already been copied; everything
+       below it in the stack is already been accounted for in a
+       previous call to this function.
+    */
+    if (tag->rawName == rawNameBuf)
+      break;
+    /* For re-use purposes we need to ensure that the
+       size of tag->buf is a multiple of sizeof(XML_Char).
+    */
+    rawNameLen = ROUND_UP(tag->rawNameLength, sizeof(XML_Char));
+    /* Detect and prevent integer overflow. */
+    if (rawNameLen > (size_t)INT_MAX - nameLen)
+      return XML_FALSE;
+    bufSize = nameLen + (int)rawNameLen;
+    if (bufSize > tag->bufEnd - tag->buf) {
+      char *temp = (char *)REALLOC(parser, tag->buf, bufSize);
+      if (temp == NULL)
+        return XML_FALSE;
+      /* if tag->name.str points to tag->buf (only when namespace
+         processing is off) then we have to update it
+      */
+      if (tag->name.str == (XML_Char *)tag->buf)
+        tag->name.str = (XML_Char *)temp;
+      /* if tag->name.localPart is set (when namespace processing is on)
+         then update it as well, since it will always point into tag->buf
+      */
+      if (tag->name.localPart)
+        tag->name.localPart
+            = (XML_Char *)temp + (tag->name.localPart - (XML_Char *)tag->buf);
+      tag->buf = temp;
+      tag->bufEnd = temp + bufSize;
+      rawNameBuf = temp + nameLen;
+    }
+    memcpy(rawNameBuf, tag->rawName, tag->rawNameLength);
+    tag->rawName = rawNameBuf;
+    tag = tag->parent;
+  }
+  return XML_TRUE;
+}
+
+static enum XML_Error PTRCALL
+contentProcessor(XML_Parser parser, const char *start, const char *end,
+                 const char **endPtr) {
+  enum XML_Error result = doContent(
+      parser, 0, parser->m_encoding, start, end, endPtr,
+      (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_ACCOUNT_DIRECT);
+  if (result == XML_ERROR_NONE) {
+    if (! storeRawNames(parser))
+      return XML_ERROR_NO_MEMORY;
+  }
+  return result;
+}
+
+static enum XML_Error PTRCALL
+externalEntityInitProcessor(XML_Parser parser, const char *start,
+                            const char *end, const char **endPtr) {
+  enum XML_Error result = initializeEncoding(parser);
+  if (result != XML_ERROR_NONE)
+    return result;
+  parser->m_processor = externalEntityInitProcessor2;
+  return externalEntityInitProcessor2(parser, start, end, endPtr);
+}
+
+static enum XML_Error PTRCALL
+externalEntityInitProcessor2(XML_Parser parser, const char *start,
+                             const char *end, const char **endPtr) {
+  const char *next = start; /* XmlContentTok doesn't always set the last arg */
+  int tok = XmlContentTok(parser->m_encoding, start, end, &next);
+  switch (tok) {
+  case XML_TOK_BOM:
+#ifdef XML_DTD
+    if (! accountingDiffTolerated(parser, tok, start, next, __LINE__,
+                                  XML_ACCOUNT_DIRECT)) {
+      accountingOnAbort(parser);
+      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+    }
+#endif /* XML_DTD */
+
+    /* If we are at the end of the buffer, this would cause the next stage,
+       i.e. externalEntityInitProcessor3, to pass control directly to
+       doContent (by detecting XML_TOK_NONE) without processing any xml text
+       declaration - causing the error XML_ERROR_MISPLACED_XML_PI in doContent.
+    */
+    if (next == end && ! parser->m_parsingStatus.finalBuffer) {
+      *endPtr = next;
+      return XML_ERROR_NONE;
+    }
+    start = next;
+    break;
+  case XML_TOK_PARTIAL:
+    if (! parser->m_parsingStatus.finalBuffer) {
+      *endPtr = start;
+      return XML_ERROR_NONE;
+    }
+    parser->m_eventPtr = start;
+    return XML_ERROR_UNCLOSED_TOKEN;
+  case XML_TOK_PARTIAL_CHAR:
+    if (! parser->m_parsingStatus.finalBuffer) {
+      *endPtr = start;
+      return XML_ERROR_NONE;
+    }
+    parser->m_eventPtr = start;
+    return XML_ERROR_PARTIAL_CHAR;
+  }
+  parser->m_processor = externalEntityInitProcessor3;
+  return externalEntityInitProcessor3(parser, start, end, endPtr);
+}
+
+static enum XML_Error PTRCALL
+externalEntityInitProcessor3(XML_Parser parser, const char *start,
+                             const char *end, const char **endPtr) {
+  int tok;
+  const char *next = start; /* XmlContentTok doesn't always set the last arg */
+  parser->m_eventPtr = start;
+  tok = XmlContentTok(parser->m_encoding, start, end, &next);
+  /* Note: These bytes are accounted later in:
+           - processXmlDecl
+           - externalEntityContentProcessor
+  */
+  parser->m_eventEndPtr = next;
+
+  switch (tok) {
+  case XML_TOK_XML_DECL: {
+    enum XML_Error result;
+    result = processXmlDecl(parser, 1, start, next);
+    if (result != XML_ERROR_NONE)
+      return result;
+    switch (parser->m_parsingStatus.parsing) {
+    case XML_SUSPENDED:
+      *endPtr = next;
+      return XML_ERROR_NONE;
+    case XML_FINISHED:
+      return XML_ERROR_ABORTED;
+    default:
+      start = next;
+    }
+  } break;
+  case XML_TOK_PARTIAL:
+    if (! parser->m_parsingStatus.finalBuffer) {
+      *endPtr = start;
+      return XML_ERROR_NONE;
+    }
+    return XML_ERROR_UNCLOSED_TOKEN;
+  case XML_TOK_PARTIAL_CHAR:
+    if (! parser->m_parsingStatus.finalBuffer) {
+      *endPtr = start;
+      return XML_ERROR_NONE;
+    }
+    return XML_ERROR_PARTIAL_CHAR;
+  }
+  parser->m_processor = externalEntityContentProcessor;
+  parser->m_tagLevel = 1;
+  return externalEntityContentProcessor(parser, start, end, endPtr);
+}
+
+static enum XML_Error PTRCALL
+externalEntityContentProcessor(XML_Parser parser, const char *start,
+                               const char *end, const char **endPtr) {
+  enum XML_Error result
+      = doContent(parser, 1, parser->m_encoding, start, end, endPtr,
+                  (XML_Bool)! parser->m_parsingStatus.finalBuffer,
+                  XML_ACCOUNT_ENTITY_EXPANSION);
+  if (result == XML_ERROR_NONE) {
+    if (! storeRawNames(parser))
+      return XML_ERROR_NO_MEMORY;
+  }
+  return result;
+}
+
+static enum XML_Error
+doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,
+          const char *s, const char *end, const char **nextPtr,
+          XML_Bool haveMore, enum XML_Account account) {
+  /* save one level of indirection */
+  DTD *const dtd = parser->m_dtd;
+
+  const char **eventPP;
+  const char **eventEndPP;
+  if (enc == parser->m_encoding) {
+    eventPP = &parser->m_eventPtr;
+    eventEndPP = &parser->m_eventEndPtr;
+  } else {
+    eventPP = &(parser->m_openInternalEntities->internalEventPtr);
+    eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
+  }
+  *eventPP = s;
+
+  for (;;) {
+    const char *next = s; /* XmlContentTok doesn't always set the last arg */
+    int tok = XmlContentTok(enc, s, end, &next);
+#ifdef XML_DTD
+    const char *accountAfter
+        = ((tok == XML_TOK_TRAILING_RSQB) || (tok == XML_TOK_TRAILING_CR))
+              ? (haveMore ? s /* i.e. 0 bytes */ : end)
+              : next;
+    if (! accountingDiffTolerated(parser, tok, s, accountAfter, __LINE__,
+                                  account)) {
+      accountingOnAbort(parser);
+      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+    }
+#endif
+    *eventEndPP = next;
+    switch (tok) {
+    case XML_TOK_TRAILING_CR:
+      if (haveMore) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      *eventEndPP = end;
+      if (parser->m_characterDataHandler) {
+        XML_Char c = 0xA;
+        parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, end);
+      /* We are at the end of the final buffer, should we check for
+         XML_SUSPENDED, XML_FINISHED?
+      */
+      if (startTagLevel == 0)
+        return XML_ERROR_NO_ELEMENTS;
+      if (parser->m_tagLevel != startTagLevel)
+        return XML_ERROR_ASYNC_ENTITY;
+      *nextPtr = end;
+      return XML_ERROR_NONE;
+    case XML_TOK_NONE:
+      if (haveMore) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      if (startTagLevel > 0) {
+        if (parser->m_tagLevel != startTagLevel)
+          return XML_ERROR_ASYNC_ENTITY;
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      return XML_ERROR_NO_ELEMENTS;
+    case XML_TOK_INVALID:
+      *eventPP = next;
+      return XML_ERROR_INVALID_TOKEN;
+    case XML_TOK_PARTIAL:
+      if (haveMore) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      return XML_ERROR_UNCLOSED_TOKEN;
+    case XML_TOK_PARTIAL_CHAR:
+      if (haveMore) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      return XML_ERROR_PARTIAL_CHAR;
+    case XML_TOK_ENTITY_REF: {
+      const XML_Char *name;
+      ENTITY *entity;
+      XML_Char ch = (XML_Char)XmlPredefinedEntityName(
+          enc, s + enc->minBytesPerChar, next - enc->minBytesPerChar);
+      if (ch) {
+#ifdef XML_DTD
+        /* NOTE: We are replacing 4-6 characters original input for 1 character
+         *       so there is no amplification and hence recording without
+         *       protection. */
+        accountingDiffTolerated(parser, tok, (char *)&ch,
+                                ((char *)&ch) + sizeof(XML_Char), __LINE__,
+                                XML_ACCOUNT_ENTITY_EXPANSION);
+#endif /* XML_DTD */
+        if (parser->m_characterDataHandler)
+          parser->m_characterDataHandler(parser->m_handlerArg, &ch, 1);
+        else if (parser->m_defaultHandler)
+          reportDefault(parser, enc, s, next);
+        break;
+      }
+      name = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
+                             next - enc->minBytesPerChar);
+      if (! name)
+        return XML_ERROR_NO_MEMORY;
+      entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
+      poolDiscard(&dtd->pool);
+      /* First, determine if a check for an existing declaration is needed;
+         if yes, check that the entity exists, and that it is internal,
+         otherwise call the skipped entity or default handler.
+      */
+      if (! dtd->hasParamEntityRefs || dtd->standalone) {
+        if (! entity)
+          return XML_ERROR_UNDEFINED_ENTITY;
+        else if (! entity->is_internal)
+          return XML_ERROR_ENTITY_DECLARED_IN_PE;
+      } else if (! entity) {
+        if (parser->m_skippedEntityHandler)
+          parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
+        else if (parser->m_defaultHandler)
+          reportDefault(parser, enc, s, next);
+        break;
+      }
+      if (entity->open)
+        return XML_ERROR_RECURSIVE_ENTITY_REF;
+      if (entity->notation)
+        return XML_ERROR_BINARY_ENTITY_REF;
+      if (entity->textPtr) {
+        enum XML_Error result;
+        if (! parser->m_defaultExpandInternalEntities) {
+          if (parser->m_skippedEntityHandler)
+            parser->m_skippedEntityHandler(parser->m_handlerArg, entity->name,
+                                           0);
+          else if (parser->m_defaultHandler)
+            reportDefault(parser, enc, s, next);
+          break;
+        }
+        result = processInternalEntity(parser, entity, XML_FALSE);
+        if (result != XML_ERROR_NONE)
+          return result;
+      } else if (parser->m_externalEntityRefHandler) {
+        const XML_Char *context;
+        entity->open = XML_TRUE;
+        context = getContext(parser);
+        entity->open = XML_FALSE;
+        if (! context)
+          return XML_ERROR_NO_MEMORY;
+        if (! parser->m_externalEntityRefHandler(
+                parser->m_externalEntityRefHandlerArg, context, entity->base,
+                entity->systemId, entity->publicId))
+          return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+        poolDiscard(&parser->m_tempPool);
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      break;
+    }
+    case XML_TOK_START_TAG_NO_ATTS:
+      /* fall through */
+    case XML_TOK_START_TAG_WITH_ATTS: {
+      TAG *tag;
+      enum XML_Error result;
+      XML_Char *toPtr;
+      if (parser->m_freeTagList) {
+        tag = parser->m_freeTagList;
+        parser->m_freeTagList = parser->m_freeTagList->parent;
+      } else {
+        tag = (TAG *)MALLOC(parser, sizeof(TAG));
+        if (! tag)
+          return XML_ERROR_NO_MEMORY;
+        tag->buf = (char *)MALLOC(parser, INIT_TAG_BUF_SIZE);
+        if (! tag->buf) {
+          FREE(parser, tag);
+          return XML_ERROR_NO_MEMORY;
+        }
+        tag->bufEnd = tag->buf + INIT_TAG_BUF_SIZE;
+      }
+      tag->bindings = NULL;
+      tag->parent = parser->m_tagStack;
+      parser->m_tagStack = tag;
+      tag->name.localPart = NULL;
+      tag->name.prefix = NULL;
+      tag->rawName = s + enc->minBytesPerChar;
+      tag->rawNameLength = XmlNameLength(enc, tag->rawName);
+      ++parser->m_tagLevel;
+      {
+        const char *rawNameEnd = tag->rawName + tag->rawNameLength;
+        const char *fromPtr = tag->rawName;
+        toPtr = (XML_Char *)tag->buf;
+        for (;;) {
+          int bufSize;
+          int convLen;
+          const enum XML_Convert_Result convert_res
+              = XmlConvert(enc, &fromPtr, rawNameEnd, (ICHAR **)&toPtr,
+                           (ICHAR *)tag->bufEnd - 1);
+          convLen = (int)(toPtr - (XML_Char *)tag->buf);
+          if ((fromPtr >= rawNameEnd)
+              || (convert_res == XML_CONVERT_INPUT_INCOMPLETE)) {
+            tag->name.strLen = convLen;
+            break;
+          }
+          bufSize = (int)(tag->bufEnd - tag->buf) << 1;
+          {
+            char *temp = (char *)REALLOC(parser, tag->buf, bufSize);
+            if (temp == NULL)
+              return XML_ERROR_NO_MEMORY;
+            tag->buf = temp;
+            tag->bufEnd = temp + bufSize;
+            toPtr = (XML_Char *)temp + convLen;
+          }
+        }
+      }
+      tag->name.str = (XML_Char *)tag->buf;
+      *toPtr = XML_T('\0');
+      result
+          = storeAtts(parser, enc, s, &(tag->name), &(tag->bindings), account);
+      if (result)
+        return result;
+      if (parser->m_startElementHandler)
+        parser->m_startElementHandler(parser->m_handlerArg, tag->name.str,
+                                      (const XML_Char **)parser->m_atts);
+      else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      poolClear(&parser->m_tempPool);
+      break;
+    }
+    case XML_TOK_EMPTY_ELEMENT_NO_ATTS:
+      /* fall through */
+    case XML_TOK_EMPTY_ELEMENT_WITH_ATTS: {
+      const char *rawName = s + enc->minBytesPerChar;
+      enum XML_Error result;
+      BINDING *bindings = NULL;
+      XML_Bool noElmHandlers = XML_TRUE;
+      TAG_NAME name;
+      name.str = poolStoreString(&parser->m_tempPool, enc, rawName,
+                                 rawName + XmlNameLength(enc, rawName));
+      if (! name.str)
+        return XML_ERROR_NO_MEMORY;
+      poolFinish(&parser->m_tempPool);
+      result = storeAtts(parser, enc, s, &name, &bindings,
+                         XML_ACCOUNT_NONE /* token spans whole start tag */);
+      if (result != XML_ERROR_NONE) {
+        freeBindings(parser, bindings);
+        return result;
+      }
+      poolFinish(&parser->m_tempPool);
+      if (parser->m_startElementHandler) {
+        parser->m_startElementHandler(parser->m_handlerArg, name.str,
+                                      (const XML_Char **)parser->m_atts);
+        noElmHandlers = XML_FALSE;
+      }
+      if (parser->m_endElementHandler) {
+        if (parser->m_startElementHandler)
+          *eventPP = *eventEndPP;
+        parser->m_endElementHandler(parser->m_handlerArg, name.str);
+        noElmHandlers = XML_FALSE;
+      }
+      if (noElmHandlers && parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      poolClear(&parser->m_tempPool);
+      freeBindings(parser, bindings);
+    }
+      if ((parser->m_tagLevel == 0)
+          && (parser->m_parsingStatus.parsing != XML_FINISHED)) {
+        if (parser->m_parsingStatus.parsing == XML_SUSPENDED)
+          parser->m_processor = epilogProcessor;
+        else
+          return epilogProcessor(parser, next, end, nextPtr);
+      }
+      break;
+    case XML_TOK_END_TAG:
+      if (parser->m_tagLevel == startTagLevel)
+        return XML_ERROR_ASYNC_ENTITY;
+      else {
+        int len;
+        const char *rawName;
+        TAG *tag = parser->m_tagStack;
+        parser->m_tagStack = tag->parent;
+        tag->parent = parser->m_freeTagList;
+        parser->m_freeTagList = tag;
+        rawName = s + enc->minBytesPerChar * 2;
+        len = XmlNameLength(enc, rawName);
+        if (len != tag->rawNameLength
+            || memcmp(tag->rawName, rawName, len) != 0) {
+          *eventPP = rawName;
+          return XML_ERROR_TAG_MISMATCH;
+        }
+        --parser->m_tagLevel;
+        if (parser->m_endElementHandler) {
+          const XML_Char *localPart;
+          const XML_Char *prefix;
+          XML_Char *uri;
+          localPart = tag->name.localPart;
+          if (parser->m_ns && localPart) {
+            /* localPart and prefix may have been overwritten in
+               tag->name.str, since this points to the binding->uri
+               buffer which gets re-used; so we have to add them again
+            */
+            uri = (XML_Char *)tag->name.str + tag->name.uriLen;
+            /* don't need to check for space - already done in storeAtts() */
+            while (*localPart)
+              *uri++ = *localPart++;
+            prefix = (XML_Char *)tag->name.prefix;
+            if (parser->m_ns_triplets && prefix) {
+              *uri++ = parser->m_namespaceSeparator;
+              while (*prefix)
+                *uri++ = *prefix++;
+            }
+            *uri = XML_T('\0');
+          }
+          parser->m_endElementHandler(parser->m_handlerArg, tag->name.str);
+        } else if (parser->m_defaultHandler)
+          reportDefault(parser, enc, s, next);
+        while (tag->bindings) {
+          BINDING *b = tag->bindings;
+          if (parser->m_endNamespaceDeclHandler)
+            parser->m_endNamespaceDeclHandler(parser->m_handlerArg,
+                                              b->prefix->name);
+          tag->bindings = tag->bindings->nextTagBinding;
+          b->nextTagBinding = parser->m_freeBindingList;
+          parser->m_freeBindingList = b;
+          b->prefix->binding = b->prevPrefixBinding;
+        }
+        if ((parser->m_tagLevel == 0)
+            && (parser->m_parsingStatus.parsing != XML_FINISHED)) {
+          if (parser->m_parsingStatus.parsing == XML_SUSPENDED)
+            parser->m_processor = epilogProcessor;
+          else
+            return epilogProcessor(parser, next, end, nextPtr);
+        }
+      }
+      break;
+    case XML_TOK_CHAR_REF: {
+      int n = XmlCharRefNumber(enc, s);
+      if (n < 0)
+        return XML_ERROR_BAD_CHAR_REF;
+      if (parser->m_characterDataHandler) {
+        XML_Char buf[XML_ENCODE_MAX];
+        parser->m_characterDataHandler(parser->m_handlerArg, buf,
+                                       XmlEncode(n, (ICHAR *)buf));
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+    } break;
+    case XML_TOK_XML_DECL:
+      return XML_ERROR_MISPLACED_XML_PI;
+    case XML_TOK_DATA_NEWLINE:
+      if (parser->m_characterDataHandler) {
+        XML_Char c = 0xA;
+        parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      break;
+    case XML_TOK_CDATA_SECT_OPEN: {
+      enum XML_Error result;
+      if (parser->m_startCdataSectionHandler)
+        parser->m_startCdataSectionHandler(parser->m_handlerArg);
+      /* BEGIN disabled code */
+      /* Suppose you doing a transformation on a document that involves
+         changing only the character data.  You set up a defaultHandler
+         and a characterDataHandler.  The defaultHandler simply copies
+         characters through.  The characterDataHandler does the
+         transformation and writes the characters out escaping them as
+         necessary.  This case will fail to work if we leave out the
+         following two lines (because & and < inside CDATA sections will
+         be incorrectly escaped).
+
+         However, now we have a start/endCdataSectionHandler, so it seems
+         easier to let the user deal with this.
+      */
+      else if (0 && parser->m_characterDataHandler)
+        parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,
+                                       0);
+      /* END disabled code */
+      else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      result
+          = doCdataSection(parser, enc, &next, end, nextPtr, haveMore, account);
+      if (result != XML_ERROR_NONE)
+        return result;
+      else if (! next) {
+        parser->m_processor = cdataSectionProcessor;
+        return result;
+      }
+    } break;
+    case XML_TOK_TRAILING_RSQB:
+      if (haveMore) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      if (parser->m_characterDataHandler) {
+        if (MUST_CONVERT(enc, s)) {
+          ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
+          XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
+          parser->m_characterDataHandler(
+              parser->m_handlerArg, parser->m_dataBuf,
+              (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
+        } else
+          parser->m_characterDataHandler(
+              parser->m_handlerArg, (XML_Char *)s,
+              (int)((XML_Char *)end - (XML_Char *)s));
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, end);
+      /* We are at the end of the final buffer, should we check for
+         XML_SUSPENDED, XML_FINISHED?
+      */
+      if (startTagLevel == 0) {
+        *eventPP = end;
+        return XML_ERROR_NO_ELEMENTS;
+      }
+      if (parser->m_tagLevel != startTagLevel) {
+        *eventPP = end;
+        return XML_ERROR_ASYNC_ENTITY;
+      }
+      *nextPtr = end;
+      return XML_ERROR_NONE;
+    case XML_TOK_DATA_CHARS: {
+      XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;
+      if (charDataHandler) {
+        if (MUST_CONVERT(enc, s)) {
+          for (;;) {
+            ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
+            const enum XML_Convert_Result convert_res = XmlConvert(
+                enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
+            *eventEndPP = s;
+            charDataHandler(parser->m_handlerArg, parser->m_dataBuf,
+                            (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
+            if ((convert_res == XML_CONVERT_COMPLETED)
+                || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
+              break;
+            *eventPP = s;
+          }
+        } else
+          charDataHandler(parser->m_handlerArg, (XML_Char *)s,
+                          (int)((XML_Char *)next - (XML_Char *)s));
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+    } break;
+    case XML_TOK_PI:
+      if (! reportProcessingInstruction(parser, enc, s, next))
+        return XML_ERROR_NO_MEMORY;
+      break;
+    case XML_TOK_COMMENT:
+      if (! reportComment(parser, enc, s, next))
+        return XML_ERROR_NO_MEMORY;
+      break;
+    default:
+      /* All of the tokens produced by XmlContentTok() have their own
+       * explicit cases, so this default is not strictly necessary.
+       * However it is a useful safety net, so we retain the code and
+       * simply exclude it from the coverage tests.
+       *
+       * LCOV_EXCL_START
+       */
+      if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      break;
+      /* LCOV_EXCL_STOP */
+    }
+    *eventPP = s = next;
+    switch (parser->m_parsingStatus.parsing) {
+    case XML_SUSPENDED:
+      *nextPtr = next;
+      return XML_ERROR_NONE;
+    case XML_FINISHED:
+      return XML_ERROR_ABORTED;
+    default:;
+    }
+  }
+  /* not reached */
+}
+
+/* This function does not call free() on the allocated memory, merely
+ * moving it to the parser's m_freeBindingList where it can be freed or
+ * reused as appropriate.
+ */
+static void
+freeBindings(XML_Parser parser, BINDING *bindings) {
+  while (bindings) {
+    BINDING *b = bindings;
+
+    /* m_startNamespaceDeclHandler will have been called for this
+     * binding in addBindings(), so call the end handler now.
+     */
+    if (parser->m_endNamespaceDeclHandler)
+      parser->m_endNamespaceDeclHandler(parser->m_handlerArg, b->prefix->name);
+
+    bindings = bindings->nextTagBinding;
+    b->nextTagBinding = parser->m_freeBindingList;
+    parser->m_freeBindingList = b;
+    b->prefix->binding = b->prevPrefixBinding;
+  }
+}
+
+/* Precondition: all arguments must be non-NULL;
+   Purpose:
+   - normalize attributes
+   - check attributes for well-formedness
+   - generate namespace aware attribute names (URI, prefix)
+   - build list of attributes for startElementHandler
+   - default attributes
+   - process namespace declarations (check and report them)
+   - generate namespace aware element name (URI, prefix)
+*/
+static enum XML_Error
+storeAtts(XML_Parser parser, const ENCODING *enc, const char *attStr,
+          TAG_NAME *tagNamePtr, BINDING **bindingsPtr,
+          enum XML_Account account) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  ELEMENT_TYPE *elementType;
+  int nDefaultAtts;
+  const XML_Char **appAtts; /* the attribute list for the application */
+  int attIndex = 0;
+  int prefixLen;
+  int i;
+  int n;
+  XML_Char *uri;
+  int nPrefixes = 0;
+  BINDING *binding;
+  const XML_Char *localPart;
+
+  /* lookup the element type name */
+  elementType
+      = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, tagNamePtr->str, 0);
+  if (! elementType) {
+    const XML_Char *name = poolCopyString(&dtd->pool, tagNamePtr->str);
+    if (! name)
+      return XML_ERROR_NO_MEMORY;
+    elementType = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
+                                         sizeof(ELEMENT_TYPE));
+    if (! elementType)
+      return XML_ERROR_NO_MEMORY;
+    if (parser->m_ns && ! setElementTypePrefix(parser, elementType))
+      return XML_ERROR_NO_MEMORY;
+  }
+  nDefaultAtts = elementType->nDefaultAtts;
+
+  /* get the attributes from the tokenizer */
+  n = XmlGetAttributes(enc, attStr, parser->m_attsSize, parser->m_atts);
+
+  /* Detect and prevent integer overflow */
+  if (n > INT_MAX - nDefaultAtts) {
+    return XML_ERROR_NO_MEMORY;
+  }
+
+  if (n + nDefaultAtts > parser->m_attsSize) {
+    int oldAttsSize = parser->m_attsSize;
+    ATTRIBUTE *temp;
+#ifdef XML_ATTR_INFO
+    XML_AttrInfo *temp2;
+#endif
+
+    /* Detect and prevent integer overflow */
+    if ((nDefaultAtts > INT_MAX - INIT_ATTS_SIZE)
+        || (n > INT_MAX - (nDefaultAtts + INIT_ATTS_SIZE))) {
+      return XML_ERROR_NO_MEMORY;
+    }
+
+    parser->m_attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
+
+    /* Detect and prevent integer overflow.
+     * The preprocessor guard addresses the "always false" warning
+     * from -Wtype-limits on platforms where
+     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+    if ((unsigned)parser->m_attsSize > (size_t)(-1) / sizeof(ATTRIBUTE)) {
+      parser->m_attsSize = oldAttsSize;
+      return XML_ERROR_NO_MEMORY;
+    }
+#endif
+
+    temp = (ATTRIBUTE *)REALLOC(parser, (void *)parser->m_atts,
+                                parser->m_attsSize * sizeof(ATTRIBUTE));
+    if (temp == NULL) {
+      parser->m_attsSize = oldAttsSize;
+      return XML_ERROR_NO_MEMORY;
+    }
+    parser->m_atts = temp;
+#ifdef XML_ATTR_INFO
+    /* Detect and prevent integer overflow.
+     * The preprocessor guard addresses the "always false" warning
+     * from -Wtype-limits on platforms where
+     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#  if UINT_MAX >= SIZE_MAX
+    if ((unsigned)parser->m_attsSize > (size_t)(-1) / sizeof(XML_AttrInfo)) {
+      parser->m_attsSize = oldAttsSize;
+      return XML_ERROR_NO_MEMORY;
+    }
+#  endif
+
+    temp2 = (XML_AttrInfo *)REALLOC(parser, (void *)parser->m_attInfo,
+                                    parser->m_attsSize * sizeof(XML_AttrInfo));
+    if (temp2 == NULL) {
+      parser->m_attsSize = oldAttsSize;
+      return XML_ERROR_NO_MEMORY;
+    }
+    parser->m_attInfo = temp2;
+#endif
+    if (n > oldAttsSize)
+      XmlGetAttributes(enc, attStr, n, parser->m_atts);
+  }
+
+  appAtts = (const XML_Char **)parser->m_atts;
+  for (i = 0; i < n; i++) {
+    ATTRIBUTE *currAtt = &parser->m_atts[i];
+#ifdef XML_ATTR_INFO
+    XML_AttrInfo *currAttInfo = &parser->m_attInfo[i];
+#endif
+    /* add the name and value to the attribute list */
+    ATTRIBUTE_ID *attId
+        = getAttributeId(parser, enc, currAtt->name,
+                         currAtt->name + XmlNameLength(enc, currAtt->name));
+    if (! attId)
+      return XML_ERROR_NO_MEMORY;
+#ifdef XML_ATTR_INFO
+    currAttInfo->nameStart
+        = parser->m_parseEndByteIndex - (parser->m_parseEndPtr - currAtt->name);
+    currAttInfo->nameEnd
+        = currAttInfo->nameStart + XmlNameLength(enc, currAtt->name);
+    currAttInfo->valueStart = parser->m_parseEndByteIndex
+                              - (parser->m_parseEndPtr - currAtt->valuePtr);
+    currAttInfo->valueEnd = parser->m_parseEndByteIndex
+                            - (parser->m_parseEndPtr - currAtt->valueEnd);
+#endif
+    /* Detect duplicate attributes by their QNames. This does not work when
+       namespace processing is turned on and different prefixes for the same
+       namespace are used. For this case we have a check further down.
+    */
+    if ((attId->name)[-1]) {
+      if (enc == parser->m_encoding)
+        parser->m_eventPtr = parser->m_atts[i].name;
+      return XML_ERROR_DUPLICATE_ATTRIBUTE;
+    }
+    (attId->name)[-1] = 1;
+    appAtts[attIndex++] = attId->name;
+    if (! parser->m_atts[i].normalized) {
+      enum XML_Error result;
+      XML_Bool isCdata = XML_TRUE;
+
+      /* figure out whether declared as other than CDATA */
+      if (attId->maybeTokenized) {
+        int j;
+        for (j = 0; j < nDefaultAtts; j++) {
+          if (attId == elementType->defaultAtts[j].id) {
+            isCdata = elementType->defaultAtts[j].isCdata;
+            break;
+          }
+        }
+      }
+
+      /* normalize the attribute value */
+      result = storeAttributeValue(
+          parser, enc, isCdata, parser->m_atts[i].valuePtr,
+          parser->m_atts[i].valueEnd, &parser->m_tempPool, account);
+      if (result)
+        return result;
+      appAtts[attIndex] = poolStart(&parser->m_tempPool);
+      poolFinish(&parser->m_tempPool);
+    } else {
+      /* the value did not need normalizing */
+      appAtts[attIndex] = poolStoreString(&parser->m_tempPool, enc,
+                                          parser->m_atts[i].valuePtr,
+                                          parser->m_atts[i].valueEnd);
+      if (appAtts[attIndex] == 0)
+        return XML_ERROR_NO_MEMORY;
+      poolFinish(&parser->m_tempPool);
+    }
+    /* handle prefixed attribute names */
+    if (attId->prefix) {
+      if (attId->xmlns) {
+        /* deal with namespace declarations here */
+        enum XML_Error result = addBinding(parser, attId->prefix, attId,
+                                           appAtts[attIndex], bindingsPtr);
+        if (result)
+          return result;
+        --attIndex;
+      } else {
+        /* deal with other prefixed names later */
+        attIndex++;
+        nPrefixes++;
+        (attId->name)[-1] = 2;
+      }
+    } else
+      attIndex++;
+  }
+
+  /* set-up for XML_GetSpecifiedAttributeCount and XML_GetIdAttributeIndex */
+  parser->m_nSpecifiedAtts = attIndex;
+  if (elementType->idAtt && (elementType->idAtt->name)[-1]) {
+    for (i = 0; i < attIndex; i += 2)
+      if (appAtts[i] == elementType->idAtt->name) {
+        parser->m_idAttIndex = i;
+        break;
+      }
+  } else
+    parser->m_idAttIndex = -1;
+
+  /* do attribute defaulting */
+  for (i = 0; i < nDefaultAtts; i++) {
+    const DEFAULT_ATTRIBUTE *da = elementType->defaultAtts + i;
+    if (! (da->id->name)[-1] && da->value) {
+      if (da->id->prefix) {
+        if (da->id->xmlns) {
+          enum XML_Error result = addBinding(parser, da->id->prefix, da->id,
+                                             da->value, bindingsPtr);
+          if (result)
+            return result;
+        } else {
+          (da->id->name)[-1] = 2;
+          nPrefixes++;
+          appAtts[attIndex++] = da->id->name;
+          appAtts[attIndex++] = da->value;
+        }
+      } else {
+        (da->id->name)[-1] = 1;
+        appAtts[attIndex++] = da->id->name;
+        appAtts[attIndex++] = da->value;
+      }
+    }
+  }
+  appAtts[attIndex] = 0;
+
+  /* expand prefixed attribute names, check for duplicates,
+     and clear flags that say whether attributes were specified */
+  i = 0;
+  if (nPrefixes) {
+    int j; /* hash table index */
+    unsigned long version = parser->m_nsAttsVersion;
+
+    /* Detect and prevent invalid shift */
+    if (parser->m_nsAttsPower >= sizeof(unsigned int) * 8 /* bits per byte */) {
+      return XML_ERROR_NO_MEMORY;
+    }
+
+    unsigned int nsAttsSize = 1u << parser->m_nsAttsPower;
+    unsigned char oldNsAttsPower = parser->m_nsAttsPower;
+    /* size of hash table must be at least 2 * (# of prefixed attributes) */
+    if ((nPrefixes << 1)
+        >> parser->m_nsAttsPower) { /* true for m_nsAttsPower = 0 */
+      NS_ATT *temp;
+      /* hash table size must also be a power of 2 and >= 8 */
+      while (nPrefixes >> parser->m_nsAttsPower++)
+        ;
+      if (parser->m_nsAttsPower < 3)
+        parser->m_nsAttsPower = 3;
+
+      /* Detect and prevent invalid shift */
+      if (parser->m_nsAttsPower >= sizeof(nsAttsSize) * 8 /* bits per byte */) {
+        /* Restore actual size of memory in m_nsAtts */
+        parser->m_nsAttsPower = oldNsAttsPower;
+        return XML_ERROR_NO_MEMORY;
+      }
+
+      nsAttsSize = 1u << parser->m_nsAttsPower;
+
+      /* Detect and prevent integer overflow.
+       * The preprocessor guard addresses the "always false" warning
+       * from -Wtype-limits on platforms where
+       * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+      if (nsAttsSize > (size_t)(-1) / sizeof(NS_ATT)) {
+        /* Restore actual size of memory in m_nsAtts */
+        parser->m_nsAttsPower = oldNsAttsPower;
+        return XML_ERROR_NO_MEMORY;
+      }
+#endif
+
+      temp = (NS_ATT *)REALLOC(parser, parser->m_nsAtts,
+                               nsAttsSize * sizeof(NS_ATT));
+      if (! temp) {
+        /* Restore actual size of memory in m_nsAtts */
+        parser->m_nsAttsPower = oldNsAttsPower;
+        return XML_ERROR_NO_MEMORY;
+      }
+      parser->m_nsAtts = temp;
+      version = 0; /* force re-initialization of m_nsAtts hash table */
+    }
+    /* using a version flag saves us from initializing m_nsAtts every time */
+    if (! version) { /* initialize version flags when version wraps around */
+      version = INIT_ATTS_VERSION;
+      for (j = nsAttsSize; j != 0;)
+        parser->m_nsAtts[--j].version = version;
+    }
+    parser->m_nsAttsVersion = --version;
+
+    /* expand prefixed names and check for duplicates */
+    for (; i < attIndex; i += 2) {
+      const XML_Char *s = appAtts[i];
+      if (s[-1] == 2) { /* prefixed */
+        ATTRIBUTE_ID *id;
+        const BINDING *b;
+        unsigned long uriHash;
+        struct siphash sip_state;
+        struct sipkey sip_key;
+
+        copy_salt_to_sipkey(parser, &sip_key);
+        sip24_init(&sip_state, &sip_key);
+
+        ((XML_Char *)s)[-1] = 0; /* clear flag */
+        id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, s, 0);
+        if (! id || ! id->prefix) {
+          /* This code is walking through the appAtts array, dealing
+           * with (in this case) a prefixed attribute name.  To be in
+           * the array, the attribute must have already been bound, so
+           * has to have passed through the hash table lookup once
+           * already.  That implies that an entry for it already
+           * exists, so the lookup above will return a pointer to
+           * already allocated memory.  There is no opportunaity for
+           * the allocator to fail, so the condition above cannot be
+           * fulfilled.
+           *
+           * Since it is difficult to be certain that the above
+           * analysis is complete, we retain the test and merely
+           * remove the code from coverage tests.
+           */
+          return XML_ERROR_NO_MEMORY; /* LCOV_EXCL_LINE */
+        }
+        b = id->prefix->binding;
+        if (! b)
+          return XML_ERROR_UNBOUND_PREFIX;
+
+        for (j = 0; j < b->uriLen; j++) {
+          const XML_Char c = b->uri[j];
+          if (! poolAppendChar(&parser->m_tempPool, c))
+            return XML_ERROR_NO_MEMORY;
+        }
+
+        sip24_update(&sip_state, b->uri, b->uriLen * sizeof(XML_Char));
+
+        while (*s++ != XML_T(ASCII_COLON))
+          ;
+
+        sip24_update(&sip_state, s, keylen(s) * sizeof(XML_Char));
+
+        do { /* copies null terminator */
+          if (! poolAppendChar(&parser->m_tempPool, *s))
+            return XML_ERROR_NO_MEMORY;
+        } while (*s++);
+
+        uriHash = (unsigned long)sip24_final(&sip_state);
+
+        { /* Check hash table for duplicate of expanded name (uriName).
+             Derived from code in lookup(parser, HASH_TABLE *table, ...).
+          */
+          unsigned char step = 0;
+          unsigned long mask = nsAttsSize - 1;
+          j = uriHash & mask; /* index into hash table */
+          while (parser->m_nsAtts[j].version == version) {
+            /* for speed we compare stored hash values first */
+            if (uriHash == parser->m_nsAtts[j].hash) {
+              const XML_Char *s1 = poolStart(&parser->m_tempPool);
+              const XML_Char *s2 = parser->m_nsAtts[j].uriName;
+              /* s1 is null terminated, but not s2 */
+              for (; *s1 == *s2 && *s1 != 0; s1++, s2++)
+                ;
+              if (*s1 == 0)
+                return XML_ERROR_DUPLICATE_ATTRIBUTE;
+            }
+            if (! step)
+              step = PROBE_STEP(uriHash, mask, parser->m_nsAttsPower);
+            j < step ? (j += nsAttsSize - step) : (j -= step);
+          }
+        }
+
+        if (parser->m_ns_triplets) { /* append namespace separator and prefix */
+          parser->m_tempPool.ptr[-1] = parser->m_namespaceSeparator;
+          s = b->prefix->name;
+          do {
+            if (! poolAppendChar(&parser->m_tempPool, *s))
+              return XML_ERROR_NO_MEMORY;
+          } while (*s++);
+        }
+
+        /* store expanded name in attribute list */
+        s = poolStart(&parser->m_tempPool);
+        poolFinish(&parser->m_tempPool);
+        appAtts[i] = s;
+
+        /* fill empty slot with new version, uriName and hash value */
+        parser->m_nsAtts[j].version = version;
+        parser->m_nsAtts[j].hash = uriHash;
+        parser->m_nsAtts[j].uriName = s;
+
+        if (! --nPrefixes) {
+          i += 2;
+          break;
+        }
+      } else                     /* not prefixed */
+        ((XML_Char *)s)[-1] = 0; /* clear flag */
+    }
+  }
+  /* clear flags for the remaining attributes */
+  for (; i < attIndex; i += 2)
+    ((XML_Char *)(appAtts[i]))[-1] = 0;
+  for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding)
+    binding->attId->name[-1] = 0;
+
+  if (! parser->m_ns)
+    return XML_ERROR_NONE;
+
+  /* expand the element type name */
+  if (elementType->prefix) {
+    binding = elementType->prefix->binding;
+    if (! binding)
+      return XML_ERROR_UNBOUND_PREFIX;
+    localPart = tagNamePtr->str;
+    while (*localPart++ != XML_T(ASCII_COLON))
+      ;
+  } else if (dtd->defaultPrefix.binding) {
+    binding = dtd->defaultPrefix.binding;
+    localPart = tagNamePtr->str;
+  } else
+    return XML_ERROR_NONE;
+  prefixLen = 0;
+  if (parser->m_ns_triplets && binding->prefix->name) {
+    for (; binding->prefix->name[prefixLen++];)
+      ; /* prefixLen includes null terminator */
+  }
+  tagNamePtr->localPart = localPart;
+  tagNamePtr->uriLen = binding->uriLen;
+  tagNamePtr->prefix = binding->prefix->name;
+  tagNamePtr->prefixLen = prefixLen;
+  for (i = 0; localPart[i++];)
+    ; /* i includes null terminator */
+
+  /* Detect and prevent integer overflow */
+  if (binding->uriLen > INT_MAX - prefixLen
+      || i > INT_MAX - (binding->uriLen + prefixLen)) {
+    return XML_ERROR_NO_MEMORY;
+  }
+
+  n = i + binding->uriLen + prefixLen;
+  if (n > binding->uriAlloc) {
+    TAG *p;
+
+    /* Detect and prevent integer overflow */
+    if (n > INT_MAX - EXPAND_SPARE) {
+      return XML_ERROR_NO_MEMORY;
+    }
+    /* Detect and prevent integer overflow.
+     * The preprocessor guard addresses the "always false" warning
+     * from -Wtype-limits on platforms where
+     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+    if ((unsigned)(n + EXPAND_SPARE) > (size_t)(-1) / sizeof(XML_Char)) {
+      return XML_ERROR_NO_MEMORY;
+    }
+#endif
+
+    uri = (XML_Char *)MALLOC(parser, (n + EXPAND_SPARE) * sizeof(XML_Char));
+    if (! uri)
+      return XML_ERROR_NO_MEMORY;
+    binding->uriAlloc = n + EXPAND_SPARE;
+    memcpy(uri, binding->uri, binding->uriLen * sizeof(XML_Char));
+    for (p = parser->m_tagStack; p; p = p->parent)
+      if (p->name.str == binding->uri)
+        p->name.str = uri;
+    FREE(parser, binding->uri);
+    binding->uri = uri;
+  }
+  /* if m_namespaceSeparator != '\0' then uri includes it already */
+  uri = binding->uri + binding->uriLen;
+  memcpy(uri, localPart, i * sizeof(XML_Char));
+  /* we always have a namespace separator between localPart and prefix */
+  if (prefixLen) {
+    uri += i - 1;
+    *uri = parser->m_namespaceSeparator; /* replace null terminator */
+    memcpy(uri + 1, binding->prefix->name, prefixLen * sizeof(XML_Char));
+  }
+  tagNamePtr->str = binding->uri;
+  return XML_ERROR_NONE;
+}
+
+static XML_Bool
+is_rfc3986_uri_char(XML_Char candidate) {
+  // For the RFC 3986 ANBF grammar see
+  // https://datatracker.ietf.org/doc/html/rfc3986#appendix-A
+
+  switch (candidate) {
+  // From rule "ALPHA" (uppercase half)
+  case 'A':
+  case 'B':
+  case 'C':
+  case 'D':
+  case 'E':
+  case 'F':
+  case 'G':
+  case 'H':
+  case 'I':
+  case 'J':
+  case 'K':
+  case 'L':
+  case 'M':
+  case 'N':
+  case 'O':
+  case 'P':
+  case 'Q':
+  case 'R':
+  case 'S':
+  case 'T':
+  case 'U':
+  case 'V':
+  case 'W':
+  case 'X':
+  case 'Y':
+  case 'Z':
+
+  // From rule "ALPHA" (lowercase half)
+  case 'a':
+  case 'b':
+  case 'c':
+  case 'd':
+  case 'e':
+  case 'f':
+  case 'g':
+  case 'h':
+  case 'i':
+  case 'j':
+  case 'k':
+  case 'l':
+  case 'm':
+  case 'n':
+  case 'o':
+  case 'p':
+  case 'q':
+  case 'r':
+  case 's':
+  case 't':
+  case 'u':
+  case 'v':
+  case 'w':
+  case 'x':
+  case 'y':
+  case 'z':
+
+  // From rule "DIGIT"
+  case '0':
+  case '1':
+  case '2':
+  case '3':
+  case '4':
+  case '5':
+  case '6':
+  case '7':
+  case '8':
+  case '9':
+
+  // From rule "pct-encoded"
+  case '%':
+
+  // From rule "unreserved"
+  case '-':
+  case '.':
+  case '_':
+  case '~':
+
+  // From rule "gen-delims"
+  case ':':
+  case '/':
+  case '?':
+  case '#':
+  case '[':
+  case ']':
+  case '@':
+
+  // From rule "sub-delims"
+  case '!':
+  case '$':
+  case '&':
+  case '\'':
+  case '(':
+  case ')':
+  case '*':
+  case '+':
+  case ',':
+  case ';':
+  case '=':
+    return XML_TRUE;
+
+  default:
+    return XML_FALSE;
+  }
+}
+
+/* addBinding() overwrites the value of prefix->binding without checking.
+   Therefore one must keep track of the old value outside of addBinding().
+*/
+static enum XML_Error
+addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
+           const XML_Char *uri, BINDING **bindingsPtr) {
+  // "http://www.w3.org/XML/1998/namespace"
+  static const XML_Char xmlNamespace[]
+      = {ASCII_h,      ASCII_t,     ASCII_t,     ASCII_p,      ASCII_COLON,
+         ASCII_SLASH,  ASCII_SLASH, ASCII_w,     ASCII_w,      ASCII_w,
+         ASCII_PERIOD, ASCII_w,     ASCII_3,     ASCII_PERIOD, ASCII_o,
+         ASCII_r,      ASCII_g,     ASCII_SLASH, ASCII_X,      ASCII_M,
+         ASCII_L,      ASCII_SLASH, ASCII_1,     ASCII_9,      ASCII_9,
+         ASCII_8,      ASCII_SLASH, ASCII_n,     ASCII_a,      ASCII_m,
+         ASCII_e,      ASCII_s,     ASCII_p,     ASCII_a,      ASCII_c,
+         ASCII_e,      '\0'};
+  static const int xmlLen = (int)sizeof(xmlNamespace) / sizeof(XML_Char) - 1;
+  // "http://www.w3.org/2000/xmlns/"
+  static const XML_Char xmlnsNamespace[]
+      = {ASCII_h,     ASCII_t,      ASCII_t, ASCII_p, ASCII_COLON,  ASCII_SLASH,
+         ASCII_SLASH, ASCII_w,      ASCII_w, ASCII_w, ASCII_PERIOD, ASCII_w,
+         ASCII_3,     ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g,      ASCII_SLASH,
+         ASCII_2,     ASCII_0,      ASCII_0, ASCII_0, ASCII_SLASH,  ASCII_x,
+         ASCII_m,     ASCII_l,      ASCII_n, ASCII_s, ASCII_SLASH,  '\0'};
+  static const int xmlnsLen
+      = (int)sizeof(xmlnsNamespace) / sizeof(XML_Char) - 1;
+
+  XML_Bool mustBeXML = XML_FALSE;
+  XML_Bool isXML = XML_TRUE;
+  XML_Bool isXMLNS = XML_TRUE;
+
+  BINDING *b;
+  int len;
+
+  /* empty URI is only valid for default namespace per XML NS 1.0 (not 1.1) */
+  if (*uri == XML_T('\0') && prefix->name)
+    return XML_ERROR_UNDECLARING_PREFIX;
+
+  if (prefix->name && prefix->name[0] == XML_T(ASCII_x)
+      && prefix->name[1] == XML_T(ASCII_m)
+      && prefix->name[2] == XML_T(ASCII_l)) {
+    /* Not allowed to bind xmlns */
+    if (prefix->name[3] == XML_T(ASCII_n) && prefix->name[4] == XML_T(ASCII_s)
+        && prefix->name[5] == XML_T('\0'))
+      return XML_ERROR_RESERVED_PREFIX_XMLNS;
+
+    if (prefix->name[3] == XML_T('\0'))
+      mustBeXML = XML_TRUE;
+  }
+
+  for (len = 0; uri[len]; len++) {
+    if (isXML && (len > xmlLen || uri[len] != xmlNamespace[len]))
+      isXML = XML_FALSE;
+
+    if (! mustBeXML && isXMLNS
+        && (len > xmlnsLen || uri[len] != xmlnsNamespace[len]))
+      isXMLNS = XML_FALSE;
+
+    // NOTE: While Expat does not validate namespace URIs against RFC 3986
+    //       today (and is not REQUIRED to do so with regard to the XML 1.0
+    //       namespaces specification) we have to at least make sure, that
+    //       the application on top of Expat (that is likely splitting expanded
+    //       element names ("qualified names") of form
+    //       "[uri sep] local [sep prefix] '\0'" back into 1, 2 or 3 pieces
+    //       in its element handler code) cannot be confused by an attacker
+    //       putting additional namespace separator characters into namespace
+    //       declarations.  That would be ambiguous and not to be expected.
+    //
+    //       While the HTML API docs of function XML_ParserCreateNS have been
+    //       advising against use of a namespace separator character that can
+    //       appear in a URI for >20 years now, some widespread applications
+    //       are using URI characters (':' (colon) in particular) for a
+    //       namespace separator, in practice.  To keep these applications
+    //       functional, we only reject namespaces URIs containing the
+    //       application-chosen namespace separator if the chosen separator
+    //       is a non-URI character with regard to RFC 3986.
+    if (parser->m_ns && (uri[len] == parser->m_namespaceSeparator)
+        && ! is_rfc3986_uri_char(uri[len])) {
+      return XML_ERROR_SYNTAX;
+    }
+  }
+  isXML = isXML && len == xmlLen;
+  isXMLNS = isXMLNS && len == xmlnsLen;
+
+  if (mustBeXML != isXML)
+    return mustBeXML ? XML_ERROR_RESERVED_PREFIX_XML
+                     : XML_ERROR_RESERVED_NAMESPACE_URI;
+
+  if (isXMLNS)
+    return XML_ERROR_RESERVED_NAMESPACE_URI;
+
+  if (parser->m_namespaceSeparator)
+    len++;
+  if (parser->m_freeBindingList) {
+    b = parser->m_freeBindingList;
+    if (len > b->uriAlloc) {
+      /* Detect and prevent integer overflow */
+      if (len > INT_MAX - EXPAND_SPARE) {
+        return XML_ERROR_NO_MEMORY;
+      }
+
+      /* Detect and prevent integer overflow.
+       * The preprocessor guard addresses the "always false" warning
+       * from -Wtype-limits on platforms where
+       * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+      if ((unsigned)(len + EXPAND_SPARE) > (size_t)(-1) / sizeof(XML_Char)) {
+        return XML_ERROR_NO_MEMORY;
+      }
+#endif
+
+      XML_Char *temp = (XML_Char *)REALLOC(
+          parser, b->uri, sizeof(XML_Char) * (len + EXPAND_SPARE));
+      if (temp == NULL)
+        return XML_ERROR_NO_MEMORY;
+      b->uri = temp;
+      b->uriAlloc = len + EXPAND_SPARE;
+    }
+    parser->m_freeBindingList = b->nextTagBinding;
+  } else {
+    b = (BINDING *)MALLOC(parser, sizeof(BINDING));
+    if (! b)
+      return XML_ERROR_NO_MEMORY;
+
+    /* Detect and prevent integer overflow */
+    if (len > INT_MAX - EXPAND_SPARE) {
+      return XML_ERROR_NO_MEMORY;
+    }
+    /* Detect and prevent integer overflow.
+     * The preprocessor guard addresses the "always false" warning
+     * from -Wtype-limits on platforms where
+     * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+    if ((unsigned)(len + EXPAND_SPARE) > (size_t)(-1) / sizeof(XML_Char)) {
+      return XML_ERROR_NO_MEMORY;
+    }
+#endif
+
+    b->uri
+        = (XML_Char *)MALLOC(parser, sizeof(XML_Char) * (len + EXPAND_SPARE));
+    if (! b->uri) {
+      FREE(parser, b);
+      return XML_ERROR_NO_MEMORY;
+    }
+    b->uriAlloc = len + EXPAND_SPARE;
+  }
+  b->uriLen = len;
+  memcpy(b->uri, uri, len * sizeof(XML_Char));
+  if (parser->m_namespaceSeparator)
+    b->uri[len - 1] = parser->m_namespaceSeparator;
+  b->prefix = prefix;
+  b->attId = attId;
+  b->prevPrefixBinding = prefix->binding;
+  /* NULL binding when default namespace undeclared */
+  if (*uri == XML_T('\0') && prefix == &parser->m_dtd->defaultPrefix)
+    prefix->binding = NULL;
+  else
+    prefix->binding = b;
+  b->nextTagBinding = *bindingsPtr;
+  *bindingsPtr = b;
+  /* if attId == NULL then we are not starting a namespace scope */
+  if (attId && parser->m_startNamespaceDeclHandler)
+    parser->m_startNamespaceDeclHandler(parser->m_handlerArg, prefix->name,
+                                        prefix->binding ? uri : 0);
+  return XML_ERROR_NONE;
+}
+
+/* The idea here is to avoid using stack for each CDATA section when
+   the whole file is parsed with one call.
+*/
+static enum XML_Error PTRCALL
+cdataSectionProcessor(XML_Parser parser, const char *start, const char *end,
+                      const char **endPtr) {
+  enum XML_Error result = doCdataSection(
+      parser, parser->m_encoding, &start, end, endPtr,
+      (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_ACCOUNT_DIRECT);
+  if (result != XML_ERROR_NONE)
+    return result;
+  if (start) {
+    if (parser->m_parentParser) { /* we are parsing an external entity */
+      parser->m_processor = externalEntityContentProcessor;
+      return externalEntityContentProcessor(parser, start, end, endPtr);
+    } else {
+      parser->m_processor = contentProcessor;
+      return contentProcessor(parser, start, end, endPtr);
+    }
+  }
+  return result;
+}
+
+/* startPtr gets set to non-null if the section is closed, and to null if
+   the section is not yet closed.
+*/
+static enum XML_Error
+doCdataSection(XML_Parser parser, const ENCODING *enc, const char **startPtr,
+               const char *end, const char **nextPtr, XML_Bool haveMore,
+               enum XML_Account account) {
+  const char *s = *startPtr;
+  const char **eventPP;
+  const char **eventEndPP;
+  if (enc == parser->m_encoding) {
+    eventPP = &parser->m_eventPtr;
+    *eventPP = s;
+    eventEndPP = &parser->m_eventEndPtr;
+  } else {
+    eventPP = &(parser->m_openInternalEntities->internalEventPtr);
+    eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
+  }
+  *eventPP = s;
+  *startPtr = NULL;
+
+  for (;;) {
+    const char *next = s; /* in case of XML_TOK_NONE or XML_TOK_PARTIAL */
+    int tok = XmlCdataSectionTok(enc, s, end, &next);
+#ifdef XML_DTD
+    if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) {
+      accountingOnAbort(parser);
+      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+    }
+#else
+    UNUSED_P(account);
+#endif
+    *eventEndPP = next;
+    switch (tok) {
+    case XML_TOK_CDATA_SECT_CLOSE:
+      if (parser->m_endCdataSectionHandler)
+        parser->m_endCdataSectionHandler(parser->m_handlerArg);
+      /* BEGIN disabled code */
+      /* see comment under XML_TOK_CDATA_SECT_OPEN */
+      else if (0 && parser->m_characterDataHandler)
+        parser->m_characterDataHandler(parser->m_handlerArg, parser->m_dataBuf,
+                                       0);
+      /* END disabled code */
+      else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      *startPtr = next;
+      *nextPtr = next;
+      if (parser->m_parsingStatus.parsing == XML_FINISHED)
+        return XML_ERROR_ABORTED;
+      else
+        return XML_ERROR_NONE;
+    case XML_TOK_DATA_NEWLINE:
+      if (parser->m_characterDataHandler) {
+        XML_Char c = 0xA;
+        parser->m_characterDataHandler(parser->m_handlerArg, &c, 1);
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      break;
+    case XML_TOK_DATA_CHARS: {
+      XML_CharacterDataHandler charDataHandler = parser->m_characterDataHandler;
+      if (charDataHandler) {
+        if (MUST_CONVERT(enc, s)) {
+          for (;;) {
+            ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
+            const enum XML_Convert_Result convert_res = XmlConvert(
+                enc, &s, next, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
+            *eventEndPP = next;
+            charDataHandler(parser->m_handlerArg, parser->m_dataBuf,
+                            (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
+            if ((convert_res == XML_CONVERT_COMPLETED)
+                || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
+              break;
+            *eventPP = s;
+          }
+        } else
+          charDataHandler(parser->m_handlerArg, (XML_Char *)s,
+                          (int)((XML_Char *)next - (XML_Char *)s));
+      } else if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+    } break;
+    case XML_TOK_INVALID:
+      *eventPP = next;
+      return XML_ERROR_INVALID_TOKEN;
+    case XML_TOK_PARTIAL_CHAR:
+      if (haveMore) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      return XML_ERROR_PARTIAL_CHAR;
+    case XML_TOK_PARTIAL:
+    case XML_TOK_NONE:
+      if (haveMore) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      return XML_ERROR_UNCLOSED_CDATA_SECTION;
+    default:
+      /* Every token returned by XmlCdataSectionTok() has its own
+       * explicit case, so this default case will never be executed.
+       * We retain it as a safety net and exclude it from the coverage
+       * statistics.
+       *
+       * LCOV_EXCL_START
+       */
+      *eventPP = next;
+      return XML_ERROR_UNEXPECTED_STATE;
+      /* LCOV_EXCL_STOP */
+    }
+
+    *eventPP = s = next;
+    switch (parser->m_parsingStatus.parsing) {
+    case XML_SUSPENDED:
+      *nextPtr = next;
+      return XML_ERROR_NONE;
+    case XML_FINISHED:
+      return XML_ERROR_ABORTED;
+    default:;
+    }
+  }
+  /* not reached */
+}
+
+#ifdef XML_DTD
+
+/* The idea here is to avoid using stack for each IGNORE section when
+   the whole file is parsed with one call.
+*/
+static enum XML_Error PTRCALL
+ignoreSectionProcessor(XML_Parser parser, const char *start, const char *end,
+                       const char **endPtr) {
+  enum XML_Error result
+      = doIgnoreSection(parser, parser->m_encoding, &start, end, endPtr,
+                        (XML_Bool)! parser->m_parsingStatus.finalBuffer);
+  if (result != XML_ERROR_NONE)
+    return result;
+  if (start) {
+    parser->m_processor = prologProcessor;
+    return prologProcessor(parser, start, end, endPtr);
+  }
+  return result;
+}
+
+/* startPtr gets set to non-null is the section is closed, and to null
+   if the section is not yet closed.
+*/
+static enum XML_Error
+doIgnoreSection(XML_Parser parser, const ENCODING *enc, const char **startPtr,
+                const char *end, const char **nextPtr, XML_Bool haveMore) {
+  const char *next = *startPtr; /* in case of XML_TOK_NONE or XML_TOK_PARTIAL */
+  int tok;
+  const char *s = *startPtr;
+  const char **eventPP;
+  const char **eventEndPP;
+  if (enc == parser->m_encoding) {
+    eventPP = &parser->m_eventPtr;
+    *eventPP = s;
+    eventEndPP = &parser->m_eventEndPtr;
+  } else {
+    /* It's not entirely clear, but it seems the following two lines
+     * of code cannot be executed.  The only occasions on which 'enc'
+     * is not 'encoding' are when this function is called
+     * from the internal entity processing, and IGNORE sections are an
+     * error in internal entities.
+     *
+     * Since it really isn't clear that this is true, we keep the code
+     * and just remove it from our coverage tests.
+     *
+     * LCOV_EXCL_START
+     */
+    eventPP = &(parser->m_openInternalEntities->internalEventPtr);
+    eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
+    /* LCOV_EXCL_STOP */
+  }
+  *eventPP = s;
+  *startPtr = NULL;
+  tok = XmlIgnoreSectionTok(enc, s, end, &next);
+#  ifdef XML_DTD
+  if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
+                                XML_ACCOUNT_DIRECT)) {
+    accountingOnAbort(parser);
+    return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+  }
+#  endif
+  *eventEndPP = next;
+  switch (tok) {
+  case XML_TOK_IGNORE_SECT:
+    if (parser->m_defaultHandler)
+      reportDefault(parser, enc, s, next);
+    *startPtr = next;
+    *nextPtr = next;
+    if (parser->m_parsingStatus.parsing == XML_FINISHED)
+      return XML_ERROR_ABORTED;
+    else
+      return XML_ERROR_NONE;
+  case XML_TOK_INVALID:
+    *eventPP = next;
+    return XML_ERROR_INVALID_TOKEN;
+  case XML_TOK_PARTIAL_CHAR:
+    if (haveMore) {
+      *nextPtr = s;
+      return XML_ERROR_NONE;
+    }
+    return XML_ERROR_PARTIAL_CHAR;
+  case XML_TOK_PARTIAL:
+  case XML_TOK_NONE:
+    if (haveMore) {
+      *nextPtr = s;
+      return XML_ERROR_NONE;
+    }
+    return XML_ERROR_SYNTAX; /* XML_ERROR_UNCLOSED_IGNORE_SECTION */
+  default:
+    /* All of the tokens that XmlIgnoreSectionTok() returns have
+     * explicit cases to handle them, so this default case is never
+     * executed.  We keep it as a safety net anyway, and remove it
+     * from our test coverage statistics.
+     *
+     * LCOV_EXCL_START
+     */
+    *eventPP = next;
+    return XML_ERROR_UNEXPECTED_STATE;
+    /* LCOV_EXCL_STOP */
+  }
+  /* not reached */
+}
+
+#endif /* XML_DTD */
+
+static enum XML_Error
+initializeEncoding(XML_Parser parser) {
+  const char *s;
+#ifdef XML_UNICODE
+  char encodingBuf[128];
+  /* See comments about `protocolEncodingName` in parserInit() */
+  if (! parser->m_protocolEncodingName)
+    s = NULL;
+  else {
+    int i;
+    for (i = 0; parser->m_protocolEncodingName[i]; i++) {
+      if (i == sizeof(encodingBuf) - 1
+          || (parser->m_protocolEncodingName[i] & ~0x7f) != 0) {
+        encodingBuf[0] = '\0';
+        break;
+      }
+      encodingBuf[i] = (char)parser->m_protocolEncodingName[i];
+    }
+    encodingBuf[i] = '\0';
+    s = encodingBuf;
+  }
+#else
+  s = parser->m_protocolEncodingName;
+#endif
+  if ((parser->m_ns ? XmlInitEncodingNS : XmlInitEncoding)(
+          &parser->m_initEncoding, &parser->m_encoding, s))
+    return XML_ERROR_NONE;
+  return handleUnknownEncoding(parser, parser->m_protocolEncodingName);
+}
+
+static enum XML_Error
+processXmlDecl(XML_Parser parser, int isGeneralTextEntity, const char *s,
+               const char *next) {
+  const char *encodingName = NULL;
+  const XML_Char *storedEncName = NULL;
+  const ENCODING *newEncoding = NULL;
+  const char *version = NULL;
+  const char *versionend;
+  const XML_Char *storedversion = NULL;
+  int standalone = -1;
+
+#ifdef XML_DTD
+  if (! accountingDiffTolerated(parser, XML_TOK_XML_DECL, s, next, __LINE__,
+                                XML_ACCOUNT_DIRECT)) {
+    accountingOnAbort(parser);
+    return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+  }
+#endif
+
+  if (! (parser->m_ns ? XmlParseXmlDeclNS : XmlParseXmlDecl)(
+          isGeneralTextEntity, parser->m_encoding, s, next, &parser->m_eventPtr,
+          &version, &versionend, &encodingName, &newEncoding, &standalone)) {
+    if (isGeneralTextEntity)
+      return XML_ERROR_TEXT_DECL;
+    else
+      return XML_ERROR_XML_DECL;
+  }
+  if (! isGeneralTextEntity && standalone == 1) {
+    parser->m_dtd->standalone = XML_TRUE;
+#ifdef XML_DTD
+    if (parser->m_paramEntityParsing
+        == XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)
+      parser->m_paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
+#endif /* XML_DTD */
+  }
+  if (parser->m_xmlDeclHandler) {
+    if (encodingName != NULL) {
+      storedEncName = poolStoreString(
+          &parser->m_temp2Pool, parser->m_encoding, encodingName,
+          encodingName + XmlNameLength(parser->m_encoding, encodingName));
+      if (! storedEncName)
+        return XML_ERROR_NO_MEMORY;
+      poolFinish(&parser->m_temp2Pool);
+    }
+    if (version) {
+      storedversion
+          = poolStoreString(&parser->m_temp2Pool, parser->m_encoding, version,
+                            versionend - parser->m_encoding->minBytesPerChar);
+      if (! storedversion)
+        return XML_ERROR_NO_MEMORY;
+    }
+    parser->m_xmlDeclHandler(parser->m_handlerArg, storedversion, storedEncName,
+                             standalone);
+  } else if (parser->m_defaultHandler)
+    reportDefault(parser, parser->m_encoding, s, next);
+  if (parser->m_protocolEncodingName == NULL) {
+    if (newEncoding) {
+      /* Check that the specified encoding does not conflict with what
+       * the parser has already deduced.  Do we have the same number
+       * of bytes in the smallest representation of a character?  If
+       * this is UTF-16, is it the same endianness?
+       */
+      if (newEncoding->minBytesPerChar != parser->m_encoding->minBytesPerChar
+          || (newEncoding->minBytesPerChar == 2
+              && newEncoding != parser->m_encoding)) {
+        parser->m_eventPtr = encodingName;
+        return XML_ERROR_INCORRECT_ENCODING;
+      }
+      parser->m_encoding = newEncoding;
+    } else if (encodingName) {
+      enum XML_Error result;
+      if (! storedEncName) {
+        storedEncName = poolStoreString(
+            &parser->m_temp2Pool, parser->m_encoding, encodingName,
+            encodingName + XmlNameLength(parser->m_encoding, encodingName));
+        if (! storedEncName)
+          return XML_ERROR_NO_MEMORY;
+      }
+      result = handleUnknownEncoding(parser, storedEncName);
+      poolClear(&parser->m_temp2Pool);
+      if (result == XML_ERROR_UNKNOWN_ENCODING)
+        parser->m_eventPtr = encodingName;
+      return result;
+    }
+  }
+
+  if (storedEncName || storedversion)
+    poolClear(&parser->m_temp2Pool);
+
+  return XML_ERROR_NONE;
+}
+
+static enum XML_Error
+handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName) {
+  if (parser->m_unknownEncodingHandler) {
+    XML_Encoding info;
+    int i;
+    for (i = 0; i < 256; i++)
+      info.map[i] = -1;
+    info.convert = NULL;
+    info.data = NULL;
+    info.release = NULL;
+    if (parser->m_unknownEncodingHandler(parser->m_unknownEncodingHandlerData,
+                                         encodingName, &info)) {
+      ENCODING *enc;
+      parser->m_unknownEncodingMem = MALLOC(parser, XmlSizeOfUnknownEncoding());
+      if (! parser->m_unknownEncodingMem) {
+        if (info.release)
+          info.release(info.data);
+        return XML_ERROR_NO_MEMORY;
+      }
+      enc = (parser->m_ns ? XmlInitUnknownEncodingNS : XmlInitUnknownEncoding)(
+          parser->m_unknownEncodingMem, info.map, info.convert, info.data);
+      if (enc) {
+        parser->m_unknownEncodingData = info.data;
+        parser->m_unknownEncodingRelease = info.release;
+        parser->m_encoding = enc;
+        return XML_ERROR_NONE;
+      }
+    }
+    if (info.release != NULL)
+      info.release(info.data);
+  }
+  return XML_ERROR_UNKNOWN_ENCODING;
+}
+
+static enum XML_Error PTRCALL
+prologInitProcessor(XML_Parser parser, const char *s, const char *end,
+                    const char **nextPtr) {
+  enum XML_Error result = initializeEncoding(parser);
+  if (result != XML_ERROR_NONE)
+    return result;
+  parser->m_processor = prologProcessor;
+  return prologProcessor(parser, s, end, nextPtr);
+}
+
+#ifdef XML_DTD
+
+static enum XML_Error PTRCALL
+externalParEntInitProcessor(XML_Parser parser, const char *s, const char *end,
+                            const char **nextPtr) {
+  enum XML_Error result = initializeEncoding(parser);
+  if (result != XML_ERROR_NONE)
+    return result;
+
+  /* we know now that XML_Parse(Buffer) has been called,
+     so we consider the external parameter entity read */
+  parser->m_dtd->paramEntityRead = XML_TRUE;
+
+  if (parser->m_prologState.inEntityValue) {
+    parser->m_processor = entityValueInitProcessor;
+    return entityValueInitProcessor(parser, s, end, nextPtr);
+  } else {
+    parser->m_processor = externalParEntProcessor;
+    return externalParEntProcessor(parser, s, end, nextPtr);
+  }
+}
+
+static enum XML_Error PTRCALL
+entityValueInitProcessor(XML_Parser parser, const char *s, const char *end,
+                         const char **nextPtr) {
+  int tok;
+  const char *start = s;
+  const char *next = start;
+  parser->m_eventPtr = start;
+
+  for (;;) {
+    tok = XmlPrologTok(parser->m_encoding, start, end, &next);
+    /* Note: Except for XML_TOK_BOM below, these bytes are accounted later in:
+             - storeEntityValue
+             - processXmlDecl
+    */
+    parser->m_eventEndPtr = next;
+    if (tok <= 0) {
+      if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      switch (tok) {
+      case XML_TOK_INVALID:
+        return XML_ERROR_INVALID_TOKEN;
+      case XML_TOK_PARTIAL:
+        return XML_ERROR_UNCLOSED_TOKEN;
+      case XML_TOK_PARTIAL_CHAR:
+        return XML_ERROR_PARTIAL_CHAR;
+      case XML_TOK_NONE: /* start == end */
+      default:
+        break;
+      }
+      /* found end of entity value - can store it now */
+      return storeEntityValue(parser, parser->m_encoding, s, end,
+                              XML_ACCOUNT_DIRECT);
+    } else if (tok == XML_TOK_XML_DECL) {
+      enum XML_Error result;
+      result = processXmlDecl(parser, 0, start, next);
+      if (result != XML_ERROR_NONE)
+        return result;
+      /* At this point, m_parsingStatus.parsing cannot be XML_SUSPENDED.  For
+       * that to happen, a parameter entity parsing handler must have attempted
+       * to suspend the parser, which fails and raises an error.  The parser can
+       * be aborted, but can't be suspended.
+       */
+      if (parser->m_parsingStatus.parsing == XML_FINISHED)
+        return XML_ERROR_ABORTED;
+      *nextPtr = next;
+      /* stop scanning for text declaration - we found one */
+      parser->m_processor = entityValueProcessor;
+      return entityValueProcessor(parser, next, end, nextPtr);
+    }
+    /* If we are at the end of the buffer, this would cause XmlPrologTok to
+       return XML_TOK_NONE on the next call, which would then cause the
+       function to exit with *nextPtr set to s - that is what we want for other
+       tokens, but not for the BOM - we would rather like to skip it;
+       then, when this routine is entered the next time, XmlPrologTok will
+       return XML_TOK_INVALID, since the BOM is still in the buffer
+    */
+    else if (tok == XML_TOK_BOM && next == end
+             && ! parser->m_parsingStatus.finalBuffer) {
+#  ifdef XML_DTD
+      if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
+                                    XML_ACCOUNT_DIRECT)) {
+        accountingOnAbort(parser);
+        return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+      }
+#  endif
+
+      *nextPtr = next;
+      return XML_ERROR_NONE;
+    }
+    /* If we get this token, we have the start of what might be a
+       normal tag, but not a declaration (i.e. it doesn't begin with
+       "<!").  In a DTD context, that isn't legal.
+    */
+    else if (tok == XML_TOK_INSTANCE_START) {
+      *nextPtr = next;
+      return XML_ERROR_SYNTAX;
+    }
+    start = next;
+    parser->m_eventPtr = start;
+  }
+}
+
+static enum XML_Error PTRCALL
+externalParEntProcessor(XML_Parser parser, const char *s, const char *end,
+                        const char **nextPtr) {
+  const char *next = s;
+  int tok;
+
+  tok = XmlPrologTok(parser->m_encoding, s, end, &next);
+  if (tok <= 0) {
+    if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
+      *nextPtr = s;
+      return XML_ERROR_NONE;
+    }
+    switch (tok) {
+    case XML_TOK_INVALID:
+      return XML_ERROR_INVALID_TOKEN;
+    case XML_TOK_PARTIAL:
+      return XML_ERROR_UNCLOSED_TOKEN;
+    case XML_TOK_PARTIAL_CHAR:
+      return XML_ERROR_PARTIAL_CHAR;
+    case XML_TOK_NONE: /* start == end */
+    default:
+      break;
+    }
+  }
+  /* This would cause the next stage, i.e. doProlog to be passed XML_TOK_BOM.
+     However, when parsing an external subset, doProlog will not accept a BOM
+     as valid, and report a syntax error, so we have to skip the BOM, and
+     account for the BOM bytes.
+  */
+  else if (tok == XML_TOK_BOM) {
+    if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
+                                  XML_ACCOUNT_DIRECT)) {
+      accountingOnAbort(parser);
+      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+    }
+
+    s = next;
+    tok = XmlPrologTok(parser->m_encoding, s, end, &next);
+  }
+
+  parser->m_processor = prologProcessor;
+  return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
+                  (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,
+                  XML_ACCOUNT_DIRECT);
+}
+
+static enum XML_Error PTRCALL
+entityValueProcessor(XML_Parser parser, const char *s, const char *end,
+                     const char **nextPtr) {
+  const char *start = s;
+  const char *next = s;
+  const ENCODING *enc = parser->m_encoding;
+  int tok;
+
+  for (;;) {
+    tok = XmlPrologTok(enc, start, end, &next);
+    /* Note: These bytes are accounted later in:
+             - storeEntityValue
+    */
+    if (tok <= 0) {
+      if (! parser->m_parsingStatus.finalBuffer && tok != XML_TOK_INVALID) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      switch (tok) {
+      case XML_TOK_INVALID:
+        return XML_ERROR_INVALID_TOKEN;
+      case XML_TOK_PARTIAL:
+        return XML_ERROR_UNCLOSED_TOKEN;
+      case XML_TOK_PARTIAL_CHAR:
+        return XML_ERROR_PARTIAL_CHAR;
+      case XML_TOK_NONE: /* start == end */
+      default:
+        break;
+      }
+      /* found end of entity value - can store it now */
+      return storeEntityValue(parser, enc, s, end, XML_ACCOUNT_DIRECT);
+    }
+    start = next;
+  }
+}
+
+#endif /* XML_DTD */
+
+static enum XML_Error PTRCALL
+prologProcessor(XML_Parser parser, const char *s, const char *end,
+                const char **nextPtr) {
+  const char *next = s;
+  int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
+  return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
+                  (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,
+                  XML_ACCOUNT_DIRECT);
+}
+
+static enum XML_Error
+doProlog(XML_Parser parser, const ENCODING *enc, const char *s, const char *end,
+         int tok, const char *next, const char **nextPtr, XML_Bool haveMore,
+         XML_Bool allowClosingDoctype, enum XML_Account account) {
+#ifdef XML_DTD
+  static const XML_Char externalSubsetName[] = {ASCII_HASH, '\0'};
+#endif /* XML_DTD */
+  static const XML_Char atypeCDATA[]
+      = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
+  static const XML_Char atypeID[] = {ASCII_I, ASCII_D, '\0'};
+  static const XML_Char atypeIDREF[]
+      = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0'};
+  static const XML_Char atypeIDREFS[]
+      = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0'};
+  static const XML_Char atypeENTITY[]
+      = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0'};
+  static const XML_Char atypeENTITIES[]
+      = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T,
+         ASCII_I, ASCII_E, ASCII_S, '\0'};
+  static const XML_Char atypeNMTOKEN[]
+      = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0'};
+  static const XML_Char atypeNMTOKENS[]
+      = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K,
+         ASCII_E, ASCII_N, ASCII_S, '\0'};
+  static const XML_Char notationPrefix[]
+      = {ASCII_N, ASCII_O, ASCII_T, ASCII_A,      ASCII_T,
+         ASCII_I, ASCII_O, ASCII_N, ASCII_LPAREN, '\0'};
+  static const XML_Char enumValueSep[] = {ASCII_PIPE, '\0'};
+  static const XML_Char enumValueStart[] = {ASCII_LPAREN, '\0'};
+
+#ifndef XML_DTD
+  UNUSED_P(account);
+#endif
+
+  /* save one level of indirection */
+  DTD *const dtd = parser->m_dtd;
+
+  const char **eventPP;
+  const char **eventEndPP;
+  enum XML_Content_Quant quant;
+
+  if (enc == parser->m_encoding) {
+    eventPP = &parser->m_eventPtr;
+    eventEndPP = &parser->m_eventEndPtr;
+  } else {
+    eventPP = &(parser->m_openInternalEntities->internalEventPtr);
+    eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
+  }
+
+  for (;;) {
+    int role;
+    XML_Bool handleDefault = XML_TRUE;
+    *eventPP = s;
+    *eventEndPP = next;
+    if (tok <= 0) {
+      if (haveMore && tok != XML_TOK_INVALID) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      switch (tok) {
+      case XML_TOK_INVALID:
+        *eventPP = next;
+        return XML_ERROR_INVALID_TOKEN;
+      case XML_TOK_PARTIAL:
+        return XML_ERROR_UNCLOSED_TOKEN;
+      case XML_TOK_PARTIAL_CHAR:
+        return XML_ERROR_PARTIAL_CHAR;
+      case -XML_TOK_PROLOG_S:
+        tok = -tok;
+        break;
+      case XML_TOK_NONE:
+#ifdef XML_DTD
+        /* for internal PE NOT referenced between declarations */
+        if (enc != parser->m_encoding
+            && ! parser->m_openInternalEntities->betweenDecl) {
+          *nextPtr = s;
+          return XML_ERROR_NONE;
+        }
+        /* WFC: PE Between Declarations - must check that PE contains
+           complete markup, not only for external PEs, but also for
+           internal PEs if the reference occurs between declarations.
+        */
+        if (parser->m_isParamEntity || enc != parser->m_encoding) {
+          if (XmlTokenRole(&parser->m_prologState, XML_TOK_NONE, end, end, enc)
+              == XML_ROLE_ERROR)
+            return XML_ERROR_INCOMPLETE_PE;
+          *nextPtr = s;
+          return XML_ERROR_NONE;
+        }
+#endif /* XML_DTD */
+        return XML_ERROR_NO_ELEMENTS;
+      default:
+        tok = -tok;
+        next = end;
+        break;
+      }
+    }
+    role = XmlTokenRole(&parser->m_prologState, tok, s, next, enc);
+#ifdef XML_DTD
+    switch (role) {
+    case XML_ROLE_INSTANCE_START: // bytes accounted in contentProcessor
+    case XML_ROLE_XML_DECL:       // bytes accounted in processXmlDecl
+    case XML_ROLE_TEXT_DECL:      // bytes accounted in processXmlDecl
+      break;
+    default:
+      if (! accountingDiffTolerated(parser, tok, s, next, __LINE__, account)) {
+        accountingOnAbort(parser);
+        return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+      }
+    }
+#endif
+    switch (role) {
+    case XML_ROLE_XML_DECL: {
+      enum XML_Error result = processXmlDecl(parser, 0, s, next);
+      if (result != XML_ERROR_NONE)
+        return result;
+      enc = parser->m_encoding;
+      handleDefault = XML_FALSE;
+    } break;
+    case XML_ROLE_DOCTYPE_NAME:
+      if (parser->m_startDoctypeDeclHandler) {
+        parser->m_doctypeName
+            = poolStoreString(&parser->m_tempPool, enc, s, next);
+        if (! parser->m_doctypeName)
+          return XML_ERROR_NO_MEMORY;
+        poolFinish(&parser->m_tempPool);
+        parser->m_doctypePubid = NULL;
+        handleDefault = XML_FALSE;
+      }
+      parser->m_doctypeSysid = NULL; /* always initialize to NULL */
+      break;
+    case XML_ROLE_DOCTYPE_INTERNAL_SUBSET:
+      if (parser->m_startDoctypeDeclHandler) {
+        parser->m_startDoctypeDeclHandler(
+            parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,
+            parser->m_doctypePubid, 1);
+        parser->m_doctypeName = NULL;
+        poolClear(&parser->m_tempPool);
+        handleDefault = XML_FALSE;
+      }
+      break;
+#ifdef XML_DTD
+    case XML_ROLE_TEXT_DECL: {
+      enum XML_Error result = processXmlDecl(parser, 1, s, next);
+      if (result != XML_ERROR_NONE)
+        return result;
+      enc = parser->m_encoding;
+      handleDefault = XML_FALSE;
+    } break;
+#endif /* XML_DTD */
+    case XML_ROLE_DOCTYPE_PUBLIC_ID:
+#ifdef XML_DTD
+      parser->m_useForeignDTD = XML_FALSE;
+      parser->m_declEntity = (ENTITY *)lookup(
+          parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));
+      if (! parser->m_declEntity)
+        return XML_ERROR_NO_MEMORY;
+#endif /* XML_DTD */
+      dtd->hasParamEntityRefs = XML_TRUE;
+      if (parser->m_startDoctypeDeclHandler) {
+        XML_Char *pubId;
+        if (! XmlIsPublicId(enc, s, next, eventPP))
+          return XML_ERROR_PUBLICID;
+        pubId = poolStoreString(&parser->m_tempPool, enc,
+                                s + enc->minBytesPerChar,
+                                next - enc->minBytesPerChar);
+        if (! pubId)
+          return XML_ERROR_NO_MEMORY;
+        normalizePublicId(pubId);
+        poolFinish(&parser->m_tempPool);
+        parser->m_doctypePubid = pubId;
+        handleDefault = XML_FALSE;
+        goto alreadyChecked;
+      }
+      /* fall through */
+    case XML_ROLE_ENTITY_PUBLIC_ID:
+      if (! XmlIsPublicId(enc, s, next, eventPP))
+        return XML_ERROR_PUBLICID;
+    alreadyChecked:
+      if (dtd->keepProcessing && parser->m_declEntity) {
+        XML_Char *tem
+            = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
+                              next - enc->minBytesPerChar);
+        if (! tem)
+          return XML_ERROR_NO_MEMORY;
+        normalizePublicId(tem);
+        parser->m_declEntity->publicId = tem;
+        poolFinish(&dtd->pool);
+        /* Don't suppress the default handler if we fell through from
+         * the XML_ROLE_DOCTYPE_PUBLIC_ID case.
+         */
+        if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_PUBLIC_ID)
+          handleDefault = XML_FALSE;
+      }
+      break;
+    case XML_ROLE_DOCTYPE_CLOSE:
+      if (allowClosingDoctype != XML_TRUE) {
+        /* Must not close doctype from within expanded parameter entities */
+        return XML_ERROR_INVALID_TOKEN;
+      }
+
+      if (parser->m_doctypeName) {
+        parser->m_startDoctypeDeclHandler(
+            parser->m_handlerArg, parser->m_doctypeName, parser->m_doctypeSysid,
+            parser->m_doctypePubid, 0);
+        poolClear(&parser->m_tempPool);
+        handleDefault = XML_FALSE;
+      }
+      /* parser->m_doctypeSysid will be non-NULL in the case of a previous
+         XML_ROLE_DOCTYPE_SYSTEM_ID, even if parser->m_startDoctypeDeclHandler
+         was not set, indicating an external subset
+      */
+#ifdef XML_DTD
+      if (parser->m_doctypeSysid || parser->m_useForeignDTD) {
+        XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
+        dtd->hasParamEntityRefs = XML_TRUE;
+        if (parser->m_paramEntityParsing
+            && parser->m_externalEntityRefHandler) {
+          ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
+                                            externalSubsetName, sizeof(ENTITY));
+          if (! entity) {
+            /* The external subset name "#" will have already been
+             * inserted into the hash table at the start of the
+             * external entity parsing, so no allocation will happen
+             * and lookup() cannot fail.
+             */
+            return XML_ERROR_NO_MEMORY; /* LCOV_EXCL_LINE */
+          }
+          if (parser->m_useForeignDTD)
+            entity->base = parser->m_curBase;
+          dtd->paramEntityRead = XML_FALSE;
+          if (! parser->m_externalEntityRefHandler(
+                  parser->m_externalEntityRefHandlerArg, 0, entity->base,
+                  entity->systemId, entity->publicId))
+            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+          if (dtd->paramEntityRead) {
+            if (! dtd->standalone && parser->m_notStandaloneHandler
+                && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
+              return XML_ERROR_NOT_STANDALONE;
+          }
+          /* if we didn't read the foreign DTD then this means that there
+             is no external subset and we must reset dtd->hasParamEntityRefs
+          */
+          else if (! parser->m_doctypeSysid)
+            dtd->hasParamEntityRefs = hadParamEntityRefs;
+          /* end of DTD - no need to update dtd->keepProcessing */
+        }
+        parser->m_useForeignDTD = XML_FALSE;
+      }
+#endif /* XML_DTD */
+      if (parser->m_endDoctypeDeclHandler) {
+        parser->m_endDoctypeDeclHandler(parser->m_handlerArg);
+        handleDefault = XML_FALSE;
+      }
+      break;
+    case XML_ROLE_INSTANCE_START:
+#ifdef XML_DTD
+      /* if there is no DOCTYPE declaration then now is the
+         last chance to read the foreign DTD
+      */
+      if (parser->m_useForeignDTD) {
+        XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
+        dtd->hasParamEntityRefs = XML_TRUE;
+        if (parser->m_paramEntityParsing
+            && parser->m_externalEntityRefHandler) {
+          ENTITY *entity = (ENTITY *)lookup(parser, &dtd->paramEntities,
+                                            externalSubsetName, sizeof(ENTITY));
+          if (! entity)
+            return XML_ERROR_NO_MEMORY;
+          entity->base = parser->m_curBase;
+          dtd->paramEntityRead = XML_FALSE;
+          if (! parser->m_externalEntityRefHandler(
+                  parser->m_externalEntityRefHandlerArg, 0, entity->base,
+                  entity->systemId, entity->publicId))
+            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+          if (dtd->paramEntityRead) {
+            if (! dtd->standalone && parser->m_notStandaloneHandler
+                && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
+              return XML_ERROR_NOT_STANDALONE;
+          }
+          /* if we didn't read the foreign DTD then this means that there
+             is no external subset and we must reset dtd->hasParamEntityRefs
+          */
+          else
+            dtd->hasParamEntityRefs = hadParamEntityRefs;
+          /* end of DTD - no need to update dtd->keepProcessing */
+        }
+      }
+#endif /* XML_DTD */
+      parser->m_processor = contentProcessor;
+      return contentProcessor(parser, s, end, nextPtr);
+    case XML_ROLE_ATTLIST_ELEMENT_NAME:
+      parser->m_declElementType = getElementType(parser, enc, s, next);
+      if (! parser->m_declElementType)
+        return XML_ERROR_NO_MEMORY;
+      goto checkAttListDeclHandler;
+    case XML_ROLE_ATTRIBUTE_NAME:
+      parser->m_declAttributeId = getAttributeId(parser, enc, s, next);
+      if (! parser->m_declAttributeId)
+        return XML_ERROR_NO_MEMORY;
+      parser->m_declAttributeIsCdata = XML_FALSE;
+      parser->m_declAttributeType = NULL;
+      parser->m_declAttributeIsId = XML_FALSE;
+      goto checkAttListDeclHandler;
+    case XML_ROLE_ATTRIBUTE_TYPE_CDATA:
+      parser->m_declAttributeIsCdata = XML_TRUE;
+      parser->m_declAttributeType = atypeCDATA;
+      goto checkAttListDeclHandler;
+    case XML_ROLE_ATTRIBUTE_TYPE_ID:
+      parser->m_declAttributeIsId = XML_TRUE;
+      parser->m_declAttributeType = atypeID;
+      goto checkAttListDeclHandler;
+    case XML_ROLE_ATTRIBUTE_TYPE_IDREF:
+      parser->m_declAttributeType = atypeIDREF;
+      goto checkAttListDeclHandler;
+    case XML_ROLE_ATTRIBUTE_TYPE_IDREFS:
+      parser->m_declAttributeType = atypeIDREFS;
+      goto checkAttListDeclHandler;
+    case XML_ROLE_ATTRIBUTE_TYPE_ENTITY:
+      parser->m_declAttributeType = atypeENTITY;
+      goto checkAttListDeclHandler;
+    case XML_ROLE_ATTRIBUTE_TYPE_ENTITIES:
+      parser->m_declAttributeType = atypeENTITIES;
+      goto checkAttListDeclHandler;
+    case XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN:
+      parser->m_declAttributeType = atypeNMTOKEN;
+      goto checkAttListDeclHandler;
+    case XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS:
+      parser->m_declAttributeType = atypeNMTOKENS;
+    checkAttListDeclHandler:
+      if (dtd->keepProcessing && parser->m_attlistDeclHandler)
+        handleDefault = XML_FALSE;
+      break;
+    case XML_ROLE_ATTRIBUTE_ENUM_VALUE:
+    case XML_ROLE_ATTRIBUTE_NOTATION_VALUE:
+      if (dtd->keepProcessing && parser->m_attlistDeclHandler) {
+        const XML_Char *prefix;
+        if (parser->m_declAttributeType) {
+          prefix = enumValueSep;
+        } else {
+          prefix = (role == XML_ROLE_ATTRIBUTE_NOTATION_VALUE ? notationPrefix
+                                                              : enumValueStart);
+        }
+        if (! poolAppendString(&parser->m_tempPool, prefix))
+          return XML_ERROR_NO_MEMORY;
+        if (! poolAppend(&parser->m_tempPool, enc, s, next))
+          return XML_ERROR_NO_MEMORY;
+        parser->m_declAttributeType = parser->m_tempPool.start;
+        handleDefault = XML_FALSE;
+      }
+      break;
+    case XML_ROLE_IMPLIED_ATTRIBUTE_VALUE:
+    case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE:
+      if (dtd->keepProcessing) {
+        if (! defineAttribute(parser->m_declElementType,
+                              parser->m_declAttributeId,
+                              parser->m_declAttributeIsCdata,
+                              parser->m_declAttributeIsId, 0, parser))
+          return XML_ERROR_NO_MEMORY;
+        if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {
+          if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN)
+              || (*parser->m_declAttributeType == XML_T(ASCII_N)
+                  && parser->m_declAttributeType[1] == XML_T(ASCII_O))) {
+            /* Enumerated or Notation type */
+            if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))
+                || ! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
+              return XML_ERROR_NO_MEMORY;
+            parser->m_declAttributeType = parser->m_tempPool.start;
+            poolFinish(&parser->m_tempPool);
+          }
+          *eventEndPP = s;
+          parser->m_attlistDeclHandler(
+              parser->m_handlerArg, parser->m_declElementType->name,
+              parser->m_declAttributeId->name, parser->m_declAttributeType, 0,
+              role == XML_ROLE_REQUIRED_ATTRIBUTE_VALUE);
+          poolClear(&parser->m_tempPool);
+          handleDefault = XML_FALSE;
+        }
+      }
+      break;
+    case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:
+    case XML_ROLE_FIXED_ATTRIBUTE_VALUE:
+      if (dtd->keepProcessing) {
+        const XML_Char *attVal;
+        enum XML_Error result = storeAttributeValue(
+            parser, enc, parser->m_declAttributeIsCdata,
+            s + enc->minBytesPerChar, next - enc->minBytesPerChar, &dtd->pool,
+            XML_ACCOUNT_NONE);
+        if (result)
+          return result;
+        attVal = poolStart(&dtd->pool);
+        poolFinish(&dtd->pool);
+        /* ID attributes aren't allowed to have a default */
+        if (! defineAttribute(
+                parser->m_declElementType, parser->m_declAttributeId,
+                parser->m_declAttributeIsCdata, XML_FALSE, attVal, parser))
+          return XML_ERROR_NO_MEMORY;
+        if (parser->m_attlistDeclHandler && parser->m_declAttributeType) {
+          if (*parser->m_declAttributeType == XML_T(ASCII_LPAREN)
+              || (*parser->m_declAttributeType == XML_T(ASCII_N)
+                  && parser->m_declAttributeType[1] == XML_T(ASCII_O))) {
+            /* Enumerated or Notation type */
+            if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_RPAREN))
+                || ! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
+              return XML_ERROR_NO_MEMORY;
+            parser->m_declAttributeType = parser->m_tempPool.start;
+            poolFinish(&parser->m_tempPool);
+          }
+          *eventEndPP = s;
+          parser->m_attlistDeclHandler(
+              parser->m_handlerArg, parser->m_declElementType->name,
+              parser->m_declAttributeId->name, parser->m_declAttributeType,
+              attVal, role == XML_ROLE_FIXED_ATTRIBUTE_VALUE);
+          poolClear(&parser->m_tempPool);
+          handleDefault = XML_FALSE;
+        }
+      }
+      break;
+    case XML_ROLE_ENTITY_VALUE:
+      if (dtd->keepProcessing) {
+        enum XML_Error result
+            = storeEntityValue(parser, enc, s + enc->minBytesPerChar,
+                               next - enc->minBytesPerChar, XML_ACCOUNT_NONE);
+        if (parser->m_declEntity) {
+          parser->m_declEntity->textPtr = poolStart(&dtd->entityValuePool);
+          parser->m_declEntity->textLen
+              = (int)(poolLength(&dtd->entityValuePool));
+          poolFinish(&dtd->entityValuePool);
+          if (parser->m_entityDeclHandler) {
+            *eventEndPP = s;
+            parser->m_entityDeclHandler(
+                parser->m_handlerArg, parser->m_declEntity->name,
+                parser->m_declEntity->is_param, parser->m_declEntity->textPtr,
+                parser->m_declEntity->textLen, parser->m_curBase, 0, 0, 0);
+            handleDefault = XML_FALSE;
+          }
+        } else
+          poolDiscard(&dtd->entityValuePool);
+        if (result != XML_ERROR_NONE)
+          return result;
+      }
+      break;
+    case XML_ROLE_DOCTYPE_SYSTEM_ID:
+#ifdef XML_DTD
+      parser->m_useForeignDTD = XML_FALSE;
+#endif /* XML_DTD */
+      dtd->hasParamEntityRefs = XML_TRUE;
+      if (parser->m_startDoctypeDeclHandler) {
+        parser->m_doctypeSysid = poolStoreString(&parser->m_tempPool, enc,
+                                                 s + enc->minBytesPerChar,
+                                                 next - enc->minBytesPerChar);
+        if (parser->m_doctypeSysid == NULL)
+          return XML_ERROR_NO_MEMORY;
+        poolFinish(&parser->m_tempPool);
+        handleDefault = XML_FALSE;
+      }
+#ifdef XML_DTD
+      else
+        /* use externalSubsetName to make parser->m_doctypeSysid non-NULL
+           for the case where no parser->m_startDoctypeDeclHandler is set */
+        parser->m_doctypeSysid = externalSubsetName;
+#endif /* XML_DTD */
+      if (! dtd->standalone
+#ifdef XML_DTD
+          && ! parser->m_paramEntityParsing
+#endif /* XML_DTD */
+          && parser->m_notStandaloneHandler
+          && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
+        return XML_ERROR_NOT_STANDALONE;
+#ifndef XML_DTD
+      break;
+#else  /* XML_DTD */
+      if (! parser->m_declEntity) {
+        parser->m_declEntity = (ENTITY *)lookup(
+            parser, &dtd->paramEntities, externalSubsetName, sizeof(ENTITY));
+        if (! parser->m_declEntity)
+          return XML_ERROR_NO_MEMORY;
+        parser->m_declEntity->publicId = NULL;
+      }
+#endif /* XML_DTD */
+      /* fall through */
+    case XML_ROLE_ENTITY_SYSTEM_ID:
+      if (dtd->keepProcessing && parser->m_declEntity) {
+        parser->m_declEntity->systemId
+            = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
+                              next - enc->minBytesPerChar);
+        if (! parser->m_declEntity->systemId)
+          return XML_ERROR_NO_MEMORY;
+        parser->m_declEntity->base = parser->m_curBase;
+        poolFinish(&dtd->pool);
+        /* Don't suppress the default handler if we fell through from
+         * the XML_ROLE_DOCTYPE_SYSTEM_ID case.
+         */
+        if (parser->m_entityDeclHandler && role == XML_ROLE_ENTITY_SYSTEM_ID)
+          handleDefault = XML_FALSE;
+      }
+      break;
+    case XML_ROLE_ENTITY_COMPLETE:
+      if (dtd->keepProcessing && parser->m_declEntity
+          && parser->m_entityDeclHandler) {
+        *eventEndPP = s;
+        parser->m_entityDeclHandler(
+            parser->m_handlerArg, parser->m_declEntity->name,
+            parser->m_declEntity->is_param, 0, 0, parser->m_declEntity->base,
+            parser->m_declEntity->systemId, parser->m_declEntity->publicId, 0);
+        handleDefault = XML_FALSE;
+      }
+      break;
+    case XML_ROLE_ENTITY_NOTATION_NAME:
+      if (dtd->keepProcessing && parser->m_declEntity) {
+        parser->m_declEntity->notation
+            = poolStoreString(&dtd->pool, enc, s, next);
+        if (! parser->m_declEntity->notation)
+          return XML_ERROR_NO_MEMORY;
+        poolFinish(&dtd->pool);
+        if (parser->m_unparsedEntityDeclHandler) {
+          *eventEndPP = s;
+          parser->m_unparsedEntityDeclHandler(
+              parser->m_handlerArg, parser->m_declEntity->name,
+              parser->m_declEntity->base, parser->m_declEntity->systemId,
+              parser->m_declEntity->publicId, parser->m_declEntity->notation);
+          handleDefault = XML_FALSE;
+        } else if (parser->m_entityDeclHandler) {
+          *eventEndPP = s;
+          parser->m_entityDeclHandler(
+              parser->m_handlerArg, parser->m_declEntity->name, 0, 0, 0,
+              parser->m_declEntity->base, parser->m_declEntity->systemId,
+              parser->m_declEntity->publicId, parser->m_declEntity->notation);
+          handleDefault = XML_FALSE;
+        }
+      }
+      break;
+    case XML_ROLE_GENERAL_ENTITY_NAME: {
+      if (XmlPredefinedEntityName(enc, s, next)) {
+        parser->m_declEntity = NULL;
+        break;
+      }
+      if (dtd->keepProcessing) {
+        const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
+        if (! name)
+          return XML_ERROR_NO_MEMORY;
+        parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->generalEntities,
+                                                name, sizeof(ENTITY));
+        if (! parser->m_declEntity)
+          return XML_ERROR_NO_MEMORY;
+        if (parser->m_declEntity->name != name) {
+          poolDiscard(&dtd->pool);
+          parser->m_declEntity = NULL;
+        } else {
+          poolFinish(&dtd->pool);
+          parser->m_declEntity->publicId = NULL;
+          parser->m_declEntity->is_param = XML_FALSE;
+          /* if we have a parent parser or are reading an internal parameter
+             entity, then the entity declaration is not considered "internal"
+          */
+          parser->m_declEntity->is_internal
+              = ! (parser->m_parentParser || parser->m_openInternalEntities);
+          if (parser->m_entityDeclHandler)
+            handleDefault = XML_FALSE;
+        }
+      } else {
+        poolDiscard(&dtd->pool);
+        parser->m_declEntity = NULL;
+      }
+    } break;
+    case XML_ROLE_PARAM_ENTITY_NAME:
+#ifdef XML_DTD
+      if (dtd->keepProcessing) {
+        const XML_Char *name = poolStoreString(&dtd->pool, enc, s, next);
+        if (! name)
+          return XML_ERROR_NO_MEMORY;
+        parser->m_declEntity = (ENTITY *)lookup(parser, &dtd->paramEntities,
+                                                name, sizeof(ENTITY));
+        if (! parser->m_declEntity)
+          return XML_ERROR_NO_MEMORY;
+        if (parser->m_declEntity->name != name) {
+          poolDiscard(&dtd->pool);
+          parser->m_declEntity = NULL;
+        } else {
+          poolFinish(&dtd->pool);
+          parser->m_declEntity->publicId = NULL;
+          parser->m_declEntity->is_param = XML_TRUE;
+          /* if we have a parent parser or are reading an internal parameter
+             entity, then the entity declaration is not considered "internal"
+          */
+          parser->m_declEntity->is_internal
+              = ! (parser->m_parentParser || parser->m_openInternalEntities);
+          if (parser->m_entityDeclHandler)
+            handleDefault = XML_FALSE;
+        }
+      } else {
+        poolDiscard(&dtd->pool);
+        parser->m_declEntity = NULL;
+      }
+#else  /* not XML_DTD */
+      parser->m_declEntity = NULL;
+#endif /* XML_DTD */
+      break;
+    case XML_ROLE_NOTATION_NAME:
+      parser->m_declNotationPublicId = NULL;
+      parser->m_declNotationName = NULL;
+      if (parser->m_notationDeclHandler) {
+        parser->m_declNotationName
+            = poolStoreString(&parser->m_tempPool, enc, s, next);
+        if (! parser->m_declNotationName)
+          return XML_ERROR_NO_MEMORY;
+        poolFinish(&parser->m_tempPool);
+        handleDefault = XML_FALSE;
+      }
+      break;
+    case XML_ROLE_NOTATION_PUBLIC_ID:
+      if (! XmlIsPublicId(enc, s, next, eventPP))
+        return XML_ERROR_PUBLICID;
+      if (parser
+              ->m_declNotationName) { /* means m_notationDeclHandler != NULL */
+        XML_Char *tem = poolStoreString(&parser->m_tempPool, enc,
+                                        s + enc->minBytesPerChar,
+                                        next - enc->minBytesPerChar);
+        if (! tem)
+          return XML_ERROR_NO_MEMORY;
+        normalizePublicId(tem);
+        parser->m_declNotationPublicId = tem;
+        poolFinish(&parser->m_tempPool);
+        handleDefault = XML_FALSE;
+      }
+      break;
+    case XML_ROLE_NOTATION_SYSTEM_ID:
+      if (parser->m_declNotationName && parser->m_notationDeclHandler) {
+        const XML_Char *systemId = poolStoreString(&parser->m_tempPool, enc,
+                                                   s + enc->minBytesPerChar,
+                                                   next - enc->minBytesPerChar);
+        if (! systemId)
+          return XML_ERROR_NO_MEMORY;
+        *eventEndPP = s;
+        parser->m_notationDeclHandler(
+            parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase,
+            systemId, parser->m_declNotationPublicId);
+        handleDefault = XML_FALSE;
+      }
+      poolClear(&parser->m_tempPool);
+      break;
+    case XML_ROLE_NOTATION_NO_SYSTEM_ID:
+      if (parser->m_declNotationPublicId && parser->m_notationDeclHandler) {
+        *eventEndPP = s;
+        parser->m_notationDeclHandler(
+            parser->m_handlerArg, parser->m_declNotationName, parser->m_curBase,
+            0, parser->m_declNotationPublicId);
+        handleDefault = XML_FALSE;
+      }
+      poolClear(&parser->m_tempPool);
+      break;
+    case XML_ROLE_ERROR:
+      switch (tok) {
+      case XML_TOK_PARAM_ENTITY_REF:
+        /* PE references in internal subset are
+           not allowed within declarations. */
+        return XML_ERROR_PARAM_ENTITY_REF;
+      case XML_TOK_XML_DECL:
+        return XML_ERROR_MISPLACED_XML_PI;
+      default:
+        return XML_ERROR_SYNTAX;
+      }
+#ifdef XML_DTD
+    case XML_ROLE_IGNORE_SECT: {
+      enum XML_Error result;
+      if (parser->m_defaultHandler)
+        reportDefault(parser, enc, s, next);
+      handleDefault = XML_FALSE;
+      result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);
+      if (result != XML_ERROR_NONE)
+        return result;
+      else if (! next) {
+        parser->m_processor = ignoreSectionProcessor;
+        return result;
+      }
+    } break;
+#endif /* XML_DTD */
+    case XML_ROLE_GROUP_OPEN:
+      if (parser->m_prologState.level >= parser->m_groupSize) {
+        if (parser->m_groupSize) {
+          {
+            /* Detect and prevent integer overflow */
+            if (parser->m_groupSize > (unsigned int)(-1) / 2u) {
+              return XML_ERROR_NO_MEMORY;
+            }
+
+            char *const new_connector = (char *)REALLOC(
+                parser, parser->m_groupConnector, parser->m_groupSize *= 2);
+            if (new_connector == NULL) {
+              parser->m_groupSize /= 2;
+              return XML_ERROR_NO_MEMORY;
+            }
+            parser->m_groupConnector = new_connector;
+          }
+
+          if (dtd->scaffIndex) {
+            /* Detect and prevent integer overflow.
+             * The preprocessor guard addresses the "always false" warning
+             * from -Wtype-limits on platforms where
+             * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+            if (parser->m_groupSize > (size_t)(-1) / sizeof(int)) {
+              return XML_ERROR_NO_MEMORY;
+            }
+#endif
+
+            int *const new_scaff_index = (int *)REALLOC(
+                parser, dtd->scaffIndex, parser->m_groupSize * sizeof(int));
+            if (new_scaff_index == NULL)
+              return XML_ERROR_NO_MEMORY;
+            dtd->scaffIndex = new_scaff_index;
+          }
+        } else {
+          parser->m_groupConnector
+              = (char *)MALLOC(parser, parser->m_groupSize = 32);
+          if (! parser->m_groupConnector) {
+            parser->m_groupSize = 0;
+            return XML_ERROR_NO_MEMORY;
+          }
+        }
+      }
+      parser->m_groupConnector[parser->m_prologState.level] = 0;
+      if (dtd->in_eldecl) {
+        int myindex = nextScaffoldPart(parser);
+        if (myindex < 0)
+          return XML_ERROR_NO_MEMORY;
+        assert(dtd->scaffIndex != NULL);
+        dtd->scaffIndex[dtd->scaffLevel] = myindex;
+        dtd->scaffLevel++;
+        dtd->scaffold[myindex].type = XML_CTYPE_SEQ;
+        if (parser->m_elementDeclHandler)
+          handleDefault = XML_FALSE;
+      }
+      break;
+    case XML_ROLE_GROUP_SEQUENCE:
+      if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_PIPE)
+        return XML_ERROR_SYNTAX;
+      parser->m_groupConnector[parser->m_prologState.level] = ASCII_COMMA;
+      if (dtd->in_eldecl && parser->m_elementDeclHandler)
+        handleDefault = XML_FALSE;
+      break;
+    case XML_ROLE_GROUP_CHOICE:
+      if (parser->m_groupConnector[parser->m_prologState.level] == ASCII_COMMA)
+        return XML_ERROR_SYNTAX;
+      if (dtd->in_eldecl
+          && ! parser->m_groupConnector[parser->m_prologState.level]
+          && (dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
+              != XML_CTYPE_MIXED)) {
+        dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
+            = XML_CTYPE_CHOICE;
+        if (parser->m_elementDeclHandler)
+          handleDefault = XML_FALSE;
+      }
+      parser->m_groupConnector[parser->m_prologState.level] = ASCII_PIPE;
+      break;
+    case XML_ROLE_PARAM_ENTITY_REF:
+#ifdef XML_DTD
+    case XML_ROLE_INNER_PARAM_ENTITY_REF:
+      dtd->hasParamEntityRefs = XML_TRUE;
+      if (! parser->m_paramEntityParsing)
+        dtd->keepProcessing = dtd->standalone;
+      else {
+        const XML_Char *name;
+        ENTITY *entity;
+        name = poolStoreString(&dtd->pool, enc, s + enc->minBytesPerChar,
+                               next - enc->minBytesPerChar);
+        if (! name)
+          return XML_ERROR_NO_MEMORY;
+        entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
+        poolDiscard(&dtd->pool);
+        /* first, determine if a check for an existing declaration is needed;
+           if yes, check that the entity exists, and that it is internal,
+           otherwise call the skipped entity handler
+        */
+        if (parser->m_prologState.documentEntity
+            && (dtd->standalone ? ! parser->m_openInternalEntities
+                                : ! dtd->hasParamEntityRefs)) {
+          if (! entity)
+            return XML_ERROR_UNDEFINED_ENTITY;
+          else if (! entity->is_internal) {
+            /* It's hard to exhaustively search the code to be sure,
+             * but there doesn't seem to be a way of executing the
+             * following line.  There are two cases:
+             *
+             * If 'standalone' is false, the DTD must have no
+             * parameter entities or we wouldn't have passed the outer
+             * 'if' statement.  That measn the only entity in the hash
+             * table is the external subset name "#" which cannot be
+             * given as a parameter entity name in XML syntax, so the
+             * lookup must have returned NULL and we don't even reach
+             * the test for an internal entity.
+             *
+             * If 'standalone' is true, it does not seem to be
+             * possible to create entities taking this code path that
+             * are not internal entities, so fail the test above.
+             *
+             * Because this analysis is very uncertain, the code is
+             * being left in place and merely removed from the
+             * coverage test statistics.
+             */
+            return XML_ERROR_ENTITY_DECLARED_IN_PE; /* LCOV_EXCL_LINE */
+          }
+        } else if (! entity) {
+          dtd->keepProcessing = dtd->standalone;
+          /* cannot report skipped entities in declarations */
+          if ((role == XML_ROLE_PARAM_ENTITY_REF)
+              && parser->m_skippedEntityHandler) {
+            parser->m_skippedEntityHandler(parser->m_handlerArg, name, 1);
+            handleDefault = XML_FALSE;
+          }
+          break;
+        }
+        if (entity->open)
+          return XML_ERROR_RECURSIVE_ENTITY_REF;
+        if (entity->textPtr) {
+          enum XML_Error result;
+          XML_Bool betweenDecl
+              = (role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);
+          result = processInternalEntity(parser, entity, betweenDecl);
+          if (result != XML_ERROR_NONE)
+            return result;
+          handleDefault = XML_FALSE;
+          break;
+        }
+        if (parser->m_externalEntityRefHandler) {
+          dtd->paramEntityRead = XML_FALSE;
+          entity->open = XML_TRUE;
+          entityTrackingOnOpen(parser, entity, __LINE__);
+          if (! parser->m_externalEntityRefHandler(
+                  parser->m_externalEntityRefHandlerArg, 0, entity->base,
+                  entity->systemId, entity->publicId)) {
+            entityTrackingOnClose(parser, entity, __LINE__);
+            entity->open = XML_FALSE;
+            return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+          }
+          entityTrackingOnClose(parser, entity, __LINE__);
+          entity->open = XML_FALSE;
+          handleDefault = XML_FALSE;
+          if (! dtd->paramEntityRead) {
+            dtd->keepProcessing = dtd->standalone;
+            break;
+          }
+        } else {
+          dtd->keepProcessing = dtd->standalone;
+          break;
+        }
+      }
+#endif /* XML_DTD */
+      if (! dtd->standalone && parser->m_notStandaloneHandler
+          && ! parser->m_notStandaloneHandler(parser->m_handlerArg))
+        return XML_ERROR_NOT_STANDALONE;
+      break;
+
+      /* Element declaration stuff */
+
+    case XML_ROLE_ELEMENT_NAME:
+      if (parser->m_elementDeclHandler) {
+        parser->m_declElementType = getElementType(parser, enc, s, next);
+        if (! parser->m_declElementType)
+          return XML_ERROR_NO_MEMORY;
+        dtd->scaffLevel = 0;
+        dtd->scaffCount = 0;
+        dtd->in_eldecl = XML_TRUE;
+        handleDefault = XML_FALSE;
+      }
+      break;
+
+    case XML_ROLE_CONTENT_ANY:
+    case XML_ROLE_CONTENT_EMPTY:
+      if (dtd->in_eldecl) {
+        if (parser->m_elementDeclHandler) {
+          XML_Content *content
+              = (XML_Content *)MALLOC(parser, sizeof(XML_Content));
+          if (! content)
+            return XML_ERROR_NO_MEMORY;
+          content->quant = XML_CQUANT_NONE;
+          content->name = NULL;
+          content->numchildren = 0;
+          content->children = NULL;
+          content->type = ((role == XML_ROLE_CONTENT_ANY) ? XML_CTYPE_ANY
+                                                          : XML_CTYPE_EMPTY);
+          *eventEndPP = s;
+          parser->m_elementDeclHandler(
+              parser->m_handlerArg, parser->m_declElementType->name, content);
+          handleDefault = XML_FALSE;
+        }
+        dtd->in_eldecl = XML_FALSE;
+      }
+      break;
+
+    case XML_ROLE_CONTENT_PCDATA:
+      if (dtd->in_eldecl) {
+        dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]].type
+            = XML_CTYPE_MIXED;
+        if (parser->m_elementDeclHandler)
+          handleDefault = XML_FALSE;
+      }
+      break;
+
+    case XML_ROLE_CONTENT_ELEMENT:
+      quant = XML_CQUANT_NONE;
+      goto elementContent;
+    case XML_ROLE_CONTENT_ELEMENT_OPT:
+      quant = XML_CQUANT_OPT;
+      goto elementContent;
+    case XML_ROLE_CONTENT_ELEMENT_REP:
+      quant = XML_CQUANT_REP;
+      goto elementContent;
+    case XML_ROLE_CONTENT_ELEMENT_PLUS:
+      quant = XML_CQUANT_PLUS;
+    elementContent:
+      if (dtd->in_eldecl) {
+        ELEMENT_TYPE *el;
+        const XML_Char *name;
+        size_t nameLen;
+        const char *nxt
+            = (quant == XML_CQUANT_NONE ? next : next - enc->minBytesPerChar);
+        int myindex = nextScaffoldPart(parser);
+        if (myindex < 0)
+          return XML_ERROR_NO_MEMORY;
+        dtd->scaffold[myindex].type = XML_CTYPE_NAME;
+        dtd->scaffold[myindex].quant = quant;
+        el = getElementType(parser, enc, s, nxt);
+        if (! el)
+          return XML_ERROR_NO_MEMORY;
+        name = el->name;
+        dtd->scaffold[myindex].name = name;
+        nameLen = 0;
+        for (; name[nameLen++];)
+          ;
+
+        /* Detect and prevent integer overflow */
+        if (nameLen > UINT_MAX - dtd->contentStringLen) {
+          return XML_ERROR_NO_MEMORY;
+        }
+
+        dtd->contentStringLen += (unsigned)nameLen;
+        if (parser->m_elementDeclHandler)
+          handleDefault = XML_FALSE;
+      }
+      break;
+
+    case XML_ROLE_GROUP_CLOSE:
+      quant = XML_CQUANT_NONE;
+      goto closeGroup;
+    case XML_ROLE_GROUP_CLOSE_OPT:
+      quant = XML_CQUANT_OPT;
+      goto closeGroup;
+    case XML_ROLE_GROUP_CLOSE_REP:
+      quant = XML_CQUANT_REP;
+      goto closeGroup;
+    case XML_ROLE_GROUP_CLOSE_PLUS:
+      quant = XML_CQUANT_PLUS;
+    closeGroup:
+      if (dtd->in_eldecl) {
+        if (parser->m_elementDeclHandler)
+          handleDefault = XML_FALSE;
+        dtd->scaffLevel--;
+        dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel]].quant = quant;
+        if (dtd->scaffLevel == 0) {
+          if (! handleDefault) {
+            XML_Content *model = build_model(parser);
+            if (! model)
+              return XML_ERROR_NO_MEMORY;
+            *eventEndPP = s;
+            parser->m_elementDeclHandler(
+                parser->m_handlerArg, parser->m_declElementType->name, model);
+          }
+          dtd->in_eldecl = XML_FALSE;
+          dtd->contentStringLen = 0;
+        }
+      }
+      break;
+      /* End element declaration stuff */
+
+    case XML_ROLE_PI:
+      if (! reportProcessingInstruction(parser, enc, s, next))
+        return XML_ERROR_NO_MEMORY;
+      handleDefault = XML_FALSE;
+      break;
+    case XML_ROLE_COMMENT:
+      if (! reportComment(parser, enc, s, next))
+        return XML_ERROR_NO_MEMORY;
+      handleDefault = XML_FALSE;
+      break;
+    case XML_ROLE_NONE:
+      switch (tok) {
+      case XML_TOK_BOM:
+        handleDefault = XML_FALSE;
+        break;
+      }
+      break;
+    case XML_ROLE_DOCTYPE_NONE:
+      if (parser->m_startDoctypeDeclHandler)
+        handleDefault = XML_FALSE;
+      break;
+    case XML_ROLE_ENTITY_NONE:
+      if (dtd->keepProcessing && parser->m_entityDeclHandler)
+        handleDefault = XML_FALSE;
+      break;
+    case XML_ROLE_NOTATION_NONE:
+      if (parser->m_notationDeclHandler)
+        handleDefault = XML_FALSE;
+      break;
+    case XML_ROLE_ATTLIST_NONE:
+      if (dtd->keepProcessing && parser->m_attlistDeclHandler)
+        handleDefault = XML_FALSE;
+      break;
+    case XML_ROLE_ELEMENT_NONE:
+      if (parser->m_elementDeclHandler)
+        handleDefault = XML_FALSE;
+      break;
+    } /* end of big switch */
+
+    if (handleDefault && parser->m_defaultHandler)
+      reportDefault(parser, enc, s, next);
+
+    switch (parser->m_parsingStatus.parsing) {
+    case XML_SUSPENDED:
+      *nextPtr = next;
+      return XML_ERROR_NONE;
+    case XML_FINISHED:
+      return XML_ERROR_ABORTED;
+    default:
+      s = next;
+      tok = XmlPrologTok(enc, s, end, &next);
+    }
+  }
+  /* not reached */
+}
+
+static enum XML_Error PTRCALL
+epilogProcessor(XML_Parser parser, const char *s, const char *end,
+                const char **nextPtr) {
+  parser->m_processor = epilogProcessor;
+  parser->m_eventPtr = s;
+  for (;;) {
+    const char *next = NULL;
+    int tok = XmlPrologTok(parser->m_encoding, s, end, &next);
+#ifdef XML_DTD
+    if (! accountingDiffTolerated(parser, tok, s, next, __LINE__,
+                                  XML_ACCOUNT_DIRECT)) {
+      accountingOnAbort(parser);
+      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+    }
+#endif
+    parser->m_eventEndPtr = next;
+    switch (tok) {
+    /* report partial linebreak - it might be the last token */
+    case -XML_TOK_PROLOG_S:
+      if (parser->m_defaultHandler) {
+        reportDefault(parser, parser->m_encoding, s, next);
+        if (parser->m_parsingStatus.parsing == XML_FINISHED)
+          return XML_ERROR_ABORTED;
+      }
+      *nextPtr = next;
+      return XML_ERROR_NONE;
+    case XML_TOK_NONE:
+      *nextPtr = s;
+      return XML_ERROR_NONE;
+    case XML_TOK_PROLOG_S:
+      if (parser->m_defaultHandler)
+        reportDefault(parser, parser->m_encoding, s, next);
+      break;
+    case XML_TOK_PI:
+      if (! reportProcessingInstruction(parser, parser->m_encoding, s, next))
+        return XML_ERROR_NO_MEMORY;
+      break;
+    case XML_TOK_COMMENT:
+      if (! reportComment(parser, parser->m_encoding, s, next))
+        return XML_ERROR_NO_MEMORY;
+      break;
+    case XML_TOK_INVALID:
+      parser->m_eventPtr = next;
+      return XML_ERROR_INVALID_TOKEN;
+    case XML_TOK_PARTIAL:
+      if (! parser->m_parsingStatus.finalBuffer) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      return XML_ERROR_UNCLOSED_TOKEN;
+    case XML_TOK_PARTIAL_CHAR:
+      if (! parser->m_parsingStatus.finalBuffer) {
+        *nextPtr = s;
+        return XML_ERROR_NONE;
+      }
+      return XML_ERROR_PARTIAL_CHAR;
+    default:
+      return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;
+    }
+    parser->m_eventPtr = s = next;
+    switch (parser->m_parsingStatus.parsing) {
+    case XML_SUSPENDED:
+      *nextPtr = next;
+      return XML_ERROR_NONE;
+    case XML_FINISHED:
+      return XML_ERROR_ABORTED;
+    default:;
+    }
+  }
+}
+
+static enum XML_Error
+processInternalEntity(XML_Parser parser, ENTITY *entity, XML_Bool betweenDecl) {
+  const char *textStart, *textEnd;
+  const char *next;
+  enum XML_Error result;
+  OPEN_INTERNAL_ENTITY *openEntity;
+
+  if (parser->m_freeInternalEntities) {
+    openEntity = parser->m_freeInternalEntities;
+    parser->m_freeInternalEntities = openEntity->next;
+  } else {
+    openEntity
+        = (OPEN_INTERNAL_ENTITY *)MALLOC(parser, sizeof(OPEN_INTERNAL_ENTITY));
+    if (! openEntity)
+      return XML_ERROR_NO_MEMORY;
+  }
+  entity->open = XML_TRUE;
+#ifdef XML_DTD
+  entityTrackingOnOpen(parser, entity, __LINE__);
+#endif
+  entity->processed = 0;
+  openEntity->next = parser->m_openInternalEntities;
+  parser->m_openInternalEntities = openEntity;
+  openEntity->entity = entity;
+  openEntity->startTagLevel = parser->m_tagLevel;
+  openEntity->betweenDecl = betweenDecl;
+  openEntity->internalEventPtr = NULL;
+  openEntity->internalEventEndPtr = NULL;
+  textStart = (const char *)entity->textPtr;
+  textEnd = (const char *)(entity->textPtr + entity->textLen);
+  /* Set a safe default value in case 'next' does not get set */
+  next = textStart;
+
+#ifdef XML_DTD
+  if (entity->is_param) {
+    int tok
+        = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
+    result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd,
+                      tok, next, &next, XML_FALSE, XML_FALSE,
+                      XML_ACCOUNT_ENTITY_EXPANSION);
+  } else
+#endif /* XML_DTD */
+    result = doContent(parser, parser->m_tagLevel, parser->m_internalEncoding,
+                       textStart, textEnd, &next, XML_FALSE,
+                       XML_ACCOUNT_ENTITY_EXPANSION);
+
+  if (result == XML_ERROR_NONE) {
+    if (textEnd != next && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
+      entity->processed = (int)(next - textStart);
+      parser->m_processor = internalEntityProcessor;
+    } else {
+#ifdef XML_DTD
+      entityTrackingOnClose(parser, entity, __LINE__);
+#endif /* XML_DTD */
+      entity->open = XML_FALSE;
+      parser->m_openInternalEntities = openEntity->next;
+      /* put openEntity back in list of free instances */
+      openEntity->next = parser->m_freeInternalEntities;
+      parser->m_freeInternalEntities = openEntity;
+    }
+  }
+  return result;
+}
+
+static enum XML_Error PTRCALL
+internalEntityProcessor(XML_Parser parser, const char *s, const char *end,
+                        const char **nextPtr) {
+  ENTITY *entity;
+  const char *textStart, *textEnd;
+  const char *next;
+  enum XML_Error result;
+  OPEN_INTERNAL_ENTITY *openEntity = parser->m_openInternalEntities;
+  if (! openEntity)
+    return XML_ERROR_UNEXPECTED_STATE;
+
+  entity = openEntity->entity;
+  textStart = ((const char *)entity->textPtr) + entity->processed;
+  textEnd = (const char *)(entity->textPtr + entity->textLen);
+  /* Set a safe default value in case 'next' does not get set */
+  next = textStart;
+
+#ifdef XML_DTD
+  if (entity->is_param) {
+    int tok
+        = XmlPrologTok(parser->m_internalEncoding, textStart, textEnd, &next);
+    result = doProlog(parser, parser->m_internalEncoding, textStart, textEnd,
+                      tok, next, &next, XML_FALSE, XML_TRUE,
+                      XML_ACCOUNT_ENTITY_EXPANSION);
+  } else
+#endif /* XML_DTD */
+    result = doContent(parser, openEntity->startTagLevel,
+                       parser->m_internalEncoding, textStart, textEnd, &next,
+                       XML_FALSE, XML_ACCOUNT_ENTITY_EXPANSION);
+
+  if (result != XML_ERROR_NONE)
+    return result;
+  else if (textEnd != next
+           && parser->m_parsingStatus.parsing == XML_SUSPENDED) {
+    entity->processed = (int)(next - (const char *)entity->textPtr);
+    return result;
+  } else {
+#ifdef XML_DTD
+    entityTrackingOnClose(parser, entity, __LINE__);
+#endif
+    entity->open = XML_FALSE;
+    parser->m_openInternalEntities = openEntity->next;
+    /* put openEntity back in list of free instances */
+    openEntity->next = parser->m_freeInternalEntities;
+    parser->m_freeInternalEntities = openEntity;
+  }
+
+#ifdef XML_DTD
+  if (entity->is_param) {
+    int tok;
+    parser->m_processor = prologProcessor;
+    tok = XmlPrologTok(parser->m_encoding, s, end, &next);
+    return doProlog(parser, parser->m_encoding, s, end, tok, next, nextPtr,
+                    (XML_Bool)! parser->m_parsingStatus.finalBuffer, XML_TRUE,
+                    XML_ACCOUNT_DIRECT);
+  } else
+#endif /* XML_DTD */
+  {
+    parser->m_processor = contentProcessor;
+    /* see externalEntityContentProcessor vs contentProcessor */
+    return doContent(parser, parser->m_parentParser ? 1 : 0, parser->m_encoding,
+                     s, end, nextPtr,
+                     (XML_Bool)! parser->m_parsingStatus.finalBuffer,
+                     XML_ACCOUNT_DIRECT);
+  }
+}
+
+static enum XML_Error PTRCALL
+errorProcessor(XML_Parser parser, const char *s, const char *end,
+               const char **nextPtr) {
+  UNUSED_P(s);
+  UNUSED_P(end);
+  UNUSED_P(nextPtr);
+  return parser->m_errorCode;
+}
+
+static enum XML_Error
+storeAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
+                    const char *ptr, const char *end, STRING_POOL *pool,
+                    enum XML_Account account) {
+  enum XML_Error result
+      = appendAttributeValue(parser, enc, isCdata, ptr, end, pool, account);
+  if (result)
+    return result;
+  if (! isCdata && poolLength(pool) && poolLastChar(pool) == 0x20)
+    poolChop(pool);
+  if (! poolAppendChar(pool, XML_T('\0')))
+    return XML_ERROR_NO_MEMORY;
+  return XML_ERROR_NONE;
+}
+
+static enum XML_Error
+appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
+                     const char *ptr, const char *end, STRING_POOL *pool,
+                     enum XML_Account account) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+#ifndef XML_DTD
+  UNUSED_P(account);
+#endif
+
+  for (;;) {
+    const char *next
+        = ptr; /* XmlAttributeValueTok doesn't always set the last arg */
+    int tok = XmlAttributeValueTok(enc, ptr, end, &next);
+#ifdef XML_DTD
+    if (! accountingDiffTolerated(parser, tok, ptr, next, __LINE__, account)) {
+      accountingOnAbort(parser);
+      return XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+    }
+#endif
+    switch (tok) {
+    case XML_TOK_NONE:
+      return XML_ERROR_NONE;
+    case XML_TOK_INVALID:
+      if (enc == parser->m_encoding)
+        parser->m_eventPtr = next;
+      return XML_ERROR_INVALID_TOKEN;
+    case XML_TOK_PARTIAL:
+      if (enc == parser->m_encoding)
+        parser->m_eventPtr = ptr;
+      return XML_ERROR_INVALID_TOKEN;
+    case XML_TOK_CHAR_REF: {
+      XML_Char buf[XML_ENCODE_MAX];
+      int i;
+      int n = XmlCharRefNumber(enc, ptr);
+      if (n < 0) {
+        if (enc == parser->m_encoding)
+          parser->m_eventPtr = ptr;
+        return XML_ERROR_BAD_CHAR_REF;
+      }
+      if (! isCdata && n == 0x20 /* space */
+          && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
+        break;
+      n = XmlEncode(n, (ICHAR *)buf);
+      /* The XmlEncode() functions can never return 0 here.  That
+       * error return happens if the code point passed in is either
+       * negative or greater than or equal to 0x110000.  The
+       * XmlCharRefNumber() functions will all return a number
+       * strictly less than 0x110000 or a negative value if an error
+       * occurred.  The negative value is intercepted above, so
+       * XmlEncode() is never passed a value it might return an
+       * error for.
+       */
+      for (i = 0; i < n; i++) {
+        if (! poolAppendChar(pool, buf[i]))
+          return XML_ERROR_NO_MEMORY;
+      }
+    } break;
+    case XML_TOK_DATA_CHARS:
+      if (! poolAppend(pool, enc, ptr, next))
+        return XML_ERROR_NO_MEMORY;
+      break;
+    case XML_TOK_TRAILING_CR:
+      next = ptr + enc->minBytesPerChar;
+      /* fall through */
+    case XML_TOK_ATTRIBUTE_VALUE_S:
+    case XML_TOK_DATA_NEWLINE:
+      if (! isCdata && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
+        break;
+      if (! poolAppendChar(pool, 0x20))
+        return XML_ERROR_NO_MEMORY;
+      break;
+    case XML_TOK_ENTITY_REF: {
+      const XML_Char *name;
+      ENTITY *entity;
+      char checkEntityDecl;
+      XML_Char ch = (XML_Char)XmlPredefinedEntityName(
+          enc, ptr + enc->minBytesPerChar, next - enc->minBytesPerChar);
+      if (ch) {
+#ifdef XML_DTD
+        /* NOTE: We are replacing 4-6 characters original input for 1 character
+         *       so there is no amplification and hence recording without
+         *       protection. */
+        accountingDiffTolerated(parser, tok, (char *)&ch,
+                                ((char *)&ch) + sizeof(XML_Char), __LINE__,
+                                XML_ACCOUNT_ENTITY_EXPANSION);
+#endif /* XML_DTD */
+        if (! poolAppendChar(pool, ch))
+          return XML_ERROR_NO_MEMORY;
+        break;
+      }
+      name = poolStoreString(&parser->m_temp2Pool, enc,
+                             ptr + enc->minBytesPerChar,
+                             next - enc->minBytesPerChar);
+      if (! name)
+        return XML_ERROR_NO_MEMORY;
+      entity = (ENTITY *)lookup(parser, &dtd->generalEntities, name, 0);
+      poolDiscard(&parser->m_temp2Pool);
+      /* First, determine if a check for an existing declaration is needed;
+         if yes, check that the entity exists, and that it is internal.
+      */
+      if (pool == &dtd->pool) /* are we called from prolog? */
+        checkEntityDecl =
+#ifdef XML_DTD
+            parser->m_prologState.documentEntity &&
+#endif /* XML_DTD */
+            (dtd->standalone ? ! parser->m_openInternalEntities
+                             : ! dtd->hasParamEntityRefs);
+      else /* if (pool == &parser->m_tempPool): we are called from content */
+        checkEntityDecl = ! dtd->hasParamEntityRefs || dtd->standalone;
+      if (checkEntityDecl) {
+        if (! entity)
+          return XML_ERROR_UNDEFINED_ENTITY;
+        else if (! entity->is_internal)
+          return XML_ERROR_ENTITY_DECLARED_IN_PE;
+      } else if (! entity) {
+        /* Cannot report skipped entity here - see comments on
+           parser->m_skippedEntityHandler.
+        if (parser->m_skippedEntityHandler)
+          parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
+        */
+        /* Cannot call the default handler because this would be
+           out of sync with the call to the startElementHandler.
+        if ((pool == &parser->m_tempPool) && parser->m_defaultHandler)
+          reportDefault(parser, enc, ptr, next);
+        */
+        break;
+      }
+      if (entity->open) {
+        if (enc == parser->m_encoding) {
+          /* It does not appear that this line can be executed.
+           *
+           * The "if (entity->open)" check catches recursive entity
+           * definitions.  In order to be called with an open
+           * entity, it must have gone through this code before and
+           * been through the recursive call to
+           * appendAttributeValue() some lines below.  That call
+           * sets the local encoding ("enc") to the parser's
+           * internal encoding (internal_utf8 or internal_utf16),
+           * which can never be the same as the principle encoding.
+           * It doesn't appear there is another code path that gets
+           * here with entity->open being TRUE.
+           *
+           * Since it is not certain that this logic is watertight,
+           * we keep the line and merely exclude it from coverage
+           * tests.
+           */
+          parser->m_eventPtr = ptr; /* LCOV_EXCL_LINE */
+        }
+        return XML_ERROR_RECURSIVE_ENTITY_REF;
+      }
+      if (entity->notation) {
+        if (enc == parser->m_encoding)
+          parser->m_eventPtr = ptr;
+        return XML_ERROR_BINARY_ENTITY_REF;
+      }
+      if (! entity->textPtr) {
+        if (enc == parser->m_encoding)
+          parser->m_eventPtr = ptr;
+        return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;
+      } else {
+        enum XML_Error result;
+        const XML_Char *textEnd = entity->textPtr + entity->textLen;
+        entity->open = XML_TRUE;
+#ifdef XML_DTD
+        entityTrackingOnOpen(parser, entity, __LINE__);
+#endif
+        result = appendAttributeValue(parser, parser->m_internalEncoding,
+                                      isCdata, (const char *)entity->textPtr,
+                                      (const char *)textEnd, pool,
+                                      XML_ACCOUNT_ENTITY_EXPANSION);
+#ifdef XML_DTD
+        entityTrackingOnClose(parser, entity, __LINE__);
+#endif
+        entity->open = XML_FALSE;
+        if (result)
+          return result;
+      }
+    } break;
+    default:
+      /* The only token returned by XmlAttributeValueTok() that does
+       * not have an explicit case here is XML_TOK_PARTIAL_CHAR.
+       * Getting that would require an entity name to contain an
+       * incomplete XML character (e.g. \xE2\x82); however previous
+       * tokenisers will have already recognised and rejected such
+       * names before XmlAttributeValueTok() gets a look-in.  This
+       * default case should be retained as a safety net, but the code
+       * excluded from coverage tests.
+       *
+       * LCOV_EXCL_START
+       */
+      if (enc == parser->m_encoding)
+        parser->m_eventPtr = ptr;
+      return XML_ERROR_UNEXPECTED_STATE;
+      /* LCOV_EXCL_STOP */
+    }
+    ptr = next;
+  }
+  /* not reached */
+}
+
+static enum XML_Error
+storeEntityValue(XML_Parser parser, const ENCODING *enc,
+                 const char *entityTextPtr, const char *entityTextEnd,
+                 enum XML_Account account) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  STRING_POOL *pool = &(dtd->entityValuePool);
+  enum XML_Error result = XML_ERROR_NONE;
+#ifdef XML_DTD
+  int oldInEntityValue = parser->m_prologState.inEntityValue;
+  parser->m_prologState.inEntityValue = 1;
+#else
+  UNUSED_P(account);
+#endif /* XML_DTD */
+  /* never return Null for the value argument in EntityDeclHandler,
+     since this would indicate an external entity; therefore we
+     have to make sure that entityValuePool.start is not null */
+  if (! pool->blocks) {
+    if (! poolGrow(pool))
+      return XML_ERROR_NO_MEMORY;
+  }
+
+  for (;;) {
+    const char *next
+        = entityTextPtr; /* XmlEntityValueTok doesn't always set the last arg */
+    int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next);
+
+#ifdef XML_DTD
+    if (! accountingDiffTolerated(parser, tok, entityTextPtr, next, __LINE__,
+                                  account)) {
+      accountingOnAbort(parser);
+      result = XML_ERROR_AMPLIFICATION_LIMIT_BREACH;
+      goto endEntityValue;
+    }
+#endif
+
+    switch (tok) {
+    case XML_TOK_PARAM_ENTITY_REF:
+#ifdef XML_DTD
+      if (parser->m_isParamEntity || enc != parser->m_encoding) {
+        const XML_Char *name;
+        ENTITY *entity;
+        name = poolStoreString(&parser->m_tempPool, enc,
+                               entityTextPtr + enc->minBytesPerChar,
+                               next - enc->minBytesPerChar);
+        if (! name) {
+          result = XML_ERROR_NO_MEMORY;
+          goto endEntityValue;
+        }
+        entity = (ENTITY *)lookup(parser, &dtd->paramEntities, name, 0);
+        poolDiscard(&parser->m_tempPool);
+        if (! entity) {
+          /* not a well-formedness error - see XML 1.0: WFC Entity Declared */
+          /* cannot report skipped entity here - see comments on
+             parser->m_skippedEntityHandler
+          if (parser->m_skippedEntityHandler)
+            parser->m_skippedEntityHandler(parser->m_handlerArg, name, 0);
+          */
+          dtd->keepProcessing = dtd->standalone;
+          goto endEntityValue;
+        }
+        if (entity->open) {
+          if (enc == parser->m_encoding)
+            parser->m_eventPtr = entityTextPtr;
+          result = XML_ERROR_RECURSIVE_ENTITY_REF;
+          goto endEntityValue;
+        }
+        if (entity->systemId) {
+          if (parser->m_externalEntityRefHandler) {
+            dtd->paramEntityRead = XML_FALSE;
+            entity->open = XML_TRUE;
+            entityTrackingOnOpen(parser, entity, __LINE__);
+            if (! parser->m_externalEntityRefHandler(
+                    parser->m_externalEntityRefHandlerArg, 0, entity->base,
+                    entity->systemId, entity->publicId)) {
+              entityTrackingOnClose(parser, entity, __LINE__);
+              entity->open = XML_FALSE;
+              result = XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+              goto endEntityValue;
+            }
+            entityTrackingOnClose(parser, entity, __LINE__);
+            entity->open = XML_FALSE;
+            if (! dtd->paramEntityRead)
+              dtd->keepProcessing = dtd->standalone;
+          } else
+            dtd->keepProcessing = dtd->standalone;
+        } else {
+          entity->open = XML_TRUE;
+          entityTrackingOnOpen(parser, entity, __LINE__);
+          result = storeEntityValue(
+              parser, parser->m_internalEncoding, (const char *)entity->textPtr,
+              (const char *)(entity->textPtr + entity->textLen),
+              XML_ACCOUNT_ENTITY_EXPANSION);
+          entityTrackingOnClose(parser, entity, __LINE__);
+          entity->open = XML_FALSE;
+          if (result)
+            goto endEntityValue;
+        }
+        break;
+      }
+#endif /* XML_DTD */
+      /* In the internal subset, PE references are not legal
+         within markup declarations, e.g entity values in this case. */
+      parser->m_eventPtr = entityTextPtr;
+      result = XML_ERROR_PARAM_ENTITY_REF;
+      goto endEntityValue;
+    case XML_TOK_NONE:
+      result = XML_ERROR_NONE;
+      goto endEntityValue;
+    case XML_TOK_ENTITY_REF:
+    case XML_TOK_DATA_CHARS:
+      if (! poolAppend(pool, enc, entityTextPtr, next)) {
+        result = XML_ERROR_NO_MEMORY;
+        goto endEntityValue;
+      }
+      break;
+    case XML_TOK_TRAILING_CR:
+      next = entityTextPtr + enc->minBytesPerChar;
+      /* fall through */
+    case XML_TOK_DATA_NEWLINE:
+      if (pool->end == pool->ptr && ! poolGrow(pool)) {
+        result = XML_ERROR_NO_MEMORY;
+        goto endEntityValue;
+      }
+      *(pool->ptr)++ = 0xA;
+      break;
+    case XML_TOK_CHAR_REF: {
+      XML_Char buf[XML_ENCODE_MAX];
+      int i;
+      int n = XmlCharRefNumber(enc, entityTextPtr);
+      if (n < 0) {
+        if (enc == parser->m_encoding)
+          parser->m_eventPtr = entityTextPtr;
+        result = XML_ERROR_BAD_CHAR_REF;
+        goto endEntityValue;
+      }
+      n = XmlEncode(n, (ICHAR *)buf);
+      /* The XmlEncode() functions can never return 0 here.  That
+       * error return happens if the code point passed in is either
+       * negative or greater than or equal to 0x110000.  The
+       * XmlCharRefNumber() functions will all return a number
+       * strictly less than 0x110000 or a negative value if an error
+       * occurred.  The negative value is intercepted above, so
+       * XmlEncode() is never passed a value it might return an
+       * error for.
+       */
+      for (i = 0; i < n; i++) {
+        if (pool->end == pool->ptr && ! poolGrow(pool)) {
+          result = XML_ERROR_NO_MEMORY;
+          goto endEntityValue;
+        }
+        *(pool->ptr)++ = buf[i];
+      }
+    } break;
+    case XML_TOK_PARTIAL:
+      if (enc == parser->m_encoding)
+        parser->m_eventPtr = entityTextPtr;
+      result = XML_ERROR_INVALID_TOKEN;
+      goto endEntityValue;
+    case XML_TOK_INVALID:
+      if (enc == parser->m_encoding)
+        parser->m_eventPtr = next;
+      result = XML_ERROR_INVALID_TOKEN;
+      goto endEntityValue;
+    default:
+      /* This default case should be unnecessary -- all the tokens
+       * that XmlEntityValueTok() can return have their own explicit
+       * cases -- but should be retained for safety.  We do however
+       * exclude it from the coverage statistics.
+       *
+       * LCOV_EXCL_START
+       */
+      if (enc == parser->m_encoding)
+        parser->m_eventPtr = entityTextPtr;
+      result = XML_ERROR_UNEXPECTED_STATE;
+      goto endEntityValue;
+      /* LCOV_EXCL_STOP */
+    }
+    entityTextPtr = next;
+  }
+endEntityValue:
+#ifdef XML_DTD
+  parser->m_prologState.inEntityValue = oldInEntityValue;
+#endif /* XML_DTD */
+  return result;
+}
+
+static void FASTCALL
+normalizeLines(XML_Char *s) {
+  XML_Char *p;
+  for (;; s++) {
+    if (*s == XML_T('\0'))
+      return;
+    if (*s == 0xD)
+      break;
+  }
+  p = s;
+  do {
+    if (*s == 0xD) {
+      *p++ = 0xA;
+      if (*++s == 0xA)
+        s++;
+    } else
+      *p++ = *s++;
+  } while (*s);
+  *p = XML_T('\0');
+}
+
+static int
+reportProcessingInstruction(XML_Parser parser, const ENCODING *enc,
+                            const char *start, const char *end) {
+  const XML_Char *target;
+  XML_Char *data;
+  const char *tem;
+  if (! parser->m_processingInstructionHandler) {
+    if (parser->m_defaultHandler)
+      reportDefault(parser, enc, start, end);
+    return 1;
+  }
+  start += enc->minBytesPerChar * 2;
+  tem = start + XmlNameLength(enc, start);
+  target = poolStoreString(&parser->m_tempPool, enc, start, tem);
+  if (! target)
+    return 0;
+  poolFinish(&parser->m_tempPool);
+  data = poolStoreString(&parser->m_tempPool, enc, XmlSkipS(enc, tem),
+                         end - enc->minBytesPerChar * 2);
+  if (! data)
+    return 0;
+  normalizeLines(data);
+  parser->m_processingInstructionHandler(parser->m_handlerArg, target, data);
+  poolClear(&parser->m_tempPool);
+  return 1;
+}
+
+static int
+reportComment(XML_Parser parser, const ENCODING *enc, const char *start,
+              const char *end) {
+  XML_Char *data;
+  if (! parser->m_commentHandler) {
+    if (parser->m_defaultHandler)
+      reportDefault(parser, enc, start, end);
+    return 1;
+  }
+  data = poolStoreString(&parser->m_tempPool, enc,
+                         start + enc->minBytesPerChar * 4,
+                         end - enc->minBytesPerChar * 3);
+  if (! data)
+    return 0;
+  normalizeLines(data);
+  parser->m_commentHandler(parser->m_handlerArg, data);
+  poolClear(&parser->m_tempPool);
+  return 1;
+}
+
+static void
+reportDefault(XML_Parser parser, const ENCODING *enc, const char *s,
+              const char *end) {
+  if (MUST_CONVERT(enc, s)) {
+    enum XML_Convert_Result convert_res;
+    const char **eventPP;
+    const char **eventEndPP;
+    if (enc == parser->m_encoding) {
+      eventPP = &parser->m_eventPtr;
+      eventEndPP = &parser->m_eventEndPtr;
+    } else {
+      /* To get here, two things must be true; the parser must be
+       * using a character encoding that is not the same as the
+       * encoding passed in, and the encoding passed in must need
+       * conversion to the internal format (UTF-8 unless XML_UNICODE
+       * is defined).  The only occasions on which the encoding passed
+       * in is not the same as the parser's encoding are when it is
+       * the internal encoding (e.g. a previously defined parameter
+       * entity, already converted to internal format).  This by
+       * definition doesn't need conversion, so the whole branch never
+       * gets executed.
+       *
+       * For safety's sake we don't delete these lines and merely
+       * exclude them from coverage statistics.
+       *
+       * LCOV_EXCL_START
+       */
+      eventPP = &(parser->m_openInternalEntities->internalEventPtr);
+      eventEndPP = &(parser->m_openInternalEntities->internalEventEndPtr);
+      /* LCOV_EXCL_STOP */
+    }
+    do {
+      ICHAR *dataPtr = (ICHAR *)parser->m_dataBuf;
+      convert_res
+          = XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)parser->m_dataBufEnd);
+      *eventEndPP = s;
+      parser->m_defaultHandler(parser->m_handlerArg, parser->m_dataBuf,
+                               (int)(dataPtr - (ICHAR *)parser->m_dataBuf));
+      *eventPP = s;
+    } while ((convert_res != XML_CONVERT_COMPLETED)
+             && (convert_res != XML_CONVERT_INPUT_INCOMPLETE));
+  } else
+    parser->m_defaultHandler(parser->m_handlerArg, (XML_Char *)s,
+                             (int)((XML_Char *)end - (XML_Char *)s));
+}
+
+static int
+defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,
+                XML_Bool isId, const XML_Char *value, XML_Parser parser) {
+  DEFAULT_ATTRIBUTE *att;
+  if (value || isId) {
+    /* The handling of default attributes gets messed up if we have
+       a default which duplicates a non-default. */
+    int i;
+    for (i = 0; i < type->nDefaultAtts; i++)
+      if (attId == type->defaultAtts[i].id)
+        return 1;
+    if (isId && ! type->idAtt && ! attId->xmlns)
+      type->idAtt = attId;
+  }
+  if (type->nDefaultAtts == type->allocDefaultAtts) {
+    if (type->allocDefaultAtts == 0) {
+      type->allocDefaultAtts = 8;
+      type->defaultAtts = (DEFAULT_ATTRIBUTE *)MALLOC(
+          parser, type->allocDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
+      if (! type->defaultAtts) {
+        type->allocDefaultAtts = 0;
+        return 0;
+      }
+    } else {
+      DEFAULT_ATTRIBUTE *temp;
+
+      /* Detect and prevent integer overflow */
+      if (type->allocDefaultAtts > INT_MAX / 2) {
+        return 0;
+      }
+
+      int count = type->allocDefaultAtts * 2;
+
+      /* Detect and prevent integer overflow.
+       * The preprocessor guard addresses the "always false" warning
+       * from -Wtype-limits on platforms where
+       * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+      if ((unsigned)count > (size_t)(-1) / sizeof(DEFAULT_ATTRIBUTE)) {
+        return 0;
+      }
+#endif
+
+      temp = (DEFAULT_ATTRIBUTE *)REALLOC(parser, type->defaultAtts,
+                                          (count * sizeof(DEFAULT_ATTRIBUTE)));
+      if (temp == NULL)
+        return 0;
+      type->allocDefaultAtts = count;
+      type->defaultAtts = temp;
+    }
+  }
+  att = type->defaultAtts + type->nDefaultAtts;
+  att->id = attId;
+  att->value = value;
+  att->isCdata = isCdata;
+  if (! isCdata)
+    attId->maybeTokenized = XML_TRUE;
+  type->nDefaultAtts += 1;
+  return 1;
+}
+
+static int
+setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *elementType) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  const XML_Char *name;
+  for (name = elementType->name; *name; name++) {
+    if (*name == XML_T(ASCII_COLON)) {
+      PREFIX *prefix;
+      const XML_Char *s;
+      for (s = elementType->name; s != name; s++) {
+        if (! poolAppendChar(&dtd->pool, *s))
+          return 0;
+      }
+      if (! poolAppendChar(&dtd->pool, XML_T('\0')))
+        return 0;
+      prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->pool),
+                                sizeof(PREFIX));
+      if (! prefix)
+        return 0;
+      if (prefix->name == poolStart(&dtd->pool))
+        poolFinish(&dtd->pool);
+      else
+        poolDiscard(&dtd->pool);
+      elementType->prefix = prefix;
+      break;
+    }
+  }
+  return 1;
+}
+
+static ATTRIBUTE_ID *
+getAttributeId(XML_Parser parser, const ENCODING *enc, const char *start,
+               const char *end) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  ATTRIBUTE_ID *id;
+  const XML_Char *name;
+  if (! poolAppendChar(&dtd->pool, XML_T('\0')))
+    return NULL;
+  name = poolStoreString(&dtd->pool, enc, start, end);
+  if (! name)
+    return NULL;
+  /* skip quotation mark - its storage will be re-used (like in name[-1]) */
+  ++name;
+  id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, name,
+                              sizeof(ATTRIBUTE_ID));
+  if (! id)
+    return NULL;
+  if (id->name != name)
+    poolDiscard(&dtd->pool);
+  else {
+    poolFinish(&dtd->pool);
+    if (! parser->m_ns)
+      ;
+    else if (name[0] == XML_T(ASCII_x) && name[1] == XML_T(ASCII_m)
+             && name[2] == XML_T(ASCII_l) && name[3] == XML_T(ASCII_n)
+             && name[4] == XML_T(ASCII_s)
+             && (name[5] == XML_T('\0') || name[5] == XML_T(ASCII_COLON))) {
+      if (name[5] == XML_T('\0'))
+        id->prefix = &dtd->defaultPrefix;
+      else
+        id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, name + 6,
+                                      sizeof(PREFIX));
+      id->xmlns = XML_TRUE;
+    } else {
+      int i;
+      for (i = 0; name[i]; i++) {
+        /* attributes without prefix are *not* in the default namespace */
+        if (name[i] == XML_T(ASCII_COLON)) {
+          int j;
+          for (j = 0; j < i; j++) {
+            if (! poolAppendChar(&dtd->pool, name[j]))
+              return NULL;
+          }
+          if (! poolAppendChar(&dtd->pool, XML_T('\0')))
+            return NULL;
+          id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes,
+                                        poolStart(&dtd->pool), sizeof(PREFIX));
+          if (! id->prefix)
+            return NULL;
+          if (id->prefix->name == poolStart(&dtd->pool))
+            poolFinish(&dtd->pool);
+          else
+            poolDiscard(&dtd->pool);
+          break;
+        }
+      }
+    }
+  }
+  return id;
+}
+
+#define CONTEXT_SEP XML_T(ASCII_FF)
+
+static const XML_Char *
+getContext(XML_Parser parser) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  HASH_TABLE_ITER iter;
+  XML_Bool needSep = XML_FALSE;
+
+  if (dtd->defaultPrefix.binding) {
+    int i;
+    int len;
+    if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))
+      return NULL;
+    len = dtd->defaultPrefix.binding->uriLen;
+    if (parser->m_namespaceSeparator)
+      len--;
+    for (i = 0; i < len; i++) {
+      if (! poolAppendChar(&parser->m_tempPool,
+                           dtd->defaultPrefix.binding->uri[i])) {
+        /* Because of memory caching, I don't believe this line can be
+         * executed.
+         *
+         * This is part of a loop copying the default prefix binding
+         * URI into the parser's temporary string pool.  Previously,
+         * that URI was copied into the same string pool, with a
+         * terminating NUL character, as part of setContext().  When
+         * the pool was cleared, that leaves a block definitely big
+         * enough to hold the URI on the free block list of the pool.
+         * The URI copy in getContext() therefore cannot run out of
+         * memory.
+         *
+         * If the pool is used between the setContext() and
+         * getContext() calls, the worst it can do is leave a bigger
+         * block on the front of the free list.  Given that this is
+         * all somewhat inobvious and program logic can be changed, we
+         * don't delete the line but we do exclude it from the test
+         * coverage statistics.
+         */
+        return NULL; /* LCOV_EXCL_LINE */
+      }
+    }
+    needSep = XML_TRUE;
+  }
+
+  hashTableIterInit(&iter, &(dtd->prefixes));
+  for (;;) {
+    int i;
+    int len;
+    const XML_Char *s;
+    PREFIX *prefix = (PREFIX *)hashTableIterNext(&iter);
+    if (! prefix)
+      break;
+    if (! prefix->binding) {
+      /* This test appears to be (justifiable) paranoia.  There does
+       * not seem to be a way of injecting a prefix without a binding
+       * that doesn't get errored long before this function is called.
+       * The test should remain for safety's sake, so we instead
+       * exclude the following line from the coverage statistics.
+       */
+      continue; /* LCOV_EXCL_LINE */
+    }
+    if (needSep && ! poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))
+      return NULL;
+    for (s = prefix->name; *s; s++)
+      if (! poolAppendChar(&parser->m_tempPool, *s))
+        return NULL;
+    if (! poolAppendChar(&parser->m_tempPool, XML_T(ASCII_EQUALS)))
+      return NULL;
+    len = prefix->binding->uriLen;
+    if (parser->m_namespaceSeparator)
+      len--;
+    for (i = 0; i < len; i++)
+      if (! poolAppendChar(&parser->m_tempPool, prefix->binding->uri[i]))
+        return NULL;
+    needSep = XML_TRUE;
+  }
+
+  hashTableIterInit(&iter, &(dtd->generalEntities));
+  for (;;) {
+    const XML_Char *s;
+    ENTITY *e = (ENTITY *)hashTableIterNext(&iter);
+    if (! e)
+      break;
+    if (! e->open)
+      continue;
+    if (needSep && ! poolAppendChar(&parser->m_tempPool, CONTEXT_SEP))
+      return NULL;
+    for (s = e->name; *s; s++)
+      if (! poolAppendChar(&parser->m_tempPool, *s))
+        return 0;
+    needSep = XML_TRUE;
+  }
+
+  if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
+    return NULL;
+  return parser->m_tempPool.start;
+}
+
+static XML_Bool
+setContext(XML_Parser parser, const XML_Char *context) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  const XML_Char *s = context;
+
+  while (*context != XML_T('\0')) {
+    if (*s == CONTEXT_SEP || *s == XML_T('\0')) {
+      ENTITY *e;
+      if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
+        return XML_FALSE;
+      e = (ENTITY *)lookup(parser, &dtd->generalEntities,
+                           poolStart(&parser->m_tempPool), 0);
+      if (e)
+        e->open = XML_TRUE;
+      if (*s != XML_T('\0'))
+        s++;
+      context = s;
+      poolDiscard(&parser->m_tempPool);
+    } else if (*s == XML_T(ASCII_EQUALS)) {
+      PREFIX *prefix;
+      if (poolLength(&parser->m_tempPool) == 0)
+        prefix = &dtd->defaultPrefix;
+      else {
+        if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
+          return XML_FALSE;
+        prefix
+            = (PREFIX *)lookup(parser, &dtd->prefixes,
+                               poolStart(&parser->m_tempPool), sizeof(PREFIX));
+        if (! prefix)
+          return XML_FALSE;
+        if (prefix->name == poolStart(&parser->m_tempPool)) {
+          prefix->name = poolCopyString(&dtd->pool, prefix->name);
+          if (! prefix->name)
+            return XML_FALSE;
+        }
+        poolDiscard(&parser->m_tempPool);
+      }
+      for (context = s + 1; *context != CONTEXT_SEP && *context != XML_T('\0');
+           context++)
+        if (! poolAppendChar(&parser->m_tempPool, *context))
+          return XML_FALSE;
+      if (! poolAppendChar(&parser->m_tempPool, XML_T('\0')))
+        return XML_FALSE;
+      if (addBinding(parser, prefix, NULL, poolStart(&parser->m_tempPool),
+                     &parser->m_inheritedBindings)
+          != XML_ERROR_NONE)
+        return XML_FALSE;
+      poolDiscard(&parser->m_tempPool);
+      if (*context != XML_T('\0'))
+        ++context;
+      s = context;
+    } else {
+      if (! poolAppendChar(&parser->m_tempPool, *s))
+        return XML_FALSE;
+      s++;
+    }
+  }
+  return XML_TRUE;
+}
+
+static void FASTCALL
+normalizePublicId(XML_Char *publicId) {
+  XML_Char *p = publicId;
+  XML_Char *s;
+  for (s = publicId; *s; s++) {
+    switch (*s) {
+    case 0x20:
+    case 0xD:
+    case 0xA:
+      if (p != publicId && p[-1] != 0x20)
+        *p++ = 0x20;
+      break;
+    default:
+      *p++ = *s;
+    }
+  }
+  if (p != publicId && p[-1] == 0x20)
+    --p;
+  *p = XML_T('\0');
+}
+
+static DTD *
+dtdCreate(const XML_Memory_Handling_Suite *ms) {
+  DTD *p = (DTD *)ms->malloc_fcn(sizeof(DTD));
+  if (p == NULL)
+    return p;
+  poolInit(&(p->pool), ms);
+  poolInit(&(p->entityValuePool), ms);
+  hashTableInit(&(p->generalEntities), ms);
+  hashTableInit(&(p->elementTypes), ms);
+  hashTableInit(&(p->attributeIds), ms);
+  hashTableInit(&(p->prefixes), ms);
+#ifdef XML_DTD
+  p->paramEntityRead = XML_FALSE;
+  hashTableInit(&(p->paramEntities), ms);
+#endif /* XML_DTD */
+  p->defaultPrefix.name = NULL;
+  p->defaultPrefix.binding = NULL;
+
+  p->in_eldecl = XML_FALSE;
+  p->scaffIndex = NULL;
+  p->scaffold = NULL;
+  p->scaffLevel = 0;
+  p->scaffSize = 0;
+  p->scaffCount = 0;
+  p->contentStringLen = 0;
+
+  p->keepProcessing = XML_TRUE;
+  p->hasParamEntityRefs = XML_FALSE;
+  p->standalone = XML_FALSE;
+  return p;
+}
+
+static void
+dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms) {
+  HASH_TABLE_ITER iter;
+  hashTableIterInit(&iter, &(p->elementTypes));
+  for (;;) {
+    ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
+    if (! e)
+      break;
+    if (e->allocDefaultAtts != 0)
+      ms->free_fcn(e->defaultAtts);
+  }
+  hashTableClear(&(p->generalEntities));
+#ifdef XML_DTD
+  p->paramEntityRead = XML_FALSE;
+  hashTableClear(&(p->paramEntities));
+#endif /* XML_DTD */
+  hashTableClear(&(p->elementTypes));
+  hashTableClear(&(p->attributeIds));
+  hashTableClear(&(p->prefixes));
+  poolClear(&(p->pool));
+  poolClear(&(p->entityValuePool));
+  p->defaultPrefix.name = NULL;
+  p->defaultPrefix.binding = NULL;
+
+  p->in_eldecl = XML_FALSE;
+
+  ms->free_fcn(p->scaffIndex);
+  p->scaffIndex = NULL;
+  ms->free_fcn(p->scaffold);
+  p->scaffold = NULL;
+
+  p->scaffLevel = 0;
+  p->scaffSize = 0;
+  p->scaffCount = 0;
+  p->contentStringLen = 0;
+
+  p->keepProcessing = XML_TRUE;
+  p->hasParamEntityRefs = XML_FALSE;
+  p->standalone = XML_FALSE;
+}
+
+static void
+dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms) {
+  HASH_TABLE_ITER iter;
+  hashTableIterInit(&iter, &(p->elementTypes));
+  for (;;) {
+    ELEMENT_TYPE *e = (ELEMENT_TYPE *)hashTableIterNext(&iter);
+    if (! e)
+      break;
+    if (e->allocDefaultAtts != 0)
+      ms->free_fcn(e->defaultAtts);
+  }
+  hashTableDestroy(&(p->generalEntities));
+#ifdef XML_DTD
+  hashTableDestroy(&(p->paramEntities));
+#endif /* XML_DTD */
+  hashTableDestroy(&(p->elementTypes));
+  hashTableDestroy(&(p->attributeIds));
+  hashTableDestroy(&(p->prefixes));
+  poolDestroy(&(p->pool));
+  poolDestroy(&(p->entityValuePool));
+  if (isDocEntity) {
+    ms->free_fcn(p->scaffIndex);
+    ms->free_fcn(p->scaffold);
+  }
+  ms->free_fcn(p);
+}
+
+/* Do a deep copy of the DTD. Return 0 for out of memory, non-zero otherwise.
+   The new DTD has already been initialized.
+*/
+static int
+dtdCopy(XML_Parser oldParser, DTD *newDtd, const DTD *oldDtd,
+        const XML_Memory_Handling_Suite *ms) {
+  HASH_TABLE_ITER iter;
+
+  /* Copy the prefix table. */
+
+  hashTableIterInit(&iter, &(oldDtd->prefixes));
+  for (;;) {
+    const XML_Char *name;
+    const PREFIX *oldP = (PREFIX *)hashTableIterNext(&iter);
+    if (! oldP)
+      break;
+    name = poolCopyString(&(newDtd->pool), oldP->name);
+    if (! name)
+      return 0;
+    if (! lookup(oldParser, &(newDtd->prefixes), name, sizeof(PREFIX)))
+      return 0;
+  }
+
+  hashTableIterInit(&iter, &(oldDtd->attributeIds));
+
+  /* Copy the attribute id table. */
+
+  for (;;) {
+    ATTRIBUTE_ID *newA;
+    const XML_Char *name;
+    const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID *)hashTableIterNext(&iter);
+
+    if (! oldA)
+      break;
+    /* Remember to allocate the scratch byte before the name. */
+    if (! poolAppendChar(&(newDtd->pool), XML_T('\0')))
+      return 0;
+    name = poolCopyString(&(newDtd->pool), oldA->name);
+    if (! name)
+      return 0;
+    ++name;
+    newA = (ATTRIBUTE_ID *)lookup(oldParser, &(newDtd->attributeIds), name,
+                                  sizeof(ATTRIBUTE_ID));
+    if (! newA)
+      return 0;
+    newA->maybeTokenized = oldA->maybeTokenized;
+    if (oldA->prefix) {
+      newA->xmlns = oldA->xmlns;
+      if (oldA->prefix == &oldDtd->defaultPrefix)
+        newA->prefix = &newDtd->defaultPrefix;
+      else
+        newA->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),
+                                        oldA->prefix->name, 0);
+    }
+  }
+
+  /* Copy the element type table. */
+
+  hashTableIterInit(&iter, &(oldDtd->elementTypes));
+
+  for (;;) {
+    int i;
+    ELEMENT_TYPE *newE;
+    const XML_Char *name;
+    const ELEMENT_TYPE *oldE = (ELEMENT_TYPE *)hashTableIterNext(&iter);
+    if (! oldE)
+      break;
+    name = poolCopyString(&(newDtd->pool), oldE->name);
+    if (! name)
+      return 0;
+    newE = (ELEMENT_TYPE *)lookup(oldParser, &(newDtd->elementTypes), name,
+                                  sizeof(ELEMENT_TYPE));
+    if (! newE)
+      return 0;
+    if (oldE->nDefaultAtts) {
+      newE->defaultAtts = (DEFAULT_ATTRIBUTE *)
+        ms->malloc_fcn(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
+      if (! newE->defaultAtts) {
+        return 0;
+      }
+    }
+    if (oldE->idAtt)
+      newE->idAtt = (ATTRIBUTE_ID *)lookup(oldParser, &(newDtd->attributeIds),
+                                           oldE->idAtt->name, 0);
+    newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;
+    if (oldE->prefix)
+      newE->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes),
+                                      oldE->prefix->name, 0);
+    for (i = 0; i < newE->nDefaultAtts; i++) {
+      newE->defaultAtts[i].id = (ATTRIBUTE_ID *)lookup(
+          oldParser, &(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
+      newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;
+      if (oldE->defaultAtts[i].value) {
+        newE->defaultAtts[i].value
+            = poolCopyString(&(newDtd->pool), oldE->defaultAtts[i].value);
+        if (! newE->defaultAtts[i].value)
+          return 0;
+      } else
+        newE->defaultAtts[i].value = NULL;
+    }
+  }
+
+  /* Copy the entity tables. */
+  if (! copyEntityTable(oldParser, &(newDtd->generalEntities), &(newDtd->pool),
+                        &(oldDtd->generalEntities)))
+    return 0;
+
+#ifdef XML_DTD
+  if (! copyEntityTable(oldParser, &(newDtd->paramEntities), &(newDtd->pool),
+                        &(oldDtd->paramEntities)))
+    return 0;
+  newDtd->paramEntityRead = oldDtd->paramEntityRead;
+#endif /* XML_DTD */
+
+  newDtd->keepProcessing = oldDtd->keepProcessing;
+  newDtd->hasParamEntityRefs = oldDtd->hasParamEntityRefs;
+  newDtd->standalone = oldDtd->standalone;
+
+  /* Don't want deep copying for scaffolding */
+  newDtd->in_eldecl = oldDtd->in_eldecl;
+  newDtd->scaffold = oldDtd->scaffold;
+  newDtd->contentStringLen = oldDtd->contentStringLen;
+  newDtd->scaffSize = oldDtd->scaffSize;
+  newDtd->scaffLevel = oldDtd->scaffLevel;
+  newDtd->scaffIndex = oldDtd->scaffIndex;
+
+  return 1;
+} /* End dtdCopy */
+
+static int
+copyEntityTable(XML_Parser oldParser, HASH_TABLE *newTable,
+                STRING_POOL *newPool, const HASH_TABLE *oldTable) {
+  HASH_TABLE_ITER iter;
+  const XML_Char *cachedOldBase = NULL;
+  const XML_Char *cachedNewBase = NULL;
+
+  hashTableIterInit(&iter, oldTable);
+
+  for (;;) {
+    ENTITY *newE;
+    const XML_Char *name;
+    const ENTITY *oldE = (ENTITY *)hashTableIterNext(&iter);
+    if (! oldE)
+      break;
+    name = poolCopyString(newPool, oldE->name);
+    if (! name)
+      return 0;
+    newE = (ENTITY *)lookup(oldParser, newTable, name, sizeof(ENTITY));
+    if (! newE)
+      return 0;
+    if (oldE->systemId) {
+      const XML_Char *tem = poolCopyString(newPool, oldE->systemId);
+      if (! tem)
+        return 0;
+      newE->systemId = tem;
+      if (oldE->base) {
+        if (oldE->base == cachedOldBase)
+          newE->base = cachedNewBase;
+        else {
+          cachedOldBase = oldE->base;
+          tem = poolCopyString(newPool, cachedOldBase);
+          if (! tem)
+            return 0;
+          cachedNewBase = newE->base = tem;
+        }
+      }
+      if (oldE->publicId) {
+        tem = poolCopyString(newPool, oldE->publicId);
+        if (! tem)
+          return 0;
+        newE->publicId = tem;
+      }
+    } else {
+      const XML_Char *tem
+          = poolCopyStringN(newPool, oldE->textPtr, oldE->textLen);
+      if (! tem)
+        return 0;
+      newE->textPtr = tem;
+      newE->textLen = oldE->textLen;
+    }
+    if (oldE->notation) {
+      const XML_Char *tem = poolCopyString(newPool, oldE->notation);
+      if (! tem)
+        return 0;
+      newE->notation = tem;
+    }
+    newE->is_param = oldE->is_param;
+    newE->is_internal = oldE->is_internal;
+  }
+  return 1;
+}
+
+#define INIT_POWER 6
+
+static XML_Bool FASTCALL
+keyeq(KEY s1, KEY s2) {
+  for (; *s1 == *s2; s1++, s2++)
+    if (*s1 == 0)
+      return XML_TRUE;
+  return XML_FALSE;
+}
+
+static size_t
+keylen(KEY s) {
+  size_t len = 0;
+  for (; *s; s++, len++)
+    ;
+  return len;
+}
+
+static void
+copy_salt_to_sipkey(XML_Parser parser, struct sipkey *key) {
+  key->k[0] = 0;
+  key->k[1] = get_hash_secret_salt(parser);
+}
+
+static unsigned long FASTCALL
+hash(XML_Parser parser, KEY s) {
+  struct siphash state;
+  struct sipkey key;
+  (void)sip24_valid;
+  copy_salt_to_sipkey(parser, &key);
+  sip24_init(&state, &key);
+  sip24_update(&state, s, keylen(s) * sizeof(XML_Char));
+  return (unsigned long)sip24_final(&state);
+}
+
+static NAMED *
+lookup(XML_Parser parser, HASH_TABLE *table, KEY name, size_t createSize) {
+  size_t i;
+  if (table->size == 0) {
+    size_t tsize;
+    if (! createSize)
+      return NULL;
+    table->power = INIT_POWER;
+    /* table->size is a power of 2 */
+    table->size = (size_t)1 << INIT_POWER;
+    tsize = table->size * sizeof(NAMED *);
+    table->v = (NAMED **)table->mem->malloc_fcn(tsize);
+    if (! table->v) {
+      table->size = 0;
+      return NULL;
+    }
+    memset(table->v, 0, tsize);
+    i = hash(parser, name) & ((unsigned long)table->size - 1);
+  } else {
+    unsigned long h = hash(parser, name);
+    unsigned long mask = (unsigned long)table->size - 1;
+    unsigned char step = 0;
+    i = h & mask;
+    while (table->v[i]) {
+      if (keyeq(name, table->v[i]->name))
+        return table->v[i];
+      if (! step)
+        step = PROBE_STEP(h, mask, table->power);
+      i < step ? (i += table->size - step) : (i -= step);
+    }
+    if (! createSize)
+      return NULL;
+
+    /* check for overflow (table is half full) */
+    if (table->used >> (table->power - 1)) {
+      unsigned char newPower = table->power + 1;
+
+      /* Detect and prevent invalid shift */
+      if (newPower >= sizeof(unsigned long) * 8 /* bits per byte */) {
+        return NULL;
+      }
+
+      size_t newSize = (size_t)1 << newPower;
+      unsigned long newMask = (unsigned long)newSize - 1;
+
+      /* Detect and prevent integer overflow */
+      if (newSize > (size_t)(-1) / sizeof(NAMED *)) {
+        return NULL;
+      }
+
+      size_t tsize = newSize * sizeof(NAMED *);
+      NAMED **newV = (NAMED **)table->mem->malloc_fcn(tsize);
+      if (! newV)
+        return NULL;
+      memset(newV, 0, tsize);
+      for (i = 0; i < table->size; i++)
+        if (table->v[i]) {
+          unsigned long newHash = hash(parser, table->v[i]->name);
+          size_t j = newHash & newMask;
+          step = 0;
+          while (newV[j]) {
+            if (! step)
+              step = PROBE_STEP(newHash, newMask, newPower);
+            j < step ? (j += newSize - step) : (j -= step);
+          }
+          newV[j] = table->v[i];
+        }
+      table->mem->free_fcn(table->v);
+      table->v = newV;
+      table->power = newPower;
+      table->size = newSize;
+      i = h & newMask;
+      step = 0;
+      while (table->v[i]) {
+        if (! step)
+          step = PROBE_STEP(h, newMask, newPower);
+        i < step ? (i += newSize - step) : (i -= step);
+      }
+    }
+  }
+  table->v[i] = (NAMED *)table->mem->malloc_fcn(createSize);
+  if (! table->v[i])
+    return NULL;
+  memset(table->v[i], 0, createSize);
+  table->v[i]->name = name;
+  (table->used)++;
+  return table->v[i];
+}
+
+static void FASTCALL
+hashTableClear(HASH_TABLE *table) {
+  size_t i;
+  for (i = 0; i < table->size; i++) {
+    table->mem->free_fcn(table->v[i]);
+    table->v[i] = NULL;
+  }
+  table->used = 0;
+}
+
+static void FASTCALL
+hashTableDestroy(HASH_TABLE *table) {
+  size_t i;
+  for (i = 0; i < table->size; i++)
+    table->mem->free_fcn(table->v[i]);
+  table->mem->free_fcn(table->v);
+}
+
+static void FASTCALL
+hashTableInit(HASH_TABLE *p, const XML_Memory_Handling_Suite *ms) {
+  p->power = 0;
+  p->size = 0;
+  p->used = 0;
+  p->v = NULL;
+  p->mem = ms;
+}
+
+static void FASTCALL
+hashTableIterInit(HASH_TABLE_ITER *iter, const HASH_TABLE *table) {
+  iter->p = table->v;
+  iter->end = iter->p ? iter->p + table->size : NULL;
+}
+
+static NAMED *FASTCALL
+hashTableIterNext(HASH_TABLE_ITER *iter) {
+  while (iter->p != iter->end) {
+    NAMED *tem = *(iter->p)++;
+    if (tem)
+      return tem;
+  }
+  return NULL;
+}
+
+static void FASTCALL
+poolInit(STRING_POOL *pool, const XML_Memory_Handling_Suite *ms) {
+  pool->blocks = NULL;
+  pool->freeBlocks = NULL;
+  pool->start = NULL;
+  pool->ptr = NULL;
+  pool->end = NULL;
+  pool->mem = ms;
+}
+
+static void FASTCALL
+poolClear(STRING_POOL *pool) {
+  if (! pool->freeBlocks)
+    pool->freeBlocks = pool->blocks;
+  else {
+    BLOCK *p = pool->blocks;
+    while (p) {
+      BLOCK *tem = p->next;
+      p->next = pool->freeBlocks;
+      pool->freeBlocks = p;
+      p = tem;
+    }
+  }
+  pool->blocks = NULL;
+  pool->start = NULL;
+  pool->ptr = NULL;
+  pool->end = NULL;
+}
+
+static void FASTCALL
+poolDestroy(STRING_POOL *pool) {
+  BLOCK *p = pool->blocks;
+  while (p) {
+    BLOCK *tem = p->next;
+    pool->mem->free_fcn(p);
+    p = tem;
+  }
+  p = pool->freeBlocks;
+  while (p) {
+    BLOCK *tem = p->next;
+    pool->mem->free_fcn(p);
+    p = tem;
+  }
+}
+
+static XML_Char *
+poolAppend(STRING_POOL *pool, const ENCODING *enc, const char *ptr,
+           const char *end) {
+  if (! pool->ptr && ! poolGrow(pool))
+    return NULL;
+  for (;;) {
+    const enum XML_Convert_Result convert_res = XmlConvert(
+        enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end);
+    if ((convert_res == XML_CONVERT_COMPLETED)
+        || (convert_res == XML_CONVERT_INPUT_INCOMPLETE))
+      break;
+    if (! poolGrow(pool))
+      return NULL;
+  }
+  return pool->start;
+}
+
+static const XML_Char *FASTCALL
+poolCopyString(STRING_POOL *pool, const XML_Char *s) {
+  do {
+    if (! poolAppendChar(pool, *s))
+      return NULL;
+  } while (*s++);
+  s = pool->start;
+  poolFinish(pool);
+  return s;
+}
+
+static const XML_Char *
+poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n) {
+  if (! pool->ptr && ! poolGrow(pool)) {
+    /* The following line is unreachable given the current usage of
+     * poolCopyStringN().  Currently it is called from exactly one
+     * place to copy the text of a simple general entity.  By that
+     * point, the name of the entity is already stored in the pool, so
+     * pool->ptr cannot be NULL.
+     *
+     * If poolCopyStringN() is used elsewhere as it well might be,
+     * this line may well become executable again.  Regardless, this
+     * sort of check shouldn't be removed lightly, so we just exclude
+     * it from the coverage statistics.
+     */
+    return NULL; /* LCOV_EXCL_LINE */
+  }
+  for (; n > 0; --n, s++) {
+    if (! poolAppendChar(pool, *s))
+      return NULL;
+  }
+  s = pool->start;
+  poolFinish(pool);
+  return s;
+}
+
+static const XML_Char *FASTCALL
+poolAppendString(STRING_POOL *pool, const XML_Char *s) {
+  while (*s) {
+    if (! poolAppendChar(pool, *s))
+      return NULL;
+    s++;
+  }
+  return pool->start;
+}
+
+static XML_Char *
+poolStoreString(STRING_POOL *pool, const ENCODING *enc, const char *ptr,
+                const char *end) {
+  if (! poolAppend(pool, enc, ptr, end))
+    return NULL;
+  if (pool->ptr == pool->end && ! poolGrow(pool))
+    return NULL;
+  *(pool->ptr)++ = 0;
+  return pool->start;
+}
+
+static size_t
+poolBytesToAllocateFor(int blockSize) {
+  /* Unprotected math would be:
+  ** return offsetof(BLOCK, s) + blockSize * sizeof(XML_Char);
+  **
+  ** Detect overflow, avoiding _signed_ overflow undefined behavior
+  ** For a + b * c we check b * c in isolation first, so that addition of a
+  ** on top has no chance of making us accept a small non-negative number
+  */
+  const size_t stretch = sizeof(XML_Char); /* can be 4 bytes */
+
+  if (blockSize <= 0)
+    return 0;
+
+  if (blockSize > (int)(INT_MAX / stretch))
+    return 0;
+
+  {
+    const int stretchedBlockSize = blockSize * (int)stretch;
+    const int bytesToAllocate
+        = (int)(offsetof(BLOCK, s) + (unsigned)stretchedBlockSize);
+    if (bytesToAllocate < 0)
+      return 0;
+
+    return (size_t)bytesToAllocate;
+  }
+}
+
+static XML_Bool FASTCALL
+poolGrow(STRING_POOL *pool) {
+  if (pool->freeBlocks) {
+    if (pool->start == 0) {
+      pool->blocks = pool->freeBlocks;
+      pool->freeBlocks = pool->freeBlocks->next;
+      pool->blocks->next = NULL;
+      pool->start = pool->blocks->s;
+      pool->end = pool->start + pool->blocks->size;
+      pool->ptr = pool->start;
+      return XML_TRUE;
+    }
+    if (pool->end - pool->start < pool->freeBlocks->size) {
+      BLOCK *tem = pool->freeBlocks->next;
+      pool->freeBlocks->next = pool->blocks;
+      pool->blocks = pool->freeBlocks;
+      pool->freeBlocks = tem;
+      memcpy(pool->blocks->s, pool->start,
+             (pool->end - pool->start) * sizeof(XML_Char));
+      pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
+      pool->start = pool->blocks->s;
+      pool->end = pool->start + pool->blocks->size;
+      return XML_TRUE;
+    }
+  }
+  if (pool->blocks && pool->start == pool->blocks->s) {
+    BLOCK *temp;
+    int blockSize = (int)((unsigned)(pool->end - pool->start) * 2U);
+    size_t bytesToAllocate;
+
+    /* NOTE: Needs to be calculated prior to calling `realloc`
+             to avoid dangling pointers: */
+    const ptrdiff_t offsetInsideBlock = pool->ptr - pool->start;
+
+    if (blockSize < 0) {
+      /* This condition traps a situation where either more than
+       * INT_MAX/2 bytes have already been allocated.  This isn't
+       * readily testable, since it is unlikely that an average
+       * machine will have that much memory, so we exclude it from the
+       * coverage statistics.
+       */
+      return XML_FALSE; /* LCOV_EXCL_LINE */
+    }
+
+    bytesToAllocate = poolBytesToAllocateFor(blockSize);
+    if (bytesToAllocate == 0)
+      return XML_FALSE;
+
+    temp = (BLOCK *)pool->mem->realloc_fcn(pool->blocks,
+                                           (unsigned)bytesToAllocate);
+    if (temp == NULL)
+      return XML_FALSE;
+    pool->blocks = temp;
+    pool->blocks->size = blockSize;
+    pool->ptr = pool->blocks->s + offsetInsideBlock;
+    pool->start = pool->blocks->s;
+    pool->end = pool->start + blockSize;
+  } else {
+    BLOCK *tem;
+    int blockSize = (int)(pool->end - pool->start);
+    size_t bytesToAllocate;
+
+    if (blockSize < 0) {
+      /* This condition traps a situation where either more than
+       * INT_MAX bytes have already been allocated (which is prevented
+       * by various pieces of program logic, not least this one, never
+       * mind the unlikelihood of actually having that much memory) or
+       * the pool control fields have been corrupted (which could
+       * conceivably happen in an extremely buggy user handler
+       * function).  Either way it isn't readily testable, so we
+       * exclude it from the coverage statistics.
+       */
+      return XML_FALSE; /* LCOV_EXCL_LINE */
+    }
+
+    if (blockSize < INIT_BLOCK_SIZE)
+      blockSize = INIT_BLOCK_SIZE;
+    else {
+      /* Detect overflow, avoiding _signed_ overflow undefined behavior */
+      if ((int)((unsigned)blockSize * 2U) < 0) {
+        return XML_FALSE;
+      }
+      blockSize *= 2;
+    }
+
+    bytesToAllocate = poolBytesToAllocateFor(blockSize);
+    if (bytesToAllocate == 0)
+      return XML_FALSE;
+
+    tem = (BLOCK *)pool->mem->malloc_fcn(bytesToAllocate);
+    if (! tem)
+      return XML_FALSE;
+    tem->size = blockSize;
+    tem->next = pool->blocks;
+    pool->blocks = tem;
+    if (pool->ptr != pool->start)
+      memcpy(tem->s, pool->start, (pool->ptr - pool->start) * sizeof(XML_Char));
+    pool->ptr = tem->s + (pool->ptr - pool->start);
+    pool->start = tem->s;
+    pool->end = tem->s + blockSize;
+  }
+  return XML_TRUE;
+}
+
+static int FASTCALL
+nextScaffoldPart(XML_Parser parser) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  CONTENT_SCAFFOLD *me;
+  int next;
+
+  if (! dtd->scaffIndex) {
+    dtd->scaffIndex = (int *)MALLOC(parser, parser->m_groupSize * sizeof(int));
+    if (! dtd->scaffIndex)
+      return -1;
+    dtd->scaffIndex[0] = 0;
+  }
+
+  if (dtd->scaffCount >= dtd->scaffSize) {
+    CONTENT_SCAFFOLD *temp;
+    if (dtd->scaffold) {
+      /* Detect and prevent integer overflow */
+      if (dtd->scaffSize > UINT_MAX / 2u) {
+        return -1;
+      }
+      /* Detect and prevent integer overflow.
+       * The preprocessor guard addresses the "always false" warning
+       * from -Wtype-limits on platforms where
+       * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+      if (dtd->scaffSize > (size_t)(-1) / 2u / sizeof(CONTENT_SCAFFOLD)) {
+        return -1;
+      }
+#endif
+
+      temp = (CONTENT_SCAFFOLD *)REALLOC(
+          parser, dtd->scaffold, dtd->scaffSize * 2 * sizeof(CONTENT_SCAFFOLD));
+      if (temp == NULL)
+        return -1;
+      dtd->scaffSize *= 2;
+    } else {
+      temp = (CONTENT_SCAFFOLD *)MALLOC(parser, INIT_SCAFFOLD_ELEMENTS
+                                                    * sizeof(CONTENT_SCAFFOLD));
+      if (temp == NULL)
+        return -1;
+      dtd->scaffSize = INIT_SCAFFOLD_ELEMENTS;
+    }
+    dtd->scaffold = temp;
+  }
+  next = dtd->scaffCount++;
+  me = &dtd->scaffold[next];
+  if (dtd->scaffLevel) {
+    CONTENT_SCAFFOLD *parent
+        = &dtd->scaffold[dtd->scaffIndex[dtd->scaffLevel - 1]];
+    if (parent->lastchild) {
+      dtd->scaffold[parent->lastchild].nextsib = next;
+    }
+    if (! parent->childcnt)
+      parent->firstchild = next;
+    parent->lastchild = next;
+    parent->childcnt++;
+  }
+  me->firstchild = me->lastchild = me->childcnt = me->nextsib = 0;
+  return next;
+}
+
+static XML_Content *
+build_model(XML_Parser parser) {
+  /* Function build_model transforms the existing parser->m_dtd->scaffold
+   * array of CONTENT_SCAFFOLD tree nodes into a new array of
+   * XML_Content tree nodes followed by a gapless list of zero-terminated
+   * strings. */
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  XML_Content *ret;
+  XML_Char *str; /* the current string writing location */
+
+  /* Detect and prevent integer overflow.
+   * The preprocessor guard addresses the "always false" warning
+   * from -Wtype-limits on platforms where
+   * sizeof(unsigned int) < sizeof(size_t), e.g. on x86_64. */
+#if UINT_MAX >= SIZE_MAX
+  if (dtd->scaffCount > (size_t)(-1) / sizeof(XML_Content)) {
+    return NULL;
+  }
+  if (dtd->contentStringLen > (size_t)(-1) / sizeof(XML_Char)) {
+    return NULL;
+  }
+#endif
+  if (dtd->scaffCount * sizeof(XML_Content)
+      > (size_t)(-1) - dtd->contentStringLen * sizeof(XML_Char)) {
+    return NULL;
+  }
+
+  const size_t allocsize = (dtd->scaffCount * sizeof(XML_Content)
+                            + (dtd->contentStringLen * sizeof(XML_Char)));
+
+  ret = (XML_Content *)MALLOC(parser, allocsize);
+  if (! ret)
+    return NULL;
+
+  /* What follows is an iterative implementation (of what was previously done
+   * recursively in a dedicated function called "build_node".  The old recursive
+   * build_node could be forced into stack exhaustion from input as small as a
+   * few megabyte, and so that was a security issue.  Hence, a function call
+   * stack is avoided now by resolving recursion.)
+   *
+   * The iterative approach works as follows:
+   *
+   * - We have two writing pointers, both walking up the result array; one does
+   *   the work, the other creates "jobs" for its colleague to do, and leads
+   *   the way:
+   *
+   *   - The faster one, pointer jobDest, always leads and writes "what job
+   *     to do" by the other, once they reach that place in the
+   *     array: leader "jobDest" stores the source node array index (relative
+   *     to array dtd->scaffold) in field "numchildren".
+   *
+   *   - The slower one, pointer dest, looks at the value stored in the
+   *     "numchildren" field (which actually holds a source node array index
+   *     at that time) and puts the real data from dtd->scaffold in.
+   *
+   * - Before the loop starts, jobDest writes source array index 0
+   *   (where the root node is located) so that dest will have something to do
+   *   when it starts operation.
+   *
+   * - Whenever nodes with children are encountered, jobDest appends
+   *   them as new jobs, in order.  As a result, tree node siblings are
+   *   adjacent in the resulting array, for example:
+   *
+   *     [0] root, has two children
+   *       [1] first child of 0, has three children
+   *         [3] first child of 1, does not have children
+   *         [4] second child of 1, does not have children
+   *         [5] third child of 1, does not have children
+   *       [2] second child of 0, does not have children
+   *
+   *   Or (the same data) presented in flat array view:
+   *
+   *     [0] root, has two children
+   *
+   *     [1] first child of 0, has three children
+   *     [2] second child of 0, does not have children
+   *
+   *     [3] first child of 1, does not have children
+   *     [4] second child of 1, does not have children
+   *     [5] third child of 1, does not have children
+   *
+   * - The algorithm repeats until all target array indices have been processed.
+   */
+  XML_Content *dest = ret; /* tree node writing location, moves upwards */
+  XML_Content *const destLimit = &ret[dtd->scaffCount];
+  XML_Content *jobDest = ret; /* next free writing location in target array */
+  str = (XML_Char *)&ret[dtd->scaffCount];
+
+  /* Add the starting job, the root node (index 0) of the source tree  */
+  (jobDest++)->numchildren = 0;
+
+  for (; dest < destLimit; dest++) {
+    /* Retrieve source tree array index from job storage */
+    const int src_node = (int)dest->numchildren;
+
+    /* Convert item */
+    dest->type = dtd->scaffold[src_node].type;
+    dest->quant = dtd->scaffold[src_node].quant;
+    if (dest->type == XML_CTYPE_NAME) {
+      const XML_Char *src;
+      dest->name = str;
+      src = dtd->scaffold[src_node].name;
+      for (;;) {
+        *str++ = *src;
+        if (! *src)
+          break;
+        src++;
+      }
+      dest->numchildren = 0;
+      dest->children = NULL;
+    } else {
+      unsigned int i;
+      int cn;
+      dest->name = NULL;
+      dest->numchildren = dtd->scaffold[src_node].childcnt;
+      dest->children = jobDest;
+
+      /* Append scaffold indices of children to array */
+      for (i = 0, cn = dtd->scaffold[src_node].firstchild;
+           i < dest->numchildren; i++, cn = dtd->scaffold[cn].nextsib)
+        (jobDest++)->numchildren = (unsigned int)cn;
+    }
+  }
+
+  return ret;
+}
+
+static ELEMENT_TYPE *
+getElementType(XML_Parser parser, const ENCODING *enc, const char *ptr,
+               const char *end) {
+  DTD *const dtd = parser->m_dtd; /* save one level of indirection */
+  const XML_Char *name = poolStoreString(&dtd->pool, enc, ptr, end);
+  ELEMENT_TYPE *ret;
+
+  if (! name)
+    return NULL;
+  ret = (ELEMENT_TYPE *)lookup(parser, &dtd->elementTypes, name,
+                               sizeof(ELEMENT_TYPE));
+  if (! ret)
+    return NULL;
+  if (ret->name != name)
+    poolDiscard(&dtd->pool);
+  else {
+    poolFinish(&dtd->pool);
+    if (! setElementTypePrefix(parser, ret))
+      return NULL;
+  }
+  return ret;
+}
+
+static XML_Char *
+copyString(const XML_Char *s, const XML_Memory_Handling_Suite *memsuite) {
+  size_t charsRequired = 0;
+  XML_Char *result;
+
+  /* First determine how long the string is */
+  while (s[charsRequired] != 0) {
+    charsRequired++;
+  }
+  /* Include the terminator */
+  charsRequired++;
+
+  /* Now allocate space for the copy */
+  result = (XML_Char*) memsuite->malloc_fcn(charsRequired * sizeof(XML_Char));
+  if (result == NULL)
+    return NULL;
+  /* Copy the original into place */
+  memcpy(result, s, charsRequired * sizeof(XML_Char));
+  return result;
+}
+
+#ifdef XML_DTD
+
+static float
+accountingGetCurrentAmplification(XML_Parser rootParser) {
+  const XmlBigCount countBytesOutput
+      = rootParser->m_accounting.countBytesDirect
+        + rootParser->m_accounting.countBytesIndirect;
+  const float amplificationFactor
+      = rootParser->m_accounting.countBytesDirect
+            ? (countBytesOutput
+               / (float)(rootParser->m_accounting.countBytesDirect))
+            : 1.0f;
+  assert(! rootParser->m_parentParser);
+  return amplificationFactor;
+}
+
+static void
+accountingReportStats(XML_Parser originParser, const char *epilog) {
+  const XML_Parser rootParser = getRootParserOf(originParser, NULL);
+  assert(! rootParser->m_parentParser);
+
+  if (rootParser->m_accounting.debugLevel < 1) {
+    return;
+  }
+
+  const float amplificationFactor
+      = accountingGetCurrentAmplification(rootParser);
+  fprintf(stderr,
+          "expat: Accounting(%p): Direct " EXPAT_FMT_ULL(
+              "10") ", indirect " EXPAT_FMT_ULL("10") ", amplification %8.2f%s",
+          (void *)rootParser, rootParser->m_accounting.countBytesDirect,
+          rootParser->m_accounting.countBytesIndirect,
+          (double)amplificationFactor, epilog);
+}
+
+static void
+accountingOnAbort(XML_Parser originParser) {
+  accountingReportStats(originParser, " ABORTING\n");
+}
+
+static void
+accountingReportDiff(XML_Parser rootParser,
+                     unsigned int levelsAwayFromRootParser, const char *before,
+                     const char *after, ptrdiff_t bytesMore, int source_line,
+                     enum XML_Account account) {
+  assert(! rootParser->m_parentParser);
+
+  fprintf(stderr,
+          " (+" EXPAT_FMT_PTRDIFF_T("6") " bytes %s|%d, xmlparse.c:%d) %*s\"",
+          bytesMore, (account == XML_ACCOUNT_DIRECT) ? "DIR" : "EXP",
+          levelsAwayFromRootParser, source_line, 10, "");
+
+  const char ellipis[] = "[..]";
+  const size_t ellipsisLength = sizeof(ellipis) /* because compile-time */ - 1;
+  const unsigned int contextLength = 10;
+
+  /* Note: Performance is of no concern here */
+  const char *walker = before;
+  if ((rootParser->m_accounting.debugLevel >= 3)
+      || (after - before)
+             <= (ptrdiff_t)(contextLength + ellipsisLength + contextLength)) {
+    for (; walker < after; walker++) {
+      fprintf(stderr, "%s", unsignedCharToPrintable(walker[0]));
+    }
+  } else {
+    for (; walker < before + contextLength; walker++) {
+      fprintf(stderr, "%s", unsignedCharToPrintable(walker[0]));
+    }
+    fprintf(stderr, ellipis);
+    walker = after - contextLength;
+    for (; walker < after; walker++) {
+      fprintf(stderr, "%s", unsignedCharToPrintable(walker[0]));
+    }
+  }
+  fprintf(stderr, "\"\n");
+}
+
+static XML_Bool
+accountingDiffTolerated(XML_Parser originParser, int tok, const char *before,
+                        const char *after, int source_line,
+                        enum XML_Account account) {
+  /* Note: We need to check the token type *first* to be sure that
+   *       we can even access variable <after>, safely.
+   *       E.g. for XML_TOK_NONE <after> may hold an invalid pointer. */
+  switch (tok) {
+  case XML_TOK_INVALID:
+  case XML_TOK_PARTIAL:
+  case XML_TOK_PARTIAL_CHAR:
+  case XML_TOK_NONE:
+    return XML_TRUE;
+  }
+
+  if (account == XML_ACCOUNT_NONE)
+    return XML_TRUE; /* because these bytes have been accounted for, already */
+
+  unsigned int levelsAwayFromRootParser;
+  const XML_Parser rootParser
+      = getRootParserOf(originParser, &levelsAwayFromRootParser);
+  assert(! rootParser->m_parentParser);
+
+  const int isDirect
+      = (account == XML_ACCOUNT_DIRECT) && (originParser == rootParser);
+  const ptrdiff_t bytesMore = after - before;
+
+  XmlBigCount *const additionTarget
+      = isDirect ? &rootParser->m_accounting.countBytesDirect
+                 : &rootParser->m_accounting.countBytesIndirect;
+
+  /* Detect and avoid integer overflow */
+  if (*additionTarget > (XmlBigCount)(-1) - (XmlBigCount)bytesMore)
+    return XML_FALSE;
+  *additionTarget += bytesMore;
+
+  const XmlBigCount countBytesOutput
+      = rootParser->m_accounting.countBytesDirect
+        + rootParser->m_accounting.countBytesIndirect;
+  const float amplificationFactor
+      = accountingGetCurrentAmplification(rootParser);
+  const XML_Bool tolerated
+      = (countBytesOutput < rootParser->m_accounting.activationThresholdBytes)
+        || (amplificationFactor
+            <= rootParser->m_accounting.maximumAmplificationFactor);
+
+  if (rootParser->m_accounting.debugLevel >= 2) {
+    accountingReportStats(rootParser, "");
+    accountingReportDiff(rootParser, levelsAwayFromRootParser, before, after,
+                         bytesMore, source_line, account);
+  }
+
+  return tolerated;
+}
+
+unsigned long long
+testingAccountingGetCountBytesDirect(XML_Parser parser) {
+  if (! parser)
+    return 0;
+  return parser->m_accounting.countBytesDirect;
+}
+
+unsigned long long
+testingAccountingGetCountBytesIndirect(XML_Parser parser) {
+  if (! parser)
+    return 0;
+  return parser->m_accounting.countBytesIndirect;
+}
+
+static void
+entityTrackingReportStats(XML_Parser rootParser, ENTITY *entity,
+                          const char *action, int sourceLine) {
+  assert(! rootParser->m_parentParser);
+  if (rootParser->m_entity_stats.debugLevel < 1)
+    return;
+
+#  if defined(XML_UNICODE)
+  const char *const entityName = "[..]";
+#  else
+  const char *const entityName = entity->name;
+#  endif
+
+  fprintf(
+      stderr,
+      "expat: Entities(%p): Count %9d, depth %2d/%2d %*s%s%s; %s length %d (xmlparse.c:%d)\n",
+      (void *)rootParser, rootParser->m_entity_stats.countEverOpened,
+      rootParser->m_entity_stats.currentDepth,
+      rootParser->m_entity_stats.maximumDepthSeen,
+      (rootParser->m_entity_stats.currentDepth - 1) * 2, "",
+      entity->is_param ? "%" : "&", entityName, action, entity->textLen,
+      sourceLine);
+}
+
+static void
+entityTrackingOnOpen(XML_Parser originParser, ENTITY *entity, int sourceLine) {
+  const XML_Parser rootParser = getRootParserOf(originParser, NULL);
+  assert(! rootParser->m_parentParser);
+
+  rootParser->m_entity_stats.countEverOpened++;
+  rootParser->m_entity_stats.currentDepth++;
+  if (rootParser->m_entity_stats.currentDepth
+      > rootParser->m_entity_stats.maximumDepthSeen) {
+    rootParser->m_entity_stats.maximumDepthSeen++;
+  }
+
+  entityTrackingReportStats(rootParser, entity, "OPEN ", sourceLine);
+}
+
+static void
+entityTrackingOnClose(XML_Parser originParser, ENTITY *entity, int sourceLine) {
+  const XML_Parser rootParser = getRootParserOf(originParser, NULL);
+  assert(! rootParser->m_parentParser);
+
+  entityTrackingReportStats(rootParser, entity, "CLOSE", sourceLine);
+  rootParser->m_entity_stats.currentDepth--;
+}
+
+static XML_Parser
+getRootParserOf(XML_Parser parser, unsigned int *outLevelDiff) {
+  XML_Parser rootParser = parser;
+  unsigned int stepsTakenUpwards = 0;
+  while (rootParser->m_parentParser) {
+    rootParser = rootParser->m_parentParser;
+    stepsTakenUpwards++;
+  }
+  assert(! rootParser->m_parentParser);
+  if (outLevelDiff != NULL) {
+    *outLevelDiff = stepsTakenUpwards;
+  }
+  return rootParser;
+}
+
+const char *
+unsignedCharToPrintable(unsigned char c) {
+  switch (c) {
+  case 0:
+    return "\\0";
+  case 1:
+    return "\\x1";
+  case 2:
+    return "\\x2";
+  case 3:
+    return "\\x3";
+  case 4:
+    return "\\x4";
+  case 5:
+    return "\\x5";
+  case 6:
+    return "\\x6";
+  case 7:
+    return "\\x7";
+  case 8:
+    return "\\x8";
+  case 9:
+    return "\\t";
+  case 10:
+    return "\\n";
+  case 11:
+    return "\\xB";
+  case 12:
+    return "\\xC";
+  case 13:
+    return "\\r";
+  case 14:
+    return "\\xE";
+  case 15:
+    return "\\xF";
+  case 16:
+    return "\\x10";
+  case 17:
+    return "\\x11";
+  case 18:
+    return "\\x12";
+  case 19:
+    return "\\x13";
+  case 20:
+    return "\\x14";
+  case 21:
+    return "\\x15";
+  case 22:
+    return "\\x16";
+  case 23:
+    return "\\x17";
+  case 24:
+    return "\\x18";
+  case 25:
+    return "\\x19";
+  case 26:
+    return "\\x1A";
+  case 27:
+    return "\\x1B";
+  case 28:
+    return "\\x1C";
+  case 29:
+    return "\\x1D";
+  case 30:
+    return "\\x1E";
+  case 31:
+    return "\\x1F";
+  case 32:
+    return " ";
+  case 33:
+    return "!";
+  case 34:
+    return "\\\"";
+  case 35:
+    return "#";
+  case 36:
+    return "$";
+  case 37:
+    return "%";
+  case 38:
+    return "&";
+  case 39:
+    return "'";
+  case 40:
+    return "(";
+  case 41:
+    return ")";
+  case 42:
+    return "*";
+  case 43:
+    return "+";
+  case 44:
+    return ",";
+  case 45:
+    return "-";
+  case 46:
+    return ".";
+  case 47:
+    return "/";
+  case 48:
+    return "0";
+  case 49:
+    return "1";
+  case 50:
+    return "2";
+  case 51:
+    return "3";
+  case 52:
+    return "4";
+  case 53:
+    return "5";
+  case 54:
+    return "6";
+  case 55:
+    return "7";
+  case 56:
+    return "8";
+  case 57:
+    return "9";
+  case 58:
+    return ":";
+  case 59:
+    return ";";
+  case 60:
+    return "<";
+  case 61:
+    return "=";
+  case 62:
+    return ">";
+  case 63:
+    return "?";
+  case 64:
+    return "@";
+  case 65:
+    return "A";
+  case 66:
+    return "B";
+  case 67:
+    return "C";
+  case 68:
+    return "D";
+  case 69:
+    return "E";
+  case 70:
+    return "F";
+  case 71:
+    return "G";
+  case 72:
+    return "H";
+  case 73:
+    return "I";
+  case 74:
+    return "J";
+  case 75:
+    return "K";
+  case 76:
+    return "L";
+  case 77:
+    return "M";
+  case 78:
+    return "N";
+  case 79:
+    return "O";
+  case 80:
+    return "P";
+  case 81:
+    return "Q";
+  case 82:
+    return "R";
+  case 83:
+    return "S";
+  case 84:
+    return "T";
+  case 85:
+    return "U";
+  case 86:
+    return "V";
+  case 87:
+    return "W";
+  case 88:
+    return "X";
+  case 89:
+    return "Y";
+  case 90:
+    return "Z";
+  case 91:
+    return "[";
+  case 92:
+    return "\\\\";
+  case 93:
+    return "]";
+  case 94:
+    return "^";
+  case 95:
+    return "_";
+  case 96:
+    return "`";
+  case 97:
+    return "a";
+  case 98:
+    return "b";
+  case 99:
+    return "c";
+  case 100:
+    return "d";
+  case 101:
+    return "e";
+  case 102:
+    return "f";
+  case 103:
+    return "g";
+  case 104:
+    return "h";
+  case 105:
+    return "i";
+  case 106:
+    return "j";
+  case 107:
+    return "k";
+  case 108:
+    return "l";
+  case 109:
+    return "m";
+  case 110:
+    return "n";
+  case 111:
+    return "o";
+  case 112:
+    return "p";
+  case 113:
+    return "q";
+  case 114:
+    return "r";
+  case 115:
+    return "s";
+  case 116:
+    return "t";
+  case 117:
+    return "u";
+  case 118:
+    return "v";
+  case 119:
+    return "w";
+  case 120:
+    return "x";
+  case 121:
+    return "y";
+  case 122:
+    return "z";
+  case 123:
+    return "{";
+  case 124:
+    return "|";
+  case 125:
+    return "}";
+  case 126:
+    return "~";
+  case 127:
+    return "\\x7F";
+  case 128:
+    return "\\x80";
+  case 129:
+    return "\\x81";
+  case 130:
+    return "\\x82";
+  case 131:
+    return "\\x83";
+  case 132:
+    return "\\x84";
+  case 133:
+    return "\\x85";
+  case 134:
+    return "\\x86";
+  case 135:
+    return "\\x87";
+  case 136:
+    return "\\x88";
+  case 137:
+    return "\\x89";
+  case 138:
+    return "\\x8A";
+  case 139:
+    return "\\x8B";
+  case 140:
+    return "\\x8C";
+  case 141:
+    return "\\x8D";
+  case 142:
+    return "\\x8E";
+  case 143:
+    return "\\x8F";
+  case 144:
+    return "\\x90";
+  case 145:
+    return "\\x91";
+  case 146:
+    return "\\x92";
+  case 147:
+    return "\\x93";
+  case 148:
+    return "\\x94";
+  case 149:
+    return "\\x95";
+  case 150:
+    return "\\x96";
+  case 151:
+    return "\\x97";
+  case 152:
+    return "\\x98";
+  case 153:
+    return "\\x99";
+  case 154:
+    return "\\x9A";
+  case 155:
+    return "\\x9B";
+  case 156:
+    return "\\x9C";
+  case 157:
+    return "\\x9D";
+  case 158:
+    return "\\x9E";
+  case 159:
+    return "\\x9F";
+  case 160:
+    return "\\xA0";
+  case 161:
+    return "\\xA1";
+  case 162:
+    return "\\xA2";
+  case 163:
+    return "\\xA3";
+  case 164:
+    return "\\xA4";
+  case 165:
+    return "\\xA5";
+  case 166:
+    return "\\xA6";
+  case 167:
+    return "\\xA7";
+  case 168:
+    return "\\xA8";
+  case 169:
+    return "\\xA9";
+  case 170:
+    return "\\xAA";
+  case 171:
+    return "\\xAB";
+  case 172:
+    return "\\xAC";
+  case 173:
+    return "\\xAD";
+  case 174:
+    return "\\xAE";
+  case 175:
+    return "\\xAF";
+  case 176:
+    return "\\xB0";
+  case 177:
+    return "\\xB1";
+  case 178:
+    return "\\xB2";
+  case 179:
+    return "\\xB3";
+  case 180:
+    return "\\xB4";
+  case 181:
+    return "\\xB5";
+  case 182:
+    return "\\xB6";
+  case 183:
+    return "\\xB7";
+  case 184:
+    return "\\xB8";
+  case 185:
+    return "\\xB9";
+  case 186:
+    return "\\xBA";
+  case 187:
+    return "\\xBB";
+  case 188:
+    return "\\xBC";
+  case 189:
+    return "\\xBD";
+  case 190:
+    return "\\xBE";
+  case 191:
+    return "\\xBF";
+  case 192:
+    return "\\xC0";
+  case 193:
+    return "\\xC1";
+  case 194:
+    return "\\xC2";
+  case 195:
+    return "\\xC3";
+  case 196:
+    return "\\xC4";
+  case 197:
+    return "\\xC5";
+  case 198:
+    return "\\xC6";
+  case 199:
+    return "\\xC7";
+  case 200:
+    return "\\xC8";
+  case 201:
+    return "\\xC9";
+  case 202:
+    return "\\xCA";
+  case 203:
+    return "\\xCB";
+  case 204:
+    return "\\xCC";
+  case 205:
+    return "\\xCD";
+  case 206:
+    return "\\xCE";
+  case 207:
+    return "\\xCF";
+  case 208:
+    return "\\xD0";
+  case 209:
+    return "\\xD1";
+  case 210:
+    return "\\xD2";
+  case 211:
+    return "\\xD3";
+  case 212:
+    return "\\xD4";
+  case 213:
+    return "\\xD5";
+  case 214:
+    return "\\xD6";
+  case 215:
+    return "\\xD7";
+  case 216:
+    return "\\xD8";
+  case 217:
+    return "\\xD9";
+  case 218:
+    return "\\xDA";
+  case 219:
+    return "\\xDB";
+  case 220:
+    return "\\xDC";
+  case 221:
+    return "\\xDD";
+  case 222:
+    return "\\xDE";
+  case 223:
+    return "\\xDF";
+  case 224:
+    return "\\xE0";
+  case 225:
+    return "\\xE1";
+  case 226:
+    return "\\xE2";
+  case 227:
+    return "\\xE3";
+  case 228:
+    return "\\xE4";
+  case 229:
+    return "\\xE5";
+  case 230:
+    return "\\xE6";
+  case 231:
+    return "\\xE7";
+  case 232:
+    return "\\xE8";
+  case 233:
+    return "\\xE9";
+  case 234:
+    return "\\xEA";
+  case 235:
+    return "\\xEB";
+  case 236:
+    return "\\xEC";
+  case 237:
+    return "\\xED";
+  case 238:
+    return "\\xEE";
+  case 239:
+    return "\\xEF";
+  case 240:
+    return "\\xF0";
+  case 241:
+    return "\\xF1";
+  case 242:
+    return "\\xF2";
+  case 243:
+    return "\\xF3";
+  case 244:
+    return "\\xF4";
+  case 245:
+    return "\\xF5";
+  case 246:
+    return "\\xF6";
+  case 247:
+    return "\\xF7";
+  case 248:
+    return "\\xF8";
+  case 249:
+    return "\\xF9";
+  case 250:
+    return "\\xFA";
+  case 251:
+    return "\\xFB";
+  case 252:
+    return "\\xFC";
+  case 253:
+    return "\\xFD";
+  case 254:
+    return "\\xFE";
+  case 255:
+    return "\\xFF";
+  default:
+    assert(0); /* never gets here */
+    return "dead code";
+  }
+  assert(0); /* never gets here */
+}
+
+#endif /* XML_DTD */
+
+static unsigned long
+getDebugLevel(const char *variableName, unsigned long defaultDebugLevel) {
+  const char *const valueOrNull = getenv(variableName);
+  if (valueOrNull == NULL) {
+    return defaultDebugLevel;
+  }
+  const char *const value = valueOrNull;
+
+  errno = 0;
+  char *afterValue = (char *)value;
+  unsigned long debugLevel = strtoul(value, &afterValue, 10);
+  if ((errno != 0) || (afterValue[0] != '\0')) {
+    errno = 0;
+    return defaultDebugLevel;
+  }
+
+  return debugLevel;
+}
diff --git a/base/poco/XML/src/xmlrole.c b/base/poco/XML/src/xmlrole.c
new file mode 100644
index 00000000000..1c88fd0bf3a
--- /dev/null
+++ b/base/poco/XML/src/xmlrole.c
@@ -0,0 +1,1255 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Greg Stein <gstein@users.sourceforge.net>
+   Copyright (c) 2002-2006 Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2002-2003 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2005-2009 Steven Solie <steven@solie.ca>
+   Copyright (c) 2016-2021 Sebastian Pipping <sebastian@pipping.org>
+   Copyright (c) 2017      Rhodri James <rhodri@wildebeest.org.uk>
+   Copyright (c) 2019      David Loffredo <loffredo@steptools.com>
+   Copyright (c) 2021      Dong-hee Na <donghee.na@python.org>
+   Licensed under the MIT license:
+
+   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.
+*/
+
+#include <stddef.h>
+
+#ifdef EXPAT_WIN32
+#include "winconfig.h"
+#endif
+
+#include "expat_config.h"
+
+#include "Poco/XML/expat_external.h"
+#include "internal.h"
+#include "xmlrole.h"
+#include "ascii.h"
+
+/* Doesn't check:
+
+ that ,| are not mixed in a model group
+ content of literals
+
+*/
+
+static const char KW_ANY[] = {ASCII_A, ASCII_N, ASCII_Y, '\0'};
+static const char KW_ATTLIST[]
+    = {ASCII_A, ASCII_T, ASCII_T, ASCII_L, ASCII_I, ASCII_S, ASCII_T, '\0'};
+static const char KW_CDATA[]
+    = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
+static const char KW_DOCTYPE[]
+    = {ASCII_D, ASCII_O, ASCII_C, ASCII_T, ASCII_Y, ASCII_P, ASCII_E, '\0'};
+static const char KW_ELEMENT[]
+    = {ASCII_E, ASCII_L, ASCII_E, ASCII_M, ASCII_E, ASCII_N, ASCII_T, '\0'};
+static const char KW_EMPTY[]
+    = {ASCII_E, ASCII_M, ASCII_P, ASCII_T, ASCII_Y, '\0'};
+static const char KW_ENTITIES[] = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T,
+                                   ASCII_I, ASCII_E, ASCII_S, '\0'};
+static const char KW_ENTITY[]
+    = {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0'};
+static const char KW_FIXED[]
+    = {ASCII_F, ASCII_I, ASCII_X, ASCII_E, ASCII_D, '\0'};
+static const char KW_ID[] = {ASCII_I, ASCII_D, '\0'};
+static const char KW_IDREF[]
+    = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0'};
+static const char KW_IDREFS[]
+    = {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0'};
+#ifdef XML_DTD
+static const char KW_IGNORE[]
+    = {ASCII_I, ASCII_G, ASCII_N, ASCII_O, ASCII_R, ASCII_E, '\0'};
+#endif
+static const char KW_IMPLIED[]
+    = {ASCII_I, ASCII_M, ASCII_P, ASCII_L, ASCII_I, ASCII_E, ASCII_D, '\0'};
+#ifdef XML_DTD
+static const char KW_INCLUDE[]
+    = {ASCII_I, ASCII_N, ASCII_C, ASCII_L, ASCII_U, ASCII_D, ASCII_E, '\0'};
+#endif
+static const char KW_NDATA[]
+    = {ASCII_N, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
+static const char KW_NMTOKEN[]
+    = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0'};
+static const char KW_NMTOKENS[] = {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K,
+                                   ASCII_E, ASCII_N, ASCII_S, '\0'};
+static const char KW_NOTATION[] = {ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T,
+                                   ASCII_I, ASCII_O, ASCII_N, '\0'};
+static const char KW_PCDATA[]
+    = {ASCII_P, ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
+static const char KW_PUBLIC[]
+    = {ASCII_P, ASCII_U, ASCII_B, ASCII_L, ASCII_I, ASCII_C, '\0'};
+static const char KW_REQUIRED[] = {ASCII_R, ASCII_E, ASCII_Q, ASCII_U, ASCII_I,
+                                   ASCII_R, ASCII_E, ASCII_D, '\0'};
+static const char KW_SYSTEM[]
+    = {ASCII_S, ASCII_Y, ASCII_S, ASCII_T, ASCII_E, ASCII_M, '\0'};
+
+#ifndef MIN_BYTES_PER_CHAR
+#  define MIN_BYTES_PER_CHAR(enc) ((enc)->minBytesPerChar)
+#endif
+
+#ifdef XML_DTD
+#  define setTopLevel(state)                                                   \
+    ((state)->handler                                                          \
+     = ((state)->documentEntity ? internalSubset : externalSubset1))
+#else /* not XML_DTD */
+#  define setTopLevel(state) ((state)->handler = internalSubset)
+#endif /* not XML_DTD */
+
+typedef int PTRCALL PROLOG_HANDLER(PROLOG_STATE *state, int tok,
+                                   const char *ptr, const char *end,
+                                   const ENCODING *enc);
+
+static PROLOG_HANDLER prolog0, prolog1, prolog2, doctype0, doctype1, doctype2,
+    doctype3, doctype4, doctype5, internalSubset, entity0, entity1, entity2,
+    entity3, entity4, entity5, entity6, entity7, entity8, entity9, entity10,
+    notation0, notation1, notation2, notation3, notation4, attlist0, attlist1,
+    attlist2, attlist3, attlist4, attlist5, attlist6, attlist7, attlist8,
+    attlist9, element0, element1, element2, element3, element4, element5,
+    element6, element7,
+#ifdef XML_DTD
+    externalSubset0, externalSubset1, condSect0, condSect1, condSect2,
+#endif /* XML_DTD */
+    declClose, error;
+
+static int FASTCALL common(PROLOG_STATE *state, int tok);
+
+static int PTRCALL
+prolog0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    state->handler = prolog1;
+    return XML_ROLE_NONE;
+  case XML_TOK_XML_DECL:
+    state->handler = prolog1;
+    return XML_ROLE_XML_DECL;
+  case XML_TOK_PI:
+    state->handler = prolog1;
+    return XML_ROLE_PI;
+  case XML_TOK_COMMENT:
+    state->handler = prolog1;
+    return XML_ROLE_COMMENT;
+  case XML_TOK_BOM:
+    return XML_ROLE_NONE;
+  case XML_TOK_DECL_OPEN:
+    if (! XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
+                              KW_DOCTYPE))
+      break;
+    state->handler = doctype0;
+    return XML_ROLE_DOCTYPE_NONE;
+  case XML_TOK_INSTANCE_START:
+    state->handler = error;
+    return XML_ROLE_INSTANCE_START;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+prolog1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_PI:
+    return XML_ROLE_PI;
+  case XML_TOK_COMMENT:
+    return XML_ROLE_COMMENT;
+  case XML_TOK_BOM:
+    /* This case can never arise.  To reach this role function, the
+     * parse must have passed through prolog0 and therefore have had
+     * some form of input, even if only a space.  At that point, a
+     * byte order mark is no longer a valid character (though
+     * technically it should be interpreted as a non-breaking space),
+     * so will be rejected by the tokenizing stages.
+     */
+    return XML_ROLE_NONE; /* LCOV_EXCL_LINE */
+  case XML_TOK_DECL_OPEN:
+    if (! XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
+                              KW_DOCTYPE))
+      break;
+    state->handler = doctype0;
+    return XML_ROLE_DOCTYPE_NONE;
+  case XML_TOK_INSTANCE_START:
+    state->handler = error;
+    return XML_ROLE_INSTANCE_START;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+prolog2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_PI:
+    return XML_ROLE_PI;
+  case XML_TOK_COMMENT:
+    return XML_ROLE_COMMENT;
+  case XML_TOK_INSTANCE_START:
+    state->handler = error;
+    return XML_ROLE_INSTANCE_START;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+doctype0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_DOCTYPE_NONE;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = doctype1;
+    return XML_ROLE_DOCTYPE_NAME;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+doctype1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_DOCTYPE_NONE;
+  case XML_TOK_OPEN_BRACKET:
+    state->handler = internalSubset;
+    return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
+  case XML_TOK_DECL_CLOSE:
+    state->handler = prolog2;
+    return XML_ROLE_DOCTYPE_CLOSE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
+      state->handler = doctype3;
+      return XML_ROLE_DOCTYPE_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
+      state->handler = doctype2;
+      return XML_ROLE_DOCTYPE_NONE;
+    }
+    break;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+doctype2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_DOCTYPE_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = doctype3;
+    return XML_ROLE_DOCTYPE_PUBLIC_ID;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+doctype3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_DOCTYPE_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = doctype4;
+    return XML_ROLE_DOCTYPE_SYSTEM_ID;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+doctype4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_DOCTYPE_NONE;
+  case XML_TOK_OPEN_BRACKET:
+    state->handler = internalSubset;
+    return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
+  case XML_TOK_DECL_CLOSE:
+    state->handler = prolog2;
+    return XML_ROLE_DOCTYPE_CLOSE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+doctype5(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_DOCTYPE_NONE;
+  case XML_TOK_DECL_CLOSE:
+    state->handler = prolog2;
+    return XML_ROLE_DOCTYPE_CLOSE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+internalSubset(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+               const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_DECL_OPEN:
+    if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
+                            KW_ENTITY)) {
+      state->handler = entity0;
+      return XML_ROLE_ENTITY_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
+                            KW_ATTLIST)) {
+      state->handler = attlist0;
+      return XML_ROLE_ATTLIST_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
+                            KW_ELEMENT)) {
+      state->handler = element0;
+      return XML_ROLE_ELEMENT_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr + 2 * MIN_BYTES_PER_CHAR(enc), end,
+                            KW_NOTATION)) {
+      state->handler = notation0;
+      return XML_ROLE_NOTATION_NONE;
+    }
+    break;
+  case XML_TOK_PI:
+    return XML_ROLE_PI;
+  case XML_TOK_COMMENT:
+    return XML_ROLE_COMMENT;
+  case XML_TOK_PARAM_ENTITY_REF:
+    return XML_ROLE_PARAM_ENTITY_REF;
+  case XML_TOK_CLOSE_BRACKET:
+    state->handler = doctype5;
+    return XML_ROLE_DOCTYPE_NONE;
+  case XML_TOK_NONE:
+    return XML_ROLE_NONE;
+  }
+  return common(state, tok);
+}
+
+#ifdef XML_DTD
+
+static int PTRCALL
+externalSubset0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+                const ENCODING *enc) {
+  state->handler = externalSubset1;
+  if (tok == XML_TOK_XML_DECL)
+    return XML_ROLE_TEXT_DECL;
+  return externalSubset1(state, tok, ptr, end, enc);
+}
+
+static int PTRCALL
+externalSubset1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+                const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_COND_SECT_OPEN:
+    state->handler = condSect0;
+    return XML_ROLE_NONE;
+  case XML_TOK_COND_SECT_CLOSE:
+    if (state->includeLevel == 0)
+      break;
+    state->includeLevel -= 1;
+    return XML_ROLE_NONE;
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_CLOSE_BRACKET:
+    break;
+  case XML_TOK_NONE:
+    if (state->includeLevel)
+      break;
+    return XML_ROLE_NONE;
+  default:
+    return internalSubset(state, tok, ptr, end, enc);
+  }
+  return common(state, tok);
+}
+
+#endif /* XML_DTD */
+
+static int PTRCALL
+entity0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_PERCENT:
+    state->handler = entity1;
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_NAME:
+    state->handler = entity2;
+    return XML_ROLE_GENERAL_ENTITY_NAME;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_NAME:
+    state->handler = entity7;
+    return XML_ROLE_PARAM_ENTITY_NAME;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
+      state->handler = entity4;
+      return XML_ROLE_ENTITY_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
+      state->handler = entity3;
+      return XML_ROLE_ENTITY_NONE;
+    }
+    break;
+  case XML_TOK_LITERAL:
+    state->handler = declClose;
+    state->role_none = XML_ROLE_ENTITY_NONE;
+    return XML_ROLE_ENTITY_VALUE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = entity4;
+    return XML_ROLE_ENTITY_PUBLIC_ID;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = entity5;
+    return XML_ROLE_ENTITY_SYSTEM_ID;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity5(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_DECL_CLOSE:
+    setTopLevel(state);
+    return XML_ROLE_ENTITY_COMPLETE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_NDATA)) {
+      state->handler = entity6;
+      return XML_ROLE_ENTITY_NONE;
+    }
+    break;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity6(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_NAME:
+    state->handler = declClose;
+    state->role_none = XML_ROLE_ENTITY_NONE;
+    return XML_ROLE_ENTITY_NOTATION_NAME;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity7(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
+      state->handler = entity9;
+      return XML_ROLE_ENTITY_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
+      state->handler = entity8;
+      return XML_ROLE_ENTITY_NONE;
+    }
+    break;
+  case XML_TOK_LITERAL:
+    state->handler = declClose;
+    state->role_none = XML_ROLE_ENTITY_NONE;
+    return XML_ROLE_ENTITY_VALUE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity8(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = entity9;
+    return XML_ROLE_ENTITY_PUBLIC_ID;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity9(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+        const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = entity10;
+    return XML_ROLE_ENTITY_SYSTEM_ID;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+entity10(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ENTITY_NONE;
+  case XML_TOK_DECL_CLOSE:
+    setTopLevel(state);
+    return XML_ROLE_ENTITY_COMPLETE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+notation0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NOTATION_NONE;
+  case XML_TOK_NAME:
+    state->handler = notation1;
+    return XML_ROLE_NOTATION_NAME;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+notation1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NOTATION_NONE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
+      state->handler = notation3;
+      return XML_ROLE_NOTATION_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
+      state->handler = notation2;
+      return XML_ROLE_NOTATION_NONE;
+    }
+    break;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+notation2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NOTATION_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = notation4;
+    return XML_ROLE_NOTATION_PUBLIC_ID;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+notation3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NOTATION_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = declClose;
+    state->role_none = XML_ROLE_NOTATION_NONE;
+    return XML_ROLE_NOTATION_SYSTEM_ID;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+notation4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NOTATION_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = declClose;
+    state->role_none = XML_ROLE_NOTATION_NONE;
+    return XML_ROLE_NOTATION_SYSTEM_ID;
+  case XML_TOK_DECL_CLOSE:
+    setTopLevel(state);
+    return XML_ROLE_NOTATION_NO_SYSTEM_ID;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+attlist0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = attlist1;
+    return XML_ROLE_ATTLIST_ELEMENT_NAME;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+attlist1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_DECL_CLOSE:
+    setTopLevel(state);
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = attlist2;
+    return XML_ROLE_ATTRIBUTE_NAME;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+attlist2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_NAME: {
+    static const char *const types[] = {
+        KW_CDATA,  KW_ID,       KW_IDREF,   KW_IDREFS,
+        KW_ENTITY, KW_ENTITIES, KW_NMTOKEN, KW_NMTOKENS,
+    };
+    int i;
+    for (i = 0; i < (int)(sizeof(types) / sizeof(types[0])); i++)
+      if (XmlNameMatchesAscii(enc, ptr, end, types[i])) {
+        state->handler = attlist8;
+        return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
+      }
+  }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) {
+      state->handler = attlist5;
+      return XML_ROLE_ATTLIST_NONE;
+    }
+    break;
+  case XML_TOK_OPEN_PAREN:
+    state->handler = attlist3;
+    return XML_ROLE_ATTLIST_NONE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+attlist3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_NMTOKEN:
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = attlist4;
+    return XML_ROLE_ATTRIBUTE_ENUM_VALUE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+attlist4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_CLOSE_PAREN:
+    state->handler = attlist8;
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_OR:
+    state->handler = attlist3;
+    return XML_ROLE_ATTLIST_NONE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+attlist5(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_OPEN_PAREN:
+    state->handler = attlist6;
+    return XML_ROLE_ATTLIST_NONE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+attlist6(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_NAME:
+    state->handler = attlist7;
+    return XML_ROLE_ATTRIBUTE_NOTATION_VALUE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+attlist7(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_CLOSE_PAREN:
+    state->handler = attlist8;
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_OR:
+    state->handler = attlist6;
+    return XML_ROLE_ATTLIST_NONE;
+  }
+  return common(state, tok);
+}
+
+/* default value */
+static int PTRCALL
+attlist8(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_POUND_NAME:
+    if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end,
+                            KW_IMPLIED)) {
+      state->handler = attlist1;
+      return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end,
+                            KW_REQUIRED)) {
+      state->handler = attlist1;
+      return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end,
+                            KW_FIXED)) {
+      state->handler = attlist9;
+      return XML_ROLE_ATTLIST_NONE;
+    }
+    break;
+  case XML_TOK_LITERAL:
+    state->handler = attlist1;
+    return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+attlist9(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ATTLIST_NONE;
+  case XML_TOK_LITERAL:
+    state->handler = attlist1;
+    return XML_ROLE_FIXED_ATTRIBUTE_VALUE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+element0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ELEMENT_NONE;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = element1;
+    return XML_ROLE_ELEMENT_NAME;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+element1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ELEMENT_NONE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) {
+      state->handler = declClose;
+      state->role_none = XML_ROLE_ELEMENT_NONE;
+      return XML_ROLE_CONTENT_EMPTY;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) {
+      state->handler = declClose;
+      state->role_none = XML_ROLE_ELEMENT_NONE;
+      return XML_ROLE_CONTENT_ANY;
+    }
+    break;
+  case XML_TOK_OPEN_PAREN:
+    state->handler = element2;
+    state->level = 1;
+    return XML_ROLE_GROUP_OPEN;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+element2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ELEMENT_NONE;
+  case XML_TOK_POUND_NAME:
+    if (XmlNameMatchesAscii(enc, ptr + MIN_BYTES_PER_CHAR(enc), end,
+                            KW_PCDATA)) {
+      state->handler = element3;
+      return XML_ROLE_CONTENT_PCDATA;
+    }
+    break;
+  case XML_TOK_OPEN_PAREN:
+    state->level = 2;
+    state->handler = element6;
+    return XML_ROLE_GROUP_OPEN;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT;
+  case XML_TOK_NAME_QUESTION:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT_OPT;
+  case XML_TOK_NAME_ASTERISK:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT_REP;
+  case XML_TOK_NAME_PLUS:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT_PLUS;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+element3(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ELEMENT_NONE;
+  case XML_TOK_CLOSE_PAREN:
+    state->handler = declClose;
+    state->role_none = XML_ROLE_ELEMENT_NONE;
+    return XML_ROLE_GROUP_CLOSE;
+  case XML_TOK_CLOSE_PAREN_ASTERISK:
+    state->handler = declClose;
+    state->role_none = XML_ROLE_ELEMENT_NONE;
+    return XML_ROLE_GROUP_CLOSE_REP;
+  case XML_TOK_OR:
+    state->handler = element4;
+    return XML_ROLE_ELEMENT_NONE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+element4(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ELEMENT_NONE;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = element5;
+    return XML_ROLE_CONTENT_ELEMENT;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+element5(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ELEMENT_NONE;
+  case XML_TOK_CLOSE_PAREN_ASTERISK:
+    state->handler = declClose;
+    state->role_none = XML_ROLE_ELEMENT_NONE;
+    return XML_ROLE_GROUP_CLOSE_REP;
+  case XML_TOK_OR:
+    state->handler = element4;
+    return XML_ROLE_ELEMENT_NONE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+element6(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ELEMENT_NONE;
+  case XML_TOK_OPEN_PAREN:
+    state->level += 1;
+    return XML_ROLE_GROUP_OPEN;
+  case XML_TOK_NAME:
+  case XML_TOK_PREFIXED_NAME:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT;
+  case XML_TOK_NAME_QUESTION:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT_OPT;
+  case XML_TOK_NAME_ASTERISK:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT_REP;
+  case XML_TOK_NAME_PLUS:
+    state->handler = element7;
+    return XML_ROLE_CONTENT_ELEMENT_PLUS;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+element7(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+         const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_ELEMENT_NONE;
+  case XML_TOK_CLOSE_PAREN:
+    state->level -= 1;
+    if (state->level == 0) {
+      state->handler = declClose;
+      state->role_none = XML_ROLE_ELEMENT_NONE;
+    }
+    return XML_ROLE_GROUP_CLOSE;
+  case XML_TOK_CLOSE_PAREN_ASTERISK:
+    state->level -= 1;
+    if (state->level == 0) {
+      state->handler = declClose;
+      state->role_none = XML_ROLE_ELEMENT_NONE;
+    }
+    return XML_ROLE_GROUP_CLOSE_REP;
+  case XML_TOK_CLOSE_PAREN_QUESTION:
+    state->level -= 1;
+    if (state->level == 0) {
+      state->handler = declClose;
+      state->role_none = XML_ROLE_ELEMENT_NONE;
+    }
+    return XML_ROLE_GROUP_CLOSE_OPT;
+  case XML_TOK_CLOSE_PAREN_PLUS:
+    state->level -= 1;
+    if (state->level == 0) {
+      state->handler = declClose;
+      state->role_none = XML_ROLE_ELEMENT_NONE;
+    }
+    return XML_ROLE_GROUP_CLOSE_PLUS;
+  case XML_TOK_COMMA:
+    state->handler = element6;
+    return XML_ROLE_GROUP_SEQUENCE;
+  case XML_TOK_OR:
+    state->handler = element6;
+    return XML_ROLE_GROUP_CHOICE;
+  }
+  return common(state, tok);
+}
+
+#ifdef XML_DTD
+
+static int PTRCALL
+condSect0(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_NAME:
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_INCLUDE)) {
+      state->handler = condSect1;
+      return XML_ROLE_NONE;
+    }
+    if (XmlNameMatchesAscii(enc, ptr, end, KW_IGNORE)) {
+      state->handler = condSect2;
+      return XML_ROLE_NONE;
+    }
+    break;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+condSect1(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_OPEN_BRACKET:
+    state->handler = externalSubset1;
+    state->includeLevel += 1;
+    return XML_ROLE_NONE;
+  }
+  return common(state, tok);
+}
+
+static int PTRCALL
+condSect2(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return XML_ROLE_NONE;
+  case XML_TOK_OPEN_BRACKET:
+    state->handler = externalSubset1;
+    return XML_ROLE_IGNORE_SECT;
+  }
+  return common(state, tok);
+}
+
+#endif /* XML_DTD */
+
+static int PTRCALL
+declClose(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+          const ENCODING *enc) {
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  switch (tok) {
+  case XML_TOK_PROLOG_S:
+    return state->role_none;
+  case XML_TOK_DECL_CLOSE:
+    setTopLevel(state);
+    return state->role_none;
+  }
+  return common(state, tok);
+}
+
+/* This function will only be invoked if the internal logic of the
+ * parser has broken down.  It is used in two cases:
+ *
+ * 1: When the XML prolog has been finished.  At this point the
+ * processor (the parser level above these role handlers) should
+ * switch from prologProcessor to contentProcessor and reinitialise
+ * the handler function.
+ *
+ * 2: When an error has been detected (via common() below).  At this
+ * point again the processor should be switched to errorProcessor,
+ * which will never call a handler.
+ *
+ * The result of this is that error() can only be called if the
+ * processor switch failed to happen, which is an internal error and
+ * therefore we shouldn't be able to provoke it simply by using the
+ * library.  It is a necessary backstop, however, so we merely exclude
+ * it from the coverage statistics.
+ *
+ * LCOV_EXCL_START
+ */
+static int PTRCALL
+error(PROLOG_STATE *state, int tok, const char *ptr, const char *end,
+      const ENCODING *enc) {
+  UNUSED_P(state);
+  UNUSED_P(tok);
+  UNUSED_P(ptr);
+  UNUSED_P(end);
+  UNUSED_P(enc);
+  return XML_ROLE_NONE;
+}
+/* LCOV_EXCL_STOP */
+
+static int FASTCALL
+common(PROLOG_STATE *state, int tok) {
+#ifdef XML_DTD
+  if (! state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF)
+    return XML_ROLE_INNER_PARAM_ENTITY_REF;
+#else
+  UNUSED_P(tok);
+#endif
+  state->handler = error;
+  return XML_ROLE_ERROR;
+}
+
+void
+XmlPrologStateInit(PROLOG_STATE *state) {
+  state->handler = prolog0;
+#ifdef XML_DTD
+  state->documentEntity = 1;
+  state->includeLevel = 0;
+  state->inEntityValue = 0;
+#endif /* XML_DTD */
+}
+
+#ifdef XML_DTD
+
+void
+XmlPrologStateInitExternalEntity(PROLOG_STATE *state) {
+  state->handler = externalSubset0;
+  state->documentEntity = 0;
+  state->includeLevel = 0;
+}
+
+#endif /* XML_DTD */
diff --git a/base/poco/XML/src/xmlrole.h b/base/poco/XML/src/xmlrole.h
new file mode 100644
index 00000000000..d6e1fa150a1
--- /dev/null
+++ b/base/poco/XML/src/xmlrole.h
@@ -0,0 +1,142 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef XmlRole_INCLUDED
+#define XmlRole_INCLUDED 1
+
+#ifdef __VMS
+/*      0        1         2         3      0        1         2         3
+        1234567890123456789012345678901     1234567890123456789012345678901 */
+#  define XmlPrologStateInitExternalEntity XmlPrologStateInitExternalEnt
+#endif
+
+#include "xmltok.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+  XML_ROLE_ERROR = -1,
+  XML_ROLE_NONE = 0,
+  XML_ROLE_XML_DECL,
+  XML_ROLE_INSTANCE_START,
+  XML_ROLE_DOCTYPE_NONE,
+  XML_ROLE_DOCTYPE_NAME,
+  XML_ROLE_DOCTYPE_SYSTEM_ID,
+  XML_ROLE_DOCTYPE_PUBLIC_ID,
+  XML_ROLE_DOCTYPE_INTERNAL_SUBSET,
+  XML_ROLE_DOCTYPE_CLOSE,
+  XML_ROLE_GENERAL_ENTITY_NAME,
+  XML_ROLE_PARAM_ENTITY_NAME,
+  XML_ROLE_ENTITY_NONE,
+  XML_ROLE_ENTITY_VALUE,
+  XML_ROLE_ENTITY_SYSTEM_ID,
+  XML_ROLE_ENTITY_PUBLIC_ID,
+  XML_ROLE_ENTITY_COMPLETE,
+  XML_ROLE_ENTITY_NOTATION_NAME,
+  XML_ROLE_NOTATION_NONE,
+  XML_ROLE_NOTATION_NAME,
+  XML_ROLE_NOTATION_SYSTEM_ID,
+  XML_ROLE_NOTATION_NO_SYSTEM_ID,
+  XML_ROLE_NOTATION_PUBLIC_ID,
+  XML_ROLE_ATTRIBUTE_NAME,
+  XML_ROLE_ATTRIBUTE_TYPE_CDATA,
+  XML_ROLE_ATTRIBUTE_TYPE_ID,
+  XML_ROLE_ATTRIBUTE_TYPE_IDREF,
+  XML_ROLE_ATTRIBUTE_TYPE_IDREFS,
+  XML_ROLE_ATTRIBUTE_TYPE_ENTITY,
+  XML_ROLE_ATTRIBUTE_TYPE_ENTITIES,
+  XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN,
+  XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS,
+  XML_ROLE_ATTRIBUTE_ENUM_VALUE,
+  XML_ROLE_ATTRIBUTE_NOTATION_VALUE,
+  XML_ROLE_ATTLIST_NONE,
+  XML_ROLE_ATTLIST_ELEMENT_NAME,
+  XML_ROLE_IMPLIED_ATTRIBUTE_VALUE,
+  XML_ROLE_REQUIRED_ATTRIBUTE_VALUE,
+  XML_ROLE_DEFAULT_ATTRIBUTE_VALUE,
+  XML_ROLE_FIXED_ATTRIBUTE_VALUE,
+  XML_ROLE_ELEMENT_NONE,
+  XML_ROLE_ELEMENT_NAME,
+  XML_ROLE_CONTENT_ANY,
+  XML_ROLE_CONTENT_EMPTY,
+  XML_ROLE_CONTENT_PCDATA,
+  XML_ROLE_GROUP_OPEN,
+  XML_ROLE_GROUP_CLOSE,
+  XML_ROLE_GROUP_CLOSE_REP,
+  XML_ROLE_GROUP_CLOSE_OPT,
+  XML_ROLE_GROUP_CLOSE_PLUS,
+  XML_ROLE_GROUP_CHOICE,
+  XML_ROLE_GROUP_SEQUENCE,
+  XML_ROLE_CONTENT_ELEMENT,
+  XML_ROLE_CONTENT_ELEMENT_REP,
+  XML_ROLE_CONTENT_ELEMENT_OPT,
+  XML_ROLE_CONTENT_ELEMENT_PLUS,
+  XML_ROLE_PI,
+  XML_ROLE_COMMENT,
+#ifdef XML_DTD
+  XML_ROLE_TEXT_DECL,
+  XML_ROLE_IGNORE_SECT,
+  XML_ROLE_INNER_PARAM_ENTITY_REF,
+#endif /* XML_DTD */
+  XML_ROLE_PARAM_ENTITY_REF
+};
+
+typedef struct prolog_state {
+  int(PTRCALL *handler)(struct prolog_state *state, int tok, const char *ptr,
+                        const char *end, const ENCODING *enc);
+  unsigned level;
+  int role_none;
+#ifdef XML_DTD
+  unsigned includeLevel;
+  int documentEntity;
+  int inEntityValue;
+#endif /* XML_DTD */
+} PROLOG_STATE;
+
+void XmlPrologStateInit(PROLOG_STATE *);
+#ifdef XML_DTD
+void XmlPrologStateInitExternalEntity(PROLOG_STATE *);
+#endif /* XML_DTD */
+
+#define XmlTokenRole(state, tok, ptr, end, enc)                                \
+  (((state)->handler)(state, tok, ptr, end, enc))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not XmlRole_INCLUDED */
diff --git a/base/poco/XML/src/xmltok.c b/base/poco/XML/src/xmltok.c
new file mode 100644
index 00000000000..2a50f73d779
--- /dev/null
+++ b/base/poco/XML/src/xmltok.c
@@ -0,0 +1,1676 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2001-2003 Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2002      Greg Stein <gstein@users.sourceforge.net>
+   Copyright (c) 2002-2016 Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2005-2009 Steven Solie <steven@solie.ca>
+   Copyright (c) 2016-2022 Sebastian Pipping <sebastian@pipping.org>
+   Copyright (c) 2016      Pascal Cuoq <cuoq@trust-in-soft.com>
+   Copyright (c) 2016      Don Lewis <truckman@apache.org>
+   Copyright (c) 2017      Rhodri James <rhodri@wildebeest.org.uk>
+   Copyright (c) 2017      Alexander Bluhm <alexander.bluhm@gmx.net>
+   Copyright (c) 2017      Benbuck Nason <bnason@netflix.com>
+   Copyright (c) 2017      José Gutiérrez de la Concha <jose@zeroc.com>
+   Copyright (c) 2019      David Loffredo <loffredo@steptools.com>
+   Copyright (c) 2021      Dong-hee Na <donghee.na@python.org>
+   Licensed under the MIT license:
+
+   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.
+*/
+
+#include <stddef.h>
+#include <string.h> /* memcpy */
+#include <stdbool.h>
+
+#ifdef EXPAT_WIN32
+#  include "winconfig.h"
+#endif 
+
+#include "expat_config.h"
+
+#include "Poco/XML/expat_external.h"
+#include "internal.h"
+#include "xmltok.h"
+#include "nametab.h"
+
+#ifdef XML_DTD
+#  define IGNORE_SECTION_TOK_VTABLE , PREFIX(ignoreSectionTok)
+#else
+#  define IGNORE_SECTION_TOK_VTABLE /* as nothing */
+#endif
+
+#define VTABLE1                                                                \
+  {PREFIX(prologTok), PREFIX(contentTok),                                      \
+   PREFIX(cdataSectionTok) IGNORE_SECTION_TOK_VTABLE},                         \
+      {PREFIX(attributeValueTok), PREFIX(entityValueTok)},                     \
+      PREFIX(nameMatchesAscii), PREFIX(nameLength), PREFIX(skipS),             \
+      PREFIX(getAtts), PREFIX(charRefNumber), PREFIX(predefinedEntityName),    \
+      PREFIX(updatePosition), PREFIX(isPublicId)
+
+#define VTABLE VTABLE1, PREFIX(toUtf8), PREFIX(toUtf16)
+
+#define UCS2_GET_NAMING(pages, hi, lo)                                         \
+  (namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1u << ((lo)&0x1F)))
+
+/* A 2 byte UTF-8 representation splits the characters 11 bits between
+   the bottom 5 and 6 bits of the bytes.  We need 8 bits to index into
+   pages, 3 bits to add to that index and 5 bits to generate the mask.
+*/
+#define UTF8_GET_NAMING2(pages, byte)                                          \
+  (namingBitmap[((pages)[(((byte)[0]) >> 2) & 7] << 3)                         \
+                + ((((byte)[0]) & 3) << 1) + ((((byte)[1]) >> 5) & 1)]         \
+   & (1u << (((byte)[1]) & 0x1F)))
+
+/* A 3 byte UTF-8 representation splits the characters 16 bits between
+   the bottom 4, 6 and 6 bits of the bytes.  We need 8 bits to index
+   into pages, 3 bits to add to that index and 5 bits to generate the
+   mask.
+*/
+#define UTF8_GET_NAMING3(pages, byte)                                          \
+  (namingBitmap                                                                \
+       [((pages)[((((byte)[0]) & 0xF) << 4) + ((((byte)[1]) >> 2) & 0xF)]      \
+         << 3)                                                                 \
+        + ((((byte)[1]) & 3) << 1) + ((((byte)[2]) >> 5) & 1)]                 \
+   & (1u << (((byte)[2]) & 0x1F)))
+
+/* Detection of invalid UTF-8 sequences is based on Table 3.1B
+   of Unicode 3.2: http://www.unicode.org/unicode/reports/tr28/
+   with the additional restriction of not allowing the Unicode
+   code points 0xFFFF and 0xFFFE (sequences EF,BF,BF and EF,BF,BE).
+   Implementation details:
+     (A & 0x80) == 0     means A < 0x80
+   and
+     (A & 0xC0) == 0xC0  means A > 0xBF
+*/
+
+#define UTF8_INVALID2(p)                                                       \
+  ((*p) < 0xC2 || ((p)[1] & 0x80) == 0 || ((p)[1] & 0xC0) == 0xC0)
+
+#define UTF8_INVALID3(p)                                                       \
+  (((p)[2] & 0x80) == 0                                                        \
+   || ((*p) == 0xEF && (p)[1] == 0xBF ? (p)[2] > 0xBD                          \
+                                      : ((p)[2] & 0xC0) == 0xC0)               \
+   || ((*p) == 0xE0                                                            \
+           ? (p)[1] < 0xA0 || ((p)[1] & 0xC0) == 0xC0                          \
+           : ((p)[1] & 0x80) == 0                                              \
+                 || ((*p) == 0xED ? (p)[1] > 0x9F : ((p)[1] & 0xC0) == 0xC0)))
+
+#define UTF8_INVALID4(p)                                                       \
+  (((p)[3] & 0x80) == 0 || ((p)[3] & 0xC0) == 0xC0 || ((p)[2] & 0x80) == 0     \
+   || ((p)[2] & 0xC0) == 0xC0                                                  \
+   || ((*p) == 0xF0                                                            \
+           ? (p)[1] < 0x90 || ((p)[1] & 0xC0) == 0xC0                          \
+           : ((p)[1] & 0x80) == 0                                              \
+                 || ((*p) == 0xF4 ? (p)[1] > 0x8F : ((p)[1] & 0xC0) == 0xC0)))
+
+static int PTRFASTCALL
+isNever(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  UNUSED_P(p);
+  return 0;
+}
+
+static int PTRFASTCALL
+utf8_isName2(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return UTF8_GET_NAMING2(namePages, (const unsigned char *)p);
+}
+
+static int PTRFASTCALL
+utf8_isName3(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return UTF8_GET_NAMING3(namePages, (const unsigned char *)p);
+}
+
+#define utf8_isName4 isNever
+
+static int PTRFASTCALL
+utf8_isNmstrt2(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return UTF8_GET_NAMING2(nmstrtPages, (const unsigned char *)p);
+}
+
+static int PTRFASTCALL
+utf8_isNmstrt3(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return UTF8_GET_NAMING3(nmstrtPages, (const unsigned char *)p);
+}
+
+#define utf8_isNmstrt4 isNever
+
+static int PTRFASTCALL
+utf8_isInvalid2(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return UTF8_INVALID2((const unsigned char *)p);
+}
+
+static int PTRFASTCALL
+utf8_isInvalid3(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return UTF8_INVALID3((const unsigned char *)p);
+}
+
+static int PTRFASTCALL
+utf8_isInvalid4(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return UTF8_INVALID4((const unsigned char *)p);
+}
+
+struct normal_encoding {
+  ENCODING enc;
+  unsigned char type[256];
+#ifdef XML_MIN_SIZE
+  int(PTRFASTCALL *byteType)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isNameMin)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isNmstrtMin)(const ENCODING *, const char *);
+  int(PTRFASTCALL *byteToAscii)(const ENCODING *, const char *);
+  int(PTRCALL *charMatches)(const ENCODING *, const char *, int);
+#endif /* XML_MIN_SIZE */
+  int(PTRFASTCALL *isName2)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isName3)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isName4)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isNmstrt2)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isNmstrt3)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isNmstrt4)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isInvalid2)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isInvalid3)(const ENCODING *, const char *);
+  int(PTRFASTCALL *isInvalid4)(const ENCODING *, const char *);
+};
+
+#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *)(enc))
+
+#ifdef XML_MIN_SIZE
+
+#  define STANDARD_VTABLE(E)                                                   \
+    E##byteType, E##isNameMin, E##isNmstrtMin, E##byteToAscii, E##charMatches,
+
+#else
+
+#  define STANDARD_VTABLE(E) /* as nothing */
+
+#endif
+
+#define NORMAL_VTABLE(E)                                                       \
+  E##isName2, E##isName3, E##isName4, E##isNmstrt2, E##isNmstrt3,              \
+      E##isNmstrt4, E##isInvalid2, E##isInvalid3, E##isInvalid4
+
+#define NULL_VTABLE                                                            \
+  /* isName2 */ NULL, /* isName3 */ NULL, /* isName4 */ NULL,                  \
+      /* isNmstrt2 */ NULL, /* isNmstrt3 */ NULL, /* isNmstrt4 */ NULL,        \
+      /* isInvalid2 */ NULL, /* isInvalid3 */ NULL, /* isInvalid4 */ NULL
+
+static int FASTCALL checkCharRefNumber(int);
+
+#include "xmltok_impl.h"
+#include "ascii.h"
+
+#ifdef XML_MIN_SIZE
+#  define sb_isNameMin isNever
+#  define sb_isNmstrtMin isNever
+#endif
+
+#ifdef XML_MIN_SIZE
+#  define MINBPC(enc) ((enc)->minBytesPerChar)
+#else
+/* minimum bytes per character */
+#  define MINBPC(enc) 1
+#endif
+
+#define SB_BYTE_TYPE(enc, p)                                                   \
+  (((struct normal_encoding *)(enc))->type[(unsigned char)*(p)])
+
+#ifdef XML_MIN_SIZE
+static int PTRFASTCALL
+sb_byteType(const ENCODING *enc, const char *p) {
+  return SB_BYTE_TYPE(enc, p);
+}
+#  define BYTE_TYPE(enc, p) (AS_NORMAL_ENCODING(enc)->byteType(enc, p))
+#else
+#  define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p)
+#endif
+
+#ifdef XML_MIN_SIZE
+#  define BYTE_TO_ASCII(enc, p) (AS_NORMAL_ENCODING(enc)->byteToAscii(enc, p))
+static int PTRFASTCALL
+sb_byteToAscii(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return *p;
+}
+#else
+#  define BYTE_TO_ASCII(enc, p) (*(p))
+#endif
+
+#define IS_NAME_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isName##n(enc, p))
+#define IS_NMSTRT_CHAR(enc, p, n) (AS_NORMAL_ENCODING(enc)->isNmstrt##n(enc, p))
+#ifdef XML_MIN_SIZE
+#  define IS_INVALID_CHAR(enc, p, n)                                           \
+    (AS_NORMAL_ENCODING(enc)->isInvalid##n                                     \
+     && AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p))
+#else
+#  define IS_INVALID_CHAR(enc, p, n)                                           \
+    (AS_NORMAL_ENCODING(enc)->isInvalid##n(enc, p))
+#endif
+
+#ifdef XML_MIN_SIZE
+#  define IS_NAME_CHAR_MINBPC(enc, p)                                          \
+    (AS_NORMAL_ENCODING(enc)->isNameMin(enc, p))
+#  define IS_NMSTRT_CHAR_MINBPC(enc, p)                                        \
+    (AS_NORMAL_ENCODING(enc)->isNmstrtMin(enc, p))
+#else
+#  define IS_NAME_CHAR_MINBPC(enc, p) (0)
+#  define IS_NMSTRT_CHAR_MINBPC(enc, p) (0)
+#endif
+
+#ifdef XML_MIN_SIZE
+#  define CHAR_MATCHES(enc, p, c)                                              \
+    (AS_NORMAL_ENCODING(enc)->charMatches(enc, p, c))
+static int PTRCALL
+sb_charMatches(const ENCODING *enc, const char *p, int c) {
+  UNUSED_P(enc);
+  return *p == c;
+}
+#else
+/* c is an ASCII character */
+#  define CHAR_MATCHES(enc, p, c) (*(p) == c)
+#endif
+
+#define PREFIX(ident) normal_##ident
+#define XML_TOK_IMPL_C
+#include "xmltok_impl.c"
+#undef XML_TOK_IMPL_C
+
+#undef MINBPC
+#undef BYTE_TYPE
+#undef BYTE_TO_ASCII
+#undef CHAR_MATCHES
+#undef IS_NAME_CHAR
+#undef IS_NAME_CHAR_MINBPC
+#undef IS_NMSTRT_CHAR
+#undef IS_NMSTRT_CHAR_MINBPC
+#undef IS_INVALID_CHAR
+
+enum { /* UTF8_cvalN is value of masked first byte of N byte sequence */
+       UTF8_cval1 = 0x00,
+       UTF8_cval2 = 0xc0,
+       UTF8_cval3 = 0xe0,
+       UTF8_cval4 = 0xf0
+};
+
+void
+_INTERNAL_trim_to_complete_utf8_characters(const char *from,
+                                           const char **fromLimRef) {
+  const char *fromLim = *fromLimRef;
+  size_t walked = 0;
+  for (; fromLim > from; fromLim--, walked++) {
+    const unsigned char prev = (unsigned char)fromLim[-1];
+    if ((prev & 0xf8u)
+        == 0xf0u) { /* 4-byte character, lead by 0b11110xxx byte */
+      if (walked + 1 >= 4) {
+        fromLim += 4 - 1;
+        break;
+      } else {
+        walked = 0;
+      }
+    } else if ((prev & 0xf0u)
+               == 0xe0u) { /* 3-byte character, lead by 0b1110xxxx byte */
+      if (walked + 1 >= 3) {
+        fromLim += 3 - 1;
+        break;
+      } else {
+        walked = 0;
+      }
+    } else if ((prev & 0xe0u)
+               == 0xc0u) { /* 2-byte character, lead by 0b110xxxxx byte */
+      if (walked + 1 >= 2) {
+        fromLim += 2 - 1;
+        break;
+      } else {
+        walked = 0;
+      }
+    } else if ((prev & 0x80u)
+               == 0x00u) { /* 1-byte character, matching 0b0xxxxxxx */
+      break;
+    }
+  }
+  *fromLimRef = fromLim;
+}
+
+static enum XML_Convert_Result PTRCALL
+utf8_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim,
+            char **toP, const char *toLim) {
+  bool input_incomplete = false;
+  bool output_exhausted = false;
+
+  /* Avoid copying partial characters (due to limited space). */
+  const ptrdiff_t bytesAvailable = fromLim - *fromP;
+  const ptrdiff_t bytesStorable = toLim - *toP;
+  UNUSED_P(enc);
+  if (bytesAvailable > bytesStorable) {
+    fromLim = *fromP + bytesStorable;
+    output_exhausted = true;
+  }
+
+  /* Avoid copying partial characters (from incomplete input). */
+  {
+    const char *const fromLimBefore = fromLim;
+    _INTERNAL_trim_to_complete_utf8_characters(*fromP, &fromLim);
+    if (fromLim < fromLimBefore) {
+      input_incomplete = true;
+    }
+  }
+
+  {
+    const ptrdiff_t bytesToCopy = fromLim - *fromP;
+    memcpy(*toP, *fromP, bytesToCopy);
+    *fromP += bytesToCopy;
+    *toP += bytesToCopy;
+  }
+
+  if (output_exhausted) /* needs to go first */
+    return XML_CONVERT_OUTPUT_EXHAUSTED;
+  else if (input_incomplete)
+    return XML_CONVERT_INPUT_INCOMPLETE;
+  else
+    return XML_CONVERT_COMPLETED;
+}
+
+static enum XML_Convert_Result PTRCALL
+utf8_toUtf16(const ENCODING *enc, const char **fromP, const char *fromLim,
+             unsigned short **toP, const unsigned short *toLim) {
+  enum XML_Convert_Result res = XML_CONVERT_COMPLETED;
+  unsigned short *to = *toP;
+  const char *from = *fromP;
+  while (from < fromLim && to < toLim) {
+    switch (((struct normal_encoding *)enc)->type[(unsigned char)*from]) {
+    case BT_LEAD2:
+      if (fromLim - from < 2) {
+        res = XML_CONVERT_INPUT_INCOMPLETE;
+        goto after;
+      }
+      *to++ = (unsigned short)(((from[0] & 0x1f) << 6) | (from[1] & 0x3f));
+      from += 2;
+      break;
+    case BT_LEAD3:
+      if (fromLim - from < 3) {
+        res = XML_CONVERT_INPUT_INCOMPLETE;
+        goto after;
+      }
+      *to++ = (unsigned short)(((from[0] & 0xf) << 12) | ((from[1] & 0x3f) << 6)
+                               | (from[2] & 0x3f));
+      from += 3;
+      break;
+    case BT_LEAD4: {
+      unsigned long n;
+      if (toLim - to < 2) {
+        res = XML_CONVERT_OUTPUT_EXHAUSTED;
+        goto after;
+      }
+      if (fromLim - from < 4) {
+        res = XML_CONVERT_INPUT_INCOMPLETE;
+        goto after;
+      }
+      n = ((from[0] & 0x7) << 18) | ((from[1] & 0x3f) << 12)
+          | ((from[2] & 0x3f) << 6) | (from[3] & 0x3f);
+      n -= 0x10000;
+      to[0] = (unsigned short)((n >> 10) | 0xD800);
+      to[1] = (unsigned short)((n & 0x3FF) | 0xDC00);
+      to += 2;
+      from += 4;
+    } break;
+    default:
+      *to++ = *from++;
+      break;
+    }
+  }
+  if (from < fromLim)
+    res = XML_CONVERT_OUTPUT_EXHAUSTED;
+after:
+  *fromP = from;
+  *toP = to;
+  return res;
+}
+
+#ifdef XML_NS
+static const struct normal_encoding utf8_encoding_ns
+    = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
+       {
+#  include "asciitab.h"
+#  include "utf8tab.h"
+       },
+       STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)};
+#endif
+
+static const struct normal_encoding utf8_encoding
+    = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
+       {
+#define BT_COLON BT_NMSTRT
+#include "asciitab.h"
+#undef BT_COLON
+#include "utf8tab.h"
+       },
+       STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)};
+
+#ifdef XML_NS
+
+static const struct normal_encoding internal_utf8_encoding_ns
+    = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
+       {
+#  include "iasciitab.h"
+#  include "utf8tab.h"
+       },
+       STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)};
+
+#endif
+
+static const struct normal_encoding internal_utf8_encoding
+    = {{VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0},
+       {
+#define BT_COLON BT_NMSTRT
+#include "iasciitab.h"
+#undef BT_COLON
+#include "utf8tab.h"
+       },
+       STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)};
+
+static enum XML_Convert_Result PTRCALL
+latin1_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim,
+              char **toP, const char *toLim) {
+  UNUSED_P(enc);
+  for (;;) {
+    unsigned char c;
+    if (*fromP == fromLim)
+      return XML_CONVERT_COMPLETED;
+    c = (unsigned char)**fromP;
+    if (c & 0x80) {
+      if (toLim - *toP < 2)
+        return XML_CONVERT_OUTPUT_EXHAUSTED;
+      *(*toP)++ = (char)((c >> 6) | UTF8_cval2);
+      *(*toP)++ = (char)((c & 0x3f) | 0x80);
+      (*fromP)++;
+    } else {
+      if (*toP == toLim)
+        return XML_CONVERT_OUTPUT_EXHAUSTED;
+      *(*toP)++ = *(*fromP)++;
+    }
+  }
+}
+
+static enum XML_Convert_Result PTRCALL
+latin1_toUtf16(const ENCODING *enc, const char **fromP, const char *fromLim,
+               unsigned short **toP, const unsigned short *toLim) {
+  UNUSED_P(enc);
+  while (*fromP < fromLim && *toP < toLim)
+    *(*toP)++ = (unsigned char)*(*fromP)++;
+
+  if ((*toP == toLim) && (*fromP < fromLim))
+    return XML_CONVERT_OUTPUT_EXHAUSTED;
+  else
+    return XML_CONVERT_COMPLETED;
+}
+
+#ifdef XML_NS
+
+static const struct normal_encoding latin1_encoding_ns
+    = {{VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0},
+       {
+#  include "asciitab.h"
+#  include "latin1tab.h"
+       },
+       STANDARD_VTABLE(sb_) NULL_VTABLE};
+
+#endif
+
+static const struct normal_encoding latin1_encoding
+    = {{VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0},
+       {
+#define BT_COLON BT_NMSTRT
+#include "asciitab.h"
+#undef BT_COLON
+#include "latin1tab.h"
+       },
+       STANDARD_VTABLE(sb_) NULL_VTABLE};
+
+static enum XML_Convert_Result PTRCALL
+ascii_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim,
+             char **toP, const char *toLim) {
+  UNUSED_P(enc);
+  while (*fromP < fromLim && *toP < toLim)
+    *(*toP)++ = *(*fromP)++;
+
+  if ((*toP == toLim) && (*fromP < fromLim))
+    return XML_CONVERT_OUTPUT_EXHAUSTED;
+  else
+    return XML_CONVERT_COMPLETED;
+}
+
+#ifdef XML_NS
+
+static const struct normal_encoding ascii_encoding_ns
+    = {{VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0},
+       {
+#  include "asciitab.h"
+           /* BT_NONXML == 0 */
+       },
+       STANDARD_VTABLE(sb_) NULL_VTABLE};
+
+#endif
+
+static const struct normal_encoding ascii_encoding
+    = {{VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0},
+       {
+#define BT_COLON BT_NMSTRT
+#include "asciitab.h"
+#undef BT_COLON
+           /* BT_NONXML == 0 */
+       },
+       STANDARD_VTABLE(sb_) NULL_VTABLE};
+
+static int PTRFASTCALL
+unicode_byte_type(char hi, char lo) {
+  switch ((unsigned char)hi) {
+  /* 0xD800-0xDBFF first 16-bit code unit or high surrogate (W1) */
+  case 0xD8:
+  case 0xD9:
+  case 0xDA:
+  case 0xDB:
+    return BT_LEAD4;
+  /* 0xDC00-0xDFFF second 16-bit code unit or low surrogate (W2) */
+  case 0xDC:
+  case 0xDD:
+  case 0xDE:
+  case 0xDF:
+    return BT_TRAIL;
+  case 0xFF:
+    switch ((unsigned char)lo) {
+    case 0xFF: /* noncharacter-FFFF */
+    case 0xFE: /* noncharacter-FFFE */
+      return BT_NONXML;
+    }
+    break;
+  }
+  return BT_NONASCII;
+}
+
+#define DEFINE_UTF16_TO_UTF8(E)                                                \
+  static enum XML_Convert_Result PTRCALL E##toUtf8(                            \
+      const ENCODING *enc, const char **fromP, const char *fromLim,            \
+      char **toP, const char *toLim) {                                         \
+    const char *from = *fromP;                                                 \
+    UNUSED_P(enc);                                                             \
+    fromLim = from + (((fromLim - from) >> 1) << 1); /* shrink to even */      \
+    for (; from < fromLim; from += 2) {                                        \
+      int plane;                                                               \
+      unsigned char lo2;                                                       \
+      unsigned char lo = GET_LO(from);                                         \
+      unsigned char hi = GET_HI(from);                                         \
+      switch (hi) {                                                            \
+      case 0:                                                                  \
+        if (lo < 0x80) {                                                       \
+          if (*toP == toLim) {                                                 \
+            *fromP = from;                                                     \
+            return XML_CONVERT_OUTPUT_EXHAUSTED;                               \
+          }                                                                    \
+          *(*toP)++ = lo;                                                      \
+          break;                                                               \
+        }                                                                      \
+        /* fall through */                                                     \
+      case 0x1:                                                                \
+      case 0x2:                                                                \
+      case 0x3:                                                                \
+      case 0x4:                                                                \
+      case 0x5:                                                                \
+      case 0x6:                                                                \
+      case 0x7:                                                                \
+        if (toLim - *toP < 2) {                                                \
+          *fromP = from;                                                       \
+          return XML_CONVERT_OUTPUT_EXHAUSTED;                                 \
+        }                                                                      \
+        *(*toP)++ = ((lo >> 6) | (hi << 2) | UTF8_cval2);                      \
+        *(*toP)++ = ((lo & 0x3f) | 0x80);                                      \
+        break;                                                                 \
+      default:                                                                 \
+        if (toLim - *toP < 3) {                                                \
+          *fromP = from;                                                       \
+          return XML_CONVERT_OUTPUT_EXHAUSTED;                                 \
+        }                                                                      \
+        /* 16 bits divided 4, 6, 6 amongst 3 bytes */                          \
+        *(*toP)++ = ((hi >> 4) | UTF8_cval3);                                  \
+        *(*toP)++ = (((hi & 0xf) << 2) | (lo >> 6) | 0x80);                    \
+        *(*toP)++ = ((lo & 0x3f) | 0x80);                                      \
+        break;                                                                 \
+      case 0xD8:                                                               \
+      case 0xD9:                                                               \
+      case 0xDA:                                                               \
+      case 0xDB:                                                               \
+        if (toLim - *toP < 4) {                                                \
+          *fromP = from;                                                       \
+          return XML_CONVERT_OUTPUT_EXHAUSTED;                                 \
+        }                                                                      \
+        if (fromLim - from < 4) {                                              \
+          *fromP = from;                                                       \
+          return XML_CONVERT_INPUT_INCOMPLETE;                                 \
+        }                                                                      \
+        plane = (((hi & 0x3) << 2) | ((lo >> 6) & 0x3)) + 1;                   \
+        *(*toP)++ = (char)((plane >> 2) | UTF8_cval4);                         \
+        *(*toP)++ = (((lo >> 2) & 0xF) | ((plane & 0x3) << 4) | 0x80);         \
+        from += 2;                                                             \
+        lo2 = GET_LO(from);                                                    \
+        *(*toP)++ = (((lo & 0x3) << 4) | ((GET_HI(from) & 0x3) << 2)           \
+                     | (lo2 >> 6) | 0x80);                                     \
+        *(*toP)++ = ((lo2 & 0x3f) | 0x80);                                     \
+        break;                                                                 \
+      }                                                                        \
+    }                                                                          \
+    *fromP = from;                                                             \
+    if (from < fromLim)                                                        \
+      return XML_CONVERT_INPUT_INCOMPLETE;                                     \
+    else                                                                       \
+      return XML_CONVERT_COMPLETED;                                            \
+  }
+
+#define DEFINE_UTF16_TO_UTF16(E)                                               \
+  static enum XML_Convert_Result PTRCALL E##toUtf16(                           \
+      const ENCODING *enc, const char **fromP, const char *fromLim,            \
+      unsigned short **toP, const unsigned short *toLim) {                     \
+    enum XML_Convert_Result res = XML_CONVERT_COMPLETED;                       \
+    UNUSED_P(enc);                                                             \
+    fromLim = *fromP + (((fromLim - *fromP) >> 1) << 1); /* shrink to even */  \
+    /* Avoid copying first half only of surrogate */                           \
+    if (fromLim - *fromP > ((toLim - *toP) << 1)                               \
+        && (GET_HI(fromLim - 2) & 0xF8) == 0xD8) {                             \
+      fromLim -= 2;                                                            \
+      res = XML_CONVERT_INPUT_INCOMPLETE;                                      \
+    }                                                                          \
+    for (; *fromP < fromLim && *toP < toLim; *fromP += 2)                      \
+      *(*toP)++ = (GET_HI(*fromP) << 8) | GET_LO(*fromP);                      \
+    if ((*toP == toLim) && (*fromP < fromLim))                                 \
+      return XML_CONVERT_OUTPUT_EXHAUSTED;                                     \
+    else                                                                       \
+      return res;                                                              \
+  }
+
+#define SET2(ptr, ch) (((ptr)[0] = ((ch)&0xff)), ((ptr)[1] = ((ch) >> 8)))
+#define GET_LO(ptr) ((unsigned char)(ptr)[0])
+#define GET_HI(ptr) ((unsigned char)(ptr)[1])
+
+DEFINE_UTF16_TO_UTF8(little2_)
+DEFINE_UTF16_TO_UTF16(little2_)
+
+#undef SET2
+#undef GET_LO
+#undef GET_HI
+
+#define SET2(ptr, ch) (((ptr)[0] = ((ch) >> 8)), ((ptr)[1] = ((ch)&0xFF)))
+#define GET_LO(ptr) ((unsigned char)(ptr)[1])
+#define GET_HI(ptr) ((unsigned char)(ptr)[0])
+
+DEFINE_UTF16_TO_UTF8(big2_)
+DEFINE_UTF16_TO_UTF16(big2_)
+
+#undef SET2
+#undef GET_LO
+#undef GET_HI
+
+#define LITTLE2_BYTE_TYPE(enc, p)                                              \
+  ((p)[1] == 0 ? ((struct normal_encoding *)(enc))->type[(unsigned char)*(p)]  \
+               : unicode_byte_type((p)[1], (p)[0]))
+#define LITTLE2_BYTE_TO_ASCII(p) ((p)[1] == 0 ? (p)[0] : -1)
+#define LITTLE2_CHAR_MATCHES(p, c) ((p)[1] == 0 && (p)[0] == c)
+#define LITTLE2_IS_NAME_CHAR_MINBPC(p)                                         \
+  UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0])
+#define LITTLE2_IS_NMSTRT_CHAR_MINBPC(p)                                       \
+  UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0])
+
+#ifdef XML_MIN_SIZE
+
+static int PTRFASTCALL
+little2_byteType(const ENCODING *enc, const char *p) {
+  return LITTLE2_BYTE_TYPE(enc, p);
+}
+
+static int PTRFASTCALL
+little2_byteToAscii(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return LITTLE2_BYTE_TO_ASCII(p);
+}
+
+static int PTRCALL
+little2_charMatches(const ENCODING *enc, const char *p, int c) {
+  UNUSED_P(enc);
+  return LITTLE2_CHAR_MATCHES(p, c);
+}
+
+static int PTRFASTCALL
+little2_isNameMin(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return LITTLE2_IS_NAME_CHAR_MINBPC(p);
+}
+
+static int PTRFASTCALL
+little2_isNmstrtMin(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return LITTLE2_IS_NMSTRT_CHAR_MINBPC(p);
+}
+
+#  undef VTABLE
+#  define VTABLE VTABLE1, little2_toUtf8, little2_toUtf16
+
+#else /* not XML_MIN_SIZE */
+
+#  undef PREFIX
+#  define PREFIX(ident) little2_##ident
+#  define MINBPC(enc) 2
+/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
+#  define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p)
+#  define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(p)
+#  define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(p, c)
+#  define IS_NAME_CHAR(enc, p, n) 0
+#  define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(p)
+#  define IS_NMSTRT_CHAR(enc, p, n) (0)
+#  define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(p)
+
+#  define XML_TOK_IMPL_C
+#  include "xmltok_impl.c"
+#  undef XML_TOK_IMPL_C
+
+#  undef MINBPC
+#  undef BYTE_TYPE
+#  undef BYTE_TO_ASCII
+#  undef CHAR_MATCHES
+#  undef IS_NAME_CHAR
+#  undef IS_NAME_CHAR_MINBPC
+#  undef IS_NMSTRT_CHAR
+#  undef IS_NMSTRT_CHAR_MINBPC
+#  undef IS_INVALID_CHAR
+
+#endif /* not XML_MIN_SIZE */
+
+#ifdef XML_NS
+
+static const struct normal_encoding little2_encoding_ns
+    = {{VTABLE, 2, 0,
+#  if BYTEORDER == 1234
+        1
+#  else
+        0
+#  endif
+       },
+       {
+#  include "asciitab.h"
+#  include "latin1tab.h"
+       },
+       STANDARD_VTABLE(little2_) NULL_VTABLE};
+
+#endif
+
+static const struct normal_encoding little2_encoding
+    = {{VTABLE, 2, 0,
+#if BYTEORDER == 1234
+        1
+#else
+        0
+#endif
+       },
+       {
+#define BT_COLON BT_NMSTRT
+#include "asciitab.h"
+#undef BT_COLON
+#include "latin1tab.h"
+       },
+       STANDARD_VTABLE(little2_) NULL_VTABLE};
+
+#if BYTEORDER != 4321
+
+#  ifdef XML_NS
+
+static const struct normal_encoding internal_little2_encoding_ns
+    = {{VTABLE, 2, 0, 1},
+       {
+#    include "iasciitab.h"
+#    include "latin1tab.h"
+       },
+       STANDARD_VTABLE(little2_) NULL_VTABLE};
+
+#  endif
+
+static const struct normal_encoding internal_little2_encoding
+    = {{VTABLE, 2, 0, 1},
+       {
+#  define BT_COLON BT_NMSTRT
+#  include "iasciitab.h"
+#  undef BT_COLON
+#  include "latin1tab.h"
+       },
+       STANDARD_VTABLE(little2_) NULL_VTABLE};
+
+#endif
+
+#define BIG2_BYTE_TYPE(enc, p)                                                 \
+  ((p)[0] == 0                                                                 \
+       ? ((struct normal_encoding *)(enc))->type[(unsigned char)(p)[1]]        \
+       : unicode_byte_type((p)[0], (p)[1]))
+#define BIG2_BYTE_TO_ASCII(p) ((p)[0] == 0 ? (p)[1] : -1)
+#define BIG2_CHAR_MATCHES(p, c) ((p)[0] == 0 && (p)[1] == c)
+#define BIG2_IS_NAME_CHAR_MINBPC(p)                                            \
+  UCS2_GET_NAMING(namePages, (unsigned char)p[0], (unsigned char)p[1])
+#define BIG2_IS_NMSTRT_CHAR_MINBPC(p)                                          \
+  UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[0], (unsigned char)p[1])
+
+#ifdef XML_MIN_SIZE
+
+static int PTRFASTCALL
+big2_byteType(const ENCODING *enc, const char *p) {
+  return BIG2_BYTE_TYPE(enc, p);
+}
+
+static int PTRFASTCALL
+big2_byteToAscii(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return BIG2_BYTE_TO_ASCII(p);
+}
+
+static int PTRCALL
+big2_charMatches(const ENCODING *enc, const char *p, int c) {
+  UNUSED_P(enc);
+  return BIG2_CHAR_MATCHES(p, c);
+}
+
+static int PTRFASTCALL
+big2_isNameMin(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return BIG2_IS_NAME_CHAR_MINBPC(p);
+}
+
+static int PTRFASTCALL
+big2_isNmstrtMin(const ENCODING *enc, const char *p) {
+  UNUSED_P(enc);
+  return BIG2_IS_NMSTRT_CHAR_MINBPC(p);
+}
+
+#  undef VTABLE
+#  define VTABLE VTABLE1, big2_toUtf8, big2_toUtf16
+
+#else /* not XML_MIN_SIZE */
+
+#  undef PREFIX
+#  define PREFIX(ident) big2_##ident
+#  define MINBPC(enc) 2
+/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
+#  define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p)
+#  define BYTE_TO_ASCII(enc, p) BIG2_BYTE_TO_ASCII(p)
+#  define CHAR_MATCHES(enc, p, c) BIG2_CHAR_MATCHES(p, c)
+#  define IS_NAME_CHAR(enc, p, n) 0
+#  define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_NAME_CHAR_MINBPC(p)
+#  define IS_NMSTRT_CHAR(enc, p, n) (0)
+#  define IS_NMSTRT_CHAR_MINBPC(enc, p) BIG2_IS_NMSTRT_CHAR_MINBPC(p)
+
+#  define XML_TOK_IMPL_C
+#  include "xmltok_impl.c"
+#  undef XML_TOK_IMPL_C
+
+#  undef MINBPC
+#  undef BYTE_TYPE
+#  undef BYTE_TO_ASCII
+#  undef CHAR_MATCHES
+#  undef IS_NAME_CHAR
+#  undef IS_NAME_CHAR_MINBPC
+#  undef IS_NMSTRT_CHAR
+#  undef IS_NMSTRT_CHAR_MINBPC
+#  undef IS_INVALID_CHAR
+
+#endif /* not XML_MIN_SIZE */
+
+#ifdef XML_NS
+
+static const struct normal_encoding big2_encoding_ns
+    = {{VTABLE, 2, 0,
+#  if BYTEORDER == 4321
+        1
+#  else
+        0
+#  endif
+       },
+       {
+#  include "asciitab.h"
+#  include "latin1tab.h"
+       },
+       STANDARD_VTABLE(big2_) NULL_VTABLE};
+
+#endif
+
+static const struct normal_encoding big2_encoding
+    = {{VTABLE, 2, 0,
+#if BYTEORDER == 4321
+        1
+#else
+        0
+#endif
+       },
+       {
+#define BT_COLON BT_NMSTRT
+#include "asciitab.h"
+#undef BT_COLON
+#include "latin1tab.h"
+       },
+       STANDARD_VTABLE(big2_) NULL_VTABLE};
+
+#if BYTEORDER != 1234
+
+#  ifdef XML_NS
+
+static const struct normal_encoding internal_big2_encoding_ns
+    = {{VTABLE, 2, 0, 1},
+       {
+#    include "iasciitab.h"
+#    include "latin1tab.h"
+       },
+       STANDARD_VTABLE(big2_) NULL_VTABLE};
+
+#  endif
+
+static const struct normal_encoding internal_big2_encoding
+    = {{VTABLE, 2, 0, 1},
+       {
+#  define BT_COLON BT_NMSTRT
+#  include "iasciitab.h"
+#  undef BT_COLON
+#  include "latin1tab.h"
+       },
+       STANDARD_VTABLE(big2_) NULL_VTABLE};
+
+#endif
+
+#undef PREFIX
+
+static int FASTCALL
+streqci(const char *s1, const char *s2) {
+  for (;;) {
+    char c1 = *s1++;
+    char c2 = *s2++;
+    if (ASCII_a <= c1 && c1 <= ASCII_z)
+      c1 += ASCII_A - ASCII_a;
+    if (ASCII_a <= c2 && c2 <= ASCII_z)
+      /* The following line will never get executed.  streqci() is
+       * only called from two places, both of which guarantee to put
+       * upper-case strings into s2.
+       */
+      c2 += ASCII_A - ASCII_a; /* LCOV_EXCL_LINE */
+    if (c1 != c2)
+      return 0;
+    if (! c1)
+      break;
+  }
+  return 1;
+}
+
+static void PTRCALL
+initUpdatePosition(const ENCODING *enc, const char *ptr, const char *end,
+                   POSITION *pos) {
+  UNUSED_P(enc);
+  normal_updatePosition(&utf8_encoding.enc, ptr, end, pos);
+}
+
+static int
+toAscii(const ENCODING *enc, const char *ptr, const char *end) {
+  char buf[1];
+  char *p = buf;
+  XmlUtf8Convert(enc, &ptr, end, &p, p + 1);
+  if (p == buf)
+    return -1;
+  else
+    return buf[0];
+}
+
+static int FASTCALL
+isSpace(int c) {
+  switch (c) {
+  case 0x20:
+  case 0xD:
+  case 0xA:
+  case 0x9:
+    return 1;
+  }
+  return 0;
+}
+
+/* Return 1 if there's just optional white space or there's an S
+   followed by name=val.
+*/
+static int
+parsePseudoAttribute(const ENCODING *enc, const char *ptr, const char *end,
+                     const char **namePtr, const char **nameEndPtr,
+                     const char **valPtr, const char **nextTokPtr) {
+  int c;
+  char open;
+  if (ptr == end) {
+    *namePtr = NULL;
+    return 1;
+  }
+  if (! isSpace(toAscii(enc, ptr, end))) {
+    *nextTokPtr = ptr;
+    return 0;
+  }
+  do {
+    ptr += enc->minBytesPerChar;
+  } while (isSpace(toAscii(enc, ptr, end)));
+  if (ptr == end) {
+    *namePtr = NULL;
+    return 1;
+  }
+  *namePtr = ptr;
+  for (;;) {
+    c = toAscii(enc, ptr, end);
+    if (c == -1) {
+      *nextTokPtr = ptr;
+      return 0;
+    }
+    if (c == ASCII_EQUALS) {
+      *nameEndPtr = ptr;
+      break;
+    }
+    if (isSpace(c)) {
+      *nameEndPtr = ptr;
+      do {
+        ptr += enc->minBytesPerChar;
+      } while (isSpace(c = toAscii(enc, ptr, end)));
+      if (c != ASCII_EQUALS) {
+        *nextTokPtr = ptr;
+        return 0;
+      }
+      break;
+    }
+    ptr += enc->minBytesPerChar;
+  }
+  if (ptr == *namePtr) {
+    *nextTokPtr = ptr;
+    return 0;
+  }
+  ptr += enc->minBytesPerChar;
+  c = toAscii(enc, ptr, end);
+  while (isSpace(c)) {
+    ptr += enc->minBytesPerChar;
+    c = toAscii(enc, ptr, end);
+  }
+  if (c != ASCII_QUOT && c != ASCII_APOS) {
+    *nextTokPtr = ptr;
+    return 0;
+  }
+  open = (char)c;
+  ptr += enc->minBytesPerChar;
+  *valPtr = ptr;
+  for (;; ptr += enc->minBytesPerChar) {
+    c = toAscii(enc, ptr, end);
+    if (c == open)
+      break;
+    if (! (ASCII_a <= c && c <= ASCII_z) && ! (ASCII_A <= c && c <= ASCII_Z)
+        && ! (ASCII_0 <= c && c <= ASCII_9) && c != ASCII_PERIOD
+        && c != ASCII_MINUS && c != ASCII_UNDERSCORE) {
+      *nextTokPtr = ptr;
+      return 0;
+    }
+  }
+  *nextTokPtr = ptr + enc->minBytesPerChar;
+  return 1;
+}
+
+static const char KW_version[]
+    = {ASCII_v, ASCII_e, ASCII_r, ASCII_s, ASCII_i, ASCII_o, ASCII_n, '\0'};
+
+static const char KW_encoding[] = {ASCII_e, ASCII_n, ASCII_c, ASCII_o, ASCII_d,
+                                   ASCII_i, ASCII_n, ASCII_g, '\0'};
+
+static const char KW_standalone[]
+    = {ASCII_s, ASCII_t, ASCII_a, ASCII_n, ASCII_d, ASCII_a,
+       ASCII_l, ASCII_o, ASCII_n, ASCII_e, '\0'};
+
+static const char KW_yes[] = {ASCII_y, ASCII_e, ASCII_s, '\0'};
+
+static const char KW_no[] = {ASCII_n, ASCII_o, '\0'};
+
+static int
+doParseXmlDecl(const ENCODING *(*encodingFinder)(const ENCODING *, const char *,
+                                                 const char *),
+               int isGeneralTextEntity, const ENCODING *enc, const char *ptr,
+               const char *end, const char **badPtr, const char **versionPtr,
+               const char **versionEndPtr, const char **encodingName,
+               const ENCODING **encoding, int *standalone) {
+  const char *val = NULL;
+  const char *name = NULL;
+  const char *nameEnd = NULL;
+  ptr += 5 * enc->minBytesPerChar;
+  end -= 2 * enc->minBytesPerChar;
+  if (! parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)
+      || ! name) {
+    *badPtr = ptr;
+    return 0;
+  }
+  if (! XmlNameMatchesAscii(enc, name, nameEnd, KW_version)) {
+    if (! isGeneralTextEntity) {
+      *badPtr = name;
+      return 0;
+    }
+  } else {
+    if (versionPtr)
+      *versionPtr = val;
+    if (versionEndPtr)
+      *versionEndPtr = ptr;
+    if (! parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) {
+      *badPtr = ptr;
+      return 0;
+    }
+    if (! name) {
+      if (isGeneralTextEntity) {
+        /* a TextDecl must have an EncodingDecl */
+        *badPtr = ptr;
+        return 0;
+      }
+      return 1;
+    }
+  }
+  if (XmlNameMatchesAscii(enc, name, nameEnd, KW_encoding)) {
+    int c = toAscii(enc, val, end);
+    if (! (ASCII_a <= c && c <= ASCII_z) && ! (ASCII_A <= c && c <= ASCII_Z)) {
+      *badPtr = val;
+      return 0;
+    }
+    if (encodingName)
+      *encodingName = val;
+    if (encoding)
+      *encoding = encodingFinder(enc, val, ptr - enc->minBytesPerChar);
+    if (! parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) {
+      *badPtr = ptr;
+      return 0;
+    }
+    if (! name)
+      return 1;
+  }
+  if (! XmlNameMatchesAscii(enc, name, nameEnd, KW_standalone)
+      || isGeneralTextEntity) {
+    *badPtr = name;
+    return 0;
+  }
+  if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_yes)) {
+    if (standalone)
+      *standalone = 1;
+  } else if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_no)) {
+    if (standalone)
+      *standalone = 0;
+  } else {
+    *badPtr = val;
+    return 0;
+  }
+  while (isSpace(toAscii(enc, ptr, end)))
+    ptr += enc->minBytesPerChar;
+  if (ptr != end) {
+    *badPtr = ptr;
+    return 0;
+  }
+  return 1;
+}
+
+static int FASTCALL
+checkCharRefNumber(int result) {
+  switch (result >> 8) {
+  case 0xD8:
+  case 0xD9:
+  case 0xDA:
+  case 0xDB:
+  case 0xDC:
+  case 0xDD:
+  case 0xDE:
+  case 0xDF:
+    return -1;
+  case 0:
+    if (latin1_encoding.type[result] == BT_NONXML)
+      return -1;
+    break;
+  case 0xFF:
+    if (result == 0xFFFE || result == 0xFFFF)
+      return -1;
+    break;
+  }
+  return result;
+}
+
+int FASTCALL
+XmlUtf8Encode(int c, char *buf) {
+  enum {
+    /* minN is minimum legal resulting value for N byte sequence */
+    min2 = 0x80,
+    min3 = 0x800,
+    min4 = 0x10000
+  };
+
+  if (c < 0)
+    return 0; /* LCOV_EXCL_LINE: this case is always eliminated beforehand */
+  if (c < min2) {
+    buf[0] = (char)(c | UTF8_cval1);
+    return 1;
+  }
+  if (c < min3) {
+    buf[0] = (char)((c >> 6) | UTF8_cval2);
+    buf[1] = (char)((c & 0x3f) | 0x80);
+    return 2;
+  }
+  if (c < min4) {
+    buf[0] = (char)((c >> 12) | UTF8_cval3);
+    buf[1] = (char)(((c >> 6) & 0x3f) | 0x80);
+    buf[2] = (char)((c & 0x3f) | 0x80);
+    return 3;
+  }
+  if (c < 0x110000) {
+    buf[0] = (char)((c >> 18) | UTF8_cval4);
+    buf[1] = (char)(((c >> 12) & 0x3f) | 0x80);
+    buf[2] = (char)(((c >> 6) & 0x3f) | 0x80);
+    buf[3] = (char)((c & 0x3f) | 0x80);
+    return 4;
+  }
+  return 0; /* LCOV_EXCL_LINE: this case too is eliminated before calling */
+}
+
+int FASTCALL
+XmlUtf16Encode(int charNum, unsigned short *buf) {
+  if (charNum < 0)
+    return 0;
+  if (charNum < 0x10000) {
+    buf[0] = (unsigned short)charNum;
+    return 1;
+  }
+  if (charNum < 0x110000) {
+    charNum -= 0x10000;
+    buf[0] = (unsigned short)((charNum >> 10) + 0xD800);
+    buf[1] = (unsigned short)((charNum & 0x3FF) + 0xDC00);
+    return 2;
+  }
+  return 0;
+}
+
+struct unknown_encoding {
+  struct normal_encoding normal;
+  CONVERTER convert;
+  void *userData;
+  unsigned short utf16[256];
+  char utf8[256][4];
+};
+
+#define AS_UNKNOWN_ENCODING(enc) ((const struct unknown_encoding *)(enc))
+
+int
+XmlSizeOfUnknownEncoding(void) {
+  return sizeof(struct unknown_encoding);
+}
+
+static int PTRFASTCALL
+unknown_isName(const ENCODING *enc, const char *p) {
+  const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
+  int c = uenc->convert(uenc->userData, p);
+  if (c & ~0xFFFF)
+    return 0;
+  return UCS2_GET_NAMING(namePages, c >> 8, c & 0xFF);
+}
+
+static int PTRFASTCALL
+unknown_isNmstrt(const ENCODING *enc, const char *p) {
+  const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
+  int c = uenc->convert(uenc->userData, p);
+  if (c & ~0xFFFF)
+    return 0;
+  return UCS2_GET_NAMING(nmstrtPages, c >> 8, c & 0xFF);
+}
+
+static int PTRFASTCALL
+unknown_isInvalid(const ENCODING *enc, const char *p) {
+  const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
+  int c = uenc->convert(uenc->userData, p);
+  return (c & ~0xFFFF) || checkCharRefNumber(c) < 0;
+}
+
+static enum XML_Convert_Result PTRCALL
+unknown_toUtf8(const ENCODING *enc, const char **fromP, const char *fromLim,
+               char **toP, const char *toLim) {
+  const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
+  char buf[XML_UTF8_ENCODE_MAX];
+  for (;;) {
+    const char *utf8;
+    int n;
+    if (*fromP == fromLim)
+      return XML_CONVERT_COMPLETED;
+    utf8 = uenc->utf8[(unsigned char)**fromP];
+    n = *utf8++;
+    if (n == 0) {
+      int c = uenc->convert(uenc->userData, *fromP);
+      n = XmlUtf8Encode(c, buf);
+      if (n > toLim - *toP)
+        return XML_CONVERT_OUTPUT_EXHAUSTED;
+      utf8 = buf;
+      *fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP]
+                 - (BT_LEAD2 - 2));
+    } else {
+      if (n > toLim - *toP)
+        return XML_CONVERT_OUTPUT_EXHAUSTED;
+      (*fromP)++;
+    }
+    memcpy(*toP, utf8, n);
+    *toP += n;
+  }
+}
+
+static enum XML_Convert_Result PTRCALL
+unknown_toUtf16(const ENCODING *enc, const char **fromP, const char *fromLim,
+                unsigned short **toP, const unsigned short *toLim) {
+  const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
+  while (*fromP < fromLim && *toP < toLim) {
+    unsigned short c = uenc->utf16[(unsigned char)**fromP];
+    if (c == 0) {
+      c = (unsigned short)uenc->convert(uenc->userData, *fromP);
+      *fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP]
+                 - (BT_LEAD2 - 2));
+    } else
+      (*fromP)++;
+    *(*toP)++ = c;
+  }
+
+  if ((*toP == toLim) && (*fromP < fromLim))
+    return XML_CONVERT_OUTPUT_EXHAUSTED;
+  else
+    return XML_CONVERT_COMPLETED;
+}
+
+ENCODING *
+XmlInitUnknownEncoding(void *mem, int *table, CONVERTER convert,
+                       void *userData) {
+  int i;
+  struct unknown_encoding *e = (struct unknown_encoding *)mem;
+  memcpy(mem, &latin1_encoding, sizeof(struct normal_encoding));
+  for (i = 0; i < 128; i++)
+    if (latin1_encoding.type[i] != BT_OTHER
+        && latin1_encoding.type[i] != BT_NONXML && table[i] != i)
+      return 0;
+  for (i = 0; i < 256; i++) {
+    int c = table[i];
+    if (c == -1) {
+      e->normal.type[i] = BT_MALFORM;
+      /* This shouldn't really get used. */
+      e->utf16[i] = 0xFFFF;
+      e->utf8[i][0] = 1;
+      e->utf8[i][1] = 0;
+    } else if (c < 0) {
+      if (c < -4)
+        return 0;
+      /* Multi-byte sequences need a converter function */
+      if (! convert)
+        return 0;
+      e->normal.type[i] = (unsigned char)(BT_LEAD2 - (c + 2));
+      e->utf8[i][0] = 0;
+      e->utf16[i] = 0;
+    } else if (c < 0x80) {
+      if (latin1_encoding.type[c] != BT_OTHER
+          && latin1_encoding.type[c] != BT_NONXML && c != i)
+        return 0;
+      e->normal.type[i] = latin1_encoding.type[c];
+      e->utf8[i][0] = 1;
+      e->utf8[i][1] = (char)c;
+      e->utf16[i] = (unsigned short)(c == 0 ? 0xFFFF : c);
+    } else if (checkCharRefNumber(c) < 0) {
+      e->normal.type[i] = BT_NONXML;
+      /* This shouldn't really get used. */
+      e->utf16[i] = 0xFFFF;
+      e->utf8[i][0] = 1;
+      e->utf8[i][1] = 0;
+    } else {
+      if (c > 0xFFFF)
+        return 0;
+      if (UCS2_GET_NAMING(nmstrtPages, c >> 8, c & 0xff))
+        e->normal.type[i] = BT_NMSTRT;
+      else if (UCS2_GET_NAMING(namePages, c >> 8, c & 0xff))
+        e->normal.type[i] = BT_NAME;
+      else
+        e->normal.type[i] = BT_OTHER;
+      e->utf8[i][0] = (char)XmlUtf8Encode(c, e->utf8[i] + 1);
+      e->utf16[i] = (unsigned short)c;
+    }
+  }
+  e->userData = userData;
+  e->convert = convert;
+  if (convert) {
+    e->normal.isName2 = unknown_isName;
+    e->normal.isName3 = unknown_isName;
+    e->normal.isName4 = unknown_isName;
+    e->normal.isNmstrt2 = unknown_isNmstrt;
+    e->normal.isNmstrt3 = unknown_isNmstrt;
+    e->normal.isNmstrt4 = unknown_isNmstrt;
+    e->normal.isInvalid2 = unknown_isInvalid;
+    e->normal.isInvalid3 = unknown_isInvalid;
+    e->normal.isInvalid4 = unknown_isInvalid;
+  }
+  e->normal.enc.utf8Convert = unknown_toUtf8;
+  e->normal.enc.utf16Convert = unknown_toUtf16;
+  return &(e->normal.enc);
+}
+
+/* If this enumeration is changed, getEncodingIndex and encodings
+must also be changed. */
+enum {
+  UNKNOWN_ENC = -1,
+  ISO_8859_1_ENC = 0,
+  US_ASCII_ENC,
+  UTF_8_ENC,
+  UTF_16_ENC,
+  UTF_16BE_ENC,
+  UTF_16LE_ENC,
+  /* must match encodingNames up to here */
+  NO_ENC
+};
+
+static const char KW_ISO_8859_1[]
+    = {ASCII_I, ASCII_S, ASCII_O,     ASCII_MINUS, ASCII_8, ASCII_8,
+       ASCII_5, ASCII_9, ASCII_MINUS, ASCII_1,     '\0'};
+static const char KW_US_ASCII[]
+    = {ASCII_U, ASCII_S, ASCII_MINUS, ASCII_A, ASCII_S,
+       ASCII_C, ASCII_I, ASCII_I,     '\0'};
+static const char KW_UTF_8[]
+    = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_8, '\0'};
+static const char KW_UTF_16[]
+    = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1, ASCII_6, '\0'};
+static const char KW_UTF_16BE[]
+    = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1,
+       ASCII_6, ASCII_B, ASCII_E, '\0'};
+static const char KW_UTF_16LE[]
+    = {ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1,
+       ASCII_6, ASCII_L, ASCII_E, '\0'};
+
+static int FASTCALL
+getEncodingIndex(const char *name) {
+  static const char *const encodingNames[] = {
+      KW_ISO_8859_1, KW_US_ASCII, KW_UTF_8, KW_UTF_16, KW_UTF_16BE, KW_UTF_16LE,
+  };
+  int i;
+  if (name == NULL)
+    return NO_ENC;
+  for (i = 0; i < (int)(sizeof(encodingNames) / sizeof(encodingNames[0])); i++)
+    if (streqci(name, encodingNames[i]))
+      return i;
+  return UNKNOWN_ENC;
+}
+
+/* For binary compatibility, we store the index of the encoding
+   specified at initialization in the isUtf16 member.
+*/
+
+#define INIT_ENC_INDEX(enc) ((int)(enc)->initEnc.isUtf16)
+#define SET_INIT_ENC_INDEX(enc, i) ((enc)->initEnc.isUtf16 = (char)i)
+
+/* This is what detects the encoding.  encodingTable maps from
+   encoding indices to encodings; INIT_ENC_INDEX(enc) is the index of
+   the external (protocol) specified encoding; state is
+   XML_CONTENT_STATE if we're parsing an external text entity, and
+   XML_PROLOG_STATE otherwise.
+*/
+
+static int
+initScan(const ENCODING *const *encodingTable, const INIT_ENCODING *enc,
+         int state, const char *ptr, const char *end, const char **nextTokPtr) {
+  const ENCODING **encPtr;
+
+  if (ptr >= end)
+    return XML_TOK_NONE;
+  encPtr = enc->encPtr;
+  if (ptr + 1 == end) {
+    /* only a single byte available for auto-detection */
+#ifndef XML_DTD /* FIXME */
+    /* a well-formed document entity must have more than one byte */
+    if (state != XML_CONTENT_STATE)
+      return XML_TOK_PARTIAL;
+#endif
+    /* so we're parsing an external text entity... */
+    /* if UTF-16 was externally specified, then we need at least 2 bytes */
+    switch (INIT_ENC_INDEX(enc)) {
+    case UTF_16_ENC:
+    case UTF_16LE_ENC:
+    case UTF_16BE_ENC:
+      return XML_TOK_PARTIAL;
+    }
+    switch ((unsigned char)*ptr) {
+    case 0xFE:
+    case 0xFF:
+    case 0xEF: /* possibly first byte of UTF-8 BOM */
+      if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE)
+        break;
+      /* fall through */
+    case 0x00:
+    case 0x3C:
+      return XML_TOK_PARTIAL;
+    }
+  } else {
+    switch (((unsigned char)ptr[0] << 8) | (unsigned char)ptr[1]) {
+    case 0xFEFF:
+      if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE)
+        break;
+      *nextTokPtr = ptr + 2;
+      *encPtr = encodingTable[UTF_16BE_ENC];
+      return XML_TOK_BOM;
+    /* 00 3C is handled in the default case */
+    case 0x3C00:
+      if ((INIT_ENC_INDEX(enc) == UTF_16BE_ENC
+           || INIT_ENC_INDEX(enc) == UTF_16_ENC)
+          && state == XML_CONTENT_STATE)
+        break;
+      *encPtr = encodingTable[UTF_16LE_ENC];
+      return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
+    case 0xFFFE:
+      if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC && state == XML_CONTENT_STATE)
+        break;
+      *nextTokPtr = ptr + 2;
+      *encPtr = encodingTable[UTF_16LE_ENC];
+      return XML_TOK_BOM;
+    case 0xEFBB:
+      /* Maybe a UTF-8 BOM (EF BB BF) */
+      /* If there's an explicitly specified (external) encoding
+         of ISO-8859-1 or some flavour of UTF-16
+         and this is an external text entity,
+         don't look for the BOM,
+         because it might be a legal data.
+      */
+      if (state == XML_CONTENT_STATE) {
+        int e = INIT_ENC_INDEX(enc);
+        if (e == ISO_8859_1_ENC || e == UTF_16BE_ENC || e == UTF_16LE_ENC
+            || e == UTF_16_ENC)
+          break;
+      }
+      if (ptr + 2 == end)
+        return XML_TOK_PARTIAL;
+      if ((unsigned char)ptr[2] == 0xBF) {
+        *nextTokPtr = ptr + 3;
+        *encPtr = encodingTable[UTF_8_ENC];
+        return XML_TOK_BOM;
+      }
+      break;
+    default:
+      if (ptr[0] == '\0') {
+        /* 0 isn't a legal data character. Furthermore a document
+           entity can only start with ASCII characters.  So the only
+           way this can fail to be big-endian UTF-16 if it it's an
+           external parsed general entity that's labelled as
+           UTF-16LE.
+        */
+        if (state == XML_CONTENT_STATE && INIT_ENC_INDEX(enc) == UTF_16LE_ENC)
+          break;
+        *encPtr = encodingTable[UTF_16BE_ENC];
+        return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
+      } else if (ptr[1] == '\0') {
+        /* We could recover here in the case:
+            - parsing an external entity
+            - second byte is 0
+            - no externally specified encoding
+            - no encoding declaration
+           by assuming UTF-16LE.  But we don't, because this would mean when
+           presented just with a single byte, we couldn't reliably determine
+           whether we needed further bytes.
+        */
+        if (state == XML_CONTENT_STATE)
+          break;
+        *encPtr = encodingTable[UTF_16LE_ENC];
+        return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
+      }
+      break;
+    }
+  }
+  *encPtr = encodingTable[INIT_ENC_INDEX(enc)];
+  return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
+}
+
+#define NS(x) x
+#define ns(x) x
+#define XML_TOK_NS_C
+#include "xmltok_ns.c"
+#undef XML_TOK_NS_C
+#undef NS
+#undef ns
+
+#ifdef XML_NS
+
+#  define NS(x) x##NS
+#  define ns(x) x##_ns
+
+#  define XML_TOK_NS_C
+#  include "xmltok_ns.c"
+#  undef XML_TOK_NS_C
+
+#  undef NS
+#  undef ns
+
+ENCODING *
+XmlInitUnknownEncodingNS(void *mem, int *table, CONVERTER convert,
+                         void *userData) {
+  ENCODING *enc = XmlInitUnknownEncoding(mem, table, convert, userData);
+  if (enc)
+    ((struct normal_encoding *)enc)->type[ASCII_COLON] = BT_COLON;
+  return enc;
+}
+
+#endif /* XML_NS */
diff --git a/base/poco/XML/src/xmltok.h b/base/poco/XML/src/xmltok.h
new file mode 100644
index 00000000000..6f630c2f9ba
--- /dev/null
+++ b/base/poco/XML/src/xmltok.h
@@ -0,0 +1,319 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2002-2005 Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2016-2017 Sebastian Pipping <sebastian@pipping.org>
+   Copyright (c) 2017      Rhodri James <rhodri@wildebeest.org.uk>
+   Licensed under the MIT license:
+
+   Permission is  hereby granted,  free of charge,  to any  person obtaining
+   a  copy  of  this  software   and  associated  documentation  files  (the
+   "Software"),  to  deal in  the  Software  without restriction,  including
+   without  limitation the  rights  to use,  copy,  modify, merge,  publish,
+   distribute, sublicense, and/or sell copies of the Software, and to permit
+   persons  to whom  the Software  is  furnished to  do so,  subject to  the
+   following conditions:
+
+   The above copyright  notice and this permission notice  shall be included
+   in all copies or substantial portions of the Software.
+
+   THE  SOFTWARE  IS  PROVIDED  "AS  IS",  WITHOUT  WARRANTY  OF  ANY  KIND,
+   EXPRESS  OR IMPLIED,  INCLUDING  BUT  NOT LIMITED  TO  THE WARRANTIES  OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+   NO EVENT SHALL THE AUTHORS OR  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+   DAMAGES OR  OTHER LIABILITY, WHETHER  IN AN  ACTION OF CONTRACT,  TORT OR
+   OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+   USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef XmlTok_INCLUDED
+#define XmlTok_INCLUDED 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* The following token may be returned by XmlContentTok */
+#define XML_TOK_TRAILING_RSQB                                                  \
+  -5 /* ] or ]] at the end of the scan; might be                               \
+        start of illegal ]]> sequence */
+/* The following tokens may be returned by both XmlPrologTok and
+   XmlContentTok.
+*/
+#define XML_TOK_NONE -4 /* The string to be scanned is empty */
+#define XML_TOK_TRAILING_CR                                                    \
+  -3                            /* A CR at the end of the scan;                \
+                                   might be part of CRLF sequence */
+#define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */
+#define XML_TOK_PARTIAL -1      /* only part of a token */
+#define XML_TOK_INVALID 0
+
+/* The following tokens are returned by XmlContentTok; some are also
+   returned by XmlAttributeValueTok, XmlEntityTok, XmlCdataSectionTok.
+*/
+#define XML_TOK_START_TAG_WITH_ATTS 1
+#define XML_TOK_START_TAG_NO_ATTS 2
+#define XML_TOK_EMPTY_ELEMENT_WITH_ATTS 3 /* empty element tag <e/> */
+#define XML_TOK_EMPTY_ELEMENT_NO_ATTS 4
+#define XML_TOK_END_TAG 5
+#define XML_TOK_DATA_CHARS 6
+#define XML_TOK_DATA_NEWLINE 7
+#define XML_TOK_CDATA_SECT_OPEN 8
+#define XML_TOK_ENTITY_REF 9
+#define XML_TOK_CHAR_REF 10 /* numeric character reference */
+
+/* The following tokens may be returned by both XmlPrologTok and
+   XmlContentTok.
+*/
+#define XML_TOK_PI 11       /* processing instruction */
+#define XML_TOK_XML_DECL 12 /* XML decl or text decl */
+#define XML_TOK_COMMENT 13
+#define XML_TOK_BOM 14 /* Byte order mark */
+
+/* The following tokens are returned only by XmlPrologTok */
+#define XML_TOK_PROLOG_S 15
+#define XML_TOK_DECL_OPEN 16  /* <!foo */
+#define XML_TOK_DECL_CLOSE 17 /* > */
+#define XML_TOK_NAME 18
+#define XML_TOK_NMTOKEN 19
+#define XML_TOK_POUND_NAME 20 /* #name */
+#define XML_TOK_OR 21         /* | */
+#define XML_TOK_PERCENT 22
+#define XML_TOK_OPEN_PAREN 23
+#define XML_TOK_CLOSE_PAREN 24
+#define XML_TOK_OPEN_BRACKET 25
+#define XML_TOK_CLOSE_BRACKET 26
+#define XML_TOK_LITERAL 27
+#define XML_TOK_PARAM_ENTITY_REF 28
+#define XML_TOK_INSTANCE_START 29
+
+/* The following occur only in element type declarations */
+#define XML_TOK_NAME_QUESTION 30        /* name? */
+#define XML_TOK_NAME_ASTERISK 31        /* name* */
+#define XML_TOK_NAME_PLUS 32            /* name+ */
+#define XML_TOK_COND_SECT_OPEN 33       /* <![ */
+#define XML_TOK_COND_SECT_CLOSE 34      /* ]]> */
+#define XML_TOK_CLOSE_PAREN_QUESTION 35 /* )? */
+#define XML_TOK_CLOSE_PAREN_ASTERISK 36 /* )* */
+#define XML_TOK_CLOSE_PAREN_PLUS 37     /* )+ */
+#define XML_TOK_COMMA 38
+
+/* The following token is returned only by XmlAttributeValueTok */
+#define XML_TOK_ATTRIBUTE_VALUE_S 39
+
+/* The following token is returned only by XmlCdataSectionTok */
+#define XML_TOK_CDATA_SECT_CLOSE 40
+
+/* With namespace processing this is returned by XmlPrologTok for a
+   name with a colon.
+*/
+#define XML_TOK_PREFIXED_NAME 41
+
+#ifdef XML_DTD
+#  define XML_TOK_IGNORE_SECT 42
+#endif /* XML_DTD */
+
+#ifdef XML_DTD
+#  define XML_N_STATES 4
+#else /* not XML_DTD */
+#  define XML_N_STATES 3
+#endif /* not XML_DTD */
+
+#define XML_PROLOG_STATE 0
+#define XML_CONTENT_STATE 1
+#define XML_CDATA_SECTION_STATE 2
+#ifdef XML_DTD
+#  define XML_IGNORE_SECTION_STATE 3
+#endif /* XML_DTD */
+
+#define XML_N_LITERAL_TYPES 2
+#define XML_ATTRIBUTE_VALUE_LITERAL 0
+#define XML_ENTITY_VALUE_LITERAL 1
+
+/* The size of the buffer passed to XmlUtf8Encode must be at least this. */
+#define XML_UTF8_ENCODE_MAX 4
+/* The size of the buffer passed to XmlUtf16Encode must be at least this. */
+#define XML_UTF16_ENCODE_MAX 2
+
+typedef struct position {
+  /* first line and first column are 0 not 1 */
+  XML_Size lineNumber;
+  XML_Size columnNumber;
+} POSITION;
+
+typedef struct {
+  const char *name;
+  const char *valuePtr;
+  const char *valueEnd;
+  char normalized;
+} ATTRIBUTE;
+
+struct encoding;
+typedef struct encoding ENCODING;
+
+typedef int(PTRCALL *SCANNER)(const ENCODING *, const char *, const char *,
+                              const char **);
+
+enum XML_Convert_Result {
+  XML_CONVERT_COMPLETED = 0,
+  XML_CONVERT_INPUT_INCOMPLETE = 1,
+  XML_CONVERT_OUTPUT_EXHAUSTED
+  = 2 /* and therefore potentially input remaining as well */
+};
+
+struct encoding {
+  SCANNER scanners[XML_N_STATES];
+  SCANNER literalScanners[XML_N_LITERAL_TYPES];
+  int(PTRCALL *nameMatchesAscii)(const ENCODING *, const char *, const char *,
+                                 const char *);
+  int(PTRFASTCALL *nameLength)(const ENCODING *, const char *);
+  const char *(PTRFASTCALL *skipS)(const ENCODING *, const char *);
+  int(PTRCALL *getAtts)(const ENCODING *enc, const char *ptr, int attsMax,
+                        ATTRIBUTE *atts);
+  int(PTRFASTCALL *charRefNumber)(const ENCODING *enc, const char *ptr);
+  int(PTRCALL *predefinedEntityName)(const ENCODING *, const char *,
+                                     const char *);
+  void(PTRCALL *updatePosition)(const ENCODING *, const char *ptr,
+                                const char *end, POSITION *);
+  int(PTRCALL *isPublicId)(const ENCODING *enc, const char *ptr,
+                           const char *end, const char **badPtr);
+  enum XML_Convert_Result(PTRCALL *utf8Convert)(const ENCODING *enc,
+                                                const char **fromP,
+                                                const char *fromLim, char **toP,
+                                                const char *toLim);
+  enum XML_Convert_Result(PTRCALL *utf16Convert)(const ENCODING *enc,
+                                                 const char **fromP,
+                                                 const char *fromLim,
+                                                 unsigned short **toP,
+                                                 const unsigned short *toLim);
+  int minBytesPerChar;
+  char isUtf8;
+  char isUtf16;
+};
+
+/* Scan the string starting at ptr until the end of the next complete
+   token, but do not scan past eptr.  Return an integer giving the
+   type of token.
+
+   Return XML_TOK_NONE when ptr == eptr; nextTokPtr will not be set.
+
+   Return XML_TOK_PARTIAL when the string does not contain a complete
+   token; nextTokPtr will not be set.
+
+   Return XML_TOK_INVALID when the string does not start a valid
+   token; nextTokPtr will be set to point to the character which made
+   the token invalid.
+
+   Otherwise the string starts with a valid token; nextTokPtr will be
+   set to point to the character following the end of that token.
+
+   Each data character counts as a single token, but adjacent data
+   characters may be returned together.  Similarly for characters in
+   the prolog outside literals, comments and processing instructions.
+*/
+
+#define XmlTok(enc, state, ptr, end, nextTokPtr)                               \
+  (((enc)->scanners[state])(enc, ptr, end, nextTokPtr))
+
+#define XmlPrologTok(enc, ptr, end, nextTokPtr)                                \
+  XmlTok(enc, XML_PROLOG_STATE, ptr, end, nextTokPtr)
+
+#define XmlContentTok(enc, ptr, end, nextTokPtr)                               \
+  XmlTok(enc, XML_CONTENT_STATE, ptr, end, nextTokPtr)
+
+#define XmlCdataSectionTok(enc, ptr, end, nextTokPtr)                          \
+  XmlTok(enc, XML_CDATA_SECTION_STATE, ptr, end, nextTokPtr)
+
+#ifdef XML_DTD
+
+#  define XmlIgnoreSectionTok(enc, ptr, end, nextTokPtr)                       \
+    XmlTok(enc, XML_IGNORE_SECTION_STATE, ptr, end, nextTokPtr)
+
+#endif /* XML_DTD */
+
+/* This is used for performing a 2nd-level tokenization on the content
+   of a literal that has already been returned by XmlTok.
+*/
+#define XmlLiteralTok(enc, literalType, ptr, end, nextTokPtr)                  \
+  (((enc)->literalScanners[literalType])(enc, ptr, end, nextTokPtr))
+
+#define XmlAttributeValueTok(enc, ptr, end, nextTokPtr)                        \
+  XmlLiteralTok(enc, XML_ATTRIBUTE_VALUE_LITERAL, ptr, end, nextTokPtr)
+
+#define XmlEntityValueTok(enc, ptr, end, nextTokPtr)                           \
+  XmlLiteralTok(enc, XML_ENTITY_VALUE_LITERAL, ptr, end, nextTokPtr)
+
+#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2)                             \
+  (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2))
+
+#define XmlNameLength(enc, ptr) (((enc)->nameLength)(enc, ptr))
+
+#define XmlSkipS(enc, ptr) (((enc)->skipS)(enc, ptr))
+
+#define XmlGetAttributes(enc, ptr, attsMax, atts)                              \
+  (((enc)->getAtts)(enc, ptr, attsMax, atts))
+
+#define XmlCharRefNumber(enc, ptr) (((enc)->charRefNumber)(enc, ptr))
+
+#define XmlPredefinedEntityName(enc, ptr, end)                                 \
+  (((enc)->predefinedEntityName)(enc, ptr, end))
+
+#define XmlUpdatePosition(enc, ptr, end, pos)                                  \
+  (((enc)->updatePosition)(enc, ptr, end, pos))
+
+#define XmlIsPublicId(enc, ptr, end, badPtr)                                   \
+  (((enc)->isPublicId)(enc, ptr, end, badPtr))
+
+#define XmlUtf8Convert(enc, fromP, fromLim, toP, toLim)                        \
+  (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim))
+
+#define XmlUtf16Convert(enc, fromP, fromLim, toP, toLim)                       \
+  (((enc)->utf16Convert)(enc, fromP, fromLim, toP, toLim))
+
+typedef struct {
+  ENCODING initEnc;
+  const ENCODING **encPtr;
+} INIT_ENCODING;
+
+int XmlParseXmlDecl(int isGeneralTextEntity, const ENCODING *enc,
+                    const char *ptr, const char *end, const char **badPtr,
+                    const char **versionPtr, const char **versionEndPtr,
+                    const char **encodingNamePtr,
+                    const ENCODING **namedEncodingPtr, int *standalonePtr);
+
+int XmlInitEncoding(INIT_ENCODING *, const ENCODING **, const char *name);
+const ENCODING *XmlGetUtf8InternalEncoding(void);
+const ENCODING *XmlGetUtf16InternalEncoding(void);
+int FASTCALL XmlUtf8Encode(int charNumber, char *buf);
+int FASTCALL XmlUtf16Encode(int charNumber, unsigned short *buf);
+int XmlSizeOfUnknownEncoding(void);
+
+typedef int(XMLCALL *CONVERTER)(void *userData, const char *p);
+
+ENCODING *XmlInitUnknownEncoding(void *mem, int *table, CONVERTER convert,
+                                 void *userData);
+
+int XmlParseXmlDeclNS(int isGeneralTextEntity, const ENCODING *enc,
+                      const char *ptr, const char *end, const char **badPtr,
+                      const char **versionPtr, const char **versionEndPtr,
+                      const char **encodingNamePtr,
+                      const ENCODING **namedEncodingPtr, int *standalonePtr);
+
+int XmlInitEncodingNS(INIT_ENCODING *, const ENCODING **, const char *name);
+const ENCODING *XmlGetUtf8InternalEncodingNS(void);
+const ENCODING *XmlGetUtf16InternalEncodingNS(void);
+ENCODING *XmlInitUnknownEncodingNS(void *mem, int *table, CONVERTER convert,
+                                   void *userData);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* not XmlTok_INCLUDED */
diff --git a/base/poco/XML/src/xmltok_impl.c b/base/poco/XML/src/xmltok_impl.c
new file mode 100644
index 00000000000..4072b06497d
--- /dev/null
+++ b/base/poco/XML/src/xmltok_impl.c
@@ -0,0 +1,1817 @@
+/* This file is included (from xmltok.c, 1-3 times depending on XML_MIN_SIZE)!
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2002-2016 Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2016-2022 Sebastian Pipping <sebastian@pipping.org>
+   Copyright (c) 2017      Rhodri James <rhodri@wildebeest.org.uk>
+   Copyright (c) 2018      Benjamin Peterson <benjamin@python.org>
+   Copyright (c) 2018      Anton Maklakov <antmak.pub@gmail.com>
+   Copyright (c) 2019      David Loffredo <loffredo@steptools.com>
+   Copyright (c) 2020      Boris Kolpackov <boris@codesynthesis.com>
+   Licensed under the MIT license:
+
+   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.
+*/
+
+#ifdef XML_TOK_IMPL_C
+
+#  ifndef IS_INVALID_CHAR // i.e. for UTF-16 and XML_MIN_SIZE not defined
+#    define IS_INVALID_CHAR(enc, ptr, n) (0)
+#  endif
+
+#  define INVALID_LEAD_CASE(n, ptr, nextTokPtr)                                \
+  case BT_LEAD##n:                                                             \
+    if (end - ptr < n)                                                         \
+      return XML_TOK_PARTIAL_CHAR;                                             \
+    if (IS_INVALID_CHAR(enc, ptr, n)) {                                        \
+      *(nextTokPtr) = (ptr);                                                   \
+      return XML_TOK_INVALID;                                                  \
+    }                                                                          \
+    ptr += n;                                                                  \
+    break;
+
+#  define INVALID_CASES(ptr, nextTokPtr)                                       \
+    INVALID_LEAD_CASE(2, ptr, nextTokPtr)                                      \
+    INVALID_LEAD_CASE(3, ptr, nextTokPtr)                                      \
+    INVALID_LEAD_CASE(4, ptr, nextTokPtr)                                      \
+  case BT_NONXML:                                                              \
+  case BT_MALFORM:                                                             \
+  case BT_TRAIL:                                                               \
+    *(nextTokPtr) = (ptr);                                                     \
+    return XML_TOK_INVALID;
+
+#  define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr)                        \
+  case BT_LEAD##n:                                                             \
+    if (end - ptr < n)                                                         \
+      return XML_TOK_PARTIAL_CHAR;                                             \
+    if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) {         \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_INVALID;                                                  \
+    }                                                                          \
+    ptr += n;                                                                  \
+    break;
+
+#  define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)                          \
+  case BT_NONASCII:                                                            \
+    if (! IS_NAME_CHAR_MINBPC(enc, ptr)) {                                     \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_INVALID;                                                  \
+    }                                                                          \
+    /* fall through */                                                         \
+  case BT_NMSTRT:                                                              \
+  case BT_HEX:                                                                 \
+  case BT_DIGIT:                                                               \
+  case BT_NAME:                                                                \
+  case BT_MINUS:                                                               \
+    ptr += MINBPC(enc);                                                        \
+    break;                                                                     \
+    CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr)                              \
+    CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr)                              \
+    CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr)
+
+#  define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr)                      \
+  case BT_LEAD##n:                                                             \
+    if (end - ptr < n)                                                         \
+      return XML_TOK_PARTIAL_CHAR;                                             \
+    if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) {       \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_INVALID;                                                  \
+    }                                                                          \
+    ptr += n;                                                                  \
+    break;
+
+#  define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)                        \
+  case BT_NONASCII:                                                            \
+    if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {                                   \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_INVALID;                                                  \
+    }                                                                          \
+    /* fall through */                                                         \
+  case BT_NMSTRT:                                                              \
+  case BT_HEX:                                                                 \
+    ptr += MINBPC(enc);                                                        \
+    break;                                                                     \
+    CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr)                            \
+    CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr)                            \
+    CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr)
+
+#  ifndef PREFIX
+#    define PREFIX(ident) ident
+#  endif
+
+#  define HAS_CHARS(enc, ptr, end, count) (end - ptr >= count * MINBPC(enc))
+
+#  define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1)
+
+#  define REQUIRE_CHARS(enc, ptr, end, count)                                  \
+    {                                                                          \
+      if (! HAS_CHARS(enc, ptr, end, count)) {                                 \
+        return XML_TOK_PARTIAL;                                                \
+      }                                                                        \
+    }
+
+#  define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1)
+
+/* ptr points to character following "<!-" */
+
+static int PTRCALL
+PREFIX(scanComment)(const ENCODING *enc, const char *ptr, const char *end,
+                    const char **nextTokPtr) {
+  if (HAS_CHAR(enc, ptr, end)) {
+    if (! CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+    ptr += MINBPC(enc);
+    while (HAS_CHAR(enc, ptr, end)) {
+      switch (BYTE_TYPE(enc, ptr)) {
+        INVALID_CASES(ptr, nextTokPtr)
+      case BT_MINUS:
+        ptr += MINBPC(enc);
+        REQUIRE_CHAR(enc, ptr, end);
+        if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
+          ptr += MINBPC(enc);
+          REQUIRE_CHAR(enc, ptr, end);
+          if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+            *nextTokPtr = ptr;
+            return XML_TOK_INVALID;
+          }
+          *nextTokPtr = ptr + MINBPC(enc);
+          return XML_TOK_COMMENT;
+        }
+        break;
+      default:
+        ptr += MINBPC(enc);
+        break;
+      }
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+/* ptr points to character following "<!" */
+
+static int PTRCALL
+PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
+                 const char **nextTokPtr) {
+  REQUIRE_CHAR(enc, ptr, end);
+  switch (BYTE_TYPE(enc, ptr)) {
+  case BT_MINUS:
+    return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_LSQB:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_COND_SECT_OPEN;
+  case BT_NMSTRT:
+  case BT_HEX:
+    ptr += MINBPC(enc);
+    break;
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_PERCNT:
+      REQUIRE_CHARS(enc, ptr, end, 2);
+      /* don't allow <!ENTITY% foo "whatever"> */
+      switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
+      case BT_S:
+      case BT_CR:
+      case BT_LF:
+      case BT_PERCNT:
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      /* fall through */
+    case BT_S:
+    case BT_CR:
+    case BT_LF:
+      *nextTokPtr = ptr;
+      return XML_TOK_DECL_OPEN;
+    case BT_NMSTRT:
+    case BT_HEX:
+      ptr += MINBPC(enc);
+      break;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+static int PTRCALL
+PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end,
+                      int *tokPtr) {
+  int upper = 0;
+  UNUSED_P(enc);
+  *tokPtr = XML_TOK_PI;
+  if (end - ptr != MINBPC(enc) * 3)
+    return 1;
+  switch (BYTE_TO_ASCII(enc, ptr)) {
+  case ASCII_x:
+    break;
+  case ASCII_X:
+    upper = 1;
+    break;
+  default:
+    return 1;
+  }
+  ptr += MINBPC(enc);
+  switch (BYTE_TO_ASCII(enc, ptr)) {
+  case ASCII_m:
+    break;
+  case ASCII_M:
+    upper = 1;
+    break;
+  default:
+    return 1;
+  }
+  ptr += MINBPC(enc);
+  switch (BYTE_TO_ASCII(enc, ptr)) {
+  case ASCII_l:
+    break;
+  case ASCII_L:
+    upper = 1;
+    break;
+  default:
+    return 1;
+  }
+  if (upper)
+    return 0;
+  *tokPtr = XML_TOK_XML_DECL;
+  return 1;
+}
+
+/* ptr points to character following "<?" */
+
+static int PTRCALL
+PREFIX(scanPi)(const ENCODING *enc, const char *ptr, const char *end,
+               const char **nextTokPtr) {
+  int tok;
+  const char *target = ptr;
+  REQUIRE_CHAR(enc, ptr, end);
+  switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_S:
+    case BT_CR:
+    case BT_LF:
+      if (! PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      ptr += MINBPC(enc);
+      while (HAS_CHAR(enc, ptr, end)) {
+        switch (BYTE_TYPE(enc, ptr)) {
+          INVALID_CASES(ptr, nextTokPtr)
+        case BT_QUEST:
+          ptr += MINBPC(enc);
+          REQUIRE_CHAR(enc, ptr, end);
+          if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+            *nextTokPtr = ptr + MINBPC(enc);
+            return tok;
+          }
+          break;
+        default:
+          ptr += MINBPC(enc);
+          break;
+        }
+      }
+      return XML_TOK_PARTIAL;
+    case BT_QUEST:
+      if (! PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      ptr += MINBPC(enc);
+      REQUIRE_CHAR(enc, ptr, end);
+      if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+        *nextTokPtr = ptr + MINBPC(enc);
+        return tok;
+      }
+      /* fall through */
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+static int PTRCALL
+PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr, const char *end,
+                         const char **nextTokPtr) {
+  static const char CDATA_LSQB[]
+      = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB};
+  int i;
+  UNUSED_P(enc);
+  /* CDATA[ */
+  REQUIRE_CHARS(enc, ptr, end, 6);
+  for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
+    if (! CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) {
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  *nextTokPtr = ptr;
+  return XML_TOK_CDATA_SECT_OPEN;
+}
+
+static int PTRCALL
+PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
+                        const char **nextTokPtr) {
+  if (ptr >= end)
+    return XML_TOK_NONE;
+  if (MINBPC(enc) > 1) {
+    size_t n = end - ptr;
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
+      if (n == 0)
+        return XML_TOK_PARTIAL;
+      end = ptr + n;
+    }
+  }
+  switch (BYTE_TYPE(enc, ptr)) {
+  case BT_RSQB:
+    ptr += MINBPC(enc);
+    REQUIRE_CHAR(enc, ptr, end);
+    if (! CHAR_MATCHES(enc, ptr, ASCII_RSQB))
+      break;
+    ptr += MINBPC(enc);
+    REQUIRE_CHAR(enc, ptr, end);
+    if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+      ptr -= MINBPC(enc);
+      break;
+    }
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_CDATA_SECT_CLOSE;
+  case BT_CR:
+    ptr += MINBPC(enc);
+    REQUIRE_CHAR(enc, ptr, end);
+    if (BYTE_TYPE(enc, ptr) == BT_LF)
+      ptr += MINBPC(enc);
+    *nextTokPtr = ptr;
+    return XML_TOK_DATA_NEWLINE;
+  case BT_LF:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_DATA_NEWLINE;
+    INVALID_CASES(ptr, nextTokPtr)
+  default:
+    ptr += MINBPC(enc);
+    break;
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) {                       \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_DATA_CHARS;                                               \
+    }                                                                          \
+    ptr += n;                                                                  \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
+    case BT_NONXML:
+    case BT_MALFORM:
+    case BT_TRAIL:
+    case BT_CR:
+    case BT_LF:
+    case BT_RSQB:
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+  }
+  *nextTokPtr = ptr;
+  return XML_TOK_DATA_CHARS;
+}
+
+/* ptr points to character following "</" */
+
+static int PTRCALL
+PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, const char *end,
+                   const char **nextTokPtr) {
+  REQUIRE_CHAR(enc, ptr, end);
+  switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_S:
+    case BT_CR:
+    case BT_LF:
+      for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
+        switch (BYTE_TYPE(enc, ptr)) {
+        case BT_S:
+        case BT_CR:
+        case BT_LF:
+          break;
+        case BT_GT:
+          *nextTokPtr = ptr + MINBPC(enc);
+          return XML_TOK_END_TAG;
+        default:
+          *nextTokPtr = ptr;
+          return XML_TOK_INVALID;
+        }
+      }
+      return XML_TOK_PARTIAL;
+#  ifdef XML_NS
+    case BT_COLON:
+      /* no need to check qname syntax here,
+         since end-tag must match exactly */
+      ptr += MINBPC(enc);
+      break;
+#  endif
+    case BT_GT:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_END_TAG;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+/* ptr points to character following "&#X" */
+
+static int PTRCALL
+PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr, const char *end,
+                       const char **nextTokPtr) {
+  if (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_DIGIT:
+    case BT_HEX:
+      break;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+    for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
+      switch (BYTE_TYPE(enc, ptr)) {
+      case BT_DIGIT:
+      case BT_HEX:
+        break;
+      case BT_SEMI:
+        *nextTokPtr = ptr + MINBPC(enc);
+        return XML_TOK_CHAR_REF;
+      default:
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+/* ptr points to character following "&#" */
+
+static int PTRCALL
+PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, const char *end,
+                    const char **nextTokPtr) {
+  if (HAS_CHAR(enc, ptr, end)) {
+    if (CHAR_MATCHES(enc, ptr, ASCII_x))
+      return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_DIGIT:
+      break;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+    for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
+      switch (BYTE_TYPE(enc, ptr)) {
+      case BT_DIGIT:
+        break;
+      case BT_SEMI:
+        *nextTokPtr = ptr + MINBPC(enc);
+        return XML_TOK_CHAR_REF;
+      default:
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+/* ptr points to character following "&" */
+
+static int PTRCALL
+PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
+                const char **nextTokPtr) {
+  REQUIRE_CHAR(enc, ptr, end);
+  switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  case BT_NUM:
+    return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_SEMI:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_ENTITY_REF;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+/* ptr points to character following first character of attribute name */
+
+static int PTRCALL
+PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
+                 const char **nextTokPtr) {
+#  ifdef XML_NS
+  int hadColon = 0;
+#  endif
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+#  ifdef XML_NS
+    case BT_COLON:
+      if (hadColon) {
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      hadColon = 1;
+      ptr += MINBPC(enc);
+      REQUIRE_CHAR(enc, ptr, end);
+      switch (BYTE_TYPE(enc, ptr)) {
+        CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+      default:
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      break;
+#  endif
+    case BT_S:
+    case BT_CR:
+    case BT_LF:
+      for (;;) {
+        int t;
+
+        ptr += MINBPC(enc);
+        REQUIRE_CHAR(enc, ptr, end);
+        t = BYTE_TYPE(enc, ptr);
+        if (t == BT_EQUALS)
+          break;
+        switch (t) {
+        case BT_S:
+        case BT_LF:
+        case BT_CR:
+          break;
+        default:
+          *nextTokPtr = ptr;
+          return XML_TOK_INVALID;
+        }
+      }
+      /* fall through */
+    case BT_EQUALS: {
+      int open;
+#  ifdef XML_NS
+      hadColon = 0;
+#  endif
+      for (;;) {
+        ptr += MINBPC(enc);
+        REQUIRE_CHAR(enc, ptr, end);
+        open = BYTE_TYPE(enc, ptr);
+        if (open == BT_QUOT || open == BT_APOS)
+          break;
+        switch (open) {
+        case BT_S:
+        case BT_LF:
+        case BT_CR:
+          break;
+        default:
+          *nextTokPtr = ptr;
+          return XML_TOK_INVALID;
+        }
+      }
+      ptr += MINBPC(enc);
+      /* in attribute value */
+      for (;;) {
+        int t;
+        REQUIRE_CHAR(enc, ptr, end);
+        t = BYTE_TYPE(enc, ptr);
+        if (t == open)
+          break;
+        switch (t) {
+          INVALID_CASES(ptr, nextTokPtr)
+        case BT_AMP: {
+          int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
+          if (tok <= 0) {
+            if (tok == XML_TOK_INVALID)
+              *nextTokPtr = ptr;
+            return tok;
+          }
+          break;
+        }
+        case BT_LT:
+          *nextTokPtr = ptr;
+          return XML_TOK_INVALID;
+        default:
+          ptr += MINBPC(enc);
+          break;
+        }
+      }
+      ptr += MINBPC(enc);
+      REQUIRE_CHAR(enc, ptr, end);
+      switch (BYTE_TYPE(enc, ptr)) {
+      case BT_S:
+      case BT_CR:
+      case BT_LF:
+        break;
+      case BT_SOL:
+        goto sol;
+      case BT_GT:
+        goto gt;
+      default:
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      /* ptr points to closing quote */
+      for (;;) {
+        ptr += MINBPC(enc);
+        REQUIRE_CHAR(enc, ptr, end);
+        switch (BYTE_TYPE(enc, ptr)) {
+          CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+        case BT_S:
+        case BT_CR:
+        case BT_LF:
+          continue;
+        case BT_GT:
+        gt:
+          *nextTokPtr = ptr + MINBPC(enc);
+          return XML_TOK_START_TAG_WITH_ATTS;
+        case BT_SOL:
+        sol:
+          ptr += MINBPC(enc);
+          REQUIRE_CHAR(enc, ptr, end);
+          if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+            *nextTokPtr = ptr;
+            return XML_TOK_INVALID;
+          }
+          *nextTokPtr = ptr + MINBPC(enc);
+          return XML_TOK_EMPTY_ELEMENT_WITH_ATTS;
+        default:
+          *nextTokPtr = ptr;
+          return XML_TOK_INVALID;
+        }
+        break;
+      }
+      break;
+    }
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+/* ptr points to character following "<" */
+
+static int PTRCALL
+PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
+               const char **nextTokPtr) {
+#  ifdef XML_NS
+  int hadColon;
+#  endif
+  REQUIRE_CHAR(enc, ptr, end);
+  switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  case BT_EXCL:
+    ptr += MINBPC(enc);
+    REQUIRE_CHAR(enc, ptr, end);
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_MINUS:
+      return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+    case BT_LSQB:
+      return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+    }
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  case BT_QUEST:
+    return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_SOL:
+    return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+#  ifdef XML_NS
+  hadColon = 0;
+#  endif
+  /* we have a start-tag */
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+#  ifdef XML_NS
+    case BT_COLON:
+      if (hadColon) {
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      hadColon = 1;
+      ptr += MINBPC(enc);
+      REQUIRE_CHAR(enc, ptr, end);
+      switch (BYTE_TYPE(enc, ptr)) {
+        CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+      default:
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      break;
+#  endif
+    case BT_S:
+    case BT_CR:
+    case BT_LF: {
+      ptr += MINBPC(enc);
+      while (HAS_CHAR(enc, ptr, end)) {
+        switch (BYTE_TYPE(enc, ptr)) {
+          CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+        case BT_GT:
+          goto gt;
+        case BT_SOL:
+          goto sol;
+        case BT_S:
+        case BT_CR:
+        case BT_LF:
+          ptr += MINBPC(enc);
+          continue;
+        default:
+          *nextTokPtr = ptr;
+          return XML_TOK_INVALID;
+        }
+        return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr);
+      }
+      return XML_TOK_PARTIAL;
+    }
+    case BT_GT:
+    gt:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_START_TAG_NO_ATTS;
+    case BT_SOL:
+    sol:
+      ptr += MINBPC(enc);
+      REQUIRE_CHAR(enc, ptr, end);
+      if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_EMPTY_ELEMENT_NO_ATTS;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+static int PTRCALL
+PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
+                   const char **nextTokPtr) {
+  if (ptr >= end)
+    return XML_TOK_NONE;
+  if (MINBPC(enc) > 1) {
+    size_t n = end - ptr;
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
+      if (n == 0)
+        return XML_TOK_PARTIAL;
+      end = ptr + n;
+    }
+  }
+  switch (BYTE_TYPE(enc, ptr)) {
+  case BT_LT:
+    return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_AMP:
+    return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_CR:
+    ptr += MINBPC(enc);
+    if (! HAS_CHAR(enc, ptr, end))
+      return XML_TOK_TRAILING_CR;
+    if (BYTE_TYPE(enc, ptr) == BT_LF)
+      ptr += MINBPC(enc);
+    *nextTokPtr = ptr;
+    return XML_TOK_DATA_NEWLINE;
+  case BT_LF:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_DATA_NEWLINE;
+  case BT_RSQB:
+    ptr += MINBPC(enc);
+    if (! HAS_CHAR(enc, ptr, end))
+      return XML_TOK_TRAILING_RSQB;
+    if (! CHAR_MATCHES(enc, ptr, ASCII_RSQB))
+      break;
+    ptr += MINBPC(enc);
+    if (! HAS_CHAR(enc, ptr, end))
+      return XML_TOK_TRAILING_RSQB;
+    if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+      ptr -= MINBPC(enc);
+      break;
+    }
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+    INVALID_CASES(ptr, nextTokPtr)
+  default:
+    ptr += MINBPC(enc);
+    break;
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) {                       \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_DATA_CHARS;                                               \
+    }                                                                          \
+    ptr += n;                                                                  \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
+    case BT_RSQB:
+      if (HAS_CHARS(enc, ptr, end, 2)) {
+        if (! CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) {
+          ptr += MINBPC(enc);
+          break;
+        }
+        if (HAS_CHARS(enc, ptr, end, 3)) {
+          if (! CHAR_MATCHES(enc, ptr + 2 * MINBPC(enc), ASCII_GT)) {
+            ptr += MINBPC(enc);
+            break;
+          }
+          *nextTokPtr = ptr + 2 * MINBPC(enc);
+          return XML_TOK_INVALID;
+        }
+      }
+      /* fall through */
+    case BT_AMP:
+    case BT_LT:
+    case BT_NONXML:
+    case BT_MALFORM:
+    case BT_TRAIL:
+    case BT_CR:
+    case BT_LF:
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+  }
+  *nextTokPtr = ptr;
+  return XML_TOK_DATA_CHARS;
+}
+
+/* ptr points to character following "%" */
+
+static int PTRCALL
+PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
+                    const char **nextTokPtr) {
+  REQUIRE_CHAR(enc, ptr, end);
+  switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  case BT_S:
+  case BT_LF:
+  case BT_CR:
+  case BT_PERCNT:
+    *nextTokPtr = ptr;
+    return XML_TOK_PERCENT;
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_SEMI:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_PARAM_ENTITY_REF;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+static int PTRCALL
+PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
+                      const char **nextTokPtr) {
+  REQUIRE_CHAR(enc, ptr, end);
+  switch (BYTE_TYPE(enc, ptr)) {
+    CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_CR:
+    case BT_LF:
+    case BT_S:
+    case BT_RPAR:
+    case BT_GT:
+    case BT_PERCNT:
+    case BT_VERBAR:
+      *nextTokPtr = ptr;
+      return XML_TOK_POUND_NAME;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return -XML_TOK_POUND_NAME;
+}
+
+static int PTRCALL
+PREFIX(scanLit)(int open, const ENCODING *enc, const char *ptr, const char *end,
+                const char **nextTokPtr) {
+  while (HAS_CHAR(enc, ptr, end)) {
+    int t = BYTE_TYPE(enc, ptr);
+    switch (t) {
+      INVALID_CASES(ptr, nextTokPtr)
+    case BT_QUOT:
+    case BT_APOS:
+      ptr += MINBPC(enc);
+      if (t != open)
+        break;
+      if (! HAS_CHAR(enc, ptr, end))
+        return -XML_TOK_LITERAL;
+      *nextTokPtr = ptr;
+      switch (BYTE_TYPE(enc, ptr)) {
+      case BT_S:
+      case BT_CR:
+      case BT_LF:
+      case BT_GT:
+      case BT_PERCNT:
+      case BT_LSQB:
+        return XML_TOK_LITERAL;
+      default:
+        return XML_TOK_INVALID;
+      }
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+static int PTRCALL
+PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
+                  const char **nextTokPtr) {
+  int tok;
+  if (ptr >= end)
+    return XML_TOK_NONE;
+  if (MINBPC(enc) > 1) {
+    size_t n = end - ptr;
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
+      if (n == 0)
+        return XML_TOK_PARTIAL;
+      end = ptr + n;
+    }
+  }
+  switch (BYTE_TYPE(enc, ptr)) {
+  case BT_QUOT:
+    return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_APOS:
+    return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_LT: {
+    ptr += MINBPC(enc);
+    REQUIRE_CHAR(enc, ptr, end);
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_EXCL:
+      return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+    case BT_QUEST:
+      return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+    case BT_NMSTRT:
+    case BT_HEX:
+    case BT_NONASCII:
+    case BT_LEAD2:
+    case BT_LEAD3:
+    case BT_LEAD4:
+      *nextTokPtr = ptr - MINBPC(enc);
+      return XML_TOK_INSTANCE_START;
+    }
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  case BT_CR:
+    if (ptr + MINBPC(enc) == end) {
+      *nextTokPtr = end;
+      /* indicate that this might be part of a CR/LF pair */
+      return -XML_TOK_PROLOG_S;
+    }
+    /* fall through */
+  case BT_S:
+  case BT_LF:
+    for (;;) {
+      ptr += MINBPC(enc);
+      if (! HAS_CHAR(enc, ptr, end))
+        break;
+      switch (BYTE_TYPE(enc, ptr)) {
+      case BT_S:
+      case BT_LF:
+        break;
+      case BT_CR:
+        /* don't split CR/LF pair */
+        if (ptr + MINBPC(enc) != end)
+          break;
+        /* fall through */
+      default:
+        *nextTokPtr = ptr;
+        return XML_TOK_PROLOG_S;
+      }
+    }
+    *nextTokPtr = ptr;
+    return XML_TOK_PROLOG_S;
+  case BT_PERCNT:
+    return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+  case BT_COMMA:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_COMMA;
+  case BT_LSQB:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_OPEN_BRACKET;
+  case BT_RSQB:
+    ptr += MINBPC(enc);
+    if (! HAS_CHAR(enc, ptr, end))
+      return -XML_TOK_CLOSE_BRACKET;
+    if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
+      REQUIRE_CHARS(enc, ptr, end, 2);
+      if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) {
+        *nextTokPtr = ptr + 2 * MINBPC(enc);
+        return XML_TOK_COND_SECT_CLOSE;
+      }
+    }
+    *nextTokPtr = ptr;
+    return XML_TOK_CLOSE_BRACKET;
+  case BT_LPAR:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_OPEN_PAREN;
+  case BT_RPAR:
+    ptr += MINBPC(enc);
+    if (! HAS_CHAR(enc, ptr, end))
+      return -XML_TOK_CLOSE_PAREN;
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_AST:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_CLOSE_PAREN_ASTERISK;
+    case BT_QUEST:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_CLOSE_PAREN_QUESTION;
+    case BT_PLUS:
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_CLOSE_PAREN_PLUS;
+    case BT_CR:
+    case BT_LF:
+    case BT_S:
+    case BT_GT:
+    case BT_COMMA:
+    case BT_VERBAR:
+    case BT_RPAR:
+      *nextTokPtr = ptr;
+      return XML_TOK_CLOSE_PAREN;
+    }
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  case BT_VERBAR:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_OR;
+  case BT_GT:
+    *nextTokPtr = ptr + MINBPC(enc);
+    return XML_TOK_DECL_CLOSE;
+  case BT_NUM:
+    return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    if (end - ptr < n)                                                         \
+      return XML_TOK_PARTIAL_CHAR;                                             \
+    if (IS_INVALID_CHAR(enc, ptr, n)) {                                        \
+      *nextTokPtr = ptr;                                                       \
+      return XML_TOK_INVALID;                                                  \
+    }                                                                          \
+    if (IS_NMSTRT_CHAR(enc, ptr, n)) {                                         \
+      ptr += n;                                                                \
+      tok = XML_TOK_NAME;                                                      \
+      break;                                                                   \
+    }                                                                          \
+    if (IS_NAME_CHAR(enc, ptr, n)) {                                           \
+      ptr += n;                                                                \
+      tok = XML_TOK_NMTOKEN;                                                   \
+      break;                                                                   \
+    }                                                                          \
+    *nextTokPtr = ptr;                                                         \
+    return XML_TOK_INVALID;
+    LEAD_CASE(2)
+    LEAD_CASE(3)
+    LEAD_CASE(4)
+#  undef LEAD_CASE
+  case BT_NMSTRT:
+  case BT_HEX:
+    tok = XML_TOK_NAME;
+    ptr += MINBPC(enc);
+    break;
+  case BT_DIGIT:
+  case BT_NAME:
+  case BT_MINUS:
+#  ifdef XML_NS
+  case BT_COLON:
+#  endif
+    tok = XML_TOK_NMTOKEN;
+    ptr += MINBPC(enc);
+    break;
+  case BT_NONASCII:
+    if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {
+      ptr += MINBPC(enc);
+      tok = XML_TOK_NAME;
+      break;
+    }
+    if (IS_NAME_CHAR_MINBPC(enc, ptr)) {
+      ptr += MINBPC(enc);
+      tok = XML_TOK_NMTOKEN;
+      break;
+    }
+    /* fall through */
+  default:
+    *nextTokPtr = ptr;
+    return XML_TOK_INVALID;
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+      CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+    case BT_GT:
+    case BT_RPAR:
+    case BT_COMMA:
+    case BT_VERBAR:
+    case BT_LSQB:
+    case BT_PERCNT:
+    case BT_S:
+    case BT_CR:
+    case BT_LF:
+      *nextTokPtr = ptr;
+      return tok;
+#  ifdef XML_NS
+    case BT_COLON:
+      ptr += MINBPC(enc);
+      switch (tok) {
+      case XML_TOK_NAME:
+        REQUIRE_CHAR(enc, ptr, end);
+        tok = XML_TOK_PREFIXED_NAME;
+        switch (BYTE_TYPE(enc, ptr)) {
+          CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
+        default:
+          tok = XML_TOK_NMTOKEN;
+          break;
+        }
+        break;
+      case XML_TOK_PREFIXED_NAME:
+        tok = XML_TOK_NMTOKEN;
+        break;
+      }
+      break;
+#  endif
+    case BT_PLUS:
+      if (tok == XML_TOK_NMTOKEN) {
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_NAME_PLUS;
+    case BT_AST:
+      if (tok == XML_TOK_NMTOKEN) {
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_NAME_ASTERISK;
+    case BT_QUEST:
+      if (tok == XML_TOK_NMTOKEN) {
+        *nextTokPtr = ptr;
+        return XML_TOK_INVALID;
+      }
+      *nextTokPtr = ptr + MINBPC(enc);
+      return XML_TOK_NAME_QUESTION;
+    default:
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    }
+  }
+  return -tok;
+}
+
+static int PTRCALL
+PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *end,
+                          const char **nextTokPtr) {
+  const char *start;
+  if (ptr >= end)
+    return XML_TOK_NONE;
+  else if (! HAS_CHAR(enc, ptr, end)) {
+    /* This line cannot be executed.  The incoming data has already
+     * been tokenized once, so incomplete characters like this have
+     * already been eliminated from the input.  Retaining the paranoia
+     * check is still valuable, however.
+     */
+    return XML_TOK_PARTIAL; /* LCOV_EXCL_LINE */
+  }
+  start = ptr;
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    ptr += n; /* NOTE: The encoding has already been validated. */             \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
+    case BT_AMP:
+      if (ptr == start)
+        return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    case BT_LT:
+      /* this is for inside entity references */
+      *nextTokPtr = ptr;
+      return XML_TOK_INVALID;
+    case BT_LF:
+      if (ptr == start) {
+        *nextTokPtr = ptr + MINBPC(enc);
+        return XML_TOK_DATA_NEWLINE;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    case BT_CR:
+      if (ptr == start) {
+        ptr += MINBPC(enc);
+        if (! HAS_CHAR(enc, ptr, end))
+          return XML_TOK_TRAILING_CR;
+        if (BYTE_TYPE(enc, ptr) == BT_LF)
+          ptr += MINBPC(enc);
+        *nextTokPtr = ptr;
+        return XML_TOK_DATA_NEWLINE;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    case BT_S:
+      if (ptr == start) {
+        *nextTokPtr = ptr + MINBPC(enc);
+        return XML_TOK_ATTRIBUTE_VALUE_S;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+  }
+  *nextTokPtr = ptr;
+  return XML_TOK_DATA_CHARS;
+}
+
+static int PTRCALL
+PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr, const char *end,
+                       const char **nextTokPtr) {
+  const char *start;
+  if (ptr >= end)
+    return XML_TOK_NONE;
+  else if (! HAS_CHAR(enc, ptr, end)) {
+    /* This line cannot be executed.  The incoming data has already
+     * been tokenized once, so incomplete characters like this have
+     * already been eliminated from the input.  Retaining the paranoia
+     * check is still valuable, however.
+     */
+    return XML_TOK_PARTIAL; /* LCOV_EXCL_LINE */
+  }
+  start = ptr;
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    ptr += n; /* NOTE: The encoding has already been validated. */             \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
+    case BT_AMP:
+      if (ptr == start)
+        return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    case BT_PERCNT:
+      if (ptr == start) {
+        int tok = PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
+        return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    case BT_LF:
+      if (ptr == start) {
+        *nextTokPtr = ptr + MINBPC(enc);
+        return XML_TOK_DATA_NEWLINE;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    case BT_CR:
+      if (ptr == start) {
+        ptr += MINBPC(enc);
+        if (! HAS_CHAR(enc, ptr, end))
+          return XML_TOK_TRAILING_CR;
+        if (BYTE_TYPE(enc, ptr) == BT_LF)
+          ptr += MINBPC(enc);
+        *nextTokPtr = ptr;
+        return XML_TOK_DATA_NEWLINE;
+      }
+      *nextTokPtr = ptr;
+      return XML_TOK_DATA_CHARS;
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+  }
+  *nextTokPtr = ptr;
+  return XML_TOK_DATA_CHARS;
+}
+
+#  ifdef XML_DTD
+
+static int PTRCALL
+PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
+                         const char **nextTokPtr) {
+  int level = 0;
+  if (MINBPC(enc) > 1) {
+    size_t n = end - ptr;
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
+      end = ptr + n;
+    }
+  }
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+      INVALID_CASES(ptr, nextTokPtr)
+    case BT_LT:
+      ptr += MINBPC(enc);
+      REQUIRE_CHAR(enc, ptr, end);
+      if (CHAR_MATCHES(enc, ptr, ASCII_EXCL)) {
+        ptr += MINBPC(enc);
+        REQUIRE_CHAR(enc, ptr, end);
+        if (CHAR_MATCHES(enc, ptr, ASCII_LSQB)) {
+          ++level;
+          ptr += MINBPC(enc);
+        }
+      }
+      break;
+    case BT_RSQB:
+      ptr += MINBPC(enc);
+      REQUIRE_CHAR(enc, ptr, end);
+      if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
+        ptr += MINBPC(enc);
+        REQUIRE_CHAR(enc, ptr, end);
+        if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
+          ptr += MINBPC(enc);
+          if (level == 0) {
+            *nextTokPtr = ptr;
+            return XML_TOK_IGNORE_SECT;
+          }
+          --level;
+        }
+      }
+      break;
+    default:
+      ptr += MINBPC(enc);
+      break;
+    }
+  }
+  return XML_TOK_PARTIAL;
+}
+
+#  endif /* XML_DTD */
+
+static int PTRCALL
+PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
+                   const char **badPtr) {
+  ptr += MINBPC(enc);
+  end -= MINBPC(enc);
+  for (; HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_DIGIT:
+    case BT_HEX:
+    case BT_MINUS:
+    case BT_APOS:
+    case BT_LPAR:
+    case BT_RPAR:
+    case BT_PLUS:
+    case BT_COMMA:
+    case BT_SOL:
+    case BT_EQUALS:
+    case BT_QUEST:
+    case BT_CR:
+    case BT_LF:
+    case BT_SEMI:
+    case BT_EXCL:
+    case BT_AST:
+    case BT_PERCNT:
+    case BT_NUM:
+#  ifdef XML_NS
+    case BT_COLON:
+#  endif
+      break;
+    case BT_S:
+      if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) {
+        *badPtr = ptr;
+        return 0;
+      }
+      break;
+    case BT_NAME:
+    case BT_NMSTRT:
+      if (! (BYTE_TO_ASCII(enc, ptr) & ~0x7f))
+        break;
+      /* fall through */
+    default:
+      switch (BYTE_TO_ASCII(enc, ptr)) {
+      case 0x24: /* $ */
+      case 0x40: /* @ */
+        break;
+      default:
+        *badPtr = ptr;
+        return 0;
+      }
+      break;
+    }
+  }
+  return 1;
+}
+
+/* This must only be called for a well-formed start-tag or empty
+   element tag.  Returns the number of attributes.  Pointers to the
+   first attsMax attributes are stored in atts.
+*/
+
+static int PTRCALL
+PREFIX(getAtts)(const ENCODING *enc, const char *ptr, int attsMax,
+                ATTRIBUTE *atts) {
+  enum { other, inName, inValue } state = inName;
+  int nAtts = 0;
+  int open = 0; /* defined when state == inValue;
+                   initialization just to shut up compilers */
+
+  for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#  define START_NAME                                                           \
+    if (state == other) {                                                      \
+      if (nAtts < attsMax) {                                                   \
+        atts[nAtts].name = ptr;                                                \
+        atts[nAtts].normalized = 1;                                            \
+      }                                                                        \
+      state = inName;                                                          \
+    }
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n: /* NOTE: The encoding has already been validated. */        \
+    START_NAME ptr += (n - MINBPC(enc));                                       \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
+    case BT_NONASCII:
+    case BT_NMSTRT:
+    case BT_HEX:
+      START_NAME
+      break;
+#  undef START_NAME
+    case BT_QUOT:
+      if (state != inValue) {
+        if (nAtts < attsMax)
+          atts[nAtts].valuePtr = ptr + MINBPC(enc);
+        state = inValue;
+        open = BT_QUOT;
+      } else if (open == BT_QUOT) {
+        state = other;
+        if (nAtts < attsMax)
+          atts[nAtts].valueEnd = ptr;
+        nAtts++;
+      }
+      break;
+    case BT_APOS:
+      if (state != inValue) {
+        if (nAtts < attsMax)
+          atts[nAtts].valuePtr = ptr + MINBPC(enc);
+        state = inValue;
+        open = BT_APOS;
+      } else if (open == BT_APOS) {
+        state = other;
+        if (nAtts < attsMax)
+          atts[nAtts].valueEnd = ptr;
+        nAtts++;
+      }
+      break;
+    case BT_AMP:
+      if (nAtts < attsMax)
+        atts[nAtts].normalized = 0;
+      break;
+    case BT_S:
+      if (state == inName)
+        state = other;
+      else if (state == inValue && nAtts < attsMax && atts[nAtts].normalized
+               && (ptr == atts[nAtts].valuePtr
+                   || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE
+                   || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE
+                   || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open))
+        atts[nAtts].normalized = 0;
+      break;
+    case BT_CR:
+    case BT_LF:
+      /* This case ensures that the first attribute name is counted
+         Apart from that we could just change state on the quote. */
+      if (state == inName)
+        state = other;
+      else if (state == inValue && nAtts < attsMax)
+        atts[nAtts].normalized = 0;
+      break;
+    case BT_GT:
+    case BT_SOL:
+      if (state != inValue)
+        return nAtts;
+      break;
+    default:
+      break;
+    }
+  }
+  /* not reached */
+}
+
+static int PTRFASTCALL
+PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr) {
+  int result = 0;
+  /* skip &# */
+  UNUSED_P(enc);
+  ptr += 2 * MINBPC(enc);
+  if (CHAR_MATCHES(enc, ptr, ASCII_x)) {
+    for (ptr += MINBPC(enc); ! CHAR_MATCHES(enc, ptr, ASCII_SEMI);
+         ptr += MINBPC(enc)) {
+      int c = BYTE_TO_ASCII(enc, ptr);
+      switch (c) {
+      case ASCII_0:
+      case ASCII_1:
+      case ASCII_2:
+      case ASCII_3:
+      case ASCII_4:
+      case ASCII_5:
+      case ASCII_6:
+      case ASCII_7:
+      case ASCII_8:
+      case ASCII_9:
+        result <<= 4;
+        result |= (c - ASCII_0);
+        break;
+      case ASCII_A:
+      case ASCII_B:
+      case ASCII_C:
+      case ASCII_D:
+      case ASCII_E:
+      case ASCII_F:
+        result <<= 4;
+        result += 10 + (c - ASCII_A);
+        break;
+      case ASCII_a:
+      case ASCII_b:
+      case ASCII_c:
+      case ASCII_d:
+      case ASCII_e:
+      case ASCII_f:
+        result <<= 4;
+        result += 10 + (c - ASCII_a);
+        break;
+      }
+      if (result >= 0x110000)
+        return -1;
+    }
+  } else {
+    for (; ! CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
+      int c = BYTE_TO_ASCII(enc, ptr);
+      result *= 10;
+      result += (c - ASCII_0);
+      if (result >= 0x110000)
+        return -1;
+    }
+  }
+  return checkCharRefNumber(result);
+}
+
+static int PTRCALL
+PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr,
+                             const char *end) {
+  UNUSED_P(enc);
+  switch ((end - ptr) / MINBPC(enc)) {
+  case 2:
+    if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
+      switch (BYTE_TO_ASCII(enc, ptr)) {
+      case ASCII_l:
+        return ASCII_LT;
+      case ASCII_g:
+        return ASCII_GT;
+      }
+    }
+    break;
+  case 3:
+    if (CHAR_MATCHES(enc, ptr, ASCII_a)) {
+      ptr += MINBPC(enc);
+      if (CHAR_MATCHES(enc, ptr, ASCII_m)) {
+        ptr += MINBPC(enc);
+        if (CHAR_MATCHES(enc, ptr, ASCII_p))
+          return ASCII_AMP;
+      }
+    }
+    break;
+  case 4:
+    switch (BYTE_TO_ASCII(enc, ptr)) {
+    case ASCII_q:
+      ptr += MINBPC(enc);
+      if (CHAR_MATCHES(enc, ptr, ASCII_u)) {
+        ptr += MINBPC(enc);
+        if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
+          ptr += MINBPC(enc);
+          if (CHAR_MATCHES(enc, ptr, ASCII_t))
+            return ASCII_QUOT;
+        }
+      }
+      break;
+    case ASCII_a:
+      ptr += MINBPC(enc);
+      if (CHAR_MATCHES(enc, ptr, ASCII_p)) {
+        ptr += MINBPC(enc);
+        if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
+          ptr += MINBPC(enc);
+          if (CHAR_MATCHES(enc, ptr, ASCII_s))
+            return ASCII_APOS;
+        }
+      }
+      break;
+    }
+  }
+  return 0;
+}
+
+static int PTRCALL
+PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1,
+                         const char *end1, const char *ptr2) {
+  UNUSED_P(enc);
+  for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
+    if (end1 - ptr1 < MINBPC(enc)) {
+      /* This line cannot be executed.  The incoming data has already
+       * been tokenized once, so incomplete characters like this have
+       * already been eliminated from the input.  Retaining the
+       * paranoia check is still valuable, however.
+       */
+      return 0; /* LCOV_EXCL_LINE */
+    }
+    if (! CHAR_MATCHES(enc, ptr1, *ptr2))
+      return 0;
+  }
+  return ptr1 == end1;
+}
+
+static int PTRFASTCALL
+PREFIX(nameLength)(const ENCODING *enc, const char *ptr) {
+  const char *start = ptr;
+  for (;;) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    ptr += n; /* NOTE: The encoding has already been validated. */             \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
+    case BT_NONASCII:
+    case BT_NMSTRT:
+#  ifdef XML_NS
+    case BT_COLON:
+#  endif
+    case BT_HEX:
+    case BT_DIGIT:
+    case BT_NAME:
+    case BT_MINUS:
+      ptr += MINBPC(enc);
+      break;
+    default:
+      return (int)(ptr - start);
+    }
+  }
+}
+
+static const char *PTRFASTCALL
+PREFIX(skipS)(const ENCODING *enc, const char *ptr) {
+  for (;;) {
+    switch (BYTE_TYPE(enc, ptr)) {
+    case BT_LF:
+    case BT_CR:
+    case BT_S:
+      ptr += MINBPC(enc);
+      break;
+    default:
+      return ptr;
+    }
+  }
+}
+
+static void PTRCALL
+PREFIX(updatePosition)(const ENCODING *enc, const char *ptr, const char *end,
+                       POSITION *pos) {
+  while (HAS_CHAR(enc, ptr, end)) {
+    switch (BYTE_TYPE(enc, ptr)) {
+#  define LEAD_CASE(n)                                                         \
+  case BT_LEAD##n:                                                             \
+    ptr += n; /* NOTE: The encoding has already been validated. */             \
+    pos->columnNumber++;                                                       \
+    break;
+      LEAD_CASE(2)
+      LEAD_CASE(3)
+      LEAD_CASE(4)
+#  undef LEAD_CASE
+    case BT_LF:
+      pos->columnNumber = 0;
+      pos->lineNumber++;
+      ptr += MINBPC(enc);
+      break;
+    case BT_CR:
+      pos->lineNumber++;
+      ptr += MINBPC(enc);
+      if (HAS_CHAR(enc, ptr, end) && BYTE_TYPE(enc, ptr) == BT_LF)
+        ptr += MINBPC(enc);
+      pos->columnNumber = 0;
+      break;
+    default:
+      ptr += MINBPC(enc);
+      pos->columnNumber++;
+      break;
+    }
+  }
+}
+
+#  undef DO_LEAD_CASE
+#  undef MULTIBYTE_CASES
+#  undef INVALID_CASES
+#  undef CHECK_NAME_CASE
+#  undef CHECK_NAME_CASES
+#  undef CHECK_NMSTRT_CASE
+#  undef CHECK_NMSTRT_CASES
+
+#endif /* XML_TOK_IMPL_C */
diff --git a/base/poco/XML/src/xmltok_impl.h b/base/poco/XML/src/xmltok_impl.h
new file mode 100644
index 00000000000..c518aada013
--- /dev/null
+++ b/base/poco/XML/src/xmltok_impl.h
@@ -0,0 +1,74 @@
+/*
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2017-2019 Sebastian Pipping <sebastian@pipping.org>
+   Licensed under the MIT license:
+
+   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.
+*/
+
+enum {
+  BT_NONXML,   /* e.g. noncharacter-FFFF */
+  BT_MALFORM,  /* illegal, with regard to encoding */
+  BT_LT,       /* less than = "<" */
+  BT_AMP,      /* ampersand = "&" */
+  BT_RSQB,     /* right square bracket = "[" */
+  BT_LEAD2,    /* lead byte of a 2-byte UTF-8 character */
+  BT_LEAD3,    /* lead byte of a 3-byte UTF-8 character */
+  BT_LEAD4,    /* lead byte of a 4-byte UTF-8 character */
+  BT_TRAIL,    /* trailing unit, e.g. second 16-bit unit of a 4-byte char. */
+  BT_CR,       /* carriage return = "\r" */
+  BT_LF,       /* line feed = "\n" */
+  BT_GT,       /* greater than = ">" */
+  BT_QUOT,     /* quotation character = "\"" */
+  BT_APOS,     /* aposthrophe = "'" */
+  BT_EQUALS,   /* equal sign = "=" */
+  BT_QUEST,    /* question mark = "?" */
+  BT_EXCL,     /* exclamation mark = "!" */
+  BT_SOL,      /* solidus, slash = "/" */
+  BT_SEMI,     /* semicolon = ";" */
+  BT_NUM,      /* number sign = "#" */
+  BT_LSQB,     /* left square bracket = "[" */
+  BT_S,        /* white space, e.g. "\t", " "[, "\r"] */
+  BT_NMSTRT,   /* non-hex name start letter = "G".."Z" + "g".."z" + "_" */
+  BT_COLON,    /* colon = ":" */
+  BT_HEX,      /* hex letter = "A".."F" + "a".."f" */
+  BT_DIGIT,    /* digit = "0".."9" */
+  BT_NAME,     /* dot and middle dot = "." + chr(0xb7) */
+  BT_MINUS,    /* minus = "-" */
+  BT_OTHER,    /* known not to be a name or name start character */
+  BT_NONASCII, /* might be a name or name start character */
+  BT_PERCNT,   /* percent sign = "%" */
+  BT_LPAR,     /* left parenthesis = "(" */
+  BT_RPAR,     /* right parenthesis = "(" */
+  BT_AST,      /* asterisk = "*" */
+  BT_PLUS,     /* plus sign = "+" */
+  BT_COMMA,    /* comma = "," */
+  BT_VERBAR    /* vertical bar = "|" */
+};
+
+#include <stddef.h>
diff --git a/base/poco/XML/src/xmltok_ns.c b/base/poco/XML/src/xmltok_ns.c
new file mode 100644
index 00000000000..5fd83922359
--- /dev/null
+++ b/base/poco/XML/src/xmltok_ns.c
@@ -0,0 +1,122 @@
+/* This file is included!
+                            __  __            _
+                         ___\ \/ /_ __   __ _| |_
+                        / _ \\  /| '_ \ / _` | __|
+                       |  __//  \| |_) | (_| | |_
+                        \___/_/\_\ .__/ \__,_|\__|
+                                 |_| XML parser
+
+   Copyright (c) 1997-2000 Thai Open Source Software Center Ltd
+   Copyright (c) 2000      Clark Cooper <coopercc@users.sourceforge.net>
+   Copyright (c) 2002      Greg Stein <gstein@users.sourceforge.net>
+   Copyright (c) 2002      Fred L. Drake, Jr. <fdrake@users.sourceforge.net>
+   Copyright (c) 2002-2006 Karl Waclawek <karl@waclawek.net>
+   Copyright (c) 2017      Sebastian Pipping <sebastian@pipping.org>
+   Licensed under the MIT license:
+
+   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.
+*/
+
+#ifdef XML_TOK_NS_C
+
+const ENCODING *
+NS(XmlGetUtf8InternalEncoding)(void) {
+  return &ns(internal_utf8_encoding).enc;
+}
+
+const ENCODING *
+NS(XmlGetUtf16InternalEncoding)(void) {
+#  if BYTEORDER == 1234
+  return &ns(internal_little2_encoding).enc;
+#  elif BYTEORDER == 4321
+  return &ns(internal_big2_encoding).enc;
+#  else
+  const short n = 1;
+  return (*(const char *)&n ? &ns(internal_little2_encoding).enc
+                            : &ns(internal_big2_encoding).enc);
+#  endif
+}
+
+static const ENCODING *const NS(encodings)[] = {
+    &ns(latin1_encoding).enc, &ns(ascii_encoding).enc,
+    &ns(utf8_encoding).enc,   &ns(big2_encoding).enc,
+    &ns(big2_encoding).enc,   &ns(little2_encoding).enc,
+    &ns(utf8_encoding).enc /* NO_ENC */
+};
+
+static int PTRCALL
+NS(initScanProlog)(const ENCODING *enc, const char *ptr, const char *end,
+                   const char **nextTokPtr) {
+  return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_PROLOG_STATE,
+                  ptr, end, nextTokPtr);
+}
+
+static int PTRCALL
+NS(initScanContent)(const ENCODING *enc, const char *ptr, const char *end,
+                    const char **nextTokPtr) {
+  return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_CONTENT_STATE,
+                  ptr, end, nextTokPtr);
+}
+
+int
+NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr,
+                    const char *name) {
+  int i = getEncodingIndex(name);
+  if (i == UNKNOWN_ENC)
+    return 0;
+  SET_INIT_ENC_INDEX(p, i);
+  p->initEnc.scanners[XML_PROLOG_STATE] = NS(initScanProlog);
+  p->initEnc.scanners[XML_CONTENT_STATE] = NS(initScanContent);
+  p->initEnc.updatePosition = initUpdatePosition;
+  p->encPtr = encPtr;
+  *encPtr = &(p->initEnc);
+  return 1;
+}
+
+static const ENCODING *
+NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end) {
+#  define ENCODING_MAX 128
+  char buf[ENCODING_MAX];
+  char *p = buf;
+  int i;
+  XmlUtf8Convert(enc, &ptr, end, &p, p + ENCODING_MAX - 1);
+  if (ptr != end)
+    return 0;
+  *p = 0;
+  if (streqci(buf, KW_UTF_16) && enc->minBytesPerChar == 2)
+    return enc;
+  i = getEncodingIndex(buf);
+  if (i == UNKNOWN_ENC)
+    return 0;
+  return NS(encodings)[i];
+}
+
+int
+NS(XmlParseXmlDecl)(int isGeneralTextEntity, const ENCODING *enc,
+                    const char *ptr, const char *end, const char **badPtr,
+                    const char **versionPtr, const char **versionEndPtr,
+                    const char **encodingName, const ENCODING **encoding,
+                    int *standalone) {
+  return doParseXmlDecl(NS(findEncoding), isGeneralTextEntity, enc, ptr, end,
+                        badPtr, versionPtr, versionEndPtr, encodingName,
+                        encoding, standalone);
+}
+
+#endif /* XML_TOK_NS_C */
diff --git a/base/poco/patches/AIX/xlC8.diff b/base/poco/patches/AIX/xlC8.diff
new file mode 100644
index 00000000000..3f6398b7cf2
--- /dev/null
+++ b/base/poco/patches/AIX/xlC8.diff
@@ -0,0 +1,439 @@
+This patch fixes some template declarations for use
+with IBM xlC 8, which apparently has issues with default
+template arguments, as well as namespace lookup.
+
+
+==== //poco/1.3/Foundation/include/Poco/Delegate.h#2 - /ws/poco-1.3/Foundation/include/Poco/Delegate.h ====
+Index: Foundation/include/Poco/Delegate.h
+--- Foundation/include/Poco/Delegate.h.~1~	Fri Mar 20 11:19:53 2009
++++ Foundation/include/Poco/Delegate.h	Fri Mar 20 11:19:53 2009
+@@ -205,7 +205,7 @@
+ template <class TArgs>
+ static Expire<TArgs> delegate(void (*NotifyMethod)(TArgs&), Timestamp::TimeDiff expireMillisecs)
+ {
+-	return Expire<TArgs>(FunctionDelegate<TArgs, false>( NotifyMethod), expireMillisecs);
++	return Expire<TArgs>(FunctionDelegate<TArgs, false, false>( NotifyMethod), expireMillisecs);
+ }
+ 
+ 
+@@ -224,9 +224,9 @@
+ 
+ 
+ template <class TArgs>
+-static FunctionDelegate<TArgs, false> delegate(void (*NotifyMethod)(TArgs&))
++static FunctionDelegate<TArgs, false, false> delegate(void (*NotifyMethod)(TArgs&))
+ {
+-	return FunctionDelegate<TArgs, false>(NotifyMethod);
++	return FunctionDelegate<TArgs, false, false>(NotifyMethod);
+ }
+ 
+ 
+==== //poco/1.3/Foundation/include/Poco/LinearHashTable.h#5 - /ws/poco-1.3/Foundation/include/Poco/LinearHashTable.h ====
+Index: Foundation/include/Poco/LinearHashTable.h
+--- Foundation/include/Poco/LinearHashTable.h.~1~	Fri Mar 20 11:19:53 2009
++++ Foundation/include/Poco/LinearHashTable.h	Fri Mar 20 11:19:53 2009
+@@ -441,10 +441,9 @@
+ 		++_split;
+ 		for (BucketIterator it = tmp.begin(); it != tmp.end(); ++it)
+ 		{
+-			using std::swap;
+ 			std::size_t addr = bucketAddress(*it);
+ 			_buckets[addr].push_back(Value());
+-			swap(*it, _buckets[addr].back());
++			std::swap(*it, _buckets[addr].back());
+ 		}
+ 	}
+ 	
+@@ -461,10 +460,9 @@
+ 		_buckets.pop_back();
+ 		for (BucketIterator it = tmp.begin(); it != tmp.end(); ++it)
+ 		{
+-			using std::swap;
+ 			std::size_t addr = bucketAddress(*it);
+ 			_buckets[addr].push_back(Value());
+-			swap(*it, _buckets[addr].back());
++			std::swap(*it, _buckets[addr].back());
+ 		}
+ 	}
+
+ 	
+==== //poco/1.3/Foundation/include/Poco/NamedTuple.h#3 - /ws/poco-1.3/Foundation/include/Poco/NamedTuple.h ====
+Index: Foundation/include/Poco/NamedTuple.h
+--- Foundation/include/Poco/NamedTuple.h.~1~	Fri Mar 20 11:19:53 2009
++++ Foundation/include/Poco/NamedTuple.h	Fri Mar 20 11:19:53 2009
+@@ -654,7 +654,7 @@
+     class T15,
+     class T16,
+     class T17>
+-struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,NullTypeList>:
++struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,NullTypeList,NullTypeList>:
+ 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>
+ {
+ 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17> TupleType;
+@@ -934,7 +934,7 @@
+     class T14,
+     class T15,
+     class T16>
+-struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,NullTypeList>:
++struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,NullTypeList,NullTypeList,NullTypeList>:
+ 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>
+ {
+ 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16> TupleType;
+@@ -1206,7 +1206,7 @@
+     class T13,
+     class T14,
+     class T15>
+-struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,NullTypeList>:
++struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,NullTypeList,NullTypeList,NullTypeList,NullTypeList>:
+ 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>
+ {
+ 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15> TupleType;
+@@ -1471,7 +1471,7 @@
+     class T12,
+     class T13,
+     class T14>
+-struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,NullTypeList>:
++struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>:
+ 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>
+ {
+ 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14> TupleType;
+@@ -1728,7 +1728,7 @@
+     class T11,
+     class T12,
+     class T13>
+-struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,NullTypeList>:
++struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>:
+ 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>
+ {
+ 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13> TupleType;
+@@ -1977,7 +1977,7 @@
+     class T10,
+     class T11,
+     class T12>
+-struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,NullTypeList>:
++struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>:
+ 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>
+ {
+ 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12> TupleType;
+@@ -2217,7 +2217,7 @@
+     class T9,
+     class T10,
+     class T11>
+-struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,NullTypeList>:
++struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>:
+ 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>
+ {
+ 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11> TupleType;
+@@ -2450,7 +2450,7 @@
+     class T8,
+     class T9,
+     class T10>
+-struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,NullTypeList>:
++struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>:
+ 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>
+ {
+ 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10> TupleType;
+@@ -2674,7 +2674,7 @@
+     class T7, 
+     class T8,
+     class T9>
+-struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,NullTypeList>:
++struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>:
+ 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>
+ {
+ 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9> TupleType;
+@@ -2891,7 +2891,7 @@
+     class T6,
+     class T7, 
+     class T8>
+-struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,NullTypeList>:
++struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>:
+ 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8>
+ {
+ 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8> TupleType;
+@@ -3100,7 +3100,7 @@
+     class T5,
+     class T6,
+     class T7>
+-struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,NullTypeList>:
++struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,T7,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>:
+ 	public Tuple<T0,T1,T2,T3,T4,T5,T6,T7>
+ {
+ 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6,T7> TupleType;
+@@ -3301,7 +3301,7 @@
+     class T4,
+     class T5,
+     class T6>
+-struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,NullTypeList>:
++struct NamedTuple<T0,T1,T2,T3,T4,T5,T6,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>:
+ 	public Tuple<T0,T1,T2,T3,T4,T5,T6>
+ {
+ 	typedef Tuple<T0,T1,T2,T3,T4,T5,T6> TupleType;
+@@ -3492,7 +3492,7 @@
+     class T3,
+     class T4,
+     class T5>
+-struct NamedTuple<T0,T1,T2,T3,T4,T5,NullTypeList>:
++struct NamedTuple<T0,T1,T2,T3,T4,T5,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>:
+ 	public Tuple<T0,T1,T2,T3,T4,T5>
+ {
+ 	typedef Tuple<T0,T1,T2,T3,T4,T5> TupleType;
+@@ -3675,7 +3675,7 @@
+     class T2,
+     class T3,
+     class T4>
+-struct NamedTuple<T0,T1,T2,T3,T4,NullTypeList>:
++struct NamedTuple<T0,T1,T2,T3,T4,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>:
+ 	public Tuple<T0,T1,T2,T3,T4>
+ {
+ 	typedef Tuple<T0,T1,T2,T3,T4> TupleType;
+@@ -3852,7 +3852,7 @@
+     class T1,
+     class T2,
+     class T3>
+-struct NamedTuple<T0,T1,T2,T3,NullTypeList>:
++struct NamedTuple<T0,T1,T2,T3,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>:
+ 	public Tuple<T0,T1,T2,T3>
+ {
+ 	typedef Tuple<T0,T1,T2,T3> TupleType;
+@@ -4020,7 +4020,7 @@
+ template<class T0, 
+     class T1,
+     class T2>
+-struct NamedTuple<T0,T1,T2,NullTypeList>:
++struct NamedTuple<T0,T1,T2,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>:
+ 	public Tuple<T0,T1,T2>
+ {
+ 	typedef Tuple<T0,T1,T2> TupleType;
+@@ -4181,7 +4181,7 @@
+ 
+ template<class T0, 
+     class T1>
+-struct NamedTuple<T0,T1,NullTypeList>:
++struct NamedTuple<T0,T1,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>:
+ 	public Tuple<T0,T1>
+ {
+ 	typedef Tuple<T0,T1> TupleType;
+@@ -4334,7 +4334,7 @@
+ 
+ 
+ template<class T0>
+-struct NamedTuple<T0,NullTypeList>:
++struct NamedTuple<T0,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>:
+ 	public Tuple<T0>
+ {
+ 	typedef Tuple<T0> TupleType;
+
+
+==== //poco/1.3/Foundation/include/Poco/PriorityDelegate.h#2 - /ws/poco-1.3/Foundation/include/Poco/PriorityDelegate.h ====
+Index: Foundation/include/Poco/PriorityDelegate.h
+--- Foundation/include/Poco/PriorityDelegate.h.~1~	Fri Mar 20 11:19:53 2009
++++ Foundation/include/Poco/PriorityDelegate.h	Fri Mar 20 11:19:53 2009
+@@ -207,7 +207,7 @@
+ template <class TArgs>
+ static PriorityExpire<TArgs> priorityDelegate(void (*NotifyMethod)(TArgs&), int prio, Timestamp::TimeDiff expireMilliSec)
+ {
+-	return PriorityExpire<TArgs>(FunctionPriorityDelegate<TArgs, false>(NotifyMethod, prio), expireMilliSec);
++	return PriorityExpire<TArgs>(FunctionPriorityDelegate<TArgs, false, true>(NotifyMethod, prio), expireMilliSec);
+ }
+ 
+ 
+@@ -226,9 +226,9 @@
+ 
+ 
+ template <class TArgs>
+-static FunctionPriorityDelegate<TArgs, false> priorityDelegate(void (*NotifyMethod)(TArgs&), int prio)
++static FunctionPriorityDelegate<TArgs, false, true> priorityDelegate(void (*NotifyMethod)(TArgs&), int prio)
+ {
+-	return FunctionPriorityDelegate<TArgs, false>(NotifyMethod, prio);
++	return FunctionPriorityDelegate<TArgs, false, true>(NotifyMethod, prio);
+ }
+ 
+ 
+==== //poco/1.3/Foundation/include/Poco/Tuple.h#7 - /ws/poco-1.3/Foundation/include/Poco/Tuple.h ====
+Index: Foundation/include/Poco/Tuple.h
+--- Foundation/include/Poco/Tuple.h.~1~	Fri Mar 20 11:19:53 2009
++++ Foundation/include/Poco/Tuple.h	Fri Mar 20 11:19:53 2009
+@@ -297,7 +297,7 @@
+ 	class T15,
+ 	class T16,
+ 	class T17>
+-struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,NullTypeList>
++struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17,NullTypeList,NullTypeList>
+ {
+ 	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,T17>::HeadType Type;
+ 
+@@ -404,7 +404,7 @@
+ 	class T14,
+ 	class T15,
+ 	class T16>
+-struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,NullTypeList>
++struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,NullTypeList,NullTypeList,NullTypeList>
+ {
+ 	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>::HeadType Type;
+ 
+@@ -508,7 +508,7 @@
+ 	class T13,
+ 	class T14,
+ 	class T15>
+-struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,NullTypeList>
++struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,NullTypeList,NullTypeList,NullTypeList,NullTypeList>
+ {
+ 	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15>::HeadType Type;
+ 
+@@ -609,7 +609,7 @@
+ 	class T12,
+ 	class T13,
+ 	class T14>
+-struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,NullTypeList>
++struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>
+ {
+ 	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14>::HeadType Type;
+ 
+@@ -707,7 +707,7 @@
+ 	class T11,
+ 	class T12,
+ 	class T13>
+-struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,NullTypeList>
++struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>
+ {
+ 	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13>::HeadType Type;
+ 
+@@ -802,7 +802,7 @@
+ 	class T10,
+ 	class T11,
+ 	class T12>
+-struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12, NullTypeList>
++struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>
+ {
+ 	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12>::HeadType Type;
+ 
+@@ -894,7 +894,7 @@
+ 	class T9,
+ 	class T10,
+ 	class T11>
+-struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,NullTypeList>
++struct Tuple<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>
+ {
+ 	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11>::HeadType Type;
+ 
+@@ -983,7 +983,7 @@
+ 	class T8,
+ 	class T9,
+ 	class T10>
+-struct Tuple<T0, T1,T2,T3,T4,T5,T6,T7,T8,T9,T10, NullTypeList>
++struct Tuple<T0, T1,T2,T3,T4,T5,T6,T7,T8,T9,T10, NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>
+ {
+ 	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>::HeadType Type;
+ 
+@@ -1069,7 +1069,7 @@
+ 	class T7,
+ 	class T8,
+ 	class T9>
+-struct Tuple<T0, T1,T2,T3,T4,T5,T6,T7,T8,T9, NullTypeList>
++struct Tuple<T0, T1,T2,T3,T4,T5,T6,T7,T8,T9, NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>
+ {
+ 	typedef typename TypeListType<T0, T1,T2,T3,T4,T5,T6,T7,T8,T9>::HeadType Type;
+ 
+@@ -1152,7 +1152,7 @@
+ 	class T6,
+ 	class T7,
+ 	class T8>
+-struct Tuple<T0, T1,T2,T3,T4,T5,T6,T7,T8, NullTypeList>
++struct Tuple<T0, T1,T2,T3,T4,T5,T6,T7,T8, NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>
+ {
+ 	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7,T8>::HeadType Type;
+ 
+@@ -1232,7 +1232,7 @@
+ 	class T5,
+ 	class T6,
+ 	class T7>
+-struct Tuple<T0, T1,T2,T3,T4,T5,T6,T7, NullTypeList>
++struct Tuple<T0, T1,T2,T3,T4,T5,T6,T7, NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>
+ {
+ 	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6,T7>::HeadType Type;
+ 
+@@ -1309,7 +1309,7 @@
+ 	class T4,
+ 	class T5,
+ 	class T6>
+-struct Tuple<T0, T1,T2,T3,T4,T5,T6, NullTypeList>
++struct Tuple<T0, T1,T2,T3,T4,T5,T6, NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>
+ {
+ 	typedef typename TypeListType<T0,T1,T2,T3,T4,T5,T6>::HeadType Type;
+ 
+@@ -1383,7 +1383,7 @@
+ 	class T3,
+ 	class T4,
+ 	class T5>
+-struct Tuple<T0, T1,T2,T3,T4,T5, NullTypeList>
++struct Tuple<T0, T1,T2,T3,T4,T5, NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>
+ {
+ 	typedef typename TypeListType<T0,T1,T2,T3,T4,T5>::HeadType Type;
+ 
+@@ -1454,7 +1454,7 @@
+ 	class T2,
+ 	class T3,
+ 	class T4>
+-struct Tuple<T0, T1,T2,T3,T4, NullTypeList>
++struct Tuple<T0, T1,T2,T3,T4, NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>
+ {
+ 	typedef typename TypeListType<T0,T1,T2,T3,T4>::HeadType Type;
+ 
+@@ -1522,7 +1522,7 @@
+ 	class T1,
+ 	class T2,
+ 	class T3>
+-struct Tuple<T0, T1,T2,T3, NullTypeList>
++struct Tuple<T0, T1,T2,T3, NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>
+ {
+ 	typedef typename TypeListType<T0,T1,T2,T3>::HeadType Type;
+ 
+@@ -1587,7 +1587,7 @@
+ template <class T0,
+ 	class T1,
+ 	class T2>
+-struct Tuple<T0, T1,T2, NullTypeList>
++struct Tuple<T0, T1,T2, NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>
+ {
+ 	typedef typename TypeListType<T0,T1,T2>::HeadType Type;
+ 
+@@ -1649,7 +1649,7 @@
+ 
+ template <class T0,
+ 	class T1>
+-struct Tuple<T0, T1, NullTypeList>
++struct Tuple<T0, T1, NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>
+ {
+ 	typedef typename TypeListType<T0,T1>::HeadType Type;
+ 
+@@ -1707,7 +1707,7 @@
+ 
+ 
+ template <class T0>
+-struct Tuple<T0, NullTypeList>
++struct Tuple<T0, NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList,NullTypeList>
+ {
+ 	typedef TypeList<T0, NullTypeList> Type;
+
+ 	
+==== //poco/1.3/Foundation/src/pcre_internal.h#2 - /ws/poco-1.3/Foundation/src/pcre_internal.h ====
+Index: Foundation/src/pcre_internal.h
+--- Foundation/src/pcre_internal.h.~1~	Fri Mar 20 11:19:53 2009
++++ Foundation/src/pcre_internal.h	Fri Mar 20 11:19:53 2009
+@@ -562,10 +562,14 @@
+ /* Miscellaneous definitions. The #ifndef is to pacify compiler warnings in
+ environments where these macros are defined elsewhere. */
+ 
+-#ifndef FALSE
++#ifndef BOOL
+ typedef int BOOL;
++#endif
+ 
++#ifndef FALSE
+ #define FALSE   0
++#endif
++#ifndef TRUE
+ #define TRUE    1
+ #endif
+End of Patch.
diff --git a/base/readpassphrase/CMakeLists.txt b/base/readpassphrase/CMakeLists.txt
index 51b12106eca..ab3b97a1b39 100644
--- a/base/readpassphrase/CMakeLists.txt
+++ b/base/readpassphrase/CMakeLists.txt
@@ -1,3 +1,7 @@
+if (USE_CLANG_TIDY)
+    set (CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_PATH}")
+endif ()
+
 # wget https://raw.githubusercontent.com/openssh/openssh-portable/master/openbsd-compat/readpassphrase.c
 # wget https://raw.githubusercontent.com/openssh/openssh-portable/master/openbsd-compat/readpassphrase.h
 
diff --git a/base/widechar_width/CMakeLists.txt b/base/widechar_width/CMakeLists.txt
index 724498ac9c7..66678c1be97 100644
--- a/base/widechar_width/CMakeLists.txt
+++ b/base/widechar_width/CMakeLists.txt
@@ -1,2 +1,6 @@
+if (USE_CLANG_TIDY)
+    set (CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_PATH}")
+endif ()
+
 add_library(widechar_width widechar_width.cpp)
 target_include_directories(widechar_width PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
diff --git a/contrib/CMakeLists.txt b/contrib/CMakeLists.txt
index 5fc8d960f56..cb2e62fd027 100644
--- a/contrib/CMakeLists.txt
+++ b/contrib/CMakeLists.txt
@@ -79,7 +79,6 @@ add_contrib (re2-cmake re2)
 add_contrib (xz-cmake xz)
 add_contrib (brotli-cmake brotli)
 add_contrib (double-conversion-cmake double-conversion)
-add_contrib (poco-cmake poco)
 add_contrib (croaring-cmake croaring)
 add_contrib (zstd-cmake zstd)
 add_contrib (zlib-ng-cmake zlib-ng)
diff --git a/contrib/poco b/contrib/poco
deleted file mode 160000
index 7fefdf30244..00000000000
--- a/contrib/poco
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 7fefdf30244a9bf8eb58562a9b2a51cc59a8877a
diff --git a/contrib/poco-cmake/Crypto/CMakeLists.txt b/contrib/poco-cmake/Crypto/CMakeLists.txt
deleted file mode 100644
index 9886a05b21b..00000000000
--- a/contrib/poco-cmake/Crypto/CMakeLists.txt
+++ /dev/null
@@ -1,40 +0,0 @@
-if (ENABLE_SSL)
-    set (SRCS
-        "${LIBRARY_DIR}/Crypto/src/Cipher.cpp"
-        "${LIBRARY_DIR}/Crypto/src/CipherFactory.cpp"
-        "${LIBRARY_DIR}/Crypto/src/CipherImpl.cpp"
-        "${LIBRARY_DIR}/Crypto/src/CipherKey.cpp"
-        "${LIBRARY_DIR}/Crypto/src/CipherKeyImpl.cpp"
-        "${LIBRARY_DIR}/Crypto/src/CryptoException.cpp"
-        "${LIBRARY_DIR}/Crypto/src/CryptoStream.cpp"
-        "${LIBRARY_DIR}/Crypto/src/CryptoTransform.cpp"
-        "${LIBRARY_DIR}/Crypto/src/DigestEngine.cpp"
-        "${LIBRARY_DIR}/Crypto/src/ECDSADigestEngine.cpp"
-        "${LIBRARY_DIR}/Crypto/src/ECKey.cpp"
-        "${LIBRARY_DIR}/Crypto/src/ECKeyImpl.cpp"
-        "${LIBRARY_DIR}/Crypto/src/EVPPKey.cpp"
-        "${LIBRARY_DIR}/Crypto/src/KeyPair.cpp"
-        "${LIBRARY_DIR}/Crypto/src/KeyPairImpl.cpp"
-        "${LIBRARY_DIR}/Crypto/src/OpenSSLInitializer.cpp"
-        "${LIBRARY_DIR}/Crypto/src/PKCS12Container.cpp"
-        "${LIBRARY_DIR}/Crypto/src/RSACipherImpl.cpp"
-        "${LIBRARY_DIR}/Crypto/src/RSADigestEngine.cpp"
-        "${LIBRARY_DIR}/Crypto/src/RSAKey.cpp"
-        "${LIBRARY_DIR}/Crypto/src/RSAKeyImpl.cpp"
-        "${LIBRARY_DIR}/Crypto/src/X509Certificate.cpp"
-    )
-
-    add_library (_poco_crypto ${SRCS})
-    add_library (Poco::Crypto ALIAS _poco_crypto)
-
-    target_compile_options (_poco_crypto PRIVATE -Wno-newline-eof)
-    target_include_directories (_poco_crypto SYSTEM PUBLIC "${LIBRARY_DIR}/Crypto/include")
-    target_link_libraries (_poco_crypto PUBLIC Poco::Foundation OpenSSL::SSL OpenSSL::Crypto)
-
-    message (STATUS "Using Poco::Crypto")
-else ()
-    add_library (_poco_crypto INTERFACE)
-    add_library (Poco::Crypto ALIAS _poco_crypto)
-
-    message (STATUS "Not using Poco::Crypto")
-endif ()
diff --git a/contrib/poco-cmake/Data/CMakeLists.txt b/contrib/poco-cmake/Data/CMakeLists.txt
deleted file mode 100644
index b13c07583ad..00000000000
--- a/contrib/poco-cmake/Data/CMakeLists.txt
+++ /dev/null
@@ -1,46 +0,0 @@
-set (SRCS
-    "${LIBRARY_DIR}/Data/src/AbstractBinder.cpp"
-    "${LIBRARY_DIR}/Data/src/AbstractBinding.cpp"
-    "${LIBRARY_DIR}/Data/src/AbstractExtraction.cpp"
-    "${LIBRARY_DIR}/Data/src/AbstractExtractor.cpp"
-    "${LIBRARY_DIR}/Data/src/AbstractPreparation.cpp"
-    "${LIBRARY_DIR}/Data/src/AbstractPreparator.cpp"
-    "${LIBRARY_DIR}/Data/src/ArchiveStrategy.cpp"
-    "${LIBRARY_DIR}/Data/src/Bulk.cpp"
-    "${LIBRARY_DIR}/Data/src/Connector.cpp"
-    "${LIBRARY_DIR}/Data/src/DataException.cpp"
-    "${LIBRARY_DIR}/Data/src/Date.cpp"
-    "${LIBRARY_DIR}/Data/src/DynamicLOB.cpp"
-    "${LIBRARY_DIR}/Data/src/Limit.cpp"
-    "${LIBRARY_DIR}/Data/src/MetaColumn.cpp"
-    "${LIBRARY_DIR}/Data/src/PooledSessionHolder.cpp"
-    "${LIBRARY_DIR}/Data/src/PooledSessionImpl.cpp"
-    "${LIBRARY_DIR}/Data/src/Position.cpp"
-    "${LIBRARY_DIR}/Data/src/Range.cpp"
-    "${LIBRARY_DIR}/Data/src/RecordSet.cpp"
-    "${LIBRARY_DIR}/Data/src/Row.cpp"
-    "${LIBRARY_DIR}/Data/src/RowFilter.cpp"
-    "${LIBRARY_DIR}/Data/src/RowFormatter.cpp"
-    "${LIBRARY_DIR}/Data/src/RowIterator.cpp"
-    "${LIBRARY_DIR}/Data/src/Session.cpp"
-    "${LIBRARY_DIR}/Data/src/SessionFactory.cpp"
-    "${LIBRARY_DIR}/Data/src/SessionImpl.cpp"
-    "${LIBRARY_DIR}/Data/src/SessionPool.cpp"
-    "${LIBRARY_DIR}/Data/src/SessionPoolContainer.cpp"
-    "${LIBRARY_DIR}/Data/src/SimpleRowFormatter.cpp"
-    "${LIBRARY_DIR}/Data/src/SQLChannel.cpp"
-    "${LIBRARY_DIR}/Data/src/Statement.cpp"
-    "${LIBRARY_DIR}/Data/src/StatementCreator.cpp"
-    "${LIBRARY_DIR}/Data/src/StatementImpl.cpp"
-    "${LIBRARY_DIR}/Data/src/Time.cpp"
-    "${LIBRARY_DIR}/Data/src/Transaction.cpp"
-)
-
-add_library (_poco_data ${SRCS})
-add_library (Poco::Data ALIAS _poco_data)
-
-if (COMPILER_GCC)
-    target_compile_options (_poco_data PRIVATE -Wno-deprecated-copy)
-endif ()
-target_include_directories (_poco_data SYSTEM PUBLIC "${LIBRARY_DIR}/Data/include")
-target_link_libraries (_poco_data PUBLIC Poco::Foundation)
diff --git a/contrib/poco-cmake/Data/ODBC/CMakeLists.txt b/contrib/poco-cmake/Data/ODBC/CMakeLists.txt
deleted file mode 100644
index 7de77cdacf7..00000000000
--- a/contrib/poco-cmake/Data/ODBC/CMakeLists.txt
+++ /dev/null
@@ -1,39 +0,0 @@
-if (ENABLE_ODBC)
-    if (NOT TARGET ch_contrib::unixodbc)
-        message(FATAL_ERROR "Configuration error: unixodbc is not a target")
-    endif()
-
-    set (SRCS
-        "${LIBRARY_DIR}/Data/ODBC/src/Binder.cpp"
-        "${LIBRARY_DIR}/Data/ODBC/src/ConnectionHandle.cpp"
-        "${LIBRARY_DIR}/Data/ODBC/src/Connector.cpp"
-        "${LIBRARY_DIR}/Data/ODBC/src/EnvironmentHandle.cpp"
-        "${LIBRARY_DIR}/Data/ODBC/src/Extractor.cpp"
-        "${LIBRARY_DIR}/Data/ODBC/src/ODBCException.cpp"
-        "${LIBRARY_DIR}/Data/ODBC/src/ODBCMetaColumn.cpp"
-        "${LIBRARY_DIR}/Data/ODBC/src/ODBCStatementImpl.cpp"
-        "${LIBRARY_DIR}/Data/ODBC/src/Parameter.cpp"
-        "${LIBRARY_DIR}/Data/ODBC/src/Preparator.cpp"
-        "${LIBRARY_DIR}/Data/ODBC/src/SessionImpl.cpp"
-        "${LIBRARY_DIR}/Data/ODBC/src/TypeInfo.cpp"
-        "${LIBRARY_DIR}/Data/ODBC/src/Unicode.cpp"
-        "${LIBRARY_DIR}/Data/ODBC/src/Utility.cpp"
-    )
-
-    add_library (_poco_data_odbc ${SRCS})
-    add_library (Poco::Data::ODBC ALIAS _poco_data_odbc)
-
-    target_compile_options (_poco_data_odbc PRIVATE -Wno-unused-variable)
-    target_include_directories (_poco_data_odbc SYSTEM PUBLIC "${LIBRARY_DIR}/Data/ODBC/include")
-    target_link_libraries (_poco_data_odbc PUBLIC Poco::Data ch_contrib::unixodbc)
-
-    message (STATUS "Using Poco::Data::ODBC")
-else ()
-    add_library (_poco_data_odbc INTERFACE)
-    add_library (Poco::Data::ODBC ALIAS _poco_data_odbc)
-    if (TARGET ch_contrib::unixodbc)
-        target_link_libraries (_poco_data_odbc INTERFACE ch_contrib::unixodbc)
-    endif()
-
-    message (STATUS "Not using Poco::Data::ODBC")
-endif ()
diff --git a/contrib/poco-cmake/Foundation/CMakeLists.txt b/contrib/poco-cmake/Foundation/CMakeLists.txt
deleted file mode 100644
index 795ec985cb4..00000000000
--- a/contrib/poco-cmake/Foundation/CMakeLists.txt
+++ /dev/null
@@ -1,236 +0,0 @@
-# Foundation (pcre)
-
-set (SRCS_PCRE
-    "${LIBRARY_DIR}/Foundation/src/pcre_config.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_byte_order.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_chartables.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_compile.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_exec.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_fullinfo.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_globals.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_maketables.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_newline.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_ord2utf8.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_study.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_tables.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_dfa_exec.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_get.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_jit_compile.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_refcount.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_string_utils.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_version.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_ucd.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_valid_utf8.c"
-    "${LIBRARY_DIR}/Foundation/src/pcre_xclass.c"
-)
-
-add_library (_poco_foundation_pcre ${SRCS_PCRE})
-add_library (Poco::Foundation::PCRE ALIAS _poco_foundation_pcre)
-
-target_compile_options (_poco_foundation_pcre PRIVATE -Wno-sign-compare)
-
-# Foundation
-
-set (SRCS
-    "${LIBRARY_DIR}/Foundation/src/AbstractObserver.cpp"
-    "${LIBRARY_DIR}/Foundation/src/ActiveDispatcher.cpp"
-    "${LIBRARY_DIR}/Foundation/src/ArchiveStrategy.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Ascii.cpp"
-    "${LIBRARY_DIR}/Foundation/src/ASCIIEncoding.cpp"
-    "${LIBRARY_DIR}/Foundation/src/AsyncChannel.cpp"
-    "${LIBRARY_DIR}/Foundation/src/AtomicCounter.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Base32Decoder.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Base32Encoder.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Base64Decoder.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Base64Encoder.cpp"
-    "${LIBRARY_DIR}/Foundation/src/BinaryReader.cpp"
-    "${LIBRARY_DIR}/Foundation/src/BinaryWriter.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Bugcheck.cpp"
-    "${LIBRARY_DIR}/Foundation/src/ByteOrder.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Channel.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Checksum.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Clock.cpp"
-    "${LIBRARY_DIR}/Foundation/src/CompressedLogFile.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Condition.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Configurable.cpp"
-    "${LIBRARY_DIR}/Foundation/src/ConsoleChannel.cpp"
-    "${LIBRARY_DIR}/Foundation/src/CountingStream.cpp"
-    "${LIBRARY_DIR}/Foundation/src/DateTime.cpp"
-    "${LIBRARY_DIR}/Foundation/src/DateTimeFormat.cpp"
-    "${LIBRARY_DIR}/Foundation/src/DateTimeFormatter.cpp"
-    "${LIBRARY_DIR}/Foundation/src/DateTimeParser.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Debugger.cpp"
-    "${LIBRARY_DIR}/Foundation/src/DeflatingStream.cpp"
-    "${LIBRARY_DIR}/Foundation/src/DigestEngine.cpp"
-    "${LIBRARY_DIR}/Foundation/src/DigestStream.cpp"
-    "${LIBRARY_DIR}/Foundation/src/DirectoryIterator.cpp"
-    "${LIBRARY_DIR}/Foundation/src/DirectoryIteratorStrategy.cpp"
-    "${LIBRARY_DIR}/Foundation/src/DirectoryWatcher.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Environment.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Error.cpp"
-    "${LIBRARY_DIR}/Foundation/src/ErrorHandler.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Event.cpp"
-    "${LIBRARY_DIR}/Foundation/src/EventArgs.cpp"
-    "${LIBRARY_DIR}/Foundation/src/EventChannel.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Exception.cpp"
-    "${LIBRARY_DIR}/Foundation/src/FIFOBufferStream.cpp"
-    "${LIBRARY_DIR}/Foundation/src/File.cpp"
-    "${LIBRARY_DIR}/Foundation/src/FileChannel.cpp"
-    "${LIBRARY_DIR}/Foundation/src/FileStream.cpp"
-    "${LIBRARY_DIR}/Foundation/src/FileStreamFactory.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Format.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Formatter.cpp"
-    "${LIBRARY_DIR}/Foundation/src/FormattingChannel.cpp"
-    "${LIBRARY_DIR}/Foundation/src/FPEnvironment.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Glob.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Hash.cpp"
-    "${LIBRARY_DIR}/Foundation/src/HashStatistic.cpp"
-    "${LIBRARY_DIR}/Foundation/src/HexBinaryDecoder.cpp"
-    "${LIBRARY_DIR}/Foundation/src/HexBinaryEncoder.cpp"
-    "${LIBRARY_DIR}/Foundation/src/InflatingStream.cpp"
-    "${LIBRARY_DIR}/Foundation/src/JSONString.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Latin1Encoding.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Latin2Encoding.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Latin9Encoding.cpp"
-    "${LIBRARY_DIR}/Foundation/src/LineEndingConverter.cpp"
-    "${LIBRARY_DIR}/Foundation/src/LocalDateTime.cpp"
-    "${LIBRARY_DIR}/Foundation/src/LogFile.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Logger.cpp"
-    "${LIBRARY_DIR}/Foundation/src/LoggingFactory.cpp"
-    "${LIBRARY_DIR}/Foundation/src/LoggingRegistry.cpp"
-    "${LIBRARY_DIR}/Foundation/src/LogStream.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Manifest.cpp"
-    "${LIBRARY_DIR}/Foundation/src/MD4Engine.cpp"
-    "${LIBRARY_DIR}/Foundation/src/MD5Engine.cpp"
-    "${LIBRARY_DIR}/Foundation/src/MemoryPool.cpp"
-    "${LIBRARY_DIR}/Foundation/src/MemoryStream.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Message.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Mutex.cpp"
-    "${LIBRARY_DIR}/Foundation/src/NamedEvent.cpp"
-    "${LIBRARY_DIR}/Foundation/src/NamedMutex.cpp"
-    "${LIBRARY_DIR}/Foundation/src/NestedDiagnosticContext.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Notification.cpp"
-    "${LIBRARY_DIR}/Foundation/src/NotificationCenter.cpp"
-    "${LIBRARY_DIR}/Foundation/src/NotificationQueue.cpp"
-    "${LIBRARY_DIR}/Foundation/src/NullChannel.cpp"
-    "${LIBRARY_DIR}/Foundation/src/NullStream.cpp"
-    "${LIBRARY_DIR}/Foundation/src/NumberFormatter.cpp"
-    "${LIBRARY_DIR}/Foundation/src/NumberParser.cpp"
-    "${LIBRARY_DIR}/Foundation/src/NumericString.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Path.cpp"
-    "${LIBRARY_DIR}/Foundation/src/PatternFormatter.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Pipe.cpp"
-    "${LIBRARY_DIR}/Foundation/src/PipeImpl.cpp"
-    "${LIBRARY_DIR}/Foundation/src/PipeStream.cpp"
-    "${LIBRARY_DIR}/Foundation/src/PriorityNotificationQueue.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Process.cpp"
-    "${LIBRARY_DIR}/Foundation/src/PurgeStrategy.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Random.cpp"
-    "${LIBRARY_DIR}/Foundation/src/RandomStream.cpp"
-    "${LIBRARY_DIR}/Foundation/src/RefCountedObject.cpp"
-    "${LIBRARY_DIR}/Foundation/src/RegularExpression.cpp"
-    "${LIBRARY_DIR}/Foundation/src/RotateStrategy.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Runnable.cpp"
-    "${LIBRARY_DIR}/Foundation/src/RWLock.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Semaphore.cpp"
-    "${LIBRARY_DIR}/Foundation/src/SHA1Engine.cpp"
-    "${LIBRARY_DIR}/Foundation/src/SharedLibrary.cpp"
-    "${LIBRARY_DIR}/Foundation/src/SharedMemory.cpp"
-    "${LIBRARY_DIR}/Foundation/src/SignalHandler.cpp"
-    "${LIBRARY_DIR}/Foundation/src/SimpleFileChannel.cpp"
-    "${LIBRARY_DIR}/Foundation/src/SortedDirectoryIterator.cpp"
-    "${LIBRARY_DIR}/Foundation/src/SplitterChannel.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Stopwatch.cpp"
-    "${LIBRARY_DIR}/Foundation/src/StreamChannel.cpp"
-    "${LIBRARY_DIR}/Foundation/src/StreamConverter.cpp"
-    "${LIBRARY_DIR}/Foundation/src/StreamCopier.cpp"
-    "${LIBRARY_DIR}/Foundation/src/StreamTokenizer.cpp"
-    "${LIBRARY_DIR}/Foundation/src/String.cpp"
-    "${LIBRARY_DIR}/Foundation/src/StringTokenizer.cpp"
-    "${LIBRARY_DIR}/Foundation/src/SynchronizedObject.cpp"
-    "${LIBRARY_DIR}/Foundation/src/SyslogChannel.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Task.cpp"
-    "${LIBRARY_DIR}/Foundation/src/TaskManager.cpp"
-    "${LIBRARY_DIR}/Foundation/src/TaskNotification.cpp"
-    "${LIBRARY_DIR}/Foundation/src/TeeStream.cpp"
-    "${LIBRARY_DIR}/Foundation/src/TemporaryFile.cpp"
-    "${LIBRARY_DIR}/Foundation/src/TextBufferIterator.cpp"
-    "${LIBRARY_DIR}/Foundation/src/TextConverter.cpp"
-    "${LIBRARY_DIR}/Foundation/src/TextEncoding.cpp"
-    "${LIBRARY_DIR}/Foundation/src/TextIterator.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Thread.cpp"
-    "${LIBRARY_DIR}/Foundation/src/ThreadLocal.cpp"
-    "${LIBRARY_DIR}/Foundation/src/ThreadPool.cpp"
-    "${LIBRARY_DIR}/Foundation/src/ThreadTarget.cpp"
-    "${LIBRARY_DIR}/Foundation/src/TimedNotificationQueue.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Timer.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Timespan.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Timestamp.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Timezone.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Token.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Unicode.cpp"
-    "${LIBRARY_DIR}/Foundation/src/UnicodeConverter.cpp"
-    "${LIBRARY_DIR}/Foundation/src/URI.cpp"
-    "${LIBRARY_DIR}/Foundation/src/URIStreamFactory.cpp"
-    "${LIBRARY_DIR}/Foundation/src/URIStreamOpener.cpp"
-    "${LIBRARY_DIR}/Foundation/src/UTF16Encoding.cpp"
-    "${LIBRARY_DIR}/Foundation/src/UTF32Encoding.cpp"
-    "${LIBRARY_DIR}/Foundation/src/UTF8Encoding.cpp"
-    "${LIBRARY_DIR}/Foundation/src/UTF8String.cpp"
-    "${LIBRARY_DIR}/Foundation/src/UUID.cpp"
-    "${LIBRARY_DIR}/Foundation/src/UUIDGenerator.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Var.cpp"
-    "${LIBRARY_DIR}/Foundation/src/VarHolder.cpp"
-    "${LIBRARY_DIR}/Foundation/src/VarIterator.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Void.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Windows1250Encoding.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Windows1251Encoding.cpp"
-    "${LIBRARY_DIR}/Foundation/src/Windows1252Encoding.cpp"
-)
-
-add_library (_poco_foundation ${SRCS})
-add_library (Poco::Foundation ALIAS _poco_foundation)
-
-if (COMPILER_GCC)
-    target_compile_options (_poco_foundation
-        PRIVATE
-            -Wno-suggest-override
-    )
-elseif (COMPILER_CLANG)
-    target_compile_options (_poco_foundation
-        PRIVATE
-            -Wno-atomic-implicit-seq-cst
-            -Wno-deprecated
-            -Wno-extra-semi-stmt
-            -Wno-zero-as-null-pointer-constant
-            -Wno-implicit-int-float-conversion
-            -Wno-thread-safety-analysis
-            -Wno-thread-safety-negative
-    )
-endif ()
-target_compile_options (_poco_foundation
-    PRIVATE
-        -Wno-sign-compare
-        -Wno-unused-parameter
-)
-target_compile_definitions (_poco_foundation
-    PRIVATE
-        POCO_UNBUNDLED
-        POCO_UNBUNDLED_ZLIB
-    PUBLIC
-        POCO_ENABLE_CPP11
-        POCO_OS_FAMILY_UNIX
-)
-target_include_directories (_poco_foundation SYSTEM PUBLIC "${LIBRARY_DIR}/Foundation/include")
-target_link_libraries (_poco_foundation
-    PRIVATE
-        Poco::Foundation::PCRE
-        ch_contrib::zlib
-        ch_contrib::lz4)
-
-if(OS_DARWIN AND ARCH_AARCH64)
-    target_compile_definitions (_poco_foundation
-        PRIVATE
-            POCO_NO_STAT64
-    )
-endif()
diff --git a/contrib/poco-cmake/JSON/CMakeLists.txt b/contrib/poco-cmake/JSON/CMakeLists.txt
deleted file mode 100644
index e138dd046a8..00000000000
--- a/contrib/poco-cmake/JSON/CMakeLists.txt
+++ /dev/null
@@ -1,31 +0,0 @@
-# Poco::JSON (pdjson)
-
-set (SRCS_PDJSON
-    "${LIBRARY_DIR}/JSON/src/pdjson.c"
-)
-
-add_library (_poco_json_pdjson ${SRCS_PDJSON})
-add_library (Poco::JSON::Pdjson ALIAS _poco_json_pdjson)
-
-# Poco::JSON
-
-set (SRCS
-    "${LIBRARY_DIR}/JSON/src/Array.cpp"
-    "${LIBRARY_DIR}/JSON/src/Handler.cpp"
-    "${LIBRARY_DIR}/JSON/src/JSONException.cpp"
-    "${LIBRARY_DIR}/JSON/src/Object.cpp"
-    "${LIBRARY_DIR}/JSON/src/ParseHandler.cpp"
-    "${LIBRARY_DIR}/JSON/src/Parser.cpp"
-    "${LIBRARY_DIR}/JSON/src/ParserImpl.cpp"
-    "${LIBRARY_DIR}/JSON/src/PrintHandler.cpp"
-    "${LIBRARY_DIR}/JSON/src/Query.cpp"
-    "${LIBRARY_DIR}/JSON/src/Stringifier.cpp"
-    "${LIBRARY_DIR}/JSON/src/Template.cpp"
-    "${LIBRARY_DIR}/JSON/src/TemplateCache.cpp"
-)
-
-add_library (_poco_json ${SRCS})
-add_library (Poco::JSON ALIAS _poco_json)
-
-target_include_directories (_poco_json SYSTEM PUBLIC "${LIBRARY_DIR}/JSON/include")
-target_link_libraries (_poco_json PUBLIC Poco::Foundation Poco::JSON::Pdjson)
diff --git a/contrib/poco-cmake/MongoDB/CMakeLists.txt b/contrib/poco-cmake/MongoDB/CMakeLists.txt
deleted file mode 100644
index fec256b4dcd..00000000000
--- a/contrib/poco-cmake/MongoDB/CMakeLists.txt
+++ /dev/null
@@ -1,29 +0,0 @@
-set (SRCS
-    "${LIBRARY_DIR}/MongoDB/src/Array.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/Binary.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/Connection.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/Cursor.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/Database.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/DeleteRequest.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/Document.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/Element.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/GetMoreRequest.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/InsertRequest.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/JavaScriptCode.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/KillCursorsRequest.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/Message.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/MessageHeader.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/ObjectId.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/QueryRequest.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/RegularExpression.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/ReplicaSet.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/RequestMessage.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/ResponseMessage.cpp"
-    "${LIBRARY_DIR}/MongoDB/src/UpdateRequest.cpp"
-)
-
-add_library (_poco_mongodb ${SRCS})
-add_library (Poco::MongoDB ALIAS _poco_mongodb)
-
-target_include_directories (_poco_mongodb SYSTEM PUBLIC "${LIBRARY_DIR}/MongoDB/include")
-target_link_libraries (_poco_mongodb PUBLIC Poco::Net)
diff --git a/contrib/poco-cmake/Net/CMakeLists.txt b/contrib/poco-cmake/Net/CMakeLists.txt
deleted file mode 100644
index 30ff799ccfc..00000000000
--- a/contrib/poco-cmake/Net/CMakeLists.txt
+++ /dev/null
@@ -1,128 +0,0 @@
-set (SRCS
-    "${LIBRARY_DIR}/Net/src/AbstractHTTPRequestHandler.cpp"
-    "${LIBRARY_DIR}/Net/src/DatagramSocket.cpp"
-    "${LIBRARY_DIR}/Net/src/DatagramSocketImpl.cpp"
-    "${LIBRARY_DIR}/Net/src/DialogSocket.cpp"
-    "${LIBRARY_DIR}/Net/src/DNS.cpp"
-    "${LIBRARY_DIR}/Net/src/FilePartSource.cpp"
-    "${LIBRARY_DIR}/Net/src/FTPClientSession.cpp"
-    "${LIBRARY_DIR}/Net/src/FTPStreamFactory.cpp"
-    "${LIBRARY_DIR}/Net/src/HostEntry.cpp"
-    "${LIBRARY_DIR}/Net/src/HTMLForm.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPAuthenticationParams.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPBasicCredentials.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPBufferAllocator.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPChunkedStream.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPClientSession.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPCookie.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPCredentials.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPDigestCredentials.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPFixedLengthStream.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPHeaderStream.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPIOStream.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPMessage.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPRequest.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPRequestHandler.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPRequestHandlerFactory.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPResponse.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPServer.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPServerConnection.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPServerConnectionFactory.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPServerParams.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPServerRequest.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPServerRequestImpl.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPServerResponse.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPServerResponseImpl.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPServerSession.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPSession.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPSessionFactory.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPSessionInstantiator.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPStream.cpp"
-    "${LIBRARY_DIR}/Net/src/HTTPStreamFactory.cpp"
-    "${LIBRARY_DIR}/Net/src/ICMPClient.cpp"
-    "${LIBRARY_DIR}/Net/src/ICMPEventArgs.cpp"
-    "${LIBRARY_DIR}/Net/src/ICMPPacket.cpp"
-    "${LIBRARY_DIR}/Net/src/ICMPPacketImpl.cpp"
-    "${LIBRARY_DIR}/Net/src/ICMPSocket.cpp"
-    "${LIBRARY_DIR}/Net/src/ICMPSocketImpl.cpp"
-    "${LIBRARY_DIR}/Net/src/ICMPv4PacketImpl.cpp"
-    "${LIBRARY_DIR}/Net/src/IPAddress.cpp"
-    "${LIBRARY_DIR}/Net/src/IPAddressImpl.cpp"
-    "${LIBRARY_DIR}/Net/src/MailMessage.cpp"
-    "${LIBRARY_DIR}/Net/src/MailRecipient.cpp"
-    "${LIBRARY_DIR}/Net/src/MailStream.cpp"
-    "${LIBRARY_DIR}/Net/src/MediaType.cpp"
-    "${LIBRARY_DIR}/Net/src/MessageHeader.cpp"
-    "${LIBRARY_DIR}/Net/src/MulticastSocket.cpp"
-    "${LIBRARY_DIR}/Net/src/MultipartReader.cpp"
-    "${LIBRARY_DIR}/Net/src/MultipartWriter.cpp"
-    "${LIBRARY_DIR}/Net/src/NameValueCollection.cpp"
-    "${LIBRARY_DIR}/Net/src/Net.cpp"
-    "${LIBRARY_DIR}/Net/src/NetException.cpp"
-    "${LIBRARY_DIR}/Net/src/NetworkInterface.cpp"
-    "${LIBRARY_DIR}/Net/src/NTPClient.cpp"
-    "${LIBRARY_DIR}/Net/src/NTPEventArgs.cpp"
-    "${LIBRARY_DIR}/Net/src/NTPPacket.cpp"
-    "${LIBRARY_DIR}/Net/src/NullPartHandler.cpp"
-    "${LIBRARY_DIR}/Net/src/OAuth10Credentials.cpp"
-    "${LIBRARY_DIR}/Net/src/OAuth20Credentials.cpp"
-    "${LIBRARY_DIR}/Net/src/PartHandler.cpp"
-    "${LIBRARY_DIR}/Net/src/PartSource.cpp"
-    "${LIBRARY_DIR}/Net/src/PartStore.cpp"
-    "${LIBRARY_DIR}/Net/src/PollSet.cpp"
-    "${LIBRARY_DIR}/Net/src/POP3ClientSession.cpp"
-    "${LIBRARY_DIR}/Net/src/QuotedPrintableDecoder.cpp"
-    "${LIBRARY_DIR}/Net/src/QuotedPrintableEncoder.cpp"
-    "${LIBRARY_DIR}/Net/src/RawSocket.cpp"
-    "${LIBRARY_DIR}/Net/src/RawSocketImpl.cpp"
-    "${LIBRARY_DIR}/Net/src/RemoteSyslogChannel.cpp"
-    "${LIBRARY_DIR}/Net/src/RemoteSyslogListener.cpp"
-    "${LIBRARY_DIR}/Net/src/ServerSocket.cpp"
-    "${LIBRARY_DIR}/Net/src/ServerSocketImpl.cpp"
-    "${LIBRARY_DIR}/Net/src/SMTPChannel.cpp"
-    "${LIBRARY_DIR}/Net/src/SMTPClientSession.cpp"
-    "${LIBRARY_DIR}/Net/src/Socket.cpp"
-    "${LIBRARY_DIR}/Net/src/SocketAddress.cpp"
-    "${LIBRARY_DIR}/Net/src/SocketAddressImpl.cpp"
-    "${LIBRARY_DIR}/Net/src/SocketImpl.cpp"
-    "${LIBRARY_DIR}/Net/src/SocketNotification.cpp"
-    "${LIBRARY_DIR}/Net/src/SocketNotifier.cpp"
-    "${LIBRARY_DIR}/Net/src/SocketReactor.cpp"
-    "${LIBRARY_DIR}/Net/src/SocketStream.cpp"
-    "${LIBRARY_DIR}/Net/src/StreamSocket.cpp"
-    "${LIBRARY_DIR}/Net/src/StreamSocketImpl.cpp"
-    "${LIBRARY_DIR}/Net/src/StringPartSource.cpp"
-    "${LIBRARY_DIR}/Net/src/TCPServer.cpp"
-    "${LIBRARY_DIR}/Net/src/TCPServerConnection.cpp"
-    "${LIBRARY_DIR}/Net/src/TCPServerConnectionFactory.cpp"
-    "${LIBRARY_DIR}/Net/src/TCPServerDispatcher.cpp"
-    "${LIBRARY_DIR}/Net/src/TCPServerParams.cpp"
-    "${LIBRARY_DIR}/Net/src/WebSocket.cpp"
-    "${LIBRARY_DIR}/Net/src/WebSocketImpl.cpp"
-)
-
-add_library (_poco_net ${SRCS})
-add_library (Poco::Net ALIAS _poco_net)
-
-if (OS_LINUX)
-    target_compile_definitions (_poco_net PUBLIC POCO_HAVE_FD_EPOLL)
-elseif (OS_DARWIN OR OS_FREEBSD)
-    target_compile_definitions (_poco_net PUBLIC POCO_HAVE_FD_POLL)
-endif ()
-
-if (COMPILER_CLANG)
-    # clang-specific warnings
-    target_compile_options (_poco_net
-        PRIVATE
-            -Wno-atomic-implicit-seq-cst
-            -Wno-extra-semi-stmt
-            -Wno-extra-semi
-    )
-endif ()
-target_compile_options (_poco_net
-    PRIVATE
-        -Wno-deprecated
-        -Wno-extra-semi
-)
-target_include_directories (_poco_net SYSTEM PUBLIC "${LIBRARY_DIR}/Net/include")
-target_link_libraries (_poco_net PUBLIC Poco::Foundation)
diff --git a/contrib/poco-cmake/Net/SSL/CMakeLists.txt b/contrib/poco-cmake/Net/SSL/CMakeLists.txt
deleted file mode 100644
index de2bb624a8b..00000000000
--- a/contrib/poco-cmake/Net/SSL/CMakeLists.txt
+++ /dev/null
@@ -1,42 +0,0 @@
-if (ENABLE_SSL)
-    set (SRCS
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/AcceptCertificateHandler.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/CertificateHandlerFactory.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/CertificateHandlerFactoryMgr.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/ConsoleCertificateHandler.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/Context.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/HTTPSClientSession.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/HTTPSSessionInstantiator.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/HTTPSStreamFactory.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/InvalidCertificateHandler.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/KeyConsoleHandler.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/KeyFileHandler.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/PrivateKeyFactory.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/PrivateKeyFactoryMgr.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/PrivateKeyPassphraseHandler.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/RejectCertificateHandler.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/SecureServerSocket.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/SecureServerSocketImpl.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/SecureSMTPClientSession.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/SecureSocketImpl.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/SecureStreamSocket.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/SecureStreamSocketImpl.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/Session.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/SSLException.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/SSLManager.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/Utility.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/VerificationErrorArgs.cpp"
-        "${LIBRARY_DIR}/NetSSL_OpenSSL/src/X509Certificate.cpp"
-    )
-
-    add_library (_poco_net_ssl ${SRCS})
-    add_library (Poco::Net::SSL ALIAS _poco_net_ssl)
-
-    target_include_directories (_poco_net_ssl SYSTEM PUBLIC "${LIBRARY_DIR}/NetSSL_OpenSSL/include")
-    target_link_libraries (_poco_net_ssl PUBLIC Poco::Crypto Poco::Net Poco::Util)
-else ()
-    add_library (_poco_net_ssl INTERFACE)
-    add_library (Poco::Net::SSL ALIAS _poco_net_ssl)
-
-    message (STATUS "Not using Poco::Net::SSL")
-endif ()
diff --git a/contrib/poco-cmake/Redis/CMakeLists.txt b/contrib/poco-cmake/Redis/CMakeLists.txt
deleted file mode 100644
index 98e86a8592b..00000000000
--- a/contrib/poco-cmake/Redis/CMakeLists.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-set (SRCS
-    "${LIBRARY_DIR}/Redis/src/Array.cpp"
-    "${LIBRARY_DIR}/Redis/src/AsyncReader.cpp"
-    "${LIBRARY_DIR}/Redis/src/Client.cpp"
-    "${LIBRARY_DIR}/Redis/src/Command.cpp"
-    "${LIBRARY_DIR}/Redis/src/Error.cpp"
-    "${LIBRARY_DIR}/Redis/src/Exception.cpp"
-    "${LIBRARY_DIR}/Redis/src/RedisEventArgs.cpp"
-    "${LIBRARY_DIR}/Redis/src/RedisStream.cpp"
-    "${LIBRARY_DIR}/Redis/src/Type.cpp"
-)
-
-add_library (_poco_redis ${SRCS})
-add_library (Poco::Redis ALIAS _poco_redis)
-
-if (COMPILER_GCC)
-    target_compile_options (_poco_redis PRIVATE -Wno-deprecated-copy)
-endif ()
-target_compile_options (_poco_redis PRIVATE -Wno-shadow)
-target_include_directories (_poco_redis SYSTEM PUBLIC "${LIBRARY_DIR}/Redis/include")
-target_link_libraries (_poco_redis PUBLIC Poco::Net)
diff --git a/contrib/poco-cmake/Util/CMakeLists.txt b/contrib/poco-cmake/Util/CMakeLists.txt
deleted file mode 100644
index dc355e47658..00000000000
--- a/contrib/poco-cmake/Util/CMakeLists.txt
+++ /dev/null
@@ -1,35 +0,0 @@
-set (SRCS
-    "${LIBRARY_DIR}/Util/src/AbstractConfiguration.cpp"
-    "${LIBRARY_DIR}/Util/src/Application.cpp"
-    "${LIBRARY_DIR}/Util/src/ConfigurationMapper.cpp"
-    "${LIBRARY_DIR}/Util/src/ConfigurationView.cpp"
-    "${LIBRARY_DIR}/Util/src/FilesystemConfiguration.cpp"
-    "${LIBRARY_DIR}/Util/src/HelpFormatter.cpp"
-    "${LIBRARY_DIR}/Util/src/IniFileConfiguration.cpp"
-    "${LIBRARY_DIR}/Util/src/IntValidator.cpp"
-    "${LIBRARY_DIR}/Util/src/JSONConfiguration.cpp"
-    "${LIBRARY_DIR}/Util/src/LayeredConfiguration.cpp"
-    "${LIBRARY_DIR}/Util/src/LoggingConfigurator.cpp"
-    "${LIBRARY_DIR}/Util/src/LoggingSubsystem.cpp"
-    "${LIBRARY_DIR}/Util/src/MapConfiguration.cpp"
-    "${LIBRARY_DIR}/Util/src/Option.cpp"
-    "${LIBRARY_DIR}/Util/src/OptionCallback.cpp"
-    "${LIBRARY_DIR}/Util/src/OptionException.cpp"
-    "${LIBRARY_DIR}/Util/src/OptionProcessor.cpp"
-    "${LIBRARY_DIR}/Util/src/OptionSet.cpp"
-    "${LIBRARY_DIR}/Util/src/PropertyFileConfiguration.cpp"
-    "${LIBRARY_DIR}/Util/src/RegExpValidator.cpp"
-    "${LIBRARY_DIR}/Util/src/ServerApplication.cpp"
-    "${LIBRARY_DIR}/Util/src/Subsystem.cpp"
-    "${LIBRARY_DIR}/Util/src/SystemConfiguration.cpp"
-    "${LIBRARY_DIR}/Util/src/Timer.cpp"
-    "${LIBRARY_DIR}/Util/src/TimerTask.cpp"
-    "${LIBRARY_DIR}/Util/src/Validator.cpp"
-    "${LIBRARY_DIR}/Util/src/XMLConfiguration.cpp"
-)
-
-add_library (_poco_util ${SRCS})
-add_library (Poco::Util ALIAS _poco_util)
-
-target_include_directories (_poco_util SYSTEM PUBLIC "${LIBRARY_DIR}/Util/include")
-target_link_libraries (_poco_util PUBLIC Poco::JSON Poco::XML)
diff --git a/contrib/poco-cmake/XML/CMakeLists.txt b/contrib/poco-cmake/XML/CMakeLists.txt
deleted file mode 100644
index 97e655a0f04..00000000000
--- a/contrib/poco-cmake/XML/CMakeLists.txt
+++ /dev/null
@@ -1,100 +0,0 @@
-# Poco::XML (expat)
-
-set (SRCS_EXPAT
-    "${LIBRARY_DIR}/XML/src/xmlrole.c"
-    "${LIBRARY_DIR}/XML/src/xmltok_impl.c"
-    "${LIBRARY_DIR}/XML/src/xmltok_ns.c"
-    "${LIBRARY_DIR}/XML/src/xmltok.c"
-)
-
-add_library (_poco_xml_expat ${SRCS_EXPAT})
-add_library (Poco::XML::Expat ALIAS _poco_xml_expat)
-
-target_include_directories (_poco_xml_expat PUBLIC "${LIBRARY_DIR}/XML/include")
-target_include_directories (_poco_xml_expat PRIVATE "${LIBRARY_DIR}/Foundation/include")
-
-# Poco::XML
-
-set (SRCS
-    "${LIBRARY_DIR}/XML/src/AbstractContainerNode.cpp"
-    "${LIBRARY_DIR}/XML/src/AbstractNode.cpp"
-    "${LIBRARY_DIR}/XML/src/Attr.cpp"
-    "${LIBRARY_DIR}/XML/src/Attributes.cpp"
-    "${LIBRARY_DIR}/XML/src/AttributesImpl.cpp"
-    "${LIBRARY_DIR}/XML/src/AttrMap.cpp"
-    "${LIBRARY_DIR}/XML/src/CDATASection.cpp"
-    "${LIBRARY_DIR}/XML/src/CharacterData.cpp"
-    "${LIBRARY_DIR}/XML/src/ChildNodesList.cpp"
-    "${LIBRARY_DIR}/XML/src/Comment.cpp"
-    "${LIBRARY_DIR}/XML/src/ContentHandler.cpp"
-    "${LIBRARY_DIR}/XML/src/DeclHandler.cpp"
-    "${LIBRARY_DIR}/XML/src/DefaultHandler.cpp"
-    "${LIBRARY_DIR}/XML/src/Document.cpp"
-    "${LIBRARY_DIR}/XML/src/DocumentEvent.cpp"
-    "${LIBRARY_DIR}/XML/src/DocumentFragment.cpp"
-    "${LIBRARY_DIR}/XML/src/DocumentType.cpp"
-    "${LIBRARY_DIR}/XML/src/DOMBuilder.cpp"
-    "${LIBRARY_DIR}/XML/src/DOMException.cpp"
-    "${LIBRARY_DIR}/XML/src/DOMImplementation.cpp"
-    "${LIBRARY_DIR}/XML/src/DOMObject.cpp"
-    "${LIBRARY_DIR}/XML/src/DOMParser.cpp"
-    "${LIBRARY_DIR}/XML/src/DOMSerializer.cpp"
-    "${LIBRARY_DIR}/XML/src/DOMWriter.cpp"
-    "${LIBRARY_DIR}/XML/src/DTDHandler.cpp"
-    "${LIBRARY_DIR}/XML/src/DTDMap.cpp"
-    "${LIBRARY_DIR}/XML/src/Element.cpp"
-    "${LIBRARY_DIR}/XML/src/ElementsByTagNameList.cpp"
-    "${LIBRARY_DIR}/XML/src/Entity.cpp"
-    "${LIBRARY_DIR}/XML/src/EntityReference.cpp"
-    "${LIBRARY_DIR}/XML/src/EntityResolver.cpp"
-    "${LIBRARY_DIR}/XML/src/EntityResolverImpl.cpp"
-    "${LIBRARY_DIR}/XML/src/ErrorHandler.cpp"
-    "${LIBRARY_DIR}/XML/src/Event.cpp"
-    "${LIBRARY_DIR}/XML/src/EventDispatcher.cpp"
-    "${LIBRARY_DIR}/XML/src/EventException.cpp"
-    "${LIBRARY_DIR}/XML/src/EventListener.cpp"
-    "${LIBRARY_DIR}/XML/src/EventTarget.cpp"
-    "${LIBRARY_DIR}/XML/src/InputSource.cpp"
-    "${LIBRARY_DIR}/XML/src/LexicalHandler.cpp"
-    "${LIBRARY_DIR}/XML/src/Locator.cpp"
-    "${LIBRARY_DIR}/XML/src/LocatorImpl.cpp"
-    "${LIBRARY_DIR}/XML/src/MutationEvent.cpp"
-    "${LIBRARY_DIR}/XML/src/Name.cpp"
-    "${LIBRARY_DIR}/XML/src/NamedNodeMap.cpp"
-    "${LIBRARY_DIR}/XML/src/NamePool.cpp"
-    "${LIBRARY_DIR}/XML/src/NamespaceStrategy.cpp"
-    "${LIBRARY_DIR}/XML/src/NamespaceSupport.cpp"
-    "${LIBRARY_DIR}/XML/src/Node.cpp"
-    "${LIBRARY_DIR}/XML/src/NodeAppender.cpp"
-    "${LIBRARY_DIR}/XML/src/NodeFilter.cpp"
-    "${LIBRARY_DIR}/XML/src/NodeIterator.cpp"
-    "${LIBRARY_DIR}/XML/src/NodeList.cpp"
-    "${LIBRARY_DIR}/XML/src/Notation.cpp"
-    "${LIBRARY_DIR}/XML/src/ParserEngine.cpp"
-    "${LIBRARY_DIR}/XML/src/ProcessingInstruction.cpp"
-    "${LIBRARY_DIR}/XML/src/QName.cpp"
-    "${LIBRARY_DIR}/XML/src/SAXException.cpp"
-    "${LIBRARY_DIR}/XML/src/SAXParser.cpp"
-    "${LIBRARY_DIR}/XML/src/Text.cpp"
-    "${LIBRARY_DIR}/XML/src/TreeWalker.cpp"
-    "${LIBRARY_DIR}/XML/src/ValueTraits.cpp"
-    "${LIBRARY_DIR}/XML/src/WhitespaceFilter.cpp"
-    "${LIBRARY_DIR}/XML/src/XMLException.cpp"
-    "${LIBRARY_DIR}/XML/src/XMLFilter.cpp"
-    "${LIBRARY_DIR}/XML/src/XMLFilterImpl.cpp"
-    "${LIBRARY_DIR}/XML/src/XMLReader.cpp"
-    "${LIBRARY_DIR}/XML/src/XMLStreamParser.cpp"
-    "${LIBRARY_DIR}/XML/src/XMLStreamParserException.cpp"
-    "${LIBRARY_DIR}/XML/src/XMLString.cpp"
-    "${LIBRARY_DIR}/XML/src/XMLWriter.cpp"
-
-    # expat
-    "${LIBRARY_DIR}/XML/src/xmlparse.cpp"
-)
-
-add_library (_poco_xml ${SRCS})
-add_library (Poco::XML ALIAS _poco_xml)
-
-target_compile_options (_poco_xml PRIVATE -Wno-old-style-cast)
-target_include_directories (_poco_xml SYSTEM PUBLIC "${LIBRARY_DIR}/XML/include")
-target_link_libraries (_poco_xml PUBLIC Poco::Foundation Poco::XML::Expat)
diff --git a/docker/test/fasttest/run.sh b/docker/test/fasttest/run.sh
index 9c8b40df02b..086276bed55 100755
--- a/docker/test/fasttest/run.sh
+++ b/docker/test/fasttest/run.sh
@@ -110,7 +110,6 @@ function clone_submodules
             contrib/boost
             contrib/zlib-ng
             contrib/libxml2
-            contrib/poco
             contrib/libunwind
             contrib/fmtlib
             contrib/base64
diff --git a/src/Functions/CMakeLists.txt b/src/Functions/CMakeLists.txt
index 45543f57b37..ec4dc7a1292 100644
--- a/src/Functions/CMakeLists.txt
+++ b/src/Functions/CMakeLists.txt
@@ -54,10 +54,6 @@ if (TARGET ch_contrib::fastops)
     list (APPEND PRIVATE_LIBS ch_contrib::fastops)
 endif ()
 
-if (ENABLE_EXAMPLES)
-    add_subdirectory(examples)
-endif ()
-
 if (TARGET ch_contrib::llvm)
     list (APPEND PRIVATE_LIBS ch_contrib::llvm)
 endif ()
diff --git a/src/Functions/examples/CMakeLists.txt b/src/Functions/examples/CMakeLists.txt
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/utils/check-style/check-duplicate-includes.sh b/utils/check-style/check-duplicate-includes.sh
index 64aca4d180d..8043930cf5c 100755
--- a/utils/check-style/check-duplicate-includes.sh
+++ b/utils/check-style/check-duplicate-includes.sh
@@ -3,4 +3,4 @@
 ROOT_PATH=$(git rev-parse --show-toplevel)
 
 # Find duplicate include directives
-find $ROOT_PATH/{src,base,programs,utils} -name '*.h' -or -name '*.cpp' | while read file; do grep -P '^#include ' $file | sort | uniq -c | grep -v -P '^\s+1\s' && echo $file; done | sed '/^[[:space:]]*$/d'
+find $ROOT_PATH/{src,base/base,base/glibc-compatibility,base/harmful,base/pcg-random,base/readpassphrase,base/widechar_width,programs,utils} -name '*.h' -or -name '*.cpp' | while read file; do grep -P '^#include ' $file | sort | uniq -c | grep -v -P '^\s+1\s' && echo $file; done | sed '/^[[:space:]]*$/d' # all in base/ except poco
diff --git a/utils/check-style/check-style b/utils/check-style/check-style
index 5c36d85fc74..d68df26a23f 100755
--- a/utils/check-style/check-style
+++ b/utils/check-style/check-style
@@ -13,7 +13,7 @@
 #  and then to run formatter only for the specified files.
 
 ROOT_PATH=$(git rev-parse --show-toplevel)
-EXCLUDE_DIRS='build/|integration/|widechar_width/|glibc-compatibility/|memcpy/|consistent-hashing|benchmark|tests/'
+EXCLUDE_DIRS='build/|integration/|widechar_width/|glibc-compatibility/|poco/|memcpy/|consistent-hashing|benchmark|tests/'
 
 # From [1]:
 #     But since array_to_string_internal() in array.c still loops over array
diff --git a/utils/check-style/check-typos b/utils/check-style/check-typos
index 9194a9464a7..24f1f5d1b2d 100755
--- a/utils/check-style/check-typos
+++ b/utils/check-style/check-typos
@@ -9,6 +9,6 @@ codespell \
     --ignore-words "${ROOT_PATH}/utils/check-style/codespell-ignore-words.list" \
     --exclude-file "${ROOT_PATH}/utils/check-style/codespell-ignore-lines.list" \
     --quiet-level 2 \
-    "$ROOT_PATH"/{src,base,programs,utils} \
+    "$ROOT_PATH"/{src,base/base,base/glibc-compatibility,base/harmful,base/pcg-random,base/readpassphrase,base/widechar_width,programs,utils} \ # all subdirs of base/ except poco
     $@ | grep -P '.' \
     && echo -e "\nFound some typos in code.\nSee the files utils/check-style/codespell* if you want to add an exception."
diff --git a/utils/check-style/check-whitespaces b/utils/check-style/check-whitespaces
index 1aa3fd8cf6d..331190f7804 100755
--- a/utils/check-style/check-whitespaces
+++ b/utils/check-style/check-whitespaces
@@ -1,9 +1,9 @@
 #!/usr/bin/env bash
 
 ROOT_PATH=$(git rev-parse --show-toplevel)
-EXCLUDE_DIRS='build/|integration/|widechar_width/|glibc-compatibility/|memcpy/|consistent-hashing/|Parsers/New'
+EXCLUDE_DIRS='build/|integration/|widechar_width/|glibc-compatibility/|poco/|memcpy/|consistent-hashing/|Parsers/New'
 
 # Double whitespaces
 find $ROOT_PATH/{src,base,programs,utils} -name '*.h' -or -name '*.cpp' 2>/dev/null |
     grep -vP $EXCLUDE_DIRS |
-    while read i; do $ROOT_PATH/utils/check-style/double-whitespaces.pl < $i || echo -e "^ File $i contains double whitespaces\n"; done
\ No newline at end of file
+    while read i; do $ROOT_PATH/utils/check-style/double-whitespaces.pl < $i || echo -e "^ File $i contains double whitespaces\n"; done